VirtualBox

Changeset 3756 in vbox


Ignore:
Timestamp:
Jul 21, 2007 7:00:53 AM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
23067
Message:

USBFILTER for darwin.

Location:
trunk/src/VBox/Main
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Main/HostImpl.cpp

    r3668 r3756  
    11711171        CFGLDRSetBool (filter, "active", !!data.mActive);
    11721172
     1173#ifndef VBOX_WITH_USBFILTER
    11731174        // all are optional
    11741175        if (data.mVendorId.string())
    … …  
    11951196        else
    11961197            AssertMsgFailed (("Invalid action: %d\n", data.mAction));
     1198
     1199#else  /* VBOX_WITH_USBFILTER */
     1200        // all are optional
     1201        Bstr str;
     1202        (*it)->COMGETTER (VendorId) (str.asOutParam());
     1203        if (!str.isNull())
     1204            CFGLDRSetBSTR (filter, "vendorid", str);
     1205
     1206        (*it)->COMGETTER (ProductId) (str.asOutParam());
     1207        if (!str.isNull())
     1208            CFGLDRSetBSTR (filter, "productid", str);
     1209
     1210        (*it)->COMGETTER (Revision) (str.asOutParam());
     1211        if (!str.isNull())
     1212            CFGLDRSetBSTR (filter, "revision", str);
     1213
     1214        (*it)->COMGETTER (Manufacturer) (str.asOutParam());
     1215        if (!str.isNull())
     1216            CFGLDRSetBSTR (filter, "manufacturer", str);
     1217
     1218        (*it)->COMGETTER (Product) (str.asOutParam());
     1219        if (!str.isNull())
     1220            CFGLDRSetBSTR (filter, "product", str);
     1221
     1222        (*it)->COMGETTER (SerialNumber) (str.asOutParam());
     1223        if (!str.isNull())
     1224            CFGLDRSetBSTR (filter, "serialnumber", str);
     1225
     1226        (*it)->COMGETTER (Port) (str.asOutParam());
     1227        if (!str.isNull())
     1228            CFGLDRSetBSTR (filter, "port", str);
     1229
     1230        // action is mandatory
     1231        ULONG action = USBDeviceFilterAction_InvalidUSBDeviceFilterAction;
     1232        (*it)->COMGETTER (Action) (&action);
     1233        if (action == USBDeviceFilterAction_USBDeviceFilterIgnore)
     1234            CFGLDRSetString (filter, "action", "Ignore");
     1235        else if (action == USBDeviceFilterAction_USBDeviceFilterHold)
     1236            CFGLDRSetString (filter, "action", "Hold");
     1237        else
     1238            AssertMsgFailed (("Invalid action: %d\n", action));
     1239#endif /* VBOX_WITH_USBFILTER */
    11971240
    11981241        CFGLDRReleaseNode (filter);
    … …  
    19301973        if (aDevice->isMatch (data))
    19311974        {
    1932             if (data.mAction == USBDeviceFilterAction_USBDeviceFilterIgnore)
     1975#ifndef VBOX_WITH_USBFILTER
     1976            USBDeviceFilterAction_T action = data.mAction;
     1977#else
     1978            ULONG action = USBDeviceFilterAction_InvalidUSBDeviceFilterAction;
     1979            (*it)->COMGETTER (Action) (&action);
     1980#endif
     1981            if (action == USBDeviceFilterAction_USBDeviceFilterIgnore)
    19331982            {
    19341983                /* request to give the device back to the host*/
    … …  
    19371986                return S_OK;
    19381987            }
    1939             if (data.mAction == USBDeviceFilterAction_USBDeviceFilterHold)
     1988            if (action == USBDeviceFilterAction_USBDeviceFilterHold)
    19401989                break;
    19411990        }

  • trunk/src/VBox/Main/HostUSBDeviceImpl.cpp

    r3668 r3756  
    822822        return false;
    823823
     824#ifndef VBOX_WITH_USBFILTER
    824825    if (!aData.mVendorId.isMatch (mUsb->idVendor))
    825826    {
    … …  
    892893        && aData.mSerialNumber.string().isEmpty())
    893894        return false;
     895
     896#else  /* VBOX_WITH_USBFILTER */
     897    if (USBFilterMatchDevice (&aData.mUSBFilter, mUsb))
     898    {
     899        /* Don't match busy devices with a 100% wildcard filter - this will
     900           later become a filter prop (ring-3 only). */
     901        if (    mUsb->enmState == USBDEVICESTATE_USED_BY_HOST_CAPTURABLE
     902            &&  !USBFilterHasAnySubstatialCriteria (&aData.mUSBFilter))
     903            return false;
     904    }
     905#endif /* VBOX_WITH_USBFILTER */
    894906
    895907    LogFlowThisFunc (("returns true\n"));

  • trunk/src/VBox/Main/Makefile.kmk

    r3720 r3756  
    4242 DEFS           += VBOX_WITH_UNIXY_TAP_NETWORKING
    4343endif
     44
    4445
    4546#PROGRAMS         = tstCFGLdr
    … …  
    218219endif
    219220
     221## Alternative USB filtering.
     222#ifeq ($(filter-out darwin,$(BUILD_TARGET)),)
     223#VBoxSVC_DEFS += VBOX_WITH_USBFILTER
     224#VBoxSVC_LIBS += $(PATH_LIB)/USBFilter$(VBOX_SUFF_LIB)
     225#endif
     226
     227
    220228#
    221229# VBoxSVC wrapper module

  • trunk/src/VBox/Main/USBControllerImpl.cpp

    r3668 r3756  
    560560
    561561        /* all are optional */
     562#ifndef VBOX_WITH_USBFILTER
    562563        if (data.mVendorId.string())
    563564            CFGLDRSetBSTR (filter, "vendorid", data.mVendorId.string());
    … …  
    576577        if (data.mRemote.string())
    577578            CFGLDRSetBSTR (filter, "remote", data.mRemote.string());
     579
     580#else  /* VBOX_WITH_USBFILTER */
     581        Bstr str;
     582        (*it)->COMGETTER (VendorId) (str.asOutParam());
     583        if (!str.isNull())
     584            CFGLDRSetBSTR (filter, "vendorid", str);
     585
     586        (*it)->COMGETTER (ProductId) (str.asOutParam());
     587        if (!str.isNull())
     588            CFGLDRSetBSTR (filter, "productid", str);
     589
     590        (*it)->COMGETTER (Revision) (str.asOutParam());
     591        if (!str.isNull())
     592            CFGLDRSetBSTR (filter, "revision", str);
     593
     594        (*it)->COMGETTER (Manufacturer) (str.asOutParam());
     595        if (!str.isNull())
     596            CFGLDRSetBSTR (filter, "manufacturer", str);
     597
     598        (*it)->COMGETTER (Product) (str.asOutParam());
     599        if (!str.isNull())
     600            CFGLDRSetBSTR (filter, "product", str);
     601
     602        (*it)->COMGETTER (SerialNumber) (str.asOutParam());
     603        if (!str.isNull())
     604            CFGLDRSetBSTR (filter, "serialnumber", str);
     605
     606        (*it)->COMGETTER (Port) (str.asOutParam());
     607        if (!str.isNull())
     608            CFGLDRSetBSTR (filter, "port", str);
     609
     610        if (data.mRemote.string())
     611            CFGLDRSetBSTR (filter, "remote", data.mRemote.string());
     612#endif /* VBOX_WITH_USBFILTER */
    578613
    579614        CFGLDRReleaseNode (filter);
    … …  
    10621097
    10631098    /* query fields */
     1099#ifdef VBOX_WITH_USBFILTER
     1100    USBFILTER dev;
     1101    USBFilterInit (&dev, USBFILTERTYPE_CAPTURE);
     1102#endif
    10641103
    10651104    USHORT vendorId = 0;
    … …  
    10671106    ComAssertComRCRet (rc, false);
    10681107    ComAssertRet (vendorId, false);
     1108#ifdef VBOX_WITH_USBFILTER
     1109    int vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_VENDOR_ID, vendorId, true); AssertRC(vrc);
     1110#endif
    10691111
    10701112    USHORT productId = 0;
    … …  
    10721114    ComAssertComRCRet (rc, false);
    10731115    ComAssertRet (productId, false);
     1116#ifdef VBOX_WITH_USBFILTER
     1117    vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_PRODUCT_ID, productId, true); AssertRC(vrc);
     1118#endif
    10741119
    10751120    USHORT revision;
    10761121    rc = aUSBDevice->COMGETTER(Revision) (&revision);
    10771122    ComAssertComRCRet (rc, false);
     1123#ifdef VBOX_WITH_USBFILTER
     1124    vrc = USBFilterSetNumExact (&dev, USBFILTERIDX_DEVICE, revision, true); AssertRC(vrc);
     1125#endif
    10781126
    10791127    Bstr manufacturer;
    10801128    rc = aUSBDevice->COMGETTER(Manufacturer) (manufacturer.asOutParam());
    10811129    ComAssertComRCRet (rc, false);
     1130#ifdef VBOX_WITH_USBFILTER
     1131    if (!manufacturer.isNull())
     1132        USBFilterSetStringExact (&dev, USBFILTERIDX_MANUFACTURER_STR, Utf8Str(manufacturer), true);
     1133#endif
    10821134
    10831135    Bstr product;
    10841136    rc = aUSBDevice->COMGETTER(Product) (product.asOutParam());
    10851137    ComAssertComRCRet (rc, false);
     1138#ifdef VBOX_WITH_USBFILTER
     1139    if (!product.isNull())
     1140        USBFilterSetStringExact (&dev, USBFILTERIDX_PRODUCT_STR, Utf8Str(product), true);
     1141#endif
    10861142
    10871143    Bstr serialNumber;
    10881144    rc = aUSBDevice->COMGETTER(SerialNumber) (serialNumber.asOutParam());
    10891145    ComAssertComRCRet (rc, false);
     1146#ifdef VBOX_WITH_USBFILTER
     1147    if (!serialNumber.isNull())
     1148        USBFilterSetStringExact (&dev, USBFILTERIDX_SERIAL_NUMBER_STR, Utf8Str(serialNumber), true);
     1149#endif
    10901150
    10911151    Bstr address;
    … …  
    10961156    rc = aUSBDevice->COMGETTER(Port)(&port);
    10971157    ComAssertComRCRet (rc, false);
     1158#ifdef VBOX_WITH_USBFILTER
     1159    USBFilterSetNumExact (&dev, USBFILTERIDX_PORT, port, true);
     1160#endif
    10981161
    10991162    BOOL remote = FALSE;
    … …  
    11121175        const USBDeviceFilter::Data &aData = (*it)->data();
    11131176
     1177
    11141178        if (!aData.mActive)
    11151179            continue;
     1180        if (!aData.mRemote.isMatch (remote))
     1181            continue;
     1182
     1183#ifndef VBOX_WITH_USBFILTER
    11161184        if (!aData.mVendorId.isMatch (vendorId))
    11171185            continue;
    … …  
    11331201#endif
    11341202
    1135         if (!aData.mRemote.isMatch (remote))
     1203#else  /* VBOX_WITH_USBFILTER */
     1204        if (!USBFilterMatch (&aData.mUSBFilter, &dev))
    11361205            continue;
     1206#endif /* VBOX_WITH_USBFILTER */
    11371207
    11381208        match = true;

  • trunk/src/VBox/Main/USBDeviceFilterImpl.cpp

    r3668 r3756  
    2828
    2929#include <iprt/cpputils.h>
     30
     31#ifdef VBOX_WITH_USBFILTER
     32////////////////////////////////////////////////////////////////////////////////
     33// Internal Helpers
     34////////////////////////////////////////////////////////////////////////////////
     35
     36/**
     37 *  Converts a USBFilter field into a string.
     38 *
     39 *  (This function is also used by HostUSBDeviceFilter.)
     40 *
     41 *  @param  aFilter     The filter.
     42 *  @param  aIdx        The field index.
     43 *  @param  aStr        The output string.
     44 */
     45static void usbFilterFieldToString (PCUSBFILTER aFilter, USBFILTERIDX aIdx, BSTR *aStr)
     46{
     47    const USBFILTERMATCH matchingMethod = USBFilterGetMatchingMethod (aFilter, aIdx);
     48    Assert (matchingMethod != USBFILTERMATCH_INVALID);
     49
     50    if (USBFilterIsMethodNumeric (matchingMethod))
     51    {
     52        int value = USBFilterGetNum (aFilter, aIdx);
     53        Assert(value >= 0 && value <= 0xffff);
     54
     55        char str[16];
     56        RTStrPrintf (str, sizeof(str), "%x", value);
     57        Bstr ((const char *)str).cloneTo (aStr);
     58    }
     59    else if (USBFilterIsMethodString (matchingMethod))
     60        Bstr (USBFilterGetString (aFilter, aIdx)).cloneTo (aStr);
     61    else
     62        Bstr ().cloneTo (aStr);
     63}
     64
     65/**
     66 *  Interprets a string and assigns it to a USBFilter field.
     67 *
     68 *  (This function is also used by HostUSBDeviceFilter.)
     69 *
     70 *  @param  aFilter     The filter.
     71 *  @param  aIdx        The field index.
     72 *  @param  aStr        The input string.
     73 *  @param  aName       The field name for use in the error string.
     74 *  @param  aErrStr     Where to return the error string on failure.
     75 *
     76 *  @return COM status code.
     77 *  @remark The idea was to have this as a static function, but tr() doesn't wanna work without a class :-/
     78 */
     79/*static*/ HRESULT
     80USBDeviceFilter::usbFilterFieldFromString (PUSBFILTER aFilter, USBFILTERIDX aIdx, INPTR BSTR aStr, const char *aName, Utf8Str &aErrStr)
     81{
     82    int vrc;
     83    Utf8Str str (aStr);
     84    if (str.isNull())
     85        vrc = USBFilterSetIgnore (aFilter, aIdx);
     86    else
     87    {
     88        const char *psz = str;
     89        if (USBFilterIsNumericField (aIdx))
     90        {
     91            /* Is it a lonely number? */
     92            char *pszNext;
     93            uint64_t u64;
     94            vrc = RTStrToUInt64Ex (psz, &pszNext, 16, &u64);
     95            if (RT_SUCCESS(vrc))
     96                pszNext = RTStrStripL (pszNext);
     97            if (    vrc == VINF_SUCCESS
     98                &&  !*pszNext)
     99            {
     100                if (u64 > 0xffff)
     101                {
     102                    aErrStr = Utf8StrFmt (tr ("The %s value '%s' is too big (max 0xFFFF)"), aName, str.raw());
     103                    return E_INVALIDARG;
     104                }
     105
     106                vrc = USBFilterSetNumExact (aFilter, aIdx, (uint16_t)u64, true /* fMustBePresent */);
     107            }
     108            else
     109                vrc = USBFilterSetNumExpression (aFilter, aIdx, psz, true /* fMustBePresent */);
     110        }
     111        else
     112        {
     113            /* Any wildcard in the string? */
     114            Assert (USBFilterIsStringField (aIdx));
     115            if (    strchr (psz, '*')
     116                ||  strchr (psz, '?')
     117                /* || strchr (psz, '[') - later */
     118                )
     119                vrc = USBFilterSetStringPattern (aFilter, aIdx, psz, true /* fMustBePresent */);
     120            else
     121                vrc = USBFilterSetStringExact (aFilter, aIdx, psz, true /* fMustBePresent */);
     122        }
     123    }
     124
     125    if (RT_FAILURE(vrc))
     126    {
     127        if (vrc == VERR_INVALID_PARAMETER)
     128        {
     129            aErrStr = Utf8StrFmt (tr ("The %s filter expression '%s' is not valid"), aName, str.raw());
     130            return E_INVALIDARG;
     131        }
     132        if (vrc == VERR_BUFFER_OVERFLOW)
     133        {
     134            aErrStr = Utf8StrFmt (tr ("Insufficient expression space for the '%s' filter expression '%s'"), aName, str.raw());
     135            return E_FAIL;
     136        }
     137        AssertRC (vrc);
     138        aErrStr = Utf8StrFmt (tr ("Encountered unexpected status %Vrc when setting '%s' to '%s'"), vrc, aName, str.raw());
     139        return E_FAIL;
     140    }
     141
     142    return S_OK;
     143}
     144#endif /* VBOX_WITH_USBFILTER */
     145
    30146
    31147////////////////////////////////////////////////////////////////////////////////
    … …  
    84200
    85201    /* initialize all filters to any match using null string */
     202#ifndef VBOX_WITH_USBFILTER
    86203    mData->mVendorId = NULL;
    87204    mData->mProductId = NULL;
    … …  
    91208    mData->mSerialNumber = NULL;
    92209    mData->mPort = NULL;
     210#else  /* VBOX_WITH_USBFILTER */
     211    USBFilterInit(&mData->mUSBFilter, USBFILTERTYPE_CAPTURE);
     212#endif /* VBOX_WITH_USBFILTER */
    93213    mData->mRemote = NULL;
    94214
    … …  
    155275
    156276    /* initialize all filters to any match using null string */
     277#ifndef VBOX_WITH_USBFILTER
    157278    mData->mVendorId = NULL;
    158279    mData->mProductId = NULL;
    … …  
    162283    mData->mSerialNumber = NULL;
    163284    mData->mPort = NULL;
     285#else  /* VBOX_WITH_USBFILTER */
     286    USBFilterInit (&mData->mUSBFilter, USBFILTERTYPE_CAPTURE);
     287#endif /* VBOX_WITH_USBFILTER */
    164288    mData->mRemote = NULL;
    165289
    … …  
    391515STDMETHODIMP USBDeviceFilter::COMGETTER(VendorId) (BSTR *aVendorId)
    392516{
     517#ifndef VBOX_WITH_USBFILTER
    393518    if (!aVendorId)
    394519        return E_POINTER;
    … …  
    402527
    403528    return S_OK;
     529#else
     530    return usbFilterFieldGetter (USBFILTERIDX_VENDOR_ID, aVendorId);
     531#endif
    404532}
    405533
    406534STDMETHODIMP USBDeviceFilter::COMSETTER(VendorId) (INPTR BSTR aVendorId)
    407535{
     536#ifndef VBOX_WITH_USBFILTER
    408537    AutoCaller autoCaller (this);
    409538    CheckComRCReturnRC (autoCaller.rc());
    … …  
    441570
    442571    return S_OK;
     572#else  /* VBOX_WITH_USBFILTER */
     573    return usbFilterFieldSetter (USBFILTERIDX_VENDOR_ID, aVendorId, tr ("Vendor ID"));
     574#endif /* VBOX_WITH_USBFILTER */
    443575}
    444576
    445577STDMETHODIMP USBDeviceFilter::COMGETTER(ProductId) (BSTR *aProductId)
    446578{
     579#ifndef VBOX_WITH_USBFILTER
    447580    if (!aProductId)
    448581        return E_POINTER;
    … …  
    456589
    457590    return S_OK;
     591#else
     592    return usbFilterFieldGetter (USBFILTERIDX_PRODUCT_ID, aProductId);
     593#endif
    458594}
    459595
    460596STDMETHODIMP USBDeviceFilter::COMSETTER(ProductId) (INPTR BSTR aProductId)
    461597{
     598#ifndef VBOX_WITH_USBFILTER
    462599    AutoCaller autoCaller (this);
    463600    CheckComRCReturnRC (autoCaller.rc());
    … …  
    495632
    496633    return S_OK;
    497 }
     634#else  /* VBOX_WITH_USBFILTER */
     635    return usbFilterFieldSetter (USBFILTERIDX_PRODUCT_ID, aProductId, tr ("Product ID"));
     636#endif /* VBOX_WITH_USBFILTER */
     637 }
    498638
    499639STDMETHODIMP USBDeviceFilter::COMGETTER(Revision) (BSTR *aRevision)
    500640{
     641#ifndef VBOX_WITH_USBFILTER
    501642    if (!aRevision)
    502643        return E_POINTER;
    … …  
    510651
    511652    return S_OK;
     653#else
     654    return usbFilterFieldGetter (USBFILTERIDX_DEVICE, aRevision);
     655#endif
    512656}
    513657
    514658STDMETHODIMP USBDeviceFilter::COMSETTER(Revision) (INPTR BSTR aRevision)
    515659{
     660#ifndef VBOX_WITH_USBFILTER
    516661    AutoCaller autoCaller (this);
    517662    CheckComRCReturnRC (autoCaller.rc());
    … …  
    549694
    550695    return S_OK;
     696#else  /* VBOX_WITH_USBFILTER */
     697    return usbFilterFieldSetter (USBFILTERIDX_DEVICE, aRevision, tr ("Revision"));
     698#endif /* VBOX_WITH_USBFILTER */
    551699}
    552700
    553701STDMETHODIMP USBDeviceFilter::COMGETTER(Manufacturer) (BSTR *aManufacturer)
    554702{
     703#ifndef VBOX_WITH_USBFILTER
    555704    if (!aManufacturer)
    556705        return E_POINTER;
    … …  
    562711
    563712    mData->mManufacturer.string().cloneTo (aManufacturer);
    564     return S_OK;
     713
     714    return S_OK;
     715#else
     716    return usbFilterFieldGetter (USBFILTERIDX_MANUFACTURER_STR, aManufacturer);
     717#endif
    565718}
    566719
    567720STDMETHODIMP USBDeviceFilter::COMSETTER(Manufacturer) (INPTR BSTR aManufacturer)
    568721{
     722#ifndef VBOX_WITH_USBFILTER
    569723    AutoCaller autoCaller (this);
    570724    CheckComRCReturnRC (autoCaller.rc());
    … …  
    595749
    596750    return S_OK;
     751#else  /* VBOX_WITH_USBFILTER */
     752    return usbFilterFieldSetter (USBFILTERIDX_MANUFACTURER_STR, aManufacturer, tr ("Manufacturer"));
     753#endif /* VBOX_WITH_USBFILTER */
    597754}
    598755
    599756STDMETHODIMP USBDeviceFilter::COMGETTER(Product) (BSTR *aProduct)
    600757{
     758#ifndef VBOX_WITH_USBFILTER
    601759    if (!aProduct)
    602760        return E_POINTER;
    … …  
    610768
    611769    return S_OK;
     770#else
     771    return usbFilterFieldGetter (USBFILTERIDX_PRODUCT_STR, aProduct);
     772#endif
    612773}
    613774
    614775STDMETHODIMP USBDeviceFilter::COMSETTER(Product) (INPTR BSTR aProduct)
    615776{
     777#ifndef VBOX_WITH_USBFILTER
    616778    AutoCaller autoCaller (this);
    617779    CheckComRCReturnRC (autoCaller.rc());
    … …  
    642804
    643805    return S_OK;
     806#else  /* VBOX_WITH_USBFILTER */
     807    return usbFilterFieldSetter (USBFILTERIDX_PRODUCT_STR, aProduct, tr ("Product"));
     808#endif /* VBOX_WITH_USBFILTER */
    644809}
    645810
    646811STDMETHODIMP USBDeviceFilter::COMGETTER(SerialNumber) (BSTR *aSerialNumber)
    647812{
     813#ifndef VBOX_WITH_USBFILTER
    648814    if (!aSerialNumber)
    649815        return E_POINTER;
    … …  
    657823
    658824    return S_OK;
     825#else
     826    return usbFilterFieldGetter (USBFILTERIDX_SERIAL_NUMBER_STR, aSerialNumber);
     827#endif
    659828}
    660829
    661830STDMETHODIMP USBDeviceFilter::COMSETTER(SerialNumber) (INPTR BSTR aSerialNumber)
    662831{
     832#ifndef VBOX_WITH_USBFILTER
    663833    AutoCaller autoCaller (this);
    664834    CheckComRCReturnRC (autoCaller.rc());
    … …  
    689859
    690860    return S_OK;
     861#else  /* VBOX_WITH_USBFILTER */
     862    return usbFilterFieldSetter (USBFILTERIDX_SERIAL_NUMBER_STR, aSerialNumber, tr ("Serial number"));
     863#endif /* VBOX_WITH_USBFILTER */
    691864}
    692865
    693866STDMETHODIMP USBDeviceFilter::COMGETTER(Port) (BSTR *aPort)
    694867{
     868#ifndef VBOX_WITH_USBFILTER
    695869    if (!aPort)
    696870        return E_POINTER;
    … …  
    704878
    705879    return S_OK;
     880#else
     881    return usbFilterFieldGetter (USBFILTERIDX_PORT, aPort);
     882#endif
    706883}
    707884
    708885STDMETHODIMP USBDeviceFilter::COMSETTER(Port) (INPTR BSTR aPort)
    709886{
     887#ifndef VBOX_WITH_USBFILTER
    710888    AutoCaller autoCaller (this);
    711889    CheckComRCReturnRC (autoCaller.rc());
    … …  
    743921
    744922    return S_OK;
     923#else  /* VBOX_WITH_USBFILTER */
     924    return usbFilterFieldSetter (USBFILTERIDX_PORT, aPort, tr ("Port number"));
     925#endif /* VBOX_WITH_USBFILTER */
    745926}
    746927
    … …  
    795976////////////////////////////////////////////////////////////////////////////////
    796977
    797 /** 
     978/**
    798979 *  @note Locks this object for writing.
    799980 */
    … …  
    8191000}
    8201001
    821 /** 
     1002/**
    8221003 *  @note Locks this object for writing, together with the peer object (also
    8231004 *  for writing) if there is one.
    … …  
    8631044    AutoCaller thatCaller (mPeer);
    8641045    AssertComRCReturnVoid (thatCaller.rc());
    865      
     1046
    8661047    /* peer is not modified, lock it for reading */
    8671048    AutoMultiLock <2> alock (this->wlock(), AutoLock::maybeRlock (mPeer));
    868    
     1049
    8691050    if (mData.isShared())
    8701051    {
    … …  
    8781059    unconst (mPeer).setNull();
    8791060}
     1061
     1062#ifdef VBOX_WITH_USBFILTER
     1063/**
     1064 *  Generic USB filter field getter.
     1065 *
     1066 *  @param  aIdx    The field index.
     1067 *  @param  aStr    Where to store the value.
     1068 *
     1069 *  @return COM status.
     1070 */
     1071HRESULT USBDeviceFilter::usbFilterFieldGetter (USBFILTERIDX aIdx, BSTR *aStr)
     1072{
     1073    if (!aStr)
     1074        return E_POINTER;
     1075
     1076    AutoCaller autoCaller (this);
     1077    CheckComRCReturnRC (autoCaller.rc());
     1078
     1079    AutoReaderLock alock (this);
     1080
     1081    usbFilterFieldToString (&mData->mUSBFilter, aIdx, aStr);
     1082
     1083    return S_OK;
     1084}
     1085
     1086/**
     1087 *  Generic USB filter field setter.
     1088 *
     1089 *  @param  aIdx    The field index.
     1090 *  @param  aStr    The new value.
     1091 *  @param  aName   The translated field name (for error messages).
     1092 *
     1093 *  @return COM status.
     1094 */
     1095HRESULT USBDeviceFilter::usbFilterFieldSetter (USBFILTERIDX aIdx, Bstr aStr, Utf8Str aName)
     1096{
     1097    AutoCaller autoCaller (this);
     1098    CheckComRCReturnRC (autoCaller.rc());
     1099
     1100    /* the machine needs to be mutable */
     1101    Machine::AutoMutableStateDependency adep (mParent->parent());
     1102    CheckComRCReturnRC (adep.rc());
     1103
     1104    AutoLock alock (this);
     1105
     1106    Bstr old;
     1107    usbFilterFieldToString (&mData->mUSBFilter, aIdx, old.asOutParam());
     1108    if (old != aStr)
     1109    {
     1110        mData.backup();
     1111
     1112        Utf8Str errStr;
     1113        HRESULT rc = usbFilterFieldFromString (&mData->mUSBFilter, aIdx, aStr, aName, errStr);
     1114        if (FAILED (rc))
     1115        {
     1116            mData.rollback();
     1117            return setError (rc, "%s", errStr.raw());
     1118        }
     1119
     1120        /* leave the lock before informing callbacks */
     1121        alock.unlock();
     1122
     1123        return mParent->onDeviceFilterChange (this);
     1124    }
     1125
     1126    return S_OK;
     1127}
     1128#endif /* VBOX_WITH_USBFILTER */
    8801129
    8811130////////////////////////////////////////////////////////////////////////////////
    … …  
    9321181    mData->mName = aName;
    9331182    mData->mActive = aActive;
     1183#ifndef VBOX_WITH_USBFILTER
    9341184    mData->mAction = aAction;
    9351185
    … …  
    9421192    mData->mSerialNumber = NULL;
    9431193    mData->mPort = NULL;
     1194#else  /* VBOX_WITH_USBFILTER */
     1195    USBFilterInit (&mData->mUSBFilter, USBFILTERTYPE_IGNORE);
     1196#endif /* VBOX_WITH_USBFILTER */
    9441197    mData->mRemote = NULL;
    9451198
    … …  
    9521205    do
    9531206    {
     1207#ifndef VBOX_WITH_USBFILTER
     1208        rc = COMSETTER(Action) (aAction);
     1209        CheckComRCBreakRC (rc);
     1210#endif /* VBOX_WITH_USBFILTER */
    9541211        rc = COMSETTER(VendorId) (aVendorId);
    9551212        CheckComRCBreakRC (rc);
    … …  
    10011258    mData->mName = aName;
    10021259    mData->mActive = FALSE;
     1260#ifndef VBOX_WITH_USBFILTER
    10031261    mData->mAction = USBDeviceFilterAction_USBDeviceFilterIgnore;
     1262#endif /* !VBOX_WITH_USBFILTER */
    10041263
    10051264    mInList = false;
    10061265
     1266#ifndef VBOX_WITH_USBFILTER
    10071267    /* initialize all filters to any match using null string */
    10081268    mData->mVendorId = NULL;
    … …  
    10131273    mData->mSerialNumber = NULL;
    10141274    mData->mPort = NULL;
     1275#else  /* VBOX_WITH_USBFILTER */
     1276    USBFilterInit (&mData->mUSBFilter, USBFILTERTYPE_IGNORE);
     1277#endif /* VBOX_WITH_USBFILTER */
    10151278    mData->mRemote = NULL;
    10161279
    … …  
    11211384STDMETHODIMP HostUSBDeviceFilter::COMGETTER(VendorId) (BSTR *aVendorId)
    11221385{
     1386#ifndef VBOX_WITH_USBFILTER
    11231387    if (!aVendorId)
    11241388        return E_POINTER;
    … …  
    11321396
    11331397    return S_OK;
     1398#else
     1399    return usbFilterFieldGetter (USBFILTERIDX_VENDOR_ID, aVendorId);
     1400#endif
    11341401}
    11351402
    11361403STDMETHODIMP HostUSBDeviceFilter::COMSETTER(VendorId) (INPTR BSTR aVendorId)
    11371404{
     1405#ifndef VBOX_WITH_USBFILTER
    11381406    AutoCaller autoCaller (this);
    11391407    CheckComRCReturnRC (autoCaller.rc());
    … …  
    11661434
    11671435    return S_OK;
     1436#else  /* VBOX_WITH_USBFILTER */
     1437    return usbFilterFieldSetter (USBFILTERIDX_VENDOR_ID, aVendorId, tr ("Vendor ID"));
     1438#endif /* VBOX_WITH_USBFILTER */
    11681439}
    11691440
    11701441STDMETHODIMP HostUSBDeviceFilter::COMGETTER(ProductId) (BSTR *aProductId)
    11711442{
     1443#ifndef VBOX_WITH_USBFILTER
    11721444    if (!aProductId)
    11731445        return E_POINTER;
    … …  
    11811453
    11821454    return S_OK;
     1455#else
     1456    return usbFilterFieldGetter (USBFILTERIDX_PRODUCT_ID, aProductId);
     1457#endif
    11831458}
    11841459
    11851460STDMETHODIMP HostUSBDeviceFilter::COMSETTER(ProductId) (INPTR BSTR aProductId)
    11861461{
     1462#ifndef VBOX_WITH_USBFILTER
    11871463    AutoCaller autoCaller (this);
    11881464    CheckComRCReturnRC (autoCaller.rc());
    … …  
    12151491
    12161492    return S_OK;
     1493#else  /* VBOX_WITH_USBFILTER */
     1494    return usbFilterFieldSetter (USBFILTERIDX_PRODUCT_ID, aProductId, tr ("Product ID"));
     1495#endif /* VBOX_WITH_USBFILTER */
    12171496}
    12181497
    12191498STDMETHODIMP HostUSBDeviceFilter::COMGETTER(Revision) (BSTR *aRevision)
    12201499{
     1500#ifndef VBOX_WITH_USBFILTER
    12211501    if (!aRevision)
    12221502        return E_POINTER;
    … …  
    12301510
    12311511    return S_OK;
     1512#else
     1513    return usbFilterFieldGetter (USBFILTERIDX_DEVICE, aRevision);
     1514#endif
    12321515}
    12331516
    12341517STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Revision) (INPTR BSTR aRevision)
    12351518{
     1519#ifndef VBOX_WITH_USBFILTER
    12361520    AutoCaller autoCaller (this);
    12371521    CheckComRCReturnRC (autoCaller.rc());
    … …  
    12641548
    12651549    return S_OK;
     1550#else  /* VBOX_WITH_USBFILTER */
     1551    return usbFilterFieldSetter (USBFILTERIDX_DEVICE, aRevision, tr ("Revision"));
     1552#endif /* VBOX_WITH_USBFILTER */
    12661553}
    12671554
    12681555STDMETHODIMP HostUSBDeviceFilter::COMGETTER(Manufacturer) (BSTR *aManufacturer)
    12691556{
     1557#ifndef VBOX_WITH_USBFILTER
    12701558    if (!aManufacturer)
    12711559        return E_POINTER;
    … …  
    12791567
    12801568    return S_OK;
     1569#else
     1570    return usbFilterFieldGetter (USBFILTERIDX_MANUFACTURER_STR, aManufacturer);
     1571#endif
    12811572}
    12821573
    12831574STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Manufacturer) (INPTR BSTR aManufacturer)
    12841575{
     1576#ifndef VBOX_WITH_USBFILTER
    12851577    AutoCaller autoCaller (this);
    12861578    CheckComRCReturnRC (autoCaller.rc());
    … …  
    13061598
    13071599    return S_OK;
     1600#else  /* VBOX_WITH_USBFILTER */
     1601    return usbFilterFieldSetter (USBFILTERIDX_MANUFACTURER_STR, aManufacturer, tr ("Manufacturer"));
     1602#endif /* VBOX_WITH_USBFILTER */
    13081603}
    13091604
    13101605STDMETHODIMP HostUSBDeviceFilter::COMGETTER(Product) (BSTR *aProduct)
    13111606{
     1607#ifndef VBOX_WITH_USBFILTER
    13121608    if (!aProduct)
    13131609        return E_POINTER;
    … …  
    13211617
    13221618    return S_OK;
     1619#else
     1620    return usbFilterFieldGetter (USBFILTERIDX_PRODUCT_STR, aProduct);
     1621#endif
    13231622}
    13241623
    13251624STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Product) (INPTR BSTR aProduct)
    13261625{
     1626#ifndef VBOX_WITH_USBFILTER
    13271627    AutoCaller autoCaller (this);
    13281628    CheckComRCReturnRC (autoCaller.rc());
    … …  
    13481648
    13491649    return S_OK;
     1650#else  /* VBOX_WITH_USBFILTER */
     1651    return usbFilterFieldSetter (USBFILTERIDX_PRODUCT_STR, aProduct, tr ("Product"));
     1652#endif /* VBOX_WITH_USBFILTER */
    13501653}
    13511654
    13521655STDMETHODIMP HostUSBDeviceFilter::COMGETTER(SerialNumber) (BSTR *aSerialNumber)
    13531656{
     1657#ifndef VBOX_WITH_USBFILTER
    13541658    if (!aSerialNumber)
    13551659        return E_POINTER;
    … …  
    13631667
    13641668    return S_OK;
     1669#else   /* VBOX_WITH_USBFILTER */
     1670    return usbFilterFieldGetter (USBFILTERIDX_SERIAL_NUMBER_STR, aSerialNumber);
     1671#endif  /* VBOX_WITH_USBFILTER */
    13651672}
    13661673
    13671674STDMETHODIMP HostUSBDeviceFilter::COMSETTER(SerialNumber) (INPTR BSTR aSerialNumber)
    13681675{
     1676#ifndef VBOX_WITH_USBFILTER
    13691677    AutoCaller autoCaller (this);
    13701678    CheckComRCReturnRC (autoCaller.rc());
    … …  
    13901698
    13911699    return S_OK;
     1700#else  /* VBOX_WITH_USBFILTER */
     1701    return usbFilterFieldSetter (USBFILTERIDX_SERIAL_NUMBER_STR, aSerialNumber, tr ("Serial number"));
     1702#endif /* VBOX_WITH_USBFILTER */
    13921703}
    13931704
    13941705STDMETHODIMP HostUSBDeviceFilter::COMGETTER(Port) (BSTR *aPort)
    13951706{
     1707#ifndef VBOX_WITH_USBFILTER
    13961708    if (!aPort)
    13971709        return E_POINTER;
    … …  
    14051717
    14061718    return S_OK;
     1719#else  /* VBOX_WITH_USBFILTER */
     1720    return usbFilterFieldGetter (USBFILTERIDX_PORT, aPort);
     1721#endif  /* VBOX_WITH_USBFILTER */
    14071722}
    14081723
    14091724STDMETHODIMP HostUSBDeviceFilter::COMSETTER(Port) (INPTR BSTR aPort)
    14101725{
     1726#ifndef VBOX_WITH_USBFILTER
    14111727    AutoCaller autoCaller (this);
    14121728    CheckComRCReturnRC (autoCaller.rc());
    … …  
    14391755
    14401756    return S_OK;
     1757#else  /* VBOX_WITH_USBFILTER */
     1758    return usbFilterFieldSetter (USBFILTERIDX_PORT, aPort, tr ("Port number"));
     1759#endif /* VBOX_WITH_USBFILTER */
    14411760}
    14421761
    … …  
    14761795    AutoReaderLock alock (this);
    14771796
     1797#ifndef VBOX_WITH_USBFILTER
    14781798    *aAction = mData->mAction;
     1799#else   /* VBOX_WITH_USBFILTER */
     1800    switch (USBFilterGetFilterType (&mData->mUSBFilter))
     1801    {
     1802        case USBFILTERTYPE_IGNORE:   *aAction = USBDeviceFilterAction_USBDeviceFilterIgnore; break;
     1803        case USBFILTERTYPE_CAPTURE:  *aAction = USBDeviceFilterAction_USBDeviceFilterHold; break;
     1804        default:                     *aAction = USBDeviceFilterAction_InvalidUSBDeviceFilterAction; break;
     1805    }
     1806#endif  /* VBOX_WITH_USBFILTER */
    14791807
    14801808    return S_OK;
    … …  
    14881816    AutoLock alock (this);
    14891817
     1818#ifndef VBOX_WITH_USBFILTER
    14901819    if (mData->mAction != aAction)
    14911820    {
    … …  
    14981827    }
    14991828
    1500     return S_OK;
    1501 }
    1502 
     1829#else   /* VBOX_WITH_USBFILTER */
     1830    USBFILTERTYPE filterType;
     1831    switch (aAction)
     1832    {
     1833        case USBDeviceFilterAction_USBDeviceFilterIgnore:   filterType = USBFILTERTYPE_IGNORE; break;
     1834        case USBDeviceFilterAction_USBDeviceFilterHold:     filterType = USBFILTERTYPE_CAPTURE; break;
     1835        case USBDeviceFilterAction_InvalidUSBDeviceFilterAction:
     1836            return setError (E_INVALIDARG,
     1837                tr ("Action value InvalidUSBDeviceFilterAction is not permitted"));
     1838        default:
     1839            return setError (E_INVALIDARG,
     1840                tr ("Invalid action %d"),
     1841                aAction);
     1842    }
     1843    if (USBFilterGetFilterType (&mData->mUSBFilter) != filterType)
     1844    {
     1845        int vrc = USBFilterSetFilterType (&mData->mUSBFilter, filterType);
     1846        if (RT_FAILURE (vrc))
     1847            return setError (E_INVALIDARG,
     1848                tr ("Unexpected error %Vrc"),
     1849                vrc);
     1850
     1851        /* leave the lock before informing callbacks */
     1852        alock.unlock();
     1853
     1854        return mParent->onUSBDeviceFilterChange (this);
     1855    }
     1856#endif  /* VBOX_WITH_USBFILTER */
     1857
     1858    return S_OK;
     1859}
     1860
     1861
     1862#ifdef VBOX_WITH_USBFILTER
     1863/**
     1864 *  Generic USB filter field getter.
     1865 *
     1866 *  @param  aIdx    The field index.
     1867 *  @param  aStr    Where to store the value.
     1868 *
     1869 *  @return COM status.
     1870 */
     1871HRESULT HostUSBDeviceFilter::usbFilterFieldGetter (USBFILTERIDX aIdx, BSTR *aStr)
     1872{
     1873    if (!aStr)
     1874        return E_POINTER;
     1875
     1876    AutoCaller autoCaller (this);
     1877    CheckComRCReturnRC (autoCaller.rc());
     1878
     1879    AutoReaderLock alock (this);
     1880
     1881    usbFilterFieldToString (&mData->mUSBFilter, aIdx, aStr);
     1882
     1883    return S_OK;
     1884}
     1885
     1886
     1887/**
     1888 *  Generic USB filter field setter.
     1889 *
     1890 *  @param  aIdx    The field index.
     1891 *  @param  aStr    The new value.
     1892 *  @param  aName   The translated field name (for error messages).
     1893 *
     1894 *  @return COM status.
     1895 */
     1896HRESULT HostUSBDeviceFilter::usbFilterFieldSetter (USBFILTERIDX aIdx, Bstr aStr, Utf8Str aName)
     1897{
     1898    AutoCaller autoCaller (this);
     1899    CheckComRCReturnRC (autoCaller.rc());
     1900
     1901    AutoLock alock (this);
     1902
     1903    Bstr old;
     1904    usbFilterFieldToString (&mData->mUSBFilter, aIdx, old.asOutParam());
     1905    if (old != aStr)
     1906    {
     1907        //mData.backup();
     1908
     1909        Utf8Str errStr;
     1910        HRESULT rc = USBDeviceFilter::usbFilterFieldFromString (&mData->mUSBFilter, aIdx, aStr, aName, errStr);
     1911        if (FAILED (rc))
     1912        {
     1913            //mData.rollback();
     1914            return setError (rc, "%s", errStr.raw());
     1915        }
     1916
     1917        /* leave the lock before informing callbacks */
     1918        alock.unlock();
     1919
     1920        return mParent->onUSBDeviceFilterChange (this);
     1921    }
     1922
     1923    return S_OK;
     1924}
     1925#endif /* VBOX_WITH_USBFILTER */
     1926

  • trunk/src/VBox/Main/include/USBDeviceFilterImpl.h

    r3412 r3756  
    2828
    2929#include "Matching.h"
     30#ifdef VBOX_WITH_USBFILTER
     31# include <VBox/usbfilter.h>
     32#endif /* VBOX_WITH_USBFILTER */
    3033
    3134class USBController;
    … …  
    4548    struct Data
    4649    {
     50#ifndef VBOX_WITH_USBFILTER
    4751        struct ConvForRegexp
    4852        {
    … …  
    6569        typedef matching::Matchable
    6670            <matching::ParsedRegexpFilter <ConvForRegexp, false> > BstrFilter;
     71#endif /* VBOX_WITH_USBFILTER */
    6772
    6873        typedef matching::Matchable <matching::ParsedBoolFilter> BOOLFilter;
    6974
    7075        Data() : mActive (FALSE), mId (NULL) {}
     76#ifdef VBOX_WITH_USBFILTER
     77        Data (const Data &aThat) : mName (aThat.mName), mActive (aThat.mActive),
     78            mRemote (aThat.mRemote), mId (NULL)
     79        {
     80            USBFilterClone (&mUSBFilter, &aThat.mUSBFilter);
     81        }
     82#endif /* VBOX_WITH_USBFILTER */
    7183
    7284        bool operator== (const Data &that) const
    7385        {
     86#ifndef VBOX_WITH_USBFILTER
    7487            return this == &that ||
    7588                   (mName == that.mName &&
    … …  
    8396                    mPort.string() == that. mPort.string() &&
    8497                    mRemote.string() == that. mRemote.string());
     98#else /* VBOX_WITH_USBFILTER */
     99            return this == &that
     100                || (    mName == that.mName
     101                    &&  mActive == that.mActive
     102                    &&  USBFilterIsIdentical (&mUSBFilter, &that.mUSBFilter));
     103#endif /* VBOX_WITH_USBFILTER */
    85104        }
    86105
    … …  
    88107        BOOL mActive;
    89108
     109#ifndef VBOX_WITH_USBFILTER
    90110        USHORTFilter mVendorId;
    91111        USHORTFilter mProductId;
    … …  
    95115        BstrFilter mSerialNumber;
    96116        USHORTFilter mPort;
     117#else /* VBOX_WITH_USBFILTER */
     118        USBFILTER mUSBFilter;
     119#endif /* VBOX_WITH_USBFILTER */
    97120        BOOLFilter mRemote;
    98121
    … …  
    175198    static const wchar_t *getComponentName() { return L"USBDeviceFilter"; }
    176199
     200#ifdef VBOX_WITH_USBFILTER
     201    // tr() wants to belong to a class it seems, thus this one here.
     202    static HRESULT usbFilterFieldFromString (PUSBFILTER aFilter, USBFILTERIDX aIdx, INPTR BSTR aStr, const char *aName, Utf8Str &aErrStr);
     203#endif
     204
    177205private:
     206#ifdef VBOX_WITH_USBFILTER
     207    HRESULT usbFilterFieldGetter (USBFILTERIDX aIdx, BSTR *aStr);
     208    HRESULT usbFilterFieldSetter (USBFILTERIDX aIdx, Bstr aStr, Utf8Str aName);
     209#endif
    178210
    179211    const ComObjPtr <USBController, ComWeakRef> mParent;
    … …  
    202234    struct Data : public USBDeviceFilter::Data
    203235    {
     236#ifndef VBOX_WITH_USBFILTER
    204237        Data() : mAction (USBDeviceFilterAction_USBDeviceFilterIgnore) {}
    205 
    206238        USBDeviceFilterAction_T mAction;
     239#else  /* VBOX_WITH_USBFILTER */
     240        Data() {}
     241#endif /* VBOX_WITH_USBFILTER */
    207242    };
    208243
    … …  
    277312
    278313private:
     314#ifdef VBOX_WITH_USBFILTER
     315    HRESULT usbFilterFieldGetter (USBFILTERIDX aIdx, BSTR *aStr);
     316    HRESULT usbFilterFieldSetter (USBFILTERIDX aIdx, Bstr aStr, Utf8Str aName);
     317#endif
    279318
    280319    const ComObjPtr <Host, ComWeakRef> mParent;
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette