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