SUPLib-win.cpp@ 51907

Last change on this file since 51907 was 51907, checked in by vboxsync, 10 years ago
SUP: NT status code conversion fix + cleanups.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 22.6 KB

Line
1	/* $Id: SUPLib-win.cpp 51907 2014-07-07 17:15:05Z vboxsync $ */
2	/** @file
3	* VirtualBox Support Library - Windows NT specific parts.
4	*/
5
6	/*
7	* Copyright (C) 2006-2013 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27	/*******************************************************************************
28	* Header Files *
29	*******************************************************************************/
30	#define LOG_GROUP LOG_GROUP_SUP
31	#ifdef IN_SUP_HARDENED_R3
32	# undef DEBUG /* Warning: disables RT_STRICT */
33	# undef LOG_DISABLED
34	# define LOG_DISABLED
35	/** @todo RTLOGREL_DISABLED */
36	# include <iprt/log.h>
37	# undef LogRelIt
38	# define LogRelIt(pvInst, fFlags, iGroup, fmtargs) do { } while (0)
39	#endif
40
41	#define USE_NT_DEVICE_IO_CONTROL_FILE
42	#include <iprt/nt/nt-and-windows.h>
43
44	#include <VBox/sup.h>
45	#include <VBox/types.h>
46	#include <VBox/err.h>
47	#include <VBox/param.h>
48	#include <VBox/log.h>
49	#include <iprt/assert.h>
50	#include <iprt/path.h>
51	#include <iprt/string.h>
52	#include "../SUPLibInternal.h"
53	#include "../SUPDrvIOC.h"
54	#ifdef VBOX_WITH_HARDENING
55	# include "win/SUPHardenedVerify-win.h"
56	#endif
57
58
59	/*******************************************************************************
60	* Defined Constants And Macros *
61	*******************************************************************************/
62	/** The support service name. */
63	#define SERVICE_NAME "VBoxDrv"
64	/** Win32 Device name - system. */
65	#define DEVICE_NAME_SYS "\\\\.\\VBoxDrv"
66	/** Win32 Device name - user. */
67	#define DEVICE_NAME_USR "\\\\.\\VBoxDrvU"
68	/** NT Device name. */
69	#define DEVICE_NAME_NT L"\\Device\\VBoxDrv"
70	/** Win32 Symlink name. */
71	#define DEVICE_NAME_DOS L"\\DosDevices\\VBoxDrv"
72
73
74	/*******************************************************************************
75	* Internal Functions *
76	*******************************************************************************/
77	#ifndef IN_SUP_HARDENED_R3
78	static int suplibOsCreateService(void);
79	//unused: static int suplibOsUpdateService(void);
80	static int suplibOsDeleteService(void);
81	static int suplibOsStartService(void);
82	static int suplibOsStopService(void);
83	#endif
84	#ifdef USE_NT_DEVICE_IO_CONTROL_FILE
85	static int suplibConvertNtStatus(NTSTATUS rcNt);
86	#else
87	static int suplibConvertWin32Err(int);
88	#endif
89
90
91	int suplibOsInit(PSUPLIBDATA pThis, bool fPreInited, bool fUnrestricted)
92	{
93	/*
94	* Almost nothing to do if pre-inited.
95	*/
96	if (fPreInited)
97	{
98	#if defined(VBOX_WITH_HARDENING) && !defined(IN_SUP_HARDENED_R3)
99	# ifdef IN_SUP_R3_STATIC
100	return VERR_NOT_SUPPORTED;
101	# else
102	supR3HardenedWinInitVersion();
103	return supHardenedWinInitImageVerifier(NULL);
104	# endif
105	#else
106	return VINF_SUCCESS;
107	#endif
108	}
109
110	/*
111	* Try open the device.
112	*/
113	#ifndef IN_SUP_HARDENED_R3
114	uint32_t cTry = 0;
115	#endif
116	HANDLE hDevice;
117	for (;;)
118	{
119	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
120
121	static const WCHAR s_wszName[] = L"\\Device\\VBoxDrvU";
122	UNICODE_STRING NtName;
123	NtName.Buffer = (PWSTR)s_wszName;
124	NtName.Length = sizeof(s_wszName) - sizeof(WCHAR) * (fUnrestricted ? 2 : 1);
125	NtName.MaximumLength = NtName.Length;
126
127	OBJECT_ATTRIBUTES ObjAttr;
128	InitializeObjectAttributes(&ObjAttr, &NtName, OBJ_CASE_INSENSITIVE, NULL /hRootDir/, NULL /pSecDesc/);
129
130	hDevice = RTNT_INVALID_HANDLE_VALUE;
131
132	NTSTATUS rcNt = NtCreateFile(&hDevice,
133	GENERIC_READ \| GENERIC_WRITE,
134	&ObjAttr,
135	&Ios,
136	NULL /* Allocation Size*/,
137	FILE_ATTRIBUTE_NORMAL,
138	FILE_SHARE_READ \| FILE_SHARE_WRITE,
139	FILE_OPEN,
140	FILE_NON_DIRECTORY_FILE,
141	NULL /EaBuffer/,
142	0 /EaLength/);
143	if (NT_SUCCESS(rcNt))
144	rcNt = Ios.Status;
145	if (!NT_SUCCESS(rcNt))
146	{
147	#ifndef IN_SUP_HARDENED_R3
148	/*
149	* Failed to open, try starting the service and reopen the device
150	* exactly once.
151	*/
152	if (cTry == 0 && !NT_SUCCESS(rcNt))
153	{
154	cTry++;
155	suplibOsStartService();
156	continue;
157	}
158	#endif
159	switch (rcNt)
160	{
161	/** @todo someone must test what is actually returned. */
162	case STATUS_DEVICE_DOES_NOT_EXIST:
163	case STATUS_DEVICE_NOT_CONNECTED:
164	//case ERROR_BAD_DEVICE:
165	case STATUS_DEVICE_REMOVED:
166	//case ERROR_DEVICE_NOT_AVAILABLE:
167	return VERR_VM_DRIVER_LOAD_ERROR;
168	case STATUS_OBJECT_PATH_NOT_FOUND:
169	case STATUS_NO_SUCH_DEVICE:
170	case STATUS_NO_SUCH_FILE:
171	case STATUS_OBJECT_NAME_NOT_FOUND:
172	return VERR_VM_DRIVER_NOT_INSTALLED;
173	case STATUS_ACCESS_DENIED:
174	case STATUS_SHARING_VIOLATION:
175	return VERR_VM_DRIVER_NOT_ACCESSIBLE;
176	case STATUS_UNSUCCESSFUL:
177	return VERR_SUPLIB_NT_PROCESS_UNTRUSTED_0;
178	case STATUS_TRUST_FAILURE:
179	return VERR_SUPLIB_NT_PROCESS_UNTRUSTED_1;
180	case STATUS_TOO_LATE:
181	return VERR_SUPDRV_HARDENING_EVIL_HANDLE;
182	default:
183	if (SUP_NT_STATUS_IS_VBOX(rcNt)) /* See VBoxDrvNtErr2NtStatus. */
184	return SUP_NT_STATUS_TO_VBOX(rcNt);
185	return VERR_VM_DRIVER_OPEN_ERROR;
186	}
187	}
188	break;
189	}
190
191	/*
192	* We're done.
193	*/
194	pThis->hDevice = hDevice;
195	pThis->fUnrestricted = fUnrestricted;
196	return VINF_SUCCESS;
197	}
198
199	#ifndef IN_SUP_HARDENED_R3
200
201	int suplibOsInstall(void)
202	{
203	return suplibOsCreateService();
204	}
205
206
207	int suplibOsUninstall(void)
208	{
209	int rc = suplibOsStopService();
210	if (!rc)
211	rc = suplibOsDeleteService();
212	return rc;
213	}
214
215
216	/**
217	* Creates the service.
218	*
219	* @returns 0 on success.
220	* @returns -1 on failure.
221	*/
222	static int suplibOsCreateService(void)
223	{
224	/*
225	* Assume it didn't exist, so we'll create the service.
226	*/
227	SC_HANDLE hSMgrCreate = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
228	DWORD LastError = GetLastError(); NOREF(LastError);
229	AssertMsg(hSMgrCreate, ("OpenSCManager(,,create) failed rc=%d\n", LastError));
230	if (hSMgrCreate)
231	{
232	char szDriver[RTPATH_MAX];
233	int rc = RTPathExecDir(szDriver, sizeof(szDriver) - sizeof("\\VBoxDrv.sys"));
234	if (RT_SUCCESS(rc))
235	{
236	strcat(szDriver, "\\VBoxDrv.sys");
237	SC_HANDLE hService = CreateService(hSMgrCreate,
238	SERVICE_NAME,
239	"VBox Support Driver",
240	SERVICE_QUERY_STATUS,
241	SERVICE_KERNEL_DRIVER,
242	SERVICE_DEMAND_START,
243	SERVICE_ERROR_NORMAL,
244	szDriver,
245	NULL, NULL, NULL, NULL, NULL);
246	DWORD LastError = GetLastError(); NOREF(LastError);
247	AssertMsg(hService, ("CreateService failed! LastError=%Rwa szDriver=%s\n", LastError, szDriver));
248	CloseServiceHandle(hService);
249	CloseServiceHandle(hSMgrCreate);
250	return hService ? 0 : -1;
251	}
252	CloseServiceHandle(hSMgrCreate);
253	return rc;
254	}
255	return -1;
256	}
257
258
259	/**
260	* Stops a possibly running service.
261	*
262	* @returns 0 on success.
263	* @returns -1 on failure.
264	*/
265	static int suplibOsStopService(void)
266	{
267	/*
268	* Assume it didn't exist, so we'll create the service.
269	*/
270	int rc = -1;
271	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_STOP \| SERVICE_QUERY_STATUS);
272	DWORD LastError = GetLastError(); NOREF(LastError);
273	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError));
274	if (hSMgr)
275	{
276	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_STOP \| SERVICE_QUERY_STATUS);
277	if (hService)
278	{
279	/*
280	* Stop the service.
281	*/
282	SERVICE_STATUS Status;
283	QueryServiceStatus(hService, &Status);
284	if (Status.dwCurrentState == SERVICE_STOPPED)
285	rc = 0;
286	else if (ControlService(hService, SERVICE_CONTROL_STOP, &Status))
287	{
288	int iWait = 100;
289	while (Status.dwCurrentState == SERVICE_STOP_PENDING && iWait-- > 0)
290	{
291	Sleep(100);
292	QueryServiceStatus(hService, &Status);
293	}
294	if (Status.dwCurrentState == SERVICE_STOPPED)
295	rc = 0;
296	else
297	AssertMsgFailed(("Failed to stop service. status=%d\n", Status.dwCurrentState));
298	}
299	else
300	{
301	DWORD LastError = GetLastError(); NOREF(LastError);
302	AssertMsgFailed(("ControlService failed with LastError=%Rwa. status=%d\n", LastError, Status.dwCurrentState));
303	}
304	CloseServiceHandle(hService);
305	}
306	else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST)
307	rc = 0;
308	else
309	{
310	DWORD LastError = GetLastError(); NOREF(LastError);
311	AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
312	}
313	CloseServiceHandle(hSMgr);
314	}
315	return rc;
316	}
317
318
319	/**
320	* Deletes the service.
321	*
322	* @returns 0 on success.
323	* @returns -1 on failure.
324	*/
325	int suplibOsDeleteService(void)
326	{
327	/*
328	* Assume it didn't exist, so we'll create the service.
329	*/
330	int rc = -1;
331	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
332	DWORD LastError = GetLastError(); NOREF(LastError);
333	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError));
334	if (hSMgr)
335	{
336	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, DELETE);
337	if (hService)
338	{
339	/*
340	* Delete the service.
341	*/
342	if (DeleteService(hService))
343	rc = 0;
344	else
345	{
346	DWORD LastError = GetLastError(); NOREF(LastError);
347	AssertMsgFailed(("DeleteService failed LastError=%Rwa\n", LastError));
348	}
349	CloseServiceHandle(hService);
350	}
351	else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST)
352	rc = 0;
353	else
354	{
355	DWORD LastError = GetLastError(); NOREF(LastError);
356	AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
357	}
358	CloseServiceHandle(hSMgr);
359	}
360	return rc;
361	}
362
363	#if 0
364	/**
365	* Creates the service.
366	*
367	* @returns 0 on success.
368	* @returns -1 on failure.
369	*/
370	static int suplibOsUpdateService(void)
371	{
372	/*
373	* Assume it didn't exist, so we'll create the service.
374	*/
375	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG);
376	DWORD LastError = GetLastError(); NOREF(LastError);
377	AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed LastError=%Rwa\n", LastError));
378	if (hSMgr)
379	{
380	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_CHANGE_CONFIG);
381	if (hService)
382	{
383	char szDriver[RTPATH_MAX];
384	int rc = RTPathExecDir(szDriver, sizeof(szDriver) - sizeof("\\VBoxDrv.sys"));
385	if (RT_SUCCESS(rc))
386	{
387	strcat(szDriver, "\\VBoxDrv.sys");
388
389	SC_LOCK hLock = LockServiceDatabase(hSMgr);
390	if (ChangeServiceConfig(hService,
391	SERVICE_KERNEL_DRIVER,
392	SERVICE_DEMAND_START,
393	SERVICE_ERROR_NORMAL,
394	szDriver,
395	NULL, NULL, NULL, NULL, NULL, NULL))
396	{
397
398	UnlockServiceDatabase(hLock);
399	CloseServiceHandle(hService);
400	CloseServiceHandle(hSMgr);
401	return 0;
402	}
403	else
404	{
405	DWORD LastError = GetLastError(); NOREF(LastError);
406	AssertMsgFailed(("ChangeServiceConfig failed LastError=%Rwa\n", LastError));
407	}
408	}
409	UnlockServiceDatabase(hLock);
410	CloseServiceHandle(hService);
411	}
412	else
413	{
414	DWORD LastError = GetLastError(); NOREF(LastError);
415	AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError));
416	}
417	CloseServiceHandle(hSMgr);
418	}
419	return -1;
420	}
421	#endif
422
423
424	/**
425	* Attempts to start the service, creating it if necessary.
426	*
427	* @returns 0 on success.
428	* @returns -1 on failure.
429	* @param fRetry Indicates retry call.
430	*/
431	static int suplibOsStartService(void)
432	{
433	/*
434	* Check if the driver service is there.
435	*/
436	SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_QUERY_STATUS \| SERVICE_START);
437	if (hSMgr == NULL)
438	{
439	AssertMsgFailed(("couldn't open service manager in SERVICE_QUERY_CONFIG \| SERVICE_QUERY_STATUS mode!\n"));
440	return -1;
441	}
442
443	/*
444	* Try open our service to check it's status.
445	*/
446	SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_QUERY_STATUS \| SERVICE_START);
447	if (!hService)
448	{
449	/*
450	* Create the service.
451	*/
452	int rc = suplibOsCreateService();
453	if (rc)
454	return rc;
455
456	/*
457	* Try open the service.
458	*/
459	hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_QUERY_STATUS \| SERVICE_START);
460	}
461
462	/*
463	* Check if open and on demand create succeeded.
464	*/
465	int rc = -1;
466	if (hService)
467	{
468
469	/*
470	* Query service status to see if we need to start it or not.
471	*/
472	SERVICE_STATUS Status;
473	BOOL fRc = QueryServiceStatus(hService, &Status);
474	Assert(fRc);
475	if ( Status.dwCurrentState != SERVICE_RUNNING
476	&& Status.dwCurrentState != SERVICE_START_PENDING)
477	{
478	/*
479	* Start it.
480	*/
481	fRc = StartService(hService, 0, NULL);
482	DWORD LastError = GetLastError(); NOREF(LastError);
483	#ifndef DEBUG_bird
484	AssertMsg(fRc, ("StartService failed with LastError=%Rwa\n", LastError));
485	#endif
486	}
487
488	/*
489	* Wait for the service to finish starting.
490	* We'll wait for 10 seconds then we'll give up.
491	*/
492	QueryServiceStatus(hService, &Status);
493	if (Status.dwCurrentState == SERVICE_START_PENDING)
494	{
495	int iWait;
496	for (iWait = 100; iWait > 0 && Status.dwCurrentState == SERVICE_START_PENDING; iWait--)
497	{
498	Sleep(100);
499	QueryServiceStatus(hService, &Status);
500	}
501	DWORD LastError = GetLastError(); NOREF(LastError);
502	AssertMsg(Status.dwCurrentState != SERVICE_RUNNING,
503	("Failed to start. LastError=%Rwa iWait=%d status=%d\n",
504	LastError, iWait, Status.dwCurrentState));
505	}
506
507	if (Status.dwCurrentState == SERVICE_RUNNING)
508	rc = 0;
509
510	/*
511	* Close open handles.
512	*/
513	CloseServiceHandle(hService);
514	}
515	else
516	{
517	DWORD LastError = GetLastError(); NOREF(LastError);
518	AssertMsgFailed(("OpenService failed! LastError=%Rwa\n", LastError));
519	}
520	if (!CloseServiceHandle(hSMgr))
521	AssertFailed();
522
523	return rc;
524	}
525
526
527	int suplibOsTerm(PSUPLIBDATA pThis)
528	{
529	/*
530	* Check if we're inited at all.
531	*/
532	if (pThis->hDevice != NULL)
533	{
534	if (!CloseHandle((HANDLE)pThis->hDevice))
535	AssertFailed();
536	pThis->hDevice = NIL_RTFILE; /* yes, that's right */
537	}
538
539	return VINF_SUCCESS;
540	}
541
542
543	int suplibOsIOCtl(PSUPLIBDATA pThis, uintptr_t uFunction, void *pvReq, size_t cbReq)
544	{
545	/*
546	* Issue the device I/O control.
547	*/
548	PSUPREQHDR pHdr = (PSUPREQHDR)pvReq;
549	Assert(cbReq == RT_MAX(pHdr->cbIn, pHdr->cbOut));
550	# ifdef USE_NT_DEVICE_IO_CONTROL_FILE
551	IO_STATUS_BLOCK Ios;
552	Ios.Status = -1;
553	Ios.Information = 0;
554	NTSTATUS rcNt = NtDeviceIoControlFile((HANDLE)pThis->hDevice, NULL /hEvent/, NULL /pfnApc/, NULL /pvApcCtx/, &Ios,
555	(ULONG)uFunction,
556	pvReq /pvInput /, pHdr->cbIn /* cbInput */,
557	pvReq /pvOutput/, pHdr->cbOut /* cbOutput */);
558	if (NT_SUCCESS(rcNt))
559	{
560	if (NT_SUCCESS(Ios.Status))
561	return VINF_SUCCESS;
562	rcNt = Ios.Status;
563	}
564	return suplibConvertNtStatus(rcNt);
565
566	# else
567	DWORD cbReturned = (ULONG)pHdr->cbOut;
568	if (DeviceIoControl((HANDLE)pThis->hDevice, uFunction, pvReq, pHdr->cbIn, pvReq, cbReturned, &cbReturned, NULL))
569	return 0;
570	return suplibConvertWin32Err(GetLastError());
571	# endif
572	}
573
574
575	int suplibOsIOCtlFast(PSUPLIBDATA pThis, uintptr_t uFunction, uintptr_t idCpu)
576	{
577	/*
578	* Issue device I/O control.
579	*/
580	# ifdef USE_NT_DEVICE_IO_CONTROL_FILE
581	IO_STATUS_BLOCK Ios;
582	Ios.Status = -1;
583	Ios.Information = 0;
584	NTSTATUS rcNt = NtDeviceIoControlFile((HANDLE)pThis->hDevice, NULL /hEvent/, NULL /pfnApc/, NULL /pvApcCtx/, &Ios,
585	(ULONG)uFunction,
586	NULL /pvInput /, 0 /* cbInput */,
587	(PVOID)idCpu /pvOutput/, 0 /* cbOutput */);
588	if (NT_SUCCESS(rcNt))
589	{
590	if (NT_SUCCESS(Ios.Status))
591	return VINF_SUCCESS;
592	rcNt = Ios.Status;
593	}
594	return suplibConvertNtStatus(rcNt);
595	# else
596	DWORD cbReturned = 0;
597	if (DeviceIoControl((HANDLE)pThis->hDevice, uFunction, NULL, 0, (LPVOID)idCpu, 0, &cbReturned, NULL))
598	return VINF_SUCCESS;
599	return suplibConvertWin32Err(GetLastError());
600	# endif
601	}
602
603
604	int suplibOsPageAlloc(PSUPLIBDATA pThis, size_t cPages, void **ppvPages)
605	{
606	NOREF(pThis);
607	*ppvPages = VirtualAlloc(NULL, (size_t)cPages << PAGE_SHIFT, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
608	if (*ppvPages)
609	return VINF_SUCCESS;
610	return RTErrConvertFromWin32(GetLastError());
611	}
612
613
614	int suplibOsPageFree(PSUPLIBDATA pThis, void pvPages, size_t / cPages */)
615	{
616	NOREF(pThis);
617	if (VirtualFree(pvPages, 0, MEM_RELEASE))
618	return VINF_SUCCESS;
619	return RTErrConvertFromWin32(GetLastError());
620	}
621
622
623	# ifndef USE_NT_DEVICE_IO_CONTROL_FILE
624	/**
625	* Converts a supdrv win32 error code to an IPRT status code.
626	*
627	* @returns corresponding IPRT error code.
628	* @param rc Win32 error code.
629	*/
630	static int suplibConvertWin32Err(int rc)
631	{
632	/* Conversion program (link with ntdll.lib from ddk):
633	#define _WIN32_WINNT 0x0501
634	#include <windows.h>
635	#include <ntstatus.h>
636	#include <winternl.h>
637	#include <stdio.h>
638
639	int main()
640	{
641	#define CONVERT(a) printf(#a " %#x -> %d\n", a, RtlNtStatusToDosError((a)))
642	CONVERT(STATUS_SUCCESS);
643	CONVERT(STATUS_NOT_SUPPORTED);
644	CONVERT(STATUS_INVALID_PARAMETER);
645	CONVERT(STATUS_UNKNOWN_REVISION);
646	CONVERT(STATUS_INVALID_HANDLE);
647	CONVERT(STATUS_INVALID_ADDRESS);
648	CONVERT(STATUS_NOT_LOCKED);
649	CONVERT(STATUS_IMAGE_ALREADY_LOADED);
650	CONVERT(STATUS_ACCESS_DENIED);
651	CONVERT(STATUS_REVISION_MISMATCH);
652
653	return 0;
654	}
655	*/
656
657	switch (rc)
658	{
659	//case 0: return STATUS_SUCCESS;
660	case 0: return VINF_SUCCESS;
661	case ERROR_NOT_SUPPORTED: return VERR_GENERAL_FAILURE;
662	case ERROR_INVALID_PARAMETER: return VERR_INVALID_PARAMETER;
663	case ERROR_UNKNOWN_REVISION: return VERR_INVALID_MAGIC;
664	case ERROR_INVALID_HANDLE: return VERR_INVALID_HANDLE;
665	case ERROR_UNEXP_NET_ERR: return VERR_INVALID_POINTER;
666	case ERROR_NOT_LOCKED: return VERR_LOCK_FAILED;
667	case ERROR_SERVICE_ALREADY_RUNNING: return VERR_ALREADY_LOADED;
668	case ERROR_ACCESS_DENIED: return VERR_PERMISSION_DENIED;
669	case ERROR_REVISION_MISMATCH: return VERR_VERSION_MISMATCH;
670	}
671
672	/* fall back on the default conversion. */
673	return RTErrConvertFromWin32(rc);
674	}
675	# else
676	/**
677	* Reverse of VBoxDrvNtErr2NtStatus
678	* returns VBox status code.
679	* @param rcNt NT status code.
680	*/
681	static int suplibConvertNtStatus(NTSTATUS rcNt)
682	{
683	switch (rcNt)
684	{
685	case STATUS_SUCCESS: return VINF_SUCCESS;
686	case STATUS_NOT_SUPPORTED: return VERR_GENERAL_FAILURE;
687	case STATUS_INVALID_PARAMETER: return VERR_INVALID_PARAMETER;
688	case STATUS_UNKNOWN_REVISION: return VERR_INVALID_MAGIC;
689	case STATUS_INVALID_HANDLE: return VERR_INVALID_HANDLE;
690	case STATUS_INVALID_ADDRESS: return VERR_INVALID_POINTER;
691	case STATUS_NOT_LOCKED: return VERR_LOCK_FAILED;
692	case STATUS_IMAGE_ALREADY_LOADED: return VERR_ALREADY_LOADED;
693	case STATUS_ACCESS_DENIED: return VERR_PERMISSION_DENIED;
694	case STATUS_REVISION_MISMATCH: return VERR_VERSION_MISMATCH;
695	}
696
697	/* See VBoxDrvNtErr2NtStatus. */
698	if (SUP_NT_STATUS_IS_VBOX(rcNt))
699	return SUP_NT_STATUS_TO_VBOX(rcNt);
700
701	/* Fall back on IPRT for the rest. */
702	return RTErrConvertFromNtStatus(rcNt);
703	}
704	# endif
705
706	#endif /* !IN_SUP_HARDENED_R3 */
707

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/HostDrivers/Support/win/SUPLib-win.cpp@ 51907

Download in other formats: