diff options
Diffstat (limited to 'src/VBox/HostDrivers/VBoxUSB')
63 files changed, 23672 insertions, 0 deletions
diff --git a/src/VBox/HostDrivers/VBoxUSB/Makefile.kmk b/src/VBox/HostDrivers/VBoxUSB/Makefile.kmk new file mode 100644 index 00000000..f4ed3701 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/Makefile.kmk @@ -0,0 +1,77 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for the Windows USB drivers. +# + +# +# Copyright (C) 2006-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# +# The contents of this file may alternatively be used under the terms +# of the Common Development and Distribution License Version 1.0 +# (CDDL) only, as it comes in the "COPYING.CDDL" file of the +# VirtualBox OSE distribution, in which case the provisions of the +# CDDL are applicable instead of those of the GPL. +# +# You may elect to license modified versions of this file under the +# terms and conditions of either the GPL or the CDDL or both. +# + +SUB_DEPTH = ../../../.. +include $(KBUILD_PATH)/subheader.kmk + +# Include sub-makefiles. +if1of ($(KBUILD_TARGET), darwin solaris win) + include $(PATH_SUB_CURRENT)/$(KBUILD_TARGET)/Makefile.kmk +endif + +# +# USBLib - The static USB Library for use in VBoxSVC and VBoxDD. +# +# Note! Drivers using USBFilter.cpp should just add ../USBFilter.cpp +# to their source list. +# +LIBRARIES += USBLib +USBLib_TEMPLATE = VBOXR3 +USBLib_SDKS.win = ReorderCompilerIncs $(VBOX_WINPSDK) $(VBOX_WINDDK) +USBLib_DEFS = IN_USBLIB +USBLib_DEFS.os2 = STATIC_USBCALLS +USBLib_DEFS.win = _WIN32_WINNT=0x0501 +USBLib_SOURCES = \ + USBLib.cpp \ + USBFilter.cpp + +# OS specific bits if applicable. +USBLib_SOURCES.darwin = \ + darwin/USBLib-darwin.cpp +USBLib_SOURCES.os2 = \ + os2/usbcalls.c +USBLib_SOURCES.solaris = \ + solaris/USBLib-solaris.cpp +USBLib_SOURCES.win = \ + win/lib/VBoxUsbLib-win.cpp + +ifdef VBOX_WITH_TESTCASES + # + # USBFilter testcase. + # + PROGRAMS += tstUSBFilter + tstUSBFilter_TEMPLATE = VBOXR3TSTEXE + tstUSBFilter_DEFS = IN_USBLIB + tstUSBFilter_SOURCES = \ + testcase/tstUSBFilter.cpp + tstUSBFilter_LIBS = \ + $(USBLib_1_TARGET) +endif # VBOX_WITH_TESTCASES + + +# generate rules +include $(FILE_KBUILD_SUB_FOOTER) + diff --git a/src/VBox/HostDrivers/VBoxUSB/USBFilter.cpp b/src/VBox/HostDrivers/VBoxUSB/USBFilter.cpp new file mode 100644 index 00000000..93cabf32 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/USBFilter.cpp @@ -0,0 +1,1815 @@ +/* $Id: USBFilter.cpp $ */ +/** @file + * VirtualBox USB filter abstraction. + */ + +/* + * Copyright (C) 2007-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/usbfilter.h> +#include <VBox/usblib.h> +#include <VBox/err.h> +#include <VBox/log.h> +#include <iprt/string.h> +#include <iprt/assert.h> +#include <iprt/ctype.h> + + +/** @todo split this up for the sake of device drivers and such. */ + + +/** + * Initializes an USBFILTER structure. + * + * @param pFilter The filter to initialize. + * @param enmType The filter type. If not valid, the filter will not + * be properly initialized and all other calls will fail. + */ +USBLIB_DECL(void) USBFilterInit(PUSBFILTER pFilter, USBFILTERTYPE enmType) +{ + memset(pFilter, 0, sizeof(*pFilter)); + AssertReturnVoid(enmType > USBFILTERTYPE_INVALID && enmType < USBFILTERTYPE_END); + pFilter->u32Magic = USBFILTER_MAGIC; + pFilter->enmType = enmType; + for (unsigned i = 0; i < RT_ELEMENTS(pFilter->aFields); i++) + pFilter->aFields[i].enmMatch = USBFILTERMATCH_IGNORE; +} + + +/** + * Make a clone of the specified filter. + * + * @param pFilter The target filter. + * @param pToClone The source filter. + */ +USBLIB_DECL(void) USBFilterClone(PUSBFILTER pFilter, PCUSBFILTER pToClone) +{ + memcpy(pFilter, pToClone, sizeof(*pToClone)); +} + + +/** + * Deletes (invalidates) an USBFILTER structure. + * + * @param pFilter The filter to delete. + */ +USBLIB_DECL(void) USBFilterDelete(PUSBFILTER pFilter) +{ + pFilter->u32Magic = ~USBFILTER_MAGIC; + pFilter->enmType = USBFILTERTYPE_INVALID; + pFilter->offCurEnd = 0xfffff; +} + + +/** + * Skips blanks. + * + * @returns Next non-blank char in the string. + * @param psz The string. + */ +DECLINLINE(const char *) usbfilterSkipBlanks(const char *psz) +{ + while (RT_C_IS_BLANK(*psz)) + psz++; + return psz; +} + + +/** + * Worker for usbfilterReadNumber that parses a hexadecimal number. + * + * @returns Same as usbfilterReadNumber, except for VERR_NO_DIGITS. + * @param pszExpr Where to start converting, first char is a valid digit. + * @param ppszExpr See usbfilterReadNumber. + * @param pu16Val See usbfilterReadNumber. + */ +static int usbfilterReadNumberHex(const char *pszExpr, const char **ppszExpr, uint16_t *pu16Val) +{ + int rc = VINF_SUCCESS; + uint32_t u32 = 0; + do + { + unsigned uDigit = *pszExpr >= 'a' && *pszExpr <= 'f' + ? *pszExpr - 'a' + 10 + : *pszExpr >= 'A' && *pszExpr <= 'F' + ? *pszExpr - 'A' + 10 + : *pszExpr - '0'; + if (uDigit >= 16) + break; + u32 *= 16; + u32 += uDigit; + if (u32 > UINT16_MAX) + rc = VWRN_NUMBER_TOO_BIG; + } while (*++pszExpr); + + *ppszExpr = usbfilterSkipBlanks(pszExpr); + *pu16Val = rc == VINF_SUCCESS ? u32 : UINT16_MAX; + return VINF_SUCCESS; +} + + +/** + * Worker for usbfilterReadNumber that parses a decimal number. + * + * @returns Same as usbfilterReadNumber, except for VERR_NO_DIGITS. + * @param pszExpr Where to start converting, first char is a valid digit. + * @param uBase The base - 8 or 16. + * @param ppszExpr See usbfilterReadNumber. + * @param pu16Val See usbfilterReadNumber. + */ +static int usbfilterReadNumberDecimal(const char *pszExpr, unsigned uBase, const char **ppszExpr, uint16_t *pu16Val) +{ + int rc = VINF_SUCCESS; + uint32_t u32 = 0; + do + { + unsigned uDigit = *pszExpr - '0'; + if (uDigit >= uBase) + break; + u32 *= uBase; + u32 += uDigit; + if (u32 > UINT16_MAX) + rc = VWRN_NUMBER_TOO_BIG; + } while (*++pszExpr); + + *ppszExpr = usbfilterSkipBlanks(pszExpr); + *pu16Val = rc == VINF_SUCCESS ? u32 : UINT16_MAX; + return rc; +} + + +/** + * Reads a number from a numeric expression. + * + * @returns IPRT status code. + * @retval VINF_SUCCESS if all is fine. *ppszExpr and *pu16Val are updated. + * @retval VWRN_NUMBER_TOO_BIG if the number exceeds unsigned 16-bit, both *ppszExpr and *pu16Val are updated. + * @retval VERR_NO_DIGITS if there aren't any digits. + * + * @param ppszExpr Pointer to the current expression pointer. + * This is advanced past the expression and trailing blanks on success. + * @param pu16Val Where to store the value on success. + */ +static int usbfilterReadNumber(const char **ppszExpr, uint16_t *pu16Val) +{ + const char *pszExpr = usbfilterSkipBlanks(*ppszExpr); + if (!RT_C_IS_DIGIT(*pszExpr)) + return VERR_NO_DIGITS; + + if (*pszExpr == '0') + { + if (pszExpr[1] == 'x' || pszExpr[1] == 'X') + { + if (!RT_C_IS_XDIGIT(pszExpr[2])) + return VERR_NO_DIGITS; + return usbfilterReadNumberHex(pszExpr + 2, ppszExpr, pu16Val); + } + if (RT_C_IS_ODIGIT(pszExpr[1])) + return usbfilterReadNumberDecimal(pszExpr + 1, 8, ppszExpr, pu16Val); + /* Solitary 0! */ + if (RT_C_IS_DIGIT(pszExpr[1])) + return VERR_NO_DIGITS; + } + return usbfilterReadNumberDecimal(pszExpr, 10, ppszExpr, pu16Val); +} + + +/** + * Validates a numeric expression. + * + * @returns VBox status code. + * @retval VINF_SUCCESS if valid. + * @retval VERR_INVALID_PARAMETER if invalid. + * @retval VERR_NO_DIGITS if some expression is short of digits. + * + * @param pszExpr The numeric expression. + */ +static int usbfilterValidateNumExpression(const char *pszExpr) +{ + /* + * An empty expression is fine. + */ + if (!*pszExpr) + return VINF_SUCCESS; + + /* + * The string format is: "(<m>|([<m>]-[<n>]))|(<m>|([<m>]-[<n>]))+" + * where <m> and <n> are numbers in the decimal, hex (0xNNN) or octal (0NNN) + * form. Spaces are allowed around <m> and <n>. + */ + unsigned cSubExpressions = 0; + while (*pszExpr) + { + /* + * Skip remnants of the previous expression and any empty expressions. + * ('|' is the expression separator.) + */ + while (*pszExpr == '|' || RT_C_IS_BLANK(*pszExpr)) + pszExpr++; + if (!*pszExpr) + break; + + /* + * Parse the expression. + */ + int rc; + uint16_t u16First = 0; + uint16_t u16Last = 0; + if (*pszExpr == '-') + { + /* -N */ + pszExpr++; + rc = usbfilterReadNumber(&pszExpr, &u16Last); + } + else + { + /* M or M-N */ + rc = usbfilterReadNumber(&pszExpr, &u16First); + if (RT_SUCCESS(rc)) + { + if (*pszExpr == '-') + { + /* M-N */ + pszExpr++; + rc = usbfilterReadNumber(&pszExpr, &u16Last); + } + else + { + /* M */ + u16Last = u16First; + } + } + } + if (RT_FAILURE(rc)) + return rc; + + /* + * We should either be at the end of the string or at + * an expression separator (|). + */ + if (*pszExpr && *pszExpr != '|' ) + return VERR_INVALID_PARAMETER; + + cSubExpressions++; + } + + return cSubExpressions ? VINF_SUCCESS : VERR_INVALID_PARAMETER; +} + + +/** + * Validates a string pattern. + * + * @returns VBox status code. + * @retval VINF_SUCCESS if valid. + * @retval VERR_INVALID_PARAMETER if invalid. + * + * @param psz The string pattern. + */ +static int usbfilterValidateStringPattern(const char *psz) +{ + /* + * This is only becomes important if we start doing + * sets ([0-9]) and such like. + */ + RT_NOREF1(psz); + return VINF_SUCCESS; +} + + +/** + * Thoroughly validates the USB Filter. + * + * @returns Appropriate VBox status code. + * @param pFilter The filter to validate. + */ +USBLIB_DECL(int) USBFilterValidate(PCUSBFILTER pFilter) +{ + if (!VALID_PTR(pFilter)) + return VERR_INVALID_POINTER; + + if (pFilter->u32Magic != USBFILTER_MAGIC) + return VERR_INVALID_MAGIC; + + if ( pFilter->enmType <= USBFILTERTYPE_INVALID + || pFilter->enmType >= USBFILTERTYPE_END) + { + Log(("USBFilter: %p - enmType=%d!\n", pFilter, pFilter->enmType)); + return VERR_INVALID_PARAMETER; + } + + if (pFilter->offCurEnd >= sizeof(pFilter->achStrTab)) + { + Log(("USBFilter: %p - offCurEnd=%#x!\n", pFilter, pFilter->offCurEnd)); + return VERR_INVALID_PARAMETER; + } + + /* + * Validate the string table. + */ + if (pFilter->achStrTab[0]) + { + Log(("USBFilter: %p - bad null string\n", pFilter)); + return VERR_INVALID_PARAMETER; + } + + const char *psz = &pFilter->achStrTab[1]; + while (psz < &pFilter->achStrTab[pFilter->offCurEnd]) + { + const char *pszEnd = RTStrEnd(psz, &pFilter->achStrTab[sizeof(pFilter->achStrTab)] - psz); + if (!pszEnd) + { + Log(("USBFilter: %p - string at %#x isn't terminated!\n", + pFilter, psz - &pFilter->achStrTab[0])); + return VERR_INVALID_PARAMETER; + } + + uint16_t off = (uint16_t)(uintptr_t)(psz - &pFilter->achStrTab[0]); + unsigned i; + for (i = 0; i < RT_ELEMENTS(pFilter->aFields); i++) + if ( USBFilterIsMethodString((USBFILTERMATCH)pFilter->aFields[i].enmMatch) + && pFilter->aFields[i].u16Value == off) + break; + if (i >= RT_ELEMENTS(pFilter->aFields)) + { + Log(("USBFilter: %p - string at %#x isn't used by anyone! (%s)\n", + pFilter, psz - &pFilter->achStrTab[0], psz)); + return VERR_INVALID_PARAMETER; + } + + psz = pszEnd + 1; + } + + if ((uintptr_t)(psz - &pFilter->achStrTab[0] - 1) != pFilter->offCurEnd) + { + Log(("USBFilter: %p - offCurEnd=%#x currently at %#x\n", + pFilter, pFilter->offCurEnd, psz - &pFilter->achStrTab[0] - 1)); + return VERR_INVALID_PARAMETER; + } + + while (psz < &pFilter->achStrTab[sizeof(pFilter->achStrTab)]) + { + if (*psz) + { + Log(("USBFilter: %p - str tab isn't zero padded! %#x: %c\n", + pFilter, psz - &pFilter->achStrTab[0], *psz)); + return VERR_INVALID_PARAMETER; + } + psz++; + } + + + /* + * Validate the fields. + */ + int rc; + for (unsigned i = 0; i < RT_ELEMENTS(pFilter->aFields); i++) + { + switch (pFilter->aFields[i].enmMatch) + { + case USBFILTERMATCH_IGNORE: + case USBFILTERMATCH_PRESENT: + if (pFilter->aFields[i].u16Value) + { + Log(("USBFilter: %p - #%d/%d u16Value=%d expected 0!\n", + pFilter, i, pFilter->aFields[i].enmMatch, pFilter->aFields[i].u16Value)); + return VERR_INVALID_PARAMETER; + } + break; + + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + if (!USBFilterIsNumericField((USBFILTERIDX)i)) + { + Log(("USBFilter: %p - #%d / %d - not numeric field\n", + pFilter, i, pFilter->aFields[i].enmMatch)); + return VERR_INVALID_PARAMETER; + } + break; + + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + if (!USBFilterIsNumericField((USBFILTERIDX)i)) + { + Log(("USBFilter: %p - #%d / %d - not numeric field\n", + pFilter, i, pFilter->aFields[i].enmMatch)); + return VERR_INVALID_PARAMETER; + } + if ( pFilter->aFields[i].u16Value >= pFilter->offCurEnd + && pFilter->offCurEnd) + { + Log(("USBFilter: %p - #%d / %d - off=%#x max=%#x\n", + pFilter, i, pFilter->aFields[i].enmMatch, pFilter->aFields[i].u16Value, pFilter->offCurEnd)); + return VERR_INVALID_PARAMETER; + } + psz = &pFilter->achStrTab[pFilter->aFields[i].u16Value]; + rc = usbfilterValidateNumExpression(psz); + if (RT_FAILURE(rc)) + { + Log(("USBFilter: %p - #%d / %d - bad num expr: %s (rc=%Rrc)\n", + pFilter, i, pFilter->aFields[i].enmMatch, psz, rc)); + return rc; + } + break; + + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_EXACT_NP: + if (!USBFilterIsStringField((USBFILTERIDX)i)) + { + Log(("USBFilter: %p - #%d / %d - not string field\n", + pFilter, i, pFilter->aFields[i].enmMatch)); + return VERR_INVALID_PARAMETER; + } + if ( pFilter->aFields[i].u16Value >= pFilter->offCurEnd + && pFilter->offCurEnd) + { + Log(("USBFilter: %p - #%d / %d - off=%#x max=%#x\n", + pFilter, i, pFilter->aFields[i].enmMatch, pFilter->aFields[i].u16Value, pFilter->offCurEnd)); + return VERR_INVALID_PARAMETER; + } + break; + + case USBFILTERMATCH_STR_PATTERN: + case USBFILTERMATCH_STR_PATTERN_NP: + if (!USBFilterIsStringField((USBFILTERIDX)i)) + { + Log(("USBFilter: %p - #%d / %d - not string field\n", + pFilter, i, pFilter->aFields[i].enmMatch)); + return VERR_INVALID_PARAMETER; + } + if ( pFilter->aFields[i].u16Value >= pFilter->offCurEnd + && pFilter->offCurEnd) + { + Log(("USBFilter: %p - #%d / %d - off=%#x max=%#x\n", + pFilter, i, pFilter->aFields[i].enmMatch, pFilter->aFields[i].u16Value, pFilter->offCurEnd)); + return VERR_INVALID_PARAMETER; + } + psz = &pFilter->achStrTab[pFilter->aFields[i].u16Value]; + rc = usbfilterValidateStringPattern(psz); + if (RT_FAILURE(rc)) + { + Log(("USBFilter: %p - #%d / %d - bad string pattern: %s (rc=%Rrc)\n", + pFilter, i, pFilter->aFields[i].enmMatch, psz, rc)); + return rc; + } + break; + + default: + Log(("USBFilter: %p - #%d enmMatch=%d!\n", pFilter, i, pFilter->aFields[i].enmMatch)); + return VERR_INVALID_PARAMETER; + } + } + + return VINF_SUCCESS; +} + + +/** + * Find the specified field in the string table. + * + * @returns Pointer to the string in the string table on success. + * NULL if the field is invalid or it doesn't have a string value. + * @param pFilter The filter. + * @param enmFieldIdx The field index. + */ +DECLINLINE(const char *) usbfilterGetString(PCUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + if ((unsigned)enmFieldIdx < (unsigned)USBFILTERIDX_END) + { + switch (pFilter->aFields[enmFieldIdx].enmMatch) + { + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_EXACT_NP: + case USBFILTERMATCH_STR_PATTERN: + case USBFILTERMATCH_STR_PATTERN_NP: + Assert(pFilter->aFields[enmFieldIdx].u16Value < sizeof(pFilter->achStrTab)); + return &pFilter->achStrTab[pFilter->aFields[enmFieldIdx].u16Value]; + + default: + AssertMsgFailed(("%d\n", pFilter->aFields[enmFieldIdx].enmMatch)); + case USBFILTERMATCH_IGNORE: + case USBFILTERMATCH_PRESENT: + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + break; + } + } + return NULL; +} + + +/** + * Gets a number value of a field. + * + * The field must contain a numeric value. + * + * @returns The field value on success, -1 on failure (invalid input / not numeric). + * @param pFilter The filter. + * @param enmFieldIdx The field index. + */ +DECLINLINE(int) usbfilterGetNum(PCUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + if ((unsigned)enmFieldIdx < (unsigned)USBFILTERIDX_END) + { + switch (pFilter->aFields[enmFieldIdx].enmMatch) + { + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + return pFilter->aFields[enmFieldIdx].u16Value; + + default: + AssertMsgFailed(("%d\n", pFilter->aFields[enmFieldIdx].enmMatch)); + case USBFILTERMATCH_IGNORE: + case USBFILTERMATCH_PRESENT: + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_EXACT_NP: + case USBFILTERMATCH_STR_PATTERN: + case USBFILTERMATCH_STR_PATTERN_NP: + break; + } + } + return -1; +} + + +/** + * Performs simple pattern matching. + * + * @returns true on match and false on mismatch. + * @param pszExpr The numeric expression. + * @param u16Value The value to match. + */ +static bool usbfilterMatchNumExpression(const char *pszExpr, uint16_t u16Value) +{ + /* + * The string format is: "(<m>|([<m>]-[<n>]))|(<m>|([<m>]-[<n>]))+" + * where <m> and <n> are numbers in the decimal, hex (0xNNN) or octal (0NNN) + * form. Spaces are allowed around <m> and <n>. + */ + while (*pszExpr) + { + /* + * Skip remnants of the previous expression and any empty expressions. + * ('|' is the expression separator.) + */ + while (*pszExpr == '|' || RT_C_IS_BLANK(*pszExpr)) + pszExpr++; + if (!*pszExpr) + break; + + /* + * Parse the expression. + */ + int rc; + uint16_t u16First = 0; + uint16_t u16Last = 0; + if (*pszExpr == '-') + { + /* -N */ + pszExpr++; + rc = usbfilterReadNumber(&pszExpr, &u16Last); + } + else + { + /* M or M-N */ + rc = usbfilterReadNumber(&pszExpr, &u16First); + if (RT_SUCCESS(rc)) + { + pszExpr = usbfilterSkipBlanks(pszExpr); + if (*pszExpr == '-') + { + /* M-N */ + pszExpr++; + rc = usbfilterReadNumber(&pszExpr, &u16Last); + } + else + { + /* M */ + u16Last = u16First; + } + } + } + + /* On success, we should either be at the end of the string or + at an expression separator (|). */ + if (RT_SUCCESS(rc) && *pszExpr && *pszExpr != '|' ) + rc = VERR_INVALID_PARAMETER; + if (RT_SUCCESS(rc)) + { + /* + * Swap the values if the order is mixed up. + */ + if (u16First > u16Last) + { + uint16_t u16Tmp = u16First; + u16First = u16Last; + u16Last = u16Tmp; + } + + /* + * Perform the compare. + */ + if ( u16Value >= u16First + && u16Value <= u16Last) + return true; + } + else + { + /* + * Skip the bad expression. + * ('|' is the expression separator.) + */ + while (*pszExpr && *pszExpr != '|') + pszExpr++; + } + } + + return false; +} + + +/** + * Performs simple pattern matching. + * + * @returns true on match and false on mismatch. + * @param pszPattern The pattern to match against. + * @param psz The string to match. + */ +static bool usbfilterMatchStringPattern(const char *pszPattern, const char *psz) +{ + char ch; + while ((ch = *pszPattern++)) + { + if (ch == '?') + { + /* + * Matches one char or end of string. + */ + if (*psz) + psz++; + } + else if (ch == '*') + { + /* + * Matches zero or more characters. + */ + /* skip subsequent wildcards */ + while ( (ch = *pszPattern) == '*' + || ch == '?') + pszPattern++; + if (!ch) + /* Pattern ends with a '*' and thus matches the rest of psz. */ + return true; + + /* Find the length of the following exact pattern sequence. */ + ssize_t cchMatch = 1; + while ( (ch = pszPattern[cchMatch]) != '\0' + && ch != '*' + && ch != '?') + cchMatch++; + + /* Check if the exact pattern sequence is too long. */ + ssize_t cch = strlen(psz); + cch -= cchMatch; + if (cch < 0) + return false; + + /* Is the rest an exact match? */ + if (!ch) + return memcmp(psz + cch, pszPattern, cchMatch) == 0; + + /* + * This is where things normally starts to get recursive or ugly. + * + * Just to make life simple, we'll skip the nasty stuff and say + * that we will do a maximal wildcard match and forget about any + * alternative matches. + * + * If somebody is bored out of their mind one day, feel free to + * implement correct matching without using recursion. + */ + ch = *pszPattern; + const char *pszMatch = NULL; + while ( cch-- >= 0 + && *psz) + { + if ( *psz == ch + && !strncmp(psz, pszPattern, cchMatch)) + pszMatch = psz; + psz++; + } + if (!pszMatch) + return false; + + /* advance */ + psz = pszMatch + cchMatch; + pszPattern += cchMatch; + } + else + { + /* exact match */ + if (ch != *psz) + return false; + psz++; + } + } + + return *psz == '\0'; +} + + +/** + * Match a filter against a device. + * + * @returns true if they match, false if not. + * + * @param pFilter The filter to match with. + * @param pDevice The device data. This is a filter (type ignored) that + * contains 'exact' values for all present fields and 'ignore' + * values for the non-present fields. + * + * @remark Both the filter and the device are ASSUMED to be valid because + * we don't wish to waste any time in this function. + */ +USBLIB_DECL(bool) USBFilterMatch(PCUSBFILTER pFilter, PCUSBFILTER pDevice) +{ + return USBFilterMatchRated(pFilter, pDevice) > 0; +} + + +#if 0 /*def IN_RING0*/ /** @todo convert to proper logging. */ +extern "C" int printf(const char *format, ...); +# define dprintf(a) printf a +#else +# define dprintf(a) do {} while (0) +#endif + +/** + * Match a filter against a device and rate the result. + * + * @returns -1 if no match, matching rate between 1 and 100 (inclusive) if matched. + * + * @param pFilter The filter to match with. + * @param pDevice The device data. This is a filter (type ignored) that + * contains 'exact' values for all present fields and 'ignore' + * values for the non-present fields. + * + * @remark Both the filter and the device are ASSUMED to be valid because + * we don't wish to waste any time in this function. + */ +USBLIB_DECL(int) USBFilterMatchRated(PCUSBFILTER pFilter, PCUSBFILTER pDevice) +{ + unsigned iRate = 0; +dprintf(("USBFilterMatchRated: %p %p\n", pFilter, pDevice)); + + for (unsigned i = 0; i < RT_ELEMENTS(pFilter->aFields); i++) + { + switch (pFilter->aFields[i].enmMatch) + { + case USBFILTERMATCH_IGNORE: + iRate += 2; + break; + + case USBFILTERMATCH_PRESENT: + if (pDevice->aFields[i].enmMatch == USBFILTERMATCH_IGNORE) + { +dprintf(("filter match[%d]: !present\n", i)); + return -1; + } + iRate += 2; + break; + + case USBFILTERMATCH_NUM_EXACT: + if ( pDevice->aFields[i].enmMatch == USBFILTERMATCH_IGNORE + || pFilter->aFields[i].u16Value != pDevice->aFields[i].u16Value) + { +if (pDevice->aFields[i].enmMatch == USBFILTERMATCH_IGNORE) + dprintf(("filter match[%d]: !num_exact device=ignore\n", i)); +else + dprintf(("filter match[%d]: !num_exact %#x (filter) != %#x (device)\n", i, pFilter->aFields[i].u16Value, pDevice->aFields[i].u16Value)); + return -1; + } + iRate += 2; + break; + + case USBFILTERMATCH_NUM_EXACT_NP: + if ( pDevice->aFields[i].enmMatch != USBFILTERMATCH_IGNORE + && pFilter->aFields[i].u16Value != pDevice->aFields[i].u16Value) + { +dprintf(("filter match[%d]: !num_exact_np %#x (filter) != %#x (device)\n", i, pFilter->aFields[i].u16Value, pDevice->aFields[i].u16Value)); + return -1; + } + iRate += 2; + break; + + case USBFILTERMATCH_NUM_EXPRESSION: + if ( pDevice->aFields[i].enmMatch == USBFILTERMATCH_IGNORE + || !usbfilterMatchNumExpression(usbfilterGetString(pFilter, (USBFILTERIDX)i), + pDevice->aFields[i].u16Value)) + { +dprintf(("filter match[%d]: !num_expression\n", i)); + return -1; + } + iRate += 1; + break; + + case USBFILTERMATCH_NUM_EXPRESSION_NP: + if ( pDevice->aFields[i].enmMatch != USBFILTERMATCH_IGNORE + && !usbfilterMatchNumExpression(usbfilterGetString(pFilter, (USBFILTERIDX)i), + pDevice->aFields[i].u16Value)) + { +dprintf(("filter match[%d]: !num_expression_no\n", i)); + return -1; + } + iRate += 1; + break; + + case USBFILTERMATCH_STR_EXACT: + if ( pDevice->aFields[i].enmMatch == USBFILTERMATCH_IGNORE + || strcmp(usbfilterGetString(pFilter, (USBFILTERIDX)i), + usbfilterGetString(pDevice, (USBFILTERIDX)i))) + { +dprintf(("filter match[%d]: !str_exact\n", i)); + return -1; + } + iRate += 2; + break; + + case USBFILTERMATCH_STR_EXACT_NP: + if ( pDevice->aFields[i].enmMatch != USBFILTERMATCH_IGNORE + && strcmp(usbfilterGetString(pFilter, (USBFILTERIDX)i), + usbfilterGetString(pDevice, (USBFILTERIDX)i))) + { +dprintf(("filter match[%d]: !str_exact_np\n", i)); + return -1; + } + iRate += 2; + break; + + case USBFILTERMATCH_STR_PATTERN: + if ( pDevice->aFields[i].enmMatch == USBFILTERMATCH_IGNORE + || !usbfilterMatchStringPattern(usbfilterGetString(pFilter, (USBFILTERIDX)i), + usbfilterGetString(pDevice, (USBFILTERIDX)i))) + { +dprintf(("filter match[%d]: !str_pattern\n", i)); + return -1; + } + iRate += 1; + break; + + case USBFILTERMATCH_STR_PATTERN_NP: + if ( pDevice->aFields[i].enmMatch != USBFILTERMATCH_IGNORE + && !usbfilterMatchStringPattern(usbfilterGetString(pFilter, (USBFILTERIDX)i), + usbfilterGetString(pDevice, (USBFILTERIDX)i))) + { +dprintf(("filter match[%d]: !str_pattern_np\n", i)); + return -1; + } + iRate += 1; + break; + + default: + AssertMsgFailed(("#%d: %d\n", i, pFilter->aFields[i].enmMatch)); + return -1; + } + } + + /* iRate is the range 0..2*cFields - recalc to percent. */ +dprintf(("filter match: iRate=%d", iRate)); + return iRate == 2 * RT_ELEMENTS(pFilter->aFields) + ? 100 + : (iRate * 100) / (2 * RT_ELEMENTS(pFilter->aFields)); +} + + +/** + * Match a filter against a USBDEVICE. + * + * @returns true if they match, false if not. + * + * @param pFilter The filter to match with. + * @param pDevice The device to match. + * + * @remark Both the filter and the device are ASSUMED to be valid because + * we don't wish to waste any time in this function. + */ +USBLIB_DECL(bool) USBFilterMatchDevice(PCUSBFILTER pFilter, PUSBDEVICE pDevice) +{ + for (unsigned i = 0; i < RT_ELEMENTS(pFilter->aFields); i++) + { + switch (pFilter->aFields[i].enmMatch) + { + case USBFILTERMATCH_IGNORE: + break; + + case USBFILTERMATCH_PRESENT: + { + const char *psz; + switch (i) + { + case USBFILTERIDX_MANUFACTURER_STR: psz = pDevice->pszManufacturer; break; + case USBFILTERIDX_PRODUCT_STR: psz = pDevice->pszProduct; break; + case USBFILTERIDX_SERIAL_NUMBER_STR: psz = pDevice->pszSerialNumber; break; + default: psz = ""; break; + } + if (!psz) + return false; + break; + } + + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + { + uint16_t u16Value; + switch (i) + { + case USBFILTERIDX_VENDOR_ID: u16Value = pDevice->idVendor; break; + case USBFILTERIDX_PRODUCT_ID: u16Value = pDevice->idProduct; break; + case USBFILTERIDX_DEVICE: u16Value = pDevice->bcdDevice; break; + case USBFILTERIDX_DEVICE_CLASS: u16Value = pDevice->bDeviceClass; break; + case USBFILTERIDX_DEVICE_SUB_CLASS: u16Value = pDevice->bDeviceSubClass; break; + case USBFILTERIDX_DEVICE_PROTOCOL: u16Value = pDevice->bDeviceProtocol; break; + case USBFILTERIDX_BUS: u16Value = pDevice->bBus; break; + case USBFILTERIDX_PORT: u16Value = pDevice->bPort; break; + default: u16Value = UINT16_MAX; break; + + } + switch (pFilter->aFields[i].enmMatch) + { + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + if (pFilter->aFields[i].u16Value != u16Value) + return false; + break; + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + if (!usbfilterMatchNumExpression(usbfilterGetString(pFilter, (USBFILTERIDX)i), u16Value)) + return false; + break; + } + break; + } + + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_EXACT_NP: + case USBFILTERMATCH_STR_PATTERN: + case USBFILTERMATCH_STR_PATTERN_NP: + { + const char *psz; + switch (i) + { + case USBFILTERIDX_MANUFACTURER_STR: psz = pDevice->pszManufacturer; break; + case USBFILTERIDX_PRODUCT_STR: psz = pDevice->pszProduct; break; + case USBFILTERIDX_SERIAL_NUMBER_STR: psz = pDevice->pszSerialNumber; break; + default: psz = NULL; break; + } + switch (pFilter->aFields[i].enmMatch) + { + case USBFILTERMATCH_STR_EXACT: + if ( !psz + || strcmp(usbfilterGetString(pFilter, (USBFILTERIDX)i), psz)) + return false; + break; + + case USBFILTERMATCH_STR_EXACT_NP: + if ( psz + && strcmp(usbfilterGetString(pFilter, (USBFILTERIDX)i), psz)) + return false; + break; + + case USBFILTERMATCH_STR_PATTERN: + if ( !psz + || !usbfilterMatchStringPattern(usbfilterGetString(pFilter, (USBFILTERIDX)i), psz)) + return false; + break; + + case USBFILTERMATCH_STR_PATTERN_NP: + if ( psz + && !usbfilterMatchStringPattern(usbfilterGetString(pFilter, (USBFILTERIDX)i), psz)) + return false; + break; + } + break; + } + + default: + AssertMsgFailed(("#%d: %d\n", i, pFilter->aFields[i].enmMatch)); + return false; + } + } + + return true; +} + + +/** + * Checks if the two filters are identical. + * + * @returns true if the are identical, false if they aren't. + * @param pFilter The first filter. + * @param pFilter2 The second filter. + */ +USBLIB_DECL(bool) USBFilterIsIdentical(PCUSBFILTER pFilter, PCUSBFILTER pFilter2) +{ + /* Lazy works here because we're darn strict with zero padding and such elsewhere. */ + return memcmp(pFilter, pFilter2, sizeof(*pFilter)) == 0; +} + + + +/** + * Sets the filter type. + * + * @returns VBox status code. + * @retval VERR_INVALID_PARAMETER if the filter type is invalid. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmType The new filter type. + */ +USBLIB_DECL(int) USBFilterSetFilterType(PUSBFILTER pFilter, USBFILTERTYPE enmType) +{ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, VERR_INVALID_MAGIC); + AssertReturn(enmType > USBFILTERTYPE_INVALID && enmType < USBFILTERTYPE_END, VERR_INVALID_PARAMETER); + + pFilter->enmType = enmType; + return VINF_SUCCESS; +} + + +/** + * Replaces the string value of a field. + * + * This will remove any existing string value current held by the field from the + * string table and then attempt to add the new value. This function can be used + * to delete any assigned string before changing the type to numeric by passing + * in an empty string. This works because the first byte in the string table is + * reserved for the empty (NULL) string. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_BUFFER_OVERFLOW if the string table is full. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx isn't valid. + * @retval VERR_INVALID_POINTER if pszString isn't valid. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. + * @param pszString The string to add. + * @param fPurge Purge invalid UTF-8 encoding and control characters + * before setting it. + */ +static int usbfilterSetString(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, const char *pszString, bool fPurge) +{ + /* + * Validate input. + */ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, VERR_INVALID_MAGIC); + AssertReturn((unsigned)enmFieldIdx < (unsigned)USBFILTERIDX_END, VERR_INVALID_PARAMETER); + AssertPtrReturn(pszString, VERR_INVALID_POINTER); + + Assert(pFilter->offCurEnd < sizeof(pFilter->achStrTab)); + Assert(pFilter->achStrTab[pFilter->offCurEnd] == '\0'); + + /* + * Remove old string value if any. + */ + if ( USBFilterIsMethodUsingStringValue((USBFILTERMATCH)pFilter->aFields[enmFieldIdx].enmMatch) + && pFilter->aFields[enmFieldIdx].u16Value != 0) + { + uint32_t off = pFilter->aFields[enmFieldIdx].u16Value; + pFilter->aFields[enmFieldIdx].u16Value = 0; /* Assign it to the NULL string. */ + + unsigned cchShift = (unsigned)strlen(&pFilter->achStrTab[off]) + 1; + ssize_t cchToMove = (pFilter->offCurEnd + 1) - (off + cchShift); + Assert(cchToMove >= 0); + if (cchToMove > 0) + { + /* We're not last - must shift the strings. */ + memmove(&pFilter->achStrTab[off], &pFilter->achStrTab[off + cchShift], cchToMove); + for (unsigned i = 0; i < RT_ELEMENTS(pFilter->aFields); i++) + if ( pFilter->aFields[i].u16Value >= off + && USBFilterIsMethodUsingStringValue((USBFILTERMATCH)pFilter->aFields[i].enmMatch)) + pFilter->aFields[i].u16Value -= cchShift; + } + pFilter->offCurEnd -= cchShift; + Assert(pFilter->offCurEnd < sizeof(pFilter->achStrTab)); + Assert(pFilter->offCurEnd + cchShift <= sizeof(pFilter->achStrTab)); + + /* zero the unused string table (to allow lazyness/strictness elsewhere). */ + memset(&pFilter->achStrTab[pFilter->offCurEnd], '\0', cchShift); + } + + /* + * Make a special case for the empty string. + * (This also makes the delete logical above work correctly for the last string.) + */ + if (!*pszString) + pFilter->aFields[enmFieldIdx].u16Value = 0; + else + { + size_t cch = strlen(pszString); + if (pFilter->offCurEnd + cch + 2 > sizeof(pFilter->achStrTab)) + return VERR_BUFFER_OVERFLOW; + + pFilter->aFields[enmFieldIdx].u16Value = pFilter->offCurEnd + 1; + memcpy(&pFilter->achStrTab[pFilter->offCurEnd + 1], pszString, cch + 1); + if (fPurge) + cch = USBLibPurgeEncoding(&pFilter->achStrTab[pFilter->offCurEnd + 1]); + pFilter->offCurEnd += (uint32_t)cch + 1; + } + + return VINF_SUCCESS; +} + +/** + * Wrapper around usbfilterSetString() that deletes any string value + * currently assigned to a field. + * + * Upon successful return the field contains a null string, nothing or a number. + * + * This function will validate the field index if there isn't any string + * value to delete, thus preventing any extra validating of the index. + * + * @returns VBox status code. See usbfilterSetString. + * @param pFilter The filter. + * @param enmFieldIdx The index of the field which string value should be deleted. + */ +static int usbfilterDeleteAnyStringValue(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + int rc = VINF_SUCCESS; + if ( USBFilterIsMethodUsingStringValue((USBFILTERMATCH)pFilter->aFields[enmFieldIdx].enmMatch) + && pFilter->aFields[enmFieldIdx].u16Value != 0) + rc = usbfilterSetString(pFilter, enmFieldIdx, "", false /*fPurge*/); + else if ((unsigned)enmFieldIdx >= (unsigned)USBFILTERIDX_END) + rc = VERR_INVALID_PARAMETER; + return rc; +} + + +/** + * Sets a field to always match (ignore whatever is thrown at it). + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx isn't valid. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. This must be a string field. + */ +USBLIB_DECL(int) USBFilterSetIgnore(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + int rc = usbfilterDeleteAnyStringValue(pFilter, enmFieldIdx); + if (RT_SUCCESS(rc)) + { + pFilter->aFields[enmFieldIdx].enmMatch = USBFILTERMATCH_IGNORE; + pFilter->aFields[enmFieldIdx].u16Value = 0; + } + return rc; +} + + +/** + * Sets a field to match on device field present only. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx isn't valid. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. This must be a string field. + */ +USBLIB_DECL(int) USBFilterSetPresentOnly(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + int rc = usbfilterDeleteAnyStringValue(pFilter, enmFieldIdx); + if (RT_SUCCESS(rc)) + { + pFilter->aFields[enmFieldIdx].enmMatch = USBFILTERMATCH_PRESENT; + pFilter->aFields[enmFieldIdx].u16Value = 0; + } + return rc; +} + + +/** + * Sets a field to exactly match a number. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx isn't valid. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. This must be a string field. + * @param u16Value The string pattern. + * @param fMustBePresent If set, a non-present field on the device will result in a mismatch. + * If clear, a non-present field on the device will match. + */ +USBLIB_DECL(int) USBFilterSetNumExact(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, uint16_t u16Value, bool fMustBePresent) +{ + int rc = USBFilterIsNumericField(enmFieldIdx) ? VINF_SUCCESS : VERR_INVALID_PARAMETER; + if (RT_SUCCESS(rc)) + { + rc = usbfilterDeleteAnyStringValue(pFilter, enmFieldIdx); + if (RT_SUCCESS(rc)) + { + pFilter->aFields[enmFieldIdx].u16Value = u16Value; + pFilter->aFields[enmFieldIdx].enmMatch = fMustBePresent ? USBFILTERMATCH_NUM_EXACT : USBFILTERMATCH_NUM_EXACT_NP; + } + } + + return rc; +} + + +/** + * Sets a field to match a numeric expression. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_BUFFER_OVERFLOW if the string table is full. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx or the numeric expression aren't valid. + * @retval VERR_INVALID_POINTER if pszExpression isn't a valid pointer. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. This must be a string field. + * @param pszExpression The numeric expression. + * @param fMustBePresent If set, a non-present field on the device will result in a mismatch. + * If clear, a non-present field on the device will match. + */ +USBLIB_DECL(int) USBFilterSetNumExpression(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, const char *pszExpression, bool fMustBePresent) +{ + int rc = USBFilterIsNumericField(enmFieldIdx) ? VINF_SUCCESS : VERR_INVALID_PARAMETER; + if (RT_SUCCESS(rc)) + { + /* Strip leading spaces and empty sub expressions (||). */ + while (*pszExpression && (RT_C_IS_BLANK(*pszExpression) || *pszExpression == '|')) + pszExpression++; + + rc = usbfilterValidateNumExpression(pszExpression); + if (RT_SUCCESS(rc)) + { + /* We could optimize the expression further (stripping spaces, convert numbers), + but it's more work than what it's worth and it could upset some users. */ + rc = usbfilterSetString(pFilter, enmFieldIdx, pszExpression, false /*fPurge*/); + if (RT_SUCCESS(rc)) + pFilter->aFields[enmFieldIdx].enmMatch = fMustBePresent ? USBFILTERMATCH_NUM_EXPRESSION : USBFILTERMATCH_NUM_EXPRESSION_NP; + else if (rc == VERR_NO_DIGITS) + rc = VERR_INVALID_PARAMETER; + } + } + return rc; +} + + +/** + * Sets a field to exactly match a string. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_BUFFER_OVERFLOW if the string table is full. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx isn't valid. + * @retval VERR_INVALID_POINTER if pszPattern isn't a valid pointer. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. This must be a string field. + * @param pszValue The string value. + * @param fMustBePresent If set, a non-present field on the device will result in a mismatch. + * If clear, a non-present field on the device will match. + * @param fPurge Purge invalid UTF-8 encoding and control + * characters before setting it. + */ +USBLIB_DECL(int) USBFilterSetStringExact(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, const char *pszValue, + bool fMustBePresent, bool fPurge) +{ + int rc = USBFilterIsStringField(enmFieldIdx) ? VINF_SUCCESS : VERR_INVALID_PARAMETER; + if (RT_SUCCESS(rc)) + { + rc = usbfilterSetString(pFilter, enmFieldIdx, pszValue, fPurge); + if (RT_SUCCESS(rc)) + pFilter->aFields[enmFieldIdx].enmMatch = fMustBePresent ? USBFILTERMATCH_STR_EXACT : USBFILTERMATCH_STR_EXACT_NP; + } + return rc; +} + + +/** + * Sets a field to match a string pattern. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_BUFFER_OVERFLOW if the string table is full. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx or pattern aren't valid. + * @retval VERR_INVALID_POINTER if pszPattern isn't a valid pointer. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. This must be a string field. + * @param pszPattern The string pattern. + * @param fMustBePresent If set, a non-present field on the device will result in a mismatch. + * If clear, a non-present field on the device will match. + */ +USBLIB_DECL(int) USBFilterSetStringPattern(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, const char *pszPattern, bool fMustBePresent) +{ + int rc = USBFilterIsStringField(enmFieldIdx) ? VINF_SUCCESS : VERR_INVALID_PARAMETER; + if (RT_SUCCESS(rc)) + { + rc = usbfilterValidateStringPattern(pszPattern); + if (RT_SUCCESS(rc)) + { + rc = usbfilterSetString(pFilter, enmFieldIdx, pszPattern, false /*fPurge*/); + if (RT_SUCCESS(rc)) + pFilter->aFields[enmFieldIdx].enmMatch = fMustBePresent ? USBFILTERMATCH_STR_PATTERN : USBFILTERMATCH_STR_PATTERN_NP; + } + } + return rc; +} + + +/** + * Sets the must-be-present part of a field. + * + * This only works on field which already has matching criteria. This means + * that field marked 'ignore' will not be processed and will result in a + * warning status code. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VWRN_INVALID_PARAMETER if the field is marked 'ignore'. No assertions. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx or pattern aren't valid. + * @retval VERR_INVALID_POINTER if pszPattern isn't a valid pointer. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. + * @param fMustBePresent If set, a non-present field on the device will result in a mismatch. + * If clear, a non-present field on the device will match. + */ +USBLIB_DECL(int) USBFilterSetMustBePresent(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, bool fMustBePresent) +{ + AssertPtrReturn(pFilter, VERR_INVALID_POINTER); + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, VERR_INVALID_MAGIC); + AssertReturn((unsigned)enmFieldIdx < (unsigned)USBFILTERIDX_END, VERR_INVALID_PARAMETER); + + USBFILTERMATCH enmMatch = (USBFILTERMATCH)pFilter->aFields[enmFieldIdx].enmMatch; + if (fMustBePresent) + { + switch (enmMatch) + { + case USBFILTERMATCH_IGNORE: + return VWRN_INVALID_PARAMETER; + + case USBFILTERMATCH_PRESENT: + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_PATTERN: + break; + + case USBFILTERMATCH_NUM_EXACT_NP: + enmMatch = USBFILTERMATCH_NUM_EXACT; + break; + case USBFILTERMATCH_NUM_EXPRESSION_NP: + enmMatch = USBFILTERMATCH_NUM_EXPRESSION; + break; + case USBFILTERMATCH_STR_EXACT_NP: + enmMatch = USBFILTERMATCH_STR_EXACT; + break; + case USBFILTERMATCH_STR_PATTERN_NP: + enmMatch = USBFILTERMATCH_STR_PATTERN; + break; + default: + AssertMsgFailedReturn(("%p: enmFieldIdx=%d enmMatch=%d\n", pFilter, enmFieldIdx, enmMatch), VERR_INVALID_MAGIC); + } + } + else + { + switch (enmMatch) + { + case USBFILTERMATCH_IGNORE: + return VWRN_INVALID_PARAMETER; + + case USBFILTERMATCH_NUM_EXACT_NP: + case USBFILTERMATCH_STR_PATTERN_NP: + case USBFILTERMATCH_STR_EXACT_NP: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + break; + + case USBFILTERMATCH_PRESENT: + enmMatch = USBFILTERMATCH_IGNORE; + break; + case USBFILTERMATCH_NUM_EXACT: + enmMatch = USBFILTERMATCH_NUM_EXACT_NP; + break; + case USBFILTERMATCH_NUM_EXPRESSION: + enmMatch = USBFILTERMATCH_NUM_EXPRESSION_NP; + break; + case USBFILTERMATCH_STR_EXACT: + enmMatch = USBFILTERMATCH_STR_EXACT_NP; + break; + case USBFILTERMATCH_STR_PATTERN: + enmMatch = USBFILTERMATCH_STR_PATTERN_NP; + break; + + default: + AssertMsgFailedReturn(("%p: enmFieldIdx=%d enmMatch=%d\n", pFilter, enmFieldIdx, enmMatch), VERR_INVALID_MAGIC); + } + } + + pFilter->aFields[enmFieldIdx].enmMatch = enmMatch; + return VINF_SUCCESS; +} + + +/** + * Gets the filter type. + * + * @returns The filter type. + * USBFILTERTYPE_INVALID if the filter is invalid. + * @param pFilter The filter. + */ +USBLIB_DECL(USBFILTERTYPE) USBFilterGetFilterType(PCUSBFILTER pFilter) +{ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, USBFILTERTYPE_INVALID); + return pFilter->enmType; +} + + +/** + * Gets the matching method for a field. + * + * @returns The matching method on success, UBFILTERMATCH_INVALID on invalid field index. + * @param pFilter The filter. + * @param enmFieldIdx The field index. + */ +USBLIB_DECL(USBFILTERMATCH) USBFilterGetMatchingMethod(PCUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + if ( pFilter->u32Magic == USBFILTER_MAGIC + && (unsigned)enmFieldIdx < (unsigned)USBFILTERIDX_END) + return (USBFILTERMATCH)pFilter->aFields[enmFieldIdx].enmMatch; + return USBFILTERMATCH_INVALID; +} + + +/** + * Gets the numeric value of a field. + * + * The field must contain a number, we're not doing any conversions for you. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx isn't valid or if the field doesn't contain a number. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. + * @param pu16Value Where to store the value. + */ +USBLIB_DECL(int) USBFilterQueryNum(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, uint16_t *pu16Value) +{ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, VERR_INVALID_MAGIC); + int iValue = usbfilterGetNum(pFilter, enmFieldIdx); + if (iValue == -1) + return VERR_INVALID_PARAMETER; + *pu16Value = (uint16_t)iValue; + return VINF_SUCCESS; +} + + +/** + * Gets the numeric value of a field. + * + * The field must contain a number, we're not doing any conversions for you. + * + * @returns The field value on success, -1 on failure (invalid input / not numeric). + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. + */ +USBLIB_DECL(int) USBFilterGetNum(PCUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, -1); + return usbfilterGetNum(pFilter, enmFieldIdx); +} + + +/** + * Gets the string value of a field. + * + * The field must contain a string, we're not doing any conversions for you. + * + * @returns VBox status code. + * @retval VINF_SUCCESS on success. + * @retval VERR_BUFFER_OVERFLOW if the buffer isn't sufficient to hold the string. The buffer + * will be filled with as much of the string that'll fit. + * @retval VERR_INVALID_PARAMETER if the enmFieldIdx isn't valid or if the field doesn't contain a string. + * @retval VERR_INVALID_MAGIC if pFilter is invalid. + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. + * @param pszBuf Where to store the string. + * @param cchBuf The size of the buffer. + */ +USBLIB_DECL(int) USBFilterQueryString(PUSBFILTER pFilter, USBFILTERIDX enmFieldIdx, char *pszBuf, size_t cchBuf) +{ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, VERR_INVALID_MAGIC); + + const char *psz = usbfilterGetString(pFilter, enmFieldIdx); + if (RT_UNLIKELY(!psz)) + return VERR_INVALID_PARAMETER; + + int rc = VINF_SUCCESS; + size_t cch = strlen(psz); + if (cch < cchBuf) + memcpy(pszBuf, psz, cch + 1); + else + { + rc = VERR_BUFFER_OVERFLOW; + if (cchBuf) + { + memcpy(pszBuf, psz, cchBuf - 1); + pszBuf[cchBuf - 1] = '\0'; + } + } + + return rc; +} + + +/** + * Gets the string table entry for a field. + * + * @returns Pointer to the string. (readonly!) + * + * @param pFilter The filter. + * @param enmFieldIdx The field index. + */ +USBLIB_DECL(const char *) USBFilterGetString(PCUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, NULL); + + const char *psz = usbfilterGetString(pFilter, enmFieldIdx); + if (RT_UNLIKELY(!psz)) + return NULL; + return psz; +} + + +/** + * Gets the string length of a field containing a string. + * + * @returns String length on success, -1 on failure (not a string, bad filter). + * @param pFilter The filter. + * @param enmFieldIdx The field index. + */ +USBLIB_DECL(ssize_t) USBFilterGetStringLen(PCUSBFILTER pFilter, USBFILTERIDX enmFieldIdx) +{ + if (RT_LIKELY(pFilter->u32Magic == USBFILTER_MAGIC)) + { + const char *psz = usbfilterGetString(pFilter, enmFieldIdx); + if (RT_LIKELY(psz)) + return strlen(psz); + } + return -1; +} + + +/** + * Check if any of the fields are set to something substatial. + * + * Consider the fileter a wildcard if this returns false. + * + * @returns true / false. + * @param pFilter The filter. + */ +USBLIB_DECL(bool) USBFilterHasAnySubstatialCriteria(PCUSBFILTER pFilter) +{ + AssertReturn(pFilter->u32Magic == USBFILTER_MAGIC, false); + + for (unsigned i = 0; i < RT_ELEMENTS(pFilter->aFields); i++) + { + switch (pFilter->aFields[i].enmMatch) + { + case USBFILTERMATCH_IGNORE: + case USBFILTERMATCH_PRESENT: + break; + + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_EXACT_NP: + return true; + + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + { + const char *psz = usbfilterGetString(pFilter, (USBFILTERIDX)i); + if (psz) + { + while (*psz && (*psz == '|' || RT_C_IS_BLANK(*psz))) + psz++; + if (*psz) + return true; + } + break; + } + + case USBFILTERMATCH_STR_PATTERN: + case USBFILTERMATCH_STR_PATTERN_NP: + { + const char *psz = usbfilterGetString(pFilter, (USBFILTERIDX)i); + if (psz) + { + while (*psz && (*psz == '*' || *psz == '?')) + psz++; + if (*psz) + return true; + } + break; + } + } + } + + return false; +} + + + +/** + * Checks whether the specified field is a numeric field or not. + * + * @returns true / false. + * @param enmFieldIdx The field index. + */ +USBLIB_DECL(bool) USBFilterIsNumericField(USBFILTERIDX enmFieldIdx) +{ + switch (enmFieldIdx) + { + case USBFILTERIDX_VENDOR_ID: + case USBFILTERIDX_PRODUCT_ID: + case USBFILTERIDX_DEVICE: + case USBFILTERIDX_DEVICE_CLASS: + case USBFILTERIDX_DEVICE_SUB_CLASS: + case USBFILTERIDX_DEVICE_PROTOCOL: + case USBFILTERIDX_BUS: + case USBFILTERIDX_PORT: + return true; + + default: + AssertMsgFailed(("%d\n", enmFieldIdx)); + RT_FALL_THRU(); + case USBFILTERIDX_MANUFACTURER_STR: + case USBFILTERIDX_PRODUCT_STR: + case USBFILTERIDX_SERIAL_NUMBER_STR: + return false; + } +} + + +/** + * Checks whether the specified field is a string field or not. + * + * @returns true / false. + * @param enmFieldIdx The field index. + */ +USBLIB_DECL(bool) USBFilterIsStringField(USBFILTERIDX enmFieldIdx) +{ + switch (enmFieldIdx) + { + default: + AssertMsgFailed(("%d\n", enmFieldIdx)); + RT_FALL_THRU(); + case USBFILTERIDX_VENDOR_ID: + case USBFILTERIDX_PRODUCT_ID: + case USBFILTERIDX_DEVICE: + case USBFILTERIDX_DEVICE_CLASS: + case USBFILTERIDX_DEVICE_SUB_CLASS: + case USBFILTERIDX_DEVICE_PROTOCOL: + case USBFILTERIDX_BUS: + case USBFILTERIDX_PORT: + return false; + + case USBFILTERIDX_MANUFACTURER_STR: + case USBFILTERIDX_PRODUCT_STR: + case USBFILTERIDX_SERIAL_NUMBER_STR: + return true; + } +} + + +/** + * Checks whether the specified matching method uses a numeric value or not. + * + * @returns true / false. + * @param enmMatchingMethod The matching method. + */ +USBLIB_DECL(bool) USBFilterIsMethodUsingNumericValue(USBFILTERMATCH enmMatchingMethod) +{ + switch (enmMatchingMethod) + { + default: + AssertMsgFailed(("%d\n", enmMatchingMethod)); + RT_FALL_THRU(); + case USBFILTERMATCH_IGNORE: + case USBFILTERMATCH_PRESENT: + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_EXACT_NP: + case USBFILTERMATCH_STR_PATTERN: + case USBFILTERMATCH_STR_PATTERN_NP: + return false; + + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + return true; + } +} + + +/** + * Checks whether the specified matching method uses a string value or not. + * + * @returns true / false. + * @param enmMatchingMethod The matching method. + */ +USBLIB_DECL(bool) USBFilterIsMethodUsingStringValue(USBFILTERMATCH enmMatchingMethod) +{ + switch (enmMatchingMethod) + { + default: + AssertMsgFailed(("%d\n", enmMatchingMethod)); + RT_FALL_THRU(); + case USBFILTERMATCH_IGNORE: + case USBFILTERMATCH_PRESENT: + case USBFILTERMATCH_NUM_EXACT: + case USBFILTERMATCH_NUM_EXACT_NP: + return false; + + case USBFILTERMATCH_NUM_EXPRESSION: + case USBFILTERMATCH_NUM_EXPRESSION_NP: + case USBFILTERMATCH_STR_EXACT: + case USBFILTERMATCH_STR_EXACT_NP: + case USBFILTERMATCH_STR_PATTERN: + case USBFILTERMATCH_STR_PATTERN_NP: + return true; + } +} + + +/** + * Checks if a matching method is for string fields or not. + * + * @returns true / false. + * @param enmMatchingMethod The matching method. + */ +USBLIB_DECL(bool) USBFilterIsMethodNumeric(USBFILTERMATCH enmMatchingMethod) +{ + return enmMatchingMethod >= USBFILTERMATCH_NUM_FIRST + && enmMatchingMethod <= USBFILTERMATCH_NUM_LAST; +} + +/** + * Checks if a matching method is for string fields or not. + * + * @returns true / false. + * @param enmMatchingMethod The matching method. + */ +USBLIB_DECL(bool) USBFilterIsMethodString(USBFILTERMATCH enmMatchingMethod) +{ + return enmMatchingMethod >= USBFILTERMATCH_STR_FIRST + && enmMatchingMethod <= USBFILTERMATCH_STR_LAST; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/USBLib.cpp b/src/VBox/HostDrivers/VBoxUSB/USBLib.cpp new file mode 100644 index 00000000..a8e41c01 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/USBLib.cpp @@ -0,0 +1,61 @@ +/* $Id: USBLib.cpp $ */ +/** @file + * VirtualBox USB Library, Common Bits. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/usblib.h> + + +/** + * Calculate the hash of the serial string. + * + * 64bit FNV1a, chosen because it is designed to hash in to a power of two + * space, and is much quicker and simpler than, say, a half MD4. + * + * @returns the hash. + * @param pszSerial The serial string. + */ +USBLIB_DECL(uint64_t) USBLibHashSerial(const char *pszSerial) +{ + if (!pszSerial) + pszSerial = ""; + + register const uint8_t *pu8 = (const uint8_t *)pszSerial; + register uint64_t u64 = UINT64_C(14695981039346656037); + for (;;) + { + register uint8_t u8 = *pu8; + if (!u8) + break; + u64 = (u64 * UINT64_C(1099511628211)) ^ u8; + pu8++; + } + + return u64; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/VBoxUSBFilterMgr.cpp b/src/VBox/HostDrivers/VBoxUSB/VBoxUSBFilterMgr.cpp new file mode 100644 index 00000000..ada63574 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/VBoxUSBFilterMgr.cpp @@ -0,0 +1,561 @@ +/* $Id: VBoxUSBFilterMgr.cpp $ */ +/** @file + * VirtualBox Ring-0 USB Filter Manager. + */ + +/* + * Copyright (C) 2007-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/usbfilter.h> +#include "VBoxUSBFilterMgr.h" + +#include <iprt/err.h> +#include <iprt/handletable.h> +#include <iprt/mem.h> +#ifdef VBOXUSBFILTERMGR_USB_SPINLOCK +# include <iprt/spinlock.h> +#else +# include <iprt/semaphore.h> +#endif +#include <iprt/string.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ + +/** @def VBOXUSBFILTERMGR_LOCK + * Locks the filter list. Careful with scoping since this may + * create a temporary variable. Don't call twice in the same function. + */ + +/** @def VBOXUSBFILTERMGR_UNLOCK + * Unlocks the filter list. + */ +#ifdef VBOXUSBFILTERMGR_USB_SPINLOCK + +# define VBOXUSBFILTERMGR_LOCK() \ + RTSpinlockAcquire(g_Spinlock) + +# define VBOXUSBFILTERMGR_UNLOCK() \ + RTSpinlockRelease(g_Spinlock) + +#else + +# define VBOXUSBFILTERMGR_LOCK() \ + do { int rc2 = RTSemFastMutexRequest(g_Mtx); AssertRC(rc2); } while (0) + +# define VBOXUSBFILTERMGR_UNLOCK() \ + do { int rc2 = RTSemFastMutexRelease(g_Mtx); AssertRC(rc2); } while (0) + +#endif + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** Pointer to an VBoxUSB filter. */ +typedef struct VBOXUSBFILTER *PVBOXUSBFILTER; +/** Pointer to PVBOXUSBFILTER. */ +typedef PVBOXUSBFILTER *PPVBOXUSBFILTER; + +/** + * VBoxUSB internal filter representation. + */ +typedef struct VBOXUSBFILTER +{ + /** The core filter. */ + USBFILTER Core; + /** The filter owner. */ + VBOXUSBFILTER_CONTEXT Owner; + /** The filter Id. */ + uint32_t uHnd; + /** Pointer to the next filter in the list. */ + PVBOXUSBFILTER pNext; +} VBOXUSBFILTER; + +/** + * VBoxUSB filter list. + */ +typedef struct VBOXUSBFILTERLIST +{ + /** The head pointer. */ + PVBOXUSBFILTER pHead; + /** The tail pointer. */ + PVBOXUSBFILTER pTail; +} VBOXUSBFILTERLIST; +/** Pointer to a VBOXUSBFILTERLIST. */ +typedef VBOXUSBFILTERLIST *PVBOXUSBFILTERLIST; + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +#ifdef VBOXUSBFILTERMGR_USB_SPINLOCK +/** Spinlock protecting the filter lists. */ +static RTSPINLOCK g_Spinlock = NIL_RTSPINLOCK; +#else +/** Mutex protecting the filter lists. */ +static RTSEMFASTMUTEX g_Mtx = NIL_RTSEMFASTMUTEX; +#endif +/** The per-type filter lists. + * @remark The first entry is empty (USBFILTERTYPE_INVALID). */ +static VBOXUSBFILTERLIST g_aLists[USBFILTERTYPE_END]; +/** The handle table to match handles to the right filter. */ +static RTHANDLETABLE g_hHndTableFilters = NIL_RTHANDLETABLE; + + + +/** + * Initializes the VBoxUSB filter manager. + * + * @returns IPRT status code. + */ +int VBoxUSBFilterInit(void) +{ +#ifdef VBOXUSBFILTERMGR_USB_SPINLOCK + int rc = RTSpinlockCreate(&g_Spinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "VBoxUSBFilter"); +#else + int rc = RTSemFastMutexCreate(&g_Mtx); +#endif + if (RT_SUCCESS(rc)) + { + uint32_t fFlags; +#ifdef VBOXUSBFILTERMGR_USB_SPINLOCK + fFlags = RTHANDLETABLE_FLAGS_LOCKED_IRQ_SAFE; +#else + fFlags = RTHANDLETABLE_FLAGS_LOCKED; +#endif + rc = RTHandleTableCreateEx(&g_hHndTableFilters, fFlags, 1 /* uBase */, 8192 /* cMax */, + NULL, NULL); + if (RT_SUCCESS(rc)) + { + /* not really required, but anyway... */ + for (unsigned i = USBFILTERTYPE_FIRST; i < RT_ELEMENTS(g_aLists); i++) + g_aLists[i].pHead = g_aLists[i].pTail = NULL; + } + else + { +#ifdef VBOXUSBFILTERMGR_USB_SPINLOCK + RTSpinlockDestroy(g_Spinlock); + g_Spinlock = NIL_RTSPINLOCK; +#else + RTSemFastMutexDestroy(g_Mtx); + g_Mtx = NIL_RTSEMFASTMUTEX; +#endif + } + } + return rc; +} + + +/** + * Internal worker that frees a filter. + * + * @param pFilter The filter to free. + */ +static void vboxUSBFilterFree(PVBOXUSBFILTER pFilter) +{ + USBFilterDelete(&pFilter->Core); + pFilter->Owner = VBOXUSBFILTER_CONTEXT_NIL; + pFilter->pNext = NULL; + RTMemFree(pFilter); +} + + +/** + * Terminates the VBoxUSB filter manager. + */ +void VBoxUSBFilterTerm(void) +{ +#ifdef VBOXUSBFILTERMGR_USB_SPINLOCK + RTSpinlockDestroy(g_Spinlock); + g_Spinlock = NIL_RTSPINLOCK; +#else + RTSemFastMutexDestroy(g_Mtx); + g_Mtx = NIL_RTSEMFASTMUTEX; +#endif + + for (unsigned i = USBFILTERTYPE_FIRST; i < RT_ELEMENTS(g_aLists); i++) + { + PVBOXUSBFILTER pCur = g_aLists[i].pHead; + g_aLists[i].pHead = g_aLists[i].pTail = NULL; + while (pCur) + { + PVBOXUSBFILTER pNext = pCur->pNext; + RTHandleTableFree(g_hHndTableFilters, pCur->uHnd); + vboxUSBFilterFree(pCur); + pCur = pNext; + } + } + + RTHandleTableDestroy(g_hHndTableFilters, NULL, NULL); +} + + +/** + * Adds a new filter. + * + * The filter will be validate, duplicated and added. + * + * @returns IPRT status code. + * @param pFilter The filter. + * @param Owner The filter owner. Must be non-zero. + * @param puId Where to store the filter ID. + */ +int VBoxUSBFilterAdd(PCUSBFILTER pFilter, VBOXUSBFILTER_CONTEXT Owner, uintptr_t *puId) +{ + /* + * Validate input. + */ + int rc = USBFilterValidate(pFilter); + if (RT_FAILURE(rc)) + return rc; + if (!Owner || Owner == VBOXUSBFILTER_CONTEXT_NIL) + return VERR_INVALID_PARAMETER; + if (!VALID_PTR(puId)) + return VERR_INVALID_POINTER; + + /* + * Allocate a new filter. + */ + PVBOXUSBFILTER pNew = (PVBOXUSBFILTER)RTMemAlloc(sizeof(*pNew)); + if (!pNew) + return VERR_NO_MEMORY; + memcpy(&pNew->Core, pFilter, sizeof(pNew->Core)); + pNew->Owner = Owner; + pNew->pNext = NULL; + + rc = RTHandleTableAlloc(g_hHndTableFilters, pNew, &pNew->uHnd); + if (RT_SUCCESS(rc)) + { + *puId = pNew->uHnd; + + /* + * Insert it. + */ + PVBOXUSBFILTERLIST pList = &g_aLists[pFilter->enmType]; + + VBOXUSBFILTERMGR_LOCK(); + + if (pList->pTail) + pList->pTail->pNext = pNew; + else + pList->pHead = pNew; + pList->pTail = pNew; + + VBOXUSBFILTERMGR_UNLOCK(); + } + else + RTMemFree(pNew); + + return rc; +} + + +/** + * Removes an existing filter. + * + * The filter will be validate, duplicated and added. + * + * @returns IPRT status code. + * @retval VINF_SUCCESS if successfully removed. + * @retval VERR_FILE_NOT_FOUND if the specified filter/owner cannot be found. + * + * @param Owner The filter owner. + * @param uId The ID of the filter that's to be removed. + * Returned by VBoxUSBFilterAdd(). + */ +int VBoxUSBFilterRemove(VBOXUSBFILTER_CONTEXT Owner, uintptr_t uId) +{ + /* + * Validate input. + */ + if (!uId || uId != (uint32_t)uId) + return VERR_INVALID_PARAMETER; + if (!Owner || Owner == VBOXUSBFILTER_CONTEXT_NIL) + return VERR_INVALID_PARAMETER; + + /* + * Locate and unlink it. + */ + uint32_t uHnd = (uint32_t)uId; + PVBOXUSBFILTER pCur = NULL; + + VBOXUSBFILTERMGR_LOCK(); + + for (unsigned i = USBFILTERTYPE_FIRST; !pCur && i < RT_ELEMENTS(g_aLists); i++) + { + PVBOXUSBFILTER pPrev = NULL; + pCur = g_aLists[i].pHead; + while (pCur) + { + if ( pCur->uHnd == uHnd + && pCur->Owner == Owner) + { + PVBOXUSBFILTER pNext = pCur->pNext; + if (pPrev) + pPrev->pNext = pNext; + else + g_aLists[i].pHead = pNext; + if (!pNext) + g_aLists[i].pTail = pPrev; + break; + } + + pPrev = pCur; + pCur = pCur->pNext; + } + } + + VBOXUSBFILTERMGR_UNLOCK(); + + /* + * Free it (if found). + */ + if (pCur) + { + void *pv = RTHandleTableFree(g_hHndTableFilters, pCur->uHnd); + Assert(pv == pCur); NOREF(pv); + vboxUSBFilterFree(pCur); + return VINF_SUCCESS; + } + + return VERR_FILE_NOT_FOUND; +} + +VBOXUSBFILTER_CONTEXT VBoxUSBFilterGetOwner(uintptr_t uId) +{ + Assert(uId); + /* + * Validate input. + */ + if (!uId || uId != (uint32_t)uId) + return VBOXUSBFILTER_CONTEXT_NIL; + + /* + * Result. + */ + VBOXUSBFILTER_CONTEXT Owner = VBOXUSBFILTER_CONTEXT_NIL; + + VBOXUSBFILTERMGR_LOCK(); + + PVBOXUSBFILTER pCur = (PVBOXUSBFILTER)RTHandleTableLookup(g_hHndTableFilters, (uint32_t)uId); + if (pCur) + Owner = pCur->Owner; + + Assert(Owner != VBOXUSBFILTER_CONTEXT_NIL); + + VBOXUSBFILTERMGR_UNLOCK(); + + return Owner; +} + +/** + * Removes all filters belonging to the specified owner. + * + * This is typically called when an owner disconnects or + * terminates unexpectedly. + * + * @param Owner The owner + */ +void VBoxUSBFilterRemoveOwner(VBOXUSBFILTER_CONTEXT Owner) +{ + /* + * Collect the filters that should be freed. + */ + PVBOXUSBFILTER pToFree = NULL; + + VBOXUSBFILTERMGR_LOCK(); + + for (unsigned i = USBFILTERTYPE_FIRST; i < RT_ELEMENTS(g_aLists); i++) + { + PVBOXUSBFILTER pPrev = NULL; + PVBOXUSBFILTER pCur = g_aLists[i].pHead; + while (pCur) + { + if (pCur->Owner == Owner) + { + PVBOXUSBFILTER pNext = pCur->pNext; + if (pPrev) + pPrev->pNext = pNext; + else + g_aLists[i].pHead = pNext; + if (!pNext) + g_aLists[i].pTail = pPrev; + + pCur->pNext = pToFree; + pToFree = pCur; + + pCur = pNext; + } + else + { + pPrev = pCur; + pCur = pCur->pNext; + } + } + } + + VBOXUSBFILTERMGR_UNLOCK(); + + /* + * Free any filters we've found. + */ + while (pToFree) + { + PVBOXUSBFILTER pNext = pToFree->pNext; + void *pv = RTHandleTableFree(g_hHndTableFilters, pToFree->uHnd); + Assert(pv == pToFree); NOREF(pv); + vboxUSBFilterFree(pToFree); + pToFree = pNext; + } +} + +/** + * Match the specified device against the filters. + * Unlike the VBoxUSBFilterMatch, returns Owner also if exclude filter is matched + * + * @returns Owner on if matched, VBOXUSBFILTER_CONTEXT_NIL it not matched. + * @param pDevice The device data as a filter structure. + * See USBFilterMatch for how to construct this. + * @param puId Where to store the filter id (optional). + * @param fRemoveFltIfOneShot Whether or not to remove one-shot filters on + * match. + * @param pfFilter Where to store whether the device must be filtered or not + * @param pfIsOneShot Where to return whetehr the match was a one-shot + * filter or not. Optional. + * + */ +VBOXUSBFILTER_CONTEXT VBoxUSBFilterMatchEx(PCUSBFILTER pDevice, uintptr_t *puId, + bool fRemoveFltIfOneShot, bool *pfFilter, bool *pfIsOneShot) +{ + /* + * Validate input. + */ + int rc = USBFilterValidate(pDevice); + AssertRCReturn(rc, VBOXUSBFILTER_CONTEXT_NIL); + + *pfFilter = false; + if (puId) + *puId = 0; + + /* + * Search the lists for a match. + * (The lists are ordered by priority.) + */ + VBOXUSBFILTERMGR_LOCK(); + + for (unsigned i = USBFILTERTYPE_FIRST; i < RT_ELEMENTS(g_aLists); i++) + { + PVBOXUSBFILTER pPrev = NULL; + PVBOXUSBFILTER pCur = g_aLists[i].pHead; + while (pCur) + { + if (USBFilterMatch(&pCur->Core, pDevice)) + { + /* + * Take list specific actions and return. + * + * The code does NOT implement the case where there are two or more + * filter clients, and one of them is releasing a device that's + * requested by some of the others. It's just too much work for a + * situation that noone will encounter. + */ + if (puId) + *puId = pCur->uHnd; + VBOXUSBFILTER_CONTEXT Owner = pCur->Owner; + *pfFilter = !!(i != USBFILTERTYPE_IGNORE + && i != USBFILTERTYPE_ONESHOT_IGNORE); + + if ( i == USBFILTERTYPE_ONESHOT_IGNORE + || i == USBFILTERTYPE_ONESHOT_CAPTURE) + { + if (fRemoveFltIfOneShot) + { + /* unlink */ + PVBOXUSBFILTER pNext = pCur->pNext; + if (pPrev) + pPrev->pNext = pNext; + else + g_aLists[i].pHead = pNext; + if (!pNext) + g_aLists[i].pTail = pPrev; + } + } + + VBOXUSBFILTERMGR_UNLOCK(); + + if ( i == USBFILTERTYPE_ONESHOT_IGNORE + || i == USBFILTERTYPE_ONESHOT_CAPTURE) + { + if (fRemoveFltIfOneShot) + { + void *pv = RTHandleTableFree(g_hHndTableFilters, pCur->uHnd); + Assert(pv == pCur); NOREF(pv); + vboxUSBFilterFree(pCur); + } + if (pfIsOneShot) + *pfIsOneShot = true; + } + else + { + if (pfIsOneShot) + *pfIsOneShot = false; + } + return Owner; + } + + pPrev = pCur; + pCur = pCur->pNext; + } + } + + VBOXUSBFILTERMGR_UNLOCK(); + return VBOXUSBFILTER_CONTEXT_NIL; +} + +/** + * Match the specified device against the filters. + * + * @returns Owner on if matched, VBOXUSBFILTER_CONTEXT_NIL it not matched. + * @param pDevice The device data as a filter structure. + * See USBFilterMatch for how to construct this. + * @param puId Where to store the filter id (optional). + */ +VBOXUSBFILTER_CONTEXT VBoxUSBFilterMatch(PCUSBFILTER pDevice, uintptr_t *puId) +{ + bool fFilter = false; + VBOXUSBFILTER_CONTEXT Owner = VBoxUSBFilterMatchEx(pDevice, puId, + true, /* remove filter is it's a one-shot*/ + &fFilter, NULL /* bool * fIsOneShot */); + if (fFilter) + { + Assert(Owner != VBOXUSBFILTER_CONTEXT_NIL); + return Owner; + } + return VBOXUSBFILTER_CONTEXT_NIL; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/VBoxUSBFilterMgr.h b/src/VBox/HostDrivers/VBoxUSB/VBoxUSBFilterMgr.h new file mode 100644 index 00000000..ba84996f --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/VBoxUSBFilterMgr.h @@ -0,0 +1,58 @@ +/* $Id: VBoxUSBFilterMgr.h $ */ +/** @file + * VirtualBox Ring-0 USB Filter Manager. + */ + +/* + * Copyright (C) 2007-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_VBoxUSBFilterMgr_h +#define VBOX_INCLUDED_SRC_VBoxUSB_VBoxUSBFilterMgr_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include <VBox/usbfilter.h> + +RT_C_DECLS_BEGIN + +/** @todo r=bird: VBOXUSBFILTER_CONTEXT isn't following the coding + * guildlines. Don't know which clueless dude did this... */ +#if defined(RT_OS_WINDOWS) +typedef struct VBOXUSBFLTCTX *VBOXUSBFILTER_CONTEXT; +#define VBOXUSBFILTER_CONTEXT_NIL NULL +#else +typedef RTPROCESS VBOXUSBFILTER_CONTEXT; +#define VBOXUSBFILTER_CONTEXT_NIL NIL_RTPROCESS +#endif + +int VBoxUSBFilterInit(void); +void VBoxUSBFilterTerm(void); +void VBoxUSBFilterRemoveOwner(VBOXUSBFILTER_CONTEXT Owner); +int VBoxUSBFilterAdd(PCUSBFILTER pFilter, VBOXUSBFILTER_CONTEXT Owner, uintptr_t *puId); +int VBoxUSBFilterRemove(VBOXUSBFILTER_CONTEXT Owner, uintptr_t uId); +VBOXUSBFILTER_CONTEXT VBoxUSBFilterMatch(PCUSBFILTER pDevice, uintptr_t *puId); +VBOXUSBFILTER_CONTEXT VBoxUSBFilterMatchEx(PCUSBFILTER pDevice, uintptr_t *puId, bool fRemoveFltIfOneShot, bool *pfFilter, bool *pfIsOneShot); +VBOXUSBFILTER_CONTEXT VBoxUSBFilterGetOwner(uintptr_t uId); + +RT_C_DECLS_END + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_VBoxUSBFilterMgr_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/Info.plist b/src/VBox/HostDrivers/VBoxUSB/darwin/Info.plist new file mode 100644 index 00000000..16aac548 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/Info.plist @@ -0,0 +1,89 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> +<plist version="1.0"> +<dict> + <key>CFBundleDevelopmentRegion</key> <string>English</string> + <key>CFBundleExecutable</key> <string>VBoxUSB</string> + <key>CFBundleIdentifier</key> <string>org.virtualbox.kext.VBoxUSB</string> + <key>CFBundleInfoDictionaryVersion</key> <string>6.0</string> + <key>CFBundleName</key> <string>VBoxUSB</string> + <key>CFBundlePackageType</key> <string>KEXT</string> + <key>CFBundleSignature</key> <string>????</string> + <key>CFBundleVersion</key> <string>@VBOX_VERSION_MAJOR@.@VBOX_VERSION_MINOR@.@VBOX_VERSION_BUILD@</string> + <key>CFBundleShortVersionString</key> <string>@VBOX_VERSION_MAJOR@.@VBOX_VERSION_MINOR@.@VBOX_VERSION_BUILD@</string> + <key>CFBundleGetInfoString</key> <string>@VBOX_PRODUCT@ @VBOX_VERSION_STRING@, © 2007-@VBOX_C_YEAR@ @VBOX_VENDOR@</string> + <key>IOKitPersonalities</key> + <dict> + <key>VBoxUSB</key> + <dict> + <key>CFBundleIdentifier</key> <string>org.virtualbox.kext.VBoxUSB</string> + <key>IOClass</key> <string>org_virtualbox_VBoxUSB</string> + <key>IOMatchCategory</key> <string>org_virtualbox_VBoxUSB</string> + <key>IOProviderClass</key> <string>IOResources</string> + <key>IOResourceMatch</key> <string>IOKit</string> + <key>IOUserClientClass</key> <string>org_virtualbox_VBoxUSBClient</string> + </dict> + <key>VBoxUSBDevice</key> + <dict> + <key>CFBundleIdentifier</key> <string>org.virtualbox.kext.VBoxUSB</string> + <key>IOClass</key> <string>org_virtualbox_VBoxUSBDevice</string> + <key>IOProviderClass</key> <string>IOUSBDevice</string> + <key>idVendor</key> <string>*</string> + <key>idProduct</key> <string>*</string> + <key>bcdDevice</key> <string>*</string> + <key>IOProbeScore</key> <integer>9942</integer> + <key>IOProviderMergeProperties</key> + <dict> + <key>IOCFPlugInTypes</key> + <dict> + <key>9dc7b780-9ec0-11d4-a54f-000a27052861</key> <string>IOUSBFamily.kext/Contents/PlugIns/IOUSBLib.bundle</string> + </dict> + <key>IOUserClientClass</key> <string>IOUSBDeviceUserClientV2</string> + </dict> + </dict> + <key>VBoxUSBInterface</key> + <dict> + <key>CFBundleIdentifier</key> <string>org.virtualbox.kext.VBoxUSB</string> + <key>IOClass</key> <string>org_virtualbox_VBoxUSBInterface</string> + <key>IOProviderClass</key> <string>IOUSBInterface</string> + <key>idVendor</key> <string>*</string> + <key>idProduct</key> <string>*</string> + <key>bcdDevice</key> <string>*</string> + <key>bConfigurationValue</key> <string>*</string> + <key>bInterfaceNumber</key> <string>*</string> + <key>IOProbeScore</key> <integer>9942</integer> + <key>IOProviderMergeProperties</key> + <dict> + <key>IOCFPlugInTypes</key> + <dict> + <key>2d9786c6-9ef3-11d4-ad51-000a27052861</key> <string>IOUSBFamily.kext/Contents/PlugIns/IOUSBLib.bundle</string> + </dict> + <key>IOUserClientClass</key> <string>IOUSBInterfaceUserClientV2</string> + </dict> + </dict> + </dict> + <key>OSBundleLibraries</key> + <dict> + <key>com.apple.iokit.IOUSBFamily</key> <string>3.0.0</string> + <key>com.apple.iokit.IOUSBUserClient</key> <string>3.0.0</string> + <key>com.apple.kpi.iokit</key> <string>9.0.0</string> + <key>com.apple.kpi.bsd</key> <string>9.0.0</string> + <key>com.apple.kpi.mach</key> <string>9.0.0</string> + <key>com.apple.kpi.libkern</key> <string>9.0.0</string> + <key>com.apple.kpi.unsupported</key> <string>9.0.0</string> + <key>org.virtualbox.kext.VBoxDrv</key> <string>@VBOX_VERSION_MAJOR@.@VBOX_VERSION_MINOR@.@VBOX_VERSION_BUILD@</string> + </dict> + <key>OSBundleLibraries_x86_64</key> + <dict> + <key>com.apple.iokit.IOUSBFamily</key> <string>3.5.0a25</string> + <key>com.apple.iokit.IOUSBUserClient</key> <string>3.5.0a25</string> + <key>com.apple.kpi.iokit</key> <string>10.0.0d3</string> + <key>com.apple.kpi.bsd</key> <string>10.0.0d3</string> + <key>com.apple.kpi.mach</key> <string>10.0.0d3</string> + <key>com.apple.kpi.libkern</key> <string>10.0.0d3</string> + <key>com.apple.kpi.unsupported</key> <string>10.0.0d3</string> + <key>org.virtualbox.kext.VBoxDrv</key> <string>@VBOX_VERSION_MAJOR@.@VBOX_VERSION_MINOR@.@VBOX_VERSION_BUILD@</string> + </dict> +</dict> +</plist> + diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/Makefile.kmk b/src/VBox/HostDrivers/VBoxUSB/darwin/Makefile.kmk new file mode 100644 index 00000000..435b89f4 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/Makefile.kmk @@ -0,0 +1,87 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for the Darwin VBoxUSB kernel extension. +# + +# +# Copyright (C) 2006-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# +# The contents of this file may alternatively be used under the terms +# of the Common Development and Distribution License Version 1.0 +# (CDDL) only, as it comes in the "COPYING.CDDL" file of the +# VirtualBox OSE distribution, in which case the provisions of the +# CDDL are applicable instead of those of the GPL. +# +# You may elect to license modified versions of this file under the +# terms and conditions of either the GPL or the CDDL or both. +# + +SUB_DEPTH = ../../../../.. +include $(KBUILD_PATH)/subheader.kmk + +# +# VBoxUSB.kext - The Darwin Kernel Extension. +# + +# Leopard (x86) and Snow Leopard (x86/amd64) +SYSMODS.darwin += VBoxUSB +VBoxUSB_TEMPLATE = VBOXR0DRV +VBoxUSB_INST = $(INST_VBOXUSB)Contents/MacOS/ +VBoxUSB_DEBUG_INST.darwin = $(patsubst %/,%,$(INST_VBOXUSB)) +VBoxUSB_INCS = \ + . \ + .. +#VBoxUSB_LDFLAGS = -v -Wl,-whyload -Wl,-v -Wl,-whatsloaded +VBoxUSB_SOURCES := \ + VBoxUSB.cpp \ + ../USBFilter.cpp \ + ../VBoxUSBFilterMgr.cpp + +INSTALLS += VBoxUSB.kext +VBoxUSB.kext_INST = $(INST_VBOXUSB)Contents/ +VBoxUSB.kext_SOURCES = $(VBoxUSB.kext_0_OUTDIR)/Contents/Info.plist +VBoxUSB.kext_CLEAN = $(VBoxUSB.kext_0_OUTDIR)/Contents/Info.plist +VBoxUSB.kext_BLDDIRS = $(VBoxUSB.kext_0_OUTDIR)/Contents/ + +$$(VBoxUSB.kext_0_OUTDIR)/Contents/Info.plist: $(PATH_SUB_CURRENT)/Info.plist $(VBOX_VERSION_MK) | $$(dir $$@) + $(call MSG_GENERATE,VBoxUSB,$@,$<) + $(QUIET)$(RM) -f $@ + $(QUIET)$(SED) \ + -e 's/@VBOX_VERSION_STRING@/$(VBOX_VERSION_STRING)/g' \ + -e 's/@VBOX_VERSION_MAJOR@/$(VBOX_VERSION_MAJOR)/g' \ + -e 's/@VBOX_VERSION_MINOR@/$(VBOX_VERSION_MINOR)/g' \ + -e 's/@VBOX_VERSION_BUILD@/$(VBOX_VERSION_BUILD)/g' \ + -e 's/@VBOX_VENDOR@/$(VBOX_VENDOR)/g' \ + -e 's/@VBOX_PRODUCT@/$(VBOX_PRODUCT)/g' \ + -e 's/@VBOX_C_YEAR@/$(VBOX_C_YEAR)/g' \ + --output $@ \ + $< + +$(evalcall2 VBOX_TEST_SIGN_KEXT,VBoxUSB) + +# Common manual loader script. +INSTALLS += ScriptsUSB +ScriptsUSB_INST = $(INST_DIST) +ScriptsUSB_EXEC_SOURCES = \ + loadusb.sh + +ifdef VBOX_WITH_TESTCASES +# +# Testcase for doing some manual driver testing... +# +PROGRAMS += tstOpenUSBDev +tstOpenUSBDev_TEMPLATE = VBOXR3TSTEXE +tstOpenUSBDev_SOURCES = testcase/tstOpenUSBDev.cpp +tstOpenUSBDev_LDFLAGS = -framework CoreFoundation -framework IOKit +endif + +include $(FILE_KBUILD_SUB_FOOTER) + diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/USBLib-darwin.cpp b/src/VBox/HostDrivers/VBoxUSB/darwin/USBLib-darwin.cpp new file mode 100644 index 00000000..30415310 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/USBLib-darwin.cpp @@ -0,0 +1,201 @@ +/** $Id: USBLib-darwin.cpp $ */ +/** @file + * USBLib - Library for wrapping up the VBoxUSB functionality, Darwin flavor. + */ + +/* + * Copyright (C) 2007-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/usblib.h> +#include <iprt/errcore.h> +#include <VBox/log.h> +#include "VBoxUSBInterface.h" + +#include <iprt/assert.h> +#include <iprt/asm.h> + +#include <mach/mach_port.h> +#include <IOKit/IOKitLib.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The IOClass key of the service (see VBoxUSB.cpp / Info.plist). */ +#define IOCLASS_NAME "org_virtualbox_VBoxUSB" + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Reference counter. */ +static uint32_t volatile g_cUsers = 0; +/** The IOMasterPort. */ +static mach_port_t g_MasterPort = 0; +/** The current service connection. */ +static io_connect_t g_Connection = 0; + + + +USBLIB_DECL(int) USBLibInit(void) +{ + /* + * Already open? + * This isn't properly serialized, but we'll be fine with the current usage. + */ + if (g_cUsers) + { + ASMAtomicIncU32(&g_cUsers); + return VINF_SUCCESS; + } + + /* + * Finding the VBoxUSB service. + */ + mach_port_t MasterPort; + kern_return_t kr = IOMasterPort(MACH_PORT_NULL, &MasterPort); + if (kr != kIOReturnSuccess) + { + LogRel(("USBLib: IOMasterPort -> %#x\n", kr)); + return RTErrConvertFromDarwinKern(kr); + } + + CFDictionaryRef ClassToMatch = IOServiceMatching(IOCLASS_NAME); + if (!ClassToMatch) + { + LogRel(("USBLib: IOServiceMatching(\"%s\") failed.\n", IOCLASS_NAME)); + return VERR_GENERAL_FAILURE; + } + + /* Create an io_iterator_t for all instances of our drivers class that exist in the IORegistry. */ + io_iterator_t Iterator; + kr = IOServiceGetMatchingServices(g_MasterPort, ClassToMatch, &Iterator); + if (kr != kIOReturnSuccess) + { + LogRel(("USBLib: IOServiceGetMatchingServices returned %#x\n", kr)); + return RTErrConvertFromDarwinKern(kr); + } + + /* Get the first item in the iterator and release it. */ + io_service_t ServiceObject = IOIteratorNext(Iterator); + IOObjectRelease(Iterator); + if (!ServiceObject) + { + LogRel(("USBLib: Couldn't find any matches.\n")); + return VERR_GENERAL_FAILURE; + } + + /* + * Open the service. + * This will cause the user client class in VBoxUSB.cpp to be instantiated. + */ + kr = IOServiceOpen(ServiceObject, mach_task_self(), VBOXUSB_DARWIN_IOSERVICE_COOKIE, &g_Connection); + IOObjectRelease(ServiceObject); + if (kr != kIOReturnSuccess) + { + LogRel(("USBLib: IOServiceOpen returned %#x\n", kr)); + return RTErrConvertFromDarwinKern(kr); + } + + ASMAtomicIncU32(&g_cUsers); + return VINF_SUCCESS; +} + + +USBLIB_DECL(int) USBLibTerm(void) +{ + if (!g_cUsers) + return VERR_WRONG_ORDER; + if (ASMAtomicDecU32(&g_cUsers) != 0) + return VINF_SUCCESS; + + /* + * We're the last guy, close down the connection. + */ + kern_return_t kr = IOServiceClose(g_Connection); + if (kr != kIOReturnSuccess) + { + LogRel(("USBLib: Warning: IOServiceClose(%p) returned %#x\n", g_Connection, kr)); + AssertMsgFailed(("%#x\n", kr)); + } + g_Connection = 0; + + return VINF_SUCCESS; +} + + +USBLIB_DECL(void *) USBLibAddFilter(PCUSBFILTER pFilter) +{ + VBOXUSBADDFILTEROUT Out = { 0, VERR_WRONG_ORDER }; +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050 + IOByteCount cbOut = sizeof(Out); + kern_return_t kr = IOConnectMethodStructureIStructureO(g_Connection, + VBOXUSBMETHOD_ADD_FILTER, + sizeof(*pFilter), + &cbOut, + (void *)pFilter, + &Out); +#else /* 10.5 and later */ + size_t cbOut = sizeof(Out); + kern_return_t kr = IOConnectCallStructMethod(g_Connection, + VBOXUSBMETHOD_ADD_FILTER, + (void *)pFilter, sizeof(*pFilter), + &Out, &cbOut); +#endif /* 10.5 and later */ + if ( kr == kIOReturnSuccess + && RT_SUCCESS(Out.rc)) + { + Assert(cbOut == sizeof(Out)); + Assert((void *)Out.uId != NULL); + return (void *)Out.uId; + } + + AssertMsgFailed(("kr=%#x Out.rc=%Rrc\n", kr, Out.rc)); + return NULL; +} + + +USBLIB_DECL(void) USBLibRemoveFilter(void *pvId) +{ + int rc = VERR_WRONG_ORDER; +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1050 + IOByteCount cbOut = sizeof(rc); + kern_return_t kr = IOConnectMethodStructureIStructureO(g_Connection, + VBOXUSBMETHOD_REMOVE_FILTER, + sizeof(pvId), + &cbOut, + &pvId, + &rc); +#else /* 10.5 and later */ + size_t cbOut = sizeof(rc); + kern_return_t kr = IOConnectCallStructMethod(g_Connection, + VBOXUSBMETHOD_REMOVE_FILTER, + (void *)&pvId, sizeof(pvId), + &rc, &cbOut); +#endif /* 10.5 and later */ + AssertMsg(kr == kIOReturnSuccess && RT_SUCCESS(rc), ("kr=%#x rc=%Rrc\n", kr, rc)); + NOREF(kr); +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/VBoxUSB.cpp b/src/VBox/HostDrivers/VBoxUSB/darwin/VBoxUSB.cpp new file mode 100644 index 00000000..4b7868f1 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/VBoxUSB.cpp @@ -0,0 +1,1890 @@ +/* $Id: VBoxUSB.cpp $ */ +/** @file + * VirtualBox USB driver for Darwin. + * + * This driver is responsible for hijacking USB devices when any of the + * VBoxSVC daemons requests it. It is also responsible for arbitrating + * access to hijacked USB devices. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_USB_DRV +/* Deal with conflicts first. + * (This is mess inherited from BSD. The *BSDs has clean this up long ago.) */ +#include <sys/param.h> +#undef PVM +#include <IOKit/IOLib.h> /* Assert as function */ + +#include "VBoxUSBInterface.h" +#include "VBoxUSBFilterMgr.h" +#include <VBox/version.h> +#include <VBox/usblib-darwin.h> +#include <VBox/log.h> +#include <iprt/types.h> +#include <iprt/initterm.h> +#include <iprt/assert.h> +#include <iprt/semaphore.h> +#include <iprt/process.h> +#include <iprt/alloc.h> +#include <iprt/errcore.h> +#include <iprt/asm.h> + +#include <mach/kmod.h> +#include <miscfs/devfs/devfs.h> +#include <sys/conf.h> +#include <sys/errno.h> +#include <sys/ioccom.h> +#include <sys/malloc.h> +#include <sys/proc.h> +#include <kern/task.h> +#include <IOKit/IOService.h> +#include <IOKit/IOUserClient.h> +#include <IOKit/IOKitKeys.h> +#include <IOKit/usb/USB.h> +#include <IOKit/usb/IOUSBDevice.h> +#include <IOKit/usb/IOUSBInterface.h> +#include <IOKit/usb/IOUSBUserClient.h> + +/* private: */ +RT_C_DECLS_BEGIN +extern void *get_bsdtask_info(task_t); +RT_C_DECLS_END + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Locks the lists. */ +#define VBOXUSB_LOCK() do { int rc = RTSemFastMutexRequest(g_Mtx); AssertRC(rc); } while (0) +/** Unlocks the lists. */ +#define VBOXUSB_UNLOCK() do { int rc = RTSemFastMutexRelease(g_Mtx); AssertRC(rc); } while (0) + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +RT_C_DECLS_BEGIN +static kern_return_t VBoxUSBStart(struct kmod_info *pKModInfo, void *pvData); +static kern_return_t VBoxUSBStop(struct kmod_info *pKModInfo, void *pvData); +RT_C_DECLS_END + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * The service class. + * + * This is the management service that VBoxSVC and the VMs speak to. + * + * @remark The method prototypes are ordered somewhat after their order of + * invocation, while the implementation is ordered by pair. + */ +class org_virtualbox_VBoxUSB : public IOService +{ + OSDeclareDefaultStructors(org_virtualbox_VBoxUSB); + +public: + RTR0MEMEF_NEW_AND_DELETE_OPERATORS_IOKIT(); + + /** @name IOService + * @{ */ + virtual bool init(OSDictionary *pDictionary = 0); + virtual bool start(IOService *pProvider); + virtual bool open(IOService *pForClient, IOOptionBits fOptions = 0, void *pvArg = 0); + virtual bool terminate(IOOptionBits fOptions); + virtual void close(IOService *pForClient, IOOptionBits fOptions = 0); + virtual void stop(IOService *pProvider); + virtual void free(); + /** @} */ + +private: + /** Guard against the parent class growing and us using outdated headers. */ + uint8_t m_abSafetyPadding[256]; +}; +OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSB, IOService); + + +/** + * The user client class that pairs up with org_virtualbox_VBoxUSB. + */ +class org_virtualbox_VBoxUSBClient : public IOUserClient +{ + OSDeclareDefaultStructors(org_virtualbox_VBoxUSBClient); + +public: + RTR0MEMEF_NEW_AND_DELETE_OPERATORS_IOKIT(); + + /** @name IOService & IOUserClient + * @{ */ + virtual bool initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type); + virtual bool start(IOService *pProvider); + virtual IOReturn clientClose(void); + virtual IOReturn clientDied(void); + virtual bool terminate(IOOptionBits fOptions = 0); + virtual bool finalize(IOOptionBits fOptions); + virtual void stop(IOService *pProvider); + virtual void free(); + virtual IOExternalMethod *getTargetAndMethodForIndex(IOService **ppService, UInt32 iMethod); + /** @} */ + + /** @name User client methods + * @{ */ + IOReturn addFilter(PUSBFILTER pFilter, PVBOXUSBADDFILTEROUT pOut, IOByteCount cbFilter, IOByteCount *pcbOut); + IOReturn removeFilter(uintptr_t *puId, int *prc, IOByteCount cbIn, IOByteCount *pcbOut); + /** @} */ + + static bool isClientTask(task_t ClientTask); + +private: + /** Guard against the parent class growing and us using outdated headers. */ + uint8_t m_abSafetyPadding[256]; + /** The service provider. */ + org_virtualbox_VBoxUSB *m_pProvider; + /** The client task. */ + task_t m_Task; + /** The client process. */ + RTPROCESS m_Process; + /** Pointer to the next user client. */ + org_virtualbox_VBoxUSBClient * volatile m_pNext; + /** List of user clients. Protected by g_Mtx. */ + static org_virtualbox_VBoxUSBClient * volatile s_pHead; +}; +OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSBClient, IOUserClient); + + +/** + * The IOUSBDevice driver class. + * + * The main purpose of this is hijack devices matching current filters. + * + * @remarks This is derived from IOUSBUserClientInit instead of IOService because we must make + * sure IOUSBUserClientInit::start() gets invoked for this provider. The problem is that + * there is some kind of magic that prevents this from happening if we boost the probe + * score to high. With the result that we don't have the required plugin entry for + * user land and consequently cannot open it. + * + * So, to avoid having to write a lot of code we just inherit from IOUSBUserClientInit + * and make some possibly bold assumptions about it not changing. This just means + * we'll have to keep an eye on the source apple releases or only call + * IOUSBUserClientInit::start() and hand the rest of the super calls to IOService. For + * now we're doing it by the C++ book. + */ +class org_virtualbox_VBoxUSBDevice : public IOUSBUserClientInit +{ + OSDeclareDefaultStructors(org_virtualbox_VBoxUSBDevice); + +public: + RTR0MEMEF_NEW_AND_DELETE_OPERATORS_IOKIT(); + + /** @name IOService + * @{ */ + virtual bool init(OSDictionary *pDictionary = 0); + virtual IOService *probe(IOService *pProvider, SInt32 *pi32Score); + virtual bool start(IOService *pProvider); + virtual bool terminate(IOOptionBits fOptions = 0); + virtual void stop(IOService *pProvider); + virtual void free(); + virtual IOReturn message(UInt32 enmMsg, IOService *pProvider, void *pvArg = 0); + /** @} */ + + static void scheduleReleaseByOwner(RTPROCESS Owner); +private: + /** Padding to guard against parent class expanding (see class remarks). */ + uint8_t m_abSafetyPadding[256]; + /** The interface we're driving (aka. the provider). */ + IOUSBDevice *m_pDevice; + /** The owner process, meaning the VBoxSVC process. */ + RTPROCESS volatile m_Owner; + /** The client process, meaning the VM process. */ + RTPROCESS volatile m_Client; + /** The ID of the matching filter. */ + uintptr_t m_uId; + /** Have we opened the device or not? */ + bool volatile m_fOpen; + /** Should be open the device on the next close notification message? */ + bool volatile m_fOpenOnWasClosed; + /** Whether to re-enumerate this device when the client closes it. + * This is something we'll do when the filter owner dies. */ + bool volatile m_fReleaseOnClose; + /** Whether we're being unloaded or not. + * Only valid in stop(). */ + bool m_fBeingUnloaded; + /** Pointer to the next device in the list. */ + org_virtualbox_VBoxUSBDevice * volatile m_pNext; + /** Pointer to the list head. Protected by g_Mtx. */ + static org_virtualbox_VBoxUSBDevice * volatile s_pHead; + +#ifdef DEBUG + /** The interest notifier. */ + IONotifier *m_pNotifier; + + static IOReturn MyInterestHandler(void *pvTarget, void *pvRefCon, UInt32 enmMsgType, + IOService *pProvider, void * pvMsgArg, vm_size_t cbMsgArg); +#endif +}; +OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSBDevice, IOUSBUserClientInit); + + +/** + * The IOUSBInterface driver class. + * + * The main purpose of this is hijack interfaces which device is driven + * by org_virtualbox_VBoxUSBDevice. + * + * @remarks See org_virtualbox_VBoxUSBDevice for why we use IOUSBUserClientInit. + */ +class org_virtualbox_VBoxUSBInterface : public IOUSBUserClientInit +{ + OSDeclareDefaultStructors(org_virtualbox_VBoxUSBInterface); + +public: + RTR0MEMEF_NEW_AND_DELETE_OPERATORS_IOKIT(); + + /** @name IOService + * @{ */ + virtual bool init(OSDictionary *pDictionary = 0); + virtual IOService *probe(IOService *pProvider, SInt32 *pi32Score); + virtual bool start(IOService *pProvider); + virtual bool terminate(IOOptionBits fOptions = 0); + virtual void stop(IOService *pProvider); + virtual void free(); + virtual IOReturn message(UInt32 enmMsg, IOService *pProvider, void *pvArg = 0); + /** @} */ + +private: + /** Padding to guard against parent class expanding (see class remarks). */ + uint8_t m_abSafetyPadding[256]; + /** The interface we're driving (aka. the provider). */ + IOUSBInterface *m_pInterface; + /** Have we opened the device or not? */ + bool volatile m_fOpen; + /** Should be open the device on the next close notification message? */ + bool volatile m_fOpenOnWasClosed; +}; +OSDefineMetaClassAndStructors(org_virtualbox_VBoxUSBInterface, IOUSBUserClientInit); + + + + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/* + * Declare the module stuff. + */ +RT_C_DECLS_BEGIN +extern kern_return_t _start(struct kmod_info *pKModInfo, void *pvData); +extern kern_return_t _stop(struct kmod_info *pKModInfo, void *pvData); + +KMOD_EXPLICIT_DECL(VBoxDrv, VBOX_VERSION_STRING, _start, _stop) +DECLHIDDEN(kmod_start_func_t *) _realmain = VBoxUSBStart; +DECLHIDDEN(kmod_stop_func_t *) _antimain = VBoxUSBStop; +DECLHIDDEN(int) _kext_apple_cc = __APPLE_CC__; +RT_C_DECLS_END + +/** Mutex protecting the lists. */ +static RTSEMFASTMUTEX g_Mtx = NIL_RTSEMFASTMUTEX; +org_virtualbox_VBoxUSBClient * volatile org_virtualbox_VBoxUSBClient::s_pHead = NULL; +org_virtualbox_VBoxUSBDevice * volatile org_virtualbox_VBoxUSBDevice::s_pHead = NULL; + +/** Global instance count - just for checking proving that everything is destroyed correctly. */ +static volatile uint32_t g_cInstances = 0; + + +/** + * Start the kernel module. + */ +static kern_return_t VBoxUSBStart(struct kmod_info *pKModInfo, void *pvData) +{ + RT_NOREF(pKModInfo, pvData); + int rc; + Log(("VBoxUSBStart\n")); + + /* + * Initialize IPRT. + */ + rc = RTR0Init(0); + if (RT_SUCCESS(rc)) + { + /* + * Create the spinlock. + */ + rc = RTSemFastMutexCreate(&g_Mtx); + if (RT_SUCCESS(rc)) + { + rc = VBoxUSBFilterInit(); + if (RT_SUCCESS(rc)) + { +#if 0 /* testing */ + USBFILTER Flt; + USBFilterInit(&Flt, USBFILTERTYPE_CAPTURE); + USBFilterSetNumExact(&Flt, USBFILTERIDX_VENDOR_ID, 0x096e, true); + uintptr_t uId; + rc = VBoxUSBFilterAdd(&Flt, 1, &uId); + printf("VBoxUSB: VBoxUSBFilterAdd #1 -> %d + %p\n", rc, uId); + + USBFilterInit(&Flt, USBFILTERTYPE_CAPTURE); + USBFilterSetStringPattern(&Flt, USBFILTERIDX_PRODUCT_STR, "*DISK*", true); + rc = VBoxUSBFilterAdd(&Flt, 2, &uId); + printf("VBoxUSB: VBoxUSBFilterAdd #2 -> %d + %p\n", rc, uId); +#endif + return KMOD_RETURN_SUCCESS; + } + printf("VBoxUSB: VBoxUSBFilterInit failed (rc=%d)\n", rc); + RTSemFastMutexDestroy(g_Mtx); + g_Mtx = NIL_RTSEMFASTMUTEX; + } + else + printf("VBoxUSB: RTSemFastMutexCreate failed (rc=%d)\n", rc); + RTR0Term(); + } + else + printf("VBoxUSB: failed to initialize IPRT (rc=%d)\n", rc); + + return KMOD_RETURN_FAILURE; +} + + +/** + * Stop the kernel module. + */ +static kern_return_t VBoxUSBStop(struct kmod_info *pKModInfo, void *pvData) +{ + RT_NOREF(pKModInfo, pvData); + Log(("VBoxUSBStop: g_cInstances=%d\n", g_cInstances)); + + /** @todo Fix problem with crashing when unloading a driver that's in use. */ + + /* + * Undo the work done during start (in reverse order). + */ + VBoxUSBFilterTerm(); + + int rc = RTSemFastMutexDestroy(g_Mtx); + AssertRC(rc); + g_Mtx = NIL_RTSEMFASTMUTEX; + + RTR0Term(); + + Log(("VBoxUSBStop - done\n")); + return KMOD_RETURN_SUCCESS; +} + + + + + +#ifdef LOG_ENABLED +/** + * Gets the name of a IOKit message. + * + * @returns Message name (read only). + * @param enmMsg The message. + */ +DECLINLINE(const char *) DbgGetIOKitMessageName(UInt32 enmMsg) +{ + switch (enmMsg) + { +# define MY_CASE(enm) case enm: return #enm; break + MY_CASE(kIOMessageServiceIsTerminated); + MY_CASE(kIOMessageServiceIsSuspended); + MY_CASE(kIOMessageServiceIsResumed); + MY_CASE(kIOMessageServiceIsRequestingClose); + MY_CASE(kIOMessageServiceIsAttemptingOpen); + MY_CASE(kIOMessageServiceWasClosed); + MY_CASE(kIOMessageServiceBusyStateChange); + MY_CASE(kIOMessageServicePropertyChange); + MY_CASE(kIOMessageCanDevicePowerOff); + MY_CASE(kIOMessageDeviceWillPowerOff); + MY_CASE(kIOMessageDeviceWillNotPowerOff); + MY_CASE(kIOMessageDeviceHasPoweredOn); + MY_CASE(kIOMessageCanSystemPowerOff); + MY_CASE(kIOMessageSystemWillPowerOff); + MY_CASE(kIOMessageSystemWillNotPowerOff); + MY_CASE(kIOMessageCanSystemSleep); + MY_CASE(kIOMessageSystemWillSleep); + MY_CASE(kIOMessageSystemWillNotSleep); + MY_CASE(kIOMessageSystemHasPoweredOn); + MY_CASE(kIOMessageSystemWillRestart); + MY_CASE(kIOMessageSystemWillPowerOn); + MY_CASE(kIOUSBMessageHubResetPort); + MY_CASE(kIOUSBMessageHubSuspendPort); + MY_CASE(kIOUSBMessageHubResumePort); + MY_CASE(kIOUSBMessageHubIsDeviceConnected); + MY_CASE(kIOUSBMessageHubIsPortEnabled); + MY_CASE(kIOUSBMessageHubReEnumeratePort); + MY_CASE(kIOUSBMessagePortHasBeenReset); + MY_CASE(kIOUSBMessagePortHasBeenResumed); + MY_CASE(kIOUSBMessageHubPortClearTT); + MY_CASE(kIOUSBMessagePortHasBeenSuspended); + MY_CASE(kIOUSBMessageFromThirdParty); + MY_CASE(kIOUSBMessagePortWasNotSuspended); + MY_CASE(kIOUSBMessageExpressCardCantWake); +// MY_CASE(kIOUSBMessageCompositeDriverReconfigured); +# undef MY_CASE + } + return "unknown"; +} +#endif /* LOG_ENABLED */ + + + + + +/* + * + * org_virtualbox_VBoxUSB + * + */ + + +/** + * Initialize the object. + * @remark Only for logging. + */ +bool +org_virtualbox_VBoxUSB::init(OSDictionary *pDictionary) +{ + uint32_t cInstances = ASMAtomicIncU32(&g_cInstances); + Log(("VBoxUSB::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances)); + RT_NOREF_PV(cInstances); + + if (IOService::init(pDictionary)) + { + /* init members. */ + return true; + } + ASMAtomicDecU32(&g_cInstances); + return false; +} + + +/** + * Free the object. + * @remark Only for logging. + */ +void +org_virtualbox_VBoxUSB::free() +{ + uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances); + Log(("VBoxUSB::free([%p]) new g_cInstances=%d\n", this, cInstances)); + IOService::free(); +} + + +/** + * Start this service. + */ +bool +org_virtualbox_VBoxUSB::start(IOService *pProvider) +{ + Log(("VBoxUSB::start([%p], %p {%s})\n", this, pProvider, pProvider->getName())); + + if (IOService::start(pProvider)) + { + /* register the service. */ + registerService(); + return true; + } + return false; +} + + +/** + * Stop this service. + * @remark Only for logging. + */ +void +org_virtualbox_VBoxUSB::stop(IOService *pProvider) +{ + Log(("VBoxUSB::stop([%p], %p (%s))\n", this, pProvider, pProvider->getName())); + IOService::stop(pProvider); +} + + +/** + * Stop this service. + * @remark Only for logging. + */ +bool +org_virtualbox_VBoxUSB::open(IOService *pForClient, IOOptionBits fOptions/* = 0*/, void *pvArg/* = 0*/) +{ + Log(("VBoxUSB::open([%p], %p, %#x, %p)\n", this, pForClient, fOptions, pvArg)); + bool fRc = IOService::open(pForClient, fOptions, pvArg); + Log(("VBoxUSB::open([%p], %p, %#x, %p) -> %d\n", this, pForClient, fOptions, pvArg, fRc)); + return fRc; +} + + +/** + * Stop this service. + * @remark Only for logging. + */ +void +org_virtualbox_VBoxUSB::close(IOService *pForClient, IOOptionBits fOptions/* = 0*/) +{ + Log(("VBoxUSB::close([%p], %p, %#x)\n", this, pForClient, fOptions)); + IOService::close(pForClient, fOptions); +} + + +/** + * Terminate request. + * @remark Only for logging. + */ +bool +org_virtualbox_VBoxUSB::terminate(IOOptionBits fOptions) +{ + Log(("VBoxUSB::terminate([%p], %#x): g_cInstances=%d\n", this, fOptions, g_cInstances)); + bool fRc = IOService::terminate(fOptions); + Log(("VBoxUSB::terminate([%p], %#x): returns %d\n", this, fOptions, fRc)); + return fRc; +} + + + + + + + + + + + +/* + * + * org_virtualbox_VBoxUSBClient + * + */ + + +/** + * Initializer called when the client opens the service. + */ +bool +org_virtualbox_VBoxUSBClient::initWithTask(task_t OwningTask, void *pvSecurityId, UInt32 u32Type) +{ + if (!OwningTask) + { + Log(("VBoxUSBClient::initWithTask([%p], %p, %p, %#x) -> false (no task)\n", this, OwningTask, pvSecurityId, u32Type)); + return false; + } + if (u32Type != VBOXUSB_DARWIN_IOSERVICE_COOKIE) + { + Log(("VBoxUSBClient::initWithTask: Bade cookie %#x\n", u32Type)); + return false; + } + + proc_t pProc = (proc_t)get_bsdtask_info(OwningTask); /* we need the pid */ + Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x)\n", + this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type)); + + if (IOUserClient::initWithTask(OwningTask, pvSecurityId , u32Type)) + { + /* + * In theory we have to call task_reference() to make sure that the task is + * valid during the lifetime of this object. The pointer is only used to check + * for the context this object is called in though and never dereferenced + * or passed to anything which might, so we just skip this step. + */ + m_pProvider = NULL; + m_Task = OwningTask; + m_Process = pProc ? proc_pid(pProc) : NIL_RTPROCESS; + m_pNext = NULL; + + uint32_t cInstances = ASMAtomicIncU32(&g_cInstances); + Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x) -> true; new g_cInstances=%d\n", + this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type, cInstances)); + RT_NOREF_PV(cInstances); + return true; + } + + Log(("VBoxUSBClient::initWithTask([%p], %p(->%p:{.pid=%d}, %p, %#x) -> false\n", + this, OwningTask, pProc, pProc ? proc_pid(pProc) : -1, pvSecurityId, u32Type)); + return false; +} + + +/** + * Free the object. + * @remark Only for logging. + */ +void +org_virtualbox_VBoxUSBClient::free() +{ + uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances); + Log(("VBoxUSBClient::free([%p]) new g_cInstances=%d\n", this, cInstances)); + IOUserClient::free(); +} + + +/** + * Start the client service. + */ +bool +org_virtualbox_VBoxUSBClient::start(IOService *pProvider) +{ + Log(("VBoxUSBClient::start([%p], %p)\n", this, pProvider)); + if (IOUserClient::start(pProvider)) + { + m_pProvider = OSDynamicCast(org_virtualbox_VBoxUSB, pProvider); + if (m_pProvider) + { + /* + * Add ourselves to the list of user clients. + */ + VBOXUSB_LOCK(); + + m_pNext = s_pHead; + s_pHead = this; + + VBOXUSB_UNLOCK(); + + return true; + } + Log(("VBoxUSBClient::start: %p isn't org_virtualbox_VBoxUSB\n", pProvider)); + } + return false; +} + + +/** + * Client exits normally. + */ +IOReturn +org_virtualbox_VBoxUSBClient::clientClose(void) +{ + Log(("VBoxUSBClient::clientClose([%p:{.m_Process=%d}])\n", this, (int)m_Process)); + + /* + * Remove this process from the client list. + */ + VBOXUSB_LOCK(); + + org_virtualbox_VBoxUSBClient *pPrev = NULL; + for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext) + { + if (pCur == this) + { + if (pPrev) + pPrev->m_pNext = m_pNext; + else + s_pHead = m_pNext; + m_pNext = NULL; + break; + } + pPrev = pCur; + } + + VBOXUSB_UNLOCK(); + + /* + * Drop all filters owned by this client. + */ + if (m_Process != NIL_RTPROCESS) + VBoxUSBFilterRemoveOwner(m_Process); + + /* + * Schedule all devices owned (filtered) by this process for + * immediate release or release upon close. + */ + if (m_Process != NIL_RTPROCESS) + org_virtualbox_VBoxUSBDevice::scheduleReleaseByOwner(m_Process); + + /* + * Initiate termination. + */ + m_pProvider = NULL; + terminate(); + + return kIOReturnSuccess; +} + + +/** + * The client exits abnormally / forgets to do cleanups. + * @remark Only for logging. + */ +IOReturn +org_virtualbox_VBoxUSBClient::clientDied(void) +{ + Log(("VBoxUSBClient::clientDied([%p]) m_Task=%p R0Process=%p Process=%d\n", + this, m_Task, RTR0ProcHandleSelf(), RTProcSelf())); + + /* IOUserClient::clientDied() calls clientClose... */ + return IOUserClient::clientDied(); +} + + +/** + * Terminate the service (initiate the destruction). + * @remark Only for logging. + */ +bool +org_virtualbox_VBoxUSBClient::terminate(IOOptionBits fOptions) +{ + /* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */ + Log(("VBoxUSBClient::terminate([%p], %#x)\n", this, fOptions)); + return IOUserClient::terminate(fOptions); +} + + +/** + * The final stage of the client service destruction. + * @remark Only for logging. + */ +bool +org_virtualbox_VBoxUSBClient::finalize(IOOptionBits fOptions) +{ + Log(("VBoxUSBClient::finalize([%p], %#x)\n", this, fOptions)); + return IOUserClient::finalize(fOptions); +} + + +/** + * Stop the client service. + */ +void +org_virtualbox_VBoxUSBClient::stop(IOService *pProvider) +{ + Log(("VBoxUSBClient::stop([%p])\n", this)); + IOUserClient::stop(pProvider); + + /* + * Paranoia. + */ + VBOXUSB_LOCK(); + + org_virtualbox_VBoxUSBClient *pPrev = NULL; + for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext) + { + if (pCur == this) + { + if (pPrev) + pPrev->m_pNext = m_pNext; + else + s_pHead = m_pNext; + m_pNext = NULL; + break; + } + pPrev = pCur; + } + + VBOXUSB_UNLOCK(); +} + + +/** + * Translate a user method index into a service object and an external method structure. + * + * @returns Pointer to external method structure descripting the method. + * NULL if the index isn't valid. + * @param ppService Where to store the service object on success. + * @param iMethod The method index. + */ +IOExternalMethod * +org_virtualbox_VBoxUSBClient::getTargetAndMethodForIndex(IOService **ppService, UInt32 iMethod) +{ + static IOExternalMethod s_aMethods[VBOXUSBMETHOD_END] = + { + /*[VBOXUSBMETHOD_ADD_FILTER] = */ + { + (IOService *)0, /* object */ + (IOMethod)&org_virtualbox_VBoxUSBClient::addFilter, /* func */ + kIOUCStructIStructO, /* flags - struct input (count0) and struct output (count1) */ + sizeof(USBFILTER), /* count0 - size of the input struct. */ + sizeof(VBOXUSBADDFILTEROUT) /* count1 - size of the return struct. */ + }, + /* [VBOXUSBMETHOD_FILTER_REMOVE] = */ + { + (IOService *)0, /* object */ + (IOMethod)&org_virtualbox_VBoxUSBClient::removeFilter, /* func */ + kIOUCStructIStructO, /* flags - struct input (count0) and struct output (count1) */ + sizeof(uintptr_t), /* count0 - size of the input (id) */ + sizeof(int) /* count1 - size of the output (rc) */ + }, + }; + + if (RT_UNLIKELY(iMethod >= RT_ELEMENTS(s_aMethods))) + return NULL; + + *ppService = this; + return &s_aMethods[iMethod]; +} + + +/** + * Add filter user request. + * + * @returns IOKit status code. + * @param pFilter The filter to add. + * @param pOut Pointer to the output structure. + * @param cbFilter Size of the filter structure. + * @param pcbOut In/Out - sizeof(*pOut). + */ +IOReturn +org_virtualbox_VBoxUSBClient::addFilter(PUSBFILTER pFilter, PVBOXUSBADDFILTEROUT pOut, IOByteCount cbFilter, IOByteCount *pcbOut) +{ + Log(("VBoxUSBClient::addFilter: [%p:{.m_Process=%d}] pFilter=%p pOut=%p\n", this, (int)m_Process, pFilter, pOut)); + + /* + * Validate input. + */ + if (RT_UNLIKELY( cbFilter != sizeof(*pFilter) + || *pcbOut != sizeof(*pOut))) + { + printf("VBoxUSBClient::addFilter: cbFilter=%#x expected %#x; *pcbOut=%#x expected %#x\n", + (int)cbFilter, (int)sizeof(*pFilter), (int)*pcbOut, (int)sizeof(*pOut)); + return kIOReturnBadArgument; + } + + /* + * Log the filter details. + */ +#ifdef DEBUG + Log2(("VBoxUSBClient::addFilter: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n", + USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID), + USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_REV), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_CLASS), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_SUB_CLASS), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL), + USBFilterGetNum(pFilter, USBFILTERIDX_BUS), + USBFilterGetNum(pFilter, USBFILTERIDX_PORT))); + Log2(("VBoxUSBClient::addFilter: Manufacturer=%s Product=%s Serial=%s\n", + USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>")); +#endif + + /* + * Since we cannot query the bus number, make sure the filter + * isn't requiring that field to be present. + */ + int rc = USBFilterSetMustBePresent(pFilter, USBFILTERIDX_BUS, false /* fMustBePresent */); AssertRC(rc); + + /* + * Add the filter. + */ + pOut->uId = 0; + pOut->rc = VBoxUSBFilterAdd(pFilter, m_Process, &pOut->uId); + + Log(("VBoxUSBClient::addFilter: returns *pOut={.rc=%d, .uId=%p}\n", pOut->rc, (void *)pOut->uId)); + return kIOReturnSuccess; +} + + +/** + * Removes filter user request. + * + * @returns IOKit status code. + * @param puId Where to get the filter ID. + * @param prc Where to store the return code. + * @param cbIn sizeof(*puId). + * @param pcbOut In/Out - sizeof(*prc). + */ +IOReturn +org_virtualbox_VBoxUSBClient::removeFilter(uintptr_t *puId, int *prc, IOByteCount cbIn, IOByteCount *pcbOut) +{ + Log(("VBoxUSBClient::removeFilter: [%p:{.m_Process=%d}] *puId=%p m_Proc\n", this, (int)m_Process, *puId)); + + /* + * Validate input. + */ + if (RT_UNLIKELY( cbIn != sizeof(*puId) + || *pcbOut != sizeof(*prc))) + { + printf("VBoxUSBClient::removeFilter: cbIn=%#x expected %#x; *pcbOut=%#x expected %#x\n", + (int)cbIn, (int)sizeof(*puId), (int)*pcbOut, (int)sizeof(*prc)); + return kIOReturnBadArgument; + } + + /* + * Remove the filter. + */ + *prc = VBoxUSBFilterRemove(m_Process, *puId); + + Log(("VBoxUSBClient::removeFilter: returns *prc=%d\n", *prc)); + return kIOReturnSuccess; +} + + +/** + * Checks whether the specified task is a VBoxUSB client task or not. + * + * This is used to validate clients trying to open any of the device + * or interfaces that we've hijacked. + * + * @returns true / false. + * @param ClientTask The task. + * + * @remark This protecting against other user clients is not currently implemented + * as it turned out to be more bothersome than first imagined. + */ +/* static*/ bool +org_virtualbox_VBoxUSBClient::isClientTask(task_t ClientTask) +{ + VBOXUSB_LOCK(); + + for (org_virtualbox_VBoxUSBClient *pCur = s_pHead; pCur; pCur = pCur->m_pNext) + if (pCur->m_Task == ClientTask) + { + VBOXUSB_UNLOCK(); + return true; + } + + VBOXUSB_UNLOCK(); + return false; +} + + + + + + + + + + + + + + +/* + * + * org_virtualbox_VBoxUSBDevice + * + */ + +/** + * Initialize instance data. + * + * @returns Success indicator. + * @param pDictionary The dictionary that will become the registry entry's + * property table, or NULL. Hand it up to our parents. + */ +bool +org_virtualbox_VBoxUSBDevice::init(OSDictionary *pDictionary) +{ + uint32_t cInstances = ASMAtomicIncU32(&g_cInstances); + Log(("VBoxUSBDevice::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances)); + RT_NOREF_PV(cInstances); + + m_pDevice = NULL; + m_Owner = NIL_RTPROCESS; + m_Client = NIL_RTPROCESS; + m_uId = ~(uintptr_t)0; + m_fOpen = false; + m_fOpenOnWasClosed = false; + m_fReleaseOnClose = false; + m_fBeingUnloaded = false; + m_pNext = NULL; +#ifdef DEBUG + m_pNotifier = NULL; +#endif + + return IOUSBUserClientInit::init(pDictionary); +} + +/** + * Free the object. + * @remark Only for logging. + */ +void +org_virtualbox_VBoxUSBDevice::free() +{ + uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances); + Log(("VBoxUSBDevice::free([%p]) new g_cInstances=%d\n", this, cInstances)); + IOUSBUserClientInit::free(); +} + + +/** + * The device/driver probing. + * + * I/O Kit will iterate all device drivers suitable for this kind of device + * (this is something it figures out from the property file) and call their + * probe() method in order to try determine which is the best match for the + * device. We will match the device against the registered filters and set + * a ridiculously high score if we find it, thus making it extremely likely + * that we'll be the first driver to be started. We'll also set a couple of + * attributes so that it's not necessary to do a rematch in init to find + * the appropriate filter (might not be necessary..., see todo). + * + * @returns Service instance to be started and *pi32Score if matching. + * NULL if not a device suitable for this driver. + * + * @param pProvider The provider instance. + * @param pi32Score Where to store the probe score. + */ +IOService * +org_virtualbox_VBoxUSBDevice::probe(IOService *pProvider, SInt32 *pi32Score) +{ + Log(("VBoxUSBDevice::probe([%p], %p {%s}, %p={%d})\n", this, + pProvider, pProvider->getName(), pi32Score, pi32Score ? *pi32Score : 0)); + + /* + * Check against filters. + */ + USBFILTER Device; + USBFilterInit(&Device, USBFILTERTYPE_CAPTURE); + + static const struct + { + const char *pszName; + USBFILTERIDX enmIdx; + bool fNumeric; + } s_aProps[] = + { + { kUSBVendorID, USBFILTERIDX_VENDOR_ID, true }, + { kUSBProductID, USBFILTERIDX_PRODUCT_ID, true }, + { kUSBDeviceReleaseNumber, USBFILTERIDX_DEVICE_REV, true }, + { kUSBDeviceClass, USBFILTERIDX_DEVICE_CLASS, true }, + { kUSBDeviceSubClass, USBFILTERIDX_DEVICE_SUB_CLASS, true }, + { kUSBDeviceProtocol, USBFILTERIDX_DEVICE_PROTOCOL, true }, + { "PortNum", USBFILTERIDX_PORT, true }, + /// @todo { , USBFILTERIDX_BUS, true }, - must be derived :-/ + /// Seems to be the upper byte of locationID and our "grand parent" has a USBBusNumber prop. + { "USB Vendor Name", USBFILTERIDX_MANUFACTURER_STR, false }, + { "USB Product Name", USBFILTERIDX_PRODUCT_STR, false }, + { "USB Serial Number", USBFILTERIDX_SERIAL_NUMBER_STR, false }, + }; + for (unsigned i = 0; i < RT_ELEMENTS(s_aProps); i++) + { + OSObject *pObj = pProvider->getProperty(s_aProps[i].pszName); + if (!pObj) + continue; + if (s_aProps[i].fNumeric) + { + OSNumber *pNum = OSDynamicCast(OSNumber, pObj); + if (pNum) + { + uint16_t u16 = pNum->unsigned16BitValue(); + Log2(("VBoxUSBDevice::probe: %d/%s - %#x (32bit=%#x)\n", i, s_aProps[i].pszName, u16, pNum->unsigned32BitValue())); + int vrc = USBFilterSetNumExact(&Device, s_aProps[i].enmIdx, u16, true); + if (RT_FAILURE(vrc)) + Log(("VBoxUSBDevice::probe: pObj=%p pNum=%p - %d/%s - rc=%d!\n", pObj, pNum, i, s_aProps[i].pszName, vrc)); + } + else + Log(("VBoxUSBDevice::probe: pObj=%p pNum=%p - %d/%s!\n", pObj, pNum, i, s_aProps[i].pszName)); + } + else + { + OSString *pStr = OSDynamicCast(OSString, pObj); + if (pStr) + { + Log2(("VBoxUSBDevice::probe: %d/%s - %s\n", i, s_aProps[i].pszName, pStr->getCStringNoCopy())); + int vrc = USBFilterSetStringExact(&Device, s_aProps[i].enmIdx, pStr->getCStringNoCopy(), + true /*fMustBePresent*/, true /*fPurge*/); + if (RT_FAILURE(vrc)) + Log(("VBoxUSBDevice::probe: pObj=%p pStr=%p - %d/%s - rc=%d!\n", pObj, pStr, i, s_aProps[i].pszName, vrc)); + } + else + Log(("VBoxUSBDevice::probe: pObj=%p pStr=%p - %d/%s\n", pObj, pStr, i, s_aProps[i].pszName)); + } + } + /** @todo try figure the blasted bus number */ + + /* + * Run filters on it. + */ + uintptr_t uId = 0; + RTPROCESS Owner = VBoxUSBFilterMatch(&Device, &uId); + USBFilterDelete(&Device); + if (Owner == NIL_RTPROCESS) + { + Log(("VBoxUSBDevice::probe: returns NULL uId=%d\n", uId)); + return NULL; + } + + /* + * It matched. Save the owner in the provider registry (hope that works). + */ + /*IOService *pRet = IOUSBUserClientInit::probe(pProvider, pi32Score); - call always returns NULL on 10.11+ */ + /*AssertMsg(pRet == this, ("pRet=%p this=%p *pi32Score=%d \n", pRet, this, pi32Score ? *pi32Score : 0)); - call always returns NULL on 10.11+ */ + IOService *pRet = this; + m_Owner = Owner; + m_uId = uId; + Log(("%p: m_Owner=%d m_uId=%d\n", this, (int)m_Owner, (int)m_uId)); + *pi32Score = _1G; + Log(("VBoxUSBDevice::probe: returns %p and *pi32Score=%d\n", pRet, *pi32Score)); + return pRet; +} + + +/** + * Try start the device driver. + * + * We will do device linking, copy the filter and owner properties from the provider, + * set the client property, retain the device, and try open (seize) the device. + * + * @returns Success indicator. + * @param pProvider The provider instance. + */ +bool +org_virtualbox_VBoxUSBDevice::start(IOService *pProvider) +{ + Log(("VBoxUSBDevice::start([%p:{.m_Owner=%d, .m_uId=%p}], %p {%s})\n", + this, m_Owner, m_uId, pProvider, pProvider->getName())); + + m_pDevice = OSDynamicCast(IOUSBDevice, pProvider); + if (!m_pDevice) + { + printf("VBoxUSBDevice::start([%p], %p {%s}): failed!\n", this, pProvider, pProvider->getName()); + return false; + } + +#ifdef DEBUG + /* for some extra log messages */ + m_pNotifier = pProvider->registerInterest(gIOGeneralInterest, + &org_virtualbox_VBoxUSBDevice::MyInterestHandler, + this, /* pvTarget */ + NULL); /* pvRefCon */ +#endif + + /* + * Exploit IOUSBUserClientInit to process IOProviderMergeProperties. + */ + IOUSBUserClientInit::start(pProvider); /* returns false */ + + /* + * Link ourselves into the list of hijacked device. + */ + VBOXUSB_LOCK(); + + m_pNext = s_pHead; + s_pHead = this; + + VBOXUSB_UNLOCK(); + + /* + * Set the VBoxUSB properties. + */ + if (!setProperty(VBOXUSB_OWNER_KEY, (unsigned long long)m_Owner, sizeof(m_Owner) * 8 /* bits */)) + Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_OWNER_KEY "' property!\n")); + if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */)) + Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n")); + if (!setProperty(VBOXUSB_FILTER_KEY, (unsigned long long)m_uId, sizeof(m_uId) * 8 /* bits */)) + Log(("VBoxUSBDevice::start: failed to set the '" VBOXUSB_FILTER_KEY "' property!\n")); + + /* + * Retain and open the device. + */ + m_pDevice->retain(); + m_fOpen = m_pDevice->open(this, kIOServiceSeize, 0); + if (!m_fOpen) + Log(("VBoxUSBDevice::start: failed to open the device!\n")); + m_fOpenOnWasClosed = !m_fOpen; + + Log(("VBoxUSBDevice::start: returns %d\n", true)); + return true; +} + + +/** + * Stop the device driver. + * + * We'll unlink the device, start device re-enumeration and close it. And call + * the parent stop method of course. + * + * @param pProvider The provider instance. + */ +void +org_virtualbox_VBoxUSBDevice::stop(IOService *pProvider) +{ + Log(("VBoxUSBDevice::stop([%p], %p {%s})\n", this, pProvider, pProvider->getName())); + + /* + * Remove ourselves from the list of device. + */ + VBOXUSB_LOCK(); + + org_virtualbox_VBoxUSBDevice *pPrev = NULL; + for (org_virtualbox_VBoxUSBDevice *pCur = s_pHead; pCur; pCur = pCur->m_pNext) + { + if (pCur == this) + { + if (pPrev) + pPrev->m_pNext = m_pNext; + else + s_pHead = m_pNext; + m_pNext = NULL; + break; + } + pPrev = pCur; + } + + VBOXUSB_UNLOCK(); + + /* + * Should we release the device? + */ + if (m_fBeingUnloaded) + { + if (m_pDevice) + { + IOReturn irc = m_pDevice->ReEnumerateDevice(0); NOREF(irc); + Log(("VBoxUSBDevice::stop([%p], %p {%s}): m_pDevice=%p unload & ReEnumerateDevice -> %#x\n", + this, pProvider, pProvider->getName(), m_pDevice, irc)); + } + else + { + IOUSBDevice *pDevice = OSDynamicCast(IOUSBDevice, pProvider); + if (pDevice) + { + IOReturn irc = pDevice->ReEnumerateDevice(0); NOREF(irc); + Log(("VBoxUSBDevice::stop([%p], %p {%s}): pDevice=%p unload & ReEnumerateDevice -> %#x\n", + this, pProvider, pProvider->getName(), pDevice, irc)); + } + else + Log(("VBoxUSBDevice::stop([%p], %p {%s}): failed to cast provider to IOUSBDevice\n", + this, pProvider, pProvider->getName())); + } + } + else if (m_fReleaseOnClose) + { + ASMAtomicWriteBool(&m_fReleaseOnClose, false); + if (m_pDevice) + { + IOReturn irc = m_pDevice->ReEnumerateDevice(0); NOREF(irc); + Log(("VBoxUSBDevice::stop([%p], %p {%s}): m_pDevice=%p close & ReEnumerateDevice -> %#x\n", + this, pProvider, pProvider->getName(), m_pDevice, irc)); + } + } + + /* + * Close and release the IOUSBDevice if didn't do that already in message(). + */ + if (m_pDevice) + { + /* close it */ + if (m_fOpen) + { + m_fOpenOnWasClosed = false; + m_fOpen = false; + m_pDevice->close(this, 0); + } + + /* release it (see start()) */ + m_pDevice->release(); + m_pDevice = NULL; + } + +#ifdef DEBUG + /* avoid crashing on unload. */ + if (m_pNotifier) + { + m_pNotifier->release(); + m_pNotifier = NULL; + } +#endif + + IOUSBUserClientInit::stop(pProvider); + Log(("VBoxUSBDevice::stop: returns void\n")); +} + + +/** + * Terminate the service (initiate the destruction). + * @remark Only for logging. + */ +bool +org_virtualbox_VBoxUSBDevice::terminate(IOOptionBits fOptions) +{ + /* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */ + Log(("VBoxUSBDevice::terminate([%p], %#x)\n", this, fOptions)); + + /* + * There aren't too many reasons why we gets terminated. + * The most common one is that the device is being unplugged. Another is + * that we've triggered reenumeration. In both cases we'll get a + * kIOMessageServiceIsTerminated message before we're stopped. + * + * But, when we're unloaded the provider service isn't terminated, and + * for some funny reason we're frequently causing kernel panics when the + * device is detached (after we're unloaded). So, for now, let's try + * re-enumerate it in stop. + * + * To avoid creating unnecessary trouble we'll try guess if we're being + * unloaded from the option bit mask. (kIOServiceRecursing is private btw.) + */ + /** @todo would be nice if there was a documented way of doing the unload detection this, or + * figure out what exactly we're doing wrong in the unload scenario. */ + if ((fOptions & 0xffff) == (kIOServiceRequired | kIOServiceSynchronous)) + m_fBeingUnloaded = true; + + return IOUSBUserClientInit::terminate(fOptions); +} + + +/** + * Intercept open requests and only let Mr. Right (the VM process) open the device. + * This is where it all gets a bit complicated... + * + * @return Status code. + * + * @param enmMsg The message number. + * @param pProvider Pointer to the provider instance. + * @param pvArg Message argument. + */ +IOReturn +org_virtualbox_VBoxUSBDevice::message(UInt32 enmMsg, IOService *pProvider, void *pvArg) +{ + Log(("VBoxUSBDevice::message([%p], %#x {%s}, %p {%s}, %p) - pid=%d\n", + this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, RTProcSelf())); + + IOReturn irc; + switch (enmMsg) + { + /* + * This message is send to the current IOService client from IOService::handleOpen(), + * expecting it to call pProvider->close() if it agrees to the other party seizing + * the service. It is also called in IOService::didTerminate() and perhaps some other + * odd places. The way to find out is to examin the pvArg, which would be including + * kIOServiceSeize if it's the handleOpen case. + * + * How to validate that the other end is actually our VM process? Well, IOKit doesn't + * provide any clue about the new client really. But fortunately, it seems like the + * calling task/process context when the VM tries to open the device is the VM process. + * We'll ASSUME this'll remain like this for now... + */ + case kIOMessageServiceIsRequestingClose: + irc = kIOReturnExclusiveAccess; + /* If it's not a seize request, assume it's didTerminate and pray that it isn't a rouge driver. + ... weird, doesn't seem to match for the post has-terminated messages. */ + if (!((uintptr_t)pvArg & kIOServiceSeize)) + { + Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d: not seize - closing...\n", + this, pProvider, pProvider->getName(), pvArg, RTProcSelf())); + m_fOpen = false; + m_fOpenOnWasClosed = false; + if (m_pDevice) + m_pDevice->close(this, 0); + m_Client = NIL_RTPROCESS; + irc = kIOReturnSuccess; + } + else + { + if (org_virtualbox_VBoxUSBClient::isClientTask(current_task())) + { + Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d task=%p: client process, closing.\n", + this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task())); + m_fOpen = false; + m_fOpenOnWasClosed = false; + if (m_pDevice) + m_pDevice->close(this, 0); + m_fOpenOnWasClosed = true; + m_Client = RTProcSelf(); + irc = kIOReturnSuccess; + } + else + Log(("VBoxUSBDevice::message([%p],%p {%s}, %p) - pid=%d task=%p: not client process!\n", + this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task())); + } + if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */)) + Log(("VBoxUSBDevice::message: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n")); + break; + + /* + * The service was closed by the current client. + * Update the client property, check for scheduled re-enumeration and re-open. + * + * Note that we will not be called if we're doing the closing. (Even if we was + * called in that case, the code should be able to handle it.) + */ + case kIOMessageServiceWasClosed: + /* + * Update the client property value. + */ + if (m_Client != NIL_RTPROCESS) + { + m_Client = NIL_RTPROCESS; + if (!setProperty(VBOXUSB_CLIENT_KEY, (unsigned long long)m_Client, sizeof(m_Client) * 8 /* bits */)) + Log(("VBoxUSBDevice::message: failed to set the '" VBOXUSB_CLIENT_KEY "' property!\n")); + } + + if (m_pDevice) + { + /* + * Should we release the device? + */ + if (ASMAtomicXchgBool(&m_fReleaseOnClose, false)) + { + m_fOpenOnWasClosed = false; + irc = m_pDevice->ReEnumerateDevice(0); + Log(("VBoxUSBDevice::message([%p], %p {%s}) - ReEnumerateDevice() -> %#x\n", + this, pProvider, pProvider->getName(), irc)); + } + /* + * Should we attempt to re-open the device? + */ + else if (m_fOpenOnWasClosed) + { + Log(("VBoxUSBDevice::message: attempting to re-open the device...\n")); + m_fOpenOnWasClosed = false; + m_fOpen = m_pDevice->open(this, kIOServiceSeize, 0); + if (!m_fOpen) + Log(("VBoxUSBDevice::message: failed to open the device!\n")); + m_fOpenOnWasClosed = !m_fOpen; + } + } + + irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg); + break; + + /* + * The IOUSBDevice is shutting down, so close it if we've opened it. + */ + case kIOMessageServiceIsTerminated: + m_fBeingUnloaded = false; + ASMAtomicWriteBool(&m_fReleaseOnClose, false); + if (m_pDevice) + { + /* close it */ + if (m_fOpen) + { + m_fOpen = false; + m_fOpenOnWasClosed = false; + Log(("VBoxUSBDevice::message: closing the device (%p)...\n", m_pDevice)); + m_pDevice->close(this, 0); + } + + /* release it (see start()) */ + Log(("VBoxUSBDevice::message: releasing the device (%p)...\n", m_pDevice)); + m_pDevice->release(); + m_pDevice = NULL; + } + + irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg); + break; + + default: + irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg); + break; + } + + Log(("VBoxUSBDevice::message([%p], %#x {%s}, %p {%s}, %p) -> %#x\n", + this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, irc)); + return irc; +} + + +/** + * Schedule all devices belonging to the specified process for release. + * + * Devices that aren't currently in use will be released immediately. + * + * @param Owner The owner process. + */ +/* static */ void +org_virtualbox_VBoxUSBDevice::scheduleReleaseByOwner(RTPROCESS Owner) +{ + Log2(("VBoxUSBDevice::scheduleReleaseByOwner: Owner=%d\n", Owner)); + AssertReturnVoid(Owner && Owner != NIL_RTPROCESS); + + /* + * Walk the list of devices looking for device belonging to this process. + * + * If we release a device, we have to lave the spinlock and will therefore + * have to restart the search. + */ + VBOXUSB_LOCK(); + + org_virtualbox_VBoxUSBDevice *pCur; + do + { + for (pCur = s_pHead; pCur; pCur = pCur->m_pNext) + { + Log2(("VBoxUSBDevice::scheduleReleaseByOwner: pCur=%p m_Owner=%d (%s) m_fReleaseOnClose=%d\n", + pCur, pCur->m_Owner, pCur->m_Owner == Owner ? "match" : "mismatch", pCur->m_fReleaseOnClose)); + if (pCur->m_Owner == Owner) + { + /* make sure we won't hit it again. */ + pCur->m_Owner = NIL_RTPROCESS; + IOUSBDevice *pDevice = pCur->m_pDevice; + if ( pDevice + && !pCur->m_fReleaseOnClose) + { + pCur->m_fOpenOnWasClosed = false; + if (pCur->m_Client != NIL_RTPROCESS) + { + /* It's currently open, so just schedule it for re-enumeration on close. */ + ASMAtomicWriteBool(&pCur->m_fReleaseOnClose, true); + Log(("VBoxUSBDevice::scheduleReleaseByOwner: %p {%s} - used by %d\n", + pDevice, pDevice->getName(), pCur->m_Client)); + } + else + { + /* + * Get the USBDevice object and do the re-enumeration now. + * Retain the device so we don't run into any trouble. + */ + pDevice->retain(); + VBOXUSB_UNLOCK(); + + IOReturn irc = pDevice->ReEnumerateDevice(0); NOREF(irc); + Log(("VBoxUSBDevice::scheduleReleaseByOwner: %p {%s} - ReEnumerateDevice -> %#x\n", + pDevice, pDevice->getName(), irc)); + + pDevice->release(); + VBOXUSB_LOCK(); + break; + } + } + } + } + } while (pCur); + + VBOXUSB_UNLOCK(); +} + + +#ifdef DEBUG +/*static*/ IOReturn +org_virtualbox_VBoxUSBDevice::MyInterestHandler(void *pvTarget, void *pvRefCon, UInt32 enmMsgType, + IOService *pProvider, void * pvMsgArg, vm_size_t cbMsgArg) +{ + org_virtualbox_VBoxUSBDevice *pThis = (org_virtualbox_VBoxUSBDevice *)pvTarget; + if (!pThis) + return kIOReturnError; + + switch (enmMsgType) + { + case kIOMessageServiceIsAttemptingOpen: + /* pvMsgArg == the open() fOptions, so we could check for kIOServiceSeize if we care. + We'll also get a kIIOServiceRequestingClose message() for that... */ + Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceIsAttemptingOpen - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n", + pvRefCon, pProvider, pvMsgArg, cbMsgArg)); + break; + + case kIOMessageServiceWasClosed: + Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceWasClosed - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n", + pvRefCon, pProvider, pvMsgArg, cbMsgArg)); + break; + + case kIOMessageServiceIsTerminated: + Log(("VBoxUSBDevice::MyInterestHandler: kIOMessageServiceIsTerminated - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n", + pvRefCon, pProvider, pvMsgArg, cbMsgArg)); + break; + + case kIOUSBMessagePortHasBeenReset: + Log(("VBoxUSBDevice::MyInterestHandler: kIOUSBMessagePortHasBeenReset - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n", + pvRefCon, pProvider, pvMsgArg, cbMsgArg)); + break; + + default: + Log(("VBoxUSBDevice::MyInterestHandler: %#x (%s) - pvRefCon=%p pProvider=%p pvMsgArg=%p cbMsgArg=%d\n", + enmMsgType, DbgGetIOKitMessageName(enmMsgType), pvRefCon, pProvider, pvMsgArg, cbMsgArg)); + break; + } + + return kIOReturnSuccess; +} +#endif /* DEBUG */ + + + + + + + + + + + + + + +/* + * + * org_virtualbox_VBoxUSBInterface + * + */ + +/** + * Initialize our data members. + */ +bool +org_virtualbox_VBoxUSBInterface::init(OSDictionary *pDictionary) +{ + uint32_t cInstances = ASMAtomicIncU32(&g_cInstances); + Log(("VBoxUSBInterface::init([%p], %p) new g_cInstances=%d\n", this, pDictionary, cInstances)); + RT_NOREF_PV(cInstances); + + m_pInterface = NULL; + m_fOpen = false; + m_fOpenOnWasClosed = false; + + return IOUSBUserClientInit::init(pDictionary); +} + + +/** + * Free the object. + * @remark Only for logging. + */ +void +org_virtualbox_VBoxUSBInterface::free() +{ + uint32_t cInstances = ASMAtomicDecU32(&g_cInstances); NOREF(cInstances); + Log(("VBoxUSBInterfaces::free([%p]) new g_cInstances=%d\n", this, cInstances)); + IOUSBUserClientInit::free(); +} + + +/** + * Probe the interface to see if we're the right driver for it. + * + * We implement this similarly to org_virtualbox_VBoxUSBDevice, except that + * we don't bother matching filters but instead just check if the parent is + * handled by org_virtualbox_VBoxUSBDevice or not. + */ +IOService * +org_virtualbox_VBoxUSBInterface::probe(IOService *pProvider, SInt32 *pi32Score) +{ + Log(("VBoxUSBInterface::probe([%p], %p {%s}, %p={%d})\n", this, + pProvider, pProvider->getName(), pi32Score, pi32Score ? *pi32Score : 0)); + + /* + * Check if VBoxUSBDevice is the parent's driver. + */ + bool fHijackIt = false; + const IORegistryPlane *pServicePlane = getPlane(kIOServicePlane); + IORegistryEntry *pParent = pProvider->getParentEntry(pServicePlane); + if (pParent) + { + Log(("VBoxUSBInterface::probe: pParent=%p {%s}\n", pParent, pParent->getName())); + + OSIterator *pSiblings = pParent->getChildIterator(pServicePlane); + if (pSiblings) + { + IORegistryEntry *pSibling; + while ( (pSibling = OSDynamicCast(IORegistryEntry, pSiblings->getNextObject())) ) + { + const OSMetaClass *pMetaClass = pSibling->getMetaClass(); + Log2(("sibling: %p - %s - %s\n", pMetaClass, pSibling->getName(), pMetaClass->getClassName())); + if (pMetaClass == &org_virtualbox_VBoxUSBDevice::gMetaClass) + { + fHijackIt = true; + break; + } + } + pSiblings->release(); + } + } + if (!fHijackIt) + { + Log(("VBoxUSBInterface::probe: returns NULL\n")); + return NULL; + } + + /* IOService *pRet = IOUSBUserClientInit::probe(pProvider, pi32Score); - call always returns NULL on 10.11+ */ + IOService *pRet = this; + *pi32Score = _1G; + Log(("VBoxUSBInterface::probe: returns %p and *pi32Score=%d - hijack it.\n", pRet, *pi32Score)); + return pRet; +} + + +/** + * Start the driver (this), retain and open the USB interface object (pProvider). + */ +bool +org_virtualbox_VBoxUSBInterface::start(IOService *pProvider) +{ + Log(("VBoxUSBInterface::start([%p], %p {%s})\n", this, pProvider, pProvider->getName())); + + /* + * Exploit IOUSBUserClientInit to process IOProviderMergeProperties. + */ + IOUSBUserClientInit::start(pProvider); /* returns false */ + + /* + * Retain the and open the interface (stop() or message() cleans up). + */ + bool fRc = true; + m_pInterface = OSDynamicCast(IOUSBInterface, pProvider); + if (m_pInterface) + { + m_pInterface->retain(); + m_fOpen = m_pInterface->open(this, kIOServiceSeize, 0); + if (!m_fOpen) + Log(("VBoxUSBInterface::start: failed to open the interface!\n")); + m_fOpenOnWasClosed = !m_fOpen; + } + else + { + printf("VBoxUSBInterface::start([%p], %p {%s}): failed!\n", this, pProvider, pProvider->getName()); + fRc = false; + } + + Log(("VBoxUSBInterface::start: returns %d\n", fRc)); + return fRc; +} + + +/** + * Close and release the USB interface object (pProvider) and stop the driver (this). + */ +void +org_virtualbox_VBoxUSBInterface::stop(IOService *pProvider) +{ + Log(("org_virtualbox_VBoxUSBInterface::stop([%p], %p {%s})\n", this, pProvider, pProvider->getName())); + + /* + * Close and release the IOUSBInterface if didn't do that already in message(). + */ + if (m_pInterface) + { + /* close it */ + if (m_fOpen) + { + m_fOpenOnWasClosed = false; + m_fOpen = false; + m_pInterface->close(this, 0); + } + + /* release it (see start()) */ + m_pInterface->release(); + m_pInterface = NULL; + } + + IOUSBUserClientInit::stop(pProvider); + Log(("VBoxUSBInterface::stop: returns void\n")); +} + + +/** + * Terminate the service (initiate the destruction). + * @remark Only for logging. + */ +bool +org_virtualbox_VBoxUSBInterface::terminate(IOOptionBits fOptions) +{ + /* kIOServiceRecursing, kIOServiceRequired, kIOServiceTerminate, kIOServiceSynchronous - interesting option bits */ + Log(("VBoxUSBInterface::terminate([%p], %#x)\n", this, fOptions)); + return IOUSBUserClientInit::terminate(fOptions); +} + + +/** + * @copydoc org_virtualbox_VBoxUSBDevice::message + */ +IOReturn +org_virtualbox_VBoxUSBInterface::message(UInt32 enmMsg, IOService *pProvider, void *pvArg) +{ + Log(("VBoxUSBInterface::message([%p], %#x {%s}, %p {%s}, %p)\n", + this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg)); + + IOReturn irc; + switch (enmMsg) + { + /* + * See explanation in org_virtualbox_VBoxUSBDevice::message. + */ + case kIOMessageServiceIsRequestingClose: + irc = kIOReturnExclusiveAccess; + if (!((uintptr_t)pvArg & kIOServiceSeize)) + { + Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d: not seize - closing...\n", + this, pProvider, pProvider->getName(), pvArg, RTProcSelf())); + m_fOpen = false; + m_fOpenOnWasClosed = false; + if (m_pInterface) + m_pInterface->close(this, 0); + irc = kIOReturnSuccess; + } + else + { + if (org_virtualbox_VBoxUSBClient::isClientTask(current_task())) + { + Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d task=%p: client process, closing.\n", + this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task())); + m_fOpen = false; + m_fOpenOnWasClosed = false; + if (m_pInterface) + m_pInterface->close(this, 0); + m_fOpenOnWasClosed = true; + irc = kIOReturnSuccess; + } + else + Log(("VBoxUSBInterface::message([%p],%p {%s}, %p) - pid=%d task=%p: not client process!\n", + this, pProvider, pProvider->getName(), pvArg, RTProcSelf(), current_task())); + } + break; + + /* + * The service was closed by the current client, check for re-open. + */ + case kIOMessageServiceWasClosed: + if (m_pInterface && m_fOpenOnWasClosed) + { + Log(("VBoxUSBInterface::message: attempting to re-open the interface...\n")); + m_fOpenOnWasClosed = false; + m_fOpen = m_pInterface->open(this, kIOServiceSeize, 0); + if (!m_fOpen) + Log(("VBoxUSBInterface::message: failed to open the interface!\n")); + m_fOpenOnWasClosed = !m_fOpen; + } + + irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg); + break; + + /* + * The IOUSBInterface/Device is shutting down, so close and release. + */ + case kIOMessageServiceIsTerminated: + if (m_pInterface) + { + /* close it */ + if (m_fOpen) + { + m_fOpen = false; + m_fOpenOnWasClosed = false; + m_pInterface->close(this, 0); + } + + /* release it (see start()) */ + m_pInterface->release(); + m_pInterface = NULL; + } + + irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg); + break; + + default: + irc = IOUSBUserClientInit::message(enmMsg, pProvider, pvArg); + break; + } + + Log(("VBoxUSBInterface::message([%p], %#x {%s}, %p {%s}, %p) -> %#x\n", + this, enmMsg, DbgGetIOKitMessageName(enmMsg), pProvider, pProvider->getName(), pvArg, irc)); + return irc; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/VBoxUSBInterface.h b/src/VBox/HostDrivers/VBoxUSB/darwin/VBoxUSBInterface.h new file mode 100644 index 00000000..362189b7 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/VBoxUSBInterface.h @@ -0,0 +1,65 @@ +/** $Id: VBoxUSBInterface.h $ */ +/** @file + * VirtualBox USB Driver User<->Kernel Interface. + */ + +/* + * Copyright (C) 2007-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_darwin_VBoxUSBInterface_h +#define VBOX_INCLUDED_SRC_VBoxUSB_darwin_VBoxUSBInterface_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include <VBox/usbfilter.h> + +/** + * org_virtualbox_VBoxUSBClient method indexes. + */ +typedef enum VBOXUSBMETHOD +{ + /** org_virtualbox_VBoxUSBClient::addFilter */ + VBOXUSBMETHOD_ADD_FILTER = 0, + /** org_virtualbox_VBoxUSBClient::removeFilter */ + VBOXUSBMETHOD_REMOVE_FILTER, + /** End/max. */ + VBOXUSBMETHOD_END +} VBOXUSBMETHOD; + +/** + * Output from a VBOXUSBMETHOD_ADD_FILTER call. + */ +typedef struct VBOXUSBADDFILTEROUT +{ + /** The ID. */ + uintptr_t uId; + /** The return code. */ + int rc; +} VBOXUSBADDFILTEROUT; +/** Pointer to a VBOXUSBADDFILTEROUT. */ +typedef VBOXUSBADDFILTEROUT *PVBOXUSBADDFILTEROUT; + +/** Cookie used to fend off some unwanted clients to the IOService. */ +#define VBOXUSB_DARWIN_IOSERVICE_COOKIE UINT32_C(0x62735556) /* 'VUsb' */ + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_darwin_VBoxUSBInterface_h */ + diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/loadusb.sh b/src/VBox/HostDrivers/VBoxUSB/darwin/loadusb.sh new file mode 100755 index 00000000..972ff6ad --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/loadusb.sh @@ -0,0 +1,123 @@ +#!/bin/bash +## @file +# For development. +# + +# +# Copyright (C) 2006-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# +# The contents of this file may alternatively be used under the terms +# of the Common Development and Distribution License Version 1.0 +# (CDDL) only, as it comes in the "COPYING.CDDL" file of the +# VirtualBox OSE distribution, in which case the provisions of the +# CDDL are applicable instead of those of the GPL. +# +# You may elect to license modified versions of this file under the +# terms and conditions of either the GPL or the CDDL or both. +# + +SCRIPT_NAME="loadusb" +XNU_VERSION=`LC_ALL=C uname -r | LC_ALL=C cut -d . -f 1` + +DRVNAME="VBoxUSB.kext" +BUNDLE="org.virtualbox.kext.VBoxUSB" + +DEP_DRVNAME="VBoxDrv.kext" +DEP_BUNDLE="org.virtualbox.kext.VBoxDrv" + + +DIR=`dirname "$0"` +DIR=`cd "$DIR" && pwd` +DEP_DIR="$DIR/$DEP_DRVNAME" +DIR="$DIR/$DRVNAME" +if [ ! -d "$DIR" ]; then + echo "Cannot find $DIR or it's not a directory..." + exit 1; +fi +if [ ! -d "$DEP_DIR" ]; then + echo "Cannot find $DEP_DIR or it's not a directory... (dependency)" + exit 1; +fi +if [ -n "$*" ]; then + OPTS="$*" +else + OPTS="-t" +fi + +trap "sudo chown -R `whoami` $DIR $DEP_DIR; exit 1" INT + +# Try unload any existing instance first. +LOADED=`kextstat -b $BUNDLE -l` +if test -n "$LOADED"; then + echo "${SCRIPT_NAME}.sh: Unloading $BUNDLE..." + sudo kextunload -v 6 -b $BUNDLE + LOADED=`kextstat -b $BUNDLE -l` + if test -n "$LOADED"; then + echo "${SCRIPT_NAME}.sh: failed to unload $BUNDLE, see above..." + exit 1; + fi + echo "${SCRIPT_NAME}.sh: Successfully unloaded $BUNDLE" +fi + +set -e + +# Copy the .kext to the symbols directory and tweak the kextload options. +if test -n "$VBOX_DARWIN_SYMS"; then + echo "${SCRIPT_NAME}.sh: copying the extension the symbol area..." + rm -Rf "$VBOX_DARWIN_SYMS/$DRVNAME" + mkdir -p "$VBOX_DARWIN_SYMS" + cp -R "$DIR" "$VBOX_DARWIN_SYMS/" + OPTS="$OPTS -s $VBOX_DARWIN_SYMS/ " + sync +fi + +# On smbfs, this might succeed just fine but make no actual changes, +# so we might have to temporarily copy the driver to a local directory. +if sudo chown -R root:wheel "$DIR" "$DEP_DIR"; then + OWNER=`/usr/bin/stat -f "%u" "$DIR"` +else + OWNER=1000 +fi +if test "$OWNER" -ne 0; then + TMP_DIR=/tmp/${SCRIPT_NAME}.tmp + echo "${SCRIPT_NAME}.sh: chown didn't work on $DIR, using temp location $TMP_DIR/$DRVNAME" + + # clean up first (no sudo rm) + if test -e "$TMP_DIR"; then + sudo chown -R `whoami` "$TMP_DIR" + rm -Rf "$TMP_DIR" + fi + + # make a copy and switch over DIR + mkdir -p "$TMP_DIR/" + sudo cp -Rp "$DIR" "$TMP_DIR/" + DIR="$TMP_DIR/$DRVNAME" + + # load.sh puts it here. + DEP_DIR="/tmp/loaddrv.tmp/$DEP_DRVNAME" + + # retry + sudo chown -R root:wheel "$DIR" "$DEP_DIR" +fi + +sudo chmod -R o-rwx "$DIR" +sync +if [ "$XNU_VERSION" -ge "10" ]; then + echo "${SCRIPT_NAME}.sh: loading $DIR... (kextutil $OPTS -d \"$DEP_DIR\" \"$DIR\")" + sudo kextutil $OPTS -d "$DEP_DIR" "$DIR" +else + echo "${SCRIPT_NAME}.sh: loading $DIR... (kextload $OPTS -d \"$DEP_DIR\" \"$DIR\")" + sudo kextload $OPTS -d "$DEP_DIR" "$DIR" +fi +sync +sudo chown -R `whoami` "$DIR" "$DEP_DIR" +kextstat | grep org.virtualbox.kext + diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/testcase/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/darwin/testcase/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/testcase/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/darwin/testcase/tstOpenUSBDev.cpp b/src/VBox/HostDrivers/VBoxUSB/darwin/testcase/tstOpenUSBDev.cpp new file mode 100644 index 00000000..3eec565b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/darwin/testcase/tstOpenUSBDev.cpp @@ -0,0 +1,295 @@ +/* $Id: tstOpenUSBDev.cpp $ */ +/** @file + * Testcase that attempts to locate and open the specified device. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <mach/mach.h> +#include <Carbon/Carbon.h> +#include <IOKit/IOKitLib.h> +#include <IOKit/storage/IOStorageDeviceCharacteristics.h> +#include <IOKit/scsi/SCSITaskLib.h> +#include <mach/mach_error.h> +#include <IOKit/usb/IOUSBLib.h> +#include <IOKit/IOCFPlugIn.h> + +#include <iprt/err.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/process.h> +#include <iprt/assert.h> +#include <iprt/thread.h> +#include <iprt/getopt.h> +#include <iprt/initterm.h> +#include <iprt/stream.h> + + +/** + * Gets an unsigned 32-bit integer value. + * + * @returns Success indicator (true/false). + * @param DictRef The dictionary. + * @param KeyStrRef The key name. + * @param pu32 Where to store the key value. + */ +static bool tstDictGetU32(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint32_t *pu32) +{ + CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef); + if (ValRef) + { + if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt32Type, pu32)) + return true; + } + *pu32 = 0; + return false; +} + + +/** + * Gets an unsigned 64-bit integer value. + * + * @returns Success indicator (true/false). + * @param DictRef The dictionary. + * @param KeyStrRef The key name. + * @param pu64 Where to store the key value. + */ +static bool tstDictGetU64(CFMutableDictionaryRef DictRef, CFStringRef KeyStrRef, uint64_t *pu64) +{ + CFTypeRef ValRef = CFDictionaryGetValue(DictRef, KeyStrRef); + if (ValRef) + { + if (CFNumberGetValue((CFNumberRef)ValRef, kCFNumberSInt64Type, pu64)) + return true; + } + *pu64 = 0; + return false; +} + + +static int tstDoWork(io_object_t USBDevice, const char *argv0) +{ + /* + * Create a plugin interface for the device and query its IOUSBDeviceInterface. + */ + int vrc = VINF_SUCCESS; + SInt32 Score = 0; + IOCFPlugInInterface **ppPlugInInterface = NULL; + IOReturn irc = IOCreatePlugInInterfaceForService(USBDevice, kIOUSBDeviceUserClientTypeID, + kIOCFPlugInInterfaceID, &ppPlugInInterface, &Score); + if (irc == kIOReturnSuccess) + { + IOUSBDeviceInterface245 **ppDevI = NULL; + HRESULT hrc = (*ppPlugInInterface)->QueryInterface(ppPlugInInterface, + CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID245), + (LPVOID *)&ppDevI); + irc = IODestroyPlugInInterface(ppPlugInInterface); Assert(irc == kIOReturnSuccess); + ppPlugInInterface = NULL; + if (hrc == S_OK) + { + /* + * Try open the device for exclusive access. + */ + irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI); + if (irc == kIOReturnExclusiveAccess) + { + RTThreadSleep(20); + irc = (*ppDevI)->USBDeviceOpenSeize(ppDevI); + } + if (irc == kIOReturnSuccess) + { +#if 0 + /* + * Re-enumerate the device and bail out. + */ + irc = (*ppDevI)->USBDeviceReEnumerate(ppDevI, 0); + if (irc != kIOReturnSuccess) + { + vrc = RTErrConvertFromDarwinIO(irc); + RTPrintf("%s: Failed to re-enumerate the device, irc=%#x (vrc=%Rrc).\n", argv0, irc, vrc); + } +#endif + + (*ppDevI)->USBDeviceClose(ppDevI); + } + else if (irc == kIOReturnExclusiveAccess) + { + vrc = VERR_SHARING_VIOLATION; + RTPrintf("%s: The device is being used by another process (irc=kIOReturnExclusiveAccess)\n", argv0); + } + else + { + vrc = VERR_OPEN_FAILED; + RTPrintf("%s: Failed to open the device, irc=%#x (vrc=%Rrc).\n", argv0, irc, vrc); + } + } + else + { + vrc = VERR_OPEN_FAILED; + RTPrintf("%s: Failed to create plugin interface for the device, hrc=%#x (vrc=%Rrc).\n", argv0, hrc, vrc); + } + + (*ppDevI)->Release(ppDevI); + } + else + { + vrc = RTErrConvertFromDarwinIO(irc); + RTPrintf("%s: Failed to open the device, plug-in creation failed with irc=%#x (vrc=%Rrc).\n", argv0, irc, vrc); + } + + return vrc; +} + + +static int tstSyntax(const char *argv0) +{ + RTPrintf("syntax: %s [criteria]\n" + "\n" + "Criteria:\n" + " -l <location>\n" + " -s <session>\n" + , argv0); + return 1; +} + + +int main(int argc, char **argv) +{ + RTR3InitExe(argc, &argv, 0); + + /* + * Show help if not arguments. + */ + if (argc <= 1) + return tstSyntax(argv[0]); + + /* + * Parse arguments. + */ + static const RTGETOPTDEF g_aOptions[] = + { + { "--location", 'l', RTGETOPT_REQ_UINT32 }, + { "--session", 's', RTGETOPT_REQ_UINT64 }, + }; + + kern_return_t krc; + uint64_t u64SessionId = 0; + uint32_t u32LocationId = 0; + + int ch; + RTGETOPTUNION ValueUnion; + RTGETOPTSTATE GetState; + RTGetOptInit(&GetState, argc, argv, g_aOptions, RT_ELEMENTS(g_aOptions), 1, 0 /* fFlags */); + while ((ch = RTGetOpt(&GetState, &ValueUnion))) + { + switch (ch) + { + case 'l': + u32LocationId = ValueUnion.u32; + break; + case 's': + u64SessionId = ValueUnion.u64; + break; + case 'h': + return tstSyntax(argv[0]); + case 'V': + RTPrintf("$Revision: 127855 $\n"); + return 0; + + default: + return RTGetOptPrintError(ch, &ValueUnion); + } + } + + /* + * Open the master port. + */ + mach_port_t MasterPort = MACH_PORT_NULL; + krc = IOMasterPort(MACH_PORT_NULL, &MasterPort); + if (krc != KERN_SUCCESS) + { + RTPrintf("%s: IOMasterPort -> %x\n", argv[0], krc); + return 1; + } + + /* + * Iterate the USB devices and find all that matches. + */ + CFMutableDictionaryRef RefMatchingDict = IOServiceMatching(kIOUSBDeviceClassName); + if (!RefMatchingDict) + { + RTPrintf("%s: IOServiceMatching failed\n", argv[0]); + return 1; + } + + io_iterator_t USBDevices = IO_OBJECT_NULL; + IOReturn irc = IOServiceGetMatchingServices(MasterPort, RefMatchingDict, &USBDevices); + if (irc != kIOReturnSuccess) + { + RTPrintf("%s: IOServiceGetMatchingServices -> %#x\n", argv[0], irc); + return 1; + } + RefMatchingDict = NULL; /* the reference is consumed by IOServiceGetMatchingServices. */ + + unsigned cDevices = 0; + unsigned cMatches = 0; + io_object_t USBDevice; + while ((USBDevice = IOIteratorNext(USBDevices))) + { + cDevices++; + CFMutableDictionaryRef PropsRef = 0; + krc = IORegistryEntryCreateCFProperties(USBDevice, &PropsRef, kCFAllocatorDefault, kNilOptions); + if (krc == KERN_SUCCESS) + { + uint64_t u64CurSessionId; + uint32_t u32CurLocationId; + if ( ( !u64SessionId + || ( tstDictGetU64(PropsRef, CFSTR("sessionID"), &u64CurSessionId) + && u64CurSessionId == u64SessionId)) + && ( !u32LocationId + || ( tstDictGetU32(PropsRef, CFSTR(kUSBDevicePropertyLocationID), &u32CurLocationId) + && u32CurLocationId == u32LocationId)) + ) + { + cMatches++; + CFRelease(PropsRef); + tstDoWork(USBDevice, argv[0]); + } + else + CFRelease(PropsRef); + } + IOObjectRelease(USBDevice); + } + IOObjectRelease(USBDevices); + + /* + * Bitch if we didn't find anything matching the criteria. + */ + if (!cMatches) + RTPrintf("%s: No matching devices found from a total of %d.\n", argv[0], cDevices); + return !cMatches; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/os2/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/os2/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/os2/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.c b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.c new file mode 100644 index 00000000..5950cc6f --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.c @@ -0,0 +1,1278 @@ +#define INCL_DOSERRORS +#define INCL_DOSMEMMGR +#define INCL_DOSSEMAPHORES +#define INCL_DOSDEVICES +#define INCL_DOSDEVIOCTL +#define INCL_DOSMODULEMGR +#include <os2.h> + +#if !defined(__GNUC__) || defined(STATIC_USBCALLS) +#include <string.h> +#else +#define memcpy __builtin_memcpy +#endif +#include <stdlib.h> +#include <stdio.h> + +#define LOG_GROUP LOG_GROUP_DRV_USBPROXY +#include <VBox/log.h> + +#ifdef __GNUC__ +# define APIEXPORT __declspec(dllexport) +#else +# define APIEXPORT +#endif + +#ifndef ERROR_USER_DEFINED_BASE +/*#define ERROR_USER_DEFINED_BASE 0xFF00 */ + +#define ERROR_I24_WRITE_PROTECT 0 +#define ERROR_I24_BAD_UNIT 1 +#define ERROR_I24_NOT_READY 2 +#define ERROR_I24_BAD_COMMAND 3 +#define ERROR_I24_CRC 4 +#define ERROR_I24_BAD_LENGTH 5 +#define ERROR_I24_SEEK 6 +#define ERROR_I24_NOT_DOS_DISK 7 +#define ERROR_I24_SECTOR_NOT_FOUND 8 +#define ERROR_I24_OUT_OF_PAPER 9 +#define ERROR_I24_WRITE_FAULT 10 +#define ERROR_I24_READ_FAULT 11 +#define ERROR_I24_GEN_FAILURE 12 +#define ERROR_I24_DISK_CHANGE 13 +#define ERROR_I24_WRONG_DISK 15 +#define ERROR_I24_UNCERTAIN_MEDIA 16 +#define ERROR_I24_CHAR_CALL_INTERRUPTED 17 +#define ERROR_I24_NO_MONITOR_SUPPORT 18 +#define ERROR_I24_INVALID_PARAMETER 19 +#define ERROR_I24_DEVICE_IN_USE 20 +#define ERROR_I24_QUIET_INIT_FAIL 21 +#endif + +#include "usbcalls.h" + +#define IOCAT_USBRES 0x000000A0 /* USB Resource device control */ +#define IOCTLF_NUMDEVICE 0x00000031 /* Get Number of plugged in Devices */ +#define IOCTLF_GETINFO 0x00000032 /* Get Info About a device */ +#define IOCTLF_AQUIREDEVICE 0x00000033 +#define IOCTLF_RELEASEDEVICE 0x00000034 +#define IOCTLF_GETSTRING 0x00000035 +#define IOCTLF_SENDCONTROLURB 0x00000036 +#define IOCTLF_SENDBULKURB 0x00000037 /* Send */ +#define IOCTLF_START_IRQ_PROC 0x00000038 /* Start IRQ polling in a buffer */ +#define IOCTLF_GETDEVINFO 0x00000039 /* Get information about device */ +#define IOCTLF_STOP_IRQ_PROC 0x0000003A /* Stop IRQ Polling */ +#define IOCTLF_START_ISO_PROC 0x0000003B /* Start ISO buffering in a Ringbuffer */ +#define IOCTLF_STOP_ISO_PROC 0x0000003C /* Stop ISO buffering */ +#define IOCTLF_CANCEL_IORB 0x0000003D /* Abort an IORB; */ +#define IOCTLF_SELECT_BULKPIPE 0x0000003E /* Select which Bulk endpoints can be used via Read/Write */ +#define IOCTLF_SENDIRQURB 0x0000003F /* Start IRQ polling in a buffer */ +#define IOCTLF_FIXUPDEVUCE 0x00000040 /* Fixup USB device configuration data */ +#define IOCTLF_REG_STATUSSEM 0x00000041 /* Register Semaphore for general Statuschange */ +#define IOCTLF_DEREG_STATUSSEM 0x00000042 /* Deregister Semaphore */ +#define IOCTLF_REG_DEVICESEM 0x00000043 /* Register Semaphore for a vendor&deviceID */ +#define IOCTLF_DEREG_DEVICESEM 0x00000044 /* Deregister Semaphore */ + + +#define NOTIFY_FREE 0 +#define NOTIFY_CHANGE 1 +#define NOTIFY_DEVICE 2 +#define MAX_NOTIFICATIONS 256 + +#pragma pack(1) + +typedef struct +{ + HEV hDeviceAdded; + HEV hDeviceRemoved; + USHORT usFlags; + USHORT usVendor; + USHORT usProduct; + USHORT usBCDDevice; +} NOTIFYENTRY, *PNOTIFYENTRY; + +#define DEV_SEM_ADD 0x00000001 +#define DEV_SEM_REMOVE 0x00000002 +#define DEV_SEM_MASK 0x00000003 +#define DEV_SEM_VENDORID 0x00000004 +#define DEV_SEM_PRODUCTID 0x00000008 +#define DEV_SEM_BCDDEVICE 0x00000010 + +typedef struct{ + ULONG ulSize; + ULONG ulCaps; + ULONG ulSemDeviceAdd; + ULONG ulSemDeviceRemove; +} STATUSEVENTSET, * PSTATUSEVENTSET; + + +typedef struct{ + ULONG ulSize; + ULONG ulCaps; + ULONG ulSemDeviceAdd; + ULONG ulSemDeviceRemove; + USHORT usVendorID; + USHORT usProductID; + USHORT usBCDDevice; + USHORT usStatus; +} DEVEVENTSET, * PDEVEVENTSET; + +typedef struct +{ + USHORT usVendorID; + USHORT usProductID; + USHORT usBCDDevice; + USHORT usDeviceNumber; /* Get the usDeviceNumber device in the system fi. if 2 acquire the 2nd device + 0 means first not acquired device. */ +} AQUIREDEV, *PAQUIREDEV; + +typedef struct +{ + UCHAR bRequestType; + UCHAR bRequest; + USHORT wValue; + USHORT wIndex; + USHORT wLength; + ULONG ulTimeout; /* in milliseconds */ +} SETUPPACKET, *PSETUPPACKET; + +typedef struct +{ + ULONG ulHandle; + UCHAR bRequestType; + UCHAR bRequest; + USHORT wValue; + USHORT wIndex; + USHORT wLength; + ULONG ulTimeout; /* in milliseconds */ + USHORT usStatus; +} USBCALLS_CTRL_REQ, *PUSBCALLS_CTRL_REQ; + +typedef struct +{ + ULONG ulDevHandle; + UCHAR ucEndpoint; + UCHAR ucAltInterface; + USHORT usStatus; + ULONG ulEvent; + ULONG ulID; +} USBCALLS_ISO_START, *NPUSBCALLS_ISO_START, FAR *PUSBCALLS_ISO_START, + USBCALLS_IRQ_START, *NPUSBCALLS_IRQ_START, FAR *PUSBCALLS_IRQ_START, + USBCALLS_CANCEL_REQ, *NPUSBCALLS_CANCEL_REQ, FAR *PUSBCALLS_CANCEL_REQ; + +#define ISO_DIRMASK 0x80 +typedef struct +{ + ULONG hSemAccess; /* Synchronise access to the Pos values */ + ULONG hDevice; + USHORT usPosWrite; + USHORT usPosRead; + USHORT usBufSize; + UCHAR ucEndpoint; + UCHAR ucAltInterface; + UCHAR ucBuffer[16*1023]; +} ISORINGBUFFER, *PISORINGBUFFER; + +typedef USBCALLS_ISO_START USBCALLS_ISO_STOP, * NPUSBCALLS_ISO_STOP, FAR *PUSBCALLS_ISO_STOP; +typedef USBCALLS_ISO_START USBCALLS_IRQ_STOP, * NPUSBCALLS_IRQ_STOP, FAR *PUSBCALLS_IRQ_STOP; + +#define USB_TRANSFER_FULL_SIZE 0x01 + +typedef struct +{ + ULONG ulDevHandle; + UCHAR ucEndpoint; + UCHAR ucAltInterface; + USHORT usStatus; + ULONG ulEvent; +/* ULONG ulID; - yeah, right */ + ULONG ulTimeout; + USHORT usDataProcessed; + USHORT usDataRemain; + USHORT usFlags; +} USBCALLS_BULK_REQ, *PUSBCALLS_BULK_REQ; + +typedef struct +{ + ULONG ulDevHandle; + UCHAR ucEndpoint; + UCHAR ucAltInterface; + USHORT usStatus; + ULONG ulEvent; + ULONG ulID; + ULONG ulTimeout; + USHORT usDataLen; +} LIBUSB_IRQ_REQ, *NPLIBUSB_IRQ_REQ, FAR *PLIBUSB_IRQ_REQ; + +typedef struct +{ + ULONG ulDevHandle; + UCHAR ucConfiguration; + UCHAR ucAltInterface; + USHORT usStatus; +} LIBUSB_FIXUP, *NPLIBUSB_FIXUP, FAR *PLIBUSB_FIXUP; + +#pragma pack() + +/******************************************************************************/ + +HFILE g_hUSBDrv; +ULONG g_cInit; +ULONG g_ulFreeNotifys; +HMTX g_hSemNotifytable; +NOTIFYENTRY g_Notifications[MAX_NOTIFICATIONS]; + +HMTX g_hSemRingBuffers; +PISORINGBUFFER g_pIsoRingBuffers; +ULONG g_ulNumIsoRingBuffers; + +APIEXPORT APIRET APIENTRY +InitUsbCalls(void) +{ + int i; + ULONG ulAction; + APIRET rc; + + if (++g_cInit > 1) + return NO_ERROR; + + rc = DosOpen( (PCSZ)"USBRESM$", + &g_hUSBDrv, + &ulAction, + 0, + FILE_NORMAL, + OPEN_ACTION_OPEN_IF_EXISTS, + OPEN_ACCESS_READWRITE | + OPEN_FLAGS_NOINHERIT | + OPEN_SHARE_DENYNONE, + 0 ); + if(rc) + { + g_hUSBDrv = 0; + g_cInit = 0; + + } + else + { + /* @@ToDO Add EnvVar or INI for dynamically setting the number */ + g_ulNumIsoRingBuffers = 8; + for(i=0;i<MAX_NOTIFICATIONS;i++) + { + g_Notifications[i].usFlags = NOTIFY_FREE; + g_Notifications[i].hDeviceAdded = 0; + g_Notifications[i].hDeviceRemoved = 0; + g_Notifications[i].usVendor = 0; + g_Notifications[i].usProduct = 0; + g_Notifications[i].usBCDDevice = 0; + } + rc = DosAllocMem( (PPVOID)&g_pIsoRingBuffers, + g_ulNumIsoRingBuffers * sizeof(ISORINGBUFFER), + PAG_WRITE | PAG_COMMIT | OBJ_TILE); + if(!rc) + { + PISORINGBUFFER pIter = g_pIsoRingBuffers; + for(i=0;i< g_ulNumIsoRingBuffers;i++,pIter++) + { + pIter->hDevice = 0; + pIter->hSemAccess = 0; /* Synchronise access to the Pos values */ + pIter->usPosWrite = 0; + pIter->usPosRead = 0; + pIter->usBufSize = 16*1023; + pIter->ucEndpoint = 0; + pIter->ucAltInterface = 0; + /*pIter->ucBuffer */ + } + rc=DosCreateMutexSem(NULL,&g_hSemRingBuffers,DC_SEM_SHARED,FALSE); + if(!rc) + { + rc=DosCreateMutexSem(NULL,&g_hSemNotifytable,DC_SEM_SHARED,FALSE); + if(rc) + { + DosCloseMutexSem(g_hSemRingBuffers); + DosFreeMem(g_pIsoRingBuffers); + } + } + else + { + DosFreeMem(g_pIsoRingBuffers); + } + } + + if(rc) + { + DosClose(g_hUSBDrv); + g_hUSBDrv = 0; + g_cInit = 0; + } + } + return g_cInit ? NO_ERROR : rc ? rc : ERROR_GEN_FAILURE; +} + +APIEXPORT APIRET APIENTRY +TermUsbCalls(void) +{ + if (!g_cInit) + return ERROR_GEN_FAILURE; + if(!--g_cInit) + { + int i; + for(i=0;i<MAX_NOTIFICATIONS;i++) + if( g_Notifications[i].usFlags != NOTIFY_FREE); + UsbDeregisterNotification((USBNOTIFY)(&g_Notifications[i])); + + DosClose(g_hUSBDrv); + g_hUSBDrv = NULLHANDLE; + + if (g_pIsoRingBuffers) + DosFreeMem(g_pIsoRingBuffers); + + DosCloseMutexSem(g_hSemRingBuffers); + g_hSemRingBuffers = NULLHANDLE; + DosCloseMutexSem(g_hSemNotifytable); + g_hSemNotifytable = NULLHANDLE; + } + return NO_ERROR; +} + + +#ifdef VBOX /* complete wast of time */ +# define IsBadReadPointer(pBase, ulSize) (FALSE) +# define IsBadWritePointer(pBase, ulSize) (FALSE) +#else +static BOOL IsBadReadPointer(PVOID pBase, ULONG ulSize) +{ + APIRET rc; + ULONG ulFlags; + rc = DosQueryMem(pBase, &ulSize, &ulFlags); + + return rc!=0?TRUE:(ulFlags&PAG_READ)&&(ulFlags&PAG_COMMIT)?FALSE:TRUE; +} + +static BOOL IsBadWritePointer(PVOID pBase, ULONG ulSize) +{ + APIRET rc; + ULONG ulFlags; + rc = DosQueryMem(pBase, &ulSize, &ulFlags); + + return rc!=0?TRUE:((ulFlags&PAG_WRITE)==PAG_WRITE&&(ulFlags&PAG_COMMIT)==PAG_COMMIT)?FALSE:TRUE; +} +#endif + +APIEXPORT APIRET APIENTRY +UsbQueryNumberDevices(ULONG *pulNumDev) +{ + APIRET rc; + ULONG ulLength; + if(!g_cInit) + return USB_NOT_INIT; + + if( IsBadWritePointer(pulNumDev,sizeof(ULONG)) ) + return ERROR_INVALID_PARAMETER; + ulLength=sizeof(ULONG); + *pulNumDev = 0; + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_NUMDEVICE, + NULL, 0, NULL, + pulNumDev, ulLength, &ulLength); + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbQueryDeviceReport(ULONG ulDevNumber, ULONG *pulBufLen, PVOID pData) +{ + APIRET rc; + ULONG ulParmLen; + + if(!g_cInit) + return USB_NOT_INIT; + + if( IsBadWritePointer(pulBufLen, sizeof(ULONG)) ) + return ERROR_INVALID_PARAMETER; + + if( pData!=NULL && IsBadWritePointer(pData,*pulBufLen) ) + return ERROR_INVALID_PARAMETER; + if(pData==NULL) + *pulBufLen = 0; + ulParmLen = sizeof(ulDevNumber); + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_GETINFO, + (PVOID)&ulDevNumber, ulParmLen, &ulParmLen, + pData, *pulBufLen, pulBufLen); + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbRegisterChangeNotification( PUSBNOTIFY pNotifyID, + HEV hDeviceAdded, + HEV hDeviceRemoved) +{ + APIRET rc; + int i; + STATUSEVENTSET EventSet; + ULONG ulSize; + + if(!g_cInit) + return USB_NOT_INIT; + + if( IsBadWritePointer(pNotifyID, sizeof(ULONG)) || + (hDeviceAdded==0 && hDeviceRemoved==0) ) + return ERROR_INVALID_PARAMETER; + + ulSize = sizeof(EventSet); + EventSet.ulSize = ulSize; + EventSet.ulCaps = 0; + + if(hDeviceAdded!=0) + { + ULONG ulCnt; + rc = DosQueryEventSem(hDeviceAdded,&ulCnt); + if(rc) + return rc; + EventSet.ulCaps |= DEV_SEM_ADD; + EventSet.ulSemDeviceAdd = hDeviceAdded; + } + + if(hDeviceRemoved!=0) + { + ULONG ulCnt; + rc = DosQueryEventSem(hDeviceRemoved,&ulCnt); + if(rc) + return rc; + EventSet.ulCaps |= DEV_SEM_REMOVE; + EventSet.ulSemDeviceRemove = hDeviceRemoved; + } + + rc = DosRequestMutexSem(g_hSemNotifytable,SEM_INDEFINITE_WAIT); + if(rc) + return rc; + + for(i=0;i<MAX_NOTIFICATIONS;i++) + { + if( g_Notifications[i].usFlags == NOTIFY_FREE) + { + g_Notifications[i].usFlags = NOTIFY_CHANGE; + g_Notifications[i].hDeviceAdded = hDeviceAdded; + g_Notifications[i].hDeviceRemoved = hDeviceRemoved; + g_Notifications[i].usVendor = 0; + g_Notifications[i].usProduct = 0; + g_Notifications[i].usBCDDevice = 0; + break; + } + } + DosReleaseMutexSem(g_hSemNotifytable); + if(i==MAX_NOTIFICATIONS) + return USB_ERROR_NO_MORE_NOTIFICATIONS; + + /* @@ToDo come up with a better way to generate IDs */ + *pNotifyID = (USBNOTIFY) (&g_Notifications[i]); + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_REG_STATUSSEM, + NULL, 0, NULL, + &EventSet,ulSize, &ulSize); + if(rc) + { + g_Notifications[i].usFlags = NOTIFY_FREE; + *pNotifyID = 0; + } + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbRegisterDeviceNotification( PUSBNOTIFY pNotifyID, + HEV hDeviceAdded, + HEV hDeviceRemoved, + USHORT usVendor, + USHORT usProduct, + USHORT usBCDVersion) +{ + DEVEVENTSET EventSet; + ULONG ulCnt,ulSize; + int i; + APIRET rc; + + if(!g_cInit) + return USB_NOT_INIT; + + if( IsBadWritePointer(pNotifyID, sizeof(ULONG)) || + hDeviceAdded==0 || hDeviceRemoved==0 || + usVendor == 0 || usVendor == 0xFFFF || + usProduct == 0 || usProduct == 0xFFFF ) + return ERROR_INVALID_PARAMETER; + + + rc = DosQueryEventSem(hDeviceAdded,&ulCnt); + if(rc) + return rc; + rc = DosQueryEventSem(hDeviceRemoved,&ulCnt); + if(rc) + return rc; + + ulSize = sizeof(EventSet); + EventSet.ulSize = ulSize; + EventSet.ulCaps = DEV_SEM_ADD | DEV_SEM_REMOVE | + DEV_SEM_VENDORID | DEV_SEM_PRODUCTID | + DEV_SEM_BCDDEVICE ; + EventSet.ulSemDeviceAdd = hDeviceAdded; + EventSet.ulSemDeviceRemove = hDeviceRemoved; + EventSet.usVendorID = usVendor; + EventSet.usProductID = usProduct; + EventSet.usBCDDevice = usBCDVersion; + EventSet.usStatus = 0; + + rc = DosRequestMutexSem(g_hSemNotifytable,SEM_INDEFINITE_WAIT); + + if(rc) + return rc; + + for(i=0;i<MAX_NOTIFICATIONS;i++) + { + if( g_Notifications[i].usFlags == NOTIFY_FREE) + { + g_Notifications[i].usFlags = NOTIFY_DEVICE; + g_Notifications[i].hDeviceAdded = hDeviceAdded; + g_Notifications[i].hDeviceRemoved = hDeviceRemoved; + g_Notifications[i].usVendor = usVendor; + g_Notifications[i].usProduct = usProduct; + g_Notifications[i].usBCDDevice = usBCDVersion; + break; + } + } + DosReleaseMutexSem(g_hSemNotifytable); + if(i==MAX_NOTIFICATIONS) + return USB_ERROR_NO_MORE_NOTIFICATIONS; + + /* @@ToDo come up with a better way to generate IDs */ + *pNotifyID = (USBNOTIFY) (&g_Notifications[i]); + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_REG_DEVICESEM, + NULL, 0, NULL, + &EventSet,ulSize, &ulSize); + if(rc) + { + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) ) + rc= ERROR_INVALID_PARAMETER; + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) ) + rc= EventSet.usStatus; + + g_Notifications[i].usFlags = NOTIFY_FREE; + *pNotifyID = 0; + } + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbDeregisterNotification( USBNOTIFY NotifyID ) +{ + DEVEVENTSET EventSet; + USBNOTIFY MinID,MaxID; + ULONG Index, ulFunction, ulSize; + APIRET rc; + + if(!g_cInit) + return USB_NOT_INIT; + + MinID = (USBNOTIFY) (&g_Notifications[0]); + MaxID = (USBNOTIFY) (&g_Notifications[MAX_NOTIFICATIONS-1]); + + if(NotifyID<MinID || NotifyID>MaxID) + return ERROR_INVALID_PARAMETER; + + Index = NotifyID - MinID; + + if(Index % sizeof(NOTIFYENTRY)) + return ERROR_INVALID_PARAMETER; + + Index /= sizeof(NOTIFYENTRY); + + rc = DosRequestMutexSem(g_hSemNotifytable,SEM_INDEFINITE_WAIT); + + switch(g_Notifications[Index].usFlags) + { + case NOTIFY_FREE: + DosReleaseMutexSem(g_hSemNotifytable); + return ERROR_INVALID_PARAMETER; + case NOTIFY_CHANGE: + ulFunction = IOCTLF_DEREG_STATUSSEM; + ulSize = sizeof(STATUSEVENTSET); + EventSet.ulSize = ulSize; + EventSet.ulCaps = DEV_SEM_ADD | DEV_SEM_REMOVE; + EventSet.ulSemDeviceAdd = g_Notifications[Index].hDeviceAdded; + EventSet.ulSemDeviceRemove = g_Notifications[Index].hDeviceRemoved; + break; + case NOTIFY_DEVICE: + ulFunction = IOCTLF_DEREG_DEVICESEM; + ulSize = sizeof(DEVEVENTSET); + EventSet.ulSize = ulSize; + EventSet.ulCaps = DEV_SEM_ADD | DEV_SEM_REMOVE | + DEV_SEM_VENDORID | DEV_SEM_PRODUCTID | + DEV_SEM_BCDDEVICE ; + EventSet.ulSemDeviceAdd = g_Notifications[Index].hDeviceAdded; + EventSet.ulSemDeviceRemove = g_Notifications[Index].hDeviceRemoved; + EventSet.usVendorID = g_Notifications[Index].usVendor; + EventSet.usProductID = g_Notifications[Index].usProduct; + EventSet.usBCDDevice = g_Notifications[Index].usBCDDevice; + EventSet.usStatus = 0; + break; + default: + DosReleaseMutexSem(g_hSemNotifytable); + return ERROR_GEN_FAILURE; + } + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, ulFunction, + NULL, 0, NULL, + &EventSet,ulSize, &ulSize); + if(0==rc) + { + g_Notifications[Index].usFlags = NOTIFY_FREE; + g_Notifications[Index].hDeviceAdded = 0; + g_Notifications[Index].hDeviceRemoved = 0; + g_Notifications[Index].usVendor = 0; + g_Notifications[Index].usProduct = 0; + g_Notifications[Index].usBCDDevice = 0; + } else + { + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) ) + rc= ERROR_INVALID_PARAMETER; + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) ) + rc= EventSet.usStatus; + } + DosReleaseMutexSem(g_hSemNotifytable); + + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbOpen( PUSBHANDLE pHandle, + USHORT usVendor, + USHORT usProduct, + USHORT usBCDDevice, + USHORT usEnumDevice) +{ + ULONG ulCat, ulFunc; + ULONG ulParmLen, ulDataLen; + AQUIREDEV Aquire; + APIRET rc; + + if(!g_cInit) + return USB_NOT_INIT; + if(IsBadWritePointer(pHandle,sizeof(USBHANDLE)) ) + return ERROR_INVALID_PARAMETER; + + Aquire.usVendorID = usVendor; + Aquire.usProductID = usProduct; + Aquire.usBCDDevice = usBCDDevice; + Aquire.usDeviceNumber = usEnumDevice; + ulCat = 0xA0; + ulFunc = 0x33; + ulParmLen = sizeof(Aquire); + ulDataLen = sizeof(USBHANDLE); + rc = DosDevIOCtl( g_hUSBDrv, + ulCat,ulFunc, /*IOCAT_USBRES, IOCTLF_AQUIREDEVICE, */ + &Aquire, ulParmLen, &ulParmLen, + pHandle, ulDataLen, &ulDataLen); + + /* @@ ToDO maybe gether some info about device here (endpoints etc for safety checks) */ + return rc; + +} + +APIEXPORT APIRET APIENTRY +UsbClose( USBHANDLE Handle) +{ + APIRET rc; + ULONG ulDataLen,ulParmLen; + if(!g_cInit) + return USB_NOT_INIT; + + ulParmLen = sizeof(USBHANDLE); + ulDataLen = 0; + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_RELEASEDEVICE, + (PVOID)&Handle, ulParmLen, &ulParmLen, + NULL, ulDataLen, &ulDataLen); + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbCtrlMessage( USBHANDLE Handle, + UCHAR ucRequestType, + UCHAR ucRequest, + USHORT usValue, + USHORT usIndex, + USHORT usLength, + PVOID pData, + ULONG ulTimeout) +{ + APIRET rc; + USBCALLS_CTRL_REQ CtrlRequest; + ULONG ulParmLen, ulDataLen; + + if(!g_cInit) + return USB_NOT_INIT; + + ulParmLen = sizeof(USBCALLS_CTRL_REQ); + CtrlRequest.ulHandle = Handle; + CtrlRequest.bRequestType = ucRequestType; + CtrlRequest.bRequest = ucRequest; + CtrlRequest.wValue = usValue; + CtrlRequest.wIndex = usIndex; + CtrlRequest.wLength = usLength; + CtrlRequest.ulTimeout = ulTimeout; + ulDataLen = usLength; + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_SENDCONTROLURB, + (PVOID)&CtrlRequest, ulParmLen, &ulParmLen, + ulDataLen>0?(PVOID)pData:NULL, + ulDataLen, + ulDataLen>0?&ulDataLen:NULL); + if( rc != NO_ERROR ) + { + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) ) + rc= ERROR_INVALID_PARAMETER; + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) ) + rc= CtrlRequest.usStatus; + } + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbBulkRead( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + ULONG *ulNumBytes, + PVOID pvData, + ULONG ulTimeout) +{ + return UsbBulkRead2(Handle, Endpoint, AltInterface, TRUE /* fShortOk */, ulNumBytes, pvData, ulTimeout); +} + +APIEXPORT APIRET APIENTRY +UsbBulkRead2( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + BOOL fShortOk, + ULONG *ulNumBytes, + PVOID pvData, + ULONG ulTimeout) +{ + APIRET rc; + ULONG ulParmLen, ulDataLen, ulToProcess, ulTotalProcessed; + USBCALLS_BULK_REQ BulkRequest; + + if(!g_cInit) + return USB_NOT_INIT; + + if(*ulNumBytes==0) + return 0; + + /* just require this */ + if ((ULONG)pvData & 0xfff) + return ERROR_INVALID_ADDRESS; + if ((ULONG)pvData >= 0x20000000) + return ERROR_INVALID_ADDRESS; + + ulToProcess = *ulNumBytes; + ulTotalProcessed = 0; + + do + { + /* Process up to 64k, making sure we're working on segments. */ + ulDataLen = 0x10000 - ((ULONG)pvData & 0xffff); + if (ulDataLen > ulToProcess) + ulDataLen = ulToProcess; + + ulParmLen = sizeof(USBCALLS_BULK_REQ); + + memset(&BulkRequest, 0, sizeof(BulkRequest)); + BulkRequest.ulDevHandle = Handle; + BulkRequest.ucEndpoint = Endpoint; + BulkRequest.ucAltInterface = AltInterface; + BulkRequest.usStatus = 0; + BulkRequest.ulEvent = 0; + //BulkRequest.ulID = (ULONG)pvData; + BulkRequest.ulTimeout = ulTimeout; + BulkRequest.usDataProcessed = 0; + BulkRequest.usDataRemain = ulDataLen; + BulkRequest.usFlags = fShortOk && ulDataLen == ulToProcess ? 0 : USB_TRANSFER_FULL_SIZE; + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_SENDBULKURB, + (PVOID)&BulkRequest, ulParmLen, &ulParmLen, + pvData, ulDataLen, &ulDataLen); + Log(("BulkRead: usStatus=%d rc=%ld usDataProcessed=%d usDataRemain=%d ulDataLen=%ld\n", + BulkRequest.usStatus, rc, BulkRequest.usDataProcessed, BulkRequest.usDataRemain, ulDataLen)); + + if (rc != NO_ERROR) + { + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) ) + rc= ERROR_INVALID_PARAMETER; + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) ) + rc= BulkRequest.usStatus; + break; + } + + /* Adjust count and source pointer */ + ulToProcess -= ulDataLen; + pvData = (PBYTE)pvData + ulDataLen; + ulTotalProcessed += BulkRequest.usDataProcessed; + + if (BulkRequest.usDataProcessed != ulDataLen) + { + /* Transferred less than we wanted? so something is wrong, + or device doesn't wish to send more, exit loop */ + rc = USB_ERROR_LESSTRANSFERED; + break; + } + } while( ulToProcess>0 ); + + *ulNumBytes = ulTotalProcessed; + + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbBulkWrite( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + ULONG ulNumBytes, + PVOID pvData, + ULONG ulTimeout) +{ + return UsbBulkWrite2(Handle, Endpoint, AltInterface, FALSE /* fShortOk */, ulNumBytes, pvData, ulTimeout); +} + +APIEXPORT APIRET APIENTRY +UsbBulkWrite2( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + BOOL fShortOk, + ULONG ulNumBytes, + PVOID pvData, + ULONG ulTimeout) +{ + APIRET rc; + ULONG ulParmLen, ulDataLen; + USBCALLS_BULK_REQ BulkRequest; + + if(!g_cInit) + return USB_NOT_INIT; + + /* just require this */ + if ((ULONG)pvData & 0xfff) + return ERROR_INVALID_ADDRESS; + if ((ULONG)pvData >= 0x20000000) + return ERROR_INVALID_ADDRESS; + + do + { + /* Process up to 64k, making sure we're working on segments. */ + ulDataLen = 0x10000 - ((ULONG)pvData & 0xffff); + if (ulDataLen > ulNumBytes) + ulDataLen = ulNumBytes; + + ulParmLen = sizeof(USBCALLS_BULK_REQ); + + memset(&BulkRequest, 0, sizeof(BulkRequest)); + BulkRequest.ulDevHandle = Handle; + BulkRequest.ucEndpoint = Endpoint; + BulkRequest.ucAltInterface = AltInterface; + BulkRequest.usStatus = 0; + BulkRequest.ulEvent = 0; + //BulkRequest.ulID = (ULONG)pvData; + BulkRequest.ulTimeout = ulTimeout; + BulkRequest.usDataProcessed = 0; + BulkRequest.usDataRemain = ulDataLen; + BulkRequest.usFlags = fShortOk && ulDataLen == ulNumBytes ? 0 : USB_TRANSFER_FULL_SIZE; + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_SENDBULKURB, + &BulkRequest, ulParmLen, &ulParmLen, + pvData, ulDataLen, &ulDataLen ); + Log(("BulkWrite: usStatus=%d rc=%ld usDataProcessed=%d usDataRemain=%d ulDataLen=%ld\n", + BulkRequest.usStatus, rc, BulkRequest.usDataProcessed, BulkRequest.usDataRemain, ulDataLen)); + if (rc != NO_ERROR) + { + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) ) + rc= ERROR_INVALID_PARAMETER; + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) ) + rc= BulkRequest.usStatus; + break; + } + /* Adjust count and source pointer */ + ulNumBytes -= ulDataLen; + pvData = (PBYTE)pvData + ulDataLen; + } while( ulNumBytes > 0 ); + + return rc; +} + +APIRET APIENTRY +UsbIrqStart( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + USHORT ulNumBytes, + PVOID pData, + PHEV pHevModified) +{ + APIRET rc; + ULONG ulParmLen, ulDataLen; + USBCALLS_IRQ_START IrqStart; + HEV hEvent; + + if(!g_cInit) + return USB_NOT_INIT; + + if(0==ulNumBytes || IsBadWritePointer(pData, ulNumBytes)) + return ERROR_INVALID_PARAMETER; + + rc = DosCreateEventSem( NULL, + &hEvent, + DC_SEM_SHARED, + FALSE); + if(rc) + return rc; + + IrqStart.ulDevHandle = Handle; + IrqStart.ucEndpoint = Endpoint; + IrqStart.ucAltInterface = AltInterface; + IrqStart.usStatus = 0; + IrqStart.ulEvent = hEvent; + ulParmLen = sizeof(IrqStart); + ulDataLen = ulNumBytes; + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_START_IRQ_PROC, + (PVOID)&IrqStart, ulParmLen, &ulParmLen, + pData, ulDataLen,&ulDataLen); + if(rc) + DosCloseEventSem(hEvent); + else + *pHevModified = hEvent; + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbIrqStop( USBHANDLE Handle, + HEV HevModified) +{ + APIRET rc; + ULONG ulParmLen, ulDataLen; + + if(!g_cInit) + return USB_NOT_INIT; + + ulParmLen = sizeof(Handle); + ulDataLen = sizeof(HevModified); + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_STOP_IRQ_PROC, + (PVOID)&Handle, ulParmLen, &ulParmLen, + &HevModified, ulDataLen, &ulDataLen); + if(!rc) + DosCloseEventSem(HevModified); + + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbIsoStart( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + ISOHANDLE *phIso) +{ + APIRET rc; + PISORINGBUFFER pIter = g_pIsoRingBuffers; + USBCALLS_ISO_START IsoStart; + ULONG ulParmLen, ulDataLen; + int i; + + if(!g_cInit) + return USB_NOT_INIT; + + rc = DosRequestMutexSem(g_hSemRingBuffers,SEM_INDEFINITE_WAIT); + if(rc) + return rc; + + for(i=0;i< g_ulNumIsoRingBuffers;i++,pIter++) + { + if (pIter->hDevice==0) + { + pIter->hDevice = Handle; + break; + } + } + DosReleaseMutexSem(g_hSemRingBuffers); + + if(i==g_ulNumIsoRingBuffers) + return USB_ERROR_OUTOF_RESOURCES; + + IsoStart.ulDevHandle = Handle; + IsoStart.ucEndpoint = Endpoint; + IsoStart.ucAltInterface = AltInterface; + ulParmLen = sizeof(IsoStart); + ulDataLen = sizeof(ISORINGBUFFER); + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_STOP_IRQ_PROC, + (PVOID)&IsoStart, ulParmLen, &ulParmLen, + pIter, ulDataLen, &ulDataLen); + if(rc) + { + pIter->hDevice = 0; + *phIso = 0; + } + else + { + pIter->ucEndpoint = Endpoint; + pIter->ucAltInterface = AltInterface; + } + return rc; +} + +static APIRET IsInvalidIsoHandle(const ISOHANDLE hIso) +{ + PISORINGBUFFER pIter; + ULONG i; + pIter = g_pIsoRingBuffers; + + for(i=0;i<g_ulNumIsoRingBuffers;i++,pIter++) + { + if(pIter==(PISORINGBUFFER)hIso && pIter->hDevice) + return 0; + } + return ERROR_INVALID_PARAMETER; +} + +APIEXPORT APIRET APIENTRY +UsbIsoStop( ISOHANDLE hIso) +{ + + APIRET rc = NO_ERROR; + if(!g_cInit) + return USB_NOT_INIT; + +/* rc = DosDevIOCtl( g_hUSBDrv, */ + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbIsoDequeue( ISOHANDLE hIso, + PVOID pBuffer, + ULONG ulNumBytes) +{ + APIRET rc; + PISORINGBUFFER pRB = (PISORINGBUFFER)hIso; + + rc = IsInvalidIsoHandle(hIso); + if(rc) + return rc; + if(!(pRB->ucEndpoint & ISO_DIRMASK)) + return ERROR_INVALID_PARAMETER; + + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbIsoPeekQueue( ISOHANDLE hIso, + UCHAR * pByte, + ULONG ulOffset) +{ + APIRET rc; + PISORINGBUFFER pRB = (PISORINGBUFFER)hIso; + + rc = IsInvalidIsoHandle(hIso); + if(rc) + return rc; + if(!(pRB->ucEndpoint & ISO_DIRMASK)) + return ERROR_INVALID_PARAMETER; + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbIsoEnqueue( ISOHANDLE hIso, + const UCHAR * pBuffer, + ULONG ulNumBytes) +{ + APIRET rc; + PISORINGBUFFER pRB = (PISORINGBUFFER)hIso; + + rc = IsInvalidIsoHandle(hIso); + if(rc) + return rc; + if(pRB->ucEndpoint & ISO_DIRMASK) + return ERROR_INVALID_PARAMETER; + + return rc; +} + +APIEXPORT APIRET APIENTRY +UsbIsoGetLength( ISOHANDLE hIso, + ULONG *pulLength) +{ + APIRET rc; + PISORINGBUFFER pRB = (PISORINGBUFFER) hIso; + USHORT ri,wi; + + rc = IsInvalidIsoHandle(hIso); + if(rc) + return rc; + wi = pRB->usPosWrite; + ri = pRB->usPosRead; + + if (ri == wi) + *pulLength = 0; + else if (ri < wi) + *pulLength = wi - ri; + else + *pulLength = wi + (pRB->usBufSize - ri); + + return 0; +} + +APIEXPORT APIRET APIENTRY +UsbIrqRead( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + ULONG *ulNumBytes, + PVOID pData, + ULONG ulTimeout) +{ + APIRET rc; + ULONG ulParmLen, ulDataLen; + LIBUSB_IRQ_REQ IrqRequest; + + if(!g_cInit) + return USB_NOT_INIT; + + /* 10 01 2003 - KIEWITZ -> Still @@ToDo Add Endpoint check based on descriptors + We currently only allow Endpoint-addresses 80h->8Fh here */ + if ((Endpoint<0x80) || (Endpoint>0x8F)) + return USB_ERROR_INVALID_ENDPOINT; + + if(*ulNumBytes==0) + return 0; + + IrqRequest.ulDevHandle = Handle; + IrqRequest.ucEndpoint = Endpoint; + IrqRequest.ucAltInterface = AltInterface; + IrqRequest.usStatus = 0; + IrqRequest.ulEvent = 0; + IrqRequest.ulTimeout = ulTimeout; + ulParmLen = sizeof(LIBUSB_IRQ_REQ); + ulDataLen = *ulNumBytes; + + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_SENDIRQURB, + (PVOID)&IrqRequest, ulParmLen, &ulParmLen, + pData, ulDataLen, &ulDataLen); + + if( rc == NO_ERROR ) + { + *ulNumBytes = IrqRequest.usDataLen; + } else + { + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) ) + rc= ERROR_INVALID_PARAMETER; + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) ) + rc= IrqRequest.usStatus; + } + return rc; +} + + +APIEXPORT APIRET APIENTRY +UsbFixupDevice( USBHANDLE Handle, + UCHAR ucConfiguration, + UCHAR *pucConfigurationData, + ULONG ulConfigurationLen ) +{ + LIBUSB_FIXUP request; + ULONG ulParmLen; + APIRET rc; + + request.ulDevHandle= Handle; + request.ucConfiguration= ucConfiguration; + request.usStatus= 0; + ulParmLen= sizeof(LIBUSB_FIXUP); + rc = DosDevIOCtl( g_hUSBDrv, + IOCAT_USBRES, IOCTLF_FIXUPDEVUCE, + (PVOID)&request, ulParmLen, &ulParmLen, + pucConfigurationData, ulConfigurationLen, &ulConfigurationLen); + if( rc != NO_ERROR ) + { + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_INVALID_PARAMETER) ) + rc= ERROR_INVALID_PARAMETER; + if( rc == (ERROR_USER_DEFINED_BASE|ERROR_I24_GEN_FAILURE) ) + rc= request.usStatus; + } + return rc; +} + +#ifndef STATIC_USBCALLS + /*+-------------------------------------------------------------------+*/ + /*| _CRT_init is the C run-time environment initialization function. |*/ + /*|It will return 0 to indicate success and -1 to indicate failure. |*/ + /*+-------------------------------------------------------------------+*/ + +/* int _CRT_init (void); */ + + /*+-------------------------------------------------------------------+*/ + /*| _CRT_term is the C run-time environment termination function. |*/ + /*+-------------------------------------------------------------------+*/ + +/* void _CRT_term (unsigned long);*/ + + /*+-------------------------------------------------------------------+*/ + /*| _DLL_InitTerm is the function that gets called by the operating |*/ + /*| system loader when it loads and frees this DLL for each process |*/ + /*| that accesses this DLL. However, it only gets called the first |*/ + /*| time the DLL is loaded and the last time it is freed for a |*/ + /*| particular process. The system linkage convention must be used |*/ + /*| because the operating system loader is calling this function. |*/ + /*+-------------------------------------------------------------------+*/ + +#ifdef STATIC_LINK +int _CRT_init (void); +void _CRT_term(0UL); +#endif + +unsigned long _System _DLL_InitTerm (unsigned long modhandle, unsigned long flag) +{ + + /* If flag is zero then the DLL is being loaded so initialization */ + /* should be performed. If flag is 1 then the DLL is being freed */ + /* so termination should be performed. */ + + switch (flag) + { + case 0: + /* The C run-time environment initialization function must */ + /* be called before any calls to C run-time functions that */ + /* are not inlined. */ + +#ifdef STATIC_LINK + if (_CRT_init () == -1) + return 0UL; +#endif + InitUsbCalls(); + break; + + case 1: + TermUsbCalls(); +#ifdef STATIC_LINK + _CRT_term(0UL); +#endif + break; + + default: + return 0UL; + + } + + /* A nonzero value must be returned to indicate success. */ + return 1UL; +} +#endif /* !STATIC_USBCALLS */ + diff --git a/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.h b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.h new file mode 100644 index 00000000..151a5bc1 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/os2/usbcalls.h @@ -0,0 +1,242 @@ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_os2_usbcalls_h +#define VBOX_INCLUDED_SRC_VBoxUSB_os2_usbcalls_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +typedef ULONG USBHANDLE, *PUSBHANDLE; +typedef ULONG USBNOTIFY, *PUSBNOTIFY; +typedef ULONG ISOHANDLE, *PISOHANDLE; + +#define USB_NOT_INIT 7000 +#define USB_ERROR_NO_MORE_NOTIFICATIONS 7001 +#define USB_ERROR_OUTOF_RESOURCES 7002 +#define USB_ERROR_INVALID_ENDPOINT 7003 +#define USB_ERROR_LESSTRANSFERED 7004 + +/* IORB status codes */ +#define USB_IORB_DONE 0x0000 +#define USB_IORB_FAILED 0x8000 + +#define USB_ANY_PRODUCTVERSION 0xFFFF +#define USB_OPEN_FIRST_UNUSED 0 + +#ifdef USB_BIND_DYNAMIC + typedef APIRET APIENTRY USBREGISTERDEVICENOTIFICATION( PUSBNOTIFY pNotifyID, + HEV hDeviceAdded, + HEV hDeviceRemoved, + USHORT usVendor, + USHORT usProduct, + USHORT usBCDVersion); + typedef USBREGISTERDEVICENOTIFICATION *PUSBREGISTERDEVICENOTIFICATION; + + typedef APIRET APIENTRY USBDEREGISTERNOTIFICATION( USBNOTIFY NotifyID); + + typedef USBDEREGISTERNOTIFICATION *PUSBDEREGISTERNOTIFICATION; + + typedef APIRET APIENTRY USBOPEN( PUSBHANDLE pHandle, + USHORT usVendor, + USHORT usProduct, + USHORT usBCDDevice, + USHORT usEnumDevice); + typedef USBOPEN *PUSBOPEN; + typedef APIRET APIENTRY USBCLOSE( USBHANDLE Handle); + typedef USBCLOSE *PUSBCLOSE; + + typedef APIRET APIENTRY USBCTRLMESSAGE( USBHANDLE Handle, + UCHAR ucRequestType, + UCHAR ucRequest, + USHORT usValue, + USHORT usIndex, + USHORT usLength, + PVOID pvData, + ULONG ulTimeout); + typedef USBCTRLMESSAGE *PUSBCTRLMESSAGE; +#else + APIRET APIENTRY UsbQueryNumberDevices( ULONG *pulNumDev); + + APIRET APIENTRY UsbQueryDeviceReport( ULONG ulDevNumber, + ULONG *ulBufLen, + PVOID pvData); + APIRET APIENTRY UsbRegisterChangeNotification( PUSBNOTIFY pNotifyID, + HEV hDeviceAdded, + HEV hDeviceRemoved); + + APIRET APIENTRY UsbRegisterDeviceNotification( PUSBNOTIFY pNotifyID, + HEV hDeviceAdded, + HEV hDeviceRemoved, + USHORT usVendor, + USHORT usProduct, + USHORT usBCDVersion); + + APIRET APIENTRY UsbDeregisterNotification( USBNOTIFY NotifyID); + + APIRET APIENTRY UsbOpen( PUSBHANDLE pHandle, + USHORT usVendor, + USHORT usProduct, + USHORT usBCDDevice, + USHORT usEnumDevice); + + APIRET APIENTRY UsbClose( USBHANDLE Handle); + + APIRET APIENTRY UsbCtrlMessage( USBHANDLE Handle, + UCHAR ucRequestType, + UCHAR ucRequest, + USHORT usValue, + USHORT usIndex, + USHORT usLength, + PVOID pvData, + ULONG ulTimeout); + + APIRET APIENTRY UsbBulkRead( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR Interface, + ULONG *ulNumBytes, + PVOID pvData, + ULONG ulTimeout); + + APIRET APIENTRY UsbBulkRead2( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR Interface, + BOOL fShortOk, + ULONG *ulNumBytes, + PVOID pvData, + ULONG ulTimeout); + + APIRET APIENTRY UsbBulkWrite( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR Interface, + ULONG ulNumBytes, + PVOID pvData, + ULONG ulTimeout); + + APIRET APIENTRY UsbBulkWrite2( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR AltInterface, + BOOL fShortOk, + ULONG ulNumBytes, + PVOID pvData, + ULONG ulTimeout); + + APIRET APIENTRY UsbIrqStart( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR Interface, + USHORT usNumBytes, + PVOID pvData, + PHEV pHevModified); + APIRET APIENTRY UsbIrqStop( USBHANDLE Handle, + HEV HevModified); + + APIRET APIENTRY UsbIsoStart( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR Interface, + ISOHANDLE *phIso); + APIRET APIENTRY UsbIsoStop( ISOHANDLE hIso); + + APIRET APIENTRY UsbIsoDequeue( ISOHANDLE hIso, + PVOID pBuffer, + ULONG ulNumBytes); + APIRET APIENTRY UsbIsoEnqueue( ISOHANDLE hIso, + const UCHAR * pBuffer, + ULONG ulNumBytes); + APIRET APIENTRY UsbIsoPeekQueue( ISOHANDLE hIso, + UCHAR * pByte, + ULONG ulOffset); + APIRET APIENTRY UsbIsoGetLength( ISOHANDLE hIso, + ULONG *pulLength); + + APIRET APIENTRY UsbIrqRead( USBHANDLE Handle, + UCHAR Endpoint, + UCHAR Interface, + ULONG *ulNumBytes, + PVOID pvData, + ULONG ulTimeout); + + APIRET APIENTRY UsbFixupDevice( USBHANDLE Handle, + UCHAR ucConfiguration, + UCHAR *pucConfigurationData, + ULONG ulConfigurationLen ); + + APIRET APIENTRY InitUsbCalls(void); + APIRET APIENTRY TermUsbCalls(void); + + /* Standard USB Requests See 9.4. in USB 1.1. spec. */ + + /* 09 01 2003 - KIEWITZ */ + #define UsbDeviceClearFeature(HANDLE, FEAT) \ + UsbCtrlMessage(HANDLE, 0x00, 0x01, FEAT, 0, 0, NULL, 0) + #define UsbDeviceSetFeature(HANDLE, FEAT) \ + UsbCtrlMessage(HANDLE, 0x80, 0x03, FEAT, 0, 0, NULL, 0) + #define UsbInterfaceClearFeature(HANDLE, IFACE, FEAT) \ + UsbCtrlMessage(HANDLE, 0x01, 0x01, FEAT, IFACE, 0, NULL, 0) + #define UsbInterfaceSetFeature(HANDLE, IFACE, FEAT) \ + UsbCtrlMessage(HANDLE, 0x80, 0x03, FEAT, IFACE, 0, NULL, 0) + #define UsbEndpointClearFeature(HANDLE, ENDPOINT, FEAT) \ + UsbCtrlMessage(HANDLE, 0x02, 0x01, FEAT, ENDPOINT, 0, NULL, 0) + #define UsbEndpointSetFeature(HANDLE, ENDPOINT, FEAT) \ + UsbCtrlMessage(HANDLE, 0x80, 0x03, FEAT, ENDPOINT, 0, NULL, 0) + #define FEATURE_DEVICE_REMOTE_WAKEUP 1 + #define FEATURE_ENDPOINT_HALT 0 + #define UsbEndpointClearHalt(HANDLE, ENDPOINT) \ + UsbEndpointClearFeature(HANDLE, ENDPOINT, FEATURE_ENDPOINT_HALT) + + #define UsbDeviceGetConfiguration(HANDLE, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x08, 0, 0, 1, DATA, 0) + #define UsbDeviceSetConfiguration(HANDLE, CONFIG) \ + UsbCtrlMessage(HANDLE, 0x00, 0x09, CONFIG, 0, 0, NULL, 0) + + #define UsbDeviceGetStatus(HANDLE, STATUS) \ + UsbCtrlMessage(HANDLE, 0x80, 0x00, 0, 0, 2, STATUS, 0) + #define UsbInterfaceGetStatus(HANDLE, IFACE, STATUS) \ + UsbCtrlMessage(HANDLE, 0x80, 0x00, 0, IFACE, 2, STATUS, 0) + #define UsbEndpointGetStatus(HANDLE, ENDPOINT, STATUS) \ + UsbCtrlMessage(HANDLE, 0x80, 0x00, 0, ENDPOINT, 2, STATUS, 0) + + #define STATUS_ENDPOINT_HALT 0x0001 + #define STATUS_DEVICE_SELFPOWERD 0x0001 + #define STATUS_DEVICE_REMOTEWAKEUP 0x0002 + + #define UsbDeviceSetAddress(HANDLE, ADDRESS) \ + UsbCtrlMessage(HANDLE, 0x80, 0x05, ADDRESS, 0, 0, NULL, 0) + + #define UsbDeviceGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0100|INDEX), LID, LEN, DATA, 0) + #define UsbDeviceSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0100|INDEX), LID, LEN, DATA, 0) + #define UsbConfigurationGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0200|INDEX), LID, LEN, DATA, 0) + #define UsbConfigurationSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0200|INDEX), LID, LEN, DATA, 0) + #define UsbStringGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0300|INDEX), LID, LEN, DATA, 0) + #define UsbStringSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0300|INDEX), LID, LEN, DATA, 0) + #define UsbInterfaceGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0400|INDEX), LID, LEN, DATA, 0) + #define UsbInterfaceSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0400|INDEX), LID, LEN, DATA, 0) + #define UsbEndpointGetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x06, (0x0500|INDEX), LID, LEN, DATA, 0) + #define UsbEndpointSetDescriptor(HANDLE, INDEX, LID, LEN, DATA) \ + UsbCtrlMessage(HANDLE, 0x80, 0x07, (0x0500|INDEX), LID, LEN, DATA, 0) + + #define UsbInterfaceGetAltSetting(HANDLE, IFACE, SETTING) \ + UsbCtrlMessage(HANDLE, 0x81, 0x0A, 0, IFACE, 1, SETTING, 0) + #define UsbInterfaceSetAltSetting(HANDLE, IFACE, ALTSET) \ + UsbCtrlMessage(HANDLE, 0x01, 0x0B, ALTSET, IFACE, 0, NULL, 0) + + #define UsbEndpointSynchFrame(HANDLE, ENDPOINT, FRAMENUM) \ + UsbCtrlMessage(HANDLE, 0x82, 0x0B, 0, ENDPOINT, 2, FRAMENUM, 0) +#endif + + +#ifdef __cplusplus +} +#endif + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_os2_usbcalls_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/solaris/Makefile.kmk b/src/VBox/HostDrivers/VBoxUSB/solaris/Makefile.kmk new file mode 100644 index 00000000..61f940e5 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/solaris/Makefile.kmk @@ -0,0 +1,57 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for the Solaris VBoxUSB kernel extension. +# + +# +# Copyright (C) 2008-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# +# The contents of this file may alternatively be used under the terms +# of the Common Development and Distribution License Version 1.0 +# (CDDL) only, as it comes in the "COPYING.CDDL" file of the +# VirtualBox OSE distribution, in which case the provisions of the +# CDDL are applicable instead of those of the GPL. +# +# You may elect to license modified versions of this file under the +# terms and conditions of either the GPL or the CDDL or both. +# + +SUB_DEPTH = ../../../../.. +include $(KBUILD_PATH)/subheader.kmk + +# +# vboxusbmon - The Solaris USB Monitor Kernel module. +# +SYSMODS.solaris += vboxusbmon +vboxusbmon_TEMPLATE = VBOXR0DRV +vboxusbmon_DEFS = IN_RT_R0 VBOX_SVN_REV=$(VBOX_SVN_REV) +vboxusbmon_DEPS += $(VBOX_SVN_REV_KMK) +vboxusbmon_INCS := . .. include +vboxusbmon_LDFLAGS += -N drv/vboxdrv -N misc/usba +vboxusbmon_SOURCES = \ + VBoxUSBMon-solaris.c \ + ../USBFilter.cpp \ + ../VBoxUSBFilterMgr.cpp + +# +# vboxusb - The Solaris Generic USB Client Kernel module. +# +SYSMODS.solaris += vboxusb +vboxusb_TEMPLATE = VBOXR0DRV +vboxusb_DEFS = IN_RT_R0 IN_SUP_R0 VBOX_SVN_REV=$(VBOX_SVN_REV) +vboxusb_DEPS += $(VBOX_SVN_REV_KMK) +vboxusb_INCS := . include/ +vboxusb_LDFLAGS += -N drv/vboxdrv -N drv/vboxusbmon -N misc/usba +vboxusb_SOURCES = \ + VBoxUSB-solaris.c + +include $(FILE_KBUILD_SUB_FOOTER) + diff --git a/src/VBox/HostDrivers/VBoxUSB/solaris/USBLib-solaris.cpp b/src/VBox/HostDrivers/VBoxUSB/solaris/USBLib-solaris.cpp new file mode 100644 index 00000000..fd6155f9 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/solaris/USBLib-solaris.cpp @@ -0,0 +1,269 @@ +/** $Id: USBLib-solaris.cpp $ */ +/** @file + * USBLib - Library for wrapping up the VBoxUSB functionality, Solaris flavor. + */ + +/* + * Copyright (C) 2008-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/usblib.h> +#include <VBox/err.h> +#include <VBox/log.h> +#include <iprt/assert.h> +#include <iprt/asm.h> +#include <iprt/file.h> +#include <iprt/mem.h> +#include <iprt/process.h> +#include <iprt/env.h> +#include <iprt/path.h> +#include <iprt/string.h> + +# include <sys/types.h> +# include <sys/stat.h> +# include <errno.h> +# include <unistd.h> +# include <string.h> +# include <limits.h> +# include <strings.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Logging class. */ +#define USBLIBR3 "USBLibR3" + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Reference counter. */ +static uint32_t volatile g_cUsers = 0; +/** VBoxUSB Device handle. */ +static RTFILE g_hFile = NIL_RTFILE; + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int usblibDoIOCtl(unsigned iFunction, void *pvData, size_t cbData); + + +USBLIB_DECL(int) USBLibInit(void) +{ + LogFlow((USBLIBR3 ":USBLibInit\n")); + + /* + * Already open? + * This isn't properly serialized, but we'll be fine with the current usage. + */ + if (g_cUsers) + { + ASMAtomicIncU32(&g_cUsers); + return VINF_SUCCESS; + } + + RTFILE File; + int rc = RTFileOpen(&File, VBOXUSB_DEVICE_NAME, RTFILE_O_READWRITE | RTFILE_O_OPEN | RTFILE_O_DENY_NONE); + if (RT_FAILURE(rc)) + { + LogRel((USBLIBR3 ":failed to open the VBoxUSB monitor device node '%s' rc=%Rrc\n", VBOXUSB_DEVICE_NAME, rc)); + return rc; + } + g_hFile = File; + + ASMAtomicIncU32(&g_cUsers); + /* + * Check the USBMonitor version. + */ + VBOXUSBREQ_GET_VERSION Req; + bzero(&Req, sizeof(Req)); + rc = usblibDoIOCtl(VBOXUSBMON_IOCTL_GET_VERSION, &Req, sizeof(Req)); + if (RT_SUCCESS(rc)) + { + if ( Req.u32Major != VBOXUSBMON_VERSION_MAJOR + || Req.u32Minor < VBOXUSBMON_VERSION_MINOR) + { + rc = VERR_VERSION_MISMATCH; + LogRel((USBLIBR3 ":USBMonitor version mismatch! driver v%d.%d, expecting ~v%d.%d\n", + Req.u32Major, Req.u32Minor, VBOXUSBMON_VERSION_MAJOR, VBOXUSBMON_VERSION_MINOR)); + + RTFileClose(File); + g_hFile = NIL_RTFILE; + ASMAtomicDecU32(&g_cUsers); + return rc; + } + } + else + { + LogRel((USBLIBR3 ":USBMonitor driver version query failed. rc=%Rrc\n", rc)); + RTFileClose(File); + g_hFile = NIL_RTFILE; + ASMAtomicDecU32(&g_cUsers); + return rc; + } + + return VINF_SUCCESS; +} + + +USBLIB_DECL(int) USBLibTerm(void) +{ + LogFlow((USBLIBR3 ":USBLibTerm\n")); + + if (!g_cUsers) + return VERR_WRONG_ORDER; + if (ASMAtomicDecU32(&g_cUsers) != 0) + return VINF_SUCCESS; + + /* + * We're the last guy, close down the connection. + */ + RTFILE File = g_hFile; + g_hFile = NIL_RTFILE; + if (File == NIL_RTFILE) + return VERR_INTERNAL_ERROR; + + int rc = RTFileClose(File); + AssertRC(rc); + return rc; +} + + +USBLIB_DECL(void *) USBLibAddFilter(PCUSBFILTER pFilter) +{ + LogFlow((USBLIBR3 ":USBLibAddFilter pFilter=%p\n", pFilter)); + + VBOXUSBREQ_ADD_FILTER Req; + Req.Filter = *pFilter; + Req.uId = 0; + + int rc = usblibDoIOCtl(VBOXUSBMON_IOCTL_ADD_FILTER, &Req, sizeof(Req)); + if (RT_SUCCESS(rc)) + return (void *)Req.uId; + + AssertMsgFailed((USBLIBR3 ":VBOXUSBMON_IOCTL_ADD_FILTER failed! rc=%Rrc\n", rc)); + return NULL; +} + + +USBLIB_DECL(void) USBLibRemoveFilter(void *pvId) +{ + LogFlow((USBLIBR3 ":USBLibRemoveFilter pvId=%p\n", pvId)); + + VBOXUSBREQ_REMOVE_FILTER Req; + Req.uId = (uintptr_t)pvId; + + int rc = usblibDoIOCtl(VBOXUSBMON_IOCTL_REMOVE_FILTER, &Req, sizeof(Req)); + if (RT_SUCCESS(rc)) + return; + + AssertMsgFailed((USBLIBR3 ":VBOXUSBMON_IOCTL_REMOVE_FILTER failed! rc=%Rrc\n", rc)); +} + + +USBLIB_DECL(int) USBLibGetClientInfo(char *pszDeviceIdent, char **ppszClientPath, int *pInstance) +{ + LogFlow((USBLIBR3 ":USBLibGetClientInfo pszDeviceIdent=%s ppszClientPath=%p pInstance=%p\n", + pszDeviceIdent, ppszClientPath, pInstance)); + + AssertPtrReturn(pInstance, VERR_INVALID_PARAMETER); + AssertPtrReturn(ppszClientPath, VERR_INVALID_PARAMETER); + AssertPtrReturn(pszDeviceIdent, VERR_INVALID_PARAMETER); + + VBOXUSBREQ_CLIENT_INFO Req; + bzero(&Req, sizeof(Req)); + RTStrPrintf(Req.szDeviceIdent, sizeof(Req.szDeviceIdent), "%s", pszDeviceIdent); + + int rc = usblibDoIOCtl(VBOXUSBMON_IOCTL_CLIENT_INFO, &Req, sizeof(Req)); + if (RT_SUCCESS(rc)) + { + *pInstance = Req.Instance; + rc = RTStrDupEx(ppszClientPath, Req.szClientPath); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + + LogRel((USBLIBR3 ":USBLibGetClientInfo RTStrDupEx failed! rc=%Rrc szClientPath=%s\n", rc, Req.szClientPath)); + } + else + LogRel((USBLIBR3 ":USBLibGetClientInfo VBOXUSBMON_IOCTL_CLIENTPATH failed! rc=%Rrc\n", rc)); + + return rc; +} + + +USBLIB_DECL(int) USBLibResetDevice(char *pszDevicePath, bool fReattach) +{ + LogFlow((USBLIBR3 ":USBLibResetDevice pszDevicePath=%s\n", pszDevicePath)); + + size_t cbPath = strlen(pszDevicePath) + 1; + size_t cbReq = sizeof(VBOXUSBREQ_RESET_DEVICE) + cbPath; + VBOXUSBREQ_RESET_DEVICE *pReq = (VBOXUSBREQ_RESET_DEVICE *)RTMemTmpAllocZ(cbReq); + if (RT_UNLIKELY(!pReq)) + return VERR_NO_MEMORY; + + pReq->fReattach = fReattach; + if (strlcpy(pReq->szDevicePath, pszDevicePath, cbPath) >= cbPath) + { + LogRel((USBLIBR3 ":USBLibResetDevice buffer overflow. cbPath=%u pszDevicePath=%s\n", cbPath, pszDevicePath)); + return VERR_BUFFER_OVERFLOW; + } + + int rc = usblibDoIOCtl(VBOXUSBMON_IOCTL_RESET_DEVICE, pReq, cbReq); + if (RT_FAILURE(rc)) + LogRel((USBLIBR3 ":VBOXUSBMON_IOCTL_RESET_DEVICE failed! rc=%Rrc\n", rc)); + + RTMemFree(pReq); + return rc; +} + + +static int usblibDoIOCtl(unsigned iFunction, void *pvData, size_t cbData) +{ + if (g_hFile == NIL_RTFILE) + { + LogRel((USBLIBR3 ":IOCtl failed, device not open.\n")); + return VERR_FILE_NOT_FOUND; + } + + VBOXUSBREQ Hdr; + Hdr.u32Magic = VBOXUSBMON_MAGIC; + Hdr.cbData = cbData; /* Don't include full size because the header size is fixed. */ + Hdr.pvDataR3 = pvData; + + int rc = ioctl(RTFileToNative(g_hFile), iFunction, &Hdr); + if (rc < 0) + { + rc = errno; + LogRel((USBLIBR3 ":IOCtl failed iFunction=%x errno=%d g_file=%d\n", iFunction, rc, RTFileToNative(g_hFile))); + return RTErrConvertFromErrno(rc); + } + + rc = Hdr.rc; + if (RT_UNLIKELY(RT_FAILURE(rc))) + LogRel((USBLIBR3 ":Function (%x) failed. rc=%Rrc\n", iFunction, rc)); + + return rc; +} diff --git a/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c b/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c new file mode 100644 index 00000000..694361f9 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSB-solaris.c @@ -0,0 +1,4044 @@ +/* $Id: VBoxUSB-solaris.c $ */ +/** @file + * VirtualBox USB Client Driver, Solaris Hosts. + */ + +/* + * Copyright (C) 2008-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_USB_DRV +#include <VBox/version.h> +#include <VBox/log.h> +#include <VBox/err.h> +#include <VBox/cdefs.h> +#include <VBox/sup.h> +#include <VBox/usblib-solaris.h> + +#include <iprt/assert.h> +#include <iprt/initterm.h> +#include <iprt/semaphore.h> +#include <iprt/mem.h> +#include <iprt/process.h> +#include <iprt/string.h> +#include <iprt/path.h> +#include <iprt/thread.h> +#include <iprt/dbg.h> + +#define USBDRV_MAJOR_VER 2 +#define USBDRV_MINOR_VER 0 +#include <sys/usb/usba.h> +#include <sys/strsun.h> +#include "usbai_private.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The module name. */ +#define DEVICE_NAME "vboxusb" +/** The module description as seen in 'modinfo'. */ +#define DEVICE_DESC_DRV "VirtualBox USB" + +/** -=-=-=-=-=-=- Standard Specifics -=-=-=-=-=-=- */ +/** Max. supported endpoints. */ +#define VBOXUSB_MAX_ENDPOINTS 32 +/** Size of USB Ctrl Xfer Header in bytes. */ +#define VBOXUSB_CTRL_XFER_SIZE 8 +/** + * USB2.0 (Sec. 9-13) Bits 10..0 is the max packet size; for high speed Isoc/Intr, bits 12..11 is + * number of additional transaction opportunities per microframe. + */ +#define VBOXUSB_PKT_SIZE(pkt) (pkt & 0x07FF) * (1 + ((pkt >> 11) & 3)) +/** Endpoint Xfer Type. */ +#define VBOXUSB_XFER_TYPE(endp) ((endp)->EpDesc.bmAttributes & USB_EP_ATTR_MASK) +/** Endpoint Xfer Direction. */ +#define VBOXUSB_XFER_DIR(endp) ((endp)->EpDesc.bEndpointAddress & USB_EP_DIR_IN) +/** Create an Endpoint index from an Endpoint address. */ +#define VBOXUSB_GET_EP_INDEX(epaddr) (((epaddr) & USB_EP_NUM_MASK) + \ + (((epaddr) & USB_EP_DIR_MASK) ? 16 : 0)) + + +/** -=-=-=-=-=-=- Tunable Parameters -=-=-=-=-=-=- */ +/** Time to wait while draining inflight UBRs on suspend, in seconds. */ +#define VBOXUSB_DRAIN_TIME 20 +/** Ctrl Xfer timeout in seconds. */ +#define VBOXUSB_CTRL_XFER_TIMEOUT 15 +/** Maximum URB queue length. */ +#define VBOXUSB_URB_QUEUE_SIZE 512 +/** Maximum asynchronous requests per pipe. */ +#define VBOXUSB_MAX_PIPE_ASYNC_REQS 2 + +/** For enabling global symbols while debugging. **/ +#if defined(DEBUG_ramshankar) +# define LOCAL +#else +# define LOCAL static +#endif + + +/********************************************************************************************************************************* +* Kernel Entry Hooks * +*********************************************************************************************************************************/ +int VBoxUSBSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred); +int VBoxUSBSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred); +int VBoxUSBSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred); +int VBoxUSBSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred); +int VBoxUSBSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal); +int VBoxUSBSolarisPoll(dev_t Dev, short fEvents, int fAnyYet, short *pReqEvents, struct pollhead **ppPollHead); +int VBoxUSBSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pArg, void **ppResult); +int VBoxUSBSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd); +int VBoxUSBSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd); +int VBoxUSBSolarisPower(dev_info_t *pDip, int Component, int Level); + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * cb_ops: for drivers that support char/block entry points + */ +static struct cb_ops g_VBoxUSBSolarisCbOps = +{ + VBoxUSBSolarisOpen, + VBoxUSBSolarisClose, + nodev, /* b strategy */ + nodev, /* b dump */ + nodev, /* b print */ + VBoxUSBSolarisRead, + VBoxUSBSolarisWrite, + VBoxUSBSolarisIOCtl, + nodev, /* c devmap */ + nodev, /* c mmap */ + nodev, /* c segmap */ + VBoxUSBSolarisPoll, + ddi_prop_op, /* property ops */ + NULL, /* streamtab */ + D_NEW | D_MP, /* compat. flag */ + CB_REV, /* revision */ + nodev, /* c aread */ + nodev /* c awrite */ +}; + +/** + * dev_ops: for driver device operations + */ +static struct dev_ops g_VBoxUSBSolarisDevOps = +{ + DEVO_REV, /* driver build revision */ + 0, /* ref count */ + VBoxUSBSolarisGetInfo, + nulldev, /* identify */ + nulldev, /* probe */ + VBoxUSBSolarisAttach, + VBoxUSBSolarisDetach, + nodev, /* reset */ + &g_VBoxUSBSolarisCbOps, + NULL, /* bus ops */ + VBoxUSBSolarisPower, + ddi_quiesce_not_needed +}; + +/** + * modldrv: export driver specifics to the kernel + */ +static struct modldrv g_VBoxUSBSolarisModule = +{ + &mod_driverops, /* extern from kernel */ + DEVICE_DESC_DRV " " VBOX_VERSION_STRING "r" RT_XSTR(VBOX_SVN_REV), + &g_VBoxUSBSolarisDevOps +}; + +/** + * modlinkage: export install/remove/info to the kernel + */ +static struct modlinkage g_VBoxUSBSolarisModLinkage = +{ + MODREV_1, + &g_VBoxUSBSolarisModule, + NULL, +}; + +/** + * vboxusb_ep_t: Endpoint structure with info. for managing an endpoint. + */ +typedef struct vboxusb_ep_t +{ + bool fInitialized; /* Whether this Endpoint is initialized */ + usb_ep_descr_t EpDesc; /* Endpoint descriptor */ + usb_pipe_handle_t pPipe; /* Endpoint pipe handle */ + usb_pipe_policy_t PipePolicy; /* Endpoint policy */ + bool fIsocPolling; /* Whether Isoc. IN polling is enabled */ + list_t hIsocInUrbs; /* Isoc. IN inflight URBs */ + uint16_t cIsocInUrbs; /* Number of Isoc. IN inflight URBs */ + list_t hIsocInLandedReqs; /* Isoc. IN landed requests */ + uint16_t cbIsocInLandedReqs; /* Cumulative size of landed Isoc. IN requests */ + size_t cbMaxIsocData; /* Maximum size of Isoc. IN landed buffer */ +} vboxusb_ep_t; + +/** + * vboxusb_isoc_req_t: Isoc IN. requests queued from device till they are reaped. + */ +typedef struct vboxusb_isoc_req_t +{ + mblk_t *pMsg; /* Pointer to the data buffer */ + uint32_t cIsocPkts; /* Number of Isoc pkts */ + VUSBISOC_PKT_DESC aIsocPkts[8]; /* Array of Isoc pkt descriptors */ + list_node_t hListLink; +} vboxusb_isoc_req_t; + +/** + * VBOXUSB_URB_STATE: Internal USB URB state. + */ +typedef enum VBOXUSB_URB_STATE +{ + VBOXUSB_URB_STATE_FREE = 0x00, + VBOXUSB_URB_STATE_INFLIGHT = 0x04, + VBOXUSB_URB_STATE_LANDED = 0x08 +} VBOXUSB_URB_STATE; + +/** + * vboxusb_urb_t: kernel URB representation. + */ +typedef struct vboxusb_urb_t +{ + void *pvUrbR3; /* Userspace URB address (untouched, returned while reaping) */ + uint8_t bEndpoint; /* Endpoint address */ + VUSBXFERTYPE enmType; /* Xfer type */ + VUSBDIRECTION enmDir; /* Xfer direction */ + VUSBSTATUS enmStatus; /* URB status */ + bool fShortOk; /* Whether receiving less data than requested is acceptable */ + RTR3PTR pvDataR3; /* Userspace address of the original data buffer */ + size_t cbDataR3; /* Size of the data buffer */ + mblk_t *pMsg; /* Pointer to the data buffer */ + uint32_t cIsocPkts; /* Number of Isoc pkts */ + VUSBISOC_PKT_DESC aIsocPkts[8]; /* Array of Isoc pkt descriptors */ + VBOXUSB_URB_STATE enmState; /* URB state (free/in-flight/landed). */ + struct vboxusb_state_t *pState; /* Pointer to the device instance */ + list_node_t hListLink; /* List node link handle */ +} vboxusb_urb_t; + +/** + * vboxusb_power_t: Per Device Power Management info. + */ +typedef struct vboxusb_power_t +{ + uint_t PowerStates; /* Bit mask of the power states */ + int PowerBusy; /* Busy reference counter */ + bool fPowerWakeup; /* Whether remote power wakeup is enabled */ + bool fPowerRaise; /* Whether to raise the power level */ + uint8_t PowerLevel; /* Current power level */ +} vboxusb_power_t; + +/** + * vboxusb_state_t: Per Device instance state info. + */ +typedef struct vboxusb_state_t +{ + dev_info_t *pDip; /* Per instance device info. */ + usb_client_dev_data_t *pDevDesc; /* Parsed & complete device descriptor */ + uint8_t DevState; /* Current USB Device state */ + bool fDefaultPipeOpen; /* Whether the device (default control pipe) is closed */ + bool fPollPending; /* Whether the userland process' poll is pending */ + kmutex_t Mtx; /* Mutex state protection */ + usb_serialization_t StateMulti; /* State serialization */ + size_t cbMaxBulkXfer; /* Maximum bulk xfer size */ + vboxusb_ep_t aEps[VBOXUSB_MAX_ENDPOINTS]; /* Array of all endpoints structures */ + list_t hFreeUrbs; /* List of free URBs */ + list_t hInflightUrbs; /* List of inflight URBs */ + list_t hLandedUrbs; /* List of landed URBs */ + uint32_t cFreeUrbs; /* Number of free URBs */ + uint32_t cInflightUrbs; /* Number of inflight URBs */ + uint32_t cLandedUrbs; /* Number of landed URBs */ + pollhead_t PollHead; /* Handle to pollhead for waking polling processes */ + RTPROCESS Process; /* The process (pid) of the user session */ + VBOXUSBREQ_CLIENT_INFO ClientInfo; /* Registration data */ + vboxusb_power_t *pPower; /* Power Management */ + char szMfg[255]; /* Parsed manufacturer string */ + char szProduct[255]; /* Parsed product string */ +} vboxusb_state_t; +AssertCompileMemberSize(vboxusb_state_t, szMfg, USB_MAXSTRINGLEN); +AssertCompileMemberSize(vboxusb_state_t, szProduct, USB_MAXSTRINGLEN); + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +LOCAL int vboxUsbSolarisInitEp(vboxusb_state_t *pState, usb_ep_data_t *pEpData); +LOCAL int vboxUsbSolarisInitEpsForCfg(vboxusb_state_t *pState); +LOCAL int vboxUsbSolarisInitEpsForIfAlt(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt); +LOCAL void vboxUsbSolarisDestroyAllEps(vboxusb_state_t *pState); +LOCAL void vboxUsbSolarisDestroyEp(vboxusb_state_t *pState, vboxusb_ep_t *pEp); +LOCAL void vboxUsbSolarisCloseAllPipes(vboxusb_state_t *pState, bool fControlPipe); +LOCAL int vboxUsbSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp); +LOCAL void vboxUsbSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp); +LOCAL int vboxUsbSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb); +LOCAL void vboxUsbSolarisCtrlXferCompleted(usb_pipe_handle_t pPipe, usb_ctrl_req_t *pReq); +LOCAL int vboxUsbSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *purb); +LOCAL void vboxUsbSolarisBulkXferCompleted(usb_pipe_handle_t pPipe, usb_bulk_req_t *pReq); +LOCAL int vboxUsbSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb); +LOCAL void vboxUsbSolarisIntrXferCompleted(usb_pipe_handle_t pPipe, usb_intr_req_t *pReq); +LOCAL int vboxUsbSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb); +LOCAL void vboxUsbSolarisIsocInXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq); +LOCAL void vboxUsbSolarisIsocInXferError(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq); +LOCAL void vboxUsbSolarisIsocOutXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq); +LOCAL vboxusb_urb_t *vboxUsbSolarisGetIsocInUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq); +LOCAL vboxusb_urb_t *vboxUsbSolarisQueueUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg); +LOCAL VUSBSTATUS vboxUsbSolarisGetUrbStatus(usb_cr_t Status); +LOCAL void vboxUsbSolarisConcatMsg(vboxusb_urb_t *pUrb); +LOCAL void vboxUsbSolarisDeQueueUrb(vboxusb_urb_t *pUrb, int URBStatus); +LOCAL void vboxUsbSolarisNotifyComplete(vboxusb_state_t *pState); +LOCAL int vboxUsbSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf, + size_t *pcbDataOut); +LOCAL bool vboxUsbSolarisIsUSBDevice(dev_info_t *pDip); + +/** @name Device Operation Hooks + * @{ */ +LOCAL int vboxUsbSolarisSendUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode); +LOCAL int vboxUsbSolarisReapUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode); +LOCAL int vboxUsbSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint); +LOCAL int vboxUsbSolarisSetConfig(vboxusb_state_t *pState, uint8_t bCfgValue); +LOCAL int vboxUsbSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pCfgValue); +LOCAL int vboxUsbSolarisSetInterface(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt); +LOCAL int vboxUsbSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset); +LOCAL int vboxUsbSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint); +LOCAL int vboxUsbSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t bCfgValue); +/** @} */ + +/** @name Hotplug & Power Management Hooks + * @{ */ +LOCAL void vboxUsbSolarisNotifyUnplug(vboxusb_state_t *pState); +LOCAL int vboxUsbSolarisDeviceDisconnected(dev_info_t *pDip); +LOCAL int vboxUsbSolarisDeviceReconnected(dev_info_t *pDip); + +LOCAL int vboxUsbSolarisInitPower(vboxusb_state_t *pState); +LOCAL void vboxUsbSolarisDestroyPower(vboxusb_state_t *pState); +LOCAL int vboxUsbSolarisDeviceSuspend(vboxusb_state_t *pState); +LOCAL void vboxUsbSolarisDeviceResume(vboxusb_state_t *pState); +LOCAL void vboxUsbSolarisDeviceRestore(vboxusb_state_t *pState); +LOCAL void vboxUsbSolarisPowerBusy(vboxusb_state_t *pState); +LOCAL void vboxUsbSolarisPowerIdle(vboxusb_state_t *pState); +/** @} */ + +/** @name Monitor Hooks + * @{ */ +int VBoxUSBMonSolarisRegisterClient(dev_info_t *pClientDip, PVBOXUSB_CLIENT_INFO pClientInfo); +int VBoxUSBMonSolarisUnregisterClient(dev_info_t *pClientDip); +/** @} */ + +/** @name Callbacks from Monitor + * @{ */ +LOCAL int vboxUsbSolarisSetConsumerCredentials(RTPROCESS Process, int Instance, void *pvReserved); +/** @} */ + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Global list of all device instances. */ +static void *g_pVBoxUSBSolarisState; + +/** The default endpoint descriptor */ +static usb_ep_descr_t g_VBoxUSBSolarisDefaultEpDesc = { 7, 5, 0, USB_EP_ATTR_CONTROL, 8, 0 }; + +/** Size of the usb_ep_data_t struct (used to index into data). */ +static size_t g_cbUsbEpData = ~0UL; + +/** The offset of usb_ep_data_t::ep_desc. */ +static size_t g_offUsbEpDataDescr = ~0UL; + + +#ifdef LOG_ENABLED +/** + * Gets the description of an Endpoint's transfer type. + * + * @param pEp The Endpoint. + * @returns The type of the Endpoint. + */ +static const char *vboxUsbSolarisEpType(vboxusb_ep_t *pEp) +{ + uint8_t uType = VBOXUSB_XFER_TYPE(pEp); + switch (uType) + { + case 0: return "CTRL"; + case 1: return "ISOC"; + case 2: return "BULK"; + default: return "INTR"; + } +} + + +/** + * Gets the description of an Endpoint's direction. + * + * @param pEp The Endpoint. + * @returns The direction of the Endpoint. + */ +static const char *vboxUsbSolarisEpDir(vboxusb_ep_t *pEp) +{ + return VBOXUSB_XFER_DIR(pEp) == USB_EP_DIR_IN ? "IN " : "OUT"; +} +#endif + + +/** + * Caches device strings from the parsed device descriptors. + * + * @param pState The USB device instance. + * + * @remarks Must only be called after usb_get_dev_data(). + */ +static void vboxUsbSolarisGetDeviceStrings(vboxusb_state_t *pState) +{ + AssertReturnVoid(pState); + AssertReturnVoid(pState->pDevDesc); + + if (pState->pDevDesc->dev_product) + strlcpy(&pState->szMfg[0], pState->pDevDesc->dev_mfg, sizeof(pState->szMfg)); + else + strlcpy(&pState->szMfg[0], "<Unknown Manufacturer>", sizeof(pState->szMfg)); + + if (pState->pDevDesc->dev_product) + strlcpy(&pState->szProduct[0], pState->pDevDesc->dev_product, sizeof(pState->szProduct)); + else + strlcpy(&pState->szProduct[0], "<Unnamed USB device>", sizeof(pState->szProduct)); +} + + +/** + * Queries the necessary symbols at runtime. + * + * @returns VBox status code. + */ +LOCAL int vboxUsbSolarisQuerySymbols(void) +{ + RTDBGKRNLINFO hKrnlDbgInfo; + int rc = RTR0DbgKrnlInfoOpen(&hKrnlDbgInfo, 0 /* fFlags */); + if (RT_SUCCESS(rc)) + { + /* + * Query and sanitize the size of usb_ep_data_t struct. + */ + size_t cbPrevUsbEpData = g_cbUsbEpData; + rc = RTR0DbgKrnlInfoQuerySize(hKrnlDbgInfo, "usba", "usb_ep_data_t", &g_cbUsbEpData); + if (RT_FAILURE(rc)) + { + LogRel(("Failed to query size of \"usb_ep_data_t\" in the \"usba\" module, rc=%Rrc\n", rc)); + return rc; + } + if (g_cbUsbEpData > _4K) + { + LogRel(("Size of \"usb_ep_data_t\" (%u bytes) seems implausible, too paranoid to continue\n", g_cbUsbEpData)); + return VERR_MISMATCH; + } + + /* + * Query and sanitizie the offset of usb_ep_data_t::ep_descr. + */ + size_t offPrevUsbEpDataDescr = g_offUsbEpDataDescr; + rc = RTR0DbgKrnlInfoQueryMember(hKrnlDbgInfo, "usba", "usb_ep_data_t", "ep_descr", &g_offUsbEpDataDescr); + if (RT_FAILURE(rc)) + { + LogRel(("Failed to query offset of usb_ep_data_t::ep_descr, rc=%Rrc\n", rc)); + return rc; + } + if (g_offUsbEpDataDescr > _4K - sizeof(usb_ep_descr_t)) + { + LogRel(("Offset of \"ep_desrc\" (%u) seems implausible, too paranoid to continue\n", g_offUsbEpDataDescr)); + return VERR_MISMATCH; + } + + /* + * Log only when it changes / first time, since _init() seems to be called often (e.g. on failed attaches). + * cmn_err, CE_CONT and '!' is used to not show the message on console during boot each time. + */ + if ( cbPrevUsbEpData != g_cbUsbEpData + || offPrevUsbEpDataDescr != g_offUsbEpDataDescr) + { + cmn_err(CE_CONT, "!usba_ep_data_t is %lu bytes\n", g_cbUsbEpData); + cmn_err(CE_CONT, "!usba_ep_data_t::ep_descr @ 0x%lx (%ld)\n", g_offUsbEpDataDescr, g_offUsbEpDataDescr); + } + + RTR0DbgKrnlInfoRelease(hKrnlDbgInfo); + } +} + + +/** + * Kernel entry points + */ +int _init(void) +{ + LogFunc((DEVICE_NAME ": _init\n")); + + /* + * Prevent module autounloading. + */ + modctl_t *pModCtl = mod_getctl(&g_VBoxUSBSolarisModLinkage); + if (pModCtl) + pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD; + else + LogRel((DEVICE_NAME ": _init: failed to disable autounloading!\n")); + + /* + * Initialize IPRT R0 driver, which internally calls OS-specific r0 init. + */ + int rc = RTR0Init(0); + if (RT_SUCCESS(rc)) + { + rc = vboxUsbSolarisQuerySymbols(); + if (RT_FAILURE(rc)) + { + RTR0Term(); + return EINVAL; + } + + rc = ddi_soft_state_init(&g_pVBoxUSBSolarisState, sizeof(vboxusb_state_t), 4 /* pre-alloc */); + if (!rc) + { + rc = mod_install(&g_VBoxUSBSolarisModLinkage); + if (!rc) + return rc; + + LogRel((DEVICE_NAME ": _init: mod_install failed! rc=%d\n", rc)); + ddi_soft_state_fini(&g_pVBoxUSBSolarisState); + } + else + LogRel((DEVICE_NAME ": _init: failed to initialize soft state\n")); + + RTR0Term(); + } + else + LogRel((DEVICE_NAME ": _init: RTR0Init failed! rc=%d\n", rc)); + return RTErrConvertToErrno(rc); +} + + +int _fini(void) +{ + int rc; + + LogFunc((DEVICE_NAME ": _fini\n")); + + rc = mod_remove(&g_VBoxUSBSolarisModLinkage); + if (!rc) + { + ddi_soft_state_fini(&g_pVBoxUSBSolarisState); + RTR0Term(); + } + + return rc; +} + + +int _info(struct modinfo *pModInfo) +{ + LogFunc((DEVICE_NAME ": _info\n")); + + return mod_info(&g_VBoxUSBSolarisModLinkage, pModInfo); +} + + +/** + * Attach entry point, to attach a device to the system or resume it. + * + * @param pDip The module structure instance. + * @param enmCmd Attach type (ddi_attach_cmd_t) + * + * @returns Solaris error code. + */ +int VBoxUSBSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisAttach: pDip=%p enmCmd=%d\n", pDip, enmCmd)); + + int rc; + int instance = ddi_get_instance(pDip); + vboxusb_state_t *pState = NULL; + + switch (enmCmd) + { + case DDI_ATTACH: + { + rc = ddi_soft_state_zalloc(g_pVBoxUSBSolarisState, instance); + if (rc == DDI_SUCCESS) + { + pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (RT_LIKELY(pState)) + { + pState->pDip = pDip; + pState->pDevDesc = NULL; + pState->fPollPending = false; + pState->cInflightUrbs = 0; + pState->cFreeUrbs = 0; + pState->cLandedUrbs = 0; + pState->Process = NIL_RTPROCESS; + pState->pPower = NULL; + bzero(pState->aEps, sizeof(pState->aEps)); + list_create(&pState->hFreeUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink)); + list_create(&pState->hInflightUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink)); + list_create(&pState->hLandedUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink)); + + /* + * There is a bug in usb_client_attach() as of Nevada 120 which panics when we bind to + * a non-USB device. So check if we are really binding to a USB device or not. + */ + if (vboxUsbSolarisIsUSBDevice(pState->pDip)) + { + /* + * Here starts the USB specifics. + */ + rc = usb_client_attach(pState->pDip, USBDRV_VERSION, 0); + if (rc == USB_SUCCESS) + { + pState->fDefaultPipeOpen = true; + + /* + * Parse out the entire descriptor. + */ + rc = usb_get_dev_data(pState->pDip, &pState->pDevDesc, USB_PARSE_LVL_ALL, 0 /* Unused */); + if (rc == USB_SUCCESS) + { + /* + * Cache some device descriptor strings. + */ + vboxUsbSolarisGetDeviceStrings(pState); +#ifdef DEBUG_ramshankar + usb_print_descr_tree(pState->pDip, pState->pDevDesc); +#endif + + /* + * Initialize state locks. + */ + mutex_init(&pState->Mtx, NULL, MUTEX_DRIVER, pState->pDevDesc->dev_iblock_cookie); + pState->StateMulti = usb_init_serialization(pState->pDip, USB_INIT_SER_CHECK_SAME_THREAD); + + /* + * Get maximum bulk transfer size supported by the HCD. + */ + rc = usb_pipe_get_max_bulk_transfer_size(pState->pDip, &pState->cbMaxBulkXfer); + if (rc == USB_SUCCESS) + { + Log((DEVICE_NAME ": VBoxUSBSolarisAttach: cbMaxBulkXfer=%d\n", pState->cbMaxBulkXfer)); + + /* + * Initialize the default endpoint. + */ + rc = vboxUsbSolarisInitEp(pState, NULL /* pEp */); + if (RT_SUCCESS(rc)) + { + /* + * Set the device state. + */ + pState->DevState = USB_DEV_ONLINE; + + /* + * Initialize power management for the device. + */ + rc = vboxUsbSolarisInitPower(pState); + if (RT_SUCCESS(rc)) + { + /* + * Initialize endpoints for the current config. + */ + rc = vboxUsbSolarisInitEpsForCfg(pState); + AssertRC(rc); + + /* + * Publish the minor node. + */ + rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME, S_IFCHR, instance, DDI_PSEUDO, 0, + "none", "none", 0666); + if (RT_LIKELY(rc == DDI_SUCCESS)) + { + /* + * Register hotplug callbacks. + */ + rc = usb_register_hotplug_cbs(pState->pDip, &vboxUsbSolarisDeviceDisconnected, + &vboxUsbSolarisDeviceReconnected); + if (RT_LIKELY(rc == USB_SUCCESS)) + { + /* + * Register with our monitor driver. + */ + bzero(&pState->ClientInfo, sizeof(pState->ClientInfo)); + char szDevicePath[MAXPATHLEN]; + ddi_pathname(pState->pDip, szDevicePath); + RTStrPrintf(pState->ClientInfo.szClientPath, + sizeof(pState->ClientInfo.szClientPath), + "/devices%s:%s", szDevicePath, DEVICE_NAME); + RTStrPrintf(pState->ClientInfo.szDeviceIdent, + sizeof(pState->ClientInfo.szDeviceIdent), + "%#x:%#x:%d:%s", + pState->pDevDesc->dev_descr->idVendor, + pState->pDevDesc->dev_descr->idProduct, + pState->pDevDesc->dev_descr->bcdDevice, szDevicePath); + pState->ClientInfo.Instance = instance; + pState->ClientInfo.pfnSetConsumerCredentials = &vboxUsbSolarisSetConsumerCredentials; + rc = VBoxUSBMonSolarisRegisterClient(pState->pDip, &pState->ClientInfo); + if (RT_SUCCESS(rc)) + { +#if 0 + LogRel((DEVICE_NAME ": Captured %s %s (Ident=%s)\n", pState->szMfg, + pState->szProduct, pState->ClientInfo.szDeviceIdent)); +#else + /* Until IPRT R0 logging is fixed. See @bugref{6657#c7} */ + cmn_err(CE_CONT, "Captured %s %s (Ident=%s)\n", pState->szMfg, + pState->szProduct, pState->ClientInfo.szDeviceIdent); +#endif + return DDI_SUCCESS; + } + + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisRegisterClient failed! rc=%d " + "path=%s instance=%d\n", rc, pState->ClientInfo.szClientPath, + instance)); + + usb_unregister_hotplug_cbs(pState->pDip); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to register hotplug callbacks! rc=%d\n", rc)); + + ddi_remove_minor_node(pState->pDip, NULL); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: ddi_create_minor_node failed! rc=%d\n", rc)); + + mutex_enter(&pState->Mtx); + vboxUsbSolarisDestroyPower(pState); + mutex_exit(&pState->Mtx); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to init power management! rc=%d\n", rc)); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: vboxUsbSolarisInitEp failed! rc=%d\n", rc)); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: usb_pipe_get_max_bulk_transfer_size failed! rc=%d\n", rc)); + + usb_fini_serialization(pState->StateMulti); + mutex_destroy(&pState->Mtx); + usb_free_dev_data(pState->pDip, pState->pDevDesc); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to get device descriptor. rc=%d\n", rc)); + + usb_client_detach(pState->pDip, NULL); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: usb_client_attach failed! rc=%d\n", rc)); + } + else + { + /* This would appear on every boot if it were LogRel() */ + Log((DEVICE_NAME ": VBoxUSBSolarisAttach: Not a USB device\n")); + } + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to get soft state\n", sizeof(*pState))); + + ddi_soft_state_free(g_pVBoxUSBSolarisState, instance); + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: Failed to alloc soft state. rc=%d\n", rc)); + + return DDI_FAILURE; + } + + case DDI_RESUME: + { + pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (RT_UNLIKELY(!pState)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisAttach: DDI_RESUME failed to get soft state on detach\n")); + return DDI_FAILURE; + } + + vboxUsbSolarisDeviceResume(pState); + return DDI_SUCCESS; + } + + default: + return DDI_FAILURE; + } +} + + +/** + * Detach entry point, to detach a device to the system or suspend it. + * + * @param pDip The module structure instance. + * @param enmCmd Attach type (ddi_attach_cmd_t) + * + * @returns Solaris error code. + */ +int VBoxUSBSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisDetach: pDip=%p enmCmd=%d\n", pDip, enmCmd)); + + int instance = ddi_get_instance(pDip); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (RT_UNLIKELY(!pState)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisDetach: Failed to get soft state on detach\n")); + return DDI_FAILURE; + } + + switch (enmCmd) + { + case DDI_DETACH: + { + /* + * At this point it must be assumed that the default control pipe has + * already been closed by userland (via VBoxUSBSolarisClose() entry point). + * Once it's closed we can no longer open or reference the device here. + */ + + /* + * Notify userland if any that we're gone (while resetting device held by us). + */ + mutex_enter(&pState->Mtx); + pState->DevState = USB_DEV_DISCONNECTED; + vboxUsbSolarisNotifyUnplug(pState); + mutex_exit(&pState->Mtx); + + + /* + * Unregister hotplug callback events first without holding the mutex as the callbacks + * would otherwise block on the mutex. + */ + usb_unregister_hotplug_cbs(pDip); + + /* + * Serialize: paranoid; drain other driver activity. + */ + usb_serialize_access(pState->StateMulti, USB_WAIT, 0 /* timeout */); + usb_release_access(pState->StateMulti); + mutex_enter(&pState->Mtx); + + /* + * Close all pipes. + */ + vboxUsbSolarisCloseAllPipes(pState, true /* ControlPipe */); + Assert(!pState->fDefaultPipeOpen); + + /* + * Deinitialize power, destroy all endpoints. + */ + vboxUsbSolarisDestroyPower(pState); + vboxUsbSolarisDestroyAllEps(pState); + + /* + * Free up all URB lists. + */ + vboxusb_urb_t *pUrb = NULL; + while ((pUrb = list_remove_head(&pState->hFreeUrbs)) != NULL) + { + if (pUrb->pMsg) + freemsg(pUrb->pMsg); + RTMemFree(pUrb); + } + while ((pUrb = list_remove_head(&pState->hInflightUrbs)) != NULL) + { + if (pUrb->pMsg) + freemsg(pUrb->pMsg); + RTMemFree(pUrb); + } + while ((pUrb = list_remove_head(&pState->hLandedUrbs)) != NULL) + { + if (pUrb->pMsg) + freemsg(pUrb->pMsg); + RTMemFree(pUrb); + } + pState->cFreeUrbs = 0; + pState->cLandedUrbs = 0; + pState->cInflightUrbs = 0; + list_destroy(&pState->hFreeUrbs); + list_destroy(&pState->hInflightUrbs); + list_destroy(&pState->hLandedUrbs); + + /* + * Destroy locks, free up descriptor and detach from USBA. + */ + mutex_exit(&pState->Mtx); + usb_fini_serialization(pState->StateMulti); + mutex_destroy(&pState->Mtx); + + usb_free_dev_data(pState->pDip, pState->pDevDesc); + usb_client_detach(pState->pDip, NULL); + + /* + * Deregister with our Monitor driver. + */ + VBoxUSBMonSolarisUnregisterClient(pState->pDip); + + ddi_remove_minor_node(pState->pDip, NULL); + +#if 0 + LogRel((DEVICE_NAME ": Released %s %s (Ident=%s)\n", pState->szMfg, pState->szProduct, + pState->ClientInfo.szDeviceIdent)); +#else + /* Until IPRT R0 logging is fixed. See @bugref{6657#c7} */ + cmn_err(CE_CONT, "Released %s %s (Ident=%s)\n", pState->szMfg, pState->szProduct, pState->ClientInfo.szDeviceIdent); +#endif + + ddi_soft_state_free(g_pVBoxUSBSolarisState, instance); + pState = NULL; + return DDI_SUCCESS; + } + + case DDI_SUSPEND: + { + int rc = vboxUsbSolarisDeviceSuspend(pState); + if (RT_SUCCESS(rc)) + return DDI_SUCCESS; + + return DDI_FAILURE; + } + + default: + return DDI_FAILURE; + } +} + + +/** + * Info entry point, called by solaris kernel for obtaining driver info. + * + * @param pDip The module structure instance (do not use). + * @param enmCmd Information request type. + * @param pvArg Type specific argument. + * @param ppvResult Where to store the requested info. + * + * @returns Solaris error code. + */ +int VBoxUSBSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppvResult) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisGetInfo\n")); + + vboxusb_state_t *pState = NULL; + int instance = getminor((dev_t)pvArg); + + switch (enmCmd) + { + case DDI_INFO_DEVT2DEVINFO: + { + /* + * One is to one mapping of instance & minor number as we publish only one minor node per device. + */ + pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (pState) + { + *ppvResult = (void *)pState->pDip; + return DDI_SUCCESS; + } + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisGetInfo: Failed to get device state\n")); + return DDI_FAILURE; + } + + case DDI_INFO_DEVT2INSTANCE: + { + *ppvResult = (void *)(uintptr_t)instance; + return DDI_SUCCESS; + } + + default: + return DDI_FAILURE; + } +} + + +/** + * Callback invoked from the VirtualBox USB Monitor driver when a VM process + * tries to access this USB client instance. + * + * This determines which VM process will be allowed to open and access this USB + * device. + * + * @returns VBox status code. + * + * @param Process The VM process performing the client info. query. + * @param Instance This client instance (the one set while we register + * ourselves to the Monitor driver) + * @param pvReserved Reserved for future, unused. + */ +LOCAL int vboxUsbSolarisSetConsumerCredentials(RTPROCESS Process, int Instance, void *pvReserved) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisSetConsumerCredentials: Process=%u Instance=%d\n", Process, Instance)); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, Instance); + if (!pState) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSetConsumerCredentials: Failed to get device state for instance %d\n", Instance)); + return VERR_INVALID_STATE; + } + + int rc = VINF_SUCCESS; + mutex_enter(&pState->Mtx); + + if (pState->Process == NIL_RTPROCESS) + pState->Process = Process; + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSetConsumerCredentials: Failed! Process %u already has client open\n", + pState->Process)); + rc = VERR_RESOURCE_BUSY; + } + + mutex_exit(&pState->Mtx); + + return rc; +} + + +int VBoxUSBSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisOpen: pDev=%p fFlag=%d fType=%d pCred=%p\n", pDev, fFlag, fType, pCred)); + + /* + * Verify we are being opened as a character device + */ + if (fType != OTYP_CHR) + return EINVAL; + + /* + * One is to one mapping. (Minor<=>Instance). + */ + int instance = getminor((dev_t)*pDev); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (!pState) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisOpen: Failed to get device state for instance %d\n", instance)); + return ENXIO; + } + + mutex_enter(&pState->Mtx); + + /* + * Only one user process can open a device instance at a time. + */ + if (pState->Process != RTProcSelf()) + { + if (pState->Process == NIL_RTPROCESS) + LogRel((DEVICE_NAME ": VBoxUSBSolarisOpen: No prior information about authorized process\n")); + else + LogRel((DEVICE_NAME ": VBoxUSBSolarisOpen: Process %u is already using this device instance\n", pState->Process)); + + mutex_exit(&pState->Mtx); + return EPERM; + } + + mutex_exit(&pState->Mtx); + + NOREF(fFlag); + NOREF(pCred); + + return 0; +} + + +int VBoxUSBSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisClose: Dev=%d fFlag=%d fType=%d pCred=%p\n", Dev, fFlag, fType, pCred)); + + int instance = getminor((dev_t)Dev); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (RT_UNLIKELY(!pState)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisClose: Failed to get device state for instance %d\n", instance)); + return ENXIO; + } + + mutex_enter(&pState->Mtx); + pState->fPollPending = false; + pState->Process = NIL_RTPROCESS; + mutex_exit(&pState->Mtx); + + return 0; +} + + +int VBoxUSBSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisRead\n")); + return ENOTSUP; +} + + +int VBoxUSBSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisWrite\n")); + return ENOTSUP; +} + + +int VBoxUSBSolarisPoll(dev_t Dev, short fEvents, int fAnyYet, short *pReqEvents, struct pollhead **ppPollHead) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisPoll: Dev=%d fEvents=%d fAnyYet=%d pReqEvents=%p\n", Dev, fEvents, fAnyYet, pReqEvents)); + + /* + * Get the device state (one to one mapping). + */ + int instance = getminor((dev_t)Dev); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (RT_UNLIKELY(!pState)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisPoll: No state data for %d\n", instance)); + return ENXIO; + } + + mutex_enter(&pState->Mtx); + + /* + * Disconnect event (POLLHUP) is invalid in "fEvents". + */ + if (pState->DevState == USB_DEV_DISCONNECTED) + *pReqEvents |= POLLHUP; + else if (pState->cLandedUrbs) + *pReqEvents |= POLLIN; + else + { + *pReqEvents = 0; + if (!fAnyYet) + { + *ppPollHead = &pState->PollHead; + pState->fPollPending = true; + } + } + + mutex_exit(&pState->Mtx); + + return 0; +} + + +int VBoxUSBSolarisPower(dev_info_t *pDip, int Component, int Level) +{ + LogFunc((DEVICE_NAME ": VBoxUSBSolarisPower: pDip=%p Component=%d Level=%d\n", pDip, Component, Level)); + + int instance = ddi_get_instance(pDip); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (RT_UNLIKELY(!pState)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisPower: Failed! State Gone\n")); + return DDI_FAILURE; + } + + if (!pState->pPower) + return DDI_SUCCESS; + + usb_serialize_access(pState->StateMulti, USB_WAIT, 0); + mutex_enter(&pState->Mtx); + + int rc = USB_FAILURE; + if (pState->DevState == USB_DEV_ONLINE) + { + /* + * Check if we are transitioning to a valid power state. + */ + if (!USB_DEV_PWRSTATE_OK(pState->pPower->PowerStates, Level)) + { + switch (Level) + { + case USB_DEV_OS_PWR_OFF: + { + if (pState->pPower->PowerBusy) + break; + + /* + * USB D3 command. + */ + pState->pPower->PowerLevel = USB_DEV_OS_PWR_OFF; + mutex_exit(&pState->Mtx); + rc = USB_SUCCESS; /* usb_set_device_pwrlvl3(pDip); */ + mutex_enter(&pState->Mtx); + break; + } + + case USB_DEV_OS_FULL_PWR: + { + /* + * Can happen during shutdown of the OS. + */ + pState->pPower->PowerLevel = USB_DEV_OS_FULL_PWR; + mutex_exit(&pState->Mtx); + rc = USB_SUCCESS; /* usb_set_device_pwrlvl0(pDip); */ + mutex_enter(&pState->Mtx); + break; + } + + default: /* Power levels 1, 2 not implemented */ + break; + } + } + else + Log((DEVICE_NAME ": VBoxUSBSolarisPower: USB_DEV_PWRSTATE_OK failed\n")); + } + else + rc = USB_SUCCESS; + + mutex_exit(&pState->Mtx); + usb_release_access(pState->StateMulti); + return rc == USB_SUCCESS ? DDI_SUCCESS : DDI_FAILURE; +} + + +/** @def IOCPARM_LEN + * Gets the length from the ioctl number. + * This is normally defined by sys/ioccom.h on BSD systems... + */ +#ifndef IOCPARM_LEN +# define IOCPARM_LEN(Code) (((Code) >> 16) & IOCPARM_MASK) +#endif + +int VBoxUSBSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal) +{ + /* LogFunc((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg)); */ + + /* + * Get the device state (one to one mapping). + */ + int instance = getminor((dev_t)Dev); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + if (RT_UNLIKELY(!pState)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: No state data for %d\n", instance)); + return EINVAL; + } + + /* + * Read the request wrapper. + */ + VBOXUSBREQ ReqWrap; + if (IOCPARM_LEN(Cmd) != sizeof(ReqWrap)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd), + sizeof(ReqWrap))); + return ENOTTY; + } + + int rc = ddi_copyin((void *)pArg, &ReqWrap, sizeof(ReqWrap), Mode); + if (RT_UNLIKELY(rc)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d\n", pArg, Cmd, rc)); + return EINVAL; + } + + if (ReqWrap.u32Magic != VBOXUSB_MAGIC) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Bad magic %#x; pArg=%p Cmd=%d\n", ReqWrap.u32Magic, pArg, Cmd)); + return EINVAL; + } + if (RT_UNLIKELY( ReqWrap.cbData == 0 + || ReqWrap.cbData > _1M*16)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Bad size %#x; pArg=%p Cmd=%d\n", ReqWrap.cbData, pArg, Cmd)); + return EINVAL; + } + + /* + * Read the request. + */ + void *pvBuf = RTMemTmpAlloc(ReqWrap.cbData); + if (RT_UNLIKELY(!pvBuf)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes\n", ReqWrap.cbData)); + return ENOMEM; + } + + rc = ddi_copyin((void *)(uintptr_t)ReqWrap.pvDataR3, pvBuf, ReqWrap.cbData, Mode); + if (RT_UNLIKELY(rc)) + { + RTMemTmpFree(pvBuf); + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyin failed! pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, rc)); + return EFAULT; + } + if (RT_UNLIKELY( ReqWrap.cbData == 0 + || pvBuf == NULL)) + { + RTMemTmpFree(pvBuf); + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Invalid request! pvBuf=%p cbData=%d\n", pvBuf, ReqWrap.cbData)); + return EINVAL; + } + + /* + * Process the IOCtl. + */ + size_t cbDataOut = 0; + rc = vboxUsbSolarisProcessIOCtl(Cmd, pState, Mode, &ReqWrap, pvBuf, &cbDataOut); + ReqWrap.rc = rc; + rc = 0; + + if (RT_UNLIKELY(cbDataOut > ReqWrap.cbData)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: Too much output data %d expected %d Truncating!\n", cbDataOut, + ReqWrap.cbData)); + cbDataOut = ReqWrap.cbData; + } + + ReqWrap.cbData = cbDataOut; + + /* + * Copy VBOXUSBREQ back to userspace (which contains rc for USB operation). + */ + rc = ddi_copyout(&ReqWrap, (void *)pArg, sizeof(ReqWrap), Mode); + if (RT_LIKELY(!rc)) + { + /* + * Copy payload (if any) back to userspace. + */ + if (cbDataOut > 0) + { + rc = ddi_copyout(pvBuf, (void *)(uintptr_t)ReqWrap.pvDataR3, cbDataOut, Mode); + if (RT_UNLIKELY(rc)) + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyout failed! pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, + Cmd, rc)); + rc = EFAULT; + } + } + } + else + { + LogRel((DEVICE_NAME ": VBoxUSBSolarisIOCtl: ddi_copyout(1)failed! pReqWrap=%p pArg=%p Cmd=%d. rc=%d\n", &ReqWrap, pArg, + Cmd, rc)); + rc = EFAULT; + } + + *pVal = rc; + RTMemTmpFree(pvBuf); + return rc; +} + + +/** + * IOCtl processor for user to kernel and kernel to kernel communication. + * + * @returns VBox status code. + * + * @param iFunction The requested function. + * @param pvState The USB device instance. + * @param Mode The IOCtl mode. + * @param pUSBReq Pointer to the VBOXUSB request. + * @param pvBuf Pointer to the ring-3 URB. + * @param pcbDataOut Where to store the IOCtl OUT data size. + */ +LOCAL int vboxUsbSolarisProcessIOCtl(int iFunction, void *pvState, int Mode, PVBOXUSBREQ pUSBReq, void *pvBuf, + size_t *pcbDataOut) +{ + /* LogFunc((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: iFunction=%d pvState=%p pUSBReq=%p\n", iFunction, pvState, pUSBReq)); */ + + AssertPtrReturn(pvState, VERR_INVALID_PARAMETER); + vboxusb_state_t *pState = (vboxusb_state_t *)pvState; + size_t cbData = pUSBReq->cbData; + int rc; + +#define CHECKRET_MIN_SIZE(mnemonic, cbMin) \ + do { \ + if (cbData < (cbMin)) \ + { \ + LogRel((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: " mnemonic ": cbData=%#zx (%zu) min is %#zx (%zu)\n", \ + cbData, cbData, (size_t)(cbMin), (size_t)(cbMin))); \ + return VERR_BUFFER_OVERFLOW; \ + } \ + if ((cbMin) != 0 && !VALID_PTR(pvBuf)) \ + { \ + LogRel((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: " mnemonic ": Invalid pointer %p\n", pvBuf)); \ + return VERR_INVALID_PARAMETER; \ + } \ + } while (0) + + switch (iFunction) + { + case VBOXUSB_IOCTL_SEND_URB: + { + CHECKRET_MIN_SIZE("SEND_URB", sizeof(VBOXUSBREQ_URB)); + + PVBOXUSBREQ_URB pUrbReq = (PVBOXUSBREQ_URB)pvBuf; + rc = vboxUsbSolarisSendUrb(pState, pUrbReq, Mode); + *pcbDataOut = 0; + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: SEND_URB returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_REAP_URB: + { + CHECKRET_MIN_SIZE("REAP_URB", sizeof(VBOXUSBREQ_URB)); + + PVBOXUSBREQ_URB pUrbReq = (PVBOXUSBREQ_URB)pvBuf; + rc = vboxUsbSolarisReapUrb(pState, pUrbReq, Mode); + *pcbDataOut = sizeof(VBOXUSBREQ_URB); + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: REAP_URB returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_CLEAR_EP: + { + CHECKRET_MIN_SIZE("CLEAR_EP", sizeof(VBOXUSBREQ_CLEAR_EP)); + + PVBOXUSBREQ_CLEAR_EP pClearEpReq = (PVBOXUSBREQ_CLEAR_EP)pvBuf; + rc = vboxUsbSolarisClearEndPoint(pState, pClearEpReq->bEndpoint); + *pcbDataOut = 0; + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: CLEAR_EP returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_SET_CONFIG: + { + CHECKRET_MIN_SIZE("SET_CONFIG", sizeof(VBOXUSBREQ_SET_CONFIG)); + + PVBOXUSBREQ_SET_CONFIG pSetCfgReq = (PVBOXUSBREQ_SET_CONFIG)pvBuf; + rc = vboxUsbSolarisSetConfig(pState, pSetCfgReq->bConfigValue); + *pcbDataOut = 0; + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: SET_CONFIG returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_SET_INTERFACE: + { + CHECKRET_MIN_SIZE("SET_INTERFACE", sizeof(VBOXUSBREQ_SET_INTERFACE)); + + PVBOXUSBREQ_SET_INTERFACE pSetInterfaceReq = (PVBOXUSBREQ_SET_INTERFACE)pvBuf; + rc = vboxUsbSolarisSetInterface(pState, pSetInterfaceReq->bInterface, pSetInterfaceReq->bAlternate); + *pcbDataOut = 0; + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: SET_INTERFACE returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_CLOSE_DEVICE: + { + CHECKRET_MIN_SIZE("CLOSE_DEVICE", sizeof(VBOXUSBREQ_CLOSE_DEVICE)); + + PVBOXUSBREQ_CLOSE_DEVICE pCloseDeviceReq = (PVBOXUSBREQ_CLOSE_DEVICE)pvBuf; + if ( pCloseDeviceReq->ResetLevel != VBOXUSB_RESET_LEVEL_REATTACH + || (Mode & FKIOCTL)) + { + rc = vboxUsbSolarisCloseDevice(pState, pCloseDeviceReq->ResetLevel); + } + else + { + /* Userland IOCtls are not allowed to perform a reattach of the device. */ + rc = VERR_NOT_SUPPORTED; + } + *pcbDataOut = 0; + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: CLOSE_DEVICE returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_ABORT_PIPE: + { + CHECKRET_MIN_SIZE("ABORT_PIPE", sizeof(VBOXUSBREQ_ABORT_PIPE)); + + PVBOXUSBREQ_ABORT_PIPE pAbortPipeReq = (PVBOXUSBREQ_ABORT_PIPE)pvBuf; + rc = vboxUsbSolarisAbortPipe(pState, pAbortPipeReq->bEndpoint); + *pcbDataOut = 0; + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: ABORT_PIPE returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_GET_CONFIG: + { + CHECKRET_MIN_SIZE("GET_CONFIG", sizeof(VBOXUSBREQ_GET_CONFIG)); + + PVBOXUSBREQ_GET_CONFIG pGetCfgReq = (PVBOXUSBREQ_GET_CONFIG)pvBuf; + rc = vboxUsbSolarisGetConfig(pState, &pGetCfgReq->bConfigValue); + *pcbDataOut = sizeof(VBOXUSBREQ_GET_CONFIG); + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: GET_CONFIG returned %d\n", rc)); + break; + } + + case VBOXUSB_IOCTL_GET_VERSION: + { + CHECKRET_MIN_SIZE("GET_VERSION", sizeof(VBOXUSBREQ_GET_VERSION)); + + PVBOXUSBREQ_GET_VERSION pGetVersionReq = (PVBOXUSBREQ_GET_VERSION)pvBuf; + pGetVersionReq->u32Major = VBOXUSB_VERSION_MAJOR; + pGetVersionReq->u32Minor = VBOXUSB_VERSION_MINOR; + *pcbDataOut = sizeof(VBOXUSBREQ_GET_VERSION); + rc = VINF_SUCCESS; + Log((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: GET_VERSION returned %d\n", rc)); + break; + } + + default: + { + LogRel((DEVICE_NAME ": vboxUsbSolarisProcessIOCtl: Unknown request %#x\n", iFunction)); + rc = VERR_NOT_SUPPORTED; + *pcbDataOut = 0; + break; + } + } + + pUSBReq->cbData = *pcbDataOut; + return rc; +} + + +/** + * Initializes device power management. + * + * @param pState The USB device instance. + * + * @returns VBox status code. + */ +LOCAL int vboxUsbSolarisInitPower(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisInitPower: pState=%p\n", pState)); + + int rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_ENABLE); + if (rc == USB_SUCCESS) + { + vboxusb_power_t *pPower = RTMemAllocZ(sizeof(vboxusb_power_t)); + if (RT_LIKELY(pPower)) + { + mutex_enter(&pState->Mtx); + pState->pPower = pPower; + pState->pPower->fPowerWakeup = false; + mutex_exit(&pState->Mtx); + + uint_t PowerStates; + rc = usb_create_pm_components(pState->pDip, &PowerStates); + if (rc == USB_SUCCESS) + { + pState->pPower->fPowerWakeup = true; + pState->pPower->PowerLevel = USB_DEV_OS_FULL_PWR; + pState->pPower->PowerStates = PowerStates; + + rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR); + + if (rc != DDI_SUCCESS) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisInitPower: Failed to raise power level usb(%#x,%#x)\n", + pState->pDevDesc->dev_descr->idVendor, pState->pDevDesc->dev_descr->idProduct)); + } + } + else + Log((DEVICE_NAME ": vboxUsbSolarisInitPower: Failed to create power components\n")); + + return VINF_SUCCESS; + } + else + rc = VERR_NO_MEMORY; + } + else + { + Log((DEVICE_NAME ": vboxUsbSolarisInitPower: Failed to enable remote wakeup, No PM!\n")); + rc = VINF_SUCCESS; + } + + return rc; +} + + +/** + * Destroys device power management. + * + * @param pState The USB device instance. + * @remarks Requires the device state mutex to be held. + * + * @returns VBox status code. + */ +LOCAL void vboxUsbSolarisDestroyPower(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDestroyPower: pState=%p\n", pState)); + + if (pState->pPower) + { + mutex_exit(&pState->Mtx); + vboxUsbSolarisPowerBusy(pState); + mutex_enter(&pState->Mtx); + + int rc = -1; + if ( pState->pPower->fPowerWakeup + && pState->DevState != USB_DEV_DISCONNECTED) + { + mutex_exit(&pState->Mtx); + rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR); + if (rc != DDI_SUCCESS) + Log((DEVICE_NAME ": vboxUsbSolarisDestroyPower: Raising power failed! rc=%d\n", rc)); + + rc = usb_handle_remote_wakeup(pState->pDip, USB_REMOTE_WAKEUP_DISABLE); + if (rc != DDI_SUCCESS) + Log((DEVICE_NAME ": vboxUsbSolarisDestroyPower: Failed to disable remote wakeup\n")); + } + else + mutex_exit(&pState->Mtx); + + rc = pm_lower_power(pState->pDip, 0 /* component */, USB_DEV_OS_PWR_OFF); + if (rc != DDI_SUCCESS) + Log((DEVICE_NAME ": vboxUsbSolarisDestroyPower: Lowering power failed! rc=%d\n", rc)); + + vboxUsbSolarisPowerIdle(pState); + mutex_enter(&pState->Mtx); + RTMemFree(pState->pPower); + pState->pPower = NULL; + } +} + + +/** + * Converts Solaris' USBA URB status to VBox's USB URB status. + * + * @param Status Solaris USBA USB URB status. + * + * @returns VBox USB URB status. + */ +LOCAL VUSBSTATUS vboxUsbSolarisGetUrbStatus(usb_cr_t Status) +{ + switch (Status) + { + case USB_CR_OK: return VUSBSTATUS_OK; + case USB_CR_CRC: return VUSBSTATUS_CRC; + case USB_CR_DEV_NOT_RESP: return VUSBSTATUS_DNR; + case USB_CR_DATA_UNDERRUN: return VUSBSTATUS_DATA_UNDERRUN; + case USB_CR_DATA_OVERRUN: return VUSBSTATUS_DATA_OVERRUN; + case USB_CR_STALL: return VUSBSTATUS_STALL; + /* + case USB_CR_BITSTUFFING: + case USB_CR_DATA_TOGGLE_MM: + case USB_CR_PID_CHECKFAILURE: + case USB_CR_UNEXP_PID: + case USB_CR_BUFFER_OVERRUN: + case USB_CR_BUFFER_UNDERRUN: + case USB_CR_TIMEOUT: + case USB_CR_NOT_ACCESSED: + case USB_CR_NO_RESOURCES: + case USB_CR_UNSPECIFIED_ERR: + case USB_CR_STOPPED_POLLING: + case USB_CR_PIPE_CLOSING: + case USB_CR_PIPE_RESET: + case USB_CR_NOT_SUPPORTED: + case USB_CR_FLUSHED: + case USB_CR_HC_HARDWARE_ERR: + */ + default: return VUSBSTATUS_INVALID; + } +} + + +/** + * Converts Solaris' USBA error code to VBox's error code. + * + * @param UsbRc Solaris USBA error code. + * + * @returns VBox error code. + */ +static int vboxUsbSolarisToVBoxRC(int UsbRc) +{ + switch (UsbRc) + { + case USB_SUCCESS: return VINF_SUCCESS; + case USB_INVALID_ARGS: return VERR_INVALID_PARAMETER; + case USB_INVALID_PIPE: return VERR_BAD_PIPE; + case USB_INVALID_CONTEXT: return VERR_INVALID_CONTEXT; + case USB_BUSY: return VERR_PIPE_BUSY; + case USB_PIPE_ERROR: return VERR_PIPE_IO_ERROR; + /* + case USB_FAILURE: + case USB_NO_RESOURCES: + case USB_NO_BANDWIDTH: + case USB_NOT_SUPPORTED: + case USB_PIPE_ERROR: + case USB_NO_FRAME_NUMBER: + case USB_INVALID_START_FRAME: + case USB_HC_HARDWARE_ERROR: + case USB_INVALID_REQUEST: + case USB_INVALID_VERSION: + case USB_INVALID_PERM: + */ + default: return VERR_GENERAL_FAILURE; + } +} + + +/** + * Converts Solaris' USBA device state to VBox's error code. + * + * @param uDeviceState The USB device state to convert. + * + * @returns VBox error code. + */ +static int vboxUsbSolarisDeviceState(uint8_t uDeviceState) +{ + switch (uDeviceState) + { + case USB_DEV_ONLINE: return VINF_SUCCESS; + case USB_DEV_SUSPENDED: return VERR_VUSB_DEVICE_IS_SUSPENDED; + case USB_DEV_DISCONNECTED: + case USB_DEV_PWRED_DOWN: return VERR_VUSB_DEVICE_NOT_ATTACHED; + default: return VERR_GENERAL_FAILURE; + } +} + + +/** + * Checks if the device is a USB device. + * + * @param pDip Pointer to this device info. structure. + * + * @returns If this is really a USB device returns true, otherwise false. + */ +LOCAL bool vboxUsbSolarisIsUSBDevice(dev_info_t *pDip) +{ + int rc = DDI_FAILURE; + + /* + * Check device for "usb" compatible property, root hubs->device would likely mean parent has no "usb" property. + */ + char **ppszCompatible = NULL; + uint_t cCompatible; + rc = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, pDip, DDI_PROP_DONTPASS, "compatible", &ppszCompatible, &cCompatible); + if (RT_LIKELY(rc == DDI_PROP_SUCCESS)) + { + while (cCompatible--) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Compatible[%d]=%s\n", cCompatible, ppszCompatible[cCompatible])); + if (!strncmp(ppszCompatible[cCompatible], "usb", 3)) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Verified device as USB. pszCompatible=%s\n", + ppszCompatible[cCompatible])); + ddi_prop_free(ppszCompatible); + return true; + } + } + + ddi_prop_free(ppszCompatible); + ppszCompatible = NULL; + } + else + Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: USB property lookup failed, rc=%d\n", rc)); + + /* + * Check parent for "usb" compatible property. + */ + dev_info_t *pParentDip = ddi_get_parent(pDip); + if (pParentDip) + { + rc = ddi_prop_lookup_string_array(DDI_DEV_T_ANY, pParentDip, DDI_PROP_DONTPASS, "compatible", &ppszCompatible, + &cCompatible); + if (RT_LIKELY(rc == DDI_PROP_SUCCESS)) + { + while (cCompatible--) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Parent compatible[%d]=%s\n", cCompatible, + ppszCompatible[cCompatible])); + if (!strncmp(ppszCompatible[cCompatible], "usb", 3)) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Verified device as USB. parent pszCompatible=%s\n", + ppszCompatible[cCompatible])); + ddi_prop_free(ppszCompatible); + return true; + } + } + + ddi_prop_free(ppszCompatible); + ppszCompatible = NULL; + } + else + Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: USB parent property lookup failed. rc=%d\n", rc)); + } + else + Log((DEVICE_NAME ": vboxUsbSolarisIsUSBDevice: Failed to obtain parent device for property lookup\n")); + + return false; +} + + +/** + * Submits a URB. + * + * @param pState The USB device instance. + * @param pUrbReq Pointer to the VBox USB URB. + * @param Mode The IOCtl mode. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisSendUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode) +{ + int iEpIndex = VBOXUSB_GET_EP_INDEX(pUrbReq->bEndpoint); + Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps)); + vboxusb_ep_t *pEp = &pState->aEps[iEpIndex]; + AssertPtrReturn(pEp, VERR_INVALID_POINTER); + Assert(pUrbReq); + +#if 0 + LogFunc((DEVICE_NAME ": vboxUsbSolarisSendUrb: pState=%p pUrbReq=%p bEndpoint=%#x[%d] enmDir=%#x enmType=%#x " + "cbData=%d pvData=%p\n", pState, pUrbReq, pUrbReq->bEndpoint, iEpIndex, pUrbReq->enmDir, + pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData)); +#endif + + if (RT_UNLIKELY(!pUrbReq->pvData)) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: Invalid request - No data\n")); + return VERR_INVALID_POINTER; + } + + /* + * Allocate message block & copy userspace buffer for host to device Xfers and for + * Control Xfers (since input has Setup header that needs copying). + */ + mblk_t *pMsg = NULL; + int rc = VINF_SUCCESS; + if ( pUrbReq->enmDir == VUSBDIRECTION_OUT + || pUrbReq->enmType == VUSBXFERTYPE_MSG) + { + pMsg = allocb(pUrbReq->cbData, BPRI_HI); + if (RT_UNLIKELY(!pMsg)) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: Failed to allocate %u bytes\n", pUrbReq->cbData)); + return VERR_NO_MEMORY; + } + + rc = ddi_copyin(pUrbReq->pvData, pMsg->b_wptr, pUrbReq->cbData, Mode); + if (RT_UNLIKELY(rc)) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: ddi_copyin failed! rc=%d\n", rc)); + freemsg(pMsg); + return VERR_NO_MEMORY; + } + + pMsg->b_wptr += pUrbReq->cbData; + } + + mutex_enter(&pState->Mtx); + rc = vboxUsbSolarisDeviceState(pState->DevState); + if (!pState->fDefaultPipeOpen) /* Required for Isoc. IN Xfers which don't Xfer through the pipe after polling starts */ + rc = VERR_VUSB_DEVICE_NOT_ATTACHED; + if (RT_SUCCESS(rc)) + { + /* + * Open the pipe if needed. + */ + rc = vboxUsbSolarisOpenPipe(pState, pEp); + if (RT_UNLIKELY(RT_FAILURE(rc))) + { + mutex_exit(&pState->Mtx); + freemsg(pMsg); + LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: OpenPipe failed! pState=%p pUrbReq=%p bEndpoint=%#x enmDir=%#x " + "enmType=%#x cbData=%d pvData=%p rc=%d\n", pState, pUrbReq, pUrbReq->bEndpoint, pUrbReq->enmDir, + pUrbReq->enmType, pUrbReq->cbData, pUrbReq->pvData, rc)); + return VERR_BAD_PIPE; + } + + mutex_exit(&pState->Mtx); + + vboxusb_urb_t *pUrb = NULL; + if ( pUrbReq->enmType == VUSBXFERTYPE_ISOC + && pUrbReq->enmDir == VUSBDIRECTION_IN) + pUrb = vboxUsbSolarisGetIsocInUrb(pState, pUrbReq); + else + pUrb = vboxUsbSolarisQueueUrb(pState, pUrbReq, pMsg); + + if (RT_LIKELY(pUrb)) + { + switch (pUrb->enmType) + { + case VUSBXFERTYPE_MSG: + { + rc = vboxUsbSolarisCtrlXfer(pState, pEp, pUrb); + break; + } + + case VUSBXFERTYPE_BULK: + { + rc = vboxUsbSolarisBulkXfer(pState, pEp, pUrb); + break; + } + + case VUSBXFERTYPE_INTR: + { + rc = vboxUsbSolarisIntrXfer(pState, pEp, pUrb); + break; + } + + case VUSBXFERTYPE_ISOC: + { + rc = vboxUsbSolarisIsocXfer(pState, pEp, pUrb); + break; + } + + default: + { + LogRelMax(5, (DEVICE_NAME ": vboxUsbSolarisSendUrb: URB type unsupported %d\n", pUrb->enmType)); + rc = VERR_NOT_SUPPORTED; + break; + } + } + + if (RT_FAILURE(rc)) + { + mutex_enter(&pState->Mtx); + freemsg(pUrb->pMsg); + pUrb->pMsg = NULL; + pMsg = NULL; + + if ( pUrb->enmType == VUSBXFERTYPE_ISOC + && pUrb->enmDir == VUSBDIRECTION_IN) + { + RTMemFree(pUrb); + pUrb = NULL; + } + else + { + /* + * Xfer failed, move URB back to the free list. + */ + list_remove(&pState->hInflightUrbs, pUrb); + Assert(pState->cInflightUrbs > 0); + --pState->cInflightUrbs; + + pUrb->enmState = VBOXUSB_URB_STATE_FREE; + Assert(!pUrb->pMsg); + list_insert_head(&pState->hFreeUrbs, pUrb); + ++pState->cFreeUrbs; + } + mutex_exit(&pState->Mtx); + } + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSendUrb: Failed to queue URB\n")); + rc = VERR_NO_MEMORY; + freemsg(pMsg); + } + } + else + { + mutex_exit(&pState->Mtx); + freemsg(pMsg); + } + + return rc; +} + + +/** + * Reaps a completed URB. + * + * @param pState The USB device instance. + * @param pUrbReq Pointer to the VBox USB URB. + * @param Mode The IOCtl mode. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisReapUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, int Mode) +{ + /* LogFunc((DEVICE_NAME ": vboxUsbSolarisReapUrb: pState=%p pUrbReq=%p\n", pState, pUrbReq)); */ + + AssertPtrReturn(pUrbReq, VERR_INVALID_POINTER); + + int rc = VINF_SUCCESS; + mutex_enter(&pState->Mtx); + rc = vboxUsbSolarisDeviceState(pState->DevState); + if (!pState->fDefaultPipeOpen) + rc = VERR_VUSB_DEVICE_NOT_ATTACHED; + if (RT_SUCCESS(rc)) + { + vboxusb_urb_t *pUrb = list_remove_head(&pState->hLandedUrbs); + if (pUrb) + { + Assert(pState->cLandedUrbs > 0); + --pState->cLandedUrbs; + } + + /* + * It is safe to access pUrb->pMsg outside the state mutex because this is from the landed URB list + * and not the inflight URB list. + */ + mutex_exit(&pState->Mtx); + if (pUrb) + { + /* + * Copy the URB which will then be copied to user-space. + */ + pUrbReq->pvUrbR3 = pUrb->pvUrbR3; + pUrbReq->bEndpoint = pUrb->bEndpoint; + pUrbReq->enmType = pUrb->enmType; + pUrbReq->enmDir = pUrb->enmDir; + pUrbReq->enmStatus = pUrb->enmStatus; + pUrbReq->pvData = (void *)pUrb->pvDataR3; + pUrbReq->cbData = pUrb->cbDataR3; + + if (RT_LIKELY(pUrb->pMsg)) + { + /* + * Copy the message back into the user buffer. + */ + if (RT_LIKELY(pUrb->pvDataR3 != NIL_RTR3PTR)) + { + Assert(!pUrb->pMsg->b_cont); /* We really should have a single message block always. */ + size_t cbData = RT_MIN(MBLKL(pUrb->pMsg), pUrb->cbDataR3); + pUrbReq->cbData = cbData; + + if (RT_LIKELY(cbData)) + { + rc = ddi_copyout(pUrb->pMsg->b_rptr, (void *)pUrbReq->pvData, cbData, Mode); + if (RT_UNLIKELY(rc)) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisReapUrb: ddi_copyout failed! rc=%d\n", rc)); + pUrbReq->enmStatus = VUSBSTATUS_INVALID; + } + } + + Log((DEVICE_NAME ": vboxUsbSolarisReapUrb: pvUrbR3=%p pvDataR3=%p cbData=%d\n", pUrbReq->pvUrbR3, + pUrbReq->pvData, pUrbReq->cbData)); + } + else + { + pUrbReq->cbData = 0; + rc = VERR_INVALID_POINTER; + LogRel((DEVICE_NAME ": vboxUsbSolarisReapUrb: Missing pvDataR3!!\n")); + } + + /* + * Free buffer allocated in vboxUsbSolarisSendUrb or vboxUsbSolaris[Ctrl|Bulk|Intr]Xfer(). + */ + freemsg(pUrb->pMsg); + pUrb->pMsg = NULL; + } + else + { + if ( pUrb->enmType == VUSBXFERTYPE_ISOC + && pUrb->enmDir == VUSBDIRECTION_IN) + { + pUrbReq->enmStatus = VUSBSTATUS_INVALID; + pUrbReq->cbData = 0; + } + } + + /* + * Copy Isoc packet descriptors. + */ + if (pUrb->enmType == VUSBXFERTYPE_ISOC) + { + AssertCompile(sizeof(pUrbReq->aIsocPkts) == sizeof(pUrb->aIsocPkts)); + pUrbReq->cIsocPkts = pUrb->cIsocPkts; + + for (unsigned i = 0; i < pUrb->cIsocPkts; i++) + { + pUrbReq->aIsocPkts[i].cbPkt = pUrb->aIsocPkts[i].cbPkt; + pUrbReq->aIsocPkts[i].cbActPkt = pUrb->aIsocPkts[i].cbActPkt; + pUrbReq->aIsocPkts[i].enmStatus = pUrb->aIsocPkts[i].enmStatus; + } + + if (pUrb->enmDir == VUSBDIRECTION_IN) + { + RTMemFree(pUrb); + pUrb = NULL; + } + } + + if (pUrb) + { + /* + * Add URB back to the free list. + */ + Assert(!pUrb->pMsg); + pUrb->cbDataR3 = 0; + pUrb->pvDataR3 = NIL_RTR3PTR; + pUrb->enmState = VBOXUSB_URB_STATE_FREE; + mutex_enter(&pState->Mtx); + list_insert_head(&pState->hFreeUrbs, pUrb); + ++pState->cFreeUrbs; + mutex_exit(&pState->Mtx); + } + } + else + { + pUrbReq->pvUrbR3 = NULL; + pUrbReq->cbData = 0; + pUrbReq->pvData = NULL; + pUrbReq->enmStatus = VUSBSTATUS_INVALID; + } + } + else + mutex_exit(&pState->Mtx); + + return rc; +} + + +/** + * Clears a pipe (CLEAR_FEATURE). + * + * @param pState The USB device instance. + * @param bEndpoint The Endpoint address. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisClearEndPoint(vboxusb_state_t *pState, uint8_t bEndpoint) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: pState=%p bEndpoint=%#x\n", pState, bEndpoint)); + + mutex_enter(&pState->Mtx); + int rc = vboxUsbSolarisDeviceState(pState->DevState); + if (RT_SUCCESS(rc)) + { + int iEpIndex = VBOXUSB_GET_EP_INDEX(bEndpoint); + Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps)); + vboxusb_ep_t *pEp = &pState->aEps[iEpIndex]; + if (RT_LIKELY(pEp)) + { + /* + * Check if the endpoint is open to be cleared. + */ + if (pEp->pPipe) + { + mutex_exit(&pState->Mtx); + + /* + * Synchronous reset pipe. + */ + usb_pipe_reset(pState->pDip, pEp->pPipe, + USB_FLAGS_SLEEP, /* Synchronous */ + NULL, /* Completion callback */ + NULL); /* Exception callback */ + + mutex_enter(&pState->Mtx); + + Log((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: bEndpoint=%#x[%d] returns %d\n", bEndpoint, iEpIndex, rc)); + + rc = VINF_SUCCESS; + } + else + { + Log((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: Not opened to be cleared. Faking success. bEndpoint=%#x\n", + bEndpoint)); + rc = VINF_SUCCESS; + } + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: Endpoint missing! bEndpoint=%#x[%d]\n", bEndpoint, iEpIndex)); + rc = VERR_GENERAL_FAILURE; + } + } + else + Log((DEVICE_NAME ": vboxUsbSolarisClearEndPoint: Device not online, state=%d\n", pState->DevState)); + + mutex_exit(&pState->Mtx); + return rc; +} + + +/** + * Sets configuration (SET_CONFIGURATION) + * + * @param pState The USB device instance. + * @param bConfig The Configuration. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisSetConfig(vboxusb_state_t *pState, uint8_t bConfig) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisSetConfig: pState=%p bConfig=%u\n", pState, bConfig)); + + mutex_enter(&pState->Mtx); + int rc = vboxUsbSolarisDeviceState(pState->DevState); + if (RT_SUCCESS(rc)) + { + vboxUsbSolarisCloseAllPipes(pState, false /* ControlPipe */); + int iCfgIndex = vboxUsbSolarisGetConfigIndex(pState, bConfig); + + if ( iCfgIndex >= 0 + && iCfgIndex < pState->pDevDesc->dev_n_cfg) + { + /* + * Switch Config synchronously. + */ + mutex_exit(&pState->Mtx); + rc = usb_set_cfg(pState->pDip, (uint_t)iCfgIndex, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback data */); + mutex_enter(&pState->Mtx); + + if (rc == USB_SUCCESS) + { + int rc2 = vboxUsbSolarisInitEpsForCfg(pState); + AssertRC(rc2); NOREF(rc2); + rc = VINF_SUCCESS; + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSetConfig: usb_set_cfg failed for iCfgIndex=%#x bConfig=%u rc=%d\n", + iCfgIndex, bConfig, rc)); + rc = vboxUsbSolarisToVBoxRC(rc); + } + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSetConfig: Invalid iCfgIndex=%d bConfig=%u\n", iCfgIndex, bConfig)); + rc = VERR_OUT_OF_RANGE; + } + } + + mutex_exit(&pState->Mtx); + + return rc; +} + + +/** + * Gets configuration (GET_CONFIGURATION) + * + * @param pState The USB device instance. + * @param pbConfig Where to store the Configuration. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisGetConfig(vboxusb_state_t *pState, uint8_t *pbConfig) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisGetConfig: pState=%p pbConfig=%p\n", pState, pbConfig)); + AssertPtrReturn(pbConfig, VERR_INVALID_POINTER); + + /* + * Get Config synchronously. + */ + uint_t bConfig; + int rc = usb_get_cfg(pState->pDip, &bConfig, USB_FLAGS_SLEEP); + if (RT_LIKELY(rc == USB_SUCCESS)) + { + *pbConfig = bConfig; + rc = VINF_SUCCESS; + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisGetConfig: Failed, rc=%d\n", rc)); + rc = vboxUsbSolarisToVBoxRC(rc); + } + + Log((DEVICE_NAME ": vboxUsbSolarisGetConfig: Returns %d bConfig=%u\n", rc, *pbConfig)); + return rc; +} + + +/** + * Sets interface (SET_INTERFACE) and alternate. + * + * @param pState The USB device instance. + * @param bIf The Interface. + * @param bAlt The Alternate setting. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisSetInterface(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisSetInterface: pState=%p bIf=%#x bAlt=%#x\n", pState, bIf, bAlt)); + + mutex_enter(&pState->Mtx); + int rc = vboxUsbSolarisDeviceState(pState->DevState); + if (RT_SUCCESS(rc)) + { + /* + * Set Interface & Alt setting synchronously. + */ + mutex_exit(&pState->Mtx); + rc = usb_set_alt_if(pState->pDip, bIf, bAlt, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback data */); + mutex_enter(&pState->Mtx); + + if (rc == USB_SUCCESS) + { + Log((DEVICE_NAME ": vboxUsbSolarisSetInterface: Success, bIf=%#x bAlt=%#x\n", bIf, bAlt, rc)); + int rc2 = vboxUsbSolarisInitEpsForIfAlt(pState, bIf, bAlt); + AssertRC(rc2); NOREF(rc2); + rc = VINF_SUCCESS; + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisSetInterface: usb_set_alt_if failed for bIf=%#x bAlt=%#x rc=%d\n", bIf, bAlt, rc)); + rc = vboxUsbSolarisToVBoxRC(rc); + } + } + + mutex_exit(&pState->Mtx); + + return rc; +} + + +/** + * Closes the USB device and optionally resets it. + * + * @param pState The USB device instance. + * @param enmReset The reset level. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisCloseDevice(vboxusb_state_t *pState, VBOXUSB_RESET_LEVEL enmReset) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisCloseDevice: pState=%p enmReset=%d\n", pState, enmReset)); + + mutex_enter(&pState->Mtx); + int rc = vboxUsbSolarisDeviceState(pState->DevState); + + if (enmReset == VBOXUSB_RESET_LEVEL_CLOSE) + vboxUsbSolarisCloseAllPipes(pState, true /* ControlPipe */); + else + vboxUsbSolarisCloseAllPipes(pState, false /* ControlPipe */); + + mutex_exit(&pState->Mtx); + + if (RT_SUCCESS(rc)) + { + switch (enmReset) + { + case VBOXUSB_RESET_LEVEL_REATTACH: + rc = usb_reset_device(pState->pDip, USB_RESET_LVL_REATTACH); + break; + + case VBOXUSB_RESET_LEVEL_SOFT: + rc = usb_reset_device(pState->pDip, USB_RESET_LVL_DEFAULT); + break; + + default: + rc = USB_SUCCESS; + break; + } + + rc = vboxUsbSolarisToVBoxRC(rc); + } + + Log((DEVICE_NAME ": vboxUsbSolarisCloseDevice: Returns %d\n", rc)); + return rc; +} + + +/** + * Aborts pending requests and reset the pipe. + * + * @param pState The USB device instance. + * @param bEndpoint The Endpoint address. + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisAbortPipe(vboxusb_state_t *pState, uint8_t bEndpoint) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisAbortPipe: pState=%p bEndpoint=%#x\n", pState, bEndpoint)); + + mutex_enter(&pState->Mtx); + int rc = vboxUsbSolarisDeviceState(pState->DevState); + if (RT_SUCCESS(rc)) + { + int iEpIndex = VBOXUSB_GET_EP_INDEX(bEndpoint); + Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps)); + vboxusb_ep_t *pEp = &pState->aEps[iEpIndex]; + if (RT_LIKELY(pEp)) + { + if (pEp->pPipe) + { + /* + * Aborting requests not supported for the default control pipe. + */ + if ((pEp->EpDesc.bEndpointAddress & USB_EP_NUM_MASK) == 0) + { + mutex_exit(&pState->Mtx); + LogRel((DEVICE_NAME ": vboxUsbSolarisAbortPipe: Cannot reset default control pipe\n")); + return VERR_NOT_SUPPORTED; + } + + mutex_exit(&pState->Mtx); + usb_pipe_reset(pState->pDip, pEp->pPipe, + USB_FLAGS_SLEEP, /* Synchronous */ + NULL, /* Completion callback */ + NULL); /* Callback's parameter */ + + /* + * Allow pending async requests to complete. + */ + /** @todo this is most likely not required. */ + rc = usb_pipe_drain_reqs(pState->pDip, pEp->pPipe, + USB_FLAGS_SLEEP, /* Synchronous */ + 5, /* Timeout (seconds) */ + NULL, /* Completion callback */ + NULL); /* Callback's parameter */ + + mutex_enter(&pState->Mtx); + + Log((DEVICE_NAME ": vboxUsbSolarisAbortPipe: usb_pipe_drain_reqs returns %d\n", rc)); + rc = vboxUsbSolarisToVBoxRC(rc); + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisAbortPipe: pipe not open. bEndpoint=%#x\n", bEndpoint)); + rc = VERR_PIPE_IO_ERROR; + } + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisAbortPipe: Invalid pipe bEndpoint=%#x[%d]\n", bEndpoint, iEpIndex)); + rc = VERR_INVALID_HANDLE; + } + } + + mutex_exit(&pState->Mtx); + + LogFunc((DEVICE_NAME ": vboxUsbSolarisAbortPipe: Returns %d\n", rc)); + return rc; +} + + +/** + * Initializes an Endpoint. + * + * @param pState The USB device instance. + * @param pEpData The Endpoint data (NULL implies the default + * endpoint). + * + * @returns VBox error code. + */ +LOCAL int vboxUsbSolarisInitEp(vboxusb_state_t *pState, usb_ep_data_t *pEpData) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisInitEp: pState=%p pEpData=%p", pState, pEpData)); + + /* + * Is this the default endpoint? + */ + usb_ep_descr_t *pEpDesc = NULL; + vboxusb_ep_t *pEp = NULL; + int iEpIndex; + if (!pEpData) + { + iEpIndex = 0; + pEpDesc = &g_VBoxUSBSolarisDefaultEpDesc; + } + else + { + iEpIndex = VBOXUSB_GET_EP_INDEX(pEpData->ep_descr.bEndpointAddress); + pEpDesc = (usb_ep_descr_t *)((uint8_t *)pEpData + g_offUsbEpDataDescr); + } + + Assert(iEpIndex >= 0 && iEpIndex < RT_ELEMENTS(pState->aEps)); + pEp = &pState->aEps[iEpIndex]; + + /* + * Initialize the endpoint. + */ + pEp->EpDesc = *pEpDesc; + if (!pEp->fInitialized) + { + pEp->pPipe = NULL; + bzero(&pEp->PipePolicy, sizeof(pEp->PipePolicy)); + pEp->PipePolicy.pp_max_async_reqs = VBOXUSB_MAX_PIPE_ASYNC_REQS; + pEp->fIsocPolling = false; + list_create(&pEp->hIsocInUrbs, sizeof(vboxusb_urb_t), offsetof(vboxusb_urb_t, hListLink)); + pEp->cIsocInUrbs = 0; + list_create(&pEp->hIsocInLandedReqs, sizeof(vboxusb_isoc_req_t), offsetof(vboxusb_isoc_req_t, hListLink)); + pEp->cbIsocInLandedReqs = 0; + pEp->cbMaxIsocData = 0; + pEp->fInitialized = true; + } + + Log((DEVICE_NAME ": vboxUsbSolarisInitEp: Success, %s[%2d] %s %s bEndpoint=%#x\n", !pEpData ? "Default " : "Endpoint", + iEpIndex, vboxUsbSolarisEpType(pEp), vboxUsbSolarisEpDir(pEp), pEp->EpDesc.bEndpointAddress)); + return VINF_SUCCESS; +} + + +/** + * Initializes Endpoints for the current configuration, all interfaces and + * alternate setting 0 for each interface. + * + * @param pState The USB device instance. + * + * @returns VBox status code. + */ +LOCAL int vboxUsbSolarisInitEpsForCfg(vboxusb_state_t *pState) +{ + uint_t uCfgIndex = usb_get_current_cfgidx(pState->pDip); + if (uCfgIndex >= pState->pDevDesc->dev_n_cfg) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForCfg: Invalid current config index %u\n", uCfgIndex)); + return VERR_OUT_OF_RANGE; + } + + usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex]; + uchar_t bConfig = pConfig->cfg_descr.bConfigurationValue; + + LogFunc((DEVICE_NAME ": vboxUsbSolarisInitEpsForCfg: pState=%p bConfig=%u uCfgIndex=%u\n", pState, bConfig, uCfgIndex)); + + const uint_t cIfs = pConfig->cfg_n_if; + for (uchar_t uIf = 0; uIf < cIfs; uIf++) + { + usb_if_data_t *pIf = &pConfig->cfg_if[uIf]; + const uint_t cAlts = pIf->if_n_alt; + for (uchar_t uAlt = 0; uAlt < cAlts; uAlt++) + { + usb_alt_if_data_t *pAlt = &pIf->if_alt[uAlt]; + if (pAlt->altif_descr.bAlternateSetting == 0) /* Refer USB 2.0 spec 9.6.5 "Interface" */ + { + const uint_t cEps = pAlt->altif_n_ep; + for (uchar_t uEp = 0; uEp < cEps; uEp++) + { + uint8_t *pbEpData = (uint8_t *)&pAlt->altif_ep[0]; + usb_ep_data_t *pEpData = (usb_ep_data_t *)(pbEpData + uEp * g_cbUsbEpData); + int rc = vboxUsbSolarisInitEp(pState, pEpData); + if (RT_FAILURE(rc)) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForCfg: Failed to init endpoint! " + "bConfig=%u bIf=%#x bAlt=%#x\n", bConfig, pAlt->altif_descr.bInterfaceNumber, + pAlt->altif_descr.bAlternateSetting)); + return rc; + } + } + break; /* move on to next interface. */ + } + } + } + return VINF_SUCCESS; +} + + +/** + * Initializes Endpoints for the given Interface & Alternate setting. + * + * @param pState The USB device instance. + * @param bIf The Interface. + * @param bAlt The Alterate. + * + * @returns VBox status code. + */ +LOCAL int vboxUsbSolarisInitEpsForIfAlt(vboxusb_state_t *pState, uint8_t bIf, uint8_t bAlt) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisInitEpsForIfAlt: pState=%p bIf=%d uAlt=%d\n", pState, bIf, bAlt)); + + /* Doesn't hurt to be paranoid */ + uint_t uCfgIndex = usb_get_current_cfgidx(pState->pDip); + if (uCfgIndex >= pState->pDevDesc->dev_n_cfg) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForIfAlt: Invalid current config index %d\n", uCfgIndex)); + return VERR_OUT_OF_RANGE; + } + + usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[uCfgIndex]; + for (uchar_t uIf = 0; uIf < pConfig->cfg_n_if; uIf++) + { + usb_if_data_t *pInterface = &pConfig->cfg_if[uIf]; + const uint_t cAlts = pInterface->if_n_alt; + for (uchar_t uAlt = 0; uAlt < cAlts; uAlt++) + { + usb_alt_if_data_t *pAlt = &pInterface->if_alt[uAlt]; + if ( pAlt->altif_descr.bInterfaceNumber == bIf + && pAlt->altif_descr.bAlternateSetting == bAlt) + { + const uint_t cEps = pAlt->altif_n_ep; + for (uchar_t uEp = 0; uEp < cEps; uEp++) + { + uint8_t *pbEpData = (uint8_t *)&pAlt->altif_ep[0]; + usb_ep_data_t *pEpData = (usb_ep_data_t *)(pbEpData + uEp * g_cbUsbEpData); + int rc = vboxUsbSolarisInitEp(pState, pEpData); + if (RT_FAILURE(rc)) + { + uint8_t bCfgValue = pConfig->cfg_descr.bConfigurationValue; + LogRel((DEVICE_NAME ": vboxUsbSolarisInitEpsForIfAlt: Failed to init endpoint! " + "bCfgValue=%u bIf=%#x bAlt=%#x\n", bCfgValue, bIf, bAlt)); + return rc; + } + } + return VINF_SUCCESS; + } + } + } + return VERR_NOT_FOUND; +} + + +/** + * Destroys all Endpoints. + * + * @param pState The USB device instance. + * + * @remarks Requires the state mutex to be held. + * Call only from Detach() or similar as callbacks + */ +LOCAL void vboxUsbSolarisDestroyAllEps(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDestroyAllEps: pState=%p\n", pState)); + + Assert(mutex_owned(&pState->Mtx)); + for (unsigned i = 0; i < VBOXUSB_MAX_ENDPOINTS; i++) + { + vboxusb_ep_t *pEp = &pState->aEps[i]; + if (pEp->fInitialized) + vboxUsbSolarisDestroyEp(pState, pEp); + } +} + + +/** + * Destroys an Endpoint. + * + * @param pState The USB device instance. + * @param pEp The Endpoint. + * + * @remarks Requires the state mutex to be held. + */ +LOCAL void vboxUsbSolarisDestroyEp(vboxusb_state_t *pState, vboxusb_ep_t *pEp) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDestroyEp: pState=%p pEp=%p\n", pState, pEp)); + + Assert(pEp->fInitialized); + Assert(mutex_owned(&pState->Mtx)); + vboxusb_urb_t *pUrb = list_remove_head(&pEp->hIsocInUrbs); + while (pUrb) + { + if (pUrb->pMsg) + freemsg(pUrb->pMsg); + RTMemFree(pUrb); + pUrb = list_remove_head(&pEp->hIsocInUrbs); + } + pEp->cIsocInUrbs = 0; + list_destroy(&pEp->hIsocInUrbs); + + vboxusb_isoc_req_t *pIsocReq = list_remove_head(&pEp->hIsocInLandedReqs); + while (pIsocReq) + { + kmem_free(pIsocReq, sizeof(vboxusb_isoc_req_t)); + pIsocReq = list_remove_head(&pEp->hIsocInLandedReqs); + } + pEp->cbIsocInLandedReqs = 0; + list_destroy(&pEp->hIsocInLandedReqs); + + pEp->fInitialized = false; +} + + +/** + * Closes all non-default pipes and drains the default pipe. + * + * @param pState The USB device instance. + * @param fDefault Whether to close the default control pipe. + * + * @remarks Requires the device state mutex to be held. + */ +LOCAL void vboxUsbSolarisCloseAllPipes(vboxusb_state_t *pState, bool fDefault) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisCloseAllPipes: pState=%p\n", pState)); + + for (int i = 1; i < VBOXUSB_MAX_ENDPOINTS; i++) + { + vboxusb_ep_t *pEp = &pState->aEps[i]; + if ( pEp + && pEp->pPipe) + { + Log((DEVICE_NAME ": vboxUsbSolarisCloseAllPipes: Closing[%d]\n", i)); + vboxUsbSolarisClosePipe(pState, pEp); + } + } + + if (fDefault) + { + vboxusb_ep_t *pEp = &pState->aEps[0]; + if ( pEp + && pEp->pPipe) + { + vboxUsbSolarisClosePipe(pState, pEp); + Log((DEVICE_NAME ": vboxUsbSolarisCloseAllPipes: Closed default pipe\n")); + } + } +} + + +/** + * Opens the pipe associated with an Endpoint. + * + * @param pState The USB device instance. + * @param pEp The Endpoint. + * @remarks Requires the device state mutex to be held. + * + * @returns VBox status code. + */ +LOCAL int vboxUsbSolarisOpenPipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp) +{ + Assert(mutex_owned(&pState->Mtx)); + + /* + * Make sure the Endpoint isn't open already. + */ + if (pEp->pPipe) + return VINF_SUCCESS; + + /* + * Default Endpoint; already opened just copy the pipe handle. + */ + if ((pEp->EpDesc.bEndpointAddress & USB_EP_NUM_MASK) == 0) + { + pEp->pPipe = pState->pDevDesc->dev_default_ph; + Log((DEVICE_NAME ": vboxUsbSolarisOpenPipe: Default pipe opened\n")); + return VINF_SUCCESS; + } + + /* + * Open the non-default pipe for the Endpoint. + */ + mutex_exit(&pState->Mtx); + int rc = usb_pipe_open(pState->pDip, &pEp->EpDesc, &pEp->PipePolicy, USB_FLAGS_NOSLEEP, &pEp->pPipe); + mutex_enter(&pState->Mtx); + if (rc == USB_SUCCESS) + { + LogFunc((DEVICE_NAME ": vboxUsbSolarisOpenPipe: Opened pipe, pState=%p pEp=%p\n", pState, pEp)); + usb_pipe_set_private(pEp->pPipe, (usb_opaque_t)pEp); + + /* + * Determine input buffer size for Isoc. IN transfers. + */ + if ( VBOXUSB_XFER_TYPE(pEp) == VUSBXFERTYPE_ISOC + && VBOXUSB_XFER_DIR(pEp) == VUSB_DIR_TO_HOST) + { + /* + * wMaxPacketSize bits 10..0 specifies maximum packet size which can hold 1024 bytes. + * If bits 12..11 is non-zero, cbMax will be more than 1024 and thus the Endpoint is a + * high-bandwidth Endpoint. + */ + uint16_t cbMax = VBOXUSB_PKT_SIZE(pEp->EpDesc.wMaxPacketSize); + if (cbMax <= 1024) + { + /* Buffer 1 second for highspeed and 8 seconds for fullspeed Endpoints. */ + pEp->cbMaxIsocData = 1000 * cbMax * 8; + } + else + { + /* Buffer about 400 milliseconds of data for highspeed high-bandwidth endpoints. */ + pEp->cbMaxIsocData = 400 * cbMax * 8; + } + Log((DEVICE_NAME ": vboxUsbSolarisOpenPipe: bEndpoint=%#x cbMaxIsocData=%u\n", pEp->EpDesc.bEndpointAddress, + pEp->cbMaxIsocData)); + } + + rc = VINF_SUCCESS; + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisOpenPipe: Failed! rc=%d pState=%p pEp=%p\n", rc, pState, pEp)); + rc = VERR_BAD_PIPE; + } + + return rc; +} + + +/** + * Closes the pipe associated with an Endpoint. + * + * @param pState The USB device instance. + * @param pEp The Endpoint. + * + * @remarks Requires the device state mutex to be held. + */ +LOCAL void vboxUsbSolarisClosePipe(vboxusb_state_t *pState, vboxusb_ep_t *pEp) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisClosePipe: pState=%p pEp=%p\n", pState, pEp)); + AssertPtr(pEp); + + if (pEp->pPipe) + { + /* + * Default pipe: allow completion of pending requests. + */ + if (pEp->pPipe == pState->pDevDesc->dev_default_ph) + { + mutex_exit(&pState->Mtx); + usb_pipe_drain_reqs(pState->pDip, pEp->pPipe, 0, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */); + mutex_enter(&pState->Mtx); + Log((DEVICE_NAME ": vboxUsbSolarisClosePipe: Closed default pipe\n")); + pState->fDefaultPipeOpen = false; + } + else + { + /* + * Stop Isoc. IN polling if required. + */ + if (pEp->fIsocPolling) + { + pEp->fIsocPolling = false; + mutex_exit(&pState->Mtx); + usb_pipe_stop_isoc_polling(pEp->pPipe, USB_FLAGS_NOSLEEP); + mutex_enter(&pState->Mtx); + } + + /* + * Non-default pipe: close it. + */ + Log((DEVICE_NAME ": vboxUsbSolarisClosePipe: Pipe bmAttributes=%#x bEndpoint=%#x\n", pEp->EpDesc.bmAttributes, + pEp->EpDesc.bEndpointAddress)); + mutex_exit(&pState->Mtx); + usb_pipe_close(pState->pDip, pEp->pPipe, USB_FLAGS_SLEEP, NULL /* callback */, NULL /* callback arg. */); + mutex_enter(&pState->Mtx); + } + + /* + * Free the Endpoint data message block and reset pipe handle. + */ + pEp->pPipe = NULL; + + Log((DEVICE_NAME ": vboxUsbSolarisClosePipe: Success, bEndpoint=%#x\n", pEp->EpDesc.bEndpointAddress)); + } + + Assert(pEp->pPipe == NULL); +} + + +/** + * Finds the Configuration index for the passed in Configuration value. + * + * @param pState The USB device instance. + * @param bConfig The Configuration. + * + * @returns The configuration index if found, otherwise -1. + */ +LOCAL int vboxUsbSolarisGetConfigIndex(vboxusb_state_t *pState, uint_t bConfig) +{ + for (int CfgIndex = 0; CfgIndex < pState->pDevDesc->dev_n_cfg; CfgIndex++) + { + usb_cfg_data_t *pConfig = &pState->pDevDesc->dev_cfg[CfgIndex]; + if (pConfig->cfg_descr.bConfigurationValue == bConfig) + return CfgIndex; + } + + return -1; +} + + +/** + * Allocates and initializes an Isoc. In URB from the ring-3 equivalent. + * + * @param pState The USB device instance. + * @param pUrbReq Opaque pointer to the complete request. + * + * @returns The allocated Isoc. In URB to be used. + */ +LOCAL vboxusb_urb_t *vboxUsbSolarisGetIsocInUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq) +{ + /* + * Isoc. In URBs are not queued into the Inflight list like every other URBs. + * For now we allocate each URB which gets queued into the respective Endpoint during Xfer. + */ + vboxusb_urb_t *pUrb = RTMemAllocZ(sizeof(vboxusb_urb_t)); + if (RT_LIKELY(pUrb)) + { + pUrb->enmState = VBOXUSB_URB_STATE_INFLIGHT; + pUrb->pState = pState; + + if (RT_LIKELY(pUrbReq)) + { + pUrb->pvUrbR3 = pUrbReq->pvUrbR3; + pUrb->bEndpoint = pUrbReq->bEndpoint; + pUrb->enmType = pUrbReq->enmType; + pUrb->enmDir = pUrbReq->enmDir; + pUrb->enmStatus = pUrbReq->enmStatus; + pUrb->cbDataR3 = pUrbReq->cbData; + pUrb->pvDataR3 = (RTR3PTR)pUrbReq->pvData; + pUrb->cIsocPkts = pUrbReq->cIsocPkts; + + for (unsigned i = 0; i < pUrbReq->cIsocPkts; i++) + pUrb->aIsocPkts[i].cbPkt = pUrbReq->aIsocPkts[i].cbPkt; + + pUrb->pMsg = NULL; + } + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisGetIsocInUrb: Failed to alloc %d bytes\n", sizeof(vboxusb_urb_t))); + return pUrb; +} + + +/** + * Queues a URB reusing previously allocated URBs as required. + * + * @param pState The USB device instance. + * @param pUrbReq Opaque pointer to the complete request. + * @param pMsg Pointer to the allocated request data. + * + * @returns The allocated URB to be used, or NULL upon failure. + */ +LOCAL vboxusb_urb_t *vboxUsbSolarisQueueUrb(vboxusb_state_t *pState, PVBOXUSBREQ_URB pUrbReq, mblk_t *pMsg) +{ + Assert(pUrbReq); + LogFunc((DEVICE_NAME ": vboxUsbSolarisQueueUrb: pState=%p pUrbReq=%p\n", pState, pUrbReq)); + + mutex_enter(&pState->Mtx); + + /* + * Grab a URB from the free list. + */ + vboxusb_urb_t *pUrb = list_remove_head(&pState->hFreeUrbs); + if (pUrb) + { + Assert(pUrb->enmState == VBOXUSB_URB_STATE_FREE); + Assert(!pUrb->pMsg); + Assert(pState->cFreeUrbs > 0); + --pState->cFreeUrbs; + } + else + { + /* + * We can't discard "old" URBs. For instance, INTR IN URBs that don't complete as + * they don't have a timeout can essentially take arbitrarily long to complete depending + * on the device and it's not safe to discard them in case they -do- complete. However, + * we also have to reasonably assume a device doesn't have too many pending URBs always. + * + * Thus we just use a large queue and simply refuse further transfers. This is not + * a situation which normally ever happens as usually there are at most than 4 or 5 URBs + * in-flight until we reap them. + */ + uint32_t const cTotalUrbs = pState->cInflightUrbs + pState->cFreeUrbs + pState->cLandedUrbs; + if (cTotalUrbs >= VBOXUSB_URB_QUEUE_SIZE) + { + mutex_exit(&pState->Mtx); + LogRelMax(5, (DEVICE_NAME ": vboxUsbSolarisQueueUrb: Max queue size %u reached, refusing further transfers", + cTotalUrbs)); + return NULL; + } + + /* + * Allocate a new URB as we have no free URBs. + */ + mutex_exit(&pState->Mtx); + pUrb = RTMemAllocZ(sizeof(vboxusb_urb_t)); + if (RT_UNLIKELY(!pUrb)) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisQueueUrb: Failed to alloc %d bytes\n", sizeof(vboxusb_urb_t))); + return NULL; + } + mutex_enter(&pState->Mtx); + } + + /* + * Add the URB to the inflight list. + */ + list_insert_tail(&pState->hInflightUrbs, pUrb); + ++pState->cInflightUrbs; + + Assert(!pUrb->pMsg); + pUrb->pMsg = pMsg; + pUrb->pState = pState; + pUrb->enmState = VBOXUSB_URB_STATE_INFLIGHT; + pUrb->pvUrbR3 = pUrbReq->pvUrbR3; + pUrb->bEndpoint = pUrbReq->bEndpoint; + pUrb->enmType = pUrbReq->enmType; + pUrb->enmDir = pUrbReq->enmDir; + pUrb->enmStatus = pUrbReq->enmStatus; + pUrb->fShortOk = pUrbReq->fShortOk; + pUrb->pvDataR3 = (RTR3PTR)pUrbReq->pvData; + pUrb->cbDataR3 = pUrbReq->cbData; + pUrb->cIsocPkts = pUrbReq->cIsocPkts; + if (pUrbReq->enmType == VUSBXFERTYPE_ISOC) + { + for (unsigned i = 0; i < pUrbReq->cIsocPkts; i++) + pUrb->aIsocPkts[i].cbPkt = pUrbReq->aIsocPkts[i].cbPkt; + } + + mutex_exit(&pState->Mtx); + return pUrb; +} + + +/** + * Dequeues a completed URB into the landed list and informs user-land. + * + * @param pUrb The URB to move. + * @param URBStatus The Solaris URB completion code. + * + * @remarks All pipes could be closed at this point (e.g. Device disconnected during inflight URBs) + */ +LOCAL void vboxUsbSolarisDeQueueUrb(vboxusb_urb_t *pUrb, int URBStatus) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDeQueue: pUrb=%p\n", pUrb)); + AssertPtrReturnVoid(pUrb); + + pUrb->enmStatus = vboxUsbSolarisGetUrbStatus(URBStatus); + if (pUrb->enmStatus != VUSBSTATUS_OK) + Log((DEVICE_NAME ": vboxUsbSolarisDeQueueUrb: URB failed! URBStatus=%d bEndpoint=%#x\n", URBStatus, pUrb->bEndpoint)); + + vboxusb_state_t *pState = pUrb->pState; + if (RT_LIKELY(pState)) + { + mutex_enter(&pState->Mtx); + pUrb->enmState = VBOXUSB_URB_STATE_LANDED; + + /* + * Remove it from the inflight list & move it to the landed list. + */ + list_remove(&pState->hInflightUrbs, pUrb); + Assert(pState->cInflightUrbs > 0); + --pState->cInflightUrbs; + + list_insert_tail(&pState->hLandedUrbs, pUrb); + ++pState->cLandedUrbs; + + vboxUsbSolarisNotifyComplete(pUrb->pState); + mutex_exit(&pState->Mtx); + return; + } + + /* Well, let's at least not leak memory... */ + freemsg(pUrb->pMsg); + pUrb->pMsg = NULL; + pUrb->enmStatus = VUSBSTATUS_INVALID; + + LogRel((DEVICE_NAME ": vboxUsbSolarisDeQueue: State Gone\n")); +} + + +/** + * Concatenates a chain message block into a single message block if possible. + * + * @param pUrb The URB to move. + */ +LOCAL void vboxUsbSolarisConcatMsg(vboxusb_urb_t *pUrb) +{ + /* + * Concatenate the whole message rather than doing a chained copy while reaping. + */ + if ( pUrb->pMsg + && pUrb->pMsg->b_cont) + { + mblk_t *pFullMsg = msgpullup(pUrb->pMsg, -1 /* all data */); + if (RT_LIKELY(pFullMsg)) + { + freemsg(pUrb->pMsg); + pUrb->pMsg = pFullMsg; + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisConcatMsg: Failed. Expect glitches due to truncated data!\n")); + } +} + + +/** + * Wakes up a user process signalling URB completion. + * + * @param pState The USB device instance. + * @remarks Requires the device state mutex to be held. + */ +LOCAL void vboxUsbSolarisNotifyComplete(vboxusb_state_t *pState) +{ + if (pState->fPollPending) + { + pollhead_t *pPollHead = &pState->PollHead; + pState->fPollPending = false; + mutex_exit(&pState->Mtx); + pollwakeup(pPollHead, POLLIN); + mutex_enter(&pState->Mtx); + } +} + + +/** + * Wakes up a user process signalling a device unplug events. + * + * @param pState The USB device instance. + * @remarks Requires the device state mutex to be held. + */ +LOCAL void vboxUsbSolarisNotifyUnplug(vboxusb_state_t *pState) +{ + if (pState->fPollPending) + { + pollhead_t *pPollHead = &pState->PollHead; + pState->fPollPending = false; + mutex_exit(&pState->Mtx); + pollwakeup(pPollHead, POLLHUP); + mutex_enter(&pState->Mtx); + } +} + + +/** + * Performs a Control Xfer. + * + * @param pState The USB device instance. + * @param pEp The Endpoint for the Xfer. + * @param pUrb The VBox USB URB. + * + * @returns VBox status code. + */ +LOCAL int vboxUsbSolarisCtrlXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisCtrlXfer: pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, + pUrb->enmDir, pUrb->cbDataR3)); + + AssertPtrReturn(pUrb->pMsg, VERR_INVALID_PARAMETER); + const size_t cbData = pUrb->cbDataR3 > VBOXUSB_CTRL_XFER_SIZE ? pUrb->cbDataR3 - VBOXUSB_CTRL_XFER_SIZE : 0; + + /* + * Allocate a wrapper request. + */ + usb_ctrl_req_t *pReq = usb_alloc_ctrl_req(pState->pDip, cbData, USB_FLAGS_SLEEP); + if (RT_LIKELY(pReq)) + { + uchar_t *pSetupData = pUrb->pMsg->b_rptr; + + /* + * Initialize the Ctrl Xfer Header. + */ + pReq->ctrl_bmRequestType = pSetupData[0]; + pReq->ctrl_bRequest = pSetupData[1]; + pReq->ctrl_wValue = (pSetupData[3] << VBOXUSB_CTRL_XFER_SIZE) | pSetupData[2]; + pReq->ctrl_wIndex = (pSetupData[5] << VBOXUSB_CTRL_XFER_SIZE) | pSetupData[4]; + pReq->ctrl_wLength = (pSetupData[7] << VBOXUSB_CTRL_XFER_SIZE) | pSetupData[6]; + + if ( pUrb->enmDir == VUSBDIRECTION_OUT + && cbData) + { + bcopy(pSetupData + VBOXUSB_CTRL_XFER_SIZE, pReq->ctrl_data->b_wptr, cbData); + pReq->ctrl_data->b_wptr += cbData; + } + + freemsg(pUrb->pMsg); + pUrb->pMsg = NULL; + + /* + * Initialize callbacks and timeouts. + */ + pReq->ctrl_cb = vboxUsbSolarisCtrlXferCompleted; + pReq->ctrl_exc_cb = vboxUsbSolarisCtrlXferCompleted; + pReq->ctrl_timeout = VBOXUSB_CTRL_XFER_TIMEOUT; + pReq->ctrl_attributes = USB_ATTRS_AUTOCLEARING | USB_ATTRS_SHORT_XFER_OK; + pReq->ctrl_client_private = (usb_opaque_t)pUrb; + + /* + * Submit the request. + */ + int rc = usb_pipe_ctrl_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP); + if (RT_LIKELY(rc == USB_SUCCESS)) + return VINF_SUCCESS; + + LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXfer: Request failed! bEndpoint=%#x rc=%d\n", pUrb->bEndpoint, rc)); + + usb_free_ctrl_req(pReq); + return VERR_PIPE_IO_ERROR; + } + + LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXfer: Failed to alloc request for %u bytes\n", cbData)); + return VERR_NO_MEMORY; +} + + +/** + * Completion/Exception callback for Control Xfers. + * + * @param pPipe The Ctrl pipe handle. + * @param pReq The Ctrl request. + */ +LOCAL void vboxUsbSolarisCtrlXferCompleted(usb_pipe_handle_t pPipe, usb_ctrl_req_t *pReq) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisCtrlXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq)); + Assert(pReq); + Assert(!(pReq->ctrl_cb_flags & USB_CB_INTR_CONTEXT)); + + vboxusb_urb_t *pUrb = (vboxusb_urb_t *)pReq->ctrl_client_private; + if (RT_LIKELY(pUrb)) + { + /* + * Funky stuff: We need to reconstruct the header for control transfers. + * Let us chain along the data and concatenate the entire message. + */ + mblk_t *pSetupMsg = allocb(sizeof(VUSBSETUP), BPRI_MED); + if (RT_LIKELY(pSetupMsg)) + { + VUSBSETUP SetupData; + SetupData.bmRequestType = pReq->ctrl_bmRequestType; + SetupData.bRequest = pReq->ctrl_bRequest; + SetupData.wValue = pReq->ctrl_wValue; + SetupData.wIndex = pReq->ctrl_wIndex; + SetupData.wLength = pReq->ctrl_wLength; + + bcopy(&SetupData, pSetupMsg->b_wptr, sizeof(VUSBSETUP)); + pSetupMsg->b_wptr += sizeof(VUSBSETUP); + + /* + * Should be safe to update pMsg here without the state mutex as typically nobody else + * touches this URB in the inflight list. + * + * The reason we choose to use vboxUsbSolarisConcatMsg here is that we don't assume the + * message returned by Solaris is one contiguous chunk in 'pMsg->b_rptr'. + */ + Assert(!pUrb->pMsg); + pUrb->pMsg = pSetupMsg; + pUrb->pMsg->b_cont = pReq->ctrl_data; + pReq->ctrl_data = NULL; + vboxUsbSolarisConcatMsg(pUrb); + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXferCompleted: Failed to alloc %u bytes for header\n", sizeof(VUSBSETUP))); + + /* + * Update the URB and move to landed list for reaping. + */ + vboxUsbSolarisDeQueueUrb(pUrb, pReq->ctrl_completion_reason); + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisCtrlXferCompleted: Extreme error! missing private data\n")); + + usb_free_ctrl_req(pReq); +} + + +/** + * Performs a Bulk Xfer. + * + * @param pState The USB device instance. + * @param pEp The Endpoint for the Xfer. + * @param pUrb The VBox USB URB. + * + * @returns VBox status code. + * @remarks Any errors, the caller should free pUrb->pMsg. + */ +LOCAL int vboxUsbSolarisBulkXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisBulkXfer: pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, + pUrb->enmDir, pUrb->cbDataR3)); + + /* + * Allocate a wrapper request. + */ + size_t const cbAlloc = pUrb->enmDir == VUSBDIRECTION_IN ? pUrb->cbDataR3 : 0; + usb_bulk_req_t *pReq = usb_alloc_bulk_req(pState->pDip, cbAlloc, USB_FLAGS_SLEEP); + if (RT_LIKELY(pReq)) + { + /* + * Initialize Bulk Xfer, callbacks and timeouts. + */ + usb_req_attrs_t fAttributes = USB_ATTRS_AUTOCLEARING; + if (pUrb->enmDir == VUSBDIRECTION_OUT) + { + pReq->bulk_data = pUrb->pMsg; + pUrb->pMsg = NULL; + } + else if ( pUrb->enmDir == VUSBDIRECTION_IN + && pUrb->fShortOk) + { + fAttributes |= USB_ATTRS_SHORT_XFER_OK; + } + + Assert(!pUrb->pMsg); + pReq->bulk_len = pUrb->cbDataR3; + pReq->bulk_cb = vboxUsbSolarisBulkXferCompleted; + pReq->bulk_exc_cb = vboxUsbSolarisBulkXferCompleted; + pReq->bulk_timeout = 0; + pReq->bulk_attributes = fAttributes; + pReq->bulk_client_private = (usb_opaque_t)pUrb; + + /* Don't obtain state lock here, we're just reading unchanging data... */ + if (RT_UNLIKELY(pUrb->cbDataR3 > pState->cbMaxBulkXfer)) + { + LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXfer: Requesting %d bytes when only %d bytes supported by device\n", + pUrb->cbDataR3, pState->cbMaxBulkXfer)); + } + + /* + * Submit the request. + */ + int rc = usb_pipe_bulk_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP); + if (RT_LIKELY(rc == USB_SUCCESS)) + return VINF_SUCCESS; + + LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXfer: Request failed! Ep=%#x rc=%d cbData=%u\n", pUrb->bEndpoint, rc, + pReq->bulk_len)); + + usb_free_bulk_req(pReq); + return VERR_PIPE_IO_ERROR; + } + + LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXfer: Failed to alloc bulk request\n")); + return VERR_NO_MEMORY; +} + + +/** + * Completion/Exception callback for Bulk Xfers. + * + * @param pPipe The Bulk pipe handle. + * @param pReq The Bulk request. + */ +LOCAL void vboxUsbSolarisBulkXferCompleted(usb_pipe_handle_t pPipe, usb_bulk_req_t *pReq) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisBulkXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq)); + + Assert(pReq); + Assert(!(pReq->bulk_cb_flags & USB_CB_INTR_CONTEXT)); + + vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe); + if (RT_LIKELY(pEp)) + { + vboxusb_urb_t *pUrb = (vboxusb_urb_t *)pReq->bulk_client_private; + if (RT_LIKELY(pUrb)) + { + Assert(!pUrb->pMsg); + if ( pUrb->enmDir == VUSBDIRECTION_IN + && pReq->bulk_data) + { + pUrb->pMsg = pReq->bulk_data; + pReq->bulk_data = NULL; + vboxUsbSolarisConcatMsg(pUrb); + } + + /* + * Update the URB and move to tail for reaping. + */ + vboxUsbSolarisDeQueueUrb(pUrb, pReq->bulk_completion_reason); + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisBulkXferCompleted: Extreme error! private request data missing!\n")); + } + else + Log((DEVICE_NAME ": vboxUsbSolarisBulkXferCompleted: Pipe Gone!\n")); + + usb_free_bulk_req(pReq); +} + + +/** + * Performs an Interrupt Xfer. + * + * @param pState The USB device instance. + * @param pEp The Endpoint for the Xfer. + * @param pUrb The VBox USB URB. + * + * @returns VBox status code. + * @remarks Any errors, the caller should free pUrb->pMsg. + */ +LOCAL int vboxUsbSolarisIntrXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisIntrXfer: pState=%p pEp=%p pUrb=%p enmDir=%d cbData=%d\n", pState, pEp, pUrb, + pUrb->enmDir, pUrb->cbDataR3)); + + usb_intr_req_t *pReq = usb_alloc_intr_req(pState->pDip, 0 /* length */, USB_FLAGS_SLEEP); + if (RT_LIKELY(pReq)) + { + /* + * Initialize Intr Xfer, callbacks & timeouts. + */ + usb_req_attrs_t fAttributes = USB_ATTRS_AUTOCLEARING; + if (pUrb->enmDir == VUSBDIRECTION_OUT) + { + pReq->intr_data = pUrb->pMsg; + pUrb->pMsg = NULL; + } + else + { + Assert(pUrb->enmDir == VUSBDIRECTION_IN); + fAttributes |= USB_ATTRS_ONE_XFER; + if (pUrb->fShortOk) + fAttributes |= USB_ATTRS_SHORT_XFER_OK; + } + + Assert(!pUrb->pMsg); + pReq->intr_len = pUrb->cbDataR3; /* Not pEp->EpDesc.wMaxPacketSize */ + pReq->intr_cb = vboxUsbSolarisIntrXferCompleted; + pReq->intr_exc_cb = vboxUsbSolarisIntrXferCompleted; + pReq->intr_timeout = 0; + pReq->intr_attributes = fAttributes; + pReq->intr_client_private = (usb_opaque_t)pUrb; + + /* + * Submit the request. + */ + int rc = usb_pipe_intr_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP); + if (RT_LIKELY(rc == USB_SUCCESS)) + return VINF_SUCCESS; + + LogRel((DEVICE_NAME ": vboxUsbSolarisIntrXfer: usb_pipe_intr_xfer failed! rc=%d bEndpoint=%#x\n", rc, pUrb->bEndpoint)); + + usb_free_intr_req(pReq); + return VERR_PIPE_IO_ERROR; + } + + LogRel((DEVICE_NAME ": vboxUsbSolarisIntrXfer: Failed to alloc intr request\n")); + return VERR_NO_MEMORY; +} + + +/** + * Completion/Exception callback for Intr Xfers. + * + * @param pPipe The Intr pipe handle. + * @param pReq The Intr request. + */ +LOCAL void vboxUsbSolarisIntrXferCompleted(usb_pipe_handle_t pPipe, usb_intr_req_t *pReq) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisIntrXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq)); + + Assert(pReq); + Assert(!(pReq->intr_cb_flags & USB_CB_INTR_CONTEXT)); + + vboxusb_urb_t *pUrb = (vboxusb_urb_t *)pReq->intr_client_private; + if (RT_LIKELY(pUrb)) + { + if ( pUrb->enmDir == VUSBDIRECTION_IN + && pReq->intr_data) + { + pUrb->pMsg = pReq->intr_data; + pReq->intr_data = NULL; + vboxUsbSolarisConcatMsg(pUrb); + } + + /* + * Update the URB and move to landed list for reaping. + */ + vboxUsbSolarisDeQueueUrb(pUrb, pReq->intr_completion_reason); + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisIntrXferCompleted: Extreme error! private request data missing\n")); + + usb_free_intr_req(pReq); +} + + +/** + * Performs an Isochronous Xfer. + * + * @param pState The USB device instance. + * @param pEp The Endpoint for the Xfer. + * @param pUrb The VBox USB URB. + * + * @returns VBox status code. + * @remarks Any errors, the caller should free pUrb->pMsg. + */ +LOCAL int vboxUsbSolarisIsocXfer(vboxusb_state_t *pState, vboxusb_ep_t *pEp, vboxusb_urb_t *pUrb) +{ + /* LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocXfer: pState=%p pEp=%p pUrb=%p\n", pState, pEp, pUrb)); */ + + /* + * For Isoc. IN transfers we perform one request and USBA polls the device continuously + * and supplies our Xfer callback with input data. We cannot perform one-shot Isoc. In transfers. + */ + size_t cbData = (pUrb->enmDir == VUSBDIRECTION_IN ? pUrb->cIsocPkts * pUrb->aIsocPkts[0].cbPkt : 0); + if (pUrb->enmDir == VUSBDIRECTION_IN) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsocXfer: Isoc. IN - Queueing\n")); + + mutex_enter(&pState->Mtx); + if (pEp->fIsocPolling) + { + /* + * Queue a maximum of cbMaxIsocData bytes, else fail. + */ + if (pEp->cbIsocInLandedReqs + cbData > pEp->cbMaxIsocData) + { + mutex_exit(&pState->Mtx); + Log((DEVICE_NAME ": vboxUsbSolarisIsocXfer: Max Isoc. data %d bytes queued\n", pEp->cbMaxIsocData)); + return VERR_TOO_MUCH_DATA; + } + + list_insert_tail(&pEp->hIsocInUrbs, pUrb); + ++pEp->cIsocInUrbs; + + mutex_exit(&pState->Mtx); + return VINF_SUCCESS; + } + mutex_exit(&pState->Mtx); + } + + int rc = VINF_SUCCESS; + usb_isoc_req_t *pReq = usb_alloc_isoc_req(pState->pDip, pUrb->cIsocPkts, cbData, USB_FLAGS_NOSLEEP); + Log((DEVICE_NAME ": vboxUsbSolarisIsocXfer: enmDir=%#x cIsocPkts=%d aIsocPkts[0]=%d cbDataR3=%d\n", pUrb->enmDir, + pUrb->cIsocPkts, pUrb->aIsocPkts[0].cbPkt, pUrb->cbDataR3)); + if (RT_LIKELY(pReq)) + { + /* + * Initialize Isoc Xfer, callbacks & timeouts. + */ + for (unsigned i = 0; i < pUrb->cIsocPkts; i++) + pReq->isoc_pkt_descr[i].isoc_pkt_length = pUrb->aIsocPkts[i].cbPkt; + + if (pUrb->enmDir == VUSBDIRECTION_OUT) + { + pReq->isoc_data = pUrb->pMsg; + pReq->isoc_attributes = USB_ATTRS_AUTOCLEARING | USB_ATTRS_ISOC_XFER_ASAP; + pReq->isoc_cb = vboxUsbSolarisIsocOutXferCompleted; + pReq->isoc_exc_cb = vboxUsbSolarisIsocOutXferCompleted; + pReq->isoc_client_private = (usb_opaque_t)pUrb; + } + else + { + pReq->isoc_attributes = USB_ATTRS_AUTOCLEARING | USB_ATTRS_ISOC_XFER_ASAP | USB_ATTRS_SHORT_XFER_OK; + pReq->isoc_cb = vboxUsbSolarisIsocInXferCompleted; + pReq->isoc_exc_cb = vboxUsbSolarisIsocInXferError; + pReq->isoc_client_private = (usb_opaque_t)pState; + } + pReq->isoc_pkts_count = pUrb->cIsocPkts; + pReq->isoc_pkts_length = 0; /* auto compute */ + + /* + * Submit the request. + */ + rc = usb_pipe_isoc_xfer(pEp->pPipe, pReq, USB_FLAGS_NOSLEEP); + if (RT_LIKELY(rc == USB_SUCCESS)) + { + if (pUrb->enmDir == VUSBDIRECTION_IN) + { + /* + * Add the first Isoc. IN URB to the queue as well. + */ + mutex_enter(&pState->Mtx); + list_insert_tail(&pEp->hIsocInUrbs, pUrb); + ++pEp->cIsocInUrbs; + pEp->fIsocPolling = true; + mutex_exit(&pState->Mtx); + } + + return VINF_SUCCESS; + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisIsocXfer: usb_pipe_isoc_xfer failed! rc=%d\n", rc)); + rc = VERR_PIPE_IO_ERROR; + + if (pUrb->enmDir == VUSBDIRECTION_IN) + { + mutex_enter(&pState->Mtx); + vboxusb_urb_t *pIsocFailedUrb = list_remove_tail(&pEp->hIsocInUrbs); + if (pIsocFailedUrb) + { + RTMemFree(pIsocFailedUrb); + --pEp->cIsocInUrbs; + } + pEp->fIsocPolling = false; + mutex_exit(&pState->Mtx); + } + } + + if (pUrb->enmDir == VUSBDIRECTION_OUT) + { + freemsg(pUrb->pMsg); + pUrb->pMsg = NULL; + } + + usb_free_isoc_req(pReq); + } + else + { + LogRel((DEVICE_NAME ": vboxUsbSolarisIsocXfer: Failed to alloc isoc req for %d packets\n", pUrb->cIsocPkts)); + rc = VERR_NO_MEMORY; + } + + return rc; +} + + +/** + * Completion/Exception callback for Isoc IN Xfers. + * + * @param pPipe The Intr pipe handle. + * @param pReq The Intr request. + * + * @remarks Completion callback executes in interrupt context! + */ +LOCAL void vboxUsbSolarisIsocInXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq) +{ + /* LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq)); */ + + vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private; + if (RT_LIKELY(pState)) + { + vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe); + if ( pEp + && pEp->pPipe) + { +#if 0 + /* + * Stop polling if all packets failed. + */ + if (pReq->isoc_error_count == pReq->isoc_pkts_count) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Stopping polling! Too many errors\n")); + mutex_exit(&pState->Mtx); + usb_pipe_stop_isoc_polling(pPipe, USB_FLAGS_NOSLEEP); + mutex_enter(&pState->Mtx); + pEp->fIsocPolling = false; + } +#endif + + /** @todo Query and verify this at runtime. */ + AssertCompile(sizeof(VUSBISOC_PKT_DESC) == sizeof(usb_isoc_pkt_descr_t)); + if (RT_LIKELY(pReq->isoc_data)) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: cIsocInUrbs=%d cbIsocInLandedReqs=%d\n", pEp->cIsocInUrbs, + pEp->cbIsocInLandedReqs)); + + mutex_enter(&pState->Mtx); + + /* + * If there are waiting URBs, satisfy the oldest one. + */ + if ( pEp->cIsocInUrbs > 0 + && pEp->cbIsocInLandedReqs == 0) + { + vboxusb_urb_t *pUrb = list_remove_head(&pEp->hIsocInUrbs); + if (RT_LIKELY(pUrb)) + { + --pEp->cIsocInUrbs; + mutex_exit(&pState->Mtx); + + for (unsigned i = 0; i < pReq->isoc_pkts_count; i++) + { + pUrb->aIsocPkts[i].cbActPkt = pReq->isoc_pkt_descr[i].isoc_pkt_actual_length; + pUrb->aIsocPkts[i].enmStatus = vboxUsbSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status); + } + + pUrb->pMsg = pReq->isoc_data; + pReq->isoc_data = NULL; + + /* + * Move to landed list + */ + mutex_enter(&pState->Mtx); + list_insert_tail(&pState->hLandedUrbs, pUrb); + ++pState->cLandedUrbs; + vboxUsbSolarisNotifyComplete(pState); + } + else + { + /* Huh!? cIsocInUrbs is wrong then! Should never happen unless we decide to decrement cIsocInUrbs in + Reap time */ + pEp->cIsocInUrbs = 0; + LogRel((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Extreme error! Isoc. counter borked!\n")); + } + + mutex_exit(&pState->Mtx); + usb_free_isoc_req(pReq); + return; + } + + mutex_exit(&pState->Mtx); + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Data missing\n")); + } + else + LogRel((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: Pipe Gone\n")); + } + else + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferCompleted: State Gone\n")); + + usb_free_isoc_req(pReq); +} + + +/** + * Exception callback for Isoc IN Xfers. + * + * @param pPipe The Intr pipe handle. + * @param pReq The Intr request. + * @remarks Completion callback executes in interrupt context! + */ +LOCAL void vboxUsbSolarisIsocInXferError(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: pPipe=%p pReq=%p\n", pPipe, pReq)); + + vboxusb_state_t *pState = (vboxusb_state_t *)pReq->isoc_client_private; + if (RT_UNLIKELY(!pState)) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: State Gone\n")); + usb_free_isoc_req(pReq); + return; + } + + mutex_enter(&pState->Mtx); + vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe); + if (RT_UNLIKELY(!pEp)) + { + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Pipe Gone\n")); + mutex_exit(&pState->Mtx); + usb_free_isoc_req(pReq); + return; + } + + switch(pReq->isoc_completion_reason) + { + case USB_CR_NO_RESOURCES: + { + /* + * Resubmit the request in case the original request did not complete due to + * immediately unavailable requests + */ + mutex_exit(&pState->Mtx); + usb_pipe_isoc_xfer(pPipe, pReq, USB_FLAGS_NOSLEEP); + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Resubmitted Isoc. IN request due to unavailable resources\n")); + return; + } + + case USB_CR_PIPE_CLOSING: + case USB_CR_STOPPED_POLLING: + case USB_CR_PIPE_RESET: + { + pEp->fIsocPolling = false; + usb_free_isoc_req(pReq); + break; + } + + default: + { + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Stopping Isoc. IN polling due to rc=%d\n", + pReq->isoc_completion_reason)); + pEp->fIsocPolling = false; + mutex_exit(&pState->Mtx); + usb_pipe_stop_isoc_polling(pPipe, USB_FLAGS_NOSLEEP); + usb_free_isoc_req(pReq); + mutex_enter(&pState->Mtx); + break; + } + } + + /* + * Dequeue i.e. delete the last queued Isoc In. URB. as failed. + */ + vboxusb_urb_t *pUrb = list_remove_tail(&pEp->hIsocInUrbs); + if (pUrb) + { + --pEp->cIsocInUrbs; + Log((DEVICE_NAME ": vboxUsbSolarisIsocInXferError: Deleting last queued URB as it failed\n")); + freemsg(pUrb->pMsg); + RTMemFree(pUrb); + vboxUsbSolarisNotifyComplete(pState); + } + + mutex_exit(&pState->Mtx); +} + + +/** + * Completion/Exception callback for Isoc OUT Xfers. + * + * @param pPipe The Intr pipe handle. + * @param pReq The Intr request. + * @remarks Completion callback executes in interrupt context! + */ +LOCAL void vboxUsbSolarisIsocOutXferCompleted(usb_pipe_handle_t pPipe, usb_isoc_req_t *pReq) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: pPipe=%p pReq=%p\n", pPipe, pReq)); + + vboxusb_ep_t *pEp = (vboxusb_ep_t *)usb_pipe_get_private(pPipe); + if (RT_LIKELY(pEp)) + { + vboxusb_urb_t *pUrb = (vboxusb_urb_t *)pReq->isoc_client_private; + if (RT_LIKELY(pUrb)) + { + size_t cbActPkt = 0; + for (int i = 0; i < pReq->isoc_pkts_count; i++) + { + cbActPkt += pReq->isoc_pkt_descr[i].isoc_pkt_actual_length; + pUrb->aIsocPkts[i].cbActPkt = pReq->isoc_pkt_descr[i].isoc_pkt_actual_length; + pUrb->aIsocPkts[i].enmStatus = vboxUsbSolarisGetUrbStatus(pReq->isoc_pkt_descr[i].isoc_pkt_status); + } + + Log((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: cIsocPkts=%d cbData=%d cbActPkt=%d\n", pUrb->cIsocPkts, + pUrb->cbDataR3, cbActPkt)); + + if (pReq->isoc_completion_reason == USB_CR_OK) + { + if (RT_UNLIKELY(pUrb->pMsg != pReq->isoc_data)) /* Paranoia */ + { + freemsg(pUrb->pMsg); + pUrb->pMsg = pReq->isoc_data; + } + } + pReq->isoc_data = NULL; + + pUrb->cIsocPkts = pReq->isoc_pkts_count; + pUrb->cbDataR3 = cbActPkt; + + /* + * Update the URB and move to landed list for reaping. + */ + vboxUsbSolarisDeQueueUrb(pUrb, pReq->isoc_completion_reason); + } + else + Log((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: Missing private data!?! Dropping OUT pUrb\n")); + } + else + Log((DEVICE_NAME ": vboxUsbSolarisIsocOutXferCompleted: Pipe Gone\n")); + + usb_free_isoc_req(pReq); +} + + +/** + * Callback when the device gets disconnected. + * + * @param pDip The module structure instance. + * + * @returns Solaris USB error code. + */ +LOCAL int vboxUsbSolarisDeviceDisconnected(dev_info_t *pDip) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceDisconnected: pDip=%p\n", pDip)); + + int instance = ddi_get_instance(pDip); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + + if (RT_LIKELY(pState)) + { + /* + * Serialize access: exclusive access to the state. + */ + usb_serialize_access(pState->StateMulti, USB_WAIT, 0); + mutex_enter(&pState->Mtx); + + pState->DevState = USB_DEV_DISCONNECTED; + + vboxUsbSolarisCloseAllPipes(pState, true /* ControlPipe */); + vboxUsbSolarisNotifyUnplug(pState); + + mutex_exit(&pState->Mtx); + usb_release_access(pState->StateMulti); + + return USB_SUCCESS; + } + + LogRel((DEVICE_NAME ": vboxUsbSolarisDeviceDisconnected: Failed to get device state!\n")); + return USB_FAILURE; +} + + +/** + * Callback when the device gets reconnected. + * + * @param pDip The module structure instance. + * + * @returns Solaris USB error code. + */ +LOCAL int vboxUsbSolarisDeviceReconnected(dev_info_t *pDip) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceReconnected: pDip=%p\n", pDip)); + + int instance = ddi_get_instance(pDip); + vboxusb_state_t *pState = ddi_get_soft_state(g_pVBoxUSBSolarisState, instance); + + if (RT_LIKELY(pState)) + { + vboxUsbSolarisDeviceRestore(pState); + return USB_SUCCESS; + } + + LogRel((DEVICE_NAME ": vboxUsbSolarisDeviceReconnected: Failed to get device state!\n")); + return USB_FAILURE; +} + + +/** + * Restores device state after a reconnect or resume. + * + * @param pState The USB device instance. + */ +LOCAL void vboxUsbSolarisDeviceRestore(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceRestore: pState=%p\n", pState)); + AssertPtrReturnVoid(pState); + + /* + * Raise device power. + */ + vboxUsbSolarisPowerBusy(pState); + int rc = pm_raise_power(pState->pDip, 0 /* component */, USB_DEV_OS_FULL_PWR); + + /* + * Check if the same device is resumed/reconnected. + */ + rc = usb_check_same_device(pState->pDip, + NULL, /* log handle */ + USB_LOG_L2, /* log level */ + -1, /* log mask */ + USB_CHK_ALL, /* check level */ + NULL); /* device string */ + + if (rc != USB_SUCCESS) + { + mutex_enter(&pState->Mtx); + pState->DevState = USB_DEV_DISCONNECTED; + mutex_exit(&pState->Mtx); + + /* Do we need to inform userland here? */ + vboxUsbSolarisPowerIdle(pState); + Log((DEVICE_NAME ": vboxUsbSolarisDeviceRestore: Not the same device\n")); + return; + } + + /* + * Serialize access to not race with other PM functions. + */ + usb_serialize_access(pState->StateMulti, USB_WAIT, 0); + + mutex_enter(&pState->Mtx); + if (pState->DevState == USB_DEV_DISCONNECTED) + pState->DevState = USB_DEV_ONLINE; + else if (pState->DevState == USB_DEV_SUSPENDED) + pState->DevState = USB_DEV_ONLINE; + + mutex_exit(&pState->Mtx); + usb_release_access(pState->StateMulti); + + vboxUsbSolarisPowerIdle(pState); +} + + +/** + * Restores device state after a reconnect or resume. + * + * @param pState The USB device instance. + * + * @returns VBox status code. + */ +LOCAL int vboxUsbSolarisDeviceSuspend(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceSuspend: pState=%p\n", pState)); + + int rc = VERR_VUSB_DEVICE_IS_SUSPENDED; + mutex_enter(&pState->Mtx); + + switch (pState->DevState) + { + case USB_DEV_SUSPENDED: + { + LogRel((DEVICE_NAME ": vboxUsbSolarisDeviceSuspend: Invalid device state %d\n", pState->DevState)); + break; + } + + case USB_DEV_ONLINE: + case USB_DEV_DISCONNECTED: + case USB_DEV_PWRED_DOWN: + { + int PreviousState = pState->DevState; + pState->DevState = USB_DEV_DISCONNECTED; + + /** @todo this doesn't make sense when for e.g. an INTR IN URB with infinite + * timeout is pending on the device. Fix suspend logic later. */ + /* + * Drain pending URBs. + */ + for (int i = 0; i < VBOXUSB_DRAIN_TIME; i++) + { + if (pState->cInflightUrbs < 1) + break; + + mutex_exit(&pState->Mtx); + delay(drv_usectohz(100000)); + mutex_enter(&pState->Mtx); + } + + /* + * Deny suspend if we still have pending URBs. + */ + if (pState->cInflightUrbs > 0) + { + pState->DevState = PreviousState; + LogRel((DEVICE_NAME ": Cannot suspend %s %s (Ident=%s), %d inflight URBs\n", pState->szMfg, pState->szProduct, + pState->ClientInfo.szDeviceIdent, pState->cInflightUrbs)); + + mutex_exit(&pState->Mtx); + return VERR_RESOURCE_BUSY; + } + + pState->cInflightUrbs = 0; + + /* + * Serialize access to not race with Open/Detach/Close and + * Close all pipes including the default pipe. + */ + mutex_exit(&pState->Mtx); + usb_serialize_access(pState->StateMulti, USB_WAIT, 0); + mutex_enter(&pState->Mtx); + + vboxUsbSolarisCloseAllPipes(pState, true /* default pipe */); + vboxUsbSolarisNotifyUnplug(pState); + + mutex_exit(&pState->Mtx); + usb_release_access(pState->StateMulti); + + LogRel((DEVICE_NAME ": Suspended %s %s (Ident=%s)\n", pState->szMfg, pState->szProduct, + pState->ClientInfo.szDeviceIdent)); + return VINF_SUCCESS; + } + } + + mutex_exit(&pState->Mtx); + Log((DEVICE_NAME ": vboxUsbSolarisDeviceSuspend: Returns %d\n", rc)); + return rc; +} + + +/** + * Restores device state after a reconnect or resume. + * + * @param pState The USB device instance. + */ +LOCAL void vboxUsbSolarisDeviceResume(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisDeviceResume: pState=%p\n", pState)); + return vboxUsbSolarisDeviceRestore(pState); +} + + +/** + * Flags the PM component as busy so the system will not manage it's power. + * + * @param pState The USB device instance. + */ +LOCAL void vboxUsbSolarisPowerBusy(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisPowerBusy: pState=%p\n", pState)); + AssertPtrReturnVoid(pState); + + mutex_enter(&pState->Mtx); + if (pState->pPower) + { + pState->pPower->PowerBusy++; + mutex_exit(&pState->Mtx); + + int rc = pm_busy_component(pState->pDip, 0 /* component */); + if (rc != DDI_SUCCESS) + { + Log((DEVICE_NAME ": vboxUsbSolarisPowerBusy: Busy component failed! rc=%d\n", rc)); + mutex_enter(&pState->Mtx); + pState->pPower->PowerBusy--; + mutex_exit(&pState->Mtx); + } + } + else + mutex_exit(&pState->Mtx); +} + + +/** + * Flags the PM component as idle so its power managed by the system. + * + * @param pState The USB device instance. + */ +LOCAL void vboxUsbSolarisPowerIdle(vboxusb_state_t *pState) +{ + LogFunc((DEVICE_NAME ": vboxUsbSolarisPowerIdle: pState=%p\n", pState)); + AssertPtrReturnVoid(pState); + + if (pState->pPower) + { + int rc = pm_idle_component(pState->pDip, 0 /* component */); + if (rc == DDI_SUCCESS) + { + mutex_enter(&pState->Mtx); + Assert(pState->pPower->PowerBusy > 0); + pState->pPower->PowerBusy--; + mutex_exit(&pState->Mtx); + } + else + Log((DEVICE_NAME ": vboxUsbSolarisPowerIdle: Idle component failed! rc=%d\n", rc)); + } +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSBMon-solaris.c b/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSBMon-solaris.c new file mode 100644 index 00000000..3d9b9ab3 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/solaris/VBoxUSBMon-solaris.c @@ -0,0 +1,1048 @@ +/* $Id: VBoxUSBMon-solaris.c $ */ +/** @file + * VirtualBox USB Monitor Driver, Solaris Hosts. + */ + +/* + * Copyright (C) 2008-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_USB_DRV +#include "VBoxUSBFilterMgr.h" +#include <VBox/usblib-solaris.h> +#include <VBox/version.h> +#include <VBox/log.h> +#include <VBox/cdefs.h> +#include <VBox/types.h> +#include <VBox/version.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/initterm.h> +#include <iprt/mem.h> +#include <iprt/process.h> +#include <iprt/path.h> +#include <iprt/semaphore.h> +#include <iprt/string.h> + +#define USBDRV_MAJOR_VER 2 +#define USBDRV_MINOR_VER 0 +#include <sys/usb/usba.h> +#include <sys/conf.h> +#include <sys/modctl.h> +#include <sys/mutex.h> +#include <sys/stat.h> +#include <sys/ddi.h> +#include <sys/sunddi.h> +#include <sys/sunndi.h> +#include <sys/open.h> +#include <sys/cmn_err.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The module name. */ +#define DEVICE_NAME "vboxusbmon" +/** The module description as seen in 'modinfo'. */ +#define DEVICE_DESC_DRV "VirtualBox USBMon" + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int VBoxUSBMonSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred); +static int VBoxUSBMonSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred); +static int VBoxUSBMonSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred); +static int VBoxUSBMonSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred); +static int VBoxUSBMonSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal); +static int VBoxUSBMonSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pArg, void **ppResult); +static int VBoxUSBMonSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd); +static int VBoxUSBMonSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd); + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * cb_ops: for drivers that support char/block entry points + */ +static struct cb_ops g_VBoxUSBMonSolarisCbOps = +{ + VBoxUSBMonSolarisOpen, + VBoxUSBMonSolarisClose, + nodev, /* b strategy */ + nodev, /* b dump */ + nodev, /* b print */ + VBoxUSBMonSolarisRead, + VBoxUSBMonSolarisWrite, + VBoxUSBMonSolarisIOCtl, + nodev, /* c devmap */ + nodev, /* c mmap */ + nodev, /* c segmap */ + nochpoll, /* c poll */ + ddi_prop_op, /* property ops */ + NULL, /* streamtab */ + D_NEW | D_MP, /* compat. flag */ + CB_REV /* revision */ +}; + +/** + * dev_ops: for driver device operations + */ +static struct dev_ops g_VBoxUSBMonSolarisDevOps = +{ + DEVO_REV, /* driver build revision */ + 0, /* ref count */ + VBoxUSBMonSolarisGetInfo, + nulldev, /* identify */ + nulldev, /* probe */ + VBoxUSBMonSolarisAttach, + VBoxUSBMonSolarisDetach, + nodev, /* reset */ + &g_VBoxUSBMonSolarisCbOps, + (struct bus_ops *)0, + nodev, /* power */ + ddi_quiesce_not_needed +}; + +/** + * modldrv: export driver specifics to the kernel + */ +static struct modldrv g_VBoxUSBMonSolarisModule = +{ + &mod_driverops, /* extern from kernel */ + DEVICE_DESC_DRV " " VBOX_VERSION_STRING "r" RT_XSTR(VBOX_SVN_REV), + &g_VBoxUSBMonSolarisDevOps +}; + +/** + * modlinkage: export install/remove/info to the kernel + */ +static struct modlinkage g_VBoxUSBMonSolarisModLinkage = +{ + MODREV_1, + &g_VBoxUSBMonSolarisModule, + NULL, +}; + +/** + * Client driver info. + */ +typedef struct vboxusbmon_client_t +{ + dev_info_t *pDip; /* Client device info. pointer */ + VBOXUSB_CLIENT_INFO Info; /* Client registration data. */ + struct vboxusbmon_client_t *pNext; /* Pointer to next client */ +} vboxusbmon_client_t; + +/** + * Device state info. + */ +typedef struct +{ + RTPROCESS Process; /* The process (id) of the session */ +} vboxusbmon_state_t; + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Global Device handle we only support one instance. */ +static dev_info_t *g_pDip = NULL; +/** Global Mutex. */ +static kmutex_t g_VBoxUSBMonSolarisMtx; +/** Global list of client drivers registered with us. */ +vboxusbmon_client_t *g_pVBoxUSBMonSolarisClients = NULL; +/** Opaque pointer to list of soft states. */ +static void *g_pVBoxUSBMonSolarisState; + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int vboxUSBMonSolarisProcessIOCtl(int iFunction, void *pvState, void *pvData, size_t cbData, size_t *pcbReturnedData); +static int vboxUSBMonSolarisResetDevice(char *pszDevicePath, bool fReattach); + + +/********************************************************************************************************************************* +* Monitor Global Hooks * +*********************************************************************************************************************************/ +static int vboxUSBMonSolarisClientInfo(vboxusbmon_state_t *pState, PVBOXUSB_CLIENT_INFO pClientInfo); +int VBoxUSBMonSolarisRegisterClient(dev_info_t *pClientDip, PVBOXUSB_CLIENT_INFO pClientInfo); +int VBoxUSBMonSolarisUnregisterClient(dev_info_t *pClientDip); +int VBoxUSBMonSolarisElectDriver(usb_dev_descr_t *pDevDesc, usb_dev_str_t *pDevStrings, char *pszDevicePath, int Bus, int Port, + char **ppszDrv, void *pvReserved); + + +/** + * Kernel entry points + */ +int _init(void) +{ + int rc; + + LogFunc((DEVICE_NAME ": _init\n")); + + g_pDip = NULL; + + /* + * Prevent module autounloading. + */ + modctl_t *pModCtl = mod_getctl(&g_VBoxUSBMonSolarisModLinkage); + if (pModCtl) + pModCtl->mod_loadflags |= MOD_NOAUTOUNLOAD; + else + LogRel((DEVICE_NAME ": _init: Failed to disable autounloading!\n")); + + /* + * Initialize IPRT R0 driver, which internally calls OS-specific r0 init. + */ + rc = RTR0Init(0); + if (RT_SUCCESS(rc)) + { + /* + * Initialize global mutex. + */ + mutex_init(&g_VBoxUSBMonSolarisMtx, NULL, MUTEX_DRIVER, NULL); + rc = VBoxUSBFilterInit(); + if (RT_SUCCESS(rc)) + { + rc = ddi_soft_state_init(&g_pVBoxUSBMonSolarisState, sizeof(vboxusbmon_state_t), 1); + if (!rc) + { + rc = mod_install(&g_VBoxUSBMonSolarisModLinkage); + if (!rc) + return rc; + + LogRel((DEVICE_NAME ": _init: mod_install failed! rc=%d\n", rc)); + ddi_soft_state_fini(&g_pVBoxUSBMonSolarisState); + } + else + LogRel((DEVICE_NAME ": _init: ddi_soft_state_init failed! rc=%d\n", rc)); + } + else + LogRel((DEVICE_NAME ": _init: VBoxUSBFilterInit failed! rc=%d\n", rc)); + + mutex_destroy(&g_VBoxUSBMonSolarisMtx); + RTR0Term(); + } + else + LogRel((DEVICE_NAME ": _init: RTR0Init failed! rc=%d\n", rc)); + + return -1; +} + + +int _fini(void) +{ + int rc; + + LogFunc((DEVICE_NAME ": _fini\n")); + + rc = mod_remove(&g_VBoxUSBMonSolarisModLinkage); + if (!rc) + { + ddi_soft_state_fini(&g_pVBoxUSBMonSolarisState); + VBoxUSBFilterTerm(); + mutex_destroy(&g_VBoxUSBMonSolarisMtx); + + RTR0Term(); + } + return rc; +} + + +int _info(struct modinfo *pModInfo) +{ + LogFunc((DEVICE_NAME ": _info\n")); + + return mod_info(&g_VBoxUSBMonSolarisModLinkage, pModInfo); +} + + +/** + * Attach entry point, to attach a device to the system or resume it. + * + * @param pDip The module structure instance. + * @param enmCmd Attach type (ddi_attach_cmd_t) + * + * @returns corresponding solaris error code. + */ +static int VBoxUSBMonSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisAttach: pDip=%p enmCmd=%d\n", pDip, enmCmd)); + switch (enmCmd) + { + case DDI_ATTACH: + { + if (RT_UNLIKELY(g_pDip)) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: Global instance already initialized\n")); + return DDI_FAILURE; + } + + g_pDip = pDip; + int instance = ddi_get_instance(pDip); + int rc = ddi_create_priv_minor_node(pDip, DEVICE_NAME, S_IFCHR, instance, DDI_PSEUDO, 0, + "none", "none", 0660); + if (rc == DDI_SUCCESS) + { + rc = usb_register_dev_driver(g_pDip, VBoxUSBMonSolarisElectDriver); + if (rc == DDI_SUCCESS) + { + ddi_report_dev(pDip); + return DDI_SUCCESS; + } + + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: Failed to register driver election callback! rc=%d\n", rc)); + } + else + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisAttach: ddi_create_minor_node failed! rc=%d\n", rc)); + return DDI_FAILURE; + } + + case DDI_RESUME: + { + /* We don't have to bother about power management. */ + return DDI_SUCCESS; + } + + default: + return DDI_FAILURE; + } +} + + +/** + * Detach entry point, to detach a device to the system or suspend it. + * + * @param pDip The module structure instance. + * @param enmCmd Attach type (ddi_attach_cmd_t) + * + * @returns corresponding solaris error code. + */ +static int VBoxUSBMonSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t enmCmd) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisDetach\n")); + + switch (enmCmd) + { + case DDI_DETACH: + { + /* + * Free all registered clients' info. + */ + mutex_enter(&g_VBoxUSBMonSolarisMtx); + vboxusbmon_client_t *pCur = g_pVBoxUSBMonSolarisClients; + while (pCur) + { + vboxusbmon_client_t *pNext = pCur->pNext; + RTMemFree(pCur); + pCur = pNext; + } + mutex_exit(&g_VBoxUSBMonSolarisMtx); + + usb_unregister_dev_driver(g_pDip); + + ddi_remove_minor_node(pDip, NULL); + g_pDip = NULL; + return DDI_SUCCESS; + } + + case DDI_SUSPEND: + { + /* We don't have to bother about power management. */ + return DDI_SUCCESS; + } + + default: + return DDI_FAILURE; + } +} + + +/** + * Info entry point, called by solaris kernel for obtaining driver info. + * + * @param pDip The module structure instance (do not use). + * @param enmCmd Information request type. + * @param pvArg Type specific argument. + * @param ppvResult Where to store the requested info. + * + * @returns corresponding solaris error code. + */ +static int VBoxUSBMonSolarisGetInfo(dev_info_t *pDip, ddi_info_cmd_t enmCmd, void *pvArg, void **ppvResult) +{ + int rc = DDI_SUCCESS; + + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisGetInfo\n")); + + switch (enmCmd) + { + case DDI_INFO_DEVT2DEVINFO: + *ppvResult = (void *)g_pDip; + break; + + case DDI_INFO_DEVT2INSTANCE: + *ppvResult = (void *)(uintptr_t)ddi_get_instance(g_pDip); + break; + + default: + rc = DDI_FAILURE; + break; + } + return rc; +} + + +static int VBoxUSBMonSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred) +{ + vboxusbmon_state_t *pState = NULL; + unsigned iOpenInstance; + + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisOpen\n")); + + /* + * Verify we are being opened as a character device. + */ + if (fType != OTYP_CHR) + return EINVAL; + + /* + * Verify that we're called after attach. + */ + if (!g_pDip) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisOpen: Invalid state for opening\n")); + return ENXIO; + } + + for (iOpenInstance = 0; iOpenInstance < 4096; iOpenInstance++) + { + if ( !ddi_get_soft_state(g_pVBoxUSBMonSolarisState, iOpenInstance) /* faster */ + && ddi_soft_state_zalloc(g_pVBoxUSBMonSolarisState, iOpenInstance) == DDI_SUCCESS) + { + pState = ddi_get_soft_state(g_pVBoxUSBMonSolarisState, iOpenInstance); + break; + } + } + if (!pState) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisOpen: Too many open instances")); + return ENXIO; + } + + pState->Process = RTProcSelf(); + *pDev = makedevice(getmajor(*pDev), iOpenInstance); + + NOREF(fFlag); + NOREF(pCred); + + return 0; +} + + +static int VBoxUSBMonSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred) +{ + vboxusbmon_state_t *pState = NULL; + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisClose\n")); + + pState = ddi_get_soft_state(g_pVBoxUSBMonSolarisState, getminor(Dev)); + if (!pState) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisClose: Failed to get state\n")); + return EFAULT; + } + + /* + * Remove all filters for this client process. + */ + VBoxUSBFilterRemoveOwner(pState->Process); + + ddi_soft_state_free(g_pVBoxUSBMonSolarisState, getminor(Dev)); + pState = NULL; + + NOREF(fFlag); + NOREF(fType); + NOREF(pCred); + + return 0; +} + + +static int VBoxUSBMonSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisRead\n")); + return 0; +} + + +static int VBoxUSBMonSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisWrite\n")); + return 0; +} + + +/** @def IOCPARM_LEN + * Gets the length from the ioctl number. + * This is normally defined by sys/ioccom.h on BSD systems... + */ +#ifndef IOCPARM_LEN +# define IOCPARM_LEN(Code) (((Code) >> 16) & IOCPARM_MASK) +#endif + +static int VBoxUSBMonSolarisIOCtl(dev_t Dev, int Cmd, intptr_t pArg, int Mode, cred_t *pCred, int *pVal) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Dev=%d Cmd=%d pArg=%p Mode=%d\n", Dev, Cmd, pArg)); + + /* + * Get the session from the soft state item. + */ + vboxusbmon_state_t *pState = ddi_get_soft_state(g_pVBoxUSBMonSolarisState, getminor(Dev)); + if (!pState) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: No state data for minor instance %d\n", getminor(Dev))); + return EINVAL; + } + + /* + * Read the request wrapper. Though We don't really need wrapper struct. now + * it's room for the future as Solaris isn't generous regarding the size. + */ + VBOXUSBREQ ReqWrap; + if (IOCPARM_LEN(Cmd) != sizeof(ReqWrap)) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: bad request %#x size=%d expected=%d\n", Cmd, IOCPARM_LEN(Cmd), + sizeof(ReqWrap))); + return ENOTTY; + } + + int rc = ddi_copyin((void *)pArg, &ReqWrap, sizeof(ReqWrap), Mode); + if (RT_UNLIKELY(rc)) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyin failed to read header pArg=%p Cmd=%d. rc=%d\n", pArg, Cmd, rc)); + return EINVAL; + } + + if (ReqWrap.u32Magic != VBOXUSBMON_MAGIC) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Bad magic %#x; pArg=%p Cmd=%d\n", ReqWrap.u32Magic, pArg, Cmd)); + return EINVAL; + } + if (RT_UNLIKELY( ReqWrap.cbData == 0 + || ReqWrap.cbData > _1M*16)) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Bad size %#x; pArg=%p Cmd=%d\n", ReqWrap.cbData, pArg, Cmd)); + return EINVAL; + } + + /* + * Read the request. + */ + void *pvBuf = RTMemTmpAlloc(ReqWrap.cbData); + if (RT_UNLIKELY(!pvBuf)) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: RTMemTmpAlloc failed to alloc %d bytes\n", ReqWrap.cbData)); + return ENOMEM; + } + + rc = ddi_copyin((void *)(uintptr_t)ReqWrap.pvDataR3, pvBuf, ReqWrap.cbData, Mode); + if (RT_UNLIKELY(rc)) + { + RTMemTmpFree(pvBuf); + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyin failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, pArg, Cmd, + rc)); + return EFAULT; + } + if (RT_UNLIKELY( ReqWrap.cbData != 0 + && !VALID_PTR(pvBuf))) + { + RTMemTmpFree(pvBuf); + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: pvBuf Invalid pointer %p\n", pvBuf)); + return EINVAL; + } + Log((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: pid=%d\n", (int)RTProcSelf())); + + /* + * Process the IOCtl. + */ + size_t cbDataReturned = 0; + rc = vboxUSBMonSolarisProcessIOCtl(Cmd, pState, pvBuf, ReqWrap.cbData, &cbDataReturned); + ReqWrap.rc = rc; + rc = 0; + + if (RT_UNLIKELY(cbDataReturned > ReqWrap.cbData)) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: Too much output data %d expected %d\n", cbDataReturned, ReqWrap.cbData)); + cbDataReturned = ReqWrap.cbData; + } + + ReqWrap.cbData = cbDataReturned; + + /* + * Copy the request back to user space. + */ + rc = ddi_copyout(&ReqWrap, (void *)pArg, sizeof(ReqWrap), Mode); + if (RT_LIKELY(!rc)) + { + /* + * Copy the payload (if any) back to user space. + */ + if (cbDataReturned > 0) + { + rc = ddi_copyout(pvBuf, (void *)(uintptr_t)ReqWrap.pvDataR3, cbDataReturned, Mode); + if (RT_UNLIKELY(rc)) + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyout failed; pvBuf=%p pArg=%p Cmd=%d. rc=%d\n", pvBuf, + pArg, Cmd, rc)); + rc = EFAULT; + } + } + } + else + { + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisIOCtl: ddi_copyout(1) failed pArg=%p Cmd=%d\n", pArg, Cmd)); + rc = EFAULT; + } + + *pVal = rc; + RTMemTmpFree(pvBuf); + return rc; +} + + +/** + * IOCtl processor for user to kernel and kernel to kernel communication. + * + * @returns VBox status code. + * + * @param iFunction The requested function. + * @param pvState Opaque pointer to driver state used for getting + * ring-3 process (Id). + * @param pvData The input/output data buffer. Can be NULL + * depending on the function. + * @param cbData The max size of the data buffer. + * @param pcbReturnedData Where to store the amount of returned data. Can + * be NULL. + */ +static int vboxUSBMonSolarisProcessIOCtl(int iFunction, void *pvState, void *pvData, size_t cbData, size_t *pcbReturnedData) +{ + LogFunc((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: iFunction=%d pvBuf=%p cbBuf=%zu\n", iFunction, pvData, cbData)); + + AssertPtrReturn(pvState, VERR_INVALID_POINTER); + vboxusbmon_state_t *pState = (vboxusbmon_state_t *)pvState; + int rc; + +#define CHECKRET_MIN_SIZE(mnemonic, cbMin) \ + do { \ + if (cbData < (cbMin)) \ + { \ + LogRel(("vboxUSBSolarisProcessIOCtl: " mnemonic ": cbData=%#zx (%zu) min is %#zx (%zu)\n", \ + cbData, cbData, (size_t)(cbMin), (size_t)(cbMin))); \ + return VERR_BUFFER_OVERFLOW; \ + } \ + if ((cbMin) != 0 && !VALID_PTR(pvData)) \ + { \ + LogRel(("vboxUSBSolarisProcessIOCtl: " mnemonic ": Invalid pointer %p\n", pvData)); \ + return VERR_INVALID_POINTER; \ + } \ + } while (0) + + switch (iFunction) + { + case VBOXUSBMON_IOCTL_ADD_FILTER: + { + CHECKRET_MIN_SIZE("ADD_FILTER", sizeof(VBOXUSBREQ_ADD_FILTER)); + + VBOXUSBREQ_ADD_FILTER *pReq = (VBOXUSBREQ_ADD_FILTER *)pvData; + PUSBFILTER pFilter = (PUSBFILTER)&pReq->Filter; + + Log(("vboxUSBMonSolarisProcessIOCtl: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x " + "bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n", + USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID), + USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_REV), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_CLASS), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_SUB_CLASS), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL), + USBFilterGetNum(pFilter, USBFILTERIDX_BUS), + USBFilterGetNum(pFilter, USBFILTERIDX_PORT))); + Log(("vboxUSBMonSolarisProcessIOCtl: Manufacturer=%s Product=%s Serial=%s\n", + USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>")); + + rc = USBFilterSetMustBePresent(pFilter, USBFILTERIDX_BUS, false /* fMustBePresent */); AssertRC(rc); + + rc = VBoxUSBFilterAdd(pFilter, pState->Process, &pReq->uId); + *pcbReturnedData = cbData; + Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: ADD_FILTER (Process:%d) returned %d\n", pState->Process, rc)); + break; + } + + case VBOXUSBMON_IOCTL_REMOVE_FILTER: + { + CHECKRET_MIN_SIZE("REMOVE_FILTER", sizeof(VBOXUSBREQ_REMOVE_FILTER)); + + VBOXUSBREQ_REMOVE_FILTER *pReq = (VBOXUSBREQ_REMOVE_FILTER *)pvData; + rc = VBoxUSBFilterRemove(pState->Process, (uintptr_t)pReq->uId); + *pcbReturnedData = 0; + Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: REMOVE_FILTER (Process:%d) returned %d\n", pState->Process, rc)); + break; + } + + case VBOXUSBMON_IOCTL_RESET_DEVICE: + { + CHECKRET_MIN_SIZE("RESET_DEVICE", sizeof(VBOXUSBREQ_RESET_DEVICE)); + + VBOXUSBREQ_RESET_DEVICE *pReq = (VBOXUSBREQ_RESET_DEVICE *)pvData; + rc = vboxUSBMonSolarisResetDevice(pReq->szDevicePath, pReq->fReattach); + *pcbReturnedData = 0; + Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: RESET_DEVICE (Process:%d) returned %d\n", pState->Process, rc)); + break; + } + + case VBOXUSBMON_IOCTL_CLIENT_INFO: + { + CHECKRET_MIN_SIZE("CLIENT_INFO", sizeof(VBOXUSBREQ_CLIENT_INFO)); + + VBOXUSBREQ_CLIENT_INFO *pReq = (VBOXUSBREQ_CLIENT_INFO *)pvData; + rc = vboxUSBMonSolarisClientInfo(pState, pReq); + *pcbReturnedData = cbData; + Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: CLIENT_INFO (Process:%d) returned %d\n", pState->Process, rc)); + break; + } + + case VBOXUSBMON_IOCTL_GET_VERSION: + { + CHECKRET_MIN_SIZE("GET_VERSION", sizeof(VBOXUSBREQ_GET_VERSION)); + + PVBOXUSBREQ_GET_VERSION pGetVersionReq = (PVBOXUSBREQ_GET_VERSION)pvData; + pGetVersionReq->u32Major = VBOXUSBMON_VERSION_MAJOR; + pGetVersionReq->u32Minor = VBOXUSBMON_VERSION_MINOR; + *pcbReturnedData = sizeof(VBOXUSBREQ_GET_VERSION); + rc = VINF_SUCCESS; + Log((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: GET_VERSION returned %d\n", rc)); + break; + } + + default: + { + LogRel((DEVICE_NAME ": vboxUSBMonSolarisProcessIOCtl: Unknown request (Process:%d) %#x\n", pState->Process, + iFunction)); + *pcbReturnedData = 0; + rc = VERR_NOT_SUPPORTED; + break; + } + } + return rc; +} + + +static int vboxUSBMonSolarisResetDevice(char *pszDevicePath, bool fReattach) +{ + int rc = VERR_GENERAL_FAILURE; + + LogFunc((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: pszDevicePath=%s fReattach=%d\n", pszDevicePath, fReattach)); + + /* + * Try grabbing the dev_info_t. + */ + dev_info_t *pDeviceInfo = e_ddi_hold_devi_by_path(pszDevicePath, 0); + if (pDeviceInfo) + { + ddi_release_devi(pDeviceInfo); + + /* + * Grab the root device node from the parent hub for resetting. + */ + dev_info_t *pTmpDeviceInfo = NULL; + for (;;) + { + pTmpDeviceInfo = ddi_get_parent(pDeviceInfo); + if (!pTmpDeviceInfo) + { + LogRel((DEVICE_NAME ":vboxUSBMonSolarisResetDevice: Failed to get parent device info for %s\n", pszDevicePath)); + return VERR_GENERAL_FAILURE; + } + + if (ddi_prop_exists(DDI_DEV_T_ANY, pTmpDeviceInfo, DDI_PROP_DONTPASS, "usb-port-count")) /* parent hub */ + break; + + pDeviceInfo = pTmpDeviceInfo; + } + + /* + * Try re-enumerating the device. + */ + rc = usb_reset_device(pDeviceInfo, fReattach ? USB_RESET_LVL_REATTACH : USB_RESET_LVL_DEFAULT); + Log((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: usb_reset_device for %s level=%s rc=%d\n", pszDevicePath, + fReattach ? "ReAttach" : "Default", rc)); + + switch (rc) + { + case USB_SUCCESS: rc = VINF_SUCCESS; break; + case USB_INVALID_PERM: rc = VERR_PERMISSION_DENIED; break; + case USB_INVALID_ARGS: rc = VERR_INVALID_PARAMETER; break; + case USB_BUSY: rc = VERR_RESOURCE_BUSY; break; + case USB_INVALID_CONTEXT: rc = VERR_INVALID_CONTEXT; break; + case USB_FAILURE: rc = VERR_GENERAL_FAILURE; break; + + default: rc = VERR_UNRESOLVED_ERROR; break; + } + } + else + { + rc = VERR_INVALID_HANDLE; + LogRel((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: Cannot obtain device info for %s\n", pszDevicePath)); + } + + return rc; +} + + +/** + * Query client driver information. This also has a side-effect that it informs + * the client driver which upcoming VM process should be allowed to open it. + * + * @returns VBox status code. + * @param pState Pointer to the device state. + * @param pClientInfo Pointer to the client info. object. + */ +static int vboxUSBMonSolarisClientInfo(vboxusbmon_state_t *pState, PVBOXUSB_CLIENT_INFO pClientInfo) +{ + LogFunc((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: pState=%p pClientInfo=%p\n", pState, pClientInfo)); + + AssertPtrReturn(pState, VERR_INVALID_POINTER); + AssertPtrReturn(pClientInfo, VERR_INVALID_POINTER); + + mutex_enter(&g_VBoxUSBMonSolarisMtx); + vboxusbmon_client_t *pCur = g_pVBoxUSBMonSolarisClients; + vboxusbmon_client_t *pPrev = NULL; + while (pCur) + { + if (strncmp(pClientInfo->szDeviceIdent, pCur->Info.szDeviceIdent, sizeof(pCur->Info.szDeviceIdent) - 1) == 0) + { + pClientInfo->Instance = pCur->Info.Instance; + RTStrPrintf(pClientInfo->szClientPath, sizeof(pClientInfo->szClientPath), "%s", pCur->Info.szClientPath); + + /* + * Inform the client driver that this is the client process that is going to open it. We can predict the future! + */ + int rc; + if (pCur->Info.pfnSetConsumerCredentials) + { + rc = pCur->Info.pfnSetConsumerCredentials(pState->Process, pCur->Info.Instance, NULL /* pvReserved */); + if (RT_FAILURE(rc)) + LogRel((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: pfnSetConsumerCredentials failed! rc=%d\n", rc)); + } + else + rc = VERR_INVALID_FUNCTION; + + mutex_exit(&g_VBoxUSBMonSolarisMtx); + + Log((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: Found %s, rc=%d\n", pClientInfo->szDeviceIdent, rc)); + return rc; + } + pPrev = pCur; + pCur = pCur->pNext; + } + + mutex_exit(&g_VBoxUSBMonSolarisMtx); + + LogRel((DEVICE_NAME ": vboxUSBMonSolarisClientInfo: Failed to find client %s\n", pClientInfo->szDeviceIdent)); + return VERR_NOT_FOUND; +} + + +/** + * Registers client driver. + * + * @returns VBox status code. + */ +int VBoxUSBMonSolarisRegisterClient(dev_info_t *pClientDip, PVBOXUSB_CLIENT_INFO pClientInfo) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisRegisterClient: pClientDip=%p pClientInfo=%p\n", pClientDip, pClientInfo)); + AssertPtrReturn(pClientInfo, VERR_INVALID_PARAMETER); + + if (RT_LIKELY(g_pDip)) + { + vboxusbmon_client_t *pClient = RTMemAllocZ(sizeof(vboxusbmon_client_t)); + if (RT_LIKELY(pClient)) + { + pClient->Info.Instance = pClientInfo->Instance; + strncpy(pClient->Info.szClientPath, pClientInfo->szClientPath, sizeof(pClient->Info.szClientPath)); + strncpy(pClient->Info.szDeviceIdent, pClientInfo->szDeviceIdent, sizeof(pClient->Info.szDeviceIdent)); + pClient->Info.pfnSetConsumerCredentials = pClientInfo->pfnSetConsumerCredentials; + pClient->pDip = pClientDip; + + mutex_enter(&g_VBoxUSBMonSolarisMtx); + pClient->pNext = g_pVBoxUSBMonSolarisClients; + g_pVBoxUSBMonSolarisClients = pClient; + mutex_exit(&g_VBoxUSBMonSolarisMtx); + + Log((DEVICE_NAME ": Client registered (ClientPath=%s Ident=%s)\n", pClient->Info.szClientPath, + pClient->Info.szDeviceIdent)); + return VINF_SUCCESS; + } + return VERR_NO_MEMORY; + } + return VERR_INVALID_STATE; +} + + +/** + * Deregisters client driver. + * + * @returns VBox status code. + */ +int VBoxUSBMonSolarisUnregisterClient(dev_info_t *pClientDip) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisUnregisterClient: pClientDip=%p\n", pClientDip)); + AssertReturn(pClientDip, VERR_INVALID_PARAMETER); + + if (RT_LIKELY(g_pDip)) + { + mutex_enter(&g_VBoxUSBMonSolarisMtx); + + vboxusbmon_client_t *pCur = g_pVBoxUSBMonSolarisClients; + vboxusbmon_client_t *pPrev = NULL; + while (pCur) + { + if (pCur->pDip == pClientDip) + { + if (pPrev) + pPrev->pNext = pCur->pNext; + else + g_pVBoxUSBMonSolarisClients = pCur->pNext; + + mutex_exit(&g_VBoxUSBMonSolarisMtx); + + Log((DEVICE_NAME ": Client unregistered (ClientPath=%s Ident=%s)\n", pCur->Info.szClientPath, + pCur->Info.szDeviceIdent)); + RTMemFree(pCur); + return VINF_SUCCESS; + } + pPrev = pCur; + pCur = pCur->pNext; + } + + mutex_exit(&g_VBoxUSBMonSolarisMtx); + + LogRel((DEVICE_NAME ": VBoxUSBMonSolarisUnregisterClient: Failed to find registered client %p\n", pClientDip)); + return VERR_NOT_FOUND; + } + return VERR_INVALID_STATE; +} + + +/** + * USBA driver election callback. + * + * @returns USB_SUCCESS if we want to capture the device, USB_FAILURE otherwise. + * @param pDevDesc The parsed device descriptor (does not include subconfigs). + * @param pDevStrings Device strings: Manufacturer, Product, Serial Number. + * @param pszDevicePath The physical path of the device being attached. + * @param Bus The Bus number on which the device is on. + * @param Port The Port number on the bus. + * @param ppszDrv The name of the driver we wish to capture the device with. + * @param pvReserved Reserved for future use. + */ +int VBoxUSBMonSolarisElectDriver(usb_dev_descr_t *pDevDesc, usb_dev_str_t *pDevStrings, char *pszDevicePath, int Bus, int Port, + char **ppszDrv, void *pvReserved) +{ + LogFunc((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: pDevDesc=%p pDevStrings=%p pszDevicePath=%s Bus=%d Port=%d\n", pDevDesc, + pDevStrings, pszDevicePath, Bus, Port)); + + AssertPtrReturn(pDevDesc, USB_FAILURE); + AssertPtrReturn(pDevStrings, USB_FAILURE); + + /* + * Create a filter from the device being attached. + */ + USBFILTER Filter; + USBFilterInit(&Filter, USBFILTERTYPE_CAPTURE); + USBFilterSetNumExact(&Filter, USBFILTERIDX_VENDOR_ID, pDevDesc->idVendor, true); + USBFilterSetNumExact(&Filter, USBFILTERIDX_PRODUCT_ID, pDevDesc->idProduct, true); + USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_REV, pDevDesc->bcdDevice, true); + USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_CLASS, pDevDesc->bDeviceClass, true); + USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_SUB_CLASS, pDevDesc->bDeviceSubClass, true); + USBFilterSetNumExact(&Filter, USBFILTERIDX_DEVICE_PROTOCOL, pDevDesc->bDeviceProtocol, true); + USBFilterSetNumExact(&Filter, USBFILTERIDX_BUS, 0x0 /* Bus */, true); /* Use 0x0 as userland initFilterFromDevice function in Main: see comment on "SetMustBePresent" below */ + USBFilterSetNumExact(&Filter, USBFILTERIDX_PORT, Port, true); + USBFilterSetStringExact(&Filter, USBFILTERIDX_MANUFACTURER_STR, pDevStrings->usb_mfg ? pDevStrings->usb_mfg : "", + true /*fMustBePresent*/, true /*fPurge*/); + USBFilterSetStringExact(&Filter, USBFILTERIDX_PRODUCT_STR, pDevStrings->usb_product ? pDevStrings->usb_product : "", + true /*fMustBePresent*/, true /*fPurge*/); + USBFilterSetStringExact(&Filter, USBFILTERIDX_SERIAL_NUMBER_STR, pDevStrings->usb_serialno ? pDevStrings->usb_serialno : "", + true /*fMustBePresent*/, true /*fPurge*/); + + /* This doesn't work like it should (USBFilterMatch fails on matching field (6) i.e. Bus despite this. Investigate later. */ + USBFilterSetMustBePresent(&Filter, USBFILTERIDX_BUS, false /* fMustBePresent */); + + Log((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x " + "bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x\n", + USBFilterGetNum(&Filter, USBFILTERIDX_VENDOR_ID), + USBFilterGetNum(&Filter, USBFILTERIDX_PRODUCT_ID), + USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_REV), + USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_CLASS), + USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_SUB_CLASS), + USBFilterGetNum(&Filter, USBFILTERIDX_DEVICE_PROTOCOL), + USBFilterGetNum(&Filter, USBFILTERIDX_BUS), + USBFilterGetNum(&Filter, USBFILTERIDX_PORT))); + Log((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: Manufacturer=%s Product=%s Serial=%s\n", + USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(&Filter, USBFILTERIDX_MANUFACTURER_STR) : "<null>", + USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(&Filter, USBFILTERIDX_PRODUCT_STR) : "<null>", + USBFilterGetString(&Filter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(&Filter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>")); + + /* + * Run through user filters and try to see if it has a match. + */ + uintptr_t uId = 0; + RTPROCESS Owner = VBoxUSBFilterMatch(&Filter, &uId); + USBFilterDelete(&Filter); + if (Owner == NIL_RTPROCESS) + { + Log((DEVICE_NAME ": VBoxUSBMonSolarisElectDriver: No matching filters, device %#x:%#x uninteresting\n", + pDevDesc->idVendor, pDevDesc->idProduct)); + return USB_FAILURE; + } + + *ppszDrv = ddi_strdup(VBOXUSB_DRIVER_NAME, KM_SLEEP); +#if 0 + LogRel((DEVICE_NAME ": Capturing %s %s %#x:%#x:%s Bus=%d Port=%d\n", + pDevStrings->usb_mfg ? pDevStrings->usb_mfg : "<Unknown Manufacturer>", + pDevStrings->usb_product ? pDevStrings->usb_product : "<Unnamed USB device>", + pDevDesc->idVendor, pDevDesc->idProduct, pszDevicePath, Bus, Port)); +#else + /* Until IPRT R0 logging is fixed. See @bugref{6657#c7} */ + cmn_err(CE_CONT, "Capturing %s %s 0x%x:0x%x:%s Bus=%d Port=%d\n", + pDevStrings->usb_mfg ? pDevStrings->usb_mfg : "<Unknown Manufacturer>", + pDevStrings->usb_product ? pDevStrings->usb_product : "<Unnamed USB device>", + pDevDesc->idVendor, pDevDesc->idProduct, pszDevicePath, Bus, Port); +#endif + return USB_SUCCESS; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/solaris/include/usbai_private.h b/src/VBox/HostDrivers/VBoxUSB/solaris/include/usbai_private.h new file mode 100644 index 00000000..2e61d804 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/solaris/include/usbai_private.h @@ -0,0 +1,161 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2009-2010 Oracle Corporation. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _SYS_USB_USBA_USBAI_PRIVATE_H +#define _SYS_USB_USBA_USBAI_PRIVATE_H + +/* + * Unstable interfaces not part of USBAI but used by Solaris client drivers. + * These interfaces may not be present in future releases and are highly + * unstable. + * + * Status key: + * C = Remove from Sun client drivers before removing from this file + * D = May be needed by legacy (DDK) drivers. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * convenience function for getting default config index + * as saved in usba_device structure + * + * Status: C + */ +uint_t usb_get_current_cfgidx(dev_info_t *); + +/* + * Usb logging, debug and console message handling. + */ +typedef struct usb_log_handle *usb_log_handle_t; + +#define USB_LOG_L0 0 /* warnings, console & syslog buffer */ +#define USB_LOG_L1 1 /* errors, syslog buffer */ +#define USB_LOG_L2 2 /* recoverable errors, debug only */ +#define USB_LOG_L3 3 /* interesting data, debug only */ +#define USB_LOG_L4 4 /* tracing, debug only */ + +#define USB_CHK_BASIC 0 /* Empty mask. Basics always done. */ +#define USB_CHK_SERIAL 0x00000001 /* Compare device serial numbers. */ +#define USB_CHK_CFG 0x00000002 /* Compare raw config clouds. */ +#define USB_CHK_VIDPID 0x00000004 /* Compare product and vendor ID. */ +#define USB_CHK_ALL 0xFFFFFFFF /* Perform maximum checking. */ + +int usb_check_same_device(dev_info_t *dip, + usb_log_handle_t log_handle, + int log_level, + int log_mask, + uint_t check_mask, + char *device_string); + +/* + * ************************************************************************** + * Serialization functions remaining Contracted Consolidation Private + * ************************************************************************** + */ + +/* This whole section: status: C and D. */ + +/* + * opaque serialization handle. + * Used by all usb_serialization routines. + * + * This handle is opaque to the client driver. + */ +typedef struct usb_serialization *usb_serialization_t; + +/* + * usb_init_serialization + * setup for serialization + * + * ARGUMENTS: + * s_dip - devinfo pointer + * flag - USB_INIT_SER_CHECK_SAME_THREAD + * when set, usb_release_access() will verify that the same + * thread releases access. If not, a console warning will + * be issued but access will be released anyways. + * + * RETURNS: + * usb_serialization handle + * + */ +usb_serialization_t usb_init_serialization(dev_info_t *s_dip, + uint_t flag); + +#define USB_INIT_SER_CHECK_SAME_THREAD 1 + +/* fini for serialization */ +void usb_fini_serialization(usb_serialization_t usb_serp); + +/* + * Various ways of calling usb_serialize_access. These correspond to + * their cv_*wait* function counterparts for usb_serialize_access. + */ +#define USB_WAIT 0 +#define USB_WAIT_SIG 1 +#define USB_TIMEDWAIT 2 +#define USB_TIMEDWAIT_SIG 3 + +/* + * usb_serialize_access: + * acquire serialized access + * + * ARGUMENTS: + * usb_serp - usb_serialization handle + * how_to_wait - Which cv_*wait* function to wait for condition. + * USB_WAIT: use cv_wait + * USB_WAIT_SIG: use cv_wait_sig + * USB_TIMEDWAIT: use cv_timedwait + * USB_TIMEDWAIT_SIG: use cv_timedwait_sig + * delta_timeout - Time in ms from current time to timeout. Checked + * only if USB_TIMEDWAIT or USB_TIMEDWAIT_SIG + * specified in how_to_wait. + * RETURNS: + * Same as values returned by cv_*wait* functions, + * except for when how_to_wait == USB_WAIT, where 0 is always returned. + * For calls where a timeout or signal could be expected, use this value + * to tell whether a kill(2) signal or timeout occurred. + */ +int usb_serialize_access(usb_serialization_t usb_serp, + uint_t how_to_wait, + uint_t delta_timeout); + +/* + * usb_release_access: + * release serialized access + * + * ARGUMENTS: + * usb_serp - usb_serialization handle + */ +void usb_release_access(usb_serialization_t usb_serp); + +#ifdef __cplusplus +} +#endif + +#endif /* _SYS_USB_USBA_USBAI_PRIVATE_H */ + diff --git a/src/VBox/HostDrivers/VBoxUSB/solaris/vboxusb.conf b/src/VBox/HostDrivers/VBoxUSB/solaris/vboxusb.conf new file mode 100644 index 00000000..93555689 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/solaris/vboxusb.conf @@ -0,0 +1,27 @@ +# +# Solaris Host USB Client Driver Configuration +# + +# +# Copyright (C) 2010-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# +# The contents of this file may alternatively be used under the terms +# of the Common Development and Distribution License Version 1.0 +# (CDDL) only, as it comes in the "COPYING.CDDL" file of the +# VirtualBox OSE distribution, in which case the provisions of the +# CDDL are applicable instead of those of the GPL. +# +# You may elect to license modified versions of this file under the +# terms and conditions of either the GPL or the CDDL or both. +# + +name="vboxusb" parent="pseudo"; + diff --git a/src/VBox/HostDrivers/VBoxUSB/solaris/vboxusbmon.conf b/src/VBox/HostDrivers/VBoxUSB/solaris/vboxusbmon.conf new file mode 100644 index 00000000..22e0cdeb --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/solaris/vboxusbmon.conf @@ -0,0 +1,27 @@ +# +# Solaris Host USB Monitor Driver Configuration +# + +# +# Copyright (C) 2010-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# +# The contents of this file may alternatively be used under the terms +# of the Common Development and Distribution License Version 1.0 +# (CDDL) only, as it comes in the "COPYING.CDDL" file of the +# VirtualBox OSE distribution, in which case the provisions of the +# CDDL are applicable instead of those of the GPL. +# +# You may elect to license modified versions of this file under the +# terms and conditions of either the GPL or the CDDL or both. +# + +name="vboxusbmon" parent="pseudo" instance=0; + diff --git a/src/VBox/HostDrivers/VBoxUSB/testcase/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/testcase/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/testcase/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/testcase/tstUSBFilter.cpp b/src/VBox/HostDrivers/VBoxUSB/testcase/tstUSBFilter.cpp new file mode 100644 index 00000000..120ac61e --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/testcase/tstUSBFilter.cpp @@ -0,0 +1,367 @@ +/** $Id: tstUSBFilter.cpp $ */ +/** @file + * VirtualBox USB filter abstraction - testcase. + */ + +/* + * Copyright (C) 2007-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <VBox/usbfilter.h> +#include <iprt/errcore.h> + +#include <iprt/string.h> +#include <iprt/stream.h> +#include <iprt/assert.h> +#include <iprt/initterm.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +#define TESTCASE "tstUSBFilter" + +#define TST_CHECK_RC(expr) do { \ + int rc = expr; \ + if (RT_FAILURE(rc)) \ + { \ + RTPrintf( TESTCASE "(%d): %Rrc - %s\n", __LINE__, rc, #expr); \ + cErrors++; \ + } \ + } while (0) + +#define TST_CHECK_EXPR(expr) do { \ + int rc = (intptr_t)(expr); \ + if (!rc) \ + { \ + RTPrintf( TESTCASE "(%d): %s -> %d\n", __LINE__, #expr, rc); \ + cErrors++; \ + } \ +} while (0) + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +static const char g_szString64[64+1] = +{ + "abcdefghijklmnopqrstuvwxyz012345" + "abcdefghijklmnopqrstuvwxyz012345" +}; + +static const char g_szString128[128+1] = +{ + "abcdefghijklmnopqrstuvwxyz012345abcdefghijklmnopqrstuvwxyz012345" + "abcdefghijklmnopqrstuvwxyz012345abcdefghijklmnopqrstuvwxyz012345" +}; + +static const char g_szString256[256+1] = +{ + "abcdefghijklmnopqrstuvwxyz012345abcdefghijklmnopqrstuvwxyz012345" + "abcdefghijklmnopqrstuvwxyz012345abcdefghijklmnopqrstuvwxyz012345" + "abcdefghijklmnopqrstuvwxyz012345abcdefghijklmnopqrstuvwxyz012345" + "abcdefghijklmnopqrstuvwxyz012345abcdefghijklmnopqrstuvwxyz012345" +}; + + +int main() +{ + unsigned cErrors = 0; + RTR3InitExeNoArguments(0); + + /* + * Basic property setting and simple matching. + */ + USBFILTER Flt1; + USBFilterInit(&Flt1, USBFILTERTYPE_CAPTURE); + /* numbers */ + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_VENDOR_ID, 0x1111, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PRODUCT_ID, 0x2222, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE, 0, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE_CLASS, 0, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE_SUB_CLASS, 0, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_DEVICE_PROTOCOL, 0xff, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, true)); + TST_CHECK_RC(USBFilterSetIgnore(&Flt1, USBFILTERIDX_BUS)); + TST_CHECK_RC(USBFilterSetPresentOnly(&Flt1, USBFILTERIDX_BUS)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, false)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 1, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 1, false)); + TST_CHECK_RC(USBFilterSetIgnore(&Flt1, USBFILTERIDX_PORT)); + /* strings */ + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, "foobar", true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, "foobar", true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString128, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "barbar", true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, g_szString64, true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_MANUFACTURER_STR, "vendor", true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "product", true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_SERIAL_NUMBER_STR, "serial", true, false )); + + /* cloning */ + USBFILTER Dev; + USBFilterClone(&Dev, &Flt1); + + TST_CHECK_EXPR(USBFilterIsIdentical(&Dev, &Flt1)); + TST_CHECK_EXPR(USBFilterMatch(&Dev, &Flt1)); + + USBFilterDelete(&Flt1); + USBFilterDelete(&Dev); + + /* make a sample device */ + USBFilterInit(&Dev, USBFILTERTYPE_CAPTURE); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_VENDOR_ID, 0x1111, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_PRODUCT_ID, 0x2222, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE, 0, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE_CLASS, 0, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE_SUB_CLASS, 0, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_DEVICE_PROTOCOL, 0xff, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_BUS, 1, true)); + TST_CHECK_RC(USBFilterSetNumExact(&Dev, USBFILTERIDX_PORT, 2, true)); + TST_CHECK_RC(USBFilterSetStringExact(&Dev, USBFILTERIDX_MANUFACTURER_STR, "vendor", true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Dev, USBFILTERIDX_PRODUCT_STR, "product", true, false )); + TST_CHECK_RC(USBFilterSetStringExact(&Dev, USBFILTERIDX_SERIAL_NUMBER_STR, "serial", true, false )); + + /* do some basic matching tests */ + USBFilterInit(&Flt1, USBFILTERTYPE_CAPTURE); + TST_CHECK_EXPR(!USBFilterHasAnySubstatialCriteria(&Flt1)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev) /* 100% ignore filter */); + + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 3, true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_PORT, 2, true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 2, true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExact(&Flt1, USBFILTERIDX_BUS, 1, true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "no match", true, false )); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringExact(&Flt1, USBFILTERIDX_PRODUCT_STR, "product", true, false )); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + /* string patterns */ + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "p*", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*product", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "product*", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*t", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*uct", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*uct", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*duct", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "pro*x", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*product*", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*oduct*", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "*produc*", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "?r??u*?t", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "?r??u*?*?*?***??t", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "?r??u*?*?*?***??", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "p*d*t", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetStringPattern(&Flt1, USBFILTERIDX_PRODUCT_STR, "p*x*t", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetIgnore(&Flt1, USBFILTERIDX_PRODUCT_STR)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + /* numeric patterns */ + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1111", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0X1111", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "4369", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "010421", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1111-0x1111", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "4369-4369", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "010421-010421", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1110-0x1112", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "4360-4370", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "010420-010422", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1112-0x1110", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0-0x1f", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-19", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-017", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0-0xffff", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-65535", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0-177777", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0-0XABCD", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x0EF-0XABCD", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0X0ef-0Xabcd", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "42|1|0x1111", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "42|0x1111|1", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1111|42|1", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x1112|42|1", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "39-59|0x256-0x101f|0xfffff-0xf000|0x1000-0x2000", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "0x000256-0x0101f|0xf000-0xfffff|0x000008000-0x2000|39-59", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "| | \t \t\t| 0x256 - 0x101f | 0xf000 - 0xfeff\t| 0x1000 -\t0x6000 | 1- 0512", true)); + TST_CHECK_EXPR(USBFilterMatch(&Flt1, &Dev)); + TST_CHECK_RC(USBFilterSetNumExpression(&Flt1, USBFILTERIDX_VENDOR_ID, "| | \t \t\t| 0x256 - 0x101f | 0xf000 - 0xfeff\t| 0x1112 -\t0x6000 | 1- 0512", true)); + TST_CHECK_EXPR(!USBFilterMatch(&Flt1, &Dev)); + + + USBFilterDelete(&Flt1); + + /* + * string overflow + */ + struct + { + uint64_t u64Pre; + USBFILTER Flt; + uint64_t u64Post; + } sOf; + sOf.u64Pre = sOf.u64Post = UINT64_C(0x1234567887654321); + + USBFilterInit(&sOf.Flt, USBFILTERTYPE_CAPTURE); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + + AssertCompileMemberSize(USBFILTER, achStrTab, 256); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[0], true, false ) == VERR_BUFFER_OVERFLOW); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[1], true, false ) == VERR_BUFFER_OVERFLOW); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[2], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString256[3], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + /* 0 + 1 */ + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, "", true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString256[2], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString256[1], true, false ) == VERR_BUFFER_OVERFLOW); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + /* 0 + 2 */ + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString128[2], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString128[1], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + /* 3 */ + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_SERIAL_NUMBER_STR, &g_szString64[0], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_PRODUCT_STR, &g_szString64[0], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_MANUFACTURER_STR, &g_szString128[4], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_MANUFACTURER_STR, &g_szString128[4], true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetStringExact(&sOf.Flt, USBFILTERIDX_MANUFACTURER_STR, &g_szString128[3], true, false ) == VERR_BUFFER_OVERFLOW); + TST_CHECK_EXPR(sOf.u64Pre == UINT64_C(0x1234567887654321)); TST_CHECK_EXPR(sOf.u64Post == UINT64_C(0x1234567887654321)); + + /* + * Check for a string replacement bug. + */ + USBFILTER Dev2; + USBFilterInit(&Dev2, USBFILTERTYPE_CAPTURE); + TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_VENDOR_ID, 0x19b6, true) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_PRODUCT_ID, 0x1024, true) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_REV, 0x0141, true) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_CLASS, 0, true) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_SUB_CLASS, 0, true) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_DEVICE_PROTOCOL, 0, true) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetNumExact(&Dev2, USBFILTERIDX_PORT, 0x1, true) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetStringExact(&Dev2, USBFILTERIDX_MANUFACTURER_STR, "Generic", true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetStringExact(&Dev2, USBFILTERIDX_PRODUCT_STR, "Mass Storage Device", true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterSetStringExact(&Dev2, USBFILTERIDX_MANUFACTURER_STR, "YBU1PPRS", true, false ) == VINF_SUCCESS); + TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_VENDOR_ID) == 0x19b6); + TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_PRODUCT_ID) == 0x1024); + TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_REV) == 0x0141); + TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_CLASS) == 0); + TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_SUB_CLASS) == 0); + TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_DEVICE_PROTOCOL) == 0); + TST_CHECK_EXPR(USBFilterGetNum(&Dev2, USBFILTERIDX_PORT) == 1); + + + /* + * Summary. + */ + if (!cErrors) + RTPrintf(TESTCASE ": SUCCESS\n"); + else + RTPrintf(TESTCASE ": FAILURE - %d errors\n", cErrors); + return !!cErrors; +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/Install/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/Install/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/Install/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/Install/USBInstall.cpp b/src/VBox/HostDrivers/VBoxUSB/win/Install/USBInstall.cpp new file mode 100644 index 00000000..aeb98d29 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/Install/USBInstall.cpp @@ -0,0 +1,229 @@ +/* $Id: USBInstall.cpp $ */ +/** @file + * VBox host drivers - USB drivers - Filter & driver installation, Installation code. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> +#include <iprt/win/setupapi.h> +#include <newdev.h> +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/initterm.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/errcore.h> +#include <stdio.h> + +#include <VBox/VBoxDrvCfg-win.h> + +static DECLCALLBACK(void) vboxUsbLog(VBOXDRVCFG_LOG_SEVERITY enmSeverity, char *pszMsg, void *pvContext) +{ + RT_NOREF1(pvContext); + switch (enmSeverity) + { + case VBOXDRVCFG_LOG_SEVERITY_FLOW: + case VBOXDRVCFG_LOG_SEVERITY_REGULAR: + break; + case VBOXDRVCFG_LOG_SEVERITY_REL: + RTPrintf("%s", pszMsg); + break; + default: + break; + } +} + +static DECLCALLBACK(void) vboxUsbPanic(void *pvPanic) +{ + RT_NOREF1(pvPanic); +#ifndef DEBUG_bird + AssertFailed(); +#endif +} + +int usblibOsCreateService(void); + +int __cdecl main(int argc, char **argv) +{ + if (RTR3InitExe(argc, &argv, 0) != VINF_SUCCESS) + { + printf("Could not init IPRT!\n"); + return 1; + } + + VBoxDrvCfgLoggerSet(vboxUsbLog, NULL); + VBoxDrvCfgPanicSet(vboxUsbPanic, NULL); + + RTPrintf("USB installation\n"); + + int rc = usblibOsCreateService(); + + if (RT_SUCCESS(rc)) + { + LPWSTR lpszFilePart; + WCHAR szFullPath[MAX_PATH]; + DWORD len; + + len = GetFullPathNameW(L".\\VBoxUSB.inf", RT_ELEMENTS(szFullPath), szFullPath, &lpszFilePart); + Assert(len); + + HRESULT hr = VBoxDrvCfgInfInstall(szFullPath); + if (hr == S_OK) + { + RTPrintf("Installation successful.\n"); + } + else + { + rc = -1; + } + } + + if (RT_SUCCESS(rc)) + rc = 0; + + /** @todo RTR3Term(); */ + return rc; +} + +/** The support service name. */ +#define SERVICE_NAME "VBoxUSBMon" +/** Win32 Device name. */ +#define DEVICE_NAME "\\\\.\\VBoxUSBMon" +/** NT Device name. */ +#define DEVICE_NAME_NT L"\\Device\\VBoxUSBMon" +/** Win32 Symlink name. */ +#define DEVICE_NAME_DOS L"\\DosDevices\\VBoxUSBMon" + + +/** + * Changes the USB driver service to specified driver path. + * + * @returns 0 on success. + * @returns < 0 on failure. + */ +int usblibOsChangeService(const char *pszDriverPath) +{ + SC_HANDLE hSMgrCreate = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG); + DWORD dwLastError = GetLastError(); + int rc = RTErrConvertFromWin32(dwLastError); + AssertPtr(pszDriverPath); + AssertMsg(hSMgrCreate, ("OpenSCManager(,,create) failed rc=%d\n", dwLastError)); + if (hSMgrCreate) + { + SC_HANDLE hService = OpenService(hSMgrCreate, + SERVICE_NAME, + GENERIC_ALL); + DWORD dwLastError = GetLastError(); + if (hService == NULL) + { + AssertMsg(hService, ("OpenService failed! LastError=%Rwa, pszDriver=%s\n", dwLastError, pszDriverPath)); + rc = RTErrConvertFromWin32(dwLastError); + } + else + { + /* We only gonna change the driver image path, the rest remains like it already is */ + if (ChangeServiceConfig(hService, + SERVICE_NO_CHANGE, + SERVICE_NO_CHANGE, + SERVICE_NO_CHANGE, + pszDriverPath, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL)) + { + RTPrintf("Changed service config to new driver path: %s\n", pszDriverPath); + } + else + { + AssertMsg(hService, ("ChangeServiceConfig failed! LastError=%Rwa, pszDriver=%s\n", dwLastError, pszDriverPath)); + rc = RTErrConvertFromWin32(dwLastError); + } + if (hService != NULL) + CloseServiceHandle(hService); + } + + CloseServiceHandle(hSMgrCreate); + } + return rc; +} + + +/** + * Creates the service. + * + * @returns 0 on success. + * @returns < 0 on failure. + */ +int usblibOsCreateService(void) +{ + /* + * Assume it didn't exist, so we'll create the service. + */ + SC_HANDLE hSMgrCreate = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG); + DWORD dwLastError = GetLastError(); + int rc = RTErrConvertFromWin32(dwLastError); + AssertMsg(hSMgrCreate, ("OpenSCManager(,,create) failed rc=%d\n", dwLastError)); + if (hSMgrCreate) + { + char szDriver[RTPATH_MAX]; + int rc = RTPathExecDir(szDriver, sizeof(szDriver) - sizeof("\\VBoxUSBMon.sys")); + if (RT_SUCCESS(rc)) + { + strcat(szDriver, "\\VBoxUSBMon.sys"); + RTPrintf("Creating USB monitor driver service with path %s ...\n", szDriver); + SC_HANDLE hService = CreateService(hSMgrCreate, + SERVICE_NAME, + "VBox USB Monitor Driver", + SERVICE_QUERY_STATUS, + SERVICE_KERNEL_DRIVER, + SERVICE_DEMAND_START, + SERVICE_ERROR_NORMAL, + szDriver, + NULL, NULL, NULL, NULL, NULL); + DWORD dwLastError = GetLastError(); + if (dwLastError == ERROR_SERVICE_EXISTS) + { + RTPrintf("USB monitor driver service already exists, skipping creation.\n"); + rc = usblibOsChangeService(szDriver); + } + else + { + AssertMsg(hService, ("CreateService failed! LastError=%Rwa, szDriver=%s\n", dwLastError, szDriver)); + rc = RTErrConvertFromWin32(dwLastError); + if (hService != NULL) + CloseServiceHandle(hService); + } + } + CloseServiceHandle(hSMgrCreate); + } + return rc; +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/Install/USBUninstall.cpp b/src/VBox/HostDrivers/VBoxUSB/win/Install/USBUninstall.cpp new file mode 100644 index 00000000..f03fb6c8 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/Install/USBUninstall.cpp @@ -0,0 +1,211 @@ +/* $Id: USBUninstall.cpp $ */ +/** @file + * VBox host drivers - USB drivers - Filter & driver uninstallation. + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> +#include <iprt/win/setupapi.h> +#include <newdev.h> + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/string.h> +#include <iprt/errcore.h> +#include <VBox/VBoxDrvCfg-win.h> +#include <stdio.h> + + +int usblibOsStopService(void); +int usblibOsDeleteService(void); + +static DECLCALLBACK(void) vboxUsbLog(VBOXDRVCFG_LOG_SEVERITY enmSeverity, char *pszMsg, void *pvContext) +{ + RT_NOREF1(pvContext); + switch (enmSeverity) + { + case VBOXDRVCFG_LOG_SEVERITY_FLOW: + case VBOXDRVCFG_LOG_SEVERITY_REGULAR: + break; + case VBOXDRVCFG_LOG_SEVERITY_REL: + printf("%s", pszMsg); + break; + default: + break; + } +} + +static DECLCALLBACK(void) vboxUsbPanic(void *pvPanic) +{ + RT_NOREF1(pvPanic); +#ifndef DEBUG_bird + AssertFailed(); +#endif +} + + +int __cdecl main(int argc, char **argv) +{ + RT_NOREF2(argc, argv); + printf("USB uninstallation\n"); + + VBoxDrvCfgLoggerSet(vboxUsbLog, NULL); + VBoxDrvCfgPanicSet(vboxUsbPanic, NULL); + + usblibOsStopService(); + usblibOsDeleteService(); + + HRESULT hr = VBoxDrvCfgInfUninstallAllF(L"USB", L"USB\\VID_80EE&PID_CAFE", SUOI_FORCEDELETE); + if (hr != S_OK) + { + printf("SetupUninstallOEMInf failed with hr=0x%x\n", hr); + return 1; + } + + printf("USB uninstallation succeeded!\n"); + + return 0; +} + +/** The support service name. */ +#define SERVICE_NAME "VBoxUSBMon" +/** Win32 Device name. */ +#define DEVICE_NAME "\\\\.\\VBoxUSBMon" +/** NT Device name. */ +#define DEVICE_NAME_NT L"\\Device\\VBoxUSBMon" +/** Win32 Symlink name. */ +#define DEVICE_NAME_DOS L"\\DosDevices\\VBoxUSBMon" + +/** + * Stops a possibly running service. + * + * @returns 0 on success. + * @returns -1 on failure. + */ +int usblibOsStopService(void) +{ + /* + * Assume it didn't exist, so we'll create the service. + */ + int rc = -1; + SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_STOP | SERVICE_QUERY_STATUS); + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError)); + if (hSMgr) + { + SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, SERVICE_STOP | SERVICE_QUERY_STATUS); + if (hService) + { + /* + * Stop the service. + */ + SERVICE_STATUS Status; + QueryServiceStatus(hService, &Status); + if (Status.dwCurrentState == SERVICE_STOPPED) + rc = 0; + else if (ControlService(hService, SERVICE_CONTROL_STOP, &Status)) + { + /* + * Wait for finish about 1 minute. + * It should be enough for work with driver verifier + */ + int iWait = 600; + while (Status.dwCurrentState == SERVICE_STOP_PENDING && iWait-- > 0) + { + Sleep(100); + QueryServiceStatus(hService, &Status); + } + if (Status.dwCurrentState == SERVICE_STOPPED) + rc = 0; + else + AssertMsgFailed(("Failed to stop service. status=%d\n", Status.dwCurrentState)); + } + else + { + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsgFailed(("ControlService failed with LastError=%Rwa. status=%d\n", LastError, Status.dwCurrentState)); + } + CloseServiceHandle(hService); + } + else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) + rc = 0; + else + { + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError)); + } + CloseServiceHandle(hSMgr); + } + return rc; +} + + +/** + * Deletes the service. + * + * @returns 0 on success. + * @returns -1 on failure. + */ +int usblibOsDeleteService(void) +{ + /* + * Assume it didn't exist, so we'll create the service. + */ + int rc = -1; + SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_CHANGE_CONFIG); + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError)); + if (hSMgr) + { + SC_HANDLE hService = OpenService(hSMgr, SERVICE_NAME, DELETE); + if (hService) + { + /* + * Delete the service. + */ + if (DeleteService(hService)) + rc = 0; + else + { + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsgFailed(("DeleteService failed LastError=%Rwa\n", LastError)); + } + CloseServiceHandle(hService); + } + else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) + rc = 0; + else + { + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError)); + } + CloseServiceHandle(hSMgr); + } + return rc; +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kmk b/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kmk new file mode 100644 index 00000000..32c22b53 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kmk @@ -0,0 +1,203 @@ +# $Id: Makefile.kmk $ +## @file +# Sub-Makefile for the Windows USB drivers. +# + +# +# Copyright (C) 2006-2019 Oracle Corporation +# +# This file is part of VirtualBox Open Source Edition (OSE), as +# available from http://www.virtualbox.org. This file is free software; +# you can redistribute it and/or modify it under the terms of the GNU +# General Public License (GPL) as published by the Free Software +# Foundation, in version 2 as it comes in the "COPYING" file of the +# VirtualBox OSE distribution. VirtualBox OSE is distributed in the +# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +# +# The contents of this file may alternatively be used under the terms +# of the Common Development and Distribution License Version 1.0 +# (CDDL) only, as it comes in the "COPYING.CDDL" file of the +# VirtualBox OSE distribution, in which case the provisions of the +# CDDL are applicable instead of those of the GPL. +# +# You may elect to license modified versions of this file under the +# terms and conditions of either the GPL or the CDDL or both. +# + +SUB_DEPTH = ../../../../.. +include $(KBUILD_PATH)/subheader.kmk + +LIBRARIES.win += usbd +SYSMODS.win += VBoxUSB VBoxUSBMon +PROGRAMS.win += USBInstall USBUninstall USBTest +INSTALLS.win += install-infs + +# +# usbd +# +usbd_TEMPLATE = VBOXR0DRV +usbd_SOURCES = usbd/usbd.def + +# +# VBoxUSB +# +VBoxUSB_TEMPLATE = VBOXR0DRV +ifdef VBOX_SIGNING_MODE + VBoxUSB_INSTTYPE = none + VBoxUSB_DEBUG_INSTTYPE = both +endif +VBoxUSB_SDKS = ReorderCompilerIncs $(VBOX_WINDDK) $(VBOX_WINPSDK)INCS +VBoxUSB_DEFS = IN_RT_R0 IN_SUP_R0 VBOX_DBG_LOG_NAME=\"USBDev\" +VBoxUSB_LDFLAGS.x86 = -Entry:DriverEntry@8 +VBoxUSB_LDFLAGS.amd64 = -Entry:DriverEntry +VBoxUSB_SOURCES = \ + dev/VBoxUsbDev.cpp \ + dev/VBoxUsbRt.cpp \ + dev/VBoxUsbPnP.cpp \ + dev/VBoxUsbPwr.cpp \ + cmn/VBoxUsbTool.cpp \ + cmn/VBoxDrvTool.cpp \ + dev/VBoxUsbDev.rc +VBoxUSB_LIBS = \ + $(PATH_SDK_$(VBOX_WINDDK)_LIB)/ntoskrnl.lib \ + $(PATH_SDK_$(VBOX_WINDDK)_LIB)/hal.lib \ + $(PATH_STAGE_LIB)/RuntimeR0Drv$(VBOX_SUFF_LIB) \ + $(usbd_1_TARGET) + +# +# VBoxUSBMon +# +VBoxUSBMon_TEMPLATE = VBOXR0DRV +ifdef VBOX_SIGNING_MODE + VBoxUSBMon_INSTTYPE = none + VBoxUSBMon_DEBUG_INSTTYPE = both +endif +VBoxUSBMon_INCS := $(PATH_SUB_CURRENT)/.. +VBoxUSBMon_SDKS = ReorderCompilerIncs $(VBOX_WINDDK) $(VBOX_WINPSDK)INCS +VBoxUSBMon_DEFS = IN_RT_R0 IN_SUP_R0 i386=1 STD_CALL CONDITION_HANDLING=1 NT_INST=0 \ + WIN32=100 _NT1X_=100 WINNT=1 _WIN32_WINNT=0x0501 WINVER=0x0501 _WIN32_IE=0x0600 WIN32_LEAN_AND_MEAN=1 \ + VBOXUSBFILTERMGR_USB_SPINLOCK VBOX_DBG_LOG_NAME=\"USBMon\" +VBoxUSBMon_LDFLAGS.x86 = -Entry:DriverEntry@8 +VBoxUSBMon_LDFLAGS.amd64 = -Entry:DriverEntry +ifdef VBOX_USBMON_WITH_FILTER_AUTOAPPLY + VBoxUSBMon_DEFS += VBOX_USBMON_WITH_FILTER_AUTOAPPLY +endif +VBoxUSBMon_SOURCES = \ + mon/VBoxUsbMon.cpp \ + mon/VBoxUsbFlt.cpp \ + mon/VBoxUsbHook.cpp \ + cmn/VBoxUsbTool.cpp \ + cmn/VBoxDrvTool.cpp \ + ../USBFilter.cpp \ + ../VBoxUSBFilterMgr.cpp \ + mon/VBoxUsbMon.rc +VBoxUSBMon_LIBS = \ + $(PATH_SDK_$(VBOX_WINDDK)_LIB)/ntoskrnl.lib \ + $(PATH_SDK_$(VBOX_WINDDK)_LIB)/hal.lib \ + $(PATH_STAGE_LIB)/RuntimeR0Drv$(VBOX_SUFF_LIB) \ + $(usbd_1_TARGET) +if1of ($(KBUILD_TYPE), debug) +VBoxUSBMon_DEFS += LOG_ENABLED VBOX_USB_WITH_VERBOSE_LOGGING +endif + +# +# USBInstall +# +USBInstall_TEMPLATE = VBOXR3EXE +USBInstall_DEFS = IN_RT_R3 +USBInstall_SDKS = ReorderCompilerIncs $(VBOX_WINPSDK) $(VBOX_WINDDK) VBOX_NTDLL +USBInstall_CXXFLAGS = -Gz +USBInstall_CFLAGS = -Gz +USBInstall_SOURCES = \ + Install/USBInstall.cpp +USBInstall_LIBS = \ + $(PATH_SDK_$(VBOX_WINDDK)_LIB)/newdev.lib \ + $(LIB_RUNTIME) \ + $(PATH_STAGE_LIB)/SUPR3$(VBOX_SUFF_LIB) \ + $(PATH_STAGE_LIB)/VBoxDrvCfg$(VBOX_SUFF_LIB) + + +# +# USBUninstall +# +USBUninstall_TEMPLATE = VBOXR3EXE +USBUninstall_DEFS = IN_RT_R3 +USBUninstall_SDKS = ReorderCompilerIncs $(VBOX_WINPSDK) $(VBOX_WINDDK) VBOX_NTDLL +USBUninstall_CXXFLAGS = -Gz +USBUninstall_CFLAGS = -Gz +USBUninstall_SOURCES = \ + Install/USBUninstall.cpp +USBUninstall_LIBS = \ + $(PATH_SDK_$(VBOX_WINDDK)_LIB)/newdev.lib \ + $(LIB_RUNTIME) \ + $(PATH_STAGE_LIB)/SUPR3$(VBOX_SUFF_LIB) \ + $(PATH_STAGE_LIB)/VBoxDrvCfg$(VBOX_SUFF_LIB) + +# +# USBTest +# +USBTest_TEMPLATE = VBOXR3EXE +USBTest_DEFS = IN_RT_R3 +USBTest_SDKS = ReorderCompilerIncs $(VBOX_WINPSDK) $(VBOX_WINDDK) VBOX_NTDLL +USBTest_CXXFLAGS = -Gz +USBTest_CFLAGS = -Gz +USBTest_SOURCES = \ + testcase/USBTest.cpp +USBTest_LIBS = \ + $(PATH_SDK_$(VBOX_WINDDK)_LIB)/newdev.lib \ + $(LIB_RUNTIME) \ + $(PATH_STAGE_LIB)/SUPR3$(VBOX_SUFF_LIB) \ + $(PATH_STAGE_LIB)/VBoxDrvCfg$(VBOX_SUFF_LIB) + +# +# Install the INF files. +# +install-infs_TEMPLATE = VBoxR0DrvInfCat +install-infs_SOURCES = \ + $(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.inf \ + $(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.inf +install-infs_CLEAN = $(install-infs_SOURCES) +install-infs_BLDDIRS = \ + $(PATH_TARGET)/VBoxUSBCat.dir \ + $(PATH_TARGET)/VBoxUSBMonCat.dir + +$(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.inf: $(PATH_SUB_CURRENT)/dev/VBoxUSB.inf $(MAKEFILE_CURRENT) | $$(dir $$@) + $(call MSG_GENERATE,install-infs,$@,$<) + $(call VBOX_EDIT_INF_FN,$<,$@) + +$(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.inf: $(PATH_SUB_CURRENT)/mon/VBoxUSBMon.inf $(MAKEFILE_CURRENT) | $$(dir $$@) + $(call MSG_GENERATE,install-infs,$@,$<) + $(call VBOX_EDIT_INF_FN,$<,$@) + +ifdef VBOX_SIGNING_MODE +install-infs_SOURCES += \ + $(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.cat \ + $(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.cat=>VBoxUSB-PreW10.cat \ + $(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.sys \ + $(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.cat \ + $(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.cat=>VBoxUSBMon-PreW10.cat \ + $(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.sys + +$(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.sys: $$(VBoxUSB_1_TARGET) | $$(dir $$@) + $(INSTALL) -m 644 $< $(@D) + +$(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.cat: \ + $(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.inf \ + $(PATH_TARGET)/VBoxUSBCat.dir/VBoxUSB.sys + $(call MSG_TOOL,Inf2Cat,VBoxUSB-inf,$@,$<) + $(call VBOX_MAKE_CAT_FN, $(@D),$@) + +$(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.sys: $$(VBoxUSBMon_1_TARGET) | $$(dir $$@) + $(INSTALL) -m 644 $< $(@D) + +$(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.cat: \ + $(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.inf \ + $(PATH_TARGET)/VBoxUSBMonCat.dir/VBoxUSBMon.sys + $(call MSG_TOOL,Inf2Cat,VBoxUSBMon-inf,$@,$<) + $(call VBOX_MAKE_CAT_FN, $(@D),$@) + +endif # signing + +# generate rules +include $(FILE_KBUILD_SUB_FOOTER) + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/cmn/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/cmn/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/cmn/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp new file mode 100644 index 00000000..bb2fe14b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.cpp @@ -0,0 +1,237 @@ +/* $Id: VBoxDrvTool.cpp $ */ +/** @file + * Windows Driver R0 Tooling. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#include "VBoxDrvTool.h" + +#include <iprt/assert.h> +#include <VBox/log.h> + +#include "../../../win/VBoxDbgLog.h" + +#define VBOXDRVTOOL_MEMTAG 'TDBV' + +static PVOID vboxDrvToolMemAlloc(SIZE_T cbBytes) +{ + PVOID pvMem = ExAllocatePoolWithTag(NonPagedPool, cbBytes, VBOXDRVTOOL_MEMTAG); + Assert(pvMem); + return pvMem; +} + +static PVOID vboxDrvToolMemAllocZ(SIZE_T cbBytes) +{ + PVOID pvMem = vboxDrvToolMemAlloc(cbBytes); + if (pvMem) + { + RtlZeroMemory(pvMem, cbBytes); + } + return pvMem; +} + +static VOID vboxDrvToolMemFree(PVOID pvMem) +{ + ExFreePoolWithTag(pvMem, VBOXDRVTOOL_MEMTAG); +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegOpenKeyU(OUT PHANDLE phKey, IN PUNICODE_STRING pName, IN ACCESS_MASK fAccess) +{ + OBJECT_ATTRIBUTES ObjAttr; + + InitializeObjectAttributes(&ObjAttr, pName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); + + return ZwOpenKey(phKey, fAccess, &ObjAttr); +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegOpenKey(OUT PHANDLE phKey, IN PWCHAR pName, IN ACCESS_MASK fAccess) +{ + UNICODE_STRING RtlStr; + RtlInitUnicodeString(&RtlStr, pName); + + return VBoxDrvToolRegOpenKeyU(phKey, &RtlStr, fAccess); +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegCloseKey(IN HANDLE hKey) +{ + return ZwClose(hKey); +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegQueryValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT PULONG pDword) +{ + struct + { + KEY_VALUE_PARTIAL_INFORMATION Info; + UCHAR Buf[32]; /* should be enough */ + } Buf; + ULONG cbBuf; + UNICODE_STRING RtlStr; + RtlInitUnicodeString(&RtlStr, pName); + NTSTATUS Status = ZwQueryValueKey(hKey, + &RtlStr, + KeyValuePartialInformation, + &Buf.Info, + sizeof(Buf), + &cbBuf); + if (Status == STATUS_SUCCESS) + { + if (Buf.Info.Type == REG_DWORD) + { + Assert(Buf.Info.DataLength == 4); + *pDword = *((PULONG)Buf.Info.Data); + return STATUS_SUCCESS; + } + } + + return STATUS_INVALID_PARAMETER; +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegSetValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT ULONG val) +{ + UNICODE_STRING RtlStr; + RtlInitUnicodeString(&RtlStr, pName); + return ZwSetValueKey(hKey, &RtlStr, + NULL, /* IN ULONG TitleIndex OPTIONAL, reserved */ + REG_DWORD, + &val, + sizeof(val)); +} + +static NTSTATUS vboxDrvToolIoCompletionSetEvent(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp, IN PVOID pvContext) +{ + RT_NOREF2(pDevObj, pIrp); + PKEVENT pEvent = (PKEVENT)pvContext; + KeSetEvent(pEvent, 0, FALSE); + return STATUS_MORE_PROCESSING_REQUIRED; +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostAsync(PDEVICE_OBJECT pDevObj, PIRP pIrp, PKEVENT pEvent) +{ + IoSetCompletionRoutine(pIrp, vboxDrvToolIoCompletionSetEvent, pEvent, TRUE, TRUE, TRUE); + return IoCallDriver(pDevObj, pIrp); +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostSync(PDEVICE_OBJECT pDevObj, PIRP pIrp) +{ + KEVENT Event; + KeInitializeEvent(&Event, NotificationEvent, FALSE); + NTSTATUS Status = VBoxDrvToolIoPostAsync(pDevObj, pIrp, &Event); + if (Status == STATUS_PENDING) + { + KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); + Status = pIrp->IoStatus.Status; + } + return Status; +} + +/* !!!NOTE: the caller MUST be the IRP owner!!! * + * !! one can not post threaded IRPs this way!! */ +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostSyncWithTimeout(PDEVICE_OBJECT pDevObj, PIRP pIrp, ULONG dwTimeoutMs) +{ + KEVENT Event; + LOG(("post irp (0x%p) to DevObj(0x%p) with timeout (%u)", pIrp, pDevObj, dwTimeoutMs)); + + KeInitializeEvent(&Event, NotificationEvent, FALSE); + NTSTATUS Status = VBoxDrvToolIoPostAsync(pDevObj, pIrp, &Event); + if (Status == STATUS_PENDING) + { + LARGE_INTEGER Interval; + PLARGE_INTEGER pInterval = NULL; + if (dwTimeoutMs != RT_INDEFINITE_WAIT) + { + Interval.QuadPart = -(int64_t) dwTimeoutMs /* ms */ * 10000; + pInterval = &Interval; + } + + Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, pInterval); + if (Status == STATUS_TIMEOUT) + { + WARN(("irp (0x%p) to DevObj(0x%p) was not completed within timeout (%u), cancelling", pIrp, pDevObj, dwTimeoutMs)); + if (!IoCancelIrp(pIrp)) + { + /* this may happen, but this is something the caller with timeout is not expecting */ + WARN(("IoCancelIrp failed")); + } + + /* wait for the IRP to complete */ + KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); + } + else + { + ASSERT_WARN(Status == STATUS_SUCCESS, ("uunexpected Status (0x%x)", Status)); + } + + /* by this time the IRP is completed */ + Status = pIrp->IoStatus.Status; + LOG(("Pending IRP(0x%p) completed with status(0x%x)", pIrp, Status)); + } + else + { + LOG(("IRP(0x%p) completed with status(0x%x)", pIrp, Status)); + } + return Status; +} + +VBOXDRVTOOL_DECL(VOID) VBoxDrvToolRefWaitEqual(PVBOXDRVTOOL_REF pRef, uint32_t u32Val) +{ + LARGE_INTEGER Interval; + Interval.QuadPart = -(int64_t) 2 /* ms */ * 10000; + uint32_t cRefs; + size_t loops = 0; + KTIMER kTimer; + NTSTATUS status = STATUS_SUCCESS; + + KeInitializeTimer(&kTimer); + + while ((cRefs = ASMAtomicReadU32(&pRef->cRefs)) > u32Val && loops < 256) + { + Assert(cRefs >= u32Val); + Assert(cRefs < UINT32_MAX/2); + + KeSetTimer(&kTimer, Interval, NULL); + status = KeWaitForSingleObject(&kTimer, Executive, KernelMode, false, NULL); + Assert(NT_SUCCESS(status)); + loops++; + } +} + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolStrCopy(PUNICODE_STRING pDst, CONST PUNICODE_STRING pSrc) +{ + USHORT cbLength = pSrc->Length + sizeof (pDst->Buffer[0]); + pDst->Buffer = (PWCHAR)vboxDrvToolMemAlloc(cbLength); + Assert(pDst->Buffer); + if (pDst->Buffer) + { + RtlMoveMemory(pDst->Buffer, pSrc->Buffer, pSrc->Length); + pDst->Buffer[pSrc->Length / sizeof (pDst->Buffer[0])] = L'\0'; + pDst->Length = pSrc->Length; + pDst->MaximumLength = cbLength; + return STATUS_SUCCESS; + } + return STATUS_NO_MEMORY; +} + +VBOXDRVTOOL_DECL(VOID) VBoxDrvToolStrFree(PUNICODE_STRING pStr) +{ + vboxDrvToolMemFree(pStr->Buffer); +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.h b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.h new file mode 100644 index 00000000..248c4b63 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxDrvTool.h @@ -0,0 +1,103 @@ +/* $Id: VBoxDrvTool.h $ */ +/** @file + * Windows Driver R0 Tooling. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxDrvTool_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxDrvTool_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include <VBox/cdefs.h> +#include <iprt/stdint.h> +#include <iprt/assert.h> +#include <iprt/asm.h> +#include <iprt/nt/wdm.h> + + +RT_C_DECLS_BEGIN + +#if 0 +/* enable this in case we include this in a dll*/ +# ifdef IN_VBOXDRVTOOL +# define VBOXDRVTOOL_DECL(a_Type) DECLEXPORT(a_Type) +# else +# define VBOXDRVTOOL_DECL(a_Type) DECLIMPORT(a_Type) +# endif +#else +/*enable this in case we include this in a static lib*/ +# define VBOXDRVTOOL_DECL(a_Type) a_Type VBOXCALL +#endif + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegOpenKeyU(OUT PHANDLE phKey, IN PUNICODE_STRING pName, IN ACCESS_MASK fAccess); +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegOpenKey(OUT PHANDLE phKey, IN PWCHAR pName, IN ACCESS_MASK fAccess); +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegCloseKey(IN HANDLE hKey); +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegQueryValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT PULONG pDword); +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolRegSetValueDword(IN HANDLE hKey, IN PWCHAR pName, OUT ULONG val); + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostAsync(PDEVICE_OBJECT pDevObj, PIRP pIrp, PKEVENT pEvent); +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostSync(PDEVICE_OBJECT pDevObj, PIRP pIrp); +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolIoPostSyncWithTimeout(PDEVICE_OBJECT pDevObj, PIRP pIrp, ULONG dwTimeoutMs); +DECLINLINE(NTSTATUS) VBoxDrvToolIoComplete(PIRP pIrp, NTSTATUS Status, ULONG ulInfo) +{ + pIrp->IoStatus.Status = Status; + pIrp->IoStatus.Information = ulInfo; + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + return Status; +} + +typedef struct VBOXDRVTOOL_REF +{ + volatile uint32_t cRefs; +} VBOXDRVTOOL_REF, *PVBOXDRVTOOL_REF; + +DECLINLINE(void) VBoxDrvToolRefInit(PVBOXDRVTOOL_REF pRef) +{ + pRef->cRefs = 1; +} + +DECLINLINE(uint32_t) VBoxDrvToolRefRetain(PVBOXDRVTOOL_REF pRef) +{ + Assert(pRef->cRefs); + Assert(pRef->cRefs < UINT32_MAX / 2); + return ASMAtomicIncU32(&pRef->cRefs); +} + +DECLINLINE(uint32_t) VBoxDrvToolRefRelease(PVBOXDRVTOOL_REF pRef) +{ + uint32_t cRefs = ASMAtomicDecU32(&pRef->cRefs); + Assert(cRefs < UINT32_MAX/2); + return cRefs; +} + +VBOXDRVTOOL_DECL(VOID) VBoxDrvToolRefWaitEqual(PVBOXDRVTOOL_REF pRef, uint32_t u32Val); + +VBOXDRVTOOL_DECL(NTSTATUS) VBoxDrvToolStrCopy(PUNICODE_STRING pDst, CONST PUNICODE_STRING pSrc); +VBOXDRVTOOL_DECL(VOID) VBoxDrvToolStrFree(PUNICODE_STRING pStr); + +RT_C_DECLS_END + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxDrvTool_h */ + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbIdc.h b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbIdc.h new file mode 100644 index 00000000..75cb651c --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbIdc.h @@ -0,0 +1,85 @@ +/* $Id: VBoxUsbIdc.h $ */ +/** @file + * Windows USB Proxy - Monitor Driver communication interface. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxUsbIdc_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxUsbIdc_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#define VBOXUSBIDC_VERSION_MAJOR 1 +#define VBOXUSBIDC_VERSION_MINOR 0 + +#define VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION CTL_CODE(FILE_DEVICE_UNKNOWN, 0x618, METHOD_NEITHER, FILE_WRITE_ACCESS) +#define VBOXUSBIDC_INTERNAL_IOCTL_PROXY_STARTUP CTL_CODE(FILE_DEVICE_UNKNOWN, 0x619, METHOD_NEITHER, FILE_WRITE_ACCESS) +#define VBOXUSBIDC_INTERNAL_IOCTL_PROXY_TEARDOWN CTL_CODE(FILE_DEVICE_UNKNOWN, 0x61A, METHOD_NEITHER, FILE_WRITE_ACCESS) +#define VBOXUSBIDC_INTERNAL_IOCTL_PROXY_STATE_CHANGE CTL_CODE(FILE_DEVICE_UNKNOWN, 0x61B, METHOD_NEITHER, FILE_WRITE_ACCESS) + +typedef struct +{ + uint32_t u32Major; + uint32_t u32Minor; +} VBOXUSBIDC_VERSION, *PVBOXUSBIDC_VERSION; + +typedef void *HVBOXUSBIDCDEV; + +/* the initial device state is USBDEVICESTATE_HELD_BY_PROXY */ +typedef struct VBOXUSBIDC_PROXY_STARTUP +{ + union + { + /* in: device PDO */ + PDEVICE_OBJECT pPDO; + /* out: device handle to be used for subsequent USBSUP_PROXY_XXX calls */ + HVBOXUSBIDCDEV hDev; + } u; +} VBOXUSBIDC_PROXY_STARTUP, *PVBOXUSBIDC_PROXY_STARTUP; + +typedef struct VBOXUSBIDC_PROXY_TEARDOWN +{ + HVBOXUSBIDCDEV hDev; +} VBOXUSBIDC_PROXY_TEARDOWN, *PVBOXUSBIDC_PROXY_TEARDOWN; + +typedef enum +{ + VBOXUSBIDC_PROXY_STATE_UNKNOWN = 0, + VBOXUSBIDC_PROXY_STATE_IDLE, + VBOXUSBIDC_PROXY_STATE_INITIAL = VBOXUSBIDC_PROXY_STATE_IDLE, + VBOXUSBIDC_PROXY_STATE_USED_BY_GUEST +} VBOXUSBIDC_PROXY_STATE; + +typedef struct VBOXUSBIDC_PROXY_STATE_CHANGE +{ + HVBOXUSBIDCDEV hDev; + VBOXUSBIDC_PROXY_STATE enmState; +} VBOXUSBIDC_PROXY_STATE_CHANGE, *PVBOXUSBIDC_PROXY_STATE_CHANGE; + +NTSTATUS VBoxUsbIdcInit(); +VOID VBoxUsbIdcTerm(); +NTSTATUS VBoxUsbIdcProxyStarted(PDEVICE_OBJECT pPDO, HVBOXUSBIDCDEV *phDev); +NTSTATUS VBoxUsbIdcProxyStopped(HVBOXUSBIDCDEV hDev); + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxUsbIdc_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.cpp b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.cpp new file mode 100644 index 00000000..0016881b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.cpp @@ -0,0 +1,418 @@ +/* $Id: VBoxUsbTool.cpp $ */ +/** @file + * Windows USB R0 Tooling. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#define INITGUID +#include "VBoxUsbTool.h" +#include <usbbusif.h> + +#include <iprt/assert.h> +#include <iprt/string.h> +#include <iprt/utf16.h> +#include <VBox/log.h> +#include <VBox/usblib.h> + +#include "../../../win/VBoxDbgLog.h" + +#define VBOXUSBTOOL_MEMTAG 'TUBV' + +static PVOID vboxUsbToolMemAlloc(SIZE_T cbBytes) +{ + PVOID pvMem = ExAllocatePoolWithTag(NonPagedPool, cbBytes, VBOXUSBTOOL_MEMTAG); + Assert(pvMem); + return pvMem; +} + +static PVOID vboxUsbToolMemAllocZ(SIZE_T cbBytes) +{ + PVOID pvMem = vboxUsbToolMemAlloc(cbBytes); + if (pvMem) + { + RtlZeroMemory(pvMem, cbBytes); + } + return pvMem; +} + +static VOID vboxUsbToolMemFree(PVOID pvMem) +{ + ExFreePoolWithTag(pvMem, VBOXUSBTOOL_MEMTAG); +} + +VBOXUSBTOOL_DECL(PURB) VBoxUsbToolUrbAlloc(USHORT u16Function, USHORT cbSize) +{ + PURB pUrb = (PURB)vboxUsbToolMemAlloc(cbSize); + Assert(pUrb); + if (!pUrb) + return NULL; + + pUrb->UrbHeader.Length = cbSize; + pUrb->UrbHeader.Function = u16Function; + return pUrb; +} + +VBOXUSBTOOL_DECL(PURB) VBoxUsbToolUrbAllocZ(USHORT u16Function, USHORT cbSize) +{ + PURB pUrb = (PURB)vboxUsbToolMemAllocZ(cbSize); + Assert(pUrb); + if (!pUrb) + return NULL; + + pUrb->UrbHeader.Length = cbSize; + pUrb->UrbHeader.Function = u16Function; + return pUrb; +} + +VBOXUSBTOOL_DECL(PURB) VBoxUsbToolUrbReinit(PURB pUrb, USHORT cbSize, USHORT u16Function) +{ + Assert(pUrb->UrbHeader.Length == cbSize); + if (pUrb->UrbHeader.Length < cbSize) + return NULL; + pUrb->UrbHeader.Length = cbSize; + pUrb->UrbHeader.Function = u16Function; + return pUrb; +} + +VBOXUSBTOOL_DECL(VOID) VBoxUsbToolUrbFree(PURB pUrb) +{ + vboxUsbToolMemFree(pUrb); +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolUrbPost(PDEVICE_OBJECT pDevObj, PURB pUrb, ULONG dwTimeoutMs) +{ + if (dwTimeoutMs == RT_INDEFINITE_WAIT) + return VBoxUsbToolIoInternalCtlSendSync(pDevObj, IOCTL_INTERNAL_USB_SUBMIT_URB, pUrb, NULL); + return VBoxUsbToolIoInternalCtlSendSyncWithTimeout(pDevObj, IOCTL_INTERNAL_USB_SUBMIT_URB, pUrb, NULL, dwTimeoutMs); +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDescriptor(PDEVICE_OBJECT pDevObj, void *pvBuffer, int cbBuffer, int Type, int iIndex, int LangId, ULONG dwTimeoutMs) +{ + NTSTATUS Status; + USHORT cbUrb = sizeof (struct _URB_CONTROL_DESCRIPTOR_REQUEST); + PURB pUrb = VBoxUsbToolUrbAllocZ(URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE, cbUrb); + if (!pUrb) + { + WARN(("allocating URB failed")); + return STATUS_INSUFFICIENT_RESOURCES; + } + + PUSB_COMMON_DESCRIPTOR pCmn = (PUSB_COMMON_DESCRIPTOR)pvBuffer; + pCmn->bLength = cbBuffer; + pCmn->bDescriptorType = Type; + + pUrb->UrbHeader.Function = URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE; + pUrb->UrbHeader.Length = sizeof(struct _URB_CONTROL_DESCRIPTOR_REQUEST); + pUrb->UrbControlDescriptorRequest.TransferBufferLength = cbBuffer; + pUrb->UrbControlDescriptorRequest.TransferBuffer = pvBuffer; + pUrb->UrbControlDescriptorRequest.Index = (UCHAR)iIndex; + pUrb->UrbControlDescriptorRequest.DescriptorType = (UCHAR)Type; + pUrb->UrbControlDescriptorRequest.LanguageId = (USHORT)LangId; + + Status = VBoxUsbToolUrbPost(pDevObj, pUrb, dwTimeoutMs); + ASSERT_WARN(Status == STATUS_SUCCESS, ("VBoxUsbToolUrbPost failed Status (0x%x)", Status)); + + VBoxUsbToolUrbFree(pUrb); + + return Status; +} + +VBOXUSBTOOL_DECL(VOID) VBoxUsbToolStringDescriptorToUnicodeString(PUSB_STRING_DESCRIPTOR pDr, PUNICODE_STRING pUnicode) +{ + /* for some reason the string dr sometimes contains a non-null terminated string + * although we zeroed up the complete descriptor buffer + * this is why RtlInitUnicodeString won't work + * we need to init the scting length based on dr length */ + pUnicode->Buffer = pDr->bString; + pUnicode->Length = pUnicode->MaximumLength = pDr->bLength - RT_OFFSETOF(USB_STRING_DESCRIPTOR, bString); +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptor(PDEVICE_OBJECT pDevObj, char *pszResult, ULONG cbResult, + int iIndex, int LangId, ULONG dwTimeoutMs) +{ + char aBuf[MAXIMUM_USB_STRING_LENGTH]; + AssertCompile(sizeof (aBuf) <= UINT8_MAX); + UCHAR cbBuf = (UCHAR)sizeof (aBuf); + PUSB_STRING_DESCRIPTOR pDr = (PUSB_STRING_DESCRIPTOR)&aBuf; + + Assert(pszResult); + *pszResult = 0; + + memset(pDr, 0, cbBuf); + pDr->bLength = cbBuf; + pDr->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE; + + NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, iIndex, LangId, dwTimeoutMs); + if (NT_SUCCESS(Status)) + { + if (pDr->bLength >= sizeof (USB_STRING_DESCRIPTOR)) + { + int rc = RTUtf16ToUtf8Ex(pDr->bString, (pDr->bLength - RT_OFFSETOF(USB_STRING_DESCRIPTOR, bString)) / sizeof(RTUTF16), + &pszResult, cbResult, NULL /*pcch*/); + if (RT_SUCCESS(rc)) + { + USBLibPurgeEncoding(pszResult); + Status = STATUS_SUCCESS; + } + else + Status = STATUS_UNSUCCESSFUL; + } + else + Status = STATUS_INVALID_PARAMETER; + } + return Status; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetLangID(PDEVICE_OBJECT pDevObj, int *pLangId, ULONG dwTimeoutMs) +{ + char aBuf[MAXIMUM_USB_STRING_LENGTH]; + AssertCompile(sizeof (aBuf) <= UINT8_MAX); + UCHAR cbBuf = (UCHAR)sizeof (aBuf); + PUSB_STRING_DESCRIPTOR pDr = (PUSB_STRING_DESCRIPTOR)&aBuf; + + Assert(pLangId); + *pLangId = 0; + + memset(pDr, 0, cbBuf); + pDr->bLength = cbBuf; + pDr->bDescriptorType = USB_STRING_DESCRIPTOR_TYPE; + + NTSTATUS Status = VBoxUsbToolGetDescriptor(pDevObj, pDr, cbBuf, USB_STRING_DESCRIPTOR_TYPE, 0, 0, dwTimeoutMs); + if (NT_SUCCESS(Status)) + { + /* Just grab the first lang ID if available. In 99% cases, it will be US English (0x0409).*/ + if (pDr->bLength >= sizeof (USB_STRING_DESCRIPTOR)) + { + AssertCompile(sizeof (pDr->bString[0]) == sizeof (uint16_t)); + *pLangId = pDr->bString[0]; + Status = STATUS_SUCCESS; + } + else + { + Status = STATUS_INVALID_PARAMETER; + } + } + return Status; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDeviceSpeed(PDEVICE_OBJECT pDevObj, BOOLEAN *pbIsHigh) +{ + Assert(pbIsHigh); + *pbIsHigh = FALSE; + + PIRP pIrp = IoAllocateIrp(pDevObj->StackSize, FALSE); + Assert(pIrp); + if (!pIrp) + { + return STATUS_INSUFFICIENT_RESOURCES; + } + + USB_BUS_INTERFACE_USBDI_V1 BusIf; + PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp); + pSl->MajorFunction = IRP_MJ_PNP; + pSl->MinorFunction = IRP_MN_QUERY_INTERFACE; + pSl->Parameters.QueryInterface.InterfaceType = &USB_BUS_INTERFACE_USBDI_GUID; + pSl->Parameters.QueryInterface.Size = sizeof (BusIf); + pSl->Parameters.QueryInterface.Version = USB_BUSIF_USBDI_VERSION_1; + pSl->Parameters.QueryInterface.Interface = (PINTERFACE)&BusIf; + pSl->Parameters.QueryInterface.InterfaceSpecificData = NULL; + + pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED; + + NTSTATUS Status = VBoxDrvToolIoPostSync(pDevObj, pIrp); + Assert(NT_SUCCESS(Status) || Status == STATUS_NOT_SUPPORTED); + if (NT_SUCCESS(Status)) + { + *pbIsHigh = BusIf.IsDeviceHighSpeed(BusIf.BusContext); + BusIf.InterfaceDereference(BusIf.BusContext); + } + IoFreeIrp(pIrp); + + return Status; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolPipeClear(PDEVICE_OBJECT pDevObj, HANDLE hPipe, bool fReset) +{ + if (!hPipe) + { + Log(("Resetting the control pipe??\n")); + return STATUS_SUCCESS; + } + USHORT u16Function = fReset ? URB_FUNCTION_RESET_PIPE : URB_FUNCTION_ABORT_PIPE; + PURB pUrb = VBoxUsbToolUrbAlloc(u16Function, sizeof (struct _URB_PIPE_REQUEST)); + if (!pUrb) + { + AssertMsgFailed((__FUNCTION__": VBoxUsbToolUrbAlloc failed!\n")); + return STATUS_INSUFFICIENT_RESOURCES; + } + pUrb->UrbPipeRequest.PipeHandle = hPipe; + pUrb->UrbPipeRequest.Reserved = 0; + + NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, pUrb, RT_INDEFINITE_WAIT); + if (!NT_SUCCESS(Status) || !USBD_SUCCESS(pUrb->UrbHeader.Status)) + { + AssertMsgFailed((__FUNCTION__": vboxUsbToolRequest failed with %x (%x)\n", Status, pUrb->UrbHeader.Status)); + } + + VBoxUsbToolUrbFree(pUrb); + + return Status; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolCurrentFrame(PDEVICE_OBJECT pDevObj, PIRP pIrp, PULONG piFrame) +{ + struct _URB_GET_CURRENT_FRAME_NUMBER Urb; + Urb.Hdr.Function = URB_FUNCTION_GET_CURRENT_FRAME_NUMBER; + Urb.Hdr.Length = sizeof(Urb); + Urb.FrameNumber = (ULONG)-1; + + Assert(piFrame); + *piFrame = (ULONG)-1; + + PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp); + pSl->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; + pSl->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB; + pSl->Parameters.Others.Argument1 = (PVOID)&Urb; + pSl->Parameters.Others.Argument2 = NULL; + + NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, (PURB)&Urb, RT_INDEFINITE_WAIT); + Assert(NT_SUCCESS(Status)); + if (NT_SUCCESS(Status)) + { + *piFrame = Urb.FrameNumber; + } + + return Status; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolDevUnconfigure(PDEVICE_OBJECT pDevObj) +{ + USHORT cbUrb = sizeof (struct _URB_SELECT_CONFIGURATION); + PURB pUrb = VBoxUsbToolUrbAlloc(URB_FUNCTION_SELECT_CONFIGURATION, cbUrb); + Assert(pUrb); + if (!pUrb) + return STATUS_INSUFFICIENT_RESOURCES; + + UsbBuildSelectConfigurationRequest(pUrb, (USHORT)cbUrb, NULL); + + NTSTATUS Status = VBoxUsbToolUrbPost(pDevObj, pUrb, RT_INDEFINITE_WAIT); + Assert(NT_SUCCESS(Status)); + + VBoxUsbToolUrbFree(pUrb); + + return Status; +} + +VBOXUSBTOOL_DECL(PIRP) VBoxUsbToolIoBuildAsyncInternalCtl(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2) +{ + PIRP pIrp = IoAllocateIrp(pDevObj->StackSize, FALSE); + Assert(pIrp); + if (!pIrp) + { + return NULL; + } + + pIrp->IoStatus.Status = STATUS_SUCCESS; + pIrp->IoStatus.Information = NULL; + + PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp); + pSl->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; + pSl->MinorFunction = 0; + pSl->Parameters.DeviceIoControl.IoControlCode = uCtl; + pSl->Parameters.Others.Argument1 = pvArg1; + pSl->Parameters.Others.Argument2 = pvArg2; + return pIrp; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendSyncWithTimeout(PDEVICE_OBJECT pDevObj, ULONG uCtl, + void *pvArg1, void *pvArg2, ULONG dwTimeoutMs) +{ + /* since we're going to cancel the irp on timeout, we should allocate our own IRP rather than using the threaded one + * */ + PIRP pIrp = VBoxUsbToolIoBuildAsyncInternalCtl(pDevObj, uCtl, pvArg1, pvArg2); + if (!pIrp) + { + WARN(("VBoxUsbToolIoBuildAsyncInternalCtl failed")); + return STATUS_INSUFFICIENT_RESOURCES; + } + + NTSTATUS Status = VBoxDrvToolIoPostSyncWithTimeout(pDevObj, pIrp, dwTimeoutMs); + + IoFreeIrp(pIrp); + + return Status; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendAsync(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2, + PKEVENT pEvent, PIO_STATUS_BLOCK pIoStatus) +{ + NTSTATUS Status; + PIRP pIrp; + PIO_STACK_LOCATION pSl; + Assert(KeGetCurrentIrql() == PASSIVE_LEVEL); + + pIrp = IoBuildDeviceIoControlRequest(uCtl, pDevObj, NULL, 0, NULL, 0, TRUE, pEvent, pIoStatus); + if (!pIrp) + { + WARN(("IoBuildDeviceIoControlRequest failed!!\n")); + pIoStatus->Status = STATUS_INSUFFICIENT_RESOURCES; + pIoStatus->Information = 0; + return STATUS_INSUFFICIENT_RESOURCES; + } + + /* Get the next stack location as that is used for the new irp */ + pSl = IoGetNextIrpStackLocation(pIrp); + pSl->Parameters.Others.Argument1 = pvArg1; + pSl->Parameters.Others.Argument2 = pvArg2; + + Status = IoCallDriver(pDevObj, pIrp); + + return Status; +} + +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendSync(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2) +{ + IO_STATUS_BLOCK IoStatus = {0}; + KEVENT Event; + NTSTATUS Status; + + KeInitializeEvent(&Event, NotificationEvent, FALSE); + + LOG(("Sending sync Ctl pDevObj(0x%p), uCtl(0x%x), pvArg1(0x%p), pvArg2(0x%p)", pDevObj, uCtl, pvArg1, pvArg2)); + + Status = VBoxUsbToolIoInternalCtlSendAsync(pDevObj, uCtl, pvArg1, pvArg2, &Event, &IoStatus); + + if (Status == STATUS_PENDING) + { + LOG(("VBoxUsbToolIoInternalCtlSendAsync returned pending for pDevObj(0x%x)", pDevObj)); + KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); + Status = IoStatus.Status; + LOG(("Pending VBoxUsbToolIoInternalCtlSendAsync completed with Status (0x%x) for pDevObj(0x%x)", Status, pDevObj)); + } + else + { + LOG(("VBoxUsbToolIoInternalCtlSendAsync completed with Status (0x%x) for pDevObj(0x%x)", Status, pDevObj)); + } + + return Status; +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.h b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.h new file mode 100644 index 00000000..aeb62f05 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/cmn/VBoxUsbTool.h @@ -0,0 +1,79 @@ +/* $Id: VBoxUsbTool.h $ */ +/** @file + * Windows USB R0 Tooling. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxUsbTool_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxUsbTool_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "VBoxDrvTool.h" + +RT_C_DECLS_BEGIN +#pragma warning( disable : 4200 ) +#include <usbdi.h> +#pragma warning( default : 4200 ) +#include <usbdlib.h> + +RT_C_DECLS_END + +#if 0 +/* enable this in case we include this in a dll*/ +# ifdef IN_VBOXUSBTOOL +# define VBOXUSBTOOL_DECL(a_Type) DECLEXPORT(a_Type) +# else +# define VBOXUSBTOOL_DECL(a_Type) DECLIMPORT(a_Type) +# endif +#else +/*enable this in case we include this in a static lib*/ +# define VBOXUSBTOOL_DECL(a_Type) a_Type VBOXCALL +#endif + + +RT_C_DECLS_BEGIN + +VBOXUSBTOOL_DECL(PURB) VBoxUsbToolUrbAlloc(USHORT u16Function, USHORT cbSize); +VBOXUSBTOOL_DECL(PURB) VBoxUsbToolUrbAllocZ(USHORT u16Function, USHORT cbSize); +VBOXUSBTOOL_DECL(PURB) VBoxUsbToolUrbReinit(PURB pUrb, USHORT cbSize, USHORT u16Function); +VBOXUSBTOOL_DECL(VOID) VBoxUsbToolUrbFree(PURB pUrb); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolUrbPost(PDEVICE_OBJECT pDevObj, PURB pUrb, ULONG dwTimeoutMs); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDescriptor(PDEVICE_OBJECT pDevObj, void *pvBuffer, int cbBuffer, int Type, int iIndex, int LangId, ULONG dwTimeoutMs); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetStringDescriptor(PDEVICE_OBJECT pDevObj, char *pszResult, ULONG cbResult, int iIndex, int LangId, ULONG dwTimeoutMs); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetLangID(PDEVICE_OBJECT pDevObj, int *pLangId, ULONG dwTimeoutMs); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolGetDeviceSpeed(PDEVICE_OBJECT pDevObj, BOOLEAN *pbIsHigh); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolPipeClear(PDEVICE_OBJECT pDevObj, HANDLE hPipe, bool fReset); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolCurrentFrame(PDEVICE_OBJECT pDevObj, PIRP pIrp, PULONG piFrame); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolDevUnconfigure(PDEVICE_OBJECT pDevObj); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendAsync(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2, PKEVENT pEvent, PIO_STATUS_BLOCK pIoStatus); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendSync(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2); +VBOXUSBTOOL_DECL(PIRP) VBoxUsbToolIoBuildAsyncInternalCtl(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2); +VBOXUSBTOOL_DECL(NTSTATUS) VBoxUsbToolIoInternalCtlSendSyncWithTimeout(PDEVICE_OBJECT pDevObj, ULONG uCtl, void *pvArg1, void *pvArg2, ULONG dwTimeoutMs); +VBOXUSBTOOL_DECL(VOID) VBoxUsbToolStringDescriptorToUnicodeString(PUSB_STRING_DESCRIPTOR pDr, PUNICODE_STRING pUnicode); + + +RT_C_DECLS_END + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_cmn_VBoxUsbTool_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/dev/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUSB.inf b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUSB.inf new file mode 100644 index 00000000..54ef604d --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUSB.inf @@ -0,0 +1,81 @@ +; $Id: VBoxUSB.inf $ +;; @file +; VBox host drivers - USB drivers - Win32 USB device +; + +; +; Copyright (C) 2011-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +[Version] +Signature="$Windows NT$" +Class=USB +ClassGUID={36FC9E60-C465-11CF-8056-444553540000} +provider=%ORACLE% +;edit-DriverVer=08/26/2008,2.00.0000 +;cat CatalogFile=VBoxUSB.cat + +[SourceDisksNames] +1=%Disk_Description%,,, + +[SourceDisksFiles] +VBoxUSB.sys = 1 + +[Manufacturer] +;x86 %MfgName%=ORACLE +;amd64 %MfgName%=ORACLE, NTamd64 + +;x86 [ORACLE] +;amd64 [ORACLE.NTamd64] +%USB\VID_80EE&PID_CAFE.DeviceDesc%=VBoxUSB.Dev, USB\VID_80EE&PID_CAFE + +[DestinationDirs] +VBoxUSB.Files.Ext = 10,System32\Drivers + +[VBoxUSB.Dev.NT] +CopyFiles=VBoxUSB.Files.Ext + +[VBoxUSB.Dev.NT.Services] +Addservice = VBoxUSB, 0x00000002, VBoxUSB.AddService + +[VBoxUSB.AddService] +DisplayName = %VBoxUSB.SvcDesc% +ServiceType = 1 ; SERVICE_KERNEL_DRIVER +StartType = 3 ; SERVICE_DEMAND_START +ErrorControl = 1 ; SERVICE_ERROR_NORMAL +ServiceBinary = %10%\System32\Drivers\VBoxUSB.sys +AddReg = VBoxUSB.AddReg +LoadOrderGroup = Base + +[VBoxUSB.AddReg] +HKR,,DevLoader,,*ntkern +HKR,,NTMPDriver,,VBoxUSB.sys + +[VBoxUSB.Files.Ext] +VBoxUSB.sys + +;---------------------------------------------------------------; + +[Strings] +ORACLE="Oracle Corporation" +MfgName="Oracle Corporation" +Disk_Description="VBoxUSB Installation Disk" +USB\VID_80EE&PID_CAFE.DeviceDesc="VirtualBox USB" +VBoxUSB.SvcDesc="VirtualBox USB" diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbCmn.h b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbCmn.h new file mode 100644 index 00000000..bc7e82ac --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbCmn.h @@ -0,0 +1,93 @@ +/* $Id: VBoxUsbCmn.h $ */ +/** @file + * VBoxUsmCmn.h - USB device. Common defs + */ +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbCmn_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbCmn_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "../cmn/VBoxDrvTool.h" +#include "../cmn/VBoxUsbTool.h" + +#include <iprt/cdefs.h> +#include <iprt/asm.h> + +#include <VBox/usblib-win.h> + +#define VBOXUSB_CFG_IDLE_TIME_MS 5000 + +typedef struct VBOXUSBDEV_EXT *PVBOXUSBDEV_EXT; + +RT_C_DECLS_BEGIN + +#ifdef _WIN64 +#define DECLSPEC_USBIMPORT DECLSPEC_IMPORT +#else +#define DECLSPEC_USBIMPORT + +#define USBD_ParseDescriptors _USBD_ParseDescriptors +#define USBD_ParseConfigurationDescriptorEx _USBD_ParseConfigurationDescriptorEx +#define USBD_CreateConfigurationRequestEx _USBD_CreateConfigurationRequestEx +#endif + +DECLSPEC_USBIMPORT PUSB_COMMON_DESCRIPTOR +USBD_ParseDescriptors( + IN PVOID DescriptorBuffer, + IN ULONG TotalLength, + IN PVOID StartPosition, + IN LONG DescriptorType + ); + +DECLSPEC_USBIMPORT PUSB_INTERFACE_DESCRIPTOR +USBD_ParseConfigurationDescriptorEx( + IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, + IN PVOID StartPosition, + IN LONG InterfaceNumber, + IN LONG AlternateSetting, + IN LONG InterfaceClass, + IN LONG InterfaceSubClass, + IN LONG InterfaceProtocol + ); + +DECLSPEC_USBIMPORT PURB +USBD_CreateConfigurationRequestEx( + IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor, + IN PUSBD_INTERFACE_LIST_ENTRY InterfaceList + ); + +RT_C_DECLS_END + +DECLHIDDEN(PVOID) vboxUsbMemAlloc(SIZE_T cbBytes); +DECLHIDDEN(PVOID) vboxUsbMemAllocZ(SIZE_T cbBytes); +DECLHIDDEN(VOID) vboxUsbMemFree(PVOID pvMem); + +#include "VBoxUsbRt.h" +#include "VBoxUsbPnP.h" +#include "VBoxUsbPwr.h" +#include "VBoxUsbDev.h" + + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbCmn_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.cpp b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.cpp new file mode 100644 index 00000000..b3a23ae4 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.cpp @@ -0,0 +1,347 @@ +/* $Id: VBoxUsbDev.cpp $ */ +/** @file + * VBoxUsbDev.cpp - USB device. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxUsbCmn.h" +#include <iprt/assert.h> +#include <VBox/log.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +#define VBOXUSB_MEMTAG 'bUBV' + + + +DECLHIDDEN(PVOID) vboxUsbMemAlloc(SIZE_T cbBytes) +{ + PVOID pvMem = ExAllocatePoolWithTag(NonPagedPool, cbBytes, VBOXUSB_MEMTAG); + Assert(pvMem); + return pvMem; +} + +DECLHIDDEN(PVOID) vboxUsbMemAllocZ(SIZE_T cbBytes) +{ + PVOID pvMem = vboxUsbMemAlloc(cbBytes); + if (pvMem) + { + RtlZeroMemory(pvMem, cbBytes); + } + return pvMem; +} + +DECLHIDDEN(VOID) vboxUsbMemFree(PVOID pvMem) +{ + ExFreePoolWithTag(pvMem, VBOXUSB_MEMTAG); +} + +VBOXUSB_GLOBALS g_VBoxUsbGlobals = {0}; + +static NTSTATUS vboxUsbDdiAddDevice(PDRIVER_OBJECT pDriverObject, + PDEVICE_OBJECT pPDO) +{ + PDEVICE_OBJECT pFDO = NULL; + NTSTATUS Status = IoCreateDevice(pDriverObject, + sizeof (VBOXUSBDEV_EXT), + NULL, /* IN PUNICODE_STRING pDeviceName OPTIONAL */ + FILE_DEVICE_UNKNOWN, /* IN DEVICE_TYPE DeviceType */ + FILE_AUTOGENERATED_DEVICE_NAME, /* IN ULONG DeviceCharacteristics */ + FALSE, /* IN BOOLEAN fExclusive */ + &pFDO); + Assert(Status == STATUS_SUCCESS); + if (Status == STATUS_SUCCESS) + { + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pFDO->DeviceExtension; + /* init Device Object bits */ + pFDO->Flags |= DO_DIRECT_IO; + if (pPDO->Flags & DO_POWER_PAGABLE) + pFDO->Flags |= DO_POWER_PAGABLE; + + + /* now init our state bits */ + + pDevExt->cHandles = 0; + + pDevExt->pFDO = pFDO; + pDevExt->pPDO = pPDO; + pDevExt->pLowerDO = IoAttachDeviceToDeviceStack(pFDO, pPDO); + Assert(pDevExt->pLowerDO); + if (pDevExt->pLowerDO) + { + vboxUsbDdiStateInit(pDevExt); + Status = vboxUsbRtInit(pDevExt); + if (Status == STATUS_SUCCESS) + { + /* we're done! */ + pFDO->Flags &= ~DO_DEVICE_INITIALIZING; + return STATUS_SUCCESS; + } + + IoDetachDevice(pDevExt->pLowerDO); + } + else + Status = STATUS_NO_SUCH_DEVICE; + + IoDeleteDevice(pFDO); + } + + return Status; +} + +static VOID vboxUsbDdiUnload(PDRIVER_OBJECT pDriverObject) +{ + RT_NOREF1(pDriverObject); + LogRel(("VBoxUsb::DriverUnload. Built Date (%s) Time (%s)\n", __DATE__, __TIME__)); + VBoxDrvToolStrFree(&g_VBoxUsbGlobals.RegPath); + + vboxUsbRtGlobalsTerm(); + + PRTLOGGER pLogger = RTLogRelSetDefaultInstance(NULL); + if (pLogger) + { + RTLogDestroy(pLogger); + } + pLogger = RTLogSetDefaultInstance(NULL); + if (pLogger) + { + RTLogDestroy(pLogger); + } +} + +static NTSTATUS vboxUsbDispatchCreate(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + NTSTATUS Status = STATUS_INVALID_HANDLE; + do + { + if (vboxUsbPnPStateGet(pDevExt) != ENMVBOXUSB_PNPSTATE_STARTED) + { + Status = STATUS_INVALID_DEVICE_STATE; + break; + } + + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + if (!pFObj) + { + Status = STATUS_INVALID_PARAMETER; + break; + } + + pFObj->FsContext = NULL; + + if (pFObj->FileName.Length) + { + Status = STATUS_INVALID_PARAMETER; + break; + } + + Status = vboxUsbRtCreate(pDevExt, pIrp); + if (!NT_SUCCESS(Status)) + { + AssertFailed(); + break; + } + + ASMAtomicIncU32(&pDevExt->cHandles); + Status = STATUS_SUCCESS; + break; + } while (0); + + Status = VBoxDrvToolIoComplete(pIrp, Status, 0); + return Status; +} + +static NTSTATUS vboxUsbDispatchClose(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + NTSTATUS Status = STATUS_SUCCESS; +#ifdef VBOX_STRICT + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + Assert(pFObj); + Assert(!pFObj->FileName.Length); +#endif + Status = vboxUsbRtClose(pDevExt, pIrp); + if (NT_SUCCESS(Status)) + { + ASMAtomicDecU32(&pDevExt->cHandles); + } + else + { + AssertFailed(); + } + Status = VBoxDrvToolIoComplete(pIrp, Status, 0); + return Status; +} + +static NTSTATUS vboxUsbDispatchDeviceControl(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + if (vboxUsbDdiStateRetainIfStarted(pDevExt)) + return vboxUsbRtDispatch(pDevExt, pIrp); + return VBoxDrvToolIoComplete(pIrp, STATUS_INVALID_DEVICE_STATE, 0); +} + +static NTSTATUS vboxUsbDispatchCleanup(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + RT_NOREF1(pDeviceObject); + return VBoxDrvToolIoComplete(pIrp, STATUS_SUCCESS, 0); +} + +static NTSTATUS vboxUsbDevAccessDeviedDispatchStub(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + if (!vboxUsbDdiStateRetainIfNotRemoved(pDevExt)) + { + VBoxDrvToolIoComplete(pIrp, STATUS_DELETE_PENDING, 0); + return STATUS_DELETE_PENDING; + } + + NTSTATUS Status = VBoxDrvToolIoComplete(pIrp, STATUS_ACCESS_DENIED, 0); + + vboxUsbDdiStateRelease(pDevExt); + + return Status; +} + +static NTSTATUS vboxUsbDispatchSystemControl(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + if (!vboxUsbDdiStateRetainIfNotRemoved(pDevExt)) + { + VBoxDrvToolIoComplete(pIrp, STATUS_DELETE_PENDING, 0); + return STATUS_DELETE_PENDING; + } + + IoSkipCurrentIrpStackLocation(pIrp); + + NTSTATUS Status = IoCallDriver(pDevExt->pLowerDO, pIrp); + + vboxUsbDdiStateRelease(pDevExt); + + return Status; +} + +static NTSTATUS vboxUsbDispatchRead(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ +#ifdef DEBUG_misha + AssertFailed(); +#endif + return vboxUsbDevAccessDeviedDispatchStub(pDeviceObject, pIrp); +} + +static NTSTATUS vboxUsbDispatchWrite(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ +#ifdef DEBUG_misha + AssertFailed(); +#endif + return vboxUsbDevAccessDeviedDispatchStub(pDeviceObject, pIrp); +} + +RT_C_DECLS_BEGIN + +NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath); + +RT_C_DECLS_END + +NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath) +{ + LogRel(("VBoxUsb::DriverEntry. Built Date (%s) Time (%s)\n", __DATE__, __TIME__)); + + NTSTATUS Status = vboxUsbRtGlobalsInit(); + Assert(Status == STATUS_SUCCESS); + if (Status == STATUS_SUCCESS) + { + Status = VBoxDrvToolStrCopy(&g_VBoxUsbGlobals.RegPath, pRegistryPath); + Assert(Status == STATUS_SUCCESS); + if (Status == STATUS_SUCCESS) + { + g_VBoxUsbGlobals.pDrvObj = pDriverObject; + + pDriverObject->DriverExtension->AddDevice = vboxUsbDdiAddDevice; + + pDriverObject->DriverUnload = vboxUsbDdiUnload; + + pDriverObject->MajorFunction[IRP_MJ_CREATE] = vboxUsbDispatchCreate; + pDriverObject->MajorFunction[IRP_MJ_CLOSE] = vboxUsbDispatchClose; + pDriverObject->MajorFunction[IRP_MJ_READ] = vboxUsbDispatchRead; + pDriverObject->MajorFunction[IRP_MJ_WRITE] = vboxUsbDispatchWrite; + pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = vboxUsbDispatchDeviceControl; + pDriverObject->MajorFunction[IRP_MJ_CLEANUP] = vboxUsbDispatchCleanup; + pDriverObject->MajorFunction[IRP_MJ_POWER] = vboxUsbDispatchPower; + pDriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = vboxUsbDispatchSystemControl; + pDriverObject->MajorFunction[IRP_MJ_PNP] = vboxUsbDispatchPnP; + + return STATUS_SUCCESS; + } + vboxUsbRtGlobalsTerm(); + } + + LogRel(("VBoxUsb::DriverEntry. failed with Status (0x%x)\n", Status)); + + return Status; +} + +#ifdef VBOX_STRICT +DECLHIDDEN(VOID) vboxUsbPnPStateGbgChange(ENMVBOXUSB_PNPSTATE enmOldState, ENMVBOXUSB_PNPSTATE enmNewState) +{ + /* *ensure the state change is valid */ + switch (enmNewState) + { + case ENMVBOXUSB_PNPSTATE_STARTED: + Assert( enmOldState == ENMVBOXUSB_PNPSTATE_START_PENDING + || enmOldState == ENMVBOXUSB_PNPSTATE_REMOVE_PENDING + || enmOldState == ENMVBOXUSB_PNPSTATE_STOPPED + || enmOldState == ENMVBOXUSB_PNPSTATE_STOP_PENDING); + break; + case ENMVBOXUSB_PNPSTATE_STOP_PENDING: + Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STARTED); + break; + case ENMVBOXUSB_PNPSTATE_STOPPED: + Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STOP_PENDING); + break; + case ENMVBOXUSB_PNPSTATE_SURPRISE_REMOVED: + Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STARTED); + break; + case ENMVBOXUSB_PNPSTATE_REMOVE_PENDING: + Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STARTED); + break; + case ENMVBOXUSB_PNPSTATE_REMOVED: + Assert( enmOldState == ENMVBOXUSB_PNPSTATE_REMOVE_PENDING + || enmOldState == ENMVBOXUSB_PNPSTATE_SURPRISE_REMOVED); + break; + default: + AssertFailed(); + break; + } + +} +#endif diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.h b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.h new file mode 100644 index 00000000..231218c9 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.h @@ -0,0 +1,208 @@ +/* $Id: VBoxUsbDev.h $ */ +/** @file + * VBoxUsbDev.h - USB device. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbDev_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbDev_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "VBoxUsbCmn.h" +#include <VBox/cdefs.h> +#include <iprt/assert.h> + +typedef struct VBOXUSB_GLOBALS +{ + PDRIVER_OBJECT pDrvObj; + UNICODE_STRING RegPath; + VBOXUSBRT_IDC RtIdc; +} VBOXUSB_GLOBALS, *PVBOXUSB_GLOBALS; + +extern VBOXUSB_GLOBALS g_VBoxUsbGlobals; + +/* pnp state decls */ +typedef enum +{ + ENMVBOXUSB_PNPSTATE_UNKNOWN = 0, + ENMVBOXUSB_PNPSTATE_START_PENDING, + ENMVBOXUSB_PNPSTATE_STARTED, + ENMVBOXUSB_PNPSTATE_STOP_PENDING, + ENMVBOXUSB_PNPSTATE_STOPPED, + ENMVBOXUSB_PNPSTATE_SURPRISE_REMOVED, + ENMVBOXUSB_PNPSTATE_REMOVE_PENDING, + ENMVBOXUSB_PNPSTATE_REMOVED, + ENMVBOXUSB_PNPSTATE_FORSEDWORD = 0x8fffffff +} ENMVBOXUSB_PNPSTATE; +AssertCompile(sizeof (ENMVBOXUSB_PNPSTATE) == sizeof (uint32_t)); + +#ifdef VBOX_STRICT +DECLHIDDEN(VOID) vboxUsbPnPStateGbgChange(ENMVBOXUSB_PNPSTATE enmOld, ENMVBOXUSB_PNPSTATE enmNew); +# define VBOXUSB_PNP_GBG_STATE_CHANGE(_old, _new) vboxUsbPnPStateGbgChange((_old), (_new)) +#else +# define VBOXUSB_PNP_GBG_STATE_CHANGE(_old, _new) do { } while (0) +#endif + + +typedef struct VBOXUSB_PNPSTATE +{ + /* Current state */ + volatile ENMVBOXUSB_PNPSTATE Curr; + /* Previous state, used to restore state info on cancell stop device */ + ENMVBOXUSB_PNPSTATE Prev; +} VBOXUSB_PNPSTATE, *PVBOXUSB_PNPSTATE; + +typedef struct VBOXUSBDEV_DDISTATE +{ + /* Lock */ + KSPIN_LOCK Lock; + VBOXDRVTOOL_REF Ref; + VBOXUSB_PNPSTATE PnPState; + VBOXUSB_PWRSTATE PwrState; + /* current dev caps */ + DEVICE_CAPABILITIES DevCaps; +} VBOXUSBDEV_DDISTATE, *PVBOXUSBDEV_DDISTATE; + +typedef struct VBOXUSBDEV_EXT +{ + PDEVICE_OBJECT pFDO; + PDEVICE_OBJECT pPDO; + PDEVICE_OBJECT pLowerDO; + + VBOXUSBDEV_DDISTATE DdiState; + + uint32_t cHandles; + + VBOXUSB_RT Rt; + +} VBOXUSBDEV_EXT, *PVBOXUSBDEV_EXT; + +/* pnp state api */ +DECLINLINE(ENMVBOXUSB_PNPSTATE) vboxUsbPnPStateGet(PVBOXUSBDEV_EXT pDevExt) +{ + return (ENMVBOXUSB_PNPSTATE)ASMAtomicUoReadU32((volatile uint32_t*)&pDevExt->DdiState.PnPState.Curr); +} + +DECLINLINE(ENMVBOXUSB_PNPSTATE) vboxUsbPnPStateSet(PVBOXUSBDEV_EXT pDevExt, ENMVBOXUSB_PNPSTATE enmState) +{ + KIRQL Irql; + ENMVBOXUSB_PNPSTATE enmOldState; + KeAcquireSpinLock(&pDevExt->DdiState.Lock, &Irql); + pDevExt->DdiState.PnPState.Prev = (ENMVBOXUSB_PNPSTATE)ASMAtomicUoReadU32((volatile uint32_t*)&pDevExt->DdiState.PnPState.Curr); + ASMAtomicWriteU32((volatile uint32_t*)&pDevExt->DdiState.PnPState.Curr, (uint32_t)enmState); + pDevExt->DdiState.PnPState.Curr = enmState; + enmOldState = pDevExt->DdiState.PnPState.Prev; + KeReleaseSpinLock(&pDevExt->DdiState.Lock, Irql); + VBOXUSB_PNP_GBG_STATE_CHANGE(enmOldState, enmState); + return enmState; +} + +DECLINLINE(ENMVBOXUSB_PNPSTATE) vboxUsbPnPStateRestore(PVBOXUSBDEV_EXT pDevExt) +{ + ENMVBOXUSB_PNPSTATE enmNewState, enmOldState; + KIRQL Irql; + KeAcquireSpinLock(&pDevExt->DdiState.Lock, &Irql); + enmOldState = pDevExt->DdiState.PnPState.Curr; + enmNewState = pDevExt->DdiState.PnPState.Prev; + ASMAtomicWriteU32((volatile uint32_t*)&pDevExt->DdiState.PnPState.Curr, (uint32_t)pDevExt->DdiState.PnPState.Prev); + KeReleaseSpinLock(&pDevExt->DdiState.Lock, Irql); + VBOXUSB_PNP_GBG_STATE_CHANGE(enmOldState, enmNewState); + Assert(enmNewState == ENMVBOXUSB_PNPSTATE_STARTED); + Assert(enmOldState == ENMVBOXUSB_PNPSTATE_STOP_PENDING + || enmOldState == ENMVBOXUSB_PNPSTATE_REMOVE_PENDING); + return enmNewState; +} + +DECLINLINE(VOID) vboxUsbPnPStateInit(PVBOXUSBDEV_EXT pDevExt) +{ + pDevExt->DdiState.PnPState.Curr = pDevExt->DdiState.PnPState.Prev = ENMVBOXUSB_PNPSTATE_START_PENDING; +} + +DECLINLINE(VOID) vboxUsbDdiStateInit(PVBOXUSBDEV_EXT pDevExt) +{ + KeInitializeSpinLock(&pDevExt->DdiState.Lock); + VBoxDrvToolRefInit(&pDevExt->DdiState.Ref); + vboxUsbPwrStateInit(pDevExt); + vboxUsbPnPStateInit(pDevExt); +} + +DECLINLINE(bool) vboxUsbDdiStateRetainIfStarted(PVBOXUSBDEV_EXT pDevExt) +{ + KIRQL oldIrql; + bool bRetained = true; + KeAcquireSpinLock(&pDevExt->DdiState.Lock, &oldIrql); + if (vboxUsbPnPStateGet(pDevExt) == ENMVBOXUSB_PNPSTATE_STARTED) + { + VBoxDrvToolRefRetain(&pDevExt->DdiState.Ref); + } + else + { + bRetained = false; + } + KeReleaseSpinLock(&pDevExt->DdiState.Lock, oldIrql); + return bRetained; +} + +/* if device is removed - does nothing and returns zero, + * otherwise increments a ref counter and returns the current pnp state + * NOTE: never returns ENMVBOXUSB_PNPSTATE_REMOVED + * */ +DECLINLINE(ENMVBOXUSB_PNPSTATE) vboxUsbDdiStateRetainIfNotRemoved(PVBOXUSBDEV_EXT pDevExt) +{ + KIRQL oldIrql; + ENMVBOXUSB_PNPSTATE enmState; + KeAcquireSpinLock(&pDevExt->DdiState.Lock, &oldIrql); + enmState = vboxUsbPnPStateGet(pDevExt); + if (enmState != ENMVBOXUSB_PNPSTATE_REMOVED) + { + VBoxDrvToolRefRetain(&pDevExt->DdiState.Ref); + } + KeReleaseSpinLock(&pDevExt->DdiState.Lock, oldIrql); + return enmState != ENMVBOXUSB_PNPSTATE_REMOVED ? enmState : (ENMVBOXUSB_PNPSTATE)0; +} + +DECLINLINE(uint32_t) vboxUsbDdiStateRetain(PVBOXUSBDEV_EXT pDevExt) +{ + return VBoxDrvToolRefRetain(&pDevExt->DdiState.Ref); +} + +DECLINLINE(uint32_t) vboxUsbDdiStateRelease(PVBOXUSBDEV_EXT pDevExt) +{ + return VBoxDrvToolRefRelease(&pDevExt->DdiState.Ref); +} + +DECLINLINE(VOID) vboxUsbDdiStateReleaseAndWaitCompleted(PVBOXUSBDEV_EXT pDevExt) +{ + VBoxDrvToolRefRelease(&pDevExt->DdiState.Ref); + VBoxDrvToolRefWaitEqual(&pDevExt->DdiState.Ref, 1); +} + +DECLINLINE(VOID) vboxUsbDdiStateReleaseAndWaitRemoved(PVBOXUSBDEV_EXT pDevExt) +{ + VBoxDrvToolRefRelease(&pDevExt->DdiState.Ref); + VBoxDrvToolRefWaitEqual(&pDevExt->DdiState.Ref, 0); +} + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbDev_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.rc b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.rc new file mode 100644 index 00000000..1db5a5d8 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbDev.rc @@ -0,0 +1,60 @@ +/* $Id: VBoxUsbDev.rc $ */ +/** @file + * VBoxUSB - Resource file containing version info and icon. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#include <windows.h> +#include <VBox/version.h> + +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VBOX_RC_FILE_VERSION + PRODUCTVERSION VBOX_RC_FILE_VERSION + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK + FILEFLAGS VBOX_RC_FILE_FLAGS + FILEOS VBOX_RC_FILE_OS + FILETYPE VBOX_RC_TYPE_DRV + FILESUBTYPE VFT2_DRV_SYSTEM +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" // Lang=US English, CharSet=Unicode + BEGIN + VALUE "FileDescription", "VirtualBox USB Driver\0" + VALUE "InternalName", "VBoxUSB\0" + VALUE "OriginalFilename", "VBoxUSB.sys\0" + VALUE "CompanyName", VBOX_RC_COMPANY_NAME + VALUE "FileVersion", VBOX_RC_FILE_VERSION_STR + VALUE "LegalCopyright", VBOX_RC_LEGAL_COPYRIGHT + VALUE "ProductName", VBOX_RC_PRODUCT_NAME_STR + VALUE "ProductVersion", VBOX_RC_PRODUCT_VERSION_STR + VBOX_RC_MORE_STRINGS + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.cpp b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.cpp new file mode 100644 index 00000000..a4c896d0 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.cpp @@ -0,0 +1,264 @@ +/* $Id: VBoxUsbPnP.cpp $ */ +/** @file + * USB PnP Handling + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#include "VBoxUsbCmn.h" + +static NTSTATUS vboxUsbPnPMnStartDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + IoCopyCurrentIrpStackLocationToNext(pIrp); + NTSTATUS Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); + Assert(NT_SUCCESS(Status) || Status == STATUS_NOT_SUPPORTED); + if (NT_SUCCESS(Status)) + { + Status = vboxUsbRtStart(pDevExt); + Assert(Status == STATUS_SUCCESS); + if (NT_SUCCESS(Status)) + { + vboxUsbPnPStateSet(pDevExt, ENMVBOXUSB_PNPSTATE_STARTED); + } + } + + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbPnPMnQueryStopDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + vboxUsbPnPStateSet(pDevExt, ENMVBOXUSB_PNPSTATE_STOP_PENDING); + + vboxUsbDdiStateReleaseAndWaitCompleted(pDevExt); + + pIrp->IoStatus.Status = STATUS_SUCCESS; + pIrp->IoStatus.Information = 0; + IoSkipCurrentIrpStackLocation(pIrp); + return IoCallDriver(pDevExt->pLowerDO, pIrp); +} + +static NTSTATUS vboxUsbPnPMnStopDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + vboxUsbPnPStateSet(pDevExt, ENMVBOXUSB_PNPSTATE_STOPPED); + + vboxUsbRtClear(pDevExt); + + NTSTATUS Status = VBoxUsbToolDevUnconfigure(pDevExt->pLowerDO); + Assert(NT_SUCCESS(Status)); + + pIrp->IoStatus.Status = Status; + pIrp->IoStatus.Information = 0; + IoSkipCurrentIrpStackLocation(pIrp); + Status = IoCallDriver(pDevExt->pLowerDO, pIrp); + + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbPnPMnCancelStopDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + ENMVBOXUSB_PNPSTATE enmState = vboxUsbPnPStateGet(pDevExt); + NTSTATUS Status = STATUS_SUCCESS; + + IoCopyCurrentIrpStackLocationToNext(pIrp); + Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); + if (NT_SUCCESS(Status) && enmState == ENMVBOXUSB_PNPSTATE_STOP_PENDING) + { + vboxUsbPnPStateRestore(pDevExt); + } + + Status = STATUS_SUCCESS; + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + + return Status; +} + +static NTSTATUS vboxUsbPnPMnQueryRemoveDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + vboxUsbPnPStateSet(pDevExt, ENMVBOXUSB_PNPSTATE_REMOVE_PENDING); + + vboxUsbDdiStateReleaseAndWaitCompleted(pDevExt); + + pIrp->IoStatus.Status = STATUS_SUCCESS; + pIrp->IoStatus.Information = 0; + IoSkipCurrentIrpStackLocation(pIrp); + return IoCallDriver(pDevExt->pLowerDO, pIrp); +} + +static NTSTATUS vboxUsbPnPRmDev(PVBOXUSBDEV_EXT pDevExt) +{ + NTSTATUS Status = vboxUsbRtRm(pDevExt); + Assert(Status == STATUS_SUCCESS); + + return Status; +} + +static NTSTATUS vboxUsbPnPMnRemoveDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + ENMVBOXUSB_PNPSTATE enmState = vboxUsbPnPStateGet(pDevExt); + NTSTATUS Status = STATUS_SUCCESS; + if (enmState != ENMVBOXUSB_PNPSTATE_SURPRISE_REMOVED) + { + Status = vboxUsbPnPRmDev(pDevExt); + Assert(Status == STATUS_SUCCESS); + } + + vboxUsbPnPStateSet(pDevExt, ENMVBOXUSB_PNPSTATE_REMOVED); + + vboxUsbDdiStateRelease(pDevExt); + + vboxUsbDdiStateReleaseAndWaitRemoved(pDevExt); + + vboxUsbRtClear(pDevExt); + + pIrp->IoStatus.Status = STATUS_SUCCESS; + pIrp->IoStatus.Information = 0; + IoSkipCurrentIrpStackLocation(pIrp); + Status = IoCallDriver(pDevExt->pLowerDO, pIrp); + + IoDetachDevice(pDevExt->pLowerDO); + IoDeleteDevice(pDevExt->pFDO); + + return Status; +} + +static NTSTATUS vboxUsbPnPMnCancelRemoveDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + ENMVBOXUSB_PNPSTATE enmState = vboxUsbPnPStateGet(pDevExt); + NTSTATUS Status = STATUS_SUCCESS; + IoCopyCurrentIrpStackLocationToNext(pIrp); + + Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); + + if (NT_SUCCESS(Status) && + enmState == ENMVBOXUSB_PNPSTATE_REMOVE_PENDING) + { + vboxUsbPnPStateRestore(pDevExt); + } + + Status = STATUS_SUCCESS; + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + + return Status; +} + +static NTSTATUS vboxUsbPnPMnSurpriseRemoval(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + vboxUsbPnPStateSet(pDevExt, ENMVBOXUSB_PNPSTATE_SURPRISE_REMOVED); + + NTSTATUS Status = vboxUsbPnPRmDev(pDevExt); + Assert(Status == STATUS_SUCCESS); + + pIrp->IoStatus.Status = STATUS_SUCCESS; + pIrp->IoStatus.Information = 0; + IoSkipCurrentIrpStackLocation(pIrp); + Status = IoCallDriver(pDevExt->pLowerDO, pIrp); + + vboxUsbDdiStateRelease(pDevExt); + + return Status; +} + +static NTSTATUS vboxUsbPnPMnQueryCapabilities(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PDEVICE_CAPABILITIES pDevCaps = pSl->Parameters.DeviceCapabilities.Capabilities; + + if (pDevCaps->Version < 1 || pDevCaps->Size < sizeof (*pDevCaps)) + { + AssertFailed(); + /** @todo return more appropriate status ?? */ + return STATUS_UNSUCCESSFUL; + } + + pDevCaps->SurpriseRemovalOK = TRUE; + pIrp->IoStatus.Status = STATUS_SUCCESS; + + IoCopyCurrentIrpStackLocationToNext(pIrp); + NTSTATUS Status = VBoxDrvToolIoPostSync(pDevExt->pLowerDO, pIrp); + Assert(NT_SUCCESS(Status)); + if (NT_SUCCESS(Status)) + { + pDevCaps->SurpriseRemovalOK = 1; + pDevExt->DdiState.DevCaps = *pDevCaps; + } + + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + + return Status; +} + +static NTSTATUS vboxUsbPnPMnDefault(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + NTSTATUS Status; + IoSkipCurrentIrpStackLocation(pIrp); + Status = IoCallDriver(pDevExt->pLowerDO, pIrp); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +DECLHIDDEN(NTSTATUS) vboxUsbDispatchPnP(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + if (!vboxUsbDdiStateRetainIfNotRemoved(pDevExt)) + return VBoxDrvToolIoComplete(pIrp, STATUS_DELETE_PENDING, 0); + + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + switch (pSl->MinorFunction) + { + case IRP_MN_START_DEVICE: + return vboxUsbPnPMnStartDevice(pDevExt, pIrp); + + case IRP_MN_QUERY_STOP_DEVICE: + return vboxUsbPnPMnQueryStopDevice(pDevExt, pIrp); + + case IRP_MN_STOP_DEVICE: + return vboxUsbPnPMnStopDevice(pDevExt, pIrp); + + case IRP_MN_CANCEL_STOP_DEVICE: + return vboxUsbPnPMnCancelStopDevice(pDevExt, pIrp); + + case IRP_MN_QUERY_REMOVE_DEVICE: + return vboxUsbPnPMnQueryRemoveDevice(pDevExt, pIrp); + + case IRP_MN_REMOVE_DEVICE: + return vboxUsbPnPMnRemoveDevice(pDevExt, pIrp); + + case IRP_MN_CANCEL_REMOVE_DEVICE: + return vboxUsbPnPMnCancelRemoveDevice(pDevExt, pIrp); + + case IRP_MN_SURPRISE_REMOVAL: + return vboxUsbPnPMnSurpriseRemoval(pDevExt, pIrp); + + case IRP_MN_QUERY_CAPABILITIES: + return vboxUsbPnPMnQueryCapabilities(pDevExt, pIrp); + + default: + return vboxUsbPnPMnDefault(pDevExt, pIrp); + } +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.h b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.h new file mode 100644 index 00000000..5d3ab170 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPnP.h @@ -0,0 +1,36 @@ +/* $Id: VBoxUsbPnP.h $ */ +/** @file + * USB PnP Handling + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbPnP_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbPnP_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif +#include "VBoxUsbCmn.h" + +DECLHIDDEN(NTSTATUS) vboxUsbDispatchPnP(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp); + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbPnP_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.cpp b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.cpp new file mode 100644 index 00000000..d75a9873 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.cpp @@ -0,0 +1,417 @@ +/* $Id: VBoxUsbPwr.cpp $ */ +/** @file + * USB Power state Handling + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#include "VBoxUsbCmn.h" + +#include <iprt/assert.h> + +DECLHIDDEN(VOID) vboxUsbPwrStateInit(PVBOXUSBDEV_EXT pDevExt) +{ + POWER_STATE PowerState; + PowerState.SystemState = PowerSystemWorking; + PowerState.DeviceState = PowerDeviceD0; + PoSetPowerState(pDevExt->pFDO, DevicePowerState, PowerState); + pDevExt->DdiState.PwrState.PowerState = PowerState; + pDevExt->DdiState.PwrState.PowerDownLevel = PowerDeviceUnspecified; +} + +static NTSTATUS vboxUsbPwrMnDefault(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + NTSTATUS Status; + PoStartNextPowerIrp(pIrp); + IoSkipCurrentIrpStackLocation(pIrp); + Status = PoCallDriver(pDevExt->pLowerDO, pIrp); + Assert(NT_SUCCESS(Status) || Status == STATUS_NOT_SUPPORTED); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbPwrMnPowerSequence(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + AssertFailed(); + return vboxUsbPwrMnDefault(pDevExt, pIrp); +} + +typedef struct VBOXUSB_PWRDEV_CTX +{ + PVBOXUSBDEV_EXT pDevExt; + PIRP pIrp; +} VBOXUSB_PWRDEV_CTX, *PVBOXUSB_PWRDEV_CTX; + +static VOID vboxUsbPwrIoDeviceCompletion(IN PDEVICE_OBJECT pDeviceObject, + IN UCHAR MinorFunction, + IN POWER_STATE PowerState, + IN PVOID pvContext, + IN PIO_STATUS_BLOCK pIoStatus) +{ + RT_NOREF3(pDeviceObject, MinorFunction, PowerState); + PVBOXUSB_PWRDEV_CTX pDevCtx = (PVBOXUSB_PWRDEV_CTX)pvContext; + PVBOXUSBDEV_EXT pDevExt = pDevCtx->pDevExt; + PIRP pIrp = pDevCtx->pIrp; + pIrp->IoStatus.Status = pIoStatus->Status; + pIrp->IoStatus.Information = 0; + + PoStartNextPowerIrp(pIrp); + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + vboxUsbDdiStateRelease(pDevExt); + + vboxUsbMemFree(pDevCtx); +} + +static NTSTATUS vboxUsbPwrIoRequestDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + POWER_STATE PwrState; + PwrState.SystemState = pSl->Parameters.Power.State.SystemState; + PwrState.DeviceState = pDevExt->DdiState.DevCaps.DeviceState[PwrState.SystemState]; + + NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES; + PVBOXUSB_PWRDEV_CTX pDevCtx = (PVBOXUSB_PWRDEV_CTX)vboxUsbMemAlloc(sizeof (*pDevCtx)); + Assert(pDevCtx); + if (pDevCtx) + { + pDevCtx->pDevExt = pDevExt; + pDevCtx->pIrp = pIrp; + + Status = PoRequestPowerIrp(pDevExt->pPDO, pSl->MinorFunction, PwrState, + vboxUsbPwrIoDeviceCompletion, pDevCtx, NULL); + Assert(NT_SUCCESS(Status)); + if (NT_SUCCESS(Status)) + return STATUS_MORE_PROCESSING_REQUIRED; + + vboxUsbMemFree(pDevCtx); + } + + PoStartNextPowerIrp(pIrp); + pIrp->IoStatus.Status = Status; + pIrp->IoStatus.Information = 0; + vboxUsbDdiStateRelease(pDevExt); + + /* the "real" Status is stored in pIrp->IoStatus.Status, + * return success here to complete the Io */ + return STATUS_SUCCESS; +} + +static NTSTATUS vboxUsbPwrIoPostSysCompletion(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp, IN PVOID pvContext) +{ + RT_NOREF1(pDevObj); + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pvContext; + NTSTATUS Status = pIrp->IoStatus.Status; + Assert(Status == STATUS_SUCCESS); + if (NT_SUCCESS(Status)) + { + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + switch (pSl->MinorFunction) + { + case IRP_MN_SET_POWER: + pDevExt->DdiState.PwrState.PowerState.SystemState = pSl->Parameters.Power.State.SystemState; + break; + + default: + break; + } + + return vboxUsbPwrIoRequestDev(pDevExt, pIrp); + } + + PoStartNextPowerIrp(pIrp); + vboxUsbDdiStateRelease(pDevExt); + return STATUS_SUCCESS; +} + +static NTSTATUS vboxUsbPwrIoPostSys(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + IoMarkIrpPending(pIrp); + IoCopyCurrentIrpStackLocationToNext(pIrp); + IoSetCompletionRoutine(pIrp, vboxUsbPwrIoPostSysCompletion, pDevExt, TRUE, TRUE, TRUE); + NTSTATUS Status = PoCallDriver(pDevExt->pLowerDO, pIrp); + Assert(NT_SUCCESS(Status)); NOREF(Status); + return STATUS_PENDING; +} + +static NTSTATUS vboxUsbPwrQueryPowerSys(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + /*PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + SYSTEM_POWER_STATE enmSysPState = pSl->Parameters.Power.State.SystemState;*/ + + return vboxUsbPwrIoPostSys(pDevExt, pIrp); +} + +static NTSTATUS vboxUsbPwrIoPostDevCompletion(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp, IN PVOID pvContext) +{ + RT_NOREF1(pDevObj); + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pvContext; + + if (pIrp->PendingReturned) + IoMarkIrpPending(pIrp); + + NTSTATUS Status = pIrp->IoStatus.Status; + Assert(Status == STATUS_SUCCESS); + if (NT_SUCCESS(Status)) + { + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + switch (pSl->MinorFunction) + { + case IRP_MN_SET_POWER: + pDevExt->DdiState.PwrState.PowerState.DeviceState = pSl->Parameters.Power.State.DeviceState; + PoSetPowerState(pDevExt->pFDO, DevicePowerState, pSl->Parameters.Power.State); + break; + + default: + break; + } + } + + PoStartNextPowerIrp(pIrp); + vboxUsbDdiStateRelease(pDevExt); + return STATUS_SUCCESS; +} + +static NTSTATUS vboxUsbPwrIoPostDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + IoMarkIrpPending(pIrp); + IoCopyCurrentIrpStackLocationToNext(pIrp); + IoSetCompletionRoutine(pIrp, vboxUsbPwrIoPostDevCompletion, pDevExt, TRUE, TRUE, TRUE); + NTSTATUS Status = PoCallDriver(pDevExt->pLowerDO, pIrp); + Assert(NT_SUCCESS(Status)); RT_NOREF_PV(Status); + return STATUS_PENDING; +} + +typedef struct VBOXUSB_IOASYNC_CTX +{ + PIO_WORKITEM pWrkItem; + PIRP pIrp; +} VBOXUSB_IOASYNC_CTX, *PVBOXUSB_IOASYNC_CTX; + +static VOID vboxUsbPwrIoWaitCompletionAndPostAsyncWorker(IN PDEVICE_OBJECT pDeviceObject, IN PVOID pvContext) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + PVBOXUSB_IOASYNC_CTX pCtx = (PVBOXUSB_IOASYNC_CTX)pvContext; + PIRP pIrp = pCtx->pIrp; + + vboxUsbPwrIoPostDev(pDevExt, pIrp); + + IoFreeWorkItem(pCtx->pWrkItem); + vboxUsbMemFree(pCtx); +} + +static NTSTATUS vboxUsbPwrIoWaitCompletionAndPostAsync(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES; + PVBOXUSB_IOASYNC_CTX pCtx = (PVBOXUSB_IOASYNC_CTX)vboxUsbMemAlloc(sizeof (*pCtx)); + Assert(pCtx); + if (pCtx) + { + PIO_WORKITEM pWrkItem = IoAllocateWorkItem(pDevExt->pFDO); + Assert(pWrkItem); + if (pWrkItem) + { + pCtx->pWrkItem = pWrkItem; + pCtx->pIrp = pIrp; + IoMarkIrpPending(pIrp); + IoQueueWorkItem(pWrkItem, vboxUsbPwrIoWaitCompletionAndPostAsyncWorker, DelayedWorkQueue, pCtx); + return STATUS_PENDING; + } + vboxUsbMemFree(pCtx); + } + return Status; +} + +static NTSTATUS vboxUsbPwrQueryPowerDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + DEVICE_POWER_STATE enmDevPState = pSl->Parameters.Power.State.DeviceState; + NTSTATUS Status = STATUS_SUCCESS; + + if (enmDevPState >= pDevExt->DdiState.PwrState.PowerState.DeviceState) + { + Status = vboxUsbPwrIoWaitCompletionAndPostAsync(pDevExt, pIrp); + Assert(NT_SUCCESS(Status)); + if (NT_SUCCESS(Status)) + return Status; + } + + pIrp->IoStatus.Status = Status; + pIrp->IoStatus.Information = 0; + + PoStartNextPowerIrp(pIrp); + + if (NT_SUCCESS(Status)) + { + IoSkipCurrentIrpStackLocation(pIrp); + Status = PoCallDriver(pDevExt->pLowerDO, pIrp); + } + else + { + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + } + + vboxUsbDdiStateRelease(pDevExt); + + return Status; +} + +static NTSTATUS vboxUsbPwrMnQueryPower(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + switch (pSl->Parameters.Power.Type) + { + case SystemPowerState: + return vboxUsbPwrQueryPowerSys(pDevExt, pIrp); + + case DevicePowerState: + return vboxUsbPwrQueryPowerDev(pDevExt, pIrp); + + default: + AssertFailed(); + return vboxUsbPwrMnDefault(pDevExt, pIrp); + + } +} + +static NTSTATUS vboxUsbPwrSetPowerSys(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + /*PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + SYSTEM_POWER_STATE enmSysPState = pSl->Parameters.Power.State.SystemState;*/ + + return vboxUsbPwrIoPostSys(pDevExt, pIrp); +} + +static NTSTATUS vboxUsbPwrSetPowerDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + DEVICE_POWER_STATE enmDevPState = pSl->Parameters.Power.State.DeviceState; + DEVICE_POWER_STATE enmCurDevPState = pDevExt->DdiState.PwrState.PowerState.DeviceState; + NTSTATUS Status = STATUS_SUCCESS; + + if (enmDevPState > enmCurDevPState && enmCurDevPState == PowerDeviceD0) + { + Status = vboxUsbPwrIoWaitCompletionAndPostAsync(pDevExt, pIrp); + Assert(NT_SUCCESS(Status)); + if (NT_SUCCESS(Status)) + return Status; + } + + PoStartNextPowerIrp(pIrp); + + if (NT_SUCCESS(Status)) + { + IoCopyCurrentIrpStackLocationToNext(pIrp); + IoSetCompletionRoutine(pIrp, vboxUsbPwrIoPostDevCompletion, pDevExt, TRUE, TRUE, TRUE); + Status = PoCallDriver(pDevExt->pLowerDO, pIrp); + } + else + { + pIrp->IoStatus.Status = Status; + pIrp->IoStatus.Information = 0; + + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + vboxUsbDdiStateRelease(pDevExt); + } + + return Status; +} + + +static NTSTATUS vboxUsbPwrMnSetPower(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + switch (pSl->Parameters.Power.Type) + { + case SystemPowerState: + return vboxUsbPwrSetPowerSys(pDevExt, pIrp); + + case DevicePowerState: + return vboxUsbPwrSetPowerDev(pDevExt, pIrp); + + default: + AssertFailed(); + return vboxUsbPwrMnDefault(pDevExt, pIrp); + } +} + +static NTSTATUS vboxUsbPwrMnWaitWake(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + AssertFailed(); + return vboxUsbPwrMnDefault(pDevExt, pIrp); +} + + +static NTSTATUS vboxUsbPwrDispatch(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + + switch (pSl->MinorFunction) + { + case IRP_MN_POWER_SEQUENCE: + return vboxUsbPwrMnPowerSequence(pDevExt, pIrp); + + case IRP_MN_QUERY_POWER: + return vboxUsbPwrMnQueryPower(pDevExt, pIrp); + + case IRP_MN_SET_POWER: + return vboxUsbPwrMnSetPower(pDevExt, pIrp); + + case IRP_MN_WAIT_WAKE: + return vboxUsbPwrMnWaitWake(pDevExt, pIrp); + + default: +// AssertFailed(); + return vboxUsbPwrMnDefault(pDevExt, pIrp); + } +} + +DECLHIDDEN(NTSTATUS) vboxUsbDispatchPower(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp) +{ + PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension; + ENMVBOXUSB_PNPSTATE enmState = vboxUsbDdiStateRetainIfNotRemoved(pDevExt); + switch (enmState) + { + case ENMVBOXUSB_PNPSTATE_REMOVED: + PoStartNextPowerIrp(pIrp); + + pIrp->IoStatus.Status = STATUS_DELETE_PENDING; + pIrp->IoStatus.Information = 0; + + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + + vboxUsbDdiStateRelease(pDevExt); + + return STATUS_DELETE_PENDING; + + case ENMVBOXUSB_PNPSTATE_START_PENDING: + PoStartNextPowerIrp(pIrp); + IoSkipCurrentIrpStackLocation(pIrp); + + vboxUsbDdiStateRelease(pDevExt); + + return PoCallDriver(pDevExt->pLowerDO, pIrp); + + default: + return vboxUsbPwrDispatch(pDevExt, pIrp); + } +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.h b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.h new file mode 100644 index 00000000..40823c33 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbPwr.h @@ -0,0 +1,41 @@ +/* $Id: VBoxUsbPwr.h $ */ +/** @file + * USB Power state Handling + */ +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbPwr_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbPwr_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +typedef struct VBOXUSB_PWRSTATE +{ + POWER_STATE PowerState; + ULONG PowerDownLevel; +} VBOXUSB_PWRSTATE, *PVBOXUSB_PWRSTATE; + +DECLHIDDEN(VOID) vboxUsbPwrStateInit(PVBOXUSBDEV_EXT pDevExt); +DECLHIDDEN(NTSTATUS) vboxUsbDispatchPower(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp); + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbPwr_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbRt.cpp b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbRt.cpp new file mode 100644 index 00000000..28ecae0a --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbRt.cpp @@ -0,0 +1,1581 @@ +/* $Id: VBoxUsbRt.cpp $ */ +/** @file + * VBox USB R0 runtime + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxUsbCmn.h" +#include "../cmn/VBoxUsbIdc.h" +#include "../cmn/VBoxUsbTool.h" + +#include <VBox/usblib-win.h> +#include <iprt/assert.h> +#include <VBox/log.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +#define _USBD_ /** @todo r=bird: What is this?? */ + +#define USBD_DEFAULT_PIPE_TRANSFER 0x00000008 + +#define VBOXUSB_MAGIC 0xABCF1423 + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef struct VBOXUSB_URB_CONTEXT +{ + PURB pUrb; + PMDL pMdlBuf; + PVBOXUSBDEV_EXT pDevExt; + PVOID pOut; + ULONG ulTransferType; + ULONG ulMagic; +} VBOXUSB_URB_CONTEXT, * PVBOXUSB_URB_CONTEXT; + +typedef struct VBOXUSB_SETUP +{ + uint8_t bmRequestType; + uint8_t bRequest; + uint16_t wValue; + uint16_t wIndex; + uint16_t wLength; +} VBOXUSB_SETUP, *PVBOXUSB_SETUP; + + + +static bool vboxUsbRtCtxSetOwner(PVBOXUSBDEV_EXT pDevExt, PFILE_OBJECT pFObj) +{ + bool fRc = ASMAtomicCmpXchgPtr(&pDevExt->Rt.pOwner, pFObj, NULL); + if (fRc) + LogFunc(("pDevExt (0x%x) Owner(0x%x) acquired\n", pFObj)); + else + LogFunc(("pDevExt (0x%x) Owner(0x%x) FAILED!!\n", pFObj)); + return fRc; +} + +static bool vboxUsbRtCtxReleaseOwner(PVBOXUSBDEV_EXT pDevExt, PFILE_OBJECT pFObj) +{ + bool fRc = ASMAtomicCmpXchgPtr(&pDevExt->Rt.pOwner, NULL, pFObj); + if (fRc) + LogFunc(("pDevExt (0x%x) Owner(0x%x) released\n", pFObj)); + else + LogFunc(("pDevExt (0x%x) Owner(0x%x) release: is NOT an owner\n", pFObj)); + return fRc; +} + +static bool vboxUsbRtCtxIsOwner(PVBOXUSBDEV_EXT pDevExt, PFILE_OBJECT pFObj) +{ + PFILE_OBJECT pOwner = (PFILE_OBJECT)ASMAtomicReadPtr((void *volatile *)(&pDevExt->Rt.pOwner)); + return pOwner == pFObj; +} + +static NTSTATUS vboxUsbRtIdcSubmit(ULONG uCtl, void *pvBuffer) +{ + /* we just reuse the standard usb tooling for simplicity here */ + NTSTATUS Status = VBoxUsbToolIoInternalCtlSendSync(g_VBoxUsbGlobals.RtIdc.pDevice, uCtl, pvBuffer, NULL); + Assert(Status == STATUS_SUCCESS); + return Status; +} + +static NTSTATUS vboxUsbRtIdcInit() +{ + UNICODE_STRING UniName; + RtlInitUnicodeString(&UniName, USBMON_DEVICE_NAME_NT); + NTSTATUS Status = IoGetDeviceObjectPointer(&UniName, FILE_ALL_ACCESS, &g_VBoxUsbGlobals.RtIdc.pFile, &g_VBoxUsbGlobals.RtIdc.pDevice); + if (NT_SUCCESS(Status)) + { + VBOXUSBIDC_VERSION Version; + vboxUsbRtIdcSubmit(VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION, &Version); + if (NT_SUCCESS(Status)) + { + if ( Version.u32Major == VBOXUSBIDC_VERSION_MAJOR +#if VBOXUSBIDC_VERSION_MINOR != 0 + && Version.u32Minor >= VBOXUSBIDC_VERSION_MINOR +#endif + ) + return STATUS_SUCCESS; + AssertFailed(); + } + else + { + AssertFailed(); + } + + /* this will as well dereference the dev obj */ + ObDereferenceObject(g_VBoxUsbGlobals.RtIdc.pFile); + } + else + { + AssertFailed(); + } + + memset(&g_VBoxUsbGlobals.RtIdc, 0, sizeof (g_VBoxUsbGlobals.RtIdc)); + return Status; +} + +static VOID vboxUsbRtIdcTerm() +{ + Assert(g_VBoxUsbGlobals.RtIdc.pFile); + Assert(g_VBoxUsbGlobals.RtIdc.pDevice); + ObDereferenceObject(g_VBoxUsbGlobals.RtIdc.pFile); + memset(&g_VBoxUsbGlobals.RtIdc, 0, sizeof (g_VBoxUsbGlobals.RtIdc)); +} + +static NTSTATUS vboxUsbRtIdcReportDevStart(PDEVICE_OBJECT pPDO, HVBOXUSBIDCDEV *phDev) +{ + VBOXUSBIDC_PROXY_STARTUP Start; + Start.u.pPDO = pPDO; + + *phDev = NULL; + + NTSTATUS Status = vboxUsbRtIdcSubmit(VBOXUSBIDC_INTERNAL_IOCTL_PROXY_STARTUP, &Start); + Assert(Status == STATUS_SUCCESS); + if (!NT_SUCCESS(Status)) + return Status; + + *phDev = Start.u.hDev; + return STATUS_SUCCESS; +} + +static NTSTATUS vboxUsbRtIdcReportDevStop(HVBOXUSBIDCDEV hDev) +{ + VBOXUSBIDC_PROXY_TEARDOWN Stop; + Stop.hDev = hDev; + + NTSTATUS Status = vboxUsbRtIdcSubmit(VBOXUSBIDC_INTERNAL_IOCTL_PROXY_TEARDOWN, &Stop); + Assert(Status == STATUS_SUCCESS); + return Status; +} + + +DECLHIDDEN(NTSTATUS) vboxUsbRtGlobalsInit() +{ + return vboxUsbRtIdcInit(); +} + +DECLHIDDEN(VOID) vboxUsbRtGlobalsTerm() +{ + vboxUsbRtIdcTerm(); +} + + +DECLHIDDEN(NTSTATUS) vboxUsbRtInit(PVBOXUSBDEV_EXT pDevExt) +{ + RtlZeroMemory(&pDevExt->Rt, sizeof (pDevExt->Rt)); + NTSTATUS Status = IoRegisterDeviceInterface(pDevExt->pPDO, &GUID_CLASS_VBOXUSB, + NULL, /* IN PUNICODE_STRING ReferenceString OPTIONAL */ + &pDevExt->Rt.IfName); + Assert(Status == STATUS_SUCCESS); + if (NT_SUCCESS(Status)) + { + Status = vboxUsbRtIdcReportDevStart(pDevExt->pPDO, &pDevExt->Rt.hMonDev); + Assert(Status == STATUS_SUCCESS); + if (NT_SUCCESS(Status)) + { + Assert(pDevExt->Rt.hMonDev); + return STATUS_SUCCESS; + } + + NTSTATUS tmpStatus = IoSetDeviceInterfaceState(&pDevExt->Rt.IfName, FALSE); + Assert(tmpStatus == STATUS_SUCCESS); + if (NT_SUCCESS(tmpStatus)) + { + RtlFreeUnicodeString(&pDevExt->Rt.IfName); + } + } + return Status; +} + +/** + * Free cached USB device/configuration descriptors + * + * @param pDevExt USB DevExt pointer + */ +static void vboxUsbRtFreeCachedDescriptors(PVBOXUSBDEV_EXT pDevExt) +{ + if (pDevExt->Rt.devdescr) + { + vboxUsbMemFree(pDevExt->Rt.devdescr); + pDevExt->Rt.devdescr = NULL; + } + for (ULONG i = 0; i < VBOXUSBRT_MAX_CFGS; ++i) + { + if (pDevExt->Rt.cfgdescr[i]) + { + vboxUsbMemFree(pDevExt->Rt.cfgdescr[i]); + pDevExt->Rt.cfgdescr[i] = NULL; + } + } +} + +/** + * Free per-device interface info + * + * @param pDevExt USB DevExt pointer + * @param fAbortPipes If true, also abort any open pipes + */ +static void vboxUsbRtFreeInterfaces(PVBOXUSBDEV_EXT pDevExt, BOOLEAN fAbortPipes) +{ + unsigned i; + unsigned j; + + /* + * Free old interface info + */ + if (pDevExt->Rt.pVBIfaceInfo) + { + for (i=0;i<pDevExt->Rt.uNumInterfaces;i++) + { + if (pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo) + { + if (fAbortPipes) + { + for (j=0; j<pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->NumberOfPipes; j++) + { + Log(("Aborting Pipe %d handle %x address %x\n", j, + pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->Pipes[j].PipeHandle, + pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->Pipes[j].EndpointAddress)); + VBoxUsbToolPipeClear(pDevExt->pLowerDO, pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->Pipes[j].PipeHandle, FALSE); + } + } + vboxUsbMemFree(pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo); + } + pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo = NULL; + if (pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo) + vboxUsbMemFree(pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo); + pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo = NULL; + } + vboxUsbMemFree(pDevExt->Rt.pVBIfaceInfo); + pDevExt->Rt.pVBIfaceInfo = NULL; + } +} + +DECLHIDDEN(VOID) vboxUsbRtClear(PVBOXUSBDEV_EXT pDevExt) +{ + vboxUsbRtFreeCachedDescriptors(pDevExt); + vboxUsbRtFreeInterfaces(pDevExt, FALSE); +} + +DECLHIDDEN(NTSTATUS) vboxUsbRtRm(PVBOXUSBDEV_EXT pDevExt) +{ + if (!pDevExt->Rt.IfName.Buffer) + return STATUS_SUCCESS; + + NTSTATUS Status = vboxUsbRtIdcReportDevStop(pDevExt->Rt.hMonDev); + Assert(Status == STATUS_SUCCESS); + Status = IoSetDeviceInterfaceState(&pDevExt->Rt.IfName, FALSE); + Assert(Status == STATUS_SUCCESS); + if (NT_SUCCESS(Status)) + { + RtlFreeUnicodeString(&pDevExt->Rt.IfName); + pDevExt->Rt.IfName.Buffer = NULL; + } + return Status; +} + +DECLHIDDEN(NTSTATUS) vboxUsbRtStart(PVBOXUSBDEV_EXT pDevExt) +{ + NTSTATUS Status = IoSetDeviceInterfaceState(&pDevExt->Rt.IfName, TRUE); + Assert(Status == STATUS_SUCCESS); + return Status; +} + +static NTSTATUS vboxUsbRtCacheDescriptors(PVBOXUSBDEV_EXT pDevExt) +{ + NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES; +// uint32_t uTotalLength; +// unsigned i; + + /* Read device descriptor */ + Assert(!pDevExt->Rt.devdescr); + pDevExt->Rt.devdescr = (PUSB_DEVICE_DESCRIPTOR)vboxUsbMemAlloc(sizeof (USB_DEVICE_DESCRIPTOR)); + if (pDevExt->Rt.devdescr) + { + memset(pDevExt->Rt.devdescr, 0, sizeof (USB_DEVICE_DESCRIPTOR)); + Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDevExt->Rt.devdescr, sizeof (USB_DEVICE_DESCRIPTOR), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, RT_INDEFINITE_WAIT); + if (NT_SUCCESS(Status)) + { + Assert(pDevExt->Rt.devdescr->bNumConfigurations > 0); + PUSB_CONFIGURATION_DESCRIPTOR pDr = (PUSB_CONFIGURATION_DESCRIPTOR)vboxUsbMemAlloc(sizeof (USB_CONFIGURATION_DESCRIPTOR)); + Assert(pDr); + if (pDr) + { + UCHAR i = 0; + for (; i < pDevExt->Rt.devdescr->bNumConfigurations; ++i) + { + Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDr, sizeof (USB_CONFIGURATION_DESCRIPTOR), USB_CONFIGURATION_DESCRIPTOR_TYPE, i, 0, RT_INDEFINITE_WAIT); + if (!NT_SUCCESS(Status)) + { + break; + } + + USHORT uTotalLength = pDr->wTotalLength; + pDevExt->Rt.cfgdescr[i] = (PUSB_CONFIGURATION_DESCRIPTOR)vboxUsbMemAlloc(uTotalLength); + if (!pDevExt->Rt.cfgdescr[i]) + { + Status = STATUS_INSUFFICIENT_RESOURCES; + break; + } + + Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDevExt->Rt.cfgdescr[i], uTotalLength, USB_CONFIGURATION_DESCRIPTOR_TYPE, i, 0, RT_INDEFINITE_WAIT); + if (!NT_SUCCESS(Status)) + { + break; + } + } + + vboxUsbMemFree(pDr); + + if (NT_SUCCESS(Status)) + return Status; + + /* recources will be freed in vboxUsbRtFreeCachedDescriptors below */ + } + } + + vboxUsbRtFreeCachedDescriptors(pDevExt); + } + + /* shoud be only on fail here */ + Assert(!NT_SUCCESS(Status)); + return Status; +} + +static NTSTATUS vboxUsbRtDispatchClaimDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + PUSBSUP_CLAIMDEV pDev = (PUSBSUP_CLAIMDEV)pIrp->AssociatedIrp.SystemBuffer; + ULONG cbOut = 0; + NTSTATUS Status = STATUS_SUCCESS; + + do + { + if (!pFObj) + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + + if ( !pDev + || pSl->Parameters.DeviceIoControl.InputBufferLength != sizeof (*pDev) + || pSl->Parameters.DeviceIoControl.OutputBufferLength != sizeof (*pDev)) + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + + if (!vboxUsbRtCtxSetOwner(pDevExt, pFObj)) + { + AssertFailed(); + pDev->fClaimed = false; + cbOut = sizeof (*pDev); + break; + } + + vboxUsbRtFreeCachedDescriptors(pDevExt); + Status = vboxUsbRtCacheDescriptors(pDevExt); + if (NT_SUCCESS(Status)) + { + pDev->fClaimed = true; + cbOut = sizeof (*pDev); + } + } while (0); + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, cbOut); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtDispatchReleaseDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + NTSTATUS Status= STATUS_SUCCESS; + + if (vboxUsbRtCtxIsOwner(pDevExt, pFObj)) + { + vboxUsbRtFreeCachedDescriptors(pDevExt); + bool fRc = vboxUsbRtCtxReleaseOwner(pDevExt, pFObj); + Assert(fRc); NOREF(fRc); + } + else + { + AssertFailed(); + Status = STATUS_ACCESS_DENIED; + } + + VBoxDrvToolIoComplete(pIrp, STATUS_SUCCESS, 0); + vboxUsbDdiStateRelease(pDevExt); + return STATUS_SUCCESS; +} + +static NTSTATUS vboxUsbRtGetDeviceDescription(PVBOXUSBDEV_EXT pDevExt) +{ + NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES; + PUSB_DEVICE_DESCRIPTOR pDr = (PUSB_DEVICE_DESCRIPTOR)vboxUsbMemAllocZ(sizeof (USB_DEVICE_DESCRIPTOR)); + if (pDr) + { + Status = VBoxUsbToolGetDescriptor(pDevExt->pLowerDO, pDr, sizeof(*pDr), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, RT_INDEFINITE_WAIT); + if (NT_SUCCESS(Status)) + { + pDevExt->Rt.idVendor = pDr->idVendor; + pDevExt->Rt.idProduct = pDr->idProduct; + pDevExt->Rt.bcdDevice = pDr->bcdDevice; + pDevExt->Rt.szSerial[0] = 0; + + if (pDr->iSerialNumber +#ifdef DEBUG + || pDr->iProduct || pDr->iManufacturer +#endif + ) + { + int langId; + Status = VBoxUsbToolGetLangID(pDevExt->pLowerDO, &langId, RT_INDEFINITE_WAIT); + if (NT_SUCCESS(Status)) + { + Status = VBoxUsbToolGetStringDescriptor(pDevExt->pLowerDO, pDevExt->Rt.szSerial, sizeof (pDevExt->Rt.szSerial), + pDr->iSerialNumber, langId, RT_INDEFINITE_WAIT); + } + else + { + Status = STATUS_SUCCESS; + } + } + } + vboxUsbMemFree(pDr); + } + + return Status; +} + +static NTSTATUS vboxUsbRtDispatchGetDevice(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PUSBSUP_GETDEV pDev = (PUSBSUP_GETDEV)pIrp->AssociatedIrp.SystemBuffer; + ULONG cbOut = 0; + + /* don't check for owner since this request is allowed for non-owners as well */ + NTSTATUS Status; + if ( pDev + && pSl->Parameters.DeviceIoControl.InputBufferLength == sizeof(*pDev) + && pSl->Parameters.DeviceIoControl.OutputBufferLength == sizeof(*pDev)) + { + /* Even if we don't return it, we need to query the HS flag for later use. */ + Status = VBoxUsbToolGetDeviceSpeed(pDevExt->pLowerDO, &pDevExt->Rt.fIsHighSpeed); + if (NT_SUCCESS(Status)) + { + pDev->hDevice = pDevExt->Rt.hMonDev; + cbOut = sizeof (*pDev); + } + } + else + Status = STATUS_INVALID_PARAMETER; + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, cbOut); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtDispatchUsbReset(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + NTSTATUS rcNt; + if (pFObj) + { + if (vboxUsbRtCtxIsOwner(pDevExt, pFObj)) + { + if ( pIrp->AssociatedIrp.SystemBuffer == NULL + && pSl->Parameters.DeviceIoControl.InputBufferLength == 0 + && pSl->Parameters.DeviceIoControl.OutputBufferLength == 0) + { + rcNt = VBoxUsbToolIoInternalCtlSendSync(pDevExt->pLowerDO, IOCTL_INTERNAL_USB_RESET_PORT, NULL, NULL); + Assert(NT_SUCCESS(rcNt)); + } + else + { + AssertFailed(); + rcNt = STATUS_INVALID_PARAMETER; + } + } + else + { + AssertFailed(); + rcNt = STATUS_ACCESS_DENIED; + } + } + else + { + AssertFailed(); + rcNt = STATUS_INVALID_PARAMETER; + } + + Assert(rcNt != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, rcNt, 0); + vboxUsbDdiStateRelease(pDevExt); + return rcNt; +} + +static PUSB_CONFIGURATION_DESCRIPTOR vboxUsbRtFindConfigDesc(PVBOXUSBDEV_EXT pDevExt, uint8_t uConfiguration) +{ + PUSB_CONFIGURATION_DESCRIPTOR pCfgDr = NULL; + + for (ULONG i = 0; i < VBOXUSBRT_MAX_CFGS; ++i) + { + if (pDevExt->Rt.cfgdescr[i]) + { + if (pDevExt->Rt.cfgdescr[i]->bConfigurationValue == uConfiguration) + { + pCfgDr = pDevExt->Rt.cfgdescr[i]; + break; + } + } + } + + return pCfgDr; +} + +static NTSTATUS vboxUsbRtSetConfig(PVBOXUSBDEV_EXT pDevExt, uint8_t uConfiguration) +{ + PURB pUrb = NULL; + NTSTATUS Status = STATUS_SUCCESS; + uint32_t i; + + if (!uConfiguration) + { + pUrb = VBoxUsbToolUrbAllocZ(URB_FUNCTION_SELECT_CONFIGURATION, sizeof (struct _URB_SELECT_CONFIGURATION)); + if (!pUrb) + { + AssertMsgFailed((__FUNCTION__": VBoxUsbToolUrbAlloc failed\n")); + return STATUS_INSUFFICIENT_RESOURCES; + } + + vboxUsbRtFreeInterfaces(pDevExt, TRUE); + + pUrb->UrbSelectConfiguration.ConfigurationDescriptor = NULL; + + Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb, RT_INDEFINITE_WAIT); + if (NT_SUCCESS(Status) && USBD_SUCCESS(pUrb->UrbHeader.Status)) + { + pDevExt->Rt.hConfiguration = pUrb->UrbSelectConfiguration.ConfigurationHandle; + pDevExt->Rt.uConfigValue = uConfiguration; + } + else + { + AssertMsgFailed((__FUNCTION__": VBoxUsbToolUrbPost failed Status (0x%x), usb Status (0x%x)\n", Status, pUrb->UrbHeader.Status)); + } + + VBoxUsbToolUrbFree(pUrb); + + return Status; + } + +/** @todo r=bird: Need to write a script for fixing these kind of clueless use + * of AssertMsgFailed (into AssertMsgReturn). The __FUNCTION__ is just + * the topping it off - the assertion message includes function, file and + * line number. Duh! */ + PUSB_CONFIGURATION_DESCRIPTOR pCfgDr = vboxUsbRtFindConfigDesc(pDevExt, uConfiguration); + if (!pCfgDr) + { + AssertMsgFailed((__FUNCTION__": VBoxUSBFindConfigDesc did not find cfg (%d)\n", uConfiguration)); + return STATUS_INVALID_PARAMETER; + } + + PUSBD_INTERFACE_LIST_ENTRY pIfLe = (PUSBD_INTERFACE_LIST_ENTRY)vboxUsbMemAllocZ((pCfgDr->bNumInterfaces + 1) * sizeof(USBD_INTERFACE_LIST_ENTRY)); + if (!pIfLe) + { + AssertMsgFailed((__FUNCTION__": vboxUsbMemAllocZ for pIfLe failed\n")); + return STATUS_INSUFFICIENT_RESOURCES; + } + + for (i = 0; i < pCfgDr->bNumInterfaces; i++) + { + pIfLe[i].InterfaceDescriptor = USBD_ParseConfigurationDescriptorEx(pCfgDr, pCfgDr, i, 0, -1, -1, -1); + if (!pIfLe[i].InterfaceDescriptor) + { + AssertMsgFailed((__FUNCTION__": interface %d not found\n", i)); + Status = STATUS_INVALID_PARAMETER; + break; + } + } + pIfLe[pCfgDr->bNumInterfaces].InterfaceDescriptor = NULL; + + if (NT_SUCCESS(Status)) + { + pUrb = USBD_CreateConfigurationRequestEx(pCfgDr, pIfLe); + if (pUrb) + { + Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb, RT_INDEFINITE_WAIT); + if (NT_SUCCESS(Status) && USBD_SUCCESS(pUrb->UrbHeader.Status)) + { + vboxUsbRtFreeInterfaces(pDevExt, FALSE); + + pDevExt->Rt.hConfiguration = pUrb->UrbSelectConfiguration.ConfigurationHandle; + pDevExt->Rt.uConfigValue = uConfiguration; + pDevExt->Rt.uNumInterfaces = pCfgDr->bNumInterfaces; + + pDevExt->Rt.pVBIfaceInfo = (VBOXUSB_IFACE_INFO*)vboxUsbMemAllocZ(pDevExt->Rt.uNumInterfaces * sizeof (VBOXUSB_IFACE_INFO)); + if (pDevExt->Rt.pVBIfaceInfo) + { + Assert(NT_SUCCESS(Status)); + for (i = 0; i < pDevExt->Rt.uNumInterfaces; i++) + { + size_t uTotalIfaceInfoLength = GET_USBD_INTERFACE_SIZE(pIfLe[i].Interface->NumberOfPipes); + pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo = (PUSBD_INTERFACE_INFORMATION)vboxUsbMemAlloc(uTotalIfaceInfoLength); + if (!pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo) + { + AssertMsgFailed((__FUNCTION__": vboxUsbMemAlloc failed\n")); + Status = STATUS_INSUFFICIENT_RESOURCES; + break; + } + + if (pIfLe[i].Interface->NumberOfPipes > 0) + { + pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo = (VBOXUSB_PIPE_INFO *)vboxUsbMemAlloc(pIfLe[i].Interface->NumberOfPipes * sizeof(VBOXUSB_PIPE_INFO)); + if (!pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo) + { + AssertMsgFailed((__FUNCTION__": vboxUsbMemAlloc failed\n")); + Status = STATUS_NO_MEMORY; + break; + } + } + else + { + pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo = NULL; + } + + RtlCopyMemory(pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo, pIfLe[i].Interface, uTotalIfaceInfoLength); + + for (ULONG j = 0; j < pIfLe[i].Interface->NumberOfPipes; j++) + { + pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo[j].EndpointAddress = pIfLe[i].Interface->Pipes[j].EndpointAddress; + pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo[j].NextScheduledFrame = 0; + } + } + +// if (NT_SUCCESS(Status)) +// { +// +// } + } + else + { + AssertMsgFailed((__FUNCTION__": vboxUsbMemAllocZ failed\n")); + Status = STATUS_NO_MEMORY; + } + } + else + { + AssertMsgFailed((__FUNCTION__": VBoxUsbToolUrbPost failed Status (0x%x), usb Status (0x%x)\n", Status, pUrb->UrbHeader.Status)); + } + ExFreePool(pUrb); + } + else + { + AssertMsgFailed((__FUNCTION__": USBD_CreateConfigurationRequestEx failed\n")); + Status = STATUS_INSUFFICIENT_RESOURCES; + } + } + + vboxUsbMemFree(pIfLe); + + return Status; +} + +static NTSTATUS vboxUsbRtDispatchUsbSetConfig(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + PUSBSUP_SET_CONFIG pCfg = (PUSBSUP_SET_CONFIG)pIrp->AssociatedIrp.SystemBuffer; + NTSTATUS Status = STATUS_SUCCESS; + + do + { + if (!pFObj) + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + + if (!vboxUsbRtCtxIsOwner(pDevExt, pFObj)) + { + AssertFailed(); + Status = STATUS_ACCESS_DENIED; + break; + } + + if ( !pCfg + || pSl->Parameters.DeviceIoControl.InputBufferLength != sizeof (*pCfg) + || pSl->Parameters.DeviceIoControl.OutputBufferLength != 0) + { + AssertMsgFailed((__FUNCTION__": STATUS_INVALID_PARAMETER\n")); + Status = STATUS_INVALID_PARAMETER; + break; + } + + Status = vboxUsbRtSetConfig(pDevExt, pCfg->bConfigurationValue); + } while (0); + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtSetInterface(PVBOXUSBDEV_EXT pDevExt, uint32_t InterfaceNumber, int AlternateSetting) +{ + AssertMsgReturn(pDevExt->Rt.uConfigValue, ("Can't select an interface without an active configuration\n"), + STATUS_INVALID_PARAMETER); + AssertMsgReturn(InterfaceNumber < pDevExt->Rt.uNumInterfaces, ("InterfaceNumber %d too high!!\n", InterfaceNumber), + STATUS_INVALID_PARAMETER); + PUSB_CONFIGURATION_DESCRIPTOR pCfgDr = vboxUsbRtFindConfigDesc(pDevExt, pDevExt->Rt.uConfigValue); + AssertMsgReturn(pCfgDr, ("configuration %d not found!!\n", pDevExt->Rt.uConfigValue), + STATUS_INVALID_PARAMETER); + PUSB_INTERFACE_DESCRIPTOR pIfDr = USBD_ParseConfigurationDescriptorEx(pCfgDr, pCfgDr, InterfaceNumber, AlternateSetting, -1, -1, -1); + AssertMsgReturn(pIfDr, ("invalid interface %d or alternate setting %d\n", InterfaceNumber, AlternateSetting), + STATUS_UNSUCCESSFUL); + + USHORT uUrbSize = GET_SELECT_INTERFACE_REQUEST_SIZE(pIfDr->bNumEndpoints); + ULONG uTotalIfaceInfoLength = GET_USBD_INTERFACE_SIZE(pIfDr->bNumEndpoints); + NTSTATUS Status = STATUS_SUCCESS; + PURB pUrb; + PUSBD_INTERFACE_INFORMATION pNewIFInfo = NULL; + VBOXUSB_PIPE_INFO *pNewPipeInfo = NULL; + + if (pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pInterfaceInfo) + { + /* Clear pipes associated with the interface, else Windows may hang. */ + for (ULONG i = 0; i < pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pInterfaceInfo->NumberOfPipes; i++) + VBoxUsbToolPipeClear(pDevExt->pLowerDO, pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pInterfaceInfo->Pipes[i].PipeHandle, FALSE); + } + + do { + /* First allocate all the structures we'll need. */ + pUrb = VBoxUsbToolUrbAllocZ(0, uUrbSize); + if (!pUrb) + { + AssertMsgFailed((__FUNCTION__": VBoxUsbToolUrbAllocZ failed\n")); + Status = STATUS_NO_MEMORY; + break; + } + + pNewIFInfo = (PUSBD_INTERFACE_INFORMATION)vboxUsbMemAlloc(uTotalIfaceInfoLength); + if (!pNewIFInfo) + { + AssertMsgFailed((__FUNCTION__": Failed allocating interface storage\n")); + Status = STATUS_NO_MEMORY; + break; + } + + if (pIfDr->bNumEndpoints > 0) + { + pNewPipeInfo = (VBOXUSB_PIPE_INFO *)vboxUsbMemAlloc(pIfDr->bNumEndpoints * sizeof(VBOXUSB_PIPE_INFO)); + if (!pNewPipeInfo) + { + AssertMsgFailed((__FUNCTION__": Failed allocating pipe info storage\n")); + Status = STATUS_NO_MEMORY; + break; + } + } + else + pNewPipeInfo = NULL; + + /* Now that we have all the bits, select the interface. */ + UsbBuildSelectInterfaceRequest(pUrb, uUrbSize, pDevExt->Rt.hConfiguration, InterfaceNumber, AlternateSetting); + pUrb->UrbSelectInterface.Interface.Length = GET_USBD_INTERFACE_SIZE(pIfDr->bNumEndpoints); + + Status = VBoxUsbToolUrbPost(pDevExt->pLowerDO, pUrb, RT_INDEFINITE_WAIT); + if (NT_SUCCESS(Status) && USBD_SUCCESS(pUrb->UrbHeader.Status)) + { + /* Free the old memory and put new in. */ + if (pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pInterfaceInfo) + vboxUsbMemFree(pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pInterfaceInfo); + pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pInterfaceInfo = pNewIFInfo; + if (pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pPipeInfo) + vboxUsbMemFree(pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pPipeInfo); + pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pPipeInfo = pNewPipeInfo; + pNewPipeInfo = NULL; pNewIFInfo = NULL; /* Don't try to free it again. */ + + USBD_INTERFACE_INFORMATION *pIfInfo = &pUrb->UrbSelectInterface.Interface; + memcpy(pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pInterfaceInfo, pIfInfo, GET_USBD_INTERFACE_SIZE(pIfDr->bNumEndpoints)); + + Assert(pIfInfo->NumberOfPipes == pIfDr->bNumEndpoints); + for (ULONG i = 0; i < pIfInfo->NumberOfPipes; i++) + { + pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pPipeInfo[i].EndpointAddress = pIfInfo->Pipes[i].EndpointAddress; + pDevExt->Rt.pVBIfaceInfo[InterfaceNumber].pPipeInfo[i].NextScheduledFrame = 0; + } + } + else + { + AssertMsgFailed((__FUNCTION__": VBoxUsbToolUrbPost failed Status (0x%x) usb Status (0x%x)\n", Status, pUrb->UrbHeader.Status)); + } + } while (0); + + /* Clean up. */ + if (pUrb) + VBoxUsbToolUrbFree(pUrb); + if (pNewIFInfo) + vboxUsbMemFree(pNewIFInfo); + if (pNewPipeInfo) + vboxUsbMemFree(pNewPipeInfo); + + return Status; +} + +static NTSTATUS vboxUsbRtDispatchUsbSelectInterface(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + PUSBSUP_SELECT_INTERFACE pIf = (PUSBSUP_SELECT_INTERFACE)pIrp->AssociatedIrp.SystemBuffer; + NTSTATUS Status; + + do + { + if (!pFObj) + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + + if (!vboxUsbRtCtxIsOwner(pDevExt, pFObj)) + { + AssertFailed(); + Status = STATUS_ACCESS_DENIED; + break; + } + + if ( !pIf + || pSl->Parameters.DeviceIoControl.InputBufferLength != sizeof (*pIf) + || pSl->Parameters.DeviceIoControl.OutputBufferLength != 0) + { + AssertMsgFailed((__FUNCTION__": STATUS_INVALID_PARAMETER\n")); + Status = STATUS_INVALID_PARAMETER; + break; + } + + Status = vboxUsbRtSetInterface(pDevExt, pIf->bInterfaceNumber, pIf->bAlternateSetting); + } while (0); + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static HANDLE vboxUsbRtGetPipeHandle(PVBOXUSBDEV_EXT pDevExt, uint32_t EndPointAddress) +{ + if (EndPointAddress == 0) + return pDevExt->Rt.hPipe0; + + for (ULONG i = 0; i < pDevExt->Rt.uNumInterfaces; i++) + { + for (ULONG j = 0; j < pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->NumberOfPipes; j++) + { + /* Note that bit 7 determines pipe direction, but is still significant + * because endpoints may be numbered like 0x01, 0x81, 0x02, 0x82 etc. + */ + if (pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->Pipes[j].EndpointAddress == EndPointAddress) + return pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->Pipes[j].PipeHandle; + } + } + return 0; +} + +static VBOXUSB_PIPE_INFO* vboxUsbRtGetPipeInfo(PVBOXUSBDEV_EXT pDevExt, uint32_t EndPointAddress) +{ + for (ULONG i = 0; i < pDevExt->Rt.uNumInterfaces; i++) + { + for (ULONG j = 0; j < pDevExt->Rt.pVBIfaceInfo[i].pInterfaceInfo->NumberOfPipes; j++) + { + if (pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo[j].EndpointAddress == EndPointAddress) + return &pDevExt->Rt.pVBIfaceInfo[i].pPipeInfo[j]; + } + } + return NULL; +} + + + +static NTSTATUS vboxUsbRtClearEndpoint(PVBOXUSBDEV_EXT pDevExt, uint32_t EndPointAddress, bool fReset) +{ + NTSTATUS Status = VBoxUsbToolPipeClear(pDevExt->pLowerDO, vboxUsbRtGetPipeHandle(pDevExt, EndPointAddress), fReset); + if (!NT_SUCCESS(Status)) + { + AssertMsgFailed((__FUNCTION__": VBoxUsbToolPipeClear failed Status (0x%x)\n", Status)); + } + + return Status; +} + +static NTSTATUS vboxUsbRtDispatchUsbClearEndpoint(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + PUSBSUP_CLEAR_ENDPOINT pCe = (PUSBSUP_CLEAR_ENDPOINT)pIrp->AssociatedIrp.SystemBuffer; + NTSTATUS Status; + + do + { + if (!pFObj) + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + + if (!vboxUsbRtCtxIsOwner(pDevExt, pFObj)) + { + AssertFailed(); + Status = STATUS_ACCESS_DENIED; + break; + } + + if ( !pCe + || pSl->Parameters.DeviceIoControl.InputBufferLength != sizeof (*pCe) + || pSl->Parameters.DeviceIoControl.OutputBufferLength != 0) + { + AssertMsgFailed((__FUNCTION__": STATUS_INVALID_PARAMETER\n")); + Status = STATUS_INVALID_PARAMETER; + break; + } + + Status = vboxUsbRtClearEndpoint(pDevExt, pCe->bEndpoint, TRUE); + } while (0); + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtDispatchUsbAbortEndpoint(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + PUSBSUP_CLEAR_ENDPOINT pCe = (PUSBSUP_CLEAR_ENDPOINT)pIrp->AssociatedIrp.SystemBuffer; + NTSTATUS Status; + + do + { + if (!pFObj) + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + + if (!vboxUsbRtCtxIsOwner(pDevExt, pFObj)) + { + AssertFailed(); + Status = STATUS_ACCESS_DENIED; + break; + } + + if ( !pCe + || pSl->Parameters.DeviceIoControl.InputBufferLength != sizeof (*pCe) + || pSl->Parameters.DeviceIoControl.OutputBufferLength != 0) + { + AssertMsgFailed((__FUNCTION__": STATUS_INVALID_PARAMETER\n")); + Status = STATUS_INVALID_PARAMETER; + break; + } + + Status = vboxUsbRtClearEndpoint(pDevExt, pCe->bEndpoint, FALSE); + } while (0); + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtUrbSendCompletion(PDEVICE_OBJECT pDevObj, IRP *pIrp, void *pvContext) +{ + RT_NOREF1(pDevObj); + + if (!pvContext) + { + AssertMsgFailed((__FUNCTION__": context is NULL\n")); + pIrp->IoStatus.Information = 0; + return STATUS_CONTINUE_COMPLETION; + } + + PVBOXUSB_URB_CONTEXT pContext = (PVBOXUSB_URB_CONTEXT)pvContext; + + if (pContext->ulMagic != VBOXUSB_MAGIC) + { + AssertMsgFailed((__FUNCTION__": Invalid context magic\n")); + pIrp->IoStatus.Information = 0; + return STATUS_CONTINUE_COMPLETION; + } + + PURB pUrb = pContext->pUrb; + PMDL pMdlBuf = pContext->pMdlBuf; + PUSBSUP_URB pUrbInfo = (PUSBSUP_URB)pContext->pOut; + PVBOXUSBDEV_EXT pDevExt = pContext->pDevExt; + + if (!pUrb || !pMdlBuf || !pUrbInfo || !pDevExt) + { + AssertMsgFailed((__FUNCTION__": Invalid args\n")); + if (pDevExt) + vboxUsbDdiStateRelease(pDevExt); + pIrp->IoStatus.Information = 0; + return STATUS_CONTINUE_COMPLETION; + } + + NTSTATUS Status = pIrp->IoStatus.Status; + if (Status == STATUS_SUCCESS) + { + switch(pUrb->UrbHeader.Status) + { + case USBD_STATUS_CRC: + pUrbInfo->error = USBSUP_XFER_CRC; + break; + case USBD_STATUS_SUCCESS: + pUrbInfo->error = USBSUP_XFER_OK; + break; + case USBD_STATUS_STALL_PID: + pUrbInfo->error = USBSUP_XFER_STALL; + break; + case USBD_STATUS_INVALID_URB_FUNCTION: + case USBD_STATUS_INVALID_PARAMETER: + AssertMsgFailed((__FUNCTION__": sw error, urb Status (0x%x)\n", pUrb->UrbHeader.Status)); + case USBD_STATUS_DEV_NOT_RESPONDING: + default: + pUrbInfo->error = USBSUP_XFER_DNR; + break; + } + + switch(pContext->ulTransferType) + { + case USBSUP_TRANSFER_TYPE_MSG: + pUrbInfo->len = pUrb->UrbControlTransfer.TransferBufferLength; + /* QUSB_TRANSFER_TYPE_MSG is a control transfer, but it is special + * the first 8 bytes of the buffer is the setup packet so the real + * data length is therefore urb->len - 8 + */ + pUrbInfo->len += sizeof (pUrb->UrbControlTransfer.SetupPacket); + + /* If a control URB was successfully completed on the default control + * pipe, stash away the handle. When submitting the URB, we don't need + * to know (and initially don't have) the handle. If we want to abort + * the default control pipe, we *have* to have a handle. This is how we + * find out what the handle is. + */ + if (!pUrbInfo->ep && (pDevExt->Rt.hPipe0 == NULL)) + { + pDevExt->Rt.hPipe0 = pUrb->UrbControlTransfer.PipeHandle; + } + + break; + case USBSUP_TRANSFER_TYPE_ISOC: + pUrbInfo->len = pUrb->UrbIsochronousTransfer.TransferBufferLength; + break; + case USBSUP_TRANSFER_TYPE_BULK: + case USBSUP_TRANSFER_TYPE_INTR: + if (pUrbInfo->dir == USBSUP_DIRECTION_IN && pUrbInfo->error == USBSUP_XFER_OK + && !(pUrbInfo->flags & USBSUP_FLAG_SHORT_OK) + && pUrbInfo->len > pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength + ) + { + /* If we don't use the USBD_SHORT_TRANSFER_OK flag, the returned buffer lengths are + * wrong for short transfers (always a multiple of max packet size?). So we just figure + * out if this was a data underrun on our own. + */ + pUrbInfo->error = USBSUP_XFER_UNDERRUN; + } + pUrbInfo->len = pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength; + break; + default: + break; + } + } + else + { + pUrbInfo->len = 0; + + LogFunc(("URB failed Status (0x%x) urb Status (0x%x)\n", Status, pUrb->UrbHeader.Status)); +#ifdef DEBUG + switch(pContext->ulTransferType) + { + case USBSUP_TRANSFER_TYPE_MSG: + LogRel(("Msg (CTRL) length=%d\n", pUrb->UrbControlTransfer.TransferBufferLength)); + break; + case USBSUP_TRANSFER_TYPE_ISOC: + LogRel(("ISOC length=%d\n", pUrb->UrbIsochronousTransfer.TransferBufferLength)); + break; + case USBSUP_TRANSFER_TYPE_BULK: + case USBSUP_TRANSFER_TYPE_INTR: + LogRel(("BULK/INTR length=%d\n", pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength)); + break; + } +#endif + switch(pUrb->UrbHeader.Status) + { + case USBD_STATUS_CRC: + pUrbInfo->error = USBSUP_XFER_CRC; + Status = STATUS_SUCCESS; + break; + case USBD_STATUS_STALL_PID: + pUrbInfo->error = USBSUP_XFER_STALL; + Status = STATUS_SUCCESS; + break; + case USBD_STATUS_DEV_NOT_RESPONDING: + case USBD_STATUS_DEVICE_GONE: + pUrbInfo->error = USBSUP_XFER_DNR; + Status = STATUS_SUCCESS; + break; + case ((USBD_STATUS)0xC0010000L): // USBD_STATUS_CANCELED - too bad usbdi.h and usb.h aren't consistent! + /// @todo What the heck are we really supposed to do here? + pUrbInfo->error = USBSUP_XFER_STALL; + Status = STATUS_SUCCESS; + break; + case USBD_STATUS_BAD_START_FRAME: // This one really shouldn't happen + case USBD_STATUS_ISOCH_REQUEST_FAILED: + pUrbInfo->error = USBSUP_XFER_NAC; + Status = STATUS_SUCCESS; + break; + default: + AssertMsgFailed((__FUNCTION__": err Status (0x%x) (0x%x)\n", Status, pUrb->UrbHeader.Status)); + pUrbInfo->error = USBSUP_XFER_DNR; + Status = STATUS_SUCCESS; + break; + } + } + // For isochronous transfers, always update the individual packets + if (pContext->ulTransferType == USBSUP_TRANSFER_TYPE_ISOC) + { + Assert(pUrbInfo->numIsoPkts == pUrb->UrbIsochronousTransfer.NumberOfPackets); + for (ULONG i = 0; i < pUrbInfo->numIsoPkts; ++i) + { + Assert(pUrbInfo->aIsoPkts[i].off == pUrb->UrbIsochronousTransfer.IsoPacket[i].Offset); + pUrbInfo->aIsoPkts[i].cb = (uint16_t)pUrb->UrbIsochronousTransfer.IsoPacket[i].Length; + switch (pUrb->UrbIsochronousTransfer.IsoPacket[i].Status) + { + case USBD_STATUS_SUCCESS: + pUrbInfo->aIsoPkts[i].stat = USBSUP_XFER_OK; + break; + case USBD_STATUS_NOT_ACCESSED: + pUrbInfo->aIsoPkts[i].stat = USBSUP_XFER_NAC; + break; + default: + pUrbInfo->aIsoPkts[i].stat = USBSUP_XFER_STALL; + break; + } + } + } + + MmUnlockPages(pMdlBuf); + IoFreeMdl(pMdlBuf); + + vboxUsbMemFree(pContext); + + vboxUsbDdiStateRelease(pDevExt); + + Assert(pIrp->IoStatus.Status != STATUS_IO_TIMEOUT); + pIrp->IoStatus.Information = sizeof(*pUrbInfo); + pIrp->IoStatus.Status = Status; + return STATUS_CONTINUE_COMPLETION; +} + +static NTSTATUS vboxUsbRtUrbSend(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp, PUSBSUP_URB pUrbInfo) +{ + NTSTATUS Status = STATUS_SUCCESS; + PVBOXUSB_URB_CONTEXT pContext = NULL; + PMDL pMdlBuf = NULL; + ULONG cbUrb; + + Assert(pUrbInfo); + if (pUrbInfo->type == USBSUP_TRANSFER_TYPE_ISOC) + { + Assert(pUrbInfo->numIsoPkts <= 8); + cbUrb = GET_ISO_URB_SIZE(pUrbInfo->numIsoPkts); + } + else + cbUrb = sizeof (URB); + + do + { + pContext = (PVBOXUSB_URB_CONTEXT)vboxUsbMemAllocZ(cbUrb + sizeof (VBOXUSB_URB_CONTEXT)); + if (!pContext) + { + AssertMsgFailed((__FUNCTION__": vboxUsbMemAlloc failed\n")); + Status = STATUS_INSUFFICIENT_RESOURCES; + break; + } + + PURB pUrb = (PURB)(pContext + 1); + HANDLE hPipe = NULL; + if (pUrbInfo->ep) + { + hPipe = vboxUsbRtGetPipeHandle(pDevExt, pUrbInfo->ep | ((pUrbInfo->dir == USBSUP_DIRECTION_IN) ? 0x80 : 0x00)); + if (!hPipe) + { + AssertMsgFailed((__FUNCTION__": vboxUsbRtGetPipeHandle failed for endpoint (0x%x)\n", pUrbInfo->ep)); + Status = STATUS_INVALID_PARAMETER; + break; + } + } + + pMdlBuf = IoAllocateMdl(pUrbInfo->buf, (ULONG)pUrbInfo->len, FALSE, FALSE, NULL); + if (!pMdlBuf) + { + AssertMsgFailed((__FUNCTION__": IoAllocateMdl failed for buffer (0x%p) length (%d)\n", pUrbInfo->buf, pUrbInfo->len)); + Status = STATUS_INSUFFICIENT_RESOURCES; + break; + } + + __try + { + MmProbeAndLockPages(pMdlBuf, KernelMode, IoModifyAccess); + } + __except(EXCEPTION_EXECUTE_HANDLER) + { + Status = GetExceptionCode(); + IoFreeMdl(pMdlBuf); + pMdlBuf = NULL; + AssertMsgFailed((__FUNCTION__": Exception Code (0x%x)\n", Status)); + break; + } + + /* For some reason, passing a MDL in the URB does not work reliably. Notably + * the iPhone when used with iTunes fails. + */ + PVOID pBuffer = MmGetSystemAddressForMdlSafe(pMdlBuf, NormalPagePriority); + if (!pBuffer) + { + AssertMsgFailed((__FUNCTION__": MmGetSystemAddressForMdlSafe failed\n")); + Status = STATUS_INSUFFICIENT_RESOURCES; + break; + } + + switch (pUrbInfo->type) + { + case USBSUP_TRANSFER_TYPE_MSG: + { + pUrb->UrbHeader.Function = URB_FUNCTION_CONTROL_TRANSFER; + pUrb->UrbHeader.Length = sizeof (struct _URB_CONTROL_TRANSFER); + pUrb->UrbControlTransfer.PipeHandle = hPipe; + pUrb->UrbControlTransfer.TransferBufferLength = (ULONG)pUrbInfo->len; + pUrb->UrbControlTransfer.TransferFlags = ((pUrbInfo->dir == USBSUP_DIRECTION_IN) ? USBD_TRANSFER_DIRECTION_IN : USBD_TRANSFER_DIRECTION_OUT); + pUrb->UrbControlTransfer.UrbLink = 0; + + if (!hPipe) + pUrb->UrbControlTransfer.TransferFlags |= USBD_DEFAULT_PIPE_TRANSFER; + + /* QUSB_TRANSFER_TYPE_MSG is a control transfer, but it is special + * the first 8 bytes of the buffer is the setup packet so the real + * data length is therefore pUrb->len - 8 + */ + //PVBOXUSB_SETUP pSetup = (PVBOXUSB_SETUP)pUrb->UrbControlTransfer.SetupPacket; + memcpy(pUrb->UrbControlTransfer.SetupPacket, pBuffer, min(sizeof (pUrb->UrbControlTransfer.SetupPacket), pUrbInfo->len)); + + if (pUrb->UrbControlTransfer.TransferBufferLength <= sizeof (pUrb->UrbControlTransfer.SetupPacket)) + pUrb->UrbControlTransfer.TransferBufferLength = 0; + else + pUrb->UrbControlTransfer.TransferBufferLength -= sizeof (pUrb->UrbControlTransfer.SetupPacket); + + pUrb->UrbControlTransfer.TransferBuffer = (uint8_t *)pBuffer + sizeof(pUrb->UrbControlTransfer.SetupPacket); + pUrb->UrbControlTransfer.TransferBufferMDL = 0; + pUrb->UrbControlTransfer.TransferFlags |= USBD_SHORT_TRANSFER_OK; + break; + } + case USBSUP_TRANSFER_TYPE_ISOC: + { + Assert(hPipe); + VBOXUSB_PIPE_INFO *pPipeInfo = vboxUsbRtGetPipeInfo(pDevExt, pUrbInfo->ep | ((pUrbInfo->dir == USBSUP_DIRECTION_IN) ? 0x80 : 0x00)); + if (pPipeInfo == NULL) + { + /* Can happen if the isoc request comes in too early or late. */ + AssertMsgFailed((__FUNCTION__": pPipeInfo not found\n")); + Status = STATUS_INVALID_PARAMETER; + break; + } + + pUrb->UrbHeader.Function = URB_FUNCTION_ISOCH_TRANSFER; + pUrb->UrbHeader.Length = (USHORT)cbUrb; + pUrb->UrbIsochronousTransfer.PipeHandle = hPipe; + pUrb->UrbIsochronousTransfer.TransferBufferLength = (ULONG)pUrbInfo->len; + pUrb->UrbIsochronousTransfer.TransferBufferMDL = 0; + pUrb->UrbIsochronousTransfer.TransferBuffer = pBuffer; + pUrb->UrbIsochronousTransfer.TransferFlags = ((pUrbInfo->dir == USBSUP_DIRECTION_IN) ? USBD_TRANSFER_DIRECTION_IN : USBD_TRANSFER_DIRECTION_OUT); + pUrb->UrbIsochronousTransfer.TransferFlags |= USBD_SHORT_TRANSFER_OK; // May be implied already + pUrb->UrbIsochronousTransfer.NumberOfPackets = pUrbInfo->numIsoPkts; + pUrb->UrbIsochronousTransfer.ErrorCount = 0; + pUrb->UrbIsochronousTransfer.UrbLink = 0; + + Assert(pUrbInfo->numIsoPkts == pUrb->UrbIsochronousTransfer.NumberOfPackets); + for (ULONG i = 0; i < pUrbInfo->numIsoPkts; ++i) + { + pUrb->UrbIsochronousTransfer.IsoPacket[i].Offset = pUrbInfo->aIsoPkts[i].off; + pUrb->UrbIsochronousTransfer.IsoPacket[i].Length = pUrbInfo->aIsoPkts[i].cb; + } + + /* We have to schedule the URBs ourselves. There is an ASAP flag but + * that can only be reliably used after pipe creation/reset, ie. it's + * almost completely useless. + */ + ULONG iFrame, iStartFrame; + VBoxUsbToolCurrentFrame(pDevExt->pLowerDO, pIrp, &iFrame); + iFrame += 2; + iStartFrame = pPipeInfo->NextScheduledFrame; + if ((iFrame < iStartFrame) || (iStartFrame > iFrame + 512)) + iFrame = iStartFrame; + /* For full-speed devices, there must be one transfer per frame (Windows USB + * stack requirement), but URBs can contain multiple packets. For high-speed or + * faster transfers, we expect one URB per frame, regardless of the interval. + */ + if (pDevExt->Rt.devdescr->bcdUSB < 0x300 && !pDevExt->Rt.fIsHighSpeed) + pPipeInfo->NextScheduledFrame = iFrame + pUrbInfo->numIsoPkts; + else + pPipeInfo->NextScheduledFrame = iFrame + 1; + pUrb->UrbIsochronousTransfer.StartFrame = iFrame; + break; + } + case USBSUP_TRANSFER_TYPE_BULK: + case USBSUP_TRANSFER_TYPE_INTR: + { + Assert(pUrbInfo->dir != USBSUP_DIRECTION_SETUP); + Assert(pUrbInfo->dir == USBSUP_DIRECTION_IN || pUrbInfo->type == USBSUP_TRANSFER_TYPE_BULK); + Assert(hPipe); + + pUrb->UrbHeader.Function = URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER; + pUrb->UrbHeader.Length = sizeof (struct _URB_BULK_OR_INTERRUPT_TRANSFER); + pUrb->UrbBulkOrInterruptTransfer.PipeHandle = hPipe; + pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength = (ULONG)pUrbInfo->len; + pUrb->UrbBulkOrInterruptTransfer.TransferBufferMDL = 0; + pUrb->UrbBulkOrInterruptTransfer.TransferBuffer = pBuffer; + pUrb->UrbBulkOrInterruptTransfer.TransferFlags = ((pUrbInfo->dir == USBSUP_DIRECTION_IN) ? USBD_TRANSFER_DIRECTION_IN : USBD_TRANSFER_DIRECTION_OUT); + + if (pUrb->UrbBulkOrInterruptTransfer.TransferFlags & USBD_TRANSFER_DIRECTION_IN) + pUrb->UrbBulkOrInterruptTransfer.TransferFlags |= (USBD_SHORT_TRANSFER_OK); + + pUrb->UrbBulkOrInterruptTransfer.UrbLink = 0; + break; + } + default: + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + } + + if (!NT_SUCCESS(Status)) + { + break; + } + + pContext->pDevExt = pDevExt; + pContext->pMdlBuf = pMdlBuf; + pContext->pUrb = pUrb; + pContext->pOut = pUrbInfo; + pContext->ulTransferType = pUrbInfo->type; + pContext->ulMagic = VBOXUSB_MAGIC; + + PIO_STACK_LOCATION pSl = IoGetNextIrpStackLocation(pIrp); + pSl->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL; + pSl->Parameters.DeviceIoControl.IoControlCode = IOCTL_INTERNAL_USB_SUBMIT_URB; + pSl->Parameters.Others.Argument1 = pUrb; + pSl->Parameters.Others.Argument2 = NULL; + + IoSetCompletionRoutine(pIrp, vboxUsbRtUrbSendCompletion, pContext, TRUE, TRUE, TRUE); + IoMarkIrpPending(pIrp); + Status = IoCallDriver(pDevExt->pLowerDO, pIrp); + AssertMsg(NT_SUCCESS(Status), (__FUNCTION__": IoCallDriver failed Status (0x%x)\n", Status)); + return STATUS_PENDING; + } while (0); + + Assert(!NT_SUCCESS(Status)); + + if (pMdlBuf) + { + MmUnlockPages(pMdlBuf); + IoFreeMdl(pMdlBuf); + } + + if (pContext) + vboxUsbMemFree(pContext); + + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtDispatchSendUrb(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + PUSBSUP_URB pUrbInfo = (PUSBSUP_URB)pIrp->AssociatedIrp.SystemBuffer; + NTSTATUS Status; + + do + { + if (!pFObj) + { + AssertFailed(); + Status = STATUS_INVALID_PARAMETER; + break; + } + + if (!vboxUsbRtCtxIsOwner(pDevExt, pFObj)) + { + AssertFailed(); + Status = STATUS_ACCESS_DENIED; + break; + } + + if ( !pUrbInfo + || pSl->Parameters.DeviceIoControl.InputBufferLength != sizeof (*pUrbInfo) + || pSl->Parameters.DeviceIoControl.OutputBufferLength != sizeof (*pUrbInfo)) + { + AssertMsgFailed((__FUNCTION__": STATUS_INVALID_PARAMETER\n")); + Status = STATUS_INVALID_PARAMETER; + break; + } + return vboxUsbRtUrbSend(pDevExt, pIrp, pUrbInfo); + } while (0); + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, 0); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtDispatchIsOperational(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + VBoxDrvToolIoComplete(pIrp, STATUS_SUCCESS, 0); + vboxUsbDdiStateRelease(pDevExt); + return STATUS_SUCCESS; +} + +static NTSTATUS vboxUsbRtDispatchGetVersion(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PUSBSUP_VERSION pVer= (PUSBSUP_VERSION)pIrp->AssociatedIrp.SystemBuffer; + NTSTATUS Status = STATUS_SUCCESS; + + if ( pVer + && pSl->Parameters.DeviceIoControl.InputBufferLength == 0 + && pSl->Parameters.DeviceIoControl.OutputBufferLength == sizeof(*pVer)) + { + pVer->u32Major = USBDRV_MAJOR_VERSION; + pVer->u32Minor = USBDRV_MINOR_VERSION; + } + else + { + AssertMsgFailed((__FUNCTION__": STATUS_INVALID_PARAMETER\n")); + Status = STATUS_INVALID_PARAMETER; + } + + Assert(Status != STATUS_PENDING); + VBoxDrvToolIoComplete(pIrp, Status, sizeof (*pVer)); + vboxUsbDdiStateRelease(pDevExt); + return Status; +} + +static NTSTATUS vboxUsbRtDispatchDefault(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + VBoxDrvToolIoComplete(pIrp, STATUS_INVALID_DEVICE_REQUEST, 0); + vboxUsbDdiStateRelease(pDevExt); + return STATUS_INVALID_DEVICE_REQUEST; +} + +DECLHIDDEN(NTSTATUS) vboxUsbRtCreate(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + RT_NOREF1(pDevExt); + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + AssertReturn(pFObj, STATUS_INVALID_PARAMETER); + return STATUS_SUCCESS; +} + +DECLHIDDEN(NTSTATUS) vboxUsbRtClose(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFObj = pSl->FileObject; + Assert(pFObj); + + vboxUsbRtCtxReleaseOwner(pDevExt, pFObj); + + return STATUS_SUCCESS; +} + +DECLHIDDEN(NTSTATUS) vboxUsbRtDispatch(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp) +{ + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + switch (pSl->Parameters.DeviceIoControl.IoControlCode) + { + case SUPUSB_IOCTL_USB_CLAIM_DEVICE: + return vboxUsbRtDispatchClaimDevice(pDevExt, pIrp); + + case SUPUSB_IOCTL_USB_RELEASE_DEVICE: + return vboxUsbRtDispatchReleaseDevice(pDevExt, pIrp); + + case SUPUSB_IOCTL_GET_DEVICE: + return vboxUsbRtDispatchGetDevice(pDevExt, pIrp); + + case SUPUSB_IOCTL_USB_RESET: + return vboxUsbRtDispatchUsbReset(pDevExt, pIrp); + + case SUPUSB_IOCTL_USB_SET_CONFIG: + return vboxUsbRtDispatchUsbSetConfig(pDevExt, pIrp); + + case SUPUSB_IOCTL_USB_SELECT_INTERFACE: + return vboxUsbRtDispatchUsbSelectInterface(pDevExt, pIrp); + + case SUPUSB_IOCTL_USB_CLEAR_ENDPOINT: + return vboxUsbRtDispatchUsbClearEndpoint(pDevExt, pIrp); + + case SUPUSB_IOCTL_USB_ABORT_ENDPOINT: + return vboxUsbRtDispatchUsbAbortEndpoint(pDevExt, pIrp); + + case SUPUSB_IOCTL_SEND_URB: + return vboxUsbRtDispatchSendUrb(pDevExt, pIrp); + + case SUPUSB_IOCTL_IS_OPERATIONAL: + return vboxUsbRtDispatchIsOperational(pDevExt, pIrp); + + case SUPUSB_IOCTL_GET_VERSION: + return vboxUsbRtDispatchGetVersion(pDevExt, pIrp); + + default: + return vboxUsbRtDispatchDefault(pDevExt, pIrp); + } +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbRt.h b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbRt.h new file mode 100644 index 00000000..6684045b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/dev/VBoxUsbRt.h @@ -0,0 +1,87 @@ +/* $Id: VBoxUsbRt.h $ */ +/** @file + * VBox USB R0 runtime + */ +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbRt_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbRt_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "VBoxUsbCmn.h" +#include "../cmn/VBoxUsbIdc.h" + +#define VBOXUSBRT_MAX_CFGS 4 + +typedef struct VBOXUSB_PIPE_INFO { + UCHAR EndpointAddress; + ULONG NextScheduledFrame; +} VBOXUSB_PIPE_INFO; + +typedef struct VBOXUSB_IFACE_INFO { + USBD_INTERFACE_INFORMATION *pInterfaceInfo; + VBOXUSB_PIPE_INFO *pPipeInfo; +} VBOXUSB_IFACE_INFO; + +typedef struct VBOXUSB_RT +{ + UNICODE_STRING IfName; + + HANDLE hPipe0; + HANDLE hConfiguration; + uint32_t uConfigValue; + + uint32_t uNumInterfaces; + USB_DEVICE_DESCRIPTOR *devdescr; + USB_CONFIGURATION_DESCRIPTOR *cfgdescr[VBOXUSBRT_MAX_CFGS]; + + VBOXUSB_IFACE_INFO *pVBIfaceInfo; + + uint16_t idVendor, idProduct, bcdDevice; + char szSerial[MAX_USB_SERIAL_STRING]; + BOOLEAN fIsHighSpeed; + + HVBOXUSBIDCDEV hMonDev; + PFILE_OBJECT pOwner; +} VBOXUSB_RT, *PVBOXUSB_RT; + +typedef struct VBOXUSBRT_IDC +{ + PDEVICE_OBJECT pDevice; + PFILE_OBJECT pFile; +} VBOXUSBRT_IDC, *PVBOXUSBRT_IDC; + +DECLHIDDEN(NTSTATUS) vboxUsbRtGlobalsInit(); +DECLHIDDEN(VOID) vboxUsbRtGlobalsTerm(); + +DECLHIDDEN(NTSTATUS) vboxUsbRtInit(PVBOXUSBDEV_EXT pDevExt); +DECLHIDDEN(VOID) vboxUsbRtClear(PVBOXUSBDEV_EXT pDevExt); +DECLHIDDEN(NTSTATUS) vboxUsbRtRm(PVBOXUSBDEV_EXT pDevExt); +DECLHIDDEN(NTSTATUS) vboxUsbRtStart(PVBOXUSBDEV_EXT pDevExt); + +DECLHIDDEN(NTSTATUS) vboxUsbRtDispatch(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp); +DECLHIDDEN(NTSTATUS) vboxUsbRtCreate(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp); +DECLHIDDEN(NTSTATUS) vboxUsbRtClose(PVBOXUSBDEV_EXT pDevExt, PIRP pIrp); + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_dev_VBoxUsbRt_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/lib/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/lib/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/lib/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/lib/VBoxUsbLib-win.cpp b/src/VBox/HostDrivers/VBoxUSB/win/lib/VBoxUsbLib-win.cpp new file mode 100644 index 00000000..df9c4683 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/lib/VBoxUsbLib-win.cpp @@ -0,0 +1,1616 @@ +/* $Id: VBoxUsbLib-win.cpp $ */ +/** @file + * VBox USB ring-3 Driver Interface library, Windows. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP LOG_GROUP_DRV_USBPROXY +#include <iprt/win/windows.h> + +#include <VBox/sup.h> +#include <VBox/types.h> +#include <VBox/err.h> +#include <VBox/param.h> +#include <iprt/path.h> +#include <iprt/assert.h> +#include <iprt/alloc.h> +#include <iprt/string.h> +#include <iprt/thread.h> +#include <iprt/utf16.h> +#include <VBox/log.h> +#include <VBox/usblib.h> +#include <VBox/usblib-win.h> +#include <VBox/usb.h> +#include <VBox/VBoxDrvCfg-win.h> +#pragma warning (disable:4200) /* shuts up the empty array member warnings */ +#include <iprt/win/setupapi.h> +#include <usbdi.h> +#include <hidsdi.h> + +/* Defined in Windows 8 DDK (through usbdi.h) but we use Windows 7 DDK to build. */ +#define UsbSuperSpeed 3 + +#define VBOX_USB_USE_DEVICE_NOTIFICATION + +#ifdef VBOX_USB_USE_DEVICE_NOTIFICATION +# include <Dbt.h> +#endif + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef struct _USB_INTERFACE_DESCRIPTOR2 +{ + UCHAR bLength; + UCHAR bDescriptorType; + UCHAR bInterfaceNumber; + UCHAR bAlternateSetting; + UCHAR bNumEndpoints; + UCHAR bInterfaceClass; + UCHAR bInterfaceSubClass; + UCHAR bInterfaceProtocol; + UCHAR iInterface; + USHORT wNumClasses; +} USB_INTERFACE_DESCRIPTOR2, *PUSB_INTERFACE_DESCRIPTOR2; + +typedef struct VBOXUSBGLOBALSTATE +{ + HANDLE hMonitor; + HANDLE hNotifyEvent; + HANDLE hInterruptEvent; +#ifdef VBOX_USB_USE_DEVICE_NOTIFICATION + HANDLE hThread; + HWND hWnd; + HANDLE hTimerQueue; + HANDLE hTimer; +#endif +} VBOXUSBGLOBALSTATE, *PVBOXUSBGLOBALSTATE; + +typedef struct VBOXUSB_STRING_DR_ENTRY +{ + struct VBOXUSB_STRING_DR_ENTRY *pNext; + UCHAR iDr; + USHORT idLang; + USB_STRING_DESCRIPTOR StrDr; +} VBOXUSB_STRING_DR_ENTRY, *PVBOXUSB_STRING_DR_ENTRY; + +/** + * This represents VBoxUsb device instance + */ +typedef struct VBOXUSB_DEV +{ + struct VBOXUSB_DEV *pNext; + char szName[512]; + char szDriverRegName[512]; +} VBOXUSB_DEV, *PVBOXUSB_DEV; + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +static VBOXUSBGLOBALSTATE g_VBoxUsbGlobal; + + +int usbLibVuDeviceValidate(PVBOXUSB_DEV pVuDev) +{ + HANDLE hOut = INVALID_HANDLE_VALUE; + + hOut = CreateFile(pVuDev->szName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL); + + if (hOut == INVALID_HANDLE_VALUE) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("CreateFile FAILED to open %s, dwErr (%d)\n", pVuDev->szName, dwErr)); + return VERR_GENERAL_FAILURE; + } + + USBSUP_VERSION version = {0}; + DWORD cbReturned = 0; + int rc = VERR_VERSION_MISMATCH; + + do + { + if (!DeviceIoControl(hOut, SUPUSB_IOCTL_GET_VERSION, NULL, 0,&version, sizeof(version), &cbReturned, NULL)) + { + AssertMsgFailed(("DeviceIoControl SUPUSB_IOCTL_GET_VERSION failed with LastError=%Rwa\n", GetLastError())); + break; + } + + if ( version.u32Major != USBDRV_MAJOR_VERSION +#if USBDRV_MINOR_VERSION != 0 + || version.u32Minor < USBDRV_MINOR_VERSION +#endif + ) + { + AssertMsgFailed(("Invalid version %d:%d vs %d:%d\n", version.u32Major, version.u32Minor, USBDRV_MAJOR_VERSION, USBDRV_MINOR_VERSION)); + break; + } + + if (!DeviceIoControl(hOut, SUPUSB_IOCTL_IS_OPERATIONAL, NULL, 0, NULL, NULL, &cbReturned, NULL)) + { + AssertMsgFailed(("DeviceIoControl SUPUSB_IOCTL_IS_OPERATIONAL failed with LastError=%Rwa\n", GetLastError())); + break; + } + + rc = VINF_SUCCESS; + } while (0); + + CloseHandle(hOut); + return rc; +} + +static int usbLibVuDevicePopulate(PVBOXUSB_DEV pVuDev, HDEVINFO hDevInfo, PSP_DEVICE_INTERFACE_DATA pIfData) +{ + DWORD cbIfDetailData; + int rc = VINF_SUCCESS; + + SetupDiGetDeviceInterfaceDetail(hDevInfo, pIfData, + NULL, /* OUT PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData */ + 0, /* IN DWORD DeviceInterfaceDetailDataSize */ + &cbIfDetailData, + NULL + ); + Assert(GetLastError() == ERROR_INSUFFICIENT_BUFFER); + + PSP_DEVICE_INTERFACE_DETAIL_DATA pIfDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)RTMemAllocZ(cbIfDetailData); + if (!pIfDetailData) + { + AssertMsgFailed(("RTMemAllocZ failed\n")); + return VERR_OUT_OF_RESOURCES; + } + + DWORD cbDbgRequired; + SP_DEVINFO_DATA DevInfoData; + DevInfoData.cbSize = sizeof (DevInfoData); + /* the cbSize should contain the sizeof a fixed-size part according to the docs */ + pIfDetailData->cbSize = sizeof (*pIfDetailData); + do + { + if (!SetupDiGetDeviceInterfaceDetail(hDevInfo, pIfData, + pIfDetailData, + cbIfDetailData, + &cbDbgRequired, + &DevInfoData)) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("SetupDiGetDeviceInterfaceDetail, cbRequired (%d), was (%d), dwErr (%d)\n", cbDbgRequired, cbIfDetailData, dwErr)); + rc = VERR_GENERAL_FAILURE; + break; + } + + strncpy(pVuDev->szName, pIfDetailData->DevicePath, sizeof (pVuDev->szName)); + + if (!SetupDiGetDeviceRegistryPropertyA(hDevInfo, &DevInfoData, SPDRP_DRIVER, + NULL, /* OUT PDWORD PropertyRegDataType */ + (PBYTE)pVuDev->szDriverRegName, + sizeof (pVuDev->szDriverRegName), + &cbDbgRequired)) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("SetupDiGetDeviceRegistryPropertyA, cbRequired (%d), was (%d), dwErr (%d)\n", cbDbgRequired, sizeof (pVuDev->szDriverRegName), dwErr)); + rc = VERR_GENERAL_FAILURE; + break; + } + + rc = usbLibVuDeviceValidate(pVuDev); + AssertRC(rc); + } while (0); + + RTMemFree(pIfDetailData); + return rc; +} + +static void usbLibVuFreeDevices(PVBOXUSB_DEV pDevInfos) +{ + while (pDevInfos) + { + PVBOXUSB_DEV pNext = pDevInfos->pNext; + RTMemFree(pDevInfos); + pDevInfos = pNext; + } +} + +static int usbLibVuGetDevices(PVBOXUSB_DEV *ppVuDevs, uint32_t *pcVuDevs) +{ + *ppVuDevs = NULL; + *pcVuDevs = 0; + + HDEVINFO hDevInfo = SetupDiGetClassDevs(&GUID_CLASS_VBOXUSB, + NULL, /* IN PCTSTR Enumerator */ + NULL, /* IN HWND hwndParent */ + (DIGCF_PRESENT | DIGCF_DEVICEINTERFACE) /* IN DWORD Flags */ + ); + if (hDevInfo == INVALID_HANDLE_VALUE) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("SetupDiGetClassDevs, dwErr (%d)\n", dwErr)); + return VERR_GENERAL_FAILURE; + } + + for (int i = 0; ; ++i) + { + SP_DEVICE_INTERFACE_DATA IfData; + IfData.cbSize = sizeof (IfData); + if (!SetupDiEnumDeviceInterfaces(hDevInfo, + NULL, /* IN PSP_DEVINFO_DATA DeviceInfoData */ + &GUID_CLASS_VBOXUSB, /* IN LPGUID InterfaceClassGuid */ + i, + &IfData)) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_NO_MORE_ITEMS) + break; + + AssertMsgFailed(("SetupDiEnumDeviceInterfaces, dwErr (%d), resuming\n", dwErr)); + continue; + } + + /* we've now got the IfData */ + PVBOXUSB_DEV pVuDev = (PVBOXUSB_DEV)RTMemAllocZ(sizeof (*pVuDev)); + if (!pVuDev) + { + AssertMsgFailed(("RTMemAllocZ failed, resuming\n")); + continue; + } + + int rc = usbLibVuDevicePopulate(pVuDev, hDevInfo, &IfData); + if (!RT_SUCCESS(rc)) + { + AssertMsgFailed(("usbLibVuDevicePopulate failed, rc (%d), resuming\n", rc)); + continue; + } + + pVuDev->pNext = *ppVuDevs; + *ppVuDevs = pVuDev; + ++*pcVuDevs; + } + + SetupDiDestroyDeviceInfoList(hDevInfo); + + return VINF_SUCCESS; +} + +static int usbLibDevPopulate(PUSBDEVICE pDev, PUSB_NODE_CONNECTION_INFORMATION_EX pConInfo, ULONG iPort, LPCSTR lpszDrvKeyName, LPCSTR lpszHubName, PVBOXUSB_STRING_DR_ENTRY pDrList) +{ + pDev->bcdUSB = pConInfo->DeviceDescriptor.bcdUSB; + pDev->bDeviceClass = pConInfo->DeviceDescriptor.bDeviceClass; + pDev->bDeviceSubClass = pConInfo->DeviceDescriptor.bDeviceSubClass; + pDev->bDeviceProtocol = pConInfo->DeviceDescriptor.bDeviceProtocol; + pDev->idVendor = pConInfo->DeviceDescriptor.idVendor; + pDev->idProduct = pConInfo->DeviceDescriptor.idProduct; + pDev->bcdDevice = pConInfo->DeviceDescriptor.bcdDevice; + pDev->bBus = 0; /** @todo figure out bBus on windows... */ + pDev->bPort = iPort; + /** @todo check which devices are used for primary input (keyboard & mouse) */ + if (!lpszDrvKeyName || *lpszDrvKeyName == 0) + pDev->enmState = USBDEVICESTATE_UNUSED; + else + pDev->enmState = USBDEVICESTATE_USED_BY_HOST_CAPTURABLE; + + /* Determine the speed the device is operating at. */ + switch (pConInfo->Speed) + { + case UsbLowSpeed: pDev->enmSpeed = USBDEVICESPEED_LOW; break; + case UsbFullSpeed: pDev->enmSpeed = USBDEVICESPEED_FULL; break; + case UsbHighSpeed: pDev->enmSpeed = USBDEVICESPEED_HIGH; break; + default: /* If we don't know, most likely it's something new. */ + case UsbSuperSpeed: pDev->enmSpeed = USBDEVICESPEED_SUPER; break; + } + /* Unfortunately USB_NODE_CONNECTION_INFORMATION_EX will not report UsbSuperSpeed, and + * it's not even defined in the Win7 DDK we use. So we go by the USB version, and + * luckily we know that USB3 must mean SuperSpeed. The USB3 spec guarantees this (9.6.1). + */ + if (pDev->bcdUSB >= 0x0300) + pDev->enmSpeed = USBDEVICESPEED_SUPER; + + int rc = RTStrAPrintf((char **)&pDev->pszAddress, "%s", lpszDrvKeyName); + if (rc < 0) + return VERR_NO_MEMORY; + pDev->pszBackend = RTStrDup("host"); + if (!pDev->pszBackend) + { + RTStrFree((char *)pDev->pszAddress); + return VERR_NO_STR_MEMORY; + } + pDev->pszHubName = RTStrDup(lpszHubName); + pDev->bNumConfigurations = 0; + pDev->u64SerialHash = 0; + + for (; pDrList; pDrList = pDrList->pNext) + { + char **ppszString = NULL; + if ( pConInfo->DeviceDescriptor.iManufacturer + && pDrList->iDr == pConInfo->DeviceDescriptor.iManufacturer) + ppszString = (char **)&pDev->pszManufacturer; + else if ( pConInfo->DeviceDescriptor.iProduct + && pDrList->iDr == pConInfo->DeviceDescriptor.iProduct) + ppszString = (char **)&pDev->pszProduct; + else if ( pConInfo->DeviceDescriptor.iSerialNumber + && pDrList->iDr == pConInfo->DeviceDescriptor.iSerialNumber) + ppszString = (char **)&pDev->pszSerialNumber; + if (ppszString) + { + rc = RTUtf16ToUtf8((PCRTUTF16)pDrList->StrDr.bString, ppszString); + if (RT_SUCCESS(rc)) + { + Assert(*ppszString); + USBLibPurgeEncoding(*ppszString); + + if (pDrList->iDr == pConInfo->DeviceDescriptor.iSerialNumber) + pDev->u64SerialHash = USBLibHashSerial(*ppszString); + } + else + { + AssertMsgFailed(("RTUtf16ToUtf8 failed, rc (%d), resuming\n", rc)); + *ppszString = NULL; + } + } + } + + return VINF_SUCCESS; +} + +static void usbLibDevStrFree(LPSTR lpszName) +{ + RTStrFree(lpszName); +} + +static int usbLibDevStrDriverKeyGet(HANDLE hHub, ULONG iPort, LPSTR* plpszName) +{ + USB_NODE_CONNECTION_DRIVERKEY_NAME Name; + DWORD cbReturned = 0; + Name.ConnectionIndex = iPort; + *plpszName = NULL; + if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, &Name, sizeof (Name), &Name, sizeof (Name), &cbReturned, NULL)) + { +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + DWORD dwErr = GetLastError(); + AssertMsgFailed(("DeviceIoControl 1 fail dwErr (%d)\n", dwErr)); +#endif + return VERR_GENERAL_FAILURE; + } + + if (Name.ActualLength < sizeof (Name)) + { + AssertFailed(); + return VERR_OUT_OF_RESOURCES; + } + + PUSB_NODE_CONNECTION_DRIVERKEY_NAME pName = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME)RTMemAllocZ(Name.ActualLength); + if (!pName) + { + AssertFailed(); + return VERR_OUT_OF_RESOURCES; + } + + int rc = VINF_SUCCESS; + pName->ConnectionIndex = iPort; + if (DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, pName, Name.ActualLength, pName, Name.ActualLength, &cbReturned, NULL)) + { + rc = RTUtf16ToUtf8Ex((PCRTUTF16)pName->DriverKeyName, pName->ActualLength / sizeof (WCHAR), plpszName, 0, NULL); + AssertRC(rc); + if (RT_SUCCESS(rc)) + rc = VINF_SUCCESS; + } + else + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("DeviceIoControl 2 fail dwErr (%d)\n", dwErr)); + rc = VERR_GENERAL_FAILURE; + } + RTMemFree(pName); + return rc; +} + +static int usbLibDevStrHubNameGet(HANDLE hHub, ULONG iPort, LPSTR* plpszName) +{ + USB_NODE_CONNECTION_NAME Name; + DWORD cbReturned = 0; + Name.ConnectionIndex = iPort; + *plpszName = NULL; + if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_NAME, &Name, sizeof (Name), &Name, sizeof (Name), &cbReturned, NULL)) + { + AssertFailed(); + return VERR_GENERAL_FAILURE; + } + + if (Name.ActualLength < sizeof (Name)) + { + AssertFailed(); + return VERR_OUT_OF_RESOURCES; + } + + PUSB_NODE_CONNECTION_NAME pName = (PUSB_NODE_CONNECTION_NAME)RTMemAllocZ(Name.ActualLength); + if (!pName) + { + AssertFailed(); + return VERR_OUT_OF_RESOURCES; + } + + int rc = VINF_SUCCESS; + pName->ConnectionIndex = iPort; + if (DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_NAME, pName, Name.ActualLength, pName, Name.ActualLength, &cbReturned, NULL)) + { + rc = RTUtf16ToUtf8Ex((PCRTUTF16)pName->NodeName, pName->ActualLength / sizeof (WCHAR), plpszName, 0, NULL); + AssertRC(rc); + if (RT_SUCCESS(rc)) + rc = VINF_SUCCESS; + } + else + { + AssertFailed(); + rc = VERR_GENERAL_FAILURE; + } + RTMemFree(pName); + return rc; +} + +static int usbLibDevStrRootHubNameGet(HANDLE hCtl, LPSTR* plpszName) +{ + USB_ROOT_HUB_NAME HubName; + DWORD cbReturned = 0; + *plpszName = NULL; + if (!DeviceIoControl(hCtl, IOCTL_USB_GET_ROOT_HUB_NAME, NULL, 0, &HubName, sizeof (HubName), &cbReturned, NULL)) + { + return VERR_GENERAL_FAILURE; + } + PUSB_ROOT_HUB_NAME pHubName = (PUSB_ROOT_HUB_NAME)RTMemAllocZ(HubName.ActualLength); + if (!pHubName) + return VERR_OUT_OF_RESOURCES; + + int rc = VINF_SUCCESS; + if (DeviceIoControl(hCtl, IOCTL_USB_GET_ROOT_HUB_NAME, NULL, 0, pHubName, HubName.ActualLength, &cbReturned, NULL)) + { + rc = RTUtf16ToUtf8Ex((PCRTUTF16)pHubName->RootHubName, pHubName->ActualLength / sizeof (WCHAR), plpszName, 0, NULL); + AssertRC(rc); + if (RT_SUCCESS(rc)) + rc = VINF_SUCCESS; + } + else + { + rc = VERR_GENERAL_FAILURE; + } + RTMemFree(pHubName); + return rc; +} + +static int usbLibDevCfgDrGet(HANDLE hHub, ULONG iPort, ULONG iDr, PUSB_CONFIGURATION_DESCRIPTOR *ppDr) +{ + *ppDr = NULL; + + char Buf[sizeof (USB_DESCRIPTOR_REQUEST) + sizeof (USB_CONFIGURATION_DESCRIPTOR)]; + memset(&Buf, 0, sizeof (Buf)); + + PUSB_DESCRIPTOR_REQUEST pCfgDrRq = (PUSB_DESCRIPTOR_REQUEST)Buf; + PUSB_CONFIGURATION_DESCRIPTOR pCfgDr = (PUSB_CONFIGURATION_DESCRIPTOR)(Buf + sizeof (*pCfgDrRq)); + + pCfgDrRq->ConnectionIndex = iPort; + pCfgDrRq->SetupPacket.wValue = (USB_CONFIGURATION_DESCRIPTOR_TYPE << 8) | iDr; + pCfgDrRq->SetupPacket.wLength = (USHORT)(sizeof (USB_CONFIGURATION_DESCRIPTOR)); + DWORD cbReturned = 0; + if (!DeviceIoControl(hHub, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, pCfgDrRq, sizeof (Buf), + pCfgDrRq, sizeof (Buf), + &cbReturned, NULL)) + { + DWORD dwErr = GetLastError(); + LogRelFunc(("DeviceIoControl 1 fail dwErr (%d)\n", dwErr)); +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + AssertFailed(); +#endif + return VERR_GENERAL_FAILURE; + } + + if (sizeof (Buf) != cbReturned) + { + AssertFailed(); + return VERR_GENERAL_FAILURE; + } + + if (pCfgDr->wTotalLength < sizeof (USB_CONFIGURATION_DESCRIPTOR)) + { + AssertFailed(); + return VERR_GENERAL_FAILURE; + } + + DWORD cbRq = sizeof (USB_DESCRIPTOR_REQUEST) + pCfgDr->wTotalLength; + PUSB_DESCRIPTOR_REQUEST pRq = (PUSB_DESCRIPTOR_REQUEST)RTMemAllocZ(cbRq); + Assert(pRq); + if (!pRq) + return VERR_OUT_OF_RESOURCES; + + int rc = VERR_GENERAL_FAILURE; + do + { + PUSB_CONFIGURATION_DESCRIPTOR pDr = (PUSB_CONFIGURATION_DESCRIPTOR)(pRq + 1); + pRq->ConnectionIndex = iPort; + pRq->SetupPacket.wValue = (USB_CONFIGURATION_DESCRIPTOR_TYPE << 8) | iDr; + pRq->SetupPacket.wLength = (USHORT)(cbRq - sizeof (USB_DESCRIPTOR_REQUEST)); + if (!DeviceIoControl(hHub, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, pRq, cbRq, + pRq, cbRq, + &cbReturned, NULL)) + { + DWORD dwErr = GetLastError(); + LogRelFunc(("DeviceIoControl 2 fail dwErr (%d)\n", dwErr)); +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + AssertFailed(); +#endif + break; + } + + if (cbRq != cbReturned) + { + AssertFailed(); + break; + } + + if (pDr->wTotalLength != cbRq - sizeof (USB_DESCRIPTOR_REQUEST)) + { + AssertFailed(); + break; + } + + *ppDr = pDr; + return VINF_SUCCESS; + } while (0); + + RTMemFree(pRq); + return rc; +} + +static void usbLibDevCfgDrFree(PUSB_CONFIGURATION_DESCRIPTOR pDr) +{ + Assert(pDr); + PUSB_DESCRIPTOR_REQUEST pRq = ((PUSB_DESCRIPTOR_REQUEST)pDr)-1; + RTMemFree(pRq); +} + +static int usbLibDevStrDrEntryGet(HANDLE hHub, ULONG iPort, ULONG iDr, USHORT idLang, PVBOXUSB_STRING_DR_ENTRY *ppList) +{ + char szBuf[sizeof (USB_DESCRIPTOR_REQUEST) + MAXIMUM_USB_STRING_LENGTH]; + RT_ZERO(szBuf); + + PUSB_DESCRIPTOR_REQUEST pRq = (PUSB_DESCRIPTOR_REQUEST)szBuf; + PUSB_STRING_DESCRIPTOR pDr = (PUSB_STRING_DESCRIPTOR)(szBuf + sizeof (*pRq)); + RT_BZERO(pDr, sizeof(USB_STRING_DESCRIPTOR)); + + pRq->ConnectionIndex = iPort; + pRq->SetupPacket.wValue = (USB_STRING_DESCRIPTOR_TYPE << 8) | iDr; + pRq->SetupPacket.wIndex = idLang; + pRq->SetupPacket.wLength = sizeof (szBuf) - sizeof (*pRq); + + DWORD cbReturned = 0; + if (!DeviceIoControl(hHub, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, pRq, sizeof (szBuf), + pRq, sizeof(szBuf), + &cbReturned, NULL)) + { + DWORD dwErr = GetLastError(); + LogRel(("Getting USB descriptor failed with error %ld\n", dwErr)); + return RTErrConvertFromWin32(dwErr); + } + + /* Wrong descriptor type at the requested port index? Bail out. */ + if (pDr->bDescriptorType != USB_STRING_DESCRIPTOR_TYPE) + return VERR_NOT_FOUND; + + /* Some more sanity checks. */ + if ( (cbReturned < sizeof (*pDr) + 2) + || (!!(pDr->bLength % 2)) + || (pDr->bLength != cbReturned - sizeof(*pRq))) + { + AssertMsgFailed(("Sanity check failed for string descriptor: cbReturned=%RI32, cbDevReq=%zu, type=%RU8, len=%RU8, port=%RU32, index=%RU32, lang=%RU32\n", + cbReturned, sizeof(*pRq), pDr->bDescriptorType, pDr->bLength, iPort, iDr, idLang)); + return VERR_INVALID_PARAMETER; + } + + PVBOXUSB_STRING_DR_ENTRY pEntry = + (PVBOXUSB_STRING_DR_ENTRY)RTMemAllocZ(sizeof(VBOXUSB_STRING_DR_ENTRY) + pDr->bLength + 2); + AssertPtr(pEntry); + if (!pEntry) + return VERR_NO_MEMORY; + + pEntry->pNext = *ppList; + pEntry->iDr = iDr; + pEntry->idLang = idLang; + memcpy(&pEntry->StrDr, pDr, pDr->bLength); + + *ppList = pEntry; + + return VINF_SUCCESS; +} + +static void usbLibDevStrDrEntryFree(PVBOXUSB_STRING_DR_ENTRY pDr) +{ + RTMemFree(pDr); +} + +static void usbLibDevStrDrEntryFreeList(PVBOXUSB_STRING_DR_ENTRY pDr) +{ + while (pDr) + { + PVBOXUSB_STRING_DR_ENTRY pNext = pDr->pNext; + usbLibDevStrDrEntryFree(pDr); + pDr = pNext; + } +} + +static int usbLibDevStrDrEntryGetForLangs(HANDLE hHub, ULONG iPort, ULONG iDr, ULONG cIdLang, const USHORT *pIdLang, PVBOXUSB_STRING_DR_ENTRY *ppList) +{ + for (ULONG i = 0; i < cIdLang; ++i) + { + usbLibDevStrDrEntryGet(hHub, iPort, iDr, pIdLang[i], ppList); + } + return VINF_SUCCESS; +} + +static int usbLibDevStrDrEntryGetAll(HANDLE hHub, ULONG iPort, PUSB_DEVICE_DESCRIPTOR pDevDr, PUSB_CONFIGURATION_DESCRIPTOR pCfgDr, PVBOXUSB_STRING_DR_ENTRY *ppList) +{ + /* Read string descriptor zero to determine what languages are available. */ + int rc = usbLibDevStrDrEntryGet(hHub, iPort, 0, 0, ppList); + if (RT_FAILURE(rc)) + return rc; + + PUSB_STRING_DESCRIPTOR pLangStrDr = &(*ppList)->StrDr; + USHORT *pIdLang = pLangStrDr->bString; + ULONG cIdLang = (pLangStrDr->bLength - RT_OFFSETOF(USB_STRING_DESCRIPTOR, bString)) / sizeof (*pIdLang); + + if (pDevDr->iManufacturer) + { + rc = usbLibDevStrDrEntryGetForLangs(hHub, iPort, pDevDr->iManufacturer, cIdLang, pIdLang, ppList); + AssertRC(rc); + } + + if (pDevDr->iProduct) + { + rc = usbLibDevStrDrEntryGetForLangs(hHub, iPort, pDevDr->iProduct, cIdLang, pIdLang, ppList); + AssertRC(rc); + } + + if (pDevDr->iSerialNumber) + { + rc = usbLibDevStrDrEntryGetForLangs(hHub, iPort, pDevDr->iSerialNumber, cIdLang, pIdLang, ppList); + AssertRC(rc); + } + + PUCHAR pCur = (PUCHAR)pCfgDr; + PUCHAR pEnd = pCur + pCfgDr->wTotalLength; + while (pCur + sizeof (USB_COMMON_DESCRIPTOR) <= pEnd) + { + PUSB_COMMON_DESCRIPTOR pCmnDr = (PUSB_COMMON_DESCRIPTOR)pCur; + if (pCur + pCmnDr->bLength > pEnd) + { + AssertFailed(); + break; + } + + /* This is invalid but was seen with a TerraTec Aureon 7.1 USB sound card. */ + if (!pCmnDr->bLength) + break; + + switch (pCmnDr->bDescriptorType) + { + case USB_CONFIGURATION_DESCRIPTOR_TYPE: + { + if (pCmnDr->bLength != sizeof (USB_CONFIGURATION_DESCRIPTOR)) + { + AssertFailed(); + break; + } + PUSB_CONFIGURATION_DESCRIPTOR pCurCfgDr = (PUSB_CONFIGURATION_DESCRIPTOR)pCmnDr; + if (!pCurCfgDr->iConfiguration) + break; + rc = usbLibDevStrDrEntryGetForLangs(hHub, iPort, pCurCfgDr->iConfiguration, cIdLang, pIdLang, ppList); + AssertRC(rc); + break; + } + case USB_INTERFACE_DESCRIPTOR_TYPE: + { + if (pCmnDr->bLength != sizeof (USB_INTERFACE_DESCRIPTOR) && pCmnDr->bLength != sizeof (USB_INTERFACE_DESCRIPTOR2)) + { + AssertFailed(); + break; + } + PUSB_INTERFACE_DESCRIPTOR pCurIfDr = (PUSB_INTERFACE_DESCRIPTOR)pCmnDr; + if (!pCurIfDr->iInterface) + break; + rc = usbLibDevStrDrEntryGetForLangs(hHub, iPort, pCurIfDr->iInterface, cIdLang, pIdLang, ppList); + AssertRC(rc); + break; + } + default: + break; + } + + pCur = pCur + pCmnDr->bLength; + } + + return VINF_SUCCESS; +} + +static int usbLibDevGetHubDevices(LPCSTR lpszName, PUSBDEVICE *ppDevs, uint32_t *pcDevs); + +static int usbLibDevGetHubPortDevices(HANDLE hHub, LPCSTR lpcszHubName, ULONG iPort, PUSBDEVICE *ppDevs, uint32_t *pcDevs) +{ + int rc = VINF_SUCCESS; + char Buf[sizeof (USB_NODE_CONNECTION_INFORMATION_EX) + (sizeof (USB_PIPE_INFO) * 20)]; + PUSB_NODE_CONNECTION_INFORMATION_EX pConInfo = (PUSB_NODE_CONNECTION_INFORMATION_EX)Buf; + //PUSB_PIPE_INFO paPipeInfo = (PUSB_PIPE_INFO)(Buf + sizeof (PUSB_NODE_CONNECTION_INFORMATION_EX)); + DWORD cbReturned = 0; + memset(&Buf, 0, sizeof (Buf)); + pConInfo->ConnectionIndex = iPort; + if (!DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, + pConInfo, sizeof (Buf), + pConInfo, sizeof (Buf), + &cbReturned, NULL)) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsg(dwErr == ERROR_DEVICE_NOT_CONNECTED, (__FUNCTION__": DeviceIoControl failed dwErr (%d)\n", dwErr)); + return VERR_GENERAL_FAILURE; + } + + if (pConInfo->ConnectionStatus != DeviceConnected) + { + /* just ignore & return success */ + return VWRN_INVALID_HANDLE; + } + + if (pConInfo->DeviceIsHub) + { + LPSTR lpszHubName = NULL; + rc = usbLibDevStrHubNameGet(hHub, iPort, &lpszHubName); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + rc = usbLibDevGetHubDevices(lpszHubName, ppDevs, pcDevs); + usbLibDevStrFree(lpszHubName); + AssertRC(rc); + return rc; + } + /* ignore this err */ + return VINF_SUCCESS; + } + + bool fFreeNameBuf = true; + char nameEmptyBuf = '\0'; + LPSTR lpszName = NULL; + rc = usbLibDevStrDriverKeyGet(hHub, iPort, &lpszName); + Assert(!!lpszName == !!RT_SUCCESS(rc)); + if (!lpszName) + { + lpszName = &nameEmptyBuf; + fFreeNameBuf = false; + } + + PUSB_CONFIGURATION_DESCRIPTOR pCfgDr = NULL; + PVBOXUSB_STRING_DR_ENTRY pList = NULL; + rc = usbLibDevCfgDrGet(hHub, iPort, 0, &pCfgDr); + if (pCfgDr) + { + rc = usbLibDevStrDrEntryGetAll(hHub, iPort, &pConInfo->DeviceDescriptor, pCfgDr, &pList); +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + AssertRC(rc); +#endif + } + + PUSBDEVICE pDev = (PUSBDEVICE)RTMemAllocZ(sizeof (*pDev)); + if (RT_LIKELY(pDev)) + { + rc = usbLibDevPopulate(pDev, pConInfo, iPort, lpszName, lpcszHubName, pList); + if (RT_SUCCESS(rc)) + { + pDev->pNext = *ppDevs; + *ppDevs = pDev; + ++*pcDevs; + } + else + RTMemFree(pDev); + } + else + rc = VERR_NO_MEMORY; + + if (pCfgDr) + usbLibDevCfgDrFree(pCfgDr); + if (fFreeNameBuf) + { + Assert(lpszName); + usbLibDevStrFree(lpszName); + } + if (pList) + usbLibDevStrDrEntryFreeList(pList); + + return rc; +} + +static int usbLibDevGetHubDevices(LPCSTR lpszName, PUSBDEVICE *ppDevs, uint32_t *pcDevs) +{ + LPSTR lpszDevName = (LPSTR)RTMemAllocZ(strlen(lpszName) + sizeof("\\\\.\\")); + HANDLE hDev = INVALID_HANDLE_VALUE; + Assert(lpszDevName); + if (!lpszDevName) + { + AssertFailed(); + return VERR_OUT_OF_RESOURCES; + } + + int rc = VINF_SUCCESS; + strcpy(lpszDevName, "\\\\.\\"); + strcpy(lpszDevName + sizeof("\\\\.\\") - sizeof (lpszDevName[0]), lpszName); + do + { + DWORD cbReturned = 0; + hDev = CreateFile(lpszDevName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); + if (hDev == INVALID_HANDLE_VALUE) + { + AssertFailed(); + break; + } + + USB_NODE_INFORMATION NodeInfo; + memset(&NodeInfo, 0, sizeof (NodeInfo)); + if (!DeviceIoControl(hDev, IOCTL_USB_GET_NODE_INFORMATION, + &NodeInfo, sizeof (NodeInfo), + &NodeInfo, sizeof (NodeInfo), + &cbReturned, NULL)) + { + AssertFailed(); + break; + } + + for (ULONG i = 1; i <= NodeInfo.u.HubInformation.HubDescriptor.bNumberOfPorts; ++i) + { + /* Just skip devices for which we failed to create the device structure. */ + usbLibDevGetHubPortDevices(hDev, lpszName, i, ppDevs, pcDevs); + } + } while (0); + + if (hDev != INVALID_HANDLE_VALUE) + CloseHandle(hDev); + + RTMemFree(lpszDevName); + + return rc; +} + +static int usbLibDevGetDevices(PUSBDEVICE *ppDevs, uint32_t *pcDevs) +{ + char CtlName[16]; + int rc = VINF_SUCCESS; + + for (int i = 0; i < 10; ++i) + { + RTStrPrintf(CtlName, sizeof(CtlName), "\\\\.\\HCD%d", i); + HANDLE hCtl = CreateFile(CtlName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL); + if (hCtl != INVALID_HANDLE_VALUE) + { + char* lpszName; + rc = usbLibDevStrRootHubNameGet(hCtl, &lpszName); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + rc = usbLibDevGetHubDevices(lpszName, ppDevs, pcDevs); + AssertRC(rc); + usbLibDevStrFree(lpszName); + } + CloseHandle(hCtl); + if (RT_FAILURE(rc)) + break; + } + } + return VINF_SUCCESS; +} + +static int usbLibMonDevicesCmp(PUSBDEVICE pDev, PVBOXUSB_DEV pDevInfo) +{ + int iDiff; + iDiff = strcmp(pDev->pszAddress, pDevInfo->szDriverRegName); + return iDiff; +} + +static int usbLibMonDevicesUpdate(PVBOXUSBGLOBALSTATE pGlobal, PUSBDEVICE pDevs, PVBOXUSB_DEV pDevInfos) +{ + + PUSBDEVICE pDevsHead = pDevs; + for (; pDevInfos; pDevInfos = pDevInfos->pNext) + { + for (pDevs = pDevsHead; pDevs; pDevs = pDevs->pNext) + { + if (usbLibMonDevicesCmp(pDevs, pDevInfos)) + continue; + + if (!pDevInfos->szDriverRegName[0]) + { + AssertFailed(); + break; + } + + USBSUP_GETDEV Dev = {0}; + HANDLE hDev = CreateFile(pDevInfos->szName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE | FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL); + if (hDev == INVALID_HANDLE_VALUE) + { + AssertFailed(); + break; + } + + DWORD cbReturned = 0; + if (!DeviceIoControl(hDev, SUPUSB_IOCTL_GET_DEVICE, &Dev, sizeof (Dev), &Dev, sizeof (Dev), &cbReturned, NULL)) + { +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + DWORD dwErr = GetLastError(); NOREF(dwErr); + /* ERROR_DEVICE_NOT_CONNECTED -> device was removed just now */ + AssertMsg(dwErr == ERROR_DEVICE_NOT_CONNECTED, (__FUNCTION__": DeviceIoControl failed dwErr (%d)\n", dwErr)); +#endif + Log(("SUPUSB_IOCTL_GET_DEVICE: DeviceIoControl no longer connected\n")); + CloseHandle(hDev); + break; + } + + /* we must not close the handle until we request for the device state from the monitor to ensure + * the device handle returned by the device driver does not disappear */ + Assert(Dev.hDevice); + USBSUP_GETDEV_MON MonInfo; + HVBOXUSBDEVUSR hDevice = Dev.hDevice; + if (!DeviceIoControl(pGlobal->hMonitor, SUPUSBFLT_IOCTL_GET_DEVICE, &hDevice, sizeof (hDevice), &MonInfo, sizeof (MonInfo), &cbReturned, NULL)) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + /* ERROR_DEVICE_NOT_CONNECTED -> device was removed just now */ + AssertMsgFailed(("Monitor DeviceIoControl failed dwErr (%d)\n", dwErr)); + Log(("SUPUSBFLT_IOCTL_GET_DEVICE: DeviceIoControl no longer connected\n")); + CloseHandle(hDev); + break; + } + + CloseHandle(hDev); + + /* success!! update device info */ + /* ensure the state returned is valid */ + Assert( MonInfo.enmState == USBDEVICESTATE_USED_BY_HOST + || MonInfo.enmState == USBDEVICESTATE_USED_BY_HOST_CAPTURABLE + || MonInfo.enmState == USBDEVICESTATE_UNUSED + || MonInfo.enmState == USBDEVICESTATE_HELD_BY_PROXY + || MonInfo.enmState == USBDEVICESTATE_USED_BY_GUEST); + pDevs->enmState = MonInfo.enmState; + + if (pDevs->enmState != USBDEVICESTATE_USED_BY_HOST) + { + /* only set the interface name if device can be grabbed */ + RTStrFree(pDevs->pszAltAddress); + pDevs->pszAltAddress = (char*)pDevs->pszAddress; + pDevs->pszAddress = RTStrDup(pDevInfos->szName); + } +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + else + { + /* dbg breakpoint */ + AssertFailed(); + } +#endif + + /* we've found the device, break in any way */ + break; + } + } + + return VINF_SUCCESS; +} + +static int usbLibGetDevices(PVBOXUSBGLOBALSTATE pGlobal, PUSBDEVICE *ppDevs, uint32_t *pcDevs) +{ + *ppDevs = NULL; + *pcDevs = 0; + + int rc = usbLibDevGetDevices(ppDevs, pcDevs); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + PVBOXUSB_DEV pDevInfos = NULL; + uint32_t cDevInfos = 0; + rc = usbLibVuGetDevices(&pDevInfos, &cDevInfos); + AssertRC(rc); + if (RT_SUCCESS(rc)) + { + rc = usbLibMonDevicesUpdate(pGlobal, *ppDevs, pDevInfos); + AssertRC(rc); + usbLibVuFreeDevices(pDevInfos); + } + + return VINF_SUCCESS; + } + return rc; +} + +AssertCompile(INFINITE == RT_INDEFINITE_WAIT); +static int usbLibStateWaitChange(PVBOXUSBGLOBALSTATE pGlobal, RTMSINTERVAL cMillies) +{ + HANDLE ahEvents[] = {pGlobal->hNotifyEvent, pGlobal->hInterruptEvent}; + DWORD dwResult = WaitForMultipleObjects(RT_ELEMENTS(ahEvents), ahEvents, + FALSE, /* BOOL bWaitAll */ + cMillies); + + switch (dwResult) + { + case WAIT_OBJECT_0: + return VINF_SUCCESS; + case WAIT_OBJECT_0 + 1: + return VERR_INTERRUPTED; + case WAIT_TIMEOUT: + return VERR_TIMEOUT; + default: + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("WaitForMultipleObjects failed, dwErr (%d)\n", dwErr)); + return VERR_GENERAL_FAILURE; + } + } +} + +AssertCompile(RT_INDEFINITE_WAIT == INFINITE); +AssertCompile(sizeof (RTMSINTERVAL) == sizeof (DWORD)); +USBLIB_DECL(int) USBLibWaitChange(RTMSINTERVAL msWaitTimeout) +{ + return usbLibStateWaitChange(&g_VBoxUsbGlobal, msWaitTimeout); +} + +static int usbLibInterruptWaitChange(PVBOXUSBGLOBALSTATE pGlobal) +{ + BOOL fRc = SetEvent(pGlobal->hInterruptEvent); + if (!fRc) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("SetEvent failed, dwErr (%d)\n", dwErr)); + return VERR_GENERAL_FAILURE; + } + return VINF_SUCCESS; +} + +USBLIB_DECL(int) USBLibInterruptWaitChange(void) +{ + return usbLibInterruptWaitChange(&g_VBoxUsbGlobal); +} + +/* +USBLIB_DECL(bool) USBLibHasPendingDeviceChanges(void) +{ + int rc = USBLibWaitChange(0); + return rc == VINF_SUCCESS; +} +*/ + +USBLIB_DECL(int) USBLibGetDevices(PUSBDEVICE *ppDevices, uint32_t *pcbNumDevices) +{ + Assert(g_VBoxUsbGlobal.hMonitor != INVALID_HANDLE_VALUE); + return usbLibGetDevices(&g_VBoxUsbGlobal, ppDevices, pcbNumDevices); +} + +USBLIB_DECL(void *) USBLibAddFilter(PCUSBFILTER pFilter) +{ + USBSUP_FLTADDOUT FltAddRc; + DWORD cbReturned = 0; + + if (g_VBoxUsbGlobal.hMonitor == INVALID_HANDLE_VALUE) + { +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + AssertFailed(); +#endif + return NULL; + } + + Log(("usblibInsertFilter: Manufacturer=%s Product=%s Serial=%s\n", + USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>")); + + if (!DeviceIoControl(g_VBoxUsbGlobal.hMonitor, SUPUSBFLT_IOCTL_ADD_FILTER, + (LPVOID)pFilter, sizeof(*pFilter), + &FltAddRc, sizeof(FltAddRc), + &cbReturned, NULL)) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("DeviceIoControl failed with dwErr (%d(\n", dwErr)); + return NULL; + } + + if (RT_FAILURE(FltAddRc.rc)) + { + AssertMsgFailed(("Adding filter failed with %d\n", FltAddRc.rc)); + return NULL; + } + return (void *)FltAddRc.uId; +} + + +USBLIB_DECL(void) USBLibRemoveFilter(void *pvId) +{ + uintptr_t uId; + DWORD cbReturned = 0; + + if (g_VBoxUsbGlobal.hMonitor == INVALID_HANDLE_VALUE) + { +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + AssertFailed(); +#endif + return; + } + + Log(("usblibRemoveFilter %p\n", pvId)); + + uId = (uintptr_t)pvId; + if (!DeviceIoControl(g_VBoxUsbGlobal.hMonitor, SUPUSBFLT_IOCTL_REMOVE_FILTER, &uId, sizeof(uId), NULL, 0,&cbReturned, NULL)) + AssertMsgFailed(("DeviceIoControl failed with LastError=%Rwa\n", GetLastError())); +} + +USBLIB_DECL(int) USBLibRunFilters(void) +{ + DWORD cbReturned = 0; + + Assert(g_VBoxUsbGlobal.hMonitor != INVALID_HANDLE_VALUE); + + if (!DeviceIoControl(g_VBoxUsbGlobal.hMonitor, SUPUSBFLT_IOCTL_RUN_FILTERS, + NULL, 0, + NULL, 0, + &cbReturned, NULL)) + { + DWORD dwErr = GetLastError(); + AssertMsgFailed(("DeviceIoControl failed with dwErr (%d(\n", dwErr)); + return RTErrConvertFromWin32(dwErr); + } + + return VINF_SUCCESS; +} + + +#ifdef VBOX_USB_USE_DEVICE_NOTIFICATION + +static VOID CALLBACK usbLibTimerCallback(__in PVOID lpParameter, __in BOOLEAN TimerOrWaitFired) +{ + RT_NOREF2(lpParameter, TimerOrWaitFired); + SetEvent(g_VBoxUsbGlobal.hNotifyEvent); +} + +static void usbLibOnDeviceChange(void) +{ + /* we're getting series of events like that especially on device re-attach + * (i.e. first for device detach and then for device attach) + * unfortunately the event does not tell us what actually happened. + * To avoid extra notifications, we delay the SetEvent via a timer + * and update the timer if additional notification comes before the timer fires + * */ + if (g_VBoxUsbGlobal.hTimer) + { + if (!DeleteTimerQueueTimer(g_VBoxUsbGlobal.hTimerQueue, g_VBoxUsbGlobal.hTimer, NULL)) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsg(dwErr == ERROR_IO_PENDING, ("DeleteTimerQueueTimer failed, dwErr (%d)\n", dwErr)); + } + } + + if (!CreateTimerQueueTimer(&g_VBoxUsbGlobal.hTimer, g_VBoxUsbGlobal.hTimerQueue, + usbLibTimerCallback, + NULL, + 500, /* ms*/ + 0, + WT_EXECUTEONLYONCE)) + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("CreateTimerQueueTimer failed, dwErr (%d)\n", dwErr)); + + /* call it directly */ + usbLibTimerCallback(NULL, FALSE); + } +} + +static LRESULT CALLBACK usbLibWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + switch (uMsg) + { + case WM_DEVICECHANGE: + if (wParam == DBT_DEVNODES_CHANGED) + { + /* we notify change any device arivals/removals on the system + * and let the client decide whether the usb change actually happened + * so far this is more clean than reporting events from the Monitor + * because monitor sees only PDO arrivals/removals, + * and by the time PDO is created, device can not + * be yet started and fully functional, + * so usblib won't be able to pick it up + * */ + + usbLibOnDeviceChange(); + } + break; + case WM_DESTROY: + { + PostQuitMessage(0); + return 0; + } + } + return DefWindowProc (hwnd, uMsg, wParam, lParam); +} + +/** @todo r=bird: Use an IPRT thread? */ +static DWORD WINAPI usbLibMsgThreadProc(__in LPVOID lpParameter) +{ + static LPCSTR s_szVBoxUsbWndClassName = "VBoxUsbLibClass"; + const HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL); + RT_NOREF1(lpParameter); + + Assert(g_VBoxUsbGlobal.hWnd == NULL); + g_VBoxUsbGlobal.hWnd = NULL; + + /* + * Register the Window Class and create the hidden window. + */ + WNDCLASS wc; + wc.style = 0; + wc.lpfnWndProc = usbLibWndProc; + wc.cbClsExtra = 0; + wc.cbWndExtra = sizeof(void *); + wc.hInstance = hInstance; + wc.hIcon = NULL; + wc.hCursor = NULL; + wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1); + wc.lpszMenuName = NULL; + wc.lpszClassName = s_szVBoxUsbWndClassName; + ATOM atomWindowClass = RegisterClass(&wc); + if (atomWindowClass != 0) + g_VBoxUsbGlobal.hWnd = CreateWindowEx(WS_EX_TOOLWINDOW | WS_EX_TRANSPARENT | WS_EX_TOPMOST, + s_szVBoxUsbWndClassName, s_szVBoxUsbWndClassName, + WS_POPUPWINDOW, + -200, -200, 100, 100, NULL, NULL, hInstance, NULL); + else + AssertMsgFailed(("RegisterClass failed, last error %u\n", GetLastError())); + + /* + * Signal the creator thread. + */ + ASMCompilerBarrier(); + SetEvent(g_VBoxUsbGlobal.hNotifyEvent); + + if (g_VBoxUsbGlobal.hWnd) + { + /* Make sure it's really hidden. */ + SetWindowPos(g_VBoxUsbGlobal.hWnd, HWND_TOPMOST, -200, -200, 0, 0, + SWP_NOACTIVATE | SWP_HIDEWINDOW | SWP_NOCOPYBITS | SWP_NOREDRAW | SWP_NOSIZE); + + /* + * The message pump. + */ + MSG msg; + BOOL fRet; + while ((fRet = GetMessage(&msg, NULL, 0, 0)) > 0) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + Assert(fRet >= 0); + } + + if (atomWindowClass != NULL) + UnregisterClass(s_szVBoxUsbWndClassName, hInstance); + + return 0; +} + +#endif /* VBOX_USB_USE_DEVICE_NOTIFICATION */ + +/** + * Initialize the USB library + * + * @returns VBox status code. + */ +USBLIB_DECL(int) USBLibInit(void) +{ + int rc = VERR_GENERAL_FAILURE; + + Log(("usbproxy: usbLibInit\n")); + + RT_ZERO(g_VBoxUsbGlobal); + g_VBoxUsbGlobal.hMonitor = INVALID_HANDLE_VALUE; + + /* + * Create the notification and interrupt event before opening the device. + */ + g_VBoxUsbGlobal.hNotifyEvent = CreateEvent(NULL, /* LPSECURITY_ATTRIBUTES lpEventAttributes */ + FALSE, /* BOOL bManualReset */ +#ifndef VBOX_USB_USE_DEVICE_NOTIFICATION + TRUE, /* BOOL bInitialState */ +#else + FALSE, /* set to false since it will be initially used for notification thread startup sync */ +#endif + NULL /* LPCTSTR lpName */); + if (g_VBoxUsbGlobal.hNotifyEvent) + { + g_VBoxUsbGlobal.hInterruptEvent = CreateEvent(NULL, /* LPSECURITY_ATTRIBUTES lpEventAttributes */ + FALSE, /* BOOL bManualReset */ + FALSE, /* BOOL bInitialState */ + NULL /* LPCTSTR lpName */); + if (g_VBoxUsbGlobal.hInterruptEvent) + { + /* + * Open the USB monitor device, starting if needed. + */ + g_VBoxUsbGlobal.hMonitor = CreateFile(USBMON_DEVICE_NAME, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_SYSTEM, + NULL); + + if (g_VBoxUsbGlobal.hMonitor == INVALID_HANDLE_VALUE) + { + HRESULT hr = VBoxDrvCfgSvcStart(USBMON_SERVICE_NAME_W); + if (hr == S_OK) + { + g_VBoxUsbGlobal.hMonitor = CreateFile(USBMON_DEVICE_NAME, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_SYSTEM, + NULL); + if (g_VBoxUsbGlobal.hMonitor == INVALID_HANDLE_VALUE) + { + DWORD dwErr = GetLastError(); + LogRelFunc(("CreateFile failed dwErr(%d)\n", dwErr)); + rc = VERR_FILE_NOT_FOUND; + } + } + } + + if (g_VBoxUsbGlobal.hMonitor != INVALID_HANDLE_VALUE) + { + /* + * Check the USB monitor version. + * + * Drivers are backwards compatible within the same major + * number. We consider the minor version number this library + * is compiled with to be the minimum required by the driver. + * This is by reasoning that the library uses the full feature + * set of the driver it's written for. + */ + USBSUP_VERSION Version = {0}; + DWORD cbReturned = 0; + if (DeviceIoControl(g_VBoxUsbGlobal.hMonitor, SUPUSBFLT_IOCTL_GET_VERSION, + NULL, 0, + &Version, sizeof (Version), + &cbReturned, NULL)) + { + if ( Version.u32Major == USBMON_MAJOR_VERSION +#if USBMON_MINOR_VERSION != 0 + && Version.u32Minor >= USBMON_MINOR_VERSION +#endif + ) + { +#ifndef VBOX_USB_USE_DEVICE_NOTIFICATION + /* + * Tell the monitor driver which event object to use + * for notifications. + */ + USBSUP_SET_NOTIFY_EVENT SetEvent = {0}; + Assert(g_VBoxUsbGlobal.hNotifyEvent); + SetEvent.u.hEvent = g_VBoxUsbGlobal.hNotifyEvent; + if (DeviceIoControl(g_VBoxUsbGlobal.hMonitor, SUPUSBFLT_IOCTL_SET_NOTIFY_EVENT, + &SetEvent, sizeof(SetEvent), + &SetEvent, sizeof(SetEvent), + &cbReturned, NULL)) + { + rc = SetEvent.u.rc; + if (RT_SUCCESS(rc)) + { + /* + * We're DONE! + */ + return VINF_SUCCESS; + } + + AssertMsgFailed(("SetEvent failed, %Rrc (%d)\n", rc, rc)); + } + else + { + DWORD dwErr = GetLastError(); + AssertMsgFailed(("SetEvent Ioctl failed, dwErr (%d)\n", dwErr)); + rc = VERR_VERSION_MISMATCH; + } +#else + /* + * We can not use USB Mon for reliable device add/remove tracking + * since once USB Mon is notified about PDO creation and/or IRP_MN_START_DEVICE, + * the function device driver may still do some initialization, which might result in + * notifying too early. + * Instead we use WM_DEVICECHANGE + DBT_DEVNODES_CHANGED to make Windows notify us about + * device arivals/removals. + * Since WM_DEVICECHANGE is a window message, create a dedicated thread to be used for WndProc and stuff. + * The thread would create a window, track windows messages and call usbLibOnDeviceChange on WM_DEVICECHANGE arrival. + * See comments in usbLibOnDeviceChange function for detail about using the timer queue. + */ + g_VBoxUsbGlobal.hTimerQueue = CreateTimerQueue(); + if (g_VBoxUsbGlobal.hTimerQueue) + { + g_VBoxUsbGlobal.hThread = CreateThread( + NULL, /*__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, */ + 0, /*__in SIZE_T dwStackSize, */ + usbLibMsgThreadProc, /*__in LPTHREAD_START_ROUTINE lpStartAddress,*/ + NULL, /*__in_opt LPVOID lpParameter,*/ + 0, /*__in DWORD dwCreationFlags,*/ + NULL /*__out_opt LPDWORD lpThreadId*/ + ); + if (g_VBoxUsbGlobal.hThread) + { + DWORD dwResult = WaitForSingleObject(g_VBoxUsbGlobal.hNotifyEvent, INFINITE); + Assert(dwResult == WAIT_OBJECT_0); + if (g_VBoxUsbGlobal.hWnd) + { + /* + * We're DONE! + * + * Just ensure that the event is set so the + * first "wait change" request is processed. + */ + SetEvent(g_VBoxUsbGlobal.hNotifyEvent); + return VINF_SUCCESS; + } + + dwResult = WaitForSingleObject(g_VBoxUsbGlobal.hThread, INFINITE); + Assert(dwResult == WAIT_OBJECT_0); + BOOL fRc = CloseHandle(g_VBoxUsbGlobal.hThread); NOREF(fRc); + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsg(fRc, ("CloseHandle for hThread failed dwErr(%d)\n", dwErr)); + g_VBoxUsbGlobal.hThread = INVALID_HANDLE_VALUE; + } + else + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("CreateThread failed, dwErr (%d)\n", dwErr)); + rc = VERR_GENERAL_FAILURE; + } + + DeleteTimerQueueEx(g_VBoxUsbGlobal.hTimerQueue, INVALID_HANDLE_VALUE /* see term */); + g_VBoxUsbGlobal.hTimerQueue = NULL; + } + else + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("CreateTimerQueue failed dwErr(%d)\n", dwErr)); + } +#endif + } + else + { + LogRelFunc(("USB Monitor driver version mismatch! driver=%u.%u library=%u.%u\n", + Version.u32Major, Version.u32Minor, USBMON_MAJOR_VERSION, USBMON_MINOR_VERSION)); +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + AssertFailed(); +#endif + rc = VERR_VERSION_MISMATCH; + } + } + else + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("DeviceIoControl failed dwErr(%d)\n", dwErr)); + rc = VERR_VERSION_MISMATCH; + } + + CloseHandle(g_VBoxUsbGlobal.hMonitor); + g_VBoxUsbGlobal.hMonitor = INVALID_HANDLE_VALUE; + } + else + { + LogRelFunc(("USB Service not found\n")); +#ifdef VBOX_WITH_ANNOYING_USB_ASSERTIONS + AssertFailed(); +#endif + rc = VERR_FILE_NOT_FOUND; + } + + CloseHandle(g_VBoxUsbGlobal.hInterruptEvent); + g_VBoxUsbGlobal.hInterruptEvent = NULL; + } + else + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("CreateEvent for InterruptEvent failed dwErr(%d)\n", dwErr)); + rc = VERR_GENERAL_FAILURE; + } + + CloseHandle(g_VBoxUsbGlobal.hNotifyEvent); + g_VBoxUsbGlobal.hNotifyEvent = NULL; + } + else + { + DWORD dwErr = GetLastError(); NOREF(dwErr); + AssertMsgFailed(("CreateEvent for NotifyEvent failed dwErr(%d)\n", dwErr)); + rc = VERR_GENERAL_FAILURE; + } + + /* since main calls us even if USBLibInit fails, + * we use hMonitor == INVALID_HANDLE_VALUE as a marker to indicate whether the lib is inited */ + + Assert(RT_FAILURE(rc)); + return rc; +} + + +/** + * Terminate the USB library + * + * @returns VBox status code. + */ +USBLIB_DECL(int) USBLibTerm(void) +{ + if (g_VBoxUsbGlobal.hMonitor == INVALID_HANDLE_VALUE) + { + Assert(g_VBoxUsbGlobal.hInterruptEvent == NULL); + Assert(g_VBoxUsbGlobal.hNotifyEvent == NULL); + return VINF_SUCCESS; + } + + BOOL fRc; +#ifdef VBOX_USB_USE_DEVICE_NOTIFICATION + fRc = PostMessage(g_VBoxUsbGlobal.hWnd, WM_CLOSE, 0, 0); + AssertMsg(fRc, ("PostMessage for hWnd failed dwErr(%d)\n", GetLastError())); + + if (g_VBoxUsbGlobal.hThread != NULL) + { + DWORD dwResult = WaitForSingleObject(g_VBoxUsbGlobal.hThread, INFINITE); + Assert(dwResult == WAIT_OBJECT_0); NOREF(dwResult); + fRc = CloseHandle(g_VBoxUsbGlobal.hThread); + AssertMsg(fRc, ("CloseHandle for hThread failed dwErr(%d)\n", GetLastError())); + } + + if (g_VBoxUsbGlobal.hTimer) + { + fRc = DeleteTimerQueueTimer(g_VBoxUsbGlobal.hTimerQueue, g_VBoxUsbGlobal.hTimer, + INVALID_HANDLE_VALUE); /* <-- to block until the timer is completed */ + AssertMsg(fRc, ("DeleteTimerQueueTimer failed dwErr(%d)\n", GetLastError())); + } + + if (g_VBoxUsbGlobal.hTimerQueue) + { + fRc = DeleteTimerQueueEx(g_VBoxUsbGlobal.hTimerQueue, + INVALID_HANDLE_VALUE); /* <-- to block until all timers are completed */ + AssertMsg(fRc, ("DeleteTimerQueueEx failed dwErr(%d)\n", GetLastError())); + } +#endif /* VBOX_USB_USE_DEVICE_NOTIFICATION */ + + fRc = CloseHandle(g_VBoxUsbGlobal.hMonitor); + AssertMsg(fRc, ("CloseHandle for hMonitor failed dwErr(%d)\n", GetLastError())); + g_VBoxUsbGlobal.hMonitor = INVALID_HANDLE_VALUE; + + fRc = CloseHandle(g_VBoxUsbGlobal.hInterruptEvent); + AssertMsg(fRc, ("CloseHandle for hInterruptEvent failed lasterr=%u\n", GetLastError())); + g_VBoxUsbGlobal.hInterruptEvent = NULL; + + fRc = CloseHandle(g_VBoxUsbGlobal.hNotifyEvent); + AssertMsg(fRc, ("CloseHandle for hNotifyEvent failed dwErr(%d)\n", GetLastError())); + g_VBoxUsbGlobal.hNotifyEvent = NULL; + + return VINF_SUCCESS; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/mon/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUSBMon.inf b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUSBMon.inf new file mode 100644 index 00000000..a3cb6b68 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUSBMon.inf @@ -0,0 +1,88 @@ +; $Id: VBoxUSBMon.inf $ +;; @file +; VBox USB Monitor driver - Installation file +; + +; +; Copyright (C) 2011-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +[Version] +Signature="$Windows NT$" +Class=System +ClassGuid={4d36e97d-e325-11ce-bfc1-08002be10318} +Provider=%ORACLE% +;edit-DriverVer=08/26/2008,2.00.0000 +DriverPackageType=KernelService +;cat CatalogFile=VBoxUSBMon.cat + +[DestinationDirs] +DefaultDestDir = 12 + +[DefaultInstall@DOT-NT-ARCH@] +CopyFiles=VBoxUSBMon_CopyFiles + +[DefaultInstall@DOT-NT-ARCH@.Services] +AddService=VBoxUSBMon,0x00000002,VBoxUSBMon_Service,VBoxUSBMon_AddEventLog + +;; Cannot get this to work (same works fine for VBoxDrv): +;; [Manufacturer] +;; %ORACLE%=Oracle@COMMA-NT-ARCH@ +;; +;; ; Models section (referenced by [Manufacturer]). +;; [Oracle@DOT-NT-ARCH@] +;; %VBoxUSBMon.DRVDESC%=VBoxUSBMonInstall,root\VBoxUSBMon +;; +;; [VBoxUSBMonInstall@DOT-NT-ARCH@] +;; CopyFiles=VBoxUSBMon_CopyFiles +;; +;; [VBoxUSBMonInstall@DOT-NT-ARCH@.Services] +;; AddService=VBoxUSBMon,0x00000002,VBoxUSBMon_Service,VBoxUSBMon_AddEventLog + +[SourceDisksFiles] +VBoxUSBMon.sys=1 + +[SourceDisksNames] +1=%VBoxUSBMon.DSKDESC%, + +[VBoxUSBMon_CopyFiles] +VBoxUSBMon.sys + +[VBoxUSBMon_Service] +DisplayName = %VBoxUSBMon.SVCDESC% +ServiceType = 1 ; SERVICE_KERNEL_DRIVER +;StartType = 3 ; SERVICE_DEMAND_START +StartType = 1 ; autostart to fix Vista problem +ErrorControl = 1 ; SERVICE_ERROR_NORMAL +ServiceBinary = %12%\VBoxUSBMon.sys + +[VBoxUSBMon_AddEventLog] +AddReg = VBoxUSBMon_AddEventLogRegistry + +[VBoxUSBMon_AddEventLogRegistry] +HKR,,EventMessageFile,0x00020000,"%%SystemRoot%%\System32\IoLogMsg.dll" +HKR,,TypesSupported,0x00010001,7 + +[Strings] +ORACLE = "Oracle Corporation" +VBoxUSBMon.SVCDESC = "VirtualBox USB Monitor Service" +VBoxUSBMon.DRVDESC = "VirtualBox USB Monitor Driver" +VBoxUSBMon.DSKDESC = "VirtualBox USB Monitor Driver Installation Disk" + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.cpp b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.cpp new file mode 100644 index 00000000..232150ee --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.cpp @@ -0,0 +1,1457 @@ +/* $Id: VBoxUsbFlt.cpp $ */ +/** @file + * VBox USB Monitor Device Filtering functionality + */ +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxUsbMon.h" +#include "../cmn/VBoxUsbTool.h" + +#include <VBox/cdefs.h> +#include <VBox/types.h> +#include <iprt/process.h> +#include <iprt/assert.h> +#include <iprt/errcore.h> + +#include <iprt/assert.h> + +#pragma warning(disable : 4200) +#include "usbdi.h" +#pragma warning(default : 4200) +#include "usbdlib.h" +#include "VBoxUSBFilterMgr.h" +#include <VBox/usblib.h> +#include <devguid.h> + +/* + * Note: Must match the VID & PID in the USB driver .inf file!! + */ +/* + BusQueryDeviceID USB\Vid_80EE&Pid_CAFE + BusQueryInstanceID 2 + BusQueryHardwareIDs USB\Vid_80EE&Pid_CAFE&Rev_0100 + BusQueryHardwareIDs USB\Vid_80EE&Pid_CAFE + BusQueryCompatibleIDs USB\Class_ff&SubClass_00&Prot_00 + BusQueryCompatibleIDs USB\Class_ff&SubClass_00 + BusQueryCompatibleIDs USB\Class_ff +*/ + +#define szBusQueryDeviceId L"USB\\Vid_80EE&Pid_CAFE" +#define szBusQueryHardwareIDs L"USB\\Vid_80EE&Pid_CAFE&Rev_0100\0USB\\Vid_80EE&Pid_CAFE\0\0" +#define szBusQueryCompatibleIDs L"USB\\Class_ff&SubClass_00&Prot_00\0USB\\Class_ff&SubClass_00\0USB\\Class_ff\0\0" + +#define szDeviceTextDescription L"VirtualBox USB" + +/* Possible USB bus driver names. */ +static LPWSTR lpszStandardControllerName[1] = +{ + L"\\Driver\\usbhub", +}; + +/* + * state transitions: + * + * (we are not filtering this device ) + * ADDED --> UNCAPTURED ------------------------------->- + * | | + * | (we are filtering this device, | (the device is being + * | waiting for our device driver | re-plugged to perform + * | to pick it up) | capture-uncapture transition) + * |-> CAPTURING -------------------------------->|---> REPLUGGING ----- + * ^ | (device driver picked | | + * | | up the device) | (remove cased | (device is removed + * | ->---> CAPTURED ---------------------->| by "real" removal | the device info is removed form the list) + * | | |------------------->->--> REMOVED + * | | | + * |-----------<->---> USED_BY_GUEST ------->| + * | | + * |------------------------<- + * + * NOTE: the order of enums DOES MATTER!! + * Do not blindly modify!! as the code assumes the state is ordered this way. + */ +typedef enum +{ + VBOXUSBFLT_DEVSTATE_UNKNOWN = 0, + VBOXUSBFLT_DEVSTATE_REMOVED, + VBOXUSBFLT_DEVSTATE_REPLUGGING, + VBOXUSBFLT_DEVSTATE_ADDED, + VBOXUSBFLT_DEVSTATE_UNCAPTURED, + VBOXUSBFLT_DEVSTATE_CAPTURING, + VBOXUSBFLT_DEVSTATE_CAPTURED, + VBOXUSBFLT_DEVSTATE_USED_BY_GUEST, + VBOXUSBFLT_DEVSTATE_32BIT_HACK = 0x7fffffff +} VBOXUSBFLT_DEVSTATE; + +typedef struct VBOXUSBFLT_DEVICE +{ + LIST_ENTRY GlobalLe; + /* auxiliary list to be used for gathering devices to be re-plugged + * only thread that puts the device to the REPLUGGING state can use this list */ + LIST_ENTRY RepluggingLe; + /* Owning session. Each matched device has an owning session. */ + struct VBOXUSBFLTCTX *pOwner; + /* filter id - if NULL AND device has an owner - the filter is destroyed */ + uintptr_t uFltId; + /* true iff device is filtered with a one-shot filter */ + bool fIsFilterOneShot; + /* The device state. If the non-owner session is requesting the state while the device is grabbed, + * the USBDEVICESTATE_USED_BY_HOST is returned. */ + VBOXUSBFLT_DEVSTATE enmState; + volatile uint32_t cRefs; + PDEVICE_OBJECT Pdo; + uint16_t idVendor; + uint16_t idProduct; + uint16_t bcdDevice; + uint8_t bClass; + uint8_t bSubClass; + uint8_t bProtocol; + char szSerial[MAX_USB_SERIAL_STRING]; + char szMfgName[MAX_USB_SERIAL_STRING]; + char szProduct[MAX_USB_SERIAL_STRING]; +#if 0 + char szDrvKeyName[512]; + BOOLEAN fHighSpeed; +#endif +} VBOXUSBFLT_DEVICE, *PVBOXUSBFLT_DEVICE; + +#define PVBOXUSBFLT_DEVICE_FROM_LE(_pLe) ( (PVBOXUSBFLT_DEVICE)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLT_DEVICE, GlobalLe) ) ) +#define PVBOXUSBFLT_DEVICE_FROM_REPLUGGINGLE(_pLe) ( (PVBOXUSBFLT_DEVICE)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLT_DEVICE, RepluggingLe) ) ) +#define PVBOXUSBFLTCTX_FROM_LE(_pLe) ( (PVBOXUSBFLTCTX)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLTCTX, ListEntry) ) ) + +typedef struct VBOXUSBFLT_LOCK +{ + KSPIN_LOCK Lock; + KIRQL OldIrql; +} VBOXUSBFLT_LOCK, *PVBOXUSBFLT_LOCK; + +#define VBOXUSBFLT_LOCK_INIT() \ + KeInitializeSpinLock(&g_VBoxUsbFltGlobals.Lock.Lock) +#define VBOXUSBFLT_LOCK_TERM() do { } while (0) +#define VBOXUSBFLT_LOCK_ACQUIRE() \ + KeAcquireSpinLock(&g_VBoxUsbFltGlobals.Lock.Lock, &g_VBoxUsbFltGlobals.Lock.OldIrql); +#define VBOXUSBFLT_LOCK_RELEASE() \ + KeReleaseSpinLock(&g_VBoxUsbFltGlobals.Lock.Lock, g_VBoxUsbFltGlobals.Lock.OldIrql); + + +typedef struct VBOXUSBFLT_BLDEV +{ + LIST_ENTRY ListEntry; + uint16_t idVendor; + uint16_t idProduct; + uint16_t bcdDevice; +} VBOXUSBFLT_BLDEV, *PVBOXUSBFLT_BLDEV; + +#define PVBOXUSBFLT_BLDEV_FROM_LE(_pLe) ( (PVBOXUSBFLT_BLDEV)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBFLT_BLDEV, ListEntry) ) ) + +typedef struct VBOXUSBFLTGLOBALS +{ + LIST_ENTRY DeviceList; + LIST_ENTRY ContextList; + /* devices known to misbehave */ + LIST_ENTRY BlackDeviceList; + VBOXUSBFLT_LOCK Lock; +} VBOXUSBFLTGLOBALS, *PVBOXUSBFLTGLOBALS; +static VBOXUSBFLTGLOBALS g_VBoxUsbFltGlobals; + +static bool vboxUsbFltBlDevMatchLocked(uint16_t idVendor, uint16_t idProduct, uint16_t bcdDevice) +{ + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.BlackDeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.BlackDeviceList; + pEntry = pEntry->Flink) + { + PVBOXUSBFLT_BLDEV pDev = PVBOXUSBFLT_BLDEV_FROM_LE(pEntry); + if (pDev->idVendor != idVendor) + continue; + if (pDev->idProduct != idProduct) + continue; + if (pDev->bcdDevice != bcdDevice) + continue; + + return true; + } + return false; +} + +static NTSTATUS vboxUsbFltBlDevAddLocked(uint16_t idVendor, uint16_t idProduct, uint16_t bcdDevice) +{ + if (vboxUsbFltBlDevMatchLocked(idVendor, idProduct, bcdDevice)) + return STATUS_SUCCESS; + PVBOXUSBFLT_BLDEV pDev = (PVBOXUSBFLT_BLDEV)VBoxUsbMonMemAllocZ(sizeof (*pDev)); + if (!pDev) + { + AssertFailed(); + return STATUS_INSUFFICIENT_RESOURCES; + } + + pDev->idVendor = idVendor; + pDev->idProduct = idProduct; + pDev->bcdDevice = bcdDevice; + InsertHeadList(&g_VBoxUsbFltGlobals.BlackDeviceList, &pDev->ListEntry); + return STATUS_SUCCESS; +} + +static void vboxUsbFltBlDevClearLocked() +{ + PLIST_ENTRY pNext; + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.BlackDeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.BlackDeviceList; + pEntry = pNext) + { + pNext = pEntry->Flink; + VBoxUsbMonMemFree(pEntry); + } +} + +static void vboxUsbFltBlDevPopulateWithKnownLocked() +{ + /* this one halts when trying to get string descriptors from it */ + vboxUsbFltBlDevAddLocked(0x5ac, 0x921c, 0x115); +} + + +DECLINLINE(void) vboxUsbFltDevRetain(PVBOXUSBFLT_DEVICE pDevice) +{ + Assert(pDevice->cRefs); + ASMAtomicIncU32(&pDevice->cRefs); +} + +static void vboxUsbFltDevDestroy(PVBOXUSBFLT_DEVICE pDevice) +{ + Assert(!pDevice->cRefs); + Assert(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REMOVED); + VBoxUsbMonMemFree(pDevice); +} + +DECLINLINE(void) vboxUsbFltDevRelease(PVBOXUSBFLT_DEVICE pDevice) +{ + uint32_t cRefs = ASMAtomicDecU32(&pDevice->cRefs); + Assert(cRefs < UINT32_MAX/2); + if (!cRefs) + { + vboxUsbFltDevDestroy(pDevice); + } +} + +static void vboxUsbFltDevOwnerSetLocked(PVBOXUSBFLT_DEVICE pDevice, PVBOXUSBFLTCTX pContext, uintptr_t uFltId, bool fIsOneShot) +{ + ASSERT_WARN(!pDevice->pOwner, ("device 0x%p has an owner(0x%p)", pDevice, pDevice->pOwner)); + ++pContext->cActiveFilters; + pDevice->pOwner = pContext; + pDevice->uFltId = uFltId; + pDevice->fIsFilterOneShot = fIsOneShot; +} + +static void vboxUsbFltDevOwnerClearLocked(PVBOXUSBFLT_DEVICE pDevice) +{ + ASSERT_WARN(pDevice->pOwner, ("no owner for device 0x%p", pDevice)); + --pDevice->pOwner->cActiveFilters; + ASSERT_WARN(pDevice->pOwner->cActiveFilters < UINT32_MAX/2, ("cActiveFilters (%d)", pDevice->pOwner->cActiveFilters)); + pDevice->pOwner = NULL; + pDevice->uFltId = 0; +} + +static void vboxUsbFltDevOwnerUpdateLocked(PVBOXUSBFLT_DEVICE pDevice, PVBOXUSBFLTCTX pContext, uintptr_t uFltId, bool fIsOneShot) +{ + if (pDevice->pOwner != pContext) + { + if (pDevice->pOwner) + vboxUsbFltDevOwnerClearLocked(pDevice); + if (pContext) + vboxUsbFltDevOwnerSetLocked(pDevice, pContext, uFltId, fIsOneShot); + } + else if (pContext) + { + pDevice->uFltId = uFltId; + pDevice->fIsFilterOneShot = fIsOneShot; + } +} + +static PVBOXUSBFLT_DEVICE vboxUsbFltDevGetLocked(PDEVICE_OBJECT pPdo) +{ +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.DeviceList; + pEntry = pEntry->Flink) + { + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry); + for (PLIST_ENTRY pEntry2 = pEntry->Flink; + pEntry2 != &g_VBoxUsbFltGlobals.DeviceList; + pEntry2 = pEntry2->Flink) + { + PVBOXUSBFLT_DEVICE pDevice2 = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry2); + ASSERT_WARN( pDevice->idVendor != pDevice2->idVendor + || pDevice->idProduct != pDevice2->idProduct + || pDevice->bcdDevice != pDevice2->bcdDevice, ("duplicate devices in a list!!")); + } + } +#endif + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.DeviceList; + pEntry = pEntry->Flink) + { + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry); + ASSERT_WARN( pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING + || pDevice->enmState == VBOXUSBFLT_DEVSTATE_UNCAPTURED + || pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURING + || pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURED + || pDevice->enmState == VBOXUSBFLT_DEVSTATE_USED_BY_GUEST, + ("Invalid device state(%d) for device(0x%p) PDO(0x%p)", pDevice->enmState, pDevice, pDevice->Pdo)); + if (pDevice->Pdo == pPdo) + return pDevice; + } + return NULL; +} + +PVBOXUSBFLT_DEVICE vboxUsbFltDevGet(PDEVICE_OBJECT pPdo) +{ + PVBOXUSBFLT_DEVICE pDevice; + + VBOXUSBFLT_LOCK_ACQUIRE(); + pDevice = vboxUsbFltDevGetLocked(pPdo); + /* + * Prevent a host crash when vboxUsbFltDevGetLocked fails to locate the matching PDO + * in g_VBoxUsbFltGlobals.DeviceList (see @bugref{6509}). + */ + if (pDevice == NULL) + { + WARN(("failed to get device for PDO(0x%p)", pPdo)); + } + else if (pDevice->enmState > VBOXUSBFLT_DEVSTATE_ADDED) + { + vboxUsbFltDevRetain(pDevice); + LOG(("found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo)); + } + else + { + LOG(("found replugging device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo)); + pDevice = NULL; + } + VBOXUSBFLT_LOCK_RELEASE(); + + return pDevice; +} + +static NTSTATUS vboxUsbFltPdoReplug(PDEVICE_OBJECT pDo) +{ + LOG(("Replugging PDO(0x%p)", pDo)); + NTSTATUS Status = VBoxUsbToolIoInternalCtlSendSync(pDo, IOCTL_INTERNAL_USB_CYCLE_PORT, NULL, NULL); + ASSERT_WARN(Status == STATUS_SUCCESS, ("replugging PDO(0x%p) failed Status(0x%x)", pDo, Status)); + LOG(("Replugging PDO(0x%p) done with Status(0x%x)", pDo, Status)); + return Status; +} + +static bool vboxUsbFltDevCanBeCaptured(PVBOXUSBFLT_DEVICE pDevice) +{ + if (pDevice->bClass == USB_DEVICE_CLASS_HUB) + { + LOG(("device (0x%p), pdo (0x%p) is a hub, can not be captured", pDevice, pDevice->Pdo)); + return false; + } + return true; +} + +static PVBOXUSBFLTCTX vboxUsbFltDevMatchLocked(PVBOXUSBFLT_DEVICE pDevice, uintptr_t *puId, bool fRemoveFltIfOneShot, bool *pfFilter, bool *pfIsOneShot) +{ + *puId = 0; + *pfFilter = false; + *pfIsOneShot = false; + if (!vboxUsbFltDevCanBeCaptured(pDevice)) + { + LOG(("vboxUsbFltDevCanBeCaptured returned false")); + return NULL; + } + + USBFILTER DevFlt; + USBFilterInit(&DevFlt, USBFILTERTYPE_CAPTURE); + USBFilterSetNumExact(&DevFlt, USBFILTERIDX_VENDOR_ID, pDevice->idVendor, true); + USBFilterSetNumExact(&DevFlt, USBFILTERIDX_PRODUCT_ID, pDevice->idProduct, true); + USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_REV, pDevice->bcdDevice, true); + USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_CLASS, pDevice->bClass, true); + USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_SUB_CLASS, pDevice->bSubClass, true); + USBFilterSetNumExact(&DevFlt, USBFILTERIDX_DEVICE_PROTOCOL, pDevice->bProtocol, true); + USBFilterSetStringExact(&DevFlt, USBFILTERIDX_MANUFACTURER_STR, pDevice->szMfgName, true /*fMustBePresent*/, true /*fPurge*/); + USBFilterSetStringExact(&DevFlt, USBFILTERIDX_PRODUCT_STR, pDevice->szProduct, true /*fMustBePresent*/, true /*fPurge*/); + USBFilterSetStringExact(&DevFlt, USBFILTERIDX_SERIAL_NUMBER_STR, pDevice->szSerial, true /*fMustBePresent*/, true /*fPurge*/); + + /* Run filters on the thing. */ + PVBOXUSBFLTCTX pOwner = VBoxUSBFilterMatchEx(&DevFlt, puId, fRemoveFltIfOneShot, pfFilter, pfIsOneShot); + USBFilterDelete(&DevFlt); + return pOwner; +} + +static void vboxUsbFltDevStateMarkReplugLocked(PVBOXUSBFLT_DEVICE pDevice) +{ + vboxUsbFltDevOwnerUpdateLocked(pDevice, NULL, 0, false); + pDevice->enmState = VBOXUSBFLT_DEVSTATE_REPLUGGING; +} + +static bool vboxUsbFltDevStateIsNotFiltered(PVBOXUSBFLT_DEVICE pDevice) +{ + return pDevice->enmState == VBOXUSBFLT_DEVSTATE_UNCAPTURED; +} + +static bool vboxUsbFltDevStateIsFiltered(PVBOXUSBFLT_DEVICE pDevice) +{ + return pDevice->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING; +} + +#define VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS 10000 + +static NTSTATUS vboxUsbFltDevPopulate(PVBOXUSBFLT_DEVICE pDevice, PDEVICE_OBJECT pDo /*, BOOLEAN bPopulateNonFilterProps*/) +{ + NTSTATUS Status; + PUSB_DEVICE_DESCRIPTOR pDevDr = 0; + + pDevice->Pdo = pDo; + + LOG(("Populating Device(0x%p) for PDO(0x%p)", pDevice, pDo)); + + pDevDr = (PUSB_DEVICE_DESCRIPTOR)VBoxUsbMonMemAllocZ(sizeof(*pDevDr)); + if (pDevDr == NULL) + { + WARN(("Failed to alloc mem for urb")); + return STATUS_INSUFFICIENT_RESOURCES; + } + + do + { + Status = VBoxUsbToolGetDescriptor(pDo, pDevDr, sizeof(*pDevDr), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS); + if (!NT_SUCCESS(Status)) + { + WARN(("getting device descriptor failed, Status (0x%x)", Status)); + break; + } + + if (vboxUsbFltBlDevMatchLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice)) + { + WARN(("found a known black list device, vid(0x%x), pid(0x%x), rev(0x%x)", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice)); + Status = STATUS_UNSUCCESSFUL; + break; + } + + LOG(("Device pid=%x vid=%x rev=%x", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice)); + pDevice->idVendor = pDevDr->idVendor; + pDevice->idProduct = pDevDr->idProduct; + pDevice->bcdDevice = pDevDr->bcdDevice; + pDevice->bClass = pDevDr->bDeviceClass; + pDevice->bSubClass = pDevDr->bDeviceSubClass; + pDevice->bProtocol = pDevDr->bDeviceProtocol; + pDevice->szSerial[0] = 0; + pDevice->szMfgName[0] = 0; + pDevice->szProduct[0] = 0; + + /* If there are no strings, don't even try to get any string descriptors. */ + if (pDevDr->iSerialNumber || pDevDr->iManufacturer || pDevDr->iProduct) + { + int langId; + + Status = VBoxUsbToolGetLangID(pDo, &langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS); + if (!NT_SUCCESS(Status)) + { + WARN(("reading language ID failed")); + if (Status == STATUS_CANCELLED) + { + WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice)); + vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice); + Status = STATUS_UNSUCCESSFUL; + } + break; + } + + if (pDevDr->iSerialNumber) + { + Status = VBoxUsbToolGetStringDescriptor(pDo, pDevice->szSerial, sizeof (pDevice->szSerial), pDevDr->iSerialNumber, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS); + if (!NT_SUCCESS(Status)) + { + WARN(("reading serial number failed")); + ASSERT_WARN(pDevice->szSerial[0] == '\0', ("serial is not zero!!")); + if (Status == STATUS_CANCELLED) + { + WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice)); + vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice); + Status = STATUS_UNSUCCESSFUL; + break; + } + LOG(("pretending success..")); + Status = STATUS_SUCCESS; + } + } + + if (pDevDr->iManufacturer) + { + Status = VBoxUsbToolGetStringDescriptor(pDo, pDevice->szMfgName, sizeof (pDevice->szMfgName), pDevDr->iManufacturer, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS); + if (!NT_SUCCESS(Status)) + { + WARN(("reading manufacturer name failed")); + ASSERT_WARN(pDevice->szMfgName[0] == '\0', ("szMfgName is not zero!!")); + if (Status == STATUS_CANCELLED) + { + WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice)); + vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice); + Status = STATUS_UNSUCCESSFUL; + break; + } + LOG(("pretending success..")); + Status = STATUS_SUCCESS; + } + } + + if (pDevDr->iProduct) + { + Status = VBoxUsbToolGetStringDescriptor(pDo, pDevice->szProduct, sizeof (pDevice->szProduct), pDevDr->iProduct, langId, VBOXUSBMON_POPULATE_REQUEST_TIMEOUT_MS); + if (!NT_SUCCESS(Status)) + { + WARN(("reading product name failed")); + ASSERT_WARN(pDevice->szProduct[0] == '\0', ("szProduct is not zero!!")); + if (Status == STATUS_CANCELLED) + { + WARN(("found a new black list device, vid(0x%x), pid(0x%x), rev(0x%x)", pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice)); + vboxUsbFltBlDevAddLocked(pDevDr->idVendor, pDevDr->idProduct, pDevDr->bcdDevice); + Status = STATUS_UNSUCCESSFUL; + break; + } + LOG(("pretending success..")); + Status = STATUS_SUCCESS; + } + } + + LOG((": strings: '%s':'%s':'%s' (lang ID %x)", + pDevice->szMfgName, pDevice->szProduct, pDevice->szSerial, langId)); + } + + LOG(("Populating Device(0x%p) for PDO(0x%p) Succeeded", pDevice, pDo)); + Status = STATUS_SUCCESS; + } while (0); + + VBoxUsbMonMemFree(pDevDr); + LOG(("Populating Device(0x%p) for PDO(0x%p) Done, Status (0x%x)", pDevice, pDo, Status)); + return Status; +} + +static void vboxUsbFltSignalChangeLocked() +{ + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.ContextList.Flink; + pEntry != &g_VBoxUsbFltGlobals.ContextList; + pEntry = pEntry->Flink) + { + PVBOXUSBFLTCTX pCtx = PVBOXUSBFLTCTX_FROM_LE(pEntry); + /* the removed context can not be in a list */ + Assert(!pCtx->bRemoved); + if (pCtx->pChangeEvent) + { + KeSetEvent(pCtx->pChangeEvent, + 0, /* increment*/ + FALSE /* wait */); + } + } +} + +static bool vboxUsbFltDevCheckReplugLocked(PVBOXUSBFLT_DEVICE pDevice, PVBOXUSBFLTCTX pContext) +{ + ASSERT_WARN(pContext, ("context is NULL!")); + + LOG(("Current context is (0x%p)", pContext)); + LOG(("Current Device owner is (0x%p)", pDevice->pOwner)); + + /* check if device is already replugging */ + if (pDevice->enmState <= VBOXUSBFLT_DEVSTATE_ADDED) + { + LOG(("Device (0x%p) is already replugging, return..", pDevice)); + /* it is, do nothing */ + ASSERT_WARN(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING, + ("Device (0x%p) state is NOT REPLUGGING (%d)", pDevice, pDevice->enmState)); + return false; + } + + if (pDevice->pOwner && pContext != pDevice->pOwner) + { + LOG(("Device (0x%p) is owned by another context(0x%p), current is(0x%p)", pDevice, pDevice->pOwner, pContext)); + /* this device is owned by another context, we're not allowed to do anything */ + return false; + } + + uintptr_t uId = 0; + bool bNeedReplug = false; + bool fFilter = false; + bool fIsOneShot = false; + PVBOXUSBFLTCTX pNewOwner = vboxUsbFltDevMatchLocked(pDevice, &uId, + false, /* do not remove a one-shot filter */ + &fFilter, &fIsOneShot); + LOG(("Matching Info: Filter (0x%p), NewOwner(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pNewOwner, (int)fFilter, (int)fIsOneShot)); + if (pDevice->pOwner && pNewOwner && pDevice->pOwner != pNewOwner) + { + LOG(("Matching: Device (0x%p) is requested another owner(0x%p), current is(0x%p)", pDevice, pNewOwner, pDevice->pOwner)); + /* the device is owned by another owner, we can not change the owner here */ + return false; + } + + if (!fFilter) + { + LOG(("Matching: Device (0x%p) should NOT be filtered", pDevice)); + /* the device should NOT be filtered, check the current state */ + if (vboxUsbFltDevStateIsNotFiltered(pDevice)) + { + LOG(("Device (0x%p) is NOT filtered", pDevice)); + /* no changes */ + if (fIsOneShot) + { + ASSERT_WARN(pNewOwner, ("no new owner")); + LOG(("Matching: This is a one-shot filter (0x%p), removing..", uId)); + /* remove a one-shot filter and keep the original filter data */ + int tmpRc = VBoxUSBFilterRemove(pNewOwner, uId); + ASSERT_WARN(RT_SUCCESS(tmpRc), ("remove filter failed, rc (%d)", tmpRc)); + if (!pDevice->pOwner) + { + LOG(("Matching: updating the one-shot owner to (0x%p), fltId(0x%p)", pNewOwner, uId)); + /* update owner for one-shot if the owner is changed (i.e. assigned) */ + vboxUsbFltDevOwnerUpdateLocked(pDevice, pNewOwner, uId, true); + } + else + { + LOG(("Matching: device already has owner (0x%p) assigned", pDevice->pOwner)); + } + } + else + { + LOG(("Matching: This is NOT a one-shot filter (0x%p), newOwner(0x%p)", uId, pNewOwner)); + if (pNewOwner) + { + vboxUsbFltDevOwnerUpdateLocked(pDevice, pNewOwner, uId, false); + } + } + } + else + { + LOG(("Device (0x%p) IS filtered", pDevice)); + /* the device is currently filtered, we should release it only if + * 1. device does not have an owner + * or + * 2. it should be released bue to a one-shot filter + * or + * 3. it is NOT grabbed by a one-shot filter */ + if (!pDevice->pOwner || fIsOneShot || !pDevice->fIsFilterOneShot) + { + LOG(("Matching: Need replug")); + bNeedReplug = true; + } + } + } + else + { + LOG(("Matching: Device (0x%p) SHOULD be filtered", pDevice)); + /* the device should be filtered, check the current state */ + ASSERT_WARN(uId, ("zero uid")); + ASSERT_WARN(pNewOwner, ("zero pNewOwner")); + if (vboxUsbFltDevStateIsFiltered(pDevice)) + { + LOG(("Device (0x%p) IS filtered", pDevice)); + /* the device is filtered */ + if (pNewOwner == pDevice->pOwner) + { + LOG(("Device owner match")); + /* no changes */ + if (fIsOneShot) + { + LOG(("Matching: This is a one-shot filter (0x%p), removing..", uId)); + /* remove a one-shot filter and keep the original filter data */ + int tmpRc = VBoxUSBFilterRemove(pNewOwner, uId); + ASSERT_WARN(RT_SUCCESS(tmpRc), ("remove filter failed, rc (%d)", tmpRc)); + } + else + { + LOG(("Matching: This is NOT a one-shot filter (0x%p), Owner(0x%p)", uId, pDevice->pOwner)); + vboxUsbFltDevOwnerUpdateLocked(pDevice, pDevice->pOwner, uId, false); + } + } + else + { + ASSERT_WARN(!pDevice->pOwner, ("device should NOT have owner")); + LOG(("Matching: Need replug")); + /* the device needs to be filtered, but the owner changes, replug needed */ + bNeedReplug = true; + } + } + else + { + /* the device is currently NOT filtered, + * we should replug it only if + * 1. device does not have an owner + * or + * 2. it should be captured due to a one-shot filter + * or + * 3. it is NOT released by a one-shot filter */ + if (!pDevice->pOwner || fIsOneShot || !pDevice->fIsFilterOneShot) + { + bNeedReplug = true; + LOG(("Matching: Need replug")); + } + } + } + + if (bNeedReplug) + { + LOG(("Matching: Device needs replugging, marking as such")); + vboxUsbFltDevStateMarkReplugLocked(pDevice); + } + else + { + LOG(("Matching: Device does NOT need replugging")); + } + + return bNeedReplug; +} + +static void vboxUsbFltReplugList(PLIST_ENTRY pList) +{ + PLIST_ENTRY pNext; + for (PLIST_ENTRY pEntry = pList->Flink; + pEntry != pList; + pEntry = pNext) + { + pNext = pEntry->Flink; + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_REPLUGGINGLE(pEntry); + LOG(("replugging matched PDO(0x%p), pDevice(0x%p)", pDevice->Pdo, pDevice)); + ASSERT_WARN(pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING + || pDevice->enmState == VBOXUSBFLT_DEVSTATE_REMOVED, + ("invalid state(0x%x) for device(0x%p)", pDevice->enmState, pDevice)); + + vboxUsbFltPdoReplug(pDevice->Pdo); + ObDereferenceObject(pDevice->Pdo); + vboxUsbFltDevRelease(pDevice); + } +} + +typedef struct VBOXUSBFLTCHECKWALKER +{ + PVBOXUSBFLTCTX pContext; +} VBOXUSBFLTCHECKWALKER, *PVBOXUSBFLTCHECKWALKER; + +static DECLCALLBACK(BOOLEAN) vboxUsbFltFilterCheckWalker(PFILE_OBJECT pFile, PDEVICE_OBJECT pTopDo, + PDEVICE_OBJECT pHubDo, PVOID pvContext) +{ + RT_NOREF1(pHubDo); + PVBOXUSBFLTCHECKWALKER pData = (PVBOXUSBFLTCHECKWALKER)pvContext; + PVBOXUSBFLTCTX pContext = pData->pContext; + + LOG(("Visiting pFile(0x%p), pTopDo(0x%p), pHubDo(0x%p), oContext(0x%p)", pFile, pTopDo, pHubDo, pContext)); + KIRQL Irql = KeGetCurrentIrql(); + ASSERT_WARN(Irql == PASSIVE_LEVEL, ("unexpected IRQL (%d)", Irql)); + + PDEVICE_RELATIONS pDevRelations = NULL; + + NTSTATUS Status = VBoxUsbMonQueryBusRelations(pTopDo, pFile, &pDevRelations); + if (Status == STATUS_SUCCESS && pDevRelations) + { + ULONG cReplugPdos = pDevRelations->Count; + LIST_ENTRY ReplugDevList; + InitializeListHead(&ReplugDevList); + for (ULONG k = 0; k < pDevRelations->Count; ++k) + { + PDEVICE_OBJECT pDevObj = pDevRelations->Objects[k]; + + LOG(("Found existing USB PDO 0x%p", pDevObj)); + VBOXUSBFLT_LOCK_ACQUIRE(); + PVBOXUSBFLT_DEVICE pDevice = vboxUsbFltDevGetLocked(pDevObj); + if (pDevice) + { + LOG(("Found existing device info (0x%p) for PDO 0x%p", pDevice, pDevObj)); + bool bReplug = vboxUsbFltDevCheckReplugLocked(pDevice, pContext); + if (bReplug) + { + LOG(("Replug needed for device (0x%p)", pDevice)); + InsertHeadList(&ReplugDevList, &pDevice->RepluggingLe); + vboxUsbFltDevRetain(pDevice); + /* do not dereference object since we will use it later */ + } + else + { + LOG(("Replug NOT needed for device (0x%p)", pDevice)); + ObDereferenceObject(pDevObj); + } + + VBOXUSBFLT_LOCK_RELEASE(); + + pDevRelations->Objects[k] = NULL; + --cReplugPdos; + ASSERT_WARN((uint32_t)cReplugPdos < UINT32_MAX/2, ("cReplugPdos(%d) state broken", cReplugPdos)); + continue; + } + VBOXUSBFLT_LOCK_RELEASE(); + + LOG(("NO device info found for PDO 0x%p", pDevObj)); + VBOXUSBFLT_DEVICE Device; + Status = vboxUsbFltDevPopulate(&Device, pDevObj /*, FALSE /* only need filter properties */); + if (NT_SUCCESS(Status)) + { + uintptr_t uId = 0; + bool fFilter = false; + bool fIsOneShot = false; + VBOXUSBFLT_LOCK_ACQUIRE(); + PVBOXUSBFLTCTX pCtx = vboxUsbFltDevMatchLocked(&Device, &uId, + false, /* do not remove a one-shot filter */ + &fFilter, &fIsOneShot); + VBOXUSBFLT_LOCK_RELEASE(); + NOREF(pCtx); + LOG(("Matching Info: Filter (0x%p), pCtx(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pCtx, (int)fFilter, (int)fIsOneShot)); + if (fFilter) + { + LOG(("Matching: This device SHOULD be filtered")); + /* this device needs to be filtered, but it's not, + * leave the PDO in array to issue a replug request for it + * later on */ + continue; + } + } + else + { + WARN(("vboxUsbFltDevPopulate for PDO 0x%p failed with Status 0x%x", pDevObj, Status)); + } + + LOG(("Matching: This device should NOT be filtered")); + /* this device should not be filtered, and it's not */ + ObDereferenceObject(pDevObj); + pDevRelations->Objects[k] = NULL; + --cReplugPdos; + ASSERT_WARN((uint32_t)cReplugPdos < UINT32_MAX/2, ("cReplugPdos is %d", cReplugPdos)); + } + + LOG(("(%d) non-matched PDOs to be replugged", cReplugPdos)); + + if (cReplugPdos) + { + for (ULONG k = 0; k < pDevRelations->Count; ++k) + { + if (!pDevRelations->Objects[k]) + continue; + + Status = vboxUsbFltPdoReplug(pDevRelations->Objects[k]); + ASSERT_WARN(Status == STATUS_SUCCESS, ("vboxUsbFltPdoReplug ailed Status(0x%x)", Status)); + ObDereferenceObject(pDevRelations->Objects[k]); + if (!--cReplugPdos) + break; + } + + ASSERT_WARN(!cReplugPdos, ("cReplugPdosreached zero!")); + } + + vboxUsbFltReplugList(&ReplugDevList); + + ExFreePool(pDevRelations); + } + else + { + WARN(("VBoxUsbMonQueryBusRelations failed for DO(0x%p), Status(0x%x), pDevRelations(0x%p)", + pTopDo, Status, pDevRelations)); + } + + LOG(("Done Visiting pFile(0x%p), pTopDo(0x%p), pHubDo(0x%p), oContext(0x%p)", pFile, pTopDo, pHubDo, pContext)); + + return TRUE; +} + +NTSTATUS VBoxUsbFltFilterCheck(PVBOXUSBFLTCTX pContext) +{ + KIRQL Irql = KeGetCurrentIrql(); + ASSERT_WARN(Irql == PASSIVE_LEVEL, ("unexpected IRQL (%d)", Irql)); + + LOG(("Running filters, Context (0x%p)..", pContext)); + + VBOXUSBFLTCHECKWALKER Data; + Data.pContext = pContext; + vboxUsbMonHubDevWalk(vboxUsbFltFilterCheckWalker, &Data, VBOXUSBMONHUBWALK_F_FDO); + + LOG(("DONE Running filters, Context (0x%p)", pContext)); + + return STATUS_SUCCESS; +} + +NTSTATUS VBoxUsbFltClose(PVBOXUSBFLTCTX pContext) +{ + LOG(("Closing context(0x%p)", pContext)); + LIST_ENTRY ReplugDevList; + InitializeListHead(&ReplugDevList); + + ASSERT_WARN(pContext, ("null context")); + + KIRQL Irql = KeGetCurrentIrql(); + ASSERT_WARN(Irql == PASSIVE_LEVEL, ("irql==(%d)", Irql)); + + VBOXUSBFLT_LOCK_ACQUIRE(); + + pContext->bRemoved = TRUE; + if (pContext->pChangeEvent) + { + LOG(("seting & closing change event (0x%p)", pContext->pChangeEvent)); + KeSetEvent(pContext->pChangeEvent, + 0, /* increment*/ + FALSE /* wait */); + ObDereferenceObject(pContext->pChangeEvent); + pContext->pChangeEvent = NULL; + } + else + LOG(("no change event")); + RemoveEntryList(&pContext->ListEntry); + + LOG(("removing owner filters")); + /* now re-arrange the filters */ + /* 1. remove filters */ + VBoxUSBFilterRemoveOwner(pContext); + + LOG(("enumerating devices..")); + /* 2. check if there are devices owned */ + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.DeviceList; + pEntry = pEntry->Flink) + { + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry); + if (pDevice->pOwner != pContext) + continue; + + LOG(("found device(0x%p), pdo(0x%p), state(%d), filter id(0x%p), oneshot(%d)", + pDevice, pDevice->Pdo, pDevice->enmState, pDevice->uFltId, (int)pDevice->fIsFilterOneShot)); + ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED, ("VBOXUSBFLT_DEVSTATE_ADDED state for device(0x%p)", pDevice)); + ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED, ("VBOXUSBFLT_DEVSTATE_REMOVED state for device(0x%p)", pDevice)); + + vboxUsbFltDevOwnerClearLocked(pDevice); + + if (vboxUsbFltDevCheckReplugLocked(pDevice, pContext)) + { + LOG(("device needs replug")); + InsertHeadList(&ReplugDevList, &pDevice->RepluggingLe); + /* retain to ensure the device is not removed before we issue a replug */ + vboxUsbFltDevRetain(pDevice); + /* keep the PDO alive */ + ObReferenceObject(pDevice->Pdo); + } + else + { + LOG(("device does NOT need replug")); + } + } + + VBOXUSBFLT_LOCK_RELEASE(); + + /* this should replug all devices that were either skipped or grabbed due to the context's */ + vboxUsbFltReplugList(&ReplugDevList); + + LOG(("SUCCESS done context(0x%p)", pContext)); + return STATUS_SUCCESS; +} + +NTSTATUS VBoxUsbFltCreate(PVBOXUSBFLTCTX pContext) +{ + LOG(("Creating context(0x%p)", pContext)); + memset(pContext, 0, sizeof (*pContext)); + pContext->Process = RTProcSelf(); + VBOXUSBFLT_LOCK_ACQUIRE(); + InsertHeadList(&g_VBoxUsbFltGlobals.ContextList, &pContext->ListEntry); + VBOXUSBFLT_LOCK_RELEASE(); + LOG(("SUCCESS context(0x%p)", pContext)); + return STATUS_SUCCESS; +} + +int VBoxUsbFltAdd(PVBOXUSBFLTCTX pContext, PUSBFILTER pFilter, uintptr_t *pId) +{ + LOG(("adding filter, Context (0x%p)..", pContext)); + *pId = 0; + /* LOG the filter details. */ + LOG((__FUNCTION__": %s %s %s", + USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_MANUFACTURER_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_PRODUCT_STR) : "<null>", + USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) ? USBFilterGetString(pFilter, USBFILTERIDX_SERIAL_NUMBER_STR) : "<null>")); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + LOG(("VBoxUSBClient::addFilter: idVendor=%#x idProduct=%#x bcdDevice=%#x bDeviceClass=%#x bDeviceSubClass=%#x bDeviceProtocol=%#x bBus=%#x bPort=%#x Type%#x", + USBFilterGetNum(pFilter, USBFILTERIDX_VENDOR_ID), + USBFilterGetNum(pFilter, USBFILTERIDX_PRODUCT_ID), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_REV), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_CLASS), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_SUB_CLASS), + USBFilterGetNum(pFilter, USBFILTERIDX_DEVICE_PROTOCOL), + USBFilterGetNum(pFilter, USBFILTERIDX_BUS), + USBFilterGetNum(pFilter, USBFILTERIDX_PORT), + USBFilterGetFilterType(pFilter))); +#endif + + /* We can't get the bus/port numbers. Ignore them while matching. */ + USBFilterSetMustBePresent(pFilter, USBFILTERIDX_BUS, false); + USBFilterSetMustBePresent(pFilter, USBFILTERIDX_PORT, false); + + uintptr_t uId = 0; + VBOXUSBFLT_LOCK_ACQUIRE(); + /* Add the filter. */ + int rc = VBoxUSBFilterAdd(pFilter, pContext, &uId); + VBOXUSBFLT_LOCK_RELEASE(); + if (RT_SUCCESS(rc)) + { + LOG(("ADDED filer id 0x%p", uId)); + ASSERT_WARN(uId, ("uid is NULL")); +#ifdef VBOX_USBMON_WITH_FILTER_AUTOAPPLY + VBoxUsbFltFilterCheck(); +#endif + } + else + { + WARN(("VBoxUSBFilterAdd failed rc (%d)", rc)); + ASSERT_WARN(!uId, ("uid is not NULL")); + } + + *pId = uId; + return rc; +} + +int VBoxUsbFltRemove(PVBOXUSBFLTCTX pContext, uintptr_t uId) +{ + LOG(("removing filter id(0x%p), Context (0x%p)..", pContext, uId)); + Assert(uId); + + VBOXUSBFLT_LOCK_ACQUIRE(); + int rc = VBoxUSBFilterRemove(pContext, uId); + if (!RT_SUCCESS(rc)) + { + WARN(("VBoxUSBFilterRemove failed rc (%d)", rc)); + VBOXUSBFLT_LOCK_RELEASE(); + return rc; + } + + LOG(("enumerating devices..")); + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.DeviceList; + pEntry = pEntry->Flink) + { + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry); + if (pDevice->fIsFilterOneShot) + { + ASSERT_WARN(!pDevice->uFltId, ("oneshot filter on device(0x%p): unexpected uFltId(%d)", pDevice, pDevice->uFltId)); + } + + if (pDevice->uFltId != uId) + continue; + + ASSERT_WARN(pDevice->pOwner == pContext, ("Device(0x%p) owner(0x%p) not match to (0x%p)", pDevice, pDevice->pOwner, pContext)); + if (pDevice->pOwner != pContext) + continue; + + LOG(("found device(0x%p), pdo(0x%p), state(%d), filter id(0x%p), oneshot(%d)", + pDevice, pDevice->Pdo, pDevice->enmState, pDevice->uFltId, (int)pDevice->fIsFilterOneShot)); + ASSERT_WARN(!pDevice->fIsFilterOneShot, ("device(0x%p) is filtered with a oneshot filter", pDevice)); + pDevice->uFltId = 0; + /* clear the fIsFilterOneShot flag to ensure the device is replugged on the next VBoxUsbFltFilterCheck call */ + pDevice->fIsFilterOneShot = false; + } + VBOXUSBFLT_LOCK_RELEASE(); + + LOG(("done enumerating devices")); + + if (RT_SUCCESS(rc)) + { +#ifdef VBOX_USBMON_WITH_FILTER_AUTOAPPLY + VBoxUsbFltFilterCheck(); +#endif + } + return rc; +} + +NTSTATUS VBoxUsbFltSetNotifyEvent(PVBOXUSBFLTCTX pContext, HANDLE hEvent) +{ + NTSTATUS Status = STATUS_SUCCESS; + PKEVENT pEvent = NULL; + PKEVENT pOldEvent = NULL; + if (hEvent) + { + Status = ObReferenceObjectByHandle(hEvent, + EVENT_MODIFY_STATE, + *ExEventObjectType, UserMode, + (PVOID*)&pEvent, + NULL); + Assert(Status == STATUS_SUCCESS); + if (!NT_SUCCESS(Status)) + return Status; + } + + VBOXUSBFLT_LOCK_ACQUIRE(); + pOldEvent = pContext->pChangeEvent; + pContext->pChangeEvent = pEvent; + VBOXUSBFLT_LOCK_RELEASE(); + + if (pOldEvent) + { + ObDereferenceObject(pOldEvent); + } + + return STATUS_SUCCESS; +} + +static USBDEVICESTATE vboxUsbDevGetUserState(PVBOXUSBFLTCTX pContext, PVBOXUSBFLT_DEVICE pDevice) +{ + if (vboxUsbFltDevStateIsNotFiltered(pDevice)) + return USBDEVICESTATE_USED_BY_HOST_CAPTURABLE; + + /* the device is filtered, or replugging */ + if (pDevice->enmState == VBOXUSBFLT_DEVSTATE_REPLUGGING) + { + ASSERT_WARN(!pDevice->pOwner, ("replugging device(0x%p) still has an owner(0x%p)", pDevice, pDevice->pOwner)); + ASSERT_WARN(!pDevice->uFltId, ("replugging device(0x%p) still has filter(0x%p)", pDevice, pDevice->uFltId)); + /* no user state for this, we should not return it tu the user */ + return USBDEVICESTATE_USED_BY_HOST; + } + + /* the device is filtered, if owner differs from the context, return as USED_BY_HOST */ + ASSERT_WARN(pDevice->pOwner, ("device(0x%p) has noowner", pDevice)); + /* the id can be null if a filter is removed */ +// Assert(pDevice->uFltId); + + if (pDevice->pOwner != pContext) + { + LOG(("Device owner differs from the current context, returning used by host")); + return USBDEVICESTATE_USED_BY_HOST; + } + + switch (pDevice->enmState) + { + case VBOXUSBFLT_DEVSTATE_UNCAPTURED: + case VBOXUSBFLT_DEVSTATE_CAPTURING: + return USBDEVICESTATE_USED_BY_HOST_CAPTURABLE; + case VBOXUSBFLT_DEVSTATE_CAPTURED: + return USBDEVICESTATE_HELD_BY_PROXY; + case VBOXUSBFLT_DEVSTATE_USED_BY_GUEST: + return USBDEVICESTATE_USED_BY_GUEST; + default: + WARN(("unexpected device state(%d) for device(0x%p)", pDevice->enmState, pDevice)); + return USBDEVICESTATE_UNSUPPORTED; + } +} + +NTSTATUS VBoxUsbFltGetDevice(PVBOXUSBFLTCTX pContext, HVBOXUSBDEVUSR hDevice, PUSBSUP_GETDEV_MON pInfo) +{ + Assert(hDevice); + + memset (pInfo, 0, sizeof (*pInfo)); + VBOXUSBFLT_LOCK_ACQUIRE(); + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.DeviceList; + pEntry = pEntry->Flink) + { + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry); + Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED); + Assert(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED); + + if (pDevice != hDevice) + continue; + + USBDEVICESTATE enmUsrState = vboxUsbDevGetUserState(pContext, pDevice); + pInfo->enmState = enmUsrState; + VBOXUSBFLT_LOCK_RELEASE(); + return STATUS_SUCCESS; + } + + VBOXUSBFLT_LOCK_RELEASE(); + + /* this should not occur */ + AssertFailed(); + + return STATUS_INVALID_PARAMETER; +} + +NTSTATUS VBoxUsbFltPdoAdd(PDEVICE_OBJECT pPdo, BOOLEAN *pbFiltered) +{ + *pbFiltered = FALSE; + PVBOXUSBFLT_DEVICE pDevice; + + /* first check if device is in the a already */ + VBOXUSBFLT_LOCK_ACQUIRE(); + pDevice = vboxUsbFltDevGetLocked(pPdo); + if (pDevice) + { + LOG(("found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo)); + ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED, ("VBOXUSBFLT_DEVSTATE_ADDED state for device(0x%p)", pDevice)); + ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED, ("VBOXUSBFLT_DEVSTATE_REMOVED state for device(0x%p)", pDevice)); + *pbFiltered = pDevice->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING; + VBOXUSBFLT_LOCK_RELEASE(); + return STATUS_SUCCESS; + } + VBOXUSBFLT_LOCK_RELEASE(); + pDevice = (PVBOXUSBFLT_DEVICE)VBoxUsbMonMemAllocZ(sizeof (*pDevice)); + if (!pDevice) + { + WARN(("VBoxUsbMonMemAllocZ failed")); + return STATUS_NO_MEMORY; + } + + pDevice->enmState = VBOXUSBFLT_DEVSTATE_ADDED; + pDevice->cRefs = 1; + NTSTATUS Status = vboxUsbFltDevPopulate(pDevice, pPdo /* , TRUE /* need all props */); + if (!NT_SUCCESS(Status)) + { + WARN(("vboxUsbFltDevPopulate failed, Status 0x%x", Status)); + VBoxUsbMonMemFree(pDevice); + return Status; + } + + uintptr_t uId; + bool fFilter = false; + bool fIsOneShot = false; + PVBOXUSBFLTCTX pCtx; + PVBOXUSBFLT_DEVICE pTmpDev; + VBOXUSBFLT_LOCK_ACQUIRE(); + /* (paranoia) re-check the device is still not here */ + pTmpDev = vboxUsbFltDevGetLocked(pPdo); + if (pTmpDev) + { + LOG(("second try: found device (0x%p), state(%d) for PDO(0x%p)", pDevice, pDevice->enmState, pPdo)); + ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_ADDED, ("second try: VBOXUSBFLT_DEVSTATE_ADDED state for device(0x%p)", pDevice)); + ASSERT_WARN(pDevice->enmState != VBOXUSBFLT_DEVSTATE_REMOVED, ("second try: VBOXUSBFLT_DEVSTATE_REMOVED state for device(0x%p)", pDevice)); + *pbFiltered = pTmpDev->enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING; + VBOXUSBFLT_LOCK_RELEASE(); + VBoxUsbMonMemFree(pDevice); + return STATUS_SUCCESS; + } + + LOG(("Created Device 0x%p for PDO 0x%p", pDevice, pPdo)); + + pCtx = vboxUsbFltDevMatchLocked(pDevice, &uId, + true, /* remove a one-shot filter */ + &fFilter, &fIsOneShot); + LOG(("Matching Info: Filter (0x%p), pCtx(0x%p), fFilter(%d), fIsOneShot(%d)", uId, pCtx, (int)fFilter, (int)fIsOneShot)); + if (fFilter) + { + LOG(("Created Device 0x%p should be filtered", pDevice)); + ASSERT_WARN(pCtx, ("zero ctx")); + ASSERT_WARN(uId, ("zero uId")); + pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURING; + } + else + { + LOG(("Created Device 0x%p should NOT be filtered", pDevice)); + ASSERT_WARN(!uId == !pCtx, ("invalid uid(0x%p) - ctx(0x%p) pair", uId, pCtx)); /* either both zero or both not */ + pDevice->enmState = VBOXUSBFLT_DEVSTATE_UNCAPTURED; + } + + if (pCtx) + vboxUsbFltDevOwnerSetLocked(pDevice, pCtx, fIsOneShot ? 0 : uId, fIsOneShot); + + InsertHeadList(&g_VBoxUsbFltGlobals.DeviceList, &pDevice->GlobalLe); + + /* do not need to signal anything here - + * going to do that once the proxy device object starts */ + VBOXUSBFLT_LOCK_RELEASE(); + + *pbFiltered = fFilter; + + return STATUS_SUCCESS; +} + +NTSTATUS VBoxUsbFltPdoAddCompleted(PDEVICE_OBJECT pPdo) +{ + RT_NOREF1(pPdo); + VBOXUSBFLT_LOCK_ACQUIRE(); + vboxUsbFltSignalChangeLocked(); + VBOXUSBFLT_LOCK_RELEASE(); + return STATUS_SUCCESS; +} + +BOOLEAN VBoxUsbFltPdoIsFiltered(PDEVICE_OBJECT pPdo) +{ + VBOXUSBFLT_DEVSTATE enmState = VBOXUSBFLT_DEVSTATE_REMOVED; + VBOXUSBFLT_LOCK_ACQUIRE(); + + PVBOXUSBFLT_DEVICE pDevice = vboxUsbFltDevGetLocked(pPdo); + if (pDevice) + enmState = pDevice->enmState; + + VBOXUSBFLT_LOCK_RELEASE(); + + return enmState >= VBOXUSBFLT_DEVSTATE_CAPTURING; +} + +NTSTATUS VBoxUsbFltPdoRemove(PDEVICE_OBJECT pPdo) +{ + PVBOXUSBFLT_DEVICE pDevice; + VBOXUSBFLT_DEVSTATE enmOldState; + + VBOXUSBFLT_LOCK_ACQUIRE(); + pDevice = vboxUsbFltDevGetLocked(pPdo); + if (pDevice) + { + RemoveEntryList(&pDevice->GlobalLe); + enmOldState = pDevice->enmState; + pDevice->enmState = VBOXUSBFLT_DEVSTATE_REMOVED; + if (enmOldState != VBOXUSBFLT_DEVSTATE_REPLUGGING) + { + vboxUsbFltSignalChangeLocked(); + } + else + { + /* the device *should* reappear, do signlling on re-appear only + * to avoid extra signaling. still there might be a situation + * when the device will not re-appear if it gets physically removed + * before it re-appears + * @todo: set a timer callback to do a notification from it */ + } + } + VBOXUSBFLT_LOCK_RELEASE(); + if (pDevice) + vboxUsbFltDevRelease(pDevice); + return STATUS_SUCCESS; +} + +HVBOXUSBFLTDEV VBoxUsbFltProxyStarted(PDEVICE_OBJECT pPdo) +{ + PVBOXUSBFLT_DEVICE pDevice; + VBOXUSBFLT_LOCK_ACQUIRE(); + pDevice = vboxUsbFltDevGetLocked(pPdo); + /* + * Prevent a host crash when vboxUsbFltDevGetLocked fails to locate the matching PDO + * in g_VBoxUsbFltGlobals.DeviceList (see @bugref{6509}). + */ + if (pDevice == NULL) + { + WARN(("failed to get device for PDO(0x%p)", pPdo)); + } + else if (pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURING) + { + pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURED; + LOG(("The proxy notified proxy start for the captured device 0x%x", pDevice)); + vboxUsbFltDevRetain(pDevice); + vboxUsbFltSignalChangeLocked(); + } + else + { + WARN(("invalid state, %d", pDevice->enmState)); + pDevice = NULL; + } + VBOXUSBFLT_LOCK_RELEASE(); + return pDevice; +} + +void VBoxUsbFltProxyStopped(HVBOXUSBFLTDEV hDev) +{ + PVBOXUSBFLT_DEVICE pDevice = (PVBOXUSBFLT_DEVICE)hDev; + /* + * Prevent a host crash when VBoxUsbFltProxyStarted fails, returning NULL. + * See @bugref{6509}. + */ + if (pDevice == NULL) + { + WARN(("VBoxUsbFltProxyStopped called with NULL device pointer")); + return; + } + VBOXUSBFLT_LOCK_ACQUIRE(); + if (pDevice->enmState == VBOXUSBFLT_DEVSTATE_CAPTURED + || pDevice->enmState == VBOXUSBFLT_DEVSTATE_USED_BY_GUEST) + { + /* this is due to devie was physically removed */ + LOG(("The proxy notified proxy stop for the captured device 0x%x, current state %d", pDevice, pDevice->enmState)); + pDevice->enmState = VBOXUSBFLT_DEVSTATE_CAPTURING; + vboxUsbFltSignalChangeLocked(); + } + else + { + if (pDevice->enmState != VBOXUSBFLT_DEVSTATE_REPLUGGING) + { + WARN(("invalid state, %d", pDevice->enmState)); + } + } + VBOXUSBFLT_LOCK_RELEASE(); + + vboxUsbFltDevRelease(pDevice); +} + +NTSTATUS VBoxUsbFltInit() +{ + int rc = VBoxUSBFilterInit(); + if (RT_FAILURE(rc)) + { + WARN(("VBoxUSBFilterInit failed, rc (%d)", rc)); + return STATUS_UNSUCCESSFUL; + } + + memset(&g_VBoxUsbFltGlobals, 0, sizeof (g_VBoxUsbFltGlobals)); + InitializeListHead(&g_VBoxUsbFltGlobals.DeviceList); + InitializeListHead(&g_VBoxUsbFltGlobals.ContextList); + InitializeListHead(&g_VBoxUsbFltGlobals.BlackDeviceList); + vboxUsbFltBlDevPopulateWithKnownLocked(); + VBOXUSBFLT_LOCK_INIT(); + return STATUS_SUCCESS; +} + +NTSTATUS VBoxUsbFltTerm() +{ + bool bBusy = false; + VBOXUSBFLT_LOCK_ACQUIRE(); + do + { + if (!IsListEmpty(&g_VBoxUsbFltGlobals.ContextList)) + { + AssertFailed(); + bBusy = true; + break; + } + + PLIST_ENTRY pNext = NULL; + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.DeviceList; + pEntry = pNext) + { + pNext = pEntry->Flink; + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry); + Assert(!pDevice->uFltId); + Assert(!pDevice->pOwner); + if (pDevice->cRefs != 1) + { + AssertFailed(); + bBusy = true; + break; + } + } + } while (0); + + VBOXUSBFLT_LOCK_RELEASE() + + if (bBusy) + { + return STATUS_DEVICE_BUSY; + } + + for (PLIST_ENTRY pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink; + pEntry != &g_VBoxUsbFltGlobals.DeviceList; + pEntry = g_VBoxUsbFltGlobals.DeviceList.Flink) + { + RemoveEntryList(pEntry); + PVBOXUSBFLT_DEVICE pDevice = PVBOXUSBFLT_DEVICE_FROM_LE(pEntry); + pDevice->enmState = VBOXUSBFLT_DEVSTATE_REMOVED; + vboxUsbFltDevRelease(pDevice); + } + + vboxUsbFltBlDevClearLocked(); + + VBOXUSBFLT_LOCK_TERM(); + + VBoxUSBFilterTerm(); + + return STATUS_SUCCESS; +} + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.h b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.h new file mode 100644 index 00000000..f1249bdb --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbFlt.h @@ -0,0 +1,68 @@ +/* $Id: VBoxUsbFlt.h $ */ +/** @file + * VBox USB Monitor Device Filtering functionality + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbFlt_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbFlt_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "VBoxUsbMon.h" +#include <VBoxUSBFilterMgr.h> + +#include <VBox/usblib-win.h> + +typedef struct VBOXUSBFLTCTX +{ + LIST_ENTRY ListEntry; + PKEVENT pChangeEvent; + RTPROCESS Process; + uint32_t cActiveFilters; + BOOLEAN bRemoved; +} VBOXUSBFLTCTX, *PVBOXUSBFLTCTX; + +NTSTATUS VBoxUsbFltInit(); +NTSTATUS VBoxUsbFltTerm(); +NTSTATUS VBoxUsbFltCreate(PVBOXUSBFLTCTX pContext); +NTSTATUS VBoxUsbFltClose(PVBOXUSBFLTCTX pContext); +int VBoxUsbFltAdd(PVBOXUSBFLTCTX pContext, PUSBFILTER pFilter, uintptr_t *pId); +int VBoxUsbFltRemove(PVBOXUSBFLTCTX pContext, uintptr_t uId); +NTSTATUS VBoxUsbFltSetNotifyEvent(PVBOXUSBFLTCTX pContext, HANDLE hEvent); +NTSTATUS VBoxUsbFltFilterCheck(PVBOXUSBFLTCTX pContext); + +NTSTATUS VBoxUsbFltGetDevice(PVBOXUSBFLTCTX pContext, HVBOXUSBDEVUSR hDevice, PUSBSUP_GETDEV_MON pInfo); + +typedef void* HVBOXUSBFLTDEV; +HVBOXUSBFLTDEV VBoxUsbFltProxyStarted(PDEVICE_OBJECT pPdo); +void VBoxUsbFltProxyStopped(HVBOXUSBFLTDEV hDev); + +NTSTATUS VBoxUsbFltPdoAdd(PDEVICE_OBJECT pPdo, BOOLEAN *pbFiltered); +NTSTATUS VBoxUsbFltPdoAddCompleted(PDEVICE_OBJECT pPdo); +NTSTATUS VBoxUsbFltPdoRemove(PDEVICE_OBJECT pPdo); +BOOLEAN VBoxUsbFltPdoIsFiltered(PDEVICE_OBJECT pPdo); + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbFlt_h */ + diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.cpp b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.cpp new file mode 100644 index 00000000..3061d5cf --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.cpp @@ -0,0 +1,208 @@ +/* $Id: VBoxUsbHook.cpp $ */ +/** @file + * Driver Dispatch Table Hooking API + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxUsbMon.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +#define VBOXUSBHOOK_MEMTAG 'HUBV' + + +NTSTATUS VBoxUsbHookInstall(PVBOXUSBHOOK_ENTRY pHook) +{ + KIRQL Irql; + KeAcquireSpinLock(&pHook->Lock, &Irql); + if (pHook->fIsInstalled) + { + WARN(("hook is marked installed, returning failure")); + KeReleaseSpinLock(&pHook->Lock, Irql); + return STATUS_UNSUCCESSFUL; + } + + pHook->pfnOldHandler = (PDRIVER_DISPATCH)InterlockedExchangePointer((PVOID*)&pHook->pDrvObj->MajorFunction[pHook->iMjFunction], pHook->pfnHook); + Assert(pHook->pfnOldHandler); + Assert(pHook->pfnHook != pHook->pfnOldHandler); + pHook->fIsInstalled = TRUE; + KeReleaseSpinLock(&pHook->Lock, Irql); + return STATUS_SUCCESS; + +} +NTSTATUS VBoxUsbHookUninstall(PVBOXUSBHOOK_ENTRY pHook) +{ + KIRQL Irql; + KeAcquireSpinLock(&pHook->Lock, &Irql); + if (!pHook->fIsInstalled) + { + KeReleaseSpinLock(&pHook->Lock, Irql); + return STATUS_SUCCESS; + } + + PDRIVER_DISPATCH pfnOldVal = (PDRIVER_DISPATCH)InterlockedCompareExchangePointer((PVOID*)&pHook->pDrvObj->MajorFunction[pHook->iMjFunction], pHook->pfnOldHandler, pHook->pfnHook); + Assert(pfnOldVal == pHook->pfnHook); + if (pfnOldVal != pHook->pfnHook) + { + AssertMsgFailed(("unhook failed!!!\n")); + /* this is bad! this could happen if someone else has chained another hook, + * or (which is even worse) restored the "initial" entry value it saved when doing a hooking before us + * return the failure and don't do anything else + * the best thing to do if this happens is to leave everything as is + * and to prevent the driver from being unloaded to ensure no one references our unloaded hook routine */ + KeReleaseSpinLock(&pHook->Lock, Irql); + return STATUS_UNSUCCESSFUL; + } + + pHook->fIsInstalled = FALSE; + KeReleaseSpinLock(&pHook->Lock, Irql); + + /* wait for the current handlers to exit */ + VBoxDrvToolRefWaitEqual(&pHook->HookRef, 1); + + return STATUS_SUCCESS; +} + +BOOLEAN VBoxUsbHookIsInstalled(PVBOXUSBHOOK_ENTRY pHook) +{ + KIRQL Irql; + BOOLEAN fIsInstalled; + KeAcquireSpinLock(&pHook->Lock, &Irql); + fIsInstalled = pHook->fIsInstalled; + KeReleaseSpinLock(&pHook->Lock, Irql); + return fIsInstalled; +} + +VOID VBoxUsbHookInit(PVBOXUSBHOOK_ENTRY pHook, PDRIVER_OBJECT pDrvObj, UCHAR iMjFunction, PDRIVER_DISPATCH pfnHook) +{ + Assert(pDrvObj); + Assert(iMjFunction <= IRP_MJ_MAXIMUM_FUNCTION); + Assert(pfnHook); + memset(pHook, 0, sizeof (*pHook)); + InitializeListHead(&pHook->RequestList); + KeInitializeSpinLock(&pHook->Lock); + VBoxDrvToolRefInit(&pHook->HookRef); + pHook->pDrvObj = pDrvObj; + pHook->iMjFunction = iMjFunction; + pHook->pfnHook = pfnHook; + Assert(!pHook->pfnOldHandler); + Assert(!pHook->fIsInstalled); + +} + +static void vboxUsbHookRequestRegisterCompletion(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp, PIO_COMPLETION_ROUTINE pfnCompletion, PVBOXUSBHOOK_REQUEST pRequest) +{ + Assert(pfnCompletion); + Assert(pRequest); + Assert(pDevObj); + Assert(pIrp); + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + memset(pRequest, 0, sizeof (*pRequest)); + pRequest->pHook = pHook; + pRequest->OldLocation = *pSl; + pRequest->pDevObj = pDevObj; + pRequest->pIrp = pIrp; + pRequest->bCompletionStopped = FALSE; + pSl->CompletionRoutine = pfnCompletion; + pSl->Context = pRequest; + pSl->Control = SL_INVOKE_ON_SUCCESS | SL_INVOKE_ON_ERROR | SL_INVOKE_ON_CANCEL; + + KIRQL oldIrql; + KeAcquireSpinLock(&pHook->Lock, &oldIrql); + InsertTailList(&pHook->RequestList, &pRequest->ListEntry); + KeReleaseSpinLock(&pHook->Lock, oldIrql); +} + +NTSTATUS VBoxUsbHookRequestPassDownHookCompletion(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp, PIO_COMPLETION_ROUTINE pfnCompletion, PVBOXUSBHOOK_REQUEST pRequest) +{ + Assert(pfnCompletion); + vboxUsbHookRequestRegisterCompletion(pHook, pDevObj, pIrp, pfnCompletion, pRequest); + return pHook->pfnOldHandler(pDevObj, pIrp); +} + +NTSTATUS VBoxUsbHookRequestPassDownHookSkip(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp) +{ + return pHook->pfnOldHandler(pDevObj, pIrp); +} + +NTSTATUS VBoxUsbHookRequestMoreProcessingRequired(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp, + PVBOXUSBHOOK_REQUEST pRequest) +{ + RT_NOREF3(pHook, pDevObj, pIrp); + Assert(!pRequest->bCompletionStopped); + pRequest->bCompletionStopped = TRUE; + return STATUS_MORE_PROCESSING_REQUIRED; +} + +NTSTATUS VBoxUsbHookRequestComplete(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp, PVBOXUSBHOOK_REQUEST pRequest) +{ + NTSTATUS Status = STATUS_SUCCESS; + + if (pRequest->OldLocation.CompletionRoutine && pRequest->OldLocation.Control) + { + Status = pRequest->OldLocation.CompletionRoutine(pDevObj, pIrp, pRequest->OldLocation.Context); + } + + if (Status != STATUS_MORE_PROCESSING_REQUIRED) + { + if (pRequest->bCompletionStopped) + { + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + } + } + /* + * else - in case driver returned STATUS_MORE_PROCESSING_REQUIRED, + * it will call IoCompleteRequest itself + */ + + KIRQL oldIrql; + KeAcquireSpinLock(&pHook->Lock, &oldIrql); + RemoveEntryList(&pRequest->ListEntry); + KeReleaseSpinLock(&pHook->Lock, oldIrql); + return Status; +} + +#define PVBOXUSBHOOK_REQUEST_FROM_LE(_pLe) ( (PVBOXUSBHOOK_REQUEST)( ((uint8_t*)(_pLe)) - RT_OFFSETOF(VBOXUSBHOOK_REQUEST, ListEntry) ) ) + +VOID VBoxUsbHookVerifyCompletion(PVBOXUSBHOOK_ENTRY pHook, PVBOXUSBHOOK_REQUEST pRequest, PIRP pIrp) +{ + KIRQL oldIrql; + KeAcquireSpinLock(&pHook->Lock, &oldIrql); + for (PLIST_ENTRY pLe = pHook->RequestList.Flink; pLe != &pHook->RequestList; pLe = pLe->Flink) + { + PVBOXUSBHOOK_REQUEST pCur = PVBOXUSBHOOK_REQUEST_FROM_LE(pLe); + if (pCur != pRequest) + continue; + if (pCur->pIrp != pIrp) + continue; + WARN(("found pending IRP(0x%p) when it should not be", pIrp)); + } + KeReleaseSpinLock(&pHook->Lock, oldIrql); + +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.h b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.h new file mode 100644 index 00000000..b730ef60 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbHook.h @@ -0,0 +1,86 @@ +/* $Id: VBoxUsbHook.h $ */ +/** @file + * Driver Dispatch Table Hooking API impl + */ +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbHook_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbHook_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include "VBoxUsbMon.h" + +typedef struct VBOXUSBHOOK_ENTRY +{ + LIST_ENTRY RequestList; + KSPIN_LOCK Lock; + BOOLEAN fIsInstalled; + PDRIVER_DISPATCH pfnOldHandler; + VBOXDRVTOOL_REF HookRef; + PDRIVER_OBJECT pDrvObj; + UCHAR iMjFunction; + PDRIVER_DISPATCH pfnHook; +} VBOXUSBHOOK_ENTRY, *PVBOXUSBHOOK_ENTRY; + +typedef struct VBOXUSBHOOK_REQUEST +{ + LIST_ENTRY ListEntry; + PVBOXUSBHOOK_ENTRY pHook; + IO_STACK_LOCATION OldLocation; + PDEVICE_OBJECT pDevObj; + PIRP pIrp; + BOOLEAN bCompletionStopped; +} VBOXUSBHOOK_REQUEST, *PVBOXUSBHOOK_REQUEST; + +DECLINLINE(BOOLEAN) VBoxUsbHookRetain(PVBOXUSBHOOK_ENTRY pHook) +{ + KIRQL Irql; + KeAcquireSpinLock(&pHook->Lock, &Irql); + if (!pHook->fIsInstalled) + { + KeReleaseSpinLock(&pHook->Lock, Irql); + return FALSE; + } + + VBoxDrvToolRefRetain(&pHook->HookRef); + KeReleaseSpinLock(&pHook->Lock, Irql); + return TRUE; +} + +DECLINLINE(VOID) VBoxUsbHookRelease(PVBOXUSBHOOK_ENTRY pHook) +{ + VBoxDrvToolRefRelease(&pHook->HookRef); +} + +VOID VBoxUsbHookInit(PVBOXUSBHOOK_ENTRY pHook, PDRIVER_OBJECT pDrvObj, UCHAR iMjFunction, PDRIVER_DISPATCH pfnHook); +NTSTATUS VBoxUsbHookInstall(PVBOXUSBHOOK_ENTRY pHook); +NTSTATUS VBoxUsbHookUninstall(PVBOXUSBHOOK_ENTRY pHook); +BOOLEAN VBoxUsbHookIsInstalled(PVBOXUSBHOOK_ENTRY pHook); +NTSTATUS VBoxUsbHookRequestPassDownHookCompletion(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp, PIO_COMPLETION_ROUTINE pfnCompletion, PVBOXUSBHOOK_REQUEST pRequest); +NTSTATUS VBoxUsbHookRequestPassDownHookSkip(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp); +NTSTATUS VBoxUsbHookRequestMoreProcessingRequired(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp, PVBOXUSBHOOK_REQUEST pRequest); +NTSTATUS VBoxUsbHookRequestComplete(PVBOXUSBHOOK_ENTRY pHook, PDEVICE_OBJECT pDevObj, PIRP pIrp, PVBOXUSBHOOK_REQUEST pRequest); +VOID VBoxUsbHookVerifyCompletion(PVBOXUSBHOOK_ENTRY pHook, PVBOXUSBHOOK_REQUEST pRequest, PIRP pIrp); + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbHook_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.cpp b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.cpp new file mode 100644 index 00000000..0dd0a5c4 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.cpp @@ -0,0 +1,1986 @@ +/* $Id: VBoxUsbMon.cpp $ */ +/** @file + * VBox USB Monitor + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "VBoxUsbMon.h" +#include "../cmn/VBoxUsbIdc.h" +#include <iprt/errcore.h> +#include <VBox/usblib.h> +#include <excpt.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/* + * Note: Must match the VID & PID in the USB driver .inf file!! + */ +/* + BusQueryDeviceID USB\Vid_80EE&Pid_CAFE + BusQueryInstanceID 2 + BusQueryHardwareIDs USB\Vid_80EE&Pid_CAFE&Rev_0100 + BusQueryHardwareIDs USB\Vid_80EE&Pid_CAFE + BusQueryCompatibleIDs USB\Class_ff&SubClass_00&Prot_00 + BusQueryCompatibleIDs USB\Class_ff&SubClass_00 + BusQueryCompatibleIDs USB\Class_ff +*/ + +#define szBusQueryDeviceId L"USB\\Vid_80EE&Pid_CAFE" +#define szBusQueryHardwareIDs L"USB\\Vid_80EE&Pid_CAFE&Rev_0100\0USB\\Vid_80EE&Pid_CAFE\0\0" +#define szBusQueryCompatibleIDs L"USB\\Class_ff&SubClass_00&Prot_00\0USB\\Class_ff&SubClass_00\0USB\\Class_ff\0\0" + +#define szDeviceTextDescription L"VirtualBox USB" + + +#define VBOXUSBMON_MEMTAG 'MUBV' + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef struct VBOXUSBMONINS +{ + void * pvDummy; +} VBOXUSBMONINS, *PVBOXUSBMONINS; + +typedef struct VBOXUSBMONCTX +{ + VBOXUSBFLTCTX FltCtx; +} VBOXUSBMONCTX, *PVBOXUSBMONCTX; + +typedef struct VBOXUSBHUB_PNPHOOK +{ + VBOXUSBHOOK_ENTRY Hook; + bool fUninitFailed; +} VBOXUSBHUB_PNPHOOK, *PVBOXUSBHUB_PNPHOOK; + +typedef struct VBOXUSBHUB_PNPHOOK_COMPLETION +{ + VBOXUSBHOOK_REQUEST Rq; +} VBOXUSBHUB_PNPHOOK_COMPLETION, *PVBOXUSBHUB_PNPHOOK_COMPLETION; + +/* + * Comment out VBOX_USB3PORT definition to disable hooking to multiple drivers (#6509) + */ +#define VBOX_USB3PORT + +#ifdef VBOX_USB3PORT +#define VBOXUSBMON_MAXDRIVERS 5 +typedef struct VBOXUSB_PNPDRIVER +{ + PDRIVER_OBJECT DriverObject; + VBOXUSBHUB_PNPHOOK UsbHubPnPHook; + PDRIVER_DISPATCH pfnHookStub; +} VBOXUSB_PNPDRIVER, *PVBOXUSB_PNPDRIVER; +#endif /* !VBOX_USB3PORT */ + +typedef struct VBOXUSBMONGLOBALS +{ + PDEVICE_OBJECT pDevObj; +#ifdef VBOX_USB3PORT + VBOXUSB_PNPDRIVER pDrivers[VBOXUSBMON_MAXDRIVERS]; +#else /* !VBOX_USB3PORT */ + VBOXUSBHUB_PNPHOOK UsbHubPnPHook; +#endif /* !VBOX_USB3PORT */ + KEVENT OpenSynchEvent; + IO_REMOVE_LOCK RmLock; + uint32_t cOpens; + volatile LONG ulPreventUnloadOn; + PFILE_OBJECT pPreventUnloadFileObj; +} VBOXUSBMONGLOBALS, *PVBOXUSBMONGLOBALS; + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +static VBOXUSBMONGLOBALS g_VBoxUsbMonGlobals; + + + +PVOID VBoxUsbMonMemAlloc(SIZE_T cbBytes) +{ + PVOID pvMem = ExAllocatePoolWithTag(NonPagedPool, cbBytes, VBOXUSBMON_MEMTAG); + Assert(pvMem); + return pvMem; +} + +PVOID VBoxUsbMonMemAllocZ(SIZE_T cbBytes) +{ + PVOID pvMem = VBoxUsbMonMemAlloc(cbBytes); + if (pvMem) + { + RtlZeroMemory(pvMem, cbBytes); + } + return pvMem; +} + +VOID VBoxUsbMonMemFree(PVOID pvMem) +{ + ExFreePoolWithTag(pvMem, VBOXUSBMON_MEMTAG); +} + +#define VBOXUSBDBG_STRCASE(_t) \ + case _t: return #_t +#define VBOXUSBDBG_STRCASE_UNKNOWN(_v) \ + default: LOG((__FUNCTION__": Unknown Value (0n%d), (0x%x)", _v, _v)); return "Unknown" + +static const char* vboxUsbDbgStrPnPMn(UCHAR uMn) +{ + switch (uMn) + { + VBOXUSBDBG_STRCASE(IRP_MN_START_DEVICE); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_REMOVE_DEVICE); + VBOXUSBDBG_STRCASE(IRP_MN_REMOVE_DEVICE); + VBOXUSBDBG_STRCASE(IRP_MN_CANCEL_REMOVE_DEVICE); + VBOXUSBDBG_STRCASE(IRP_MN_STOP_DEVICE); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_STOP_DEVICE); + VBOXUSBDBG_STRCASE(IRP_MN_CANCEL_STOP_DEVICE); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_DEVICE_RELATIONS); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_INTERFACE); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_CAPABILITIES); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_RESOURCES); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_RESOURCE_REQUIREMENTS); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_DEVICE_TEXT); + VBOXUSBDBG_STRCASE(IRP_MN_FILTER_RESOURCE_REQUIREMENTS); + VBOXUSBDBG_STRCASE(IRP_MN_READ_CONFIG); + VBOXUSBDBG_STRCASE(IRP_MN_WRITE_CONFIG); + VBOXUSBDBG_STRCASE(IRP_MN_EJECT); + VBOXUSBDBG_STRCASE(IRP_MN_SET_LOCK); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_ID); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_PNP_DEVICE_STATE); + VBOXUSBDBG_STRCASE(IRP_MN_QUERY_BUS_INFORMATION); + VBOXUSBDBG_STRCASE(IRP_MN_DEVICE_USAGE_NOTIFICATION); + VBOXUSBDBG_STRCASE(IRP_MN_SURPRISE_REMOVAL); + VBOXUSBDBG_STRCASE_UNKNOWN(uMn); + } +} + +void vboxUsbDbgPrintUnicodeString(PUNICODE_STRING pUnicodeString) +{ + RT_NOREF1(pUnicodeString); + Log(("%.*ls", pUnicodeString->Length / 2, pUnicodeString->Buffer)); +} + +/** + * Send IRP_MN_QUERY_DEVICE_RELATIONS + * + * @returns NT Status + * @param pDevObj USB device pointer + * @param pFileObj Valid file object pointer + * @param pDevRelations Pointer to DEVICE_RELATIONS pointer (out) + */ +NTSTATUS VBoxUsbMonQueryBusRelations(PDEVICE_OBJECT pDevObj, PFILE_OBJECT pFileObj, PDEVICE_RELATIONS *pDevRelations) +{ + IO_STATUS_BLOCK IoStatus; + KEVENT Event; + NTSTATUS Status; + PIRP pIrp; + PIO_STACK_LOCATION pSl; + + KeInitializeEvent(&Event, NotificationEvent, FALSE); + + Assert(pDevRelations); + *pDevRelations = NULL; + + pIrp = IoBuildSynchronousFsdRequest(IRP_MJ_PNP, pDevObj, NULL, 0, NULL, &Event, &IoStatus); + if (!pIrp) + { + WARN(("IoBuildDeviceIoControlRequest failed!!")); + return STATUS_INSUFFICIENT_RESOURCES; + } + pIrp->IoStatus.Status = STATUS_NOT_SUPPORTED; + + pSl = IoGetNextIrpStackLocation(pIrp); + pSl->MajorFunction = IRP_MJ_PNP; + pSl->MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS; + pSl->Parameters.QueryDeviceRelations.Type = BusRelations; + pSl->FileObject = pFileObj; + + Status = IoCallDriver(pDevObj, pIrp); + if (Status == STATUS_PENDING) + { + LOG(("IoCallDriver returned STATUS_PENDING!!")); + KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); + Status = IoStatus.Status; + } + + if (Status == STATUS_SUCCESS) + { + PDEVICE_RELATIONS pRel = (PDEVICE_RELATIONS)IoStatus.Information; + LOG(("pRel = %p", pRel)); + if (VALID_PTR(pRel)) + { + *pDevRelations = pRel; + } + else + { + WARN(("Invalid pointer %p", pRel)); + } + } + else + { + WARN(("IRP_MN_QUERY_DEVICE_RELATIONS failed Status(0x%x)", Status)); + } + + LOG(("IoCallDriver returned %x", Status)); + return Status; +} + +RT_C_DECLS_BEGIN +/* these two come from IFS Kit, which is not included in 2K DDK we use, + * although they are documented and exported in ntoskrnl, + * and both should be present for >= XP according to MSDN */ +NTKERNELAPI +NTSTATUS +ObQueryNameString( + __in PVOID Object, + __out_bcount_opt(Length) POBJECT_NAME_INFORMATION ObjectNameInfo, + __in ULONG Length, + __out PULONG ReturnLength + ); + +NTKERNELAPI +PDEVICE_OBJECT +IoGetLowerDeviceObject( + __in PDEVICE_OBJECT DeviceObject + ); + +RT_C_DECLS_END + +typedef DECLCALLBACK(VOID) FNVBOXUSBDEVNAMEMATCHER(PDEVICE_OBJECT pDo, PUNICODE_STRING pName, PVOID pvMatcher); +typedef FNVBOXUSBDEVNAMEMATCHER *PFNVBOXUSBDEVNAMEMATCHER; + +static NTSTATUS vboxUsbObjCheckName(PDEVICE_OBJECT pDo, PFNVBOXUSBDEVNAMEMATCHER pfnMatcher, PVOID pvMatcher) +{ + union + { + OBJECT_NAME_INFORMATION Info; + char buf[1024]; + } buf; + ULONG cbLength = 0; + + POBJECT_NAME_INFORMATION pInfo = &buf.Info; + NTSTATUS Status = ObQueryNameString(pDo, &buf.Info, sizeof (buf), &cbLength); + if (!NT_SUCCESS(Status)) + { + if (STATUS_INFO_LENGTH_MISMATCH != Status) + { + WARN(("ObQueryNameString failed 0x%x", Status)); + return Status; + } + + LOG(("ObQueryNameString returned STATUS_INFO_LENGTH_MISMATCH, required size %d", cbLength)); + + pInfo = (POBJECT_NAME_INFORMATION)VBoxUsbMonMemAlloc(cbLength); + if (!pInfo) + { + WARN(("VBoxUsbMonMemAlloc failed")); + return STATUS_NO_MEMORY; + } + Status = ObQueryNameString(pDo, pInfo, cbLength, &cbLength); + if (!NT_SUCCESS(Status)) + { + WARN(("ObQueryNameString second try failed 0x%x", Status)); + VBoxUsbMonMemFree(pInfo); + return Status; + } + } + + /* we've got the name! */ + LOG(("got the name:")); + LOG_USTR(&pInfo->Name); + pfnMatcher(pDo, &pInfo->Name, pvMatcher); + + if (&buf.Info != pInfo) + { + LOG(("freeing allocated pInfo(0x%p)", pInfo)); + VBoxUsbMonMemFree(pInfo); + } + else + { + LOG(("no freeing info needed")); + } + + return STATUS_SUCCESS; +} + + +typedef DECLCALLBACK(BOOLEAN) FNVBOXUSBDEVSTACKWALKER(PDEVICE_OBJECT pTopDo, PDEVICE_OBJECT pCurDo, PVOID pvContext); +typedef FNVBOXUSBDEVSTACKWALKER *PFNVBOXUSBDEVSTACKWALKER; + +VOID vboxUsbObjDevStackWalk(PDEVICE_OBJECT pDo, PFNVBOXUSBDEVSTACKWALKER pfnWalker, PVOID pvWalker) +{ + LOG(("==>tree walk for Do 0x%p", pDo)); + PDEVICE_OBJECT pCurDo = pDo; + ObReferenceObject(pCurDo); /* <- to make sure the dereferencing logic below works correctly */ + do + { + LOG(("==Do 0x%p", pCurDo)); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + { + union + { + OBJECT_NAME_INFORMATION Info; + char buf[1024]; + } buf; + ULONG cbLength = 0; + + NTSTATUS tmpStatus = ObQueryNameString(pCurDo, &buf.Info, sizeof (buf), &cbLength); + if (NT_SUCCESS(tmpStatus)) + { + LOG((" Obj name:")); + LOG_USTR(&buf.Info.Name); + } + else + { + if (STATUS_INFO_LENGTH_MISMATCH != tmpStatus) + { + WARN(("ObQueryNameString failed 0x%x", tmpStatus)); + } + else + { + WARN(("ObQueryNameString STATUS_INFO_LENGTH_MISMATCH, required %d", cbLength)); + } + } + + if (pCurDo->DriverObject + && pCurDo->DriverObject->DriverName.Buffer + && pCurDo->DriverObject->DriverName.Length) + { + LOG((" Drv Obj(0x%p), name:", pCurDo->DriverObject)); + LOG_USTR(&pCurDo->DriverObject->DriverName); + } + else + { + LOG((" No Drv Name, Drv Obj(0x%p)", pCurDo->DriverObject)); + if (pCurDo->DriverObject) + { + LOG((" driver name is zero, Length(%d), Buffer(0x%p)", + pCurDo->DriverObject->DriverName.Length, pCurDo->DriverObject->DriverName.Buffer)); + } + else + { + LOG((" driver object is NULL")); + } + } + } +#endif + if (!pfnWalker(pDo, pCurDo, pvWalker)) + { + LOG(("the walker said to stop")); + ObDereferenceObject(pCurDo); + break; + } + + PDEVICE_OBJECT pLowerDo = IoGetLowerDeviceObject(pCurDo); + ObDereferenceObject(pCurDo); + if (!pLowerDo) + { + LOG(("IoGetLowerDeviceObject returnned NULL, stop")); + break; + } + pCurDo = pLowerDo; + } while (1); + + LOG(("<==tree walk")); +} + +static DECLCALLBACK(BOOLEAN) vboxUsbObjNamePrefixMatch(PUNICODE_STRING pName, PUNICODE_STRING pNamePrefix, BOOLEAN fCaseInSensitive) +{ + LOG(("Matching prefix:")); + LOG_USTR(pNamePrefix); + if (pNamePrefix->Length > pName->Length) + { + LOG(("Pregix Length(%d) > Name Length(%d)", pNamePrefix->Length, pName->Length)); + return FALSE; + } + + LOG(("Pregix Length(%d) <= Name Length(%d)", pNamePrefix->Length, pName->Length)); + + UNICODE_STRING NamePrefix = *pName; + NamePrefix.Length = pNamePrefix->Length; + LONG rc = RtlCompareUnicodeString(&NamePrefix, pNamePrefix, fCaseInSensitive); + + if (!rc) + { + LOG(("prefix MATCHED!")); + return TRUE; + } + + LOG(("prefix NOT matched!")); + return FALSE; +} + +typedef struct VBOXUSBOBJNAMEPREFIXMATCHER +{ + PUNICODE_STRING pNamePrefix; + BOOLEAN fMatched; +} VBOXUSBOBJNAMEPREFIXMATCHER, *PVBOXUSBOBJNAMEPREFIXMATCHER; + +static DECLCALLBACK(VOID) vboxUsbObjDevNamePrefixMatcher(PDEVICE_OBJECT pDo, PUNICODE_STRING pName, PVOID pvMatcher) +{ + RT_NOREF1(pDo); + PVBOXUSBOBJNAMEPREFIXMATCHER pData = (PVBOXUSBOBJNAMEPREFIXMATCHER)pvMatcher; + PUNICODE_STRING pNamePrefix = pData->pNamePrefix; + ASSERT_WARN(!pData->fMatched, ("match flag already set!")); + pData->fMatched = vboxUsbObjNamePrefixMatch(pName, pNamePrefix, TRUE /* fCaseInSensitive */); + LOG(("match result (%d)", (int)pData->fMatched)); +} + +typedef struct VBOXUSBOBJDRVOBJSEARCHER +{ + PDEVICE_OBJECT pDevObj; + PUNICODE_STRING pDrvName; + PUNICODE_STRING pPdoNamePrefix; + ULONG fFlags; +} VBOXUSBOBJDRVOBJSEARCHER, *PVBOXUSBOBJDRVOBJSEARCHER; + +static DECLCALLBACK(BOOLEAN) vboxUsbObjDevObjSearcherWalker(PDEVICE_OBJECT pTopDo, PDEVICE_OBJECT pCurDo, PVOID pvContext) +{ + RT_NOREF1(pTopDo); + PVBOXUSBOBJDRVOBJSEARCHER pData = (PVBOXUSBOBJDRVOBJSEARCHER)pvContext; + ASSERT_WARN(!pData->pDevObj, ("non-null dev object (0x%p) on enter", pData->pDevObj)); + pData->pDevObj = NULL; + if (pCurDo->DriverObject + && pCurDo->DriverObject->DriverName.Buffer + && pCurDo->DriverObject->DriverName.Length + && !RtlCompareUnicodeString(pData->pDrvName, &pCurDo->DriverObject->DriverName, TRUE /* case insensitive */)) + { + LOG(("MATCHED driver:")); + LOG_USTR(&pCurDo->DriverObject->DriverName); + if ((pData->fFlags & VBOXUSBMONHUBWALK_F_ALL) != VBOXUSBMONHUBWALK_F_ALL) + { + VBOXUSBOBJNAMEPREFIXMATCHER Data = {0}; + Data.pNamePrefix = pData->pPdoNamePrefix; + NTSTATUS Status = vboxUsbObjCheckName(pCurDo, vboxUsbObjDevNamePrefixMatcher, &Data); + if (!NT_SUCCESS(Status)) + { + WARN(("vboxUsbObjCheckName failed Status (0x%x)", Status)); + return TRUE; + } + + + LOG(("prefix match result (%d)", Data.fMatched)); + if ((pData->fFlags & VBOXUSBMONHUBWALK_F_FDO) == VBOXUSBMONHUBWALK_F_FDO) + { + LOG(("VBOXUSBMONHUBWALK_F_FDO")); + if (Data.fMatched) + { + LOG(("this is a PDO object, skip it and stop search")); + /* stop search as we will not find FDO here */ + return FALSE; + } + + LOG(("this is a FDO object, MATCHED!!")); + } + else if ((pData->fFlags & VBOXUSBMONHUBWALK_F_PDO) == VBOXUSBMONHUBWALK_F_PDO) + { + LOG(("VBOXUSBMONHUBWALK_F_PDO")); + if (!Data.fMatched) + { + LOG(("this is a FDO object, skip it and continue search")); + /* continue seach since since this could be a nested hub that would have a usbhub-originated PDO */ + return TRUE; + } + + LOG(("this is a PDO object, MATCHED!!")); + } + + } + else + { + LOG(("VBOXUSBMONHUBWALK_F_ALL")); + LOG(("either PDO or FDO, MATCHED!!")); + } + + /* ensure the dev object is not destroyed */ + ObReferenceObject(pCurDo); + pData->pDevObj = pCurDo; + /* we are done */ + return FALSE; + } + else + { + LOG(("driver object (0x%p) no match", pCurDo->DriverObject)); + if (pCurDo->DriverObject) + { + if ( pCurDo->DriverObject->DriverName.Buffer + && pCurDo->DriverObject->DriverName.Length) + { + LOG(("driver name not match, was:")); + LOG_USTR(&pCurDo->DriverObject->DriverName); + LOG(("but expected:")); + LOG_USTR(pData->pDrvName); + } + else + { + LOG(("driver name is zero, Length(%d), Buffer(0x%p)", + pCurDo->DriverObject->DriverName.Length, pCurDo->DriverObject->DriverName.Buffer)); + } + } + else + { + LOG(("driver object is NULL")); + } + } + return TRUE; +} + +VOID vboxUsbMonHubDevWalk(PFNVBOXUSBMONDEVWALKER pfnWalker, PVOID pvWalker, ULONG fFlags) +{ + NTSTATUS Status = STATUS_UNSUCCESSFUL; +#ifndef VBOX_USB3PORT + UNICODE_STRING szStandardHubName; + PDRIVER_OBJECT pDrvObj = NULL; + szStandardHubName.Length = 0; + szStandardHubName.MaximumLength = 0; + szStandardHubName.Buffer = 0; + RtlInitUnicodeString(&szStandardHubName, L"\\Driver\\usbhub"); + UNICODE_STRING szStandardHubPdoNamePrefix; + szStandardHubPdoNamePrefix.Length = 0; + szStandardHubPdoNamePrefix.MaximumLength = 0; + szStandardHubPdoNamePrefix.Buffer = 0; + RtlInitUnicodeString(&szStandardHubPdoNamePrefix, L"\\Device\\USBPDO-"); + + for (int i = 0; i < 16; i++) + { + WCHAR szwHubName[32] = {0}; + char szHubName[32] = {0}; + ANSI_STRING AnsiName; + UNICODE_STRING UnicodeName; + PDEVICE_OBJECT pHubDevObj; + PFILE_OBJECT pHubFileObj; + + sprintf(szHubName, "\\Device\\USBPDO-%d", i); + + RtlInitAnsiString(&AnsiName, szHubName); + + UnicodeName.Length = 0; + UnicodeName.MaximumLength = sizeof (szwHubName); + UnicodeName.Buffer = szwHubName; + + RtlInitAnsiString(&AnsiName, szHubName); + Status = RtlAnsiStringToUnicodeString(&UnicodeName, &AnsiName, FALSE); + if (Status == STATUS_SUCCESS) + { + Status = IoGetDeviceObjectPointer(&UnicodeName, FILE_READ_DATA, &pHubFileObj, &pHubDevObj); + if (Status == STATUS_SUCCESS) + { + LOG(("IoGetDeviceObjectPointer for \\Device\\USBPDO-%d returned %p %p", i, pHubDevObj, pHubFileObj)); + + VBOXUSBOBJDRVOBJSEARCHER Data = {0}; + Data.pDrvName = &szStandardHubName; + Data.pPdoNamePrefix = &szStandardHubPdoNamePrefix; + Data.fFlags = fFlags; + + vboxUsbObjDevStackWalk(pHubDevObj, vboxUsbObjDevObjSearcherWalker, &Data); + if (Data.pDevObj) + { + LOG(("found hub dev obj (0x%p)", Data.pDevObj)); + if (!pfnWalker(pHubFileObj, pHubDevObj, Data.pDevObj, pvWalker)) + { + LOG(("the walker said to stop")); + ObDereferenceObject(Data.pDevObj); + ObDereferenceObject(pHubFileObj); + break; + } + + LOG(("going forward..")); + ObDereferenceObject(Data.pDevObj); + } + else + { + LOG(("no hub driver obj found")); + ASSERT_WARN(!Data.pDevObj, ("non-null dev obj poiter returned (0x%p)", Data.pDevObj)); + } + + /* this will dereference both file and dev obj */ + ObDereferenceObject(pHubFileObj); + } + else + { + LOG(("IoGetDeviceObjectPointer returned Status (0x%x) for (\\Device\\USBPDO-%d)", Status, i)); + } + } + else + { + WARN(("RtlAnsiStringToUnicodeString failed, Status (0x%x) for Ansu name (\\Device\\USBPDO-%d)", Status, i)); + } + } +#else /* VBOX_USB3PORT */ + RT_NOREF1(fFlags); + PWSTR szwHubList; + Status = IoGetDeviceInterfaces(&GUID_DEVINTERFACE_USB_HUB, NULL, 0, &szwHubList); + if (Status != STATUS_SUCCESS) + { + LOG(("IoGetDeviceInterfaces failed with %d\n", Status)); + return; + } + if (szwHubList) + { + UNICODE_STRING UnicodeName; + PDEVICE_OBJECT pHubDevObj; + PFILE_OBJECT pHubFileObj; + PWSTR szwHubName = szwHubList; + while (*szwHubName != UNICODE_NULL) + { + RtlInitUnicodeString(&UnicodeName, szwHubName); + Status = IoGetDeviceObjectPointer(&UnicodeName, FILE_READ_DATA, &pHubFileObj, &pHubDevObj); + if (Status == STATUS_SUCCESS) + { + /* We could not log hub name here. + * It is the paged memory and we cannot use it in logger cause it increases the IRQL + */ + LOG(("IoGetDeviceObjectPointer returned %p %p", pHubDevObj, pHubFileObj)); + if (!pfnWalker(pHubFileObj, pHubDevObj, pHubDevObj, pvWalker)) + { + LOG(("the walker said to stop")); + ObDereferenceObject(pHubFileObj); + break; + } + + LOG(("going forward..")); + ObDereferenceObject(pHubFileObj); + } + szwHubName += wcslen(szwHubName) + 1; + } + ExFreePool(szwHubList); + } +#endif /* VBOX_USB3PORT */ +} + +typedef struct VBOXUSBMONFINDHUBWALKER +{ + PDRIVER_OBJECT pDrvObj; +} VBOXUSBMONFINDHUBWALKER, *PVBOXUSBMONFINDHUBWALKER; + +static DECLCALLBACK(BOOLEAN) vboxUsbMonFindHubDrvObjWalker(PFILE_OBJECT pFile, PDEVICE_OBJECT pTopDo, PDEVICE_OBJECT pHubDo, PVOID pvContext) +{ + RT_NOREF2(pFile, pTopDo); + PVBOXUSBMONFINDHUBWALKER pData = (PVBOXUSBMONFINDHUBWALKER)pvContext; + PDRIVER_OBJECT pDrvObj = pHubDo->DriverObject; + + ASSERT_WARN(!pData->pDrvObj, ("pDrvObj expected null on enter, but was(0x%p)", pData->pDrvObj)); + if (pDrvObj) + { + LOG(("found driver object 0x%p", pDrvObj)); + ObReferenceObject(pDrvObj); + pData->pDrvObj = pDrvObj; + return FALSE; + } + + WARN(("null pDrvObj!")); + return TRUE; +} + +static PDRIVER_OBJECT vboxUsbMonHookFindHubDrvObj() +{ + UNICODE_STRING szStandardHubName; + szStandardHubName.Length = 0; + szStandardHubName.MaximumLength = 0; + szStandardHubName.Buffer = 0; + RtlInitUnicodeString(&szStandardHubName, L"\\Driver\\usbhub"); + + LOG(("Search USB hub")); + VBOXUSBMONFINDHUBWALKER Data = {0}; + vboxUsbMonHubDevWalk(vboxUsbMonFindHubDrvObjWalker, &Data, VBOXUSBMONHUBWALK_F_ALL); + if (Data.pDrvObj) + LOG(("returning driver object 0x%p", Data.pDrvObj)); + else + WARN(("no hub driver object found!")); + return Data.pDrvObj; +} + +/* NOTE: the stack location data is not the "actual" IRP stack location, + * but a copy being preserved on the IRP way down. + * See the note in VBoxUsbPnPCompletion for detail */ +static NTSTATUS vboxUsbMonHandlePnPIoctl(PDEVICE_OBJECT pDevObj, PIO_STACK_LOCATION pSl, PIO_STATUS_BLOCK pIoStatus) +{ + LOG(("IRQL = %d", KeGetCurrentIrql())); + switch(pSl->MinorFunction) + { + case IRP_MN_QUERY_DEVICE_TEXT: + { + LOG(("IRP_MN_QUERY_DEVICE_TEXT: pIoStatus->Status = %x", pIoStatus->Status)); + if (pIoStatus->Status == STATUS_SUCCESS) + { + WCHAR *pId = (WCHAR *)pIoStatus->Information; + if (VALID_PTR(pId)) + { + KIRQL Iqrl = KeGetCurrentIrql(); + /* IRQL should be always passive here */ + ASSERT_WARN(Iqrl == PASSIVE_LEVEL, ("irql is not PASSIVE")); + switch(pSl->Parameters.QueryDeviceText.DeviceTextType) + { + case DeviceTextLocationInformation: + LOG(("DeviceTextLocationInformation")); + LOG_STRW(pId); + break; + + case DeviceTextDescription: + LOG(("DeviceTextDescription")); + LOG_STRW(pId); + if (VBoxUsbFltPdoIsFiltered(pDevObj)) + { + LOG(("PDO (0x%p) is filtered", pDevObj)); + WCHAR *pId = (WCHAR *)ExAllocatePool(PagedPool, sizeof(szDeviceTextDescription)); + if (!pId) + { + AssertFailed(); + break; + } + memcpy(pId, szDeviceTextDescription, sizeof(szDeviceTextDescription)); + LOG(("NEW szDeviceTextDescription")); + LOG_STRW(pId); + ExFreePool((PVOID)pIoStatus->Information); + pIoStatus->Information = (ULONG_PTR)pId; + } + else + { + LOG(("PDO (0x%p) is NOT filtered", pDevObj)); + } + break; + default: + LOG(("DeviceText %d", pSl->Parameters.QueryDeviceText.DeviceTextType)); + break; + } + } + else + LOG(("Invalid pointer %p", pId)); + } + break; + } + + case IRP_MN_QUERY_ID: + { + LOG(("IRP_MN_QUERY_ID: Irp->pIoStatus->Status = %x", pIoStatus->Status)); + if (pIoStatus->Status == STATUS_SUCCESS && pDevObj) + { + WCHAR *pId = (WCHAR *)pIoStatus->Information; +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + WCHAR *pTmp; +#endif + if (VALID_PTR(pId)) + { + KIRQL Iqrl = KeGetCurrentIrql(); + /* IRQL should be always passive here */ + ASSERT_WARN(Iqrl == PASSIVE_LEVEL, ("irql is not PASSIVE")); + + switch (pSl->Parameters.QueryId.IdType) + { + case BusQueryInstanceID: + LOG(("BusQueryInstanceID")); + LOG_STRW(pId); + break; + + case BusQueryDeviceID: + { + LOG(("BusQueryDeviceID")); + pId = (WCHAR *)ExAllocatePool(PagedPool, sizeof(szBusQueryDeviceId)); + if (!pId) + { + WARN(("ExAllocatePool failed")); + break; + } + + BOOLEAN bFiltered = FALSE; + NTSTATUS Status = VBoxUsbFltPdoAdd(pDevObj, &bFiltered); + if (Status != STATUS_SUCCESS || !bFiltered) + { + if (Status == STATUS_SUCCESS) + { + LOG(("PDO (0x%p) is NOT filtered", pDevObj)); + } + else + { + WARN(("VBoxUsbFltPdoAdd for PDO (0x%p) failed Status 0x%x", pDevObj, Status)); + } + ExFreePool(pId); + break; + } + + LOG(("PDO (0x%p) is filtered", pDevObj)); + ExFreePool((PVOID)pIoStatus->Information); + memcpy(pId, szBusQueryDeviceId, sizeof(szBusQueryDeviceId)); + pIoStatus->Information = (ULONG_PTR)pId; + break; + } + case BusQueryHardwareIDs: + { + LOG(("BusQueryHardwareIDs")); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + while (*pId) //MULTI_SZ + { + LOG_STRW(pId); + while (*pId) pId++; + pId++; + } +#endif + pId = (WCHAR *)ExAllocatePool(PagedPool, sizeof(szBusQueryHardwareIDs)); + if (!pId) + { + WARN(("ExAllocatePool failed")); + break; + } + + BOOLEAN bFiltered = FALSE; + NTSTATUS Status = VBoxUsbFltPdoAdd(pDevObj, &bFiltered); + if (Status != STATUS_SUCCESS || !bFiltered) + { + if (Status == STATUS_SUCCESS) + { + LOG(("PDO (0x%p) is NOT filtered", pDevObj)); + } + else + { + WARN(("VBoxUsbFltPdoAdd for PDO (0x%p) failed Status 0x%x", pDevObj, Status)); + } + ExFreePool(pId); + break; + } + + LOG(("PDO (0x%p) is filtered", pDevObj)); + + memcpy(pId, szBusQueryHardwareIDs, sizeof(szBusQueryHardwareIDs)); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + LOG(("NEW BusQueryHardwareIDs")); + pTmp = pId; + while (*pTmp) //MULTI_SZ + { + + LOG_STRW(pTmp); + while (*pTmp) pTmp++; + pTmp++; + } +#endif + ExFreePool((PVOID)pIoStatus->Information); + pIoStatus->Information = (ULONG_PTR)pId; + break; + } + case BusQueryCompatibleIDs: + LOG(("BusQueryCompatibleIDs")); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + while (*pId) //MULTI_SZ + { + LOG_STRW(pId); + while (*pId) pId++; + pId++; + } +#endif + if (VBoxUsbFltPdoIsFiltered(pDevObj)) + { + LOG(("PDO (0x%p) is filtered", pDevObj)); + pId = (WCHAR *)ExAllocatePool(PagedPool, sizeof(szBusQueryCompatibleIDs)); + if (!pId) + { + WARN(("ExAllocatePool failed")); + break; + } + memcpy(pId, szBusQueryCompatibleIDs, sizeof(szBusQueryCompatibleIDs)); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + LOG(("NEW BusQueryCompatibleIDs")); + pTmp = pId; + while (*pTmp) //MULTI_SZ + { + LOG_STRW(pTmp); + while (*pTmp) pTmp++; + pTmp++; + } +#endif + ExFreePool((PVOID)pIoStatus->Information); + pIoStatus->Information = (ULONG_PTR)pId; + } + else + { + LOG(("PDO (0x%p) is NOT filtered", pDevObj)); + } + break; + + default: + /** @todo r=bird: handle BusQueryContainerID and whatever else we might see */ + break; + } + } + else + { + LOG(("Invalid pointer %p", pId)); + } + } + break; + } + +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + case IRP_MN_QUERY_DEVICE_RELATIONS: + { + switch(pSl->Parameters.QueryDeviceRelations.Type) + { + case BusRelations: + LOG(("BusRelations")); + + if (pIoStatus->Status == STATUS_SUCCESS) + { + PDEVICE_RELATIONS pRel = (PDEVICE_RELATIONS)pIoStatus->Information; + LOG(("pRel = %p", pRel)); + if (VALID_PTR(pRel)) + { + for (unsigned i=0;i<pRel->Count;i++) + { + if (VBoxUsbFltPdoIsFiltered(pDevObj)) + LOG(("New PDO %p", pRel->Objects[i])); + } + } + else + LOG(("Invalid pointer %p", pRel)); + } + break; + case TargetDeviceRelation: + LOG(("TargetDeviceRelation")); + break; + case RemovalRelations: + LOG(("RemovalRelations")); + break; + case EjectionRelations: + LOG(("EjectionRelations")); + break; + default: + LOG(("QueryDeviceRelations.Type=%d", pSl->Parameters.QueryDeviceRelations.Type)); + } + break; + } + + case IRP_MN_QUERY_CAPABILITIES: + { + LOG(("IRP_MN_QUERY_CAPABILITIES: pIoStatus->Status = %x", pIoStatus->Status)); + if (pIoStatus->Status == STATUS_SUCCESS) + { + PDEVICE_CAPABILITIES pCaps = pSl->Parameters.DeviceCapabilities.Capabilities; + if (VALID_PTR(pCaps)) + { + LOG(("Caps.SilentInstall = %d", pCaps->SilentInstall)); + LOG(("Caps.UniqueID = %d", pCaps->UniqueID )); + LOG(("Caps.Address = %d", pCaps->Address )); + LOG(("Caps.UINumber = %d", pCaps->UINumber )); + } + else + LOG(("Invalid pointer %p", pCaps)); + } + break; + } + + default: + break; +#endif + } /*switch */ + + LOG(("Done returns %x (IRQL = %d)", pIoStatus->Status, KeGetCurrentIrql())); + return pIoStatus->Status; +} + +NTSTATUS _stdcall VBoxUsbPnPCompletion(DEVICE_OBJECT *pDevObj, IRP *pIrp, void *pvContext) +{ + LOG(("Completion PDO(0x%p), IRP(0x%p), Status(0x%x)", pDevObj, pIrp, pIrp->IoStatus.Status)); + ASSERT_WARN(pvContext, ("zero context")); + + PVBOXUSBHOOK_REQUEST pRequest = (PVBOXUSBHOOK_REQUEST)pvContext; + /* NOTE: despite a regular IRP processing the stack location in our completion + * differs from those of the PnP hook since the hook is invoked in the "context" of the calle, + * while the completion is in the "coller" context in terms of IRP, + * so the completion stack location is one level "up" here. + * + * Moreover we CAN NOT access irp stack location in the completion because we might not have one at all + * in case the hooked driver is at the top of the irp call stack + * + * This is why we use the stack location we saved on IRP way down. + * */ + PIO_STACK_LOCATION pSl = &pRequest->OldLocation; + ASSERT_WARN(pIrp == pRequest->pIrp, ("completed IRP(0x%x) not match request IRP(0x%x)", pIrp, pRequest->pIrp)); + /* NOTE: we can not rely on pDevObj passed in IoCompletion since it may be zero + * in case IRP was created with extra stack locations and the caller did not initialize + * the IO_STACK_LOCATION::DeviceObject */ + DEVICE_OBJECT *pRealDevObj = pRequest->pDevObj; +// Assert(!pDevObj || pDevObj == pRealDevObj); +// Assert(pSl->DeviceObject == pDevObj); + + switch(pSl->MinorFunction) + { + case IRP_MN_QUERY_DEVICE_TEXT: + case IRP_MN_QUERY_ID: +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + case IRP_MN_QUERY_DEVICE_RELATIONS: + case IRP_MN_QUERY_CAPABILITIES: +#endif + if (NT_SUCCESS(pIrp->IoStatus.Status)) + { + vboxUsbMonHandlePnPIoctl(pRealDevObj, pSl, &pIrp->IoStatus); + } + else + { + ASSERT_WARN(pIrp->IoStatus.Status == STATUS_NOT_SUPPORTED, ("Irp failed with status(0x%x)", pIrp->IoStatus.Status)); + } + break; + + case IRP_MN_SURPRISE_REMOVAL: + case IRP_MN_REMOVE_DEVICE: + if (NT_SUCCESS(pIrp->IoStatus.Status)) + { + VBoxUsbFltPdoRemove(pRealDevObj); + } + else + { + AssertFailed(); + } + break; + + /* These two IRPs are received when the PnP subsystem has determined the id of the newly arrived device */ + /* IRP_MN_START_DEVICE only arrives if it's a USB device of a known class or with a present host driver */ + case IRP_MN_QUERY_RESOURCE_REQUIREMENTS: + case IRP_MN_QUERY_RESOURCES: + if (NT_SUCCESS(pIrp->IoStatus.Status) || pIrp->IoStatus.Status == STATUS_NOT_SUPPORTED) + { + VBoxUsbFltPdoAddCompleted(pRealDevObj); + } + else + { + AssertFailed(); + } + break; + + default: + break; + } + + LOG(("<==PnP: Mn(%s), PDO(0x%p), IRP(0x%p), Status(0x%x), Sl PDO(0x%p), Compl PDO(0x%p)", + vboxUsbDbgStrPnPMn(pSl->MinorFunction), + pRealDevObj, pIrp, pIrp->IoStatus.Status, + pSl->DeviceObject, pDevObj)); +#ifdef DEBUG_misha + NTSTATUS tmpStatus = pIrp->IoStatus.Status; +#endif +#ifdef VBOX_USB3PORT + PVBOXUSBHOOK_ENTRY pHook = pRequest->pHook; +#else /* !VBOX_USB3PORT */ + PVBOXUSBHOOK_ENTRY pHook = &g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook; +#endif /* !VBOX_USB3PORT */ + NTSTATUS Status = VBoxUsbHookRequestComplete(pHook, pDevObj, pIrp, pRequest); + VBoxUsbMonMemFree(pRequest); +#ifdef DEBUG_misha + if (Status != STATUS_MORE_PROCESSING_REQUIRED) + { + Assert(pIrp->IoStatus.Status == tmpStatus); + } +#endif + VBoxUsbHookRelease(pHook); + return Status; +} + +/** + * Device PnP hook + * + * @param pDevObj Device object. + * @param pIrp Request packet. + */ +#ifdef VBOX_USB3PORT +static NTSTATUS vboxUsbMonPnPHook(IN PVBOXUSBHOOK_ENTRY pHook, IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) +#else /* !VBOX_USB3PORT */ +NTSTATUS _stdcall VBoxUsbMonPnPHook(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) +#endif /* !VBOX_USB3PORT */ +{ +#ifndef VBOX_USB3PORT + PVBOXUSBHOOK_ENTRY pHook = &g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook; +#endif /* !VBOX_USB3PORT */ + LOG(("==>PnP: Mn(%s), PDO(0x%p), IRP(0x%p), Status(0x%x)", vboxUsbDbgStrPnPMn(IoGetCurrentIrpStackLocation(pIrp)->MinorFunction), pDevObj, pIrp, pIrp->IoStatus.Status)); + + if (!VBoxUsbHookRetain(pHook)) + { + WARN(("VBoxUsbHookRetain failed")); + return VBoxUsbHookRequestPassDownHookSkip(pHook, pDevObj, pIrp); + } + + PVBOXUSBHUB_PNPHOOK_COMPLETION pCompletion = (PVBOXUSBHUB_PNPHOOK_COMPLETION)VBoxUsbMonMemAlloc(sizeof (*pCompletion)); + if (!pCompletion) + { + WARN(("VBoxUsbMonMemAlloc failed")); + VBoxUsbHookRelease(pHook); + pIrp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES; + pIrp->IoStatus.Information = 0; + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + return STATUS_INSUFFICIENT_RESOURCES; + } + + NTSTATUS Status = VBoxUsbHookRequestPassDownHookCompletion(pHook, pDevObj, pIrp, VBoxUsbPnPCompletion, &pCompletion->Rq); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + if (Status != STATUS_PENDING) + { + LOG(("Request completed, Status(0x%x)", Status)); + VBoxUsbHookVerifyCompletion(pHook, &pCompletion->Rq, pIrp); + } + else + { + LOG(("Request pending")); + } +#endif + return Status; +} + +#ifdef VBOX_USB3PORT +/** + * Device PnP hook stubs. + * + * @param pDevObj Device object. + * @param pIrp Request packet. + */ +#define VBOX_PNPHOOKSTUB(n) NTSTATUS _stdcall VBoxUsbMonPnPHook##n(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp) \ +{ \ + return vboxUsbMonPnPHook(&g_VBoxUsbMonGlobals.pDrivers[n].UsbHubPnPHook.Hook, pDevObj, pIrp); \ +} + +#define VBOX_PNPHOOKSTUB_INIT(n) g_VBoxUsbMonGlobals.pDrivers[n].pfnHookStub = VBoxUsbMonPnPHook##n + +VBOX_PNPHOOKSTUB(0) +VBOX_PNPHOOKSTUB(1) +VBOX_PNPHOOKSTUB(2) +VBOX_PNPHOOKSTUB(3) +VBOX_PNPHOOKSTUB(4) +AssertCompile(VBOXUSBMON_MAXDRIVERS == 5); + +typedef struct VBOXUSBMONHOOKDRIVERWALKER +{ + PDRIVER_OBJECT pDrvObj; +} VBOXUSBMONHOOKDRIVERWALKER, *PVBOXUSBMONHOOKDRIVERWALKER; + +/** + * Logs an error to the system event log. + * + * @param ErrCode Error to report to event log. + * @param ReturnedStatus Error that was reported by the driver to the caller. + * @param uErrId Unique error id representing the location in the driver. + * @param cbDumpData Number of bytes at pDumpData. + * @param pDumpData Pointer to data that will be added to the message (see 'details' tab). + */ +static void vboxUsbMonLogError(NTSTATUS ErrCode, NTSTATUS ReturnedStatus, ULONG uErrId, USHORT cbDumpData, PVOID pDumpData) +{ + PIO_ERROR_LOG_PACKET pErrEntry; + + + /* Truncate dumps that do not fit into IO_ERROR_LOG_PACKET. */ + if (FIELD_OFFSET(IO_ERROR_LOG_PACKET, DumpData) + cbDumpData > ERROR_LOG_MAXIMUM_SIZE) + cbDumpData = ERROR_LOG_MAXIMUM_SIZE - FIELD_OFFSET(IO_ERROR_LOG_PACKET, DumpData); + + pErrEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(g_VBoxUsbMonGlobals.pDevObj, + FIELD_OFFSET(IO_ERROR_LOG_PACKET, DumpData) + cbDumpData); + if (pErrEntry) + { + uint8_t *pDump = (uint8_t *)pErrEntry->DumpData; + if (cbDumpData) + memcpy(pDump, pDumpData, cbDumpData); + pErrEntry->MajorFunctionCode = 0; + pErrEntry->RetryCount = 0; + pErrEntry->DumpDataSize = cbDumpData; + pErrEntry->NumberOfStrings = 0; + pErrEntry->StringOffset = 0; + pErrEntry->ErrorCode = ErrCode; + pErrEntry->UniqueErrorValue = uErrId; + pErrEntry->FinalStatus = ReturnedStatus; + pErrEntry->IoControlCode = 0; + IoWriteErrorLogEntry(pErrEntry); + } + else + { + LOG(("Failed to allocate error log entry (cb=%d)\n", FIELD_OFFSET(IO_ERROR_LOG_PACKET, DumpData) + cbDumpData)); + } +} + +static DECLCALLBACK(BOOLEAN) vboxUsbMonHookDrvObjWalker(PFILE_OBJECT pFile, PDEVICE_OBJECT pTopDo, PDEVICE_OBJECT pHubDo, PVOID pvContext) +{ + RT_NOREF3(pFile, pTopDo, pvContext); + PDRIVER_OBJECT pDrvObj = pHubDo->DriverObject; + + /* First we try to figure out if we are already hooked to this driver. */ + for (int i = 0; i < VBOXUSBMON_MAXDRIVERS; i++) + if (pDrvObj == g_VBoxUsbMonGlobals.pDrivers[i].DriverObject) + { + LOG(("Found %p at pDrivers[%d]\n", pDrvObj, i)); + /* We've already hooked to this one -- nothing to do. */ + return TRUE; + } + /* We are not hooked yet, find an empty slot. */ + for (int i = 0; i < VBOXUSBMON_MAXDRIVERS; i++) + { + if (!g_VBoxUsbMonGlobals.pDrivers[i].DriverObject) + { + /* Found an emtpy slot, use it. */ + g_VBoxUsbMonGlobals.pDrivers[i].DriverObject = pDrvObj; + ObReferenceObject(pDrvObj); + LOG(("pDrivers[%d] = %p, installing the hook...\n", i, pDrvObj)); + VBoxUsbHookInit(&g_VBoxUsbMonGlobals.pDrivers[i].UsbHubPnPHook.Hook, + pDrvObj, + IRP_MJ_PNP, + g_VBoxUsbMonGlobals.pDrivers[i].pfnHookStub); + VBoxUsbHookInstall(&g_VBoxUsbMonGlobals.pDrivers[i].UsbHubPnPHook.Hook); + return TRUE; /* Must continue to find all drivers. */ + } + if (pDrvObj == g_VBoxUsbMonGlobals.pDrivers[i].DriverObject) + { + LOG(("Found %p at pDrivers[%d]\n", pDrvObj, i)); + /* We've already hooked to this one -- nothing to do. */ + return TRUE; + } + } + /* No empty slots! No reason to continue. */ + LOG(("No empty slots!\n")); + ANSI_STRING ansiDrvName; + NTSTATUS Status = RtlUnicodeStringToAnsiString(&ansiDrvName, &pDrvObj->DriverName, true); + if (Status != STATUS_SUCCESS) + { + ansiDrvName.Length = 0; + LOG(("RtlUnicodeStringToAnsiString failed with 0x%x", Status)); + } + vboxUsbMonLogError(IO_ERR_INSUFFICIENT_RESOURCES, STATUS_SUCCESS, 1, ansiDrvName.Length, ansiDrvName.Buffer); + if (Status == STATUS_SUCCESS) + RtlFreeAnsiString(&ansiDrvName); + return FALSE; +} + +/** + * Finds all USB drivers in the system and installs hooks if haven't done already. + */ +static NTSTATUS vboxUsbMonInstallAllHooks() +{ + vboxUsbMonHubDevWalk(vboxUsbMonHookDrvObjWalker, NULL, VBOXUSBMONHUBWALK_F_ALL); + return STATUS_SUCCESS; +} +#endif /* VBOX_USB3PORT */ + +static NTSTATUS vboxUsbMonHookCheckInit() +{ + static bool fIsHookInited = false; + if (fIsHookInited) + { + LOG(("hook inited already, success")); + return STATUS_SUCCESS; + } +#ifdef VBOX_USB3PORT + return vboxUsbMonInstallAllHooks(); +#else /* !VBOX_USB3PORT */ + PDRIVER_OBJECT pDrvObj = vboxUsbMonHookFindHubDrvObj(); + if (pDrvObj) + { + VBoxUsbHookInit(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook, pDrvObj, IRP_MJ_PNP, VBoxUsbMonPnPHook); + fIsHookInited = true; + LOG(("SUCCESS")); + return STATUS_SUCCESS; + } + WARN(("hub drv obj not found, fail")); + return STATUS_UNSUCCESSFUL; +#endif /* !VBOX_USB3PORT */ +} + +static NTSTATUS vboxUsbMonHookInstall() +{ +#ifdef VBOX_USB3PORT + /* Nothing to do here as we have already installed all hooks in vboxUsbMonHookCheckInit(). */ + return STATUS_SUCCESS; +#else /* !VBOX_USB3PORT */ +#ifdef VBOXUSBMON_DBG_NO_PNPHOOK + return STATUS_SUCCESS; +#else + if (g_VBoxUsbMonGlobals.UsbHubPnPHook.fUninitFailed) + { + WARN(("trying to hook usbhub pnp after the unhook failed, do nothing & pretend success")); + return STATUS_SUCCESS; + } + return VBoxUsbHookInstall(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook); +#endif +#endif /* !VBOX_USB3PORT */ +} + +static NTSTATUS vboxUsbMonHookUninstall() +{ +#ifdef VBOXUSBMON_DBG_NO_PNPHOOK + return STATUS_SUCCESS; +#else +#ifdef VBOX_USB3PORT + NTSTATUS Status = STATUS_SUCCESS; + for (int i = 0; i < VBOXUSBMON_MAXDRIVERS; i++) + { + if (g_VBoxUsbMonGlobals.pDrivers[i].DriverObject) + { + Assert(g_VBoxUsbMonGlobals.pDrivers[i].DriverObject == g_VBoxUsbMonGlobals.pDrivers[i].UsbHubPnPHook.Hook.pDrvObj); + LOG(("Unhooking from %p...\n", g_VBoxUsbMonGlobals.pDrivers[i].DriverObject)); + Status = VBoxUsbHookUninstall(&g_VBoxUsbMonGlobals.pDrivers[i].UsbHubPnPHook.Hook); + if (!NT_SUCCESS(Status)) + { + /* + * We failed to uninstall the hook, so we keep the reference to the driver + * in order to prevent another driver re-using this slot because we are + * going to mark this hook as fUninitFailed. + */ + //AssertMsgFailed(("usbhub pnp unhook failed, setting the fUninitFailed flag, the current value of fUninitFailed (%d)", g_VBoxUsbMonGlobals.UsbHubPnPHook.fUninitFailed)); + LOG(("usbhub pnp unhook failed, setting the fUninitFailed flag, the current value of fUninitFailed (%d)", g_VBoxUsbMonGlobals.pDrivers[i].UsbHubPnPHook.fUninitFailed)); + g_VBoxUsbMonGlobals.pDrivers[i].UsbHubPnPHook.fUninitFailed = true; + } + else + { + /* The hook was removed successfully, now we can forget about this driver. */ + ObDereferenceObject(g_VBoxUsbMonGlobals.pDrivers[i].DriverObject); + g_VBoxUsbMonGlobals.pDrivers[i].DriverObject = NULL; + } + } + } +#else /* !VBOX_USB3PORT */ + NTSTATUS Status = VBoxUsbHookUninstall(&g_VBoxUsbMonGlobals.UsbHubPnPHook.Hook); + if (!NT_SUCCESS(Status)) + { + AssertMsgFailed(("usbhub pnp unhook failed, setting the fUninitFailed flag, the current value of fUninitFailed (%d)", g_VBoxUsbMonGlobals.UsbHubPnPHook.fUninitFailed)); + g_VBoxUsbMonGlobals.UsbHubPnPHook.fUninitFailed = true; + } +#endif /* !VBOX_USB3PORT */ + return Status; +#endif +} + + +static NTSTATUS vboxUsbMonCheckTermStuff() +{ + NTSTATUS Status = KeWaitForSingleObject(&g_VBoxUsbMonGlobals.OpenSynchEvent, + Executive, KernelMode, + FALSE, /* BOOLEAN Alertable */ + NULL /* IN PLARGE_INTEGER Timeout */ + ); + AssertRelease(Status == STATUS_SUCCESS); + + do + { + if (--g_VBoxUsbMonGlobals.cOpens) + break; + + Status = vboxUsbMonHookUninstall(); + + NTSTATUS tmpStatus = VBoxUsbFltTerm(); + if (!NT_SUCCESS(tmpStatus)) + { + /* this means a driver state is screwed up, KeBugCheckEx here ? */ + AssertReleaseFailed(); + } + } while (0); + + KeSetEvent(&g_VBoxUsbMonGlobals.OpenSynchEvent, 0, FALSE); + + return Status; +} + +static NTSTATUS vboxUsbMonCheckInitStuff() +{ + NTSTATUS Status = KeWaitForSingleObject(&g_VBoxUsbMonGlobals.OpenSynchEvent, + Executive, KernelMode, + FALSE, /* BOOLEAN Alertable */ + NULL /* IN PLARGE_INTEGER Timeout */ + ); + if (Status == STATUS_SUCCESS) + { + do + { + if (g_VBoxUsbMonGlobals.cOpens++) + { + LOG(("opens: %d, success", g_VBoxUsbMonGlobals.cOpens)); + break; + } + + Status = VBoxUsbFltInit(); + if (NT_SUCCESS(Status)) + { + Status = vboxUsbMonHookCheckInit(); + if (NT_SUCCESS(Status)) + { + Status = vboxUsbMonHookInstall(); + if (NT_SUCCESS(Status)) + { + Status = STATUS_SUCCESS; + LOG(("succeded!!")); + break; + } + else + { + WARN(("vboxUsbMonHookInstall failed, Status (0x%x)", Status)); + } + } + else + { + WARN(("vboxUsbMonHookCheckInit failed, Status (0x%x)", Status)); + } + VBoxUsbFltTerm(); + } + else + { + WARN(("VBoxUsbFltInit failed, Status (0x%x)", Status)); + } + + --g_VBoxUsbMonGlobals.cOpens; + Assert(!g_VBoxUsbMonGlobals.cOpens); + } while (0); + + KeSetEvent(&g_VBoxUsbMonGlobals.OpenSynchEvent, 0, FALSE); + } + else + { + WARN(("KeWaitForSingleObject failed, Status (0x%x)", Status)); + } + return Status; +} + +static NTSTATUS vboxUsbMonContextCreate(PVBOXUSBMONCTX *ppCtx) +{ + NTSTATUS Status; + *ppCtx = NULL; + PVBOXUSBMONCTX pFileCtx = (PVBOXUSBMONCTX)VBoxUsbMonMemAllocZ(sizeof (*pFileCtx)); + if (pFileCtx) + { + Status = vboxUsbMonCheckInitStuff(); + if (Status == STATUS_SUCCESS) + { + Status = VBoxUsbFltCreate(&pFileCtx->FltCtx); + if (Status == STATUS_SUCCESS) + { + *ppCtx = pFileCtx; + LOG(("succeeded!!")); + return STATUS_SUCCESS; + } + else + { + WARN(("VBoxUsbFltCreate failed")); + } + vboxUsbMonCheckTermStuff(); + } + else + { + WARN(("vboxUsbMonCheckInitStuff failed")); + } + VBoxUsbMonMemFree(pFileCtx); + } + else + { + WARN(("VBoxUsbMonMemAllocZ failed")); + Status = STATUS_NO_MEMORY; + } + + return Status; +} + +static NTSTATUS vboxUsbMonContextClose(PVBOXUSBMONCTX pCtx) +{ + NTSTATUS Status = VBoxUsbFltClose(&pCtx->FltCtx); + if (Status == STATUS_SUCCESS) + { + Status = vboxUsbMonCheckTermStuff(); + Assert(Status == STATUS_SUCCESS); + /* ignore the failure */ + VBoxUsbMonMemFree(pCtx); + } + + return Status; +} + +static NTSTATUS _stdcall VBoxUsbMonClose(PDEVICE_OBJECT pDevObj, PIRP pIrp) +{ + PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFileObj = pStack->FileObject; + Assert(pFileObj->FsContext); + PVBOXUSBMONCTX pCtx = (PVBOXUSBMONCTX)pFileObj->FsContext; + + LOG(("VBoxUsbMonClose")); + + NTSTATUS Status = vboxUsbMonContextClose(pCtx); + if (Status != STATUS_SUCCESS) + { + WARN(("vboxUsbMonContextClose failed, Status (0x%x), prefent unload", Status)); + if (!InterlockedExchange(&g_VBoxUsbMonGlobals.ulPreventUnloadOn, 1)) + { + LOGREL(("ulPreventUnloadOn not set, preventing unload")); + UNICODE_STRING UniName; + PDEVICE_OBJECT pTmpDevObj; + RtlInitUnicodeString(&UniName, USBMON_DEVICE_NAME_NT); + NTSTATUS tmpStatus = IoGetDeviceObjectPointer(&UniName, FILE_ALL_ACCESS, &g_VBoxUsbMonGlobals.pPreventUnloadFileObj, &pTmpDevObj); + AssertRelease(NT_SUCCESS(tmpStatus)); + AssertRelease(pTmpDevObj == pDevObj); + } + else + { + WARN(("ulPreventUnloadOn already set")); + } + LOG(("success!!")); + Status = STATUS_SUCCESS; + } + pFileObj->FsContext = NULL; + pIrp->IoStatus.Status = Status; + pIrp->IoStatus.Information = 0; + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + return Status; +} + + +static NTSTATUS _stdcall VBoxUsbMonCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp) +{ + RT_NOREF1(pDevObj); + PIO_STACK_LOCATION pStack = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFileObj = pStack->FileObject; + NTSTATUS Status; + + LOG(("VBoxUSBMonCreate")); + + if (pStack->Parameters.Create.Options & FILE_DIRECTORY_FILE) + { + WARN(("trying to open as a directory")); + pIrp->IoStatus.Status = STATUS_NOT_A_DIRECTORY; + pIrp->IoStatus.Information = 0; + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + return STATUS_NOT_A_DIRECTORY; + } + + pFileObj->FsContext = NULL; + PVBOXUSBMONCTX pCtx = NULL; + Status = vboxUsbMonContextCreate(&pCtx); + if (Status == STATUS_SUCCESS) + { + Assert(pCtx); + pFileObj->FsContext = pCtx; + } + else + { + WARN(("vboxUsbMonContextCreate failed Status (0x%x)", Status)); + } + + pIrp->IoStatus.Status = Status; + pIrp->IoStatus.Information = 0; + IoCompleteRequest(pIrp, IO_NO_INCREMENT); + return Status; +} + +static int VBoxUsbMonSetNotifyEvent(PVBOXUSBMONCTX pContext, HANDLE hEvent) +{ + int rc = VBoxUsbFltSetNotifyEvent(&pContext->FltCtx, hEvent); + return rc; +} + +static int VBoxUsbMonFltAdd(PVBOXUSBMONCTX pContext, PUSBFILTER pFilter, uintptr_t *pId) +{ +#ifdef VBOXUSBMON_DBG_NO_FILTERS + static uintptr_t idDummy = 1; + *pId = idDummy; + ++idDummy; + return VINF_SUCCESS; +#else + int rc = VBoxUsbFltAdd(&pContext->FltCtx, pFilter, pId); + return rc; +#endif +} + +static int VBoxUsbMonFltRemove(PVBOXUSBMONCTX pContext, uintptr_t uId) +{ +#ifdef VBOXUSBMON_DBG_NO_FILTERS + return VINF_SUCCESS; +#else + int rc = VBoxUsbFltRemove(&pContext->FltCtx, uId); + return rc; +#endif +} + +static NTSTATUS VBoxUsbMonRunFilters(PVBOXUSBMONCTX pContext) +{ + NTSTATUS Status = VBoxUsbFltFilterCheck(&pContext->FltCtx); + return Status; +} + +static NTSTATUS VBoxUsbMonGetDevice(PVBOXUSBMONCTX pContext, HVBOXUSBDEVUSR hDevice, PUSBSUP_GETDEV_MON pInfo) +{ + NTSTATUS Status = VBoxUsbFltGetDevice(&pContext->FltCtx, hDevice, pInfo); + return Status; +} + +static NTSTATUS vboxUsbMonIoctlDispatch(PVBOXUSBMONCTX pContext, ULONG Ctl, PVOID pvBuffer, ULONG cbInBuffer, + ULONG cbOutBuffer, ULONG_PTR *pInfo) +{ + NTSTATUS Status = STATUS_SUCCESS; + ULONG_PTR Info = 0; + switch (Ctl) + { + case SUPUSBFLT_IOCTL_GET_VERSION: + { + PUSBSUP_VERSION pOut = (PUSBSUP_VERSION)pvBuffer; + + LOG(("SUPUSBFLT_IOCTL_GET_VERSION")); + if (!pvBuffer || cbOutBuffer != sizeof(*pOut) || cbInBuffer != 0) + { + WARN(("SUPUSBFLT_IOCTL_GET_VERSION: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.", + cbInBuffer, 0, cbOutBuffer, sizeof (*pOut))); + Status = STATUS_INVALID_PARAMETER; + break; + } + pOut->u32Major = USBMON_MAJOR_VERSION; + pOut->u32Minor = USBMON_MINOR_VERSION; + Info = sizeof (*pOut); + ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status)); + break; + } + + case SUPUSBFLT_IOCTL_ADD_FILTER: + { + PUSBFILTER pFilter = (PUSBFILTER)pvBuffer; + PUSBSUP_FLTADDOUT pOut = (PUSBSUP_FLTADDOUT)pvBuffer; + uintptr_t uId = 0; + int rc; + if (RT_UNLIKELY(!pvBuffer || cbInBuffer != sizeof (*pFilter) || cbOutBuffer != sizeof (*pOut))) + { + WARN(("SUPUSBFLT_IOCTL_ADD_FILTER: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.", + cbInBuffer, sizeof (*pFilter), cbOutBuffer, sizeof (*pOut))); + Status = STATUS_INVALID_PARAMETER; + break; + } + + rc = VBoxUsbMonFltAdd(pContext, pFilter, &uId); + pOut->rc = rc; + pOut->uId = uId; + Info = sizeof (*pOut); + ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status)); + break; + } + + case SUPUSBFLT_IOCTL_REMOVE_FILTER: + { + uintptr_t *pIn = (uintptr_t *)pvBuffer; + int *pRc = (int *)pvBuffer; + + if (!pvBuffer || cbInBuffer != sizeof (*pIn) || (cbOutBuffer && cbOutBuffer != sizeof (*pRc))) + { + WARN(("SUPUSBFLT_IOCTL_REMOVE_FILTER: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.", + cbInBuffer, sizeof (*pIn), cbOutBuffer, 0)); + Status = STATUS_INVALID_PARAMETER; + break; + } + LOG(("SUPUSBFLT_IOCTL_REMOVE_FILTER %x", *pIn)); + int rc = VBoxUsbMonFltRemove(pContext, *pIn); + if (cbOutBuffer) + { + /* we've validated that already */ + Assert(cbOutBuffer == (ULONG)*pRc); + *pRc = rc; + Info = sizeof (*pRc); + } + ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status)); + break; + } + + case SUPUSBFLT_IOCTL_RUN_FILTERS: + { + if (pvBuffer || cbInBuffer || cbOutBuffer) + { + WARN(("SUPUSBFLT_IOCTL_RUN_FILTERS: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.", + cbInBuffer, 0, cbOutBuffer, 0)); + Status = STATUS_INVALID_PARAMETER; + break; + } + LOG(("SUPUSBFLT_IOCTL_RUN_FILTERS ")); + Status = VBoxUsbMonRunFilters(pContext); + ASSERT_WARN(Status != STATUS_PENDING, ("status pending!")); + break; + } + + case SUPUSBFLT_IOCTL_GET_DEVICE: + { + HVBOXUSBDEVUSR hDevice = *((HVBOXUSBDEVUSR*)pvBuffer); + PUSBSUP_GETDEV_MON pOut = (PUSBSUP_GETDEV_MON)pvBuffer; + if (!pvBuffer || cbInBuffer != sizeof (hDevice) || cbOutBuffer < sizeof (*pOut)) + { + WARN(("SUPUSBFLT_IOCTL_GET_DEVICE: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected >= %d.", + cbInBuffer, sizeof (hDevice), cbOutBuffer, sizeof (*pOut))); + Status = STATUS_INVALID_PARAMETER; + break; + } + + Status = VBoxUsbMonGetDevice(pContext, hDevice, pOut); + + if (NT_SUCCESS(Status)) + { + Info = sizeof (*pOut); + } + else + { + WARN(("VBoxUsbMonGetDevice fail 0x%x", Status)); + } + break; + } + + case SUPUSBFLT_IOCTL_SET_NOTIFY_EVENT: + { + PUSBSUP_SET_NOTIFY_EVENT pSne = (PUSBSUP_SET_NOTIFY_EVENT)pvBuffer; + if (!pvBuffer || cbInBuffer != sizeof (*pSne) || cbOutBuffer != sizeof (*pSne)) + { + WARN(("SUPUSBFLT_IOCTL_SET_NOTIFY_EVENT: Invalid input/output sizes. cbIn=%d expected %d. cbOut=%d expected %d.", + cbInBuffer, sizeof (*pSne), cbOutBuffer, sizeof (*pSne))); + Status = STATUS_INVALID_PARAMETER; + break; + } + + pSne->u.rc = VBoxUsbMonSetNotifyEvent(pContext, pSne->u.hEvent); + Info = sizeof (*pSne); + ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status)); + break; + } + + default: + WARN(("Unknown code 0x%x", Ctl)); + Status = STATUS_INVALID_PARAMETER; + break; + } + + ASSERT_WARN(Status != STATUS_PENDING, ("Status pending!")); + + *pInfo = Info; + return Status; +} + +static NTSTATUS _stdcall VBoxUsbMonDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp) +{ + ULONG_PTR Info = 0; + NTSTATUS Status = IoAcquireRemoveLock(&g_VBoxUsbMonGlobals.RmLock, pDevObj); + if (NT_SUCCESS(Status)) + { + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + PFILE_OBJECT pFileObj = pSl->FileObject; + Assert(pFileObj); + Assert(pFileObj->FsContext); + PVBOXUSBMONCTX pCtx = (PVBOXUSBMONCTX)pFileObj->FsContext; + Assert(pCtx); + Status = vboxUsbMonIoctlDispatch(pCtx, + pSl->Parameters.DeviceIoControl.IoControlCode, + pIrp->AssociatedIrp.SystemBuffer, + pSl->Parameters.DeviceIoControl.InputBufferLength, + pSl->Parameters.DeviceIoControl.OutputBufferLength, + &Info); + ASSERT_WARN(Status != STATUS_PENDING, ("Status pending")); + + IoReleaseRemoveLock(&g_VBoxUsbMonGlobals.RmLock, pDevObj); + } + else + { + WARN(("IoAcquireRemoveLock failed Status (0x%x)", Status)); + } + + pIrp->IoStatus.Information = Info; + pIrp->IoStatus.Status = Status; + IoCompleteRequest (pIrp, IO_NO_INCREMENT); + return Status; +} + +static NTSTATUS vboxUsbMonInternalIoctlDispatch(ULONG Ctl, PVOID pvBuffer, ULONG_PTR *pInfo) +{ + NTSTATUS Status = STATUS_SUCCESS; + *pInfo = 0; + switch (Ctl) + { + case VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION: + { + PVBOXUSBIDC_VERSION pOut = (PVBOXUSBIDC_VERSION)pvBuffer; + + LOG(("VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION")); + if (!pvBuffer) + { + WARN(("VBOXUSBIDC_INTERNAL_IOCTL_GET_VERSION: Buffer is NULL")); + Status = STATUS_INVALID_PARAMETER; + break; + } + pOut->u32Major = VBOXUSBIDC_VERSION_MAJOR; + pOut->u32Minor = VBOXUSBIDC_VERSION_MINOR; + ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status)); + break; + } + + case VBOXUSBIDC_INTERNAL_IOCTL_PROXY_STARTUP: + { + PVBOXUSBIDC_PROXY_STARTUP pOut = (PVBOXUSBIDC_PROXY_STARTUP)pvBuffer; + + LOG(("VBOXUSBIDC_INTERNAL_IOCTL_PROXY_STARTUP")); + if (!pvBuffer) + { + WARN(("VBOXUSBIDC_INTERNAL_IOCTL_PROXY_STARTUP: Buffer is NULL")); + Status = STATUS_INVALID_PARAMETER; + break; + } + + pOut->u.hDev = VBoxUsbFltProxyStarted(pOut->u.pPDO); + ASSERT_WARN(pOut->u.hDev, ("zero hDev")); + ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status)); + break; + } + + case VBOXUSBIDC_INTERNAL_IOCTL_PROXY_TEARDOWN: + { + PVBOXUSBIDC_PROXY_TEARDOWN pOut = (PVBOXUSBIDC_PROXY_TEARDOWN)pvBuffer; + + LOG(("VBOXUSBIDC_INTERNAL_IOCTL_PROXY_TEARDOWN")); + if (!pvBuffer) + { + WARN(("VBOXUSBIDC_INTERNAL_IOCTL_PROXY_TEARDOWN: Buffer is NULL")); + Status = STATUS_INVALID_PARAMETER; + break; + } + + ASSERT_WARN(pOut->hDev, ("zero hDev")); + VBoxUsbFltProxyStopped(pOut->hDev); + ASSERT_WARN(Status == STATUS_SUCCESS, ("unexpected status, 0x%x", Status)); + break; + } + + default: + { + WARN(("Unknown code 0x%x", Ctl)); + Status = STATUS_INVALID_PARAMETER; + break; + } + } + + return Status; +} + +static NTSTATUS _stdcall VBoxUsbMonInternalDeviceControl(PDEVICE_OBJECT pDevObj, PIRP pIrp) +{ + ULONG_PTR Info = 0; + NTSTATUS Status = IoAcquireRemoveLock(&g_VBoxUsbMonGlobals.RmLock, pDevObj); + if (NT_SUCCESS(Status)) + { + PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp); + Status = vboxUsbMonInternalIoctlDispatch(pSl->Parameters.DeviceIoControl.IoControlCode, + pSl->Parameters.Others.Argument1, + &Info); + Assert(Status != STATUS_PENDING); + + IoReleaseRemoveLock(&g_VBoxUsbMonGlobals.RmLock, pDevObj); + } + + pIrp->IoStatus.Information = Info; + pIrp->IoStatus.Status = Status; + IoCompleteRequest (pIrp, IO_NO_INCREMENT); + return Status; +} + +/** + * Unload the driver. + * + * @param pDrvObj Driver object. + */ +static void _stdcall VBoxUsbMonUnload(PDRIVER_OBJECT pDrvObj) +{ + RT_NOREF1(pDrvObj); + LOG(("VBoxUSBMonUnload pDrvObj (0x%p)", pDrvObj)); + + IoReleaseRemoveLockAndWait(&g_VBoxUsbMonGlobals.RmLock, &g_VBoxUsbMonGlobals); + + Assert(!g_VBoxUsbMonGlobals.cOpens); + + UNICODE_STRING DosName; + RtlInitUnicodeString(&DosName, USBMON_DEVICE_NAME_DOS); + IoDeleteSymbolicLink(&DosName); + + IoDeleteDevice(g_VBoxUsbMonGlobals.pDevObj); + + /* cleanup the logger */ + PRTLOGGER pLogger = RTLogRelSetDefaultInstance(NULL); + if (pLogger) + RTLogDestroy(pLogger); + pLogger = RTLogSetDefaultInstance(NULL); + if (pLogger) + RTLogDestroy(pLogger); +} + +RT_C_DECLS_BEGIN +NTSTATUS _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath); +RT_C_DECLS_END + +/** + * Driver entry point. + * + * @returns appropriate status code. + * @param pDrvObj Pointer to driver object. + * @param pRegPath Registry base path. + */ +NTSTATUS _stdcall DriverEntry(PDRIVER_OBJECT pDrvObj, PUNICODE_STRING pRegPath) +{ + RT_NOREF1(pRegPath); +#ifdef VBOX_USB_WITH_VERBOSE_LOGGING + RTLogGroupSettings(0, "+default.e.l.f.l2.l3"); + RTLogDestinations(0, "debugger"); +#endif + + LOGREL(("Built %s %s", __DATE__, __TIME__)); + + memset (&g_VBoxUsbMonGlobals, 0, sizeof (g_VBoxUsbMonGlobals)); +#ifdef VBOX_USB3PORT + VBOX_PNPHOOKSTUB_INIT(0); + VBOX_PNPHOOKSTUB_INIT(1); + VBOX_PNPHOOKSTUB_INIT(2); + VBOX_PNPHOOKSTUB_INIT(3); + VBOX_PNPHOOKSTUB_INIT(4); + AssertCompile(VBOXUSBMON_MAXDRIVERS == 5); +#endif /* VBOX_USB3PORT */ + KeInitializeEvent(&g_VBoxUsbMonGlobals.OpenSynchEvent, SynchronizationEvent, TRUE /* signaled */); + IoInitializeRemoveLock(&g_VBoxUsbMonGlobals.RmLock, VBOXUSBMON_MEMTAG, 1, 100); + UNICODE_STRING DevName; + PDEVICE_OBJECT pDevObj; + /* create the device */ + RtlInitUnicodeString(&DevName, USBMON_DEVICE_NAME_NT); + NTSTATUS Status = IoAcquireRemoveLock(&g_VBoxUsbMonGlobals.RmLock, &g_VBoxUsbMonGlobals); + if (NT_SUCCESS(Status)) + { + Status = IoCreateDevice(pDrvObj, sizeof (VBOXUSBMONINS), &DevName, FILE_DEVICE_UNKNOWN, 0, FALSE, &pDevObj); + if (NT_SUCCESS(Status)) + { + UNICODE_STRING DosName; + RtlInitUnicodeString(&DosName, USBMON_DEVICE_NAME_DOS); + Status = IoCreateSymbolicLink(&DosName, &DevName); + if (NT_SUCCESS(Status)) + { + PVBOXUSBMONINS pDevExt = (PVBOXUSBMONINS)pDevObj->DeviceExtension; + memset(pDevExt, 0, sizeof(*pDevExt)); + + pDrvObj->DriverUnload = VBoxUsbMonUnload; + pDrvObj->MajorFunction[IRP_MJ_CREATE] = VBoxUsbMonCreate; + pDrvObj->MajorFunction[IRP_MJ_CLOSE] = VBoxUsbMonClose; + pDrvObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = VBoxUsbMonDeviceControl; + pDrvObj->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = VBoxUsbMonInternalDeviceControl; + + g_VBoxUsbMonGlobals.pDevObj = pDevObj; + LOG(("VBoxUSBMon::DriverEntry returning STATUS_SUCCESS")); + return STATUS_SUCCESS; + } + IoDeleteDevice(pDevObj); + } + IoReleaseRemoveLockAndWait(&g_VBoxUsbMonGlobals.RmLock, &g_VBoxUsbMonGlobals); + } + + return Status; +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.h b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.h new file mode 100644 index 00000000..ffd32894 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.h @@ -0,0 +1,74 @@ +/* $Id: VBoxUsbMon.h $ */ +/** @file + * VBox USB Monitor + */ +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#ifndef VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbMon_h +#define VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbMon_h +#ifndef RT_WITHOUT_PRAGMA_ONCE +# pragma once +#endif + +#include <VBox/cdefs.h> +#include <VBox/types.h> +#include <iprt/assert.h> +#include <VBox/sup.h> +#include <iprt/asm.h> +#include <VBox/log.h> + +#ifdef DEBUG +/* disables filters */ +//#define VBOXUSBMON_DBG_NO_FILTERS +/* disables pnp hooking */ +//#define VBOXUSBMON_DBG_NO_PNPHOOK +#endif + +#include "../../../win/VBoxDbgLog.h" +#include "../cmn/VBoxDrvTool.h" +#include "../cmn/VBoxUsbTool.h" + +#include "VBoxUsbHook.h" +#include "VBoxUsbFlt.h" + +PVOID VBoxUsbMonMemAlloc(SIZE_T cbBytes); +PVOID VBoxUsbMonMemAllocZ(SIZE_T cbBytes); +VOID VBoxUsbMonMemFree(PVOID pvMem); + +NTSTATUS VBoxUsbMonGetDescriptor(PDEVICE_OBJECT pDevObj, void *buffer, int size, int type, int index, int language_id); +NTSTATUS VBoxUsbMonQueryBusRelations(PDEVICE_OBJECT pDevObj, PFILE_OBJECT pFileObj, PDEVICE_RELATIONS *pDevRelations); + +void vboxUsbDbgPrintUnicodeString(PUNICODE_STRING pUnicodeString); + +/* visit usbhub-originated device PDOs */ +#define VBOXUSBMONHUBWALK_F_PDO 0x00000001 +/* visit usbhub device FDOs */ +#define VBOXUSBMONHUBWALK_F_FDO 0x00000002 +/* visit all usbhub-originated device objects */ +#define VBOXUSBMONHUBWALK_F_ALL (VBOXUSBMONHUBWALK_F_FDO | VBOXUSBMONHUBWALK_F_PDO) + +typedef DECLCALLBACK(BOOLEAN) FNVBOXUSBMONDEVWALKER(PFILE_OBJECT pFile, PDEVICE_OBJECT pTopDo, PDEVICE_OBJECT pHubDo, PVOID pvContext); +typedef FNVBOXUSBMONDEVWALKER *PFNVBOXUSBMONDEVWALKER; + +VOID vboxUsbMonHubDevWalk(PFNVBOXUSBMONDEVWALKER pfnWalker, PVOID pvWalker, ULONG fFlags); + +#endif /* !VBOX_INCLUDED_SRC_VBoxUSB_win_mon_VBoxUsbMon_h */ diff --git a/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.rc b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.rc new file mode 100644 index 00000000..cab1b055 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/mon/VBoxUsbMon.rc @@ -0,0 +1,60 @@ +/* $Id: VBoxUsbMon.rc $ */ +/** @file + * VBoxUSBMon - Resource file containing version info and icon. + */ + +/* + * Copyright (C) 2011-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + +#include <windows.h> +#include <VBox/version.h> + +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VBOX_RC_FILE_VERSION + PRODUCTVERSION VBOX_RC_FILE_VERSION + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK + FILEFLAGS VBOX_RC_FILE_FLAGS + FILEOS VBOX_RC_FILE_OS + FILETYPE VBOX_RC_TYPE_DRV + FILESUBTYPE VFT2_DRV_SYSTEM +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" // Lang=US English, CharSet=Unicode + BEGIN + VALUE "FileDescription", "VirtualBox USB Monitor Driver\0" + VALUE "InternalName", "VBoxUSBMon\0" + VALUE "OriginalFilename", "VBoxUSBMon.sys\0" + VALUE "CompanyName", VBOX_RC_COMPANY_NAME + VALUE "FileVersion", VBOX_RC_FILE_VERSION_STR + VALUE "LegalCopyright", VBOX_RC_LEGAL_COPYRIGHT + VALUE "ProductName", VBOX_RC_PRODUCT_NAME_STR + VALUE "ProductVersion", VBOX_RC_PRODUCT_VERSION_STR + VBOX_RC_MORE_STRINGS + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END diff --git a/src/VBox/HostDrivers/VBoxUSB/win/testcase/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/testcase/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/testcase/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/testcase/USBTest.cpp b/src/VBox/HostDrivers/VBoxUSB/win/testcase/USBTest.cpp new file mode 100644 index 00000000..e47c2d52 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/testcase/USBTest.cpp @@ -0,0 +1,343 @@ +/* $Id: USBTest.cpp $ */ +/** @file + * VBox host drivers - USB drivers - Filter & driver installation + */ + +/* + * Copyright (C) 2006-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/win/windows.h> +#include <iprt/win/setupapi.h> +#include <newdev.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/string.h> +#include <VBox/err.h> +#include <stdio.h> +#include <VBox/usblib.h> +#include <VBox/VBoxDrvCfg-win.h> + +/** Handle to the open device. */ +static HANDLE g_hUSBMonitor = INVALID_HANDLE_VALUE; +/** Flags whether or not we started the service. */ +static bool g_fStartedService = false; + +/** + * Attempts to start the service, creating it if necessary. + * + * @returns 0 on success. + * @returns -1 on failure. + * @param fRetry Indicates retry call. + */ +int usbMonStartService(void) +{ + HRESULT hr = VBoxDrvCfgSvcStart(USBMON_SERVICE_NAME_W); + if (hr != S_OK) + { + AssertMsgFailed(("couldn't start service, hr (0x%x)\n", hr)); + return -1; + } + return 0; +} + +/** + * Stops a possibly running service. + * + * @returns 0 on success. + * @returns -1 on failure. + */ +int usbMonStopService(void) +{ + printf("usbMonStopService\n"); + /* + * Assume it didn't exist, so we'll create the service. + */ + int rc = -1; + SC_HANDLE hSMgr = OpenSCManager(NULL, NULL, SERVICE_STOP | SERVICE_QUERY_STATUS); + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsg(hSMgr, ("OpenSCManager(,,delete) failed rc=%d\n", LastError)); + if (hSMgr) + { + SC_HANDLE hService = OpenServiceW(hSMgr, USBMON_SERVICE_NAME_W, SERVICE_STOP | SERVICE_QUERY_STATUS); + if (hService) + { + /* + * Stop the service. + */ + SERVICE_STATUS Status; + QueryServiceStatus(hService, &Status); + if (Status.dwCurrentState == SERVICE_STOPPED) + rc = 0; + else if (ControlService(hService, SERVICE_CONTROL_STOP, &Status)) + { + int iWait = 100; + while (Status.dwCurrentState == SERVICE_STOP_PENDING && iWait-- > 0) + { + Sleep(100); + QueryServiceStatus(hService, &Status); + } + if (Status.dwCurrentState == SERVICE_STOPPED) + rc = 0; + else + AssertMsgFailed(("Failed to stop service. status=%d\n", Status.dwCurrentState)); + } + else + { + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsgFailed(("ControlService failed with LastError=%Rwa. status=%d\n", LastError, Status.dwCurrentState)); + } + CloseServiceHandle(hService); + } + else if (GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) + rc = 0; + else + { + DWORD LastError = GetLastError(); NOREF(LastError); + AssertMsgFailed(("OpenService failed LastError=%Rwa\n", LastError)); + } + CloseServiceHandle(hSMgr); + } + return rc; +} +/** + * Release specified USB device to the host. + * + * @returns VBox status code + * @param usVendorId Vendor id + * @param usProductId Product id + * @param usRevision Revision + */ +int usbMonReleaseDevice(USHORT usVendorId, USHORT usProductId, USHORT usRevision) +{ + USBSUP_RELEASE release; + DWORD cbReturned = 0; + + printf("usbLibReleaseDevice %x %x %x\n", usVendorId, usProductId, usRevision); + + release.usVendorId = usVendorId; + release.usProductId = usProductId; + release.usRevision = usRevision; + + if (!DeviceIoControl(g_hUSBMonitor, SUPUSBFLT_IOCTL_RELEASE_DEVICE, &release, sizeof(release), NULL, 0, &cbReturned, NULL)) + { + AssertMsgFailed(("DeviceIoControl failed with %d\n", GetLastError())); + return RTErrConvertFromWin32(GetLastError()); + } + + return VINF_SUCCESS; +} + + +/** + * Add USB device filter + * + * @returns VBox status code. + * @param pszVendor Vendor filter string + * @param pszProduct Product filter string + * @param pszRevision Revision filter string + * @param ppID Pointer to filter id + */ +int usbMonInsertFilter(const char *pszVendor, const char *pszProduct, const char *pszRevision, void **ppID) +{ + USBFILTER filter; + USBSUP_FLTADDOUT flt_add; + DWORD cbReturned = 0; + + Assert(g_hUSBMonitor); + + printf("usblibInsertFilter %s %s %s\n", pszVendor, pszProduct, pszRevision); + +// strncpy(filter.szVendor, pszVendor, sizeof(filter.szVendor)); +// strncpy(filter.szProduct, pszProduct, sizeof(filter.szProduct)); +// strncpy(filter.szRevision, pszRevision, sizeof(filter.szRevision)); + + if (!DeviceIoControl(g_hUSBMonitor, SUPUSBFLT_IOCTL_ADD_FILTER, &filter, sizeof(filter), &flt_add, sizeof(flt_add), &cbReturned, NULL)) + { + AssertMsgFailed(("DeviceIoControl failed with %d\n", GetLastError())); + return RTErrConvertFromWin32(GetLastError()); + } + *ppID = (void *)flt_add.uId; + return VINF_SUCCESS; +} + +/** + * Remove USB device filter + * + * @returns VBox status code. + * @param aID Filter id + */ +int usbMonRemoveFilter (void *aID) +{ + uintptr_t uId; + DWORD cbReturned = 0; + + Assert(g_hUSBMonitor); + + printf("usblibRemoveFilter %p\n", aID); + + uId = (uintptr_t)aID; + if (!DeviceIoControl(g_hUSBMonitor, SUPUSBFLT_IOCTL_REMOVE_FILTER, &uId, sizeof(uId), NULL, 0,&cbReturned, NULL)) + { + AssertMsgFailed(("DeviceIoControl failed with %d\n", GetLastError())); + return RTErrConvertFromWin32(GetLastError()); + } + return VINF_SUCCESS; +} + +/** + * Initialize the USB monitor + * + * @returns VBox status code. + */ +int usbMonitorInit() +{ + int rc; + USBSUP_VERSION version = {0}; + DWORD cbReturned; + + printf("usbproxy: usbLibInit\n"); + + g_hUSBMonitor = CreateFile (USBMON_DEVICE_NAME, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, // no SECURITY_ATTRIBUTES structure + OPEN_EXISTING, // No special create flags + FILE_ATTRIBUTE_SYSTEM, + NULL); // No template file + + if (g_hUSBMonitor == INVALID_HANDLE_VALUE) + { + usbMonStartService(); + + g_hUSBMonitor = CreateFile (USBMON_DEVICE_NAME, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, // no SECURITY_ATTRIBUTES structure + OPEN_EXISTING, // No special create flags + FILE_ATTRIBUTE_SYSTEM, + NULL); // No template file + + if (g_hUSBMonitor == INVALID_HANDLE_VALUE) + { + /* AssertFailed(); */ + printf("usbproxy: Unable to open filter driver!! (rc=%d)\n", GetLastError()); + rc = VERR_FILE_NOT_FOUND; + goto failure; + } + } + + /* + * Check the version + */ + cbReturned = 0; + if (!DeviceIoControl(g_hUSBMonitor, SUPUSBFLT_IOCTL_GET_VERSION, NULL, 0,&version, sizeof(version), &cbReturned, NULL)) + { + printf("usbproxy: Unable to query filter version!! (rc=%d)\n", GetLastError()); + rc = VERR_VERSION_MISMATCH; + goto failure; + } + + if ( version.u32Major != USBMON_MAJOR_VERSION +#if USBMON_MINOR_VERSION != 0 + || version.u32Minor < USBMON_MINOR_VERSION +#endif + ) + { + printf("usbproxy: Filter driver version mismatch!!\n"); + rc = VERR_VERSION_MISMATCH; + goto failure; + } + + return VINF_SUCCESS; + +failure: + if (g_hUSBMonitor != INVALID_HANDLE_VALUE) + { + CloseHandle(g_hUSBMonitor); + g_hUSBMonitor = INVALID_HANDLE_VALUE; + } + return rc; +} + + + +/** + * Terminate the USB monitor + * + * @returns VBox status code. + */ +int usbMonitorTerm() +{ + if (g_hUSBMonitor != INVALID_HANDLE_VALUE) + { + CloseHandle(g_hUSBMonitor); + g_hUSBMonitor = INVALID_HANDLE_VALUE; + } + /* + * If we started the service we might consider stopping it too. + * + * Since this won't work unless the process starting it is the + * last user we might wanna skip this... + */ + if (g_fStartedService) + { + usbMonStopService(); + g_fStartedService = false; + } + + return VINF_SUCCESS; +} + + +int __cdecl main(int argc, char **argv) +{ + int rc; + RT_NOREF2(argc, argv); + + printf("USB test\n"); + + rc = usbMonitorInit(); + AssertRC(rc); + + void *pId1, *pId2; + + usbMonInsertFilter("0529", "0514", "0100", &pId1); + usbMonInsertFilter("0A16", "2499", "0100", &pId2); + + printf("Waiting to capture device\n"); + getchar(); + + printf("Releasing device\n"); + usbMonReleaseDevice(0xA16, 0x2499, 0x100); + + usbMonRemoveFilter(pId1); + usbMonRemoveFilter(pId2); + + rc = usbMonitorTerm(); + + return 0; +} diff --git a/src/VBox/HostDrivers/VBoxUSB/win/usbd/Makefile.kup b/src/VBox/HostDrivers/VBoxUSB/win/usbd/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/usbd/Makefile.kup diff --git a/src/VBox/HostDrivers/VBoxUSB/win/usbd/usbd.def b/src/VBox/HostDrivers/VBoxUSB/win/usbd/usbd.def new file mode 100644 index 00000000..c5bb9fd1 --- /dev/null +++ b/src/VBox/HostDrivers/VBoxUSB/win/usbd/usbd.def @@ -0,0 +1,64 @@ +; $Id: usbd.def $ +;; @file +; Export definitions +; + +; +; Copyright (C) 2006-2019 Oracle Corporation +; +; This file is part of VirtualBox Open Source Edition (OSE), as +; available from http://www.virtualbox.org. This file is free software; +; you can redistribute it and/or modify it under the terms of the GNU +; General Public License (GPL) as published by the Free Software +; Foundation, in version 2 as it comes in the "COPYING" file of the +; VirtualBox OSE distribution. VirtualBox OSE is distributed in the +; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. +; +; The contents of this file may alternatively be used under the terms +; of the Common Development and Distribution License Version 1.0 +; (CDDL) only, as it comes in the "COPYING.CDDL" file of the +; VirtualBox OSE distribution, in which case the provisions of the +; CDDL are applicable instead of those of the GPL. +; +; You may elect to license modified versions of this file under the +; terms and conditions of either the GPL or the CDDL or both. +; + +LIBRARY USBD.SYS + +EXPORTS +USBD_AllocateDeviceName +USBD_CalculateUsbBandwidth +USBD_CompleteRequest +USBD_CreateConfigurationRequest +USBD_CreateDevice +USBD_Debug_GetHeap +USBD_Debug_LogEntry +USBD_Debug_RetHeap +USBD_Dispatch +USBD_FreeDeviceMutex +USBD_FreeDeviceName +USBD_GetDeviceInformation +USBD_GetInterfaceLength +USBD_GetPdoRegistryParameter +USBD_GetSuspendPowerState +USBD_GetUSBDIVersion +USBD_InitializeDevice +USBD_MakePdoName +USBD_ParseConfigurationDescriptor +USBD_QueryBusTime +USBD_RegisterHcDeviceCapabilities +USBD_RegisterHcFilter +USBD_RegisterHostController +USBD_RemoveDevice +USBD_RestoreDevice +USBD_SetSuspendPowerState +USBD_WaitDeviceMutex +_USBD_CreateConfigurationRequestEx@8 +_USBD_ParseDescriptors@16 +_USBD_ParseConfigurationDescriptorEx@28 + +; win64 strips the _stdcall postfix +USBD_CreateConfigurationRequestEx +USBD_ParseConfigurationDescriptorEx +USBD_ParseDescriptors |