← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox/trusty-proposed

« back to all changes in this revision

Viewing changes to src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibHostChannel.cpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-03-07 16:38:36 UTC
  • mfrom: (1.1.13) (3.1.20 experimental)
  • Revision ID: package-import@ubuntu.com-20130307163836-p93jpbgx39tp3gb4
Tags: 4.2.8-dfsg-0ubuntu1
http://bugs.debian.org/691148
http://bugs.debian.org/700823
https://launchpad.net/bugs/1101867
http://bugs.debian.org/700479
http://bugs.debian.org/686994
http://bugs.debian.org/680053
* New upstream release. (Closes: #691148)
  - Fixes compatibility with kernel 3.8. (Closes: #700823; LP: #1101867)
* Switch to my @debian.org email address.
* Move package to contrib as virtualbox 4.2 needs a non-free compiler to
  build the BIOS.
* Build-depend on libdevmapper-dev.
* Refresh patches.
  - Drop 36-fix-ftbfs-xserver-112.patch, cve-2012-3221.patch,
    CVE-2013-0420.patch 37-kcompat-3.6.patch and 38-kcompat-3.7.patch.
* Drop all virtualbox-ose transitional packages.
* Drop the virtualbox-fuse package as vdfuse fails to build with
  virtualbox 4.2.
* Update install files and VBox.sh.
* Bump required kbuild version to 0.1.9998svn2577.
* Fix path to VBoxCreateUSBNode.sh in virtualbox.postinst. (Closes: #700479)
* Add an init script to virtuabox-guest-x11 which loads the vboxvideo
  kernel module. The X Server 1.13 doesn't load it anymore. (Closes: #686994)
* Update man pages. (Closes: #680053)
* Add 36-python-multiarch.patch from Rico Tzschichholz to fix detection of
  python in multiarch paths using pkg-config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibHostChannel.cpp
 
1
/* $Id: VBoxGuestR3LibHostChannel.cpp $ */
 
2
/** @file
 
3
 * VBoxGuestR3Lib - Ring-3 Support Library for VirtualBox guest additions, Host Channel.
 
4
 */
 
5
 
 
6
/*
 
7
 * Copyright (C) 2012 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
 
 
35
VBGLR3DECL(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
 
 
60
VBGLR3DECL(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
 
 
69
VBGLR3DECL(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
 
 
111
VBGLR3DECL(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
 
 
126
VBGLR3DECL(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
 
 
151
VBGLR3DECL(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
 
 
186
VBGLR3DECL(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
 
 
223
VBGLR3DECL(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
 
 
259
VBGLR3DECL(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
 
 
279
VBGLR3DECL(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
}