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