void IoControlDriver()
{
HANDLE device = CreateFile("\\\\.\\ObjNameGetter",
GENERIC_READ | GENERIC_WRITE,
0, // Not allow share
NULL, // No security
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE == device) {
Error("Create device fail!");
return;
}
TCHAR buf_read[16] = {};
TCHAR buf_write[8] = {};
DWORD bytes_read = 0;
DWORD ctl_code = CTL_CODE(FILE_DEVICE_UNKNOWN,
2048,
METHOD_BUFFERED,
FILE_ANY_ACCESS);
BOOL result = DeviceIoControl(device,
ctl_code,
buf_read,
_countof(buf_read),
buf_write,
_countof(buf_write),
&bytes_read,
NULL);
printf("IoControl return %d, read %u bytes\n", result, bytes_read);
CloseHandle(device);
}
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE hvolume1 = CreateFileW(
L"C:\\Users\\Jim\\AppData\\Roaming\\WandoujiaUsbDriver\\33F9DF8D2000F3A6E56C83E479B48E53_13028264933821.zip",
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
HANDLE hvolume2 = CreateFileW(
L"C:\\Users\\Jim\\AppData\\Roaming\\WandoujiaUsbDriver\\002_dfe690df0.zip.wdj",
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
HANDLE hvolume3 = CreateFileW(
L"C:\\Users\\Jim\\AppData\\Roaming\\WandoujiaUsbDriver\\33F9DF8D2000F3A6E56C83E479B48E53_13028264933821\\android_winusb.inf",
GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
const char* device_path = "\\\\?\\usb#vid_12d1&pid_1038&mi_01#7&389a7fb&0&0001#{f72fe0d4-cbcb-407d-8814-9ed673d0dd6b}";
bool success = false;
HANDLE usb_handle = CreateFileA(device_path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, NULL);
if (usb_handle != INVALID_HANDLE_VALUE) {
char buf[512 + 1] = { 0 };
DWORD temp = 0;
if (DeviceIoControl(usb_handle, CTL_CODE(FILE_DEVICE_UNKNOWN, 16, METHOD_BUFFERED, FILE_READ_ACCESS), NULL, NULL, &buf, 512, &temp, NULL)) {
buf[temp] = '\0';
success = true;
}
CloseHandle(usb_handle);
}
return 0;
}
BOOL WriteTrackpadOptions(DWORD *opt) {
HANDLE hDevice;
BOOL bResult;
DWORD junk;
hDevice = CreateFile(TEXT(DEVICE_PRIMARY),
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hDevice == INVALID_HANDLE_VALUE) {
hDevice = CreateFile(TEXT(DEVICE_ALTERNATE),
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL);
if (hDevice == INVALID_HANDLE_VALUE) {
return (FALSE);
}
}
bResult = DeviceIoControl(hDevice,
CTL_CODE(FILE_DEVICE_MOUSE, 0x0801, METHOD_BUFFERED, FILE_ANY_ACCESS), //0xf2004,
opt, sizeof(*opt),
NULL, 0,
&junk,
(LPOVERLAPPED) NULL);
CloseHandle(hDevice);
return (bResult);
}
/*
* @implemented
*/
VOID
SendLinkDeleted(IN PUNICODE_STRING DeviceName,
IN PUNICODE_STRING SymbolicName)
{
PIRP Irp;
KEVENT Event;
ULONG NameSize;
NTSTATUS Status;
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION Stack;
PMOUNTDEV_NAME Name = NULL;
PDEVICE_OBJECT DeviceObject;
IO_STATUS_BLOCK IoStatusBlock;
/* Get the device associated with the name */
Status = IoGetDeviceObjectPointer(DeviceName,
FILE_READ_ATTRIBUTES,
&FileObject,
&DeviceObject);
if (!NT_SUCCESS(Status))
{
return;
}
/* Get attached device (will notify it) */
DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
/* NameSize is the size of the whole MOUNTDEV_NAME struct */
NameSize = sizeof(USHORT) + SymbolicName->Length;
Name = AllocatePool(NameSize);
if (!Name)
{
goto Cleanup;
}
/* Initialize struct */
Name->NameLength = SymbolicName->Length;
RtlCopyMemory(Name->Name, SymbolicName->Buffer, SymbolicName->Length);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
/* Cf: SendLinkCreated comment */
Irp = IoBuildDeviceIoControlRequest(CTL_CODE(MOUNTDEVCONTROLTYPE, 5, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
DeviceObject,
Name,
NameSize,
NULL,
0,
FALSE,
&Event,
&IoStatusBlock);
/* This one can fail, no one matters */
if (Irp)
{
Stack = IoGetNextIrpStackLocation(Irp);
Stack->FileObject = FileObject;
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
}
}
/* Then, second one */
KeInitializeEvent(&Event, NotificationEvent, FALSE);
Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_LINK_DELETED,
DeviceObject,
Name,
NameSize,
NULL,
0,
FALSE,
&Event,
&IoStatusBlock);
if (!Irp)
{
goto Cleanup;
}
Stack = IoGetNextIrpStackLocation(Irp);
Stack->FileObject = FileObject;
/* Really notify */
Status = IoCallDriver(DeviceObject, Irp);
if (Status == STATUS_PENDING)
{
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
}
Cleanup:
if (Name)
{
FreePool(Name);
}
ObDereferenceObject(DeviceObject);
ObDereferenceObject(FileObject);
return;
}
/*
* pgsymlink - uses Win32 junction points
*
* For reference: http://www.codeproject.com/KB/winsdk/junctionpoints.aspx
*/
int
pgsymlink(const char *oldpath, const char *newpath)
{
HANDLE dirhandle;
DWORD len;
char buffer[MAX_PATH * sizeof(WCHAR) + sizeof(REPARSE_JUNCTION_DATA_BUFFER)];
char nativeTarget[MAX_PATH];
char *p = nativeTarget;
REPARSE_JUNCTION_DATA_BUFFER *reparseBuf = (REPARSE_JUNCTION_DATA_BUFFER *) buffer;
CreateDirectory(newpath, 0);
dirhandle = CreateFile(newpath, GENERIC_READ | GENERIC_WRITE,
0, 0, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, 0);
if (dirhandle == INVALID_HANDLE_VALUE)
return -1;
/* make sure we have an unparsed native win32 path */
if (memcmp("\\??\\", oldpath, 4))
sprintf(nativeTarget, "\\??\\%s", oldpath);
else
strcpy(nativeTarget, oldpath);
while ((p = strchr(p, '/')) != 0)
*p++ = '\\';
len = strlen(nativeTarget) * sizeof(WCHAR);
reparseBuf->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
reparseBuf->ReparseDataLength = len + 12;
reparseBuf->Reserved = 0;
reparseBuf->SubstituteNameOffset = 0;
reparseBuf->SubstituteNameLength = len;
reparseBuf->PrintNameOffset = len + sizeof(WCHAR);
reparseBuf->PrintNameLength = 0;
MultiByteToWideChar(CP_ACP, 0, nativeTarget, -1,
reparseBuf->PathBuffer, MAX_PATH);
/*
* FSCTL_SET_REPARSE_POINT is coded differently depending on SDK version;
* we use our own definition
*/
if (!DeviceIoControl(dirhandle,
CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_ANY_ACCESS),
reparseBuf,
reparseBuf->ReparseDataLength + REPARSE_JUNCTION_DATA_BUFFER_HEADER_SIZE,
0, 0, &len, 0))
{
LPSTR msg;
errno = 0;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(),
MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
(LPSTR) &msg, 0, NULL);
#ifndef FRONTEND
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not set junction for \"%s\": %s",
nativeTarget, msg)));
#else
fprintf(stderr, _("could not set junction for \"%s\": %s\n"),
nativeTarget, msg);
#endif
LocalFree(msg);
CloseHandle(dirhandle);
RemoveDirectory(newpath);
return -1;
}
CloseHandle(dirhandle);
return 0;
}
#define WIN32_LEAN_AND_MEAN
#define STRICT
#define STRICT_GS_ENABLED
#define _ATL_NO_AUTOMATIC_NAMESPACE
#include <atlbase.h>
#include <windows.h>
#include <winioctl.h>
#include <clocale>
#include <cstdio>
#include <crtdbg.h>
#ifndef FSCTL_GET_RETRIEVAL_POINTERS_AND_REFCOUNT
const ULONG FSCTL_GET_RETRIEVAL_POINTERS_AND_REFCOUNT = CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 244, METHOD_NEITHER, FILE_ANY_ACCESS);
typedef struct RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER {
ULONG ExtentCount;
LARGE_INTEGER StartingVcn;
struct {
LARGE_INTEGER NextVcn;
LARGE_INTEGER Lcn;
ULONG ReferenceCount;
} Extents[ANYSIZE_ARRAY];
} RETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER, *PRETRIEVAL_POINTERS_AND_REFCOUNT_BUFFER;
#endif
void pwerror()
{
PWSTR msg;
ATLENSURE(FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, GetLastError(), 0, reinterpret_cast<PWSTR>(&msg), 0, nullptr));
fputws(msg, stderr);
#pragma GCC diagnostic push
#endif
#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif
// CTL_CODE macro for non-win OSes
#ifndef UHD_PLATFORM_WIN32
#define CTL_CODE(a,controlCode,b,c) (controlCode)
#endif
const uint32_t NIRIO_IOCTL_BASE = 0x800;
const uint32_t NIRIO_IOCTL_SYNCOP =
CTL_CODE(FILE_DEVICE_UNKNOWN,
NIRIO_IOCTL_BASE + 4,
METHOD_OUT_DIRECT,
FILE_READ_DATA | FILE_WRITE_DATA);
///< The synchronous operation code. Note: We
/// must use METHOD_OUT_DIRECT on the syncOp()
/// IOCTL to ensure the contents of the output
/// block are available in the kernel.
const uint32_t NIRIO_IOCTL_GET_IFACE_NUM =
CTL_CODE(FILE_DEVICE_UNKNOWN,
NIRIO_IOCTL_BASE + 6,
METHOD_BUFFERED,
FILE_READ_DATA); ///< Get the interface number for a device
//const uint32_t NIRIO_IOCTL_GET_SESSION =
//CTL_CODE(FILE_DEVICE_UNKNOWN,
//NIRIO_IOCTL_BASE + 8,
