自学教程：C++ ConvertToUnicode函数代码示例

void sspi_SetAuthIdentity(SEC_WINNT_AUTH_IDENTITY* identity, char* user, char* domain, char* password){	identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;	if (user)	{		identity->UserLength = ConvertToUnicode(CP_UTF8, 0, user, -1, &identity->User, 0) - 1;	}	else	{		identity->User = (UINT16*) NULL;		identity->UserLength = 0;	}	if (domain)	{		identity->DomainLength = ConvertToUnicode(CP_UTF8, 0, domain, -1, &identity->Domain, 0) - 1;	}	else	{		identity->Domain = (UINT16*) NULL;		identity->DomainLength = 0;	}	if (password != NULL)	{		identity->PasswordLength = ConvertToUnicode(CP_UTF8, 0, password, -1, &identity->Password, 0) - 1;	}	else	{		identity->Password = NULL;		identity->PasswordLength = 0;	}}

int test_unicode_uppercasing(BYTE* lower, BYTE* upper){	WCHAR* lowerW = NULL;	int lowerLength;	WCHAR* upperW = NULL;	int upperLength;	lowerLength = ConvertToUnicode(CP_UTF8, 0, (LPSTR) lower, -1, &lowerW, 0);	upperLength = ConvertToUnicode(CP_UTF8, 0, (LPSTR) upper, -1, &upperW, 0);	CharUpperBuffW(lowerW, lowerLength);	if (_wcscmp(lowerW, upperW) != 0)	{		printf("Lowercase String:/n");		string_hexdump((BYTE*) lowerW, lowerLength * 2);		printf("Uppercase String:/n");		string_hexdump((BYTE*) upperW, upperLength * 2);		return -1;	}	free(lowerW);	free(upperW);	return 0;}

// This method is called during the sending of message from nsMsgCompose::CheckAndPopulateRecipients()nsresult nsMsgCompFields::SplitRecipientsEx(const nsAString &recipients,                                            nsTArray<nsMsgRecipient> &aResult){  nsresult rv;    nsCOMPtr<nsIMsgHeaderParser> parser =    do_GetService(NS_MAILNEWS_MIME_HEADER_PARSER_CONTRACTID, &rv);  NS_ENSURE_SUCCESS(rv, rv);  nsCOMPtr<nsIMimeConverter> converter = do_GetService(NS_MIME_CONVERTER_CONTRACTID, &rv);  NS_ENSURE_SUCCESS(rv, rv);  nsCAutoString recipientsStr;  char *names;  char *addresses;  PRUint32 numAddresses;        CopyUTF16toUTF8(recipients, recipientsStr);  rv = parser->ParseHeaderAddresses(recipientsStr.get(), &names,                                    &addresses, &numAddresses);  if (NS_SUCCEEDED(rv))  {    char *pNames = names;    char *pAddresses = addresses;    for (PRUint32 i = 0; i < numAddresses; ++i)    {      nsCString fullAddress;      nsCString decodedName;      converter->DecodeMimeHeaderToCharPtr(pNames, GetCharacterSet(), false, true,                                            getter_Copies(decodedName));      rv = parser->MakeFullAddressString((!decodedName.IsEmpty() ?                                           decodedName.get() : pNames),                                          pAddresses,                                          getter_Copies(fullAddress));      nsMsgRecipient msgRecipient;      rv = ConvertToUnicode("UTF-8",                            NS_SUCCEEDED(rv) ? fullAddress.get() : pAddresses,                            msgRecipient.mAddress);      if (NS_FAILED(rv))        return rv;      rv = ConvertToUnicode("UTF-8", pAddresses, msgRecipient.mEmail);      if (NS_FAILED(rv))        return rv;      aResult.AppendElement(msgRecipient);      pNames += PL_strlen(pNames) + 1;      pAddresses += PL_strlen(pAddresses) + 1;    }    PR_FREEIF(names);    PR_FREEIF(addresses);  }   return rv;}

LPTSTR nla_make_spn(const char* ServiceClass, const char* hostname){	DWORD status;	DWORD SpnLength;	LPTSTR hostnameX = NULL;	LPTSTR ServiceClassX = NULL;	LPTSTR ServicePrincipalName = NULL;#ifdef UNICODE	ConvertToUnicode(CP_UTF8, 0, hostname, -1, &hostnameX, 0);	ConvertToUnicode(CP_UTF8, 0, ServiceClass, -1, &ServiceClassX, 0);#else	hostnameX = _strdup(hostname);	ServiceClassX = _strdup(ServiceClass);#endif	if (!hostnameX || !ServiceClassX)	{		free(hostnameX);		free(ServiceClassX);		return NULL;	}	if (!ServiceClass)	{		ServicePrincipalName = (LPTSTR) _tcsdup(hostnameX);		free(ServiceClassX);		free(hostnameX);		return ServicePrincipalName;	}	SpnLength = 0;	status = DsMakeSpn(ServiceClassX, hostnameX, NULL, 0, NULL, &SpnLength, NULL);	if (status != ERROR_BUFFER_OVERFLOW)	{		free(ServiceClassX);		free(hostnameX);		return NULL;	}	ServicePrincipalName = (LPTSTR) malloc(SpnLength * sizeof(TCHAR));	if (!ServicePrincipalName)		return NULL;	status = DsMakeSpn(ServiceClassX, hostnameX, NULL, 0, NULL, &SpnLength, ServicePrincipalName);	if (status != ERROR_SUCCESS)	{		free(ServicePrincipalName);		free(ServiceClassX);		free(hostnameX);		return NULL;	}	free(ServiceClassX);	free(hostnameX);	return ServicePrincipalName;}

int sspi_SetAuthIdentity(SEC_WINNT_AUTH_IDENTITY* identity, const char* user, const char* domain, const char* password){	int status;	identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;	if (identity->User)		free(identity->User);	identity->User = (UINT16*) NULL;	identity->UserLength = 0;	if (user)	{		status = ConvertToUnicode(CP_UTF8, 0, user, -1, (LPWSTR*) &(identity->User), 0);		if (status <= 0)			return -1;		identity->UserLength = (ULONG) (status - 1);	}	if (identity->Domain)		free(identity->Domain);	identity->Domain = (UINT16*) NULL;	identity->DomainLength = 0;	if (domain)	{		status = ConvertToUnicode(CP_UTF8, 0, domain, -1, (LPWSTR*) &(identity->Domain), 0);		if (status <= 0)			return -1;		identity->DomainLength = (ULONG) (status - 1);	}	if (identity->Password)		free(identity->Password);	identity->Password = NULL;	identity->PasswordLength = 0;	if (password)	{		status = ConvertToUnicode(CP_UTF8, 0, password, -1, (LPWSTR*) &(identity->Password), 0);		if (status <= 0)			return -1;		identity->PasswordLength = (ULONG) (status - 1);	}	return 1;}

void rdp_write_extended_info_packet(rdpRdp* rdp, wStream* s){	int clientAddressFamily;	WCHAR* clientAddress = NULL;	int cbClientAddress;	WCHAR* clientDir = NULL;	int cbClientDir;	int cbAutoReconnectCookie;	rdpSettings* settings = rdp->settings;	clientAddressFamily = settings->IPv6Enabled ? ADDRESS_FAMILY_INET6 : ADDRESS_FAMILY_INET;	cbClientAddress = ConvertToUnicode(CP_UTF8, 0, settings->ClientAddress, -1, &clientAddress, 0) * 2;	cbClientDir = ConvertToUnicode(CP_UTF8, 0, settings->ClientDir, -1, &clientDir, 0) * 2;	cbAutoReconnectCookie = (int) settings->ServerAutoReconnectCookie->cbLen;	Stream_Write_UINT16(s, clientAddressFamily); /* clientAddressFamily (2 bytes) */	Stream_Write_UINT16(s, cbClientAddress + 2); /* cbClientAddress (2 bytes) */	if (cbClientAddress > 0)		Stream_Write(s, clientAddress, cbClientAddress); /* clientAddress */	Stream_Write_UINT16(s, 0);	Stream_Write_UINT16(s, cbClientDir + 2); /* cbClientDir (2 bytes) */	if (cbClientDir > 0)		Stream_Write(s, clientDir, cbClientDir); /* clientDir */	Stream_Write_UINT16(s, 0);	rdp_write_client_time_zone(s, settings); /* clientTimeZone (172 bytes) */	Stream_Write_UINT32(s, 0); /* clientSessionId (4 bytes), should be set to 0 */	freerdp_performance_flags_make(settings);	Stream_Write_UINT32(s, settings->PerformanceFlags); /* performanceFlags (4 bytes) */	Stream_Write_UINT16(s, cbAutoReconnectCookie); /* cbAutoReconnectCookie (2 bytes) */	if (cbAutoReconnectCookie > 0)	{		rdp_compute_client_auto_reconnect_cookie(rdp);		rdp_write_client_auto_reconnect_cookie(rdp, s); /* autoReconnectCookie */		Stream_Write_UINT16(s, 0); /* reserved1 (2 bytes) */		Stream_Write_UINT16(s, 0); /* reserved2 (2 bytes) */	}	free(clientAddress);	free(clientDir);}

static int remdesk_send_ctl_authenticate_pdu(remdeskPlugin* remdesk){	int status;	wStream* s;	int cbExpertBlobW = 0;	WCHAR* expertBlobW = NULL;	int cbRaConnectionStringW = 0;	WCHAR* raConnectionStringW = NULL;	REMDESK_CTL_AUTHENTICATE_PDU pdu;	status = remdesk_generate_expert_blob(remdesk);	if (status < 0)		return -1;	pdu.expertBlob = remdesk->ExpertBlob;	pdu.raConnectionString = remdesk->settings->RemoteAssistanceRCTicket;	status = ConvertToUnicode(CP_UTF8, 0, pdu.raConnectionString, -1, &raConnectionStringW, 0);	if (status <= 0)		return -1;	cbRaConnectionStringW = status * 2;	status = ConvertToUnicode(CP_UTF8, 0, pdu.expertBlob, -1, &expertBlobW, 0);	if (status <= 0)		return -1;	cbExpertBlobW = status * 2;	remdesk_prepare_ctl_header(&(pdu.ctlHeader), REMDESK_CTL_AUTHENTICATE,			cbRaConnectionStringW + cbExpertBlobW);	s = Stream_New(NULL, REMDESK_CHANNEL_CTL_SIZE + pdu.ctlHeader.DataLength);	remdesk_write_ctl_header(s, &(pdu.ctlHeader));	Stream_Write(s, (BYTE*) raConnectionStringW, cbRaConnectionStringW);	Stream_Write(s, (BYTE*) expertBlobW, cbExpertBlobW);	Stream_SealLength(s);	remdesk_virtual_channel_write(remdesk, s);	free(raConnectionStringW);	free(expertBlobW);	return 1;}

HMODULE LoadLibraryA(LPCSTR lpLibFileName){#if defined(_UWP)	int status;	HMODULE hModule = NULL;	WCHAR* filenameW = NULL;	if (!lpLibFileName)		return NULL;	status = ConvertToUnicode(CP_UTF8, 0, lpLibFileName, -1, &filenameW, 0);	if (status < 1)		return NULL;	hModule = LoadPackagedLibrary(filenameW, 0);	free(filenameW);	return hModule;#else	HMODULE library;	library = dlopen(lpLibFileName, RTLD_LOCAL | RTLD_LAZY);	if (!library)	{		WLog_ERR(TAG, "LoadLibraryA: %s", dlerror());		return NULL;	}	return library;#endif}

int cliprdr_temp_directory(CliprdrClientContext* context, CLIPRDR_TEMP_DIRECTORY* tempDirectory){	int length;	wStream* s;	WCHAR* wszTempDir = NULL;	cliprdrPlugin* cliprdr = (cliprdrPlugin*) context->handle;	s = cliprdr_packet_new(CB_TEMP_DIRECTORY, 0, 520 * 2);	length = ConvertToUnicode(CP_UTF8, 0, tempDirectory->szTempDir, -1, &wszTempDir, 0);	if (length < 0)		return -1;	if (length > 520)		length = 520;	Stream_Write(s, tempDirectory->szTempDir, length * 2);	Stream_Zero(s, (520 - length) * 2);	free(wszTempDir);	WLog_Print(cliprdr->log, WLOG_DEBUG, "TempDirectory: %s",			tempDirectory->szTempDir);	cliprdr_packet_send(cliprdr, s);	return 1;}

int statvfs(const char *path, struct statvfs *buf){	BOOL res;	int len;	LPWSTR unicodestr = NULL;	DWORD lpSectorsPerCluster;	DWORD lpBytesPerSector;	DWORD lpNumberOfFreeClusters;	DWORD lpTotalNumberOfClusters;	len = ConvertToUnicode(CP_ACP, 0, path, -1, &unicodestr, 0);	if (len <= 0)		return -1;	res = GetDiskFreeSpaceW(unicodestr, &lpSectorsPerCluster, &lpBytesPerSector, &lpNumberOfFreeClusters, &lpTotalNumberOfClusters);	free(unicodestr);	buf->f_bsize = lpBytesPerSector; /* file system block size */	buf->f_frsize = 0; /* fragment size */	buf->f_blocks = lpTotalNumberOfClusters; /* size of fs in f_frsize units */	buf->f_bfree = lpNumberOfFreeClusters; /* # free blocks */	buf->f_bavail = lpNumberOfFreeClusters; /* # free blocks for unprivileged users */	buf->f_files = 0; /* # inodes */	buf->f_ffree = 0; /* # free inodes */	buf->f_favail = 0; /* # free inodes for unprivileged users */	buf->f_fsid = lpNumberOfFreeClusters & 0xffff; /* file system ID */	buf->f_flag = 0; /* mount flags */	buf->f_namemax = 250; /* maximum filename length */		return res;}

static void* clipboard_synthesize_cf_unicodetext(wClipboard* clipboard, UINT32 formatId,        const void* data, UINT32* pSize){	int size;	int status;	char* crlfStr = NULL;	WCHAR* pDstData = NULL;	if ((formatId == CF_TEXT) || (formatId == CF_OEMTEXT) ||	    (formatId == ClipboardGetFormatId(clipboard, "UTF8_STRING")) ||	    (formatId == ClipboardGetFormatId(clipboard, "text/plain")) ||	    (formatId == ClipboardGetFormatId(clipboard, "TEXT")) ||	    (formatId == ClipboardGetFormatId(clipboard, "STRING")))	{		if (!pSize || (*pSize > INT32_MAX))			return NULL;		size = (int) * pSize;		crlfStr = ConvertLineEndingToCRLF((char*) data, &size);		if (!crlfStr)			return NULL;		status = ConvertToUnicode(CP_UTF8, 0, crlfStr, size, &pDstData, 0);		free(crlfStr);		if (status <= 0)			return NULL;		*pSize = status * 2;	}	return (void*) pDstData;}

int ntlm_SetContextWorkstation(NTLM_CONTEXT* context, char* Workstation){	int status;	DWORD nSize = 0;	char* ws = Workstation;	if (!Workstation)	{		GetComputerNameExA(ComputerNameNetBIOS, NULL, &nSize);				ws = (char*) malloc(nSize);		if (!ws)			return -1;		if (!GetComputerNameExA(ComputerNameNetBIOS, ws, &nSize))			return 0;	}	context->Workstation.Buffer = NULL;	status = ConvertToUnicode(CP_UTF8, 0, ws, -1, &context->Workstation.Buffer, 0);	free(ws);	if (status <= 0)		return -1;	context->Workstation.Length = (USHORT) (status - 1);	context->Workstation.Length *= 2;	if (!Workstation)		free(Workstation);	return 1;}

void nsMsgI18NConvertRawBytesToUTF16(const nsCString& inString,                                      const char* charset,                                     nsAString& outString){  if (MsgIsUTF8(inString))  {    CopyUTF8toUTF16(inString, outString);    return;  }  nsresult rv = ConvertToUnicode(charset, inString, outString);  if (NS_SUCCEEDED(rv))    return;  const char* cur = inString.BeginReading();  const char* end = inString.EndReading();  outString.Truncate();  while (cur < end) {    char c = *cur++;    if (c & char(0x80))      outString.Append(UCS2_REPLACEMENT_CHAR);    else      outString.Append(c);  }}

static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr){	STREAM* data_out;	WCHAR* computerNameW = NULL;	size_t computerNameLenW;	if (!rdpdr->computerName[0])		gethostname(rdpdr->computerName, sizeof(rdpdr->computerName) - 1);	computerNameLenW = ConvertToUnicode(CP_UTF8, 0, rdpdr->computerName, -1, &computerNameW, 0) * 2;	data_out = stream_new(16 + computerNameLenW + 2);	stream_write_UINT16(data_out, RDPDR_CTYP_CORE);	stream_write_UINT16(data_out, PAKID_CORE_CLIENT_NAME);	stream_write_UINT32(data_out, 1); /* unicodeFlag, 0 for ASCII and 1 for Unicode */	stream_write_UINT32(data_out, 0); /* codePage, must be set to zero */	stream_write_UINT32(data_out, computerNameLenW + 2); /* computerNameLen, including null terminator */	stream_write(data_out, computerNameW, computerNameLenW);	stream_write_UINT16(data_out, 0); /* null terminator */	free(computerNameW);	svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);}

static int remdesk_send_ctl_remote_control_desktop_pdu(remdeskPlugin* remdesk){	int status;	wStream* s;	int cbRaConnectionStringW = 0;	WCHAR* raConnectionStringW = NULL;	REMDESK_CTL_REMOTE_CONTROL_DESKTOP_PDU pdu;	pdu.raConnectionString = remdesk->settings->RemoteAssistanceRCTicket;	status = ConvertToUnicode(CP_UTF8, 0, pdu.raConnectionString, -1, &raConnectionStringW, 0);	if (status <= 0)		return -1;	cbRaConnectionStringW = status * 2;	remdesk_prepare_ctl_header(&(pdu.ctlHeader), REMDESK_CTL_REMOTE_CONTROL_DESKTOP, cbRaConnectionStringW);	s = Stream_New(NULL, REMDESK_CHANNEL_CTL_SIZE + pdu.ctlHeader.DataLength);	remdesk_write_ctl_header(s, &(pdu.ctlHeader));	Stream_Write(s, (BYTE*) raConnectionStringW, cbRaConnectionStringW);	Stream_SealLength(s);	remdesk_virtual_channel_write(remdesk, s);	free(raConnectionStringW);	return 1;}

int ntlm_SetContextTargetName(NTLM_CONTEXT* context, char* TargetName){	int status;	DWORD nSize = 0;	char* name = TargetName;	if (!TargetName)	{		if (!GetComputerNameExA(ComputerNameDnsHostname, NULL, &nSize))			return -1;		name = (char*) malloc(nSize);		if (!name)			return -1;		if (!GetComputerNameExA(ComputerNameDnsHostname, name, &nSize))			return -1;		CharUpperA(TargetName);	}	context->TargetName.pvBuffer = NULL;	status = ConvertToUnicode(CP_UTF8, 0, name, -1, (LPWSTR*) &context->TargetName.pvBuffer, 0);	if (status <= 0)		return -1;	context->TargetName.cbBuffer = (USHORT) ((status - 1) * 2);	if (!TargetName)		free(name);	return 1;}

void nsMsgI18NConvertRawBytesToUTF8(const nsCString& inString,                                     const char* charset,                                    nsACString& outString){  if (MsgIsUTF8(inString))  {    outString.Assign(inString);    return;  }  nsAutoString utf16Text;  nsresult rv = ConvertToUnicode(charset, inString, utf16Text);  if (NS_SUCCEEDED(rv))  {    CopyUTF16toUTF8(utf16Text, outString);    return;  }  // EF BF BD (UTF-8 encoding of U+FFFD)  NS_NAMED_LITERAL_CSTRING(utf8ReplacementChar, "/357/277/275");  const char* cur = inString.BeginReading();  const char* end = inString.EndReading();  outString.Truncate();  while (cur < end) {    char c = *cur++;    if (c & char(0x80))      outString.Append(utf8ReplacementChar);    else      outString.Append(c);  }}

void rdp_write_extended_info_packet(wStream* s, rdpSettings* settings){	int clientAddressFamily;	WCHAR* clientAddress = NULL;	int cbClientAddress;	WCHAR* clientDir = NULL;	int cbClientDir;	int cbAutoReconnectLen;	clientAddressFamily = settings->IPv6Enabled ? ADDRESS_FAMILY_INET6 : ADDRESS_FAMILY_INET;	cbClientAddress = ConvertToUnicode(CP_UTF8, 0, settings->ClientAddress, -1, &clientAddress, 0) * 2;	cbClientDir = ConvertToUnicode(CP_UTF8, 0, settings->ClientDir, -1, &clientDir, 0) * 2;	cbAutoReconnectLen = (int) settings->ClientAutoReconnectCookie->cbLen;	Stream_Write_UINT16(s, clientAddressFamily); /* clientAddressFamily */	Stream_Write_UINT16(s, cbClientAddress + 2); /* cbClientAddress */	if (cbClientAddress > 0)		Stream_Write(s, clientAddress, cbClientAddress); /* clientAddress */	Stream_Write_UINT16(s, 0);	Stream_Write_UINT16(s, cbClientDir + 2); /* cbClientDir */	if (cbClientDir > 0)		Stream_Write(s, clientDir, cbClientDir); /* clientDir */	Stream_Write_UINT16(s, 0);	rdp_write_client_time_zone(s, settings); /* clientTimeZone */	Stream_Write_UINT32(s, 0); /* clientSessionId, should be set to 0 */	Stream_Write_UINT32(s, settings->PerformanceFlags); /* performanceFlags */	Stream_Write_UINT16(s, cbAutoReconnectLen); /* cbAutoReconnectLen */	if (cbAutoReconnectLen > 0)		rdp_write_client_auto_reconnect_cookie(s, settings); /* autoReconnectCookie */	/* reserved1 (2 bytes) */	/* reserved2 (2 bytes) */	free(clientAddress);	free(clientDir);}

int HunspellInterface::InitializeSpellCheckEngine(){  UninitializeSpellCheckEngine();  wxString strAffixFile = GetAffixFileName();  wxString strDictionaryFile = GetDictionaryFileName();  if ( wxFileName::FileExists(strAffixFile) && wxFileName::FileExists(strDictionaryFile) )  {    wxCharBuffer affixFileCharBuffer = ConvertToUnicode(strAffixFile);    wxCharBuffer dictionaryFileCharBuffer = ConvertToUnicode(strDictionaryFile);    m_pHunspell = new Hunspell(affixFileCharBuffer, dictionaryFileCharBuffer);  }  m_bEngineInitialized = (m_pHunspell != NULL);  return m_bEngineInitialized;}

int sspi_SetAuthIdentityWithUnicodePassword(SEC_WINNT_AUTH_IDENTITY* identity, const char* user,        const char* domain, LPWSTR password, ULONG passwordLength){	int status;	identity->Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;	free(identity->User);	identity->User = (UINT16*) NULL;	identity->UserLength = 0;	if (user)	{		status = ConvertToUnicode(CP_UTF8, 0, user, -1, (LPWSTR*) & (identity->User), 0);		if (status <= 0)			return -1;		identity->UserLength = (ULONG)(status - 1);	}	free(identity->Domain);	identity->Domain = (UINT16*) NULL;	identity->DomainLength = 0;	if (domain)	{		status = ConvertToUnicode(CP_UTF8, 0, domain, -1, (LPWSTR*) & (identity->Domain), 0);		if (status <= 0)			return -1;		identity->DomainLength = (ULONG)(status - 1);	}	free(identity->Password);	identity->Password = (UINT16*) calloc(1, (passwordLength + 1) * sizeof(WCHAR));	if (!identity->Password)		return -1;	CopyMemory(identity->Password, password, passwordLength * sizeof(WCHAR));	identity->PasswordLength = passwordLength;	return 1;}

SECURITY_STATUS SEC_ENTRY schannel_AcquireCredentialsHandleA(SEC_CHAR* pszPrincipal, SEC_CHAR* pszPackage,		ULONG fCredentialUse, void* pvLogonID, void* pAuthData, SEC_GET_KEY_FN pGetKeyFn,		void* pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry){	SECURITY_STATUS status;	SEC_WCHAR* pszPrincipalW = NULL;	SEC_WCHAR* pszPackageW = NULL;	ConvertToUnicode(CP_UTF8, 0, pszPrincipal, -1, &pszPrincipalW, 0);	ConvertToUnicode(CP_UTF8, 0, pszPackage, -1, &pszPackageW, 0);	status = schannel_AcquireCredentialsHandleW(pszPrincipalW, pszPackageW, fCredentialUse, pvLogonID,			pAuthData, pGetKeyFn, pvGetKeyArgument, phCredential, ptsExpiry);	free(pszPrincipalW);	free(pszPackageW);	return SEC_E_OK;}

Info::Info(wxWindow* parent) : GUIInfo(parent){	std::string inf=getFile(g_res_path+"info_"+g_lang+".txt");	if(inf.empty())	{		inf=getFile(g_res_path+"info.txt");	}	m_textCtrl14->SetValue(ConvertToUnicode(inf));	Show(true);}

bool HunspellInterface::IsWordInDictionary(const wxString& strWord){  if (m_pHunspell == NULL)    return false;  wxCharBuffer wordCharBuffer = ConvertToUnicode(strWord);  if ( wordCharBuffer == NULL )    return false;  return ((m_pHunspell->spell(wordCharBuffer) == 1) || (m_PersonalDictionary.IsWordInDictionary(strWord)));}

std::vector<SBackupDir> Connector::getSharedPaths(void){    std::vector<SBackupDir> ret;    std::string d=getResponse("1GET BACKUP DIRS","");    int lc=linecount(d);    for(int i=0; i<lc; i+=2)    {        SBackupDir bd;        bd.id=atoi(getline(i, d).c_str() );        std::string path=getline(i+1, d);        bd.path=wxString::FromUTF8(path.c_str() );        if(path.find("|")!=std::string::npos)        {            bd.path=ConvertToUnicode(getafter("|", path));            bd.name=ConvertToUnicode(getuntil("|", path));        }        ret.push_back( bd );    }    return ret;}

SecurityFunctionTableW* sspi_GetSecurityFunctionTableWByNameA(const SEC_CHAR* Name){	SEC_WCHAR* NameW;	SecurityFunctionTableW* table;	ConvertToUnicode(CP_UTF8, 0, Name, -1, &NameW, 0);	table = sspi_GetSecurityFunctionTableWByNameW(NameW);	free(NameW);	return table;}

/** * Function description * * @return 0 on success, otherwise a Win32 error code */static UINT remdesk_send_ctl_verify_password_pdu(remdeskPlugin* remdesk){	int status;	UINT error;	wStream* s;	int cbExpertBlobW = 0;	WCHAR* expertBlobW = NULL;	REMDESK_CTL_VERIFY_PASSWORD_PDU pdu;	if ((error = remdesk_generate_expert_blob(remdesk)))	{		WLog_ERR(TAG, "remdesk_generate_expert_blob failed with error %lu!", error);		return error;	}	pdu.expertBlob = remdesk->ExpertBlob;	status = ConvertToUnicode(CP_UTF8, 0, pdu.expertBlob, -1, &expertBlobW, 0);	if (status <= 0)	{		WLog_ERR(TAG, "ConvertToUnicode failed!");		return ERROR_INTERNAL_ERROR;	}	cbExpertBlobW = status * 2;	remdesk_prepare_ctl_header(&(pdu.ctlHeader), REMDESK_CTL_VERIFY_PASSWORD, cbExpertBlobW);	s = Stream_New(NULL, REMDESK_CHANNEL_CTL_SIZE + pdu.ctlHeader.DataLength);	if (!s)	{		WLog_ERR(TAG, "Stream_New failed!");		error = CHANNEL_RC_NO_MEMORY;		goto out;	}	remdesk_write_ctl_header(s, &(pdu.ctlHeader));	Stream_Write(s, (BYTE*) expertBlobW, cbExpertBlobW);	Stream_SealLength(s);	if ((error = remdesk_virtual_channel_write(remdesk, s)))		WLog_ERR(TAG, "remdesk_virtual_channel_write failed with error %lu!", error);out:	free(expertBlobW);	if (error != CHANNEL_RC_OK)		Stream_Free(s, TRUE);	return error;}

BOOL nego_send_preconnection_pdu(rdpNego* nego){	wStream* s;	UINT32 cbSize;	UINT16 cchPCB = 0;	WCHAR* wszPCB = NULL;	WLog_DBG(TAG, "Sending preconnection PDU");	if (!nego_tcp_connect(nego))		return FALSE;	/* it's easier to always send the version 2 PDU, and it's just 2 bytes overhead */	cbSize = PRECONNECTION_PDU_V2_MIN_SIZE;	if (nego->PreconnectionBlob)	{		cchPCB = (UINT16) ConvertToUnicode(CP_UTF8, 0, nego->PreconnectionBlob, -1, &wszPCB, 0);		cchPCB += 1; /* zero-termination */		cbSize += cchPCB * 2;	}	s = Stream_New(NULL, cbSize);	if (!s)	{		free(wszPCB);		WLog_ERR(TAG, "Stream_New failed!");		return FALSE;	}	Stream_Write_UINT32(s, cbSize); /* cbSize */	Stream_Write_UINT32(s, 0); /* Flags */	Stream_Write_UINT32(s, PRECONNECTION_PDU_V2); /* Version */	Stream_Write_UINT32(s, nego->PreconnectionId); /* Id */	Stream_Write_UINT16(s, cchPCB); /* cchPCB */	if (wszPCB)	{		Stream_Write(s, wszPCB, cchPCB * 2); /* wszPCB */		free(wszPCB);	}	Stream_SealLength(s);	if (transport_write(nego->transport, s) < 0)	{		Stream_Free(s, TRUE);		return FALSE;	}	Stream_Free(s, TRUE);	return TRUE;}

static BOOL rdg_send_tunnel_request(rdpRdg* rdg){	wStream* s;	BOOL status;	UINT32 packetSize = 16;	UINT16 fieldsPresent = 0;	WCHAR* PAACookie = NULL;	UINT16 PAACookieLen = 0;	if (rdg->extAuth == HTTP_EXTENDED_AUTH_PAA)	{		PAACookieLen = ConvertToUnicode(CP_UTF8, 0, rdg->settings->GatewayAccessToken, -1, &PAACookie, 0);		if (!PAACookie)			return FALSE;		packetSize += 2 + PAACookieLen * sizeof(WCHAR);		fieldsPresent = HTTP_TUNNEL_PACKET_FIELD_PAA_COOKIE;	}	s = Stream_New(NULL, packetSize);	if (!s)	{		free(PAACookie);		return FALSE;	}	Stream_Write_UINT16(s, PKT_TYPE_TUNNEL_CREATE); /* Type (2 bytes) */	Stream_Write_UINT16(s, 0); /* Reserved (2 bytes) */	Stream_Write_UINT32(s, packetSize); /* PacketLength (4 bytes) */	Stream_Write_UINT32(s, HTTP_CAPABILITY_TYPE_QUAR_SOH); /* CapabilityFlags (4 bytes) */	Stream_Write_UINT16(s, fieldsPresent); /* FieldsPresent (2 bytes) */	Stream_Write_UINT16(s, 0); /* Reserved (2 bytes), must be 0 */	if (PAACookie)	{		Stream_Write_UINT16(s, PAACookieLen * 2); /* PAA cookie string length */		Stream_Write_UTF16_String(s, PAACookie, PAACookieLen);	}	Stream_SealLength(s);	status = rdg_write_packet(rdg, s);	Stream_Free(s, TRUE);	free(PAACookie);	if (status)	{		rdg->state = RDG_CLIENT_STATE_TUNNEL_CREATE;	}	return status;}

int ntlm_SetContextTargetName(NTLM_CONTEXT* context, char* TargetName){	int status;	char* name = TargetName;	DWORD nSize = 0;	CHAR* computerName = NULL;	if (!name)	{		if (GetComputerNameExA(ComputerNameNetBIOS, NULL, &nSize) || (GetLastError() != ERROR_MORE_DATA) ||		    (nSize < 2))			return -1;		computerName = calloc(nSize, sizeof(CHAR));		if (!computerName)			return -1;		if (!GetComputerNameExA(ComputerNameNetBIOS, computerName, &nSize))		{			free(computerName);			return -1;		}		if (nSize > MAX_COMPUTERNAME_LENGTH)			computerName[MAX_COMPUTERNAME_LENGTH] = '/0';		name = computerName;		if (!name)			return -1;		CharUpperA(name);	}	context->TargetName.pvBuffer = NULL;	status = ConvertToUnicode(CP_UTF8, 0, name, -1, (LPWSTR*) &context->TargetName.pvBuffer, 0);	if (status <= 0)	{		if (!TargetName)			free(name);		return -1;	}	context->TargetName.cbBuffer = (USHORT)((status - 1) * 2);	if (!TargetName)		free(name);	return 1;}