| blob | e812aecc510881a9687e65e5c935bc96b3a2c9a7 |
1 // This is a part of the Active Template Library.
2 // Copyright (C) Microsoft Corporation
3 // All rights reserved.
4 //
5 // This source code is only intended as a supplement to the
6 // Active Template Library Reference and related
7 // electronic documentation provided with the library.
8 // See these sources for detailed information regarding the
9 // Active Template Library product.
11 #ifndef __ATLSTENCIL_H__
12 #include <atlstencil.h>
13 #endif
15 #ifndef __ATLISAPI_H__
16 #define __ATLISAPI_H__
18 #pragma once
19 #include <atlbase.h>
22 #include <atlspriv.h>
23 #include <atlserr.h>
24 #include <atlfile.h>
25 #include <atlstr.h>
26 #include <atldbcli.h>
27 #include <atlutil.h>
28 #include <atlcache.h>
29 #include <atlsrvres.h>
30 #include <atlsiface.h>
31 #include <objbase.h>
32 #include <atlsecurity.h>
33 #include <errno.h>
34 #ifndef ATL_NO_SOAP
35 #include <msxml2.h>
36 #endif
37 #ifndef ATL_NO_ACLAPI
38 #include <aclapi.h>
39 #endif
40 #ifndef ATL_NO_MMSYS
41 #pragma warning(push)
43 #include <mmsystem.h>
44 #pragma warning(pop)
45 #ifndef _ATL_NO_DEFAULT_LIBS
47 #ifndef ATL_NO_SOAP
49 #endif
51 #endif
52 #include <atlpath.h>
54 #pragma warning(push)
59 #pragma warning(disable: 4625) // copy constructor could not be generated because a base class copy constructor is inaccessible
60 #pragma warning(disable: 4626) // assignment operator could not be generated because a base class assignment operator is inaccessible
64 #include <initguid.h>
65 #include <dbgautoattach.h>
67 #ifndef SESSION_COOKIE_NAME
69 #endif
71 // override this if you want to use a different CLSID for SAX
72 #ifndef ATLS_SAXXMLREADER_CLSID
73 #define ATLS_SAXXMLREADER_CLSID __uuidof(SAXXMLReader)
77 // This function is used in CValidateObject to determine if an empty
78 // request parameter really should be empty. You can
79 // specialize this function in your own code such as
80 // the following specialization for type long:
81 // template <>
82 // inline bool IsNullByType<long>(long type) throw()
83 // {
84 // return type == 0;
85 // }
86 // You should provide your own specialization for this
87 // function if the comparison of type==0 is not adequate
88 // to discover whether or not your type is 0.
91 {
93 }
96 #pragma pack(push,_ATL_PACKING)
99 // Default file extension for server response files
100 #ifndef ATL_DEFAULT_STENCIL_EXTENSION
102 #endif
103 extern __declspec(selectany) const char * const c_AtlSRFExtension = ATL_DEFAULT_STENCIL_EXTENSION;
104 extern __declspec(selectany) const TCHAR * const c_tAtlSRFExtension = _T(ATL_DEFAULT_STENCIL_EXTENSION);
105 #define ATLS_EXTENSION_LEN (sizeof(ATL_DEFAULT_STENCIL_EXTENSION)-2)
107 // Default file extension for handler DLLs
108 #ifndef ATL_DEFAULT_DLL_EXTENSION
110 #endif
112 extern __declspec(selectany) const TCHAR * const c_tAtlDLLExtension = _T(ATL_DEFAULT_DLL_EXTENSION);
113 #define ATLS_DLL_EXTENSION_LEN (sizeof(ATL_DEFAULT_DLL_EXTENSION)-2)
115 // maximum handler name length
116 #ifndef ATL_MAX_HANDLER_NAME_LEN
117 #define ATL_MAX_HANDLER_NAME_LEN 64
118 #endif
120 #ifndef ATL_HANDLER_NAME_DEFAULT
125 // maximum timeout for async guard mutex
126 #ifndef ATLS_ASYNC_MUTEX_TIMEOUT
127 #define ATLS_ASYNC_MUTEX_TIMEOUT 10000
128 #endif
130 #if defined(_M_IA64) || defined (_M_AMD64)
134 #elif defined(_M_IX86)
138 #else
139 #error Unknown Platform.
140 #endif
142 #define ATL_MAX_COOKIE_LEN 2048
143 #define ATL_MAX_COOKIE_ELEM 1024
146 // Defines a small value used for comparing the equality of floating point numbers.
147 #ifndef ATL_EPSILON
148 #define ATL_EPSILON .0001
149 #endif
151 #ifndef ATL_DEFAULT_PRECISION
152 #define ATL_DEFAULT_PRECISION 6
153 #endif
155 // Call this function to URL-encode a buffer and have the result appended to a CString passed by reference.
156 //
157 // A space in the input string is encoded as a plus sign (+).
158 // Other unsafe characters (as determined by AtlIsUnsafeUrlChar) are encoded as escaped octets.
159 // An escaped octet is a percent sign (%) followed by two digits representing the hexadecimal code of the character.
160 //
161 // string A CStringA reference to which will be appended the encoded version of szBuf.
162 //
163 // szBuf The string to be URL-encoded.
165 {
168 _ATLTRY
169 {
175 {
177 {
182 }
184 {
186 {
187 dwLen++;
189 }
190 else
191 {
196 {
198 }
202 }
203 }
204 else
205 {
207 dwLen++;
208 }
209 szBuf++;
210 }
214 }
216 {
218 }
221 }
223 // UNICODE overload for EscapeToCString
224 // follow specifications detailed in RFC document on
225 // Internationalized Uniform Resource Identifiers (IURI)
227 {
228 _ATLTRY
229 {
230 // convert string to UTF8
233 // get the required length for conversion
237 {
239 }
241 // allocate MBCS conversion string
244 {
246 }
248 // do the UNICODE to UTF8 conversion
251 {
253 }
255 // null-terminate
258 // delegate to ANSI version of EscapeToCString
260 {
262 }
265 }
267 {
269 }
272 }
274 struct CDefaultErrorProvider
275 {
276 struct HTTP_ERROR_TEXT
277 {
282 };
285 // GetErrorText retrieves the http response header string
286 // and a resource id of the response body for a given
287 // http error code
288 // uError: Http error code to retrieve information for
289 // ppszHeader: pointer to LPCSTR that receives the response header string
290 // ppszHeader is optional
291 // puResId: pointer to UINT that receives the response body resource id
292 // puResId is optional
293 static BOOL GetErrorText(__in UINT uError, __in UINT uSubErr, __deref_out_opt LPCSTR *ppszHeader, __out_opt UINT *puResId) throw()
294 {
296 {
304 { 204, DBG_SUBERR_INVALID_SESSION, "Requested DebugSessionID does not match current DebugSessionID", 0},
346 { 500, ISE_SUBERR_STENCIL_PARSE_FAIL, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_STENCILPARSEFAIL},
347 { 500, ISE_SUBERR_STENCIL_LOAD_FAIL, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_STENCILLOADFAIL},
348 { 500, ISE_SUBERR_HANDLER_NOT_FOUND, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_HANDLERNOTFOUND},
349 { 500, ISE_SUBERR_BAD_HANDLER_TAG, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_BADHANDLERTAG},
350 { 500, ISE_SUBERR_LONGMETHODNAME, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_LONGMETHODNAME},
351 { 500, ISE_SUBERR_LONGHANDLERNAME, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_LONGHANDLERNAME},
352 { 500, ISE_SUBERR_NO_HANDLER_TAG, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_NOHANDLERTAG},
353 { 500, ISE_SUBERR_IMPERSONATIONFAILED, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_IMPERSONATIONFAILED},
354 { 500, ISE_SUBERR_ISAPISTARTUPFAILED, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_ISAPISTARTUPFAILED},
355 { 500, ISE_SUBERR_SOAPNOSOAPACTION, "Internal Server Error", IDS_ATLSRV_SERVER_ERROR_SOAPNOSOAPACTION},
362 };
364 // look for the error
366 {
368 {
374 }
375 }
377 // not found
379 }
383 void GetStatusHeader(__inout CStringA &strStatus, __in DWORD dwStatus, __in DWORD dwSubStatus, __in HttpUserErrorTextProvider* pErrorProvider, __out_opt UINT *puResId = NULL) throw(...)
384 {
388 // First, we check for the error text in the extension's user error text provider
391 {
393 }
398 // add the space after the 3 digit response code
403 }
406 void RenderError(__in IHttpServerContext *pServerContext, __in DWORD dwStatus, __in DWORD dwSubStatus, __in HttpUserErrorTextProvider* pErrorProvider)
407 {
410 _ATLTRY
411 {
422 {
423 // load the body string from a resource
425 {
428 }
429 }
432 }
434 {
435 // last resort message when low on memory
436 LPCSTR szError;
437 BOOL bRes;
444 {
446 }
449 }
450 }
452 // Call this function to retrieve the full canonical physical path
453 // of a file relative to the current script.
454 //
455 // Returns TRUE on success, FALSE on error.
456 //
457 // szFile A file path relative to the current script directory for which
458 // you are trying to retrieve the full path.
459 //
460 // szFullFileName A caller-allocated buffer of at least MAX_PATH characters in length.
461 // On success, contains the the full canonical path of szFile.
462 //
463 // pServerContext The context for the current request. The context is used to obtain the
464 // current script directory.
466 __in LPCSTR szFile,
469 {
478 {
480 }
483 {
484 // path is too long
486 }
490 LPSTR szBackslash;
492 {
498 szBackslash++;
499 }
500 else
501 {
502 // handle case where szFile is of the form \directory\etc\etc
504 }
514 {
516 }
519 {
521 }
526 }
528 enum ATLSRV_STATE
529 {
532 ATLSRV_STATE_DONE, // The request is a continuation of an async request, but the server is done with it
533 ATLSRV_STATE_CACHE_DONE // The request is the callback of a cached page
534 };
536 enum ATLSRV_REQUESTTYPE
537 {
540 ATLSRV_REQUEST_DLL // The request is for a .dll file
541 };
543 // Flags the InitRequest can return in dwStatus
544 #define ATLSRV_INIT_USECACHE 1
545 #define ATLSRV_INIT_USEASYNC 2
548 typedef HTTP_CODE (IRequestHandler::*PFnHandleRequest)(AtlServerRequest *pRequestInfo, IServiceProvider *pProvider);
551 struct AtlServerRequest
552 {
556 // Indicates whether it was called through an .srf file or through a .dll file
558 // Indicates what state of completion the request is in
559 IRequestHandler *pHandler; // Necessary because the callback (for async calls) must know where to
560 // route the request
565 HANDLE hFile;
566 HCACHEITEM hEntry;
570 // if HandleRequest could potientially make an
571 // async call before returning. only used
572 // if indicated with ATLSRV_INIT_USEASYNC_EX
576 PFnHandleRequest pfnHandleRequest;
577 PFnAsyncComplete pfnAsyncComplete;
581 };
584 {
594 }
596 typedef BOOL (__stdcall *GETATLHANDLERBYNAME)(LPCSTR szHandlerName, IIsapiExtension *pExtension, IUnknown **ppHandler);
600 // initial size of thread worker heap (per thread)
601 // The heap is growable. The default initial is 16KB
602 #ifndef ATLS_WORKER_HEAP_SIZE
603 #define ATLS_WORKER_HEAP_SIZE 16384
604 #endif
606 class CIsapiWorker
607 {
610 HANDLE m_hHeap;
611 #ifndef ATL_NO_SOAP
613 #endif
616 {
618 }
621 {
623 }
626 {
635 #ifndef ATL_NO_SOAP
637 {
640 }
641 #endif
643 }
646 {
648 {
651 else
652 {
654 }
655 }
657 #ifndef ATL_NO_SOAP
659 #endif
662 }
664 void Execute(__inout AtlServerRequest *pRequestInfo, __inout __crt_typefix(IIsapiExtension*) void *pvParam, __reserved OVERLAPPED *pOverlapped)
665 {
670 // any exceptions thrown at this point should have been caught in an
671 // override of DispatchStencilCall. They will not be thrown out of this
672 // function.
673 _ATLTRY
674 {
676 }
678 {
681 }
682 }
685 {
687 }
688 };
691 __in LPCSTR szPathTranslated,
693 {
698 {
700 szEnd++;
704 szEnd++;
713 {
717 }
718 }
724 {
728 }
729 }
732 struct CStencilState
733 {
735 {
740 }
742 DWORD dwIndex;
743 LCID locale;
746 };
749 public IHttpServerContext
750 {
755 {
756 }
759 {
760 }
763 {
765 }
768 {
771 }
774 {
777 }
780 {
783 }
786 {
789 }
792 {
795 }
798 {
801 }
804 {
807 }
810 {
813 }
816 {
819 }
821 __checkReturn BOOL GetServerVariable(__in_z LPCSTR pszVariableName, __out_ecount_part(*pdwSize,*pdwSize) LPSTR pvBuffer, __inout DWORD *pdwSize)
822 {
825 }
828 {
831 }
833 __checkReturn BOOL AsyncWriteClient(__in_bcount(*pdwBytes) void * pvBuffer, __inout DWORD * pdwBytes)
834 {
837 }
839 __checkReturn BOOL ReadClient(__out_bcount_part(*pdwSize,*pdwSize) void * pvBuffer, __inout DWORD * pdwSize)
840 {
843 }
845 __checkReturn BOOL AsyncReadClient(__out_bcount_part(*pdwSize,*pdwSize) void * pvBuffer, __inout DWORD * pdwSize)
846 {
849 }
852 {
855 }
858 {
861 }
863 __checkReturn BOOL SendResponseHeader(__in LPCSTR pszHeader, __in LPCSTR pszStatusCode, __in BOOL fKeepConn)
864 {
867 }
870 {
873 }
876 {
879 }
882 __in LPCSTR szStatusCode, __in DWORD dwBytesToWrite, __in DWORD dwOffset, __in_bcount_opt(dwHeadLen) void * pvHead,
883 __in DWORD dwHeadLen, __in_bcount_opt(dwTailLen) void * pvTail, __in DWORD dwTailLen, __in DWORD dwFlags)
884 {
888 dwFlags);
889 }
892 {
895 }
897 BOOL MapUrlToPathEx(__in_bcount(dwLen) LPCSTR szLogicalPath, __in DWORD dwLen, __out HSE_URL_MAPEX_INFO *pumInfo)
898 {
901 }
904 // Wraps the EXTENSION_CONTROL_BLOCK structure used by IIS to provide
905 // an ISAPI extension with information about the current request and
906 // access to the web server's functionality.
909 public IHttpServerContext
910 {
917 {
920 }
922 {
923 }
926 {
930 // Initialize the translated script path
932 }
934 // Returns a nul-terminated string that contains the HTTP method of the current request.
935 // Examples of common HTTP methods include "GET" and "POST".
936 // Equivalent to the REQUEST_METHOD server variable or EXTENSION_CONTROL_BLOCK::lpszMethod.
938 {
941 }
943 // Returns a nul-terminated string that contains the query information.
944 // This is the part of the URL that appears after the question mark (?).
945 // Equivalent to the QUERY_STRING server variable or EXTENSION_CONTROL_BLOCK::lpszQueryString.
947 {
950 }
952 // Returns a nul-terminated string that contains the path of the current request.
953 // This is the part of the URL that appears after the server name, but before the query string.
954 // Equivalent to the PATH_INFO server variable or EXTENSION_CONTROL_BLOCK::lpszPathInfo.
956 {
959 }
961 // Call this function to retrieve a nul-terminated string containing the physical path of the script.
962 //
963 // Returns TRUE on success, and FALSE on failure. Call GetLastError to get extended error information.
964 //
965 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
966 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the
967 // buffer (including the nul-terminating byte).
968 // The script path is the same as GetPathTranslated up to the first .srf or .dll.
969 // For example, if GetPathTranslated returns "c:\inetpub\vcisapi\hello.srf\goodmorning",
970 // then this function returns "c:\inetpub\vcisapi\hello.srf".
972 {
975 }
978 // Returns a nul-terminated string that contains the translated path of the requested resource.
979 // This is the path of the resource on the local server.
980 // Equivalent to the PATH_TRANSLATED server variable or EXTENSION_CONTROL_BLOCK::lpszPathTranslated.
982 {
985 }
987 // Returns the total number of bytes to be received from the client.
988 // If this value is 0xffffffff, then there are four gigabytes or more of available data.
989 // In this case, ReadClient or AsyncReadClient should be called until no more data is returned.
990 // Equivalent to the CONTENT_LENGTH server variable or EXTENSION_CONTROL_BLOCK::cbTotalBytes.
992 {
995 }
997 // Returns the number of bytes available in the request buffer accessible via GetAvailableData.
998 // If GetAvailableBytes returns the same value as GetTotalBytes, the request buffer contains the whole request.
999 // Otherwise, the remaining data should be read from the client using ReadClient or AsyncReadClient.
1000 // Equivalent to EXTENSION_CONTROL_BLOCK::cbAvailable.
1002 {
1005 }
1007 // Returns a pointer to the request buffer containing the data sent by the client.
1008 // The size of the buffer can be determined by calling GetAvailableBytes.
1009 // Equivalent to EXTENSION_CONTROL_BLOCK::lpbData
1011 {
1014 }
1016 // Returns a nul-terminated string that contains the content type of the data sent by the client.
1017 // Equivalent to the CONTENT_TYPE server variable or EXTENSION_CONTROL_BLOCK::lpszContentType.
1019 {
1022 }
1024 // Call this function to retrieve a nul-terminated string containing the value of the requested server variable.
1025 // Returns TRUE on success, and FALSE on failure. Call GetLastError to get extended error information.
1026 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
1027 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
1028 // Equivalent to EXTENSION_CONTROL_BLOCK::GetServerVariable.
1030 __in LPCSTR pszVariableName,
1033 {
1039 {
1042 }
1044 }
1046 // Synchronously sends the data present in the given buffer to the client that made the request.
1047 // Returns TRUE on success, and FALSE on failure. Call GetLastError to get extended error information.
1048 // Equivalent to EXTENSION_CONTROL_BLOCK::WriteClient(..., HSE_IO_SYNC).
1050 {
1056 {
1058 }
1060 }
1062 // Asynchronously sends the data present in the given buffer to the client that made the request.
1063 // Returns TRUE on success, and FALSE on failure. Call GetLastError to get extended error information.
1064 // Equivalent to EXTENSION_CONTROL_BLOCK::WriteClient(..., HSE_IO_ASYNC).
1065 __checkReturn BOOL AsyncWriteClient(__in_bcount(*pdwBytes) void *pvBuffer, __inout DWORD *pdwBytes)
1066 {
1072 {
1074 }
1076 }
1078 // Call this function to synchronously read information from the body of the web client's HTTP request into the buffer supplied by the caller.
1079 // Returns TRUE on success, and FALSE on failure. Call GetLastError to get extended error information.
1080 // Equivalent to EXTENSION_CONTROL_BLOCK::ReadClient.
1081 __checkReturn BOOL ReadClient(__out_ecount_part(*pdwSize,*pdwSize) void *pvBuffer, __inout DWORD *pdwSize)
1082 {
1088 {
1090 }
1092 }
1094 // Call this function to asynchronously read information from the body of the web client's HTTP request into the buffer supplied by the caller.
1095 // Returns TRUE on success, and FALSE on failure. Call GetLastError to get extended error information.
1096 // Equivalent to the HSE_REQ_ASYNC_READ_CLIENT server support function.
1097 __checkReturn BOOL AsyncReadClient(__out_bcount_part(*pdwSize,*pdwSize) void *pvBuffer, __inout DWORD *pdwSize)
1098 {
1099 // To call this function successfully someone has to have already
1100 // called RequestIOCompletion specifying the callback function
1101 // to be used for IO completion.
1107 {
1112 }
1114 }
1116 // Call this function to redirect the client to the specified URL.
1117 // The client receives a 302 (Found) HTTP status code.
1118 // Returns TRUE on success, and FALSE on failure.
1119 // Equivalent to the HSE_REQ_SEND_URL_REDIRECT_RESP server support function.
1121 {
1126 {
1129 HSE_REQ_SEND_URL_REDIRECT_RESP,
1131 }
1133 }
1135 // Call this function to retrieve a handle to the impersonation token for this request.
1136 // An impersonation token represents a user context. You can use the handle in calls to ImpersonateLoggedOnUser or SetThreadToken.
1137 // Do not call CloseHandle on the handle.
1138 // Returns TRUE on success, and FALSE on failure.
1139 // Equivalent to the HSE_REQ_GET_IMPERSONATION_TOKEN server support function.
1141 {
1144 {
1148 }
1150 }
1152 // Call this function to send an HTTP response header to the client including the HTTP status, server version, message time, and MIME version.
1153 // Returns TRUE on success, and FALSE on failure.
1154 // Equivalent to the HSE_REQ_SEND_RESPONSE_HEADER_EX server support function.
1159 {
1165 HSE_SEND_HEADER_EX_INFO hex;
1175 HSE_REQ_SEND_RESPONSE_HEADER_EX,
1177 }
1179 // Call this function to terminate the session for the current request.
1180 // Returns TRUE on success, and FALSE on failure.
1181 // Equivalent to the HSE_REQ_DONE_WITH_SESSION server support function.
1183 {
1192 }
1194 // Call this function to set a special callback function that will be used for handling the completion of asynchronous I/O operations.
1195 // Returns TRUE on success, and FALSE on failure.
1196 // Equivalent to the HSE_REQ_IO_COMPLETION server support function.
1198 {
1203 {
1206 }
1208 }
1210 // Call this function to transmit a file asynchronously to the client.
1211 // Returns TRUE on success, and FALSE on failure.
1212 // Equivalent to the HSE_REQ_TRANSMIT_FILE server support function.
1214 __in HANDLE hFile,
1215 __in_opt PFN_HSE_IO_COMPLETION pfn,
1217 __in LPCSTR szStatusCode,
1218 __in DWORD dwBytesToWrite,
1219 __in DWORD dwOffset,
1221 __in DWORD dwHeadLen,
1223 __in DWORD dwTailLen,
1224 __in DWORD dwFlags)
1225 {
1228 HSE_TF_INFO tf;
1242 }
1244 // Appends the string szMessage to the web server log for the current
1245 // request.
1246 // Returns TRUE on success, FALSE on failure.
1247 // Equivalent to the HSE_APPEND_LOG_PARAMETER server support function.
1249 {
1252 {
1254 {
1256 }
1258 }
1259 else
1260 {
1262 }
1267 }
1269 // Maps a logical Url Path to a physical path
1270 // Returns TRUE on success, FALSE on failure.
1271 // Equivalent to the HSE_REQ_MAP_URL_TO_PATH_EX server support function.
1272 // you can pass 0 for dwLen if szLogicalPath is null terminated
1273 BOOL MapUrlToPathEx(__in_bcount(dwLen) LPCSTR szLogicalPath, __in DWORD dwLen, __out HSE_URL_MAPEX_INFO *pumInfo)
1274 {
1278 return m_pECB->ServerSupportFunction(m_pECB->ConnID, HSE_REQ_MAP_URL_TO_PATH_EX, (void *) szLogicalPath,
1280 }
1283 // The pointer to the extension control block provided by IIS.
1287 // The translated script path
1292 class CPageCachePeer
1293 {
1296 struct PeerInfo
1297 {
1298 CStringA strHeader;
1299 CStringA strStatus;
1300 };
1303 {
1304 _ATLTRY
1305 {
1310 }
1312 {
1314 }
1315 }
1318 {
1320 }
1321 };
1327 public IPageCacheControl
1328 {
1331 CAtlTemporaryFile m_cacheFile;
1334 FILETIME m_ftExpiration;
1335 BOOL m_bIsCached;
1346 {
1347 }
1349 {
1350 }
1353 {
1374 {
1376 nSize++;
1377 }
1379 {
1381 }
1383 nSize++;
1385 {
1387 nSize++;
1388 }
1390 {
1392 }
1399 }
1401 // IPageCacheControl methods
1403 {
1411 }
1414 {
1418 }
1421 {
1423 }
1426 {
1430 }
1433 {
1441 }
1444 {
1447 _ATLTRY
1448 {
1450 {
1454 }
1455 else
1457 }
1459 {
1461 }
1464 }
1467 {
1469 _T(" -- Caching a page that requires special privileges to build is a possible security problem. ")
1470 _T("Future hits may get a cached page without going through the security checks done during the page creation process"));
1474 }
1477 {
1481 }
1487 {
1494 }
1496 // The methods below this point are actions that should not be performed on cached
1497 // pages, as they will not behave correctly.
1499 {
1500 // Asynchronous calls will not work
1503 }
1506 {
1507 // Nobody should be reading from this client if the page is being cached
1508 // Also, only GET's are cached anyway
1511 }
1514 {
1517 }
1520 {
1523 }
1527 {
1530 }
1544 {
1547 }
1548 };
1551 // This class represents a collection of validation failures.
1552 // Use this class in combination with CValidateObject to validate
1553 // forms, cookies, or query strings and build up a collection of
1554 // failures. If appropriate, use the information in the collection
1555 // to return detailed responses to the client to help them correct the failures.
1558 class CValidateContext
1559 {
1564 {
1567 }
1570 {
1571 _ATLTRY
1572 {
1579 }
1581 {
1582 }
1585 }
1587 // Call this function to add a validation result to the collection managed by this object.
1588 // Each result is identified by a name and the type of result that occurred.
1589 // The result codes are the VALIDATION_ codes defined at the top of this file.
1590 // The bOnlyFailure parameter below is used to only allow failure results to
1591 // be added to the list of failures. The reason you'd want to do this is that
1592 // success codes should be the common case in validation routines so you can
1593 // use bOnlyFailures to limit the number of allocations by this class's base
1594 // map for mapping success results if you don't care about iterating successes.
1597 {
1598 _ATLTRY
1599 {
1611 }
1613 {
1614 }
1617 }
1619 // Returns true if there are no validation failures in the collection,
1620 // returns false otherwise.
1622 {
1624 }
1626 // Returns the number of validation results in the collection.
1628 {
1630 }
1632 // Call this function to retrieve the name and type of a
1633 // validation result based on its index in the collection.
1634 // Returns true on success, false on failure.
1635 //
1636 // i The index of a result managed by this collection.
1637 //
1638 // strName On success, the name of the result with index i.
1639 //
1640 // type On success, the type of the result with index i.
1642 {
1644 {
1645 _ATLTRY
1646 {
1649 }
1651 {
1653 }
1655 }
1657 }
1659 DWORD m_dwFlags;
1667 class CAtlValidator
1668 {
1672 __in T value,
1673 __in TCompType nMinValue,
1675 {
1682 }
1685 {
1688 {
1690 }
1697 }
1698 static DWORD Validate( __in double dblValue, __in double dblMinValue, __in double dblMaxValue) throw()
1699 {
1706 }
1707 };
1709 // This class provides functions for retrieving and validating named values.
1710 //
1711 // The named values are expected to be provided in string form by the class used as
1712 // the template parameter. CValidateObject provides the means of
1713 // retrieving these values converted to data types chosen by you. You can validate the values
1714 // by specifying a range for numeric values or by specifying a minimum and maximum length
1715 // for string values.
1716 //
1717 // Call one of the Exchange overloads to retrieve a named value converted to your chosen data type.
1718 // Call one of the Validate overloads to retrieve a named value converted to your chosen data type
1719 // and validated against a minimum and maximum value or length supplied by you.
1720 //
1721 // To add validation functionality to the class TLookupClass, derive that class from CValidateObject<TLookupClass>
1722 // and provide a Lookup function that takes a name as a string and returns the corresponding value
1723 // also as a string:
1724 // LPCSTR Lookup(LPCSTR szName);
1726 class CValidateObject
1727 {
1729 // Exchange Routines
1731 // Call this function to retrieve a named value converted to your chosen data type.
1732 // Returns one of the following validation status codes:
1733 // VALIDATION_S_OK The named value was found and could be converted successfully
1734 // VALIDATION_S_EMPTY The name was present, but the value was empty
1735 // VALIDATION_E_PARAMNOTFOUND The named value was not found
1736 // VALIDATION_E_INVALIDPARAM The name was present, but the value could not be converted to the requested data type
1737 // VALIDATION_E_FAIL An unspecified error occurred
1738 // Pass a pointer to a validation context object if you want to add
1739 // failures to the collection managed by that object.
1742 __in LPCSTR szParam,
1745 {
1748 {
1749 _ATLTRY
1750 {
1754 {
1757 else
1758 {
1760 }
1761 }
1762 }
1764 {
1766 }
1767 }
1768 else
1774 }
1778 __in LPCSTR szParam,
1781 {
1782 _ATLTRY
1783 {
1787 {
1791 }
1792 else
1793 {
1797 }
1800 }
1802 {
1804 }
1805 }
1809 __in LPCSTR szParam,
1812 {
1815 {
1816 _ATLTRY
1817 {
1822 {
1825 else
1826 {
1829 }
1830 }
1831 }
1833 {
1835 }
1836 }
1837 else
1843 }
1847 __in LPCSTR szParam,
1850 {
1853 {
1854 _ATLTRY
1855 {
1859 {
1862 else
1863 {
1865 {
1867 }
1868 else
1870 }
1871 }
1872 }
1874 {
1876 }
1877 }
1878 else
1884 }
1888 __in LPCSTR szParam,
1891 {
1894 {
1895 _ATLTRY
1896 {
1901 {
1904 }
1905 }
1907 {
1909 }
1910 }
1911 else
1918 }
1921 {
1932 {
1934 }
1937 }
1940 {
1951 {
1953 }
1956 }
1959 {
1970 {
1972 }
1975 }
1978 {
1980 }
1983 {
1985 }
1988 {
1999 {
2001 }
2004 }
2007 {
2018 {
2020 }
2023 }
2026 {
2036 {
2037 // clamp to the size of a short
2040 {
2042 }
2043 else
2044 {
2046 }
2047 }
2049 };
2051 __checkReturn DWORD ConvertNumber(__in LPCSTR szVal, __out unsigned short *pnVal) const throw()
2052 {
2062 {
2063 // clamp to the size of a short
2066 {
2068 }
2069 else
2070 {
2072 }
2073 }
2075 };
2077 // Call this function to retrieve a named value converted to your chosen data type
2078 // and validated against a minimum and maximum value or length supplied by you.
2079 //
2080 // Returns one of the following validation status codes:
2081 // VALIDATION_S_OK The named value was found and could be converted successfully
2082 // VALIDATION_S_EMPTY The name was present, but the value was empty
2083 // VALIDATION_E_PARAMNOTFOUND The named value was not found
2084 // VALIDATION_E_INVALIDPARAM The name was present, but the value could not be converted to the requested data type
2085 // VALIDATION_E_LENGTHMIN The name was present and could be converted to the requested data type, but the value was too small
2086 // VALIDATION_E_LENGTHMAX The name was present and could be converted to the requested data type, but the value was too large
2087 // VALIDATION_E_FAIL An unspecified error occurred
2088 //
2089 // Validate can be used to convert and validate name-value pairs
2090 // such as those associated with HTTP requests (query string, form fields, or cookie values).
2091 // The numeric specializations validate the minimum and maximum value.
2092 // The string specializations validate the minimum and maximum length.
2093 //
2094 // Pass a pointer to a validation context object if you want to add
2095 // failures to the collection managed by that object.
2096 //
2097 // Note that you can validate the value of a parameter without
2098 // storing its value by passing NULL for the second parameter. However
2099 // if you pass NULL for the second parameter, make sure you cast the NULL to a
2100 // type so that the compiler will call the correct specialization of Validate.
2103 __in LPCSTR Param,
2105 __in TCompType nMinValue,
2106 __in TCompType nMaxValue,
2108 {
2109 T value;
2112 {
2118 }
2121 {
2124 {
2126 }
2127 }
2130 }
2132 // Specialization for strings. Comparison is for number of characters.
2135 __in LPCSTR Param,
2140 {
2144 {
2150 }
2153 {
2156 {
2158 }
2159 }
2163 }
2165 // Specialization for CString so caller doesn't have to cast CString
2168 __in LPCSTR Param,
2173 {
2174 _ATLTRY
2175 {
2176 LPCSTR szValue;
2181 }
2183 {
2185 }
2186 }
2188 // Specialization for doubles, uses a different comparison.
2191 __in LPCSTR Param,
2196 {
2200 {
2206 }
2210 {
2213 {
2215 }
2216 }
2218 }
2219 };
2221 // Cookies provide a way for a server to store a small amount of data on a client
2222 // and have that data returned to it on each request the client makes.
2223 // Use this class to represent a cookie to be sent from the server to a client
2224 // or to represent a cookie that has been returned by a client to the originating server.
2225 //
2226 // At the HTTP level, a cookie is an application-defined name-value pair
2227 // plus some standard attribute-value pairs that describe the way in which the user agent (web browser)
2228 // should interact with the cookie. The HTTP format of a cookie is described in RFC 2109.
2229 //
2230 // The CCookie class provides methods to set and get the application-defined name and value
2231 // as well as methods for the standard attributes. In addition, CCookie provides an abstraction
2232 // on top of the application-defined value that allows it to be treated as a collection of name-value
2233 // pairs if that model makes sense to you. Cookies with a single value are known as single-valued cookies.
2234 // Cookies whose value consists of name-value pairs are known as multi-valued cookies or dictionary cookies.
2235 //
2236 // You can set the name of a cookie by calling SetName or using the appropriate constructor.
2237 // The name of a cookie can be 0 or more characters.
2238 //
2239 // You can set the value of a cookie by calling SetValue or using the appropriate constructor.
2240 // If the cookie has a value set, it is a single-valued cookie and attempts to add a name-value pair will fail.
2241 // You can remove the value of a cookie by calling SetValue(NULL).
2242 //
2243 // You can add a name-value pair to a cookie by calling AddValue.
2244 // If the cookie has any name-value pairs, it is a multi-valued cookie and attempts to set the primary value will fail.
2245 // You can remove all the name-value pairs of a cookie by calling RemoveAllValues.
2246 //
2247 // Class CCookie follows the same rules for creating cookies as ASP does.
2250 {
2257 // Constructs a named cookie.
2259 {
2261 }
2263 // Constructs a single-valued cookie.
2265 {
2268 }
2271 {
2273 }
2276 {
2278 {
2280 }
2282 }
2285 {
2287 }
2290 {
2292 }
2294 // Call this function to set the name of this cookie.
2295 // Returns TRUE on success, FALSE on failure.
2296 // The name of a cookie cannot contain whitespace, semicolons or commas.
2297 // The name should not begin with a dollar sign ($) since such names are reserved for future use.
2299 {
2300 _ATLTRY
2301 {
2303 {
2306 }
2307 }
2309 {
2310 }
2312 }
2314 // Call this function to retrieve the name of this cookie.
2315 // Returns TRUE on success, FALSE on failure.
2316 __checkReturn BOOL GetName(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) const throw()
2317 {
2319 }
2321 // Call this function to retrieve the name of this cookie.
2322 // Returns TRUE on success, FALSE on failure.
2324 {
2325 _ATLTRY
2326 {
2329 }
2331 {
2332 }
2334 }
2336 // Call this function to set the value of this cookie.
2337 // Returns TRUE on success, FALSE on failure.
2338 // Will fail if the cookie is multi-valued.
2339 // Pass NULL to remove the cookie's value.
2341 {
2342 _ATLTRY
2343 {
2349 else
2353 }
2355 {
2356 }
2358 }
2360 // Call this function to retrieve the value of this cookie.
2361 // Returns TRUE on success, FALSE on failure.
2362 // Returns TRUE if there is no value or the value is of zero length.
2363 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
2364 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
2365 __checkReturn BOOL GetValue(__out_ecount(*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) const throw()
2366 {
2368 }
2370 // Call this function to retrieve the value of this cookie.
2371 // Returns TRUE on success, FALSE on failure.
2373 {
2374 _ATLTRY
2375 {
2378 }
2380 {
2381 }
2383 }
2385 // Call this function to add a name-value pair to the cookie.
2386 // Returns TRUE on success, FALSE on failure.
2387 // Will fail if the cookie is single-valued.
2388 // If the named value is already present in the cookie, calling this function
2389 // will modify the current value, otherwise a new name-value pair is added to the cookie.
2390 // Call RemoveValue or RemoveAllValues to remove the name-value pairs
2391 // added by this function.
2393 {
2396 _ATLTRY
2397 {
2399 }
2401 {
2402 }
2404 }
2406 // Call this function to modify a name-value pair associated with the cookie.
2407 // Returns TRUE on success, FALSE on failure.
2408 // Will fail if the cookie is single-valued.
2409 // This function just calls AddValue so the name-value pair will be added if not already present.
2410 // Use this function instead of AddValue to document the intentions of your call.
2412 {
2414 }
2416 // Call this function to remove a name-value pair from the collection managed by this cookie.
2417 // Returns TRUE on success, FALSE on failure.
2419 {
2421 }
2423 // Call this function to remove all the name-value pairs from the collection managed by this cookie.
2425 {
2427 }
2429 // Call this function to add an attribute-value pair to the collection of attributes for this cookie.
2430 // Returns TRUE on success, FALSE on failure.
2431 // This function is equivalent to calling ModifyAttribute.
2432 // Both functions will add the attribute if not already present or
2433 // change its value if it has already been applied to the cookie.
2435 {
2439 _ATLTRY
2440 {
2442 }
2444 {
2445 }
2448 }
2450 // Call this function to modify an attribute-value pair associated with the cookie.
2451 // Returns TRUE on success, FALSE on failure.
2452 // This function is equivalent to calling AddAttribute.
2453 // Both functions will add the attribute if not already present or
2454 // change its value if it has already been applied to the cookie.
2456 {
2458 }
2460 // Call this function to remove an attribute-value pair from the collection of attributes managed by this cookie.
2461 // Returns TRUE on success, FALSE on failure.
2463 {
2465 }
2467 // Call this function to remove all the attribute-value pairs from the collection of attributes managed by this cookie.
2469 {
2471 }
2474 // Call this function to set the Comment attribute of the cookie.
2475 // Returns TRUE on success, FALSE on failure.
2476 // The Comment attribute allows a web server to document its
2477 // intended use of a cookie. This information may be displayed
2478 // by supporting browsers so that the user of the web site can
2479 // decide whether to initiate or continue a session with this cookie.
2480 // This attribute is optional.
2481 // Version 1 attribute.
2483 {
2488 }
2490 // Call this function to set the CommentUrl attribute of the cookie.
2491 // Returns TRUE on success, FALSE on failure.
2492 // The CommentUrl attribute allows a web server to document its intended
2493 // use of a cookie via a URL that the user of the web site can navigate to.
2494 // The URL specified here should not send further cookies to the client to
2495 // avoid frustrating the user.
2496 // This attribute is optional.
2497 // Version 1 attribute.
2499 {
2504 }
2506 // Call this function to add or remove the Discard attribute of the cookie.
2507 // Returns TRUE on success, FALSE on failure.
2508 // The Discard attribute does not have a value.
2509 // Call SetDiscard(TRUE) to add the Discard attribute
2510 // or SetDiscard(FALSE) to remove the Discard attribute.
2511 // Setting the Discard attribute tells a web browser that it should
2512 // discard this cookie when the browser exits regardless of the
2513 // value of the Max-Age attribute.
2514 // This attribute is optional.
2515 // When omitted, the default behavior is that the Max-Age attribute
2516 // controls the lifetime of the cookie.
2517 // Version 1 attribute.
2519 {
2524 {
2526 {
2528 }
2529 else
2530 {
2531 _ATLTRY
2532 {
2534 }
2536 {
2538 }
2539 }
2540 }
2542 }
2544 // Call this function to set the Domain attribute of the cookie.
2545 // Returns TRUE on success, FALSE on failure.
2546 // The Domain attribute is used to indicate the domain to which the current
2547 // cookie applies. Browsers should only send cookies back to the relevant domains.
2548 // This attribute is optional.
2549 // When omitted, the default behavior is for
2550 // browsers to use the full domain of the server originating the cookie. You can
2551 // set this attribute value explicitly if you want to share cookies among several servers.
2552 // Version 0 & Version 1 attribute.
2554 {
2559 }
2561 // Call this function to set the Max-Age attribute of the cookie.
2562 // Returns TRUE on success, FALSE on failure.
2563 // The value of the Max-Age attribute is a lifetime in seconds for the cookie.
2564 // When the time has expired, compliant browsers will discard this cookie
2565 // (if they haven't already done so as a result of the Discard attribute).
2566 // If Max-Age is set to zero, the browser discards the cookie immediately.
2567 // This attribute is the Version 1 replacement for the Expires attribute.
2568 // This attribute is optional.
2569 // When omitted, the default behavior is for browsers to discard cookies
2570 // when the user closes the browser.
2571 // Version 1 attribute.
2573 {
2577 {
2580 {
2582 }
2583 }
2585 }
2587 // Call this function to set the Path attribute of the cookie.
2588 // Returns TRUE on success, FALSE on failure.
2589 // The Path attribute specifies the subset of URLs to which this cookie applies.
2590 // Only URLs that contain that path are allowed to read or modify the cookie.
2591 // This attribute is optional.
2592 // When omitted the default behavior is for browsers to treat the path of a cookie
2593 // as the path of the request URL that generated the Set-Cookie response, up to,
2594 // but not including, the right-most /.
2595 // Version 0 & Version 1 attribute.
2597 {
2602 }
2604 // Call this function to set the Port attribute of the cookie.
2605 // Returns TRUE on success, FALSE on failure.
2606 // The Port attribute specifies the port to which this cookie applies.
2607 // Only URLs accessed via that port are allowed to read or modify the cookie.
2608 // This attribute is optional.
2609 // When omitted the default behavior is for browsers to return the cookie via any port.
2610 // Version 1 attribute.
2612 {
2617 }
2619 // Call this function to add or remove the Secure attribute of the cookie.
2620 // Returns TRUE on success, FALSE on failure.
2621 // The Secure attribute does not have a value.
2622 // Call SetSecure(TRUE) to add the Secure attribute
2623 // or SetSecure(FALSE) to remove the Secure attribute.
2624 // Setting the Secure attribute tells a browser that it should
2625 // transmit the cookie to the web server only via secure means such as HTTPS.
2626 // This attribute is optional.
2627 // When omitted, the default behavior is that the cookie
2628 // will be sent via unsecured protocols.
2629 // Version 0 & Version 1 attribute.
2631 {
2636 {
2638 {
2640 }
2641 else
2642 {
2643 _ATLTRY
2644 {
2646 }
2648 {
2650 }
2651 }
2652 }
2654 }
2656 // Call this function to set the Version attribute of the cookie.
2657 // Returns TRUE on success, FALSE on failure.
2658 // This attribute is required for Version 1 cookies by RFC 2109 and must have a value of 1.
2659 // However, you do not need to call SetVersion explicitly from your own code unless you need to
2660 // force RFC 2109 compliance. CCookie will automatically set this attribute whenever
2661 // you use a Version 1 attribute in your cookie.
2662 // Version 1 attribute.
2664 {
2668 {
2670 }
2672 }
2674 // Call this function to set the Expires attribute of the cookie.
2675 // Returns TRUE on success, FALSE on failure.
2676 // The Expires attribute specifies an absolute date and time at which this cookie
2677 // should be discarded by web browsers. Pass a SYSTEMTIME holding a Greenwich Mean Time (GMT)
2678 // value or a string in the following format:
2679 // Wdy, DD-Mon-YY HH:MM:SS GMT
2680 // This attribute is optional.
2681 // When omitted, the default behavior is for browsers to discard cookies
2682 // when the user closes the browser.
2683 // This attribute has been superceded in Version 1 by the Max-Age attribute,
2684 // but you should continue to use this attribute for Version 0 clients.
2685 // Version 0 attribute.
2687 {
2689 }
2692 {
2693 _ATLTRY
2694 {
2698 }
2700 {
2701 }
2703 }
2705 // Call this function to look up the value of a name-value pair applied to this cookie.
2706 // Returns the requested value if present or NULL if the name was not found.
2708 {
2713 {
2716 }
2719 {
2725 }
2728 }
2730 // Call this function to clear the cookie of all content
2731 // including name, value, name-value pairs, and attributes.
2733 {
2738 }
2740 // Call this function to create a CCookie from a buffer.
2741 // The passed in buffer contains a cookie header retrieved
2742 // from the HTTP_COOKIE request variable
2744 {
2749 // could be just a value or could be an array of name=value pairs
2755 {
2757 pEnd++;
2760 {
2765 {
2766 pEnd++;
2769 }
2771 }
2773 {
2774 // we have name=value
2776 {
2778 }
2779 else
2780 {
2781 pEnd++;
2784 }
2786 // skip '=' and go for value
2787 pEnd++;
2790 pEnd++;
2797 pEnd++;
2800 }
2801 }
2804 }
2806 // Call this function to render this cookie
2807 // into a buffer. Returns TRUE on success, FALSE on failure.
2808 // On entry, pdwLen should point to a DWORD that indicates
2809 // the size of the buffer in bytes. On exit, the DWORD contains
2810 // the number of bytes transferred or available to be transferred
2811 // into the buffer (including the nul-terminating byte). On
2812 // success, the buffer will contain the correct HTTP
2813 // representation of the current cookie suitable for sending to
2814 // a client as the body of a Set-Cookie header.
2815 __success(return==true) ATL_NOINLINE __checkReturn BOOL Render(__out_ecount_part_opt(*pdwLen,*pdwLen) LPSTR szCookieBuffer, __inout DWORD *pdwLen) const throw()
2816 {
2819 CStringA strCookie;
2824 // A cookie must have a name!
2826 {
2829 }
2830 _ATLTRY
2831 {
2835 {
2839 {
2843 {
2846 }
2849 }
2850 }
2851 else
2852 {
2856 }
2858 CStringA strAttributes;
2862 {
2865 }
2872 // see if buffer is big enough
2876 // copy the buffer
2878 }
2880 {
2882 }
2884 }
2887 {
2889 }
2892 {
2894 }
2897 {
2899 }
2903 {
2904 _ATLTRY
2905 {
2907 }
2909 {
2911 }
2913 }
2916 {
2918 }
2921 {
2923 }
2926 {
2928 }
2932 {
2933 _ATLTRY
2934 {
2936 }
2938 {
2940 }
2942 }
2945 // Implementation
2947 {
2948 _ATLTRY
2949 {
2955 {
2962 }
2963 }
2965 {
2967 }
2969 }
2972 {
2978 {
2981 {
2984 }
2985 }
2987 {
2992 {
2995 }
2996 }
2998 }
3000 // Call this function to copy a substring to a CString reference and ensure nul-termination.
3001 void CopyToCString(__out CStringA& string, __in_ecount(pEnd-pStart) LPCSTR pStart, __in LPCSTR pEnd) throw( ... )
3002 {
3008 }
3012 // These are implementation only, use at your own risk!
3013 // Map of attribute-value pairs applied to this cookie.
3014 mapType m_Attributes;
3016 // Map of name-value pairs applied to this cookie.
3017 mapType m_Values;
3019 // The name of this cookie.
3020 CStringA m_strName;
3022 // The value of this cookie.
3023 CStringA m_strValue;
3028 {
3031 {
3035 }
3038 {
3043 }
3046 {
3049 }
3055 {
3061 {
3063 }
3066 {
3068 }
3071 {
3073 }
3074 };
3077 ///////////////////////////////////////////////////////////////////////////////
3078 // Request and response classes and support functions
3081 // This class is a wrapper for CAtlMap that allows maps to be chained.
3082 // It simply adds a bool that tells whether or not a map shares values
3083 template <typename K, typename V, typename KTraits=CElementTraits<K>, typename VTraits=CElementTraits<V> >
3084 class CHttpMap
3085 {
3088 #ifdef ATL_HTTP_PARAM_MULTIMAP
3090 #else
3107 MAPTYPE m_map;
3113 {
3114 }
3117 {
3118 }
3121 {
3123 }
3126 {
3128 }
3130 //
3131 // exposed lookup and iteration functionality
3132 //
3135 {
3137 }
3140 {
3142 }
3145 {
3146 #ifdef ATL_HTTP_PARAM_MULTIMAP
3148 #else
3151 }
3153 // Lookup wrappers
3155 {
3156 _ATLTRY
3157 {
3158 #ifdef ATL_HTTP_PARAM_MULTIMAP
3161 {
3164 }
3166 #else
3169 }
3171 {
3173 }
3174 }
3177 {
3178 #ifdef ATL_HTTP_PARAM_MULTIMAP
3181 {
3183 }
3185 #else
3188 }
3191 {
3192 #ifdef ATL_HTTP_PARAM_MULTIMAP
3195 {
3197 }
3199 #else
3202 }
3204 // iteration wrappers
3205 void GetNextAssoc( __inout POSITION& pos, __out KOUTARGTYPE key, __out VOUTARGTYPE value ) const throw(...)
3206 {
3208 }
3211 {
3213 }
3216 {
3218 }
3221 {
3223 }
3226 {
3228 }
3231 {
3233 }
3235 void GetAt( __in POSITION pos, __out KOUTARGTYPE key, __out VOUTARGTYPE value ) const throw(...)
3236 {
3238 }
3241 {
3243 }
3246 {
3248 }
3251 {
3253 }
3256 {
3258 }
3261 {
3263 }
3265 // modification wrappers
3267 {
3268 #ifdef ATL_HTTP_PARAM_MULTIMAP
3270 #else
3273 }
3276 {
3277 #ifdef ATL_HTTP_PARAM_MULTIMAP
3279 #else
3282 }
3285 {
3287 }
3288 };
3290 // This class is a wrapper for CHttpMap that assumes it's values are pointers that
3291 // should be deleted on RemoveAll
3292 template <typename K, typename V, typename KTraits=CElementTraits<K>, typename VTraits=CElementTraits<V> >
3294 {
3299 {
3301 {
3304 {
3306 }
3307 }
3309 }
3312 {
3314 }
3315 };
3317 // This class represents a collection of request parameters - the name-value pairs
3318 // found, for example, in a query string or in the data provided when a form is submitted to the server.
3319 // Call Parse to build the collection from a string of URL-encoded data.
3320 // Use the standard collection methods of the CHttpMap base class to retrieve the
3321 // decoded names and values.
3322 // Use the methods of the CValidateObject base class to validate the parameters.
3324 #if (defined(ATL_HTTP_PARAM_MAP_CASEINSENSITIVE))
3325 public CHttpMap<CStringA, CStringA, CStringElementTraitsI<CStringA>, CStringElementTraitsI<CStringA> >,
3326 #else
3327 public CHttpMap<CStringA, CStringA, CStringElementTraits<CStringA>, CStringElementTraits<CStringA> >,
3328 #endif
3330 {
3332 #if (defined(ATL_HTTP_PARAM_MAP_CASEINSENSITIVE))
3333 typedef CHttpMap<CStringA, CStringA, CStringElementTraitsI<CStringA>, CStringElementTraitsI<CStringA> > BaseMap;
3334 #else
3335 typedef CHttpMap<CStringA, CStringA, CStringElementTraits<CStringA>, CStringElementTraits<CStringA> > BaseMap;
3336 #endif
3339 {
3340 _ATLTRY
3341 {
3347 {
3349 }
3350 }
3352 {
3353 }
3355 }
3357 // Call this function to build a collection of name-value pairs from a string of URL-encoded data.
3358 // Returns TRUE on success, FALSE on failure.
3359 // URL-encoded data:
3360 // Each name-value pair is separated from the next by an ampersand (&)
3361 // Each name is separated from its corresponding value by an equals signs (=)
3362 // The end of the data to be parsed is indicated by a nul character (\0) or a pound symbol (#)
3363 // A plus sign (+) in the input will be decoded as a space
3364 // A percent sign (%) in the input signifies the start of an escaped octet.
3365 // The next two digits represent the hexadecimal code of the character.
3366 // For example, %21 is the escaped encoding for the US-ASCII exclamation mark and will be decoded as !.
3367 // Common sources of URL-encoded data are query strings and the bodies of POST requests with content type of application/x-www-form-urlencoded.
3368 //
3369 // Parse and Render are complementary operations.
3370 // Parse creates a collection from a string.
3371 // Render creates a string from a collection.
3373 {
3375 {
3378 LPSTR szPropValue;
3381 {
3383 {
3384 szQueryString++;
3386 }
3388 {
3390 }
3394 {
3395 // if there is a % without two characters
3396 // at the end of the url we skip it
3398 {
3403 {
3405 }
3408 }
3409 else
3411 }
3412 else
3415 szQueryString++;
3416 szUrlCurrent++;
3417 }
3420 {
3422 szQueryString++;
3424 }
3425 else
3426 {
3430 // we have the property name
3433 {
3435 {
3436 szQueryString++;
3438 }
3442 {
3443 // if there is a % without two characters
3444 // at the end of the url we skip it
3446 {
3451 {
3453 }
3456 }
3457 else
3459 }
3460 else
3462 szQueryString++;
3463 szUrlCurrent++;
3464 }
3465 // we have the value
3467 szUrlCurrent++;
3468 }
3470 _ATLTRY
3471 {
3473 }
3475 {
3477 }
3478 }
3480 }
3482 // Call this function to render the map of names and values into a buffer as a URL-encoded string.
3483 // Returns TRUE on success, FALSE on failure.
3484 // On entry, pdwLen should point to a DWORD that indicates the size of the buffer in bytes.
3485 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
3486 // On success, the buffer will contain the correct URL-encoded representation of the current object
3487 // suitable for sending to a server as a query string or in the body of a form.
3488 // URL-encoding:
3489 // Each name-value pair is separated from the next by an ampersand (&)
3490 // Each name is separated from its corresponding value by an equals signs (=)
3491 // A space is encoded as a plus sign (+).
3492 // Other unsafe characters (as determined by AtlIsUnsafeUrlChar) are encoded as escaped octets.
3493 // An escaped octet is a percent sign (%) followed by two digits representing the hexadecimal code of the character.
3494 //
3495 // Parse and Render are complementary operations.
3496 // Parse creates a collection from a string.
3497 // Render creates a string from a collection.
3498 ATL_NOINLINE __checkReturn BOOL Render(__out_ecount(pdwLen) LPSTR szParameters, __inout LPDWORD pdwLen)
3499 {
3502 _ATLTRY
3503 {
3505 {
3509 }
3511 CStringA strParams;
3514 {
3519 {
3522 }
3525 }
3531 {
3533 }
3534 else
3535 {
3536 dwLen--;
3539 }
3543 }
3545 {
3547 }
3548 }
3552 #ifndef MAX_TOKEN_LENGTH
3553 #define MAX_TOKEN_LENGTH (MAX_PATH)
3554 #endif
3556 // This class represents the information about a file that has been uploaded to the web server.
3558 {
3561 // The name of the form field used to upload the file.
3564 // The original file name of the uploaded file as set by the client.
3567 // The original path and file name of the uploaded file as set by the client.
3570 // The MIME type of the uploaded file.
3573 // The name of the uploaded file on the server.
3576 // The size of the file in bytes.
3577 ULONGLONG m_nFileSize;
3582 {
3588 }
3591 __in_opt LPCSTR pParamName,
3592 __in LPCSTR pFileName,
3593 __in_opt LPCSTR pTempFileName,
3594 __in_opt LPCSTR pContentType,
3596 {
3600 {
3601 // path too long
3603 }
3606 {
3608 {
3609 // string too long
3611 }
3612 }
3615 {
3617 {
3618 // path too long
3620 }
3621 }
3624 {
3626 {
3627 // string too long
3629 }
3630 }
3632 // Set m_szFileName to be the file name without the path.
3633 // This is likely to be the most meaningful part of the
3634 // original file name once the file reaches the server.
3640 {
3642 {
3644 }
3645 else
3646 {
3648 {
3650 }
3652 }
3653 szTmp++;
3654 }
3656 {
3658 }
3663 }
3666 //=======================================
3667 // IHttpFile interface
3668 //=======================================
3670 {
3672 }
3675 {
3677 }
3680 {
3682 }
3685 {
3687 }
3690 {
3692 }
3695 {
3697 }
3700 {
3702 }
3707 // utility function to ReadData from a ServerContext
3708 ATL_NOINLINE inline
3709 __checkReturn BOOL ReadClientData(__inout IHttpServerContext *pServerContext, __out_ecount_part(*pdwLen,*pdwLen) LPSTR pbDest, __inout LPDWORD pdwLen, __in DWORD dwBytesRead)
3710 {
3715 _ATLTRY
3716 {
3721 // Read from available data first
3723 {
3732 }
3736 // If there is still more to read after the available data is exhausted
3738 {
3742 // keep on reading until we've read the amount requested
3743 do
3744 {
3747 {
3749 }
3757 }
3760 }
3762 {
3764 }
3767 }
3769 #ifndef MAX_MIME_BOUNDARY_LEN
3770 #define MAX_MIME_BOUNDARY_LEN 128
3771 #endif
3773 enum ATL_FORM_FLAGS
3774 {
3780 };
3782 // Use this class to read multipart/form-data from the associated server context
3783 // and generate files as necessary from the data in the body of the request.
3784 class CMultiPartFormParser
3785 {
3788 LPSTR m_pCurrent;
3789 LPSTR m_pEnd;
3790 LPSTR m_pStart;
3792 DWORD m_dwBoundaryLen;
3793 BOOL m_bFinished;
3807 {
3809 }
3812 {
3813 _ATLTRY
3814 {
3815 // free memory if necessary
3817 {
3819 }
3820 }
3822 {
3823 }
3824 }
3826 // Call this function to read multipart/form-data from the current HTTP request,
3827 // allowing files to be uploaded to the web server.
3828 //
3829 // Returns TRUE on success, FALSE on failure.
3830 //
3831 // Forms can be sent to a web server using one of two encodings: application/x-www-form-urlencoded or multipart/form-data.
3832 // In addition to the simple name-value pairs typically associated with
3833 // application/x-www-form-urlencoded form data, multipart/form-data (as
3834 // described in RFC 2388) can also contain files to be uploaded
3835 // to the web server.
3836 //
3837 // This function will generate a physical file for each file contained in the multipart/form-data request body.
3838 // The generated files are stored in the server's temporary directory as returned by the
3839 // GetTempPath API and are named using the GetTempFileName API.
3840 // The information about each file can be obtained from the elements of the Files array.
3841 // You can retrieve the original name of the file on the client, the name of the generated file on the server,
3842 // the MIME content type of the uploaded file, the name of the form field associated with that file, and the size in
3843 // bytes of the file. All this information is exposed by the CHttpRequestFile objects in the array.
3844 //
3845 // In addition to generating files and populating the Files array with information about them,
3846 // this function also populates the pQueryParams array with the names and values of the other form fields
3847 // contained in the current request. The file fields are also added to this array. The value of these fields
3848 // is the full name of the generated file on the server.
3849 //
3850 // Note that files can be generated even if this function returns FALSE unless you specify either the
3851 // ATL_FORM_FLAG_IGNORE_FILES or the ATL_FORM_FLAG_REFUSE_FILES flag. If you don't specify one of these
3852 // flags, you should always check the Files array for generated files and delete any that are no longer
3853 // needed to prevent your web server from running out of disk space.
3854 //
3855 // dwFlags can be a combination of one or more of the following values:
3856 // ATL_FORM_FLAG_NONE Default behavior.
3857 // ATL_FORM_FLAG_IGNORE_FILES Any attempt to upload files is ignored.
3858 // ATL_FORM_FLAG_REFUSE_FILES Any attempt to upload files is treated as a failure. The function will return FALSE.
3859 // ATL_FORM_FLAG_IGNORE_EMPTY_FILES Files with a size of zero bytes are ignored.
3860 // ATL_FORM_FLAG_IGNORE_EMPTY_FIELDS Fields with no content are ignored.
3865 {
3866 _ATLTRY
3867 {
3869 {
3871 }
3873 //Get to the first boundary
3875 {
3877 }
3879 CStringA strParamName;
3880 CStringA strFileName;
3881 CStringA strContentType;
3882 CStringA strData;
3883 BOOL bFound;
3886 {
3887 // look for "name" field
3889 {
3892 }
3894 // see if it's a file
3896 {
3899 }
3902 {
3904 {
3906 }
3909 {
3911 {
3913 }
3915 }
3918 {
3921 }
3923 // move to the actual uploaded data
3925 {
3928 }
3930 // if the user doesn't want files, don't save the file
3932 {
3934 {
3936 }
3938 }
3940 CAtlTemporaryFile ctf;
3946 {
3949 }
3955 {
3958 }
3966 {
3968 }
3970 if (!spFile->Initialize(strParamName, strFileName, szTempFileNameA, strContentType, nFileSize))
3971 {
3972 // one of the strings was too long
3974 }
3977 {
3979 }
3984 {
3986 }
3991 }
3993 // move to the actual uploaded data
3995 {
3998 }
4001 {
4003 }
4009 {
4011 }
4013 }
4016 }
4018 {
4020 }
4021 }
4025 // implementation
4027 // case insensitive substring search -- does not handle multibyte characters (unlike tolower)
4028 // allows searching up to a maximum point in a string
4030 {
4032 {
4034 }
4037 }
4040 {
4050 {
4055 {
4057 }
4060 {
4062 }
4064 cp++;
4065 }
4068 }
4071 inline __checkReturn char * _stristrex (__in const char * str1, __in const char * str2, __in const char * str1End)
4072 {
4082 {
4087 {
4089 }
4092 {
4094 }
4097 {
4099 }
4101 cp++;
4102 }
4105 }
4107 inline __checkReturn char * _strstrex (__in const char * str1, __in const char * str2, __in const char * str1End)
4108 {
4118 {
4123 {
4125 }
4128 {
4130 }
4133 {
4135 }
4137 cp++;
4138 }
4141 }
4144 {
4147 _ATLTRY
4148 {
4151 // if greater than bytes available, allocate necessary space
4153 {
4156 {
4158 }
4162 {
4164 }
4165 }
4166 else
4167 {
4169 }
4174 //get the boundary
4180 {
4183 }
4188 {
4190 pszTmp++;
4191 }
4198 {
4200 {
4203 }
4206 {
4208 {
4209 pszTmp++;
4211 }
4213 }
4215 {
4217 }
4220 m_dwBoundaryLen++;
4221 }
4224 }
4226 {
4228 }
4231 }
4234 {
4237 {
4239 }
4243 {
4245 }
4248 }
4250 inline __checkReturn BOOL GetMimeData(__inout CStringA &str, __in_ecount(dwFieldLen) LPCSTR szField, __in DWORD dwFieldLen, __out LPBOOL pbFound, __in BOOL bIgnoreCase = FALSE) throw()
4251 {
4252 _ATLTRY
4253 {
4261 {
4263 }
4268 {
4270 }
4271 else
4272 {
4274 }
4277 {
4280 {
4282 }
4286 {
4288 szDataStart++;
4289 }
4293 {
4294 szDataEnd++;
4295 }
4298 {
4300 }
4303 {
4305 {
4307 {
4309 }
4310 }
4311 szDataEnd++;
4312 }
4315 {
4317 }
4321 }
4324 }
4326 {
4328 }
4329 }
4331 ATL_NOINLINE __checkReturn BOOL ReadUntilBoundary(__inout_opt CStringA* pStrData=NULL, __inout_opt CAtlTemporaryFile* pCtf=NULL) throw()
4332 {
4333 _ATLTRY
4334 {
4338 do
4339 {
4342 {
4344 {
4346 {
4347 szBoundaryStart++;
4349 }
4350 }
4353 {
4355 }
4357 {
4359 }
4361 {
4364 }
4365 szBoundaryStart++;
4366 }
4370 {
4372 }
4375 {
4377 }
4379 {
4381 }
4383 {
4385 {
4387 }
4388 }
4391 {
4394 {
4396 }
4397 }
4400 }
4402 {
4404 }
4405 }
4408 {
4418 {
4420 }
4423 }
4426 {
4428 }
4431 // Prevents copying.
4433 {
4435 }
4438 {
4441 }
4445 // 48K max form size
4446 #ifndef DEFAULT_MAX_FORM_SIZE
4447 #define DEFAULT_MAX_FORM_SIZE 49152
4448 #endif
4450 // This class provides access to the information contained in an HTTP request submitted to a web server.
4451 //
4452 // CHttpRequest provides access to the query string parameters, form fields, cookies, and files
4453 // that make up an HTTP request, as well as many other important properties of the request.
4455 {
4457 // Implementation: Array used to map an HTTP request method (for example, "GET" or "POST")
4458 // from a string to a numeric constant from the HTTP_METHOD enum (HTTP_METHOD_GET or HTTP_METHOD_HEAD).
4461 // Implementation: The server context.
4464 // Implementation: The number of bytes read from the body of the request.
4465 DWORD m_dwBytesRead;
4467 // Implementation: TRUE if the request method was POST and the encoding was
4468 // multipart/form-data, FALSE otherwise.
4469 BOOL m_bMultiPart;
4471 CCookie m_EmptyCookie;
4473 // Implementation: Constructor function used to reinitialize all data members.
4475 {
4488 }
4491 {
4496 }
4500 // Implementation: The collection of query parameters (name-value pairs) obtained from the query string.
4501 CHttpRequestParams m_QueryParams;
4503 // Implementation: The collection of form fields (name-value pairs).
4504 // The elements of this collection are obtained from the query string for a GET request,
4505 // or from the body of the request for a POST request.
4508 // The array of CHttpRequestFiles obtained from the current request.
4509 // See CHttpRequest::Initialize and CMultiPartFormParser::GetMultiPartData for more information.
4511 FileMap m_Files;
4513 // Implementation: The array of cookies obtained from the current request.
4515 CookieMap m_requestCookies;
4517 // Numeric constants for the HTTP request methods (such as GET and POST).
4518 enum HTTP_METHOD
4519 {
4521 HTTP_METHOD_GET,
4522 HTTP_METHOD_POST,
4523 HTTP_METHOD_HEAD,
4524 HTTP_METHOD_DELETE,
4525 HTTP_METHOD_LINK,
4526 HTTP_METHOD_UNLINK,
4527 HTTP_METHOD_DEBUG // Debugging support for VS7
4528 };
4530 // The collection of query parameters (name-value pairs) obtained from the query string.
4531 // A read-only property.
4534 // Returns a reference to the collection of query parameters(name-value pairs)
4535 // obtained from the query string.
4537 {
4539 }
4541 // The collection of form fields (name-value pairs).
4542 // The elements of this collection are obtained from the query string for a GET request,
4543 // or from the body of the request for a POST request.
4544 // A read-only property.
4547 // Returns a reference to the collection of form fields (name-value pairs)
4548 // obtained from the query string for a GET request,
4549 // or from the body of the request for a POST request.
4551 {
4553 }
4556 {
4560 }
4563 {
4567 {
4570 }
4571 }
4573 // Constructs and initializes the object.
4579 {
4583 }
4587 {
4590 }
4592 //=========================================================================================
4593 // BEGIN IHttpRequestLoookup interface
4594 //=========================================================================================
4595 __success(return != NULL) __checkReturn POSITION GetFirstQueryParam(__deref_out LPCSTR *ppszName, __deref_out LPCSTR *ppszValue)
4596 {
4599 {
4604 }
4607 }
4609 __success(return != NULL) __checkReturn POSITION GetNextQueryParam(__in POSITION pos, __deref_out LPCSTR *ppszName, __deref_out LPCSTR *ppszValue)
4610 {
4617 {
4622 }
4625 }
4627 __success(return != NULL) __checkReturn POSITION GetFirstFormVar(__deref_out LPCSTR *ppszName, __deref_out LPCSTR *ppszValue)
4628 {
4629 // if no form vars and just pointing to the query params,
4630 // then return NULL
4636 {
4641 }
4644 }
4646 __success(return != NULL) __checkReturn POSITION GetNextFormVar(__in POSITION pos, __deref_out LPCSTR *ppszName, __deref_out LPCSTR *ppszValue)
4647 {
4655 {
4658 }
4661 }
4664 {
4670 {
4673 }
4676 }
4678 __success(return != NULL) __checkReturn POSITION GetNextFile(__in POSITION pos, __deref_out LPCSTR *ppszName, __deref_out IHttpFile **ppFile)
4679 {
4686 {
4689 }
4692 }
4694 // Returns a pointer to the IHttpServerContext interface for the current request.
4696 {
4698 }
4699 //=========================================================================================
4700 // END IHttpRequestLookup interface
4701 //=========================================================================================
4703 __success(return != NULL) __checkReturn POSITION GetFirstCookie(__deref_out LPCSTR *ppszName, __deref_out const CCookie **ppCookie) throw()
4704 {
4709 {
4712 {
4715 }
4716 }
4718 }
4720 __success(return != NULL) __checkReturn POSITION GetNextCookie(__in POSITION pos, __deref_out LPCSTR *ppszName, __deref_out const CCookie **ppCookie) throw()
4721 {
4729 {
4732 }
4734 }
4737 {
4739 }
4742 {
4743 _ATLTRY
4744 {
4746 // if there's no pRequestLookup, just return
4758 // Initialize query params from the IHttpRequestLookup*
4761 {
4764 }
4767 // Initialize the form vars from the IHttpRequestLookup*
4770 {
4777 {
4780 }
4782 }
4783 else
4784 {
4786 }
4788 // Initialize the files from the IHttpRequestLookup*
4792 {
4795 }
4798 // Initialzie the cookies form the IHttpRequestLookup*
4800 CStringA strCookies;
4803 {
4805 }
4810 {
4811 }
4813 }
4815 // Call this function to initialize the object with information about the current request.
4816 //
4817 // Returns TRUE on success, FALSE on failure.
4818 //
4819 // Call Initialize directly or via the appropriate constructor before using the methods and
4820 // properties of the request object.
4821 //
4822 // Initialize does the following:
4823 //
4824 // Parses and decodes the query string into a collection of name-value pairs.
4825 // This collection is accessible via the GetQueryParams method or the QueryParams property.
4826 //
4827 // Sets m_bMultiPart to TRUE if the request is a POST request with multipart/form-data encoding.
4828 //
4829 // Parses the body of a POST request if the size of the request data is less than or equal to dwMaxFormSize.
4830 // The body of the request will consist of simple form fields and may also contain files if the request is encoded as multipart/form-data.
4831 // In that case, the dwFlags parameter is passed to CMultiPartFormParser::GetMultiPartData to control the creation of the files.
4832 // The collection of form fields is accessible via the GetFormVars method or the FormVars property.
4833 // The collection of files is accessible via the m_Files member.
4834 //
4835 // Note that Initialize does not parse the cookies associated with a request.
4836 // Cookies are not processed until an attempt is made to access a cookie in the collection.
4841 {
4842 _ATLTRY
4843 {
4846 {
4848 }
4855 {
4856 // Parse the query string.
4859 {
4861 }
4864 {
4866 }
4867 }
4870 {
4872 }
4874 // If this is a GET request, the collection of form fields
4875 // is the same as the collection of query parameters.
4877 {
4880 }
4882 {
4887 // Don't parse the form data if the size is bigger than the maximum specified.
4889 {
4896 }
4898 // If POSTed data is urlencoded, call InitFromPost.
4899 if (strncmp(szContentType, "application/x-www-form-urlencoded", 33) == 0 && !m_pFormVars->IsShared())
4902 // If POSTed data is encoded as multipart/form-data, use CMultiPartFormParser.
4904 {
4916 }
4918 // else initialize m_dwBytesRead for ReadData
4920 }
4923 }
4925 {
4926 }
4929 }
4931 // Implementation: Call this function to initialize the collection of form fields
4932 // from the body of an application/x-www-form-urlencoded POST request.
4934 {
4935 _ATLTRY
4936 {
4939 // create our m_pFormVars
4941 {
4944 {
4946 }
4947 }
4949 // read the form data into a buffer
4953 {
4955 }
4957 {
4959 }
4960 // first copy the available
4963 {
4966 }
4969 }
4971 {
4972 }
4974 }
4976 // Call this function to remove the files listed in m_Files from the web server's hard disk.
4977 // Returns the number of files deleted.
4979 {
4983 {
4986 {
4987 nDeleted++;
4988 }
4990 }
4993 }
4995 // Read a specified amount of data into pbDest and return the bytes read in pdwLen.
4996 // Returns TRUE on success, FALSE on failure.
4998 {
5006 }
5008 // Returns the number of bytes available in the request buffer accessible via GetAvailableData.
5009 // If GetAvailableBytes returns the same value as GetTotalBytes, the request buffer contains the whole request.
5010 // Otherwise, the remaining data should be read from the client using ReadData.
5011 // Equivalent to EXTENSION_CONTROL_BLOCK::cbAvailable.
5013 {
5016 }
5018 // Returns the total number of bytes to be received from the client.
5019 // If this value is 0xffffffff, then there are four gigabytes or more of available data.
5020 // In this case, ReadData should be called until no more data is returned.
5021 // Equivalent to the CONTENT_LENGTH server variable or EXTENSION_CONTROL_BLOCK::cbTotalBytes.
5023 {
5026 }
5028 // Returns a pointer to the request buffer containing the data sent by the client.
5029 // The size of the buffer can be determined by calling GetAvailableBytes.
5030 // Equivalent to EXTENSION_CONTROL_BLOCK::lpbData
5032 {
5035 }
5038 // Returns a nul-terminated string that contains the query information.
5039 // This is the part of the URL that appears after the question mark (?).
5040 // Equivalent to the QUERY_STRING server variable or EXTENSION_CONTROL_BLOCK::lpszQueryString.
5042 {
5045 }
5047 // Returns a nul-terminated string that contains the HTTP method of the current request.
5048 // Examples of common HTTP methods include "GET" and "POST".
5049 // Equivalent to the REQUEST_METHOD server variable or EXTENSION_CONTROL_BLOCK::lpszMethod.
5051 {
5054 }
5056 // Returns an HTTP_METHOD enum value corresponding to the HTTP method of the current request.
5057 // Returns HTTP_METHOD_UNKNOWN if the request method is not one of the following methods:
5058 // GET
5059 // POST
5060 // HEAD
5061 // DELETE
5062 // LINK
5063 // UNLINK
5065 {
5070 {
5073 }
5075 }
5077 // Returns a nul-terminated string that contains the content type of the data sent by the client.
5078 // Equivalent to the CONTENT_TYPE server variable or EXTENSION_CONTROL_BLOCK::lpszContentType.
5080 {
5083 }
5086 // Call this function to retrieve a nul-terminated string containing the value of the "AUTH_USER" server variable.
5087 //
5088 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5089 //
5090 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5091 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5092 __checkReturn BOOL GetAuthUserName(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5093 {
5096 }
5098 // Call this function to retrieve a nul-terminated string containing the value of the "APPL_PHYSICAL_PATH" server variable.
5099 //
5100 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5101 //
5102 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5103 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5104 __checkReturn BOOL GetPhysicalPath(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5105 {
5108 }
5110 // Call this function to retrieve a nul-terminated string containing the value of the "AUTH_PASSWORD" server variable.
5111 //
5112 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5113 //
5114 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5115 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5116 __checkReturn BOOL GetAuthUserPassword(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5117 {
5120 }
5122 // Call this function to retrieve a nul-terminated string containing the value of the "URL" server variable.
5123 //
5124 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5125 //
5126 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5127 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5128 __checkReturn BOOL GetUrl(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, DWORD *pdwSize) throw(...)
5129 {
5132 }
5134 // Call this function to retrieve a nul-terminated string containing the value of the "REMOTE_HOST" server variable.
5135 //
5136 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5137 //
5138 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5139 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5140 __checkReturn BOOL GetUserHostName(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5141 {
5144 }
5146 // Call this function to retrieve a nul-terminated string containing the value of the "REMOTE_ADDR" server variable.
5147 //
5148 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5149 //
5150 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5151 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5152 __checkReturn BOOL GetUserHostAddress(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5153 {
5156 }
5158 // Call this function to retrieve a nul-terminated string containing the physical path of the script.
5159 //
5160 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5161 //
5162 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5163 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5164 // The script path is the same as GetPathTranslated up to the first .srf or .dll.
5165 // For example, if GetPathTranslated returns "c:\inetpub\vcisapi\hello.srf\goodmorning",
5166 // then this function returns "c:\inetpub\vcisapi\hello.srf".
5168 {
5171 }
5173 // Returns a nul-terminated string that contains the physical path of the requested resource on the local server.
5174 // Equivalent to the PATH_TRANSLATED server variable or EXTENSION_CONTROL_BLOCK::lpszPathTranslated.
5176 {
5179 }
5181 // Returns a nul-terminated string that contains the path of the current request.
5182 // This is the part of the URL that appears after the server name, but before the query string.
5183 // Equivalent to the PATH_INFO server variable or EXTENSION_CONTROL_BLOCK::lpszPathInfo.
5185 {
5188 }
5190 // Call this function to determine whether the current request was authenticated.
5192 {
5193 // We assume that if we get an authentication type from IIS,
5194 // then the user has been authenticated.
5195 CStringA strAuthType;
5201 }
5203 // Call this function to retrieve a nul-terminated string containing the value of the "AUTH_TYPE" server variable.
5204 //
5205 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5206 //
5207 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5208 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5209 __checkReturn BOOL GetAuthenticationType(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5210 {
5213 }
5215 // Call this function to retrieve a nul-terminated string containing the value of the "REMOTE_USER" server variable.
5216 //
5217 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5218 //
5219 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5220 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5221 __checkReturn BOOL GetUserName(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, DWORD __inout *pdwSize) throw(...)
5222 {
5225 }
5227 // Call this function to retrieve a nul-terminated string containing the value of the "HTTP_USER_AGENT" server variable.
5228 //
5229 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5230 //
5231 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5232 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5233 __checkReturn BOOL GetUserAgent(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5234 {
5237 }
5239 // Call this function to retrieve a nul-terminated string containing the value of the "HTTP_ACCEPT_LANGUAGE" server variable.
5240 //
5241 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5242 //
5243 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5244 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5245 __checkReturn BOOL GetUserLanguages(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5246 {
5249 }
5251 // Call this function to retrieve a nul-terminated string containing the value of the "HTTP_ACCEPT" server variable.
5252 //
5253 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5254 //
5255 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5256 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5257 __checkReturn BOOL GetAcceptTypes(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5258 {
5261 }
5263 // Call this function to retrieve a nul-terminated string containing the value of the "HTTP_ACCEPT_ENCODING" server variable.
5264 //
5265 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5266 //
5267 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5268 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5269 __checkReturn BOOL GetAcceptEncodings(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5270 {
5273 }
5276 // Call this function to retrieve a nul-terminated string containing the value of the "HTTP_REFERER" server variable.
5277 //
5278 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5279 //
5280 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5281 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5282 __checkReturn BOOL GetUrlReferer(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5283 {
5286 }
5288 // Call this function to retrieve a nul-terminated string containing the value of the "SCRIPT_NAME" server variable.
5289 //
5290 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5291 //
5292 // On entry, pdwSize should point to a DWORD that indicates the size of the buffer in bytes.
5293 // On exit, the DWORD contains the number of bytes transferred or available to be transferred into the buffer (including the nul-terminating byte).
5294 __checkReturn BOOL GetScriptName(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuff, __inout DWORD *pdwSize) throw(...)
5295 {
5298 }
5300 // Fills a buffer with the contents of the HTTP_COOKIE headers sent
5301 // from the browser.
5302 __checkReturn BOOL GetCookies(__out_ecount_part(*pdwSize,*pdwSize) LPSTR szBuf, __inout LPDWORD pdwSize) const throw(...)
5303 {
5306 CStringA strCookie;
5308 {
5311 {
5315 }
5316 }
5318 }
5320 // Fills a CStringA with the contents of the HTTP_COOKIE headers sent
5321 // from the browser.
5323 {
5325 }
5327 // Call this function to retrieve a reference to the specified cookie.
5328 // Returns a CCookie reference to the specified cookie or a
5329 // reference to an empty cookie if the name can not be found.
5331 {
5333 {
5334 // p->m_value is a const CCookie&
5338 {
5340 }
5341 }
5344 }
5347 // Call this function to retrieve the session cookie.
5349 {
5351 }
5353 // Call this function to retrieve the value of the requested server variable in a CStringA object.
5354 // Returns TRUE on success, and FALSE on failure. Call GetLastError to get extended error information.
5355 // Equivalent to EXTENSION_CONTROL_BLOCK::GetServerVariable.
5357 {
5362 _ATLTRY
5363 {
5367 dwSize--;
5369 }
5371 {
5373 }
5375 }
5377 // Call this function to retrieve the value of the "APPL_PHYSICAL_PATH" server variable.
5378 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5380 {
5382 }
5384 // Call this function to retrieve the value of the "REMOTE_HOST" server variable.
5385 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5387 {
5389 }
5391 // Call this function to retrieve the value of the "REMOTE_ADDR" server variable.
5392 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5394 {
5396 }
5398 // Call this function to retrieve the value of the "AUTH_TYPE" server variable.
5399 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5401 {
5403 }
5405 // Call this function to retrieve the value of the "REMOTE_USER" server variable.
5406 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5408 {
5410 }
5412 // Call this function to retrieve the value of the "HTTP_USER_AGENT" server variable.
5413 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5415 {
5417 }
5419 // Call this function to retrieve the value of the "HTTP_ACCEPT_LANGUAGE" server variable.
5420 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5422 {
5424 }
5426 // Call this function to retrieve the value of the "AUTH_USER" server variable.
5427 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5429 {
5431 }
5433 // Call this function to retrieve the value of the "AUTH_PASSWORD" server variable.
5434 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5436 {
5438 }
5440 // Call this function to retrieve the value of the "URL" server variable.
5441 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5443 {
5445 }
5447 // Call this function to retrieve the value of the "HTTP_ACCEPT" server variable.
5448 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5450 {
5452 }
5454 // Call this function to retrieve the value of the "HTTP_ACCEPT_ENCODING" server variable.
5455 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5457 {
5459 }
5461 // Call this function to retrieve the value of the "HTTP_REFERER" server variable.
5462 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5464 {
5466 }
5468 // Call this function to retrieve the value of the "SCRIPT_NAME" server variable.
5469 // Returns TRUE on success, FALSE on failure. Call GetLastError to get extended error information.
5471 {
5473 }
5475 // Implementation: Call this function to populate the collection
5476 // of CCookie objects with the cookies in the current request.
5477 // Returns TRUE on success, FALSE on failure.
5479 {
5485 CStringA strCookies;
5487 {
5489 }
5491 }
5494 struct Pair
5495 {
5497 {
5500 }
5503 {
5506 }
5508 CStringA name;
5509 CStringA value;
5510 };
5514 // Implementation: Call this function to populate m_requestCookies
5515 // with a collection of CCookie objects which represents the
5516 // cookies contained in szCookie header sent from the browser.
5518 {
5521 LPCSTR szStart;
5522 LPCSTR szEnd;
5526 // create a list of name=value pairs
5527 // these are separated by or ;
5531 {
5540 szEnd++;
5543 {
5545 {
5546 szEnd++;
5549 }
5552 }
5556 {
5557 // no value expected;
5560 }
5562 {
5566 szEnd++;
5569 {
5571 {
5572 szEnd++;
5575 }
5579 }
5584 }
5585 }
5587 // now make cookies out of the list
5588 // The first item could be $Version, which would
5589 // be the version for all cookies in the list.
5590 // any other $Version's found in the list will be ignored.
5594 // check for $Version
5598 {
5604 }
5608 CCookie cookie;
5611 {
5614 {
5617 else
5618 {
5619 //add attribute to current cookie
5621 {
5623 }
5624 }
5625 }
5626 else
5627 {
5629 {
5635 }
5636 else
5637 {
5638 // add previous cookie
5639 CStringA strPrevName;
5641 {
5643 }
5646 // empty current cookie and start over
5653 }
5654 }
5655 }
5658 {
5659 CStringA strName;
5661 {
5663 }
5665 }
5668 }
5671 // Call this function to copy a substring to a CString reference and ensure nul-termination.
5672 inline void CopyToCString(__out CStringA& string, __in_ecount(pEnd-pStart) LPCSTR pStart, __in LPCSTR pEnd) throw( ... )
5673 {
5680 }
5683 {
5690 }
5694 __success(SUCCEEDED(return)) __checkReturn HRESULT STDMETHODCALLTYPE QueryInterface(__in REFIID riid, __deref_out void **ppv)
5695 {
5699 {
5703 }
5705 {
5709 }
5711 }
5714 {
5716 }
5719 {
5721 }
5732 NULL
5733 };
5735 // This class provides type conversions via the Write method
5736 // and overloaded left shift << operator for writing
5737 // data to the IWriteStream interface. The IWriteStream interface
5738 // only accepts strings, but this helper class allows you to transparently
5739 // pass many different types by providing automatic type conversions.
5740 //
5741 // Notes on Type Conversions:
5742 // Numeric types are converted to their decimal representations.
5743 // Floating point values are output with a precision of 6 decimal places.
5744 // Currency values are converted according to the locale settings of the current thread.
5745 class CWriteStreamHelper
5746 {
5748 // Implementation: The IWriteStream interface.
5750 UINT m_ulACP;
5755 {
5757 }
5760 {
5763 }
5765 // Attach a IWriteStream
5767 {
5771 }
5773 // Call this function to write data to the IWriteStream interface managed by this object.
5774 // Returns TRUE on success, FALSE on failure.
5776 {
5782 DWORD dwWritten;
5784 }
5786 // Call this function to write data to the IWriteStream interface managed by this object.
5787 // Returns TRUE on success, FALSE on failure.
5789 {
5793 }
5795 // Call this function to write data to the IWriteStream interface managed by this object.
5796 // Returns TRUE on success, FALSE on failure.
5798 {
5802 }
5804 // Call this function to write data to the IWriteStream interface managed by this object.
5805 // Returns TRUE on success, FALSE on failure.
5807 {
5809 }
5811 // Call this function to write data to the IWriteStream interface managed by this object.
5812 // Returns TRUE on success, FALSE on failure.
5814 {
5816 }
5818 // Call this function to write data to the IWriteStream interface managed by this object.
5819 // Returns TRUE on success, FALSE on failure.
5821 {
5825 }
5827 // Call this function to write data to the IWriteStream interface managed by this object.
5828 // Returns TRUE on success, FALSE on failure.
5830 {
5834 }
5836 // Call this function to write data to the IWriteStream interface managed by this object.
5837 // Returns TRUE on success, FALSE on failure.
5839 {
5847 {
5848 // too large
5850 }
5855 {
5859 {
5861 }
5864 }
5868 {
5869 // if the decimal lies at the end of the number
5870 // (no digits to the right of the decimal, we don't
5871 // print it.
5875 nDec--;
5876 p++;
5877 }
5879 }
5881 // Call this function to write data to the IWriteStream interface managed by this object.
5882 // Returns TRUE on success, FALSE on failure.
5884 {
5888 }
5890 // Call this function to write data to the IWriteStream interface managed by this object.
5891 // Returns TRUE on success, FALSE on failure.
5893 {
5897 }
5899 // Call this function to write data to the IWriteStream interface managed by this object.
5900 // Returns TRUE on success, FALSE on failure.
5902 {
5909 {
5910 // prepend ascii zeros
5914 }
5933 {
5936 }
5945 }
5947 // Call this function to write data to the IWriteStream interface managed by this object.
5948 // Returns TRUE on success, FALSE on failure.
5950 {
5953 BOOL bRet;
5955 _ATLTRY
5956 {
5960 {
5962 }
5964 DWORD dwWritten;
5966 }
5968 {
5970 }
5973 }
5975 // Use this operator to write data to the IWriteStream interface managed by this object.
5977 {
5981 }
5983 // Use this operator to write data to the IWriteStream interface managed by this object.
5985 {
5989 }
5991 // Use this operator to write data to the IWriteStream interface managed by this object.
5993 {
5997 }
5999 // Use this operator to write data to the IWriteStream interface managed by this object.
6001 {
6005 }
6007 // Use this operator to write data to the IWriteStream interface managed by this object.
6009 {
6013 }
6015 // Use this operator to write data to the IWriteStream interface managed by this object.
6017 {
6021 }
6023 // Use this operator to write data to the IWriteStream interface managed by this object.
6025 {
6029 }
6031 // Use this operator to write data to the IWriteStream interface managed by this object.
6033 {
6037 }
6039 // Use this operator to write data to the IWriteStream interface managed by this object.
6041 {
6045 }
6047 // Use this operator to write data to the IWriteStream interface managed by this object.
6049 {
6053 }
6055 // Use this operator to write data to the IWriteStream interface managed by this object.
6057 {
6061 }
6064 {
6068 }
6069 };
6073 class CAtlIsapiBuffer
6074 {
6077 LPSTR m_pBuffer;
6078 DWORD m_dwLen;
6079 DWORD m_dwAlloc;
6080 HANDLE m_hProcHeap;
6084 {
6092 }
6095 {
6103 }
6106 {
6108 }
6111 {
6113 {
6115 }
6117 {
6121 }
6124 {
6127 }
6129 }
6132 {
6137 {
6140 {
6142 }
6144 }
6148 {
6152 }
6154 }
6157 {
6159 {
6163 }
6165 }
6168 {
6170 {
6173 }
6174 }
6177 {
6179 }
6182 {
6191 {
6193 }
6195 {
6198 }
6203 }
6206 {
6208 }
6211 {
6215 }
6218 // This class represents the response that the web server will send back to the client.
6219 //
6220 // CHttpResponse provides friendly functions for building up the headers, cookies, and body of an HTTP response.
6221 // The class derives from IWriteStream and CWriteStreamHelper, allowing you to call those classes' methods
6222 // to build up the body of the response. By default, the class improves performance by buffering the response until it is complete before sending it back to the client.
6224 {
6227 // Implementation: A map of HTTP response headers.
6228 // The key is the name of the response header.
6229 // The value is the data for the response header.
6232 // Implementation: Determines whether the response is currently being buffered.
6233 BOOL m_bBufferOutput;
6235 // Implementation: Determines whether any output should be sent to the client.
6236 // Intended mainly for HEAD requests, where the client should get the same headers
6237 // (i.e. Content-Length) as for a GET request
6238 BOOL m_bSendOutput;
6240 // Implementation: The limit in bytes of the response buffer.
6241 // When the limit is reached, the buffer is automatically flushed
6242 // and data is sent to the client. You can set this to ULONG_MAX
6243 // to enable full buffering (this is the default, and is required
6244 // for enabling keep alive connections).
6245 DWORD m_dwBufferLimit;
6247 // Implementation: The server context.
6250 // Implementation: The HTTP status code for the response.
6253 // Implementation: Determines whether the response headers have already been sent to the client.
6254 BOOL m_bHeadersSent;
6256 // Implementation: Handle of the file being transmitted so it can be closed
6257 // when the async I/O completes
6258 HANDLE m_hFile;
6261 // Implementation: The buffer used to store the response before
6262 // the data is sent to the client.
6265 // Numeric constants for the HTTP status codes used for redirecting client requests.
6266 enum HTTP_REDIRECT
6267 {
6275 };
6278 {
6286 }
6289 {
6298 }
6300 // The destructor flushes the buffer if there is content that
6301 // hasn't yet been sent to the client.
6303 {
6307 }
6309 // Call this function to initialize the response object with a pointer to the server context.
6310 // Returns TRUE on success, FALSE on failure.
6312 {
6320 }
6322 // This is called to initialize the CHttpResponse for a child handler. By default, it
6323 // assumes the parent will be responsible for sending the headers.
6325 {
6341 }
6343 // Returns a pointer to the IHttpServerContext interface for the current request.
6345 {
6347 }
6350 {
6353 }
6354 // Call this function to set buffering options for the response.
6355 //
6356 // This function allows you to turn buffering on or off, and to set a size limit
6357 // on the amount of data that will be buffered before being sent to the client.
6358 //
6359 // When you turn off buffering, the current contents of the buffer will be sent to the client.
6360 // If you need to clear the buffer without sending the contents to the client, call ClearContent instead.
6361 //
6362 // When the size of the buffer is reduced below the current size of the buffered content,
6363 // the entire buffer is flushed.
6364 void SetBufferOutput(__in BOOL bBufferOutput, __in DWORD dwBufferLimit=ATL_ISAPI_BUFFER_SIZE) throw()
6365 {
6367 {
6368 // before turning off buffering, flush
6369 // the current contents
6371 }
6375 }
6377 // Call this function to determine whether data written to the response object is being buffered or not.
6378 // Returns TRUE if output is being buffered, FALSE otherwise.
6380 {
6382 }
6384 // Call this function to determine whether the response headers have been sent
6385 // Returns TRUE if headers have been sent, FALSE otherwise.
6387 {
6389 }
6391 // Call this function to override the m_bHeadersSent state. This is useful
6392 // when you want child handlers (e.g. from an include or subhandler) to send the headers
6394 {
6396 }
6398 // Call this function to set a size limit on the amount of data buffered by the reponse object.
6399 // When the size of the buffer is reduced below the current size of the buffered content,
6400 // the entire buffer is flushed.
6401 // See GetBufferLimit.
6403 {
6405 {
6407 {
6408 // new buffer limit is less than the
6409 // size currently buffered. So flush
6410 // the current buffer
6412 }
6413 }
6415 }
6417 // Returns the current size limit of the buffer in bytes.
6418 // See SetBufferLimit.
6420 {
6422 }
6424 // Returns the current value of the Content-Type header if present, otherwise returns NULL.
6426 {
6427 // return the content type from the
6428 // header collection if any
6429 _ATLTRY
6430 {
6436 }
6438 {
6439 }
6441 }
6443 // Call this function to set the Content-Type of the HTTP response.
6444 // Examples of common MIME content types include text/html and text/plain.
6446 {
6447 _ATLTRY
6448 {
6451 }
6453 {
6454 }
6456 }
6458 // Call this function to set the HTTP status code of the response.
6459 // If not set explicitly, the default status code is 200 (OK).
6460 // See GetStatusCode.
6462 {
6464 }
6466 // Returns the current HTTP status code of the response.
6467 // See SetStatusCode.
6469 {
6471 }
6473 // Call this function to set the Cache-Control http header of the response.
6474 // Examples of common Cache-Control header values: public, private, max-age=delta-seconds
6476 {
6477 _ATLTRY
6478 {
6481 }
6483 {
6484 }
6486 }
6488 // Call this function to set the Expires HTTP header to the absolute date/time
6489 // specified in the stExpires parameter
6491 {
6492 _ATLTRY
6493 {
6494 CStringA strExpires;
6499 }
6501 {
6502 }
6504 }
6506 // Call this function to set the Expires HTTP header to a relative date/time
6507 // value specified in minutes;
6509 {
6510 CFileTime ft;
6513 // add the specified number of minutes
6516 SYSTEMTIME st;
6519 }
6521 // Call this function to set whether or not to output to client.
6522 // Intended primarily for HEAD requests
6524 {
6527 }
6529 // Call this function to determine whether or not the data is
6530 // sent to the client. Intended primarily for HEAD requests
6532 {
6534 }
6536 // Call this function to write data to the response object.
6537 //
6538 // Returns S_OK on success, E_INVALIDARG or E_FAIL on failure.
6539 //
6540 // See WriteClient for comments on buffering.
6541 //
6542 // szOut A pointer to the first byte of the data to be written.
6543 //
6544 // nLen The number of bytes to write. If this parameter is -1,
6545 // szOut is assumed to be a nul-terminated string and the
6546 // whole string will be written.
6547 //
6548 // pdwWritten A DWORD pointer that can be used to get the number of bytes written.
6549 // This parameter can be NULL.
6550 __checkReturn HRESULT WriteStream(__in_z LPCSTR szOut, __in int nLen, __out_opt DWORD *pdwWritten)
6551 {
6557 {
6561 }
6564 {
6566 }
6570 }
6572 // Call this function to write data to the response object.
6573 //
6574 // Returns TRUE on success. FALSE on failure.
6575 //
6576 // If buffering is disabled, data is written directly to the client.
6577 // If buffering is enabled, this function attempts to write to the buffer.
6578 // If the buffer is too small to contain its existing data and the new data,
6579 // the current contents of the buffer are flushed.
6580 // If the buffer is still too small to contain the new data, that data is written
6581 // directly to the client. Otherwise the new data is written to the buffer.
6582 //
6583 // Any headers that have been set in the response will be sent just before the
6584 // data is written to the client if no headers have been sent up to that point.
6585 //
6586 // szOut A pointer to the first byte of the data to be written.
6587 //
6588 // nLen The number of bytes to write.
6590 {
6596 {
6598 {
6601 }
6604 }
6611 }
6613 // Call this function to redirect the client to a different resource.
6614 //
6615 // Returns TRUE on success, FALSE on failure.
6616 //
6617 // szURL A nul-terminated string specifying the resource the client should navigate to.
6618 //
6619 // statusCode An HTTP status code from the HTTP_REDIRECT enumeration describing the reason
6620 // for the redirection.
6621 //
6622 // bSendBody Specifies whether to generate and send a response body with the headers.
6623 //
6624 // This function allows (and RFC 2616 encourages) a response body to be sent
6625 // with the following redirect types:
6626 // HTTP_REDIRECT_MOVED
6627 // HTTP_REDIRECT_FOUND
6628 // HTTP_REDIRECT_SEE_OTHER
6629 // HTTP_REDIRECT_TEMPORARY_REDIRECT
6630 // No body will be sent with other redirect types.
6631 //
6632 // The response body contains a short hypertext note with a hyperlink to the new resource.
6633 // A meta refresh tag is also included to allow browsers to automatically redirect
6634 // the user to the resource even if they don't understand the redirect header.
6635 //
6636 // See RFC 2616 section 10.3 for more information on redirection.
6637 BOOL Redirect(__in LPCSTR szUrl, __in HTTP_REDIRECT statusCode=HTTP_REDIRECT_MOVED, __in BOOL bSendBody=TRUE) throw(...)
6638 {
6639 CStringA strBody;
6644 {
6645 _ATLTRY
6646 {
6653 "<body>Please use the following link to access this resource:"
6658 }
6660 {
6662 }
6664 }
6666 }
6668 // Call this function to redirect the client to a different resource.
6669 //
6670 // Returns TRUE on success, FALSE on failure.
6671 //
6672 // szURL A nul-terminated string specifying the resource the client should navigate to.
6673 //
6674 // szBody A nul-terminated string containing the body of the response to be sent to the client.
6675 //
6676 // statusCode An HTTP status code from the HTTP_REDIRECT enumeration describing the reason
6677 // for the redirection.
6678 //
6679 // This function allows (and RFC 2616 encourages) a response body to be sent
6680 // with the following redirect types:
6681 // HTTP_REDIRECT_MOVED
6682 // HTTP_REDIRECT_FOUND
6683 // HTTP_REDIRECT_SEE_OTHER
6684 // HTTP_REDIRECT_TEMPORARY_REDIRECT
6685 // No body will be sent with other redirect types.
6686 //
6687 // The response body should contain a short hypertext note with a hyperlink to the new resource.
6688 // You can include a meta refresh tag to allow browsers to automatically redirect
6689 // the user to the resource even if they don't understand the redirect header.
6690 //
6691 // See RFC 2616 section 10.3 for more information on redirection.
6692 BOOL Redirect(__in LPCSTR szUrl, __in LPCSTR szBody, __in HTTP_REDIRECT statusCode=HTTP_REDIRECT_MOVED) throw()
6693 {
6697 _ATLTRY
6698 {
6701 }
6703 {
6705 }
6710 {
6713 }
6715 }
6717 // Call this function to append a header to the collection of HTTP headers managed by this object.
6718 //
6719 // szName A nul-teminated string containing the name of the HTTP header.
6720 //
6721 // szValue A nul-teminated string containing the value of the HTTP header.
6723 {
6726 _ATLTRY
6727 {
6729 }
6731 {
6733 }
6735 }
6737 // Call this function to add a Set-Cookie header to the collection of HTTP headers managed by this object.
6738 //
6739 // pCookie A pointer to a CCookie object describing the cookie to be sent to the client.
6741 {
6744 }
6746 // Call this function to add a Set-Cookie header to the collection of HTTP headers managed by this object.
6747 //
6748 // cookie A reference to a CCookie object describing the cookie to be sent to the client.
6750 {
6756 {
6757 _ATLTRY
6758 {
6760 }
6762 {
6765 }
6766 }
6769 {
6770 //We'll have to try dynamically allocating it
6771 //allocate a buffer
6774 {
6777 {
6778 _ATLTRY
6779 {
6781 }
6783 {
6785 }
6786 }
6787 }
6788 }
6790 }
6792 // Call this function to add a Set-Cookie header to the collection of HTTP headers managed by this object.
6793 //
6794 // szName A nul-terminated string containing the name of the cookie to be sent to the client.
6795 //
6796 // szValue A nul-terminated string containing the value of the cookie to be sent to the client.
6798 {
6801 _ATLTRY
6802 {
6805 }
6807 {
6809 }
6811 }
6813 // Call this function to add a Set-Cookie header that removes a cookie value
6814 // to the collection of HTTP headers managed by this object.
6815 //
6816 // szName A nul-terminated string containing the name of the cookie to be deleted
6818 {
6821 _ATLTRY
6822 {
6826 {
6828 }
6829 }
6831 {
6833 }
6836 }
6838 // Call this function to clear the collection of HTTP response headers maintained by this object.
6839 //
6840 // Note that clearing the headers includes removing all cookies associated with the response
6841 // object. Cookies are sent to the client as Set-Cookie HTTP headers.
6843 {
6845 }
6847 // Call this function to clear theresponse buffer without sending the contents to the client.
6848 // If you need to empty the buffer but you do want the current contents sent to the client, call Flush instead.
6850 {
6852 }
6854 // Call this function to send the current headers associated with this object to the client.
6855 //
6856 // Returns TRUE on success, FALSE on failure.
6857 //
6858 // The response headers are sent to the client using the current status code for the
6859 // response object. See SetStatusCode and GetStatusCode.
6861 {
6867 CStringA strHeaders;
6871 _ATLTRY
6872 {
6874 {
6877 {
6879 }
6881 }
6884 CDefaultErrorProvider prov;
6888 {
6890 }
6891 }
6893 {
6895 }
6897 }
6899 // Call this function to get a string containing all the HTTP headers associated with
6900 // this object in a format suitable for sending to a client.
6901 //
6902 // strHeaders A CStringA reference to which will be appended the HTTP headers.
6904 {
6905 _ATLTRY
6906 {
6909 {
6914 }
6916 }
6918 {
6919 }
6920 }
6922 // Call this function to empty the response buffer and send its current
6923 // contents to the client.
6924 //
6925 // Returns S_OK on success, or an error HRESULT on failure.
6927 {
6931 }
6933 // Call this function to empty the response buffer and send its current
6934 // contents to the client.
6935 //
6936 // Returns TRUE on success, or FALSE on failure.
6937 //
6938 // Any headers that have been set in the response will be sent just before the
6939 // data is written to the client if no headers have been sent up to that point.
6941 {
6947 _ATLTRY
6948 {
6949 // if the headers haven't been sent,
6950 // send them now
6953 {
6958 {
6965 }
6966 else
6968 }
6970 {
6975 {
6978 {
6981 }
6983 }
6984 }
6987 {
6989 }
6991 }
6993 // Call this function to clear the response object of any headers
6994 // and the contents of the buffer.
6996 {
6999 }
7002 {
7006 }
7009 {
7015 {
7020 {
7021 _ATLTRY
7022 {
7024 {
7026 }
7027 }
7029 {
7031 }
7032 }
7033 }
7036 }
7039 {
7051 {
7052 _ATLTRY
7053 {
7056 }
7058 {
7060 }
7061 }
7064 }
7069 #define ATLS_FLAG_NONE 0
7072 // push_macro/pop_macro doesn't work in a template definition.
7074 #undef new
7077 {
7080 {
7082 }
7085 {
7086 }
7089 {
7092 {
7100 {
7102 }
7103 }
7105 }
7106 };
7109 inline BOOL CreateRequestHandlerSync(__in IIsapiExtension *pExtension, __deref_out_opt IUnknown **ppOut)
7110 {
7127 }
7130 #define DECLARE_ASYNC_HANDLER() \
7131 static DWORD GetHandlerFlags() \
7132 { \
7133 return ATLS_FLAG_ASYNC; \
7134 } \
7135 DWORD GetAsyncFlags() \
7136 { \
7137 return ATLSRV_INIT_USEASYNC; \
7138 }
7140 #define DECLARE_ASYNC_HANDLER_EX() \
7141 static DWORD GetHandlerFlags() \
7142 { \
7143 return ATLS_FLAG_ASYNC; \
7144 } \
7145 DWORD GetAsyncFlags() \
7146 { \
7147 return (ATLSRV_INIT_USEASYNC|ATLSRV_INIT_USEASYNC_EX); \
7148 }
7153 {
7155 HINSTANCE m_hInstHandler;
7159 DWORD m_dwAsyncFlags;
7163 {
7165 }
7167 {
7168 }
7171 {
7179 #ifdef _DEBUG
7182 #endif
7185 }
7187 HTTP_CODE InitializeHandler(__in AtlServerRequest *pRequestInfo, __in IServiceProvider *pProvider)
7188 {
7194 // Initialize our internal references to required services
7200 }
7202 HTTP_CODE InitializeChild(__in AtlServerRequest *pRequestInfo, __in IServiceProvider *pProvider, IHttpRequestLookup * /*pLookup*/)
7203 {
7205 }
7208 {
7209 }
7214 {
7216 }
7219 {
7221 }
7224 {
7227 }
7230 {
7232 }
7235 {
7237 }
7239 // Used to create new instance of this object. A pointer to this
7240 // function is stored in the handler map in user's code.
7241 static BOOL CreateRequestHandler(__in IIsapiExtension *pExtension, __deref_out_opt IUnknown **ppOut)
7242 {
7250 {
7258 }
7259 else
7260 {
7263 }
7266 }
7268 // Used to initialize the class
7269 // function is stored in the handler map in user's code.
7271 {
7275 }
7277 // Used to uninitialize the class
7278 // function is stored in the handler map in user's code.
7280 {
7282 }
7283 };
7285 struct CRequestStats
7286 {
7289 __int64 m_liTotalResponseTime;
7296 {
7304 }
7307 {
7316 #ifndef ATL_NO_MMSYS
7318 #else
7320 #endif
7326 }
7329 {
7331 }
7334 {
7336 }
7339 {
7341 }
7344 {
7347 }
7350 {
7353 }
7356 {
7358 }
7361 {
7363 }
7366 {
7368 }
7371 // not actually atomic, but it will add safely.
7373 // the returned value is not 100% guaranteed to be
7374 // correct, but should be correct more often than
7375 // just reading the __int64
7376 // the 2 cases where the return value will not be
7377 // a valid result value from an add are:
7378 // * multiple threads wrap the low part in rapid succession
7379 // * different threads are adding values with different signs
7381 // this is good enough for our use in RequestHandled -
7382 // we always add positive values and we shouldn't wrap 32-bits often
7384 {
7387 #if defined(_WIN64) && defined(_M_CEE)
7389 // Use System::Threading::Interlocked::Add because InterlockedExchangeAdd is an intrisinc not supported in managed code
7390 // with 64bits compilers.
7391 // Also, System::Threading::Interlocked::Add support 64bits operands.
7394 #else
7407 LARGE_INTEGER li;
7412 #endif
7413 }
7414 };
7417 {
7421 {
7423 }
7426 {
7427 }
7428 };
7430 #define PERF_REQUEST_OBJECT 100
7433 public CRequestStats
7434 {
7435 DECLARE_PERF_CATEGORY_EX(PERF_REQUEST_OBJECT, IDS_PERFMON_REQUEST, IDS_PERFMON_REQUEST_HELP, PERF_DETAIL_NOVICE, 0, sizeof(CPerfRequestStatObject), MAX_PATH, -1);
7437 DEFINE_COUNTER(m_lTotalRequests, IDS_PERFMON_REQUEST_TOTAL, IDS_PERFMON_REQUEST_TOTAL_HELP, PERF_COUNTER_RAWCOUNT, -1)
7438 DEFINE_COUNTER(m_lFailedRequests, IDS_PERFMON_REQUEST_FAILED, IDS_PERFMON_REQUEST_FAILED_HELP, PERF_COUNTER_RAWCOUNT, -1)
7439 DEFINE_COUNTER(m_lTotalRequests, IDS_PERFMON_REQUEST_RATE, IDS_PERFMON_REQUEST_RATE_HELP, PERF_COUNTER_COUNTER, -1)
7440 DEFINE_COUNTER(m_lAvgResponseTime, IDS_PERFMON_REQUEST_AVG_RESPONSE_TIME, IDS_PERFMON_REQUEST_AVG_RESPONSE_TIME_HELP, PERF_COUNTER_RAWCOUNT, -1)
7441 DEFINE_COUNTER(m_lCurrWaiting, IDS_PERFMON_REQUEST_CURR_WAITING, IDS_PERFMON_REQUEST_CURR_WAITING_HELP, PERF_COUNTER_RAWCOUNT, -1)
7442 DEFINE_COUNTER(m_lMaxWaiting, IDS_PERFMON_REQUEST_MAX_WAITING, IDS_PERFMON_REQUEST_MAX_WAITING_HELP, PERF_COUNTER_RAWCOUNT, -1)
7443 DEFINE_COUNTER(m_lActiveThreads, IDS_PERFMON_REQUEST_ACTIVE_THREADS, IDS_PERFMON_REQUEST_ACTIVE_THREADS, PERF_COUNTER_RAWCOUNT, -1)
7445 };
7448 {
7453 };
7455 class CPerfMonRequestStats
7456 {
7457 CRequestPerfMon m_PerfMon;
7463 {
7466 }
7469 {
7470 HRESULT hr;
7477 {
7480 {
7482 }
7487 {
7489 }
7494 {
7496 }
7500 {
7504 }
7505 }
7508 }
7511 {
7521 }
7524 {
7529 }
7532 {
7537 }
7540 {
7545 }
7548 {
7553 }
7556 {
7561 }
7564 {
7569 }
7572 {
7577 }
7580 {
7585 }
7588 {
7593 }
7594 };
7596 class CNoRequestStats
7597 {
7603 {
7605 }
7608 {
7609 }
7612 {
7613 }
7616 {
7618 }
7621 {
7623 }
7626 {
7628 }
7631 {
7632 }
7635 {
7636 }
7639 {
7641 }
7644 {
7646 }
7649 {
7651 }
7652 };
7654 struct ATLServerDllInfo
7655 {
7656 GETATLHANDLERBYNAME pfnGetHandler;
7657 UNINITIALIZEATLHANDLERS pfnUninitHandlers;
7658 INITIALIZEATLHANDLERS pfnInitHandlers;
7661 };
7663 class CDllCachePeer
7664 {
7667 {
7669 {
7671 {
7677 }
7679 }
7680 };
7683 {
7685 pInfo->pfnInitHandlers = (INITIALIZEATLHANDLERS) GetProcAddress(hInst, ATLS_FUNCID_INITIALIZEHANDLERS);
7687 pInfo->pfnGetHandler = (GETATLHANDLERBYNAME) GetProcAddress(hInst, ATLS_FUNCID_GETATLHANDLERBYNAME);
7691 pInfo->pfnUninitHandlers = (UNINITIALIZEATLHANDLERS) GetProcAddress(hInst, ATLS_FUNCID_UNINITIALIZEHANDLERS);
7694 {
7697 }
7700 }
7703 {
7707 }
7709 };
7711 inline bool operator==(__in const CDllCachePeer::DllInfo& left, __in const CDllCachePeer::DllInfo& right) throw()
7712 {
7718 );
7719 }
7723 // Helper function to impersonate the client
7724 // on the current thread
7726 {
7729 // impersonate the calling client on the current thread
7730 HANDLE hToken;
7731 _ATLTRY
7732 {
7735 }
7737 {
7739 }
7744 }
7746 // Helper class to set the thread impersonation token
7747 // This is mainly used internally to ensure that we
7748 // don't forget to revert to the process impersonation
7749 // level
7750 class CSetThreadToken
7751 {
7756 {
7760 }
7763 {
7765 {
7767 }
7768 }
7770 BOOL m_bShouldRevert;
7771 };
7774 // push_macro/pop_macro doesn't work in a template definition.
7776 #undef new
7779 //Base is the user's class that derives from CComObjectRoot and whatever
7780 //interfaces the user wants to support on the object
7783 {
7786 HANDLE m_hHeap;
7789 {
7791 }
7792 // Set refcount to -(LONG_MAX/2) to protect destruction and
7793 // also catch mismatched Release in debug builds
7795 {
7798 #ifdef _ATL_DEBUG_INTERFACES
7800 #endif
7801 }
7803 //If InternalAddRef or InternalRelease is undefined then your class
7804 //doesn't derive from CComObjectRoot
7807 {
7810 {
7814 {
7816 }
7817 }
7819 }
7820 //if _InternalQueryInterface is undefined then you forgot BEGIN_COM_MAP
7825 };
7830 HRESULT WINAPI _CComObjectHeapNoLock<Base>::CreateInstance(__deref_out _CComObjectHeapNoLock<Base>** pp, __in HANDLE hHeap) throw()
7831 {
7838 // Allocate a fixed block size to avoid fragmentation
7842 {
7844 }
7845 #pragma warning(push)
7846 #pragma warning(disable: 6280)
7847 /* prefast noise VSW 493229 */
7849 #pragma warning(pop)
7860 {
7862 #pragma warning(push)
7863 #pragma warning(disable: 6280)
7864 /* prefast noise VSW 493229 */
7866 #pragma warning(pop)
7868 }
7871 }
7874 {
7878 }
7881 // _AtlGetHandlerName
7882 // get handler name from stencil file. Ignore all server side comments
7883 // szFileName - the file from which to extract the handler name
7884 // szHandlerName - buffer into which handler name will be copied,
7885 // it is assumed to be of size MAX_PATH+ATL_MAX_HANDLER_NAME+2
7886 inline HTTP_CODE _AtlGetHandlerName(__in LPCSTR szFileName, __out_ecount(MAX_PATH+ATL_MAX_HANDLER_NAME+2) LPSTR szHandlerName)
7887 {
7892 CAtlFile cfFile;
7893 HRESULT hr;
7895 _ATLTRY
7896 {
7897 hr = cfFile.Create(CA2CTEX<MAX_PATH>(szFileName), GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING);
7899 {
7904 else
7906 }
7907 }
7909 {
7911 }
7923 // state:
7924 // 0 = default/unknown
7925 // 1 = have "{"
7926 // 2 = have "{{" -- skip spaces
7927 // 3 = have "{{" -- check "handler"
7928 // 4 = have "handler" -- skip spaces
7929 // 5 = have "handler" -- get name
7930 // 6 = scan until first '}'
7931 // 7 = better be '}'
7932 // 8 = done
7935 do
7936 {
7939 {
7941 }
7947 {
7949 {
7951 // 0 = default/unknown
7953 // look for the first curly
7956 {
7957 // skip to the end of the buffer
7959 }
7960 else
7961 {
7964 }
7967 // 1 = have "{"
7969 {
7971 }
7972 else
7973 {
7975 }
7979 {
7981 pszBuf--;
7983 }
7986 // 3 = partial handler "h..."
7988 {
7989 // not a handler, skip tag
7991 }
7992 else
7993 {
7994 pszHandlerPos++;
7997 }
8000 // 4 = have "handler" -- skip spaces
8002 {
8004 {
8006 }
8007 else
8008 {
8009 pszBuf--;
8010 }
8012 }
8015 // 5 = have "handler" -- get name
8017 {
8019 {
8020 // end of the name -- jump to getting the first '}'
8022 }
8023 else
8024 {
8026 }
8027 }
8029 {
8030 // end of the name -- jump to getting the second '}'
8032 }
8034 {
8036 {
8038 }
8039 else
8040 {
8043 }
8044 }
8045 else
8046 {
8047 // ensure we don't overwrite the buffer
8049 {
8052 }
8053 else
8054 {
8056 }
8057 }
8060 // 6 = scan until first '}'
8065 // 7 = better be '}'
8067 {
8070 }
8073 else
8079 }
8081 pszBuf++;
8082 }
8088 }
8090 // _AtlCrackHandler cracks a request path of the form dll_path/handler_name into its
8091 // constituent parts
8092 // szHandlerDllName - the full handler path of the form "dll_path/handler_name"
8093 // szDllPath - the DLL path (should be of length MAX_PATH)
8094 // szHandlerName - the handler name (should be of length ATL_MAX_HANDLER_NAME_LEN+1)
8095 //
8097 __in_z LPCSTR szHandlerDllName,
8099 __inout LPDWORD pdwDllPathLen,
8101 __inout LPDWORD pdwHandlerNameLen)
8102 {
8111 // skip leading spaces
8115 // get the handler name
8120 // if it is of the form <dll_name>/<handler_name>
8122 {
8125 // skip trailing spaces on <dll_name>
8129 szSlash++;
8130 // skip leading whitespace
8132 szSlash++;
8134 // right trim szSlash;
8137 szSlashEnd++;
8138 }
8140 {
8144 // do it this way to handle paths with spaces
8145 // (e.g. "some path\subdirectory one\subdirectory two\dll_name.dll")
8148 // skip trailing spaces
8151 }
8153 // if the dll path is quoted, strip the quotes
8155 {
8156 szHandlerDllName++;
8157 szEnd--;
8158 }
8161 {
8165 }
8166 else
8167 {
8170 }
8173 {
8177 }
8178 else
8179 {
8182 }
8185 }
8188 __in LPCSTR szDllPath,
8189 __in LPCSTR szHandlerName,
8195 {
8202 ATLServerDllInfo DllInfo;
8206 {
8209 {
8211 }
8214 }
8215 else
8216 {
8218 }
8220 {
8223 }
8230 {
8234 }
8241 public CWrappedServerContext
8242 {
8246 CStringA m_strUrl;
8254 {
8256 }
8259 {
8261 return Initialize(pOtherContext->m_strUrl, pOtherContext->m_pStream, pOtherContext->m_spParent);
8262 }
8264 BOOL Initialize(__in LPCSTR szUrl, __in IWriteStream *pStream, __in IHttpServerContext *pParent) throw()
8265 {
8269 _ATLTRY
8270 {
8271 m_strUrl = szUrl; // we store the URL in case we need to initialize another context from this context
8272 }
8274 {
8276 }
8282 {
8285 _ATLTRY
8286 {
8289 m_szFileName,
8291 }
8293 {
8295 }
8298 {
8300 }
8301 }
8303 // check for query params
8306 {
8311 {
8314 {
8315 #pragma warning(push)
8316 #pragma warning(disable: 22008)
8317 /* Prefast false warning about unbound nPathLen in the below fragment -
8318 we already have necessary checks few lines above
8319 */
8321 {
8323 }
8324 else
8325 {
8328 }
8329 #pragma warning(pop)
8330 }
8331 else
8332 {
8334 }
8335 }
8336 else
8337 {
8339 }
8341 // save query params
8344 {
8346 }
8347 else
8348 {
8350 }
8351 }
8352 else
8353 {
8354 // no query string
8357 {
8359 {
8361 }
8362 else
8363 {
8365 }
8366 }
8367 else
8368 {
8370 }
8372 }
8375 }
8377 {
8381 _ATLTRY
8382 {
8384 }
8386 {
8388 }
8391 }
8394 {
8397 }
8400 {
8403 }
8406 {
8409 }
8411 // Asynchronous writes will not work properly in a child handler
8413 {
8416 }
8418 // These next few methods are to protect against attempting to parse form data twice
8419 // We tell the new handler that it was a GET request
8421 {
8424 }
8426 // The handler should not query these methods -- they are only useful if attempting to
8427 // parse form data, which is not allowed in child handlers.
8429 {
8431 }
8434 {
8436 }
8439 {
8442 }
8445 {
8448 }
8451 {
8454 }
8457 {
8460 }
8461 };
8463 class CAllocContextBase
8464 {
8467 };
8471 __in LPCSTR szFileName,
8472 __in LPCSTR szQueryParams,
8473 __in WORD wCodePage,
8478 {
8483 // get a pointer to the ISAPI extension
8487 {
8489 }
8491 // get a pointer to the extension's dll cache
8497 {
8499 }
8501 #ifdef _DEBUG
8503 #endif
8505 {
8508 #ifdef _DEBUG
8510 #endif
8511 }
8512 else
8513 {
8519 {
8521 }
8529 {
8531 }
8533 // Extract the file extension of the included file by searching
8534 // for the first '.' from the right.
8535 // Can't use _tcsrchr because we have to use the stencil's codepage
8540 {
8546 {
8547 // embedded null
8551 }
8553 }
8556 {
8559 {
8563 }
8564 }
8566 {
8567 // Get the handler name if they used the asdf.dll?Handler=Default notation
8574 {
8578 {
8579 Checked::memcpy_s(szHandlerName, ATL_MAX_HANDLER_NAME_LEN+1, szStart, __min((szEnd-szStart), ATL_MAX_HANDLER_NAME_LEN));
8581 }
8582 else
8583 {
8585 {
8586 // handler name too long
8590 }
8591 }
8592 }
8593 else
8594 {
8596 Checked::memcpy_s(szHandlerName, ATL_MAX_HANDLER_NAME_LEN+1, ATL_HANDLER_NAME_DEFAULT, sizeof(ATL_HANDLER_NAME_DEFAULT));
8597 }
8601 hcErr = spExtension->LoadRequestHandler(szFileName, szHandlerName, pRequestInfo->pServerContext,
8604 {
8608 }
8609 }
8610 else
8611 {
8612 // unknown extension
8616 }
8618 DWORD dwStatus;
8622 {
8627 }
8630 {
8631 #ifdef _DEBUG
8633 #endif
8637 {
8640 {
8642 }
8645 }
8646 }
8650 {
8653 {
8655 }
8658 }
8661 }
8664 {
8666 {
8668 hcErr = (pRequestInfo->pHandler->*pRequestInfo->pfnHandleRequest)(pRequestInfo, pServiceProvider);
8670 #ifdef _DEBUG
8671 // must use ATLSRV_INIT_USEASYNC to use ASYNC returns
8673 {
8675 }
8676 #endif
8679 {
8682 {
8685 }
8687 {
8690 {
8692 }
8694 }
8695 }
8696 else
8697 {
8700 {
8702 }
8704 }
8705 }
8706 }
8707 else
8708 {
8710 }
8713 }
8715 // CAllocTransferAsyncContext is an unsupported implementation detail, used
8716 // for implementing _AtlTransferRequest.
8718 public CAllocContextBase
8719 {
8723 {
8724 }
8727 {
8740 }
8743 };
8750 __in LPCSTR szNewUrl,
8751 __in WORD nCodePage,
8754 {
8762 nCodePage,
8764 pServiceProvider,
8765 pLookup,
8766 pState);
8770 }
8772 //
8773 // This function is now deprecated. ATL is not using it anymore.
8774 //
8777 {
8778 //
8779 // a buffer overflow has occurred in your code
8780 //
8783 //
8784 // terminate process (safest thing to do)
8785 //
8787 }
8789 //
8790 // Class CIsapiExtension
8791 // The main ISAPI Extension implementation.
8792 // Template parameters
8793 // ThreadPoolClass: Specifies the thread pool that will be used by the
8794 // extension to queue incoming requests. CThreadPool is the
8795 // default and is declared and implemented in ATLUTIL.H. This class
8796 // templatizes on a worker thread class. The worker thread class
8797 // represents an abstraction of a thread that will be used to
8798 // process requests as they are dequeued from the pool's work queue.
8799 // You would change this parameter if you wanted to use a completely
8800 // different thread pool, or, more commonly, if you wanted to use
8801 // a different worker thread class. Request processing code can
8802 // access a pointer to the worker thread class, which allows the
8803 // request handling code to easily access per-thread data.
8804 // CRequestStatClass: Specifies the class to be used to track request statistics
8805 // CNoRequestStats is the default which is a noop class.
8806 // You would change this parameter to provide a class that will
8807 // track request statistics for you. ATL provides CStdRequestStats
8808 // and CPerfRequestStatObject but these classes should be used
8809 // with caution because they require interlocked operations to
8810 // keep track of request statistics which can affect server performance.
8811 // HttpUserErrorTextProvider: This class provides error text messages
8812 // and headers, including resource IDs of error messages to the
8813 // isapi extension's error handling functions. You would change this
8814 // parameter if you wanted to provide your own error headers and/or
8815 // messages in response to error encountered during request processing.
8816 // CPageCacheStats, CStencilCacheStats: These two classes are used to keep
8817 // statistics about the page and stencil caches. You could change these
8818 // paramters if you wanted to track statistics for these caches. ATL
8819 // provides CPerfStatClass and CStdStatClass to store the stat data but
8820 // using these classes can affect server performance because they use
8821 // interlocked operations internally to store the data.
8830 {
8833 #ifndef ATL_NO_CRITICAL_ISAPI_ERROR
8835 DWORD m_dwCriticalIsapiError;
8840 DWORD m_dwTlsIndex;
8844 extWorkerType m_WorkerThread;
8845 ThreadPoolClass m_ThreadPool;
8850 HttpUserErrorTextProvider m_UserErrorProvider;
8851 HANDLE m_hRequestHeap;
8852 CComCriticalSection m_critSec;
8854 // Dynamic services stuff
8855 struct ServiceNode
8856 {
8857 HINSTANCE hInst;
8859 GUID guidService;
8860 IID riid;
8863 {
8864 }
8868 {
8869 }
8870 };
8872 class CServiceEqualHelper
8873 {
8876 {
8879 }
8880 };
8885 CWin32Heap m_heap;
8887 CRequestStatClass m_reqStats;
8890 {
8891 // Allocate a fixed block size to avoid fragmentation
8893 HEAP_ZERO_MEMORY, __max(sizeof(AtlServerRequest), sizeof(_CComObjectHeapNoLock<CServerContext>)));
8899 }
8902 {
8905 }
8908 {
8910 #ifdef _DEBUG
8912 #endif
8914 #ifndef ATL_NO_CRITICAL_ISAPI_ERROR
8919 }
8926 __in LPCSTR szNewUrl,
8927 __in WORD nCodePage,
8930 {
8931 HTTP_CODE hcErr;
8932 _ATLTRY
8933 {
8936 }
8938 {
8940 }
8942 }
8944 #ifndef ATL_NO_CRITICAL_ISAPI_ERROR
8947 {
8949 _ATLTRY
8950 {
8955 CStringA strStatus;
8956 CStringA strBody;
8957 CStringA strFormat;
8958 CStringA strError;
8962 {
8964 }
8966 #ifdef ATL_CRITICAL_ISAPI_ERROR_LOGONLY
8967 // we've logged the real error - don't send detailed internal info to the user
8969 SUBERR_NONE,
8974 {
8976 }
8977 #else
8979 ISE_SUBERR_ISAPISTARTUPFAILED,
8983 {
8984 strFormat = "<html><body>A critical error has occurred initializing this ISAPI extension: %s</body></html>";
8985 }
8987 #endif
8990 HSE_SEND_HEADER_EX_INFO hex;
8998 HSE_REQ_SEND_RESPONSE_HEADER_EX,
9000 NULL,
9001 NULL);
9007 NULL);
9008 }
9010 {
9012 }
9014 }
9019 {
9021 #ifndef ATL_NO_CRITICAL_ISAPI_ERROR
9024 {
9026 }
9032 _ATLTRY
9033 {
9041 {
9044 }
9054 #ifndef ATL_NO_MMSYS
9056 #else
9058 #endif
9067 {
9069 }
9071 }
9073 {
9074 }
9079 }
9083 {
9085 }
9088 {
9090 }
9093 {
9095 }
9097 // Configuration functions -- override in base class if another value is desired
9107 {
9109 }
9112 {
9114 }
9116 #ifndef ATL_NO_CRITICAL_ISAPI_ERROR
9119 {
9122 // send the error to the event log
9123 _ATLTRY
9124 {
9125 CStringA strBody;
9126 CStringA strFormat;
9127 CStringA strError;
9129 // format an error message
9131 {
9133 }
9136 {
9138 }
9141 // take the base module name as the app name
9142 CPath path;
9143 {
9148 }
9151 // log the event
9154 {
9158 }
9159 }
9161 {
9162 }
9165 }
9168 {
9170 }
9172 #else
9175 {
9178 }
9181 {
9183 }
9189 {
9192 {
9194 }
9195 // allocate a Tls slot for storing per thread data
9198 // create a private heap for request data
9199 // this heap has to be thread safe to allow for
9200 // async processing of requests
9203 {
9207 {
9209 }
9211 }
9213 // create a private heap (synchronized) for
9214 // allocations. This reduces fragmentation overhead
9215 // as opposed to the process heap
9218 {
9222 }
9223 else
9224 {
9226 }
9230 {
9235 }
9238 {
9240 }
9243 {
9247 }
9249 if (S_OK != m_ThreadPool.Initialize(static_cast<IIsapiExtension*>(this), GetNumPoolThreads(), GetPoolStackSize(), GetIOCompletionHandle()))
9250 {
9255 }
9258 {
9264 }
9267 {
9274 }
9280 {
9288 }
9291 Checked::strncpy_s(pVer->lpszExtensionDesc, HSE_MAX_EXT_DLL_NAME_LEN, GetExtensionDesc(), _TRUNCATE);
9295 }
9298 {
9301 {
9304 {
9306 }
9308 }
9319 // free the request heap
9323 // free the Tls slot that we allocated
9327 }
9330 __in PVOID pContext,
9331 __in DWORD cbIO,
9333 {
9337 {
9338 // synchronize in case the previous async_noflush call isn't finished
9339 // setting up state for the next call.
9342 {
9343 _ATLTRY
9344 {
9346 }
9348 {
9350 _ATLRETHROW;
9351 }
9353 }
9354 }
9360 {
9362 }
9364 {
9368 }
9369 else
9370 {
9375 }
9376 }
9378 void HandleError(__in IHttpServerContext *pServerContext, __in DWORD dwStatus, __in DWORD dwSubStatus) throw()
9379 {
9381 }
9383 void RequestComplete(__inout AtlServerRequest *pRequestInfo, __in DWORD dwStatus, __in DWORD dwSubStatus)
9384 {
9395 {
9399 }
9400 else
9408 }
9410 HTTP_CODE GetHandlerName(__in LPCSTR szFileName, __out_ecount(MAX_PATH+ATL_MAX_HANDLER_NAME+2) LPSTR szHandlerName) throw()
9411 {
9413 }
9416 {
9423 // Must have space for the path to the handler + the maximum size
9424 // of the handler, plus the '/' plus the '\0'
9433 // Stencil was found, check to see if it needs to be refreshed
9435 {
9439 CFileTime cftCurr;
9440 CFileTime cftLastChecked;
9448 {
9450 m_StencilCache.QueryInterface(__uuidof(IStencilCacheControl), reinterpret_cast<void**>(&spCacheCtrl));
9452 {
9453 CFileTime cftLastModified;
9456 // Resource based stencils have a last modified filetime of 0
9458 {
9459 // for file base stencils, we check whether the file
9460 // has been modified since being put in the cache
9461 WIN32_FILE_ATTRIBUTE_DATA fad;
9467 {
9468 // the file has changed or an error has occurred trying to read the file,
9469 // so remove it from the cache and force a reload
9473 }
9474 }
9475 }
9476 }
9477 }
9481 {
9485 // not in the cache, so open the file
9491 if (!_AtlCrackHandler(szHandlerDllName, szDllPath, &dwDllPathLen, szHandlerName, &dwHandlerNameLen))
9492 {
9494 }
9498 {
9500 }
9501 }
9502 else
9503 {
9505 }
9510 }
9513 {
9517 _ATLTRY
9518 {
9523 {
9526 {
9529 {
9534 {
9536 {
9538 nCnt++;
9539 }
9540 else
9541 {
9544 }
9545 }
9547 {
9549 }
9550 }
9551 }
9552 }
9555 {
9558 {
9559 hcErr = LoadRequestHandler(szFile, szHandler, pRequestInfo->pServerContext, &pRequestInfo->hInstDll, &pRequestInfo->pHandler);
9560 }
9561 else
9562 {
9564 }
9565 }
9568 }
9570 {
9572 }
9573 }
9575 #pragma warning(push)
9576 #pragma warning(disable: 6014)
9577 virtual __success(return) __checkReturn BOOL GetCacheServerContext(__in AtlServerRequest *pRequestInfo, __in IFileCache *pCache, __deref_out_opt IHttpServerContext **pCacheCtx)
9578 {
9588 {
9591 }
9600 }
9601 #pragma warning(pop)
9603 virtual BOOL TransmitFromCache(__in AtlServerRequest* pRequestInfo, __out BOOL *pbAllowCaching)
9604 {
9610 _ATLTRY
9611 {
9623 {
9625 nSize++;
9626 }
9628 {
9630 }
9632 nSize++;
9635 {
9637 nSize++;
9638 }
9640 {
9642 }
9645 HCACHEITEM hEntry;
9648 {
9649 LPSTR szFileName;
9653 CAtlFile file;
9658 GENERIC_READ,
9659 FILE_SHARE_READ,
9660 OPEN_EXISTING,
9664 {
9668 }
9689 );
9692 {
9697 }
9699 }
9700 }
9702 {
9703 }
9706 }
9708 #if defined(_DEBUG) || defined(ATLS_ENABLE_DEBUGGING)
9710 BOOL m_bDebug;
9711 // F5 debugging support for VS7
9713 {
9724 };
9725 _ATLTRY
9726 {
9728 {
9729 // Debugger must be able to validate the client we are impersonating
9730 // on an NT Domain so the client needs to use either NTLM or Negotiate.
9734 if ( !pRequestInfo->pServerContext->GetServerVariable("AUTH_TYPE", szAuthType, &dwAuthTypeSize) )
9735 {
9736 // error retrieving authentication type
9739 }
9741 // if it's empty or not NTLM or negotiate we fail.
9745 ) )
9746 {
9747 // wrong authorization type or not authorized
9750 }
9753 CStringA strHeaders;
9755 BOOL bRet = pRequestInfo->pServerContext->GetServerVariable("ALL_HTTP", strHeaders.GetBuffer(dwHeadersLen), &dwHeadersLen);
9757 {
9760 }
9765 {
9767 {
9770 }
9774 {
9777 }
9779 szCur++;
9780 }
9784 {
9787 {
9789 RequestComplete(pRequestInfo, 204, DBG_SUBERR_ALREADY_DEBUGGING); // Already being debugged by another process
9791 }
9792 CHttpRequest HttpRequest;
9795 LPCSTR szString;
9798 {
9802 }
9805 {
9809 }
9813 {
9816 szPoint++;
9817 }
9820 {
9824 }
9831 {
9835 }
9842 {
9846 }
9851 {
9854 }
9856 {
9860 }
9863 hr = CoCreateInstance(clsidDebugAutoAttach, NULL, CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_SERVER, __uuidof(IDebugAutoAttach), (void**)&spDebugAutoAttach);
9865 {
9868 else
9869 {
9872 }
9874 }
9875 hr = spDebugAutoAttach->AutoAttach(GUID_NULL, dwPid, AUTOATTACH_PROGRAM_WIN32, 0, szSessionID);
9877 {
9879 int nLen = sprintf_s(szRetBuf, _countof(szRetBuf), "204 HRESULT=0x%.08X;ErrorString=Unable to attach to worker process", hr);
9881 {
9886 }
9888 }
9893 }
9895 {
9900 }
9901 else
9902 {
9905 }
9906 }
9908 }
9910 {
9912 }
9913 }
9917 {
9919 CSetThreadToken sec;
9924 {
9927 }
9929 #if defined(_DEBUG) || defined(ATLS_ENABLE_DEBUGGING)
9935 {
9936 // synchronize in case the previous async_noflush call isn't finished
9937 // setting up state for the next call.
9940 {
9943 }
9944 }
9946 #ifdef _DEBUG
9948 #endif
9951 {
9956 }
9958 // get the srf filename
9962 {
9965 }
9969 // load a handler
9971 {
9974 }
9976 {
9979 }
9980 else
9981 {
9983 }
9986 {
9989 }
9993 // initialize the handler
9998 {
10001 }
10005 {
10009 {
10012 }
10016 }
10019 {
10020 #ifdef _DEBUG
10022 #endif
10024 {
10027 }
10028 }
10031 {
10034 {
10037 }
10041 {
10044 }
10045 }
10046 hcErr = pRequestInfo->pHandler->InitializeHandler(pRequestInfo, static_cast<IServiceProvider*>(this));
10047 }
10048 #ifdef _DEBUG
10050 {
10052 }
10053 #endif
10058 hcErr = (pRequestInfo->pHandler->*pRequestInfo->pfnHandleRequest)(pRequestInfo, static_cast<IServiceProvider*>(this));
10061 {
10063 HRESULT hr = pRequestInfo->pServerContext->QueryInterface(__uuidof(IPageCacheControl), reinterpret_cast<void**>(&spControl));
10066 }
10068 #ifdef _DEBUG
10069 // must use ATLSRV_INIT_USEASYNC to use ASYNC returns
10073 // must use ATLSRV_INIT_USEASYNC_EX to use NOFLUSH returns
10076 #endif
10078 // save hMutex in case pRequestInfo is deleted by AsyncCallback after
10079 // we call StartAsyncFlush but before we check to see if we need to
10080 // call ReleaseMutex
10084 {
10087 else
10091 {
10094 }
10095 }
10096 else
10097 {
10100 }
10106 }
10109 {
10112 {
10115 }
10119 _ATLTRY
10120 {
10124 }
10126 {
10128 }
10131 }
10134 {
10136 }
10139 {
10141 }
10144 {
10146 }
10149 {
10151 }
10154 {
10156 }
10159 {
10161 }
10163 __success(SUCCEEDED(return)) __checkReturn HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, __deref_out void **ppv)
10164 {
10168 {
10172 }
10175 {
10179 }
10181 {
10185 }
10187 }
10190 {
10192 }
10195 {
10197 }
10200 __in REFGUID guidService,
10201 __in REFIID riid,
10203 {
10214 {
10217 }
10218 #ifndef ATL_NO_SOAP
10220 {
10224 }
10225 #endif
10227 // otherwise look it up in the servicemap
10229 }
10231 virtual HRESULT AddService(REFGUID guidService, REFIID riid, IUnknown *punkService, HINSTANCE hInstance)
10232 {
10239 ServiceNode srvNode;
10248 {
10250 }
10252 // if the service is already there, return S_FALSE
10262 }
10265 {
10266 ServiceNode srvNode;
10273 {
10275 }
10292 }
10294 __success(SUCCEEDED(return)) __checkReturn HRESULT GetService(__in REFGUID guidService, __in REFIID riid, __deref_out void **ppvObject) throw()
10295 {
10303 ServiceNode srvNode;
10310 {
10312 }
10320 }
10322 HTTP_CODE LoadRequestHandler(__in LPCSTR szDllPath, __in LPCSTR szHandlerName, __in IHttpServerContext *pServerContext,
10324 {
10332 //===========================================================================================
10333 // IMPORTANT NOTE TO USERS:
10334 // DO NOT ASSUME *ANYTHING* ABOUT THE STRUCTURE OF THESE MAPS/ENTRIES/FUNCTIONS--THEY CAN
10335 // AND *WILL* CHANGE IN THE FUTURE. CORRECT USAGE MANDATES THAT YOU USE THE MACROS PROVIDED.
10336 // ABSOLUTELY NO GUARANTEES ABOUT BACKWARD COMPATABILITY ARE MADE FOR MANUALLY DEFINED
10337 // HANDLERS OR FUNCTIONS.
10338 //===========================================================================================
10344 struct _HANDLER_ENTRY
10345 {
10346 LPCSTR szName;
10347 CREATEHANDLERFUNC pfnCreate;
10348 INITHANDLERFUNC pfnInit;
10349 UNINITHANDLERFUNC pfnUninit;
10350 };
10351 // definitions of data segments and _HANDLER_ENTRY delimiters
10356 {
10359 }
10361 #if !defined(_M_IA64)
10363 #endif
10365 #ifndef HANDLER_ENTRY_PRAGMA
10367 #if defined(_M_IX86)
10368 #define HANDLER_ENTRY_PRAGMA(class, line) __pragma(comment(linker, "/include:___phdlrEntry_" #class "_" #line));
10369 #elif defined(_M_IA64)
10370 #define HANDLER_ENTRY_PRAGMA(class, line) __pragma(comment(linker, "/include:__phdlrEntry_" #class "_" #line));
10371 #elif defined(_M_AMD64)
10372 #define HANDLER_ENTRY_PRAGMA(class, line) __pragma(comment(linker, "/include:__phdlrEntry_" #class "_" #line));
10373 #else
10374 #error Unknown Platform. define HANDLER_ENTRY_PRAGMA
10375 #endif
10379 // DECLARE_REQUEST_HANDLER macro
10380 #define __DECLARE_REQUEST_HANDLER_INTERNAL(handlerName, className, classQName, lineNum) \
10381 __declspec(selectany) ATL::_HANDLER_ENTRY __hdlrEntry_ ## className ## _ ## lineNum = { handlerName, classQName::CreateRequestHandler, classQName::InitRequestHandlerClass, classQName::UninitRequestHandlerClass }; \
10383 ATL::_HANDLER_ENTRY * const __phdlrEntry_ ## className ## _ ## lineNum = &__hdlrEntry_ ## className ## _ ## lineNum; \
10384 HANDLER_ENTRY_PRAGMA(className, lineNum) \
10385 __if_not_exists(GetAtlHandlerByName) \
10386 { \
10387 extern "C" ATL_NOINLINE inline BOOL __declspec(dllexport) __stdcall GetAtlHandlerByName(LPCSTR szHandlerName, IIsapiExtension *pExtension, IUnknown **ppHandler) throw() \
10388 { \
10389 *ppHandler = NULL; \
10390 ATL::_HANDLER_ENTRY **pEntry = &__phdlrA; \
10391 while (pEntry != &__phdlrZ) \
10392 { \
10393 if (*pEntry && (*pEntry)->szName) \
10394 { \
10395 if (strcmp((*pEntry)->szName, szHandlerName)==0) \
10396 { \
10397 return (*(*pEntry)->pfnCreate)(pExtension, ppHandler); \
10398 } \
10399 } \
10400 pEntry++; \
10401 } \
10402 return FALSE; \
10403 } \
10404 extern "C" ATL_NOINLINE inline BOOL __declspec(dllexport) __stdcall InitializeAtlHandlers(IHttpServerContext *pContext, IIsapiExtension *pExt) throw() \
10405 { \
10406 ATL::_HANDLER_ENTRY **pEntry = &__phdlrA; \
10407 BOOL bRet = TRUE; \
10408 while (pEntry != &__phdlrZ) \
10409 { \
10410 if (*pEntry && (*pEntry)->szName && (*pEntry)->pfnInit) \
10411 { \
10412 bRet = (*(*pEntry)->pfnInit)(pContext, pExt); \
10413 if (!bRet) \
10414 break; \
10415 } \
10416 pEntry++; \
10417 } \
10418 if (!bRet) \
10419 { \
10420 if (pEntry == &__phdlrA) \
10421 return FALSE; \
10422 do \
10423 { \
10424 pEntry--; \
10425 if(*pEntry) \
10426 (*(*pEntry)->pfnUninit)(); \
10427 } \
10428 while (pEntry != &__phdlrA); \
10429 } \
10430 return bRet; \
10431 } \
10432 extern "C" ATL_NOINLINE inline void __declspec(dllexport) __stdcall UninitializeAtlHandlers() throw() \
10433 {\
10434 ATL::_HANDLER_ENTRY **pEntry = &__phdlrA; \
10435 while (pEntry != &__phdlrZ) \
10436 { \
10437 if (*pEntry && (*pEntry)->szName && (*pEntry)->pfnUninit) \
10438 { \
10439 (*(*pEntry)->pfnUninit)(); \
10440 } \
10441 pEntry++; \
10442 } \
10443 } \
10444 }
10446 #define __DECLARE_REQUEST_HANDLER(handlerName, className, classQName, lineNum) __DECLARE_REQUEST_HANDLER_INTERNAL(handlerName, className, classQName, lineNum)
10447 #define DECLARE_REQUEST_HANDLER(handlerName, className, classQName) __DECLARE_REQUEST_HANDLER(handlerName, className, classQName, __COUNTER__)
10449 #define BEGIN_HANDLER_MAP()
10450 #define HANDLER_ENTRY(handlerName, className) DECLARE_REQUEST_HANDLER(handlerName, className, className)
10451 #define HANDLER_ENTRY_EX(handlerName, className, classQName) DECLARE_REQUEST_HANDLER(handlerName, className, classQName)
10452 #define END_HANDLER_MAP()
10454 #define __HANDLER_ENTRY_SDL_INTERNAL(handlerString, handlerClass, handlerQClass, sdlClassName, lineNum)\
10455 _ATLSOAP_DECLARE_WSDL_SRF() \
10456 extern __declspec(selectany) const char const s_szClassName##sdlClassName##lineNum[]=handlerString;\
10457 typedef ATL::CSDLGenerator<handlerQClass, s_szClassName##sdlClassName##lineNum> sdlClassName; \
10458 HANDLER_ENTRY_EX(handlerString, handlerClass, handlerQClass)\
10459 HANDLER_ENTRY(#sdlClassName, sdlClassName)
10461 #define __HANDLER_ENTRY_SDL(handlerString, handlerClass, handlerQClass, sdlClassName, lineNum) __HANDLER_ENTRY_SDL_INTERNAL(handlerString, handlerClass, handlerQClass, sdlClassName, lineNum)
10462 #define HANDLER_ENTRY_SDL(handlerString, handlerClass, handlerQClass, sdlClassName) __HANDLER_ENTRY_SDL(handlerString, handlerClass, handlerQClass, sdlClassName, __COUNTER__)
10463 //
10464 // Use this class to check the authorization level of a client who is making
10465 // a request to this application. This class checks for the stronger authentication
10466 // levels (NTLM and Negotiate). You can call it directly from an implementation
10467 // of HandleRequest to check authorization before handling a request.
10468 #define MAX_AUTH_TYPE 50
10469 #define MAX_NAME_LEN 255
10472 class CVerifyAuth
10473 {
10476 {
10485 _ATLTRY
10486 {
10489 {
10492 {
10493 // if we were passed a group name
10494 // we check to see that the logged on user is part
10495 // of that group, else we just return success.
10497 {
10501 else
10503 }
10504 else
10506 }
10507 }
10508 }
10510 {
10512 }
10515 }
10518 {
10522 }
10525 {
10528 }
10530 __checkReturn bool CheckAuthAccount(__in IHttpServerContext *pContext, __in const SID* psidAuthGroup) throw()
10531 {
10539 _ATLTRY
10540 {
10545 CAccessToken tok;
10552 }
10554 {
10556 }
10559 }
10560 };
10562 // Checks that the user that is logging on is in the required group
10565 {
10567 virtual bool CheckAccount(__in IHttpServerContext *pContext, __in const SID* psidAuthGroup) throw()
10568 {
10570 }
10573 {
10576 {
10578 }
10580 _ATLTRY
10581 {
10585 }
10587 {
10589 }
10592 }
10595 {
10597 "<H1 align=center>NOT AUTHORIZED</H1><p>"
10600 }
10602 };
10605 #pragma pack(pop)
10607 #pragma warning(pop)