[BACK]Return to parser3.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / targets / cgi

Diff for /parser3/src/targets/cgi/parser3.C between versions 1.203 and 1.219

version 1.203, 2002/11/20 14:14:17 version 1.219, 2003/11/03 11:24:53
Line 1 Line 1
 /** @file  /** @file
         Parser: scripting and CGI main.          Parser: scripting and CGI main.
   
         Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */  */
   
Line 10  static const char* IDENT_PARSER3_C="$Dat Line 10  static const char* IDENT_PARSER3_C="$Dat
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
 #if _MSC_VER  #if _MSC_VER
 #       include <new.h>  
 #       include <crtdbg.h>  #       include <crtdbg.h>
 #endif  #endif
   
Line 20  static const char* IDENT_PARSER3_C="$Dat Line 19  static const char* IDENT_PARSER3_C="$Dat
 #include "pa_request.h"  #include "pa_request.h"
 #include "pa_socks.h"  #include "pa_socks.h"
 #include "pa_version.h"  #include "pa_version.h"
 #include "pool_storage.h"  
   
   
 #ifdef WIN32  #ifdef WIN32
 #       include <windows.h>  #       include <windows.h>
Line 29  static const char* IDENT_PARSER3_C="$Dat Line 29  static const char* IDENT_PARSER3_C="$Dat
 #       include <getopt.h>  #       include <getopt.h>
 #endif  #endif
   
 //#define DEBUG_POOL_MALLOC  
 //#define DEBUG_STRING_APPENDS_VS_EXPANDS  
 //#define DEBUG_MAILRECEIVE "mailreceive.eml"  //#define DEBUG_MAILRECEIVE "mailreceive.eml"
   
 #ifdef DEBUG_STRING_APPENDS_VS_EXPANDS  
 extern ulong   
         string_piece_appends,   
         wcontext_result_size,  
         total_alloc_size,  
         string_string_shortcut_economy;  
 #endif  
   
 // consts  // consts
   
 #define REDIRECT_PREFIX "REDIRECT_"  #define REDIRECT_PREFIX "REDIRECT_"
Line 49  extern ulong Line 39  extern ulong
 /// IIS refuses to read bigger chunks  /// IIS refuses to read bigger chunks
 const size_t READ_POST_CHUNK_SIZE=0x400*0x400; // 1M   const size_t READ_POST_CHUNK_SIZE=0x400*0x400; // 1M 
   
 static const char *argv0;  static const char* argv0;
 static const char *config_filespec_cstr=0;  static const char* config_filespec_cstr=0;
 static bool fail_on_config_read_problem=true;  static bool fail_on_config_read_problem=true;
   
 static Pool_storage global_pool_storage; ///< global pool storage  
 static Pool global_pool(&global_pool_storage); ///< global pool  
 static bool cgi; ///< we were started as CGI?  static bool cgi; ///< we were started as CGI?
 static bool mail_received=false; ///< we were started with -m option? [asked to parse incoming message to $mail:received]  static bool mail_received=false; ///< we were started with -m option? [asked to parse incoming message to $mail:received]
   
 // for signal handlers  // for signal handlers
 Request *request=0;  Request *request=0;
   Request_info *request_info=0;
   bool execution_canceled=false;
   
 // SAPI  // SAPI
   
 static void log(const char *fmt, va_list args) {  class SAPI_Info{} SAPI_info;
   
   static void log(const char* fmt, va_list args) {
         bool opened=false;          bool opened=false;
         FILE *f=0;          FILE *f=0;
   
Line 87  static void log(const char *fmt, va_list Line 79  static void log(const char *fmt, va_list
         if(!opened)          if(!opened)
                 f=stderr;                  f=stderr;
   
           // use no memory [so that we could log out-of-memory error]
           setbuf(f, 0); // stderr stream is unbuffered by default, but still...
   
         // prefix          // prefix
         time_t t=time(0);          time_t t=time(0);
         if(const char *stamp=ctime(&t)) { // never saw that          if(const char* stamp=ctime(&t)) { // never saw that
                 if(size_t len=strlen(stamp)) // saw once stamp being =""                  if(size_t len=strlen(stamp)) // saw once stamp being =""
                         fprintf(f, "[%.*s] ", len-1, stamp);                          fprintf(f, "[%.*s] ", len-1, stamp);
         }          }
Line 110  static void log(const char *fmt, va_list Line 105  static void log(const char *fmt, va_list
 }  }
   
 // appends to parser3.log located beside my binary if openable, to stderr otherwize  // appends to parser3.log located beside my binary if openable, to stderr otherwize
 void SAPI::log(Pool& , const char *fmt, ...) {  void SAPI::log(SAPI_Info&, const char* fmt, ...) {
     va_list args;      va_list args;
         va_start(args,fmt);          va_start(args,fmt);
         ::log(fmt, args);          ::log(fmt, args);
         va_end(args);          va_end(args);
 }  }
   
 void SAPI::die(const char *fmt, ...) {  static void die_or_abort(const char* fmt, va_list args, bool write_core) {
 #ifdef DEBUG_POOL_MALLOC  
         extern void log_pool_stats(Pool& pool);  
         log_pool_stats(global_pool);  
 #endif  
   
     va_list args;  
         va_start(args,fmt);  
         // log          // log
   
         // logging is more important than user           // logging is more important than user 
         // she can cancel download, we'd get SIG_PIPE,           // she can cancel download, we'd get SIGPIPE, 
         // nothing would be logged then          // nothing would be logged then
         ::log(fmt, args);          ::log(fmt, args);
   
Line 137  void SAPI::die(const char *fmt, ...) { Line 125  void SAPI::die(const char *fmt, ...) {
         char body[MAX_STRING];          char body[MAX_STRING];
         int content_length=vsnprintf(body, MAX_STRING, fmt, args);          int content_length=vsnprintf(body, MAX_STRING, fmt, args);
   
         va_end(args);  
   
         // prepare header          // prepare header
         // let's be honest, that's bad we couldn't produce valid output          // let's be honest, that's bad we couldn't produce valid output
         SAPI::add_header_attribute(global_pool, "status", "500");          SAPI::add_header_attribute(SAPI_info, "status", "500");
         SAPI::add_header_attribute(global_pool, "content-type", "text/plain");          SAPI::add_header_attribute(SAPI_info, "content-type", "text/plain");
         char content_length_cstr[MAX_NUMBER];          char content_length_cstr[MAX_NUMBER];
         snprintf(content_length_cstr, sizeof(content_length_cstr), "%u", content_length);          snprintf(content_length_cstr, sizeof(content_length_cstr), "%u", content_length);
         SAPI::add_header_attribute(global_pool, "content-length", content_length_cstr);          SAPI::add_header_attribute(SAPI_info, "content-length", content_length_cstr);
   
         // send header          // send header
         SAPI::send_header(global_pool);          SAPI::send_header(SAPI_info);
   
         // body          // body
         SAPI::send_body(global_pool, body, content_length);          SAPI::send_body(SAPI_info, body, content_length);
   
         exit(1);          // exit & try to produce core dump[unix] or invoke debugger[Win32 Debug version]
           if(write_core) {
   #if defined(WIN32) && !defined(_DEBUG)
                   // IIS with abort failes to show STDOUT, it just barks "abnormal program termination"
                   exit(1);
   #else
   #if _MSC_VER
                   _asm int 3;
   #endif
                   abort();
   #endif
           } 
           else
                   exit(1);
 }  }
   
 const char *SAPI::get_env(Pool& , const char *name) {  void SAPI::die(const char* fmt, ...) {
         return getenv(name);      va_list args;
           va_start(args, fmt);
           die_or_abort(fmt, args, false/*write core?*/);
           va_end(args);
 }  }
   
 const char *const *SAPI::environment(Pool&) {  void SAPI::abort(const char* fmt, ...) {
       va_list args;
           va_start(args, fmt);
           die_or_abort(fmt, args, true/*write core?*/);
           va_end(args);
   }
   
   char* SAPI::get_env(SAPI_Info& , const char* name) {
           if(char *local=getenv(name))
                   return pa_strdup(local);
           else
                   return 0;
   }
   
   const char* const *SAPI::environment(SAPI_Info&) {
 #ifdef _MSC_VER  #ifdef _MSC_VER
         extern char **_environ;          extern char **_environ;
         return _environ;          return _environ;
Line 170  const char *const *SAPI::environment(Poo Line 186  const char *const *SAPI::environment(Poo
 #endif  #endif
 }  }
   
 size_t SAPI::read_post(Pool& , char *buf, size_t max_bytes) {  size_t SAPI::read_post(SAPI_Info& , char *buf, size_t max_bytes) {
         size_t read_size=0;          size_t read_size=0;
         do {          do {
                 ssize_t chunk_size=read(fileno(stdin),                   ssize_t chunk_size=read(fileno(stdin), 
Line 183  size_t SAPI::read_post(Pool& , char *buf Line 199  size_t SAPI::read_post(Pool& , char *buf
         return read_size;          return read_size;
 }  }
   
 void SAPI::add_header_attribute(Pool& , const char *key, const char *value) {  void SAPI::add_header_attribute(SAPI_Info& , const char* dont_store_key, const char* dont_store_value) {
         if(cgi)          if(cgi)
                 printf("%s: %s\n", key, value);                  printf("%s: %s\n", dont_store_key, dont_store_value);
 }  }
   
 /// @todo intelligent cache-control  /// @todo intelligent cache-control
 void SAPI::send_header(Pool& ) {  void SAPI::send_header(SAPI_Info& ) {
         if(cgi) {          if(cgi) {
 //              puts("expires: Fri, 23 Mar 2001 09:32:23 GMT");  //              puts("expires: Fri, 23 Mar 2001 09:32:23 GMT");
   
Line 198  void SAPI::send_header(Pool& ) { Line 214  void SAPI::send_header(Pool& ) {
         }          }
 }  }
   
 void SAPI::send_body(Pool& , const void *buf, size_t size) {  void SAPI::send_body(SAPI_Info& , const void *buf, size_t size) {
         stdout_write(buf, size);          stdout_write(buf, size);
 }  }
   
 //  //
   
 static void full_file_spec(const char *file_name, char *buf, size_t buf_size) {  static void full_file_spec(const char* file_name, char *buf, size_t buf_size) {
         if(file_name)          if(file_name)
                 if(file_name[0]=='/'                   if(file_name[0]=='/' 
 #ifdef WIN32  #ifdef WIN32
                         || (file_name[0] && file_name[1]==':')                          || file_name[0] && file_name[1]==':'
 #endif  #endif
                         )                           )
                         strncpy(buf, file_name, buf_size);                                  strncpy(buf, file_name, buf_size);
                 else {                  else {
                         char cwd[MAX_STRING];  getcwd(cwd, MAX_STRING);                          char cwd[MAX_STRING];  getcwd(cwd, MAX_STRING);
                         snprintf(buf, buf_size, "%s/%s", cwd, file_name);                          snprintf(buf, buf_size, "%s/%s", cwd, file_name);
Line 223  static void full_file_spec(const char *f Line 239  static void full_file_spec(const char *f
 #endif  #endif
 }  }
   
   static void log_signal(const char* signal_name) {
           if(request_info)
                   SAPI::log(SAPI_info, "%s received while %s. uri=%s, method=%s, cl=%u",
                           signal_name,
                           request?"executing code":"reading data",
                           request_info->uri,
                           request_info->method,
                           request_info->content_length);
           else
                   SAPI::log(SAPI_info, "%s received before or after processing request",
                           signal_name);
   }
   
 #ifdef SIGUSR1  #ifdef SIGUSR1
 void SIGUSR1_Handler(int /*sig*/){  static void SIGUSR1_handler(int /*sig*/){
         SAPI::log(global_pool, "SIGUSR1 received. url=%s", request?request->info.uri:"<no request>");          log_signal("SIGUSR1");
 }  }
 #endif  #endif
   
 #ifdef SIGPIPE  #ifdef SIGPIPE
 void SIGPIPE_Handler(int /*sig*/){  static void SIGPIPE_handler(int /*sig*/){
         SAPI::log(global_pool, "SIGPIPE received. url=%s", request?request->info.uri:"<no request>");          log_signal("SIGPIPE");
           execution_canceled=true;
         if(request)          if(request)
                 request->interrupt();                  request->set_interrupted(true);
 }  }
 #endif  #endif
   
Line 244  main workhorse Line 274  main workhorse
                 IIS: remove trailing default-document[index.html] from $request.uri.                  IIS: remove trailing default-document[index.html] from $request.uri.
                 to do that we need to consult metabase,                  to do that we need to consult metabase,
                 wich is tested but seems slow.                  wich is tested but seems slow.
                 IIS5 todo find out proper 'illegal call' check   
 */  */
 static void real_parser_handler(  static void real_parser_handler(const char* filespec_to_process,
                                         const char *filespec_to_process,                                  const char* request_method, bool header_only) {
                                         const char *request_method, bool header_only) {  
         // init socks          // init socks
         init_socks(global_pool);          pa_init_socks();
                   
         // init global classes  
         init_methoded_array(global_pool);  
         // init global variables          // init global variables
         pa_globals_init(global_pool);          pa_globals_init();
                   
         // request pool, must be different ptr from global [used in VStateless_class.add_method]  
         Pool request_pool(&global_pool_storage);  
   
         if(!filespec_to_process || !*filespec_to_process)          if(!filespec_to_process || !*filespec_to_process)
                 SAPI::die("Parser/%s", PARSER_VERSION);                  SAPI::die("Parser/%s", PARSER_VERSION);
                   
         // Request info          // Request info
         Request::Info request_info;          Request_info request_info;  memset(&request_info, 0, sizeof(request_info));
         char document_root_buf[MAX_STRING];          char document_root_buf[MAX_STRING];
         if(cgi) {          if(cgi) {
                 if(const char *env_document_root=SAPI::get_env(request_pool, "DOCUMENT_ROOT"))                  if(const char* env_document_root=getenv("DOCUMENT_ROOT"))
                         request_info.document_root=env_document_root;                          request_info.document_root=env_document_root;
                 else if(const char *path_info=SAPI::get_env(request_pool, "PATH_INFO")) {                  else if(const char* path_info=getenv("PATH_INFO")) {
                         // IIS                          // IIS
                         size_t len=min(sizeof(document_root_buf)-1, strlen(filespec_to_process)-strlen(path_info));                          size_t len=min(sizeof(document_root_buf)-1, strlen(filespec_to_process)-strlen(path_info));
                         memcpy(document_root_buf, filespec_to_process, len); document_root_buf[len]=0;                          memcpy(document_root_buf, filespec_to_process, len); document_root_buf[len]=0;
Line 284  static void real_parser_handler( Line 307  static void real_parser_handler(
         }          }
         request_info.path_translated=filespec_to_process;          request_info.path_translated=filespec_to_process;
         request_info.method=request_method ? request_method : "GET";          request_info.method=request_method ? request_method : "GET";
         const char *query_string=SAPI::get_env(request_pool, "QUERY_STRING");          const char* query_string=getenv("QUERY_STRING");
         request_info.query_string=query_string;          request_info.query_string=query_string;
         if(cgi) {          if(cgi) {
                 if(const char *env_request_uri=SAPI::get_env(request_pool, "REQUEST_URI"))                  // few absolute obligatory
                   const char* path_info=getenv("PATH_INFO");
                   if(!path_info)
                           SAPI::die("CGI: illegal call (missing PATH_INFO)");
                   const char* script_name=getenv("SCRIPT_NAME");
                   if(!script_name)
                                   SAPI::die("CGI: illegal call (missing SCRIPT_NAME)");
   
                   const char* env_request_uri=getenv("REQUEST_URI");
                   if(env_request_uri)
                         request_info.uri=env_request_uri;                          request_info.uri=env_request_uri;
                 else if(const char *path_info=SAPI::get_env(request_pool, "PATH_INFO"))                  else 
                         if(query_string) {                          if(query_string) {
                                 char *reconstructed_uri=(char *)request_pool.malloc(                                  char* reconstructed_uri=new(PointerFreeGC) char[
                                         strlen(path_info)+1/*'?'*/+                                          strlen(path_info)+1/*'?'*/+
                                         strlen(query_string)+1/*0*/);                                          strlen(query_string)+1/*0*/];
                                 strcpy(reconstructed_uri, path_info);                                  strcpy(reconstructed_uri, path_info);
                                 strcat(reconstructed_uri, "?");                                  strcat(reconstructed_uri, "?");
                                 strcat(reconstructed_uri, query_string);                                  strcat(reconstructed_uri, query_string);
                                 request_info.uri=reconstructed_uri;                                  request_info.uri=reconstructed_uri;
                         } else                          } else
                                 request_info.uri=path_info;                                  request_info.uri=path_info;
                 else  
                         throw Exception("parser.runtime",                  if(env_request_uri) { // apache & others stuck to standards
                                 0,                          /*
                                 "CGI: no PATH_INFO defined(in reinventing REQUEST_URI)");                                  http://parser3/env.html?123  =OK
                                                           $request:uri=/env.html?123
                         // they've changed this under IIS5.                                  REQUEST_URI='/env.html?123'
                         if(const char *script_name=SAPI::get_env(request_pool, "SCRIPT_NAME")) {                                  SCRIPT_NAME='/cgi-bin/parser3'
                                 size_t script_name_len=strlen(script_name);                                  PATH_INFO='/env.html'
                                 size_t uri_len=strlen(request_info.uri);  
                                 if(strncmp(request_info.uri,script_name, script_name_len)==0 &&                                  http://parser3/cgi-bin/parser3/env.html?123 =ERROR
                                         script_name_len != uri_len) // under IIS they are the same                                  $request:uri=/cgi-bin/parser3/env.html?123
                                         SAPI::die("CGI: illegal call");                                  REQUEST_URI='/cgi-bin/parser3/env.html?123'
                         }                                  SCRIPT_NAME='/cgi-bin/parser3'
                                   PATH_INFO='/env.html'
                           */
                           size_t script_name_len=strlen(script_name);
                           size_t uri_len=strlen(env_request_uri);
                           if(strncmp(env_request_uri, script_name, script_name_len)==0 &&
                                   script_name_len != uri_len) // under IIS they are the same
                                   SAPI::die("CGI: illegal call (1)");
                   } else { // seen on IIS5
                           /*
                                   http://nestle/env.html?123 =OK
                                   $request:uri=/env.html?123
                                   REQUEST_URI=''
                                   SCRIPT_NAME='/env.html'
                                   PATH_INFO='/env.html'
   
                                   http://nestle/cgi-bin/parser3.exe/env.html =ERROR
                                   $request:uri=/env.html
                                   REQUEST_URI=''
                                   SCRIPT_NAME='/cgi-bin/parser3.exe'
                                   PATH_INFO='/env.html'
                           */
                           if(strcmp(script_name, path_info)!=0)
                                   SAPI::die("CGI: illegal call (2)");
                   }
         } else          } else
                 request_info.uri="";                  request_info.uri="";
                   
         request_info.content_type=SAPI::get_env(request_pool, "CONTENT_TYPE");          request_info.content_type=getenv("CONTENT_TYPE");
         const char *content_length=SAPI::get_env(request_pool, "CONTENT_LENGTH");          const char* content_length=getenv("CONTENT_LENGTH");
         request_info.content_length=(content_length?atoi(content_length):0);          request_info.content_length=(content_length?atoi(content_length):0);
         request_info.cookie=SAPI::get_env(request_pool, "HTTP_COOKIE");          request_info.cookie=getenv("HTTP_COOKIE");
         request_info.mail_received=mail_received;          request_info.mail_received=mail_received;
   
           // get request_info ptr for signal handlers
           ::request_info=&request_info;
           if(execution_canceled)
                   SAPI::die("Execution canceled");
   
         // prepare to process request          // prepare to process request
         Request request(request_pool,          Request request(SAPI_info, 
                 request_info,                  request_info,
 /*#ifdef _DEBUG                  cgi ? String::Language(String::L_HTML|String::L_OPTIMIZE_BIT) : String::L_AS_IS,
                 String::UL_HTML|String::UL_OPTIMIZE_BIT  
 #else*/  
                 cgi ? String::UL_HTML|String::UL_OPTIMIZE_BIT : String::UL_AS_IS  
 /*#endif*/  
                 ,  
                 true /* status_allowed */);                  true /* status_allowed */);
   
         // get request ptr for signal handlers          // get request ptr for signal handlers
Line 339  static void real_parser_handler( Line 394  static void real_parser_handler(
   
         char config_filespec_buf[MAX_STRING];          char config_filespec_buf[MAX_STRING];
         if(!config_filespec_cstr) {          if(!config_filespec_cstr) {
                 const char *config_by_env=getenv(PARSER_CONFIG_ENV_NAME);                  const char* config_by_env=getenv(PARSER_CONFIG_ENV_NAME);
                 if(!config_by_env)                  if(!config_by_env)
                         config_by_env=getenv(REDIRECT_PREFIX PARSER_CONFIG_ENV_NAME);                          config_by_env=getenv(REDIRECT_PREFIX PARSER_CONFIG_ENV_NAME);
                 if(config_by_env)                  if(config_by_env)
Line 372  static void real_parser_handler( Line 427  static void real_parser_handler(
         ::request=0;          ::request=0;
                   
         //          //
         done_socks();          pa_done_socks();
           
 #ifdef DEBUG_POOL_MALLOC  
         extern void log_pool_stats(Pool& pool);  
         log_pool_stats(request_pool);  
 #endif  
   
 #ifdef DEBUG_STRING_APPENDS_VS_EXPANDS  
         SAPI::log(global_pool,   
                 "string piece appends=%lu, wcontext_result_size=%lu, string_string_shortcut_economy_closer=%lu, total_alloc_size=%lu",   
                 string_piece_appends,  
                 wcontext_result_size,  
                 string_string_shortcut_economy,  
                 total_alloc_size);  
 #endif  
   
 }  }
   
 static void call_real_parser_handler__do_SEH(  
                                                                  const char *filespec_to_process,  
                                                                  const char *request_method, bool header_only) {  
 #if _MSC_VER && !defined(_DEBUG)  #if _MSC_VER && !defined(_DEBUG)
         LPEXCEPTION_POINTERS system_exception=0;  #       define PA_USE___TRY
   struct Parser_executed {
           bool with_system_exception;
           LPEXCEPTION_POINTERS system_exception;
   };
   #endif
   
   static 
   #ifdef PA_USE___TRY
   Parser_executed 
   #else
   void
   #endif
   call_real_parser_handler__do_SEH_return_it(
                                              const char* filespec_to_process,
                                              const char* request_method, bool header_only) {
   #ifdef PA_USE___TRY
           Parser_executed result={false};
         __try {          __try {
 #endif  #endif
                 real_parser_handler(                  real_parser_handler(
                         filespec_to_process,                          filespec_to_process,
                         request_method, header_only);                          request_method, header_only);
                                   
 #if _MSC_VER && !defined(_DEBUG)  #ifdef PA_USE___TRY
         } __except (          } __except (
                 (system_exception=GetExceptionInformation()),                   (result.system_exception=GetExceptionInformation()), 
                 EXCEPTION_EXECUTE_HANDLER) {                  EXCEPTION_EXECUTE_HANDLER) {
                                   result.with_system_exception=true;
                 if(system_exception)  
                         if(_EXCEPTION_RECORD *er=system_exception->ExceptionRecord)  
                                 throw Exception(0,  
                                         0,  
                                         "Exception 0x%08X at 0x%08X", er->ExceptionCode,  er->ExceptionAddress);  
                         else  
                                 throw Exception(0, 0, "Exception <no exception record>");  
                         else  
                                 throw Exception(0, 0, "Exception <no exception information>");  
         }          }
           return result;
 #endif  #endif
 }  }
   
 #if _MSC_VER  static void call_real_parser_handler__do_SEH(
 int failed_new(size_t size) {                                               const char* filespec_to_process,
         SAPI::die("out of memory in 'new', failed to allocated %u bytes", size);                                               const char* request_method, bool header_only) {
         return 0; // not reached  #ifdef PA_USE___TRY
 }          Parser_executed executed=
 #endif  #endif
                   call_real_parser_handler__do_SEH_return_it(filespec_to_process, 
                           request_method, header_only);
   
 #ifdef HAVE_SET_NEW_HANDLER  #ifdef PA_USE___TRY
 static void failed_new() {          if(executed.with_system_exception)
     SAPI::die("out of memory in 'new'");                  if(executed.system_exception)
 }                          if(_EXCEPTION_RECORD *er=executed.system_exception->ExceptionRecord)
                                   throw Exception(0,
                                           0,
                                           "Exception 0x%08X at 0x%08X", er->ExceptionCode,  er->ExceptionAddress);
                           else
                                   throw Exception(0, 
                                           0, 
                                           "Exception <no exception record>");
                   else
                           throw Exception(0, 
                                   0, 
                                   "Exception <no exception information>");
 #endif  #endif
   }
   
 static void usage(const char *program) {  static void usage(const char* program) {
         printf(          printf(
                 "Parser/%s Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)\n"                  "Parser/%s Copyright(c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)\n"
                 "Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)\n"                  "Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)\n"
                 "\n"                  "\n"
                 "Usage: %s [options] file\n"                  "Usage: %s [options] file\n"
Line 450  static void usage(const char *program) { Line 510  static void usage(const char *program) {
 }  }
   
 int main(int argc, char *argv[]) {  int main(int argc, char *argv[]) {
           GC_java_finalization=0;
   
   #ifndef PA_DEBUG_DISABLE_GC
           // Dont collect unless explicitly requested 
           // this is quicker (~30% ), but less memory-efficient(~8%)
           // so deciding for speed
           GC_dont_gc=1; 
   #endif
   /*
           
           Array<int> test;
           test+=3;
           test+=4;
   //      int a=test.count();
           int i=0;
           scanf("%d", &i);
           int b=test.get(i);
   //      int b=test.get(10);
           printf("%d", b);//test.count());*/
   
 #ifdef SIGUSR1  #ifdef SIGUSR1
     if(signal(SIGUSR1, SIGUSR1_Handler)==SIG_ERR)      if(signal(SIGUSR1, SIGUSR1_handler)==SIG_ERR)
                 SAPI::die("Can not set handler for SIGUSR1");                  SAPI::die("Can not set handler for SIGUSR1");
 #endif  #endif
 #ifdef SIGPIPE  #ifdef SIGPIPE
     if(signal(SIGPIPE, SIGPIPE_Handler)==SIG_ERR)      if(signal(SIGPIPE, SIGPIPE_handler)==SIG_ERR)
                 SAPI::die("Can not set handler for SIGPIPE");                  SAPI::die("Can not set handler for SIGPIPE");
 #endif  #endif
   
Line 467  int main(int argc, char *argv[]) { Line 547  int main(int argc, char *argv[]) {
 #endif  #endif
   
 #ifdef _DEBUG  #ifdef _DEBUG
 //      _crtBreakAlloc=33112;          //_crtBreakAlloc=4042;
 #endif  #endif
 //      _asm int 3;  
         argv0=argv[0];          argv0=argv[0];
   
         umask(2);          umask(2);
Line 482  int main(int argc, char *argv[]) { Line 561  int main(int argc, char *argv[]) {
                 getenv("REQUEST_METHOD");                  getenv("REQUEST_METHOD");
                   
         char *raw_filespec_to_process;          char *raw_filespec_to_process;
         if(cgi)           if(cgi) {
                 raw_filespec_to_process=getenv("PATH_TRANSLATED");                  raw_filespec_to_process=getenv("PATH_TRANSLATED");
         else {                  if(raw_filespec_to_process && !*raw_filespec_to_process)
                           raw_filespec_to_process=0;
           } else {
                 optind = 1;                  optind = 1;
                 opterr = 0;                  opterr = 0;
                 int c;                  int c;
Line 525  int main(int argc, char *argv[]) { Line 606  int main(int argc, char *argv[]) {
         setmode(fileno(stderr), _O_BINARY);          setmode(fileno(stderr), _O_BINARY);
 #endif  #endif
   
 #if _MSC_VER  #if defined(_MSC_VER) && defined(_DEBUG)
         _set_new_handler(failed_new);  
   
 #ifdef _DEBUG  
         // Get current flag          // Get current flag
         int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );          int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
   
Line 537  int main(int argc, char *argv[]) { Line 615  int main(int argc, char *argv[]) {
   
         // Set flag to the new value          // Set flag to the new value
         _CrtSetDbgFlag( tmpFlag );          _CrtSetDbgFlag( tmpFlag );
 //      _CrtSetBreakAlloc(471);  //      _CrtSetBreakAlloc(61);
   
 #endif  
   
 #endif  
   
 #ifdef HAVE_SET_NEW_HANDLER          _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
         std::set_new_handler(failed_new);          _CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR );
 #endif  #endif
   
         char filespec_to_process[MAX_STRING];          char filespec_to_process[MAX_STRING];
         full_file_spec(raw_filespec_to_process, filespec_to_process, sizeof(filespec_to_process));          full_file_spec(raw_filespec_to_process, filespec_to_process, sizeof(filespec_to_process));
   
         const char *request_method=getenv("REQUEST_METHOD");          const char* request_method=getenv("REQUEST_METHOD");
         bool header_only=request_method && strcasecmp(request_method, "HEAD")==0;          bool header_only=request_method && strcasecmp(request_method, "HEAD")==0;
   
         try { // global try          try { // global try
Line 561  int main(int argc, char *argv[]) { Line 635  int main(int argc, char *argv[]) {
                 // don't allocate anything on pool here:                  // don't allocate anything on pool here:
                 //   possible pool' exception not catch-ed now                  //   possible pool' exception not catch-ed now
                 //   and there could be out-of-memory exception                  //   and there could be out-of-memory exception
                   const char* body=e.comment();
                   char buf[MAX_STRING];
                   snprintf(buf, MAX_STRING, "exception in request exception handler: %s",
                           body);
                   // log it
                   SAPI::log(SAPI_info, "%s", buf);
   
                   //
                   int content_length=strlen(buf);
   
                   // prepare header
                   SAPI::add_header_attribute(SAPI_info, "content-type", "text/plain");
                   char content_length_cstr[MAX_NUMBER];
                   snprintf(content_length_cstr, MAX_NUMBER, "%u", content_length);
                   SAPI::add_header_attribute(SAPI_info, "content-length", content_length_cstr);
   
                   // send header
                   SAPI::send_header(SAPI_info);
   
                   // send body
                   if(!header_only)
                           SAPI::send_body(SAPI_info, buf, content_length);
   
                 SAPI::die("exception in request exception handler: %s", e.comment());                  // unsuccessful finish
 #ifndef _DEBUG  
         } catch(...) {   
                 SAPI::die("<unknown exception>");  
 #endif  
         }          }
           
   
 #ifndef WIN32  
         //   
         if(!cgi)  
                 SAPI::send_body(global_pool, "\n", 1);  
 #endif  
   
         //_asm int 3;  
         return 0;          return 0;
 }  }
Removed from v.1.203  
changed lines
  Added in v.1.219

E-mail: