[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.239 and 1.257

version 1.239, 2009/01/12 07:15:45 version 1.257, 2010/04/19 19:35:55
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001-2005 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
  * BASE64 part   * BASE64 part
Line 36  static const char * const IDENT_COMMON_C Line 36  static const char * const IDENT_COMMON_C
 #include "pa_http.h"  #include "pa_http.h"
 #include "pa_request_charsets.h"  #include "pa_request_charsets.h"
 #include "pcre.h"  #include "pcre.h"
   #include "pa_request.h"
   
 // some maybe-undefined constants  // some maybe-undefined constants
   
Line 66  const String file_status_name(FILE_STATU Line 67  const String file_status_name(FILE_STATU
   
 // functions  // functions
   
   bool capitalized(const char* s){
           bool upper=true;
           for(const char* c=s; *c; c++){
                   if(*c != (upper ? toupper((unsigned char)*c) : tolower((unsigned char)*c)))
                           return false;
                   upper=strchr("-_ ", *c) != 0;
           }
           return true;
   }
   
   const char* capitalize(const char* s){
           if(!s || capitalized(s))
                   return s;
   
           char* result=pa_strdup(s);
           if(result){
                   bool upper=true;
                   for(char* c=result; *c; c++){
                           *c=upper ? (char)toupper((unsigned char)*c) : (char)tolower((unsigned char)*c);
                           upper=strchr("-_ ", *c) != 0;
                   }
           }
           return (const char*)result;
   }
   
 void fix_line_breaks(char *str, size_t& length) {  void fix_line_breaks(char *str, size_t& length) {
         //_asm int 3;          //_asm int 3;
         const char* const eob=str+length;          const char* const eob=str+length;
Line 102  char* file_read_text(Request_charsets& c Line 128  char* file_read_text(Request_charsets& c
         return file.success?file.str:0;          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 139  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 149  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;
         }          }
 }  }
   
 File_read_result file_read(Request_charsets& charsets, const String& file_spec,   File_read_result file_read(Request_charsets& charsets, const String& file_spec, 
                         bool as_text, HashStringValue *params,                          bool as_text, HashStringValue *params,
                         bool fail_on_read_problem,                          bool fail_on_read_problem,
                         char* buf, size_t offset, size_t count, bool transcode_text_result) {                          char* buf, size_t offset, size_t count, bool transcode_text_result) {
         File_read_result result={false, 0, 0, 0};          File_read_result result={false, 0, 0, 0};
         if(file_spec.starts_with("http://")) {          if(params){
                 if(offset || count)                  int valid_options=pa_get_valid_file_options_count(*params);
                   if(valid_options!=params->count())
                         throw Exception(PARSER_RUNTIME,                          throw Exception(PARSER_RUNTIME,
                                 0,                                  0,
                                 "offset and load options are not supported for HTTP:// file load");                                  INVALID_OPTION_PASSED);
           }
   
                 // fail on read problem          File_read_action_info info={&result.str, &result.length, buf, offset, count}; 
                 File_read_http_result http=pa_internal_file_read_http(charsets, file_spec, as_text, params, transcode_text_result);  
                 result.success=true;  
                 result.str=http.str;  
                 result.length=http.length;  
                 result.headers=http.headers;   
         } else {  
                 if(params){  
                         int valid_options=pa_get_valid_file_options_count(*params);  
                         if(valid_options!=params->count())  
                                 throw Exception(PARSER_RUNTIME,  
                                         0,  
                                         "invalid option passed");  
                 }  
   
                 File_read_action_info info={&result.str, &result.length,          result.success=file_read_action_under_lock(file_spec, 
                         buf, offset, count};                   "read", file_read_action, &info, 
                 result.success=file_read_action_under_lock(file_spec,                   as_text, fail_on_read_problem); 
                         "read", file_read_action, &info,   
                         as_text, fail_on_read_problem);   
   
                 if(as_text && result.success){          if(as_text){
                   if(result.success){
                         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: EF BB BF  (BOM code)                                  // skip UTF-8 signature (BOM code)
                                 result.str+=3;                                  result.str+=3;
                                 result.length-=3;                                  result.length-=3;
                         }                          }
                                                   
                         if(result.length && transcode_text_result && params){ // must be checked because transcode returns CONST string in case length==0, which contradicts hacking few lines below                          if(result.length && transcode_text_result && params){ // must be checked because transcode returns CONST string in case length==0, which contradicts hacking few lines below
                                 if( Value* vcharset_name=params->get(PA_CHARSET_NAME) ){                                  if(Value* vcharset_name=params->get(PA_CHARSET_NAME)){
                                         Charset asked_charset=::charsets.get(vcharset_name->as_string().                                          Charset asked_charset=::charsets.get(vcharset_name->as_string().
                                                 change_case(charsets.source(), String::CC_UPPER));                                                  change_case(charsets.source(), String::CC_UPPER));
   
Line 207  File_read_result file_read(Request_chars Line 232  File_read_result file_read(Request_chars
                                 }                                  }
                         }                          }
                 }                  }
                   if(result.length)
                           fix_line_breaks(result.str, result.length);
         }          }
           
         if(as_text && result.length)  
                 fix_line_breaks(result.str, result.length);  
   
         return result;          return result;
 }  }
   
 #ifdef PA_SAFE_MODE   File_read_result file_load(Request& r, const String& file_spec, 
                           bool as_text, HashStringValue *params,
                           bool fail_on_read_problem,
                           char* buf, size_t offset, size_t count, bool transcode_text_result) {
   
           File_read_result result={false, 0, 0, 0};
           if(file_spec.starts_with("http://")) {
                   if(offset || count)
                           throw Exception(PARSER_RUNTIME,
                                   0,
                                   "offset and load options are not supported for HTTP:// file load");
   
                   // fail on read problem
                   File_read_http_result http=pa_internal_file_read_http(r, file_spec, as_text, params, transcode_text_result);
                   result.success=true;
                   result.str=http.str;
                   result.length=http.length;
                   result.headers=http.headers; 
           } else
                   result=
                           file_read(r.charsets, file_spec, as_text, params, fail_on_read_problem, buf, offset, count, transcode_text_result);
   
           return result;
   }
   
   
 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) { 
   #ifdef PA_SAFE_MODE 
         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 229  void check_safe_mode(struct stat finfo, Line 279  void check_safe_mode(struct stat finfo,
                                 fname,                                   fname, 
                                 finfo.st_uid, geteuid(),                                   finfo.st_uid, geteuid(), 
                                 finfo.st_gid, getegid());                                   finfo.st_gid, getegid()); 
   #endif
 }   } 
 #endif   
   
 bool file_read_action_under_lock(const String& file_spec,   bool file_read_action_under_lock(const String& file_spec, 
                                 const char* action_name, File_read_action action, void *context,                                   const char* action_name, File_read_action action, void *context, 
                                 bool as_text,                                   bool as_text, 
                                 bool fail_on_read_problem) {                                  bool fail_on_read_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         int f;          int f;
   
         // first open, next stat:          // first open, next stat:
Line 257  bool file_read_action_under_lock(const S Line 308  bool file_read_action_under_lock(const S
                                                         strerror(errno), errno, fname);                                                          strerror(errno), errno, fname);
   
                         struct stat finfo;                          struct stat finfo;
                         if(stat(fname, &finfo)!=0)                          if(fstat(f, &finfo)!=0)
                                 throw Exception("file.missing", // hardly possible: we just opened it OK                                  throw Exception("file.missing", // hardly possible: we just opened it OK
                                         &file_spec,                                           &file_spec, 
                                         "stat failed: %s (%d), actual filename '%s'",                                           "stat failed: %s (%d), actual filename '%s'", 
                                                 strerror(errno), errno, fname);                                                  strerror(errno), errno, fname);
   
 #ifdef PA_SAFE_MODE  
                         check_safe_mode(finfo, file_spec, fname);                          check_safe_mode(finfo, file_spec, fname);
 #endif  
   
                         action(finfo, f, file_spec, fname, as_text, context);                           action(finfo, f, file_spec, fname, as_text, context); 
                 } catch(...) {                  } catch(...) {
Line 279  bool file_read_action_under_lock(const S Line 328  bool file_read_action_under_lock(const S
                 return true;                  return true;
         } else {          } else {
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
                         throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                           throw Exception(errno==EACCES?"file.access"
                                                           :(errno==ENOENT || errno==ENOTDIR || errno==ENODEV)?"file.missing":0, 
                                 &file_spec,                                   &file_spec, 
                                 "%s failed: %s (%d), actual filename '%s'",                                   "%s failed: %s (%d), actual filename '%s'", 
                                         action_name, strerror(errno), errno, fname);                                          action_name, strerror(errno), errno, fname);
Line 291  void create_dir_for_file(const String& f Line 341  void create_dir_for_file(const String& f
         size_t pos_after=1;          size_t pos_after=1;
         size_t pos_before;          size_t pos_before;
         while((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND) {          while((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND) {
                 mkdir(file_spec.mid(0, pos_before).cstr(String::L_FILE_SPEC), 0775);                   mkdir(file_spec.mid(0, pos_before).taint_cstr(String::L_FILE_SPEC), 0775); 
                 pos_after=pos_before+1;                  pos_after=pos_before+1;
         }          }
 }  }
Line 305  bool file_write_action_under_lock( Line 355  bool file_write_action_under_lock(
                                 bool do_append,                                   bool do_append, 
                                 bool do_block,                                   bool do_block, 
                                 bool fail_on_lock_problem) {                                  bool fail_on_lock_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         int f;          int f;
         if(access(fname, W_OK)!=0) // no          if(access(fname, W_OK)!=0) // no
                 create_dir_for_file(file_spec);                   create_dir_for_file(file_spec); 
Line 326  bool file_write_action_under_lock( Line 376  bool file_write_action_under_lock(
                 }                  }
   
                 try {                  try {
                         action(f, context);   #if (defined(HAVE_FCHMOD) && defined(PA_SAFE_MODE))
                           struct stat finfo;
                           if(fstat(f, &finfo)==0 && finfo.st_mode & 0111)
                                   fchmod(f, finfo.st_mode & 0666/*clear executable bits*/); // backward: ignore errors if any
   #endif
                           action(f, context);
                 } catch(...) {                  } catch(...) {
 #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
                         if(!do_append)                          if(!do_append)
Line 352  bool file_write_action_under_lock( Line 407  bool file_write_action_under_lock(
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_write_action_info {  struct File_write_action_info {
         const char* str; size_t length;          const char* str;
           size_t length;
 };   }; 
 #endif  #endif
 static void file_write_action(int f, void *context) {  static void file_write_action(int f, void *context) {
Line 366  static void file_write_action(int f, voi Line 422  static void file_write_action(int f, voi
         }          }
 }  }
 void file_write(  void file_write(
                                 const String& file_spec,                                   Request_charsets& charsets,
                                 const char* data, size_t size,                                   const String& file_spec,
                                   const char* data,
                                   size_t size, 
                                 bool as_text,                                   bool as_text, 
                                 bool do_append) {                                  bool do_append,
                                   Charset* asked_charset) {
   
           if(as_text && asked_charset){
                   String::C body=String::C(data, size);
                   body=Charset::transcode(body, charsets.source(), *asked_charset);
                   data=body.str;
                   size=body.length;
           };
   
         File_write_action_info info={data, size};           File_write_action_info info={data, size}; 
   
         file_write_action_under_lock(          file_write_action_under_lock(
Line 387  static void rmdir(const String& file_spe Line 454  static void rmdir(const String& file_spe
         if((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND)          if((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND)
                 rmdir(file_spec, pos_before+1);                   rmdir(file_spec, pos_before+1); 
                   
         rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::L_FILE_SPEC));           rmdir(file_spec.mid(0, pos_after-1/* / */).taint_cstr(String::L_FILE_SPEC)); 
 }  }
   
 bool file_delete(const String& file_spec, bool fail_on_problem) {  bool file_delete(const String& file_spec, bool fail_on_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         if(unlink(fname)!=0)          if(unlink(fname)!=0)
                 if(fail_on_problem)                  if(fail_on_problem)
                         throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                           throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0, 
Line 406  bool file_delete(const String& file_spec Line 473  bool file_delete(const String& file_spec
 }  }
   
 void file_move(const String& old_spec, const String& new_spec) {  void file_move(const String& old_spec, const String& new_spec) {
         const char* old_spec_cstr=old_spec.cstr(String::L_FILE_SPEC);           const char* old_spec_cstr=old_spec.taint_cstr(String::L_FILE_SPEC); 
         const char* new_spec_cstr=new_spec.cstr(String::L_FILE_SPEC);           const char* new_spec_cstr=new_spec.taint_cstr(String::L_FILE_SPEC); 
                   
         create_dir_for_file(new_spec);           create_dir_for_file(new_spec); 
   
Line 430  bool entry_exists(const char* fname, str Line 497  bool entry_exists(const char* fname, str
 }  }
   
 bool entry_exists(const String& file_spec) {  bool entry_exists(const String& file_spec) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         return entry_exists(fname, 0);           return entry_exists(fname, 0); 
 }  }
   
 static bool entry_readable(const String& file_spec, bool need_dir) {  static bool entry_readable(const String& file_spec, bool need_dir) {
         char* fname=file_spec.cstrm(String::L_FILE_SPEC);           char* fname=file_spec.taint_cstrm(String::L_FILE_SPEC); 
         if(need_dir) {          if(need_dir) {
                 size_t size=strlen(fname);                   size_t size=strlen(fname); 
                 while(size) {                  while(size) {
Line 470  const String* file_exist(const String& p Line 537  const String* file_exist(const String& p
 }  }
   
 bool file_executable(const String& file_spec) {  bool file_executable(const String& file_spec) {
         return access(file_spec.cstr(String::L_FILE_SPEC), X_OK)==0;          return access(file_spec.taint_cstr(String::L_FILE_SPEC), X_OK)==0;
 }  }
   
 bool file_stat(const String& file_spec,   bool file_stat(const String& file_spec, 
Line 479  bool file_stat(const String& file_spec, Line 546  bool file_stat(const String& file_spec,
                         time_t& rmtime,                          time_t& rmtime,
                         time_t& rctime,                          time_t& rctime,
                         bool fail_on_read_problem) {                          bool fail_on_read_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         struct stat finfo;          struct stat finfo;
         if(stat(fname, &finfo)!=0)          if(stat(fname, &finfo)!=0)
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
Line 772  size_t strpos(const char *str, const cha Line 839  size_t strpos(const char *str, const cha
 // content-type: xxx; charset="WE-NEED-THIS";  // content-type: xxx; charset="WE-NEED-THIS";
 Charset* detect_charset(const char* content_type){  Charset* detect_charset(const char* content_type){
         if(content_type){          if(content_type){
                 size_t len=strlen(content_type);                  char* CONTENT_TYPE=pa_strdup(content_type);
                 char* CONTENT_TYPE=new(PointerFreeGC) char[len+1];  
                 memcpy(CONTENT_TYPE, content_type, len);  
                 for(char *p=CONTENT_TYPE; *p; p++)                  for(char *p=CONTENT_TYPE; *p; p++)
                         *p=(char)toupper((unsigned char)*p);                          *p=(char)toupper((unsigned char)*p);
   
Line 789  Charset* detect_charset(const char* cont Line 855  Charset* detect_charset(const char* cont
                         if(!end)                          if(!end)
                                 end=(char*)strchr(begin, ';');                                  end=(char*)strchr(begin, ';');
   
                         size_t len;                          if(end)
                         if(end){  
                                 *end=0; // terminator                                  *end=0; // terminator
                                 len=end-begin;  
                         } else {  
                                 len=strlen(begin);  
                         }  
   
                         String::Body NAME=String::Body(begin, len);  
                         return &charsets.get(NAME);  
                 }  
         }  
         return 0;  
 }  
   
 Charset* detect_charset(Charset& source_charset, const String& content_type){                          return *begin?&charsets.get(begin):0;
         const String& CONTENT_TYPE=content_type.change_case(source_charset, String::CC_UPPER);  
         size_t begin=CONTENT_TYPE.pos("CHARSET=");  
         if(begin!=STRING_NOT_FOUND) {  
                 begin+=8; // skip "CHARSET="  
                 size_t end=STRING_NOT_FOUND;  
   
                 if(CONTENT_TYPE.pos('"', begin)==begin){  
                         begin++;  
                         end=CONTENT_TYPE.pos('"', begin);  
                 } else if(CONTENT_TYPE.pos('\'', begin)==begin){  
                         begin++;  
                         end=CONTENT_TYPE.pos('\'', begin);  
                 }                  }
   
                 if(end==STRING_NOT_FOUND)  
                         end=CONTENT_TYPE.pos(';', begin);  
   
                 if(end==STRING_NOT_FOUND)  
                         end=CONTENT_TYPE.length();  
   
                 const String::Body NAME=CONTENT_TYPE.mid(begin, end);  
                 return &charsets.get(NAME);  
         }          }
         return 0;          return 0;
 }  }
Line 933  int __vsnprintf(char* b, size_t s, const Line 966  int __vsnprintf(char* b, size_t s, const
   
 int __snprintf(char* b, size_t s, const char* f, ...) {  int __snprintf(char* b, size_t s, const char* f, ...) {
         va_list l;          va_list l;
     va_start(l, f);           va_start(l, f); 
     int r=__vsnprintf(b, s, f, l);           int r=__vsnprintf(b, s, f, l); 
     va_end(l);           va_end(l); 
         return r;          return r;
 }  }
   
Line 979  static char *base64_alphabet = Line 1012  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 1016  g_mime_utils_base64_encode_step (const u Line 1052  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 1182  g_mime_utils_base64_decode_step (const u Line 1218  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 1258  int file_block_read(const int f, unsigne Line 1296  int file_block_read(const int f, unsigne
 const unsigned long pa_crc32(const char *in, size_t in_size){  const unsigned long pa_crc32(const char *in, size_t in_size){
         unsigned long crc32=0xFFFFFFFF;          unsigned long crc32=0xFFFFFFFF;
   
                 InitCrc32Table();          InitCrc32Table();
         for(size_t i = 0; i<in_size; i++)          for(size_t i = 0; i<in_size; i++)
                 CalcCrc32(in[i], crc32);                  CalcCrc32(in[i], crc32);
   
Line 1288  static void file_crc32_file_action( Line 1326  static void file_crc32_file_action(
         }          }
 }  }
   
 char* print_pcre_exec_error_text(int exec_result){  
         switch(exec_result){  
                 case PCRE_ERROR_BADUTF8:  
                         return "validation of UTF-8 string failed while pcre_exec (%d).";  
                         break;  
                 default:  
                         return "regular expression execute error (%d)";  
         }  
 }  
   
Removed from v.1.239  
changed lines
  Added in v.1.257

E-mail: