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);
}
}
nsresult
nsMsgAttachmentHandler::LoadDataFromFile(nsILocalFile *file, nsString &sigData, PRBool charsetConversion)
{
PRInt32 readSize;
char *readBuf;
nsCOMPtr <nsIInputStream> inputFile;
nsresult rv = NS_NewLocalFileInputStream(getter_AddRefs(inputFile), file);
if (NS_FAILED(rv))
return NS_MSG_ERROR_WRITING_FILE;
PRInt64 fileSize;
file->GetFileSize(&fileSize);
readSize = (PRUint32) fileSize;
readBuf = (char *)PR_Malloc(readSize + 1);
if (!readBuf)
return NS_ERROR_OUT_OF_MEMORY;
memset(readBuf, 0, readSize + 1);
PRUint32 bytesRead;
inputFile->Read(readBuf, readSize, &bytesRead);
inputFile->Close();
if (charsetConversion)
{
if (NS_FAILED(ConvertToUnicode(m_charset, nsDependentCString(readBuf), sigData)))
CopyASCIItoUTF16(readBuf, sigData);
}
else
CopyASCIItoUTF16(readBuf, sigData);
PR_FREEIF(readBuf);
return NS_OK;
}
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;
}
