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 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 );
}
}
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);
}
}
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;
}
zmq::uuid_t::uuid_t ()
{
RPC_STATUS ret = UuidCreate (&uuid);
zmq_assert (ret == RPC_S_OK);
ret = UuidToStringA (&uuid, &string_buf);
zmq_assert (ret == RPC_S_OK);
create_blob ();
}
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;
}
int
ut_get_uuid_str(char *uuid_str)
{
UUID uuid;
char *buff;
if (UuidCreate(&uuid) == 0)
if (UuidToStringA(&uuid, &buff) == RPC_S_OK) {
strcpy_s(uuid_str, UT_POOL_HDR_UUID_STR_LEN, buff);
return 0;
}
return -1;
}
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;
}
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);
}
}
}
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;
}
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;
}
void __fastcall TForm1::Button5Click(TObject *Sender)
{
// unsigned char *p;
// UUID uuid;
//
// ::UuidCreate(&uuid ); // UUID生成
// ::UuidToString(&uuid, &p ); // UUIDを文字列にする
//
// char str[38];
// strncpy(str, (char*)p, sizeof(str)); // 自分で用意したバッファにコピー
//
// ::RpcStringFree(&p );
//
// Memo1->Lines->Add(str);
UUID uuid;
UuidCreate(&uuid);
unsigned char *ch = (unsigned char *)&uuid;
char *szUuid = NULL;
UuidToStringA(&uuid, (RPC_CSTR *)&szUuid);
Memo1->Lines->Add(szUuid);
// printf("%s\n", szUuid);
}
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;
}
int _tmain(int argc, _TCHAR* argv[])
{
WSADATA wsaData;
int result;
system("pause");
result = WSAStartup(MAKEWORD(2, 2), &wsaData);
if(0 != result)
{
_tprintf(_T("WSAStartup error, code: %d"), WSAGetLastError());
exit(0);
}
SOCKET socketForProbe = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(INVALID_SOCKET == socketForProbe)
{
_tprintf(_T("socket error, code: %d"), WSAGetLastError());
exit(0);
}
sockaddr_in sockaddrClient;
memset(&sockaddrClient, 0x0, sizeof(sockaddr_in));
sockaddrClient.sin_addr.s_addr = htonl(INADDR_ANY);
sockaddrClient.sin_family = AF_INET;
sockaddrClient.sin_port = htons(0);
sockaddr_in sockaddrMulticastAddrForOnvif;
memset(&sockaddrMulticastAddrForOnvif, 0x0, sizeof(sockaddr_in));
InetPton(AF_INET, _T("239.255.255.250"), &sockaddrMulticastAddrForOnvif.sin_addr.s_addr);
sockaddrMulticastAddrForOnvif.sin_family = AF_INET;
sockaddrMulticastAddrForOnvif.sin_port = htons(3702);
result = bind(socketForProbe, (struct sockaddr*)&sockaddrClient, sizeof(sockaddr_in));
if(0 != result)
{
_tprintf(_T("bind error, code: %d"), WSAGetLastError());
exit(0);
}
DWORD timeOut = 5000;
result = setsockopt(socketForProbe, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeOut, sizeof(DWORD));
if(0 != result)
{
_tprintf(_T("setsockopt error, code: %d"), WSAGetLastError());
exit(0);
}
char* pProbeMessage = (char*)malloc(2048);
if(NULL == pProbeMessage)
{
_tprintf(_T("malloc error"));
exit(0);
}
receiveThreadParameter parameter;
BOOL loop = TRUE;
DWORD threadID;
parameter.socketForProbe = &socketForProbe;
parameter.bLoop = &loop;
UUID uuid;
RPC_STATUS rpcStatus = UuidCreate(&uuid);
if(RPC_S_OK != rpcStatus)
{
_tprintf(_T("UuidCreate error, code: %d"), WSAGetLastError());
exit(0);
}
RPC_CSTR RpcCstr;
rpcStatus = UuidToStringA(&uuid, &RpcCstr);
if(RPC_S_OK != rpcStatus)
{
_tprintf(_T("UuidCreate error, code: %d"), WSAGetLastError());
exit(0);
}
result = _snprintf_s(pProbeMessage, 2048, _TRUNCATE, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:SOAP-ENC=\"http://www.w3.org/2003/05/soap-encoding\" xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:wsdd=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\"><SOAP-ENV:Header><wsa:MessageID>urn:uuid:%s</wsa:MessageID><wsa:To SOAP-ENV:mustUnderstand=\"true\">urn:schemas-xmlsoap-org:ws:2005:04:discovery</wsa:To><wsa:Action SOAP-ENV:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</wsa:Action></SOAP-ENV:Header><SOAP-ENV:Body><wsdd:Probe></wsdd:Probe></SOAP-ENV:Body></SOAP-ENV:Envelope>", RpcCstr);
if(-1 == result)
{
_tprintf(_T("_snprintf_s error"));
exit(0);
}
rpcStatus = RpcStringFreeA(&RpcCstr);
if(RPC_S_OK != rpcStatus)
{
_tprintf(_T("UuidCreate error, code: %d"), WSAGetLastError());
exit(0);
}
//result = _snprintf_s(pProbeMessage, 2048, _TRUNCATE, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:SOAP-ENC=\"http://www.w3.org/2003/05/soap-encoding\" xmlns:wsa=\"http://schemas.xmlsoap.org/ws/2004/08/addressing\" xmlns:wsdd=\"http://schemas.xmlsoap.org/ws/2005/04/discovery\"><SOAP-ENV:Header><wsa:MessageID>urn:uuid:bc9fb550-1dd1-11b2-807c-c056e3fb5481</wsa:MessageID><wsa:To SOAP-ENV:mustUnderstand=\"true\">urn:schemas-xmlsoap-org:ws:2005:04:discovery</wsa:To><wsa:Action SOAP-ENV:mustUnderstand=\"true\">http://schemas.xmlsoap.org/ws/2005/04/discovery/Probe</wsa:Action></SOAP-ENV:Header><SOAP-ENV:Body><wsdd:Probe><wsdd:Types>Device</wsdd:Types><wsdd:Scopes></wsdd:Scopes></wsdd:Probe></SOAP-ENV:Body></SOAP-ENV:Envelope>");
//if(-1 == result)
//{
// _tprintf(_T("_snprintf_s error"));
// exit(0);
//}
HANDLE hThread = CreateThread(NULL, 0, receiveThread, ¶meter, 0, &threadID);
if(NULL == hThread)
{
_tprintf(_T("CreateThread error, code: %d"), GetLastError());
exit(0);
}
result = sendto(socketForProbe, pProbeMessage, result, 0, (sockaddr*)&sockaddrMulticastAddrForOnvif, sizeof(sockaddr_in));
if(SOCKET_ERROR == result)
{
_tprintf(_T("sendto error, code: %d"), WSAGetLastError());
exit(0);
}
Sleep(5000);
loop = FALSE;
WaitForMultipleObjects(1, &hThread, TRUE, INFINITE);
CloseHandle(hThread);
free(pProbeMessage);
pProbeMessage = NULL;
result = closesocket(socketForProbe);
if(0 != result)
{
_tprintf(_T("closesocket error, code: %d"), WSAGetLastError());
exit(0);
}
result = WSACleanup();
if(0 != result)
{
_tprintf(_T("WSACleanup error, code: %d"), WSAGetLastError());
exit(0);
}
system("pause");
return 0;
}
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);
}
}
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;
}
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;
}
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();
}
/***********************************************************************
* NdrDllRegisterProxy [RPCRT4.@]
*/
HRESULT WINAPI NdrDllRegisterProxy(HMODULE hDll,
const ProxyFileInfo **pProxyFileList,
const CLSID *pclsid)
{
LPSTR clsid;
char keyname[120], module[MAX_PATH];
HKEY key, subkey;
DWORD len;
TRACE("(%p,%p,%s)\n", hDll, pProxyFileList, debugstr_guid(pclsid));
UuidToStringA((UUID*)pclsid, (unsigned char**)&clsid);
/* register interfaces to point to clsid */
while (*pProxyFileList) {
unsigned u;
for (u=0; u<(*pProxyFileList)->TableSize; u++) {
CInterfaceStubVtbl *proxy = (*pProxyFileList)->pStubVtblList[u];
PCInterfaceName name = (*pProxyFileList)->pNamesArray[u];
LPSTR iid;
TRACE("registering %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);
if (RegCreateKeyExA(HKEY_CLASSES_ROOT, keyname, 0, NULL, 0,
KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS) {
if (name)
RegSetValueExA(key, NULL, 0, REG_SZ, (LPBYTE)name, strlen(name));
if (RegCreateKeyExA(key, "ProxyStubClsid32", 0, NULL, 0,
KEY_WRITE, NULL, &subkey, NULL) == ERROR_SUCCESS) {
snprintf(module, sizeof(module), "{%s}", clsid);
RegSetValueExA(subkey, NULL, 0, REG_SZ, (LPBYTE)module, strlen(module));
RegCloseKey(subkey);
}
RegCloseKey(key);
}
}
pProxyFileList++;
}
/* register clsid to point to module */
snprintf(keyname, sizeof(keyname), "CLSID\\{%s}", clsid);
len = GetModuleFileNameA(hDll, module, sizeof(module));
if (len && len < sizeof(module)) {
TRACE("registering CLSID %s => %s\n", clsid, module);
if (RegCreateKeyExA(HKEY_CLASSES_ROOT, keyname, 0, NULL, 0,
KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS) {
RegSetValueExA(subkey, NULL, 0, REG_SZ, (LPBYTE)"PSFactoryBuffer", strlen("PSFactoryBuffer"));
if (RegCreateKeyExA(key, "InProcServer32", 0, NULL, 0,
KEY_WRITE, NULL, &subkey, NULL) == ERROR_SUCCESS) {
RegSetValueExA(subkey, NULL, 0, REG_SZ, (LPBYTE)module, strlen(module));
RegSetValueExA(subkey, "ThreadingModel", 0, REG_SZ, (LPBYTE)"Both", strlen("Both"));
RegCloseKey(subkey);
}
RegCloseKey(key);
}
}
/* done */
RpcStringFreeA((unsigned char**)&clsid);
return S_OK;
}