VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibHostChannel.cpp@ 58029

Last change on this file since 58029 was 56294, checked in by vboxsync, 10 years ago

Additions/common,Additions/os2: Updated (C) year.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 10.1 KB
Line 
1/* $Id: VBoxGuestR3LibHostChannel.cpp 56294 2015-06-09 14:26:20Z vboxsync $ */
2/** @file
3 * VBoxGuestR3Lib - Ring-3 Support Library for VirtualBox guest additions, Host Channel.
4 */
5
6/*
7 * Copyright (C) 2012-2015 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#include <iprt/mem.h>
29
30#include <VBox/HostServices/VBoxHostChannel.h>
31
32#include "VBGLR3Internal.h"
33
34
35VBGLR3DECL(int) VbglR3HostChannelInit(uint32_t *pu32HGCMClientId)
36{
37 VBoxGuestHGCMConnectInfo connectInfo;
38 RT_ZERO(connectInfo);
39
40 connectInfo.result = VERR_WRONG_ORDER;
41 connectInfo.Loc.type = VMMDevHGCMLoc_LocalHost_Existing;
42 strcpy(connectInfo.Loc.u.host.achName, "VBoxHostChannel");
43 connectInfo.u32ClientID = 0;
44
45 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CONNECT, &connectInfo, sizeof(connectInfo));
46
47 if (RT_SUCCESS(rc))
48 {
49 rc = connectInfo.result;
50
51 if (RT_SUCCESS(rc))
52 {
53 *pu32HGCMClientId = connectInfo.u32ClientID;
54 }
55 }
56
57 return rc;
58}
59
60VBGLR3DECL(void) VbglR3HostChannelTerm(uint32_t u32HGCMClientId)
61{
62 VBoxGuestHGCMDisconnectInfo disconnectInfo;
63 disconnectInfo.result = VERR_WRONG_ORDER;
64 disconnectInfo.u32ClientID = u32HGCMClientId;
65
66 vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &disconnectInfo, sizeof(disconnectInfo));
67}
68
69VBGLR3DECL(int) VbglR3HostChannelAttach(uint32_t *pu32ChannelHandle,
70 uint32_t u32HGCMClientId,
71 const char *pszName,
72 uint32_t u32Flags)
73{
74 /* Make a heap copy of the name, because HGCM can not use some of other memory types. */
75 size_t cbName = strlen(pszName) + 1;
76 char *pszCopy = (char *)RTMemAlloc(cbName);
77 if (pszCopy == NULL)
78 {
79 return VERR_NO_MEMORY;
80 }
81
82 memcpy(pszCopy, pszName, cbName);
83
84 VBoxHostChannelAttach parms;
85
86 parms.hdr.result = VERR_WRONG_ORDER;
87 parms.hdr.u32ClientID = u32HGCMClientId;
88 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_ATTACH;
89 parms.hdr.cParms = 3;
90
91 VbglHGCMParmPtrSet(&parms.name, pszCopy, (uint32_t)cbName);
92 VbglHGCMParmUInt32Set(&parms.flags, u32Flags);
93 VbglHGCMParmUInt32Set(&parms.handle, 0);
94
95 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
96
97 if (RT_SUCCESS(rc))
98 {
99 rc = parms.hdr.result;
100 if (RT_SUCCESS(rc))
101 {
102 *pu32ChannelHandle = parms.handle.u.value32;
103 }
104 }
105
106 RTMemFree(pszCopy);
107
108 return rc;
109}
110
111VBGLR3DECL(void) VbglR3HostChannelDetach(uint32_t u32ChannelHandle,
112 uint32_t u32HGCMClientId)
113{
114 VBoxHostChannelDetach parms;
115
116 parms.hdr.result = VERR_WRONG_ORDER;
117 parms.hdr.u32ClientID = u32HGCMClientId;
118 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_DETACH;
119 parms.hdr.cParms = 1;
120
121 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
122
123 vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
124}
125
126VBGLR3DECL(int) VbglR3HostChannelSend(uint32_t u32ChannelHandle,
127 uint32_t u32HGCMClientId,
128 void *pvData,
129 uint32_t cbData)
130{
131 VBoxHostChannelSend parms;
132
133 parms.hdr.result = VERR_WRONG_ORDER;
134 parms.hdr.u32ClientID = u32HGCMClientId;
135 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_SEND;
136 parms.hdr.cParms = 2;
137
138 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
139 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
140
141 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
142
143 if (RT_SUCCESS(rc))
144 {
145 rc = parms.hdr.result;
146 }
147
148 return rc;
149}
150
151VBGLR3DECL(int) VbglR3HostChannelRecv(uint32_t u32ChannelHandle,
152 uint32_t u32HGCMClientId,
153 void *pvData,
154 uint32_t cbData,
155 uint32_t *pu32SizeReceived,
156 uint32_t *pu32SizeRemaining)
157{
158 VBoxHostChannelRecv parms;
159
160 parms.hdr.result = VERR_WRONG_ORDER;
161 parms.hdr.u32ClientID = u32HGCMClientId;
162 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_RECV;
163 parms.hdr.cParms = 4;
164
165 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
166 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
167 VbglHGCMParmUInt32Set(&parms.sizeReceived, 0);
168 VbglHGCMParmUInt32Set(&parms.sizeRemaining, 0);
169
170 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
171
172 if (RT_SUCCESS(rc))
173 {
174 rc = parms.hdr.result;
175
176 if (RT_SUCCESS(rc))
177 {
178 *pu32SizeReceived = parms.sizeReceived.u.value32;
179 *pu32SizeRemaining = parms.sizeRemaining.u.value32;
180 }
181 }
182
183 return rc;
184}
185
186VBGLR3DECL(int) VbglR3HostChannelControl(uint32_t u32ChannelHandle,
187 uint32_t u32HGCMClientId,
188 uint32_t u32Code,
189 void *pvParm,
190 uint32_t cbParm,
191 void *pvData,
192 uint32_t cbData,
193 uint32_t *pu32SizeDataReturned)
194{
195 VBoxHostChannelControl parms;
196
197 parms.hdr.result = VERR_WRONG_ORDER;
198 parms.hdr.u32ClientID = u32HGCMClientId;
199 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_CONTROL;
200 parms.hdr.cParms = 5;
201
202 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
203 VbglHGCMParmUInt32Set(&parms.code, u32Code);
204 VbglHGCMParmPtrSet(&parms.parm, pvParm, cbParm);
205 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
206 VbglHGCMParmUInt32Set(&parms.sizeDataReturned, 0);
207
208 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
209
210 if (RT_SUCCESS(rc))
211 {
212 rc = parms.hdr.result;
213
214 if (RT_SUCCESS(rc))
215 {
216 *pu32SizeDataReturned = parms.sizeDataReturned.u.value32;
217 }
218 }
219
220 return rc;
221}
222
223VBGLR3DECL(int) VbglR3HostChannelEventWait(uint32_t *pu32ChannelHandle,
224 uint32_t u32HGCMClientId,
225 uint32_t *pu32EventId,
226 void *pvParm,
227 uint32_t cbParm,
228 uint32_t *pu32SizeReturned)
229{
230 VBoxHostChannelEventWait parms;
231
232 parms.hdr.result = VERR_WRONG_ORDER;
233 parms.hdr.u32ClientID = u32HGCMClientId;
234 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_EVENT_WAIT;
235 parms.hdr.cParms = 4;
236
237 VbglHGCMParmUInt32Set(&parms.handle, 0);
238 VbglHGCMParmUInt32Set(&parms.id, 0);
239 VbglHGCMParmPtrSet(&parms.parm, pvParm, cbParm);
240 VbglHGCMParmUInt32Set(&parms.sizeReturned, 0);
241
242 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
243
244 if (RT_SUCCESS(rc))
245 {
246 rc = parms.hdr.result;
247
248 if (RT_SUCCESS(rc))
249 {
250 *pu32ChannelHandle = parms.handle.u.value32;
251 *pu32EventId = parms.id.u.value32;
252 *pu32SizeReturned = parms.sizeReturned.u.value32;
253 }
254 }
255
256 return rc;
257}
258
259VBGLR3DECL(int) VbglR3HostChannelEventCancel(uint32_t u32ChannelHandle,
260 uint32_t u32HGCMClientId)
261{
262 VBoxHostChannelEventCancel parms;
263
264 parms.hdr.result = VERR_WRONG_ORDER;
265 parms.hdr.u32ClientID = u32HGCMClientId;
266 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_EVENT_CANCEL;
267 parms.hdr.cParms = 0;
268
269 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
270
271 if (RT_SUCCESS(rc))
272 {
273 rc = parms.hdr.result;
274 }
275
276 return rc;
277}
278
279VBGLR3DECL(int) VbglR3HostChannelQuery(const char *pszName,
280 uint32_t u32HGCMClientId,
281 uint32_t u32Code,
282 void *pvParm,
283 uint32_t cbParm,
284 void *pvData,
285 uint32_t cbData,
286 uint32_t *pu32SizeDataReturned)
287{
288 /* Make a heap copy of the name, because HGCM can not use some of other memory types. */
289 size_t cbName = strlen(pszName) + 1;
290 char *pszCopy = (char *)RTMemAlloc(cbName);
291 if (pszCopy == NULL)
292 {
293 return VERR_NO_MEMORY;
294 }
295
296 memcpy(pszCopy, pszName, cbName);
297
298 VBoxHostChannelQuery parms;
299
300 parms.hdr.result = VERR_WRONG_ORDER;
301 parms.hdr.u32ClientID = u32HGCMClientId;
302 parms.hdr.u32Function = VBOX_HOST_CHANNEL_FN_QUERY;
303 parms.hdr.cParms = 5;
304
305 VbglHGCMParmPtrSet(&parms.name, pszCopy, (uint32_t)cbName);
306 VbglHGCMParmUInt32Set(&parms.code, u32Code);
307 VbglHGCMParmPtrSet(&parms.parm, pvParm, cbParm);
308 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
309 VbglHGCMParmUInt32Set(&parms.sizeDataReturned, 0);
310
311 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
312
313 if (RT_SUCCESS(rc))
314 {
315 rc = parms.hdr.result;
316
317 if (RT_SUCCESS(rc))
318 {
319 *pu32SizeDataReturned = parms.sizeDataReturned.u.value32;
320 }
321 }
322
323 RTMemFree(pszCopy);
324
325 return rc;
326}
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