| p2p.h (6.1.7600.16385-Windows_7.0) | | p2p.h (6.3.9600.17415-Windows_8.1) |
|---|
| | |
| skipping to change at line 30 | | skipping to change at line 30 |
|---|
| // NO_P2P_GROUP - no Peer-to-Peer Grouping | | // NO_P2P_GROUP - no Peer-to-Peer Grouping |
| // NO_P2P_GRAPH - no Peer-to-Peer Graphing | | // NO_P2P_GRAPH - no Peer-to-Peer Graphing |
| // NO_P2P_IDENTITY - no Peer-to-Peer Identity manager | | // NO_P2P_IDENTITY - no Peer-to-Peer Identity manager |
| // NO_P2P_PNRP - no Peer-to-Peer Peer Name Resolution Protocol | | // NO_P2P_PNRP - no Peer-to-Peer Peer Name Resolution Protocol |
| // NO_P2P_COLLABORATION - no Peer-to-Peer Collaboration Infrastructure | | // NO_P2P_COLLABORATION - no Peer-to-Peer Collaboration Infrastructure |
| // | | // |
| //---------------------------------------------------------------------------- | | //---------------------------------------------------------------------------- |
| | |
| #ifndef _P2P_H_ | | #ifndef _P2P_H_ |
| #define _P2P_H_ | | #define _P2P_H_ |
|
| | #include <winapifamily.h> |
| | |
| | #pragma region Desktop Family |
| | #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) |
| | |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| #include <specstrings.h> | | #include <specstrings.h> |
| #include <winsock2.h> | | #include <winsock2.h> |
| #include <pnrpns.h> | | #include <pnrpns.h> |
| #include <ws2tcpip.h> // for sockaddrin_6 | | #include <ws2tcpip.h> // for sockaddrin_6 |
| #endif | | #endif |
| | |
| #pragma warning(push) | | #pragma warning(push) |
| #pragma warning(disable:4201) // nameless struct/union | | #pragma warning(disable:4201) // nameless struct/union |
| | |
| skipping to change at line 278 | | skipping to change at line 282 |
|---|
| PEER_GRAPH_STATUS_FLAGS dwStatus; | | PEER_GRAPH_STATUS_FLAGS dwStatus; |
| PEER_EVENT_INCOMING_DATA incomingData; | | PEER_EVENT_INCOMING_DATA incomingData; |
| PEER_EVENT_RECORD_CHANGE_DATA recordChangeData; | | PEER_EVENT_RECORD_CHANGE_DATA recordChangeData; |
| PEER_EVENT_CONNECTION_CHANGE_DATA connectionChangeData; | | PEER_EVENT_CONNECTION_CHANGE_DATA connectionChangeData; |
| PEER_EVENT_NODE_CHANGE_DATA nodeChangeData; | | PEER_EVENT_NODE_CHANGE_DATA nodeChangeData; |
| PEER_EVENT_SYNCHRONIZED_DATA synchronizedData; | | PEER_EVENT_SYNCHRONIZED_DATA synchronizedData; |
| }; | | }; |
| } PEER_GRAPH_EVENT_DATA, *PPEER_GRAPH_EVENT_DATA; | | } PEER_GRAPH_EVENT_DATA, *PPEER_GRAPH_EVENT_DATA; |
| | |
| typedef HRESULT (CALLBACK * PFNPEER_VALIDATE_RECORD)( | | typedef HRESULT (CALLBACK * PFNPEER_VALIDATE_RECORD)( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt PVOID pvContext, | | _In_opt_ PVOID pvContext, |
| __in PPEER_RECORD pRecord, | | _In_ PPEER_RECORD pRecord, |
| __in PEER_RECORD_CHANGE_TYPE changeType); | | _In_ PEER_RECORD_CHANGE_TYPE changeType); |
| | |
| typedef HRESULT (CALLBACK * PFNPEER_SECURE_RECORD)( | | typedef HRESULT (CALLBACK * PFNPEER_SECURE_RECORD)( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt PVOID pvContext, | | _In_opt_ PVOID pvContext, |
| __in PPEER_RECORD pRecord, | | _In_ PPEER_RECORD pRecord, |
| __in PEER_RECORD_CHANGE_TYPE changeType, | | _In_ PEER_RECORD_CHANGE_TYPE changeType, |
| __deref_out PPEER_DATA * ppSecurityData); | | _Outptr_ PPEER_DATA * ppSecurityData); |
| | |
| typedef HRESULT (CALLBACK * PFNPEER_FREE_SECURITY_DATA)( | | typedef HRESULT (CALLBACK * PFNPEER_FREE_SECURITY_DATA)( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt PVOID pvContext, | | _In_opt_ PVOID pvContext, |
| __in PPEER_DATA pSecurityData); | | _In_ PPEER_DATA pSecurityData); |
| | |
| typedef HRESULT (CALLBACK * PFNPEER_ON_PASSWORD_AUTH_FAILED)( | | typedef HRESULT (CALLBACK * PFNPEER_ON_PASSWORD_AUTH_FAILED)( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt PVOID pvContext); | | _In_opt_ PVOID pvContext); |
| | |
| typedef struct peer_security_interface_tag { | | typedef struct peer_security_interface_tag { |
| DWORD dwSize; | | DWORD dwSize; |
| PWSTR pwzSspFilename; | | PWSTR pwzSspFilename; |
| PWSTR pwzPackageName; | | PWSTR pwzPackageName; |
| ULONG cbSecurityInfo; | | ULONG cbSecurityInfo; |
| PBYTE pbSecurityInfo; | | PBYTE pbSecurityInfo; |
| PVOID pvContext; | | PVOID pvContext; |
| PFNPEER_VALIDATE_RECORD pfnValidateRecord; | | PFNPEER_VALIDATE_RECORD pfnValidateRecord; |
| PFNPEER_SECURE_RECORD pfnSecureRecord; | | PFNPEER_SECURE_RECORD pfnSecureRecord; |
| PFNPEER_FREE_SECURITY_DATA pfnFreeSecurityData; | | PFNPEER_FREE_SECURITY_DATA pfnFreeSecurityData; |
| PFNPEER_ON_PASSWORD_AUTH_FAILED pfnAuthFailed; | | PFNPEER_ON_PASSWORD_AUTH_FAILED pfnAuthFailed; |
| }PEER_SECURITY_INTERFACE, * PPEER_SECURITY_INTERFACE; | | }PEER_SECURITY_INTERFACE, * PPEER_SECURITY_INTERFACE; |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // API Definitions | | // API Definitions |
| | |
| HRESULT WINAPI PeerGraphStartup( | | HRESULT WINAPI PeerGraphStartup( |
|
| __in WORD wVersionRequested, | | _In_ WORD wVersionRequested, |
| __out PPEER_VERSION_DATA pVersionData); | | _Out_ PPEER_VERSION_DATA pVersionData); |
| | |
| HRESULT WINAPI PeerGraphShutdown(); | | HRESULT WINAPI PeerGraphShutdown(); |
| | |
| VOID WINAPI PeerGraphFreeData( | | VOID WINAPI PeerGraphFreeData( |
|
| __in PVOID pvData); | | _In_ PVOID pvData); |
| | |
| HRESULT WINAPI PeerGraphGetItemCount( | | HRESULT WINAPI PeerGraphGetItemCount( |
|
| __in HPEERENUM hPeerEnum, | | _In_ HPEERENUM hPeerEnum, |
| __out ULONG * pCount); | | _Out_ ULONG * pCount); |
| | |
| HRESULT WINAPI PeerGraphGetNextItem( | | HRESULT WINAPI PeerGraphGetNextItem( |
|
| __in HPEERENUM hPeerEnum, | | _In_ HPEERENUM hPeerEnum, |
| __inout ULONG * pCount, | | _Inout_ ULONG * pCount, |
| __deref_out_ecount(*pCount) PVOID ** pppvItems); | | _Outptr_result_buffer_(*pCount) PVOID ** pppvItems); |
| | |
| HRESULT WINAPI PeerGraphEndEnumeration( | | HRESULT WINAPI PeerGraphEndEnumeration( |
|
| __in HPEERENUM hPeerEnum); | | _In_ HPEERENUM hPeerEnum); |
| | |
| HRESULT WINAPI PeerGraphCreate( | | HRESULT WINAPI PeerGraphCreate( |
|
| __in PPEER_GRAPH_PROPERTIES pGraphProperties, | | _In_ PPEER_GRAPH_PROPERTIES pGraphProperties, |
| __in PCWSTR pwzDatabaseName, | | _In_ PCWSTR pwzDatabaseName, |
| __in_opt PPEER_SECURITY_INTERFACE pSecurityInterface, | | _In_opt_ PPEER_SECURITY_INTERFACE pSecurityInterface, |
| __out HGRAPH * phGraph); | | _Out_ HGRAPH * phGraph); |
| | |
| HRESULT WINAPI PeerGraphOpen( | | HRESULT WINAPI PeerGraphOpen( |
|
| __in PCWSTR pwzGraph | | _In_ PCWSTR pwzGraph |
| Id, | | Id, |
| __in PCWSTR pwzPeerI | | _In_ PCWSTR pwzPeerI |
| d, | | d, |
| __in PCWSTR pwzDatab | | _In_ PCWSTR pwzDatab |
| aseName, | | aseName, |
| __in_opt PPEER_SECURITY_INTERFACE pSecurit | | _In_opt_ PPEER_SECURITY_INTERFACE pSecurit |
| yInterface, | | yInterface, |
| __in ULONG cRecordT | | _In_ ULONG cRecordT |
| ypeSyncPrecedence, | | ypeSyncPrecedence, |
| __in_ecount_opt(cRecordTypeSyncPrecedence) const GUID * pRecor | | _In_reads_opt_(cRecordTypeSyncPrecedence) const GUID * pRecord |
| dTypeSyncPrecedence, | | TypeSyncPrecedence, |
| __out HGRAPH * phGrap | | _Out_ HGRAPH * phGrap |
| h); | | h); |
| | |
| HRESULT WINAPI PeerGraphListen( | | HRESULT WINAPI PeerGraphListen( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt DWORD dwScope, | | _In_opt_ DWORD dwScope, |
| __in_opt DWORD dwScopeId, | | _In_opt_ DWORD dwScopeId, |
| __in_opt WORD wPort); | | _In_opt_ WORD wPort); |
| | |
| HRESULT WINAPI PeerGraphConnect( | | HRESULT WINAPI PeerGraphConnect( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt PCWSTR pwzPeerId, | | _In_opt_ PCWSTR pwzPeerId, |
| __in PPEER_ADDRESS pAddress, | | _In_ PPEER_ADDRESS pAddress, |
| __out ULONGLONG * pullConnectionId); | | _Out_ ULONGLONG * pullConnectionId); |
| | |
| HRESULT WINAPI PeerGraphClose( | | HRESULT WINAPI PeerGraphClose( |
|
| __in HGRAPH hGraph); | | _In_ HGRAPH hGraph); |
| | |
| HRESULT WINAPI PeerGraphDelete( | | HRESULT WINAPI PeerGraphDelete( |
|
| __in PCWSTR pwzGraphId, | | _In_ PCWSTR pwzGraphId, |
| __in PCWSTR pwzPeerId, | | _In_ PCWSTR pwzPeerId, |
| __in PCWSTR pwzDatabaseName); | | _In_ PCWSTR pwzDatabaseName); |
| | |
| HRESULT WINAPI PeerGraphGetStatus( | | HRESULT WINAPI PeerGraphGetStatus( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __out DWORD * pdwStatus); | | _Out_ DWORD * pdwStatus); |
| | |
| HRESULT WINAPI PeerGraphGetProperties( | | HRESULT WINAPI PeerGraphGetProperties( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __deref_out PPEER_GRAPH_PROPERTIES * ppGraphProperties); | | _Outptr_ PPEER_GRAPH_PROPERTIES * ppGraphProperties); |
| | |
| HRESULT WINAPI PeerGraphSetProperties( | | HRESULT WINAPI PeerGraphSetProperties( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PPEER_GRAPH_PROPERTIES pGraphProperties); | | _In_ PPEER_GRAPH_PROPERTIES pGraphProperties); |
| | |
| // Eventing interfaces | | // Eventing interfaces |
| | |
| HRESULT WINAPI PeerGraphRegisterEvent( | | HRESULT WINAPI PeerGraphRegisterEvent( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in HANDLE hEvent, | | _In_ HANDLE hEvent, |
| __in ULONG cEventRegistrations, | | _In_ ULONG cEventRegistrations, |
| __in_ecount(cEventRegistrations) PEER_GRAPH_EVENT_REGISTRATION | | _In_reads_(cEventRegistrations) PEER_GRAPH_EVENT_REGISTRATION * |
| * pEventRegistrations, | | pEventRegistrations, |
| __out HPEEREVENT * phPeerEvent); | | _Out_ HPEEREVENT * phPeerEvent); |
| | |
| HRESULT WINAPI PeerGraphUnregisterEvent( | | HRESULT WINAPI PeerGraphUnregisterEvent( |
|
| __in HPEEREVENT hPeerEvent); | | _In_ HPEEREVENT hPeerEvent); |
| | |
| HRESULT WINAPI PeerGraphGetEventData( | | HRESULT WINAPI PeerGraphGetEventData( |
|
| __in HPEEREVENT hPeerEvent, | | _In_ HPEEREVENT hPeerEvent, |
| __deref_out PPEER_GRAPH_EVENT_DATA * ppEventData); | | _Outptr_ PPEER_GRAPH_EVENT_DATA * ppEventData); |
| | |
| // Data Storage | | // Data Storage |
| | |
| HRESULT WINAPI PeerGraphGetRecord( | | HRESULT WINAPI PeerGraphGetRecord( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in const GUID * pRecordId, | | _In_ const GUID * pRecordId, |
| __deref_out PPEER_RECORD * ppRecord); | | _Outptr_ PPEER_RECORD * ppRecord); |
| | |
| HRESULT WINAPI PeerGraphAddRecord( | | HRESULT WINAPI PeerGraphAddRecord( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PPEER_RECORD pRecord, | | _In_ PPEER_RECORD pRecord, |
| __out GUID * pRecordId); | | _Out_ GUID * pRecordId); |
| | |
| HRESULT WINAPI PeerGraphUpdateRecord( | | HRESULT WINAPI PeerGraphUpdateRecord( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PPEER_RECORD pRecord); | | _In_ PPEER_RECORD pRecord); |
| | |
| HRESULT WINAPI PeerGraphDeleteRecord( | | HRESULT WINAPI PeerGraphDeleteRecord( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in const GUID * pRecordId, | | _In_ const GUID * pRecordId, |
| __in BOOL fLocal); | | _In_ BOOL fLocal); |
| | |
| HRESULT WINAPI PeerGraphEnumRecords( | | HRESULT WINAPI PeerGraphEnumRecords( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt const GUID * pRecordType, | | _In_opt_ const GUID * pRecordType, |
| __in_opt PCWSTR pwzPeerId, | | _In_opt_ PCWSTR pwzPeerId, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGraphSearchRecords( | | HRESULT WINAPI PeerGraphSearchRecords( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PCWSTR pwzCriteria, | | _In_ PCWSTR pwzCriteria, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGraphExportDatabase( | | HRESULT WINAPI PeerGraphExportDatabase( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PCWSTR pwzFilePath); | | _In_ PCWSTR pwzFilePath); |
| | |
| HRESULT WINAPI PeerGraphImportDatabase( | | HRESULT WINAPI PeerGraphImportDatabase( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PCWSTR pwzFilePath); | | _In_ PCWSTR pwzFilePath); |
| | |
| HRESULT WINAPI PeerGraphValidateDeferredRecords( | | HRESULT WINAPI PeerGraphValidateDeferredRecords( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in ULONG cRecordIds, | | _In_ ULONG cRecordIds, |
| __in_ecount(cRecordIds) const GUID * pRecordIds); | | _In_reads_(cRecordIds) const GUID * pRecordIds); |
| | |
| // Node/Connection interfaces | | // Node/Connection interfaces |
| | |
| HRESULT WINAPI PeerGraphOpenDirectConnection( | | HRESULT WINAPI PeerGraphOpenDirectConnection( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PCWSTR pwzPeerId, | | _In_ PCWSTR pwzPeerId, |
| __in PPEER_ADDRESS pAddress, | | _In_ PPEER_ADDRESS pAddress, |
| __out ULONGLONG * pullConnectionId); | | _Out_ ULONGLONG * pullConnectionId); |
| | |
| HRESULT WINAPI PeerGraphSendData( | | HRESULT WINAPI PeerGraphSendData( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in ULONGLONG ullConnectionId, | | _In_ ULONGLONG ullConnectionId, |
| __in const GUID * pType, | | _In_ const GUID * pType, |
| __in ULONG cbData, | | _In_ ULONG cbData, |
| __in_bcount(cbData) PVOID pvData); | | _In_reads_bytes_(cbData) PVOID pvData); |
| | |
| HRESULT WINAPI PeerGraphCloseDirectConnection( | | HRESULT WINAPI PeerGraphCloseDirectConnection( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in ULONGLONG ullConnectionId); | | _In_ ULONGLONG ullConnectionId); |
| | |
| HRESULT WINAPI PeerGraphEnumConnections( | | HRESULT WINAPI PeerGraphEnumConnections( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in DWORD dwFlags, // PEER_CONNECTION_FLAGS | | _In_ DWORD dwFlags, // PEER_CONNECTION_FLAGS |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGraphEnumNodes( | | HRESULT WINAPI PeerGraphEnumNodes( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in_opt PCWSTR pwzPeerId, | | _In_opt_ PCWSTR pwzPeerId, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGraphSetPresence( | | HRESULT WINAPI PeerGraphSetPresence( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in BOOL fPresent); | | _In_ BOOL fPresent); |
| | |
| HRESULT WINAPI PeerGraphGetNodeInfo( | | HRESULT WINAPI PeerGraphGetNodeInfo( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in ULONGLONG ullNodeId, | | _In_ ULONGLONG ullNodeId, |
| __deref_out PPEER_NODE_INFO * ppNodeInfo); | | _Outptr_ PPEER_NODE_INFO * ppNodeInfo); |
| | |
| HRESULT WINAPI PeerGraphSetNodeAttributes( | | HRESULT WINAPI PeerGraphSetNodeAttributes( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in PCWSTR pwzAttributes); | | _In_ PCWSTR pwzAttributes); |
| | |
| HRESULT WINAPI PeerGraphPeerTimeToUniversalTime( | | HRESULT WINAPI PeerGraphPeerTimeToUniversalTime( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in FILETIME * pftPeerTime, | | _In_ FILETIME * pftPeerTime, |
| __out FILETIME * pftUniversalTime); | | _Out_ FILETIME * pftUniversalTime); |
| | |
| HRESULT WINAPI PeerGraphUniversalTimeToPeerTime( | | HRESULT WINAPI PeerGraphUniversalTimeToPeerTime( |
|
| __in HGRAPH hGraph, | | _In_ HGRAPH hGraph, |
| __in FILETIME * pftUniversalTime, | | _In_ FILETIME * pftUniversalTime, |
| __out FILETIME * pftPeerTime); | | _Out_ FILETIME * pftPeerTime); |
| | |
| #endif // MIDL_PASS | | #endif // MIDL_PASS |
| #endif // NO_P2P_GRAPH | | #endif // NO_P2P_GRAPH |
| | |
| #if (!(defined (NO_P2P_GROUP)) || (!defined (NO_P2P_IDENTITY))) | | #if (!(defined (NO_P2P_GROUP)) || (!defined (NO_P2P_IDENTITY))) |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| | |
| ////////////////////////////////////////////////////////////////////////////// | | ////////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // Common APIs used by Grouping and the Identity Manager | | // Common APIs used by Grouping and the Identity Manager |
| // | | // |
| ////////////////////////////////////////////////////////////////////////////// | | ////////////////////////////////////////////////////////////////////////////// |
| | |
| #include <wincrypt.h> | | #include <wincrypt.h> |
| | |
| VOID WINAPI PeerFreeData( | | VOID WINAPI PeerFreeData( |
|
| __in_opt LPCVOID pvData); | | _In_opt_ LPCVOID pvData); |
| | |
| HRESULT WINAPI PeerGetItemCount( | | HRESULT WINAPI PeerGetItemCount( |
|
| __in HPEERENUM hPeerEnum, | | _In_ HPEERENUM hPeerEnum, |
| __out ULONG * pCount); | | _Out_ ULONG * pCount); |
| | |
| HRESULT WINAPI PeerGetNextItem( | | HRESULT WINAPI PeerGetNextItem( |
|
| __in HPEERENUM hPeerEnum, | | _In_ HPEERENUM hPeerEnum, |
| __inout ULONG * pCount, | | _Inout_ ULONG * pCount, |
| __deref_out_ecount(*pCount) PVOID ** pppvItems); | | _Outptr_result_buffer_(*pCount) PVOID ** pppvItems); |
| | |
| HRESULT WINAPI PeerEndEnumeration( | | HRESULT WINAPI PeerEndEnumeration( |
|
| __in HPEERENUM hPeerEnum); | | _In_ HPEERENUM hPeerEnum); |
| | |
| #endif // MIDL_PASS | | #endif // MIDL_PASS |
| #endif | | #endif |
| | |
| #ifndef NO_P2P_GROUP | | #ifndef NO_P2P_GROUP |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // G R O U P I N G | | // G R O U P I N G |
| // | | // |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
| skipping to change at line 610 | | skipping to change at line 614 |
|---|
| { | | { |
| DWORD dwSize; | | DWORD dwSize; |
| DWORD dwFlags; | | DWORD dwFlags; |
| PWSTR pwzFriendlyName; | | PWSTR pwzFriendlyName; |
| CERT_PUBLIC_KEY_INFO * pPublicKey; | | CERT_PUBLIC_KEY_INFO * pPublicKey; |
| PWSTR pwzIssuerPeerName; | | PWSTR pwzIssuerPeerName; |
| PWSTR pwzIssuerFriendlyName; | | PWSTR pwzIssuerFriendlyName; |
| FILETIME ftValidityStart; | | FILETIME ftValidityStart; |
| FILETIME ftValidityEnd; | | FILETIME ftValidityEnd; |
| ULONG cRoles; | | ULONG cRoles; |
|
| __field_ecount(cRoles) PEER_ROLE_ID * pRoles; | | _Field_size_(cRoles) PEER_ROLE_ID * pRoles; |
| } PEER_CREDENTIAL_INFO, * PPEER_CREDENTIAL_INFO; | | } PEER_CREDENTIAL_INFO, * PPEER_CREDENTIAL_INFO; |
| | |
| typedef struct peer_member_tag { | | typedef struct peer_member_tag { |
| DWORD dwSize; | | DWORD dwSize; |
| DWORD dwFlags; // PEER_MEMBER_FLAGS | | DWORD dwFlags; // PEER_MEMBER_FLAGS |
| PWSTR pwzIdentity; | | PWSTR pwzIdentity; |
| PWSTR pwzAttributes; | | PWSTR pwzAttributes; |
| ULONGLONG ullNodeId; | | ULONGLONG ullNodeId; |
| ULONG cAddresses; | | ULONG cAddresses; |
|
| __field_ecount(cAddresses) PEER_ADDRESS * pAddresses; | | _Field_size_(cAddresses) PEER_ADDRESS * pAddresses; |
| PEER_CREDENTIAL_INFO * pCredentialInfo; | | PEER_CREDENTIAL_INFO * pCredentialInfo; |
| } PEER_MEMBER, *PPEER_MEMBER; | | } PEER_MEMBER, *PPEER_MEMBER; |
| | |
| typedef struct peer_invitation_info_tag { | | typedef struct peer_invitation_info_tag { |
| DWORD dwSize; | | DWORD dwSize; |
| DWORD dwFlags; | | DWORD dwFlags; |
| PWSTR pwzCloudName; | | PWSTR pwzCloudName; |
| DWORD dwScope; | | DWORD dwScope; |
| DWORD dwCloudFlags; | | DWORD dwCloudFlags; |
| PWSTR pwzGroupPeerName; | | PWSTR pwzGroupPeerName; |
| | |
| skipping to change at line 736 | | skipping to change at line 740 |
|---|
| PWSTR pwzPeerName; | | PWSTR pwzPeerName; |
| PWSTR pwzFriendlyName; | | PWSTR pwzFriendlyName; |
| } PEER_NAME_PAIR, * PPEER_NAME_PAIR; | | } PEER_NAME_PAIR, * PPEER_NAME_PAIR; |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // API Definitions | | // API Definitions |
| | |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| | |
| HRESULT WINAPI PeerGroupStartup( | | HRESULT WINAPI PeerGroupStartup( |
|
| __in WORD wVersionRequested, | | _In_ WORD wVersionRequested, |
| __out PPEER_VERSION_DATA pVersionData); | | _Out_ PPEER_VERSION_DATA pVersionData); |
| | |
| HRESULT WINAPI PeerGroupShutdown(); | | HRESULT WINAPI PeerGroupShutdown(); |
| | |
| HRESULT WINAPI PeerGroupCreate( | | HRESULT WINAPI PeerGroupCreate( |
|
| __in PPEER_GROUP_PROPERTIES pProperties, | | _In_ PPEER_GROUP_PROPERTIES pProperties, |
| __out HGROUP * phGroup); | | _Out_ HGROUP * phGroup); |
| | |
| HRESULT WINAPI PeerGroupOpen( | | HRESULT WINAPI PeerGroupOpen( |
|
| __in PCWSTR pwzIdentity, | | _In_ PCWSTR pwzIdentity, |
| __in PCWSTR pwzGroupPeerName, | | _In_ PCWSTR pwzGroupPeerName, |
| __in_opt PCWSTR pwzCloud, | | _In_opt_ PCWSTR pwzCloud, |
| __out HGROUP * phGroup); | | _Out_ HGROUP * phGroup); |
| | |
| HRESULT WINAPI PeerGroupJoin( | | HRESULT WINAPI PeerGroupJoin( |
|
| __in PCWSTR pwzIdentity, | | _In_ PCWSTR pwzIdentity, |
| __in PCWSTR pwzInvitation, | | _In_ PCWSTR pwzInvitation, |
| __in_opt PCWSTR pwzCloud, | | _In_opt_ PCWSTR pwzCloud, |
| __out HGROUP * phGroup); | | _Out_ HGROUP * phGroup); |
| | |
| #if NTDDI_VERSION >= NTDDI_VISTA | | #if NTDDI_VERSION >= NTDDI_VISTA |
| HRESULT WINAPI PeerGroupPasswordJoin( | | HRESULT WINAPI PeerGroupPasswordJoin( |
|
| __in PCWSTR pwzIdentity, | | _In_ PCWSTR pwzIdentity, |
| __in PCWSTR pwzInvitation, | | _In_ PCWSTR pwzInvitation, |
| __in PCWSTR pwzPassword, | | _In_ PCWSTR pwzPassword, |
| __in_opt PCWSTR pwzCloud, | | _In_opt_ PCWSTR pwzCloud, |
| __out HGROUP * phGroup); | | _Out_ HGROUP * phGroup); |
| #endif | | #endif |
| | |
| HRESULT WINAPI PeerGroupConnect( | | HRESULT WINAPI PeerGroupConnect( |
|
| __in HGROUP hGroup); | | _In_ HGROUP hGroup); |
| | |
| #if NTDDI_VERSION >= NTDDI_VISTA | | #if NTDDI_VERSION >= NTDDI_VISTA |
| HRESULT WINAPI PeerGroupConnectByAddress( | | HRESULT WINAPI PeerGroupConnectByAddress( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| ULONG cAddresses, | | ULONG cAddresses, |
|
| __in_ecount(cAddresses) PPEER_ADDRESS pAddresses); | | _In_reads_(cAddresses) PPEER_ADDRESS pAddresses); |
| #endif | | #endif |
| | |
| HRESULT WINAPI PeerGroupClose( | | HRESULT WINAPI PeerGroupClose( |
|
| __in HGROUP hGroup); | | _In_ HGROUP hGroup); |
| | |
| HRESULT WINAPI PeerGroupDelete( | | HRESULT WINAPI PeerGroupDelete( |
|
| __in PCWSTR pwzIdentity, | | _In_ PCWSTR pwzIdentity, |
| __in PCWSTR pwzGroupPeerName); | | _In_ PCWSTR pwzGroupPeerName); |
| | |
| HRESULT WINAPI PeerGroupCreateInvitation( | | HRESULT WINAPI PeerGroupCreateInvitation( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PCWSTR pwzIdentityInfo, | | _In_ PCWSTR pwzIdentityInfo, |
| __in_opt FILETIME * pftExpiration, | | _In_opt_ FILETIME * pftExpiration, |
| __in ULONG cRoles, | | _In_ ULONG cRoles, |
| __in_ecount_opt(cRoles) const GUID * pRoles, | | _In_reads_opt_(cRoles) const GUID * pRoles, |
| __deref_out PWSTR * ppwzInvitation); | | _Outptr_ PWSTR * ppwzInvitation); |
| | |
| #if NTDDI_VERSION >= NTDDI_VISTA | | #if NTDDI_VERSION >= NTDDI_VISTA |
| HRESULT WINAPI PeerGroupCreatePasswordInvitation( | | HRESULT WINAPI PeerGroupCreatePasswordInvitation( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __deref_out PWSTR * ppwzInvitation); | | _Outptr_ PWSTR * ppwzInvitation); |
| #endif | | #endif |
| | |
| HRESULT WINAPI PeerGroupParseInvitation( | | HRESULT WINAPI PeerGroupParseInvitation( |
|
| __in PCWSTR pwzInvitation, | | _In_ PCWSTR pwzInvitation, |
| __deref_out PPEER_INVITATION_INFO * ppInvitationInfo); | | _Outptr_ PPEER_INVITATION_INFO * ppInvitationInfo); |
| | |
| HRESULT WINAPI PeerGroupGetStatus( | | HRESULT WINAPI PeerGroupGetStatus( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __out DWORD * pdwStatus); | | _Out_ DWORD * pdwStatus); |
| | |
| HRESULT WINAPI PeerGroupGetProperties( | | HRESULT WINAPI PeerGroupGetProperties( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __deref_out PPEER_GROUP_PROPERTIES * ppProperties); | | _Outptr_ PPEER_GROUP_PROPERTIES * ppProperties); |
| | |
| HRESULT WINAPI PeerGroupSetProperties( | | HRESULT WINAPI PeerGroupSetProperties( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PPEER_GROUP_PROPERTIES pProperties); | | _In_ PPEER_GROUP_PROPERTIES pProperties); |
| | |
| HRESULT WINAPI PeerGroupEnumMembers( | | HRESULT WINAPI PeerGroupEnumMembers( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in DWORD dwFlags, // PEER_MEMBER_FLAGS | | _In_ DWORD dwFlags, // PEER_MEMBER_FLAGS |
| __in_opt PCWSTR pwzIdentity, | | _In_opt_ PCWSTR pwzIdentity, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGroupOpenDirectConnection( | | HRESULT WINAPI PeerGroupOpenDirectConnection( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PCWSTR pwzIdentity, | | _In_ PCWSTR pwzIdentity, |
| __in PPEER_ADDRESS pAddress, | | _In_ PPEER_ADDRESS pAddress, |
| __out ULONGLONG * pullConnectionId); | | _Out_ ULONGLONG * pullConnectionId); |
| | |
| HRESULT WINAPI PeerGroupCloseDirectConnection( | | HRESULT WINAPI PeerGroupCloseDirectConnection( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in ULONGLONG ullConnectionId); | | _In_ ULONGLONG ullConnectionId); |
| | |
| HRESULT WINAPI PeerGroupEnumConnections( | | HRESULT WINAPI PeerGroupEnumConnections( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in DWORD dwFlags, // PEER_CONNECTION_FLAGS | | _In_ DWORD dwFlags, // PEER_CONNECTION_FLAGS |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGroupSendData( | | HRESULT WINAPI PeerGroupSendData( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in ULONGLONG ullConnectionId, | | _In_ ULONGLONG ullConnectionId, |
| __in const GUID * pType, | | _In_ const GUID * pType, |
| __in ULONG cbData, | | _In_ ULONG cbData, |
| __in_bcount(cbData) PVOID pvData); | | _In_reads_bytes_(cbData) PVOID pvData); |
| | |
| // Eventing interfaces | | // Eventing interfaces |
| | |
| HRESULT WINAPI PeerGroupRegisterEvent( | | HRESULT WINAPI PeerGroupRegisterEvent( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in HANDLE hEvent, | | _In_ HANDLE hEvent, |
| __in DWORD cEventRegistration, | | _In_ DWORD cEventRegistration, |
| __in_ecount(cEventRegistration) PEER_GROUP_EVENT_REGISTRATION | | _In_reads_(cEventRegistration) PEER_GROUP_EVENT_REGISTRATION * |
| * pEventRegistrations, | | pEventRegistrations, |
| __out HPEEREVENT * phPeerEvent); | | _Out_ HPEEREVENT * phPeerEvent); |
| | |
| HRESULT WINAPI PeerGroupUnregisterEvent( | | HRESULT WINAPI PeerGroupUnregisterEvent( |
|
| __in HPEEREVENT hPeerEvent); | | _In_ HPEEREVENT hPeerEvent); |
| | |
| HRESULT WINAPI PeerGroupGetEventData( | | HRESULT WINAPI PeerGroupGetEventData( |
|
| __in HPEEREVENT hPeerEvent, | | _In_ HPEEREVENT hPeerEvent, |
| __deref_out PPEER_GROUP_EVENT_DATA * ppEventData); | | _Outptr_ PPEER_GROUP_EVENT_DATA * ppEventData); |
| | |
| // Data Storage | | // Data Storage |
| | |
| HRESULT WINAPI PeerGroupGetRecord( | | HRESULT WINAPI PeerGroupGetRecord( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in const GUID * pRecordId, | | _In_ const GUID * pRecordId, |
| __deref_out PPEER_RECORD * ppRecord); | | _Outptr_ PPEER_RECORD * ppRecord); |
| | |
| HRESULT WINAPI PeerGroupAddRecord( | | HRESULT WINAPI PeerGroupAddRecord( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PPEER_RECORD pRecord, | | _In_ PPEER_RECORD pRecord, |
| __out GUID * pRecordId); | | _Out_ GUID * pRecordId); |
| | |
| HRESULT WINAPI PeerGroupUpdateRecord( | | HRESULT WINAPI PeerGroupUpdateRecord( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PPEER_RECORD pRecord); | | _In_ PPEER_RECORD pRecord); |
| | |
| HRESULT WINAPI PeerGroupDeleteRecord( | | HRESULT WINAPI PeerGroupDeleteRecord( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in const GUID * pRecordId); | | _In_ const GUID * pRecordId); |
| | |
| HRESULT WINAPI PeerGroupEnumRecords( | | HRESULT WINAPI PeerGroupEnumRecords( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in_opt const GUID * pRecordType, | | _In_opt_ const GUID * pRecordType, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGroupSearchRecords( | | HRESULT WINAPI PeerGroupSearchRecords( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PCWSTR pwzCriteria, | | _In_ PCWSTR pwzCriteria, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerGroupExportDatabase( | | HRESULT WINAPI PeerGroupExportDatabase( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PCWSTR pwzFilePath); | | _In_ PCWSTR pwzFilePath); |
| | |
| HRESULT WINAPI PeerGroupImportDatabase( | | HRESULT WINAPI PeerGroupImportDatabase( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PCWSTR pwzFilePath); | | _In_ PCWSTR pwzFilePath); |
| | |
| HRESULT WINAPI PeerGroupIssueCredentials( | | HRESULT WINAPI PeerGroupIssueCredentials( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PCWSTR pwzSubjectIdentity, | | _In_ PCWSTR pwzSubjectIdentity, |
| __in_opt PEER_CREDENTIAL_INFO * pCredentialInfo, | | _In_opt_ PEER_CREDENTIAL_INFO * pCredentialInfo, |
| __in DWORD dwFlags, | | _In_ DWORD dwFlags, |
| __deref_opt_out PWSTR * ppwzInvitation); | | _Outptr_opt_ PWSTR * ppwzInvitation); |
| | |
| HRESULT WINAPI PeerGroupExportConfig( | | HRESULT WINAPI PeerGroupExportConfig( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in PCWSTR pwzPassword, | | _In_ PCWSTR pwzPassword, |
| __deref_out PWSTR * ppwzXML); | | _Outptr_ PWSTR * ppwzXML); |
| | |
| HRESULT WINAPI PeerGroupImportConfig( | | HRESULT WINAPI PeerGroupImportConfig( |
|
| __in PCWSTR pwzXML, | | _In_ PCWSTR pwzXML, |
| __in PCWSTR pwzPassword, | | _In_ PCWSTR pwzPassword, |
| __in BOOL fOverwrite, | | _In_ BOOL fOverwrite, |
| __deref_out PWSTR * ppwzIdentity, | | _Outptr_ PWSTR * ppwzIdentity, |
| __deref_out PWSTR * ppwzGroup); | | _Outptr_ PWSTR * ppwzGroup); |
| | |
| HRESULT WINAPI PeerGroupPeerTimeToUniversalTime( | | HRESULT WINAPI PeerGroupPeerTimeToUniversalTime( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in FILETIME * pftPeerTime, | | _In_ FILETIME * pftPeerTime, |
| __out FILETIME * pftUniversalTime); | | _Out_ FILETIME * pftUniversalTime); |
| | |
| HRESULT WINAPI PeerGroupUniversalTimeToPeerTime( | | HRESULT WINAPI PeerGroupUniversalTimeToPeerTime( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in FILETIME * pftUniversalTime, | | _In_ FILETIME * pftUniversalTime, |
| __out FILETIME * pftPeerTime); | | _Out_ FILETIME * pftPeerTime); |
| | |
| #if NTDDI_VERSION >= NTDDI_WIN7 | | #if NTDDI_VERSION >= NTDDI_WIN7 |
| HRESULT WINAPI PeerGroupResumePasswordAuthentication( | | HRESULT WINAPI PeerGroupResumePasswordAuthentication( |
|
| __in HGROUP hGroup, | | _In_ HGROUP hGroup, |
| __in HPEEREVENT hPeerEventHandle); | | _In_ HPEEREVENT hPeerEventHandle); |
| #endif | | #endif |
| | |
| #endif // NIDL_PASS | | #endif // NIDL_PASS |
| | |
| #endif // NO_P2P_GROUP | | #endif // NO_P2P_GROUP |
| | |
| #ifndef NO_P2P_IDENTITY | | #ifndef NO_P2P_IDENTITY |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // I D E N T I T Y | | // I D E N T I T Y |
| // | | // |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
| // API Definitions | | // API Definitions |
| | |
| HRESULT WINAPI PeerIdentityCreate( | | HRESULT WINAPI PeerIdentityCreate( |
|
| __in_opt PCWSTR pwzClassifier, | | _In_opt_ PCWSTR pwzClassifier, |
| __in_opt PCWSTR pwzFriendlyName, | | _In_opt_ PCWSTR pwzFriendlyName, |
| __in_opt HCRYPTPROV hCryptProv, | | _In_opt_ HCRYPTPROV hCryptProv, |
| __deref_out PWSTR * ppwzIdentity); | | _Outptr_ PWSTR * ppwzIdentity); |
| | |
| HRESULT WINAPI PeerIdentityGetFriendlyName( | | HRESULT WINAPI PeerIdentityGetFriendlyName( |
|
| __in_opt PCWSTR pwzIdentity, | | _In_opt_ PCWSTR pwzIdentity, |
| __deref_out PWSTR * ppwzFriendlyName); | | _Outptr_ PWSTR * ppwzFriendlyName); |
| | |
| HRESULT WINAPI PeerIdentitySetFriendlyName( | | HRESULT WINAPI PeerIdentitySetFriendlyName( |
|
| __in_opt PCWSTR pwzIdentity, | | _In_opt_ PCWSTR pwzIdentity, |
| __in PCWSTR pwzFriendlyName); | | _In_ PCWSTR pwzFriendlyName); |
| | |
| HRESULT WINAPI PeerIdentityGetCryptKey( | | HRESULT WINAPI PeerIdentityGetCryptKey( |
|
| __in_opt PCWSTR pwzIdentity, | | _In_opt_ PCWSTR pwzIdentity, |
| __out HCRYPTPROV * phCryptProv); | | _Out_ HCRYPTPROV * phCryptProv); |
| | |
| HRESULT WINAPI PeerIdentityDelete( | | HRESULT WINAPI PeerIdentityDelete( |
|
| __in PCWSTR pwzIdentity); | | _In_ PCWSTR pwzIdentity); |
| | |
| HRESULT WINAPI PeerEnumIdentities( | | HRESULT WINAPI PeerEnumIdentities( |
|
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerEnumGroups( | | HRESULT WINAPI PeerEnumGroups( |
|
| __in PCWSTR pwzIdentity, | | _In_ PCWSTR pwzIdentity, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerCreatePeerName( | | HRESULT WINAPI PeerCreatePeerName( |
|
| __in_opt PCWSTR pwzIdentity, | | _In_opt_ PCWSTR pwzIdentity, |
| __in_opt PCWSTR pwzClassifier, | | _In_opt_ PCWSTR pwzClassifier, |
| __deref_out PWSTR * ppwzPeerName); | | _Outptr_ PWSTR * ppwzPeerName); |
| | |
| HRESULT WINAPI PeerIdentityGetXML( | | HRESULT WINAPI PeerIdentityGetXML( |
|
| __in_opt PCWSTR pwzIdentity, | | _In_opt_ PCWSTR pwzIdentity, |
| __deref_out PWSTR * ppwzIdentityXML); | | _Outptr_ PWSTR * ppwzIdentityXML); |
| | |
| HRESULT WINAPI PeerIdentityExport( | | HRESULT WINAPI PeerIdentityExport( |
|
| __in_opt PCWSTR pwzIdentity, | | _In_opt_ PCWSTR pwzIdentity, |
| __in PCWSTR pwzPassword, | | _In_ PCWSTR pwzPassword, |
| __deref_out PWSTR * ppwzExportXML); | | _Outptr_ PWSTR * ppwzExportXML); |
| | |
| HRESULT WINAPI PeerIdentityImport( | | HRESULT WINAPI PeerIdentityImport( |
|
| __in PCWSTR pwzImportXML, | | _In_ PCWSTR pwzImportXML, |
| __in PCWSTR pwzPassword, | | _In_ PCWSTR pwzPassword, |
| __deref_out PWSTR * ppwzIdentity); | | _Outptr_ PWSTR * ppwzIdentity); |
| | |
| HRESULT WINAPI PeerIdentityGetDefault( | | HRESULT WINAPI PeerIdentityGetDefault( |
|
| __deref_out PWSTR * ppwzPeerName); | | _Outptr_ PWSTR * ppwzPeerName); |
| | |
| #endif // MIDL_PASS | | #endif // MIDL_PASS |
| #endif // NO_P2P_IDENTITY | | #endif // NO_P2P_IDENTITY |
| | |
| #ifndef NO_P2P_COLLABORATION | | #ifndef NO_P2P_COLLABORATION |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // C O L L A B O R A T I O N | | // C O L L A B O R A T I O N |
| // | | // |
| | |
| skipping to change at line 1084 | | skipping to change at line 1088 |
|---|
| GUID id; | | GUID id; |
| } PEER_PEOPLE_NEAR_ME, *PPEER_PEOPLE_NEAR_ME; | | } PEER_PEOPLE_NEAR_ME, *PPEER_PEOPLE_NEAR_ME; |
| typedef const PEER_PEOPLE_NEAR_ME *PCPEER_PEOPLE_NEAR_ME; | | typedef const PEER_PEOPLE_NEAR_ME *PCPEER_PEOPLE_NEAR_ME; |
| typedef PPEER_PEOPLE_NEAR_ME *PPPEER_PEOPLE_NEAR_ME; | | typedef PPEER_PEOPLE_NEAR_ME *PPPEER_PEOPLE_NEAR_ME; |
| | |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // APIs | | // APIs |
| | |
| HRESULT WINAPI PeerCollabStartup( | | HRESULT WINAPI PeerCollabStartup( |
|
| __in WORD wVersionRequested); | | _In_ WORD wVersionRequested); |
| | |
| HRESULT WINAPI PeerCollabShutdown(); | | HRESULT WINAPI PeerCollabShutdown(); |
| | |
| HRESULT WINAPI PeerCollabSignin( | | HRESULT WINAPI PeerCollabSignin( |
|
| __in_opt HWND hwndParent, | | _In_opt_ HWND hwndParent, |
| __in DWORD dwSigninOptions); | | _In_ DWORD dwSigninOptions); |
| | |
| HRESULT WINAPI PeerCollabSignout( | | HRESULT WINAPI PeerCollabSignout( |
|
| __in DWORD dwSigninOptions); | | _In_ DWORD dwSigninOptions); |
| | |
| HRESULT WINAPI PeerCollabGetSigninOptions( | | HRESULT WINAPI PeerCollabGetSigninOptions( |
|
| __out DWORD * pdwSigninOptions); | | _Out_ DWORD * pdwSigninOptions); |
| | |
| #endif //MIDL_PASS | | #endif //MIDL_PASS |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // A P P I N V I T E | | // A P P I N V I T E |
| // | | // |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // constants | | // constants |
| | |
| skipping to change at line 1158 | | skipping to change at line 1162 |
|---|
| DWORD dwPublicationScope; | | DWORD dwPublicationScope; |
| } PEER_APPLICATION_REGISTRATION_INFO, *PPEER_APPLICATION_REGISTRATION_INFO; | | } PEER_APPLICATION_REGISTRATION_INFO, *PPEER_APPLICATION_REGISTRATION_INFO; |
| typedef const PEER_APPLICATION_REGISTRATION_INFO * PCPEER_APPLICATION_REGISTRATI
ON_INFO; | | typedef const PEER_APPLICATION_REGISTRATION_INFO * PCPEER_APPLICATION_REGISTRATI
ON_INFO; |
| | |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // API's | | // API's |
| | |
| // AppInvite sender side API's | | // AppInvite sender side API's |
| HRESULT WINAPI PeerCollabAsyncInviteContact( | | HRESULT WINAPI PeerCollabAsyncInviteContact( |
|
| __in_opt PCPEER_CONTACT pcContact, | | _In_opt_ PCPEER_CONTACT pcContact, |
| __in PCPEER_ENDPOINT pcEndpoint, | | _In_ PCPEER_ENDPOINT pcEndpoint, |
| __in PCPEER_INVITATION pcInvitation, | | _In_ PCPEER_INVITATION pcInvitation, |
| __in_opt HANDLE hEvent, | | _In_opt_ HANDLE hEvent, |
| __out_opt HANDLE * phInvitation); | | _Out_opt_ HANDLE * phInvitation); |
| | |
| HRESULT WINAPI PeerCollabGetInvitationResponse( | | HRESULT WINAPI PeerCollabGetInvitationResponse( |
|
| __in HANDLE hInvitation, | | _In_ HANDLE hInvitation, |
| __deref_out PPEER_INVITATION_RESPONSE * ppInvitationRespon | | _Outptr_ PPEER_INVITATION_RESPONSE * ppInvitationResponse) |
| se); | | ; |
| | |
| HRESULT WINAPI PeerCollabCancelInvitation( | | HRESULT WINAPI PeerCollabCancelInvitation( |
|
| __in HANDLE hInvitation); | | _In_ HANDLE hInvitation); |
| | |
| HRESULT WINAPI PeerCollabCloseHandle( | | HRESULT WINAPI PeerCollabCloseHandle( |
|
| __in HANDLE hInvitation); | | _In_ HANDLE hInvitation); |
| | |
| HRESULT WINAPI PeerCollabInviteContact( | | HRESULT WINAPI PeerCollabInviteContact( |
|
| __in_opt PCPEER_CONTACT pcContact, | | _In_opt_ PCPEER_CONTACT pcContact, |
| __in PCPEER_ENDPOINT pcEndpoint, | | _In_ PCPEER_ENDPOINT pcEndpoint, |
| __in PCPEER_INVITATION pcInvitation, | | _In_ PCPEER_INVITATION pcInvitation, |
| __deref_out PPEER_INVITATION_RESPONSE * ppResponse); | | _Outptr_ PPEER_INVITATION_RESPONSE * ppResponse); |
| | |
| HRESULT WINAPI PeerCollabAsyncInviteEndpoint( | | HRESULT WINAPI PeerCollabAsyncInviteEndpoint( |
|
| __in PCPEER_ENDPOINT pcEndpoint, | | _In_ PCPEER_ENDPOINT pcEndpoint, |
| __in PCPEER_INVITATION pcInvitation, | | _In_ PCPEER_INVITATION pcInvitation, |
| __in_opt HANDLE hEvent, | | _In_opt_ HANDLE hEvent, |
| __out_opt HANDLE * phInvitation); | | _Out_opt_ HANDLE * phInvitation); |
| | |
| HRESULT WINAPI PeerCollabInviteEndpoint( | | HRESULT WINAPI PeerCollabInviteEndpoint( |
|
| __in PCPEER_ENDPOINT pcEndpoint, | | _In_ PCPEER_ENDPOINT pcEndpoint, |
| __in PCPEER_INVITATION pcInvitation, | | _In_ PCPEER_INVITATION pcInvitation, |
| __deref_out PPEER_INVITATION_RESPONSE * ppResponse); | | _Outptr_ PPEER_INVITATION_RESPONSE * ppResponse); |
| | |
| // AppInvite receiver side API's | | // AppInvite receiver side API's |
| HRESULT WINAPI PeerCollabGetAppLaunchInfo( | | HRESULT WINAPI PeerCollabGetAppLaunchInfo( |
|
| __deref_out PPEER_APP_LAUNCH_INFO * ppLaunchInfo); | | _Outptr_ PPEER_APP_LAUNCH_INFO * ppLaunchInfo); |
| | |
| // Applications registration API's | | // Applications registration API's |
| HRESULT WINAPI PeerCollabRegisterApplication( | | HRESULT WINAPI PeerCollabRegisterApplication( |
|
| __in PCPEER_APPLICATION_REGISTRATION_INFO pcApplication, | | _In_ PCPEER_APPLICATION_REGISTRATION_INFO pcApplication, |
| __in PEER_APPLICATION_REGISTRATION_TYPE registrationType | | _In_ PEER_APPLICATION_REGISTRATION_TYPE registrationType |
| ); | | ); |
| | |
| HRESULT WINAPI PeerCollabUnregisterApplication( | | HRESULT WINAPI PeerCollabUnregisterApplication( |
|
| __in const GUID * pApplicationId | | _In_ const GUID * pApplicationId |
| , | | , |
| __in PEER_APPLICATION_REGISTRATION_TYPE registrationType | | _In_ PEER_APPLICATION_REGISTRATION_TYPE registrationType |
| ); | | ); |
| | |
| HRESULT WINAPI PeerCollabGetApplicationRegistrationInfo( | | HRESULT WINAPI PeerCollabGetApplicationRegistrationInfo( |
|
| __in const GUID * pAppli | | _In_ const GUID * pAppli |
| cationId, | | cationId, |
| __in PEER_APPLICATION_REGISTRATION_TYPE registra | | _In_ PEER_APPLICATION_REGISTRATION_TYPE registra |
| tionType, | | tionType, |
| __deref_out PPEER_APPLICATION_REGISTRATION_INFO * ppAppl | | _Outptr_ PPEER_APPLICATION_REGISTRATION_INFO * ppApplica |
| ication); | | tion); |
| | |
| HRESULT WINAPI PeerCollabEnumApplicationRegistrationInfo( | | HRESULT WINAPI PeerCollabEnumApplicationRegistrationInfo( |
|
| __in PEER_APPLICATION_REGISTRATION_TYPE registrationTy | | _In_ PEER_APPLICATION_REGISTRATION_TYPE registrationTy |
| pe, | | pe, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| #endif // MIDL_PASS | | #endif // MIDL_PASS |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // S E R V E R L E S S P R E S E N C E | | // S E R V E R L E S S P R E S E N C E |
| // | | // |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // constants | | // constants |
| | |
| skipping to change at line 1249 | | skipping to change at line 1253 |
|---|
| PWSTR pwzDescriptiveText; | | PWSTR pwzDescriptiveText; |
| } PEER_PRESENCE_INFO, *PPEER_PRESENCE_INFO; | | } PEER_PRESENCE_INFO, *PPEER_PRESENCE_INFO; |
| typedef const PEER_PRESENCE_INFO * PCPEER_PRESENCE_INFO; | | typedef const PEER_PRESENCE_INFO * PCPEER_PRESENCE_INFO; |
| | |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| ////////////////////////////////////////////////////////////////////////////// | | ////////////////////////////////////////////////////////////////////////////// |
| // API's | | // API's |
| | |
| // Subscriber | | // Subscriber |
| HRESULT WINAPI PeerCollabGetPresenceInfo( | | HRESULT WINAPI PeerCollabGetPresenceInfo( |
|
| __in_opt PCPEER_ENDPOINT pcEndpoint, | | _In_opt_ PCPEER_ENDPOINT pcEndpoint, |
| __deref_out PPEER_PRESENCE_INFO *ppPresenceInfo); | | _Outptr_ PPEER_PRESENCE_INFO *ppPresenceInfo); |
| | |
| HRESULT WINAPI PeerCollabEnumApplications( | | HRESULT WINAPI PeerCollabEnumApplications( |
|
| __in_opt PCPEER_ENDPOINT pcEndpoint, | | _In_opt_ PCPEER_ENDPOINT pcEndpoint, |
| __in_opt const GUID * pApplicationId, | | _In_opt_ const GUID * pApplicationId, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerCollabEnumObjects( | | HRESULT WINAPI PeerCollabEnumObjects( |
|
| __in_opt PCPEER_ENDPOINT pcEndpoint, | | _In_opt_ PCPEER_ENDPOINT pcEndpoint, |
| __in_opt const GUID * pObjectId, | | _In_opt_ const GUID * pObjectId, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerCollabEnumEndpoints( | | HRESULT WINAPI PeerCollabEnumEndpoints( |
|
| __in_opt PCPEER_CONTACT pcContact, | | _In_opt_ PCPEER_CONTACT pcContact, |
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerCollabRefreshEndpointData( | | HRESULT WINAPI PeerCollabRefreshEndpointData( |
|
| __in PCPEER_ENDPOINT pcEndpoint); | | _In_ PCPEER_ENDPOINT pcEndpoint); |
| | |
| HRESULT WINAPI PeerCollabDeleteEndpointData( | | HRESULT WINAPI PeerCollabDeleteEndpointData( |
|
| __in PCPEER_ENDPOINT pcEndpoint); | | _In_ PCPEER_ENDPOINT pcEndpoint); |
| | |
| HRESULT WINAPI PeerCollabQueryContactData( | | HRESULT WINAPI PeerCollabQueryContactData( |
|
| __in_opt PCPEER_ENDPOINT pcEndpoint, | | _In_opt_ PCPEER_ENDPOINT pcEndpoint, |
| __deref_out PWSTR * ppwzContactData); | | _Outptr_ PWSTR * ppwzContactData); |
| | |
| HRESULT WINAPI PeerCollabSubscribeEndpointData( | | HRESULT WINAPI PeerCollabSubscribeEndpointData( |
|
| __in const PCPEER_ENDPOINT pcEndpoint); | | _In_ const PCPEER_ENDPOINT pcEndpoint); |
| | |
| HRESULT WINAPI PeerCollabUnsubscribeEndpointData( | | HRESULT WINAPI PeerCollabUnsubscribeEndpointData( |
|
| __in const PCPEER_ENDPOINT pcEndpoint); | | _In_ const PCPEER_ENDPOINT pcEndpoint); |
| | |
| // Publisher | | // Publisher |
| | |
| HRESULT WINAPI PeerCollabSetPresenceInfo( | | HRESULT WINAPI PeerCollabSetPresenceInfo( |
|
| __in PCPEER_PRESENCE_INFO pcPresenceInfo); | | _In_ PCPEER_PRESENCE_INFO pcPresenceInfo); |
| | |
| HRESULT WINAPI PeerCollabGetEndpointName( | | HRESULT WINAPI PeerCollabGetEndpointName( |
|
| __deref_out PWSTR * ppwzEndpointName); | | _Outptr_ PWSTR * ppwzEndpointName); |
| | |
| HRESULT WINAPI PeerCollabSetEndpointName( | | HRESULT WINAPI PeerCollabSetEndpointName( |
|
| __in PCWSTR pwzEndpointName); | | _In_ PCWSTR pwzEndpointName); |
| | |
| HRESULT WINAPI PeerCollabSetObject( | | HRESULT WINAPI PeerCollabSetObject( |
|
| __in PCPEER_OBJECT pcObject); | | _In_ PCPEER_OBJECT pcObject); |
| | |
| HRESULT WINAPI PeerCollabDeleteObject( | | HRESULT WINAPI PeerCollabDeleteObject( |
|
| __in const GUID * pObjectId); | | _In_ const GUID * pObjectId); |
| | |
| #endif | | #endif |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // R E G I S T R A T I O N | | // R E G I S T R A T I O N |
| // | | // |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
| skipping to change at line 1432 | | skipping to change at line 1436 |
|---|
| PEER_EVENT_REQUEST_STATUS_CHANGED_DATA requestStatusCha
ngedData; | | PEER_EVENT_REQUEST_STATUS_CHANGED_DATA requestStatusCha
ngedData; |
| }; | | }; |
| } PEER_COLLAB_EVENT_DATA, *PPEER_COLLAB_EVENT_DATA; | | } PEER_COLLAB_EVENT_DATA, *PPEER_COLLAB_EVENT_DATA; |
| #endif | | #endif |
| | |
| #ifndef MIDL_PASS | | #ifndef MIDL_PASS |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // API's | | // API's |
| | |
| HRESULT WINAPI PeerCollabRegisterEvent( | | HRESULT WINAPI PeerCollabRegisterEvent( |
|
| __in HANDLE hEvent, | | _In_ HANDLE hEvent, |
| __in DWORD cEventRegistration, | | _In_ DWORD cEventRegistration, |
| __in_ecount(cEventRegistration) PEER_COLLAB_EVENT_REGISTRATION * | | _In_reads_(cEventRegistration) PEER_COLLAB_EVENT_REGISTRATION * |
| pEventRegistrations, | | pEventRegistrations, |
| __out HPEEREVENT *phPeerEvent); | | _Out_ HPEEREVENT *phPeerEvent); |
| | |
| HRESULT WINAPI PeerCollabGetEventData( | | HRESULT WINAPI PeerCollabGetEventData( |
|
| __in HPEEREVENT hPeerEvent, | | _In_ HPEEREVENT hPeerEvent, |
| __deref_out PPEER_COLLAB_EVENT_DATA * ppEventData); | | _Outptr_ PPEER_COLLAB_EVENT_DATA * ppEventData); |
| | |
| HRESULT WINAPI PeerCollabUnregisterEvent( | | HRESULT WINAPI PeerCollabUnregisterEvent( |
|
| __in HPEEREVENT hPeerEvent); | | _In_ HPEEREVENT hPeerEvent); |
| | |
| ////////////////////////////////////////////////////////////////////////////// | | ////////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // P N M | | // P N M |
| // | | // |
| ////////////////////////////////////////////////////////////////////////////// | | ////////////////////////////////////////////////////////////////////////////// |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // API's | | // API's |
| | |
| HRESULT WINAPI PeerCollabEnumPeopleNearMe( | | HRESULT WINAPI PeerCollabEnumPeopleNearMe( |
|
| __out HPEERENUM *phPeerEnum); | | _Out_ HPEERENUM *phPeerEnum); |
| | |
| ////////////////////////////////////////////////////////////////////////////// | | ////////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // C O N T A C T | | // C O N T A C T |
| // | | // |
| ////////////////////////////////////////////////////////////////////////////// | | ////////////////////////////////////////////////////////////////////////////// |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // API's | | // API's |
| | |
| HRESULT WINAPI PeerCollabAddContact( | | HRESULT WINAPI PeerCollabAddContact( |
|
| __in PCWSTR pwzContactData, | | _In_ PCWSTR pwzContactData, |
| __deref_opt_out PPEER_CONTACT * ppContact); | | _Outptr_opt_ PPEER_CONTACT * ppContact); |
| | |
| HRESULT WINAPI PeerCollabDeleteContact( | | HRESULT WINAPI PeerCollabDeleteContact( |
|
| __in PCWSTR pwzPeerName); | | _In_ PCWSTR pwzPeerName); |
| | |
| HRESULT WINAPI PeerCollabGetContact( | | HRESULT WINAPI PeerCollabGetContact( |
|
| __in_opt PCWSTR pwzPeerName, | | _In_opt_ PCWSTR pwzPeerName, |
| __deref_out PPEER_CONTACT * ppContact); | | _Outptr_ PPEER_CONTACT * ppContact); |
| | |
| HRESULT WINAPI PeerCollabUpdateContact( | | HRESULT WINAPI PeerCollabUpdateContact( |
|
| __in PCPEER_CONTACT pContact); | | _In_ PCPEER_CONTACT pContact); |
| | |
| HRESULT WINAPI PeerCollabEnumContacts( | | HRESULT WINAPI PeerCollabEnumContacts( |
|
| __out HPEERENUM * phPeerEnum); | | _Out_ HPEERENUM * phPeerEnum); |
| | |
| HRESULT WINAPI PeerCollabExportContact( | | HRESULT WINAPI PeerCollabExportContact( |
|
| __in_opt PCWSTR pwzPeerName, | | _In_opt_ PCWSTR pwzPeerName, |
| __deref_out PWSTR * ppwzContactData); | | _Outptr_ PWSTR * ppwzContactData); |
| | |
| HRESULT WINAPI PeerCollabParseContact( | | HRESULT WINAPI PeerCollabParseContact( |
|
| __in PCWSTR pwzContactData, | | _In_ PCWSTR pwzContactData, |
| __deref_out PPEER_CONTACT * ppContact); | | _Outptr_ PPEER_CONTACT * ppContact); |
| | |
| #endif // MIDL_PASS | | #endif // MIDL_PASS |
| #endif // NO_P2P_COLLABORATION | | #endif // NO_P2P_COLLABORATION |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // PNRP APIs | | // PNRP APIs |
| // | | // |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
| | |
| skipping to change at line 1516 | | skipping to change at line 1520 |
|---|
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // Structures | | // Structures |
| | |
| typedef PVOID HRESOLUTION, HREGISTRATION; | | typedef PVOID HRESOLUTION, HREGISTRATION; |
| | |
| typedef struct peer_pnrp_endpoint_info_tag | | typedef struct peer_pnrp_endpoint_info_tag |
| { | | { |
| PWSTR pwzPeerName; | | PWSTR pwzPeerName; |
| ULONG cAddresses; | | ULONG cAddresses; |
|
| __field_ecount(cAddresses) SOCKADDR **ppAddresses; | | _Field_size_(cAddresses) SOCKADDR **ppAddresses; |
| PWSTR pwzComment; | | PWSTR pwzComment; |
| PEER_DATA payload; | | PEER_DATA payload; |
| } PEER_PNRP_ENDPOINT_INFO, *PPEER_PNRP_ENDPOINT_INFO; | | } PEER_PNRP_ENDPOINT_INFO, *PPEER_PNRP_ENDPOINT_INFO; |
| | |
| typedef struct peer_pnrp_cloud_info_tag | | typedef struct peer_pnrp_cloud_info_tag |
| { | | { |
| PWSTR pwzCloudName; | | PWSTR pwzCloudName; |
| PNRP_SCOPE dwScope; | | PNRP_SCOPE dwScope; |
| DWORD dwScopeId; | | DWORD dwScopeId; |
| } PEER_PNRP_CLOUD_INFO, *PPEER_PNRP_CLOUD_INFO; | | } PEER_PNRP_CLOUD_INFO, *PPEER_PNRP_CLOUD_INFO; |
| | |
| typedef struct peer_pnrp_registration_info_tag { | | typedef struct peer_pnrp_registration_info_tag { |
| PWSTR pwzCloudName; | | PWSTR pwzCloudName; |
| PWSTR pwzPublishingIdentity; | | PWSTR pwzPublishingIdentity; |
| ULONG cAddresses; | | ULONG cAddresses; |
|
| __field_ecount(cAddresses) SOCKADDR **ppAddresses; | | _Field_size_(cAddresses) SOCKADDR **ppAddresses; |
| WORD wPort; | | WORD wPort; |
| PWSTR pwzComment; | | PWSTR pwzComment; |
| PEER_DATA payload; | | PEER_DATA payload; |
| } PEER_PNRP_REGISTRATION_INFO, *PPEER_PNRP_REGISTRATION_INFO; | | } PEER_PNRP_REGISTRATION_INFO, *PPEER_PNRP_REGISTRATION_INFO; |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // API's | | // API's |
| | |
| HRESULT WINAPI PeerNameToPeerHostName( | | HRESULT WINAPI PeerNameToPeerHostName( |
|
| __in PCWSTR pwzPeerName, | | _In_ PCWSTR pwzPeerName, |
| __deref_out PWSTR *ppwzHostName); | | _Outptr_ PWSTR *ppwzHostName); |
| | |
| HRESULT WINAPI PeerHostNameToPeerName( | | HRESULT WINAPI PeerHostNameToPeerName( |
|
| __in PCWSTR pwzHostName, | | _In_ PCWSTR pwzHostName, |
| __deref_out PWSTR *ppwzPeerName); | | _Outptr_ PWSTR *ppwzPeerName); |
| | |
| HRESULT WINAPI PeerPnrpStartup( | | HRESULT WINAPI PeerPnrpStartup( |
|
| __in WORD wVersionRequested); | | _In_ WORD wVersionRequested); |
| | |
| HRESULT WINAPI PeerPnrpShutdown(); | | HRESULT WINAPI PeerPnrpShutdown(); |
| | |
| HRESULT WINAPI PeerPnrpRegister( | | HRESULT WINAPI PeerPnrpRegister( |
|
| __in PCWSTR pcwzPeerName, | | _In_ PCWSTR pcwzPeerName, |
| __in_opt PPEER_PNRP_REGISTRATION_INFO pRegistrationInfo, | | _In_opt_ PPEER_PNRP_REGISTRATION_INFO pRegistrationInfo, |
| __out HREGISTRATION *phRegistration); | | _Out_ HREGISTRATION *phRegistration); |
| | |
| HRESULT WINAPI PeerPnrpUpdateRegistration( | | HRESULT WINAPI PeerPnrpUpdateRegistration( |
|
| __in HREGISTRATION hRegistration, | | _In_ HREGISTRATION hRegistration, |
| __in PPEER_PNRP_REGISTRATION_INFO pRegistrationInfo); | | _In_ PPEER_PNRP_REGISTRATION_INFO pRegistrationInfo); |
| | |
| HRESULT WINAPI PeerPnrpUnregister( | | HRESULT WINAPI PeerPnrpUnregister( |
|
| __in HREGISTRATION hRegistration); | | _In_ HREGISTRATION hRegistration); |
| | |
| HRESULT WINAPI PeerPnrpResolve( | | HRESULT WINAPI PeerPnrpResolve( |
|
| __in PCWSTR pcwzPeerName, | | _In_ PCWSTR pcwzPeerName, |
| __in_opt PCWSTR pcwzCloudName, | | _In_opt_ PCWSTR pcwzCloudName, |
| __inout ULONG *pcEndpoints, | | _Inout_ ULONG *pcEndpoints, |
| __deref_out_ecount(*pcEndpoints) PPEER_PNRP_ENDPOINT_INFO *pp | | _Outptr_result_buffer_(*pcEndpoints) PPEER_PNRP_ENDPOINT_INFO |
| Endpoints); | | *ppEndpoints); |
| | |
| HRESULT WINAPI PeerPnrpStartResolve( | | HRESULT WINAPI PeerPnrpStartResolve( |
|
| __in PCWSTR pcwzPeerName, | | _In_ PCWSTR pcwzPeerName, |
| __in_opt PCWSTR pcwzCloudName, | | _In_opt_ PCWSTR pcwzCloudName, |
| __in_opt ULONG cMaxEndpoints, | | _In_opt_ ULONG cMaxEndpoints, |
| __in HANDLE hEvent, | | _In_ HANDLE hEvent, |
| __out HRESOLUTION *phResolve); | | _Out_ HRESOLUTION *phResolve); |
| | |
| HRESULT WINAPI PeerPnrpGetCloudInfo( | | HRESULT WINAPI PeerPnrpGetCloudInfo( |
|
| __out ULONG *pcN | | _Out_ ULONG *pcN |
| umClouds, | | umClouds, |
| __deref_out_ecount(*pcNumClouds) PPEER_PNRP_CLOUD_INFO *ppC | | _Outptr_result_buffer_(*pcNumClouds) PPEER_PNRP_CLOUD_INFO |
| loudInfo); | | *ppCloudInfo); |
| | |
| HRESULT WINAPI PeerPnrpGetEndpoint( | | HRESULT WINAPI PeerPnrpGetEndpoint( |
|
| __in HRESOLUTION hResolve, | | _In_ HRESOLUTION hResolve, |
| __deref_out PPEER_PNRP_ENDPOINT_INFO *ppEndpoint); | | _Outptr_ PPEER_PNRP_ENDPOINT_INFO *ppEndpoint); |
| | |
| HRESULT WINAPI PeerPnrpEndResolve( | | HRESULT WINAPI PeerPnrpEndResolve( |
|
| __in HRESOLUTION hResolve); | | _In_ HRESOLUTION hResolve); |
| | |
| #endif // NO_P2P_PNRP | | #endif // NO_P2P_PNRP |
| #endif // MIDL_PASS | | #endif // MIDL_PASS |
| | |
| #ifdef __cplusplus | | #ifdef __cplusplus |
| } | | } |
| #endif /* __cplusplus */ | | #endif /* __cplusplus */ |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // Error codes | | // Error codes |
| // | | // |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| | |
|
| #ifndef FACILITY_P2P | | // |
| #define FACILITY_P2P 99 | | // all the error codes with a facility of FACILITY_P2P have been moved to winer |
| #endif | | ror.h |
| | // |
| #define PEER_E_IPV6_NOT_INSTALLED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | // it is build from %SDXROOT%\minkernel\publish\base\winerror.mc |
| TY_P2P, 0x0001) | | |
| #define PEER_E_NOT_INITIALIZED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0002) | | |
| #define PEER_E_CANNOT_START_SERVICE MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0003) | | |
| #define PEER_E_NOT_LICENSED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0004) | | |
| #define PEER_E_INVALID_GRAPH MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0010) | | |
| #define PEER_E_DBNAME_CHANGED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0011) | | |
| #define PEER_E_DUPLICATE_GRAPH MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0012) | | |
| #define PEER_E_GRAPH_NOT_READY MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0013) | | |
| #define PEER_E_GRAPH_SHUTTING_DOWN MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0014) | | |
| #define PEER_E_GRAPH_IN_USE MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0015) | | |
| #define PEER_E_INVALID_DATABASE MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0016) | | |
| #define PEER_E_TOO_MANY_ATTRIBUTES MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0017) | | |
| | |
| #define PEER_E_CONNECTION_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0103) | | |
| #define PEER_E_CONNECT_SELF MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0106) | | |
| #define PEER_E_ALREADY_LISTENING MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0107) | | |
| #define PEER_E_NODE_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0108) | | |
| #define PEER_E_CONNECTION_FAILED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0109) | | |
| #define PEER_E_CONNECTION_NOT_AUTHENTICATED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x010A) | | |
| #define PEER_E_CONNECTION_REFUSED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x010B) | | |
| | |
| #define PEER_E_CLASSIFIER_TOO_LONG MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0201) | | |
| #define PEER_E_TOO_MANY_IDENTITIES MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0202) | | |
| #define PEER_E_NO_KEY_ACCESS MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0203) | | |
| #define PEER_E_GROUPS_EXIST MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0204) | | |
| | | |
| // record error codes | | |
| #define PEER_E_RECORD_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0301) | | |
| #define PEER_E_DATABASE_ACCESSDENIED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0302) | | |
| #define PEER_E_DBINITIALIZATION_FAILED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0303) | | |
| #define PEER_E_MAX_RECORD_SIZE_EXCEEDED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0304) | | |
| #define PEER_E_DATABASE_ALREADY_PRESENT MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0305) | | |
| #define PEER_E_DATABASE_NOT_PRESENT MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0306) | | |
| | |
| #define PEER_E_IDENTITY_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0401) | | |
| | | |
| // eventing error | | |
| #define PEER_E_EVENT_HANDLE_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0501) | | |
| | |
| // searching error | | |
| #define PEER_E_INVALID_SEARCH MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0601) | | |
| #define PEER_E_INVALID_ATTRIBUTES MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0602) | | |
| | |
| // certificate verification error codes | | |
| #define PEER_E_INVITATION_NOT_TRUSTED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0701) | | |
| #define PEER_E_CHAIN_TOO_LONG MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0703) | | |
| #define PEER_E_INVALID_TIME_PERIOD MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0705) | | |
| #define PEER_E_CIRCULAR_CHAIN_DETECTED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0706) | | |
| | |
| #define PEER_E_CERT_STORE_CORRUPTED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x0801) | | |
| | |
| #define PEER_E_NO_CLOUD MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x1001) | | |
| #define PEER_E_CLOUD_NAME_AMBIGUOUS MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x1005) | | |
| | |
| #define PEER_E_INVALID_RECORD MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2010) | | |
| #define PEER_E_NOT_AUTHORIZED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2020) | | |
| #define PEER_E_PASSWORD_DOES_NOT_MEET_POLICY MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2021) | | |
| #define PEER_E_DEFERRED_VALIDATION MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2030) | | |
| #define PEER_E_INVALID_GROUP_PROPERTIES MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2040) | | |
| #define PEER_E_INVALID_PEER_NAME MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2050) | | |
| #define PEER_E_INVALID_CLASSIFIER MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2060) | | |
| #define PEER_E_INVALID_FRIENDLY_NAME MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2070) | | |
| #define PEER_E_INVALID_ROLE_PROPERTY MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2071) | | |
| #define PEER_E_INVALID_CLASSIFIER_PROPERTY MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2072) | | |
| #define PEER_E_INVALID_RECORD_EXPIRATION MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2080) | | |
| #define PEER_E_INVALID_CREDENTIAL_INFO MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2081) | | |
| #define PEER_E_INVALID_CREDENTIAL MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2082) | | |
| #define PEER_E_INVALID_RECORD_SIZE MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2083) | | |
| #define PEER_E_UNSUPPORTED_VERSION MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2090) | | |
| #define PEER_E_GROUP_NOT_READY MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2091) | | |
| #define PEER_E_GROUP_IN_USE MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2092) | | |
| #define PEER_E_INVALID_GROUP MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2093) | | |
| #define PEER_E_NO_MEMBERS_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2094) | | |
| #define PEER_E_NO_MEMBER_CONNECTIONS MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2095) | | |
| #define PEER_E_UNABLE_TO_LISTEN MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x2096) | | |
| #define PEER_E_IDENTITY_DELETED MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x20A0) | | |
| #define PEER_E_SERVICE_NOT_AVAILABLE MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x20A1) | | |
| | |
| // Contacts APIs error code | | |
| #define PEER_E_CONTACT_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x6001) | | |
| | |
| // Special success codes | | |
| #define PEER_S_GRAPH_DATA_CREATED MAKE_HRESULT(SEVERITY_SUCCESS, FACI | | |
| LITY_P2P, 0x0001) | | |
| #define PEER_S_NO_EVENT_DATA MAKE_HRESULT(SEVERITY_SUCCESS, FACI | | |
| LITY_P2P, 0x0002) | | |
| #define PEER_S_ALREADY_CONNECTED MAKE_HRESULT(SEVERITY_SUCCESS, FACI | | |
| LITY_P2P, 0x2000) | | |
| #define PEER_S_SUBSCRIPTION_EXISTS MAKE_HRESULT(SEVERITY_SUCCESS, FACI | | |
| LITY_P2P, 0x6000) | | |
| #define PEER_S_NO_CONNECTIVITY MAKE_HRESULT(SEVERITY_SUCCESS, FACI | | |
| LITY_P2P, 0x0005) | | |
| #define PEER_S_ALREADY_A_MEMBER MAKE_HRESULT(SEVERITY_SUCCESS, FACI | | |
| LITY_P2P, 0x0006) | | |
| | |
| // Pnrp helpers errors | | |
| #define PEER_E_CANNOT_CONVERT_PEER_NAME MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x4001) | | |
| #define PEER_E_INVALID_PEER_HOST_NAME MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x4002) | | |
| #define PEER_E_NO_MORE MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x4003) | | |
| #define PEER_E_PNRP_DUPLICATE_PEER_NAME MAKE_HRESULT(SEVERITY_ERROR, FACILI | | |
| TY_P2P, 0x4005) | | |
| | | |
| // AppInvite APIs error code | | |
| #define PEER_E_INVITE_CANCELLED MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0x7000) | | |
| #define PEER_E_INVITE_RESPONSE_NOT_AVAILABLE MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0x7001) | | |
| | | |
| // Serverless presence error codes | | |
| #define PEER_E_NOT_SIGNED_IN MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0x7003) | | |
| #define PEER_E_PRIVACY_DECLINED MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0x7004) | | |
| #define PEER_E_TIMEOUT MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0x7005) | | |
| #define PEER_E_INVALID_ADDRESS MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0X7007) | | |
| #define PEER_E_FW_EXCEPTION_DISABLED MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0X7008) | | |
| #define PEER_E_FW_BLOCKED_BY_POLICY MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0X7009) | | |
| #define PEER_E_FW_BLOCKED_BY_SHIELDS_UP MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0X700A) | | |
| #define PEER_E_FW_DECLINED MAKE_HRESULT(SEVERITY_ERROR, FAC | | |
| ILITY_P2P, 0x700B) | | |
| | |
| // | | // |
| // WSA_PNRP_* error codes returned by the NSP | | // WSA_PNRP_* error codes returned by the NSP |
| // | | // |
| | |
| // These errors are only used by PNRP NSP and applications using the NSP. | | // These errors are only used by PNRP NSP and applications using the NSP. |
| // Any usage from other system/apps not related to PNRP (for example PNRP based
getaddrinfo | | // Any usage from other system/apps not related to PNRP (for example PNRP based
getaddrinfo |
| // implementations) would require these errors be moved to winerror.h | | // implementations) would require these errors be moved to winerror.h |
| | |
| #define WSA_PNRP_ERROR_BASE 11500 | | #define WSA_PNRP_ERROR_BASE 11500 |
| | |
| skipping to change at line 1737 | | skipping to change at line 1633 |
|---|
| #define WSA_PNRP_INVALID_IDENTITY (WSA_PNRP_ERROR_BASE + 3) | | #define WSA_PNRP_INVALID_IDENTITY (WSA_PNRP_ERROR_BASE + 3) |
| #define WSA_PNRP_TOO_MUCH_LOAD (WSA_PNRP_ERROR_BASE + 4) | | #define WSA_PNRP_TOO_MUCH_LOAD (WSA_PNRP_ERROR_BASE + 4) |
| #define WSA_PNRP_CLOUD_IS_SEARCH_ONLY (WSA_PNRP_ERROR_BASE + 5) | | #define WSA_PNRP_CLOUD_IS_SEARCH_ONLY (WSA_PNRP_ERROR_BASE + 5) |
| #define WSA_PNRP_CLIENT_INVALID_COMPARTMENT_ID (WSA_PNRP_ERROR_BASE + 6) | | #define WSA_PNRP_CLIENT_INVALID_COMPARTMENT_ID (WSA_PNRP_ERROR_BASE + 6) |
| #define WSA_PNRP_DUPLICATE_PEER_NAME (WSA_PNRP_ERROR_BASE + 8) | | #define WSA_PNRP_DUPLICATE_PEER_NAME (WSA_PNRP_ERROR_BASE + 8) |
| #define WSA_PNRP_CLOUD_IS_DEAD (WSA_PNRP_ERROR_BASE + 9) | | #define WSA_PNRP_CLOUD_IS_DEAD (WSA_PNRP_ERROR_BASE + 9) |
| | |
| // | | // |
| // these are the HRESULTs corresponding to the WSA error codes above and ret
urned by Grouping and Simple API | | // these are the HRESULTs corresponding to the WSA error codes above and ret
urned by Grouping and Simple API |
| // | | // |
|
| #define PEER_E_CLOUD_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, | | #define PEER_E_CLOUD_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FAC |
| FACILITY_WIN32, WSA_PNRP_CLOUD_NOT_FOUND) | | ILITY_WIN32, WSA_PNRP_CLOUD_NOT_FOUND) |
| #define PEER_E_CLOUD_DISABLED MAKE_HRESULT(SEVERITY_ERROR, F | | #define PEER_E_CLOUD_DISABLED MAKE_HRESULT(SEVERITY_ERROR, FAC |
| ACILITY_WIN32, WSA_PNRP_CLOUD_DISABLED) | | ILITY_WIN32, WSA_PNRP_CLOUD_DISABLED) |
| #define PEER_E_INVALID_IDENTITY MAKE_HRESULT(SEVERITY_ERROR, | | #define PEER_E_INVALID_IDENTITY MAKE_HRESULT(SEVERITY_ERROR, FAC |
| FACILITY_WIN32, WSA_PNRP_INVALID_IDENTITY) | | ILITY_WIN32, WSA_PNRP_INVALID_IDENTITY) |
| #define PEER_E_TOO_MUCH_LOAD MAKE_HRESULT(SEVERITY_ERROR, F | | #define PEER_E_TOO_MUCH_LOAD MAKE_HRESULT(SEVERITY_ERROR, FAC |
| ACILITY_WIN32, WSA_PNRP_TOO_MUCH_LOAD) | | ILITY_WIN32, WSA_PNRP_TOO_MUCH_LOAD) |
| #define PEER_E_CLOUD_IS_SEARCH_ONLY MAKE_HRESULT(SEVERITY_ | | #define PEER_E_CLOUD_IS_SEARCH_ONLY MAKE_HRESULT(SEVERITY_ERROR, FAC |
| ERROR, FACILITY_WIN32, WSA_PNRP_CLOUD_IS_SEARCH_ONLY) | | ILITY_WIN32, WSA_PNRP_CLOUD_IS_SEARCH_ONLY) |
| #define PEER_E_CLIENT_INVALID_COMPARTMENT_ID MAKE_HRESULT(S | | #define PEER_E_CLIENT_INVALID_COMPARTMENT_ID MAKE_HRESULT(SEVERITY_ERROR, FAC |
| EVERITY_ERROR, FACILITY_WIN32, WSA_PNRP_CLIENT_INVALID_COMPARTMENT_ID) | | ILITY_WIN32, WSA_PNRP_CLIENT_INVALID_COMPARTMENT_ID) |
| #define PEER_E_DUPLICATE_PEER_NAME MAKE_HRESULT(SEVERITY_E | | #define PEER_E_DUPLICATE_PEER_NAME MAKE_HRESULT(SEVERITY_ERROR, FAC |
| RROR, FACILITY_WIN32, WSA_PNRP_DUPLICATE_PEER_NAME) | | ILITY_WIN32, WSA_PNRP_DUPLICATE_PEER_NAME) |
| #define PEER_E_CLOUD_IS_DEAD MAKE_HRESULT(SEVERITY_ERROR, | | #define PEER_E_CLOUD_IS_DEAD MAKE_HRESULT(SEVERITY_ERROR, FAC |
| FACILITY_WIN32, WSA_PNRP_CLOUD_IS_DEAD) | | ILITY_WIN32, WSA_PNRP_CLOUD_IS_DEAD) |
| | |
| // | | // |
| // these are the error codes that are not defined by winerror.h, so we define th
em as our own | | // these are the error codes that are not defined by winerror.h, so we define th
em as our own |
| // | | // |
|
| #define PEER_E_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FACILI | | #define PEER_E_NOT_FOUND MAKE_HRESULT(SEVERITY_ERROR, FAC |
| TY_WIN32, ERROR_NOT_FOUND) | | ILITY_WIN32, ERROR_NOT_FOUND) |
| #define PEER_E_DISK_FULL MAKE_HRESULT(SEVERITY_ERROR, FACILI | | #define PEER_E_DISK_FULL MAKE_HRESULT(SEVERITY_ERROR, FAC |
| TY_WIN32, ERROR_DISK_FULL) | | ILITY_WIN32, ERROR_DISK_FULL) |
| #define PEER_E_ALREADY_EXISTS MAKE_HRESULT(SEVERITY_ERROR, FACILI | | #define PEER_E_ALREADY_EXISTS MAKE_HRESULT(SEVERITY_ERROR, FAC |
| TY_WIN32, ERROR_ALREADY_EXISTS) | | ILITY_WIN32, ERROR_ALREADY_EXISTS) |
| | |
| #pragma warning(pop) | | #pragma warning(pop) |
| | |
|
| | #endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ |
| | #pragma endregion |
| | |
| #endif // _P2P_H_ | | #endif // _P2P_H_ |
| | |
| ///////////////////////////////////////////////////////////////////////////// | | ///////////////////////////////////////////////////////////////////////////// |
| // | | // |
| // These GUIDs are outside conditional includes so you can | | // These GUIDs are outside conditional includes so you can |
| // #include <p2p.h> in precompiled header | | // #include <p2p.h> in precompiled header |
| // then | | // then |
| // #include <initguid.h> in a single source file | | // #include <initguid.h> in a single source file |
| // #include <p2p.h> in that source file a second time to instantiate the GUI
Ds | | // #include <p2p.h> in that source file a second time to instantiate the GUI
Ds |
| | |
| | |
| End of changes. 155 change blocks. |
|---|
| 597 lines changed or deleted | | 413 lines changed or added |
|---|
|