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