/****************************************************************************
*
* FUNCTION: LoadDeviceDriver( const TCHAR, const TCHAR, HANDLE *)
*
* PURPOSE: Registers a driver with the system configuration manager
* and then loads it.
*
****************************************************************************/
BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path, HANDLE * lphDevice,BOOL Install)
{
SC_HANDLE schSCManager;
BOOL okay;
DWORD Service_Error;
char LogZeile[128];
sprintf(LogZeile,"Service Installations");
Write_Log(LogZeile);
sprintf(LogZeile,"=====================");
Write_Log(LogZeile);
schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
if ( schSCManager == NULL ) {
Service_Error = GetLastError();
sprintf(LogZeile,"OpenSCManager für %s (%s) return %d ",Name,Path,Service_Error);
if ( Service_Error == ERROR_ACCESS_DENIED ) strcat(LogZeile,"ACCESS_DENIED");
else if ( Service_Error == ERROR_DATABASE_DOES_NOT_EXIST ) strcat(LogZeile,"DATABASE_DOES_NOT_EXIST");
else if ( Service_Error == ERROR_INVALID_PARAMETER ) strcat(LogZeile,"INVALID_PARAMETER");
strcat(LogZeile,")");
Write_Log(LogZeile);
if ( Service_Error == ERROR_ACCESS_DENIED ) MessageBox(hWnd,"Sie besitzen nicht die notwendigen Rechte für die Verwaltung von Geräten","Multi-Decode",MB_ICONSTOP|MB_OK);
}
// Ignore success of installation: it may already be installed.
if ( Install == TRUE ) InstallDriver( schSCManager, Name, Path );
// Ignore success of start: it may already be started.
okay=StartDriver( schSCManager, Name );
CloseServiceHandle( schSCManager );
return okay;
}
void GetDeviceDetail( HANDLE DeviceInformation, SP_DEVINFO_DATA* DeviceData )
{
wchar_t propertyBuffer[1000];
DWORD propertyDataType = 1;
DWORD requiredSize = 0;
SetupDiGetDeviceRegistryPropertyW(
DeviceInformation,
DeviceData,
SPDRP_DEVICEDESC,
&propertyDataType,
&propertyBuffer,
1000 * sizeof(wchar_t),
&requiredSize
);
if (String_Compare(propertyBuffer, L"MotioninJoy Virtual Xinput device for Windows") == 0)
{
Log(L"Driver already installed for this device");
}
else
{
Log(L"Installing driver...");
InstallDriver(DeviceInformation, DeviceData);
}
}
BOOL PacketInstallDriver60()
{
BOOL result = FALSE;
result = (BOOL) InstallDriver();
return result;
}
BOOL PacketInstallDriver60(BOOL bWifiOrNormal)
{
BOOL result = FALSE;
result = (BOOL) InstallDriver(bWifiOrNormal);
return result;
}
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
InstallDriver();
StartDriver();
hInst = hInstance;
DialogBoxParam( hInstance, MAKEINTRESOURCE( IDD_MAIN ), NULL, DlgProc, WM_INITDIALOG );
UninstallDriver();
return 0;
}
static BOOL __cdecl start_driver( void )
{
SC_HANDLE schSCManager;
BOOL ret = FALSE;
schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
if(!schSCManager) return(FALSE);
if(!InstallDriver( schSCManager, sDriverShort, sDriverLong )) {
CloseServiceHandle( schSCManager );
return(FALSE);
}
ret = StartDriver( schSCManager, sDriverShort );
if(!ret) {
(void)RemoveDriver( schSCManager, sDriverShort );
}
CloseServiceHandle( schSCManager );
return( ret );
}
int main()
{
int action = 0;
const char* prompt = "\nPlease enter action:\n"
"0: Install driver\n"
"1: Read data\n"
"2: Write data\n"
"3: IoControl driver\n"
"4: Uninstall driver";
puts(prompt);
const TCHAR* drv_name = _T("ObjNameGetter");
while (EOF != scanf("%d", &action)) {
switch (action) {
case Install:
InstallDriver(drv_name);
break;
case Read:
ReadDriver();
break;
case Write:
WriteDriver();
break;
case Uninstall:
UninstallDriver(drv_name);
break;
case IoControl:
IoControlDriver();
break;
default:
;
}
puts(prompt);
}
return 0;
}
/****************************************************************************
*
* FUNCTION: LoadDeviceDriver( const TCHAR, const TCHAR, HANDLE *)
*
* PURPOSE: Registers a driver with the system configuration manager
* and then loads it.
*
****************************************************************************/
BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path, HANDLE * lphDevice )
{
SC_HANDLE schSCManager;
BOOL okay;
schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
// Remove previous instance
RemoveDriver( schSCManager, Name );
// Ignore success of installation: it may already be installed.
InstallDriver( schSCManager, Name, Path );
// Ignore success of start: it may already be started.
StartDriver( schSCManager, Name );
// Do make sure we can open it.
okay = OpenDevice( Name, lphDevice );
CloseServiceHandle( schSCManager );
return okay;
}
/****************************************************************************
*
* FUNCTION: LoadDeviceDriver( const TCHAR, const TCHAR, HANDLE *)
*
* PURPOSE: Registers a driver with the system configuration manager
* and then loads it.
*
****************************************************************************/
BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path, PDWORD Error )
{
SC_HANDLE schSCManager;
BOOL okay;
schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
if(schSCManager)
{
// Remove previous instance
// RemoveDriver( schSCManager, Name );
// Ignore success of installation: it may already be installed.
InstallDriver( schSCManager, Name, Path );
// Ignore success of start: it may already be started.
okay = StartDriver( schSCManager, Name );
*Error = GetLastError();
CloseServiceHandle( schSCManager );
}
return okay;
}
/*************************************
* int _cdecl main( )
* 功能 加载驱动，进行控制
**************************************/
int _cdecl main()
{
HANDLE hDevice;
BOOL bRc;
ULONG bytesReturned;
DWORD errNum = 0;
UCHAR driverLocation[MAX_PATH];
SC_HANDLE schSCManager;// 服务控制器句柄
// 打开服务控制器，后续安装、启动都会使用到。
schSCManager = OpenSCManager(NULL, // 本机
NULL, // 本机数据库
SC_MANAGER_ALL_ACCESS // 存取权限
);
if (!schSCManager)
{
// 打开失败
printf("Open SC Manager failed! Error = %d \n", GetLastError());
return 1;
}
// 获得驱动文件的路径
if (!GetDriverPath(driverLocation))
{
return 1;
}
// 安装驱动服务
if (InstallDriver(schSCManager,
DRIVER_NAME,
driverLocation
))
{
// 安装成功，启动服务，运行驱动
if(!StartDriver(schSCManager, DRIVER_NAME ))
{
printf("Unable to start driver. \n");
return 1;
}
}
else
{
// 安装失败，删除驱动。
RemoveDriver(schSCManager, DRIVER_NAME );
printf("Unable to install driver. \n");
return 1;
}
// 打开驱动，获得控制所用的句柄
// 由驱动创建的符号链接
hDevice = CreateFile( "\\\\.\\IoctlTest",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( hDevice == INVALID_HANDLE_VALUE )
{
printf ( "Error: CreatFile Failed : %d\n", GetLastError());
return 1;
}
// 打印，输入输出。
printf("InputBuffer Pointer = %p, BufLength = %d\n", InputBuffer,
sizeof(InputBuffer));
printf("OutputBuffer Pointer = %p BufLength = %d\n", OutputBuffer,
sizeof(OutputBuffer));
// 输入到内核的数据，
lstrcpy(InputBuffer,
"This String is from User Application; using IOCTL_XIOCTL_BUFFER");
printf("\nCalling DeviceIoControl IOCTL_XIOCTL_BUFFER:\n");
// 清空输出缓存
memset(OutputBuffer, 0, sizeof(OutputBuffer));
// 进行IO控制，
bRc = DeviceIoControl ( hDevice,// 句柄
(DWORD) IOCTL_XIOCTL_BUFFER,// IOCTL
&InputBuffer,// 输入数据
strlen ( InputBuffer )+1,// 输入数据的长度
&OutputBuffer,// 输出数据
sizeof( OutputBuffer),// 输出数据长度
&bytesReturned,// 实际输出的数据长度
NULL
);
// 判断是否成功
if ( !bRc )
{
printf ( "Error in DeviceIoControl : %d", GetLastError());
return 1;
}
// 打印从内核输出的内容
printf(" OutBuffer (%d): %s\n", bytesReturned, OutputBuffer);
// 关闭句柄
CloseHandle ( hDevice );
// 停止运行
StopDriver(schSCManager,
DRIVER_NAME
);
// 删除服务
RemoveDriver(schSCManager,
DRIVER_NAME
);
// 关闭服务控制器
CloseServiceHandle (schSCManager);
return 0;
}
VOID Mij_EnumerateDevices()
{
HANDLE deviceInfo = NULL;
deviceInfo = SetupDiGetClassDevsW(NULL, L"USB", NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT);
if (deviceInfo != INVALID_HANDLE_VALUE)
{
BOOLEAN flag = TRUE;
unsigned int num = 0;
while (flag)
{
SP_DEVINFO_DATA deviceData;
Memory_Clear(&deviceData, sizeof(SP_DEVINFO_DATA));
deviceData.cbSize = sizeof(SP_DEVINFO_DATA);
deviceData.DevInst = NULL;
deviceData.Reserved = 0;
flag = SetupDiEnumDeviceInfo(deviceInfo, num, &deviceData);
if (flag)
{
wchar_t propertyBuffer[1000];
DWORD requiredSize = 0;
DWORD propertyDataType = 1;
if (SetupDiGetDeviceRegistryPropertyW(
deviceInfo,
&deviceData,
SPDRP_HARDWAREID,
&propertyDataType,
&propertyBuffer,
1000 * sizeof(wchar_t),
&requiredSize))
{
BOOLEAN flag2 = FALSE;
int i;
// Direct Match, definitely a device we recognize
for (i = 0; i < sizeof(KnownDevices) / sizeof(KnownDevices[0]); i++)
{
if (String_CompareIgnoreCaseN(propertyBuffer, KnownDevices[i].RegistryId, 22))
{
flag2 = TRUE;
Log(L"found %s [%s]", KnownDevices[i].FriendlyName, propertyBuffer);
break;
}
}
// Possible devices that could work
if (!flag2
&& SetupDiGetDeviceRegistryPropertyW(
deviceInfo,
&deviceData,
SPDRP_COMPATIBLEIDS,
&propertyDataType,
&propertyBuffer,
1000 * sizeof(wchar_t),
&requiredSize))
{
//Bluetooth Device
//BaseClass[0xE0] = Wireless Controller,
//SubClass[0x01] = Wireless Radio,
//Protocol[0x01] = Bluetooth Programming Interface
//https://web.archive.org/web/20070626033649/http://www.usb.org/developers/defined_class/#BaseClassE0h
if (String_CompareIgnoreCaseN(propertyBuffer, L"usb\\Class_e0&subClass_01&Prot_01", 33))
{
Log(L"found Bluetooth device %s", propertyBuffer);
flag2 = TRUE;
}
//Controller
else if (String_CompareIgnoreCaseN(propertyBuffer, L"usb\\Class_58&subClass_42", 25))
{
Log(L"found Controller %s", propertyBuffer);
flag2 = TRUE;
}
}
if (flag2)
{
//Callback(&deviceData);
//GetDeviceDetail(deviceInfo, &deviceData);
Log(L"Installing driver...");
InstallDriver(deviceInfo, &deviceData);
Log(L"Finished Installing driver...");
}
}
}
num += 1;
}
}
}
LONG __cdecl main(ULONG argc, CHAR *argv[])
{
PCHAR command;
int temp_n, temp_k;
if(argc == 1)
{
PrintHelp();
return 0;
}
command = argv[1];
if(argc > 2)
Args = argv + 2;
else
Args = NULL;
ArgNum = argc - 2;
if(!strcmp(command, "encode"))
{
temp_n = atoi(Args[0]);
temp_k = atoi(Args[1]);
if(temp_n < 1 || temp_n > 255 || temp_k < 1 || temp_k > 255)
{
printf("Parameters <n> and <k> must be positive integers between 1 and 255.\n");
return 1;
}
if(temp_n <= temp_k)
{
printf("<n> must be greater then <k>.\n");
return 1;
}
if(ArgNum == 2)
{
printf("Please specify the name of file to encode.\n");
return 1;
}
if(ArgNum == 3)
{
printf("Please specify the name of resulting file.\n");
return 1;
}
return CreateImage(Args[2], Args[3], (UCHAR)temp_n, (UCHAR)temp_k);
}
if(!strcmp(command, "test"))
{
temp_n = atoi(Args[0]);
temp_k = atoi(Args[1]);
printf("Testing %s with n = %d, k = %d\n", Args[2], temp_n, temp_k);
return TestImage(Args[2], (UCHAR)temp_n, (UCHAR)temp_k);
}
if(!strcmp(command, "install"))
return InstallDriver();
if(!strcmp(command, "uninstall"))
return UninstallDriver();
printf("%s: unknown command. Read help:\n\n", command);
PrintHelp();
return 0;
}
int __cdecl wmain(int argc, PWCHAR argv[]) {
size_t i;
WCHAR fileName[MAX_PATH];
WCHAR driverFullPath[MAX_PATH] = {0};
WCHAR mounterFullPath[MAX_PATH] = {0};
WCHAR type;
PVOID wow64OldValue;
DokanUseStdErr(TRUE); // Set dokan library debug output
Wow64DisableWow64FsRedirection(&wow64OldValue); //Disable system32 direct
// setlocale(LC_ALL, "");
GetModuleFileName(NULL, fileName, MAX_PATH);
// search the last "\"
for (i = wcslen(fileName) - 1; i > 0 && fileName[i] != L'\\'; --i) {
;
}
fileName[i] = L'\0';
wcscpy_s(mounterFullPath, MAX_PATH, fileName);
wcscat_s(mounterFullPath, MAX_PATH, L"\\mounter.exe");
fwprintf(stderr, L"Mounter path: '%s'\n", mounterFullPath);
ExpandEnvironmentStringsW(DOKAN_DRIVER_FULL_PATH, driverFullPath, MAX_PATH);
fwprintf(stderr, L"Driver path: '%s'\n", driverFullPath);
if (GetOption(argc, argv, 1) == L'v') {
fprintf(stderr, "dokanctl : %s %s\n", __DATE__, __TIME__);
fprintf(stderr, "Dokan version : %d\n", DokanVersion());
fprintf(stderr, "Dokan driver version : 0x%lx\n", DokanDriverVersion());
return EXIT_SUCCESS;
} else if (GetOption(argc, argv, 1) == L'm') {
return ShowMountList();
} else if (GetOption(argc, argv, 1) == L'u' && argc == 3) {
return Unmount(argv[2], FALSE);
} else if (GetOption(argc, argv, 1) == L'u' &&
GetOption(argc, argv, 3) == L'f' && argc == 4) {
return Unmount(argv[2], TRUE);
} else if (argc < 3 || wcslen(argv[1]) != 2 || argv[1][0] != L'/') {
return ShowUsage();
}
type = towlower(argv[2][0]);
switch (towlower(argv[1][1])) {
case L'i':
if (type == L'd') {
return InstallDriver(driverFullPath);
} else if (type == L's') {
return InstallMounter(mounterFullPath);
} else if (type == L'a') {
if (InstallDriver(driverFullPath) == EXIT_FAILURE)
return EXIT_FAILURE;
if (InstallMounter(mounterFullPath) == EXIT_FAILURE)
return EXIT_FAILURE;
} else if (type == L'n') {
if (DokanNetworkProviderInstall())
fprintf(stderr, "network provider install ok\n");
else
fprintf(stderr, "network provider install failed\n");
}
break;
case L'r':
if (type == L'd') {
return DeleteDokanService(DOKAN_DRIVER_SERVICE);
} else if (type == L's') {
return DeleteDokanService(DOKAN_MOUNTER_SERVICE);
} else if (type == L'a') {
if (DeleteDokanService(DOKAN_MOUNTER_SERVICE) == EXIT_FAILURE)
return EXIT_FAILURE;
if (DeleteDokanService(DOKAN_DRIVER_SERVICE) == EXIT_FAILURE)
return EXIT_FAILURE;
} else if (type == L'n') {
if (DokanNetworkProviderUninstall())
fprintf(stderr, "network provider remove ok\n");
else
fprintf(stderr, "network provider remove failed\n");
}
break;
case L'd':
if (L'0' <= type && type <= L'9') {
ULONG mode = type - L'0';
if (DokanSetDebugMode(mode)) {
fprintf(stderr, "set debug mode ok\n");
} else {
fprintf(stderr, "set debug mode failed\n");
}
}
break;
default:
fprintf(stderr, "unknown option\n");
}
return EXIT_SUCCESS;
}
int __cdecl wmain(int argc, PWCHAR argv[]) {
size_t i;
WCHAR fileName[MAX_PATH];
WCHAR driverFullPath[MAX_PATH] = {0};
PVOID wow64OldValue;
BOOL isAdmin;
isAdmin = IsUserAnAdmin();
DokanUseStdErr(TRUE); // Set dokan library debug output
Wow64DisableWow64FsRedirection(&wow64OldValue); // Disable system32 direct
// setlocale(LC_ALL, "");
GetModuleFileName(NULL, fileName, MAX_PATH);
// search the last "\"
for (i = wcslen(fileName) - 1; i > 0 && fileName[i] != L'\\'; --i) {
;
}
fileName[i] = L'\0';
ExpandEnvironmentStringsW(DOKAN_DRIVER_FULL_PATH, driverFullPath, MAX_PATH);
fwprintf(stdout, L"Driver path: '%s'\n", driverFullPath);
WCHAR option = GetOption(argc, argv, 1);
if (option == L'\0' || option == L'?') {
return ShowUsage();
}
if (!isAdmin &&
(option == L'i' || option == L'r' || option == L'd' || option == L'u')) {
fprintf(stderr, "Admin rights required to process this operation\n");
return EXIT_FAILURE;
}
switch (option) {
// Admin rights required
case L'i': {
WCHAR type = towlower(argv[2][0]);
if (type == L'd') {
return InstallDriver(driverFullPath);
} else if (type == L'n') {
if (DokanNetworkProviderInstall())
fprintf(stdout, "network provider install ok\n");
else
fprintf(stderr, "network provider install failed\n");
} else {
goto DEFAULT;
}
} break;
case L'r': {
WCHAR type = towlower(argv[2][0]);
if (type == L'd') {
return DeleteDokanService(DOKAN_DRIVER_SERVICE);
} else if (type == L'n') {
if (DokanNetworkProviderUninstall())
fprintf(stdout, "network provider remove ok\n");
else
fprintf(stderr, "network provider remove failed\n");
} else {
goto DEFAULT;
}
} break;
case L'd': {
WCHAR type = towlower(argv[2][0]);
if (L'0' > type || type > L'9')
goto DEFAULT;
ULONG mode = type - L'0';
if (DokanSetDebugMode(mode)) {
fprintf(stdout, "set debug mode ok\n");
} else {
fprintf(stderr, "set debug mode failed\n");
}
} break;
case L'u': {
if (argc < 3) {
goto DEFAULT;
}
return Unmount(argv[2]);
} break;
// No admin rights required
case L'l': {
ULONG nbRead = 0;
PDOKAN_CONTROL dokanControl =
malloc(DOKAN_MAX_INSTANCES * sizeof(*dokanControl));
if (dokanControl == NULL) {
fprintf(stderr, "Failed to allocate dokanControl\n");
return EXIT_FAILURE;
}
ZeroMemory(dokanControl, DOKAN_MAX_INSTANCES * sizeof(*dokanControl));
if (DokanGetMountPointList(dokanControl, DOKAN_MAX_INSTANCES, FALSE,
&nbRead)) {
fwprintf(stdout, L" Mount points: %d\n", nbRead);
for (unsigned int p = 0; p < nbRead; ++p) {
fwprintf(stdout, L" %u# MountPoint: %s - UNC: %s - DeviceName: %s\n",
p, dokanControl[p].MountPoint, dokanControl[p].UNCName,
dokanControl[p].DeviceName);
}
} else {
fwprintf(stderr, L" Cannot retrieve mount point list.\n");
}
free(dokanControl);
} break;
case L'v': {
fprintf(stdout, "dokanctl : %s %s\n", __DATE__, __TIME__);
fprintf(stdout, "Dokan version : %d\n", DokanVersion());
fprintf(stdout, "Dokan driver version : 0x%lx\n", DokanDriverVersion());
} break;
DEFAULT:
default:
fprintf(stderr, "Unknown option - Use /? to show usage\n");
}
return EXIT_SUCCESS;
}
VOID
InstallDevice(
IN HINF hInf,
IN HANDLE hEnum,
IN HANDLE hServices,
IN LPCWSTR DeviceId)
{
UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
UNICODE_STRING CompatibleIDsU = RTL_CONSTANT_STRING(L"CompatibleIDs");
UNICODE_STRING DeviceIdU;
OBJECT_ATTRIBUTES ObjectAttributes;
LPCWSTR HardwareID;
PKEY_VALUE_PARTIAL_INFORMATION pPartialInformation = NULL;
HANDLE hDeviceKey;
ULONG ulRequired;
BOOLEAN bDriverInstalled = FALSE;
NTSTATUS Status;
RtlInitUnicodeString(&DeviceIdU, DeviceId);
InitializeObjectAttributes(&ObjectAttributes, &DeviceIdU, 0, hEnum, NULL);
Status = NtOpenKey(&hDeviceKey, KEY_QUERY_VALUE | KEY_SET_VALUE, &ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT("Unable to open subkey '%S'\n", DeviceId);
return;
}
Status = NtQueryValueKey(
hDeviceKey,
&HardwareIDU,
KeyValuePartialInformation,
NULL,
0,
&ulRequired);
if (Status == STATUS_BUFFER_TOO_SMALL)
{
pPartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)RtlAllocateHeap(ProcessHeap, 0, ulRequired);
if (!pPartialInformation)
{
DPRINT1("RtlAllocateHeap() failed\n");
NtClose(hDeviceKey);
return;
}
Status = NtQueryValueKey(
hDeviceKey,
&HardwareIDU,
KeyValuePartialInformation,
pPartialInformation,
ulRequired,
&ulRequired);
}
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
{
/* Nothing to do */
}
else if (!NT_SUCCESS(Status))
{
DPRINT1("NtQueryValueKey() failed with status 0x%08x\n", Status);
if (pPartialInformation)
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
NtClose(hDeviceKey);
return;
}
else if (pPartialInformation)
{
for (HardwareID = (LPCWSTR)pPartialInformation->Data;
(PUCHAR)HardwareID < pPartialInformation->Data + pPartialInformation->DataLength
&& *HardwareID
&& !bDriverInstalled;
HardwareID += wcslen(HardwareID) + 1)
{
bDriverInstalled = InstallDriver(hInf, hServices,hDeviceKey, DeviceId, HardwareID);
}
}
if (!bDriverInstalled)
{
if (pPartialInformation)
{
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
pPartialInformation = NULL;
}
Status = NtQueryValueKey(
hDeviceKey,
&CompatibleIDsU,
KeyValuePartialInformation,
NULL,
0,
&ulRequired);
if (Status == STATUS_BUFFER_TOO_SMALL)
{
pPartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)RtlAllocateHeap(ProcessHeap, 0, ulRequired);
if (!pPartialInformation)
{
DPRINT("RtlAllocateHeap() failed\n");
NtClose(hDeviceKey);
return;
}
Status = NtQueryValueKey(
hDeviceKey,
&CompatibleIDsU,
KeyValuePartialInformation,
pPartialInformation,
ulRequired,
&ulRequired);
}
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
{
/* Nothing to do */
}
else if (!NT_SUCCESS(Status))
{
if (pPartialInformation)
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
NtClose(hDeviceKey);
DPRINT1("NtQueryValueKey() failed with status 0x%08x\n", Status);
return;
}
else if (pPartialInformation)
{
for (HardwareID = (LPCWSTR)pPartialInformation->Data;
(PUCHAR)HardwareID < pPartialInformation->Data + pPartialInformation->DataLength
&& *HardwareID
&& !bDriverInstalled;
HardwareID += wcslen(HardwareID) + 1)
{
bDriverInstalled = InstallDriver(hInf, hServices,hDeviceKey, DeviceId, HardwareID);
}
}
}
if (!bDriverInstalled)
DPRINT("No driver available for %S\n", DeviceId);
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
NtClose(hDeviceKey);
}
/****************************************************************************
*
* FUNCTION: LoadDeviceDriver( const TCHAR, const TCHAR, HANDLE *)
*
* PURPOSE: Registers a driver with the system configuration manager
* and then loads it.
*
****************************************************************************/
BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path,
HANDLE * lphDevice, PDWORD Error, BOOL extended)
{
SC_HANDLE schSCManager;
BOOL okay;
if (extended)
{
schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
if (schSCManager != NULL)
{
// Remove old instances
//RemoveDriver( schSCManager, Name );
// Ignore success of installation: it may already be installed.
okay = InstallDriver( schSCManager, Name, Path );
/* if (okay == FALSE)
{
if (Error != NULL)
*Error = GetLastError();
CloseServiceHandle( schSCManager );
return FALSE;
}
*/
// Ignore success of start: it may already be started.
okay = StartDriver( schSCManager, Name );
if (okay == FALSE)
{
if (Error != NULL)
{
*Error = GetLastError();
if ((*Error != ERROR_SERVICE_ALREADY_RUNNING))
{
CloseServiceHandle( schSCManager );
return FALSE;
}
}
else
{
CloseServiceHandle( schSCManager );
return FALSE;
}
}
CloseServiceHandle( schSCManager );
}
else {
if (Error != NULL)
*Error = GetLastError();
return FALSE;
}
}
// Do make sure we can open it.
okay = OpenDevice( Name, lphDevice );
if (okay == FALSE)
{
if (Error != NULL)
*Error = GetLastError();
}
return okay;
}
BOOLEAN
ManageDriver(
IN LPCTSTR DriverName,
IN LPCTSTR ServiceName,
IN USHORT Function
)
{
SC_HANDLE schSCManager;
BOOLEAN rCode = TRUE;
//
// Insure (somewhat) that the driver and service names are valid.
//
if (!DriverName || !ServiceName) {
printf("Invalid Driver or Service provided to ManageDriver() \n");
return FALSE;
}
//
// Connect to the Service Control Manager and open the Services database.
//
schSCManager = OpenSCManager(NULL, // local machine
NULL, // local database
SC_MANAGER_ALL_ACCESS // access required
);
if (!schSCManager) {
printf("Open SC Manager failed! Error = %d \n", GetLastError());
return FALSE;
}
//
// Do the requested function.
//
switch( Function ) {
case DRIVER_FUNC_INSTALL:
//
// Install the driver service.
//
if (InstallDriver(schSCManager,
DriverName,
ServiceName
)) {
//
// Start the driver service (i.e. start the driver).
//
rCode = StartDriver(schSCManager,
DriverName
);
} else {
//
// Indicate an error.
//
rCode = FALSE;
}
break;
case DRIVER_FUNC_REMOVE:
//
// Stop the driver.
//
StopDriver(schSCManager,
DriverName
);
//
// Remove the driver service.
//
RemoveDriver(schSCManager,
DriverName
);
//
// Ignore all errors.
//
rCode = TRUE;
break;
default:
printf("Unknown ManageDriver() function. \n");
rCode = FALSE;
break;
}
//
// Close handle to service control manager.
//
if (schSCManager) {
CloseServiceHandle(schSCManager);
}
return rCode;
} // ManageDriver
int __cdecl wmain(int argc, PWCHAR argv[]) {
size_t i;
WCHAR fileName[MAX_PATH];
WCHAR driverFullPath[MAX_PATH] = {0};
WCHAR type;
PVOID wow64OldValue;
DokanUseStdErr(TRUE); // Set dokan library debug output
Wow64DisableWow64FsRedirection(&wow64OldValue); // Disable system32 direct
// setlocale(LC_ALL, "");
GetModuleFileName(NULL, fileName, MAX_PATH);
// search the last "\"
for (i = wcslen(fileName) - 1; i > 0 && fileName[i] != L'\\'; --i) {
;
}
fileName[i] = L'\0';
ExpandEnvironmentStringsW(DOKAN_DRIVER_FULL_PATH, driverFullPath, MAX_PATH);
fwprintf(stdout, L"Driver path: '%s'\n", driverFullPath);
if (GetOption(argc, argv, 1) == L'v') {
fprintf(stdout, "dokanctl : %s %s\n", __DATE__, __TIME__);
fprintf(stdout, "Dokan version : %d\n", DokanVersion());
fprintf(stdout, "Dokan driver version : 0x%lx\n", DokanDriverVersion());
return EXIT_SUCCESS;
} else if (GetOption(argc, argv, 1) == L'u' && argc == 3) {
return Unmount(argv[2], FALSE);
} else if (GetOption(argc, argv, 1) == L'u' &&
GetOption(argc, argv, 3) == L'f' && argc == 4) {
return Unmount(argv[2], TRUE);
} else if (argc < 3 || wcslen(argv[1]) != 2 || argv[1][0] != L'/') {
return ShowUsage();
}
type = towlower(argv[2][0]);
switch (towlower(argv[1][1])) {
case L'i':
if (type == L'd') {
return InstallDriver(driverFullPath);
} else if (type == L'n') {
if (DokanNetworkProviderInstall())
fprintf(stdout, "network provider install ok\n");
else
fprintf(stderr, "network provider install failed\n");
}
break;
case L'r':
if (type == L'd') {
return DeleteDokanService(DOKAN_DRIVER_SERVICE);
} else if (type == L'n') {
if (DokanNetworkProviderUninstall())
fprintf(stdout, "network provider remove ok\n");
else
fprintf(stderr, "network provider remove failed\n");
}
break;
case L'd':
if (L'0' <= type && type <= L'9') {
ULONG mode = type - L'0';
if (DokanSetDebugMode(mode)) {
fprintf(stdout, "set debug mode ok\n");
} else {
fprintf(stderr, "set debug mode failed\n");
}
}
break;
case L'l': {
ULONG nbRead = 0;
DOKAN_CONTROL dokanControl[DOKAN_MAX_INSTANCES];
if (DokanGetMountPointList(dokanControl, DOKAN_MAX_INSTANCES, FALSE,
&nbRead)) {
fwprintf(stdout, L" Mount points: %d\n", nbRead);
for (unsigned int p = 0; p < nbRead; ++p) {
fwprintf(stdout, L" %d# MountPoint: %s - UNC: %s - DeviceName: %s\n",
p, dokanControl[p].MountPoint, dokanControl[p].UNCName,
dokanControl[p].DeviceName);
}
} else {
fwprintf(stderr, L" Cannot retrieve mount point list.\n");
}
} break;
default:
fprintf(stderr, "unknown option\n");
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
SC_HANDLE schSCManager;
BOOL remove = FALSE;
char *test_file = NULL;
char *curr_dep;
char ServiceName[256] = "";
char ServiceExe[256] = "";
curr_dep = &DependencyList[0];
for (;;) {
++argv;
--argc;
if (argv[0] == NULL)
break;
if (argv[0][0] != '-')
break;
switch( argv[0][1] ) {
case 'r':
remove = TRUE;
break;
case 'd':
strcpy( curr_dep, &argv[0][2] );
curr_dep += strlen( curr_dep ) + 1;
break;
case 's':
StartType = atoi( &argv[0][2] );
break;
case 'e':
ErrorControl = atoi( &argv[0][2] );
break;
case 't':
test_file = &argv[0][2];
break;
case 'q':
Quiet = TRUE;
break;
case 'h':
Usage();
break;
default:
fprintf( stderr, "Invalid option '%c'\n", argv[0][1] );
Usage();
break;
}
}
// Handle defaults if driver names are not specified
if (curr_dep == &DependencyList[0]) {
strcpy(curr_dep, "ParPort");
curr_dep += strlen(curr_dep) + 1;
}
if (argc < 1)
strcpy(ServiceName,"DbgPort");
else
strcpy(ServiceName,argv[0]);
if (argc < 2) {
GetSystemDirectory(ServiceExe,sizeof(ServiceExe));
strcat(ServiceExe,"\\drivers\\dbgport.sys");
}
else
strcpy(ServiceExe,argv[1]);
if (GetVersion() & 0x80000000) {
if (!Quiet) printf( "Not on Windows NT, can not install driver.\n" );
return 0;
}
if (test_file != NULL && OpenDevice(test_file)) {
if (!Quiet) printf( "Driver already running\n" );
return 0;
}
schSCManager = OpenSCManager (NULL, // machine (NULL == local)
NULL, // database (NULL == default)
SC_MANAGER_ALL_ACCESS // access required
);
if (schSCManager == NULL) {
fprintf( stderr, "Can not open service manager (%ld)\n", GetLastError() );
return 1;
}
if (remove) {
StopDriver( schSCManager, ServiceName );
RemoveDriver( schSCManager, ServiceName );
}
else if (ServiceExe == NULL) {
fprintf( stderr, "Missing service executable\n" );
Usage();
}
else {
*curr_dep = '\0';
if (InstallDriver( schSCManager, ServiceName, ServiceExe ) ) {
if (StartDriver( schSCManager, ServiceName ) ) {
if (test_file != NULL ) {
if (OpenDevice( test_file ) )
if( !Quiet ) printf( "Driver Installation SUCCESS\n" );
else
fprintf ( stderr, "Driver not started\n" );
}
}
}
}
CloseServiceHandle (schSCManager);
return 0;
}
