using System; using System.Runtime.InteropServices; using System.Threading; namespace Vanara.PInvoke { /// Items from the PeerDist.dll public static partial class PeerDist { private const string Lib_PeerDist = "peerdist.dll"; /// public const uint PEERDIST_READ_TIMEOUT_DEFAULT = 0xfffffffe; /// public const uint PEERDIST_READ_TIMEOUT_LOCAL_CACHE_ONLY = 0; /// public const uint PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION = 2; /// public const uint PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 = 1; /// public const uint PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 = 2; /// The PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS enumeration defines the possible client information values. /// /// A value from this enumeration is passed to thePeerDistClientGetInformationByHandle function as the PeerDistClientInfoClass parameter. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/ne-peerdist-peerdist_client_info_by_handle_class typedef enum // _PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS { PeerDistClientBasicInfo, MaximumPeerDistClientInfoByHandlesClass } // PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS, *PPEERDIST_CLIENT_INFO_BY_HANDLE_CLASS; [PInvokeData("peerdist.h", MSDNShortId = "NE:peerdist._PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS")] public enum PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS { /// Indicates the information to retrieve is a PEERDIST_CLIENT_BASIC_INFO structure. PeerDistClientBasicInfo, /// /// The maximum value for the enumeration that is used for error checking. This value should not be sent to the /// PeerDistClientGetInformationByHandle function. /// MaximumPeerDistClientInfoByHandlesClass, } /// The PEERDIST_STATUS enumeration defines the possible status values of the Peer Distribution service. // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/ne-peerdist-peerdist_status typedef enum { PEERDIST_STATUS_DISABLED, // PEERDIST_STATUS_UNAVAILABLE, PEERDIST_STATUS_AVAILABLE } PEERDIST_STATUS; [PInvokeData("peerdist.h", MSDNShortId = "NE:peerdist.__unnamed_enum_0")] public enum PEERDIST_STATUS { /// The service is disabled by Group Policy or according to configuration parameters. PEERDIST_STATUS_DISABLED, /// The service is not ready to process the request. PEERDIST_STATUS_UNAVAILABLE, /// The Peer Distribution service is available and ready to process requests. PEERDIST_STATUS_AVAILABLE, } /// /// The PeerDistClientAddContentInformation function adds the content information associated with a content handle opened by PeerDistClientOpenContent. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A PEERDIST_CONTENT_HANDLE opened by PeerDistClientOpenContent. /// Number of bytes in the pBuffer array. /// /// Pointer to the buffer that contains the content information. This buffer must remain valid for the duration of the add /// operation. The caller must not use this buffer until the add operation is completed. /// /// /// Pointer to an OVERLAPPED structure. The Internal member of OVERLAPPED structure contains the completion status of the /// asynchronous operation. The Offset and OffsetHigh are reserved and must be 0. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// In order to retrieve content data from Peer Distribution service the client must add content information that it received from /// the content server by calling the PeerDistClientAddContentInformation function. When all content information data has /// been added, the PeerDistClientCompleteContentInformation function must be called. Once /// PeerDistClientCompleteContentInformation is complete, the client can call PeerDistClientStreamRead or /// PeerDistClientBlockRead to retrieve the data from the Peer Distribution system. /// /// /// When calling this function multiple times on a single content handle, the caller must wait for each operation to complete before /// the next call is made. /// /// /// An application is not limited to adding content information with a single PeerDistClientAddContentInformation API call, /// as it is possible to add portions of that content information as it is made available. When more content information is /// available, the application can again call PeerDistClientAddContentInformation. When the application is done adding the /// entire content information, it must then call PeerDistClientCompleteContentInformation. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientaddcontentinformation DWORD // PeerDistClientAddContentInformation( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD // cbNumberOfBytes, PBYTE pBuffer, LPOVERLAPPED lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientAddContentInformation")] public static unsafe extern Win32Error PeerDistClientAddContentInformation(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, uint cbNumberOfBytes, [In] IntPtr pBuffer, [In] NativeOverlapped* lpOverlapped); /// /// The PeerDistClientAddData function is used to supply content to the local cache. Typically this is done when data could /// not be found on the local network as indicated when either PeerDistClientBlockRead or PeerDistClientStreamRead complete with /// ERROR_TIMEOUT or PEERDIST_ERROR_MISSING_DATA. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A PEERDIST_CONTENT_HANDLE returned by PeerDistClientOpenContent. /// The number of bytes to be added to the local cache. /// /// Pointer to the buffer that contains the data to be added to the local cache. This buffer must remain valid for the duration of /// the add operation. The caller must not use this buffer until the add operation is completed. /// /// /// Pointer to an OVERLAPPED structure. The byte offset from the beginning of content, at which this data is being added, is /// specified by setting the Offset and OffsetHigh members of the OVERLAPPED structure. The OffsetHigh member /// MUST be set to the higher 32 bits of the byte offset and the Offset member MUST be set to the lower 32 bits of the byte offset. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hContent handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// The data that has been added with this function and passed verification is available to other peers or hosted cache for /// download. The Peer Distribution service stores this data in its local cache. /// /// /// If the API completes with PEERDIST_ERROR_OUT_OF_BOUNDS, this indicates that the offset specified in the overlapped /// structure is beyond the end of the content. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientadddata DWORD PeerDistClientAddData( // PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD cbNumberOfBytes, PBYTE pBuffer, LPOVERLAPPED // lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientAddData")] public static unsafe extern Win32Error PeerDistClientAddData(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, uint cbNumberOfBytes, [In] IntPtr pBuffer, [In] NativeOverlapped* lpOverlapped); /// The PeerDistClientBlockRead function reads content data blocks. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A content handle opened by PeerDistClientOpenContent function call. /// /// The maximum number of bytes to read. If the cbMaxNumberOfBytesToRead is equal to 0, it indicates that the /// PeerDistClientBlockRead function is querying the length of available consecutive content byes in the local cache at the /// current block read offset. The query will neither download content from the peers, nor return the count of bytes present in the /// peer cache. /// /// /// Pointer to the buffer that receives the data from the local cache. This buffer must remain valid for the duration of the read /// operation. The caller must not use this buffer until the read operation is completed. If the cbMaxNumberOfBytesToRead argument /// is equal to 0, the pBuffer parameter can be NULL /// /// /// Timeout value for the read, in milliseconds. There are two special values that may be specified: /// /// /// Value /// Meaning /// /// /// PEERDIST_READ_TIMEOUT_LOCAL_CACHE_ONLY /// Specifies that a read should not cause any additional network traffic by contacting peers or a Hosted Cache. /// /// /// PEERDIST_READ_TIMEOUT_DEFAULT /// Specifies the default timeout of 5 seconds. /// /// /// /// /// Pointer to an OVERLAPPED structure. The start offset for read is specified by setting the Offset and OffsetHigh /// members of the OVERLAPPED structure. The OffsetHigh member should be set to the higher 32 bits of the start offset and /// the Offset member should be set to the lower 32 bits of the start offset. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hContent handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// PeerDistClientBlockRead queues the read and immediately returns to the caller. As a result, multiple reads can be issued /// simultaneously. PeerDistClientBlockRead will complete a read as soon as any data is available and will not wait for the /// buffer to fill completely. /// /// /// If the PeerDistClientBlockRead function operation completes successfully, the Offset and OffsetHigh fields /// of the OVERLAPPED structure will be populated with the ULONGLONG offset at which the read started. The OffsetHigh member /// will be set to the higher 32 bits of the offset and the Offset member will be set to the lower 32 bits of the offset. /// GetOverlappedResult will populate lpNumberOfBytesTransferred with the number of bytes transferred. In the event the caller is /// using a completion port to process Peer Distribution API completions then the lpNumberOfBytes argument of /// GetQueuedCompletionStatus will be populated with the number of bytes transferred. /// /// /// If the cbMaxNumberOfBytesToRead argument is equal to 0, and the PeerDistClientBlockRead function completes successfully, /// the number of bytes transferred (obtained via either GetQueuedCompletionStatus or GetOverlappedResult) will contain the actual /// length of content available in the local cache. /// /// /// When this API completes with error values PEERDIST_ERROR_MISSING_DATA or ERROR_TIMEOUT, the Offset and /// OffsetHigh fields of the OVERLAPPED structure specify the ULONGLONG offset at which the missing data range begins. /// The OffsetHigh member will be set to the higher 32 bits of the offset and the Offset member will be set to the lower 32 bits of /// the offset. This missing data range is the start offset (relative to start of the content) and length, in bytes, which needs to /// be retrieved from an alternate source, like the original content server. In order to allow the Peer Distribution service to /// satisfy the same read in the future, add this data to the local cache by calling PeerDistClientAddData. The length of the /// missing data range is specified by the number of bytes transferred (obtained via GetQueuedCompletionStatus or GetOverlappedResult). /// /// /// It is important to note that the missing data range can start at any offset in the content and be any length up to the end of /// the content. In the event the content information passed to PeerDistClientAddContentInformation was generated in response to a /// range request, then the missing data range will be constrained to the range request bounds. This occurs when the call to /// PeerDistServerOpenContentInformation on the content server specified an offset and a length which was a sub-range of the content /// as a whole. A completion with ERROR_NO_MORE in this case indicates that the read offset is outside of the sub-range of /// the content. /// /// Range Requests /// /// If a client is interested in only a portion of the original content, a range request can be used to retrieve that portion. A /// range request contains an offset and length of the original content. The size of the content information is directly /// proportional to the size of the content requested. /// /// /// PeerDistServerOpenContentInformation supports generating content information for a range request via the ullContentOffset and /// cbContentLength parameters. The ullContentOffset parameter represents the offset in the original content where the range begins /// and cbContentLength represents the length of the range. /// /// /// Once a client obtains content information representing a particular content range, that content information works seamlessly /// with the PeerDistClientOpenContent, PeerDistClientAddContentInformation and PeerDistClientCompleteContentInformation APIs. The /// content information can be passed to PeerDistServerOpenContentInformation and will associate the PEERDIST_CONTENT_HANDLE /// with the content range. PeerDistClientStreamRead is constrained by the ullContentOffset offset and cbContentLength length /// specified in the server side call to PeerDistServerRetrieveContentInformation. PeerDistClientStreamRead will begin at /// ullContentOffset and will complete with the error code PEERDIST_ERROR_NO_MORE when the end of the content range is /// reached at ullContentOffset + cbContentLength. PeerDistClientBlockRead will complete with the error code /// PEERDIST_ERROR_NO_MORE if the offset specified in the OVERLAPPED parameter is less than ullContentOffset or greater than /// ullContentOffset + cbContentLength. PeerDistClientStreamRead and PeerDistClientBlockRead both limit the amount of /// missing data reported to the content range specified in the content information associated with the /// PEERDIST_CONTENT_HANDLE. For example, if the content information represents only the first half of the content, missing /// data will be limited to the first half of the content. In all other respects, PeerDistClientBlockRead and /// PeerDistClientStreamRead work with content ranges in exactly the same manner in which they work with the content as a whole. /// /// /// A client can use PeerDistClientStreamRead or PeerDistClientBlockRead to retrieve the content from the offset specified by /// the ullContentOffset up to the length specified by cbContentLength in the PeerDistServerRetrieveContentInformation call. Both /// PeerDistClientStreamRead and PeerDistClientBlockRead will complete with PEERDIST_ERROR_NO_MORE if the /// client tries to read beyond the range specified by the ullContentOffset and cbContentLength. Additionally, /// PeerDistClientBlockRead will also complete with the error code PEERDIST_ERROR_NO_MORE if the offset specified in /// the OVERLAPPED parameter is less than ullContentOffset /// /// /// If the read cannot not be completed from either the local cache or the peer cache, both PeerDistClientStreamRead and /// PeerDistClientBlockRead will report PEERDIST_ERROR_MISSING_DATA. When using the ranged content information, /// PeerDistClientStreamRead will report a missing data from the start offset of the range up to the end of the range. /// PeerDistClientBlockRead will report missing data from start offset of the range up to the end of the range. /// /// /// PeerDistClientAddData allows content data to be added even if it lies outside the content range. This extended data will be /// validated after the corresponding content information has been added to the local cache. Once validated, it becomes available to /// peers. In other words, if a client adds only content information for the first half of content, PeerDistClientAddData /// still allows the client to add data for the entire content. However, the second half of the content will not be validated until /// the corresponding content information for the second half has been added. No other Peer Distribution APIs are affected by range requests. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientblockread DWORD PeerDistClientBlockRead( // PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD cbMaxNumberOfBytes, PBYTE pBuffer, DWORD // dwTimeoutInMilliseconds, LPOVERLAPPED lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientBlockRead")] public static unsafe extern Win32Error PeerDistClientBlockRead(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, uint cbMaxNumberOfBytes, [Out] IntPtr pBuffer, uint dwTimeoutInMilliseconds, [In] NativeOverlapped* lpOverlapped); /// /// The PeerDistClientCancelAsyncOperation function cancels asynchronous operation associated with an OVERLAPPED structure /// and the content handle returned by PeerDistClientOpenContent. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A content handle opened by PeerDistClientOpenContent function call. /// /// Pointer to an OVERLAPPED structure that contains the canceling asynchronous operation data. If the pointer is NULL all /// asynchronous operations for specified content handle will be canceled. /// /// /// /// The function will return ERROR_SUCCESS value if the operation associated with the specified OVERLAPPED structure is /// successfully canceled. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// PEERDIST_ERROR_OPERATION_NOT_FOUND /// The operation associated with the specified OVERLAPPED structure cannot be found. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// This function will synchronously cancel the operation, but will not return until the cancellation result is posted to the /// completion port or wait event is set to the signaled state. Any threads in waiting can receive the completion notice for the /// operation before or after the PeerDistClientCancelAsyncOperation function returns. /// /// /// This function does not guarantee that the operation will complete as canceled. The cancellation result will be posted only if no /// other results have been posted. /// /// To confirm successfully canceled operations, a call should be made to GetOverlappedResult with an expected return of FALSE. /// /// Additionally, calling GetLastError immediately after a successful PeerDistClientCancelAsyncOperation will return the /// ERROR_OPERATION_ABORTED error code. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientcancelasyncoperation DWORD // PeerDistClientCancelAsyncOperation( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, LPOVERLAPPED // pOverlapped ); [DllImport(Lib_PeerDist, SetLastError = true, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientCancelAsyncOperation")] public static unsafe extern Win32Error PeerDistClientCancelAsyncOperation(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, [In] NativeOverlapped* pOverlapped); /// The PeerDistClientCloseContent function closes the content handle opened by PeerDistClientOpenContent. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A PEERDIST_CONTENT_HANDLE opened by PeerDistClientOpenContent. /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hContent handle is invalid. /// /// /// /// /// This function will cancel all pending asynchronous operations associated with the provided hContentHandle. /// All handles opened by the PeerDistClientOpenContent function must be closed by PeerDistClientCloseContent. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientclosecontent DWORD // PeerDistClientCloseContent( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientCloseContent")] public static extern Win32Error PeerDistClientCloseContent(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle); /// The PeerDistClientCompleteContentInformation function completes the process of adding the content information. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A PEERDIST_CONTENT_HANDLE returned by PeerDistClientOpenContent. /// Pointer to an OVERLAPPED structure. /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// Upon completion of this function, a client can call PeerDistClientStreamRead or PeerDistClientBlockRead to retrieve the data /// from the Peer Distribution system. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientcompletecontentinformation DWORD // PeerDistClientCompleteContentInformation( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, // LPOVERLAPPED lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientCompleteContentInformation")] public static unsafe extern Win32Error PeerDistClientCompleteContentInformation(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, [In] NativeOverlapped* lpOverlapped); /// The PEERDIST_CONTENT_TAG. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// Pointer to a PEERDIST_CONTENT_TAG structure that contains the tag supplied when PeerDistClientOpenContent is called. /// /// /// A handle to the completion port that can be used for retrieving the completion notification of the asynchronous function. To /// create a completion port, use the CreateIoCompletionPort function. This parameter can be NULL. /// /// /// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored /// when hCompletionPort is NULL. /// /// /// Pointer to an OVERLAPPED structure. Offset and OffsetHigh are reserved and must be zero. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// The pContentTag is a client supplied tag passed to PeerDistClientOpenContent, which labels the content added by the client. This /// tag is used by the API to selectively flush content from the Peer Distribution cache. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientflushcontent DWORD // PeerDistClientFlushContent( PEERDIST_INSTANCE_HANDLE hPeerDist, PCPEERDIST_CONTENT_TAG pContentTag, HANDLE hCompletionPort, // ULONG_PTR ulCompletionKey, LPOVERLAPPED lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientFlushContent")] public static unsafe extern Win32Error PeerDistClientFlushContent(PEERDIST_INSTANCE_HANDLE hPeerDist, in PEERDIST_CONTENT_TAG pContentTag, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, [In] NativeOverlapped* lpOverlapped); /// /// The PeerDistClientGetInformationByHandle function retrieves additional information from the Peer Distribution service for /// a specific content handle. /// /// A PEERDIST_INSTANCE_HANDLE returned by the PeerDistStartup function. /// A PEERDIST_CONTENT_HANDLE returned by the PeerDistClientOpenContent function. /// /// A value from the PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS enumeration that indicates the information to retrieve. /// /// The size, in bytes, of the buffer for the lpInformation parameter. /// /// A buffer for the returned information. The format of this information depends on the value of the PeerDistClientInfoClass parameter. /// /// If the function succeeds, the return value is ERROR_SUCCESS. // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientgetinformationbyhandle DWORD // PeerDistClientGetInformationByHandle( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, // PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS PeerDistClientInfoClass, DWORD dwBufferSize, LPVOID lpInformation ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientGetInformationByHandle")] public static extern Win32Error PeerDistClientGetInformationByHandle(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS PeerDistClientInfoClass, uint dwBufferSize, [Out] IntPtr lpInformation); /// /// The PeerDistClientOpenContent function opens and returns a PEERDIST_CONTENT_HANDLE. The client uses the content handle to /// retrieve data from the Peer Distribution service. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// Pointer to a PEERDIST_CONTENT_TAG structure that contains a 16 byte client specified identifier. This parameter is used in /// conjunction with the PeerDistClientFlushContent function. /// /// /// A handle to the completion port that can be used for retrieving the completion notification of the asynchronous function. To /// create a completion port, use the CreateIoCompletionPort function This parameter can be NULL. /// /// /// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored /// when hCompletionPort is NULL. /// /// /// A pointer to a variable that receives the PEERDIST_CONTENT_HANDLE used to retrieve or add data. /// /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// Client must call the PeerDistClientOpenContent function to obtain a PEERDIST_CONTENT_HANDLE handle that later can /// be used in the following functions: /// /// /// /// PeerDistClientAddContentInformation /// /// /// PeerDistClientCompleteContentInformation /// /// /// PeerDistClientBlockRead /// /// /// PeerDistClientStreamRead /// /// /// PeerDistClientAddData /// /// /// /// If an optional completion port handle is specified, it is used for posting the completion results of above listed asynchronous functions. /// /// The handle returned by PeerDistClientOpenContent function call must be closed by PeerDistClientCloseContent function. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientopencontent DWORD // PeerDistClientOpenContent( PEERDIST_INSTANCE_HANDLE hPeerDist, PCPEERDIST_CONTENT_TAG pContentTag, HANDLE hCompletionPort, // ULONG_PTR ulCompletionKey, PPEERDIST_CONTENT_HANDLE phContentHandle ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientOpenContent")] public static extern Win32Error PeerDistClientOpenContent(PEERDIST_INSTANCE_HANDLE hPeerDist, in PEERDIST_CONTENT_TAG pContentTag, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, out PEERDIST_CONTENT_HANDLE phContentHandle); /// The PeerDistClientStreamRead reads a sequence of bytes from content stream. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A content handle opened by the PeerDistClientOpenContent function call. /// /// The maximum number of bytes to read. If the cbMaxNumberOfBytesToRead is equal to 0, it indicates that the /// PeerDistClientStreamRead function is querying the length of available consecutive content byes in the local cache at the /// current stream read offset. The query will neither download content from the peers, nor return the count of bytes present in the /// peer cache. /// /// /// Pointer to the buffer that receives the data from the local cache. This buffer must remain valid for the duration of the read /// operation. The caller must not use this buffer until the read operation is completed. If the cbMaxNumberOfBytesToRead argument /// is equal to 0, the pBuffer parameter can be NULL. /// /// /// Timeout value for the read, in milliseconds. There are two special values that may be specified: /// /// /// Value /// Meaning /// /// /// PEERDIST_READ_TIMEOUT_LOCAL_CACHE_ONLY /// Specifies that a read should not cause any additional network traffic by contacting peers or a Hosted Cache. /// /// /// PEERDIST_READ_TIMEOUT_DEFAULT /// Specifies the default timeout of 5 seconds. /// /// /// /// /// Pointer to an OVERLAPPED structure. Stream read does not allow the caller to specify the start Offset for the reading. /// The next stream read offset is implicitly maintained per hContentHandle. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hContent handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// PeerDistClientStreamRead queues the read and immediately returns to the caller. As a result, multiple reads can be issued /// simultaneously with the data buffers utilized in a first-in/first-out manner. PeerDistClientStreamRead will complete a /// read as soon as any data is available and will not wait for the buffer to fill completely. /// /// /// If the PeerDistClientStreamRead function operation completes successfully, the Offset and OffsetHigh fields /// of the OVERLAPPED structure will be populated with the ULONGLONG offset at which the read started. The OffsetHigh member /// will be set to the higher 32 bits of the offset and the Offset member will be set to the lower 32 bits of the offset. /// GetOverlappedResult populates lpNumberOfBytesTransferred with the number of bytes transferred. In the event the caller is using /// a completion port to process Peer Distribution API completions then the lpNumberOfBytes argument of GetQueuedCompletionStatus /// will be populated with the number of bytes transferred. The stream offset will be advanced by the number of bytes reported as /// read. To query the length of available content for content larger than 4GB, PeerDistClientBlockRead can be used with /// cbMaxNumberOfBytesToRead equal to 0 and appropriate offsets. /// /// /// If the API completes with the error value PEERDIST_ERROR_MISSING_DATA or ERROR_TIMEOUT, the Offset and /// OffsetHigh fields of the OVERLAPPED structure specify the ULONGLONG offset at which the missing data range begins. /// The OffsetHigh member will be set to the higher 32 bits of the offset and the Offset member will be set to the /// lower 32 bits of the offset. This missing data range is the start offset (relative to start of the content) and length, in /// bytes, which needs to be retrieved from an alternate source, like the original content server., In order to allow the Peer /// Distribution service to satisfy the same read in the future, add this data to the local cache by calling PeerDistClientAddData. /// The length of the missing data range is specified by the number of bytes transferred (obtained via GetQueuedCompletionStatus or /// GetOverlappedResult). The stream offset is advanced by the number of bytes reported as the length of the missing data range. /// /// /// If PeerDistClientStreamRead is called after the stream offset has advanced beyond the end of the content, the API will /// complete with ERROR_NO_MORE. /// /// /// It is important to note that the missing data range can start at any offset in the content and be any length up to the end of /// the content. In the event the content information passed to PeerDistClientAddContentInformation was generated in response to a /// range request, then the missing data range will be constrained to the range request bounds. This will happen when the call to /// PeerDistServerOpenContentInformation on the content server specified an offset and a length which was a sub-range of the content /// as a whole. A completion with ERROR_NO_MORE in this case indicates that the read offset is outside of the sub-range of /// the content. /// /// Range Requests /// /// If a client is interested in only a portion of the original content, a range request can be used to retrieve that portion. A /// range request contains an offset and length of the original content. The size of the content information is directly /// proportional to the size of the content requested. /// /// /// PeerDistServerOpenContentInformation supports generating content information for a range request via the ullContentOffset and /// cbContentLength parameters. The ullContentOffset parameter represents the offset in the original content where the range begins /// and cbContentLength represents the length of the range. /// /// /// Once a client obtains content information representing a particular content range, that content information works seamlessly /// with the PeerDistClientOpenContent, PeerDistClientAddContentInformation and PeerDistClientCompleteContentInformation APIs. The /// content information can be passed to PeerDistServerOpenContentInformation and will associate the PEERDIST_CONTENT_HANDLE /// with the content range. PeerDistClientStreamRead is constrained by the ullContentOffset offset and cbContentLength length /// specified in the server side call to PeerDistServerRetrieveContentInformation. PeerDistClientStreamRead will begin at /// ullContentOffset and will complete with the error code PEERDIST_ERROR_NO_MORE when the end of the content range is /// reached at ullContentOffset + cbContentLength. PeerDistClientBlockRead will complete with the error code /// PEERDIST_ERROR_NO_MORE if the offset specified in the OVERLAPPED parameter is less than ullContentOffset or greater than /// ullContentOffset + cbContentLength. PeerDistClientStreamRead and PeerDistClientBlockRead both limit the amount of /// missing data reported to the content range specified in the content information associated with the /// PEERDIST_CONTENT_HANDLE. For example, if the content information represents only the first half of the content, missing /// data will be limited to the first half of the content. In all other respects, PeerDistClientBlockRead and /// PeerDistClientStreamRead work with content ranges in exactly the same manner in which they work with the content as a whole. /// /// /// A client can use PeerDistClientStreamRead or PeerDistClientBlockRead to retrieve the content from the offset specified by /// the ullContentOffset up to the length specified by cbContentLength in the PeerDistServerRetrieveContentInformation call. Both /// PeerDistClientStreamRead and PeerDistClientBlockRead will complete with PEERDIST_ERROR_NO_MORE if the /// client tries to read beyond the range specified by the ullContentOffset and cbContentLength. Additionally, /// PeerDistClientBlockRead will also complete with the error code PEERDIST_ERROR_NO_MORE if the offset specified in /// the OVERLAPPED parameter is less than ullContentOffset /// /// /// If the read cannot not be completed from either the local cache or the peer cache, both PeerDistClientStreamRead and /// PeerDistClientBlockRead will report PEERDIST_ERROR_MISSING_DATA. When using the ranged content information, /// PeerDistClientStreamRead will report a missing data from the start offset of the range up to the end of the range. /// PeerDistClientBlockRead will report missing data from start offset of the range up to the end of the range. /// /// /// PeerDistClientAddData allows content data to be added even if it lies outside the content range. This extended data will be /// validated after the corresponding content information has been added to the local cache. Once validated, it becomes available to /// peers. In other words, if a client adds only content information for the first half of content, PeerDistClientAddData /// still allows the client to add data for the entire content. However, the second half of the content will not be validated until /// the corresponding content information for the second half has been added. No other Peer Distribution APIs are affected by range requests. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistclientstreamread DWORD PeerDistClientStreamRead( // PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, DWORD cbMaxNumberOfBytes, PBYTE pBuffer, DWORD // dwTimeoutInMilliseconds, LPOVERLAPPED lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistClientStreamRead")] public static unsafe extern Win32Error PeerDistClientStreamRead(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENT_HANDLE hContentHandle, uint cbMaxNumberOfBytes, [Out, Optional] IntPtr pBuffer, uint dwTimeoutInMilliseconds, [In] NativeOverlapped* lpOverlapped); /// /// The PeerDistGetOverlappedResult function retrieves the results of asynchronous operations. This function replaces the /// GetOverlappedResult function for Peer Distribution asynchronous operations. /// /// A pointer to an OVERLAPPED structure that was specified when the overlapped operation was started. /// /// A pointer to a variable that receives the number of bytes that were actually transferred by a read or write operation. /// /// /// If this parameter is /// true /// , the function does not return until the operation has been completed. If this parameter is /// false /// and the operation is still pending, the function returns /// false /// . /// /// /// Type: BOOL /// /// true /// if the operation has completed. /// false /// if the bWait argument is /// false /// and the operation is still pending. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistgetoverlappedresult BOOL // PeerDistGetOverlappedResult( LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistGetOverlappedResult")] [return: MarshalAs(UnmanagedType.Bool)] public static unsafe extern bool PeerDistGetOverlappedResult([In] NativeOverlapped* lpOverlapped, out uint lpNumberOfBytesTransferred, [MarshalAs(UnmanagedType.Bool)] bool bWait); /// The PeerDistGetStatus function returns the current status of the Peer Distribution service. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// A pointer to a PEERDIST_STATUS enumeration which upon operation success receives the current status of the Peer Distribution service. /// /// If the function succeeds, the return value is ERROR_SUCCESS. /// /// A Group Policy change can result in the Peer Distribution service moving to an available, unavailable, or disabled state. /// Depending on the resultant state of this transition, the content, content information, or stream handles the caller has access /// to may no longer function. If this is the case, the caller must explicitly close the handles by calling the appropriate Peer /// Distribution API. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistgetstatus DWORD PeerDistGetStatus( // PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STATUS *pPeerDistStatus ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistGetStatus")] public static extern Win32Error PeerDistGetStatus(PEERDIST_INSTANCE_HANDLE hPeerDist, out PEERDIST_STATUS pPeerDistStatus); /// The PeerDistGetStatusEx function returns the current status and capabilities of the Peer Distribution service. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// A pointer to a PEERDIST_STATUS_INFO structure that contains the current status and capabilities of the Peer Distribution service. /// /// If the function succeeds, the return value is ERROR_SUCCESS. /// /// A Group Policy change can result in the Peer Distribution service moving to an available, unavailable, or disabled state. /// Depending on the resultant state of this transition, the content, content information, or stream handles the caller has access /// to may no longer function. If this is the case, the caller must explicitly close the handles by calling the appropriate Peer /// Distribution API. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistgetstatusex DWORD PeerDistGetStatusEx( // PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STATUS_INFO *pPeerDistStatus ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistGetStatusEx")] public static extern Win32Error PeerDistGetStatusEx(PEERDIST_INSTANCE_HANDLE hPeerDist, ref PEERDIST_STATUS_INFO pPeerDistStatus); /// /// The PeerDistRegisterForStatusChangeNotification function requests the Peer Distribution service status change notification. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// A handle to the completion port that can be used for retrieving the completion notification of the asynchronous function. To /// create a completion port, use the CreateIoCompletionPort function. This parameter can be NULL. /// /// /// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored /// when hCompletionPort is NULL. /// /// /// Pointer to an OVERLAPPED structure. If the hEvent member of the structure is not NULL, it will be signaled via /// SetEvent() used in order to signal the notification. This can occur even if the completion port is specified via the /// hCompletionPort argument. /// /// /// A pointer to a PEERDIST_STATUS enumeration that indicates the current status of the Peer Distribution service. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// /// /// /// This function optionally registers a completion port and an OVERLAPPED structure for status change notification. Upon successful /// completion, the pPeerDistStatus parameter will contain a valid PEERDIST_STATUS value. /// /// /// Only one active registration for each session is allowed. The caller must register for notification each time after it signals. /// The notification will be sent only if the current status is changed from the previous notification. After the first call of the /// PeerDistRegisterForStatusChangeNotification function for the Peer Distribution session, the first notification will /// trigger only if the status is no longer equal to PEERDIST_STATUS_DISABLED. /// /// /// A Peer Distribution status change can result in the Peer Distribution service moving to an available, unavailable, or disabled /// state. If the new status is disabled or unavailable, the content, content information, or stream handles the caller has access /// to will no longer function. In this case, any API that uses these handles will fail with error PEERDIST_ /// ERROR_INVALIDATED. The caller must explicitly close the handles by calling the appropriate Peer Distribution API. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistregisterforstatuschangenotification DWORD // PeerDistRegisterForStatusChangeNotification( PEERDIST_INSTANCE_HANDLE hPeerDist, HANDLE hCompletionPort, ULONG_PTR // ulCompletionKey, LPOVERLAPPED lpOverlapped, PEERDIST_STATUS *pPeerDistStatus ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistRegisterForStatusChangeNotification")] public static unsafe extern Win32Error PeerDistRegisterForStatusChangeNotification(PEERDIST_INSTANCE_HANDLE hPeerDist, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, [In] NativeOverlapped* lpOverlapped, out PEERDIST_STATUS pPeerDistStatus); /// /// The PeerDistRegisterForStatusChangeNotificationEx function requests the Peer Distribution service status change notification. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// A handle to the completion port that can be used for retrieving the completion notification of the asynchronous function. To /// create a completion port, use the CreateIoCompletionPort function. This parameter can be NULL. /// /// /// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored /// when hCompletionPort is NULL. /// /// /// Pointer to an OVERLAPPED structure. If the hEvent member of the structure is not NULL, it will be signaled via /// SetEvent() used in order to signal the notification. This can occur even if the completion port is specified via the /// hCompletionPort argument. /// /// /// A pointer to a PEERDIST_STATUS_INFO structure that contains the current status and capabilities of the Peer Distribution service. /// /// If the function succeeds, the return value is ERROR_SUCCESS. /// /// /// This function optionally registers a completion port and an OVERLAPPED structure for status change notification. Upon successful /// completion, the pPeerDistStatus parameter will contain a valid PEERDIST_STATUS value. /// /// /// Only one active registration for each session is allowed. The caller must register for notification each time after it signals. /// The notification will be sent only if the current status is changed from the previous notification. After the first call of the /// PeerDistRegisterForStatusChangeNotification function for the Peer Distribution session, the first notification will trigger only /// if the status is no longer equal to PEERDIST_STATUS_DISABLED. /// /// /// A Peer Distribution status change can result in the Peer Distribution service moving to an available, unavailable, or disabled /// state. If the new status is disabled or unavailable, the content, content information, or stream handles the caller has access /// to will no longer function. In this case, any API that uses these handles will fail with error PEERDIST_ /// ERROR_INVALIDATED. The caller must explicitly close the handles by calling the appropriate Peer Distribution API. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistregisterforstatuschangenotificationex DWORD // PeerDistRegisterForStatusChangeNotificationEx( PEERDIST_INSTANCE_HANDLE hPeerDist, HANDLE hCompletionPort, ULONG_PTR // ulCompletionKey, LPOVERLAPPED lpOverlapped, PEERDIST_STATUS_INFO *pPeerDistStatus ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistRegisterForStatusChangeNotificationEx")] public static unsafe extern Win32Error PeerDistRegisterForStatusChangeNotificationEx(PEERDIST_INSTANCE_HANDLE hPeerDist, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, [In] NativeOverlapped* lpOverlapped, ref PEERDIST_STATUS_INFO pPeerDistStatus); /// /// The PeerDistServerCancelAsyncOperation function cancels the asynchronous operation associated with the content identifier /// and OVERLAPPED structure. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The length, in bytes, of the content identifier. /// Pointer to an array that contains the content identifier. /// Pointer to an OVERLAPPED structure that contains the canceling asynchronous operation data. /// /// /// The function will return ERROR_SUCCESS value if the operation associated with OVERLAPPED structure is successfully /// canceled. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// PEERDIST_ERROR_OPERATION_NOT_FOUND /// The operation for OVERLAPPED structure cannot be found. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// This function will synchronously cancel the operation, but will not return until the cancelation result is posted to the /// completion port or wait event is set to the 'signaled' state. Any threads in waiting can receive the completion notice for the /// operation before or after the PeerDistServerCancelAsyncOperation function returns. /// /// /// This function does not guarantee that the operation will complete as canceled. The cancellation result will be posted only if no /// other results have been posted. /// /// To confirm successfully canceled operations, a call should be made to GetOverlappedResult with an expected return of FALSE. /// /// Additionally, calling GetLastError immediately after a successful PeerDistServerCancelAsyncOperation will return the /// ERROR_OPERATION_ABORTED error code. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistservercancelasyncoperation DWORD // PeerDistServerCancelAsyncOperation( PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, // LPOVERLAPPED pOverlapped ); [DllImport(Lib_PeerDist, SetLastError = true, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerCancelAsyncOperation")] public static unsafe extern Win32Error PeerDistServerCancelAsyncOperation(PEERDIST_INSTANCE_HANDLE hPeerDist, uint cbContentIdentifier, [In] IntPtr pContentIdentifier, [In] NativeOverlapped* pOverlapped); /// The PeerDistServerCloseContentInformation function closes the handle opened by PeerDistServerOpenContentInformation. /// The PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The handle returned by PeerDistServerOpenContentInformation. /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_HANDLE /// The provided hPeerDist or hContentInfo handles are invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// /// /// The PeerDistServerCloseContentInformation closes the PEERDIST_CONTENTINFO_HANDLE. Additionally, calling /// PeerDistServerCloseContentInformation will cancel any pending operations associated with the PEERDIST_CONTENTINFO_HANDLE. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverclosecontentinformation DWORD // PeerDistServerCloseContentInformation( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENTINFO_HANDLE hContentInfo ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerCloseContentInformation")] public static extern Win32Error PeerDistServerCloseContentInformation(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENTINFO_HANDLE hContentInfo); /// The PeerDistServerCloseStreamHandle function closes a handle returned by PeerDistServerPublishStream. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A PEERDIST_STREAM_HANDLE returned by PeerDistServerPublishStream. /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hStream handle is invalid /// /// /// /// /// /// The PeerDistServerCloseStreamHandle function call cancels all pending operations associated with hStream. To prevent /// unintended cancellation of publication and closure of the stream handle, this function should be called after the completion of PeerDistServerPublishCompleteStream. /// /// PeerDistServerCloseStreamHandle does not remove the publication. In order to remove the publication, call PeerDistServerUnpublish. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverclosestreamhandle DWORD // PeerDistServerCloseStreamHandle( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerCloseStreamHandle")] public static extern Win32Error PeerDistServerCloseStreamHandle(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream); /// /// The PeerDistServerOpenContentInformation function opens a PEERDIST_CONTENTINFO_HANDLE. The client uses the handle /// to retrieve content information. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The length, in bytes, of the content identifier. /// Pointer to a buffer that contains the content identifier. /// /// An offset from the beginning of the published content for which the content information handle is requested. /// /// /// The length, in bytes, of the content (starting from the ullContentOffset) for which the content information is requested. /// /// /// A handle to the completion port used for retrieving the completion notification of the asynchronous function. To create a /// completion port, use the CreateIoCompletionPort function. This parameter can be NULL. /// /// /// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored /// when hCompletionPort is NULL. /// /// A handle used to retrieve the content information. /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// PEERDIST_ERROR_NOT_FOUND /// The specified content identifier data is not published. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// If function succeeds, the handle received by phContentInfo can be passed to the PeerDistServerRetrieveContentInformation /// function to retrieve content information. The handle must be closed via the PeerDistServerCloseContentInformation function. /// /// If ullContentOffset and cbContentLength are both zero, then the content information for the whole content will be retrieved. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserveropencontentinformation DWORD // PeerDistServerOpenContentInformation( PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, // ULONGLONG ullContentOffset, ULONGLONG cbContentLength, HANDLE hCompletionPort, ULONG_PTR ulCompletionKey, // PPEERDIST_CONTENTINFO_HANDLE phContentInfo ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerOpenContentInformation")] public static extern Win32Error PeerDistServerOpenContentInformation(PEERDIST_INSTANCE_HANDLE hPeerDist, uint cbContentIdentifier, [In] IntPtr pContentIdentifier, ulong ullContentOffset, ulong cbContentLength, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, out PEERDIST_CONTENTINFO_HANDLE phContentInfo); /// /// The PeerDistServerOpenContentInformationEx function opens a PEERDIST_CONTENTINFO_HANDLE. The client uses the /// handle to retrieve content information. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The length, in bytes, of the content identifier. /// Pointer to a buffer that contains the content identifier. /// /// An offset from the beginning of the published content for which the content information handle is requested. /// /// /// The length, in bytes, of the content (starting from the ullContentOffset) for which the content information is requested. /// /// A PEER_RETRIEVAL_OPTIONS structure specifying additional options for retrieving content information. /// /// A handle to the completion port used for retrieving the completion notification of the asynchronous function. To create a /// completion port, use the CreateIoCompletionPort function. This parameter can be NULL. /// /// /// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored /// when hCompletionPort is NULL. /// /// A handle used to retrieve the content information. /// If the function succeeds, the return value is ERROR_SUCCESS. /// /// /// If function succeeds, the handle received by phContentInfo can be passed to the PeerDistServerRetrieveContentInformation /// function to retrieve content information. The handle must be closed via the PeerDistServerCloseContentInformation function. /// /// If ullContentOffset and cbContentLength are both zero, then the content information for the whole content will be retrieved. /// /// The pRetrievalOptions parameter can be used to specify the range of content information versions that the requesting client is /// configured to process. This enables the client to retrieve an applicable version of the content information structure. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserveropencontentinformationex DWORD // PeerDistServerOpenContentInformationEx( PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, // ULONGLONG ullContentOffset, ULONGLONG cbContentLength, PEERDIST_RETRIEVAL_OPTIONS *pRetrievalOptions, HANDLE hCompletionPort, // ULONG_PTR ulCompletionKey, PPEERDIST_CONTENTINFO_HANDLE phContentInfo ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerOpenContentInformationEx")] public static extern Win32Error PeerDistServerOpenContentInformationEx(PEERDIST_INSTANCE_HANDLE hPeerDist, uint cbContentIdentifier, [In] IntPtr pContentIdentifier, ulong ullContentOffset, ulong cbContentLength, in PEERDIST_RETRIEVAL_OPTIONS pRetrievalOptions, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, out PEERDIST_CONTENTINFO_HANDLE phContentInfo); /// The PeerDistServerPublishAddToStream function adds data to the publishing stream. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A PEERDIST_STREAM_HANDLE created by PeerDistServerPublishStream. /// Number of bytes to be published. /// /// Pointer to the buffer that contains the data to be published. This buffer must remain valid for the duration of the add /// operation. The caller must not use this buffer until the add operation is completed. /// /// /// Pointer to an OVERLAPPED structure. The Offset and OffsetHigh members are reserved and must be zero. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hStream handle is invalid. /// /// /// ERROR_OPERATION_ABORTED /// The operation was canceled. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// When calling this function multiple times on a single stream handle, the caller must wait for each operation to complete before /// the next call is made. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverpublishaddtostream DWORD // PeerDistServerPublishAddToStream( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream, DWORD cbNumberOfBytes, // PBYTE pBuffer, LPOVERLAPPED lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerPublishAddToStream")] public static unsafe extern Win32Error PeerDistServerPublishAddToStream(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream, uint cbNumberOfBytes, [In] IntPtr pBuffer, [In] NativeOverlapped* lpOverlapped); /// The PeerDistServerPublishCompleteStream function completes the process of adding data to the stream. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// A PEERDIST_STREAM_HANDLE returned by PeerDistServerPublishStream. /// /// Pointer to an OVERLAPPED structure. The Offset and OffsetHigh are reserved and must be zero. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hStream handle is invalid /// /// /// ERROR_OPERATION_ABORTED /// The operation was canceled. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// Once this API completes successfully, PeerDistServerOpenContentInformation and PeerDistServerRetrieveContentInformation can be /// used to retrieve content information. /// /// PeerDistServerPublishCompleteStream does not close hStream. In order to close hStream, call PeerDistServerCloseStreamHandle. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverpublishcompletestream DWORD // PeerDistServerPublishCompleteStream( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream, LPOVERLAPPED // lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerPublishCompleteStream")] public static unsafe extern Win32Error PeerDistServerPublishCompleteStream(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_STREAM_HANDLE hStream, [In] NativeOverlapped* lpOverlapped); /// /// The PeerDistServerPublishStream function initializes a new stream to be published to the Peer Distribution service. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The length, in bytes, of the buffer that contains content identifier data. /// A pointer to an array that contains a content identifier data. /// /// The length, in bytes, of the content to be published. This value can be 0 if the content length is not yet known. If a non-zero /// argument is provided then it must match to the total data length added by PeerDistServerPublishAddToStream function calls. /// /// Pointer to a PEERDIST_PUBLICATION_OPTIONS structure that specifies content publishing rules. /// /// A handle to the completion port that can be used for retrieving the completion notification of the asynchronous function. To /// create a completion port, use the CreateIoCompletionPort function. This parameter can be NULL. /// /// /// Value returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored when /// hCompletionPort is NULL. /// /// /// A pointer that receives a handle to the stream that is used to publish data into the Peer Distribution service. /// /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The specified hPeerDist is invalid. /// /// /// PEERDIST_ERROR_ALREADY_EXISTS /// The content identifier used for publication is already published. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// A content identifier is a user defined label for the content being published. This content identifier is used for /// PeerDistServerOpenContentInformation, PeerDistServerUnpublish, and PeerDistServerCancelAsyncOperation calls. /// /// /// The handle received by phStream can be used in PeerDistServerPublishAddToStream and PeerDistServerPublishCompleteStream to /// publish data into the Peer Distribution service. This handle should be closed by PeerDistServerCloseStreamHandle. /// /// /// A publication is accessible only to the User Account that originally published the content. If a different user calls /// PeerDistServerPublishStream with the same content identifier, a separate publication will be created under the context of /// that user. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverpublishstream DWORD // PeerDistServerPublishStream( PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, ULONGLONG // cbContentLength, PCPEERDIST_PUBLICATION_OPTIONS pPublishOptions, HANDLE hCompletionPort, ULONG_PTR ulCompletionKey, // PPEERDIST_STREAM_HANDLE phStream ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerPublishStream")] public static extern Win32Error PeerDistServerPublishStream(PEERDIST_INSTANCE_HANDLE hPeerDist, uint cbContentIdentifier, [In] IntPtr pContentIdentifier, ulong cbContentLength, in PEERDIST_PUBLICATION_OPTIONS pPublishOptions, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, out PEERDIST_STREAM_HANDLE phStream); /// /// The PeerDistServerPublishStream function initializes a new stream to be published to the Peer Distribution service. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The length, in bytes, of the buffer that contains content identifier data. /// A pointer to an array that contains a content identifier data. /// /// The length, in bytes, of the content to be published. This value can be 0 if the content length is not yet known. If a non-zero /// argument is provided then it must match to the total data length added by PeerDistServerPublishAddToStream function calls. /// /// Pointer to a PEERDIST_PUBLICATION_OPTIONS structure that specifies content publishing rules. /// /// A handle to the completion port that can be used for retrieving the completion notification of the asynchronous function. To /// create a completion port, use the CreateIoCompletionPort function. This parameter can be NULL. /// /// /// Value returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored when /// hCompletionPort is NULL. /// /// /// A pointer that receives a handle to the stream that is used to publish data into the Peer Distribution service. /// /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The specified hPeerDist is invalid. /// /// /// PEERDIST_ERROR_ALREADY_EXISTS /// The content identifier used for publication is already published. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// A content identifier is a user defined label for the content being published. This content identifier is used for /// PeerDistServerOpenContentInformation, PeerDistServerUnpublish, and PeerDistServerCancelAsyncOperation calls. /// /// /// The handle received by phStream can be used in PeerDistServerPublishAddToStream and PeerDistServerPublishCompleteStream to /// publish data into the Peer Distribution service. This handle should be closed by PeerDistServerCloseStreamHandle. /// /// /// A publication is accessible only to the User Account that originally published the content. If a different user calls /// PeerDistServerPublishStream with the same content identifier, a separate publication will be created under the context of /// that user. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverpublishstream DWORD // PeerDistServerPublishStream( PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier, ULONGLONG // cbContentLength, PCPEERDIST_PUBLICATION_OPTIONS pPublishOptions, HANDLE hCompletionPort, ULONG_PTR ulCompletionKey, // PPEERDIST_STREAM_HANDLE phStream ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerPublishStream")] public static extern Win32Error PeerDistServerPublishStream(PEERDIST_INSTANCE_HANDLE hPeerDist, uint cbContentIdentifier, [In] IntPtr pContentIdentifier, ulong cbContentLength, [In, Optional] IntPtr pPublishOptions, [In, Optional] HANDLE hCompletionPort, [In, Optional] UIntPtr ulCompletionKey, out PEERDIST_STREAM_HANDLE phStream); /// /// The PeerDistServerRetrieveContentInformation function retrieves the encoded content information associated with a handle /// returned by PeerDistServerOpenContentInformation. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The handle returned by PeerDistServerOpenContentInformation. /// The maximum number of bytes to read. /// Pointer to the buffer that receives the content information data. /// /// Pointer to an OVERLAPPED structure. This function does not allow the caller to specify the start Offset in the content. The /// offset is implicitly maintained per hContentInfo. The Offset and OffsetHigh are reserved and must be zero. /// /// /// /// If the function succeeds, the return value is ERROR_IO_PENDING. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist or hContentInfo handle is invalid. /// /// /// PEERDIST_ERROR_NO_MORE /// EOF on the content information has been reached. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// On the success of the PeerDistServerRetrieveContentInformation operation, the Offset and OffsetHigh fields /// of the OVERLAPPED structure will be populated with the ULONGLONG offset in the content information that was retrieved. /// The OffsetHigh member will be set to the higher 32 bits of the offset and the Offset member will be set to the /// lower 32 bits of the offset. /// /// /// GetOverlappedResult will populate lpNumberOfBytesTransferred with the number of bytes transferred. In the event the caller is /// using a completion port to process Peer Distribution API completions, the lpNumberOfBytes argument of GetQueuedCompletionStatus /// will be populated with the number of bytes transferred. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverretrievecontentinformation DWORD // PeerDistServerRetrieveContentInformation( PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENTINFO_HANDLE hContentInfo, DWORD // cbMaxNumberOfBytes, PBYTE pBuffer, LPOVERLAPPED lpOverlapped ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerRetrieveContentInformation")] public static unsafe extern Win32Error PeerDistServerRetrieveContentInformation(PEERDIST_INSTANCE_HANDLE hPeerDist, PEERDIST_CONTENTINFO_HANDLE hContentInfo, uint cbMaxNumberOfBytes, [Out] IntPtr pBuffer, [In] NativeOverlapped* lpOverlapped); /// The PeerDistServerUnpublish function removes a publication created via PeerDistServerPublishStream. /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// The length, in bytes, of the content identifier. /// Pointer to a buffer that contains the content identifier. /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// ERROR_ACCESS_DISABLED_BY_POLICY /// The feature is disabled by Group Policy. /// /// /// PEERDIST_ERROR_SERVICE_UNAVAILABLE /// The service is unavailable. /// /// /// /// /// /// The PeerDistServerUnpublish function cancels all pending operations on unpublished content within the Peer Distribution /// session that is associated with the specified hPeerDist. The client is still required to close previously opened handles on that /// content with a call to PeerDistClientCloseContent. /// /// A publication is accessible only to the User Account that originally published the content. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistserverunpublish DWORD PeerDistServerUnpublish( // PEERDIST_INSTANCE_HANDLE hPeerDist, DWORD cbContentIdentifier, PBYTE pContentIdentifier ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistServerUnpublish")] public static extern Win32Error PeerDistServerUnpublish(PEERDIST_INSTANCE_HANDLE hPeerDist, uint cbContentIdentifier, [In] IntPtr pContentIdentifier); /// /// The PeerDistShutdown function releases resources allocated by a call to PeerDistStartup. Each handle returned by a /// PeerDistStartup call must be closed by a matching call to PeerDistShutdown /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// /// /// This function will remove all publications that were created with the specified hPeerDist handle. It is recommended that this /// function is called after all pending operations have completed, as PeerDistShutdown cancel all pending Peer Distribution /// client and server operations associated with the supplied PEERDIST_INSTANCE_HANDLE. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistshutdown DWORD PeerDistShutdown( // PEERDIST_INSTANCE_HANDLE hPeerDist ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistShutdown")] public static extern Win32Error PeerDistShutdown(PEERDIST_INSTANCE_HANDLE hPeerDist); /// /// The PeerDistStartup function creates a new Peer Distribution instance handle which must be passed to all other Peer /// Distribution APIs. /// /// /// Contains the minimum version of the Peer Distribution requested by the application. The high order byte specifies the minor /// version number; the low order byte specifies the major version number. /// /// /// A pointer to a PEERDIST_INSTANCE_HANDLE variable which upon success receives a newly created handle. /// /// /// A pointer to a variable which, if not NULL, contains the maximum version number that is supported by the Peer /// Distribution system. The high order byte specifies the minor version number; the low order byte specifies the major version number. /// /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// PEERDIST_ERROR_VERSION_UNSUPPORTED /// The requested version is not supported by client side DLL. /// /// /// /// /// PeerDistStartup must be called before any other Peer Distribution functions. When no longer needed, the handle returned /// by PeerDistStartup should be closed via a call to PeerDistShutdown. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdiststartup DWORD PeerDistStartup( DWORD // dwVersionRequested, PPEERDIST_INSTANCE_HANDLE phPeerDist, PDWORD pdwSupportedVersion ); [DllImport(Lib_PeerDist, SetLastError = false, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistStartup")] public static extern Win32Error PeerDistStartup(uint dwVersionRequested, out PEERDIST_INSTANCE_HANDLE phPeerDist, out uint pdwSupportedVersion); /// /// The PeerDistUnregisterForStatusChangeNotification function unregisters the status change notification for the session /// associated with the specified handle. /// /// A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup. /// /// /// If the function succeeds, the return value is ERROR_SUCCESS. Otherwise, the function may return one of the following values: /// /// /// /// Return code /// Description /// /// /// ERROR_INVALID_PARAMETER /// One or more parameters are invalid. /// /// /// ERROR_INVALID_HANDLE /// The hPeerDist handle is invalid. /// /// /// /// /// /// This function cancels any registered notification previously set by a PeerDistRegisterForStatusChangeNotification function call. /// /// /// To confirm successfully canceled operations, a call should be made to GetOverlappedResult using the OVERLAPPED structure /// returned by GetQueuedCompletionStatus with an expected return of FALSE. /// /// /// Additionally, calling GetLastError immediately after a successful PeerDistRegisterForStatusChangeNotification will return the /// ERROR_OPERATION_ABORTED error code. /// /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/nf-peerdist-peerdistunregisterforstatuschangenotification DWORD // PeerDistUnregisterForStatusChangeNotification( PEERDIST_INSTANCE_HANDLE hPeerDist ); [DllImport(Lib_PeerDist, SetLastError = true, ExactSpelling = true)] [PInvokeData("peerdist.h", MSDNShortId = "NF:peerdist.PeerDistUnregisterForStatusChangeNotification")] public static extern Win32Error PeerDistUnregisterForStatusChangeNotification(PEERDIST_INSTANCE_HANDLE hPeerDist); /// /// The PEERDIST_CLIENT_BASIC_INFO structure indicates whether or not there are many clients simultaneously downloading the /// same content. /// /// /// /// Thie PEERDIST_CLIENT_BASIC_INFO structure is retrieved from the PeerDistClientGetInformationHandle function with /// PeerDistClientBasicInfo value specified for the PeerDistClientInfoClass parameter. /// /// If true, content that cannot be retrieved from the Peer Distribution APIs may soon be available for retrieval. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/ns-peerdist-peerdist_client_basic_info typedef struct // _PEERDIST_CLIENT_BASIC_INFO { BOOL fFlashCrowd; } PEERDIST_CLIENT_BASIC_INFO, *PPEERDIST_CLIENT_BASIC_INFO; [PInvokeData("peerdist.h", MSDNShortId = "NS:peerdist._PEERDIST_CLIENT_BASIC_INFO")] [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_CLIENT_BASIC_INFO { /// /// Indicates that a "flash crowd" situation has been detected, where many clients in the branch office are simultaneously /// downloading the same content. /// [MarshalAs(UnmanagedType.Bool)] public bool fFlashCrowd; } /// Provides a handle to peer distribution conent. [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_CONTENT_HANDLE : IHandle { private IntPtr handle; /// Initializes a new instance of the struct. /// An object that represents the pre-existing handle to use. public PEERDIST_CONTENT_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle; /// Returns an invalid handle by instantiating a object with . public static PEERDIST_CONTENT_HANDLE NULL => new PEERDIST_CONTENT_HANDLE(IntPtr.Zero); /// Gets a value indicating whether this instance is a null handle. public bool IsNull => handle == IntPtr.Zero; /// Performs an explicit conversion from to . /// The handle. /// The result of the conversion. public static explicit operator IntPtr(PEERDIST_CONTENT_HANDLE h) => h.handle; /// Performs an implicit conversion from to . /// The pointer to a handle. /// The result of the conversion. public static implicit operator PEERDIST_CONTENT_HANDLE(IntPtr h) => new PEERDIST_CONTENT_HANDLE(h); /// Implements the operator !=. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(PEERDIST_CONTENT_HANDLE h1, PEERDIST_CONTENT_HANDLE h2) => !(h1 == h2); /// Implements the operator ==. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(PEERDIST_CONTENT_HANDLE h1, PEERDIST_CONTENT_HANDLE h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is PEERDIST_CONTENT_HANDLE h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } /// /// The PEERDIST_CONTENT_TAG structure contains a client supplied content tag as an input to the PeerDistClientOpenContent API. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/ns-peerdist-peerdist_content_tag typedef struct // peerdist_content_tag_tag { BYTE Data[16]; } PEERDIST_CONTENT_TAG, *PPEERDIST_CONTENT_TAG; [PInvokeData("peerdist.h", MSDNShortId = "NS:peerdist.peerdist_content_tag_tag")] [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_CONTENT_TAG { /// A 16 byte tag associated with the open content. [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public byte[] Data; } /// Provides a handle to peer distribution content info. [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_CONTENTINFO_HANDLE : IHandle { private IntPtr handle; /// Initializes a new instance of the struct. /// An object that represents the pre-existing handle to use. public PEERDIST_CONTENTINFO_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle; /// Returns an invalid handle by instantiating a object with . public static PEERDIST_CONTENTINFO_HANDLE NULL => new PEERDIST_CONTENTINFO_HANDLE(IntPtr.Zero); /// Gets a value indicating whether this instance is a null handle. public bool IsNull => handle == IntPtr.Zero; /// Performs an explicit conversion from to . /// The handle. /// The result of the conversion. public static explicit operator IntPtr(PEERDIST_CONTENTINFO_HANDLE h) => h.handle; /// Performs an implicit conversion from to . /// The pointer to a handle. /// The result of the conversion. public static implicit operator PEERDIST_CONTENTINFO_HANDLE(IntPtr h) => new PEERDIST_CONTENTINFO_HANDLE(h); /// Implements the operator !=. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(PEERDIST_CONTENTINFO_HANDLE h1, PEERDIST_CONTENTINFO_HANDLE h2) => !(h1 == h2); /// Implements the operator ==. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(PEERDIST_CONTENTINFO_HANDLE h1, PEERDIST_CONTENTINFO_HANDLE h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is PEERDIST_CONTENTINFO_HANDLE h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } /// Provides a handle to a peer distribution instance. [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_INSTANCE_HANDLE : IHandle { private IntPtr handle; /// Initializes a new instance of the struct. /// An object that represents the pre-existing handle to use. public PEERDIST_INSTANCE_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle; /// Returns an invalid handle by instantiating a object with . public static PEERDIST_INSTANCE_HANDLE NULL => new PEERDIST_INSTANCE_HANDLE(IntPtr.Zero); /// Gets a value indicating whether this instance is a null handle. public bool IsNull => handle == IntPtr.Zero; /// Performs an explicit conversion from to . /// The handle. /// The result of the conversion. public static explicit operator IntPtr(PEERDIST_INSTANCE_HANDLE h) => h.handle; /// Performs an implicit conversion from to . /// The pointer to a handle. /// The result of the conversion. public static implicit operator PEERDIST_INSTANCE_HANDLE(IntPtr h) => new PEERDIST_INSTANCE_HANDLE(h); /// Implements the operator !=. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(PEERDIST_INSTANCE_HANDLE h1, PEERDIST_INSTANCE_HANDLE h2) => !(h1 == h2); /// Implements the operator ==. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(PEERDIST_INSTANCE_HANDLE h1, PEERDIST_INSTANCE_HANDLE h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is PEERDIST_INSTANCE_HANDLE h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } /// /// The PEERDIST_PUBLICATION_OPTIONS structure contains publication options, including the API version information and /// possible option flags. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/ns-peerdist-peerdist_publication_options typedef struct // peerdist_publication_options_tag { DWORD dwVersion; DWORD dwFlags; } PEERDIST_PUBLICATION_OPTIONS, *PPEERDIST_PUBLICATION_OPTIONS; [PInvokeData("peerdist.h", MSDNShortId = "NS:peerdist.peerdist_publication_options_tag")] [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_PUBLICATION_OPTIONS { /// /// The following possible values reflect the version number of the client: /// /// /// Value /// Meaning /// /// /// 1 /// Version 1.0 /// /// /// 2 /// Version 2.0 /// /// /// public uint dwVersion; /// Reserved. public uint dwFlags; } /// The PEER_RETRIEVAL_OPTIONS structure contains version of the content information to retrieve. // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/ns-peerdist-peerdist_retrieval_options typedef struct // peerdist_retrieval_options_tag { DWORD cbSize; DWORD dwContentInfoMinVersion; DWORD dwContentInfoMaxVersion; DWORD dwReserved; } // PEERDIST_RETRIEVAL_OPTIONS, *PPEERDIST_RETRIEVAL_OPTIONS; [PInvokeData("peerdist.h", MSDNShortId = "NS:peerdist.peerdist_retrieval_options_tag")] [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_RETRIEVAL_OPTIONS { /// Specifies the size of the input structure. public uint cbSize; /// /// Specifies the minimum version of the content information to retrieve. Must be set to one of the following values: /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 /// public uint dwContentInfoMinVersion; /// /// Specifies the maximum version of the content information to retrieve. Must be set to one of the following values: /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 /// public uint dwContentInfoMaxVersion; /// Reserved. The dwReserved member should be set to 0. public uint dwReserved; } /// /// The PEERDIST_STATUS_INFO structure contains information about the current status and capabilities of the BranchCache /// service on the local computer. /// // https://docs.microsoft.com/en-us/windows/win32/api/peerdist/ns-peerdist-peerdist_status_info typedef struct // peerdist_status_info_tag { DWORD cbSize; PEERDIST_STATUS status; DWORD dwMinVer; DWORD dwMaxVer; } PEERDIST_STATUS_INFO, *PPEERDIST_STATUS_INFO; [PInvokeData("peerdist.h", MSDNShortId = "NS:peerdist.peerdist_status_info_tag")] [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_STATUS_INFO { /// Size, in bytes, of the PEERDIST_STATUS_INFO structure. public uint cbSize; /// /// Specifies the current status of the BranchCache service. This member should be one of following values defined in the /// PEERDIST_STATUS enumeration. /// public PEERDIST_STATUS status; /// /// /// Specifies the minimum version of the content information format supported by the BranchCache service on the local machine. /// This member must be set to one of the following values. /// /// /// /// Value /// Meaning /// /// /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 1 /// Windows 7 compatible content information format. /// /// /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 2 /// Windows 8 content information format. /// /// /// public uint dwMinVer; /// /// /// Specifies the maximum version of the content information format supported by the BranchCache service on the local machine. /// This member must be set to one of the following values. /// /// /// /// Value /// Meaning /// /// /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 1 /// Windows 7 compatible content information format. /// /// /// PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 2 /// Windows 8 content information format. /// /// /// public uint dwMaxVer; } /// Provides a handle to a peer distribution stream. [StructLayout(LayoutKind.Sequential)] public struct PEERDIST_STREAM_HANDLE : IHandle { private IntPtr handle; /// Initializes a new instance of the struct. /// An object that represents the pre-existing handle to use. public PEERDIST_STREAM_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle; /// Returns an invalid handle by instantiating a object with . public static PEERDIST_STREAM_HANDLE NULL => new PEERDIST_STREAM_HANDLE(IntPtr.Zero); /// Gets a value indicating whether this instance is a null handle. public bool IsNull => handle == IntPtr.Zero; /// Performs an explicit conversion from to . /// The handle. /// The result of the conversion. public static explicit operator IntPtr(PEERDIST_STREAM_HANDLE h) => h.handle; /// Performs an implicit conversion from to . /// The pointer to a handle. /// The result of the conversion. public static implicit operator PEERDIST_STREAM_HANDLE(IntPtr h) => new PEERDIST_STREAM_HANDLE(h); /// Implements the operator !=. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator !=(PEERDIST_STREAM_HANDLE h1, PEERDIST_STREAM_HANDLE h2) => !(h1 == h2); /// Implements the operator ==. /// The first handle. /// The second handle. /// The result of the operator. public static bool operator ==(PEERDIST_STREAM_HANDLE h1, PEERDIST_STREAM_HANDLE h2) => h1.Equals(h2); /// public override bool Equals(object obj) => obj is PEERDIST_STREAM_HANDLE h && handle == h.handle; /// public override int GetHashCode() => handle.GetHashCode(); /// public IntPtr DangerousGetHandle() => handle; } } }