[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.143.2.3 and 1.143.2.6

version 1.143.2.3, 2003/01/24 14:36:10 version 1.143.2.6, 2003/01/27 17:17:06
Line 12  static const char* IDENT_COMMON_C="$Date Line 12  static const char* IDENT_COMMON_C="$Date
 #include "pa_globals.h"  #include "pa_globals.h"
 #include "pa_hash.h"  #include "pa_hash.h"
 #include "pa_vstring.h"  #include "pa_vstring.h"
   #include "pa_vint.h"
   
 #ifdef WIN32  #ifdef WIN32
 #       include <windows.h>  #       include <windows.h>
Line 118  char* file_read_text(Pool& pool, Charset Line 119  char* file_read_text(Pool& pool, Charset
                                          ConstStringPtr file_spec,                                            ConstStringPtr file_spec, 
                                          bool fail_on_read_problem,                                           bool fail_on_read_problem,
                                          HashStringValue *params, HashStringValue** out_fields) {                                           HashStringValue *params, HashStringValue** out_fields) {
         void *result;  size_t size;          char *result;  size_t size;
         return file_read(pool, charset, file_spec, result, size, true, params, out_fields, fail_on_read_problem)?          File_read_result file_read_result=file_read(pool, charset, file_spec, result, size, true, params, out_fields, fail_on_read_problem);
                 (char *)result:0;          return file_read_result.success?result:0;
 }  }
   
 //http request stuff  //http request stuff
Line 258  struct Http_pass_header_info { Line 259  struct Http_pass_header_info {
 static void http_pass_header(HashStringValue::key_type key, HashStringValue::value_type value,   static void http_pass_header(HashStringValue::key_type key, HashStringValue::value_type value, 
                                                          Http_pass_header_info *info) {                                                           Http_pass_header_info *info) {
     *(info->request)<<*key<<": "      *(info->request)<<*key<<": "
                 << *attributed_meaning_to_string(value, String::UL_HTTP_HEADER, false)                  << attributed_meaning_to_string(value, String::UL_HTTP_HEADER, false)
                 <<"\n";                   <<"\n"; 
                   
         if(*key->change_case(*info->pool, *info->charset, String::CC_UPPER)=="USER-AGENT")          if(*key->change_case(*info->pool, *info->charset, String::CC_UPPER)=="USER-AGENT")
                 info->user_agent_specified=true;                  info->user_agent_specified=true;
 }  }
 static HashStringValuePtr file_read_http(Pool& pool, Charset& charset, const String& file_spec,   static HashStringValuePtr file_read_http(Pool& pool, Charset& charset, ConstStringPtr file_spec, 
                                         char*& data, size_t& data_size,                                           char*& data, size_t& data_size, 
                                         HashStringValue *options=0, bool return_outfields=false) {                                          HashStringValue *options=0, bool return_outfields=false) {
         HashStringValuePtr result(0);          HashStringValuePtr result(0);
         char host[MAX_STRING];           char host[MAX_STRING]; 
         const char* uri;           const char* uri; 
         int port;          int port;
         ConstCharPtr method(0);          CharPtr method(0);
         int timeout=2;          int timeout=2;
         bool fail_on_status_ne_200=true;          bool fail_on_status_ne_200=true;
         ValuePtr vheaders(0);          ValuePtr vheaders(0);
   
         StringPtr connect_string(new String());          StringPtr connect_string(new String());
         // not in ^sql{... UL_SQL ...} spirit, but closer to ^file::load one          // not in ^sql{... UL_SQL ...} spirit, but closer to ^file::load one
         connect_string->append(file_spec, String::UL_URI); // tainted pieces -> URI pieces          connect_string->append(*file_spec, String::UL_URI); // tainted pieces -> URI pieces
   
         CharPtr connect_string_cstr=connect_string->cstr(String::UL_UNSPECIFIED);           CharPtr connect_string_cstr=connect_string->cstr(String::UL_UNSPECIFIED); 
         const char *current=connect_string_cstr.get();          const char *current=connect_string_cstr;
         if(strncmp(current, "http://", 7)!=0)          if(strncmp(current, "http://", 7)!=0)
                 throw Exception(0,                   throw Exception(0, 
                         connect_string,                           connect_string, 
Line 322  static HashStringValuePtr file_read_http Line 323  static HashStringValuePtr file_read_http
         //making request          //making request
         String request;          String request;
         if(method)          if(method)
                 request<<method.get();                  request<<method;
         else          else
                 request<<"GET";                  request<<"GET";
         request<< " "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n";           request<< " "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n"; 
Line 343  static HashStringValuePtr file_read_http Line 344  static HashStringValuePtr file_read_http
                   
         //sending request          //sending request
         String response;          String response;
         ConstCharPtr request_cstr=request.cstr(String::UL_UNSPECIFIED);          CharPtr request_cstr=request.cstr(String::UL_UNSPECIFIED);
         int status_code=http_request(pool, response,          int status_code=http_request(pool, response,
                 connect_string, host, port, request_cstr.get(),                   connect_string, host, port, request_cstr, 
                 timeout, fail_on_status_ne_200);                   timeout, fail_on_status_ne_200); 
                   
         //processing results              //processing results    
Line 380  static HashStringValuePtr file_read_http Line 381  static HashStringValuePtr file_read_http
         data=new(pool) char[data_size=body->size()];          data=new(pool) char[data_size=body->size()];
         body->store_to(data, String::UL_AS_IS);          body->store_to(data, String::UL_AS_IS);
         if(return_outfields) {          if(return_outfields) {
                 headers.put(file_status_name, VIntPtr<new VInt(pool, status_code)>);                   headers->put(file_status_name, ValuePtr(new VInt(status_code))); 
                 *out_fields=&headers;                  return headers;
         }          } else
                   return HashStringValuePtr(0);
         return result;  
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_read_action_info {  struct File_read_action_info {
         void **data; size_t *data_size;          char **data; size_t *data_size;
 };   }; 
 #endif  #endif
 static void file_read_action(  static void file_read_action(Pool& pool,
                                                          struct stat& finfo,                                                            struct stat& finfo, 
                                                          int f,                                                            int f, 
                                                          const String& file_spec, const char* fname, bool as_text,                                                            ConstStringPtr file_spec, const char* fname, bool as_text, 
                                                          void *context) {                                                           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); 
         if(size_t to_read_size=(size_t)finfo.st_size) {           if(size_t to_read_size=(size_t)finfo.st_size) { 
                 *info.data=pool.malloc(to_read_size+(as_text?1:0), 3);                   *info.data=pool.malloc(to_read_size+(as_text?1:0)); 
                 *info.data_size=(size_t)read(f, *info.data, to_read_size);                   *info.data_size=(size_t)read(f, *info.data, to_read_size); 
   
                 if(ssize_t(*info.data_size)<0 || *info.data_size>to_read_size)                  if(ssize_t(*info.data_size)<0 || *info.data_size>to_read_size)
                         throw Exception(0,                           throw Exception(0, 
                                 &file_spec,                                   file_spec, 
                                 "read failed: actually read %lu bytes count not in [0..%lu] valid range",                                   "read failed: actually read %lu bytes count not in [0..%lu] valid range", 
                                         *info.data_size, to_read_size);                                           *info.data_size, to_read_size); 
         } else { // empty file          } else { // empty file
Line 417  static void file_read_action( Line 417  static void file_read_action(
                 return;                  return;
         }          }
 }  }
 bool file_read(ConstStringPtr file_spec,   File_read_result file_read(Pool& pool, Charset& charset, ConstStringPtr file_spec, 
                            void*& data, size_t& data_size,                              char*& data, size_t& data_size, 
                            bool as_text, HashStringValue *params, HashStringValue** out_fields,                              bool as_text, HashStringValue *params, HashStringValue** out_fields, 
                            bool fail_on_read_problem) {                             bool fail_on_read_problem) {
         bool result;          File_read_result result;
         if(file_spec.starts_with("http://", 7)) {          if(file_spec->starts_with("http://", 7)) {
                 // fail on read problem                  // fail on read problem
                 file_read_http(pool, file_spec, data, data_size, params, out_fields);                   result.fields=file_read_http(pool, charset, file_spec, data, data_size, params); 
                 result=true;                  result.success=true;
         } else {          } else {
                 File_read_action_info info={&data, &data_size};                   File_read_action_info info={&data, &data_size}; 
                 result=file_read_action_under_lock(pool, file_spec,                   result.success=file_read_action_under_lock(pool, file_spec, 
                         "read", file_read_action, &info,                           "read", file_read_action, &info, 
                         as_text, fail_on_read_problem);                           as_text, fail_on_read_problem); 
         }          }
   
         if(result && as_text) {          if(result.success && as_text) {
                 // UTF-8 signature: EF BB BF                  // UTF-8 signature: EF BB BF
                 if(data_size>=3) {                  if(data_size>=3) {
                         char *in=(char *)data;                          char *in=(char *)data;
Line 451  bool file_read(ConstStringPtr file_spec, Line 451  bool file_read(ConstStringPtr file_spec,
         return result;          return result;
 }  }
   
 bool file_read_action_under_lock(const String& file_spec,   bool file_read_action_under_lock(Pool& pool, ConstStringPtr 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::UL_FILE_SPEC);           CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         int f;          int f;
   
         // first open, next stat:          // first open, next stat:
Line 471  bool file_read_action_under_lock(const S Line 471  bool file_read_action_under_lock(const S
                 try {                  try {
                         if(lock_shared_blocking(f)!=0)                          if(lock_shared_blocking(f)!=0)
                                 throw Exception("file.lock",                                   throw Exception("file.lock", 
                                                 &file_spec,                                                   file_spec, 
                                                 "shared lock failed: %s (%d), actual filename '%s'",                                                   "shared lock failed: %s (%d), actual filename '%s'", 
                                                         strerror(errno), errno, fname);                                                           strerror(errno), errno, fname); 
   
                         struct stat finfo;                          struct stat finfo;
                         if(stat(fname, &finfo)!=0)                          if(stat(fname, &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); 
   
Line 486  bool file_read_action_under_lock(const S Line 486  bool file_read_action_under_lock(const S
                         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", 
                                         &file_spec,                                           file_spec, 
                                         "parser is in safe mode: reading files of foreign group and user disabled [recompile parser with --disable-safe-mode configure option], actual filename '%s'",                                           "parser is in safe mode: reading files of foreign group and user disabled [recompile parser with --disable-safe-mode configure option], actual filename '%s'", 
                                                 fname);                                                   fname); 
 #endif  #endif
Line 504  bool file_read_action_under_lock(const S Line 504  bool file_read_action_under_lock(const S
     } 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?"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); 
                 return false;                  return false;
         }          }
 }  }
   
 static void create_dir_for_file(const String& file_spec) {  static void create_dir_for_file(ConstStringPtr file_spec) {
         size_t pos_after=1;          size_t pos_after=1;
         int pos_before;          int pos_before;
         while((pos_before=file_spec.pos("/", 1, pos_after))>=0) {          while((pos_before=file_spec->pos("/", 1, pos_after))>=0) {
                 mkdir(file_spec.mid(0, pos_before).cstr(String::UL_FILE_SPEC), 0775);                   mkdir(file_spec->mid(0, pos_before)->cstr(String::UL_FILE_SPEC), 0775); 
                 pos_after=pos_before+1;                  pos_after=pos_before+1;
         }          }
 }  }
   
 bool file_write_action_under_lock(  bool file_write_action_under_lock(
                                 const String& file_spec,                                   ConstStringPtr file_spec, 
                                 const char* action_name, File_write_action action, void *context,                                   const char* action_name, File_write_action action, void *context, 
                                 bool as_text,                                   bool as_text, 
                                 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::UL_FILE_SPEC);           CharPtr fname=file_spec->cstr(String::UL_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 538  bool file_write_action_under_lock( Line 538  bool file_write_action_under_lock(
                 |(do_append?O_APPEND:PA_O_TRUNC), 0664))>=0) {                  |(do_append?O_APPEND:PA_O_TRUNC), 0664))>=0) {
                 if((do_block?lock_exclusive_blocking(f):lock_exclusive_nonblocking(f))!=0) {                  if((do_block?lock_exclusive_blocking(f):lock_exclusive_nonblocking(f))!=0) {
                         Exception e("file.lock",                           Exception e("file.lock", 
                                 &file_spec,                                   file_spec, 
                                 "shared lock failed: %s (%d), actual filename '%s'",                                   "shared lock failed: %s (%d), actual filename '%s'", 
                                 strerror(errno), errno, fname);                                   strerror(errno), errno, fname); 
                         close(f);                           close(f); 
Line 566  bool file_write_action_under_lock( Line 566  bool file_write_action_under_lock(
                 return true;                  return true;
         } else          } else
                 throw Exception(errno==EACCES?"file.access":0,                   throw Exception(errno==EACCES?"file.access":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); 
         // here should be nothing, see rethrow above          // here should be nothing, see rethrow above
Line 583  static void file_write_action(int f, voi Line 583  static void file_write_action(int f, voi
                 int written=write(f, info.data, info.size);                   int written=write(f, info.data, info.size); 
                 if(written<0)                  if(written<0)
                         throw Exception(0,                           throw Exception(0, 
                                 0,                                   Exception::undefined_source, 
                                 "write failed: %s (%d)",  strerror(errno), errno);                                   "write failed: %s (%d)",  strerror(errno), errno); 
         }          }
 }  }
 void file_write(  void file_write(
                                 const String& file_spec,                                   ConstStringPtr file_spec, 
                                 const void *data, size_t size,                                   const void *data, size_t size, 
                                 bool as_text,                                   bool as_text, 
                                 bool do_append) {                                  bool do_append) {
         File_write_action_info info={data, size};           File_write_action_info info={data, size}; 
         file_write_action_under_lock(          file_write_action_under_lock(
                                 file_spec,                   file_spec, 
                                 "write", file_write_action, &info,                   "write", file_write_action, &info, 
                                 as_text,                   as_text, 
                                 do_append);                   do_append); 
 }  }
   
 // throws nothing! [this is required in file_move & file_delete]  // throws nothing! [this is required in file_move & file_delete]
 static void rmdir(const String& file_spec, size_t pos_after) {  static void rmdir(ConstStringPtr file_spec, size_t pos_after) {
         int pos_before;          int pos_before;
         if((pos_before=file_spec.pos("/", 1, pos_after))>=0)          if((pos_before=file_spec->pos("/", 1, pos_after))>=0)
                 rmdir(file_spec, pos_before+1);                   rmdir(file_spec, pos_before+1); 
                   
         rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::UL_FILE_SPEC));           rmdir(file_spec->mid(0, pos_after-1/* / */)->cstr(String::UL_FILE_SPEC)); 
 }  }
 bool file_delete(const String& file_spec, bool fail_on_read_problem) {  bool file_delete(ConstStringPtr file_spec, bool fail_on_read_problem) {
         const char* fname=file_spec.cstr(String::UL_FILE_SPEC);           CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         if(unlink(fname)!=0)          if(unlink(fname)!=0)
                 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?"file.missing":0, 
                                 &file_spec,                                   file_spec, 
                                 "unlink failed: %s (%d), actual filename '%s'",                                   "unlink failed: %s (%d), actual filename '%s'", 
                                         strerror(errno), errno, fname);                                           strerror(errno), errno, fname); 
                 else                  else
Line 622  bool file_delete(const String& file_spec Line 622  bool file_delete(const String& file_spec
         rmdir(file_spec, 1);           rmdir(file_spec, 1); 
         return true;          return true;
 }  }
 void file_move(const String& old_spec, const String& new_spec) {  void file_move(ConstStringPtr old_spec, ConstStringPtr new_spec) {
         const char* old_spec_cstr=old_spec.cstr(String::UL_FILE_SPEC);           CharPtr old_spec_cstr=old_spec->cstr(String::UL_FILE_SPEC); 
         const char* new_spec_cstr=new_spec.cstr(String::UL_FILE_SPEC);           CharPtr new_spec_cstr=new_spec->cstr(String::UL_FILE_SPEC); 
                   
         create_dir_for_file(new_spec);           create_dir_for_file(new_spec); 
   
         if(rename(old_spec_cstr, new_spec_cstr)!=0)          if(rename(old_spec_cstr, new_spec_cstr)!=0)
                 throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                   throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0, 
                         &old_spec,                           old_spec, 
                         "rename failed: %s (%d), actual filename '%s' to '%s'",                           "rename failed: %s (%d), actual filename '%s' to '%s'", 
                                 strerror(errno), errno, old_spec_cstr, new_spec_cstr);                                   strerror(errno), errno, old_spec_cstr, new_spec_cstr); 
   
Line 646  bool entry_exists(const char* fname, str Line 646  bool entry_exists(const char* fname, str
         return result;          return result;
 }  }
   
 bool entry_exists(const String& file_spec) {  bool entry_exists(ConstStringPtr file_spec) {
         const char* fname=file_spec.cstr(String::UL_FILE_SPEC);           CharPtr fname=file_spec->cstr(String::UL_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(ConstStringPtr file_spec, bool need_dir) {
     char* fname=file_spec.cstr(String::UL_FILE_SPEC);       CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         if(need_dir) {          if(need_dir) {
                 size_t size=strlen(fname);                   size_t size=strlen(fname); 
                 while(size) {                  while(size) {
Line 670  static bool entry_readable(const String& Line 670  static bool entry_readable(const String&
         }          }
         return false;          return false;
 }  }
 bool file_readable(const String& file_spec) {  bool file_readable(ConstStringPtr file_spec) {
         return entry_readable(file_spec, false);           return entry_readable(file_spec, false); 
 }  }
 bool dir_readable(const String& file_spec) {  bool dir_readable(ConstStringPtr file_spec) {
         return entry_readable(file_spec, true);           return entry_readable(file_spec, true); 
 }  }
 String *file_readable(const String& path, const String& name) {  ConstStringPtr file_readable(ConstStringPtr path, const String& name) {
         String *result=new(path.pool()) String(path);           StringPtr result(new String(*path));
         *result << "/";           *result << "/"; 
         *result << name;          *result << name;
         return file_readable(*result)?result:0;          return file_readable(result)?result:ConstStringPtrZero;
 }  }
 bool file_executable(const String& file_spec) {  bool file_executable(ConstStringPtr file_spec) {
     return access(file_spec.cstr(String::UL_FILE_SPEC), X_OK)==0;      return access(file_spec->cstr(String::UL_FILE_SPEC), X_OK)==0;
 }  }
   
 bool file_stat(const String& file_spec,   bool file_stat(ConstStringPtr file_spec, 
                            size_t& rsize,                              size_t& rsize, 
                            time_t& ratime,                              time_t& ratime, 
                            time_t& rmtime,                              time_t& rmtime, 
                            time_t& rctime,                              time_t& rctime, 
                            bool fail_on_read_problem) {                             bool fail_on_read_problem) {
         Pool& pool=file_spec.pool();           CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC); 
         const char* fname=file_spec.cstr(String::UL_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)
                         throw Exception("file.missing",                           throw Exception("file.missing", 
                                 &file_spec,                                   file_spec, 
                                 "getting file size failed: %s (%d), real filename '%s'",                                   "getting file size failed: %s (%d), real filename '%s'", 
                                         strerror(errno), errno, fname);                                           strerror(errno), errno, fname); 
                 else                  else
Line 752  char* rsplit(char* string, char delim) { Line 751  char* rsplit(char* string, char delim) {
 }  }
   
 /// @todo less stupid type detection  /// @todo less stupid type detection
 char* format(double value, char* fmt) {  const char *format(Pool& pool, double value, char* fmt) {
         char local_buf[MAX_NUMBER];           char local_buf[MAX_NUMBER]; 
         size_t size;          size_t size;
                   
Line 767  char* format(double value, char* fmt) { Line 766  char* format(double value, char* fmt) {
         else          else
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                   size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value); 
                   
         char* pool_buf=(char *)pool.malloc(size+1, 4);           return pool.malloc(local_buf, size+1); 
         memcpy(pool_buf, local_buf, size+1);   
         return pool_buf;  
 }  }
   
 size_t stdout_write(const void *buf, size_t size) {  size_t stdout_write(const void *buf, size_t size) {
Line 788  size_t stdout_write(const void *buf, siz Line 785  size_t stdout_write(const void *buf, siz
 #endif  #endif
 }  }
   
 char* unescape_chars(const char* cp, int len) {  char* unescape_chars(Pool& pool, const char* cp, int len) {
         char* s=(char *)pool.malloc(len + 1, 5);           char* s=pool.malloc(len + 1); 
         enum EscapeState {          enum EscapeState {
                 EscapeRest,                   EscapeRest, 
                 EscapeFirst,                   EscapeFirst, 
Removed from v.1.143.2.3  
changed lines
  Added in v.1.143.2.6

E-mail: