windows-xp/Source/XPSP1/NT/windows/winstate/cobra/inc/ismproc.h

/*++

Copyright (c) 2000 Microsoft Corporation

Module Name:

    ismproc.h

Abstract:

    Callback function prototype definitions for the Intermediate State Manager.

Author:

    Jim Schmidt (jimschm) 15-Nov-1999

Revision History:

    <alias> <date> <comments>

--*/

#pragma once

//
// Types
//

//
// misc types
//

#define ISM_VERSION         0x10000

typedef VOID (WINAPI MIG_LOGCALLBACK)(PVOID Arg);
typedef MIG_LOGCALLBACK * PMIG_LOGCALLBACK;

typedef VOID(PROGRESSBARFN)(
                MIG_PROGRESSPHASE Phase,
                MIG_PROGRESSSTATE State,
                UINT WorkDone,
                UINT TotalWork,
                ULONG_PTR Arg
                );

typedef PROGRESSBARFN * PPROGRESSBARFN;

//
// transport
//

typedef BOOL(WINAPI TRANSPORTINITIALIZE)(PMIG_LOGCALLBACK LogCallback);
typedef TRANSPORTINITIALIZE *PTRANSPORTINITIALIZE;

typedef VOID(WINAPI TRANSPORTESTIMATEPROGRESSBAR)(MIG_PLATFORMTYPEID PlatformTypeId);
typedef TRANSPORTESTIMATEPROGRESSBAR *PTRANSPORTESTIMATEPROGRESSBAR;

typedef BOOL(WINAPI TRANSPORTQUERYCAPABILITIES)(
                        IN      MIG_TRANSPORTSTORAGEID TransportStorageId,
                        OUT     PMIG_TRANSPORTTYPE TransportType,
                        OUT     PMIG_TRANSPORTCAPABILITIES Capabilities,
                        OUT     PCTSTR *FriendlyDescription
                        );
typedef TRANSPORTQUERYCAPABILITIES *PTRANSPORTQUERYCAPABILITIES;

typedef BOOL(WINAPI TRANSPORTSETSTORAGE)(
                        IN      MIG_PLATFORMTYPEID Platform,
                        IN      MIG_TRANSPORTSTORAGEID TransportStorageId,
                        IN      MIG_TRANSPORTCAPABILITIES Capabilities,
                        IN      PCTSTR StoragePath,
                        OUT     PBOOL Valid,
                        OUT     PBOOL ImageExists
                        );
typedef TRANSPORTSETSTORAGE *PTRANSPORTSETSTORAGE;

typedef VOID(WINAPI TRANSPORTRESETSTORAGE)(MIG_TRANSPORTSTORAGEID TransportStorageId);
typedef TRANSPORTRESETSTORAGE *PTRANSPORTRESETSTORAGE;

typedef VOID(WINAPI TRANSPORTTERMINATE)(VOID);
typedef TRANSPORTTERMINATE *PTRANSPORTTERMINATE;

typedef BOOL(WINAPI TRANSPORTSAVESTATE)(VOID);
typedef TRANSPORTSAVESTATE *PTRANSPORTSAVESTATE;

typedef BOOL(WINAPI TRANSPORTRESUMESAVESTATE)(VOID);
typedef TRANSPORTRESUMESAVESTATE *PTRANSPORTRESUMESAVESTATE;

typedef BOOL(WINAPI TRANSPORTBEGINAPPLY)(VOID);
typedef TRANSPORTBEGINAPPLY *PTRANSPORTBEGINAPPLY;

typedef BOOL(WINAPI TRANSPORTRESUMEAPPLY)(VOID);
typedef TRANSPORTRESUMEAPPLY *PTRANSPORTRESUMEAPPLY;

typedef BOOL(WINAPI TRANSPORTACQUIREOBJECT)(
                            IN      MIG_OBJECTTYPEID ObjectTypeId,
                            IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                            IN OUT  PMIG_CONTENT ObjectContent,
                            IN      MIG_CONTENTTYPE ContentType,
                            IN      UINT MemoryContentLimit
                            );
typedef TRANSPORTACQUIREOBJECT *PTRANSPORTACQUIREOBJECT;

typedef BOOL(WINAPI TRANSPORTRELEASEOBJECT)(PMIG_CONTENT ObjectContent);
typedef TRANSPORTRELEASEOBJECT *PTRANSPORTRELEASEOBJECT;

typedef VOID(WINAPI TRANSPORTENDAPPLY)(VOID);
typedef TRANSPORTENDAPPLY *PTRANSPORTENDAPPLY;

typedef struct {
    UINT Version;
    PTRANSPORTINITIALIZE TransportInitialize;
    PTRANSPORTESTIMATEPROGRESSBAR TransportEstimateProgressBar;
    PTRANSPORTQUERYCAPABILITIES TransportQueryCapabilities;
    PTRANSPORTSETSTORAGE TransportSetStorage;
    PTRANSPORTRESETSTORAGE TransportResetStorage;
    PTRANSPORTTERMINATE TransportTerminate;
    PTRANSPORTSAVESTATE TransportSaveState;
    PTRANSPORTRESUMESAVESTATE TransportResumeSaveState;
    PTRANSPORTBEGINAPPLY TransportBeginApply;
    PTRANSPORTRESUMEAPPLY TransportResumeApply;
    PTRANSPORTACQUIREOBJECT TransportAcquireObject;
    PTRANSPORTRELEASEOBJECT TransportReleaseObject;
    PTRANSPORTENDAPPLY TransportEndApply;
} TRANSPORT_ENTRYPOINTS, *PTRANSPORT_ENTRYPOINTS;

//
// operations
//

typedef BOOL (WINAPI OPMFILTERCALLBACK)(
                        PCMIG_FILTERINPUT InputData,
                        PMIG_FILTEROUTPUT OutputData,
                        BOOL NoRestoreObject,
                        PCMIG_BLOB SourceOperationData,             OPTIONAL
                        PCMIG_BLOB DestinationOperationData         OPTIONAL
                        );
typedef OPMFILTERCALLBACK *POPMFILTERCALLBACK;

typedef BOOL (WINAPI OPMAPPLYCALLBACK)(
                        MIG_OBJECTTYPEID SrcObjectTypeId,
                        MIG_OBJECTSTRINGHANDLE SrcObjectName,
                        PCMIG_CONTENT OriginalContent,
                        PCMIG_CONTENT CurrentContent,
                        PMIG_CONTENT NewContent,
                        PCMIG_BLOB SourceOperationData,             OPTIONAL
                        PCMIG_BLOB DestinationOperationData         OPTIONAL
                        );
typedef OPMAPPLYCALLBACK *POPMAPPLYCALLBACK;

//
// message passing
//

typedef ULONG_PTR(CALLBACK MESSAGECALLBACK)(UINT Message, ULONG_PTR Arg);
typedef MESSAGECALLBACK *PMESSAGECALLBACK;

//
// ETM entry points
//

typedef BOOL(WINAPI TYPE_ENUMFIRSTPHYSICALOBJECT)(
                IN OUT  PMIG_TYPEOBJECTENUM EnumPtr,
                IN      MIG_OBJECTSTRINGHANDLE Pattern,
                IN      UINT MaxLevel
                );
typedef TYPE_ENUMFIRSTPHYSICALOBJECT *PTYPE_ENUMFIRSTPHYSICALOBJECT;

typedef BOOL(WINAPI TYPE_ENUMNEXTPHYSICALOBJECT)(
                IN OUT  PMIG_TYPEOBJECTENUM EnumPtr
                );
typedef TYPE_ENUMNEXTPHYSICALOBJECT *PTYPE_ENUMNEXTPHYSICALOBJECT;

typedef VOID(WINAPI TYPE_ABORTENUMCURRENTPHYSICALNODE)(
                IN OUT  PMIG_TYPEOBJECTENUM EnumPtr
                );
typedef TYPE_ABORTENUMCURRENTPHYSICALNODE *PTYPE_ABORTENUMCURRENTPHYSICALNODE;

typedef VOID(WINAPI TYPE_ABORTENUMPHYSICALOBJECT)(
                IN OUT  PMIG_TYPEOBJECTENUM EnumPtr
                );
typedef TYPE_ABORTENUMPHYSICALOBJECT *PTYPE_ABORTENUMPHYSICALOBJECT;

typedef PCTSTR(WINAPI TYPE_CONVERTOBJECTTOMULTISZ)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                IN      PMIG_CONTENT ObjectContent
                );
typedef TYPE_CONVERTOBJECTTOMULTISZ *PTYPE_CONVERTOBJECTTOMULTISZ;

typedef BOOL(WINAPI TYPE_CONVERTMULTISZTOOBJECT)(
                IN      PCTSTR ObjectMultiSz,
                OUT     MIG_OBJECTSTRINGHANDLE *ObjectName,
                OUT     PMIG_CONTENT ObjectContent          OPTIONAL
                );
typedef TYPE_CONVERTMULTISZTOOBJECT *PTYPE_CONVERTMULTISZTOOBJECT;

typedef PCTSTR(WINAPI TYPE_GETNATIVEOBJECTNAME)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName
                );
typedef TYPE_GETNATIVEOBJECTNAME *PTYPE_GETNATIVEOBJECTNAME;

typedef BOOL(WINAPI TYPE_ACQUIREPHYSICALOBJECT)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                OUT     PMIG_CONTENT ObjectContent,
                IN      MIG_CONTENTTYPE ContentType,
                IN      UINT MemoryContentLimit
                );
typedef TYPE_ACQUIREPHYSICALOBJECT *PTYPE_ACQUIREPHYSICALOBJECT;

typedef BOOL(WINAPI TYPE_RELEASEPHYSICALOBJECT)(
                IN OUT  PMIG_CONTENT ObjectContent
                );
typedef TYPE_RELEASEPHYSICALOBJECT *PTYPE_RELEASEPHYSICALOBJECT;

typedef BOOL(WINAPI TYPE_DOESPHYSICALOBJECTEXIST)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName
                );
typedef TYPE_DOESPHYSICALOBJECTEXIST *PTYPE_DOESPHYSICALOBJECTEXIST;

typedef BOOL(WINAPI TYPE_REMOVEPHYSICALOBJECT)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName
                );
typedef TYPE_REMOVEPHYSICALOBJECT *PTYPE_REMOVEPHYSICALOBJECT;

typedef BOOL(WINAPI TYPE_CREATEPHYSICALOBJECT)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                IN      PMIG_CONTENT ObjectContent
                );
typedef TYPE_CREATEPHYSICALOBJECT *PTYPE_CREATEPHYSICALOBJECT;

typedef BOOL(WINAPI TYPE_REPLACEPHYSICALOBJECT)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                IN      PMIG_CONTENT ObjectContent
                );
typedef TYPE_REPLACEPHYSICALOBJECT *PTYPE_REPLACEPHYSICALOBJECT;

typedef PMIG_CONTENT(WINAPI TYPE_CONVERTOBJECTCONTENTTOUNICODE)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                IN      PMIG_CONTENT ObjectContent
                );
typedef TYPE_CONVERTOBJECTCONTENTTOUNICODE *PTYPE_CONVERTOBJECTCONTENTTOUNICODE;

typedef PMIG_CONTENT(WINAPI TYPE_CONVERTOBJECTCONTENTTOANSI)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                IN      PMIG_CONTENT ObjectContent
                );
typedef TYPE_CONVERTOBJECTCONTENTTOANSI *PTYPE_CONVERTOBJECTCONTENTTOANSI;

typedef BOOL(WINAPI TYPE_FREECONVERTEDOBJECTCONTENT)(
                IN      PMIG_CONTENT ObjectContent
                );
typedef TYPE_FREECONVERTEDOBJECTCONTENT *PTYPE_FREECONVERTEDOBJECTCONTENT;

typedef struct {
    PTYPE_ENUMFIRSTPHYSICALOBJECT EnumFirstPhysicalObject;
    PTYPE_ENUMNEXTPHYSICALOBJECT EnumNextPhysicalObject;
    PTYPE_ABORTENUMCURRENTPHYSICALNODE AbortEnumCurrentPhysicalNode;
    PTYPE_ABORTENUMPHYSICALOBJECT AbortEnumPhysicalObject;
    PTYPE_CONVERTOBJECTTOMULTISZ ConvertObjectToMultiSz;
    PTYPE_CONVERTMULTISZTOOBJECT ConvertMultiSzToObject;
    PTYPE_GETNATIVEOBJECTNAME GetNativeObjectName;
    PTYPE_ACQUIREPHYSICALOBJECT AcquirePhysicalObject;
    PTYPE_RELEASEPHYSICALOBJECT ReleasePhysicalObject;
    PTYPE_DOESPHYSICALOBJECTEXIST DoesPhysicalObjectExist;
    PTYPE_REMOVEPHYSICALOBJECT RemovePhysicalObject;
    PTYPE_CREATEPHYSICALOBJECT CreatePhysicalObject;
    PTYPE_REPLACEPHYSICALOBJECT ReplacePhysicalObject;
    PTYPE_CONVERTOBJECTCONTENTTOUNICODE ConvertObjectContentToUnicode;
    PTYPE_CONVERTOBJECTCONTENTTOANSI ConvertObjectContentToAnsi;
    PTYPE_FREECONVERTEDOBJECTCONTENT FreeConvertedObjectContent;
} TYPE_REGISTER, *PTYPE_REGISTER;

typedef BOOL (WINAPI MIG_PHYSICALENUMCHECK)(
                IN      PMIG_TYPEOBJECTENUM ObjectEnum,
                IN      ULONG_PTR Arg
                );

typedef MIG_PHYSICALENUMCHECK *PMIG_PHYSICALENUMCHECK;

typedef BOOL (WINAPI MIG_PHYSICALENUMADD)(
                IN OUT  PMIG_TYPEOBJECTENUM ObjectEnum,
                IN      MIG_OBJECTSTRINGHANDLE Pattern,     // NULL if Abort is TRUE
                IN      MIG_PARSEDPATTERN ParsedPattern,    // NULL if Abort is TRUE
                IN      ULONG_PTR Arg,
                IN      BOOL Abort
                );

typedef MIG_PHYSICALENUMADD *PMIG_PHYSICALENUMADD;

typedef BOOL (WINAPI MIG_PHYSICALACQUIREHOOK)(
                IN      MIG_OBJECTSTRINGHANDLE ObjectName,
                IN      PMIG_CONTENT ObjectContent,
                IN      MIG_CONTENTTYPE ContentType,
                IN      UINT MemoryContentLimit,
                OUT     PMIG_CONTENT *NewObjectContent,         CALLER_INITIALIZED OPTIONAL
                IN      BOOL ReleaseContent,
                IN      ULONG_PTR Arg
                );

typedef MIG_PHYSICALACQUIREHOOK *PMIG_PHYSICALACQUIREHOOK;

typedef VOID (WINAPI MIG_PHYSICALACQUIREFREE)(PMIG_CONTENT ObjectContent);

typedef MIG_PHYSICALACQUIREFREE *PMIG_PHYSICALACQUIREFREE;


//
// module entry points
//

typedef BOOL(WINAPI MODULEINITIALIZE)(VOID);
typedef MODULEINITIALIZE * PMODULEINITIALIZE;

typedef VOID(WINAPI MODULETERMINATE)(VOID);
typedef MODULETERMINATE * PMODULETERMINATE;

typedef BOOL(WINAPI ETMINITIALIZE)(MIG_PLATFORMTYPEID Platform, PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef ETMINITIALIZE * PETMINITIALIZE;

typedef BOOL(WINAPI ETMPARSE)(PVOID Reserved);
typedef ETMPARSE *PETMPARSE;

typedef VOID(WINAPI ETMTERMINATE)(VOID);
typedef ETMTERMINATE * PETMTERMINATE;

typedef VOID(WINAPI ETMNEWUSERCREATED)(PCTSTR UserName, PCTSTR DomainName, PCTSTR UserProfileRoot, PSID UserSid);
typedef ETMNEWUSERCREATED * PETMNEWUSERCREATED;

typedef struct {
    UINT Version;
    PETMINITIALIZE EtmInitialize;
    PETMPARSE EtmParse;
    PETMTERMINATE EtmTerminate;
    PETMNEWUSERCREATED EtmNewUserCreated;
} TYPE_ENTRYPOINTS, *PTYPE_ENTRYPOINTS;

typedef BOOL(WINAPI VCMINITIALIZE)(PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef VCMINITIALIZE * PVCMINITIALIZE;

typedef BOOL(WINAPI VCMPARSE)(PVOID Reserved);
typedef VCMPARSE * PVCMPARSE;

typedef BOOL(WINAPI VCMQUEUEENUMERATION)(PVOID Reserved);
typedef VCMQUEUEENUMERATION * PVCMQUEUEENUMERATION;

typedef BOOL(WINAPI VCMQUEUEHIGHPRIORITYENUMERATION)(PVOID Reserved);
typedef VCMQUEUEHIGHPRIORITYENUMERATION * PVCMQUEUEHIGHPRIORITYENUMERATION;

typedef UINT(WINAPI VCMENUMERATIONCALLBACK)(
                IN      PCMIG_OBJECTENUMDATA Data,
                IN      ULONG_PTR CallerArg
                );
typedef VCMENUMERATIONCALLBACK * PVCMENUMERATIONCALLBACK;

typedef VOID(WINAPI VCMTERMINATE)(VOID);
typedef VCMTERMINATE * PVCMTERMINATE;

typedef struct {
    UINT Version;
    PVCMINITIALIZE VcmInitialize;
    PVCMPARSE VcmParse;
    PVCMQUEUEENUMERATION VcmQueueEnumeration;
    PVCMQUEUEHIGHPRIORITYENUMERATION VcmQueueHighPriorityEnumeration;
    PVCMTERMINATE VcmTerminate;
} VIRTUAL_COMPUTER_ENTRYPOINTS, *PVIRTUAL_COMPUTER_ENTRYPOINTS;

typedef BOOL(WINAPI SGMINITIALIZE)(PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef SGMINITIALIZE * PSGMINITIALIZE;

typedef BOOL(WINAPI SGMPARSE)(PVOID Reserved);
typedef SGMPARSE * PSGMPARSE;

typedef BOOL(WINAPI SGMQUEUEENUMERATION)(PVOID Reserved);
typedef SGMQUEUEENUMERATION * PSGMQUEUEENUMERATION;

typedef BOOL(WINAPI SGMQUEUEHIGHPRIORITYENUMERATION)(PVOID Reserved);
typedef SGMQUEUEHIGHPRIORITYENUMERATION * PSGMQUEUEHIGHPRIORITYENUMERATION;

typedef UINT(WINAPI SGMENUMERATIONCALLBACK)(
                IN      PCMIG_OBJECTENUMDATA Data,
                IN      ULONG_PTR CallerArg
                );
typedef SGMENUMERATIONCALLBACK * PSGMENUMERATIONCALLBACK;

typedef VOID(WINAPI SGMTERMINATE)(VOID);
typedef SGMTERMINATE * PSGMTERMINATE;

typedef BOOL(WINAPI SAMINITIALIZE)(PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef SAMINITIALIZE * PSAMINITIALIZE;

typedef BOOL(WINAPI SAMEXECUTE)(VOID);
typedef SAMEXECUTE * PSAMEXECUTE;

typedef VOID(WINAPI SAMESTIMATEPROGRESSBAR)(VOID);
typedef SAMESTIMATEPROGRESSBAR *PSAMESTIMATEPROGRESSBAR;

typedef VOID(WINAPI SAMTERMINATE)(VOID);
typedef SAMTERMINATE * PSAMTERMINATE;

typedef struct {
    UINT Version;
    PSGMINITIALIZE SgmInitialize;
    PSGMPARSE SgmParse;
    PSGMQUEUEENUMERATION SgmQueueEnumeration;
    PSGMQUEUEHIGHPRIORITYENUMERATION SgmQueueHighPriorityEnumeration;
    PSGMTERMINATE SgmTerminate;
    PSAMINITIALIZE SamInitialize;
    PSAMEXECUTE SamExecute;
    PSAMESTIMATEPROGRESSBAR SamEstimateProgressBar;
    PSAMTERMINATE SamTerminate;
} SOURCE_ENTRYPOINTS, *PSOURCE_ENTRYPOINTS;

typedef BOOL(WINAPI DGMINITIALIZE)(PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef DGMINITIALIZE * PDGMINITIALIZE;

typedef BOOL(WINAPI DGMQUEUEENUMERATION)(PVOID Reserved);
typedef DGMQUEUEENUMERATION * PDGMQUEUEENUMERATION;

typedef BOOL(WINAPI DGMQUEUEHIGHPRIORITYENUMERATION)(PVOID Reserved);
typedef DGMQUEUEHIGHPRIORITYENUMERATION * PDGMQUEUEHIGHPRIORITYENUMERATION;

typedef UINT(WINAPI DGMENUMERATIONCALLBACK)(
                IN      PCMIG_OBJECTENUMDATA Data,
                IN      ULONG_PTR CallerArg
                );
typedef DGMENUMERATIONCALLBACK * PDGMENUMERATIONCALLBACK;

typedef VOID(WINAPI DGMTERMINATE)(VOID);
typedef DGMTERMINATE * PDGMTERMINATE;

typedef BOOL(WINAPI DAMINITIALIZE)(PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef DAMINITIALIZE * PDAMINITIALIZE;

typedef BOOL(WINAPI DAMEXECUTE)(VOID);
typedef DAMEXECUTE * PDAMEXECUTE;

typedef VOID(WINAPI DAMESTIMATEPROGRESSBAR)(VOID);
typedef DAMESTIMATEPROGRESSBAR *PDAMESTIMATEPROGRESSBAR;

typedef VOID(WINAPI DAMTERMINATE)(VOID);
typedef DAMTERMINATE * PDAMTERMINATE;

typedef BOOL(WINAPI CSMINITIALIZE)(PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef CSMINITIALIZE * PCSMINITIALIZE;

typedef BOOL(WINAPI CSMEXECUTE)(VOID);
typedef CSMEXECUTE * PCSMEXECUTE;

typedef VOID(WINAPI CSMESTIMATEPROGRESSBAR)(VOID);
typedef CSMESTIMATEPROGRESSBAR *PCSMESTIMATEPROGRESSBAR;

typedef VOID(WINAPI CSMTERMINATE)(VOID);
typedef CSMTERMINATE * PCSMTERMINATE;

typedef BOOL(WINAPI OPMINITIALIZE)(PMIG_LOGCALLBACK LogCallback, PVOID Reserved);
typedef OPMINITIALIZE * POPMINITIALIZE;

typedef VOID(WINAPI OPMTERMINATE)(VOID);
typedef OPMTERMINATE * POPMTERMINATE;

typedef struct {
    UINT Version;
    PDGMINITIALIZE DgmInitialize;
    PDGMQUEUEENUMERATION DgmQueueEnumeration;
    PDGMQUEUEHIGHPRIORITYENUMERATION DgmQueueHighPriorityEnumeration;
    PDGMTERMINATE DgmTerminate;
    PDAMINITIALIZE DamInitialize;
    PDAMEXECUTE DamExecute;
    PDAMESTIMATEPROGRESSBAR DamEstimateProgressBar;
    PDAMTERMINATE DamTerminate;
    PCSMINITIALIZE CsmInitialize;
    PCSMEXECUTE CsmExecute;
    PCSMESTIMATEPROGRESSBAR CsmEstimateProgressBar;
    PCSMTERMINATE CsmTerminate;
    POPMINITIALIZE OpmInitialize;
    POPMTERMINATE OpmTerminate;
} DESTINATION_ENTRYPOINTS, *PDESTINATION_ENTRYPOINTS;

//
// callback prototypes
//

typedef UINT (WINAPI MIG_OBJECTENUMCALLBACK)(PCMIG_OBJECTENUMDATA Data, ULONG_PTR CallerArg);
typedef MIG_OBJECTENUMCALLBACK *PMIG_OBJECTENUMCALLBACK;

typedef BOOL (WINAPI MIG_PREENUMCALLBACK)(VOID);
typedef MIG_PREENUMCALLBACK *PMIG_PREENUMCALLBACK;

typedef BOOL (WINAPI MIG_POSTENUMCALLBACK)(VOID);
typedef MIG_POSTENUMCALLBACK *PMIG_POSTENUMCALLBACK;

typedef BOOL (WINAPI MIG_DYNAMICEXCLUSIONCALLBACK)(
                    MIG_OBJECTTYPEID ObjectTypeId,
                    MIG_OBJECTSTRINGHANDLE EncodedObjectName,
                    ULONG_PTR Arg
                    );

typedef MIG_DYNAMICEXCLUSIONCALLBACK *PMIG_DYNAMICEXCLUSIONCALLBACK;

typedef BOOL (WINAPI MIG_RESTORECALLBACK)(MIG_OBJECTTYPEID,MIG_OBJECTID,MIG_OBJECTSTRINGHANDLE);
typedef MIG_RESTORECALLBACK *PMIG_RESTORECALLBACK;

//
// entry points that return module funciton addresses
//

typedef BOOL(WINAPI VIRTUALCOMPUTERMODULE)(
                IN      PCTSTR ModuleId,
                IN OUT  PVIRTUAL_COMPUTER_ENTRYPOINTS VirtualComputerEntryPoints
                );
typedef VIRTUALCOMPUTERMODULE *PVIRTUALCOMPUTERMODULE;

typedef BOOL(WINAPI SOURCEMODULE)(
                IN      PCTSTR ModuleId,
                IN OUT  PSOURCE_ENTRYPOINTS SourceEntryPoints
                );
typedef SOURCEMODULE *PSOURCEMODULE;

typedef BOOL(WINAPI DESTINATIONMODULE)(
                IN      PCTSTR ModuleId,
                IN OUT  PDESTINATION_ENTRYPOINTS DestinationEntryPoints
                );
typedef DESTINATIONMODULE *PDESTINATIONMODULE;

typedef BOOL(WINAPI TYPEMODULE)(
                IN      PCTSTR ModuleId,
                IN OUT  PTYPE_ENTRYPOINTS TypeEntryPoints
                );
typedef TYPEMODULE *PTYPEMODULE;

typedef BOOL(WINAPI TRANSPORTMODULE)(
                IN      PCTSTR ModuleId,
                IN OUT  PTRANSPORT_ENTRYPOINTS TransportEntryPoints
                );
typedef TRANSPORTMODULE *PTRANSPORTMODULE;