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

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

CA认证

开发平台：

Visual C++

W3Mfc.cpp：源码内容
  1. /*
  2. Module : W3Mfc.cpp
  3. Purpose: Implementation for a simple MFC class encapsulation of a HTTP server
  4. Created: PJN / 22-04-1999
  5. History: PJN / 24-06-1999 1.  Implemented support for "HEAD" command
  6.                           2.  Sample provided now also displays the HTTP verb used
  7.                           3.  Sample provided now also displays the date and time of each request
  8.                           4.  Now fully supports multiple virtual directories
  9.                           5.  Now fully supports URL's with encoded characters
  10.                           6.  Implemented support for "DELETE" command
  11.                           7.  Now returns an "Allow:" HTTP header
  12.                           8.  Timeout for requests is now 90 seconds if built for debug
  13.                           9.  Now supports directory listing
  14.                           10. User name is now displayed in the log window
  15.          PJN / 29-02-2000 1.  Fixed a number of VC 6 level 4 warnings
  16.                           2.  Now empties the username and password once they are used
  17.                           3.  Now implements W3C Common Logfile logging to the console window
  18.          PJN / 15-04-2001 1.  Updated copyright information   
  19.                           2.  A new generalised thread pool wrapper class is now included which can
  20.                           be used in other projects.
  21.                           3.  A new generalised sockets wrapper class is now included which can be 
  22.                           used in other winsock projects
  23.          PJN / 23-04-2001 1. Fixed a stack overwrite issue in CHttpResponseHeader::DateToStr
  24.                           2. Fixed a bug in CHttpClient::TransmitFile which was causing "304 Not Modified"
  25.                           headers to never be returned
  26.          PJN / 25-07-2001 1. Code now uses Winsock 2 functionality, namely "WSAEventSelect" to avoid a busy loop
  27.                           in the listening socket thread. This means that you will have to have Winsock 2 
  28.                           downloaded and installed if running on Windows 95 which did not ship with 
  29.                           Winsock 2 built in.
  30.          PJN / 23-08-2001 1. Added support for CGI v1.1 (has been verfied with perl scripts and batch files)
  31.                           2. Added support for reverse DNS lookups
  32.                           3. Now fully supports POST HTTP method.
  33.                           4. Following values have been added to CHttpRequest:
  34.                              m_pszRawRequest, m_pszRawEntity, m_sRemoteHost and m_sContentType
  35.                           5. Improved the robustness of the code by making sure exceptions are caught
  36.          PJN / 30-09-2001 1. Fixed a bug in CWSocket::Receive which can occur when a disconnection occurs
  37.                           while a receive is in progress
  38.                           2. Fixed a bug where entities sent i.e. m_pszRawEntity did not correctly handle the 
  39.                           case where it had enbedded NULL's e.g. a file upload. Thanks to Christian Hett for 
  40.                           spotting this problem.
  41.                           3. Removed some unnecessary memcpy's from CHttpClient::ParseRequest
  42.                           4. Made the main program configurable via an ini file instead of hard coding all the
  43.                           settings.
  44.                           5. Fixed a resource leak on an anonymous pipe handle in CHttpClient::TransmitCGIResponse.
  45.          PJN / 03-11-2001 1. Fixed an issue where socket sends would sometimes throw the exception WSAEWOULDBLOCK.
  46.                           The httpsocket class now includes a "SendWithRetry" method which handles this case.
  47.          PJN / 27-12-2001 1. Fixed an exception memory leak in the method CHttpSocket::SendWithRetry. Thanks 
  48.                           to Olivier Meyer for spotting this problem.
  49.                           2. Removed an unreferrenced variable from CHttpSocket::ReadResponse
  50.                           3. Added a flag to TransmitFile to allow the transmission of an "Expires: " header
  51.                           4. Added CHttpDirectory parameter to all transmit methods. Allows derived classes
  52.                           more control over the response procedure.
  53.                           5. Added optional Non-NT authentication to the web server at the virtual directory
  54.                           level. 
  55.                           6. Reviewed TRACE statements throughtout W3MFC for completeness and validity
  56.                           7. Addition of a CHttpClient::TransmitBuffer method to allow for easy transmission of 
  57.                           in-memory generated responses. Thanks to "Golden Crater" for most of those suggestions.
  58.                           8. W3MFC now takes advantage of the MS Winsock extension API "TransmitFile". This
  59.                           should improve the performance of the code by avoiding inordinate kernel transitions
  60.                           on NT based operating systems.
  61.                           9. Includes a new error reporting mechanism via the CHttpServer::OnError method
  62.                           10. Now includes a nice icon for the generated binary
  63.                           11. Version info resource is now included in the generated binary
  64.                           12. Modified "Return..." functions to return body length sent
  65.                           13. Check all PostLog calls to ensure indicated parameter size is correct
  66.                           14. W3MFC now takes advantage of the MS Winsock extension API "TransmitPackets". This
  67.                           should improve the performance of the code by avoiding inordinate kernel transitions
  68.                           on Windows XP or later. Please note that I have been unable to test this feature so 
  69.                           feeback on this would be appreciated.
  70.          PJN / 08-01-2002 1. Code only uses TransmitFile and TransmitPackets APIs if running on NT/2000/XP/.Net Server
  71.                           2. Provided a virtual CHttpClient::TransmitFile and CHttpClient::TransmitBuffer functions. 
  72.                           The default implemenations just pass the buck to the _W3MFC_DATA function pointers if 
  73.                           available.
  74.                           3. Made CHttpClient::HandleClient function virtual.
  75.                           4. Fixed an issue in CHttpClient::TransmitDirectory where created URL's could sometimes forget 
  76.                           to put in directory separators in the URL.
  77.                           5. Updated copyright messages to be 2002.
  78.                           6. Provided a virtual CHttpClient::ParseRequestLine to allow derived classes to easily pull
  79.                           out any additional http headers e.g. "User-Agent" or "Accept-Language" etc.
  80.                           7. Provided a virtual CHttpClient::FormCGIEnvironment to allow derived classes to easily change
  81.                           the environment variables sent to CGI processes.
  82.                           8. Fixed a serious bug in CHttpResponseHeader::GetData while code was compiled for UNICODE
  83.                           9. Addition of a very handy new "CW32Handle" class which implements a "Smart Pointer" class
  84.                           for Win32 Handles. For one thing it looks after calling CloseHandle in the destructor. The class
  85.                           turns out to be very handy when you are implementing CGI in this web server as you have to
  86.                           create loads of Win32 handles such as anonymous pipes etc.
  87.                           10. Improved the error reporting in CHttpClient::TransmitCGIResponse
  88.                           11. Rewrote the CGI handling code in CHttpClient::TransmitCGIResponse to use the information 
  89.                           provided by MS Knowledge base article "Q190351".
  90.          PJN / 26-01-2002 1. CIOCP9x clas: added an additional semaphore as I have forgotten that we need to synchronise 
  91.                           the removal of items from the queue in addition to synchronising the addition of items to the 
  92.                           queue.
  93.                           2. Fixed a level 4 warning in the CHttpClient class.
  94.                           3. Only now uses TransmitPackets and TransmitFile if running 2000 / XP or .Net Server. Thanks 
  95.                           to Olivier Meyer for spotting this problem on NT 4.
  96.          PJN / 21-02-2002 1. Fixed an issue in CHttpClient::GetCGICommandLine where the code was using RegQueryValue 
  97.                           instead of RegQueryValueEx which is the recommended way of doing registry queries in Win32.
  98.                           Thanks to Josh Clarke for spotting this problem.
  99.                           2. CGI command line is now expanded with any environment variables it may contain. Again 
  100.                           thanks goes to Josh Clarke for this nice update.
  101.          PJN / 23-03-2002 1. W3MFC ships with a sample CGI app "TestCGI.exe"
  102.                           2. CHttpClient::GetCGICommandLine function now defaults to the local file path if a registry 
  103.                           entry cannot be found for it. Thanks to Gilad Novik for this suggestion.
  104.          PJN / 23-05-2002 1. Now fully supports SSL via the OpenSSL open source Library.
  105.                           2. Removed IOCP9x module from project as not required.
  106.                           3. Fixed a bug in CHttpServer::ListenSocketFunction which was causing the thread pool to initialize
  107.                           incorrectly.
  108.          PJN / 24-05-2002 1. Fixed a bug in the SSL code path which was causing a crash in CHttpClient::TransmitBuffer.
  109.                           2. Provision of wrapper classes for OpenSSL C type variables used by W3MFC
  110.                           3. Tidied up the SSL code in CHttpClient::HandleClient
  111.          PJN / 25-05-2002 1. Improved the performance of CHttpClient::URLDecode method
  112.                           2. Improved the performance of CHttpClient::TransmitDirectory. Thanks to "Jim" for this fix.
  113.                           3. URL's transmitedd down to client in CHttpClient::TransmitDirectory are now URL encoded.
  114.                           4. Fixed a crash which was occurring for some requests in CHttpClient::ParseRequest where the code
  115.                           ended up parsing into the entity body instead of stopping when it reached the separator after the
  116.                           http header. Thanks to Harold B Johns for spotting this.
  117.          PJN / 29-05-2002 1. Environment variables for CGI processes now includes all the environment variables which W3MFC
  118.                           itself has. These missing environment variables were causing CGI programs to fail in calls to
  119.                           CoInitialize if they were using COM. Thanks to Harold B Johns for spotting this.
  120.          PJN / 30-05-2002 1. Fixed a #include issue when doing a non SSL build. Thanks to Harold B Johns for spotting this.
  121.                           2. Fixed an issue where a request for a non existent CGI file caused the web server to become
  122.                           unresponsive. Thanks to Harold B Johns for spotting this.
  123.                           3. Fixed an issue in the CGI code when SSL is enabled. Thanks to Gilad Novik for reporting this
  124.                           problem.
  125.          PJN / 14-06-2002 1. Fixed a problem in CHttpClient::FindNextTerminatorFromRequest which was parsing out header
  126.                           details incorrectly. Thanks to Gilad Novik for reporting this problem.                         
  127.          PJN / 28-07-2002 1. Now CHttpMimeManager can be replaced at runtime. This allows the mime map to be easily configured
  128.                           or replaced with a custom implementation.
  129.                           2. Mime map as used by the sample app is now configured from the W3MFC ini file instead of from
  130.                           the system registry. In addition the shipped W3MFC ini file now includes a fully fleshed out mime 
  131.                           section
  132.                           3. You can now improve the robustness of the SSL behaviour by initializing the OpenSSL PRNG (Pseudo
  133.                           Random Number generator) with the contents of a file as specified via 
  134.                           CHttpServerSettings::m_sSSLRandomnessFile.
  135.                           4. A fresh default web site is now shown using the default ini settings, instead of expecting a web 
  136.                           site to be configured at c:inetpubwwwroot
  137.                           5. Improved the performance of looking up mime types by implementing a hash table for storage
  138.          PJN / 18-08-2002 1. Now uses v1.09 of the CThreadPoolServer class.                 
  139.                           2. Sample app now allows you to decide via a ini value whether or not to use the CIOCPThreadPoolQueue
  140.                           class instead of the CDirectedThreadPoolQueue class. While I was at it, I avoiding an issue with
  141.                           leaving an item on the Q if updating the "Get" semaphores failed.
  142.          PJN / 17-10-2002 1. Fixed a bug in CHttpClient::HexToInt which was causing it to not work for upper case characters.
  143.                           Thanks to Frank Schmidt for spotting this problem.
  144.                           Failure to setup thread pool recycling is now reported as an error.
  145.          PJN / 16-11-2002 1. Class now supports the use of the "Connection: Keep-Alive" Header.
  146.                           2. Removed the StringReplace method and replaced it with CString::Replace.
  147.                           3. Fixed some Log message's text to correctly reflect the function they are used in.
  148.                           4. Code now makes the call to CHttpClient::AllowThisConnection before the incoming request is parsed.
  149.                           5. Fixed a typo in the name of the CHttpClient::HandleDirectoryAuthorization function
  150.                           6. Made the operation of the delivery of the "Expires" header contingent on a configurable setting
  151.                           7. CHttpResponseHeader::AddW3MfcAllowFields now returns that it can handle POST requests
  152.                           8. The "DELETE" verb support is now contingent on a configurable setting.
  153.                           9. Fixed a typo in the creation of the "SERVER_PROTOCOL" CGI environment variable
  154.                           10. Updated the sample CGI app to also send a Content-Length HTTP header. This allows the sample
  155.                           app to work correctly when it is used in conjuction with HTTP Keep Alives  
  156.          PJN / 17-11-2002 1. Optimized the use of the Keep Alives variables in the function CHttpClient::HandleClient
  157.                           2. Implemented code to find whether CGI programs send Keep Alives.
  158.          PJN / 18-11-2002 1. Now allows anonymous access to be enabled / disabled
  159.                           2. Now allows Basic authentication to be enabled / disabled.
  160.                           3. Reworked the Base64 class to be based on the ATL Server Base64 routines in ATL Server in VC.Net
  161.                           4. Renamed and Reworked the CHttpClient::ReturnUnauthorizedMessage method.
  162.                           5. Impersonation handle used during Basic authentication now is a CW32Handle instance instead of a 
  163.                           raw SDK handle
  164.                           6. Now fully supports NTLM Authentication via the SSPI interface. The code is enabled for support
  165.                           for Kerberos, "Negotiate" and Digest authentication which will be added in a future release. The use 
  166.                           of SSPI support can be changed via the compile time define "W3MFC_NO_SSPI_SUPPORT". Thanks to 
  167.                           Harold B Johns for suggesting this.
  168.                           7. Fixed a problem in CHttpClient::ParseRequest which was causing failures to parse a certain line
  169.                           to be overwritten upon successfull parsing of subsequent lines. 
  170.                           8. test CGI app now is implemented without MFC support and deliberatly does not use a Content-Length
  171.                           or Keep-Alive header for testing purposes.
  172.                           9. Tidied up the importing of various header files throughout W3MFC and also the associated
  173.                           #pragma messages which these something display.
  174.          PJN / 18-11-2002 1. CHttpSocket::ReadResponse now uses waitable timers (if it can) instead of a loop which has calls
  175.                           to Sleep. This should improve the scalabilty of the code under heavy load. Please note that if you
  176.                           want to compile the code, then you will need to download the CWaitableTimer source code separately
  177.                           from my web site and copy in the wtimer.h & wtimer.cpp into your W3MFC's source code directory.
  178.                           2. Added code to protect against NTFS alternate streams being accessed by client browsers.
  179.                           3. Improved the robustness of parsing the authorization header fields.
  180.          PJN / 20-11-2002 1. Fixed a number of level 4 warnings about unreferrenced variables. Thanks to Harold Johns for 
  181.                           reporting these.
  182.                           2. Updated the documentation to refer to the fact that you will need an up to date Platform SDK 
  183.                           to be installed to compile W3MFC with SSPI support.
  184.                           3. Fixed a memory leak of CHttpRequest objects which can occur when you shutdown the web server and
  185.                           you are using a directed thread pool queue and there are outstanding items in the queue which are
  186.                           not shutdown requests
  187.          PJN / 03-02-2003 1. W3MFC now compares HTTP headers without regard to case. Thanks to Gilad Novik and Frank Hahn for 
  188.                           reporting these problems.
  189.                           2. Tidied up inclusion of afxpriv.h throughout W3MFC modules.
  190.          PJN / 21-02-2003 1. Made the m_Directories member of CHttpServerSettings a pointer array. This allows client code
  191.                           to add their own derived instances of CHttpDirectory to the array. This allows per directory 
  192.                           customisation of the web server. This change also necessitated changing the settings class of the 
  193.                           CHttpServer to be a pointer also. Thanks to "Edgar" for this update.
  194.                           2. Remove the digest authentication boolean from the settings class as Digest authentication is 
  195.                           currently not supported.
  196.                           3. Made the CHttpClient::LoadHTMLResource method virtual
  197.                           4. Moved a lot of the CHttpClient implementation code to CHttpDirectory. This allows more additional
  198.                           complex client customisation of the code.
  199.                           5. Split off the CHttpDirectory class into its own module.
  200.                           6. Implemented a virtual CHttpDirectory::HandleClient. This allows customisation of per directory
  201.                           responses. Thanks to "Edgar" for this suggestion.
  202.          PJN / 22-02-2003 1. Fixed a bug in the parsing of SSL requests which was causing heap corruption problems on
  203.                           subsequent reads of SSL requests on the same thread.
  204.                           2. Reworked the CHttpClient::HandleClient to avoid having to call various functions when the code
  205.                           needs to exit prematurely
  206.                           3. Added a member variable "m_bResponseKeepAlive" to avoid having to pass a keep alive variable
  207.                           throughout all the CHttpClient code.
  208.                           4. Fixed a deadlock bug in CHttpServer::Stop. Thanks to "Edgar" for reporting this problem.
  209.                           5. modified the Mime manager class method "GetMimeType" to be sent the full request rather than just
  210.                           the extension of the URL when it is called to determine the mime type.
  211.                           6. Addition of a string version of the HTTP verb to CHttpRequest. This speeds up the CGI and 
  212.                           ISAPI implementations somewhat.
  213.                           7. Addition of a hash table in the request structure which contains all the HTTP request headers. These
  214.                           values are now available via CGI or ISAPI
  215.                           8. Split of the CGI implementation into its own module and made it optional via a preprocessor directive
  216.                           9. Split of the ISAPI implementation into its own module and made it optional via a preprocessor directive
  217.                           10. W3MFC now uses Win32 TransmitFile API in SSL configuration and only falls back to user mode sockets
  218.                           if SSL is actively being used.
  219.                           11. W3MFC now supports PATH_INFO information in URL's
  220.                           12. Optimized loading of error pages which W3MFC uses
  221.          PJN / 02-03-2002 1. Removed the function CHttpDirectory::SetClient as it can lead to thread synchronisation problems. 
  222.                           Thanks to "Edgar" for reporting this problem.
  223.          PJN / 03-03-2202 1. Added a few defines to allow the W3MFC to compile if you do not have the latest version of the Platform
  224.                           SDK installed. Thanks to "Edgar" for reporting this.
  225.                           2. Fixed a copy and paste gremlin in CHttpServer::Start which was causing a critical section to not be
  226.                           acquired. Thanks to "Edgar" for reporting this.
  227.                           3. Removed the use of "friend classes" entirely throughout the W3MFC codebase. This avoids potential 
  228.                           compilation problems in any derived classes used by client code of W3MFC.
  229.                           4. Addition of a number of preprocessor defines, namely W3MFC_EXT_CLASS, THRDPOOL_EXT_CLASS and 
  230.                           SOCKMFC_EXT_CLASS. This allows the classes to easily be added and exported from a MFC extension dll.
  231.          PJN / 12-09-2003 1. Removed double definition of SCRIPT_NAME from CGI environment. Thanks to Dave Horner for reporting
  232.                           this.
  233.                           2. SCRIPT_NAME CGI environment variable now uses forward slashes rather than back slashes as
  234.                           directory separators. Thanks to Dave Horner for reporting this problem.
  235.                           3. Added a "REQUEST_URI" CGI environment variable. Thanks to Dave Horner for reporting this.
  236.                           4. CGI implementation now returns a HTTP return code line if one if the CGI script does not provide one.
  237.                           Again thanks to Dave Horner for reporting this issue.
  238.                           5. CGI implementation now returns immedately from CHttpCGI::ReadFromClientStdout from a socket error is
  239.                           detected. Again thanks to Dave Horner for reporting this issue.
  240.                           6. "PATH_TRANSLATED" CGI and ISAPI environment variable is now reported as an absolute path. Again thanks 
  241.                           to Dave Horner for reporting this issue.
  242.                           7. "SCRIPT_NAME" CGI and ISAPI environment variable now includes an initial "/". Again thanks to Dave 
  243.                           Horner for reporting this issue.
  244.                           8. CGI now uses pClient->m_Request.m_dwRawEntitySize variable when determining when W3MFC needs to 
  245.                           write to the CGI child process.
  246.                           9. ISAPI implementation now sends just the HTTP body to client ISAPI dlls instead of the whole HTTP
  247.                           request. Thanks to Michael St. Laurent for reporting this problem.
  248.          PJN / 03-11-2003 1. Simplified the code in CHttpSocket::ReadResponse. Thanks to Clarke Brunt for reporting this issue.
  249.          PJN / 10-11-2003 1. URL Encoded spaces as "+" are now correctly handled. Thanks to Dan Baker for reporting this issue. 
  250.                           2. CHttpRequest now includes a m_sRawURL member variable which provides access to the raw URL 
  251.                           before it is URL decoded. Thanks to Dan Baker for suggesting this addition.
  252.                           3. Shipped binary for W3MFC is now linked with the OpenSSL 0.9.6l which is the latest version currently.
  253.          PJN / 30-03-2004 1. Tidied up the interaction of the various classes by removing all friend classes
  254.          PJN / 25-08-2004 1. The binaries included in the download now link against OpenSSL 0.9.7d.
  255.                           2. Per thread cleanup is now done for OpenSSL. Again thanks to Leandro Gustavo Biss Becker for reporting 
  256.                           this problem.
  257.                           3. OpenSSL is now configured by the W3MFC sample app to operate in a thread safe manner. Again thanks 
  258.                           to Leandro Gustavo Biss Becker for reporting this problem.
  259.                           4. Application initialization of OpenSSL has been taken out of W3MFC and is now the responsibility of 
  260.                           your application. See the sample W3MFC application code in main.cpp for an example on how to correctly
  261.                           initialize and terminate OpenSSL.
  262.                           5. CSSL::Close() now calls SSL_shutdown to ensure SSL connections are properly terminated. Thanks to 
  263.                           to Leandro Gustavo Biss Becker for reporting this problem.
  264.                           6. W3MFC now correctly handles UTF8 encoded URL requests. Thanks to Huang Wei for reporting this problem
  265.                           and providing the fix.
  266.          PJN / 15-10-2004 1. Removed an unnecessary ASSERT from CHttpClient::MapURLToLocalFilename. Thanks to Jan Bares for 
  267.                           reporting this problem.
  268.                           2. Changed the behaviour of the code in CHttpClient::MapURLToLocalFilename as follows:
  270.                           Before Change
  272.                           Requesting the URL "/name" would return the file "name" in the root directory of the web server even if
  273.                           a "/name" virtual directory existed. If "name" did not exist in the root directory then a 404 error 
  274.                           would be returned
  276.                           After Change
  278.                           Requesting the URL "/name" will return the virtual directory "/name" if such a virtual directory exists. 
  279.                           If not then the file "name" in the root directory will be returned.
  281.                           Thanks to Jan Bares for pointing out this behaviour which is inconsistent with other Web Server implementations.
  283.                           3. URLs which include "@" now are parsed correctly. Previously the code was parsing the URI
  284.                           expecting it to contain username and password in the URL itself. Instead when the URI arrives at the 
  285.                           server it is not in the URI itself but is represented in the HTTP request headers. Thanks to Jan Bares for 
  286.                           pointing out this problem.
  287.                           4. Passthrough authentication can now be disabled via a new CHttpServerSettings::m_bPerformPassthroughAuthentication
  288.                           setting. This is useful where you want to setup per directory protection using a username / password pair but
  289.                           you do not want to use these credentials in an attempt to impersonate that user by calling the SDK function 
  290.                           "LogonUser". Again thanks to Jan Bares for this suggestion.
  291.          PJN / 11-11-2004 1. Added a m_sRawExtra variable to CHttpRequest. This value is now passed to CGI and ISAPI instead of m_sExtra. 
  292.                           This allows apps to correctly parse form parameters. Thanks to Jan Bares for reporting this problem.
  293.          PJN / 19-02-2004 1. Fixed a bug when directory lists were displayed by W3MFC. It incorrectly always dropped the last entry from
  294.                           the listing. Thanks to Pablo Romero for reporting this bug.
  296. Copyright (c) 1999 - 2005 by PJ Naughter.  (Web: www.naughter.com, Email: pjna@naughter.com)
  298. All rights reserved.
  300. Copyright / Usage Details:
  302. You are allowed to include the source code in any product (commercial, shareware, freeware or otherwise) 
  303. when your product is released in binary form. You are allowed to modify the source code in any way you want 
  304. except you cannot modify the copyright details at the top of each module. If you want to distribute source 
  305. code with your application, then you are only allowed to distribute versions released by the author. This is 
  306. to maintain a single distribution point for the source code. 
  308. */
  312. //////////////// Includes ////////////////////////////////////////////
  314. #include "stdafx.h"
  315. #include "..resource.h"
  316. #include "SocMFC.h"
  317. #include "HttpClient.h"
  318. #include "W3Mfc.h"
  319. #include "Win32Handle.h"
  320. #ifdef W3MFC_SSL_SUPPORT
  321. #include "OpenSSLMfc.h"
  322. #include <opensslrand.h>
  323. #endif
  324. #ifndef __AFXPRIV_H__
  325. #pragma message("To avoid this message please put afxpriv.h in your PCH (normally stdafx.h)")
  326. #include <afxpriv.h>
  327. #endif
  331. //////////////// Macros / Defines /////////////////////////////////////
  333. //automatically pull in Winsock 2
  334. #pragma comment(lib, "Ws2_32.lib")
  336. //automatically pull in SSPI (if required)
  337. #ifndef W3MFC_NO_SSPI_SUPPORT
  338. //#pragma comment(lib, "E:\sdk\Lib\secur32.lib")
  339. #endif
  341. #ifndef SEC_E_OK
  342. #define SEC_E_OK ((SECURITY_STATUS)0x0000)
  343. #endif
  345. #ifdef _DEBUG
  346. #define new DEBUG_NEW
  347. #undef THIS_FILE
  348. static char THIS_FILE[] = __FILE__;
  349. #endif
  353. //////////////// Implementation //////////////////////////////////////
  355. CHttpServerSettings::CHttpServerSettings()
  356. {
  357.   m_nPort = 80;                  //Default to the standard HTTP port
  358.   m_bBind = FALSE;               //Default to not binding to a specific IP address
  360. #ifdef _DEBUG
  361.   m_dwIdleClientTimeout = 90000; //Default to client idle timeout of 90 seconds (when in debug mode)
  362. #else
  363.   m_dwIdleClientTimeout = 30000; //Default to client idle timeout of 30 seconds
  364. #endif
  366.   //Default root directory will be where the exe is running from
  367.   TCHAR sPath[_MAX_PATH];
  368.   GetModuleFileName(NULL, sPath, _MAX_PATH);
  369.   TCHAR sDrive[_MAX_DRIVE];   
  370.   TCHAR sDir[_MAX_DIR];
  371.   _tsplitpath(sPath, sDrive, sDir, NULL, NULL);
  372.   _tmakepath(sPath, sDrive, sDir, NULL, NULL);
  373.   CHttpDirectory* pDir = new CHttpDirectory;
  374.   pDir->SetDirectory(sPath);    
  375.   pDir->SetAlias(_T('/'));
  376.   pDir->SetDefaultFile(_T("default.htm")); //Default filename returned for root requests will be "default.htm"
  377.   m_Directories.Add(pDir);
  379.   m_sServerName = _T("MiniCA Web Server"); //Default server name will be the name of the MFC classes i.e "W3MFC" plus the current version number 
  380.   m_pRuntimeClientClass = RUNTIME_CLASS(CHttpClient); //Default class to use is CHttpClient
  381.   m_nThreadPoolSize = 10;
  382.   m_bDNSLookup = FALSE;
  383.   m_dwWritableTimeout = 10000;
  384.   m_bEnableThreadLifetime = FALSE;
  385.   m_dwThreadLifetime = 120;
  386.   m_pMimeManager = NULL;
  387.   m_bUseIOCPQueue = FALSE;
  388.   m_bKeepAlives = TRUE;
  389.   m_bAutoExpire = FALSE;
  390.   m_bAllowDeleteRequest = FALSE;
  391. #ifndef W3MFC_NO_CGI_SUPPORT
  392.   m_dwCGIResponseBufferSize = 4096;
  393. #endif
  394.   m_bAllowAnonymous = TRUE;
  395.   m_bAllowBasicAuthentication = TRUE;
  396.   m_bAllowNTLMAuthentication = FALSE;
  397.   m_bPerformPassthroughAuthentication = TRUE;
  398. #ifndef W3MFC_NO_ISAPI_SUPPORT
  399.   m_bCacheISAPI = TRUE;
  400.   m_pISAPIManager = NULL;
  401.   m_pISAPI = NULL;
  402. #endif
  403. #ifndef W3MFC_NO_CGI_SUPPORT
  404.   m_pCGI = NULL;
  405. #endif
  406. #ifdef W3MFC_SSL_SUPPORT
  407.   m_SSLProtocol = SSL_NONE;
  408.   m_sServerCertificateFile = _T("W3MFC.pem");
  409.   m_bReuseSessions = TRUE;
  410.   m_dwSSLSessionTimeout = 300;
  411.   m_dwSSLNegotiationTimeout = 10000;
  412. #endif
  413. }
  415. CHttpServerSettings::~CHttpServerSettings()
  416. {
  417.   FreeDirectoryArray();
  418. }
  420. void CHttpServerSettings::FreeDirectoryArray()
  421. {
  422.   for (int i=0; i<m_Directories.GetSize(); i++)
  423.   {
  424.     CHttpDirectory* pDir = m_Directories.GetAt(i);
  425.     delete pDir; 
  426.     pDir = NULL;
  427.   }
  428.   m_Directories.RemoveAll();
  429. }
  433. IMPLEMENT_DYNCREATE(CHttpDirectedThreadPoolQueue, CDirectedThreadPoolQueue)
  435. CHttpDirectedThreadPoolQueue::~CHttpDirectedThreadPoolQueue()
  436. {
  437.   //Before we are destroyed, deallocate any user requests
  438.   //which may still be lying around in the requests array
  439.   for (int i=0; i<m_Requests.GetSize(); i++)
  440.   {
  441.     CThreadPoolRequest& request = m_Requests.ElementAt(i);
  442.     if (request.m_dwID == THREADPOOL_USER_DEFINED_REQUEST)
  443.     {
  444.       CHttpThreadPoolRequest* pHttpRequest = (CHttpThreadPoolRequest*) request.m_pData;
  445.       delete pHttpRequest;
  446.       pHttpRequest = NULL;
  447.     }
  448.   }
  449. }
  453. IMPLEMENT_DYNAMIC(CHttpServer, CObject)
  455. CHttpServer::CHttpServer() : m_ListenStartEvent(TRUE), m_pListenThread(NULL), m_hImpersonation(NULL)
  456. {
  457. #ifndef W3MFC_NO_SSPI_SUPPORT
  458.   ZeroMemory(&m_hCredHandle, sizeof(m_hCredHandle));
  459. #endif
  461.   LoadHTMLResources();
  462. }
  464. void CHttpServer::LoadHTMLResources()
  465. {
  466.   m_psz302HTML = NULL;
  467.   m_dw302HTML = 0;
  468.   m_psz400HTML = NULL;
  469.   m_dw400HTML = 0;
  470.   m_psz401HTML = NULL;
  471.   m_dw401HTML = 0;
  472.   m_psz404HTML = NULL;
  473.   m_dw404HTML = 0;
  474.   m_psz500HTML = NULL;
  475.   m_dw500HTML = 0;
  476.   m_pszDeletedHTML = NULL;
  477.   m_dwDeletedHTML = 0;
  479.   LoadHTMLResource(IDH_302, m_psz302HTML, m_dw302HTML);
  480.   LoadHTMLResource(IDH_400, m_psz400HTML, m_dw400HTML);
  481.   LoadHTMLResource(IDH_401, m_psz401HTML, m_dw401HTML);
  482.   LoadHTMLResource(IDH_404, m_psz404HTML, m_dw404HTML);
  483.   LoadHTMLResource(IDH_500, m_psz500HTML, m_dw500HTML);
  484.   LoadHTMLResource(IDH_FILE_DELETED_OK, m_pszDeletedHTML, m_dwDeletedHTML);
  485. }
  487. CHttpServer::~CHttpServer()
  488. {
  489.   Stop();
  490.   FreeHTMLResources();
  491. }
  493. void CHttpServer::FreeHTMLResources()
  494. {
  495.   if (m_psz302HTML)
  496.   {
  497.     delete [] m_psz302HTML;
  498.     m_psz302HTML = NULL;
  499.     m_dw302HTML = 0;
  500.   }
  501.   if (m_psz400HTML)
  502.   {
  503.     delete [] m_psz400HTML;
  504.     m_psz400HTML = NULL;
  505.     m_dw400HTML = 0;
  506.   }
  507.   if (m_psz401HTML)
  508.   {
  509.     delete [] m_psz401HTML;
  510.     m_psz401HTML = NULL;
  511.     m_dw401HTML = 0;
  512.   }
  513.   if (m_psz404HTML)
  514.   {
  515.     delete [] m_psz404HTML;
  516.     m_psz404HTML = NULL;
  517.     m_dw404HTML = 0;
  518.   }
  519.   if (m_psz500HTML)
  520.   {
  521.     delete [] m_psz500HTML;
  522.     m_psz500HTML = NULL;
  523.     m_dw500HTML = 0;
  524.   }
  525.   if (m_pszDeletedHTML)
  526.   {
  527.     delete [] m_pszDeletedHTML;
  528.     m_pszDeletedHTML = NULL;
  529.     m_dwDeletedHTML = 0;
  530.   }
  531. }
  533. #ifndef W3MFC_NO_SSPI_SUPPORT
  534. BOOL CHttpServer::AcquireSSPI()
  535. {
  536.   //Get a connection to SSPI
  537.   TimeStamp tsExpires;
  538.   SECURITY_STATUS ss = AcquireCredentialsHandle(NULL, _T("NTLM"), SECPKG_CRED_INBOUND, NULL, NULL, NULL, NULL, &m_hCredHandle, &tsExpires);
  539.   BOOL bSuccess = (ss == SEC_E_OK);
  541.   //Report the error
  542.   if (!bSuccess)
  543.   {
  544.     CString sError;
  545.     sError.Format(_T("CHttpServer::AcquireSSPI, Failed in call to AcquireCredentialsHandle, Error:%d"), ss);
  546.     OnError(sError);
  547.   }
  549.   return bSuccess;
  550. }
  552. void CHttpServer::ReleaseSSPI()
  553. {
  554.   SECURITY_STATUS ss = FreeCredentialsHandle(&m_hCredHandle);
  555.   if (ss != SEC_E_OK)
  556.   {
  557.     CString sError;
  558.     sError.Format(_T("CHttpServer::ReleaseSSPI, Failed in call to FreeCredentialsHandle, Error:%d"), ss);
  559.     OnError(sError);
  560.   }
  561. }
  562. #endif
  564. BOOL CHttpServer::Start(CHttpServerSettings* pSettings)
  565. {
  566.   CSingleLock sl(&m_csListenThread, TRUE); //synchronize access to the listening thread
  568.   ASSERT(m_pListenThread == NULL); //Trying to start an already started server
  569.   ASSERT(pSettings);
  570.   ASSERT(pSettings->m_pMimeManager); //must be assigned before you call this function
  571. #ifndef W3MFC_NO_ISAPI_SUPPORT
  572.   ASSERT(pSettings->m_pISAPIManager); //must be assigned before you call this function
  573.   ASSERT(pSettings->m_pISAPI); //must be assigned before you call this function
  574.   pSettings->m_pISAPI->SetServer(this);
  575. #endif
  576. #ifndef W3MFC_NO_CGI_SUPPORT
  577.   ASSERT(pSettings->m_pCGI); //must be assigned before you call this function
  578. #endif
  580.   //Initialize SSPI
  581. #ifndef W3MFC_NO_SSPI_SUPPORT
  582.   if (!AcquireSSPI())
  583.     return FALSE;
  584. #endif
  586.   //Start the listener thread
  587.   m_pSettings = pSettings;
  588.   m_bListenerRunningOK = FALSE;
  589.   m_StopEvent.ResetEvent();
  590.   m_ListenStartEvent.ResetEvent();
  591.   m_pListenThread = AfxBeginThread(ListenSocketFunction, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
  592.   if (m_pListenThread == NULL)
  593.   {
  594.     //Report the error
  595.     CString sError;
  596.     sError.Format(_T("CHttpServer::Start, Failed to call to create listener thread, please check settings"));
  597.     OnError(sError);
  598.     return FALSE;
  599.   }
  600.   m_pListenThread->m_bAutoDelete = FALSE;
  601.   m_pListenThread->ResumeThread();
  603.   //Wait until the thread has completely started and return the success indicator
  604.   ::WaitForSingleObject(m_ListenStartEvent, INFINITE);
  605.   return m_bListenerRunningOK;
  606. }
  608. BOOL CHttpServer::Wait()
  609. {
  610.   CSingleLock sl(&m_csListenThread, TRUE); //synchronize access to the listening thread
  612.   //If the listener thread is running, then just wait for it to exit
  613.   if (m_pListenThread)
  614.   {
  615.     ::WaitForSingleObject(m_pListenThread->m_hThread, INFINITE);
  616.     delete m_pListenThread;
  617.     m_pListenThread = NULL;
  618.     return TRUE;
  619.   }
  620.   else
  621.   {
  622.     //Report the error
  623.     CString sError;
  624.     sError.Format(_T("CHttpServer::Wait, Http server is not running, so no need to wait"));
  625.     OnError(sError);
  626.     return FALSE;
  627.   }
  628. }
  630. BOOL CHttpServer::Stop()
  631. {
  632.   //Signal the listener thread to stop and wait for it to do so, Note that we do 
  633.   //this before we enter the critical section because otherwise we could end
  634.   //up in a deadlock situation between this function and Wait
  635.   m_StopEvent.SetEvent();
  637.   CSingleLock sl(&m_csListenThread, TRUE); //synchronize access to the listening thread
  639.   //If the listener thread is running, then stop it
  640.   if (m_pListenThread)
  641.   {
  642.     ::WaitForSingleObject(m_pListenThread->m_hThread, INFINITE);
  643.     delete m_pListenThread;
  644.     m_pListenThread = NULL;
  646.     //Release SSPI
  647. #ifndef W3MFC_NO_SSPI_SUPPORT
  648.     ReleaseSSPI();
  649. #endif
  650.   }
  652.   return TRUE;
  653. }
  655. BOOL CHttpServer::ReverseDNSLookup(in_addr sin_addr, CString& sDomainName)
  656. {
  657.   BOOL bSuccess = FALSE;
  658.   HOSTENT* pHostEnt = gethostbyaddr((const char*) &sin_addr, sizeof(sin_addr), AF_INET); 
  659.   if (pHostEnt)
  660.   {
  661.     bSuccess = TRUE;
  662.     sDomainName = pHostEnt->h_name;
  663.   }
  665.   return bSuccess;
  666. }
  668. #ifdef W3MFC_SSL_SUPPORT
  669. void CHttpServer::LogSSLErrors()
  670. {
  671.   char sError[1024];
  672.   unsigned long nError;
  673.   do
  674.   { 
  675.     nError = ERR_get_error();
  676.     if (nError)
  677.     {
  678.       ERR_error_string(nError, sError);
  679.       OnError(sError);
  680.     }
  681.   }
  682.   while (nError);
  683. }
  684. #endif
  687. CString CHttpServer::ErrorString()
  688. {
  689. DWORD err = ::GetLastError();
  690. CString Error;
  691. LPTSTR s;
  692. if(::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
  693. FORMAT_MESSAGE_FROM_SYSTEM,
  694. NULL,
  695. err,
  696. 0x0409,
  697. (LPTSTR)&s,
  698. 0,
  699. NULL) == 0)
  700.     { /* failed */
  701. // Unknown error code %08x (%d)
  702. CString fmt;
  703. CString t;
  704. fmt.LoadString(IDS_UNKNOWN_ERROR);
  705. t.Format(fmt, err, LOWORD(err));
  706. Error = t;
  707.     } /* failed */
  708. else
  709.     { /* success */
  710. LPTSTR p = _tcschr(s, _T('r'));
  711. if(p != NULL)
  712.         { /* lose CRLF */
  713. *p = _T('');
  714.         } /* lose CRLF */
  715. Error = s;
  716. ::LocalFree(s);
  717.     } /* success */
  718. return Error;
  719. }
  720.                                
  721. void CHttpServer::ListenSocketFunction()
  722. {
  723.   USES_CONVERSION;
  725.   //Setup the thread pool 
  726.   ASSERT(m_pSettings);
  727.   ASSERT(m_pSettings->m_pRuntimeClientClass);
  728.   if (!m_ThreadPool.Start(m_pSettings->m_pRuntimeClientClass, m_pSettings->m_bUseIOCPQueue ? RUNTIME_CLASS(CIOCPThreadPoolQueue) : RUNTIME_CLASS(CHttpDirectedThreadPoolQueue), 
  729.                           m_pSettings->m_nThreadPoolSize, m_pSettings->m_nThreadPoolSize, TRUE))
  730.   {
  731.     //Report the error
  732.     CString sError;
  733.     sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to create thread pool, GetLastError:%d"), ::GetLastError());
  734.     OnError(sError);
  735.     m_ListenStartEvent.SetEvent();
  736.     return;
  737.   }
  739.   //Setup the pointers in the thread pool instances and resume the threads
  740.   for (int i=0; i<m_pSettings->m_nThreadPoolSize; i++)
  741.   {
  742.     CHttpClient* pClient = (CHttpClient*) m_ThreadPool.GetAtClient(i);
  743.     ASSERT(pClient);
  744.     ASSERT(pClient->IsKindOf(RUNTIME_CLASS(CHttpClient)));
  745.     pClient->m_pServer = this;
  746.     pClient->m_pWorkerThread->ResumeThread();
  747.   }
  749.   //Setup the recycling of threads
  750.   if (!m_ThreadPool.SetMaxThreadClientLifetime(m_pSettings->m_bEnableThreadLifetime, m_pSettings->m_dwThreadLifetime))
  751.   {
  752.     //Report the error
  753.     CString sError;
  754.     sError.Format(_T("CHttpServer::ListenSocketFunction, Failed in call to m_ThreadPool.SetMaxThreadClientLifetime, GetLastError:%d"), GetLastError());
  755.     OnError(sError);
  757.     m_ListenStartEvent.SetEvent();
  758.     return;
  759.   }
  761.   //Create the server socket
  762.   CHttpSocket serverSocket;
  763.   try
  764.   {
  765.     serverSocket.Create();
  766.   }
  767.   catch(CWSocketException* pEx)
  768.   {
  769.     //Report the error
  770.     CString sError;
  771.     sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to create server socket, GetLastError:%d"), pEx->m_nError);
  772.     OnError(sError);
  774.     m_ListenStartEvent.SetEvent();
  775.     pEx->Delete();  
  776.     return;
  777.   }
  779.   //Bind the server socket
  780.   try
  781.   {
  782.     if (m_pSettings->m_bBind)
  783.       serverSocket.Bind(m_pSettings->m_nPort, m_pSettings->m_sBindAddress);
  784.     else
  785.       serverSocket.Bind(m_pSettings->m_nPort);
  786.   }
  787.   catch(CWSocketException* pEx)
  788.   {
  789.     //Report the error
  790.     CString sError;
  791.     sError.Format(_T("Error Code:%d  %s"), pEx->m_nError,  ErrorString());
  792.     OnError(sError);
  794.     m_ListenStartEvent.SetEvent();
  795.     pEx->Delete();  
  796.     return;
  797.   }
  799.   //Put the server socket in a listening state
  800.   try
  801.   {
  802.     serverSocket.Listen();
  803.   }
  804.   catch(CWSocketException* pEx)
  805.   {
  806.     //Report the error
  807.     CString sError;
  808.     sError.Format(_T("Error Code:%d  %s"), pEx->m_nError,  ErrorString());
  809.     OnError(sError);
  811.     m_ListenStartEvent.SetEvent();
  812.     pEx->Delete();
  813.     return;
  814.   }
  816.   //Run the server under a different account if configured to do so
  817.   BOOL bUseAccount = (m_pSettings->m_sUsername.GetLength() != 0);
  818.   CW32Handle hImpersonation;
  819.   BOOL bLoggedOn = FALSE;
  820.   BOOL bImpersonated = FALSE;
  821.   if (bUseAccount)
  822.   {
  823.     LPTSTR pszUser = m_pSettings->m_sUsername.GetBuffer(m_pSettings->m_sUsername.GetLength());
  824.     LPTSTR pszPassword = m_pSettings->m_sPassword.GetBuffer(m_pSettings->m_sPassword.GetLength());
  825.     HANDLE hRawImpersonation = NULL;
  826.     bLoggedOn = LogonUser(pszUser, NULL, pszPassword, LOGON32_LOGON_NETWORK, LOGON32_PROVIDER_DEFAULT, &hImpersonation);
  827.     if (bLoggedOn)
  828.     {
  829.       hImpersonation.Attach(hRawImpersonation);
  830.       bImpersonated = ImpersonateLoggedOnUser(hImpersonation);
  831.     }
  832.     else
  833.     {
  834.       //Report the error
  835.       CString sError;
  836.       sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to logon using user name: %s, GetLastError:%d"), pszUser, ::GetLastError());
  837.       OnError(sError);
  838.     }
  839.     m_pSettings->m_sUsername.ReleaseBuffer();
  840.     m_pSettings->m_sPassword.ReleaseBuffer();
  842.     //Clear the password now that we are finished with it
  843.     m_pSettings->m_sPassword.Empty();
  844.   } 
  845.   m_hImpersonation = hImpersonation; 
  847.   //Handle the case if the impersonation failed
  848.   if (bUseAccount && !bImpersonated)
  849.   {
  850.     //Report the error
  851.     CString sError;
  852.     sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to impersonate using supplied user credentials"));
  853.     OnError(sError);
  855.     m_ListenStartEvent.SetEvent();
  856.     return;
  857.   }
  859.   //Initialize SSL context if required to do so
  860. #ifdef W3MFC_SSL_SUPPORT
  861.   //Initialize the PRNG in OpenSSL
  862.   if (m_pSettings->m_sSSLRandomnessFile.IsEmpty())
  863.   {
  864.     //Get the default rand file from OpenSSL
  865.     char sSSLFile[1024];
  866.     const char* pszRandFile = RAND_file_name(sSSLFile, sizeof(sSSLFile));
  867.     if (pszRandFile)
  868.       m_pSettings->m_sSSLRandomnessFile = pszRandFile;
  869.     else
  870.     {
  871.       //Report the error
  872.       CString sError;
  873.       sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to get the default RAND file from OpenSSL"));
  874.       OnError(sError);
  876.       LogSSLErrors();
  877.     }
  878.   }
  879.   RAND_load_file(T2A((LPTSTR)(LPCTSTR)m_pSettings->m_sSSLRandomnessFile), -1);
  880.   if (RAND_status() == 0)
  881.   {
  882.     //Report the error
  883.     CString sError;
  884.     sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to initialize the PRNG in OpenSSL"));
  885.     OnError(sError);
  887.     LogSSLErrors();
  889.     //Failing to initialize the PRNG is not considered critical for W3MFC
  890.   }
  892.   CSSLContext sslContext;
  893.   if (m_pSettings->m_SSLProtocol != CHttpServerSettings::SSL_NONE)
  894.   {
  895.     //Pick the SSL protocol to use
  896.     SSL_METHOD* pSSLMethod = NULL;
  897.     switch (m_pSettings->m_SSLProtocol)
  898.     {
  899.       case CHttpServerSettings::SSL_V2:
  900.       {
  901.         pSSLMethod = SSLv23_server_method();
  902.         break;
  903.       }
  904.       case CHttpServerSettings::SSL_V3:
  905.       {
  906.         pSSLMethod = SSLv3_server_method();
  907.         break;
  908.       }
  909.       case CHttpServerSettings::SSL_V2_OR_V3:
  910.       {
  911.         pSSLMethod = SSLv23_server_method();
  912.         break;
  913.       }
  914.       case CHttpServerSettings::TLS_V1:
  915.       {
  916.         pSSLMethod = TLSv1_server_method();
  917.         break;
  918.       }
  919.       default:
  920.       {
  921.         ASSERT(FALSE);
  922.         break;
  923.       }
  924.     }
  926.     //Create the SSL context object
  927.     ASSERT(pSSLMethod != NULL);
  928.     SSL_CTX* pSSLContext = SSL_CTX_new(pSSLMethod);
  929.     if (pSSLContext == NULL) 
  930.     {
  931.       //Report the error
  932.       CString sError;
  933.       sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to create SSL context object"));
  934.       OnError(sError);
  936.       LogSSLErrors();
  938.       m_ListenStartEvent.SetEvent();
  939.       return;
  940.     }
  941.     else
  942.       sslContext.Attach(pSSLContext);
  944.     //Set the certificate to use
  945.     if (SSL_CTX_use_certificate_file(sslContext, T2A((LPTSTR) (LPCTSTR) m_pSettings->m_sServerCertificateFile), SSL_FILETYPE_PEM) != 1) 
  946.     {
  947.       //Report the error
  948.       CString sError;
  949.       sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to load up server certificate"));
  950.       OnError(sError);
  952.       LogSSLErrors();
  954.       m_ListenStartEvent.SetEvent();
  955.       return;
  956.     }
  958.     //Set the private key to use
  959.     if (SSL_CTX_use_PrivateKey_file(sslContext, m_pSettings->m_sPrivateKeyFile.GetLength() ? 
  960.                                     T2A((LPTSTR) (LPCTSTR) m_pSettings->m_sPrivateKeyFile) : 
  961.                                     T2A((LPTSTR) (LPCTSTR) m_pSettings->m_sServerCertificateFile), SSL_FILETYPE_PEM) != 1) 
  962.     {
  963.       //Report the error
  964.       CString sError;
  965.       sError.Format(_T("CHttpServer::ListenSocketFunction, Failed to load up private key"));
  966.       OnError(sError);
  968.       LogSSLErrors();
  970.       m_ListenStartEvent.SetEvent();
  971.       return;
  972.     }
  974.     //Check that we the private key is ok
  975.     if (SSL_CTX_check_private_key(sslContext) != 1) 
  976.     {
  977.       //Report the error
  978.       CString sError;
  979.       sError.Format(_T("CHttpServer::ListenSocketFunction, Private key does not match the certificate public key"));
  980.       OnError(sError);
  982.       LogSSLErrors();  
  984.       m_ListenStartEvent.SetEvent();
  985.       return;
  986.     }
  988.     //Set the SSL session settings
  989.     if (m_pSettings->m_bReuseSessions)
  990.     {
  991.       int nOldTimeout;
  992.       nOldTimeout = SSL_CTX_set_timeout(sslContext, m_pSettings->m_dwSSLSessionTimeout);
  993.     }
  994.     else
  995.       SSL_CTX_set_timeout(sslContext, 0);
  996.   }
  997. #endif
  999.   //Use a Win32 event notification on the server socket
  1000.   int nError = WSAEventSelect(serverSocket, m_SocketEvent, FD_ACCEPT);
  1001.   if (nError == SOCKET_ERROR)
  1002.   {
  1003.     DWORD dwError = ::GetLastError();
  1005.     //Report the error
  1006.     CString sError;
  1007.     sError.Format(_T("CHttpServer::ListenSocketFunction, Failed in call to WSAEventSelect, GetLastError:%d"), dwError);
  1008.     OnError(sError);
  1010.     m_ListenStartEvent.SetEvent();
  1011.     return;
  1012.   }
  1014.   //We're now ready for accepting client connections, inform
  1015.   //the main thread that everthing is ok
  1016.   m_bListenerRunningOK = TRUE;
  1017.   m_ListenStartEvent.SetEvent();
  1019.   //Create the wait handles array (used for waiting for an event)
  1020.   HANDLE Handles[2];
  1021.   Handles[0] = m_StopEvent;
  1022.   Handles[1] = m_SocketEvent;
  1024.   //Wait for any incoming connections and the signal to exit the thread m_ListenStopEvent
  1025.   BOOL bWantStop = FALSE;
  1026.   CThreadPoolQueue* pQueue = m_ThreadPool.GetQueue();
  1027.   ASSERT(pQueue);
  1028.   while (!bWantStop)
  1029.   {
  1030.     DWORD dwWait = WaitForMultipleObjects(2, (CONST HANDLE*) &Handles, FALSE, INFINITE);
  1031.     int nSignaledHandle = dwWait - WAIT_OBJECT_0;
  1032.     if (nSignaledHandle == 0) //It was the stop request
  1033.       bWantStop = TRUE;
  1034.     else if (nSignaledHandle == 1) //It was a socket event
  1035.     {
  1036.       CHttpThreadPoolRequest* pRequest = new CHttpThreadPoolRequest;  
  1037.       try
  1038.       {
  1039. #ifdef W3MFC_SSL_SUPPORT
  1040.         pRequest->m_pSSLContext = &sslContext;
  1041. #endif
  1043.         //Accept the client connection  
  1044.         serverSocket.Accept(pRequest->m_ClientSocket, pRequest->m_ClientAddress);
  1046.         //Let a thread pool client class instance handle the work
  1047.         CThreadPoolRequest poolRequest;
  1048.         poolRequest.m_dwID = 1;
  1049.         poolRequest.m_pData = pRequest;  
  1050.         pQueue->PostRequest(poolRequest);
  1051.       }
  1052.       catch(CWSocketException* pEx)
  1053.       {
  1054.         //Report the error
  1055.         CString sError;
  1056.         sError.Format(_T("CHttpServer::ListenSocketFunction, An error occurred accepting a client connection, GetLastError:%d"), pEx->m_nError);
  1057.         OnError(sError);
  1059.         pEx->Delete();
  1060.       }
  1061.     }
  1062.   }
  1064.   //Revert back to normal security settings
  1065.   if (bUseAccount)
  1066.   {
  1067.     //Revert to the usual security settings
  1068.     if (bImpersonated)
  1069.       RevertToSelf();
  1070.   }
  1072.   //Bring down the thread pool
  1073.   m_ThreadPool.Stop();
  1074. }
  1076. UINT CHttpServer::ListenSocketFunction(LPVOID pParam)
  1077. {
  1078.   //Get back the "this" pointer from the pParam parameter
  1079.   CHttpServer* pServer = (CHttpServer*) pParam;
  1080.   ASSERT(pServer);
  1081.   ASSERT(pServer->IsKindOf(RUNTIME_CLASS(CHttpServer)));
  1083.   //Call the run method of the CHttpServer instance
  1084.   pServer->ListenSocketFunction();
  1086. #ifdef W3MFC_SSL_SUPPORT
  1087.   //cleanup SSL thread state
  1088.   ERR_remove_state(0);
  1089. #endif
  1091.   //Return the thread exit code
  1092.   return TRUE;
  1093. }
  1095. #ifdef _DEBUG
  1096. void CHttpServer::OnError(const CString& sError) //To avoid level 4 warning in release
  1097. #else
  1098. void CHttpServer::OnError(const CString& /*sError*/)
  1099. #endif
  1100. {
  1101. #ifdef _DEBUG
  1102.   //The default is to just TRACE the details
  1103.   TRACE(_T("%sn"), sError);
  1104. #endif
  1105. }
  1107. BOOL CHttpServer::LoadHTMLResource(UINT nID, char*& pszHTML, DWORD& dwSize)
  1108. {
  1109.   BOOL bSuccess = FALSE;
  1111.   HMODULE hModule = AfxFindResourceHandle(MAKEINTRESOURCE(nID), RT_HTML);
  1112.   HRSRC hRsrc = ::FindResource(hModule, MAKEINTRESOURCE(nID), RT_HTML);
  1113.   if (hRsrc)
  1114.   {
  1115.     //Load up the resource
  1116.     dwSize = ::SizeofResource(hModule, hRsrc); 
  1117.     HGLOBAL hGlobal = ::LoadResource(hModule, hRsrc);
  1119.     //Allocate a new char array and copy the HTML resource into it 
  1120.     if (hGlobal)
  1121.     {
  1122.       pszHTML = new char[dwSize + 1];
  1123.       char* pszResource = (char*) ::LockResource(hGlobal);
  1124.       if (pszResource)
  1125.       {
  1126.         strncpy(pszHTML, pszResource, dwSize);
  1127.         pszHTML[dwSize] = _T('');
  1128.         bSuccess = TRUE;
  1129.       }
  1130.       else
  1131.       {
  1132.         //Report the error
  1133.         TRACE(_T("CHttpServer::LoadHTMLResource, Failed to load HTML resource, GetLastError:%dn"), GetLastError());
  1134.       }
  1135.     }
  1136.   }
  1138.   return bSuccess;
  1139. }
  1141. char* CHttpServer::LoadHTML(int nStatusCode, DWORD& dwSize)
  1142. {
  1143.   //What will be the return value
  1144.   char* pszHTML = NULL;
  1146.   dwSize = 0;
  1148.   switch(nStatusCode)
  1149.   {
  1150.     case 302:
  1151.     {
  1152.       pszHTML = m_psz302HTML;
  1153.       dwSize = m_dw302HTML;
  1154.       break;
  1155.     }
  1156.     case 400:
  1157.     {
  1158.       pszHTML = m_psz400HTML;
  1159.       dwSize = m_dw400HTML;
  1160.       break;
  1161.     }
  1162.     case 401:
  1163.     {
  1164.       pszHTML = m_psz401HTML;
  1165.       dwSize = m_dw401HTML;
  1166.       break;
  1167.     }
  1168.     case 404:
  1169.     {
  1170.       pszHTML = m_psz404HTML;
  1171.       dwSize = m_dw404HTML;
  1172.       break;
  1173.     }
  1174.     default:
  1175.     {
  1176.       pszHTML = m_psz500HTML;
  1177.       dwSize = m_dw500HTML;
  1178.       break;
  1179.     }
  1180.   }
  1182.   return pszHTML;
  1183. }
  1185. char* CHttpServer::GetFileDeletedHTML(DWORD& dwSize)
  1186. {
  1187.   dwSize = m_dwDeletedHTML;
  1188.   return m_pszDeletedHTML;
  1189. }