int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR szCmdLine, int iCmdShow) { DBG_UNREFERENCED_PARAMETER(szCmdLine); DBG_UNREFERENCED_PARAMETER(hPrevInstance); g_hMainInstance = hInstance; // Initialize common controls InitCommonControls(); if (!CreateConsoleWindow()) { MessageBox(NULL, L"Cannot create console window.", L"Warning", MB_OK | MB_ICONWARNING); } INT_PTR iptr = DialogBox(hInstance, MAKEINTRESOURCE(IDD_DLG_FDIFF), NULL, FolderDiffDP); if (iptr == -1) { DWORD dw = GetLastError(); MessageBox(NULL, L"Cannot create dialog box.", L"Error", MB_OK | MB_ICONERROR); DebugBreak(); } return 0; }
int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nCmdShow) { DBG_UNREFERENCED_PARAMETER(hPrevInstance); DBG_UNREFERENCED_PARAMETER(lpCmdLine); DBG_UNREFERENCED_PARAMETER(nCmdShow); #ifdef _DEBUG ID3D11Debug *debugInterface = nullptr; #endif // Force scope so we can guarantee the destructor is called before we try to use ReportLiveDeviceObjects { PBRDemo::PBRDemo app(hInstance); app.Initialize(L"Physically Based Rendering Demo", 1280, 720, false); #ifdef _DEBUG app.CreateDebugInterface(&debugInterface); #endif app.Run(); app.Shutdown(); } #ifdef _DEBUG debugInterface->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL); ReleaseCOM(debugInterface); #endif return 0; }
NTSTATUS SamGetDisplayEnumerationIndex ( IN SAM_HANDLE DomainHandle, IN DOMAIN_DISPLAY_INFORMATION DisplayInformation, IN PUNICODE_STRING Prefix, OUT PULONG Index ) /*++ Routine Description: This routine returns the index of the entry which alphabetically immediatly preceeds a specified prefix. If no such entry exists, then zero is returned as the index. Parameters: DomainHandle - A handle to an open domain for DOMAIN_LIST_ACCOUNTS. DisplayInformation - Indicates which sorted information class is to be searched. Prefix - The prefix to compare. Index - Receives the index of the entry of the information class with a LogonName (or MachineName) which immediatly preceeds the provided prefix string. If there are no elements which preceed the prefix, then zero is returned. Return Values: STATUS_SUCCESS - normal, successful completion. STATUS_ACCESS_DENIED - The specified handle was not opened for the necessary access. STATUS_INVALID_HANDLE - The specified handle is not that of an opened Domain object. --*/ { (*Index) = 0; return(STATUS_SUCCESS); DBG_UNREFERENCED_PARAMETER(DomainHandle); DBG_UNREFERENCED_PARAMETER(DisplayInformation); DBG_UNREFERENCED_PARAMETER(Prefix); }
INT APIENTRY NtGdiAddFontResourceW( IN WCHAR *pwcFiles, IN ULONG cwc, IN ULONG cFiles, IN FLONG fl, IN DWORD dwPidTid, IN OPTIONAL DESIGNVECTOR *pdv) { UNICODE_STRING SafeFileName; INT Ret; DBG_UNREFERENCED_PARAMETER(cFiles); DBG_UNREFERENCED_PARAMETER(dwPidTid); DBG_UNREFERENCED_PARAMETER(pdv); /* cwc = Length + trailing zero. */ if (cwc <= 1 || cwc > UNICODE_STRING_MAX_CHARS) return 0; SafeFileName.MaximumLength = cwc * sizeof(WCHAR); SafeFileName.Length = SafeFileName.MaximumLength - sizeof(UNICODE_NULL); SafeFileName.Buffer = ExAllocatePoolWithTag(PagedPool, SafeFileName.MaximumLength, TAG_STRING); if (!SafeFileName.Buffer) { return 0; } _SEH2_TRY { ProbeForRead(pwcFiles, cwc * sizeof(WCHAR), sizeof(WCHAR)); RtlCopyMemory(SafeFileName.Buffer, pwcFiles, SafeFileName.Length); } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) { ExFreePoolWithTag(SafeFileName.Buffer, TAG_STRING); _SEH2_YIELD(return 0); } _SEH2_END; SafeFileName.Buffer[SafeFileName.Length / sizeof(WCHAR)] = UNICODE_NULL; Ret = IntGdiAddFontResource(&SafeFileName, fl); ExFreePoolWithTag(SafeFileName.Buffer, TAG_STRING); return Ret; }
// FindIAT_InText() // Find the starting address - virtual address and file pointer - and the // size of the IAT within the .text section if present. BOOL FindIAT_InText(HANDLE hFileBase, IMAGE_NT_HEADERS *pNTHeader, __out NONCODE_LOC *pNonCodeBlocks) { ASSERT(hFileBase != NULL); ASSERT(pNTHeader != NULL && pNonCodeBlocks != NULL); DBG_UNREFERENCED_PARAMETER(hFileBase); DBG_UNREFERENCED_PARAMETER(pNTHeader); DBG_UNREFERENCED_PARAMETER(pNonCodeBlocks); // first find the virtual address and size of the imports section // from the DataDirectory //IMAGE_THUNK_DATA return TRUE; }// FindIAT_InText()
/* This entry point is called on DLL initialisation. * We need to know the module handle so we can load resources. */ BOOL InitializeDll( IN PVOID hmod, IN DWORD Reason, IN PCONTEXT pctx OPTIONAL) { DBG_UNREFERENCED_PARAMETER(pctx); switch (Reason) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls((HMODULE)hmod); hInst = hmod; if (!WPCInit()) return FALSE; break; case DLL_PROCESS_DETACH: WPCDone(); break; } return TRUE; }
void CMinotaurIdle::Exit(CMinotaur* _agent) { DBG_UNREFERENCED_PARAMETER(_agent); m_fWaitTimer = 0; _agent->GetCurrAnimation().SetScale(1.0f); }
BOOL fRemoveThread(CHL_HTABLE *phtThreads, DWORD dwThreadId, __out LPCREATE_THREAD_DEBUG_INFO lpThreadInfo) { ASSERT(phtThreads); DBG_UNREFERENCED_PARAMETER(lpThreadInfo); return fChlDsRemoveHT(phtThreads, &dwThreadId, sizeof(DWORD)); }
intptr_t __cdecl _cwait ( int *stat_loc, intptr_t process_id, int action_code ) { intptr_t retval; int retstatus; unsigned long oserror; DBG_UNREFERENCED_PARAMETER(action_code); /* Explicitly check for process_id being -1 or -2. In Windows NT, * -1 is a handle on the current process, -2 is a handle on the * current thread, and it is perfectly legal to to wait (forever) * on either */ if ( (process_id == -1) || (process_id == -2) ) { errno = ECHILD; return -1; } /* wait for child process, then fetch its exit code */ if ( (WaitForSingleObject((HANDLE)process_id, (DWORD)(-1L)) == 0) && GetExitCodeProcess((HANDLE)process_id, (LPDWORD)&retstatus) ) { retval = process_id; } else { /* one of the API calls failed. map the error and set up to return failure. note the invalid handle error is mapped in- line to ECHILD */ if ( (oserror = GetLastError()) == ERROR_INVALID_HANDLE ) { errno = ECHILD; _doserrno = oserror; } else _dosmaperr(GetLastError()); retval = -1; retstatus = -1; } CloseHandle((HANDLE)process_id); if (stat_loc != NULL) *stat_loc = retstatus; return retval; }
NTSTATUS SamQueryDisplayInformation ( IN SAM_HANDLE DomainHandle, IN DOMAIN_DISPLAY_INFORMATION DisplayInformation, IN ULONG Index, IN ULONG PreferredMaximumLength, OUT PULONG TotalAvailable, OUT PULONG TotalReturned, OUT PULONG ReturnedEntryCount, OUT PVOID *SortedBuffer ) /*++ Routine Description: This routine provides fast return of information commonly needed to be displayed in user interfaces. NT User Interface has a requirement for quick enumeration of SAM accounts for display in list boxes. (Replication has similar but broader requirements.) The netui listboxes all contain similar information. That is: o AccountControl, the bits that identify the account type, eg, HOME, REMOTE, SERVER, WORKSTATION, etc. o Logon name (machine name for computers) o Full name (not used for computers) o Comment (admin comment for users) SAM maintains this data locally in two sorted indexed cached lists identified by infolevels. o DomainDisplayUser: HOME and REMOTE user accounts only o DomainDisplayMachine: SERVER and WORKSTATION accounts only Note that trust accounts, groups, and aliases are not in either of these lists. Parameters: DomainHandle - A handle to an open domain for DOMAIN_LIST_ACCOUNTS. DisplayInformation - Indicates which information is to be enumerated. Index - The index of the first entry to be retrieved. PreferedMaximumLength - A recommended upper limit to the number of bytes to be returned. The returned information is allocated by this routine. TotalAvailable - Total number of bytes availabe in the specified info class. TotalReturned - Number of bytes actually returned for this call. Zero indicates there are no entries with an index as large as that specified. ReturnedEntryCount - Number of entries returned by this call. Zero indicates there are no entries with an index as large as that specified. SortedBuffer - Receives a pointer to a buffer containing a sorted list of the requested information. This buffer is allocated by this routine and contains the following structure: DomainDisplayMachine --> An array of ReturnedEntryCount elements of type DOMAIN_DISPLAY_USER. This is followed by the bodies of the various strings pointed to from within the DOMAIN_DISPLAY_USER structures. DomainDisplayMachine --> An array of ReturnedEntryCount elements of type DOMAIN_DISPLAY_MACHINE. This is followed by the bodies of the various strings pointed to from within the DOMAIN_DISPLAY_MACHINE structures. Return Values: STATUS_SUCCESS - normal, successful completion. STATUS_ACCESS_DENIED - The specified handle was not opened for the necessary access. STATUS_INVALID_HANDLE - The specified handle is not that of an opened Domain object. STATUS_INVALID_INFO_CLASS - The requested class of information is not legitimate for this service. --*/ { // if ((DisplayInformation != DomainDisplayUser) && // (DisplayInformation != DomainDisplayMachine) ) { // return( STATUS_INVALID_INFO_CLASS ); // // } SampBuildDummyAccounts( DisplayInformation, Index, TotalAvailable, TotalReturned, ReturnedEntryCount, SortedBuffer); return(STATUS_SUCCESS); DBG_UNREFERENCED_PARAMETER(DomainHandle); DBG_UNREFERENCED_PARAMETER(PreferredMaximumLength); }
VOID SoundInDeferred( IN PKDPC pDpc, IN OUT PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp, IN PVOID Context ) /*++ Routine Description: Dpc routine for wave input device Collect the data from the DMA buffer and pass it to the application's buffer(s). Arguments: Return Value: None. --*/ { PLOCAL_DEVICE_INFO pLDI; PGLOBAL_DEVICE_INFO pGDI; pLDI = (PLOCAL_DEVICE_INFO)pDeviceObject->DeviceExtension; pGDI = pLDI->pGlobalInfo; // // Acquire the spin lock before we mess with the list // GlobalEnter(pGDI); // // Fill in any buffers we can // dprintf4(pGDI->NextHalf == LowerHalf ? "dpc():L" : "dpc():U"); // // Zero bytes taken out of new buffer // if( pGDI->DMABuffer[pGDI->NextHalf].nBytes == DMA_BUFFER_SIZE / 2) pGDI->DMABuffer[pGDI->NextHalf].nBytes = 0; // // Request input without posting the last buffer // sndFlush(pGDI, pGDI->NextHalf); sndFillInputBuffers(pLDI, pGDI->NextHalf); // // Restart this buffer's DMA // sndReStartDMA(pGDI, pGDI->NextHalf); // // Move on to next half // pGDI->NextHalf = UpperHalf + LowerHalf - pGDI->NextHalf; // // Release the spin lock // GlobalLeave(pGDI); return; DBG_UNREFERENCED_PARAMETER(pDpc); DBG_UNREFERENCED_PARAMETER(Context); DBG_UNREFERENCED_PARAMETER(pIrp); }
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow) { HWND g_hMainWnd; MSG MainWndMsg; WNDCLASS MainWndClass; HACCEL hAccel; WCHAR szAppName[SLEN_COMMON64]; int iScreenX, iScreenY, iWndX, iWndY, iWidth, iHeight; RECT rcMainWnd; DBG_UNREFERENCED_PARAMETER(szCmdLine); DBG_UNREFERENCED_PARAMETER(hPrevInstance); // First, initialize logger if(!fInitializeLogger(L"OSD_Log.txt", &StLogger)) { MessageBox(NULL, L"Cannot initialize logger", L"Error", MB_ICONEXCLAMATION); return CE_WMAIN_ERROR; } g_hMainInstance = hInstance; LoadString(GetModuleHandle(NULL), IDS_PGMNAME, szAppName, _countof(szAppName)); // UI Window Class MainWndClass.style = CS_HREDRAW | CS_VREDRAW; MainWndClass.lpfnWndProc = WndProc; MainWndClass.cbClsExtra = 0; MainWndClass.cbWndExtra = 0; MainWndClass.hInstance = g_hMainInstance; MainWndClass.hIcon = NULL; MainWndClass.hCursor = LoadCursor(NULL, IDC_ARROW); MainWndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); MainWndClass.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU); MainWndClass.lpszClassName = szAppName; if(!RegisterClass(&MainWndClass)) { MessageBox(NULL, TEXT("This program requires Windows NT!"), szAppName, MB_ICONERROR); return CE_WMAIN_ERROR; } // Initialize common controls InitCommonControls(); // Create the main window g_hMainWnd = CreateWindow(szAppName, // class name szAppName, // caption WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU, // window style CW_USEDEFAULT, // initial X position CW_USEDEFAULT, // initial Y position WNDSIZE_WIDTH, // initial X size WNDSIZE_HEIGHT, // initial Y size NULL, // parent window handle NULL, // window menu handle g_hMainInstance, // program instance handle NULL); // exit if window was not created if( !g_hMainWnd ) { MessageBox(0, L"Main Window creation error. Cannot continue.", 0, 0); return CE_WMAIN_ERROR; } // Init accelerators hAccel = LoadAccelerators(g_hMainInstance, MAKEINTRESOURCE(IDR_ACCELERATOR1)); if(!hAccel) { MessageBox(g_hMainWnd, L"Initialization failed. See log file.", L"Error", MB_OK | MB_ICONSTOP); logerror(pstLogger, L"LoadAccelerators() failed %u", GetLastError()); return CE_WMAIN_ERROR; } // centre the main window in the screen // get the screen co-ordinates iScreenX = GetSystemMetrics(SM_CXSCREEN); iScreenY = GetSystemMetrics(SM_CYSCREEN); // get window rect and calculate the main window dimensions GetWindowRect(g_hMainWnd, &rcMainWnd); iWidth = rcMainWnd.right - rcMainWnd.left; iHeight = rcMainWnd.bottom - rcMainWnd.top; // calculate the new co-ordinates for the main window iWndX = iScreenX / 2 - iWidth / 2; iWndY = iScreenY / 2 - iHeight / 2; MoveWindow(g_hMainWnd, iWndX, iWndY, iWidth, iHeight, FALSE); ShowWindow(g_hMainWnd, iCmdShow); UpdateWindow(g_hMainWnd); while( GetMessage(&MainWndMsg, NULL, 0, 0) ) { if(!TranslateAccelerator(g_hMainWnd, hAccel, &MainWndMsg)) { TranslateMessage(&MainWndMsg); DispatchMessage(&MainWndMsg); } } return MainWndMsg.wParam; }
/* * -------------------------------------------------------------------------- * Utility function to issue the specified OID to the NDIS stack. The OID is * directed towards the miniport edge of the extensible switch. * An OID that gets issued may not complete immediately, and in such cases, the * function waits for the OID to complete. Thus, this function must not be * called at the PASSIVE_LEVEL. * -------------------------------------------------------------------------- */ static NDIS_STATUS OvsIssueOidRequest(POVS_SWITCH_CONTEXT switchContext, NDIS_REQUEST_TYPE oidType, UINT32 oidRequestEnum, PVOID oidInputBuffer, UINT32 inputSize, PVOID oidOutputBuffer, UINT32 outputSize, UINT32 *outputSizeNeeded) { NDIS_STATUS status; PNDIS_OID_REQUEST oidRequest; POVS_OID_CONTEXT oidContext; ULONG OvsExtOidRequestId = 'ISVO'; DBG_UNREFERENCED_PARAMETER(inputSize); DBG_UNREFERENCED_PARAMETER(oidInputBuffer); OVS_LOG_TRACE("Enter: switchContext: %p, oidType: %d", switchContext, oidType); ASSERT(oidInputBuffer == NULL || inputSize != 0); ASSERT(oidOutputBuffer == NULL || outputSize != 0); ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL); oidRequest = OvsAllocateMemoryWithTag(sizeof *oidRequest, OVS_OID_POOL_TAG); if (!oidRequest) { status = NDIS_STATUS_RESOURCES; goto done; } oidContext = OvsAllocateMemoryWithTag(sizeof *oidContext, OVS_OID_POOL_TAG); if (!oidContext) { OvsFreeMemoryWithTag(oidRequest, OVS_OID_POOL_TAG); status = NDIS_STATUS_RESOURCES; goto done; } RtlZeroMemory(oidRequest, sizeof *oidRequest); RtlZeroMemory(oidContext, sizeof *oidContext); oidRequest->Header.Type = NDIS_OBJECT_TYPE_OID_REQUEST; oidRequest->Header.Revision = NDIS_OID_REQUEST_REVISION_1; oidRequest->Header.Size = NDIS_SIZEOF_OID_REQUEST_REVISION_1; oidRequest->RequestType = oidType; oidRequest->PortNumber = 0; oidRequest->Timeout = 0; oidRequest->RequestId = (PVOID)OvsExtOidRequestId; switch(oidType) { case NdisRequestQueryInformation: oidRequest->DATA.QUERY_INFORMATION.Oid = oidRequestEnum; oidRequest->DATA.QUERY_INFORMATION.InformationBuffer = oidOutputBuffer; oidRequest->DATA.QUERY_INFORMATION.InformationBufferLength = outputSize; break; default: ASSERT(FALSE); status = NDIS_STATUS_INVALID_PARAMETER; break; } /* * We make use of the SourceReserved field in the OID request to store * pointers to the original OID (if any), and also context for completion * (if any). */ oidContext->status = NDIS_STATUS_SUCCESS; NdisInitializeEvent(&oidContext->oidComplete); OvsOidSetOrigRequest(oidRequest, NULL); OvsOidSetContext(oidRequest, oidContext); NdisInterlockedIncrement(&(switchContext->pendingOidCount)); status = NdisFOidRequest(switchContext->NdisFilterHandle, oidRequest); if (status == NDIS_STATUS_PENDING) { NdisWaitEvent(&oidContext->oidComplete, 0); } else { NdisInterlockedDecrement(&(switchContext->pendingOidCount)); } if (status == NDIS_STATUS_INVALID_LENGTH || oidContext->status == NDIS_STATUS_INVALID_LENGTH) { switch(oidType) { case NdisRequestQueryInformation: *outputSizeNeeded = oidRequest->DATA.QUERY_INFORMATION.BytesNeeded; } } status = oidContext->status; ASSERT(status != NDIS_STATUS_PENDING); OvsFreeMemoryWithTag(oidRequest, OVS_OID_POOL_TAG); OvsFreeMemoryWithTag(oidContext, OVS_OID_POOL_TAG); done: OVS_LOG_TRACE("Exit: status %8x.", status); return status; }
int COrcFollow::UpdateState(COrc* _agent) { DBG_UNREFERENCED_PARAMETER(_agent); return 0; }
DBGSTATIC VOID ReplClientInitPool( IN DWORD PoolNumber, IN DWORD EntryCount, IN DWORD EntrySize ) /*++ Routine Description: Allocates initial (guessed) memory for the Big Buffer pool. If needed, other entries will be allocated dynamically. Guess is = MAX(count, POOL_MIN_ENTRY_COUNT ) From here the linked list memory is managed as follows: If an entry is deleted (FREE) add record to free_list. If a new entry is required (ALLOC) if NOTEMPTY(free_list) grab a record from free_list else Allocate new entry from the heap. Arguments: PoolNumber - Which pool to initialize EntryCount - Initial guess of number of entries to allocate. EntrySize - Size in byte of each entry in the pool. Return Value: None. --*/ { #ifdef notdef DWORD i; NET_API_STATUS NetStatus; #endif // notdef // // Ensure the EntrySize is a multiple of pointer size to ensure // each entry allocated here is pointer size aligned. // EntrySize = ROUND_UP_COUNT( EntrySize, ALIGN_LPBYTE ); RCGlobalPoolEntrySize[PoolNumber] = EntrySize; RCGlobalPoolHeader[PoolNumber] = NULL; #ifdef notdef // // Always allocate a minimum number of entries. // if (EntryCount < POOL_MIN_ENTRY_COUNT ) { EntryCount = POOL_MIN_ENTRY_COUNT ; } // // Allocate all the appropiate entries. // // It is better to detect a lack of resources at service initialization // rather than later. That is why the pool is primed, otherwise we // could just let the pools prime themselves. // for (i = 0; i < (EntryCount - 1); i++) { PUCHAR rec; rec = NetpMemoryAllocate( RCGlobalPoolEntrySize[PoolNumber] ); if ( rec == NULL ) { NetStatus = ERROR_NOT_ENOUGH_MEMORY; AlertLogExit( ALERT_ReplSysErr, NELOG_ReplSysErr, NetStatus, NULL, NULL, NO_EXIT); BUGBUG; // Hey, this will cause ReplClientFreePoolEntry to // fault on a NULL pointer! --JR } ReplClientFreePoolEntry( PoolNumber, rec ); } #endif // notdef DBG_UNREFERENCED_PARAMETER (EntryCount); }
void CMinotaurIdle::Execute(CMinotaur* _agent) { DBG_UNREFERENCED_PARAMETER(_agent); m_fWaitTimer -= DELTA_TIME(); }
/***************************************************************** * CollisionResponse(): Called after a collision is made between this object and another * * Ins: N/A * * Outs: N/A * * Returns: N/A * * Mod. Date: 8/15/2015 * Mod. Initials: NH *****************************************************************/ void IObject::CollisionResponse(IObject * _cCollidedObject) { DBG_UNREFERENCED_PARAMETER(_cCollidedObject); //handles collision response for this object }
void COrcFollow::Execute(COrc* _agent) { DBG_UNREFERENCED_PARAMETER(_agent); }