[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.302 and 1.312

version 1.302, 2017/02/06 16:33:33 version 1.312, 2020/02/26 12:17:30
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright (c) 2000-2015 Art. Lebedev Studio (http://www.artlebedev.com)          Copyright (c) 2000-2017 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  
  *  Authors: Michael Zucchi <notzed@ximian.com>  
  *           Jeffrey Stedfast <fejj@ximian.com>  
  *  
  *  Copyright 2000-2004 Ximian, Inc. (www.ximian.com)  
  *  
  *  This program is free software; you can redistribute it and/or modify  
  *  it under the terms of the GNU General Public License as published by  
  *  the Free Software Foundation; either version 2 of the License, or  
  *  (at your option) any later version.  
  *  
  *  This program is distributed in the hope that it will be useful,  
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of  
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
  *  GNU General Public License for more details.  
  *  
  *  You should have received a copy of the GNU General Public License  
  *  along with this program; if not, write to the Free Software  
  *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.  
  *  
  */  
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_exception.h"  #include "pa_exception.h"
Line 79  volatile const char * IDENT_PA_COMMON_C= Line 58  volatile const char * IDENT_PA_COMMON_C=
   
 const String file_status_name(FILE_STATUS_NAME);  const String file_status_name(FILE_STATUS_NAME);
   
   String sql_bind_name(SQL_BIND_NAME);
   String sql_limit_name(PA_SQL_LIMIT_NAME);
   String sql_offset_name(PA_SQL_OFFSET_NAME);
   String sql_default_name(SQL_DEFAULT_NAME);
   String sql_distinct_name(SQL_DISTINCT_NAME);
   String sql_value_type_name(SQL_VALUE_TYPE_NAME);
   
 // forwards  // forwards
   
 const UTF16* pa_utf16_encode(const char* in, Charset& source_charset);  const UTF16* pa_utf16_encode(const char* in, Charset& source_charset);
Line 105  FILE *pa_fopen(const char *pathname, con Line 91  FILE *pa_fopen(const char *pathname, con
   
 #endif  #endif
   
 char* file_read_text(Request_charsets& charsets, const String& file_spec, bool fail_on_read_problem, HashStringValue* params, bool transcode_result) {  
         File_read_result file=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;  
 }  
   
 /// 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;
Line 134  int pa_get_valid_file_options_count(Hash Line 110  int pa_get_valid_file_options_count(Hash
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_read_action_info {  struct File_read_action_info {
         char **data; size_t *data_size;          char **data; size_t *data_size;
         char* buf; size_t offset; size_t count;          char* buf; size_t offset; size_t limit;
 };   }; 
 #endif  #endif
   
 static void file_read_action(struct stat& finfo, int f, const String& file_spec, void *context) {  static void file_read_action(struct stat& finfo, int f, const String& file_spec, void *context) {
         File_read_action_info& info=*static_cast<File_read_action_info *>(context);           File_read_action_info& info = *static_cast<File_read_action_info *>(context); 
         size_t to_read_size=info.count;          size_t to_read_size = info.limit;
         if(!to_read_size)          if(!to_read_size)
                 to_read_size=check_file_size(finfo.st_size, file_spec);                  to_read_size = check_file_size(finfo.st_size, file_spec);
         if(to_read_size) {          if(to_read_size) {
                 if(info.offset)                  if(info.offset)
                         lseek(f, info.offset, SEEK_SET);                          lseek(f, info.offset, SEEK_SET);
                 *info.data=info.buf ? info.buf : (char *)pa_malloc_atomic(to_read_size+1);                  *info.data = info.buf ? info.buf : (char *)pa_malloc_atomic(to_read_size+1);
                 ssize_t result=read(f, *info.data, to_read_size);                  ssize_t result = read(f, *info.data, to_read_size);
                 if(result<0)                  if(result<0)
                         throw Exception("file.read", &file_spec, "read failed: %s (%d)", strerror(errno), errno);                          throw Exception("file.read", &file_spec, "read failed: %s (%d)", strerror(errno), errno);
                 *info.data_size=result;                  *info.data_size = result;
         } 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=(char *)pa_malloc_atomic(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_binary(const String& file_spec, bool fail_on_read_problem, char* buf, size_t offset, size_t limit) {
           File_read_result result = {false, 0, 0, 0};
           File_read_action_info info = {&result.str, &result.length, buf, offset, limit};
   
           result.success = file_read_action_under_lock(file_spec, "read", file_read_action, &info, 0, fail_on_read_problem);
           return result;
   }
   
 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 *options,
                         bool fail_on_read_problem,                          bool fail_on_read_problem,
                         char* buf, size_t offset, size_t count, bool transcode_text_result) {                          size_t offset = 0, size_t limit = 0, bool transcode_text_result = true) {
         File_read_result result={false, 0, 0, 0};          File_read_result result = {false, 0, 0, 0};
         if(params){          if(options){
                 int valid_options=pa_get_valid_file_options_count(*params);                  int valid_options = pa_get_valid_file_options_count(*options);
                 if(valid_options!=params->count())                  if(valid_options != options->count())
                         throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);                          throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
         }          }
   
         File_read_action_info info={&result.str, &result.length, buf, offset, count};           File_read_action_info info = {&result.str, &result.length, 0, offset, limit}; 
   
         result.success=file_read_action_under_lock(file_spec, "read", file_read_action, &info, as_text, fail_on_read_problem);           result.success = file_read_action_under_lock(file_spec, "read", file_read_action, &info, as_text, fail_on_read_problem); 
   
         if(as_text){          if(as_text){
                 if(result.success){                  if(result.success){
                         Charset* asked_charset=0;                          Charset* asked_charset = 0;
                         if(params)                          if(options)
                                 if(Value* vcharset_name=params->get(PA_CHARSET_NAME))                                  if(Value* vcharset_name = options->get(PA_CHARSET_NAME))
                                         asked_charset=&pa_charsets.get(vcharset_name->as_string());                                          asked_charset = &pa_charsets.get(vcharset_name->as_string());
   
                         asked_charset=pa_charsets.checkBOM(result.str, result.length, asked_charset);                          asked_charset = pa_charsets.checkBOM(result.str, result.length, asked_charset);
   
                         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                          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 200  File_read_result file_read(Request_chars Line 184  File_read_result file_read(Request_chars
 }  }
   
 File_read_result file_load(Request& r, const String& file_spec,   File_read_result file_load(Request& r, const String& file_spec, 
                         bool as_text, HashStringValue *params,                          bool as_text, HashStringValue *options,
                         bool fail_on_read_problem,                          bool fail_on_read_problem,
                         char* buf, size_t offset, size_t count, bool transcode_text_result) {                          bool transcode_text_result) {
   
           size_t offset = 0;
           size_t limit = 0;
   
           if(options){
                   if(Value *voffset = (Value *)options->get(sql_offset_name))
                           offset = r.process(*voffset).as_int();
                   if(Value *vlimit = (Value *)options->get(sql_limit_name))
                           limit = r.process(*vlimit).as_int();
                   // no check on options count here
           }
   
         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 || limit)
                         throw Exception(PARSER_RUNTIME, 0, "offset and load options are not supported for HTTP:// file load");                          throw Exception(PARSER_RUNTIME, 0, "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(r, file_spec, as_text, params, transcode_text_result);                  File_read_http_result http = pa_internal_file_read_http(r, file_spec, as_text, options, transcode_text_result);
                 result.success=true;  
                 result.str=http.str;                  File_read_result result = {true, http.str, http.length, http.headers};
                 result.length=http.length;                  return result;
                 result.headers=http.headers;   
         } else          } else
                 result=                  return file_read(r.charsets, file_spec, as_text, options, fail_on_read_problem, offset, limit, transcode_text_result);
                         file_read(r.charsets, file_spec, as_text, params, fail_on_read_problem, buf, offset, count, transcode_text_result);  }
   
         return result;  char* file_read_text(Request_charsets& charsets, const String& file_spec, bool fail_on_read_problem) {
           File_read_result file = file_read(charsets, file_spec, true, 0, fail_on_read_problem);
           return file.success ? file.str : 0;
 }  }
   
   char* file_load_text(Request& r, const String& file_spec, bool fail_on_read_problem, HashStringValue* options, bool transcode_result) {
           File_read_result file = file_load(r, file_spec, true, options, fail_on_read_problem, transcode_result);
           return file.success ? file.str : 0;
   }
   
 #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) {
Line 408  static size_t get_dir(char* fname, size_ Line 407  static size_t get_dir(char* fname, size_
         return pos;          return pos;
 }  }
   
 static bool entry_readable(char* fname, bool need_dir) {  bool entry_exists(const char* fname, struct stat *afinfo) {
           struct stat lfinfo;
           bool result=pa_stat(fname, &lfinfo)==0;
           if(afinfo)
                   *afinfo=lfinfo;
           return result;
   }
   
   bool entry_exists(const String& file_spec) {
           return entry_exists(file_spec.taint_cstr(String::L_FILE_SPEC), 0); 
   }
   
   static bool entry_ifdir(char *fname, bool need_dir) {
         if(need_dir){          if(need_dir){
                 size_t size=strlen(fname);                  size_t size=strlen(fname);
                 while(size) {                  while(size) {
Line 421  static bool entry_readable(char* fname, Line 432  static bool entry_readable(char* fname,
         }          }
   
         struct stat finfo;          struct stat finfo;
         if(access(fname, R_OK)==0 && entry_exists(fname, &finfo)) {          if(entry_exists(fname, &finfo)) {
                 bool is_dir=(finfo.st_mode&S_IFDIR) != 0;                  bool is_dir=(finfo.st_mode&S_IFDIR) != 0;
                 return is_dir==need_dir;                  return is_dir==need_dir;
         }          }
         return false;          return false;
 }  }
   
 static bool entry_readable(const String& file_spec, bool need_dir) {  static bool entry_ifdir(const String& file_spec, bool need_dir) {
         return entry_readable(file_spec.taint_cstrm(String::L_FILE_SPEC), need_dir);          return entry_ifdir(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]
Line 438  static void rmdir(const String& file_spe Line 449  static void rmdir(const String& file_spe
         size_t length=strlen(dir_spec);          size_t length=strlen(dir_spec);
         while( (length=get_dir(dir_spec, length)) && (length > pos_after) ){          while( (length=get_dir(dir_spec, length)) && (length > pos_after) ){
 #ifdef _MSC_VER  #ifdef _MSC_VER
                 if(!entry_readable(dir_spec, true))                  if(!entry_ifdir(dir_spec, true))
                         break;                          break;
                 DWORD attrs=GetFileAttributes(dir_spec);                  DWORD attrs=GetFileAttributes(dir_spec);
                 if(                  if(
Line 484  void file_move(const String& old_spec, c Line 495  void file_move(const String& old_spec, c
 }  }
   
   
 bool entry_exists(const char* fname, struct stat *afinfo) {  
         struct stat lfinfo;  
         bool result=pa_stat(fname, &lfinfo)==0;  
         if(afinfo)  
                 *afinfo=lfinfo;  
         return result;  
 }  
   
 bool entry_exists(const String& file_spec) {  
         const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC);   
         return entry_exists(fname, 0);   
 }  
   
 bool file_exist(const String& file_spec) {  bool file_exist(const String& file_spec) {
         return entry_readable(file_spec, false);           return entry_ifdir(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_ifdir(file_spec, true); 
 }  }
   
 const String* file_exist(const String& path, const String& name) {  const String* file_exist(const String& path, const String& name) {
Line 743  const char* format(double value, const c Line 741  const char* format(double value, const c
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                  size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);
   
         if(size < 0 || size >= MAX_NUMBER-1){ // on win32 we manually reduce max size while printing          if(size < 0 || size >= MAX_NUMBER-1){ // on win32 we manually reduce max size while printing
                 throw Exception(PARSER_RUNTIME, 0, "Error occure white executing snprintf with format string '%s'.", fmt);                  throw Exception(PARSER_RUNTIME, 0, "Error occurred white executing snprintf with format string '%s'.", fmt);
         }          }
   
         return pa_strdup(local_buf, (size_t)size);          return pa_strdup(local_buf, (size_t)size);
Line 920  const char* hex_string(unsigned char* by Line 918  const char* hex_string(unsigned char* by
         return bytes_hex;          return bytes_hex;
 }  }
   
 /* mime64 functions are from libgmime[http://spruce.sourceforge.net/gmime/] lib */  
 /*  
  *  Authors: Michael Zucchi <notzed@helixcode.com>  
  *           Jeffrey Stedfast <fejj@helixcode.com>  
  *  
  *  Copyright 2000 Helix Code, Inc. (www.helixcode.com)  
  *  
  *  This program is free software; you can redistribute it and/or modify  
  *  it under the terms of the GNU General Public License as published by  
  *  the Free Software Foundation; either version 2 of the License, or  
  *  (at your option) any later version.  
  *  
  *  This program is distributed in the hope that it will be useful,  
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of  
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
  *  GNU General Public License for more details.  
  *  
  *  You should have received a copy of the GNU General Public License  
  *  along with this program; if not, write to the Free Software  
  *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.  
  *  
  */  
 static const char *base64_alphabet =  
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";  
   
 /**  
  * g_mime_utils_base64_encode_step:  
  * @in: input stream  
  * @inlen: length of the input  
  * @out: output string  
  * @state: holds the number of bits that are stored in @save  
  * @save: leftover bits that have not yet been encoded  
  *  
  * Base64 encodes a chunk of data. Performs an 'encode step', only  
  * encodes blocks of 3 characters to the output at a time, saves  
  * left-over state in state and save (initialise to 0 on first  
  * invocation).  
  *  
  * Returns the number of bytes encoded.  
  **/  
   
 #define BASE64_GROUPS_IN_LINE 19  
   
 static size_t  
 g_mime_utils_base64_encode_step (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)  
 {  
         register const unsigned char *inptr;  
         register unsigned char *outptr;  
           
         if (inlen <= 0)  
                 return 0;  
           
         inptr = in;  
         outptr = out;  
           
         if (inlen + ((unsigned char *)save)[0] > 2) {  
                 const unsigned char *inend = in + inlen - 2;  
                 register int c1 = 0, c2 = 0, c3 = 0;  
                 register int already;  
                   
                 already = *state;  
                   
                 switch (((char *)save)[0]) {  
                 case 1: c1 = ((unsigned char *)save)[1]; goto skip1;  
                 case 2: c1 = ((unsigned char *)save)[1];  
                         c2 = ((unsigned char *)save)[2]; goto skip2;  
                 }  
                   
                 /* yes, we jump into the loop, no i'm not going to change it, its beautiful! */  
                 while (inptr < inend) {  
                         c1 = *inptr++;  
                 skip1:  
                         c2 = *inptr++;  
                 skip2:  
                         c3 = *inptr++;  
                         *outptr++ = base64_alphabet [c1 >> 2];  
                         *outptr++ = base64_alphabet [(c2 >> 4) | ((c1 & 0x3) << 4)];  
                         *outptr++ = base64_alphabet [((c2 & 0x0f) << 2) | (c3 >> 6)];  
                         *outptr++ = base64_alphabet [c3 & 0x3f];  
                         /* this is a bit ugly ... */  
                         if ((++already) >= BASE64_GROUPS_IN_LINE) {  
                                 *outptr++ = '\n';  
                                 already = 0;  
                         }  
                 }  
                   
                 ((unsigned char *)save)[0] = 0;  
                 inlen = 2 - (inptr - inend);  
                 *state = already;  
         }  
           
         //d(printf ("state = %d, inlen = %d\n", (int)((char *)save)[0], inlen));  
           
         if (inlen > 0) {  
                 register char *saveout;  
                   
                 /* points to the slot for the next char to save */  
                 saveout = & (((char *)save)[1]) + ((char *)save)[0];  
                   
                 /* inlen can only be 0 1 or 2 */  
                 switch (inlen) {  
                 case 2: *saveout++ = *inptr++;  
                 case 1: *saveout++ = *inptr++;  
                 }  
                 *(char *)save = *(char *)save+(char)inlen;  
         }  
           
         /*d(printf ("mode = %d\nc1 = %c\nc2 = %c\n",  
                   (int)((char *)save)[0],  
                   (int)((char *)save)[1],  
                   (int)((char *)save)[2]));*/  
           
         return (outptr - out);  
 }  
   
 /**  
  * g_mime_utils_base64_encode_close:  
  * @in: input stream  
  * @inlen: length of the input  
  * @out: output string  
  * @state: holds the number of bits that are stored in @save  
  * @save: leftover bits that have not yet been encoded  
  *  
  * Base64 encodes the input stream to the output stream. Call this  
  * when finished encoding data with g_mime_utils_base64_encode_step to  
  * flush off the last little bit.  
  *  
  * Returns the number of bytes encoded.  
  **/  
 static size_t  
 g_mime_utils_base64_encode_close (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)  
 {  
         unsigned char *outptr = out;  
         int c1, c2;  
           
         if (inlen > 0)  
                 outptr += g_mime_utils_base64_encode_step (in, inlen, outptr, state, save);  
           
         c1 = ((unsigned char *)save)[1];  
         c2 = ((unsigned char *)save)[2];  
           
         switch (((unsigned char *)save)[0]) {  
         case 2:  
                 outptr[2] = base64_alphabet [(c2 & 0x0f) << 2];  
                 goto skip;  
         case 1:  
                 outptr[2] = '=';  
         skip:  
                 outptr[0] = base64_alphabet [c1 >> 2];  
                 outptr[1] = base64_alphabet [c2 >> 4 | ((c1 & 0x3) << 4)];  
                 outptr[3] = '=';  
                 outptr += 4;  
                 break;  
         }  
           
         *outptr++ = 0;  
           
         *save = 0;  
         *state = 0;  
           
         return (outptr - out);  
 }  
   
 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,  
         254,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,  
         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,  
         255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,  
          41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,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,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,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,  
 };  
   
 /**  
  * g_mime_utils_base64_decode_step:  
  * @in: input stream  
  * @inlen: max length of data to decode  
  * @out: output stream  
  * @state: holds the number of bits that are stored in @save  
  * @save: leftover bits that have not yet been decoded  
  * @strict: only base64 and whitespace chars are allowed  
  *  
  * Decodes a chunk of base64 encoded data.  
  *  
  * Returns the number of bytes decoded (which have been dumped in @out).  
  **/  
 size_t  
 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;  
         unsigned char *outptr;  
         const unsigned char *inend;  
         int saved;  
         unsigned char c;  
         int i;  
           
         inend = in + inlen;  
         outptr = out;  
           
         /* convert 4 base64 bytes to 3 normal bytes */  
         saved = *save;  
         i = *state;  
         inptr = in;  
         while (inptr < inend) {  
                 c = gmime_base64_rank[*inptr++];  
                 switch(c) {  
                         case 0xff: // non-base64 and non-whitespace chars. not allowed in strict mode  
                                 if(strict)  
                                         throw Exception(BASE64_FORMAT, 0, "Invalid base64 char on position %d is detected", inptr-in-1);  
                         case 0xfe: // whitespace chars 0x09, 0x0A, 0x0D, 0x20 are allowed in any mode  
                                 break;  
                         default:  
                                 saved = (saved << 6) | c;  
                                 i++;  
                                 if (i == 4) {  
                                         *outptr++ = (unsigned char)(saved >> 16);  
                                         *outptr++ = (unsigned char)(saved >> 8);  
                                         *outptr++ = (unsigned char)(saved);  
                                         i = 0;  
                                 }  
                 }  
         }  
           
         *save = saved;  
         *state = i;  
           
         /* quick scan back for '=' on the end somewhere */  
         /* fortunately we can drop 1 output char for each trailing = (upto 2) */  
         i = 2;  
         while (inptr > in && i) {  
                 inptr--;  
                 if (gmime_base64_rank[*inptr] <= 0xfe) {  
                         if (*inptr == '=' && outptr > out)  
                                 outptr--;  
                         i--;  
                 }  
         }  
           
         /* if i != 0 then there is a truncation error! */  
         return (outptr - out);  
 }  
   
   
 char* pa_base64_encode(const char *in, size_t in_size){  
         size_t new_size = ((in_size / 3 + 1) * 4);  
         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 save=0;  
 #ifndef NDEBUG  
         size_t filled=  
 #endif  
                 g_mime_utils_base64_encode_close ((const unsigned char*)in, in_size, (unsigned char*)result, &state, &save);  
   
         //throw Exception(PARSER_RUNTIME, 0, "%d %d %d", in_size, new_size, filled);  
         assert(filled <= new_size);  
   
         return result;  
 }  
   
 struct File_base64_action_info {  
         unsigned char** base64;  
 };   
   
 static void file_base64_file_action(struct stat& finfo, int f, const String& file_spec, void *context) {  
   
         if(finfo.st_size) {   
                 File_base64_action_info& info=*static_cast<File_base64_action_info *>(context);  
                 *info.base64=new(PointerFreeGC) unsigned char[check_file_size(finfo.st_size, file_spec) * 2 + 6];   
                 unsigned char* base64 = *info.base64;  
                 int state=0;  
                 int save=0;  
                 int nCount;  
                 do {  
                         unsigned char buffer[FILE_BUFFER_SIZE];  
                         nCount = file_block_read(f, buffer, sizeof(buffer));  
                         if( nCount ){  
                                 size_t filled=g_mime_utils_base64_encode_step ((const unsigned char*)buffer, nCount, base64, &state, &save);  
                                 base64+=filled;  
                         }  
                 } while(nCount > 0);  
                 g_mime_utils_base64_encode_close (0, 0, base64, &state, &save);  
         }  
 }  
   
 char* pa_base64_encode(const String& file_spec){  
         unsigned char* base64=0;  
         File_base64_action_info info={&base64};   
   
         file_read_action_under_lock(file_spec, "pa_base64_encode", file_base64_file_action, &info);  
   
         return (char*)base64;   
 }  
   
 void pa_base64_decode(const char *in, size_t in_size, char*& result, size_t& result_size, bool strict) {  
         // every 4 base64 bytes are converted into 3 normal bytes  
         // 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 save=0;  
         result_size=g_mime_utils_base64_decode_step ((const unsigned char*)in, in_size, (unsigned char*)result, &state, &save, strict);  
         assert(result_size <= new_size);  
         result[result_size]=0; // for text files  
   
         if(strict && state!=0)  
                 throw Exception(BASE64_FORMAT, 0, "Unexpected end of chars");  
 }  
   
   
 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)
Removed from v.1.302  
changed lines
  Added in v.1.312

E-mail: