1 | /* $Id: DrvCloudTunnel.cpp 103346 2024-02-14 02:06:13Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * DrvCloudTunnel - Cloud tunnel network transport driver
|
---|
4 | *
|
---|
5 | * Based on code contributed by Christophe Devriese
|
---|
6 | */
|
---|
7 |
|
---|
8 | /*
|
---|
9 | * Copyright (C) 2022-2023 Oracle and/or its affiliates.
|
---|
10 | *
|
---|
11 | * This file is part of VirtualBox base platform packages, as
|
---|
12 | * available from https://www.virtualbox.org.
|
---|
13 | *
|
---|
14 | * This program is free software; you can redistribute it and/or
|
---|
15 | * modify it under the terms of the GNU General Public License
|
---|
16 | * as published by the Free Software Foundation, in version 3 of the
|
---|
17 | * License.
|
---|
18 | *
|
---|
19 | * This program is distributed in the hope that it will be useful, but
|
---|
20 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
21 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
22 | * General Public License for more details.
|
---|
23 | *
|
---|
24 | * You should have received a copy of the GNU General Public License
|
---|
25 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
26 | *
|
---|
27 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
28 | */
|
---|
29 |
|
---|
30 |
|
---|
31 | /*********************************************************************************************************************************
|
---|
32 | * Header Files *
|
---|
33 | *********************************************************************************************************************************/
|
---|
34 | #define LOG_GROUP LOG_GROUP_DRV_CTUN
|
---|
35 | #include <VBox/log.h>
|
---|
36 | #include <VBox/vmm/pdmdrv.h>
|
---|
37 | #include <VBox/vmm/pdmnetifs.h>
|
---|
38 | #include <VBox/vmm/pdmnetinline.h>
|
---|
39 |
|
---|
40 | #include <iprt/asm.h>
|
---|
41 | #include <iprt/assert.h>
|
---|
42 | #include <iprt/ctype.h>
|
---|
43 | #include <iprt/mem.h>
|
---|
44 | #include <iprt/path.h>
|
---|
45 | #include <iprt/uuid.h>
|
---|
46 | #include <iprt/req.h>
|
---|
47 | #include <iprt/stream.h>
|
---|
48 | #include <iprt/string.h>
|
---|
49 | #include <iprt/critsect.h>
|
---|
50 |
|
---|
51 | #include "VBoxDD.h"
|
---|
52 |
|
---|
53 | #ifdef RT_OS_WINDOWS
|
---|
54 | # include <iprt/win/windows.h>
|
---|
55 | typedef int socklen_t;
|
---|
56 | #else
|
---|
57 | # include <errno.h>
|
---|
58 | typedef int SOCKET;
|
---|
59 | # define closesocket close
|
---|
60 | # define INVALID_SOCKET -1
|
---|
61 | # define SOCKET_ERROR -1
|
---|
62 | DECLINLINE(int) WSAGetLastError() { return errno; }
|
---|
63 | #endif
|
---|
64 |
|
---|
65 | /* Prevent inclusion of Winsock2.h */
|
---|
66 | #define _WINSOCK2API_
|
---|
67 | #include <libssh/libssh.h>
|
---|
68 | #include <libssh/callbacks.h>
|
---|
69 |
|
---|
70 |
|
---|
71 | /*********************************************************************************************************************************
|
---|
72 | * Structures and Typedefs *
|
---|
73 | *********************************************************************************************************************************/
|
---|
74 | /**
|
---|
75 | * Cloud tunnel driver instance data.
|
---|
76 | *
|
---|
77 | * @implements PDMINETWORKUP
|
---|
78 | */
|
---|
79 | typedef struct DRVCLOUDTUNNEL
|
---|
80 | {
|
---|
81 | /** The network interface. */
|
---|
82 | PDMINETWORKUP INetworkUp;
|
---|
83 | /** The network interface. */
|
---|
84 | PPDMINETWORKDOWN pIAboveNet;
|
---|
85 | /** Pointer to the driver instance. */
|
---|
86 | PPDMDRVINS pDrvIns;
|
---|
87 | /** Cloud instance private key. */
|
---|
88 | ssh_key SshKey;
|
---|
89 | /** Cloud instance user. */
|
---|
90 | char *pszUser;
|
---|
91 | /** Cloud instance primary IP address. */
|
---|
92 | char *pszPrimaryIP;
|
---|
93 | /** Cloud instance primary IP address. */
|
---|
94 | char *pszSecondaryIP;
|
---|
95 | /** MAC address to set on cloud primary interface. */
|
---|
96 | RTMAC targetMac;
|
---|
97 | /** SSH connection timeout in seconds. */
|
---|
98 | long ulTimeoutInSecounds;
|
---|
99 |
|
---|
100 | /** Primary proxy type. */
|
---|
101 | char *pszPrimaryProxyType;
|
---|
102 | /** Primary proxy server IP address. */
|
---|
103 | char *pszPrimaryProxyHost;
|
---|
104 | /** Primary proxy server port. */
|
---|
105 | uint16_t u16PrimaryProxyPort;
|
---|
106 | /** Primary proxy user. */
|
---|
107 | char *pszPrimaryProxyUser;
|
---|
108 | /** Primary proxy password. */
|
---|
109 | char *pszPrimaryProxyPassword;
|
---|
110 |
|
---|
111 | /** Secondary proxy type. */
|
---|
112 | char *pszSecondaryProxyType;
|
---|
113 | /** Secondary proxy server IP address. */
|
---|
114 | char *pszSecondaryProxyHost;
|
---|
115 | /** Secondary proxy server port. */
|
---|
116 | uint16_t u16SecondaryProxyPort;
|
---|
117 | /** Secondary proxy user. */
|
---|
118 | char *pszSecondaryProxyUser;
|
---|
119 | /** Secondary proxy password. */
|
---|
120 | char *pszSecondaryProxyPassword;
|
---|
121 |
|
---|
122 | /** Cloud tunnel instance string. */
|
---|
123 | char *pszInstance;
|
---|
124 | /** Cloud tunnel I/O thread unique name. */
|
---|
125 | char *pszInstanceIo;
|
---|
126 | /** Cloud tunnel device thread unique name. */
|
---|
127 | char *pszInstanceDev;
|
---|
128 |
|
---|
129 | /** Command assembly buffer. */
|
---|
130 | char *pszCommandBuffer;
|
---|
131 | /** Command output buffer. */
|
---|
132 | char *pszOutputBuffer;
|
---|
133 | /** Name of primary interface of cloud instance. */
|
---|
134 | char *pszCloudPrimaryInterface;
|
---|
135 |
|
---|
136 | /** Cloud destination address. */
|
---|
137 | RTNETADDR DestAddress;
|
---|
138 | /** Transmit lock used by drvCloudTunnelUp_BeginXmit. */
|
---|
139 | RTCRITSECT XmitLock;
|
---|
140 | /** Server data structure for Cloud communication. */
|
---|
141 | // PRTCLOUDSERVER pServer;
|
---|
142 |
|
---|
143 | /** RX thread for delivering packets to attached device. */
|
---|
144 | PPDMTHREAD pDevThread;
|
---|
145 | /** Queue for device-thread requests. */
|
---|
146 | RTREQQUEUE hDevReqQueue;
|
---|
147 | /** I/O thread for tunnel channel. */
|
---|
148 | PPDMTHREAD pIoThread;
|
---|
149 | /** Queue for I/O-thread requests. */
|
---|
150 | RTREQQUEUE hIoReqQueue;
|
---|
151 | /** I/O thread notification socket pair (in). */
|
---|
152 | SOCKET iSocketIn;
|
---|
153 | /** I/O thread notification socket pair (out). */
|
---|
154 | SOCKET iSocketOut;
|
---|
155 |
|
---|
156 | /** SSH private key. */
|
---|
157 |
|
---|
158 | /** SSH Log Verbosity: 0 - No log, 1 - warnings, 2 - protocol, 3 - packet, 4 - functions */
|
---|
159 | int iSshVerbosity;
|
---|
160 | /** SSH Session. */
|
---|
161 | ssh_session pSshSession;
|
---|
162 | /** SSH Tunnel Channel. */
|
---|
163 | ssh_channel pSshChannel;
|
---|
164 | /** SSH Packet Receive Callback Structure. */
|
---|
165 | struct ssh_channel_callbacks_struct Callbacks;
|
---|
166 |
|
---|
167 | /** Flag whether the link is down. */
|
---|
168 | bool volatile fLinkDown;
|
---|
169 |
|
---|
170 | #ifdef VBOX_WITH_STATISTICS
|
---|
171 | /** Number of sent packets. */
|
---|
172 | STAMCOUNTER StatPktSent;
|
---|
173 | /** Number of sent bytes. */
|
---|
174 | STAMCOUNTER StatPktSentBytes;
|
---|
175 | /** Number of received packets. */
|
---|
176 | STAMCOUNTER StatPktRecv;
|
---|
177 | /** Number of received bytes. */
|
---|
178 | STAMCOUNTER StatPktRecvBytes;
|
---|
179 | /** Profiling packet transmit runs. */
|
---|
180 | STAMPROFILEADV StatTransmit;
|
---|
181 | /** Profiling packet receive runs. */
|
---|
182 | STAMPROFILEADV StatReceive;
|
---|
183 | /** Profiling packet receive device (both actual receive and waiting). */
|
---|
184 | STAMPROFILE StatDevRecv;
|
---|
185 | /** Profiling packet receive device waiting. */
|
---|
186 | STAMPROFILE StatDevRecvWait;
|
---|
187 | #endif /* VBOX_WITH_STATISTICS */
|
---|
188 |
|
---|
189 | #ifdef LOG_ENABLED
|
---|
190 | /** The nano ts of the last transfer. */
|
---|
191 | uint64_t u64LastTransferTS;
|
---|
192 | /** The nano ts of the last receive. */
|
---|
193 | uint64_t u64LastReceiveTS;
|
---|
194 | #endif
|
---|
195 | } DRVCLOUDTUNNEL, *PDRVCLOUDTUNNEL;
|
---|
196 |
|
---|
197 |
|
---|
198 | /** Converts a pointer to CLOUDTUNNEL::INetworkUp to a PRDVCLOUDTUNNEL. */
|
---|
199 | #define PDMINETWORKUP_2_DRVCLOUDTUNNEL(pInterface) ( (PDRVCLOUDTUNNEL)((uintptr_t)pInterface - RT_UOFFSETOF(DRVCLOUDTUNNEL, INetworkUp)) )
|
---|
200 |
|
---|
201 |
|
---|
202 | /*********************************************************************************************************************************
|
---|
203 | * Internal Functions *
|
---|
204 | *********************************************************************************************************************************/
|
---|
205 |
|
---|
206 | /**
|
---|
207 | * @interface_method_impl{PDMINETWORKUP,pfnBeginXmit}
|
---|
208 | */
|
---|
209 | static DECLCALLBACK(int) drvCloudTunnelUp_BeginXmit(PPDMINETWORKUP pInterface, bool fOnWorkerThread)
|
---|
210 | {
|
---|
211 | RT_NOREF(fOnWorkerThread);
|
---|
212 | PDRVCLOUDTUNNEL pThis = PDMINETWORKUP_2_DRVCLOUDTUNNEL(pInterface);
|
---|
213 | int rc = RTCritSectTryEnter(&pThis->XmitLock);
|
---|
214 | if (RT_FAILURE(rc))
|
---|
215 | {
|
---|
216 | /** @todo XMIT thread */
|
---|
217 | rc = VERR_TRY_AGAIN;
|
---|
218 | }
|
---|
219 | return rc;
|
---|
220 | }
|
---|
221 |
|
---|
222 | /**
|
---|
223 | * @interface_method_impl{PDMINETWORKUP,pfnAllocBuf}
|
---|
224 | */
|
---|
225 | static DECLCALLBACK(int) drvCloudTunnelUp_AllocBuf(PPDMINETWORKUP pInterface, size_t cbMin,
|
---|
226 | PCPDMNETWORKGSO pGso, PPPDMSCATTERGATHER ppSgBuf)
|
---|
227 | {
|
---|
228 | PDRVCLOUDTUNNEL pThis = PDMINETWORKUP_2_DRVCLOUDTUNNEL(pInterface);
|
---|
229 | Assert(RTCritSectIsOwner(&pThis->XmitLock)); NOREF(pThis);
|
---|
230 |
|
---|
231 | /*
|
---|
232 | * Allocate a scatter / gather buffer descriptor that is immediately
|
---|
233 | * followed by the buffer space of its single segment. The GSO context
|
---|
234 | * comes after that again.
|
---|
235 | */
|
---|
236 | PPDMSCATTERGATHER pSgBuf = (PPDMSCATTERGATHER)RTMemAlloc( RT_ALIGN_Z(sizeof(*pSgBuf), 16)
|
---|
237 | + RT_ALIGN_Z(cbMin, 16)
|
---|
238 | + (pGso ? RT_ALIGN_Z(sizeof(*pGso), 16) : 0));
|
---|
239 | if (!pSgBuf)
|
---|
240 | return VERR_NO_MEMORY;
|
---|
241 |
|
---|
242 | /*
|
---|
243 | * Initialize the S/G buffer and return.
|
---|
244 | */
|
---|
245 | pSgBuf->fFlags = PDMSCATTERGATHER_FLAGS_MAGIC | PDMSCATTERGATHER_FLAGS_OWNER_1;
|
---|
246 | pSgBuf->cbUsed = 0;
|
---|
247 | pSgBuf->cbAvailable = RT_ALIGN_Z(cbMin, 16);
|
---|
248 | pSgBuf->pvAllocator = NULL;
|
---|
249 | if (!pGso)
|
---|
250 | pSgBuf->pvUser = NULL;
|
---|
251 | else
|
---|
252 | {
|
---|
253 | pSgBuf->pvUser = (uint8_t *)(pSgBuf + 1) + pSgBuf->cbAvailable;
|
---|
254 | *(PPDMNETWORKGSO)pSgBuf->pvUser = *pGso;
|
---|
255 | }
|
---|
256 | pSgBuf->cSegs = 1;
|
---|
257 | pSgBuf->aSegs[0].cbSeg = pSgBuf->cbAvailable;
|
---|
258 | pSgBuf->aSegs[0].pvSeg = pSgBuf + 1;
|
---|
259 |
|
---|
260 | #if 0 /* poison */
|
---|
261 | memset(pSgBuf->aSegs[0].pvSeg, 'F', pSgBuf->aSegs[0].cbSeg);
|
---|
262 | #endif
|
---|
263 | *ppSgBuf = pSgBuf;
|
---|
264 | return VINF_SUCCESS;
|
---|
265 | }
|
---|
266 |
|
---|
267 |
|
---|
268 | /**
|
---|
269 | * @interface_method_impl{PDMINETWORKUP,pfnFreeBuf}
|
---|
270 | */
|
---|
271 | static DECLCALLBACK(int) drvCloudTunnelUp_FreeBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf)
|
---|
272 | {
|
---|
273 | PDRVCLOUDTUNNEL pThis = PDMINETWORKUP_2_DRVCLOUDTUNNEL(pInterface);
|
---|
274 | Assert(RTCritSectIsOwner(&pThis->XmitLock)); NOREF(pThis);
|
---|
275 | if (pSgBuf)
|
---|
276 | {
|
---|
277 | Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
|
---|
278 | pSgBuf->fFlags = 0;
|
---|
279 | RTMemFree(pSgBuf);
|
---|
280 | }
|
---|
281 | return VINF_SUCCESS;
|
---|
282 | }
|
---|
283 |
|
---|
284 | static int createConnectedSockets(PDRVCLOUDTUNNEL pThis)
|
---|
285 | {
|
---|
286 | LogFlow(("%s: creating a pair of connected sockets...\n", pThis->pszInstance));
|
---|
287 | struct sockaddr_in inaddr;
|
---|
288 | struct sockaddr addr;
|
---|
289 | SOCKET lst = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
---|
290 | memset(&inaddr, 0, sizeof(inaddr));
|
---|
291 | memset(&addr, 0, sizeof(addr));
|
---|
292 | inaddr.sin_family = AF_INET;
|
---|
293 | inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
|
---|
294 | inaddr.sin_port = 0;
|
---|
295 | int yes = 1;
|
---|
296 | setsockopt(lst, SOL_SOCKET, SO_REUSEADDR, (char*)&yes, sizeof(yes));
|
---|
297 | bind(lst, (struct sockaddr *)&inaddr, sizeof(inaddr));
|
---|
298 | listen(lst, 1);
|
---|
299 | socklen_t len=sizeof(inaddr);
|
---|
300 | getsockname(lst, &addr, &len);
|
---|
301 | pThis->iSocketOut = socket(AF_INET, SOCK_STREAM, 0);
|
---|
302 | connect(pThis->iSocketOut, &addr, len);
|
---|
303 | pThis->iSocketIn = accept(lst, 0, 0);
|
---|
304 | closesocket(lst);
|
---|
305 | Log2(("%s: socket(%d) <= socket(%d) created successfully.\n", pThis->pszInstance, pThis->iSocketIn, pThis->iSocketOut));
|
---|
306 | return VINF_SUCCESS;
|
---|
307 | }
|
---|
308 |
|
---|
309 |
|
---|
310 | static void destroyConnectedSockets(PDRVCLOUDTUNNEL pThis)
|
---|
311 | {
|
---|
312 | if (pThis->iSocketOut != INVALID_SOCKET)
|
---|
313 | {
|
---|
314 | LogFlow(("%s: destroying output socket (%d)...\n", pThis->pszInstance, pThis->iSocketOut));
|
---|
315 | closesocket(pThis->iSocketOut);
|
---|
316 | }
|
---|
317 | if (pThis->iSocketIn != INVALID_SOCKET)
|
---|
318 | {
|
---|
319 | LogFlow(("%s: destroying input socket (%d)...\n", pThis->pszInstance, pThis->iSocketIn));
|
---|
320 | closesocket(pThis->iSocketIn);
|
---|
321 | }
|
---|
322 | }
|
---|
323 |
|
---|
324 |
|
---|
325 | DECLINLINE(void) drvCloudTunnelFreeSgBuf(PDRVCLOUDTUNNEL pThis, PPDMSCATTERGATHER pSgBuf)
|
---|
326 | {
|
---|
327 | RT_NOREF(pThis);
|
---|
328 | RTMemFree(pSgBuf);
|
---|
329 | }
|
---|
330 |
|
---|
331 | DECLINLINE(void) drvCloudTunnelNotifyIoThread(PDRVCLOUDTUNNEL pThis, const char *pszWho)
|
---|
332 | {
|
---|
333 | RT_NOREF(pszWho);
|
---|
334 | int cBytes = send(pThis->iSocketOut, " ", 1, 0);
|
---|
335 | if (cBytes == SOCKET_ERROR)
|
---|
336 | LogRel(("Failed to send a signalling packet, error code %d", WSAGetLastError())); // @todo!
|
---|
337 |
|
---|
338 | }
|
---|
339 |
|
---|
340 |
|
---|
341 | /**
|
---|
342 | * Worker function for sending packets on I/O thread.
|
---|
343 | *
|
---|
344 | * @param pThis Pointer to the cloud tunnel instance.
|
---|
345 | * @param pSgBuf The scatter/gather buffer.
|
---|
346 | * @thread I/O
|
---|
347 | */
|
---|
348 | static DECLCALLBACK(void) drvCloudTunnelSendWorker(PDRVCLOUDTUNNEL pThis, PPDMSCATTERGATHER pSgBuf)
|
---|
349 | {
|
---|
350 | // int rc = VINF_SUCCESS;
|
---|
351 | if (!pSgBuf->pvUser)
|
---|
352 | {
|
---|
353 | #ifdef LOG_ENABLED
|
---|
354 | uint64_t u64Now = RTTimeProgramNanoTS();
|
---|
355 | LogFunc(("%-4d bytes at %llu ns deltas: r=%llu t=%llu\n",
|
---|
356 | pSgBuf->cbUsed, u64Now, u64Now - pThis->u64LastReceiveTS, u64Now - pThis->u64LastTransferTS));
|
---|
357 | pThis->u64LastTransferTS = u64Now;
|
---|
358 | #endif
|
---|
359 | Log2(("writing to tunnel channel: pSgBuf->aSegs[0].pvSeg=%p pSgBuf->cbUsed=%#x\n%.*Rhxd\n",
|
---|
360 | pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed, pSgBuf->cbUsed, pSgBuf->aSegs[0].pvSeg));
|
---|
361 |
|
---|
362 | int cBytes = ssh_channel_write(pThis->pSshChannel, pSgBuf->aSegs[0].pvSeg, (uint32_t)pSgBuf->cbUsed);
|
---|
363 | if (cBytes == SSH_ERROR)
|
---|
364 | LogRel(("%s: ssh_channel_write failed\n", pThis->pszInstance));
|
---|
365 | }
|
---|
366 | else
|
---|
367 | {
|
---|
368 | uint8_t abHdrScratch[256];
|
---|
369 | uint8_t const *pbFrame = (uint8_t const *)pSgBuf->aSegs[0].pvSeg;
|
---|
370 | PCPDMNETWORKGSO pGso = (PCPDMNETWORKGSO)pSgBuf->pvUser;
|
---|
371 | uint32_t const cSegs = PDMNetGsoCalcSegmentCount(pGso, pSgBuf->cbUsed); Assert(cSegs > 1);
|
---|
372 | for (uint32_t iSeg = 0; iSeg < cSegs; iSeg++)
|
---|
373 | {
|
---|
374 | uint32_t cbSegFrame;
|
---|
375 | void *pvSegFrame = PDMNetGsoCarveSegmentQD(pGso, (uint8_t *)pbFrame, pSgBuf->cbUsed, abHdrScratch,
|
---|
376 | iSeg, cSegs, &cbSegFrame);
|
---|
377 | Log2(("writing to tunnel channel: pvSegFrame=%p cbSegFrame=%#x\n%.*Rhxd\n",
|
---|
378 | pvSegFrame, cbSegFrame, cbSegFrame, pvSegFrame));
|
---|
379 | int cBytes = ssh_channel_write(pThis->pSshChannel, pvSegFrame, cbSegFrame);
|
---|
380 | if (cBytes == SSH_ERROR)
|
---|
381 | LogRel(("%s: ssh_channel_write failed\n", pThis->pszInstance));
|
---|
382 | }
|
---|
383 | }
|
---|
384 |
|
---|
385 | pSgBuf->fFlags = 0;
|
---|
386 | RTMemFree(pSgBuf);
|
---|
387 |
|
---|
388 | STAM_PROFILE_ADV_STOP(&pThis->StatTransmit, a);
|
---|
389 | // AssertRC(rc);
|
---|
390 | // if (RT_FAILURE(rc))
|
---|
391 | // {
|
---|
392 | // if (rc == VERR_NO_MEMORY)
|
---|
393 | // rc = VERR_NET_NO_BUFFER_SPACE;
|
---|
394 | // else
|
---|
395 | // rc = VERR_NET_DOWN;
|
---|
396 | // }
|
---|
397 | // return rc;
|
---|
398 | }
|
---|
399 |
|
---|
400 |
|
---|
401 | /**
|
---|
402 | * @interface_method_impl{PDMINETWORKUP,pfnSendBuf}
|
---|
403 | */
|
---|
404 | static DECLCALLBACK(int) drvCloudTunnelUp_SendBuf(PPDMINETWORKUP pInterface, PPDMSCATTERGATHER pSgBuf, bool fOnWorkerThread)
|
---|
405 | {
|
---|
406 | RT_NOREF(fOnWorkerThread);
|
---|
407 | PDRVCLOUDTUNNEL pThis = PDMINETWORKUP_2_DRVCLOUDTUNNEL(pInterface);
|
---|
408 | STAM_COUNTER_INC(&pThis->StatPktSent);
|
---|
409 | STAM_COUNTER_ADD(&pThis->StatPktSentBytes, pSgBuf->cbUsed);
|
---|
410 | STAM_PROFILE_ADV_START(&pThis->StatTransmit, a);
|
---|
411 |
|
---|
412 | AssertPtr(pSgBuf);
|
---|
413 | Assert((pSgBuf->fFlags & PDMSCATTERGATHER_FLAGS_MAGIC_MASK) == PDMSCATTERGATHER_FLAGS_MAGIC);
|
---|
414 | Assert(RTCritSectIsOwner(&pThis->XmitLock));
|
---|
415 |
|
---|
416 | int rc = VINF_SUCCESS;
|
---|
417 | if (pThis->pIoThread && pThis->pIoThread->enmState == PDMTHREADSTATE_RUNNING)
|
---|
418 | {
|
---|
419 | Log2(("%s: submitting TX request (pvSeg=%p, %u bytes) to I/O queue...\n",
|
---|
420 | pThis->pszInstance, pSgBuf->aSegs[0].pvSeg, pSgBuf->cbUsed));
|
---|
421 | rc = RTReqQueueCallEx(pThis->hIoReqQueue, NULL /*ppReq*/, 0 /*cMillies*/,
|
---|
422 | RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
|
---|
423 | (PFNRT)drvCloudTunnelSendWorker, 2, pThis, pSgBuf);
|
---|
424 |
|
---|
425 | if (RT_SUCCESS(rc))
|
---|
426 | {
|
---|
427 | drvCloudTunnelNotifyIoThread(pThis, "drvCloudTunnelUp_SendBuf");
|
---|
428 | return VINF_SUCCESS;
|
---|
429 | }
|
---|
430 |
|
---|
431 | rc = VERR_NET_NO_BUFFER_SPACE;
|
---|
432 | }
|
---|
433 | else
|
---|
434 | rc = VERR_NET_DOWN;
|
---|
435 | drvCloudTunnelFreeSgBuf(pThis, pSgBuf);
|
---|
436 | return rc;
|
---|
437 | }
|
---|
438 |
|
---|
439 |
|
---|
440 | /**
|
---|
441 | * @interface_method_impl{PDMINETWORKUP,pfnEndXmit}
|
---|
442 | */
|
---|
443 | static DECLCALLBACK(void) drvCloudTunnelUp_EndXmit(PPDMINETWORKUP pInterface)
|
---|
444 | {
|
---|
445 | PDRVCLOUDTUNNEL pThis = PDMINETWORKUP_2_DRVCLOUDTUNNEL(pInterface);
|
---|
446 | RTCritSectLeave(&pThis->XmitLock);
|
---|
447 | }
|
---|
448 |
|
---|
449 |
|
---|
450 | /**
|
---|
451 | * @interface_method_impl{PDMINETWORKUP,pfnSetPromiscuousMode}
|
---|
452 | */
|
---|
453 | static DECLCALLBACK(void) drvCloudTunnelUp_SetPromiscuousMode(PPDMINETWORKUP pInterface, bool fPromiscuous)
|
---|
454 | {
|
---|
455 | RT_NOREF(pInterface, fPromiscuous);
|
---|
456 | LogFlowFunc(("fPromiscuous=%d\n", fPromiscuous));
|
---|
457 | /* nothing to do */
|
---|
458 | }
|
---|
459 |
|
---|
460 |
|
---|
461 | /**
|
---|
462 | * Notification on link status changes.
|
---|
463 | *
|
---|
464 | * @param pInterface Pointer to the interface structure containing the called function pointer.
|
---|
465 | * @param enmLinkState The new link state.
|
---|
466 | * @thread EMT
|
---|
467 | */
|
---|
468 | static DECLCALLBACK(void) drvCloudTunnelUp_NotifyLinkChanged(PPDMINETWORKUP pInterface, PDMNETWORKLINKSTATE enmLinkState)
|
---|
469 | {
|
---|
470 | LogFlowFunc(("enmLinkState=%d\n", enmLinkState));
|
---|
471 | PDRVCLOUDTUNNEL pThis = PDMINETWORKUP_2_DRVCLOUDTUNNEL(pInterface);
|
---|
472 |
|
---|
473 | bool fLinkDown;
|
---|
474 | switch (enmLinkState)
|
---|
475 | {
|
---|
476 | case PDMNETWORKLINKSTATE_DOWN:
|
---|
477 | case PDMNETWORKLINKSTATE_DOWN_RESUME:
|
---|
478 | fLinkDown = true;
|
---|
479 | break;
|
---|
480 | default:
|
---|
481 | AssertMsgFailed(("enmLinkState=%d\n", enmLinkState));
|
---|
482 | RT_FALL_THRU();
|
---|
483 | case PDMNETWORKLINKSTATE_UP:
|
---|
484 | fLinkDown = false;
|
---|
485 | break;
|
---|
486 | }
|
---|
487 | ASMAtomicXchgSize(&pThis->fLinkDown, fLinkDown);
|
---|
488 | }
|
---|
489 |
|
---|
490 |
|
---|
491 |
|
---|
492 | /* -=-=-=-=- PDMIBASE -=-=-=-=- */
|
---|
493 |
|
---|
494 | /**
|
---|
495 | * @interface_method_impl{PDMIBASE,pfnQueryInterface}
|
---|
496 | */
|
---|
497 | static DECLCALLBACK(void *) drvCloudTunnelQueryInterface(PPDMIBASE pInterface, const char *pszIID)
|
---|
498 | {
|
---|
499 | PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
|
---|
500 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
501 |
|
---|
502 | PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
|
---|
503 | PDMIBASE_RETURN_INTERFACE(pszIID, PDMINETWORKUP, &pThis->INetworkUp);
|
---|
504 | return NULL;
|
---|
505 | }
|
---|
506 |
|
---|
507 |
|
---|
508 | /**
|
---|
509 | * I/O thread handling the libssh I/O.
|
---|
510 | *
|
---|
511 | * The libssh implementation is single-threaded so we perform I/O in a
|
---|
512 | * dedicated thread. We take care that this thread does not become the
|
---|
513 | * bottleneck: If the guest wants to send, a request is enqueued into the
|
---|
514 | * hIoReqQueue and is handled asynchronously by this thread. TODO:If this thread
|
---|
515 | * wants to deliver packets to the guest, it enqueues a request into
|
---|
516 | * hRecvReqQueue which is later handled by the Recv thread.
|
---|
517 | */
|
---|
518 | static DECLCALLBACK(int) drvCloudTunnelIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
|
---|
519 | {
|
---|
520 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
521 | // int nFDs = -1;
|
---|
522 |
|
---|
523 | LogFlow(("%s: started I/O thread %p\n", pThis->pszInstance, pThread));
|
---|
524 |
|
---|
525 | if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
|
---|
526 | return VINF_SUCCESS;
|
---|
527 |
|
---|
528 | // if (pThis->enmLinkStateWant != pThis->enmLinkState)
|
---|
529 | // drvNATNotifyLinkChangedWorker(pThis, pThis->enmLinkStateWant);
|
---|
530 |
|
---|
531 | /*
|
---|
532 | * Polling loop.
|
---|
533 | */
|
---|
534 | while (pThread->enmState == PDMTHREADSTATE_RUNNING)
|
---|
535 | {
|
---|
536 | /*
|
---|
537 | * To prevent concurrent execution of sending/receiving threads
|
---|
538 | */
|
---|
539 | //#ifndef RT_OS_WINDOWS
|
---|
540 | // /* process _all_ outstanding requests but don't wait */
|
---|
541 | // RTReqQueueProcess(pThis->hIoReqQueue, 0);
|
---|
542 | // RTMemFree(polls);
|
---|
543 | //#else /* RT_OS_WINDOWS */
|
---|
544 |
|
---|
545 | struct timeval timeout;
|
---|
546 | ssh_channel in_channels[2], out_channels[2];
|
---|
547 | fd_set fds;
|
---|
548 | int maxfd;
|
---|
549 |
|
---|
550 | timeout.tv_sec = 30;
|
---|
551 | timeout.tv_usec = 0;
|
---|
552 | in_channels[0] = pThis->pSshChannel;
|
---|
553 | in_channels[1] = NULL;
|
---|
554 | FD_ZERO(&fds);
|
---|
555 | FD_SET(pThis->iSocketIn, &fds);
|
---|
556 | maxfd = pThis->iSocketIn + 1;
|
---|
557 |
|
---|
558 | ssh_select(in_channels, out_channels, maxfd, &fds, &timeout);
|
---|
559 |
|
---|
560 | /* Poll will call the receive callback on each packet coming from the tunnel. */
|
---|
561 | if (out_channels[0] != NULL)
|
---|
562 | ssh_channel_poll(pThis->pSshChannel, false);
|
---|
563 |
|
---|
564 | /* Did we get notified by drvCloudTunnelNotifyIoThread() via connected sockets? */
|
---|
565 | if (FD_ISSET(pThis->iSocketIn, &fds))
|
---|
566 | {
|
---|
567 | char buf[2];
|
---|
568 | recv(pThis->iSocketIn, buf, 1, 0);
|
---|
569 | /* process all outstanding requests but don't wait */
|
---|
570 | RTReqQueueProcess(pThis->hIoReqQueue, 0);
|
---|
571 | }
|
---|
572 | //#endif /* RT_OS_WINDOWS */
|
---|
573 | }
|
---|
574 |
|
---|
575 | LogFlow(("%s: I/O thread %p terminated\n", pThis->pszInstance, pThread));
|
---|
576 |
|
---|
577 | return VINF_SUCCESS;
|
---|
578 | }
|
---|
579 |
|
---|
580 |
|
---|
581 | /**
|
---|
582 | * Unblock the I/O thread so it can respond to a state change.
|
---|
583 | *
|
---|
584 | * @returns VBox status code.
|
---|
585 | * @param pDevIns The pcnet device instance.
|
---|
586 | * @param pThread The send thread.
|
---|
587 | */
|
---|
588 | static DECLCALLBACK(int) drvCloudTunnelIoWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
|
---|
589 | {
|
---|
590 | RT_NOREF(pThread);
|
---|
591 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
592 |
|
---|
593 | LogFlow(("%s: waking up I/O thread %p...\n", pThis->pszInstance, pThread));
|
---|
594 |
|
---|
595 | drvCloudTunnelNotifyIoThread(pThis, "drvCloudTunnelIoWakeup");
|
---|
596 | return VINF_SUCCESS;
|
---|
597 | }
|
---|
598 |
|
---|
599 |
|
---|
600 | /*
|
---|
601 | * Remove the following cut&paste code after a while, when
|
---|
602 | * we are positive that no frames get coalesced!
|
---|
603 | */
|
---|
604 | #define VBOX_CTUN_COALESCED_FRAME_DETECTION
|
---|
605 | #ifdef VBOX_CTUN_COALESCED_FRAME_DETECTION
|
---|
606 | struct ssh_buffer_struct {
|
---|
607 | bool secure;
|
---|
608 | size_t used;
|
---|
609 | size_t allocated;
|
---|
610 | size_t pos;
|
---|
611 | uint8_t *data;
|
---|
612 | };
|
---|
613 |
|
---|
614 | /** @internal
|
---|
615 | * Describes the different possible states in a
|
---|
616 | * outgoing (client) channel request
|
---|
617 | */
|
---|
618 | enum ssh_channel_request_state_e {
|
---|
619 | /** No request has been made */
|
---|
620 | SSH_CHANNEL_REQ_STATE_NONE = 0,
|
---|
621 | /** A request has been made and answer is pending */
|
---|
622 | SSH_CHANNEL_REQ_STATE_PENDING,
|
---|
623 | /** A request has been replied and accepted */
|
---|
624 | SSH_CHANNEL_REQ_STATE_ACCEPTED,
|
---|
625 | /** A request has been replied and refused */
|
---|
626 | SSH_CHANNEL_REQ_STATE_DENIED,
|
---|
627 | /** A request has been replied and an error happend */
|
---|
628 | SSH_CHANNEL_REQ_STATE_ERROR
|
---|
629 | };
|
---|
630 |
|
---|
631 | enum ssh_channel_state_e {
|
---|
632 | SSH_CHANNEL_STATE_NOT_OPEN = 0,
|
---|
633 | SSH_CHANNEL_STATE_OPENING,
|
---|
634 | SSH_CHANNEL_STATE_OPEN_DENIED,
|
---|
635 | SSH_CHANNEL_STATE_OPEN,
|
---|
636 | SSH_CHANNEL_STATE_CLOSED
|
---|
637 | };
|
---|
638 |
|
---|
639 | /* The channel has been closed by the remote side */
|
---|
640 | #define SSH_CHANNEL_FLAG_CLOSED_REMOTE 0x0001
|
---|
641 |
|
---|
642 | /* The channel has been closed locally */
|
---|
643 | #define SSH_CHANNEL_FLAG_CLOSED_LOCAL 0x0002
|
---|
644 |
|
---|
645 | /* The channel has been freed by the calling program */
|
---|
646 | #define SSH_CHANNEL_FLAG_FREED_LOCAL 0x0004
|
---|
647 |
|
---|
648 | /* the channel has not yet been bound to a remote one */
|
---|
649 | #define SSH_CHANNEL_FLAG_NOT_BOUND 0x0008
|
---|
650 |
|
---|
651 | struct ssh_channel_struct {
|
---|
652 | ssh_session session; /* SSH_SESSION pointer */
|
---|
653 | uint32_t local_channel;
|
---|
654 | uint32_t local_window;
|
---|
655 | int local_eof;
|
---|
656 | uint32_t local_maxpacket;
|
---|
657 |
|
---|
658 | uint32_t remote_channel;
|
---|
659 | uint32_t remote_window;
|
---|
660 | int remote_eof; /* end of file received */
|
---|
661 | uint32_t remote_maxpacket;
|
---|
662 | enum ssh_channel_state_e state;
|
---|
663 | int delayed_close;
|
---|
664 | int flags;
|
---|
665 | ssh_buffer stdout_buffer;
|
---|
666 | ssh_buffer stderr_buffer;
|
---|
667 | void *userarg;
|
---|
668 | int exit_status;
|
---|
669 | enum ssh_channel_request_state_e request_state;
|
---|
670 | struct ssh_list *callbacks; /* list of ssh_channel_callbacks */
|
---|
671 |
|
---|
672 | /* counters */
|
---|
673 | ssh_counter counter;
|
---|
674 | };
|
---|
675 | #endif /* VBOX_CTUN_COALESCED_FRAME_DETECTION */
|
---|
676 |
|
---|
677 | /**
|
---|
678 | * Worker function for delivering receive packets to the attached device.
|
---|
679 | *
|
---|
680 | * @param pThis Pointer to the cloud tunnel instance.
|
---|
681 | * @param pbData Packet data.
|
---|
682 | * @param u32Len Packet length.
|
---|
683 | * @thread Dev
|
---|
684 | */
|
---|
685 | static DECLCALLBACK(void) drvCloudTunnelReceiveWorker(PDRVCLOUDTUNNEL pThis, uint8_t *pbData, uint32_t u32Len)
|
---|
686 | {
|
---|
687 | AssertPtrReturnVoid(pbData);
|
---|
688 | AssertReturnVoid(u32Len!=0);
|
---|
689 |
|
---|
690 | STAM_PROFILE_START(&pThis->StatDevRecv, a);
|
---|
691 |
|
---|
692 | Log2(("%s: waiting until device is ready to receive...\n", pThis->pszInstance));
|
---|
693 | STAM_PROFILE_START(&pThis->StatDevRecvWait, b);
|
---|
694 | int rc = pThis->pIAboveNet->pfnWaitReceiveAvail(pThis->pIAboveNet, RT_INDEFINITE_WAIT);
|
---|
695 | STAM_PROFILE_STOP(&pThis->StatDevRecvWait, b);
|
---|
696 |
|
---|
697 | if (RT_SUCCESS(rc))
|
---|
698 | {
|
---|
699 | Log2(("%s: delivering %u-byte packet to attached device...\n", pThis->pszInstance, u32Len));
|
---|
700 | rc = pThis->pIAboveNet->pfnReceive(pThis->pIAboveNet, pbData, u32Len);
|
---|
701 | AssertRC(rc);
|
---|
702 | }
|
---|
703 |
|
---|
704 | RTMemFree(pbData);
|
---|
705 | STAM_PROFILE_STOP(&pThis->StatDevRecv, a);
|
---|
706 | STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
|
---|
707 | }
|
---|
708 |
|
---|
709 | static int drvCloudTunnelReceiveCallback(ssh_session session, ssh_channel channel, void* data, uint32_t len, int is_stderr, void* userdata)
|
---|
710 | {
|
---|
711 | RT_NOREF(session);
|
---|
712 | PDRVCLOUDTUNNEL pThis = (PDRVCLOUDTUNNEL)userdata;
|
---|
713 |
|
---|
714 | Log2(("drvCloudTunnelReceiveCallback: len=%d is_stderr=%s\n", len, is_stderr ? "true" : "false"));
|
---|
715 | if (ASMAtomicReadBool(&pThis->fLinkDown))
|
---|
716 | {
|
---|
717 | Log2(("drvCloudTunnelReceiveCallback: ignoring packet as the link is down\n"));
|
---|
718 | return len;
|
---|
719 | }
|
---|
720 |
|
---|
721 | #ifdef VBOX_CTUN_COALESCED_FRAME_DETECTION
|
---|
722 | if (channel->stdout_buffer->data != data)
|
---|
723 | LogRel(("drvCloudTunnelReceiveCallback: coalesced frames!\n"));
|
---|
724 | #endif /* VBOX_CTUN_COALESCED_FRAME_DETECTION */
|
---|
725 |
|
---|
726 | if (is_stderr)
|
---|
727 | {
|
---|
728 | LogRel(("%s: [REMOTE] %.*s", pThis->pszInstance, len, data));
|
---|
729 | return 0;
|
---|
730 | }
|
---|
731 |
|
---|
732 | STAM_PROFILE_ADV_START(&pThis->StatReceive, a);
|
---|
733 |
|
---|
734 | if (pThis->iSshVerbosity >= SSH_LOG_PACKET)
|
---|
735 | Log2(("%.*Rhxd\n", len, data));
|
---|
736 |
|
---|
737 | /** @todo Validate len! */
|
---|
738 | void *pvPacket = RTMemDup(data, len);
|
---|
739 | if (!pvPacket)
|
---|
740 | {
|
---|
741 | LogRel(("%s: failed to allocate %d bytes\n", pThis->pszInstance, len));
|
---|
742 | STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
|
---|
743 | return len;
|
---|
744 | }
|
---|
745 | int rc = RTReqQueueCallEx(pThis->hDevReqQueue, NULL /*ppReq*/, 0 /*cMillies*/,
|
---|
746 | RTREQFLAGS_VOID | RTREQFLAGS_NO_WAIT,
|
---|
747 | (PFNRT)drvCloudTunnelReceiveWorker, 3, pThis, pvPacket, len);
|
---|
748 | if (RT_FAILURE(rc))
|
---|
749 | {
|
---|
750 | LogRel(("%s: failed to enqueue device request - %Rrc\n", pThis->pszInstance, rc));
|
---|
751 | STAM_PROFILE_ADV_STOP(&pThis->StatReceive, a);
|
---|
752 | }
|
---|
753 |
|
---|
754 | return len;
|
---|
755 | }
|
---|
756 |
|
---|
757 |
|
---|
758 | /* See ssh_channel_write_wontblock_callback in libssh/callbacks.h. */
|
---|
759 | #if LIBSSH_VERSION_INT >= SSH_VERSION_INT(0,10,0)
|
---|
760 | static int channelWriteWontblockCallback(ssh_session, ssh_channel, uint32_t, void *)
|
---|
761 | #else
|
---|
762 | static int channelWriteWontblockCallback(ssh_session, ssh_channel, size_t, void *)
|
---|
763 | #endif
|
---|
764 | {
|
---|
765 | return 0;
|
---|
766 | }
|
---|
767 |
|
---|
768 |
|
---|
769 |
|
---|
770 | /**
|
---|
771 | * This thread feeds the attached device with the packets received from the tunnel.
|
---|
772 | *
|
---|
773 | * This thread is needed because we cannot block I/O thread waiting for the attached
|
---|
774 | * device to become ready to receive packets coming from the tunnel.
|
---|
775 | */
|
---|
776 | static DECLCALLBACK(int) drvCloudTunnelDevThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
|
---|
777 | {
|
---|
778 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
779 |
|
---|
780 | LogFlow(("%s: device thread %p started\n", pThis->pszInstance, pThread));
|
---|
781 |
|
---|
782 | if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
|
---|
783 | return VINF_SUCCESS;
|
---|
784 |
|
---|
785 | /*
|
---|
786 | * Request processing loop.
|
---|
787 | */
|
---|
788 | while (pThread->enmState == PDMTHREADSTATE_RUNNING)
|
---|
789 | {
|
---|
790 | int rc = RTReqQueueProcess(pThis->hDevReqQueue, RT_INDEFINITE_WAIT);
|
---|
791 | Log2(("drvCloudTunnelDevThread: RTReqQueueProcess returned '%Rrc'\n", rc));
|
---|
792 | if (RT_FAILURE(rc))
|
---|
793 | LogRel(("%s: failed to process device request with '%Rrc'\n", pThis->pszInstance, rc));
|
---|
794 | }
|
---|
795 |
|
---|
796 | LogFlow(("%s: device thread %p terminated\n", pThis->pszInstance, pThread));
|
---|
797 | return VINF_SUCCESS;
|
---|
798 | }
|
---|
799 |
|
---|
800 |
|
---|
801 | static DECLCALLBACK(int) drvCloudTunnelReceiveWakeup(PDRVCLOUDTUNNEL pThis)
|
---|
802 | {
|
---|
803 | NOREF(pThis);
|
---|
804 | /* Returning a VINF_* will cause RTReqQueueProcess return. */
|
---|
805 | return VWRN_STATE_CHANGED;
|
---|
806 | }
|
---|
807 |
|
---|
808 | /**
|
---|
809 | * Unblock the I/O thread so it can respond to a state change.
|
---|
810 | *
|
---|
811 | * @returns VBox status code.
|
---|
812 | * @param pDevIns The pcnet device instance.
|
---|
813 | * @param pThread The send thread.
|
---|
814 | */
|
---|
815 | static DECLCALLBACK(int) drvCloudTunnelDevWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
|
---|
816 | {
|
---|
817 | RT_NOREF(pThread);
|
---|
818 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
819 | LogFlow(("%s: waking up device thread %p...\n", pThis->pszInstance, pThread));
|
---|
820 |
|
---|
821 | /* Wake up device thread. */
|
---|
822 | PRTREQ pReq;
|
---|
823 | int rc = RTReqQueueCall(pThis->hDevReqQueue, &pReq, 10000 /*cMillies*/,
|
---|
824 | (PFNRT)drvCloudTunnelReceiveWakeup, 1, pThis);
|
---|
825 | if (RT_FAILURE(rc))
|
---|
826 | LogRel(("%s: failed to wake up device thread - %Rrc\n", pThis->pszInstance, rc));
|
---|
827 | if (RT_SUCCESS(rc))
|
---|
828 | RTReqRelease(pReq);
|
---|
829 |
|
---|
830 | return rc;
|
---|
831 | }
|
---|
832 |
|
---|
833 | #define DRVCLOUDTUNNEL_COMMAND_BUFFER_SIZE 1024
|
---|
834 | #define DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE 65536
|
---|
835 |
|
---|
836 | static int drvCloudTunnelExecuteRemoteCommandNoOutput(PDRVCLOUDTUNNEL pThis, const char *pcszCommand, ...)
|
---|
837 | {
|
---|
838 | va_list va;
|
---|
839 | va_start(va, pcszCommand);
|
---|
840 | ssize_t const cch = RTStrPrintf2V(pThis->pszCommandBuffer, DRVCLOUDTUNNEL_COMMAND_BUFFER_SIZE, pcszCommand, va);
|
---|
841 | va_end(va);
|
---|
842 | if (cch <= 0)
|
---|
843 | {
|
---|
844 | Log(("%s: Failed to process '%s'\n", pThis->pszInstance, pcszCommand));
|
---|
845 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
846 | N_("Failed to compose command line"));
|
---|
847 | }
|
---|
848 |
|
---|
849 | LogFlow(("%s: [REMOTE] executing '%s'...\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
850 |
|
---|
851 | ssh_channel channel = ssh_channel_new(pThis->pSshSession);
|
---|
852 | if (channel == NULL)
|
---|
853 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
854 | N_("Failed to allocate new channel"));
|
---|
855 |
|
---|
856 | int rc = ssh_channel_open_session(channel);
|
---|
857 | if (rc != SSH_OK)
|
---|
858 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
859 | N_("Failed to open session channel"));
|
---|
860 | else
|
---|
861 | {
|
---|
862 | rc = ssh_channel_request_exec(channel, pThis->pszCommandBuffer);
|
---|
863 | if (rc != SSH_OK)
|
---|
864 | {
|
---|
865 | LogRel(("%s: Failed to execute '%s'\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
866 | Log(("%s: Failed to execute '%s'\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
867 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
868 | N_("Execute request failed with %d"), rc);
|
---|
869 | }
|
---|
870 | ssh_channel_close(channel);
|
---|
871 | }
|
---|
872 | ssh_channel_free(channel);
|
---|
873 |
|
---|
874 | return VINF_SUCCESS;
|
---|
875 | }
|
---|
876 |
|
---|
877 |
|
---|
878 | static int drvCloudTunnelExecuteRemoteCommand(PDRVCLOUDTUNNEL pThis, const char *pcszCommand, ...)
|
---|
879 | {
|
---|
880 | va_list va;
|
---|
881 | va_start(va, pcszCommand);
|
---|
882 | ssize_t const cch = RTStrPrintf2V(pThis->pszCommandBuffer, DRVCLOUDTUNNEL_COMMAND_BUFFER_SIZE, pcszCommand, va);
|
---|
883 | va_end(va);
|
---|
884 | if (cch <= 0)
|
---|
885 | {
|
---|
886 | Log(("%s: Failed to process '%s'\n", pThis->pszInstance, pcszCommand));
|
---|
887 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
888 | N_("Failed to compose command line"));
|
---|
889 | }
|
---|
890 |
|
---|
891 | LogFlow(("%s: [REMOTE] executing '%s'...\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
892 |
|
---|
893 | ssh_channel channel = ssh_channel_new(pThis->pSshSession);
|
---|
894 | if (channel == NULL)
|
---|
895 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
896 | N_("Failed to allocate new channel"));
|
---|
897 |
|
---|
898 | int rc = ssh_channel_open_session(channel);
|
---|
899 | if (rc != SSH_OK)
|
---|
900 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
901 | N_("Failed to open session channel"));
|
---|
902 | else
|
---|
903 | {
|
---|
904 | rc = ssh_channel_request_exec(channel, pThis->pszCommandBuffer);
|
---|
905 | if (rc != SSH_OK)
|
---|
906 | {
|
---|
907 | LogRel(("%s: Failed to execute '%s'\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
908 | Log(("%s: Failed to execute '%s'\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
909 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
910 | N_("Execute request failed with %d"), rc);
|
---|
911 | }
|
---|
912 | else
|
---|
913 | {
|
---|
914 | int cbSpaceLeft = DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE;
|
---|
915 | int cbStdOut = 0;
|
---|
916 | char *pszBuffer = pThis->pszOutputBuffer;
|
---|
917 | int cBytes = ssh_channel_read_timeout(channel, pszBuffer, cbSpaceLeft, 0, 60000 /* ms */); /* Is 60 seconds really enough? */
|
---|
918 | while (cBytes > 0)
|
---|
919 | {
|
---|
920 | cbStdOut += cBytes;
|
---|
921 | pszBuffer += cBytes;
|
---|
922 | cbSpaceLeft -= cBytes;
|
---|
923 | if (cbSpaceLeft <= 0)
|
---|
924 | break;
|
---|
925 | cBytes = ssh_channel_read_timeout(channel, pszBuffer, cbSpaceLeft, 0, 60000 /* ms */); /* Is 60 seconds really enough? */
|
---|
926 | }
|
---|
927 | if (cBytes < 0)
|
---|
928 | {
|
---|
929 | LogRel(("%s: while executing '%s' ssh_channel_read_timeout returned error\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
930 | Log(("%s: while executing '%s' ssh_channel_read_timeout returned error\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
931 | rc = VERR_INTERNAL_ERROR;
|
---|
932 | }
|
---|
933 | else
|
---|
934 | {
|
---|
935 | /* Make sure the buffer is terminated. */
|
---|
936 | if (cbStdOut < DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE)
|
---|
937 | if (cbStdOut > 1 && pThis->pszOutputBuffer[cbStdOut - 1] == '\n')
|
---|
938 | pThis->pszOutputBuffer[cbStdOut - 1] = 0; /* Trim newline */
|
---|
939 | else
|
---|
940 | pThis->pszOutputBuffer[cbStdOut] = 0;
|
---|
941 | else
|
---|
942 | pThis->pszOutputBuffer[DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE - 1] = 0; /* No choice but to eat up last character. Could have returned warning though. */
|
---|
943 | if (cbStdOut == 0)
|
---|
944 | Log(("%s: received no output from remote console\n", pThis->pszInstance));
|
---|
945 | else
|
---|
946 | Log(("%s: received output from remote console:\n%s\n", pThis->pszInstance, pThis->pszOutputBuffer));
|
---|
947 | rc = VINF_SUCCESS;
|
---|
948 |
|
---|
949 | char *pszErrorBuffer = (char *)RTMemAlloc(DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE);
|
---|
950 | if (pszErrorBuffer == NULL)
|
---|
951 | {
|
---|
952 | LogRel(("%s: Failed to allocate error buffer\n", pThis->pszInstance));
|
---|
953 | rc = VERR_INTERNAL_ERROR;
|
---|
954 | }
|
---|
955 | else
|
---|
956 | {
|
---|
957 | /* Report errors if there were any */
|
---|
958 | cBytes = ssh_channel_read_timeout(channel, pszErrorBuffer, DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE, 1, 0); /* Peek at stderr */
|
---|
959 | if (cBytes > 0)
|
---|
960 | {
|
---|
961 | LogRel(("%s: WARNING! While executing '%s' remote console reported errors:\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
962 | Log(("%s: WARNING! While executing '%s' remote console reported errors:\n", pThis->pszInstance, pThis->pszCommandBuffer));
|
---|
963 | }
|
---|
964 | while (cBytes > 0)
|
---|
965 | {
|
---|
966 | LogRel(("%.*s", cBytes, pszErrorBuffer));
|
---|
967 | Log(("%.*s", cBytes, pszErrorBuffer));
|
---|
968 | cBytes = ssh_channel_read_timeout(channel, pszErrorBuffer, DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE, 1, 1000); /* Wait for a second for more error output */
|
---|
969 | }
|
---|
970 | RTMemFree(pszErrorBuffer);
|
---|
971 | }
|
---|
972 | }
|
---|
973 | ssh_channel_send_eof(channel);
|
---|
974 | }
|
---|
975 | ssh_channel_close(channel);
|
---|
976 | }
|
---|
977 | ssh_channel_free(channel);
|
---|
978 |
|
---|
979 | return VINF_SUCCESS;
|
---|
980 | }
|
---|
981 |
|
---|
982 |
|
---|
983 | static int drvCloudTunnelCloudInstanceInitialConfig(PDRVCLOUDTUNNEL pThis)
|
---|
984 | {
|
---|
985 | LogFlow(("%s: configuring cloud instance...\n", pThis->pszInstance));
|
---|
986 |
|
---|
987 | int rc = drvCloudTunnelExecuteRemoteCommand(pThis, "python3 -c \"from oci_utils.vnicutils import VNICUtils; cfg = VNICUtils().get_network_config(); print('CONFIG:', [i['IFACE'] for i in cfg if 'IS_PRIMARY' in i][0], [i['IFACE']+' '+i['VIRTRT'] for i in cfg if not 'IS_PRIMARY' in i][0])\"");
|
---|
988 | if (RT_FAILURE(rc))
|
---|
989 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
990 | N_("Failed to get network config via console channel"));
|
---|
991 | else
|
---|
992 | {
|
---|
993 | char *pszConfig = RTStrStr(pThis->pszOutputBuffer, "CONFIG: ");
|
---|
994 | if (!pszConfig)
|
---|
995 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
996 | N_("Failed to parse network config"));
|
---|
997 | else
|
---|
998 | {
|
---|
999 | char **ppapszTokens;
|
---|
1000 | size_t cTokens;
|
---|
1001 | rc = RTStrSplit(pszConfig + 8, DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE - (pszConfig - pThis->pszOutputBuffer) - 8,
|
---|
1002 | " ", &ppapszTokens, &cTokens);
|
---|
1003 | if (RT_SUCCESS(rc))
|
---|
1004 | {
|
---|
1005 | /*
|
---|
1006 | * There should be exactly three tokens:
|
---|
1007 | * 1) Primary network interface name;
|
---|
1008 | * 2) Secondary network interface name;
|
---|
1009 | * 3) Secondary network gateway address.
|
---|
1010 | */
|
---|
1011 | if (cTokens != 3)
|
---|
1012 | Log(("%s: Got %u tokes instead of three while parsing '%s'\n", pThis->pszInstance, cTokens, pThis->pszOutputBuffer));
|
---|
1013 | else
|
---|
1014 | {
|
---|
1015 | char *pszSecondaryInterface = NULL;
|
---|
1016 | char *pszSecondaryGateway = NULL;
|
---|
1017 |
|
---|
1018 | if (pThis->pszCloudPrimaryInterface)
|
---|
1019 | RTStrFree(pThis->pszCloudPrimaryInterface);
|
---|
1020 | pThis->pszCloudPrimaryInterface = RTStrDup(ppapszTokens[0]);
|
---|
1021 | pszSecondaryInterface = ppapszTokens[1];
|
---|
1022 | pszSecondaryGateway = ppapszTokens[2];
|
---|
1023 | Log(("%s: primary=%s secondary=%s gateway=%s\n", pThis->pszInstance, pThis->pszCloudPrimaryInterface, pszSecondaryInterface, pszSecondaryGateway));
|
---|
1024 |
|
---|
1025 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo oci-network-config -c");
|
---|
1026 | if (RT_SUCCESS(rc))
|
---|
1027 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip tuntap add dev tap0 mod tap user opc");
|
---|
1028 | if (RT_SUCCESS(rc))
|
---|
1029 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo sh -c 'echo \"PermitTunnel yes\" >> /etc/ssh/sshd_config'");
|
---|
1030 | if (RT_SUCCESS(rc))
|
---|
1031 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo kill -SIGHUP $(pgrep -f \"sshd -D\")");
|
---|
1032 | if (RT_SUCCESS(rc))
|
---|
1033 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link add name br0 type bridge");
|
---|
1034 | if (RT_SUCCESS(rc))
|
---|
1035 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link set dev tap0 master br0");
|
---|
1036 | if (RT_SUCCESS(rc))
|
---|
1037 | rc = drvCloudTunnelExecuteRemoteCommandNoOutput(pThis, "sudo ip route change default via %s dev %s", pszSecondaryGateway, pszSecondaryInterface);
|
---|
1038 | if (RT_FAILURE(rc))
|
---|
1039 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1040 | N_("Failed to execute network config command via console channel"));
|
---|
1041 | }
|
---|
1042 |
|
---|
1043 | for (size_t i = 0; i < cTokens; i++)
|
---|
1044 | RTStrFree(ppapszTokens[i]);
|
---|
1045 | RTMemFree(ppapszTokens);
|
---|
1046 | }
|
---|
1047 | }
|
---|
1048 | }
|
---|
1049 |
|
---|
1050 | return rc;
|
---|
1051 | }
|
---|
1052 |
|
---|
1053 |
|
---|
1054 | static int drvCloudTunnelCloudInstanceFinalConfig(PDRVCLOUDTUNNEL pThis)
|
---|
1055 | {
|
---|
1056 | if (pThis->pszCloudPrimaryInterface == NULL)
|
---|
1057 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1058 | N_("Failed to finalize cloud instance config because of unknown primary interface name!"));
|
---|
1059 |
|
---|
1060 | LogFlow(("%s: finalizing cloud instance configuration...\n", pThis->pszInstance));
|
---|
1061 |
|
---|
1062 | int rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link set dev %s down", pThis->pszCloudPrimaryInterface);
|
---|
1063 | if (RT_SUCCESS(rc))
|
---|
1064 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link set dev %s address %RTmac", pThis->pszCloudPrimaryInterface, pThis->targetMac.au8);
|
---|
1065 | if (RT_SUCCESS(rc))
|
---|
1066 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ifconfig %s 0.0.0.0", pThis->pszCloudPrimaryInterface); /* Make sure no IP is configured on primary */
|
---|
1067 | if (RT_SUCCESS(rc))
|
---|
1068 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link set dev %s master br0", pThis->pszCloudPrimaryInterface);
|
---|
1069 | if (RT_SUCCESS(rc))
|
---|
1070 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link set dev %s up", pThis->pszCloudPrimaryInterface);
|
---|
1071 | if (RT_SUCCESS(rc))
|
---|
1072 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link set dev tap0 up");
|
---|
1073 | if (RT_SUCCESS(rc))
|
---|
1074 | rc = drvCloudTunnelExecuteRemoteCommand(pThis, "sudo ip link set dev br0 up");
|
---|
1075 | if (RT_FAILURE(rc))
|
---|
1076 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1077 | N_("Failed to execute network config command via console channel"));
|
---|
1078 |
|
---|
1079 | return rc;
|
---|
1080 | }
|
---|
1081 |
|
---|
1082 |
|
---|
1083 | static int drvCloudTunnelOpenTunnelChannel(PDRVCLOUDTUNNEL pThis)
|
---|
1084 | {
|
---|
1085 | LogFlow(("%s: opening tunnel channel...\n", pThis->pszInstance));
|
---|
1086 | pThis->pSshChannel = ssh_channel_new(pThis->pSshSession);
|
---|
1087 | if (pThis->pSshChannel == NULL)
|
---|
1088 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1089 | N_("Failed to allocate new channel"));
|
---|
1090 | int rc = ssh_channel_open_tunnel(pThis->pSshChannel, 0);
|
---|
1091 | if (rc < 0)
|
---|
1092 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1093 | N_("Failed to open tunnel channel"));
|
---|
1094 | else
|
---|
1095 | {
|
---|
1096 | /* Set packet receive callback. */
|
---|
1097 | rc = ssh_set_channel_callbacks(pThis->pSshChannel, &pThis->Callbacks);
|
---|
1098 | if (rc != SSH_OK)
|
---|
1099 | rc = PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1100 | N_("Failed to set packet receive callback"));
|
---|
1101 | }
|
---|
1102 |
|
---|
1103 | return rc;
|
---|
1104 | }
|
---|
1105 |
|
---|
1106 |
|
---|
1107 | static void closeTunnelChannel(PDRVCLOUDTUNNEL pThis)
|
---|
1108 | {
|
---|
1109 | if (pThis->pSshChannel)
|
---|
1110 | {
|
---|
1111 | LogFlow(("%s: closing tunnel channel %p\n", pThis->pszInstance, pThis->pSshChannel));
|
---|
1112 | ssh_channel_close(pThis->pSshChannel);
|
---|
1113 | ssh_channel_free(pThis->pSshChannel);
|
---|
1114 | pThis->pSshChannel = NULL;
|
---|
1115 | }
|
---|
1116 | }
|
---|
1117 |
|
---|
1118 |
|
---|
1119 | static int drvCloudTunnelStartIoThread(PDRVCLOUDTUNNEL pThis)
|
---|
1120 | {
|
---|
1121 | LogFlow(("%s: starting I/O thread...\n", pThis->pszInstance));
|
---|
1122 | int rc = createConnectedSockets(pThis);
|
---|
1123 | if (RT_FAILURE(rc))
|
---|
1124 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1125 | N_("CloudTunnel: Failed to create a pair of connected sockets"));
|
---|
1126 |
|
---|
1127 | /*
|
---|
1128 | * Start the cloud I/O thread.
|
---|
1129 | */
|
---|
1130 | rc = PDMDrvHlpThreadCreate(pThis->pDrvIns, &pThis->pIoThread,
|
---|
1131 | pThis, drvCloudTunnelIoThread, drvCloudTunnelIoWakeup,
|
---|
1132 | 64 * _1K, RTTHREADTYPE_IO, pThis->pszInstanceIo);
|
---|
1133 | if (RT_FAILURE(rc))
|
---|
1134 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1135 | N_("CloudTunnel: Failed to start I/O thread"));
|
---|
1136 |
|
---|
1137 | return rc;
|
---|
1138 | }
|
---|
1139 |
|
---|
1140 | static void drvCloudTunnelStopIoThread(PDRVCLOUDTUNNEL pThis)
|
---|
1141 | {
|
---|
1142 | if (pThis->pIoThread)
|
---|
1143 | {
|
---|
1144 | LogFlow(("%s: stopping I/O thread...\n", pThis->pszInstance));
|
---|
1145 | int rc = PDMDrvHlpThreadDestroy(pThis->pDrvIns, pThis->pIoThread, NULL);
|
---|
1146 | AssertRC(rc);
|
---|
1147 | pThis->pIoThread = NULL;
|
---|
1148 | }
|
---|
1149 | destroyConnectedSockets(pThis);
|
---|
1150 |
|
---|
1151 | }
|
---|
1152 |
|
---|
1153 | static int destroyTunnel(PDRVCLOUDTUNNEL pThis)
|
---|
1154 | {
|
---|
1155 | if (pThis->pSshChannel)
|
---|
1156 | {
|
---|
1157 | int rc = ssh_remove_channel_callbacks(pThis->pSshChannel, &pThis->Callbacks);
|
---|
1158 | if (rc != SSH_OK)
|
---|
1159 | LogRel(("%s: WARNING! Failed to remove tunnel channel callbacks.\n", pThis->pszInstance));
|
---|
1160 | }
|
---|
1161 | drvCloudTunnelStopIoThread(pThis);
|
---|
1162 | closeTunnelChannel(pThis);
|
---|
1163 | ssh_disconnect(pThis->pSshSession);
|
---|
1164 | ssh_free(pThis->pSshSession);
|
---|
1165 | pThis->pSshSession = NULL;
|
---|
1166 | return VINF_SUCCESS;
|
---|
1167 | }
|
---|
1168 |
|
---|
1169 |
|
---|
1170 | static int drvCloudTunnelNewSession(PDRVCLOUDTUNNEL pThis, bool fPrimary)
|
---|
1171 | {
|
---|
1172 | pThis->pSshSession = ssh_new();
|
---|
1173 | if (pThis->pSshSession == NULL)
|
---|
1174 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1175 | N_("CloudTunnel: Failed to allocate new SSH session"));
|
---|
1176 | if (ssh_options_set(pThis->pSshSession, SSH_OPTIONS_LOG_VERBOSITY, &pThis->iSshVerbosity) < 0)
|
---|
1177 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1178 | N_("Failed to set SSH_OPTIONS_LOG_VERBOSITY"));
|
---|
1179 | if (ssh_options_set(pThis->pSshSession, SSH_OPTIONS_USER, pThis->pszUser) < 0)
|
---|
1180 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1181 | N_("Failed to set SSH_OPTIONS_USER"));
|
---|
1182 | if (ssh_options_set(pThis->pSshSession, SSH_OPTIONS_HOST, fPrimary ? pThis->pszPrimaryIP : pThis->pszSecondaryIP) < 0)
|
---|
1183 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1184 | N_("Failed to set SSH_OPTIONS_HOST"));
|
---|
1185 |
|
---|
1186 | if (ssh_options_set(pThis->pSshSession, SSH_OPTIONS_TIMEOUT, &pThis->ulTimeoutInSecounds) < 0)
|
---|
1187 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1188 | N_("Failed to set SSH_OPTIONS_TIMEOUT"));
|
---|
1189 |
|
---|
1190 | const char *pcszProxyType = fPrimary ? pThis->pszPrimaryProxyType : pThis->pszSecondaryProxyType;
|
---|
1191 | if (pcszProxyType)
|
---|
1192 | {
|
---|
1193 | char szProxyCmd[1024];
|
---|
1194 |
|
---|
1195 | const char *pcszProxyUser = fPrimary ? pThis->pszPrimaryProxyUser : pThis->pszSecondaryProxyUser;
|
---|
1196 | if (pcszProxyUser)
|
---|
1197 | RTStrPrintf(szProxyCmd, sizeof(szProxyCmd), "#VBoxProxy%s %s %u %s %s",
|
---|
1198 | fPrimary ? pThis->pszPrimaryProxyType : pThis->pszSecondaryProxyType,
|
---|
1199 | fPrimary ? pThis->pszPrimaryProxyHost : pThis->pszSecondaryProxyHost,
|
---|
1200 | fPrimary ? pThis->u16PrimaryProxyPort : pThis->u16SecondaryProxyPort,
|
---|
1201 | fPrimary ? pThis->pszPrimaryProxyUser : pThis->pszSecondaryProxyUser,
|
---|
1202 | fPrimary ? pThis->pszPrimaryProxyPassword : pThis->pszSecondaryProxyPassword);
|
---|
1203 | else
|
---|
1204 | RTStrPrintf(szProxyCmd, sizeof(szProxyCmd), "#VBoxProxy%s %s %u",
|
---|
1205 | fPrimary ? pThis->pszPrimaryProxyType : pThis->pszSecondaryProxyType,
|
---|
1206 | fPrimary ? pThis->pszPrimaryProxyHost : pThis->pszSecondaryProxyHost,
|
---|
1207 | fPrimary ? pThis->u16PrimaryProxyPort : pThis->u16SecondaryProxyPort);
|
---|
1208 | LogRel(("%s: using proxy command '%s'\n", pThis->pszInstance, szProxyCmd));
|
---|
1209 | if (ssh_options_set(pThis->pSshSession, SSH_OPTIONS_PROXYCOMMAND, szProxyCmd) < 0)
|
---|
1210 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1211 | N_("Failed to set SSH_OPTIONS_PROXYCOMMAND"));
|
---|
1212 | }
|
---|
1213 |
|
---|
1214 | int rc = ssh_connect(pThis->pSshSession);
|
---|
1215 | for (int cAttempt = 1; rc != SSH_OK && cAttempt <= 5; cAttempt++)
|
---|
1216 | {
|
---|
1217 | ssh_disconnect(pThis->pSshSession);
|
---|
1218 | /* One more time, just to be sure. */
|
---|
1219 | LogRel(("%s: failed to connect to %s, retrying(#%d)...\n", pThis->pszInstance,
|
---|
1220 | fPrimary ? pThis->pszPrimaryIP : pThis->pszSecondaryIP, cAttempt));
|
---|
1221 | RTThreadSleep(10000); /* Sleep 10 seconds, then retry */
|
---|
1222 | rc = ssh_connect(pThis->pSshSession);
|
---|
1223 | }
|
---|
1224 | if (rc != SSH_OK)
|
---|
1225 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1226 | N_("CloudTunnel: Failed to connect to %s interface"), fPrimary ? "primary" : "secondary");
|
---|
1227 |
|
---|
1228 | rc = ssh_userauth_publickey(pThis->pSshSession, NULL, pThis->SshKey);
|
---|
1229 | if (rc != SSH_AUTH_SUCCESS)
|
---|
1230 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1231 | N_("Failed to authenticate with public key"));
|
---|
1232 |
|
---|
1233 | return VINF_SUCCESS;
|
---|
1234 | }
|
---|
1235 |
|
---|
1236 | static int drvCloudTunnelSwitchToSecondary(PDRVCLOUDTUNNEL pThis)
|
---|
1237 | {
|
---|
1238 | int rc = drvCloudTunnelNewSession(pThis, true /* fPrimary */);
|
---|
1239 | /*
|
---|
1240 | * Establish temporary console channel and configure the cloud instance
|
---|
1241 | * to bridge the tunnel channel to instance's primary interface.
|
---|
1242 | */
|
---|
1243 | if (RT_SUCCESS(rc))
|
---|
1244 | rc = drvCloudTunnelCloudInstanceInitialConfig(pThis);
|
---|
1245 |
|
---|
1246 | ssh_disconnect(pThis->pSshSession);
|
---|
1247 | ssh_free(pThis->pSshSession);
|
---|
1248 | pThis->pSshSession = NULL;
|
---|
1249 |
|
---|
1250 | return rc;
|
---|
1251 | }
|
---|
1252 |
|
---|
1253 |
|
---|
1254 | static int establishTunnel(PDRVCLOUDTUNNEL pThis)
|
---|
1255 | {
|
---|
1256 | int rc = drvCloudTunnelNewSession(pThis, false /* fPrimary */);
|
---|
1257 | if (RT_SUCCESS(rc))
|
---|
1258 | rc = drvCloudTunnelCloudInstanceFinalConfig(pThis);
|
---|
1259 | if (RT_SUCCESS(rc))
|
---|
1260 | rc = drvCloudTunnelOpenTunnelChannel(pThis);
|
---|
1261 | if (RT_SUCCESS(rc))
|
---|
1262 | rc = drvCloudTunnelStartIoThread(pThis);
|
---|
1263 | if (RT_FAILURE(rc))
|
---|
1264 | {
|
---|
1265 | destroyTunnel(pThis);
|
---|
1266 | return rc;
|
---|
1267 | }
|
---|
1268 |
|
---|
1269 | return rc;
|
---|
1270 | }
|
---|
1271 |
|
---|
1272 |
|
---|
1273 | static DECL_NOTHROW(void) drvCloudTunnelSshLogCallback(int priority, const char *function, const char *buffer, void *userdata)
|
---|
1274 | {
|
---|
1275 | PDRVCLOUDTUNNEL pThis = (PDRVCLOUDTUNNEL)userdata;
|
---|
1276 | #ifdef LOG_ENABLED
|
---|
1277 | const char *pcszVerbosity;
|
---|
1278 | switch (priority)
|
---|
1279 | {
|
---|
1280 | case SSH_LOG_WARNING:
|
---|
1281 | pcszVerbosity = "WARNING";
|
---|
1282 | break;
|
---|
1283 | case SSH_LOG_PROTOCOL:
|
---|
1284 | pcszVerbosity = "PROTOCOL";
|
---|
1285 | break;
|
---|
1286 | case SSH_LOG_PACKET:
|
---|
1287 | pcszVerbosity = "PACKET";
|
---|
1288 | break;
|
---|
1289 | case SSH_LOG_FUNCTIONS:
|
---|
1290 | pcszVerbosity = "FUNCTIONS";
|
---|
1291 | break;
|
---|
1292 | default:
|
---|
1293 | pcszVerbosity = "UNKNOWN";
|
---|
1294 | break;
|
---|
1295 | }
|
---|
1296 | Log3(("%s: SSH-%s: %s: %s\n", pThis->pszInstance, pcszVerbosity, function, buffer));
|
---|
1297 | #else
|
---|
1298 | RT_NOREF(priority);
|
---|
1299 | LogRel(("%s: SSH %s: %s\n", pThis->pszInstance, function, buffer));
|
---|
1300 | #endif
|
---|
1301 | }
|
---|
1302 |
|
---|
1303 | /* -=-=-=-=- PDMDRVREG -=-=-=-=- */
|
---|
1304 |
|
---|
1305 | DECLINLINE(void) drvCloudTunnelStrFree(char **ppszString)
|
---|
1306 | {
|
---|
1307 | if (*ppszString)
|
---|
1308 | {
|
---|
1309 | RTStrFree(*ppszString);
|
---|
1310 | *ppszString = NULL;
|
---|
1311 | }
|
---|
1312 | }
|
---|
1313 |
|
---|
1314 | DECLINLINE(void) drvCloudTunnelHeapFree(PPDMDRVINS pDrvIns, char **ppszString)
|
---|
1315 | {
|
---|
1316 | if (*ppszString)
|
---|
1317 | {
|
---|
1318 | PDMDrvHlpMMHeapFree(pDrvIns, *ppszString);
|
---|
1319 | *ppszString = NULL;
|
---|
1320 | }
|
---|
1321 | }
|
---|
1322 |
|
---|
1323 | /**
|
---|
1324 | * Destruct a driver instance.
|
---|
1325 | *
|
---|
1326 | * Most VM resources are freed by the VM. This callback is provided so that any non-VM
|
---|
1327 | * resources can be freed correctly.
|
---|
1328 | *
|
---|
1329 | * @param pDrvIns The driver instance data.
|
---|
1330 | */
|
---|
1331 | static DECLCALLBACK(void) drvCloudTunnelDestruct(PPDMDRVINS pDrvIns)
|
---|
1332 | {
|
---|
1333 | LogFlowFunc(("\n"));
|
---|
1334 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
1335 | PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
|
---|
1336 |
|
---|
1337 | ASMAtomicXchgSize(&pThis->fLinkDown, true);
|
---|
1338 |
|
---|
1339 | destroyTunnel(pThis);
|
---|
1340 |
|
---|
1341 | if (pThis->hIoReqQueue != NIL_RTREQQUEUE)
|
---|
1342 | {
|
---|
1343 | RTReqQueueDestroy(pThis->hIoReqQueue);
|
---|
1344 | pThis->hIoReqQueue = NIL_RTREQQUEUE;
|
---|
1345 | }
|
---|
1346 |
|
---|
1347 | drvCloudTunnelStrFree(&pThis->pszCloudPrimaryInterface);
|
---|
1348 |
|
---|
1349 | drvCloudTunnelHeapFree(pDrvIns, &pThis->pszPrimaryProxyType);
|
---|
1350 | drvCloudTunnelStrFree(&pThis->pszPrimaryProxyHost);
|
---|
1351 | drvCloudTunnelHeapFree(pDrvIns, &pThis->pszPrimaryProxyUser);
|
---|
1352 | drvCloudTunnelStrFree(&pThis->pszPrimaryProxyPassword);
|
---|
1353 |
|
---|
1354 | drvCloudTunnelHeapFree(pDrvIns, &pThis->pszSecondaryProxyType);
|
---|
1355 | drvCloudTunnelStrFree(&pThis->pszSecondaryProxyHost);
|
---|
1356 | drvCloudTunnelHeapFree(pDrvIns, &pThis->pszSecondaryProxyUser);
|
---|
1357 | drvCloudTunnelStrFree(&pThis->pszSecondaryProxyPassword);
|
---|
1358 |
|
---|
1359 | drvCloudTunnelStrFree(&pThis->pszSecondaryIP);
|
---|
1360 | drvCloudTunnelStrFree(&pThis->pszPrimaryIP);
|
---|
1361 | drvCloudTunnelStrFree(&pThis->pszUser);
|
---|
1362 |
|
---|
1363 | drvCloudTunnelStrFree(&pThis->pszInstanceDev);
|
---|
1364 | drvCloudTunnelStrFree(&pThis->pszInstanceIo);
|
---|
1365 | drvCloudTunnelStrFree(&pThis->pszInstance);
|
---|
1366 |
|
---|
1367 | drvCloudTunnelStrFree(&pThis->pszOutputBuffer);
|
---|
1368 | drvCloudTunnelStrFree(&pThis->pszCommandBuffer);
|
---|
1369 |
|
---|
1370 | ssh_key_free(pThis->SshKey);
|
---|
1371 |
|
---|
1372 | ssh_finalize();
|
---|
1373 | //OPENSSL_cleanup();
|
---|
1374 |
|
---|
1375 | // if (pThis->pServer)
|
---|
1376 | // {
|
---|
1377 | // RTUdpServerDestroy(pThis->pServer);
|
---|
1378 | // pThis->pServer = NULL;
|
---|
1379 | // }
|
---|
1380 |
|
---|
1381 | /*
|
---|
1382 | * Kill the xmit lock.
|
---|
1383 | */
|
---|
1384 | if (RTCritSectIsInitialized(&pThis->XmitLock))
|
---|
1385 | RTCritSectDelete(&pThis->XmitLock);
|
---|
1386 |
|
---|
1387 | #ifdef VBOX_WITH_STATISTICS
|
---|
1388 | /*
|
---|
1389 | * Deregister statistics.
|
---|
1390 | */
|
---|
1391 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSent);
|
---|
1392 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktSentBytes);
|
---|
1393 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecv);
|
---|
1394 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatPktRecvBytes);
|
---|
1395 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatTransmit);
|
---|
1396 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatReceive);
|
---|
1397 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatDevRecv);
|
---|
1398 | PDMDrvHlpSTAMDeregister(pDrvIns, &pThis->StatDevRecvWait);
|
---|
1399 | #endif /* VBOX_WITH_STATISTICS */
|
---|
1400 | }
|
---|
1401 |
|
---|
1402 |
|
---|
1403 | /**
|
---|
1404 | * Construct a Cloud tunnel network transport driver instance.
|
---|
1405 | *
|
---|
1406 | * @copydoc FNPDMDRVCONSTRUCT
|
---|
1407 | */
|
---|
1408 | static DECLCALLBACK(int) drvCloudTunnelConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
|
---|
1409 | {
|
---|
1410 | RT_NOREF(fFlags);
|
---|
1411 | PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
|
---|
1412 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
1413 | PCPDMDRVHLPR3 pHlp = pDrvIns->pHlpR3;
|
---|
1414 |
|
---|
1415 | /*
|
---|
1416 | * Init the static parts.
|
---|
1417 | */
|
---|
1418 | pThis->pDrvIns = pDrvIns;
|
---|
1419 | pThis->pszCommandBuffer = NULL;
|
---|
1420 | pThis->pszOutputBuffer = NULL;
|
---|
1421 | pThis->pszInstance = NULL;
|
---|
1422 | pThis->pszPrimaryIP = NULL;
|
---|
1423 | pThis->pszSecondaryIP = NULL;
|
---|
1424 | pThis->pszUser = NULL;
|
---|
1425 | pThis->SshKey = 0;
|
---|
1426 |
|
---|
1427 | /* IBase */
|
---|
1428 | pDrvIns->IBase.pfnQueryInterface = drvCloudTunnelQueryInterface;
|
---|
1429 | /* INetwork */
|
---|
1430 | pThis->INetworkUp.pfnBeginXmit = drvCloudTunnelUp_BeginXmit;
|
---|
1431 | pThis->INetworkUp.pfnAllocBuf = drvCloudTunnelUp_AllocBuf;
|
---|
1432 | pThis->INetworkUp.pfnFreeBuf = drvCloudTunnelUp_FreeBuf;
|
---|
1433 | pThis->INetworkUp.pfnSendBuf = drvCloudTunnelUp_SendBuf;
|
---|
1434 | pThis->INetworkUp.pfnEndXmit = drvCloudTunnelUp_EndXmit;
|
---|
1435 | pThis->INetworkUp.pfnSetPromiscuousMode = drvCloudTunnelUp_SetPromiscuousMode;
|
---|
1436 | pThis->INetworkUp.pfnNotifyLinkChanged = drvCloudTunnelUp_NotifyLinkChanged;
|
---|
1437 |
|
---|
1438 | /* ??? */
|
---|
1439 | pThis->iSocketIn = INVALID_SOCKET;
|
---|
1440 | pThis->iSocketOut = INVALID_SOCKET;
|
---|
1441 | pThis->pSshSession = 0;
|
---|
1442 | pThis->pSshChannel = 0;
|
---|
1443 |
|
---|
1444 | pThis->pDevThread = 0;
|
---|
1445 | pThis->pIoThread = 0;
|
---|
1446 | pThis->hIoReqQueue = NIL_RTREQQUEUE;
|
---|
1447 |
|
---|
1448 | pThis->fLinkDown = false;
|
---|
1449 |
|
---|
1450 | pThis->pszCloudPrimaryInterface = NULL;
|
---|
1451 |
|
---|
1452 | #ifdef VBOX_WITH_STATISTICS
|
---|
1453 | /*
|
---|
1454 | * Statistics.
|
---|
1455 | */
|
---|
1456 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSent, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of sent packets.", "/Drivers/CloudTunnel%d/Packets/Sent", pDrvIns->iInstance);
|
---|
1457 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktSentBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of sent bytes.", "/Drivers/CloudTunnel%d/Bytes/Sent", pDrvIns->iInstance);
|
---|
1458 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecv, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_OCCURENCES, "Number of received packets.", "/Drivers/CloudTunnel%d/Packets/Received", pDrvIns->iInstance);
|
---|
1459 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatPktRecvBytes, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES, "Number of received bytes.", "/Drivers/CloudTunnel%d/Bytes/Received", pDrvIns->iInstance);
|
---|
1460 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatTransmit, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet transmit runs.", "/Drivers/CloudTunnel%d/Transmit", pDrvIns->iInstance);
|
---|
1461 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatReceive, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling packet receive runs.", "/Drivers/CloudTunnel%d/Receive", pDrvIns->iInstance);
|
---|
1462 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatDevRecv, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling device receive runs.", "/Drivers/CloudTunnel%d/DeviceReceive", pDrvIns->iInstance);
|
---|
1463 | PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatDevRecvWait, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_TICKS_PER_CALL, "Profiling device receive waits.", "/Drivers/CloudTunnel%d/DeviceReceiveWait", pDrvIns->iInstance);
|
---|
1464 | #endif /* VBOX_WITH_STATISTICS */
|
---|
1465 |
|
---|
1466 | /*
|
---|
1467 | * Validate the config.
|
---|
1468 | */
|
---|
1469 | PDMDRV_VALIDATE_CONFIG_RETURN(pDrvIns, "SshKey"
|
---|
1470 | "|PrimaryIP"
|
---|
1471 | "|SecondaryIP"
|
---|
1472 | "|TargetMAC"
|
---|
1473 |
|
---|
1474 | "|PrimaryProxyType"
|
---|
1475 | "|PrimaryProxyHost"
|
---|
1476 | "|PrimaryProxyPort"
|
---|
1477 | "|PrimaryProxyUser"
|
---|
1478 | "|PrimaryProxyPassword"
|
---|
1479 | "|SecondaryProxyType"
|
---|
1480 | "|SecondaryProxyHost"
|
---|
1481 | "|SecondaryProxyPort"
|
---|
1482 | "|SecondaryProxyUser"
|
---|
1483 | "|SecondaryProxyPassword"
|
---|
1484 |
|
---|
1485 | ,"");
|
---|
1486 |
|
---|
1487 | /*
|
---|
1488 | * Check that no-one is attached to us.
|
---|
1489 | */
|
---|
1490 | AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
|
---|
1491 | ("Configuration error: Not possible to attach anything to this driver!\n"),
|
---|
1492 | VERR_PDM_DRVINS_NO_ATTACH);
|
---|
1493 |
|
---|
1494 | /*
|
---|
1495 | * Query the network port interface.
|
---|
1496 | */
|
---|
1497 | pThis->pIAboveNet = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMINETWORKDOWN);
|
---|
1498 | if (!pThis->pIAboveNet)
|
---|
1499 | return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE,
|
---|
1500 | N_("Configuration error: The above device/driver didn't export the network port interface"));
|
---|
1501 |
|
---|
1502 | /*
|
---|
1503 | * Read the configuration.
|
---|
1504 | */
|
---|
1505 | int rc;
|
---|
1506 |
|
---|
1507 | char szVal[2048];
|
---|
1508 | RTNETADDRIPV4 tmpAddr;
|
---|
1509 | rc = pHlp->pfnCFGMQueryString(pCfg, "PrimaryIP", szVal, sizeof(szVal));
|
---|
1510 | if (RT_FAILURE(rc))
|
---|
1511 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1512 | N_("DrvCloudTunnel: Configuration error: Querying \"PrimaryIP\" as string failed"));
|
---|
1513 | rc = RTNetStrToIPv4Addr(szVal, &tmpAddr);
|
---|
1514 | if (RT_FAILURE(rc))
|
---|
1515 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1516 | N_("DrvCloudTunnel: Configuration error: \"PrimaryIP\" is not valid"));
|
---|
1517 | else
|
---|
1518 | pThis->pszPrimaryIP = RTStrDup(szVal);
|
---|
1519 |
|
---|
1520 | rc = pHlp->pfnCFGMQueryString(pCfg, "SecondaryIP", szVal, sizeof(szVal));
|
---|
1521 | if (RT_FAILURE(rc))
|
---|
1522 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1523 | N_("DrvCloudTunnel: Configuration error: Querying \"SecondaryIP\" as string failed"));
|
---|
1524 | rc = RTNetStrToIPv4Addr(szVal, &tmpAddr);
|
---|
1525 | if (RT_FAILURE(rc))
|
---|
1526 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1527 | N_("DrvCloudTunnel: Configuration error: \"SecondaryIP\" is not valid"));
|
---|
1528 | else
|
---|
1529 | pThis->pszSecondaryIP = RTStrDup(szVal);
|
---|
1530 | rc = pHlp->pfnCFGMQueryBytes(pCfg, "TargetMAC", pThis->targetMac.au8, sizeof(pThis->targetMac.au8));
|
---|
1531 | if (RT_FAILURE(rc))
|
---|
1532 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1533 | N_("DrvCloudTunnel: Configuration error: Failed to get target MAC address"));
|
---|
1534 | /** @todo In the near future we will want to include proxy settings here! */
|
---|
1535 | // Do we want to pass the user name via CFGM?
|
---|
1536 | pThis->pszUser = RTStrDup("opc");
|
---|
1537 | // Is it safe to expose verbosity via CFGM?
|
---|
1538 | #ifdef LOG_ENABLED
|
---|
1539 | pThis->iSshVerbosity = SSH_LOG_PACKET; //SSH_LOG_FUNCTIONS;
|
---|
1540 | #else
|
---|
1541 | pThis->iSshVerbosity = SSH_LOG_WARNING;
|
---|
1542 | #endif
|
---|
1543 |
|
---|
1544 | pThis->ulTimeoutInSecounds = 30; /* The default 10-second timeout is too short? */
|
---|
1545 |
|
---|
1546 | rc = pHlp->pfnCFGMQueryPassword(pCfg, "SshKey", szVal, sizeof(szVal));
|
---|
1547 | if (RT_FAILURE(rc))
|
---|
1548 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1549 | N_("DrvCloudTunnel: Configuration error: Querying \"SshKey\" as password failed"));
|
---|
1550 | rc = ssh_pki_import_privkey_base64(szVal, NULL, NULL, NULL, &pThis->SshKey);
|
---|
1551 | RTMemWipeThoroughly(szVal, sizeof(szVal), 10);
|
---|
1552 | if (rc != SSH_OK)
|
---|
1553 | return PDMDRV_SET_ERROR(pDrvIns, VERR_INVALID_BASE64_ENCODING,
|
---|
1554 | N_("DrvCloudTunnel: Configuration error: Converting \"SshKey\" from base64 failed"));
|
---|
1555 |
|
---|
1556 | /* PrimaryProxyType is optional */
|
---|
1557 | rc = pHlp->pfnCFGMQueryStringAllocDef(pCfg, "PrimaryProxyType", &pThis->pszPrimaryProxyType, NULL);
|
---|
1558 | if (RT_FAILURE(rc))
|
---|
1559 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1560 | N_("DrvCloudTunnel: Configuration error: Querying \"PrimaryProxyType\" as string failed"));
|
---|
1561 | if (pThis->pszPrimaryProxyType)
|
---|
1562 | {
|
---|
1563 | rc = pHlp->pfnCFGMQueryString(pCfg, "PrimaryProxyHost", szVal, sizeof(szVal));
|
---|
1564 | if (RT_FAILURE(rc))
|
---|
1565 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1566 | N_("DrvCloudTunnel: Configuration error: Querying \"PrimaryProxyHost\" as string failed"));
|
---|
1567 | rc = RTNetStrToIPv4Addr(szVal, &tmpAddr);
|
---|
1568 | if (RT_FAILURE(rc))
|
---|
1569 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1570 | N_("DrvCloudTunnel: Configuration error: \"PrimaryProxyHost\" is not valid"));
|
---|
1571 | else
|
---|
1572 | pThis->pszPrimaryProxyHost = RTStrDup(szVal);
|
---|
1573 |
|
---|
1574 | uint64_t u64Val;
|
---|
1575 | rc = pHlp->pfnCFGMQueryInteger(pCfg, "PrimaryProxyPort", &u64Val);
|
---|
1576 | if (RT_FAILURE(rc))
|
---|
1577 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1578 | N_("DrvCloudTunnel: Configuration error: Querying \"PrimaryProxyPort\" as integer failed"));
|
---|
1579 | if (u64Val > 0xFFFF)
|
---|
1580 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1581 | N_("DrvCloudTunnel: Configuration error: \"PrimaryProxyPort\" is not valid"));
|
---|
1582 | pThis->u16PrimaryProxyPort = (uint16_t)u64Val;
|
---|
1583 |
|
---|
1584 | /* PrimaryProxyUser is optional */
|
---|
1585 | rc = pHlp->pfnCFGMQueryStringAllocDef(pCfg, "PrimaryProxyUser", &pThis->pszPrimaryProxyUser, NULL);
|
---|
1586 | if (RT_FAILURE(rc))
|
---|
1587 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1588 | N_("DrvCloudTunnel: Configuration error: Querying \"PrimaryProxyUser\" as string failed"));
|
---|
1589 | /* PrimaryProxyPassword must be present if PrimaryProxyUser is present */
|
---|
1590 | if (pThis->pszPrimaryProxyUser)
|
---|
1591 | {
|
---|
1592 | rc = pHlp->pfnCFGMQueryPassword(pCfg, "PrimaryProxyPassword", szVal, sizeof(szVal));
|
---|
1593 | if (RT_FAILURE(rc))
|
---|
1594 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1595 | N_("DrvCloudTunnel: Configuration error: Querying \"PrimaryProxyPassword\" as string failed"));
|
---|
1596 | pThis->pszPrimaryProxyPassword = RTStrDup(szVal);
|
---|
1597 | }
|
---|
1598 | }
|
---|
1599 |
|
---|
1600 | /* SecondaryProxyType is optional */
|
---|
1601 | rc = pHlp->pfnCFGMQueryStringAllocDef(pCfg, "SecondaryProxyType", &pThis->pszSecondaryProxyType, NULL);
|
---|
1602 | if (RT_FAILURE(rc))
|
---|
1603 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1604 | N_("DrvCloudTunnel: Configuration error: Querying \"SecondaryProxyType\" as string failed"));
|
---|
1605 | if (pThis->pszSecondaryProxyType)
|
---|
1606 | {
|
---|
1607 | if (RT_FAILURE(rc))
|
---|
1608 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1609 | N_("DrvCloudTunnel: Configuration error: Querying \"SecondaryProxyType\" as string failed"));
|
---|
1610 |
|
---|
1611 | rc = pHlp->pfnCFGMQueryString(pCfg, "SecondaryProxyHost", szVal, sizeof(szVal));
|
---|
1612 | if (RT_FAILURE(rc))
|
---|
1613 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1614 | N_("DrvCloudTunnel: Configuration error: Querying \"SecondaryProxyHost\" as string failed"));
|
---|
1615 | rc = RTNetStrToIPv4Addr(szVal, &tmpAddr);
|
---|
1616 | if (RT_FAILURE(rc))
|
---|
1617 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1618 | N_("DrvCloudTunnel: Configuration error: \"SecondaryProxyHost\" is not valid"));
|
---|
1619 | else
|
---|
1620 | pThis->pszSecondaryProxyHost = RTStrDup(szVal);
|
---|
1621 |
|
---|
1622 | uint64_t u64Val;
|
---|
1623 | rc = pHlp->pfnCFGMQueryInteger(pCfg, "SecondaryProxyPort", &u64Val);
|
---|
1624 | if (RT_FAILURE(rc))
|
---|
1625 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1626 | N_("DrvCloudTunnel: Configuration error: Querying \"SecondaryProxyPort\" as integer failed"));
|
---|
1627 | if (u64Val > 0xFFFF)
|
---|
1628 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1629 | N_("DrvCloudTunnel: Configuration error: \"SecondaryProxyPort\" is not valid"));
|
---|
1630 | pThis->u16SecondaryProxyPort = (uint16_t)u64Val;
|
---|
1631 |
|
---|
1632 | /* SecondaryProxyUser is optional */
|
---|
1633 | rc = pHlp->pfnCFGMQueryStringAllocDef(pCfg, "SecondaryProxyUser", &pThis->pszSecondaryProxyUser, NULL);
|
---|
1634 | if (RT_FAILURE(rc))
|
---|
1635 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1636 | N_("DrvCloudTunnel: Configuration error: Querying \"SecondaryProxyUser\" as string failed"));
|
---|
1637 | /* SecondaryProxyPassword must be present if SecondaryProxyUser is present */
|
---|
1638 | if (pThis->pszSecondaryProxyUser)
|
---|
1639 | {
|
---|
1640 | rc = pHlp->pfnCFGMQueryPassword(pCfg, "SecondaryProxyPassword", szVal, sizeof(szVal));
|
---|
1641 | if (RT_FAILURE(rc))
|
---|
1642 | return PDMDRV_SET_ERROR(pDrvIns, rc,
|
---|
1643 | N_("DrvCloudTunnel: Configuration error: Querying \"SecondaryProxyPassword\" as string failed"));
|
---|
1644 | pThis->pszSecondaryProxyPassword = RTStrDup(szVal);
|
---|
1645 | }
|
---|
1646 | }
|
---|
1647 |
|
---|
1648 | pThis->pszCommandBuffer = (char *)RTMemAlloc(DRVCLOUDTUNNEL_COMMAND_BUFFER_SIZE);
|
---|
1649 | if (pThis->pszCommandBuffer == NULL)
|
---|
1650 | return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_HIF_OPEN_FAILED,
|
---|
1651 | N_("DrvCloudTunnel: Failed to allocate command buffer"));
|
---|
1652 | pThis->pszOutputBuffer = (char *)RTMemAlloc(DRVCLOUDTUNNEL_OUTPUT_BUFFER_SIZE);
|
---|
1653 | if (pThis->pszOutputBuffer == NULL)
|
---|
1654 | return PDMDRV_SET_ERROR(pDrvIns, VERR_PDM_HIF_OPEN_FAILED,
|
---|
1655 | N_("DrvCloudTunnel: Failed to allocate output buffer"));
|
---|
1656 | /*
|
---|
1657 | * Create unique instance name for logging.
|
---|
1658 | */
|
---|
1659 | rc = RTStrAPrintf(&pThis->pszInstance, "CT#%d", pDrvIns->iInstance);
|
---|
1660 | AssertRC(rc);
|
---|
1661 |
|
---|
1662 | LogRel(("%s: primary=%s secondary=%s target-mac=%RTmac\n", pThis->pszInstance, pThis->pszPrimaryIP, pThis->pszSecondaryIP, pThis->targetMac.au8));
|
---|
1663 |
|
---|
1664 | /*
|
---|
1665 | * Create unique thread name for cloud I/O.
|
---|
1666 | */
|
---|
1667 | rc = RTStrAPrintf(&pThis->pszInstanceIo, "CTunIO%d", pDrvIns->iInstance);
|
---|
1668 | AssertRC(rc);
|
---|
1669 |
|
---|
1670 | /*
|
---|
1671 | * Create unique thread name for device receive function.
|
---|
1672 | */
|
---|
1673 | rc = RTStrAPrintf(&pThis->pszInstanceDev, "CTunDev%d", pDrvIns->iInstance);
|
---|
1674 | AssertRC(rc);
|
---|
1675 |
|
---|
1676 | /*
|
---|
1677 | * Create the transmit lock.
|
---|
1678 | */
|
---|
1679 | rc = RTCritSectInit(&pThis->XmitLock);
|
---|
1680 | AssertRCReturn(rc, rc);
|
---|
1681 |
|
---|
1682 | /*
|
---|
1683 | * Create the request queue for I/O requests.
|
---|
1684 | */
|
---|
1685 | rc = RTReqQueueCreate(&pThis->hIoReqQueue);
|
---|
1686 | AssertLogRelRCReturn(rc, rc);
|
---|
1687 |
|
---|
1688 | /*
|
---|
1689 | * Create the request queue for attached device requests.
|
---|
1690 | */
|
---|
1691 | rc = RTReqQueueCreate(&pThis->hDevReqQueue);
|
---|
1692 | AssertLogRelRCReturn(rc, rc);
|
---|
1693 |
|
---|
1694 | /*
|
---|
1695 | * Start the device output thread.
|
---|
1696 | */
|
---|
1697 | rc = PDMDrvHlpThreadCreate(pThis->pDrvIns, &pThis->pDevThread,
|
---|
1698 | pThis, drvCloudTunnelDevThread, drvCloudTunnelDevWakeup,
|
---|
1699 | 64 * _1K, RTTHREADTYPE_IO, pThis->pszInstanceDev);
|
---|
1700 | if (RT_FAILURE(rc))
|
---|
1701 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1702 | N_("CloudTunnel: Failed to start device thread"));
|
---|
1703 |
|
---|
1704 | rc = ssh_init();
|
---|
1705 | if (rc != SSH_OK)
|
---|
1706 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1707 | N_("CloudTunnel: Failed to initialize libssh"));
|
---|
1708 |
|
---|
1709 | memset(&pThis->Callbacks, 0, sizeof(pThis->Callbacks));
|
---|
1710 | #ifdef PACKET_CAPTURE_ENABLED
|
---|
1711 | pThis->Callbacks.channel_data_function = drvCloudTunnelReceiveCallbackWithPacketCapture;
|
---|
1712 | #else
|
---|
1713 | pThis->Callbacks.channel_data_function = drvCloudTunnelReceiveCallback;
|
---|
1714 | #endif
|
---|
1715 | pThis->Callbacks.userdata = pThis;
|
---|
1716 | pThis->Callbacks.channel_write_wontblock_function = channelWriteWontblockCallback;
|
---|
1717 | ssh_callbacks_init(&pThis->Callbacks);
|
---|
1718 |
|
---|
1719 | rc = ssh_set_log_callback(drvCloudTunnelSshLogCallback);
|
---|
1720 | if (rc != SSH_OK)
|
---|
1721 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1722 | N_("CloudTunnel: Failed to set libssh log callback"));
|
---|
1723 | rc = ssh_set_log_userdata(pThis);
|
---|
1724 | if (rc != SSH_OK)
|
---|
1725 | return PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1726 | N_("CloudTunnel: Failed to set libssh log userdata"));
|
---|
1727 |
|
---|
1728 | rc = drvCloudTunnelSwitchToSecondary(pThis);
|
---|
1729 | if (RT_SUCCESS(rc))
|
---|
1730 | rc = establishTunnel(pThis);
|
---|
1731 |
|
---|
1732 | return rc;
|
---|
1733 | }
|
---|
1734 |
|
---|
1735 |
|
---|
1736 | #if 0
|
---|
1737 | /**
|
---|
1738 | * Suspend notification.
|
---|
1739 | *
|
---|
1740 | * @param pDrvIns The driver instance.
|
---|
1741 | */
|
---|
1742 | static DECLCALLBACK(void) drvCloudTunnelSuspend(PPDMDRVINS pDrvIns)
|
---|
1743 | {
|
---|
1744 | LogFlowFunc(("\n"));
|
---|
1745 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
1746 |
|
---|
1747 | RT_NOREF(pThis);
|
---|
1748 | // if (pThis->pServer)
|
---|
1749 | // {
|
---|
1750 | // RTUdpServerDestroy(pThis->pServer);
|
---|
1751 | // pThis->pServer = NULL;
|
---|
1752 | // }
|
---|
1753 | }
|
---|
1754 |
|
---|
1755 |
|
---|
1756 | /**
|
---|
1757 | * Resume notification.
|
---|
1758 | *
|
---|
1759 | * @param pDrvIns The driver instance.
|
---|
1760 | */
|
---|
1761 | static DECLCALLBACK(void) drvCloudTunnelResume(PPDMDRVINS pDrvIns)
|
---|
1762 | {
|
---|
1763 | LogFlowFunc(("\n"));
|
---|
1764 | PDRVCLOUDTUNNEL pThis = PDMINS_2_DATA(pDrvIns, PDRVCLOUDTUNNEL);
|
---|
1765 |
|
---|
1766 | int rc = RTUdpServerCreate("", pThis->uSrcPort, RTTHREADTYPE_IO, pThis->pszInstance,
|
---|
1767 | drvCloudTunnelReceive, pDrvIns, &pThis->pServer);
|
---|
1768 | if (RT_FAILURE(rc))
|
---|
1769 | PDMDrvHlpVMSetError(pThis->pDrvIns, VERR_PDM_HIF_OPEN_FAILED, RT_SRC_POS,
|
---|
1770 | N_("CloudTunnel: Failed to start the Cloud tunnel server"));
|
---|
1771 |
|
---|
1772 | }
|
---|
1773 | #endif
|
---|
1774 |
|
---|
1775 | /**
|
---|
1776 | * Cloud tunnel network transport driver registration record.
|
---|
1777 | */
|
---|
1778 | const PDMDRVREG g_DrvCloudTunnel =
|
---|
1779 | {
|
---|
1780 | /* u32Version */
|
---|
1781 | PDM_DRVREG_VERSION,
|
---|
1782 | /* szName */
|
---|
1783 | "CloudTunnel",
|
---|
1784 | /* szRCMod */
|
---|
1785 | "",
|
---|
1786 | /* szR0Mod */
|
---|
1787 | "",
|
---|
1788 | /* pszDescription */
|
---|
1789 | "Cloud Tunnel Network Transport Driver",
|
---|
1790 | /* fFlags */
|
---|
1791 | PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
|
---|
1792 | /* fClass. */
|
---|
1793 | PDM_DRVREG_CLASS_NETWORK,
|
---|
1794 | /* cMaxInstances */
|
---|
1795 | ~0U,
|
---|
1796 | /* cbInstance */
|
---|
1797 | sizeof(DRVCLOUDTUNNEL),
|
---|
1798 | /* pfnConstruct */
|
---|
1799 | drvCloudTunnelConstruct,
|
---|
1800 | /* pfnDestruct */
|
---|
1801 | drvCloudTunnelDestruct,
|
---|
1802 | /* pfnRelocate */
|
---|
1803 | NULL,
|
---|
1804 | /* pfnIOCtl */
|
---|
1805 | NULL,
|
---|
1806 | /* pfnPowerOn */
|
---|
1807 | NULL,
|
---|
1808 | /* pfnReset */
|
---|
1809 | NULL,
|
---|
1810 | /* pfnSuspend */
|
---|
1811 | NULL, // drvCloudTunnelSuspend,
|
---|
1812 | /* pfnResume */
|
---|
1813 | NULL, // drvCloudTunnelResume,
|
---|
1814 | /* pfnAttach */
|
---|
1815 | NULL,
|
---|
1816 | /* pfnDetach */
|
---|
1817 | NULL,
|
---|
1818 | /* pfnPowerOff */
|
---|
1819 | NULL,
|
---|
1820 | /* pfnSoftReset */
|
---|
1821 | NULL,
|
---|
1822 | /* u32EndVersion */
|
---|
1823 | PDM_DRVREG_VERSION
|
---|
1824 | };
|
---|
1825 |
|
---|