git.oblomov.eu Git - wine/blob - dlls/user32/dde_client.c

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