// Displays a property assumed to be in string form. void DisplayStringProperty( IPortableDeviceValues* pProperties, REFPROPERTYKEY key, PCWSTR pszKey) { PWSTR pszValue = NULL; HRESULT hr = pProperties->GetStringValue(key,&pszValue); if (SUCCEEDED(hr)) { // Get the length of the string value so we // can output <empty string value> if one // is encountered. CAtlStringW strValue; strValue = pszValue; if (strValue.GetLength() > 0) { printf("%ws: %ws\n",pszKey, pszValue); } else { printf("%ws: <empty string value>\n", pszKey); } } else { printf("%ws: <Not Found>\n", pszKey); } // Free the allocated string returned from the // GetStringValue method CoTaskMemFree(pszValue); pszValue = NULL; }
bool CDeviceView::EnableSelectedDevice( _In_ bool Enable, _Out_ bool &NeedsReboot ) { CDeviceNode *Node = dynamic_cast<CDeviceNode *>(GetSelectedNode()); if (Node == nullptr) return false; if (Enable == false) { CAtlStringW str; if (str.LoadStringW(g_hThisInstance, IDS_CONFIRM_DISABLE)) { if (MessageBoxW(m_hMainWnd, str, Node->GetDisplayName(), MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2) != IDYES) { return false; } } } return Node->EnableDevice(Enable, NeedsReboot); }
// Initialize the enumeration context VOID WpdObjectEnumerator::InitializeEnumerationContext( WpdObjectEnumeratorContext* pEnumeratorContext, CAtlStringW strParentObjectID) { if (pEnumeratorContext == NULL) { return; } // Initialize the enumeration context with the parent object identifier pEnumeratorContext->m_strParentObjectID = strParentObjectID; // Our sample driver has a very simple object structure where we know // how many children are under each parent. // The eumeration context is initialized below with this information. if (strParentObjectID.CompareNoCase(L"") == 0) { // Clients passing an 'empty' string for the parent are asking for the // 'DEVICE' object. We should return 1 child in this case. pEnumeratorContext->m_TotalChildren = 1; } else if (strParentObjectID.CompareNoCase(WPD_DEVICE_OBJECT_ID) == 0) { // The device object contains 1 child (the storage object). pEnumeratorContext->m_TotalChildren = 1; } // If the sensor objects have children, add them here... else { // The sensor object contains 0 children. pEnumeratorContext->m_TotalChildren = 0; } }
CNetRequestImpl::CNetRequestImpl(const char* method, const String& strUrl) { pszErrFunction = NULL; hInet = NULL, hConnection = NULL, hRequest = NULL; memset(&uri, 0, sizeof(uri) ); m_pInstance = this; CAtlStringW strUrlW(strUrl.c_str()); do { if ( !isLocalHost(strUrl.c_str()) && !SetupInternetConnection(strUrlW) ) { pszErrFunction = L"SetupInternetConnection"; break; } hInet = InternetOpen(_T("rhodes-wm"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, NULL ); if ( !hInet ) { pszErrFunction = L"InternetOpen"; break; } DWORD dwUrlLength = 1024; CAtlStringW strCanonicalUrlW; if ( !InternetCanonicalizeUrl( strUrlW, strCanonicalUrlW.GetBuffer(dwUrlLength), &dwUrlLength, 0) ) { pszErrFunction = _T("InternetCanonicalizeUrl"); break; } strCanonicalUrlW.ReleaseBuffer(); alloc_url_components( &uri, strCanonicalUrlW ); if( !InternetCrackUrl( strCanonicalUrlW, strCanonicalUrlW.GetLength(), 0, &uri ) ) { pszErrFunction = L"InternetCrackUrl"; break; } hConnection = InternetConnect( hInet, uri.lpszHostName, uri.nPort, _T("anonymous"), NULL, INTERNET_SERVICE_HTTP, 0, 0 ); if ( !hConnection ) { pszErrFunction = L"InternetConnect"; break; } strReqUrlW = uri.lpszUrlPath; strReqUrlW += uri.lpszExtraInfo; hRequest = HttpOpenRequest( hConnection, CAtlStringW(method), strReqUrlW, NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_NO_CACHE_WRITE, NULL ); if ( !hRequest ) { pszErrFunction = L"HttpOpenRequest"; break; } }while(0); }
HRESULT CDBHistory::UpdateHistory(HDBCONNECTION hDBConnection, int nIndex, LPCWSTR lpszComment, BSTR* pbstrResult) { HRESULT hr = E_FAIL; IMT::CDBConnection* pDBConnection = reinterpret_cast<IMT::CDBConnection*>(hDBConnection); if (pDBConnection != NULL) { ATL::CCommand<ATL::CDynamicAccessor> Command; ATL::CDBPropSet _DBPropSet(DBPROPSET_ROWSET); pDBConnection->GetRowsetProperties(&_DBPropSet); CAtlStringW strCommand; strCommand.Format(QUERY_HISTORY_UPDATE, lpszComment, nIndex); hr = Command.Open(ATL::CSession(*pDBConnection), strCommand, &_DBPropSet); if (hr != S_OK) { if (pbstrResult != NULL) IMT::GetDBErrorString(hr, pbstrResult); } else { TRACE(_T(":::[CDBHistory]-[UPDATE] SUCCEEDED :::\n")); } } return hr; }
HRESULT CDBConnection::OpenDataSource(LPCWSTR lpszPathFileName, LPCWSTR lpszUserName, LPCWSTR lpszPassword) { _ASSERTE(lpszPathFileName != NULL); _ASSERTE(lpszUserName != NULL); _ASSERTE(lpszPassword != NULL); USES_CONVERSION; HRESULT hr = E_FAIL; if (lpszPathFileName != NULL && lpszUserName != NULL && lpszPassword != NULL) { if (::PathFileExists(lpszPathFileName)) { CAtlStringW strConnection; strConnection.Format( #if defined(USES_JET_OLEDB_DRIVER) L"Provider=Microsoft.Jet.OLEDB.4.0;" #else L"Provider=Microsoft.ACE.OLEDB.12.0;" #endif L"Data Source=%s;" L"User ID=%s;" L"Mode=Share Deny None;" L"Extended Properties=\"\";" L"Jet OLEDB:System database=\"\";" L"Jet OLEDB:Registry Path=\"\";" L"Jet OLEDB:Database Password=\"%s\";" L"Jet OLEDB:Engine Type=5;" L"Jet OLEDB:Database Locking Mode=1;" L"Jet OLEDB:Global Partial Bulk Ops=2;" L"Jet OLEDB:Global Bulk Transactions=1;" L"Jet OLEDB:New Database Password=\"\";" L"Jet OLEDB:Create System Database=False;" L"Jet OLEDB:Encrypt Database=False;" L"Jet OLEDB:Don't Copy Locale on Compact=False;" L"Jet OLEDB:Compact Without Replica Repair=False;" L"Jet OLEDB:SFP=False" , lpszPathFileName, lpszUserName, lpszPassword); hr = Open(LPCWSTR(strConnection)); if (FAILED(hr)) { #ifdef _DEBUG ATL::AtlTraceErrorRecords(hr); #endif } } else hr = HRESULT_FROM_WIN32(::GetLastError()); } else hr = E_POINTER; return hr; }
LRESULT CPropertyEditWindow::OnAdd(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { CPropertyAddDialog dialog; // Add the property categories for(size_t i = 0; i < m_arrPropertyInfo.GetCount(); i++) { if(m_arrPropertyInfo.GetAt(i)->IsWriteable() == S_OK) { LPWSTR szPropertyCategory; TED_ATTRIBUTE_CATEGORY Category; m_arrPropertyInfo.GetAt(i)->GetPropertyInfoName(&szPropertyCategory, &Category); dialog.AddPropertyCategory(szPropertyCategory, Category, (DWORD) i); CoTaskMemFree(szPropertyCategory); } } // Fill dialog properties if(dialog.DoModal() == IDOK) { DWORD dwIndex = dialog.GetChosenCategory(); CAtlStringW strName = dialog.GetChosenProperty(); CAtlStringW strValue = dialog.GetValue(); ITedPropertyInfo* pPropertyInfo = m_arrPropertyInfo.GetAt(dwIndex); for(DWORD i = 0; i < TEDGetAttributeListLength(); i++) { if(TEDGetAttributeName(i) == strName) { DWORD dwPropertyCount; pPropertyInfo->GetPropertyCount(&dwPropertyCount); pPropertyInfo->SetProperty(dwPropertyCount, strName.GetBuffer(), TEDGetAttributeType(i), strValue.GetBuffer()); RECT clientRect; GetClientRect(&clientRect); DWORD dwViewWidth = clientRect.right - clientRect.left - 5; RECT rectNextLabel; rectNextLabel.top = 5 + (ms_LabelHeight * dwPropertyCount); rectNextLabel.left = 5; rectNextLabel.right = rectNextLabel.left + dwViewWidth / 2; rectNextLabel.bottom = rectNextLabel.top + ms_LabelHeight; CreatePropertyInterfaceForIndex(dwIndex, dwPropertyCount, rectNextLabel); ResizeChildren(); break; } } } return 0; }
DWORD IGFrame::GetImageType (LPCWSTR lpPicturePath) { CAtlStringW cstrExtension (lpPicturePath); if (cstrExtension.GetLength() < 5) return CXIMAGE_FORMAT_UNKNOWN; cstrExtension = cstrExtension.Right (4); // supported file extenstion length may be 2, 3 or 4 if (cstrExtension.GetAt (0) == L'.') cstrExtension = cstrExtension.Right (3); else if (cstrExtension.GetAt (1) == L'.') cstrExtension = cstrExtension.Right (2); cstrExtension.MakeUpper(); if (cstrExtension == L"BMP") return CXIMAGE_FORMAT_BMP; else if (cstrExtension == L"JPG") return CXIMAGE_FORMAT_JPG; else if (cstrExtension == L"PNG") return CXIMAGE_FORMAT_PNG; else if (cstrExtension == L"ICO") return CXIMAGE_FORMAT_ICO; else if (cstrExtension == L"GIF") return CXIMAGE_FORMAT_GIF; else if (cstrExtension == L"TIF") return CXIMAGE_FORMAT_TIF; else if (cstrExtension == L"IG") return CXIMAGE_FORMAT_IG; return CXIMAGE_FORMAT_UNKNOWN; }
HRESULT CDefaultRecordGraphBuilder::CreateAudioSrcFilter(IBaseFilter** ppSrcFilter) { CHECK_POINTER_RETURN_VALUE_IF_FAIL(ppSrcFilter, E_POINTER); HRESULT hr = E_FAIL; CFSharePtr<FTL::CFDShowHardwareMgr> spAudioCaptureHardwareMgr(new FTL::CFDShowHardwareMgr()); DX_VERIFY_EXCEPT1(spAudioCaptureHardwareMgr->Refresh(&CLSID_AudioInputDeviceCategory), S_FALSE); if (S_OK == hr) { CAtlStringW wstrAudioInputString; if (m_Param.strAudioInputName.IsEmpty()) { //get first -- TODO: use enum FTL::HardwareMonikerInfoContainer& rHardwares = spAudioCaptureHardwareMgr->GetAllHardwares(); if (!rHardwares.empty()) { wstrAudioInputString = (*rHardwares.begin())->wachFriendlyName; //m_spAudioCaptureHardwareMgr->GetDefault } } else { //User Save audio wstrAudioInputString = CT2W(m_Param.strAudioInputName); } if (!wstrAudioInputString.IsEmpty()) { CComPtr<IBaseFilter> spAudioSrcFilter; DX_VERIFY(spAudioCaptureHardwareMgr->GetBindObject(wstrAudioInputString, IID_IBaseFilter, (void **)&spAudioSrcFilter)); if (SUCCEEDED(hr)) { DX_VERIFY(m_spGraphBuilder->AddFilter(spAudioSrcFilter, wstrAudioInputString)); if (SUCCEEDED(hr)) { *ppSrcFilter = spAudioSrcFilter.Detach(); //(*ppSrcFilter)->AddRef(); } } else { //maybe user change audio device ? } } } return hr; }
HRESULT CDBHistory::AddHistory(HDBCONNECTION hDBConnection, DB_HISTORY_COMMON dbHistory, BSTR* pbstrResult) { HRESULT hr = E_FAIL; IMT::CDBConnection* pDBConnection = reinterpret_cast<IMT::CDBConnection*>(hDBConnection); if (pDBConnection != NULL) { ATL::CCommand<ATL::CDynamicAccessor> Command; ATL::CDBPropSet _DBPropSet(DBPROPSET_ROWSET); pDBConnection->GetRowsetProperties(&_DBPropSet); CAtlStringW strCommand; strCommand.Format(QUERY_HISTORY_INSERT, dbHistory.dateTime.year, dbHistory.dateTime.month, dbHistory.dateTime.day, dbHistory.dateTime.hour, dbHistory.dateTime.minute, dbHistory.dateTime.second, dbHistory.nLRUIdx, dbHistory.wszSerialNum, dbHistory.wszSRUName, dbHistory.nInspectType, dbHistory.wszItem, dbHistory.nBIT, dbHistory.lPresentedResult, dbHistory.wszID, dbHistory.wszComment, dbHistory.l_Index); hr = Command.Open(ATL::CSession(*pDBConnection), strCommand, &_DBPropSet); if (hr != S_OK) { if (pbstrResult != NULL) IMT::GetDBErrorString(hr, pbstrResult); } else { TRACE(_T(":::[CDBHistory]-[INSERT] SUCCEEDED :::\n")); } } return hr; }
HRESULT CDBHistroy_BIT::AddHistoryBIT(HDBCONNECTION hDBConnection, DB_BIT dbBIT, BSTR* pbstrResult) { HRESULT hr = E_FAIL; IMT::CDBConnection* pDBConnection = reinterpret_cast<IMT::CDBConnection*>(hDBConnection); if (pDBConnection != NULL) { ATL::CCommand<ATL::CDynamicAccessor> Command; ATL::CDBPropSet _DBPropSet(DBPROPSET_ROWSET); pDBConnection->GetRowsetProperties(&_DBPropSet); CAtlStringW strCommand; strCommand.Format(QUERY_H_BIT_INSERT, dbBIT.dbHistory.dateTime.year, dbBIT.dbHistory.dateTime.month, dbBIT.dbHistory.dateTime.day, dbBIT.dbHistory.dateTime.hour, dbBIT.dbHistory.dateTime.minute, dbBIT.dbHistory.dateTime.second, dbBIT.wszInstrumentName, dbBIT.dbHistory.nBIT, dbBIT.wszInspectionItem, dbBIT.dbHistory.lPresentedResult, dbBIT.dbHistory.wszComment, dbBIT.bMainSection); hr = Command.Open(ATL::CSession(*pDBConnection), strCommand, &_DBPropSet); if (hr != S_OK) { if (pbstrResult != NULL) IMT::GetDBErrorString(hr, pbstrResult); } else { TRACE(_T(":::[CDBHistroy_BIT]-[INSERT] SUCCEEDED :::\n")); } } /*SELECT MAX(rowId) FROM property */ return hr; }
HRESULT CDBHistroy_External::AddHistoryExternal(HDBCONNECTION hDBConnection, DB_EXTERNAL dbExternal, BSTR* pbstrResult) { HRESULT hr = E_FAIL; IMT::CDBConnection* pDBConnection = reinterpret_cast<IMT::CDBConnection*>(hDBConnection); if (pDBConnection != NULL) { ATL::CCommand<ATL::CDynamicAccessor> Command; ATL::CDBPropSet _DBPropSet(DBPROPSET_ROWSET); pDBConnection->GetRowsetProperties(&_DBPropSet); CAtlStringW strCommand; strCommand.Format(QUERY_H_EXTERNAL_INSERT, dbExternal.dbHistory.dateTime.year, dbExternal.dbHistory.dateTime.month, dbExternal.dbHistory.dateTime.day, dbExternal.dbHistory.dateTime.hour, dbExternal.dbHistory.dateTime.minute, dbExternal.dbHistory.dateTime.second, dbExternal.wszInspectionItem, dbExternal.wszLRUPort, dbExternal.wszCable, dbExternal.wszInspectionSignal, dbExternal.wszInterlockPort, dbExternal.dbHistory.bResult, dbExternal.dbHistory.wszID, dbExternal.dbHistory.wszComment); hr = Command.Open(ATL::CSession(*pDBConnection), strCommand, &_DBPropSet); if (hr != S_OK) { if (pbstrResult != NULL) IMT::GetDBErrorString(hr, pbstrResult); } else { TRACE(_T(":::[CDBHistroy_External]-[INSERT] SUCCEEDED :::\n")); } } return hr; }
LRESULT CPropertyEditWindow::OnOK(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) { bool fAllSucceeded = true; for(size_t i = 0; i < m_arrPropertyInfo.GetCount(); i++) { ITedPropertyInfo* pPropertyInfo = m_arrPropertyInfo.GetAt(i); PropertyInfoDisplay* pDisplay = m_arrPropertyInfoDisplay.GetAt(i); for(size_t j = 0; j < pDisplay->m_arrLabels.GetCount(); j++) { VARTYPE vt = pDisplay->m_arrVartypes.GetAt(j); if(vt == VT_EMPTY || vt == VT_UNKNOWN || vt == (VT_VECTOR | VT_UI1)) continue; LPWSTR strName, strValue; // Get label text (property name) int nameLen = pDisplay->m_arrLabels.GetAt(j)->GetWindowTextLength(); strName = new WCHAR[nameLen + 1]; if(NULL == strName) continue; pDisplay->m_arrLabels.GetAt(j)->GetWindowText(strName, nameLen + 1); // Get edit text (property value) int valueLen = pDisplay->m_arrEdits.GetAt(j)->GetWindowTextLength(); strValue = new WCHAR[valueLen + 1]; if(NULL == strValue) { delete[] strName; continue; } pDisplay->m_arrEdits.GetAt(j)->GetWindowText(strValue, valueLen + 1); HRESULT hr = pPropertyInfo->SetProperty((DWORD) j, strName, vt, strValue); if( FAILED(hr) && fAllSucceeded) { CAtlStringW strError; strError.FormatMessage(IDS_E_SAVE_PROP, hr); MessageBox(strError, LoadAtlString(IDS_ERROR), MB_OK); fAllSucceeded = false; } delete[] strName; delete[] strValue; } } return 0; }
HRESULT WpdService::CheckRequestFilename( _In_ LPCWSTR pszRequestFilename) { HRESULT hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND); CAtlStringW strRequestFilename = pszRequestFilename; // For simplicity, the request filename happens to be the same as the service object ID if (strRequestFilename.CompareNoCase(m_pGattService->GetRequestFilename()) == 0) { hr = S_OK; } else { CHECK_HR(hr, "Unknown request filename %ws received", pszRequestFilename); } return hr; }
HRESULT CDBHistory::QueryHistory(HDBCONNECTION hDBConnection, LPCWSTR lpszSerialNum, LPDB_HISTORY_COMMON pRecord, BSTR* pbstrResult) { HRESULT hr = E_FAIL; IMT::CDBConnection* pDBConnection = reinterpret_cast<IMT::CDBConnection*>(hDBConnection); if (pDBConnection != NULL) { ATL::CCommand<ATL::CAccessor<IMT::CDBHistory>> Command; ATL::CDBPropSet _DBPropSet(DBPROPSET_ROWSET); pDBConnection->GetRowsetProperties(&_DBPropSet); CAtlStringW strCommand; CAtlStringW strTemp; strCommand.Format(QUERY_HISTORY_SELECT L" WHERE "); BOOL isExist = FALSE; strTemp.Format(L"SerialNum = '%s'", lpszSerialNum);//L"SerialNum = '%s'", lpszSerial);// strCommand += strTemp; hr = Command.Open(ATL::CSession(*pDBConnection), strCommand, &_DBPropSet); if (hr != S_OK) { if (pbstrResult != NULL) IMT::GetDBErrorString(hr, pbstrResult); } else { TRACE(_T(":::[CDBUser]-[QUERY] SUCCEEDED :::\n")); hr = Command.MoveNext(); if (hr == S_OK) ::CopyMemory(pRecord, LPDB_HISTORY_COMMON(Command), sizeof(DB_HISTORY_COMMON)); } } return hr; }
void CNetRequestImpl::ErrorMessage(LPCTSTR pszFunction) { // Retrieve the system error message for the last-error code LPTSTR pszMessage = NULL; DWORD dwLastError = GetLastError(); DWORD dwLen = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | //FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_FROM_HMODULE| FORMAT_MESSAGE_IGNORE_INSERTS, GetModuleHandle( _T("wininet.dll") ), dwLastError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&pszMessage, 0, NULL ); CAtlStringW strExtError; if ( dwLastError == ERROR_INTERNET_EXTENDED_ERROR ) { DWORD dwInetError =0, dwExtLength = 0; InternetGetLastResponseInfo( &dwInetError, NULL, &dwExtLength ); if ( dwExtLength > 0 ) { InternetGetLastResponseInfo( &dwInetError, strExtError.GetBuffer(dwExtLength+1), &dwExtLength ); strExtError.ReleaseBuffer(); } } rho::LogMessage oLogMsg(__FILE__, __LINE__, L_ERROR, LOGCONF(), getLogCategory() ); oLogMsg + "Call " + pszFunction + " failed. With code : " + dwLastError; if ( pszMessage ) oLogMsg + ".Message: " + pszMessage; if ( strExtError.GetLength() ) oLogMsg + ".Extended info: " + strExtError.GetString(); if ( pszMessage ) LocalFree(pszMessage); }
ACCESS_SCOPE FakeDevice::GetAccessScope( _In_ IPortableDeviceValues* pParams) { ACCESS_SCOPE Scope = FULL_DEVICE_ACCESS; LPWSTR pszFileName = NULL; // For simplicity, our request filename is the same as the the service object ID if (pParams && (pParams->GetStringValue(PRIVATE_SAMPLE_DRIVER_REQUEST_FILENAME, &pszFileName) == S_OK)) { CAtlStringW strRequestFilename = pszFileName; // For simplicity, our request filename is the same as the the service object ID // Case-insensitive comparison is required if (strRequestFilename.CompareNoCase(m_ContactsService.GetRequestFilename()) == 0) { Scope = CONTACTS_SERVICE_ACCESS; } } CoTaskMemFree(pszFileName); return Scope; }
bool CDeviceView::UninstallSelectedDevice( ) { CDeviceNode *Node = dynamic_cast<CDeviceNode *>(GetSelectedNode()); if (Node == nullptr) return false; CAtlStringW str; if (str.LoadStringW(g_hThisInstance, IDS_CONFIRM_UNINSTALL)) { if (MessageBoxW(m_hMainWnd, str, Node->GetDisplayName(), MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2) != IDYES) { return false; } } return Node->UninstallDevice(); }
HRESULT CIIS7XMLConfigHelper::RemoveModuleNodes(IXMLDOMDocument* pDoc, LPCSTR pszModuleName) { if (pDoc == NULL || pszModuleName == NULL) return E_POINTER; CAtlStringW sQuery; sQuery.Format(L"//add[@name='%hs']", pszModuleName); CComBSTR bsQuery(sQuery); CComPtr<IXMLDOMNodeList> pModuleNodes; HRESULT hr = pDoc->selectNodes(bsQuery, &pModuleNodes); if (hr == S_OK) { LONG nModules = 0; hr = pModuleNodes->get_length(&nModules); for (LONG i = 0; i < nModules; i++) { CComPtr<IXMLDOMNode> pModuleNode; hr = pModuleNodes->get_item(i, &pModuleNode); if (hr != S_OK || pModuleNode == NULL) continue; CComPtr<IXMLDOMNode> pParentNode; hr = pModuleNode->get_parentNode(&pParentNode); if (hr != S_OK || pParentNode == NULL) continue; CComPtr<IXMLDOMNode> pTemp; hr = pParentNode->removeChild(pModuleNode, &pTemp); if (hr != S_OK) break; } } return hr; }
HRESULT CDBHistroy_BIT::QueryHistoryBIT_InspRecord(HDBCONNECTION hDBConnection, long l_Index, LPDB_BIT pRecord, BSTR* pbstrResult) { HRESULT hr = E_FAIL; IMT::CDBConnection* pDBConnection = reinterpret_cast<IMT::CDBConnection*>(hDBConnection); if (pDBConnection != NULL) { ATL::CCommand<ATL::CAccessor<IMT::CDBHistroy_BIT>> Command; ATL::CDBPropSet _DBPropSet(DBPROPSET_ROWSET); pDBConnection->GetRowsetProperties(&_DBPropSet); CAtlStringW strCommand; CAtlStringW strTemp; strCommand.Format(QUERY_H_BIT_SELECT L" WHERE Index = %d", l_Index); hr = Command.Open(ATL::CSession(*pDBConnection), strCommand, &_DBPropSet); if (hr != S_OK) { if (pbstrResult != NULL) IMT::GetDBErrorString(hr, pbstrResult); } else { TRACE(_T(":::[CDBHistroy_BIT]-[QUERY] SUCCEEDED :::\n")); hr = Command.MoveNext(); if (hr == S_OK) ::CopyMemory(pRecord, LPDB_BIT(Command), sizeof(DB_BIT)); } } return hr; }
String CNetRequestImpl::makeClientCookie() { DWORD nIndex = 0; String cookie; while(true) { CAtlStringW strCookie; DWORD dwLen = 0; if( !HttpQueryInfo( hRequest, HTTP_QUERY_SET_COOKIE, null, &dwLen, &nIndex) ) { DWORD dwErr = ::GetLastError(); if ( dwErr == ERROR_HTTP_HEADER_NOT_FOUND ) break; if ( dwErr != ERROR_INSUFFICIENT_BUFFER ) { pszErrFunction = L"HttpQueryInfo"; break; } } if( !HttpQueryInfo( hRequest, HTTP_QUERY_SET_COOKIE, strCookie.GetBuffer(dwLen), &dwLen, &nIndex) ) { pszErrFunction = L"HttpQueryInfo"; break; } strCookie.ReleaseBuffer(); URI::parseCookie(common::convertToStringA(strCookie.GetString()).c_str(), cookie); } if (pszErrFunction) return ""; // if ( cookie.strAuth.length() > 0 || cookie.strSession.length() >0 ) // return cookie.strAuth + ";" + cookie.strSession + ";"; return cookie; }
/** * This method is called to populate PROPERTYKEYs found on objects. * * The parameters sent to us are: * wszObjectID - the object whose supported resource keys are being requested * pKeys - An IPortableDeviceKeyCollection to be populated with supported PROPERTYKEYs * * The driver should: * Add PROPERTYKEYs pertaining to the specified object. */ HRESULT WpdObjectResources::GetSupportedResourcesForObject( _In_ LPCWSTR wszObjectID, _In_ IPortableDeviceKeyCollection* pKeys) { HRESULT hr = S_OK; CAtlStringW strObjectID; if ((wszObjectID == NULL) || (pKeys == NULL)) { hr = E_INVALIDARG; return hr; } strObjectID = wszObjectID; if (strObjectID.CompareNoCase(README_FILE_OBJECT_ID) == 0) { hr = pKeys->Add(WPD_RESOURCE_DEFAULT); CHECK_HR(hr, "Failed to set WPD_RESOURCE_DEFAULT"); } return hr; }
void ProcessSolution(UI& ui, const doctor_dump::HaveSolutionResponse& solution) { m_log.Info(_T("Process solution...")); switch (solution.type) { case ns4__HaveSolutionResponse_SolutionType__Url: if (!solution.askConfirmation || ui.AskGetSolution(CSolutionDlg::Read)) { CAtlStringW url = solution.url.c_str(); url.Replace(L"{ClientID}", solution.clientID.c_str()); url.Replace(L"{ProblemID}", ToString(solution.problemID)); url.Replace(L"{DumpGroupID}", ToString(solution.dumpGroupID)); url.Replace(L"{DumpID}", ToString(solution.dumpID)); if (url.Find(L"http://") == 0 || url.Find(L"https://") == 0) ShellExecute(NULL, _T("open"), CW2CT(url), NULL, NULL, SW_SHOWNORMAL); } break; #ifdef REMOTE_CODE_DOWNLOAD_AND_EXECUTION case ns4__HaveSolutionResponse_SolutionType__Exe: if (!solution.askConfirmation || ui.AskGetSolution(CSolutionDlg::Install)) { CAtlFile hFile(CreateFile(m_patch, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL)); if (hFile == INVALID_HANDLE_VALUE) throw runtime_error("failed to create solution.exe file"); if (FAILED(hFile.Write(&solution.exe[0], static_cast<DWORD>(solution.exe.size())))) throw runtime_error("failed to write solution.exe file"); hFile.Close(); STARTUPINFO si = {}; si.cb = sizeof(si); PROCESS_INFORMATION pi = {}; if (!CreateProcess(NULL, m_patch.GetBuffer(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) throw runtime_error("failed to start solution.exe"); CloseHandle(pi.hThread); CloseHandle(pi.hProcess); } break; #endif default: throw runtime_error("Unknown SolutionType"); } }
void CVisualNode::Draw(CVisualDrawContext & Ctx) { RECT rect; size_t n; Ctx.SelectSmallFont(); if(IsSelected()) { Ctx.SelectPen(m_clrSelectedBorder, 2); } else { Ctx.SelectPen(m_clrLine, 1); } // select colors Ctx.SelectSolidBrush(m_clrFill); // draw rect Ctx.MapRect(m_Rect, rect); Rectangle(Ctx.DC(), rect.left, rect.top, rect.right, rect.bottom); if(!m_strLabel.IsEmpty()) { COLORREF oldColor = SetTextColor(Ctx.DC(), m_clrLine); Ctx.SelectSolidBrush(RGB(0, 0, 0)); SetBkColor(Ctx.DC(), m_clrFill); rect.left += 5; rect.right -= 5; rect.top +=5; DrawText(Ctx.DC(), m_strLabel, m_strLabel.GetLength(), &rect, DT_WORDBREAK); SetTextColor(Ctx.DC(), oldColor); } if(m_fTopoError) { COLORREF oldColor = SetTextColor(Ctx.DC(), m_clrErrorText); rect.top += 10; CAtlStringW errString = LoadAtlString(IDS_E_TOPO_RESOLUTION); DrawText(Ctx.DC(), errString, errString.GetLength(), &rect, DT_WORDBREAK); SetTextColor(Ctx.DC(), oldColor); } Ctx.PushState(); Ctx.ShiftCoordinates(m_Rect.x(), m_Rect.y()); // draw pins for(n = 0; n < m_InputPins.GetCount(); n++) { m_InputPins.GetAt(n)->Draw(Ctx); } for(n = 0; n < m_OutputPins.GetCount(); n++) { m_OutputPins.GetAt(n)->Draw(Ctx); } Ctx.PopState(); Ctx.DeselectSmallFont(); }
HRESULT CDBHistory::QueryHistory_InspectionRecord(HDBCONNECTION hDBConnection, SYSTEMTIME sysTimeFrom, SYSTEMTIME sysTimeTo, long l_LRUIndex, LPCWSTR lpszSerial, long lResult, LPCWSTR lpszUserID, long l_Index, LPDB_HISTORY_COMMON pRecord, BSTR* pbstrResult) { HRESULT hr = E_FAIL; IMT::CDBConnection* pDBConnection = reinterpret_cast<IMT::CDBConnection*>(hDBConnection); if (pDBConnection != NULL) { ATL::CCommand<ATL::CAccessor<IMT::CDBHistory>> Command; ATL::CDBPropSet _DBPropSet(DBPROPSET_ROWSET); pDBConnection->GetRowsetProperties(&_DBPropSet); CAtlStringW strCommand; CAtlStringW strTemp; strCommand.Format(QUERY_USER_BY_VALID_CONDITIONS, sysTimeFrom.wYear, sysTimeFrom.wMonth, sysTimeFrom.wDay, sysTimeTo.wYear, sysTimeTo.wMonth, sysTimeTo.wDay); BOOL isExist = FALSE; strTemp = strCommand; strCommand += L"AND "; if(l_LRUIndex != 0) { strTemp.Format(L"(LRU_Index = %d) ", l_LRUIndex); strCommand += strTemp; strTemp = strCommand; strCommand += L"AND "; } else TRACE(L""); if(::lstrcmpi(lpszSerial, L"Àüü") != 0) { strTemp.Format(L"(SerialNum = '%s') ", lpszSerial); strCommand += strTemp; strTemp = strCommand; strCommand += L"AND "; } else TRACE(L""); if(lResult != dfRESULT_ALL) { strTemp.Format(L"(State = %d) ", lResult); strCommand += strTemp; strTemp = strCommand; strCommand += L"AND "; } else TRACE(L""); if(::lstrcmpi(lpszUserID, L"Àüü") != 0) { strTemp.Format(L"(User = '******') ", lpszUserID); strCommand += strTemp; strTemp = strCommand; strCommand += L"AND "; } else TRACE(L""); if(::lstrcmpi(strCommand.Right(4), L"AND ") == 0) { strCommand = strTemp; } else TRACE(L""); hr = Command.Open(ATL::CSession(*pDBConnection), strCommand, &_DBPropSet); if (hr != S_OK) { if (pbstrResult != NULL) IMT::GetDBErrorString(hr, pbstrResult); } else { TRACE(_T(":::[CDBHistory]-[QUERY] SUCCEEDED :::\n")); for(long i = 0; i < l_Index; i++) { hr = Command.MoveNext(); } if (hr == S_OK) ::CopyMemory(pRecord, LPDB_HISTORY_COMMON(Command), sizeof(DB_HISTORY_COMMON)); } } return hr; }
CAtlStringW ToString(int n) { CAtlStringW result; result.Format(L"%i", n); return result; }
void CDeviceView::BuildActionMenuForNode( _In_ HMENU OwnerMenu, _In_ CNode *Node, _In_ bool MainMenu ) { // Create a seperator structure MENUITEMINFOW MenuSeperator = { 0 }; MenuSeperator.cbSize = sizeof(MENUITEMINFOW); MenuSeperator.fType = MFT_SEPARATOR; // Setup the MENUITEMINFOW MenuItemInfo = { 0 }; MenuItemInfo.cbSize = sizeof(MENUITEMINFOW); MenuItemInfo.fMask = MIIM_ID | MIIM_STRING | MIIM_DATA | MIIM_SUBMENU; MenuItemInfo.fType = MFT_STRING; CAtlStringW String; int i = 0; // Device nodes have extra data if (Node->GetNodeType() == DeviceNode) { CDeviceNode *DeviceNode = dynamic_cast<CDeviceNode *>(Node); if (DeviceNode->CanUpdate()) { String.LoadStringW(g_hThisInstance, IDS_MENU_UPDATE); MenuItemInfo.wID = IDC_UPDATE_DRV; MenuItemInfo.dwTypeData = String.GetBuffer(); InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo); i++; } if (DeviceNode->IsDisabled()) { String.LoadStringW(g_hThisInstance, IDS_MENU_ENABLE); MenuItemInfo.wID = IDC_ENABLE_DRV; MenuItemInfo.dwTypeData = String.GetBuffer(); InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo); i++; } if (DeviceNode->CanDisable() && !DeviceNode->IsDisabled()) { String.LoadStringW(g_hThisInstance, IDS_MENU_DISABLE); MenuItemInfo.wID = IDC_DISABLE_DRV; MenuItemInfo.dwTypeData = String.GetBuffer(); InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo); i++; } if (DeviceNode->CanUninstall()) { String.LoadStringW(g_hThisInstance, IDS_MENU_UNINSTALL); MenuItemInfo.wID = IDC_UNINSTALL_DRV; MenuItemInfo.dwTypeData = String.GetBuffer(); InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo); i++; } InsertMenuItemW(OwnerMenu, i, TRUE, &MenuSeperator); i++; } // All nodes have the scan option String.LoadStringW(g_hThisInstance, IDS_MENU_SCAN); MenuItemInfo.wID = IDC_SCAN_HARDWARE; MenuItemInfo.dwTypeData = String.GetBuffer(); InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo); i++; if ((Node->GetNodeType() == RootNode) || (MainMenu == true)) { String.LoadStringW(g_hThisInstance, IDS_MENU_ADD); MenuItemInfo.wID = IDC_ADD_HARDWARE; MenuItemInfo.dwTypeData = String.GetBuffer(); InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo); i++; } if (Node->HasProperties()) { InsertMenuItemW(OwnerMenu, i, TRUE, &MenuSeperator); i++; String.LoadStringW(g_hThisInstance, IDS_MENU_PROPERTIES); MenuItemInfo.wID = IDC_PROPERTIES; MenuItemInfo.dwTypeData = String.GetBuffer(); InsertMenuItemW(OwnerMenu, i, TRUE, &MenuItemInfo); i++; SetMenuDefaultItem(OwnerMenu, IDC_PROPERTIES, FALSE); } }
bool Process(Params& params) { HANDLE hProcess = params.Process; DWORD dwProcessId = params.ProcessId; MINIDUMP_EXCEPTION_INFORMATION* pExceptInfo = ¶ms.ExceptInfo; bool wasAssert = !!params.WasAssert; m_dumpWriter.Init(m_config.DbgHelpPath); // we need to get CrashInfo before writing the dumps, since dumps writing will change WorkingSet m_crashInfo.reset(new CrashInfo(hProcess)); InitPathes(); UI ui(m_config); ui.ShowInitialProgressWindow(wasAssert); PrepareMiniDump(hProcess, dwProcessId, pExceptInfo); if (m_config.ServiceMode) { PrepareFullDump(hProcess, dwProcessId, pExceptInfo, true); TerminateProcess(hProcess, E_FAIL); // It is necessary for DUMPPARSER to terminate app, because it should process our dump, and it could not do it since it crashes. CloseHandle(hProcess); hProcess = NULL; } doctor_dump::Application app; app.applicationGUID = m_config.ApplicationGUID; app.v[0] = m_config.V[0]; app.v[1] = m_config.V[1]; app.v[2] = m_config.V[2]; app.v[3] = m_config.V[3]; app.hotfix = m_config.Hotfix; app.processName = m_config.ProcessName; m_log.Info(_T("App %d.%d.%d.%d %ls"), app.v[0], app.v[1], app.v[2], app.v[3], app.applicationGUID); doctor_dump::DumpAdditionalInfo addInfo; addInfo.crashDate = time(NULL); addInfo.PCID = GetUserPCID(); addInfo.submitterID = m_config.SubmitterID; addInfo.group = CA2W(params.Group); addInfo.description = m_config.CustomInfo; std::unique_ptr<doctor_dump::Response> response = m_dumpUploader.Hello(app, (LPCWSTR)m_config.AppName, (LPCWSTR)m_config.Company, addInfo); while (1) { switch (response->GetResponseType()) { case doctor_dump::Response::HaveSolutionResponseType: ProcessSolution(ui, static_cast<doctor_dump::HaveSolutionResponse&>(*response)); goto finish; case doctor_dump::Response::NeedMiniDumpResponseType: response = m_dumpUploader.UploadMiniDump(response->context, app, addInfo, (LPCWSTR)m_miniDumpZipFile); break; case doctor_dump::Response::NeedFullDumpResponseType: if (!ui.AskSendFullDump()) { response = m_dumpUploader.RejectedToSendAdditionalInfo(response->context, app, response->dumpID); break; } ui.ShowFullDumpUploadProgressWindow(); if (!m_config.ServiceMode) { auto& resp = static_cast<doctor_dump::NeedFullDumpResponse&>(*response); m_config.FullDumpType = m_config.FullDumpType & (~resp.restrictedDumpType); PrepareFullDump(hProcess, dwProcessId, pExceptInfo, resp.attachUserInfo); CloseHandle(hProcess); hProcess = NULL; } SetEvent(params.ReportReady); response = m_dumpUploader.UploadFullDump(response->context, app, response->dumpID, (LPCWSTR)m_fullDumpZipFile, &ui); break; case doctor_dump::Response::NeedMoreInfoResponseType: if (!ui.AskSendFullDump()) { response = m_dumpUploader.RejectedToSendAdditionalInfo(response->context, app, response->dumpID); break; } ui.ShowFullDumpUploadProgressWindow(); PrepareAdditionalInfo(static_cast<doctor_dump::NeedMoreInfoResponse&>(*response), hProcess, dwProcessId); response = m_dumpUploader.UploadAdditionalInfo(response->context, app, response->dumpID, (LPCWSTR)m_infoFile, &ui); break; case doctor_dump::Response::ErrorResponseType: throw runtime_error((const char*)CW2A(static_cast<doctor_dump::ErrorResponse&>(*response).error.c_str())); case doctor_dump::Response::StopResponseType: default: goto finish; } } finish: if (!m_config.ServiceMode && !response->urlToProblem.empty() && m_config.OpenProblemInBrowser) { CAtlStringW url = response->urlToProblem.c_str(); if (url.Find(L"http://") == 0 || url.Find(L"https://") == 0) ShellExecuteW(NULL, _T("open"), url, NULL, NULL, SW_SHOWNORMAL); } return true; }
/** * This method is called when we receive a WPD_COMMAND_OBJECT_RESOURCES_OPEN * command. * * The parameters sent to us are: * - WPD_PROPERTY_OBJECT_RESOURCES_OBJECT_ID: the object identifier of the * object which contains the specified resource * * - WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_KEYS: the specified resource * to open * * - WPD_PROPERTY_OBJECT_RESOURCES_ACCESS_MODE: the access mode to which to * open the specified resource * * The driver should: * - Create a new context for this resource operation. * - Return an identifier for the context in WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT. * - Set the optimal transfer size in WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE * */ HRESULT WpdObjectResources::OnOpenResource( _In_ IPortableDeviceValues* pParams, _In_ IPortableDeviceValues* pResults) { HRESULT hr = S_OK; LPWSTR wszObjectID = NULL; PROPERTYKEY Key = WPD_PROPERTY_NULL; DWORD dwMode = STGM_READ; CAtlStringW strStrObjectID; CAtlStringW strResourceContext; ContextMap* pContextMap = NULL; // Get the Object identifier of the object which contains the specified resource hr = pParams->GetStringValue(WPD_PROPERTY_OBJECT_RESOURCES_OBJECT_ID, &wszObjectID); if (hr != S_OK) { hr = E_INVALIDARG; CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_RESOURCES_OBJECT_ID"); } // Get the resource key if (hr == S_OK) { hr = pParams->GetKeyValue(WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_KEYS, &Key); CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_RESOURCES_RESOURCE_KEYS"); } // Get the access mode if (hr == S_OK) { hr = pParams->GetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_RESOURCES_ACCESS_MODE, &dwMode); CHECK_HR(hr, "Missing value for WPD_PROPERTY_OBJECT_RESOURCES_ACCESS_MODE"); } // Validate whether the params given to us are correct. In this case, we need to check that the object // supports the resource requested, and can be opened in the requested access mode. if (hr == S_OK) { // In this sample, we only have one object (README_FILE_OBJECT_ID) which supports a // resource (WPD_RESOURCE_DEFAULT) for reading only. // So if any other Object ID or any other resource is specified, it must be invalid. strStrObjectID = wszObjectID; if(strStrObjectID.CompareNoCase(README_FILE_OBJECT_ID) != 0) { hr = E_INVALIDARG; CHECK_HR(hr, "Object [%ws] does not support resources", wszObjectID); } if (hr == S_OK) { if (!IsEqualPropertyKey(Key, WPD_RESOURCE_DEFAULT)) { hr = E_INVALIDARG; CHECK_HR(hr, "Only WPD_RESOURCE_DEFAULT is supported in this sample driver"); } } if (hr == S_OK) { if ((dwMode & STGM_WRITE) != 0) { hr = E_ACCESSDENIED; CHECK_HR(hr, "This resource is not available for write access"); } } } // Get the context map which the driver stored in pParams for convenience if (hr == S_OK) { hr = pParams->GetIUnknownValue(PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP, (IUnknown**)&pContextMap); CHECK_HR(hr, "Failed to get PRIVATE_SAMPLE_DRIVER_CLIENT_CONTEXT_MAP"); } // Create a new resource operation context, initialize it, and add it to the client context map. if (hr == S_OK) { WpdObjectResourceContext* pResourceContext = new WpdObjectResourceContext(); if (pResourceContext != NULL) { // Initialize the resource context with ... pResourceContext->m_strObjectID = wszObjectID; pResourceContext->m_Resource = Key; pResourceContext->m_BytesTransferred = 0; pResourceContext->m_BytesTotal = GetObjectSize(wszObjectID); // Add the resource context to the context map pContextMap->Add(pResourceContext, strResourceContext); // Release the resource context because it has been AddRef'ed during Add() SAFE_RELEASE(pResourceContext); } else { hr = E_OUTOFMEMORY; CHECK_HR(hr, "Failed to allocate resource context"); } } if (hr == S_OK) { hr = pResults->SetStringValue(WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT, strResourceContext); CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_RESOURCES_CONTEXT"); } // Set the optimal buffer size if (hr == S_OK) { hr = pResults->SetUnsignedIntegerValue(WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE, FILE_OPTIMAL_READ_BUFFER_SIZE_VALUE); CHECK_HR(hr, "Failed to set WPD_PROPERTY_OBJECT_RESOURCES_OPTIMAL_TRANSFER_BUFFER_SIZE value"); } // Free the memory. CoTaskMemFree ignores NULLs so no need to check. CoTaskMemFree(wszObjectID); SAFE_RELEASE(pContextMap); return hr; }
/** * This method is called to populate resource attributes found on a particular object * resource. * * The parameters sent to us are: * wszObjectID - the object whose resource attributes are being requested * Key - the resource on the specified object whose attributes are being returned * pAttributes - An IPortableDeviceValues to be populated with resource attributes. * * The driver should: * Add attributes pertaining to the resource on the specified object. */ HRESULT WpdObjectResources::GetResourceAttributesForObject( _In_ LPCWSTR wszObjectID, _In_ REFPROPERTYKEY Key, _In_ IPortableDeviceValues* pAttributes) { HRESULT hr = S_OK; CAtlStringW strObjectID; if ((wszObjectID == NULL) || (pAttributes == NULL)) { hr = E_INVALIDARG; return hr; } strObjectID = wszObjectID; if ((strObjectID.CompareNoCase(README_FILE_OBJECT_ID) == 0) && (IsEqualPropertyKey(Key, WPD_RESOURCE_DEFAULT))) { if (hr == S_OK) { hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_DELETE, FALSE); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_DELETE"); } if (hr == S_OK) { hr = pAttributes->SetUnsignedLargeIntegerValue(WPD_RESOURCE_ATTRIBUTE_TOTAL_SIZE, GetObjectSize(strObjectID)); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_TOTAL_SIZE"); } if (hr == S_OK) { hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_READ, TRUE); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_READ"); } if (hr == S_OK) { hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_WRITE, FALSE); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_WRITE"); } if (hr == S_OK) { hr = pAttributes->SetBoolValue(WPD_RESOURCE_ATTRIBUTE_CAN_DELETE, FALSE); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_CAN_DELETE"); } if (hr == S_OK) { hr = pAttributes->SetGuidValue(WPD_RESOURCE_ATTRIBUTE_FORMAT, GetObjectFormat(strObjectID)); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_FORMAT"); } if (hr == S_OK) { hr = pAttributes->SetUnsignedIntegerValue(WPD_RESOURCE_ATTRIBUTE_OPTIMAL_READ_BUFFER_SIZE, FILE_OPTIMAL_READ_BUFFER_SIZE_VALUE); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_OPTIMAL_READ_BUFFER_SIZE"); } if (hr == S_OK) { hr = pAttributes->SetUnsignedIntegerValue(WPD_RESOURCE_ATTRIBUTE_OPTIMAL_WRITE_BUFFER_SIZE, FILE_OPTIMAL_WRITE_BUFFER_SIZE_VALUE); CHECK_HR(hr, "Failed to set WPD_RESOURCE_ATTRIBUTE_OPTIMAL_WRITE_BUFFER_SIZE"); } } return hr; }