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