qshelpr.c File Reference

#include <ws2_32.h>
#include <debug.h>

Include dependency graph for qshelpr.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
LPSTR WSAAPI	AnsiDupFromUnicode (IN LPCWSTR UnicodeString)
LPWSTR WSAAPI	UnicodeDupFromAnsi (IN LPCSTR AnsiString)
SIZE_T WSAAPI	ComputeStringSize (IN LPSTR String, IN BOOLEAN IsUnicode)
SIZE_T WSAAPI	ComputeQuerySetSize (IN LPWSAQUERYSETA AnsiSet, IN BOOLEAN IsUnicode)
SIZE_T WSAAPI	WSAComputeQuerySetSizeA (IN LPWSAQUERYSETA AnsiSet)
SIZE_T WSAAPI	WSAComputeQuerySetSizeW (IN LPWSAQUERYSETW UnicodeSet)
PVOID WSAAPI	WsBufferAllocate (IN PWS_BUFFER Buffer, IN SIZE_T Size, IN DWORD Align)
VOID WSAAPI	CopyBlobIndirect (IN PWS_BUFFER Buffer, IN OUT LPBLOB RelativeBlob, IN LPBLOB Blob)
VOID WSAAPI	CopyAddrInfoArrayIndirect (IN PWS_BUFFER Buffer, IN OUT LPCSADDR_INFO RelativeCsaddr, IN DWORD Addresses, IN LPCSADDR_INFO Csaddr)
VOID WSAAPI	CopyQuerySetIndirectA (IN PWS_BUFFER Buffer, IN OUT LPWSAQUERYSETA RelativeSet, IN LPWSAQUERYSETA AnsiSet)
VOID WSAAPI	CopyQuerySetIndirectW (IN PWS_BUFFER Buffer, IN OUT LPWSAQUERYSETW RelativeSet, IN LPWSAQUERYSETW UnicodeSet)
INT WSAAPI	WSABuildQuerySetBufferA (IN LPWSAQUERYSETA AnsiSet, IN SIZE_T BufferSize, OUT LPWSAQUERYSETA RelativeSet)
INT WSAAPI	WSABuildQuerySetBufferW (IN LPWSAQUERYSETW UnicodeSet, IN SIZE_T BufferSize, OUT LPWSAQUERYSETW RelativeSet)
INT WSAAPI	MapAnsiQuerySetToUnicode (IN LPWSAQUERYSETA AnsiSet, IN OUT PSIZE_T SetSize, OUT LPWSAQUERYSETW UnicodeSet)
INT WSAAPI	MapUnicodeQuerySetToAnsi (IN LPWSAQUERYSETW UnicodeSet, IN OUT PSIZE_T SetSize, OUT LPWSAQUERYSETA AnsiSet)
INT WSAAPI	CopyQuerySetW (IN LPWSAQUERYSETW UnicodeSet, OUT LPWSAQUERYSETW *UnicodeCopy)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file qshelpr.c.

Function Documentation

AnsiDupFromUnicode()

LPSTR WSAAPI AnsiDupFromUnicode

(

IN LPCWSTR

UnicodeString

)

Definition at line 20 of file qshelpr.c.

{
    INT Length = 0;
    BOOL GoOn = TRUE;
    LPSTR DuplicatedString = NULL;
    INT ReturnValue;
 
    /* Start a loop (which should only run twice) */
    while (GoOn)
    {
        /* Call the conversion function */
        ReturnValue = WideCharToMultiByte(CP_ACP,
                                          0,
                                          UnicodeString,
                                          -1,
                                          DuplicatedString,
                                          Length,
                                          NULL,
                                          NULL);
        if (ReturnValue > Length)
        {
            /* This is the first loop, and we have the real size now */
            Length = ReturnValue;
 
            /* Allocate buffer for it */
            DuplicatedString = HeapAlloc(WsSockHeap, 0, Length);
            if (!DuplicatedString) GoOn = FALSE;
        }
        else if (ReturnValue > 0)
        {
            /* The second loop was successful and we have the string */
            GoOn = FALSE;
        }
        else
        {
            /* Some weird error happened */
            if (DuplicatedString) HeapFree(WsSockHeap, 0, DuplicatedString);
            DuplicatedString = NULL;
            GoOn = FALSE;
        }
    }
 
    /* Return the duplicate */
    return DuplicatedString;
}

Referenced by ConvertAddrinfoFromUnicodeToAnsi(), and MapUnicodeQuerySetToAnsi().

ComputeQuerySetSize()

SIZE_T WSAAPI ComputeQuerySetSize	(	IN LPWSAQUERYSETA	AnsiSet,
		IN BOOLEAN	IsUnicode
	)

Definition at line 124 of file qshelpr.c.

{
    SIZE_T Size = sizeof(WSAQUERYSETA);
    //LPWSAQUERYSETW UnicodeSet = (LPWSAQUERYSETW)AnsiSet;
    DWORD i;
 
    /* Check for instance name */
    if (AnsiSet->lpszServiceInstanceName)
    {
        /* Add its size */
        Size += ComputeStringSize(AnsiSet->lpszServiceInstanceName, IsUnicode);
    }
 
    /* Check for Service Class ID */
    if (AnsiSet->lpServiceClassId)
    {
        /* Align the current size and add GUID size */
        Size = (Size + 3) & ~3;
        Size += sizeof(GUID);
    }
 
    /* Check for version data */
    if (AnsiSet->lpVersion)
    {
        /* Align the current size and add GUID size */
        Size = (Size + 3) & ~3;
        Size += sizeof(WSAVERSION);
    }
 
    /* Check for comment */
    if (AnsiSet->lpszComment)
    {
        /* Align the current size and add string size */
        Size = (Size + 1) & ~1;
        Size += ComputeStringSize(AnsiSet->lpszComment, IsUnicode);
    }
 
    /* Check for Provider ID */
    if (AnsiSet->lpNSProviderId)
    {
        /* Align the current size and add GUID size */
        Size = (Size + 3) & ~3;
        Size += sizeof(GUID);
    }
 
    /* Check for context */
    if (AnsiSet->lpszContext)
    {
        /* Align the current size and add string size */
        Size = (Size + 1) & ~1;
        Size += ComputeStringSize(AnsiSet->lpszContext, IsUnicode);
    }
 
    /* Check for query string */
    if (AnsiSet->lpszQueryString)
    {
        /* Align the current size and add string size */
        Size = (Size + 1) & ~1;
        Size += ComputeStringSize(AnsiSet->lpszQueryString, IsUnicode);
    }
 
    /* Check for AF Protocol data */
    if (AnsiSet->lpafpProtocols)
    {
        /* Align the current size and add AFP size */
        Size = (Size + 3) & ~3;
        Size += sizeof(AFPROTOCOLS) * AnsiSet->dwNumberOfProtocols;
    }
 
    /* Check for CSADDR buffer */
    if (AnsiSet->lpcsaBuffer)
    {
        /* Align the current size */
        Size = (Size + 3) & ~3;
 
        /* Loop all the addresses in the array */
        for (i = 0; i < AnsiSet->dwNumberOfCsAddrs; i++)
        {
            /* Check for local sockaddr */
            if (AnsiSet->lpcsaBuffer[i].LocalAddr.lpSockaddr)
            {
                /* Align the current size and add the sockaddr's length */
                Size = (Size + 3) & ~3;
                Size += AnsiSet->lpcsaBuffer[i].LocalAddr.iSockaddrLength;
            }
            /* Check for remote sockaddr */
            if (AnsiSet->lpcsaBuffer[i].RemoteAddr.lpSockaddr)
            {
                /* Align the current size and add the sockaddr's length */
                Size = (Size + 3) & ~3;
                Size += AnsiSet->lpcsaBuffer[i].RemoteAddr.iSockaddrLength;
            }
 
            /* Add the sockaddr size itself */
            Size += sizeof(CSADDR_INFO);
        }
    }
 
    /* Check for blob data */
    if (AnsiSet->lpBlob)
    {
        /* Align the current size and add blob size */
        Size = (Size + 3) & ~3;
        Size += sizeof(BLOB);
 
        /* Also add the actual blob data size, if it exists */
        if (AnsiSet->lpBlob) Size += AnsiSet->lpBlob->cbSize;
    }
 
    /* Return the total size */
    return Size;
}

Referenced by WSAComputeQuerySetSizeA(), and WSAComputeQuerySetSizeW().

ComputeStringSize()

SIZE_T WSAAPI ComputeStringSize	(	IN LPSTR	String,
		IN BOOLEAN	IsUnicode
	)

Definition at line 114 of file qshelpr.c.

{
    /* Return the size of the string, in bytes, including null-char */
    return (IsUnicode) ? (wcslen((LPWSTR)String) + 1 ) * sizeof(WCHAR) :
                          strlen(String) + sizeof(CHAR);
}

Referenced by ComputeQuerySetSize().

CopyAddrInfoArrayIndirect()

VOID WSAAPI CopyAddrInfoArrayIndirect	(	IN PWS_BUFFER	Buffer,
		IN OUT LPCSADDR_INFO	RelativeCsaddr,
		IN DWORD	Addresses,
		IN LPCSADDR_INFO	Csaddr
	)

Definition at line 296 of file qshelpr.c.

{
    DWORD i;
 
    /* Loop for every address inside */
    for (i = 0; i < Addresses; i++)
    {
        /* Check for a local address */
        if ((Csaddr[i].LocalAddr.lpSockaddr) &&
            (Csaddr[i].LocalAddr.iSockaddrLength))
        {
            /* Allocate and copy the address */
            RelativeCsaddr[i].LocalAddr.lpSockaddr =
                WsBufferAllocate(Buffer,
                                 Csaddr[i].LocalAddr.iSockaddrLength,
                                 sizeof(PVOID));
            RtlCopyMemory(RelativeCsaddr[i].LocalAddr.lpSockaddr,
                          Csaddr[i].LocalAddr.lpSockaddr,
                          Csaddr[i].LocalAddr.iSockaddrLength);
        }
        else
        {
            /* Nothing in this address */
            Csaddr[i].LocalAddr.lpSockaddr = NULL;
            Csaddr[i].LocalAddr.iSockaddrLength = 0;
        }
 
        /* Check for a remote address */
        if ((Csaddr[i].RemoteAddr.lpSockaddr) &&
            (Csaddr[i].RemoteAddr.iSockaddrLength))
        {
            /* Allocate and copy the address */
            RelativeCsaddr[i].RemoteAddr.lpSockaddr =
                WsBufferAllocate(Buffer,
                                 Csaddr[i].RemoteAddr.iSockaddrLength,
                                 sizeof(PVOID));
            RtlCopyMemory(RelativeCsaddr[i].RemoteAddr.lpSockaddr,
                          Csaddr[i].RemoteAddr.lpSockaddr,
                          Csaddr[i].RemoteAddr.iSockaddrLength);
        }
        else
        {
            /* Nothing in this address */
            Csaddr[i].RemoteAddr.lpSockaddr = NULL;
            Csaddr[i].RemoteAddr.iSockaddrLength = 0;
        }
    }
}

Referenced by CopyQuerySetIndirectA(), and CopyQuerySetIndirectW().

CopyBlobIndirect()

VOID WSAAPI CopyBlobIndirect	(	IN PWS_BUFFER	Buffer,
		IN OUT LPBLOB	RelativeBlob,
		IN LPBLOB	Blob
	)

Definition at line 277 of file qshelpr.c.

{
    /* Make sure we have blob data */
    if ((Blob->pBlobData) && (Blob->cbSize))
    {
        /* Allocate and copy the blob data */
        RelativeBlob->pBlobData = WsBufferAllocate(Buffer,
                                                   Blob->cbSize,
                                                   sizeof(PVOID));
        RtlCopyMemory(RelativeBlob->pBlobData,
                      Blob->pBlobData,
                      Blob->cbSize);
    }
}

Referenced by CopyQuerySetIndirectA(), and CopyQuerySetIndirectW().

CopyQuerySetIndirectA()

VOID WSAAPI CopyQuerySetIndirectA	(	IN PWS_BUFFER	Buffer,
		IN OUT LPWSAQUERYSETA	RelativeSet,
		IN LPWSAQUERYSETA	AnsiSet
	)

Definition at line 350 of file qshelpr.c.

{
    LPSTR AnsiString;
 
    /* Get the service name */
    AnsiString = AnsiSet->lpszServiceInstanceName;
    if (AnsiString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszServiceInstanceName = WsBufferAllocate(Buffer,
                                                                strlen(AnsiString) + 1,
                                                                sizeof(CHAR));
        /* Copy it into the buffer */
        strcpy(RelativeSet->lpszServiceInstanceName, AnsiString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszServiceInstanceName = NULL;
    }
 
    /* Check for the service class ID */
    if (AnsiSet->lpServiceClassId)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpServiceClassId = WsBufferAllocate(Buffer,
                                                         sizeof(GUID),
                                                         sizeof(PVOID));
        /* Copy it into the buffer */
        *(RelativeSet->lpServiceClassId) = *(AnsiSet->lpServiceClassId);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpServiceClassId = NULL;
    }
 
    /* Get the version data */
    if (AnsiSet->lpVersion)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpVersion = WsBufferAllocate(Buffer,
                                                  sizeof(WSAVERSION),
                                                  sizeof(PVOID));
        /* Copy it into the buffer */
        *(RelativeSet->lpVersion) = *(AnsiSet->lpVersion);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpVersion = NULL;
    }
 
    /* Get the comment */
    AnsiString = AnsiSet->lpszComment;
    if (AnsiString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszComment = WsBufferAllocate(Buffer,
                                                    strlen(AnsiString) + 1,
                                                    sizeof(CHAR));
        /* Copy it into the buffer */
        strcpy(RelativeSet->lpszComment, AnsiString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszComment = NULL;
    }
 
    /* Get the NS Provider ID */
    if (AnsiSet->lpNSProviderId)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpNSProviderId = WsBufferAllocate(Buffer,
                                                       sizeof(GUID),
                                                       sizeof(PVOID));
        /* Copy it into the buffer */
        *(RelativeSet->lpNSProviderId) = *(AnsiSet->lpNSProviderId);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpNSProviderId = NULL;
    }
 
    /* Get the context */
    AnsiString = AnsiSet->lpszContext;
    if (AnsiString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszContext = WsBufferAllocate(Buffer,
                                                    strlen(AnsiString) + 1,
                                                    sizeof(CHAR));
        /* Copy it into the buffer */
        strcpy(RelativeSet->lpszContext, AnsiString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszContext = NULL;
    }
 
    /* Get the query string */
    AnsiString = AnsiSet->lpszQueryString;
    if (AnsiString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszQueryString = WsBufferAllocate(Buffer,
                                                        strlen(AnsiString) + 1,
                                                        sizeof(CHAR));
        /* Copy it into the buffer */
        strcpy(RelativeSet->lpszQueryString, AnsiString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszQueryString = NULL;
    }
 
    /* Check for a protocol structure with non-zero protocols */
    if ((AnsiSet->lpafpProtocols) && (AnsiSet->dwNumberOfProtocols))
    {
        /* One exists, allocate space for it */
        RelativeSet->lpafpProtocols = WsBufferAllocate(Buffer,
                                                       AnsiSet->dwNumberOfProtocols *
                                                       sizeof(AFPROTOCOLS),
                                                       sizeof(PVOID));
        /* Copy it into the buffer */
        RtlCopyMemory(RelativeSet->lpafpProtocols,
                      AnsiSet->lpafpProtocols,
                      AnsiSet->dwNumberOfProtocols * sizeof(AFPROTOCOLS));
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpafpProtocols = NULL;
        RelativeSet->dwNumberOfProtocols = 0;
    }
 
    /* Check if we have a CSADDR with addresses inside */
    if ((AnsiSet->lpcsaBuffer) && (AnsiSet->dwNumberOfCsAddrs))
    {
        /* Allocate and copy the CSADDR structure itself */
        RelativeSet->lpcsaBuffer = WsBufferAllocate(Buffer,
                                                    AnsiSet->dwNumberOfCsAddrs *
                                                    sizeof(CSADDR_INFO),
                                                    sizeof(PVOID));
 
        /* Copy it into the buffer */
        RtlCopyMemory(RelativeSet->lpcsaBuffer,
                      AnsiSet->lpcsaBuffer,
                      AnsiSet->dwNumberOfCsAddrs * sizeof(CSADDR_INFO));
 
        /* Copy the addresses inside the CSADDR */
        CopyAddrInfoArrayIndirect(Buffer,
                                  RelativeSet->lpcsaBuffer,
                                  AnsiSet->dwNumberOfCsAddrs,
                                  AnsiSet->lpcsaBuffer);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpcsaBuffer = NULL;
        RelativeSet->dwNumberOfCsAddrs = 0;
    }
 
    /* Check for blob data */
    if (AnsiSet->lpBlob)
    {
        /* Allocate and copy the blob itself */
        RelativeSet->lpBlob = WsBufferAllocate(Buffer,
                                               sizeof(BLOB),
                                               sizeof(PVOID));
        *(RelativeSet->lpBlob) = *(AnsiSet->lpBlob);
 
        /* Copy the data inside the blob */
        CopyBlobIndirect(Buffer, RelativeSet->lpBlob, AnsiSet->lpBlob);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpBlob = NULL;
    }
}

Referenced by WSABuildQuerySetBufferA().

CopyQuerySetIndirectW()

VOID WSAAPI CopyQuerySetIndirectW	(	IN PWS_BUFFER	Buffer,
		IN OUT LPWSAQUERYSETW	RelativeSet,
		IN LPWSAQUERYSETW	UnicodeSet
	)

Definition at line 540 of file qshelpr.c.

{
    LPWSTR UnicodeString;
 
    /* Get the service name */
    UnicodeString = UnicodeSet->lpszServiceInstanceName;
    if (UnicodeString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszServiceInstanceName = WsBufferAllocate(Buffer,
                                                                (wcslen(UnicodeString) + 1) *
                                                                sizeof(WCHAR),
                                                                sizeof(CHAR));
        /* Copy it into the buffer */
        wcscpy(RelativeSet->lpszServiceInstanceName, UnicodeString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszServiceInstanceName = NULL;
    }
 
    /* Check for the service class ID */
    if (UnicodeSet->lpServiceClassId)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpServiceClassId = WsBufferAllocate(Buffer,
                                                         sizeof(GUID),
                                                         sizeof(PVOID));
        /* Copy it into the buffer */
        *(RelativeSet->lpServiceClassId) = *(UnicodeSet->lpServiceClassId);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpServiceClassId = NULL;
    }
 
    /* Get the version data */
    if (UnicodeSet->lpVersion)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpVersion = WsBufferAllocate(Buffer,
                                                  sizeof(WSAVERSION),
                                                  sizeof(PVOID));
        /* Copy it into the buffer */
        *(RelativeSet->lpVersion) = *(UnicodeSet->lpVersion);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpVersion = NULL;
    }
 
    /* Get the comment */
    UnicodeString = UnicodeSet->lpszComment;
    if (UnicodeString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszComment = WsBufferAllocate(Buffer,
                                                    (wcslen(UnicodeString) + 1) *
                                                    sizeof(WCHAR),
                                                    sizeof(CHAR));
        /* Copy it into the buffer */
        wcscpy(RelativeSet->lpszComment, UnicodeString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszComment = NULL;
    }
 
    /* Get the NS Provider ID */
    if (UnicodeSet->lpNSProviderId)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpNSProviderId = WsBufferAllocate(Buffer,
                                                       sizeof(GUID),
                                                       sizeof(PVOID));
        /* Copy it into the buffer */
        *(RelativeSet->lpNSProviderId) = *(UnicodeSet->lpNSProviderId);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpNSProviderId = NULL;
    }
 
    /* Get the context */
    UnicodeString = UnicodeSet->lpszContext;
    if (UnicodeString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszContext = WsBufferAllocate(Buffer,
                                                    (wcslen(UnicodeString) + 1) *
                                                    sizeof(WCHAR),
                                                    sizeof(CHAR));
        /* Copy it into the buffer */
        wcscpy(RelativeSet->lpszContext, UnicodeString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszContext = NULL;
    }
 
    /* Get the query string */
    UnicodeString = UnicodeSet->lpszQueryString;
    if (UnicodeString)
    {
        /* One exists, allocate a space in the buffer for it */
        RelativeSet->lpszQueryString = WsBufferAllocate(Buffer,
                                                        (wcslen(UnicodeString) + 1) *
                                                        sizeof(WCHAR),
                                                        sizeof(CHAR));
        /* Copy it into the buffer */
        wcscpy(RelativeSet->lpszQueryString, UnicodeString);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpszQueryString = NULL;
    }
 
    /* Check for a protocol structure with non-zero protocols */
    if ((UnicodeSet->lpafpProtocols) && (UnicodeSet->dwNumberOfProtocols))
    {
        /* One exists, allocate space for it */
        RelativeSet->lpafpProtocols = WsBufferAllocate(Buffer,
                                                       UnicodeSet->dwNumberOfProtocols *
                                                       sizeof(AFPROTOCOLS),
                                                       sizeof(PVOID));
        /* Copy it into the buffer */
        RtlCopyMemory(RelativeSet->lpafpProtocols,
                      UnicodeSet->lpafpProtocols,
                      UnicodeSet->dwNumberOfProtocols * sizeof(AFPROTOCOLS));
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpafpProtocols = NULL;
        RelativeSet->dwNumberOfProtocols = 0;
    }
 
    /* Check if we have a CSADDR with addresses inside */
    if ((UnicodeSet->lpcsaBuffer) && (UnicodeSet->dwNumberOfCsAddrs))
    {
        /* Allocate and copy the CSADDR structure itself */
        RelativeSet->lpcsaBuffer = WsBufferAllocate(Buffer,
                                                    UnicodeSet->dwNumberOfCsAddrs *
                                                    sizeof(CSADDR_INFO),
                                                    sizeof(PVOID));
 
        /* Copy it into the buffer */
        RtlCopyMemory(RelativeSet->lpcsaBuffer,
                      UnicodeSet->lpcsaBuffer,
                      UnicodeSet->dwNumberOfCsAddrs * sizeof(CSADDR_INFO));
 
        /* Copy the addresses inside the CSADDR */
        CopyAddrInfoArrayIndirect(Buffer,
                                  RelativeSet->lpcsaBuffer,
                                  UnicodeSet->dwNumberOfCsAddrs,
                                  UnicodeSet->lpcsaBuffer);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpcsaBuffer = NULL;
        RelativeSet->dwNumberOfCsAddrs = 0;
    }
 
    /* Check for blob data */
    if (UnicodeSet->lpBlob)
    {
        /* Allocate and copy the blob itself */
        RelativeSet->lpBlob = WsBufferAllocate(Buffer,
                                               sizeof(BLOB),
                                               sizeof(PVOID));
        *(RelativeSet->lpBlob) = *(UnicodeSet->lpBlob);
 
        /* Copy the data inside the blob */
        CopyBlobIndirect(Buffer, RelativeSet->lpBlob, UnicodeSet->lpBlob);
    }
    else
    {
        /* Nothing in the buffer */
        RelativeSet->lpBlob = NULL;
    }
}

Referenced by WSABuildQuerySetBufferW().

CopyQuerySetW()

INT WSAAPI CopyQuerySetW	(	IN LPWSAQUERYSETW	UnicodeSet,
		OUT LPWSAQUERYSETW *	UnicodeCopy
	)

Definition at line 1050 of file qshelpr.c.

{
    SIZE_T SetSize;
 
    /* Get the size */
    SetSize = WSAComputeQuerySetSizeW(UnicodeSet);
 
    /* Allocate memory for copy */
    *UnicodeCopy = HeapAlloc(WsSockHeap, 0, SetSize);
    if (!(*UnicodeCopy)) return WSA_NOT_ENOUGH_MEMORY;
 
    /* Build a copy and return */
    return WSABuildQuerySetBufferW(UnicodeSet, SetSize, *UnicodeCopy);
}

Referenced by WsNqLookupServiceBegin().

MapAnsiQuerySetToUnicode()

INT WSAAPI MapAnsiQuerySetToUnicode	(	IN LPWSAQUERYSETA	AnsiSet,
		IN OUT PSIZE_T	SetSize,
		OUT LPWSAQUERYSETW	UnicodeSet
	)

Definition at line 808 of file qshelpr.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    SIZE_T AnsiSize, UnicodeSize;
    LPWSAQUERYSETA AnsiCopy = NULL;
    LPWSAQUERYSETW UnicodeCopy;
    LPWSTR ServiceCopy = NULL, CommentCopy = NULL;
    LPWSTR ContextCopy = NULL, QueryCopy = NULL;
 
    /* Calculate the size of the Ansi version and allocate space for a copy */
    AnsiSize = WSAComputeQuerySetSizeA(AnsiSet);
    AnsiCopy = HeapAlloc(WsSockHeap, 0, AnsiSize);
    if (!AnsiCopy)
    {
        /* Fail, couldn't allocate memory */
        ErrorCode = WSA_NOT_ENOUGH_MEMORY;
        goto Exit;
    }
 
    /* Build the relative buffer version */
    ErrorCode = WSABuildQuerySetBufferA(AnsiSet, AnsiSize, AnsiCopy);
    if (ErrorCode != ERROR_SUCCESS) goto Exit;
 
    /* Re-use the ANSI version since the fields match */
    UnicodeCopy = (LPWSAQUERYSETW)AnsiCopy;
 
    /* Check if we have a service instance name */
    if (AnsiCopy->lpszServiceInstanceName)
    {
        /* Duplicate it into unicode form */
        ServiceCopy = UnicodeDupFromAnsi(AnsiCopy->lpszServiceInstanceName);
        if (!ServiceCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszServiceInstanceName = ServiceCopy;
    }
 
    /* Check if we have a service instance name */
    if (AnsiCopy->lpszContext)
    {
        /* Duplicate it into unicode form */
        ContextCopy = UnicodeDupFromAnsi(AnsiCopy->lpszContext);
        if (!ContextCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszContext = ContextCopy;
    }
 
    /* Check if we have a service instance name */
    if (AnsiCopy->lpszComment)
    {
        /* Duplicate it into unicode form */
        CommentCopy = UnicodeDupFromAnsi(AnsiCopy->lpszComment);
        if (!CommentCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszComment = CommentCopy;
    }
 
    /* Check if we have a query name */
    if (AnsiCopy->lpszQueryString)
    {
        /* Duplicate it into unicode form */
        QueryCopy = UnicodeDupFromAnsi(AnsiCopy->lpszQueryString);
        if (!QueryCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszQueryString = QueryCopy;
    }
 
    /* Now that we have the absolute unicode buffer, calculate its size */
    UnicodeSize = WSAComputeQuerySetSizeW(UnicodeCopy);
    if (UnicodeSize > *SetSize)
    {
        /* The buffer wasn't large enough; return how much we need */
        *SetSize = UnicodeSize;
        ErrorCode = WSAEFAULT;
        goto Exit;
    }
 
    /* Build the relative unicode buffer */
    ErrorCode = WSABuildQuerySetBufferW(UnicodeCopy, *SetSize, UnicodeSet);
 
Exit:
    /* Free the Ansi copy if we had one */
    if (AnsiCopy) HeapFree(WsSockHeap, 0, AnsiCopy);
 
    /* Free all the strings */
    if (ServiceCopy) HeapFree(WsSockHeap, 0, ServiceCopy);
    if (CommentCopy) HeapFree(WsSockHeap, 0, CommentCopy);
    if (ContextCopy) HeapFree(WsSockHeap, 0, ContextCopy);
    if (QueryCopy) HeapFree(WsSockHeap, 0, QueryCopy);
 
    /* Return error code */
    return ErrorCode;
}

Referenced by WSALookupServiceBeginA().

MapUnicodeQuerySetToAnsi()

INT WSAAPI MapUnicodeQuerySetToAnsi	(	IN LPWSAQUERYSETW	UnicodeSet,
		IN OUT PSIZE_T	SetSize,
		OUT LPWSAQUERYSETA	AnsiSet
	)

Definition at line 929 of file qshelpr.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    SIZE_T UnicodeSize, AnsiSize;
    LPWSAQUERYSETW UnicodeCopy = NULL;
    LPWSAQUERYSETA AnsiCopy;
    LPSTR ServiceCopy = NULL, CommentCopy = NULL;
    LPSTR ContextCopy = NULL, QueryCopy = NULL;
 
    /* Calculate the size of the Ansi version and allocate space for a copy */
    UnicodeSize = WSAComputeQuerySetSizeW(UnicodeSet);
    UnicodeCopy = HeapAlloc(WsSockHeap, 0, UnicodeSize);
    if (!UnicodeCopy)
    {
        /* Fail, couldn't allocate memory */
        ErrorCode = WSA_NOT_ENOUGH_MEMORY;
        goto Exit;
    }
 
    /* Build the relative buffer version */
    ErrorCode = WSABuildQuerySetBufferW(UnicodeSet, UnicodeSize, UnicodeCopy);
    if (ErrorCode != ERROR_SUCCESS) goto Exit;
 
    /* Re-use the Unicode version since the fields match */
    AnsiCopy = (LPWSAQUERYSETA)UnicodeCopy;
 
    /* Check if we have a service instance name */
    if (UnicodeCopy->lpszServiceInstanceName)
    {
        /* Duplicate it into unicode form */
        ServiceCopy = AnsiDupFromUnicode(UnicodeCopy->lpszServiceInstanceName);
        if (!ServiceCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszServiceInstanceName = ServiceCopy;
    }
 
    /* Check if we have a service instance name */
    if (UnicodeCopy->lpszContext)
    {
        /* Duplicate it into unicode form */
        ContextCopy = AnsiDupFromUnicode(UnicodeCopy->lpszContext);
        if (!ContextCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszContext = ContextCopy;
    }
 
    /* Check if we have a service instance name */
    if (UnicodeCopy->lpszComment)
    {
        /* Duplicate it into unicode form */
        CommentCopy = AnsiDupFromUnicode(UnicodeCopy->lpszComment);
        if (!CommentCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszComment = CommentCopy;
    }
 
    /* Check if we have a query name */
    if (UnicodeCopy->lpszQueryString)
    {
        /* Duplicate it into unicode form */
        QueryCopy = AnsiDupFromUnicode(UnicodeCopy->lpszQueryString);
        if (!QueryCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszQueryString = QueryCopy;
    }
 
    /* Now that we have the absolute unicode buffer, calculate its size */
    AnsiSize = WSAComputeQuerySetSizeA(AnsiCopy);
    if (AnsiSize > *SetSize)
    {
        /* The buffer wasn't large enough; return how much we need */
        *SetSize = AnsiSize;
        ErrorCode = WSAEFAULT;
        goto Exit;
    }
 
    /* Build the relative unicode buffer */
    ErrorCode = WSABuildQuerySetBufferA(AnsiCopy, *SetSize, AnsiSet);
 
Exit:
    /* Free the Ansi copy if we had one */
    if (UnicodeCopy) HeapFree(WsSockHeap, 0, UnicodeCopy);
 
    /* Free all the strings */
    if (ServiceCopy) HeapFree(WsSockHeap, 0, ServiceCopy);
    if (CommentCopy) HeapFree(WsSockHeap, 0, CommentCopy);
    if (ContextCopy) HeapFree(WsSockHeap, 0, ContextCopy);
    if (QueryCopy) HeapFree(WsSockHeap, 0, QueryCopy);
 
    /* Return error code */
    return ErrorCode;
}

Referenced by WSALookupServiceNextA().

UnicodeDupFromAnsi()

LPWSTR WSAAPI UnicodeDupFromAnsi

(

IN LPCSTR

AnsiString

)

Definition at line 68 of file qshelpr.c.

{
    INT Length = 0;
    BOOL GoOn = TRUE;
    LPWSTR DuplicatedString = NULL;
    INT ReturnValue;
 
    /* Start a loop (which should only run twice) */
    while (GoOn)
    {
        /* Call the conversion function */
        ReturnValue = MultiByteToWideChar(CP_ACP,
                                          0,
                                          AnsiString,
                                          -1,
                                          DuplicatedString,
                                          Length);
        if (ReturnValue > Length)
        {
            /* This is the first loop, and we have the real size now */
            Length = ReturnValue;
 
            /* Allocate buffer for it */
            DuplicatedString = HeapAlloc(WsSockHeap, 0, Length * sizeof(WCHAR));
            if (!DuplicatedString) GoOn = FALSE;
        }
        else if (ReturnValue > 0)
        {
            /* The second loop was successful and we have the string */
            GoOn = FALSE;
        }
        else
        {
            /* Some weird error happened */
            if (DuplicatedString) HeapFree(WsSockHeap, 0, DuplicatedString);
            DuplicatedString = NULL;
            GoOn = FALSE;
        }
    }
 
    /* Return the duplicate */
    return DuplicatedString;
}

Referenced by getaddrinfo(), and MapAnsiQuerySetToUnicode().

WSABuildQuerySetBufferA()

INT WSAAPI WSABuildQuerySetBufferA	(	IN LPWSAQUERYSETA	AnsiSet,
		IN SIZE_T	BufferSize,
		OUT LPWSAQUERYSETA	RelativeSet
	)

Definition at line 734 of file qshelpr.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    SIZE_T SetSize;
    WS_BUFFER Buffer;
    LPWSAQUERYSETA NewSet;
 
    /* Find out how big the set really is */
    SetSize = WSAComputeQuerySetSizeA(AnsiSet);
    if (SetSize <= BufferSize)
    {
        /* Configure the buffer */
        Buffer.Position = (ULONG_PTR)RelativeSet;
        Buffer.MaxSize = SetSize;
        Buffer.BytesUsed = 0;
 
        /* Copy the set itself into the buffer */
        NewSet = WsBufferAllocate(&Buffer, sizeof(*AnsiSet), sizeof(PVOID));
        *NewSet = *AnsiSet;
 
        /* Now copy the data inside */
        CopyQuerySetIndirectA(&Buffer, NewSet, AnsiSet);
    }
    else
    {
        /* We failed */
        ErrorCode = SOCKET_ERROR;
    }
 
    /* Return to caller */
    return ErrorCode;
}

Referenced by MapAnsiQuerySetToUnicode(), and MapUnicodeQuerySetToAnsi().

WSABuildQuerySetBufferW()

INT WSAAPI WSABuildQuerySetBufferW	(	IN LPWSAQUERYSETW	UnicodeSet,
		IN SIZE_T	BufferSize,
		OUT LPWSAQUERYSETW	RelativeSet
	)

Definition at line 771 of file qshelpr.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    SIZE_T SetSize;
    WS_BUFFER Buffer;
    LPWSAQUERYSETW NewSet;
 
    /* Find out how big the set really is */
    SetSize = WSAComputeQuerySetSizeW(UnicodeSet);
    if (SetSize <= BufferSize)
    {
        /* Configure the buffer */
        Buffer.Position = (ULONG_PTR)RelativeSet;
        Buffer.MaxSize = SetSize;
        Buffer.BytesUsed = 0;
 
        /* Copy the set itself into the buffer */
        NewSet = WsBufferAllocate(&Buffer, sizeof(*UnicodeSet), sizeof(PVOID));
        *NewSet = *UnicodeSet;
 
        /* Now copy the data inside */
        CopyQuerySetIndirectW(&Buffer, NewSet, UnicodeSet);
    }
    else
    {
        /* We failed */
        ErrorCode = SOCKET_ERROR;
    }
 
    /* Return to caller */
    return ErrorCode;
}

Referenced by CopyQuerySetW(), MapAnsiQuerySetToUnicode(), and MapUnicodeQuerySetToAnsi().

WSAComputeQuerySetSizeA()

SIZE_T WSAAPI WSAComputeQuerySetSizeA

(

IN LPWSAQUERYSETA

AnsiSet

)

Definition at line 240 of file qshelpr.c.

{
    /* Call the generic helper */
    return ComputeQuerySetSize(AnsiSet, FALSE);
}

Referenced by MapAnsiQuerySetToUnicode(), MapUnicodeQuerySetToAnsi(), and WSABuildQuerySetBufferA().

WSAComputeQuerySetSizeW()

SIZE_T WSAAPI WSAComputeQuerySetSizeW

(

IN LPWSAQUERYSETW

UnicodeSet

)

Definition at line 248 of file qshelpr.c.

{
    /* Call the generic helper */
    return ComputeQuerySetSize((LPWSAQUERYSETA)UnicodeSet, TRUE);
}

Referenced by CopyQuerySetW(), MapAnsiQuerySetToUnicode(), MapUnicodeQuerySetToAnsi(), and WSABuildQuerySetBufferW().

WsBufferAllocate()

PVOID WSAAPI WsBufferAllocate	(	IN PWS_BUFFER	Buffer,
		IN SIZE_T	Size,
		IN DWORD	Align
	)

Definition at line 256 of file qshelpr.c.

{
    PVOID NewPosition;
 
    /* Align the current usage */
    Buffer->BytesUsed = (Buffer->BytesUsed + Align - 1) & ~(Align - 1);
 
    /* Update our location */
    NewPosition = (PVOID)(Buffer->Position + Buffer->BytesUsed);
 
    /* Update the usage */
    Buffer->BytesUsed += Size;
 
    /* Return new location */
    return NewPosition;
}

Referenced by CopyAddrInfoArrayIndirect(), CopyBlobIndirect(), CopyQuerySetIndirectA(), CopyQuerySetIndirectW(), WSABuildQuerySetBufferA(), and WSABuildQuerySetBufferW().