VirtualBox

source: vbox/trunk/src/VBox/Frontends/VBoxManage/VBoxManageNATNetwork.cpp@ 77910

Last change on this file since 77910 was 76553, checked in by vboxsync, 5 years ago

scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.5 KB
Line 
1/* $Id: VBoxManageNATNetwork.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * VBoxManage - Implementation of NAT Network command command.
4 */
5
6/*
7 * Copyright (C) 2006-2019 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
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#ifndef VBOX_ONLY_DOCS
23
24#include <VBox/com/com.h>
25#include <VBox/com/array.h>
26#include <VBox/com/ErrorInfo.h>
27#include <VBox/com/errorprint.h>
28#include <VBox/com/VirtualBox.h>
29#endif /* !VBOX_ONLY_DOCS */
30
31#ifndef RT_OS_WINDOWS
32# include <netinet/in.h>
33#else
34/* from <ws2ipdef.h> */
35# define INET6_ADDRSTRLEN 65
36#endif
37
38#define IPv6
39
40#include <iprt/cdefs.h>
41#include <iprt/cidr.h>
42#include <iprt/param.h>
43#include <iprt/path.h>
44#include <iprt/stream.h>
45#include <iprt/string.h>
46#include <iprt/net.h>
47#include <iprt/getopt.h>
48#include <iprt/ctype.h>
49
50#include <VBox/log.h>
51
52#include <vector>
53#include <string>
54
55#include "VBoxManage.h"
56#include "VBoxPortForwardString.h"
57
58#ifndef VBOX_ONLY_DOCS
59
60using namespace com;
61
62typedef enum
63{
64 OP_ADD = 1000,
65 OP_REMOVE,
66 OP_MODIFY,
67 OP_START,
68 OP_STOP
69} OPCODE;
70
71typedef struct PFNAME2DELETE
72{
73 char szName[PF_NAMELEN];
74 bool fIPv6;
75} PFNAME2DELETE, *PPFNAME2DELETE;
76
77typedef std::vector<PFNAME2DELETE> VPF2DELETE;
78typedef VPF2DELETE::const_iterator VPF2DELETEITERATOR;
79
80typedef std::vector<PORTFORWARDRULE> VPF2ADD;
81typedef VPF2ADD::const_iterator VPF2ADDITERATOR;
82
83typedef std::vector<std::string> LOOPBACK2DELETEADD;
84typedef LOOPBACK2DELETEADD::iterator LOOPBACK2DELETEADDITERATOR;
85
86static HRESULT printNATNetwork(const ComPtr<INATNetwork> &pNATNet)
87{
88 HRESULT rc;
89
90 do
91 {
92 Bstr strVal;
93 CHECK_ERROR_BREAK(pNATNet, COMGETTER(NetworkName)(strVal.asOutParam()));
94 RTPrintf("Name: %ls\n", strVal.raw());
95 CHECK_ERROR_BREAK(pNATNet, COMGETTER(Network)(strVal.asOutParam()));
96 RTPrintf("Network: %ls\n", strVal.raw());
97 CHECK_ERROR_BREAK(pNATNet, COMGETTER(Gateway)(strVal.asOutParam()));
98 RTPrintf("Gateway: %ls\n", strVal.raw());
99 BOOL fVal;
100 CHECK_ERROR_BREAK(pNATNet, COMGETTER(IPv6Enabled)(&fVal));
101 RTPrintf("IPv6: %s\n", fVal ? "Yes" : "No");
102 if (fVal)
103 {
104 CHECK_ERROR_BREAK(pNATNet, COMGETTER(IPv6Prefix)(strVal.asOutParam()));
105 RTPrintf("IPv6 Prefix: %s\n", strVal.raw());
106 }
107 CHECK_ERROR_BREAK(pNATNet, COMGETTER(Enabled)(&fVal));
108 RTPrintf("Enabled: %s\n", fVal ? "Yes" : "No");
109 /** @todo Add more information here. */
110 RTPrintf("\n");
111
112 } while (0);
113
114 return rc;
115}
116
117static RTEXITCODE handleNATList(HandlerArg *a)
118{
119 HRESULT rc;
120
121 RTPrintf("NAT Networks:\n\n");
122
123 const char *pszFilter = NULL;
124 if (a->argc > 1)
125 pszFilter = a->argv[1];
126
127 size_t cFound = 0;
128
129 com::SafeIfaceArray<INATNetwork> arrNetNets;
130 CHECK_ERROR(a->virtualBox, COMGETTER(NATNetworks)(ComSafeArrayAsOutParam(arrNetNets)));
131 for (size_t i = 0; i < arrNetNets.size(); ++i)
132 {
133 ComPtr<INATNetwork> pNATNet = arrNetNets[i];
134
135 if (pszFilter)
136 {
137 Bstr strVal;
138 CHECK_ERROR_BREAK(pNATNet, COMGETTER(NetworkName)(strVal.asOutParam()));
139
140 Utf8Str strValUTF8 = Utf8Str(strVal);
141 if (!RTStrSimplePatternMatch(pszFilter, strValUTF8.c_str()))
142 continue;
143 }
144
145 if (i > 0)
146 RTPrintf("\n");
147 rc = printNATNetwork(pNATNet);
148 if (FAILED(rc))
149 break;
150
151 cFound++;
152 }
153
154 if (SUCCEEDED(rc))
155 RTPrintf("%zu %s found\n", cFound, cFound == 1 ? "network" : "networks");
156
157 return SUCCEEDED(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE;
158}
159
160static RTEXITCODE handleOp(HandlerArg *a, OPCODE enmCode)
161{
162 if (a->argc - 1 <= 1)
163 return errorSyntax(USAGE_NATNETWORK, "Not enough parameters");
164
165 const char *pNetName = NULL;
166 const char *pNetworkCidr = NULL;
167 int enable = -1;
168 int dhcp = -1;
169 int ipv6 = -1;
170
171 VPF2DELETE vPfName2Delete;
172 VPF2ADD vPf2Add;
173
174 LOOPBACK2DELETEADD vLoopback2Delete;
175 LOOPBACK2DELETEADD vLoopback2Add;
176
177 LONG loopback6Offset = 0; /* ignore me */
178
179 static const RTGETOPTDEF g_aNATNetworkIPOptions[] =
180 {
181 { "--netname", 't', RTGETOPT_REQ_STRING },
182 { "--network", 'n', RTGETOPT_REQ_STRING },
183 { "--dhcp", 'h', RTGETOPT_REQ_BOOL },
184 { "--ipv6", '6', RTGETOPT_REQ_BOOL },
185 { "--enable", 'e', RTGETOPT_REQ_NOTHING },
186 { "--disable", 'd', RTGETOPT_REQ_NOTHING },
187 { "--port-forward-4", 'p', RTGETOPT_REQ_STRING },
188 { "--port-forward-6", 'P', RTGETOPT_REQ_STRING },
189 { "--loopback-4", 'l', RTGETOPT_REQ_STRING },
190 { "--loopback-6", 'L', RTGETOPT_REQ_STRING },
191 };
192
193 int c;
194 RTGETOPTUNION ValueUnion;
195 RTGETOPTSTATE GetState;
196 RTGetOptInit(&GetState, a->argc, a->argv, g_aNATNetworkIPOptions,
197 enmCode != OP_REMOVE ? RT_ELEMENTS(g_aNATNetworkIPOptions) : 4, /* we use only --netname and --ifname for remove*/
198 1, RTGETOPTINIT_FLAGS_NO_STD_OPTS);
199 while ((c = RTGetOpt(&GetState, &ValueUnion)) != 0)
200 {
201 switch (c)
202 {
203 case 't': // --netname
204 if (pNetName)
205 return errorSyntax(USAGE_NATNETWORK, "You can only specify --netname only once.");
206 pNetName = ValueUnion.psz;
207 break;
208
209 case 'n': // --network
210 if (pNetworkCidr)
211 return errorSyntax(USAGE_NATNETWORK, "You can only specify --network only once.");
212 pNetworkCidr = ValueUnion.psz;
213 break;
214
215 case 'e': // --enable
216 if (enable >= 0)
217 return errorSyntax(USAGE_NATNETWORK, "You can specify either --enable or --disable once.");
218 enable = 1;
219 break;
220
221 case 'd': // --disable
222 if (enable >= 0)
223 return errorSyntax(USAGE_NATNETWORK, "You can specify either --enable or --disable once.");
224 enable = 0;
225 break;
226
227 case 'h':
228 if (dhcp != -1)
229 return errorSyntax(USAGE_NATNETWORK, "You can specify --dhcp only once.");
230 dhcp = ValueUnion.f;
231 break;
232
233 case '6':
234 if (ipv6 != -1)
235 return errorSyntax(USAGE_NATNETWORK, "You can specify --ipv6 only once.");
236 ipv6 = ValueUnion.f;
237 break;
238
239 case 'L': /* ipv6 loopback */
240 case 'l': /* ipv4 loopback */
241 if (RTStrCmp(ValueUnion.psz, "delete") == 0)
242 {
243 /* deletion */
244 if (enmCode != OP_MODIFY)
245 errorSyntax(USAGE_NATNETWORK,
246 "loopback couldn't be deleted on modified\n");
247 if (c == 'L')
248 loopback6Offset = -1;
249 else
250 {
251 int vrc;
252 RTGETOPTUNION Addr2Delete;
253 vrc = RTGetOptFetchValue(&GetState,
254 &Addr2Delete,
255 RTGETOPT_REQ_STRING);
256 if (RT_FAILURE(vrc))
257 return errorSyntax(USAGE_NATNETWORK,
258 "Not enough parmaters\n");
259
260 vLoopback2Delete.push_back(std::string(Addr2Delete.psz));
261 }
262 }
263 else
264 {
265 /* addition */
266 if (c == 'L')
267 loopback6Offset = ValueUnion.u32;
268 else
269 vLoopback2Add.push_back(std::string(ValueUnion.psz));
270 }
271 break;
272
273 case 'P': /* ipv6 portforwarding*/
274 case 'p': /* ipv4 portforwarding */
275 {
276 if (RTStrCmp(ValueUnion.psz, "delete") != 0)
277 {
278 /* addition */
279 /* netPfStrToPf will clean up the Pfr */
280 PORTFORWARDRULE Pfr;
281 int irc = netPfStrToPf(ValueUnion.psz, (c == 'P'), &Pfr);
282 if (RT_FAILURE(irc))
283 return errorSyntax(USAGE_NATNETWORK, "Invalid port-forward rule %s\n", ValueUnion.psz);
284
285 vPf2Add.push_back(Pfr);
286 }
287 else
288 {
289 /* deletion */
290 if (enmCode != OP_MODIFY)
291 return errorSyntax(USAGE_NATNETWORK,
292 "Port-forward could be deleted on modify \n");
293
294 RTGETOPTUNION NamePf2DeleteUnion;
295 int vrc = RTGetOptFetchValue(&GetState, &NamePf2DeleteUnion, RTGETOPT_REQ_STRING);
296 if (RT_FAILURE(vrc))
297 return errorSyntax(USAGE_NATNETWORK, "Not enough parmaters\n");
298
299 if (strlen(NamePf2DeleteUnion.psz) > PF_NAMELEN)
300 return errorSyntax(USAGE_NATNETWORK, "Port-forward rule name is too long\n");
301
302 PFNAME2DELETE Name2Delete;
303 RT_ZERO(Name2Delete);
304 RTStrCopy(Name2Delete.szName, PF_NAMELEN, NamePf2DeleteUnion.psz);
305 Name2Delete.fIPv6 = (c == 'P');
306 vPfName2Delete.push_back(Name2Delete);
307 }
308 break;
309 }
310
311 default:
312 return errorGetOpt(USAGE_NATNETWORK, c, &ValueUnion);
313 }
314 }
315
316 if (!pNetName)
317 return errorSyntax(USAGE_NATNETWORK, "You need to specify the --netname option");
318 /* verification */
319 switch (enmCode)
320 {
321 case OP_ADD:
322 if (!pNetworkCidr)
323 return errorSyntax(USAGE_NATNETWORK, "You need to specify the --network option");
324 break;
325 case OP_MODIFY:
326 case OP_REMOVE:
327 case OP_START:
328 case OP_STOP:
329 break;
330 default:
331 AssertMsgFailedReturn(("Unknown operation (:%d)", enmCode), RTEXITCODE_FAILURE);
332 }
333
334 HRESULT rc;
335 Bstr NetName;
336 NetName = Bstr(pNetName);
337
338 ComPtr<INATNetwork> net;
339 rc = a->virtualBox->FindNATNetworkByName(NetName.mutableRaw(), net.asOutParam());
340 if (enmCode == OP_ADD)
341 {
342 if (SUCCEEDED(rc))
343 return errorArgument("NATNetwork server already exists");
344
345 CHECK_ERROR(a->virtualBox, CreateNATNetwork(NetName.raw(), net.asOutParam()));
346 if (FAILED(rc))
347 return errorArgument("Failed to create the NAT network service");
348 }
349 else if (FAILED(rc))
350 return errorArgument("NATNetwork server does not exist");
351
352 switch (enmCode)
353 {
354 case OP_ADD:
355 case OP_MODIFY:
356 {
357 if (pNetworkCidr)
358 {
359 CHECK_ERROR(net, COMSETTER(Network)(Bstr(pNetworkCidr).raw()));
360 if (FAILED(rc))
361 return errorArgument("Failed to set configuration");
362 }
363 if (dhcp >= 0)
364 {
365 CHECK_ERROR(net, COMSETTER(NeedDhcpServer) ((BOOL)dhcp));
366 if (FAILED(rc))
367 return errorArgument("Failed to set configuration");
368 }
369
370 if (ipv6 >= 0)
371 {
372 CHECK_ERROR(net, COMSETTER(IPv6Enabled) ((BOOL)ipv6));
373 if (FAILED(rc))
374 return errorArgument("Failed to set configuration");
375 }
376
377 if (!vPfName2Delete.empty())
378 {
379 VPF2DELETEITERATOR it;
380 for (it = vPfName2Delete.begin(); it != vPfName2Delete.end(); ++it)
381 {
382 CHECK_ERROR(net, RemovePortForwardRule((BOOL)(*it).fIPv6,
383 Bstr((*it).szName).raw()));
384 if (FAILED(rc))
385 return errorArgument("Failed to delete pf");
386 }
387 }
388
389 if (!vPf2Add.empty())
390 {
391 VPF2ADDITERATOR it;
392 for (it = vPf2Add.begin(); it != vPf2Add.end(); ++it)
393 {
394 NATProtocol_T proto = NATProtocol_TCP;
395 if ((*it).iPfrProto == IPPROTO_TCP)
396 proto = NATProtocol_TCP;
397 else if ((*it).iPfrProto == IPPROTO_UDP)
398 proto = NATProtocol_UDP;
399 else
400 continue; /* XXX: warning here. */
401
402 CHECK_ERROR(net, AddPortForwardRule((BOOL)(*it).fPfrIPv6,
403 Bstr((*it).szPfrName).raw(),
404 proto,
405 Bstr((*it).szPfrHostAddr).raw(),
406 (*it).u16PfrHostPort,
407 Bstr((*it).szPfrGuestAddr).raw(),
408 (*it).u16PfrGuestPort));
409 if (FAILED(rc))
410 return errorArgument("Failed to add pf");
411 }
412 }
413
414 if (loopback6Offset)
415 {
416 if (loopback6Offset == -1)
417 loopback6Offset = 0; /* deletion */
418
419 CHECK_ERROR_RET(net, COMSETTER(LoopbackIp6)(loopback6Offset), RTEXITCODE_FAILURE);
420 }
421
422 /* addLocalMapping (hostid, offset) */
423 if (!vLoopback2Add.empty())
424 {
425 /* we're expecting stings 127.0.0.1=5 */
426 LOOPBACK2DELETEADDITERATOR it;
427 for (it = vLoopback2Add.begin();
428 it != vLoopback2Add.end();
429 ++it)
430 {
431 std::string address, strOffset;
432 size_t pos = it->find('=');
433 LONG lOffset = 0;
434 Bstr bstrAddress;
435
436 AssertReturn(pos != std::string::npos, errorArgument("invalid loopback string"));
437
438 address = it->substr(0, pos);
439 strOffset = it->substr(pos + 1);
440
441 lOffset = RTStrToUInt32(strOffset.c_str());
442 AssertReturn(lOffset > 0, errorArgument("invalid loopback string"));
443
444 bstrAddress = Bstr(address.c_str());
445
446 CHECK_ERROR_RET(net, AddLocalMapping(bstrAddress.raw(), lOffset), RTEXITCODE_FAILURE);
447 }
448 }
449
450 if (!vLoopback2Delete.empty())
451 {
452 /* we're expecting stings 127.0.0.1 */
453 LOOPBACK2DELETEADDITERATOR it;
454 for (it = vLoopback2Add.begin();
455 it != vLoopback2Add.end();
456 ++it)
457 {
458 Bstr bstrAddress;
459 bstrAddress = Bstr(it->c_str());
460
461 CHECK_ERROR_RET(net, AddLocalMapping(bstrAddress.raw(), 0), RTEXITCODE_FAILURE);
462 }
463 }
464
465 if (enable >= 0)
466 {
467 CHECK_ERROR(net, COMSETTER(Enabled) ((BOOL)enable));
468 if (FAILED(rc))
469 return errorArgument("Failed to set configuration");
470 }
471 break;
472 }
473 case OP_REMOVE:
474 {
475 CHECK_ERROR(a->virtualBox, RemoveNATNetwork(net));
476 if (FAILED(rc))
477 return errorArgument("Failed to remove nat network");
478 break;
479 }
480 case OP_START:
481 {
482 CHECK_ERROR(net, Start(Bstr("whatever").raw()));
483 if (FAILED(rc))
484 return errorArgument("Failed to start network");
485 break;
486 }
487 case OP_STOP:
488 {
489 CHECK_ERROR(net, Stop());
490 if (FAILED(rc))
491 return errorArgument("Failed to start network");
492 break;
493 }
494 default:;
495 }
496 return RTEXITCODE_SUCCESS;
497}
498
499
500RTEXITCODE handleNATNetwork(HandlerArg *a)
501{
502 if (a->argc < 1)
503 return errorSyntax(USAGE_NATNETWORK, "Not enough parameters");
504
505 RTEXITCODE rcExit;
506 if (strcmp(a->argv[0], "modify") == 0)
507 rcExit = handleOp(a, OP_MODIFY);
508 else if (strcmp(a->argv[0], "add") == 0)
509 rcExit = handleOp(a, OP_ADD);
510 else if (strcmp(a->argv[0], "remove") == 0)
511 rcExit = handleOp(a, OP_REMOVE);
512 else if (strcmp(a->argv[0], "start") == 0)
513 rcExit = handleOp(a, OP_START);
514 else if (strcmp(a->argv[0], "stop") == 0)
515 rcExit = handleOp(a, OP_STOP);
516 else if (strcmp(a->argv[0], "list") == 0)
517 rcExit = handleNATList(a);
518 else
519 rcExit = errorSyntax(USAGE_NATNETWORK, "Invalid parameter '%s'", Utf8Str(a->argv[0]).c_str());
520 return rcExit;
521}
522
523#endif /* !VBOX_ONLY_DOCS */
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use