git.oblomov.eu Git - wine/blob - dlls/user/dde/client.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * DDEML library
   5  *
   6  * Copyright 1997 Alexandre Julliard
   7  * Copyright 1997 Len White
   8  * Copyright 1999 Keith Matthews
   9  * Copyright 2000 Corel
  10  * Copyright 2001 Eric Pouech
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27 #include <string.h>
  28 #include "winbase.h"
  29 #include "windef.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "winerror.h"
  33 #include "winnls.h"
  34 #include "dde.h"
  35 #include "ddeml.h"
  36 #include "win.h"
  37 #include "wine/debug.h"
  38 #include "dde/dde_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
  41
  42 static LRESULT CALLBACK WDML_ClientProc(HWND, UINT, WPARAM, LPARAM);    /* only for one client, not conv list */
  43 const char  WDML_szClientConvClassA[] = "DdeClientAnsi";
  44 const WCHAR WDML_szClientConvClassW[] = {'D','d','e','C','l','i','e','n','t','U','n','i','c','o','d','e',0};
  45
  46 /******************************************************************************
  47  * DdeConnectList [USER32.@]  Establishes conversation with DDE servers
  48  *
  49  * PARAMS
  50  *    idInst     [I] Instance identifier
  51  *    hszService [I] Handle to service name string
  52  *    hszTopic   [I] Handle to topic name string
  53  *    hConvList  [I] Handle to conversation list
  54  *    pCC        [I] Pointer to structure with context data
  55  *
  56  * RETURNS
  57  *    Success: Handle to new conversation list
  58  *    Failure: 0
  59  */
  60 HCONVLIST WINAPI DdeConnectList(DWORD idInst, HSZ hszService, HSZ hszTopic,
  61                                 HCONVLIST hConvList, PCONVCONTEXT pCC)
  62 {
  63     FIXME("(%ld,%p,%p,%p,%p): stub\n", idInst, hszService, hszTopic, hConvList, pCC);
  64     return (HCONVLIST)1;
  65 }
  66
  67 /*****************************************************************
  68  * DdeQueryNextServer [USER32.@]
  69  */
  70 HCONV WINAPI DdeQueryNextServer(HCONVLIST hConvList, HCONV hConvPrev)
  71 {
  72     FIXME("(%p,%p): stub\n", hConvList, hConvPrev);
  73     return 0;
  74 }
  75
  76 /******************************************************************************
  77  * DdeDisconnectList [USER32.@]  Destroys list and terminates conversations
  78  *
  79  *
  80  * PARAMS
  81  *    hConvList  [I] Handle to conversation list
  82  *
  83  * RETURNS
  84  *    Success: TRUE
  85  *    Failure: FALSE
  86  */
  87 BOOL WINAPI DdeDisconnectList(HCONVLIST hConvList)
  88 {
  89     FIXME("(%p): stub\n", hConvList);
  90     return TRUE;
  91 }
  92
  93 /*****************************************************************
  94  *            DdeConnect   (USER32.@)
  95  */
  96 HCONV WINAPI DdeConnect(DWORD idInst, HSZ hszService, HSZ hszTopic,
  97                         PCONVCONTEXT pCC)
  98 {
  99     HWND                hwndClient;
 100     WDML_INSTANCE*      pInstance;
 101     WDML_CONV*          pConv = NULL;
 102     ATOM                aSrv = 0, aTpc = 0;
 103
 104     TRACE("(0x%lx,%p,%p,%p)\n", idInst, hszService, hszTopic, pCC);
 105
 106     EnterCriticalSection(&WDML_CritSect);
 107
 108     pInstance = WDML_GetInstance(idInst);
 109     if (!pInstance)
 110     {
 111         goto theEnd;
 112     }
 113
 114     /* make sure this conv is never created */
 115     pConv = WDML_FindConv(pInstance, WDML_CLIENT_SIDE, hszService, hszTopic);
 116     if (pConv != NULL)
 117     {
 118         ERR("This Conv already exists: (0x%lx)\n", (DWORD)pConv);
 119         goto theEnd;
 120     }
 121
 122     /* we need to establish a conversation with
 123        server, so create a window for it       */
 124
 125     if (pInstance->unicode)
 126     {
 127         WNDCLASSEXW     wndclass;
 128
 129         wndclass.cbSize        = sizeof(wndclass);
 130         wndclass.style         = 0;
 131         wndclass.lpfnWndProc   = WDML_ClientProc;
 132         wndclass.cbClsExtra    = 0;
 133         wndclass.cbWndExtra    = 2 * sizeof(DWORD);
 134         wndclass.hInstance     = 0;
 135         wndclass.hIcon         = 0;
 136         wndclass.hCursor       = 0;
 137         wndclass.hbrBackground = 0;
 138         wndclass.lpszMenuName  = NULL;
 139         wndclass.lpszClassName = WDML_szClientConvClassW;
 140         wndclass.hIconSm       = 0;
 141
 142         RegisterClassExW(&wndclass);
 143
 144         hwndClient = CreateWindowW(WDML_szClientConvClassW, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
 145     }
 146     else
 147     {
 148         WNDCLASSEXA     wndclass;
 149
 150         wndclass.cbSize        = sizeof(wndclass);
 151         wndclass.style         = 0;
 152         wndclass.lpfnWndProc   = WDML_ClientProc;
 153         wndclass.cbClsExtra    = 0;
 154         wndclass.cbWndExtra    = 2 * sizeof(DWORD);
 155         wndclass.hInstance     = 0;
 156         wndclass.hIcon         = 0;
 157         wndclass.hCursor       = 0;
 158         wndclass.hbrBackground = 0;
 159         wndclass.lpszMenuName  = NULL;
 160         wndclass.lpszClassName = WDML_szClientConvClassA;
 161         wndclass.hIconSm       = 0;
 162
 163         RegisterClassExA(&wndclass);
 164
 165         hwndClient = CreateWindowA(WDML_szClientConvClassA, NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
 166     }
 167
 168     SetWindowLongA(hwndClient, GWL_WDML_INSTANCE, (DWORD)pInstance);
 169
 170     if (hszService)
 171     {
 172         aSrv = WDML_MakeAtomFromHsz(hszService);
 173         if (!aSrv) goto theEnd;
 174     }
 175     if (hszTopic)
 176     {
 177         aTpc = WDML_MakeAtomFromHsz(hszTopic);
 178         if (!aTpc) goto theEnd;
 179     }
 180
 181     LeaveCriticalSection(&WDML_CritSect);
 182
 183     /* note: sent messages shall not use packing */
 184     SendMessageA(HWND_BROADCAST, WM_DDE_INITIATE, (WPARAM)hwndClient, MAKELPARAM(aSrv, aTpc));
 185
 186     EnterCriticalSection(&WDML_CritSect);
 187
 188     pInstance = WDML_GetInstance(idInst);
 189     if (!pInstance)
 190     {
 191         goto theEnd;
 192     }
 193
 194     /* At this point, Client WM_DDE_ACK should have saved hwndServer
 195        for this instance id and hwndClient if server responds.
 196        So get HCONV and return it. And add it to conv list */
 197     pConv = WDML_GetConvFromWnd(hwndClient);
 198     if (pConv == NULL || pConv->hwndServer == 0)
 199     {
 200         ERR("Done with INITIATE, but no Server window available\n");
 201         pConv = NULL;
 202         goto theEnd;
 203     }
 204     TRACE("Connected to Server window (%p)\n", pConv->hwndServer);
 205     pConv->wConvst = XST_CONNECTED;
 206
 207     /* finish init of pConv */
 208     if (pCC != NULL)
 209     {
 210         pConv->convContext = *pCC;
 211     }
 212     else
 213     {
 214         memset(&pConv->convContext, 0, sizeof(pConv->convContext));
 215         pConv->convContext.cb = sizeof(pConv->convContext);
 216         pConv->convContext.iCodePage = (pInstance->unicode) ? CP_WINUNICODE : CP_WINANSI;
 217     }
 218
 219  theEnd:
 220     LeaveCriticalSection(&WDML_CritSect);
 221
 222     if (aSrv) GlobalDeleteAtom(aSrv);
 223     if (aTpc) GlobalDeleteAtom(aTpc);
 224     return (HCONV)pConv;
 225 }
 226
 227 /*****************************************************************
 228  *            DdeReconnect   (DDEML.37)
 229  *            DdeReconnect   (USER32.@)
 230  */
 231 HCONV WINAPI DdeReconnect(HCONV hConv)
 232 {
 233     WDML_CONV*  pConv;
 234     WDML_CONV*  pNewConv = NULL;
 235     ATOM        aSrv = 0, aTpc = 0;
 236
 237     EnterCriticalSection(&WDML_CritSect);
 238     pConv = WDML_GetConv(hConv, FALSE);
 239     if (pConv != NULL && (pConv->wStatus & ST_CLIENT))
 240     {
 241         BOOL    ret;
 242
 243         /* to reestablist a connection, we have to make sure that:
 244          * 1/ pConv is the converstation attached to the client window (it wouldn't be
 245          *    if a call to DdeReconnect would have already been done...)
 246          *    FIXME: is this really an error ???
 247          * 2/ the pConv conversation had really been deconnected
 248          */
 249         if (pConv == WDML_GetConvFromWnd(pConv->hwndClient) &&
 250             (pConv->wStatus & ST_TERMINATED) && !(pConv->wStatus & ST_CONNECTED))
 251         {
 252             HWND        hwndClient = pConv->hwndClient;
 253             HWND        hwndServer = pConv->hwndServer;
 254             ATOM        aSrv, aTpc;
 255
 256             SetWindowLongA(pConv->hwndClient, GWL_WDML_CONVERSATION, 0);
 257
 258             aSrv = WDML_MakeAtomFromHsz(pConv->hszService);
 259             aTpc = WDML_MakeAtomFromHsz(pConv->hszTopic);
 260             if (!aSrv || !aTpc) goto theEnd;
 261
 262             LeaveCriticalSection(&WDML_CritSect);
 263
 264             /* note: sent messages shall not use packing */
 265             ret = SendMessageA(hwndServer, WM_DDE_INITIATE, (WPARAM)hwndClient,
 266                                MAKELPARAM(aSrv, aTpc));
 267
 268             EnterCriticalSection(&WDML_CritSect);
 269
 270             pConv = WDML_GetConv(hConv, FALSE);
 271             if (pConv == NULL)
 272             {
 273                 FIXME("Should fail reconnection\n");
 274                 goto theEnd;
 275             }
 276
 277             if (ret && (pNewConv = WDML_GetConvFromWnd(pConv->hwndClient)) != NULL)
 278             {
 279                 /* re-establish all links... */
 280                 WDML_LINK* pLink;
 281
 282                 for (pLink = pConv->instance->links[WDML_CLIENT_SIDE]; pLink; pLink = pLink->next)
 283                 {
 284                     if (pLink->hConv == hConv)
 285                     {
 286                         /* try to reestablish the links... */
 287                         DdeClientTransaction(NULL, 0, (HCONV)pNewConv, pLink->hszItem, pLink->uFmt,
 288                                              pLink->transactionType, 1000, NULL);
 289                     }
 290                 }
 291             }
 292             else
 293             {
 294                 /* reset the conversation as it was */
 295                 SetWindowLongA(pConv->hwndClient, GWL_WDML_CONVERSATION, (DWORD)pConv);
 296             }
 297         }
 298     }
 299
 300  theEnd:
 301     LeaveCriticalSection(&WDML_CritSect);
 302
 303     if (aSrv) GlobalDeleteAtom(aSrv);
 304     if (aTpc) GlobalDeleteAtom(aTpc);
 305     return (HCONV)pNewConv;
 306 }
 307
 308 /******************************************************************
 309  *              WDML_ClientQueueAdvise
 310  *
 311  * Creates and queue an WM_DDE_ADVISE transaction
 312  */
 313 static WDML_XACT*       WDML_ClientQueueAdvise(WDML_CONV* pConv, UINT wType, UINT wFmt, HSZ hszItem)
 314 {
 315     DDEADVISE*          pDdeAdvise;
 316     WDML_XACT*          pXAct;
 317     ATOM                atom;
 318
 319     TRACE("XTYP_ADVSTART (with%s data) transaction\n", (wType & XTYPF_NODATA) ? "out" : "");
 320
 321     atom = WDML_MakeAtomFromHsz(hszItem);
 322     if (!atom) return NULL;
 323
 324     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE, wFmt, hszItem);
 325     if (!pXAct)
 326     {
 327         GlobalDeleteAtom(atom);
 328         return NULL;
 329     }
 330
 331     pXAct->wType = wType & ~0x0F;
 332     pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, sizeof(DDEADVISE));
 333     /* FIXME: hMem is unfreed for now... should be deleted in server */
 334
 335     /* pack DdeAdvise   */
 336     pDdeAdvise = (DDEADVISE*)GlobalLock(pXAct->hMem);
 337     pDdeAdvise->fAckReq   = (wType & XTYPF_ACKREQ) ? TRUE : FALSE;
 338     pDdeAdvise->fDeferUpd = (wType & XTYPF_NODATA) ? TRUE : FALSE;
 339     pDdeAdvise->cfFormat  = wFmt;
 340     GlobalUnlock(pXAct->hMem);
 341
 342     pXAct->lParam = PackDDElParam(WM_DDE_ADVISE, (UINT)pXAct->hMem, atom);
 343
 344     return pXAct;
 345 }
 346
 347 /******************************************************************
 348  *              WDML_HandleAdviseReply
 349  *
 350  * handles the reply to an advise request
 351  */
 352 static WDML_QUEUE_STATE WDML_HandleAdviseReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct)
 353 {
 354     DDEACK              ddeAck;
 355     UINT                uiLo, uiHi;
 356     HSZ                 hsz;
 357
 358     if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
 359     {
 360         return WDML_QS_PASS;
 361     }
 362
 363     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
 364     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 365
 366     if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
 367         return WDML_QS_PASS;
 368
 369     GlobalDeleteAtom(uiHi);
 370     FreeDDElParam(WM_DDE_ACK, msg->lParam);
 371
 372     WDML_ExtractAck(uiLo, &ddeAck);
 373
 374     if (ddeAck.fAck)
 375     {
 376         WDML_LINK*      pLink;
 377
 378         /* billx: first to see if the link is already created. */
 379         pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
 380                               pXAct->hszItem, TRUE, pXAct->wFmt);
 381         if (pLink != NULL)
 382         {
 383             /* we found a link, and only need to modify it in case it changes */
 384             pLink->transactionType = pXAct->wType;
 385         }
 386         else
 387         {
 388             WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
 389                          pXAct->wType, pXAct->hszItem, pXAct->wFmt);
 390         }
 391         pXAct->hDdeData = (HDDEDATA)1;
 392     }
 393     else
 394     {
 395         TRACE("Returning FALSE on XTYP_ADVSTART - fAck was FALSE\n");
 396         GlobalFree(pXAct->hMem);
 397         pXAct->hDdeData = NULL;
 398     }
 399
 400     return WDML_QS_HANDLED;
 401 }
 402
 403 /******************************************************************
 404  *              WDML_ClientQueueUnadvise
 405  *
 406  * queues an unadvise transaction
 407  */
 408 static WDML_XACT*       WDML_ClientQueueUnadvise(WDML_CONV* pConv, UINT wFmt, HSZ hszItem)
 409 {
 410     WDML_XACT*  pXAct;
 411     ATOM        atom;
 412
 413     TRACE("XTYP_ADVSTOP transaction\n");
 414
 415     atom = WDML_MakeAtomFromHsz(hszItem);
 416     if (!atom) return NULL;
 417
 418     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE, wFmt, hszItem);
 419     if (!pXAct)
 420     {
 421         GlobalDeleteAtom(atom);
 422         return NULL;
 423     }
 424
 425     /* end advise loop: post WM_DDE_UNADVISE to server to terminate link
 426      * on the specified item.
 427      */
 428     pXAct->lParam = PackDDElParam(WM_DDE_UNADVISE, wFmt, atom);
 429     return pXAct;
 430 }
 431
 432 /******************************************************************
 433  *              WDML_HandleUnadviseReply
 434  *
 435  *
 436  */
 437 static WDML_QUEUE_STATE WDML_HandleUnadviseReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct)
 438 {
 439     DDEACK      ddeAck;
 440     UINT        uiLo, uiHi;
 441     HSZ         hsz;
 442
 443     if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
 444     {
 445         return WDML_QS_PASS;
 446     }
 447
 448     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
 449     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 450
 451     if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
 452         return WDML_QS_PASS;
 453
 454     FreeDDElParam(WM_DDE_ACK, msg->lParam);
 455     GlobalDeleteAtom(uiHi);
 456
 457     WDML_ExtractAck(uiLo, &ddeAck);
 458
 459     TRACE("WM_DDE_ACK received while waiting for a timeout\n");
 460
 461     if (!ddeAck.fAck)
 462     {
 463         TRACE("Returning FALSE on XTYP_ADVSTOP - fAck was FALSE\n");
 464         pXAct->hDdeData = NULL;
 465     }
 466     else
 467     {
 468         /* billx: remove the link */
 469         WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE,
 470                         pXAct->hszItem, pXAct->wFmt);
 471         pXAct->hDdeData = (HDDEDATA)1;
 472     }
 473     return WDML_QS_HANDLED;
 474 }
 475
 476 /******************************************************************
 477  *              WDML_ClientQueueRequest
 478  *
 479  *
 480  */
 481 static WDML_XACT*       WDML_ClientQueueRequest(WDML_CONV* pConv, UINT wFmt, HSZ hszItem)
 482 {
 483     WDML_XACT*  pXAct;
 484     ATOM        atom;
 485
 486     TRACE("XTYP_REQUEST transaction\n");
 487
 488     atom = WDML_MakeAtomFromHsz(hszItem);
 489     if (!atom) return NULL;
 490
 491     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST, wFmt, hszItem);
 492     if (!pXAct)
 493     {
 494         GlobalDeleteAtom(atom);
 495         return NULL;
 496     }
 497
 498     pXAct->lParam = PackDDElParam(WM_DDE_REQUEST, wFmt, atom);
 499
 500     return pXAct;
 501 }
 502
 503 /******************************************************************
 504  *              WDML_HandleRequestReply
 505  *
 506  *
 507  */
 508 static WDML_QUEUE_STATE WDML_HandleRequestReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct)
 509 {
 510     DDEACK              ddeAck;
 511     WINE_DDEHEAD        wdh;
 512     UINT                uiLo, uiHi;
 513     HSZ                 hsz;
 514
 515     if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
 516         return WDML_QS_PASS;
 517
 518     switch (msg->message)
 519     {
 520     case WM_DDE_ACK:
 521         UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
 522         FreeDDElParam(WM_DDE_ACK, msg->lParam);
 523         GlobalDeleteAtom(uiHi);
 524         WDML_ExtractAck(uiLo, &ddeAck);
 525         pXAct->hDdeData = 0;
 526         if (ddeAck.fAck)
 527             ERR("Positive answer should appear in NACK for a request, assuming negative\n");
 528         TRACE("Negative answer...\n");
 529         break;
 530
 531     case WM_DDE_DATA:
 532         UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
 533         TRACE("Got the result (%08lx)\n", (DWORD)uiLo);
 534
 535         hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 536
 537         if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
 538             return WDML_QS_PASS;
 539
 540         pXAct->hDdeData = WDML_Global2DataHandle((HGLOBAL)uiLo, &wdh);
 541         if (wdh.fRelease)
 542         {
 543             GlobalFree((HGLOBAL)uiLo);
 544         }
 545         if (wdh.fAckReq)
 546         {
 547             WDML_PostAck(pConv, WDML_CLIENT_SIDE, 0, FALSE, TRUE, uiHi, msg->lParam, WM_DDE_DATA);
 548         }
 549         else
 550         {
 551             GlobalDeleteAtom(uiHi);
 552             FreeDDElParam(WM_DDE_ACK, msg->lParam);
 553         }
 554         break;
 555
 556     default:
 557         FreeDDElParam(msg->message, msg->lParam);
 558         return WDML_QS_PASS;
 559     }
 560
 561     return WDML_QS_HANDLED;
 562 }
 563
 564 /******************************************************************
 565  *              WDML_BuildExecuteCommand
 566  *
 567  * Creates a DDE block suitable for sending in WM_DDE_COMMAND
 568  * It also takes care of string conversion between the two window procedures
 569  */
 570 static  HGLOBAL WDML_BuildExecuteCommand(WDML_CONV* pConv, LPCVOID pData, DWORD cbData)
 571 {
 572     HGLOBAL     hMem;
 573     BOOL        clientUnicode, serverUnicode;
 574     DWORD       memSize;
 575
 576     clientUnicode = IsWindowUnicode(pConv->hwndClient);
 577     serverUnicode = IsWindowUnicode(pConv->hwndServer);
 578
 579     if (clientUnicode == serverUnicode)
 580     {
 581         memSize = cbData;
 582     }
 583     else
 584     {
 585         if (clientUnicode)
 586         {
 587             memSize = WideCharToMultiByte( CP_ACP, 0, pData, cbData, NULL, 0, NULL, NULL);
 588         }
 589         else
 590         {
 591             memSize = MultiByteToWideChar( CP_ACP, 0, pData, cbData, NULL, 0);
 592         }
 593     }
 594
 595     hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, memSize);
 596
 597     if (hMem)
 598     {
 599         LPBYTE  pDst;
 600
 601         pDst = GlobalLock(hMem);
 602         if (pDst)
 603         {
 604             if (clientUnicode == serverUnicode)
 605             {
 606                 memcpy(pDst, pData, cbData);
 607             }
 608             else
 609             {
 610                 if (clientUnicode)
 611                 {
 612                     WideCharToMultiByte( CP_ACP, 0, pData, cbData, pDst, memSize, NULL, NULL);
 613                 }
 614                 else
 615                 {
 616                     MultiByteToWideChar( CP_ACP, 0, pData, cbData, (LPWSTR)pDst, memSize);
 617                 }
 618             }
 619
 620             GlobalUnlock(hMem);
 621         }
 622         else
 623         {
 624             GlobalFree(hMem);
 625             hMem = 0;
 626         }
 627     }
 628     return hMem;
 629 }
 630
 631 /******************************************************************
 632  *              WDML_ClientQueueExecute
 633  *
 634  *
 635  */
 636 static WDML_XACT*       WDML_ClientQueueExecute(WDML_CONV* pConv, LPCVOID pData, DWORD cbData)
 637 {
 638     WDML_XACT*  pXAct;
 639
 640     TRACE("XTYP_EXECUTE transaction\n");
 641
 642     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
 643     if (!pXAct)
 644         return NULL;
 645
 646     if (cbData == (DWORD)-1)
 647     {
 648         HDDEDATA        hDdeData = (HDDEDATA)pData;
 649
 650         pData = DdeAccessData(hDdeData, &cbData);
 651         if (pData)
 652         {
 653             pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
 654             DdeUnaccessData(hDdeData);
 655         }
 656     }
 657     else
 658     {
 659         pXAct->hMem = WDML_BuildExecuteCommand(pConv, pData, cbData);
 660     }
 661
 662     pXAct->lParam = (LPARAM)pXAct->hMem;
 663
 664     return pXAct;
 665 }
 666
 667 /******************************************************************
 668  *              WDML_HandleExecuteReply
 669  *
 670  *
 671  */
 672 static WDML_QUEUE_STATE WDML_HandleExecuteReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct)
 673 {
 674     DDEACK      ddeAck;
 675     UINT        uiLo, uiHi;
 676
 677     if (msg->message != WM_DDE_ACK || WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
 678     {
 679         return WDML_QS_PASS;
 680     }
 681
 682     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
 683     FreeDDElParam(WM_DDE_ACK, msg->lParam);
 684
 685     if ((HANDLE)uiHi != pXAct->hMem)
 686     {
 687         return WDML_QS_PASS;
 688     }
 689
 690     WDML_ExtractAck(uiLo, &ddeAck);
 691     pXAct->hDdeData = (HDDEDATA)(UINT_PTR)ddeAck.fAck;
 692
 693     return WDML_QS_HANDLED;
 694 }
 695
 696 /******************************************************************
 697  *              WDML_ClientQueuePoke
 698  *
 699  *
 700  */
 701 static WDML_XACT*       WDML_ClientQueuePoke(WDML_CONV* pConv, LPCVOID pData, DWORD cbData,
 702                                              UINT wFmt, HSZ hszItem)
 703 {
 704     WDML_XACT*  pXAct;
 705     ATOM        atom;
 706
 707     TRACE("XTYP_POKE transaction\n");
 708
 709     atom = WDML_MakeAtomFromHsz(hszItem);
 710     if (!atom) return NULL;
 711
 712     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE, wFmt, hszItem);
 713     if (!pXAct)
 714     {
 715         GlobalDeleteAtom(atom);
 716         return NULL;
 717     }
 718
 719     if (cbData == (DWORD)-1)
 720     {
 721         pXAct->hMem = (HDDEDATA)pData;
 722     }
 723     else
 724     {
 725         DDEPOKE*        ddePoke;
 726
 727         pXAct->hMem = GlobalAlloc(GHND | GMEM_DDESHARE, sizeof(DDEPOKE) + cbData);
 728         ddePoke = GlobalLock(pXAct->hMem);
 729         if (ddePoke)
 730         {
 731             memcpy(ddePoke->Value, pData, cbData);
 732             ddePoke->fRelease = FALSE; /* FIXME: app owned ? */
 733             ddePoke->cfFormat = wFmt;
 734             GlobalUnlock(pXAct->hMem);
 735         }
 736     }
 737
 738     pXAct->lParam = PackDDElParam(WM_DDE_POKE, (UINT)pXAct->hMem, atom);
 739
 740     return pXAct;
 741 }
 742
 743 /******************************************************************
 744  *              WDML_HandlePokeReply
 745  *
 746  *
 747  */
 748 static WDML_QUEUE_STATE WDML_HandlePokeReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct)
 749 {
 750     DDEACK      ddeAck;
 751     UINT        uiLo, uiHi;
 752     HSZ         hsz;
 753
 754     if (msg->message != WM_DDE_ACK && WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
 755     {
 756         return WDML_QS_PASS;
 757     }
 758
 759     UnpackDDElParam(WM_DDE_ACK, msg->lParam, &uiLo, &uiHi);
 760     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 761     if (DdeCmpStringHandles(hsz, pXAct->hszItem) != 0)
 762     {
 763         return WDML_QS_PASS;
 764     }
 765     FreeDDElParam(WM_DDE_ACK, msg->lParam);
 766     GlobalDeleteAtom(uiHi);
 767
 768     WDML_ExtractAck(uiLo, &ddeAck);
 769     GlobalFree(pXAct->hMem);
 770
 771     pXAct->hDdeData = (HDDEDATA)TRUE;
 772     return TRUE;
 773 }
 774
 775 /******************************************************************
 776  *              WDML_ClientQueueTerminate
 777  *
 778  * Creates and queue an WM_DDE_TERMINATE transaction
 779  */
 780 static WDML_XACT*       WDML_ClientQueueTerminate(WDML_CONV* pConv)
 781 {
 782     WDML_XACT*          pXAct;
 783
 784     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
 785     if (!pXAct)
 786         return NULL;
 787
 788     pXAct->lParam = 0;
 789     pConv->wStatus &= ~ST_CONNECTED;
 790
 791     return pXAct;
 792 }
 793
 794 /******************************************************************
 795  *              WDML_HandleTerminateReply
 796  *
 797  * handles the reply to a terminate request
 798  */
 799 static WDML_QUEUE_STATE WDML_HandleTerminateReply(WDML_CONV* pConv, MSG* msg, WDML_XACT* pXAct)
 800 {
 801     if (msg->message != WM_DDE_TERMINATE)
 802     {
 803         /* FIXME: should delete data passed here */
 804         return WDML_QS_SWALLOWED;
 805     }
 806
 807     if (WIN_GetFullHandle((HWND)msg->wParam) != pConv->hwndServer)
 808     {
 809         FIXME("hmmm shouldn't happen\n");
 810         return WDML_QS_PASS;
 811     }
 812     if (!pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS)
 813     {
 814         WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
 815                             0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
 816     }
 817     WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
 818     return WDML_QS_HANDLED;
 819 }
 820
 821 /******************************************************************
 822  *              WDML_HandleReplyData
 823  *
 824  *
 825  */
 826 static WDML_QUEUE_STATE WDML_HandleIncomingData(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
 827 {
 828     UINT                uiLo, uiHi;
 829     HDDEDATA            hDdeDataIn, hDdeDataOut;
 830     WDML_LINK*          pLink;
 831     WINE_DDEHEAD        wdh;
 832     HSZ                 hsz;
 833
 834     TRACE("WM_DDE_DATA message received in the Client Proc!\n");
 835     /* wParam -- sending window handle  */
 836     /* lParam -- hDdeData & item HSZ    */
 837
 838     UnpackDDElParam(WM_DDE_DATA, msg->lParam, &uiLo, &uiHi);
 839     hsz = WDML_MakeHszFromAtom(pConv->instance, uiHi);
 840
 841     hDdeDataIn = WDML_Global2DataHandle((HGLOBAL)uiLo, &wdh);
 842
 843     /* billx:
 844      *  For hot link, data should be passed to its callback with
 845      * XTYP_ADVDATA and callback should return the proper status.
 846      */
 847     pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_CLIENT_SIDE, hsz,
 848                           uiLo ? TRUE : FALSE, wdh.cfFormat);
 849     if (!pLink)
 850     {
 851         WDML_DecHSZ(pConv->instance, hsz);
 852         DdeFreeDataHandle(hDdeDataIn);
 853         return WDML_QS_PASS;
 854     }
 855
 856     if (hDdeDataIn != 0 && wdh.fAckReq)
 857     {
 858         WDML_PostAck(pConv, WDML_CLIENT_SIDE, 0, FALSE, TRUE, uiHi, msg->lParam, WM_DDE_DATA);
 859         if (msg->lParam)
 860             msg->lParam = 0;
 861     }
 862     else
 863     {
 864         GlobalDeleteAtom(uiHi);
 865     }
 866
 867     hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_ADVDATA, pLink->uFmt, pLink->hConv,
 868                                       pConv->hszTopic, pLink->hszItem, hDdeDataIn, 0, 0);
 869
 870     if (hDdeDataOut != (HDDEDATA)DDE_FACK || wdh.fRelease)
 871     {
 872         if (uiLo) GlobalFree((HANDLE)uiLo);
 873     }
 874
 875     DdeFreeDataHandle(hDdeDataIn);
 876
 877     WDML_DecHSZ(pConv->instance, hsz);
 878     if (msg->lParam)
 879         FreeDDElParam(WM_DDE_DATA, msg->lParam);
 880
 881     return WDML_QS_HANDLED;
 882 }
 883
 884 /******************************************************************
 885  *              WDML_HandleIncomingTerminate
 886  *
 887  *
 888  */
 889 static WDML_QUEUE_STATE WDML_HandleIncomingTerminate(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
 890 {
 891     if (pConv->hwndServer != WIN_GetFullHandle((HWND)msg->wParam))
 892         return WDML_QS_PASS;
 893
 894     pConv->wStatus |= ST_TERMINATED;
 895     if (!pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS)
 896     {
 897         WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv,
 898                             0, 0, 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
 899     }
 900     if (pConv->wStatus & ST_CONNECTED)
 901     {
 902         /* don't care about result code (if server exists or not) */
 903         PostMessageA(pConv->hwndServer, WM_DDE_TERMINATE, (WPARAM)pConv->hwndClient, 0L);
 904         pConv->wStatus &= ~ST_CONNECTED;
 905     }
 906     /* have to keep connection around to allow reconnection */
 907     return WDML_QS_HANDLED;
 908 }
 909
 910 /******************************************************************
 911  *              WDML_HandleReply
 912  *
 913  * handles any incoming reply, and try to match to an already sent request
 914  */
 915 static WDML_QUEUE_STATE WDML_HandleReply(WDML_CONV* pConv, MSG* msg, HDDEDATA* hdd)
 916 {
 917     WDML_XACT*          pXAct = pConv->transactions;
 918     WDML_QUEUE_STATE    qs;
 919
 920     if (pConv->transactions)
 921     {
 922         /* first check message against a pending transaction, if any */
 923         switch (pXAct->ddeMsg)
 924         {
 925         case WM_DDE_ADVISE:
 926             qs = WDML_HandleAdviseReply(pConv, msg, pXAct);
 927             break;
 928         case WM_DDE_UNADVISE:
 929             qs = WDML_HandleUnadviseReply(pConv, msg, pXAct);
 930             break;
 931         case WM_DDE_EXECUTE:
 932             qs = WDML_HandleExecuteReply(pConv, msg, pXAct);
 933             break;
 934         case WM_DDE_REQUEST:
 935             qs = WDML_HandleRequestReply(pConv, msg, pXAct);
 936             break;
 937         case WM_DDE_POKE:
 938             qs = WDML_HandlePokeReply(pConv, msg, pXAct);
 939             break;
 940         case WM_DDE_TERMINATE:
 941             qs = WDML_HandleTerminateReply(pConv, msg, pXAct);
 942             break;
 943         default:
 944             qs = WDML_QS_ERROR;
 945             FIXME("oooch\n");
 946         }
 947     }
 948     else
 949     {
 950         qs = WDML_QS_PASS;
 951     }
 952
 953     /* now check the results */
 954     switch (qs)
 955     {
 956     case WDML_QS_ERROR:
 957     case WDML_QS_SWALLOWED:
 958         *hdd = 0;
 959         break;
 960     case WDML_QS_HANDLED:
 961         /* ok, we have resolved a pending transaction
 962          * notify callback if asynchronous, and remove it in any case
 963          */
 964         WDML_UnQueueTransaction(pConv, pXAct);
 965         if (pXAct->dwTimeout == TIMEOUT_ASYNC && pXAct->ddeMsg != WM_DDE_TERMINATE)
 966         {
 967             WDML_InvokeCallback(pConv->instance, XTYP_XACT_COMPLETE, pXAct->wFmt,
 968                                 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
 969                                 pXAct->hDdeData, MAKELONG(0, pXAct->xActID), 0 /* FIXME */);
 970             qs = WDML_QS_PASS;
 971         }
 972         else
 973         {
 974             *hdd = pXAct->hDdeData;
 975         }
 976         WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
 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         }
 989         break;
 990     case WDML_QS_BLOCK:
 991         FIXME("shouldn't be used on client side\n");
 992         break;
 993     }
 994
 995     return qs;
 996 }
 997
 998 /******************************************************************
 999  *              WDML_SyncWaitTransactionReply
1000  *
1001  * waits until an answer for a sent request is received
1002  * time out is also handled. only used for synchronous transactions
1003  */
1004 static HDDEDATA WDML_SyncWaitTransactionReply(HCONV hConv, DWORD dwTimeout, WDML_XACT* pXAct)
1005 {
1006     DWORD       dwTime;
1007     DWORD       err;
1008     WDML_CONV*  pConv;
1009
1010     TRACE("Starting wait for a timeout of %ld ms\n", dwTimeout);
1011
1012     /* FIXME: time 32 bit wrap around */
1013     dwTimeout += GetCurrentTime();
1014
1015     while ((dwTime = GetCurrentTime()) < dwTimeout)
1016     {
1017         /* we cannot be in the crit sect all the time because when client and server run in a
1018          * single process they need to share the access to the internal data
1019          */
1020         if (MsgWaitForMultipleObjects(0, NULL, FALSE,
1021                                       dwTimeout - dwTime, QS_POSTMESSAGE) == WAIT_OBJECT_0)
1022         {
1023             BOOL        ret = FALSE;
1024             MSG         msg;
1025             WDML_CONV*  pConv;
1026             HDDEDATA    hdd;
1027
1028             EnterCriticalSection(&WDML_CritSect);
1029
1030             pConv = WDML_GetConv(hConv, FALSE);
1031             if (pConv == NULL)
1032             {
1033                 LeaveCriticalSection(&WDML_CritSect);
1034                 /* conversation no longer available... return failure */
1035                 break;
1036             }
1037             while (PeekMessageA(&msg, pConv->hwndClient, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE))
1038             {
1039                 /* check that either pXAct has been processed or no more xActions are pending */
1040                 ret = (pConv->transactions == pXAct);
1041                 ret = WDML_HandleReply(pConv, &msg, &hdd) == WDML_QS_HANDLED &&
1042                     (pConv->transactions == NULL || ret);
1043                 if (ret) break;
1044             }
1045             LeaveCriticalSection(&WDML_CritSect);
1046             if (ret)
1047             {
1048                 return hdd;
1049             }
1050         }
1051     }
1052
1053     TRACE("Timeout !!\n");
1054
1055     EnterCriticalSection(&WDML_CritSect);
1056
1057     pConv = WDML_GetConv(hConv, FALSE);
1058     if (pConv != NULL)
1059     {
1060         if (pConv->transactions)
1061         {
1062             switch (pConv->transactions->ddeMsg)
1063             {
1064             case WM_DDE_ADVISE:         err = DMLERR_ADVACKTIMEOUT;     break;
1065             case WM_DDE_REQUEST:        err = DMLERR_DATAACKTIMEOUT;    break;
1066             case WM_DDE_EXECUTE:        err = DMLERR_EXECACKTIMEOUT;    break;
1067             case WM_DDE_POKE:           err = DMLERR_POKEACKTIMEOUT;    break;
1068             case WM_DDE_UNADVISE:       err = DMLERR_UNADVACKTIMEOUT;   break;
1069             default:                    err = DMLERR_INVALIDPARAMETER;  break;
1070             }
1071
1072             pConv->instance->lastError = err;
1073         }
1074     }
1075     LeaveCriticalSection(&WDML_CritSect);
1076
1077     return 0;
1078 }
1079
1080 /*****************************************************************
1081  *            DdeClientTransaction  (USER32.@)
1082  */
1083 HDDEDATA WINAPI DdeClientTransaction(LPBYTE pData, DWORD cbData, HCONV hConv, HSZ hszItem, UINT wFmt,
1084                                      UINT wType, DWORD dwTimeout, LPDWORD pdwResult)
1085 {
1086     WDML_CONV*          pConv;
1087     WDML_XACT*          pXAct;
1088     HDDEDATA            hDdeData = 0;
1089
1090     TRACE("(%p,%ld,%p,%p,%d,%d,%ld,%p)\n",
1091           pData, cbData, hConv, hszItem, wFmt, wType, dwTimeout, pdwResult);
1092
1093     if (hConv == 0)
1094     {
1095         ERR("Invalid conversation handle\n");
1096         return 0;
1097     }
1098
1099     EnterCriticalSection(&WDML_CritSect);
1100
1101     pConv = WDML_GetConv(hConv, TRUE);
1102     if (pConv == NULL)
1103     {
1104         /* cannot set error... cannot get back to DDE instance */
1105         goto theError;
1106     }
1107
1108     switch (wType)
1109     {
1110     case XTYP_EXECUTE:
1111         if (hszItem != 0 || wFmt != 0)
1112         {
1113             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1114             goto theError;
1115         }
1116         pXAct = WDML_ClientQueueExecute(pConv, pData, cbData);
1117         break;
1118     case XTYP_POKE:
1119         pXAct = WDML_ClientQueuePoke(pConv, pData, cbData, wFmt, hszItem);
1120         break;
1121     case XTYP_ADVSTART|XTYPF_NODATA:
1122     case XTYP_ADVSTART|XTYPF_NODATA|XTYPF_ACKREQ:
1123     case XTYP_ADVSTART:
1124     case XTYP_ADVSTART|XTYPF_ACKREQ:
1125         if (pData)
1126         {
1127             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1128             goto theError;
1129         }
1130         pXAct = WDML_ClientQueueAdvise(pConv, wType, wFmt, hszItem);
1131         break;
1132     case XTYP_ADVSTOP:
1133         if (pData)
1134         {
1135             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1136             goto theError;
1137         }
1138         pXAct = WDML_ClientQueueUnadvise(pConv, wFmt, hszItem);
1139         break;
1140     case XTYP_REQUEST:
1141         if (pData)
1142         {
1143             pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1144             goto theError;
1145         }
1146         pXAct = WDML_ClientQueueRequest(pConv, wFmt, hszItem);
1147         break;
1148     default:
1149         FIXME("Unknown transation\n");
1150         /* unknown transaction type */
1151         pConv->instance->lastError = DMLERR_INVALIDPARAMETER;
1152         goto theError;
1153     }
1154
1155     if (pXAct == NULL)
1156     {
1157         pConv->instance->lastError = DMLERR_MEMORY_ERROR;
1158         goto theError;
1159     }
1160
1161     WDML_QueueTransaction(pConv, pXAct);
1162
1163     if (!PostMessageA(pConv->hwndServer, pXAct->ddeMsg, (WPARAM)pConv->hwndClient, pXAct->lParam))
1164     {
1165         TRACE("Failed posting message %d to %p (error=0x%lx)\n",
1166               pXAct->ddeMsg, pConv->hwndServer, GetLastError());
1167         pConv->wStatus &= ~ST_CONNECTED;
1168         WDML_UnQueueTransaction(pConv, pXAct);
1169         WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1170         goto theError;
1171     }
1172     pXAct->dwTimeout = dwTimeout;
1173     /* FIXME: should set the app bits on *pdwResult */
1174
1175     if (dwTimeout == TIMEOUT_ASYNC)
1176     {
1177         if (pdwResult)
1178         {
1179             *pdwResult = MAKELONG(0, pXAct->xActID);
1180         }
1181         hDdeData = (HDDEDATA)1;
1182     }
1183     else
1184     {
1185         DWORD   count, i;
1186
1187         if (pdwResult)
1188         {
1189             *pdwResult = 0L;
1190         }
1191         count = WDML_CritSect.RecursionCount;
1192         for (i = 0; i < count; i++)
1193             LeaveCriticalSection(&WDML_CritSect);
1194         hDdeData = WDML_SyncWaitTransactionReply((HCONV)pConv, dwTimeout, pXAct);
1195         for (i = 0; i < count; i++)
1196             EnterCriticalSection(&WDML_CritSect);
1197     }
1198     LeaveCriticalSection(&WDML_CritSect);
1199
1200     return hDdeData;
1201  theError:
1202     LeaveCriticalSection(&WDML_CritSect);
1203     return 0;
1204 }
1205
1206 /*****************************************************************
1207  *            DdeAbandonTransaction (USER32.@)
1208  */
1209 BOOL WINAPI DdeAbandonTransaction(DWORD idInst, HCONV hConv, DWORD idTransaction)
1210 {
1211     WDML_INSTANCE*      pInstance;
1212     WDML_CONV*          pConv;
1213     WDML_XACT*          pXAct;
1214
1215     TRACE("(%08lx,%08lx,%08ld);\n", idInst, (DWORD)hConv, idTransaction);
1216
1217     EnterCriticalSection(&WDML_CritSect);
1218     if ((pInstance = WDML_GetInstance(idInst)))
1219     {
1220         if (hConv)
1221         {
1222             if ((pConv = WDML_GetConv(hConv, TRUE)) && pConv->instance == pInstance)
1223             {
1224                 for (pXAct = pConv->transactions; pXAct; pXAct = pXAct->next)
1225                 {
1226                     if (pXAct->dwTimeout == TIMEOUT_ASYNC &&
1227                         (idTransaction == 0 || pXAct->xActID == idTransaction))
1228                     {
1229                         WDML_UnQueueTransaction(pConv, pXAct);
1230                         WDML_FreeTransaction(pInstance, pXAct, TRUE);
1231                     }
1232                 }
1233             }
1234         }
1235         else
1236         {
1237             for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv; pConv = pConv->next)
1238             {
1239                 if (!(pConv->wStatus & ST_CONNECTED)) continue;
1240                 for (pXAct = pConv->transactions; pXAct; pXAct = pXAct->next)
1241                 {
1242                     if (pXAct->dwTimeout == TIMEOUT_ASYNC)
1243                     {
1244                         WDML_UnQueueTransaction(pConv, pXAct);
1245                         WDML_FreeTransaction(pInstance, pXAct, TRUE);
1246                     }
1247                 }
1248             }
1249         }
1250     }
1251     LeaveCriticalSection(&WDML_CritSect);
1252
1253     return TRUE;
1254 }
1255
1256 /******************************************************************
1257  *              WDML_ClientProc
1258  *
1259  * Window Proc created on client side for each conversation
1260  */
1261 static LRESULT CALLBACK WDML_ClientProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
1262 {
1263     UINT        uiLo, uiHi;
1264     WDML_CONV*  pConv = NULL;
1265     HSZ         hszSrv, hszTpc;
1266
1267     if (iMsg == WM_DDE_ACK &&
1268         /* in the initial WM_INITIATE sendmessage */
1269         ((pConv = WDML_GetConvFromWnd(hwnd)) == NULL || pConv->wStatus == XST_INIT1))
1270     {
1271         /* In response to WM_DDE_INITIATE, save server window  */
1272         char            buf[256];
1273         WDML_INSTANCE*  pInstance;
1274
1275         /* note: sent messages do not need packing */
1276         uiLo = LOWORD(lParam);
1277         uiHi = HIWORD(lParam);
1278
1279         /* FIXME: convlist should be handled here */
1280         if (pConv)
1281         {
1282             /* we already have started the conv with a server, drop other replies */
1283             GlobalDeleteAtom(uiLo);
1284             GlobalDeleteAtom(uiHi);
1285             PostMessageA((HWND)wParam, WM_DDE_TERMINATE, (WPARAM)hwnd, 0);
1286             return 0;
1287         }
1288
1289         pInstance = WDML_GetInstanceFromWnd(hwnd);
1290
1291         hszSrv = WDML_MakeHszFromAtom(pInstance, uiLo);
1292         hszTpc = WDML_MakeHszFromAtom(pInstance, uiHi);
1293
1294         pConv = WDML_AddConv(pInstance, WDML_CLIENT_SIDE, hszSrv, hszTpc, hwnd, (HWND)wParam);
1295
1296         SetWindowLongA(hwnd, GWL_WDML_CONVERSATION, (DWORD)pConv);
1297         pConv->wStatus |= ST_CONNECTED;
1298         pConv->wConvst = XST_INIT1;
1299
1300         /* check if server is handled by DDEML */
1301         if ((GetClassNameA((HWND)wParam, buf, sizeof(buf)) &&
1302              strcmp(buf, WDML_szServerConvClassA) == 0) ||
1303             (GetClassNameW((HWND)wParam, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
1304              lstrcmpW((LPWSTR)buf, WDML_szServerConvClassW) == 0))
1305         {
1306             pConv->wStatus |= ST_ISLOCAL;
1307         }
1308
1309         WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_CONNECT_CONFIRM, (WPARAM)hwnd, wParam);
1310
1311         GlobalDeleteAtom(uiLo);
1312         GlobalDeleteAtom(uiHi);
1313
1314         /* accept conversation */
1315         return 1;
1316     }
1317
1318     if (iMsg >= WM_DDE_FIRST && iMsg <= WM_DDE_LAST)
1319     {
1320         EnterCriticalSection(&WDML_CritSect);
1321
1322         pConv = WDML_GetConvFromWnd(hwnd);
1323
1324         if (pConv)
1325         {
1326             MSG         msg;
1327             HDDEDATA    hdd;
1328
1329             msg.hwnd = hwnd;
1330             msg.message = iMsg;
1331             msg.wParam = wParam;
1332             msg.lParam = lParam;
1333
1334             WDML_HandleReply(pConv, &msg, &hdd);
1335         }
1336
1337         LeaveCriticalSection(&WDML_CritSect);
1338         return 0;
1339     }
1340
1341     return (IsWindowUnicode(hwnd)) ?
1342         DefWindowProcA(hwnd, iMsg, wParam, lParam) : DefWindowProcW(hwnd, iMsg, wParam, lParam);
1343 }
1344
1345 /*****************************************************************
1346  *            DdeDisconnect   (USER32.@)
1347  */
1348 BOOL WINAPI DdeDisconnect(HCONV hConv)
1349 {
1350     WDML_CONV*  pConv = NULL;
1351     WDML_XACT*  pXAct;
1352     DWORD       count, i;
1353     BOOL        ret = FALSE;
1354
1355     TRACE("(%ld)\n", (DWORD)hConv);
1356
1357     if (hConv == 0)
1358     {
1359         ERR("DdeDisconnect(): hConv = 0\n");
1360         return FALSE;
1361     }
1362
1363     EnterCriticalSection(&WDML_CritSect);
1364     pConv = WDML_GetConv(hConv, TRUE);
1365     if (pConv != NULL)
1366     {
1367         if (pConv->wStatus & ST_CLIENT)
1368         {
1369             /* FIXME: should abandon all pending transactions */
1370             pXAct = WDML_ClientQueueTerminate(pConv);
1371             if (pXAct != NULL)
1372             {
1373                 count = WDML_CritSect.RecursionCount;
1374                 for (i = 0; i < count; i++)
1375                     LeaveCriticalSection(&WDML_CritSect);
1376                 if (PostMessageA(pConv->hwndServer, pXAct->ddeMsg,
1377                                  (WPARAM)pConv->hwndClient, pXAct->lParam))
1378                     WDML_SyncWaitTransactionReply(hConv, 10000, pXAct);
1379                 for (i = 0; i < count; i++)
1380                     EnterCriticalSection(&WDML_CritSect);
1381                 ret = TRUE;
1382                 WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1383                 /* still have to destroy data assosiated with conversation */
1384                 WDML_RemoveConv(pConv, WDML_CLIENT_SIDE);
1385             }
1386             else
1387             {
1388                 FIXME("Not implemented yet for a server side conversation\n");
1389             }
1390         }
1391     }
1392     LeaveCriticalSection(&WDML_CritSect);
1393
1394     return ret;
1395 }
1396
1397 /*****************************************************************
1398  *            DdeImpersonateClient (USER32.@)
1399  */
1400 BOOL WINAPI DdeImpersonateClient(HCONV hConv)
1401 {
1402     WDML_CONV*  pConv;
1403     BOOL        ret = FALSE;
1404
1405     EnterCriticalSection(&WDML_CritSect);
1406     pConv = WDML_GetConv(hConv, TRUE);
1407     if (pConv)
1408     {
1409         ret = ImpersonateDdeClientWindow(pConv->hwndClient, pConv->hwndServer);
1410     }
1411     LeaveCriticalSection(&WDML_CritSect);
1412     return ret;
1413 }