VirtualBox

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

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

VBoxGuestLib: Use common VbglR3HGCMDisconnect to disconnect.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 9.2 KB
Line 
1/* $Id: VBoxGuestR3LibHostChannel.cpp 68462 2017-08-18 11:23:02Z vboxsync $ */
2/** @file
3 * VBoxGuestR3Lib - Ring-3 Support Library for VirtualBox guest additions, Host Channel.
4 */
5
6/*
7 * Copyright (C) 2012-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#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 VbglR3HGCMDisconnect(u32HGCMClientId);
63}
64
65VBGLR3DECL(int) VbglR3HostChannelAttach(uint32_t *pu32ChannelHandle,
66 uint32_t u32HGCMClientId,
67 const char *pszName,
68 uint32_t u32Flags)
69{
70 /* Make a heap copy of the name, because HGCM can not use some of other memory types. */
71 size_t cbName = strlen(pszName) + 1;
72 char *pszCopy = (char *)RTMemAlloc(cbName);
73 if (pszCopy == NULL)
74 {
75 return VERR_NO_MEMORY;
76 }
77
78 memcpy(pszCopy, pszName, cbName);
79
80 VBoxHostChannelAttach parms;
81 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_ATTACH, 3);
82 VbglHGCMParmPtrSet(&parms.name, pszCopy, (uint32_t)cbName);
83 VbglHGCMParmUInt32Set(&parms.flags, u32Flags);
84 VbglHGCMParmUInt32Set(&parms.handle, 0);
85
86 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
87
88 if (RT_SUCCESS(rc))
89 {
90 rc = parms.hdr.result;
91 if (RT_SUCCESS(rc))
92 {
93 *pu32ChannelHandle = parms.handle.u.value32;
94 }
95 }
96
97 RTMemFree(pszCopy);
98
99 return rc;
100}
101
102VBGLR3DECL(void) VbglR3HostChannelDetach(uint32_t u32ChannelHandle,
103 uint32_t u32HGCMClientId)
104{
105 VBoxHostChannelDetach parms;
106 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_DETACH, 1);
107 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
108
109 vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
110}
111
112VBGLR3DECL(int) VbglR3HostChannelSend(uint32_t u32ChannelHandle,
113 uint32_t u32HGCMClientId,
114 void *pvData,
115 uint32_t cbData)
116{
117 VBoxHostChannelSend parms;
118 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_SEND, 2);
119 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
120 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
121
122 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
123
124 if (RT_SUCCESS(rc))
125 {
126 rc = parms.hdr.result;
127 }
128
129 return rc;
130}
131
132VBGLR3DECL(int) VbglR3HostChannelRecv(uint32_t u32ChannelHandle,
133 uint32_t u32HGCMClientId,
134 void *pvData,
135 uint32_t cbData,
136 uint32_t *pu32SizeReceived,
137 uint32_t *pu32SizeRemaining)
138{
139 VBoxHostChannelRecv parms;
140 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_RECV, 4);
141 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
142 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
143 VbglHGCMParmUInt32Set(&parms.sizeReceived, 0);
144 VbglHGCMParmUInt32Set(&parms.sizeRemaining, 0);
145
146 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
147
148 if (RT_SUCCESS(rc))
149 {
150 rc = parms.hdr.result;
151
152 if (RT_SUCCESS(rc))
153 {
154 *pu32SizeReceived = parms.sizeReceived.u.value32;
155 *pu32SizeRemaining = parms.sizeRemaining.u.value32;
156 }
157 }
158
159 return rc;
160}
161
162VBGLR3DECL(int) VbglR3HostChannelControl(uint32_t u32ChannelHandle,
163 uint32_t u32HGCMClientId,
164 uint32_t u32Code,
165 void *pvParm,
166 uint32_t cbParm,
167 void *pvData,
168 uint32_t cbData,
169 uint32_t *pu32SizeDataReturned)
170{
171 VBoxHostChannelControl parms;
172 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_CONTROL, 5);
173 VbglHGCMParmUInt32Set(&parms.handle, u32ChannelHandle);
174 VbglHGCMParmUInt32Set(&parms.code, u32Code);
175 VbglHGCMParmPtrSet(&parms.parm, pvParm, cbParm);
176 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
177 VbglHGCMParmUInt32Set(&parms.sizeDataReturned, 0);
178
179 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
180
181 if (RT_SUCCESS(rc))
182 {
183 rc = parms.hdr.result;
184
185 if (RT_SUCCESS(rc))
186 {
187 *pu32SizeDataReturned = parms.sizeDataReturned.u.value32;
188 }
189 }
190
191 return rc;
192}
193
194VBGLR3DECL(int) VbglR3HostChannelEventWait(uint32_t *pu32ChannelHandle,
195 uint32_t u32HGCMClientId,
196 uint32_t *pu32EventId,
197 void *pvParm,
198 uint32_t cbParm,
199 uint32_t *pu32SizeReturned)
200{
201 VBoxHostChannelEventWait parms;
202 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_EVENT_WAIT, 4);
203 VbglHGCMParmUInt32Set(&parms.handle, 0);
204 VbglHGCMParmUInt32Set(&parms.id, 0);
205 VbglHGCMParmPtrSet(&parms.parm, pvParm, cbParm);
206 VbglHGCMParmUInt32Set(&parms.sizeReturned, 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 *pu32ChannelHandle = parms.handle.u.value32;
217 *pu32EventId = parms.id.u.value32;
218 *pu32SizeReturned = parms.sizeReturned.u.value32;
219 }
220 }
221
222 return rc;
223}
224
225VBGLR3DECL(int) VbglR3HostChannelEventCancel(uint32_t u32ChannelHandle,
226 uint32_t u32HGCMClientId)
227{
228 RT_NOREF1(u32ChannelHandle);
229
230 VBoxHostChannelEventCancel parms;
231 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_EVENT_CANCEL, 0);
232
233 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
234
235 if (RT_SUCCESS(rc))
236 {
237 rc = parms.hdr.result;
238 }
239
240 return rc;
241}
242
243VBGLR3DECL(int) VbglR3HostChannelQuery(const char *pszName,
244 uint32_t u32HGCMClientId,
245 uint32_t u32Code,
246 void *pvParm,
247 uint32_t cbParm,
248 void *pvData,
249 uint32_t cbData,
250 uint32_t *pu32SizeDataReturned)
251{
252 /* Make a heap copy of the name, because HGCM can not use some of other memory types. */
253 size_t cbName = strlen(pszName) + 1;
254 char *pszCopy = (char *)RTMemAlloc(cbName);
255 if (pszCopy == NULL)
256 {
257 return VERR_NO_MEMORY;
258 }
259
260 memcpy(pszCopy, pszName, cbName);
261
262 VBoxHostChannelQuery parms;
263 VBGL_HGCM_HDR_INIT(&parms.hdr, u32HGCMClientId, VBOX_HOST_CHANNEL_FN_QUERY, 5);
264 VbglHGCMParmPtrSet(&parms.name, pszCopy, (uint32_t)cbName);
265 VbglHGCMParmUInt32Set(&parms.code, u32Code);
266 VbglHGCMParmPtrSet(&parms.parm, pvParm, cbParm);
267 VbglHGCMParmPtrSet(&parms.data, pvData, cbData);
268 VbglHGCMParmUInt32Set(&parms.sizeDataReturned, 0);
269
270 int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(parms)), &parms, sizeof(parms));
271
272 if (RT_SUCCESS(rc))
273 {
274 rc = parms.hdr.result;
275
276 if (RT_SUCCESS(rc))
277 {
278 *pu32SizeDataReturned = parms.sizeDataReturned.u.value32;
279 }
280 }
281
282 RTMemFree(pszCopy);
283
284 return rc;
285}
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