VirtualBox

Changeset 49494 in vbox


Ignore:
Timestamp:
Nov 15, 2013 10:32:10 AM (11 years ago)
Author:
vboxsync
Message:

Main/NetServiceRunner: Make command line more flexible for adding service specific parameters.

XXX: creating final array parameter to RTProcCreate(array,) need further improvements.

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

Legend:

Unmodified
Added
Removed

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

    r48955 r49494  
    4343    DHCPServerRunner():NetworkServiceRunner(DHCP_EXECUTABLE_NAME){}
    4444    virtual ~DHCPServerRunner(){};
     45
     46    static const std::string kDsrKeyGateway;
     47    static const std::string kDsrKeyLowerIp;
     48    static const std::string kDsrKeyUpperIp;
    4549};
    4650

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

    r49129 r49494  
    4949public:
    5050    NATNetworkServiceRunner(): NetworkServiceRunner(NATSR_EXECUTABLE_NAME){}
    51     virtual ~NATNetworkServiceRunner(){}
     51    ~NATNetworkServiceRunner(){}
    5252};
    5353

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

    r48107 r49494  
    2222#include <VBox/com/string.h>
    2323
    24 typedef enum
    25 {
    26     NETCFG_NAME = 1,
    27     NETCFG_NETNAME,
    28     NETCFG_TRUNKTYPE,
    29     NETCFG_TRUNKNAME,
    30     NETCFG_MACADDRESS,
    31     NETCFG_IPADDRESS,
    32     NETCFG_NETMASK,
    33     NETCFG_VERBOSE,
    34     NETCFG_NOTOPT_MAXVAL
    35 } NETCFG;
    36 
    3724#define TRUNKTYPE_WHATEVER "whatever"
    3825#define TRUNKTYPE_NETFLT   "netflt"
    … …  
    4330{
    4431public:
    45     NetworkServiceRunner(const char *aProcName)
    46         : mProcName(aProcName)
    47         , mProcess(NIL_RTPROCESS)
    48     {
    49         RT_ZERO(mOptionEnabled);
    50     };
    51     ~NetworkServiceRunner()
    52     {
    53         stop(); /* don't leave abandoned servers */
    54     }
     32    NetworkServiceRunner(const char *aProcName);
     33    virtual ~NetworkServiceRunner();
    5534
    56     int setOption(NETCFG opt, const char *val, bool enabled)
    57     {
    58         if (opt == 0 || opt >= NETCFG_NOTOPT_MAXVAL)
    59             return VERR_INVALID_PARAMETER;
    60         if (isRunning())
    61             return VERR_INVALID_STATE;
    62 
    63         mOptions[opt] = val;
    64         mOptionEnabled[opt] = enabled;
    65         return VINF_SUCCESS;
    66     }
    67 
    68     int setOption(NETCFG opt, const com::Utf8Str &val, bool enabled)
    69     {
    70         return setOption(opt, val.c_str(), enabled);
    71     }
     35    int setOption(const std::string& key, const std::string& val);
    7236
    7337    int start();
    … …  
    7640
    7741    void detachFromServer();
     42
     43    static const std::string kNsrKeyName;
     44    static const std::string kNsrKeyNetwork;
     45    static const std::string kNsrKeyTrunkType;
     46    static const std::string kNsrTrunkName;
     47    static const std::string kNsrMacAddress;
     48    static const std::string kNsrIpAddress;
     49    static const std::string kNsrIpNetmask;
     50   
    7851private:
    79     com::Utf8Str mOptions[NETCFG_NOTOPT_MAXVAL];
    80     bool mOptionEnabled[NETCFG_NOTOPT_MAXVAL];
    81     const char *mProcName;
    82     RTPROCESS mProcess;
     52    struct Data;
     53    Data *m;
    8354};
    84 

  • trunk/src/VBox/Main/src-server/DHCPServerImpl.cpp

    r47112 r49494  
    1818 */
    1919
     20#include <string>
    2021#include "NetworkServiceRunner.h"
    2122#include "DHCPServerImpl.h"
    … …  
    3233// constructor / destructor
    3334/////////////////////////////////////////////////////////////////////////////
     35const std::string DHCPServerRunner::kDsrKeyGateway = "--gateway";
     36const std::string DHCPServerRunner::kDsrKeyLowerIp = "--lower-ip";
     37const std::string DHCPServerRunner::kDsrKeyUpperIp = "--upper-ip";
     38
    3439
    3540DHCPServer::DHCPServer()
    … …  
    471476
    472477    /* Commmon Network Settings */
    473     m.dhcp.setOption(NETCFG_NETNAME, Utf8Str(aNetworkName), true);
     478    m.dhcp.setOption(NetworkServiceRunner::kNsrKeyNetwork, Utf8Str(aNetworkName).c_str());
    474479
    475480    Bstr tmp(aTrunkName);
    476481
    477482    if (!tmp.isEmpty())
    478         m.dhcp.setOption(NETCFG_TRUNKNAME, Utf8Str(tmp), true);
    479     m.dhcp.setOption(NETCFG_TRUNKTYPE, Utf8Str(aTrunkType), true);
     483        m.dhcp.setOption(NetworkServiceRunner::kNsrTrunkName, Utf8Str(tmp).c_str());
     484    m.dhcp.setOption(NetworkServiceRunner::kNsrKeyTrunkType, Utf8Str(aTrunkType).c_str());
    480485
    481486    /* XXX: should this MAC default initialization moved to NetworkServiceRunner? */
    … …  
    487492                 guid.raw()->au8[1],
    488493                 guid.raw()->au8[2]);
    489     m.dhcp.setOption(NETCFG_MACADDRESS, strMAC, true);
    490     m.dhcp.setOption(NETCFG_IPADDRESS,  Utf8Str(m.IPAddress), true);
    491     m.dhcp.setOption(NETCFG_NETMASK, Utf8Str(m.GlobalDhcpOptions[DhcpOpt_SubnetMask]), true);
     494    m.dhcp.setOption(NetworkServiceRunner::kNsrMacAddress, strMAC);
     495    m.dhcp.setOption(NetworkServiceRunner::kNsrIpAddress,  Utf8Str(m.IPAddress).c_str());
     496    m.dhcp.setOption(NetworkServiceRunner::kNsrIpNetmask, Utf8Str(m.GlobalDhcpOptions[DhcpOpt_SubnetMask]).c_str());
     497    m.dhcp.setOption(DHCPServerRunner::kDsrKeyLowerIp, Utf8Str(m.lowerIP).c_str());
     498    m.dhcp.setOption(DHCPServerRunner::kDsrKeyUpperIp, Utf8Str(m.upperIP).c_str());
    492499
    493500    /* XXX: This parameters Dhcp Server will fetch via API */

  • trunk/src/VBox/Main/src-server/NATNetworkImpl.cpp

    r49408 r49494  
    1616 */
    1717
     18#include <string>
    1819#include "NetworkServiceRunner.h"
    1920#include "DHCPServerImpl.h"
    … …  
    870871    if (!m->fEnabled) return S_OK;
    871872
    872     m->NATRunner.setOption(NETCFG_NETNAME, mName, true);
    873     m->NATRunner.setOption(NETCFG_TRUNKTYPE, Utf8Str(aTrunkType), true);
    874     m->NATRunner.setOption(NETCFG_IPADDRESS, m->IPv4Gateway, true);
    875     m->NATRunner.setOption(NETCFG_NETMASK, m->IPv4NetworkMask, true);
     873    m->NATRunner.setOption(NetworkServiceRunner::kNsrKeyNetwork, Utf8Str(mName).c_str());
     874    m->NATRunner.setOption(NetworkServiceRunner::kNsrKeyTrunkType, Utf8Str(aTrunkType).c_str());
     875    m->NATRunner.setOption(NetworkServiceRunner::kNsrIpAddress, Utf8Str(m->IPv4Gateway).c_str());
     876    m->NATRunner.setOption(NetworkServiceRunner::kNsrIpNetmask, Utf8Str(m->IPv4NetworkMask).c_str());
    876877
    877878    /* No portforwarding rules from command-line, all will be fetched via API */

  • trunk/src/VBox/Main/src-server/NetworkServiceRunner.cpp

    r47447 r49494  
    1515 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
    1616 */
     17
     18#include <map>
     19#include <string>
    1720#include "NetworkServiceRunner.h"
    1821#include <iprt/process.h>
    … …  
    2023#include <iprt/env.h>
    2124
    22 struct ARGDEF
     25
     26const std::string NetworkServiceRunner::kNsrKeyName = "--name";
     27const std::string NetworkServiceRunner::kNsrKeyNetwork = "--network";
     28const std::string NetworkServiceRunner::kNsrKeyTrunkType = "--trunk-type";
     29const std::string NetworkServiceRunner::kNsrTrunkName = "--trunk-name";
     30const std::string NetworkServiceRunner::kNsrMacAddress = "--mac-address";
     31const std::string NetworkServiceRunner::kNsrIpAddress = "--ip-address";
     32const std::string NetworkServiceRunner::kNsrIpNetmask = "--netmask";
     33
     34struct NetworkServiceRunner::Data
    2335{
    24     NETCFG Type;
    25     const char * Name;
     36    Data(const char* aProcName):mProcName(aProcName), mProcess(NIL_RTPROCESS){}
     37    const char *mProcName;
     38    RTPROCESS mProcess;
     39    std::map<std::string, std::string> mOptions;
    2640};
    2741
    28 static const ARGDEF g_aArgDefs[] =
     42NetworkServiceRunner::NetworkServiceRunner(const char *aProcName)
    2943{
    30     {NETCFG_NAME, "--name"},
    31     {NETCFG_NETNAME, "--network"},
    32     {NETCFG_TRUNKTYPE, "--trunk-type"},
    33     {NETCFG_TRUNKNAME, "--trunk-name"},
    34     {NETCFG_MACADDRESS, "--mac-address"},
    35     {NETCFG_IPADDRESS, "--ip-address"},
    36     {NETCFG_VERBOSE, "--verbose"},
    37     {NETCFG_NETMASK, "--netmask"},
    38 };
     44    m = new NetworkServiceRunner::Data(aProcName);
     45   
     46}
    3947
    40 static const ARGDEF * getArgDef(NETCFG type)
     48
     49NetworkServiceRunner::~NetworkServiceRunner()
    4150{
    42     for (unsigned i = 0; i < RT_ELEMENTS(g_aArgDefs); i++)
    43         if (g_aArgDefs[i].Type == type)
    44             return &g_aArgDefs[i];
     51    stop();
     52    delete m;
     53    m = NULL;
     54}
    4555
    46     return NULL;
     56
     57int NetworkServiceRunner::setOption(const std::string& key, const std::string& val)
     58{
     59    m->mOptions.insert(std::map<std::string, std::string>::value_type(key, val));
     60    return VINF_SUCCESS;
    4761}
     62
    4863
    4964void NetworkServiceRunner::detachFromServer()
    5065{
    51     mProcess = NIL_RTPROCESS;
     66    m->mProcess = NIL_RTPROCESS;
    5267}
     68
    5369
    5470int NetworkServiceRunner::start()
    … …  
    5773        return VINF_ALREADY_INITIALIZED;
    5874
    59     const char * args[NETCFG_NOTOPT_MAXVAL * 2];
     75    const char * args[10*2];
     76
     77    AssertReturn(m->mOptions.size() < 10, VERR_INTERNAL_ERROR);
    6078
    6179    /* get the path to the executable */
    … …  
    6987    {
    7088        suffix++;
    71         strcpy(suffix, mProcName);
     89        strcpy(suffix, m->mProcName);
    7290    }
    7391
    … …  
    7694    args[index++] = exePath;
    7795
    78     for (unsigned i = 0; i < NETCFG_NOTOPT_MAXVAL; i++)
     96    std::map<std::string, std::string>::const_iterator it;
     97    for(it = m->mOptions.begin(); it != m->mOptions.end(); ++it)
    7998    {
    80         if (mOptionEnabled[i])
    81         {
    82             const ARGDEF *pArgDef = getArgDef((NETCFG)i);
    83             if (!pArgDef)
    84                 continue;
    85             args[index++] = pArgDef->Name;
    86 
    87             if (mOptions[i].length())
    88                 args[index++] = mOptions[i].c_str();  // value
    89         }
     99        args[index++] = it->first.c_str();
     100        args[index++] = it->second.c_str();
    90101    }
    91102
    92103    args[index++] = NULL;
    93104
    94     int rc = RTProcCreate(suffix ? exePath : mProcName, args, RTENV_DEFAULT, 0, &mProcess);
     105    int rc = RTProcCreate(suffix ? exePath : m->mProcName, args, RTENV_DEFAULT, 0, &m->mProcess);
    95106    if (RT_FAILURE(rc))
    96         mProcess = NIL_RTPROCESS;
     107        m->mProcess = NIL_RTPROCESS;
    97108
    98109    return rc;
    99110}
     111
    100112
    101113int NetworkServiceRunner::stop()
    … …  
    104116        return VINF_OBJECT_DESTROYED;
    105117
    106     int rc = RTProcTerminate(mProcess);
    107     RTProcWait(mProcess, RTPROCWAIT_FLAGS_BLOCK, NULL);
    108     mProcess = NIL_RTPROCESS;
     118    int rc = RTProcTerminate(m->mProcess);
     119    RTProcWait(m->mProcess, RTPROCWAIT_FLAGS_BLOCK, NULL);
     120    m->mProcess = NIL_RTPROCESS;
    109121    return rc;
    110122}
    … …  
    112124bool NetworkServiceRunner::isRunning()
    113125{
    114     if (mProcess == NIL_RTPROCESS)
     126    if (m->mProcess == NIL_RTPROCESS)
    115127        return false;
    116128
    117129    RTPROCSTATUS status;
    118     int rc = RTProcWait(mProcess, RTPROCWAIT_FLAGS_NOBLOCK, &status);
     130    int rc = RTProcWait(m->mProcess, RTPROCWAIT_FLAGS_NOBLOCK, &status);
    119131
    120132    if (rc == VERR_PROCESS_RUNNING)
    121133        return true;
    122134
    123     mProcess = NIL_RTPROCESS;
     135    m->mProcess = NIL_RTPROCESS;
    124136    return false;
    125137}
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