ChEXPORT void WrdStringTable::appendString (const ChCHAR2* in_pData, ChUINT2 in_unNumberOfCharacters, ChWriter* pOverwriteInfo) { ChAutoPtr<CsString> pString(ChNEW CsString); pString->append(in_pData, in_unNumberOfCharacters); pString->SetOverwriteInfo(pOverwriteInfo); m_strings.push_back(pString.get()); pString.giveUpOwnership(); }
pString Result::get_summary() const { io::pNode opt_summary = _data->find_node("summary"); if (!opt_summary) { return pString(); } else { return opt_summary->to_string(); } }
ChEXPORT WrdStringTable& WrdStringTable::operator= (const WrdStringTable& rhs) { cleanup(); for (ChUINT4 i = 0; i < rhs.m_strings.size(); ++i) { ChAutoPtr<CsString> pString(ChNEW CsString); *pString = *rhs.m_strings[i]; m_strings.push_back(pString.get()); pString.giveUpOwnership(); } return *this; }
int WPSRegistrar::ProcessDone() { uint32 err; err = g_regProtocol.ProcessMessageDone(&m_regInfo, m_msgBuffer ); if(WSC_SUCCESS != err) { return err_process_Done; } printf("\n***** Successfully processed Message Done\n"); if (m_regInfo.p_enrolleeInfo) { WPSDeviceWasAuthenticated(* ((GUID*) & (m_regInfo.p_enrolleeInfo->uuid))); } //****** Derivation of UPnP Protected Setup AuthKey and KeyWrapKey ****** //1. declare and initialize the appropriate buffer objects BufferObj kdkBuf(m_regInfo.emsk.GetBuf(), SIZE_256_BITS); BufferObj pString((uint8 *)UPNP_PERSONALIZATION_STRING, strlen(UPNP_PERSONALIZATION_STRING)); BufferObj keys; //2. call the key derivation function g_regProtocol.DeriveKey(kdkBuf, pString, 256 + 128, keys); //3. split the key into the component keys and store them keys.Rewind(keys.Length()); m_regInfo.UPnPPSauthKey.Reset(); m_regInfo.UPnPPSkeyWrapKey.Reset(); m_regInfo.UPnPPSauthKey.Append(SIZE_256_BITS, keys.Pos()); keys.Advance(SIZE_256_BITS); m_regInfo.UPnPPSkeyWrapKey.Append(SIZE_128_BITS, keys.Pos()); // **** End of key derivation code return init; }
/** * Adds a std::string value to the parameter map. * @param comp :: Component to which the new parameter is related * @param name :: Name for the new parameter * @param value :: Parameter value * @param pDescription :: a pointer (may be NULL) to a string, containing * parameter's * description. If provided, the contents of the string is copied to the * parameter's * memory */ void ParameterMap::addString(const IComponent *comp, const std::string &name, const std::string &value, const std::string *const pDescription) { add<std::string>(pString(), comp, name, value, pDescription); }
BOOL CSocketThreadManager::SpawnThreads(LPCSTR lpClassName) { try { //Add to this class our thread ID, and a random number if (!lpClassName) { //Calculate our string int iStringLength; iStringLength=strlen(CSocketThreadManager_Class); //Add some size to it iStringLength+=50; //Allocate the string std::auto_ptr<char> pString(new char[iStringLength]); //Get our thread ID DWORD dwThreadID; dwThreadID=GetCurrentThreadId(); //Get the tick of the system DWORD dwProcessID; dwProcessID=GetTickCount(); //Create the string sprintf(pString.get(),"%s_%lu_%lu",CSocketThreadManager_Class, GetCurrentThreadId(), GetTickCount()); //And register the window //Check if we need to register the class if (!m_bRegisteredWindow) if (!RegisterClass(pString.get())) { //Report it ReportError("SpawnThreads","Failed to register window!"); //And quit return FALSE; } //Save the class name m_sClassName=pString.get(); } else m_sClassName=lpClassName; //Start creating threads //Allocate the thread structure m_pThreadData=new ThreadData[m_ulThreadCount]; //Initialize the data for (int iCount=0;iCount<m_ulThreadCount;++iCount) { m_pThreadData[iCount].bFreeze=FALSE; m_pThreadData[iCount].pEvent=NULL; m_pThreadData[iCount].hInstance=NULL; m_pThreadData[iCount].hWindowHandle=NULL; m_pThreadData[iCount].iSocketCount=0; m_pThreadData[iCount].iTimeoutCount=0; m_pThreadData[iCount].pThread=NULL; m_pThreadData[iCount].pCSection=COSManager::CreateCriticalSection(); m_pThreadData[iCount].pClass=this; } //Did we have an error? BOOL bError; bError=FALSE; //Our waiting list CWaitList aList; //Start spawning for (int iCounter=0; iCounter<m_ulThreadCount; ++iCounter) { //Copy the class name m_pThreadData[iCounter].sClassName=m_sClassName; //Create an event m_pThreadData[iCounter].pEvent=COSManager::CreateEvent(); //Add it to the list aList.AddObject(m_pThreadData[iCounter].pEvent, TRUE); //Set our instance m_pThreadData[iCounter].hInstance=m_hInstance; //Create extended data CreateExtendedData(m_pThreadData[iCounter].aExtension); //And create it m_pThreadData[iCounter].pThread=COSManager::CreateThread(SocketThread); //Check the thread has been created if (!m_pThreadData[iCounter].pThread->GetThreadID()) { //Report the error ReportError("SpawnThreads","Failed to create thread!"); //We have an error bError=TRUE; //Exit the loop break; } else //Start the thread m_pThreadData[iCounter].pThread->Start((LPVOID)&m_pThreadData[iCounter]); } //Tmp position DWORD dwTmp; if (aList.Wait(TRUE, dwTmp, THREADS_TIMEOUT)) { //Report the error ReportError("SpawnThreads","Timeout waiting for threads!"); //Close the threads CleanThreads(TRUE); //Exit return FALSE; } else if (bError) { //Close the threads CleanThreads(FALSE); //Exit return FALSE; } else { //We are OK m_bInitialized=TRUE; //Done return TRUE; } } ERROR_HANDLER_RETURN("SpawnThreads",FALSE) }