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 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/debug.h"
37 #include "dde_private.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
40
41 static LRESULT CALLBACK WDML_ClientProc(HWND, UINT, WPARAM, LPARAM); /* only for one client, not conv list */
42 const char WDML_szClientConvClassA[] = "WineDdeClientA";
43 const WCHAR WDML_szClientConvClassW[] = {'W','i','n','e','D','d','e','C','l','i','e','n','t','W',0};
44
45 /******************************************************************************
46 * DdeConnectList [USER32.@] Establishes conversation with DDE servers
47 *
48 * PARAMS
49 * idInst [I] Instance identifier
50 * hszService [I] Handle to service name string
51 * hszTopic [I] Handle to topic name string
52 * hConvList [I] Handle to conversation list
53 * pCC [I] Pointer to structure with context data
54 *
55 * RETURNS
56 * Success: Handle to new conversation list
57 * Failure: 0
58 */
59 HCONVLIST WINAPI DdeConnectList(DWORD idInst, HSZ hszService, HSZ hszTopic,
60 HCONVLIST hConvList, PCONVCONTEXT pCC)
61 {
62 FIXME("(%d,%p,%p,%p,%p): stub\n", idInst, hszService, hszTopic, hConvList, pCC);
63 return (HCONVLIST)1;
64 }
65
66 /*****************************************************************
67 * DdeQueryNextServer [USER32.@]
68 */
69 HCONV WINAPI DdeQueryNextServer(HCONVLIST hConvList, HCONV hConvPrev)
70 {
71 FIXME("(%p,%p): stub\n", hConvList, hConvPrev);
72 return 0;
73 }
74
75 /******************************************************************************
76 * DdeDisconnectList [USER32.@] Destroys list and terminates conversations
77 *
78 *
79 * PARAMS
80 * hConvList [I] Handle to conversation list
81 *
82 * RETURNS
83 * Success: TRUE
84 * Failure: FALSE
85 */
86 BOOL WINAPI DdeDisconnectList(HCONVLIST hConvList)
87 {
88 FIXME("(%p): stub\n", hConvList);
89 return TRUE;
90 }
91
92 /*****************************************************************
93 * DdeConnect (USER32.@)
94 */
95 HCONV WINAPI DdeConnect(DWORD idInst, HSZ hszService, HSZ hszTopic,
96 PCONVCONTEXT pCC)
97 {
98 HWND hwndClient;
99 WDML_INSTANCE* pInstance;
100 WDML_CONV* pConv = NULL;
101 ATOM aSrv = 0, aTpc = 0;
102
103 TRACE("(0x%x,%p,%p,%p)\n", idInst, hszService, hszTopic, pCC);
104
105 pInstance = WDML_GetInstance(idInst);
106 if (!pInstance)
107 return NULL;
108
109 /* make sure this conv is never created */
110 pConv = WDML_FindConv(pInstance, WDML_CLIENT_SIDE, hszService, hszTopic);
111 if (pConv != NULL)
112 {
113 ERR("This Conv already exists: (%p)\n", pConv);
114 return NULL;
115 }
116
117 /* we need to establish a conversation with
118 server, so create a window for it */
119
120 if (pInstance->unicode)
121 {
122 WNDCLASSEXW wndclass;
123
124 wndclass.cbSize = sizeof(wndclass);
125 wndclass.style = 0;
126 wndclass.lpfnWndProc = WDML_ClientProc;
127 wndclass.cbClsExtra = 0;
128 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
129 wndclass.hInstance = 0;
130 wndclass.hIcon = 0;
131 wndclass.hCursor = 0;
132 wndclass.hbrBackground = 0;
133 wndclass.lpszMenuName = NULL;
134 wndclass.lpszClassName = WDML_szClientConvClassW;
135 wndclass.hIconSm = 0;
136
137 RegisterClassExW(&wndclass);
138
139 hwndClient = CreateWindowW(WDML_szClientConvClassW, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
140 }
141 else
142 {
143 WNDCLASSEXA wndclass;
144
145 wndclass.cbSize = sizeof(wndclass);
146 wndclass.style = 0;
147 wndclass.lpfnWndProc = WDML_ClientProc;
148 wndclass.cbClsExtra = 0;
149 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
150 wndclass.hInstance = 0;
151 wndclass.hIcon = 0;
152 wndclass.hCursor = 0;
153 wndclass.hbrBackground = 0;
154 wndclass.lpszMenuName = NULL;
155 wndclass.lpszClassName = WDML_szClientConvClassA;
156 wndclass.hIconSm = 0;
157
158 RegisterClassExA(&wndclass);
159
160 hwndClient = CreateWindowA(WDML_szClientConvClassA, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
161 }
162
163 SetWindowLongPtrW(hwndClient, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
164
165 if (hszService)
166 {
167 aSrv = WDML_MakeAtomFromHsz(hszService);
168 if (!aSrv) goto theEnd;
169 }
170 if (hszTopic)
171 {
172 aTpc = WDML_MakeAtomFromHsz(hszTopic);
173 if (!aTpc) goto theEnd;
174 }
175
176 /* note: sent messages shall not use packing */
177 SendMessageTimeoutW( HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndClient, MAKELPARAM(aSrv, aTpc),
178 SMTO_ABORTIFHUNG, 2000, NULL );
179
180 pInstance = WDML_GetInstance(idInst);
181 if (!pInstance)
182 {
183 goto theEnd;
184 }
185
186 /* At this point, Client WM_DDE_ACK should have saved hwndServer
187 for this instance id and hwndClient if server responds.
188 So get HCONV and return it. And add it to conv list */
189 pConv = WDML_GetConvFromWnd(hwndClient);
190 if (pConv == NULL || pConv->hwndServer == 0)
191 {
192 WARN("Done with INITIATE, but no Server window available\n");
193 pConv = NULL;
194 pInstance->lastError = DMLERR_NO_CONV_ESTABLISHED;
195 goto theEnd;
196 }
197 TRACE("Connected to Server window (%p)\n", pConv->hwndServer);
198 pConv->wConvst = XST_CONNECTED;
199
200 /* finish init of pConv */
201 if (pCC != NULL)
202 {
203 pConv->convContext = *pCC;
204 }
205 else
206 {
207 memset(&pConv->convContext, 0, sizeof(pConv->convContext));
208 pConv->convContext.cb = sizeof(pConv->convContext);
209 pConv->convContext.iCodePage = (pInstance->unicode) ? CP_WINUNICODE : CP_WINANSI;
210 }
211
212 theEnd:
213
214 if (aSrv) GlobalDeleteAtom(aSrv);
215 if (aTpc) GlobalDeleteAtom(aTpc);
216 return (HCONV)pConv;
217 }
218
219 /*****************************************************************
220 * DdeReconnect (DDEML.37)
221 * DdeReconnect (USER32.@)
222 */
223 HCONV WINAPI DdeReconnect(HCONV hConv)
224 {
225 WDML_CONV* pConv;
226 WDML_CONV* pNewConv = NULL;
227 ATOM aSrv = 0, aTpc = 0;
228
229 TRACE("(%p)\n", hConv);
230
231 pConv = WDML_GetConv(hConv, FALSE);
232 if (pConv != NULL && (pConv->wStatus & ST_CLIENT))
233 {
234 BOOL ret;
235
236 /* to reestablish a connection, we have to make sure that:
237 * 1/ pConv is the conversation attached to the client window (it wouldn't be
238 * if a call to DdeReconnect would have already been done...)
239 * FIXME: is this really an error ???
240 * 2/ the pConv conversation had really been deconnected
241 */
242 if (pConv == WDML_GetConvFromWnd(pConv->hwndClient) &&
243 (pConv->wStatus & ST_TERMINATED) && !(pConv->wStatus & ST_CONNECTED))
244 {
245 HWND hwndClient = pConv->hwndClient;
246 HWND hwndServer = pConv->hwndServer;
247
248 SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, 0);
249
250 aSrv = WDML_MakeAtomFromHsz(pConv->hszService);
251 aTpc = WDML_MakeAtomFromHsz(pConv->hszTopic);
252 if (!aSrv || !aTpc) goto theEnd;
253
254 /* note: sent messages shall not use packing */
255 ret = SendMessageW(hwndServer, WM_DDE_INITIATE, (WPARAM)hwndClient,
256 MAKELPARAM(aSrv, aTpc));
257
258 pConv = WDML_GetConv(hConv, FALSE);
259 if (pConv == NULL)
260 {
261 FIXME("Should fail reconnection\n");
262 goto theEnd;
263 }
264
265 if (ret && (pNewConv = WDML_GetConvFromWnd(pConv->hwndClient)) != NULL)
266 {
267 /* re-establish all links... */
268 WDML_LINK* pLink;
269
270 for (pLink = pConv->instance->links[WDML_CLIENT_SIDE]; pLink; pLink = pLink->next)
271 {
272 if (pLink->hConv == hConv)
273 {
274 /* try to reestablish the links... */
275 DdeClientTransaction(NULL, 0, (HCONV)pNewConv, pLink->hszItem, pLink->uFmt,
276 pLink->transactionType, 1000, NULL);
277 }
278 }
279 }
280 else
281 {
282 /* reset the conversation as it was */
283 SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
284 }
285 }
286 }
287
288 theEnd:
289
290 if (aSrv) GlobalDeleteAtom(aSrv);
291 if (aTpc) GlobalDeleteAtom(aTpc);
292 return (HCONV)pNewConv;
293 }
294
295 /******************************************************************
296 * WDML_ClientQueueAdvise
297 *
298 * Creates and queue an WM_DDE_ADVISE transaction
299 */
300 static WDML_XACT* WDML_ClientQueueAdvise(WDML_CONV* pConv, UINT wType, UINT wFmt, HSZ hszItem)
301 {
302 DDEADVISE* pDdeAdvise;
303 WDML_XACT* pXAct;
304 ATOM atom;
305
306 TRACE("XTYP_ADVSTART (with%s data) transaction\n", (wType & XTYPF_NODATA) ? "out" : "");
307
308 atom = WDML_MakeAtomFromHsz(hszItem);
309 if (!atom) return NULL;
310
311 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE, wFmt, hszItem);
312 if (!pXAct)
313 {
314 GlobalDeleteAtom(atom);
315 return NULL;
316 }
317
318 pXAct->wType = wType & ~0x0F;
319 pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, sizeof(DDEADVISE));
320 /* FIXME: hMem is unfreed for now... should be deleted in server */
321
322 /* pack DdeAdvise */
323 pDdeAdvise = GlobalLock(pXAct->hMem);
324 pDdeAdvise->fAckReq = (wType & XTYPF_ACKREQ) ? TRUE : FALSE;
325 pDdeAdvise->fDeferUpd = (wType & XTYPF_NODATA) ? TRUE : FALSE;
326 pDdeAdvise->cfFormat = wFmt;
327 GlobalUnlock(pXAct->hMem);
328
329 pXAct->lParam = PackDDElParam(WM_DDE_ADVISE, (UINT_PTR)pXAct->hMem, atom);
330
331 return pXAct;
332 }
333
334 /******************************************************************
335 * WDML_HandleAdviseReply
336 *
337 * handles the reply to an advise request
338 */
339 static WDML_QUEUE_STATE WDML_HandleAdviseReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
340 {
341 DDEACK ddeAck;
342 UINT_PTR uiLo, uiHi;
343 HSZ hsz;
344
345 if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
346 {
347 return WDML_QS_PASS;
348 }
349
350 UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
351 hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
352
353 if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
354 return WDML_QS_PASS;
355
356 GlobalDeleteAtom(uiHi);
357 FreeDDElParam(WM_DDE_ACK, msg->lParam);
358
359 if (ack) *ack = uiLo;
360 WDML_ExtractAck(uiLo, &ddeAck);
361
362 if (ddeAck.fAck)
363 {
364 WDML_LINK* pLink;
365
366 /* billx: first to see if the link is already created. */
367 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
368 pXAct->hszItem, TRUE, pXAct->wFmt);
369 if (pLink != NULL)
370 {
371 /* we found a link, and only need to modify it in case it changes */
372 pLink->transactionType = pXAct->wType;
373 }
374 else
375 {
376 WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
377 pXAct->wType, pXAct->hszItem, pXAct->wFmt);
378 }
379 pXAct->hDdeData = (HDDEDATA)1;
380 }
381 else
382 {
383 TRACE("Returning FALSE on XTYP_ADVSTART - fAck was FALSE\n");
384 GlobalFree(pXAct->hMem);
385 pXAct->hDdeData = NULL;
386 }
387
388 return WDML_QS_HANDLED;
389 }
390
391 /******************************************************************
392 * WDML_ClientQueueUnadvise
393 *
394 * queues an unadvise transaction
395 */
396 static WDML_XACT* WDML_ClientQueueUnadvise(WDML_CONV* pConv, UINT wFmt, HSZ hszItem)
397 {
398 WDML_XACT* pXAct;
399 ATOM atom;
400
401 TRACE("XTYP_ADVSTOP transaction\n");
402
403 atom = WDML_MakeAtomFromHsz(hszItem);
404 if (!atom) return NULL;
405
406 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE, wFmt, hszItem);
407 if (!pXAct)
408 {
409 GlobalDeleteAtom(atom);
410 return NULL;
411 }
412
413 /* end advise loop: post WM_DDE_UNADVISE to server to terminate link
414 * on the specified item.
415 */
416 pXAct->lParam = PackDDElParam(WM_DDE_UNADVISE, wFmt, atom);
417 return pXAct;
418 }
419
420 /******************************************************************
421 * WDML_HandleUnadviseReply
422 *
423 *
424 */
425 static WDML_QUEUE_STATE WDML_HandleUnadviseReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
426 {
427 DDEACK ddeAck;
428 UINT_PTR uiLo, uiHi;
429 HSZ hsz;
430
431 if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
432 {
433 return WDML_QS_PASS;
434 }
435
436 UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
437 hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
438
439 if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
440 return WDML_QS_PASS;
441
442 FreeDDElParam(WM_DDE_ACK, msg->lParam);
443 GlobalDeleteAtom(uiHi);
444
445 if (ack) *ack = uiLo;
446 WDML_ExtractAck(uiLo, &ddeAck);
447
448 TRACE("WM_DDE_ACK received while waiting for a timeout\n");
449
450 if (!ddeAck.fAck)
451 {
452 TRACE("Returning FALSE on XTYP_ADVSTOP - fAck was FALSE\n");
453 pXAct->hDdeData = NULL;
454 }
455 else
456 {
457 /* billx: remove the link */
458 WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
459 pXAct->hszItem, pXAct->wFmt);
460 pXAct->hDdeData = (HDDEDATA)1;
461 }
462 return WDML_QS_HANDLED;
463 }
464
465 /******************************************************************
466 * WDML_ClientQueueRequest
467 *
468 *
469 */
470 static WDML_XACT* WDML_ClientQueueRequest(WDML_CONV* pConv, UINT wFmt, HSZ hszItem)
471 {
472 WDML_XACT* pXAct;
473 ATOM atom;
474
475 TRACE("XTYP_REQUEST transaction\n");
476
477 atom = WDML_MakeAtomFromHsz(hszItem);
478 if (!atom) return NULL;
479
480 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST, wFmt, hszItem);
481 if (!pXAct)
482 {
483 GlobalDeleteAtom(atom);
484 return NULL;
485 }
486
487 pXAct->lParam = PackDDElParam(WM_DDE_REQUEST, wFmt, atom);
488
489 return pXAct;
490 }
491
492 /******************************************************************
493 * WDML_HandleRequestReply
494 *
495 *
496 */
497 static WDML_QUEUE_STATE WDML_HandleRequestReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
498 {
499 DDEACK ddeAck;
500 WINE_DDEHEAD wdh;
501 UINT_PTR uiLo, uiHi;
502 HSZ hsz;
503
504 if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
505 return WDML_QS_PASS;
506
507 switch (msg->message)
508 {
509 case WM_DDE_ACK:
510 UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
511 FreeDDElParam(WM_DDE_ACK, msg->lParam);
512 GlobalDeleteAtom(uiHi);
513 if (ack) *ack = uiLo;
514 WDML_ExtractAck(uiLo, &ddeAck);
515 pXAct->hDdeData = 0;
516 if (ddeAck.fAck)
517 ERR("Positive answer should appear in NACK for a request, assuming negative\n");
518 TRACE("Negative answer...\n");
519 break;
520
521 case WM_DDE_DATA:
522 UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
523 TRACE("Got the result (%08lx)\n", uiLo);
524
525 hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
526
527 if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
528 return WDML_QS_PASS;
529
530 pXAct->hDdeData = WDML_Global2DataHandle((HGLOBAL)uiLo, &wdh);
531 if (wdh.fRelease)
532 {
533 GlobalFree((HGLOBAL)uiLo);
534 }
535 if (wdh.fAckReq)
536 {
537 pConv->instance->lastError = DMLERR_MEMORY_ERROR;
538 }
539 else
540 {
541 GlobalDeleteAtom(uiHi);
542 FreeDDElParam(WM_DDE_ACK, msg->lParam);
543 }
544 break;
545
546 default:
547 FreeDDElParam(msg->message, msg->lParam);
548 return WDML_QS_PASS;
549 }
550
551 return WDML_QS_HANDLED;
552 }
553
554 /******************************************************************
555 * WDML_BuildExecuteCommand
556 *
557 * Creates a DDE block suitable for sending in WM_DDE_COMMAND
558 * It also takes care of string conversion between the two window procedures
559 */
560 static HGLOBAL WDML_BuildExecuteCommand(WDML_CONV* pConv, LPCVOID pData, DWORD cbData)
561 {
562 HGLOBAL hMem;
563 BOOL clientUnicode, serverUnicode;
564 DWORD memSize;
565
566 clientUnicode = pConv->instance->unicode;
567 TRACE("client %p uses unicode = %d\n", pConv->hwndClient, clientUnicode);
568 /* FIXME: how exactly Windows determines what to use for the server side? */
569 serverUnicode = IsWindowUnicode(pConv->hwndServer) && IsWindowUnicode(pConv->hwndClient);
570 TRACE("server %p uses unicode = %d\n", pConv->hwndServer, serverUnicode);
571
572 if (clientUnicode == serverUnicode)
573 {
574 memSize = cbData;
575 }
576 else
577 {
578 if (clientUnicode)
579 {
580 memSize = WideCharToMultiByte( CP_ACP, 0, pData, cbData / sizeof(WCHAR), NULL, 0, NULL, NULL);
581 }
582 else
583 {
584 memSize = MultiByteToWideChar( CP_ACP, 0, pData, cbData, NULL, 0) * sizeof(WCHAR);
585 }
586 }
587
588 hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, memSize);
589
590 if (hMem)
591 {
592 LPSTR pDst;
593
594 pDst = GlobalLock(hMem);
595 if (pDst)
596 {
597 if (clientUnicode == serverUnicode)
598 {
599 memcpy(pDst, pData, cbData);
600 }
601 else
602 {
603 if (clientUnicode)
604 {
605 WideCharToMultiByte( CP_ACP, 0, pData, cbData / sizeof(WCHAR), pDst, memSize, NULL, NULL);
606 }
607 else
608 {
609 MultiByteToWideChar( CP_ACP, 0, pData, cbData, (LPWSTR)pDst, memSize/sizeof(WCHAR));
610 }
611 }
612
613 GlobalUnlock(hMem);
614 }
615 else
616 {
617 GlobalFree(hMem);
618 hMem = 0;
619 }
620 }
621 return hMem;
622 }
623
624 /******************************************************************
625 * WDML_ClientQueueExecute
626 *
627 *
628 */
629 static WDML_XACT* WDML_ClientQueueExecute(WDML_CONV* pConv, LPVOID pData, DWORD cbData)
630 {
631 WDML_XACT* pXAct;
632
633 TRACE("XTYP_EXECUTE transaction\n");
634
635 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
636 if (!pXAct)
637 return NULL;
638
639 if (cbData == (DWORD)-1)
640 {
641 HDDEDATA hDdeData = pData;
642
643 pData = DdeAccessData(hDdeData, &cbData);
644 if (pData)
645 {
646 pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
647 DdeUnaccessData(hDdeData);
648 }
649 }
650 else
651 {
652 pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
653 }
654
655 pXAct->lParam = (LPARAM)pXAct->hMem;
656
657 return pXAct;
658 }
659
660 /******************************************************************
661 * WDML_HandleExecuteReply
662 *
663 *
664 */
665 static WDML_QUEUE_STATE WDML_HandleExecuteReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
666 {
667 DDEACK ddeAck;
668 UINT_PTR uiLo, uiHi;
669
670 if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
671 {
672 return WDML_QS_PASS;
673 }
674
675 UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
676 FreeDDElParam(WM_DDE_ACK, msg->lParam);
677
678 if ((HANDLE)uiHi != pXAct->hMem)
679 {
680 return WDML_QS_PASS;
681 }
682
683 if (ack) *ack = uiLo;
684 WDML_ExtractAck(uiLo, &ddeAck);
685 pXAct->hDdeData = (HDDEDATA)(UINT_PTR)ddeAck.fAck;
686
687 TRACE("hDdeData = %p\n", pXAct->hDdeData);
688 pConv->instance->lastError = (pXAct->hDdeData != 0) ? DMLERR_NO_ERROR : DMLERR_NOTPROCESSED;
689
690 return WDML_QS_HANDLED;
691 }
692
693 /******************************************************************
694 * WDML_ClientQueuePoke
695 *
696 *
697 */
698 static WDML_XACT* WDML_ClientQueuePoke(WDML_CONV* pConv, LPVOID pData, DWORD cbData,
699 UINT wFmt, HSZ hszItem)
700 {
701 DDE_DATAHANDLE_HEAD *dh;
702 WDML_XACT *pXAct;
703 DDEPOKE *ddePoke;
704 HGLOBAL hglobal;
705 ATOM atom;
706
707 TRACE("XTYP_POKE transaction\n");
708
709 atom = WDML_MakeAtomFromHsz(hszItem);
710 if (!atom) return NULL;
711
712 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE, wFmt, hszItem);
713 if (!pXAct)
714 {
715 GlobalDeleteAtom(atom);
716 return NULL;
717 }
718
719 if (cbData == (DWORD)-1)
720 {
721 hglobal = pData;
722 dh = GlobalLock(hglobal);
723 cbData = GlobalSize(hglobal) - sizeof(DDE_DATAHANDLE_HEAD);
724 pData = (LPVOID)(dh + 1);
725 GlobalUnlock(hglobal);
726 }
727
728 pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, FIELD_OFFSET(DDEPOKE, Value[cbData]));
729 ddePoke = GlobalLock(pXAct->hMem);
730 if (!ddePoke)
731 {
732 pConv->instance->lastError = DMLERR_MEMORY_ERROR;
733 return NULL;
734 }
735
736 ddePoke->unused = 0;
737 ddePoke->fRelease = TRUE;
738 ddePoke->cfFormat = wFmt;
739 memcpy(ddePoke->Value, pData, cbData);
740 GlobalUnlock(pXAct->hMem);
741
742 pXAct->lParam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)pXAct->hMem, atom);
743
744 return pXAct;
745 }
746
747 /******************************************************************
748 * WDML_HandlePokeReply
749 *
750 *
751 */
752 static WDML_QUEUE_STATE WDML_HandlePokeReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
753 {
754 UINT_PTR uiLo, uiHi;
755 HSZ hsz;
756
757 if (msg->message != WM_DDE_ACK && WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
758 {
759 return WDML_QS_PASS;
760 }
761
762 UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
763 hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
764 if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
765 {
766 return WDML_QS_PASS;
767 }
768 FreeDDElParam(WM_DDE_ACK, msg->lParam);
769 GlobalDeleteAtom(uiHi);
770
771 if (ack) *ack = uiLo;
772 GlobalFree(pXAct->hMem);
773
774 pXAct->hDdeData = (HDDEDATA)TRUE;
775 return TRUE;
776 }
777
778 /******************************************************************
779 * WDML_ClientQueueTerminate
780 *
781 * Creates and queue an WM_DDE_TERMINATE transaction
782 */
783 static WDML_XACT* WDML_ClientQueueTerminate(WDML_CONV* pConv)
784 {
785 WDML_XACT* pXAct;
786
787 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
788 if (!pXAct)
789 return NULL;
790
791 pXAct->lParam = 0;
792 pConv->wStatus &= ~ST_CONNECTED;
793
794 return pXAct;
795 }
796
797 /******************************************************************
798 * WDML_HandleTerminateReply
799 *
800 * handles the reply to a terminate request
801 */
802 static WDML_QUEUE_STATE WDML_HandleTerminateReply(WDML_CONV* pConv, MSG* msg)
803 {
804 if (msg->message != WM_DDE_TERMINATE)
805 {
806 /* FIXME: should delete data passed here */
807 return WDML_QS_SWALLOWED;
808 }
809
810 if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
811 {
812 FIXME("hmmm shouldn't happen\n");
813 return WDML_QS_PASS;
814 }
815 if (!pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS)
816 {
817 WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
818 0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
819 }
820 WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
821 return WDML_QS_HANDLED;
822 }
823
824 /******************************************************************
825 * WDML_HandleIncomingData
826 *
827 *
828 */
829 static WDML_QUEUE_STATE WDML_HandleIncomingData(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
830 {
831 UINT_PTR uiLo, uiHi;
832 HDDEDATA hDdeDataIn, hDdeDataOut;
833 WDML_LINK* pLink;
834 WINE_DDEHEAD wdh;
835 HSZ hsz;
836
837 TRACE("WM_DDE_DATA message received in the Client Proc!\n");
838 /* wParam -- sending window handle */
839 /* lParam -- hDdeData & item HSZ */
840
841 UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
842 hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
843
844 hDdeDataIn = WDML_Global2DataHandle((HGLOBAL)uiLo, &wdh);
845
846 /* billx:
847 * For hot link, data should be passed to its callback with
848 * XTYP_ADVDATA and callback should return the proper status.
849 */
850 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE, hsz,
851 uiLo ? TRUE : FALSE, wdh.cfFormat);
852 if (!pLink)
853 {
854 WDML_DecHSZ(pConv->instance, hsz);
855 DdeFreeDataHandle(hDdeDataIn);
856 return WDML_QS_PASS;
857 }
858
859 if (hDdeDataIn != 0 && wdh.fAckReq)
860 {
861 WDML_PostAck(pConv, WDML_CLIENT_SIDE, 0, FALSE, TRUE, uiHi, msg->lParam, WM_DDE_DATA);
862 if (msg->lParam)
863 msg->lParam = 0;
864 }
865 else
866 {
867 GlobalDeleteAtom(uiHi);
868 }
869
870 hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_ADVDATA, pLink->uFmt, pLink->hConv,
871 pConv->hszTopic, pLink->hszItem, hDdeDataIn, 0, 0);
872
873 if (hDdeDataOut != (HDDEDATA)DDE_FACK || wdh.fRelease)
874 {
875 if (uiLo) GlobalFree((HANDLE)uiLo);
876 }
877
878 DdeFreeDataHandle(hDdeDataIn);
879
880 WDML_DecHSZ(pConv->instance, hsz);
881 if (msg->lParam)
882 FreeDDElParam(WM_DDE_DATA, msg->lParam);
883
884 return WDML_QS_HANDLED;
885 }
886
887 /******************************************************************
888 * WDML_HandleIncomingTerminate
889 *
890 *
891 */
892 static WDML_QUEUE_STATE WDML_HandleIncomingTerminate(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
893 {
894 if (pConv->hwndServer != WIN_GetFullHandle((HWND)msg->wParam))
895 return WDML_QS_PASS;
896
897 pConv->wStatus |= ST_TERMINATED;
898 if (!pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS)
899 {
900 WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
901 0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
902 }
903 if (pConv->wStatus & ST_CONNECTED)
904 {
905 /* don't care about result code (if server exists or not) */
906 PostMessageW(pConv->hwndServer, WM_DDE_TERMINATE, (WPARAM)pConv->hwndClient, 0L);
907 pConv->wStatus &= ~ST_CONNECTED;
908 }
909 /* have to keep connection around to allow reconnection */
910 return WDML_QS_HANDLED;
911 }
912
913 /******************************************************************
914 * WDML_HandleReply
915 *
916 * handles any incoming reply, and try to match to an already sent request
917 */
918 static WDML_QUEUE_STATE WDML_HandleReply(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd, DWORD *ack)
919 {
920 WDML_XACT* pXAct = pConv->transactions;
921 WDML_QUEUE_STATE qs;
922
923 if (pConv->transactions)
924 {
925 if (ack) *ack = DDE_FNOTPROCESSED;
926 /* first check message against a pending transaction, if any */
927 switch (pXAct->ddeMsg)
928 {
929 case WM_DDE_ADVISE:
930 qs = WDML_HandleAdviseReply(pConv, msg, pXAct, ack);
931 break;
932 case WM_DDE_UNADVISE:
933 qs = WDML_HandleUnadviseReply(pConv, msg, pXAct, ack);
934 break;
935 case WM_DDE_EXECUTE:
936 qs = WDML_HandleExecuteReply(pConv, msg, pXAct, ack);
937 break;
938 case WM_DDE_REQUEST:
939 qs = WDML_HandleRequestReply(pConv, msg, pXAct, ack);
940 break;
941 case WM_DDE_POKE:
942 qs = WDML_HandlePokeReply(pConv, msg, pXAct, ack);
943 break;
944 case WM_DDE_TERMINATE:
945 qs = WDML_HandleTerminateReply(pConv, msg);
946 break;
947 default:
948 qs = WDML_QS_ERROR;
949 FIXME("oooch\n");
950 }
951 }
952 else
953 {
954 qs = WDML_QS_PASS;
955 }
956
957 /* now check the results */
958 switch (qs)
959 {
960 case WDML_QS_ERROR:
961 case WDML_QS_SWALLOWED:
962 *hdd = 0;
963 break;
964 case WDML_QS_HANDLED:
965 /* ok, we have resolved a pending transaction
966 * notify callback if asynchronous.
967 */
968 if (pXAct->dwTimeout == TIMEOUT_ASYNC && pXAct->ddeMsg != WM_DDE_TERMINATE)
969 {
970 WDML_InvokeCallback(pConv->instance, XTYP_XACT_COMPLETE, pXAct->wFmt,
971 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
972 pXAct->hDdeData, MAKELONG(0, pXAct->xActID), 0 /* FIXME */);
973 qs = WDML_QS_PASS;
974 }
975 else
976 {
977 *hdd = pXAct->hDdeData;
978 }
979 break;
980 case WDML_QS_PASS:
981 /* no pending transaction found, try a warm/hot link or a termination request */
982 switch (msg->message)
983 {
984 case