VirtualBox

Ignore:
Timestamp:
Sep 28, 2021 6:15:49 AM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
147096
Message:

Devices: bugref:9932 DrvVMNet and host-only network initial implementation

Location:
trunk/src/VBox/Frontends/VBoxManage
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/Makefile.kmk

    r91213 r91416  
    3232        $(if $(VBOX_WITH_HOSTNETIF_API), VBOX_WITH_HOSTNETIF_API) \
    3333        $(if $(VBOX_WITH_NETFLT), VBOX_WITH_NETFLT) \
     34        $(if $(VBOX_WITH_VMNET), VBOX_WITH_VMNET) \
    3435        $(if $(VBOX_WITH_CLOUD_NET), VBOX_WITH_CLOUD_NET) \
    3536        $(if $(VBOX_WITH_LIBCURL), VBOX_WITH_PROXY_INFO) \

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

    r91204 r91416  
    151151    { "hostonlyif",         USAGE_HOSTONLYIFS,      VBMG_CMD_TODO, handleHostonlyIf,           0 },
    152152#endif
     153#ifdef VBOX_WITH_VMNET
     154    { "hostonlynet",        USAGE_S_NEWCMD,  HELP_CMD_HOSTONLYNET, handleHostonlyNet,          0 },
     155#endif
    153156    { "dhcpserver",         USAGE_S_NEWCMD,   HELP_CMD_DHCPSERVER, handleDHCPServer,           0 },
    154157#ifdef VBOX_WITH_NAT_SERVICE

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.h

    r91157 r91416  
    333333/* VBoxManageHostonly.cpp */
    334334RTEXITCODE handleHostonlyIf(HandlerArg *a);
     335#ifdef VBOX_WITH_VMNET
     336RTEXITCODE handleHostonlyNet(HandlerArg *a);
     337#endif /* VBOX_WITH_VMNET */
    335338
    336339/* VBoxManageDHCPServer.cpp */

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageHostonly.cpp

    r82968 r91416  
    282282}
    283283
     284#ifdef VBOX_WITH_VMNET
     285struct HostOnlyNetworkOptions
     286{
     287    bool fEnable;
     288    bool fDisable;
     289    Bstr bstrNetworkId;
     290    Bstr bstrNetworkName;
     291    Bstr bstrNetworkMask;
     292    Bstr bstrLowerIp;
     293    Bstr bstrUpperIp;
     294    /* Initialize fEnable and fDisable */
     295    HostOnlyNetworkOptions() : fEnable(false), fDisable(false) {};
     296};
     297typedef struct HostOnlyNetworkOptions HOSTONLYNETOPT;
     298
     299static RTEXITCODE createUpdateHostOnlyNetworkParse(HandlerArg *a, HOSTONLYNETOPT& options)
     300{
     301    static const RTGETOPTDEF s_aOptions[] =
     302    {
     303        { "--id",             'i', RTGETOPT_REQ_STRING  },
     304        { "--name",           'n', RTGETOPT_REQ_STRING  },
     305        { "--netmask",        'm', RTGETOPT_REQ_STRING  },
     306        { "--lower-ip",       'l', RTGETOPT_REQ_STRING  },
     307        { "--lowerip",        'l', RTGETOPT_REQ_STRING  },
     308        { "--upper-ip",       'u', RTGETOPT_REQ_STRING  },
     309        { "--upperip",        'u', RTGETOPT_REQ_STRING  },
     310        { "--enable",         'e', RTGETOPT_REQ_NOTHING },
     311        { "--disable",        'd', RTGETOPT_REQ_NOTHING },
     312    };
     313
     314    RTGETOPTSTATE GetState;
     315    RTGETOPTUNION ValueUnion;
     316    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1 /* iFirst */, 0);
     317    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     318
     319    int c;
     320    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
     321    {
     322        switch (c)
     323        {
     324            case 'i':
     325                options.bstrNetworkId = ValueUnion.psz;
     326                break;
     327            case 'n':
     328                options.bstrNetworkName = ValueUnion.psz;
     329                break;
     330            case 'm':
     331                options.bstrNetworkMask = ValueUnion.psz;
     332                break;
     333            case 'l':
     334                options.bstrLowerIp = ValueUnion.psz;
     335                break;
     336            case 'u':
     337                options.bstrUpperIp = ValueUnion.psz;
     338                break;
     339            case 'e':
     340                options.fEnable = true;
     341                break;
     342            case 'd':
     343                options.fDisable = true;
     344                break;
     345            case VINF_GETOPT_NOT_OPTION:
     346                return errorUnknownSubcommand(ValueUnion.psz);
     347            default:
     348                return errorGetOpt(c, &ValueUnion);
     349        }
     350    }
     351    return RTEXITCODE_SUCCESS;
     352}
     353
     354static RTEXITCODE createUpdateHostOnlyNetworkCommon(ComPtr<IHostOnlyNetwork> hostOnlyNetwork, HOSTONLYNETOPT& options)
     355{
     356    HRESULT hrc = S_OK;
     357
     358    if (options.bstrNetworkId.isNotEmpty())
     359    {
     360        CHECK_ERROR2_RET(hrc, hostOnlyNetwork, COMSETTER(Id)(options.bstrNetworkId.raw()), RTEXITCODE_FAILURE);
     361    }
     362    if (options.bstrNetworkName.isNotEmpty())
     363    {
     364        CHECK_ERROR2_RET(hrc, hostOnlyNetwork, COMSETTER(NetworkName)(options.bstrNetworkName.raw()), RTEXITCODE_FAILURE);
     365    }
     366    if (options.bstrNetworkMask.isNotEmpty())
     367    {
     368        CHECK_ERROR2_RET(hrc, hostOnlyNetwork, COMSETTER(NetworkMask)(options.bstrNetworkMask.raw()), RTEXITCODE_FAILURE);
     369    }
     370    if (options.bstrLowerIp.isNotEmpty())
     371    {
     372        CHECK_ERROR2_RET(hrc, hostOnlyNetwork, COMSETTER(LowerIP)(options.bstrLowerIp.raw()), RTEXITCODE_FAILURE);
     373    }
     374    if (options.bstrUpperIp.isNotEmpty())
     375    {
     376        CHECK_ERROR2_RET(hrc, hostOnlyNetwork, COMSETTER(UpperIP)(options.bstrUpperIp.raw()), RTEXITCODE_FAILURE);
     377    }
     378    if (options.fEnable)
     379    {
     380        CHECK_ERROR2_RET(hrc, hostOnlyNetwork, COMSETTER(Enabled)(TRUE), RTEXITCODE_FAILURE);
     381    }
     382    if (options.fDisable)
     383    {
     384        CHECK_ERROR2_RET(hrc, hostOnlyNetwork, COMSETTER(Enabled)(FALSE), RTEXITCODE_FAILURE);
     385    }
     386
     387    return RTEXITCODE_SUCCESS;
     388}
     389
     390static RTEXITCODE handleNetAdd(HandlerArg *a)
     391{
     392    HRESULT hrc = S_OK;
     393
     394    HOSTONLYNETOPT options;
     395    hrc = createUpdateHostOnlyNetworkParse(a, options);
     396
     397    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
     398    ComPtr<IHostOnlyNetwork> hostOnlyNetwork;
     399
     400    if (options.bstrNetworkName.isEmpty())
     401        return errorArgument("The --name parameter must be specified");
     402    if (options.bstrNetworkMask.isEmpty())
     403        return errorArgument("The --netmask parameter must be specified");
     404    if (options.bstrLowerIp.isEmpty())
     405        return errorArgument("The --lower-ip parameter must be specified");
     406    if (options.bstrUpperIp.isEmpty())
     407        return errorArgument("The --upper-ip parameter must be specified");
     408
     409    CHECK_ERROR2_RET(hrc, pVirtualBox,
     410                     CreateHostOnlyNetwork(options.bstrNetworkName.raw(), hostOnlyNetwork.asOutParam()),
     411                     RTEXITCODE_FAILURE);
     412    return createUpdateHostOnlyNetworkCommon(hostOnlyNetwork, options);
     413}
     414
     415static RTEXITCODE handleNetModify(HandlerArg *a)
     416{
     417    HRESULT hrc = S_OK;
     418
     419    HOSTONLYNETOPT options;
     420    hrc = createUpdateHostOnlyNetworkParse(a, options);
     421
     422    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
     423    ComPtr<IHostOnlyNetwork> hostOnlyNetwork;
     424
     425    if (options.bstrNetworkName.isNotEmpty())
     426    {
     427        CHECK_ERROR2_RET(hrc, pVirtualBox,
     428                        FindHostOnlyNetworkByName(options.bstrNetworkName.raw(), hostOnlyNetwork.asOutParam()),
     429                        RTEXITCODE_FAILURE);
     430    }
     431    else if (options.bstrNetworkId.isNotEmpty())
     432    {
     433        CHECK_ERROR2_RET(hrc, pVirtualBox,
     434                        FindHostOnlyNetworkById(options.bstrNetworkId.raw(), hostOnlyNetwork.asOutParam()),
     435                        RTEXITCODE_FAILURE);
     436    }
     437    else
     438        return errorArgument("Either --name or --id parameter must be specified");
     439
     440    return createUpdateHostOnlyNetworkCommon(hostOnlyNetwork, options);
     441}
     442
     443static RTEXITCODE handleNetRemove(HandlerArg *a)
     444{
     445    HRESULT hrc = S_OK;
     446
     447    static const RTGETOPTDEF s_aOptions[] =
     448    {
     449        { "--id",             'i', RTGETOPT_REQ_STRING },
     450        { "--name",           'n', RTGETOPT_REQ_STRING },
     451    };
     452
     453    RTGETOPTSTATE GetState;
     454    RTGETOPTUNION ValueUnion;
     455    int vrc = RTGetOptInit(&GetState, a->argc, a->argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1 /* iFirst */, 0);
     456    AssertRCReturn(vrc, RTEXITCODE_FAILURE);
     457
     458    Bstr strNetworkId, strNetworkName;
     459
     460    int c;
     461    while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
     462    {
     463        switch (c)
     464        {
     465            case 'i':
     466                strNetworkId=ValueUnion.psz;
     467                break;
     468            case 'n':
     469                strNetworkName=ValueUnion.psz;
     470                break;
     471            case VINF_GETOPT_NOT_OPTION:
     472                return errorUnknownSubcommand(ValueUnion.psz);
     473            default:
     474                return errorGetOpt(c, &ValueUnion);
     475        }
     476    }
     477
     478    ComPtr<IVirtualBox> pVirtualBox = a->virtualBox;
     479    ComPtr<IHostOnlyNetwork> hostOnlyNetwork;
     480
     481    if (!strNetworkName.isEmpty())
     482    {
     483        CHECK_ERROR2_RET(hrc, pVirtualBox,
     484                        FindHostOnlyNetworkByName(strNetworkName.raw(), hostOnlyNetwork.asOutParam()),
     485                        RTEXITCODE_FAILURE);
     486    }
     487    else if (!strNetworkId.isEmpty())
     488    {
     489        CHECK_ERROR2_RET(hrc, pVirtualBox,
     490                        FindHostOnlyNetworkById(strNetworkId.raw(), hostOnlyNetwork.asOutParam()),
     491                        RTEXITCODE_FAILURE);
     492    }
     493    else
     494        return errorArgument("Either --name or --id parameter must be specified");
     495
     496    CHECK_ERROR2_RET(hrc, pVirtualBox,
     497                    RemoveHostOnlyNetwork(hostOnlyNetwork),
     498                    RTEXITCODE_FAILURE);
     499    return RTEXITCODE_SUCCESS;
     500}
     501
     502RTEXITCODE handleHostonlyNet(HandlerArg *a)
     503{
     504    if (a->argc < 1)
     505        return errorSyntax("No sub-command specified");
     506
     507    RTEXITCODE rcExit;
     508    if (!strcmp(a->argv[0], "add"))
     509    {
     510        setCurrentSubcommand(HELP_SCOPE_HOSTONLYNET_ADD);
     511        rcExit = handleNetAdd(a);
     512    }
     513    else if (!strcmp(a->argv[0], "modify"))
     514    {
     515        setCurrentSubcommand(HELP_SCOPE_HOSTONLYNET_MODIFY);
     516        rcExit = handleNetModify(a);
     517    }
     518    else if (!strcmp(a->argv[0], "remove"))
     519    {
     520        setCurrentSubcommand(HELP_SCOPE_HOSTONLYNET_REMOVE);
     521        rcExit = handleNetRemove(a);
     522    }
     523    else
     524        rcExit = errorSyntax("Unknown sub-command '%s'", a->argv[0]);
     525    return rcExit;
     526}
     527#endif /* VBOX_WITH_VMNET */
     528
    284529#endif /* !VBOX_ONLY_DOCS */

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

    r91363 r91416  
    15031503                    }
    15041504
     1505#ifdef VBOX_WITH_VMNET
     1506                    case NetworkAttachmentType_HostOnlyNetwork:
     1507                    {
     1508                        Bstr strNetwork;
     1509                        nic->COMGETTER(HostOnlyNetwork)(strNetwork.asOutParam());
     1510                        if (details == VMINFO_MACHINEREADABLE)
     1511                        {
     1512                            RTPrintf("hostonly-network%d=\"%ls\"\n", currentNIC + 1, strNetwork.raw());
     1513                            strAttachment = "hostonlynetwork";
     1514                        }
     1515                        else
     1516                            strAttachment.printf("Host Only Network '%s'", Utf8Str(strNetwork).c_str());
     1517                        break;
     1518                    }
     1519#endif /* VBOX_WITH_VMNET */
     1520
    15051521#ifdef VBOX_WITH_CLOUD_NET
    15061522                    case NetworkAttachmentType_Cloud:

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageList.cpp

    r90828 r91416  
    193193    return rc;
    194194}
     195
     196
     197#ifdef VBOX_WITH_VMNET
     198/**
     199 * List configured host-only networks.
     200 *
     201 * @returns See produceList.
     202 * @param   pVirtualBox         Reference to the IVirtualBox smart pointer.
     203 * @param   Reserved            Placeholder!
     204 */
     205static HRESULT listHostOnlyNetworks(const ComPtr<IVirtualBox> pVirtualBox)
     206{
     207    HRESULT rc;
     208    com::SafeIfaceArray<IHostOnlyNetwork> hostOnlyNetworks;
     209    CHECK_ERROR(pVirtualBox, COMGETTER(HostOnlyNetworks)(ComSafeArrayAsOutParam(hostOnlyNetworks)));
     210    for (size_t i = 0; i < hostOnlyNetworks.size(); ++i)
     211    {
     212        ComPtr<IHostOnlyNetwork> hostOnlyNetwork = hostOnlyNetworks[i];
     213        Bstr networkName;
     214        hostOnlyNetwork->COMGETTER(NetworkName)(networkName.asOutParam());
     215        RTPrintf("Name:            %ls\n", networkName.raw());
     216        Bstr networkGuid;
     217        hostOnlyNetwork->COMGETTER(Id)(networkGuid.asOutParam());
     218        RTPrintf("GUID:            %ls\n\n", networkGuid.raw());
     219        BOOL fEnabled = FALSE;
     220        hostOnlyNetwork->COMGETTER(Enabled)(&fEnabled);
     221        RTPrintf("State:           %s\n", fEnabled ? "Enabled" : "Disabled");
     222
     223        Bstr networkMask;
     224        hostOnlyNetwork->COMGETTER(NetworkMask)(networkMask.asOutParam());
     225        RTPrintf("NetworkMask:     %ls\n", networkMask.raw());
     226        Bstr lowerIP;
     227        hostOnlyNetwork->COMGETTER(LowerIP)(lowerIP.asOutParam());
     228        RTPrintf("LowerIP:         %ls\n", lowerIP.raw());
     229        Bstr upperIP;
     230        hostOnlyNetwork->COMGETTER(UpperIP)(upperIP.asOutParam());
     231        RTPrintf("UpperIP:         %ls\n", upperIP.raw());
     232        // Bstr NetworkId;
     233        // hostOnlyNetwork->COMGETTER(Id)(NetworkId.asOutParam());
     234        // RTPrintf("NetworkId:       %ls\n", NetworkId.raw());
     235        Bstr netName = BstrFmt("hostonly-%ls", networkName.raw());
     236        RTPrintf("VBoxNetworkName: %ls\n\n", netName.raw());
     237    }
     238    return rc;
     239}
     240#endif /* VBOX_WITH_VMNET */
    195241
    196242
    … …  
    18141860    kListHostOnlyInterfaces,
    18151861#endif
     1862#if defined(VBOX_WITH_VMNET)
     1863    kListHostOnlyNetworks,
     1864#endif
    18161865#if defined(VBOX_WITH_CLOUD_NET)
    18171866    kListCloudNetworks,
    … …  
    20262075            break;
    20272076
     2077#if defined(VBOX_WITH_VMNET)
     2078        case kListHostOnlyNetworks:
     2079            rc = listHostOnlyNetworks(pVirtualBox);
     2080            break;
     2081#endif
     2082
    20282083#if defined(VBOX_WITH_CLOUD_NET)
    20292084        case kListCloudNetworks:
    … …  
    22322287#if defined(VBOX_WITH_NETFLT)
    22332288        { "hostonlyifs",        kListHostOnlyInterfaces, RTGETOPT_REQ_NOTHING },
     2289#endif
     2290#if defined(VBOX_WITH_VMNET)
     2291        { "hostonlynets",       kListHostOnlyNetworks,   RTGETOPT_REQ_NOTHING },
    22342292#endif
    22352293#if defined(VBOX_WITH_CLOUD_NET)
    … …  
    22912349#if defined(VBOX_WITH_NETFLT)
    22922350            case kListHostOnlyInterfaces:
     2351#endif
     2352#if defined(VBOX_WITH_VMNET)
     2353            case kListHostOnlyNetworks:
    22932354#endif
    22942355#if defined(VBOX_WITH_CLOUD_NET)

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

    r91213 r91416  
    136136    MODIFYVM_BRIDGEADAPTER,
    137137    MODIFYVM_HOSTONLYADAPTER,
     138#ifdef VBOX_WITH_VMNET
     139    MODIFYVM_HOSTONLYNET,
     140#endif /* VBOX_WITH_VMNET */
    138141    MODIFYVM_INTNET,
    139142    MODIFYVM_GENERICDRV,
    … …  
    338341    { "--bridgeadapter",            MODIFYVM_BRIDGEADAPTER,             RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
    339342    { "--hostonlyadapter",          MODIFYVM_HOSTONLYADAPTER,           RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
     343#ifdef VBOX_WITH_VMNET
     344    { "--hostonlynet",              MODIFYVM_HOSTONLYNET,               RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
     345#endif /* VBOX_WITH_VMNET */
    340346    { "--intnet",                   MODIFYVM_INTNET,                    RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
    341347    { "--nicgenericdrv",            MODIFYVM_GENERICDRV,                RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
    … …  
    16891695                    CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnly));
    16901696                }
     1697#ifdef VBOX_WITH_VMNET
     1698                else if (!RTStrICmp(ValueUnion.psz, "hostonlynet"))
     1699                {
     1700                    if (!fEnabled)
     1701                        CHECK_ERROR(nic, COMSETTER(Enabled)(TRUE));
     1702                    CHECK_ERROR(nic, COMSETTER(AttachmentType)(NetworkAttachmentType_HostOnlyNetwork));
     1703                }
     1704#endif /* VBOX_WITH_VMNET */
    16911705                else if (!RTStrICmp(ValueUnion.psz, "generic"))
    16921706                {
    … …  
    17671781                break;
    17681782            }
     1783
     1784#ifdef VBOX_WITH_VMNET
     1785            case MODIFYVM_HOSTONLYNET:
     1786            {
     1787                if (!parseNum(GetOptState.uIndex, NetworkAdapterCount, "NIC"))
     1788                    break;
     1789
     1790                ComPtr<INetworkAdapter> nic;
     1791                CHECK_ERROR_BREAK(sessionMachine, GetNetworkAdapter(GetOptState.uIndex - 1, nic.asOutParam()));
     1792                ASSERT(nic);
     1793
     1794                /* remove it? */
     1795                if (!RTStrICmp(ValueUnion.psz, "none"))
     1796                {
     1797                    CHECK_ERROR(nic, COMSETTER(HostOnlyNetwork)(Bstr().raw()));
     1798                }
     1799                else
     1800                {
     1801                    CHECK_ERROR(nic, COMSETTER(HostOnlyNetwork)(Bstr(ValueUnion.psz).raw()));
     1802                }
     1803                break;
     1804            }
     1805#endif /* VBOX_WITH_VMNET */
    17691806
    17701807            case MODIFYVM_INTNET:
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