gdi32: Let user32 specify the device rectangle when setting the visible region.
[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, 0, 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) != 0;
325     pDdeAdvise->fDeferUpd = (wType & XTYPF_NODATA) != 0;
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(pConv, (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     if (pData == NULL)
636     {
637         if (cbData == (DWORD)-1)
638             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
639         else
640             pConv->instance->lastError = DMLERR_MEMORY_ERROR;
641         return NULL;
642     }
643
644     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
645     if (!pXAct)
646         return NULL;
647
648     if (cbData == (DWORD)-1)
649     {
650         HDDEDATA        hDdeData = pData;
651
652         pData = DdeAccessData(hDdeData, &cbData);
653         if (pData)
654         {
655             pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
656             DdeUnaccessData(hDdeData);
657         }
658     }
659     else
660     {
661         pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
662     }
663
664     pXAct->lParam = (LPARAM)pXAct->hMem;
665
666     return pXAct;
667 }
668
669 /******************************************************************
670  *              WDML_HandleExecuteReply
671  *
672  *
673  */
674 static WDML_QUEUE_STATE WDML_HandleExecuteReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
675 {
676     DDEACK      ddeAck;
677     UINT_PTR    uiLo, uiHi;
678
679     if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
680     {
681         return WDML_QS_PASS;
682     }
683
684     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
685     FreeDDElParam(WM_DDE_ACK, msg->lParam);
686
687     if ((HANDLE)uiHi != pXAct->hMem)
688     {
689         return WDML_QS_PASS;
690     }
691
692     if (ack) *ack = uiLo;
693     WDML_ExtractAck(uiLo, &ddeAck);
694     pXAct->hDdeData = (HDDEDATA)(UINT_PTR)ddeAck.fAck;
695
696     TRACE("hDdeData = %p\n", pXAct->hDdeData);
697     pConv->instance->lastError = (pXAct->hDdeData != 0) ? DMLERR_NO_ERROR : DMLERR_NOTPROCESSED;
698
699     return WDML_QS_HANDLED;
700 }
701
702 /******************************************************************
703  *              WDML_ClientQueuePoke
704  *
705  *
706  */
707 static WDML_XACT*       WDML_ClientQueuePoke(WDML_CONV* pConv, LPVOID pData, DWORD cbData,
708                                              UINT wFmt, HSZ hszItem)
709 {
710     DDE_DATAHANDLE_HEAD *dh;
711     WDML_XACT *pXAct;
712     DDEPOKE *ddePoke;
713     HGLOBAL hglobal;
714     ATOM atom;
715
716     TRACE("XTYP_POKE transaction\n");
717
718     atom = WDML_MakeAtomFromHsz(hszItem);
719     if (!atom) return NULL;
720
721     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE, wFmt, hszItem);
722     if (!pXAct)
723     {
724         GlobalDeleteAtom(atom);
725         return NULL;
726     }
727
728     if (cbData == (DWORD)-1)
729     {
730         hglobal = pData;
731         dh = GlobalLock(hglobal);
732         cbData = GlobalSize(hglobal) - sizeof(DDE_DATAHANDLE_HEAD);
733         pData = dh + 1;
734         GlobalUnlock(hglobal);
735     }
736
737     pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, FIELD_OFFSET(DDEPOKE, Value[cbData]));
738     ddePoke = GlobalLock(pXAct->hMem);
739     if (!ddePoke)
740     {
741         pConv->instance->lastError = DMLERR_MEMORY_ERROR;
742         return NULL;
743     }
744
745     ddePoke->unused = 0;
746     ddePoke->fRelease = TRUE;
747     ddePoke->cfFormat = wFmt;
748     memcpy(ddePoke->Value, pData, cbData);
749     GlobalUnlock(pXAct->hMem);
750
751     pXAct->lParam = PackDDElParam(WM_DDE_POKE, (UINT_PTR)pXAct->hMem, atom);
752
753     return pXAct;
754 }
755
756 /******************************************************************
757  *              WDML_HandlePokeReply
758  *
759  *
760  */
761 static WDML_QUEUE_STATE WDML_HandlePokeReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct, DWORD *ack)
762 {
763     UINT_PTR    uiLo, uiHi;
764     HSZ         hsz;
765
766     if (msg->message != WM_DDE_ACK && WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
767     {
768         return WDML_QS_PASS;
769     }
770
771     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
772     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
773     if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
774     {
775         return WDML_QS_PASS;
776     }
777     FreeDDElParam(WM_DDE_ACK, msg->lParam);
778     GlobalDeleteAtom(uiHi);
779
780     if (ack) *ack = uiLo;
781     GlobalFree(pXAct->hMem);
782
783     pXAct->hDdeData = (HDDEDATA)TRUE;
784     return TRUE;
785 }
786
787 /******************************************************************
788  *              WDML_ClientQueueTerminate
789  *
790  * Creates and queue an WM_DDE_TERMINATE transaction
791  */
792 static WDML_XACT*       WDML_ClientQueueTerminate(WDML_CONV* pConv)
793 {
794     WDML_XACT*          pXAct;
795
796     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
797     if (!pXAct)
798         return NULL;
799
800     pXAct->lParam = 0;
801     pConv->wStatus &= ~ST_CONNECTED;
802
803     return pXAct;
804 }
805
806 /******************************************************************
807  *              WDML_HandleTerminateReply
808  *
809  * handles the reply to a terminate request
810  */
811 static WDML_QUEUE_STATE WDML_HandleTerminateReply(WDML_CONV* pConv, MSG* msg)
812 {
813     if (msg->message != WM_DDE_TERMINATE)
814     {
815         /* FIXME: should delete data passed here */
816         return WDML_QS_SWALLOWED;
817     }
818
819     if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
820     {
821         FIXME("hmmm shouldn't happen\n");
822         return WDML_QS_PASS;
823     }
824     if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
825     {
826         WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
827                             0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
828     }
829     WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
830     return WDML_QS_HANDLED;
831 }
832
833 /******************************************************************
834  *              WDML_HandleIncomingData
835  *
836  *
837  */
838 static WDML_QUEUE_STATE WDML_HandleIncomingData(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
839 {
840     UINT_PTR            uiLo, uiHi;
841     HDDEDATA            hDdeDataIn, hDdeDataOut;
842     WDML_LINK*          pLink;
843     WINE_DDEHEAD        wdh;
844     HSZ                 hsz;
845
846     TRACE("WM_DDE_DATA message received in the Client Proc!\n");
847     /* wParam -- sending window handle  */
848     /* lParam -- hDdeData & item HSZ    */
849
850     UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
851     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
852
853     hDdeDataIn = WDML_Global2DataHandle(pConv, (HGLOBAL)uiLo, &wdh);
854
855     /* billx:
856      *  For hot link, data should be passed to its callback with
857      * XTYP_ADVDATA and callback should return the proper status.
858      */
859     pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE, hsz,
860                           uiLo != 0, wdh.cfFormat);
861     if (!pLink)
862     {
863         WDML_DecHSZ(pConv->instance, hsz);
864         DdeFreeDataHandle(hDdeDataIn);
865         return WDML_QS_PASS;
866     }
867
868     if (hDdeDataIn != 0 && wdh.fAckReq)
869     {
870         WDML_PostAck(pConv, WDML_CLIENT_SIDE, 0, FALSE, TRUE, uiHi, msg->lParam, WM_DDE_DATA);
871         if (msg->lParam)
872             msg->lParam = 0;
873     }
874     else
875     {
876         GlobalDeleteAtom(uiHi);
877     }
878
879     hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_ADVDATA, pLink->uFmt, pLink->hConv,
880                                       pConv->hszTopic, pLink->hszItem, hDdeDataIn, 0, 0);
881
882     if (hDdeDataOut != (HDDEDATA)DDE_FACK || wdh.fRelease)
883     {
884         if (uiLo) GlobalFree((HANDLE)uiLo);
885     }
886
887     DdeFreeDataHandle(hDdeDataIn);
888
889     WDML_DecHSZ(pConv->instance, hsz);
890     if (msg->lParam)
891         FreeDDElParam(WM_DDE_DATA, msg->lParam);
892
893     return WDML_QS_HANDLED;
894 }
895
896 /******************************************************************
897  *              WDML_HandleIncomingTerminate
898  *
899  *
900  */
901 static WDML_QUEUE_STATE WDML_HandleIncomingTerminate(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
902 {
903     if (pConv->hwndServer != WIN_GetFullHandle((HWND)msg->wParam))
904         return WDML_QS_PASS;
905
906     pConv->wStatus |= ST_TERMINATED;
907     if (pConv->wStatus & ST_CONNECTED)
908     {
909         /* don't care about result code (if server exists or not) */
910         PostMessageW(pConv->hwndServer, WM_DDE_TERMINATE, (WPARAM)pConv->hwndClient, 0L);
911         pConv->wStatus &= ~ST_CONNECTED;
912     }
913     /* have to keep connection around to allow reconnection */
914     return WDML_QS_HANDLED;
915 }
916
917 /******************************************************************
918  *              WDML_HandleReply
919  *
920  * handles any incoming reply, and try to match to an already sent request
921  */
922 static WDML_QUEUE_STATE WDML_HandleReply(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd, DWORD *ack)
923 {
924     WDML_XACT*          pXAct = pConv->transactions;
925     WDML_QUEUE_STATE    qs;
926
927     if (pConv->transactions)
928     {
929         if (ack) *ack = DDE_FNOTPROCESSED;
930         /* first check message against a pending transaction, if any */
931         switch (pXAct->ddeMsg)
932         {
933         case WM_DDE_ADVISE:
934             qs = WDML_HandleAdviseReply(pConv, msg, pXAct, ack);
935             break;
936         case WM_DDE_UNADVISE:
937             qs = WDML_HandleUnadviseReply(pConv, msg, pXAct, ack);
938             break;
939         case WM_DDE_EXECUTE:
940             qs = WDML_HandleExecuteReply(pConv, msg, pXAct, ack);
941             break;
942         case WM_DDE_REQUEST:
943             qs = WDML_HandleRequestReply(pConv, msg, pXAct, ack);
944             break;
945         case WM_DDE_POKE:
946             qs = WDML_HandlePokeReply(pConv, msg, pXAct, ack);
947             break;
948         case WM_DDE_TERMINATE:
949             qs = WDML_HandleTerminateReply(pConv, msg);
950             break;
951         default:
952             qs = WDML_QS_ERROR;
953             FIXME("oooch\n");
954         }
955     }
956     else
957     {
958         qs = WDML_QS_PASS;
959     }
960
961     /* now check the results */
962     switch (qs)
963     {
964     case WDML_QS_ERROR:
965     case WDML_QS_SWALLOWED:
966         *hdd = 0;
967         break;
968     case WDML_QS_HANDLED:
969         /* ok, we have resolved a pending transaction
970          * notify callback if asynchronous.
971          */
972         if (pXAct->dwTimeout == TIMEOUT_ASYNC && pXAct->ddeMsg != WM_DDE_TERMINATE)
973         {
974             WDML_InvokeCallback(pConv->instance, XTYP_XACT_COMPLETE, pXAct->wFmt,
975                                 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
976                                 pXAct->hDdeData, MAKELONG(0, pXAct->xActID), 0 /* FIXME */);
977             qs = WDML_QS_PASS;
978         }
979         else
980         {
981             *hdd = pXAct->hDdeData;
982         }
983         break;
984     case WDML_QS_PASS:
985         /* no pending transaction found, try a warm/hot link or a termination request */
986         switch (msg->message)
987         {
988         case WM_DDE_DATA:
989             qs = WDML_HandleIncomingData(pConv, msg, hdd);
990             break;
991         case WM_DDE_TERMINATE:
992             qs = WDML_HandleIncomingTerminate(pConv, msg, hdd);
993             break;
994         case WM_DDE_ACK:
995             /* This happens at end of DdeClientTransaction XTYP_EXECUTE
996              * Without this assignment, DdeClientTransaction's return value is undefined
997              */
998             *hdd = (HDDEDATA)TRUE;
999             if (ack)
1000                 *ack = DDE_FACK;
1001             break;
1002         }
1003         break;
1004     case WDML_QS_BLOCK:
1005         FIXME("shouldn't be used on client side\n");
1006         break;
1007     }
1008
1009     return qs;
1010 }
1011
1012 /******************************************************************
1013  *              WDML_SyncWaitTransactionReply
1014  *
1015  * waits until an answer for a sent request is received
1016  * time out is also handled. only used for synchronous transactions
1017  */
1018 static HDDEDATA WDML_SyncWaitTransactionReply(HCONV hConv, DWORD dwTimeout, const WDML_XACT* pXAct, DWORD *ack)
1019 {
1020     DWORD       dwTime;
1021     DWORD       err;
1022     WDML_CONV*  pConv;
1023
1024     TRACE("Starting wait for a timeout of %d ms\n", dwTimeout);
1025
1026     /* FIXME: time 32 bit wrap around */
1027     dwTimeout += GetCurrentTime();
1028
1029     while ((dwTime = GetCurrentTime()) < dwTimeout)
1030     {
1031         /* we cannot be in the crit sect all the time because when client and server run in a
1032          * single process they need to share the access to the internal data
1033          */
1034         if (MsgWaitForMultipleObjects(0, NULL, FALSE,
1035                                       dwTimeout - dwTime, QS_POSTMESSAGE) == WAIT_OBJECT_0)
1036         {
1037             MSG         msg;
1038
1039             while (PeekMessageW(&msg, 0, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE))
1040             {
1041                 HDDEDATA hdd = NULL;
1042
1043                 pConv = WDML_GetConv(hConv, FALSE);
1044                 if (pConv == NULL)
1045                 {
1046                     /* conversation no longer available... return failure */
1047                     return 0;
1048                 }
1049                 if (msg.hwnd == pConv->hwndClient)
1050                 {
1051                     /* check that either pXAct has been processed or no more xActions are pending */
1052                     BOOL ret = (pConv->transactions == pXAct);
1053                     if (WDML_HandleReply(pConv, &msg, &hdd, ack) == WDML_QS_HANDLED)
1054                     {
1055                         TRACE("WDML_HandleReply returned WDML_QS_HANDLED\n");
1056                         ret = TRUE;
1057                     }
1058                     else
1059                         ret = (pConv->transactions == NULL || ret);
1060
1061                     if (ret)
1062                     {
1063                         pConv->instance->lastError = hdd ? DMLERR_NO_ERROR : DMLERR_NOTPROCESSED;
1064                         return hdd;
1065                     }
1066                 }
1067                 else
1068                 {
1069                     DispatchMessageW(&msg);
1070                 }
1071             }
1072         }
1073     }
1074
1075     TRACE("Timeout !!\n");
1076
1077     pConv = WDML_GetConv(hConv, FALSE);
1078     if (pConv != NULL)
1079     {
1080         if (pConv->transactions)
1081         {
1082             switch (pConv->transactions->ddeMsg)
1083             {
1084             case WM_DDE_ADVISE:         err = DMLERR_ADVACKTIMEOUT;     break;
1085             case WM_DDE_REQUEST:        err = DMLERR_DATAACKTIMEOUT;    break;
1086             case WM_DDE_EXECUTE:        err = DMLERR_EXECACKTIMEOUT;    break;
1087             case WM_DDE_POKE:           err = DMLERR_POKEACKTIMEOUT;    break;
1088             case WM_DDE_UNADVISE:       err = DMLERR_UNADVACKTIMEOUT;   break;
1089             default:                    err = DMLERR_INVALIDPARAMETER;  break;
1090             }
1091
1092             pConv->instance->lastError = err;
1093         }
1094     }
1095
1096     return 0;
1097 }
1098
1099
1100 /*****************************************************************
1101  *            WDML_ClientHandle
1102  */
1103 HDDEDATA WDML_ClientHandle(WDML_CONV *pConv, WDML_XACT *pXAct, DWORD dwTimeout, LPDWORD pdwResult)
1104 {
1105     HDDEDATA hDdeData;
1106
1107     if (!PostMessageW(pConv->hwndServer, pXAct->ddeMsg, (WPARAM)pConv->hwndClient, pXAct->lParam))
1108     {
1109         WARN("Failed posting message %x to %p (error=0x%x)\n",
1110               pXAct->ddeMsg, pConv->hwndServer, GetLastError());
1111         pConv->wStatus &= ~ST_CONNECTED;
1112         pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
1113         return 0;
1114     }
1115     pXAct->dwTimeout = dwTimeout;
1116     /* FIXME: should set the app bits on *pdwResult */
1117
1118     if (dwTimeout == TIMEOUT_ASYNC)
1119     {
1120         if (pdwResult)
1121             *pdwResult = MAKELONG(0, pXAct->xActID);
1122
1123         hDdeData = (HDDEDATA)1;
1124     }
1125     else
1126         hDdeData = WDML_SyncWaitTransactionReply((HCONV)pConv, dwTimeout, pXAct, pdwResult);
1127
1128     return hDdeData;
1129 }
1130
1131
1132 /*****************************************************************
1133  *            DdeClientTransaction  (USER32.@)
1134  */
1135 HDDEDATA WINAPI DdeClientTransaction(LPBYTE pData, DWORD cbData, HCONV hConv, HSZ hszItem, UINT wFmt,
1136                                      UINT wType, DWORD dwTimeout, LPDWORD pdwResult)
1137 {
1138     WDML_CONV*          pConv;
1139     WDML_XACT*          pXAct;
1140     HDDEDATA            hDdeData = 0;
1141
1142     TRACE("(%p,%d,%p,%p,%x,%x,%d,%p)\n",
1143           pData, cbData, hConv, hszItem, wFmt, wType, dwTimeout, pdwResult);
1144
1145     if (hConv == 0)
1146     {
1147         WARN("Invalid conversation handle NULL\n");
1148         return 0;
1149     }
1150
1151     pConv = WDML_GetConv(hConv, TRUE);
1152     if (pConv == NULL)
1153     {
1154         /* cannot set error... cannot get back to DDE instance */
1155         return 0;
1156     }
1157
1158     switch (wType)
1159     {
1160     case XTYP_EXECUTE:
1161     /* Windows simply ignores hszItem and wFmt in this case */
1162         pXAct = WDML_ClientQueueExecute(pConv, pData, cbData);
1163         if (pXAct == NULL)
1164             return 0;
1165         break;
1166     case XTYP_POKE:
1167         if (!hszItem)
1168         {
1169             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1170             return 0;
1171         }
1172         pXAct = WDML_ClientQueuePoke(pConv, pData, cbData, wFmt, hszItem);
1173         break;
1174     case XTYP_ADVSTART|XTYPF_NODATA:
1175     case XTYP_ADVSTART|XTYPF_NODATA|XTYPF_ACKREQ:
1176     case XTYP_ADVSTART:
1177     case XTYP_ADVSTART|XTYPF_ACKREQ:
1178         if (pData)
1179         {
1180             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1181             return 0;
1182         }
1183         pXAct = WDML_ClientQueueAdvise(pConv, wType, wFmt, hszItem);
1184         break;
1185     case XTYP_ADVSTOP:
1186         if (pData)
1187         {
1188             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1189             return 0;
1190         }
1191         pXAct = WDML_ClientQueueUnadvise(pConv, wFmt, hszItem);
1192         break;
1193     case XTYP_REQUEST:
1194         if (pData || !hszItem)
1195         {
1196             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1197             return 0;
1198         }
1199         pXAct = WDML_ClientQueueRequest(pConv, wFmt, hszItem);
1200         break;
1201     default:
1202         FIXME("Unknown transaction type %04x\n", wType);
1203         /* unknown transaction type */
1204         pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1205         return 0;
1206     }
1207
1208     if (pXAct == NULL)
1209     {
1210         pConv->instance->lastError = DMLERR_MEMORY_ERROR;
1211         return 0;
1212     }
1213
1214     WDML_QueueTransaction(pConv, pXAct);
1215
1216     TRACE("pConv->wStatus %04x\n", pConv->wStatus);
1217
1218     if (pConv->wStatus & ST_BLOCKED)
1219     {
1220         TRACE("Transactions are blocked, add to the queue and exit\n");
1221         return (HDDEDATA)1;
1222     }
1223
1224     hDdeData = WDML_ClientHandle(pConv, pXAct, dwTimeout, pdwResult);
1225     if (dwTimeout != TIMEOUT_ASYNC)
1226     {
1227         WDML_UnQueueTransaction(pConv, pXAct);
1228         WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1229     }
1230
1231     return hDdeData;
1232 }
1233
1234 /*****************************************************************
1235  *            DdeAbandonTransaction (USER32.@)
1236  */
1237 BOOL WINAPI DdeAbandonTransaction(DWORD idInst, HCONV hConv, DWORD idTransaction)
1238 {
1239     WDML_INSTANCE*      pInstance;
1240     WDML_CONV*          pConv;
1241     WDML_XACT*          pXAct;
1242
1243     if ((pInstance = WDML_GetInstance(idInst)))
1244     {
1245         if (hConv)
1246         {
1247             if ((pConv = WDML_GetConv(hConv, TRUE)) && pConv->instance == pInstance)
1248             {
1249
1250                 pXAct = pConv->transactions;
1251                 while (pXAct) {
1252                     WDML_XACT *nextXAct = pXAct->next;
1253
1254                     if (pXAct->dwTimeout == TIMEOUT_ASYNC &&
1255                         (idTransaction == 0 || pXAct->xActID == idTransaction))
1256                     {
1257                         WDML_UnQueueTransaction(pConv, pXAct);
1258                         WDML_FreeTransaction(pInstance, pXAct, TRUE);
1259                     }
1260                     pXAct = nextXAct;
1261                 }
1262             }
1263         }
1264         else
1265         {
1266             for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv; pConv = pConv->next)
1267             {
1268                 if (!(pConv->wStatus & ST_CONNECTED)) continue;
1269                 pXAct = pConv->transactions;
1270                 while (pXAct) {
1271                     WDML_XACT *nextXAct = pXAct->next;
1272
1273                     if (pXAct->dwTimeout == TIMEOUT_ASYNC)
1274                     {
1275                         WDML_UnQueueTransaction(pConv, pXAct);
1276                         WDML_FreeTransaction(pInstance, pXAct, TRUE);
1277                     }
1278                     pXAct = nextXAct;
1279                 }
1280             }
1281         }
1282     }
1283
1284     return TRUE;
1285 }
1286
1287 /******************************************************************
1288  *              WDML_ClientProc
1289  *
1290  * Window Proc created on client side for each conversation
1291  */
1292 static LRESULT CALLBACK WDML_ClientProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
1293 {
1294     UINT        uiLo, uiHi;
1295     WDML_CONV*  pConv = NULL;
1296     HSZ         hszSrv, hszTpc;
1297
1298     TRACE("%p %04x %08lx %08lx\n", hwnd, iMsg, wParam , lParam);
1299
1300     if (iMsg == WM_DDE_ACK &&
1301         /* in the initial WM_INITIATE sendmessage */
1302         ((pConv = WDML_GetConvFromWnd(hwnd)) == NULL || pConv->wStatus == XST_INIT1))
1303     {
1304         /* In response to WM_DDE_INITIATE, save server window  */
1305         char            buf[256];
1306         WDML_INSTANCE*  pInstance;
1307
1308         /* note: sent messages do not need packing */
1309         uiLo = LOWORD(lParam);
1310         uiHi = HIWORD(lParam);
1311
1312         /* FIXME: convlist should be handled here */
1313         if (pConv)
1314         {
1315             /* we already have started the conv with a server, drop other replies */
1316             GlobalDeleteAtom(uiLo);
1317             GlobalDeleteAtom(uiHi);
1318             PostMessageW((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)hwnd, 0);
1319             return 0;
1320         }
1321
1322         pInstance = WDML_GetInstanceFromWnd(hwnd);
1323
1324         hszSrv = WDML_MakeHszFromAtom(pInstance, uiLo);
1325         hszTpc = WDML_MakeHszFromAtom(pInstance, uiHi);
1326
1327         pConv = WDML_AddConv(pInstance, WDML_CLIENT_SIDE, hszSrv, hszTpc, hwnd, (HWND)wParam);
1328
1329         SetWindowLongPtrW(hwnd, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
1330         pConv->wStatus |= ST_CONNECTED;
1331         pConv->wConvst = XST_INIT1;
1332
1333         /* check if server is handled by DDEML */
1334         if ((GetClassNameA((HWND)wParam, buf, sizeof(buf)) &&
1335              lstrcmpiA(buf, WDML_szServerConvClassA) == 0) ||
1336             (GetClassNameW((HWND)wParam, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
1337              lstrcmpiW((LPWSTR)buf, WDML_szServerConvClassW) == 0))
1338         {
1339             pConv->wStatus |= ST_ISLOCAL;
1340         }
1341
1342         GlobalDeleteAtom(uiLo);
1343         GlobalDeleteAtom(uiHi);
1344
1345         /* accept conversation */
1346         return 1;
1347     }
1348
1349     if (iMsg >= WM_DDE_FIRST && iMsg <= WM_DDE_LAST)
1350     {
1351         pConv = WDML_GetConvFromWnd(hwnd);
1352
1353         if (pConv)
1354         {
1355             MSG         msg;
1356             HDDEDATA    hdd;
1357
1358             msg.hwnd = hwnd;
1359             msg.message = iMsg;
1360             msg.wParam = wParam;
1361             msg.lParam = lParam;
1362
1363             WDML_HandleReply(pConv, &msg, &hdd, NULL);
1364         }
1365
1366         return 0;
1367     }
1368
1369     return IsWindowUnicode(hwnd) ? DefWindowProcW(hwnd, iMsg, wParam, lParam) :
1370                                    DefWindowProcA(hwnd, iMsg, wParam, lParam);
1371 }
1372
1373 /*****************************************************************
1374  *            DdeDisconnect   (USER32.@)
1375  */
1376 BOOL WINAPI DdeDisconnect(HCONV hConv)
1377 {
1378     WDML_CONV*  pConv = NULL;
1379     WDML_XACT*  pXAct;
1380     BOOL        ret = FALSE;
1381
1382     TRACE("(%p)\n", hConv);
1383
1384     if (hConv == 0)
1385     {
1386         WARN("DdeDisconnect(): hConv = 0\n");
1387         return FALSE;
1388     }
1389
1390     pConv = WDML_GetConv(hConv, TRUE);
1391     if (pConv != NULL)
1392     {
1393         if (pConv->wStatus & ST_CLIENT)
1394         {
1395             /* FIXME: should abandon all pending transactions */
1396             pXAct = WDML_ClientQueueTerminate(pConv);
1397             if (pXAct != NULL)
1398             {
1399                 if (PostMessageW(pConv->hwndServer, pXAct->ddeMsg,
1400                                  (WPARAM)pConv->hwndClient, pXAct->lParam))
1401                 {
1402                     WDML_SyncWaitTransactionReply(hConv, 10000, pXAct, NULL);
1403                     ret = TRUE;
1404                 }
1405                 else
1406                     pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
1407
1408                 WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1409                 /* still have to destroy data associated with conversation */
1410                 WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
1411             }
1412             else
1413             {
1414                 FIXME("Not implemented yet for a server side conversation\n");
1415             }
1416         }
1417     }
1418
1419     return ret;
1420 }
1421
1422 /*****************************************************************
1423  *            DdeImpersonateClient (USER32.@)
1424  */
1425 BOOL WINAPI DdeImpersonateClient(HCONV hConv)
1426 {
1427     WDML_CONV*  pConv;
1428     BOOL        ret = FALSE;
1429
1430     TRACE("(%p)\n", hConv);
1431
1432     pConv = WDML_GetConv(hConv, TRUE);
1433     if (pConv)
1434     {
1435         ret = ImpersonateDdeClientWindow(pConv->hwndClient, pConv->hwndServer);
1436     }
1437     return ret;
1438 }