git.oblomov.eu Git - wine/blob - dlls/user/dde/client.c

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