← Back to branch summary

~ubuntu-branches/ubuntu/raring/virtualbox-ose/raring

« back to all changes in this revision

Viewing changes to src/VBox/Main/src-server/NATEngineImpl.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2011-01-30 23:27:25 UTC
  • mfrom: (0.3.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20110130232725-2ouajjd2ggdet0zd
Tags: 4.0.2-dfsg-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Add Apport hook.
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Drop *-source packages.
* Drop ubuntu-01-fix-build-gcc45.patch, fixed upstream.
* Drop ubuntu-02-as-needed.patch, added to the Debian package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Main/src-server/NATEngineImpl.cpp
 
1
/* $Id: NATEngineImpl.cpp 35577 2011-01-16 16:16:19Z vboxsync $ */
 
2
/** @file
 
3
 * Implementation of INATEngine in VBoxSVC.
 
4
 */
 
5
 
 
6
/*
 
7
 * Copyright (C) 2010 Oracle Corporation
 
8
 *
 
9
 * This file is part of VirtualBox Open Source Edition (OSE), as
 
10
 * available from http://www.virtualbox.org. This file is free software;
 
11
 * you can redistribute it and/or modify it under the terms of the GNU
 
12
 * General Public License (GPL) as published by the Free Software
 
13
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 
14
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 
15
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 
16
 */
 
17
 
 
18
#include "NATEngineImpl.h"
 
19
#include "AutoCaller.h"
 
20
#include "Logging.h"
 
21
#include "MachineImpl.h"
 
22
#include "GuestOSTypeImpl.h"
 
23
 
 
24
#include <iprt/string.h>
 
25
#include <iprt/cpp/utils.h>
 
26
 
 
27
#include <VBox/err.h>
 
28
#include <VBox/settings.h>
 
29
 
 
30
 
 
31
// constructor / destructor
 
32
////////////////////////////////////////////////////////////////////////////////
 
33
 
 
34
NATEngine::NATEngine():mParent(NULL), mAdapter(NULL){}
 
35
NATEngine::~NATEngine(){}
 
36
 
 
37
HRESULT NATEngine::FinalConstruct()
 
38
{
 
39
    return S_OK;
 
40
}
 
41
 
 
42
HRESULT NATEngine::init(Machine *aParent, INetworkAdapter *aAdapter)
 
43
{
 
44
    AutoInitSpan autoInitSpan(this);
 
45
    AssertReturn(autoInitSpan.isOk(), E_FAIL);
 
46
    autoInitSpan.setSucceeded();
 
47
    m_fModified = false;
 
48
    mData.allocate();
 
49
    mData->mNetwork.setNull();
 
50
    mData->mBindIP.setNull();
 
51
    unconst(mParent) = aParent;
 
52
    unconst(mAdapter) = aAdapter;
 
53
    return S_OK;
 
54
}
 
55
 
 
56
HRESULT NATEngine::init(Machine *aParent, INetworkAdapter *aAdapter, NATEngine *aThat)
 
57
{
 
58
    AutoInitSpan autoInitSpan(this);
 
59
    AssertReturn(autoInitSpan.isOk(), E_FAIL);
 
60
    Log(("init that:%p this:%p\n", aThat, this));
 
61
 
 
62
    AutoCaller thatCaller (aThat);
 
63
    AssertComRCReturnRC(thatCaller.rc());
 
64
 
 
65
    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
 
66
 
 
67
    mData.share(aThat->mData);
 
68
    NATRuleMap::iterator it;
 
69
    mNATRules.clear();
 
70
    for (it = aThat->mNATRules.begin(); it != aThat->mNATRules.end(); ++it)
 
71
    {
 
72
        mNATRules.insert(std::make_pair(it->first, it->second));
 
73
    }
 
74
    unconst(mParent) = aParent;
 
75
    unconst(mAdapter) = aAdapter;
 
76
    unconst(mPeer) = aThat;
 
77
    autoInitSpan.setSucceeded();
 
78
    return S_OK;
 
79
}
 
80
 
 
81
HRESULT NATEngine::initCopy (Machine *aParent, INetworkAdapter *aAdapter, NATEngine *aThat)
 
82
{
 
83
    AutoInitSpan autoInitSpan(this);
 
84
    AssertReturn(autoInitSpan.isOk(), E_FAIL);
 
85
 
 
86
    Log(("initCopy that:%p this:%p\n", aThat, this));
 
87
 
 
88
    AutoCaller thatCaller (aThat);
 
89
    AssertComRCReturnRC(thatCaller.rc());
 
90
 
 
91
    AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
 
92
 
 
93
    mData.attachCopy(aThat->mData);
 
94
    NATRuleMap::iterator it;
 
95
    mNATRules.clear();
 
96
    for (it = aThat->mNATRules.begin(); it != aThat->mNATRules.end(); ++it)
 
97
    {
 
98
        mNATRules.insert(std::make_pair(it->first, it->second));
 
99
    }
 
100
    unconst(mAdapter) = aAdapter;
 
101
    unconst(mParent) = aParent;
 
102
    autoInitSpan.setSucceeded();
 
103
    return S_OK;
 
104
}
 
105
 
 
106
 
 
107
void NATEngine::FinalRelease()
 
108
{
 
109
    uninit();
 
110
}
 
111
 
 
112
void NATEngine::uninit()
 
113
{
 
114
    AutoUninitSpan autoUninitSpan(this);
 
115
    if (autoUninitSpan.uninitDone())
 
116
        return;
 
117
 
 
118
    mNATRules.clear();
 
119
    mData.free();
 
120
    unconst(mPeer) = NULL;
 
121
    unconst(mParent) = NULL;
 
122
}
 
123
 
 
124
bool NATEngine::isModified()
 
125
{
 
126
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
127
    bool fModified = m_fModified;
 
128
    return fModified;
 
129
}
 
130
 
 
131
bool NATEngine::rollback()
 
132
{
 
133
    AutoCaller autoCaller(this);
 
134
    AssertComRCReturn (autoCaller.rc(), false);
 
135
 
 
136
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
137
    bool fChanged = m_fModified;
 
138
 
 
139
    if (m_fModified)
 
140
    {
 
141
        /* we need to check all data to see whether anything will be changed
 
142
         * after rollback */
 
143
        mData.rollback();
 
144
    }
 
145
    m_fModified = false;
 
146
    return fChanged;
 
147
}
 
148
 
 
149
void NATEngine::commit()
 
150
{
 
151
    AutoCaller autoCaller(this);
 
152
    AssertComRCReturnVoid (autoCaller.rc());
 
153
 
 
154
    /* sanity too */
 
155
    AutoCaller peerCaller (mPeer);
 
156
    AssertComRCReturnVoid (peerCaller.rc());
 
157
 
 
158
    /* lock both for writing since we modify both (mPeer is "master" so locked
 
159
     * first) */
 
160
    AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
 
161
    if (m_fModified)
 
162
    {
 
163
        mData.commit();
 
164
        if (mPeer)
 
165
        {
 
166
            mPeer->mData.attach (mData);
 
167
            mPeer->mNATRules.clear();
 
168
            NATRuleMap::iterator it;
 
169
            for (it = mNATRules.begin(); it != mNATRules.end(); ++it)
 
170
            {
 
171
                mPeer->mNATRules.insert(std::make_pair(it->first, it->second));
 
172
            }
 
173
        }
 
174
    }
 
175
    m_fModified = false;
 
176
}
 
177
 
 
178
STDMETHODIMP
 
179
NATEngine::GetNetworkSettings(ULONG *aMtu, ULONG *aSockSnd, ULONG *aSockRcv, ULONG *aTcpWndSnd, ULONG *aTcpWndRcv)
 
180
{
 
181
    AutoCaller autoCaller(this);
 
182
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
183
 
 
184
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
185
    if (aMtu)
 
186
        *aMtu = mData->mMtu;
 
187
    if (aSockSnd)
 
188
        *aSockSnd = mData->mSockSnd;
 
189
    if (aSockRcv)
 
190
         *aSockRcv = mData->mSockRcv;
 
191
    if (aTcpWndSnd)
 
192
         *aTcpWndSnd = mData->mTcpSnd;
 
193
    if (aTcpWndRcv)
 
194
         *aTcpWndRcv = mData->mTcpRcv;
 
195
 
 
196
    return S_OK;
 
197
}
 
198
 
 
199
STDMETHODIMP
 
200
NATEngine::SetNetworkSettings(ULONG aMtu, ULONG aSockSnd, ULONG aSockRcv, ULONG aTcpWndSnd, ULONG aTcpWndRcv)
 
201
{
 
202
    AutoCaller autoCaller(this);
 
203
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
204
 
 
205
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
206
    if (   aMtu || aSockSnd || aSockRcv
 
207
        || aTcpWndSnd || aTcpWndRcv)
 
208
    {
 
209
        mData.backup();
 
210
        m_fModified = true;
 
211
    }
 
212
    if (aMtu)
 
213
        mData->mMtu = aMtu;
 
214
    if (aSockSnd)
 
215
        mData->mSockSnd = aSockSnd;
 
216
    if (aSockRcv)
 
217
        mData->mSockRcv = aSockSnd;
 
218
    if (aTcpWndSnd)
 
219
        mData->mTcpSnd = aTcpWndSnd;
 
220
    if (aTcpWndRcv)
 
221
        mData->mTcpRcv = aTcpWndRcv;
 
222
 
 
223
    if (m_fModified)
 
224
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
225
    return S_OK;
 
226
}
 
227
 
 
228
STDMETHODIMP
 
229
NATEngine::COMGETTER(Redirects)(ComSafeArrayOut(BSTR , aNatRules))
 
230
{
 
231
    CheckComArgOutSafeArrayPointerValid(aNatRules);
 
232
 
 
233
    AutoCaller autoCaller(this);
 
234
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
235
 
 
236
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
237
 
 
238
 
 
239
    SafeArray<BSTR> sf(mNATRules.size());
 
240
    size_t i = 0;
 
241
    NATRuleMap::const_iterator it;
 
242
    for (it = mNATRules.begin();
 
243
         it != mNATRules.end(); ++it, ++i)
 
244
    {
 
245
        settings::NATRule r = it->second;
 
246
        BstrFmt bstr("%s,%d,%s,%d,%s,%d",
 
247
                     r.strName.c_str(),
 
248
                     r.proto,
 
249
                     r.strHostIP.c_str(),
 
250
                     r.u16HostPort,
 
251
                     r.strGuestIP.c_str(),
 
252
                     r.u16GuestPort);
 
253
        bstr.detachTo(&sf[i]);
 
254
    }
 
255
    sf.detachTo(ComSafeArrayOutArg(aNatRules));
 
256
    return S_OK;
 
257
}
 
258
 
 
259
 
 
260
STDMETHODIMP
 
261
NATEngine::AddRedirect(IN_BSTR aName, NATProtocol_T aProto, IN_BSTR aBindIp, USHORT aHostPort, IN_BSTR aGuestIP, USHORT aGuestPort)
 
262
{
 
263
 
 
264
    AutoCaller autoCaller(this);
 
265
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
266
 
 
267
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
268
    Utf8Str name = aName;
 
269
    settings::NATRule r;
 
270
    const char *proto;
 
271
    switch (aProto)
 
272
    {
 
273
        case NATProtocol_TCP:
 
274
            proto = "tcp";
 
275
            break;
 
276
        case NATProtocol_UDP:
 
277
            proto = "udp";
 
278
            break;
 
279
        default:
 
280
            return E_INVALIDARG;
 
281
    }
 
282
    if (name.isEmpty())
 
283
        name = Utf8StrFmt("%s_%d_%d", proto, aHostPort, aGuestPort);
 
284
 
 
285
    NATRuleMap::iterator it;
 
286
    for (it = mNATRules.begin(); it != mNATRules.end(); ++it)
 
287
    {
 
288
        r = it->second;
 
289
        if (it->first == name)
 
290
            return setError(E_INVALIDARG,
 
291
                            tr("A NAT rule of this name already exists"));
 
292
        if (   r.strHostIP == Utf8Str(aBindIp)
 
293
            && r.u16HostPort == aHostPort
 
294
            && r.proto == aProto)
 
295
            return setError(E_INVALIDARG,
 
296
                            tr("A NAT rule for this host port and this host IP already exists"));
 
297
    }
 
298
 
 
299
    r.strName = name.c_str();
 
300
    r.proto = aProto;
 
301
    r.strHostIP = aBindIp;
 
302
    r.u16HostPort = aHostPort;
 
303
    r.strGuestIP = aGuestIP;
 
304
    r.u16GuestPort = aGuestPort;
 
305
    mNATRules.insert(std::make_pair(name, r));
 
306
    mParent->setModified(Machine::IsModified_NetworkAdapters);
 
307
    m_fModified = true;
 
308
 
 
309
    ULONG ulSlot;
 
310
    mAdapter->COMGETTER(Slot)(&ulSlot);
 
311
 
 
312
    alock.release();
 
313
    mParent->onNATRedirectRuleChange(ulSlot, FALSE, Bstr(name).raw(), aProto, Bstr(r.strHostIP).raw(), r.u16HostPort, Bstr(r.strGuestIP).raw(), r.u16GuestPort);
 
314
    return S_OK;
 
315
}
 
316
 
 
317
STDMETHODIMP
 
318
NATEngine::RemoveRedirect(IN_BSTR aName)
 
319
{
 
320
    AutoCaller autoCaller(this);
 
321
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
 
322
 
 
323
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
324
    NATRuleMap::iterator it = mNATRules.find(aName);
 
325
    if (it == mNATRules.end())
 
326
        return E_INVALIDARG;
 
327
    mData.backup();
 
328
    settings::NATRule r = it->second;
 
329
    Utf8Str strHostIP = r.strHostIP;
 
330
    Utf8Str strGuestIP = r.strGuestIP;
 
331
    NATProtocol_T proto = r.proto;
 
332
    uint16_t u16HostPort = r.u16HostPort;
 
333
    uint16_t u16GuestPort = r.u16GuestPort;
 
334
    ULONG ulSlot;
 
335
    mAdapter->COMGETTER(Slot)(&ulSlot);
 
336
 
 
337
    mNATRules.erase(it);
 
338
    mParent->setModified(Machine::IsModified_NetworkAdapters);
 
339
    m_fModified = true;
 
340
    alock.release();
 
341
    mParent->onNATRedirectRuleChange(ulSlot, TRUE, aName, proto, Bstr(strHostIP).raw(), u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
 
342
    return S_OK;
 
343
}
 
344
 
 
345
HRESULT NATEngine::loadSettings(const settings::NAT &data)
 
346
{
 
347
    AutoCaller autoCaller(this);
 
348
    AssertComRCReturnRC(autoCaller.rc());
 
349
 
 
350
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
351
    HRESULT rc = S_OK;
 
352
    mData->mNetwork = data.strNetwork;
 
353
    mData->mBindIP = data.strBindIP;
 
354
    mData->mMtu = data.u32Mtu;
 
355
    mData->mSockSnd = data.u32SockSnd;
 
356
    mData->mTcpRcv = data.u32TcpRcv;
 
357
    mData->mTcpSnd = data.u32TcpSnd;
 
358
    /* TFTP */
 
359
    mData->mTftpPrefix = data.strTftpPrefix;
 
360
    mData->mTftpBootFile = data.strTftpBootFile;
 
361
    mData->mTftpNextServer = data.strTftpNextServer;
 
362
    /* DNS */
 
363
    mData->mDnsPassDomain = data.fDnsPassDomain;
 
364
    mData->mDnsProxy = data.fDnsProxy;
 
365
    mData->mDnsUseHostResolver = data.fDnsUseHostResolver;
 
366
    /* Alias */
 
367
    mData->mAliasMode  = (data.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
 
368
    mData->mAliasMode |= (data.fAliasLog          ? NATAliasMode_AliasLog          : 0);
 
369
    mData->mAliasMode |= (data.fAliasProxyOnly    ? NATAliasMode_AliasProxyOnly    : 0);
 
370
    /* port forwarding */
 
371
    mNATRules.clear();
 
372
    for (settings::NATRuleList::const_iterator it = data.llRules.begin();
 
373
        it != data.llRules.end(); ++it)
 
374
    {
 
375
        mNATRules.insert(std::make_pair(it->strName, *it));
 
376
    }
 
377
    m_fModified = false;
 
378
    return rc;
 
379
}
 
380
 
 
381
 
 
382
HRESULT NATEngine::saveSettings(settings::NAT &data)
 
383
{
 
384
    AutoCaller autoCaller(this);
 
385
    AssertComRCReturnRC(autoCaller.rc());
 
386
 
 
387
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
388
    HRESULT rc = S_OK;
 
389
    data.strNetwork = mData->mNetwork;
 
390
    data.strBindIP = mData->mBindIP;
 
391
    data.u32Mtu = mData->mMtu;
 
392
    data.u32SockRcv = mData->mSockRcv;
 
393
    data.u32SockSnd = mData->mSockSnd;
 
394
    data.u32TcpRcv = mData->mTcpRcv;
 
395
    data.u32TcpSnd = mData->mTcpSnd;
 
396
    /* TFTP */
 
397
    data.strTftpPrefix = mData->mTftpPrefix;
 
398
    data.strTftpBootFile = mData->mTftpBootFile;
 
399
    data.strTftpNextServer = mData->mTftpNextServer;
 
400
    /* DNS */
 
401
    data.fDnsPassDomain = !!mData->mDnsPassDomain;
 
402
    data.fDnsProxy = !!mData->mDnsProxy;
 
403
    data.fDnsUseHostResolver = !!mData->mDnsUseHostResolver;
 
404
    /* Alias */
 
405
    data.fAliasLog = !!(mData->mAliasMode & NATAliasMode_AliasLog);
 
406
    data.fAliasProxyOnly = !!(mData->mAliasMode & NATAliasMode_AliasProxyOnly);
 
407
    data.fAliasUseSamePorts = !!(mData->mAliasMode & NATAliasMode_AliasUseSamePorts);
 
408
 
 
409
    for (NATRuleMap::iterator it = mNATRules.begin();
 
410
        it != mNATRules.end(); ++it)
 
411
        data.llRules.push_back(it->second);
 
412
    m_fModified = false;
 
413
    return rc;
 
414
}
 
415
 
 
416
 
 
417
STDMETHODIMP
 
418
NATEngine::COMSETTER(Network)(IN_BSTR aNetwork)
 
419
{
 
420
    AutoCaller autoCaller(this);
 
421
    AssertComRCReturnRC (autoCaller.rc());
 
422
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
423
    if (Bstr(mData->mNetwork) != aNetwork)
 
424
    {
 
425
        mData.backup();
 
426
        mData->mNetwork = aNetwork;
 
427
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
428
        m_fModified = true;
 
429
    }
 
430
    return S_OK;
 
431
}
 
432
 
 
433
STDMETHODIMP
 
434
NATEngine::COMGETTER(Network)(BSTR *aNetwork)
 
435
{
 
436
    CheckComArgNotNull(aNetwork);
 
437
    AutoCaller autoCaller(this);
 
438
    AssertComRCReturnRC(autoCaller.rc());
 
439
 
 
440
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
441
    if (!mData->mNetwork.isEmpty())
 
442
    {
 
443
        mData->mNetwork.cloneTo(aNetwork);
 
444
        Log(("Getter (this:%p) Network: %s\n", this, mData->mNetwork.c_str()));
 
445
    }
 
446
    return S_OK;
 
447
}
 
448
 
 
449
STDMETHODIMP
 
450
NATEngine::COMSETTER(HostIP) (IN_BSTR aBindIP)
 
451
{
 
452
    AutoCaller autoCaller(this);
 
453
    AssertComRCReturnRC (autoCaller.rc());
 
454
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
455
    if (Bstr(mData->mBindIP) != aBindIP)
 
456
    {
 
457
        mData.backup();
 
458
        mData->mBindIP = aBindIP;
 
459
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
460
        m_fModified = true;
 
461
    }
 
462
    return S_OK;
 
463
}
 
464
STDMETHODIMP NATEngine::COMGETTER(HostIP) (BSTR *aBindIP)
 
465
{
 
466
    AutoCaller autoCaller(this);
 
467
    AssertComRCReturnRC(autoCaller.rc());
 
468
 
 
469
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
470
    if (!mData->mBindIP.isEmpty())
 
471
        mData->mBindIP.cloneTo(aBindIP);
 
472
    return S_OK;
 
473
}
 
474
 
 
475
 
 
476
STDMETHODIMP
 
477
NATEngine::COMSETTER(TftpPrefix)(IN_BSTR aTftpPrefix)
 
478
{
 
479
    AutoCaller autoCaller(this);
 
480
    AssertComRCReturnRC (autoCaller.rc());
 
481
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
482
    if (Bstr(mData->mTftpPrefix) != aTftpPrefix)
 
483
    {
 
484
        mData.backup();
 
485
        mData->mTftpPrefix = aTftpPrefix;
 
486
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
487
        m_fModified = true;
 
488
    }
 
489
    return S_OK;
 
490
}
 
491
 
 
492
STDMETHODIMP
 
493
NATEngine::COMGETTER(TftpPrefix)(BSTR *aTftpPrefix)
 
494
{
 
495
    AutoCaller autoCaller(this);
 
496
    AssertComRCReturnRC(autoCaller.rc());
 
497
 
 
498
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
499
    if (!mData->mTftpPrefix.isEmpty())
 
500
    {
 
501
        mData->mTftpPrefix.cloneTo(aTftpPrefix);
 
502
        Log(("Getter (this:%p) TftpPrefix: %s\n", this, mData->mTftpPrefix.c_str()));
 
503
    }
 
504
    return S_OK;
 
505
}
 
506
 
 
507
STDMETHODIMP
 
508
NATEngine::COMSETTER(TftpBootFile)(IN_BSTR aTftpBootFile)
 
509
{
 
510
    AutoCaller autoCaller(this);
 
511
    AssertComRCReturnRC (autoCaller.rc());
 
512
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
513
    if (Bstr(mData->mTftpBootFile) != aTftpBootFile)
 
514
    {
 
515
        mData.backup();
 
516
        mData->mTftpBootFile = aTftpBootFile;
 
517
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
518
        m_fModified = true;
 
519
    }
 
520
    return S_OK;
 
521
}
 
522
 
 
523
STDMETHODIMP
 
524
NATEngine::COMGETTER(TftpBootFile)(BSTR *aTftpBootFile)
 
525
{
 
526
    AutoCaller autoCaller(this);
 
527
    AssertComRCReturnRC(autoCaller.rc());
 
528
 
 
529
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
530
    if (!mData->mTftpBootFile.isEmpty())
 
531
    {
 
532
        mData->mTftpBootFile.cloneTo(aTftpBootFile);
 
533
        Log(("Getter (this:%p) BootFile: %s\n", this, mData->mTftpBootFile.c_str()));
 
534
    }
 
535
    return S_OK;
 
536
}
 
537
 
 
538
STDMETHODIMP
 
539
NATEngine::COMSETTER(TftpNextServer)(IN_BSTR aTftpNextServer)
 
540
{
 
541
    AutoCaller autoCaller(this);
 
542
    AssertComRCReturnRC (autoCaller.rc());
 
543
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
544
    if (Bstr(mData->mTftpNextServer) != aTftpNextServer)
 
545
    {
 
546
        mData.backup();
 
547
        mData->mTftpNextServer = aTftpNextServer;
 
548
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
549
        m_fModified = true;
 
550
    }
 
551
    return S_OK;
 
552
}
 
553
 
 
554
STDMETHODIMP
 
555
NATEngine::COMGETTER(TftpNextServer)(BSTR *aTftpNextServer)
 
556
{
 
557
    AutoCaller autoCaller(this);
 
558
    AssertComRCReturnRC(autoCaller.rc());
 
559
 
 
560
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
561
    if (!mData->mTftpNextServer.isEmpty())
 
562
    {
 
563
        mData->mTftpNextServer.cloneTo(aTftpNextServer);
 
564
        Log(("Getter (this:%p) NextServer: %s\n", this, mData->mTftpNextServer.c_str()));
 
565
    }
 
566
    return S_OK;
 
567
}
 
568
/* DNS */
 
569
STDMETHODIMP
 
570
NATEngine::COMSETTER(DnsPassDomain) (BOOL aDnsPassDomain)
 
571
{
 
572
    AutoCaller autoCaller(this);
 
573
    AssertComRCReturnRC (autoCaller.rc());
 
574
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
575
 
 
576
    if (mData->mDnsPassDomain != aDnsPassDomain)
 
577
    {
 
578
        mData.backup();
 
579
        mData->mDnsPassDomain = aDnsPassDomain;
 
580
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
581
        m_fModified = true;
 
582
    }
 
583
    return S_OK;
 
584
}
 
585
STDMETHODIMP
 
586
NATEngine::COMGETTER(DnsPassDomain)(BOOL *aDnsPassDomain)
 
587
{
 
588
    AutoCaller autoCaller(this);
 
589
    AssertComRCReturnRC(autoCaller.rc());
 
590
 
 
591
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
592
    *aDnsPassDomain = mData->mDnsPassDomain;
 
593
    return S_OK;
 
594
}
 
595
STDMETHODIMP
 
596
NATEngine::COMSETTER(DnsProxy)(BOOL aDnsProxy)
 
597
{
 
598
    AutoCaller autoCaller(this);
 
599
    AssertComRCReturnRC (autoCaller.rc());
 
600
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
601
 
 
602
    if (mData->mDnsProxy != aDnsProxy)
 
603
    {
 
604
        mData.backup();
 
605
        mData->mDnsProxy = aDnsProxy;
 
606
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
607
        m_fModified = true;
 
608
    }
 
609
    return S_OK;
 
610
}
 
611
STDMETHODIMP
 
612
NATEngine::COMGETTER(DnsProxy)(BOOL *aDnsProxy)
 
613
{
 
614
    AutoCaller autoCaller(this);
 
615
    AssertComRCReturnRC(autoCaller.rc());
 
616
 
 
617
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
618
    *aDnsProxy = mData->mDnsProxy;
 
619
    return S_OK;
 
620
}
 
621
STDMETHODIMP
 
622
NATEngine::COMGETTER(DnsUseHostResolver)(BOOL *aDnsUseHostResolver)
 
623
{
 
624
    AutoCaller autoCaller(this);
 
625
    AssertComRCReturnRC (autoCaller.rc());
 
626
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
627
    *aDnsUseHostResolver = mData->mDnsUseHostResolver;
 
628
    return S_OK;
 
629
}
 
630
STDMETHODIMP
 
631
NATEngine::COMSETTER(DnsUseHostResolver)(BOOL aDnsUseHostResolver)
 
632
{
 
633
    AutoCaller autoCaller(this);
 
634
    AssertComRCReturnRC(autoCaller.rc());
 
635
 
 
636
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
637
 
 
638
    if (mData->mDnsUseHostResolver != aDnsUseHostResolver)
 
639
    {
 
640
        mData.backup();
 
641
        mData->mDnsUseHostResolver = aDnsUseHostResolver;
 
642
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
643
        m_fModified = true;
 
644
    }
 
645
    return S_OK;
 
646
}
 
647
 
 
648
STDMETHODIMP NATEngine::COMSETTER(AliasMode) (ULONG aAliasMode)
 
649
{
 
650
    AutoCaller autoCaller(this);
 
651
    AssertComRCReturnRC(autoCaller.rc());
 
652
 
 
653
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
654
 
 
655
    if (mData->mAliasMode != aAliasMode)
 
656
    {
 
657
        mData.backup();
 
658
        mData->mAliasMode = aAliasMode;
 
659
        mParent->setModified(Machine::IsModified_NetworkAdapters);
 
660
        m_fModified = true;
 
661
    }
 
662
    return S_OK;
 
663
}
 
664
 
 
665
STDMETHODIMP NATEngine::COMGETTER(AliasMode) (ULONG *aAliasMode)
 
666
{
 
667
    AutoCaller autoCaller(this);
 
668
    AssertComRCReturnRC (autoCaller.rc());
 
669
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
670
    *aAliasMode = mData->mAliasMode;
 
671
    return S_OK;
 
672
}
 
673