VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedClipboard/service.cpp@ 4922

Last change on this file since 4922 was 4071, checked in by vboxsync, 18 years ago

Biggest check-in ever. New source code headers for all (C) innotek files.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 22.6 KB
Line 
1/** @file
2 *
3 * Shared Clipboard:
4 * Host service entry points.
5 */
6
7/*
8 * Copyright (C) 2006-2007 innotek GmbH
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License as published by the Free Software Foundation,
14 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
15 * distribution. VirtualBox OSE is distributed in the hope that it will
16 * be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#include <VBox/HostServices/VBoxClipboardSvc.h>
20#include <VBox/HostServices/VBoxClipboardExt.h>
21
22#include <iprt/alloc.h>
23#include <iprt/string.h>
24#include <iprt/assert.h>
25#include <iprt/critsect.h>
26#include <VBox/ssm.h>
27
28#include "VBoxClipboard.h"
29
30#define VBOX_HGCM_PARM_COUNT(a) ((sizeof (a) - sizeof (((a *)0)->hdr)) / sizeof (HGCMFunctionParameter))
31
32static void VBoxHGCMParmUInt32Set (VBOXHGCMSVCPARM *pParm, uint32_t u32)
33{
34 pParm->type = VBOX_HGCM_SVC_PARM_32BIT;
35 pParm->u.uint32 = u32;
36}
37
38static int VBoxHGCMParmUInt32Get (VBOXHGCMSVCPARM *pParm, uint32_t *pu32)
39{
40 if (pParm->type == VBOX_HGCM_SVC_PARM_32BIT)
41 {
42 *pu32 = pParm->u.uint32;
43 return VINF_SUCCESS;
44 }
45
46 return VERR_INVALID_PARAMETER;
47}
48
49#if 0
50static void VBoxHGCMParmPtrSet (VBOXHGCMSVCPARM *pParm, void *pv, uint32_t cb)
51{
52 pParm->type = VBOX_HGCM_SVC_PARM_PTR;
53 pParm->u.pointer.size = cb;
54 pParm->u.pointer.addr = pv;
55}
56#endif
57
58static int VBoxHGCMParmPtrGet (VBOXHGCMSVCPARM *pParm, void **ppv, uint32_t *pcb)
59{
60 if (pParm->type == VBOX_HGCM_SVC_PARM_PTR)
61 {
62 *ppv = pParm->u.pointer.addr;
63 *pcb = pParm->u.pointer.size;
64 return VINF_SUCCESS;
65 }
66
67 return VERR_INVALID_PARAMETER;
68}
69
70static PVBOXHGCMSVCHELPERS g_pHelpers;
71
72static RTCRITSECT critsect;
73static uint32_t g_u32Mode;
74
75static PFNHGCMSVCEXT g_pfnExtension;
76static void *g_pvExtension;
77
78static VBOXCLIPBOARDCLIENTDATA *g_pClient;
79
80static uint32_t vboxSvcClipboardMode (void)
81{
82 return g_u32Mode;
83}
84
85static void vboxSvcClipboardModeSet (uint32_t u32Mode)
86{
87 switch (u32Mode)
88 {
89 case VBOX_SHARED_CLIPBOARD_MODE_OFF:
90 case VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST:
91 case VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST:
92 case VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL:
93 g_u32Mode = u32Mode;
94 break;
95
96 default:
97 g_u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
98 }
99}
100
101bool vboxSvcClipboardLock (void)
102{
103 return VBOX_SUCCESS(RTCritSectEnter (&critsect));
104}
105
106void vboxSvcClipboardUnlock (void)
107{
108 RTCritSectLeave (&critsect);
109}
110
111/* Set the HGCM parameters according to pending messages.
112 * Executed under the clipboard lock.
113 */
114static bool vboxSvcClipboardReturnMsg (VBOXCLIPBOARDCLIENTDATA *pClient, VBOXHGCMSVCPARM paParms[])
115{
116 /* Message priority is taken into account. */
117 if (pClient->fMsgQuit)
118 {
119 LogFlow(("vboxSvcClipboardReturnMsg: Quit\n"));
120 VBoxHGCMParmUInt32Set (&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT);
121 VBoxHGCMParmUInt32Set (&paParms[1], 0);
122 pClient->fMsgQuit = false;
123 }
124 else if (pClient->fMsgReadData)
125 {
126 LogFlow(("vboxSvcClipboardReturnMsg: ReadData %02X\n", pClient->u32RequestedFormat));
127 VBoxHGCMParmUInt32Set (&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA);
128 VBoxHGCMParmUInt32Set (&paParms[1], pClient->u32RequestedFormat);
129 pClient->fMsgReadData = false;
130 }
131 else if (pClient->fMsgFormats)
132 {
133 LogFlow(("vboxSvcClipboardReturnMsg: Formats %02X\n", pClient->u32AvailableFormats));
134 VBoxHGCMParmUInt32Set (&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS);
135 VBoxHGCMParmUInt32Set (&paParms[1], pClient->u32AvailableFormats);
136 pClient->fMsgFormats = false;
137 }
138 else
139 {
140 /* No pending messages. */
141 LogFlow(("vboxSvcClipboardReturnMsg: no message\n"));
142 return false;
143 }
144
145 /* Message information assigned. */
146 return true;
147}
148
149void vboxSvcClipboardReportMsg (VBOXCLIPBOARDCLIENTDATA *pClient, uint32_t u32Msg, uint32_t u32Formats)
150{
151 if (vboxSvcClipboardLock ())
152 {
153 switch (u32Msg)
154 {
155 case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
156 {
157 LogFlow(("vboxSvcClipboardReportMsg: Quit\n"));
158 pClient->fMsgQuit = true;
159 } break;
160 case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
161 {
162 if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
163 && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
164 {
165 /* Skip the message. */
166 break;
167 }
168
169 LogFlow(("vboxSvcClipboardReportMsg: ReadData %02X\n", u32Formats));
170 pClient->u32RequestedFormat = u32Formats;
171 pClient->fMsgReadData = true;
172 } break;
173 case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
174 {
175 if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
176 && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
177 {
178 /* Skip the message. */
179 break;
180 }
181
182 LogFlow(("vboxSvcClipboardReportMsg: Formats %02X\n", u32Formats));
183 pClient->u32AvailableFormats = u32Formats;
184 pClient->fMsgFormats = true;
185 } break;
186 default:
187 {
188 /* Invalid message. */
189 LogFlow(("vboxSvcClipboardReportMsg: invalid message %d\n", u32Msg));
190 } break;
191 }
192
193 if (pClient->fAsync)
194 {
195 bool fMessageReturned = vboxSvcClipboardReturnMsg (pClient, pClient->async.paParms);
196
197 if (fMessageReturned)
198 {
199 LogFlow(("vboxSvcClipboardReportMsg: CallComplete\n"));
200 g_pHelpers->pfnCallComplete (pClient->async.callHandle, VINF_SUCCESS);
201 pClient->fAsync = false;
202 }
203 }
204
205 vboxSvcClipboardUnlock ();
206 }
207}
208
209static int svcInit (void)
210{
211 RTCritSectInit (&critsect);
212 vboxSvcClipboardModeSet (VBOX_SHARED_CLIPBOARD_MODE_OFF);
213 return vboxClipboardInit ();
214}
215
216static DECLCALLBACK(int) svcUnload (void)
217{
218 vboxClipboardDestroy ();
219 RTCritSectDelete (&critsect);
220 return VINF_SUCCESS;
221}
222
223static DECLCALLBACK(int) svcConnect (uint32_t u32ClientID, void *pvClient)
224{
225 VBOXCLIPBOARDCLIENTDATA *pClient = (VBOXCLIPBOARDCLIENTDATA *)pvClient;
226
227 /* Register the client. */
228 int rc = VINF_SUCCESS;
229
230 memset (pClient, 0, sizeof (*pClient));
231
232 pClient->u32ClientID = u32ClientID;
233
234 rc = vboxClipboardConnect (pClient);
235
236 if (VBOX_SUCCESS (rc))
237 {
238 g_pClient = pClient;
239 }
240
241 Log(("vboxClipboardConnect: rc = %Vrc\n", rc));
242
243 return rc;
244}
245
246static DECLCALLBACK(int) svcDisconnect (uint32_t u32ClientID, void *pvClient)
247{
248 VBOXCLIPBOARDCLIENTDATA *pClient = (VBOXCLIPBOARDCLIENTDATA *)pvClient;
249
250 vboxSvcClipboardReportMsg (pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0);
251
252 vboxClipboardDisconnect (pClient);
253
254 memset (pClient, 0, sizeof (*pClient));
255
256 g_pClient = NULL;
257
258 return VINF_SUCCESS;
259}
260
261static DECLCALLBACK(void) svcCall (VBOXHGCMCALLHANDLE callHandle,
262 uint32_t u32ClientID,
263 void *pvClient,
264 uint32_t u32Function,
265 uint32_t cParms,
266 VBOXHGCMSVCPARM paParms[])
267{
268 int rc = VINF_SUCCESS;
269
270 Log(("svcCall: u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n",
271 u32ClientID, u32Function, cParms, paParms));
272
273 VBOXCLIPBOARDCLIENTDATA *pClient = (VBOXCLIPBOARDCLIENTDATA *)pvClient;
274
275 bool fAsynchronousProcessing = false;
276
277#ifdef DEBUG
278 uint32_t i;
279
280 for (i = 0; i < cParms; i++)
281 {
282 /** @todo parameters other than 32 bit */
283 Log((" pparms[%d]: type %d value %d\n", i, paParms[i].type, paParms[i].u.uint32));
284 }
285#endif
286
287 switch (u32Function)
288 {
289 case VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG:
290 {
291 /* The quest requests a host message. */
292 Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG\n"));
293
294 if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardGetHostMsg))
295 {
296 rc = VERR_INVALID_PARAMETER;
297 }
298 else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* msg */
299 || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* formats */
300 )
301 {
302 rc = VERR_INVALID_PARAMETER;
303 }
304 else
305 {
306 /* Atomically verify the client's state. */
307 if (vboxSvcClipboardLock ())
308 {
309 bool fMessageReturned = vboxSvcClipboardReturnMsg (pClient, paParms);
310
311 if (fMessageReturned)
312 {
313 /* Just return to the caller. */
314 pClient->fAsync = false;
315 }
316 else
317 {
318 /* No event available at the time. Process asynchronously. */
319 fAsynchronousProcessing = true;
320
321 pClient->fAsync = true;
322 pClient->async.callHandle = callHandle;
323 pClient->async.paParms = paParms;
324
325 Log(("svcCall: async.\n"));
326 }
327
328 vboxSvcClipboardUnlock ();
329 }
330 else
331 {
332 rc = VERR_NOT_SUPPORTED;
333 }
334 }
335 } break;
336
337 case VBOX_SHARED_CLIPBOARD_FN_FORMATS:
338 {
339 /* The guest reports that some formats are available. */
340 Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_FORMATS\n"));
341
342 if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardFormats))
343 {
344 rc = VERR_INVALID_PARAMETER;
345 }
346 else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* formats */
347 )
348 {
349 rc = VERR_INVALID_PARAMETER;
350 }
351 else
352 {
353 uint32_t u32Formats;
354
355 rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Formats);
356
357 if (VBOX_SUCCESS (rc))
358 {
359 if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
360 && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
361 {
362 rc = VERR_NOT_SUPPORTED;
363 break;
364 }
365
366 if (g_pfnExtension)
367 {
368 VBOXCLIPBOARDEXTPARMS parms;
369
370 parms.u32Format = u32Formats;
371
372 g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE, &parms, sizeof (parms));
373 }
374 else
375 {
376 vboxClipboardFormatAnnounce (pClient, u32Formats);
377 }
378 }
379 }
380 } break;
381
382 case VBOX_SHARED_CLIPBOARD_FN_READ_DATA:
383 {
384 /* The guest wants to read data in the given format. */
385 Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_READ_DATA\n"));
386
387 if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardReadData))
388 {
389 rc = VERR_INVALID_PARAMETER;
390 }
391 else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* format */
392 || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* ptr */
393 || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* size */
394 )
395 {
396 rc = VERR_INVALID_PARAMETER;
397 }
398 else
399 {
400 uint32_t u32Format;
401 void *pv;
402 uint32_t cb;
403
404 rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Format);
405
406 if (VBOX_SUCCESS (rc))
407 {
408 rc = VBoxHGCMParmPtrGet (&paParms[1], &pv, &cb);
409
410 if (VBOX_SUCCESS (rc))
411 {
412 if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST
413 && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
414 {
415 rc = VERR_NOT_SUPPORTED;
416 break;
417 }
418
419 uint32_t cbActual = 0;
420
421 if (g_pfnExtension)
422 {
423 VBOXCLIPBOARDEXTPARMS parms;
424
425 parms.u32Format = u32Format;
426 parms.pvData = pv;
427 parms.cbData = cb;
428
429 rc = g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_READ, &parms, sizeof (parms));
430
431 if (VBOX_SUCCESS (rc))
432 {
433 cbActual = parms.cbData;
434 }
435 }
436 else
437 {
438 rc = vboxClipboardReadData (pClient, u32Format, pv, cb, &cbActual);
439 }
440
441 if (VBOX_SUCCESS (rc))
442 {
443 VBoxHGCMParmUInt32Set (&paParms[2], cbActual);
444 }
445 }
446 }
447 }
448 } break;
449
450 case VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA:
451 {
452 /* The guest writes the requested data. */
453 Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA\n"));
454
455 if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardWriteData))
456 {
457 rc = VERR_INVALID_PARAMETER;
458 }
459 else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* format */
460 || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* ptr */
461 )
462 {
463 rc = VERR_INVALID_PARAMETER;
464 }
465 else
466 {
467 void *pv;
468 uint32_t cb;
469 uint32_t u32Format;
470
471 rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Format);
472
473 if (VBOX_SUCCESS (rc))
474 {
475 rc = VBoxHGCMParmPtrGet (&paParms[1], &pv, &cb);
476
477 if (VBOX_SUCCESS (rc))
478 {
479 if ( vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_GUEST_TO_HOST
480 && vboxSvcClipboardMode () != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL)
481 {
482 rc = VERR_NOT_SUPPORTED;
483 break;
484 }
485
486 if (g_pfnExtension)
487 {
488 VBOXCLIPBOARDEXTPARMS parms;
489
490 parms.u32Format = u32Format;
491 parms.pvData = pv;
492 parms.cbData = cb;
493
494 g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_WRITE, &parms, sizeof (parms));
495 }
496 else
497 {
498 vboxClipboardWriteData (pClient, pv, cb, u32Format);
499 }
500 }
501 }
502 }
503 } break;
504
505 default:
506 {
507 rc = VERR_NOT_IMPLEMENTED;
508 }
509 }
510
511 LogFlow(("svcCall: rc = %Vrc\n", rc));
512
513 if (!fAsynchronousProcessing)
514 {
515 g_pHelpers->pfnCallComplete (callHandle, rc);
516 }
517}
518
519/*
520 * We differentiate between a function handler for the guest and one for the host.
521 */
522static DECLCALLBACK(int) svcHostCall (uint32_t u32Function,
523 uint32_t cParms,
524 VBOXHGCMSVCPARM paParms[])
525{
526 int rc = VINF_SUCCESS;
527
528 Log(("svcHostCall: fn = %d, cParms = %d, pparms = %d\n",
529 u32Function, cParms, paParms));
530
531 switch (u32Function)
532 {
533 case VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE:
534 {
535 Log(("svcCall: VBOX_SHARED_CLIPBOARD_HOST_FN_SET_MODE\n"));
536
537 if (cParms != 1)
538 {
539 rc = VERR_INVALID_PARAMETER;
540 }
541 else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* mode */
542 )
543 {
544 rc = VERR_INVALID_PARAMETER;
545 }
546 else
547 {
548 uint32_t u32Mode = VBOX_SHARED_CLIPBOARD_MODE_OFF;
549
550 rc = VBoxHGCMParmUInt32Get (&paParms[0], &u32Mode);
551
552 /* The setter takes care of invalid values. */
553 vboxSvcClipboardModeSet (u32Mode);
554 }
555 } break;
556
557 default:
558 break;
559 }
560
561 LogFlow(("svcHostCall: rc = %Vrc\n", rc));
562 return rc;
563}
564
565static DECLCALLBACK(int) svcSaveState(uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
566{
567 /* If there are any pending requests, they must be completed here. Since
568 * the service is single threaded, there could be only requests
569 * which the service itself has postponed.
570 *
571 * HGCM knows that the state is being saved and that the pfnComplete
572 * calls are just clean ups. These requests are saved by the VMMDev.
573 *
574 * When the state will be restored, these requests will be reissued
575 * by VMMDev. The service therefore must save state as if there were no
576 * pending request.
577 */
578 Log(("svcSaveState: u32ClientID = %d\n", u32ClientID));
579
580 VBOXCLIPBOARDCLIENTDATA *pClient = (VBOXCLIPBOARDCLIENTDATA *)pvClient;
581
582 /* Save client structure length & contents */
583 int rc = SSMR3PutU32(pSSM, sizeof(*pClient));
584 AssertRCReturn(rc, rc);
585
586 rc = SSMR3PutMem(pSSM, pClient, sizeof(*pClient));
587 AssertRCReturn(rc, rc);
588
589 if (pClient->fAsync)
590 {
591 g_pHelpers->pfnCallComplete (pClient->async.callHandle, VINF_SUCCESS /* error code is not important here. */);
592 pClient->fAsync = false;
593 }
594
595 return VINF_SUCCESS;
596}
597
598static DECLCALLBACK(int) svcLoadState(uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
599{
600 Log(("svcLoadState: u32ClientID = %d\n", u32ClientID));
601
602 VBOXCLIPBOARDCLIENTDATA *pClient = (VBOXCLIPBOARDCLIENTDATA *)pvClient;
603
604 /* Existing client can not be in async state yet. */
605 Assert(!pClient->fAsync);
606
607 /* Restore the client data. */
608 uint32_t len;
609 int rc = SSMR3GetU32(pSSM, &len);
610 AssertRCReturn(rc, rc);
611
612 if (len != sizeof(VBOXCLIPBOARDCLIENTDATA))
613 {
614 Log(("Client len mismatch: %d %d\n", len, sizeof (VBOXCLIPBOARDCLIENTDATA)));
615 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
616 }
617
618 VBOXCLIPBOARDCLIENTDATA client;
619 rc = SSMR3GetMem(pSSM, &client, sizeof(client));
620 AssertRCReturn(rc, rc);
621
622 /* Verify the loaded clients data and update the pClient. */
623 if (pClient->u32ClientID != client.u32ClientID)
624 {
625 Log(("Client ID mismatch: %d %d\n", pClient->u32ClientID, client.u32ClientID));
626 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
627 }
628
629 pClient->fMsgQuit = client.fMsgQuit;
630 pClient->fMsgReadData = client.fMsgReadData;
631 pClient->fMsgFormats = client.fMsgFormats;
632 pClient->u32RequestedFormat = client.u32RequestedFormat;
633
634 /* Actual host data are to be reported to guest (SYNC). */
635 vboxClipboardSync (pClient);
636
637 return VINF_SUCCESS;
638}
639
640static DECLCALLBACK(int) extCallback (uint32_t u32Function, uint32_t u32Format, void *pvData, uint32_t cbData)
641{
642 if (g_pClient != NULL)
643 {
644 switch (u32Function)
645 {
646 case VBOX_CLIPBOARD_EXT_FN_FORMAT_ANNOUNCE:
647 {
648 vboxSvcClipboardReportMsg (g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS, u32Format);
649 } break;
650
651 case VBOX_CLIPBOARD_EXT_FN_DATA_READ:
652 {
653 vboxSvcClipboardReportMsg (g_pClient, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);
654 } break;
655
656 default:
657 return VERR_NOT_SUPPORTED;
658 }
659 }
660
661 return VINF_SUCCESS;
662}
663
664static DECLCALLBACK(int) svcRegisterExtension(PFNHGCMSVCEXT pfnExtension, void *pvExtension)
665{
666 LogFlowFunc(("pfnExtension = %p\n", pfnExtension));
667
668 VBOXCLIPBOARDEXTPARMS parms;
669
670 if (pfnExtension)
671 {
672 /* Install extension. */
673 g_pfnExtension = pfnExtension;
674 g_pvExtension = pvExtension;
675
676 parms.pvData = (void *)extCallback;
677 g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK, &parms, sizeof (parms));
678 }
679 else
680 {
681 if (g_pfnExtension)
682 {
683 parms.pvData = NULL;
684 g_pfnExtension (g_pvExtension, VBOX_CLIPBOARD_EXT_FN_SET_CALLBACK, &parms, sizeof (parms));
685 }
686
687 /* Uninstall extension. */
688 g_pfnExtension = NULL;
689 g_pvExtension = NULL;
690 }
691
692 return VINF_SUCCESS;
693}
694
695extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
696{
697 int rc = VINF_SUCCESS;
698
699 LogFlowFunc(("ptable = %p\n", ptable));
700
701 if (!ptable)
702 {
703 rc = VERR_INVALID_PARAMETER;
704 }
705 else
706 {
707 Log(("VBoxHGCMSvcLoad: ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", ptable->cbSize, ptable->u32Version));
708
709 if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
710 || ptable->u32Version != VBOX_HGCM_SVC_VERSION)
711 {
712 rc = VERR_INVALID_PARAMETER;
713 }
714 else
715 {
716 g_pHelpers = ptable->pHelpers;
717
718 ptable->cbClient = sizeof (VBOXCLIPBOARDCLIENTDATA);
719
720 ptable->pfnUnload = svcUnload;
721 ptable->pfnConnect = svcConnect;
722 ptable->pfnDisconnect = svcDisconnect;
723 ptable->pfnCall = svcCall;
724 ptable->pfnHostCall = svcHostCall;
725 ptable->pfnSaveState = svcSaveState;
726 ptable->pfnLoadState = svcLoadState;
727 ptable->pfnRegisterExtension = svcRegisterExtension;
728
729 /* Service specific initialization. */
730 rc = svcInit ();
731 }
732 }
733
734 return rc;
735}
Note: See TracBrowser for help on using the repository browser.

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