VirtualBox

source: vbox/trunk/src/VBox/Main/NATEngineImpl.cpp@ 33866

Last change on this file since 33866 was 33866, checked in by vboxsync, 14 years ago

Main: don't register with the same name or with the same pair (hostip:hostport).
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.3 KB
Line 
1/* $Id: NATEngineImpl.cpp 33866 2010-11-08 17:53:25Z 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
34NATEngine::NATEngine():mParent(NULL), mAdapter(NULL){}
35NATEngine::~NATEngine(){}
36
37HRESULT NATEngine::FinalConstruct()
38{
39 return S_OK;
40}
41
42HRESULT 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
56HRESULT 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
81HRESULT 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
107void NATEngine::FinalRelease()
108{
109 uninit();
110}
111
112void 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
124bool NATEngine::isModified()
125{
126 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
127 bool fModified = m_fModified;
128 return fModified;
129}
130
131bool 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
149void 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
178STDMETHODIMP
179NATEngine::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
199STDMETHODIMP
200NATEngine::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
228STDMETHODIMP
229NATEngine::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
260STDMETHODIMP
261NATEngine::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 || ( r.strHostIP == Utf8Str(aBindIp)
291 && r.u16HostPort == aHostPort))
292 {
293 return E_INVALIDARG;
294 }
295 }
296
297 r.strName = name.c_str();
298 r.proto = aProto;
299 r.strHostIP = aBindIp;
300 r.u16HostPort = aHostPort;
301 r.strGuestIP = aGuestIP;
302 r.u16GuestPort = aGuestPort;
303 mNATRules.insert(std::make_pair(name, r));
304 mParent->setModified(Machine::IsModified_NetworkAdapters);
305 m_fModified = true;
306 alock.release();
307 mParent->onNATRedirectRuleChange(mAdapter, FALSE, Bstr(name).raw(), aProto, Bstr(r.strHostIP).raw(), r.u16HostPort, Bstr(r.strGuestIP).raw(), r.u16GuestPort);
308 return S_OK;
309}
310
311STDMETHODIMP
312NATEngine::RemoveRedirect(IN_BSTR aName)
313{
314 AutoCaller autoCaller(this);
315 if (FAILED(autoCaller.rc())) return autoCaller.rc();
316
317 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
318 NATRuleMap::iterator it = mNATRules.find(aName);
319 if (it == mNATRules.end())
320 return E_INVALIDARG;
321 mData.backup();
322 settings::NATRule r = it->second;
323 Utf8Str strHostIP = r.strHostIP;
324 Utf8Str strGuestIP = r.strGuestIP;
325 NATProtocol_T proto = r.proto;
326 uint16_t u16HostPort = r.u16HostPort;
327 uint16_t u16GuestPort = r.u16GuestPort;
328
329 mNATRules.erase(it);
330 mParent->setModified(Machine::IsModified_NetworkAdapters);
331 m_fModified = true;
332 alock.release();
333 mParent->onNATRedirectRuleChange(mAdapter, TRUE, aName, proto, Bstr(strHostIP).raw(), u16HostPort, Bstr(strGuestIP).raw(), u16GuestPort);
334 return S_OK;
335}
336
337HRESULT NATEngine::loadSettings(const settings::NAT &data)
338{
339 AutoCaller autoCaller(this);
340 AssertComRCReturnRC(autoCaller.rc());
341
342 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
343 HRESULT rc = S_OK;
344 mData->mNetwork = data.strNetwork;
345 mData->mBindIP = data.strBindIP;
346 mData->mMtu = data.u32Mtu;
347 mData->mSockSnd = data.u32SockSnd;
348 mData->mTcpRcv = data.u32TcpRcv;
349 mData->mTcpSnd = data.u32TcpSnd;
350 /* TFTP */
351 mData->mTftpPrefix = data.strTftpPrefix;
352 mData->mTftpBootFile = data.strTftpBootFile;
353 mData->mTftpNextServer = data.strTftpNextServer;
354 /* DNS */
355 mData->mDnsPassDomain = data.fDnsPassDomain;
356 mData->mDnsProxy = data.fDnsProxy;
357 mData->mDnsUseHostResolver = data.fDnsUseHostResolver;
358 /* Alias */
359 mData->mAliasMode = (data.fAliasUseSamePorts ? NATAliasMode_AliasUseSamePorts : 0);
360 mData->mAliasMode |= (data.fAliasLog ? NATAliasMode_AliasLog : 0);
361 mData->mAliasMode |= (data.fAliasProxyOnly ? NATAliasMode_AliasProxyOnly : 0);
362 /* port forwarding */
363 mNATRules.clear();
364 for (settings::NATRuleList::const_iterator it = data.llRules.begin();
365 it != data.llRules.end(); ++it)
366 {
367 mNATRules.insert(std::make_pair(it->strName, *it));
368 }
369 m_fModified = false;
370 return rc;
371}
372
373
374HRESULT NATEngine::saveSettings(settings::NAT &data)
375{
376 AutoCaller autoCaller(this);
377 AssertComRCReturnRC(autoCaller.rc());
378
379 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
380 HRESULT rc = S_OK;
381 data.strNetwork = mData->mNetwork;
382 data.strBindIP = mData->mBindIP;
383 data.u32Mtu = mData->mMtu;
384 data.u32SockRcv = mData->mSockRcv;
385 data.u32SockSnd = mData->mSockSnd;
386 data.u32TcpRcv = mData->mTcpRcv;
387 data.u32TcpSnd = mData->mTcpSnd;
388 /* TFTP */
389 data.strTftpPrefix = mData->mTftpPrefix;
390 data.strTftpBootFile = mData->mTftpBootFile;
391 data.strTftpNextServer = mData->mTftpNextServer;
392 /* DNS */
393 data.fDnsPassDomain = !!mData->mDnsPassDomain;
394 data.fDnsProxy = !!mData->mDnsProxy;
395 data.fDnsUseHostResolver = !!mData->mDnsUseHostResolver;
396 /* Alias */
397 data.fAliasLog = !!(mData->mAliasMode & NATAliasMode_AliasLog);
398 data.fAliasProxyOnly = !!(mData->mAliasMode & NATAliasMode_AliasProxyOnly);
399 data.fAliasUseSamePorts = !!(mData->mAliasMode & NATAliasMode_AliasUseSamePorts);
400
401 for (NATRuleMap::iterator it = mNATRules.begin();
402 it != mNATRules.end(); ++it)
403 data.llRules.push_back(it->second);
404 m_fModified = false;
405 return rc;
406}
407
408
409STDMETHODIMP
410NATEngine::COMSETTER(Network)(IN_BSTR aNetwork)
411{
412 AutoCaller autoCaller(this);
413 AssertComRCReturnRC (autoCaller.rc());
414 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
415 if (Bstr(mData->mNetwork) != aNetwork)
416 {
417 mData.backup();
418 mData->mNetwork = aNetwork;
419 mParent->setModified(Machine::IsModified_NetworkAdapters);
420 m_fModified = true;
421 }
422 return S_OK;
423}
424
425STDMETHODIMP
426NATEngine::COMGETTER(Network)(BSTR *aNetwork)
427{
428 CheckComArgNotNull(aNetwork);
429 AutoCaller autoCaller(this);
430 AssertComRCReturnRC(autoCaller.rc());
431
432 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
433 if (!mData->mNetwork.isEmpty())
434 {
435 mData->mNetwork.cloneTo(aNetwork);
436 Log(("Getter (this:%p) Network: %s\n", this, mData->mNetwork.c_str()));
437 }
438 return S_OK;
439}
440
441STDMETHODIMP
442NATEngine::COMSETTER(HostIP) (IN_BSTR aBindIP)
443{
444 AutoCaller autoCaller(this);
445 AssertComRCReturnRC (autoCaller.rc());
446 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
447 if (Bstr(mData->mBindIP) != aBindIP)
448 {
449 mData.backup();
450 mData->mBindIP = aBindIP;
451 mParent->setModified(Machine::IsModified_NetworkAdapters);
452 m_fModified = true;
453 }
454 return S_OK;
455}
456STDMETHODIMP NATEngine::COMGETTER(HostIP) (BSTR *aBindIP)
457{
458 AutoCaller autoCaller(this);
459 AssertComRCReturnRC(autoCaller.rc());
460
461 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
462 if (!mData->mBindIP.isEmpty())
463 mData->mBindIP.cloneTo(aBindIP);
464 return S_OK;
465}
466
467
468STDMETHODIMP
469NATEngine::COMSETTER(TftpPrefix)(IN_BSTR aTftpPrefix)
470{
471 AutoCaller autoCaller(this);
472 AssertComRCReturnRC (autoCaller.rc());
473 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
474 if (Bstr(mData->mTftpPrefix) != aTftpPrefix)
475 {
476 mData.backup();
477 mData->mTftpPrefix = aTftpPrefix;
478 mParent->setModified(Machine::IsModified_NetworkAdapters);
479 m_fModified = true;
480 }
481 return S_OK;
482}
483
484STDMETHODIMP
485NATEngine::COMGETTER(TftpPrefix)(BSTR *aTftpPrefix)
486{
487 AutoCaller autoCaller(this);
488 AssertComRCReturnRC(autoCaller.rc());
489
490 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
491 if (!mData->mTftpPrefix.isEmpty())
492 {
493 mData->mTftpPrefix.cloneTo(aTftpPrefix);
494 Log(("Getter (this:%p) TftpPrefix: %s\n", this, mData->mTftpPrefix.c_str()));
495 }
496 return S_OK;
497}
498
499STDMETHODIMP
500NATEngine::COMSETTER(TftpBootFile)(IN_BSTR aTftpBootFile)
501{
502 AutoCaller autoCaller(this);
503 AssertComRCReturnRC (autoCaller.rc());
504 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
505 if (Bstr(mData->mTftpBootFile) != aTftpBootFile)
506 {
507 mData.backup();
508 mData->mTftpBootFile = aTftpBootFile;
509 mParent->setModified(Machine::IsModified_NetworkAdapters);
510 m_fModified = true;
511 }
512 return S_OK;
513}
514
515STDMETHODIMP
516NATEngine::COMGETTER(TftpBootFile)(BSTR *aTftpBootFile)
517{
518 AutoCaller autoCaller(this);
519 AssertComRCReturnRC(autoCaller.rc());
520
521 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
522 if (!mData->mTftpBootFile.isEmpty())
523 {
524 mData->mTftpBootFile.cloneTo(aTftpBootFile);
525 Log(("Getter (this:%p) BootFile: %s\n", this, mData->mTftpBootFile.c_str()));
526 }
527 return S_OK;
528}
529
530STDMETHODIMP
531NATEngine::COMSETTER(TftpNextServer)(IN_BSTR aTftpNextServer)
532{
533 AutoCaller autoCaller(this);
534 AssertComRCReturnRC (autoCaller.rc());
535 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
536 if (Bstr(mData->mTftpNextServer) != aTftpNextServer)
537 {
538 mData.backup();
539 mData->mTftpNextServer = aTftpNextServer;
540 mParent->setModified(Machine::IsModified_NetworkAdapters);
541 m_fModified = true;
542 }
543 return S_OK;
544}
545
546STDMETHODIMP
547NATEngine::COMGETTER(TftpNextServer)(BSTR *aTftpNextServer)
548{
549 AutoCaller autoCaller(this);
550 AssertComRCReturnRC(autoCaller.rc());
551
552 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
553 if (!mData->mTftpNextServer.isEmpty())
554 {
555 mData->mTftpNextServer.cloneTo(aTftpNextServer);
556 Log(("Getter (this:%p) NextServer: %s\n", this, mData->mTftpNextServer.c_str()));
557 }
558 return S_OK;
559}
560/* DNS */
561STDMETHODIMP
562NATEngine::COMSETTER(DnsPassDomain) (BOOL aDnsPassDomain)
563{
564 AutoCaller autoCaller(this);
565 AssertComRCReturnRC (autoCaller.rc());
566 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
567
568 if (mData->mDnsPassDomain != aDnsPassDomain)
569 {
570 mData.backup();
571 mData->mDnsPassDomain = aDnsPassDomain;
572 mParent->setModified(Machine::IsModified_NetworkAdapters);
573 m_fModified = true;
574 }
575 return S_OK;
576}
577STDMETHODIMP
578NATEngine::COMGETTER(DnsPassDomain)(BOOL *aDnsPassDomain)
579{
580 AutoCaller autoCaller(this);
581 AssertComRCReturnRC(autoCaller.rc());
582
583 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
584 *aDnsPassDomain = mData->mDnsPassDomain;
585 return S_OK;
586}
587STDMETHODIMP
588NATEngine::COMSETTER(DnsProxy)(BOOL aDnsProxy)
589{
590 AutoCaller autoCaller(this);
591 AssertComRCReturnRC (autoCaller.rc());
592 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
593
594 if (mData->mDnsProxy != aDnsProxy)
595 {
596 mData.backup();
597 mData->mDnsProxy = aDnsProxy;
598 mParent->setModified(Machine::IsModified_NetworkAdapters);
599 m_fModified = true;
600 }
601 return S_OK;
602}
603STDMETHODIMP
604NATEngine::COMGETTER(DnsProxy)(BOOL *aDnsProxy)
605{
606 AutoCaller autoCaller(this);
607 AssertComRCReturnRC(autoCaller.rc());
608
609 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
610 *aDnsProxy = mData->mDnsProxy;
611 return S_OK;
612}
613STDMETHODIMP
614NATEngine::COMGETTER(DnsUseHostResolver)(BOOL *aDnsUseHostResolver)
615{
616 AutoCaller autoCaller(this);
617 AssertComRCReturnRC (autoCaller.rc());
618 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
619 *aDnsUseHostResolver = mData->mDnsUseHostResolver;
620 return S_OK;
621}
622STDMETHODIMP
623NATEngine::COMSETTER(DnsUseHostResolver)(BOOL aDnsUseHostResolver)
624{
625 AutoCaller autoCaller(this);
626 AssertComRCReturnRC(autoCaller.rc());
627
628 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
629
630 if (mData->mDnsUseHostResolver != aDnsUseHostResolver)
631 {
632 mData.backup();
633 mData->mDnsUseHostResolver = aDnsUseHostResolver;
634 mParent->setModified(Machine::IsModified_NetworkAdapters);
635 m_fModified = true;
636 }
637 return S_OK;
638}
639
640STDMETHODIMP NATEngine::COMSETTER(AliasMode) (ULONG aAliasMode)
641{
642 AutoCaller autoCaller(this);
643 AssertComRCReturnRC(autoCaller.rc());
644
645 AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
646
647 if (mData->mAliasMode != aAliasMode)
648 {
649 mData.backup();
650 mData->mAliasMode = aAliasMode;
651 mParent->setModified(Machine::IsModified_NetworkAdapters);
652 m_fModified = true;
653 }
654 return S_OK;
655}
656
657STDMETHODIMP NATEngine::COMGETTER(AliasMode) (ULONG *aAliasMode)
658{
659 AutoCaller autoCaller(this);
660 AssertComRCReturnRC (autoCaller.rc());
661 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
662 *aAliasMode = mData->mAliasMode;
663 return S_OK;
664}
665
Note: See TracBrowser for help on using the repository browser.

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