开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
HttpISAPI.cpp
资源名称：MiniCA2.rar　[点击查看]
上传用户：dengkfang
上传日期：2008-12-30
资源大小：5233k
文件大小：37k
源码类别：

CA认证

开发平台：

Visual C++

HttpISAPI.cpp：源码内容
  1. /*
  2. Module : HttpISAPI.cpp
  3. Purpose: Implementation for the CHttpISAPI class
  4. Created: PJN / 21-02-2003
  5. History: PJN / 22-02-2004 1. Fixed a memory leak in CHttpISAPI::CachedLoad. Thanks to "mori" for
  6.                           reporting and suggesting the fix for this bug.
  8. Copyright (c) 2003 - 2005 by PJ Naughter.  (Web: www.naughter.com, Email: pjna@naughter.com)
  10. All rights reserved.
  12. Copyright / Usage Details:
  14. You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise) 
  15. when your product is released in binary form. You are allowed to modify the source code in any way you want 
  16. except you cannot modify the copyright details at the top of each module. If you want to distribute source 
  17. code with your application, then you are only allowed to distribute versions released by the author. This is 
  18. to maintain a single distribution point for the source code. 
  20. */
  24. //////////////// Includes ////////////////////////////////////////////
  26. #include "stdafx.h"
  27. #include "HttpISAPI.h"
  28. #include "HttpClient.h"
  30. //////////////// Macros / Defines ////////////////////////////////////
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  38. #ifndef HSE_REQ_CLOSE_CONNECTION
  39. #define HSE_REQ_CLOSE_CONNECTION                 (HSE_REQ_END_RESERVED+17)
  40. #endif
  44. //////////////// Implementation //////////////////////////////////////
  46. CHttpISAPIExtension::CHttpISAPIExtension()
  47. {
  48.   m_hDLL = NULL;
  49.   m_lpGetExtensionVersion = NULL;
  50.   m_lpHttpExtensionProc = NULL;
  51.   m_lpTerminateExtension = NULL;
  52. }
  54. CHttpISAPIExtension::~CHttpISAPIExtension()
  55. {
  56.   if (m_hDLL)
  57.   {
  58.     //Call the terminate function (if it exists)
  59.     if (m_lpTerminateExtension)
  60.       CallTerminateExtension();
  61.       
  62.     //Finally free up the library
  63.     FreeLibrary(m_hDLL);
  64.   }
  65. }
  67. BOOL CHttpISAPIExtension::CallGetExtensionVersion(HSE_VERSION_INFO* phseVerInfo)
  68. {
  69.   //Validate our parameters
  70.   ASSERT(m_lpGetExtensionVersion);
  72.   //Assume the worst
  73.   BOOL bSuccess = FALSE;
  75.   __try
  76.   {
  77.     bSuccess = m_lpGetExtensionVersion(phseVerInfo);
  78.   }
  79.   __except(1)
  80.   {
  81.     bSuccess = FALSE;
  82.   }
  84.   return bSuccess;
  85. }
  87. BOOL CHttpISAPIExtension::CallTerminateExtension()
  88. {
  89.   ASSERT(m_lpTerminateExtension);
  91.   //Assume the worst
  92.   BOOL bSuccess = FALSE;
  94.   __try
  95.   {
  96.     bSuccess = m_lpTerminateExtension(HSE_TERM_MUST_UNLOAD);
  97.   }
  98.   __except(1)
  99.   {
  100.     bSuccess = FALSE;
  101.   }
  103.   return bSuccess;
  104. }
  108. CHttpISAPI::CHttpISAPI(int nISAPIHashTableSize) : m_mapExtensions(nISAPIHashTableSize)
  109. {
  110.   m_pServer = NULL;
  111. }
  113. CHttpISAPI::~CHttpISAPI()
  114. {
  115.   FreeMapEntries();
  116. }
  118. void CHttpISAPI::SetServer(CHttpServer* pServer)
  119. {
  120.   m_pServer = pServer;
  121. }
  123. void CHttpISAPI::FreeMapEntries()
  124. {
  125.   //Prevent the hash table from being manipulated
  126.   //by multiple threads at the one time
  127.   CSingleLock sl(&m_CS, TRUE);
  129.   //Remove all the entries in the hash table
  130.   for (POSITION pos = m_mapExtensions.GetStartPosition(); pos != NULL; )
  131.   {
  132.     CHttpISAPIExtension* pEntry = NULL;
  133.     CString sKey;
  134.     m_mapExtensions.GetNextAssoc(pos, sKey, (void*&) pEntry);
  135.     if (pEntry)
  136.       delete pEntry;
  137.   }
  138.   m_mapExtensions.RemoveAll();
  139. }
  141. BOOL CHttpISAPI::UncachedLoad(const CString& sPath, CHttpISAPIExtension& extension)
  142. {
  143.   //Validate our parameters
  144.   ASSERT(m_pServer);
  146.   //What will be the return value
  147.   BOOL bSuccess = FALSE;
  148.  
  149.   //Load up the DLL
  150.   ASSERT(extension.m_hDLL == NULL);
  151.   extension.m_sPath = sPath;
  152.   extension.m_hDLL = LoadLibraryEx(sPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
  153.   if (extension.m_hDLL)
  154.   {
  155.     //Get the "GetExtensionVersion" function
  156.     extension.m_lpGetExtensionVersion = (CHttpISAPIExtension::LPGETEXTENSIONVERSION) GetProcAddress(extension.m_hDLL, "GetExtensionVersion");
  157.     if (extension.m_lpGetExtensionVersion == NULL)    
  158.     {
  159.       //Report the error that we could not find the function
  160.       CString sError;
  161.       sError.Format(_T("CHttpISAPI::UncachedLoad, Could not find entry point GetExtensionVersion in dll %s"), sPath);
  162.       m_pServer->OnError(sError);
  163.     }
  165.     //Get the HttpExtensionProc function
  166.     extension.m_lpHttpExtensionProc = (CHttpISAPIExtension::LPHTTPEXTENSIONPROC) GetProcAddress(extension.m_hDLL, "HttpExtensionProc");
  167.     if (extension.m_lpHttpExtensionProc == NULL)    
  168.     {
  169.       //Report the error that we could not find the function
  170.       CString sError;
  171.       sError.Format(_T("CHttpISAPI::UncachedLoad, Could not find entry point HttpExtensionProc in dll %s"), sPath);
  172.       m_pServer->OnError(sError);
  173.     }
  175.     if (extension.m_lpGetExtensionVersion && extension.m_lpHttpExtensionProc)
  176.     {
  177.       //Now find the optional "TerminateExtension" function (if initialisation succeeded)
  178.       extension.m_lpTerminateExtension = (CHttpISAPIExtension::LPTERMINATEEXTENSION) GetProcAddress(extension.m_hDLL, "TerminateExtension");
  180.       //Also call the GetExtensionVersion function
  181.       HSE_VERSION_INFO hseVerInfo;
  182.       CString sError;
  183.       bSuccess = extension.CallGetExtensionVersion(&hseVerInfo);
  184.       if (!bSuccess)
  185.       {
  186.         //Report the error that we could not call the GetExtensionVersion function
  187.         sError.Format(_T("CHttpISAPI::UncachedLoad, Failed in call to GetExtensionVersion in dll %s, error:%d"), sPath, GetLastError());
  188.         m_pServer->OnError(sError);
  189.       }
  190.     }
  191.   }
  192.   else
  193.   {
  194.     //Report the error that we could not find the function
  195.     DWORD dwError = GetLastError();
  196.     CString sError;
  197.     sError.Format(_T("CHttpISAPI::UncachedLoad, Could not load the dll %s, error:%d"), sPath, dwError);
  198.     m_pServer->OnError(sError);
  199.   }
  201.   return bSuccess;
  202. }
  204. CHttpISAPIExtension* CHttpISAPI::CachedLoad(const CString& sPath)
  205. {
  206.   //Validate our parameters
  207.   ASSERT(m_pServer);
  208.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  209.   ASSERT(pSettings);
  210.   ASSERT(pSettings->m_bCacheISAPI);
  212.   //Look up in the hash table case insensitively
  213.   CString sKey(sPath);
  214.   sKey.MakeUpper(); 
  216.   //What will be the return value
  217.   CHttpISAPIExtension* pExtension = NULL;
  219.   //Prevent the hash table from being manipulated
  220.   //by multiple threads at the one time
  221.   CSingleLock sl(&m_CS, TRUE);
  223.   //try looking it up in the cache first
  224.   if (!m_mapExtensions.Lookup(sKey, (void*&) pExtension))
  225.   {
  226.     //Only created if not found in hash
  227.     pExtension = new CHttpISAPIExtension;
  228.  
  229.     //Call the other Load method to do most of the work
  230.     if (!UncachedLoad(sPath, *pExtension))
  231.     {
  232.       delete pExtension;
  233.       pExtension = NULL;
  234.     }
  235.     else
  236.     {
  237.       //Add it to the hash if caching is enabled
  238.       m_mapExtensions.SetAt(sKey, pExtension);
  239.     }
  240.   }
  242.   return pExtension;
  243. }
  245. BOOL CHttpISAPI::GetServerVariable(HCONN hConn, LPSTR lpszVariableName, void* lpBuffer, DWORD* lpdwBufferSize)
  246. {
  247.   USES_CONVERSION;
  249.   //Validate our parameters
  250.   CHttpClient* pClient = (CHttpClient*) hConn;
  251.   if (pClient == NULL)
  252.   {
  253.     SetLastError(ERROR_INVALID_PARAMETER);
  254.     return FALSE;
  255.   }  
  256.   ASSERT(pClient->m_pServer);
  257.   CHttpServerSettings* pSettings = pClient->m_pServer->GetSettings();
  258.   ASSERT(pSettings);
  260.   //Assume the best
  261.   BOOL bSuccess = TRUE;
  263.   if (strcmpi(lpszVariableName, "SERVER_PORT") == 0)
  264.   {
  265.     char szPort[10];
  266.     sprintf(szPort, "%d", pSettings->m_nPort);
  267.     DWORD dwSize = strlen(szPort) + 1;
  268.     if (*lpdwBufferSize >= dwSize)
  269.     {
  270.       strcpy((char*) lpBuffer, szPort);
  271.       *lpdwBufferSize = dwSize;
  272.     }
  273.     else
  274.     { 
  275.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  276.       bSuccess = FALSE;
  277.     }
  278.   }
  279.   else if (strcmpi(lpszVariableName, "SERVER_PORT_SECURE") == 0)
  280.   {
  281.   #ifdef W3MFC_SSL_SUPPORT
  282.     if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  283.     {
  284.       char szSecure[10];
  285.       sprintf(szSecure, "%d", pSettings->m_nPort);
  286.       DWORD dwSize = strlen(szSecure) + 1;
  287.       if (*lpdwBufferSize >= dwSize)
  288.       {
  289.         strcpy((char*) lpBuffer, szSecure);
  290.         *lpdwBufferSize = dwSize;
  291.       }
  292.       else
  293.       { 
  294.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  295.         bSuccess = FALSE;
  296.       }
  297.     }
  298.     else
  299.     {
  300.       SetLastError(ERROR_NO_DATA);
  301.       bSuccess = FALSE;
  302.     }
  303.   #else
  304.     SetLastError(ERROR_NO_DATA);
  305.     bSuccess = FALSE;
  306.   #endif
  307.   }
  308.   else if (strcmpi(lpszVariableName, "SERVER_PROTOCOL") == 0)
  309.   {
  310.     char szProtocol[10];
  311.   #ifdef W3MFC_SSL_SUPPORT
  312.     if (pSettings->m_SSLProtocol == CHttpServerSettings::SSL_NONE)
  313.       strcpy(szProtocol, "HTTP/1.0");
  314.     else
  315.       strcpy(szProtocol, "HTTPS/1.0");
  316.   #else
  317.     strcpy(szProtocol, "HTTP/1.0");
  318.   #endif
  320.     DWORD dwSize = strlen(szProtocol) + 1;
  321.     if (*lpdwBufferSize >= dwSize)
  322.     {
  323.       strcpy((char*) lpBuffer, szProtocol);
  324.       *lpdwBufferSize = dwSize;
  325.     }
  326.     else
  327.     { 
  328.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  329.       bSuccess = FALSE;
  330.     }
  331.   }
  332.   else if (strcmpi(lpszVariableName, "SERVER_SOFTWARE") == 0)
  333.   {
  334.     char* szSoftware = T2A((LPTSTR) (LPCTSTR) pSettings->m_sServerName);
  335.     DWORD dwSize = strlen(szSoftware) + 1;
  336.     if (*lpdwBufferSize >= dwSize)
  337.     {
  338.       strcpy((char*) lpBuffer, szSoftware);
  339.       *lpdwBufferSize = dwSize;
  340.     }
  341.     else
  342.     { 
  343.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  344.       bSuccess = FALSE;
  345.     }
  346.   }
  347.   else if (strcmpi(lpszVariableName, "URL") == 0)
  348.   {
  349.     char* szURL = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sURL);
  350.     DWORD dwSize = strlen(szURL) + 1;
  351.     if (*lpdwBufferSize >= dwSize)
  352.     {
  353.       strcpy((char*) lpBuffer, szURL);
  354.       *lpdwBufferSize = dwSize;
  355.     }
  356.     else
  357.     { 
  358.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  359.       bSuccess = FALSE;
  360.     }
  361.   }
  362.   else if (strcmpi(lpszVariableName, "QUERY_STRING") == 0)
  363.   {
  364.     char* szQueryString = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sRawExtra);
  365.     DWORD dwSize = strlen(szQueryString) + 1;
  366.     if (*lpdwBufferSize >= dwSize)
  367.     {
  368.       strcpy((char*) lpBuffer, szQueryString);
  369.       *lpdwBufferSize = dwSize;
  370.     }
  371.     else
  372.     { 
  373.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  374.       bSuccess = FALSE;
  375.     }
  376.   }
  377.   else if (strcmpi(lpszVariableName, "PATH_INFO") == 0)
  378.   {
  379.     char* szPathInfo = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sPathInfo);
  380.     DWORD dwSize = strlen(szPathInfo) + 1;
  381.     if (*lpdwBufferSize >= dwSize)
  382.     {
  383.       strcpy((char*) lpBuffer, szPathInfo);
  384.       *lpdwBufferSize = dwSize;
  385.     }
  386.     else
  387.     { 
  388.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  389.       bSuccess = FALSE;
  390.     }
  391.   }
  392.   else if (strcmpi(lpszVariableName, "REMOTE_ADDR") == 0)
  393.   {
  394.     char szRemote[20];
  395.     sprintf(szRemote, "%d.%d.%d.%d", pClient->m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b1,
  396.                pClient->m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b2, pClient->m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b3,
  397.                pClient->m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b4);
  398.     DWORD dwSize = strlen(szRemote) + 1;
  399.     if (*lpdwBufferSize >= dwSize)
  400.     {
  401.       strcpy((char*) lpBuffer, szRemote);
  402.       *lpdwBufferSize = dwSize;
  403.     }
  404.     else
  405.     { 
  406.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  407.       bSuccess = FALSE;
  408.     }
  409.   }
  410.   else if (strcmpi(lpszVariableName, "REMOTE_HOST") == 0)
  411.   {
  412.     if (pClient->m_Request.m_sRemoteHost.GetLength())
  413.     {
  414.       char* szRemoteHost = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sRemoteHost);
  415.       DWORD dwSize = strlen(szRemoteHost) + 1;
  416.       if (*lpdwBufferSize >= dwSize)
  417.       {
  418.         strcpy((char*) lpBuffer, szRemoteHost);
  419.         *lpdwBufferSize = dwSize;
  420.       }
  421.       else
  422.       { 
  423.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  424.         bSuccess = FALSE;
  425.       }
  426.     }
  427.     else
  428.     {
  429.       //just return the IP address if the remote host string is empty
  430.       return GetServerVariable(hConn, "REMOTE_ADDR", lpBuffer, lpdwBufferSize);
  431.     }
  432.   }
  433.   else if ((strcmpi(lpszVariableName, "REMOTE_USER") == 0) ||
  434.            (strcmpi(lpszVariableName, "AUTH_USER") == 0))
  435.   {
  436.     char* szUser = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sUsername);
  437.     DWORD dwSize = strlen(szUser) + 1;
  438.     if (*lpdwBufferSize >= dwSize)
  439.     {
  440.       strcpy((char*) lpBuffer, szUser);
  441.       *lpdwBufferSize = dwSize;
  442.     }
  443.     else
  444.     { 
  445.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  446.       bSuccess = FALSE;
  447.     }
  448.   }
  449.   else if (strcmpi(lpszVariableName, "REQUEST_METHOD") == 0)
  450.   {
  451.     char* szVerb = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sVerb);
  452.     DWORD dwSize = strlen(szVerb) + 1;
  453.     if (*lpdwBufferSize >= dwSize)
  454.     {
  455.       strcpy((char*) lpBuffer, szVerb);
  456.       *lpdwBufferSize = dwSize;
  457.     }
  458.     else
  459.     { 
  460.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  461.       bSuccess = FALSE;
  462.     }
  463.   }
  464.   else if (strcmpi(lpszVariableName, "SERVER_NAME") == 0)
  465.   {
  466.     char* szServerName = NULL;
  467.     char szHostName[256];
  468.     if (pSettings->m_sBindAddress.GetLength())
  469.       szServerName = T2A((LPTSTR) (LPCTSTR) pSettings->m_sBindAddress);
  470.     else
  471.     {
  472.       if (gethostname(szHostName, 256) == 0)
  473.         szServerName = szHostName; 
  474.       else
  475.         szServerName = "";
  476.     }
  478.     DWORD dwSize = strlen(szServerName) + 1;
  479.     if (*lpdwBufferSize >= dwSize)
  480.     {
  481.       strcpy((char*) lpBuffer, szServerName);
  482.       *lpdwBufferSize = dwSize;
  483.     }
  484.     else
  485.     { 
  486.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  487.       bSuccess = FALSE;
  488.     }
  489.   }
  490.   else if (strcmpi(lpszVariableName, "HTTPS") == 0)
  491.   {
  492.     char szHTTPS[10];
  493.   #ifdef W3MFC_SSL_SUPPORT
  494.     if (pSettings->m_SSLProtocol == CHttpServerSettings::SSL_NONE)
  495.       strcpy(szHTTPS, "off");
  496.     else
  497.       strcpy(szHTTPS, "on");
  498.   #else
  499.     strcpy(szHTTPS, "off");
  500.   #endif
  502.     DWORD dwSize = strlen(szHTTPS) + 1;
  503.     if (*lpdwBufferSize >= dwSize)
  504.     {
  505.       strcpy((char*) lpBuffer, szHTTPS);
  506.       *lpdwBufferSize = dwSize;
  507.     }
  508.     else
  509.     { 
  510.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  511.       bSuccess = FALSE;
  512.     }
  513.   }
  514.   else if (strcmpi(lpszVariableName, "AUTH_TYPE") == 0)
  515.   {
  516.     char szType[10];
  517.     if (pClient->m_Request.m_AuthorizationType == CHttpRequest::HTTP_AUTHORIZATION_PLAINTEXT)
  518.       strcpy(szType, "Basic");
  519.     else if (pClient->m_Request.m_AuthorizationType == CHttpRequest::HTTP_AUTHORIZATION_NTLM)
  520.       strcpy(szType, "NTLM");
  521.     else
  522.       strcpy(szType, "");
  524.     DWORD dwSize = strlen(szType) + 1;
  525.     if (*lpdwBufferSize >= dwSize)
  526.     {
  527.       strcpy((char*) lpBuffer, szType);
  528.       *lpdwBufferSize = dwSize;
  529.     }
  530.     else
  531.     { 
  532.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  533.       bSuccess = FALSE;
  534.     }
  535.   }
  536.   else if ((strcmpi(lpszVariableName, "AUTH_PASSWORD") == 0) ||
  537.            (strcmpi(lpszVariableName, "REMOTE_PASSWORD") == 0))
  538.   {
  539.     if (pClient->m_Request.m_sPassword.GetLength())
  540.     {
  541.       char* szPassword = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sPassword);
  542.       DWORD dwSize = strlen(szPassword) + 1;
  543.       if (*lpdwBufferSize >= dwSize)
  544.       {
  545.         strcpy((char*) lpBuffer, szPassword);
  546.         *lpdwBufferSize = dwSize;
  547.       }
  548.       else
  549.       { 
  550.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  551.         bSuccess = FALSE;
  552.       }
  553.     }
  554.     else
  555.     {
  556.       SetLastError(ERROR_NO_DATA);
  557.       bSuccess = FALSE;
  558.     }
  559.   }
  560.   else if (strcmpi(lpszVariableName, "AUTH_REALM") == 0)
  561.   {
  562.     if (pClient->m_Request.m_AuthorizationType == CHttpRequest::HTTP_AUTHORIZATION_PLAINTEXT)
  563.     {
  564.       char* szRealm = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sURL);
  565.       DWORD dwSize = strlen(szRealm) + 1;
  566.       if (*lpdwBufferSize >= dwSize)
  567.       {
  568.         strcpy((char*) lpBuffer, szRealm);
  569.         *lpdwBufferSize = dwSize;
  570.       }
  571.       else
  572.       { 
  573.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  574.         bSuccess = FALSE;
  575.       }
  576.     }
  577.     else
  578.     {
  579.       SetLastError(ERROR_NO_DATA);
  580.       bSuccess = FALSE;
  581.     }
  582.   }
  583.   else if (strcmpi(lpszVariableName, "CONTENT_LENGTH") == 0)
  584.   {
  585.     if (pClient->m_Request.m_nContentLength)
  586.     {
  587.       char szContentLength[10];
  588.       sprintf(szContentLength, "%d", pClient->m_Request.m_nContentLength);
  589.       DWORD dwSize = strlen(szContentLength) + 1;
  590.       if (*lpdwBufferSize >= dwSize)
  591.       {
  592.         strcpy((char*) lpBuffer, szContentLength);
  593.         *lpdwBufferSize = dwSize;
  594.       }
  595.       else
  596.       { 
  597.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  598.         bSuccess = FALSE;
  599.       }
  600.     }
  601.     else
  602.     {
  603.       SetLastError(ERROR_NO_DATA);
  604.       bSuccess = FALSE;
  605.     }
  606.   }
  607.   else if (strcmpi(lpszVariableName, "CONTENT_TYPE") == 0)
  608.   {
  609.     if (pClient->m_Request.m_sContentType.GetLength())
  610.     {
  611.       char* szContentType = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sContentType);
  612.       DWORD dwSize = strlen(szContentType) + 1;
  613.       if (*lpdwBufferSize >= dwSize)
  614.       {
  615.         strcpy((char*) lpBuffer, szContentType);
  616.         *lpdwBufferSize = dwSize;
  617.       }
  618.       else
  619.       { 
  620.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  621.         bSuccess = FALSE;
  622.       }
  623.     }
  624.     else
  625.     {
  626.       SetLastError(ERROR_NO_DATA);
  627.       bSuccess = FALSE;
  628.     }
  629.   }
  630.   else if (strcmpi(lpszVariableName, "LOGON_USER") == 0)
  631.   {
  632.     if (pClient->m_Request.m_bLoggedOn)
  633.     {
  634.       char* szUser = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sUsername);
  635.       DWORD dwSize = strlen(szUser) + 1;
  636.       if (*lpdwBufferSize >= dwSize)
  637.       {
  638.         strcpy((char*) lpBuffer, szUser);
  639.         *lpdwBufferSize = dwSize;
  640.       }
  641.       else
  642.       { 
  643.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  644.         bSuccess = FALSE;
  645.       }
  646.     }
  647.     else if (pSettings->m_sUsername.GetLength())
  648.     {
  649.       char* szUser = T2A((LPTSTR) (LPCTSTR) pSettings->m_sUsername);
  650.       DWORD dwSize = strlen(szUser) + 1;
  651.       if (*lpdwBufferSize >= dwSize)
  652.       {
  653.         strcpy((char*) lpBuffer, szUser);
  654.         *lpdwBufferSize = dwSize;
  655.       }
  656.       else
  657.       { 
  658.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  659.         bSuccess = FALSE;
  660.       }
  661.     }
  662.     else
  663.     {
  664.       SetLastError(ERROR_NO_DATA);
  665.       bSuccess = FALSE;
  666.     }
  667.   }
  668.   else if ((strcmpi(lpszVariableName, "HTTPS_SERVER_SUBJECT") == 0) ||
  669.            (strcmpi(lpszVariableName, "CERT_SERVER_SUBJECT") == 0))
  670.   {
  671.     char* szSubject = NULL;
  672.     if (pClient->GetCertIssuerServerVariable(szSubject))
  673.     {
  674.       DWORD dwSize = strlen(szSubject) + 1;
  675.       if (*lpdwBufferSize >= dwSize)
  676.       {
  677.         strcpy((char*) lpBuffer, szSubject);
  678.         *lpdwBufferSize = dwSize;
  679.       }
  680.       else
  681.       { 
  682.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  683.         bSuccess = FALSE;
  684.       }
  685.     }
  686.     else
  687.     {
  688.       SetLastError(ERROR_NO_DATA);
  689.       bSuccess = FALSE;
  690.     }
  691.   }
  692.   else if ((strcmpi(lpszVariableName, "HTTPS_SERVER_ISSUER") == 0) ||
  693.            (strcmpi(lpszVariableName, "CERT_SERVER_ISSUER") == 0))
  694.   { 
  695.     char* szIssuer = NULL;
  696.     if (pClient->GetCertIssuerServerVariable(szIssuer))
  697.     {
  698.       DWORD dwSize = strlen(szIssuer) + 1;
  699.       if (*lpdwBufferSize >= dwSize)
  700.       {
  701.         strcpy((char*) lpBuffer, szIssuer);
  702.         *lpdwBufferSize = dwSize;
  703.       }
  704.       else
  705.       { 
  706.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  707.         bSuccess = FALSE;
  708.       }
  709.     }
  710.     else
  711.     {
  712.       SetLastError(ERROR_NO_DATA);
  713.       bSuccess = FALSE;
  714.     }
  715.   }
  716.   else if (strcmpi(lpszVariableName, "CERT_SERIALNUMBER") == 0)
  717.   {
  718.     long nSerialNumber = 0;
  719.     if (pClient->GetCertSerialNumberServerVariable(nSerialNumber))
  720.     {
  721.       char szSerialNumber[10];
  722.       sprintf(szSerialNumber, "%d", nSerialNumber);
  723.       DWORD dwSize = strlen(szSerialNumber) + 1;
  724.       if (*lpdwBufferSize >= dwSize)
  725.       {
  726.         strcpy((char*) lpBuffer, szSerialNumber);
  727.         *lpdwBufferSize = dwSize;
  728.       }
  729.       else
  730.       { 
  731.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  732.         bSuccess = FALSE;
  733.       }
  734.     }
  735.     else
  736.     {
  737.       SetLastError(ERROR_NO_DATA);
  738.       bSuccess = FALSE;
  739.     }
  740.   }
  741.   else if ((strcmpi(lpszVariableName, "HTTPS_SECRETKEYSIZE") == 0) ||
  742.            (strcmpi(lpszVariableName, "CERT_SECRETKEYSIZE") == 0))
  743.   {
  744.     int nBits = 0;
  745.     if (pClient->GetServerKeySizeServerVariable(nBits))
  746.     {
  747.       char szBits[10];
  748.       sprintf(szBits, "%d", nBits);
  749.       DWORD dwSize = strlen(szBits) + 1;
  750.       if (*lpdwBufferSize >= dwSize)
  751.       {
  752.         strcpy((char*) lpBuffer, szBits);
  753.         *lpdwBufferSize = dwSize;
  754.       }
  755.       else
  756.       { 
  757.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  758.         bSuccess = FALSE;
  759.       }
  760.     }
  761.     else
  762.     {
  763.       SetLastError(ERROR_NO_DATA);
  764.       bSuccess = FALSE;
  765.     }
  766.   }
  767.   else if ((strcmpi(lpszVariableName, "HTTPS_KEYSIZE") == 0) ||
  768.            (strcmpi(lpszVariableName, "CERT_KEYSIZE") == 0)) 
  769.   {
  770.     int nBits = 0;
  771.     if (pClient->GetKeySizeServerVariable(nBits))
  772.     {
  773.       char szBits[10];
  774.       sprintf(szBits, "%d", nBits);
  775.       DWORD dwSize = strlen(szBits) + 1;
  776.       if (*lpdwBufferSize >= dwSize)
  777.       {
  778.         strcpy((char*) lpBuffer, szBits);
  779.         *lpdwBufferSize = dwSize;
  780.       }
  781.       else
  782.       { 
  783.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  784.         bSuccess = FALSE;
  785.       }
  786.     }
  787.     else
  788.     {
  789.       SetLastError(ERROR_NO_DATA);
  790.       bSuccess = FALSE;
  791.     }
  792.   }
  793.   else if (strcmpi(lpszVariableName, "PATH_TRANSLATED") == 0)
  794.   {
  795.     LPTSTR pszFilePart;
  796.     TCHAR pszAbsolutePath[_MAX_PATH];
  797.     GetFullPathName(pClient->m_Request.m_sLocalFile, _MAX_PATH, pszAbsolutePath, &pszFilePart);
  798.     char* szAbsolutePath = T2A(pszAbsolutePath);
  799.     DWORD dwSize = strlen(szAbsolutePath) + 1;
  800.     if (*lpdwBufferSize >= dwSize)
  801.     {
  802.       strcpy((char*) lpBuffer, szAbsolutePath);
  803.       *lpdwBufferSize = dwSize;
  804.     }
  805.     else
  806.     { 
  807.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  808.       bSuccess = FALSE;
  809.     }
  810.   }
  811.   else if (strcmpi(lpszVariableName, "SCRIPT_NAME") == 0)
  812.   {
  813.     CString sScriptName = pClient->m_Request.m_sLocalFile;
  814.     sScriptName.Replace(_T('\'), _T('/')); //Ensure we use unix directory separators
  815.     if (sScriptName.GetLength() && sScriptName.GetAt(0) != _T('/'))
  816.       sScriptName = _T("/") + sScriptName;
  818.     char* szScriptName = T2A((LPTSTR) (LPCTSTR) sScriptName);
  819.     DWORD dwSize = strlen(szScriptName) + 1;
  820.     if (*lpdwBufferSize >= dwSize)
  821.     {
  822.       strcpy((char*) lpBuffer, szScriptName);
  823.       *lpdwBufferSize = dwSize;
  824.     }
  825.     else
  826.     { 
  827.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  828.       bSuccess = FALSE;
  829.     }
  830.   }
  831.   else if (strcmpi(lpszVariableName, "REQUEST_LINE") == 0)
  832.   {
  833.     char* szRequest = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sRequest);
  834.     DWORD dwSize = strlen(szRequest) + 1;
  835.     if (*lpdwBufferSize >= dwSize)
  836.     {
  837.       strcpy((char*) lpBuffer, szRequest);
  838.       *lpdwBufferSize = dwSize;
  839.     }
  840.     else
  841.     { 
  842.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  843.       bSuccess = FALSE;
  844.     }
  845.   }
  846.   else if (strcmpi(lpszVariableName, "ALL_HTTP") == 0)
  847.   {
  848.     CString sAllHeaders;
  849.     POSITION posMap = pClient->m_Request.m_HeaderMap.GetStartPosition();
  850.     while (posMap)
  851.     {
  852.       CString sKey;
  853.       CString sValue;
  854.       pClient->m_Request.m_HeaderMap.GetNextAssoc(posMap, sKey, sValue);
  856.       CString sLine;
  857.       if (posMap)  
  858.         sLine.Format(_T("HTTP_%s=%sn"), sKey, sValue);
  859.       else
  860.         sLine.Format(_T("HTTP_%s=%s"), sKey, sValue);
  861.         
  862.       sAllHeaders += sLine;
  863.     }
  864.     
  865.     char* pszAllHeaders = T2A((LPTSTR) (LPCTSTR) sAllHeaders);
  866.     DWORD dwSize = strlen(pszAllHeaders) + 1;
  867.     if (*lpdwBufferSize >= dwSize)
  868.     {
  869.       strcpy((char*) lpBuffer, pszAllHeaders);
  870.       *lpdwBufferSize = dwSize;
  871.     }
  872.     else
  873.     { 
  874.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  875.       bSuccess = FALSE;
  876.     }
  877.   }
  878.   else if (strcmpi(lpszVariableName, "ALL_RAW") == 0)
  879.   {
  880.     DWORD dwSize = 0;
  881.     if (pClient->m_Request.m_pRawEntity)
  882.       dwSize = pClient->m_Request.m_pRawEntity - pClient->m_Request.m_pRawRequest + 1;
  883.     else
  884.       dwSize = pClient->m_Request.m_dwRawRequestSize;
  885.     if (*lpdwBufferSize >= dwSize)
  886.     {
  887.       CopyMemory(lpBuffer, pClient->m_Request.m_pRawRequest, dwSize);
  888.       ((BYTE*) lpBuffer)[dwSize] = '';
  889.       *lpdwBufferSize = dwSize;
  890.     }
  891.     else
  892.     { 
  893.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  894.       bSuccess = FALSE;
  895.     }
  896.   }
  897.   else if (strcmpi(lpszVariableName, "HTTP_VERSION") == 0)
  898.   {
  899.     char szVersion[10];
  900.     sprintf(szVersion, "%d.%d", HIWORD(pClient->m_Request.m_dwHttpVersion), LOWORD(pClient->m_Request.m_dwHttpVersion));
  901.     DWORD dwSize = strlen(szVersion) + 1;
  902.     if (*lpdwBufferSize >= dwSize)
  903.     {
  904.       strcpy((char*) lpBuffer, szVersion);
  905.       *lpdwBufferSize = dwSize;
  906.     }
  907.     else
  908.     { 
  909.       SetLastError(ERROR_INSUFFICIENT_BUFFER);
  910.       bSuccess = FALSE;
  911.     }
  912.   }
  913.   else if (_strnicmp(lpszVariableName, "HTTP_", 5) == 0)
  914.   {
  915.     CString sKey(lpszVariableName);
  916.     sKey = sKey.Right(sKey.GetLength() - 5);
  917.     sKey.MakeUpper();
  918.     CString sValue;
  919.     if (pClient->m_Request.m_HeaderMap.Lookup(sKey, sValue))
  920.     {
  921.       char* szValue = T2A((LPTSTR) (LPCTSTR) sValue);
  922.       DWORD dwSize = strlen(szValue) + 1;
  923.       if (*lpdwBufferSize >= dwSize)
  924.       {
  925.         strcpy((char*) lpBuffer, szValue);
  926.         *lpdwBufferSize = dwSize;
  927.       }
  928.       else
  929.       { 
  930.         SetLastError(ERROR_INSUFFICIENT_BUFFER);
  931.         bSuccess = FALSE;
  932.       }
  933.     }
  934.     else
  935.     {
  936.       SetLastError(ERROR_NO_DATA);
  937.       bSuccess = FALSE;
  938.     }
  939.   }
  940.   else
  941.   {
  942.     SetLastError(ERROR_INVALID_INDEX);
  943.     bSuccess = FALSE;
  944.   }
  946.   return bSuccess;
  947. }
  949. BOOL CHttpISAPI::ReadClient(HCONN hConn, LPVOID /*lpvBuffer*/, LPDWORD lpdwSize)
  950. {
  951.   //nothing to read, so set the value
  952.   *lpdwSize = 0;
  954.   //Validate our parameters
  955.   CHttpClient* pClient = (CHttpClient*) hConn;
  956.   if (pClient == NULL)
  957.   {
  958.     SetLastError(ERROR_INVALID_PARAMETER);
  959.     return FALSE;
  960.   }  
  962.   //We do not support reading from the client, since we supply all of the data in the EXTENSION_CONTROL_BLOCK
  963.   SetLastError(ERROR_NO_DATA);
  964.   return FALSE;
  965. }
  967. BOOL CHttpISAPI::WriteClient(HCONN hConn, LPVOID Buffer, LPDWORD lpdwBytes, DWORD dwSync)
  968. {
  969.   //Validate our parameters
  970.   CHttpClient* pClient = (CHttpClient*) hConn;
  971.   if ((pClient == NULL) || (dwSync == HSE_IO_ASYNC))
  972.   {
  973.     SetLastError(ERROR_INVALID_PARAMETER);
  974.     return FALSE;
  975.   }  
  976.   ASSERT(pClient->m_pServer);
  977.   CHttpServerSettings* pSettings = pClient->m_pServer->GetSettings();
  978.   ASSERT(pSettings);
  980.   //Assume the worst
  981.   BOOL bSuccess = FALSE;
  983.   try
  984.   {
  985.   #ifdef W3MFC_SSL_SUPPORT
  986.     pClient->m_Socket.SendWithRetry(Buffer, *lpdwBytes, pSettings->m_dwWritableTimeout, pClient->m_SSL);
  987.   #else    
  988.     pClient->m_Socket.SendWithRetry(Buffer, *lpdwBytes, pSettings->m_dwWritableTimeout);
  989.   #endif
  991.     pClient->m_dwDataSentViaWriteClient += *lpdwBytes;
  992.     bSuccess = TRUE;
  993.   }
  994.   catch(CWSocketException* pEx)
  995.   {
  996.     //Report the error
  997.     CString sError;
  998.     sError.Format(_T("CHttpISAPI::WriteClient, Failed to send to socket, error:%d"), pEx->m_nError);
  999.     pClient->m_pServer->OnError(sError);
  1001.     //Allow callers to see what the error was
  1002.     SetLastError(pEx->m_nError);
  1004.     pEx->Delete();  
  1005.   }
  1006.   return bSuccess;
  1007. }
  1009. BOOL CHttpISAPI::ServerSupportFunction(HCONN hConn, DWORD dwHSERRequest, LPVOID lpvBuffer, LPDWORD lpdwSize, LPDWORD lpdwDataType)
  1010. {
  1011.   USES_CONVERSION;
  1013.   //Validate our parameters
  1014.   CHttpClient* pClient = (CHttpClient*) hConn;
  1015.   if (pClient == NULL)
  1016.   {
  1017.     SetLastError(ERROR_INVALID_PARAMETER);
  1018.     return FALSE;
  1019.   }  
  1020.   ASSERT(pClient->m_pServer);
  1021.   CHttpServerSettings* pSettings = pClient->m_pServer->GetSettings();
  1022.   ASSERT(pSettings);
  1024.   //Assume the best
  1025.   BOOL bSuccess = TRUE;
  1027.   switch (dwHSERRequest)
  1028.   {
  1029.     case HSE_REQ_CLOSE_CONNECTION:
  1030.     {
  1031.       //We support this function but do a NOOP since
  1032.       //the connection will be closed when HttpExtensionProc
  1033.       //returns normally
  1034.       break;
  1035.     }
  1036.     case HSE_REQ_GET_IMPERSONATION_TOKEN:
  1037.     {
  1038.       if (pClient->m_Request.m_hImpersonation)
  1039.         *((HANDLE*) lpvBuffer) = pClient->m_Request.m_hImpersonation;
  1040.       else
  1041.       {
  1042.         SetLastError(ERROR_NO_DATA);
  1043.         bSuccess = FALSE;
  1044.       }
  1045.       break;
  1046.     }
  1047.     case HSE_REQ_GET_SSPI_INFO:
  1048.     {
  1049.     #ifndef W3MFC_NO_SSPI_SUPPORT
  1050.       CopyMemory(((CtxtHandle*) lpvBuffer), &pClient->m_Request.m_hImpersonation, sizeof(CtxtHandle));
  1051.       CopyMemory(((CredHandle*) lpdwDataType), pClient->m_pServer->GetCredentialHandle(), sizeof(CredHandle));
  1052.     #else
  1053.       SetLastError(ERROR_NO_DATA);
  1054.       bSuccess = FALSE;
  1055.     #endif
  1056.       break;
  1057.     }
  1058.     case HSE_REQ_IS_KEEP_CONN:
  1059.     {
  1060.       *((BOOL*) lpvBuffer) = pClient->m_bResponseKeepAlive;
  1061.       break;
  1062.     }
  1063.     case HSE_REQ_MAP_URL_TO_PATH:
  1064.     {
  1065.       LPSTR pszURL = (LPSTR) lpvBuffer;
  1066.       HSE_URL_MAPEX_INFO* pUMI = (HSE_URL_MAPEX_INFO*) lpdwDataType;
  1067.       pUMI->dwFlags = 0;
  1069.       CString sURL(pszURL);
  1070.       BOOL bDirectory = FALSE;
  1071.       CHttpDirectory* pDirectory = NULL;
  1072.       CString sLocalFile;
  1073.       CString sPathInfo;
  1074.       if (pClient->MapURLToLocalFilename(sURL, sLocalFile, sPathInfo, bDirectory, pDirectory, pUMI->cchMatchingURL, pUMI->cchMatchingPath))
  1075.       {
  1076.         LPSTR pszLocalFile = T2A((LPTSTR) (LPCTSTR) sLocalFile);
  1077.         DWORD dwSize = strlen(pszLocalFile) + 1;
  1078.         if (*lpdwSize >= dwSize)
  1079.         {
  1080.           strcpy(pszURL, pszLocalFile);
  1082.           if (!pDirectory->GetScript())
  1083.             pUMI->dwFlags |= HSE_URL_FLAGS_READ;
  1084.           else
  1085.           {
  1086.             pUMI->dwFlags |= HSE_URL_FLAGS_EXECUTE;
  1087.             pUMI->dwFlags |= HSE_URL_FLAGS_SCRIPT;
  1088.           }
  1089.           if (pDirectory->GetWritable())
  1090.             pUMI->dwFlags |= HSE_URL_FLAGS_WRITE;
  1092.         #ifdef W3MFC_SSL_SUPPORT
  1093.           if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  1094.              pUMI->dwFlags |= HSE_URL_FLAGS_SSL;
  1095.         #endif
  1096.         }
  1097.         else
  1098.         {
  1099.           SetLastError(ERROR_INSUFFICIENT_BUFFER);
  1100.           bSuccess = FALSE;
  1101.         }
  1102.       }
  1103.       else
  1104.       {
  1105.         SetLastError(ERROR_NO_DATA);
  1106.         bSuccess = FALSE;
  1107.       }
  1108.       break;
  1109.     }
  1110.     case HSE_REQ_MAP_URL_TO_PATH_EX:
  1111.     {
  1112.       LPSTR pszURL = (LPSTR) lpvBuffer;
  1113.       HSE_URL_MAPEX_INFO* pUMI = (HSE_URL_MAPEX_INFO*) lpdwDataType;
  1114.       pUMI->dwFlags = 0;
  1116.       CString sURL(pszURL);
  1117.       BOOL bDirectory = FALSE;
  1118.       CHttpDirectory* pDirectory = NULL;
  1119.       CString sLocalFile;
  1120.       CString sPathInfo;
  1121.       if (pClient->MapURLToLocalFilename(sURL, sLocalFile, sPathInfo, bDirectory, pDirectory, pUMI->cchMatchingURL, pUMI->cchMatchingPath))
  1122.       {
  1123.         LPSTR pszLocalFile = T2A((LPTSTR) (LPCTSTR) sLocalFile);
  1124.         strcpy(pUMI->lpszPath, pszLocalFile);
  1126.         if (!pDirectory->GetScript())
  1127.           pUMI->dwFlags |= HSE_URL_FLAGS_READ;
  1128.         else
  1129.         {
  1130.           pUMI->dwFlags |= HSE_URL_FLAGS_EXECUTE;
  1131.           pUMI->dwFlags |= HSE_URL_FLAGS_SCRIPT;
  1132.         }
  1133.         if (pDirectory->GetWritable())
  1134.           pUMI->dwFlags |= HSE_URL_FLAGS_WRITE;
  1136.       #ifdef W3MFC_SSL_SUPPORT
  1137.         if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  1138.            pUMI->dwFlags |= HSE_URL_FLAGS_SSL;
  1139.       #endif
  1140.       }
  1141.       else
  1142.       {
  1143.         SetLastError(ERROR_NO_DATA);
  1144.         bSuccess = FALSE;
  1145.       }
  1146.       break;
  1147.     }
  1148.     case HSE_REQ_SEND_URL:
  1149.     case HSE_REQ_SEND_URL_REDIRECT_RESP:
  1150.     {
  1151.       LPSTR pszURL = (LPSTR) lpvBuffer;
  1152.       pClient->ReturnRedirectMessage(pszURL);
  1153.       pClient->m_nHttpStatusCodeSent = 302;
  1154.       break;
  1155.     }
  1156.     case HSE_REQ_SEND_RESPONSE_HEADER:
  1157.     {
  1158.       LPSTR pszStatusString = (LPSTR) lpvBuffer;
  1159.       LPSTR pszExtraHeaders = (LPSTR) lpdwDataType;
  1161.       CHttpResponseHeader responseHdr;
  1162.       if (pszStatusString && strlen(pszStatusString))
  1163.       {
  1164.         responseHdr.AddStatus(pszStatusString);
  1165.         pClient->m_nHttpStatusCodeSent = atoi(pszStatusString);
  1166.       }
  1167.       else
  1168.       {
  1169.         responseHdr.AddStatusCode(200);
  1170.         pClient->m_nHttpStatusCodeSent = 200;
  1171.       }
  1173.       SYSTEMTIME stCurTime;
  1174.       ::GetSystemTime(&stCurTime);
  1175.       responseHdr.AddDate(stCurTime);
  1176.       responseHdr.AddServer(pSettings->m_sServerName);
  1177.       responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1178.       if (pszExtraHeaders && strlen(pszExtraHeaders))
  1179.         responseHdr.AddExtraHeaders(pszExtraHeaders);
  1180.       pClient->m_bResponseKeepAlive = FALSE;
  1181.       responseHdr.SetAddEntitySeparator(FALSE);
  1182.       
  1183.       //Send the header 
  1184.       pClient->TransmitBuffer(pClient->m_Socket, responseHdr, NULL, 0, pSettings->m_dwWritableTimeout);
  1185.       break;
  1186.     }
  1187.     case HSE_REQ_SEND_RESPONSE_HEADER_EX:
  1188.     {
  1189.       HSE_SEND_HEADER_EX_INFO* pHeader = (HSE_SEND_HEADER_EX_INFO*) lpvBuffer;
  1191.       CHttpResponseHeader responseHdr;
  1192.       if (pHeader->pszStatus && strlen(pHeader->pszStatus))
  1193.       {
  1194.         responseHdr.AddStatus(pHeader->pszStatus);
  1195.         pClient->m_nHttpStatusCodeSent = atoi(pHeader->pszStatus);
  1196.       }
  1197.       else
  1198.       {
  1199.         responseHdr.AddStatusCode(200);
  1200.         pClient->m_nHttpStatusCodeSent = 200;
  1201.       }
  1203.       SYSTEMTIME stCurTime;
  1204.       ::GetSystemTime(&stCurTime);
  1205.       responseHdr.AddDate(stCurTime);
  1206.       responseHdr.AddServer(pSettings->m_sServerName);
  1207.       responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1208.       if (pHeader->pszHeader && strlen(pHeader->pszHeader))
  1209.         responseHdr.AddExtraHeaders(pHeader->pszHeader);
  1210.       if (pHeader->fKeepConn)
  1211.         responseHdr.AddKeepAlive();
  1212.       pClient->m_bResponseKeepAlive = pHeader->fKeepConn;
  1213.       responseHdr.SetAddEntitySeparator(FALSE);
  1215.       //Send the header 
  1216.       pClient->TransmitBuffer(pClient->m_Socket, responseHdr, NULL, 0, pSettings->m_dwWritableTimeout);
  1217.       break;
  1218.     }
  1219.     case HSE_REQ_TRANSMIT_FILE:
  1220.     {
  1221.     #ifdef W3MFC_SSL_SUPPORT
  1222.       BOOL bAvailable = (pSettings->m_SSLProtocol == CHttpServerSettings::SSL_NONE);
  1223.     #else
  1224.       BOOL bAvailable = TRUE;
  1225.     #endif
  1226.       if (bAvailable)
  1227.       {
  1228.         CHttpResponseHeader responseHdr;
  1229.         SYSTEMTIME stCurTime;
  1230.         ::GetSystemTime(&stCurTime);
  1231.         responseHdr.AddDate(stCurTime);
  1232.         responseHdr.AddServer(pSettings->m_sServerName);
  1233.         responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1234.         pClient->m_bResponseKeepAlive = FALSE;
  1236.         HSE_TF_INFO* pInfo = (HSE_TF_INFO*) lpvBuffer;
  1237.         bSuccess = pClient->TransmitFile(pClient->m_Socket, responseHdr, pInfo);
  1238.       }
  1239.       else
  1240.       {
  1241.         SetLastError(ERROR_INVALID_INDEX);
  1242.         bSuccess = FALSE;
  1243.       }
  1244.       break;
  1245.     }
  1246.     default:
  1247.     {
  1248.       //Report the error
  1249.       CString sError;
  1250.       sError.Format(_T("CHttpISAPI::ServerSupportFunction, An invalid HSERequest value was specified %s, HSERequest:%d"), pClient->m_Request.m_sURL, dwHSERRequest);
  1251.       pClient->m_pServer->OnError(sError);
  1253.       SetLastError(ERROR_INVALID_INDEX);
  1254.       bSuccess = FALSE;
  1255.       break;
  1256.     }
  1257.   }
  1259.   return bSuccess;
  1260. }
  1262. void CHttpISAPI::ReportHttpExtensionProcError(CHttpClient* pClient, CHttpISAPIExtension& extension, DWORD dwError)
  1263. {
  1264.   //Validate our parameters
  1265.   ASSERT(pClient);
  1266.   ASSERT(pClient->m_pServer);
  1268.   //Report the error
  1269.   CString sError;
  1270.   sError.Format(_T("CHttpISAPI::ReportHTTPExtensionProcError, Failed calling the function HttpExtensionProc in the ISAPI extension %s, error:%d"), extension.m_sPath, dwError);
  1271.   pClient->m_pServer->OnError(sError);
  1272. }
  1274. BOOL CHttpISAPI::CallHttpExtensionProc(CHttpClient* pClient, CHttpISAPIExtension& extension)
  1275. {
  1276.   USES_CONVERSION;
  1278.   //Validate our parameters
  1279.   ASSERT(extension.m_lpHttpExtensionProc);
  1280.   ASSERT(pClient);
  1281.   ASSERT(pClient->m_pServer);
  1283.   //Assume the worst
  1284.   BOOL bSuccess = FALSE;
  1286.   __try
  1287.   {
  1288.     //Setup the structure
  1289.     EXTENSION_CONTROL_BLOCK ecb;
  1290.     ecb.cbSize = sizeof(EXTENSION_CONTROL_BLOCK);
  1291.     ecb.dwVersion = MAKELONG(HSE_VERSION_MINOR, HSE_VERSION_MAJOR);
  1292.     ecb.ConnID = (HCONN) pClient;
  1293.     ecb.dwHttpStatusCode = 200;
  1294.     strcpy(ecb.lpszLogData, "");
  1295.     ecb.lpszMethod = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sVerb);
  1296.     ecb.lpszQueryString = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sRawExtra);
  1297.     ecb.lpszPathInfo = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sPathInfo);
  1298.     ecb.lpszPathTranslated = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sLocalFile);
  1299.     ecb.cbTotalBytes = pClient->m_Request.m_dwRawEntitySize;
  1300.     ecb.cbAvailable = ecb.cbTotalBytes;
  1301.     ecb.lpbData = pClient->m_Request.m_pRawEntity;
  1302.     ecb.lpszContentType = T2A((LPTSTR) (LPCTSTR) pClient->m_Request.m_sContentType);
  1303.     ecb.GetServerVariable = GetServerVariable;
  1304.     ecb.WriteClient = WriteClient;
  1305.     ecb.ReadClient = ReadClient;
  1306.     ecb.ServerSupportFunction = ServerSupportFunction;
  1308.     //Finally call the function with the structure
  1309.     DWORD dwSuccess = extension.m_lpHttpExtensionProc(&ecb);
  1310.     bSuccess = (dwSuccess == HSE_STATUS_SUCCESS);
  1311.     if (dwSuccess == HSE_STATUS_SUCCESS_AND_KEEP_CONN)
  1312.     {
  1313.       pClient->m_bResponseKeepAlive = TRUE;
  1314.       bSuccess = TRUE;
  1315.     }
  1317.     if (!bSuccess)
  1318.       ReportHttpExtensionProcError(pClient, extension, dwSuccess);
  1319.   }
  1320.   __except(1)
  1321.   {
  1322.     bSuccess = FALSE;
  1323.   }
  1325.   return bSuccess;
  1326. }