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