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

Diff for /parser3/src/targets/isapi/parser3isapi.C between versions 1.1 and 1.16

version 1.1, 2001/03/22 15:30:49 version 1.16, 2001/03/24 14:31:02
Line 1 Line 1
 #ifndef _MSC_VER  #ifndef _MSC_VER
 #       error compile ISAPI module with MSVC  #       error compile ISAPI module with MSVC [no urge for now to make it autoconf-ed (PAF)]
 #endif  #endif
   
 #include <windows.h>  #include <windows.h>
 #include <process.h>  #include <process.h>
   
 #include <httpext.h>  #include <httpext.h>
 #include <httpfilt.h>  
 #include <httpext.h>  
   
   #include "pa_sapi.h"
 #include "pa_globals.h"  #include "pa_globals.h"
 #include "pa_request.h"  #include "pa_request.h"
 #include "pa_version.h"  #include "pa_version.h"
   #include "pool_storage.h"
   
   #include "nt_log_events.h"
   
 #define MAX_STATUS_LENGTH sizeof("xxxx LONGEST STATUS DESCRIPTION")  #define MAX_STATUS_LENGTH sizeof("xxxx LONGEST STATUS DESCRIPTION")
 #define ISAPI_SERVER_VAR_BUF_SIZE 0x400  
   
 //@{  //@{
 /// service func decl  /// SAPI funcs decl
 static const char *get_env(Pool& pool, const char *name) {  struct SAPI_func_context {
         LPEXTENSION_CONTROL_BLOCK lpECB=static_cast<LPEXTENSION_CONTROL_BLOCK>(pool.context());          LPEXTENSION_CONTROL_BLOCK lpECB;
           String *header;
           DWORD http_response_code;
   };
   
   const char *SAPI::get_env(Pool& pool, const char *name) {
           SAPI_func_context& ctx=*static_cast<SAPI_func_context *>(pool.context());
   
         char *variable_buf=(char *)pool.malloc(MAX_STRING);          char *variable_buf=(char *)pool.malloc(MAX_STRING);
         DWORD variable_len = MAX_STRING-1;          DWORD variable_len = MAX_STRING-1;
   
         if(lpECB->GetServerVariable(lpECB->ConnID, const_cast<char *>(name),           if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name), 
                 variable_buf, &variable_len)) {  
                 variable_buf[variable_len]=0;  
                 return variable_buf;  
         }  
   
         variable_buf=(char *)pool.malloc(variable_len+1);  
           
         if(lpECB->GetServerVariable(lpECB->ConnID, const_cast<char *>(name),   
                 variable_buf, &variable_len)) {                  variable_buf, &variable_len)) {
                 variable_buf[variable_len]=0;                  variable_buf[variable_len]=0;
                 return variable_buf;                  return variable_buf;
           } else if (GetLastError()==ERROR_INSUFFICIENT_BUFFER) {
                   variable_buf=(char *)pool.malloc(variable_len+1);
                   
                   if(ctx.lpECB->GetServerVariable(ctx.lpECB->ConnID, const_cast<char *>(name), 
                           variable_buf, &variable_len)) {
                           variable_buf[variable_len]=0;
                           return variable_buf;
                   }
         }          }
                   
         return 0;          return 0;
 }  }
   
 static uint read_post(Pool& pool, char *buf, uint max_bytes) {  uint SAPI::read_post(Pool& pool, char *buf, uint max_bytes) {
         LPEXTENSION_CONTROL_BLOCK lpECB=static_cast<LPEXTENSION_CONTROL_BLOCK>(pool.context());          SAPI_func_context& ctx=*static_cast<SAPI_func_context *>(pool.context());
   
         // todo: timeout  
         DWORD read_from_buf=0;          DWORD read_from_buf=0;
         DWORD read_from_input=0;          DWORD read_from_input=0;
         DWORD total_read=0;          DWORD total_read=0;
   
         read_from_buf=min(lpECB->cbAvailable, max_bytes);          read_from_buf=min(ctx.lpECB->cbAvailable, max_bytes);
         memcpy(buf, lpECB->lpbData, read_from_buf);          memcpy(buf, ctx.lpECB->lpbData, read_from_buf);
         total_read+=read_from_buf;          total_read+=read_from_buf;
   
         if(read_from_buf<max_bytes &&          if(read_from_buf<max_bytes &&
                 read_from_buf<lpECB->cbTotalBytes) {                  read_from_buf<ctx.lpECB->cbTotalBytes) {
                 DWORD cbRead=0, cbSize;                  DWORD cbRead=0, cbSize;
   
                 read_from_input=min(max_bytes-read_from_buf, lpECB->cbTotalBytes-read_from_buf);                  read_from_input=min(max_bytes-read_from_buf, 
                           ctx.lpECB->cbTotalBytes-read_from_buf);
                 while(cbRead < read_from_input) {                  while(cbRead < read_from_input) {
                         cbSize=read_from_input - cbRead;                          cbSize=read_from_input - cbRead;
                         if(!lpECB->ReadClient(lpECB->ConnID, buf+read_from_buf+cbRead, &cbSize) ||                           if(!ctx.lpECB->ReadClient(ctx.lpECB->ConnID, 
                                   buf+read_from_buf+cbRead, &cbSize) || 
                                 cbSize==0)                                   cbSize==0) 
                                 break;                                  break;
                         cbRead+=cbSize;                          cbRead+=cbSize;
Line 70  static uint read_post(Pool& pool, char * Line 78  static uint read_post(Pool& pool, char *
         return total_read;          return total_read;
 }  }
   
 static void add_header_attribute(Pool& pool, const char *key, const char *value) {  void SAPI::add_header_attribute(Pool& pool, const char *key, const char *value) {
         LPEXTENSION_CONTROL_BLOCK lpECB=static_cast<LPEXTENSION_CONTROL_BLOCK>(pool.context());          SAPI_func_context& ctx=*static_cast<SAPI_func_context *>(pool.context());
         String *header=static_cast<String *>(pool.tag());  
         if(!header)   
                 pool.set_tag(header=new(pool) String(pool));  
   
         header->APPEND_CONST(key);  
         header->APPEND_CONST(": ");  
         header->APPEND_CONST(value);  
         header->APPEND_CONST("\r\n");  
 }  
   
 static void send_header(Pool& pool) {          if(strcasecmp(key, "location")==0) 
         LPEXTENSION_CONTROL_BLOCK lpECB=static_cast<LPEXTENSION_CONTROL_BLOCK>(pool.context());                  ctx.http_response_code=302;
         String *header=static_cast<String *>(pool.tag());  
         if(!header) // never  
                 return;  
   
         header->APPEND_CONST("\r\n");          if(strcasecmp(key, "status")==0) 
         HSE_SEND_HEADER_EX_INFO header_info;                  ctx.http_response_code=atoi(value);
           else {
                   ctx.header->APPEND_CONST(key);
                   ctx.header->APPEND_CONST(": ");
                   ctx.header->APPEND_CONST(value);
                   ctx.header->APPEND_CONST("\n");
           }
   }
   
         int http_response_code=200; // todo: dig from headers  /// @todo intelligent cache-control
   void SAPI::send_header(Pool& pool) {
           SAPI_func_context& ctx=*static_cast<SAPI_func_context *>(pool.context());
   
           ctx.header->APPEND_CONST(
                   "expires: Fri, 23 Mar 2001 09:32:23 GMT\n"
                   "\n");
           HSE_SEND_HEADER_EX_INFO header_info;
   
         char status_buf[MAX_STATUS_LENGTH];          char status_buf[MAX_STATUS_LENGTH];
         switch(http_response_code) {          switch(ctx.http_response_code) {
                 case 200:                  case 200:
                         header_info.pszStatus="200 OK";                          header_info.pszStatus="200 OK";
                         break;                          break;
                 case 302:                  case 302:
                         header_info.pszStatus="302 Moved Temporarily";                          header_info.pszStatus="302 Moved Temporarily";
                         break;                          break;
                 case 401:                  case 401:// useless untill parser auth mech
                         header_info.pszStatus="401 Authorization Required";                          header_info.pszStatus="401 Authorization Required";
                         break;                          break;
                 default:                  default:
                         snprintf(status_buf, MAX_STATUS_LENGTH, "%d Undescribed", http_response_code);                          snprintf(status_buf, MAX_STATUS_LENGTH, 
                                   "%d Undescribed", ctx.http_response_code);
                         header_info.pszStatus=status_buf;                          header_info.pszStatus=status_buf;
                         break;                          break;
         }          }
         header_info.cchStatus=strlen(header_info.pszStatus);          header_info.cchStatus=strlen(header_info.pszStatus);
         header_info.pszHeader=header->cstr();          header_info.pszHeader=ctx.header->cstr();
         header_info.cchHeader=header->size();          header_info.cchHeader=ctx.header->size();
           header_info.fKeepConn=true;
   
         lpECB->dwHttpStatusCode=http_response_code;          ctx.lpECB->dwHttpStatusCode=ctx.http_response_code;
   
         lpECB->ServerSupportFunction(lpECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER_EX,           ctx.lpECB->ServerSupportFunction(ctx.lpECB->ConnID, 
                 &header_info, NULL, NULL);                  HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);
 }  }
   
 static void send_body(Pool& pool, const char *buf, size_t size) {  void SAPI::send_body(Pool& pool, const char *buf, size_t size) {
         LPEXTENSION_CONTROL_BLOCK lpECB=static_cast<LPEXTENSION_CONTROL_BLOCK>(pool.context());          SAPI_func_context& ctx=*static_cast<SAPI_func_context *>(pool.context());
   
         DWORD num_bytes=size;          DWORD num_bytes=size;
         lpECB->WriteClient(lpECB->ConnID, const_cast<char *>(buf), &num_bytes, HSE_IO_SYNC);          ctx.lpECB->WriteClient(ctx.lpECB->ConnID, 
                   const_cast<char *>(buf), &num_bytes, HSE_IO_SYNC);
 }  }
 //@}  
   
 /// Service funcs   /// goes to 'cs-uri-query' log file field. webmaster: switch it ON[default OFF].
 Service_funcs service_funcs={  void SAPI::log(Pool& pool, const char *fmt, ...) {
         get_env,          SAPI_func_context& ctx=*static_cast<SAPI_func_context *>(pool.context());
         read_post,          
         add_header_attribute,          va_list args;
         send_header,          va_start(args,fmt);
         send_body          char buf[MAX_STRING];
 };          const char *prefix="PARSER_ERROR:";
           strcpy(buf, prefix);
           DWORD size=vsnprintf(buf+strlen(prefix), MAX_STRING-strlen(prefix), fmt, args);
           
           ctx.lpECB->ServerSupportFunction(ctx.lpECB->ConnID, 
                   HSE_APPEND_LOG_PARAMETER, buf, &size, 0);
   }
   //@}
   
 //   // 
   
 static void parser_init() {  static bool parser_init() {
         static bool globals_inited=false;          static bool globals_inited=false;
         if(globals_inited)          if(globals_inited)
                 return;                  return true;
         globals_inited=true;          globals_inited=true;
   
         static Pool pool; // global pool          static Pool pool(0); // global pool
         PTRY {          PTRY {
                 // init global variables                  // init global variables
                 globals_init(pool);                  pa_globals_init(pool);
                                   
                 //...                  // successful finish
                   return true;
         } PCATCH(e) { // global problem           } PCATCH(e) { // global problem 
                 const char *body=e.comment();                  //const char *body=e.comment();
                 // TODO: somehow report that error                  
                   // unsuccessful finish
                   return false;
         }          }
         PEND_CATCH          PEND_CATCH
 }  }
Line 160  static void parser_init() { Line 182  static void parser_init() {
 /// ISAPI //  /// ISAPI //
 BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO *pVer) {  BOOL WINAPI GetExtensionVersion(HSE_VERSION_INFO *pVer) {
         pVer->dwExtensionVersion = HSE_VERSION;          pVer->dwExtensionVersion = HSE_VERSION;
         strncpy(pVer->lpszExtensionDesc, "Parser " PARSER_VERSION, HSE_MAX_EXT_DLL_NAME_LEN);          strncpy(pVer->lpszExtensionDesc, "Parser "PARSER_VERSION, HSE_MAX_EXT_DLL_NAME_LEN);
         return TRUE;          return parser_init();
 }  }
   
 static BOOL exception_handler(LPEXCEPTION_POINTERS *e,LPEXCEPTION_POINTERS ep) {  /** 
         *e=ep;          ISAPI // main workhorse
         return TRUE;  
 }  
   
 /// ISAPI // main workhorse          @todo 
                   IIS: remove trailing default-document[index.html] from $request.uri.
                   to do that we need to consult metabase,
                   wich is tested&works but seems slow runtime 
                   and not could-be-quickly-implemented if prepared.
   */
 DWORD WINAPI HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK lpECB) {  DWORD WINAPI HttpExtensionProc(LPEXTENSION_CONTROL_BLOCK lpECB) {
         Pool pool;          Pool_storage pool_storage;
         pool.set_context(lpECB);          Pool pool(&pool_storage); // no allocations until assigned context [for reporting]
           SAPI_func_context ctx={
         // TODO r->no_cache=1;                  lpECB,
                           0, // filling later: so that if there would be error pool would have ctx
                           200
           };
           pool.set_context(&ctx);// no allocations before this line!
           
         bool header_only=strcasecmp(lpECB->lpszMethod, "HEAD")==0;          bool header_only=strcasecmp(lpECB->lpszMethod, "HEAD")==0;
         PTRY { // global try          PTRY { // global try
                 // must be first in PTRY{}PCATCH                  ctx.header=new(pool) String(pool);
                 LPEXCEPTION_POINTERS e;                  
                 __try {                  // Request info
                                           Request::Info request_info;
                         const char *filespec_to_process=lpECB->lpszPathTranslated;  
                                           size_t path_translated_buf_size=strlen(lpECB->lpszPathTranslated)+1;
                         // Request info                  char *filespec_to_process=(char *)malloc(path_translated_buf_size);
                         Request::Info request_info;                  memcpy(filespec_to_process, lpECB->lpszPathTranslated, path_translated_buf_size);
                           #ifdef WIN32
                         const char *document_root=0; // todo: get from somewhere?                  back_slashes_to_slashes(filespec_to_process);
                         if(!document_root) {  #endif
                                 static char fake_document_root[MAX_STRING];  
                                 strncpy(fake_document_root, filespec_to_process, MAX_STRING);                  if(const char *path_info=SAPI::get_env(pool, "PATH_INFO")) {
                                 rsplit(fake_document_root, '/');  rsplit(fake_document_root, '\\');// strip filename                          // IIS
                                 document_root=fake_document_root;                          size_t len=strlen(filespec_to_process)-strlen(path_info);
                         }                          char *buf=(char *)pool.malloc(len+1);
                         request_info.document_root=document_root;                          strncpy(buf, filespec_to_process, len);
                         request_info.path_translated=filespec_to_process;                          buf[len]=0;
                         request_info.method=lpECB->lpszMethod;                          request_info.document_root=buf;
                         request_info.query_string=lpECB->lpszQueryString;                  } else
                         request_info.uri=lpECB->lpszPathInfo;//todo: check for ?zzz included?                          PTHROW(0, 0,
                         request_info.content_type=lpECB->lpszContentType;                                  0,
                         request_info.content_length=lpECB->cbTotalBytes;                                  "ISAPI: no PATH_INFO defined (in reinventing DOCUMENT_ROOT)");
                         {// cookie  
                                 char variable_buf[ISAPI_SERVER_VAR_BUF_SIZE];                  request_info.path_translated=filespec_to_process;
                                 DWORD variable_len = ISAPI_SERVER_VAR_BUF_SIZE-1;                  request_info.method=lpECB->lpszMethod;
                                                   request_info.query_string=lpECB->lpszQueryString;
                                 if (lpECB->GetServerVariable(lpECB->ConnID, "HTTP_COOKIE", variable_buf, &variable_len)) {                  if(lpECB->lpszQueryString && *lpECB->lpszQueryString) {
                                         variable_buf[variable_len]=0;                          char *reconstructed_uri=(char *)malloc(
                                         request_info.cookie=variable_buf;                                  strlen(lpECB->lpszPathInfo)+1/*'?'*/+
                                 } else if (GetLastError()==ERROR_INSUFFICIENT_BUFFER) {                                  strlen(lpECB->lpszQueryString)+1/*0*/);
                                         char *tmp_variable_buf=(char *)pool.malloc(variable_len+1);                          strcpy(reconstructed_uri, lpECB->lpszPathInfo);
                                                                   strcat(reconstructed_uri, "?");
                                         if (lpECB->GetServerVariable(lpECB->ConnID, "HTTP_COOKIE", tmp_variable_buf, &variable_len)) {                          strcat(reconstructed_uri, lpECB->lpszQueryString);
                                                 tmp_variable_buf[variable_len] = 0;                          request_info.uri=reconstructed_uri;
                                                 request_info.cookie=tmp_variable_buf;                  } else
                                         } else {                          request_info.uri=lpECB->lpszPathInfo;
                                                 request_info.cookie=0;                  
                                         }                  request_info.content_type=lpECB->lpszContentType;
                                 }                  request_info.content_length=lpECB->cbTotalBytes;
                         }                  request_info.cookie=SAPI::get_env(pool, "HTTP_COOKIE");
                                           
                         // prepare to process request                  // prepare to process request
                         Request request(pool,                  Request request(pool,
                                 request_info,                          request_info,
                                 String::UL_HTML_TYPO                          String::UL_HTML_TYPO
                                 );                          );
                           
                   // some root-controlled location
                         // some root-controlled location                  //   c:\windows
                         char *root_auto_path;                  // must be dynamic: rethrowing from request.core 
                         // c:\windows                  //   may return 'source' which can be inside of 'root auto.p@exeception'
                         root_auto_path=(char *)pool.malloc(MAX_STRING);                  char *root_auto_path=(char *)pool.malloc(MAX_STRING);
                         GetWindowsDirectory(root_auto_path, MAX_STRING);                  GetWindowsDirectory(root_auto_path, MAX_STRING);
                         strcat(root_auto_path, "/");  
                                           // process the request
                         // process the request                  request.core(
                         request.core(                          root_auto_path, false/*may be abcent*/, // /path/to/admin/auto.p
                                 root_auto_path, true, // /path/to/admin/auto.p                          0/*parser_site_auto_path*/, false, // /path/to/site/auto.p
                                 0/*parser_site_auto_path*/, false, // /path/to/site/auto.p                          header_only);
                                 header_only);                  // successful finish
                                   } PCATCH(e) { // global problem
                         // successful finish                  // don't allocate anything on pool here:
                                           //   possible pool' exception not catch-ed now
                         // must be last in PTRY{}PCATCH                  //   and there could be out-of-memory exception
                 } __except(exception_handler(&e, GetExceptionInformation())) {  
                         // converting C++ exception into Parser exception  
   
                         if(_exception_code()==EXCEPTION_STACK_OVERFLOW)   
                                 PTHROW(0, 0,  
                                         0,  
                                         "Stack overflow");  
                         else if(_exception_code()==EXCEPTION_ACCESS_VIOLATION)  
                                 PTHROW(0, 0,  
                                         0,  
                                         "Access violation at %p",   
                                                 e->ExceptionRecord->ExceptionAddress);  
                         else  
                                 PTHROW(0, 0,  
                                         0,  
                                         "Exception %#X at %p",   
                                                 e->ExceptionRecord->ExceptionCode,  
                                                 e->ExceptionRecord->ExceptionAddress);  
                 }  
                 // no further code here  
         } PCATCH(e) { // global problem   
                 const char *body=e.comment();                  const char *body=e.comment();
                 int content_length=strlen(body);                  // log it
                   SAPI::log(pool, "exception in request exception handler: %s", body);
   
                 // prepare header                  //
                 (*service_funcs.add_header_attribute)(pool, "content-type", "text/plain");                  int content_length=strlen(body);
                 char content_length_cstr[MAX_NUMBER];  
                 snprintf(content_length_cstr, MAX_NUMBER, "%d", content_length);  
                 (*service_funcs.add_header_attribute)(pool, "content-length",   
                         content_length_cstr);  
   
                   // prepare header // not using SAPI func wich allocates on pool
                   char header_buf[MAX_STRING];
                   int header_len=snprintf(header_buf, MAX_STRING,
                           "content-type: text/plain\n"
                           "content-length: %ul\n"
                           "expires: Fri, 23 Mar 2001 09:32:23 GMT\n"
                           "\n",
                           content_length);
   
                   HSE_SEND_HEADER_EX_INFO header_info;
                   header_info.pszStatus="200 OK";
                   header_info.cchStatus=strlen(header_info.pszStatus);
                   header_info.pszHeader=header_buf;
                   header_info.cchHeader=header_len;
                   header_info.fKeepConn=true;
                   
                 // send header                  // send header
                 (*service_funcs.send_header)(pool);                  lpECB->dwHttpStatusCode=200;
                   lpECB->ServerSupportFunction(lpECB->ConnID, 
                           HSE_REQ_SEND_RESPONSE_HEADER_EX, &header_info, NULL, NULL);
   
                 // send body                  // send body
                 if(!header_only)                  if(!header_only)
                         (*service_funcs.send_body)(pool, body, content_length);                          SAPI::send_body(pool, body, content_length);
   
                 // unsuccessful finish                  // unsuccessful finish
                 _endthread();  
         }          }
         PEND_CATCH          PEND_CATCH
                   
         return HSE_STATUS_SUCCESS;          return HSE_STATUS_SUCCESS_AND_KEEP_CONN;
 }  
   
   
 BOOL APIENTRY DllMain(HANDLE hModule,   
                                           DWORD  ul_reason_for_call,   
                                           LPVOID lpReserved  
                                           ) {  
     switch (ul_reason_for_call) {  
                 case DLL_PROCESS_ATTACH:  
                         parser_init();  
                         break;  
                 case DLL_THREAD_ATTACH:  
                         break;  
                 case DLL_THREAD_DETACH:  
                         break;  
                 case DLL_PROCESS_DETACH:  
                         break;  
     }  
     return TRUE;  
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.16

E-mail: