stringutil.hpp File Reference

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

Go to the source code of this file.

Functions
size_t	FxCalculateTotalStringSize (__in FxCollectionInternal *StringCollection, __in BOOLEAN Verify=FALSE, __out_opt PBOOLEAN ContainsOnlyStrings=NULL)
size_t	FxCalculateTotalMultiSzStringSize (__in __nullnullterminated PCWSTR MultiSz)
PWSTR	FxCopyMultiSz (__out LPWSTR Buffer, __in FxCollectionInternal *StringCollection)
_Must_inspect_result_ NTSTATUS	FxDuplicateUnicodeString (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in const UNICODE_STRING *Source, __out PUNICODE_STRING Destination)
_Must_inspect_result_ PWCHAR	FxDuplicateUnicodeStringToString (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in const UNICODE_STRING *Source)

Function Documentation

FxCalculateTotalMultiSzStringSize()

size_t FxCalculateTotalMultiSzStringSize

(

__in __nullnullterminated PCWSTR

MultiSz

)

Definition at line 84 of file stringutil.cpp.

{
    PCWSTR pCur;
    size_t cbSize, cbLength;
 
    cbSize = 0;
 
    pCur = MultiSz;
 
    while (*pCur != NULL) {
        //
        // Compute length of string including terminating NULL
        //
        cbLength = (wcslen(pCur) + 1) * sizeof(WCHAR);
 
        cbSize += cbLength;
        pCur = (PWSTR) WDF_PTR_ADD_OFFSET(pCur, cbLength);
    }
 
    if (cbSize == 0) {
        //
        // If there are no strings, we still need 2 NULLs
        //
        cbSize = sizeof(UNICODE_NULL);
    }
 
    //
    // Final NULL which makes this a multi sz
    //
    cbSize += sizeof(UNICODE_NULL);
 
    //
    // ASSERT that we are reporting an integral number of WCHARs in bytes
    //
    ASSERT((cbSize % sizeof(WCHAR)) == 0);
 
    return cbSize;
}

Referenced by FxPkgPdo::_PnpQueryId().

FxCalculateTotalStringSize()

size_t FxCalculateTotalStringSize	(	__in FxCollectionInternal *	StringCollection,
		__in BOOLEAN	Verify = FALSE,
		__out_opt PBOOLEAN	ContainsOnlyStrings = NULL
	)

Definition at line 32 of file stringutil.cpp.

{
    size_t cbLength;
    FxString *pString;
    FxCollectionEntry* cur, *end;
 
    cbLength = 0;
 
    end = StringCollection->End();
    for (cur = StringCollection->Start();
         cur != end;
         cur = cur->Next()) {
        pString = (FxString *) cur->m_Object;
 
        if (Verify && pString->GetType() != FX_TYPE_STRING) {
            *ContainsOnlyStrings = FALSE;
            return 0;
        }
 
        cbLength += pString->ByteLength(TRUE);
    }
 
    if (ContainsOnlyStrings != NULL) {
        *ContainsOnlyStrings = TRUE;
    }
 
    if (StringCollection->Count() == 0) {
        //
        // If there are not entries, we still need 2 NULLs
        //
        cbLength = sizeof(UNICODE_NULL) * 2;
    }
    else {
        //
        // Extra NULL
        //
        cbLength += sizeof(UNICODE_NULL);
    }
 
    //
    // ASSERT that we are reporting an integral number of WCHARs in bytes
    //
    ASSERT((cbLength % sizeof(WCHAR)) == 0);
 
    return cbLength;
}

Referenced by FxPkgPdo::Initialize().

FxCopyMultiSz()

PWSTR FxCopyMultiSz	(	__out LPWSTR	Buffer,
		__in FxCollectionInternal *	StringCollection
	)

Definition at line 129 of file stringutil.cpp.

{
    LPWSTR pCur;
    ULONG length;
    FxCollectionEntry* cur, *end;
 
    pCur = Buffer;
    end = StringCollection->End();
 
    for (cur = StringCollection->Start(); cur != end; cur = cur->Next()) {
        FxString* pSourceString;
 
        pSourceString = (FxString *) cur->m_Object;
 
        length = pSourceString->ByteLength(TRUE);
        RtlCopyMemory(pCur, pSourceString->Buffer(), length);
 
        //
        // Length is expressed in number of bytes, not number of
        // characters.
        //
        // length includes the NULL.
        //
        pCur = WDF_PTR_ADD_OFFSET_TYPE(pCur, length, LPWSTR);
    }
 
    //
    // If there are no entries, we still need 2 NULLs.
    //
    if (StringCollection->Count() == 0) {
        *pCur = UNICODE_NULL;
        pCur++;
    }
 
    //
    // double NULL terminate the string
    //
    *pCur = UNICODE_NULL;
 
    //
    // Return the start of the next location in the buffer
    //
    return pCur + 1;
}

Referenced by FxPkgPdo::Initialize().

FxDuplicateUnicodeString()

_Must_inspect_result_ NTSTATUS FxDuplicateUnicodeString	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in const UNICODE_STRING *	Source,
		__out PUNICODE_STRING	Destination
	)

Definition at line 180 of file stringutil.cpp.

{
    NTSTATUS status;
    USHORT srcCbLength, srcCbLengthAndNull, dstMaxCbLength;
 
    //
    // NOTE: We assume the sources string will be smaller than 64k.
    //
    srcCbLength = Source->Length;
    dstMaxCbLength = Destination->MaximumLength;
 
    status = RtlUShortAdd(srcCbLength,
                          sizeof(UNICODE_NULL),
                          &srcCbLengthAndNull);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(
            FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGERROR,
            "Interger overflow occured when duplicating string %!STATUS!",
            status);
        return status;
    }
 
    //
    // First see if we already have enough memory to hold the string + a NULL
    //
    if (dstMaxCbLength < srcCbLengthAndNull) {
        //
        // Allocate enough memory for the source string and a NULL character
        //
        dstMaxCbLength = srcCbLengthAndNull;
 
        //
        // We need to allocate memory.  Free any old memory first.
        //
        if (Destination->Buffer != NULL) {
            FxPoolFree(Destination->Buffer);
 
            RtlZeroMemory(Destination, sizeof(UNICODE_STRING));
        }
 
        Destination->Buffer = (PWSTR) FxPoolAllocate(
            FxDriverGlobals, PagedPool, dstMaxCbLength);
 
        if (Destination->Buffer == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGERROR,
                "Failed to allocate memory when duplicating string %!STATUS!",
                status);
            return status;
        }
 
        Destination->MaximumLength =  dstMaxCbLength;
    }
 
    //
    // If we get here and we have a buffer, then we can just copy the
    // string into the buffer.
    //
    RtlCopyMemory(Destination->Buffer, Source->Buffer, srcCbLength);
    Destination->Length = srcCbLength;
 
    //
    // Make sure the string is NULL terminated and there is room for the NULL
    //
    ASSERT(Destination->Length + sizeof(UNICODE_NULL) <=
                                                    Destination->MaximumLength);
    Destination->Buffer[Destination->Length/sizeof(WCHAR)] = UNICODE_NULL;
 
    return STATUS_SUCCESS;
}

Referenced by FxString::Assign(), FxDevice::CreateSymbolicLink(), FxDeviceInterface::Initialize(), and FxIoTargetRemote::Open().

FxDuplicateUnicodeStringToString()

_Must_inspect_result_ PWCHAR FxDuplicateUnicodeStringToString	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in const UNICODE_STRING *	Source
	)

Definition at line 287 of file stringutil.cpp.

{
    PWSTR pDuplicate;
 
    pDuplicate = (PWSTR) FxPoolAllocate(
        FxDriverGlobals, PagedPool, Source->Length + sizeof(UNICODE_NULL));
 
    if (pDuplicate != NULL) {
        RtlCopyMemory(pDuplicate, Source->Buffer, Source->Length);
 
        //
        // Make sure the string is NULL terminated.  We can safely do this
        // because we allocated an extra WCHAR for the null terminator.
        //
        pDuplicate[Source->Length/sizeof(WCHAR)] = UNICODE_NULL;
    }
 
    return pDuplicate;
}