[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.162 and 1.180

version 1.162, 2003/11/06 08:48:59 version 1.180, 2004/03/05 15:14:47
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001-2004 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)
 */  */
   
 static const char* IDENT_COMMON_C="$Date$";   static const char * const IDENT_COMMON_C="$Date$"; 
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_exception.h"  #include "pa_exception.h"
Line 64  int PASCAL closesocket(SOCKET); Line 64  int PASCAL closesocket(SOCKET);
 #       endif  #       endif
 #endif  #endif
   
 // locking constants  #       ifndef INADDR_NONE
 //#define PA_DEBUG_NO_LOCKING  #               define INADDR_NONE ((ulong) -1)
   #       endif
 #ifdef PA_DEBUG_NO_LOCKING  
   
 #ifdef HAVE_FLOCK  
   
 static int pa_lock_shared_blocking(int fd) { return flock(fd, LOCK_SH); }  
 static int pa_lock_exclusive_blocking(int fd) { return flock(fd, LOCK_EX); }  
 static int pa_lock_exclusive_nonblocking(int fd) { return flock(fd, LOCK_EX || LOCK_NB); }  
 static int pa_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 pa_lock_shared_blocking(int fd) { FLOCK(_LK_LOCK); }  
 static int pa_lock_exclusive_blocking(int fd) { FLOCK(_LK_LOCK); }  
 static int pa_lock_exclusive_nonblocking(int fd) { FLOCK(_LK_NBLCK); }  
 static int pa_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 pa_lock_shared_blocking(int fd) { FLOCK(F_SETLKW, F_RDLCK); }  
 static int pa_lock_exclusive_blocking(int fd) { FLOCK(F_SETLKW, F_WRLCK); }  
 static int pa_lock_exclusive_nonblocking(int fd) { FLOCK(F_SETLK, F_RDLCK); }  
 static int pa_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 pa_lock_shared_blocking(int fd) { FLOCK(F_LOCK); } // on intel solaris man doesn't have doc on shared blocking  
 static int pa_lock_exclusive_blocking(int fd) { FLOCK(F_LOCK); }  
 static int pa_lock_exclusive_nonblocking(int fd) { FLOCK(F_TLOCK); }  
 static int pa_unlock(int fd) { FLOCK(F_TLOCK); }  
   
 #else  
   
 #error unable to find file locking func  
   
 #endif  
 #endif  
 #endif  
 #endif  
   
 #else  
 static int pa_lock_shared_blocking(int fd) { return 0; }  
 static int pa_lock_exclusive_blocking(int fd) { return 0; }  
 static int pa_lock_exclusive_nonblocking(int fd) { return 0; }  
 static int pa_unlock(int fd) { return 0; }  
   
 #endif  
   
 // defines for globals  // defines for globals
   
Line 128  static int pa_unlock(int fd) { return 0; Line 76  static int pa_unlock(int fd) { return 0;
   
 const String file_status_name(FILE_STATUS_NAME);  const String file_status_name(FILE_STATUS_NAME);
   
 // defines for statics  // defines
   
 #define HTTP_METHOD_NAME  "method"  #define HTTP_METHOD_NAME  "method"
   #define HTTP_FORM_NAME  "form"
   #define HTTP_BODY_NAME  "body"
 #define HTTP_TIMEOUT_NAME    "timeout"  #define HTTP_TIMEOUT_NAME    "timeout"
 #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"  #define HTTP_TABLES_NAME "tables"
   #define HTTP_USER "user"
 // statics  #define HTTP_PASSWORD "password"
   
 static const String http_method_name(HTTP_METHOD_NAME);  
 static const String http_timeout_name(HTTP_TIMEOUT_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_charset_name(HTTP_CHARSET_NAME);  
 static const String http_tables_name(HTTP_TABLES_NAME);  
   
 // defines  // defines
   
Line 187  char* file_read_text(Request_charsets& c Line 130  char* file_read_text(Request_charsets& c
         return file.success?file.str:0;          return file.success?file.str:0;
 }  }
   
 #ifdef PA_HTTP  
 //http request stuff  //http request stuff
   #ifdef PA_HTTP
   
 #undef CRLF  #undef CRLF
 #define CRLF "\r\n"  #define CRLF "\r\n"
Line 198  static bool set_addr(struct sockaddr_in Line 141  static bool set_addr(struct sockaddr_in
     addr->sin_family=AF_INET;      addr->sin_family=AF_INET;
     addr->sin_port=htons(port);       addr->sin_port=htons(port); 
     if(host) {      if(host) {
                 if(struct hostent *hostIP=gethostbyname(host))                   ulong packed_ip=inet_addr(host);
                   struct hostent *hostIP = packed_ip==INADDR_NONE?
                           gethostbyname(host)
                           : gethostbyaddr((char *)&packed_ip, sizeof(packed_ip), AF_INET);
                   if(hostIP) 
                         memcpy(&addr->sin_addr, hostIP->h_addr, hostIP->h_length);                           memcpy(&addr->sin_addr, hostIP->h_addr, hostIP->h_length); 
                 else                  else
                         return false;                          return false;
Line 207  static bool set_addr(struct sockaddr_in Line 154  static bool set_addr(struct sockaddr_in
     return true;      return true;
 }  }
   
 static int http_read_response(String& response, int sock, bool fail_on_status_ne_200){  static int http_read_response(char*& response, size_t& response_size, int sock, bool fail_on_status_ne_200){
           response=(char*)pa_malloc_atomic(1/*terminator*/); // setting memory block type
           response[(response_size=0)]=0;
         int result=0;          int result=0;
         size_t EOLat=0;          char* EOLat=0;
         while(true) {          while(true) {
                 char *buf=new(PointerFreeGC) char[MAX_STRING];                   char buf[MAX_STRING*10]; 
                 ssize_t size=recv(sock, buf, MAX_STRING, 0);                   ssize_t received_size=recv(sock, buf, sizeof(buf), 0); 
                 if(size<=0)                  if(received_size<=0)
                         break;                          break;
                 response.append_strdup(buf, size, String::L_TAINTED);                   response=(char*)pa_realloc(response, response_size+received_size+1/*terminator*/);
                 if(!result && (EOLat=response.pos(CRLF, 2))!=STRING_NOT_FOUND) { // checking status in first response                  memcpy(response+response_size, buf, received_size);
                         const String& status_line=response.mid(0, (size_t)EOLat);                  response_size+=received_size;
                   response[response_size]=0;
   
                   if(!result && (EOLat=strstr(response, CRLF))) { // checking status in first response
                           const String status_line(pa_strdup(response, EOLat-response));
                         ArrayString astatus;                           ArrayString astatus; 
                         size_t pos_after=0;                          size_t pos_after=0;
                         status_line.split(astatus, pos_after, " ");                           status_line.split(astatus, pos_after, " "); 
Line 235  static int http_read_response(String& re Line 188  static int http_read_response(String& re
         else          else
                 throw Exception("http.response",                  throw Exception("http.response",
                         0,                          0,
                         "bad response from host - no status found (size=%lu)", response.length());                           "bad response from host - no status found (size=%u)", response_size); 
 }  }
   
 /* ********************** request *************************** */  /* ********************** request *************************** */
Line 251  static void timeout_handler(int sig){ Line 204  static void timeout_handler(int sig){
 }  }
 #endif  #endif
   
 static int http_request(String& response,  static int http_request(char*& response, size_t& response_size,
                         const char* host, int port,                           const char* host, int port, 
                         const char* request,                           const char* request, 
                         int timeout,                          int 
   #ifdef PA_USE_ALARM
                           timeout
   #endif
                           ,
                         bool fail_on_status_ne_200) {                          bool fail_on_status_ne_200) {
         if(!host)          if(!host)
                 throw Exception("http.host",                   throw Exception("http.host", 
Line 302  static int http_request(String& response Line 259  static int http_request(String& response
                                         0,                                           0, 
                                         "error sending request: %s (%d)", strerror(errno), errno);                                           "error sending request: %s (%d)", strerror(errno), errno); 
   
                         result=http_read_response(response, sock, fail_on_status_ne_200);                           result=http_read_response(response, response_size, sock, fail_on_status_ne_200); 
                         closesocket(sock);                           closesocket(sock); 
 #ifdef PA_USE_ALARM  #ifdef PA_USE_ALARM
                         alarm(0);                           alarm(0); 
Line 372  static Charset* detect_charset(Charset& Line 329  static Charset* detect_charset(Charset&
         return 0;          return 0;
 }  }
   
   static const String* basic_authorization_field(const char* user, const char* pass) {
           if(!user&& !pass)
                   return 0;
   
           String combined;  
           if(user)
                   combined<<user;
           combined<<":";
           if(pass)
                   combined<<pass;
           
           String* result=new String("Basic "); *result<<pa_base64(combined.cstr(), combined.length());
           return result;
   }
   
   /// @todo table value
   static void form_value2string(
                                                                     HashStringValue::key_type key, 
                                                                     HashStringValue::value_type value, 
                                                                     String* result) 
   {
           *result << String(key, String::L_TAINTED) << "=";
           result->append(value->as_string(), String::L_URI, true);
   }
   static const char* form2string(HashStringValue& form) {
           String string;
           form.for_each(form_value2string, &string);
           return 0; // todo
   }
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_read_http_result {  struct File_read_http_result {
         char *str; size_t length;          char *str; size_t length;
Line 382  struct File_read_http_result { Line 367  struct File_read_http_result {
 /// @todo build .cookies field. use ^file.tables.SET-COOKIES.menu{ for now  /// @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) {                                              bool as_text,
                                                   HashStringValue *options=0) {
         File_read_http_result result;          File_read_http_result result;
         char host[MAX_STRING];           char host[MAX_STRING]; 
         const char* uri;           const char* uri; 
         int port;          int port;
         const char* method=0;          const char* method="GET"; bool method_is_get;
           HashStringValue* form=0;
           const char* body_cstr=0;
         int timeout=2;          int timeout=2;
         bool fail_on_status_ne_200=true;          bool fail_on_status_ne_200=true;
         Value* vheaders=0;          Value* vheaders=0;
         Charset *asked_remote_charset=0;          Charset *asked_remote_charset=0;
           const char* user_cstr=0;
           const char* password_cstr=0;
   
         if(options) {          if(options) {
                 int valid_options=0;                  int valid_options=0;
                 if(Value* vmethod=options->get(http_method_name)) {                  if(Value* vmethod=options->get(HTTP_METHOD_NAME)) {
                         valid_options++;                          valid_options++;
                         method=vmethod->as_string().cstr();                          method=vmethod->as_string().cstr();
                 }                  } else if(Value* vform=options->get(HTTP_FORM_NAME)) {
                 if(Value* vtimeout=options->get(http_timeout_name)) {                          valid_options++;
                           form=vform->get_hash(); 
                   } else if(Value* vbody=options->get(HTTP_BODY_NAME)) {
                           valid_options++;
                           body_cstr=vbody->as_string().cstr(String::L_UNSPECIFIED);
                   } else if(Value* vtimeout=options->get(HTTP_TIMEOUT_NAME)) {
                         valid_options++;                          valid_options++;
                         timeout=vtimeout->as_int();                           timeout=vtimeout->as_int(); 
                 }                  } else if((vheaders=options->get(HTTP_HEADERS_NAME))) {
                 if(vheaders=options->get(http_headers_name)) {  
                         valid_options++;                          valid_options++;
                 }                  } else if(Value* vany_status=options->get(HTTP_ANY_STATUS_NAME)) {
                 if(Value* vany_status=options->get(http_any_status_name)) {  
                         valid_options++;                          valid_options++;
                         fail_on_status_ne_200=!vany_status->as_bool();                           fail_on_status_ne_200=!vany_status->as_bool(); 
                 }                  } else if(Value* vcharset_name=options->get(HTTP_CHARSET_NAME)) {
                 if(Value* vcharset_name=options->get(http_charset_name)) {  
                         valid_options++;                          valid_options++;
                         asked_remote_charset=&::charsets.get(vcharset_name->as_string().                          asked_remote_charset=&::charsets.get(vcharset_name->as_string().
                                 change_case(charsets.source(), String::CC_UPPER));                                  change_case(charsets.source(), String::CC_UPPER));
                   } else if(Value* vuser=options->get(HTTP_USER)) {
                           valid_options++;
                           user_cstr=vuser->as_string().cstr();
                   } else if(Value* vpassword=options->get(HTTP_PASSWORD)) {
                           valid_options++;
                           password_cstr=vpassword->as_string().cstr();
                 }                  }
   
                 if(valid_options!=options->count())                  if(valid_options!=options->count())
Line 424  static File_read_http_result file_read_h Line 422  static File_read_http_result file_read_h
         if(!asked_remote_charset) // defaulting to $request:charset          if(!asked_remote_charset) // defaulting to $request:charset
                 asked_remote_charset=&charsets.source();                  asked_remote_charset=&charsets.source();
   
           method_is_get=strcmp(method, "GET")==0;
           if(method_is_get && body_cstr)
                   throw Exception("parser.runtime",
                           0,
                           "you can not use $."HTTP_BODY_NAME" option with method GET");
   
         //preparing request          //preparing request
         String& connect_string=*new String;          String& connect_string=*new String;
         // not in ^sql{... L_SQL ...} spirit, but closer to ^file::load one          // not in ^sql{... L_SQL ...} spirit, but closer to ^file::load one
         connect_string.append(file_spec, String::L_URI); // tainted pieces -> URI pieces          connect_string.append(file_spec, String::L_URI); // tainted pieces -> URI pieces
   
         const char* request_cstr;          String request_head_and_body;
         {          {
                 // influence URLencoding of tainted pieces to String::L_URI lang                  // influence URLencoding of tainted pieces to String::L_URI lang
                 Temp_client_charset temp(charsets, *asked_remote_charset);                  Temp_client_charset temp(charsets, *asked_remote_charset);
Line 450  static File_read_http_result file_read_h Line 454  static File_read_http_result file_read_h
                 char* error_pos=0;                  char* error_pos=0;
                 port=port_cstr?strtol(port_cstr, &error_pos, 0):80;                  port=port_cstr?strtol(port_cstr, &error_pos, 0):80;
   
                   if(strchr(uri, '?') && form)
                           throw Exception("parser.runtime",
                                   0,
                                   "use either uri with ?params or $."HTTP_FORM_NAME" option");
   
                 //making request                  //making request head
                 String request;                  String head;
                 if(method)                  head << method;
                         request<<method;                  head << " " << uri;
                 else                  if(form)
                         request<<"GET";                          if(method_is_get)
                 request<< " "<< uri <<" HTTP/1.0" CRLF                                  head << form2string(*form);
                           else
                                   body_cstr = form2string(*form);
                   head <<" HTTP/1.0" CRLF
                         "host: "<< host << CRLF;                           "host: "<< host << CRLF; 
   
                   // http://www.ietf.org/rfc/rfc2617.txt
                   if(const String* authorization_field_value=basic_authorization_field(user_cstr, password_cstr))
                           head<<"authorization: "<<*authorization_field_value<<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()) {
                                 Http_pass_header_info info={&charsets, &request};                                  Http_pass_header_info info={&charsets, &head, false};
                                 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
Line 471  static File_read_http_result file_read_h Line 487  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 CRLF;                          head << "user-agent: " DEFAULT_USER_AGENT CRLF;
                 request << CRLF;   
                   const char* head_cstr=head.cstr(String::L_UNSPECIFIED);
   
                   // recode those pieces which are not in String::L_URI lang 
                   // [those violating HTTP standard, but widly used]
                   head_cstr=Charset::transcode(
                           String::C(head_cstr, strlen(head_cstr)),
                           charsets.source(),
                           *asked_remote_charset);
   
                   if(body_cstr) {
                           // recode those pieces which are not in String::L_URI lang 
                           // [those violating HTTP standard, but widly used]
                           body_cstr=Charset::transcode(
                                   String::C(body_cstr, strlen(body_cstr)),
                                   charsets.source(),
                                   *asked_remote_charset);
                   }
   
                 request_cstr=request.cstr(String::L_UNSPECIFIED);                  request_head_and_body << head_cstr;
                   if(body_cstr)
                           head << "content-length: " << format(strlen(body_cstr), "%u") << CRLF;
   
                   // end of header
                   request_head_and_body << CRLF; 
                   // body
                   if(body_cstr)
                           request_head_and_body << body_cstr;
         }          }
         // recode those pieces which are not in String::L_URI lang   
         // [those violating HTTP standard, but widly used]  
         request_cstr=Charset::transcode(  
                 String::C(request_cstr, strlen(request_cstr)),  
                 charsets.source(),  
                 *asked_remote_charset);  
                   
         //sending request          //sending request
         String response;          char* response;
         int status_code=http_request(response,          size_t response_size;
                 host, port, request_cstr,           int status_code=http_request(response, response_size,
                   host, port, request_head_and_body.cstr(), 
                 timeout, fail_on_status_ne_200);                   timeout, fail_on_status_ne_200); 
                   
         //processing results              //processing results    
         size_t pos=response.pos(CRLF CRLF, 4);           char* raw_body; size_t raw_body_size;
         if(pos==STRING_NOT_FOUND || pos<1) {          char* headers_end_at=strstr(response, CRLF CRLF /*change '4' below along!*/); 
           if(headers_end_at) {
                   raw_body=headers_end_at+4;
                   raw_body_size=response_size-(raw_body-response);
           } else
                 throw Exception("http.response",                   throw Exception("http.response", 
                         &connect_string,                          &connect_string,
                         "bad response from host - no headers found");                           "bad response from host - no headers found"); 
         }          
         const String& header_block=response.mid(0, pos);           *headers_end_at=0;
         const String& raw_body=response.mid(pos+4, response.length());           const String header_block(response, headers_end_at-response, true);
                   
         ArrayString aheaders;          ArrayString aheaders;
         result.headers=new HashStringValue;          result.headers=new HashStringValue;
         VHash* vtables=new VHash;          VHash* vtables=new VHash;
         result.headers->put(http_tables_name, vtables);          result.headers->put(HTTP_TABLES_NAME, vtables);
         HashStringValue& tables=vtables->hash();          HashStringValue& tables=vtables->hash();
   
         size_t pos_after=0;          size_t pos_after=0;
Line 513  static File_read_http_result file_read_h Line 553  static File_read_http_result file_read_h
         Charset* real_remote_charset=0; // undetected, yet          Charset* real_remote_charset=0; // undetected, yet
         for(size_t i=1; i<aheaders_count; i++) {          for(size_t i=1; i<aheaders_count; i++) {
                 const String& line=*aheaders.get(i);                  const String& line=*aheaders.get(i);
                 pos=line.pos(": ", 2);                   size_t pos=line.pos(": ", 2); 
                 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 554  static File_read_http_result file_read_h Line 594  static File_read_http_result file_read_h
                 real_remote_charset=asked_remote_charset;                  real_remote_charset=asked_remote_charset;
   
         // output response          // output response
         String::C real_body=Charset::transcode(          String::C real_body=String::C(raw_body, raw_body_size);
                 String::C(raw_body.cstrm()/*must be modifiable*/, raw_body.length()),          if(as_text && raw_body_size) // must be checked because transcode returns CONST string in case length==0, which contradicts hacking few lines below
                 *real_remote_charset,                  real_body=Charset::transcode(real_body, *real_remote_charset, charsets.source());
                 charsets.source());  
   
         result.str=const_cast<char *>(real_body.str); // hacking a little          result.str=const_cast<char *>(real_body.str); // hacking a little
         result.length=real_body.length;          result.length=real_body.length;
Line 575  struct File_read_action_info { Line 614  struct File_read_action_info {
 static void file_read_action(  static void file_read_action(
                              struct stat& finfo,                                struct stat& finfo, 
                              int f,                                int f, 
                              const String& file_spec, const char* fname, bool as_text,                                const String& file_spec, const char* /*fname*/, bool as_text, 
                              void *context) {                               void *context) {
         File_read_action_info& info=*static_cast<File_read_action_info *>(context);           File_read_action_info& info=*static_cast<File_read_action_info *>(context); 
         if(size_t to_read_size=(size_t)finfo.st_size) {           if(size_t to_read_size=(size_t)finfo.st_size) { 
Line 585  static void file_read_action( Line 624  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 %l bytes count not in [0..%lu] valid range",                                   "read failed: actually read %u bytes count not in [0..%u] 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 600  static void file_read_action( Line 639  static void file_read_action(
 File_read_result file_read(Request_charsets& charsets, const String& file_spec,   File_read_result file_read(Request_charsets& charsets, const String& file_spec, 
                            bool as_text, HashStringValue *params,                             bool as_text, HashStringValue *params,
                            bool fail_on_read_problem) {                             bool fail_on_read_problem) {
         File_read_result result={false};          File_read_result result={false, 0, 0, 0};
 #ifdef PA_HTTP  #ifdef PA_HTTP
         if(file_spec.starts_with("http://")) {          if(file_spec.starts_with("http://")) {
                 // fail on read problem                  // fail on read problem
                 File_read_http_result http=file_read_http(charsets, file_spec, params);                  File_read_http_result http=file_read_http(charsets, file_spec, as_text, params);
                 result.success=true;                  result.success=true;
                 result.str=http.str;                  result.str=http.str;
                 result.length=http.length;                  result.length=http.length;
Line 634  File_read_result file_read(Request_chars Line 673  File_read_result file_read(Request_chars
                 }                  }
   
                 fix_line_breaks((char *)(result.str), result.length);                   fix_line_breaks((char *)(result.str), result.length); 
                 // note: after fixing  
                 ((char*&)(result.str))[result.length]=0;  
         }          }
   
         return result;          return result;
Line 810  static void rmdir(const String& file_spe Line 847  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 1104  int __vsnprintf(char* b, size_t s, const Line 1141  int __vsnprintf(char* b, size_t s, const
         // note: on win32& maybe somewhere else          // note: on win32& maybe somewhere else
         // vsnprintf do not writes terminating 0 in 'buffer full' case, reducing          // vsnprintf do not writes terminating 0 in 'buffer full' case, reducing
         --s;          --s;
   
           // clients do not check for negative 's', feature: ignore such prints
           if((ssize_t)s<0)
                   return 0;
   
 #if _MSC_VER  #if _MSC_VER
         /*          /*
         win32:           win32: 
Line 1129  int __vsnprintf(char* b, size_t s, const Line 1171  int __vsnprintf(char* b, size_t s, const
   
         if(r<0)          if(r<0)
                 r=0;                  r=0;
         else if(r>s)          else if((size_t)r>s)
                 r=s;                  r=s;
 #endif  #endif
         b[r]=0;          b[r]=0;
Line 1143  int __snprintf(char* b, size_t s, const Line 1185  int __snprintf(char* b, size_t s, const
     va_end(l);       va_end(l); 
         return r;          return r;
 }  }
   
   /* mime64 functions are from libgmime[http://spruce.sourceforge.net/gmime/] lib */
   /*
    *  Authors: Michael Zucchi <notzed@helixcode.com>
    *           Jeffrey Stedfast <fejj@helixcode.com>
    *
    *  Copyright 2000 Helix Code, Inc. (www.helixcode.com)
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation; either version 2 of the License, or
    *  (at your option) any later version.
    *
    *  This program is distributed in the hope that it will be useful,
    *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    *  GNU General Public License for more details.
    *
    *  You should have received a copy of the GNU General Public License
    *  along with this program; if not, write to the Free Software
    *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
    *
    */
   static char *base64_alphabet =
           "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   
   /**
    * g_mime_utils_base64_encode_step:
    * @in: input stream
    * @inlen: length of the input
    * @out: output string
    * @state: holds the number of bits that are stored in @save
    * @save: leftover bits that have not yet been encoded
    *
    * Base64 encodes a chunk of data. Performs an 'encode step', only
    * encodes blocks of 3 characters to the output at a time, saves
    * left-over state in state and save (initialise to 0 on first
    * invocation).
    *
    * Returns the number of bytes encoded.
    **/
   static size_t
   g_mime_utils_base64_encode_step (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)
   {
           const register unsigned char *inptr;
           register unsigned char *outptr;
           
           if (inlen <= 0)
                   return 0;
           
           inptr = in;
           outptr = out;
           
           if (inlen + ((unsigned char *)save)[0] > 2) {
                   const unsigned char *inend = in + inlen - 2;
                   register int c1 = 0, c2 = 0, c3 = 0;
                   register int already;
                   
                   already = *state;
                   
                   switch (((char *)save)[0]) {
                   case 1: c1 = ((unsigned char *)save)[1]; goto skip1;
                   case 2: c1 = ((unsigned char *)save)[1];
                           c2 = ((unsigned char *)save)[2]; goto skip2;
                   }
                   
                   /* yes, we jump into the loop, no i'm not going to change it, its beautiful! */
                   while (inptr < inend) {
                           c1 = *inptr++;
                   skip1:
                           c2 = *inptr++;
                   skip2:
                           c3 = *inptr++;
                           *outptr++ = base64_alphabet [c1 >> 2];
                           *outptr++ = base64_alphabet [(c2 >> 4) | ((c1 & 0x3) << 4)];
                           *outptr++ = base64_alphabet [((c2 & 0x0f) << 2) | (c3 >> 6)];
                           *outptr++ = base64_alphabet [c3 & 0x3f];
                           /* this is a bit ugly ... */
                           if ((++already) >= 19) {
                                   *outptr++ = '\n';
                                   already = 0;
                           }
                   }
                   
                   ((unsigned char *)save)[0] = 0;
                   inlen = 2 - (inptr - inend);
                   *state = already;
           }
           
           //d(printf ("state = %d, inlen = %d\n", (int)((char *)save)[0], inlen));
           
           if (inlen > 0) {
                   register char *saveout;
                   
                   /* points to the slot for the next char to save */
                   saveout = & (((char *)save)[1]) + ((char *)save)[0];
                   
                   /* inlen can only be 0 1 or 2 */
                   switch (inlen) {
                   case 2: *saveout++ = *inptr++;
                   case 1: *saveout++ = *inptr++;
                   }
                   ((char *)save)[0] += inlen;
           }
           
           /*d(printf ("mode = %d\nc1 = %c\nc2 = %c\n",
                     (int)((char *)save)[0],
                     (int)((char *)save)[1],
                     (int)((char *)save)[2]));*/
           
           return (outptr - out);
   }
   
   /**
    * g_mime_utils_base64_encode_close:
    * @in: input stream
    * @inlen: length of the input
    * @out: output string
    * @state: holds the number of bits that are stored in @save
    * @save: leftover bits that have not yet been encoded
    *
    * Base64 encodes the input stream to the output stream. Call this
    * when finished encoding data with g_mime_utils_base64_encode_step to
    * flush off the last little bit.
    *
    * Returns the number of bytes encoded.
    **/
   static size_t
   g_mime_utils_base64_encode_close (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)
   {
           unsigned char *outptr = out;
           int c1, c2;
           
           if (inlen > 0)
                   outptr += g_mime_utils_base64_encode_step (in, inlen, outptr, state, save);
           
           c1 = ((unsigned char *)save)[1];
           c2 = ((unsigned char *)save)[2];
           
           switch (((unsigned char *)save)[0]) {
           case 2:
                   outptr[2] = base64_alphabet [(c2 & 0x0f) << 2];
                   goto skip;
           case 1:
                   outptr[2] = '=';
           skip:
                   outptr[0] = base64_alphabet [c1 >> 2];
                   outptr[1] = base64_alphabet [c2 >> 4 | ((c1 & 0x3) << 4)];
                   outptr[3] = '=';
                   outptr += 4;
                   break;
           }
           
           *outptr++ = 0;
           
           *save = 0;
           *state = 0;
           
           return (outptr - out);
   }
   
   char* pa_base64(const char *in, size_t len)
   {
           /* wont go to more than 2x size (overly conservative) */
           char* result=new(PointerFreeGC) char[len * 2 + 6];
           int state=0;
           int save=0;
           size_t filled=g_mime_utils_base64_encode_close ((const unsigned char*)in, len, 
                   (unsigned char*)result, &state, &save);
           assert(filled <= len * 2 + 6);
   
           return result;
   }
Removed from v.1.162  
changed lines
  Added in v.1.180

E-mail: