[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.233 and 1.259

version 1.233, 2008/06/07 11:01:09 version 1.259, 2010/05/25 09:30:30
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
  * BASE64 part   * BASE64 part
Line 35  static const char * const IDENT_COMMON_C Line 35  static const char * const IDENT_COMMON_C
 #include "pa_charsets.h"  #include "pa_charsets.h"
 #include "pa_http.h"  #include "pa_http.h"
 #include "pa_request_charsets.h"  #include "pa_request_charsets.h"
   #include "pcre.h"
   #include "pa_request.h"
   
 // some maybe-undefined constants  // some maybe-undefined constants
   
Line 65  const String file_status_name(FILE_STATU Line 67  const String file_status_name(FILE_STATU
   
 // functions  // functions
   
   bool capitalized(const char* s){
           bool upper=true;
           for(const char* c=s; *c; c++){
                   if(*c != (upper ? toupper((unsigned char)*c) : tolower((unsigned char)*c)))
                           return false;
                   upper=strchr("-_ ", *c) != 0;
           }
           return true;
   }
   
   const char* capitalize(const char* s){
           if(!s || capitalized(s))
                   return 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 94  void fix_line_breaks(char *str, size_t& Line 121  void fix_line_breaks(char *str, size_t&
 char* file_read_text(Request_charsets& charsets,   char* file_read_text(Request_charsets& charsets, 
                         const String& file_spec,                           const String& file_spec, 
                         bool fail_on_read_problem,                          bool fail_on_read_problem,
                         HashStringValue* params/*, HashStringValue* * out_fields*/) {                          HashStringValue* params,
                           bool transcode_result) {
         File_read_result file=          File_read_result file=
                 file_read(charsets, file_spec, true, params, fail_on_read_problem);                  file_read(charsets, file_spec, true, params, fail_on_read_problem, 0, 0, 0, transcode_result);
           return file.success?file.str:0;
   }
   
   char* file_load_text(Request& r, 
                           const String& file_spec, 
                           bool fail_on_read_problem,
                           HashStringValue* params,
                           bool transcode_result) {
           File_read_result file=
                   file_load(r, file_spec, true, params, fail_on_read_problem, 0, 0, 0, transcode_result);
         return file.success?file.str:0;          return file.success?file.str:0;
 }  }
   
 /// these options were handled but not checked elsewhere, now check them  /// these options were handled but not checked elsewhere, now check them
 int pa_get_valid_file_options_count(HashStringValue& options)  int pa_get_valid_file_options_count(HashStringValue& options) {
 {  
         int result=0;          int result=0;
         if(options.get(PA_SQL_LIMIT_NAME))          if(options.get(PA_SQL_LIMIT_NAME))
                 result++;                  result++;
Line 138  static void file_read_action( Line 175  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)
                         throw Exception(0,                           throw Exception("file.read", 
                                 &file_spec,                                   &file_spec, 
                                 "read failed: actually read %u bytes count not in [0..%u] valid range",                                   "read failed: actually read %u bytes count not in [0..%u] valid range", 
                                         *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;
         }          }
 }  }
   
 File_read_result file_read(Request_charsets& charsets, const String& file_spec,   File_read_result file_read(Request_charsets& charsets, const String& file_spec, 
                         bool as_text, HashStringValue *params,                          bool as_text, HashStringValue *params,
                         bool fail_on_read_problem,                          bool fail_on_read_problem,
                         char* buf, size_t offset, size_t count) {                          char* buf, size_t offset, size_t count, bool transcode_text_result) {
           File_read_result result={false, 0, 0, 0};
           if(params){
                   int valid_options=pa_get_valid_file_options_count(*params);
                   if(valid_options!=params->count())
                           throw Exception(PARSER_RUNTIME,
                                   0,
                                   INVALID_OPTION_PASSED);
           }
   
           File_read_action_info info={&result.str, &result.length, buf, offset, count}; 
   
           result.success=file_read_action_under_lock(file_spec, 
                   "read", file_read_action, &info, 
                   as_text, fail_on_read_problem); 
   
           if(as_text){
                   if(result.success){
                           if(result.length>=3 && strncmp(result.str, "\xEF\xBB\xBF", 3)==0){
                                   // skip UTF-8 signature (BOM code)
                                   result.str+=3;
                                   result.length-=3;
                           }
                           
                           if(result.length && transcode_text_result && params){ // must be checked because transcode returns CONST string in case length==0, which contradicts hacking few lines below
                                   if(Value* vcharset_name=params->get(PA_CHARSET_NAME)){
                                           Charset asked_charset=::charsets.get(vcharset_name->as_string().
                                                   change_case(charsets.source(), String::CC_UPPER));
   
                                           String::C body=String::C(result.str, result.length);
                                           body=Charset::transcode(body, asked_charset, charsets.source());
   
                                           result.str=const_cast<char*>(body.str); // hacking a little
                                           result.length=body.length;
                                   }
                           }
                   }
                   if(result.length)
                           fix_line_breaks(result.str, result.length);
           }
   
           return result;
   }
   
   File_read_result file_load(Request& r, const String& file_spec, 
                           bool as_text, HashStringValue *params,
                           bool fail_on_read_problem,
                           char* buf, size_t offset, size_t count, bool transcode_text_result) {
   
         File_read_result result={false, 0, 0, 0};          File_read_result result={false, 0, 0, 0};
         if(file_spec.starts_with("http://")) {          if(file_spec.starts_with("http://")) {
                 if(offset || count)                  if(offset || count)
Line 166  File_read_result file_read(Request_chars Line 252  File_read_result file_read(Request_chars
                                 "offset and load options are not supported for HTTP:// file load");                                  "offset and load options are not supported for HTTP:// file load");
   
                 // fail on read problem                  // fail on read problem
                 File_read_http_result http=pa_internal_file_read_http(charsets, file_spec, as_text, params);                  File_read_http_result http=pa_internal_file_read_http(r, file_spec, as_text, params, transcode_text_result);
                 result.success=true;                  result.success=true;
                 result.str=http.str;                  result.str=http.str;
                 result.length=http.length;                  result.length=http.length;
                 result.headers=http.headers;                   result.headers=http.headers; 
         } else {          } else
                 if(params) {                  result=
                         int valid_options=pa_get_valid_file_options_count(*params);                          file_read(r.charsets, file_spec, as_text, params, fail_on_read_problem, buf, offset, count, transcode_text_result);
                         if(valid_options!=params->count())  
                                 throw Exception(PARSER_RUNTIME,  
                                         0,  
                                         "invalid option passed");  
                 }  
   
                 File_read_action_info info={&result.str, &result.length,  
                         buf, offset, count};   
                 result.success=file_read_action_under_lock(file_spec,   
                         "read", file_read_action, &info,   
                         as_text, fail_on_read_problem);   
   
                 if(result.length && as_text && params) {  
                         if( Value* vcharset_name=params->get(PA_CHARSET_NAME) ) {  
                                 Charset asked_charset=::charsets.get(vcharset_name->as_string().  
                                         change_case(charsets.source(), String::CC_UPPER));  
   
                                 String::C body=String::C(result.str, result.length);  
                                 body=Charset::transcode(body, asked_charset, charsets.source());  
   
                                 result.str=const_cast<char *>(body.str); // hacking a little  
                                 result.length=body.length;  
                         }   
                 }  
         }  
   
         if(result.success && as_text) {  
                 // UTF-8 signature: EF BB BF  
                 if(result.length>=3) {  
                         char *in=(char *)result.str;  
                         if(strncmp(in, "\xEF\xBB\xBF", 3)==0) {  
                                 result.str=in+3; result.length-=3;// skip prefix  
                         }  
                 }  
   
                 fix_line_breaks((char *)(result.str), result.length);   
         }  
   
         return result;          return result;
 }  }
   
   
 #ifdef PA_SAFE_MODE   #ifdef PA_SAFE_MODE 
 void check_safe_mode(struct stat finfo, const String& file_spec, const char* fname) {   void check_safe_mode(struct stat finfo, const String& file_spec, const char* fname) {
         if(finfo.st_uid/*foreign?*/!=geteuid()           if(finfo.st_uid/*foreign?*/!=geteuid() 
                 && finfo.st_gid/*foreign?*/!=getegid())                   && finfo.st_gid/*foreign?*/!=getegid()) 
                 throw Exception(PARSER_RUNTIME,                    throw Exception(PARSER_RUNTIME,  
Line 228  void check_safe_mode(struct stat finfo, Line 278  void check_safe_mode(struct stat finfo,
                         "fuid(%d)!=euid(%d) or fgid(%d)!=egid(%d)",                            "fuid(%d)!=euid(%d) or fgid(%d)!=egid(%d)",  
                                 fname,                                   fname, 
                                 finfo.st_uid, geteuid(),                                   finfo.st_uid, geteuid(), 
                                 finfo.st_gid, getegid());                                   finfo.st_gid, getegid());
 }   }
 #endif   #else
   void check_safe_mode(struct stat, const String&, const char*) {
   }
   #endif
   
   
   
 bool file_read_action_under_lock(const String& file_spec,   bool file_read_action_under_lock(const String& file_spec, 
                                 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 257  bool file_read_action_under_lock(const S Line 312  bool file_read_action_under_lock(const S
                                                         strerror(errno), errno, fname);                                                          strerror(errno), errno, fname);
   
                         struct stat finfo;                          struct stat finfo;
                         if(stat(fname, &finfo)!=0)                          if(fstat(f, &finfo)!=0)
                                 throw Exception("file.missing", // hardly possible: we just opened it OK                                  throw Exception("file.missing", // hardly possible: we just opened it OK
                                         &file_spec,                                           &file_spec, 
                                         "stat failed: %s (%d), actual filename '%s'",                                           "stat failed: %s (%d), actual filename '%s'", 
                                                 strerror(errno), errno, fname);                                                  strerror(errno), errno, fname);
   
 #ifdef PA_SAFE_MODE  
                         check_safe_mode(finfo, file_spec, fname);                          check_safe_mode(finfo, file_spec, fname);
 #endif  
   
                         action(finfo, f, file_spec, fname, as_text, context);                           action(finfo, f, file_spec, fname, as_text, context); 
                 } catch(...) {                  } catch(...) {
Line 279  bool file_read_action_under_lock(const S Line 332  bool file_read_action_under_lock(const S
                 return true;                  return true;
         } else {          } else {
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
                         throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                           throw Exception(errno==EACCES?"file.access"
                                                           :(errno==ENOENT || errno==ENOTDIR || errno==ENODEV)?"file.missing":0, 
                                 &file_spec,                                   &file_spec, 
                                 "%s failed: %s (%d), actual filename '%s'",                                   "%s failed: %s (%d), actual filename '%s'", 
                                         action_name, strerror(errno), errno, fname);                                          action_name, strerror(errno), errno, fname);
Line 291  void create_dir_for_file(const String& f Line 345  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 305  bool file_write_action_under_lock( Line 359  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 326  bool file_write_action_under_lock( Line 380  bool file_write_action_under_lock(
                 }                  }
   
                 try {                  try {
                         action(f, context);   #if (defined(HAVE_FCHMOD) && defined(PA_SAFE_MODE))
                           struct stat finfo;
                           if(fstat(f, &finfo)==0 && finfo.st_mode & 0111)
                                   fchmod(f, finfo.st_mode & 0666/*clear executable bits*/); // backward: ignore errors if any
   #endif
                           action(f, context);
                 } catch(...) {                  } catch(...) {
 #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
                         if(!do_append)                          if(!do_append)
Line 352  bool file_write_action_under_lock( Line 411  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 360  static void file_write_action(int f, voi Line 420  static void file_write_action(int f, voi
         if(info.length) {          if(info.length) {
                 int written=write(f, info.str, info.length);                   int written=write(f, info.str, info.length); 
                 if(written<0)                  if(written<0)
                         throw Exception(0,                           throw Exception("file.access", 
                                 0,                                   0, 
                                 "write failed: %s (%d)",  strerror(errno), errno);                                   "write failed: %s (%d)",  strerror(errno), errno); 
         }          }
 }  }
 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 387  static void rmdir(const String& file_spe Line 458  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 403  bool file_delete(const String& file_spec Line 475  bool file_delete(const String& file_spec
         rmdir(file_spec, 1);           rmdir(file_spec, 1); 
         return true;          return true;
 }  }
   
 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 428  bool entry_exists(const char* fname, str Line 501  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 451  static bool entry_readable(const String& Line 524  static bool entry_readable(const String&
         }          }
         return false;          return false;
 }  }
   
 bool file_exist(const String& file_spec) {  bool file_exist(const String& file_spec) {
         return entry_readable(file_spec, false);           return entry_readable(file_spec, false); 
 }  }
   
 bool dir_exists(const String& file_spec) {  bool dir_exists(const String& file_spec) {
         return entry_readable(file_spec, true);           return entry_readable(file_spec, true); 
 }  }
   
 const String* file_exist(const String& path, const String& name) {  const String* file_exist(const String& path, const String& name) {
         String& result=*new String(path);          String& result=*new String(path);
         result << "/";           result << "/"; 
         result << name;          result << name;
         return file_exist(result)?&result:0;          return file_exist(result)?&result:0;
 }  }
   
 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 473  bool file_stat(const String& file_spec, Line 550  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 598  FormatType format_type(char* fmt){ Line 675  FormatType format_type(char* fmt){
   
 const char* format(double value, char* fmt) {  const char* format(double value, char* fmt) {
         char local_buf[MAX_NUMBER];          char local_buf[MAX_NUMBER];
         size_t size;          int size=-1;
   
         if(fmt && strlen(fmt)){          if(fmt && strlen(fmt)){
                 switch(format_type(fmt)){                  switch(format_type(fmt)){
Line 625  const char* format(double value, char* f Line 702  const char* format(double value, char* f
                         "Error occure white executing snprintf with format string '%s'.", fmt);                          "Error occure white executing snprintf with format string '%s'.", fmt);
         }          }
   
         return pa_strdup(local_buf, size);          return pa_strdup(local_buf, (size_t)size);
 }  }
   
 size_t stdout_write(const void *buf, size_t size) {  size_t stdout_write(const void *buf, size_t size) {
Line 651  enum EscapeState { Line 728  enum EscapeState {
         EscapeSecond,          EscapeSecond,
         EscapeUnicode          EscapeUnicode
 };  };
 /*  
 char* unescape_chars(const char* cp, int len) {  
         char* s=new(PointerFreeGC) char[len + 1];   
         EscapeState escapeState=EscapeRest;  
         uint escapedValue=0;  
         int srcPos=0;  
         int dstPos=0;  
         while(srcPos < len) {  
                 uchar ch=(uchar)cp[srcPos];   
                 switch(escapeState) {  
                         case EscapeRest:  
                                 if(ch=='%') {  
                                         escapeState=EscapeFirst;  
                                 } else if(ch=='+'){  
                                         s[dstPos++]=' ';   
                                 } else {  
                                         s[dstPos++]=ch;   
                                 }  
                                 break;  
                         case EscapeFirst:  
                                 escapedValue=hex_value[ch] << 4;  
                                 escapeState=EscapeSecond;  
                                 break;  
                         case EscapeSecond:  
                                 escapedValue +=hex_value[ch];   
                                 s[dstPos++]=(char)escapedValue;  
                                 escapeState=EscapeRest;  
                                 break;  
                 }  
                 srcPos++;   
         }  
         s[dstPos]=0;  
         return s;  
 }  
 */  
   
 char* unescape_chars(const char* cp, int len, Charset* charset){  // @todo prescan for reduce required size (unescaped sting in 1 byte charset requires less memory usually)
         char* s=new(PointerFreeGC) char[len + 1]; // enough (%uXXXX==6 bytes, max utf-8 char length==6 bytes)  char* unescape_chars(const char* cp, int len, Charset* charset, bool js){
           char* s=new(PointerFreeGC) char[len+1]; // must be enough (%uXXXX==6 bytes, max utf-8 char length==6 bytes)
         char* dst=s;          char* dst=s;
         EscapeState escapeState=EscapeRest;          EscapeState escapeState=EscapeRest;
         uint escapedValue=0;          uint escapedValue=0;
         int srcPos=0;          int srcPos=0;
         short int jsCnt=0;          short int jsCnt=0;
         while(srcPos < len) {          while(srcPos<len){
                 uchar c=(uchar)cp[srcPos];                   uchar c=(uchar)cp[srcPos]; 
                 if(c=='%'){                  if(c=='%' || (c=='\\' && js)){
                         escapeState=EscapeFirst;                          escapeState=EscapeFirst;
                 } else {                  } else {
                         switch(escapeState) {                          switch(escapeState) {
                                 case EscapeRest:                                  case EscapeRest:
                                         if(c=='+'){                                          if(!js && c=='+'){
                                                 *dst++=' ';                                                  *dst++=' ';
                                         } else {                                          } else {
                                                 *dst++=c;                                                  *dst++=c;
Line 800  size_t strpos(const char *str, const cha Line 843  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 817  Charset* detect_charset(const char* cont Line 859  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 *begin?&charsets.get(begin):0;
                         return &charsets.get(NAME);  
                 }                  }
         }          }
         return 0;          return 0;
 }  }
   
 Charset* detect_charset(Charset& source_charset, const String& content_type){  
         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;  
 }  
   
   
 static bool isLeap(int year) {  static bool isLeap(int year) {
         return !(          return !(
Line 961  int __vsnprintf(char* b, size_t s, const Line 970  int __vsnprintf(char* b, size_t s, const
   
 int __snprintf(char* b, size_t s, const char* f, ...) {  int __snprintf(char* b, size_t s, const char* f, ...) {
         va_list l;          va_list l;
     va_start(l, f);           va_start(l, f); 
     int r=__vsnprintf(b, s, f, l);           int r=__vsnprintf(b, s, f, l); 
     va_end(l);           va_end(l); 
         return r;          return r;
 }  }
   
Line 1007  static char *base64_alphabet = Line 1016  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 1044  g_mime_utils_base64_encode_step (const u Line 1056  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 1209  g_mime_utils_base64_decode_step (const u Line 1221  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){
 {          size_t new_size = ((in_size / 3 + 1) * 4);
         /* wont go to more than 2x size (overly conservative) */          new_size += new_size / (BASE64_GROUPS_IN_LINE * 4)/*new lines*/ + 1/*zero terminator*/;
         char* result=new(PointerFreeGC) char[in_size * 2 + 6];          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;
 }  }
   
   
 char* pa_base64_encode(const String& file_spec)  char* pa_base64_encode(const String& file_spec){
 {  
         unsigned char* base64=0;          unsigned char* base64=0;
         File_base64_action_info info={&base64};           File_base64_action_info info={&base64}; 
   
Line 1263  static void file_base64_file_action( Line 1275  static void file_base64_file_action(
         }          }
 }  }
   
 void pa_base64_decode(const char *in, size_t in_size, char*& result, size_t& result_size)  void pa_base64_decode(const char *in, size_t in_size, char*& result, size_t& result_size) {
 {  
         /* wont go to more than had (overly conservative) */          /* wont go to more than had (overly conservative) */
         result=new(PointerFreeGC) char[in_size+1/*terminator*/];          result=new(PointerFreeGC) char[in_size+1/*terminator*/];
         int state=0;          int state=0;
Line 1280  void pa_base64_decode(const char *in, si Line 1291  void pa_base64_decode(const char *in, si
 int file_block_read(const int f, unsigned char* buffer, const size_t size){  int file_block_read(const int f, unsigned char* buffer, const size_t size){
         int nCount = read(f, buffer, size);          int nCount = read(f, buffer, size);
         if (nCount < 0)          if (nCount < 0)
                 throw Exception(0,                   throw Exception("file.read", 
                         0,                           0, 
                         "read failed: %s (%d)",  strerror(errno), errno);                           "read failed: %s (%d)",  strerror(errno), errno); 
         return nCount;          return nCount;
 }  }
   
 const unsigned long pa_crc32(const char *in, size_t in_size)  const unsigned long pa_crc32(const char *in, size_t in_size){
 {  
         unsigned long crc32=0xFFFFFFFF;          unsigned long crc32=0xFFFFFFFF;
   
                 InitCrc32Table();          InitCrc32Table();
                 for(size_t i = 0; i < in_size; i++) CalcCrc32(in[i], crc32);          for(size_t i = 0; i<in_size; i++)
                   CalcCrc32(in[i], crc32);
   
         return ~crc32;           return ~crc32; 
 }  }
   
 const unsigned long pa_crc32(const String& file_spec)  const unsigned long pa_crc32(const String& file_spec){
 {  
         unsigned long crc32=0xFFFFFFFF;          unsigned long crc32=0xFFFFFFFF;
         file_read_action_under_lock(file_spec, "crc32", file_crc32_file_action, &crc32);          file_read_action_under_lock(file_spec, "crc32", file_crc32_file_action, &crc32);
         return ~crc32;           return ~crc32; 
Line 1307  static void file_crc32_file_action( Line 1317  static void file_crc32_file_action(
                                 struct stat& finfo,                                   struct stat& finfo, 
                                 int f,                                   int f, 
                                 const String&, const char* /*fname*/, bool,                                   const String&, const char* /*fname*/, bool, 
                                 void *context)                                  void *context) {
 {  
         unsigned long& crc32=*static_cast<unsigned long *>(context);          unsigned long& crc32=*static_cast<unsigned long *>(context);
         if(finfo.st_size) {          if(finfo.st_size) {
                 InitCrc32Table();                  InitCrc32Table();
Removed from v.1.233  
changed lines
  Added in v.1.259

E-mail: