[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.127 and 1.144

version 1.127, 2002/11/25 14:57:33 version 1.144, 2003/01/23 08:20:39
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001, 2002 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 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_vdate.h"
   
 #ifdef WIN32  #ifdef WIN32
 #       include <windows.h>  #       include <windows.h>
Line 28  static const char* IDENT_COMMON_C="$Date Line 29  static const char* IDENT_COMMON_C="$Date
 #       define _O_BINARY 0  #       define _O_BINARY 0
 #endif  #endif
   
   #ifdef HAVE_FTRUNCATE
   #       define PA_O_TRUNC 0
   #else
   #       ifdef _O_TRUNC
   #               define PA_O_TRUNC _O_TRUNC
   #       else
   #               error you must have either ftruncate function or _O_TRUNC bit declared
   #       endif
   #endif
   
 // locking constants  // locking constants
   
 #ifdef HAVE_FLOCK  #ifdef HAVE_FLOCK
Line 76  static int unlock(int fd) { FLOCK(F_TLOC Line 87  static int unlock(int fd) { FLOCK(F_TLOC
 #define DEFAULT_USER_AGENT "parser3"  #define DEFAULT_USER_AGENT "parser3"
   
   
   
 static char* strnchr(char* buf, size_t size, char c) {  
         // sanity check  
         if(!buf)  
                 return 0;  
   
         for(;  size-->0; buf++) {  
                 if(*buf==c)  
                         return buf;  
         }  
   
         return 0;  
 }  
   
 void fix_line_breaks(char* buf, size_t& size) {  void fix_line_breaks(char* buf, size_t& size) {
           if(size==0)
                   return;
   
         //_asm int 3;          //_asm int 3;
         const char* const eob=buf+size;          const char* const eob=buf+size;
         char* dest=buf;          char* dest=buf;
         // fix DOS: \r\n -> \n          // fix DOS: \r\n -> \n
         // fix Macintosh: \r -> \n          // fix Macintosh: \r -> \n
         char* bol=buf;          char* bol=buf;
         while(char* eol=strnchr(bol, eob -bol, '\r')) {          while(char* eol=(char*)memchr(bol, '\r', eob -bol)) {
                 size_t len=eol-bol;                  size_t len=eol-bol;
                 if(dest!=bol)                  if(dest!=bol)
                         memcpy(dest, bol, len);                           memcpy(dest, bol, len); 
Line 139  static bool set_addr(struct sockaddr_in Line 139  static bool set_addr(struct sockaddr_in
     return true;      return true;
 }  }
   
 static void http_read_response(String& response, int sock){  static int http_read_response(String& response, int sock, bool fail_on_status_ne_200){
           const String* status_code=0;
           ssize_t EOLat=0;
         while(true) {          while(true) {
                 char *buf=(char *)response.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, "http response", 0);                   response.APPEND_TAINTED(buf, size, "remote HTTP server response", 0); 
     }                  if(!status_code && (EOLat=response.pos("\r\n", 2))>=0) { // checking status in first response
                           const String& status_line=response.mid(0, (size_t)EOLat);
                           Array astatus(response.pool()); 
                           size_t pos_after_ref=0; status_line.split(astatus, &pos_after_ref, " ", 1); 
                           status_code=astatus.get_string(1); 
   
                           if(fail_on_status_ne_200 && *status_code!="200")
                                   throw Exception("http.status",
                                           status_code,
                                           "invalid HTTP response status");
                   }
           }
           if(status_code)
                   return status_code->as_int();
           else
                   throw Exception("http.response",
                           0,
                           "bad response from host - no status found (size=%lu)", response.size()); 
 }  }
   
 /* ********************** request *************************** */  /* ********************** request *************************** */
Line 162  static void timeout_handler(int sig){ Line 181  static void timeout_handler(int sig){
 }  }
 #endif  #endif
   
 static void http_request(String& response,  static int http_request(String& response,
                                                         const String *origin_string,                                                           const String *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){
         if(!host)          if(!host)
                 throw Exception("http.host",                   throw Exception("http.host", 
                         origin_string,                           origin_string, 
Line 177  static void http_request(String& respons Line 197  static void http_request(String& respons
 #endif  #endif
         int sock=-1;          int sock=-1;
         try {          try {
                   int result;
 #ifdef WE_CAN_USE_ALARM  #ifdef WE_CAN_USE_ALARM
                 if(sigsetjmp(timeout_env, 1))                  if(sigsetjmp(timeout_env, 1))
                         throw Exception("http.timeout",                           throw Exception("http.timeout", 
Line 206  static void http_request(String& respons Line 227  static void http_request(String& respons
                                         origin_string,                                           origin_string, 
                                         "error sending request: %s (%d)", strerror(errno), errno);                                           "error sending request: %s (%d)", strerror(errno), errno); 
   
                         http_read_response(response, sock);                           result=http_read_response(response, sock, fail_on_status_ne_200); 
                         if(sock>=0)                           closesocket(sock); 
                                 closesocket(sock);   
 #ifdef WE_CAN_USE_ALARM  #ifdef WE_CAN_USE_ALARM
                           alarm(0); 
                 }                  }
 #endif  #endif
                   return result;
         } catch(...) {          } catch(...) {
                 if(sock>=0)                   if(sock>=0) 
                         closesocket(sock);                           closesocket(sock); 
Line 233  static void http_pass_header(const Hash: Line 255  static void http_pass_header(const Hash:
         Http_pass_header_info& i=*static_cast<Http_pass_header_info *>(info);          Http_pass_header_info& i=*static_cast<Http_pass_header_info *>(info);
         Pool& pool=i.request->pool();          Pool& pool=i.request->pool();
           
     *(i.request)<<key<<": "<<*(static_cast<Value *>(value))->get_string()<<"\n";       *(i.request)<<key<<": "
                   << attributed_meaning_to_string(*static_cast<Value *>(value), String::UL_HTTP_HEADER, false)
                   <<"\n"; 
           
         if(key.change_case(pool, String::CC_UPPER)=="USER-AGENT")          if(key.change_case(pool, String::CC_UPPER)=="USER-AGENT")
                 i.user_agent_specified=true;                  i.user_agent_specified=true;
 }  }
Line 242  static void file_read_http(Pool& pool, c Line 266  static void file_read_http(Pool& pool, c
                                         void*& data, size_t& data_size,                                           void*& data, size_t& data_size, 
                                         Hash *options=0, Hash** out_fields=0) {                                          Hash *options=0, Hash** out_fields=0) {
         char host[MAX_STRING];           char host[MAX_STRING]; 
         char* uri;           const char* uri; 
         int port;          int port;
         const char* method="GET";           const char* method="GET"; 
         int timeout=2;          int timeout=2;
           bool fail_on_status_ne_200=true;
         Value *vheaders=0;          Value *vheaders=0;
   
         char* connect_string=file_spec.cstr(String::UL_UNSPECIFIED);           String& connect_string=*new(pool) String(pool); // must not be local [exception may be reported outside]
         if(strncmp(connect_string, "http://", 7)!=0)          // not in ^sql{... UL_SQL ...} spirit, but closer to ^file::load one
           connect_string.append(file_spec, String::UL_URI); // tainted pieces -> URI pieces
   
           char* connect_string_cstr=connect_string.cstr(String::UL_UNSPECIFIED); 
           if(strncmp(connect_string_cstr, "http://", 7)!=0)
                 throw Exception(0,                   throw Exception(0, 
                         &file_spec,                           &connect_string, 
                         "does not start with http://"); //never                          "does not start with http://"); //never
         connect_string+=7;          connect_string_cstr+=7;
   
         strncpy(host, connect_string, 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?connect_string+(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;
Line 275  static void file_read_http(Pool& pool, c Line 304  static void file_read_http(Pool& pool, c
                 if(vheaders=static_cast<Value *>(options->get(*http_headers_name))) {                  if(vheaders=static_cast<Value *>(options->get(*http_headers_name))) {
                         valid_options++;                          valid_options++;
                 }                  }
                   if(Value *vany_status=static_cast<Value *>(options->get(*http_any_status_name))) {
                           valid_options++;
                           fail_on_status_ne_200=!vany_status->as_bool(); 
                   }
   
                 if(valid_options!=options->size())                  if(valid_options!=options->size())
                         throw Exception("parser.runtime",                          throw Exception("parser.runtime",
                                 0,                                  0,
                                 "invalid option passed");                                  "invalid option passed");
         }          } 
   
         //making request          //making request
         String request(pool);          String request(pool);
         request<< method <<" "<< uri <<" HTTP/1.0\nHost: "<< host<<"\n";           request<< method <<" "<< 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(Hash *headers=vheaders->get_hash(&file_spec)) {                  if(Hash *headers=vheaders->get_hash(&connect_string)) {
                         Http_pass_header_info info={&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", 
                                 &file_spec,                                  &connect_string,
                                 "headers param must be hash");                                   "headers param must be hash"); 
         };          };
         if(!user_agent_specified) // defaulting          if(!user_agent_specified) // defaulting
Line 301  static void file_read_http(Pool& pool, c Line 335  static void file_read_http(Pool& pool, c
                   
         //sending request          //sending request
         String response(pool);           String response(pool); 
         http_request(response,          int status_code=http_request(response,
                 &file_spec, host, port, request.cstr(String::UL_UNSPECIFIED), timeout);                   &connect_string, host, port, request.cstr(String::UL_UNSPECIFIED), 
                   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", 
                         &file_spec,                          &connect_string,
                         "bad response from host - no headers found");                           "bad response from host - no headers found"); 
         }          }
         String header_block=response.mid(0, pos);           String header_block=response.mid(0, pos); 
Line 319  static void file_read_http(Pool& pool, c Line 354  static void file_read_http(Pool& pool, c
         size_t pos_after_ref=0;          size_t pos_after_ref=0;
         header_block.split(aheaders, &pos_after_ref, "\r\n", 2);           header_block.split(aheaders, &pos_after_ref, "\r\n", 2); 
                   
         //processing status code  
         const String *status_line=aheaders.get_string(0);   
         if(!status_line){  
                 throw Exception("http.response",   
                         &file_spec,  
                         "bad response from host - no status line ");   
         }  
         //processing headers          //processing headers
         Array astatus(pool);   
         pos_after_ref=0;  
         status_line->split(astatus, &pos_after_ref, " ", 1);   
         const String * status_code=astatus.get_string(1);   
           
         for(int i=1;i<aheaders.size();i++) {          for(int i=1;i<aheaders.size();i++) {
                 if(const String *line=aheaders.get_string(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",                                   throw Exception("http.response", 
                                         &file_spec,                                          &connect_string,
                                         "bad response from host - bad header \"%s\"", line->cstr());                                           "bad response from host - bad header \"%s\"", line->cstr()); 
                                                                   
                         headers.put(line->mid(0, pos), new(pool) VString(line->mid(pos+2, line->size())));                           headers.put(
                                   line->mid(0, pos).change_case(pool, String::CC_UPPER), 
                                   new(pool) VString(line->mid(pos+2, line->size()))); 
                 } else                  } else
                         throw Exception("http.response",                           throw Exception("http.response", 
                                 &file_spec,                                   &connect_string, 
                                 "bad response from host - bad headers \"%s\"", header_block.cstr());                                   "bad response from host - bad headers \"%s\"", header_block.cstr()); 
         }          }
   
         // output response          // output response
         data=body.cstr(); data_size=body.size();          data=body.cstr(); data_size=body.size();
         if(out_fields) {          if(out_fields) {
                 headers.put(*file_status_name, new(pool) VString(*status_code));                   headers.put(*file_status_name, new(pool) VInt(pool, status_code)); 
                 *out_fields=&headers;                  *out_fields=&headers;
         }          }
 }  }
Line 402  bool file_read(Pool& pool, const String& Line 427  bool file_read(Pool& pool, const String&
         }          }
   
         if(result && as_text) {          if(result && as_text) {
                   // UTF-8 signature: EF BB BF
                   if(data_size>=3) {
                           char *in=(char *)data;
                           if((in[0] == '\xEF') && (in[1] == '\xBB') &&
                                   (in[2] == '\xBF')) {
                                   data=in+3; data_size-=3;// skip prefix
                           }
                   }
   
                 fix_line_breaks((char *)(data), data_size);                   fix_line_breaks((char *)(data), data_size); 
                 // note: after fixing                  // note: after fixing
                 ((char*&)(data))[data_size]=0;                  ((char*&)(data))[data_size]=0;
Line 441  bool file_read_action_under_lock(Pool& p Line 475  bool file_read_action_under_lock(Pool& p
                                         "stat failed: %s (%d), actual filename '%s'",                                           "stat failed: %s (%d), actual filename '%s'", 
                                                 strerror(errno), errno, fname);                                                   strerror(errno), errno, fname); 
   
 #ifdef NO_FOREIGN_GROUP_FILES  #ifdef PA_SAFE_MODE
                         if(finfo.st_gid/*foreign?*/!=getegid()) {                          if(finfo.st_uid/*foreign?*/!=geteuid()
                                   && finfo.st_gid/*foreign?*/!=getegid())
                                 throw Exception("parser.runtime",                                   throw Exception("parser.runtime", 
                                         &file_spec,                                           &file_spec, 
                                         "parser reading files of foreign group disabled [recompile parser without --disable-foreign-group-files 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 493  bool file_write_action_under_lock( Line 528  bool file_write_action_under_lock(
         if((f=open(fname,           if((f=open(fname, 
                 O_CREAT|O_RDWR                  O_CREAT|O_RDWR
                 |(as_text?_O_TEXT:_O_BINARY)                  |(as_text?_O_TEXT:_O_BINARY)
                 |(do_append?O_APPEND:0), 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, 
Line 508  bool file_write_action_under_lock( Line 543  bool file_write_action_under_lock(
                 try {                  try {
                         action(f, context);                           action(f, context); 
                 } catch(...) {                  } catch(...) {
   #ifdef HAVE_FTRUNCATE
                         if(!do_append)                          if(!do_append)
                                 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
                         unlock(f);close(f);                           unlock(f);close(f); 
                         /*re*/throw;                          /*re*/throw;
                 }                  }
                                   
   #ifdef HAVE_FTRUNCATE
                 if(!do_append)                  if(!do_append)
                         ftruncate(f, lseek(f, 0, SEEK_CUR)); // O_TRUNC truncates even exclusevely write-locked file [thanks to Igor Milyakov <virtan@rotabanner.com> for discovering]                          ftruncate(f, lseek(f, 0, SEEK_CUR)); // O_TRUNC truncates even exclusevely write-locked file [thanks to Igor Milyakov <virtan@rotabanner.com> for discovering]
   #endif
                 unlock(f);close(f);                   unlock(f);close(f); 
                 return true;                  return true;
         } else          } else
Line 912  int pa_sleep(unsigned long secs, unsigne Line 951  int pa_sleep(unsigned long secs, unsigne
         return (select(0, NULL, NULL, NULL, &t) == -1 ? errno : 0);           return (select(0, NULL, NULL, NULL, &t) == -1 ? errno : 0); 
 #endif  #endif
 }  }
   
   
   // attributed meaning
   
   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.127  
changed lines
  Added in v.1.144

E-mail: