[BACK]Return to pa_common.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_common.C between versions 1.243 and 1.253

version 1.243, 2009/04/22 04:35:48 version 1.253, 2009/10/02 01:19:24
Line 67  const String file_status_name(FILE_STATU Line 67  const String file_status_name(FILE_STATU
   
 // functions  // functions
   
   const char* capitalize(const char* s){
           char* result=pa_strdup(s);
           if(result){
                   bool upper=true;
                   for(char* c=result; *c; c++){
                           *c=upper ? (char)toupper((unsigned char)*c) : (char)tolower((unsigned char)*c);
                           upper=strchr("-_ ", *c) != 0;
                   }
           }
           return (const char*)result;
   }
   
 void fix_line_breaks(char *str, size_t& length) {  void fix_line_breaks(char *str, size_t& length) {
         //_asm int 3;          //_asm int 3;
         const char* const eob=str+length;          const char* const eob=str+length;
Line 150  static void file_read_action( Line 162  static void file_read_action(
                         lseek(f, info.offset, SEEK_SET);                          lseek(f, info.offset, SEEK_SET);
                 *info.data=info.buf                  *info.data=info.buf
                         ? info.buf                          ? info.buf
                         : new(PointerFreeGC) char[to_read_size+(as_text?1:0)];                           : (char *)pa_malloc_atomic(to_read_size+1);
                 *info.data_size=(size_t)read(f, *info.data, to_read_size);                   *info.data_size=(size_t)read(f, *info.data, to_read_size); 
   
                 if(ssize_t(*info.data_size)<0 || *info.data_size>to_read_size)                  if(ssize_t(*info.data_size)<0 || *info.data_size>to_read_size)
Line 160  static void file_read_action( Line 172  static void file_read_action(
                                         *info.data_size, to_read_size);                                           *info.data_size, to_read_size); 
         } else { // empty file          } else { // empty file
                 // for both, text and binary: for text we need that terminator, for binary we need nonzero pointer to be able to save such files                  // for both, text and binary: for text we need that terminator, for binary we need nonzero pointer to be able to save such files
                 *info.data=new(PointerFreeGC) char[1];                   *info.data=(char *)pa_malloc_atomic(1);
                 *(char*)(*info.data)=0;                  *(char*)(*info.data)=0;
                 *info.data_size=0;                  *info.data_size=0;
                 return;                  return;
Line 177  File_read_result file_read(Request_chars Line 189  File_read_result file_read(Request_chars
                 if(valid_options!=params->count())                  if(valid_options!=params->count())
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME,
                                 0,                                  0,
                                 "invalid option passed");                                  INVALID_OPTION_PASSED);
         }          }
   
         File_read_action_info info={&result.str, &result.length, buf, offset, count};           File_read_action_info info={&result.str, &result.length, buf, offset, count}; 
Line 260  bool file_read_action_under_lock(const S Line 272  bool file_read_action_under_lock(const S
                                 const char* action_name, File_read_action action, void *context,                                   const char* action_name, File_read_action action, void *context, 
                                 bool as_text,                                   bool as_text, 
                                 bool fail_on_read_problem) {                                  bool fail_on_read_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         int f;          int f;
   
         // first open, next stat:          // first open, next stat:
Line 315  void create_dir_for_file(const String& f Line 327  void create_dir_for_file(const String& f
         size_t pos_after=1;          size_t pos_after=1;
         size_t pos_before;          size_t pos_before;
         while((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND) {          while((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND) {
                 mkdir(file_spec.mid(0, pos_before).cstr(String::L_FILE_SPEC), 0775);                   mkdir(file_spec.mid(0, pos_before).taint_cstr(String::L_FILE_SPEC), 0775); 
                 pos_after=pos_before+1;                  pos_after=pos_before+1;
         }          }
 }  }
Line 329  bool file_write_action_under_lock( Line 341  bool file_write_action_under_lock(
                                 bool do_append,                                   bool do_append, 
                                 bool do_block,                                   bool do_block, 
                                 bool fail_on_lock_problem) {                                  bool fail_on_lock_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         int f;          int f;
         if(access(fname, W_OK)!=0) // no          if(access(fname, W_OK)!=0) // no
                 create_dir_for_file(file_spec);                   create_dir_for_file(file_spec); 
Line 376  bool file_write_action_under_lock( Line 388  bool file_write_action_under_lock(
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_write_action_info {  struct File_write_action_info {
         const char* str; size_t length;          const char* str;
           size_t length;
 };   }; 
 #endif  #endif
 static void file_write_action(int f, void *context) {  static void file_write_action(int f, void *context) {
Line 390  static void file_write_action(int f, voi Line 403  static void file_write_action(int f, voi
         }          }
 }  }
 void file_write(  void file_write(
                                 const String& file_spec,                                   Request_charsets& charsets,
                                 const char* data, size_t size,                                   const String& file_spec,
                                   const char* data,
                                   size_t size, 
                                 bool as_text,                                   bool as_text, 
                                 bool do_append) {                                  bool do_append,
                                   Charset* asked_charset) {
   
           if(as_text && asked_charset){
                   String::C body=String::C(data, size);
                   body=Charset::transcode(body, charsets.source(), *asked_charset);
                   data=body.str;
                   size=body.length;
           };
   
         File_write_action_info info={data, size};           File_write_action_info info={data, size}; 
   
         file_write_action_under_lock(          file_write_action_under_lock(
Line 411  static void rmdir(const String& file_spe Line 435  static void rmdir(const String& file_spe
         if((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND)          if((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND)
                 rmdir(file_spec, pos_before+1);                   rmdir(file_spec, pos_before+1); 
                   
         rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::L_FILE_SPEC));           rmdir(file_spec.mid(0, pos_after-1/* / */).taint_cstr(String::L_FILE_SPEC)); 
 }  }
   
 bool file_delete(const String& file_spec, bool fail_on_problem) {  bool file_delete(const String& file_spec, bool fail_on_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         if(unlink(fname)!=0)          if(unlink(fname)!=0)
                 if(fail_on_problem)                  if(fail_on_problem)
                         throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                           throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0, 
Line 430  bool file_delete(const String& file_spec Line 454  bool file_delete(const String& file_spec
 }  }
   
 void file_move(const String& old_spec, const String& new_spec) {  void file_move(const String& old_spec, const String& new_spec) {
         const char* old_spec_cstr=old_spec.cstr(String::L_FILE_SPEC);           const char* old_spec_cstr=old_spec.taint_cstr(String::L_FILE_SPEC); 
         const char* new_spec_cstr=new_spec.cstr(String::L_FILE_SPEC);           const char* new_spec_cstr=new_spec.taint_cstr(String::L_FILE_SPEC); 
                   
         create_dir_for_file(new_spec);           create_dir_for_file(new_spec); 
   
Line 454  bool entry_exists(const char* fname, str Line 478  bool entry_exists(const char* fname, str
 }  }
   
 bool entry_exists(const String& file_spec) {  bool entry_exists(const String& file_spec) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         return entry_exists(fname, 0);           return entry_exists(fname, 0); 
 }  }
   
 static bool entry_readable(const String& file_spec, bool need_dir) {  static bool entry_readable(const String& file_spec, bool need_dir) {
         char* fname=file_spec.cstrm(String::L_FILE_SPEC);           char* fname=file_spec.taint_cstrm(String::L_FILE_SPEC); 
         if(need_dir) {          if(need_dir) {
                 size_t size=strlen(fname);                   size_t size=strlen(fname); 
                 while(size) {                  while(size) {
Line 494  const String* file_exist(const String& p Line 518  const String* file_exist(const String& p
 }  }
   
 bool file_executable(const String& file_spec) {  bool file_executable(const String& file_spec) {
         return access(file_spec.cstr(String::L_FILE_SPEC), X_OK)==0;          return access(file_spec.taint_cstr(String::L_FILE_SPEC), X_OK)==0;
 }  }
   
 bool file_stat(const String& file_spec,   bool file_stat(const String& file_spec, 
Line 503  bool file_stat(const String& file_spec, Line 527  bool file_stat(const String& file_spec,
                         time_t& rmtime,                          time_t& rmtime,
                         time_t& rctime,                          time_t& rctime,
                         bool fail_on_read_problem) {                          bool fail_on_read_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         struct stat finfo;          struct stat finfo;
         if(stat(fname, &finfo)!=0)          if(stat(fname, &finfo)!=0)
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
Line 796  size_t strpos(const char *str, const cha Line 820  size_t strpos(const char *str, const cha
 // content-type: xxx; charset="WE-NEED-THIS";  // content-type: xxx; charset="WE-NEED-THIS";
 Charset* detect_charset(const char* content_type){  Charset* detect_charset(const char* content_type){
         if(content_type){          if(content_type){
                 size_t len=strlen(content_type);                  char* CONTENT_TYPE=pa_strdup(content_type);
                 char* CONTENT_TYPE=new(PointerFreeGC) char[len+1];  
                 memcpy(CONTENT_TYPE, content_type, len);  
                 for(char *p=CONTENT_TYPE; *p; p++)                  for(char *p=CONTENT_TYPE; *p; p++)
                         *p=(char)toupper((unsigned char)*p);                          *p=(char)toupper((unsigned char)*p);
   
Line 813  Charset* detect_charset(const char* cont Line 836  Charset* detect_charset(const char* cont
                         if(!end)                          if(!end)
                                 end=(char*)strchr(begin, ';');                                  end=(char*)strchr(begin, ';');
   
                         size_t len;                          if(end)
                         if(end){  
                                 *end=0; // terminator                                  *end=0; // terminator
                                 len=end-begin;  
                         } else {  
                                 len=strlen(begin);  
                         }  
   
                         String::Body NAME=String::Body(begin, len);  
                         return &charsets.get(NAME);  
                 }  
         }  
         return 0;  
 }  
   
 Charset* detect_charset(Charset& source_charset, const String& content_type){                          return *begin?&charsets.get(begin):0;
         const String& CONTENT_TYPE=content_type.change_case(source_charset, String::CC_UPPER);  
         size_t begin=CONTENT_TYPE.pos("CHARSET=");  
         if(begin!=STRING_NOT_FOUND) {  
                 begin+=8; // skip "CHARSET="  
                 size_t end=STRING_NOT_FOUND;  
   
                 if(CONTENT_TYPE.pos('"', begin)==begin){  
                         begin++;  
                         end=CONTENT_TYPE.pos('"', begin);  
                 } else if(CONTENT_TYPE.pos('\'', begin)==begin){  
                         begin++;  
                         end=CONTENT_TYPE.pos('\'', begin);  
                 }                  }
   
                 if(end==STRING_NOT_FOUND)  
                         end=CONTENT_TYPE.pos(';', begin);  
   
                 if(end==STRING_NOT_FOUND)  
                         end=CONTENT_TYPE.length();  
   
                 const String::Body NAME=CONTENT_TYPE.mid(begin, end);  
                 return &charsets.get(NAME);  
         }          }
         return 0;          return 0;
 }  }
Line 1003  static char *base64_alphabet = Line 993  static char *base64_alphabet =
  *   *
  * Returns the number of bytes encoded.   * Returns the number of bytes encoded.
  **/   **/
   
   #define BASE64_GROUPS_IN_LINE 19
   
 static size_t  static size_t
 g_mime_utils_base64_encode_step (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)  g_mime_utils_base64_encode_step (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)
 {  {
Line 1040  g_mime_utils_base64_encode_step (const u Line 1033  g_mime_utils_base64_encode_step (const u
                         *outptr++ = base64_alphabet [((c2 & 0x0f) << 2) | (c3 >> 6)];                          *outptr++ = base64_alphabet [((c2 & 0x0f) << 2) | (c3 >> 6)];
                         *outptr++ = base64_alphabet [c3 & 0x3f];                          *outptr++ = base64_alphabet [c3 & 0x3f];
                         /* this is a bit ugly ... */                          /* this is a bit ugly ... */
                         if ((++already) >= 19) {                          if ((++already) >= BASE64_GROUPS_IN_LINE) {
                                 *outptr++ = '\n';                                  *outptr++ = '\n';
                                 already = 0;                                  already = 0;
                         }                          }
Line 1206  g_mime_utils_base64_decode_step (const u Line 1199  g_mime_utils_base64_decode_step (const u
   
   
 char* pa_base64_encode(const char *in, size_t in_size){  char* pa_base64_encode(const char *in, size_t in_size){
         /* wont go to more than 2x size (overly conservative) */          size_t new_size = ((in_size / 3 + 1) * 4);
         char* result=new(PointerFreeGC) char[in_size * 2 + 6];          new_size += new_size / (BASE64_GROUPS_IN_LINE * 4)/*new lines*/ + 1/*zero terminator*/;
           char* result = new(PointerFreeGC) char[new_size];
         int state=0;          int state=0;
         int save=0;          int save=0;
 #ifndef NDEBUG  #ifndef NDEBUG
         size_t filled=          size_t filled=
 #endif  #endif
                 g_mime_utils_base64_encode_close ((const unsigned char*)in, in_size,                   g_mime_utils_base64_encode_close ((const unsigned char*)in, in_size, (unsigned char*)result, &state, &save);
                 (unsigned char*)result, &state, &save);  
         assert(filled <= in_size * 2 + 6);          //throw Exception(PARSER_RUNTIME, 0, "%d %d %d", in_size, new_size, filled);
           assert(filled <= new_size);
   
         return result;          return result;
 }  }
Removed from v.1.243  
changed lines
  Added in v.1.253

E-mail: