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