mswhelper.h File Reference

#include <ws2spi.h>

Include dependency graph for mswhelper.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MSW_BUFFER

Typedefs
typedef struct MSW_BUFFER *	PMSW_BUFFER

Functions
void	mswBufferInit (_Out_ PMSW_BUFFER mswBuf, _In_ BYTE *buffer, _In_ DWORD bufferSize)
BOOL	mswBufferCheck (_Inout_ PMSW_BUFFER mswBuf, _In_ DWORD count)
BOOL	mswBufferIncUsed (_Inout_ PMSW_BUFFER mswBuf, _In_ DWORD count)
BYTE *	mswBufferEndPtr (_Inout_ PMSW_BUFFER mswBuf)
BOOL	mswBufferAppend (_Inout_ PMSW_BUFFER mswBuf, _In_ void *dataToAppend, _In_ DWORD dataSize)
BOOL	mswBufferAppendStrA (_Inout_ PMSW_BUFFER mswBuf, _In_ char *str)
BOOL	mswBufferAppendStrW (_Inout_ PMSW_BUFFER mswBuf, _In_ WCHAR *str)
BOOL	mswBufferAppendPtr (_Inout_ PMSW_BUFFER mswBuf, _In_ void *ptr)
BOOL	mswBufferAppendLst (_Inout_ PMSW_BUFFER mswBuf, _In_ void **lst, _In_ DWORD itemByteLength, _In_opt_ int deltaofs)
BOOL	mswBufferAppendStrLstA (_Inout_ PMSW_BUFFER mswBuf, _In_ void **lst, _In_opt_ int ptrofs)
BOOL	mswBufferAppendBlob_Hostent (_Inout_ PMSW_BUFFER mswBuf, _Inout_ LPWSAQUERYSETW lpRes, _In_ char **hostAliasesA, _In_ char *hostnameA, _In_ DWORD ip4addr)
BOOL	mswBufferAppendBlob_Servent (_Inout_ PMSW_BUFFER mswBuf, _Inout_ LPWSAQUERYSETW lpRes, _In_ char *serviceNameA, _In_ char **serviceAliasesA, _In_ char *protocolNameA, _In_ WORD port)
BOOL	mswBufferAppendAddr_AddrInfoW (_Inout_ PMSW_BUFFER mswBuf, _Inout_ LPWSAQUERYSETW lpRes, _In_ DWORD ip4addr)
WCHAR *	StrA2WHeapAlloc (_In_opt_ HANDLE hHeap, _In_ char *aStr)
char *	StrW2AHeapAlloc (_In_opt_ HANDLE hHeap, _In_ WCHAR *wStr)
WCHAR *	StrCpyHeapAllocW (_In_opt_ HANDLE hHeap, _In_ WCHAR *wStr)
char *	StrCpyHeapAllocA (_In_opt_ HANDLE hHeap, _In_ char *aStr)
char **	StrAryCpyHeapAllocA (_In_opt_ HANDLE hHeap, _In_ char **aStrAry)
char **	StrAryCpyHeapAllocWToA (_In_opt_ HANDLE hHeap, _In_ WCHAR **aStrAry)

Typedef Documentation

PMSW_BUFFER

typedef struct MSW_BUFFER * PMSW_BUFFER

Function Documentation

mswBufferAppend()

BOOL mswBufferAppend	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ void *	dataToAppend,
		_In_ DWORD	dataSize
	)

Definition at line 57 of file mswhelper.c.

{
    if (!mswBufferCheck(mswBuf, dataSize))
        return FALSE;
 
    RtlCopyMemory(mswBuf->bufendptr, dataToAppend, dataSize);
    mswBuf->bytesUsed += dataSize;
    mswBuf->bufendptr += dataSize;
 
    return TRUE;
}

Referenced by mswBufferAppendLst(), mswBufferAppendPtr(), mswBufferAppendStrA(), and mswBufferAppendStrW().

mswBufferAppendAddr_AddrInfoW()

BOOL mswBufferAppendAddr_AddrInfoW	(	_Inout_ PMSW_BUFFER	mswBuf,
		_Inout_ LPWSAQUERYSETW	lpRes,
		_In_ DWORD	ip4addr
	)

Definition at line 352 of file mswhelper.c.

{
    LPCSADDR_INFO paddrinfo;
    LPSOCKADDR_IN psa;
 
    lpRes->dwNumberOfCsAddrs = 1;
    lpRes->lpcsaBuffer = (LPCSADDR_INFO)mswBufferEndPtr(mswBuf);
 
    paddrinfo = lpRes->lpcsaBuffer;
 
    if (!mswBufferIncUsed(mswBuf, sizeof(*paddrinfo)))
        return FALSE;
 
    paddrinfo->LocalAddr.lpSockaddr = (LPSOCKADDR)mswBufferEndPtr(mswBuf);
 
    if (!mswBufferIncUsed(mswBuf, sizeof(*paddrinfo->LocalAddr.lpSockaddr)))
        return FALSE;
 
    paddrinfo->RemoteAddr.lpSockaddr = (LPSOCKADDR)mswBufferEndPtr(mswBuf);
 
    if (!mswBufferIncUsed(mswBuf, sizeof(*paddrinfo->RemoteAddr.lpSockaddr)))
        return FALSE;
 
    paddrinfo->iSocketType = SOCK_DGRAM;
    paddrinfo->iProtocol = IPPROTO_UDP;
 
    psa = (LPSOCKADDR_IN)paddrinfo->LocalAddr.lpSockaddr;
    paddrinfo->LocalAddr.iSockaddrLength = sizeof(*psa);
    psa->sin_family = AF_INET;
    psa->sin_port = 0;
    psa->sin_addr.s_addr = 0;
    RtlZeroMemory(psa->sin_zero, sizeof(psa->sin_zero));
 
    psa = (LPSOCKADDR_IN)paddrinfo->RemoteAddr.lpSockaddr;
    paddrinfo->RemoteAddr.iSockaddrLength = sizeof(*psa);
    psa->sin_family = AF_INET;
    psa->sin_port = 0;
    psa->sin_addr.s_addr = ip4addr;
    RtlZeroMemory(psa->sin_zero, sizeof(psa->sin_zero));
 
    return TRUE;
}

Referenced by NSP_LookupServiceNextW().

mswBufferAppendBlob_Hostent()

BOOL mswBufferAppendBlob_Hostent	(	_Inout_ PMSW_BUFFER	mswBuf,
		_Inout_ LPWSAQUERYSETW	lpRes,
		_In_ char **	hostAliasesA,
		_In_ char *	hostnameA,
		_In_ DWORD	ip4addr
	)

Definition at line 227 of file mswhelper.c.

{
    PHOSTENT phe;
    void* lst[2];
    BYTE* bytesOfs;
 
    /* blob */
    lpRes->lpBlob = (LPBLOB)mswBufferEndPtr(mswBuf);
 
    if (!mswBufferIncUsed(mswBuf, sizeof(*lpRes->lpBlob)))
        return FALSE;
 
    /* cbSize will be set later */
    lpRes->lpBlob->cbSize = 0;
    lpRes->lpBlob->pBlobData = mswBufferEndPtr(mswBuf);
 
    /* hostent */
    phe = (PHOSTENT)lpRes->lpBlob->pBlobData;
    bytesOfs = mswBufferEndPtr(mswBuf);
 
    if (!mswBufferIncUsed(mswBuf, sizeof(*phe)))
        return FALSE;
 
    phe->h_addrtype = AF_INET;
    phe->h_length = 4; /* 4 Byte (IPv4) */
 
    /* aliases */
    phe->h_aliases = (char**)(mswBufferEndPtr(mswBuf) - bytesOfs);
 
    if (hostAliasesA)
    {
        if (!mswBufferAppendStrLstA(mswBuf,
                                    (void**)hostAliasesA,
                                    -(LONG_PTR)bytesOfs))
            return FALSE;
    }
    else
    {
        if (!mswBufferAppendPtr(mswBuf, NULL))
            return FALSE;
    }
 
    /* addr_list */
    RtlZeroMemory(lst, sizeof(lst));
 
    lst[0] = (void*)&ip4addr;
 
    phe->h_addr_list = (char**)(mswBufferEndPtr(mswBuf) - bytesOfs);
 
    if (!mswBufferAppendLst(mswBuf, lst, 4, -(LONG_PTR)bytesOfs))
        return FALSE;
 
    /* name */
    phe->h_name = (char*)(mswBufferEndPtr(mswBuf) - bytesOfs);
 
    if (!mswBufferAppendStrA(mswBuf, hostnameA))
        return FALSE;
 
    lpRes->lpBlob->cbSize = (DWORD)(mswBufferEndPtr(mswBuf) - bytesOfs);
    return mswBuf->bufok;
}

Referenced by NSP_LookupServiceNextW().

mswBufferAppendBlob_Servent()

BOOL mswBufferAppendBlob_Servent	(	_Inout_ PMSW_BUFFER	mswBuf,
		_Inout_ LPWSAQUERYSETW	lpRes,
		_In_ char *	serviceNameA,
		_In_ char **	serviceAliasesA,
		_In_ char *	protocolNameA,
		_In_ WORD	port
	)

Definition at line 294 of file mswhelper.c.

{
    PSERVENT pse;
    BYTE* bytesOfs;
 
    /* blob */
    lpRes->lpBlob = (LPBLOB)mswBufferEndPtr(mswBuf);
 
    if (!mswBufferIncUsed(mswBuf, sizeof(*lpRes->lpBlob)))
        return FALSE;
 
    lpRes->lpBlob->cbSize = 0;//later
    lpRes->lpBlob->pBlobData = mswBufferEndPtr(mswBuf);
 
    /* servent */
    pse = (LPSERVENT)lpRes->lpBlob->pBlobData;
    bytesOfs = mswBufferEndPtr(mswBuf);
 
    if (!mswBufferIncUsed(mswBuf, sizeof(*pse)))
        return FALSE;
 
    pse->s_aliases = (char**)(mswBufferEndPtr(mswBuf) - bytesOfs);
 
    if (serviceAliasesA)
    {
        if (!mswBufferAppendStrLstA(mswBuf,
                                    (void**)serviceAliasesA,
                                    -(LONG_PTR)bytesOfs))
            return FALSE;
    }
    else
    {
        if (!mswBufferAppendPtr(mswBuf, NULL))
            return FALSE;
    }
 
    pse->s_name = (char*)(mswBufferEndPtr(mswBuf) - bytesOfs);
 
    if (!mswBufferAppendStrA(mswBuf, serviceNameA))
        return FALSE;
 
    pse->s_port = htons(port);
 
    pse->s_proto = (char*)(mswBufferEndPtr(mswBuf) - bytesOfs);
 
    if (!mswBufferAppendStrA(mswBuf, protocolNameA))
        return FALSE;
 
    lpRes->lpBlob->cbSize = (DWORD)(mswBufferEndPtr(mswBuf) - bytesOfs);
    return mswBuf->bufok;
}

Referenced by NSP_LookupServiceNextW().

mswBufferAppendLst()

BOOL mswBufferAppendLst	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ void **	lst,
		_In_ DWORD	itemByteLength,
		_In_opt_ int	deltaofs
	)

Definition at line 104 of file mswhelper.c.

{
    DWORD lstItemCount;
    DWORD lstByteSize;
    DWORD_PTR lstDataPos;
    DWORD i1;
    UINT_PTR *ptrSrcLstPos;
 
    /* calculate size of list */
    ptrSrcLstPos = (UINT_PTR*)lst;
    lstItemCount = 0;
    while (*ptrSrcLstPos != (UINT_PTR)NULL)
    {
        lstItemCount++;
        ptrSrcLstPos++;
    }
 
    lstByteSize = ((lstItemCount + 1) * sizeof(UINT_PTR)) + /* item-pointer + null-ptr (for end) */
                  (lstItemCount * itemByteLength); /* item-data */
 
    if (mswBuf->bytesUsed + lstByteSize > mswBuf->bytesMax)
        return FALSE;
 
    /* calculate position for the data of the first item */
    lstDataPos = ((lstItemCount + 1) * sizeof(UINT_PTR)) +
                 (DWORD_PTR)mswBufferEndPtr(mswBuf);
    /* add ptrofs */
    lstDataPos += ptrofs;
 
    /* write array of Pointer to data */
    for (i1 = 0; i1 < lstItemCount; i1++)
    {
        if (!mswBufferAppendPtr(mswBuf, (void*)lstDataPos))
            return FALSE;
 
        lstDataPos += sizeof(UINT_PTR);
    }
 
    /* end of list */
    if (!mswBufferAppendPtr(mswBuf, NULL))
        return FALSE;
 
    /* write data */
    ptrSrcLstPos = (UINT_PTR*)lst;
    for (i1 = 0; i1 < lstItemCount; i1++)
    {
        mswBufferAppend(mswBuf, *(BYTE**)ptrSrcLstPos, itemByteLength);
        ptrSrcLstPos++;
    }
    return mswBuf->bufok;
}

Referenced by mswBufferAppendBlob_Hostent().

mswBufferAppendPtr()

BOOL mswBufferAppendPtr	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ void *	ptr
	)

Definition at line 86 of file mswhelper.c.

{
    return mswBufferAppend(mswBuf, &ptr, sizeof(ptr));
}

Referenced by mswBufferAppendBlob_Hostent(), mswBufferAppendBlob_Servent(), mswBufferAppendLst(), and mswBufferAppendStrLstA().

mswBufferAppendStrA()

BOOL mswBufferAppendStrA	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ char *	str
	)

Definition at line 71 of file mswhelper.c.

{
    return mswBufferAppend(mswBuf, str, strlen(str) + sizeof(char));
}

Referenced by mswBufferAppendBlob_Hostent(), mswBufferAppendBlob_Servent(), and mswBufferAppendStrLstA().

mswBufferAppendStrLstA()

BOOL mswBufferAppendStrLstA	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ void **	lst,
		_In_opt_ int	ptrofs
	)

Definition at line 160 of file mswhelper.c.

{
    DWORD lstItemLen[MAX_ARRAY_SIZE];
    DWORD lstItemCount;
    DWORD lstByteSize;
    DWORD_PTR lstDataPos;
    DWORD lstDataSize;
    DWORD i1;
    UINT_PTR *ptrSrcLstPos;
 
    /* calculate size of list */
    ptrSrcLstPos = (UINT_PTR*)lst;
    lstItemCount = 0;
    lstDataSize = 0;
 
    while (*ptrSrcLstPos != (UINT_PTR)NULL)
    {
        if (lstItemCount >= MAX_ARRAY_SIZE)
            return FALSE;
 
        i1 = strlen((char*)*ptrSrcLstPos) + sizeof(char);
        lstItemLen[lstItemCount] = i1;
        lstItemCount++;
        lstDataSize += i1;
        ptrSrcLstPos++;
    }
 
    lstByteSize = ((lstItemCount + 1) * sizeof(UINT_PTR)) + /* item-pointer + null-ptr (for end) */
                  lstDataSize; /* item-data */
 
    if (mswBuf->bytesUsed + lstByteSize > mswBuf->bytesMax)
        return FALSE;
 
    /* calculate position for the data of the first item */
    lstDataPos = ((lstItemCount + 1) * sizeof(UINT_PTR)) +
                 (DWORD_PTR)mswBufferEndPtr(mswBuf);
 
    /* add ptrofs */
    lstDataPos += ptrofs;
 
    for (i1 = 0; i1 < lstItemCount; i1++)
    {
        if (!mswBufferAppendPtr(mswBuf, (void*)lstDataPos))
            return FALSE;
 
        lstDataPos += lstItemLen[i1];
    }
 
    /* end of list */
    if (!mswBufferAppendPtr(mswBuf, NULL))
        return FALSE;
 
    /* write data */
    ptrSrcLstPos = (UINT_PTR*)lst;
    for (i1 = 0; i1 < lstItemCount; i1++)
    {
        if (!mswBufferAppendStrA(mswBuf, *(char**)ptrSrcLstPos))
            return FALSE;
 
        ptrSrcLstPos++;
    }
    return mswBuf->bufok;
}

Referenced by mswBufferAppendBlob_Hostent(), and mswBufferAppendBlob_Servent().

mswBufferAppendStrW()

BOOL mswBufferAppendStrW	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ WCHAR *	str
	)

Definition at line 78 of file mswhelper.c.

{
    int bytelen = (wcslen(str) + 1) * sizeof(WCHAR);
    return mswBufferAppend(mswBuf, str, bytelen);
}

Referenced by NSP_LookupServiceNextW().

mswBufferCheck()

BOOL mswBufferCheck	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ DWORD	count
	)

Definition at line 28 of file mswhelper.c.

{
    if (mswBuf->bytesUsed + count <= mswBuf->bytesMax)
        return TRUE;
 
    mswBuf->bufok = FALSE;
    return FALSE;
}

Referenced by mswBufferAppend(), and mswBufferIncUsed().

mswBufferEndPtr()

BYTE * mswBufferEndPtr

(

_Inout_ PMSW_BUFFER

mswBuf

)

Definition at line 51 of file mswhelper.c.

{
    return mswBuf->bufendptr;
}

Referenced by mswBufferAppendAddr_AddrInfoW(), mswBufferAppendBlob_Hostent(), mswBufferAppendBlob_Servent(), mswBufferAppendLst(), mswBufferAppendStrLstA(), and NSP_LookupServiceNextW().

mswBufferIncUsed()

BOOL mswBufferIncUsed	(	_Inout_ PMSW_BUFFER	mswBuf,
		_In_ DWORD	count
	)

Definition at line 39 of file mswhelper.c.

{
    if (!mswBufferCheck(mswBuf, count))
        return FALSE;
 
    mswBuf->bytesUsed += count;
    mswBuf->bufendptr += count;
    return TRUE;
}

Referenced by mswBufferAppendAddr_AddrInfoW(), mswBufferAppendBlob_Hostent(), mswBufferAppendBlob_Servent(), and NSP_LookupServiceNextW().

mswBufferInit()

void mswBufferInit	(	_Out_ PMSW_BUFFER	mswBuf,
		_In_ BYTE *	buffer,
		_In_ DWORD	bufferSize
	)

StrA2WHeapAlloc()

WCHAR * StrA2WHeapAlloc	(	_In_opt_ HANDLE	hHeap,
		_In_ char *	aStr
	)

Definition at line 399 of file mswhelper.c.

{
    int aStrByteLen;
    int wStrByteLen;
    int charLen;
    int ret;
    WCHAR* wStr;
 
    if (aStr == NULL)
        return NULL;
 
    charLen = strlen(aStr) + 1;
 
    aStrByteLen = (charLen * sizeof(char));
    wStrByteLen = (charLen * sizeof(WCHAR));
 
    if (hHeap == 0)
        hHeap = GetProcessHeap();
 
    wStr = HeapAlloc(hHeap, 0, wStrByteLen);
    if (wStr == NULL)
    {
        HeapFree(hHeap, 0, wStr);
        return NULL;
    }
 
    ret = MultiByteToWideChar(CP_ACP,
                              0,
                              aStr,
                              aStrByteLen,
                              wStr,
                              charLen);
 
    if (ret != charLen)
    {
        HeapFree(hHeap, 0, wStr);
        return NULL;
    }
    return wStr;
}

Referenced by NSP_GetServiceByNameHeapAllocW(), and NSP_LookupServiceBeginW().

StrAryCpyHeapAllocA()

char ** StrAryCpyHeapAllocA	(	_In_opt_ HANDLE	hHeap,
		_In_ char **	aStrAry
	)

Definition at line 530 of file mswhelper.c.

{
    char** aSrcPtr;
    char** aDstPtr;
    char* aDstNextStr;
    DWORD aStrByteLen[MAX_ARRAY_SIZE];
    size_t bLen;
    size_t bItmLen;
    int aCount;
    int i1;
    char** resA;
 
    if (hHeap == 0)
        hHeap = GetProcessHeap();
 
    /* Calculating size of array ... */
    aSrcPtr = aStrAry;
    bLen = 0;
    aCount = 0;
 
    while (*aSrcPtr != NULL)
    {
        if (aCount >= MAX_ARRAY_SIZE)
            return NULL;
 
        bItmLen = strlen(*aSrcPtr) + 1;
        aStrByteLen[aCount] = bItmLen;
 
        bLen += sizeof(*aSrcPtr) + bItmLen;
 
        aSrcPtr++;
        aCount++;
    }
 
    /* size for NULL-terminator */
    bLen += sizeof(*aSrcPtr);
 
    /* get memory */
    resA = HeapAlloc(hHeap, 0, bLen);
 
    /* copy data */
    aSrcPtr = aStrAry;
    aDstPtr = resA;
 
    /* pos for the first string */
    aDstNextStr = (char*)(resA + aCount + 1);
    for (i1 = 0; i1 < aCount; i1++)
    {
        bItmLen = aStrByteLen[i1];
 
        *aDstPtr = aDstNextStr;
        RtlCopyMemory(*aDstPtr, *aSrcPtr, bItmLen);
 
        aDstNextStr = (char*)((DWORD_PTR)aDstNextStr + (DWORD)bItmLen);
        aDstPtr++;
        aSrcPtr++;
    }
 
    /* terminate with NULL */
    *aDstPtr = NULL;
 
    return resA;
}

Referenced by NSP_GetServiceByNameHeapAllocW().

StrAryCpyHeapAllocWToA()

char ** StrAryCpyHeapAllocWToA	(	_In_opt_ HANDLE	hHeap,
		_In_ WCHAR **	aStrAry
	)

Definition at line 596 of file mswhelper.c.

{
    WCHAR** wSrcPtr;
    char** aDstPtr;
    char* aDstNextStr;
    DWORD aStrByteLen[MAX_ARRAY_SIZE];
    int bLen;
    int bItmLen;
    int aCount;
    int i1;
    char** resA;
    int ret;
    char* aStr;
 
    if (hHeap == 0)
        hHeap = GetProcessHeap();
 
    /* Calculating size of array ... */
    wSrcPtr = wStrAry;
    bLen = 0;
    aCount = 0;
 
    while (*wSrcPtr != NULL)
    {
        if (aCount >= MAX_ARRAY_SIZE)
            return NULL;
 
        bItmLen = wcslen(*wSrcPtr) + 1;
        aStrByteLen[aCount] = bItmLen;
 
        bLen += sizeof(*wSrcPtr) + bItmLen;
 
        wSrcPtr++;
        aCount++;
    }
 
    /* size for NULL-terminator */
    bLen += sizeof(*wSrcPtr);
 
    /* get memory */
    resA = HeapAlloc(hHeap, 0, bLen);
 
    /* copy data */
    wSrcPtr = wStrAry;
    aDstPtr = resA;
 
    /* pos for the first string */
    aDstNextStr = (char*)(resA + aCount + 1);
    for (i1 = 0; i1 < aCount; i1++)
    {
        bItmLen = aStrByteLen[i1];
 
        *aDstPtr = aDstNextStr;
 
        aStr = HeapAlloc(hHeap, 0, bItmLen);
        if (aStr == NULL)
        {
            HeapFree(hHeap, 0, aStr);
            return NULL;
        }
 
        ret = WideCharToMultiByte(CP_ACP,
                                  0,
                                  *wSrcPtr,
                                  bItmLen,
                                  aStr,
                                  bItmLen,
                                  NULL,
                                  NULL);
        if (ret != bItmLen)
        {
            HeapFree(hHeap, 0, aStr);
            return NULL;
        }
        RtlCopyMemory(*aDstPtr, aStr, bItmLen);
        HeapFree(hHeap, 0, aStr);
 
        aDstNextStr = (char*)((DWORD_PTR)aDstNextStr + (DWORD)bItmLen);
        aDstPtr++;
        wSrcPtr++;
    }
 
    /* terminate with NULL */
    *aDstPtr = NULL;
 
    return resA;
}

Referenced by NSP_GetHostByNameHeapAllocW().

StrCpyHeapAllocA()

char * StrCpyHeapAllocA	(	_In_opt_ HANDLE	hHeap,
		_In_ char *	aStr
	)

Definition at line 507 of file mswhelper.c.

{
    size_t chLen;
    size_t bLen;
    char* resA;
 
    if (aStr == NULL)
        return NULL;
 
    if (hHeap == 0)
        hHeap = GetProcessHeap();
 
    chLen = strlen(aStr);
 
    bLen = (chLen + 1) * sizeof(char);
 
    resA = HeapAlloc(hHeap, 0, bLen);
    RtlCopyMemory(resA, aStr, bLen);
    return resA;
}

StrCpyHeapAllocW()

WCHAR * StrCpyHeapAllocW	(	_In_opt_ HANDLE	hHeap,
		_In_ WCHAR *	wStr
	)

Definition at line 484 of file mswhelper.c.

{
    size_t chLen;
    size_t bLen;
    WCHAR* resW;
 
    if (wStr == NULL)
        return NULL;
 
    if (hHeap == 0)
        hHeap = GetProcessHeap();
 
    chLen = wcslen(wStr);
 
    bLen = (chLen + 1) * sizeof(WCHAR);
 
    resW = HeapAlloc(hHeap, 0, bLen);
    RtlCopyMemory(resW, wStr, bLen);
    return resW;
}

Referenced by NSP_GetHostByNameHeapAllocW(), and NSP_LookupServiceBeginW().

StrW2AHeapAlloc()

char * StrW2AHeapAlloc	(	_In_opt_ HANDLE	hHeap,
		_In_ WCHAR *	wStr
	)

Definition at line 442 of file mswhelper.c.

{
    int charLen;
    int aStrByteLen;
    int ret;
    char* aStr;
 
    if (wStr == NULL)
        return NULL;
 
    charLen = wcslen(wStr) + 1;
 
    aStrByteLen = (charLen * sizeof(char));
 
    if (hHeap == 0)
        hHeap = GetProcessHeap();
 
    aStr = HeapAlloc(hHeap, 0, aStrByteLen);
    if (aStr == NULL)
    {
        HeapFree(hHeap, 0, aStr);
        return NULL;
    }
 
    ret = WideCharToMultiByte(CP_ACP,
                              0,
                              wStr,
                              charLen,
                              aStr,
                              aStrByteLen,
                              NULL,
                              NULL);
    if (ret != aStrByteLen)
    {
        HeapFree(hHeap, 0, aStr);
        return NULL;
    }
    return aStr;
}

Referenced by NSP_GetServiceByNameHeapAllocW(), and NSP_LookupServiceNextW().