2

今天，我能够编写一个简单的 C++ 程序，授予用户“作为服务登录”权限。其中一部分涉及在 aLPCWSTR和a 之间进行转换LSA_UNICODE_STRING。执行此操作的代码在这里：

LSA_UNICODE_STRING StringToLsaUnicodeString(LPCWSTR string) {
    LSA_UNICODE_STRING lsaString;
    DWORD dwLen = 0;

    dwLen = wcslen(string);
    lsaString.Buffer = (LPWSTR) string;
    lsaString.Length = (USHORT)((dwLen) * sizeof(WCHAR));
    lsaString.MaximumLength = (USHORT)((dwLen + 1) * sizeof(WCHAR));
    return lsaString;
}

当我在这个函数中出现一些小错误时，我的调用LsaLookupNames2()失败，代码为 87（十六进制 0x57）“参数不正确。” 我正在尝试在使用std::wstring但失败的 C++ 应用程序中进行此调用。我目前的功能如下：

#if defined(_UNICODE)
    LSA_UNICODE_STRING toLsaUnicodeString (std::wstring str) {
        LSA_UNICODE_STRING lsaWStr;
        DWORD len = 0;

        LPWSTR cstr = (LPWSTR)str.c_str();
        len = wcslen(cstr);
        lsaWStr.Buffer = cstr;
        lsaWStr.Length = (USHORT)((len) * sizeof(WCHAR));
        lsaWStr.MaximumLength = (USHORT)((len + 1) * sizeof(WCHAR));
        return lsaWStr;
    } 
#endif

我究竟做错了什么？

4

3 回答 3

4

您可能会遇到wchar_t*从str.c_str(). str.c_str()将返回一个指向其生命周期由 控制的基础字符串的指针str。由于str是按值传递的，所以会在toLsaUnicodeString函数结束时销毁，导致返回LSA_UNICODE_STRING的内存指向已经被释放的内存。为了避免这种情况，您需要在toLsaUnicodeString函数中制作底层字符串的副本，并将副本与返回的 相关联LSA_UNICODE_STRING，例如：

LSA_UNICODE_STRING toLsaUnicodeString (const std::wstring& str) {
    LSA_UNICODE_STRING lsaWStr;
    DWORD len = 0;

    len = str.length(); 
    LPWSTR cstr = new WCHAR[len + 1];
    memcpy(cstr, str.c_str(), (len + 1) * sizeof(WCHAR));
    lsaWStr.Buffer = cstr;
    lsaWStr.Length = (USHORT)((len) * sizeof(WCHAR));
    lsaWStr.MaximumLength = (USHORT)((len + 1) * sizeof(WCHAR));
    return lsaWStr;
}

由于内存现在是在堆上分配的，因此您有责任确保它被释放。您可以使用以下功能来处理此问题。

void freeLsaUnicodeString(LSA_UNICODE_STRING& str) {
    delete [] str.Buffer;
    str.Buffer = 0;
    str.Length = 0;
    str.MaximumLength = 0;
}

更好的是使用 RAII 来管理内存并保证在变量不再使用时释放它。有关此方法的详细信息，请参阅 Mr_C64 的答案。

于 2012-01-16T03:50:29.353 回答
3

我认为在 C++ 中这样做的正确方法是围绕原始 C 结构 LSA_UNICODE_STRING编写一个RAII 包装类。

此类的构造函数重载正确初始化它，析构函数释放分配的资源（帮助编写异常安全代码），并且您可以提供一些 operator= 重载来进行适当的深度复制。

动态分配的 WCHAR 缓冲区不是使用显式的 new[] 和 delete[]，而是由 std::vector 的实例管理，这简化了代码（例如，std::vector 的析构函数将自动释放分配的内存）。

像这样的东西：

#include <windows.h>     // Win32 SDK header
#include <LsaLookup.h>   // LSA_UNICODE_STRING
#include <vector>        // std::vector
#include <string>        // std::wstring


//
// C++ RAII wrapper to LSA_UNICODE_STRING
//
class LsaUnicodeString
{
public:

    LsaUnicodeString()
    {
        SetEmpty();
    }


    LsaUnicodeString(const LsaUnicodeString & source)
    {
        CopyFrom(source);
    }


    explicit LsaUnicodeString(const std::wstring & source)
    {
        CopyFrom(source);
    }


    ~LsaUnicodeString()
    {
        // Nothing to do:
        // the string buffer is managed by std::vector data member
    }


    LsaUnicodeString & operator=(const LsaUnicodeString & source)
    {
        if (&source != this)
        {
            CopyFrom(source);
        }
        return *this;
    }


    LsaUnicodeString & operator=(const std::wstring & source)
    {
        CopyFrom(source);
        return *this;
    }


    const LSA_UNICODE_STRING & Get() const
    {
        return m_us;
    }


    //
    // Implementation
    //
private:
    LSA_UNICODE_STRING m_us;        // raw C structure
    std::vector<WCHAR> m_buffer;    // string content


    void SetEmpty()
    {
        m_buffer.resize(1);
        m_buffer[0] = L'\0'; // end-of-string

        m_us.Length = 0;
        m_us.MaximumLength = sizeof(WCHAR);
        m_us.Buffer = &m_buffer[0];
    }


    void CopyFrom(const std::wstring & source)
    {
        if ( source.empty() )
        {
            SetEmpty();
            return;
        }

        const int len = source.length();
        m_buffer.resize(len + 1);
        ::CopyMemory(&m_buffer[0], source.c_str(), (len+1)*sizeof(WCHAR));

        m_us.Length = len * sizeof(WCHAR);
        m_us.MaximumLength = m_us.Length + sizeof(WCHAR);
        m_us.Buffer = &m_buffer[0];
    }


    void CopyFrom(const LsaUnicodeString & source)
    {
        if (source.m_us.Length == 0)
        {
            SetEmpty();
            return;
        }

        m_buffer = source.m_buffer;
        m_us.Length = source.m_us.Length;
        m_us.MaximumLength = source.m_us.MaximumLength;
        m_us.Buffer = &m_buffer[0];
    }
};
于 2012-01-16T09:57:41.587 回答
1

您可以使用RtlInitUnicodeString函数来初始化 unicode 字符串。使用 UNICODE_STRING 调用RtlFreeUnicodeString后。

UNICODE_STRING 和 LSA_UNICODE_STRING 是相同的。

于 2012-01-16T14:53:45.907 回答