mirror of https://github.com/dahall/Vanara.git
2077 lines
115 KiB
C#
2077 lines
115 KiB
C#
using System;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
|
|
namespace Vanara.PInvoke
|
|
{
|
|
/// <summary>Items from the PeerDist.dll</summary>
|
|
public static partial class PeerDist
|
|
{
|
|
private const string Lib_PeerDist = "PeerDist.dll";
|
|
|
|
/// <summary/>
|
|
public const uint PEERDIST_READ_TIMEOUT_DEFAULT = 0xfffffffe;
|
|
/// <summary/>
|
|
public const uint PEERDIST_READ_TIMEOUT_LOCAL_CACHE_ONLY = 0;
|
|
/// <summary/>
|
|
public const uint PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION = 2;
|
|
/// <summary/>
|
|
public const uint PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 = 1;
|
|
/// <summary/>
|
|
public const uint PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 = 2;
|
|
|
|
/// <summary>The <c>PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS</c> enumeration defines the possible client information values.</summary>
|
|
/// <remarks>
|
|
/// A value from this enumeration is passed to thePeerDistClientGetInformationByHandle function as the PeerDistClientInfoClass parameter.
|
|
/// </remarks>
|
|
// 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
|
|
{
|
|
/// <summary>Indicates the information to retrieve is a PEERDIST_CLIENT_BASIC_INFO structure.</summary>
|
|
PeerDistClientBasicInfo,
|
|
|
|
/// <summary>
|
|
/// The maximum value for the enumeration that is used for error checking. This value should not be sent to the
|
|
/// PeerDistClientGetInformationByHandle function.
|
|
/// </summary>
|
|
MaximumPeerDistClientInfoByHandlesClass,
|
|
}
|
|
|
|
/// <summary>The <c>PEERDIST_STATUS</c> enumeration defines the possible status values of the Peer Distribution service.</summary>
|
|
// 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
|
|
{
|
|
/// <summary>The service is disabled by Group Policy or according to configuration parameters.</summary>
|
|
PEERDIST_STATUS_DISABLED,
|
|
|
|
/// <summary>The service is not ready to process the request.</summary>
|
|
PEERDIST_STATUS_UNAVAILABLE,
|
|
|
|
/// <summary>The Peer Distribution service is available and ready to process requests.</summary>
|
|
PEERDIST_STATUS_AVAILABLE,
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistClientAddContentInformation</c> function adds the content information associated with a content handle opened by PeerDistClientOpenContent.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentHandle">A <c>PEERDIST_CONTENT_HANDLE</c> opened by PeerDistClientOpenContent.</param>
|
|
/// <param name="cbNumberOfBytes">Number of bytes in the pBuffer array.</param>
|
|
/// <param name="pBuffer">
|
|
/// 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.
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// 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.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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 <c>PeerDistClientAddContentInformation</c> function. When all content information data has
|
|
/// been added, the PeerDistClientCompleteContentInformation function must be called. Once
|
|
/// <c>PeerDistClientCompleteContentInformation</c> is complete, the client can call PeerDistClientStreamRead or
|
|
/// PeerDistClientBlockRead to retrieve the data from the Peer Distribution system.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// An application is not limited to adding content information with a single <c>PeerDistClientAddContentInformation</c> 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 <c>PeerDistClientAddContentInformation</c>. When the application is done adding the
|
|
/// entire content information, it must then call PeerDistClientCompleteContentInformation.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistClientAddData</c> 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
|
|
/// <c>ERROR_TIMEOUT</c> or <c>PEERDIST_ERROR_MISSING_DATA</c>.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentHandle">A <c>PEERDIST_CONTENT_HANDLE</c> returned by PeerDistClientOpenContent.</param>
|
|
/// <param name="cbNumberOfBytes">The number of bytes to be added to the local cache.</param>
|
|
/// <param name="pBuffer">
|
|
/// 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.
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// 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 <c>Offset</c> and <c>OffsetHigh</c> members of the OVERLAPPED structure. The <c>OffsetHigh</c> member
|
|
/// MUST be set to the higher 32 bits of the byte offset and the <c>Offset</c> member MUST be set to the lower 32 bits of the byte offset.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hContent handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the API completes with <c>PEERDIST_ERROR_OUT_OF_BOUNDS</c>, this indicates that the offset specified in the overlapped
|
|
/// structure is beyond the end of the content.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistClientBlockRead</c> function reads content data blocks.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentHandle">A content handle opened by PeerDistClientOpenContent function call.</param>
|
|
/// <param name="cbMaxNumberOfBytes">
|
|
/// The maximum number of bytes to read. If the cbMaxNumberOfBytesToRead is equal to 0, it indicates that the
|
|
/// <c>PeerDistClientBlockRead</c> 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.
|
|
/// </param>
|
|
/// <param name="pBuffer">
|
|
/// 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 <c>NULL</c>
|
|
/// </param>
|
|
/// <param name="dwTimeoutInMilliseconds">
|
|
/// <para>Timeout value for the read, in milliseconds. There are two special values that may be specified:</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PEERDIST_READ_TIMEOUT_LOCAL_CACHE_ONLY</term>
|
|
/// <term>Specifies that a read should not cause any additional network traffic by contacting peers or a Hosted Cache.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_READ_TIMEOUT_DEFAULT</term>
|
|
/// <term>Specifies the default timeout of 5 seconds.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// Pointer to an OVERLAPPED structure. The start offset for read is specified by setting the <c>Offset</c> and <c>OffsetHigh</c>
|
|
/// members of the OVERLAPPED structure. The <c>OffsetHigh</c> member should be set to the higher 32 bits of the start offset and
|
|
/// the <c>Offset</c> member should be set to the lower 32 bits of the start offset.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hContent handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// <c>PeerDistClientBlockRead</c> queues the read and immediately returns to the caller. As a result, multiple reads can be issued
|
|
/// simultaneously. <c>PeerDistClientBlockRead</c> will complete a read as soon as any data is available and will not wait for the
|
|
/// buffer to fill completely.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the <c>PeerDistClientBlockRead</c> function operation completes successfully, the <c>Offset</c> and <c>OffsetHigh</c> fields
|
|
/// of the OVERLAPPED structure will be populated with the <c>ULONGLONG</c> 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the cbMaxNumberOfBytesToRead argument is equal to 0, and the <c>PeerDistClientBlockRead</c> 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// When this API completes with error values <c>PEERDIST_ERROR_MISSING_DATA</c> or <c>ERROR_TIMEOUT</c>, the <c>Offset</c> and
|
|
/// <c>OffsetHigh</c> fields of the OVERLAPPED structure specify the <c>ULONGLONG</c> 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).
|
|
/// </para>
|
|
/// <para>
|
|
/// 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 <c>ERROR_NO_MORE</c> in this case indicates that the read offset is outside of the sub-range of
|
|
/// the content.
|
|
/// </para>
|
|
/// <para>Range Requests</para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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 <c>PEERDIST_CONTENT_HANDLE</c>
|
|
/// with the content range. PeerDistClientStreamRead is constrained by the ullContentOffset offset and cbContentLength length
|
|
/// specified in the server side call to PeerDistServerRetrieveContentInformation. <c>PeerDistClientStreamRead</c> will begin at
|
|
/// ullContentOffset and will complete with the error code <c>PEERDIST_ERROR_NO_MORE</c> when the end of the content range is
|
|
/// reached at ullContentOffset + cbContentLength. <c>PeerDistClientBlockRead</c> will complete with the error code
|
|
/// <c>PEERDIST_ERROR_NO_MORE</c> if the offset specified in the OVERLAPPED parameter is less than ullContentOffset or greater than
|
|
/// ullContentOffset + cbContentLength. <c>PeerDistClientStreamRead</c> and <c>PeerDistClientBlockRead</c> both limit the amount of
|
|
/// missing data reported to the content range specified in the content information associated with the
|
|
/// <c>PEERDIST_CONTENT_HANDLE</c>. 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, <c>PeerDistClientBlockRead</c> and
|
|
/// <c>PeerDistClientStreamRead</c> work with content ranges in exactly the same manner in which they work with the content as a whole.
|
|
/// </para>
|
|
/// <para>
|
|
/// A client can use PeerDistClientStreamRead or <c>PeerDistClientBlockRead</c> to retrieve the content from the offset specified by
|
|
/// the ullContentOffset up to the length specified by cbContentLength in the PeerDistServerRetrieveContentInformation call. Both
|
|
/// <c>PeerDistClientStreamRead</c> and <c>PeerDistClientBlockRead</c> will complete with <c>PEERDIST_ERROR_NO_MORE</c> if the
|
|
/// client tries to read beyond the range specified by the ullContentOffset and cbContentLength. Additionally,
|
|
/// <c>PeerDistClientBlockRead</c> will also complete with the error code <c>PEERDIST_ERROR_NO_MORE</c> if the offset specified in
|
|
/// the OVERLAPPED parameter is less than ullContentOffset
|
|
/// </para>
|
|
/// <para>
|
|
/// If the read cannot not be completed from either the local cache or the peer cache, both PeerDistClientStreamRead and
|
|
/// <c>PeerDistClientBlockRead</c> will report <c>PEERDIST_ERROR_MISSING_DATA</c>. When using the ranged content information,
|
|
/// <c>PeerDistClientStreamRead</c> will report a missing data from the start offset of the range up to the end of the range.
|
|
/// <c>PeerDistClientBlockRead</c> will report missing data from start offset of the range up to the end of the range.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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, <c>PeerDistClientAddData</c>
|
|
/// 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.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistClientCancelAsyncOperation</c> function cancels asynchronous operation associated with an OVERLAPPED structure
|
|
/// and the content handle returned by PeerDistClientOpenContent.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentHandle">A content handle opened by PeerDistClientOpenContent function call.</param>
|
|
/// <param name="pOverlapped">
|
|
/// Pointer to an OVERLAPPED structure that contains the canceling asynchronous operation data. If the pointer is <c>NULL</c> all
|
|
/// asynchronous operations for specified content handle will be canceled.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// The function will return <c>ERROR_SUCCESS</c> value if the operation associated with the specified OVERLAPPED structure is
|
|
/// successfully canceled. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_OPERATION_NOT_FOUND</term>
|
|
/// <term>The operation associated with the specified OVERLAPPED structure cannot be found.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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 <c>PeerDistClientCancelAsyncOperation</c> function returns.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>To confirm successfully canceled operations, a call should be made to GetOverlappedResult with an expected return of <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// Additionally, calling GetLastError immediately after a successful <c>PeerDistClientCancelAsyncOperation</c> will return the
|
|
/// <c>ERROR_OPERATION_ABORTED</c> error code.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistClientCloseContent</c> function closes the content handle opened by PeerDistClientOpenContent.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentHandle">A <c>PEERDIST_CONTENT_HANDLE</c> opened by PeerDistClientOpenContent.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hContent handle is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>This function will cancel all pending asynchronous operations associated with the provided hContentHandle.</para>
|
|
/// <para>All handles opened by the PeerDistClientOpenContent function must be closed by <c>PeerDistClientCloseContent</c>.</para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistClientCompleteContentInformation</c> function completes the process of adding the content information.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentHandle">A <c>PEERDIST_CONTENT_HANDLE</c> returned by PeerDistClientOpenContent.</param>
|
|
/// <param name="lpOverlapped">Pointer to an OVERLAPPED structure.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// Upon completion of this function, a client can call PeerDistClientStreamRead or PeerDistClientBlockRead to retrieve the data
|
|
/// from the Peer Distribution system.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The PEERDIST_CONTENT_TAG.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="pContentTag">
|
|
/// Pointer to a PEERDIST_CONTENT_TAG structure that contains the tag supplied when PeerDistClientOpenContent is called.
|
|
/// </param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored
|
|
/// when hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// Pointer to an OVERLAPPED structure. <c>Offset</c> and <c>OffsetHigh</c> are reserved and must be zero.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// 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.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistClientGetInformationByHandle</c> function retrieves additional information from the Peer Distribution service for
|
|
/// a specific content handle.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by the PeerDistStartup function.</param>
|
|
/// <param name="hContentHandle">A <c>PEERDIST_CONTENT_HANDLE</c> returned by the PeerDistClientOpenContent function.</param>
|
|
/// <param name="PeerDistClientInfoClass">
|
|
/// A value from the PEERDIST_CLIENT_INFO_BY_HANDLE_CLASS enumeration that indicates the information to retrieve.
|
|
/// </param>
|
|
/// <param name="dwBufferSize">The size, in bytes, of the buffer for the lpInformation parameter.</param>
|
|
/// <param name="lpInformation">
|
|
/// A buffer for the returned information. The format of this information depends on the value of the PeerDistClientInfoClass parameter.
|
|
/// </param>
|
|
/// <returns>If the function succeeds, the return value is ERROR_SUCCESS.</returns>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistClientOpenContent</c> function opens and returns a PEERDIST_CONTENT_HANDLE. The client uses the content handle to
|
|
/// retrieve data from the Peer Distribution service.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="pContentTag">
|
|
/// 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.
|
|
/// </param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored
|
|
/// when hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="phContentHandle">
|
|
/// A pointer to a variable that receives the <c>PEERDIST_CONTENT_HANDLE</c> used to retrieve or add data.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Client must call the <c>PeerDistClientOpenContent</c> function to obtain a <c>PEERDIST_CONTENT_HANDLE</c> handle that later can
|
|
/// be used in the following functions:
|
|
/// </para>
|
|
/// <list type="bullet">
|
|
/// <item>
|
|
/// <term>PeerDistClientAddContentInformation</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PeerDistClientCompleteContentInformation</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PeerDistClientBlockRead</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PeerDistClientStreamRead</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PeerDistClientAddData</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// <para>
|
|
/// If an optional completion port handle is specified, it is used for posting the completion results of above listed asynchronous functions.
|
|
/// </para>
|
|
/// <para>The handle returned by <c>PeerDistClientOpenContent</c> function call must be closed by PeerDistClientCloseContent function.</para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistClientStreamRead</c> reads a sequence of bytes from content stream.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentHandle">A content handle opened by the PeerDistClientOpenContent function call.</param>
|
|
/// <param name="cbMaxNumberOfBytes">
|
|
/// The maximum number of bytes to read. If the cbMaxNumberOfBytesToRead is equal to 0, it indicates that the
|
|
/// <c>PeerDistClientStreamRead</c> 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.
|
|
/// </param>
|
|
/// <param name="pBuffer">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="dwTimeoutInMilliseconds">
|
|
/// <para>Timeout value for the read, in milliseconds. There are two special values that may be specified:</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PEERDIST_READ_TIMEOUT_LOCAL_CACHE_ONLY</term>
|
|
/// <term>Specifies that a read should not cause any additional network traffic by contacting peers or a Hosted Cache.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_READ_TIMEOUT_DEFAULT</term>
|
|
/// <term>Specifies the default timeout of 5 seconds.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// Pointer to an OVERLAPPED structure. Stream read does not allow the caller to specify the start <c>Offset</c> for the reading.
|
|
/// The next stream read offset is implicitly maintained per hContentHandle.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hContent handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// <c>PeerDistClientStreamRead</c> 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. <c>PeerDistClientStreamRead</c> will complete a
|
|
/// read as soon as any data is available and will not wait for the buffer to fill completely.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the <c>PeerDistClientStreamRead</c> function operation completes successfully, the <c>Offset</c> and <c>OffsetHigh</c> fields
|
|
/// of the OVERLAPPED structure will be populated with the <c>ULONGLONG</c> 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// If the API completes with the error value <c>PEERDIST_ERROR_MISSING_DATA</c> or <c>ERROR_TIMEOUT</c>, the <c>Offset</c> and
|
|
/// <c>OffsetHigh</c> fields of the OVERLAPPED structure specify the <c>ULONGLONG</c> offset at which the missing data range begins.
|
|
/// The <c>OffsetHigh</c> member will be set to the higher 32 bits of the offset and the <c>Offset</c> 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// If <c>PeerDistClientStreamRead</c> is called after the stream offset has advanced beyond the end of the content, the API will
|
|
/// complete with <c>ERROR_NO_MORE</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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 <c>ERROR_NO_MORE</c> in this case indicates that the read offset is outside of the sub-range of
|
|
/// the content.
|
|
/// </para>
|
|
/// <para>Range Requests</para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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 <c>PEERDIST_CONTENT_HANDLE</c>
|
|
/// with the content range. <c>PeerDistClientStreamRead</c> is constrained by the ullContentOffset offset and cbContentLength length
|
|
/// specified in the server side call to PeerDistServerRetrieveContentInformation. <c>PeerDistClientStreamRead</c> will begin at
|
|
/// ullContentOffset and will complete with the error code <c>PEERDIST_ERROR_NO_MORE</c> when the end of the content range is
|
|
/// reached at ullContentOffset + cbContentLength. PeerDistClientBlockRead will complete with the error code
|
|
/// <c>PEERDIST_ERROR_NO_MORE</c> if the offset specified in the OVERLAPPED parameter is less than ullContentOffset or greater than
|
|
/// ullContentOffset + cbContentLength. <c>PeerDistClientStreamRead</c> and <c>PeerDistClientBlockRead</c> both limit the amount of
|
|
/// missing data reported to the content range specified in the content information associated with the
|
|
/// <c>PEERDIST_CONTENT_HANDLE</c>. 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, <c>PeerDistClientBlockRead</c> and
|
|
/// <c>PeerDistClientStreamRead</c> work with content ranges in exactly the same manner in which they work with the content as a whole.
|
|
/// </para>
|
|
/// <para>
|
|
/// A client can use <c>PeerDistClientStreamRead</c> 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
|
|
/// <c>PeerDistClientStreamRead</c> and <c>PeerDistClientBlockRead</c> will complete with <c>PEERDIST_ERROR_NO_MORE</c> if the
|
|
/// client tries to read beyond the range specified by the ullContentOffset and cbContentLength. Additionally,
|
|
/// <c>PeerDistClientBlockRead</c> will also complete with the error code <c>PEERDIST_ERROR_NO_MORE</c> if the offset specified in
|
|
/// the OVERLAPPED parameter is less than ullContentOffset
|
|
/// </para>
|
|
/// <para>
|
|
/// If the read cannot not be completed from either the local cache or the peer cache, both <c>PeerDistClientStreamRead</c> and
|
|
/// PeerDistClientBlockRead will report <c>PEERDIST_ERROR_MISSING_DATA</c>. When using the ranged content information,
|
|
/// <c>PeerDistClientStreamRead</c> will report a missing data from the start offset of the range up to the end of the range.
|
|
/// <c>PeerDistClientBlockRead</c> will report missing data from start offset of the range up to the end of the range.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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, <c>PeerDistClientAddData</c>
|
|
/// 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.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistGetOverlappedResult</c> function retrieves the results of asynchronous operations. This function replaces the
|
|
/// GetOverlappedResult function for Peer Distribution asynchronous operations.
|
|
/// </summary>
|
|
/// <param name="lpOverlapped">A pointer to an OVERLAPPED structure that was specified when the overlapped operation was started.</param>
|
|
/// <param name="lpNumberOfBytesTransferred">
|
|
/// A pointer to a variable that receives the number of bytes that were actually transferred by a read or write operation.
|
|
/// </param>
|
|
/// <param name="bWait">
|
|
/// If this parameter is
|
|
/// <code>true</code>
|
|
/// , the function does not return until the operation has been completed. If this parameter is
|
|
/// <code>false</code>
|
|
/// and the operation is still pending, the function returns
|
|
/// <code>false</code>
|
|
/// .
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>Type: <c>BOOL</c></para>
|
|
/// <para>
|
|
/// <code>true</code>
|
|
/// if the operation has completed.
|
|
/// <code>false</code>
|
|
/// if the bWait argument is
|
|
/// <code>false</code>
|
|
/// and the operation is still pending.
|
|
/// </para>
|
|
/// </returns>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistGetStatus</c> function returns the current status of the Peer Distribution service.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="pPeerDistStatus">
|
|
/// A pointer to a PEERDIST_STATUS enumeration which upon operation success receives the current status of the Peer Distribution service.
|
|
/// </param>
|
|
/// <returns>If the function succeeds, the return value is <c>ERROR_SUCCESS</c>.</returns>
|
|
/// <remarks>
|
|
/// 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.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistGetStatusEx</c> function returns the current status and capabilities of the Peer Distribution service.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="pPeerDistStatus">
|
|
/// A pointer to a PEERDIST_STATUS_INFO structure that contains the current status and capabilities of the Peer Distribution service.
|
|
/// </param>
|
|
/// <returns>If the function succeeds, the return value is <c>ERROR_SUCCESS</c>.</returns>
|
|
/// <remarks>
|
|
/// 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.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistRegisterForStatusChangeNotification</c> function requests the Peer Distribution service status change notification.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored
|
|
/// when hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// Pointer to an OVERLAPPED structure. If the <c>hEvent</c> member of the structure is not <c>NULL</c>, 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.
|
|
/// </param>
|
|
/// <param name="pPeerDistStatus">
|
|
/// A pointer to a PEERDIST_STATUS enumeration that indicates the current status of the Peer Distribution service.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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 <c>PEERDIST_STATUS</c> value.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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
|
|
/// <c>PeerDistRegisterForStatusChangeNotification</c> function for the Peer Distribution session, the first notification will
|
|
/// trigger only if the status is no longer equal to <c>PEERDIST_STATUS_DISABLED</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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 <c>PEERDIST_
|
|
/// ERROR_INVALIDATED</c>. The caller must explicitly close the handles by calling the appropriate Peer Distribution API.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistRegisterForStatusChangeNotificationEx</c> function requests the Peer Distribution service status change notification.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored
|
|
/// when hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// Pointer to an OVERLAPPED structure. If the <c>hEvent</c> member of the structure is not <c>NULL</c>, 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.
|
|
/// </param>
|
|
/// <param name="pPeerDistStatus">
|
|
/// A pointer to a PEERDIST_STATUS_INFO structure that contains the current status and capabilities of the Peer Distribution service.
|
|
/// </param>
|
|
/// <returns>If the function succeeds, the return value is ERROR_SUCCESS.</returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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 <c>PEERDIST_STATUS</c> value.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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 <c>PEERDIST_STATUS_DISABLED</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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 <c>PEERDIST_
|
|
/// ERROR_INVALIDATED</c>. The caller must explicitly close the handles by calling the appropriate Peer Distribution API.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistServerCancelAsyncOperation</c> function cancels the asynchronous operation associated with the content identifier
|
|
/// and OVERLAPPED structure.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="cbContentIdentifier">The length, in bytes, of the content identifier.</param>
|
|
/// <param name="pContentIdentifier">Pointer to an array that contains the content identifier.</param>
|
|
/// <param name="pOverlapped">Pointer to an OVERLAPPED structure that contains the canceling asynchronous operation data.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// The function will return <c>ERROR_SUCCESS</c> value if the operation associated with OVERLAPPED structure is successfully
|
|
/// canceled. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_OPERATION_NOT_FOUND</term>
|
|
/// <term>The operation for OVERLAPPED structure cannot be found.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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 <c>PeerDistServerCancelAsyncOperation</c> function returns.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>To confirm successfully canceled operations, a call should be made to GetOverlappedResult with an expected return of <c>FALSE</c>.</para>
|
|
/// <para>
|
|
/// Additionally, calling GetLastError immediately after a successful <c>PeerDistServerCancelAsyncOperation</c> will return the
|
|
/// <c>ERROR_OPERATION_ABORTED</c> error code.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistServerCloseContentInformation</c> function closes the handle opened by PeerDistServerOpenContentInformation.</summary>
|
|
/// <param name="hPeerDist">The <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="hContentInfo">The handle returned by PeerDistServerOpenContentInformation.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The provided hPeerDist or hContentInfo handles are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// The <c>PeerDistServerCloseContentInformation</c> closes the <c>PEERDIST_CONTENTINFO_HANDLE</c>. Additionally, calling
|
|
/// <c>PeerDistServerCloseContentInformation</c> will cancel any pending operations associated with the <c>PEERDIST_CONTENTINFO_HANDLE</c>.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistServerCloseStreamHandle</c> function closes a handle returned by PeerDistServerPublishStream.</summary>
|
|
/// <param name="hPeerDist">A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup.</param>
|
|
/// <param name="hStream">A PEERDIST_STREAM_HANDLE returned by PeerDistServerPublishStream.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hStream handle is invalid</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The <c>PeerDistServerCloseStreamHandle</c> 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.
|
|
/// </para>
|
|
/// <para><c>PeerDistServerCloseStreamHandle</c> does not remove the publication. In order to remove the publication, call PeerDistServerUnpublish.</para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistServerOpenContentInformation</c> function opens a <c>PEERDIST_CONTENTINFO_HANDLE</c>. The client uses the handle
|
|
/// to retrieve content information.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="cbContentIdentifier">The length, in bytes, of the content identifier.</param>
|
|
/// <param name="pContentIdentifier">Pointer to a buffer that contains the content identifier.</param>
|
|
/// <param name="ullContentOffset">
|
|
/// An offset from the beginning of the published content for which the content information handle is requested.
|
|
/// </param>
|
|
/// <param name="cbContentLength">
|
|
/// The length, in bytes, of the content (starting from the ullContentOffset) for which the content information is requested.
|
|
/// </param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored
|
|
/// when hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="phContentInfo">A handle used to retrieve the content information.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_NOT_FOUND</term>
|
|
/// <term>The specified content identifier data is not published.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>If ullContentOffset and cbContentLength are both zero, then the content information for the whole content will be retrieved.</para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistServerOpenContentInformationEx</c> function opens a <c>PEERDIST_CONTENTINFO_HANDLE</c>. The client uses the
|
|
/// handle to retrieve content information.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="cbContentIdentifier">The length, in bytes, of the content identifier.</param>
|
|
/// <param name="pContentIdentifier">Pointer to a buffer that contains the content identifier.</param>
|
|
/// <param name="ullContentOffset">
|
|
/// An offset from the beginning of the published content for which the content information handle is requested.
|
|
/// </param>
|
|
/// <param name="cbContentLength">
|
|
/// The length, in bytes, of the content (starting from the ullContentOffset) for which the content information is requested.
|
|
/// </param>
|
|
/// <param name="pRetrievalOptions">A PEER_RETRIEVAL_OPTIONS structure specifying additional options for retrieving content information.</param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value to be returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored
|
|
/// when hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="phContentInfo">A handle used to retrieve the content information.</param>
|
|
/// <returns>If the function succeeds, the return value is <c>ERROR_SUCCESS</c>.</returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>If ullContentOffset and cbContentLength are both zero, then the content information for the whole content will be retrieved.</para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistServerPublishAddToStream</c> function adds data to the publishing stream.</summary>
|
|
/// <param name="hPeerDist">A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup.</param>
|
|
/// <param name="hStream">A PEERDIST_STREAM_HANDLE created by PeerDistServerPublishStream.</param>
|
|
/// <param name="cbNumberOfBytes">Number of bytes to be published.</param>
|
|
/// <param name="pBuffer">
|
|
/// 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.
|
|
/// </param>
|
|
/// <param name="lpOverlapped">
|
|
/// Pointer to an OVERLAPPED structure. The <c>Offset</c> and <c>OffsetHigh</c> members are reserved and must be zero.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hStream handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_OPERATION_ABORTED</term>
|
|
/// <term>The operation was canceled.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// 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.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistServerPublishCompleteStream</c> function completes the process of adding data to the stream.</summary>
|
|
/// <param name="hPeerDist">A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup.</param>
|
|
/// <param name="hStream">A PEERDIST_STREAM_HANDLE returned by PeerDistServerPublishStream.</param>
|
|
/// <param name="lpOverlapped">
|
|
/// Pointer to an OVERLAPPED structure. The <c>Offset</c> and <c>OffsetHigh</c> are reserved and must be zero.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hStream handle is invalid</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_OPERATION_ABORTED</term>
|
|
/// <term>The operation was canceled.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Once this API completes successfully, PeerDistServerOpenContentInformation and PeerDistServerRetrieveContentInformation can be
|
|
/// used to retrieve content information.
|
|
/// </para>
|
|
/// <para><c>PeerDistServerPublishCompleteStream</c> does not close hStream. In order to close hStream, call PeerDistServerCloseStreamHandle.</para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistServerPublishStream</c> function initializes a new stream to be published to the Peer Distribution service.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup.</param>
|
|
/// <param name="cbContentIdentifier">The length, in bytes, of the buffer that contains content identifier data.</param>
|
|
/// <param name="pContentIdentifier">A pointer to an array that contains a content identifier data.</param>
|
|
/// <param name="cbContentLength">
|
|
/// 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.
|
|
/// </param>
|
|
/// <param name="pPublishOptions">Pointer to a PEERDIST_PUBLICATION_OPTIONS structure that specifies content publishing rules.</param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored when
|
|
/// hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="phStream">
|
|
/// A pointer that receives a handle to the stream that is used to publish data into the Peer Distribution service.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The specified hPeerDist is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_ALREADY_EXISTS</term>
|
|
/// <term>The content identifier used for publication is already published.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// A content identifier is a user defined label for the content being published. This content identifier is used for
|
|
/// PeerDistServerOpenContentInformation, PeerDistServerUnpublish, and PeerDistServerCancelAsyncOperation calls.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// A publication is accessible only to the User Account that originally published the content. If a different user calls
|
|
/// <c>PeerDistServerPublishStream</c> with the same content identifier, a separate publication will be created under the context of
|
|
/// that user.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistServerPublishStream</c> function initializes a new stream to be published to the Peer Distribution service.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup.</param>
|
|
/// <param name="cbContentIdentifier">The length, in bytes, of the buffer that contains content identifier data.</param>
|
|
/// <param name="pContentIdentifier">A pointer to an array that contains a content identifier data.</param>
|
|
/// <param name="cbContentLength">
|
|
/// 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.
|
|
/// </param>
|
|
/// <param name="pPublishOptions">Pointer to a PEERDIST_PUBLICATION_OPTIONS structure that specifies content publishing rules.</param>
|
|
/// <param name="hCompletionPort">
|
|
/// 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 <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="ulCompletionKey">
|
|
/// Value returned through the lpCompletionKey parameter of the GetQueuedCompletionStatus function. This parameter is ignored when
|
|
/// hCompletionPort is <c>NULL</c>.
|
|
/// </param>
|
|
/// <param name="phStream">
|
|
/// A pointer that receives a handle to the stream that is used to publish data into the Peer Distribution service.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The specified hPeerDist is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_ALREADY_EXISTS</term>
|
|
/// <term>The content identifier used for publication is already published.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// A content identifier is a user defined label for the content being published. This content identifier is used for
|
|
/// PeerDistServerOpenContentInformation, PeerDistServerUnpublish, and PeerDistServerCancelAsyncOperation calls.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <para>
|
|
/// A publication is accessible only to the User Account that originally published the content. If a different user calls
|
|
/// <c>PeerDistServerPublishStream</c> with the same content identifier, a separate publication will be created under the context of
|
|
/// that user.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistServerRetrieveContentInformation</c> function retrieves the encoded content information associated with a handle
|
|
/// returned by PeerDistServerOpenContentInformation.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A PEERDIST_INSTANCE_HANDLE returned by PeerDistStartup.</param>
|
|
/// <param name="hContentInfo">The handle returned by PeerDistServerOpenContentInformation.</param>
|
|
/// <param name="cbMaxNumberOfBytes">The maximum number of bytes to read.</param>
|
|
/// <param name="pBuffer">Pointer to the buffer that receives the content information data.</param>
|
|
/// <param name="lpOverlapped">
|
|
/// 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.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_IO_PENDING</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist or hContentInfo handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_NO_MORE</term>
|
|
/// <term>EOF on the content information has been reached.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// On the success of the <c>PeerDistServerRetrieveContentInformation</c> operation, the <c>Offset</c> and <c>OffsetHigh</c> fields
|
|
/// of the OVERLAPPED structure will be populated with the <c>ULONGLONG</c> offset in the content information that was retrieved.
|
|
/// The <c>OffsetHigh</c> member will be set to the higher 32 bits of the offset and the <c>Offset</c> member will be set to the
|
|
/// lower 32 bits of the offset.
|
|
/// </para>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>The <c>PeerDistServerUnpublish</c> function removes a publication created via PeerDistServerPublishStream.</summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <param name="cbContentIdentifier">The length, in bytes, of the content identifier.</param>
|
|
/// <param name="pContentIdentifier">Pointer to a buffer that contains the content identifier.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_ACCESS_DISABLED_BY_POLICY</term>
|
|
/// <term>The feature is disabled by Group Policy.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_SERVICE_UNAVAILABLE</term>
|
|
/// <term>The service is unavailable.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// The <c>PeerDistServerUnpublish</c> 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.
|
|
/// </para>
|
|
/// <para>A publication is accessible only to the User Account that originally published the content.</para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistShutdown</c> function releases resources allocated by a call to PeerDistStartup. Each handle returned by a
|
|
/// <c>PeerDistStartup</c> call must be closed by a matching call to <c>PeerDistShutdown</c>
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// 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 <c>PeerDistShutdown</c> cancel all pending Peer Distribution
|
|
/// client and server operations associated with the supplied <c>PEERDIST_INSTANCE_HANDLE</c>.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistStartup</c> function creates a new Peer Distribution instance handle which must be passed to all other Peer
|
|
/// Distribution APIs.
|
|
/// </summary>
|
|
/// <param name="dwVersionRequested">
|
|
/// 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.
|
|
/// </param>
|
|
/// <param name="phPeerDist">
|
|
/// A pointer to a <c>PEERDIST_INSTANCE_HANDLE</c> variable which upon success receives a newly created handle.
|
|
/// </param>
|
|
/// <param name="pdwSupportedVersion">
|
|
/// A pointer to a variable which, if not <c>NULL</c>, 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.
|
|
/// </param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_ERROR_VERSION_UNSUPPORTED</term>
|
|
/// <term>The requested version is not supported by client side DLL.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <c>PeerDistStartup</c> must be called before any other Peer Distribution functions. When no longer needed, the handle returned
|
|
/// by <c>PeerDistStartup</c> should be closed via a call to PeerDistShutdown.
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PeerDistUnregisterForStatusChangeNotification</c> function unregisters the status change notification for the session
|
|
/// associated with the specified handle.
|
|
/// </summary>
|
|
/// <param name="hPeerDist">A <c>PEERDIST_INSTANCE_HANDLE</c> returned by PeerDistStartup.</param>
|
|
/// <returns>
|
|
/// <para>
|
|
/// If the function succeeds, the return value is <c>ERROR_SUCCESS</c>. Otherwise, the function may return one of the following values:
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Return code</term>
|
|
/// <term>Description</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_PARAMETER</term>
|
|
/// <term>One or more parameters are invalid.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>ERROR_INVALID_HANDLE</term>
|
|
/// <term>The hPeerDist handle is invalid.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </returns>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// This function cancels any registered notification previously set by a PeerDistRegisterForStatusChangeNotification function call.
|
|
/// </para>
|
|
/// <para>
|
|
/// To confirm successfully canceled operations, a call should be made to GetOverlappedResult using the <c>OVERLAPPED</c> structure
|
|
/// returned by GetQueuedCompletionStatus with an expected return of <c>FALSE</c>.
|
|
/// </para>
|
|
/// <para>
|
|
/// Additionally, calling GetLastError immediately after a successful PeerDistRegisterForStatusChangeNotification will return the
|
|
/// <c>ERROR_OPERATION_ABORTED</c> error code.
|
|
/// </para>
|
|
/// </remarks>
|
|
// 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);
|
|
|
|
/// <summary>
|
|
/// The <c>PEERDIST_CLIENT_BASIC_INFO</c> structure indicates whether or not there are many clients simultaneously downloading the
|
|
/// same content.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// <para>
|
|
/// Thie <c>PEERDIST_CLIENT_BASIC_INFO</c> structure is retrieved from the PeerDistClientGetInformationHandle function with
|
|
/// PeerDistClientBasicInfo value specified for the PeerDistClientInfoClass parameter.
|
|
/// </para>
|
|
/// <para>If true, content that cannot be retrieved from the Peer Distribution APIs may soon be available for retrieval.</para>
|
|
/// </remarks>
|
|
// 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
|
|
{
|
|
/// <summary>
|
|
/// Indicates that a "flash crowd" situation has been detected, where many clients in the branch office are simultaneously
|
|
/// downloading the same content.
|
|
/// </summary>
|
|
[MarshalAs(UnmanagedType.Bool)]
|
|
public bool fFlashCrowd;
|
|
}
|
|
|
|
/// <summary>Provides a handle to peer distribution conent.</summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct PEERDIST_CONTENT_HANDLE : IHandle
|
|
{
|
|
private IntPtr handle;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="PEERDIST_CONTENT_HANDLE"/> struct.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
public PEERDIST_CONTENT_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle;
|
|
|
|
/// <summary>Returns an invalid handle by instantiating a <see cref="PEERDIST_CONTENT_HANDLE"/> object with <see cref="IntPtr.Zero"/>.</summary>
|
|
public static PEERDIST_CONTENT_HANDLE NULL => new PEERDIST_CONTENT_HANDLE(IntPtr.Zero);
|
|
|
|
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
|
|
public bool IsNull => handle == IntPtr.Zero;
|
|
|
|
/// <summary>Performs an explicit conversion from <see cref="PEERDIST_CONTENT_HANDLE"/> to <see cref="IntPtr"/>.</summary>
|
|
/// <param name="h">The handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static explicit operator IntPtr(PEERDIST_CONTENT_HANDLE h) => h.handle;
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="PEERDIST_CONTENT_HANDLE"/>.</summary>
|
|
/// <param name="h">The pointer to a handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator PEERDIST_CONTENT_HANDLE(IntPtr h) => new PEERDIST_CONTENT_HANDLE(h);
|
|
|
|
/// <summary>Implements the operator !=.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator !=(PEERDIST_CONTENT_HANDLE h1, PEERDIST_CONTENT_HANDLE h2) => !(h1 == h2);
|
|
|
|
/// <summary>Implements the operator ==.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator ==(PEERDIST_CONTENT_HANDLE h1, PEERDIST_CONTENT_HANDLE h2) => h1.Equals(h2);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Equals(object obj) => obj is PEERDIST_CONTENT_HANDLE h && handle == h.handle;
|
|
|
|
/// <inheritdoc/>
|
|
public override int GetHashCode() => handle.GetHashCode();
|
|
|
|
/// <inheritdoc/>
|
|
public IntPtr DangerousGetHandle() => handle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>PEERDIST_CONTENT_TAG</c> structure contains a client supplied content tag as an input to the PeerDistClientOpenContent API.
|
|
/// </summary>
|
|
// 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
|
|
{
|
|
/// <summary>A 16 byte tag associated with the open content.</summary>
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public byte[] Data;
|
|
}
|
|
|
|
/// <summary>Provides a handle to peer distribution content info.</summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct PEERDIST_CONTENTINFO_HANDLE : IHandle
|
|
{
|
|
private IntPtr handle;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="PEERDIST_CONTENTINFO_HANDLE"/> struct.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
public PEERDIST_CONTENTINFO_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle;
|
|
|
|
/// <summary>Returns an invalid handle by instantiating a <see cref="PEERDIST_CONTENTINFO_HANDLE"/> object with <see cref="IntPtr.Zero"/>.</summary>
|
|
public static PEERDIST_CONTENTINFO_HANDLE NULL => new PEERDIST_CONTENTINFO_HANDLE(IntPtr.Zero);
|
|
|
|
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
|
|
public bool IsNull => handle == IntPtr.Zero;
|
|
|
|
/// <summary>Performs an explicit conversion from <see cref="PEERDIST_CONTENTINFO_HANDLE"/> to <see cref="IntPtr"/>.</summary>
|
|
/// <param name="h">The handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static explicit operator IntPtr(PEERDIST_CONTENTINFO_HANDLE h) => h.handle;
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="PEERDIST_CONTENTINFO_HANDLE"/>.</summary>
|
|
/// <param name="h">The pointer to a handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator PEERDIST_CONTENTINFO_HANDLE(IntPtr h) => new PEERDIST_CONTENTINFO_HANDLE(h);
|
|
|
|
/// <summary>Implements the operator !=.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator !=(PEERDIST_CONTENTINFO_HANDLE h1, PEERDIST_CONTENTINFO_HANDLE h2) => !(h1 == h2);
|
|
|
|
/// <summary>Implements the operator ==.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator ==(PEERDIST_CONTENTINFO_HANDLE h1, PEERDIST_CONTENTINFO_HANDLE h2) => h1.Equals(h2);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Equals(object obj) => obj is PEERDIST_CONTENTINFO_HANDLE h && handle == h.handle;
|
|
|
|
/// <inheritdoc/>
|
|
public override int GetHashCode() => handle.GetHashCode();
|
|
|
|
/// <inheritdoc/>
|
|
public IntPtr DangerousGetHandle() => handle;
|
|
}
|
|
|
|
/// <summary>Provides a handle to a peer distribution instance.</summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct PEERDIST_INSTANCE_HANDLE : IHandle
|
|
{
|
|
private IntPtr handle;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="PEERDIST_INSTANCE_HANDLE"/> struct.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
public PEERDIST_INSTANCE_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle;
|
|
|
|
/// <summary>Returns an invalid handle by instantiating a <see cref="PEERDIST_INSTANCE_HANDLE"/> object with <see cref="IntPtr.Zero"/>.</summary>
|
|
public static PEERDIST_INSTANCE_HANDLE NULL => new PEERDIST_INSTANCE_HANDLE(IntPtr.Zero);
|
|
|
|
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
|
|
public bool IsNull => handle == IntPtr.Zero;
|
|
|
|
/// <summary>Performs an explicit conversion from <see cref="PEERDIST_INSTANCE_HANDLE"/> to <see cref="IntPtr"/>.</summary>
|
|
/// <param name="h">The handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static explicit operator IntPtr(PEERDIST_INSTANCE_HANDLE h) => h.handle;
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="PEERDIST_INSTANCE_HANDLE"/>.</summary>
|
|
/// <param name="h">The pointer to a handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator PEERDIST_INSTANCE_HANDLE(IntPtr h) => new PEERDIST_INSTANCE_HANDLE(h);
|
|
|
|
/// <summary>Implements the operator !=.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator !=(PEERDIST_INSTANCE_HANDLE h1, PEERDIST_INSTANCE_HANDLE h2) => !(h1 == h2);
|
|
|
|
/// <summary>Implements the operator ==.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator ==(PEERDIST_INSTANCE_HANDLE h1, PEERDIST_INSTANCE_HANDLE h2) => h1.Equals(h2);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Equals(object obj) => obj is PEERDIST_INSTANCE_HANDLE h && handle == h.handle;
|
|
|
|
/// <inheritdoc/>
|
|
public override int GetHashCode() => handle.GetHashCode();
|
|
|
|
/// <inheritdoc/>
|
|
public IntPtr DangerousGetHandle() => handle;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>PEERDIST_PUBLICATION_OPTIONS</c> structure contains publication options, including the API version information and
|
|
/// possible option flags.
|
|
/// </summary>
|
|
// 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
|
|
{
|
|
/// <summary>
|
|
/// <para>The following possible values reflect the version number of the client:</para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>1</term>
|
|
/// <term>Version 1.0</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>2</term>
|
|
/// <term>Version 2.0</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public uint dwVersion;
|
|
|
|
/// <summary>Reserved.</summary>
|
|
public uint dwFlags;
|
|
}
|
|
|
|
/// <summary>The <c>PEER_RETRIEVAL_OPTIONS</c> structure contains version of the content information to retrieve.</summary>
|
|
// 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
|
|
{
|
|
/// <summary>Specifies the size of the input structure.</summary>
|
|
public uint cbSize;
|
|
|
|
/// <summary>
|
|
/// <para>Specifies the minimum version of the content information to retrieve. Must be set to one of the following values:</para>
|
|
/// <para>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION</para>
|
|
/// <para>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1</para>
|
|
/// <para>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2</para>
|
|
/// </summary>
|
|
public uint dwContentInfoMinVersion;
|
|
|
|
/// <summary>
|
|
/// <para>Specifies the maximum version of the content information to retrieve. Must be set to one of the following values:</para>
|
|
/// <para>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION</para>
|
|
/// <para>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1</para>
|
|
/// <para>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2</para>
|
|
/// </summary>
|
|
public uint dwContentInfoMaxVersion;
|
|
|
|
/// <summary>Reserved. The <c>dwReserved</c> member should be set to 0.</summary>
|
|
public uint dwReserved;
|
|
}
|
|
|
|
/// <summary>
|
|
/// The <c>PEERDIST_STATUS_INFO</c> structure contains information about the current status and capabilities of the BranchCache
|
|
/// service on the local computer.
|
|
/// </summary>
|
|
// 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
|
|
{
|
|
/// <summary>Size, in bytes, of the <c>PEERDIST_STATUS_INFO</c> structure.</summary>
|
|
public uint cbSize;
|
|
|
|
/// <summary>
|
|
/// Specifies the current status of the BranchCache service. This member should be one of following values defined in the
|
|
/// PEERDIST_STATUS enumeration.
|
|
/// </summary>
|
|
public PEERDIST_STATUS status;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 1</term>
|
|
/// <term>Windows 7 compatible content information format.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 2</term>
|
|
/// <term>Windows 8 content information format.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public uint dwMinVer;
|
|
|
|
/// <summary>
|
|
/// <para>
|
|
/// 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.
|
|
/// </para>
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Value</term>
|
|
/// <term>Meaning</term>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_1 1</term>
|
|
/// <term>Windows 7 compatible content information format.</term>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term>PEERDIST_RETRIEVAL_OPTIONS_CONTENTINFO_VERSION_2 2</term>
|
|
/// <term>Windows 8 content information format.</term>
|
|
/// </item>
|
|
/// </list>
|
|
/// </summary>
|
|
public uint dwMaxVer;
|
|
}
|
|
|
|
/// <summary>Provides a handle to a peer distribution stream.</summary>
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct PEERDIST_STREAM_HANDLE : IHandle
|
|
{
|
|
private IntPtr handle;
|
|
|
|
/// <summary>Initializes a new instance of the <see cref="PEERDIST_STREAM_HANDLE"/> struct.</summary>
|
|
/// <param name="preexistingHandle">An <see cref="IntPtr"/> object that represents the pre-existing handle to use.</param>
|
|
public PEERDIST_STREAM_HANDLE(IntPtr preexistingHandle) => handle = preexistingHandle;
|
|
|
|
/// <summary>Returns an invalid handle by instantiating a <see cref="PEERDIST_STREAM_HANDLE"/> object with <see cref="IntPtr.Zero"/>.</summary>
|
|
public static PEERDIST_STREAM_HANDLE NULL => new PEERDIST_STREAM_HANDLE(IntPtr.Zero);
|
|
|
|
/// <summary>Gets a value indicating whether this instance is a null handle.</summary>
|
|
public bool IsNull => handle == IntPtr.Zero;
|
|
|
|
/// <summary>Performs an explicit conversion from <see cref="PEERDIST_STREAM_HANDLE"/> to <see cref="IntPtr"/>.</summary>
|
|
/// <param name="h">The handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static explicit operator IntPtr(PEERDIST_STREAM_HANDLE h) => h.handle;
|
|
|
|
/// <summary>Performs an implicit conversion from <see cref="IntPtr"/> to <see cref="PEERDIST_STREAM_HANDLE"/>.</summary>
|
|
/// <param name="h">The pointer to a handle.</param>
|
|
/// <returns>The result of the conversion.</returns>
|
|
public static implicit operator PEERDIST_STREAM_HANDLE(IntPtr h) => new PEERDIST_STREAM_HANDLE(h);
|
|
|
|
/// <summary>Implements the operator !=.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator !=(PEERDIST_STREAM_HANDLE h1, PEERDIST_STREAM_HANDLE h2) => !(h1 == h2);
|
|
|
|
/// <summary>Implements the operator ==.</summary>
|
|
/// <param name="h1">The first handle.</param>
|
|
/// <param name="h2">The second handle.</param>
|
|
/// <returns>The result of the operator.</returns>
|
|
public static bool operator ==(PEERDIST_STREAM_HANDLE h1, PEERDIST_STREAM_HANDLE h2) => h1.Equals(h2);
|
|
|
|
/// <inheritdoc/>
|
|
public override bool Equals(object obj) => obj is PEERDIST_STREAM_HANDLE h && handle == h.handle;
|
|
|
|
/// <inheritdoc/>
|
|
public override int GetHashCode() => handle.GetHashCode();
|
|
|
|
/// <inheritdoc/>
|
|
public IntPtr DangerousGetHandle() => handle;
|
|
}
|
|
}
|
|
} |