[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.250 and 1.270

version 1.250, 2009/09/08 09:09:26 version 1.270, 2013/04/21 21:59:07
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2000-2012 Art. Lebedev Studio (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 26 Line 26
  *   *
  */   */
   
 static const char * const IDENT_COMMON_C="$Date$";   
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_hash.h"  #include "pa_hash.h"
Line 38  static const char * const IDENT_COMMON_C Line 36  static const char * const IDENT_COMMON_C
 #include "pcre.h"  #include "pcre.h"
 #include "pa_request.h"  #include "pa_request.h"
   
   volatile const char * IDENT_PA_COMMON_C="$Id$" IDENT_PA_COMMON_H IDENT_PA_HASH_H IDENT_PA_ARRAY_H IDENT_PA_STACK_H; 
   
 // some maybe-undefined constants  // some maybe-undefined constants
   
 #ifndef _O_TEXT  #ifndef _O_TEXT
Line 67  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){  const char* capitalize(const char* s){
           if(!s || capitalized(s))
                   return s;
   
         char* result=pa_strdup(s);          char* result=pa_strdup(s);
         if(result){          if(result){
                 bool upper=true;                  bool upper=true;
Line 89  void fix_line_breaks(char *str, size_t& Line 102  void fix_line_breaks(char *str, size_t&
         while(char* eol=(char*)memchr(bol, '\r', eob -bol)) {          while(char* eol=(char*)memchr(bol, '\r', eob -bol)) {
                 size_t len=eol-bol;                  size_t len=eol-bol;
                 if(dest!=bol)                  if(dest!=bol)
                         memcpy(dest, bol, len);                           memmove(dest, bol, len); 
                 dest+=len;                  dest+=len;
                 *dest++='\n';                   *dest++='\n'; 
   
Line 101  void fix_line_breaks(char *str, size_t& Line 114  void fix_line_breaks(char *str, size_t&
         }          }
         // last piece without \r          // last piece without \r
         if(dest!=bol)          if(dest!=bol)
                 memcpy(dest, bol, eob-bol);                   memmove(dest, bol, eob-bol); 
         str[length]=0; // terminating          str[length]=0; // terminating
 }  }
   
Line 162  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)
Line 172  static void file_read_action( Line 185  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 187  File_read_result file_read(Request_chars Line 200  File_read_result file_read(Request_chars
         if(params){          if(params){
                 int valid_options=pa_get_valid_file_options_count(*params);                  int valid_options=pa_get_valid_file_options_count(*params);
                 if(valid_options!=params->count())                  if(valid_options!=params->count())
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                                 0,  
                                 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 200  File_read_result file_read(Request_chars Line 211  File_read_result file_read(Request_chars
   
         if(as_text){          if(as_text){
                 if(result.success){                  if(result.success){
                           Charset* asked_charset=0;
                         if(result.length>=3 && strncmp(result.str, "\xEF\xBB\xBF", 3)==0){                          if(result.length>=3 && strncmp(result.str, "\xEF\xBB\xBF", 3)==0){
                                 // skip UTF-8 signature (BOM code)                                  // skip UTF-8 signature (BOM code)
                                 result.str+=3;                                  result.str+=3;
                                 result.length-=3;                                  result.length-=3;
                                   asked_charset=&UTF8_charset;
                         }                          }
                                                   
                         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(params)
                                 if(Value* vcharset_name=params->get(PA_CHARSET_NAME)){                                  if(Value* vcharset_name=params->get(PA_CHARSET_NAME))
                                         Charset asked_charset=::charsets.get(vcharset_name->as_string().                                          asked_charset=&::charsets.get(vcharset_name->as_string().change_case(charsets.source(), String::CC_UPPER));
                                                 change_case(charsets.source(), String::CC_UPPER));  
                           if(result.length && transcode_text_result && asked_charset){ // length must be checked because transcode returns CONST string in case length==0, which contradicts hacking few lines below
                                         String::C body=String::C(result.str, result.length);                                  String::C body=String::C(result.str, result.length);
                                         body=Charset::transcode(body, asked_charset, charsets.source());                                  body=Charset::transcode(body, *asked_charset, charsets.source());
   
                                         result.str=const_cast<char*>(body.str); // hacking a little                                  result.str=const_cast<char*>(body.str); // hacking a little
                                         result.length=body.length;                                  result.length=body.length;
                                 }  
                         }                          }
                 }                  }
                 if(result.length)                  if(result.length)
Line 251  File_read_result file_load(Request& r, c Line 263  File_read_result file_load(Request& r, c
         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 264  void check_safe_mode(struct stat finfo, Line 277  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, 
Line 293  bool file_read_action_under_lock(const S Line 311  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 315  bool file_read_action_under_lock(const S Line 331  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 362  bool file_write_action_under_lock( Line 379  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 429  void file_write( Line 451  void file_write(
                 do_append);                   do_append); 
 }  }
   
   static size_t get_dir(char* fname, size_t helper_length){
           bool dir=false;
           size_t pos=0;
           for(pos=helper_length; pos; pos--){
                   char c=fname[pos-1];
                   if(c=='/' || c=='\\'){
                           fname[pos-1]=0;
                           dir=true;
                   } else if(dir) break;
           }
           return pos;
   }
   
   static bool entry_readable(char* fname, bool need_dir) {
           if(need_dir){
                   size_t size=strlen(fname);
                   while(size) {
                           char c=fname[size-1];
                           if(c=='/' || c=='\\')
                                   fname[--size]=0;
                           else
                                   break;
                   }
           }
   
           struct stat finfo;
           if(access(fname, R_OK)==0 && entry_exists(fname, &finfo)) {
                   bool is_dir=(finfo.st_mode&S_IFDIR) != 0;
                   return is_dir==need_dir;
           }
           return false;
   }
   
   static bool entry_readable(const String& file_spec, bool need_dir) {
           return entry_readable(file_spec.taint_cstrm(String::L_FILE_SPEC), need_dir);
   }
   
 // throws nothing! [this is required in file_move & file_delete]  // throws nothing! [this is required in file_move & file_delete]
 static void rmdir(const String& file_spec, size_t pos_after) {  static void rmdir(const String& file_spec, size_t pos_after=0) {
         size_t pos_before;          char* dir_spec=file_spec.taint_cstrm(String::L_FILE_SPEC);
         if((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND)          size_t length=strlen(dir_spec);
                 rmdir(file_spec, pos_before+1);           while( (length=get_dir(dir_spec, length)) && (length > pos_after) ){
           #ifdef WIN32
         rmdir(file_spec.mid(0, pos_after-1/* / */).taint_cstr(String::L_FILE_SPEC));                   if(!entry_readable(dir_spec, true))
                           break;
                   DWORD attrs=GetFileAttributes(dir_spec);
                   if(
                           (attrs==INVALID_FILE_ATTRIBUTES)
                           || !(attrs & FILE_ATTRIBUTE_DIRECTORY)
                           || (attrs & FILE_ATTRIBUTE_REPARSE_POINT)
                   )
                           break;
   #endif
                   if( rmdir(dir_spec) )
                           break;
           };
 }  }
   
 bool file_delete(const String& file_spec, bool fail_on_problem) {  bool file_delete(const String& file_spec, bool fail_on_problem, bool keep_empty_dirs) {
         const char* fname=file_spec.taint_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)
Line 449  bool file_delete(const String& file_spec Line 520  bool file_delete(const String& file_spec
                 else                  else
                         return false;                          return false;
   
         rmdir(file_spec, 1);           if(!keep_empty_dirs)
                   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, bool keep_empty_dirs) {
         const char* old_spec_cstr=old_spec.taint_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.taint_cstr(String::L_FILE_SPEC);           const char* new_spec_cstr=new_spec.taint_cstr(String::L_FILE_SPEC); 
                   
Line 465  void file_move(const String& old_spec, c Line 538  void file_move(const String& old_spec, c
                         "rename failed: %s (%d), actual filename '%s' to '%s'",                           "rename failed: %s (%d), actual filename '%s' to '%s'", 
                                 strerror(errno), errno, old_spec_cstr, new_spec_cstr);                                  strerror(errno), errno, old_spec_cstr, new_spec_cstr);
   
         rmdir(old_spec, 1);           if(!keep_empty_dirs)
                   rmdir(old_spec, 1); 
 }  }
   
   
Line 482  bool entry_exists(const String& file_spe Line 556  bool entry_exists(const String& file_spe
         return entry_exists(fname, 0);           return entry_exists(fname, 0); 
 }  }
   
 static bool entry_readable(const String& file_spec, bool need_dir) {  
         char* fname=file_spec.taint_cstrm(String::L_FILE_SPEC);   
         if(need_dir) {  
                 size_t size=strlen(fname);   
                 while(size) {  
                         char c=fname[size-1];   
                         if(c=='/' || c=='\\')  
                                 fname[--size]=0;  
                         else  
                                 break;  
                 }  
         }  
         struct stat finfo;  
         if(access(fname, R_OK)==0 && entry_exists(fname, &finfo)) {  
                 bool is_dir=(finfo.st_mode&S_IFDIR) != 0;  
                 return is_dir==need_dir;  
         }  
         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); 
 }  }
Line 512  bool dir_exists(const String& file_spec) Line 566  bool dir_exists(const String& file_spec)
   
 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 << "/";           if(path.last_char() != '/')
                   result << "/"; 
         result << name;          result << name;
         return file_exist(result)?&result:0;          return file_exist(result)?&result:0;
 }  }
Line 707  enum EscapeState { Line 762  enum EscapeState {
 };  };
   
 // @todo prescan for reduce required size (unescaped sting in 1 byte charset requires less memory usually)  // @todo prescan for reduce required size (unescaped sting in 1 byte charset requires less memory usually)
 char* unescape_chars(const char* cp, int len, Charset* charset, bool ignore_plus){  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* 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;
Line 716  char* unescape_chars(const char* cp, int Line 771  char* unescape_chars(const char* cp, int
         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(!ignore_plus && c=='+'){                                          if(!js && c=='+'){
                                                 *dst++=' ';                                                  *dst++=' ';
                                         } else {                                          } else {
                                                 *dst++=c;                                                  *dst++=c;
Line 773  char* unescape_chars(const char* cp, int Line 828  char* unescape_chars(const char* cp, int
         return s;          return s;
 }  }
   
   char *search_stop(char*& current, char cstop_at) {
           // sanity check
           if(!current)
                   return 0;
   
           // skip leading WS
           while(*current==' ' || *current=='\t')
                   current++;
           if(!*current)
                   return current=0;
   
           char *result=current;
           if(char *pstop_at=strchr(current, cstop_at)) {
                   *pstop_at=0;
                   current=pstop_at+1;
           } else
                   current=0;
           return result;
   }
   
 #ifdef WIN32  #ifdef WIN32
 void back_slashes_to_slashes(char* s) {  void back_slashes_to_slashes(char* s) {
         if(s)          if(s)
Line 993  static char *base64_alphabet = Line 1068  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 1030  g_mime_utils_base64_encode_step (const u Line 1108  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 1114  g_mime_utils_base64_encode_close (const Line 1192  g_mime_utils_base64_encode_close (const
 }  }
   
 static unsigned char gmime_base64_rank[256] = {  static unsigned char gmime_base64_rank[256] = {
           255,255,255,255,255,255,255,255,255,254,254,255,255,254,255,255,
         255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,          255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
         255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,          254,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
         255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,  
          52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,           52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
         255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,          255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
          15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,           15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
Line 1139  static unsigned char gmime_base64_rank[2 Line 1217  static unsigned char gmime_base64_rank[2
  * @out: output stream   * @out: output stream
  * @state: holds the number of bits that are stored in @save   * @state: holds the number of bits that are stored in @save
  * @save: leftover bits that have not yet been decoded   * @save: leftover bits that have not yet been decoded
    * @strict: only base64 and whitespace chars are allowed
  *   *
  * Decodes a chunk of base64 encoded data.   * Decodes a chunk of base64 encoded data.
  *   *
  * Returns the number of bytes decoded (which have been dumped in @out).   * Returns the number of bytes decoded (which have been dumped in @out).
  **/   **/
 size_t  size_t
 g_mime_utils_base64_decode_step (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)  g_mime_utils_base64_decode_step(const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save, bool strict=false)
 {  {
         const unsigned char *inptr;          const unsigned char *inptr;
         unsigned char *outptr;          unsigned char *outptr;
Line 1163  g_mime_utils_base64_decode_step (const u Line 1242  g_mime_utils_base64_decode_step (const u
         inptr = in;          inptr = in;
         while (inptr < inend) {          while (inptr < inend) {
                 c = gmime_base64_rank[*inptr++];                  c = gmime_base64_rank[*inptr++];
                 if (c != 0xff) {                  switch(c) {
                         saved = (saved << 6) | c;                          case 0xff: // non-base64 and non-whitespace chars. not allowed in strict mode
                         i++;                                  if(strict)
                         if (i == 4) {                                          throw Exception(BASE64_FORMAT, 0, "Invalid base64 char on position %d is detected", inptr-in-1);
                                 *outptr++ = (unsigned char)(saved >> 16);                          case 0xfe: // whitespace chars 0x09, 0x0A, 0x0D, 0x20 are allowed in any mode
                                 *outptr++ = (unsigned char)(saved >> 8);                                  break;
                                 *outptr++ = (unsigned char)(saved);                          default:
                                 i = 0;                                  saved = (saved << 6) | c;
                         }                                  i++;
                                   if (i == 4) {
                                           *outptr++ = (unsigned char)(saved >> 16);
                                           *outptr++ = (unsigned char)(saved >> 8);
                                           *outptr++ = (unsigned char)(saved);
                                           i = 0;
                                   }
                 }                  }
         }          }
                   
Line 1183  g_mime_utils_base64_decode_step (const u Line 1268  g_mime_utils_base64_decode_step (const u
         i = 2;          i = 2;
         while (inptr > in && i) {          while (inptr > in && i) {
                 inptr--;                  inptr--;
                 if (gmime_base64_rank[*inptr] != 0xff) {                  if (gmime_base64_rank[*inptr] <= 0xfe) {
                         if (*inptr == '=' && outptr > out)                          if (*inptr == '=' && outptr > out)
                                 outptr--;                                  outptr--;
                         i--;                          i--;
Line 1196  g_mime_utils_base64_decode_step (const u Line 1281  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;
 }  }
Line 1247  static void file_base64_file_action( Line 1334  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, bool strict) {
         /* wont go to more than had (overly conservative) */          // every 4 base64 bytes are converted into 3 normal bytes
         result=new(PointerFreeGC) char[in_size+1/*terminator*/];          // not full set (tail) of 4-bytes set is ignored
           size_t new_size=in_size/4*3;
           result=new(PointerFreeGC) char[new_size+1/*terminator*/];
   
         int state=0;          int state=0;
         int save=0;          int save=0;
         result_size=          result_size=
                 g_mime_utils_base64_decode_step ((const unsigned char*)in, in_size,                   g_mime_utils_base64_decode_step ((const unsigned char*)in, in_size,
                 (unsigned char*)result, &state, &save);                  (unsigned char*)result, &state, &save, strict);
         assert(result_size <= in_size);          assert(result_size <= new_size);
         result[result_size]=0; // for text files          result[result_size]=0; // for text files
   
           if(strict && state!=0)
                   throw Exception(BASE64_FORMAT, 0, "Unexpected end of chars");
 }  }
   
   
Removed from v.1.250  
changed lines
  Added in v.1.270

E-mail: