include/atl/atlsiface.h

   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.
  10
  11 #ifndef __ATLSIFACE_H__
  12 #define __ATLSIFACE_H__
  13
  14 #pragma once
  15 #include <atlcoll.h>
  16 #include <httpext.h>
  17 #include <atlserr.h>
  18 #include <atlcom.h>
  19 #include <string.h>
  20 #include <atlpath.h>
  21
  22 #pragma pack(push,_ATL_PACKING)
  23 namespace ATL{
  24
  25 // Forward declarations of custom data types used in
  26 // interfaces declared in this file.
  27 struct AtlServerRequest;
  28 class CIsapiWorker;
  29 __interface IAtlMemMgr;
  30 class CCookie;
  31
  32 // Forward declarations of all interfaces declared in this file.
  33 __interface IWriteStream;
  34 __interface IHttpFile;
  35 __interface IHttpServerContext;
  36 __interface IHttpRequestLookup;
  37 __interface IRequestHandler;
  38 __interface ITagReplacer;
  39 __interface IIsapiExtension;
  40 __interface IPageCacheControl;
  41 __interface IRequestStats;
  42 __interface IBrowserCaps;
  43 __interface IBrowserCapsSvc;
  44
  45
  46 // ATLS Interface declarations.
  47
  48 // IWriteStream
  49 // Interface for writing to a stream.
  50 __interface IWriteStream
  51 {
  52         HRESULT WriteStream(LPCSTR szOut, int nLen, DWORD *pdwWritten);
  53         HRESULT FlushStream();
  54 };
  55
  56 // IHttpFile
  57 // This is an interface that provides for basic accessor
  58 // functionality for files (see CHttpRequestFile).
  59 __interface IHttpFile
  60 {
  61         LPCSTR GetParamName();
  62         LPCSTR GetFileName();
  63         LPCSTR GetFullFileName();
  64         LPCSTR GetContentType();
  65         LPCSTR GetTempFileName();
  66         ULONGLONG GetFileSize();
  67         void Free();
  68 };
  69
  70 // IHttpServerContext
  71 // This interface encapsulates the capabilities of the web server and provides information about
  72 // the current request being handled. See CServerContext for implementation.
  73 __interface ATL_NO_VTABLE __declspec(uuid("813F3F00-3881-11d3-977B-00C04F8EE25E"))
  74         IHttpServerContext : public IUnknown
  75 {
  76         HRESULT  STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppv);
  77         ULONG STDMETHODCALLTYPE AddRef();
  78         ULONG STDMETHODCALLTYPE Release();
  79
  80         LPCSTR GetRequestMethod();
  81         LPCSTR GetQueryString();
  82         LPCSTR GetPathInfo();
  83         LPCSTR GetPathTranslated();
  84         LPCSTR GetScriptPathTranslated();
  85         DWORD GetTotalBytes();
  86         DWORD GetAvailableBytes();
  87         BYTE *GetAvailableData();
  88         LPCSTR GetContentType();
  89         BOOL GetServerVariable(__in_z LPCSTR pszVariableName,
  90                                                                         __out_ecount_part_opt(*pdwSize, *pdwSize) LPSTR pvBuffer, __inout DWORD *pdwSize);
  91         BOOL GetImpersonationToken(HANDLE * pToken);
  92         BOOL WriteClient(void *pvBuffer, DWORD *pdwBytes);
  93         BOOL AsyncWriteClient(void *pvBuffer, DWORD *pdwBytes);
  94         BOOL ReadClient(void *pvBuffer, DWORD *pdwSize);
  95         BOOL AsyncReadClient(void *pvBuffer, DWORD *pdwSize);
  96         BOOL SendRedirectResponse(LPCSTR pszRedirectUrl);
  97         BOOL SendResponseHeader(LPCSTR pszHeader, LPCSTR pszStatusCode,
  98                                                         BOOL fKeepConn);
  99         BOOL DoneWithSession(DWORD dwHttpStatusCode);
 100         BOOL RequestIOCompletion(PFN_HSE_IO_COMPLETION pfn, DWORD *pdwContext);
 101         BOOL TransmitFile(HANDLE hFile, PFN_HSE_IO_COMPLETION pfn, void *pContext,
 102                 LPCSTR szStatusCode, DWORD dwBytesToWrite, DWORD dwOffset,
 103                 void *pvHead, DWORD dwHeadLen, void *pvTail,
 104                 DWORD dwTailLen, DWORD dwFlags);
 105         BOOL AppendToLog(LPCSTR szMessage, DWORD* pdwLen);
 106         BOOL MapUrlToPathEx(LPCSTR szLogicalPath, DWORD dwLen, HSE_URL_MAPEX_INFO *pumInfo);
 107 };
 108
 109 // IHttpRequestLookup
 110 // This interface is designed to allow one map to chain to another map.
 111 // The interface is implemented by the CHttpThunkMap and CHttpRequest classes.
 112 // Pointers to this interface are passed around by CRequestHandlerT and CHtmlTagReplacer.
 113 // dwType - the type of item being requested
 114 __interface ATL_NO_VTABLE __declspec(uuid("A5990B44-FF74-4bfe-B66D-F9E7E9F42D42"))
 115         IHttpRequestLookup : public IUnknown
 116 {
 117         POSITION GetFirstQueryParam(LPCSTR *ppszName, LPCSTR *ppszValue);
 118         POSITION GetNextQueryParam(POSITION pos, LPCSTR *ppszName, LPCSTR *ppszValue);
 119
 120         POSITION GetFirstFormVar(LPCSTR *ppszName, LPCSTR *ppszValue);
 121         POSITION GetNextFormVar(POSITION pos, LPCSTR *ppszName, LPCSTR *ppszValue);
 122
 123         POSITION GetFirstFile(LPCSTR *ppszName, IHttpFile **ppFile);
 124         POSITION GetNextFile(POSITION pos, LPCSTR *ppszName, IHttpFile **ppFile);
 125
 126         HRESULT GetServerContext(IHttpServerContext **ppOut);
 127 };
 128
 129
 130 // IRequestHandler
 131 // This interface is impelemented by clients who want to be request handlers in an
 132 // atl server application. Server default implementations are provided in ATL, including
 133 // IRequestHandlerImpl (atlisapi.h) and CRequestHandlerT (atlstencil.h)
 134 __interface ATL_NO_VTABLE __declspec(uuid("D57F8D0C-751A-4223-92BC-0B29F65D2453"))
 135 IRequestHandler : public IUnknown
 136 {
 137         HTTP_CODE GetFlags(DWORD *pdwStatus);
 138         HTTP_CODE InitializeHandler(AtlServerRequest *pRequestInfo, IServiceProvider *pProvider);
 139         HTTP_CODE InitializeChild(AtlServerRequest *pRequestInfo, IServiceProvider *pProvider, IHttpRequestLookup *pLookup);
 140         HTTP_CODE HandleRequest(AtlServerRequest *pRequestInfo, IServiceProvider *pProvider);
 141         void UninitializeHandler();
 142 };
 143
 144 // ITagReplacer
 145 // This interface defines the methods necessary for server response file processing.
 146 __interface ATL_NO_VTABLE __declspec(uuid("8FF5E90C-8CE0-43aa-96C4-3BF930837512"))
 147         ITagReplacer : public IUnknown
 148 {
 149         HTTP_CODE FindReplacementOffset(LPCSTR szMethodName, DWORD *pdwMethodOffset,
 150                                                 LPCSTR szObjectName, DWORD *pdwObjOffset, DWORD *pdwMap, void **ppvParam, IAtlMemMgr *pMemMgr);
 151         HTTP_CODE RenderReplacement(DWORD dwFnOffset, DWORD dwObjOffset, DWORD dwMap, void *pvParam);
 152         HRESULT GetContext(REFIID riid, void** ppv);
 153         IWriteStream *SetStream(IWriteStream *pStream);
 154 };
 155
 156
 157 struct CStencilState;
 158
 159 // IIsapiExtension
 160 // Tnis is the interface to the ISAPI extension of a running ATL Server web
 161 // application. Provides request handler clients with access to functions of the
 162 // ISAPI server.
 163 __interface __declspec(uuid("79DD4A27-D820-4fa6-954D-E1DFC2C05978"))
 164         IIsapiExtension : public IUnknown
 165 {
 166         BOOL DispatchStencilCall(AtlServerRequest *pRequestInfo);
 167         void RequestComplete(AtlServerRequest *pRequestInfo, DWORD hStatus, DWORD dwSubStatus);
 168         BOOL OnThreadAttach();
 169         void OnThreadTerminate();
 170         BOOL QueueRequest(AtlServerRequest *pRequestInfo);
 171         CIsapiWorker *GetThreadWorker();
 172         BOOL SetThreadWorker(CIsapiWorker *pWorker);
 173         HTTP_CODE LoadRequestHandler(LPCSTR szDllPath, LPCSTR szHandlerName, IHttpServerContext *pServerContext,
 174                 HINSTANCE *phInstance, IRequestHandler **ppHandler);
 175         HRESULT AddService(REFGUID guidService, REFIID riid, IUnknown *punk, HINSTANCE hInstance);
 176         HRESULT RemoveService(REFGUID guidService, REFIID riid);
 177         HTTP_CODE LoadDispatchFile(LPCSTR szFileName, AtlServerRequest *pRequestInfo);
 178
 179         AtlServerRequest* CreateRequest();
 180         void FreeRequest(AtlServerRequest* pRequest);
 181         HTTP_CODE TransferRequest(
 182                 AtlServerRequest *pRequest,
 183                 IServiceProvider *pServiceProvider,
 184                 IWriteStream *pWriteStream,
 185                 IHttpRequestLookup *pLookup,
 186                 LPCSTR szNewUrl,
 187                 WORD nCodePage,
 188                 bool bContinueAfterProcess,
 189                 CStencilState *pState);
 190 };
 191
 192 // IPageCacheControl
 193 // This interface controls the cacheability of the current page
 194 __interface ATL_NO_VTABLE __declspec(uuid("9868BFC0-D44D-4154-931C-D186EC0C45D5"))
 195         IPageCacheControl : public IUnknown
 196 {
 197         HRESULT GetExpiration(FILETIME *pftExpiration);
 198         HRESULT SetExpiration(FILETIME ftExpiration);
 199         BOOL IsCached();
 200         BOOL Cache(BOOL bCache);
 201 };
 202
 203 // IRequestStats
 204 // Used to query request statistics from a running ATL server ISAPI application.
 205 __interface ATL_NO_VTABLE __declspec(uuid("2B75C68D-0DDF-48d6-B58A-CC7C2387A6F2"))
 206         IRequestStats : public IUnknown
 207 {
 208         long GetTotalRequests();
 209         long GetFailedRequests();
 210         long GetAvgResponseTime();
 211         long GetCurrWaiting();
 212         long GetMaxWaiting();
 213         long GetActiveThreads();
 214 };
 215
 216 // IBrowserCaps
 217 // Interface that provides information about a particular web brorwser.
 218 // See atlutil.h and the ATL Browser Capabilities service for information
 219 // about this interface's implementation
 220 __interface __declspec(uuid("3339FCE2-99BC-4985-A702-4ABC8304A995"))
 221         IBrowserCaps : public IUnknown
 222 {
 223         HRESULT GetPropertyString(BSTR bstrProperty, BSTR * pbstrOut);
 224         HRESULT GetBooleanPropertyValue(BSTR bstrProperty, BOOL* pbOut);
 225         HRESULT GetBrowserName(BSTR * pbstrName);
 226         HRESULT GetPlatform(BSTR * pbstrPlatform);
 227         HRESULT GetVersion(BSTR * pbstrVersion);
 228         HRESULT GetMajorVer(BSTR * pbstrMajorVer);
 229         HRESULT GetMinorVer(BSTR * pbstrMinorVer);
 230         HRESULT SupportsFrames(BOOL* pbFrames);
 231         HRESULT SupportsTables(BOOL* pbTables);
 232         HRESULT SupportsCookies(BOOL* pbCookies);
 233         HRESULT SupportsBackgroundSounds(BOOL* pbBackgroundSounds);
 234         HRESULT SupportsVBScript(BOOL* pbVBScript);
 235         HRESULT SupportsJavaScript(BOOL* pbJavaScript);
 236         HRESULT SupportsJavaApplets(BOOL* pbJavaApplets);
 237         HRESULT SupportsActiveXControls(BOOL* pbActiveXControls);
 238         HRESULT SupportsCDF(BOOL* pbCDF);
 239         HRESULT SupportsAuthenticodeUpdate(BOOL* pbAuthenticodeUpdate);
 240         HRESULT IsBeta(BOOL* pbIsBeta);
 241         HRESULT IsCrawler(BOOL* pbIsCrawler);
 242         HRESULT IsAOL(BOOL* pbIsAOL);
 243         HRESULT IsWin16(BOOL* pbIsWin16);
 244         HRESULT IsAK(BOOL* pbIsAK);
 245         HRESULT IsSK(BOOL* pbIsSK);
 246         HRESULT IsUpdate(BOOL* pbIsUpdate);
 247 };
 248
 249 // IBrowserCapsSvc.
 250 // Interface on the browser caps service. Used by clients to query a running
 251 // instance of the browser capabilities service for information about a user's web
 252 // browser. See atlutil.h for implementation of the browser capabilities services.
 253 __interface __declspec(uuid("391E7418-863B-430e-81BB-1312ED2FF3E9"))
 254         IBrowserCapsSvc : public IUnknown
 255 {
 256         HRESULT GetCaps(IHttpServerContext * pContext, IBrowserCaps ** ppOut);
 257         HRESULT GetCapsUserAgent(BSTR bstrAgent, IBrowserCaps ** ppOut);
 258 };
 259
 260 class CBrowserCapsSvc : public IBrowserCapsSvc,
 261                                                 public CComObjectRootEx<CComSingleThreadModel>
 262 {
 263 public:
 264         virtual ~CBrowserCapsSvc()
 265         {
 266         }
 267
 268         BEGIN_COM_MAP(CBrowserCapsSvc)
 269                 COM_INTERFACE_ENTRY(IBrowserCapsSvc)
 270         END_COM_MAP()
 271
 272         __success(SUCCEEDED(return)) __checkReturn HRESULT GetCaps(__in IHttpServerContext * pContext, __deref_out_opt IBrowserCaps ** ppOut)
 273         {
 274                 if (!pContext)
 275                         return E_POINTER;
 276
 277                 if (!ppOut)
 278                         return E_POINTER;
 279
 280                 *ppOut = NULL;
 281
 282                 char szUserAgent[256];
 283                 DWORD dwSize = sizeof(szUserAgent);
 284                 if (!pContext->GetServerVariable("HTTP_USER_AGENT", szUserAgent, &dwSize))
 285                         return E_FAIL;
 286
 287                 return GetCapsUserAgent(CComBSTR(szUserAgent), ppOut);
 288         }
 289
 290         __success(SUCCEEDED(return)) __checkReturn HRESULT GetCapsUserAgent(__in BSTR bstrAgent, __deref_out IBrowserCaps ** ppOut)
 291         {
 292         if (::SysStringLen(bstrAgent) == 0 || ppOut == NULL)
 293         {
 294                         return E_POINTER;
 295         }
 296
 297                 *ppOut = NULL;
 298
 299                 BrowserCaps* pCaps = NULL;
 300
 301                 _ATLTRY
 302                 {
 303                         CW2CT szUserAgent(bstrAgent);
 304
 305                         if (!m_mapAgent.Lookup(szUserAgent, pCaps))
 306                         {
 307                                 pCaps = NULL;
 308                                 for (size_t i=0; i<m_caps.GetCount(); i++)
 309                                 {
 310                                         BrowserCaps& caps = m_caps[i];
 311                                         if (IsEqualAgentString(caps.m_strUserAgent, szUserAgent))
 312                                         {
 313                                                 pCaps = &caps;
 314                                                 break;
 315                                         }
 316                                 }
 317                         }
 318                 }
 319                 _ATLCATCHALL()
 320                 {
 321                         return E_FAIL;
 322                 }
 323
 324 #pragma warning(push)
 325 #pragma warning(disable: 6014)
 326                 if (pCaps != NULL)
 327                 {
 328                         CComObjectNoLock<CBrowserCaps> *pRet = NULL;
 329
 330                         ATLTRY(pRet = new CComObjectNoLock<CBrowserCaps>);
 331
 332                         if (!pRet)
 333                                 return E_OUTOFMEMORY;
 334                         pRet->AddRef();
 335
 336                         HRESULT hr = pRet->Initialize(pCaps);
 337                         if (FAILED(hr))
 338                         {
 339                                 pRet->Release();
 340                                 return hr;
 341                         }
 342
 343                         *ppOut = pRet;
 344                         return S_OK;
 345                 }
 346 #pragma warning(pop)
 347
 348                 return E_FAIL;
 349         }
 350
 351         __checkReturn HRESULT Initialize(__in HINSTANCE hInstance) throw()
 352         {
 353                 // tries loading browscap.ini from the same directory as the module
 354                 if (hInstance != NULL)
 355                 {
 356                         _ATLTRY
 357                         {
 358                                 CPath strBrowscapPath;
 359
 360                                 LPTSTR sz = strBrowscapPath.m_strPath.GetBuffer(MAX_PATH);
 361                                 UINT nChars = ::GetModuleFileName(hInstance, sz, MAX_PATH);
 362                                 strBrowscapPath.m_strPath.ReleaseBuffer(nChars);
 363                                 if (nChars != 0 &&
 364                                         nChars != MAX_PATH &&
 365                                         strBrowscapPath.RemoveFileSpec())
 366                                 {
 367                                         strBrowscapPath += _T("\\browscap.ini");
 368                                         if (SUCCEEDED(Load(strBrowscapPath)))
 369                                                 return S_OK;
 370                                 }
 371                         }
 372                         _ATLCATCHALL()
 373                         {
 374                                 return E_FAIL;
 375                         }
 376                 }
 377
 378                 // falls back to the system browscap.ini if previous Load failed
 379                 return Load();
 380         }
 381
 382         HRESULT Uninitialize()
 383         {
 384                 Clear();
 385                 return S_OK;
 386         }
 387
 388 private:
 389         static bool IsEqualAgentString(__in LPCTSTR szPattern, __in LPCTSTR szInput)
 390         {
 391                 while (*szPattern && *szInput && (*szPattern == *szInput || *szPattern == '?'))
 392                 {
 393                         szPattern++;
 394                         szInput++;
 395                 }
 396
 397                 if (*szPattern == *szInput)
 398                 {
 399                         return true;
 400                 }
 401
 402                 if (*szPattern == '*')
 403                 {
 404                         szPattern++;
 405                         if (!*szPattern)
 406                         {
 407                                 return true;
 408                         }
 409                         while(*szInput)
 410                         {
 411                                 if (IsEqualAgentString(szPattern, szInput))
 412                                 {
 413                                         return true;
 414                                 }
 415
 416                                 szInput++;
 417                         }
 418                 }
 419
 420                 return false;
 421         }
 422
 423         __checkReturn HRESULT Load(__in_opt LPCTSTR szPath = NULL)
 424         {
 425                 _ATLTRY
 426                 {
 427                         Clear();
 428
 429                         CString strBrowscapPath(szPath);
 430
 431                         // use default load path if a path isn't specified
 432                         if (strBrowscapPath.IsEmpty())
 433                         {
 434                                 LPTSTR sz = strBrowscapPath.GetBuffer(MAX_PATH);
 435                                 UINT nChars = ::GetSystemDirectory(sz, MAX_PATH);
 436                                 strBrowscapPath.ReleaseBuffer(nChars);
 437                                 if (nChars == 0 || nChars == MAX_PATH)
 438                                         return E_FAIL;
 439
 440                                 strBrowscapPath += _T("\\inetsrv\\browscap.ini");
 441                         }
 442
 443                         size_t nCurrent = 16384;
 444                         CHeapPtr<TCHAR> data;
 445
 446                         if (!data.Allocate(nCurrent))
 447                                 return E_OUTOFMEMORY;
 448
 449                         // load the list of all the user agents
 450                         bool bRetrieved = false;
 451
 452                         do
 453                         {
 454                                 DWORD dwRetrieved = ::GetPrivateProfileSectionNames(data, (DWORD) nCurrent, strBrowscapPath);
 455                                 if (dwRetrieved == 0)
 456                                 {
 457                                         return AtlHresultFromWin32(ERROR_FILE_NOT_FOUND);
 458                                 }
 459                                 else if (dwRetrieved < nCurrent-2)
 460                                 {
 461                                         bRetrieved = true;
 462                                 }
 463                                 else if(SIZE_MAX/2<nCurrent)
 464                                 {
 465                                         return E_OUTOFMEMORY;
 466                                 }
 467                                 else if (!data.Reallocate(nCurrent *= 2))
 468                                 {
 469                                         return E_OUTOFMEMORY;
 470                                 }
 471                         } while (!bRetrieved);
 472
 473                         // figure out how many user agents there are
 474                         // and set them in the structure
 475                         LPTSTR sz = data;
 476                         int nSections = 0;
 477                         while (*sz)
 478                         {
 479                                 nSections++;
 480                                 sz += (lstrlen(sz)+1);
 481                         }
 482
 483                         if (!m_caps.SetCount(nSections))
 484                                 return E_OUTOFMEMORY;
 485
 486                         sz = data;
 487                         nSections = 0;
 488                         while (*sz)
 489                         {
 490                                 BrowserCaps& caps = m_caps[nSections++];
 491                                 caps.m_strUserAgent = sz;
 492                                 m_mapAgent[caps.m_strUserAgent] = &caps;
 493                                 sz += (caps.m_strUserAgent.GetLength()+1);
 494                         }
 495
 496                         // for each user agent, load the properties
 497                         for (size_t i=0; i<m_caps.GetCount(); i++)
 498                         {
 499                                 bRetrieved = false;
 500                                 BrowserCaps& caps = m_caps[i];
 501                                 caps.m_pParent = NULL;
 502
 503                                 do
 504                                 {
 505                                         DWORD dwRetrieved = ::GetPrivateProfileSection(caps.m_strUserAgent, data, (DWORD) nCurrent, strBrowscapPath);
 506                                         if (dwRetrieved == 0)
 507                                         {
 508                                                 return AtlHresultFromWin32(ERROR_FILE_NOT_FOUND);
 509                                         }
 510                                         else if (dwRetrieved < nCurrent-2)
 511                                         {
 512                                                 bRetrieved = true;
 513                                         }
 514                                         else if(SIZE_MAX/2<nCurrent)
 515                                         {
 516                                                 return E_OUTOFMEMORY;
 517                                         }
 518                                         else if (!data.Reallocate(nCurrent *= 2))
 519                                         {
 520                                                 return E_OUTOFMEMORY;
 521                                         }
 522                                 } while (!bRetrieved);
 523
 524                                 sz = data;
 525                                 while (*sz)
 526                                 {
 527                                         CString str = sz;
 528                                         int nChar = str.Find('=');
 529                                         if (nChar != -1)
 530                                         {
 531                                                 CString strPropName = str.Left(nChar);
 532                                                 CString strPropVal = str.Mid(nChar+1);
 533                                                 strPropName.Trim();
 534                                                 strPropVal.Trim();
 535                                                 caps.m_props.SetAt(strPropName, strPropVal);
 536
 537                                                 // if it's the parent property, set up the parent pointer
 538                                                 if (strPropName.CompareNoCase(_T("parent")) == 0)
 539                                                 {
 540                                                         BrowserCaps* pParent = NULL;
 541                                                         if (m_mapAgent.Lookup(strPropVal, pParent))
 542                                                                 caps.m_pParent = pParent;
 543                                                 }
 544                                         }
 545                                         sz += (str.GetLength()+1);
 546                                 }
 547                         }
 548                 }
 549                 _ATLCATCHALL()
 550                 {
 551                         return E_FAIL;
 552                 }
 553
 554                 return S_OK;
 555         }
 556
 557         void Clear()
 558         {
 559                 m_caps.RemoveAll();
 560                 m_mapAgent.RemoveAll();
 561         }
 562
 563         friend class CBrowserCaps;
 564
 565         struct BrowserCaps
 566         {
 567                 CString m_strUserAgent; // user agent string to match against (with wildcards)
 568                 BrowserCaps* m_pParent;
 569                 CAtlMap<CString, CString, CStringElementTraitsI<CString>, CStringElementTraits<CString> > m_props;
 570         };
 571
 572         // map from UserAgent string to caps
 573         // used for non-wildcard lookup and parent lookup
 574         CAtlMap<CString, BrowserCaps*, CStringElementTraits<CString> > m_mapAgent;
 575
 576         // all of the caps
 577         CAtlArray<BrowserCaps> m_caps;
 578
 579         class CBrowserCaps : public IBrowserCaps, public CComObjectRootEx<CComSingleThreadModel>
 580         {
 581         public:
 582
 583                 BEGIN_COM_MAP(CBrowserCaps)
 584                         COM_INTERFACE_ENTRY(IBrowserCaps)
 585                 END_COM_MAP()
 586
 587                 CBrowserCaps()
 588                 {
 589                 }
 590
 591                 HRESULT Initialize(__in CBrowserCapsSvc::BrowserCaps * pCaps)
 592                 {
 593                         m_pCaps = pCaps;
 594                         return S_OK;
 595                 }
 596
 597                 __checkReturn HRESULT GetPropertyString(__in BSTR bstrProperty, __out BSTR * pbstrOut)
 598                 {
 599                         _ATLTRY
 600                         {
 601                                 ATLASSUME(m_pCaps);
 602                                 if (!m_pCaps)
 603                                         return E_UNEXPECTED;
 604
 605                                 if (!pbstrOut)
 606                                         return E_POINTER;
 607
 608                                 *pbstrOut = NULL;
 609
 610                                 CString strName(bstrProperty);
 611                                 CString strVal;
 612
 613                                 CBrowserCapsSvc::BrowserCaps * pCaps = m_pCaps;
 614                                 while (pCaps)
 615                                 {
 616                                         if (pCaps->m_props.Lookup(strName, strVal))
 617                                         {
 618                                                 CComBSTR bstrVal(strVal);
 619                                                 *pbstrOut = bstrVal.Detach();
 620                                                 return S_OK;
 621                                         }
 622
 623                                         pCaps = pCaps->m_pParent;
 624                                 }
 625
 626                                 return S_FALSE;
 627                         }
 628                         _ATLCATCHALL()
 629                         {
 630                                 return E_FAIL;
 631                         }
 632                 }
 633
 634                 __checkReturn HRESULT GetBooleanPropertyValue(__in BSTR bstrProperty, __out BOOL* pbOut)
 635                 {
 636                         if (!pbOut)
 637                                 return E_POINTER;
 638
 639                         CComBSTR bstrOut;
 640                         HRESULT hr = GetPropertyString(bstrProperty, &bstrOut);
 641                         if (FAILED(hr) || S_FALSE == hr)
 642                                 return hr;
 643
 644                         if (_wcsicmp(bstrOut, L"true") == 0)
 645                                 *pbOut = TRUE;
 646                         else
 647                                 *pbOut = FALSE;
 648
 649                         return S_OK;
 650                 }
 651
 652                 __checkReturn HRESULT GetBrowserName(__out BSTR * pbstrName)
 653                 {
 654                         return GetPropertyString(CComBSTR(L"browser"), pbstrName);
 655                 }
 656
 657                 __checkReturn HRESULT GetPlatform(__out BSTR * pbstrPlatform)
 658                 {
 659                         return GetPropertyString(CComBSTR(L"platform"), pbstrPlatform);
 660                 }
 661
 662                 __checkReturn HRESULT GetVersion(__out BSTR * pbstrVersion)
 663                 {
 664                         return GetPropertyString(CComBSTR(L"version"), pbstrVersion);
 665                 }
 666
 667                 __checkReturn HRESULT GetMajorVer(__out BSTR * pbstrMajorVer)
 668                 {
 669                         return GetPropertyString(CComBSTR(L"majorver"), pbstrMajorVer);
 670                 }
 671
 672                 __checkReturn HRESULT GetMinorVer(__out BSTR * pbstrMinorVer)
 673                 {
 674                         return GetPropertyString(CComBSTR(L"minorver"), pbstrMinorVer);
 675                 }
 676
 677                 __checkReturn HRESULT SupportsFrames(__out BOOL* pbFrames)
 678                 {
 679                         return GetBooleanPropertyValue(CComBSTR(L"frames"), pbFrames);
 680                 }
 681
 682                 __checkReturn HRESULT SupportsTables(__out BOOL* pbTables)
 683                 {
 684                         return GetBooleanPropertyValue(CComBSTR(L"tables"), pbTables);
 685                 }
 686                 __checkReturn HRESULT SupportsCookies(__out BOOL* pbCookies)
 687                 {
 688                         return GetBooleanPropertyValue(CComBSTR(L"cookies"), pbCookies);
 689                 }
 690                 __checkReturn HRESULT SupportsBackgroundSounds(__out BOOL* pbBackgroundSounds)
 691                 {
 692                         return GetBooleanPropertyValue(CComBSTR(L"backgroundsounds"), pbBackgroundSounds);
 693                 }
 694                 __checkReturn HRESULT SupportsVBScript(__out BOOL* pbVBScript)
 695                 {
 696                         return GetBooleanPropertyValue(CComBSTR(L"vbscript"), pbVBScript);
 697                 }
 698                 __checkReturn HRESULT SupportsJavaScript(__out BOOL* pbJavaScript)
 699                 {
 700                         return GetBooleanPropertyValue(CComBSTR(L"javascript"), pbJavaScript);
 701                 }
 702                 __checkReturn HRESULT SupportsJavaApplets(__out BOOL* pbJavaApplets)
 703                 {
 704                         return GetBooleanPropertyValue(CComBSTR(L"javaapplets"), pbJavaApplets);
 705                 }
 706                 __checkReturn HRESULT SupportsActiveXControls(__out BOOL* pbActiveXControls)
 707                 {
 708                         return GetBooleanPropertyValue(CComBSTR(L"ActiveXControls"), pbActiveXControls);
 709                 }
 710                 __checkReturn HRESULT SupportsCDF(__out BOOL* pbCDF)
 711                 {
 712                         return GetBooleanPropertyValue(CComBSTR(L"CDF"), pbCDF);
 713                 }
 714                 __checkReturn HRESULT SupportsAuthenticodeUpdate(__out BOOL* pbAuthenticodeUpdate)
 715                 {
 716                         return GetBooleanPropertyValue(CComBSTR(L"AuthenticodeUpdate"), pbAuthenticodeUpdate);
 717                 }
 718                 __checkReturn HRESULT IsBeta(__out BOOL* pbIsBeta)
 719                 {
 720                         return GetBooleanPropertyValue(CComBSTR(L"beta"), pbIsBeta);
 721                 }
 722                 __checkReturn HRESULT IsCrawler(__out BOOL* pbIsCrawler)
 723                 {
 724                         return GetBooleanPropertyValue(CComBSTR(L"Crawler"), pbIsCrawler);
 725                 }
 726                 __checkReturn HRESULT IsAOL(__out BOOL* pbIsAOL)
 727                 {
 728                         return GetBooleanPropertyValue(CComBSTR(L"AOL"), pbIsAOL);
 729                 }
 730                 __checkReturn HRESULT IsWin16(__out BOOL* pbIsWin16)
 731                 {
 732                         return GetBooleanPropertyValue(CComBSTR(L"Win16"), pbIsWin16);
 733                 }
 734                 __checkReturn HRESULT IsAK(__out BOOL* pbIsAK)
 735                 {
 736                         return GetBooleanPropertyValue(CComBSTR(L"AK"), pbIsAK);
 737                 }
 738                 __checkReturn HRESULT IsSK(__out BOOL* pbIsSK)
 739                 {
 740                         return GetBooleanPropertyValue(CComBSTR(L"SK"), pbIsSK);
 741                 }
 742                 __checkReturn HRESULT IsUpdate(__out BOOL* pbIsUpdate)
 743                 {
 744                         return GetBooleanPropertyValue(CComBSTR(L"Update"), pbIsUpdate);
 745                 }
 746
 747         private:
 748                 CBrowserCapsSvc::BrowserCaps * m_pCaps;
 749         };
 750 };
 751
 752 typedef DWORD_PTR HSESSIONENUM;
 753
 754 // ISession
 755 // Interface on a single client session. Used to access variables in the client
 756 // session in the session state services. See atlsession.h for implementation of
 757 // this interface.
 758 __interface __declspec(uuid("DEB69BE3-7AC9-4a13-9519-266C1EA3AB39"))
 759         ISession : public IUnknown
 760 {
 761         STDMETHOD(SetVariable)(LPCSTR szName, VARIANT NewVal);
 762         STDMETHOD(GetVariable)(LPCSTR szName, VARIANT *pVal);
 763         STDMETHOD(GetCount)(long *pnCount);
 764         STDMETHOD(RemoveVariable)(LPCSTR szName);
 765         STDMETHOD(RemoveAllVariables)();
 766         STDMETHOD(BeginVariableEnum)(POSITION *pPOS, HSESSIONENUM *phEnumHandle);
 767         STDMETHOD(GetNextVariable)(POSITION *pPOS, VARIANT *pVal, HSESSIONENUM hEnum, LPSTR szName, DWORD dwLen);
 768         STDMETHOD(CloseEnum)(HSESSIONENUM hEnumHandle);
 769         STDMETHOD(IsExpired)();
 770         STDMETHOD(SetTimeout)(unsigned __int64 dwNewTimeout);
 771 }; //ISession
 772
 773
 774 // ISessionStateService
 775 // Interface on the session state service for an ISAPI application. Request
 776 // handler objects will use this interface to access user sessions. See
 777 // atlsession.h for implementation of this interface.
 778 __interface __declspec(uuid("C5740C4F-0C6D-4b43-92C4-2AF778F35DDE"))
 779         ISessionStateService : public IUnknown
 780 {
 781         STDMETHOD(CreateNewSession)(LPSTR szNewID, DWORD *pdwSize, ISession** ppSession);
 782         STDMETHOD(CreateNewSessionByName)(LPSTR szNewID, ISession** ppSession);
 783         STDMETHOD(GetSession)(LPCSTR szID, ISession **ppSession);
 784         STDMETHOD(CloseSession)(LPCSTR szID);
 785 };
 786
 787 // ISessionStateControl
 788 // Interface used by session state service to get information about the service.
 789 // Currently you can get the count of active sessions and the current default
 790 // timeout for a session.
 791 __interface __declspec(uuid("6C7F5F56-6CBD-49ee-9797-4C837D4C527A"))
 792         ISessionStateControl : public IUnknown
 793 {
 794         STDMETHOD(SetSessionTimeout)(unsigned __int64 nTimeout);
 795         STDMETHOD(GetSessionTimeout)(unsigned __int64 *pnTimeout);
 796         STDMETHOD(GetSessionCount)(DWORD *pnSessionCount);
 797 };
 798
 799 }; // namespace ATL
 800 #pragma pack(pop)
 801
 802 #endif // __ATLSIFACE_H__