[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.13 and 1.151

version 1.143.2.13, 2003/02/04 10:57:16 version 1.151, 2003/05/30 10:45:37
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001, 2003 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)
 */  */
   
Line 9  static const char* IDENT_COMMON_C="$Date Line 9  static const char* IDENT_COMMON_C="$Date
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_value_includes.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"  #include "pa_vdate.h"
   
 #ifdef CYGWIN  #ifdef WIN32
 #define _GNU_H_WINDOWS32_SOCKETS  #       include <windows.h>
 // for PASCAL  
 #include <windows.h>  
 // SOCKET  
 typedef u_int   SOCKET;  
 int PASCAL closesocket(SOCKET);  
 #else  #else
 #       if defined(WIN32)  #       define closesocket close
 #               include <windows.h>  
 #       else  
 #               define closesocket close  
 #       endif  
 #endif  #endif
   
 // some maybe-undefined constants  // some maybe-undefined constants
Line 124  void fix_line_breaks(char* buf, size_t& Line 115  void fix_line_breaks(char* buf, size_t&
                 memcpy(dest, bol, eob-bol);                   memcpy(dest, bol, eob-bol); 
 }  }
   
 char* file_read_text(Pool& pool, Charset& charset,   char* file_read_text(Pool& pool, const String& file_spec, 
                                          StringPtr file_spec,   
                                          bool fail_on_read_problem,                                           bool fail_on_read_problem,
                                          HashStringValue *params, HashStringValue** out_fields) {                                           Hash *params, Hash** out_fields) {
         char *result;  size_t size;          void *result;  size_t size;
         File_read_result file_read_result=file_read(pool, charset, file_spec, result, size, true, params, out_fields, fail_on_read_problem);          return file_read(pool, 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 150  static bool set_addr(struct sockaddr_in Line 139  static bool set_addr(struct sockaddr_in
     return true;      return true;
 }  }
   
 static int http_read_response(Pool& pool, String& response, int sock, bool fail_on_status_ne_200){  static int http_read_response(String& response, int sock, bool fail_on_status_ne_200){
         int result=0;          const String* status_code=0;
         ssize_t EOLat=0;          ssize_t EOLat=0;
         while(true) {          while(true) {
                 char *buf=(char *)pool.malloc(MAX_STRING);                   char *buf=(char *)response.pool().malloc(MAX_STRING); 
                 ssize_t size=recv(sock, buf, MAX_STRING, 0);                   ssize_t size=recv(sock, buf, MAX_STRING, 0); 
                 if(size<=0)                  if(size<=0)
                         break;                          break;
                 response.APPEND_TAINTED(buf, size, "remote HTTP server response", 0);                   response.APPEND_TAINTED(buf, size, "remote HTTP server response", 0); 
                 if(!result && (EOLat=response.pos("\r\n", 2))>=0) { // checking status in first response                  if(!status_code && (EOLat=response.pos("\r\n", 2))>=0) { // checking status in first response
                         StringPtr status_line=response.mid(0, (size_t)EOLat);                          const String& status_line=response.mid(0, (size_t)EOLat);
                         Array<StringPtr> astatus;                           Array astatus(response.pool()); 
                         status_line->split(astatus, 0, " ", 1);                           size_t pos_after_ref=0; status_line.split(astatus, &pos_after_ref, " ", 1); 
                         StringPtr status_code=astatus.get(1);                          status_code=astatus.get_string(1); 
                         result=status_code->as_int();   
   
                         if(fail_on_status_ne_200 && result!=200)                          if(fail_on_status_ne_200 && *status_code!="200")
                                 throw Exception("http.status",                                  throw Exception("http.status",
                                         status_code,                                          status_code,
                                         "invalid HTTP response status");                                          "invalid HTTP response status");
                 }                  }
         }          }
         if(result)          if(status_code)
                 return result;                  return status_code->as_int();
         else          else
                 throw Exception("http.response",                  throw Exception("http.response",
                         Exception::undefined_source,                          0,
                         "bad response from host - no status found (size=%lu)", response.size());                           "bad response from host - no status found (size=%lu)", response.size()); 
 }  }
   
 /* ********************** request *************************** */  /* ********************** request *************************** */
   
 #if defined(SIGALRM) && defined(HAVE_SIGSETJMP) && defined(HAVE_SIGLONGJMP)  #if defined(SIGALRM) && defined(HAVE_SIGSETJMP) && defined(HAVE_SIGLONGJMP)
 #       define WE_CAN_USE_ALARM  #       define PA_USE_ALARM
 #endif  #endif
   
 #ifdef WE_CAN_USE_ALARM  #ifdef PA_USE_ALARM
 static sigjmp_buf timeout_env;  static sigjmp_buf timeout_env;
 static void timeout_handler(int sig){  static void timeout_handler(int sig){
     siglongjmp(timeout_env, 1);       siglongjmp(timeout_env, 1); 
 }  }
 #endif  #endif
   
 static int http_request(Pool& pool,  static int http_request(String& response,
                                                 String& response,                                                          const String *origin_string, 
                                                 StringPtr origin_string,                                                           const char* host, int port, 
                                                 const char* host, int port,                                                           const char* request, 
                                                 const char* request,                                                           int timeout,
                                                 int timeout,                                                          bool fail_on_status_ne_200) {
                                                 bool fail_on_status_ne_200) {  
         if(!host)          if(!host)
                 throw Exception("http.host",                   throw Exception("http.host", 
                         origin_string,                           origin_string, 
                         "zero hostname");  //never                          "zero hostname");  //never
   
 #ifdef WE_CAN_USE_ALARM  #ifdef PA_USE_ALARM
     signal(SIGALRM, timeout_handler);           signal(SIGALRM, timeout_handler); 
 #endif  #endif
         int sock=-1;          int sock=-1;
         try {  #ifdef PA_USE_ALARM
                 int result;          if(sigsetjmp(timeout_env, 1)) {
 #ifdef WE_CAN_USE_ALARM                  // stupid gcc [2.95.4] generated bad code
                 if(sigsetjmp(timeout_env, 1))                  // which failed to handle sigsetjmp+throw: crashed inside of pre-throw code.
                         throw Exception("http.timeout",                   // rewritten simplier [though duplicating closesocket code]
                                 origin_string,                   if(sock>=0) 
                                 "timeout occured while retrieving document");                           closesocket(sock); 
                 else {                  throw Exception("http.timeout", 
                         alarm(timeout);                           origin_string, 
                           "timeout occured while retrieving document"); 
                   return 0; // never
           } else {
                   alarm(timeout); 
 #endif  #endif
                   try {
                           int result;
                         struct sockaddr_in dest;                          struct sockaddr_in dest;
                   
                 if(!set_addr(&dest, host, port))                          if(!set_addr(&dest, host, port))
                                 throw Exception("http.host",                                   throw Exception("http.host", 
                                         origin_string,                                           origin_string, 
                                         "can not resolve hostname \"%s\"", host);                                           "can not resolve hostname \"%s\"", host); 
Line 240  static int http_request(Pool& pool, Line 233  static int http_request(Pool& pool,
                                         origin_string,                                           origin_string, 
                                         "error sending request: %s (%d)", strerror(errno), errno);                                           "error sending request: %s (%d)", strerror(errno), errno); 
   
                         result=http_read_response(pool, response, sock, fail_on_status_ne_200);                           result=http_read_response(response, sock, fail_on_status_ne_200); 
                         closesocket(sock);                           closesocket(sock); 
 #ifdef WE_CAN_USE_ALARM  #ifdef PA_USE_ALARM
                         alarm(0);                           alarm(0); 
                 }  
 #endif  #endif
                 return result;                          return result;
         } catch(...) {                  } catch(...) {
                 if(sock>=0)   #ifdef PA_USE_ALARM
                         closesocket(sock);                           alarm(0); 
 #ifdef WE_CAN_USE_ALARM  
                 alarm(0);   
 #endif  #endif
                 rethrow;                          if(sock>=0) 
                                   closesocket(sock); 
                           /*re*/throw;
                   }
   #ifdef PA_USE_ALARM
         }          }
   #endif
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct Http_pass_header_info {  struct Http_pass_header_info {
         Pool* pool;  
         Charset* charset;  
         String* request;          String* request;
         bool user_agent_specified;          bool user_agent_specified;
 };  };
 #endif  #endif
 static void http_pass_header(HashStringValue::key_type key, HashStringValue::value_type value,   static void http_pass_header(const Hash::Key& key, Hash::Val *value, void *info)
                                                          Http_pass_header_info *info) {  {
     *(info->request)<<*key<<": "          Http_pass_header_info& i=*static_cast<Http_pass_header_info *>(info);
                 << *attributed_meaning_to_string(*info->pool, value, String::UL_HTTP_HEADER, false)          Pool& pool=i.request->pool();
       
       *(i.request)<<key<<": "
                   << attributed_meaning_to_string(*static_cast<Value *>(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(pool, String::CC_UPPER)=="USER-AGENT")
                 info->user_agent_specified=true;                  i.user_agent_specified=true;
 }  }
 static HashStringValuePtr file_read_http(Pool& pool, Charset& charset, StringPtr file_spec,   static void file_read_http(Pool& pool, const String& file_spec, 
                                         char*& data, size_t& data_size,                                           void*& data, size_t& data_size, 
                                         HashStringValue *options=0, bool return_outfields=false) {                                          Hash *options=0, Hash** out_fields=0) {
         HashStringValuePtr result(0);  
         char host[MAX_STRING];           char host[MAX_STRING]; 
         const char* uri;           const char* uri; 
         int port;          int port;
         CharPtr method(0);          const char* method="GET"; 
         int timeout=2;          int timeout=2;
         bool fail_on_status_ne_200=true;          bool fail_on_status_ne_200=true;
         ValuePtr vheaders(0);          Value *vheaders=0;
   
         StringPtr connect_string(new String());          String& connect_string=*new(pool) String(pool); // must not be local [exception may be reported outside]
         // 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);           char* connect_string_cstr=connect_string.cstr(String::UL_UNSPECIFIED); 
         const char* current=connect_string_cstr;          if(strncmp(connect_string_cstr, "http://", 7)!=0)
         if(strncmp(current, "http://", 7)!=0)  
                 throw Exception(0,                   throw Exception(0, 
                         connect_string,                           &connect_string, 
                         "does not start with http://"); //never                          "does not start with http://"); //never
         current+=7;          connect_string_cstr+=7;
   
         strncpy(host, current, sizeof(host)-1);  host[sizeof(host)-1]=0;          strncpy(host, connect_string_cstr, sizeof(host)-1);  host[sizeof(host)-1]=0;
         char* host_uri=lsplit(host, '/');           char* host_uri=lsplit(host, '/'); 
         uri=host_uri?current+(host_uri-1-host):"/";           uri=host_uri?connect_string_cstr+(host_uri-1-host):"/"; 
         char* port_cstr=lsplit(host, ':');           char* port_cstr=lsplit(host, ':'); 
         char* error_pos=0;          char* error_pos=0;
         port=port_cstr?strtol(port_cstr, &error_pos, 0):80;          port=port_cstr?strtol(port_cstr, &error_pos, 0):80;
   
         if(options) {          if(options) {
                 int valid_options=0;                  int valid_options=0;
                 if(ValuePtr vmethod=options->get(http_method_name)) {                  if(Value *vmethod=static_cast<Value *>(options->get(*http_method_name))) {
                         valid_options++;                          valid_options++;
                         method=vmethod->as_string(&pool)->cstr();                          method=vmethod->as_string().cstr(); 
                 }                  }
                 if(ValuePtr vtimeout=options->get(http_timeout_name)) {                  if(Value *vtimeout=static_cast<Value *>(options->get(*http_timeout_name))) {
                         valid_options++;                          valid_options++;
                         timeout=vtimeout->as_int();                           timeout=vtimeout->as_int(); 
                 }                  }
                 if(vheaders=options->get(http_headers_name)) {                  if(vheaders=static_cast<Value *>(options->get(*http_headers_name))) {
                         valid_options++;                          valid_options++;
                 }                  }
                 if(ValuePtr vany_status=options->get(http_any_status_name)) {                  if(Value *vany_status=static_cast<Value *>(options->get(*http_any_status_name))) {
                         valid_options++;                          valid_options++;
                         fail_on_status_ne_200=!vany_status->as_bool();                           fail_on_status_ne_200=!vany_status->as_bool(); 
                 }                  }
   
                 if(valid_options!=options->count())                  if(valid_options!=options->size())
                         throw Exception("parser.runtime",                          throw Exception("parser.runtime",
                                 Exception::undefined_source,                                  0,
                                 "invalid option passed");                                  "invalid option passed");
         }           } 
   
         //making request          //making request
         String request;          String request(pool);
         if(method)          request<< method <<" "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n"; 
                 request<<method;  
         else  
                 request<<"GET";  
         request<< " "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n";   
         bool user_agent_specified=false;          bool user_agent_specified=false;
         if(vheaders && !vheaders->is_string()) { // allow empty          if(vheaders && !vheaders->is_string()) { // allow empty
                 if(HashStringValue *headers=vheaders->get_hash(connect_string)) {                  if(Hash *headers=vheaders->get_hash(&connect_string)) {
                         Http_pass_header_info info={&pool, &charset, &request};                          Http_pass_header_info info={&request};
                         headers->for_each(http_pass_header, &info);                           headers->for_each(http_pass_header, &info); 
                         user_agent_specified=info.user_agent_specified;                          user_agent_specified=info.user_agent_specified;
                 } else                  } else
                         throw Exception("parser.runtime",                           throw Exception("parser.runtime", 
                                 connect_string,                                  &connect_string,
                                 "headers param must be hash");                                   "headers param must be hash"); 
         };          };
         if(!user_agent_specified) // defaulting          if(!user_agent_specified) // defaulting
Line 352  static HashStringValuePtr file_read_http Line 342  static HashStringValuePtr file_read_http
         request<<"\n";           request<<"\n"; 
                   
         //sending request          //sending request
         String response;          String response(pool); 
         CharPtr request_cstr=request.cstr(String::UL_UNSPECIFIED);          int status_code=http_request(response,
         int status_code=http_request(pool, response,                  &connect_string, host, port, request.cstr(String::UL_UNSPECIFIED), 
                 connect_string, host, port, request_cstr,   
                 timeout, fail_on_status_ne_200);                   timeout, fail_on_status_ne_200); 
                   
         //processing results              //processing results    
         int pos=response.pos("\r\n\r\n", 4);           int pos=response.pos("\r\n\r\n", 4); 
         if(pos<1){          if(pos<1){
                 throw Exception("http.response",                   throw Exception("http.response", 
                         connect_string,                          &connect_string,
                         "bad response from host - no headers found");                           "bad response from host - no headers found"); 
         }          }
         StringPtr header_block=response.mid(0, pos);           String header_block=response.mid(0, pos); 
         StringPtr body=response.mid(pos+4, response.size());           String body=response.mid(pos+4, response.size()); 
                   
         Array<StringPtr> aheaders;          Array aheaders(pool); 
         HashStringValuePtr headers(new HashStringValue);           Hash& headers=*new(pool) Hash(pool); 
         header_block->split(aheaders, 0, "\r\n", 2);           size_t pos_after_ref=0;
           header_block.split(aheaders, &pos_after_ref, "\r\n", 2); 
                   
         //processing headers          //processing headers
         for(int i=1; i<aheaders.count(); i++) {          for(int i=1;i<aheaders.size();i++) {
                 StringPtr line=aheaders.get(i);                  if(const String *line=aheaders.get_string(i)) {
                 pos=line->pos(": ", 2);                           pos=line->pos(": ", 2); 
                 if(pos<1)                          if(pos<1)
                                   throw Exception("http.response", 
                                           &connect_string,
                                           "bad response from host - bad header \"%s\"", line->cstr()); 
                                   
                           headers.put(
                                   line->mid(0, pos).change_case(pool, String::CC_UPPER), 
                                   new(pool) VString(line->mid(pos+2, line->size()))); 
                   } else
                         throw Exception("http.response",                           throw Exception("http.response", 
                                 connect_string,                                  &connect_string, 
                                 "bad response from host - bad header \"%s\"", line->cstr().get());                                  "bad response from host - bad headers \"%s\"", header_block.cstr()); 
                           
                 headers->put(  
                         line->mid(0, pos)->change_case(pool, charset, String::CC_UPPER),   
                         ValuePtr(new VString(line->mid(pos+2, line->size()))));   
         }          }
   
         // output response          // output response
         data=new(pool) char[data_size=body->size()];          data=body.cstr(); data_size=body.size();
         body->store_to(data, String::UL_AS_IS);          if(out_fields) {
         if(return_outfields) {                  headers.put(*file_status_name, new(pool) VInt(pool, status_code)); 
                 headers->put(file_status_name, ValuePtr(new VInt(status_code)));                   *out_fields=&headers;
                 return headers;          }
         } else  
                 return HashStringValuePtr(0);  
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_read_action_info {  struct File_read_action_info {
         char **data; size_t *data_size;          void **data; size_t *data_size;
 };   }; 
 #endif  #endif
 static void file_read_action(Pool& pool,  static void file_read_action(Pool& pool, 
                                                          struct stat& finfo,                                                            struct stat& finfo, 
                                                          int f,                                                            int f, 
                                                          StringPtr file_spec, const char* fname, bool as_text,                                                            const String& 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));                   *info.data=pool.malloc(to_read_size+(as_text?1:0), 3); 
                 *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 426  static void file_read_action(Pool& pool, Line 418  static void file_read_action(Pool& pool,
                 return;                  return;
         }          }
 }  }
 File_read_result file_read(Pool& pool, Charset& charset, StringPtr file_spec,   bool file_read(Pool& pool, const String& file_spec, 
                            char*& data, size_t& data_size,                              void*& data, size_t& data_size, 
                            bool as_text, HashStringValue *params, HashStringValue** out_fields,                              bool as_text, Hash *params, Hash** out_fields, 
                            bool fail_on_read_problem) {                             bool fail_on_read_problem) {
         File_read_result result;          bool result;
         if(file_spec->starts_with("http://", 7)) {          if(file_spec.starts_with("http://", 7)) {
                 // fail on read problem                  // fail on read problem
                 result.fields=file_read_http(pool, charset, file_spec, data, data_size, params);                   file_read_http(pool, file_spec, data, data_size, params, out_fields); 
                 result.success=true;                  result=true;
         } else {          } else {
                 File_read_action_info info={&data, &data_size};                   File_read_action_info info={&data, &data_size}; 
                 result.success=file_read_action_under_lock(pool, file_spec,                   result=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.success && as_text) {          if(result && 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 460  File_read_result file_read(Pool& pool, C Line 452  File_read_result file_read(Pool& pool, C
         return result;          return result;
 }  }
   
 bool file_read_action_under_lock(Pool& pool, StringPtr file_spec,   #ifdef PA_SAFE_MODE
   void check_safe_mode(struct stat finfo, const String& file_spec, const char* fname) {
           if(finfo.st_uid/*foreign?*/!=geteuid()
                   && finfo.st_gid/*foreign?*/!=getegid())
                   throw Exception("parser.runtime", 
                           &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', "
                           "fuid(%d)!=euid(%d) or fgid(%d)!=egid(%d)", 
                                   fname,
                                   finfo.st_uid, geteuid(),
                                   finfo.st_gid, getegid());
   }
   #endif
   
   bool file_read_action_under_lock(Pool& pool, 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) {
         CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC);           const char* fname=file_spec.cstr(String::UL_FILE_SPEC); 
         int f;          int f;
   
         // first open, next stat:          // first open, next stat:
Line 480  bool file_read_action_under_lock(Pool& p Line 489  bool file_read_action_under_lock(Pool& p
                 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.get());                                                          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.get());                                                  strerror(errno), errno, fname); 
   
 #ifdef PA_SAFE_MODE  #ifdef PA_SAFE_MODE
                         if(finfo.st_uid/*foreign?*/!=geteuid()                          check_safe_mode(finfo, file_spec, fname);
                                 && finfo.st_gid/*foreign?*/!=getegid())  
                                 throw Exception("parser.runtime",   
                                         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'",   
                                                 fname.get());  
 #endif  #endif
   
                         action(pool, finfo, f, file_spec, fname, as_text, context);                           action(pool, finfo, f, file_spec, fname, as_text, context); 
                 } catch(...) {                  } catch(...) {
                         unlock(f);close(f);                           unlock(f);close(f); 
                         if(fail_on_read_problem)                          if(fail_on_read_problem)
                                 rethrow;                                  /*re*/throw;
                         return false;                                             return false;                   
                 }                   } 
   
Line 513  bool file_read_action_under_lock(Pool& p Line 517  bool file_read_action_under_lock(Pool& p
     } 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.get());                                          action_name, strerror(errno), errno, fname); 
                 return false;                  return false;
         }          }
 }  }
   
 static void create_dir_for_file(StringPtr file_spec) {  static void create_dir_for_file(const String& 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(
                                 StringPtr file_spec,                                   const String& 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) {
         CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC);           const char* 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 547  bool file_write_action_under_lock( Line 551  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.get());                                  strerror(errno), errno, fname); 
                         close(f);                           close(f); 
                         if(fail_on_lock_problem)                          if(fail_on_lock_problem)
                                 throw e;                                  throw e;
Line 564  bool file_write_action_under_lock( Line 568  bool file_write_action_under_lock(
                                 ftruncate(f, lseek(f, 0, SEEK_CUR)); // one can not use O_TRUNC, read lower                                  ftruncate(f, lseek(f, 0, SEEK_CUR)); // one can not use O_TRUNC, read lower
 #endif  #endif
                         unlock(f);close(f);                           unlock(f);close(f); 
                         rethrow;                          /*re*/throw;
                 }                  }
                                   
 #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
Line 575  bool file_write_action_under_lock( Line 579  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.get());                                  action_name, strerror(errno), errno, fname); 
         // here should be nothing, see rethrow above          // here should be nothing, see rethrow above
 }  }
   
Line 592  static void file_write_action(int f, voi Line 596  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, 
                                 Exception::undefined_source,                                   0, 
                                 "write failed: %s (%d)",  strerror(errno), errno);                                   "write failed: %s (%d)",  strerror(errno), errno); 
         }          }
 }  }
 void file_write(  void file_write(
                                 StringPtr file_spec,                                   const String& 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(StringPtr file_spec, size_t pos_after) {  static void rmdir(const String& 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(StringPtr file_spec, bool fail_on_read_problem) {  bool file_delete(const String& file_spec, bool fail_on_read_problem) {
         CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC);           const char* 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.get());                                          strerror(errno), errno, fname); 
                 else                  else
                         return false;                          return false;
   
         rmdir(file_spec, 1);           rmdir(file_spec, 1); 
         return true;          return true;
 }  }
 void file_move(StringPtr old_spec, StringPtr new_spec) {  void file_move(const String& old_spec, const String& new_spec) {
         CharPtr old_spec_cstr=old_spec->cstr(String::UL_FILE_SPEC);           const char* old_spec_cstr=old_spec.cstr(String::UL_FILE_SPEC); 
         CharPtr new_spec_cstr=new_spec->cstr(String::UL_FILE_SPEC);           const char* 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.get(), new_spec_cstr.get());                                  strerror(errno), errno, old_spec_cstr, new_spec_cstr); 
   
         rmdir(old_spec, 1);           rmdir(old_spec, 1); 
 }  }
Line 655  bool entry_exists(const char* fname, str Line 659  bool entry_exists(const char* fname, str
         return result;          return result;
 }  }
   
 bool entry_exists(StringPtr file_spec) {  bool entry_exists(const String& file_spec) {
         CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC);           const char* fname=file_spec.cstr(String::UL_FILE_SPEC); 
         return entry_exists(fname, 0);           return entry_exists(fname, 0); 
 }  }
   
 static bool entry_readable(StringPtr file_spec, bool need_dir) {  static bool entry_readable(const String& file_spec, bool need_dir) {
     CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC);       char* 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 679  static bool entry_readable(StringPtr fil Line 683  static bool entry_readable(StringPtr fil
         }          }
         return false;          return false;
 }  }
 bool file_readable(StringPtr file_spec) {  bool file_readable(const String& file_spec) {
         return entry_readable(file_spec, false);           return entry_readable(file_spec, false); 
 }  }
 bool dir_readable(StringPtr file_spec) {  bool dir_readable(const String& file_spec) {
         return entry_readable(file_spec, true);           return entry_readable(file_spec, true); 
 }  }
 StringPtr file_readable(StringPtr path, const String& name) {  String *file_readable(const String& path, const String& name) {
         StringPtr result(new String(*path));          String *result=new(path.pool()) String(path); 
         *result << "/";           *result << "/"; 
         *result << name;          *result << name;
         return file_readable(result)?result:StringPtr(0);          return file_readable(*result)?result:0;
 }  }
 bool file_executable(StringPtr file_spec) {  bool file_executable(const String& 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(StringPtr file_spec,   bool file_stat(const String& 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) {
         CharPtr fname=file_spec->cstr(String::UL_FILE_SPEC);           Pool& pool=file_spec.pool(); 
           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.get());                                          strerror(errno), errno, fname); 
                 else                  else
                         return false;                          return false;
         rsize=finfo.st_size;          rsize=finfo.st_size;
Line 760  char* rsplit(char* string, char delim) { Line 765  char* rsplit(char* string, char delim) {
 }  }
   
 /// @todo less stupid type detection  /// @todo less stupid type detection
 const char* format(Pool& pool, double value, char* fmt) {  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 775  const char* format(Pool& pool, double va Line 780  const char* format(Pool& pool, double va
         else          else
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                   size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value); 
                   
         return pool.copy(local_buf, size+1);           char* pool_buf=(char *)pool.malloc(size+1, 4); 
           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 795  size_t stdout_write(const void *buf, siz Line 802  size_t stdout_write(const void *buf, siz
 }  }
   
 char* unescape_chars(Pool& pool, const char* cp, int len) {  char* unescape_chars(Pool& pool, const char* cp, int len) {
         char* s=pool.malloc(len + 1);           char* s=(char *)pool.malloc(len + 1, 5); 
         enum EscapeState {          enum EscapeState {
                 EscapeRest,                   EscapeRest, 
                 EscapeFirst,                   EscapeFirst, 
Line 916  int __vsnprintf(char* b, size_t s, const Line 923  int __vsnprintf(char* b, size_t s, const
         win32:           win32: 
         mk:@MSITStore:C:\Program%20Files\Microsoft%20Visual%20Studio\MSDN\2001APR\1033\vccore.chm::/html/_crt__vsnprintf.2c_._vsnwprintf.htm          mk:@MSITStore:C:\Program%20Files\Microsoft%20Visual%20Studio\MSDN\2001APR\1033\vccore.chm::/html/_crt__vsnprintf.2c_._vsnwprintf.htm
   
           if the number of bytes to write exceeds buffer, then count bytes are written and Ö1 is returned            if the number of bytes to write exceeds buffer, then count bytes are written and –1 is returned
         */          */
         r=_vsnprintf(b, s, f, l);           r=_vsnprintf(b, s, f, l); 
         if(r<0)           if(r<0) 
Line 966  int pa_sleep(unsigned long secs, unsigne Line 973  int pa_sleep(unsigned long secs, unsigne
 }  }
   
   
   // attributed meaning
   
   /// http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
   static size_t date_attribute(const VDate& vdate, char *buf, size_t buf_size) {
       const char month_names[12][4]={
                   "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
       const char days[7][4]={
                   "Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
   
           time_t when=vdate.get_time();
           struct tm *tms=gmtime(&when);
           if(!tms)
                   throw Exception(0,
                           0,
                           "bad time in attribute value (seconds from epoch=%ld)", when);
           return snprintf(buf, MAX_STRING, "%s, %.2d %s %.4d %.2d:%.2d:%.2d GMT", 
                   days[tms->tm_wday],
                   tms->tm_mday,month_names[tms->tm_mon],tms->tm_year+1900,
                   tms->tm_hour,tms->tm_min,tms->tm_sec);
   }
   static void append_attribute_meaning(String& result,
                                                                            Value& value, String::Untaint_lang lang, bool forced) {
           if(const String *string=value.get_string())
                   result.append(string->join_chains(result.pool(), 0), lang, forced);
           else
                   if(Value *vdate=value.as(VDATE_TYPE, false)) {
                           char *buf=(char *)result.malloc(MAX_STRING);
                           size_t size=date_attribute(*static_cast<VDate *>(vdate), 
                                   buf, MAX_STRING);
   
                           result.APPEND_CLEAN(buf, size, "converted from date", 0);
                   } else
                           throw Exception("parser.runtime",
                                   &result,
                                   "trying to append here neither string nor date (%s)",
                                           value.type());
   }
   #ifndef DOXYGEN
   struct Attributed_meaning_info {
           String *header; // header line being constructed
           String::Untaint_lang lang; // language in which to append to that line
           bool forced; // do they force that lang?
   };
   #endif
   static void append_attribute_subattribute(const Hash::Key& akey, Hash::Val *avalue, 
                                                                                     void *info) {
           if(akey==VALUE_NAME)
                   return;
   
           Attributed_meaning_info& ami=*static_cast<Attributed_meaning_info *>(info);
   
           // ...; charset=windows1251
           *ami.header << "; ";
           ami.header->append(akey, ami.lang, ami.forced);
           *ami.header << "=";
           append_attribute_meaning(*ami.header, *static_cast<Value *>(avalue), ami.lang, ami.forced);
   }
   const String& attributed_meaning_to_string(Value& meaning, 
                                                                                      String::Untaint_lang lang, bool forced) {
           String &result=*new(meaning.pool()) String(meaning.pool());
           if(Hash *hash=meaning.get_hash(0)) {
                   // $value(value) $subattribute(subattribute value)
                   if(Value *value=static_cast<Value *>(hash->get(*value_name)))
                           append_attribute_meaning(result, *value, lang, forced);
   
                   Attributed_meaning_info attributed_meaning_info={&result, lang};
                   hash->for_each(append_attribute_subattribute, &attributed_meaning_info);
           } else // result value
                   append_attribute_meaning(result, meaning, lang, forced);
   
           return result;
   }
Removed from v.1.143.2.13  
changed lines
  Added in v.1.151

E-mail: