NTSTATUS NTAPI IntSetupDeviceSettingsKey( PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension) { static UNICODE_STRING SettingsKeyName = RTL_CONSTANT_STRING(L"Settings"); HANDLE DevInstRegKey, SourceKeyHandle, DestKeyHandle; OBJECT_ATTRIBUTES ObjectAttributes; NTSTATUS Status; /* Open the software key: HKLM\System\CurrentControlSet\Control\Class\<ClassGUID>\<n> */ Status = IoOpenDeviceRegistryKey(DeviceExtension->PhysicalDeviceObject, PLUGPLAY_REGKEY_DRIVER, KEY_ALL_ACCESS, &DevInstRegKey); if (Status != STATUS_SUCCESS) { ERR_(VIDEOPRT, "Failed to open device software key. Status 0x%lx", Status); return Status; } /* Open the 'Settings' sub-key */ InitializeObjectAttributes(&ObjectAttributes, &SettingsKeyName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, DevInstRegKey, NULL); Status = ZwOpenKey(&DestKeyHandle, KEY_WRITE, &ObjectAttributes); /* Close the device software key */ ObCloseHandle(DevInstRegKey, KernelMode); if (Status != STATUS_SUCCESS) { ERR_(VIDEOPRT, "Failed to open settings key. Status 0x%lx", Status); return Status; } /* Open the device profile key */ InitializeObjectAttributes(&ObjectAttributes, &DeviceExtension->RegistryPath, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL); Status = ZwOpenKey(&SourceKeyHandle, KEY_WRITE, &ObjectAttributes); if (Status != STATUS_SUCCESS) { ERR_(VIDEOPRT, "ZwOpenKey failed for settings key: status 0x%lx", Status); ObCloseHandle(DestKeyHandle, KernelMode); return Status; } IntCopyRegistryValue(SourceKeyHandle, DestKeyHandle, L"InstalledDisplayDrivers"); IntCopyRegistryValue(SourceKeyHandle, DestKeyHandle, L"Attach.ToDesktop"); ObCloseHandle(SourceKeyHandle, KernelMode); ObCloseHandle(DestKeyHandle, KernelMode); return STATUS_SUCCESS; }
static NTSTATUS NTAPI IrpStub( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { NTSTATUS Status = STATUS_NOT_SUPPORTED; if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO) { /* Forward some IRPs to lower device */ switch (IoGetCurrentIrpStackLocation(Irp)->MajorFunction) { case IRP_MJ_PNP: case IRP_MJ_INTERNAL_DEVICE_CONTROL: return ForwardIrpAndForget(DeviceObject, Irp); default: { ERR_(CLASS_NAME, "Port DO stub for major function 0x%lx\n", IoGetCurrentIrpStackLocation(Irp)->MajorFunction); ASSERT(FALSE); } } } else { ERR_(CLASS_NAME, "Class DO stub for major function 0x%lx\n", IoGetCurrentIrpStackLocation(Irp)->MajorFunction); ASSERT(FALSE); } Irp->IoStatus.Status = Status; IoCompleteRequest(Irp, IO_NO_INCREMENT); return Status; }
static NTSTATUS VideoPortUseDeviceInSesion( _Inout_ PDEVICE_OBJECT DeviceObject, _Inout_ PVIDEO_DEVICE_SESSION_STATUS SessionState, _In_ ULONG BufferLength, _Out_ PULONG_PTR Information) { PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension; /* Check buffer size */ *Information = sizeof(VIDEO_DEVICE_SESSION_STATUS); if (BufferLength < sizeof(VIDEO_DEVICE_SESSION_STATUS)) { ERR_(VIDEOPRT, "Buffer too small for VIDEO_DEVICE_SESSION_STATUS: %lx\n", BufferLength); return STATUS_BUFFER_TOO_SMALL; } /* Get the device extension */ DeviceExtension = DeviceObject->DeviceExtension; /* Shall we enable the session? */ if (SessionState->bEnable) { /* Check if we have no session yet */ if (DeviceExtension->SessionId == -1) { /* Use this session and return success */ DeviceExtension->SessionId = PsGetCurrentProcessSessionId(); SessionState->bSuccess = TRUE; } else { ERR_(VIDEOPRT, "Requested to set session, but session is already set to: 0x%lx", DeviceExtension->SessionId); SessionState->bSuccess = FALSE; } } else { /* Check if we belong to the current session */ if (DeviceExtension->SessionId == PsGetCurrentProcessSessionId()) { /* Reset the session and return success */ DeviceExtension->SessionId = -1; SessionState->bSuccess = TRUE; } else { ERR_(VIDEOPRT, "Requested to reset session, but session is not set\n"); SessionState->bSuccess = FALSE; } } return STATUS_SUCCESS; }
static BOOL CDECL nulldrv_CreateWindow( HWND hwnd ) { static int warned; HWND parent = GetAncestor( hwnd, GA_PARENT ); /* HWND_MESSAGE windows don't need a graphics driver */ if (!parent || parent == get_user_thread_info()->msg_window) return TRUE; if (warned++) return FALSE; ERR_(winediag)( "Application tried to create a window, but no driver could be loaded.\n" ); if (driver_load_error[0]) ERR_(winediag)( "%s\n", driver_load_error ); return FALSE; }
static NTSTATUS NTAPI i8042InternalDeviceControl( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { PFDO_DEVICE_EXTENSION DeviceExtension; ULONG ControlCode; NTSTATUS Status; TRACE_(I8042PRT, "i8042InternalDeviceControl(%p %p)\n", DeviceObject, Irp); DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension; switch (DeviceExtension->Type) { case Unknown: { ControlCode = IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode; switch (ControlCode) { case IOCTL_INTERNAL_KEYBOARD_CONNECT: Status = i8042KbdInternalDeviceControl(DeviceObject, Irp); break; case IOCTL_INTERNAL_MOUSE_CONNECT: Status = i8042MouInternalDeviceControl(DeviceObject, Irp); break; default: ERR_(I8042PRT, "Unknown IO control code 0x%lx\n", ControlCode); ASSERT(FALSE); Status = STATUS_INVALID_DEVICE_REQUEST; break; } break; } case Keyboard: Status = i8042KbdInternalDeviceControl(DeviceObject, Irp); break; case Mouse: Status = i8042MouInternalDeviceControl(DeviceObject, Irp); break; default: ERR_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type); ASSERT(FALSE); Status = STATUS_INTERNAL_ERROR; IoCompleteRequest(Irp, IO_NO_INCREMENT); break; } return Status; }
static NTSTATUS VideoPortInitWin32kCallbacks( _In_ PDEVICE_OBJECT DeviceObject, _Inout_ PVIDEO_WIN32K_CALLBACKS Win32kCallbacks, _In_ ULONG BufferLength, _Out_ PULONG_PTR Information) { *Information = sizeof(VIDEO_WIN32K_CALLBACKS); if (BufferLength < sizeof(VIDEO_WIN32K_CALLBACKS)) { ERR_(VIDEOPRT, "Buffer too small for VIDEO_WIN32K_CALLBACKS: %lx\n", BufferLength); return STATUS_BUFFER_TOO_SMALL; } /* Save the callout function globally */ Win32kCallout = Win32kCallbacks->Callout; /* Return reasonable values to win32k */ Win32kCallbacks->bACPI = FALSE; Win32kCallbacks->pPhysDeviceObject = DeviceObject; Win32kCallbacks->DualviewFlags = 0; return STATUS_SUCCESS; }
BOOLEAN NTAPI IntVideoPortSetupTimer( IN PDEVICE_OBJECT DeviceObject, IN PVIDEO_PORT_DRIVER_EXTENSION DriverExtension) { NTSTATUS Status; PVIDEO_PORT_DEVICE_EXTENSION DeviceExtension; DeviceExtension = (PVIDEO_PORT_DEVICE_EXTENSION)DeviceObject->DeviceExtension; if (DriverExtension->InitializationData.HwTimer != NULL) { INFO_(VIDEOPRT, "Initializing timer\n"); Status = IoInitializeTimer( DeviceObject, IntVideoPortTimerRoutine, DeviceExtension); if (!NT_SUCCESS(Status)) { ERR_(VIDEOPRT, "IoInitializeTimer failed with status 0x%08x\n", Status); return FALSE; } } return TRUE; }
/* * This function starts a packet. It must be called with the * correct DIRQL. */ NTSTATUS i8042StartPacket( IN PPORT_DEVICE_EXTENSION DeviceExtension, IN PFDO_DEVICE_EXTENSION FdoDeviceExtension, IN PUCHAR Bytes, IN ULONG ByteCount, IN PIRP Irp) { KIRQL Irql; NTSTATUS Status; Irql = KeAcquireInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt); if (DeviceExtension->Packet.State != Idle) { Status = STATUS_DEVICE_BUSY; goto done; } switch (FdoDeviceExtension->Type) { case Keyboard: DeviceExtension->PacketPort = 0; break; case Mouse: DeviceExtension->PacketPort = CTRL_WRITE_MOUSE; break; default: ERR_(I8042PRT, "Unknown FDO type %u\n", FdoDeviceExtension->Type); ASSERT(FALSE); Status = STATUS_INTERNAL_ERROR; goto done; } DeviceExtension->Packet.Bytes = Bytes; DeviceExtension->Packet.CurrentByte = 0; DeviceExtension->Packet.ByteCount = ByteCount; DeviceExtension->Packet.State = SendingBytes; DeviceExtension->PacketResult = Status = STATUS_PENDING; DeviceExtension->CurrentIrp = Irp; DeviceExtension->CurrentIrpDevice = FdoDeviceExtension->Fdo; if (!i8042PacketWrite(DeviceExtension)) { Status = STATUS_IO_TIMEOUT; DeviceExtension->Packet.State = Idle; DeviceExtension->PacketResult = STATUS_ABANDONED; goto done; } DeviceExtension->Packet.CurrentByte++; done: KeReleaseInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt, Irql); if (Status != STATUS_PENDING) { DeviceExtension->CurrentIrp = NULL; DeviceExtension->CurrentIrpDevice = NULL; Irp->IoStatus.Status = Status; IoCompleteRequest(Irp, IO_NO_INCREMENT); } return Status; }
/****************************************************************************** * ReportEventW [ADVAPI32.@] * * See ReportEventA. */ BOOL WINAPI ReportEventW( HANDLE hEventLog, WORD wType, WORD wCategory, DWORD dwEventID, PSID lpUserSid, WORD wNumStrings, DWORD dwDataSize, LPCWSTR *lpStrings, LPVOID lpRawData ) { UINT i; FIXME("(%p,0x%04x,0x%04x,0x%08x,%p,0x%04x,0x%08x,%p,%p): stub\n", hEventLog, wType, wCategory, dwEventID, lpUserSid, wNumStrings, dwDataSize, lpStrings, lpRawData); /* partial stub */ if (wNumStrings == 0) return TRUE; if (!lpStrings) return TRUE; for (i = 0; i < wNumStrings; i++) { switch (wType) { case EVENTLOG_SUCCESS: TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i])); break; case EVENTLOG_ERROR_TYPE: ERR_(eventlog)("%s\n", debugstr_w(lpStrings[i])); break; case EVENTLOG_WARNING_TYPE: WARN_(eventlog)("%s\n", debugstr_w(lpStrings[i])); break; default: TRACE_(eventlog)("%s\n", debugstr_w(lpStrings[i])); break; } } return TRUE; }
static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { /*ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, PersistStreamVtbl, iface);*/ HRESULT hr = E_FAIL; DMUS_PRIVATE_CHUNK Chunk; DWORD ListSize[3], ListCount[3]; LARGE_INTEGER liMove; /* used when skipping chunks */ if (pChunk->fccID != DMUS_FOURCC_SEGTRACK_LIST) { ERR_(dmfile)(": %s chunk should be a SEGTRACK list\n", debugstr_fourcc (pChunk->fccID)); return E_FAIL; } ListSize[0] = pChunk->dwSize - sizeof(FOURCC); ListCount[0] = 0; do { IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case DMUS_FOURCC_SEGTRACK_CHUNK: { TRACE_(dmfile)(": segment trigger track chunk\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } case FOURCC_LIST: { IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); ListSize[1] = Chunk.dwSize - sizeof(FOURCC); ListCount[1] = 0; switch (Chunk.fccID) { case DMUS_FOURCC_SEGMENTS_LIST: { TRACE_(dmfile)(": SEGMENTS list\n"); hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (iface, &Chunk, pStm); if (FAILED(hr)) return hr; break; } default: { TRACE_(dmfile)(": unknown (skipping)\n"); liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } break; } default: { TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]); } while (ListCount[0] < ListSize[0]); return S_OK; }
static void error_exit_fn(j_common_ptr cinfo) { char message[JMSG_LENGTH_MAX]; if (ERR_ON(jpeg)) { cinfo->err->format_message(cinfo, message); ERR_(jpeg)("%s\n", message); } longjmp(*(jmp_buf*)cinfo->client_data, 1); }
/*********************************************************************** * EnumDisplayDevicesA (USER32.@) */ BOOL WINAPI EnumDisplayDevicesA (LPCSTR lpDevice, DWORD iDevNum, LPDISPLAY_DEVICEA lpDisplayDevice, DWORD dwFlags) { DISPLAY_DEVICEW DispDev; LPWSTR pDeviceW = NULL; BOOL Ret; TRACE_(system) ("(%s, %ld, %p, 0x%08lx)\n", lpDevice, iDevNum, lpDisplayDevice, dwFlags); if (lpDevice) { INT Len; Len = MultiByteToWideChar (CP_ACP, 0, lpDevice, -1, NULL, 0); pDeviceW = HeapAlloc (GetProcessHeap (), 0, Len * sizeof (WCHAR)); if (!pDeviceW) { ERR_(system) ("Out of memory copying lpDevice!\n"); return FALSE; } MultiByteToWideChar (CP_ACP, 0, lpDevice, -1, pDeviceW, Len); } DispDev.cb = sizeof (DispDev); Ret = EnumDisplayDevicesW (pDeviceW, iDevNum, &DispDev, dwFlags); if (pDeviceW) HeapFree (GetProcessHeap (), 0, pDeviceW); if (!Ret) return FALSE; /* Don't bother checking for lpDisplayDevice != NULL; Windows XP crashes in that case too */ lpDisplayDevice->StateFlags = DispDev.StateFlags; WideCharToMultiByte (CP_ACP, 0, DispDev.DeviceName, -1, lpDisplayDevice->DeviceName, sizeof (lpDisplayDevice->DeviceName), NULL, NULL); WideCharToMultiByte (CP_ACP, 0, DispDev.DeviceString, -1, lpDisplayDevice->DeviceString, sizeof (lpDisplayDevice->DeviceString), NULL, NULL); WideCharToMultiByte (CP_ACP, 0, DispDev.DeviceID, -1, lpDisplayDevice->DeviceID, sizeof (lpDisplayDevice->DeviceID), NULL, NULL); WideCharToMultiByte (CP_ACP, 0, DispDev.DeviceKey, -1, lpDisplayDevice->DeviceKey, sizeof (lpDisplayDevice->DeviceKey), NULL, NULL); return TRUE; }
/* * Process the keyboard internal device requests */ VOID NTAPI i8042KbdStartIo( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { PIO_STACK_LOCATION Stack; PI8042_KEYBOARD_EXTENSION DeviceExtension; PPORT_DEVICE_EXTENSION PortDeviceExtension; Stack = IoGetCurrentIrpStackLocation(Irp); DeviceExtension = (PI8042_KEYBOARD_EXTENSION)DeviceObject->DeviceExtension; PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension; switch (Stack->Parameters.DeviceIoControl.IoControlCode) { case IOCTL_KEYBOARD_SET_INDICATORS: { TRACE_(I8042PRT, "IOCTL_KEYBOARD_SET_INDICATORS\n"); INFO_(I8042PRT, "Leds: {%s%s%s }\n", DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_CAPS_LOCK_ON ? " CAPSLOCK" : "", DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_NUM_LOCK_ON ? " NUMLOCK" : "", DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_SCROLL_LOCK_ON ? " SCROLLLOCK" : ""); PortDeviceExtension->PacketBuffer[0] = KBD_CMD_SET_LEDS; PortDeviceExtension->PacketBuffer[1] = 0; if (DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_CAPS_LOCK_ON) PortDeviceExtension->PacketBuffer[1] |= KBD_LED_CAPS; if (DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_NUM_LOCK_ON) PortDeviceExtension->PacketBuffer[1] |= KBD_LED_NUM; if (DeviceExtension->KeyboardIndicators.LedFlags & KEYBOARD_SCROLL_LOCK_ON) PortDeviceExtension->PacketBuffer[1] |= KBD_LED_SCROLL; i8042StartPacket( PortDeviceExtension, &DeviceExtension->Common, PortDeviceExtension->PacketBuffer, 2, Irp); break; } default: { ERR_(I8042PRT, "Unknown ioctl code 0x%lx\n", Stack->Parameters.DeviceIoControl.IoControlCode); ASSERT(FALSE); } } }
static BOOLEAN IsValidPnpIdString( IN PUCHAR Buffer, IN ULONG BufferLength) { ANSI_STRING String; /* FIXME: IsValidPnpIdString not implemented */ UNIMPLEMENTED; String.Length = String.MaximumLength = BufferLength; String.Buffer = (PCHAR)Buffer; ERR_(SERENUM, "Buffer %Z\n", &String); return TRUE; }
static NTSTATUS NTAPI IrpStub( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { NTSTATUS Status = STATUS_NOT_SUPPORTED; PPORT_DEVICE_EXTENSION DeviceExtension; DeviceExtension = DeviceObject->DeviceExtension; if (!DeviceExtension->Common.IsClassDO) { /* Forward some IRPs to lower device */ switch (IoGetCurrentIrpStackLocation(Irp)->MajorFunction) { case IRP_MJ_POWER: PoStartNextPowerIrp(Irp); IoSkipCurrentIrpStackLocation(Irp); return PoCallDriver(DeviceExtension->LowerDevice, Irp); default: { ERR_(CLASS_NAME, "Port DO stub for major function 0x%lx\n", IoGetCurrentIrpStackLocation(Irp)->MajorFunction); ASSERT(FALSE); } } } else { ERR_(CLASS_NAME, "Class DO stub for major function 0x%lx\n", IoGetCurrentIrpStackLocation(Irp)->MajorFunction); ASSERT(FALSE); } Irp->IoStatus.Status = Status; IoCompleteRequest(Irp, IO_NO_INCREMENT); return Status; }
/*********************************************************************** * EnumDisplayDevicesW (USER32.@) */ BOOL WINAPI EnumDisplayDevicesW (LPCWSTR lpDevice, DWORD iDevNum, LPDISPLAY_DEVICEW lpDisplayDevice, DWORD dwFlags) { TRACE_(system) ("(%s, %ld, %p, 0x%08lx)\n", debugstr_w (lpDevice), iDevNum, lpDisplayDevice, dwFlags); if (dwFlags) FIXME_(system) ("dwFlags 0x%lx is not supported!\n", dwFlags); /* We only present one device to the application */ if (iDevNum) return FALSE; FIXME_(system) ("Real display device and monitor names should be retrieved\n"); /* Don't bother checking for lpDisplayDevice != NULL; Windows XP crashes in that case too */ if (lpDevice == NULL) { strcpyW (lpDisplayDevice->DeviceName, DeviceName); strcpyW (lpDisplayDevice->DeviceString, DeviceString); strcpyW (lpDisplayDevice->DeviceID, DeviceID); strcpyW (lpDisplayDevice->DeviceKey, DeviceKey); lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE | DISPLAY_DEVICE_VGA_COMPATIBLE; } else { if (strcmpW (lpDevice, DeviceName)) { ERR_(system) ("Attempted to get non-existant monitor info!\n"); return FALSE; } strcpyW (lpDisplayDevice->DeviceName, MDeviceName); strcpyW (lpDisplayDevice->DeviceString, MDeviceString); strcpyW (lpDisplayDevice->DeviceID, MDeviceID); strcpyW (lpDisplayDevice->DeviceKey, MDeviceKey); lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_MULTI_DRIVER; } return TRUE; }
static NTSTATUS ReportDetectedPnpDevice( IN PUCHAR Buffer, IN ULONG BufferLength) { ANSI_STRING String; /* FIXME: ReportDetectedPnpDevice not implemented */ UNIMPLEMENTED; String.Length = String.MaximumLength = BufferLength; String.Buffer = (PCHAR)Buffer; ERR_(SERENUM, "Buffer %Z\n", &String); /* Call ReportDetectedDevice */ return STATUS_SUCCESS; }
static BOOL gnutls_initialize(void) { int ret; if (!(libgnutls_handle = wine_dlopen( SONAME_LIBGNUTLS, RTLD_NOW, NULL, 0 ))) { ERR_(winediag)( "failed to load libgnutls, no support for crypto hashes\n" ); return FALSE; } #define LOAD_FUNCPTR(f) \ if (!(p##f = wine_dlsym( libgnutls_handle, #f, NULL, 0 ))) \ { \ ERR( "failed to load %s\n", #f ); \ goto fail; \ } LOAD_FUNCPTR(gnutls_global_deinit) LOAD_FUNCPTR(gnutls_global_init) LOAD_FUNCPTR(gnutls_global_set_log_function) LOAD_FUNCPTR(gnutls_global_set_log_level) LOAD_FUNCPTR(gnutls_hash); LOAD_FUNCPTR(gnutls_hash_deinit); LOAD_FUNCPTR(gnutls_hash_init); LOAD_FUNCPTR(gnutls_perror) #undef LOAD_FUNCPTR if ((ret = pgnutls_global_init()) != GNUTLS_E_SUCCESS) { pgnutls_perror( ret ); goto fail; } if (TRACE_ON( bcrypt )) { pgnutls_global_set_log_level( 4 ); pgnutls_global_set_log_function( gnutls_log ); } return TRUE; fail: wine_dlclose( libgnutls_handle, NULL, 0 ); libgnutls_handle = NULL; return FALSE; }
/** * Close compressed stream. * * @return 0 - Success * @return -1 - File system error (not compression error), errno contains error code */ static int gzClose(gzFile fd_gz) { int res; res = gzclose(fd_gz); if (res != Z_OK) { if (res == Z_ERRNO) { ERR_("Failed to close fd_gz!"); return -1; } CRIT_("Failed to close fd_gz (gz error): %s", gzerror(fd_gz, &res)); //exit(EXIT_FAILURE); return -1; } return 0; }
static VOID NTAPI i8042StartIo( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { PFDO_DEVICE_EXTENSION DeviceExtension; DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension; switch (DeviceExtension->Type) { case Keyboard: i8042KbdStartIo(DeviceObject, Irp); break; default: ERR_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type); ASSERT(FALSE); break; } }
static HRESULT WINAPI IDirectMusicLoaderResourceStream_IStream_Seek (LPSTREAM iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition) { ICOM_THIS_MULTI(IDirectMusicLoaderResourceStream, StreamVtbl, iface); TRACE_(dmfileraw)("(%p, 0x%08llX, %s, %p)\n", This, dlibMove.QuadPart, resolve_STREAM_SEEK(dwOrigin), plibNewPosition); switch (dwOrigin) { case STREAM_SEEK_CUR: { if ((This->llPos + dlibMove.QuadPart) > This->llMemLength) { WARN_(dmfileraw)(": requested offset out of range\n"); return E_FAIL; } break; } case STREAM_SEEK_SET: { if (dlibMove.QuadPart > This->llMemLength) { WARN_(dmfileraw)(": requested offset out of range\n"); return E_FAIL; } /* set to the beginning of the stream */ This->llPos = 0; break; } case STREAM_SEEK_END: { /* TODO: check if this is true... I do think offset should be negative in this case */ if (dlibMove.QuadPart > 0) { WARN_(dmfileraw)(": requested offset out of range\n"); return E_FAIL; } /* set to the end of the stream */ This->llPos = This->llMemLength; break; } default: { ERR_(dmfileraw)(": invalid dwOrigin\n"); return E_FAIL; } } /* now simply add */ This->llPos += dlibMove.QuadPart; if (plibNewPosition) plibNewPosition->QuadPart = This->llPos; return S_OK; }
static void emit_message_fn(j_common_ptr cinfo, int msg_level) { char message[JMSG_LENGTH_MAX]; if (msg_level < 0 && ERR_ON(jpeg)) { cinfo->err->format_message(cinfo, message); ERR_(jpeg)("%s\n", message); } else if (msg_level == 0 && WARN_ON(jpeg)) { cinfo->err->format_message(cinfo, message); WARN_(jpeg)("%s\n", message); } else if (msg_level > 0 && TRACE_ON(jpeg)) { cinfo->err->format_message(cinfo, message); TRACE_(jpeg)("%s\n", message); } }
/*********************************************************************** * EnumDisplaySettingsW (USER32.@) */ BOOL WINAPI EnumDisplaySettingsW(LPCWSTR name,DWORD n,LPDEVMODEW devmode) { DEVMODEA devmodeA; BOOL ret; LPSTR nameA = NULL; if (name){ DWORD len = WideCharToMultiByte( CP_ACP, 0, name, -1, NULL, 0, NULL, NULL ); nameA = HeapAlloc( GetProcessHeap(), 0, len ); if (nameA == NULL){ ERR_(system)("not enough memory to allocate a string conversion buffer for '%s'\n", debugstr_w(name)); return FALSE; } WideCharToMultiByte( CP_ACP, 0, name, -1, nameA, len, NULL, NULL ); } ret = EnumDisplaySettingsA(nameA,n,&devmodeA); if (ret) { devmode->dmBitsPerPel = devmodeA.dmBitsPerPel; devmode->dmPelsHeight = devmodeA.dmPelsHeight; devmode->dmPelsWidth = devmodeA.dmPelsWidth; devmode->dmDisplayFlags = devmodeA.dmDisplayFlags; devmode->dmDisplayFrequency = devmodeA.dmDisplayFrequency; devmode->dmFields = devmodeA.dmFields; /* FIXME: convert rest too, if they are ever returned */ } if (nameA) HeapFree(GetProcessHeap(),0,nameA); return ret; }
PVOID NTAPI IntVideoPortGetProcAddress( IN PVOID HwDeviceExtension, IN PUCHAR FunctionName) { ULONG i = 0; TRACE_(VIDEOPRT, "VideoPortGetProcAddress(%s)\n", FunctionName); /* Search by name */ for (i = 0; i < VP_EXPORTED_FUNCS; i++) { if (!strcmp((PCHAR)FunctionName, VideoPortExports[i].Name)) { return (PVOID)VideoPortExports[i].Address; } } ERR_(VIDEOPRT, "VideoPortGetProcAddress: Can't resolve symbol %s\n", FunctionName); return NULL; }
/*********************************************************************** * NE_GetDLLInitParams */ static VOID NE_GetDLLInitParams( NE_MODULE *pModule, WORD *hInst, WORD *ds, WORD *heap ) { SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule ); if (!(pModule->ne_flags & NE_FFLAGS_SINGLEDATA)) { if (pModule->ne_flags & NE_FFLAGS_MULTIPLEDATA || pModule->ne_autodata) { /* Not SINGLEDATA */ ERR_(dll)("Library is not marked SINGLEDATA\n"); exit(1); } else /* DATA NONE DLL */ { *ds = 0; *heap = 0; } } else /* DATA SINGLE DLL */ { if (pModule->ne_autodata) { *ds = SEL(pSegTable[pModule->ne_autodata-1].hSeg); *heap = pModule->ne_heap; } else /* hmm, DLL has no dgroup, but why has it NE_FFLAGS_SINGLEDATA set ? Buggy DLL compiler ? */ { *ds = 0; *heap = 0; } } *hInst = *ds ? GlobalHandle16(*ds) : pModule->self; }
static HRESULT IDirectMusicBandImpl_IPersistStream_ParseBandForm (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { ICOM_THIS_MULTI(IDirectMusicBandImpl, PersistStreamVtbl, iface); HRESULT hr = E_FAIL; DMUS_PRIVATE_CHUNK Chunk; DWORD StreamSize, StreamCount, ListSize[3], ListCount[3]; LARGE_INTEGER liMove; /* used when skipping chunks */ GUID tmp_guid; if (pChunk->fccID != DMUS_FOURCC_BAND_FORM) { ERR_(dmfile)(": %s chunk should be a BAND form\n", debugstr_fourcc (pChunk->fccID)); return E_FAIL; } StreamSize = pChunk->dwSize - sizeof(FOURCC); StreamCount = 0; do { IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, This->pDesc); if (FAILED(hr)) return hr; if (hr == S_FALSE) { switch (Chunk.fccID) { case DMUS_FOURCC_GUID_CHUNK: { TRACE_(dmfile)(": GUID\n"); IStream_Read (pStm, &tmp_guid, sizeof(GUID), NULL); TRACE_(dmfile)(" - guid: %s\n", debugstr_dmguid(&tmp_guid)); break; } case FOURCC_LIST: { IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); ListSize[0] = Chunk.dwSize - sizeof(FOURCC); ListCount[0] = 0; switch (Chunk.fccID) { case DMUS_FOURCC_UNFO_LIST: { TRACE_(dmfile)(": UNFO list\n"); do { IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, This->pDesc); if (FAILED(hr)) return hr; if (hr == S_FALSE) { switch (Chunk.fccID) { default: { TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } } TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]); } while (ListCount[0] < ListSize[0]); break; } case DMUS_FOURCC_INSTRUMENTS_LIST: { TRACE_(dmfile)(": INSTRUMENTS list\n"); hr = IDirectMusicBandImpl_IPersistStream_ParseInstrumentsList (iface, &Chunk, pStm); if (FAILED(hr)) return hr; break; } default: { TRACE_(dmfile)(": unknown (skipping)\n"); liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } break; } default: { TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } } TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize); } while (StreamCount < StreamSize); return S_OK; }
static HRESULT IDirectMusicBandImpl_IPersistStream_ParseInstrument (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { ICOM_THIS_MULTI(IDirectMusicBandImpl, PersistStreamVtbl, iface); DMUS_PRIVATE_CHUNK Chunk; DWORD ListSize[3], ListCount[3]; LARGE_INTEGER liMove; /* used when skipping chunks */ HRESULT hr; DMUS_IO_INSTRUMENT inst; LPDMUS_PRIVATE_INSTRUMENT pNewInstrument; IDirectMusicObject* pObject = NULL; if (pChunk->fccID != DMUS_FOURCC_INSTRUMENT_LIST) { ERR_(dmfile)(": %s chunk should be an INSTRUMENT list\n", debugstr_fourcc (pChunk->fccID)); return E_FAIL; } ListSize[0] = pChunk->dwSize - sizeof(FOURCC); ListCount[0] = 0; do { IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case DMUS_FOURCC_INSTRUMENT_CHUNK: { TRACE_(dmfile)(": Instrument chunk\n"); if (Chunk.dwSize != sizeof(DMUS_IO_INSTRUMENT)) return E_FAIL; IStream_Read (pStm, &inst, sizeof(DMUS_IO_INSTRUMENT), NULL); TRACE_(dmfile)(" - dwPatch: %u\n", inst.dwPatch); TRACE_(dmfile)(" - dwAssignPatch: %u\n", inst.dwAssignPatch); TRACE_(dmfile)(" - dwNoteRanges[0]: %u\n", inst.dwNoteRanges[0]); TRACE_(dmfile)(" - dwNoteRanges[1]: %u\n", inst.dwNoteRanges[1]); TRACE_(dmfile)(" - dwNoteRanges[2]: %u\n", inst.dwNoteRanges[2]); TRACE_(dmfile)(" - dwNoteRanges[3]: %u\n", inst.dwNoteRanges[3]); TRACE_(dmfile)(" - dwPChannel: %u\n", inst.dwPChannel); TRACE_(dmfile)(" - dwFlags: %x\n", inst.dwFlags); TRACE_(dmfile)(" - bPan: %u\n", inst.bPan); TRACE_(dmfile)(" - bVolume: %u\n", inst.bVolume); TRACE_(dmfile)(" - nTranspose: %d\n", inst.nTranspose); TRACE_(dmfile)(" - dwChannelPriority: %u\n", inst.dwChannelPriority); TRACE_(dmfile)(" - nPitchBendRange: %d\n", inst.nPitchBendRange); break; } case FOURCC_LIST: { IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); ListSize[1] = Chunk.dwSize - sizeof(FOURCC); ListCount[1] = 0; switch (Chunk.fccID) { case DMUS_FOURCC_REF_LIST: { FIXME_(dmfile)(": DMRF (DM References) list\n"); hr = IDirectMusicUtils_IPersistStream_ParseReference (iface, &Chunk, pStm, &pObject); if (FAILED(hr)) { ERR(": could not load Reference\n"); return hr; } break; } default: { TRACE_(dmfile)(": unknown (skipping)\n"); liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } break; } default: { TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]); } while (ListCount[0] < ListSize[0]); /* * @TODO insert pNewInstrument into This */ pNewInstrument = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_INSTRUMENT)); if (NULL == pNewInstrument) { ERR(": no more memory\n"); return E_OUTOFMEMORY; } memcpy(&pNewInstrument->pInstrument, &inst, sizeof(DMUS_IO_INSTRUMENT)); pNewInstrument->ppReferenceCollection = NULL; if (NULL != pObject) { IDirectMusicCollection* pCol = NULL; hr = IDirectMusicObject_QueryInterface (pObject, &IID_IDirectMusicCollection, (void**) &pCol); if (FAILED(hr)) { ERR(": failed to get IDirectMusicCollection Interface from DMObject\n"); HeapFree(GetProcessHeap(), 0, pNewInstrument); return hr; } pNewInstrument->ppReferenceCollection = pCol; IDirectMusicObject_Release(pObject); } list_add_tail (&This->Instruments, &pNewInstrument->entry); return S_OK; }
static HRESULT IDirectMusicChordTrack_IPersistStream_ParseChordTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { ICOM_THIS_MULTI(IDirectMusicChordTrack, PersistStreamVtbl, iface); DMUS_PRIVATE_CHUNK Chunk; DWORD ListSize[3], ListCount[3]; LARGE_INTEGER liMove; /* used when skipping chunks */ if (pChunk->fccID != DMUS_FOURCC_CHORDTRACK_LIST) { ERR_(dmfile)(": %s chunk should be a CHORDTRACK list\n", debugstr_fourcc (pChunk->fccID)); return E_FAIL; } ListSize[0] = pChunk->dwSize - sizeof(FOURCC); ListCount[0] = 0; do { IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); switch (Chunk.fccID) { case DMUS_FOURCC_CHORDTRACKHEADER_CHUNK: { TRACE_(dmfile)(": Chord track header chunk\n"); IStream_Read (pStm, &This->dwScale, sizeof(DWORD), NULL); TRACE_(dmfile)(" - dwScale: %d\n", This->dwScale); break; } case DMUS_FOURCC_CHORDTRACKBODY_CHUNK: { DWORD sz; DWORD it; DWORD num; DMUS_IO_CHORD body; DMUS_IO_SUBCHORD subchords; TRACE_(dmfile)(": Chord track body chunk\n"); IStream_Read (pStm, &sz, sizeof(DWORD), NULL); TRACE_(dmfile)(" - sizeof(DMUS_IO_CHORD): %d\n", sz); if (sz != sizeof(DMUS_IO_CHORD)) return E_FAIL; IStream_Read (pStm, &body, sizeof(DMUS_IO_CHORD), NULL); TRACE_(dmfile)(" - wszName: %s\n", debugstr_w(body.wszName)); TRACE_(dmfile)(" - mtTime: %u\n", body.mtTime); TRACE_(dmfile)(" - wMeasure: %u\n", body.wMeasure); TRACE_(dmfile)(" - bBeat: %u\n", body.bBeat); TRACE_(dmfile)(" - bFlags: 0x%02x\n", body.bFlags); IStream_Read (pStm, &num, sizeof(DWORD), NULL); TRACE_(dmfile)(" - # DMUS_IO_SUBCHORDS: %d\n", num); IStream_Read (pStm, &sz, sizeof(DWORD), NULL); TRACE_(dmfile)(" - sizeof(DMUS_IO_SUBCHORDS): %d\n", sz); if (sz != sizeof(DMUS_IO_SUBCHORD)) return E_FAIL; for (it = 0; it < num; ++it) { IStream_Read (pStm, &subchords, sizeof(DMUS_IO_SUBCHORD), NULL); TRACE_(dmfile)("DMUS_IO_SUBCHORD #%d\n", it+1); TRACE_(dmfile)(" - dwChordPattern: %u\n", subchords.dwChordPattern); TRACE_(dmfile)(" - dwScalePattern: %u\n", subchords.dwScalePattern); TRACE_(dmfile)(" - dwInversionPoints: %u\n", subchords.dwInversionPoints); TRACE_(dmfile)(" - dwLevels: %u\n", subchords.dwLevels); TRACE_(dmfile)(" - bChordRoot: %u\n", subchords.bChordRoot); TRACE_(dmfile)(" - bScaleRoot: %u\n", subchords.bScaleRoot); } break; } default: { TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n"); liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]); } while (ListCount[0] < ListSize[0]); return S_OK; }
VOID NTAPI i8042SendHookWorkItem( IN PDEVICE_OBJECT DeviceObject, IN PVOID Context) { PI8042_HOOK_WORKITEM WorkItemData; PFDO_DEVICE_EXTENSION FdoDeviceExtension; PPORT_DEVICE_EXTENSION PortDeviceExtension; PDEVICE_OBJECT TopOfStack = NULL; ULONG IoControlCode; PVOID InputBuffer; ULONG InputBufferLength; IO_STATUS_BLOCK IoStatus; KEVENT Event; PIRP NewIrp; NTSTATUS Status; TRACE_(I8042PRT, "i8042SendHookWorkItem(%p %p)\n", DeviceObject, Context); WorkItemData = (PI8042_HOOK_WORKITEM)Context; FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension; PortDeviceExtension = FdoDeviceExtension->PortDeviceExtension; switch (FdoDeviceExtension->Type) { case Keyboard: { PI8042_KEYBOARD_EXTENSION DeviceExtension; DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension; IoControlCode = IOCTL_INTERNAL_I8042_HOOK_KEYBOARD; InputBuffer = &DeviceExtension->KeyboardHook; InputBufferLength = sizeof(INTERNAL_I8042_HOOK_KEYBOARD); break; } case Mouse: { PI8042_MOUSE_EXTENSION DeviceExtension; DeviceExtension = (PI8042_MOUSE_EXTENSION)FdoDeviceExtension; IoControlCode = IOCTL_INTERNAL_I8042_HOOK_MOUSE; InputBuffer = &DeviceExtension->MouseHook; InputBufferLength = sizeof(INTERNAL_I8042_HOOK_MOUSE); break; } default: { ERR_(I8042PRT, "Unknown FDO type %u\n", FdoDeviceExtension->Type); ASSERT(FALSE); WorkItemData->Irp->IoStatus.Status = STATUS_INTERNAL_ERROR; goto cleanup; } } KeInitializeEvent(&Event, NotificationEvent, FALSE); TopOfStack = IoGetAttachedDeviceReference(DeviceObject); NewIrp = IoBuildDeviceIoControlRequest( IoControlCode, TopOfStack, InputBuffer, InputBufferLength, NULL, 0, TRUE, &Event, &IoStatus); if (!NewIrp) { WARN_(I8042PRT, "IoBuildDeviceIoControlRequest() failed\n"); WorkItemData->Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } Status = IoCallDriver(TopOfStack, NewIrp); if (Status == STATUS_PENDING) { KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL); Status = IoStatus.Status; } if (!NT_SUCCESS(Status)) { WARN_(I8042PRT, "IoCallDriver() failed with status 0x%08lx\n", Status); goto cleanup; } if (FdoDeviceExtension->Type == Keyboard) { PI8042_KEYBOARD_EXTENSION DeviceExtension; DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension; /* Call the hooked initialization if it exists */ if (DeviceExtension->KeyboardHook.InitializationRoutine) { Status = DeviceExtension->KeyboardHook.InitializationRoutine( DeviceExtension->KeyboardHook.Context, PortDeviceExtension, i8042SynchReadPort, i8042SynchWritePortKbd, FALSE); if (!NT_SUCCESS(Status)) { WARN_(I8042PRT, "KeyboardHook.InitializationRoutine() failed with status 0x%08lx\n", Status); WorkItemData->Irp->IoStatus.Status = Status; goto cleanup; } } } WorkItemData->Irp->IoStatus.Status = STATUS_SUCCESS; cleanup: if (TopOfStack != NULL) ObDereferenceObject(TopOfStack); WorkItemData->Irp->IoStatus.Information = 0; IoCompleteRequest(WorkItemData->Irp, IO_NO_INCREMENT); IoFreeWorkItem(WorkItemData->WorkItem); ExFreePoolWithTag(WorkItemData, I8042PRT_TAG); }
/********************************************************************** * PE_LoadImage * Load one PE format DLL/EXE into memory * * Unluckily we can't just mmap the sections where we want them, for * (at least) Linux does only support offsets which are page-aligned. * * BUT we have to map the whole image anyway, for Win32 programs sometimes * want to access them. (HMODULE32 point to the start of it) */ HMODULE PE_LoadImage( int handle, LPCSTR filename, WORD *version ) { HMODULE hModule; HANDLE mapping; IMAGE_NT_HEADERS *nt; IMAGE_SECTION_HEADER *pe_sec; IMAGE_DATA_DIRECTORY *dir; // BY_HANDLE_FILE_INFORMATION bhfi; int i, rawsize, lowest_va, vma_size, file_size = 0; DWORD load_addr = 0, aoep, reloc = 0; // struct get_read_fd_request *req = get_req_buffer(); int unix_handle = handle; int page_size = getpagesize(); // if ( GetFileInformationByHandle( hFile, &bhfi ) ) // file_size = bhfi.nFileSizeLow; file_size=lseek(handle, 0, SEEK_END); lseek(handle, 0, SEEK_SET); // fix CreateFileMappingA mapping = CreateFileMappingA( handle, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL ); if (!mapping) { WARN("CreateFileMapping error %ld\n", GetLastError() ); return 0; } // hModule = (HMODULE)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 ); hModule=(HMODULE)mapping; // CloseHandle( mapping ); if (!hModule) { WARN("MapViewOfFile error %ld\n", GetLastError() ); return 0; } if ( *(WORD*)hModule !=IMAGE_DOS_SIGNATURE) { WARN("%s image doesn't have DOS signature, but 0x%04x\n", filename,*(WORD*)hModule); goto error; } nt = PE_HEADER( hModule ); if ( nt->Signature != IMAGE_NT_SIGNATURE ) { WARN("%s image doesn't have PE signature, but 0x%08lx\n", filename, nt->Signature ); goto error; } if ( nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386 ) { dbg_printf("Trying to load PE image for unsupported architecture ("); switch (nt->FileHeader.Machine) { case IMAGE_FILE_MACHINE_UNKNOWN: dbg_printf("Unknown"); break; case IMAGE_FILE_MACHINE_I860: dbg_printf("I860"); break; case IMAGE_FILE_MACHINE_R3000: dbg_printf("R3000"); break; case IMAGE_FILE_MACHINE_R4000: dbg_printf("R4000"); break; case IMAGE_FILE_MACHINE_R10000: dbg_printf("R10000"); break; case IMAGE_FILE_MACHINE_ALPHA: dbg_printf("Alpha"); break; case IMAGE_FILE_MACHINE_POWERPC: dbg_printf("PowerPC"); break; default: dbg_printf("Unknown-%04x", nt->FileHeader.Machine); break; } dbg_printf(")\n"); goto error; } pe_sec = PE_SECTIONS( hModule ); rawsize = 0; lowest_va = 0x10000; for (i = 0; i < nt->FileHeader.NumberOfSections; i++) { if (lowest_va > pe_sec[i].VirtualAddress) lowest_va = pe_sec[i].VirtualAddress; if (pe_sec[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA) continue; if (pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData > rawsize) rawsize = pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData; } if ( file_size && file_size < rawsize ) { ERR("PE module is too small (header: %d, filesize: %d), " "probably truncated download?\n", rawsize, file_size ); goto error; } aoep = nt->OptionalHeader.AddressOfEntryPoint; if (aoep && (aoep < lowest_va)) FIXME("VIRUS WARNING: '%s' has an invalid entrypoint (0x%08lx) " "below the first virtual address (0x%08x) " "(possibly infected by Tchernobyl/SpaceFiller virus)!\n", filename, aoep, lowest_va ); /* FIXME: Hack! While we don't really support shared sections yet, * this checks for those special cases where the whole DLL * consists only of shared sections and is mapped into the * shared address space > 2GB. In this case, we assume that * the module got mapped at its base address. Thus we simply * check whether the module has actually been mapped there * and use it, if so. This is needed to get Win95 USER32.DLL * to work (until we support shared sections properly). */ if ( nt->OptionalHeader.ImageBase & 0x80000000 && !strstr(filename, "xanlib.dll")) { HMODULE sharedMod = (HMODULE)nt->OptionalHeader.ImageBase; IMAGE_NT_HEADERS *sharedNt = (PIMAGE_NT_HEADERS) ( (LPBYTE)sharedMod + ((LPBYTE)nt - (LPBYTE)hModule) ); /* Well, this check is not really comprehensive, but should be good enough for now ... */ if ( !IsBadReadPtr( (LPBYTE)sharedMod, sizeof(IMAGE_DOS_HEADER) ) && memcmp( (LPBYTE)sharedMod, (LPBYTE)hModule, sizeof(IMAGE_DOS_HEADER) ) == 0 && !IsBadReadPtr( sharedNt, sizeof(IMAGE_NT_HEADERS) ) && memcmp( sharedNt, nt, sizeof(IMAGE_NT_HEADERS) ) == 0 ) { UnmapViewOfFile( (LPVOID)hModule ); return sharedMod; } } load_addr = nt->OptionalHeader.ImageBase; vma_size = calc_vma_size( hModule ); load_addr = (DWORD)VirtualAlloc( (void*)load_addr, vma_size, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE ); if (load_addr == 0) { FIXME("We need to perform base relocations for %s\n", filename); dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BASERELOC; if (dir->Size) reloc = dir->VirtualAddress; else { FIXME( "FATAL: Need to relocate %s, but no relocation records present (%s). Try to run that file directly !\n", filename, (nt->FileHeader.Characteristics&IMAGE_FILE_RELOCS_STRIPPED)? "stripped during link" : "unknown reason" ); goto error; } /* FIXME: If we need to relocate a system DLL (base > 2GB) we should * really make sure that the *new* base address is also > 2GB. * Some DLLs really check the MSB of the module handle :-/ */ if ( nt->OptionalHeader.ImageBase & 0x80000000 ) ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" ); load_addr = (DWORD)VirtualAlloc( NULL, vma_size, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE ); if (!load_addr) { FIXME_(win32)( "FATAL: Couldn't load module %s (out of memory, %d needed)!\n", filename, vma_size); goto error; } } TRACE("Load addr is %lx (base %lx), range %x\n", load_addr, nt->OptionalHeader.ImageBase, vma_size ); TRACE_(segment)("Loading %s at %lx, range %x\n", filename, load_addr, vma_size ); #if 0 *(PIMAGE_DOS_HEADER)load_addr = *(PIMAGE_DOS_HEADER)hModule; *PE_HEADER( load_addr ) = *nt; memcpy( PE_SECTIONS(load_addr), PE_SECTIONS(hModule), sizeof(IMAGE_SECTION_HEADER) * nt->FileHeader.NumberOfSections ); memcpy( load_addr, hModule, lowest_fa ); #endif if ((void*)FILE_dommap( handle, (void *)load_addr, 0, nt->OptionalHeader.SizeOfHeaders, 0, 0, PROT_EXEC | PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_FIXED ) != (void*)load_addr) { ERR_(win32)( "Critical Error: failed to map PE header to necessary address.\n"); goto error; } pe_sec = PE_SECTIONS( hModule ); for (i = 0; i < nt->FileHeader.NumberOfSections; i++, pe_sec++) { if (!pe_sec->SizeOfRawData || !pe_sec->PointerToRawData) continue; TRACE("%s: mmaping section %s at %p off %lx size %lx/%lx\n", filename, pe_sec->Name, (void*)RVA(pe_sec->VirtualAddress), pe_sec->PointerToRawData, pe_sec->SizeOfRawData, pe_sec->Misc.VirtualSize ); if ((void*)FILE_dommap( unix_handle, (void*)RVA(pe_sec->VirtualAddress), 0, pe_sec->SizeOfRawData, 0, pe_sec->PointerToRawData, PROT_EXEC | PROT_WRITE | PROT_READ, MAP_PRIVATE | MAP_FIXED ) != (void*)RVA(pe_sec->VirtualAddress)) { ERR_(win32)( "Critical Error: failed to map PE section to necessary address.\n"); goto error; } if ((pe_sec->SizeOfRawData < pe_sec->Misc.VirtualSize) && (pe_sec->SizeOfRawData & (page_size-1))) { DWORD end = (pe_sec->SizeOfRawData & ~(page_size-1)) + page_size; if (end > pe_sec->Misc.VirtualSize) end = pe_sec->Misc.VirtualSize; TRACE("clearing %p - %p\n", RVA(pe_sec->VirtualAddress) + pe_sec->SizeOfRawData, RVA(pe_sec->VirtualAddress) + end ); memset( (char*)RVA(pe_sec->VirtualAddress) + pe_sec->SizeOfRawData, 0, end - pe_sec->SizeOfRawData ); } } if ( reloc ) do_relocations( load_addr, (IMAGE_BASE_RELOCATION *)RVA(reloc) ); *version = ( (nt->OptionalHeader.MajorSubsystemVersion & 0xff) << 8 ) | (nt->OptionalHeader.MinorSubsystemVersion & 0xff); UnmapViewOfFile( (LPVOID)hModule ); return (HMODULE)load_addr; error: if (unix_handle != -1) close( unix_handle ); if (load_addr) VirtualFree( (LPVOID)load_addr, 0, MEM_RELEASE ); UnmapViewOfFile( (LPVOID)hModule ); return 0; }