user32: Fix F1 message sequence.
[wine] / dlls / user32 / dde_client.c
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         goto theEnd;
195     }
196     TRACE("Connected to Server window (%p)\n", pConv->hwndServer);
197     pConv->wConvst = XST_CONNECTED;
198
199     /* finish init of pConv */
200     if (pCC != NULL)
201     {
202         pConv->convContext = *pCC;
203     }
204     else
205     {
206         memset(&pConv->convContext, 0, sizeof(pConv->convContext));
207         pConv->convContext.cb = sizeof(pConv->convContext);
208         pConv->convContext.iCodePage = (pInstance->unicode) ? CP_WINUNICODE : CP_WINANSI;
209     }
210
211  theEnd:
212
213     if (aSrv) GlobalDeleteAtom(aSrv);
214     if (aTpc) GlobalDeleteAtom(aTpc);
215     return (HCONV)pConv;
216 }
217
218 /*****************************************************************
219  *            DdeReconnect   (DDEML.37)
220  *            DdeReconnect   (USER32.@)
221  */
222 HCONV WINAPI DdeReconnect(HCONV hConv)
223 {
224     WDML_CONV*  pConv;
225     WDML_CONV*  pNewConv = NULL;
226     ATOM        aSrv = 0, aTpc = 0;
227
228     TRACE("(%p)\n", hConv);
229
230     pConv = WDML_GetConv(hConv, FALSE);
231     if (pConv != NULL && (pConv->wStatus & ST_CLIENT))
232     {
233         BOOL    ret;
234
235         /* to reestablish a connection, we have to make sure that:
236          * 1/ pConv is the conversation attached to the client window (it wouldn't be
237          *    if a call to DdeReconnect would have already been done...)
238          *    FIXME: is this really an error ???
239          * 2/ the pConv conversation had really been deconnected
240          */
241         if (pConv == WDML_GetConvFromWnd(pConv->hwndClient) &&
242             (pConv->wStatus & ST_TERMINATED) && !(pConv->wStatus & ST_CONNECTED))
243         {
244             HWND        hwndClient = pConv->hwndClient;
245             HWND        hwndServer = pConv->hwndServer;
246
247             SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, 0);
248
249             aSrv = WDML_MakeAtomFromHsz(pConv->hszService);
250             aTpc = WDML_MakeAtomFromHsz(pConv->hszTopic);
251             if (!aSrv || !aTpc) goto theEnd;
252
253             /* note: sent messages shall not use packing */
254             ret = SendMessageW(hwndServer, WM_DDE_INITIATE, (WPARAM)hwndClient,
255                                MAKELPARAM(aSrv, aTpc));
256
257             pConv = WDML_GetConv(hConv, FALSE);
258             if (pConv == NULL)
259             {
260                 FIXME("Should fail reconnection\n");
261                 goto theEnd;
262             }
263
264             if (ret && (pNewConv = WDML_GetConvFromWnd(pConv->hwndClient)) != NULL)
265             {
266                 /* re-establish all links... */
267                 WDML_LINK* pLink;
268
269                 for (pLink = pConv->instance->links[WDML_CLIENT_SIDE]; pLink; pLink = pLink->next)
270                 {
271                     if (pLink->hConv == hConv)
272                     {
273                         /* try to reestablish the links... */
274                         DdeClientTransaction(NULL, 0, (HCONV)pNewConv, pLink->hszItem, pLink->uFmt,
275                                              pLink->transactionType, 1000, NULL);
276                     }
277                 }
278             }
279             else
280             {
281                 /* reset the conversation as it was */
282                 SetWindowLongPtrW(pConv->hwndClient, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
283             }
284         }
285     }
286
287  theEnd:
288
289     if (aSrv) GlobalDeleteAtom(aSrv);
290     if (aTpc) GlobalDeleteAtom(aTpc);
291     return (HCONV)pNewConv;
292 }
293
294 /******************************************************************
295  *              WDML_ClientQueueAdvise
296  *
297  * Creates and queue an WM_DDE_ADVISE transaction
298  */
299 static WDML_XACT*       WDML_ClientQueueAdvise(WDML_CONV* pConv, UINT wType, UINT wFmt, HSZ hszItem)
300 {
301     DDEADVISE*          pDdeAdvise;
302     WDML_XACT*          pXAct;
303     ATOM                atom;
304
305     TRACE("XTYP_ADVSTART (with%s data) transaction\n", (wType & XTYPF_NODATA) ? "out" : "");
306
307     atom = WDML_MakeAtomFromHsz(hszItem);
308     if (!atom) return NULL;
309
310     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE, wFmt, hszItem);
311     if (!pXAct)
312     {
313         GlobalDeleteAtom(atom);
314         return NULL;
315     }
316
317     pXAct->wType = wType & ~0x0F;
318     pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, sizeof(DDEADVISE));
319     /* FIXME: hMem is unfreed for now... should be deleted in server */
320
321     /* pack DdeAdvise   */
322     pDdeAdvise = (DDEADVISE*)GlobalLock(pXAct->hMem);
323     pDdeAdvise->fAckReq   = (wType & XTYPF_ACKREQ) ? TRUE : FALSE;
324     pDdeAdvise->fDeferUpd = (wType & XTYPF_NODATA) ? TRUE : FALSE;
325     pDdeAdvise->cfFormat  = wFmt;
326     GlobalUnlock(pXAct->hMem);
327
328     pXAct->lParam = PackDDElParam(WM_DDE_ADVISE, (UINT_PTR)pXAct->hMem, atom);
329
330     return pXAct;
331 }
332
333 /******************************************************************
334  *              WDML_HandleAdviseReply
335  *
336  * handles the reply to an advise request
337  */
338 static WDML_QUEUE_STATE WDML_HandleAdviseReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
339 {
340     DDEACK              ddeAck;
341     UINT_PTR            uiLo, uiHi;
342     HSZ                 hsz;
343
344     if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
345     {
346         return WDML_QS_PASS;
347     }
348
349     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
350     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
351
352     if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
353         return WDML_QS_PASS;
354
355     GlobalDeleteAtom(uiHi);
356     FreeDDElParam(WM_DDE_ACK, msg->lParam);
357
358     if (ack) *ack = uiLo;
359     WDML_ExtractAck(uiLo, &ddeAck);
360
361     if (ddeAck.fAck)
362     {
363         WDML_LINK*      pLink;
364
365         /* billx: first to see if the link is already created. */
366         pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
367                               pXAct->hszItem, TRUE, pXAct->wFmt);
368         if (pLink != NULL)
369         {
370             /* we found a link, and only need to modify it in case it changes */
371             pLink->transactionType = pXAct->wType;
372         }
373         else
374         {
375             WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
376                          pXAct->wType, pXAct->hszItem, pXAct->wFmt);
377         }
378         pXAct->hDdeData = (HDDEDATA)1;
379     }
380     else
381     {
382         TRACE("Returning FALSE on XTYP_ADVSTART - fAck was FALSE\n");
383         GlobalFree(pXAct->hMem);
384         pXAct->hDdeData = NULL;
385     }
386
387     return WDML_QS_HANDLED;
388 }
389
390 /******************************************************************
391  *              WDML_ClientQueueUnadvise
392  *
393  * queues an unadvise transaction
394  */
395 static WDML_XACT*       WDML_ClientQueueUnadvise(WDML_CONV* pConv, UINT wFmt, HSZ hszItem)
396 {
397     WDML_XACT*  pXAct;
398     ATOM        atom;
399
400     TRACE("XTYP_ADVSTOP transaction\n");
401
402     atom = WDML_MakeAtomFromHsz(hszItem);
403     if (!atom) return NULL;
404
405     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE, wFmt, hszItem);
406     if (!pXAct)
407     {
408         GlobalDeleteAtom(atom);
409         return NULL;
410     }
411
412     /* end advise loop: post WM_DDE_UNADVISE to server to terminate link
413      * on the specified item.
414      */
415     pXAct->lParam = PackDDElParam(WM_DDE_UNADVISE, wFmt, atom);
416     return pXAct;
417 }
418
419 /******************************************************************
420  *              WDML_HandleUnadviseReply
421  *
422  *
423  */
424 static WDML_QUEUE_STATE WDML_HandleUnadviseReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
425 {
426     DDEACK      ddeAck;
427     UINT_PTR    uiLo, uiHi;
428     HSZ         hsz;
429
430     if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
431     {
432         return WDML_QS_PASS;
433     }
434
435     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
436     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
437
438     if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
439         return WDML_QS_PASS;
440
441     FreeDDElParam(WM_DDE_ACK, msg->lParam);
442     GlobalDeleteAtom(uiHi);
443
444     if (ack) *ack = uiLo;
445     WDML_ExtractAck(uiLo, &ddeAck);
446
447     TRACE("WM_DDE_ACK received while waiting for a timeout\n");
448
449     if (!ddeAck.fAck)
450     {
451         TRACE("Returning FALSE on XTYP_ADVSTOP - fAck was FALSE\n");
452         pXAct->hDdeData = NULL;
453     }
454     else
455     {
456         /* billx: remove the link */
457         WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
458                         pXAct->hszItem, pXAct->wFmt);
459         pXAct->hDdeData = (HDDEDATA)1;
460     }
461     return WDML_QS_HANDLED;
462 }
463
464 /******************************************************************
465  *              WDML_ClientQueueRequest
466  *
467  *
468  */
469 static WDML_XACT*       WDML_ClientQueueRequest(WDML_CONV* pConv, UINT wFmt, HSZ hszItem)
470 {
471     WDML_XACT*  pXAct;
472     ATOM        atom;
473
474     TRACE("XTYP_REQUEST transaction\n");
475
476     atom = WDML_MakeAtomFromHsz(hszItem);
477     if (!atom) return NULL;
478
479     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST, wFmt, hszItem);
480     if (!pXAct)
481     {
482         GlobalDeleteAtom(atom);
483         return NULL;
484     }
485
486     pXAct->lParam = PackDDElParam(WM_DDE_REQUEST, wFmt, atom);
487
488     return pXAct;
489 }
490
491 /******************************************************************
492  *              WDML_HandleRequestReply
493  *
494  *
495  */
496 static WDML_QUEUE_STATE WDML_HandleRequestReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
497 {
498     DDEACK              ddeAck;
499     WINE_DDEHEAD        wdh;
500     UINT_PTR            uiLo, uiHi;
501     HSZ                 hsz;
502
503     if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
504         return WDML_QS_PASS;
505
506     switch (msg->message)
507     {
508     case WM_DDE_ACK:
509         UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
510         FreeDDElParam(WM_DDE_ACK, msg->lParam);
511         GlobalDeleteAtom(uiHi);
512        if (ack) *ack = uiLo;
513         WDML_ExtractAck(uiLo, &ddeAck);
514         pXAct->hDdeData = 0;
515         if (ddeAck.fAck)
516             ERR("Positive answer should appear in NACK for a request, assuming negative\n");
517         TRACE("Negative answer...\n");
518         break;
519
520     case WM_DDE_DATA:
521         UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
522         TRACE("Got the result (%08lx)\n", uiLo);
523
524         hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
525
526         if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
527             return WDML_QS_PASS;
528
529         pXAct->hDdeData = WDML_Global2DataHandle((HGLOBAL)uiLo, &wdh);
530         if (wdh.fRelease)
531         {
532             GlobalFree((HGLOBAL)uiLo);
533         }
534         if (wdh.fAckReq)
535         {
536             pConv->instance->lastError = DMLERR_MEMORY_ERROR;
537         }
538         else
539         {
540             GlobalDeleteAtom(uiHi);
541             FreeDDElParam(WM_DDE_ACK, msg->lParam);
542         }
543         break;
544
545     default:
546         FreeDDElParam(msg->message, msg->lParam);
547         return WDML_QS_PASS;
548     }
549
550     return WDML_QS_HANDLED;
551 }
552
553 /******************************************************************
554  *              WDML_BuildExecuteCommand
555  *
556  * Creates a DDE block suitable for sending in WM_DDE_COMMAND
557  * It also takes care of string conversion between the two window procedures
558  */
559 static  HGLOBAL WDML_BuildExecuteCommand(WDML_CONV* pConv, LPCVOID pData, DWORD cbData)
560 {
561     HGLOBAL     hMem;
562     BOOL        clientUnicode, serverUnicode;
563     DWORD       memSize;
564
565     clientUnicode = pConv->instance->unicode;
566     TRACE("client %p uses unicode = %d\n", pConv->hwndClient, clientUnicode);
567     /* FIXME: how exactly Windows determines what to use for the server side? */
568     serverUnicode = IsWindowUnicode(pConv->hwndServer) && IsWindowUnicode(pConv->hwndClient);
569     TRACE("server %p uses unicode = %d\n", pConv->hwndServer, serverUnicode);
570
571     if (clientUnicode == serverUnicode)
572     {
573         memSize = cbData;
574     }
575     else
576     {
577         if (clientUnicode)
578         {
579             memSize = WideCharToMultiByte( CP_ACP, 0, pData, cbData, NULL, 0, NULL, NULL);
580         }
581         else
582         {
583             memSize = MultiByteToWideChar( CP_ACP, 0, pData, cbData, NULL, 0) * sizeof(WCHAR);
584         }
585     }
586
587     hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, memSize);
588
589     if (hMem)
590     {
591         LPSTR   pDst;
592
593         pDst = GlobalLock(hMem);
594         if (pDst)
595         {
596             if (clientUnicode == serverUnicode)
597             {
598                 memcpy(pDst, pData, cbData);
599             }
600             else
601             {
602                 if (clientUnicode)
603                 {
604                     WideCharToMultiByte( CP_ACP, 0, pData, cbData, pDst, memSize, NULL, NULL);
605                 }
606                 else
607                 {
608                     MultiByteToWideChar( CP_ACP, 0, pData, cbData, (LPWSTR)pDst, memSize/sizeof(WCHAR));
609                 }
610             }
611
612             GlobalUnlock(hMem);
613         }
614         else
615         {
616             GlobalFree(hMem);
617             hMem = 0;
618         }
619     }
620     return hMem;
621 }
622
623 /******************************************************************
624  *              WDML_ClientQueueExecute
625  *
626  *
627  */
628 static WDML_XACT*       WDML_ClientQueueExecute(WDML_CONV* pConv, LPVOID pData, DWORD cbData)
629 {
630     WDML_XACT*  pXAct;
631
632     TRACE("XTYP_EXECUTE transaction\n");
633
634     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
635     if (!pXAct)
636         return NULL;
637
638     if (cbData == (DWORD)-1)
639     {
640         HDDEDATA        hDdeData = pData;
641
642         pData = DdeAccessData(hDdeData, &cbData);
643         if (pData)
644         {
645             pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
646             DdeUnaccessData(hDdeData);
647         }
648     }
649     else
650     {
651         pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
652     }
653
654     pXAct->lParam = (LPARAM)pXAct->hMem;
655
656     return pXAct;
657 }
658
659 /******************************************************************
660  *              WDML_HandleExecuteReply
661  *
662  *
663  */
664 static WDML_QUEUE_STATE WDML_HandleExecuteReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
665 {
666     DDEACK      ddeAck;
667     UINT_PTR    uiLo, uiHi;
668
669     if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
670     {
671         return WDML_QS_PASS;
672     }
673
674     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
675     FreeDDElParam(WM_DDE_ACK, msg->lParam);
676
677     if ((HANDLE)uiHi != pXAct->hMem)
678     {
679         return WDML_QS_PASS;
680     }
681
682     if (ack) *ack = uiLo;
683     WDML_ExtractAck(uiLo, &ddeAck);
684     pXAct->hDdeData = (HDDEDATA)(UINT_PTR)ddeAck.fAck;
685
686     TRACE("hDdeData = %p\n", pXAct->hDdeData);
687     pConv->instance->lastError = (pXAct->hDdeData != 0) ? DMLERR_NO_ERROR : DMLERR_NOTPROCESSED;
688
689     return WDML_QS_HANDLED;
690 }
691
692 /******************************************************************
693  *              WDML_ClientQueuePoke
694  *
695  *
696  */
697 static WDML_XACT*       WDML_ClientQueuePoke(WDML_CONV* pConv, LPVOID pData, DWORD cbData,
698                                              UINT wFmt, HSZ hszItem)
699 {
700     DDE_DATAHANDLE_HEAD *dh;
701     WDML_XACT *pXAct;
702     DDEPOKE *ddePoke;
703     HGLOBAL hglobal;
704     ATOM atom;
705
706     TRACE("XTYP_POKE transaction\n");
707
708     atom = WDML_MakeAtomFromHsz(hszItem);
709     if (!atom) return NULL;
710
711     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE, wFmt, hszItem);
712     if (!pXAct)
713     {
714         GlobalDeleteAtom(atom);
715         return NULL;
716     }
717
718     if (cbData == (DWORD)-1)
719     {
720         hglobal = pData;
721         dh = (DDE_DATAHANDLE_HEAD *)GlobalLock(hglobal);
722         cbData = GlobalSize(hglobal) - sizeof(DDE_DATAHANDLE_HEAD);
723         pData = (LPVOID)(dh + 1);
724         GlobalUnlock(hglobal);
725     }
726
727     pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, sizeof(DDEPOKE) + cbData);
728     ddePoke = GlobalLock(pXAct->hMem);
729     if (!ddePoke)
730     {
731         pConv->instance->lastError = DMLERR_MEMORY_ERROR;
732         return NULL;
733     }
734
735     ddePoke->unused = 0;
736     ddePoke->fRelease = TRUE;
737     ddePoke->cfFormat = wFmt;
738     memcpy(ddePoke->Value, pData, cbData);
739     GlobalUnlock(pXAct->hMem);
740
741     pXAct->lParam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)pXAct->hMem, atom);
742
743     return pXAct;
744 }
745
746 /******************************************************************
747  *              WDML_HandlePokeReply
748  *
749  *
750  */
751 static WDML_QUEUE_STATE WDML_HandlePokeReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
752 {
753     UINT_PTR    uiLo, uiHi;
754     HSZ         hsz;
755
756     if (msg->message != WM_DDE_ACK && WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
757     {
758         return WDML_QS_PASS;
759     }
760
761     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
762     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
763     if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
764     {
765         return WDML_QS_PASS;
766     }
767     FreeDDElParam(WM_DDE_ACK, msg->lParam);
768     GlobalDeleteAtom(uiHi);
769
770     if (ack) *ack = uiLo;
771     GlobalFree(pXAct->hMem);
772
773     pXAct->hDdeData = (HDDEDATA)TRUE;
774     return TRUE;
775 }
776
777 /******************************************************************
778  *              WDML_ClientQueueTerminate
779  *
780  * Creates and queue an WM_DDE_TERMINATE transaction
781  */
782 static WDML_XACT*       WDML_ClientQueueTerminate(WDML_CONV* pConv)
783 {
784     WDML_XACT*          pXAct;
785
786     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
787     if (!pXAct)
788         return NULL;
789
790     pXAct->lParam = 0;
791     pConv->wStatus &= ~ST_CONNECTED;
792
793     return pXAct;
794 }
795
796 /******************************************************************
797  *              WDML_HandleTerminateReply
798  *
799  * handles the reply to a terminate request
800  */
801 static WDML_QUEUE_STATE WDML_HandleTerminateReply(WDML_CONV* pConv, MSG* msg)
802 {
803     if (msg->message != WM_DDE_TERMINATE)
804     {
805         /* FIXME: should delete data passed here */
806         return WDML_QS_SWALLOWED;
807     }
808
809     if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
810     {
811         FIXME("hmmm shouldn't happen\n");
812         return WDML_QS_PASS;
813     }
814     if (!pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS)
815     {
816         WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
817                             0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
818     }
819     WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
820     return WDML_QS_HANDLED;
821 }
822
823 /******************************************************************
824  *              WDML_HandleIncomingData
825  *
826  *
827  */
828 static WDML_QUEUE_STATE WDML_HandleIncomingData(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
829 {
830     UINT_PTR            uiLo, uiHi;
831     HDDEDATA            hDdeDataIn, hDdeDataOut;
832     WDML_LINK*          pLink;
833     WINE_DDEHEAD        wdh;
834     HSZ                 hsz;
835
836     TRACE("WM_DDE_DATA message received in the Client Proc!\n");
837     /* wParam -- sending window handle  */
838     /* lParam -- hDdeData & item HSZ    */
839
840     UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
841     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
842
843     hDdeDataIn = WDML_Global2DataHandle((HGLOBAL)uiLo, &wdh);
844
845     /* billx:
846      *  For hot link, data should be passed to its callback with
847      * XTYP_ADVDATA and callback should return the proper status.
848      */
849     pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE, hsz,
850                           uiLo ? TRUE : FALSE, wdh.cfFormat);
851     if (!pLink)
852     {
853         WDML_DecHSZ(pConv->instance, hsz);
854         DdeFreeDataHandle(hDdeDataIn);
855         return WDML_QS_PASS;
856     }
857
858     if (hDdeDataIn != 0 && wdh.fAckReq)
859     {
860         WDML_PostAck(pConv, WDML_CLIENT_SIDE, 0, FALSE, TRUE, uiHi, msg->lParam, WM_DDE_DATA);
861         if (msg->lParam)
862             msg->lParam = 0;
863     }
864     else
865     {
866         GlobalDeleteAtom(uiHi);
867     }
868
869     hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_ADVDATA, pLink->uFmt, pLink->hConv,
870                                       pConv->hszTopic, pLink->hszItem, hDdeDataIn, 0, 0);
871
872     if (hDdeDataOut != (HDDEDATA)DDE_FACK || wdh.fRelease)
873     {
874         if (uiLo) GlobalFree((HANDLE)uiLo);
875     }
876
877     DdeFreeDataHandle(hDdeDataIn);
878
879     WDML_DecHSZ(pConv->instance, hsz);
880     if (msg->lParam)
881         FreeDDElParam(WM_DDE_DATA, msg->lParam);
882
883     return WDML_QS_HANDLED;
884 }
885
886 /******************************************************************
887  *              WDML_HandleIncomingTerminate
888  *
889  *
890  */
891 static WDML_QUEUE_STATE WDML_HandleIncomingTerminate(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
892 {
893     if (pConv->hwndServer != WIN_GetFullHandle((HWND)msg->wParam))
894         return WDML_QS_PASS;
895
896     pConv->wStatus |= ST_TERMINATED;
897     if (!pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS)
898     {
899         WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
900                             0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
901     }
902     if (pConv->wStatus & ST_CONNECTED)
903     {
904         /* don't care about result code (if server exists or not) */
905         PostMessageW(pConv->hwndServer, WM_DDE_TERMINATE, (WPARAM)pConv->hwndClient, 0L);
906         pConv->wStatus &= ~ST_CONNECTED;
907     }
908     /* have to keep connection around to allow reconnection */
909     return WDML_QS_HANDLED;
910 }
911
912 /******************************************************************
913  *              WDML_HandleReply
914  *
915  * handles any incoming reply, and try to match to an already sent request
916  */
917 static WDML_QUEUE_STATE WDML_HandleReply(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd, DWORD *ack)
918 {
919     WDML_XACT*          pXAct = pConv->transactions;
920     WDML_QUEUE_STATE    qs;
921
922     if (pConv->transactions)
923     {
924         /* first check message against a pending transaction, if any */
925         switch (pXAct->ddeMsg)
926         {
927         case WM_DDE_ADVISE:
928             qs = WDML_HandleAdviseReply(pConv, msg, pXAct, ack);
929             break;
930         case WM_DDE_UNADVISE:
931             qs = WDML_HandleUnadviseReply(pConv, msg, pXAct, ack);
932             break;
933         case WM_DDE_EXECUTE:
934             qs = WDML_HandleExecuteReply(pConv, msg, pXAct, ack);
935             break;
936         case WM_DDE_REQUEST:
937             qs = WDML_HandleRequestReply(pConv, msg, pXAct, ack);
938             break;
939         case WM_DDE_POKE:
940             qs = WDML_HandlePokeReply(pConv, msg, pXAct, ack);
941             break;
942         case WM_DDE_TERMINATE:
943             qs = WDML_HandleTerminateReply(pConv, msg);
944             break;
945         default:
946             qs = WDML_QS_ERROR;
947             FIXME("oooch\n");
948         }
949     }
950     else
951     {
952         qs = WDML_QS_PASS;
953     }
954
955     /* now check the results */
956     switch (qs)
957     {
958     case WDML_QS_ERROR:
959     case WDML_QS_SWALLOWED:
960         *hdd = 0;
961         break;
962     case WDML_QS_HANDLED:
963         /* ok, we have resolved a pending transaction
964          * notify callback if asynchronous.
965          */
966         if (pXAct->dwTimeout == TIMEOUT_ASYNC && pXAct->ddeMsg != WM_DDE_TERMINATE)
967         {
968             WDML_InvokeCallback(pConv->instance, XTYP_XACT_COMPLETE, pXAct->wFmt,
969                                 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
970                                 pXAct->hDdeData, MAKELONG(0, pXAct->xActID), 0 /* FIXME */);
971             qs = WDML_QS_PASS;
972         }
973         else
974         {
975             *hdd = pXAct->hDdeData;
976         }
977         break;
978     case WDML_QS_PASS:
979         /* no pending transaction found, try a warm/hot link or a termination request */
980         switch (msg->message)
981         {
982         case WM_DDE_DATA:
983             qs = WDML_HandleIncomingData(pConv, msg, hdd);
984             break;
985         case WM_DDE_TERMINATE:
986             qs = WDML_HandleIncomingTerminate(pConv, msg, hdd);
987             break;
988         case WM_DDE_ACK:
989             /* This happens at end of DdeClientTransaction XTYP_EXECUTE
990              * Without this assignment, DdeClientTransaction's return value is undefined
991              */
992             *hdd = (HDDEDATA)TRUE;
993             if (ack)
994                 *ack = DDE_FACK;
995             break;
996         }
997         break;
998     case WDML_QS_BLOCK:
999         FIXME("shouldn't be used on client side\n");
1000         break;
1001     }
1002
1003     return qs;
1004 }
1005
1006 /******************************************************************
1007  *              WDML_SyncWaitTransactionReply
1008  *
1009  * waits until an answer for a sent request is received
1010  * time out is also handled. only used for synchronous transactions
1011  */
1012 static HDDEDATA WDML_SyncWaitTransactionReply(HCONV hConv, DWORD dwTimeout, const WDML_XACT* pXAct, DWORD *ack)
1013 {
1014     DWORD       dwTime;
1015     DWORD       err;
1016     WDML_CONV*  pConv;
1017
1018     TRACE("Starting wait for a timeout of %d ms\n", dwTimeout);
1019
1020     /* FIXME: time 32 bit wrap around */
1021     dwTimeout += GetCurrentTime();
1022
1023     while ((dwTime = GetCurrentTime()) < dwTimeout)
1024     {
1025         /* we cannot be in the crit sect all the time because when client and server run in a
1026          * single process they need to share the access to the internal data
1027          */
1028         if (MsgWaitForMultipleObjects(0, NULL, FALSE,
1029                                       dwTimeout - dwTime, QS_POSTMESSAGE) == WAIT_OBJECT_0)
1030         {
1031             MSG         msg;
1032
1033             while (PeekMessageW(&msg, 0, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE))
1034             {
1035                 HDDEDATA hdd;
1036
1037                 pConv = WDML_GetConv(hConv, FALSE);
1038                 if (pConv == NULL)
1039                 {
1040                     /* conversation no longer available... return failure */
1041                     return 0;
1042                 }
1043                 if (msg.hwnd == pConv->hwndClient)
1044                 {
1045                     /* check that either pXAct has been processed or no more xActions are pending */
1046                     BOOL ret = (pConv->transactions == pXAct);
1047                     if (WDML_HandleReply(pConv, &msg, &hdd, ack) == WDML_QS_HANDLED)
1048                     {
1049                         TRACE("WDML_HandleReply returned WDML_QS_HANDLED\n");
1050                         ret = TRUE;
1051                     }
1052                     else
1053                         ret = (pConv->transactions == NULL || ret);
1054
1055                     if (ret)
1056                     {
1057                         pConv->instance->lastError = hdd ? DMLERR_NO_ERROR : DMLERR_NOTPROCESSED;
1058                         return hdd;
1059                     }
1060                 }
1061                 else
1062                 {
1063                     DispatchMessageW(&msg);
1064                 }
1065             }
1066         }
1067     }
1068
1069     TRACE("Timeout !!\n");
1070
1071     pConv = WDML_GetConv(hConv, FALSE);
1072     if (pConv != NULL)
1073     {
1074         if (pConv->transactions)
1075         {
1076             switch (pConv->transactions->ddeMsg)
1077             {
1078             case WM_DDE_ADVISE:         err = DMLERR_ADVACKTIMEOUT;     break;
1079             case WM_DDE_REQUEST:        err = DMLERR_DATAACKTIMEOUT;    break;
1080             case WM_DDE_EXECUTE:        err = DMLERR_EXECACKTIMEOUT;    break;
1081             case WM_DDE_POKE:           err = DMLERR_POKEACKTIMEOUT;    break;
1082             case WM_DDE_UNADVISE:       err = DMLERR_UNADVACKTIMEOUT;   break;
1083             default:                    err = DMLERR_INVALIDPARAMETER;  break;
1084             }
1085
1086             pConv->instance->lastError = err;
1087         }
1088     }
1089
1090     return 0;
1091 }
1092
1093
1094 /*****************************************************************
1095  *            WDML_ClientHandle
1096  */
1097 HDDEDATA WDML_ClientHandle(WDML_CONV *pConv, WDML_XACT *pXAct, DWORD dwTimeout, LPDWORD pdwResult)
1098 {
1099     HDDEDATA hDdeData;
1100
1101     if (!PostMessageW(pConv->hwndServer, pXAct->ddeMsg, (WPARAM)pConv->hwndClient, pXAct->lParam))
1102     {
1103         WARN("Failed posting message %x to %p (error=0x%x)\n",
1104               pXAct->ddeMsg, pConv->hwndServer, GetLastError());
1105         pConv->wStatus &= ~ST_CONNECTED;
1106         pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
1107         return 0;
1108     }
1109     pXAct->dwTimeout = dwTimeout;
1110     /* FIXME: should set the app bits on *pdwResult */
1111
1112     if (dwTimeout == TIMEOUT_ASYNC)
1113     {
1114         if (pdwResult)
1115             *pdwResult = MAKELONG(0, pXAct->xActID);
1116
1117         hDdeData = (HDDEDATA)1;
1118     }
1119     else
1120         hDdeData = WDML_SyncWaitTransactionReply((HCONV)pConv, dwTimeout, pXAct, pdwResult);
1121
1122     return hDdeData;
1123 }
1124
1125
1126 /*****************************************************************
1127  *            DdeClientTransaction  (USER32.@)
1128  */
1129 HDDEDATA WINAPI DdeClientTransaction(LPBYTE pData, DWORD cbData, HCONV hConv, HSZ hszItem, UINT wFmt,
1130                                      UINT wType, DWORD dwTimeout, LPDWORD pdwResult)
1131 {
1132     WDML_CONV*          pConv;
1133     WDML_XACT*          pXAct;
1134     HDDEDATA            hDdeData = 0;
1135
1136     TRACE("(%p,%d,%p,%p,%x,%x,%d,%p)\n",
1137           pData, cbData, hConv, hszItem, wFmt, wType, dwTimeout, pdwResult);
1138
1139     if (hConv == 0)
1140     {
1141         WARN("Invalid conversation handle NULL\n");
1142         return 0;
1143     }
1144
1145     pConv = WDML_GetConv(hConv, TRUE);
1146     if (pConv == NULL)
1147     {
1148         /* cannot set error... cannot get back to DDE instance */
1149         return 0;
1150     }
1151
1152     switch (wType)
1153     {
1154     case XTYP_EXECUTE:
1155         /* Windows simply ignores hszItem and wFmt in this case */
1156         pXAct = WDML_ClientQueueExecute(pConv, pData, cbData);
1157         break;
1158     case XTYP_POKE:
1159         if (!hszItem)
1160         {
1161             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1162             return 0;
1163         }
1164         pXAct = WDML_ClientQueuePoke(pConv, pData, cbData, wFmt, hszItem);
1165         break;
1166     case XTYP_ADVSTART|XTYPF_NODATA:
1167     case XTYP_ADVSTART|XTYPF_NODATA|XTYPF_ACKREQ:
1168     case XTYP_ADVSTART:
1169     case XTYP_ADVSTART|XTYPF_ACKREQ:
1170         if (pData)
1171         {
1172             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1173             return 0;
1174         }
1175         pXAct = WDML_ClientQueueAdvise(pConv, wType, wFmt, hszItem);
1176         break;
1177     case XTYP_ADVSTOP:
1178         if (pData)
1179         {
1180             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1181             return 0;
1182         }
1183         pXAct = WDML_ClientQueueUnadvise(pConv, wFmt, hszItem);
1184         break;
1185     case XTYP_REQUEST:
1186         if (pData || !hszItem)
1187         {
1188             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1189             return 0;
1190         }
1191         pXAct = WDML_ClientQueueRequest(pConv, wFmt, hszItem);
1192         break;
1193     default:
1194         FIXME("Unknown transaction type %04x\n", wType);
1195         /* unknown transaction type */
1196         pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1197         return 0;
1198     }
1199
1200     if (pXAct == NULL)
1201     {
1202         pConv->instance->lastError = DMLERR_MEMORY_ERROR;
1203         return 0;
1204     }
1205
1206     WDML_QueueTransaction(pConv, pXAct);
1207
1208     TRACE("pConv->wStatus %04x\n", pConv->wStatus);
1209
1210     if (pConv->wStatus & ST_BLOCKED)
1211     {
1212         TRACE("Transactions are blocked, add to the queue and exit\n");
1213         return (HDDEDATA)1;
1214     }
1215
1216     hDdeData = WDML_ClientHandle(pConv, pXAct, dwTimeout, pdwResult);
1217     if (dwTimeout != TIMEOUT_ASYNC)
1218     {
1219         WDML_UnQueueTransaction(pConv, pXAct);
1220         WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1221     }
1222
1223     return hDdeData;
1224 }
1225
1226 /*****************************************************************
1227  *            DdeAbandonTransaction (USER32.@)
1228  */
1229 BOOL WINAPI DdeAbandonTransaction(DWORD idInst, HCONV hConv, DWORD idTransaction)
1230 {
1231     WDML_INSTANCE*      pInstance;
1232     WDML_CONV*          pConv;
1233     WDML_XACT*          pXAct;
1234
1235     if ((pInstance = WDML_GetInstance(idInst)))
1236     {
1237         if (hConv)
1238         {
1239             if ((pConv = WDML_GetConv(hConv, TRUE)) && pConv->instance == pInstance)
1240             {
1241                 for (pXAct = pConv->transactions; pXAct; pXAct = pXAct->next)
1242                 {
1243                     if (pXAct->dwTimeout == TIMEOUT_ASYNC &&
1244                         (idTransaction == 0 || pXAct->xActID == idTransaction))
1245                     {
1246                         WDML_UnQueueTransaction(pConv, pXAct);
1247                         WDML_FreeTransaction(pInstance, pXAct, TRUE);
1248                     }
1249                 }
1250             }
1251         }
1252         else
1253         {
1254             for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv; pConv = pConv->next)
1255             {
1256                 if (!(pConv->wStatus & ST_CONNECTED)) continue;
1257                 for (pXAct = pConv->transactions; pXAct; pXAct = pXAct->next)
1258                 {
1259                     if (pXAct->dwTimeout == TIMEOUT_ASYNC)
1260                     {
1261                         WDML_UnQueueTransaction(pConv, pXAct);
1262                         WDML_FreeTransaction(pInstance, pXAct, TRUE);
1263                     }
1264                 }
1265             }
1266         }
1267     }
1268
1269     return TRUE;
1270 }
1271
1272 /******************************************************************
1273  *              WDML_ClientProc
1274  *
1275  * Window Proc created on client side for each conversation
1276  */
1277 static LRESULT CALLBACK WDML_ClientProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
1278 {
1279     UINT        uiLo, uiHi;
1280     WDML_CONV*  pConv = NULL;
1281     HSZ         hszSrv, hszTpc;
1282
1283     TRACE("%p %04x %08lx %08lx\n", hwnd, iMsg, wParam , lParam);
1284
1285     if (iMsg == WM_DDE_ACK &&
1286         /* in the initial WM_INITIATE sendmessage */
1287         ((pConv = WDML_GetConvFromWnd(hwnd)) == NULL || pConv->wStatus == XST_INIT1))
1288     {
1289         /* In response to WM_DDE_INITIATE, save server window  */
1290         char            buf[256];
1291         WDML_INSTANCE*  pInstance;
1292
1293         /* note: sent messages do not need packing */
1294         uiLo = LOWORD(lParam);
1295         uiHi = HIWORD(lParam);
1296
1297         /* FIXME: convlist should be handled here */
1298         if (pConv)
1299         {
1300             /* we already have started the conv with a server, drop other replies */
1301             GlobalDeleteAtom(uiLo);
1302             GlobalDeleteAtom(uiHi);
1303             PostMessageW((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)hwnd, 0);
1304             return 0;
1305         }
1306
1307         pInstance = WDML_GetInstanceFromWnd(hwnd);
1308
1309         hszSrv = WDML_MakeHszFromAtom(pInstance, uiLo);
1310         hszTpc = WDML_MakeHszFromAtom(pInstance, uiHi);
1311
1312         pConv = WDML_AddConv(pInstance, WDML_CLIENT_SIDE, hszSrv, hszTpc, hwnd, (HWND)wParam);
1313
1314         SetWindowLongPtrW(hwnd, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
1315         pConv->wStatus |= ST_CONNECTED;
1316         pConv->wConvst = XST_INIT1;
1317
1318         /* check if server is handled by DDEML */
1319         if ((GetClassNameA((HWND)wParam, buf, sizeof(buf)) &&
1320              lstrcmpiA(buf, WDML_szServerConvClassA) == 0) ||
1321             (GetClassNameW((HWND)wParam, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
1322              lstrcmpiW((LPWSTR)buf, WDML_szServerConvClassW) == 0))
1323         {
1324             pConv->wStatus |= ST_ISLOCAL;
1325         }
1326
1327         WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_CONNECT_CONFIRM, (WPARAM)hwnd, wParam);
1328
1329         GlobalDeleteAtom(uiLo);
1330         GlobalDeleteAtom(uiHi);
1331
1332         /* accept conversation */
1333         return 1;
1334     }
1335
1336     if (iMsg >= WM_DDE_FIRST && iMsg <= WM_DDE_LAST)
1337     {
1338         pConv = WDML_GetConvFromWnd(hwnd);
1339
1340         if (pConv)
1341         {
1342             MSG         msg;
1343             HDDEDATA    hdd;
1344
1345             msg.hwnd = hwnd;
1346             msg.message = iMsg;
1347             msg.wParam = wParam;
1348             msg.lParam = lParam;
1349
1350             WDML_HandleReply(pConv, &msg, &hdd, NULL);
1351         }
1352
1353         return 0;
1354     }
1355
1356     return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, iMsg, wParam, lParam) :
1357                                    DefWindowProcA(hwnd, iMsg, wParam, lParam);
1358 }
1359
1360 /*****************************************************************
1361  *            DdeDisconnect   (USER32.@)
1362  */
1363 BOOL WINAPI DdeDisconnect(HCONV hConv)
1364 {
1365     WDML_CONV*  pConv = NULL;
1366     WDML_XACT*  pXAct;
1367     BOOL        ret = FALSE;
1368
1369     TRACE("(%p)\n", hConv);
1370
1371     if (hConv == 0)
1372     {
1373         WARN("DdeDisconnect(): hConv = 0\n");
1374         return FALSE;
1375     }
1376
1377     pConv = WDML_GetConv(hConv, TRUE);
1378     if (pConv != NULL)
1379     {
1380         if (pConv->wStatus & ST_CLIENT)
1381         {
1382             /* FIXME: should abandon all pending transactions */
1383             pXAct = WDML_ClientQueueTerminate(pConv);
1384             if (pXAct != NULL)
1385             {
1386                 if (PostMessageW(pConv->hwndServer, pXAct->ddeMsg,
1387                                  (WPARAM)pConv->hwndClient, pXAct->lParam))
1388                 {
1389                     WDML_SyncWaitTransactionReply(hConv, 10000, pXAct, NULL);
1390                     ret = TRUE;
1391                 }
1392                 else
1393                     pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
1394
1395                 WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1396                 /* still have to destroy data associated with conversation */
1397                 WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
1398             }
1399             else
1400             {
1401                 FIXME("Not implemented yet for a server side conversation\n");
1402             }
1403         }
1404     }
1405
1406     return ret;
1407 }
1408
1409 /*****************************************************************
1410  *            DdeImpersonateClient (USER32.@)
1411  */
1412 BOOL WINAPI DdeImpersonateClient(HCONV hConv)
1413 {
1414     WDML_CONV*  pConv;
1415     BOOL        ret = FALSE;
1416
1417     TRACE("(%p)\n", hConv);
1418
1419     pConv = WDML_GetConv(hConv, TRUE);
1420     if (pConv)
1421     {
1422         ret = ImpersonateDdeClientWindow(pConv->hwndClient, pConv->hwndServer);
1423     }
1424     return ret;
1425 }