?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wrc: Remove non-bison compatibility code.
[wine.git] / dlls / user32 / dde_server.c
blob9d834a847429efd40b3dbe796dfe15d199327106
1 /*
2 * DDEML library
3 *
4 * Copyright 1997 Alexandre Julliard
5 * Copyright 1997 Len White
6 * Copyright 1999 Keith Matthews
7 * Copyright 2000 Corel
8 * Copyright 2001 Eric Pouech
9 * Copyright 2003, 2004, 2005 Dmitry Timoshkov
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include <stdarg.h>
27 #include <string.h>
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "winnls.h"
33 #include "dde.h"
34 #include "ddeml.h"
35 #include "win.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38 #include "dde_private.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
41
42 static const WCHAR szServerNameClass[] = {'W','i','n','e','D','d','e','S','e','r','v','e','r','N','a','m','e',0};
43 const char WDML_szServerConvClassA[] = "WineDdeServerConvA";
44 const WCHAR WDML_szServerConvClassW[] = {'W','i','n','e','D','d','e','S','e','r','v','e','r','C','o','n','v','W',0};
45
46 static LRESULT CALLBACK WDML_ServerNameProc(HWND, UINT, WPARAM, LPARAM);
47 static LRESULT CALLBACK WDML_ServerConvProc(HWND, UINT, WPARAM, LPARAM);
48
49 /******************************************************************************
50 * DdePostAdvise [USER32.@] Send transaction to DDE callback function.
51 *
52 * PARAMS
53 * idInst [I] Instance identifier
54 * hszTopic [I] Handle to topic name string
55 * hszItem [I] Handle to item name string
56 *
57 * RETURNS
58 * Success: TRUE
59 * Failure: FALSE
60 */
61 BOOL WINAPI DdePostAdvise(DWORD idInst, HSZ hszTopic, HSZ hszItem)
62 {
63 WDML_INSTANCE* pInstance = NULL;
64 WDML_LINK* pLink = NULL;
65 HDDEDATA hDdeData = 0;
66 HGLOBAL hItemData = 0;
67 WDML_CONV* pConv = NULL;
68 ATOM atom = 0;
69 UINT count;
70
71 TRACE("(%d,%p,%p)\n", idInst, hszTopic, hszItem);
72
73 pInstance = WDML_GetInstance(idInst);
74
75 if (pInstance == NULL)
76 return FALSE;
77
78 atom = WDML_MakeAtomFromHsz(hszItem);
79 if (!atom) return FALSE;
80
81 /* first compute the number of links which will trigger a message */
82 count = 0;
83 for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
84 {
85 if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
86 {
87 count++;
88 }
89 }
90 if (count >= CADV_LATEACK)
91 {
92 FIXME("too high value for count\n");
93 count &= 0xFFFF;
94 }
95
96 for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
97 {
98 if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
99 {
100 hDdeData = WDML_InvokeCallback(pInstance, XTYP_ADVREQ, pLink->uFmt, pLink->hConv,
101 hszTopic, hszItem, 0, --count, 0);
102
103 if (hDdeData == CBR_BLOCK)
104 {
105 /* MS doc is not consistent here */
106 FIXME("CBR_BLOCK returned for ADVREQ\n");
107 continue;
108 }
109 if (hDdeData)
110 {
111 if (pLink->transactionType & XTYPF_NODATA)
112 {
113 TRACE("no data\n");
114 hItemData = 0;
115 }
116 else
117 {
118 TRACE("with data\n");
119
120 hItemData = WDML_DataHandle2Global(hDdeData, FALSE, FALSE, FALSE, FALSE);
121 }
122
123 pConv = WDML_GetConv(pLink->hConv, TRUE);
124
125 if (pConv == NULL)
126 {
127 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
128 goto theError;
129 }
130
131 if (!PostMessageW(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
132 PackDDElParam(WM_DDE_DATA, (UINT_PTR)hItemData, atom)))
133 {
134 ERR("post message failed\n");
135 pConv->wStatus &= ~ST_CONNECTED;
136 pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
137 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
138 GlobalFree(hItemData);
139 goto theError;
140 }
141 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
142 }
143 }
144 }
145 return TRUE;
146
147 theError:
148 GlobalDeleteAtom(atom);
149 return FALSE;
150 }
151
152
153 /******************************************************************************
154 * DdeNameService [USER32.@] {Un}registers service name of DDE server
155 *
156 * PARAMS
157 * idInst [I] Instance identifier
158 * hsz1 [I] Handle to service name string
159 * hsz2 [I] Reserved
160 * afCmd [I] Service name flags
161 *
162 * RETURNS
163 * Success: Non-zero
164 * Failure: 0
165 */
166 HDDEDATA WINAPI DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd)
167 {
168 WDML_SERVER* pServer;
169 WDML_INSTANCE* pInstance;
170 HWND hwndServer;
171 WNDCLASSEXW wndclass;
172
173 TRACE("(%d,%p,%p,%x)\n", idInst, hsz1, hsz2, afCmd);
174
175 /* First check instance
176 */
177 pInstance = WDML_GetInstance(idInst);
178 if (pInstance == NULL)
179 {
180 TRACE("Instance not found as initialised\n");
181 /* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
182 return NULL;
183 }
184
185 if (hsz2 != 0L)
186 {
187 /* Illegal, reserved parameter
188 */
189 pInstance->lastError = DMLERR_INVALIDPARAMETER;
190 WARN("Reserved parameter no-zero !!\n");
191 return NULL;
192 }
193 if (hsz1 == 0 && !(afCmd & DNS_UNREGISTER))
194 {
195 /* don't know if we should check this but it makes sense
196 * why supply REGISTER or filter flags if de-registering all
197 */
198 TRACE("General unregister unexpected flags\n");
199 pInstance->lastError = DMLERR_INVALIDPARAMETER;
200 return NULL;
201 }
202
203 switch (afCmd & (DNS_REGISTER | DNS_UNREGISTER))
204 {
205 case DNS_REGISTER:
206 pServer = WDML_FindServer(pInstance, hsz1, 0);
207 if (pServer)
208 {
209 ERR("Trying to register already registered service!\n");
210 pInstance->lastError = DMLERR_DLL_USAGE;
211 return NULL;
212 }
213
214 TRACE("Adding service name\n");
215
216 WDML_IncHSZ(pInstance, hsz1);
217
218 pServer = WDML_AddServer(pInstance, hsz1, 0);
219
220 WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_REGISTER,
221 pServer->atomService, pServer->atomServiceSpec);
222
223 wndclass.cbSize = sizeof(wndclass);
224 wndclass.style = 0;
225 wndclass.lpfnWndProc = WDML_ServerNameProc;
226 wndclass.cbClsExtra = 0;
227 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
228 wndclass.hInstance = 0;
229 wndclass.hIcon = 0;
230 wndclass.hCursor = 0;
231 wndclass.hbrBackground = 0;
232 wndclass.lpszMenuName = NULL;
233 wndclass.lpszClassName = szServerNameClass;
234 wndclass.hIconSm = 0;
235
236 RegisterClassExW(&wndclass);
237
238 hwndServer = CreateWindowW(szServerNameClass, NULL,
239 WS_POPUP, 0, 0, 0, 0,
240 0, 0, 0, 0);
241
242 SetWindowLongPtrW(hwndServer, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
243 SetWindowLongPtrW(hwndServer, GWL_WDML_SERVER, (ULONG_PTR)pServer);
244 TRACE("Created nameServer=%p for instance=%08x\n", hwndServer, idInst);
245
246 pServer->hwndServer = hwndServer;
247 break;
248
249 case DNS_UNREGISTER:
250 if (hsz1 == 0L)
251 {
252 /* General unregister situation
253 * terminate all server side pending conversations
254 */
255 while (pInstance->servers)
256 WDML_RemoveServer(pInstance, pInstance->servers->hszService, 0);
257 pInstance->servers = NULL;
258 TRACE("General de-register - finished\n");
259 }
260 else
261 {
262 WDML_RemoveServer(pInstance, hsz1, 0L);
263 }
264 break;
265 }
266
267 if (afCmd & (DNS_FILTERON | DNS_FILTEROFF))
268 {
269 /* Set filter flags on to hold notifications of connection
270 */
271 pServer = WDML_FindServer(pInstance, hsz1, 0);
272 if (!pServer)
273 {
274 /* trying to filter where no service names !!
275 */
276 pInstance->lastError = DMLERR_DLL_USAGE;
277 return NULL;
278 }
279 else
280 {
281 pServer->filterOn = (afCmd & DNS_FILTERON) != 0;
282 }
283 }
284 return (HDDEDATA)TRUE;
285 }
286
287 /******************************************************************
288 * WDML_CreateServerConv
289 *
290 *
291 */
292 static WDML_CONV* WDML_CreateServerConv(WDML_INSTANCE* pInstance, HWND hwndClient,
293 HWND hwndServerName, HSZ hszApp, HSZ hszTopic)
294 {
295 HWND hwndServerConv;
296 WDML_CONV* pConv;
297
298 if (pInstance->unicode)
299 {
300 WNDCLASSEXW wndclass;
301
302 wndclass.cbSize = sizeof(wndclass);
303 wndclass.style = 0;
304 wndclass.lpfnWndProc = WDML_ServerConvProc;
305 wndclass.cbClsExtra = 0;
306 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
307 wndclass.hInstance = 0;
308 wndclass.hIcon = 0;
309 wndclass.hCursor = 0;
310 wndclass.hbrBackground = 0;
311 wndclass.lpszMenuName = NULL;
312 wndclass.lpszClassName = WDML_szServerConvClassW;
313 wndclass.hIconSm = 0;
314
315 RegisterClassExW(&wndclass);
316
317 hwndServerConv = CreateWindowW(WDML_szServerConvClassW, 0,
318 WS_CHILD, 0, 0, 0, 0,
319 hwndServerName, 0, 0, 0);
320 }
321 else
322 {
323 WNDCLASSEXA wndclass;
324
325 wndclass.cbSize = sizeof(wndclass);
326 wndclass.style = 0;
327 wndclass.lpfnWndProc = WDML_ServerConvProc;
328 wndclass.cbClsExtra = 0;
329 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
330 wndclass.hInstance = 0;
331 wndclass.hIcon = 0;
332 wndclass.hCursor = 0;
333 wndclass.hbrBackground = 0;
334 wndclass.lpszMenuName = NULL;
335 wndclass.lpszClassName = WDML_szServerConvClassA;
336 wndclass.hIconSm = 0;
337
338 RegisterClassExA(&wndclass);
339
340 hwndServerConv = CreateWindowA(WDML_szServerConvClassA, 0,
341 WS_CHILD, 0, 0, 0, 0,
342 hwndServerName, 0, 0, 0);
343 }
344
345 TRACE("Created convServer=%p (nameServer=%p) for instance=%08x unicode=%d\n",
346 hwndServerConv, hwndServerName, pInstance->instanceID, pInstance->unicode);
347
348 pConv = WDML_AddConv(pInstance, WDML_SERVER_SIDE, hszApp, hszTopic,
349 hwndClient, hwndServerConv);
350 if (pConv)
351 {
352 SetWindowLongPtrW(hwndServerConv, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
353 SetWindowLongPtrW(hwndServerConv, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
354
355 /* this should be the only place using SendMessage for WM_DDE_ACK */
356 /* note: sent messages shall not use packing */
357 SendMessageW(hwndClient, WM_DDE_ACK, (WPARAM)hwndServerConv,
358 MAKELPARAM(WDML_MakeAtomFromHsz(hszApp), WDML_MakeAtomFromHsz(hszTopic)));
359 /* we assume we're connected since we've sent an answer...
360 * I'm not sure what we can do... it doesn't look like the return value
361 * of SendMessage is used... sigh...
362 */
363 pConv->wStatus |= ST_CONNECTED;
364 }
365 else
366 {
367 DestroyWindow(hwndServerConv);
368 }
369 return pConv;
370 }
371
372 /******************************************************************
373 * WDML_ServerNameProc
374 *
375 *
376 */
377 static LRESULT CALLBACK WDML_ServerNameProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
378 {
379 HWND hwndClient;
380 HSZ hszApp, hszTop;
381 HDDEDATA hDdeData = 0;
382 WDML_INSTANCE* pInstance;
383 UINT_PTR uiLo, uiHi;
384
385 switch (iMsg)
386 {
387 case WM_DDE_INITIATE:
388
389 /* wParam -- sending window handle
390 LOWORD(lParam) -- application atom
391 HIWORD(lParam) -- topic atom */
392
393 TRACE("WM_DDE_INITIATE message received!\n");
394 hwndClient = (HWND)wParam;
395
396 pInstance = WDML_GetInstanceFromWnd(hwndServer);
397 if (!pInstance) return 0;
398 TRACE("idInst=%d, threadID=0x%x\n", pInstance->instanceID, GetCurrentThreadId());
399
400 /* don't free DDEParams, since this is a broadcast */
401 UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLo, &uiHi);
402
403 hszApp = WDML_MakeHszFromAtom(pInstance, uiLo);
404 hszTop = WDML_MakeHszFromAtom(pInstance, uiHi);
405
406 if (!(pInstance->CBFflags & CBF_FAIL_CONNECTIONS))
407 {
408 BOOL self = FALSE;
409 CONVCONTEXT cc;
410 CONVCONTEXT* pcc = NULL;
411 WDML_CONV* pConv;
412 char buf[256];
413
414 if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
415 WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
416 {
417 self = TRUE;
418 }
419 /* FIXME: so far, we don't grab distant convcontext, so only check if remote is
420 * handled under DDEML, and if so build a default context
421 */
422 if ((GetClassNameA(hwndClient, buf, sizeof(buf)) &&
423 lstrcmpiA(buf, WDML_szClientConvClassA) == 0) ||
424 (GetClassNameW(hwndClient, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
425 lstrcmpiW((LPWSTR)buf, WDML_szClientConvClassW) == 0))
426 {
427 pcc = &cc;
428 memset(pcc, 0, sizeof(*pcc));
429 pcc->cb = sizeof(*pcc);
430 pcc->iCodePage = IsWindowUnicode(hwndClient) ? CP_WINUNICODE : CP_WINANSI;
431 }
432 if ((pInstance->CBFflags & CBF_FAIL_SELFCONNECTIONS) && self)
433 {
434 TRACE("Don't do self connection as requested\n");
435 }
436 else if (hszApp && hszTop)
437 {
438 WDML_SERVER* pServer = (WDML_SERVER*)GetWindowLongPtrW(hwndServer, GWL_WDML_SERVER);
439
440 /* check filters for name service */
441 if (!pServer->filterOn || DdeCmpStringHandles(pServer->hszService, hszApp) == 0)
442 {
443 /* pass on to the callback */
444 hDdeData = WDML_InvokeCallback(pInstance, XTYP_CONNECT,
445 0, 0, hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
446 if ((ULONG_PTR)hDdeData)
447 {
448 pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
449 hszApp, hszTop);
450 if (pConv)
451 {
452 if (pcc) pConv->wStatus |= ST_ISLOCAL;
453 WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
454 hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
455 }
456 }
457 }
458 }
459 else if (pInstance->servers)
460 {
461 /* pass on to the callback */
462 hDdeData = WDML_InvokeCallback(pInstance, XTYP_WILDCONNECT,
463 0, 0, hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
464
465 if (hDdeData == CBR_BLOCK)
466 {
467 /* MS doc is not consistent here */
468 FIXME("CBR_BLOCK returned for WILDCONNECT\n");
469 }
470 else if ((ULONG_PTR)hDdeData != 0)
471 {
472 HSZPAIR* hszp;
473
474 hszp = (HSZPAIR*)DdeAccessData(hDdeData, NULL);
475 if (hszp)
476 {
477 int i;
478 for (i = 0; hszp[i].hszSvc && hszp[i].hszTopic; i++)
479 {
480 pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
481 hszp[i].hszSvc, hszp[i].hszTopic);
482 if (pConv)
483 {
484 if (pcc) pConv->wStatus |= ST_ISLOCAL;
485 WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
486 hszp[i].hszTopic, hszp[i].hszSvc, 0, (ULONG_PTR)pcc, self);
487 }
488 }
489 DdeUnaccessData(hDdeData);
490 }
491 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
492 }
493 }
494 }
495
496 return 0;
497
498 case WM_DDE_REQUEST:
499 FIXME("WM_DDE_REQUEST message received!\n");
500 return 0;
501 case WM_DDE_ADVISE:
502 FIXME("WM_DDE_ADVISE message received!\n");
503 return 0;
504 case WM_DDE_UNADVISE:
505 FIXME("WM_DDE_UNADVISE message received!\n");
506 return 0;
507 case WM_DDE_EXECUTE:
508 FIXME("WM_DDE_EXECUTE message received!\n");
509 return 0;
510 case WM_DDE_POKE:
511 FIXME("WM_DDE_POKE message received!\n");
512 return 0;
513 case WM_DDE_TERMINATE:
514 FIXME("WM_DDE_TERMINATE message received!\n");
515 return 0;
516 default:
517 break;
518 }
519
520 return DefWindowProcW(hwndServer, iMsg, wParam, lParam);
521 }
522
523 /******************************************************************
524 * WDML_ServerQueueRequest
525 *
526 *
527 */
528 static WDML_XACT* WDML_ServerQueueRequest(WDML_CONV* pConv, LPARAM lParam)
529 {
530 UINT_PTR uiLo, uiHi;
531 WDML_XACT* pXAct;
532
533 UnpackDDElParam(WM_DDE_REQUEST, lParam, &uiLo, &uiHi);
534
535 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST,
536 uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
537 if (pXAct) pXAct->atom = uiHi;
538 return pXAct;
539 }
540
541 /******************************************************************
542 * WDML_ServerHandleRequest
543 *
544 *
545 */
546 static WDML_QUEUE_STATE WDML_ServerHandleRequest(WDML_CONV* pConv, WDML_XACT* pXAct)
547 {
548 HDDEDATA hDdeData = 0;
549 BOOL fAck = TRUE;
550
551 if (!(pConv->instance->CBFflags & CBF_FAIL_REQUESTS))
552 {
553
554 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_REQUEST, pXAct->wFmt, (HCONV)pConv,
555 pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
556 }
557
558 switch ((ULONG_PTR)hDdeData)
559 {
560 case 0:
561 TRACE("No data returned from the Callback\n");
562 fAck = FALSE;
563 break;
564
565 case (ULONG_PTR)CBR_BLOCK:
566 return WDML_QS_BLOCK;
567
568 default:
569 {
570 HGLOBAL hMem = WDML_DataHandle2Global(hDdeData, TRUE, FALSE, FALSE, FALSE);
571 if (!PostMessageW(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
572 ReuseDDElParam(pXAct->lParam, WM_DDE_REQUEST, WM_DDE_DATA,
573 (UINT_PTR)hMem, (UINT_PTR)pXAct->atom)))
574 {
575 pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
576 DdeFreeDataHandle(hDdeData);
577 GlobalFree(hMem);
578 fAck = FALSE;
579 }
580 }
581 break;
582 }
583
584 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_REQUEST);
585
586 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
587
588 return WDML_QS_HANDLED;
589 }
590
591 /******************************************************************
592 * WDML_ServerQueueAdvise
593 *
594 *
595 */
596 static WDML_XACT* WDML_ServerQueueAdvise(WDML_CONV* pConv, LPARAM lParam)
597 {
598 UINT_PTR uiLo, uiHi;
599 WDML_XACT* pXAct;
600
601 /* XTYP_ADVSTART transaction:
602 establish link and save link info to InstanceInfoTable */
603
604 if (!UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLo, &uiHi))
605 return NULL;
606
607 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE,
608 0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
609 if (pXAct)
610 {
611 pXAct->hMem = (HGLOBAL)uiLo;
612 pXAct->atom = uiHi;
613 }
614 return pXAct;
615 }
616
617 /******************************************************************
618 * WDML_ServerHandleAdvise
619 *
620 *
621 */
622 static WDML_QUEUE_STATE WDML_ServerHandleAdvise(WDML_CONV* pConv, WDML_XACT* pXAct)
623 {
624 UINT uType;
625 WDML_LINK* pLink;
626 DDEADVISE* pDdeAdvise;
627 HDDEDATA hDdeData = 0;
628 BOOL fAck = TRUE;
629
630 pDdeAdvise = GlobalLock(pXAct->hMem);
631 uType = XTYP_ADVSTART |
632 (pDdeAdvise->fDeferUpd ? XTYPF_NODATA : 0) |
633 (pDdeAdvise->fAckReq ? XTYPF_ACKREQ : 0);
634
635 if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
636 {
637 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_ADVSTART, pDdeAdvise->cfFormat,
638 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
639 }
640
641 switch ((ULONG_PTR)hDdeData)
642 {
643 case 0:
644 TRACE("No data returned from the Callback\n");
645 fAck = FALSE;
646 break;
647
648 case (ULONG_PTR)CBR_BLOCK:
649 return WDML_QS_BLOCK;
650
651 default:
652 /* billx: first to see if the link is already created. */
653 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
654 pXAct->hszItem, TRUE, pDdeAdvise->cfFormat);
655
656 if (pLink != NULL)
657 {
658 /* we found a link, and only need to modify it in case it changes */
659 pLink->transactionType = uType;
660 }
661 else
662 {
663 TRACE("Adding Link with hConv %p\n", pConv);
664 WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
665 uType, pXAct->hszItem, pDdeAdvise->cfFormat);
666 }
667 break;
668 }
669
670 GlobalUnlock(pXAct->hMem);
671 if (fAck)
672 {
673 GlobalFree(pXAct->hMem);
674 }
675 pXAct->hMem = 0;
676
677 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_ADVISE);
678
679 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
680
681 return WDML_QS_HANDLED;
682 }
683
684 /******************************************************************
685 * WDML_ServerQueueUnadvise
686 *
687 *
688 */
689 static WDML_XACT* WDML_ServerQueueUnadvise(WDML_CONV* pConv, LPARAM lParam)
690 {
691 UINT_PTR uiLo, uiHi;
692 WDML_XACT* pXAct;
693
694 UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
695
696 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE,
697 uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
698 if (pXAct) pXAct->atom = uiHi;
699 return pXAct;
700 }
701
702 /******************************************************************
703 * WDML_ServerHandleUnadvise
704 *
705 *
706 */
707 static WDML_QUEUE_STATE WDML_ServerHandleUnadvise(WDML_CONV* pConv, WDML_XACT* pXAct)
708 {
709 WDML_LINK* pLink;
710
711 if (pXAct->hszItem == NULL || pXAct->wFmt == 0)
712 {
713 ERR("Unsupported yet options (null item or clipboard format)\n");
714 return WDML_QS_ERROR;
715 }
716
717 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
718 pXAct->hszItem, TRUE, pXAct->wFmt);
719 if (pLink == NULL)
720 {
721 ERR("Couldn't find link for %p, dropping request\n", pXAct->hszItem);
722 FreeDDElParam(WM_DDE_UNADVISE, pXAct->lParam);
723 return WDML_QS_ERROR;
724 }
725
726 if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
727 {
728 WDML_InvokeCallback(pConv->instance, XTYP_ADVSTOP, pXAct->wFmt, (HCONV)pConv,
729 pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
730 }
731
732 WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
733 pXAct->hszItem, pXAct->wFmt);
734
735 /* send back ack */
736 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, TRUE, pXAct->atom,
737 pXAct->lParam, WM_DDE_UNADVISE);
738
739 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
740
741 return WDML_QS_HANDLED;
742 }
743
744 /******************************************************************
745 * WDML_QueueExecute
746 *
747 *
748 */
749 static WDML_XACT* WDML_ServerQueueExecute(WDML_CONV* pConv, LPARAM lParam)
750 {
751 WDML_XACT* pXAct;
752
753 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
754 if (pXAct)
755 {
756 pXAct->hMem = (HGLOBAL)lParam;
757 }
758 return pXAct;
759 }
760
761 static BOOL data_looks_unicode( const WCHAR *data, DWORD size )
762 {
763 DWORD i;
764
765 if (size % sizeof(WCHAR)) return FALSE;
766 for (i = 0; i < size / sizeof(WCHAR); i++) if (data[i] > 255) return FALSE;
767 return TRUE;
768 }
769
770 /* convert data to Unicode, unless it looks like it's already Unicode */
771 static HDDEDATA map_A_to_W( DWORD instance, void *ptr, DWORD size )
772 {
773 HDDEDATA ret;
774 DWORD len;
775 const char *end;
776
777 if (!data_looks_unicode( ptr, size ))
778 {
779 if ((end = memchr( ptr, 0, size ))) size = end + 1 - (const char *)ptr;
780 len = MultiByteToWideChar( CP_ACP, 0, ptr, size, NULL, 0 );
781 ret = DdeCreateDataHandle( instance, NULL, len * sizeof(WCHAR), 0, 0, CF_TEXT, 0);
782 MultiByteToWideChar( CP_ACP, 0, ptr, size, (WCHAR *)DdeAccessData(ret, NULL), len );
783 }
784 else ret = DdeCreateDataHandle( instance, ptr, size, 0, 0, CF_TEXT, 0 );
785
786 return ret;
787 }
788
789 /* convert data to ASCII, unless it looks like it's not in Unicode format */
790 static HDDEDATA map_W_to_A( DWORD instance, void *ptr, DWORD size )
791 {
792 HDDEDATA ret;
793 DWORD len;
794 const WCHAR *end;
795
796 if (data_looks_unicode( ptr, size ))
797 {
798 size /= sizeof(WCHAR);
799 if ((end = memchrW( ptr, 0, size ))) size = end + 1 - (const WCHAR *)ptr;
800 len = WideCharToMultiByte( CP_ACP, 0, ptr, size, NULL, 0, NULL, NULL );
801 ret = DdeCreateDataHandle( instance, NULL, len, 0, 0, CF_TEXT, 0);
802 WideCharToMultiByte( CP_ACP, 0, ptr, size, (char *)DdeAccessData(ret, NULL), len, NULL, NULL );
803 }
804 else ret = DdeCreateDataHandle( instance, ptr, size, 0, 0, CF_TEXT, 0 );
805
806 return ret;
807 }
808
809 /******************************************************************
810 * WDML_ServerHandleExecute
811 *
812 *
813 */
814 static WDML_QUEUE_STATE WDML_ServerHandleExecute(WDML_CONV* pConv, WDML_XACT* pXAct)
815 {
816 HDDEDATA hDdeData = DDE_FNOTPROCESSED;
817 BOOL fAck = FALSE, fBusy = FALSE;
818
819 if (!(pConv->instance->CBFflags & CBF_FAIL_EXECUTES))
820 {
821 LPVOID ptr = GlobalLock(pXAct->hMem);
822 DWORD size = GlobalSize(pXAct->hMem);
823
824 if (ptr)
825 {
826 if (pConv->instance->unicode) /* Unicode server, try to map A->W */
827 hDdeData = map_A_to_W( pConv->instance->instanceID, ptr, size );
828 else if (!IsWindowUnicode( pConv->hwndClient )) /* ASCII server and client, try to map W->A */
829 hDdeData = map_W_to_A( pConv->instance->instanceID, ptr, size );
830 else
831 hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, ptr, size, 0, 0, CF_TEXT, 0);
832 GlobalUnlock(pXAct->hMem);
833 }
834 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_EXECUTE, 0, (HCONV)pConv,
835 pConv->hszTopic, 0, hDdeData, 0L, 0L);
836 }
837
838 switch ((ULONG_PTR)hDdeData)
839 {
840 case (ULONG_PTR)CBR_BLOCK:
841 return WDML_QS_BLOCK;
842
843 case DDE_FACK:
844 fAck = TRUE;
845 break;
846 case DDE_FBUSY:
847 fBusy = TRUE;
848 break;
849 default:
850 FIXME("Unsupported returned value %p\n", hDdeData);
851 /* fall through */
852 case DDE_FNOTPROCESSED:
853 break;
854 }
855 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, (UINT_PTR)pXAct->hMem, 0, 0);
856
857 return WDML_QS_HANDLED;
858 }
859
860 /******************************************************************
861 * WDML_ServerQueuePoke
862 *
863 *
864 */
865 static WDML_XACT* WDML_ServerQueuePoke(WDML_CONV* pConv, LPARAM lParam)
866 {
867 UINT_PTR uiLo, uiHi;
868 WDML_XACT* pXAct;
869
870 UnpackDDElParam(WM_DDE_POKE, lParam, &uiLo, &uiHi);
871
872 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE,
873 0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
874 if (pXAct)
875 {
876 pXAct->atom = uiHi;
877 pXAct->hMem = (HGLOBAL)uiLo;
878 }
879 return pXAct;
880 }
881
882 /******************************************************************
883 * WDML_ServerHandlePoke
884 *
885 *
886 */
887 static WDML_QUEUE_STATE WDML_ServerHandlePoke(WDML_CONV* pConv, WDML_XACT* pXAct)
888 {
889 DDEPOKE* pDdePoke;
890 HDDEDATA hDdeData;
891 BOOL fBusy = FALSE, fAck = FALSE;
892
893 pDdePoke = GlobalLock(pXAct->hMem);
894 if (!pDdePoke)
895 {
896 return WDML_QS_ERROR;
897 }
898
899 if (!(pConv->instance->CBFflags & CBF_FAIL_POKES))
900 {
901 hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, pDdePoke->Value,
902 GlobalSize(pXAct->hMem) - FIELD_OFFSET(DDEPOKE, Value),
903 0, 0, pDdePoke->cfFormat, 0);
904 if (hDdeData)
905 {
906 HDDEDATA hDdeDataOut;
907
908 hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_POKE, pDdePoke->cfFormat,
909 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
910 hDdeData, 0, 0);
911 switch ((ULONG_PTR)hDdeDataOut)
912 {
913 case DDE_FACK:
914 fAck = TRUE;
915 break;
916 case DDE_FBUSY:
917 fBusy = TRUE;
918 break;
919 default:
920 FIXME("Unsupported returned value %p\n", hDdeDataOut);
921 /* fal through */
922 case DDE_FNOTPROCESSED:
923 break;
924 }
925 DdeFreeDataHandle(hDdeData);
926 }
927 }
928 GlobalUnlock(pXAct->hMem);
929
930 if (!fAck)
931 {
932 GlobalFree(pXAct->hMem);
933 }
934 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, pXAct->atom, pXAct->lParam, WM_DDE_POKE);
935
936 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
937
938 return WDML_QS_HANDLED;
939 }
940
941 /******************************************************************
942 * WDML_ServerQueueTerminate
943 *
944 *
945 */
946 static WDML_XACT* WDML_ServerQueueTerminate(WDML_CONV* pConv, LPARAM lParam)
947 {
948 WDML_XACT* pXAct;
949
950 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
951 return pXAct;
952 }
953
954 /******************************************************************
955 * WDML_ServerHandleTerminate
956 *
957 *
958 */
959 static WDML_QUEUE_STATE WDML_ServerHandleTerminate(WDML_CONV* pConv, WDML_XACT* pXAct)
960 {
961 /* billx: two things to remove: the conv, and associated links.
962 * Respond with another WM_DDE_TERMINATE iMsg.
963 */
964 if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
965 {
966 WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv, 0, 0,
967 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
968 }
969 PostMessageW(pConv->hwndClient, WM_DDE_TERMINATE, (WPARAM)pConv->hwndServer, 0);
970 WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
971
972 return WDML_QS_HANDLED;
973 }
974
975 /******************************************************************
976 * WDML_ServerHandle
977 *
978 *
979 */
980 WDML_QUEUE_STATE WDML_ServerHandle(WDML_CONV* pConv, WDML_XACT* pXAct)
981 {
982 WDML_QUEUE_STATE qs = WDML_QS_ERROR;
983
984 switch (pXAct->ddeMsg)
985 {
986 case WM_DDE_INITIATE:
987 FIXME("WM_DDE_INITIATE shouldn't be there!\n");
988 break;
989 case WM_DDE_REQUEST:
990 qs = WDML_ServerHandleRequest(pConv, pXAct);
991 break;
992
993 case WM_DDE_ADVISE:
994 qs = WDML_ServerHandleAdvise(pConv, pXAct);
995 break;
996
997 case WM_DDE_UNADVISE:
998 qs = WDML_ServerHandleUnadvise(pConv, pXAct);
999 break;
1000
1001 case WM_DDE_EXECUTE:
1002 qs = WDML_ServerHandleExecute(pConv, pXAct);
1003 break;
1004
1005 case WM_DDE_POKE:
1006 qs = WDML_ServerHandlePoke(pConv, pXAct);
1007 break;
1008
1009 case WM_DDE_TERMINATE:
1010 qs = WDML_ServerHandleTerminate(pConv, pXAct);
1011 break;
1012
1013 case WM_DDE_ACK:
1014 WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
1015 break;
1016
1017 default:
1018 FIXME("Unsupported message %d\n", pXAct->ddeMsg);
1019 }
1020 return qs;
1021 }
1022
1023 /******************************************************************
1024 * WDML_ServerConvProc
1025 *
1026 *
1027 */
1028 static LRESULT CALLBACK WDML_ServerConvProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
1029 {
1030 WDML_INSTANCE* pInstance;
1031 WDML_CONV* pConv;
1032 WDML_XACT* pXAct = NULL;
1033
1034 TRACE("%p %04x %08lx %08lx\n", hwndServer, iMsg, wParam, lParam);
1035
1036 if (iMsg == WM_DESTROY)
1037 {
1038 pConv = WDML_GetConvFromWnd(hwndServer);
1039 if (pConv && !(pConv->wStatus & ST_TERMINATED))
1040 {
1041 WDML_ServerHandleTerminate(pConv, NULL);
1042 }
1043 }
1044 if (iMsg < WM_DDE_FIRST || iMsg > WM_DDE_LAST)
1045 {
1046 return IsWindowUnicode(hwndServer) ? DefWindowProcW(hwndServer, iMsg, wParam, lParam) :
1047 DefWindowProcA(hwndServer, iMsg, wParam, lParam);
1048 }
1049
1050 pInstance = WDML_GetInstanceFromWnd(hwndServer);
1051 pConv = WDML_GetConvFromWnd(hwndServer);
1052
1053 if (!pConv)
1054 {
1055 ERR("Got a message (%x) on a not known conversation, dropping request\n", iMsg);
1056 return 0;
1057 }
1058 if (pConv->hwndClient != WIN_GetFullHandle( (HWND)wParam ) || pConv->hwndServer != hwndServer)
1059 {
1060 ERR("mismatch between C/S windows and conversation\n");
1061 return 0;
1062 }
1063 if (pConv->instance != pInstance || pConv->instance == NULL)
1064 {
1065 ERR("mismatch in instances\n");
1066 return 0;
1067 }
1068
1069 switch (iMsg)
1070 {
1071 case WM_DDE_INITIATE:
1072 FIXME("WM_DDE_INITIATE message received!\n");
1073 break;
1074
1075 case WM_DDE_REQUEST:
1076 pXAct = WDML_ServerQueueRequest(pConv, lParam);
1077 break;
1078
1079 case WM_DDE_ADVISE:
1080 pXAct = WDML_ServerQueueAdvise(pConv, lParam);
1081 break;
1082
1083 case WM_DDE_UNADVISE:
1084 pXAct = WDML_ServerQueueUnadvise(pConv, lParam);
1085 break;
1086
1087 case WM_DDE_EXECUTE:
1088 pXAct = WDML_ServerQueueExecute(pConv, lParam);
1089 break;
1090
1091 case WM_DDE_POKE:
1092 pXAct = WDML_ServerQueuePoke(pConv, lParam);
1093 break;
1094
1095 case WM_DDE_TERMINATE:
1096 pXAct = WDML_ServerQueueTerminate(pConv, lParam);
1097 break;
1098
1099 case WM_DDE_ACK:
1100 WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
1101 break;
1102
1103 default:
1104 FIXME("Unsupported message %x\n", iMsg);
1105 break;
1106 }
1107
1108 if (pXAct)
1109 {
1110 pXAct->lParam = lParam;
1111
1112 if ((pConv->wStatus & ST_BLOCKED) || WDML_ServerHandle(pConv, pXAct) == WDML_QS_BLOCK)
1113 {
1114 TRACE("Transactions are blocked, add to the queue and exit\n");
1115 WDML_QueueTransaction(pConv, pXAct);
1116 }
1117 else
1118 {
1119 WDML_FreeTransaction(pInstance, pXAct, TRUE);
1120 }
1121 }
1122 else
1123 pConv->instance->lastError = DMLERR_MEMORY_ERROR;
1124
1125 return 0;
1126 }
Windows API implementation