VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestCtrl.cpp@ 62521

Last change on this file since 62521 was 62521, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 44.4 KB
Line 
1/* $Id: VBoxGuestR3LibGuestCtrl.cpp 62521 2016-07-22 19:16:33Z vboxsync $ */
2/** @file
3 * VBoxGuestR3Lib - Ring-3 Support Library for VirtualBox guest additions, guest control.
4 */
5
6/*
7 * Copyright (C) 2010-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#include <iprt/string.h>
32#include <iprt/mem.h>
33#include <iprt/assert.h>
34#include <iprt/cpp/autores.h>
35#include <iprt/stdarg.h>
36#include <VBox/log.h>
37#include <VBox/HostServices/GuestControlSvc.h>
38
39#include "VBGLR3Internal.h"
40
41using namespace guestControl;
42
43
44/**
45 * Connects to the guest control service.
46 *
47 * @returns VBox status code
48 * @param puClientId Where to put The client ID on success. The client ID
49 * must be passed to all the other calls to the service.
50 */
51VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *puClientId)
52{
53 VBoxGuestHGCMConnectInfo Info;
54 Info.result = VERR_WRONG_ORDER;
55 Info.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
56 RT_ZERO(Info.Loc.u);
57 strcpy(Info.Loc.u.host.achName, "VBoxGuestControlSvc");
58 Info.u32ClientID = UINT32_MAX; /* try make valgrind shut up. */
59
60 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CONNECT, &Info, sizeof(Info));
61 if (RT_SUCCESS(rc))
62 {
63 rc = Info.result;
64 if (RT_SUCCESS(rc))
65 *puClientId = Info.u32ClientID;
66 }
67 return rc;
68}
69
70
71/**
72 * Disconnect from the guest control service.
73 *
74 * @returns VBox status code.
75 * @param uClientId The client ID returned by VbglR3GuestCtrlConnect().
76 */
77VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t uClientId)
78{
79 VBoxGuestHGCMDisconnectInfo Info;
80 Info.result = VERR_WRONG_ORDER;
81 Info.u32ClientID = uClientId;
82
83 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));
84 if (RT_SUCCESS(rc))
85 rc = Info.result;
86 return rc;
87}
88
89
90/**
91 * Waits until a new host message arrives.
92 * This will block until a message becomes available.
93 *
94 * @returns VBox status code.
95 * @param uClientId The client ID returned by VbglR3GuestCtrlConnect().
96 * @param puMsg Where to store the message id.
97 * @param puNumParms Where to store the number of parameters which will be received
98 * in a second call to the host.
99 */
100VBGLR3DECL(int) VbglR3GuestCtrlMsgWaitFor(uint32_t uClientId, uint32_t *puMsg, uint32_t *puNumParms)
101{
102 AssertPtrReturn(puMsg, VERR_INVALID_POINTER);
103 AssertPtrReturn(puNumParms, VERR_INVALID_POINTER);
104
105 HGCMMsgCmdWaitFor Msg;
106
107 Msg.hdr.result = VERR_WRONG_ORDER;
108 Msg.hdr.u32ClientID = uClientId;
109 Msg.hdr.u32Function = GUEST_MSG_WAIT; /* Tell the host we want our next command. */
110 Msg.hdr.cParms = 2; /* Just peek for the next message! */
111
112 VbglHGCMParmUInt32Set(&Msg.msg, 0);
113 VbglHGCMParmUInt32Set(&Msg.num_parms, 0);
114
115 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
116 if (RT_SUCCESS(rc))
117 {
118 rc = VbglHGCMParmUInt32Get(&Msg.msg, puMsg);
119 if (RT_SUCCESS(rc))
120 {
121 rc = VbglHGCMParmUInt32Get(&Msg.num_parms, puNumParms);
122 if (RT_SUCCESS(rc))
123 rc = Msg.hdr.result;
124 /* Ok, so now we know what message type and how much parameters there are. */
125 }
126 }
127 return rc;
128}
129
130
131/**
132 * Asks the host guest control service to set a command filter to this
133 * client so that it only will receive certain commands in the future.
134 * The filter(s) are a bitmask for the context IDs, served from the host.
135 *
136 * @return IPRT status code.
137 * @param uClientId The client ID returned by VbglR3GuestCtrlConnect().
138 * @param uValue The value to filter messages for.
139 * @param uMaskAdd Filter mask to add.
140 * @param uMaskRemove Filter mask to remove.
141 */
142VBGLR3DECL(int) VbglR3GuestCtrlMsgFilterSet(uint32_t uClientId, uint32_t uValue,
143 uint32_t uMaskAdd, uint32_t uMaskRemove)
144{
145 HGCMMsgCmdFilterSet Msg;
146
147 Msg.hdr.result = VERR_WRONG_ORDER;
148 Msg.hdr.u32ClientID = uClientId;
149 Msg.hdr.u32Function = GUEST_MSG_FILTER_SET; /* Tell the host we want to set a filter. */
150 Msg.hdr.cParms = 4;
151
152 VbglHGCMParmUInt32Set(&Msg.value, uValue);
153 VbglHGCMParmUInt32Set(&Msg.mask_add, uMaskAdd);
154 VbglHGCMParmUInt32Set(&Msg.mask_remove, uMaskRemove);
155 VbglHGCMParmUInt32Set(&Msg.flags, 0 /* Flags, unused */);
156
157 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
158 if (RT_SUCCESS(rc))
159 rc = Msg.hdr.result;
160 return rc;
161}
162
163
164/**
165 * Disables a previously set message filter.
166 *
167 * @return IPRT status code.
168 * @param uClientId The client ID returned by VbglR3GuestCtrlConnect().
169 */
170VBGLR3DECL(int) VbglR3GuestCtrlMsgFilterUnset(uint32_t uClientId)
171{
172 HGCMMsgCmdFilterUnset Msg;
173
174 Msg.hdr.result = VERR_WRONG_ORDER;
175 Msg.hdr.u32ClientID = uClientId;
176 Msg.hdr.u32Function = GUEST_MSG_FILTER_UNSET; /* Tell the host we want to unset the filter. */
177 Msg.hdr.cParms = 1;
178
179 VbglHGCMParmUInt32Set(&Msg.flags, 0 /* Flags, unused */);
180
181 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
182 if (RT_SUCCESS(rc))
183 rc = Msg.hdr.result;
184 return rc;
185}
186
187
188VBGLR3DECL(int) VbglR3GuestCtrlMsgReply(PVBGLR3GUESTCTRLCMDCTX pCtx,
189 int rc)
190{
191 return VbglR3GuestCtrlMsgReplyEx(pCtx, rc, 0 /* uType */,
192 NULL /* pvPayload */, 0 /* cbPayload */);
193}
194
195
196VBGLR3DECL(int) VbglR3GuestCtrlMsgReplyEx(PVBGLR3GUESTCTRLCMDCTX pCtx,
197 int rc, uint32_t uType,
198 void *pvPayload, uint32_t cbPayload)
199{
200 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
201 /* Everything else is optional. */
202
203 HGCMMsgCmdReply Msg;
204
205 Msg.hdr.result = VERR_WRONG_ORDER;
206 Msg.hdr.u32ClientID = pCtx->uClientID;
207 Msg.hdr.u32Function = GUEST_MSG_REPLY;
208 Msg.hdr.cParms = 4;
209
210 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
211 VbglHGCMParmUInt32Set(&Msg.rc, (uint32_t)rc); /* int vs. uint32_t */
212 VbglHGCMParmUInt32Set(&Msg.type, uType);
213 VbglHGCMParmPtrSet(&Msg.payload, pvPayload, cbPayload);
214
215 int rc2 = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
216 if (RT_SUCCESS(rc))
217 {
218 int rc3 = Msg.hdr.result;
219 if (RT_FAILURE(rc3))
220 rc2 = rc3;
221 }
222 return rc2;
223}
224
225
226/**
227 * Tells the host service to skip the current message returned by
228 * VbglR3GuestCtrlMsgWaitFor().
229 *
230 * @return IPRT status code.
231 * @param uClientId The client ID returned by VbglR3GuestCtrlConnect().
232 */
233VBGLR3DECL(int) VbglR3GuestCtrlMsgSkip(uint32_t uClientId)
234{
235 HGCMMsgCmdSkip Msg;
236
237 Msg.hdr.result = VERR_WRONG_ORDER;
238 Msg.hdr.u32ClientID = uClientId;
239 Msg.hdr.u32Function = GUEST_MSG_SKIP; /* Tell the host we want to skip
240 the current assigned command. */
241 Msg.hdr.cParms = 1;
242
243 VbglHGCMParmUInt32Set(&Msg.flags, 0 /* Flags, unused */);
244
245 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
246 if (RT_SUCCESS(rc))
247 rc = Msg.hdr.result;
248
249 return rc;
250}
251
252
253/**
254 * Asks the host to cancel (release) all pending waits which were deferred.
255 *
256 * @returns VBox status code.
257 * @param uClientId The client ID returned by VbglR3GuestCtrlConnect().
258 */
259VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(uint32_t uClientId)
260{
261 HGCMMsgCancelPendingWaits Msg;
262
263 Msg.hdr.result = VERR_WRONG_ORDER;
264 Msg.hdr.u32ClientID = uClientId;
265 Msg.hdr.u32Function = GUEST_CANCEL_PENDING_WAITS;
266 Msg.hdr.cParms = 0;
267
268 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
269 if (RT_SUCCESS(rc))
270 {
271 int rc2 = Msg.hdr.result;
272 if (RT_FAILURE(rc2))
273 rc = rc2;
274 }
275 return rc;
276}
277
278
279/**
280 * Asks a specific guest session to close.
281 *
282 * @return IPRT status code.
283 * @param pCtx Host context.
284 * @param fFlags Some kind of flag. Figure it out yourself.
285 ** @todo Docs!
286 */
287VBGLR3DECL(int) VbglR3GuestCtrlSessionClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t fFlags)
288{
289 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
290 AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
291
292 HGCMMsgSessionClose Msg;
293
294 Msg.hdr.result = VERR_WRONG_ORDER;
295 Msg.hdr.u32ClientID = pCtx->uClientID;
296 Msg.hdr.u32Function = GUEST_SESSION_CLOSE;
297 Msg.hdr.cParms = pCtx->uNumParms;
298
299 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
300 VbglHGCMParmUInt32Set(&Msg.flags, fFlags);
301
302 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
303 if (RT_SUCCESS(rc))
304 {
305 int rc2 = Msg.hdr.result;
306 if (RT_FAILURE(rc2))
307 rc = rc2;
308 }
309
310 return rc;
311}
312
313
314VBGLR3DECL(int) VbglR3GuestCtrlSessionNotify(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uType, uint32_t uResult)
315{
316 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
317
318 HGCMMsgSessionNotify Msg;
319
320 Msg.hdr.result = VERR_WRONG_ORDER;
321 Msg.hdr.u32ClientID = pCtx->uClientID;
322 Msg.hdr.u32Function = GUEST_SESSION_NOTIFY;
323 Msg.hdr.cParms = 3;
324
325 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
326 VbglHGCMParmUInt32Set(&Msg.type, uType);
327 VbglHGCMParmUInt32Set(&Msg.result, uResult);
328
329 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
330 if (RT_SUCCESS(rc))
331 {
332 int rc2 = Msg.hdr.result;
333 if (RT_FAILURE(rc2))
334 rc = rc2;
335 }
336 return rc;
337}
338
339
340/**
341 * Retrieves the request to create a new guest session.
342 *
343 * @return IPRT status code.
344 ** @todo Docs!
345 */
346VBGLR3DECL(int) VbglR3GuestCtrlSessionGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx,
347 uint32_t *puProtocol,
348 char *pszUser, uint32_t cbUser,
349 char *pszPassword, uint32_t cbPassword,
350 char *pszDomain, uint32_t cbDomain,
351 uint32_t *pfFlags, uint32_t *pidSession)
352{
353 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
354 AssertReturn(pCtx->uNumParms == 6, VERR_INVALID_PARAMETER);
355
356 AssertPtrReturn(puProtocol, VERR_INVALID_POINTER);
357 AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
358 AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
359 AssertPtrReturn(pszDomain, VERR_INVALID_POINTER);
360 AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
361
362 HGCMMsgSessionOpen Msg;
363
364 Msg.hdr.result = VERR_WRONG_ORDER;
365 Msg.hdr.u32ClientID = pCtx->uClientID;
366 Msg.hdr.u32Function = GUEST_MSG_WAIT;
367 Msg.hdr.cParms = pCtx->uNumParms;
368
369 VbglHGCMParmUInt32Set(&Msg.context, 0);
370 VbglHGCMParmUInt32Set(&Msg.protocol, 0);
371 VbglHGCMParmPtrSet(&Msg.username, pszUser, cbUser);
372 VbglHGCMParmPtrSet(&Msg.password, pszPassword, cbPassword);
373 VbglHGCMParmPtrSet(&Msg.domain, pszDomain, cbDomain);
374 VbglHGCMParmUInt32Set(&Msg.flags, 0);
375
376 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
377 if (RT_SUCCESS(rc))
378 {
379 int rc2 = Msg.hdr.result;
380 if (RT_FAILURE(rc2))
381 {
382 rc = rc2;
383 }
384 else
385 {
386 Msg.context.GetUInt32(&pCtx->uContextID);
387 Msg.protocol.GetUInt32(puProtocol);
388 Msg.flags.GetUInt32(pfFlags);
389
390 if (pidSession)
391 *pidSession = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pCtx->uContextID);
392 }
393 }
394
395 return rc;
396}
397
398
399/**
400 * Retrieves the request to terminate an existing guest session.
401 *
402 * @return IPRT status code.
403 ** @todo Docs!
404 */
405VBGLR3DECL(int) VbglR3GuestCtrlSessionGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *pfFlags, uint32_t *pidSession)
406{
407 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
408 AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
409
410 AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
411
412 HGCMMsgSessionClose Msg;
413
414 Msg.hdr.result = VERR_WRONG_ORDER;
415 Msg.hdr.u32ClientID = pCtx->uClientID;
416 Msg.hdr.u32Function = GUEST_MSG_WAIT;
417 Msg.hdr.cParms = pCtx->uNumParms;
418
419 VbglHGCMParmUInt32Set(&Msg.context, 0);
420 VbglHGCMParmUInt32Set(&Msg.flags, 0);
421
422 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
423 if (RT_SUCCESS(rc))
424 {
425 int rc2 = Msg.hdr.result;
426 if (RT_FAILURE(rc2))
427 {
428 rc = rc2;
429 }
430 else
431 {
432 Msg.context.GetUInt32(&pCtx->uContextID);
433 Msg.flags.GetUInt32(pfFlags);
434
435 if (pidSession)
436 *pidSession = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pCtx->uContextID);
437 }
438 }
439
440 return rc;
441}
442
443
444VBGLR3DECL(int) VbglR3GuestCtrlPathGetRename(PVBGLR3GUESTCTRLCMDCTX pCtx,
445 char *pszSource, uint32_t cbSource,
446 char *pszDest, uint32_t cbDest,
447 uint32_t *pfFlags)
448{
449 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
450 AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
451
452 AssertPtrReturn(pszSource, VERR_INVALID_POINTER);
453 AssertReturn(cbSource, VERR_INVALID_PARAMETER);
454 AssertPtrReturn(pszDest, VERR_INVALID_POINTER);
455 AssertReturn(cbDest, VERR_INVALID_PARAMETER);
456 AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
457
458 HGCMMsgPathRename Msg;
459
460 Msg.hdr.result = VERR_WRONG_ORDER;
461 Msg.hdr.u32ClientID = pCtx->uClientID;
462 Msg.hdr.u32Function = GUEST_MSG_WAIT;
463 Msg.hdr.cParms = pCtx->uNumParms;
464
465 VbglHGCMParmUInt32Set(&Msg.context, 0);
466 VbglHGCMParmPtrSet(&Msg.source, pszSource, cbSource);
467 VbglHGCMParmPtrSet(&Msg.dest, pszDest, cbDest);
468 VbglHGCMParmUInt32Set(&Msg.flags, 0);
469
470 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
471 if (RT_SUCCESS(rc))
472 {
473 int rc2 = Msg.hdr.result;
474 if (RT_FAILURE(rc2))
475 {
476 rc = rc2;
477 }
478 else
479 {
480 Msg.context.GetUInt32(&pCtx->uContextID);
481 Msg.flags.GetUInt32(pfFlags);
482 }
483 }
484 return rc;
485}
486
487
488/**
489 * Allocates and gets host data, based on the message id.
490 *
491 * This will block until data becomes available.
492 *
493 * @returns VBox status code.
494 ** @todo Docs!
495 ** @todo Move the parameters in an own struct!
496 */
497VBGLR3DECL(int) VbglR3GuestCtrlProcGetStart(PVBGLR3GUESTCTRLCMDCTX pCtx,
498 char *pszCmd, uint32_t cbCmd,
499 uint32_t *pfFlags,
500 char *pszArgs, uint32_t cbArgs, uint32_t *pcArgs,
501 char *pszEnv, uint32_t *pcbEnv, uint32_t *pcEnvVars,
502 char *pszUser, uint32_t cbUser,
503 char *pszPassword, uint32_t cbPassword,
504 uint32_t *puTimeoutMS,
505 uint32_t *puPriority,
506 uint64_t *puAffinity, uint32_t cbAffinity, uint32_t *pcAffinity)
507{
508 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
509
510 AssertPtrReturn(pszCmd, VERR_INVALID_POINTER);
511 AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
512 AssertPtrReturn(pszArgs, VERR_INVALID_POINTER);
513 AssertPtrReturn(pcArgs, VERR_INVALID_POINTER);
514 AssertPtrReturn(pszEnv, VERR_INVALID_POINTER);
515 AssertPtrReturn(pcbEnv, VERR_INVALID_POINTER);
516 AssertPtrReturn(pcEnvVars, VERR_INVALID_POINTER);
517 AssertPtrReturn(puTimeoutMS, VERR_INVALID_POINTER);
518
519 HGCMMsgProcExec Msg;
520
521 Msg.hdr.result = VERR_WRONG_ORDER;
522 Msg.hdr.u32ClientID = pCtx->uClientID;
523 Msg.hdr.u32Function = GUEST_MSG_WAIT;
524 Msg.hdr.cParms = pCtx->uNumParms;
525
526 VbglHGCMParmUInt32Set(&Msg.context, 0);
527 VbglHGCMParmPtrSet(&Msg.cmd, pszCmd, cbCmd);
528 VbglHGCMParmUInt32Set(&Msg.flags, 0);
529 VbglHGCMParmUInt32Set(&Msg.num_args, 0);
530 VbglHGCMParmPtrSet(&Msg.args, pszArgs, cbArgs);
531 VbglHGCMParmUInt32Set(&Msg.num_env, 0);
532 VbglHGCMParmUInt32Set(&Msg.cb_env, 0);
533 VbglHGCMParmPtrSet(&Msg.env, pszEnv, *pcbEnv);
534 if (pCtx->uProtocol < 2)
535 {
536 AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
537 AssertReturn(cbUser, VERR_INVALID_PARAMETER);
538 AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
539 AssertReturn(pszPassword, VERR_INVALID_PARAMETER);
540
541 VbglHGCMParmPtrSet(&Msg.u.v1.username, pszUser, cbUser);
542 VbglHGCMParmPtrSet(&Msg.u.v1.password, pszPassword, cbPassword);
543 VbglHGCMParmUInt32Set(&Msg.u.v1.timeout, 0);
544 }
545 else
546 {
547 AssertPtrReturn(puAffinity, VERR_INVALID_POINTER);
548 AssertReturn(cbAffinity, VERR_INVALID_PARAMETER);
549
550 VbglHGCMParmUInt32Set(&Msg.u.v2.timeout, 0);
551 VbglHGCMParmUInt32Set(&Msg.u.v2.priority, 0);
552 VbglHGCMParmUInt32Set(&Msg.u.v2.num_affinity, 0);
553 VbglHGCMParmPtrSet(&Msg.u.v2.affinity, puAffinity, cbAffinity);
554 }
555
556 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
557 if (RT_SUCCESS(rc))
558 {
559 int rc2 = Msg.hdr.result;
560 if (RT_FAILURE(rc2))
561 {
562 rc = rc2;
563 }
564 else
565 {
566 Msg.context.GetUInt32(&pCtx->uContextID);
567 Msg.flags.GetUInt32(pfFlags);
568 Msg.num_args.GetUInt32(pcArgs);
569 Msg.num_env.GetUInt32(pcEnvVars);
570 Msg.cb_env.GetUInt32(pcbEnv);
571 if (pCtx->uProtocol < 2)
572 {
573 Msg.u.v1.timeout.GetUInt32(puTimeoutMS);
574 }
575 else
576 {
577 Msg.u.v2.timeout.GetUInt32(puTimeoutMS);
578 Msg.u.v2.priority.GetUInt32(puPriority);
579 Msg.u.v2.num_affinity.GetUInt32(pcAffinity);
580 }
581 }
582 }
583 return rc;
584}
585
586
587/**
588 * Allocates and gets host data, based on the message id.
589 *
590 * This will block until data becomes available.
591 *
592 * @returns VBox status code.
593 ** @todo Docs!
594 */
595VBGLR3DECL(int) VbglR3GuestCtrlProcGetOutput(PVBGLR3GUESTCTRLCMDCTX pCtx,
596 uint32_t *puPID, uint32_t *puHandle, uint32_t *pfFlags)
597{
598 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
599 AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
600
601 AssertPtrReturn(puPID, VERR_INVALID_POINTER);
602 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
603 AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
604
605 HGCMMsgProcOutput Msg;
606
607 Msg.hdr.result = VERR_WRONG_ORDER;
608 Msg.hdr.u32ClientID = pCtx->uClientID;
609 Msg.hdr.u32Function = GUEST_MSG_WAIT;
610 Msg.hdr.cParms = pCtx->uNumParms;
611
612 VbglHGCMParmUInt32Set(&Msg.context, 0);
613 VbglHGCMParmUInt32Set(&Msg.pid, 0);
614 VbglHGCMParmUInt32Set(&Msg.handle, 0);
615 VbglHGCMParmUInt32Set(&Msg.flags, 0);
616
617 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
618 if (RT_SUCCESS(rc))
619 {
620 int rc2 = Msg.hdr.result;
621 if (RT_FAILURE(rc2))
622 {
623 rc = rc2;
624 }
625 else
626 {
627 Msg.context.GetUInt32(&pCtx->uContextID);
628 Msg.pid.GetUInt32(puPID);
629 Msg.handle.GetUInt32(puHandle);
630 Msg.flags.GetUInt32(pfFlags);
631 }
632 }
633 return rc;
634}
635
636
637/**
638 * Retrieves the input data from host which then gets sent to the
639 * started process.
640 *
641 * This will block until data becomes available.
642 *
643 * @returns VBox status code.
644 ** @todo Docs!
645 */
646VBGLR3DECL(int) VbglR3GuestCtrlProcGetInput(PVBGLR3GUESTCTRLCMDCTX pCtx,
647 uint32_t *puPID, uint32_t *pfFlags,
648 void *pvData, uint32_t cbData,
649 uint32_t *pcbSize)
650{
651 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
652 AssertReturn(pCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
653
654 AssertPtrReturn(puPID, VERR_INVALID_POINTER);
655 AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
656 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
657 AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
658
659 HGCMMsgProcInput Msg;
660
661 Msg.hdr.result = VERR_WRONG_ORDER;
662 Msg.hdr.u32ClientID = pCtx->uClientID;
663 Msg.hdr.u32Function = GUEST_MSG_WAIT;
664 Msg.hdr.cParms = pCtx->uNumParms;
665
666 VbglHGCMParmUInt32Set(&Msg.context, 0);
667 VbglHGCMParmUInt32Set(&Msg.pid, 0);
668 VbglHGCMParmUInt32Set(&Msg.flags, 0);
669 VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
670 VbglHGCMParmUInt32Set(&Msg.size, 0);
671
672 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
673 if (RT_SUCCESS(rc))
674 {
675 int rc2 = Msg.hdr.result;
676 if (RT_FAILURE(rc2))
677 {
678 rc = rc2;
679 }
680 else
681 {
682 Msg.context.GetUInt32(&pCtx->uContextID);
683 Msg.pid.GetUInt32(puPID);
684 Msg.flags.GetUInt32(pfFlags);
685 Msg.size.GetUInt32(pcbSize);
686 }
687 }
688 return rc;
689}
690
691
692VBGLR3DECL(int) VbglR3GuestCtrlDirGetRemove(PVBGLR3GUESTCTRLCMDCTX pCtx,
693 char *pszPath, uint32_t cbPath,
694 uint32_t *pfFlags)
695{
696 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
697 AssertReturn(pCtx->uNumParms == 3, VERR_INVALID_PARAMETER);
698
699 AssertPtrReturn(pszPath, VERR_INVALID_POINTER);
700 AssertReturn(cbPath, VERR_INVALID_PARAMETER);
701 AssertPtrReturn(pfFlags, VERR_INVALID_POINTER);
702
703 HGCMMsgDirRemove Msg;
704
705 Msg.hdr.result = VERR_WRONG_ORDER;
706 Msg.hdr.u32ClientID = pCtx->uClientID;
707 Msg.hdr.u32Function = GUEST_MSG_WAIT;
708 Msg.hdr.cParms = pCtx->uNumParms;
709
710 VbglHGCMParmUInt32Set(&Msg.context, 0);
711 VbglHGCMParmPtrSet(&Msg.path, pszPath, cbPath);
712 VbglHGCMParmUInt32Set(&Msg.flags, 0);
713
714 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
715 if (RT_SUCCESS(rc))
716 {
717 int rc2 = Msg.hdr.result;
718 if (RT_FAILURE(rc2))
719 {
720 rc = rc2;
721 }
722 else
723 {
724 Msg.context.GetUInt32(&pCtx->uContextID);
725 Msg.flags.GetUInt32(pfFlags);
726 }
727 }
728 return rc;
729}
730
731
732VBGLR3DECL(int) VbglR3GuestCtrlFileGetOpen(PVBGLR3GUESTCTRLCMDCTX pCtx,
733 char *pszFileName, uint32_t cbFileName,
734 char *pszAccess, uint32_t cbAccess,
735 char *pszDisposition, uint32_t cbDisposition,
736 char *pszSharing, uint32_t cbSharing,
737 uint32_t *puCreationMode,
738 uint64_t *puOffset)
739{
740 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
741 AssertReturn(pCtx->uNumParms == 7, VERR_INVALID_PARAMETER);
742
743 AssertPtrReturn(pszFileName, VERR_INVALID_POINTER);
744 AssertReturn(cbFileName, VERR_INVALID_PARAMETER);
745 AssertPtrReturn(pszAccess, VERR_INVALID_POINTER);
746 AssertReturn(cbAccess, VERR_INVALID_PARAMETER);
747 AssertPtrReturn(pszDisposition, VERR_INVALID_POINTER);
748 AssertReturn(cbDisposition, VERR_INVALID_PARAMETER);
749 AssertPtrReturn(pszSharing, VERR_INVALID_POINTER);
750 AssertReturn(cbSharing, VERR_INVALID_PARAMETER);
751 AssertPtrReturn(puCreationMode, VERR_INVALID_POINTER);
752 AssertPtrReturn(puOffset, VERR_INVALID_POINTER);
753
754 HGCMMsgFileOpen Msg;
755
756 Msg.hdr.result = VERR_WRONG_ORDER;
757 Msg.hdr.u32ClientID = pCtx->uClientID;
758 Msg.hdr.u32Function = GUEST_MSG_WAIT;
759 Msg.hdr.cParms = pCtx->uNumParms;
760
761 VbglHGCMParmUInt32Set(&Msg.context, 0);
762 VbglHGCMParmPtrSet(&Msg.filename, pszFileName, cbFileName);
763 VbglHGCMParmPtrSet(&Msg.openmode, pszAccess, cbAccess);
764 VbglHGCMParmPtrSet(&Msg.disposition, pszDisposition, cbDisposition);
765 VbglHGCMParmPtrSet(&Msg.sharing, pszSharing, cbSharing);
766 VbglHGCMParmUInt32Set(&Msg.creationmode, 0);
767 VbglHGCMParmUInt64Set(&Msg.offset, 0);
768
769 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
770 if (RT_SUCCESS(rc))
771 {
772 int rc2 = Msg.hdr.result;
773 if (RT_FAILURE(rc2))
774 {
775 rc = rc2;
776 }
777 else
778 {
779 Msg.context.GetUInt32(&pCtx->uContextID);
780 Msg.creationmode.GetUInt32(puCreationMode);
781 Msg.offset.GetUInt64(puOffset);
782 }
783 }
784 return rc;
785}
786
787
788VBGLR3DECL(int) VbglR3GuestCtrlFileGetClose(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle)
789{
790 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
791
792 AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
793 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
794
795 HGCMMsgFileClose Msg;
796
797 Msg.hdr.result = VERR_WRONG_ORDER;
798 Msg.hdr.u32ClientID = pCtx->uClientID;
799 Msg.hdr.u32Function = GUEST_MSG_WAIT;
800 Msg.hdr.cParms = pCtx->uNumParms;
801
802 VbglHGCMParmUInt32Set(&Msg.context, 0);
803 VbglHGCMParmUInt32Set(&Msg.handle, 0);
804
805 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
806 if (RT_SUCCESS(rc))
807 {
808 int rc2 = Msg.hdr.result;
809 if (RT_FAILURE(rc2))
810 {
811 rc = rc2;
812 }
813 else
814 {
815 Msg.context.GetUInt32(&pCtx->uContextID);
816 Msg.handle.GetUInt32(puHandle);
817 }
818 }
819 return rc;
820}
821
822
823VBGLR3DECL(int) VbglR3GuestCtrlFileGetRead(PVBGLR3GUESTCTRLCMDCTX pCtx,
824 uint32_t *puHandle, uint32_t *puToRead)
825{
826 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
827
828 AssertReturn(pCtx->uNumParms == 3, VERR_INVALID_PARAMETER);
829 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
830 AssertPtrReturn(puToRead, VERR_INVALID_POINTER);
831
832 HGCMMsgFileRead Msg;
833
834 Msg.hdr.result = VERR_WRONG_ORDER;
835 Msg.hdr.u32ClientID = pCtx->uClientID;
836 Msg.hdr.u32Function = GUEST_MSG_WAIT;
837 Msg.hdr.cParms = pCtx->uNumParms;
838
839 VbglHGCMParmUInt32Set(&Msg.context, 0);
840 VbglHGCMParmUInt32Set(&Msg.handle, 0);
841 VbglHGCMParmUInt32Set(&Msg.size, 0);
842
843 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
844 if (RT_SUCCESS(rc))
845 {
846 int rc2 = Msg.hdr.result;
847 if (RT_FAILURE(rc2))
848 {
849 rc = rc2;
850 }
851 else
852 {
853 Msg.context.GetUInt32(&pCtx->uContextID);
854 Msg.handle.GetUInt32(puHandle);
855 Msg.size.GetUInt32(puToRead);
856 }
857 }
858 return rc;
859}
860
861
862VBGLR3DECL(int) VbglR3GuestCtrlFileGetReadAt(PVBGLR3GUESTCTRLCMDCTX pCtx,
863 uint32_t *puHandle, uint32_t *puToRead, uint64_t *puOffset)
864{
865 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
866
867 AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
868 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
869 AssertPtrReturn(puToRead, VERR_INVALID_POINTER);
870
871 HGCMMsgFileReadAt Msg;
872
873 Msg.hdr.result = VERR_WRONG_ORDER;
874 Msg.hdr.u32ClientID = pCtx->uClientID;
875 Msg.hdr.u32Function = GUEST_MSG_WAIT;
876 Msg.hdr.cParms = pCtx->uNumParms;
877
878 VbglHGCMParmUInt32Set(&Msg.context, 0);
879 VbglHGCMParmUInt32Set(&Msg.handle, 0);
880 VbglHGCMParmUInt32Set(&Msg.offset, 0);
881 VbglHGCMParmUInt32Set(&Msg.size, 0);
882
883 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
884 if (RT_SUCCESS(rc))
885 {
886 int rc2 = Msg.hdr.result;
887 if (RT_FAILURE(rc2))
888 {
889 rc = rc2;
890 }
891 else
892 {
893 Msg.context.GetUInt32(&pCtx->uContextID);
894 Msg.handle.GetUInt32(puHandle);
895 Msg.offset.GetUInt64(puOffset);
896 Msg.size.GetUInt32(puToRead);
897 }
898 }
899 return rc;
900}
901
902
903VBGLR3DECL(int) VbglR3GuestCtrlFileGetWrite(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
904 void *pvData, uint32_t cbData, uint32_t *pcbSize)
905{
906 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
907
908 AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
909 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
910 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
911 AssertReturn(cbData, VERR_INVALID_PARAMETER);
912 AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
913
914 HGCMMsgFileWrite Msg;
915
916 Msg.hdr.result = VERR_WRONG_ORDER;
917 Msg.hdr.u32ClientID = pCtx->uClientID;
918 Msg.hdr.u32Function = GUEST_MSG_WAIT;
919 Msg.hdr.cParms = pCtx->uNumParms;
920
921 VbglHGCMParmUInt32Set(&Msg.context, 0);
922 VbglHGCMParmUInt32Set(&Msg.handle, 0);
923 VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
924 VbglHGCMParmUInt32Set(&Msg.size, 0);
925
926 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
927 if (RT_SUCCESS(rc))
928 {
929 int rc2 = Msg.hdr.result;
930 if (RT_FAILURE(rc2))
931 {
932 rc = rc2;
933 }
934 else
935 {
936 Msg.context.GetUInt32(&pCtx->uContextID);
937 Msg.handle.GetUInt32(puHandle);
938 Msg.size.GetUInt32(pcbSize);
939 }
940 }
941 return rc;
942}
943
944
945VBGLR3DECL(int) VbglR3GuestCtrlFileGetWriteAt(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle,
946 void *pvData, uint32_t cbData, uint32_t *pcbSize, uint64_t *puOffset)
947{
948 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
949
950 AssertReturn(pCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
951 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
952 AssertPtrReturn(pvData, VERR_INVALID_POINTER);
953 AssertReturn(cbData, VERR_INVALID_PARAMETER);
954 AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
955
956 HGCMMsgFileWriteAt Msg;
957
958 Msg.hdr.result = VERR_WRONG_ORDER;
959 Msg.hdr.u32ClientID = pCtx->uClientID;
960 Msg.hdr.u32Function = GUEST_MSG_WAIT;
961 Msg.hdr.cParms = pCtx->uNumParms;
962
963 VbglHGCMParmUInt32Set(&Msg.context, 0);
964 VbglHGCMParmUInt32Set(&Msg.handle, 0);
965 VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
966 VbglHGCMParmUInt32Set(&Msg.size, 0);
967 VbglHGCMParmUInt32Set(&Msg.offset, 0);
968
969 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
970 if (RT_SUCCESS(rc))
971 {
972 int rc2 = Msg.hdr.result;
973 if (RT_FAILURE(rc2))
974 {
975 rc = rc2;
976 }
977 else
978 {
979 Msg.context.GetUInt32(&pCtx->uContextID);
980 Msg.handle.GetUInt32(puHandle);
981 Msg.size.GetUInt32(pcbSize);
982 }
983 }
984 return rc;
985}
986
987
988VBGLR3DECL(int) VbglR3GuestCtrlFileGetSeek(PVBGLR3GUESTCTRLCMDCTX pCtx,
989 uint32_t *puHandle, uint32_t *puSeekMethod, uint64_t *puOffset)
990{
991 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
992
993 AssertReturn(pCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
994 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
995 AssertPtrReturn(puSeekMethod, VERR_INVALID_POINTER);
996 AssertPtrReturn(puOffset, VERR_INVALID_POINTER);
997
998 HGCMMsgFileSeek Msg;
999
1000 Msg.hdr.result = VERR_WRONG_ORDER;
1001 Msg.hdr.u32ClientID = pCtx->uClientID;
1002 Msg.hdr.u32Function = GUEST_MSG_WAIT;
1003 Msg.hdr.cParms = pCtx->uNumParms;
1004
1005 VbglHGCMParmUInt32Set(&Msg.context, 0);
1006 VbglHGCMParmUInt32Set(&Msg.handle, 0);
1007 VbglHGCMParmUInt32Set(&Msg.method, 0);
1008 VbglHGCMParmUInt64Set(&Msg.offset, 0);
1009
1010 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1011 if (RT_SUCCESS(rc))
1012 {
1013 int rc2 = Msg.hdr.result;
1014 if (RT_FAILURE(rc2))
1015 {
1016 rc = rc2;
1017 }
1018 else
1019 {
1020 Msg.context.GetUInt32(&pCtx->uContextID);
1021 Msg.handle.GetUInt32(puHandle);
1022 Msg.method.GetUInt32(puSeekMethod);
1023 Msg.offset.GetUInt64(puOffset);
1024 }
1025 }
1026 return rc;
1027}
1028
1029
1030VBGLR3DECL(int) VbglR3GuestCtrlFileGetTell(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puHandle)
1031{
1032 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1033
1034 AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
1035 AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
1036
1037 HGCMMsgFileTell Msg;
1038
1039 Msg.hdr.result = VERR_WRONG_ORDER;
1040 Msg.hdr.u32ClientID = pCtx->uClientID;
1041 Msg.hdr.u32Function = GUEST_MSG_WAIT;
1042 Msg.hdr.cParms = pCtx->uNumParms;
1043
1044 VbglHGCMParmUInt32Set(&Msg.context, 0);
1045 VbglHGCMParmUInt32Set(&Msg.handle, 0);
1046
1047 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1048 if (RT_SUCCESS(rc))
1049 {
1050 int rc2 = Msg.hdr.result;
1051 if (RT_FAILURE(rc2))
1052 {
1053 rc = rc2;
1054 }
1055 else
1056 {
1057 Msg.context.GetUInt32(&pCtx->uContextID);
1058 Msg.handle.GetUInt32(puHandle);
1059 }
1060 }
1061 return rc;
1062}
1063
1064
1065VBGLR3DECL(int) VbglR3GuestCtrlProcGetTerminate(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t *puPID)
1066{
1067 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1068
1069 AssertReturn(pCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
1070 AssertPtrReturn(puPID, VERR_INVALID_POINTER);
1071
1072 HGCMMsgProcTerminate Msg;
1073
1074 Msg.hdr.result = VERR_WRONG_ORDER;
1075 Msg.hdr.u32ClientID = pCtx->uClientID;
1076 Msg.hdr.u32Function = GUEST_MSG_WAIT;
1077 Msg.hdr.cParms = pCtx->uNumParms;
1078
1079 VbglHGCMParmUInt32Set(&Msg.context, 0);
1080 VbglHGCMParmUInt32Set(&Msg.pid, 0);
1081
1082 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1083 if (RT_SUCCESS(rc))
1084 {
1085 int rc2 = Msg.hdr.result;
1086 if (RT_FAILURE(rc2))
1087 {
1088 rc = rc2;
1089 }
1090 else
1091 {
1092 Msg.context.GetUInt32(&pCtx->uContextID);
1093 Msg.pid.GetUInt32(puPID);
1094 }
1095 }
1096 return rc;
1097}
1098
1099
1100VBGLR3DECL(int) VbglR3GuestCtrlProcGetWaitFor(PVBGLR3GUESTCTRLCMDCTX pCtx,
1101 uint32_t *puPID, uint32_t *puWaitFlags, uint32_t *puTimeoutMS)
1102{
1103 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1104
1105 AssertReturn(pCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
1106 AssertPtrReturn(puPID, VERR_INVALID_POINTER);
1107
1108 HGCMMsgProcWaitFor Msg;
1109
1110 Msg.hdr.result = VERR_WRONG_ORDER;
1111 Msg.hdr.u32ClientID = pCtx->uClientID;
1112 Msg.hdr.u32Function = GUEST_MSG_WAIT;
1113 Msg.hdr.cParms = pCtx->uNumParms;
1114
1115 VbglHGCMParmUInt32Set(&Msg.context, 0);
1116 VbglHGCMParmUInt32Set(&Msg.pid, 0);
1117 VbglHGCMParmUInt32Set(&Msg.flags, 0);
1118 VbglHGCMParmUInt32Set(&Msg.timeout, 0);
1119
1120 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1121 if (RT_SUCCESS(rc))
1122 {
1123 int rc2 = Msg.hdr.result;
1124 if (RT_FAILURE(rc2))
1125 {
1126 rc = rc2;
1127 }
1128 else
1129 {
1130 Msg.context.GetUInt32(&pCtx->uContextID);
1131 Msg.pid.GetUInt32(puPID);
1132 Msg.flags.GetUInt32(puWaitFlags);
1133 Msg.timeout.GetUInt32(puTimeoutMS);
1134 }
1135 }
1136 return rc;
1137}
1138
1139
1140VBGLR3DECL(int) VbglR3GuestCtrlFileCbOpen(PVBGLR3GUESTCTRLCMDCTX pCtx,
1141 uint32_t uRc, uint32_t uFileHandle)
1142{
1143 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1144
1145 HGCMReplyFileNotify Msg;
1146
1147 Msg.hdr.result = VERR_WRONG_ORDER;
1148 Msg.hdr.u32ClientID = pCtx->uClientID;
1149 Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
1150 Msg.hdr.cParms = 4;
1151
1152 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1153 VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_OPEN);
1154 VbglHGCMParmUInt32Set(&Msg.rc, uRc);
1155
1156 VbglHGCMParmUInt32Set(&Msg.u.open.handle, uFileHandle);
1157
1158 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1159 if (RT_SUCCESS(rc))
1160 {
1161 int rc2 = Msg.hdr.result;
1162 if (RT_FAILURE(rc2))
1163 rc = rc2;
1164 }
1165 return rc;
1166}
1167
1168
1169VBGLR3DECL(int) VbglR3GuestCtrlFileCbClose(PVBGLR3GUESTCTRLCMDCTX pCtx,
1170 uint32_t uRc)
1171{
1172 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1173
1174 HGCMReplyFileNotify Msg;
1175
1176 Msg.hdr.result = VERR_WRONG_ORDER;
1177 Msg.hdr.u32ClientID = pCtx->uClientID;
1178 Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
1179 Msg.hdr.cParms = 3;
1180
1181 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1182 VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_CLOSE);
1183 VbglHGCMParmUInt32Set(&Msg.rc, uRc);
1184
1185 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1186 if (RT_SUCCESS(rc))
1187 {
1188 int rc2 = Msg.hdr.result;
1189 if (RT_FAILURE(rc2))
1190 rc = rc2;
1191 }
1192 return rc;
1193}
1194
1195
1196VBGLR3DECL(int) VbglR3GuestCtrlFileCbError(PVBGLR3GUESTCTRLCMDCTX pCtx, uint32_t uRc)
1197{
1198 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1199
1200 HGCMReplyFileNotify Msg;
1201
1202 Msg.hdr.result = VERR_WRONG_ORDER;
1203 Msg.hdr.u32ClientID = pCtx->uClientID;
1204 Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
1205 Msg.hdr.cParms = 3;
1206
1207 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1208 VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_ERROR);
1209 VbglHGCMParmUInt32Set(&Msg.rc, uRc);
1210
1211 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1212 if (RT_SUCCESS(rc))
1213 {
1214 int rc2 = Msg.hdr.result;
1215 if (RT_FAILURE(rc2))
1216 rc = rc2;
1217 }
1218 return rc;
1219}
1220
1221
1222VBGLR3DECL(int) VbglR3GuestCtrlFileCbRead(PVBGLR3GUESTCTRLCMDCTX pCtx,
1223 uint32_t uRc,
1224 void *pvData, uint32_t cbData)
1225{
1226 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1227
1228 HGCMReplyFileNotify Msg;
1229
1230 Msg.hdr.result = VERR_WRONG_ORDER;
1231 Msg.hdr.u32ClientID = pCtx->uClientID;
1232 Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
1233 Msg.hdr.cParms = 4;
1234
1235 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1236 VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_READ);
1237 VbglHGCMParmUInt32Set(&Msg.rc, uRc);
1238
1239 VbglHGCMParmPtrSet(&Msg.u.read.data, pvData, cbData);
1240
1241 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1242 if (RT_SUCCESS(rc))
1243 {
1244 int rc2 = Msg.hdr.result;
1245 if (RT_FAILURE(rc2))
1246 rc = rc2;
1247 }
1248 return rc;
1249}
1250
1251
1252VBGLR3DECL(int) VbglR3GuestCtrlFileCbWrite(PVBGLR3GUESTCTRLCMDCTX pCtx,
1253 uint32_t uRc, uint32_t uWritten)
1254{
1255 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1256
1257 HGCMReplyFileNotify Msg;
1258
1259 Msg.hdr.result = VERR_WRONG_ORDER;
1260 Msg.hdr.u32ClientID = pCtx->uClientID;
1261 Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
1262 Msg.hdr.cParms = 4;
1263
1264 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1265 VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_WRITE);
1266 VbglHGCMParmUInt32Set(&Msg.rc, uRc);
1267
1268 VbglHGCMParmUInt32Set(&Msg.u.write.written, uWritten);
1269
1270 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1271 if (RT_SUCCESS(rc))
1272 {
1273 int rc2 = Msg.hdr.result;
1274 if (RT_FAILURE(rc2))
1275 rc = rc2;
1276 }
1277 return rc;
1278}
1279
1280
1281VBGLR3DECL(int) VbglR3GuestCtrlFileCbSeek(PVBGLR3GUESTCTRLCMDCTX pCtx,
1282 uint32_t uRc, uint64_t uOffActual)
1283{
1284 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1285
1286 HGCMReplyFileNotify Msg;
1287
1288 Msg.hdr.result = VERR_WRONG_ORDER;
1289 Msg.hdr.u32ClientID = pCtx->uClientID;
1290 Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
1291 Msg.hdr.cParms = 4;
1292
1293 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1294 VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_SEEK);
1295 VbglHGCMParmUInt32Set(&Msg.rc, uRc);
1296
1297 VbglHGCMParmUInt64Set(&Msg.u.seek.offset, uOffActual);
1298
1299 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1300 if (RT_SUCCESS(rc))
1301 {
1302 int rc2 = Msg.hdr.result;
1303 if (RT_FAILURE(rc2))
1304 rc = rc2;
1305 }
1306 return rc;
1307}
1308
1309
1310VBGLR3DECL(int) VbglR3GuestCtrlFileCbTell(PVBGLR3GUESTCTRLCMDCTX pCtx,
1311 uint32_t uRc, uint64_t uOffActual)
1312{
1313 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1314
1315 HGCMReplyFileNotify Msg;
1316
1317 Msg.hdr.result = VERR_WRONG_ORDER;
1318 Msg.hdr.u32ClientID = pCtx->uClientID;
1319 Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
1320 Msg.hdr.cParms = 4;
1321
1322 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1323 VbglHGCMParmUInt32Set(&Msg.type, GUEST_FILE_NOTIFYTYPE_TELL);
1324 VbglHGCMParmUInt32Set(&Msg.rc, uRc);
1325
1326 VbglHGCMParmUInt64Set(&Msg.u.tell.offset, uOffActual);
1327
1328 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1329 if (RT_SUCCESS(rc))
1330 {
1331 int rc2 = Msg.hdr.result;
1332 if (RT_FAILURE(rc2))
1333 rc = rc2;
1334 }
1335 return rc;
1336}
1337
1338
1339/**
1340 * Callback for reporting a guest process status (along with some other stuff) to the host.
1341 *
1342 * @returns VBox status code.
1343 ** @todo Docs!
1344 */
1345VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatus(PVBGLR3GUESTCTRLCMDCTX pCtx,
1346 uint32_t uPID, uint32_t uStatus, uint32_t fFlags,
1347 void *pvData, uint32_t cbData)
1348{
1349 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1350
1351 HGCMMsgProcStatus Msg;
1352
1353 Msg.hdr.result = VERR_WRONG_ORDER;
1354 Msg.hdr.u32ClientID = pCtx->uClientID;
1355 Msg.hdr.u32Function = GUEST_EXEC_STATUS;
1356 Msg.hdr.cParms = 5;
1357
1358 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1359 VbglHGCMParmUInt32Set(&Msg.pid, uPID);
1360 VbglHGCMParmUInt32Set(&Msg.status, uStatus);
1361 VbglHGCMParmUInt32Set(&Msg.flags, fFlags);
1362 VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
1363
1364 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1365 if (RT_SUCCESS(rc))
1366 {
1367 int rc2 = Msg.hdr.result;
1368 if (RT_FAILURE(rc2))
1369 rc = rc2;
1370 }
1371 return rc;
1372}
1373
1374
1375/**
1376 * Sends output (from stdout/stderr) from a running process.
1377 *
1378 * @returns VBox status code.
1379 ** @todo Docs!
1380 */
1381VBGLR3DECL(int) VbglR3GuestCtrlProcCbOutput(PVBGLR3GUESTCTRLCMDCTX pCtx,
1382 uint32_t uPID,uint32_t uHandle, uint32_t fFlags,
1383 void *pvData, uint32_t cbData)
1384{
1385 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1386
1387 HGCMMsgProcOutput Msg;
1388
1389 Msg.hdr.result = VERR_WRONG_ORDER;
1390 Msg.hdr.u32ClientID = pCtx->uClientID;
1391 Msg.hdr.u32Function = GUEST_EXEC_OUTPUT;
1392 Msg.hdr.cParms = 5;
1393
1394 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1395 VbglHGCMParmUInt32Set(&Msg.pid, uPID);
1396 VbglHGCMParmUInt32Set(&Msg.handle, uHandle);
1397 VbglHGCMParmUInt32Set(&Msg.flags, fFlags);
1398 VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
1399
1400 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1401 if (RT_SUCCESS(rc))
1402 {
1403 int rc2 = Msg.hdr.result;
1404 if (RT_FAILURE(rc2))
1405 rc = rc2;
1406 }
1407 return rc;
1408}
1409
1410
1411/**
1412 * Callback for reporting back the input status of a guest process to the host.
1413 *
1414 * @returns VBox status code.
1415 ** @todo Docs!
1416 */
1417VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatusInput(PVBGLR3GUESTCTRLCMDCTX pCtx,
1418 uint32_t uPID, uint32_t uStatus,
1419 uint32_t fFlags, uint32_t cbWritten)
1420{
1421 AssertPtrReturn(pCtx, VERR_INVALID_POINTER);
1422
1423 HGCMMsgProcStatusInput Msg;
1424
1425 Msg.hdr.result = VERR_WRONG_ORDER;
1426 Msg.hdr.u32ClientID = pCtx->uClientID;
1427 Msg.hdr.u32Function = GUEST_EXEC_INPUT_STATUS;
1428 Msg.hdr.cParms = 5;
1429
1430 VbglHGCMParmUInt32Set(&Msg.context, pCtx->uContextID);
1431 VbglHGCMParmUInt32Set(&Msg.pid, uPID);
1432 VbglHGCMParmUInt32Set(&Msg.status, uStatus);
1433 VbglHGCMParmUInt32Set(&Msg.flags, fFlags);
1434 VbglHGCMParmUInt32Set(&Msg.written, cbWritten);
1435
1436 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
1437 if (RT_SUCCESS(rc))
1438 {
1439 int rc2 = Msg.hdr.result;
1440 if (RT_FAILURE(rc2))
1441 rc = rc2;
1442 }
1443 return rc;
1444}
1445
Note: See TracBrowser for help on using the repository browser.

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