hxauthn.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:20k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #ifndef _HXAUTHN_H_
  36. #define _HXAUTHN_H_
  37. /*
  38.  * Forward declarations of some interfaces defined or used here-in.
  39.  */
  40. typedef _INTERFACE  IUnknown     IUnknown;
  41. typedef _INTERFACE  IHXCredRequest     IHXCredRequest;
  42. typedef _INTERFACE  IHXCredRequestResponse     IHXCredRequestResponse;
  43. typedef _INTERFACE  IHXClientAuthConversation     IHXClientAuthConversation;
  44. typedef _INTERFACE  IHXClientAuthResponse     IHXClientAuthResponse;
  45. typedef _INTERFACE  IHXServerAuthConversation     IHXServerAuthConversation;
  46. typedef _INTERFACE  IHXServerAuthResponse     IHXServerAuthResponse;
  47. typedef _INTERFACE  IHXUserContext     IHXUserContext;
  48. typedef _INTERFACE  IHXUserProperties     IHXUserProperties;
  49. typedef _INTERFACE  IHXUserImpersonation     IHXUserImpersonation;
  50. typedef _INTERFACE  IHXChallenge     IHXChallenge;
  51. typedef _INTERFACE  IHXChallengeResponse     IHXChallengeResponse;
  52. typedef _INTERFACE  IHXRequest     IHXRequest;
  53. typedef _INTERFACE  IHXBuffer     IHXBuffer;
  54. typedef _INTERFACE  IHXValues     IHXValues;
  55. /****************************************************************************
  56.  * 
  57.  *  Interface:
  58.  *
  59.  * IHXCredRequest
  60.  *
  61.  *  Purpose:
  62.  *
  63.  * This is queried from the response interface passed into 
  64.  * IHXClientAuthConversation::MakeResponse.  MakeResponse
  65.  * uses it to request the current user to enter their credentials. 
  66.  *
  67.  *  IHXCredRequest:
  68.  *
  69.  * {00002801-0901-11d1-8B06-00A024406D59}
  70.  *
  71.  */
  72. DEFINE_GUID(IID_IHXCredRequest,   0x00002801, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  73. #undef  INTERFACE
  74. #define INTERFACE   IHXCredRequest
  75. DECLARE_INTERFACE_(IHXCredRequest, IUnknown)
  76. {
  77.     /*
  78.      * IUnknown methods
  79.      */
  80.     STDMETHOD(QueryInterface) (THIS_
  81. REFIID riid,
  82. void** ppvObj) PURE;
  83.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  84.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  85.     /************************************************************************
  86.      * Method:
  87.      *     IHXCredRequest::GetCredentials
  88.      * Purpose:
  89.      *     
  90.      *     Call this to request the credentials.  Usually presents UI to 
  91.      *     the user asking for username and password.
  92.      *
  93.      *     While ignored at this time, pValuesCredentialRequest should
  94.      *     contain CString properties that describe the reason for the 
  95.      *     request. (like the URL, the Realm, the Auth protocol, and how 
  96.      *     secure it is, etc..)  In the future this data will be displayed
  97.      *     to the user.
  98.      *
  99.      */
  100.     STDMETHOD(GetCredentials)
  101.     (
  102. THIS_
  103. IHXCredRequestResponse* pCredRequestResponseRequester,
  104. IHXValues* pValuesCredentialRequest
  105.     ) PURE;
  106. };
  107. /****************************************************************************
  108.  * 
  109.  *  Interface:
  110.  *
  111.  * IHXCredRequestResponse
  112.  *
  113.  *  Purpose:
  114.  *
  115.  * This is implemented by a client authenticator in order to receive
  116.  * the credentials requested in IHXCredRequest::GetCredentials
  117.  *
  118.  *  IHXCredRequestResponse:
  119.  *
  120.  * {00002800-0901-11d1-8B06-00A024406D59}
  121.  *
  122.  */
  123. DEFINE_GUID(IID_IHXCredRequestResponse,   0x00002800, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  124. #undef  INTERFACE
  125. #define INTERFACE   IHXCredRequestResponse
  126. DECLARE_INTERFACE_(IHXCredRequestResponse, IUnknown)
  127. {
  128.     /*
  129.      * IUnknown methods
  130.      */
  131.     STDMETHOD(QueryInterface) (THIS_
  132. REFIID riid,
  133. void** ppvObj) PURE;
  134.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  135.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  136.     /************************************************************************
  137.      * Method:
  138.      *     IHXCredRequestResponse::CredentialsReady
  139.      * Purpose:
  140.      *     
  141.      *     Reports the success or failure of 
  142.      *     IHXCredRequest::GetCredentials
  143.      *
  144.      *     If successful pValuesCredentials contains the requested 
  145.      *     credentials.  (usually CString:Username and CString:Password)
  146.      *
  147.      */
  148.     STDMETHOD(CredentialsReady)
  149.     (
  150. THIS_
  151. HX_RESULT ResultStatus,
  152. IHXValues* pValuesCredentials
  153.     ) PURE;
  154. };
  155. /****************************************************************************
  156.  * 
  157.  *  Interface:
  158.  *
  159.  * IHXClientAuthConversation
  160.  *
  161.  *  Purpose:
  162.  *
  163.  * This is implemented by a client authenticator in order to perform 
  164.  * the client side of an authentication protocol.
  165.  *
  166.  *  IHXClientAuthConversation:
  167.  *
  168.  * {00002803-0901-11d1-8B06-00A024406D59}
  169.  *
  170.  */
  171. DEFINE_GUID(IID_IHXClientAuthConversation,   0x00002803, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  172. /*
  173.  *  The IHXCommonClassFactory supports creating an instance
  174.  *  of this object.
  175.  */
  176. #define CLSID_CHXClientAuthenticator IID_IHXClientAuthConversation
  177. #undef  INTERFACE
  178. #define INTERFACE   IHXClientAuthConversation
  179. DECLARE_INTERFACE_(IHXClientAuthConversation, IUnknown)
  180. {
  181.     /*
  182.      * IUnknown methods
  183.      */
  184.     STDMETHOD(QueryInterface) (THIS_
  185. REFIID riid,
  186. void** ppvObj) PURE;
  187.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  188.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  189.     /************************************************************************
  190.      * Method:
  191.      *     IHXClientAuthConversation::MakeResponse
  192.      * Purpose:
  193.      *     
  194.      *     Call this when a challenge is received from the server.
  195.      *     
  196.      *     pRequestChallengeHeaders should contain the server challenge.
  197.      *
  198.      */
  199.     STDMETHOD(MakeResponse)
  200.     (
  201. THIS_
  202. IHXClientAuthResponse* pClientAuthResponseRequester,
  203. IHXRequest* pRequestChallengeHeaders
  204.     ) PURE;
  205.     /************************************************************************
  206.      * Method:
  207.      *     IHXClientAuthConversation::IsDone
  208.      * Purpose:
  209.      *     
  210.      *     Call this to determine whether the conversation is complete.
  211.      *     (some protocols have more then one message exchange.)
  212.      *
  213.      */
  214.     STDMETHOD_(BOOL,IsDone)(THIS) PURE;
  215.     /************************************************************************
  216.      * Method:
  217.      *     IHXClientAuthConversation::Authenticated
  218.      * Purpose:
  219.      *     
  220.      *     Call this to signal the authenticator that the conversation 
  221.      *     just completed succeeded or failed.
  222.      *
  223.      */
  224.     STDMETHOD(Authenticated)(THIS_ BOOL bAuthenticated) PURE;
  225. };
  226. /****************************************************************************
  227.  * 
  228.  *  Interface:
  229.  *
  230.  * IHXClientAuthResponse
  231.  *
  232.  *  Purpose:
  233.  *
  234.  * This is implemented by the client core in order to receive the 
  235.  * response generated by IHXClientAuthConversation::MakeResponse
  236.  *
  237.  *  IHXClientAuthResponse:
  238.  *
  239.  * {00002802-0901-11d1-8B06-00A024406D59}
  240.  *
  241.  */
  242. DEFINE_GUID(IID_IHXClientAuthResponse,   0x00002802, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  243. #undef  INTERFACE
  244. #define INTERFACE   IHXClientAuthResponse
  245. DECLARE_INTERFACE_(IHXClientAuthResponse, IUnknown)
  246. {
  247.     /*
  248.      * IUnknown methods
  249.      */
  250.     STDMETHOD(QueryInterface) (THIS_
  251. REFIID riid,
  252. void** ppvObj) PURE;
  253.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  254.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  255.     /************************************************************************
  256.      * Method:
  257.      *     IHXClientAuthResponse::ResponseReady
  258.      * Purpose:
  259.      *     
  260.      *     Reports the success or failure of 
  261.      *     IHXClientAuthConversation::MakeResponse
  262.      *
  263.      *     pRequestResponseHeaders should be the same Request object 
  264.      *     that was passed into MakeResponse, it should contain
  265.      *     CString values for each MimeHeader it wishes to send to 
  266.      *     the Server.
  267.      *
  268.      */
  269.     STDMETHOD(ResponseReady)
  270.     (
  271. THIS_
  272. HX_RESULT ResultStatus,
  273. IHXRequest* pRequestResponseHeaders
  274.     ) PURE;
  275. };
  276. /****************************************************************************
  277.  * 
  278.  *  Interface:
  279.  *
  280.  * IHXServerAuthConversation
  281.  *
  282.  *  Purpose:
  283.  *
  284.  * This is implemented by a server authenticator in order to perform 
  285.  * the server side of an authentication protocol.
  286.  *
  287.  *  IHXServerAuthConversation:
  288.  *
  289.  * {00002805-0901-11d1-8B06-00A024406D59}
  290.  *
  291.  */
  292. DEFINE_GUID(IID_IHXServerAuthConversation,   0x00002805, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  293. /*
  294.  *  The IHXCommonClassFactory supports creating an instance
  295.  *  of this object.
  296.  */
  297. #define CLSID_CHXServerAuthenticator IID_IHXServerAuthResponse
  298. #undef  INTERFACE
  299. #define INTERFACE   IHXServerAuthConversation
  300. DECLARE_INTERFACE_(IHXServerAuthConversation, IUnknown)
  301. {
  302.     /*
  303.      * IUnknown methods
  304.      */
  305.     STDMETHOD(QueryInterface) (THIS_
  306. REFIID riid,
  307. void** ppvObj) PURE;
  308.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  309.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  310.     /************************************************************************
  311.      * Method:
  312.      *     IHXServerAuthConversation::MakeChallenge
  313.      * Purpose:
  314.      *     
  315.      *     Call this to create a challenge for a client.  If the request 
  316.      *     passed in does not contain a respose from the client, then it 
  317.      *     will generate the initial challenge.
  318.      *
  319.      *     pRequestResponseHeaders is the request for a secured URL.  If
  320.      *     this is the initial request for the URL it probably does not
  321.      *     have any credentials from the client.
  322.      *
  323.      */
  324.     STDMETHOD(MakeChallenge)
  325.     (
  326. THIS_
  327. IHXServerAuthResponse* pServerAuthResponseRequester,
  328. IHXRequest* pRequestResponseHeaders
  329.     ) PURE;
  330.     /************************************************************************
  331.      * Method:
  332.      *     IHXServerAuthConversation::IsAuthenticated
  333.      * Purpose:
  334.      *     
  335.      *     Call this to determine whether the last response from the 
  336.      *     client completed the authentication successfully.
  337.      *
  338.      */
  339.     STDMETHOD_(BOOL,IsAuthenticated)(THIS) PURE;
  340.     /************************************************************************
  341.      * Method:
  342.      *     IHXServerAuthConversation::GetUserContext
  343.      * Purpose:
  344.      *     
  345.      *     Call this to retrieve the Context of the user that completed
  346.      *     authentication successfully.
  347.      *
  348.      *     If successful pUnknownUser is a valid context
  349.      *
  350.      */
  351.     STDMETHOD(GetUserContext)(THIS_ REF(IUnknown*) pUnknownUser) PURE;
  352. };
  353. /****************************************************************************
  354.  * 
  355.  *  Interface:
  356.  *
  357.  * IHXServerAuthResponse
  358.  *
  359.  *  Purpose:
  360.  *
  361.  * This is implemented by various server plugins in order to receive the 
  362.  * challenge generated by IHXServerAuthConversation::MakeChallenge
  363.  *
  364.  *  IHXServerAuthResponse:
  365.  *
  366.  * {00002804-0901-11d1-8B06-00A024406D59}
  367.  *
  368.  */
  369. DEFINE_GUID(IID_IHXServerAuthResponse,   0x00002804, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  370. #undef  INTERFACE
  371. #define INTERFACE   IHXServerAuthResponse
  372. DECLARE_INTERFACE_(IHXServerAuthResponse, IUnknown)
  373. {
  374.     /*
  375.      * IUnknown methods
  376.      */
  377.     STDMETHOD(QueryInterface) (THIS_
  378. REFIID riid,
  379. void** ppvObj) PURE;
  380.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  381.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  382.     /************************************************************************
  383.      * Method:
  384.      *     IHXServerAuthResponse::ChallengeReady
  385.      * Purpose:
  386.      *     
  387.      *     Reports the success or failure of 
  388.      *     IHXServerAuthConversation::MakeChallenge
  389.      *
  390.      *     pRequestChallengeHeaders should be the same Request object 
  391.      *     that was passed into MakeChallenge, it should contain
  392.      *     CString values for each MimeHeader it wishes to send to 
  393.      *     the client.
  394.      *
  395.      */
  396.     STDMETHOD(ChallengeReady)
  397.     (
  398. THIS_
  399. HX_RESULT ResultStatus,
  400. IHXRequest* pRequestChallengeHeaders
  401.     ) PURE;
  402. };
  403. /****************************************************************************
  404.  * 
  405.  *  Interface:
  406.  *
  407.  * IHXUserContext
  408.  *
  409.  *  Purpose:
  410.  *
  411.  * This is implemented by a user context in order to provide 
  412.  * access to information about the currently authenticated user.
  413.  *
  414.  *  IHXUserContext:
  415.  *
  416.  * {00002806-0901-11d1-8B06-00A024406D59}
  417.  *
  418.  */
  419. DEFINE_GUID(IID_IHXUserContext,   0x00002806, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  420. #undef  INTERFACE
  421. #define INTERFACE   IHXUserContext
  422. DECLARE_INTERFACE_(IHXUserContext, IUnknown)
  423. {
  424.     /*
  425.      * IUnknown methods
  426.      */
  427.     STDMETHOD(QueryInterface) (THIS_
  428. REFIID riid,
  429. void** ppvObj) PURE;
  430.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  431.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  432.     /************************************************************************
  433.      * Method:
  434.      *     IHXUserContext::IsMemberOf
  435.      * Purpose:
  436.      *     
  437.      *     Call this to determine whether the authenticated user
  438.      *     is a member of the specified group.
  439.      *
  440.      */
  441.     STDMETHOD(IsMemberOf)(THIS_ IHXBuffer* pBufferGroupID) PURE;
  442. };
  443. /****************************************************************************
  444.  * 
  445.  *  Interface:
  446.  *
  447.  * IHXUserProperties
  448.  *
  449.  *  Purpose:
  450.  *
  451.  * This is implemented by a user context in order to provide 
  452.  * access to properties of the currently authenticated user.
  453.  *
  454.  *  IHXUserProperties:
  455.  *
  456.  * {00002807-0901-11d1-8B06-00A024406D59}
  457.  *
  458.  */
  459. DEFINE_GUID(IID_IHXUserProperties,   0x00002807, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  460. #undef  INTERFACE
  461. #define INTERFACE   IHXUserProperties
  462. DECLARE_INTERFACE_(IHXUserProperties, IUnknown)
  463. {
  464.     /*
  465.      * IUnknown methods
  466.      */
  467.     STDMETHOD(QueryInterface) (THIS_
  468. REFIID riid,
  469. void** ppvObj) PURE;
  470.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  471.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  472.     /************************************************************************
  473.      * Method:
  474.      *     IHXUserProperties::GetPrincipalID
  475.      * Purpose:
  476.      *     
  477.      *     Call this to determine the principalID of the authenticated user.
  478.      *
  479.      */
  480.     STDMETHOD(GetPrincipalID)(THIS_ REF(IHXBuffer*) pBufferPrincipalID) PURE;
  481.     /************************************************************************
  482.      * Method:
  483.      *     IHXUserProperties::GetAuthorityName
  484.      * Purpose:
  485.      *     
  486.      *     Call this to determine the authority name that authorized the 
  487.      *     authenticated user. (realm or domain name)
  488.      *
  489.      */
  490.     STDMETHOD(GetAuthorityName)(THIS_ REF(IHXBuffer*) pBufferAuthorityName) PURE;
  491. };
  492. /****************************************************************************
  493.  * 
  494.  *  Interface:
  495.  *
  496.  * IHXUserImpersonation
  497.  *
  498.  *  Purpose:
  499.  *
  500.  * This can be implemented by a user context in order to provide 
  501.  * the ability to have the server impersonate the currently authenticated
  502.  * user.
  503.  *
  504.  *  IHXUserImpersonation:
  505.  *
  506.  * {00002808-0901-11d1-8B06-00A024406D59}
  507.  *
  508.  */
  509. DEFINE_GUID(IID_IHXUserImpersonation,   0x00002808, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  510. #undef  INTERFACE
  511. #define INTERFACE   IHXUserImpersonation
  512. DECLARE_INTERFACE_(IHXUserImpersonation, IUnknown)
  513. {
  514.     /*
  515.      * IUnknown methods
  516.      */
  517.     STDMETHOD(QueryInterface) (THIS_
  518. REFIID riid,
  519. void** ppvObj) PURE;
  520.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  521.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  522.     /************************************************************************
  523.      * Method:
  524.      *     IHXUserImpersonation::Start
  525.      * Purpose:
  526.      *     
  527.      *     Call this to impersonate the authenticated user.
  528.      *
  529.      */
  530.     STDMETHOD(Start)(THIS) PURE;
  531.     /************************************************************************
  532.      * Method:
  533.      *     IHXUserImpersonation::Stop
  534.      * Purpose:
  535.      *     
  536.      *     Call this to stop impersonating the authenticated user.
  537.      *
  538.      */
  539.     STDMETHOD(Stop)(THIS) PURE;
  540. };
  541. /****************************************************************************
  542.  * 
  543.  *  Interface:
  544.  *
  545.  * IHXChallenge
  546.  *
  547.  *  Purpose:
  548.  *
  549.  * This is implemented by the server core in order to allow 
  550.  * additional exchanges of information with the client without
  551.  * creating a new request. (It is stored in the IHXRequest object
  552.  * and can be retrieved by calling IHXRequestContext::GetRequester()
  553.  * if it is absent then the protocol that this request was made on 
  554.  * does not support multi-message authentication (PNA doesn't) )
  555.  *
  556.  *  IHXChallenge:
  557.  *
  558.  * {0000280A-0901-11d1-8B06-00A024406D59}
  559.  *
  560.  */
  561. DEFINE_GUID(IID_IHXChallenge,   0x0000280A, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  562. #undef  INTERFACE
  563. #define INTERFACE   IHXChallenge
  564. DECLARE_INTERFACE_(IHXChallenge, IUnknown)
  565. {
  566.     /*
  567.      * IUnknown methods
  568.      */
  569.     STDMETHOD(QueryInterface) (THIS_
  570. REFIID riid,
  571. void** ppvObj) PURE;
  572.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  573.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  574.     /************************************************************************
  575.      * Method:
  576.      *     IHXChallenge::SendChallenge
  577.      * Purpose:
  578.      *     
  579.      *     Call this to request additional information from the client.
  580.      *
  581.      *     pRequestChallenge should be the same Request object 
  582.      *     that was passed into MakeChallenge, it should contain
  583.      *     CString values for each MimeHeader it wishes to send to 
  584.      *     the client.
  585.      *
  586.      */
  587.     STDMETHOD(SendChallenge)
  588.     (
  589. THIS_
  590. IHXChallengeResponse* pChallengeResponseSender,
  591. IHXRequest* pRequestChallenge
  592.     ) PURE;
  593. };
  594. /****************************************************************************
  595.  * 
  596.  *  Interface:
  597.  *
  598.  * IHXChallengeResponse
  599.  *
  600.  *  Purpose:
  601.  *
  602.  * This is implemented by a server authenticator in order to 
  603.  * receive the Response returned by the client in response to 
  604.  * IHXChallenge::SendChallenge.
  605.  *
  606.  *  IHXChallengeResponse:
  607.  *
  608.  * {00002809-0901-11d1-8B06-00A024406D59}
  609.  *
  610.  */
  611. DEFINE_GUID(IID_IHXChallengeResponse,   0x00002809, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  612. #undef  INTERFACE
  613. #define INTERFACE   IHXChallengeResponse
  614. DECLARE_INTERFACE_(IHXChallengeResponse, IUnknown)
  615. {
  616.     /*
  617.      * IUnknown methods
  618.      */
  619.     STDMETHOD(QueryInterface) (THIS_
  620. REFIID riid,
  621. void** ppvObj) PURE;
  622.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  623.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  624.     /************************************************************************
  625.      * Method:
  626.      *     IHXChallengeResponse::ResponseReady
  627.      * Purpose:
  628.      *     
  629.      *     Called this to return the additional information requested 
  630.      *     from IHXChallenge::SendChallenge.
  631.      *
  632.      *     pRequestResponse should be the same Request object 
  633.      *     that was passed into MakeChallenge and SendChallenge.
  634.      *
  635.      */
  636.     STDMETHOD(ResponseReady)
  637.     (
  638. THIS_
  639. IHXRequest* pRequestResponse
  640.     ) PURE;
  641. };
  642. #endif //!_HXAUTHN_H_