1 | /* $Id: DrvVMNet.m 106061 2024-09-16 14:03:52Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * DrvVMNet - Network filter driver that uses MAC OS VMNET API.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2021-2024 Oracle and/or its affiliates.
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox base platform packages, as
|
---|
10 | * available from https://www.virtualbox.org.
|
---|
11 | *
|
---|
12 | * This program is free software; you can redistribute it and/or
|
---|
13 | * modify it under the terms of the GNU General Public License
|
---|
14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
15 | * License.
|
---|
16 | *
|
---|
17 | * This program is distributed in the hope that it will be useful, but
|
---|
18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
20 | * General Public License for more details.
|
---|
21 | *
|
---|
22 | * You should have received a copy of the GNU General Public License
|
---|
23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
24 | *
|
---|
25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
26 | */
|
---|
27 |
|
---|
28 |
|
---|
29 | /*********************************************************************************************************************************
|
---|
30 | * Header Files *
|
---|
31 | *********************************************************************************************************************************/
|
---|
32 | #define LOG_GROUP LOG_GROUP_DRV_VMNET
|
---|
33 | #include <VBox/vmm/pdmdrv.h>
|
---|
34 | #include <VBox/vmm/pdmnetifs.h>
|
---|
35 | #include <VBox/vmm/pdmnetinline.h>
|
---|
36 | #include <VBox/intnet.h>
|
---|
37 |
|
---|
38 | #include <VBox/log.h>
|
---|
39 | #include <iprt/assert.h>
|
---|
40 | #include <iprt/critsect.h>
|
---|
41 | #include <iprt/file.h>
|
---|
42 | #include <iprt/mem.h>
|
---|
43 | #include <iprt/process.h>
|
---|
44 | #include <iprt/string.h>
|
---|
45 | #include <iprt/time.h>
|
---|
46 | #include <iprt/uuid.h>
|
---|
47 | #include <iprt/path.h>
|
---|
48 | #include <VBox/param.h>
|
---|
49 |
|
---|
50 | #include "Pcap.h"
|
---|
51 | #include "VBoxDD.h"
|
---|
52 |
|
---|
53 | #include <sys/uio.h>
|
---|
54 | #import <vmnet/vmnet.h>
|
---|
55 |
|
---|
56 | #define VMNET_MAX_HOST_INTERFACE_NAME_LENGTH 16
|
---|
57 | #define VMNET_MAX_IP_ADDRESS_STRING_LENGTH 48
|
---|
58 |
|
---|
59 | /* Force release logging for debug builds */
|
---|
60 | #if 0
|
---|
61 | # undef Log
|
---|
62 | # undef LogFlow
|
---|
63 | # undef Log2
|
---|
64 | # undef Log3
|
---|
65 | # define Log LogRel
|
---|
66 | # define LogFlow LogRel
|
---|
67 | # define Log2 LogRel
|
---|
68 | # define Log3 LogRel
|
---|
69 | #endif
|
---|
70 |
|
---|
71 |
|
---|
72 | /*********************************************************************************************************************************
|
---|
73 | * Structures and Typedefs *
|
---|
74 | *********************************************************************************************************************************/
|
---|
75 | /**
|
---|
76 | * VMNET driver states.
|
---|
77 | */
|
---|
78 | typedef enum VMNETSTATE
|
---|
79 | {
|
---|
80 | /** The driver is suspended. */
|
---|
81 | VMNETSTATE_SUSPENDED = 1,
|
---|
82 | /** The driver is running. */
|
---|
83 | VMNETSTATE_RUNNING,
|
---|
84 | /** The usual 32-bit type blowup. */
|
---|
85 | VMNETSTATE_32BIT_HACK = 0x7fffffff
|
---|
86 | } VMNETSTATE;
|
---|
87 |
|
---|
88 | /**
|
---|
89 | * VMNET driver instance data.
|
---|
90 | *
|
---|
91 | * @implements PDMINETWORKUP
|
---|
92 | * @implements PDMINETWORKCONFIG
|
---|
93 | */
|
---|
94 | typedef struct DRVVMNET
|
---|
95 | {
|
---|
96 | /** The network interface. */
|
---|
97 | PDMINETWORKUP INetworkUp;
|
---|
98 | /** The port we're attached to. */
|
---|
99 | PPDMINETWORKDOWN pIAboveNet;
|
---|
100 | /** The config port interface we're attached to. */
|
---|
101 | PPDMINETWORKCONFIG pIAboveConfig;
|
---|
102 | /** Pointer to the driver instance. */
|
---|
103 | PPDMDRVINS pDrvIns;
|
---|
104 | /** For when we're the leaf driver. */
|
---|
105 | RTCRITSECT XmitLock;
|
---|
106 | /** VMNET interface queue handle. */
|
---|
107 | dispatch_queue_t InterfaceQueue;
|
---|
108 | /** VMNET interface handle. */
|
---|
109 | interface_ref Interface;
|
---|
110 | /** The unique id for this network. */
|
---|
111 | uuid_t uuid;
|
---|
112 | /** The operation mode: bridged or host. */
|
---|
113 | uint32_t uMode;
|
---|
114 | /** The operational state: suspended or running. */
|
---|
115 | VMNETSTATE volatile enmState;
|
---|
116 | /** The host interface name for bridge mode. */
|
---|
117 | char szHostInterface[VMNET_MAX_HOST_INTERFACE_NAME_LENGTH];
|
---|
118 | /** The network mask for host mode. */
|
---|
119 | char szNetworkMask[VMNET_MAX_IP_ADDRESS_STRING_LENGTH];
|
---|
120 | /** The lower IP address of DHCP range for host mode. */
|
---|
121 | char szLowerIP[VMNET_MAX_IP_ADDRESS_STRING_LENGTH];
|
---|
122 | /** The upper IP address of DHCP range for host mode. */
|
---|
123 | char szUpperIP[VMNET_MAX_IP_ADDRESS_STRING_LENGTH];
|
---|
124 | } DRVVMNET, *PDRVVMNET;
|
---|
125 |
|
---|
126 |
|
---|
127 |
|
---|
128 | /**
|
---|
129 | * @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
|
---|
130 | */
|
---|
131 | static DECLCALLBACK(int) drvVMNetUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
|
---|
132 | {
|
---|
133 | RT_NOREF(fOnWorkerThread);
|
---|
134 | PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
|
---|
135 | LogFlow(("drvVMNetUp_BeginXmit:\n"));
|
---|
136 | int rc = RTCritSectTryEnter(&pThis->XmitLock);
|
---|
137 | if (RT_UNLIKELY(rc == VERR_SEM_BUSY))
|
---|
138 | rc = VERR_TRY_AGAIN;
|
---|
139 | return rc;
|
---|
140 | }
|
---|
141 |
|
---|
142 |
|
---|
143 | /**
|
---|
144 | * @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
|
---|
145 | */
|
---|
146 | static DECLCALLBACK(int) drvVMNetUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
|
---|
147 | PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
|
---|
148 | {
|
---|
149 | RT_NOREF(pInterface);
|
---|
150 | //PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
|
---|
151 | LogFlow(("drvVMNetUp_AllocBuf: cb=%llu%s\n", cbMin, pGso == NULL ? "" : " GSO"));
|
---|
152 | /*
|
---|
153 | * Allocate a scatter / gather buffer descriptor that is immediately
|
---|
154 | * followed by the buffer space of its single segment. The GSO context
|
---|
155 | * comes after that again.
|
---|
156 | */
|
---|
157 | PPDMSCATTERGATHER pSgBuf = (PPDMSCATTERGATHER)RTMemAlloc( RT_ALIGN_Z(sizeof(*pSgBuf), 16)
|
---|
158 | + RT_ALIGN_Z(cbMin, 16)
|
---|
159 | + (pGso ? RT_ALIGN_Z(sizeof(*pGso), 16) : 0));
|
---|
160 | if (!pSgBuf)
|
---|
161 | return VERR_NO_MEMORY;
|
---|
162 |
|
---|
163 | /*
|
---|
164 | * Initialize the S/G buffer and return.
|
---|
165 | */
|
---|
166 | pSgBuf->fFlags = PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1;
|
---|
167 | pSgBuf->cbUsed = 0;
|
---|
168 | pSgBuf->cbAvailable = RT_ALIGN_Z(cbMin, 16);
|
---|
169 | pSgBuf->pvAllocator = NULL;
|
---|
170 | if (!pGso)
|
---|
171 | pSgBuf->pvUser = NULL;
|
---|
172 | else
|
---|
173 | {
|
---|
174 | pSgBuf->pvUser = (uint8_t *)(pSgBuf + 1) + pSgBuf->cbAvailable;
|
---|
175 | *(PPDMNETWORKGSO)pSgBuf->pvUser = *pGso;
|
---|
176 | }
|
---|
177 | pSgBuf->cSegs = 1;
|
---|
178 | pSgBuf->aSegs[0].cbSeg = pSgBuf->cbAvailable;
|
---|
179 | pSgBuf->aSegs[0].pvSeg = pSgBuf + 1;
|
---|
180 |
|
---|
181 | LogFlow(("drvVMNetUp_AllocBuf: successful %p\n", pSgBuf));
|
---|
182 | *ppSgBuf = pSgBuf;
|
---|
183 | return VINF_SUCCESS;
|
---|
184 | }
|
---|
185 |
|
---|
186 |
|
---|
187 | /**
|
---|
188 | * @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
|
---|
189 | */
|
---|
190 | static DECLCALLBACK(int) drvVMNetUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
|
---|
191 | {
|
---|
192 | PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
|
---|
193 | LogFlow(("drvVMNetUp_FreeBuf: %p\n", pSgBuf));
|
---|
194 | Assert(RTCritSectIsOwner(&pThis->XmitLock));
|
---|
195 | RT_NOREF(pThis);
|
---|
196 | if (pSgBuf)
|
---|
197 | {
|
---|
198 | Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
|
---|
199 | pSgBuf->fFlags = 0;
|
---|
200 | RTMemFree(pSgBuf);
|
---|
201 | }
|
---|
202 | return VINF_SUCCESS;
|
---|
203 | }
|
---|
204 |
|
---|
205 |
|
---|
206 | static int drvVMNetReceive(PDRVVMNET pThis, const uint8_t *pbFrame, uint32_t cbFrame)
|
---|
207 | {
|
---|
208 | if (pThis->enmState != VMNETSTATE_RUNNING)
|
---|
209 | {
|
---|
210 | Log(("drvVMNetReceive: Ignoring incoming packet (%d bytes) in suspended state\n", cbFrame));
|
---|
211 | return VINF_SUCCESS;
|
---|
212 | }
|
---|
213 |
|
---|
214 | Log(("drvVMNetReceive: Incoming packet: %RTmac <= %RTmac (%d bytes)\n", pbFrame, pbFrame + 6, cbFrame));
|
---|
215 | Log2(("%.*Rhxd\n", cbFrame, pbFrame));
|
---|
216 | if (pThis->pIAboveNet && pThis->pIAboveNet->pfnReceive)
|
---|
217 | return pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, pbFrame, cbFrame);
|
---|
218 | return VERR_TRY_AGAIN;
|
---|
219 | }
|
---|
220 |
|
---|
221 |
|
---|
222 | static int drvVMNetSend(PDRVVMNET pThis, const uint8_t *pbFrame, uint32_t cbFrame)
|
---|
223 | {
|
---|
224 | if (pThis->enmState != VMNETSTATE_RUNNING)
|
---|
225 | {
|
---|
226 | Log(("drvVMNetReceive: Ignoring outgoing packet (%d bytes) in suspended state\n", cbFrame));
|
---|
227 | return VINF_SUCCESS;
|
---|
228 | }
|
---|
229 |
|
---|
230 | Log(("drvVMNetSend: Outgoing packet (%d bytes)\n", cbFrame));
|
---|
231 | Log2(("%.*Rhxd\n", cbFrame, pbFrame));
|
---|
232 |
|
---|
233 | struct iovec io;
|
---|
234 | struct vmpktdesc packets;
|
---|
235 | int packet_count = 1;
|
---|
236 |
|
---|
237 | io.iov_base = (void*)pbFrame;
|
---|
238 | io.iov_len = cbFrame;
|
---|
239 | packets.vm_pkt_size = cbFrame;
|
---|
240 | packets.vm_pkt_iov = &io;
|
---|
241 | packets.vm_pkt_iovcnt = 1;
|
---|
242 | packets.vm_flags = 0;
|
---|
243 |
|
---|
244 | vmnet_return_t rc = vmnet_write(pThis->Interface, &packets, &packet_count);
|
---|
245 | if (rc != VMNET_SUCCESS)
|
---|
246 | Log(("drvVMNetSend: Failed to send a packet with error code %d\n", rc));
|
---|
247 | return (rc == VMNET_SUCCESS) ? VINF_SUCCESS : VERR_GENERAL_FAILURE;
|
---|
248 | }
|
---|
249 |
|
---|
250 | /**
|
---|
251 | * @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
|
---|
252 | */
|
---|
253 | static DECLCALLBACK(int) drvVMNetUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
|
---|
254 | {
|
---|
255 | RT_NOREF(fOnWorkerThread);
|
---|
256 | PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
|
---|
257 |
|
---|
258 | LogFlow(("drvVMNetUp_SendBuf: %p\n", pSgBuf));
|
---|
259 | Assert(RTCritSectIsOwner(&pThis->XmitLock));
|
---|
260 |
|
---|
261 | int rc;
|
---|
262 | if (!pSgBuf->pvUser)
|
---|
263 | {
|
---|
264 | rc = drvVMNetSend(pThis, pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed);
|
---|
265 | }
|
---|
266 | else
|
---|
267 | {
|
---|
268 | uint8_t abHdrScratch[256];
|
---|
269 | uint8_t const *pbFrame = (uint8_t const *)pSgBuf->aSegs[0].pvSeg;
|
---|
270 | PCPDMNETWORKGSO pGso = (PCPDMNETWORKGSO)pSgBuf->pvUser;
|
---|
271 | uint32_t const cSegs = PDMNetGsoCalcSegmentCount(pGso, pSgBuf->cbUsed); Assert(cSegs > 1);
|
---|
272 | rc = VINF_SUCCESS;
|
---|
273 | for (uint32_t iSeg = 0; iSeg < cSegs && RT_SUCCESS(rc); iSeg++)
|
---|
274 | {
|
---|
275 | uint32_t cbSegFrame;
|
---|
276 | void *pvSegFrame = PDMNetGsoCarveSegmentQD(pGso, (uint8_t *)pbFrame, pSgBuf->cbUsed, abHdrScratch,
|
---|
277 | iSeg, cSegs, &cbSegFrame);
|
---|
278 | rc = drvVMNetSend(pThis, pvSegFrame, cbSegFrame);
|
---|
279 | }
|
---|
280 | }
|
---|
281 |
|
---|
282 | LogFlow(("drvVMNetUp_SendBuf: free %p\n", pSgBuf));
|
---|
283 | pSgBuf->fFlags = 0;
|
---|
284 | RTMemFree(pSgBuf);
|
---|
285 | return rc;
|
---|
286 | }
|
---|
287 |
|
---|
288 |
|
---|
289 | /**
|
---|
290 | * @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
|
---|
291 | */
|
---|
292 | static DECLCALLBACK(void) drvVMNetUp_EndXmit(PPDMINETWORKUP pInterface)
|
---|
293 | {
|
---|
294 | LogFlow(("drvVMNetUp_EndXmit:\n"));
|
---|
295 | PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
|
---|
296 | RTCritSectLeave(&pThis->XmitLock);
|
---|
297 | }
|
---|
298 |
|
---|
299 |
|
---|
300 | /**
|
---|
301 | * @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
|
---|
302 | */
|
---|
303 | static DECLCALLBACK(void) drvVMNetUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
|
---|
304 | {
|
---|
305 | RT_NOREF(pInterface, fPromiscuous);
|
---|
306 | LogFlow(("drvVMNetUp_SetPromiscuousMode: fPromiscuous=%d\n", fPromiscuous));
|
---|
307 | // PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
|
---|
308 | }
|
---|
309 |
|
---|
310 |
|
---|
311 | /**
|
---|
312 | * @interface_method_impl{PDMINETWORKUP,pfnNotifyLinkChanged}
|
---|
313 | */
|
---|
314 | static DECLCALLBACK(void) drvVMNetUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
|
---|
315 | {
|
---|
316 | RT_NOREF(pInterface, enmLinkState);
|
---|
317 | LogFlow(("drvVMNetUp_NotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
|
---|
318 | // PDRVVMNET pThis = RT_FROM_MEMBER(pInterface, DRVVMNET, INetworkUp);
|
---|
319 | }
|
---|
320 |
|
---|
321 |
|
---|
322 | /**
|
---|
323 | * @interface_method_impl{PDMIBASE,pfnQueryInterface}
|
---|
324 | */
|
---|
325 | static DECLCALLBACK(void *) drvVMNetQueryInterface(PPDMIBASE pInterface, const char *pszIID)
|
---|
326 | {
|
---|
327 | PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
|
---|
328 | PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
|
---|
329 | PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
|
---|
330 | PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUp);
|
---|
331 | //PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKVMNETCONFIG, &pThis->INetworkVmnetConfig);
|
---|
332 | return NULL;
|
---|
333 | }
|
---|
334 |
|
---|
335 |
|
---|
336 | static vmnet_return_t drvVMNetAttach(PDRVVMNET pThis)
|
---|
337 | {
|
---|
338 | xpc_object_t interface_desc;
|
---|
339 | dispatch_semaphore_t operation_done;
|
---|
340 | __block vmnet_return_t vmnet_status = VMNET_FAILURE;
|
---|
341 | __block size_t max_packet_size = 0;
|
---|
342 | //__block RTMAC MacAddress;
|
---|
343 |
|
---|
344 | pThis->InterfaceQueue = dispatch_queue_create("VMNET", DISPATCH_QUEUE_SERIAL);
|
---|
345 | operation_done = dispatch_semaphore_create(0);
|
---|
346 | interface_desc = xpc_dictionary_create(NULL, NULL, 0);
|
---|
347 | xpc_dictionary_set_uuid(interface_desc, vmnet_interface_id_key, pThis->uuid);
|
---|
348 | xpc_dictionary_set_bool(interface_desc, vmnet_allocate_mac_address_key, false);
|
---|
349 | xpc_dictionary_set_uint64(interface_desc, vmnet_operation_mode_key, pThis->uMode);
|
---|
350 | if (pThis->uMode == VMNET_BRIDGED_MODE)
|
---|
351 | {
|
---|
352 | LogFlow(("drvVMNetAttach: mode=briged hostInterface='%s'\n", pThis->szHostInterface));
|
---|
353 | xpc_dictionary_set_string(interface_desc, vmnet_shared_interface_name_key, pThis->szHostInterface);
|
---|
354 | }
|
---|
355 | else
|
---|
356 | {
|
---|
357 | #ifdef LOG_ENABLED
|
---|
358 | char szUUID[40];
|
---|
359 | uuid_unparse(pThis->uuid, szUUID);
|
---|
360 | LogFlow(("drvVMNetAttach: mode=host id='%s' netmask='%s' start='%s' end='%s'\n", szUUID, pThis->szNetworkMask, pThis->szLowerIP, pThis->szUpperIP));
|
---|
361 | #endif
|
---|
362 | xpc_dictionary_set_string(interface_desc, vmnet_subnet_mask_key, pThis->szNetworkMask);
|
---|
363 | xpc_dictionary_set_string(interface_desc, vmnet_start_address_key, pThis->szLowerIP);
|
---|
364 | xpc_dictionary_set_string(interface_desc, vmnet_end_address_key, pThis->szUpperIP);
|
---|
365 | }
|
---|
366 | pThis->Interface = vmnet_start_interface(interface_desc, pThis->InterfaceQueue,
|
---|
367 | ^(vmnet_return_t status, xpc_object_t interface_param)
|
---|
368 | {
|
---|
369 | // Log(("Callback reached!\n"));
|
---|
370 | vmnet_status = status;
|
---|
371 | if (status != VMNET_SUCCESS)
|
---|
372 | Log(("Failed to start VMNET interface. Status = %d.\n", status));
|
---|
373 | else if (interface_param == NULL)
|
---|
374 | Log(("No interface parameters provided!\n"));
|
---|
375 | else
|
---|
376 | {
|
---|
377 | Log(("VMNET interface has been started. Status = %d.\n", status));
|
---|
378 | #if 0
|
---|
379 | const char *pcszMacAddress = xpc_dictionary_get_string(interface_param, vmnet_mac_address_key);
|
---|
380 | int rc = VERR_NOT_FOUND;
|
---|
381 | if (pcszMacAddress)
|
---|
382 | rc = RTNetStrToMacAddr(pcszMacAddress, &pThis->MacAddress);
|
---|
383 | if (RT_FAILURE(rc))
|
---|
384 | Log(("drvVMNetAttachBridged: Failed to convert '%s' to MAC address (%Rrc)\n", pcszMacAddress ? pcszMacAddress : "(null)", rc));
|
---|
385 | #endif
|
---|
386 | max_packet_size = xpc_dictionary_get_uint64(interface_param, vmnet_max_packet_size_key);
|
---|
387 | if (max_packet_size == 0)
|
---|
388 | {
|
---|
389 | max_packet_size = 1518;
|
---|
390 | LogRel(("VMNet: Failed to retrieve max packet size, assuming %d bytes.\n", max_packet_size));
|
---|
391 | LogRel(("VMNet: Avaliable interface parameter keys:\n"));
|
---|
392 | xpc_dictionary_apply(interface_param, ^bool(const char * _Nonnull key, xpc_object_t _Nonnull value) {
|
---|
393 | RT_NOREF(value);
|
---|
394 | LogRel(("VMNet: %s\n", key));
|
---|
395 | return true;
|
---|
396 | });
|
---|
397 | }
|
---|
398 | #ifdef LOG_ENABLED
|
---|
399 | // Log(("MAC address: %s\n", xpc_dictionary_get_string(interface_param, vmnet_mac_address_key)));
|
---|
400 | Log(("Max packet size: %zu\n", max_packet_size));
|
---|
401 | Log(("MTU size: %llu\n", xpc_dictionary_get_uint64(interface_param, vmnet_mtu_key)));
|
---|
402 | Log(("Avaliable keys:\n"));
|
---|
403 | xpc_dictionary_apply(interface_param, ^bool(const char * _Nonnull key, xpc_object_t _Nonnull value) {
|
---|
404 | RT_NOREF(value);
|
---|
405 | Log(("%s\n", key));
|
---|
406 | return true;
|
---|
407 | });
|
---|
408 | #endif /* LOG_ENABLED */
|
---|
409 | }
|
---|
410 | dispatch_semaphore_signal(operation_done);
|
---|
411 | });
|
---|
412 | if (dispatch_semaphore_wait(operation_done, dispatch_time(DISPATCH_TIME_NOW, RT_NS_1MIN)))
|
---|
413 | {
|
---|
414 | LogRel(("VMNet: Failed to start VMNET interface due to time out!\n"));
|
---|
415 | return VMNET_FAILURE;
|
---|
416 | }
|
---|
417 |
|
---|
418 | if (vmnet_status != VMNET_SUCCESS)
|
---|
419 | return vmnet_status;
|
---|
420 |
|
---|
421 | if (pThis->Interface == NULL)
|
---|
422 | {
|
---|
423 | Log(("Failed to start VMNET interface with unknown status!\n"));
|
---|
424 | return VMNET_FAILURE;
|
---|
425 | }
|
---|
426 |
|
---|
427 | LogRel(("VMNet: Max packet size is %zu\n", max_packet_size));
|
---|
428 |
|
---|
429 | vmnet_interface_set_event_callback(pThis->Interface, VMNET_INTERFACE_PACKETS_AVAILABLE, pThis->InterfaceQueue, ^(interface_event_t event_mask, xpc_object_t _Nonnull event) {
|
---|
430 | if (event_mask & VMNET_INTERFACE_PACKETS_AVAILABLE)
|
---|
431 | {
|
---|
432 | int rc;
|
---|
433 | struct vmpktdesc packets;
|
---|
434 | struct iovec io;
|
---|
435 | int packet_count = (int)xpc_dictionary_get_uint64(event, vmnet_estimated_packets_available_key);
|
---|
436 | if (packet_count == 1)
|
---|
437 | Log3(("Incoming packets available: %d\n", packet_count));
|
---|
438 | else
|
---|
439 | Log(("WARNING! %d incoming packets available, but we will fetch just one.\n", packet_count));
|
---|
440 | packet_count = 1;
|
---|
441 | io.iov_base = malloc(max_packet_size);
|
---|
442 | io.iov_len = max_packet_size;
|
---|
443 | packets.vm_pkt_iov = &io;
|
---|
444 | packets.vm_pkt_iovcnt = 1;
|
---|
445 | packets.vm_pkt_size = max_packet_size;
|
---|
446 | packets.vm_flags = 0;
|
---|
447 | rc = vmnet_read(pThis->Interface, &packets, &packet_count);
|
---|
448 | if (rc != VMNET_SUCCESS)
|
---|
449 | Log(("Failed to read packets with error code %d\n", rc));
|
---|
450 | else
|
---|
451 | {
|
---|
452 | Log3(("Successfully read %d packets:\n", packet_count));
|
---|
453 | for (int i = 0; i < packet_count; ++i)
|
---|
454 | {
|
---|
455 | rc = drvVMNetReceive(pThis, io.iov_base, packets.vm_pkt_size);
|
---|
456 | }
|
---|
457 | }
|
---|
458 | free(io.iov_base);
|
---|
459 | }
|
---|
460 | });
|
---|
461 |
|
---|
462 | return vmnet_status;
|
---|
463 | }
|
---|
464 |
|
---|
465 | static int drvVMNetDetach(PDRVVMNET pThis)
|
---|
466 | {
|
---|
467 | if (pThis->Interface)
|
---|
468 | {
|
---|
469 | vmnet_stop_interface(pThis->Interface, pThis->InterfaceQueue, ^(vmnet_return_t status){
|
---|
470 | RT_NOREF(status);
|
---|
471 | Log(("VMNET interface has been stopped. Status = %d.\n", status));
|
---|
472 | });
|
---|
473 | pThis->Interface = 0;
|
---|
474 | }
|
---|
475 | if (pThis->InterfaceQueue)
|
---|
476 | {
|
---|
477 | dispatch_release(pThis->InterfaceQueue);
|
---|
478 | pThis->InterfaceQueue = 0;
|
---|
479 | }
|
---|
480 |
|
---|
481 | return 0;
|
---|
482 | }
|
---|
483 |
|
---|
484 |
|
---|
485 | /**
|
---|
486 | * @interface_method_impl{PDMDRVREG,pfnDestruct}
|
---|
487 | */
|
---|
488 | static DECLCALLBACK(void) drvVMNetDestruct(PPDMDRVINS pDrvIns)
|
---|
489 | {
|
---|
490 | PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
|
---|
491 | PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
|
---|
492 |
|
---|
493 | LogFlow(("drvVMNetDestruct: %p\n", pDrvIns));
|
---|
494 | drvVMNetDetach(pThis);
|
---|
495 | if (RTCritSectIsInitialized(&pThis->XmitLock))
|
---|
496 | RTCritSectDelete(&pThis->XmitLock);
|
---|
497 | }
|
---|
498 |
|
---|
499 |
|
---|
500 | /**
|
---|
501 | * @interface_method_impl{Construct a NAT network transport driver instance,
|
---|
502 | * PDMDRVREG,pfnDestruct}
|
---|
503 | */
|
---|
504 | static DECLCALLBACK(int) drvVMNetConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
|
---|
505 | {
|
---|
506 | RT_NOREF(fFlags);
|
---|
507 | PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
|
---|
508 | PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
|
---|
509 | PCPDMDRVHLPR3 pHlp = pDrvIns->pHlpR3;
|
---|
510 |
|
---|
511 | LogFlow(("drvVMNetConstruct: %p\n", pDrvIns));
|
---|
512 |
|
---|
513 | /*
|
---|
514 | * Init the static parts.
|
---|
515 | */
|
---|
516 | pThis->pDrvIns = pDrvIns;
|
---|
517 | /* IBase */
|
---|
518 | pDrvIns->IBase.pfnQueryInterface = drvVMNetQueryInterface;
|
---|
519 | /* INetworkUp */
|
---|
520 | pThis->INetworkUp.pfnBeginXmit = drvVMNetUp_BeginXmit;
|
---|
521 | pThis->INetworkUp.pfnAllocBuf = drvVMNetUp_AllocBuf;
|
---|
522 | pThis->INetworkUp.pfnFreeBuf = drvVMNetUp_FreeBuf;
|
---|
523 | pThis->INetworkUp.pfnSendBuf = drvVMNetUp_SendBuf;
|
---|
524 | pThis->INetworkUp.pfnEndXmit = drvVMNetUp_EndXmit;
|
---|
525 | pThis->INetworkUp.pfnSetPromiscuousMode = drvVMNetUp_SetPromiscuousMode;
|
---|
526 | pThis->INetworkUp.pfnNotifyLinkChanged = drvVMNetUp_NotifyLinkChanged;
|
---|
527 |
|
---|
528 | /* Initialize the state. */
|
---|
529 | pThis->enmState = VMNETSTATE_SUSPENDED;
|
---|
530 |
|
---|
531 | /*
|
---|
532 | * Create the locks.
|
---|
533 | */
|
---|
534 | int rc = RTCritSectInit(&pThis->XmitLock);
|
---|
535 | AssertRCReturn(rc, rc);
|
---|
536 |
|
---|
537 | /*
|
---|
538 | * Validate the config.
|
---|
539 | */
|
---|
540 | PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns,
|
---|
541 | "Network"
|
---|
542 | "|Id"
|
---|
543 | "|Trunk"
|
---|
544 | "|TrunkType"
|
---|
545 | "|NetworkMask"
|
---|
546 | "|LowerIP"
|
---|
547 | "|UpperIP",
|
---|
548 | "");
|
---|
549 |
|
---|
550 | /** @cfgm{GUID, string}
|
---|
551 | * The unique id of the VMNET interface.
|
---|
552 | */
|
---|
553 | char szUUID[40];
|
---|
554 | rc = pHlp->pfnCFGMQueryString(pCfg, "Id", szUUID, sizeof(szUUID));
|
---|
555 | if (rc == VERR_CFGM_VALUE_NOT_FOUND)
|
---|
556 | uuid_generate_random(pThis->uuid);
|
---|
557 | else if (RT_FAILURE(rc))
|
---|
558 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
559 | N_("Configuration error: Failed to get the \"Id\" value"));
|
---|
560 | else if (uuid_parse(szUUID, pThis->uuid))
|
---|
561 | return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
|
---|
562 | N_("Configuration error: Invalid \"Id\" value: %s"), szUUID);
|
---|
563 |
|
---|
564 | /** @cfgm{TrunkType, uint32_t}
|
---|
565 | * The trunk connection type see INTNETTRUNKTYPE.
|
---|
566 | */
|
---|
567 | uint32_t u32TrunkType;
|
---|
568 | rc = pHlp->pfnCFGMQueryU32(pCfg, "TrunkType", &u32TrunkType);
|
---|
569 | if (RT_FAILURE(rc))
|
---|
570 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
571 | N_("Configuration error: Failed to get the \"TrunkType\" value"));
|
---|
572 |
|
---|
573 | switch ((INTNETTRUNKTYPE)u32TrunkType)
|
---|
574 | {
|
---|
575 | case kIntNetTrunkType_NetAdp:
|
---|
576 | /*
|
---|
577 | * Get the network mask.
|
---|
578 | */
|
---|
579 | rc = pHlp->pfnCFGMQueryString(pCfg, "NetworkMask", pThis->szNetworkMask, sizeof(pThis->szNetworkMask));
|
---|
580 | if (RT_FAILURE(rc))
|
---|
581 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
582 | N_("Configuration error: Failed to get the \"NetworkMask\" value"));
|
---|
583 |
|
---|
584 | /*
|
---|
585 | * Get the network mask.
|
---|
586 | */
|
---|
587 | rc = pHlp->pfnCFGMQueryString(pCfg, "LowerIP", pThis->szLowerIP, sizeof(pThis->szLowerIP));
|
---|
588 | if (RT_FAILURE(rc))
|
---|
589 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
590 | N_("Configuration error: Failed to get the \"LowerIP\" value"));
|
---|
591 |
|
---|
592 | /*
|
---|
593 | * Get the network mask.
|
---|
594 | */
|
---|
595 | rc = pHlp->pfnCFGMQueryString(pCfg, "UpperIP", pThis->szUpperIP, sizeof(pThis->szUpperIP));
|
---|
596 | if (RT_FAILURE(rc))
|
---|
597 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
598 | N_("Configuration error: Failed to get the \"UpperIP\" value"));
|
---|
599 |
|
---|
600 | pThis->uMode = VMNET_HOST_MODE;
|
---|
601 | LogRel(("VMNet: Host network with mask %s (%s to %s)\n", pThis->szNetworkMask, pThis->szLowerIP, pThis->szUpperIP));
|
---|
602 | break;
|
---|
603 |
|
---|
604 | case kIntNetTrunkType_NetFlt:
|
---|
605 | /** @cfgm{Trunk, string}
|
---|
606 | * The name of the host interface to use for bridging.
|
---|
607 | */
|
---|
608 | rc = pHlp->pfnCFGMQueryString(pCfg, "Trunk", pThis->szHostInterface, sizeof(pThis->szHostInterface));
|
---|
609 | if (RT_FAILURE(rc))
|
---|
610 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
611 | N_("Configuration error: Failed to get the \"Trunk\" value"));
|
---|
612 | pThis->uMode = VMNET_BRIDGED_MODE;
|
---|
613 | LogRel(("VMNet: Bridge to %s\n", pThis->szHostInterface));
|
---|
614 | break;
|
---|
615 |
|
---|
616 | default:
|
---|
617 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
618 | N_("Configuration error: Unsupported \"TrunkType\" value"));
|
---|
619 | }
|
---|
620 |
|
---|
621 | /*
|
---|
622 | * Check that no-one is attached to us.
|
---|
623 | */
|
---|
624 | AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
|
---|
625 | ("Configuration error: Not possible to attach anything to this driver!\n"),
|
---|
626 | VERR_PDM_DRVINS_NO_ATTACH);
|
---|
627 |
|
---|
628 | /*
|
---|
629 | * Query the network port interface.
|
---|
630 | */
|
---|
631 | pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
|
---|
632 | if (!pThis->pIAboveNet)
|
---|
633 | {
|
---|
634 | AssertMsgFailed(("Configuration error: the above device/driver didn't export the network port interface!\n"));
|
---|
635 | return VERR_PDM_MISSING_INTERFACE_ABOVE;
|
---|
636 | }
|
---|
637 |
|
---|
638 | /*
|
---|
639 | * Query the network config interface.
|
---|
640 | */
|
---|
641 | pThis->pIAboveConfig = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKCONFIG);
|
---|
642 | if (!pThis->pIAboveConfig)
|
---|
643 | {
|
---|
644 | AssertMsgFailed(("Configuration error: the above device/driver didn't export the network config interface!\n"));
|
---|
645 | return VERR_PDM_MISSING_INTERFACE_ABOVE;
|
---|
646 | }
|
---|
647 |
|
---|
648 | vmnet_return_t status = drvVMNetAttach(pThis);
|
---|
649 | if (status != VMNET_SUCCESS)
|
---|
650 | return PDMDrvHlpVMSetError(pDrvIns, VERR_INVALID_PARAMETER, RT_SRC_POS,
|
---|
651 | N_("Error: vmnet_start_interface returned %d"), status);
|
---|
652 |
|
---|
653 | return VINF_SUCCESS;
|
---|
654 | }
|
---|
655 |
|
---|
656 |
|
---|
657 | /**
|
---|
658 | * Power On notification.
|
---|
659 | *
|
---|
660 | * @param pDrvIns The driver instance.
|
---|
661 | */
|
---|
662 | static DECLCALLBACK(void) drvVMNetPowerOn(PPDMDRVINS pDrvIns)
|
---|
663 | {
|
---|
664 | LogFlow(("drvVMNetPowerOn\n"));
|
---|
665 | PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
|
---|
666 | ASMAtomicXchgSize(&pThis->enmState, VMNETSTATE_RUNNING);
|
---|
667 | }
|
---|
668 |
|
---|
669 |
|
---|
670 | /**
|
---|
671 | * Suspend notification.
|
---|
672 | *
|
---|
673 | * @param pDrvIns The driver instance.
|
---|
674 | */
|
---|
675 | static DECLCALLBACK(void) drvVMNetSuspend(PPDMDRVINS pDrvIns)
|
---|
676 | {
|
---|
677 | LogFlow(("drvVMNetSuspend\n"));
|
---|
678 | PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
|
---|
679 | ASMAtomicXchgSize(&pThis->enmState, VMNETSTATE_SUSPENDED);
|
---|
680 | }
|
---|
681 |
|
---|
682 |
|
---|
683 | /**
|
---|
684 | * Resume notification.
|
---|
685 | *
|
---|
686 | * @param pDrvIns The driver instance.
|
---|
687 | */
|
---|
688 | static DECLCALLBACK(void) drvVMNetResume(PPDMDRVINS pDrvIns)
|
---|
689 | {
|
---|
690 | LogFlow(("drvVMNetResume\n"));
|
---|
691 | PDRVVMNET pThis = PDMINS_2_DATA(pDrvIns, PDRVVMNET);
|
---|
692 | ASMAtomicXchgSize(&pThis->enmState, VMNETSTATE_RUNNING);
|
---|
693 | }
|
---|
694 |
|
---|
695 |
|
---|
696 |
|
---|
697 | /**
|
---|
698 | * Network sniffer filter driver registration record.
|
---|
699 | */
|
---|
700 | const PDMDRVREG g_DrvVMNet =
|
---|
701 | {
|
---|
702 | /* u32Version */
|
---|
703 | PDM_DRVREG_VERSION,
|
---|
704 | /* szName */
|
---|
705 | "VMNet",
|
---|
706 | /* szRCMod */
|
---|
707 | "",
|
---|
708 | /* szR0Mod */
|
---|
709 | "",
|
---|
710 | /* pszDescription */
|
---|
711 | "VMNET Filter Driver",
|
---|
712 | /* fFlags */
|
---|
713 | PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
|
---|
714 | /* fClass. */
|
---|
715 | PDM_DRVREG_CLASS_NETWORK,
|
---|
716 | /* cMaxInstances */
|
---|
717 | UINT32_MAX,
|
---|
718 | /* cbInstance */
|
---|
719 | sizeof(DRVVMNET),
|
---|
720 | /* pfnConstruct */
|
---|
721 | drvVMNetConstruct,
|
---|
722 | /* pfnDestruct */
|
---|
723 | drvVMNetDestruct,
|
---|
724 | /* pfnRelocate */
|
---|
725 | NULL,
|
---|
726 | /* pfnIOCtl */
|
---|
727 | NULL,
|
---|
728 | /* pfnPowerOn */
|
---|
729 | drvVMNetPowerOn,
|
---|
730 | /* pfnReset */
|
---|
731 | NULL,
|
---|
732 | /* pfnSuspend */
|
---|
733 | drvVMNetSuspend,
|
---|
734 | /* pfnResume */
|
---|
735 | drvVMNetResume,
|
---|
736 | /* pfnAttach */
|
---|
737 | NULL,
|
---|
738 | /* pfnDetach */
|
---|
739 | NULL,
|
---|
740 | /* pfnPowerOff */
|
---|
741 | NULL,
|
---|
742 | /* pfnSoftReset */
|
---|
743 | NULL,
|
---|
744 | /* u32EndVersion */
|
---|
745 | PDM_DRVREG_VERSION
|
---|
746 | };
|
---|
747 |
|
---|