[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.21.2.27 and 1.165

version 1.143.2.21.2.27, 2003/04/11 12:29:00 version 1.165, 2003/11/19 08:20:02
Line 19  static const char* IDENT_COMMON_C="$Date Line 19  static const char* IDENT_COMMON_C="$Date
 #ifdef PA_HTTP  #ifdef PA_HTTP
 #include "pa_vstring.h"  #include "pa_vstring.h"
 #include "pa_vint.h"  #include "pa_vint.h"
   #include "pa_vhash.h"
   #include "pa_vtable.h"
   
 #ifdef CYGWIN  #ifdef CYGWIN
 #define _GNU_H_WINDOWS32_SOCKETS  #define _GNU_H_WINDOWS32_SOCKETS
Line 62  int PASCAL closesocket(SOCKET); Line 64  int PASCAL closesocket(SOCKET);
 #       endif  #       endif
 #endif  #endif
   
 // locking constants  
 //#define PA_DEBUG_NO_LOCKING  
   
 #ifdef PA_DEBUG_NO_LOCKING  
   
 #ifdef HAVE_FLOCK  
   
 static int lock_shared_blocking(int fd) { return flock(fd, LOCK_SH); }  
 static int lock_exclusive_blocking(int fd) { return flock(fd, LOCK_EX); }  
 static int lock_exclusive_nonblocking(int fd) { return flock(fd, LOCK_EX || LOCK_NB); }  
 static int unlock(int fd) { return flock(fd, LOCK_UN); }  
   
 #else  
 #ifdef HAVE__LOCKING  
   
 #define FLOCK(operation) lseek(fd, 0, SEEK_SET);  return _locking(fd, operation, 1)  
 static int lock_shared_blocking(int fd) { FLOCK(_LK_LOCK); }  
 static int lock_exclusive_blocking(int fd) { FLOCK(_LK_LOCK); }  
 static int lock_exclusive_nonblocking(int fd) { FLOCK(_LK_NBLCK); }  
 static int unlock(int fd) { FLOCK(_LK_UNLCK); }  
   
 #else  
 #ifdef HAVE_FCNTL  
   
 #define FLOCK(cmd, arg) struct flock ls={arg, SEEK_SET};  return fcntl(fd, cmd, &ls)  
 static int lock_shared_blocking(int fd) { FLOCK(F_SETLKW, F_RDLCK); }  
 static int lock_exclusive_blocking(int fd) { FLOCK(F_SETLKW, F_WRLCK); }  
 static int lock_exclusive_nonblocking(int fd) { FLOCK(F_SETLK, F_RDLCK); }  
 static int unlock(int fd) { FLOCK(F_SETLK, F_UNLCK); }  
   
 #else  
 #ifdef HAVE_LOCKF  
   
 #define FLOCK(fd, operation) lseek(fd, 0, SEEK_SET);  return lockf(fd, operation, 1)  
 static int lock_shared_blocking(int fd) { FLOCK(F_LOCK); } // on intel solaris man doesn't have doc on shared blocking  
 static int lock_exclusive_blocking(int fd) { FLOCK(F_LOCK); }  
 static int lock_exclusive_nonblocking(int fd) { FLOCK(F_TLOCK); }  
 static int unlock(int fd) { FLOCK(F_TLOCK); }  
   
 #else  
   
 #error unable to find file locking func  
   
 #endif  
 #endif  
 #endif  
 #endif  
   
 #else  
 static int lock_shared_blocking(int fd) { return 0; }  
 static int lock_exclusive_blocking(int fd) { return 0; }  
 static int lock_exclusive_nonblocking(int fd) { return 0; }  
 static int unlock(int fd) { return 0; }  
   
 #endif  
   
 // defines for globals  // defines for globals
   
 #define FILE_STATUS_NAME  "status"  #define FILE_STATUS_NAME  "status"
Line 133  const String file_status_name(FILE_STATU Line 79  const String file_status_name(FILE_STATU
 #define HTTP_HEADERS_NAME "headers"  #define HTTP_HEADERS_NAME "headers"
 #define HTTP_ANY_STATUS_NAME "any-status"  #define HTTP_ANY_STATUS_NAME "any-status"
 #define HTTP_CHARSET_NAME "charset"  #define HTTP_CHARSET_NAME "charset"
   #define HTTP_TABLES_NAME "tables"
   
 // statics  // statics
   
Line 141  static const String http_timeout_name(HT Line 88  static const String http_timeout_name(HT
 static const String http_headers_name(HTTP_HEADERS_NAME);  static const String http_headers_name(HTTP_HEADERS_NAME);
 static const String http_any_status_name(HTTP_ANY_STATUS_NAME);  static const String http_any_status_name(HTTP_ANY_STATUS_NAME);
 static const String http_charset_name(HTTP_CHARSET_NAME);  static const String http_charset_name(HTTP_CHARSET_NAME);
   static const String http_tables_name(HTTP_TABLES_NAME);
   
 // defines  // defines
   
Line 168  void fix_line_breaks(char *str, size_t& Line 116  void fix_line_breaks(char *str, size_t&
                 } else // \r, not \n = Macintosh                  } else // \r, not \n = Macintosh
                         bol=eol+1;                          bol=eol+1;
         }          }
         // last piece without \r, including terminating 0          // last piece without \r
         if(dest!=bol)          if(dest!=bol)
                 memcpy(dest, bol, eob-bol);                   memcpy(dest, bol, eob-bol); 
           str[length]=0; // terminating
 }  }
   
 char* file_read_text(Request_charsets& charsets,   char* file_read_text(Request_charsets& charsets, 
Line 185  char* file_read_text(Request_charsets& c Line 134  char* file_read_text(Request_charsets& c
 #ifdef PA_HTTP  #ifdef PA_HTTP
 //http request stuff  //http request stuff
   
   #undef CRLF
   #define CRLF "\r\n"
   
 static bool set_addr(struct sockaddr_in *addr, const char* host, const short port){  static bool set_addr(struct sockaddr_in *addr, const char* host, const short port){
     memset(addr, 0, sizeof(*addr));       memset(addr, 0, sizeof(*addr)); 
     addr->sin_family=AF_INET;      addr->sin_family=AF_INET;
Line 208  static int http_read_response(String& re Line 160  static int http_read_response(String& re
                 if(size<=0)                  if(size<=0)
                         break;                          break;
                 response.append_strdup(buf, size, String::L_TAINTED);                   response.append_strdup(buf, size, String::L_TAINTED); 
                 if(!result && (EOLat=response.pos("\r\n", 2))!=STRING_NOT_FOUND) { // checking status in first response                  if(!result && (EOLat=response.pos(CRLF, 2))!=STRING_NOT_FOUND) { // checking status in first response
                         const String& status_line=response.mid(0, (size_t)EOLat);                          const String& status_line=response.mid(0, (size_t)EOLat);
                         ArrayString astatus;                           ArrayString astatus; 
                         size_t pos_after=0;                          size_t pos_after=0;
Line 325  static void http_pass_header(HashStringV Line 277  static void http_pass_header(HashStringV
                              Http_pass_header_info *info) {                               Http_pass_header_info *info) {
     *info->request <<key<<": "      *info->request <<key<<": "
         << attributed_meaning_to_string(*value, String::L_HTTP_HEADER, false)          << attributed_meaning_to_string(*value, String::L_HTTP_HEADER, false)
         << "\n";           << CRLF; 
                   
     if(String(key, String::L_TAINTED).change_case(info->charsets->source(), String::CC_UPPER)=="USER-AGENT")      if(String(key, String::L_TAINTED).change_case(info->charsets->source(), String::CC_UPPER)=="USER-AGENT")
         info->user_agent_specified=true;          info->user_agent_specified=true;
Line 333  static void http_pass_header(HashStringV Line 285  static void http_pass_header(HashStringV
   
   
 static Charset* detect_charset(Charset& source_charset, const String& content_type_value) {  static Charset* detect_charset(Charset& source_charset, const String& content_type_value) {
         const StringBody CONTENT_TYPE_VALUE=          const String::Body CONTENT_TYPE_VALUE=
                 content_type_value.change_case(source_charset, String::CC_UPPER);                  content_type_value.change_case(source_charset, String::CC_UPPER);
         // content-type: xxx/xxx; source_charset=WE-NEED-THIS          // content-type: xxx/xxx; source_charset=WE-NEED-THIS
         // content-type: xxx/xxx; source_charset="WE-NEED-THIS"          // content-type: xxx/xxx; source_charset="WE-NEED-THIS"
Line 355  static Charset* detect_charset(Charset& Line 307  static Charset* detect_charset(Charset&
                         if(delim_pos!=STRING_NOT_FOUND)                          if(delim_pos!=STRING_NOT_FOUND)
                                 charset_end=delim_pos;                                  charset_end=delim_pos;
                 }                  }
                 const StringBody CHARSET_NAME_BODY=                  const String::Body CHARSET_NAME_BODY=
                         CONTENT_TYPE_VALUE.mid(charset_begin, charset_end);                          CONTENT_TYPE_VALUE.mid(charset_begin, charset_end);
   
                 return &charsets.get(CHARSET_NAME_BODY);                  return &charsets.get(CHARSET_NAME_BODY);
Line 371  struct File_read_http_result { Line 323  struct File_read_http_result {
         HashStringValue* headers;          HashStringValue* headers;
 };   }; 
 #endif  #endif
   /// @todo build .cookies field. use ^file.tables.SET-COOKIES.menu{ for now
 static File_read_http_result file_read_http(Request_charsets& charsets,   static File_read_http_result file_read_http(Request_charsets& charsets, 
                                             const String& file_spec,                                               const String& file_spec, 
                                             HashStringValue *options=0) {                                              HashStringValue *options=0) {
Line 448  static File_read_http_result file_read_h Line 401  static File_read_http_result file_read_h
                         request<<method;                          request<<method;
                 else                  else
                         request<<"GET";                          request<<"GET";
                 request<< " "<< uri <<" HTTP/1.0\n"                  request<< " "<< uri <<" HTTP/1.0" CRLF
                         "host: "<< host <<"\n";                           "host: "<< host << CRLF; 
                 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()) {                          if(HashStringValue *headers=vheaders->get_hash()) {
Line 462  static File_read_http_result file_read_h Line 415  static File_read_http_result file_read_h
                                         "headers param must be hash");                                           "headers param must be hash"); 
                 };                  };
                 if(!user_agent_specified) // defaulting                  if(!user_agent_specified) // defaulting
                         request << "user-agent: " DEFAULT_USER_AGENT "\n";                          request << "user-agent: " DEFAULT_USER_AGENT CRLF;
                 request<<"\n";                   request << CRLF; 
   
                 request_cstr=request.cstr(String::L_UNSPECIFIED);                  request_cstr=request.cstr(String::L_UNSPECIFIED);
         }          }
Line 481  static File_read_http_result file_read_h Line 434  static File_read_http_result file_read_h
                 timeout, fail_on_status_ne_200);                   timeout, fail_on_status_ne_200); 
                   
         //processing results              //processing results    
         size_t pos=response.pos("\r\n\r\n", 4);           size_t pos=response.pos(CRLF CRLF, 4); 
         if(pos==STRING_NOT_FOUND || pos<1) {          if(pos==STRING_NOT_FOUND || pos<1) {
                 throw Exception("http.response",                   throw Exception("http.response", 
                         &connect_string,                          &connect_string,
Line 492  static File_read_http_result file_read_h Line 445  static File_read_http_result file_read_h
                   
         ArrayString aheaders;          ArrayString aheaders;
         result.headers=new HashStringValue;          result.headers=new HashStringValue;
           VHash* vtables=new VHash;
           result.headers->put(http_tables_name, vtables);
           HashStringValue& tables=vtables->hash();
   
         size_t pos_after=0;          size_t pos_after=0;
         header_block.split(aheaders, pos_after, "\r\n");           header_block.split(aheaders, pos_after, CRLF); 
                   
         //processing headers          //processing headers
         size_t aheaders_count=aheaders.count();          size_t aheaders_count=aheaders.count();
Line 505  static File_read_http_result file_read_h Line 462  static File_read_http_result file_read_h
                         throw Exception("http.response",                           throw Exception("http.response", 
                                 &connect_string,                                  &connect_string,
                                 "bad response from host - bad header \"%s\"", line.cstr());                                  "bad response from host - bad header \"%s\"", line.cstr());
                 const StringBody HEADER_NAME=                  const String::Body HEADER_NAME=
                         line.mid(0, pos).change_case(charsets.source(), String::CC_UPPER);                          line.mid(0, pos).change_case(charsets.source(), String::CC_UPPER);
                 const String& header_value=line.mid(pos+2, line.length());                  const String& header_value=line.mid(pos+2, line.length());
                 if(HEADER_NAME=="CONTENT-TYPE")                  if(HEADER_NAME=="CONTENT-TYPE")
                         real_remote_charset=detect_charset(charsets.source(), header_value);                          real_remote_charset=detect_charset(charsets.source(), header_value);
   
                   // tables
                   {
                           Value *valready=(Value *)tables.get(HEADER_NAME);
                           bool existed=valready!=0;
                           Table *table;
                           if(existed) {
                                   // second+ appearence
                                   table=valready->get_table();
                           } else {
                                   // first appearence
                                   Table::columns_type columns =new ArrayString(1);
                                   *columns+=new String("value");
                                   table=new Table(columns);
                           }
                           // this string becomes next row
                           ArrayString& row=*new ArrayString(1);
                           row+=&header_value;
                           *table+=&row;
                           // not existed before? add it
                           if(!existed)
                                   tables.put(HEADER_NAME, new VTable(table));
                   }
   
                 result.headers->put(HEADER_NAME, new VString(header_value));                  result.headers->put(HEADER_NAME, new VString(header_value));
         }          }
         // defaulting to used-asked charset [it's never empty!]          // defaulting to used-asked charset [it's never empty!]
         if(!real_remote_charset)          if(!real_remote_charset)
                 real_remote_charset=asked_remote_charset;                  real_remote_charset=asked_remote_charset;
   
           // todo: do that only if ^file::load[text
         // output response          // output response
         String::C real_body=Charset::transcode(          String::C real_body=Charset::transcode(
                 String::C(raw_body.cstrm()/*must be modifiable*/, raw_body.length()),                  String::C(raw_body.cstrm()/*must be modifiable*/, raw_body.length()),
Line 548  static void file_read_action( Line 530  static void file_read_action(
                 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 %l 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
                 if(as_text) {                  if(as_text) {
Line 574  File_read_result file_read(Request_chars Line 556  File_read_result file_read(Request_chars
                 result.headers=http.headers;                   result.headers=http.headers; 
         } else {          } else {
 #endif  #endif
                   if(params && params->count())
                           throw Exception("parser.runtime",
                                   0,
                                   "invalid option passed");
   
                 File_read_action_info info={&result.str, &result.length};                   File_read_action_info info={&result.str, &result.length}; 
                 result.success=file_read_action_under_lock(file_spec,                   result.success=file_read_action_under_lock(file_spec, 
                         "read", file_read_action, &info,                           "read", file_read_action, &info, 
Line 586  File_read_result file_read(Request_chars Line 573  File_read_result file_read(Request_chars
                 // UTF-8 signature: EF BB BF                  // UTF-8 signature: EF BB BF
                 if(result.length>=3) {                  if(result.length>=3) {
                         char *in=(char *)result.str;                          char *in=(char *)result.str;
                         if(strncmp(in, "\xEB\xBB\xBF", 3)==0) {                          if(strncmp(in, "\xEF\xBB\xBF", 3)==0) {
                                 result.str=in+3; result.length-=3;// skip prefix                                  result.str=in+3; result.length-=3;// skip prefix
                         }                          }
                 }                  }
Line 634  bool file_read_action_under_lock(const S Line 621  bool file_read_action_under_lock(const S
         // later: it seems, even this does not help sometimes          // later: it seems, even this does not help sometimes
     if((f=open(fname, O_RDONLY|(as_text?_O_TEXT:_O_BINARY)))>=0) {      if((f=open(fname, O_RDONLY|(as_text?_O_TEXT:_O_BINARY)))>=0) {
                 try {                  try {
                         if(lock_shared_blocking(f)!=0)                          if(pa_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'", 
Line 653  bool file_read_action_under_lock(const S Line 640  bool file_read_action_under_lock(const S
   
                         action(finfo, f, file_spec, fname, as_text, context);                           action(finfo, f, file_spec, fname, as_text, context); 
                 } catch(...) {                  } catch(...) {
                         unlock(f);close(f);                           pa_unlock(f);close(f); 
                         if(fail_on_read_problem)                          if(fail_on_read_problem)
                                 rethrow;                                  rethrow;
                         return false;                                             return false;                   
                 }                   } 
   
                 unlock(f);close(f);                   pa_unlock(f);close(f); 
                 return true;                  return true;
     } else {      } else {
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
Line 696  bool file_write_action_under_lock( Line 683  bool file_write_action_under_lock(
                 O_CREAT|O_RDWR                  O_CREAT|O_RDWR
                 |(as_text?_O_TEXT:_O_BINARY)                  |(as_text?_O_TEXT:_O_BINARY)
                 |(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?pa_lock_exclusive_blocking(f):pa_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'", 
Line 714  bool file_write_action_under_lock( Line 701  bool file_write_action_under_lock(
                         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  #endif
                         unlock(f);close(f);                           pa_unlock(f);close(f); 
                         rethrow;                          rethrow;
                 }                  }
                                   
Line 722  bool file_write_action_under_lock( Line 709  bool file_write_action_under_lock(
                 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  #endif
                 unlock(f);close(f);                   pa_unlock(f);close(f); 
                 return true;                  return true;
         } else          } else
                 throw Exception(errno==EACCES?"file.access":0,                   throw Exception(errno==EACCES?"file.access":0, 
Line 768  static void rmdir(const String& file_spe Line 755  static void rmdir(const String& file_spe
                   
         rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::L_FILE_SPEC));           rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::L_FILE_SPEC)); 
 }  }
 bool file_delete(const String& file_spec, bool fail_on_read_problem) {  bool file_delete(const String& file_spec, bool fail_on_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.cstr(String::L_FILE_SPEC); 
         if(unlink(fname)!=0)          if(unlink(fname)!=0)
                 if(fail_on_read_problem)                  if(fail_on_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'", 
Line 1101  int __snprintf(char* b, size_t s, const Line 1088  int __snprintf(char* b, size_t s, const
     va_end(l);       va_end(l); 
         return r;          return r;
 }  }
   
 int pa_sleep(unsigned long secs, unsigned long usecs) {  
         for (;  usecs >= 1000000; ++secs, usecs -= 1000000);   
   
 #ifdef WIN32  
         Sleep(secs * 1000 + usecs / 1000);   
         return 0;  
 #else  
         struct timeval t;  
         t.tv_sec = secs;  
         t.tv_usec = usecs;  
         return (select(0, NULL, NULL, NULL, &t) == -1 ? errno : 0);   
 #endif  
 }  
   
   
Removed from v.1.143.2.21.2.27  
changed lines
  Added in v.1.165

E-mail: