[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.164 and 1.281

version 1.164, 2003/11/10 06:51:06 version 1.281, 2015/04/02 22:04:41
Line 1 Line 1
 /** @file  /** @file
         Parser: commonly functions.          Parser: commonly functions.
   
         Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2000-2012 Art. Lebedev Studio (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$";    * BASE64 part
    *  Authors: Michael Zucchi <notzed@ximian.com>
    *           Jeffrey Stedfast <fejj@ximian.com>
    *
    *  Copyright 2000-2004 Ximian, Inc. (www.ximian.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.
    *
    */
   
 #include "pa_common.h"  #include "pa_common.h"
 #include "pa_exception.h"  #include "pa_exception.h"
 #include "pa_hash.h"  #include "pa_hash.h"
 #include "pa_globals.h"  #include "pa_globals.h"
 #include "pa_request_charsets.h"  
 #include "pa_charsets.h"  #include "pa_charsets.h"
   #include "pa_http.h"
   #include "pa_request_charsets.h"
   #include "pcre.h"
   #include "pa_request.h"
   
 #define PA_HTTP  #ifdef _MSC_VER
   
 #ifdef PA_HTTP  
 #include "pa_vstring.h"  
 #include "pa_vint.h"  
 #include "pa_vhash.h"  
 #include "pa_vtable.h"  
   
 #ifdef CYGWIN  
 #define _GNU_H_WINDOWS32_SOCKETS  
 // for PASCAL  
 #include <windows.h>  #include <windows.h>
 // SOCKET  #include <direct.h>
 typedef u_int   SOCKET;  
 int PASCAL closesocket(SOCKET);  
 #else  
 #       if defined(WIN32)  
 #               include <windows.h>  
 #       else  
 #               define closesocket close  
 #       endif  
 #endif  #endif
   
   #ifdef _MSC_VER
   #define pa_mkdir(path, mode) _mkdir(path)
 #else  #else
   #define pa_mkdir(path, mode) mkdir(path, mode)
 #       if defined(WIN32)  
 #               include <windows.h>  
 #       endif  
   
 #endif  #endif
   
   volatile const char * IDENT_PA_COMMON_C="$Id$" IDENT_PA_COMMON_H IDENT_PA_HASH_H IDENT_PA_ARRAY_H IDENT_PA_STACK_H; 
   
 // some maybe-undefined constants  // some maybe-undefined constants
   
 #ifndef _O_TEXT  #ifndef _O_TEXT
Line 72  int PASCAL closesocket(SOCKET); Line 76  int PASCAL closesocket(SOCKET);
   
 const String file_status_name(FILE_STATUS_NAME);  const String file_status_name(FILE_STATUS_NAME);
   
 // defines for statics  
   
 #define HTTP_METHOD_NAME  "method"  
 #define HTTP_TIMEOUT_NAME    "timeout"  
 #define HTTP_HEADERS_NAME "headers"  
 #define HTTP_ANY_STATUS_NAME "any-status"  
 #define HTTP_CHARSET_NAME "charset"  
 #define HTTP_TABLES_NAME "tables"  
   
 // statics  
   
 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  
   
 #define DEFAULT_USER_AGENT "parser3"  
   
 // functions  // functions
   
 void fix_line_breaks(char *str, size_t& length) {  char* file_read_text(Request_charsets& charsets, const String& file_spec, bool fail_on_read_problem, HashStringValue* params, bool transcode_result) {
         //_asm int 3;          File_read_result file=file_read(charsets, file_spec, true, params, fail_on_read_problem, 0, 0, 0, transcode_result);
         const char* const eob=str+length;  
         char* dest=str;  
         // fix DOS: \r\n -> \n  
         // fix Macintosh: \r -> \n  
         char* bol=str;  
         while(char* eol=(char*)memchr(bol, '\r', eob -bol)) {  
                 size_t len=eol-bol;  
                 if(dest!=bol)  
                         memcpy(dest, bol, len);   
                 dest+=len;  
                 *dest++='\n';   
   
                 if(&eol[1]<eob && eol[1]=='\n') { // \r, \n = DOS  
                         bol=eol+2;  
                         length--;   
                 } else // \r, not \n = Macintosh  
                         bol=eol+1;  
         }  
         // last piece without \r  
         if(dest!=bol)  
                 memcpy(dest, bol, eob-bol);   
         str[length]=0; // terminating  
 }  
   
 char* file_read_text(Request_charsets& charsets,   
                      const String& file_spec,   
                      bool fail_on_read_problem,  
                      HashStringValue* params/*, HashStringValue* * out_fields*/) {  
         File_read_result file=  
                 file_read(charsets, file_spec, true, params, fail_on_read_problem);  
         return file.success?file.str:0;          return file.success?file.str:0;
 }  }
   
 #ifdef PA_HTTP  char* file_load_text(Request& r, const String& file_spec, bool fail_on_read_problem, HashStringValue* params, bool transcode_result) {
 //http request stuff          File_read_result file=file_load(r, file_spec, true, params, fail_on_read_problem, 0, 0, 0, transcode_result);
           return file.success?file.str:0;
 #undef CRLF  
 #define CRLF "\r\n"  
   
 static bool set_addr(struct sockaddr_in *addr, const char* host, const short port){  
     memset(addr, 0, sizeof(*addr));   
     addr->sin_family=AF_INET;  
     addr->sin_port=htons(port);   
     if(host) {  
                 if(struct hostent *hostIP=gethostbyname(host))   
                         memcpy(&addr->sin_addr, hostIP->h_addr, hostIP->h_length);   
                 else  
                         return false;  
     } else   
                 addr->sin_addr.s_addr=INADDR_ANY;  
     return true;  
 }  }
   
 static int http_read_response(String& response, int sock, bool fail_on_status_ne_200){  /// these options were handled but not checked elsewhere, now check them
   int pa_get_valid_file_options_count(HashStringValue& options) {
         int result=0;          int result=0;
         size_t EOLat=0;          if(options.get(PA_SQL_LIMIT_NAME))
         while(true) {                  result++;
                 char *buf=new(PointerFreeGC) char[MAX_STRING];           if(options.get(PA_SQL_OFFSET_NAME))
                 ssize_t size=recv(sock, buf, MAX_STRING, 0);                   result++;
                 if(size<=0)          if(options.get(PA_COLUMN_SEPARATOR_NAME))
                         break;                  result++;
                 response.append_strdup(buf, size, String::L_TAINTED);           if(options.get(PA_COLUMN_ENCLOSER_NAME))
                 if(!result && (EOLat=response.pos(CRLF, 2))!=STRING_NOT_FOUND) { // checking status in first response                  result++;
                         const String& status_line=response.mid(0, (size_t)EOLat);          if(options.get(PA_CHARSET_NAME))
                         ArrayString astatus;                   result++;
                         size_t pos_after=0;          return result;
                         status_line.split(astatus, pos_after, " ");   
                         const String& status_code=*astatus.get(1);  
                         result=status_code.as_int();   
   
                         if(fail_on_status_ne_200 && result!=200)  
                                 throw Exception("http.status",  
                                         &status_code,  
                                         "invalid HTTP response status");  
                 }  
         }  
         if(result)  
                 return result;  
         else  
                 throw Exception("http.response",  
                         0,  
                         "bad response from host - no status found (size=%lu)", response.length());   
 }  
   
 /* ********************** request *************************** */  
   
 #if defined(SIGALRM) && defined(HAVE_SIGSETJMP) && defined(HAVE_SIGLONGJMP)  
 #       define PA_USE_ALARM  
 #endif  
   
 #ifdef PA_USE_ALARM  
 static sigjmp_buf timeout_env;  
 static void timeout_handler(int sig){  
     siglongjmp(timeout_env, 1);   
 }  
 #endif  
   
 static int http_request(String& response,  
                         const char* host, int port,   
                         const char* request,   
                         int timeout,  
                         bool fail_on_status_ne_200) {  
         if(!host)  
                 throw Exception("http.host",   
                         0,   
                         "zero hostname");  //never  
   
 #ifdef PA_USE_ALARM  
         signal(SIGALRM, timeout_handler);   
 #endif  
         int sock=-1;  
 #ifdef PA_USE_ALARM  
         if(sigsetjmp(timeout_env, 1)) {  
                 // stupid gcc [2.95.4] generated bad code  
                 // which failed to handle sigsetjmp+throw: crashed inside of pre-throw code.  
                 // rewritten simplier [though duplicating closesocket code]  
                 if(sock>=0)   
                         closesocket(sock);   
                 throw Exception("http.timeout",   
                         origin_string,   
                         "timeout occured while retrieving document");   
                 return 0; // never  
         } else {  
                 alarm(timeout);   
 #endif  
                 try {  
                         int result;  
                         struct sockaddr_in dest;  
                   
                         if(!set_addr(&dest, host, port))  
                                 throw Exception("http.host",   
                                         0,   
                                         "can not resolve hostname \"%s\"", host);   
                           
                         if((sock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP/*0*/))<0)  
                                 throw Exception("http.connect",   
                                         0,   
                                         "can not make socket: %s (%d)", strerror(errno), errno);   
                         if(connect(sock, (struct sockaddr *)&dest, sizeof(dest)))  
                                 throw Exception("http.connect",   
                                         0,   
                                         "can not connect to host \"%s\": %s (%d)", host, strerror(errno), errno);   
                         size_t request_size=strlen(request);  
                         if(send(sock, request, request_size, 0)!=(ssize_t)request_size)  
                                 throw Exception("http.connect",   
                                         0,   
                                         "error sending request: %s (%d)", strerror(errno), errno);   
   
                         result=http_read_response(response, sock, fail_on_status_ne_200);   
                         closesocket(sock);   
 #ifdef PA_USE_ALARM  
                         alarm(0);   
 #endif  
                         return result;  
                 } catch(...) {  
 #ifdef PA_USE_ALARM  
                         alarm(0);   
 #endif  
                         if(sock>=0)   
                                 closesocket(sock);   
                         rethrow;  
                 }  
 #ifdef PA_USE_ALARM  
         }  
 #endif  
 }  }
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct Http_pass_header_info {  struct File_read_action_info {
         Request_charsets* charsets;          char **data; size_t *data_size;
         String* request;          char* buf; size_t offset; size_t count;
         bool user_agent_specified;  }; 
 };  
 #endif  #endif
 static void http_pass_header(HashStringValue::key_type key,   
                              HashStringValue::value_type value,   
                              Http_pass_header_info *info) {  
     *info->request <<key<<": "  
         << attributed_meaning_to_string(*value, String::L_HTTP_HEADER, false)  
         << CRLF;   
           
     if(String(key, String::L_TAINTED).change_case(info->charsets->source(), String::CC_UPPER)=="USER-AGENT")  
         info->user_agent_specified=true;  
 }  
   
   static void file_read_action(struct stat& finfo, int f, const String& file_spec, const char* /*fname*/, bool as_text, void *context) {
 static Charset* detect_charset(Charset& source_charset, const String& content_type_value) {          File_read_action_info& info=*static_cast<File_read_action_info *>(context); 
         const String::Body CONTENT_TYPE_VALUE=          size_t to_read_size=info.count;
                 content_type_value.change_case(source_charset, String::CC_UPPER);          if(!to_read_size)
         // content-type: xxx/xxx; source_charset=WE-NEED-THIS                  to_read_size=(size_t)finfo.st_size;
         // content-type: xxx/xxx; source_charset="WE-NEED-THIS"          assert( !(info.buf && as_text) );
         // content-type: xxx/xxx; source_charset="WE-NEED-THIS";          if(to_read_size) {
         size_t before_charseteq_pos=CONTENT_TYPE_VALUE.pos("CHARSET=");                  if(info.offset)
         if(before_charseteq_pos!=STRING_NOT_FOUND) {                          lseek(f, info.offset, SEEK_SET);
                 size_t charset_begin=before_charseteq_pos+8/*CHARSET="*/;                  *info.data=info.buf ? info.buf : (char *)pa_malloc_atomic(to_read_size+1);
                 size_t open_quote_pos=CONTENT_TYPE_VALUE.pos('"', charset_begin);                  ssize_t result=read(f, *info.data, to_read_size);
                 bool quoted=open_quote_pos==charset_begin;                  if(result<0)
                 if(quoted)                          throw Exception("file.read", &file_spec, "read failed: %s (%d)", strerror(errno), errno);
                         charset_begin++; // skip opening '"'                  *info.data_size=result;
                 size_t charset_end=CONTENT_TYPE_VALUE.length();          } else { // empty file
                 if(quoted) {                  // for both, text and binary: for text we need that terminator, for binary we need nonzero pointer to be able to save such files
                         size_t close_quote_pos=CONTENT_TYPE_VALUE.pos('"', charset_begin);                  *info.data=(char *)pa_malloc_atomic(1);
                         if(close_quote_pos!=STRING_NOT_FOUND)                  *(char*)(*info.data)=0;
                                 charset_end=close_quote_pos;                  *info.data_size=0;
                 } else {                  return;
                         size_t delim_pos=CONTENT_TYPE_VALUE.pos(';', charset_begin);  
                         if(delim_pos!=STRING_NOT_FOUND)  
                                 charset_end=delim_pos;  
                 }  
                 const String::Body CHARSET_NAME_BODY=  
                         CONTENT_TYPE_VALUE.mid(charset_begin, charset_end);  
   
                 return &charsets.get(CHARSET_NAME_BODY);  
         }          }
   
         return 0;  
 }  }
   
   File_read_result file_read(Request_charsets& charsets, const String& file_spec, 
 #ifndef DOXYGEN                          bool as_text, HashStringValue *params,
 struct File_read_http_result {                          bool fail_on_read_problem,
         char *str; size_t length;                          char* buf, size_t offset, size_t count, bool transcode_text_result) {
         HashStringValue* headers;          File_read_result result={false, 0, 0, 0};
 };           if(params){
 #endif                  int valid_options=pa_get_valid_file_options_count(*params);
 /// @todo build .cookies field. use ^file.tables.SET-COOKIES.menu{ for now                  if(valid_options!=params->count())
 static File_read_http_result file_read_http(Request_charsets& charsets,                           throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
                                             const String& file_spec,   
                                             HashStringValue *options=0) {  
         File_read_http_result result;  
         char host[MAX_STRING];   
         const char* uri;   
         int port;  
         const char* method=0;  
         int timeout=2;  
         bool fail_on_status_ne_200=true;  
         Value* vheaders=0;  
         Charset *asked_remote_charset=0;  
   
         if(options) {  
                 int valid_options=0;  
                 if(Value* vmethod=options->get(http_method_name)) {  
                         valid_options++;  
                         method=vmethod->as_string().cstr();  
                 }  
                 if(Value* vtimeout=options->get(http_timeout_name)) {  
                         valid_options++;  
                         timeout=vtimeout->as_int();   
                 }  
                 if(vheaders=options->get(http_headers_name)) {  
                         valid_options++;  
                 }  
                 if(Value* vany_status=options->get(http_any_status_name)) {  
                         valid_options++;  
                         fail_on_status_ne_200=!vany_status->as_bool();   
                 }  
                 if(Value* vcharset_name=options->get(http_charset_name)) {  
                         valid_options++;  
                         asked_remote_charset=&::charsets.get(vcharset_name->as_string().  
                                 change_case(charsets.source(), String::CC_UPPER));  
                 }  
   
                 if(valid_options!=options->count())  
                         throw Exception("parser.runtime",  
                                 0,  
                                 "invalid option passed");  
         }          }
         if(!asked_remote_charset) // defaulting to $request:charset  
                 asked_remote_charset=&charsets.source();  
   
         //preparing request          File_read_action_info info={&result.str, &result.length, buf, offset, count}; 
         String& connect_string=*new String;  
         // not in ^sql{... L_SQL ...} spirit, but closer to ^file::load one  
         connect_string.append(file_spec, String::L_URI); // tainted pieces -> URI pieces  
   
         const char* request_cstr;  
         {  
                 // influence URLencoding of tainted pieces to String::L_URI lang  
                 Temp_client_charset temp(charsets, *asked_remote_charset);  
   
                 const char* connect_string_cstr=connect_string.cstr(String::L_UNSPECIFIED);   
   
                 const char* current=connect_string_cstr;  
                 if(strncmp(current, "http://", 7)!=0)  
                         throw Exception(0,   
                                 &connect_string,   
                                 "does not start with http://"); //never  
                 current+=7;  
   
                 strncpy(host, current, sizeof(host)-1);  host[sizeof(host)-1]=0;  
                 char* host_uri=lsplit(host, '/');   
                 uri=host_uri?current+(host_uri-1-host):"/";   
                 char* port_cstr=lsplit(host, ':');   
                 char* error_pos=0;  
                 port=port_cstr?strtol(port_cstr, &error_pos, 0):80;  
   
   
                 //making request  
                 String request;  
                 if(method)  
                         request<<method;  
                 else  
                         request<<"GET";  
                 request<< " "<< uri <<" HTTP/1.0" CRLF  
                         "host: "<< host << CRLF;   
                 bool user_agent_specified=false;  
                 if(vheaders && !vheaders->is_string()) { // allow empty  
                         if(HashStringValue *headers=vheaders->get_hash()) {  
                                 Http_pass_header_info info={&charsets, &request};  
                                 headers->for_each(http_pass_header, &info);   
                                 user_agent_specified=info.user_agent_specified;  
                         } else  
                                 throw Exception("parser.runtime",   
                                         &connect_string,  
                                         "headers param must be hash");   
                 };  
                 if(!user_agent_specified) // defaulting  
                         request << "user-agent: " DEFAULT_USER_AGENT CRLF;  
                 request << CRLF;   
   
                 request_cstr=request.cstr(String::L_UNSPECIFIED);  
         }  
         // 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  
         String response;  
         int status_code=http_request(response,  
                 host, port, request_cstr,   
                 timeout, fail_on_status_ne_200);   
           
         //processing results      
         size_t pos=response.pos(CRLF CRLF, 4);   
         if(pos==STRING_NOT_FOUND || pos<1) {  
                 throw Exception("http.response",   
                         &connect_string,  
                         "bad response from host - no headers found");   
         }  
         const String& header_block=response.mid(0, pos);   
         const String& raw_body=response.mid(pos+4, response.length());   
           
         ArrayString aheaders;  
         result.headers=new HashStringValue;  
         VHash* vtables=new VHash;  
         result.headers->put(http_tables_name, vtables);  
         HashStringValue& tables=vtables->hash();  
   
         size_t pos_after=0;          result.success=file_read_action_under_lock(file_spec, 
         header_block.split(aheaders, pos_after, CRLF);                   "read", file_read_action, &info, 
                           as_text, fail_on_read_problem); 
         //processing headers  
         size_t aheaders_count=aheaders.count();          if(as_text){
         Charset* real_remote_charset=0; // undetected, yet                  if(result.success){
         for(size_t i=1; i<aheaders_count; i++) {                          Charset* asked_charset=0;
                 const String& line=*aheaders.get(i);                          if(result.length>=3 && strncmp(result.str, "\xEF\xBB\xBF", 3)==0){
                 pos=line.pos(": ", 2);                                   // skip UTF-8 signature (BOM code)
                 if(pos==STRING_NOT_FOUND || pos<1)                                  result.str+=3;
                         throw Exception("http.response",                                   result.length-=3;
                                 &connect_string,                                  asked_charset=&UTF8_charset;
                                 "bad response from host - bad header \"%s\"", line.cstr());                          }
                 const String::Body HEADER_NAME=                          
                         line.mid(0, pos).change_case(charsets.source(), String::CC_UPPER);                          if(params)
                 const String& header_value=line.mid(pos+2, line.length());                                  if(Value* vcharset_name=params->get(PA_CHARSET_NAME))
                 if(HEADER_NAME=="CONTENT-TYPE")                                          asked_charset=&::charsets.get(vcharset_name->as_string().change_case(charsets.source(), String::CC_UPPER));
                         real_remote_charset=detect_charset(charsets.source(), header_value);  
                           if(result.length && transcode_text_result && asked_charset){ // length must be checked because transcode returns CONST string in case length==0, which contradicts hacking few lines below
                                   String::C body=String::C(result.str, result.length);
                                   body=Charset::transcode(body, *asked_charset, charsets.source());
   
                 // tables                                  result.str=const_cast<char*>(body.str); // hacking a little
                 {                                  result.length=body.length;
                         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));  
                 }                  }
                   if(result.length)
                 result.headers->put(HEADER_NAME, new VString(header_value));                          fix_line_breaks(result.str, result.length);
         }          }
         // defaulting to used-asked charset [it's never empty!]  
         if(!real_remote_charset)  
                 real_remote_charset=asked_remote_charset;  
   
         // output response  
         String::C real_body=Charset::transcode(  
                 String::C(raw_body.cstrm()/*must be modifiable*/, raw_body.length()),  
                 *real_remote_charset,  
                 charsets.source());  
   
         result.str=const_cast<char *>(real_body.str); // hacking a little  
         result.length=real_body.length;  
         result.headers->put(file_status_name, new VInt(status_code));  
         return result;          return result;
 }  }
   
 #endif  File_read_result file_load(Request& r, const String& file_spec, 
                           bool as_text, HashStringValue *params,
 #ifndef DOXYGEN                          bool fail_on_read_problem,
 struct File_read_action_info {                          char* buf, size_t offset, size_t count, bool transcode_text_result) {
         char **data; size_t *data_size;  
 };   
 #endif  
 static void file_read_action(  
                              struct stat& finfo,   
                              int f,   
                              const String& file_spec, const char* fname, bool as_text,   
                              void *context) {  
         File_read_action_info& info=*static_cast<File_read_action_info *>(context);   
         if(size_t to_read_size=(size_t)finfo.st_size) {   
                 *info.data=new(PointerFreeGC) char[to_read_size+(as_text?1:0)];   
                 *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)          File_read_result result={false, 0, 0, 0};
                         throw Exception(0,   
                                 &file_spec,   
                                 "read failed: actually read %l bytes count not in [0..%lu] valid range",   
                                         *info.data_size, to_read_size);   
         } else { // empty file  
                 if(as_text) {  
                         *info.data=new(PointerFreeGC) char[1];   
                         *(char*)(*info.data)=0;  
                 } else   
                         *info.data=0;  
                 *info.data_size=0;  
                 return;  
         }  
 }  
 File_read_result file_read(Request_charsets& charsets, const String& file_spec,   
                            bool as_text, HashStringValue *params,  
                            bool fail_on_read_problem) {  
         File_read_result result={false};  
 #ifdef PA_HTTP  
         if(file_spec.starts_with("http://")) {          if(file_spec.starts_with("http://")) {
                   if(offset || count)
                           throw Exception(PARSER_RUNTIME,
                                   0,
                                   "offset and load options are not supported for HTTP:// file load");
   
                 // 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=pa_internal_file_read_http(r, file_spec, as_text, params, transcode_text_result);
                 result.success=true;                  result.success=true;
                 result.str=http.str;                  result.str=http.str;
                 result.length=http.length;                  result.length=http.length;
                 result.headers=http.headers;                   result.headers=http.headers; 
         } else {          } else
 #endif                  result=
                 if(params && params->count())                          file_read(r.charsets, file_spec, as_text, params, fail_on_read_problem, buf, offset, count, transcode_text_result);
                         throw Exception("parser.runtime",  
                                 0,  
                                 "invalid option passed");  
   
                 File_read_action_info info={&result.str, &result.length};   
                 result.success=file_read_action_under_lock(file_spec,   
                         "read", file_read_action, &info,   
                         as_text, fail_on_read_problem);   
 #ifdef PA_HTTP  
         }  
 #endif  
   
         if(result.success && as_text) {  
                 // UTF-8 signature: EF BB BF  
                 if(result.length>=3) {  
                         char *in=(char *)result.str;  
                         if(strncmp(in, "\xEF\xBB\xBF", 3)==0) {  
                                 result.str=in+3; result.length-=3;// skip prefix  
                         }  
                 }  
   
                 fix_line_breaks((char *)(result.str), result.length);   
                 // note: after fixing  
                 ((char*&)(result.str))[result.length]=0;  
         }  
   
         return result;          return result;
 }  }
   
   
 #ifdef PA_SAFE_MODE   #ifdef PA_SAFE_MODE 
 void check_safe_mode(struct stat finfo, const String& file_spec, const char* fname) {   void check_safe_mode(struct stat finfo, const String& file_spec, const char* fname) {
         if(finfo.st_uid/*foreign?*/!=geteuid()           if(finfo.st_uid/*foreign?*/!=geteuid() 
                 && finfo.st_gid/*foreign?*/!=getegid())                   && finfo.st_gid/*foreign?*/!=getegid()) 
                 throw Exception("parser.runtime",                    throw Exception(PARSER_RUNTIME,  
                         &file_spec,                            &file_spec,  
                         "parser is in safe mode: "                           "parser is in safe mode: " 
                         "reading files of foreign group and user disabled "                           "reading files of foreign group and user disabled " 
Line 598  void check_safe_mode(struct stat finfo, Line 219  void check_safe_mode(struct stat finfo,
                         "fuid(%d)!=euid(%d) or fgid(%d)!=egid(%d)",                            "fuid(%d)!=euid(%d) or fgid(%d)!=egid(%d)",  
                                 fname,                                   fname, 
                                 finfo.st_uid, geteuid(),                                   finfo.st_uid, geteuid(), 
                                 finfo.st_gid, getegid());                                   finfo.st_gid, getegid());
 }   }
 #endif   #else
   void check_safe_mode(struct stat, const String&, const char*) {
   }
   #endif
   
   
   
 bool file_read_action_under_lock(const String& file_spec,   bool file_read_action_under_lock(const String& file_spec, 
                                 const char* action_name, File_read_action action, void *context,                                   const char* action_name, File_read_action action, void *context, 
                                 bool as_text,                                   bool as_text, 
                                 bool fail_on_read_problem) {                                  bool fail_on_read_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         int f;          int f;
   
         // first open, next stat:          // first open, next stat:
Line 618  bool file_read_action_under_lock(const S Line 244  bool file_read_action_under_lock(const S
         //   they delay update till open, so we would receive "!^test[" string          //   they delay update till open, so we would receive "!^test[" string
         //   if would do stat, next open.          //   if would do stat, next open.
         // 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(pa_lock_shared_blocking(f)!=0)                          if(pa_lock_shared_blocking(f)!=0)
                                 throw Exception("file.lock",                                   throw Exception("file.lock", 
Line 627  bool file_read_action_under_lock(const S Line 253  bool file_read_action_under_lock(const S
                                                         strerror(errno), errno, fname);                                                          strerror(errno), errno, fname);
   
                         struct stat finfo;                          struct stat finfo;
                         if(stat(fname, &finfo)!=0)                          if(fstat(f, &finfo)!=0)
                                 throw Exception("file.missing", // hardly possible: we just opened it OK                                  throw Exception("file.missing", // hardly possible: we just opened it OK
                                         &file_spec,                                           &file_spec, 
                                         "stat failed: %s (%d), actual filename '%s'",                                           "stat failed: %s (%d), actual filename '%s'", 
                                                 strerror(errno), errno, fname);                                                  strerror(errno), errno, fname);
   
 #ifdef PA_SAFE_MODE  
                         check_safe_mode(finfo, file_spec, fname);                          check_safe_mode(finfo, file_spec, fname);
 #endif  
   
                         action(finfo, f, file_spec, fname, as_text, context);                           action(finfo, f, file_spec, fname, as_text, context); 
                 } catch(...) {                  } catch(...) {
Line 647  bool file_read_action_under_lock(const S Line 271  bool file_read_action_under_lock(const S
   
                 pa_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)
                         throw Exception(errno==EACCES?"file.access":errno==ENOENT?"file.missing":0,                           throw Exception(errno==EACCES?"file.access"
                                                           :(errno==ENOENT || errno==ENOTDIR || errno==ENODEV)?"file.missing":0, 
                                 &file_spec,                                   &file_spec, 
                                 "%s failed: %s (%d), actual filename '%s'",                                   "%s failed: %s (%d), actual filename '%s'", 
                                         action_name, strerror(errno), errno, fname);                                          action_name, strerror(errno), errno, fname);
Line 657  bool file_read_action_under_lock(const S Line 282  bool file_read_action_under_lock(const S
         }          }
 }  }
   
 static void create_dir_for_file(const String& file_spec) {  void create_dir_for_file(const String& file_spec) {
         size_t pos_after=1;          size_t pos_after=1;
         size_t pos_before;          size_t pos_before;
         while((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND) {          while((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND) {
                 mkdir(file_spec.mid(0, pos_before).cstr(String::L_FILE_SPEC), 0775);                   pa_mkdir(file_spec.mid(0, pos_before).taint_cstr(String::L_FILE_SPEC), 0775); 
                 pos_after=pos_before+1;                  pos_after=pos_before+1;
         }          }
 }  }
   
 bool file_write_action_under_lock(  bool file_write_action_under_lock(
                                 const String& file_spec,                                   const String& file_spec, 
                                 const char* action_name, File_write_action action, void *context,                                   const char* action_name,
                                   File_write_action action,
                                   void *context, 
                                 bool as_text,                                   bool as_text, 
                                 bool do_append,                                   bool do_append, 
                                 bool do_block,                                   bool do_block, 
                                 bool fail_on_lock_problem) {                                  bool fail_on_lock_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         int f;          int f;
         if(access(fname, W_OK)!=0) // no          if(access(fname, W_OK)!=0) // no
                 create_dir_for_file(file_spec);                   create_dir_for_file(file_spec); 
Line 694  bool file_write_action_under_lock( Line 321  bool file_write_action_under_lock(
                 }                  }
   
                 try {                  try {
                         action(f, context);   #if (defined(HAVE_FCHMOD) && defined(PA_SAFE_MODE))
                           struct stat finfo;
                           if(fstat(f, &finfo)==0 && finfo.st_mode & 0111)
                                   fchmod(f, finfo.st_mode & 0666/*clear executable bits*/); // backward: ignore errors if any
   #endif
                           action(f, context);
                 } catch(...) {                  } catch(...) {
 #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
                         if(!do_append)                          if(!do_append)
Line 720  bool file_write_action_under_lock( Line 352  bool file_write_action_under_lock(
   
 #ifndef DOXYGEN  #ifndef DOXYGEN
 struct File_write_action_info {  struct File_write_action_info {
         const char* str; size_t length;          const char* str;
           size_t length;
 };   }; 
 #endif  #endif
   
 static void file_write_action(int f, void *context) {  static void file_write_action(int f, void *context) {
         File_write_action_info& info=*static_cast<File_write_action_info *>(context);           File_write_action_info& info=*static_cast<File_write_action_info *>(context); 
         if(info.length) {          if(info.length) {
                 int written=write(f, info.str, info.length);                   ssize_t written=write(f, info.str, info.length); 
                 if(written<0)                  if(written<0)
                         throw Exception(0,                           throw Exception("file.write", 0, "write failed: %s (%d)",  strerror(errno), errno); 
                                 0,                   if((size_t)written!=info.length)
                                 "write failed: %s (%d)",  strerror(errno), errno);                           throw Exception("file.write", 0, "write failed: %u of %u bytes written", written, info.length);
         }          }
 }  }
   
 void file_write(  void file_write(
                                 const String& file_spec,                                   Request_charsets& charsets,
                                 const char* data, size_t size,                                   const String& file_spec,
                                   const char* data,
                                   size_t size, 
                                 bool as_text,                                   bool as_text, 
                                 bool do_append) {                                  bool do_append,
                                   Charset* asked_charset) {
   
           if(as_text && asked_charset){
                   String::C body=String::C(data, size);
                   body=Charset::transcode(body, charsets.source(), *asked_charset);
                   data=body.str;
                   size=body.length;
           };
   
         File_write_action_info info={data, size};           File_write_action_info info={data, size}; 
   
         file_write_action_under_lock(          file_write_action_under_lock(
                 file_spec,                   file_spec, 
                 "write", file_write_action, &info,                   "write",
                   file_write_action,
                   &info, 
                 as_text,                   as_text, 
                 do_append);                   do_append); 
 }  }
   
   static size_t get_dir(char* fname, size_t helper_length){
           bool dir=false;
           size_t pos=0;
           for(pos=helper_length; pos; pos--){
                   char c=fname[pos-1];
                   if(c=='/' || c=='\\'){
                           fname[pos-1]=0;
                           dir=true;
                   } else if(dir) break;
           }
           return pos;
   }
   
   static bool entry_readable(char* fname, bool need_dir) {
           if(need_dir){
                   size_t size=strlen(fname);
                   while(size) {
                           char c=fname[size-1];
                           if(c=='/' || c=='\\')
                                   fname[--size]=0;
                           else
                                   break;
                   }
           }
   
           struct stat finfo;
           if(access(fname, R_OK)==0 && entry_exists(fname, &finfo)) {
                   bool is_dir=(finfo.st_mode&S_IFDIR) != 0;
                   return is_dir==need_dir;
           }
           return false;
   }
   
   static bool entry_readable(const String& file_spec, bool need_dir) {
           return entry_readable(file_spec.taint_cstrm(String::L_FILE_SPEC), need_dir);
   }
   
 // throws nothing! [this is required in file_move & file_delete]  // throws nothing! [this is required in file_move & file_delete]
 static void rmdir(const String& file_spec, size_t pos_after) {  static void rmdir(const String& file_spec, size_t pos_after) {
         size_t pos_before;          char* dir_spec=file_spec.taint_cstrm(String::L_FILE_SPEC);
         if((pos_before=file_spec.pos('/', pos_after))!=STRING_NOT_FOUND)          size_t length=strlen(dir_spec);
                 rmdir(file_spec, pos_before+1);           while( (length=get_dir(dir_spec, length)) && (length > pos_after) ){
           #ifdef _MSC_VER
         rmdir(file_spec.mid(0, pos_after-1/* / */).cstr(String::L_FILE_SPEC));                   if(!entry_readable(dir_spec, true))
                           break;
                   DWORD attrs=GetFileAttributes(dir_spec);
                   if(
                           (attrs==INVALID_FILE_ATTRIBUTES)
                           || !(attrs & FILE_ATTRIBUTE_DIRECTORY)
                           || (attrs & FILE_ATTRIBUTE_REPARSE_POINT)
                   )
                           break;
   #endif
                   if( rmdir(dir_spec) )
                           break;
           };
 }  }
 bool file_delete(const String& file_spec, bool fail_on_problem) {  
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);   bool file_delete(const String& file_spec, bool fail_on_problem, bool keep_empty_dirs) {
           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         if(unlink(fname)!=0)          if(unlink(fname)!=0)
                 if(fail_on_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, 
Line 765  bool file_delete(const String& file_spec Line 464  bool file_delete(const String& file_spec
                 else                  else
                         return false;                          return false;
   
         rmdir(file_spec, 1);           if(!keep_empty_dirs)
                   rmdir(file_spec, 1); 
   
         return true;          return true;
 }  }
 void file_move(const String& old_spec, const String& new_spec) {  
         const char* old_spec_cstr=old_spec.cstr(String::L_FILE_SPEC);   void file_move(const String& old_spec, const String& new_spec, bool keep_empty_dirs) {
         const char* new_spec_cstr=new_spec.cstr(String::L_FILE_SPEC);           const char* old_spec_cstr=old_spec.taint_cstr(String::L_FILE_SPEC); 
           const char* new_spec_cstr=new_spec.taint_cstr(String::L_FILE_SPEC); 
                   
         create_dir_for_file(new_spec);           create_dir_for_file(new_spec); 
   
Line 780  void file_move(const String& old_spec, c Line 482  void file_move(const String& old_spec, c
                         "rename failed: %s (%d), actual filename '%s' to '%s'",                           "rename failed: %s (%d), actual filename '%s' to '%s'", 
                                 strerror(errno), errno, old_spec_cstr, new_spec_cstr);                                  strerror(errno), errno, old_spec_cstr, new_spec_cstr);
   
         rmdir(old_spec, 1);           if(!keep_empty_dirs)
                   rmdir(old_spec, 1); 
 }  }
   
   
Line 793  bool entry_exists(const char* fname, str Line 496  bool entry_exists(const char* fname, str
 }  }
   
 bool entry_exists(const String& file_spec) {  bool entry_exists(const String& file_spec) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         return entry_exists(fname, 0);           return entry_exists(fname, 0); 
 }  }
   
 static bool entry_readable(const String& file_spec, bool need_dir) {  bool file_exist(const String& file_spec) {
         char* fname=file_spec.cstrm(String::L_FILE_SPEC);   
         if(need_dir) {  
                 size_t size=strlen(fname);   
                 while(size) {  
                         char c=fname[size-1];   
                         if(c=='/' || c=='\\')  
                                 fname[--size]=0;  
                         else  
                                 break;  
                 }  
         }  
         struct stat finfo;  
         if(access(fname, R_OK)==0 && entry_exists(fname, &finfo)) {  
                 bool is_dir=(finfo.st_mode&S_IFDIR) != 0;  
                 return is_dir==need_dir;  
         }  
         return false;  
 }  
 bool file_readable(const String& file_spec) {  
         return entry_readable(file_spec, false);           return entry_readable(file_spec, false); 
 }  }
 bool dir_readable(const String& file_spec) {  
   bool dir_exists(const String& file_spec) {
         return entry_readable(file_spec, true);           return entry_readable(file_spec, true); 
 }  }
 const String* file_readable(const String& path, const String& name) {  
   const String* file_exist(const String& path, const String& name) {
         String& result=*new String(path);          String& result=*new String(path);
         result << "/";           if(path.last_char() != '/')
                   result << "/"; 
         result << name;          result << name;
         return file_readable(result)?&result:0;          return file_exist(result)?&result:0;
 }  }
   
 bool file_executable(const String& file_spec) {  bool file_executable(const String& file_spec) {
     return access(file_spec.cstr(String::L_FILE_SPEC), X_OK)==0;          return access(file_spec.taint_cstr(String::L_FILE_SPEC), X_OK)==0;
 }  }
   
 bool file_stat(const String& file_spec,   bool file_stat(const String& file_spec, 
                            size_t& rsize,                           size_t& rsize,
                            time_t& ratime,                           time_t& ratime,
                            time_t& rmtime,                           time_t& rmtime,
                            time_t& rctime,                           time_t& rctime,
                            bool fail_on_read_problem) {                          bool fail_on_read_problem) {
         const char* fname=file_spec.cstr(String::L_FILE_SPEC);           const char* fname=file_spec.taint_cstr(String::L_FILE_SPEC); 
         struct stat finfo;          struct stat finfo;
         if(stat(fname, &finfo)!=0)          if(stat(fname, &finfo)!=0)
                 if(fail_on_read_problem)                  if(fail_on_read_problem)
Line 855  bool file_stat(const String& file_spec, Line 543  bool file_stat(const String& file_spec,
         return true;          return true;
 }  }
   
   /** 
           String related functions
   */
   
   bool capitalized(const char* s){
           bool upper=true;
           for(const char* c=s; *c; c++){
                   if(*c != (upper ? toupper((unsigned char)*c) : tolower((unsigned char)*c)))
                           return false;
                   upper=strchr("-_ ", *c) != 0;
           }
           return true;
   }
   
   const char* capitalize(const char* s){
           if(!s || capitalized(s))
                   return s;
   
           char* result=pa_strdup(s);
           if(result){
                   bool upper=true;
                   for(char* c=result; *c; c++){
                           *c=upper ? (char)toupper((unsigned char)*c) : (char)tolower((unsigned char)*c);
                           upper=strchr("-_ ", *c) != 0;
                   }
           }
           return (const char*)result;
   }
   
   void fix_line_breaks(char *str, size_t& length) {
           //_asm int 3;
           const char* const eob=str+length;
           char* dest=str;
           // fix DOS: \r\n -> \n
           // fix Macintosh: \r -> \n
           char* bol=str;
           while(char* eol=(char*)memchr(bol, '\r', eob -bol)) {
                   size_t len=eol-bol;
                   if(dest!=bol)
                           memmove(dest, bol, len); 
                   dest+=len;
                   *dest++='\n'; 
   
                   if(&eol[1]<eob && eol[1]=='\n') { // \r, \n = DOS
                           bol=eol+2;
                           length--; 
                   } else // \r, not \n = Macintosh
                           bol=eol+1;
           }
           // last piece without \r
           if(dest!=bol)
                   memmove(dest, bol, eob-bol); 
           str[length]=0; // terminating
   }
   
   /**
           scans for @a delim[default \n] in @a *row_ref, 
           @return piece of line before it or end of string, if no @a delim found
           assigns @a *row_ref to point right after delimiter if there were one
           or to zero if no @a delim were found.
   */
   
 char* getrow(char* *row_ref, char delim) {  char* getrow(char* *row_ref, char delim) {
     char* result=*row_ref;          char* result=*row_ref;
     if(result) {          if(result) {
                 *row_ref=strchr(result, delim);                   *row_ref=strchr(result, delim); 
                 if(*row_ref)                   if(*row_ref) 
                         *((*row_ref)++)=0;                           *((*row_ref)++)=0; 
                 else if(!*result)                   else if(!*result) 
                         return 0;                          return 0;
     }          }
     return result;          return result;
 }  }
   
 char* lsplit(char* string, char delim) {  char* lsplit(char* string, char delim) {
     if(string) {          if(string) {
                 char* v=strchr(string, delim);                   char* v=strchr(string, delim); 
                 if(v) {                  if(v) {
                         *v=0;                          *v=0;
                         return v+1;                          return v+1;
                 }                  }
     }          }
     return 0;          return 0;
 }  }
   
 char* lsplit(char* *string_ref, char delim) {  char* lsplit(char* *string_ref, char delim) {
     char* result=*string_ref;          char* result=*string_ref;
         char* next=lsplit(*string_ref, delim);           char* next=lsplit(*string_ref, delim); 
     *string_ref=next;          *string_ref=next;
     return result;          return result;
 }  }
   
 char* rsplit(char* string, char delim) {  char* rsplit(char* string, char delim) {
     if(string) {          if(string) {
                 char* v=strrchr(string, delim);                   char* v=strrchr(string, delim); 
                 if(v) {                  if(v) {
                         *v=0;                          *v=0;
                         return v+1;                          return v+1;
                 }                  }
     }          }
     return NULL;                  return NULL;    
 }  }
   
 /// @todo less stupid type detection  
 const char* format(double value, char* fmt) {  // format: %[flags][width][.precision]type      http://msdn.microsoft.com/ru-ru/library/56e442dc(en-us,VS.80).aspx
         char local_buf[MAX_NUMBER];   //              flags: '-', '+', ' ', '#', '0'          http://msdn.microsoft.com/ru-ru/library/8aky45ct(en-us,VS.80).aspx
         size_t size;  //              width, precision: non negative decimal number
           enum FormatType {
         if(fmt)          FormatInvalid,
                 if(strpbrk(fmt, "diouxX"))          FormatInt,
                         if(strpbrk(fmt, "ouxX"))          FormatUInt,
                                 size=snprintf(local_buf, sizeof(local_buf), fmt, (uint)value);           FormatDouble
                         else  };
   FormatType format_type(const char* fmt){
           enum FormatState {
                   Percent, 
                   Flags, 
                   Width,
                   Precision,
                   Done
           } state=Percent;
   
           FormatType result=FormatInvalid;
   
           const char* pos=fmt;
           while(char c=*(pos++)){
                   switch(state){
                           case Percent:
                                   if(c=='%'){
                                           state=Flags;
                                   } else {
                                           return FormatInvalid; // 1st char must be '%' only
                                   }
                                   break;
                           case Flags:
                                   if(strchr("-+ #0", c)!=0){
                                           break;
                                   }
                                   // go to the next step
                           case Width:
                                   if(c=='.'){
                                           state=Precision;
                                           break;
                                   }
                                   // go to the next step
                           case Precision:
                                   if(c>='0' && c<='9'){
                                           if(state == Flags) state=Width; // no more flags
                                           break;
                                   } else if(c=='d' || c=='i'){
                                           result=FormatInt;
                                   } else if(strchr("feEgG", c)!=0){
                                           result=FormatDouble;
                                   } else if(strchr("uoxX", c)!=0){
                                           result=FormatUInt;
                                   } else {
                                           return FormatInvalid; // invalid char
                                   }
                                   state=Done;
                                   break;
                           case Done:
                                   return FormatInvalid; // no chars allowed after 'type'
                   }
           }
           return result;
   }
   
   
   const char* format(double value, const char* fmt) {
           char local_buf[MAX_NUMBER];
           int size=-1;
   
           if(fmt && strlen(fmt)){
                   switch(format_type(fmt)){
                           case FormatDouble:
                                   size=snprintf(local_buf, sizeof(local_buf), fmt, value); 
                                   break;
                           case FormatInt:
                                 size=snprintf(local_buf, sizeof(local_buf), fmt, (int)value);                                   size=snprintf(local_buf, sizeof(local_buf), fmt, (int)value); 
                 else                                  break;
                         size=snprintf(local_buf, sizeof(local_buf), fmt, value);                           case FormatUInt:
         else                                  size=snprintf(local_buf, sizeof(local_buf), fmt, (uint)value); 
                 size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);                                   break;
                                   case FormatInvalid:
         return pa_strdup(local_buf, size);                                  throw Exception(PARSER_RUNTIME, 
                                           0, 
                                           "Incorrect format string '%s' was specified.", fmt);
                   }
           } else
                   size=snprintf(local_buf, sizeof(local_buf), "%d", (int)value);
   
           if(size < 0 || size >= MAX_NUMBER-1){ // on win32 we manually reduce max size while printing
                   throw Exception(PARSER_RUNTIME, 
                           0, 
                           "Error occure white executing snprintf with format string '%s'.", fmt);
           }
   
           return pa_strdup(local_buf, (size_t)size);
 }  }
   
 size_t stdout_write(const void *buf, size_t size) {  size_t stdout_write(const void *buf, size_t size) {
 #ifdef WIN32  #ifdef WIN32
           size_t to_write = size;
         do{          do{
                 int chunk_written=fwrite(buf, 1, min((size_t)8*0x400, size), stdout);                   int chunk_written=fwrite(buf, 1, min((size_t)8*0x400, size), stdout); 
                 if(chunk_written<=0)                  if(chunk_written<=0)
Line 925  size_t stdout_write(const void *buf, siz Line 754  size_t stdout_write(const void *buf, siz
                 buf=((const char*)buf)+chunk_written;                  buf=((const char*)buf)+chunk_written;
         } while(size>0);           } while(size>0); 
   
         return size;          return to_write-size;
 #else  #else
         return fwrite(buf, 1, size, stdout);           return fwrite(buf, 1, size, stdout); 
 #endif  #endif
 }  }
   
 char* unescape_chars(const char* cp, int len) {  enum EscapeState {
         char* s=new(PointerFreeGC) char[len + 1];           EscapeRest, 
         enum EscapeState {          EscapeFirst, 
                 EscapeRest,           EscapeSecond,
                 EscapeFirst,           EscapeUnicode
                 EscapeSecond  };
         } escapeState=EscapeRest;  
         int escapedValue=0;  // @todo prescan for reduce required size (unescaped sting in 1 byte charset requires less memory usually)
   char* unescape_chars(const char* cp, int len, Charset* charset, bool js){
           char* s=new(PointerFreeGC) char[len+1]; // must be enough (%uXXXX==6 bytes, max utf-8 char length==6 bytes)
           char* dst=s;
           EscapeState escapeState=EscapeRest;
           uint escapedValue=0;
         int srcPos=0;          int srcPos=0;
         int dstPos=0;          short int jsCnt=0;
         while(srcPos < len) {          while(srcPos<len){
                 int ch=cp[srcPos];                   uchar c=(uchar)cp[srcPos]; 
                 switch(escapeState) {                  if(c=='%' || (c=='\\' && js)){
                         case EscapeRest:                          escapeState=EscapeFirst;
                         if(ch=='%') {                  } else {
                                 escapeState=EscapeFirst;                          switch(escapeState) {
                         } else if(ch=='+') {                                  case EscapeRest:
                                 s[dstPos++]=' ';                                           if(!js && c=='+'){
                         } else {                                                  *dst++=' ';
                                 s[dstPos++]=ch;                                           } else {
                                                   *dst++=c;
                                           }
                                           break;
                                   case EscapeFirst:
                                           if(charset && c=='u'){
                                                   // escaped unicode value: %u0430
                                                   jsCnt=0;
                                                   escapedValue=0;
                                                   escapeState=EscapeUnicode;
                                           } else {
                                                   if(isxdigit(c)){
                                                           escapedValue=hex_value[c] << 4;
                                                           escapeState=EscapeSecond;
                                                   } else {
                                                           *dst++=c;
                                                           escapeState=EscapeRest;
                                                   }
                                           }
                                           break;
                                   case EscapeSecond:
                                           if(isxdigit(c)){
                                                   escapedValue+=hex_value[c]; 
                                                   *dst++=(char)escapedValue;
                                           }
                                           escapeState=EscapeRest;
                                           break;
                                   case EscapeUnicode:
                                           if(isxdigit(c)){
                                                   escapedValue=(escapedValue << 4) + hex_value[c];
                                                   if(++jsCnt==4){
                                                           // transcode utf8 char to client charset (we can lost some chars here)
                                                           charset->store_Char((XMLByte*&)dst, (XMLCh)escapedValue, '?');
                                                           escapeState=EscapeRest;
                                                   }
                                           } else {
                                                   // not full unicode value
                                                   escapeState=EscapeRest;
                                           }
                                           break;
                         }                          }
                         break;  
                         case EscapeFirst:  
                         escapedValue=hex_value[ch] << 4;          
                         escapeState=EscapeSecond;  
                         break;  
                         case EscapeSecond:  
                         escapedValue +=hex_value[ch];   
                         s[dstPos++]=escapedValue;  
                         escapeState=EscapeRest;  
                         break;  
                 }                  }
                 srcPos++;   
                   srcPos++;
         }          }
         s[dstPos]=0;  
           *dst=0; // zero-termination
         return s;          return s;
 }  }
   
   char *search_stop(char*& current, char cstop_at) {
           // sanity check
           if(!current)
                   return 0;
   
           // skip leading WS
           while(*current==' ' || *current=='\t')
                   current++;
           if(!*current)
                   return current=0;
   
           char *result=current;
           if(char *pstop_at=strchr(current, cstop_at)) {
                   *pstop_at=0;
                   current=pstop_at+1;
           } else
                   current=0;
           return result;
   }
   
 #ifdef WIN32  #ifdef WIN32
 void back_slashes_to_slashes(char* s) {  void back_slashes_to_slashes(char* s) {
         if(s)          if(s)
Line 976  void back_slashes_to_slashes(char* s) { Line 861  void back_slashes_to_slashes(char* s) {
                         if(*s=='\\')                          if(*s=='\\')
                                 *s='/';                                   *s='/'; 
 }  }
 /*  
 void slashes_to_back_slashes(char* s) {  
         if(s)  
                 for(; *s; s++)  
                         if(*s=='/')  
                                 *s='\\';   
 }  
 */  
 #endif  #endif
   
 bool StrEqNc(const char* s1, const char* s2, bool strict) {  size_t strpos(const char *str, const char *substr) {
         while(true) {          const char *p = strstr(str, substr);
                 if(!(*s1)) {          return (p==0)?STRING_NOT_FOUND:p-str;
                         if(!(*s2))  }
                                 return true;  
                         else  int remove_crlf(char* start, char* end) {
                                 return !strict;          char* from=start;
                 } else if(!(*s2))          char* to=start;
                         return !strict;          bool skip=false;
                 if(isalpha(*s1)) {          while(from < end){
                         if(tolower(*s1) !=tolower(*s2))                  switch(*from){
                                 return false;                          case '\n':
                 } else if((*s1) !=(*s2))                          case '\r':
                         return false;                          case '\t':
                 s1++;                           case ' ':
                 s2++;                                   if(!skip){
                                           *to=' ';
                                           to++;
                                           skip=true;
                                   }
                                   break;
                           default:
                                   if(from != to)
                                           *to=*from;
                                   to++;
                                   skip=false;
                   }
                   from++;
         }          }
           return to-start;
 }  }
   
 static bool isLeap(int year) {  const char* hex_digits="0123456789ABCDEF";
     return !(  
              (year % 4) || ((year % 400) && !(year % 100))  
             );   
 }  
   
 int getMonthDays(int year, int month) {  const char* hex_string(unsigned char* bytes, size_t size, bool upcase) {
     int monthDays[]={          char *bytes_hex=new(PointerFreeGC) char [size*2/*byte->hh*/+1/*for zero-teminator*/];
         31,           unsigned char *src=bytes;
         isLeap(year) ? 29 : 28,           unsigned char *end=bytes+size;
         31,           char *dest=bytes_hex;
         30,   
         31,   
         30,   
         31,   
         31,   
         30,   
         31,   
         30,   
         31  
     };   
     return monthDays[month];   
 }  
   
 void remove_crlf(char* start, char* end) {  
         for(char* p=start; p<end; p++)  
                 switch(*p) {  
                         case '\n': *p='|';  break;  
                         case '\r': *p=' ';  break;  
                 }  
 }  
   
           const char *hex=upcase? hex_digits : "0123456789abcdef";
   
           for(; src<end; src++) {
                   *dest++=hex[*src/0x10];
                   *dest++=hex[*src%0x10];
           }
           *dest=0;
   
           return bytes_hex;
   }
   
 /// must be last in this file  /// must be last in this file
 #undef vsnprintf  #undef vsnprintf
Line 1048  int __vsnprintf(char* b, size_t s, const Line 924  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;
 #if _MSC_VER  
           // clients do not check for negative 's', feature: ignore such prints
           if((ssize_t)s<0)
                   return 0;
   
   #ifdef _MSC_VER
         /*          /*
         win32:           win32: 
         mk:@MSITStore:C:\Program%20Files\Microsoft%20Visual%20Studio\MSDN\2001APR\1033\vccore.chm::/html/_crt__vsnprintf.2c_._vsnwprintf.htm          mk:@MSITStore:C:\Program%20Files\Microsoft%20Visual%20Studio\MSDN\2001APR\1033\vccore.chm::/html/_crt__vsnprintf.2c_._vsnwprintf.htm
Line 1073  int __vsnprintf(char* b, size_t s, const Line 954  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 1082  int __vsnprintf(char* b, size_t s, const Line 963  int __vsnprintf(char* b, size_t s, const
   
 int __snprintf(char* b, size_t s, const char* f, ...) {  int __snprintf(char* b, size_t s, const char* f, ...) {
         va_list l;          va_list l;
     va_start(l, f);           va_start(l, f); 
     int r=__vsnprintf(b, s, f, l);           int r=__vsnprintf(b, s, f, l); 
     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 const 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.
    **/
   
   #define BASE64_GROUPS_IN_LINE 19
   
   static size_t
   g_mime_utils_base64_encode_step (const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save)
   {
           register const 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) >= BASE64_GROUPS_IN_LINE) {
                                   *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 = *(char *)save+(char)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);
   }
   
   static unsigned char gmime_base64_rank[256] = {
           255,255,255,255,255,255,255,255,255,254,254,255,255,254,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           254,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
            52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
           255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
           255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
           255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
   };
   
   /**
    * g_mime_utils_base64_decode_step:
    * @in: input stream
    * @inlen: max length of data to decode
    * @out: output stream
    * @state: holds the number of bits that are stored in @save
    * @save: leftover bits that have not yet been decoded
    * @strict: only base64 and whitespace chars are allowed
    *
    * Decodes a chunk of base64 encoded data.
    *
    * Returns the number of bytes decoded (which have been dumped in @out).
    **/
   size_t
   g_mime_utils_base64_decode_step(const unsigned char *in, size_t inlen, unsigned char *out, int *state, int *save, bool strict=false)
   {
           const unsigned char *inptr;
           unsigned char *outptr;
           const unsigned char *inend;
           int saved;
           unsigned char c;
           int i;
           
           inend = in + inlen;
           outptr = out;
           
           /* convert 4 base64 bytes to 3 normal bytes */
           saved = *save;
           i = *state;
           inptr = in;
           while (inptr < inend) {
                   c = gmime_base64_rank[*inptr++];
                   switch(c) {
                           case 0xff: // non-base64 and non-whitespace chars. not allowed in strict mode
                                   if(strict)
                                           throw Exception(BASE64_FORMAT, 0, "Invalid base64 char on position %d is detected", inptr-in-1);
                           case 0xfe: // whitespace chars 0x09, 0x0A, 0x0D, 0x20 are allowed in any mode
                                   break;
                           default:
                                   saved = (saved << 6) | c;
                                   i++;
                                   if (i == 4) {
                                           *outptr++ = (unsigned char)(saved >> 16);
                                           *outptr++ = (unsigned char)(saved >> 8);
                                           *outptr++ = (unsigned char)(saved);
                                           i = 0;
                                   }
                   }
           }
           
           *save = saved;
           *state = i;
           
           /* quick scan back for '=' on the end somewhere */
           /* fortunately we can drop 1 output char for each trailing = (upto 2) */
           i = 2;
           while (inptr > in && i) {
                   inptr--;
                   if (gmime_base64_rank[*inptr] <= 0xfe) {
                           if (*inptr == '=' && outptr > out)
                                   outptr--;
                           i--;
                   }
           }
           
           /* if i != 0 then there is a truncation error! */
           return (outptr - out);
   }
   
   
   char* pa_base64_encode(const char *in, size_t in_size){
           size_t new_size = ((in_size / 3 + 1) * 4);
           new_size += new_size / (BASE64_GROUPS_IN_LINE * 4)/*new lines*/ + 1/*zero terminator*/;
           char* result = new(PointerFreeGC) char[new_size];
           int state=0;
           int save=0;
   #ifndef NDEBUG
           size_t filled=
   #endif
                   g_mime_utils_base64_encode_close ((const unsigned char*)in, in_size, (unsigned char*)result, &state, &save);
   
           //throw Exception(PARSER_RUNTIME, 0, "%d %d %d", in_size, new_size, filled);
           assert(filled <= new_size);
   
           return result;
   }
   
   struct File_base64_action_info {
           unsigned char** base64;
   }; 
   
   static void file_base64_file_action(
                                   struct stat& finfo, 
                                   int f, 
                                   const String&, const char* /*fname*/, bool, 
                                   void *context) {
   
           if(finfo.st_size) { 
                   File_base64_action_info& info=*static_cast<File_base64_action_info *>(context);
                   *info.base64=new(PointerFreeGC) unsigned char[finfo.st_size * 2 + 6]; 
                   unsigned char* base64 = *info.base64;
                   int state=0;
                   int save=0;
                   int nCount;
                   do {
                           unsigned char buffer[FILE_BUFFER_SIZE];
                           nCount = file_block_read(f, buffer, sizeof(buffer));
                           if( nCount ){
                                   size_t filled=g_mime_utils_base64_encode_step ((const unsigned char*)buffer, nCount, base64, &state, &save);
                                   base64+=filled;
                           }
                   } while(nCount > 0);
                   g_mime_utils_base64_encode_close (0, 0, base64, &state, &save);
           }
   }
   
   char* pa_base64_encode(const String& file_spec){
           unsigned char* base64=0;
           File_base64_action_info info={&base64}; 
   
           file_read_action_under_lock(file_spec, 
                   "pa_base64_encode", file_base64_file_action, &info);
   
           return (char*)base64; 
   }
   
   void pa_base64_decode(const char *in, size_t in_size, char*& result, size_t& result_size, bool strict) {
           // every 4 base64 bytes are converted into 3 normal bytes
           // not full set (tail) of 4-bytes set is ignored
           size_t new_size=in_size/4*3;
           result=new(PointerFreeGC) char[new_size+1/*terminator*/];
   
           int state=0;
           int save=0;
           result_size=
                   g_mime_utils_base64_decode_step ((const unsigned char*)in, in_size,
                   (unsigned char*)result, &state, &save, strict);
           assert(result_size <= new_size);
           result[result_size]=0; // for text files
   
           if(strict && state!=0)
                   throw Exception(BASE64_FORMAT, 0, "Unexpected end of chars");
   }
   
   
   int file_block_read(const int f, unsigned char* buffer, const size_t size){
           int nCount = read(f, buffer, size);
           if (nCount < 0)
                   throw Exception("file.read", 
                           0, 
                           "read failed: %s (%d)",  strerror(errno), errno); 
           return nCount;
   }
   
   static unsigned long crc32Table[256];
   static void InitCrc32Table()
   {
           if(crc32Table[1] == 0){
                   // This is the official polynomial used by CRC32 in PKZip.
                   // Often times the polynomial shown reversed as 0x04C11DB7.
                   static const unsigned long dwPolynomial = 0xEDB88320;
   
                   for(int i = 0; i < 256; i++)
                   {
                           unsigned long dwCrc = i;
                           for(int j = 8; j > 0; j--)
                           {
                                   if(dwCrc & 1)
                                           dwCrc = (dwCrc >> 1) ^ dwPolynomial;
                                   else
                                           dwCrc >>= 1;
                           }
                           crc32Table[i] = dwCrc;
                   }
           }
   }
   
   inline void CalcCrc32(const unsigned char byte, unsigned long &crc32)
   {
           crc32 = ((crc32) >> 8) ^ crc32Table[(byte) ^ ((crc32) & 0x000000FF)];
   }
   
   
   const unsigned long pa_crc32(const char *in, size_t in_size){
           unsigned long crc32=0xFFFFFFFF;
   
           InitCrc32Table();
           for(size_t i = 0; i<in_size; i++)
                   CalcCrc32(in[i], crc32);
   
           return ~crc32; 
   }
   
   static void file_crc32_file_action(
                                   struct stat& finfo, 
                                   int f, 
                                   const String&, const char* /*fname*/, bool, 
                                   void *context) {
           unsigned long& crc32=*static_cast<unsigned long *>(context);
           if(finfo.st_size) {
                   InitCrc32Table();
                   int nCount=0;
                   do {
                           unsigned char buffer[FILE_BUFFER_SIZE];
                           nCount = file_block_read(f, buffer, sizeof(buffer));
                           for(int i = 0; i < nCount; i++) CalcCrc32(buffer[i], crc32);
                   } while(nCount > 0);
           }
   }
   
   const unsigned long pa_crc32(const String& file_spec){
           unsigned long crc32=0xFFFFFFFF;
           file_read_action_under_lock(file_spec, "crc32", file_crc32_file_action, &crc32);
           return ~crc32; 
   }
   
   // content-type: xxx; charset=WE-NEED-THIS
   // content-type: xxx; charset="WE-NEED-THIS"
   // content-type: xxx; charset="WE-NEED-THIS";
   Charset* detect_charset(const char* content_type){
           if(content_type){
                   char* CONTENT_TYPE=pa_strdup(content_type);
   
                   for(char *p=CONTENT_TYPE; *p; p++)
                           *p=(char)toupper((unsigned char)*p);
   
                   if(const char* begin=strstr(CONTENT_TYPE, "CHARSET=")){
                           begin+=8; // skip "CHARSET="
                           char* end=0;
                           if(*begin && (*begin=='"' || *begin =='\'')){
                                   char quote=*begin;
                                   begin++;
                                   end=(char*)strchr(begin, quote);
                           }
                           if(!end)
                                   end=(char*)strchr(begin, ';');
   
                           if(end)
                                   *end=0; // terminator
   
                           return *begin?&charsets.get(begin):0;
                   }
           }
           return 0;
   }
   
   
   static bool isLeap(int year) {
           return !(
                                   (year % 4) || ((year % 400) && !(year % 100))
                           ); 
   }
   
   int getMonthDays(int year, int month) {
           static int monthDays[]={
                   31, 
                   28, 
                   31, 
                   30, 
                   31, 
                   30, 
                   31, 
                   31, 
                   30, 
                   31, 
                   30, 
                   31
           }; 
           return (month == 1 /* january -- 0 */ && isLeap(year)) ? 29 : monthDays[month]; 
   }
   
   String::C date_gmt_string(tm* tms) {
           /// http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3
           static const char month_names[12][4]={
                   "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
           static const char days[7][4]={
                   "Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
   
           char *buf=new(PointerFreeGC) char[MAX_STRING];
           return String::C(buf, 
                   snprintf(buf, MAX_STRING, "%s, %.2d %s %.4d %.2d:%.2d:%.2d GMT", 
                   days[tms->tm_wday],
                   tms->tm_mday,month_names[tms->tm_mon],tms->tm_year+1900,
                   tms->tm_hour,tms->tm_min,tms->tm_sec));
   }
Removed from v.1.164  
changed lines
  Added in v.1.281

E-mail: