include/realmedia/rmaauthn.h

   1 /****************************************************************************
   2  *
   3  *  $Id: rmaauthn.h 7 2003-05-30 02:18:02Z gabest $
   4  *
   5  *  Copyright (C) 1995-1999 RealNetworks, Inc. All rights reserved.
   6  *
   7  *  http://www.real.com/devzone
   8  *
   9  *  This program contains proprietary
  10  *  information of Progressive Networks, Inc, and is licensed
  11  *  subject to restrictions on use and distribution.
  12  *
  13  *
  14  *  RealMedia Architecture Interface.
  15  *
  16  */
  17
  18 #ifndef _RMAAUTHN_H_
  19 #define _RMAAUTHN_H_
  20
  21 /*
  22  * Forward declarations of some interfaces defined or used here-in.
  23  */
  24 typedef _INTERFACE  IUnknown                        IUnknown;
  25 typedef _INTERFACE  IRMACredRequest                 IRMACredRequest;
  26 typedef _INTERFACE  IRMACredRequestResponse         IRMACredRequestResponse;
  27 typedef _INTERFACE  IRMAClientAuthConversation      IRMAClientAuthConversation;
  28 typedef _INTERFACE  IRMAClientAuthResponse          IRMAClientAuthResponse;
  29 typedef _INTERFACE  IRMAServerAuthConversation      IRMAServerAuthConversation;
  30 typedef _INTERFACE  IRMAServerAuthResponse          IRMAServerAuthResponse;
  31 typedef _INTERFACE  IRMAUserContext                 IRMAUserContext;
  32 typedef _INTERFACE  IRMAUserProperties              IRMAUserProperties;
  33 typedef _INTERFACE  IRMAUserImpersonation           IRMAUserImpersonation;
  34 typedef _INTERFACE  IRMAChallenge                   IRMAChallenge;
  35 typedef _INTERFACE  IRMAChallengeResponse           IRMAChallengeResponse;
  36 typedef _INTERFACE  IRMARequest                     IRMARequest;
  37 typedef _INTERFACE  IRMABuffer                      IRMABuffer;
  38 typedef _INTERFACE  IRMAValues                      IRMAValues;
  39
  40
  41 /****************************************************************************
  42  *
  43  *  Interface:
  44  *
  45  *      IRMACredRequest
  46  *
  47  *  Purpose:
  48  *
  49  *      This is queried from the response interface passed into
  50  *      IRMAClientAuthConversation::MakeResponse.  MakeResponse
  51  *      uses it to request the current user to enter their credentials.
  52  *
  53  *  IRMACredRequest:
  54  *
  55  *      {00002801-0901-11d1-8B06-00A024406D59}
  56  *
  57  */
  58 DEFINE_GUID(IID_IRMACredRequest,   0x00002801, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
  59
  60 #undef  INTERFACE
  61 #define INTERFACE   IRMACredRequest
  62
  63 DECLARE_INTERFACE_(IRMACredRequest, IUnknown)
  64 {
  65     /*
  66      *  IUnknown methods
  67      */
  68     STDMETHOD(QueryInterface)   (THIS_
  69                                 REFIID riid,
  70                                 void** ppvObj) PURE;
  71
  72     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
  73
  74     STDMETHOD_(ULONG,Release)   (THIS) PURE;
  75
  76     /************************************************************************
  77      *  Method:
  78      *      IRMACredRequest::GetCredentials
  79      *  Purpose:
  80      *
  81      *      Call this to request the credentials.  Usually presents UI to
  82      *      the user asking for username and password.
  83      *
  84      *      While ignored at this time, pValuesCredentialRequest should
  85      *      contain CString properties that describe the reason for the
  86      *      request. (like the URL, the Realm, the Auth protocol, and how
  87      *      secure it is, etc..)  In the future this data will be displayed
  88      *      to the user.
  89      *
  90      */
  91     STDMETHOD(GetCredentials)
  92     (
  93         THIS_
  94         IRMACredRequestResponse* pCredRequestResponseRequester,
  95         IRMAValues* pValuesCredentialRequest
  96     ) PURE;
  97
  98 };
  99
 100 /****************************************************************************
 101  *
 102  *  Interface:
 103  *
 104  *      IRMACredRequestResponse
 105  *
 106  *  Purpose:
 107  *
 108  *      This is implemented by a client authenticator in order to receive
 109  *      the credentials requested in IRMACredRequest::GetCredentials
 110  *
 111  *  IRMACredRequestResponse:
 112  *
 113  *      {00002800-0901-11d1-8B06-00A024406D59}
 114  *
 115  */
 116 DEFINE_GUID(IID_IRMACredRequestResponse,   0x00002800, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 117
 118 #undef  INTERFACE
 119 #define INTERFACE   IRMACredRequestResponse
 120
 121 DECLARE_INTERFACE_(IRMACredRequestResponse, IUnknown)
 122 {
 123     /*
 124      *  IUnknown methods
 125      */
 126     STDMETHOD(QueryInterface)   (THIS_
 127                                 REFIID riid,
 128                                 void** ppvObj) PURE;
 129
 130     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 131
 132     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 133
 134     /************************************************************************
 135      *  Method:
 136      *      IRMACredRequestResponse::CredentialsReady
 137      *  Purpose:
 138      *
 139      *      Reports the success or failure of
 140      *      IRMACredRequest::GetCredentials
 141      *
 142      *      If successful pValuesCredentials contains the requested
 143      *      credentials.  (usually CString:Username and CString:Password)
 144      *
 145      */
 146     STDMETHOD(CredentialsReady)
 147     (
 148         THIS_
 149         PN_RESULT       ResultStatus,
 150         IRMAValues* pValuesCredentials
 151     ) PURE;
 152
 153 };
 154
 155 /****************************************************************************
 156  *
 157  *  Interface:
 158  *
 159  *      IRMAClientAuthConversation
 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  *  IRMAClientAuthConversation:
 167  *
 168  *      {00002803-0901-11d1-8B06-00A024406D59}
 169  *
 170  */
 171 DEFINE_GUID(IID_IRMAClientAuthConversation,   0x00002803, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 172
 173 /*
 174  *  The IRMACommonClassFactory supports creating an instance
 175  *  of this object.
 176  */
 177 #define CLSID_CRMAClientAuthenticator IID_IRMAClientAuthConversation
 178
 179 #undef  INTERFACE
 180 #define INTERFACE   IRMAClientAuthConversation
 181
 182 DECLARE_INTERFACE_(IRMAClientAuthConversation, IUnknown)
 183 {
 184     /*
 185      *  IUnknown methods
 186      */
 187     STDMETHOD(QueryInterface)   (THIS_
 188                                 REFIID riid,
 189                                 void** ppvObj) PURE;
 190
 191     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 192
 193     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 194
 195     /************************************************************************
 196      *  Method:
 197      *      IRMAClientAuthConversation::MakeResponse
 198      *  Purpose:
 199      *
 200      *      Call this when a challenge is received from the server.
 201      *
 202      *      pRequestChallengeHeaders should contain the server challenge.
 203      *
 204      */
 205     STDMETHOD(MakeResponse)
 206     (
 207         THIS_
 208         IRMAClientAuthResponse* pClientAuthResponseRequester,
 209         IRMARequest*    pRequestChallengeHeaders
 210     ) PURE;
 211
 212     /************************************************************************
 213      *  Method:
 214      *      IRMAClientAuthConversation::IsDone
 215      *  Purpose:
 216      *
 217      *      Call this to determine whether the conversation is complete.
 218      *      (some protocols have more then one message exchange.)
 219      *
 220      */
 221     STDMETHOD_(BOOL,IsDone)(THIS) PURE;
 222
 223     /************************************************************************
 224      *  Method:
 225      *      IRMAClientAuthConversation::Authenticated
 226      *  Purpose:
 227      *
 228      *      Call this to signal the authenticator that the conversation
 229      *      just completed succeeded or failed.
 230      *
 231      */
 232     STDMETHOD(Authenticated)(THIS_ BOOL bAuthenticated) PURE;
 233 };
 234
 235 /****************************************************************************
 236  *
 237  *  Interface:
 238  *
 239  *      IRMAClientAuthResponse
 240  *
 241  *  Purpose:
 242  *
 243  *      This is implemented by the client core in order to receive the
 244  *      response generated by IRMAClientAuthConversation::MakeResponse
 245  *
 246  *  IRMAClientAuthResponse:
 247  *
 248  *      {00002802-0901-11d1-8B06-00A024406D59}
 249  *
 250  */
 251 DEFINE_GUID(IID_IRMAClientAuthResponse,   0x00002802, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 252
 253 #undef  INTERFACE
 254 #define INTERFACE   IRMAClientAuthResponse
 255
 256 DECLARE_INTERFACE_(IRMAClientAuthResponse, IUnknown)
 257 {
 258     /*
 259      *  IUnknown methods
 260      */
 261     STDMETHOD(QueryInterface)   (THIS_
 262                                 REFIID riid,
 263                                 void** ppvObj) PURE;
 264
 265     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 266
 267     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 268
 269     /************************************************************************
 270      *  Method:
 271      *      IRMAClientAuthResponse::ResponseReady
 272      *  Purpose:
 273      *
 274      *      Reports the success or failure of
 275      *      IRMAClientAuthConversation::MakeResponse
 276      *
 277      *      pRequestResponseHeaders should be the same Request object
 278      *      that was passed into MakeResponse, it should contain
 279      *      CString values for each MimeHeader it wishes to send to
 280      *      the Server.
 281      *
 282      */
 283     STDMETHOD(ResponseReady)
 284     (
 285         THIS_
 286         PN_RESULT       ResultStatus,
 287         IRMARequest*    pRequestResponseHeaders
 288     ) PURE;
 289
 290 };
 291
 292
 293 /****************************************************************************
 294  *
 295  *  Interface:
 296  *
 297  *      IRMAServerAuthConversation
 298  *
 299  *  Purpose:
 300  *
 301  *      This is implemented by a server authenticator in order to perform
 302  *      the server side of an authentication protocol.
 303  *
 304  *  IRMAServerAuthConversation:
 305  *
 306  *      {00002805-0901-11d1-8B06-00A024406D59}
 307  *
 308  */
 309 DEFINE_GUID(IID_IRMAServerAuthConversation,   0x00002805, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 310
 311 /*
 312  *  The IRMACommonClassFactory supports creating an instance
 313  *  of this object.
 314  */
 315 #define CLSID_CRMAServerAuthenticator IID_IRMAServerAuthResponse
 316
 317 #undef  INTERFACE
 318 #define INTERFACE   IRMAServerAuthConversation
 319
 320 DECLARE_INTERFACE_(IRMAServerAuthConversation, IUnknown)
 321 {
 322     /*
 323      *  IUnknown methods
 324      */
 325     STDMETHOD(QueryInterface)   (THIS_
 326                                 REFIID riid,
 327                                 void** ppvObj) PURE;
 328
 329     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 330
 331     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 332
 333     /************************************************************************
 334      *  Method:
 335      *      IRMAServerAuthConversation::MakeChallenge
 336      *  Purpose:
 337      *
 338      *      Call this to create a challenge for a client.  If the request
 339      *      passed in does not contain a respose from the client, then it
 340      *      will generate the initial challenge.
 341      *
 342      *      pRequestResponseHeaders is the request for a secured URL.  If
 343      *      this is the initial request for the URL it probably does not
 344      *      have any credentials from the client.
 345      *
 346      */
 347     STDMETHOD(MakeChallenge)
 348     (
 349         THIS_
 350         IRMAServerAuthResponse* pServerAuthResponseRequester,
 351         IRMARequest*            pRequestResponseHeaders
 352     ) PURE;
 353
 354     /************************************************************************
 355      *  Method:
 356      *      IRMAServerAuthConversation::IsAuthenticated
 357      *  Purpose:
 358      *
 359      *      Call this to determine whether the last response from the
 360      *      client completed the authentication successfully.
 361      *
 362      */
 363     STDMETHOD_(BOOL,IsAuthenticated)(THIS) PURE;
 364
 365     /************************************************************************
 366      *  Method:
 367      *      IRMAServerAuthConversation::GetUserContext
 368      *  Purpose:
 369      *
 370      *      Call this to retrieve the Context of the user that completed
 371      *      authentication successfully.
 372      *
 373      *      If successful pUnknownUser is a valid context
 374      *
 375      */
 376     STDMETHOD(GetUserContext)(THIS_ REF(IUnknown*) pUnknownUser) PURE;
 377
 378 };
 379
 380 /****************************************************************************
 381  *
 382  *  Interface:
 383  *
 384  *      IRMAServerAuthResponse
 385  *
 386  *  Purpose:
 387  *
 388  *      This is implemented by various server plugins in order to receive the
 389  *      challenge generated by IRMAServerAuthConversation::MakeChallenge
 390  *
 391  *  IRMAServerAuthResponse:
 392  *
 393  *      {00002804-0901-11d1-8B06-00A024406D59}
 394  *
 395  */
 396 DEFINE_GUID(IID_IRMAServerAuthResponse,   0x00002804, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 397
 398 #undef  INTERFACE
 399 #define INTERFACE   IRMAServerAuthResponse
 400
 401 DECLARE_INTERFACE_(IRMAServerAuthResponse, IUnknown)
 402 {
 403     /*
 404      *  IUnknown methods
 405      */
 406     STDMETHOD(QueryInterface)   (THIS_
 407                                 REFIID riid,
 408                                 void** ppvObj) PURE;
 409
 410     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 411
 412     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 413
 414     /************************************************************************
 415      *  Method:
 416      *      IRMAServerAuthResponse::ChallengeReady
 417      *  Purpose:
 418      *
 419      *      Reports the success or failure of
 420      *      IRMAServerAuthConversation::MakeChallenge
 421      *
 422      *      pRequestChallengeHeaders should be the same Request object
 423      *      that was passed into MakeChallenge, it should contain
 424      *      CString values for each MimeHeader it wishes to send to
 425      *      the client.
 426      *
 427      */
 428     STDMETHOD(ChallengeReady)
 429     (
 430         THIS_
 431         PN_RESULT       ResultStatus,
 432         IRMARequest*    pRequestChallengeHeaders
 433     ) PURE;
 434
 435 };
 436
 437
 438 /****************************************************************************
 439  *
 440  *  Interface:
 441  *
 442  *      IRMAUserContext
 443  *
 444  *  Purpose:
 445  *
 446  *      This is implemented by a user context in order to provide
 447  *      access to information about the currently authenticated user.
 448  *
 449  *  IRMAUserContext:
 450  *
 451  *      {00002806-0901-11d1-8B06-00A024406D59}
 452  *
 453  */
 454 DEFINE_GUID(IID_IRMAUserContext,   0x00002806, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 455
 456 #undef  INTERFACE
 457 #define INTERFACE   IRMAUserContext
 458
 459 DECLARE_INTERFACE_(IRMAUserContext, IUnknown)
 460 {
 461     /*
 462      *  IUnknown methods
 463      */
 464     STDMETHOD(QueryInterface)   (THIS_
 465                                 REFIID riid,
 466                                 void** ppvObj) PURE;
 467
 468     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 469
 470     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 471
 472     /************************************************************************
 473      *  Method:
 474      *      IRMAUserContext::IsMemberOf
 475      *  Purpose:
 476      *
 477      *      Call this to determine whether the authenticated user
 478      *      is a member of the specified group.
 479      *
 480      */
 481     STDMETHOD(IsMemberOf)(THIS_ IRMABuffer* pBufferGroupID) PURE;
 482 };
 483
 484
 485 /****************************************************************************
 486  *
 487  *  Interface:
 488  *
 489  *      IRMAUserProperties
 490  *
 491  *  Purpose:
 492  *
 493  *      This is implemented by a user context in order to provide
 494  *      access to properties of the currently authenticated user.
 495  *
 496  *  IRMAUserProperties:
 497  *
 498  *      {00002807-0901-11d1-8B06-00A024406D59}
 499  *
 500  */
 501 DEFINE_GUID(IID_IRMAUserProperties,   0x00002807, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 502
 503 #undef  INTERFACE
 504 #define INTERFACE   IRMAUserProperties
 505
 506 DECLARE_INTERFACE_(IRMAUserProperties, IUnknown)
 507 {
 508     /*
 509      *  IUnknown methods
 510      */
 511     STDMETHOD(QueryInterface)   (THIS_
 512                                 REFIID riid,
 513                                 void** ppvObj) PURE;
 514
 515     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 516
 517     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 518
 519
 520     /************************************************************************
 521      *  Method:
 522      *      IRMAUserProperties::GetPrincipalID
 523      *  Purpose:
 524      *
 525      *      Call this to determine the principalID of the authenticated user.
 526      *
 527      */
 528     STDMETHOD(GetPrincipalID)(THIS_ REF(IRMABuffer*) pBufferPrincipalID) PURE;
 529
 530     /************************************************************************
 531      *  Method:
 532      *      IRMAUserProperties::GetAuthorityName
 533      *  Purpose:
 534      *
 535      *      Call this to determine the authority name that authorized the
 536      *      authenticated user. (realm or domain name)
 537      *
 538      */
 539     STDMETHOD(GetAuthorityName)(THIS_ REF(IRMABuffer*) pBufferAuthorityName) PURE;
 540
 541 };
 542
 543
 544 /****************************************************************************
 545  *
 546  *  Interface:
 547  *
 548  *      IRMAUserImpersonation
 549  *
 550  *  Purpose:
 551  *
 552  *      This can be implemented by a user context in order to provide
 553  *      the ability to have the server impersonate the currently authenticated
 554  *      user.
 555  *
 556  *  IRMAUserImpersonation:
 557  *
 558  *      {00002808-0901-11d1-8B06-00A024406D59}
 559  *
 560  */
 561 DEFINE_GUID(IID_IRMAUserImpersonation,   0x00002808, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 562
 563 #undef  INTERFACE
 564 #define INTERFACE   IRMAUserImpersonation
 565
 566 DECLARE_INTERFACE_(IRMAUserImpersonation, IUnknown)
 567 {
 568     /*
 569      *  IUnknown methods
 570      */
 571     STDMETHOD(QueryInterface)   (THIS_
 572                                 REFIID riid,
 573                                 void** ppvObj) PURE;
 574
 575     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 576
 577     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 578
 579     /************************************************************************
 580      *  Method:
 581      *      IRMAUserImpersonation::Start
 582      *  Purpose:
 583      *
 584      *      Call this to impersonate the authenticated user.
 585      *
 586      */
 587     STDMETHOD(Start)(THIS) PURE;
 588
 589     /************************************************************************
 590      *  Method:
 591      *      IRMAUserImpersonation::Stop
 592      *  Purpose:
 593      *
 594      *      Call this to stop impersonating the authenticated user.
 595      *
 596      */
 597     STDMETHOD(Stop)(THIS) PURE;
 598
 599 };
 600
 601 /****************************************************************************
 602  *
 603  *  Interface:
 604  *
 605  *      IRMAChallenge
 606  *
 607  *  Purpose:
 608  *
 609  *      This is implemented by the server core in order to allow
 610  *      additional exchanges of information with the client without
 611  *      creating a new request. (It is stored in the IRMARequest object
 612  *      and can be retrieved by calling IRMARequestContext::GetRequester()
 613  *      if it is absent then the protocol that this request was made on
 614  *      does not support multi-message authentication (PNA doesn't) )
 615  *
 616  *  IRMAChallenge:
 617  *
 618  *      {0000280A-0901-11d1-8B06-00A024406D59}
 619  *
 620  */
 621 DEFINE_GUID(IID_IRMAChallenge,   0x0000280A, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 622
 623 #undef  INTERFACE
 624 #define INTERFACE   IRMAChallenge
 625
 626 DECLARE_INTERFACE_(IRMAChallenge, IUnknown)
 627 {
 628     /*
 629      *  IUnknown methods
 630      */
 631     STDMETHOD(QueryInterface)   (THIS_
 632                                 REFIID riid,
 633                                 void** ppvObj) PURE;
 634
 635     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 636
 637     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 638
 639     /************************************************************************
 640      *  Method:
 641      *      IRMAChallenge::SendChallenge
 642      *  Purpose:
 643      *
 644      *      Call this to request additional information from the client.
 645      *
 646      *      pRequestChallenge should be the same Request object
 647      *      that was passed into MakeChallenge, it should contain
 648      *      CString values for each MimeHeader it wishes to send to
 649      *      the client.
 650      *
 651      */
 652     STDMETHOD(SendChallenge)
 653     (
 654         THIS_
 655         IRMAChallengeResponse* pChallengeResponseSender,
 656         IRMARequest* pRequestChallenge
 657     ) PURE;
 658
 659 };
 660
 661 /****************************************************************************
 662  *
 663  *  Interface:
 664  *
 665  *      IRMAChallengeResponse
 666  *
 667  *  Purpose:
 668  *
 669  *      This is implemented by a server authenticator in order to
 670  *      receive the Response returned by the client in response to
 671  *      IRMAChallenge::SendChallenge.
 672  *
 673  *  IRMAChallengeResponse:
 674  *
 675  *      {00002809-0901-11d1-8B06-00A024406D59}
 676  *
 677  */
 678 DEFINE_GUID(IID_IRMAChallengeResponse,   0x00002809, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
 679
 680 #undef  INTERFACE
 681 #define INTERFACE   IRMAChallengeResponse
 682
 683 DECLARE_INTERFACE_(IRMAChallengeResponse, IUnknown)
 684 {
 685     /*
 686      *  IUnknown methods
 687      */
 688     STDMETHOD(QueryInterface)   (THIS_
 689                                 REFIID riid,
 690                                 void** ppvObj) PURE;
 691
 692     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 693
 694     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 695
 696     /************************************************************************
 697      *  Method:
 698      *      IRMAChallengeResponse::ResponseReady
 699      *  Purpose:
 700      *
 701      *      Called this to return the additional information requested
 702      *      from IRMAChallenge::SendChallenge.
 703      *
 704      *      pRequestResponse should be the same Request object
 705      *      that was passed into MakeChallenge and SendChallenge.
 706      *
 707      */
 708     STDMETHOD(ResponseReady)
 709     (
 710         THIS_
 711         IRMARequest* pRequestResponse
 712     ) PURE;
 713
 714 };
 715
 716 #endif //!_RMAAUTHN_H_