[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.136 and 1.145.2.1

version 1.136, 2002/12/02 10:07:39 version 1.145.2.1, 2003/03/17 14:48:05
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_atomic(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(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"); 
           } 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))
Line 226  static void http_request(String& respons Line 232  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 PA_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); 
 #ifdef WE_CAN_USE_ALARM  #ifdef PA_USE_ALARM
                 alarm(0);                   alarm(0); 
 #endif  #endif
                 /*re*/throw;                  /*re*/throw;
Line 268  static void file_read_http(Pool& pool, c Line 275  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 309  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 340  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 359  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 379  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 388  static void file_read_action(Pool& pool, Line 397  static void file_read_action(Pool& pool,
                                                          void *context) {                                                           void *context) {
         File_read_action_info& info=*static_cast<File_read_action_info *>(context);           File_read_action_info& info=*static_cast<File_read_action_info *>(context); 
         if(size_t to_read_size=(size_t)finfo.st_size) {           if(size_t to_read_size=(size_t)finfo.st_size) { 
                 *info.data=pool.malloc(to_read_size+(as_text?1:0), 3);                   *info.data=pool.malloc_atomic(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)
Line 398  static void file_read_action(Pool& pool, Line 407  static void file_read_action(Pool& pool,
                                         *info.data_size, to_read_size);                                           *info.data_size, to_read_size); 
         } else { // empty file          } else { // empty file
                 if(as_text) {                  if(as_text) {
                         *info.data=pool.malloc(1);                           *info.data=pool.malloc_atomic(1); 
                         *(char*)(*info.data)=0;                          *(char*)(*info.data)=0;
                 } else                   } else 
                         *info.data=0;                          *info.data=0;
Line 471  bool file_read_action_under_lock(Pool& p Line 480  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 533  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 548  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 751  char* format(Pool& pool, double value, c Line 765  char* format(Pool& pool, double value, c
         else          else
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                   size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value); 
                   
         char* pool_buf=(char *)pool.malloc(size+1, 4);           char* pool_buf=(char *)pool.malloc_atomic(size+1, 4); 
         memcpy(pool_buf, local_buf, size+1);           memcpy(pool_buf, local_buf, size+1); 
         return pool_buf;          return pool_buf;
 }  }
Line 773  size_t stdout_write(const void *buf, siz Line 787  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=(char *)pool.malloc(len + 1, 5);           char* s=(char *)pool.malloc_atomic(len + 1, 5); 
         enum EscapeState {          enum EscapeState {
                 EscapeRest,                   EscapeRest, 
                 EscapeFirst,                   EscapeFirst, 
Line 969  static void append_attribute_meaning(Str Line 983  static void append_attribute_meaning(Str
                 result.append(string->join_chains(result.pool(), 0), lang, forced);                  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_atomic(MAX_STRING);
                         size_t size=date_attribute(*static_cast<VDate *>(vdate),                           size_t size=date_attribute(*static_cast<VDate *>(vdate), 
                                 buf, MAX_STRING);                                  buf, MAX_STRING);
   
Removed from v.1.136  
changed lines
  Added in v.1.145.2.1

E-mail: