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

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

CA认证

开发平台：

Visual C++

HttpClient.cpp：源码内容
  1. /*
  2. Module : HttpClient.cpp
  3. Purpose: Implementation for the CHttpClient class
  4. Created: PJN / 22-04-1999
  5. History: None
  7. Copyright (c) 1999 - 2005 by PJ Naughter.  (Web: www.naughter.com, Email: pjna@naughter.com)
  9. All rights reserved.
  11. Copyright / Usage Details:
  13. You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise) 
  14. when your product is released in binary form. You are allowed to modify the source code in any way you want 
  15. except you cannot modify the copyright details at the top of each module. If you want to distribute source 
  16. code with your application, then you are only allowed to distribute versions released by the author. This is 
  17. to maintain a single distribution point for the source code. 
  19. */
  23. //////////////// Includes ////////////////////////////////////////////
  25. #include "stdafx.h"
  26. #ifndef __AFXPRIV_H__
  27. #pragma message("To avoid this message please put afxpriv.h in your PCH (normally stdafx.h)")
  28. #include <afxpriv.h>
  29. #endif
  30. #include "W3Mfc.h"
  31. #include "HttpResponseHeader.h"
  32. #include "Base64.h"
  33. #include "HttpClient.h"
  34. #include "Win32Handle.h"
  38. //////////////// Macros / Defines ////////////////////////////////////
  40. #ifndef RT_HTML
  41. #define RT_HTML         MAKEINTRESOURCE(23)
  42. #endif
  44. #ifndef SEC_E_OK
  45. #define SEC_E_OK                         ((SECURITY_STATUS)0x0000)
  46. #endif
  48. #ifndef SEC_I_CONTINUE_NEEDED
  49. #define SEC_I_CONTINUE_NEEDED            ((SECURITY_STATUS)0x1012)
  50. #endif
  52. #ifndef INVALID_FILE_ATTRIBUTES
  53. #define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
  54. #endif
  56. #ifndef HSE_REQ_CLOSE_CONNECTION
  57. #define HSE_REQ_CLOSE_CONNECTION                 (HSE_REQ_END_RESERVED+17)
  58. #endif
  60. #ifdef _DEBUG
  61. #define new DEBUG_NEW
  62. #undef THIS_FILE
  63. static char THIS_FILE[] = __FILE__;
  64. #endif
  67. //The local variable which handle the function pointers
  69. _W3MFC_DATA _W3MFCData;
  73. //////////////// Implementation //////////////////////////////////////
  75. _W3MFC_DATA::_W3MFC_DATA()
  76. {
  77.   //Initialize the function pointers to sane defaults
  78.   m_lpfnTransmitFile = NULL;
  79.   m_lpfnTransmitPackets = NULL;
  81.   //Only use the TransmitFile and TransmitPacket API's if we are running on 2000/XP/.NET Server
  82.   OSVERSIONINFO osvi;
  83.   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  84.   BOOL bNT = (GetVersionEx(&osvi) && osvi.dwPlatformId == VER_PLATFORM_WIN32_NT);
  85.   if (bNT && (osvi.dwMajorVersion > 4))
  86.   {
  87.     m_hMSWsock = LoadLibrary(_T("MSWSOCK.DLL"));
  88.     if (m_hMSWsock)
  89.     {
  90.       m_lpfnTransmitFile = (LPTRANSMITFILE) GetProcAddress(m_hMSWsock, "TransmitFile");
  91.       m_lpfnTransmitPackets = (LPTRANSMITPACKETS) GetProcAddress(m_hMSWsock, "TransmitPackets");
  92.     }
  93.   }
  94. }
  96. _W3MFC_DATA::~_W3MFC_DATA()
  97. {
  98.   if (m_hMSWsock)
  99.   {
  100.     FreeLibrary(m_hMSWsock);
  101.     m_hMSWsock = NULL;
  102.   }
  103. }
  105. #ifndef W3MFC_NO_ISAPI_SUPPORT
  106. BOOL _W3MFC_DATA::TransmitFile(CHttpSocket& socket, CHttpResponseHeader& responseHdr, HSE_TF_INFO* pInfo)
  107. {
  108.   //Assume the worst
  109.   BOOL bSuccess = FALSE;
  111.   if (pInfo->pfnHseIO)
  112.   {
  113.     SetLastError(ERROR_INVALID_PARAMETER); //we do not support ascynchronous notifications
  114.     return FALSE;
  115.   }
  116.   if (pInfo->Offset)
  117.   {
  118.     SetLastError(ERROR_INVALID_PARAMETER); //we do not support partials sens thro TransmitFile because that requires overlapped IO
  119.     return FALSE;
  120.   }
  122.   if (pInfo->dwFlags & HSE_IO_SEND_HEADERS)
  123.   {
  124.     if (m_lpfnTransmitPackets && m_lpfnTransmitFile)
  125.     {
  126.       TRANSMIT_PACKETS_ELEMENT tpe[2];
  127.       tpe[0].pBuffer = (void*) pInfo->pszStatusCode;
  128.       tpe[0].dwElFlags = TP_ELEMENT_MEMORY;
  129.       tpe[0].cLength = strlen(pInfo->pszStatusCode);
  131.       tpe[1].pBuffer = responseHdr.GetData(tpe[1].cLength);
  132.       tpe[1].dwElFlags = TP_ELEMENT_MEMORY;
  134.       //Call the TransmitPackets function
  135.       bSuccess = m_lpfnTransmitPackets(socket, tpe, 2, 0, NULL, TF_USE_KERNEL_APC);
  137.       //And the TransmitFile function
  138.       if (bSuccess)
  139.         bSuccess = m_lpfnTransmitFile(socket, pInfo->hFile, pInfo->BytesToWrite, 0, NULL, NULL, TF_USE_KERNEL_APC);
  140.     }
  141.     else
  142.       SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  143.   }
  144.   else
  145.   {
  146.     if (m_lpfnTransmitFile)
  147.     {
  148.       TRANSMIT_FILE_BUFFERS tfb;
  149.       tfb.Head = pInfo->pHead;
  150.       tfb.HeadLength = pInfo->HeadLength;
  151.       tfb.Tail = pInfo->pTail;
  152.       tfb.TailLength = pInfo->TailLength;
  154.       //Call the TransmitFile function
  155.       bSuccess = m_lpfnTransmitFile(socket, pInfo->hFile, pInfo->BytesToWrite, 0, NULL, &tfb, TF_USE_KERNEL_APC);
  156.     }
  157.     else
  158.       SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  159.   }
  161.   return bSuccess;
  162. }
  163. #endif
  165. BOOL _W3MFC_DATA::TransmitFile(CHttpSocket& socket, CHttpResponseHeader& responseHdr, HANDLE hFile, DWORD dwSize)
  166. {
  167.   ASSERT(m_lpfnTransmitFile);
  169.   //Setup the TFB ready for the call to the "TransmitFile" function
  170.   TRANSMIT_FILE_BUFFERS tfb;
  171.   tfb.Head = responseHdr.GetData(tfb.HeadLength);
  172.   tfb.Tail = NULL;
  173.   tfb.TailLength = 0;
  175.   //Call the TransmitFile function
  176.   BOOL bSuccess = m_lpfnTransmitFile(socket, hFile, dwSize, 0, NULL, &tfb, TF_USE_KERNEL_APC);
  178.   //Tidy up the heap memory we have used
  179.   delete [] tfb.Head;
  181.   return bSuccess;
  182. }
  184. BOOL _W3MFC_DATA::TransmitBuffer(CHttpSocket& socket, CHttpResponseHeader& responseHdr, BYTE* byData, DWORD dwSize)
  185. {
  186.   ASSERT(m_lpfnTransmitPackets);
  188.   //Setup the TFB ready for the call to the "TransmitPackets" function
  189.   TRANSMIT_PACKETS_ELEMENT tpe[2];
  190.   tpe[0].pBuffer = responseHdr.GetData(tpe[0].cLength);
  191.   tpe[0].dwElFlags = TP_ELEMENT_MEMORY;
  192.   tpe[1].pBuffer = byData;
  193.   tpe[1].cLength = dwSize;
  194.   tpe[0].dwElFlags = TP_ELEMENT_MEMORY;
  196.   //Call the TransmitPackets function
  197.   return m_lpfnTransmitPackets(socket, tpe, 2, 0, NULL, TF_USE_KERNEL_APC);
  198. }
  202. IMPLEMENT_DYNCREATE(CHttpClient, CThreadPoolClient)
  204. CHttpClient::CHttpClient()
  205. {
  206.   m_pServer = NULL;
  207. #ifdef W3MFC_SSL_SUPPORT
  208.   m_pSSLContext = NULL;
  209. #endif
  210. #ifndef W3MFC_NO_ISAPI_SUPPORT
  211.   m_dwDataSentViaWriteClient = 0;
  212.   m_nHttpStatusCodeSent = 0;
  213. #endif
  214. }
  216. CHttpClient::~CHttpClient()
  217. {
  218. }
  220. BOOL CHttpClient::AllowThisConnection()
  221. {
  222.   return TRUE;
  223. }
  225. #ifdef W3MFC_SSL_SUPPORT
  226. BOOL CHttpClient::InitializeSSLConnection()
  227. {
  228.   SSL* pSSL = SSL_new(m_pSSLContext->operator SSL_CTX*());
  229.   if (pSSL == NULL)
  230.   {
  231.     //Report the error
  232.     CString sError;
  233.     sError.Format(_T("CHttpClient::InitializeSSLConnection, Failed to create create SSL connection object"));
  234.     ASSERT(m_pServer);
  235.     m_pServer->OnError(sError);
  237.     m_pServer->LogSSLErrors();
  239.     return FALSE;
  240.   }
  241.   else
  242.     m_SSL.Attach(pSSL);
  244.   //Associate the raw socket with the SSL connection object
  245.   if (SSL_set_fd(m_SSL, m_Socket) != 1)
  246.   {
  247.     //Report the error
  248.     CString sError;
  249.     sError.Format(_T("CHttpClient::InitializeSSLConnection, Failed to create create SSL connection object"));
  250.     ASSERT(m_pServer);
  251.     m_pServer->OnError(sError);
  253.     m_pServer->LogSSLErrors();
  255.     return FALSE;
  256.   }
  258.   return TRUE;
  259. }
  261. BOOL CHttpClient::DoSSLNegotiation()
  262. {
  263.   ASSERT(m_pServer);
  264.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  265.   ASSERT(pSettings);
  267.   BOOL bNegotiationComplete = FALSE;
  268.   while (!bNegotiationComplete)
  269.   {
  270.     int nSSLAccept = SSL_accept(m_SSL);
  271.     if (nSSLAccept != 1)
  272.     {
  273.       BOOL bRetry = FALSE;
  274.       int nSSL_get_error = SSL_get_error(m_SSL, nSSLAccept);
  275.       if (nSSL_get_error == SSL_ERROR_WANT_READ)
  276.       {
  277.         if (m_Socket.IsReadible(pSettings->m_dwSSLNegotiationTimeout))
  278.           bRetry = TRUE;
  279.       }
  281.       if (!bRetry)
  282.       {
  283.         //Report the error
  284.         CString sError;
  285.         sError.Format(_T("CHttpClient::DoSSLNegotiation, Failed to perform SSL handshake, SSL_accept:%d SSL_get_error:%d"), nSSLAccept, nSSL_get_error);
  286.         m_pServer->OnError(sError);
  288.         m_pServer->LogSSLErrors();
  290.         return FALSE;
  291.       }
  292.     }
  293.     else
  294.       bNegotiationComplete = TRUE;
  295.   }
  297.   return TRUE;
  298. }
  299. #endif
  301. BOOL CHttpClient::Run(const CThreadPoolRequest& request)
  302. {
  303.   //Validate our parameters
  304.   ASSERT(request.m_pData);
  305.   CHttpThreadPoolRequest* pHttpRequest = (CHttpThreadPoolRequest*) request.m_pData;
  307.   //Hive away the parameters in member variables
  308.   SOCKET clientSocket = pHttpRequest->m_ClientSocket.Detach();
  309.   m_Socket.Attach(clientSocket);
  310.   CopyMemory(&m_Request.m_ClientAddress, &pHttpRequest->m_ClientAddress, sizeof(sockaddr_in));
  311. #ifdef W3MFC_SSL_SUPPORT
  312.   m_pSSLContext = pHttpRequest->m_pSSLContext;
  313. #endif
  315.   //Call the helper function which does all of the work
  316.   HandleClient();
  318. #ifdef W3MFC_SSL_SUPPORT
  319.   //Close the SSL connection
  320.   m_SSL.Close();
  321. #endif
  323.   //Close down the connection
  324.   m_Socket.Close();
  326.   //Tidy up our heap memory after ourselves
  327.   delete pHttpRequest;
  329.   //Reset the request data
  330.   m_Request = CHttpRequest();
  332.   return TRUE;
  333. }
  335. int CHttpClient::ExitInstance()
  336. {
  337.   //Tidy up per thread SSL structures if we are using SSL
  338. #ifdef W3MFC_SSL_SUPPORT
  339.   ERR_remove_state(0);
  340. #endif
  342.   return CThreadPoolClient::ExitInstance();
  343. }
  345. void CHttpClient::HandleClient()
  346. {
  347. //Validate our parameters
  348. ASSERT(m_pServer);
  349. CHttpServerSettings* pSettings = m_pServer->GetSettings();
  350. ASSERT(pSettings);
  352. //Do the reverse DNS lookup if configured to do so
  353. m_Request.m_sRemoteHost.Empty();
  354. if (pSettings->m_bDNSLookup)
  355. {
  356. HOSTENT* pHostEnt = gethostbyaddr((const char*) &m_Request.m_ClientAddress.sin_addr, sizeof(IN_ADDR), AF_INET);
  357. if (pHostEnt)
  358. m_Request.m_sRemoteHost = pHostEnt->h_name;
  359. }
  361. //Should we allow this client to connect
  362. if (!AllowThisConnection())
  363. {
  364. ReturnErrorMessage(400); //Bad Request
  365. return;    
  366. }
  368. //Create the SSL connection if required
  369. #ifdef W3MFC_SSL_SUPPORT
  370. if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  371. {
  372. if (!InitializeSSLConnection())
  373. return;
  375. //Do the SSL negotiation
  376. if (!DoSSLNegotiation())
  377. return;
  378. }
  379. #endif
  381. //Use a Win32 event notification on the socket
  382. CEvent dataEvent;
  383. int nError = WSAEventSelect(m_Socket, dataEvent, FD_READ | FD_CLOSE);
  384. if (nError == SOCKET_ERROR)
  385. {
  386. DWORD dwError = ::GetLastError();
  388. //Report the error
  389. CString sError;
  390. sError.Format(_T("CHttpClient::HandleClient, Failed in call to WSAEventSelect, GetLastError:%d"), dwError);
  391. m_pServer->OnError(sError);
  393. return;
  394. }
  396. //Also create a waitable timer if we can
  397. CWaitableTimer dataTimer;
  398. if (dataTimer.Create(TRUE))
  399. dataTimer.SetOnceOffRelative(pSettings->m_dwIdleClientTimeout);
  401. BOOL bMoreRequests = FALSE;
  402. #ifndef W3MFC_NO_SSPI_SUPPORT
  403. BOOL bImpersonatedUsingSSPI = FALSE;
  404. #endif
  405. do
  406. {
  407. m_bResponseKeepAlive = FALSE;
  409. #ifdef W3MFC_SSL_SUPPORT
  410. //Read the client request
  411. BOOL bReadResponse = FALSE;
  412. if (dataTimer)
  413. bReadResponse = m_Socket.ReadResponse(m_Request, pSettings->m_dwIdleClientTimeout, 4096, m_SSL, *this, dataTimer, m_StopEvent, dataEvent);
  414. else
  415. bReadResponse = m_Socket.ReadResponse(m_Request, pSettings->m_dwIdleClientTimeout, 4096, m_SSL, *this);
  416. #else
  417. BOOL bReadResponse = FALSE;
  418. if (dataTimer)
  419. bReadResponse = m_Socket.ReadResponse(m_Request, pSettings->m_dwIdleClientTimeout, 4096, *this, dataTimer, m_StopEvent, dataEvent);
  420. else
  421. bReadResponse = m_Socket.ReadResponse(m_Request, pSettings->m_dwIdleClientTimeout, 4096, *this);
  422. #endif
  423. if (bReadResponse)
  424. {
  425. //Parse the client request
  426. if (ParseRequest())
  427. {
  428. m_bResponseKeepAlive = pSettings->m_bKeepAlives && m_Request.m_bKeepAlive;
  430. //Impersonate the client credentials if authorization type is PLAINTEXT
  431. CW32Handle hImpersonation;
  432. BOOL bLoggedOn = FALSE;
  433. if (m_Request.m_AuthorizationType == CHttpRequest::HTTP_AUTHORIZATION_PLAINTEXT && pSettings->m_bPerformPassthroughAuthentication)
  434. {
  435. LPTSTR pszUser = m_Request.m_sUsername.GetBuffer(m_Request.m_sUsername.GetLength());
  436. LPTSTR pszPassword = m_Request.m_sPassword.GetBuffer(m_Request.m_sPassword.GetLength());
  437. bLoggedOn = LogonUser(pszUser, NULL, pszPassword, LOGON32_LOGON_NETWORK, LOGON32_PROVIDER_DEFAULT, &hImpersonation);
  438. if (bLoggedOn)
  439. {
  440. ImpersonateLoggedOnUser(hImpersonation);
  441. m_Request.m_bLoggedOn = TRUE;
  442. }
  443. else
  444. {
  445. //Report the error
  446. CString sError;
  447. sError.Format(_T("CHttpClient::HandleClient, Failed to logon using user name: %s, GetLastError:%d"), pszUser, ::GetLastError());
  448. m_pServer->OnError(sError);
  449. }
  450. m_Request.m_sUsername.ReleaseBuffer();
  451. m_Request.m_sPassword.ReleaseBuffer();
  452. } 
  453. #ifndef W3MFC_NO_SSPI_SUPPORT
  454. else if (m_Request.m_AuthorizationType == CHttpRequest::HTTP_AUTHORIZATION_NTLM && !bImpersonatedUsingSSPI)
  455. {
  456. bImpersonatedUsingSSPI = TRUE;
  457. SECURITY_STATUS ss = ImpersonateSecurityContext(&m_Request.m_ContentHandle);
  458. bLoggedOn = (ss == SEC_E_OK);
  459. if (bLoggedOn)
  460. {
  461. //Pull out some values from the SSPI context handle and stuff them in the request object
  462. SecPkgContext_Names names;
  463. if (QueryContextAttributes(&m_Request.m_ContentHandle, SECPKG_ATTR_NAMES, &names) == SEC_E_OK)
  464. {
  465. m_Request.m_sUsername = names.sUserName;
  466. FreeContextBuffer(names.sUserName);
  467. }
  469. SecPkgContext_Authority authority;
  470. if (QueryContextAttributes(&m_Request.m_ContentHandle, SECPKG_ATTR_AUTHORITY, &authority) == SEC_E_OK)
  471. {
  472. m_Request.m_sAuthorityName = authority.sAuthorityName;
  473. FreeContextBuffer(authority.sAuthorityName);
  474. }
  475. }
  476. else
  477. {
  478. //Report the error
  479. CString sError;
  480. sError.Format(_T("CHttpClient::HandleClient, Failed to impersonate client credentials using SSPI: %s, Error:%d"), ss);
  481. m_pServer->OnError(sError);
  482. }
  483. }
  484. #endif
  486. m_Request.m_hImpersonation = hImpersonation;
  488. if (m_Request.m_AuthorizationType == CHttpRequest::HTTP_AUTHORIZATION_ANONYMOUS && !pSettings->m_bAllowAnonymous)
  489. {
  490. //Return an unauthorized message if some form of authentication is enabled
  491. if (pSettings->m_bAllowBasicAuthentication || pSettings->m_bAllowNTLMAuthentication)
  492. ReturnUnauthorizedMessage(m_Request.m_sURL);
  493. else
  494. {
  495. //Report the error
  496. m_pServer->OnError(_T("CHttpClient::HandleClient, Anonymous access is disabled in addition to all authentication mechanisms, All requests will Fail!!"));
  498. ReturnErrorMessage(500); //Internal server error
  499. }
  500. }
  501. else
  502. {
  503. if (m_Request.m_Verb == CHttpRequest::HTTP_VERB_GET || m_Request.m_Verb == CHttpRequest::HTTP_VERB_HEAD || m_Request.m_Verb == CHttpRequest::HTTP_VERB_POST)
  504. {
  505. if (!PreHandleGetPostHead()) //Allow derived classes to handle GET, HEAD or POST
  506. {
  507. BOOL bDirectory = FALSE;
  508. CHttpDirectory* pDirectory = NULL;
  509. DWORD dwMatchingURL = 0;
  510. DWORD dwMatchingPath = 0;
  511. if (MapURLToLocalFilename(m_Request.m_sURL, m_Request.m_sLocalFile, m_Request.m_sPathInfo, bDirectory, pDirectory, dwMatchingURL, dwMatchingPath))
  512. {
  513. ASSERT(pDirectory);
  514. pDirectory->HandleDirectory(this, bDirectory);
  515. }
  516. else
  517. ReturnErrorMessage(404); //Not Found
  518. }
  519. }
  520. else if (pSettings->m_bAllowDeleteRequest && m_Request.m_Verb == CHttpRequest::HTTP_VERB_DELETE)
  521. {
  522. //By default, only allow deletion of a file if we are using authorization
  523. if (m_Request.m_AuthorizationType != CHttpRequest::HTTP_AUTHORIZATION_ANONYMOUS)
  524. {
  525. CString sLocalFile;
  526. BOOL bDirectory = FALSE;
  527. CHttpDirectory* pDirectory = NULL;
  528. DWORD dwMatchingURL = 0;
  529. DWORD dwMatchingPath = 0;
  530. if (MapURLToLocalFilename(m_Request.m_sURL, m_Request.m_sLocalFile, m_Request.m_sPathInfo, bDirectory, pDirectory, dwMatchingURL, dwMatchingPath) && !bDirectory && pDirectory->GetWritable())
  531. {
  532. if (DeleteFile(m_Request.m_sLocalFile))
  533. ReturnFileDeletedOkMessage(m_Request.m_sLocalFile);
  534. else
  535. {
  536. if (::GetLastError() == ERROR_ACCESS_DENIED && !bDirectory)
  537. ReturnUnauthorizedMessage(m_Request.m_sURL);
  538. else 
  539. ReturnErrorMessage(500); //Internal server error
  540. }
  541. }
  542. else
  543. ReturnErrorMessage(404); //Not Found
  544. }
  545. else if (pSettings->m_bAllowBasicAuthentication || pSettings->m_bAllowNTLMAuthentication)
  546. ReturnUnauthorizedMessage(m_Request.m_sURL); //Not authorized
  547. else
  548. ReturnErrorMessage(404); //Not Found
  549. }
  550. else
  551. ReturnErrorMessage(501); //Not implemented
  552. }
  554. //Restore our usual security priviledges
  555. if (m_Request.m_AuthorizationType == CHttpRequest::HTTP_AUTHORIZATION_PLAINTEXT)
  556. {
  557. //Revert to the usual security settings
  558. RevertToSelf();
  559. }
  560.       }
  561.       else
  562.   ReturnErrorMessage(400); //Bad Request
  563.     }
  565.     //Should we service another request
  566.     bMoreRequests = m_bResponseKeepAlive;
  568.     //Remember some values from the old request
  569.     BOOL bAuthenticationCompleted = m_Request.m_bAuthenticationComplete;
  570.     CHttpRequest::HttpAuthorization Authorization = m_Request.m_AuthorizationType;
  571.     CString sRemoteHost = m_Request.m_sRemoteHost;
  572.     CString sUsername = m_Request.m_sUsername;
  573.     CString sAuthorityName = m_Request.m_sAuthorityName;
  574.     sockaddr_in clientAddress;
  575.     CopyMemory(&clientAddress, &m_Request.m_ClientAddress, sizeof(sockaddr_in));
  577.     //Reset the request data before we (potentially) loop around or exit
  578.     m_Request = CHttpRequest();
  580.     //Reinstate the Authentication completed flag. This prevents the need for reauthentications if the connection is keep alive
  581.     m_Request.m_bAuthenticationComplete = bAuthenticationCompleted;
  583.     //Reinstate the Authentication type and the Authority type and username (if it requires keep alives, which is only NTLM currently)
  584.     if (Authorization == CHttpRequest::HTTP_AUTHORIZATION_NTLM)
  585.     {
  586. m_Request.m_AuthorizationType = Authorization;
  587. m_Request.m_sUsername = sUsername;
  588. m_Request.m_sAuthorityName = sAuthorityName;
  589.     }
  591.     //Reinstate the client connection details
  592.     CopyMemory(&m_Request.m_ClientAddress, &clientAddress, sizeof(sockaddr_in));
  593.     m_Request.m_sRemoteHost = sRemoteHost;
  594.   }
  595.   while (bMoreRequests);
  596.   
  597.   //Undo the SSPI impersonation
  598. #ifndef W3MFC_NO_SSPI_SUPPORT
  599.   if (bImpersonatedUsingSSPI)
  600.   RevertSecurityContext(&m_Request.m_ContentHandle);
  601.   
  602.   //Free up the context handle
  603.   DeleteSecurityContext(&m_Request.m_ContentHandle);
  604. #endif
  605. }
  607. BOOL CHttpClient::ParseSimpleRequestLine(const CString& sLine)
  608. {
  609.   ASSERT(m_pServer);
  610.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  611.   ASSERT(pSettings);
  613.   //Make a local copy of the string for parsing purposes
  614.   TCHAR* pszLine = new TCHAR[sLine.GetLength() + 1];
  615.   _tcscpy(pszLine, sLine);
  617.   //Assume the worst
  618.   BOOL bSuccess = FALSE;
  620.   //First parse out the VERB
  621.   TCHAR seps[] = _T(" ");
  622.   TCHAR* pszVerb = _tcstok(pszLine, seps);
  623.   if (pszVerb)
  624.   {
  625.     m_Request.m_sVerb = pszVerb;
  626.     if (_tcsicmp(pszVerb, _T("GET")) == 0)
  627.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_GET;
  628.     else if (_tcsicmp(pszVerb, _T("POST")) == 0)
  629.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_POST;
  630.     else if (_tcsicmp(pszVerb, _T("HEAD")) == 0)
  631.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_HEAD;
  632.     else if (_tcsicmp(pszVerb, _T("PUT")) == 0)
  633.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_PUT;
  634.     else if (_tcsicmp(pszVerb, _T("LINK")) == 0)
  635.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_LINK;
  636.     else if (_tcsicmp(pszVerb, _T("DELETE")) == 0)
  637.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_DELETE;
  638.     else if (_tcsicmp(pszVerb, _T("UNLINK")) == 0)
  639.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_UNLINK;
  640.     else
  641.       m_Request.m_Verb = CHttpRequest::HTTP_VERB_UNKNOWN;
  643.     //Parse out the URL
  644.     TCHAR* pszURL = _tcstok(NULL, seps);
  645.     if (pszURL)
  646.     {
  647.       m_Request.m_sRawURL = pszURL;
  648.       m_Request.m_sURL = UTF8ToCString(URLDecode(pszURL)); //Convert any embedded escape sequences to their unencoded format 
  649.                                                            //as well as handling UTF8 input data
  651.       //Handle the Search path i.e everything after the ?
  652.       int nQuestion = m_Request.m_sURL.Find(_T('?'));
  653.       if (nQuestion != -1)
  654.       {
  655.         m_Request.m_sExtra = m_Request.m_sURL.Right(m_Request.m_sURL.GetLength() - nQuestion - 1);
  656.         m_Request.m_sURL = m_Request.m_sURL.Left(nQuestion);
  657.       }
  658.       nQuestion = m_Request.m_sRawURL.Find(_T('?'));
  659.       if (nQuestion != -1)
  660.         m_Request.m_sRawExtra = m_Request.m_sRawURL.Right(m_Request.m_sRawURL.GetLength() - nQuestion - 1);
  662.       //Parse out the HTTP version
  663.       TCHAR* pszVersion = _tcstok(NULL, seps);
  664.       if (pszVersion)
  665.       {
  666.         if (_tcsstr(pszVersion, _T("HTTP/")) == pszVersion)
  667.         {
  668.           TCHAR sepsVer[] = _T(".");
  669.           TCHAR* pszMajorVersion = _tcstok(pszVersion+5, sepsVer);
  670.           if (pszMajorVersion)
  671.           {
  672.             WORD wMajorVersion = (WORD) _ttoi(pszMajorVersion);
  673.             TCHAR* pszMinorVersion = _tcstok(NULL, sepsVer);
  674.             if (pszMinorVersion)
  675.             {
  676.               WORD wMinorVersion = (WORD) _ttoi(pszMinorVersion);
  677.               m_Request.m_dwHttpVersion = MAKELONG(wMinorVersion, wMajorVersion);
  678.               bSuccess = TRUE;
  679.             }
  680.           }
  681.         }
  682.       }
  683.       else
  684.       {
  685.         //No version included in the request, so set it to HTTP v0.9
  686.         m_Request.m_dwHttpVersion = MAKELONG(9, 0);
  687.         bSuccess = m_Request.m_Verb == CHttpRequest::HTTP_VERB_GET; //"GET" is only allowed with HTTP v0.9
  688.       }  
  689.     }
  690.   }
  692.   //Tidy up the heap memory we have used before we return
  693.   delete [] pszLine;
  695.   return bSuccess;
  696. }
  698. BOOL CHttpClient::ParseWeekDay(char* pszToken, int& nWeekDay)
  699. {
  700.   BOOL bSuccess = TRUE;
  701.   if (strcmpi(pszToken, "Sun") == 0 || strcmpi(pszToken, "Sunday") == 0)
  702.     nWeekDay = 0;
  703.   else if (strcmpi(pszToken, "Mon") == 0 || strcmpi(pszToken, "Monday") == 0)
  704.     nWeekDay = 1;
  705.   else if (strcmpi(pszToken, "Tue") == 0 || strcmpi(pszToken, "Tuesday") == 0)
  706.     nWeekDay = 2;
  707.   else if (strcmpi(pszToken, "Wed") == 0 || strcmpi(pszToken, "Wednesday") == 0)
  708.     nWeekDay = 3;
  709.   else if (strcmpi(pszToken, "Thu") == 0 || strcmpi(pszToken, "Thursday") == 0)
  710.     nWeekDay = 4;
  711.   else if (strcmpi(pszToken, "Fri") == 0 || strcmpi(pszToken, "Friday") == 0)
  712.     nWeekDay = 5;
  713.   else if (strcmpi(pszToken, "Sat") == 0 || strcmpi(pszToken, "Saturday") == 0)
  714.     nWeekDay = 6;
  715.   else
  716.     bSuccess = FALSE;
  717.   return bSuccess;
  718. }
  720. BOOL CHttpClient::ParseMonth(char* pszToken, int& nMonth)
  721. {
  722.   BOOL bSuccess = TRUE;
  723.   if (strcmpi(pszToken, "Jan") == 0)
  724.     nMonth = 1;
  725.   else if (strcmpi(pszToken, "Feb") == 0)
  726.     nMonth = 2;
  727.   else if (strcmpi(pszToken, "Mar") == 0)
  728.     nMonth = 3;
  729.   else if (strcmpi(pszToken, "Apr") == 0)
  730.     nMonth = 4;
  731.   else if (strcmpi(pszToken, "May") == 0)
  732.     nMonth = 5;
  733.   else if (strcmpi(pszToken, "Jun") == 0)
  734.     nMonth = 6;
  735.   else if (strcmpi(pszToken, "Jul") == 0)
  736.     nMonth = 7;
  737.   else if (strcmpi(pszToken, "Aug") == 0)
  738.     nMonth = 8;
  739.   else if (strcmpi(pszToken, "Sep") == 0)
  740.     nMonth = 9;
  741.   else if (strcmpi(pszToken, "Oct") == 0)
  742.     nMonth = 10;
  743.   else if (strcmpi(pszToken, "Nov") == 0)
  744.     nMonth = 11;
  745.   else if (strcmpi(pszToken, "Dec") == 0)
  746.     nMonth = 12;
  747.   else
  748.     bSuccess = FALSE;
  749.   return bSuccess;
  750. }
  752. BOOL CHttpClient::ParseDate(const CString& sField, SYSTEMTIME& time)
  753. {
  754.   //This method understands RFC 1123, RFC 850 and asctime formats
  756. //For correct operation of the T2A macro, see MFC Tech Note 59
  757.   USES_CONVERSION;
  759.   BOOL bSuccess = FALSE;
  761.   //Make a local copy of the field we are going to parse
  762.   char* pszField = T2A((LPTSTR) (LPCTSTR) sField);
  764.   //Http times never include a millisecond field, so just set it to zero
  765.   time.wMilliseconds = 0;
  767.   int nLength = strlen(pszField);
  768.   if (nLength > 5)
  769.   {
  770.     if (pszField[3] == ',') //Parsing a RFC 1123 format date
  771.     {
  772.       //First the weekday
  773.       char seps[] = ", :";
  774.       char* pszToken = strtok(pszField, seps);
  775.       if (pszToken == NULL)
  776.         return FALSE;
  777.       int nWeekDay;
  778.       bSuccess = ParseWeekDay(pszToken, nWeekDay);
  779.       if (bSuccess)
  780.         time.wDayOfWeek = (WORD) nWeekDay;
  782.       //Then the day of the month
  783.       pszToken = strtok(NULL, seps);
  784.       if (pszToken == NULL)
  785.         return FALSE;
  786.       time.wDay = (WORD) atoi(pszToken);
  788.       //Then the month
  789.       pszToken = strtok(NULL, seps);
  790.       if (pszToken == NULL)
  791.         return FALSE;
  792.       int nMonth = 0;
  793.       bSuccess = bSuccess && ParseMonth(pszToken, nMonth);
  794.       if (bSuccess)
  795.         time.wMonth = (WORD) nMonth;
  797.       //And the year
  798.       pszToken = strtok(NULL, seps);
  799.       if (pszToken == NULL)
  800.         return FALSE;
  801.       time.wYear = (WORD) atoi(pszToken);
  803.       //And the hour
  804.       pszToken = strtok(NULL, seps);
  805.       if (pszToken == NULL)
  806.         return FALSE;
  807.       time.wHour = (WORD) atoi(pszToken);
  809.       //And the minute
  810.       pszToken = strtok(NULL, seps);
  811.       if (pszToken == NULL)
  812.         return FALSE;
  813.       time.wMinute = (WORD) atoi(pszToken);
  815.       //And the second
  816.       pszToken = strtok(NULL, seps);
  817.       if (pszToken == NULL)
  818.         return FALSE;
  819.       time.wSecond = (WORD) atoi(pszToken);
  820.     }
  821.     else if (pszField[3] == ' ') //Parsing an asctime format date
  822.     {
  823.       //First the weekday
  824.       char seps[] = ", :";
  825.       char* pszToken = strtok(pszField, seps);
  826.       if (pszToken == NULL)
  827.         return FALSE;
  828.       int nWeekDay;
  829.       bSuccess = ParseWeekDay(pszToken, nWeekDay);
  830.       if (bSuccess)
  831.         time.wDayOfWeek = (WORD) nWeekDay;
  833.       //Then the month
  834.       pszToken = strtok(NULL, seps);
  835.       if (pszToken == NULL)
  836.         return FALSE;
  837.       int nMonth = 0;
  838.       bSuccess = bSuccess && ParseMonth(pszToken, nMonth);
  839.       if (bSuccess)
  840.         time.wMonth = (WORD) nMonth;
  842.       //Then the day of the month
  843.       pszToken = strtok(NULL, seps);
  844.       if (pszToken == NULL)
  845.         return FALSE;
  846.       time.wDay = (WORD) atoi(pszToken);
  848.       //And the hour
  849.       pszToken = strtok(NULL, seps);
  850.       if (pszToken == NULL)
  851.         return FALSE;
  852.       time.wHour = (WORD) atoi(pszToken);
  854.       //And the minute
  855.       pszToken = strtok(NULL, seps);
  856.       if (pszToken == NULL)
  857.         return FALSE;
  858.       time.wMinute = (WORD) atoi(pszToken);
  860.       //And the second
  861.       pszToken = strtok(NULL, seps);
  862.       if (pszToken == NULL)
  863.         return FALSE;
  864.       time.wSecond = (WORD) atoi(pszToken);
  866.       //And the year
  867.       pszToken = strtok(NULL, seps);
  868.       if (pszToken == NULL)
  869.         return FALSE;
  870.       time.wYear = (WORD) atoi(pszToken);
  871.     }
  872.     else //Must be a RFC 850 format date
  873.     {
  874.       //First the weekday
  875.       char seps[] = ", :-";
  876.       char* pszToken = strtok(pszField, seps);
  877.       if (pszToken == NULL)
  878.         return FALSE;
  879.       int nWeekDay;
  880.       bSuccess = ParseWeekDay(pszToken, nWeekDay);
  881.       if (bSuccess)
  882.         time.wDayOfWeek = (WORD) nWeekDay;
  884.       //Then the day of the month
  885.       pszToken = strtok(NULL, seps);
  886.       if (pszToken == NULL)
  887.         return FALSE;
  888.       time.wDay = (WORD) atoi(pszToken);
  890.       //Then the month
  891.       pszToken = strtok(NULL, seps);
  892.       if (pszToken == NULL)
  893.         return FALSE;
  894.       int nMonth = 0;
  895.       bSuccess = bSuccess && ParseMonth(pszToken, nMonth);
  896.       if (bSuccess)
  897.         time.wMonth = (WORD) nMonth;
  899.       //And the year (2 Digits only, so make some intelligent assumptions)
  900.       pszToken = strtok(NULL, seps);
  901.       if (pszToken == NULL)
  902.         return FALSE;
  903.       time.wYear = (WORD) atoi(pszToken);
  904.       if (time.wYear < 50)
  905.         time.wYear += 2000;
  906.       else if (time.wYear < 100)
  907.         time.wYear += 1900; 
  909.       //And the hour
  910.       pszToken = strtok(NULL, seps);
  911.       if (pszToken == NULL)
  912.         return FALSE;
  913.       time.wHour = (WORD) atoi(pszToken);
  915.       //And the minute
  916.       pszToken = strtok(NULL, seps);
  917.       if (pszToken == NULL)
  918.         return FALSE;
  919.       time.wMinute = (WORD) atoi(pszToken);
  921.       //And the second
  922.       pszToken = strtok(NULL, seps);
  923.       if (pszToken == NULL)
  924.         return FALSE;
  925.       time.wSecond = (WORD) atoi(pszToken);
  926.     }
  927.   }
  929.   return bSuccess;
  930. }
  932. BOOL CHttpClient::ParseAuthorizationLine(const CString& sField)
  933. {
  934.   //Validate our parameters
  935.   ASSERT(m_pServer);
  936.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  937.   ASSERT(pSettings);
  939.   //By default assume the best
  940.   BOOL bSuccess = TRUE;
  942. //For correct operation of the T2A macro, see MFC Tech Note 59
  943.   USES_CONVERSION;
  945.   //Make a local copy of the field we are going to parse
  946.   char* pszField = T2A((LPTSTR) (LPCTSTR) sField);
  948.   char seps[] = " ";
  949.   char* pszToken = strtok(pszField, seps);
  950.   if (pszToken)
  951.   {
  952.     //Parse out the base64 encoded username and password if we are doing Basic authentication
  953.     if ((strcmpi(pszToken, "Basic") == 0) && pSettings->m_bAllowBasicAuthentication)
  954.     {
  955.       //Move to the base64 encoded data after the text "Basic"
  956.       pszToken = strtok(NULL, seps);
  957.       if (pszToken)
  958.       {
  959.         //Decode the base64 string passed to us
  960.         CBase64 base64;
  961.         int nEncodedLength = strlen(pszToken);
  962.         int nDecodedLength = base64.DecodeGetRequiredLength(nEncodedLength);
  963.         BYTE* pszOutput = new BYTE[nDecodedLength + 1];
  964.         int nOutputLength = 0;
  965.         if (base64.Decode(pszToken, nEncodedLength, pszOutput, &nOutputLength))
  966.         {
  967.           //NULL terminate the decoded data
  968.           pszOutput[nOutputLength] = '';
  970.           CString sOutput(pszOutput);
  971.           int nColon = sOutput.Find(_T(":"));
  972.           if (nColon != -1)
  973.           {
  974.             m_Request.m_AuthorizationType = CHttpRequest::HTTP_AUTHORIZATION_PLAINTEXT;
  975.             m_Request.m_sUsername = sOutput.Left(nColon);
  976.             m_Request.m_sPassword = sOutput.Right(sOutput.GetLength() - nColon - 1);
  977.           }
  978.         }
  979.         else
  980.           bSuccess = FALSE;
  982.         //Tidy up the heap memory we have been using
  983.         delete [] pszOutput;
  984.       }
  985.       else
  986.         bSuccess = FALSE;
  987.     }
  988.   #ifndef W3MFC_NO_SSPI_SUPPORT
  989.     else if ((strcmpi(pszToken, "NTLM") == 0) && pSettings->m_bAllowNTLMAuthentication && !m_Request.m_bAuthenticationComplete)
  990.     {
  991.       //Move to the encoded data after the text "NTLM"
  992.       pszToken = strtok(NULL, seps);
  993.       if (pszToken)
  994.       {
  995.         CBase64 base64;
  996.         int nEncodedLength = strlen(pszToken);
  997.         int nDecodedLength = base64.DecodeGetRequiredLength(nEncodedLength);
  998.         BYTE* pszInput = new BYTE[nDecodedLength + 1];
  999.         int nInputLength = 0;
  1000.         if (base64.Decode(pszToken, nEncodedLength, pszInput, &nInputLength))
  1001.         {
  1002.           //Get SSPI to act on the received data
  1004.           //First setup the buffers
  1005.           SecBuffer secBufferIn[1];
  1006.           secBufferIn[0].BufferType = SECBUFFER_TOKEN;
  1007.           secBufferIn[0].cbBuffer = nInputLength;
  1008.           secBufferIn[0].pvBuffer = pszInput; 
  1010.           SecBufferDesc secbufDescriptorIn;
  1011.           secbufDescriptorIn.ulVersion = SECBUFFER_VERSION;
  1012.           secbufDescriptorIn.cBuffers = 1;
  1013.           secbufDescriptorIn.pBuffers = secBufferIn;
  1015.           SecBuffer secBufferOut[1];
  1016.           secBufferOut[0].BufferType = SECBUFFER_TOKEN;
  1017.           secBufferOut[0].cbBuffer = 0;
  1018.           secBufferOut[0].pvBuffer = NULL;
  1020.           SecBufferDesc secbufDescriptorOut;
  1021.           secbufDescriptorOut.ulVersion = SECBUFFER_VERSION;
  1022.           secbufDescriptorOut.cBuffers = 1;
  1023.           secbufDescriptorOut.pBuffers = secBufferOut;
  1025.           //Call SSPI
  1026.           ULONG nContextAttributes;
  1027.           SECURITY_STATUS ss = AcceptSecurityContext(m_pServer->GetCredentialHandle(), m_Request.m_bFirstAuthenticationRequest ? NULL : &m_Request.m_ContentHandle, 
  1028.                                                      &secbufDescriptorIn, ASC_REQ_STREAM | ASC_REQ_ALLOCATE_MEMORY, SECURITY_NETWORK_DREP, 
  1029.                                                      &m_Request.m_ContentHandle, &secbufDescriptorOut, &nContextAttributes, NULL);
  1031.           //It's no longer the first request
  1032.           m_Request.m_bFirstAuthenticationRequest = FALSE;
  1034.           //Seup the output data (if any)
  1035.           if (secBufferOut[0].cbBuffer)
  1036.           {
  1037.             nEncodedLength = base64.EncodeGetRequiredLength(secBufferOut[0].cbBuffer, BASE64_FLAG_NOCRLF);
  1038.             char* pszOutput = new char[nEncodedLength + 1];
  1040.             //Base 64 encode the data to be sent
  1041.             base64.Encode((const BYTE*) secBufferOut[0].pvBuffer, secBufferOut[0].cbBuffer, pszOutput, &nEncodedLength, BASE64_FLAG_NOCRLF);
  1043.             //Null terminate the data
  1044.             pszOutput[nEncodedLength] = '';
  1046.             //Set the data to return to the client
  1047.             m_Request.m_sAuthenticationResponse = pszOutput;
  1049.             //Tidy up the heap memory we have been using
  1050.             delete [] pszOutput;
  1052.             //Also free the data allocated by SSPI
  1053.             FreeContextBuffer(secBufferOut[0].pvBuffer);
  1054.           }
  1056.           //Do we need more data from the client?
  1057.           m_Request.m_bAuthenticationComplete = (ss != SEC_I_CONTINUE_NEEDED);
  1059.           //Is the authentication handshake completed
  1060.           if (ss == SEC_E_OK)
  1061.             m_Request.m_AuthorizationType = CHttpRequest::HTTP_AUTHORIZATION_NTLM;
  1063.           bSuccess = (ss == SEC_E_OK || ss == SEC_I_CONTINUE_NEEDED);
  1064.         }
  1065.         else
  1066.           bSuccess = FALSE;
  1068.         //Tidy up the heap memory we have been using
  1069.         delete [] pszInput;
  1070.       }
  1071.       else
  1072.         bSuccess = FALSE;      
  1073.     }
  1074.   #endif //W3MFC_NO_SSPI_SUPPORT
  1075.   }
  1077.   return bSuccess;
  1078. }
  1080. BOOL CHttpClient::ParseRequestLine(const CString& sCurrentLine, BOOL bFirstLine, const CString& sField, const CString& sValue)
  1081. {
  1082.   //Assume the worst
  1083.   BOOL bSuccess = FALSE;
  1085.   if (bFirstLine)
  1086.   {
  1087.     //Handle the first line
  1088.     m_Request.m_sRequest = sCurrentLine;
  1089.     bSuccess = ParseSimpleRequestLine(sCurrentLine);
  1090.   }
  1091.   else
  1092.   {
  1093.     bSuccess = TRUE;
  1095.     //Also add the header line to the header map
  1096.     CString sKey(sField);
  1097.     sKey.MakeUpper();
  1098.     m_Request.m_HeaderMap.SetAt(sKey, sValue);
  1100.     //Handle any other request headers  
  1101.     if (sField.CompareNoCase(_T("If-Modified-Since")) == 0)
  1102.     {
  1103.       //Handle the If-Modified-Since header
  1104.       SYSTEMTIME time;
  1105.       if (ParseDate(sValue, time))
  1106.       {
  1107.         m_Request.m_bIfModifiedSincePresent = TRUE; 
  1108.         CopyMemory(&m_Request.m_IfModifiedSince, &time, sizeof(SYSTEMTIME));
  1109.       }
  1110.     }
  1111.     else if (sField.CompareNoCase(_T("Authorization")) == 0)
  1112.     {
  1113.       //Handle the Authorization header
  1114.       bSuccess = ParseAuthorizationLine(sValue);
  1115.     }
  1116.     else if (sField.CompareNoCase(_T("Content-Type")) == 0)
  1117.       m_Request.m_sContentType = sValue;
  1118.     else if (sField.CompareNoCase(_T("Content-Length")) == 0)
  1119.       m_Request.m_nContentLength = _ttoi(sValue);
  1120.     else if ((sField.CompareNoCase(_T("Connection")) == 0) && (sValue.CompareNoCase(_T("Keep-Alive")) == 0))
  1121.       m_Request.m_bKeepAlive = TRUE;
  1122.   }
  1124.   return bSuccess;
  1125. }
  1127. LPSTR CHttpClient::FindNextTerminatorFromRequest(LPSTR pszLine)
  1128. {
  1129.   LPSTR pszCurrentLine = pszLine;
  1130.   while (TRUE)
  1131.   {
  1132.     ++pszCurrentLine;
  1133.     if (pszCurrentLine >= ((LPSTR) m_Request.m_pRawEntity))
  1134.       return pszCurrentLine;
  1135.     else if (*pszCurrentLine == 'n')
  1136.       return pszCurrentLine;
  1137.   }
  1138.   
  1139.   return NULL;
  1140. }
  1142. BOOL CHttpClient::ParseRequest()
  1143. {
  1144.   //By default assume the worst 
  1145.   BOOL bSuccess = FALSE;
  1147.   //Also store a pointer to entity body.
  1148.   LPSTR pszEntityTerminator = strstr((LPSTR) m_Request.m_pRawRequest, "rnrn");
  1149.   if (pszEntityTerminator)
  1150.   {
  1151.     m_Request.m_pRawEntity = (BYTE*) (pszEntityTerminator+4);
  1152.     m_Request.m_dwRawEntitySize = m_Request.m_dwRawRequestSize - (m_Request.m_pRawEntity - m_Request.m_pRawRequest);
  1153.   }
  1154.   else
  1155.   {
  1156.     m_Request.m_pRawEntity = NULL;
  1157.     m_Request.m_dwRawEntitySize = 0;
  1158.   }
  1160.   //Process each line
  1161.   BOOL bFirstLine = TRUE;
  1162.   LPSTR pszLine = (LPSTR) m_Request.m_pRawRequest;
  1163.   LPSTR pszTerminator = strstr(pszLine, "n");
  1164.   BOOL bMoreLines = TRUE;
  1165.   do 
  1166.   {
  1167.     CString sLine;
  1168.     if (pszTerminator)
  1169.     {
  1170.       //Form the current line
  1171.       int nCurSize = pszTerminator - pszLine;
  1172.       char* pszCurrentLine = new char[nCurSize];
  1173.       strncpy(pszCurrentLine, pszLine, nCurSize-1);
  1174.       pszCurrentLine[nCurSize-1] = ''; 
  1176.       //Transfer to the CString variable
  1177.       sLine = pszCurrentLine;
  1179.       //Tidy up the heap memory now that we are finished with it
  1180.       delete [] pszCurrentLine; 
  1182.       //Parse each line using the virtual ParseRequestLine method
  1183.       if (sLine.GetLength())
  1184.       {
  1185.       CString sField;
  1186.         CString sValue;
  1187.         if (!bFirstLine)
  1188.         {
  1189.           m_Socket.SplitRequestLine(sLine, sField, sValue);
  1190.           bSuccess = ParseRequestLine(sLine, FALSE, sField, sValue);
  1191.         }
  1192.         else
  1193.         {
  1194.           bSuccess = ParseRequestLine(sLine, TRUE, sField, sValue);
  1195.           bFirstLine = FALSE;
  1196.         }
  1197.       }
  1199.       //Move onto the next line
  1200.       if (pszTerminator)
  1201.       {
  1202.         pszLine = pszTerminator+1;
  1203.         if (pszLine >= (LPSTR) m_Request.m_pRawEntity)
  1204.           bMoreLines = FALSE;
  1205.         else 
  1206.           pszTerminator = FindNextTerminatorFromRequest(pszLine);
  1207.       }
  1208.     }  
  1209.     else
  1210.       bMoreLines = FALSE;
  1211.   }
  1212.   while (bMoreLines && bSuccess);
  1214.   m_Request.m_hImpersonation = m_pServer->GetImpersonationHandle();
  1216.   return bSuccess;
  1217. }
  1219. DWORD CHttpClient::ReturnErrorMessage(int nStatusCode)
  1220. {
  1221.   //Validate our parameters
  1222.   ASSERT(m_pServer);
  1223.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1224.   ASSERT(pSettings);
  1226.   //Form the body of the response
  1227.   DWORD dwBodyLength = 0;
  1228.   char* pszBody = m_pServer->LoadHTML(nStatusCode, dwBodyLength);
  1230.   if (m_Request.m_dwHttpVersion > MAKELONG(9, 0))
  1231.   {
  1232.     //Form the header of the response
  1233.     CHttpResponseHeader responseHdr;
  1234.     responseHdr.AddStatusCode(nStatusCode);
  1235.     SYSTEMTIME st;
  1236.     GetSystemTime(&st);
  1237.     responseHdr.AddDate(st);
  1238.     responseHdr.AddServer(pSettings->m_sServerName);
  1239.     responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1240.     if (m_bResponseKeepAlive)
  1241.       responseHdr.AddKeepAlive();
  1242.     responseHdr.AddContentLength(dwBodyLength);
  1243.     responseHdr.AddContentType(_T("text/html"));
  1245.     //Send the header and body all in one
  1246.     TransmitBuffer(m_Socket, responseHdr, (BYTE*)pszBody, dwBodyLength, pSettings->m_dwWritableTimeout);
  1247.   }
  1248.   else
  1249.   {
  1250.     //No header sent for HTTP v0.9
  1251.     //so just send the body
  1252.     try
  1253.     {
  1254. #ifdef W3MFC_SSL_SUPPORT
  1255.       m_Socket.SendWithRetry(pszBody, dwBodyLength, pSettings->m_dwWritableTimeout, m_SSL);
  1256. #else    
  1257.       m_Socket.SendWithRetry(pszBody, dwBodyLength, pSettings->m_dwWritableTimeout);
  1258. #endif
  1259.     }
  1260.     catch(CWSocketException* pEx)
  1261.     {
  1262.       //Report the error
  1263.       CString sError;
  1264.       sError.Format(_T("CHttpClient::ReturnErrorMessage, Failed to send to socket, Error:%d"), pEx->m_nError);
  1265.       ASSERT(m_pServer);
  1266.       m_pServer->OnError(sError);
  1268.       pEx->Delete();  
  1269.     }
  1270.   }
  1272.   //Log the information
  1273.   PostLog(nStatusCode, dwBodyLength);
  1275.   //Return the body length
  1276.   return dwBodyLength;
  1277. }
  1279. DWORD CHttpClient::ReturnRedirectMessage(const CString& sURL)
  1280. {
  1281.   //Validate our parameters
  1282.   ASSERT(m_pServer);
  1283.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1284.   ASSERT(pSettings);
  1286.   //Form the body of the response
  1287.   DWORD dwBodyLength = 0;
  1288.   char* pszBody = m_pServer->LoadHTML(302, dwBodyLength);
  1290.   //Form the header of the response
  1291.   CHttpResponseHeader responseHdr;
  1292.   responseHdr.AddStatusCode(302);
  1293.   SYSTEMTIME st;
  1294.   GetSystemTime(&st);
  1295.   responseHdr.AddDate(st);
  1296.   responseHdr.AddServer(pSettings->m_sServerName);
  1297.   responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1298.   responseHdr.AddLocation(sURL);
  1299.   if (m_bResponseKeepAlive)
  1300.     responseHdr.AddKeepAlive();
  1301.   responseHdr.AddContentLength(dwBodyLength);
  1302.   responseHdr.AddContentType(_T("text/html"));
  1304.   //Send the header and body all in one
  1305.   TransmitBuffer(m_Socket, responseHdr, (BYTE*)pszBody, dwBodyLength, pSettings->m_dwWritableTimeout);
  1307.   //Log the information
  1308.   PostLog(302, dwBodyLength);
  1310.   return dwBodyLength;
  1311. }
  1313. DWORD CHttpClient::ReturnUnauthorizedMessage(const CString& sRealm)
  1314. {
  1315.   //Validate our parameters
  1316.   ASSERT(m_pServer);
  1317.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1318.   ASSERT(pSettings);
  1319.   ASSERT(pSettings->m_bAllowBasicAuthentication || pSettings->m_bAllowNTLMAuthentication);
  1321.   //Form the body of the response
  1322.   DWORD dwBodyLength = 0;
  1323.   char* pszBody = m_pServer->LoadHTML(401, dwBodyLength);
  1325.   //Form the header of the response
  1326.   CHttpResponseHeader responseHdr;
  1327.   responseHdr.AddStatusCode(401);
  1328.   SYSTEMTIME st;
  1329.   GetSystemTime(&st);
  1330.   responseHdr.AddDate(st);
  1331.   responseHdr.AddServer(pSettings->m_sServerName);
  1332.   responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1334.   if (pSettings->m_bAllowNTLMAuthentication)
  1335.     responseHdr.AddWWWAuthenticateNTLM(m_Request.m_sAuthenticationResponse);
  1336.   if (pSettings->m_bAllowBasicAuthentication)
  1337.     responseHdr.AddWWWAuthenticateBasic(sRealm);
  1338.   if (m_bResponseKeepAlive)
  1339.     responseHdr.AddKeepAlive();
  1340.   responseHdr.AddContentLength(dwBodyLength);
  1341.   responseHdr.AddContentType(_T("text/html"));
  1343.   //Send the header and body all in one
  1344.   TransmitBuffer(m_Socket, responseHdr, (BYTE*)pszBody, dwBodyLength, pSettings->m_dwWritableTimeout);
  1346.   //Log the information
  1347.   PostLog(401, dwBodyLength);
  1349.   return dwBodyLength;
  1350. }
  1352. DWORD CHttpClient::ReturnFileDeletedOkMessage(const CString& /*sFile*/)
  1353. {
  1354.   //Validate our parameters
  1355.   ASSERT(m_pServer);
  1356.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1357.   ASSERT(pSettings);
  1359.   //Form the body of the response
  1360.   DWORD dwBodyLength = 0;
  1361.   char* pszBody = m_pServer->GetFileDeletedHTML(dwBodyLength);
  1363.   //Form the header of the response
  1364.   CHttpResponseHeader responseHdr;
  1365.   responseHdr.AddStatusCode(200);
  1366.   SYSTEMTIME st;
  1367.   GetSystemTime(&st);
  1368.   responseHdr.AddDate(st);
  1369.   responseHdr.AddServer(pSettings->m_sServerName);
  1370.   responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1371.   if (m_bResponseKeepAlive)
  1372.     responseHdr.AddKeepAlive();
  1373.   responseHdr.AddContentLength(dwBodyLength);
  1374.   responseHdr.AddContentType(_T("text/html"));
  1376.   //Send the header and body all in one
  1377.   TransmitBuffer(m_Socket, responseHdr, (BYTE*)pszBody, dwBodyLength, pSettings->m_dwWritableTimeout);
  1379.   //Log the information
  1380.   PostLog(200, dwBodyLength);
  1382.   //Don't forget to free up the memory
  1383.   delete [] pszBody;
  1385.   return dwBodyLength;
  1386. }
  1388. void CHttpClient::TransmitBuffer(BYTE* byData, DWORD dwSize, CHttpDirectory* /*pDirectory*/, BOOL bForceExpire)
  1389. {
  1390.   //validate our settings
  1391.   ASSERT(m_pServer);
  1392.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1393.   ASSERT(pSettings);
  1394.   ASSERT(pSettings->m_pMimeManager);
  1396.   CHttpResponseHeader responseHdr;
  1398.   //Get the current system time in UTC
  1399.   SYSTEMTIME stCurTime;
  1400.   ::GetSystemTime(&stCurTime);
  1402.   if (m_Request.m_dwHttpVersion > MAKELONG(9, 0)) //No header sent for Http 0.9
  1403.   {
  1404.     //Get the mime type for extension we are about to return
  1405.     CString sMime = pSettings->m_pMimeManager->GetMimeType(m_Request);
  1407.     //Form the header of the response
  1408.     responseHdr.AddStatusCode(200);
  1409.     responseHdr.AddDate(stCurTime);
  1410.     responseHdr.AddServer(pSettings->m_sServerName);
  1411.     responseHdr.AddW3MfcAllowFields(pSettings->m_bAllowDeleteRequest);
  1412.   if (bForceExpire)
  1413.   responseHdr.AddExpires(stCurTime);
  1414.     if (m_bResponseKeepAlive)
  1415.       responseHdr.AddKeepAlive();
  1416.     responseHdr.AddContentLength(dwSize);
  1417.     responseHdr.AddContentType(sMime);
  1419.     //Send the header and body all in one
  1420.     TransmitBuffer(m_Socket, responseHdr, byData, dwSize, pSettings->m_dwWritableTimeout);
  1421.   }
  1422.   else
  1423.   {
  1424.     //Send back the file contents (if not a HEAD request)
  1425.     if (m_Request.m_Verb != CHttpRequest::HTTP_VERB_HEAD)
  1426.     {
  1427.       try
  1428.       {
  1429.         m_Socket.SendWithRetry(byData, dwSize, pSettings->m_dwWritableTimeout);
  1430.       }
  1431.       catch(CWSocketException* pEx)
  1432.       {
  1433.         //Report the error
  1434.         CString sError;
  1435.         sError.Format(_T("CHttpClient::TransmitBuffer, Failed to send to socket, Error:%d"), pEx->m_nError);
  1436.         m_pServer->OnError(sError);
  1438.         pEx->Delete();  
  1439.       }
  1440.     }
  1441.   }
  1443.   //Log the information
  1444.   PostLog(200, dwSize);
  1445. }
  1446.  
  1447. CHttpDirectory* CHttpClient::GetVirtualDirectory(const CString& sDirectory)
  1448. {
  1449.   //Validate our parameters
  1450.   ASSERT(m_pServer);
  1451.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1452.   ASSERT(pSettings);
  1454.   CHttpDirectory* pDirectory = NULL;
  1455.   for (int i=0; i<pSettings->m_Directories.GetSize() && pDirectory == NULL; i++)  
  1456.   {
  1457.     CHttpDirectory* pDir = pSettings->m_Directories.GetAt(i);
  1458.     if (sDirectory.CompareNoCase(pDir->GetAlias()) == 0)
  1459.       pDirectory = pDir;
  1460.   }
  1462.   return pDirectory;  
  1463. }
  1465. int CHttpClient::HexToInt(TCHAR ch)
  1466. {
  1467.   //character is in range of 0-9 subtract ascii value of '0' to get integer
  1468.   if ((ch >= _T('0')) && (ch <= _T('9')))
  1469.     return ch - _T('0');
  1471.   //character is in range of a-z or A-Z subtract ascii value of 'a' and add 10 to get it converted into int
  1472.   if ((ch >= _T('a')) && (ch <= _T('f')))
  1473.     return ch - _T('a') + 10;
  1474.   else if ((ch >= _T('A')) && (ch <= _T('F')))
  1475.     return ch - _T('A') + 10;
  1477.   //Character is not a Hex Digit
  1478.   return -1;
  1479. }
  1481. TCHAR CHttpClient::IntToHex(int Character)
  1482. {
  1483.   //This function only expects nibbles
  1484.   ASSERT(Character >= 0 && Character <= 15);
  1485.   
  1486.   if (Character <= 9)
  1487.     return (TCHAR)(Character + _T('0'));
  1488.   else
  1489.     return (TCHAR)(Character - 10 + _T('A'));
  1490. }
  1492. CString CHttpClient::UTF8ToCString(const CString& sURL)
  1493. {
  1494.   //Get the length of the string to convert from UTF
  1495.   int nInputLen = sURL.GetLength();
  1497.   //Allocate memory to hold the Unicode string
  1498.   LPWSTR lpwszURL = new WCHAR[nInputLen * 4];
  1500.   //Convert the UTF input string to Unicode
  1501.   int nInputIndex = 0;
  1502.   int nOutputIndex = 0;
  1503.   while (nInputIndex < nInputLen)
  1504.   {
  1505.     BYTE cInputChar1 = (BYTE) sURL.GetAt(nInputIndex);
  1506.     if (cInputChar1 <= 0x7f)
  1507.     {
  1508.       //Form the current output character
  1509.       lpwszURL[nOutputIndex] = cInputChar1;
  1511.       //Move onto the next input character
  1512.       nInputIndex++;
  1513.     }
  1514.     else if (nInputIndex < nInputLen-1 && cInputChar1 <= 0xdf)
  1515.     {
  1516.       //Form the current output character
  1517.       lpwszURL[nOutputIndex] = (wchar_t) (((cInputChar1 & 0x1f) << 6) + 
  1518.                                           (sURL.GetAt(nInputIndex+1) & 0x3f));
  1520.       //Move onto the next input character
  1521.       nInputIndex += 2;
  1522.     }
  1523.     else if (nInputIndex < nInputLen-2)
  1524.     {
  1526.       //Form the current output character
  1527.       lpwszURL[nOutputIndex] = (wchar_t) (((cInputChar1 & 0x0f) << 12) + 
  1528.                                           ((sURL.GetAt(nInputIndex+1) & 0x3f) << 6) +
  1529.                                           (sURL.GetAt(nInputIndex+2) & 0x3f));
  1531.       //Move onto the next input character
  1532.       nInputIndex += 3;
  1533.     }
  1534.     else
  1535.     {
  1536.       //skip illegal sequence
  1537.       nInputIndex++;
  1538.     }
  1540.     //Move onto the next output character
  1541.     nOutputIndex++;
  1542.   }
  1544.   //Don't forget to NULL terminate
  1545.   lpwszURL[nOutputIndex] = _T('');
  1547.   //Form a CString version of the Unicode string
  1548.   CString sDecodedURL(lpwszURL);
  1550.   //Tidy up the heap memory we have been using
  1551.   delete [] lpwszURL;
  1553.   //Return the string
  1554.   return sDecodedURL;
  1555. }
  1557. CString CHttpClient::URLEncode(const CString& sURL)
  1558. {
  1559.   CString sEncodedURL;
  1560.   int nLength = sURL.GetLength();
  1561.   LPTSTR pszEncodedURL = sEncodedURL.GetBufferSetLength((nLength*3) + 1);
  1562.   int nOutputIndex = 0;
  1563.   for (int i=0; i<nLength; i++)
  1564.   {
  1565.     //Pull out the current character to evaluate
  1566.     BYTE CurrentChar = (BYTE) sURL.GetAt(i);
  1568.     //Should we encode the character or not? See RFC 1738 for the details.
  1569.     if ((CurrentChar >= '0' && CurrentChar <= '9') ||
  1570.         (CurrentChar >= 'a' && CurrentChar <= 'z') ||
  1571.         (CurrentChar >= 'A' && CurrentChar <= 'Z') ||
  1572.         (CurrentChar == '$') ||
  1573.         (CurrentChar == '-') ||
  1574.         (CurrentChar == '_') ||
  1575.         (CurrentChar == '.') ||
  1576.         (CurrentChar == '+') ||
  1577.         (CurrentChar == '!') ||
  1578.         (CurrentChar == '*') ||
  1579.         (CurrentChar == ''') ||
  1580.         (CurrentChar == '(') ||
  1581.         (CurrentChar == ')') ||
  1582.         (CurrentChar == ','))
  1583.     {
  1584.       pszEncodedURL[nOutputIndex] = CurrentChar;
  1585.       ++nOutputIndex;
  1586.     }
  1587.     else 
  1588.     {
  1589.       pszEncodedURL[nOutputIndex] = _T('%');
  1590.       ++nOutputIndex;
  1592.       TCHAR nNibble = IntToHex((CurrentChar & 0xF0) >> 4);
  1593.       pszEncodedURL[nOutputIndex] = nNibble;
  1594.       ++nOutputIndex;
  1596.       nNibble = IntToHex(CurrentChar & 0x0F);  
  1597.       pszEncodedURL[nOutputIndex] = nNibble;
  1598.       ++nOutputIndex;
  1599.     }
  1600.   }
  1601.   //Don't forget to NULL terminate
  1602.   pszEncodedURL[nOutputIndex] = _T('');
  1603.   sEncodedURL.ReleaseBuffer();
  1605.   return sEncodedURL;
  1606. }
  1608. CString CHttpClient::URLDecode(const CString& sURL)
  1609. {
  1610.   CString sDecodedURL;
  1611.   int nLength = sURL.GetLength();
  1612.   LPTSTR pszDecodedURL = sDecodedURL.GetBufferSetLength(nLength + 1);
  1613.   int nOutputIndex = 0;
  1614.   for (int i=0; i<nLength; i++)
  1615.   {
  1616.     TCHAR c1 = sURL[i];
  1617.     if (c1 != _T('%'))
  1618.     {
  1619.       if (c1 == '+')
  1620.         pszDecodedURL[nOutputIndex] = ' ';  
  1621.       else
  1622.         pszDecodedURL[nOutputIndex] = c1;
  1623.       nOutputIndex++;
  1624.     }
  1625.     else
  1626.     {
  1627.       if (i < nLength-2)
  1628.       {
  1629.         int msb = HexToInt(sURL[i+1]);
  1630.         int lsb = HexToInt(sURL[i+2]);
  1631.         if (msb != -1 && lsb != -1)
  1632.         {
  1633.           int nChar = (msb << 4) + lsb;
  1634.           pszDecodedURL[nOutputIndex] = TCHAR(nChar);
  1635.           nOutputIndex++;
  1636.           i += 2;
  1637.         }
  1638.         else
  1639.         {
  1640.           pszDecodedURL[nOutputIndex] = c1;
  1641.           nOutputIndex++;
  1642.         }
  1643.       }
  1644.       else
  1645.       {
  1646.         pszDecodedURL[nOutputIndex] = c1;
  1647.         nOutputIndex++;
  1648.       }
  1649.     }
  1650.   }
  1651.   //Don't forget to NULL terminate
  1652.   pszDecodedURL[nOutputIndex] = _T('');
  1653.   sDecodedURL.ReleaseBuffer();
  1655.   return sDecodedURL;
  1656. }
  1658. BOOL CHttpClient::MapURLToLocalFilename(CString& sURL, CString& sLocalFile, CString& sPathInfo, BOOL& bDirectory, CHttpDirectory*& pDirectory, DWORD& dwMatchingURL, DWORD& dwMatchingPath)
  1659. {
  1660.   //Setup the default return value from this function
  1661.   BOOL bSuccess = FALSE;
  1662.   sLocalFile.Empty();
  1663.   sPathInfo.Empty();
  1664.   bDirectory = FALSE;
  1665.   pDirectory = NULL;
  1666.   dwMatchingURL = 0;
  1667.   dwMatchingPath = 0;
  1669.   //Convert from Unix to Windows format
  1670.   CString sClientURL(sURL);
  1671.   sClientURL.Replace(_T("/"), _T("\"));
  1673.   //As a security precaution do not allow any URL's which contains any relative parts in it 
  1674.   //(as an example trying to request a file outside of the directories we are serving)
  1675.   //We also exclude URL's with a ":" in them as this is how NTFS streams are accessed
  1676.   if (sClientURL.Find(_T("..")) == -1 && sClientURL.Find(_T(":")) == -1)
  1677.   {
  1678.     pDirectory = NULL;
  1679.     TCHAR sDrive[_MAX_DRIVE];
  1680.     TCHAR sDir[_MAX_DIR];
  1681.     TCHAR sFname[_MAX_FNAME];
  1682.     TCHAR sExt[_MAX_EXT];
  1683.     CString sVirtualDir(sClientURL);
  1684.     sVirtualDir += _T("\"); //Initially try a default directory
  1685.     do
  1686.     {
  1687.       _tsplitpath(sVirtualDir, sDrive, sDir, sFname, sExt);
  1688.       if (_tcslen(sDir))
  1689.       {
  1690.         pDirectory = GetVirtualDirectory(sDir);
  1691.         if (pDirectory == NULL)
  1692.         {
  1693.           sVirtualDir = sDir;
  1694.           sVirtualDir = sVirtualDir.Left(sVirtualDir.GetLength()-1);
  1695.         }
  1696.       }
  1697.     }
  1698.     while (pDirectory == NULL && _tcslen(sDir));
  1700.     if (pDirectory)
  1701.     {
  1702.   CString strPath = pDirectory->GetDirectory();
  1703.       ASSERT(pDirectory->GetDirectory().GetLength());
  1704.       ASSERT(pDirectory->GetAlias().GetLength());
  1706.       //Ignore the alias part of the URL now that we have got the virtual directory
  1707.       CString sAlias = pDirectory->GetAlias();
  1708.       CString sRelativeFile(sClientURL);
  1709.       sRelativeFile = sRelativeFile.Right(sRelativeFile.GetLength() - sAlias.GetLength());
  1711.       //Form the local filename from the requested URL
  1712.       CString sDirectory = pDirectory->GetDirectory();
  1713.       int nLength = sDirectory.GetLength();
  1714.       if (sDirectory.GetAt(nLength-1) != _T('\'))
  1715.         sDirectory += _T("\");
  1716.       sLocalFile = sDirectory; 
  1718.       //Asking for the default filename
  1719.       if (sRelativeFile.IsEmpty())
  1720.       {
  1721.         bDirectory = pDirectory->GetDirectoryListing();
  1722.         if (!bDirectory)
  1723.           sLocalFile += pDirectory->GetDefaultFile(); 
  1725.         dwMatchingURL = sURL.GetLength();
  1726.         dwMatchingPath = sLocalFile.GetLength();
  1727.       }
  1728.       else
  1729.       {
  1730.         //Ensure that we don't have two "" separating the filename from the directory
  1731.         if (sClientURL.Find(_T('\')) == 0)
  1732.           sLocalFile += sRelativeFile.Right(sRelativeFile.GetLength());
  1733.         else
  1734.           sLocalFile += sRelativeFile; 
  1736.         dwMatchingURL = sURL.GetLength();
  1737.         dwMatchingPath = sLocalFile.GetLength();
  1739.         //Keep parsing left to right until we find a piece of the path which is a file.
  1740.         //This is used to work out the PathInfo value
  1741.         CString sTemp(sRelativeFile);
  1742.         int nLocalFileData = 0;
  1743.         BOOL bContinueParse = TRUE;
  1744.         while (bContinueParse)
  1745.         {
  1746.           int nSlash = sTemp.Find(_T('\'));
  1747.           if (nSlash != -1)
  1748.           {
  1749.             nLocalFileData += nSlash;
  1750.             CString sFile(sDirectory + sRelativeFile.Left(nLocalFileData));
  1751.             sTemp = sTemp.Right(sTemp.GetLength() - nSlash - 1);
  1753.             DWORD dwAttributes = GetFileAttributes(sFile);
  1754.             if (dwAttributes == INVALID_FILE_ATTRIBUTES)
  1755.             {
  1756.               bContinueParse = FALSE;
  1757.               sPathInfo = sLocalFile.Right(sLocalFile.GetLength() - sFile.GetLength() + nSlash);
  1758.               sPathInfo.Replace(_T("\"), _T("/"));
  1759.               sLocalFile = sFile.Left(sFile.GetLength() - nSlash - 1);
  1761.               //Remove the PathInfo from the incoming parameter
  1762.               sURL = sURL.Left(sURL.GetLength() - sPathInfo.GetLength());
  1764.               dwMatchingURL = sClientURL.GetLength() - sPathInfo.GetLength();
  1765.               dwMatchingPath = sLocalFile.GetLength();
  1766.             }
  1767.             else if ((dwAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
  1768.             {
  1769.               bContinueParse = FALSE;
  1770.               sPathInfo = sLocalFile.Right(sLocalFile.GetLength() - sFile.GetLength() - 1);
  1771.               sPathInfo.Replace(_T("\"), _T("/"));
  1772.               sLocalFile = sFile;
  1774.               //Remove the PathInfo from the incoming parameter
  1775.               sURL = sURL.Left(sURL.GetLength() - sPathInfo.GetLength() - 1);
  1777.               dwMatchingURL = sClientURL.GetLength() - sPathInfo.GetLength();
  1778.               dwMatchingPath = sLocalFile.GetLength();
  1779.             }
  1781.             nLocalFileData++; //Move over the directory separator
  1782.           }
  1783.           else
  1784.           {
  1785.             bContinueParse = FALSE;
  1787.             CString sFile(sDirectory + sRelativeFile.Left(nLocalFileData) + sTemp);
  1789.             DWORD dwAttributes = GetFileAttributes(sFile);
  1790.             if (dwAttributes == INVALID_FILE_ATTRIBUTES)
  1791.             {
  1792.               sPathInfo = sTemp;
  1793.               sPathInfo.Replace(_T("\"), _T("/"));
  1794.               sLocalFile = sDirectory + sRelativeFile.Left(nLocalFileData);
  1796.               //Remove the PathInfo from the incoming parameter
  1797.               sURL = sURL.Left(sURL.GetLength() - sPathInfo.GetLength());
  1799.               dwMatchingURL = sClientURL.GetLength() - sPathInfo.GetLength();
  1800.               dwMatchingPath = sLocalFile.GetLength();
  1801.             }
  1802.           }
  1803.         }
  1805.         bDirectory = pDirectory->GetDirectoryListing() && (((GetFileAttributes(sLocalFile) & FILE_ATTRIBUTE_DIRECTORY) != 0));
  1806.         if (bDirectory)
  1807.         {
  1808.           int nURLLength = sURL.GetLength();
  1809.           if (nURLLength && sURL.GetAt(nURLLength-1) != _T('/'))
  1810.             sURL += _T("/");
  1811.         }
  1813.       }
  1815.       bSuccess = TRUE;
  1816.     }
  1817.   }
  1819.   return bSuccess;
  1820. }
  1822. #ifdef _DEBUG
  1823. void CHttpClient::PostLog(int nHTTPStatusCode, DWORD dwBodyLength)
  1824. #else
  1825. void CHttpClient::PostLog(int /*nHTTPStatusCode*/, DWORD /*dwBodyLength*/)
  1826. #endif
  1827. {
  1828. #ifdef _DEBUG
  1829.   //The default is to just TRACE the details
  1831.   //Get the current date and time
  1832.   time_t now = time(NULL);
  1833.   tm* pNow = localtime(&now);
  1835.   //Get the time zone information
  1836.   TIME_ZONE_INFORMATION tzi;
  1837.   GetTimeZoneInformation(&tzi);
  1839.   //Format the date and time appropiately
  1840.   TCHAR sDateTime[64];
  1841.   _tcsftime(sDateTime, 64, _T("[%d/%b/%Y:%H:%M:%S"), pNow);
  1843.   //Display the connections to the console window
  1844.   CString sUser(m_Request.m_sUsername);
  1845.   if (sUser.IsEmpty())
  1846.     sUser = _T("-");
  1847.   TRACE(_T("%d.%d.%d.%d - %s %s %04d] "%s" %d %dn"), 
  1848.         m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b1,
  1849.         m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b2, 
  1850.         m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b3, 
  1851.         m_Request.m_ClientAddress.sin_addr.S_un.S_un_b.s_b4, 
  1852.         sUser, sDateTime, tzi.Bias, m_Request.m_sRequest, nHTTPStatusCode, dwBodyLength);
  1853. #endif        
  1854. }
  1856. BOOL CHttpClient::TransmitFile(CHttpSocket& socket, CHttpResponseHeader& responseHdr, HANDLE hFile, DWORD dwSize, DWORD dwTimeout)
  1857. {
  1858.   //Validate our parameters
  1859.   ASSERT(m_pServer);
  1860.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1861.   ASSERT(pSettings);
  1863.   //Assume the worst
  1864.   BOOL bSuccess = FALSE;
  1866. #ifdef W3MFC_SSL_SUPPORT
  1867.   BOOL bTryUsingSendExtension = (pSettings->m_SSLProtocol == CHttpServerSettings::SSL_NONE);
  1868. #else
  1869.   BOOL bTryUsingSendExtension = TRUE;
  1870. #endif
  1872.   if (bTryUsingSendExtension && _W3MFCData.m_lpfnTransmitFile)
  1873.   {
  1874.     bSuccess = _W3MFCData.TransmitFile(socket, responseHdr, hFile, dwSize);
  1876.     //Handle the error
  1877.     if (!bSuccess)
  1878.     {
  1879.       //Report the error
  1880.       CString sError;
  1881.       sError.Format(_T("CHttpClient::TransmitFile, Failed to send response via TransmitFile, Error:%d"), ::GetLastError());
  1882.       m_pServer->OnError(sError);
  1883.     }
  1884.   }
  1885.   else
  1886.   {
  1887.     //Send the header
  1888. #ifdef W3MFC_SSL_SUPPORT
  1889.     bSuccess = responseHdr.Send(m_Socket, dwTimeout, m_SSL);
  1890. #else
  1891.     bSuccess = responseHdr.Send(socket, dwTimeout);
  1892. #endif
  1893.     if (!bSuccess)
  1894.     {
  1895.       //Report the error
  1896.       CString sError;
  1897.       sError.Format(_T("CHttpClient::TransmitFile, Failed to send to response header, Error:%d"), ::GetLastError());
  1898.       m_pServer->OnError(sError);
  1899.     }
  1901.     //Send the body
  1902.     if (bSuccess)
  1903.     {
  1904.       try
  1905.       {
  1906.         char sBuf[4096];
  1907.         DWORD dwBytesRead = 0;
  1908.         do 
  1909.         {
  1910.           if (::ReadFile(hFile, sBuf, 4096, &dwBytesRead, NULL) && dwBytesRead)
  1911. #ifdef W3MFC_SSL_SUPPORT
  1912.             socket.SendWithRetry(sBuf, dwBytesRead, dwTimeout, m_SSL);
  1913. #else
  1914.             socket.SendWithRetry(sBuf, dwBytesRead, dwTimeout);
  1915. #endif
  1916.         } 
  1917.         while (dwBytesRead);
  1918.         bSuccess = TRUE;
  1919.       }
  1920.       catch(CWSocketException* pEx)
  1921.       {
  1922.         //Report the error
  1923.         CString sError;
  1924.         sError.Format(_T("CHttpClient::TransmitFile, Failed to send response file data, Error:%d"), pEx->m_nError);
  1925.         m_pServer->OnError(sError);
  1927.         pEx->Delete();  
  1928.       }
  1929.     }
  1930.   }
  1932.   return bSuccess;
  1933. }
  1935. BOOL CHttpClient::TransmitBuffer(CHttpSocket& socket, CHttpResponseHeader& responseHdr, BYTE* byData, DWORD dwSize, DWORD dwTimeout)
  1936. {
  1937.   //Validate our parameters
  1938.   ASSERT(m_pServer);
  1939.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  1940.   ASSERT(pSettings);
  1942.   //Assume the worst
  1943.   BOOL bSuccess = FALSE;
  1945. #ifdef W3MFC_SSL_SUPPORT
  1946.   BOOL bTryUsingSendExtension = (pSettings->m_SSLProtocol == CHttpServerSettings::SSL_NONE);
  1947. #else
  1948.   BOOL bTryUsingSendExtension = TRUE;
  1949. #endif
  1951.   if (bTryUsingSendExtension && _W3MFCData.m_lpfnTransmitPackets)
  1952.   {
  1953.     bSuccess = _W3MFCData.TransmitBuffer(socket, responseHdr, byData, dwSize);
  1954.     if (!bSuccess)
  1955.     {
  1956.       //Report the error
  1957.       CString sError;
  1958.       sError.Format(_T("CHttpClient::TransmitBuffer, Failed to send response via TransmitPackets, Error:%d"), ::GetLastError());
  1959.       m_pServer->OnError(sError);
  1960.     }
  1961.   }
  1962.   else
  1963.   {
  1964.     //Send the header
  1965. #ifdef W3MFC_SSL_SUPPORT
  1966.     bSuccess = responseHdr.Send(socket, dwTimeout, m_SSL);
  1967. #else
  1968.     bSuccess = responseHdr.Send(socket, dwTimeout);
  1969. #endif
  1970.     if (!bSuccess)
  1971.     {
  1972.       //Report the error
  1973.       CString sError;
  1974.       sError.Format(_T("CHttpClient::TransmitBuffer, Failed to send to response header, Error:%d"), ::GetLastError());
  1975.       m_pServer->OnError(sError);
  1976.     }
  1978.     //Send the body
  1979.     if (bSuccess && dwSize)
  1980.     {
  1981.       try
  1982.       {
  1983. #ifdef W3MFC_SSL_SUPPORT
  1984.         socket.SendWithRetry(byData, dwSize, dwTimeout, m_SSL);
  1985. #else
  1986.         socket.SendWithRetry(byData, dwSize, dwTimeout);
  1987. #endif
  1988.         bSuccess = TRUE;
  1989.       }
  1990.       catch(CWSocketException* pEx)
  1991.       {
  1992.         //Report the error
  1993.         CString sError;
  1994.         sError.Format(_T("CHttpClient::TransmitBuffer, Failed to send to response body, Error:%d"), pEx->m_nError);
  1995.         m_pServer->OnError(sError);
  1997.         pEx->Delete();  
  1998.       }
  1999.     }
  2000.   }
  2002.   return bSuccess;
  2003. }
  2005. void CHttpClient::SetRequestToStop()
  2006. {
  2007.   //Let the base class do its thing
  2008.   CThreadPoolClient::SetRequestToStop();
  2010.   //Set the event which signals that we want this worker thread to exit
  2011.   m_StopEvent.SetEvent();
  2012. }
  2014. BOOL CHttpClient::GetKeySizeServerVariable(int& nKeySize)
  2015. {
  2016.   //Validate our parameters
  2017.   ASSERT(m_pServer);
  2018.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  2019.   ASSERT(pSettings);
  2021.   //What will be the return value
  2022.   BOOL bSuccess = FALSE;
  2023.   nKeySize = 0;
  2025. #ifdef W3MFC_SSL_SUPPORT
  2026.   if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  2027.   {
  2028.     SSL_get_cipher_bits(m_SSL, &nKeySize);
  2029.     bSuccess = TRUE;
  2030.   }
  2031. #endif
  2033.   return bSuccess;
  2034. }
  2036. BOOL CHttpClient::GetServerKeySizeServerVariable(int& nKeySize)
  2037. {
  2038.   //Validate our parameters
  2039.   ASSERT(m_pServer);
  2040.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  2041.   ASSERT(pSettings);
  2043.   //What will be the return value
  2044.   BOOL bSuccess = FALSE;
  2045.   nKeySize = 0;
  2047. #ifdef W3MFC_SSL_SUPPORT
  2048.   if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  2049.   {
  2050.     EVP_PKEY* pKey = SSL_get_privatekey(m_SSL);
  2051.     if (pKey)
  2052.     {
  2053.       nKeySize = EVP_PKEY_bits(pKey);
  2054.       bSuccess = TRUE;
  2055.     }
  2056.   }
  2057. #endif
  2059.   return bSuccess;
  2060. }
  2062. BOOL CHttpClient::GetCertSerialNumberServerVariable(long& nSerialNumber)
  2063. {
  2064.   //Validate our parameters
  2065.   ASSERT(m_pServer);
  2066.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  2067.   ASSERT(pSettings);
  2069.   //What will be the return value
  2070.   BOOL bSuccess = FALSE;
  2071.   nSerialNumber = 0;
  2073. #ifdef W3MFC_SSL_SUPPORT
  2074.   if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  2075.   {
  2076.     X509* pCert = SSL_get_certificate(m_SSL);
  2077.     if (pCert)
  2078.     {
  2079.       ASN1_INTEGER* pSerialNumber = X509_get_serialNumber(pCert);
  2080.       if (pSerialNumber)
  2081.       {
  2082.         nSerialNumber = ASN1_INTEGER_get(pSerialNumber);
  2083.         bSuccess = TRUE;
  2084.       }
  2085.     }
  2086.   }
  2087. #endif
  2089.   return bSuccess;
  2090. }
  2092. BOOL CHttpClient::GetCertIssuerServerVariable(char*& szIssuer)
  2093. {
  2094.   //Validate our parameters
  2095.   ASSERT(m_pServer);
  2096.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  2097.   ASSERT(pSettings);
  2099.   //What will be the return value
  2100.   BOOL bSuccess = FALSE;
  2101.   szIssuer = NULL;
  2103. #ifdef W3MFC_SSL_SUPPORT
  2104.   if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  2105.   {
  2106.     X509* pCert = SSL_get_certificate(m_SSL);
  2107.     if (pCert)
  2108.     {
  2109.       szIssuer = X509_NAME_oneline(X509_get_issuer_name(pCert), NULL, NULL);
  2110.       bSuccess = TRUE;
  2111.     }
  2112.   }
  2113. #endif
  2115.   return bSuccess;  
  2116. }
  2118. BOOL CHttpClient::GetCertSubjectServerVariable(char*& szSubject)
  2119. {
  2120.   //Validate our parameters
  2121.   ASSERT(m_pServer);
  2122.   CHttpServerSettings* pSettings = m_pServer->GetSettings();
  2123.   ASSERT(pSettings);
  2125.   //What will be the return value
  2126.   BOOL bSuccess = FALSE;
  2127.   szSubject = NULL;
  2129. #ifdef W3MFC_SSL_SUPPORT
  2130.   if (pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  2131.   {
  2132.     X509* pCert = SSL_get_certificate(m_SSL);
  2133.     if (pCert)
  2134.     {
  2135.       szSubject = X509_NAME_oneline(X509_get_subject_name(pCert), NULL, NULL);
  2136.       bSuccess = TRUE;
  2137.     }
  2138.   }
  2139. #endif
  2141.   return bSuccess;
  2142. }
  2144. #ifndef W3MFC_NO_ISAPI_SUPPORT
  2145. BOOL CHttpClient::TransmitFile(CHttpSocket& socket, CHttpResponseHeader& responseHdr, HSE_TF_INFO* pInfo)
  2146. {
  2147.   return _W3MFCData.TransmitFile(socket, responseHdr, pInfo);
  2148. }
  2149. #endif
  2151. BOOL CHttpClient::PreHandleGetPostHead()
  2152. {
  2153.   //This allows derived classes to internally handle GET, POST or HEAD requests.
  2154.   //Return TRUE in your derived classes to tell the framework that the request
  2155.   //has been handled and stops the framework from implementing its default processing
  2156.   //for a URL
  2158.   //In this base class we of course allow default processing to occur
  2159.   return FALSE;
  2160. }