¿Cómo convierto una cadena std::wstring en una cadena LSA_UNICODE_STRING?

Creo que la forma correcta de hacer esto en C++ es escribir una directiva Envoltorio RAII en torno a la estructura C bruta LSA_UNICODE_STRING.

Las sobrecargas del constructor de esta clase la inicializan adecuadamente, el destructor libera los recursos asignados (ayudando a escribir código a prueba de excepciones), y puedes proporcionar algunas sobrecargas operator= para hacer copias profundas adecuadas.

En lugar de utilizar explícitamente new[] y delete[], el buffer WCHAR asignado dinámicamente es gestionado por una instancia de std::vector, lo que simplifica el código (por ejemplo, el destructor de std::vector liberará automáticamente la memoria asignada).

Algo así:

#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];
    }
};

Puede utilizar la función RtlInitUnicodeString para inicializar una cadena unicode. Después de utilizar la llamada UNICODE_STRING RtlFreeUnicodeString .

UNICODE_STRING y LSA_UNICODE_STRING son idénticos.