VirtualBox

Changeset 77984 in vbox for trunk/src/VBox/Main/src-server


Ignore:
Timestamp:
Apr 2, 2019 2:06:13 PM (6 years ago)
Author:
vboxsync
Message:

Main/HostDnsService: Renaming and cleanup (no functional changes).

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

Legend:

Unmodified
Added
Removed

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

    r77666 r77984  
    7878}
    7979
    80 struct HostDnsMonitor::Data
     80struct HostDnsServiceBase::Data
    8181{
    8282    Data(bool aThreaded)
    83       : proxy(NULL),
    84         fThreaded(aThreaded)
     83        : pProxy(NULL)
     84        , fThreaded(aThreaded)
    8585    {}
    8686
    87     HostDnsMonitorProxy *proxy;
    88 
    89     const bool fThreaded;
    90     RTSEMEVENT hDnsInitEvent;
    91     RTTHREAD hMonitoringThread;
    92 
    93     HostDnsInformation info;
     87    /** Weak pointer to parent proxy object. */
     88    HostDnsMonitorProxy *pProxy;
     89    /** Whether the DNS monitor implementation has a dedicated monitoring thread. Optional. */
     90    const bool           fThreaded;
     91    /** Event for the monitor thread, if any. */
     92    RTSEMEVENT           hMonitorThreadEvent;
     93    /** Handle of the monitor thread, if any. */
     94    RTTHREAD             hMonitorThread;
     95    /** Generic host DNS information. */
     96    HostDnsInformation   info;
    9497};
    9598
    9699struct HostDnsMonitorProxy::Data
    97100{
    98     Data(HostDnsMonitor *aMonitor, VirtualBox *aParent)
    99       : virtualbox(aParent),
    100         monitor(aMonitor),
    101         uLastExtraDataPoll(0),
    102         fLaxComparison(0),
    103         info()
     101    Data(HostDnsServiceBase *aMonitor, VirtualBox *aParent)
     102        : pVirtualBox(aParent)
     103        , pMonitorImpl(aMonitor)
     104        , uLastExtraDataPoll(0)
     105        , fLaxComparison(0)
     106        , info()
    104107    {}
    105108
    106     VirtualBox *virtualbox;
    107     HostDnsMonitor *monitor;
     109    VirtualBox *pVirtualBox;
     110    HostDnsServiceBase *pMonitorImpl;
    108111
    109112    uint64_t uLastExtraDataPoll;
    … …  
    113116
    114117
    115 HostDnsMonitor::HostDnsMonitor(bool fThreaded)
    116   : m(NULL)
    117 {
    118    m = new HostDnsMonitor::Data(fThreaded);
    119 }
    120 
    121 HostDnsMonitor::~HostDnsMonitor()
     118HostDnsServiceBase::HostDnsServiceBase(bool fThreaded)
     119    : m(NULL)
     120{
     121    m = new HostDnsServiceBase::Data(fThreaded);
     122}
     123
     124HostDnsServiceBase::~HostDnsServiceBase()
    122125{
    123126    if (m)
    … …  
    128131}
    129132
    130 HostDnsMonitor *HostDnsMonitor::createHostDnsMonitor()
    131 {
    132     HostDnsMonitor *monitor = NULL;
     133HostDnsServiceBase *HostDnsServiceBase::createHostDnsMonitor(void)
     134{
     135    HostDnsServiceBase *pMonitor = NULL;
    133136
    134137#if defined (RT_OS_DARWIN)
    135     monitor = new HostDnsServiceDarwin();
     138    pMonitor = new HostDnsServiceDarwin();
    136139#elif defined(RT_OS_WINDOWS)
    137     monitor = new HostDnsServiceWin();
     140    pMonitor = new HostDnsServiceWin();
    138141#elif defined(RT_OS_LINUX)
    139     monitor = new HostDnsServiceLinux();
     142    pMonitor = new HostDnsServiceLinux();
    140143#elif defined(RT_OS_SOLARIS)
    141     monitor =  new HostDnsServiceSolaris();
     144    pMonitor =  new HostDnsServiceSolaris();
    142145#elif defined(RT_OS_FREEBSD)
    143     monitor = new HostDnsServiceFreebsd();
     146    pMonitor = new HostDnsServiceFreebsd();
    144147#elif defined(RT_OS_OS2)
    145     monitor = new HostDnsServiceOs2();
     148    pMonitor = new HostDnsServiceOs2();
    146149#else
    147     monitor = new HostDnsService();
     150    pMonitor = new HostDnsServiceBase();
    148151#endif
    149152
    150     return monitor;
    151 }
    152 
    153 
    154 void HostDnsMonitor::shutdown()
     153    return pMonitor;
     154}
     155
     156void HostDnsServiceBase::shutdown(void)
    155157{
    156158    monitorThreadShutdown();
    157     int rc = RTThreadWait(m->hMonitoringThread, 5000, NULL);
     159    int rc = RTThreadWait(m->hMonitorThread, 5000, NULL);
    158160    AssertRCSuccess(rc);
    159161}
    160162
    161163
    162 void HostDnsMonitor::setInfo(const HostDnsInformation &info)
    163 {
    164     if (m->proxy != NULL)
    165         m->proxy->notify(info);
    166 }
    167 
    168 HRESULT HostDnsMonitor::init(HostDnsMonitorProxy *proxy)
    169 {
    170     m->proxy = proxy;
     164void HostDnsServiceBase::setInfo(const HostDnsInformation &info)
     165{
     166    if (m->pProxy != NULL)
     167        m->pProxy->notify(info);
     168}
     169
     170HRESULT HostDnsServiceBase::init(HostDnsMonitorProxy *pProxy)
     171{
     172    m->pProxy = pProxy;
    171173
    172174    if (m->fThreaded)
    173175    {
    174         int rc = RTSemEventCreate(&m->hDnsInitEvent);
     176        int rc = RTSemEventCreate(&m->hMonitorThreadEvent);
    175177        AssertRCReturn(rc, E_FAIL);
    176178
    177         rc = RTThreadCreate(&m->hMonitoringThread,
    178                             HostDnsMonitor::threadMonitoringRoutine,
     179        rc = RTThreadCreate(&m->hMonitorThread,
     180                            HostDnsServiceBase::threadMonitoringRoutine,
    179181                            this, 128 * _1K, RTTHREADTYPE_IO,
    180182                            RTTHREADFLAGS_WAITABLE, "dns-monitor");
    181183        AssertRCReturn(rc, E_FAIL);
    182184
    183         RTSemEventWait(m->hDnsInitEvent, RT_INDEFINITE_WAIT);
     185        RTSemEventWait(m->hMonitorThreadEvent, RT_INDEFINITE_WAIT);
    184186    }
    185187    return S_OK;
    186188}
    187189
    188 
    189 void HostDnsMonitorProxy::pollGlobalExtraData()
    190 {
    191     VirtualBox *virtualbox = m->virtualbox;
    192     if (RT_UNLIKELY(virtualbox == NULL))
     190void HostDnsMonitorProxy::pollGlobalExtraData(void)
     191{
     192    VirtualBox *pVirtualBox = m->pVirtualBox;
     193    if (RT_UNLIKELY(pVirtualBox == NULL))
    193194        return;
    194195
    … …  
    203204        const com::Bstr bstrHostDNSOrderIgnoreKey("VBoxInternal2/HostDNSOrderIgnore");
    204205        com::Bstr bstrHostDNSOrderIgnore;
    205         virtualbox->GetExtraData(bstrHostDNSOrderIgnoreKey.raw(),
     206        pVirtualBox->GetExtraData(bstrHostDNSOrderIgnoreKey.raw(),
    206207                                 bstrHostDNSOrderIgnore.asOutParam());
    207208        uint32_t fDNSOrderIgnore = 0;
    … …  
    226227        const com::Bstr bstrHostDNSSuffixesIgnoreKey("VBoxInternal2/HostDNSSuffixesIgnore");
    227228        com::Bstr bstrHostDNSSuffixesIgnore;
    228         virtualbox->GetExtraData(bstrHostDNSSuffixesIgnoreKey.raw(),
     229        pVirtualBox->GetExtraData(bstrHostDNSSuffixesIgnoreKey.raw(),
    229230                                 bstrHostDNSSuffixesIgnore.asOutParam());
    230231        uint32_t fDNSSuffixesIgnore = 0;
    … …  
    246247}
    247248
    248 void HostDnsMonitor::monitorThreadInitializationDone()
    249 {
    250     RTSemEventSignal(m->hDnsInitEvent);
    251 }
    252 
    253 
    254 DECLCALLBACK(int) HostDnsMonitor::threadMonitoringRoutine(RTTHREAD, void *pvUser)
    255 {
    256     HostDnsMonitor *pThis = static_cast<HostDnsMonitor *>(pvUser);
     249void HostDnsServiceBase::monitorThreadInitializationDone(void)
     250{
     251    RTSemEventSignal(m->hMonitorThreadEvent);
     252}
     253
     254DECLCALLBACK(int) HostDnsServiceBase::threadMonitoringRoutine(RTTHREAD, void *pvUser)
     255{
     256    HostDnsServiceBase *pThis = static_cast<HostDnsServiceBase *>(pvUser);
    257257    return pThis->monitorWorker();
    258258}
    … …  
    271271void HostDnsMonitorProxy::init(VirtualBox* aParent)
    272272{
    273     HostDnsMonitor *monitor = HostDnsMonitor::createHostDnsMonitor();
    274     m = new HostDnsMonitorProxy::Data(monitor, aParent);
    275     m->monitor->init(this);
    276 }
    277 
    278 
    279 void HostDnsMonitorProxy::uninit()
     273    HostDnsServiceBase *pMonitor = HostDnsServiceBase::createHostDnsMonitor();
     274    m = new HostDnsMonitorProxy::Data(pMonitor, aParent);
     275    m->pMonitorImpl->init(this);
     276}
     277
     278void HostDnsMonitorProxy::uninit(void)
    280279{
    281280    if (m)
    282281    {
    283         m->monitor->shutdown();
     282        m->pMonitorImpl->shutdown();
    284283        delete m;
    285284        m = NULL;
    … …  
    291290    bool fNotify = updateInfo(info);
    292291    if (fNotify)
    293         m->virtualbox->i_onHostNameResolutionConfigurationChange();
     292        m->pVirtualBox->i_onHostNameResolutionConfigurationChange();
    294293}
    295294
    … …  
    362361    return true;
    363362}
    364 
    365363
    366364static void dumpHostDnsInformation(const HostDnsInformation& info)

  • trunk/src/VBox/Main/src-server/HostDnsService.h

    r77506 r77984  
    5252 * it lifecycle starts and ends together with VBoxSVC.
    5353 */
    54 class HostDnsMonitor
    55 {
    56     DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostDnsMonitor);
    57 
    58   public:
    59     static HostDnsMonitor *createHostDnsMonitor();
     54class HostDnsServiceBase
     55{
     56    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP(HostDnsServiceBase);
     57
     58public:
     59 
     60    static HostDnsServiceBase *createHostDnsMonitor(void);
    6061    void shutdown();
    6162
    6263    /* @note: method will wait till client call
    6364       HostDnsService::monitorThreadInitializationDone() */
    64     virtual HRESULT init(HostDnsMonitorProxy *proxy);
    65 
    66   protected:
    67     explicit HostDnsMonitor(bool fThreaded = false);
    68     virtual ~HostDnsMonitor();
     65    virtual HRESULT init(HostDnsMonitorProxy *pProxy);
     66
     67protected:
     68
     69    explicit HostDnsServiceBase(bool fThreaded = false);
     70    virtual ~HostDnsServiceBase();
    6971
    7072    void setInfo(const HostDnsInformation &);
    … …  
    7577    virtual int monitorWorker() = 0;
    7678
    77   private:
     79private:
     80
    7881    static DECLCALLBACK(int) threadMonitoringRoutine(RTTHREAD, void *);
    7982
    80   protected:
     83protected:
     84
    8185    mutable RTCLockMtx m_LockMtx;
    8286
    83   public:
     87public: /** @todo r=andy Why is this public? */
     88
    8489    struct Data;
    8590    Data *m;
    … …  
    9196class HostDnsMonitorProxy
    9297{
    93     public:
     98public:
     99
    94100    HostDnsMonitorProxy();
    95     ~HostDnsMonitorProxy();
     101    virtual ~HostDnsMonitorProxy();
     102
     103public:
     104
    96105    void init(VirtualBox *virtualbox);
    97106    void uninit();
    … …  
    102111    HRESULT GetSearchStrings(std::vector<com::Utf8Str> &aSearchStrings);
    103112
    104   private:
     113private:
     114
    105115    void pollGlobalExtraData();
    106116    bool updateInfo(const HostDnsInformation &info);
    107117
    108   private:
     118private:
     119
    109120    mutable RTCLockMtx m_LockMtx;
    110121
    111     private:
    112122    struct Data;
    113123    Data *m;
    … …  
    115125
    116126# if defined(RT_OS_DARWIN) || defined(DOXYGEN_RUNNING)
    117 class HostDnsServiceDarwin : public HostDnsMonitor
    118 {
    119   public:
     127class HostDnsServiceDarwin : public HostDnsServiceBase
     128{
     129public:
    120130    HostDnsServiceDarwin();
    121     ~HostDnsServiceDarwin();
    122     virtual HRESULT init(HostDnsMonitorProxy *proxy);
    123 
    124     protected:
     131    virtual ~HostDnsServiceDarwin();
     132
     133public:
     134
     135    virtual HRESULT init(HostDnsMonitorProxy *pProxy);
     136
     137protected:
     138
     139  virtual void monitorThreadShutdown();
     140    virtual int monitorWorker();
     141
     142private:
     143
     144    HRESULT updateInfo();
     145    static void hostDnsServiceStoreCallback(void *store, void *arrayRef, void *info);
     146    struct Data;
     147    Data *m;
     148};
     149# endif
     150# if defined(RT_OS_WINDOWS) || defined(DOXYGEN_RUNNING)
     151class HostDnsServiceWin : public HostDnsServiceBase
     152{
     153public:
     154    HostDnsServiceWin();
     155    virtual ~HostDnsServiceWin();
     156
     157public:
     158
     159    virtual HRESULT init(HostDnsMonitorProxy *pProxy);
     160
     161protected:
     162
    125163    virtual void monitorThreadShutdown();
    126164    virtual int monitorWorker();
    127165
    128     private:
    129     HRESULT updateInfo();
    130     static void hostDnsServiceStoreCallback(void *store, void *arrayRef, void *info);
    131     struct Data;
    132     Data *m;
    133 };
    134 # endif
    135 # if defined(RT_OS_WINDOWS) || defined(DOXYGEN_RUNNING)
    136 class HostDnsServiceWin : public HostDnsMonitor
    137 {
    138     public:
    139     HostDnsServiceWin();
    140     ~HostDnsServiceWin();
    141     virtual HRESULT init(HostDnsMonitorProxy *proxy);
    142 
    143     protected:
    144     virtual void monitorThreadShutdown();
    145     virtual int monitorWorker();
    146 
    147     private:
     166private:
     167
    148168    HRESULT updateInfo();
    149169
    … …  
    155175# if defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX) || defined(RT_OS_OS2) || defined(RT_OS_FREEBSD) \
    156176    || defined(DOXYGEN_RUNNING)
    157 class HostDnsServiceResolvConf: public HostDnsMonitor
    158 {
    159   public:
    160     explicit HostDnsServiceResolvConf(bool fThreaded = false) : HostDnsMonitor(fThreaded), m(NULL) {}
     177class HostDnsServiceResolvConf: public HostDnsServiceBase
     178{
     179public:
     180
     181    explicit HostDnsServiceResolvConf(bool fThreaded = false) : HostDnsServiceBase(fThreaded), m(NULL) {}
    161182    virtual ~HostDnsServiceResolvConf();
    162     virtual HRESULT init(HostDnsMonitorProxy *proxy, const char *aResolvConfFileName);
     183
     184public:
     185
     186    virtual HRESULT init(HostDnsMonitorProxy *pProxy, const char *aResolvConfFileName);
    163187    const std::string& resolvConf() const;
    164188
    165   protected:
     189protected:
     190
    166191    HRESULT readResolvConf();
    167192    /* While not all hosts supports Hosts DNS change notifiaction
    … …  
    171196    virtual int monitorWorker() {return VERR_IGNORED;}
    172197
    173   protected:
     198protected:
     199
    174200    struct Data;
    175201    Data *m;
    … …  
    181207class HostDnsServiceSolaris : public HostDnsServiceResolvConf
    182208{
    183   public:
     209public:
     210
    184211    HostDnsServiceSolaris(){}
    185     ~HostDnsServiceSolaris(){}
    186     virtual HRESULT init(HostDnsMonitorProxy *proxy) {
    187         return HostDnsServiceResolvConf::init(proxy, "/etc/resolv.conf");
     212    virtual ~HostDnsServiceSolaris(){}
     213
     214public:
     215
     216    virtual HRESULT init(HostDnsMonitorProxy *pProxy) {
     217        return HostDnsServiceResolvConf::init(pProxy, "/etc/resolv.conf");
    188218    }
    189219};
    … …  
    193223class HostDnsServiceLinux : public HostDnsServiceResolvConf
    194224{
    195   public:
    196     HostDnsServiceLinux():HostDnsServiceResolvConf(true){}
    197     virtual ~HostDnsServiceLinux();
    198     virtual HRESULT init(HostDnsMonitorProxy *proxy) {
    199         return HostDnsServiceResolvConf::init(proxy, "/etc/resolv.conf");
    200     }
    201 
    202   protected:
     225public:
     226
     227  HostDnsServiceLinux() : HostDnsServiceResolvConf(true) {}
     228  virtual ~HostDnsServiceLinux();
     229
     230public:
     231
     232    virtual HRESULT init(HostDnsMonitorProxy *pProxy) {
     233        return HostDnsServiceResolvConf::init(pProxy, "/etc/resolv.conf");
     234    }
     235
     236protected:
     237
    203238    virtual void monitorThreadShutdown();
    204239    virtual int monitorWorker();
    … …  
    209244class HostDnsServiceFreebsd: public HostDnsServiceResolvConf
    210245{
    211     public:
     246public:
     247
    212248    HostDnsServiceFreebsd(){}
    213     ~HostDnsServiceFreebsd(){}
    214     virtual HRESULT init(HostDnsMonitorProxy *proxy) {
    215         return HostDnsServiceResolvConf::init(proxy, "/etc/resolv.conf");
     249    virtual ~HostDnsServiceFreebsd() {}
     250
     251public:
     252
     253    virtual HRESULT init(HostDnsMonitorProxy *pProxy) {
     254        return HostDnsServiceResolvConf::init(pProxy, "/etc/resolv.conf");
    216255    }
    217256};
    … …  
    221260class HostDnsServiceOs2 : public HostDnsServiceResolvConf
    222261{
    223   public:
    224     HostDnsServiceOs2(){}
    225     ~HostDnsServiceOs2(){}
     262public:
     263
     264    HostDnsServiceOs2() {}
     265    virtual ~HostDnsServiceOs2() {}
     266
     267public:
     268
    226269    /* XXX: \\MPTN\\ETC should be taken from environment variable ETC  */
    227     virtual HRESULT init(HostDnsMonitorProxy *proxy) {
    228         return HostDnsServiceResolvConf::init(proxy, "\\MPTN\\ETC\\RESOLV2");
     270    virtual HRESULT init(HostDnsMonitorProxy *pProxy) {
     271        return HostDnsServiceResolvConf::init(pProxy, "\\MPTN\\ETC\\RESOLV2");
    229272    }
    230273};

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

    r76553 r77984  
    5555};
    5656
    57 const std::string& HostDnsServiceResolvConf::resolvConf() const
     57const std::string& HostDnsServiceResolvConf::resolvConf(void) const
    5858{
    5959    return m->resolvConfFilename;
    … …  
    7070}
    7171
    72 HRESULT HostDnsServiceResolvConf::init(HostDnsMonitorProxy *proxy, const char *aResolvConfFileName)
     72HRESULT HostDnsServiceResolvConf::init(HostDnsMonitorProxy *pProxy, const char *aResolvConfFileName)
    7373{
    7474    m = new Data(aResolvConfFileName);
    7575
    76     HostDnsMonitor::init(proxy);
     76    HostDnsServiceBase::init(pProxy);
    7777
    7878    readResolvConf();
    … …  
    8181}
    8282
    83 
    84 HRESULT HostDnsServiceResolvConf::readResolvConf()
     83HRESULT HostDnsServiceResolvConf::readResolvConf(void)
    8584{
    8685    struct rcp_state st;

  • trunk/src/VBox/Main/src-server/darwin/HostDnsServiceDarwin.cpp

    r77872 r77984  
    5151
    5252
    53 HostDnsServiceDarwin::HostDnsServiceDarwin():HostDnsMonitor(true),m(NULL)
     53HostDnsServiceDarwin::HostDnsServiceDarwin()
     54    : HostDnsServiceBase(true)
     55    , m(NULL)
    5456{
    5557    m = new HostDnsServiceDarwin::Data();
    … …  
    8688
    8789
    88 HRESULT HostDnsServiceDarwin::init(HostDnsMonitorProxy *proxy)
     90HRESULT HostDnsServiceDarwin::init(HostDnsMonitorProxy *pProxy)
    8991{
    9092    SCDynamicStoreContext ctx;
    … …  
    9496
    9597    m->m_store = SCDynamicStoreCreate(NULL, CFSTR("org.virtualbox.VBoxSVC"),
    96                                    (SCDynamicStoreCallBack)HostDnsServiceDarwin::hostDnsServiceStoreCallback,
    97                                    &ctx);
     98                                      (SCDynamicStoreCallBack)HostDnsServiceDarwin::hostDnsServiceStoreCallback,
     99                                      &ctx);
    98100    AssertReturn(m->m_store, E_FAIL);
    99101
    … …  
    111113    AssertReturn(m->m_Stopper, E_FAIL);
    112114
    113     HRESULT hrc = HostDnsMonitor::init(proxy);
     115    HRESULT hrc = HostDnsServiceBase::init(pProxy);
    114116    AssertComRCReturn(hrc, hrc);
    115117
    … …  
    118120
    119121
    120 void HostDnsServiceDarwin::monitorThreadShutdown()
     122void HostDnsServiceDarwin::monitorThreadShutdown(void)
    121123{
    122124    RTCLock grab(m_LockMtx);
    … …  
    132134
    133135
    134 int HostDnsServiceDarwin::monitorWorker()
     136int HostDnsServiceDarwin::monitorWorker(void)
    135137{
    136138    m->m_RunLoopRef = CFRunLoopGetCurrent();
    … …  
    168170}
    169171
    170 
    171 HRESULT HostDnsServiceDarwin::updateInfo()
     172HRESULT HostDnsServiceDarwin::updateInfo(void)
    172173{
    173174    CFPropertyListRef propertyRef = SCDynamicStoreCopyValue(m->m_store,
    … …  
    254255}
    255256
    256 void HostDnsServiceDarwin::Data::performShutdownCallback(void *info)
    257 {
    258     HostDnsServiceDarwin::Data *pThis = static_cast<HostDnsServiceDarwin::Data *>(info);
     257void HostDnsServiceDarwin::Data::performShutdownCallback(void *pInfo)
     258{
     259    HostDnsServiceDarwin::Data *pThis = static_cast<HostDnsServiceDarwin::Data *>(pInfo);
    259260    AssertPtrReturnVoid(pThis);
    260261    pThis->m_fStop = true;

  • trunk/src/VBox/Main/src-server/linux/HostDnsServiceLinux.cpp

    r76553 r77984  
    9494
    9595
    96 int HostDnsServiceLinux::monitorWorker()
     96int HostDnsServiceLinux::monitorWorker(void)
    9797{
    9898
    … …  
    151151            RT_ZERO(combo);
    152152            ssize_t r = read(polls[0].fd, static_cast<void *>(&combo), sizeof(combo));
    153             NOREF(r);
     153            RT_NOREF(r);
    154154
    155155            if (combo.e.wd == wd[0])

  • trunk/src/VBox/Main/src-server/win/HostDnsServiceWin.cpp

    r76553 r77984  
    8787
    8888
    89 HRESULT HostDnsServiceWin::init(HostDnsMonitorProxy *proxy)
     89HRESULT HostDnsServiceWin::init(HostDnsMonitorProxy *pProxy)
    9090{
    9191    if (m == NULL)
    … …  
    129129    }
    130130
    131     HRESULT hrc = HostDnsMonitor::init(proxy);
     131    HRESULT hrc = HostDnsServiceBase::init(pProxy);
    132132    if (FAILED(hrc))
    133133        return hrc;
    … …  
    248248
    249249
    250 HRESULT HostDnsServiceWin::updateInfo()
     250HRESULT HostDnsServiceWin::updateInfo(void)
    251251{
    252252    HostDnsInformation info;
    … …  
    471471        info.searchList.clear();
    472472
    473     HostDnsMonitor::setInfo(info);
     473    HostDnsServiceBase::setInfo(info);
    474474
    475475    return S_OK;
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