[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.135 and 1.146

version 1.135, 2002/11/29 08:06:59 version 1.146, 2003/03/21 07:07:06
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 29  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 77  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 140  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){
         bool check_status=true;          const String* status_code=0;
         ssize_t EOLat=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); 
Line 149  static void http_read_response(String& r Line 148  static void http_read_response(String& r
                 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(check_status && (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
                         check_status=false;  
   
                         const String& status_line=response.mid(0, (size_t)EOLat);                          const String& status_line=response.mid(0, (size_t)EOLat);
                         Array astatus(response.pool());                           Array astatus(response.pool()); 
                         size_t pos_after_ref=0; status_line.split(astatus, &pos_after_ref, " ", 1);                           size_t pos_after_ref=0; status_line.split(astatus, &pos_after_ref, " ", 1); 
                         const String* status_code=astatus.get_string(1);                           status_code=astatus.get_string(1); 
   
                         if(!status_code || *status_code!="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(check_status)          if(status_code)
                   return status_code->as_int();
           else
                 throw Exception("http.response",                  throw Exception("http.response",
                         0,                          0,
                         "bad response from host - no status found (size=%lu)", response.size());                           "bad response from host - no status found (size=%lu)", response.size()); 
Line 172  static void http_read_response(String& r Line 171  static void http_read_response(String& r
 /* ********************** 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 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, 
                         "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
 #ifdef WE_CAN_USE_ALARM          if(sigsetjmp(timeout_env, 1)) {
                 if(sigsetjmp(timeout_env, 1))                  // stupid gcc [2.95.4] generated bad code
                         throw Exception("http.timeout",                   // which failed to handle sigsetjmp+throw: crashed inside of pre-throw code.
                                 origin_string,                   // rewritten simplier [though duplicating closesocket code]
                                 "timeout occured while retrieving document");                   if(sock>=0) 
                 else {                          closesocket(sock); 
                         alarm(timeout);                   throw Exception("http.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 226  static void http_request(String& respons Line 233  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); 
                           closesocket(sock); 
   #ifdef PA_USE_ALARM
                           alarm(0); 
   #endif
                   } catch(...) {
   #ifdef PA_USE_ALARM
                           alarm(0); 
   #endif
                         if(sock>=0)                           if(sock>=0) 
                                 closesocket(sock);                                   closesocket(sock); 
 #ifdef WE_CAN_USE_ALARM                          /*re*/throw;
                 }                  }
 #endif                  return result;
         } catch(...) {  
                 if(sock>=0)   
                         closesocket(sock);   
 #ifdef WE_CAN_USE_ALARM  
                 alarm(0);   
 #endif  
                 /*re*/throw;  
         }          }
 }  }
   
Line 254  static void http_pass_header(const Hash: Line 262  static void http_pass_header(const Hash:
         Pool& pool=i.request->pool();          Pool& pool=i.request->pool();
           
     *(i.request)<<key<<": "      *(i.request)<<key<<": "
                 << attributed_meaning_to_string(*static_cast<Value *>(value), String::UL_URI)                  << attributed_meaning_to_string(*static_cast<Value *>(value), String::UL_HTTP_HEADER, false)
                 <<"\n";                   <<"\n"; 
                   
         if(key.change_case(pool, String::CC_UPPER)=="USER-AGENT")          if(key.change_case(pool, String::CC_UPPER)=="USER-AGENT")
Line 268  static void file_read_http(Pool& pool, c Line 276  static void file_read_http(Pool& pool, c
         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;
   
         String connect_string(pool);          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
   
Line 301  static void file_read_http(Pool& pool, c Line 310  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,
Line 327  static void file_read_http(Pool& pool, c Line 341  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,
                 &connect_string, 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); 
Line 345  static void file_read_http(Pool& pool, c Line 360  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",   
                         &connect_string,  
                         "bad response from host - no status line ");   
         }  
         //processing headers          //processing headers
         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)) {
Line 372  static void file_read_http(Pool& pool, c Line 380  static void file_read_http(Pool& pool, c
   
         // 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) VInt(pool, status_code)); 
                 *out_fields=&headers;                  *out_fields=&headers;
           }
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
Line 471  bool file_read_action_under_lock(Pool& p Line 481  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 523  bool file_write_action_under_lock( Line 534  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 538  bool file_write_action_under_lock( Line 549  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 964  static size_t date_attribute(const VDate Line 979  static size_t date_attribute(const VDate
                 tms->tm_hour,tms->tm_min,tms->tm_sec);                  tms->tm_hour,tms->tm_min,tms->tm_sec);
 }  }
 static void append_attribute_meaning(String& result,  static void append_attribute_meaning(String& result,
                                                                          Value& value, String::Untaint_lang lang) {                                                                           Value& value, String::Untaint_lang lang, bool forced) {
         if(const String *string=value.get_string())          if(const String *string=value.get_string())
                 result.append(string->join_chains(result.pool(), 0), lang, true);                  result.append(string->join_chains(result.pool(), 0), lang, forced);
         else          else
                 if(Value *vdate=value.as(VDATE_TYPE, false)) {                  if(Value *vdate=value.as(VDATE_TYPE, false)) {
                         char *buf=(char *)result.malloc(MAX_STRING);                          char *buf=(char *)result.malloc(MAX_STRING);
Line 984  static void append_attribute_meaning(Str Line 999  static void append_attribute_meaning(Str
 struct Attributed_meaning_info {  struct Attributed_meaning_info {
         String *header; // header line being constructed          String *header; // header line being constructed
         String::Untaint_lang lang; // language in which to append to that line          String::Untaint_lang lang; // language in which to append to that line
           bool forced; // do they force that lang?
 };  };
 #endif  #endif
 static void append_attribute_subattribute(const Hash::Key& akey, Hash::Val *avalue,   static void append_attribute_subattribute(const Hash::Key& akey, Hash::Val *avalue, 
Line 995  static void append_attribute_subattribut Line 1011  static void append_attribute_subattribut
   
         // ...; charset=windows1251          // ...; charset=windows1251
         *ami.header << "; ";          *ami.header << "; ";
         ami.header->append(akey, ami.lang, true);          ami.header->append(akey, ami.lang, ami.forced);
         *ami.header << "=";          *ami.header << "=";
         append_attribute_meaning(*ami.header, *static_cast<Value *>(avalue), ami.lang);          append_attribute_meaning(*ami.header, *static_cast<Value *>(avalue), ami.lang, ami.forced);
 }  }
 const String& attributed_meaning_to_string(Value& meaning,   const String& attributed_meaning_to_string(Value& meaning, 
                                                                                    String::Untaint_lang lang) {                                                                                     String::Untaint_lang lang, bool forced) {
         String &result=*new(meaning.pool()) String(meaning.pool());          String &result=*new(meaning.pool()) String(meaning.pool());
         if(Hash *hash=meaning.get_hash(0)) {          if(Hash *hash=meaning.get_hash(0)) {
                 // $value(value) $subattribute(subattribute value)                  // $value(value) $subattribute(subattribute value)
                 if(Value *value=static_cast<Value *>(hash->get(*value_name)))                  if(Value *value=static_cast<Value *>(hash->get(*value_name)))
                         append_attribute_meaning(result, *value, lang);                          append_attribute_meaning(result, *value, lang, forced);
   
                 Attributed_meaning_info attributed_meaning_info={&result, lang};                  Attributed_meaning_info attributed_meaning_info={&result, lang};
                 hash->for_each(append_attribute_subattribute, &attributed_meaning_info);                  hash->for_each(append_attribute_subattribute, &attributed_meaning_info);
         } else // result value          } else // result value
                 append_attribute_meaning(result, meaning, lang);                  append_attribute_meaning(result, meaning, lang, forced);
   
         return result;          return result;
 }  }
Removed from v.1.135  
changed lines
  Added in v.1.146

E-mail: