string uuid()
{
string result;
#ifdef _WIN32
#ifndef _UNICODE
UUID uid;
auto status = UuidCreate(&uid);
ASSERT(status == RPC_S_OK, "Failed to create UUID");
char* str;
auto res = UuidToStringA(&uid, reinterpret_cast<RPC_CSTR*>(&str));
ASSERT(res == RPC_S_OK, "Failed to create string from UUID");
result = reinterpret_cast<const char*>(str);
RpcStringFreeA(reinterpret_cast<RPC_CSTR*>(&str));
#else
UUID uid;
auto status = UuidCreate(&uid);
ASSERT(status == RPC_S_OK, "Failed to create UUID");
wchar_t* str;
auto res = UuidToStringW(&uid, reinterpret_cast<RPC_WSTR*>(&str));
ASSERT(res == RPC_S_OK, "Failed to create string from UUID");
wstring wideRes = reinterpret_cast<const wchar_t*>(str);
result = engine::toUtf8String(wideRes);
RpcStringFreeW(reinterpret_cast<RPC_WSTR*>(&str));
#endif
#endif
return result;
}
static void test_RpcStringBindingFromBinding(void)
{
static unsigned char ncacn_np[] = "ncacn_np";
static unsigned char address[] = ".";
static unsigned char endpoint[] = "\\pipe\\wine_rpc_test";
RPC_STATUS status;
handle_t handle;
RPC_CSTR binding;
status = RpcStringBindingComposeA(NULL, ncacn_np, address,
endpoint, NULL, &binding);
ok(status == RPC_S_OK, "RpcStringBindingCompose failed (%u)\n", status);
status = RpcBindingFromStringBindingA(binding, &handle);
ok(status == RPC_S_OK, "RpcBindingFromStringBinding failed (%u)\n", status);
RpcStringFreeA(&binding);
status = RpcBindingToStringBindingA(handle, &binding);
ok(status == RPC_S_OK, "RpcStringBindingFromBinding failed with error %u\n", status);
ok(!strcmp((const char *)binding, "ncacn_np:.[\\\\pipe\\\\wine_rpc_test]"),
"binding string didn't match what was expected: \"%s\"\n", binding);
RpcStringFreeA(&binding);
status = RpcBindingFree(&handle);
ok(status == RPC_S_OK, "RpcBindingFree failed with error %u\n", status);
}
int Utility::GenerateGUID(CString& sGUID)
{
int status = 1;
sGUID.Empty();
strconv_t strconv;
// Create GUID
UCHAR *pszUuid = 0;
GUID *pguid = NULL;
pguid = new GUID;
if(pguid!=NULL)
{
HRESULT hr = CoCreateGuid(pguid);
if(SUCCEEDED(hr))
{
// Convert the GUID to a string
hr = UuidToStringA(pguid, &pszUuid);
if(SUCCEEDED(hr) && pszUuid!=NULL)
{
status = 0;
sGUID = strconv.a2t((char*)pszUuid);
RpcStringFreeA(&pszUuid);
}
}
delete pguid;
}
return status;
}
void MSVC8_Filter::write_filter_name_vs100(OutputWriter &output, int indent, const std::string &parent) const
{
std::string new_filter;
if (parent.length())
{
new_filter = parent + "\\" + name;
}
else
{
new_filter = name;
}
output.write_line(indent, " <Filter Include=\"" + new_filter + "\">");
// Create a new GUID:
unsigned char *projectGUID = 0;
GUID guid;
UuidCreate(&guid);
UuidToStringA(&guid, &projectGUID);
_strupr((char *) projectGUID);
std::string returnGUID = std::string("{") + ((char *) projectGUID) + std::string("}");
RpcStringFreeA(&projectGUID);
output.write_line(indent, " <UniqueIdentifier>" + returnGUID + "</UniqueIdentifier>");
output.write_line(indent, " </Filter>");
std::vector<MSVC8_FileItem *>::size_type index;
for (index = 0; index < files.size(); index++)
{
files[index]->write_filter_name_vs100(output, indent, new_filter);
}
}
static void initialize_display_settings( HWND desktop )
{
static const WCHAR display_device_guid_propW[] = {
'_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
'd','e','v','i','c','e','_','g','u','i','d',0 };
GUID guid;
RPC_CSTR guid_str;
ATOM guid_atom;
DEVMODEW dmW;
UuidCreate( &guid );
UuidToStringA( &guid, &guid_str );
WINE_TRACE( "display guid %s\n", guid_str );
guid_atom = GlobalAddAtomA( (LPCSTR)guid_str );
SetPropW( desktop, display_device_guid_propW, ULongToHandle(guid_atom) );
RpcStringFreeA( &guid_str );
/* Store current display mode in the registry */
if (EnumDisplaySettingsExW( NULL, ENUM_CURRENT_SETTINGS, &dmW, 0 ))
{
WINE_TRACE( "Current display mode %ux%u %u bpp %u Hz\n", dmW.dmPelsWidth,
dmW.dmPelsHeight, dmW.dmBitsPerPel, dmW.dmDisplayFrequency );
ChangeDisplaySettingsExW( NULL, &dmW, 0,
CDS_GLOBAL | CDS_NORESET | CDS_UPDATEREGISTRY,
NULL );
}
}
HRESULT TShellExt::QueryInterface(REFIID riid, void **ppvObject)
{
if (ppvObject == NULL)
return E_POINTER;
if (riid == IID_IContextMenu) {
*ppvObject = (IContextMenu*)this;
logA("TShellExt[%p] retrieved as IContextMenu: %d\n", this, RefCount);
}
else if (riid == IID_IContextMenu2) {
*ppvObject = (IContextMenu2*)this;
logA("TShellExt[%p] retrieved as IContextMenu2: %d\n", this, RefCount);
}
else if (riid == IID_IContextMenu3) {
*ppvObject = (IContextMenu3*)this;
logA("TShellExt[%p] retrieved as IContextMenu3: %d\n", this, RefCount);
}
else if (riid == IID_IShellExtInit || riid == IID_IUnknown) {
*ppvObject = (IShellExtInit*)this;
logA("TShellExt[%p] retrieved as IID_IUnknown: %d\n", this, RefCount);
}
else {
*ppvObject = NULL;
#ifdef LOG_ENABLED
RPC_CSTR szGuid;
UuidToStringA(&riid, &szGuid);
logA("TShellExt[%p] failed as {%s}\n", this, szGuid);
RpcStringFreeA(&szGuid);
#endif
return E_NOINTERFACE;
}
AddRef();
return S_OK;
}
std::string FMUCodeGen::generateGUID()
{
UUID uuid;
UuidCreate ( &uuid );
unsigned char * str;
UuidToStringA ( &uuid, &str );
std::string guid( ( char* ) str );
guid = "{"+guid+"}";
RpcStringFreeA ( &str );
return guid;
}
/***********************************************************************
* NdrDllUnregisterProxy [RPCRT4.@]
*/
HRESULT WINAPI NdrDllUnregisterProxy(HMODULE hDll,
const ProxyFileInfo **pProxyFileList,
const CLSID *pclsid)
{
LPSTR clsid;
char keyname[120], module[MAX_PATH];
DWORD len;
TRACE("(%p,%p,%s)\n", hDll, pProxyFileList, debugstr_guid(pclsid));
UuidToStringA((UUID*)pclsid, (unsigned char**)&clsid);
/* unregister interfaces */
while (*pProxyFileList) {
unsigned u;
for (u=0; u<(*pProxyFileList)->TableSize; u++) {
CInterfaceStubVtbl *proxy = (*pProxyFileList)->pStubVtblList[u];
PCInterfaceName name = (*pProxyFileList)->pNamesArray[u];
LPSTR iid;
TRACE("unregistering %s %s <= %s\n", name, debugstr_guid(proxy->header.piid), clsid);
UuidToStringA((UUID*)proxy->header.piid, (unsigned char**)&iid);
snprintf(keyname, sizeof(keyname), "Interface\\{%s}", iid);
RpcStringFreeA((unsigned char**)&iid);
RegDeleteKeyA(HKEY_CLASSES_ROOT, keyname);
}
pProxyFileList++;
}
/* unregister clsid */
snprintf(keyname, sizeof(keyname), "CLSID\\{%s}", clsid);
len = GetModuleFileNameA(hDll, module, sizeof(module));
if (len && len < sizeof(module)) {
TRACE("unregistering CLSID %s <= %s\n", clsid, module);
RegDeleteKeyA(HKEY_CLASSES_ROOT, keyname);
}
/* done */
RpcStringFreeA((unsigned char**)&clsid);
return S_OK;
}
std::string WorkspaceGenerator_MSVC8::get_project_guid(const std::string &project)
{
std::string returnGUID;
// Check if we already made a GUID earlier. Reuse it if we did.
LONG result;
HKEY key = 0;
result = RegCreateKeyA(HKEY_CURRENT_USER, "SOFTWARE\\Clanlib.org\\ClanLib\\ProjectGUIDs", &key);
if (result != ERROR_SUCCESS)
key = 0;
if (key)
{
DWORD type = 0, needed = 0;
result = RegQueryValueExA(key, project.c_str(), 0, &type, 0, &needed);
if (result == ERROR_SUCCESS && type == REG_SZ)
{
char *buffer = new char[needed];
result = RegQueryValueExA(key, project.c_str(), 0, &type, (LPBYTE) buffer, &needed);
if (result == ERROR_SUCCESS)
{
returnGUID = buffer;
delete[] buffer;
RegCloseKey(key);
return returnGUID;
}
delete[] buffer;
}
}
// Create a new GUID:
unsigned char *projectGUID = 0;
GUID guid;
UuidCreate(&guid);
UuidToStringA(&guid, &projectGUID);
_strupr((char *) projectGUID);
returnGUID = std::string("{") + ((char *) projectGUID) + std::string("}");
RpcStringFreeA(&projectGUID);
// Save it to registry:
if (key)
{
result = RegSetValueExA(
key,
project.c_str(),
0,
REG_SZ,
(LPBYTE) returnGUID.c_str(),
(DWORD) returnGUID.length()+1);
RegCloseKey(key);
}
return returnGUID;
}
char* directconnection::mNonceToText(void)
{
char* p;
UuidToStringA(mNonce, (BYTE**)&p);
size_t len = strlen(p) + 3;
char* result = (char*)mir_alloc(len);
mir_snprintf(result, len, "{%s}", p);
_strupr(result);
RpcStringFreeA((BYTE**)&p);
return result;
}
static void test_endpoint_mapper(RPC_CSTR protseq, RPC_CSTR address)
{
static unsigned char annotation[] = "Test annotation string.";
RPC_STATUS status;
RPC_BINDING_VECTOR *binding_vector;
handle_t handle;
unsigned char *binding;
status = RpcServerRegisterIf(IFoo_v0_0_s_ifspec, NULL, NULL);
ok(status == RPC_S_OK, "%s: RpcServerRegisterIf failed (%u)\n", protseq, status);
status = RpcServerInqBindings(&binding_vector);
ok(status == RPC_S_OK, "%s: RpcServerInqBindings failed with error %u\n", protseq, status);
/* register endpoints created in test_RpcServerUseProtseq */
status = RpcEpRegisterA(IFoo_v0_0_s_ifspec, binding_vector, NULL, annotation);
ok(status == RPC_S_OK, "%s: RpcEpRegisterA failed with error %u\n", protseq, status);
/* reregister the same endpoint with no annotation */
status = RpcEpRegisterA(IFoo_v0_0_s_ifspec, binding_vector, NULL, NULL);
ok(status == RPC_S_OK, "%s: RpcEpRegisterA failed with error %u\n", protseq, status);
status = RpcStringBindingComposeA(NULL, protseq, address,
NULL, NULL, &binding);
ok(status == RPC_S_OK, "%s: RpcStringBindingCompose failed (%u)\n", protseq, status);
status = RpcBindingFromStringBindingA(binding, &handle);
ok(status == RPC_S_OK, "%s: RpcBindingFromStringBinding failed (%u)\n", protseq, status);
RpcStringFreeA(&binding);
status = RpcBindingReset(handle);
ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
status = RpcEpResolveBinding(handle, IFoo_v0_0_s_ifspec);
ok(status == RPC_S_OK || broken(status == RPC_S_SERVER_UNAVAILABLE), /* win9x */
"%s: RpcEpResolveBinding failed with error %u\n", protseq, status);
status = RpcBindingReset(handle);
ok(status == RPC_S_OK, "%s: RpcBindingReset failed with error %u\n", protseq, status);
status = RpcBindingFree(&handle);
ok(status == RPC_S_OK, "%s: RpcBindingFree failed with error %u\n", protseq, status);
status = RpcServerUnregisterIf(NULL, NULL, FALSE);
ok(status == RPC_S_OK, "%s: RpcServerUnregisterIf failed (%u)\n", protseq, status);
status = RpcEpUnregister(IFoo_v0_0_s_ifspec, binding_vector, NULL);
ok(status == RPC_S_OK, "%s: RpcEpUnregisterA failed with error %u\n", protseq, status);
status = RpcBindingVectorFree(&binding_vector);
ok(status == RPC_S_OK, "%s: RpcBindingVectorFree failed with error %u\n", protseq, status);
}
DWORD
VmDirRpcFreeString(
PSTR* ppszString
)
{
DWORD dwError = ERROR_SUCCESS;
#if !defined(_WIN32) || defined(HAVE_DCERPC_WIN32)
rpc_string_free((PBYTE*)ppszString, &dwError);
#else
dwError = RpcStringFreeA((RPC_CSTR*)ppszString);
#endif
return dwError;
}
char* getNewUuid(void)
{
BYTE* p;
UUID id;
UuidCreate(&id);
UuidToStringA(&id, &p);
size_t len = strlen((char*)p) + 3;
char* result = (char*)mir_alloc(len);
mir_snprintf(result, len, "{%s}", p);
_strupr(result);
RpcStringFreeA(&p);
return result;
}
void parseGetUUID(char *id, size_t id_size) {
size_t i = 0;
UUID uuid;
char *uuid_string;
UuidCreate(&uuid);
UuidToStringA(&uuid, &uuid_string);
strncpy_s(id, id_size, uuid_string, _TRUNCATE);
i = 0;
for ( ; i < strlen(id) ; i++) {
id[i] = tolower(id[i]);
}
RpcStringFreeA(&uuid_string);
}
string InstanceManager::CreateId()
{
// Create binary UUID
UUID uuid;
UuidCreate(&uuid);
// Convert binary UUID to RPC string
RPC_CSTR tmpstr;
UuidToStringA(&uuid, &tmpstr);
// Copy string UUID to string and free RPC version
string uuidstr((char*)tmpstr);
RpcStringFreeA(&tmpstr);
return uuidstr;
}
RTDECL(int) RTUuidToStr(PCRTUUID pUuid, char *pszString, size_t cchString)
{
/* check params */
AssertPtrReturn(pUuid, VERR_INVALID_POINTER);
AssertPtrReturn(pszString, VERR_INVALID_POINTER);
AssertReturn(cchString >= RTUUID_STR_LENGTH, VERR_INVALID_PARAMETER);
/*
* Try convert it.
*
* The API allocates a new string buffer for us, so we can do our own
* buffer overflow handling.
*/
RPC_STATUS Status;
unsigned char *pszTmpStr = NULL;
#ifdef RPC_UNICODE_SUPPORTED
/* always use ASCII version! */
Status = UuidToStringA((UUID *)pUuid, &pszTmpStr);
#else
Status = UuidToString((UUID *)pUuid, &pszTmpStr);
#endif
if (Status != RPC_S_OK)
return RTErrConvertFromWin32(Status);
/* copy it. */
int rc = VINF_SUCCESS;
size_t cchTmpStr = strlen((char *)pszTmpStr);
if (cchTmpStr < cchString)
memcpy(pszString, pszTmpStr, cchTmpStr + 1);
else
{
AssertFailed();
rc = ERROR_BUFFER_OVERFLOW;
}
/* free buffer */
#ifdef RPC_UNICODE_SUPPORTED
/* always use ASCII version! */
RpcStringFreeA(&pszTmpStr);
#else
RpcStringFree(&pszTmpStr);
#endif
/* all done */
return rc;
}
int ustring_Uuid(lua_State* L)
{
UUID uuid;
if(lua_gettop(L) == 0 || !lua_toboolean(L, 1))
{
// generate new UUID
if(UuidCreate(&uuid) == RPC_S_OK)
{
lua_pushlstring(L, (const char*)&uuid, sizeof(UUID));
return 1;
}
}
else
{
size_t len;
const char* arg1 = luaL_checklstring(L, 1, &len);
if(len == sizeof(UUID))
{
// convert given UUID to string
unsigned char* p;
if(UuidToStringA((UUID*)arg1, &p) == RPC_S_OK)
{
lua_pushstring(L, (char*)p);
RpcStringFreeA(&p);
return 1;
}
}
else
{
// convert string UUID representation to UUID
if(UuidFromStringA((unsigned char*)arg1, &uuid) == RPC_S_OK)
{
lua_pushlstring(L, (const char*)&uuid, sizeof(UUID));
return 1;
}
}
}
lua_pushnil(L);
return 1;
}
char* directconnection::calcHashedNonce(UUID* nonce)
{
mir_sha1_ctx sha1ctx;
BYTE sha[MIR_SHA1_HASH_SIZE];
mir_sha1_init(&sha1ctx);
mir_sha1_append(&sha1ctx, (BYTE*)nonce, sizeof(UUID));
mir_sha1_finish(&sha1ctx, sha);
char* p;
UuidToStringA((UUID*)&sha, (BYTE**)&p);
size_t len = strlen(p) + 3;
char* result = (char*)mir_alloc(len);
mir_snprintf(result, len, "{%s}", p);
_strupr(result);
RpcStringFreeA((BYTE**)&p);
return result;
}
void MOInit(const char* appname)
{
strcpy(g_AppName, appname);
DWORD dwVersion = GetVersion();
DWORD dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
DWORD dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
DWORD dwBuild = 0;
if(dwVersion<0x80000000) dwBuild = (DWORD)(HIWORD(dwVersion));
sprintf(g_OSName, "windows0%d0%d0%d", dwMajorVersion, dwMinorVersion, dwBuild);
GetModuleFileNameA(NULL, g_ResourcePath, sizeof(g_ResourcePath));
*(strrchr(g_ResourcePath, '\\')) = '\0';
*(strrchr(g_ResourcePath, '\\')) = '\0';
*(strrchr(g_ResourcePath, '\\')) = '\0';
LPITEMIDLIST pidl=NULL;
char szDocument[MAX_PATH];
SHGetSpecialFolderLocation(NULL, CSIDL_PERSONAL, &pidl);
SHGetPathFromIDListA(pidl, szDocument);
strcat(szDocument, "\\MO_DEVICE_ID.txt");
FILE* fp;
fp = fopen(szDocument, "rt");
if(fp)
{
if(fgets(g_UDID, sizeof(g_UDID), fp)==NULL) g_UDID[0] = '\0';
fclose(fp);
}
if(g_UDID[0]=='\0')
{
UUID uuid;
UuidCreate(&uuid);
RPC_CSTR val;
UuidToStringA((UUID*)&uuid, &val);
strcpy(g_UDID, (const char*)val);
RpcStringFreeA(&val);
fp = fopen(szDocument, "wt");
if(fp)
{
fputs(g_UDID, fp);
fclose(fp);
}
}
}
ctci::string snewUUID()
{
#ifdef WIN32
UUID uuid;
UuidCreate ( &uuid );
unsigned char * str;
UuidToStringA ( &uuid, &str );
std::string s( ( char* ) str );
RpcStringFreeA ( &str );
#else
uuid_t uuid;
uuid_generate_random ( uuid );
char s[37];
uuid_unparse ( uuid, s );
#endif
return s;
}
handle_t __RPC_USER
EVENTLOG_HANDLE_A_bind(EVENTLOG_HANDLE_A UNCServerName)
{
handle_t hBinding = NULL;
UCHAR *pszStringBinding;
RPC_STATUS status;
TRACE("EVENTLOG_HANDLE_A_bind() called\n");
status = RpcStringBindingComposeA(NULL,
(UCHAR *)"ncacn_np",
(UCHAR *)UNCServerName,
(UCHAR *)"\\pipe\\EventLog",
NULL,
(UCHAR **)&pszStringBinding);
if (status)
{
ERR("RpcStringBindingCompose returned 0x%x\n", status);
return NULL;
}
/* Set the binding handle that will be used to bind to the server. */
status = RpcBindingFromStringBindingA(pszStringBinding,
&hBinding);
if (status)
{
ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
}
status = RpcStringFreeA(&pszStringBinding);
if (status)
{
ERR("RpcStringFree returned 0x%x\n", status);
}
return hBinding;
}
static void test_RpcServerUseProtseq(void)
{
RPC_STATUS status;
RPC_BINDING_VECTOR *bindings;
ULONG i;
ULONG binding_count_before;
ULONG binding_count_after1;
ULONG binding_count_after2;
ULONG endpoints_registered = 0;
static unsigned char iptcp[] = "ncacn_ip_tcp";
static unsigned char np[] = "ncacn_np";
static unsigned char ncalrpc[] = "ncalrpc";
status = RpcServerInqBindings(&bindings);
if (status == RPC_S_NO_BINDINGS)
binding_count_before = 0;
else
{
binding_count_before = bindings->Count;
ok(status == RPC_S_OK, "RpcServerInqBindings failed with status %d\n", status);
RpcBindingVectorFree(&bindings);
}
/* show that RpcServerUseProtseqEp(..., NULL, ...) is the same as
* RpcServerUseProtseq(...) */
status = RpcServerUseProtseqEpA(ncalrpc, 0, NULL, NULL);
ok(status == RPC_S_OK || broken(status == RPC_S_INVALID_ENDPOINT_FORMAT),
"RpcServerUseProtseqEp with NULL endpoint failed with status %d\n",
status);
/* register protocol sequences without explicit endpoints */
status = RpcServerUseProtseqA(np, 0, NULL);
if (status == RPC_S_PROTSEQ_NOT_SUPPORTED)
win_skip("ncacn_np not supported\n");
else
ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_np) failed with status %d\n", status);
if (status == RPC_S_OK) endpoints_registered++;
status = RpcServerUseProtseqA(iptcp, 0, NULL);
ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_ip_tcp) failed with status %d\n", status);
if (status == RPC_S_OK) endpoints_registered++;
status = RpcServerUseProtseqA(ncalrpc, 0, NULL);
ok(status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", status);
if (status == RPC_S_OK) endpoints_registered++;
status = RpcServerInqBindings(&bindings);
ok(status == RPC_S_OK, "RpcServerInqBindings failed with status %d\n", status);
binding_count_after1 = bindings->Count;
ok(binding_count_after1 == binding_count_before + endpoints_registered,
"wrong binding count - before: %u, after %u, endpoints registered %u\n",
binding_count_before, binding_count_after1, endpoints_registered);
for (i = 0; i < bindings->Count; i++)
{
RPC_CSTR str_bind;
status = RpcBindingToStringBindingA(bindings->BindingH[i], &str_bind);
ok(status == RPC_S_OK, "RpcBindingToStringBinding failed with status %d\n", status);
trace("string binding: %s\n", str_bind);
RpcStringFreeA(&str_bind);
}
RpcBindingVectorFree(&bindings);
/* re-register - endpoints should be reused */
status = RpcServerUseProtseqA(np, 0, NULL);
if (status == RPC_S_PROTSEQ_NOT_SUPPORTED)
win_skip("ncacn_np not supported\n");
else
ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_np) failed with status %d\n", status);
status = RpcServerUseProtseqA(iptcp, 0, NULL);
ok(status == RPC_S_OK, "RpcServerUseProtseq(ncacn_ip_tcp) failed with status %d\n", status);
status = RpcServerUseProtseqA(ncalrpc, 0, NULL);
ok(status == RPC_S_OK, "RpcServerUseProtseqEp(ncalrpc) failed with status %d\n", status);
status = RpcServerInqBindings(&bindings);
ok(status == RPC_S_OK, "RpcServerInqBindings failed with status %d\n", status);
binding_count_after2 = bindings->Count;
ok(binding_count_after2 == binding_count_after1,
"bindings should have been re-used - after1: %u after2: %u\n",
binding_count_after1, binding_count_after2);
RpcBindingVectorFree(&bindings);
}
static void UuidConversionAndComparison(void) {
CHAR strx[100], x;
LPSTR str = strx;
WCHAR wstrx[100], wx;
LPWSTR wstr = wstrx;
UUID Uuid1, Uuid2, *PUuid1, *PUuid2;
RPC_STATUS rslt;
int i1,i2;
/* Uuid Equality */
for (i1 = 0; i1 < 11; i1++)
for (i2 = 0; i2 < 11; i2++) {
if (i1 < 10) {
Uuid1 = Uuid_Table[i1];
PUuid1 = &Uuid1;
} else {
PUuid1 = NULL;
}
if (i2 < 10) {
Uuid2 = Uuid_Table[i2];
PUuid2 = &Uuid2;
} else {
PUuid2 = NULL;
}
ok( (UuidEqual(PUuid1, PUuid2, &rslt) == Uuid_Comparison_Grid[i1][i2]), "UUID Equality\n" );
}
/* Uuid to String to Uuid (char) */
for (i1 = 0; i1 < 10; i1++) {
Uuid1 = Uuid_Table[i1];
ok( (UuidToStringA(&Uuid1, (unsigned char**)&str) == RPC_S_OK), "Simple UUID->String copy\n" );
ok( (UuidFromStringA((unsigned char*)str, &Uuid2) == RPC_S_OK), "Simple String->UUID copy from generated UUID String\n" );
ok( UuidEqual(&Uuid1, &Uuid2, &rslt), "Uuid -> String -> Uuid transform\n" );
/* invalid uuid tests -- size of valid UUID string=36 */
for (i2 = 0; i2 < 36; i2++) {
x = str[i2];
str[i2] = 'g'; /* whatever, but "g" is a good boundary condition */
ok( (UuidFromStringA((unsigned char*)str, &Uuid1) == RPC_S_INVALID_STRING_UUID), "Invalid UUID String\n" );
str[i2] = x; /* change it back so remaining tests are interesting. */
}
RpcStringFreeA((unsigned char **)&str);
}
/* Uuid to String to Uuid (wchar) */
for (i1 = 0; i1 < 10; i1++) {
Uuid1 = Uuid_Table[i1];
rslt=UuidToStringW(&Uuid1, &wstr);
ok( (rslt == RPC_S_OK), "Simple UUID->WString copy\n" );
ok( (UuidFromStringW(wstr, &Uuid2) == RPC_S_OK), "Simple WString->UUID copy from generated UUID String\n" );
ok( UuidEqual(&Uuid1, &Uuid2, &rslt), "Uuid -> WString -> Uuid transform\n" );
/* invalid uuid tests -- size of valid UUID string=36 */
for (i2 = 0; i2 < 36; i2++) {
wx = wstr[i2];
wstr[i2] = 'g'; /* whatever, but "g" is a good boundary condition */
ok( (UuidFromStringW(wstr, &Uuid1) == RPC_S_INVALID_STRING_UUID), "Invalid UUID WString\n" );
wstr[i2] = wx; /* change it back so remaining tests are interesting. */
}
RpcStringFreeW(&wstr);
}
}
void fn004018D1()
{
GetCommandLineA();
RpcStringFreeA(null);
VirtualProtect(0x00401000, 0x0000063D, 0x00000040, fp - 0x00000014);
}
static void Publish_tests(void)
{
IWSDiscoveryPublisher *publisher = NULL;
IWSDiscoveryPublisherNotify *sink1 = NULL, *sink2 = NULL;
IWSDiscoveryPublisherNotifyImpl *sink1Impl = NULL, *sink2Impl = NULL;
char endpointReferenceString[MAX_PATH], app_sequence_string[MAX_PATH];
LPWSTR publisherIdW = NULL, sequenceIdW = NULL;
messageStorage *msgStorage;
WSADATA wsaData;
BOOL messageOK, hello_message_seen = FALSE, endpoint_reference_seen = FALSE, app_sequence_seen = FALSE;
BOOL metadata_version_seen = FALSE, any_header_seen = FALSE, wine_ns_seen = FALSE, body_hello_seen = FALSE;
BOOL any_body_seen = FALSE, types_seen = FALSE, xml_namespaces_seen = FALSE, scopes_seen = FALSE;
BOOL xaddrs_seen = FALSE;
int ret, i;
HRESULT rc;
ULONG ref;
char *msg;
WSDXML_ELEMENT *header_any_element, *body_any_element, *endpoint_any_element, *ref_param_any_element;
WSDXML_NAME header_any_name, another_name;
WSDXML_NAMESPACE ns, ns2;
WCHAR header_any_name_text[] = {'B','e','e','r',0};
static const WCHAR header_any_text[] = {'P','u','b','l','i','s','h','T','e','s','t',0};
static const WCHAR body_any_text[] = {'B','o','d','y','T','e','s','t',0};
static const WCHAR endpoint_any_text[] = {'E','n','d','P','T','e','s','t',0};
static const WCHAR ref_param_any_text[] = {'R','e','f','P','T','e','s','t',0};
static const WCHAR uri[] = {'h','t','t','p',':','/','/','w','i','n','e','.','t','e','s','t','/',0};
static const WCHAR prefix[] = {'w','i','n','e',0};
static const WCHAR uri3[] = {'h','t','t','p',':','/','/','t','h','i','r','d','.','u','r','l','/',0};
WSD_NAME_LIST types_list;
WSD_URI_LIST scopes_list, xaddrs_list;
unsigned char *probe_uuid_str;
rc = WSDCreateDiscoveryPublisher(NULL, &publisher);
ok(rc == S_OK, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: %08x\n", rc);
ok(publisher != NULL, "WSDCreateDiscoveryPublisher(NULL, &publisher) failed: publisher == NULL\n");
/* Test SetAddressFamily */
rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, 12345);
ok(rc == E_INVALIDARG, "IWSDiscoveryPublisher_SetAddressFamily(12345) returned unexpected result: %08x\n", rc);
rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV4);
ok(rc == S_OK, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV4) failed: %08x\n", rc);
/* Try to update the address family after already setting it */
rc = IWSDiscoveryPublisher_SetAddressFamily(publisher, WSDAPI_ADDRESSFAMILY_IPV6);
ok(rc == STG_E_INVALIDFUNCTION, "IWSDiscoveryPublisher_SetAddressFamily(WSDAPI_ADDRESSFAMILY_IPV6) returned unexpected result: %08x\n", rc);
/* Create notification sinks */
ok(create_discovery_publisher_notify(&sink1) == TRUE, "create_discovery_publisher_notify failed\n");
ok(create_discovery_publisher_notify(&sink2) == TRUE, "create_discovery_publisher_notify failed\n");
/* Get underlying implementation so we can check the ref count */
sink1Impl = impl_from_IWSDiscoveryPublisherNotify(sink1);
sink2Impl = impl_from_IWSDiscoveryPublisherNotify(sink2);
/* Attempt to unregister sink before registering it */
rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
ok(rc == E_FAIL, "IWSDiscoveryPublisher_UnRegisterNotificationSink returned unexpected result: %08x\n", rc);
/* Register notification sinks */
rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink1);
ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
ok(sink1Impl->ref == 2, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
rc = IWSDiscoveryPublisher_RegisterNotificationSink(publisher, sink2);
ok(rc == S_OK, "IWSDiscoveryPublisher_RegisterNotificationSink failed: %08x\n", rc);
ok(sink2Impl->ref == 2, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
/* Unregister the first sink */
rc = IWSDiscoveryPublisher_UnRegisterNotificationSink(publisher, sink1);
ok(rc == S_OK, "IWSDiscoveryPublisher_UnRegisterNotificationSink failed: %08x\n", rc);
ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
/* Set up network listener */
publisherIdW = utf8_to_wide(publisherId);
if (publisherIdW == NULL) goto after_publish_test;
sequenceIdW = utf8_to_wide(sequenceId);
if (sequenceIdW == NULL) goto after_publish_test;
msgStorage = heap_alloc_zero(sizeof(messageStorage));
if (msgStorage == NULL) goto after_publish_test;
msgStorage->running = TRUE;
InitializeCriticalSection(&msgStorage->criticalSection);
ret = WSAStartup(MAKEWORD(2, 2), &wsaData);
ok(ret == 0, "WSAStartup failed (ret = %d)\n", ret);
ret = start_listening_on_all_addresses(msgStorage, AF_INET);
ok(ret == TRUE, "Unable to listen on IPv4 addresses (ret == %d)\n", ret);
/* Create "any" elements for header */
ns.Uri = uri;
ns.PreferredPrefix = prefix;
header_any_name.LocalName = header_any_name_text;
header_any_name.Space = &ns;
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, header_any_text, &header_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, body_any_text, &body_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, endpoint_any_text, &endpoint_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
rc = WSDXMLBuildAnyForSingleElement(&header_any_name, ref_param_any_text, &ref_param_any_element);
ok(rc == S_OK, "WSDXMLBuildAnyForSingleElement failed with %08x\n", rc);
/* Create types list */
ns2.Uri = uri_more_tests;
ns2.PreferredPrefix = prefix_grog;
another_name.LocalName = (WCHAR *) name_cider;
another_name.Space = &ns2;
types_list.Next = malloc(sizeof(WSD_NAME_LIST));
types_list.Element = &another_name;
types_list.Next->Next = NULL;
types_list.Next->Element = &header_any_name;
/* Create scopes and xaddrs lists */
scopes_list.Next = malloc(sizeof(WSD_URI_LIST));
scopes_list.Element = uri;
scopes_list.Next->Next = NULL;
scopes_list.Next->Element = uri_more_tests;
xaddrs_list.Next = malloc(sizeof(WSD_URI_LIST));
xaddrs_list.Element = uri_more_tests;
xaddrs_list.Next->Next = NULL;
xaddrs_list.Next->Element = uri3;
/* Publish the service */
rc = IWSDiscoveryPublisher_PublishEx(publisher, publisherIdW, 1, 1, 1, sequenceIdW, &types_list, &scopes_list,
&xaddrs_list, header_any_element, ref_param_any_element, NULL, endpoint_any_element, body_any_element);
WSDFreeLinkedMemory(header_any_element);
WSDFreeLinkedMemory(body_any_element);
WSDFreeLinkedMemory(endpoint_any_element);
WSDFreeLinkedMemory(ref_param_any_element);
free(types_list.Next);
free(scopes_list.Next);
free(xaddrs_list.Next);
ok(rc == S_OK, "Publish failed: %08x\n", rc);
/* Wait up to 2 seconds for messages to be received */
if (WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 2000) == WAIT_TIMEOUT)
{
/* Wait up to 1 more second for threads to terminate */
msgStorage->running = FALSE;
WaitForMultipleObjects(msgStorage->numThreadHandles, msgStorage->threadHandles, TRUE, 1000);
}
DeleteCriticalSection(&msgStorage->criticalSection);
/* Verify we've received a message */
ok(msgStorage->messageCount >= 1, "No messages received\n");
sprintf(endpointReferenceString, "<wsa:EndpointReference><wsa:Address>%s</wsa:Address><wsa:ReferenceParameters>"
"<wine:Beer>RefPTest</wine:Beer></wsa:ReferenceParameters><wine:Beer>EndPTest</wine:Beer>"
"</wsa:EndpointReference>", publisherId);
sprintf(app_sequence_string, "<wsd:AppSequence InstanceId=\"1\" SequenceId=\"%s\" MessageNumber=\"1\"></wsd:AppSequence>",
sequenceId);
messageOK = FALSE;
/* Check we're received the correct message */
for (i = 0; i < msgStorage->messageCount; i++)
{
msg = msgStorage->messages[i];
messageOK = FALSE;
hello_message_seen = (strstr(msg, "<wsa:Action>http://schemas.xmlsoap.org/ws/2005/04/discovery/Hello</wsa:Action>") != NULL);
endpoint_reference_seen = (strstr(msg, endpointReferenceString) != NULL);
app_sequence_seen = (strstr(msg, app_sequence_string) != NULL);
metadata_version_seen = (strstr(msg, "<wsd:MetadataVersion>1</wsd:MetadataVersion>") != NULL);
any_header_seen = (strstr(msg, "<wine:Beer>PublishTest</wine:Beer>") != NULL);
wine_ns_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\"") != NULL);
body_hello_seen = (strstr(msg, "<soap:Body><wsd:Hello") != NULL);
any_body_seen = (strstr(msg, "<wine:Beer>BodyTest</wine:Beer>") != NULL);
types_seen = (strstr(msg, "<wsd:Types>grog:Cider wine:Beer</wsd:Types>") != NULL);
scopes_seen = (strstr(msg, "<wsd:Scopes>http://wine.test/ http://more.tests/</wsd:Scopes>") != NULL);
xaddrs_seen = (strstr(msg, "<wsd:XAddrs>http://more.tests/ http://third.url/</wsd:XAddrs>") != NULL);
xml_namespaces_seen = (strstr(msg, "xmlns:wine=\"http://wine.test/\" xmlns:grog=\"http://more.tests/\"") != NULL);
messageOK = hello_message_seen && endpoint_reference_seen && app_sequence_seen && metadata_version_seen &&
any_header_seen && wine_ns_seen && body_hello_seen && any_body_seen && types_seen && xml_namespaces_seen &&
scopes_seen && xaddrs_seen;
if (messageOK) break;
}
for (i = 0; i < msgStorage->messageCount; i++)
{
heap_free(msgStorage->messages[i]);
}
heap_free(msgStorage);
ok(hello_message_seen == TRUE, "Hello message not received\n");
ok(endpoint_reference_seen == TRUE, "EndpointReference not received\n");
ok(app_sequence_seen == TRUE, "AppSequence not received\n");
ok(metadata_version_seen == TRUE, "MetadataVersion not received\n");
ok(messageOK == TRUE, "Hello message metadata not received\n");
ok(any_header_seen == TRUE, "Custom header not received\n");
ok(wine_ns_seen == TRUE, "Wine namespace not received\n");
ok(body_hello_seen == TRUE, "Body and Hello elements not received\n");
ok(any_body_seen == TRUE, "Custom body element not received\n");
ok(types_seen == TRUE, "Types not received\n");
ok(xml_namespaces_seen == TRUE, "XML namespaces not received\n");
ok(scopes_seen == TRUE, "Scopes not received\n");
ok(xaddrs_seen == TRUE, "XAddrs not received\n");
after_publish_test:
heap_free(publisherIdW);
heap_free(sequenceIdW);
/* Test the receiving of a probe message */
probe_event = CreateEventW(NULL, TRUE, FALSE, NULL);
UuidCreate(&probe_message_id);
UuidToStringA(&probe_message_id, &probe_uuid_str);
ok(probe_uuid_str != NULL, "Failed to create UUID for probe message\n");
if (probe_uuid_str != NULL)
{
char probe_message[sizeof(testProbeMessage) + 50];
sprintf(probe_message, testProbeMessage, probe_uuid_str);
ok(send_udp_multicast_of_type(probe_message, strlen(probe_message), AF_INET) == TRUE, "Sending Probe message failed\n");
todo_wine ok(WaitForSingleObject(probe_event, 2000) == WAIT_OBJECT_0, "Probe message not received\n");
RpcStringFreeA(&probe_uuid_str);
}
CloseHandle(probe_event);
ref = IWSDiscoveryPublisher_Release(publisher);
ok(ref == 0, "IWSDiscoveryPublisher_Release() has %d references, should have 0\n", ref);
/* Check that the sinks have been released by the publisher */
ok(sink1Impl->ref == 1, "Ref count for sink 1 is not as expected: %d\n", sink1Impl->ref);
ok(sink2Impl->ref == 1, "Ref count for sink 2 is not as expected: %d\n", sink2Impl->ref);
/* Release the sinks */
IWSDiscoveryPublisherNotify_Release(sink1);
IWSDiscoveryPublisherNotify_Release(sink2);
WSACleanup();
}
NS_IMETHODIMP
LSPAnnotationGatherer::Run()
{
PR_SetCurrentThreadName("LSP Annotator");
mThread = NS_GetCurrentThread();
DWORD size = 0;
int err;
// Get the size of the buffer we need
if (SOCKET_ERROR != WSCEnumProtocols(nullptr, nullptr, &size, &err) ||
err != WSAENOBUFS) {
// Er, what?
NS_NOTREACHED("WSCEnumProtocols suceeded when it should have failed ...");
return NS_ERROR_FAILURE;
}
auto byteArray = MakeUnique<char[]>(size);
WSAPROTOCOL_INFOW* providers =
reinterpret_cast<WSAPROTOCOL_INFOW*>(byteArray.get());
int n = WSCEnumProtocols(nullptr, providers, &size, &err);
if (n == SOCKET_ERROR) {
// Lame. We provided the right size buffer; we'll just give up now.
NS_WARNING("Could not get LSP list");
return NS_ERROR_FAILURE;
}
nsCString str;
for (int i = 0; i < n; i++) {
AppendUTF16toUTF8(nsDependentString(providers[i].szProtocol), str);
str.AppendLiteral(" : ");
str.AppendInt(providers[i].iVersion);
str.AppendLiteral(" : ");
str.AppendInt(providers[i].iAddressFamily);
str.AppendLiteral(" : ");
str.AppendInt(providers[i].iSocketType);
str.AppendLiteral(" : ");
str.AppendInt(providers[i].iProtocol);
str.AppendLiteral(" : ");
str.AppendPrintf("0x%x", providers[i].dwServiceFlags1);
str.AppendLiteral(" : ");
str.AppendPrintf("0x%x", providers[i].dwProviderFlags);
str.AppendLiteral(" : ");
wchar_t path[MAX_PATH];
int pathLen = MAX_PATH;
if (!WSCGetProviderPath(&providers[i].ProviderId, path, &pathLen, &err)) {
AppendUTF16toUTF8(nsDependentString(path), str);
}
str.AppendLiteral(" : ");
// If WSCGetProviderInfo is available, we should call it to obtain the
// category flags for this provider. When present, these flags inform
// Windows as to which order to chain the providers.
nsModuleHandle ws2_32(LoadLibraryW(L"ws2_32.dll"));
if (ws2_32) {
decltype(WSCGetProviderInfo)* pWSCGetProviderInfo =
reinterpret_cast<decltype(WSCGetProviderInfo)*>(
GetProcAddress(ws2_32, "WSCGetProviderInfo"));
if (pWSCGetProviderInfo) {
DWORD categoryInfo;
size_t categoryInfoSize = sizeof(categoryInfo);
if (!pWSCGetProviderInfo(&providers[i].ProviderId,
ProviderInfoLspCategories,
(PBYTE)&categoryInfo, &categoryInfoSize, 0,
&err)) {
str.AppendPrintf("0x%x", categoryInfo);
}
}
}
str.AppendLiteral(" : ");
if (providers[i].ProtocolChain.ChainLen <= BASE_PROTOCOL) {
// If we're dealing with a catalog entry that identifies an individual
// base or layer provider, log its provider GUID.
RPC_CSTR provIdStr = nullptr;
if (UuidToStringA(&providers[i].ProviderId, &provIdStr) == RPC_S_OK) {
str.Append(reinterpret_cast<char*>(provIdStr));
RpcStringFreeA(&provIdStr);
}
}
if (i + 1 != n) {
str.AppendLiteral(" \n ");
}
}
mString = str;
NS_DispatchToMainThread(NewRunnableMethod(this, &LSPAnnotationGatherer::Annotate));
return NS_OK;
}
int TestWlanApi(int argc, _TCHAR* argv[])
{
// init_lib( &cs );
// return 0;
HANDLE hClient = NULL;
WLAN_INTERFACE_INFO sInfo[64];
RPC_CSTR strGuid = NULL;
TCHAR szBuffer[256];
DWORD dwRead;
if( OpenHandleAndCheckVersion( &hClient ) != ERROR_SUCCESS )
return -1;
UINT nCount = EnumInterface( hClient, sInfo );
for( UINT i = 0; i < nCount; ++i )
{
if (UuidToStringA( &sInfo[i].InterfaceGuid, &strGuid) == RPC_S_OK)
{
printf( ("%d. %s\n\tDescription: %S\n\tState: %S\n"),
i,
strGuid,
sInfo[i].strInterfaceDescription,
GetInterfaceStateString(sInfo[i].isState) );
RpcStringFreeA(&strGuid);
}
}
UINT nChoice = 0;
printf( "for choice wireless card:" );
if( ReadConsole( GetStdHandle(STD_INPUT_HANDLE), szBuffer, _countof(szBuffer), &dwRead, NULL ) == FALSE )
{
puts( "error input" );
return -1;
}
szBuffer[dwRead] = 0;
nChoice = _ttoi( szBuffer );
if( nChoice > nCount )
{
puts( "error input." );
return -1;
}
ULONG ulOperatorCode = DOT11_OPERATION_MODE_NETWORK_MONITOR;
if( ERROR_SUCCESS != WlanSetInterface(
hClient,
&sInfo[nChoice].InterfaceGuid,
wlan_intf_opcode_current_operation_mode,
sizeof(ULONG),
&ulOperatorCode,
NULL ) )
{
puts( "enter monitor mode failed!" );
return -1;
}
BOOL bRet = ReadFile( hClient, szBuffer, sizeof(szBuffer), &dwRead, NULL );
_getch();
ulOperatorCode = DOT11_OPERATION_MODE_EXTENSIBLE_STATION;
if( ERROR_SUCCESS != WlanSetInterface(
hClient,
&sInfo[nChoice].InterfaceGuid,
wlan_intf_opcode_current_operation_mode,
sizeof(ULONG),
&ulOperatorCode,
NULL ) )
{
puts( "enter monitor mode failed!" );
return -1;
}
WlanCloseHandle( hClient, NULL );
return 0;
}
zmq::uuid_t::~uuid_t ()
{
if (string_buf)
RpcStringFreeA (&string_buf);
}
rdpRdg* rdg_new(rdpTransport* transport)
{
rdpRdg* rdg;
RPC_CSTR stringUuid;
char bracedUuid[40];
RPC_STATUS rpcStatus;
assert(transport != NULL);
rdg = (rdpRdg*) calloc(1, sizeof(rdpRdg));
if (rdg)
{
rdg->state = RDG_CLIENT_STATE_INITIAL;
rdg->context = transport->context;
rdg->settings = rdg->context->settings;
UuidCreate(&rdg->guid);
rpcStatus = UuidToStringA(&rdg->guid, &stringUuid);
if (rpcStatus == RPC_S_OUT_OF_MEMORY)
goto rdg_alloc_error;
sprintf_s(bracedUuid, sizeof(bracedUuid), "{%s}", stringUuid);
RpcStringFreeA(&stringUuid);
rdg->tlsOut = tls_new(rdg->settings);
if (!rdg->tlsOut)
goto rdg_alloc_error;
rdg->tlsIn = tls_new(rdg->settings);
if (!rdg->tlsIn)
goto rdg_alloc_error;
rdg->http = http_context_new();
if (!rdg->http)
goto rdg_alloc_error;
http_context_set_uri(rdg->http, "/remoteDesktopGateway/");
http_context_set_accept(rdg->http, "*/*");
http_context_set_cache_control(rdg->http, "no-cache");
http_context_set_pragma(rdg->http, "no-cache");
http_context_set_connection(rdg->http, "Keep-Alive");
http_context_set_user_agent(rdg->http, "MS-RDGateway/1.0");
http_context_set_host(rdg->http, rdg->settings->GatewayHostname);
http_context_set_rdg_connection_id(rdg->http, bracedUuid);
if (!rdg->http->URI || !rdg->http->Accept || !rdg->http->CacheControl ||
!rdg->http->Pragma || !rdg->http->Connection || !rdg->http->UserAgent
|| !rdg->http->Host || !rdg->http->RdgConnectionId)
{
goto rdg_alloc_error;
}
rdg->frontBio = BIO_new(BIO_s_rdg());
if (!rdg->frontBio)
goto rdg_alloc_error;
rdg->frontBio->ptr = rdg;
rdg->readEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (!rdg->readEvent)
goto rdg_alloc_error;
InitializeCriticalSection(&rdg->writeSection);
}
return rdg;
rdg_alloc_error:
rdg_free(rdg);
return NULL;
}
rdpRdg* rdg_new(rdpTransport* transport)
{
rdpRdg* rdg;
RPC_CSTR stringUuid;
char bracedUuid[40];
RPC_STATUS rpcStatus;
assert(transport != NULL);
rdg = (rdpRdg*) calloc(1, sizeof(rdpRdg));
if (rdg)
{
rdg->state = RDG_CLIENT_STATE_INITIAL;
rdg->context = transport->context;
rdg->settings = rdg->context->settings;
rdg->extAuth = HTTP_EXTENDED_AUTH_NONE;
if (rdg->settings->GatewayAccessToken)
rdg->extAuth = HTTP_EXTENDED_AUTH_PAA;
UuidCreate(&rdg->guid);
rpcStatus = UuidToStringA(&rdg->guid, &stringUuid);
if (rpcStatus == RPC_S_OUT_OF_MEMORY)
goto rdg_alloc_error;
sprintf_s(bracedUuid, sizeof(bracedUuid), "{%s}", stringUuid);
RpcStringFreeA(&stringUuid);
rdg->tlsOut = tls_new(rdg->settings);
if (!rdg->tlsOut)
goto rdg_alloc_error;
rdg->tlsIn = tls_new(rdg->settings);
if (!rdg->tlsIn)
goto rdg_alloc_error;
rdg->http = http_context_new();
if (!rdg->http)
goto rdg_alloc_error;
http_context_set_uri(rdg->http, "/remoteDesktopGateway/");
http_context_set_accept(rdg->http, "*/*");
http_context_set_cache_control(rdg->http, "no-cache");
http_context_set_pragma(rdg->http, "no-cache");
http_context_set_connection(rdg->http, "Keep-Alive");
http_context_set_user_agent(rdg->http, "MS-RDGateway/1.0");
http_context_set_host(rdg->http, rdg->settings->GatewayHostname);
http_context_set_rdg_connection_id(rdg->http, bracedUuid);
if (!rdg->http->URI || !rdg->http->Accept || !rdg->http->CacheControl ||
!rdg->http->Pragma || !rdg->http->Connection || !rdg->http->UserAgent
|| !rdg->http->Host || !rdg->http->RdgConnectionId)
{
goto rdg_alloc_error;
}
if (rdg->extAuth != HTTP_EXTENDED_AUTH_NONE)
{
switch (rdg->extAuth)
{
case HTTP_EXTENDED_AUTH_PAA:
http_context_set_rdg_auth_scheme(rdg->http, "PAA");
if (!rdg->http->RdgAuthScheme)
goto rdg_alloc_error;
break;
default:
WLog_DBG(TAG, "RDG extended authentication method %d not supported", rdg->extAuth);
}
}
rdg->frontBio = BIO_new(BIO_s_rdg());
if (!rdg->frontBio)
goto rdg_alloc_error;
BIO_set_data(rdg->frontBio, rdg);
InitializeCriticalSection(&rdg->writeSection);
}
return rdg;
rdg_alloc_error:
rdg_free(rdg);
return NULL;
}