VBoxServiceClipboard-os2.cpp@ 69496

Last change on this file since 69496 was 69496, checked in by vboxsync, 7 years ago
*: scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.3 KB

Line
1	/** $Id: VBoxServiceClipboard-os2.cpp 69496 2017-10-28 14:55:58Z vboxsync $ */
2	/** @file
3	* VBoxService - Guest Additions Clipboard Service, OS/2.
4	*/
5
6	/*
7	* Copyright (C) 2007-2017 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
18
19	/** @page pg_vgsvc_clipboard VBoxService - Clipboard (OS/2)
20	*
21	* The Clipboard subservice provides clipboard sharing for OS/2 guests only.
22	*
23	* This was the second subservice that was added to VBoxService. OS/2 is a
24	* single user system and we don't provide any VBoxTray or VBoxClient like
25	* processes. Because it's kind of simple system, it became natural to put the
26	* clipboard sharing here in VBoxService for OS/2.
27	*
28	* In addition to integrating with the native OS/2 PM clipboard formats, we also
29	* try provide the Odin32, a windows API layer for OS/2 (developed by Sander van
30	* Leeuwen and friends, later mainly InnoTek), with additional formats.
31	*
32	* Bitmaps are currently not supported, but that can easily be added should the
33	* need ever arrise.
34	*/
35
36
37	/*********************************************************************************************************************************
38	* Header Files *
39	*********************************************************************************************************************************/
40	#define INCL_BASE
41	#define INCL_PM
42	#define INCL_ERRORS
43	#include <os2.h>
44
45	#include <iprt/thread.h>
46	#include <iprt/string.h>
47	#include <iprt/semaphore.h>
48	#include <iprt/time.h>
49	#include <iprt/mem.h>
50	#include <iprt/param.h>
51	#include <iprt/assert.h>
52	#include <iprt/asm.h>
53	#include <VBox/VBoxGuestLib.h>
54	#include <VBox/HostServices/VBoxClipboardSvc.h>
55	#include "VBoxServiceInternal.h"
56
57
58	/*********************************************************************************************************************************
59	* Structures and Typedefs *
60	*********************************************************************************************************************************/
61	/** Header for Odin32 specific clipboard entries.
62	* (Used to get the correct size of the data.)
63	*/
64	typedef struct _Odin32ClipboardHeader
65	{
66	/** magic number */
67	char achMagic[8];
68	/** Size of the following data.
69	* (The interpretation depends on the type.) */
70	unsigned cbData;
71	/** Odin32 format number. */
72	unsigned uFormat;
73	} CLIPHEADER, *PCLIPHEADER;
74
75	#define CLIPHEADER_MAGIC "Odin\1\0\1"
76
77
78	/*********************************************************************************************************************************
79	* Global Variables *
80	*********************************************************************************************************************************/
81
82	/** The control thread (main) handle.
83	* Only used to avoid some queue creation trouble. */
84	static RTTHREAD g_ThreadCtrl = NIL_RTTHREAD;
85	/** The HAB of the control thread (main). */
86	static HAB g_habCtrl = NULLHANDLE;
87	/** The HMQ of the control thread (main). */
88	static HMQ g_hmqCtrl = NULLHANDLE;
89
90	/** The Listener thread handle. */
91	static RTTHREAD g_ThreadListener = NIL_RTTHREAD;
92	/** The HAB of the listener thread. */
93	static HAB g_habListener = NULLHANDLE;
94	/** The HMQ of the listener thread. */
95	static HMQ g_hmqListener = NULLHANDLE;
96	/** Indicator that gets set if the listener thread is successfully initialized. */
97	static bool volatile g_fListenerOkay = false;
98
99	/** The HAB of the worker thread. */
100	static HAB g_habWorker = NULLHANDLE;
101	/** The HMQ of the worker thread. */
102	static HMQ g_hmqWorker = NULLHANDLE;
103	/** The object window handle. */
104	static HWND g_hwndWorker = NULLHANDLE;
105	/** The timer id returned by WinStartTimer. */
106	static ULONG g_idWorkerTimer = ~0UL;
107	/** The state of the clipboard.
108	* @remark I'm trying out the 'k' prefix from the mac here, bear with me. */
109	static enum
110	{
111	/** The clipboard hasn't been initialized yet. */
112	kClipboardState_Uninitialized = 0,
113	/** WinSetClipbrdViewer call in progress, ignore WM_DRAWCLIPBOARD. */
114	kClipboardState_SettingViewer,
115	/** We're monitoring the clipboard as a viewer. */
116	kClipboardState_Viewer,
117	/** We're monitoring the clipboard using polling.
118	* This usually means something is wrong... */
119	kClipboardState_Polling,
120	/** We're destroying the clipboard content, ignore WM_DESTROYCLIPBOARD. */
121	kClipboardState_Destroying,
122	/** We're owning the clipboard (i.e. we have data on it). */
123	kClipboardState_Owner
124	} g_enmState = kClipboardState_Uninitialized;
125	/** Set if the clipboard was empty the last time we polled it. */
126	static bool g_fEmptyClipboard = false;
127
128	/** A clipboard format atom for the dummy clipboard data we insert
129	* watching for clipboard changes. If this format is found on the
130	* clipboard, the empty clipboard function has not been called
131	* since we last polled it. */
132	static ATOM g_atomNothingChanged = 0;
133
134	/** The clipboard connection client ID. */
135	static uint32_t g_u32ClientId;
136	/** Odin32 CF_UNICODETEXT. See user32.cpp. */
137	static ATOM g_atomOdin32UnicodeText = 0;
138	/** Odin32 CF_UNICODETEXT. See user32.cpp. */
139	#define SZFMT_ODIN32_UNICODETEXT (PCSZ)"Odin32 UnicodeText"
140
141
142
143
144	/**
145	* @interface_method_impl{VBOXSERVICE,pfnPreInit}
146	*/
147	static DECLCALLBACK(int) vgsvcClipboardOs2PreInit(void)
148	{
149	return VINF_SUCCESS;
150	}
151
152
153	/**
154	* @interface_method_impl{VBOXSERVICE,pfnOption}
155	*/
156	static DECLCALLBACK(int) vgsvcClipboardOs2Option(const char ppszShort, int argc, char argv, int *pi)
157	{
158	NOREF(ppszShort);
159	NOREF(argc);
160	NOREF(argv);
161	NOREF(pi);
162
163	return -1;
164	}
165
166
167	/**
168	* @interface_method_impl{VBOXSERVICE,pfnInit}
169	*/
170	static DECLCALLBACK(int) vgsvcClipboardOs2Init(void)
171	{
172	int rc = VERR_GENERAL_FAILURE;
173	g_ThreadCtrl = RTThreadSelf();
174
175	/*
176	* Make PM happy.
177	*/
178	PPIB pPib;
179	PTIB pTib;
180	DosGetInfoBlocks(&pTib, &pPib);
181	pPib->pib_ultype = 3; /* PM session type */
182
183	/*
184	* Since we have to send shutdown messages and such from the
185	* service controller (main) thread, create a HAB and HMQ for it.
186	*/
187	g_habCtrl = WinInitialize(0);
188	if (g_habCtrl == NULLHANDLE)
189	{
190	VGSvcError("WinInitialize(0) failed, lasterr=%lx\n", WinGetLastError(NULLHANDLE));
191	return VERR_GENERAL_FAILURE;
192	}
193	g_hmqCtrl = WinCreateMsgQueue(g_habCtrl, 0);
194	if (g_hmqCtrl != NULLHANDLE)
195	{
196	WinCancelShutdown(g_hmqCtrl, TRUE); /* We don't care about shutdown */
197
198	/*
199	* Create the 'nothing-changed' format.
200	*/
201	g_atomNothingChanged = WinAddAtom(WinQuerySystemAtomTable(), (PCSZ)"VirtualBox Clipboard Service");
202	LONG lLastError = WinGetLastError(g_habCtrl);
203	if (g_atomNothingChanged == 0)
204	g_atomNothingChanged = WinFindAtom(WinQuerySystemAtomTable(), (PCSZ)"VirtualBox Clipboard Service");
205	if (g_atomNothingChanged)
206	{
207	/*
208	* Connect to the clipboard service.
209	*/
210	VGSvcVerbose(4, "clipboard: connecting\n");
211	rc = VbglR3ClipboardConnect(&g_u32ClientId);
212	if (RT_SUCCESS(rc))
213	{
214	/*
215	* Create any extra clipboard type atoms, like the odin unicode text.
216	*/
217	g_atomOdin32UnicodeText = WinAddAtom(WinQuerySystemAtomTable(), SZFMT_ODIN32_UNICODETEXT);
218	lLastError = WinGetLastError(g_habCtrl);
219	if (g_atomOdin32UnicodeText == 0)
220	g_atomOdin32UnicodeText = WinFindAtom(WinQuerySystemAtomTable(), SZFMT_ODIN32_UNICODETEXT);
221	if (g_atomOdin32UnicodeText == 0)
222	VGSvcError("WinAddAtom() failed, lasterr=%lx; WinFindAtom() failed, lasterror=%lx\n",
223	lLastError, WinGetLastError(g_habCtrl));
224
225	VGSvcVerbose(2, "g_u32ClientId=%RX32 g_atomNothingChanged=%#x g_atomOdin32UnicodeText=%#x\n",
226	g_u32ClientId, g_atomNothingChanged, g_atomOdin32UnicodeText);
227	return VINF_SUCCESS;
228	}
229
230	VGSvcError("Failed to connect to the clipboard service, rc=%Rrc!\n", rc);
231	}
232	else
233	VGSvcError("WinAddAtom() failed, lasterr=%lx; WinFindAtom() failed, lasterror=%lx\n",
234	lLastError, WinGetLastError(g_habCtrl));
235	}
236	else
237	VGSvcError("WinCreateMsgQueue(,0) failed, lasterr=%lx\n", WinGetLastError(g_habCtrl));
238	WinTerminate(g_habCtrl);
239	return rc;
240	}
241
242
243	/**
244	* Check that we're still the view / try make us the viewer.
245	*/
246	static void vgsvcClipboardOs2PollViewer(void)
247	{
248	const int iOrgState = g_enmState;
249
250	HWND hwndClipboardViewer = WinQueryClipbrdViewer(g_habWorker);
251	if (hwndClipboardViewer == g_hwndWorker)
252	return;
253
254	if (hwndClipboardViewer == NULLHANDLE)
255	{
256	/* The API will send a WM_DRAWCLIPBOARD message before returning. */
257	g_enmState = kClipboardState_SettingViewer;
258	if (WinSetClipbrdViewer(g_habWorker, g_hwndWorker))
259	g_enmState = kClipboardState_Viewer;
260	else
261	g_enmState = kClipboardState_Polling;
262	}
263	else
264	g_enmState = kClipboardState_Polling;
265	if ((int)g_enmState != iOrgState)
266	{
267	if (g_enmState == kClipboardState_Viewer)
268	VGSvcVerbose(3, "clipboard: viewer\n");
269	else
270	VGSvcVerbose(3, "clipboard: poller\n");
271	}
272	}
273
274
275	/**
276	* Advertise the formats available from the host.
277	*
278	* @param fFormats The formats available on the host.
279	*/
280	static void vgsvcClipboardOs2AdvertiseHostFormats(uint32_t fFormats)
281	{
282	/*
283	* Open the clipboard and switch to 'destruction' mode.
284	* Make sure we stop being viewer. Temporarily also make sure we're
285	* not the owner so that PM won't send us any WM_DESTROYCLIPBOARD message.
286	*/
287	if (WinOpenClipbrd(g_habWorker))
288	{
289	if (g_enmState == kClipboardState_Viewer)
290	WinSetClipbrdViewer(g_habWorker, NULLHANDLE);
291	if (g_enmState == kClipboardState_Owner)
292	WinSetClipbrdOwner(g_habWorker, NULLHANDLE);
293
294	g_enmState = kClipboardState_Destroying;
295	if (WinEmptyClipbrd(g_habWorker))
296	{
297	/*
298	* Take clipboard ownership.
299	*/
300	if (WinSetClipbrdOwner(g_habWorker, g_hwndWorker))
301	{
302	g_enmState = kClipboardState_Owner;
303
304	/*
305	* Do the format advertising.
306	*/
307	if (fFormats & (VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT/* \| VBOX_SHARED_CLIPBOARD_FMT_HTML ?? */))
308	{
309	if (!WinSetClipbrdData(g_habWorker, 0, CF_TEXT, CFI_POINTER))
310	VGSvcError("WinSetClipbrdData(,,CF_TEXT,) failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
311	if ( g_atomOdin32UnicodeText
312	&& !WinSetClipbrdData(g_habWorker, 0, g_atomOdin32UnicodeText, CFI_POINTER))
313	VGSvcError("WinSetClipbrdData(,,g_atomOdin32UnicodeText,) failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
314	}
315	if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
316	{
317	/** @todo bitmaps */
318	}
319	}
320	else
321	{
322	VGSvcError("WinSetClipbrdOwner failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
323	g_enmState = kClipboardState_Polling;
324	}
325	}
326	else
327	{
328	VGSvcError("WinEmptyClipbrd failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
329	g_enmState = kClipboardState_Polling;
330	}
331
332	if (g_enmState == kClipboardState_Polling)
333	{
334	g_fEmptyClipboard = true;
335	vgsvcClipboardOs2PollViewer();
336	}
337
338	WinCloseClipbrd(g_habWorker);
339	}
340	else
341	VGSvcError("vgsvcClipboardOs2AdvertiseHostFormats: WinOpenClipbrd failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
342	}
343
344
345	/**
346	* Converts (render) to an Odin32 clipboard format.
347	*
348	* We ASSUME we get windows data from the host and all we've got to do here is
349	* slapping an Odin32 header on it.
350	*
351	* @returns Pointer to the data (DosFreeMem).
352	* @param fFormat The host format.
353	* @param usFmt The PM/Odin32 format.
354	* @param pv The data in host formatting.
355	* @param cb The size of the data.
356	*/
357	static void vgsvcClipboardOs2ConvertToOdin32(uint32_t fFormat, USHORT usFmt, void pv, uint32_t cb)
358	{
359	PVOID pvPM = NULL;
360	APIRET rc = DosAllocSharedMem(&pvPM, NULL, cb + sizeof(CLIPHEADER), OBJ_GIVEABLE \| OBJ_GETTABLE \| OBJ_TILE \| PAG_READ \| PAG_WRITE \| PAG_COMMIT);
361	if (rc)
362	{
363	PCLIPHEADER pHdr = (PCLIPHEADER)pvPM;
364	memcpy(pHdr->achMagic, CLIPHEADER_MAGIC, sizeof(pHdr->achMagic));
365	pHdr->cbData = cb;
366	if (usFmt == g_atomOdin32UnicodeText)
367	pHdr->uFormat = usFmt;
368	else
369	AssertFailed();
370	memcpy(pHdr + 1, pv, cb);
371	}
372	else
373	{
374	VGSvcError("DosAllocSharedMem(,,%#x,,) -> %ld\n", cb + sizeof(CLIPHEADER), rc);
375	pvPM = NULL;
376	}
377	return pvPM;
378	}
379
380
381	/**
382	* Converts (render) to a PM clipboard format.
383	*
384	* @returns Pointer to the data (DosFreeMem).
385	* @param fFormat The host format.
386	* @param usFmt The PM/Odin32 format.
387	* @param pv The data in host formatting.
388	* @param cb The size of the data.
389	*/
390	static void vgsvcClipboardOs2ConvertToPM(uint32_t fFormat, USHORT usFmt, void pv, uint32_t cb)
391	{
392	void *pvPM = NULL;
393
394	/*
395	* The Odin32 stuff is simple, we just assume windows data from the host
396	* and all we need to do is add the header.
397	*/
398	if ( usFmt
399	&& ( usFmt == g_atomOdin32UnicodeText
400	/* \|\| usFmt == ...*/
401	)
402	)
403	pvPM = vgsvcClipboardOs2ConvertToOdin32(fFormat, usFmt, pv, cb);
404	else if (usFmt == CF_TEXT)
405	{
406	/*
407	* Convert the unicode text to the current ctype locale.
408	*
409	* Note that we probably should be using the current PM or DOS codepage
410	* here instead of the LC_CTYPE one which iconv uses by default.
411	* -lazybird
412	*/
413	Assert(fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT);
414	char *pszUtf8;
415	int rc = RTUtf16ToUtf8((PCRTUTF16)pv, &pszUtf8);
416	if (RT_SUCCESS(rc))
417	{
418	char *pszLocale;
419	rc = RTStrUtf8ToCurrentCP(&pszLocale, pszUtf8);
420	if (RT_SUCCESS(rc))
421	{
422	size_t cbPM = strlen(pszLocale) + 1;
423	APIRET orc = DosAllocSharedMem(&pvPM, NULL, cbPM, OBJ_GIVEABLE \| OBJ_GETTABLE \| OBJ_TILE \| PAG_READ \| PAG_WRITE \| PAG_COMMIT);
424	if (orc == NO_ERROR)
425	memcpy(pvPM, pszLocale, cbPM);
426	else
427	{
428	VGSvcError("DosAllocSharedMem(,,%#x,,) -> %ld\n", cb + sizeof(CLIPHEADER), orc);
429	pvPM = NULL;
430	}
431	RTStrFree(pszLocale);
432	}
433	else
434	VGSvcError("RTStrUtf8ToCurrentCP() -> %Rrc\n", rc);
435	RTStrFree(pszUtf8);
436	}
437	else
438	VGSvcError("RTUtf16ToUtf8() -> %Rrc\n", rc);
439	}
440
441	return pvPM;
442	}
443
444
445	/**
446	* Tries to deliver an advertised host format.
447	*
448	* @param usFmt The PM format name.
449	*
450	* @remark We must not try open the clipboard here because WM_RENDERFMT is a
451	* request send synchronously by someone who has already opened the
452	* clipboard. We would enter a deadlock trying to open it here.
453	*/
454	static void vgsvcClipboardOs2RenderFormat(USHORT usFmt)
455	{
456	bool fSucceeded = false;
457
458	/*
459	* Determine which format.
460	*/
461	uint32_t fFormat;
462	if ( usFmt == CF_TEXT
463	\|\| usFmt == g_atomOdin32UnicodeText)
464	fFormat = VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
465	else /** @todo bitmaps */
466	fFormat = 0;
467	if (fFormat)
468	{
469	/*
470	* Query the data from the host.
471	* This might require two iterations because of buffer guessing.
472	*/
473	uint32_t cb = _4K;
474	uint32_t cbAllocated = cb;
475	int rc = VERR_NO_MEMORY;
476	void *pv = RTMemPageAllocZ(cbAllocated);
477	if (pv)
478	{
479	VGSvcVerbose(4, "clipboard: reading host data (%#x)\n", fFormat);
480	rc = VbglR3ClipboardReadData(g_u32ClientId, fFormat, pv, cb, &cb);
481	if (rc == VINF_BUFFER_OVERFLOW)
482	{
483	RTMemPageFree(pv, cbAllocated);
484	cbAllocated = cb = RT_ALIGN_32(cb, PAGE_SIZE);
485	pv = RTMemPageAllocZ(cbAllocated);
486	rc = VbglR3ClipboardReadData(g_u32ClientId, fFormat, pv, cb, &cb);
487	}
488	if (RT_FAILURE(rc))
489	RTMemPageFree(pv, cbAllocated);
490	}
491	if (RT_SUCCESS(rc))
492	{
493	VGSvcVerbose(4, "clipboard: read %u bytes\n", cb);
494
495	/*
496	* Convert the host clipboard data to PM clipboard data and set it.
497	*/
498	PVOID pvPM = vgsvcClipboardOs2ConvertToPM(fFormat, usFmt, pv, cb);
499	if (pvPM)
500	{
501	if (WinSetClipbrdData(g_habWorker, (ULONG)pvPM, usFmt, CFI_POINTER))
502	fSucceeded = true;
503	else
504	{
505	VGSvcError("vgsvcClipboardOs2RenderFormat: WinSetClipbrdData(,%p,%#x, CF_POINTER) failed, lasterror=%lx\n",
506	pvPM, usFmt, WinGetLastError(g_habWorker));
507	DosFreeMem(pvPM);
508	}
509	}
510	RTMemPageFree(pv, cbAllocated);
511	}
512	else
513	VGSvcError("vgsvcClipboardOs2RenderFormat: Failed to query / allocate data. rc=%Rrc cb=%#RX32\n", rc, cb);
514	}
515
516	/*
517	* Empty the clipboard on failure so we don't end up in any loops.
518	*/
519	if (!fSucceeded)
520	{
521	WinSetClipbrdOwner(g_habWorker, NULLHANDLE);
522	g_enmState = kClipboardState_Destroying;
523	WinEmptyClipbrd(g_habWorker);
524	g_enmState = kClipboardState_Polling;
525	g_fEmptyClipboard = true;
526	vgsvcClipboardOs2PollViewer();
527	}
528	}
529
530
531	/**
532	* Sends data to the host.
533	*
534	* @param fFormat The data format the host is requesting.
535	*/
536	static void vgsvcClipboardOs2SendDataToHost(uint32_t fFormat)
537	{
538	if (WinOpenClipbrd(g_habWorker))
539	{
540	PRTUTF16 pwszFree = NULL;
541	void *pv = NULL;
542	uint32_t cb = 0;
543
544	if (fFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
545	{
546	/* Got any odin32 unicode text? */
547	PVOID pvPM;
548	PCLIPHEADER pHdr = (PCLIPHEADER)WinQueryClipbrdData(g_habWorker, g_atomOdin32UnicodeText);
549	if ( pHdr
550	&& !memcmp(pHdr->achMagic, CLIPHEADER_MAGIC, sizeof(pHdr->achMagic)))
551	{
552	pv = pHdr + 1;
553	cb = pHdr->cbData;
554	}
555
556	/* Got any CF_TEXT? */
557	if ( !pv
558	&& (pvPM = (PVOID)WinQueryClipbrdData(g_habWorker, CF_TEXT)) != NULL)
559	{
560	char *pszUtf8;
561	int rc = RTStrCurrentCPToUtf8(&pszUtf8, (const char *)pvPM);
562	if (RT_SUCCESS(rc))
563	{
564	PRTUTF16 pwsz;
565	rc = RTStrToUtf16(pszUtf8, &pwsz);
566	if (RT_SUCCESS(rc))
567	{
568	pv = pwszFree = pwsz;
569	cb = (RTUtf16Len(pwsz) + 1) * sizeof(RTUTF16);
570	}
571	RTStrFree(pszUtf8);
572	}
573	}
574	}
575	if (!pv)
576	VGSvcError("vgsvcClipboardOs2SendDataToHost: couldn't find data for %#x\n", fFormat);
577
578	/*
579	* Now, sent whatever we've got to the host (it's waiting).
580	*/
581	VGSvcVerbose(4, "clipboard: writing %pv/%#d (fFormat=%#x)\n", pv, cb, fFormat);
582	VbglR3ClipboardWriteData(g_u32ClientId, fFormat, pv, cb);
583	RTUtf16Free(pwszFree);
584
585	WinCloseClipbrd(g_habWorker);
586	}
587	else
588	{
589	VGSvcError("vgsvcClipboardOs2SendDataToHost: WinOpenClipbrd failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
590	VGSvcVerbose(4, "clipboard: writing NULL/0 (fFormat=%x)\n", fFormat);
591	VbglR3ClipboardWriteData(g_u32ClientId, fFormat, NULL, 0);
592	}
593	}
594
595
596	/**
597	* Figure out what's on the clipboard and report it to the host.
598	*/
599	static void vgsvcClipboardOs2ReportFormats(void)
600	{
601	uint32_t fFormats = 0;
602	ULONG ulFormat = 0;
603	while ((ulFormat = WinEnumClipbrdFmts(g_habWorker, ulFormat)) != 0)
604	{
605	if ( ulFormat == CF_TEXT
606	\|\| ulFormat == g_atomOdin32UnicodeText)
607	fFormats \|= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
608	/** @todo else bitmaps and stuff. */
609	}
610	VGSvcVerbose(4, "clipboard: reporting fFormats=%#x\n", fFormats);
611	VbglR3ClipboardReportFormats(g_u32ClientId, fFormats);
612	}
613
614
615	/**
616	* Poll the clipboard for changes.
617	*
618	* This is called both when we're the viewer and when we're
619	* falling back to polling. If something has changed it will
620	* notify the host.
621	*/
622	static void vgsvcClipboardOs2Poll(void)
623	{
624	if (WinOpenClipbrd(g_habWorker))
625	{
626	/*
627	* If our dummy is no longer there, something has actually changed,
628	* unless the clipboard is really empty.
629	*/
630	ULONG fFmtInfo;
631	if (!WinQueryClipbrdFmtInfo(g_habWorker, g_atomNothingChanged, &fFmtInfo))
632	{
633	if (WinEnumClipbrdFmts(g_habWorker, 0) != 0)
634	{
635	g_fEmptyClipboard = false;
636	vgsvcClipboardOs2ReportFormats();
637
638	/* inject the dummy */
639	PVOID pv;
640	APIRET rc = DosAllocSharedMem(&pv, NULL, 1, OBJ_GIVEABLE \| OBJ_GETTABLE \| PAG_READ \| PAG_WRITE \| PAG_COMMIT);
641	if (rc == NO_ERROR)
642	{
643	if (WinSetClipbrdData(g_habWorker, (ULONG)pv, g_atomNothingChanged, CFI_POINTER))
644	VGSvcVerbose(4, "clipboard: Added dummy item.\n");
645	else
646	{
647	VGSvcError("vgsvcClipboardOs2Poll: WinSetClipbrdData failed, lasterr=%#lx\n", WinGetLastError(g_habWorker));
648	DosFreeMem(pv);
649	}
650	}
651	else
652	VGSvcError("vgsvcClipboardOs2Poll: DosAllocSharedMem(,,1,) -> %ld\n", rc);
653	}
654	else if (!g_fEmptyClipboard)
655	{
656	g_fEmptyClipboard = true;
657	VGSvcVerbose(3, "Reporting empty clipboard\n");
658	VbglR3ClipboardReportFormats(g_u32ClientId, 0);
659	}
660	}
661	WinCloseClipbrd(g_habWorker);
662	}
663	else
664	VGSvcError("vgsvcClipboardOs2Poll: WinOpenClipbrd failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
665	}
666
667
668	/**
669	* The clipboard we owned was destroyed by someone else.
670	*/
671	static void vgsvcClipboardOs2Destroyed(void)
672	{
673	/* make sure we're no longer the owner. */
674	if (WinQueryClipbrdOwner(g_habWorker) == g_hwndWorker)
675	WinSetClipbrdOwner(g_habWorker, NULLHANDLE);
676
677	/* switch to polling state and notify the host. */
678	g_enmState = kClipboardState_Polling;
679	g_fEmptyClipboard = true;
680	VGSvcVerbose(3, "Reporting empty clipboard\n");
681	VbglR3ClipboardReportFormats(g_u32ClientId, 0);
682
683	vgsvcClipboardOs2PollViewer();
684	}
685
686
687	/**
688	* The window procedure for the object window.
689	*
690	* @returns Message result.
691	*
692	* @param hwnd The window handle.
693	* @param msg The message.
694	* @param mp1 Message parameter 1.
695	* @param mp2 Message parameter 2.
696	*/
697	static MRESULT EXPENTRY vgsvcClipboardOs2WinProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
698	{
699	if (msg != WM_TIMER)
700	VGSvcVerbose(6, "vgsvcClipboardOs2WinProc: hwnd=%#lx msg=%#lx mp1=%#lx mp2=%#lx\n", hwnd, msg, mp1, mp2);
701
702	switch (msg)
703	{
704	/*
705	* Handle the two system defined messages for object windows.
706	*
707	* We'll just use the CREATE/DESTROY message to create that timer we're
708	* using for the viewer checks and polling fallback.
709	*/
710	case WM_CREATE:
711	g_idWorkerTimer = WinStartTimer(g_habWorker, hwnd, 1 /* id /, 1000 / 1 second */);
712	g_fEmptyClipboard = true;
713	g_enmState = kClipboardState_Polling;
714	return NULL; /* FALSE(/NULL) == Continue*/
715
716	case WM_DESTROY:
717	WinStopTimer(g_habWorker, hwnd, g_idWorkerTimer);
718	g_idWorkerTimer = ~0UL;
719	g_hwndWorker = NULLHANDLE;
720	break;
721
722	/*
723	* Clipboard viewer message - the content has been changed.
724	* This is sent after releasing the clipboard sem
725	* and during the WinSetClipbrdViewer call.
726	*/
727	case WM_DRAWCLIPBOARD:
728	if (g_enmState == kClipboardState_SettingViewer)
729	break;
730	AssertMsgBreak(g_enmState == kClipboardState_Viewer, ("g_enmState=%d\n", g_enmState));
731	vgsvcClipboardOs2Poll();
732	break;
733
734	/*
735	* Clipboard owner message - the content was replaced.
736	* This is sent by someone with an open clipboard, so don't try open it now.
737	*/
738	case WM_DESTROYCLIPBOARD:
739	if (g_enmState == kClipboardState_Destroying)
740	break; /* it's us doing the replacing, ignore. */
741	AssertMsgBreak(g_enmState == kClipboardState_Owner, ("g_enmState=%d\n", g_enmState));
742	vgsvcClipboardOs2Destroyed();
743	break;
744
745	/*
746	* Clipboard owner message - somebody is requesting us to render a format.
747	* This is called by someone which owns the clipboard, but that's fine.
748	*/
749	case WM_RENDERFMT:
750	AssertMsgBreak(g_enmState == kClipboardState_Owner, ("g_enmState=%d\n", g_enmState));
751	vgsvcClipboardOs2RenderFormat(SHORT1FROMMP(mp1));
752	break;
753
754	/*
755	* Clipboard owner message - we're about to quit and should render all formats.
756	*
757	* However, because we're lazy, we'll just ASSUME that since we're quitting
758	* we're probably about to shutdown or something and there is no point in
759	* doing anything here except for emptying the clipboard and removing
760	* ourselves as owner. Any failures at this point are silently ignored.
761	*/
762	case WM_RENDERALLFMTS:
763	WinOpenClipbrd(g_habWorker);
764	WinSetClipbrdOwner(g_habWorker, NULLHANDLE);
765	g_enmState = kClipboardState_Destroying;
766	WinEmptyClipbrd(g_habWorker);
767	g_enmState = kClipboardState_Polling;
768	g_fEmptyClipboard = true;
769	WinCloseClipbrd(g_habWorker);
770	break;
771
772	/*
773	* Listener message - the host has new formats to offer.
774	*/
775	case WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
776	vgsvcClipboardOs2AdvertiseHostFormats(LONGFROMMP(mp1));
777	break;
778
779	/*
780	* Listener message - the host wish to read our clipboard data.
781	*/
782	case WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
783	vgsvcClipboardOs2SendDataToHost(LONGFROMMP(mp1));
784	break;
785
786	/*
787	* This is just a fallback polling strategy in case some other
788	* app is trying to view the clipboard too. We also use this
789	* to try recover from errors.
790	*
791	* Because the way the clipboard service works, we have to monitor
792	* it all the time and cannot get away with simpler solutions like
793	* synergy is employing (basically checking upon entering and leaving
794	* a desktop).
795	*/
796	case WM_TIMER:
797	if ( g_enmState != kClipboardState_Viewer
798	&& g_enmState != kClipboardState_Polling)
799	break;
800
801	/* Lost the position as clipboard viewer?*/
802	if (g_enmState == kClipboardState_Viewer)
803	{
804	if (WinQueryClipbrdViewer(g_habWorker) == hwnd)
805	break;
806	g_enmState = kClipboardState_Polling;
807	}
808
809	/* poll for changes */
810	vgsvcClipboardOs2Poll();
811	vgsvcClipboardOs2PollViewer();
812	break;
813
814
815	/*
816	* Clipboard owner messages dealing with owner drawn content.
817	* We shouldn't be seeing any of these.
818	*/
819	case WM_PAINTCLIPBOARD:
820	case WM_SIZECLIPBOARD:
821	case WM_HSCROLLCLIPBOARD:
822	case WM_VSCROLLCLIPBOARD:
823	AssertMsgFailed(("msg=%lx (%ld)\n", msg, msg));
824	break;
825
826	/*
827	* We shouldn't be seeing any other messages according to the docs.
828	* But for whatever reason, PM sends us a WM_ADJUSTWINDOWPOS message
829	* during WinCreateWindow. So, ignore that and assert on anything else.
830	*/
831	default:
832	AssertMsgFailed(("msg=%lx (%ld)\n", msg, msg));
833	case WM_ADJUSTWINDOWPOS:
834	break;
835	}
836	return NULL;
837	}
838
839
840	/**
841	* The listener thread.
842	*
843	* This thread is dedicated to listening for host messages and forwarding
844	* these to the worker thread (using PM).
845	*
846	* The thread will set g_fListenerOkay and signal its user event when it has
847	* completed initialization. In the case of init failure g_fListenerOkay will
848	* not be set.
849	*
850	* @returns Init error code or VINF_SUCCESS.
851	* @param ThreadSelf Our thread handle.
852	* @param pvUser Pointer to the clipboard service shutdown indicator.
853	*/
854	static DECLCALLBACK(int) vgsvcClipboardOs2Listener(RTTHREAD ThreadSelf, void *pvUser)
855	{
856	bool volatile pfShutdown = (bool volatile )pvUser;
857	int rc = VERR_GENERAL_FAILURE;
858	VGSvcVerbose(3, "vgsvcClipboardOs2Listener: ThreadSelf=%RTthrd\n", ThreadSelf);
859
860	g_habListener = WinInitialize(0);
861	if (g_habListener != NULLHANDLE)
862	{
863	g_hmqListener = WinCreateMsgQueue(g_habListener, 0);
864	if (g_hmqListener != NULLHANDLE)
865	{
866	WinCancelShutdown(g_hmqListener, TRUE); /* We don't care about shutdown */
867
868	/*
869	* Tell the worker thread that we're good.
870	*/
871	rc = VINF_SUCCESS;
872	ASMAtomicXchgBool(&g_fListenerOkay, true);
873	RTThreadUserSignal(ThreadSelf);
874	VGSvcVerbose(3, "vgsvcClipboardOs2Listener: Started successfully\n");
875
876	/*
877	* Loop until termination is requested.
878	*/
879	bool fQuit = false;
880	while (!*pfShutdown && !fQuit)
881	{
882	uint32_t Msg;
883	uint32_t fFormats;
884	rc = VbglR3ClipboardGetHostMsg(g_u32ClientId, &Msg, &fFormats);
885	if (RT_SUCCESS(rc))
886	{
887	VGSvcVerbose(3, "vgsvcClipboardOs2Listener: Msg=%#x fFormats=%#x\n", Msg, fFormats);
888	switch (Msg)
889	{
890	/*
891	* The host has announced available clipboard formats.
892	* Forward the information to the window, so it can later
893	* respond do WM_RENDERFORMAT message.
894	*/
895	case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
896	if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS,
897	MPFROMLONG(fFormats), 0))
898	VGSvcError("WinPostMsg(%lx, FORMATS,,) failed, lasterr=%#lx\n",
899	g_hwndWorker, WinGetLastError(g_habListener));
900	break;
901
902	/*
903	* The host needs data in the specified format.
904	*/
905	case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA:
906	if (!WinPostMsg(g_hwndWorker, WM_USER + VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA,
907	MPFROMLONG(fFormats), 0))
908	VGSvcError("WinPostMsg(%lx, READ_DATA,,) failed, lasterr=%#lx\n",
909	g_hwndWorker, WinGetLastError(g_habListener));
910	break;
911
912	/*
913	* The host is terminating.
914	*/
915	case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT:
916	fQuit = true;
917	break;
918
919	default:
920	VGSvcVerbose(1, "vgsvcClipboardOs2Listener: Unknown message %RU32\n", Msg);
921	break;
922	}
923	}
924	else
925	{
926	if (*pfShutdown)
927	break;
928	VGSvcError("VbglR3ClipboardGetHostMsg failed, rc=%Rrc\n", rc);
929	RTThreadSleep(1000);
930	}
931	} /* the loop */
932
933	WinDestroyMsgQueue(g_hmqListener);
934	}
935	WinTerminate(g_habListener);
936	g_habListener = NULLHANDLE;
937	}
938
939	/* Signal our semaphore to make the worker catch on. */
940	RTThreadUserSignal(ThreadSelf);
941	VGSvcVerbose(3, "vgsvcClipboardOs2Listener: terminating, rc=%Rrc\n", rc);
942	return rc;
943	}
944
945
946	/**
947	* @interface_method_impl{VBOXSERVICE,pfnWorker}
948	*/
949	static DECLCALLBACK(int) vgsvcClipboardOs2Worker(bool volatile *pfShutdown)
950	{
951	int rc = VERR_GENERAL_FAILURE;
952
953	/*
954	* Standard PM init.
955	*/
956	g_habWorker = RTThreadSelf() != g_ThreadCtrl ? WinInitialize(0) : g_habCtrl;
957	if (g_habWorker != NULLHANDLE)
958	{
959	g_hmqWorker = RTThreadSelf() != g_ThreadCtrl ? WinCreateMsgQueue(g_habWorker, 0) : g_hmqCtrl;
960	if (g_hmqWorker != NULLHANDLE)
961	{
962	if (g_hmqWorker != g_hmqCtrl)
963	WinCancelShutdown(g_hmqWorker, TRUE); /* We don't care about shutdown */
964
965	/*
966	* Create the object window.
967	*/
968	if (WinRegisterClass(g_habWorker, (PCSZ)"VBoxServiceClipboardClass", vgsvcClipboardOs2WinProc, 0, 0))
969	{
970	g_hwndWorker = WinCreateWindow(HWND_OBJECT, /* hwndParent */
971	(PCSZ)"VBoxServiceClipboardClass", /* pszClass */
972	(PCSZ)"VirtualBox Clipboard Service", /* pszName */
973	0, /* flStyle */
974	0, 0, 0, 0, /* x, y, cx, cy */
975	NULLHANDLE, /* hwndOwner */
976	HWND_BOTTOM, /* hwndInsertBehind */
977	42, /* id */
978	NULL, /* pCtlData */
979	NULL); /* pPresParams */
980	if (g_hwndWorker != NULLHANDLE)
981	{
982	VGSvcVerbose(3, "g_hwndWorker=%#lx g_habWorker=%#lx g_hmqWorker=%#lx\n", g_hwndWorker, g_habWorker, g_hmqWorker);
983
984	/*
985	* Create the listener thread.
986	*/
987	g_fListenerOkay = false;
988	rc = RTThreadCreate(&g_ThreadListener, vgsvcClipboardOs2Listener, (void *)pfShutdown, 0,
989	RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "CLIPLISTEN");
990	if (RT_SUCCESS(rc))
991	{
992	RTThreadUserWait(g_ThreadListener, 30*1000);
993	RTThreadUserReset(g_ThreadListener);
994	if (!g_fListenerOkay)
995	RTThreadWait(g_ThreadListener, 60*1000, NULL);
996	if (g_fListenerOkay)
997	{
998	/*
999	* Tell the control thread that it can continue
1000	* spawning services.
1001	*/
1002	RTThreadUserSignal(RTThreadSelf());
1003
1004	/*
1005	* The PM event pump.
1006	*/
1007	VGSvcVerbose(2, "clipboard: Entering PM message loop.\n");
1008	rc = VINF_SUCCESS;
1009	QMSG qmsg;
1010	while (WinGetMsg(g_habWorker, &qmsg, NULLHANDLE, NULLHANDLE, 0))
1011	{
1012	if (qmsg.msg != WM_TIMER)
1013	VGSvcVerbose(6, "WinGetMsg -> hwnd=%p msg=%#x mp1=%p mp2=%p time=%#x ptl=%d,%d rsrv=%#x\n",
1014	qmsg.hwnd, qmsg.msg, qmsg.mp1, qmsg.mp2, qmsg.time, qmsg.ptl.x, qmsg.ptl.y, qmsg.reserved);
1015	WinDispatchMsg(g_habWorker, &qmsg);
1016	}
1017	VGSvcVerbose(2, "clipboard: Exited PM message loop. pfShutdown=%RTbool\n", pfShutdown);
1018
1019	RTThreadWait(g_ThreadListener, 60*1000, NULL);
1020	}
1021	g_ThreadListener = NIL_RTTHREAD;
1022	}
1023
1024	/*
1025	* Got a WM_QUIT, clean up.
1026	*/
1027	if (g_hwndWorker != NULLHANDLE)
1028	{
1029	WinDestroyWindow(g_hwndWorker);
1030	g_hwndWorker = NULLHANDLE;
1031	}
1032	}
1033	else
1034	VGSvcError("WinCreateWindow() failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
1035	/* no class deregistration in PM. */
1036	}
1037	else
1038	VGSvcError("WinRegisterClass() failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
1039
1040	if (g_hmqCtrl != g_hmqWorker)
1041	WinDestroyMsgQueue(g_hmqWorker);
1042	g_hmqWorker = NULLHANDLE;
1043	}
1044	else
1045	VGSvcError("WinCreateMsgQueue(,0) failed, lasterr=%lx\n", WinGetLastError(g_habWorker));
1046
1047	if (g_habCtrl != g_habWorker)
1048	WinTerminate(g_habWorker);
1049	g_habWorker = NULLHANDLE;
1050	}
1051	else
1052	VGSvcError("WinInitialize(0) failed, lasterr=%lx\n", WinGetLastError(NULLHANDLE));
1053
1054	return rc;
1055	}
1056
1057
1058	/**
1059	* @interface_method_impl{VBOXSERVICE,pfnStop}
1060	*/
1061	static DECLCALLBACK(void) vgsvcClipboardOs2Stop(void)
1062	{
1063	if ( g_hmqWorker != NULLHANDLE
1064	&& !WinPostQueueMsg(g_hmqWorker, WM_QUIT, NULL, NULL))
1065	VGSvcError("WinPostQueueMsg(g_hmqWorker, WM_QUIT, 0,0) failed, lasterr=%lx\n", WinGetLastError(g_habCtrl));
1066
1067	/* Must disconnect the clipboard here otherwise the listner won't quit and
1068	the service shutdown will not stop. */
1069	if (g_u32ClientId != 0)
1070	{
1071	if (g_hmqWorker != NULLHANDLE)
1072	RTThreadSleep(32); /* fudge */
1073
1074	VGSvcVerbose(4, "clipboard: disconnecting %#x\n", g_u32ClientId);
1075	int rc = VbglR3ClipboardDisconnect(g_u32ClientId);
1076	if (RT_SUCCESS(rc))
1077	g_u32ClientId = 0;
1078	else
1079	VGSvcError("clipboard: VbglR3ClipboardDisconnect(%#x) -> %Rrc\n", g_u32ClientId, rc);
1080	}
1081	}
1082
1083
1084	/**
1085	* @interface_method_impl{VBOXSERVICE,pfnTerm}
1086	*/
1087	static DECLCALLBACK(void) vgsvcClipboardOs2Term(void)
1088	{
1089	if (g_u32ClientId != 0)
1090	{
1091	VGSvcVerbose(4, "clipboard: disconnecting %#x\n", g_u32ClientId);
1092	int rc = VbglR3ClipboardDisconnect(g_u32ClientId);
1093	if (RT_SUCCESS(rc))
1094	g_u32ClientId = 0;
1095	else
1096	VGSvcError("clipboard: VbglR3ClipboardDisconnect(%#x) -> %Rrc\n", g_u32ClientId, rc);
1097	}
1098	WinDestroyMsgQueue(g_hmqCtrl);
1099	g_hmqCtrl = NULLHANDLE;
1100	WinTerminate(g_habCtrl);
1101	g_habCtrl = NULLHANDLE;
1102	}
1103
1104
1105	/**
1106	* The OS/2 'clipboard' service description.
1107	*/
1108	VBOXSERVICE g_Clipboard =
1109	{
1110	/* pszName. */
1111	"clipboard",
1112	/* pszDescription. */
1113	"Shared Clipboard",
1114	/* pszUsage. */
1115	""
1116	,
1117	/* pszOptions. */
1118	""
1119	,
1120	/* methods */
1121	vgsvcClipboardOs2PreInit,
1122	vgsvcClipboardOs2Option,
1123	vgsvcClipboardOs2Init,
1124	vgsvcClipboardOs2Worker,
1125	vgsvcClipboardOs2Stop,
1126	vgsvcClipboardOs2Term
1127	};
1128

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/common/VBoxService/VBoxServiceClipboard-os2.cpp@ 69496

Download in other formats: