[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.305 and 1.336

version 1.305, 2019/09/06 10:17:07 version 1.336, 2024/12/23 16:59:17
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright (c) 2000-2017 Art. Lebedev Studio (http://www.artlebedev.com)          Copyright (c) 2000-2024 Art. Lebedev Studio (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Authors: Konstantin Morshnev <moko@design.ru>, Alexandr Petrosian <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 33 Line 12
 #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"  #include "pa_request.h"
   
 #include "pa_idna.h"  #include "pa_idna.h"
Line 112  FILE *pa_fopen(const char *pathname, con Line 90  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 141  int pa_get_valid_file_options_count(Hash Line 109  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; uint64_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 = check_file_size(info.limit && info.limit < (size_t)finfo.st_size ? info.limit : (size_t)finfo.st_size, &file_spec);
         if(!to_read_size)  
                 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);                           pa_lseek(f, info.offset, SEEK_SET); // seek never fails as POSIX allows the file offset to be set beyond the EOF
                 *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, uint64_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 207  File_read_result file_read(Request_chars Line 181  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 248  void check_safe_mode(struct stat, const Line 237  void check_safe_mode(struct stat, const
 #endif  #endif
   
   
   bool file_read_action_under_lock(const String& file_spec, const char* action_name, File_read_action action, void *context,
                                   bool as_text, bool fail_on_read_problem) {
   
 bool file_read_action_under_lock(const String& file_spec,           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC);
                                 const char* action_name, File_read_action action, void *context,   
                                 bool as_text,   
                                 bool fail_on_read_problem) {  
         const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC);   
         int f;          int f;
   
         // first open, next stat:          // first open, next stat:
Line 265  bool file_read_action_under_lock(const S Line 252  bool file_read_action_under_lock(const S
         //   they delay update till open, so we would receive "!^test[" string          //   they delay update till open, so we would receive "!^test[" string
         //   if would do stat, next open.          //   if would do stat, next open.
         // later: it seems, even this does not help sometimes          // later: it seems, even this does not help sometimes
         if((f=pa_open(fname, O_RDONLY|(as_text?_O_TEXT:_O_BINARY)))>=0) {          if((f=pa_open(fname, O_RDONLY | (as_text ? _O_TEXT : _O_BINARY) ))>=0) {
                 try {                  try {
                         if(pa_lock_shared_blocking(f)!=0)                          int pa_errno=pa_lock_shared_blocking(f);
                                 throw Exception("file.lock", &file_spec, "shared lock failed: %s (%d), actual filename '%s'", strerror(errno), errno, fname);                          if(pa_errno!=0)
                                   throw Exception("file.lock", &file_spec, "shared lock failed: %s (%d), actual filename '%s'", strerror(pa_errno), pa_errno, fname);
   
                         struct stat finfo;                          struct stat finfo;
                         if(pa_fstat(f, &finfo)!=0)                          if(pa_fstat(f, &finfo)!=0)
Line 296  bool file_read_action_under_lock(const S Line 284  bool file_read_action_under_lock(const S
 }  }
   
 void create_dir_for_file(const String& file_spec) {  void create_dir_for_file(const String& file_spec) {
         size_t pos_after=1;          const char *str=file_spec.taint_cstr(String::L_FILE_SPEC);
         size_t pos_before;          if(str[0]){
         while((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND) {                  const char *pos=str+1;
                 pa_mkdir(file_spec.mid(0, pos_before).taint_cstr(String::L_FILE_SPEC), 0775);                   while((pos=strchr(pos,'/')) && pos[1]) { // to avoid trailing /, see #1166
                 pos_after=pos_before+1;                          pa_mkdir(pa_strdup(str,pos-str), 0775);
                           pos++;
                   }
         }          }
 }  }
   
 bool file_write_action_under_lock(  bool file_write_action_under_lock(const String& file_spec, const char* action_name, File_write_action action, void *context,
                                 const String& file_spec,                                   bool as_text, bool do_append, bool do_block, bool fail_on_lock_problem) {
                                 const char* action_name,  
                                 File_write_action action,  
                                 void *context,   
                                 bool as_text,   
                                 bool do_append,   
                                 bool do_block,   
                                 bool fail_on_lock_problem) {  
         const char* fname=file_spec.taint_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); 
   
         if((f=pa_open(fname,           if((f=pa_open(fname, O_CREAT | O_RDWR | (as_text ? _O_TEXT : _O_BINARY) | (do_append ? O_APPEND : PA_O_TRUNC), 0664))>=0) {
                 O_CREAT|O_RDWR                  int pa_errno=do_block ? pa_lock_exclusive_blocking(f) : pa_lock_exclusive_nonblocking(f);
                 |(as_text?_O_TEXT:_O_BINARY)                  if(pa_errno!=0) {
                 |(do_append?O_APPEND:PA_O_TRUNC), 0664))>=0) {                          Exception e("file.lock", &file_spec, "shared lock failed: %s (%d), actual filename '%s'", strerror(pa_errno), pa_errno, fname);
                 if((do_block?pa_lock_exclusive_blocking(f):pa_lock_exclusive_nonblocking(f))!=0) {                          close(f);
                         Exception e("file.lock", &file_spec, "shared lock failed: %s (%d), actual filename '%s'", strerror(errno), errno, fname);  
                         close(f);   
                         if(fail_on_lock_problem)                          if(fail_on_lock_problem)
                                 throw e;                                  throw e;
                         return false;                          return false;
Line 340  bool file_write_action_under_lock( Line 322  bool file_write_action_under_lock(
                 } catch(...) {                  } catch(...) {
 #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
                         if(!do_append)                          if(!do_append)
                                 ftruncate(f, lseek(f, 0, SEEK_CUR)); // one can not use O_TRUNC, read lower                                  PA_UNUSED int ignore_result=ftruncate(f, lseek(f, 0, SEEK_CUR)); // one cannot use O_TRUNC, read lower
 #endif  #endif
                         pa_unlock(f);close(f);                           pa_unlock(f);close(f);
                         rethrow;                          rethrow;
                 }                  }
                                   
 #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
                 if(!do_append)                  if(!do_append)
                         ftruncate(f, lseek(f, 0, SEEK_CUR)); // O_TRUNC truncates even exclusevely write-locked file [thanks to Igor Milyakov <virtan@rotabanner.com> for discovering]                          PA_UNUSED int ignore_result=ftruncate(f, lseek(f, 0, SEEK_CUR)); // O_TRUNC truncates even exclusevely write-locked file [thanks to Igor Milyakov <virtan@rotabanner.com> for discovering]
 #endif  #endif
                 pa_unlock(f);close(f);                   pa_unlock(f);close(f);
                 return true;                  return true;
         } else          } else
                 throw Exception(errno==EACCES ? "file.access" : 0, &file_spec, "%s failed: %s (%d), actual filename '%s'", action_name, strerror(errno), errno, fname);                  throw Exception(errno==EACCES ? "file.access" : 0, &file_spec, "%s failed: %s (%d), actual filename '%s'", action_name, strerror(errno), errno, fname);
Line 415  static size_t get_dir(char* fname, size_ Line 397  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 428  static bool entry_readable(char* fname, Line 422  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 445  static void rmdir(const String& file_spe Line 439  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 491  void file_move(const String& old_spec, c Line 485  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 540  bool file_stat(const String& file_spec, Line 521  bool file_stat(const String& file_spec,
         return true;          return true;
 }  }
   
 size_t check_file_size(uint64_t size, const String& file_spec){  size_t check_file_size(uint64_t size, const String* file_spec){
         if(size > pa_file_size_limit)          if(size > (uint64_t)pa_file_size_limit)
                 throw Exception(PARSER_RUNTIME, &file_spec, "content size of %.15g bytes exceeds the limit (%.15g bytes)", (double)size, (double)pa_file_size_limit);                  throw Exception(PARSER_RUNTIME, file_spec, "content size of %.15g bytes exceeds the limit (%.15g bytes)", (double)size, (double)pa_file_size_limit);
         return (size_t)size;          return (size_t)size;
 }  }
   
Line 575  const char* capitalize(const char* s){ Line 556  const char* capitalize(const char* s){
         return (const char*)result;          return (const char*)result;
 }  }
   
 char *str_lower(const char *s, size_t helper_length){  char *str_lower(const char *s, size_t length){
         char *result=pa_strdup(s, helper_length);          char *result=pa_strdup(s, length);
         for(char* c=result; *c; c++)          for(char* c=result; *c; c++)
                 *c=(char)tolower((unsigned char)*c);                  *c=(char)tolower((unsigned char)*c);
         return result;          return result;
 }  }
   
 char *str_upper(const char *s, size_t helper_length){  char *str_upper(const char *s, size_t length){
         char *result=pa_strdup(s, helper_length);          char *result=pa_strdup(s, length);
         for(char* c=result; *c; c++)          for(char* c=result; *c; c++)
                 *c=(char)toupper((unsigned char)*c);                  *c=(char)toupper((unsigned char)*c);
         return result;          return result;
Line 660  char* rsplit(char* string, char delim) { Line 641  char* rsplit(char* string, char delim) {
                         return v+1;                          return v+1;
                 }                  }
         }          }
         return NULL;              return NULL;
   }
   
   void pa_strncpy(char *dst, const char *src, size_t n){
           size_t left = n;
   
           if (left != 0 && src) {
                   while (--left != 0) {
                           if ((*dst++ = *src++) == '\0')
                                   return;
                   }
           }
           if (n != 0)
                   *dst = '\0';
 }  }
   
   #define STRCAT_STEP(str, len) if(str) { memcpy(ptr, str, len); ptr += len; }
   
   char *pa_strcat(const char *a, const char *b, const char *c) {
           size_t len_a = a ? strlen(a) : 0;
           size_t len_b = b ? strlen(b) : 0;
           size_t len_c = c ? strlen(c) : 0;
           char *result=new(PointerFreeGC) char[len_a + len_b + len_c +1/*0*/];
           char *ptr=result;
           STRCAT_STEP(a, len_a);
           STRCAT_STEP(b, len_b);
           STRCAT_STEP(c, len_c);
           *ptr='\0';
           return result;
   }
   
   const char *pa_filename(const char *path){
           if(!path)
                   return NULL;
           for(const char *c = path + strlen(path) - 1; c >= path; c--) {
                   if(*c == '/' || *c == '\\')
                           return c+1;
           }
           return path;
   }
   
 // format: %[flags][width][.precision]type      http://msdn.microsoft.com/ru-ru/library/56e442dc(en-us,VS.80).aspx  // format: %[flags][width][.precision]type      http://msdn.microsoft.com/ru-ru/library/56e442dc(en-us,VS.80).aspx
 //              flags: '-', '+', ' ', '#', '0'          http://msdn.microsoft.com/ru-ru/library/8aky45ct(en-us,VS.80).aspx  //              flags: '-', '+', ' ', '#', '0'          http://msdn.microsoft.com/ru-ru/library/8aky45ct(en-us,VS.80).aspx
Line 728  FormatType format_type(const char* fmt){ Line 746  FormatType format_type(const char* fmt){
 }  }
   
   
 const char* format(double value, const char* fmt) {  const char* format_double(double value, const char* fmt) {
         char local_buf[MAX_NUMBER];          char local_buf[MAX_NUMBER];
         int size=-1;          int size=-1;
   
         if(fmt && strlen(fmt)){          if(fmt && strlen(fmt)){
                 switch(format_type(fmt)){                  switch(format_type(fmt)){
                         case FormatDouble:                          case FormatDouble:
                                 size=snprintf(local_buf, sizeof(local_buf), fmt, value);                                   size=snprintf(local_buf, sizeof(local_buf), fmt, value);
                                 break;  
                         case FormatInt:  
                                 size=snprintf(local_buf, sizeof(local_buf), fmt, (int)value);   
                                 break;                                  break;
                         case FormatUInt:                          case FormatUInt:
                                 size=snprintf(local_buf, sizeof(local_buf), fmt, (uint)value);                                   if(value >= 0){ // on Apple M1 (uint)<negative value> is 0
                                           size=snprintf(local_buf, sizeof(local_buf), fmt, clip2uint(value));
                                           break;
                                   }
                           case FormatInt:
                                   size=snprintf(local_buf, sizeof(local_buf), fmt, clip2int(value));
                                 break;                                  break;
                         case FormatInvalid:                          case FormatInvalid:
                                 throw Exception(PARSER_RUNTIME, 0, "Incorrect format string '%s' was specified.", fmt);                                  throw Exception(PARSER_RUNTIME, 0, "Incorrect format string '%s' was specified.", fmt);
                 }                  }
         } else          } else
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                  return pa_itoa(clip2int(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 occurred white executing snprintf with format string '%s'.", fmt);                  throw Exception(PARSER_RUNTIME, 0, "Error occurred white executing snprintf with format string '%s'.", fmt);
Line 760  size_t stdout_write(const void *buf, siz Line 780  size_t stdout_write(const void *buf, siz
 #ifdef WIN32  #ifdef WIN32
         size_t to_write = size;          size_t to_write = size;
         do{          do{
                 int chunk_written=fwrite(buf, 1, min((size_t)8*0x400, size), stdout);                   int chunk_written=fwrite(buf, 1, min((size_t)8*0x400, size), stdout);
                 if(chunk_written<=0)                  if(chunk_written<=0)
                         break;                          break;
                 size-=chunk_written;                  size-=chunk_written;
                 buf=((const char*)buf)+chunk_written;                  buf=((const char*)buf)+chunk_written;
         } while(size>0);           } while(size>0);
   
           fflush(stdout);
         return to_write-size;          return to_write-size;
 #else  #else
         return fwrite(buf, 1, size, stdout);           size_t result=fwrite(buf, 1, size, stdout);
           fflush(stdout);
           return result;
 #endif  #endif
 }  }
   
Line 783  enum EscapeState { Line 806  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 js){  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;          XMLByte* dst=(XMLByte *)s;
         EscapeState escapeState=EscapeRest;          EscapeState escapeState=EscapeRest;
         uint escapedValue=0;          uint escapedValue=0;
         int srcPos=0;          int srcPos=0;
Line 829  char* unescape_chars(const char* cp, int Line 852  char* unescape_chars(const char* cp, int
                                                 escapedValue=(escapedValue << 4) + hex_value[c];                                                  escapedValue=(escapedValue << 4) + hex_value[c];
                                                 if(++jsCnt==4){                                                  if(++jsCnt==4){
                                                         // transcode utf8 char to client charset (we can lost some chars here)                                                          // transcode utf8 char to client charset (we can lost some chars here)
                                                         charset->store_Char((XMLByte*&)dst, (XMLCh)escapedValue, '?');                                                          charset->store_Char(dst, (XMLCh)escapedValue, '?');
                                                         escapeState=EscapeRest;                                                          escapeState=EscapeRest;
                                                 }                                                  }
                                         } else {                                          } else {
Line 881  size_t strpos(const char *str, const cha Line 904  size_t strpos(const char *str, const cha
         return (p==0)?STRING_NOT_FOUND:p-str;          return (p==0)?STRING_NOT_FOUND:p-str;
 }  }
   
 int remove_crlf(char* start, char* end) {  size_t remove_crlf(char* start, char* end) {
         char* from=start;          char* from=start;
         char* to=start;          char* to=start;
         bool skip=false;          bool skip=false;
Line 927  const char* hex_string(unsigned char* by Line 950  const char* hex_string(unsigned char* by
         return bytes_hex;          return bytes_hex;
 }  }
   
 /* mime64 functions are from libgmime[http://spruce.sourceforge.net/gmime/] lib */  ssize_t file_block_read(const int f, void* buffer, const size_t size){
 /*          ssize_t nCount = read(f, buffer, size);
  *  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 nCount = read(f, buffer, size);  
         if (nCount < 0)          if (nCount < 0)
                 throw Exception("file.read", 0, "read failed: %s (%d)", strerror(errno), errno);                   throw Exception("file.read", 0, "read failed: %s (%d)", strerror(errno), errno); 
         return nCount;          return nCount;
Removed from v.1.305  
changed lines
  Added in v.1.336

E-mail: