BOOL CEnumerateSerial::UsingWMI(CSimpleArray<UINT>& ports, CSimpleArray<CString>& friendlyNames) #endif { //Make sure we clear out any elements which may already be in the array(s) #if defined CENUMERATESERIAL_USE_STL ports.clear(); friendlyNames.clear(); #else ports.RemoveAll(); friendlyNames.RemoveAll(); #endif //What will be the return value BOOL bSuccess = FALSE; //Create the WBEM locator IWbemLocator* pLocator = NULL; HRESULT hr = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, IID_IWbemLocator, reinterpret_cast<void**>(&pLocator)); if (SUCCEEDED(hr)) { IWbemServices* pServices = NULL; hr = pLocator->ConnectServer(_bstr_t("\\\\.\\root\\cimv2"), NULL, NULL, NULL, 0, NULL, NULL, &pServices); if (SUCCEEDED(hr)) { //Execute the query IEnumWbemClassObject* pClassObject = NULL; hr = pServices->CreateInstanceEnum(_bstr_t("Win32_SerialPort"), WBEM_FLAG_RETURN_WBEM_COMPLETE, NULL, &pClassObject); if (SUCCEEDED(hr)) { bSuccess = TRUE; //Now enumerate all the ports hr = WBEM_S_NO_ERROR; //Final Next will return WBEM_S_FALSE while (hr == WBEM_S_NO_ERROR) { ULONG uReturned = 0; IWbemClassObject* apObj[10]; memset(apObj, 0, sizeof(apObj)); hr = pClassObject->Next(WBEM_INFINITE, 10, reinterpret_cast<IWbemClassObject**>(apObj), &uReturned); if (SUCCEEDED(hr)) { for (ULONG n=0; n<uReturned; n++) { VARIANT varProperty1; VariantInit(&varProperty1); HRESULT hrGet = apObj[n]->Get(L"DeviceID", 0, &varProperty1, NULL, NULL); if (SUCCEEDED(hrGet) && (varProperty1.vt == VT_BSTR) && (wcslen(varProperty1.bstrVal) > 3)) { //If it looks like "COMX" then add it to the array which will be returned if ((_wcsnicmp(varProperty1.bstrVal, L"COM", 3) == 0) && IsNumeric(&(varProperty1.bstrVal[3]), TRUE)) { //Work out the port number int nPort = _wtoi(&(varProperty1.bstrVal[3])); #if defined CENUMERATESERIAL_USE_STL ports.push_back(nPort); #else ports.Add(nPort); #endif //Also get the friendly name of the port VARIANT varProperty2; VariantInit(&varProperty2); if (SUCCEEDED(apObj[n]->Get(L"Name", 0, &varProperty2, NULL, NULL)) && (varProperty2.vt == VT_BSTR)) { #if defined CENUMERATESERIAL_USE_STL #if defined _UNICODE std::wstring szName(varProperty2.bstrVal); #else CAutoHeapAlloc szAsciiValue; int nLengthA = WideCharToMultiByte(CP_ACP, 0, varProperty2.bstrVal, -1, NULL, 0, NULL, NULL); if (nLengthA) { if (szAsciiValue.Allocate(nLengthA)) WideCharToMultiByte(CP_ACP, 0, varProperty2.bstrVal, -1, static_cast<LPSTR>(szAsciiValue.m_pData), nLengthA, NULL, NULL); } std::string szName(static_cast<LPSTR>(szAsciiValue.m_pData)); #endif friendlyNames.push_back(szName); #else friendlyNames.Add(CString(varProperty2.bstrVal)); #endif } else { #if defined CENUMERATESERIAL_USE_STL friendlyNames.push_back(_T("")); #else friendlyNames.Add(_T("")); #endif } //Free up the variant; VariantClear(&varProperty2); } } //Free up the variant; VariantClear(&varProperty1); //Free up each COM interface apObj[n]->Release(); } } } //Free up the COM interface pClassObject->Release(); } //Free up the COM interface pServices->Release(); } //Free up the COM interface pLocator->Release(); } return bSuccess; }
int main(int argc, char* argv[]) { IADs *pNS = NULL, *pRoot=NULL, *pAuth=NULL; IADsOpenDSObject *pDSObj=NULL; VARIANT varDSRoot; TCHAR adspath[MAX_PATH],username[255],password[255]; HRESULT hr; hr = CoInitialize(NULL); // Get the name of the root container for this domain. // Read the Root DSE from the default DS, which will be the DS for // the local domain. This will get us the name of the schema container, // which is stored in the "defaultNamingContext" operational attribute. hr = ADsGetObject(TEXT("LDAP://RootDSE"), IID_IADs, (void**)&pRoot); if ( FAILED(hr) ) { ::CoUninitialize(); _tprintf(TEXT("\nError in ADsGetObject")); return 1; } hr = pRoot->Get(TEXT("defaultNamingContext"),&varDSRoot); if ( FAILED(hr) ) { ::CoUninitialize(); pRoot->Release(); _tprintf(TEXT("\nError in reading defaultNamingContext")); return 1; } _tprintf(TEXT("\nDomain Name is :%s\n"),varDSRoot.bstrVal); pRoot->Release(); _tcscpy_s(adspath,MAX_PATH, TEXT("LDAP://")); // get the remaining buffer size; make sure it copies, avoid buffer overrun int rem = (sizeof(adspath)/sizeof(TCHAR)) - _tcslen(adspath) -1; //-1 is for NULL int len = wcslen(varDSRoot.bstrVal); if ( rem >= len ) { _tcsncat_s(adspath,MAX_PATH,varDSRoot.bstrVal, len); } else { pRoot->Release(); VariantClear(&varDSRoot); return 1; } hr = ADsGetObject(TEXT("LDAP:"), IID_IADs, (void**)&pNS); if ( FAILED(hr) ) { ::CoUninitialize(); _tprintf(TEXT("\nError in ADsGetObject")); return 1; } hr = pNS->QueryInterface(IID_IADsOpenDSObject,(void**)&pDSObj); if ( FAILED(hr) ) { ::CoUninitialize(); pNS->Release(); _tprintf(TEXT("\nError in QueryInterface")); return 1; } // // Collect the username and password and bind to the Domain using these. // if SUCCEEDED(hr) { pNS->Release(); _tprintf(TEXT("\nusername:"******"\"%s\""), username); _tprintf(TEXT("\npassword:"******"Bind Failed"),(DWORD)hr); } else { _tprintf(TEXT("Successfully logon!")); } }
static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { DispatchEx *This = impl_from_IDispatchEx(iface); IUnknown *unk; ITypeInfo *ti; dispex_data_t *data; UINT argerr=0; int min, max, n; HRESULT hres; TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); if(This->data->vtbl && This->data->vtbl->invoke) { hres = This->data->vtbl->invoke(This->outer, id, lcid, wFlags, pdp, pvarRes, pei); if (hres != DISP_E_UNKNOWNNAME) return hres; } if(wFlags == DISPATCH_CONSTRUCT) { FIXME("DISPATCH_CONSTRUCT not implemented\n"); return E_NOTIMPL; } if(is_dynamic_dispid(id)) { DWORD idx = id - DISPID_DYNPROP_0; VARIANT *var; if(!This->dynamic_data || This->dynamic_data->prop_cnt <= idx) return DISP_E_UNKNOWNNAME; var = &This->dynamic_data->props[idx].var; switch(wFlags) { case INVOKE_PROPERTYGET: V_VT(pvarRes) = VT_EMPTY; return VariantCopy(pvarRes, var); case INVOKE_PROPERTYPUT: VariantClear(var); return VariantCopy(var, pdp->rgvarg); default: FIXME("unhandled wFlags %x\n", wFlags); return E_NOTIMPL; } } data = get_dispex_data(This); if(!data) return E_FAIL; min = 0; max = data->func_cnt-1; while(min <= max) { n = (min+max)/2; if(data->funcs[n].id == id) break; if(data->funcs[n].id < id) min = n+1; else max = n-1; } if(min > max) { WARN("invalid id %x\n", id); return DISP_E_UNKNOWNNAME; } hres = get_typeinfo(data->funcs[n].tid, &ti); if(FAILED(hres)) { ERR("Could not get type info: %08x\n", hres); return hres; } hres = IUnknown_QueryInterface(This->outer, get_riid_from_tid(data->funcs[n].tid), (void**)&unk); if(FAILED(hres)) { ERR("Could not get iface: %08x\n", hres); ITypeInfo_Release(ti); return E_FAIL; } hres = ITypeInfo_Invoke(ti, unk, id, wFlags, pdp, pvarRes, pei, &argerr); ITypeInfo_Release(ti); IUnknown_Release(unk); return hres; }
// Read merit and version information HRESULT MainDialog::GetMerit(IPropertyBag *pPropBag, DWORD *pdwMerit) { HRESULT hr; IAMFilterData *pData = NULL; VARIANT varFilData={0}; varFilData.vt = VT_UI1 | VT_ARRAY; varFilData.parray = 0; // docs say to zero this BYTE *pbFilterData = 0; // 0 if not read DWORD dwcbFilterDAta = 0; // 0 if not read // Read compressed filter data from the property bag with a variant hr = pPropBag->Read(L"FilterData", &varFilData, 0); if (SUCCEEDED(hr)) { assert(varFilData.vt == (VT_UI1 | VT_ARRAY)); dwcbFilterDAta = varFilData.parray->rgsabound[0].cElements; // Access the filter data hr = SafeArrayAccessData(varFilData.parray, (void **)&pbFilterData); } // Get the IAMFilterData interface for parsing the filter data if (SUCCEEDED(hr)) { hr = m_pMapper->QueryInterface(__uuidof(IAMFilterData), (void **)&pData); } if (SUCCEEDED(hr)) { BYTE *pb=0; // Use a helper method to parse the binary filter data. Pass in // the pointer to the filter data, its size, and a buffer to fill with // the resulting data. The "pb" buffer is allocated with CoTaskMemAlloc, // so it must be correspondingly freed by the caller. hr = pData->ParseFilterData(pbFilterData, dwcbFilterDAta, &pb); if(SUCCEEDED(hr)) { REGFILTER2 *pFil = ((REGFILTER2 **)pb)[0]; // Assign the merit value from the REGFILTER2 structure if (pFil) { *pdwMerit = pFil->dwMerit; // Free the memory allocated by ParseFilterData CoTaskMemFree(pFil); } } } if (pbFilterData) { SafeArrayUnaccessData(varFilData.parray); VariantClear(&varFilData); } // Release the IAMFilterData interface SAFE_RELEASE(pData); return hr; }
static void test_mxwriter_startendelement(void) { static const char winehqA[] = "http://winehq.org"; ISAXContentHandler *content; IMXWriter *writer; VARIANT dest; HRESULT hr; hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER, &IID_IMXWriter, (void**)&writer); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content); ok(hr == S_OK, "got %08x\n", hr); hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE); ok(hr == S_OK, "got %08x\n", hr); hr = ISAXContentHandler_startDocument(content); ok(hr == S_OK, "got %08x\n", hr); /* qualified name without defined namespace */ hr = ISAXContentHandler_startElement(content, NULL, 0, NULL, 0, _bstr_("a:b"), 3, NULL); ok(hr == E_INVALIDARG, "got %08x\n", hr); hr = ISAXContentHandler_startElement(content, NULL, 0, _bstr_("b"), 1, _bstr_("a:b"), 3, NULL); ok(hr == E_INVALIDARG, "got %08x\n", hr); /* only local name is an error too */ hr = ISAXContentHandler_startElement(content, NULL, 0, _bstr_("b"), 1, NULL, 0, NULL); ok(hr == E_INVALIDARG, "got %08x\n", hr); /* only local name is an error too */ hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_("b"), 1, NULL, 0, NULL); ok(hr == E_INVALIDARG, "got %08x\n", hr); /* all string pointers should be not null */ hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_("b"), 1, _bstr_(""), 0, NULL); ok(hr == S_OK, "got %08x\n", hr); V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); ok(!lstrcmpW(_bstr_("<>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("b"), 1, NULL); ok(hr == S_OK, "got %08x\n", hr); V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); ok(!lstrcmpW(_bstr_("<><b>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); hr = ISAXContentHandler_endElement(content, NULL, 0, NULL, 0, _bstr_("a:b"), 3); ok(hr == E_INVALIDARG, "got %08x\n", hr); hr = ISAXContentHandler_endElement(content, NULL, 0, _bstr_("b"), 1, _bstr_("a:b"), 3); ok(hr == E_INVALIDARG, "got %08x\n", hr); /* only local name is an error too */ hr = ISAXContentHandler_endElement(content, NULL, 0, _bstr_("b"), 1, NULL, 0); ok(hr == E_INVALIDARG, "got %08x\n", hr); hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("b"), 1); ok(hr == S_OK, "got %08x\n", hr); V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); ok(!lstrcmpW(_bstr_("<><b></b>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); /* some with namespace URI */ hr = ISAXContentHandler_startElement(content, _bstr_(winehqA), sizeof(winehqA), _bstr_(""), 0, _bstr_("nspace:c"), 8, NULL); ok(hr == S_OK, "got %08x\n", hr); hr = ISAXContentHandler_endElement(content, _bstr_(winehqA), sizeof(winehqA), _bstr_(""), 0, _bstr_("nspace:c"), 8); ok(hr == S_OK, "got %08x\n", hr); V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); todo_wine ok(!lstrcmpW(_bstr_("<><b></b><nspace:c/>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); /* try to end element that wasn't open */ hr = ISAXContentHandler_endElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("a"), 1); ok(hr == S_OK, "got %08x\n", hr); V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); todo_wine ok(!lstrcmpW(_bstr_("<><b></b><nspace:c/></a>"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); /* try with attributes */ hr = ISAXContentHandler_startElement(content, _bstr_(""), 0, _bstr_(""), 0, _bstr_("b"), 1, &saxattributes); ok(hr == S_OK, "got %08x\n", hr); hr = ISAXContentHandler_endDocument(content); todo_wine ok(hr == S_OK, "got %08x\n", hr); ISAXContentHandler_Release(content); IMXWriter_Release(writer); free_bstrs(); }
TEXT("雏龙"),TEXT("幼龙"),TEXT("鸭嘴龙"),TEXT("双棘龙"), TEXT("迅龙"),TEXT("雷龙"),TEXT("甲龙"),TEXT("角龙"), TEXT("剑龙"),TEXT("黄金龙"),TEXT("霸王龙"),TEXT("北海冥龙"), TEXT("南海狂龙"),TEXT("西海魔龙"),TEXT("东海神龙"),TEXT("中华圣龙"), }; for (int i=0;i<CountArray(lScoreInfo_2);i++) { if (score<lScoreInfo_2[i]) return pszOrderName_2[i]; } return pszOrderName_2[17]; } float CLogic::AssertUserPer(LONG score) { LONG lScoreInfo_2[18]= { 0L,50L,100L,200L,500L,800L,1200L,2000L,3000L,5000L,8000L,12000L,15000L,18000L,25000L,40000L,60000L, }; for (int i=0;i<CountArray(lScoreInfo_2);i++) { if (score<lScoreInfo_2[i]&&i!=0) return (float)(100.0*(score-lScoreInfo_2[i-1])/(lScoreInfo_2[i]-lScoreInfo_2[i-1])); else if (score<lScoreInfo_2[i]&&score<0&&i==0) return 0.0; } return 100.0; } void CLogic::OpenUrl(CString url) { HRESULT hr; IWebBrowserApp* pWBApp = NULL; // Derived from IWebBrowser BSTR bstrURL = NULL, bstrHeaders = NULL; VARIANT vFlags = {0}, vTargetFrameName = {0}, vPostData = {0}, vHeaders = {0}; if (FAILED(hr = CoInitialize(NULL))) { return; } if (FAILED(hr = CoCreateInstance(CLSID_InternetExplorer, NULL, CLSCTX_SERVER, IID_IWebBrowserApp, (LPVOID*)&pWBApp))) { if (bstrURL) SysFreeString(bstrURL); if (bstrHeaders) SysFreeString(bstrHeaders); VariantClear(&vPostData); if (pWBApp) pWBApp->Release(); CoUninitialize(); return; } bstrURL = url.AllocSysString(); if (!bstrURL) { if (bstrURL) SysFreeString(bstrURL); if (bstrHeaders) SysFreeString(bstrHeaders); VariantClear(&vPostData); if (pWBApp) pWBApp->Release(); CoUninitialize();
static unsigned int getclock(void) { unsigned int clock; #ifdef KONOHA_ON_MACOSX int cpu_sels[2] = { CTL_HW, HW_CPU_FREQ }; size_t len = sizeof(int); sysctl(cpu_sels, 2, &clock, &len, NULL, 0); clock = (unsigned int) clock / (1000 * 1000); #elif defined(KONOHA_ON_WINDOWS) HRESULT hres; hres = CoInitializeEx(0, COINIT_MULTITHREADED); hres = CoInitializeSecurity( NULL, -1, // COM authentication NULL, // Authentication services NULL, // Reserved RPC_C_AUTHN_LEVEL_DEFAULT, // Default authentication RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation NULL, // Authentication info EOAC_NONE, // Additional capabilities NULL // Reserved ); IWbemLocator *pLoc = NULL; hres = CoCreateInstance( CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID *) &pLoc); IWbemServices *pSvc = NULL; hres = pLoc->ConnectServer( _bstr_t(L"ROOT\\CIMV2"), // Object path of WMI namespace NULL, // User name. NULL = current user NULL, // User password. NULL = current 0, // Locale. NULL indicates current NULL, // Security flags. 0, // Authority (e.g. Kerberos) 0, // Context object &pSvc // pointer to IWbemServices proxy ); hres = CoSetProxyBlanket( pSvc, // Indicates the proxy to set RPC_C_AUTHN_WINNT, // RPC_C_AUTHN_xxx RPC_C_AUTHZ_NONE, // RPC_C_AUTHZ_xxx NULL, // Server principal name RPC_C_AUTHN_LEVEL_CALL, // RPC_C_AUTHN_LEVEL_xxx RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx NULL, // client identity EOAC_NONE // proxy capabilities ); IEnumWbemClassObject* pEnumerator = NULL; hres = pSvc->ExecQuery( bstr_t("WQL"), bstr_t("SELECT * FROM Win32_Processor"), WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pEnumerator); IWbemClassObject *pclsObj; ULONG uReturn = 0; while (pEnumerator) { HRESULT hr = pEnumerator->Next( WBEM_INFINITE, 1, &pclsObj, &uReturn ); if (uReturn == 0) { break; } VARIANT vtProp; hr = pclsObj->Get(L"MaxClockSpeed", 0, &vtProp, 0, 0); clock = (unsigned int)vtProp.bstrVal; VariantClear(&vtProp); pclsObj->Release(); } pSvc->Release(); pLoc->Release(); pEnumerator->Release(); CoUninitialize(); #elif defined(KONOHA_ON_LINUX) char buf[64] = {'\0'}, *data = buf; const char *cpumhz = "cpu MHz"; size_t len = strlen(cpumhz); FILE *fp = fopen("/proc/cpuinfo","r"); while (fgets( buf, 64, fp ) != NULL){ if ( strncmp(buf, cpumhz, len) == 0){ data = strstr(buf, cpumhz); break; } } while (!isdigit(*data)) { data++; } clock = (unsigned int) atoi(data) / 1000; fclose(fp); #else TODO(); #endif return clock; }
HRESULT IStreamToDOMDocument( __inout IStream *pStream, __deref_out IXMLDOMDocument2 **ppXmlDocument ) { HRESULT hr = S_OK; if (NULL == ppXmlDocument || NULL == pStream) { hr = E_INVALIDARG; } if (ppXmlDocument) { *ppXmlDocument = NULL; } if ( SUCCEEDED(hr) ) { hr = CoCreateInstance(CLSID_DOMDocument60,NULL,CLSCTX_INPROC_SERVER,IID_IXMLDOMDocument2,(LPVOID *)ppXmlDocument); } if( SUCCEEDED(hr) ) { LARGE_INTEGER pos = {0, 0}; hr = pStream->Seek( pos, STREAM_SEEK_SET, NULL ); } // // Load the XML synchronously // if (SUCCEEDED(hr)) { VARIANT_BOOL loadResult = 0; // Inidicates the result of loading the XML VARIANT streamVar; // Variant wrapper for the IStream to pass to load. VariantInit(&streamVar); V_VT(&streamVar) = VT_UNKNOWN; V_UNKNOWN(&streamVar) = pStream; pStream->AddRef(); hr = (*ppXmlDocument)->load( streamVar, &loadResult ); // // Check immediately to see if there was a parse error, since this // comes back as S_FALSE instead of E_... // if (hr == S_FALSE) { // We could Figure out why it failed, but for now, lets just // signal failure. hr = E_FAIL; } VariantClear(&streamVar); } return hr; }
// // Purpose: // Entry point for the process // // Parameters: // None // // Return value: // None // void __cdecl main() { DWORD result = NO_ERROR; HRESULT hr = S_OK; INetFwProduct* product = NULL; INetFwProducts* products = NULL; IUnknown* registration = NULL; long *categories = NULL; BSTR displayName = NULL; VARIANT varCategories = { VT_EMPTY }; int numberOfCategories = 1; long count=0; BOOL comInit = FALSE; //Allocate Memory categories = (long *)calloc (numberOfCategories , sizeof(long)); BAIL_ON_ALLOC_FAILURE(categories, calloc); //Take Firewall Category Ownership categories[0] = NET_FW_RULE_CATEGORY_FIREWALL; result = ArrayOfLongsToVariant(numberOfCategories, categories, &varCategories); displayName = SysAllocString(L"@RegisterFirewallSample.exe,-127"); BAIL_ON_ALLOC_FAILURE(displayName, SysAllocString); hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); if (FAILED(hr)) { //COM initialize failed wprintf(L"CoInitialize failed: 0x%08lx\n", result); goto CLEANUP; } comInit = TRUE; hr = CoCreateInstance(__uuidof(NetFwProduct),NULL,CLSCTX_INPROC_SERVER,__uuidof(INetFwProduct),(void**)&product ); if (FAILED(hr)) { //CoCreateInstance Failed wprintf(L"CoCreateInstance for INetFwProduct failed: 0x%08lx\n", hr); goto CLEANUP; } hr = product->put_DisplayName(displayName); if (FAILED(hr)) { //Put_displayName failed wprintf(L"put_DisplayName for INetFwProduct failed Error: 0x%08lx\n", hr); goto CLEANUP; } hr = product->put_RuleCategories(varCategories); if (FAILED(hr)) { //Put_rulecategories failed wprintf(L"put_RuleCategories failed for INetFwProduct Error: 0x%08lx\n", hr); goto CLEANUP; } hr = CoCreateInstance(__uuidof(NetFwProducts),NULL,CLSCTX_INPROC_SERVER,__uuidof(INetFwProducts),(void**)&products ); if (FAILED(hr)) { //CoCreateInstance Failed wprintf(L"CoCreateInstance for INetFwProducts failed: 0x%08lx\n", hr); goto CLEANUP; } hr = products->Register(product, ®istration); if (FAILED(hr)) { //Failed to Register Products wprintf(L"Register failed: 0x%08lx\n", hr); goto CLEANUP; } hr = products->get_Count( &count); if (FAILED(hr)) { //Failed to get Count of Products wprintf(L"Get count failed: 0x%08lx\n", hr); goto CLEANUP; } wprintf(L"INetFwProducts_Count returned %ld.\n", count); wprintf(L"Hit any key to unregister.\n"); _getch(); CLEANUP: if (registration != NULL) { registration->Release(); } if (products != NULL) { products->Release(); } if (product != NULL) { product->Release(); } if (comInit) { CoUninitialize(); } free(categories); SysFreeString(displayName); VariantClear(&varCategories); return; }
//+--------------------------------------------------------------------------- // // Function: VARIANTARGToCVar // // Synopsis: Converts a VARIANT to a C-language variable. // // Arguments: [pvarg] -- Variant to convert. // [pfAlloc] -- BSTR allocated during conversion caller is // now owner of this BSTR or IUnknown or IDispatch // object allocated needs to be released. // [vt] -- Type to convert to. // [pv] -- Location to place C-language variable. // // Modifies: [pv]. // // Returns: HRESULT. // // History: 2-23-94 adams Created // // Notes: Supports all variant pointer types, VT_I2, VT_I4, VT_R4, // VT_R8, VT_ERROR. //---------------------------------------------------------------------------- HRESULT VARIANTARGToCVar(VARIANT* pvarg, BOOL* pfAlloc, VARTYPE vt, void* pv, IServiceProvider* pSrvProvider, WORD wMaxstrlen) { HRESULT hr = S_OK; VARIANTARG* pVArgCopy = pvarg; VARIANTARG vargNew; // variant of new type BOOL fAlloc; Assert(pvarg); Assert(pv); if(!pfAlloc) { pfAlloc = &fAlloc; } Assert((vt&~VT_TYPEMASK) == 0 || (vt&~VT_TYPEMASK)==VT_BYREF); // Assume no allocations yet. *pfAlloc = FALSE; if(vt & VT_BYREF) { // If the parameter is a variant pointer then everything is acceptable. if((vt&VT_TYPEMASK) == VT_VARIANT) { switch(V_VT(pvarg)) { case VT_VARIANT|VT_BYREF: hr = ClipVarString(pvarg->pvarVal, *(VARIANT**)pv, pfAlloc, wMaxstrlen); break; default: hr = ClipVarString(pvarg, *(VARIANT**)pv, pfAlloc, wMaxstrlen); break; } if(hr == S_FALSE) { hr = S_OK; *(PVOID*)pv = (PVOID)pvarg; } goto Cleanup; } if((V_VT(pvarg)&VT_TYPEMASK) != (vt&VT_TYPEMASK)) { hr = DISP_E_TYPEMISMATCH; goto Cleanup; } // Type of both original and destination or same type (however, original // may not be a byref only the original. if(V_ISBYREF(pvarg)) { // Destination and original are byref and same type just copy pointer. *(PVOID*)pv = V_BYREF(pvarg); } else { // Convert original to byref. switch(vt & VT_TYPEMASK) { case VT_BOOL: *(PVOID*)pv = (PVOID)&V_BOOL(pvarg); break; case VT_I2: *(PVOID*)pv = (PVOID)&V_I2(pvarg); break; case VT_ERROR: case VT_I4: *(PVOID*)pv = (PVOID)&V_I4(pvarg); break; case VT_R4: *(PVOID*)pv = (PVOID)&V_R4(pvarg); break; case VT_R8: *(PVOID*)pv = (PVOID)&V_R8(pvarg); break; case VT_CY: *(PVOID*)pv = (PVOID)&V_CY(pvarg); break; // All pointer types. case VT_PTR: case VT_BSTR: case VT_LPSTR: case VT_LPWSTR: case VT_DISPATCH: case VT_UNKNOWN: *(PVOID*)pv = (PVOID)&V_UNKNOWN(pvarg); break; case VT_VARIANT: Assert("Dead code: shudn't have gotten here!"); *(PVOID*)pv = (PVOID)pvarg; break; default: Assert(!"Unknown type in BYREF VARIANTARGToCVar().\n"); hr = DISP_E_TYPEMISMATCH; goto Cleanup; } } goto Cleanup; } // If the c style parameter is the same type as the VARIANT then we'll just // move the data. Also if the c style type is a VARIANT then there's // nothing to convert just copy the variant to the C parameter. else if((V_VT(pvarg)&(VT_TYPEMASK|VT_BYREF))!=vt && (vt!=VT_VARIANT)) { // If the request type isn't the same as the variant passed in then we // need to convert. VariantInit(&vargNew); pVArgCopy = &vargNew; hr = VariantChangeTypeSpecial(pVArgCopy, pvarg, vt,pSrvProvider); if(hr) { goto Cleanup; } *pfAlloc = (vt==VT_BSTR) || (vt==VT_UNKNOWN) || (vt==VT_DISPATCH); } // Move the variant data to C style data. switch(vt) { case VT_BOOL: // convert VT_TRUE and any other non-zero values to TRUE *(VARIANT_BOOL*)pv = V_BOOL(pVArgCopy); break; case VT_I2: *(short*)pv = V_I2(pVArgCopy); break; case VT_ERROR: case VT_I4: *(long*)pv = V_I4(pVArgCopy); break; case VT_R4: *(float*)pv = V_R4(pVArgCopy); break; case VT_R8: *(double*)pv = V_R8(pVArgCopy); break; case VT_CY: *(CY*)pv = V_CY(pVArgCopy); break; // All Pointer types. case VT_BSTR: if(wMaxstrlen && FormsStringLen(V_BSTR(pVArgCopy))>wMaxstrlen) { hr = FormsAllocStringLen(V_BSTR(pVArgCopy), wMaxstrlen, (BSTR*)pv); if(hr) { goto Cleanup; } if(*pfAlloc) { VariantClear(&vargNew); } else { *pfAlloc = TRUE; } goto Cleanup; } case VT_PTR: case VT_LPSTR: case VT_LPWSTR: case VT_DISPATCH: case VT_UNKNOWN: *(void**)pv = V_BYREF(pVArgCopy); break; case VT_VARIANT: hr = ClipVarString(pVArgCopy, (VARIANT*)pv, pfAlloc, wMaxstrlen); if(hr == S_FALSE) { hr = S_OK; // Copy entire variant to output parameter. *(VARIANT*)pv = *pVArgCopy; } break; default: Assert(FALSE && "Unknown type in VARIANTARGToCVar().\n"); hr = DISP_E_TYPEMISMATCH; break; } Cleanup: RRETURN(hr); }
static void test_propertybag_read(IPropertyBag2 *property) { HRESULT hr; PROPBAG2 options[3] = {{0}}; VARIANT values[3]; HRESULT itm_hr[3] = {S_OK, S_OK, S_OK}; /* 1. One unknown property */ options[0].pstrName = (LPOLESTR)wszTestInvalidProperty; hr = IPropertyBag2_Read(property, 1, options, NULL, values, itm_hr); ok(hr == E_FAIL, "Read for an unknown property did not fail with expected code, hr=%x\n", hr); /* 2. One known property */ options[0].pstrName = (LPOLESTR)wszTestProperty1; itm_hr[0] = E_FAIL; hr = IPropertyBag2_Read(property, 1, options, NULL, values, itm_hr); ok(hr == S_OK, "Read failed, hr=%x\n", hr); if (SUCCEEDED(hr)) { ok(itm_hr[0] == S_OK, "Read failed, itm_hr[0]=%x\n", itm_hr[0]); ok(V_VT(&values[0]) == VT_UI1, "Read failed, V_VT(&values[0])=%x\n", V_VT(&values[0])); ok(V_UNION(&values[0], bVal) == 12, "Read failed, &values[0]=%i\n", V_UNION(&values[0], bVal)); VariantClear(&values[0]); } /* 3. Two known properties */ options[0].pstrName = (LPOLESTR)wszTestProperty1; options[1].pstrName = (LPOLESTR)wszTestProperty2; itm_hr[0] = E_FAIL; itm_hr[1] = E_FAIL; hr = IPropertyBag2_Read(property, 2, options, NULL, values, itm_hr); ok(hr == S_OK, "Read failed, hr=%x\n", hr); if (SUCCEEDED(hr)) { ok(itm_hr[0] == S_OK, "Read failed, itm_hr[0]=%x\n", itm_hr[0]); ok(V_VT(&values[0]) == VT_UI1, "Read failed, V_VT(&values[0])=%x\n", V_VT(&values[0])); ok(V_UNION(&values[0], bVal) == 12, "Read failed, &values[0]=%i\n", V_UNION(&values[0], bVal)); ok(itm_hr[1] == S_OK, "Read failed, itm_hr[1]=%x\n", itm_hr[1]); ok(V_VT(&values[1]) == VT_R4, "Read failed, V_VT(&values[1])=%x\n", V_VT(&values[1])); ok(V_UNION(&values[1], fltVal) == (float)3.14, "Read failed, &values[1]=%f\n", V_UNION(&values[1], fltVal)); VariantClear(&values[0]); VariantClear(&values[1]); } /* 4. One unknown property between two valid */ /* Exotic initializations so we can detect what is unchanged */ itm_hr[0] = -1; itm_hr[1] = -1; itm_hr[2] = -1; V_VT(&values[0]) = VT_NULL; V_VT(&values[1]) = VT_NULL; V_VT(&values[2]) = VT_NULL; V_UNION(&values[0], bVal) = 254; V_UNION(&values[1], bVal) = 254; V_UNION(&values[2], bVal) = 254; options[0].pstrName = (LPOLESTR)wszTestProperty1; options[1].pstrName = (LPOLESTR)wszTestInvalidProperty; options[2].pstrName = (LPOLESTR)wszTestProperty2; hr = IPropertyBag2_Read(property, 3, options, NULL, values, itm_hr); ok(hr == E_FAIL, "Read failed, hr=%x\n", hr); if (hr == E_FAIL) { ok(itm_hr[0] == S_OK, "Read error code has unexpected value, itm_hr[0]=%x\n", itm_hr[0]); ok(itm_hr[1] == -1, "Read error code has unexpected value, itm_hr[1]=%x\n", itm_hr[1]); ok(itm_hr[2] == -1, "Read error code has unexpected value, itm_hr[2]=%x\n", itm_hr[2]); ok(V_VT(&values[0]) == VT_UI1, "Read variant has unexpected type, V_VT(&values[0])=%x\n", V_VT(&values[0])); ok(V_VT(&values[1]) == VT_NULL, "Read variant has unexpected type, V_VT(&values[1])=%x\n", V_VT(&values[1])); ok(V_VT(&values[2]) == VT_NULL, "Read variant has unexpected type, V_VT(&values[2])=%x\n", V_VT(&values[2])); ok(V_UNION(&values[0], bVal) == 12, "Read variant has unexpected value, V_UNION(&values[0])=%i\n", V_UNION(&values[0], bVal)); ok(V_UNION(&values[1], bVal) == 254, "Read variant has unexpected value, V_UNION(&values[1])=%i\n", V_UNION(&values[1], bVal)); ok(V_UNION(&values[2], bVal) == 254, "Read variant has unexpected value, V_UNION(&values[2])=%i\n", V_UNION(&values[2], bVal)); } }
static inline HRESULT handle_xml_load(BindStatusCallback *This) { static const WCHAR selectW[] = {'p','r','o','c','e','s','s','i','n','g','-', 'i','n','s','t','r','u','c','t','i','o','n','(','\'','x','m','l', '-','s','t','y','l','e','s','h','e','e','t','\'',')',0}; static const WCHAR hrefW[] = {'h','r','e','f','=',0}; IXMLDOMDocument3 *xml = NULL, *xsl = NULL; IXMLDOMNode *stylesheet; IBindCtx *pbc; IMoniker *mon; LPOLESTR xsl_url; LARGE_INTEGER off; VARIANT_BOOL succ; VARIANT var; WCHAR *href = NULL, *p; BSTR bstr; HRESULT hres; off.QuadPart = 0; hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL); if(FAILED(hres)) return display_error_page(This); hres = DOMDocument_create(MSXML_DEFAULT, (void**)&xml); if(FAILED(hres)) return display_error_page(This); V_VT(&var) = VT_UNKNOWN; V_UNKNOWN(&var) = (IUnknown*)This->stream; hres = IXMLDOMDocument3_load(xml, var, &succ); if(FAILED(hres) || !succ) { IXMLDOMDocument3_Release(xml); return display_error_page(This); } V_VT(&var) = VT_EMPTY; bstr = SysAllocString(selectW); hres = IXMLDOMDocument3_selectSingleNode(xml, bstr, &stylesheet); SysFreeString(bstr); if(hres != S_OK) { IXMLDOMDocument3_Release(xml); return display_error_page(This); } hres = IXMLDOMNode_get_nodeValue(stylesheet, &var); IXMLDOMNode_Release(stylesheet); if(SUCCEEDED(hres) && V_VT(&var)!=VT_BSTR) { FIXME("Variant type %d not supported\n", V_VT(&var)); VariantClear(&var); hres = E_FAIL; } if(FAILED(hres)) { IXMLDOMDocument3_Release(xml); return display_error_page(This); } /* TODO: fix parsing processing instruction value */ if((p = strstrW(V_BSTR(&var), hrefW))) { p += ARRAY_SIZE(hrefW) - 1; if(*p!='\'' && *p!='\"') p = NULL; else { href = p+1; p = strchrW(href, *p); } } if(p) { *p = 0; } else { VariantClear(&var); IXMLDOMDocument3_Release(xml); return display_error_page(This); } hres = CreateURLMonikerEx(This->mon, href, &mon, 0); VariantClear(&var); if(FAILED(hres)) { IXMLDOMDocument3_Release(xml); return display_error_page(This); } hres = CreateBindCtx(0, &pbc); if(SUCCEEDED(hres)) { hres = IMoniker_GetDisplayName(mon, pbc, NULL, &xsl_url); IMoniker_Release(mon); IBindCtx_Release(pbc); } if(FAILED(hres)) { IXMLDOMDocument3_Release(xml); return display_error_page(This); } V_VT(&var) = VT_BSTR; V_BSTR(&var) = SysAllocString(xsl_url); CoTaskMemFree(xsl_url); if(!V_BSTR(&var)) { IXMLDOMDocument3_Release(xml); return display_error_page(This); } hres = DOMDocument_create(MSXML_DEFAULT, (void**)&xsl); if(FAILED(hres)) { VariantClear(&var); IXMLDOMDocument3_Release(xml); return display_error_page(This); } /* TODO: do the binding asynchronously */ hres = IXMLDOMDocument3_load(xsl, var, &succ); VariantClear(&var); if(FAILED(hres) || !succ) { IXMLDOMDocument3_Release(xsl); IXMLDOMDocument3_Release(xml); return display_error_page(This); } hres = IXMLDOMDocument3_transformNode(xml, (IXMLDOMNode*)xsl, &bstr); IXMLDOMDocument3_Release(xsl); IXMLDOMDocument3_Release(xml); if(FAILED(hres)) return display_error_page(This); hres = IStream_Seek(This->stream, off, STREAM_SEEK_SET, NULL); if(FAILED(hres)) { SysFreeString(bstr); return display_error_page(This); } hres = IStream_Write(This->stream, (BYTE*)bstr, SysStringLen(bstr)*sizeof(WCHAR), NULL); SysFreeString(bstr); if(FAILED(hres)) return display_error_page(This); return report_data(This); }
int main(int argc, char* argv[]) { HRESULT hr; IADsContainer *pCont=NULL; CoInitialize(NULL); /////////////////////////////////// // Bind to the object ///////////////////////////////// hr = ADsGetObject(L"WinNT://INDEPENDENCE", IID_IADsContainer, (void**) &pCont ); if ( !SUCCEEDED(hr) ) { return hr; } /////////////////////////////////// // Build variant filter ///////////////////////////////// LPWSTR pszFilter[] = { L"user", L"group" }; DWORD dwNumber = sizeof( pszFilter ) /sizeof(LPWSTR); VARIANT var; hr = ADsBuildVarArrayStr( pszFilter, dwNumber, &var ); if ( !SUCCEEDED(hr) ) { pCont->Release(); return hr; } /////////////////////////////////// // Set the filter ///////////////////////////////// hr = pCont->put_Filter(var); VariantClear(&var); if (!SUCCEEDED(hr) ) { pCont->Release(); return hr; } //////////////////////////////////////////// // Enumerate the result /////////////////////////////////////////////// IEnumVARIANT *pEnum = NULL; hr = ADsBuildEnumerator( pCont, &pEnum ); pCont->Release(); // no longer needed, since we have the enumerator already if ( SUCCEEDED(hr) ) { VARIANT var; ULONG lFetch; IADs *pChild=NULL; VariantInit(&var); while( SUCCEEDED(ADsEnumerateNext( pEnum, 1, &var, &lFetch )) && lFetch == 1 ) { hr = V_DISPATCH(&var)->QueryInterface( IID_IADs, (void**) &pChild ); if ( SUCCEEDED(hr) ) { BSTR bstrName; BSTR bstrClass; // Get more information on the child classes pChild->get_Name(&bstrName); pChild->get_Class(&bstrClass); printf("%S\t\t(%S)\n", bstrName, bstrClass ); // Clean-up SysFreeString(bstrName); SysFreeString(bstrClass); pChild->Release(); } VariantClear(&var); } } if ( pEnum ) { ADsFreeEnumerator( pEnum ); } CoUninitialize(); return 0; }
static void test_font_events_disp(void) { static const WCHAR nameW[] = {'N','a','m','e',0}; static const WCHAR sizeW[] = {'S','i','z','e',0}; static const WCHAR boldW[] = {'B','o','l','d',0}; static const WCHAR italicW[] = {'I','t','a','l','i','c',0}; static const WCHAR underlineW[] = {'U','n','d','e','r','l','i','n','e',0}; static const WCHAR strikeW[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0}; static const WCHAR weightW[] = {'W','e','i','g','h','t',0}; static const WCHAR charsetW[] = {'C','h','a','r','s','e','t',0}; static const struct font_dispid font_dispids[] = { { DISPID_FONT_NAME, nameW }, { DISPID_FONT_SIZE, sizeW }, { DISPID_FONT_BOLD, boldW }, { DISPID_FONT_ITALIC, italicW }, { DISPID_FONT_UNDER, underlineW }, { DISPID_FONT_STRIKE, strikeW }, { DISPID_FONT_WEIGHT, weightW }, { DISPID_FONT_CHARSET, charsetW } }; IFont *pFont; IFont *pFont2; IConnectionPointContainer *pCPC; IConnectionPoint *pCP; FONTDESC fontdesc; HRESULT hr; DWORD dwCookie; IFontDisp *pFontDisp; DISPPARAMS dispparams; VARIANTARG vararg; INT i; fontdesc.cbSizeofstruct = sizeof(fontdesc); fontdesc.lpstrName = MSSansSerif_font; fontdesc.cySize.int64 = 12 * 10000; /* 12 pt */ fontdesc.sWeight = FW_NORMAL; fontdesc.sCharset = 0; fontdesc.fItalic = FALSE; fontdesc.fUnderline = FALSE; fontdesc.fStrikethrough = FALSE; hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&pFont); EXPECT_HR(hr, S_OK); hr = IFont_QueryInterface(pFont, &IID_IConnectionPointContainer, (void **)&pCPC); EXPECT_HR(hr, S_OK); hr = IConnectionPointContainer_FindConnectionPoint(pCPC, &IID_IFontEventsDisp, &pCP); EXPECT_HR(hr, S_OK); IConnectionPointContainer_Release(pCPC); hr = IConnectionPoint_Advise(pCP, (IUnknown *)&FontEventsDisp, &dwCookie); EXPECT_HR(hr, S_OK); IConnectionPoint_Release(pCP); fonteventsdisp_invoke_called = 0; fonteventsdisp_invoke_arg0 = NULL; hr = IFont_put_Bold(pFont, TRUE); EXPECT_HR(hr, S_OK); ok(fonteventsdisp_invoke_called == 1, "IFontEventDisp::Invoke wasn't called once\n"); SysFreeString(fonteventsdisp_invoke_arg0); hr = IFont_QueryInterface(pFont, &IID_IFontDisp, (void **)&pFontDisp); EXPECT_HR(hr, S_OK); for (i = 0; i < ARRAY_SIZE(font_dispids); i++) { switch (font_dispids[i].dispid) { case DISPID_FONT_NAME: { static const WCHAR arialW[] = {'A','r','i','a','l',0}; V_VT(&vararg) = VT_BSTR; V_BSTR(&vararg) = SysAllocString(arialW); break; } case DISPID_FONT_SIZE: V_VT(&vararg) = VT_CY; S(V_CY(&vararg)).Lo = 25; S(V_CY(&vararg)).Hi = 0; break; case DISPID_FONT_BOLD: V_VT(&vararg) = VT_BOOL; V_BOOL(&vararg) = VARIANT_FALSE; break; case DISPID_FONT_ITALIC: case DISPID_FONT_UNDER: case DISPID_FONT_STRIKE: V_VT(&vararg) = VT_BOOL; V_BOOL(&vararg) = VARIANT_TRUE; break; case DISPID_FONT_WEIGHT: V_VT(&vararg) = VT_I2; V_I2(&vararg) = FW_BLACK; break; case DISPID_FONT_CHARSET: V_VT(&vararg) = VT_I2; V_I2(&vararg) = 1; break; default: ; } dispparams.cNamedArgs = 0; dispparams.rgdispidNamedArgs = NULL; dispparams.cArgs = 1; dispparams.rgvarg = &vararg; fonteventsdisp_invoke_called = 0; hr = IFontDisp_Invoke(pFontDisp, font_dispids[i].dispid, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL); ok(hr == S_OK, "dispid=%d, got 0x%08x\n", font_dispids[i].dispid, hr); ok(fonteventsdisp_invoke_called == 1, "dispid=%d, DISPID_FONT_CHANGED not called, got %d\n", font_dispids[i].dispid, fonteventsdisp_invoke_called); if (hr == S_OK) { ok(!lstrcmpW(font_dispids[i].name, fonteventsdisp_invoke_arg0), "dispid=%d, got %s, expected %s\n", font_dispids[i].dispid, wine_dbgstr_w(fonteventsdisp_invoke_arg0), wine_dbgstr_w(font_dispids[i].name)); SysFreeString(fonteventsdisp_invoke_arg0); } VariantClear(&vararg); } IFontDisp_Release(pFontDisp); hr = IFont_Clone(pFont, &pFont2); EXPECT_HR(hr, S_OK); IFont_Release(pFont); /* this test shows that the notification routine isn't called again */ fonteventsdisp_invoke_called = 0; hr = IFont_put_Bold(pFont2, FALSE); EXPECT_HR(hr, S_OK); ok(fonteventsdisp_invoke_called == 0, "got %d\n", fonteventsdisp_invoke_called); IFont_Release(pFont2); }
//---------------------------------------------------------------------------- // // GetDeletedObjectsContainer() // // Binds to the Deleted Object container. // //---------------------------------------------------------------------------- HRESULT GetDeletedObjectsContainer(IADsContainer **ppContainer) { if(NULL == ppContainer) { return E_INVALIDARG; } HRESULT hr; IADs *pRoot; *ppContainer = NULL; // Bind to the rootDSE object. hr = ADsOpenObject(L"LDAP://rootDSE", NULL, NULL, ADS_SECURE_AUTHENTICATION, IID_IADs, (LPVOID*)&pRoot); if(SUCCEEDED(hr)) { VARIANT var; VariantInit(&var); // Get the current domain DN. hr = pRoot->Get(L"defaultNamingContext", &var); if(SUCCEEDED(hr)) { // Build the binding string. LPWSTR pwszFormat = L"LDAP://<WKGUID=%s,%s>"; LPWSTR pwszPath; pwszPath = new WCHAR[wcslen(pwszFormat) + wcslen(GUID_DELETED_OBJECTS_CONTAINER_W) + wcslen(var.bstrVal)]; if(NULL != pwszPath) { swprintf(pwszPath, pwszFormat, GUID_DELETED_OBJECTS_CONTAINER_W, var.bstrVal); // Bind to the object. hr = ADsOpenObject(pwszPath, NULL, NULL, ADS_FAST_BIND | ADS_SECURE_AUTHENTICATION, IID_IADsContainer, (LPVOID*)ppContainer); delete pwszPath; } else { hr = E_OUTOFMEMORY; } VariantClear(&var); } pRoot->Release(); } return hr; }
int _tmain(int argc, _TCHAR* argv[]) { //BSTR的使用 { BSTR bstrA = SysAllocString(L"Hello BSTR"); BSTR bstrB = SysAllocStringLen(bstrA, SysStringLen(bstrA)); SysFreeString(bstrA); SysFreeString(bstrB); } //用VARIANT保存LONG { VARIANT var; VariantInit(&var); var.vt = VT_I4; var.lVal = 100; VariantClear(&var); int i = 0; i++; } //用VARIANT保存FLOAT { VARIANT var; VariantInit(&var); var.vt = VT_R4; var.fltVal = 1.23f; VariantClear(&var); } //用VARIANT保存BSTR { VARIANT var; VariantInit(&var); var.vt = VT_BSTR; var.bstrVal = SysAllocString(L"Hello World"); VariantClear(&var); } //用VARIANT保存布尔类型 { VARIANT var; VariantInit(&var); var.vt = VT_BOOL; var.boolVal = VARIANT_FALSE; VariantClear(&var); } //从VARIANT读取相应类型的值 { VARIANT var; VariantInit(&var); var.vt = VT_I4; var.lVal = 100; if (var.vt == VT_I4) { LONG lValue = var.lVal; } else if (var.vt == VT_R4) { FLOAT fValue = var.fltVal; } else if (var.vt == VT_BSTR) { BSTR bstrValue = var.bstrVal; } else if (var.vt == VT_BOOL) { VARIANT_BOOL varbValue = var.boolVal; } VariantClear(&var); } //COM数据类型的转换,LONG转成FLOAT { VARIANT var; VariantInit(&var); var.vt = VT_I4; var.lVal = 100; VariantChangeType(&var,&var,0, VT_R4); if (var.vt == VT_R4) { FLOAT fValue = var.fltVal; } VariantClear(&var); } //COM数据类型的转换,LONG转成BSTR { VARIANT var; VariantInit(&var); var.vt = VT_I4; var.lVal = 100; VariantChangeType(&var,&var,0, VT_BSTR); if (var.vt == VT_BSTR) { BSTR fValue = var.bstrVal; } VariantClear(&var); } //CComVariant的构造方法 { VARIANT varA; CComVariant varB; CComVariant varC(varA); CComVariant varD(varB); CComVariant varE(L"Hello CComVariant"); CComVariant varF("CComVariant"); CComVariant varG(true); CComVariant varH(100L); CComVariant varI(1.23f); //.... } //CComVariant的赋值方法 { VARIANT varA; CComVariant varB; CComVariant varC; varC = varA; varC = varB; varC = true; varC = 100L; varC = 1.23f; varC = L"Hello CComVariant"; varC = "Hello CComVariant"; //.... } //CComVariant与VARIANT的关联 { VARIANT varA; VariantInit(&varA); varA.vt = VT_I4; varA.lVal = 100; CComVariant varB; CComVariant varC(100L); VARIANT varD; VariantInit(&varD); //Attach varB.Attach(&varA); //之后无需调用VariantClear(&varA); //Detach varC.Detach(&varD); VariantClear(&varD); //需要调用VariantClear(&varD); } return 0; }
int main(int argc, char **argv) { // Capture settings int snapshot_delay = 2000; int show_preview_window = 0; int list_devices = 0; int device_number = 1; char device_name[100]; char filename[100]; // Other variables char char_buffer[100]; // Default device name and output filename strcpy(device_name, ""); strcpy(filename, "image.bmp"); // Information message fprintf(stderr, "\n"); fprintf(stderr, "CommandCam Copyright (C) 2012 Ted Burke\n"); fprintf(stderr, "This program comes with ABSOLUTELY NO WARRANTY;\n"); fprintf(stderr, "This is free software, and you are welcome to\n"); fprintf(stderr, "redistribute it under certain conditions;\n"); fprintf(stderr, "See the GNU General Public License v3,\n"); fprintf(stderr, "<http://www.gnu.org/licenses/gpl.txt>\n"); fprintf(stderr, "\n"); fprintf(stderr, "http://batchloaf.wordpress.com\n"); fprintf(stderr, "This version 21-4-2012\n"); fprintf(stderr, "\n"); // Parse command line arguments. Available options: // // /delay DELAY_IN_MILLISECONDS // /filename OUTPUT_FILENAME // /devnum DEVICE_NUMBER // /devname DEVICE_NAME // /preview // /devlist // int n = 1; while (n < argc) { // Process next command line argument if (strcmp(argv[n], "/preview") == 0) { // Enable preview window show_preview_window = 1; } else if (strcmp(argv[n], "/devlist") == 0) { // Set flag to list devices rather than capture image list_devices = 1; } else if (strcmp(argv[n], "/filename") == 0) { // Set output filename to specified string if (++n < argc) //strcpy(filename, argv[n]); { // Copy provided string into char buffer strcpy(char_buffer, argv[n]); // Trim inverted commas if present and copy // provided string into filename char array if (char_buffer[0] == '"') { strncat(filename, char_buffer, strlen(char_buffer)-2); } else { strcpy(filename, char_buffer); } } else exit_message("Error: no filename specified", 1); } else if (strcmp(argv[n], "/delay") == 0) { // Set snapshot delay to specified value if (++n < argc) snapshot_delay = atoi(argv[n]); else exit_message("Error: invalid delay specified", 1); if (snapshot_delay <= 0) exit_message("Error: invalid delay specified", 1); } else if (strcmp(argv[n], "/devnum") == 0) { // Set device number to specified value if (++n < argc) device_number = atoi(argv[n]); else exit_message("Error: invalid device number", 1); if (device_number <= 0) exit_message("Error: invalid device number", 1); } else if (strcmp(argv[n], "/devname") == 0) { // Set device number to specified value if (++n < argc) { // Copy device name into char buffer strcpy(char_buffer, argv[n]); // Trim inverted commas if present and copy // provided string into device_name if (char_buffer[0] == '"') { strncat(device_name, char_buffer, strlen(char_buffer)-2); } else { strcpy(device_name, char_buffer); } // Remember to choose by name rather than number device_number = 0; } else exit_message("Error: invalid device name", 1); } else { // Unknown command line argument fprintf(stderr, "Unrecognised option: %s\n", argv[n]); exit_message("", 1); } // Increment command line argument counter n++; } // Intialise COM hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); if (hr != S_OK) exit_message("Could not initialise COM", 1); // Create filter graph hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER, IID_IGraphBuilder, (void**)&pGraph); if (hr != S_OK) exit_message("Could not create filter graph", 1); // Create capture graph builder. hr = CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER, IID_ICaptureGraphBuilder2, (void **)&pBuilder); if (hr != S_OK) exit_message("Could not create capture graph builder", 1); // Attach capture graph builder to graph hr = pBuilder->SetFiltergraph(pGraph); if (hr != S_OK) exit_message("Could not attach capture graph builder to graph", 1); // Create system device enumerator hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pDevEnum)); if (hr != S_OK) exit_message("Could not crerate system device enumerator", 1); // Video input device enumerator hr = pDevEnum->CreateClassEnumerator( CLSID_VideoInputDeviceCategory, &pEnum, 0); if (hr != S_OK) exit_message("No video devices found", 1); // If the user has included the "/list" command line // argument, just list available devices, then exit. if (list_devices != 0) { fprintf(stderr, "Available capture devices:\n"); n = 0; while(1) { // Find next device hr = pEnum->Next(1, &pMoniker, NULL); if (hr == S_OK) { // Increment device counter n++; // Get device name hr = pMoniker->BindToStorage(0, 0, IID_PPV_ARGS(&pPropBag)); VARIANT var; VariantInit(&var); hr = pPropBag->Read(L"FriendlyName", &var, 0); fprintf(stderr, " %d. %ls\n", n, var.bstrVal); VariantClear(&var); } else { // Finished listing device, so exit program if (n == 0) exit_message("No devices found", 0); else exit_message("", 0); } } } // Get moniker for specified video input device, // or for the first device if no device number // was specified. VARIANT var; n = 0; while(1) { // Access next device hr = pEnum->Next(1, &pMoniker, NULL); if (hr == S_OK) { n++; // increment device count } else { if (device_number == 0) { fprintf(stderr, "Video capture device %s not found\n", device_name); } else { fprintf(stderr, "Video capture device %d not found\n", device_number); } exit_message("", 1); } // If device was specified by name rather than number... if (device_number == 0) { // Get video input device name hr = pMoniker->BindToStorage(0, 0, IID_PPV_ARGS(&pPropBag)); if (hr == S_OK) { // Get current device name VariantInit(&var); hr = pPropBag->Read(L"FriendlyName", &var, 0); // Convert to a normal C string, i.e. char* sprintf(char_buffer, "%ls", var.bstrVal); VariantClear(&var); pPropBag->Release(); pPropBag = NULL; // Exit loop if current device name matched devname if (strcmp(device_name, char_buffer) == 0) break; } else { exit_message("Error getting device names", 1); } } else if (n >= device_number) break; } // Get video input device name hr = pMoniker->BindToStorage(0, 0, IID_PPV_ARGS(&pPropBag)); VariantInit(&var); hr = pPropBag->Read(L"FriendlyName", &var, 0); fprintf(stderr, "Capture device: %ls\n", var.bstrVal); VariantClear(&var); // Create capture filter and add to graph hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&pCap); if (hr != S_OK) exit_message("Could not create capture filter", 1); // Add capture filter to graph hr = pGraph->AddFilter(pCap, L"Capture Filter"); if (hr != S_OK) exit_message("Could not add capture filter to graph", 1); // Create sample grabber filter hr = CoCreateInstance(CLSID_SampleGrabber, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)&pSampleGrabberFilter); if (hr != S_OK) exit_message("Could not create Sample Grabber filter", 1); // Query the ISampleGrabber interface of the sample grabber filter hr = pSampleGrabberFilter->QueryInterface( DexterLib::IID_ISampleGrabber, (void**)&pSampleGrabber); if (hr != S_OK) exit_message("Could not get ISampleGrabber interface to sample grabber filter", 1); // Enable sample buffering in the sample grabber filter hr = pSampleGrabber->SetBufferSamples(TRUE); if (hr != S_OK) exit_message("Could not enable sample buffering in the sample grabber", 1); // Set media type in sample grabber filter AM_MEDIA_TYPE mt; ZeroMemory(&mt, sizeof(AM_MEDIA_TYPE)); mt.majortype = MEDIATYPE_Video; mt.subtype = MEDIASUBTYPE_RGB24; hr = pSampleGrabber->SetMediaType((DexterLib::_AMMediaType *)&mt); if (hr != S_OK) exit_message("Could not set media type in sample grabber", 1); // Add sample grabber filter to filter graph hr = pGraph->AddFilter(pSampleGrabberFilter, L"SampleGrab"); if (hr != S_OK) exit_message("Could not add Sample Grabber to filter graph", 1); // Create Null Renderer filter hr = CoCreateInstance(CLSID_NullRenderer, NULL, CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)&pNullRenderer); if (hr != S_OK) exit_message("Could not create Null Renderer filter", 1); // Add Null Renderer filter to filter graph hr = pGraph->AddFilter(pNullRenderer, L"NullRender"); if (hr != S_OK) exit_message("Could not add Null Renderer to filter graph", 1); // Connect up the filter graph's capture stream hr = pBuilder->RenderStream( &PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, pCap, pSampleGrabberFilter, pNullRenderer); if (hr != S_OK) exit_message("Could not render capture video stream", 1); // Connect up the filter graph's preview stream if (show_preview_window > 0) { hr = pBuilder->RenderStream( &PIN_CATEGORY_PREVIEW, &MEDIATYPE_Video, pCap, NULL, NULL); if (hr != S_OK && hr != VFW_S_NOPREVIEWPIN) exit_message("Could not render preview video stream", 1); } // Get media control interfaces to graph builder object hr = pGraph->QueryInterface(IID_IMediaControl, (void**)&pMediaControl); if (hr != S_OK) exit_message("Could not get media control interface", 1); // Run graph while(1) { hr = pMediaControl->Run(); // Hopefully, the return value was S_OK or S_FALSE if (hr == S_OK) break; // graph is now running if (hr == S_FALSE) continue; // graph still preparing to run // If the Run function returned something else, // there must be a problem fprintf(stderr, "Error: %u\n", hr); exit_message("Could not run filter graph", 1); } // Wait for specified time delay (if any) Sleep(snapshot_delay); // Grab a sample // First, find the required buffer size long buffer_size = 0; while(1) { // Passing in a NULL pointer signals that we're just checking // the required buffer size; not looking for actual data yet. hr = pSampleGrabber->GetCurrentBuffer(&buffer_size, NULL); // Keep trying until buffer_size is set to non-zero value. if (hr == S_OK && buffer_size != 0) break; // If the return value isn't S_OK or VFW_E_WRONG_STATE // then something has gone wrong. VFW_E_WRONG_STATE just // means that the filter graph is still starting up and // no data has arrived yet in the sample grabber filter. if (hr != S_OK && hr != VFW_E_WRONG_STATE) exit_message("Could not get buffer size", 1); } // Stop the graph pMediaControl->Stop(); // Allocate buffer for image pBuffer = new char[buffer_size]; if (!pBuffer) exit_message("Could not allocate data buffer for image", 1); // Retrieve image data from sample grabber buffer hr = pSampleGrabber->GetCurrentBuffer( &buffer_size, (long*)pBuffer); if (hr != S_OK) exit_message("Could not get buffer data from sample grabber", 1); // Get the media type from the sample grabber filter hr = pSampleGrabber->GetConnectedMediaType( (DexterLib::_AMMediaType *)&mt); if (hr != S_OK) exit_message("Could not get media type", 1); // Retrieve format information VIDEOINFOHEADER *pVih = NULL; if ((mt.formattype == FORMAT_VideoInfo) && (mt.cbFormat >= sizeof(VIDEOINFOHEADER)) && (mt.pbFormat != NULL)) { // Get video info header structure from media type pVih = (VIDEOINFOHEADER*)mt.pbFormat; // Print the resolution of the captured image fprintf(stderr, "Capture resolution: %dx%d\n", pVih->bmiHeader.biWidth, pVih->bmiHeader.biHeight); // Create bitmap structure long cbBitmapInfoSize = mt.cbFormat - SIZE_PREHEADER; BITMAPFILEHEADER bfh; ZeroMemory(&bfh, sizeof(bfh)); bfh.bfType = 'MB'; // Little-endian for "BM". bfh.bfSize = sizeof(bfh) + buffer_size + cbBitmapInfoSize; bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + cbBitmapInfoSize; // Open output file HANDLE hf = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, NULL); if (hf == INVALID_HANDLE_VALUE) exit_message("Error opening output file", 1); // Write the file header. DWORD dwWritten = 0; WriteFile(hf, &bfh, sizeof(bfh), &dwWritten, NULL); WriteFile(hf, HEADER(pVih), cbBitmapInfoSize, &dwWritten, NULL); // Write pixel data to file WriteFile(hf, pBuffer, buffer_size, &dwWritten, NULL); CloseHandle(hf); } else { exit_message("Wrong media type", 1); } // Free the format block if (mt.cbFormat != 0) { CoTaskMemFree((PVOID)mt.pbFormat); mt.cbFormat = 0; mt.pbFormat = NULL; } if (mt.pUnk != NULL) { // pUnk should not be used. mt.pUnk->Release(); mt.pUnk = NULL; } // Clean up and exit fprintf(stderr, "Captured image to %s", filename); exit_message("", 0); }
HRESULT GetVideoMemoryViaWMI( WCHAR* strInputDeviceID, DWORD* pdwAdapterRam ) { HRESULT hr; bool bGotMemory = false; HRESULT hrCoInitialize = S_OK; IWbemLocator* pIWbemLocator = nullptr; IWbemServices* pIWbemServices = nullptr; BSTR pNamespace = nullptr; *pdwAdapterRam = 0; hrCoInitialize = CoInitialize( 0 ); hr = CoCreateInstance( CLSID_WbemLocator, nullptr, CLSCTX_INPROC_SERVER, IID_IWbemLocator, ( LPVOID* )&pIWbemLocator ); #ifdef PRINTF_DEBUGGING if( FAILED( hr ) ) wprintf( L"WMI: CoCreateInstance failed: 0x%0.8x\n", hr ); #endif if( SUCCEEDED( hr ) && pIWbemLocator ) { // Using the locator, connect to WMI in the given namespace. pNamespace = SysAllocString( L"\\\\.\\root\\cimv2" ); hr = pIWbemLocator->ConnectServer( pNamespace, nullptr, nullptr, 0L, 0L, nullptr, nullptr, &pIWbemServices ); #ifdef PRINTF_DEBUGGING if( FAILED( hr ) ) wprintf( L"WMI: pIWbemLocator->ConnectServer failed: 0x%0.8x\n", hr ); #endif if( SUCCEEDED( hr ) && pIWbemServices != 0 ) { HINSTANCE hinstOle32 = nullptr; hinstOle32 = LoadLibraryW( L"ole32.dll" ); if( hinstOle32 ) { PfnCoSetProxyBlanket pfnCoSetProxyBlanket = nullptr; pfnCoSetProxyBlanket = ( PfnCoSetProxyBlanket )GetProcAddress( hinstOle32, "CoSetProxyBlanket" ); if( pfnCoSetProxyBlanket != 0 ) { // Switch security level to IMPERSONATE. pfnCoSetProxyBlanket( pIWbemServices, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, 0 ); } FreeLibrary( hinstOle32 ); } IEnumWbemClassObject* pEnumVideoControllers = nullptr; BSTR pClassName = nullptr; pClassName = SysAllocString( L"Win32_VideoController" ); hr = pIWbemServices->CreateInstanceEnum( pClassName, 0, nullptr, &pEnumVideoControllers ); #ifdef PRINTF_DEBUGGING if( FAILED( hr ) ) wprintf( L"WMI: pIWbemServices->CreateInstanceEnum failed: 0x%0.8x\n", hr ); #endif if( SUCCEEDED( hr ) && pEnumVideoControllers ) { IWbemClassObject* pVideoControllers[10] = {0}; DWORD uReturned = 0; BSTR pPropName = nullptr; // Get the first one in the list pEnumVideoControllers->Reset(); hr = pEnumVideoControllers->Next( 5000, // timeout in 5 seconds 10, // return the first 10 pVideoControllers, &uReturned ); #ifdef PRINTF_DEBUGGING if( FAILED( hr ) ) wprintf( L"WMI: pEnumVideoControllers->Next failed: 0x%0.8x\n", hr ); if( uReturned == 0 ) wprintf( L"WMI: pEnumVideoControllers uReturned == 0\n" ); #endif VARIANT var; if( SUCCEEDED( hr ) ) { bool bFound = false; for( UINT iController = 0; iController < uReturned; iController++ ) { if ( !pVideoControllers[iController] ) continue; pPropName = SysAllocString( L"PNPDeviceID" ); hr = pVideoControllers[iController]->Get( pPropName, 0L, &var, nullptr, nullptr ); #ifdef PRINTF_DEBUGGING if( FAILED( hr ) ) wprintf( L"WMI: pVideoControllers[iController]->Get PNPDeviceID failed: 0x%0.8x\n", hr ); #endif if( SUCCEEDED( hr ) ) { if( wcsstr( var.bstrVal, strInputDeviceID ) != 0 ) bFound = true; } VariantClear( &var ); if( pPropName ) SysFreeString( pPropName ); if( bFound ) { pPropName = SysAllocString( L"AdapterRAM" ); hr = pVideoControllers[iController]->Get( pPropName, 0L, &var, nullptr, nullptr ); #ifdef PRINTF_DEBUGGING if( FAILED( hr ) ) wprintf( L"WMI: pVideoControllers[iController]->Get AdapterRAM failed: 0x%0.8x\n", hr ); #endif if( SUCCEEDED( hr ) ) { bGotMemory = true; *pdwAdapterRam = var.ulVal; } VariantClear( &var ); if( pPropName ) SysFreeString( pPropName ); break; } SAFE_RELEASE( pVideoControllers[iController] ); } } SAFE_RELEASE(pEnumVideoControllers); } if( pClassName ) SysFreeString( pClassName ); } if( pNamespace ) SysFreeString( pNamespace ); SAFE_RELEASE( pIWbemServices ); } SAFE_RELEASE( pIWbemLocator ); if( SUCCEEDED( hrCoInitialize ) ) CoUninitialize(); if( bGotMemory ) return S_OK; else return E_FAIL; }
MYEXPORT long MYWINAPI DisplayHTMLPage(HWND hwnd, LPCTSTR webPageName) { IWebBrowser2 *webBrowser2; VARIANT myURL; IOleObject *browserObject; // Retrieve the browser object's pointer we stored in our window's GWL_USERDATA when // we initially attached the browser object to this window. browserObject = *((IOleObject **)GetWindowLongPtr(hwnd, GWLP_USERDATA)); // We want to get the base address (ie, a pointer) to the IWebBrowser2 object embedded within the browser // object, so we can call some of the functions in the former's table. if (!browserObject->lpVtbl->QueryInterface(browserObject, &IID_IWebBrowser2, (void**)&webBrowser2)) { // Ok, now the pointer to our IWebBrowser2 object is in 'webBrowser2', and so its VTable is // webBrowser2->lpVtbl. // Our URL (ie, web address, such as "http://www.microsoft.com" or an HTM filename on disk // such as "c:\myfile.htm") must be passed to the IWebBrowser2's Navigate2() function as a BSTR. // A BSTR is like a pascal version of a double-byte character string. In other words, the // first unsigned short is a count of how many characters are in the string, and then this // is followed by those characters, each expressed as an unsigned short (rather than a // char). The string is not nul-terminated. The OS function SysAllocString can allocate and // copy a UNICODE C string to a BSTR. Of course, we'll need to free that BSTR after we're done // with it. If we're not using UNICODE, we first have to convert to a UNICODE string. // // What's more, our BSTR needs to be stuffed into a VARIENT struct, and that VARIENT struct is // then passed to Navigate2(). Why? The VARIENT struct makes it possible to define generic // 'datatypes' that can be used with all languages. Not all languages support things like // nul-terminated C strings. So, by using a VARIENT, whose first field tells what sort of // data (ie, string, float, etc) is in the VARIENT, COM interfaces can be used by just about // any language. VariantInit(&myURL); myURL.vt = VT_BSTR; #ifndef UNICODE { wchar_t *buffer; DWORD size; size = MultiByteToWideChar(CP_ACP, 0, webPageName, -1, 0, 0); if (!(buffer = (wchar_t *)GlobalAlloc(GMEM_FIXED, sizeof(wchar_t) * size))) goto badalloc; MultiByteToWideChar(CP_ACP, 0, webPageName, -1, buffer, size); myURL.bstrVal = SysAllocString(buffer); GlobalFree(buffer); } #else myURL.bstrVal = SysAllocString(webPageName); #endif if (!myURL.bstrVal) { badalloc: webBrowser2->lpVtbl->Release(webBrowser2); return(-6); } // Call the Navigate2() function to actually display the page. webBrowser2->lpVtbl->Navigate2(webBrowser2, &myURL, 0, 0, 0, 0); // Free any resources (including the BSTR we allocated above). VariantClear(&myURL); // We no longer need the IWebBrowser2 object (ie, we don't plan to call any more functions in it, // so we can release our hold on it). Note that we'll still maintain our hold on the browser // object. webBrowser2->lpVtbl->Release(webBrowser2); // Success return(0); } return(-5); }
bool IsICSConnEnabled() { HRESULT hr = S_OK; hr = CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT, RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, NULL); if(hr != S_OK && hr != RPC_E_TOO_LATE) return false; long pubconns = 0; long prvconns = 0; bool pubactive = false; bool prvactive = false; INetSharingManager *csmgr = NULL; hr = CoCreateInstance(CLSID_NetSharingManager, NULL, CLSCTX_INPROC_SERVER, IID_INetSharingManager, (LPVOID*)&csmgr); if(SUCCEEDED(hr)) { VARIANT_BOOL isinstalled = FALSE; csmgr->get_SharingInstalled(&isinstalled); if(isinstalled) { ULONG lfetched = 0; IUnknown *ienum = NULL; VARIANT vconn; INetConnection *iconn = NULL; INetSharingPublicConnectionCollection *ipubcol = NULL; hr = csmgr->get_EnumPublicConnections(ICSSC_DEFAULT, &ipubcol); if(SUCCEEDED(hr)) { if(ipubcol->get_Count(&pubconns) == S_OK && pubconns > 0) { if(ipubcol->get__NewEnum(&ienum) == S_OK) { IEnumNetSharingPublicConnection *ipubs = NULL; hr = ienum->QueryInterface(IID_IEnumNetSharingPublicConnection, (void**)&ipubs); if(SUCCEEDED(hr)) { VariantInit(&vconn); ipubs->Reset(); while(ipubs->Next(1, &vconn, &lfetched) == S_OK) { pubactive = true; iconn = NULL; iconn = (INetConnection*)vconn.punkVal; VariantClear(&vconn); } ipubs->Release(); } ienum->Release(); ienum = NULL; } } ipubcol->Release(); } INetSharingPrivateConnectionCollection *iprvcol = NULL; hr = csmgr->get_EnumPrivateConnections(ICSSC_DEFAULT, &iprvcol); if(SUCCEEDED(hr)) { if(iprvcol->get_Count(&prvconns) == S_OK && prvconns > 0) { if(iprvcol->get__NewEnum(&ienum) == S_OK) { IEnumNetSharingPrivateConnection *iprvs = NULL; hr = ienum->QueryInterface(IID_IEnumNetSharingPrivateConnection, (void**)&iprvs); if(SUCCEEDED(hr)) { VariantInit(&vconn); iprvs->Reset(); while(iprvs->Next(1, &vconn, &lfetched) == S_OK) { prvactive = true; iconn = NULL; iconn = (INetConnection*)vconn.punkVal; VariantClear(&vconn); } iprvs->Release(); } ienum->Release(); ienum = NULL; } } iprvcol->Release(); } } csmgr->Release(); } return (pubconns & prvconns) && (pubactive & prvactive); }
///////////////////////////////////////////////////////// // Demonstrate: // IADsPropertyList::GetPropertyItem // IADsPropertyEntry // void CDlgIADsPropertyList::OnGet() { HRESULT hr; CString s; BSTR bstr; VARIANT var; IDispatch *pDispatch; IADsPropertyEntry *pEntry; IADsPropertyValue *pValue; LONG lADsType; UpdateData(TRUE); m_cValueList.ResetContent(); bstr = m_sAttribute.AllocSysString(); hr = m_pPropList->GetPropertyItem( bstr, m_cADsType.GetCurSel()+1, &var ); SysFreeString( bstr ); if ( SUCCEEDED(hr) ) { pDispatch = V_DISPATCH( &var ); hr = pDispatch->QueryInterface( IID_IADsPropertyEntry, (void**) &pEntry ); VariantClear( &var ); // IADsPropertyEntry if ( SUCCEEDED(hr) ) { CPtrList dList; // get_Values return array of VT_DISPATH hr = pEntry->get_Values( &var ); pEntry->get_ADsType( &lADsType); hr = VariantToPtrList( var, dList ); pEntry->Release(); //////////////////////////// // IADsPropertyValue ///////////////////////////// if ( SUCCEEDED(hr) ) { POSITION pos; pos = dList.GetHeadPosition(); while ( pos != NULL ) { pDispatch = (IDispatch*) dList.GetAt(pos); hr = pDispatch->QueryInterface( IID_IADsPropertyValue, (void**) &pValue ); if ( SUCCEEDED(hr) ) { pValue->AddRef(); hr = PropertyValueToString( lADsType, pValue, s ); m_cValueList.AddString( s ); pValue->Release(); } dList.GetNext(pos); } } dList.RemoveAll(); VariantClear(&var); } } }
static void test_ITextDocument_Open(void) { IRichEditOle *reOle = NULL; ITextDocument *txtDoc = NULL; ITextSelection *txtSel = NULL; HRESULT hres; HWND w; HANDLE hFile; VARIANT testfile; WCHAR filename[] = {'t', 'e', 's', 't','.','t','x','t', 0}; int result; DWORD dw; static const CHAR chACP[] = "TestSomeText"; static const CHAR chUTF8[] = "\xef\xbb\xbfTextWithUTF8BOM"; static const WCHAR chUTF16[] = {0xfeff, 'T', 'e', 's', 't', 'S', 'o', 'm', 'e', 'T', 'e', 'x', 't', 0}; #define MAX_BUF_LEN 1024 CHAR bufACP[MAX_BUF_LEN]; WCHAR bufUnicode[MAX_BUF_LEN]; static const int tomConstantsSingle[] = { tomReadOnly, tomShareDenyRead, tomShareDenyWrite, tomCreateAlways, tomOpenExisting, tomOpenAlways, tomTruncateExisting, tomRTF, tomText }; static const int tomConstantsMulti[] = { tomReadOnly|tomShareDenyRead|tomPasteFile, tomReadOnly|tomPasteFile, tomReadOnly|tomShareDenyWrite|tomPasteFile, tomReadOnly|tomShareDenyRead|tomShareDenyWrite|tomPasteFile, tomShareDenyWrite|tomPasteFile, tomShareDenyRead|tomShareDenyWrite|tomPasteFile, tomShareDenyRead|tomPasteFile, tomShareDenyRead|tomShareDenyWrite, tomReadOnly|tomShareDenyRead|tomShareDenyWrite, tomReadOnly|tomShareDenyWrite, tomReadOnly|tomShareDenyRead }; int tomNumSingle = sizeof(tomConstantsSingle)/sizeof(tomConstantsSingle[0]); int tomNumMulti = sizeof(tomConstantsMulti)/sizeof(tomConstantsMulti[0]); int i; V_VT(&testfile) = VT_BSTR; V_BSTR(&testfile) = SysAllocString(filename); for(i=0; i < tomNumSingle; i++) { touch_file(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomConstantsSingle[i], CP_ACP); todo_wine ok(hres == S_OK, "ITextDocument_Open: Filename:test.txt Flags:0x%x Codepage:CP_ACP hres:0x%x\n", tomConstantsSingle[i], hres); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); touch_file(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomConstantsSingle[i], CP_UTF8); todo_wine ok(hres == S_OK, "ITextDocument_Open: Filename:test.txt Flags:0x%x Codepage:CP_UTF8 hres:0x%x\n", tomConstantsSingle[i], hres); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); } for(i=0; i < tomNumMulti; i++) { touch_file(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomConstantsMulti[i], CP_ACP); todo_wine ok(hres == S_OK, "ITextDocument_Open: Filename:test.txt Flags:0x%x Codepage:CP_ACP hres:0x%x\n", tomConstantsMulti[i], hres); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); touch_file(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomConstantsMulti[i], CP_UTF8); todo_wine ok(hres == S_OK, "ITextDocument_Open: Filename:test.txt Flags:0x%x Codepage:CP_UTF8 hres:0x%x\n", tomConstantsMulti[i], hres); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); } create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomCreateAlways, CP_ACP); todo_wine ok(hres == S_OK, "ITextDocument_Open should success Codepage:CP_ACP\n"); todo_wine ok(is_existing_file(filename), "ITextDocument_Open should create a file\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomCreateAlways, CP_UTF8); todo_wine ok(hres == S_OK, "ITextDocument_Open should success Codepage:CP_UTF8\n"); todo_wine ok(is_existing_file(filename), "ITextDocument_Open should create a file\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomOpenAlways, CP_ACP); todo_wine ok(hres == S_OK, "ITextDocument_Open should success Codepage:CP_ACP\n"); todo_wine ok(is_existing_file(filename), "ITextDocument_Open should create a file\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomOpenAlways, CP_UTF8); todo_wine ok(hres == S_OK, "ITextDocument_Open should success Codepage:CP_UTF8\n"); todo_wine ok(is_existing_file(filename), "ITextDocument_Open should create a file\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomCreateNew, CP_ACP); todo_wine ok(hres == S_OK, "ITextDocument_Open should success Codepage:CP_ACP\n"); todo_wine ok(is_existing_file(filename), "ITextDocument_Open should create a file\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomCreateNew, CP_UTF8); todo_wine ok(hres == S_OK, "ITextDocument_Open should success Codepage:CP_UTF8\n"); todo_wine ok(is_existing_file(filename), "ITextDocument_Open should create a file\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); touch_file(filename); hres = ITextDocument_Open(txtDoc, &testfile, tomCreateNew, CP_ACP); todo_wine ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "ITextDocument_Open should fail Codepage:CP_ACP\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); touch_file(filename); hres = ITextDocument_Open(txtDoc, &testfile, tomCreateNew, CP_UTF8); todo_wine ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "ITextDocument_Open should fail Codepage:CP_UTF8\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomOpenExisting, CP_ACP); todo_wine ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "ITextDocument_Open should fail Codepage:CP_ACP\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); create_interfaces(&w, &reOle, &txtDoc, &txtSel); hres = ITextDocument_Open(txtDoc, &testfile, tomOpenExisting, CP_UTF8); todo_wine ok(hres == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "ITextDocument_Open should fail Codepage:CP_UTF8\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); create_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); ITextDocument_Open(txtDoc, &testfile, tomText, CP_ACP); todo_wine ok(is_existing_file(filename) == TRUE, "a file should be created default\n"); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); /* test of share mode */ touch_file(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); ITextDocument_Open(txtDoc, &testfile, tomShareDenyRead, CP_ACP); SetLastError(0xdeadbeef); hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); todo_wine ok(GetLastError() == ERROR_SHARING_VIOLATION, "ITextDocument_Open should fail\n"); CloseHandle(hFile); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); touch_file(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); ITextDocument_Open(txtDoc, &testfile, tomShareDenyWrite, CP_ACP); SetLastError(0xdeadbeef); hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); todo_wine ok(GetLastError() == ERROR_SHARING_VIOLATION, "ITextDocument_Open should fail\n"); CloseHandle(hFile); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); touch_file(filename); create_interfaces(&w, &reOle, &txtDoc, &txtSel); SetLastError(0xdeadbeef); ITextDocument_Open(txtDoc, &testfile, tomShareDenyWrite|tomShareDenyRead, CP_ACP); hFile = CreateFileW(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); todo_wine ok(GetLastError() == ERROR_SHARING_VIOLATION, "ITextDocument_Open should fail\n"); CloseHandle(hFile); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); /* tests to check the content */ hFile = CreateFileW(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); WriteFile(hFile, chACP, sizeof(chACP)-sizeof(CHAR), &dw, NULL); CloseHandle(hFile); create_interfaces(&w, &reOle, &txtDoc, &txtSel); ITextDocument_Open(txtDoc, &testfile, tomReadOnly, CP_ACP); result = SendMessageA(w, WM_GETTEXT, 1024, (LPARAM)bufACP); todo_wine ok(result == 12, "ITextDocument_Open: Test ASCII returned %d, expected 12\n", result); result = strcmp(bufACP, chACP); todo_wine ok(result == 0, "ITextDocument_Open: Test ASCII set wrong text: Result: %s\n", bufACP); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); hFile = CreateFileW(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); WriteFile(hFile, chUTF8, sizeof(chUTF8)-sizeof(CHAR), &dw, NULL); CloseHandle(hFile); create_interfaces(&w, &reOle, &txtDoc, &txtSel); ITextDocument_Open(txtDoc, &testfile, tomReadOnly, CP_UTF8); result = SendMessageA(w, WM_GETTEXT, 1024, (LPARAM)bufACP); todo_wine ok(result == 15, "ITextDocument_Open: Test UTF-8 returned %d, expected 15\n", result); result = strcmp(bufACP, &chUTF8[3]); todo_wine ok(result == 0, "ITextDocument_Open: Test UTF-8 set wrong text: Result: %s\n", bufACP); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); hFile = CreateFileW(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); WriteFile(hFile, chUTF16, sizeof(chUTF16)-sizeof(WCHAR), &dw, NULL); CloseHandle(hFile); create_interfaces(&w, &reOle, &txtDoc, &txtSel); ITextDocument_Open(txtDoc, &testfile, tomReadOnly, 1200); result = SendMessageW(w, WM_GETTEXT, 1024, (LPARAM)bufUnicode); todo_wine ok(result == 12, "ITextDocument_Open: Test UTF-16 returned %d, expected 12\n", result); result = lstrcmpW(bufUnicode, &chUTF16[1]); todo_wine ok(result == 0, "ITextDocument_Open: Test UTF-16 set wrong text: Result: %s\n", wine_dbgstr_w(bufUnicode)); release_interfaces(&w, &reOle, &txtDoc, &txtSel); DeleteFileW(filename); VariantClear(&testfile); }
static void test_mxwriter_startenddocument(void) { ISAXContentHandler *content; IMXWriter *writer; VARIANT dest; HRESULT hr; hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER, &IID_IMXWriter, (void**)&writer); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content); ok(hr == S_OK, "got %08x\n", hr); hr = ISAXContentHandler_startDocument(content); ok(hr == S_OK, "got %08x\n", hr); hr = ISAXContentHandler_endDocument(content); todo_wine ok(hr == S_OK, "got %08x\n", hr); V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); /* now try another startDocument */ hr = ISAXContentHandler_startDocument(content); ok(hr == S_OK, "got %08x\n", hr); /* and get duplcated prolog */ V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); ok(!lstrcmpW(_bstr_("<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n" "<?xml version=\"1.0\" encoding=\"UTF-16\" standalone=\"no\"?>\r\n"), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); ISAXContentHandler_Release(content); IMXWriter_Release(writer); /* now with omitted declaration */ hr = CoCreateInstance(&CLSID_MXXMLWriter, NULL, CLSCTX_INPROC_SERVER, &IID_IMXWriter, (void**)&writer); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = IMXWriter_QueryInterface(writer, &IID_ISAXContentHandler, (void**)&content); ok(hr == S_OK, "got %08x\n", hr); hr = IMXWriter_put_omitXMLDeclaration(writer, VARIANT_TRUE); ok(hr == S_OK, "got %08x\n", hr); hr = ISAXContentHandler_startDocument(content); ok(hr == S_OK, "got %08x\n", hr); hr = ISAXContentHandler_endDocument(content); todo_wine ok(hr == S_OK, "got %08x\n", hr); V_VT(&dest) = VT_EMPTY; hr = IMXWriter_get_output(writer, &dest); ok(hr == S_OK, "got %08x\n", hr); ok(V_VT(&dest) == VT_BSTR, "got %d\n", V_VT(&dest)); ok(!lstrcmpW(_bstr_(""), V_BSTR(&dest)), "got wrong content %s\n", wine_dbgstr_w(V_BSTR(&dest))); VariantClear(&dest); ISAXContentHandler_Release(content); IMXWriter_Release(writer); free_bstrs(); }
static void call_event_handlers(HTMLDocumentNode *doc, HTMLEventObj *event_obj, event_target_t *event_target, ConnectionPointContainer *cp_container, eventid_t eid, IDispatch *this_obj) { const BOOL cancelable = event_info[eid].flags & EVENT_CANCELABLE; handler_vector_t *handler_vector = NULL; VARIANT v; int i; HRESULT hres; if(event_target) handler_vector = event_target->event_table[eid]; if(handler_vector && handler_vector->handler_prop) { DISPID named_arg = DISPID_THIS; VARIANTARG arg; DISPPARAMS dp = {&arg, &named_arg, 1, 1}; V_VT(&arg) = VT_DISPATCH; V_DISPATCH(&arg) = this_obj; V_VT(&v) = VT_EMPTY; TRACE("%s >>>\n", debugstr_w(event_info[eid].name)); hres = call_disp_func(handler_vector->handler_prop, &dp, &v); if(hres == S_OK) { TRACE("%s <<< %s\n", debugstr_w(event_info[eid].name), debugstr_variant(&v)); if(cancelable) { if(V_VT(&v) == VT_BOOL) { if(!V_BOOL(&v)) event_obj->prevent_default = TRUE; }else if(V_VT(&v) != VT_EMPTY) { FIXME("unhandled result %s\n", debugstr_variant(&v)); } } VariantClear(&v); }else { WARN("%s <<< %08x\n", debugstr_w(event_info[eid].name), hres); } } if(handler_vector && handler_vector->handler_cnt) { VARIANTARG arg; DISPPARAMS dp = {&arg, NULL, 1, 0}; V_VT(&arg) = VT_DISPATCH; V_DISPATCH(&arg) = (IDispatch*)event_obj; i = handler_vector->handler_cnt; while(i--) { if(handler_vector->handlers[i]) { V_VT(&v) = VT_EMPTY; TRACE("%s [%d] >>>\n", debugstr_w(event_info[eid].name), i); hres = call_disp_func(handler_vector->handlers[i], &dp, &v); if(hres == S_OK) { TRACE("%s [%d] <<<\n", debugstr_w(event_info[eid].name), i); if(cancelable) { if(V_VT(&v) == VT_BOOL) { if(!V_BOOL(&v)) event_obj->prevent_default = TRUE; }else if(V_VT(&v) != VT_EMPTY) { FIXME("unhandled result %s\n", debugstr_variant(&v)); } } VariantClear(&v); }else { WARN("%s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres); } } } } /* * NOTE: CP events may require doc_obj reference, which we don't own. We make sure that * it's safe to call event handler by checking nsevent_listener, which is NULL for * detached documents. */ if(cp_container && doc->nsevent_listener) { ConnectionPoint *cp; if(cp_container->forward_container) cp_container = cp_container->forward_container; for(cp = cp_container->cp_list; cp; cp = cp->next) { if(cp->sinks_size && is_cp_event(cp->data, event_info[eid].dispid)) { for(i=0; doc->nsevent_listener && i < cp->sinks_size; i++) { if(!cp->sinks[i].disp) continue; V_VT(&v) = VT_EMPTY; TRACE("cp %s [%d] >>>\n", debugstr_w(event_info[eid].name), i); hres = call_cp_func(cp->sinks[i].disp, event_info[eid].dispid, &v); if(hres == S_OK) { TRACE("cp %s [%d] <<<\n", debugstr_w(event_info[eid].name), i); if(cancelable) { if(V_VT(&v) == VT_BOOL) { if(!V_BOOL(&v)) event_obj->prevent_default = TRUE; }else if(V_VT(&v) != VT_EMPTY) { FIXME("unhandled result %s\n", debugstr_variant(&v)); } } VariantClear(&v); }else { WARN("cp %s [%d] <<< %08x\n", debugstr_w(event_info[eid].name), i, hres); } } if(!doc->nsevent_listener) break; } } } }
static void test_saxreader(void) { HRESULT hr; ISAXXMLReader *reader = NULL; VARIANT var; ISAXContentHandler *lpContentHandler; ISAXErrorHandler *lpErrorHandler; SAFEARRAY *pSA; SAFEARRAYBOUND SADim[1]; char *pSAData = NULL; IStream *iStream; ULARGE_INTEGER liSize; LARGE_INTEGER liPos; ULONG bytesWritten; HANDLE file; static const CHAR testXmlA[] = "test.xml"; static const WCHAR testXmlW[] = {'t','e','s','t','.','x','m','l',0}; IXMLDOMDocument *domDocument; BSTR bstrData; VARIANT_BOOL vBool; hr = CoCreateInstance(&CLSID_SAXXMLReader, NULL, CLSCTX_INPROC_SERVER, &IID_ISAXXMLReader, (LPVOID*)&reader); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = ISAXXMLReader_getContentHandler(reader, NULL); ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr); hr = ISAXXMLReader_getErrorHandler(reader, NULL); ok(hr == E_POINTER, "Expected E_POINTER, got %08x\n", hr); hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(lpContentHandler == NULL, "Expected %p, got %p\n", NULL, lpContentHandler); hr = ISAXXMLReader_getErrorHandler(reader, &lpErrorHandler); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(lpErrorHandler == NULL, "Expected %p, got %p\n", NULL, lpErrorHandler); hr = ISAXXMLReader_putContentHandler(reader, NULL); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = ISAXXMLReader_putContentHandler(reader, &contentHandler); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = ISAXXMLReader_putErrorHandler(reader, &errorHandler); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); hr = ISAXXMLReader_getContentHandler(reader, &lpContentHandler); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); ok(lpContentHandler == &contentHandler, "Expected %p, got %p\n", &contentHandler, lpContentHandler); V_VT(&var) = VT_BSTR; V_BSTR(&var) = SysAllocString(szSimpleXML); expectCall = contentHandlerTest1; hr = ISAXXMLReader_parse(reader, var); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); test_expect_call(CH_ENDTEST); VariantClear(&var); SADim[0].lLbound= 0; SADim[0].cElements= sizeof(szTestXML)-1; pSA = SafeArrayCreate(VT_UI1, 1, SADim); SafeArrayAccessData(pSA, (void**)&pSAData); memcpy(pSAData, szTestXML, sizeof(szTestXML)-1); SafeArrayUnaccessData(pSA); V_VT(&var) = VT_ARRAY|VT_UI1; V_ARRAY(&var) = pSA; expectCall = contentHandlerTest1; hr = ISAXXMLReader_parse(reader, var); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); test_expect_call(CH_ENDTEST); SafeArrayDestroy(pSA); CreateStreamOnHGlobal(NULL, TRUE, &iStream); liSize.QuadPart = strlen(szTestXML); IStream_SetSize(iStream, liSize); IStream_Write(iStream, szTestXML, strlen(szTestXML), &bytesWritten); liPos.QuadPart = 0; IStream_Seek(iStream, liPos, STREAM_SEEK_SET, NULL); V_VT(&var) = VT_UNKNOWN|VT_DISPATCH; V_UNKNOWN(&var) = (IUnknown*)iStream; expectCall = contentHandlerTest1; hr = ISAXXMLReader_parse(reader, var); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); test_expect_call(CH_ENDTEST); IStream_Release(iStream); V_VT(&var) = VT_BSTR; V_BSTR(&var) = SysAllocString(szCarriageRetTest); expectCall = contentHandlerTest2; hr = ISAXXMLReader_parse(reader, var); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); test_expect_call(CH_ENDTEST); VariantClear(&var); file = CreateFileA(testXmlA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError()); WriteFile(file, szTestXML, sizeof(szTestXML)-1, &bytesWritten, NULL); CloseHandle(file); expectCall = contentHandlerTest1; hr = ISAXXMLReader_parseURL(reader, testXmlW); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); test_expect_call(CH_ENDTEST); DeleteFileA(testXmlA); hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (LPVOID*)&domDocument); if(FAILED(hr)) { skip("Failed to create DOMDocument instance\n"); return; } bstrData = SysAllocString(szSimpleXML); hr = IXMLDOMDocument_loadXML(domDocument, bstrData, &vBool); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); V_VT(&var) = VT_UNKNOWN; V_UNKNOWN(&var) = (IUnknown*)domDocument; expectCall = contentHandlerTest2; hr = ISAXXMLReader_parse(reader, var); ok(hr == S_OK, "Expected S_OK, got %08x\n", hr); test_expect_call(CH_ENDTEST); IXMLDOMDocument_Release(domDocument); ISAXXMLReader_Release(reader); SysFreeString(bstrData); }
DirectShowScanner::DirectShowScanner() { ICreateDevEnum *pDevEnum = 0; int hr; int devNum; char nameBuf[80]; // Reference: Pesce, pp 54-56. debug_msg("new DirectShowScanner()\n"); // Initialize the COM subsystem hr=CoInitialize(NULL); if (FAILED(hr)) { debug_msg("Failed COM subsystem initialisation.\n"); return; } // Create a helper object to find the capture devices. hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER, IID_ICreateDevEnum, (LPVOID*)&pDevEnum); if (FAILED(hr)) { debug_msg("Failed to Create a helper object to find the DS capture devices.\n"); CoUninitialize(); return; } IEnumMoniker *pEnum = 0; IMoniker *pMoniker = 0; IPropertyBag *pPropBag = 0; VARIANT varName; // Get an enumerator over video capture filters hr = pDevEnum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &pEnum, 0); //showErrorMessage(hr); if (FAILED(hr) || pEnum == 0) { debug_msg("Failed to Get an enumerator over DS video capture filters.\n"); CoUninitialize(); return; } // Get the capture filter for each device installed, up to NUM_DEVS devices for( devNum=0; devNum < NUM_DEVS; ++devNum) { if ( pEnum->Next(1, &pMoniker, NULL) == S_OK ) { hr = pMoniker->BindToStorage(0, 0, IID_IPropertyBag, (void **)&pPropBag); if (FAILED(hr)) { debug_msg("Failed to Get propbag bound to storage on DS dev: %d\n", devNum); continue; } //showErrorMessage(hr); debug_msg("propbag bound to storage ok= %d\n", hr); VariantInit(&varName); hr = pPropBag->Read(L"FriendlyName", &varName, 0); if (FAILED(hr)) { debug_msg("Failed to Get friendly name read on DS dev: %d\n", devNum); continue; } //showErrorMessage(hr); debug_msg("friendly name read ok= %d\n", hr); // Need this macro in atlconv.h to go from bStr to char* - msp USES_CONVERSION; strcpy(nameBuf, W2A(varName.bstrVal)); debug_msg("DirectShowScanner::DirectShowScanner(): found nameBuf/FriendlyName=%s\n", nameBuf); // needs work, but don't add drivers that look like VFW drivers - msp if( (strstr(nameBuf, "VFW") == NULL) ) { hr = pMoniker->BindToObject(0, 0, IID_IBaseFilter, (void **)(pCaptureFilter+devNum)); //showErrorMessage(hr); if (FAILED(hr)) { debug_msg("Failed to Get friendly name read on DS dev: %d\n", devNum); continue; } debug_msg("capture filter bound ok= %d\n", hr); devs_[devNum] = new DirectShowDevice(strdup(nameBuf), pCaptureFilter[devNum]); } else { debug_msg("discarding an apparent VFW device= %s\n", nameBuf); devs_[devNum] = NULL; } VariantClear(&varName); pPropBag->Release(); } } // Release these objects so COM can release their memory pMoniker->Release(); pEnum->Release(); pDevEnum->Release(); }
LDAPAUTH_API BOOL CUGP(char * userin,char *password,char *machine, char * groupin,int locdom) { OSVERSIONINFO ovi = { sizeof ovi }; GetVersionEx( &ovi ); if (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT && ovi.dwMajorVersion >= 5 ) { //Handle the command line arguments. LPOLESTR pszBuffer = new OLECHAR[MAX_PATH*2]; LPOLESTR pszBuffer2 = new OLECHAR[MAX_PATH*2]; LPOLESTR pszBuffer3 = new OLECHAR[MAX_PATH*2]; LPOLESTR pszBuffer4 = new OLECHAR[MAX_PATH*2]; mbstowcs( (wchar_t *) pszBuffer, userin, MAX_PATH ); mbstowcs( (wchar_t *) pszBuffer2, password, MAX_PATH ); mbstowcs( (wchar_t *) pszBuffer3, machine, MAX_PATH ); mbstowcs( (wchar_t *) pszBuffer4, groupin, MAX_PATH ); HRESULT hr = S_OK; //Get rootDSE and the domain container's DN. IADs *pObject = NULL; IADs *pObjectUser = NULL; IADs *pObjectGroup = NULL; IDirectorySearch *pDS = NULL; LPOLESTR szPath = new OLECHAR[MAX_PATH]; LPOLESTR myPath = new OLECHAR[MAX_PATH]; VARIANT var; wcscpy(szPath,L"LDAP://"); wcscat(szPath,L"rootDSE"); wprintf(szPath); wprintf(L"\n"); hr = ADsOpenObject(szPath, pszBuffer, pszBuffer2, ADS_SECURE_AUTHENTICATION, //Use Secure Authentication IID_IADs, (void**)&pObject); if (FAILED(hr)) { wprintf(L"Bind to domain failed %i\n",hr); if (pObject) pObject->Release(); delete [] pszBuffer; delete [] pszBuffer2; delete [] pszBuffer3; delete [] pszBuffer4; delete [] szPath; delete [] myPath; return false; } hr = pObject->Get(L"defaultNamingContext",&var); if (SUCCEEDED(hr)) { wcscpy(szPath,L"LDAP://"); wcscat(szPath,var.bstrVal); VariantClear(&var); if (pObject) { pObject->Release(); pObject = NULL; } wprintf( szPath); wprintf(L"\n"); //Bind to the root of the current domain. hr = ADsOpenObject(szPath,pszBuffer,pszBuffer2, ADS_SECURE_AUTHENTICATION,IID_IDirectorySearch,(void**)&pDS); if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) { hr = FindUserByName(pDS, pszBuffer, &pObjectUser); if (FAILED(hr)) { wprintf(L"User not found %i\n",hr); delete [] pszBuffer; delete [] pszBuffer2; delete [] pszBuffer3; delete [] szPath; delete [] myPath; if (pDS) pDS->Release(); if (pObjectUser) pObjectUser->Release(); return false; } if (pObjectUser) pObjectUser->Release(); ///////////////////// VNCACCESS hr = FindGroup(pDS, pszBuffer, &pObjectGroup,pszBuffer4); if (pObjectGroup) { pObjectGroup->Release(); pObjectGroup = NULL; } if (FAILED(hr)) wprintf(L"group not found\n"); if (SUCCEEDED(hr)) { wprintf(L"Group found OK\n"); IADsGroup * pIADsG; hr = ADsOpenObject( gbsGroup,pszBuffer, pszBuffer2, ADS_SECURE_AUTHENTICATION,IID_IADsGroup, (void**) &pIADsG); if (SUCCEEDED(hr)) { VARIANT_BOOL bMember = FALSE; hr = pIADsG->IsMember(gbsMember,&bMember); if (SUCCEEDED(hr)) { if (bMember == -1) { wprintf(L"Object \n\n%s\n\n IS a member of the following Group:\n\n%s\n\n",gbsMember,gbsGroup); delete [] pszBuffer; delete [] pszBuffer2; delete [] pszBuffer3; delete [] szPath; delete [] myPath; if (pDS) pDS->Release(); return true; } else { BSTR bsMemberGUID = NULL; IDirectoryObject * pDOMember = NULL; hr = ADsOpenObject( gbsMember,pszBuffer, pszBuffer2, ADS_SECURE_AUTHENTICATION,IID_IDirectoryObject, (void**) &pDOMember); if (SUCCEEDED(hr)) { hr = GetObjectGuid(pDOMember,bsMemberGUID); pDOMember->Release(); pDOMember = NULL; if (RecursiveIsMember(pIADsG,bsMemberGUID,gbsMember,true, pszBuffer, pszBuffer2)) { delete [] pszBuffer; delete [] pszBuffer2; delete [] pszBuffer3; delete [] szPath; delete [] myPath; if (pDS) pDS->Release(); return true; } } }//else bmember }//ismember }//iadsgroup }//Findgroup wprintf(L"USER not found in group\n"); }//user } if (pDS) pDS->Release(); } /*LOGFAILED(pszBuffer3,pszBuffer);*/ delete [] pszBuffer; delete [] pszBuffer2; delete [] pszBuffer3; delete [] szPath; delete [] myPath; return false; } return false; }
//----------------------------------------------------------------------------- // Name: GetDirectXVersionViaDxDiag() // Desc: Tries to get the DirectX version from DxDiag's COM interface //----------------------------------------------------------------------------- HRESULT GetDirectXVersionViaDxDiag( DWORD* pdwDirectXVersionMajor, DWORD* pdwDirectXVersionMinor, TCHAR* pcDirectXVersionLetter ) { HRESULT hr; bool bCleanupCOM = false; bool bSuccessGettingMajor = false; bool bSuccessGettingMinor = false; bool bSuccessGettingLetter = false; // Init COM. COM may fail if its already been inited with a different // concurrency model. And if it fails you shouldn't release it. hr = CoInitialize(NULL); bCleanupCOM = SUCCEEDED(hr); // Get an IDxDiagProvider bool bGotDirectXVersion = false; IDxDiagProvider* pDxDiagProvider = NULL; hr = CoCreateInstance( CLSID_DxDiagProvider, NULL, CLSCTX_INPROC_SERVER, IID_IDxDiagProvider, (LPVOID*) &pDxDiagProvider ); if( SUCCEEDED(hr) ) { // Fill out a DXDIAG_INIT_PARAMS struct DXDIAG_INIT_PARAMS dxDiagInitParam; ZeroMemory( &dxDiagInitParam, sizeof(DXDIAG_INIT_PARAMS) ); dxDiagInitParam.dwSize = sizeof(DXDIAG_INIT_PARAMS); dxDiagInitParam.dwDxDiagHeaderVersion = DXDIAG_DX9_SDK_VERSION; dxDiagInitParam.bAllowWHQLChecks = false; dxDiagInitParam.pReserved = NULL; // Init the m_pDxDiagProvider hr = pDxDiagProvider->Initialize( &dxDiagInitParam ); if( SUCCEEDED(hr) ) { IDxDiagContainer* pDxDiagRoot = NULL; IDxDiagContainer* pDxDiagSystemInfo = NULL; // Get the DxDiag root container hr = pDxDiagProvider->GetRootContainer( &pDxDiagRoot ); if( SUCCEEDED(hr) ) { // Get the object called DxDiag_SystemInfo hr = pDxDiagRoot->GetChildContainer( L"DxDiag_SystemInfo", &pDxDiagSystemInfo ); if( SUCCEEDED(hr) ) { VARIANT var; VariantInit( &var ); // Get the "dwDirectXVersionMajor" property hr = pDxDiagSystemInfo->GetProp( L"dwDirectXVersionMajor", &var ); if( SUCCEEDED(hr) && var.vt == VT_UI4 ) { if( pdwDirectXVersionMajor ) *pdwDirectXVersionMajor = var.ulVal; bSuccessGettingMajor = true; } VariantClear( &var ); // Get the "dwDirectXVersionMinor" property hr = pDxDiagSystemInfo->GetProp( L"dwDirectXVersionMinor", &var ); if( SUCCEEDED(hr) && var.vt == VT_UI4 ) { if( pdwDirectXVersionMinor ) *pdwDirectXVersionMinor = var.ulVal; bSuccessGettingMinor = true; } VariantClear( &var ); // Get the "szDirectXVersionLetter" property hr = pDxDiagSystemInfo->GetProp( L"szDirectXVersionLetter", &var ); if( SUCCEEDED(hr) && var.vt == VT_BSTR && var.bstrVal != NULL ) { #ifdef UNICODE *pcDirectXVersionLetter = var.bstrVal[0]; #else char strDestination[10]; WideCharToMultiByte( CP_ACP, 0, var.bstrVal, -1, strDestination, 10*sizeof(CHAR), NULL, NULL ); if( pcDirectXVersionLetter ) *pcDirectXVersionLetter = strDestination[0]; #endif bSuccessGettingLetter = true; } VariantClear( &var ); // If it all worked right, then mark it down if( bSuccessGettingMajor && bSuccessGettingMinor && bSuccessGettingLetter ) bGotDirectXVersion = true; pDxDiagSystemInfo->Release(); } pDxDiagRoot->Release(); } } pDxDiagProvider->Release(); } if( bCleanupCOM ) CoUninitialize(); if( bGotDirectXVersion ) return S_OK; else return E_FAIL; }
HRESULT WebHelper::OpenURLWithData(const WCHAR *wszURL, const BYTE *pbPostData, DWORD cbData) { // This string is the header needed for HTTP POST actions. const LPWSTR POST_HEADER_DATA = L"Content-Type: application/x-www-form-urlencoded\r\n"; if (!wszURL) { return E_INVALIDARG; } if (!m_pBrowser) { return E_UNEXPECTED; } HRESULT hr = S_OK; BSTR bstrURL = NULL; VARIANT vtEmpty; VARIANT vtHeader; VARIANT vtPostData; VariantInit(&vtEmpty); VariantInit(&vtHeader); VariantInit(&vtPostData); // Allocate a BSTR for the URL. bstrURL = SysAllocString(wszURL); if (bstrURL == NULL) { hr = E_OUTOFMEMORY; } // Allocate a BSTR for the header. if (SUCCEEDED(hr)) { vtHeader.bstrVal = SysAllocString(POST_HEADER_DATA); if (vtHeader.bstrVal == NULL) { hr = E_OUTOFMEMORY; } else { vtHeader.vt = VT_BSTR; } } if (SUCCEEDED(hr)) { if ( pbPostData ) { // Convert the POST data to a safe array in a variant. The safe array type is VT_UI1. void *pvData = NULL; SAFEARRAY *saPostData = SafeArrayCreateVector(VT_UI1, 0, cbData); if (saPostData == NULL) { hr = E_OUTOFMEMORY; } if (SUCCEEDED(hr)) { hr = SafeArrayAccessData(saPostData, &pvData); } if (SUCCEEDED(hr)) { CopyMemory((BYTE*)pvData, pbPostData, cbData); hr = SafeArrayUnaccessData(saPostData); } if (SUCCEEDED(hr)) { vtPostData.vt = VT_ARRAY | VT_UI1; vtPostData.parray = saPostData; } } } // Make the IE window visible. if (SUCCEEDED(hr)) { hr = m_pBrowser->put_Visible(VARIANT_TRUE); LOG_MSG_IF_FAILED(L"put_Visible)", hr); } // Navigate to the URL. if (SUCCEEDED(hr)) { hr = m_pBrowser->Navigate(bstrURL, &vtEmpty, &vtEmpty, &vtPostData, &vtHeader); LOG_MSG_IF_FAILED(L"Navigate", hr); } SysFreeString(bstrURL); VariantClear(&vtEmpty); VariantClear(&vtHeader); VariantClear(&vtPostData); return hr; }
/** * Evaluate JavaScript expression. * * @parem [in] lpwszScript JavaScript expression * @parem [out] lpwszResult evaluation result * @return S_OK if successful. */ HRESULT JScriptEngine::Eval(LPCWSTR lpwszScript, LPWSTR lpwszResult) { HRESULT hr = E_FAIL; if (m_spScript == NULL) return E_FAIL; IActiveScriptPtr spScript; // Clone the scripting engine. hr = m_spScript->Clone(&spScript); if (FAILED(hr)) { #ifdef _DEBUG OutputDebugString(TEXT("Unable to clone JScript engine.")); #endif return hr; } IActiveScriptParsePtr spScriptParse; // Script Engine must support IActiveScriptParse for us to use it hr = spScript->QueryInterface(IID_IActiveScriptParse, (void **)&spScriptParse); if (FAILED(hr)) { #ifdef _DEBUG OutputDebugString(TEXT("JScript engine doesn't support IActiveScriptParse.")); #endif return hr; } IActiveScriptSitePtr spScriptSite; CComObject<JScriptSite>* pJScriptSite = NULL; CComObject<JScriptSite>::CreateInstance(&pJScriptSite); pJScriptSite->QueryInterface(IID_IActiveScriptSite, (void**)&spScriptSite); // Set scripting site hr = spScript->SetScriptSite(spScriptSite); if (hr) return hr; // InitNew the object: hr = spScriptParse->InitNew(); VARIANT v; VariantInit(&v); // Feed the custom JavaScript to the JavaScript engine. hr = spScriptParse->ParseScriptText(lpwszScript, NULL, NULL, NULL, 0, 0, SCRIPTTEXT_ISEXPRESSION , &v, NULL); if (v.vt == VT_BSTR) { wsprintfW(lpwszResult, L"%s", v.bstrVal); } VariantClear(&v); return hr; }