include/realmedia/rmafiles.h

   1 /****************************************************************************
   2  *
   3  *  $Id: rmafiles.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 File Format and File System Plug-in Interfaces.
  15  *
  16  */
  17
  18 #ifndef _RMAFILES_H_
  19 #define _RMAFILES_H_
  20
  21 /*
  22  * Forward declarations of some interfaces defined here-in.
  23  */
  24 typedef _INTERFACE      IRMAFileObject                  IRMAFileObject;
  25 typedef _INTERFACE      IRMAFileResponse                IRMAFileResponse;
  26 typedef _INTERFACE      IRMAFileSystemObject            IRMAFileSystemObject;
  27 typedef _INTERFACE      IRMAFileStat                    IRMAFileStat;
  28 typedef _INTERFACE      IRMAFileStatResponse            IRMAFileStatResponse;
  29
  30 typedef _INTERFACE      IRMAFileSystemManager           IRMAFileSystemManager;
  31 typedef _INTERFACE      IRMAFileSystemManagerResponse   IRMAFileSystemManagerResponse;
  32 typedef _INTERFACE      IRMAFileExists                  IRMAFileExists;
  33 typedef _INTERFACE      IRMAFileExistsResponse          IRMAFileExistsResponse;
  34 typedef _INTERFACE      IRMAFileMimeMapper              IRMAFileMimeMapper;
  35 typedef _INTERFACE      IRMAFileMimeMapperResponse      IRMAFileMimeMapperResponse;
  36 typedef _INTERFACE      IRMABroadcastMapper             IRMABroadcastMapper;
  37 typedef _INTERFACE      IRMABroadcastMapperResponse     IRMABroadcastMapperResponse;
  38 typedef _INTERFACE      IRMAGetFileFromSamePoolResponse IRMAGetFileFromSamePoolResponse;
  39 typedef _INTERFACE      IRMABuffer                      IRMABuffer;
  40 typedef _INTERFACE      IRMAPacket                      IRMAPacket;
  41 typedef _INTERFACE      IRMAValues                      IRMAValues;
  42 typedef _INTERFACE      IRMAMetaCreation                IRMAMetaCreation;
  43
  44 typedef _INTERFACE      IRMAAuthenticator               IRMAAuthenticator;
  45 typedef _INTERFACE      IRMARequest                     IRMARequest;
  46 typedef _INTERFACE      IRMAFileRename                  IRMAFileRename;
  47 typedef _INTERFACE      IRMADirHandler                  IRMADirHandler;
  48 typedef _INTERFACE      IRMADirHandlerResponse          IRMADirHandlerResponse;
  49 typedef _INTERFACE      IRMAFileRemove                  IRMAFileRemove;
  50
  51
  52
  53 /****************************************************************************
  54  *  Defines:
  55  *      PN_FILE_XXXX
  56  *  Purpose:
  57  *      Flags for opening file objects
  58  */
  59 #define PN_FILE_READ            1
  60 #define PN_FILE_WRITE           2
  61 #define PN_FILE_BINARY          4
  62 #define PN_FILE_NOTRUNC         8
  63
  64
  65 /****************************************************************************
  66  *  Defines:
  67  *      RMA_FILEADVISE_XXXX
  68  *  Purpose:
  69  *      Flags for file object Advise method
  70  */
  71 #define RMA_FILEADVISE_RANDOMACCESS             1
  72
  73
  74 #if defined(_UNIX) || defined(_WINDOWS)
  75 #include <sys/stat.h>
  76 /*
  77  * This is a subset of standard stat()/fstat() values that both Unix and
  78  * Windows support (or at least define).
  79  *
  80  * These flags are returned from IRMAFileStatResponse::StatDone() in the
  81  * ulMode argument.
  82  */
  83 #define PN_S_IFMT   S_IFMT
  84 #define PN_S_IFDIR  S_IFDIR
  85 #define PN_S_IFCHR  S_IFCHR
  86 #define PN_S_IFIFO  S_IFIFO
  87 #define PN_S_IFREG  S_IFREG
  88 #else
  89 /* Macintosh */
  90 #define PN_S_IFMT   0170000
  91 #define PN_S_IFDIR  0040000
  92 #define PN_S_IFCHR  0020000
  93 #define PN_S_IFIFO  0010000
  94 #define PN_S_IFREG  0100000
  95 #endif
  96
  97
  98 /****************************************************************************
  99  *
 100  *  Interface:
 101  *
 102  *      IRMAFileObject
 103  *
 104  *  Purpose:
 105  *
 106  *      Object that exports file control API
 107  *
 108  *  IID_IRMAFileObject:
 109  *
 110  *      {00000200-0901-11d1-8B06-00A024406D59}
 111  *
 112  */
 113 DEFINE_GUID(IID_IRMAFileObject, 0x00000200, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 114                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 115
 116 #undef  INTERFACE
 117 #define INTERFACE   IRMAFileObject
 118
 119 DECLARE_INTERFACE_(IRMAFileObject, IUnknown)
 120 {
 121     /*
 122      *  IUnknown methods
 123      */
 124     STDMETHOD(QueryInterface)   (THIS_
 125                                 REFIID riid,
 126                                 void** ppvObj) PURE;
 127
 128     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 129
 130     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 131
 132     /*
 133      *  IRMAFileObject methods
 134      */
 135
 136     /************************************************************************
 137      *  Method:
 138      *      IRMAFileObject::Init
 139      *  Purpose:
 140      *      Associates a file object with the file response object it should
 141      *      notify of operation completness. This method should also check
 142      *      for validity of the object (for example by opening it if it is
 143      *      a local file).
 144      */
 145     STDMETHOD(Init)     (THIS_
 146                         ULONG32             /*IN*/  ulFlags,
 147                         IRMAFileResponse*   /*IN*/  pFileResponse) PURE;
 148
 149     /************************************************************************
 150      *  Method:
 151      *      IRMAFileObject::GetFilename
 152      *  Purpose:
 153      *      Returns the filename (without any path information) associated
 154      *      with a file object.
 155      *
 156      *      Note: The returned pointer's lifetime expires as soon as the
 157      *      caller returns from a function which was called from the RMA
 158      *      core (i.e. when you return control to the RMA core)
 159      *
 160      */
 161     STDMETHOD(GetFilename)      (THIS_
 162                                 REF(const char*)    /*OUT*/  pFilename) PURE;
 163
 164     /************************************************************************
 165      *  Method:
 166      *      IRMAFileObject::Close
 167      *  Purpose:
 168      *      Closes the file resource and releases all resources associated
 169      *      with the object.
 170      */
 171     STDMETHOD(Close)    (THIS) PURE;
 172
 173     /************************************************************************
 174      *  Method:
 175      *      IRMAFileObject::Read
 176      *  Purpose:
 177      *      Reads a buffer of data of the specified length from the file
 178      *      and asynchronously returns it to the caller via the
 179      *      IRMAFileResponse interface passed in to Init.
 180      */
 181     STDMETHOD(Read)     (THIS_
 182                         ULONG32 ulCount) PURE;
 183
 184     /************************************************************************
 185      *  Method:
 186      *      IRMAFileObject::Write
 187      *  Purpose:
 188      *      Writes a buffer of data to the file and asynchronously notifies
 189      *      the caller via the IRMAFileResponse interface passed in to Init,
 190      *      of the completeness of the operation.
 191      */
 192     STDMETHOD(Write)    (THIS_
 193                         IRMABuffer* pBuffer) PURE;
 194
 195     /************************************************************************
 196      *  Method:
 197      *      IRMAFileObject::Seek
 198      *  Purpose:
 199      *      Seeks to an offset in the file and asynchronously notifies
 200      *      the caller via the IRMAFileResponse interface passed in to Init,
 201      *      of the completeness of the operation.
 202      *      If the bRelative flag is TRUE, it is a relative seek; else
 203      *      an absolute seek.
 204      */
 205     STDMETHOD(Seek)     (THIS_
 206                         ULONG32 ulOffset,
 207                         BOOL    bRelative) PURE;
 208
 209     /************************************************************************
 210      *  Method:
 211      *      IRMAFileObject::Advise
 212      *  Purpose:
 213      *      To pass information to the File Object advising it about usage
 214      *      heuristics.
 215      */
 216     STDMETHOD(Advise)   (THIS_
 217                         ULONG32 ulInfo) PURE;
 218 };
 219
 220
 221 /****************************************************************************
 222  *
 223  *  Interface:
 224  *
 225  *      IRMAFileResponse
 226  *
 227  *  Purpose:
 228  *
 229  *      Object that exports file response API
 230  *
 231  *  IID_IRMAFileResponse:
 232  *
 233  *      {00000201-0901-11d1-8B06-00A024406D59}
 234  *
 235  */
 236 DEFINE_GUID(IID_IRMAFileResponse, 0x00000201, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 237                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 238
 239 #undef  INTERFACE
 240 #define INTERFACE   IRMAFileResponse
 241
 242 DECLARE_INTERFACE_(IRMAFileResponse, IUnknown)
 243 {
 244     /*
 245      *  IUnknown methods
 246      */
 247     STDMETHOD(QueryInterface)           (THIS_
 248                                         REFIID riid,
 249                                         void** ppvObj) PURE;
 250
 251     STDMETHOD_(ULONG,AddRef)            (THIS) PURE;
 252
 253     STDMETHOD_(ULONG,Release)           (THIS) PURE;
 254
 255     /*
 256      *  IRMAFileResponse methods
 257      */
 258
 259     /************************************************************************
 260      *  Method:
 261      *      IRMAFileResponse::InitDone
 262      *  Purpose:
 263      *      Notification interface provided by users of the IRMAFileObject
 264      *      interface. This method is called by the IRMAFileObject when the
 265      *      initialization of the file is complete. If the file is not valid
 266      *      for the file system, the status PNR_FAILED should be
 267      *      returned.
 268      */
 269     STDMETHOD(InitDone)                 (THIS_
 270                                         PN_RESULT           status) PURE;
 271
 272     /************************************************************************
 273      *  Method:
 274      *      IRMAFileResponse::CloseDone
 275      *  Purpose:
 276      *      Notification interface provided by users of the IRMAFileObject
 277      *      interface. This method is called by the IRMAFileObject when the
 278      *      close of the file is complete.
 279      */
 280     STDMETHOD(CloseDone)                (THIS_
 281                                         PN_RESULT           status) PURE;
 282
 283     /************************************************************************
 284      *  Method:
 285      *      IRMAFileResponse::ReadDone
 286      *  Purpose:
 287      *      Notification interface provided by users of the IRMAFileObject
 288      *      interface. This method is called by the IRMAFileObject when the
 289      *      last read from the file is complete and a buffer is available.
 290      */
 291     STDMETHOD(ReadDone)                 (THIS_
 292                                         PN_RESULT           status,
 293                                         IRMABuffer*         pBuffer) PURE;
 294
 295     /************************************************************************
 296      *  Method:
 297      *      IRMAFileResponse::WriteDone
 298      *  Purpose:
 299      *      Notification interface provided by users of the IRMAFileObject
 300      *      interface. This method is called by the IRMAFileObject when the
 301      *      last write to the file is complete.
 302      */
 303     STDMETHOD(WriteDone)                (THIS_
 304                                         PN_RESULT           status) PURE;
 305
 306     /************************************************************************
 307      *  Method:
 308      *      IRMAFileResponse::SeekDone
 309      *  Purpose:
 310      *      Notification interface provided by users of the IRMAFileObject
 311      *      interface. This method is called by the IRMAFileObject when the
 312      *      last seek in the file is complete.
 313      */
 314     STDMETHOD(SeekDone)                 (THIS_
 315                                         PN_RESULT           status) PURE;
 316 };
 317
 318
 319 /****************************************************************************
 320  *
 321  *  Interface:
 322  *
 323  *      IRMAFileSystemObject
 324  *
 325  *  Purpose:
 326  *
 327  *      Object that allows a Controller to communicate with a specific
 328  *      File System plug-in session
 329  *
 330  *  IID_IRMAFileSystemObject:
 331  *
 332  *      {00000202-0901-11d1-8B06-00A024406D59}
 333  *
 334  */
 335 DEFINE_GUID(IID_IRMAFileSystemObject, 0x00000202, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 336                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 337
 338 #undef  INTERFACE
 339 #define INTERFACE   IRMAFileSystemObject
 340
 341 DECLARE_INTERFACE_(IRMAFileSystemObject, IUnknown)
 342 {
 343     /*
 344      *  IUnknown methods
 345      */
 346     STDMETHOD(QueryInterface)   (THIS_
 347                                 REFIID riid,
 348                                 void** ppvObj) PURE;
 349
 350     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 351
 352     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 353
 354     /*
 355      *  IRMAFileSystemObject methods
 356      */
 357
 358     /************************************************************************
 359      *  Method:
 360      *      IRMAFileSystemObject::GetFileSystemInfo
 361      *  Purpose:
 362      *      Returns information vital to the instantiation of file system
 363      *      plugin.
 364      *
 365      *      pShortName should be a short, human readable name in the form
 366      *      of "company-fsname".  For example: pShortName = "pn-local".
 367      */
 368     STDMETHOD(GetFileSystemInfo)    (THIS_
 369                                     REF(const char*) /*OUT*/ pShortName,
 370                                     REF(const char*) /*OUT*/ pProtocol) PURE;
 371
 372     STDMETHOD(InitFileSystem)   (THIS_
 373                                 IRMAValues* pOptions) PURE;
 374
 375     STDMETHOD(CreateFile)       (THIS_
 376                                 IUnknown**    /*OUT*/   ppFileObject) PURE;
 377
 378     /*
 379      * The following method is deprecated and should return PNR_NOTIMPL
 380      */
 381
 382     STDMETHOD(CreateDir)        (THIS_
 383                                 IUnknown**   /*OUT*/ ppDirObject) PURE;
 384
 385 };
 386
 387
 388 /****************************************************************************
 389  *
 390  *  Interface:
 391  *
 392  *      IRMAFileStat
 393  *
 394  *  Purpose:
 395  *
 396  *      Gets information about a specific File object
 397  *
 398  *  IID_IRMAFileStat:
 399  *
 400  *      {00000205-0901-11d1-8B06-00A024406D59}
 401  *
 402  */
 403 DEFINE_GUID(IID_IRMAFileStat, 0x00000205, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 404                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 405
 406 #undef  INTERFACE
 407 #define INTERFACE   IRMAFileStat
 408
 409 DECLARE_INTERFACE_(IRMAFileStat, IUnknown)
 410 {
 411     /*
 412      *  IUnknown methods
 413      */
 414     STDMETHOD(QueryInterface)   (THIS_
 415                                 REFIID riid,
 416                                 void** ppvObj) PURE;
 417
 418     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
 419
 420     STDMETHOD_(ULONG,Release) (THIS) PURE;
 421
 422     /*
 423      *  IRMAFileStat methods
 424      */
 425
 426     STDMETHOD(Stat)             (THIS_
 427                                 IRMAFileStatResponse* pFileStatResponse
 428                                 ) PURE;
 429 };
 430
 431
 432 /****************************************************************************
 433  *
 434  *  Interface:
 435  *
 436  *      IRMAFileStatResponse
 437  *
 438  *  Purpose:
 439  *
 440  *      Returns information about a specific File object
 441  *
 442  *  IID_IRMAFileStatResponse:
 443  *
 444  *      {00000206-0901-11d1-8B06-00A024406D59}
 445  *
 446  */
 447 DEFINE_GUID(IID_IRMAFileStatResponse, 0x00000206, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 448                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 449
 450 #undef  INTERFACE
 451 #define INTERFACE   IRMAFileStatResponse
 452
 453 DECLARE_INTERFACE_(IRMAFileStatResponse, IUnknown)
 454 {
 455     /*
 456      *  IUnknown methods
 457      */
 458     STDMETHOD(QueryInterface)   (THIS_
 459                                 REFIID riid,
 460                                 void** ppvObj) PURE;
 461
 462     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
 463
 464     STDMETHOD_(ULONG,Release) (THIS) PURE;
 465
 466     /*
 467      *  IRMAFileStat methods
 468      */
 469
 470     STDMETHOD(StatDone)         (THIS_
 471                                  PN_RESULT status,
 472                                  UINT32 ulSize,
 473                                  UINT32 ulCreationTime,
 474                                  UINT32 ulAccessTime,
 475                                  UINT32 ulModificationTime,
 476                                  UINT32 ulMode) PURE;
 477 };
 478
 479
 480 /****************************************************************************
 481  *
 482  *  Interface:
 483  *
 484  *      IRMAFileSystemManager
 485  *
 486  *  Purpose:
 487  *
 488  *      Gives out File Objects based on URLs
 489  *
 490  *  IID_IRMAFileSystemManager:
 491  *
 492  *      {00000207-0901-11d1-8B06-00A024406D59}
 493  *
 494  */
 495 DEFINE_GUID(IID_IRMAFileSystemManager, 0x00000207, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 496                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 497
 498 #undef  INTERFACE
 499 #define INTERFACE   IRMAFileSystemManager
 500
 501 #define CLSID_IRMAFileSystemManager IID_IRMAFileSystemManager
 502
 503 DECLARE_INTERFACE_(IRMAFileSystemManager, IUnknown)
 504 {
 505     /*
 506      *  IUnknown methods
 507      */
 508     STDMETHOD(QueryInterface)   (THIS_
 509                                 REFIID riid,
 510                                 void** ppvObj) PURE;
 511
 512     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
 513
 514     STDMETHOD_(ULONG,Release) (THIS) PURE;
 515
 516     /*
 517      *  IRMAFileSystemManager methods
 518      */
 519
 520     STDMETHOD(Init) (THIS_
 521                     IRMAFileSystemManagerResponse* /*IN*/  pFileManagerResponse
 522                     ) PURE;
 523
 524     /* GetFileObject attempts to locate an existing file via the DoesExist
 525      * method in each file system's objects, and returns that object through
 526      * FSManagerResponse->FileObjectReady
 527      */
 528     STDMETHOD(GetFileObject)    (THIS_
 529                                  IRMARequest* pRequest,
 530                                  IRMAAuthenticator* pAuthenticator) PURE;
 531
 532     /* GetNewFileObject is similar to GetFileObject except that no DoesExist
 533      * checks are done.  The first file system that matches the mount point
 534      * or protocol for the path in the request object creates the file
 535      * which is then returned through FileObjectReady.  This is especially
 536      * useful for those who wish to open a brand new file for writing.
 537      */
 538     STDMETHOD(GetNewFileObject) (THIS_
 539                                  IRMARequest* pRequest,
 540                                  IRMAAuthenticator* pAuthenticator) PURE;
 541
 542     STDMETHOD(GetRelativeFileObject) (THIS_
 543                                       IUnknown* pOriginalObject,
 544                                       const char* pPath) PURE;
 545
 546     /*
 547      * The following method is deprecated and should return PNR_NOTIMPL
 548      */
 549
 550     STDMETHOD(GetDirObjectFromURL)      (THIS_
 551                                         const char* pURL) PURE;
 552 };
 553
 554
 555 /****************************************************************************
 556  *
 557  *  Interface:
 558  *
 559  *      IRMAFileSystemManagerResponse
 560  *
 561  *  Purpose:
 562  *
 563  *      Gives out File System objects based on URLs
 564  *
 565  *  IID_IRMAFileSystemManagerResponse:
 566  *
 567  *      {00000208-0901-11d1-8B06-00A024406D59}
 568  *
 569  */
 570 DEFINE_GUID(IID_IRMAFileSystemManagerResponse, 0x00000208, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 571                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 572
 573 #undef  INTERFACE
 574 #define INTERFACE   IRMAFileSystemManagerResponse
 575
 576 DECLARE_INTERFACE_(IRMAFileSystemManagerResponse, IUnknown)
 577 {
 578     /*
 579      *  IUnknown methods
 580      */
 581     STDMETHOD(QueryInterface)   (THIS_
 582                                 REFIID riid,
 583                                 void** ppvObj) PURE;
 584
 585     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
 586
 587     STDMETHOD_(ULONG,Release) (THIS) PURE;
 588
 589     /*
 590      *  IRMAFileSystemManagerResponse methods
 591      */
 592
 593     /************************************************************************
 594      *  Method:
 595      *  IRMAFileSystemManagerResponse::InitDone
 596      *  Purpose:
 597      */
 598     STDMETHOD(InitDone)     (THIS_
 599                             PN_RESULT       status) PURE;
 600
 601     STDMETHOD(FileObjectReady)  (THIS_
 602                                 PN_RESULT status,
 603                                 IUnknown* pObject) PURE;
 604
 605     /*
 606      * The following method is deprecated and should return PNR_NOTIMPL
 607      */
 608
 609     STDMETHOD(DirObjectReady)   (THIS_
 610                                 PN_RESULT status,
 611                                 IUnknown* pDirObject) PURE;
 612 };
 613
 614
 615 /****************************************************************************
 616  *
 617  *  Interface:
 618  *
 619  *      IRMAFileExists
 620  *
 621  *  Purpose:
 622  *
 623  *      Checks for the existense of a file.  Must be implemented.
 624  *
 625  *  IID_IRMAFileExists:
 626  *
 627  *      {00000209-0901-11d1-8B06-00A024406D59}
 628  *
 629  */
 630 DEFINE_GUID(IID_IRMAFileExists, 0x00000209, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 631                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 632
 633 #undef  INTERFACE
 634 #define INTERFACE   IRMAFileExists
 635
 636 DECLARE_INTERFACE_(IRMAFileExists, IUnknown)
 637 {
 638     /*
 639      *  IUnknown methods
 640      */
 641     STDMETHOD(QueryInterface)   (THIS_
 642                                 REFIID riid,
 643                                 void** ppvObj) PURE;
 644
 645     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 646
 647     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 648
 649     /*
 650      *  IRMAFileExists methods
 651      */
 652
 653     /************************************************************************
 654      *  Method:
 655      *      IRMAFileExists::DoesExist
 656      *  Purpose:
 657      */
 658     STDMETHOD(DoesExist) (THIS_
 659                         const char*             /*IN*/  pPath,
 660                         IRMAFileExistsResponse* /*IN*/  pFileResponse) PURE;
 661 };
 662
 663
 664 /****************************************************************************
 665  *
 666  *  Interface:
 667  *
 668  *      IRMAFileExistsResponse
 669  *
 670  *  Purpose:
 671  *
 672  *      Response interface for IRMAFileExists.  Must be implemented.
 673  *
 674  *  IID_IRMAFileExistsResponse:
 675  *
 676  *      {0000020A-0901-11d1-8B06-00A024406D59}
 677  *
 678  */
 679 DEFINE_GUID(IID_IRMAFileExistsResponse, 0x0000020a, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 680                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 681
 682 #undef  INTERFACE
 683 #define INTERFACE   IRMAFileExists
 684
 685 DECLARE_INTERFACE_(IRMAFileExistsResponse, IUnknown)
 686 {
 687     /*
 688      *  IUnknown methods
 689      */
 690     STDMETHOD(QueryInterface)   (THIS_
 691                                 REFIID riid,
 692                                 void** ppvObj) PURE;
 693
 694     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 695
 696     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 697
 698     /*
 699      *  IRMAFileExistsResponse methods
 700      */
 701
 702     STDMETHOD(DoesExistDone) (THIS_
 703                               BOOL      bExist) PURE;
 704 };
 705
 706
 707 /****************************************************************************
 708  *
 709  *  Interface:
 710  *
 711  *      IRMAFileMimeMapper
 712  *
 713  *  Purpose:
 714  *
 715  *      Allows you to specify a mime type for a specific file.
 716  *      Optional interface.
 717  *
 718  *  IID_IRMAFileMimeMapper:
 719  *
 720  *      {0000020B-0901-11d1-8B06-00A024406D59}
 721  *
 722  */
 723 DEFINE_GUID(IID_IRMAFileMimeMapper, 0x0000020b, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 724                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 725
 726 #undef  INTERFACE
 727 #define INTERFACE   IRMAFileMimeMapper
 728
 729 DECLARE_INTERFACE_(IRMAFileMimeMapper, IUnknown)
 730 {
 731     /*
 732      *  IUnknown methods
 733      */
 734     STDMETHOD(QueryInterface)   (THIS_
 735                                 REFIID riid,
 736                                 void** ppvObj) PURE;
 737
 738     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 739
 740     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 741
 742     /*
 743      *  IRMAFileMimeMapper methods
 744      */
 745
 746     /************************************************************************
 747      *  Method:
 748      *      IRMAFileMimeMapper::FindMimeType
 749      *  Purpose:
 750      */
 751     STDMETHOD(FindMimeType) (THIS_
 752                             const char*             /*IN*/  pURL,
 753                             IRMAFileMimeMapperResponse* /*IN*/  pMimeMapperResponse
 754                             ) PURE;
 755 };
 756
 757
 758 /****************************************************************************
 759  *
 760  *  Interface:
 761  *
 762  *      IRMAFileMimeMapperResponse
 763  *
 764  *  Purpose:
 765  *
 766  *      Response interface for IRMAFileMimeMapper.
 767  *      Optional interface.
 768  *
 769  *  IID_IRMAFileMimeMapperResponse:
 770  *
 771  *      {0000020C-0901-11d1-8B06-00A024406D59}
 772  *
 773  */
 774 DEFINE_GUID(IID_IRMAFileMimeMapperResponse, 0x0000020c, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 775                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 776
 777 #undef  INTERFACE
 778 #define INTERFACE   IRMAFileMimeMapperResponse
 779
 780 DECLARE_INTERFACE_(IRMAFileMimeMapperResponse, IUnknown)
 781 {
 782     /*
 783      *  IUnknown methods
 784      */
 785     STDMETHOD(QueryInterface)   (THIS_
 786                                 REFIID riid,
 787                                 void** ppvObj) PURE;
 788
 789     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 790
 791     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 792
 793     /*
 794      *  IRMAFileMimeMapperResponse methods
 795      */
 796
 797     /************************************************************************
 798      *  Method:
 799      *      IRMAFileMimeMapperResponse::MimeTypeFound
 800      *  Purpose:
 801      *      Notification interface provided by users of the IRMAFileMimeMapper
 802      *      interface. This method is called by the IRMAFileObject when the
 803      *      initialization of the file is complete, and the Mime type is
 804      *      available for the request file. If the file is not valid for the
 805      *      file system, the status PNR_FAILED should be returned,
 806      *      with a mime type of NULL. If the file is valid but the mime type
 807      *      is unknown, then the status PNR_OK should be returned with
 808      *      a mime type of NULL.
 809      *
 810      */
 811     STDMETHOD(MimeTypeFound) (THIS_
 812                               PN_RESULT status,
 813                               const char* pMimeType) PURE;
 814 };
 815
 816
 817 /****************************************************************************
 818  *
 819  *  Interface:
 820  *
 821  *      IRMABroadcastMapper
 822  *
 823  *  Purpose:
 824  *
 825  *      Associates a file with a broadcast format plugin.
 826  *      Implementation only required by broadcast plugin file systems.
 827  *
 828  *  IID_IRMABroadcastMapper:
 829  *
 830  *      {0000020D-0901-11d1-8B06-00A024406D59}
 831  *
 832  */
 833 DEFINE_GUID(IID_IRMABroadcastMapper, 0x0000020d, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 834                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 835
 836 #undef  INTERFACE
 837 #define INTERFACE   IRMABroadcastMapper
 838
 839 DECLARE_INTERFACE_(IRMABroadcastMapper, IUnknown)
 840 {
 841     /*
 842      *  IUnknown methods
 843      */
 844     STDMETHOD(QueryInterface)   (THIS_
 845                                 REFIID riid,
 846                                 void** ppvObj) PURE;
 847
 848     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 849
 850     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 851
 852     /*
 853      *  IRMABroadcastMapper methods
 854      */
 855
 856     /************************************************************************
 857      *  Method:
 858      *      IRMABroadcastMapper::FindBroadcastType
 859      *  Purpose:
 860      */
 861     STDMETHOD(FindBroadcastType) (THIS_
 862                                 const char*                  /*IN*/  pURL,
 863                                 IRMABroadcastMapperResponse* /*IN*/  pBroadcastMapperResponse) PURE;
 864 };
 865
 866
 867 /****************************************************************************
 868  *
 869  *  Interface:
 870  *
 871  *      IRMABroadcastMapperResponse
 872  *
 873  *  Purpose:
 874  *
 875  *      Response interface for IRMABroadcastMapper.
 876  *      Implementation only required by broadcast plugin file systems.
 877  *
 878  *  IID_IRMABroadcastMapperResponse:
 879  *
 880  *      {0000020E-0901-11d1-8B06-00A024406D59}
 881  *
 882  */
 883 DEFINE_GUID(IID_IRMABroadcastMapperResponse, 0x0000020e, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 884                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 885
 886 #undef  INTERFACE
 887 #define INTERFACE   IRMABroadcastMapperResponse
 888
 889 DECLARE_INTERFACE_(IRMABroadcastMapperResponse, IUnknown)
 890 {
 891     /*
 892      *  IUnknown methods
 893      */
 894     STDMETHOD(QueryInterface)   (THIS_
 895                                 REFIID riid,
 896                                 void** ppvObj) PURE;
 897
 898     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
 899
 900     STDMETHOD_(ULONG,Release)   (THIS) PURE;
 901
 902     /*
 903      *  IRMABroadcastMapperResponse methods
 904      */
 905
 906     /************************************************************************
 907      *  Method:
 908      *      IRMABroadcastMapperResponse::BroadcastTypeFound
 909      *  Purpose:
 910      *      Notification interface provided by users of the IRMABroadcastMapper
 911      *      interface. This method is called by the File Object when the
 912      *      initialization of the file is complete, and the broadcast type is
 913      *      available for the request file. If the file is not valid for the
 914      *      file system, the status PNR_FAILED should be returned,
 915      *      with the broadcast type set to NULL.
 916      *
 917      */
 918     STDMETHOD(BroadcastTypeFound) (THIS_
 919                                   PN_RESULT     status,
 920                                   const char* pBroadcastType) PURE;
 921 };
 922
 923
 924 /****************************************************************************
 925  *
 926  *  Interface:
 927  *
 928  *      IRMAGetFileFromSamePool
 929  *
 930  *  Purpose:
 931  *
 932  *      Gives out File Objects based on filenames and relative "paths"
 933  *
 934  *  IID_IRMAGetFileFromSamePool:
 935  *
 936  *      {0000020f-0901-11d1-8B06-00A024406D59}
 937  *
 938  */
 939 DEFINE_GUID(IID_IRMAGetFileFromSamePool, 0x0000020f, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 940                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 941 #undef  INTERFACE
 942 #define INTERFACE   IRMAGetFileFromSamePool
 943
 944 #define CLSID_IRMAGetFileFromSamePool IID_IRMAGetFileFromSamePool
 945
 946 DECLARE_INTERFACE_(IRMAGetFileFromSamePool, IUnknown)
 947 {
 948     /*
 949      *  IUnknown methods
 950      */
 951     STDMETHOD(QueryInterface)   (THIS_
 952                                 REFIID riid,
 953                                 void** ppvObj) PURE;
 954
 955     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
 956
 957     STDMETHOD_(ULONG,Release) (THIS) PURE;
 958
 959
 960     /*
 961      * IRMAGetFileFromSamePool method
 962      */
 963     /************************************************************************
 964      *  Method:
 965      *      IRMAGetFileFromSamePool::GetFileObjectFromPool
 966      *  Purpose:
 967      *      To get another FileObject from the same pool.
 968      */
 969     STDMETHOD(GetFileObjectFromPool)    (THIS_
 970                                          IRMAGetFileFromSamePoolResponse*) PURE;
 971 };
 972
 973
 974 /****************************************************************************
 975  *
 976  *  Interface:
 977  *
 978  *      IRMAGetFileFromSamePoolResponse
 979  *
 980  *  Purpose:
 981  *
 982  *      Gives out File Objects based on filenames and relative "paths"
 983  *
 984  *  IID_IRMAGetFileFromSamePoolResponse:
 985  *
 986  *      {00000210-0901-11d1-8B06-00A024406D59}
 987  *
 988  */
 989 DEFINE_GUID(IID_IRMAGetFileFromSamePoolResponse, 0x00000210, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
 990                         0xa0, 0x24, 0x40, 0x6d, 0x59);
 991 #undef  INTERFACE
 992 #define INTERFACE   IRMAGetFileFromSamePoolResponse
 993
 994 #define CLSID_IRMAGetFileFromSamePoolResponse IID_IRMAGetFileFromSamePoolResponse
 995
 996 DECLARE_INTERFACE_(IRMAGetFileFromSamePoolResponse, IUnknown)
 997 {
 998     /*
 999      *  IUnknown methods
1000      */
1001     STDMETHOD(QueryInterface)   (THIS_
1002                                 REFIID riid,
1003                                 void** ppvObj) PURE;
1004
1005     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
1006
1007     STDMETHOD_(ULONG,Release) (THIS) PURE;
1008
1009     /*
1010      * IRMAGetFileFromSamePoolResponse method
1011      */
1012     /************************************************************************
1013      *  Method:
1014      *      IRMAGetFileFromSamePoolResponse::FileObjectReady
1015      *  Purpose:
1016      *      To return another FileObject from the same pool.
1017      */
1018     STDMETHOD(FileObjectReady) (THIS_
1019                                 PN_RESULT status,
1020                                 IUnknown* ppUnknown) PURE;
1021 };
1022
1023
1024 /****************************************************************************
1025  *
1026  *  Interface:
1027  *
1028  *      IRMAFileAuthenticator
1029  *
1030  *  Purpose:
1031  *
1032  *      Set and Get a file object's authenticator object.
1033  *
1034  *  IID_IRMAFileAuthenticator:
1035  *
1036  *      {00000211-0901-11d1-8B06-00A024406D59}
1037  *
1038  */
1039 DEFINE_GUID(IID_IRMAFileAuthenticator, 0x00000211, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1040                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1041 #undef  INTERFACE
1042 #define INTERFACE   IRMAFileAuthenticator
1043
1044 #define CLSID_IRMAFileAuthenticator IID_IRMAFileAuthenticator
1045
1046 DECLARE_INTERFACE_(IRMAFileAuthenticator, IUnknown)
1047 {
1048     /*
1049      *  IUnknown methods
1050      */
1051     STDMETHOD(QueryInterface)   (THIS_
1052                                 REFIID riid,
1053                                 void** ppvObj) PURE;
1054
1055     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
1056
1057     STDMETHOD_(ULONG,Release) (THIS) PURE;
1058
1059     /*
1060      * IRMAFileAuthenticator methods
1061      */
1062     STDMETHOD(SetAuthenticator) (THIS_
1063                                  IRMAAuthenticator* pAuthenticator) PURE;
1064
1065     STDMETHOD(GetAuthenticator) (THIS_
1066                                  REF(IRMAAuthenticator*) pAuthenticator) PURE;
1067 };
1068
1069
1070 /****************************************************************************
1071  *
1072  *  Interface:
1073  *
1074  *      IRMARequestHandler
1075  *
1076  *  Purpose:
1077  *
1078  *      Object to manage IRMARequest objects
1079  *
1080  *  IID_IRMARequestHandler:
1081  *
1082  *      {00000212-0901-11d1-8B06-00A024406D59}
1083  *
1084  */
1085 DEFINE_GUID(IID_IRMARequestHandler, 0x00000212, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1086                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1087 #undef  INTERFACE
1088 #define INTERFACE   IRMARequestHandler
1089
1090 #define CLSID_IRMARequestHandler IID_IRMARequestHandler
1091
1092 DECLARE_INTERFACE_(IRMARequestHandler, IUnknown)
1093 {
1094     /*
1095      *  IUnknown methods
1096      */
1097
1098     STDMETHOD(QueryInterface)   (THIS_
1099                                 REFIID riid,
1100                                 void** ppvObj) PURE;
1101
1102     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
1103
1104     STDMETHOD_(ULONG,Release) (THIS) PURE;
1105
1106     /************************************************************************
1107      *  Method:
1108      *      IRMARequestHandler::SetRequest
1109      *  Purpose:
1110      *      Associates an IRMARequest with an object
1111      */
1112     STDMETHOD(SetRequest)   (THIS_
1113                             IRMARequest*        /*IN*/  pRequest) PURE;
1114
1115     /************************************************************************
1116      *  Method:
1117      *      IRMARequestHandler::GetRequest
1118      *  Purpose:
1119      *      Gets the IRMARequest object associated with an object
1120      */
1121     STDMETHOD(GetRequest)   (THIS_
1122                             REF(IRMARequest*)        /*OUT*/  pRequest) PURE;
1123
1124 };
1125
1126
1127 /****************************************************************************
1128  *
1129  *  Interface:
1130  *
1131  *      IRMARequestContext
1132  *
1133  *  Purpose:
1134  *
1135  *      Object to manage the context of the Request
1136  *
1137  *  IID_IRMARequestContext:
1138  *
1139  *      {00000217-0901-11d1-8B06-00A024406D59}
1140  *
1141  */
1142 DEFINE_GUID(IID_IRMARequestContext, 0x00000217, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1143                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1144 #undef  INTERFACE
1145 #define INTERFACE   IRMARequestContext
1146
1147 #define CLSID_IRMARequestContext IID_IRMARequestContext
1148
1149 DECLARE_INTERFACE_(IRMARequestContext, IUnknown)
1150 {
1151     /*
1152      *  IUnknown methods
1153      */
1154
1155     STDMETHOD(QueryInterface)   (THIS_
1156                                 REFIID riid,
1157                                 void** ppvObj) PURE;
1158
1159     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
1160
1161     STDMETHOD_(ULONG,Release) (THIS) PURE;
1162
1163     /*
1164      * IRMARequestContext methods
1165      */
1166
1167     /************************************************************************
1168      *  Method:
1169      *      IRMARequestContext::SetUserContext
1170      *  Purpose:
1171      *      Sets the Authenticated users Context.
1172      */
1173     STDMETHOD(SetUserContext)
1174     (
1175         THIS_
1176         IUnknown* pIUnknownNewContext
1177     ) PURE;
1178
1179     /************************************************************************
1180      *  Method:
1181      *      IRMARequestContext::GetUserContext
1182      *  Purpose:
1183      *      Gets the Authenticated users Context.
1184      */
1185     STDMETHOD(GetUserContext)
1186     (
1187         THIS_
1188         REF(IUnknown*) pIUnknownCurrentContext
1189     ) PURE;
1190
1191     /************************************************************************
1192      *  Method:
1193      *      IRMARequestContext::SetRequester
1194      *  Purpose:
1195      *      Sets the Object that made the request.
1196      */
1197     STDMETHOD(SetRequester)
1198     (
1199         THIS_
1200         IUnknown* pIUnknownNewRequester
1201     ) PURE;
1202
1203     /************************************************************************
1204      *  Method:
1205      *      IRMARequestContext::GetRequester
1206      *  Purpose:
1207      *      Gets the Object that made the request.
1208      */
1209     STDMETHOD(GetRequester)
1210     (
1211         THIS_
1212         REF(IUnknown*) pIUnknownCurrentRequester
1213     ) PURE;
1214 };
1215
1216 /****************************************************************************
1217  *
1218  *  Interface:
1219  *
1220  *      IRMARequest
1221  *
1222  *  Purpose:
1223  *
1224  *      Object to manage the RFC822 headers sent by the client
1225  *
1226  *  IID_IRMARequest:
1227  *
1228  *      {00000213-0901-11d1-8B06-00A024406D59}
1229  *
1230  */
1231 DEFINE_GUID(IID_IRMARequest, 0x00000213, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1232                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1233 #undef  INTERFACE
1234 #define INTERFACE   IRMARequest
1235
1236 #define CLSID_IRMARequest IID_IRMARequest
1237
1238 DECLARE_INTERFACE_(IRMARequest, IUnknown)
1239 {
1240     /*
1241      *  IUnknown methods
1242      */
1243
1244     STDMETHOD(QueryInterface)   (THIS_
1245                                 REFIID riid,
1246                                 void** ppvObj) PURE;
1247
1248     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
1249
1250     STDMETHOD_(ULONG,Release) (THIS) PURE;
1251
1252     /*
1253      * IRMARequest methods
1254      */
1255
1256     /************************************************************************
1257      *  Method:
1258      *      IRMARequest::SetRequestHeaders
1259      *  Purpose:
1260      *      Sets the headers that will be sent in the RFC822 header section
1261      *      of the request message
1262      */
1263     STDMETHOD(SetRequestHeaders)        (THIS_
1264                                         IRMAValues* pRequestHeaders) PURE;
1265
1266     /************************************************************************
1267      *  Method:
1268      *      IRMARequest::GetRequestHeaders
1269      *  Purpose:
1270      *      Gets the headers that were sent in the RFC822 header section
1271      *      of the request message
1272      */
1273     STDMETHOD(GetRequestHeaders)        (THIS_
1274                                         REF(IRMAValues*) pRequestHeaders) PURE;
1275
1276     /************************************************************************
1277      *  Method:
1278      *      IRMARequest::SetResponseHeaders
1279      *  Purpose:
1280      *      Sets the headers that will be returned in the RFC822 header
1281      *      section of the response message
1282      */
1283     STDMETHOD(SetResponseHeaders)       (THIS_
1284                                         IRMAValues* pResponseHeaders) PURE;
1285
1286     /************************************************************************
1287      *  Method:
1288      *      IRMARequest::GetResponseHeaders
1289      *  Purpose:
1290      *      Gets the headers that were returned in the RFC822 header section
1291      *      of the response message
1292      */
1293     STDMETHOD(GetResponseHeaders)       (THIS_
1294                                         REF(IRMAValues*) pResponseHeaders) PURE;
1295
1296     /************************************************************************
1297      *  Method:
1298      *      IRMARequest::SetURL
1299      *  Purpose:
1300      *      Sets the fully qualified path associated with a file object.
1301      *      Note: On the server, this path does not include the file system
1302      *          mount point.
1303      */
1304     STDMETHOD(SetURL)                   (THIS_
1305                                         const char* pURL) PURE;
1306
1307     /************************************************************************
1308      *  Method:
1309      *      IRMARequest::GetURL
1310      *  Purpose:
1311      *      Returns the fully qualified path associated with a file object.
1312      *      Note: On the server, this path does not include the file system
1313      *          mount point.
1314      *
1315      *      Note: The returned pointer's lifetime expires as soon as the
1316      *      caller returns from a function which was called from the RMA
1317      *      core (i.e. when you return control to the RMA core)
1318      */
1319     STDMETHOD(GetURL)                   (THIS_
1320                                         REF(const char*) pURL) PURE;
1321 };
1322
1323 /****************************************************************************
1324  *
1325  *  Interface:
1326  *
1327  *      IRMAFileRename
1328  *
1329  *  Purpose:
1330  *
1331  *      Interface to allow renaming of files.  Query off of the File Object.
1332  *      Not all filesystem plugins implement this feature.
1333  *
1334  *  IID_IRMAFileRename:
1335  *
1336  *      {00000214-0901-11d1-8B06-00A024406D59}
1337  *
1338  */
1339 DEFINE_GUID(IID_IRMAFileRename, 0x00000214, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1340                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1341 #undef  INTERFACE
1342 #define INTERFACE   IRMAFileRename
1343
1344 DECLARE_INTERFACE_(IRMAFileRename, IUnknown)
1345 {
1346     /*
1347      *  IUnknown methods
1348      */
1349
1350     STDMETHOD(QueryInterface)   (THIS_
1351                                 REFIID riid,
1352                                 void** ppvObj) PURE;
1353
1354     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
1355
1356     STDMETHOD_(ULONG,Release) (THIS) PURE;
1357
1358     /*
1359      * IRMAFileRename methods
1360      */
1361
1362     /************************************************************************
1363      *  Method:
1364      *      IRMAFileRename::Rename
1365      *  Purpose:
1366      *      Renames a file to a new name.
1367      */
1368     STDMETHOD(Rename)                   (THIS_
1369                                         const char* pNewFileName) PURE;
1370 };
1371
1372 /****************************************************************************
1373  *
1374  *  Interface:
1375  *
1376  *      IRMADirHandler
1377  *
1378  *  Purpose:
1379  *
1380  *      Object that exports directory handler API
1381  *
1382  *  IID_IRMADirHandler:
1383  *
1384  *      {00000215-0901-11d1-8B06-00A024406D59}
1385  *
1386  */
1387 DEFINE_GUID(IID_IRMADirHandler, 0x00000215, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
1388
1389 #undef  INTERFACE
1390 #define INTERFACE   IRMADirHandler
1391
1392 DECLARE_INTERFACE_(IRMADirHandler, IUnknown)
1393 {
1394     /*
1395      *  IUnknown methods
1396      */
1397     STDMETHOD(QueryInterface)   (THIS_
1398                                 REFIID riid,
1399                                 void** ppvObj) PURE;
1400
1401     STDMETHOD_(ULONG,AddRef)    (THIS) PURE;
1402
1403     STDMETHOD_(ULONG,Release)   (THIS) PURE;
1404
1405     /*
1406      *  IRMADirHandler methods
1407      */
1408
1409     /************************************************************************
1410      *  Method:
1411      *      IRMADirHandler::InitDirHandler
1412      *  Purpose:
1413      *      Associates a directory handler with the directory handler
1414      *      response, it should notify of operation completness.
1415      */
1416     STDMETHOD(InitDirHandler)   (THIS_
1417                                 IRMADirHandlerResponse*    /*IN*/  pDirResponse) PURE;
1418
1419     /************************************************************************
1420      *  Method:
1421      *      IRMADirHandler::CloseDirHandler
1422      *  Purpose:
1423      *      Closes the directory handler resource and releases all resources
1424      *      associated with the object.
1425      */
1426     STDMETHOD(CloseDirHandler)  (THIS) PURE;
1427
1428     /************************************************************************
1429      *  Method:
1430      *      IRMADirHandler::MakeDir
1431      *  Purpose:
1432      *      Create the directory
1433      */
1434     STDMETHOD(MakeDir)  (THIS) PURE;
1435
1436     /************************************************************************
1437      *  Method:
1438      *      IRMADirHandler::ReadDir
1439      *  Purpose:
1440      *      Get a dump of the directory
1441      */
1442     STDMETHOD(ReadDir)  (THIS) PURE;
1443 };
1444
1445
1446 /****************************************************************************
1447  *
1448  *  Interface:
1449  *
1450  *      IRMADirHandlerResponse
1451  *
1452  *  Purpose:
1453  *
1454  *      Object that exports the directory handler response API
1455  *
1456  *  IID_IRMADirHandlerResponse:
1457  *
1458  *      {00000216-0901-11d1-8B06-00A024406D59}
1459  *
1460  */
1461 DEFINE_GUID(IID_IRMADirHandlerResponse, 0x00000216, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
1462
1463 #undef  INTERFACE
1464 #define INTERFACE   IRMADirHandlerResponse
1465
1466 DECLARE_INTERFACE_(IRMADirHandlerResponse, IUnknown)
1467 {
1468     /*
1469      *  IUnknown methods
1470      */
1471     STDMETHOD(QueryInterface)           (THIS_
1472                                         REFIID riid,
1473                                         void** ppvObj) PURE;
1474
1475     STDMETHOD_(ULONG,AddRef)            (THIS) PURE;
1476
1477     STDMETHOD_(ULONG,Release)           (THIS) PURE;
1478
1479     /*
1480      *  IRMADirHandlerResponse methods
1481      */
1482
1483     /************************************************************************
1484      *  Method:
1485      *      IRMADirHandlerResponse::InitDirHandlerDone
1486      *  Purpose:
1487      *      Notification interface provided by users of the IRMADirHandler
1488      *      interface. This method is called by the IRMADirHandler when the
1489      *      initialization of the object is complete.
1490      */
1491     STDMETHOD(InitDirHandlerDone)       (THIS_
1492                                         PN_RESULT           status) PURE;
1493
1494     /************************************************************************
1495      *  Method:
1496      *      IRMADirHandlerResponse::CloseDirHandlerDone
1497      *  Purpose:
1498      *      Notification interface provided by users of the IRMADirHandler
1499      *      interface. This method is called by the IRMADirHandler when the
1500      *      close of the directory is complete.
1501      */
1502     STDMETHOD(CloseDirHandlerDone)      (THIS_
1503                                         PN_RESULT           status) PURE;
1504
1505     /************************************************************************
1506      *  Method:
1507      *      IRMADirHandler::MakeDirDone
1508      *  Purpose:
1509      *      Notification interface provided by users of the IRMADirHandler
1510      *      interface. This method is called by the IRMADirHandler when the
1511      *      attempt to create the directory is complete.
1512      */
1513     STDMETHOD(MakeDirDone)              (THIS_
1514                                         PN_RESULT           status) PURE;
1515
1516     /************************************************************************
1517      *  Method:
1518      *      IRMADirHandler::ReadDirDone
1519      *  Purpose:
1520      *      Notification interface provided by users of the IRMADirHandler
1521      *      interface. This method is called by the IRMADirHandler when the
1522      *      read from the directory is complete and a buffer is available.
1523      */
1524     STDMETHOD(ReadDirDone)              (THIS_
1525                                         PN_RESULT           status,
1526                                         IRMABuffer*         pBuffer) PURE;
1527 };
1528
1529
1530
1531 /****************************************************************************
1532  *
1533  *  Interface:
1534  *
1535  *      IRMAFileRemove
1536  *
1537  *  Purpose:
1538  *
1539  *      Interface to allow removing of files.  Query off of the File Object.
1540  *      Not all filesystem plugins implement this feature.
1541  *
1542  *  IID_IRMAFileRemove:
1543  *
1544  *      {0000021A-0901-11d1-8B06-00A024406D59}
1545  *
1546  */
1547 DEFINE_GUID(IID_IRMAFileRemove, 0x0000021A, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1548                         0xa0, 0x24, 0x40, 0x6d, 0x59);
1549 #undef  INTERFACE
1550 #define INTERFACE   IRMAFileRemove
1551
1552 DECLARE_INTERFACE_(IRMAFileRemove, IUnknown)
1553 {
1554     /*
1555      *  IUnknown methods
1556      */
1557
1558     STDMETHOD(QueryInterface)   (THIS_
1559                                 REFIID riid,
1560                                 void** ppvObj) PURE;
1561
1562     STDMETHOD_(ULONG,AddRef)  (THIS) PURE;
1563
1564     STDMETHOD_(ULONG,Release) (THIS) PURE;
1565
1566     /*
1567      * IRMAFileRemove methods
1568      */
1569
1570     /************************************************************************
1571      *  Method:
1572      *      IRMAFileRemove::Remove
1573      *  Purpose:
1574      *      Removes a file from the file system.
1575      */
1576     STDMETHOD(Remove)                   (THIS) PURE;
1577 };
1578
1579
1580
1581
1582
1583 #endif  /* _RMAFILES_H_ */