git.oblomov.eu Git - wine/blob - dlls/user32/dde_misc.c

   1 /*
   2  * DDEML library
   3  *
   4  * Copyright 1997 Alexandre Julliard
   5  * Copyright 1997 Len White
   6  * Copyright 1999 Keith Matthews
   7  * Copyright 2000 Corel
   8  * Copyright 2001 Eric Pouech
   9  * Copyright 2003, 2004, 2005 Dmitry Timoshkov
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <string.h>
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "wingdi.h"
  35 #include "winuser.h"
  36 #include "dde.h"
  37 #include "ddeml.h"
  38 #include "win.h"
  39 #include "dde_private.h"
  40 #include "wine/unicode.h"
  41 #include "wine/debug.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
  44
  45 /* convert between ATOM and HSZ avoiding compiler warnings */
  46 #define ATOM2HSZ(atom)  ((HSZ)  (ULONG_PTR)(atom))
  47 #define HSZ2ATOM(hsz)   ((ATOM) (ULONG_PTR)(hsz))
  48
  49 static WDML_INSTANCE*   WDML_InstanceList = NULL;
  50 static LONG             WDML_MaxInstanceID = 0;  /* OK for present, have to worry about wrap-around later */
  51 const WCHAR             WDML_szEventClass[] = {'W','i','n','e','D','d','e','E','v','e','n','t','C','l','a','s','s',0};
  52
  53 /* protection for instance list */
  54 static CRITICAL_SECTION WDML_CritSect;
  55 static CRITICAL_SECTION_DEBUG critsect_debug =
  56 {
  57     0, 0, &WDML_CritSect,
  58     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  59       0, 0, { (DWORD_PTR)(__FILE__ ": WDML_CritSect") }
  60 };
  61 static CRITICAL_SECTION WDML_CritSect = { &critsect_debug, -1, 0, 0, 0, 0 };
  62
  63 /* ================================================================
  64  *
  65  *                      Pure DDE (non DDEML) management
  66  *
  67  * ================================================================ */
  68
  69
  70 /*****************************************************************
  71  *            PackDDElParam (USER32.@)
  72  *
  73  * RETURNS
  74  *   the packed lParam
  75  */
  76 LPARAM WINAPI PackDDElParam(UINT msg, UINT_PTR uiLo, UINT_PTR uiHi)
  77 {
  78     HGLOBAL hMem;
  79     UINT_PTR *params;
  80
  81     switch (msg)
  82     {
  83     case WM_DDE_ACK:
  84     case WM_DDE_ADVISE:
  85     case WM_DDE_DATA:
  86     case WM_DDE_POKE:
  87         if (!(hMem = GlobalAlloc(GMEM_DDESHARE, sizeof(UINT_PTR) * 2)))
  88         {
  89             ERR("GlobalAlloc failed\n");
  90             return 0;
  91         }
  92         if (!(params = GlobalLock(hMem)))
  93         {
  94             ERR("GlobalLock failed (%p)\n", hMem);
  95             return 0;
  96         }
  97         params[0] = uiLo;
  98         params[1] = uiHi;
  99         GlobalUnlock(hMem);
 100         return (LPARAM)hMem;
 101
 102     case WM_DDE_EXECUTE:
 103         return uiHi;
 104
 105     default:
 106         return MAKELONG(uiLo, uiHi);
 107     }
 108 }
 109
 110
 111 /*****************************************************************
 112  *            UnpackDDElParam (USER32.@)
 113  *
 114  * RETURNS
 115  *   success: nonzero
 116  *   failure: zero
 117  */
 118 BOOL WINAPI UnpackDDElParam(UINT msg, LPARAM lParam,
 119                             PUINT_PTR uiLo, PUINT_PTR uiHi)
 120 {
 121     UINT_PTR *params;
 122
 123     switch (msg)
 124     {
 125     case WM_DDE_ACK:
 126     case WM_DDE_ADVISE:
 127     case WM_DDE_DATA:
 128     case WM_DDE_POKE:
 129         if (!lParam || !(params = GlobalLock((HGLOBAL)lParam)))
 130         {
 131             if (uiLo) *uiLo = 0;
 132             if (uiHi) *uiHi = 0;
 133             return FALSE;
 134         }
 135         if (uiLo) *uiLo = params[0];
 136         if (uiHi) *uiHi = params[1];
 137         GlobalUnlock( (HGLOBAL)lParam );
 138         return TRUE;
 139
 140     case WM_DDE_EXECUTE:
 141         if (uiLo) *uiLo = 0;
 142         if (uiHi) *uiHi = lParam;
 143         return TRUE;
 144
 145     default:
 146         if (uiLo) *uiLo = LOWORD(lParam);
 147         if (uiHi) *uiHi = HIWORD(lParam);
 148         return TRUE;
 149     }
 150 }
 151
 152
 153 /*****************************************************************
 154  *            FreeDDElParam (USER32.@)
 155  *
 156  * RETURNS
 157  *   success: nonzero
 158  *   failure: zero
 159  */
 160 BOOL WINAPI FreeDDElParam(UINT msg, LPARAM lParam)
 161 {
 162     switch (msg)
 163     {
 164     case WM_DDE_ACK:
 165     case WM_DDE_ADVISE:
 166     case WM_DDE_DATA:
 167     case WM_DDE_POKE:
 168         /* first check if it's a global handle */
 169         if (!GlobalHandle( (LPVOID)lParam )) return TRUE;
 170         return !GlobalFree( (HGLOBAL)lParam );
 171
 172     default:
 173         return TRUE;
 174      }
 175 }
 176
 177
 178 /*****************************************************************
 179  *            ReuseDDElParam (USER32.@)
 180  *
 181  * RETURNS
 182  *   the packed lParam
 183  */
 184 LPARAM WINAPI ReuseDDElParam(LPARAM lParam, UINT msgIn, UINT msgOut,
 185                              UINT_PTR uiLo, UINT_PTR uiHi)
 186 {
 187     UINT_PTR *params;
 188
 189     switch (msgIn)
 190     {
 191     case WM_DDE_ACK:
 192     case WM_DDE_ADVISE:
 193     case WM_DDE_DATA:
 194     case WM_DDE_POKE:
 195         switch(msgOut)
 196         {
 197         case WM_DDE_ACK:
 198         case WM_DDE_ADVISE:
 199         case WM_DDE_DATA:
 200         case WM_DDE_POKE:
 201             if (!lParam) return 0;
 202             if (!(params = GlobalLock( (HGLOBAL)lParam )))
 203             {
 204                 ERR("GlobalLock failed\n");
 205                 return 0;
 206             }
 207             params[0] = uiLo;
 208             params[1] = uiHi;
 209             TRACE("Reusing pack %08lx %08lx\n", uiLo, uiHi);
 210             GlobalUnlock( (HGLOBAL)lParam );
 211             return lParam;
 212
 213         case WM_DDE_EXECUTE:
 214             FreeDDElParam( msgIn, lParam );
 215             return uiHi;
 216
 217         default:
 218             FreeDDElParam( msgIn, lParam );
 219             return MAKELPARAM(uiLo, uiHi);
 220         }
 221
 222     default:
 223         return PackDDElParam( msgOut, uiLo, uiHi );
 224     }
 225 }
 226
 227 /*****************************************************************
 228  *            ImpersonateDdeClientWindow (USER32.@)
 229  *
 230  * PARAMS
 231  * hWndClient     [I] handle to DDE client window
 232  * hWndServer     [I] handle to DDE server window
 233  */
 234 BOOL WINAPI ImpersonateDdeClientWindow(HWND hWndClient, HWND hWndServer)
 235 {
 236      FIXME("(%p %p): stub\n", hWndClient, hWndServer);
 237      return FALSE;
 238 }
 239
 240 /*****************************************************************
 241  *            DdeSetQualityOfService (USER32.@)
 242  */
 243
 244 BOOL WINAPI DdeSetQualityOfService(HWND hwndClient, CONST SECURITY_QUALITY_OF_SERVICE *pqosNew,
 245                                    PSECURITY_QUALITY_OF_SERVICE pqosPrev)
 246 {
 247      FIXME("(%p %p %p): stub\n", hwndClient, pqosNew, pqosPrev);
 248      return TRUE;
 249 }
 250
 251 /* ================================================================
 252  *
 253  *                      Instance management
 254  *
 255  * ================================================================ */
 256
 257 /******************************************************************************
 258  *              IncrementInstanceId
 259  *
 260  *      generic routine to increment the max instance Id and allocate a new application instance
 261  */
 262 static void WDML_IncrementInstanceId(WDML_INSTANCE* pInstance)
 263 {
 264     DWORD       id = InterlockedIncrement(&WDML_MaxInstanceID);
 265
 266     pInstance->instanceID = id;
 267     TRACE("New instance id %d allocated\n", id);
 268 }
 269
 270 /******************************************************************
 271  *              WDML_EventProc
 272  *
 273  *
 274  */
 275 static LRESULT CALLBACK WDML_EventProc(HWND hwndEvent, UINT uMsg, WPARAM wParam, LPARAM lParam)
 276 {
 277     WDML_INSTANCE*      pInstance;
 278     HSZ                 hsz1, hsz2;
 279
 280     switch (uMsg)
 281     {
 282     case WM_WDML_REGISTER:
 283         pInstance = WDML_GetInstanceFromWnd(hwndEvent);
 284         /* try calling the Callback */
 285         if (pInstance && !(pInstance->CBFflags & CBF_SKIP_REGISTRATIONS))
 286         {
 287             hsz1 = WDML_MakeHszFromAtom(pInstance, wParam);
 288             hsz2 = WDML_MakeHszFromAtom(pInstance, lParam);
 289             WDML_InvokeCallback(pInstance, XTYP_REGISTER, 0, 0, hsz1, hsz2, 0, 0, 0);
 290             WDML_DecHSZ(pInstance, hsz1);
 291             WDML_DecHSZ(pInstance, hsz2);
 292         }
 293         break;
 294
 295     case WM_WDML_UNREGISTER:
 296         pInstance = WDML_GetInstanceFromWnd(hwndEvent);
 297         if (pInstance && !(pInstance->CBFflags & CBF_SKIP_UNREGISTRATIONS))
 298         {
 299             hsz1 = WDML_MakeHszFromAtom(pInstance, wParam);
 300             hsz2 = WDML_MakeHszFromAtom(pInstance, lParam);
 301             WDML_InvokeCallback(pInstance, XTYP_UNREGISTER, 0, 0, hsz1, hsz2, 0, 0, 0);
 302             WDML_DecHSZ(pInstance, hsz1);
 303             WDML_DecHSZ(pInstance, hsz2);
 304         }
 305         break;
 306
 307     case WM_WDML_CONNECT_CONFIRM:
 308         pInstance = WDML_GetInstanceFromWnd(hwndEvent);
 309         if (pInstance && !(pInstance->CBFflags & CBF_SKIP_CONNECT_CONFIRMS))
 310         {
 311             WDML_CONV*  pConv;
 312             /* confirm connection...
 313              * lookup for this conv handle
 314              */
 315             HWND client = WIN_GetFullHandle( (HWND)wParam );
 316             HWND server = WIN_GetFullHandle( (HWND)lParam );
 317             for (pConv = pInstance->convs[WDML_SERVER_SIDE]; pConv != NULL; pConv = pConv->next)
 318             {
 319                 if (pConv->hwndClient == client && pConv->hwndServer == server)
 320                     break;
 321             }
 322             if (pConv)
 323             {
 324                 pConv->wStatus |= ST_ISLOCAL;
 325
 326                 WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
 327                                     pConv->hszTopic, pConv->hszService, 0, 0,
 328                                     (pConv->wStatus & ST_ISSELF) ? 1 : 0);
 329             }
 330         }
 331         break;
 332     default:
 333         return DefWindowProcW(hwndEvent, uMsg, wParam, lParam);
 334     }
 335     return 0;
 336 }
 337
 338 /******************************************************************
 339  *              WDML_Initialize
 340  *
 341  *
 342  */
 343 UINT WDML_Initialize(LPDWORD pidInst, PFNCALLBACK pfnCallback,
 344                      DWORD afCmd, DWORD ulRes, BOOL bUnicode, BOOL b16)
 345 {
 346     WDML_INSTANCE*              pInstance;
 347     WDML_INSTANCE*              reference_inst;
 348     UINT                        ret;
 349     WNDCLASSEXW                 wndclass;
 350
 351     TRACE("(%p,%p,0x%x,%d,0x%x)\n",
 352           pidInst, pfnCallback, afCmd, ulRes, bUnicode);
 353
 354     if (ulRes)
 355     {
 356         ERR("Reserved value not zero?  What does this mean?\n");
 357         /* trap this and no more until we know more */
 358         return DMLERR_NO_ERROR;
 359     }
 360
 361     /* grab enough heap for one control struct - not really necessary for re-initialise
 362      *  but allows us to use same validation routines */
 363     pInstance = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_INSTANCE));
 364     if (pInstance == NULL)
 365     {
 366         /* catastrophe !! warn user & abort */
 367         ERR("Instance create failed - out of memory\n");
 368         return DMLERR_SYS_ERROR;
 369     }
 370     pInstance->next = NULL;
 371     pInstance->monitor = (afCmd | APPCLASS_MONITOR);
 372
 373     /* messy bit, spec implies that 'Client Only' can be set in 2 different ways, catch 1 here */
 374
 375     pInstance->clientOnly = afCmd & APPCMD_CLIENTONLY;
 376     pInstance->instanceID = *pidInst; /* May need to add calling proc Id */
 377     pInstance->threadID = GetCurrentThreadId();
 378     pInstance->callback = *pfnCallback;
 379     pInstance->unicode = bUnicode;
 380     pInstance->win16 = b16;
 381     pInstance->nodeList = NULL; /* node will be added later */
 382     pInstance->monitorFlags = afCmd & MF_MASK;
 383     pInstance->wStatus = 0;
 384     pInstance->servers = NULL;
 385     pInstance->convs[0] = NULL;
 386     pInstance->convs[1] = NULL;
 387     pInstance->links[0] = NULL;
 388     pInstance->links[1] = NULL;
 389
 390     /* isolate CBF flags in one go, expect this will go the way of all attempts to be clever !! */
 391
 392     pInstance->CBFflags = afCmd^((afCmd&MF_MASK)|((afCmd&APPCMD_MASK)|(afCmd&APPCLASS_MASK)));
 393
 394     if (!pInstance->clientOnly)
 395     {
 396         /* Check for other way of setting Client-only !! */
 397         pInstance->clientOnly =
 398             (pInstance->CBFflags & CBF_FAIL_ALLSVRXACTIONS) == CBF_FAIL_ALLSVRXACTIONS;
 399     }
 400
 401     TRACE("instance created - checking validity\n");
 402
 403     if (*pidInst == 0)
 404     {
 405         /*  Initialisation of new Instance Identifier */
 406         TRACE("new instance, callback %p flags %X\n",pfnCallback,afCmd);
 407
 408         EnterCriticalSection(&WDML_CritSect);
 409
 410         if (WDML_InstanceList == NULL)
 411         {
 412             /* can't be another instance in this case, assign to the base pointer */
 413             WDML_InstanceList = pInstance;
 414
 415             /* since first must force filter of XTYP_CONNECT and XTYP_WILDCONNECT for
 416              *          present
 417              *  -------------------------------      NOTE NOTE NOTE    --------------------------
 418              *
 419              *  the manual is not clear if this condition
 420              *  applies to the first call to DdeInitialize from an application, or the
 421              *  first call for a given callback !!!
 422              */
 423
 424             pInstance->CBFflags = pInstance->CBFflags|APPCMD_FILTERINITS;
 425             TRACE("First application instance detected OK\n");
 426             /*  allocate new instance ID */
 427             WDML_IncrementInstanceId(pInstance);
 428         }
 429         else
 430         {
 431             /* really need to chain the new one in to the latest here, but after checking conditions
 432              *  such as trying to start a conversation from an application trying to monitor */
 433             reference_inst = WDML_InstanceList;
 434             TRACE("Subsequent application instance - starting checks\n");
 435             while (reference_inst->next != NULL)
 436             {
 437                 /*
 438                  *      This set of tests will work if application uses same instance Id
 439                  *      at application level once allocated - which is what manual implies
 440                  *      should happen. If someone tries to be
 441                  *      clever (lazy ?) it will fail to pick up that later calls are for
 442                  *      the same application - should we trust them ?
 443                  */
 444                 if (pInstance->instanceID == reference_inst->instanceID)
 445                 {
 446                     /* Check 1 - must be same Client-only state */
 447
 448                     if (pInstance->clientOnly != reference_inst->clientOnly)
 449                     {
 450                         ret = DMLERR_DLL_USAGE;
 451                         goto theError;
 452                     }
 453
 454                     /* Check 2 - cannot use 'Monitor' with any non-monitor modes */
 455
 456                     if (pInstance->monitor != reference_inst->monitor)
 457                     {
 458                         ret = DMLERR_INVALIDPARAMETER;
 459                         goto theError;
 460                     }
 461
 462                     /* Check 3 - must supply different callback address */
 463
 464                     if (pInstance->callback == reference_inst->callback)
 465                     {
 466                         ret = DMLERR_DLL_USAGE;
 467                         goto theError;
 468                     }
 469                 }
 470                 reference_inst = reference_inst->next;
 471             }
 472             /*  All cleared, add to chain */
 473
 474             TRACE("Application Instance checks finished\n");
 475             WDML_IncrementInstanceId(pInstance);
 476             reference_inst->next = pInstance;
 477         }
 478         LeaveCriticalSection(&WDML_CritSect);
 479
 480         *pidInst = pInstance->instanceID;
 481
 482         /* for deadlock issues, windows must always be created when outside the critical section */
 483         wndclass.cbSize        = sizeof(wndclass);
 484         wndclass.style         = 0;
 485         wndclass.lpfnWndProc   = WDML_EventProc;
 486         wndclass.cbClsExtra    = 0;
 487         wndclass.cbWndExtra    = sizeof(ULONG_PTR);
 488         wndclass.hInstance     = 0;
 489         wndclass.hIcon         = 0;
 490         wndclass.hCursor       = 0;
 491         wndclass.hbrBackground = 0;
 492         wndclass.lpszMenuName  = NULL;
 493         wndclass.lpszClassName = WDML_szEventClass;
 494         wndclass.hIconSm       = 0;
 495
 496         RegisterClassExW(&wndclass);
 497
 498         pInstance->hwndEvent = CreateWindowW(WDML_szEventClass, NULL,
 499                                                 WS_POPUP, 0, 0, 0, 0,
 500                                                 0, 0, 0, 0);
 501
 502         SetWindowLongPtrW(pInstance->hwndEvent, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
 503
 504         TRACE("New application instance processing finished OK\n");
 505     }
 506     else
 507     {
 508         /* Reinitialisation situation   --- FIX  */
 509         TRACE("reinitialisation of (%p,%p,0x%x,%d): stub\n", pidInst, pfnCallback, afCmd, ulRes);
 510
 511         EnterCriticalSection(&WDML_CritSect);
 512
 513         if (WDML_InstanceList == NULL)
 514         {
 515             ret = DMLERR_INVALIDPARAMETER;
 516             goto theError;
 517         }
 518         /* can't reinitialise if we have initialised nothing !! */
 519         reference_inst = WDML_InstanceList;
 520         /* must first check if we have been given a valid instance to re-initialise !!  how do we do that ? */
 521         /*
 522          *      MS allows initialisation without specifying a callback, should we allow addition of the
 523          *      callback by a later call to initialise ? - if so this lot will have to change
 524          */
 525         while (reference_inst->next != NULL)
 526         {
 527             if (*pidInst == reference_inst->instanceID && pfnCallback == reference_inst->callback)
 528             {
 529                 /* Check 1 - cannot change client-only mode if set via APPCMD_CLIENTONLY */
 530
 531                 if (reference_inst->clientOnly)
 532                 {
 533                     if  ((reference_inst->CBFflags & CBF_FAIL_ALLSVRXACTIONS) != CBF_FAIL_ALLSVRXACTIONS)
 534                     {
 535                                 /* i.e. Was set to Client-only and through APPCMD_CLIENTONLY */
 536
 537                         if (!(afCmd & APPCMD_CLIENTONLY))
 538                         {
 539                             ret = DMLERR_INVALIDPARAMETER;
 540                             goto theError;
 541                         }
 542                     }
 543                 }
 544                 /* Check 2 - cannot change monitor modes */
 545
 546                 if (pInstance->monitor != reference_inst->monitor)
 547                 {
 548                     ret = DMLERR_INVALIDPARAMETER;
 549                     goto theError;
 550                 }
 551
 552                 /* Check 3 - trying to set Client-only via APPCMD when not set so previously */
 553
 554                 if ((afCmd&APPCMD_CLIENTONLY) && !reference_inst->clientOnly)
 555                 {
 556                     ret = DMLERR_INVALIDPARAMETER;
 557                     goto theError;
 558                 }
 559                 break;
 560             }
 561             reference_inst = reference_inst->next;
 562         }
 563         if (reference_inst->next == NULL)
 564         {
 565             ret = DMLERR_INVALIDPARAMETER;
 566             goto theError;
 567         }
 568         /* All checked - change relevant flags */
 569
 570         reference_inst->CBFflags = pInstance->CBFflags;
 571         reference_inst->clientOnly = pInstance->clientOnly;
 572         reference_inst->monitorFlags = pInstance->monitorFlags;
 573
 574         HeapFree(GetProcessHeap(), 0, pInstance); /* finished - release heap space used as work store */
 575
 576         LeaveCriticalSection(&WDML_CritSect);
 577     }
 578
 579     return DMLERR_NO_ERROR;
 580  theError:
 581     HeapFree(GetProcessHeap(), 0, pInstance);
 582     LeaveCriticalSection(&WDML_CritSect);
 583     return ret;
 584 }
 585
 586 /******************************************************************************
 587  *            DdeInitializeA   (USER32.@)
 588  *
 589  * See DdeInitializeW.
 590  */
 591 UINT WINAPI DdeInitializeA(LPDWORD pidInst, PFNCALLBACK pfnCallback,
 592                            DWORD afCmd, DWORD ulRes)
 593 {
 594     return WDML_Initialize(pidInst, pfnCallback, afCmd, ulRes, FALSE, FALSE);
 595 }
 596
 597 /******************************************************************************
 598  * DdeInitializeW [USER32.@]
 599  * Registers an application with the DDEML
 600  *
 601  * PARAMS
 602  *    pidInst     [I] Pointer to instance identifier
 603  *    pfnCallback [I] Pointer to callback function
 604  *    afCmd       [I] Set of command and filter flags
 605  *    ulRes       [I] Reserved
 606  *
 607  * RETURNS
 608  *    Success: DMLERR_NO_ERROR
 609  *    Failure: DMLERR_DLL_USAGE, DMLERR_INVALIDPARAMETER, DMLERR_SYS_ERROR
 610  */
 611 UINT WINAPI DdeInitializeW(LPDWORD pidInst, PFNCALLBACK pfnCallback,
 612                            DWORD afCmd, DWORD ulRes)
 613 {
 614     return WDML_Initialize(pidInst, pfnCallback, afCmd, ulRes, TRUE, FALSE);
 615 }
 616
 617 /*****************************************************************
 618  * DdeUninitialize [USER32.@]  Frees DDEML resources
 619  *
 620  * PARAMS
 621  *    idInst [I] Instance identifier
 622  *
 623  * RETURNS
 624  *    Success: TRUE
 625  *    Failure: FALSE
 626  */
 627
 628 BOOL WINAPI DdeUninitialize(DWORD idInst)
 629 {
 630     /*  Stage one - check if we have a handle for this instance
 631      */
 632     WDML_INSTANCE*              pInstance;
 633     WDML_CONV*                  pConv;
 634     WDML_CONV*                  pConvNext;
 635
 636     TRACE("(%d)\n", idInst);
 637
 638     /*  First check instance
 639      */
 640     pInstance = WDML_GetInstance(idInst);
 641     if (pInstance == NULL)
 642     {
 643         /*
 644          *      Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
 645          */
 646         return FALSE;
 647     }
 648
 649     /* first terminate all conversations client side
 650      * this shall close existing links...
 651      */
 652     for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv != NULL; pConv = pConvNext)
 653     {
 654         pConvNext = pConv->next;
 655         DdeDisconnect((HCONV)pConv);
 656     }
 657     if (pInstance->convs[WDML_CLIENT_SIDE])
 658         FIXME("still pending conversations\n");
 659
 660     /* then unregister all known service names */
 661     DdeNameService(idInst, 0, 0, DNS_UNREGISTER);
 662
 663     /* Free the nodes that were not freed by this instance
 664      * and remove the nodes from the list of HSZ nodes.
 665      */
 666     WDML_FreeAllHSZ(pInstance);
 667
 668     DestroyWindow(pInstance->hwndEvent);
 669
 670     /* OK now delete the instance handle itself */
 671
 672     if (WDML_InstanceList == pInstance)
 673     {
 674         /* special case - the first/only entry */
 675         WDML_InstanceList = pInstance->next;
 676     }
 677     else
 678     {
 679         /* general case, remove entry */
 680         WDML_INSTANCE*  inst;
 681
 682         for (inst = WDML_InstanceList; inst->next != pInstance; inst = inst->next);
 683         inst->next = pInstance->next;
 684     }
 685     /* release the heap entry
 686      */
 687     HeapFree(GetProcessHeap(), 0, pInstance);
 688
 689     return TRUE;
 690 }
 691
 692 /******************************************************************
 693  *              WDML_NotifyThreadExit
 694  *
 695  *
 696  */
 697 void WDML_NotifyThreadDetach(void)
 698 {
 699     WDML_INSTANCE*      pInstance;
 700     WDML_INSTANCE*      next;
 701     DWORD               tid = GetCurrentThreadId();
 702
 703     EnterCriticalSection(&WDML_CritSect);
 704     for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = next)
 705     {
 706         next = pInstance->next;
 707         if (pInstance->threadID == tid)
 708         {
 709             LeaveCriticalSection(&WDML_CritSect);
 710             DdeUninitialize(pInstance->instanceID);
 711             EnterCriticalSection(&WDML_CritSect);
 712         }
 713     }
 714     LeaveCriticalSection(&WDML_CritSect);
 715 }
 716
 717 /******************************************************************
 718  *              WDML_InvokeCallback
 719  *
 720  *
 721  */
 722 HDDEDATA        WDML_InvokeCallback(WDML_INSTANCE* pInstance, UINT uType, UINT uFmt, HCONV hConv,
 723                                     HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
 724                                     ULONG_PTR dwData1, ULONG_PTR dwData2)
 725 {
 726     HDDEDATA    ret;
 727
 728     if (pInstance == NULL)
 729         return NULL;
 730
 731     TRACE("invoking CB%d[%p] (%x %x %p %p %p %p %lx %lx)\n",
 732           pInstance->win16 ? 16 : 32, pInstance->callback, uType, uFmt,
 733           hConv, hsz1, hsz2, hdata, dwData1, dwData2);
 734     if (pInstance->win16)
 735     {
 736         ret = WDML_InvokeCallback16(pInstance->callback, uType, uFmt, hConv,
 737                                     hsz1, hsz2, hdata, dwData1, dwData2);
 738     }
 739     else
 740     {
 741         ret = pInstance->callback(uType, uFmt, hConv, hsz1, hsz2, hdata, dwData1, dwData2);
 742     }
 743     TRACE("done => %p\n", ret);
 744     return ret;
 745 }
 746
 747 /*****************************************************************************
 748  *      WDML_GetInstance
 749  *
 750  *      generic routine to return a pointer to the relevant DDE_HANDLE_ENTRY
 751  *      for an instance Id, or NULL if the entry does not exist
 752  *
 753  */
 754 WDML_INSTANCE*  WDML_GetInstance(DWORD instId)
 755 {
 756     WDML_INSTANCE*      pInstance;
 757
 758     EnterCriticalSection(&WDML_CritSect);
 759
 760     for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = pInstance->next)
 761     {
 762         if (pInstance->instanceID == instId)
 763         {
 764             if (GetCurrentThreadId() != pInstance->threadID)
 765             {
 766                 FIXME("Tried to get instance from wrong thread\n");
 767                 continue;
 768             }
 769             break;
 770         }
 771     }
 772
 773     LeaveCriticalSection(&WDML_CritSect);
 774
 775     if (!pInstance)
 776         WARN("Instance entry missing for id %04x\n", instId);
 777     return pInstance;
 778 }
 779
 780 /******************************************************************
 781  *              WDML_GetInstanceFromWnd
 782  *
 783  *
 784  */
 785 WDML_INSTANCE*  WDML_GetInstanceFromWnd(HWND hWnd)
 786 {
 787     return (WDML_INSTANCE*)GetWindowLongPtrW(hWnd, GWL_WDML_INSTANCE);
 788 }
 789
 790 /******************************************************************************
 791  * DdeGetLastError [USER32.@]  Gets most recent error code
 792  *
 793  * PARAMS
 794  *    idInst [I] Instance identifier
 795  *
 796  * RETURNS
 797  *    Last error code
 798  */
 799 UINT WINAPI DdeGetLastError(DWORD idInst)
 800 {
 801     DWORD               error_code;
 802     WDML_INSTANCE*      pInstance;
 803
 804     /*  First check instance
 805      */
 806     pInstance = WDML_GetInstance(idInst);
 807     if  (pInstance == NULL)
 808     {
 809         error_code = DMLERR_INVALIDPARAMETER;
 810     }
 811     else
 812     {
 813         error_code = pInstance->lastError;
 814         pInstance->lastError = 0;
 815     }
 816
 817     return error_code;
 818 }
 819
 820 /******************************************************************
 821  *              WDML_SetAllLastError
 822  *
 823  *
 824  */
 825 static void     WDML_SetAllLastError(DWORD lastError)
 826 {
 827     DWORD               threadID;
 828     WDML_INSTANCE*      pInstance;
 829     threadID = GetCurrentThreadId();
 830     pInstance = WDML_InstanceList;
 831     while (pInstance)
 832     {
 833         if (pInstance->threadID == threadID)
 834             pInstance->lastError = lastError;
 835         pInstance = pInstance->next;
 836     }
 837 }
 838
 839 /* ================================================================
 840  *
 841  *                      String management
 842  *
 843  * ================================================================ */
 844
 845
 846 /******************************************************************
 847  *              WDML_FindNode
 848  *
 849  *
 850  */
 851 static HSZNode* WDML_FindNode(WDML_INSTANCE* pInstance, HSZ hsz)
 852 {
 853     HSZNode*    pNode;
 854
 855     if (pInstance == NULL) return NULL;
 856
 857     for (pNode = pInstance->nodeList; pNode != NULL; pNode = pNode->next)
 858     {
 859         if (pNode->hsz == hsz) break;
 860     }
 861     if (!pNode) WARN("HSZ %p not found\n", hsz);
 862     return pNode;
 863 }
 864
 865 /******************************************************************
 866  *              WDML_MakeAtomFromHsz
 867  *
 868  * Creates a global atom from an existing HSZ
 869  * Generally used before sending an HSZ as an atom to a remote app
 870  */
 871 ATOM    WDML_MakeAtomFromHsz(HSZ hsz)
 872 {
 873     WCHAR nameBuffer[MAX_BUFFER_LEN];
 874
 875     if (GetAtomNameW(HSZ2ATOM(hsz), nameBuffer, MAX_BUFFER_LEN))
 876         return GlobalAddAtomW(nameBuffer);
 877     WARN("HSZ %p not found\n", hsz);
 878     return 0;
 879 }
 880
 881 /******************************************************************
 882  *              WDML_MakeHszFromAtom
 883  *
 884  * Creates a HSZ from an existing global atom
 885  * Generally used while receiving a global atom and transforming it
 886  * into an HSZ
 887  */
 888 HSZ     WDML_MakeHszFromAtom(const WDML_INSTANCE* pInstance, ATOM atom)
 889 {
 890     WCHAR nameBuffer[MAX_BUFFER_LEN];
 891
 892     if (!atom) return NULL;
 893
 894     if (GlobalGetAtomNameW(atom, nameBuffer, MAX_BUFFER_LEN))
 895     {
 896         TRACE("%x => %s\n", atom, debugstr_w(nameBuffer));
 897         return DdeCreateStringHandleW(pInstance->instanceID, nameBuffer, CP_WINUNICODE);
 898     }
 899     WARN("ATOM 0x%x not found\n", atom);
 900     return 0;
 901 }
 902
 903 /******************************************************************
 904  *              WDML_IncHSZ
 905  *
 906  *
 907  */
 908 BOOL WDML_IncHSZ(WDML_INSTANCE* pInstance, HSZ hsz)
 909 {
 910     HSZNode*    pNode;
 911
 912     pNode = WDML_FindNode(pInstance, hsz);
 913     if (!pNode) return FALSE;
 914
 915     pNode->refCount++;
 916     return TRUE;
 917 }
 918
 919 /******************************************************************************
 920  *           WDML_DecHSZ    (INTERNAL)
 921  *
 922  * Decrease the ref count of an HSZ. If it reaches 0, the node is removed from the list
 923  * of HSZ nodes
 924  * Returns -1 is the HSZ isn't found, otherwise it's the current (after --) of the ref count
 925  */
 926 BOOL WDML_DecHSZ(WDML_INSTANCE* pInstance, HSZ hsz)
 927 {
 928     HSZNode*    pPrev = NULL;
 929     HSZNode*    pCurrent;
 930
 931     for (pCurrent = pInstance->nodeList; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
 932     {
 933         /* If we found the node we were looking for and its ref count is one,
 934          * we can remove it
 935          */
 936         if (pCurrent->hsz == hsz)
 937         {
 938             if (--pCurrent->refCount == 0)
 939             {
 940                 if (pCurrent == pInstance->nodeList)
 941                 {
 942                     pInstance->nodeList = pCurrent->next;
 943                 }
 944                 else
 945                 {
 946                     pPrev->next = pCurrent->next;
 947                 }
 948                 HeapFree(GetProcessHeap(), 0, pCurrent);
 949                 DeleteAtom(HSZ2ATOM(hsz));
 950             }
 951             return TRUE;
 952         }
 953     }
 954     WARN("HSZ %p not found\n", hsz);
 955
 956     return FALSE;
 957 }
 958
 959 /******************************************************************************
 960  *            WDML_FreeAllHSZ    (INTERNAL)
 961  *
 962  * Frees up all the strings still allocated in the list and
 963  * remove all the nodes from the list of HSZ nodes.
 964  */
 965 void WDML_FreeAllHSZ(WDML_INSTANCE* pInstance)
 966 {
 967     /* Free any strings created in this instance.
 968      */
 969     while (pInstance->nodeList != NULL)
 970     {
 971         DdeFreeStringHandle(pInstance->instanceID, pInstance->nodeList->hsz);
 972     }
 973 }
 974
 975 /******************************************************************************
 976  *            InsertHSZNode    (INTERNAL)
 977  *
 978  * Insert a node to the head of the list.
 979  */
 980 static void WDML_InsertHSZNode(WDML_INSTANCE* pInstance, HSZ hsz)
 981 {
 982     if (hsz != 0)
 983     {
 984         HSZNode* pNew = NULL;
 985         /* Create a new node for this HSZ.
 986          */
 987         pNew = HeapAlloc(GetProcessHeap(), 0, sizeof(HSZNode));
 988         if (pNew != NULL)
 989         {
 990             pNew->hsz      = hsz;
 991             pNew->next     = pInstance->nodeList;
 992             pNew->refCount = 1;
 993             pInstance->nodeList = pNew;
 994         }
 995         else
 996         {
 997             ERR("Primary HSZ Node allocation failed - out of memory\n");
 998         }
 999     }
1000 }
1001
1002 /******************************************************************
1003  *              WDML_QueryString
1004  *
1005  *
1006  */
1007 static int      WDML_QueryString(WDML_INSTANCE* pInstance, HSZ hsz, LPVOID ptr, DWORD cchMax,
1008                                  int codepage)
1009 {
1010     WCHAR       pString[MAX_BUFFER_LEN];
1011     int         ret;
1012     /* If psz is null, we have to return only the length
1013      * of the string.
1014      */
1015     if (ptr == NULL)
1016     {
1017         ptr = pString;
1018         cchMax = MAX_BUFFER_LEN;
1019     }
1020
1021     /* if there is no input windows returns a NULL string */
1022     if (hsz == NULL)
1023     {
1024         CHAR *t_ptr = ptr;
1025         *t_ptr = '\0';
1026         return 1;
1027     }
1028
1029     switch (codepage)
1030     {
1031     case CP_WINANSI:
1032         ret = GetAtomNameA(HSZ2ATOM(hsz), ptr, cchMax);
1033         break;
1034     case CP_WINUNICODE:
1035         ret = GetAtomNameW(HSZ2ATOM(hsz), ptr, cchMax);
1036         break;
1037     default:
1038         ERR("Unknown code page %d\n", codepage);
1039         ret = 0;
1040     }
1041     return ret;
1042 }
1043
1044 /*****************************************************************
1045  * DdeQueryStringA [USER32.@]
1046  */
1047 DWORD WINAPI DdeQueryStringA(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, INT iCodePage)
1048 {
1049     DWORD               ret = 0;
1050     WDML_INSTANCE*      pInstance;
1051
1052     TRACE("(%d, %p, %p, %d, %d)\n", idInst, hsz, psz, cchMax, iCodePage);
1053
1054     /*  First check instance
1055      */
1056     pInstance = WDML_GetInstance(idInst);
1057     if (pInstance != NULL)
1058     {
1059         if (iCodePage == 0) iCodePage = CP_WINANSI;
1060         ret = WDML_QueryString(pInstance, hsz, psz, cchMax, iCodePage);
1061     }
1062
1063     TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
1064     return ret;
1065 }
1066
1067 /*****************************************************************
1068  * DdeQueryStringW [USER32.@]
1069  */
1070
1071 DWORD WINAPI DdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, INT iCodePage)
1072 {
1073     DWORD               ret = 0;
1074     WDML_INSTANCE*      pInstance;
1075
1076     TRACE("(%d, %p, %p, %d, %d)\n", idInst, hsz, psz, cchMax, iCodePage);
1077
1078     /*  First check instance
1079      */
1080     pInstance = WDML_GetInstance(idInst);
1081     if (pInstance != NULL)
1082     {
1083         if (iCodePage == 0) iCodePage = CP_WINUNICODE;
1084         ret = WDML_QueryString(pInstance, hsz, psz, cchMax, iCodePage);
1085     }
1086
1087     TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
1088     return ret;
1089 }
1090
1091 /******************************************************************
1092  *              DML_CreateString
1093  *
1094  *
1095  */
1096 static  HSZ     WDML_CreateString(WDML_INSTANCE* pInstance, LPCVOID ptr, int codepage)
1097 {
1098     HSZ         hsz;
1099
1100     switch (codepage)
1101     {
1102     case CP_WINANSI:
1103         hsz = ATOM2HSZ(AddAtomA(ptr));
1104         TRACE("added atom %s with HSZ %p,\n", debugstr_a(ptr), hsz);
1105         break;
1106     case CP_WINUNICODE:
1107         hsz = ATOM2HSZ(AddAtomW(ptr));
1108         TRACE("added atom %s with HSZ %p,\n", debugstr_w(ptr), hsz);
1109         break;
1110     default:
1111         ERR("Unknown code page %d\n", codepage);
1112         return 0;
1113     }
1114     WDML_InsertHSZNode(pInstance, hsz);
1115     return hsz;
1116 }
1117
1118 /*****************************************************************
1119  * DdeCreateStringHandleA [USER32.@]
1120  *
1121  * See DdeCreateStringHandleW.
1122  */
1123 HSZ WINAPI DdeCreateStringHandleA(DWORD idInst, LPCSTR psz, INT codepage)
1124 {
1125     HSZ                 hsz = 0;
1126     WDML_INSTANCE*      pInstance;
1127
1128     TRACE("(%d,%s,%d)\n", idInst, debugstr_a(psz), codepage);
1129
1130     pInstance = WDML_GetInstance(idInst);
1131     if (pInstance == NULL)
1132         WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
1133     else
1134     {
1135         if (codepage == 0) codepage = CP_WINANSI;
1136         hsz = WDML_CreateString(pInstance, psz, codepage);
1137     }
1138
1139     return hsz;
1140 }
1141
1142
1143 /******************************************************************************
1144  * DdeCreateStringHandleW [USER32.@]  Creates handle to identify string
1145  *
1146  * PARAMS
1147  *      idInst   [I] Instance identifier
1148  *      psz      [I] Pointer to string
1149  *      codepage [I] Code page identifier
1150  * RETURNS
1151  *    Success: String handle
1152  *    Failure: 0
1153  */
1154 HSZ WINAPI DdeCreateStringHandleW(DWORD idInst, LPCWSTR psz, INT codepage)
1155 {
1156     WDML_INSTANCE*      pInstance;
1157     HSZ                 hsz = 0;
1158
1159     pInstance = WDML_GetInstance(idInst);
1160     if (pInstance == NULL)
1161         WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
1162     else
1163     {
1164         if (codepage == 0) codepage = CP_WINUNICODE;
1165         hsz = WDML_CreateString(pInstance, psz, codepage);
1166     }
1167
1168     return hsz;
1169 }
1170
1171 /*****************************************************************
1172  *            DdeFreeStringHandle   (USER32.@)
1173  * RETURNS
1174  *  success: nonzero
1175  *  fail:    zero
1176  */
1177 BOOL WINAPI DdeFreeStringHandle(DWORD idInst, HSZ hsz)
1178 {
1179     WDML_INSTANCE*      pInstance;
1180     BOOL                ret = FALSE;
1181
1182     TRACE("(%d,%p):\n", idInst, hsz);
1183
1184     /*  First check instance
1185      */
1186     pInstance = WDML_GetInstance(idInst);
1187     if (pInstance)
1188         ret = WDML_DecHSZ(pInstance, hsz);
1189
1190     return ret;
1191 }
1192
1193 /*****************************************************************
1194  *            DdeKeepStringHandle  (USER32.@)
1195  *
1196  * RETURNS
1197  *  success: nonzero
1198  *  fail:    zero
1199  */
1200 BOOL WINAPI DdeKeepStringHandle(DWORD idInst, HSZ hsz)
1201 {
1202     WDML_INSTANCE*      pInstance;
1203     BOOL                ret = FALSE;
1204
1205     TRACE("(%d,%p):\n", idInst, hsz);
1206
1207     /*  First check instance
1208      */
1209     pInstance = WDML_GetInstance(idInst);
1210     if (pInstance)
1211         ret = WDML_IncHSZ(pInstance, hsz);
1212
1213     return ret;
1214 }
1215
1216 /*****************************************************************
1217  *            DdeCmpStringHandles (USER32.@)
1218  *
1219  * Compares the value of two string handles.  This comparison is
1220  * not case sensitive.
1221  *
1222  * PARAMS
1223  *  hsz1    [I] Handle to the first string
1224  *  hsz2    [I] Handle to the second string
1225  *
1226  * RETURNS
1227  *  -1 The value of hsz1 is zero or less than hsz2
1228  *  0  The values of hsz 1 and 2 are the same or both zero.
1229  *  1  The value of hsz2 is zero of less than hsz1
1230  */
1231 INT WINAPI DdeCmpStringHandles(HSZ hsz1, HSZ hsz2)
1232 {
1233     WCHAR       psz1[MAX_BUFFER_LEN];
1234     WCHAR       psz2[MAX_BUFFER_LEN];
1235     int         ret = 0;
1236     int         ret1, ret2;
1237
1238     ret1 = GetAtomNameW(HSZ2ATOM(hsz1), psz1, MAX_BUFFER_LEN);
1239     ret2 = GetAtomNameW(HSZ2ATOM(hsz2), psz2, MAX_BUFFER_LEN);
1240
1241     TRACE("(%p<%s> %p<%s>);\n", hsz1, debugstr_w(psz1), hsz2, debugstr_w(psz2));
1242
1243     /* Make sure we found both strings. */
1244     if (ret1 == 0 && ret2 == 0)
1245     {
1246         /* If both are not found, return both  "zero strings". */
1247         ret = 0;
1248     }
1249     else if (ret1 == 0)
1250     {
1251         /* If hsz1 is a not found, return hsz1 is "zero string". */
1252         ret = -1;
1253     }
1254     else if (ret2 == 0)
1255     {
1256         /* If hsz2 is a not found, return hsz2 is "zero string". */
1257         ret = 1;
1258     }
1259     else
1260     {
1261         /* Compare the two strings we got (case insensitive). */
1262         ret = lstrcmpiW(psz1, psz2);
1263         /* Since strcmp returns any number smaller than
1264          * 0 when the first string is found to be less than
1265          * the second one we must make sure we are returning
1266          * the proper values.
1267          */
1268         if (ret < 0)
1269         {
1270             ret = -1;
1271         }
1272         else if (ret > 0)
1273         {
1274             ret = 1;
1275         }
1276     }
1277
1278     return ret;
1279 }
1280
1281 /* ================================================================
1282  *
1283  *                      Data handle management
1284  *
1285  * ================================================================ */
1286
1287 /*****************************************************************
1288  *            DdeCreateDataHandle (USER32.@)
1289  */
1290 HDDEDATA WINAPI DdeCreateDataHandle(DWORD idInst, LPBYTE pSrc, DWORD cb, DWORD cbOff,
1291                                     HSZ hszItem, UINT wFmt, UINT afCmd)
1292 {
1293
1294     /* Other than check for validity we will ignore for now idInst, hszItem.
1295      * The purpose of these arguments still need to be investigated.
1296      */
1297
1298     WDML_INSTANCE*              pInstance;
1299     HGLOBAL                     hMem;
1300     LPBYTE                      pByte;
1301     DDE_DATAHANDLE_HEAD*        pDdh;
1302     WCHAR psz[MAX_BUFFER_LEN];
1303
1304     pInstance = WDML_GetInstance(idInst);
1305     if (pInstance == NULL)
1306     {
1307         WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
1308         return NULL;
1309     }
1310
1311     if (!GetAtomNameW(HSZ2ATOM(hszItem), psz, MAX_BUFFER_LEN))
1312     {
1313         psz[0] = HSZ2ATOM(hszItem);
1314         psz[1] = 0;
1315     }
1316
1317     TRACE("(%d,%p,cb %d, cbOff %d,%p <%s>,fmt %04x,%x)\n",
1318           idInst, pSrc, cb, cbOff, hszItem, debugstr_w(psz), wFmt, afCmd);
1319
1320     if (afCmd != 0 && afCmd != HDATA_APPOWNED)
1321         return 0;
1322
1323     /* we use the first 4 bytes to store the size */
1324     if (!(hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cb + cbOff + sizeof(DDE_DATAHANDLE_HEAD))))
1325     {
1326         ERR("GlobalAlloc failed\n");
1327         return 0;
1328     }
1329
1330     pDdh = GlobalLock(hMem);
1331     if (!pDdh)
1332     {
1333         GlobalFree(hMem);
1334         return 0;
1335     }
1336
1337     pDdh->cfFormat = wFmt;
1338     pDdh->bAppOwned = (afCmd == HDATA_APPOWNED);
1339
1340     pByte = (LPBYTE)(pDdh + 1);
1341     if (pSrc)
1342     {
1343         memcpy(pByte, pSrc + cbOff, cb);
1344     }
1345     GlobalUnlock(hMem);
1346
1347     TRACE("=> %p\n", hMem);
1348     return hMem;
1349 }
1350
1351 /*****************************************************************
1352  *
1353  *            DdeAddData (USER32.@)
1354  */
1355 HDDEDATA WINAPI DdeAddData(HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff)
1356 {
1357     DWORD       old_sz, new_sz;
1358     LPBYTE      pDst;
1359
1360     TRACE("(%p,%p,cb %d, cbOff %d)\n", hData, pSrc, cb, cbOff);
1361
1362     pDst = DdeAccessData(hData, &old_sz);
1363     if (!pDst) return 0;
1364
1365     new_sz = cb + cbOff;
1366     if (new_sz > old_sz)
1367     {
1368         DdeUnaccessData(hData);
1369         hData = GlobalReAlloc(hData, new_sz + sizeof(DDE_DATAHANDLE_HEAD),
1370                               GMEM_MOVEABLE | GMEM_DDESHARE);
1371         pDst = DdeAccessData(hData, &old_sz);
1372     }
1373
1374     if (!pDst) return 0;
1375
1376     memcpy(pDst + cbOff, pSrc, cb);
1377     DdeUnaccessData(hData);
1378     return hData;
1379 }
1380
1381 /******************************************************************************
1382  * DdeGetData [USER32.@]  Copies data from DDE object to local buffer
1383  *
1384  *
1385  * PARAMS
1386  * hData        [I] Handle to DDE object
1387  * pDst         [I] Pointer to destination buffer
1388  * cbMax        [I] Amount of data to copy
1389  * cbOff        [I] Offset to beginning of data
1390  *
1391  * RETURNS
1392  *    Size of memory object associated with handle
1393  */
1394 DWORD WINAPI DdeGetData(HDDEDATA hData, LPBYTE pDst, DWORD cbMax, DWORD cbOff)
1395 {
1396     DWORD   dwSize, dwRet;
1397     LPBYTE  pByte;
1398
1399     TRACE("(%p,%p,%d,%d)\n", hData, pDst, cbMax, cbOff);
1400
1401     pByte = DdeAccessData(hData, &dwSize);
1402
1403     if (pByte)
1404     {
1405         if (!pDst)
1406         {
1407             dwRet = dwSize;
1408         }
1409         else if (cbOff + cbMax < dwSize)
1410         {
1411             dwRet = cbMax;
1412         }
1413         else if (cbOff < dwSize)
1414         {
1415             dwRet = dwSize - cbOff;
1416         }
1417         else
1418         {
1419             dwRet = 0;
1420         }
1421         if (pDst && dwRet != 0)
1422         {
1423             memcpy(pDst, pByte + cbOff, dwRet);
1424         }
1425         DdeUnaccessData(hData);
1426     }
1427     else
1428     {
1429         dwRet = 0;
1430     }
1431     return dwRet;
1432 }
1433
1434 /*****************************************************************
1435  *            DdeAccessData (USER32.@)
1436  */
1437 LPBYTE WINAPI DdeAccessData(HDDEDATA hData, LPDWORD pcbDataSize)
1438 {
1439     HGLOBAL                     hMem = hData;
1440     DDE_DATAHANDLE_HEAD*        pDdh;
1441
1442     TRACE("(%p,%p)\n", hData, pcbDataSize);
1443
1444     pDdh = GlobalLock(hMem);
1445     if (pDdh == NULL)
1446     {
1447         ERR("Failed on GlobalLock(%p)\n", hMem);
1448         return 0;
1449     }
1450
1451     if (pcbDataSize != NULL)
1452     {
1453         *pcbDataSize = GlobalSize(hMem) - sizeof(DDE_DATAHANDLE_HEAD);
1454     }
1455     TRACE("=> %p (%lu) fmt %04x\n", pDdh + 1, GlobalSize(hMem) - sizeof(DDE_DATAHANDLE_HEAD), pDdh->cfFormat);
1456     return (LPBYTE)(pDdh + 1);
1457 }
1458
1459 /*****************************************************************
1460  *            DdeUnaccessData (USER32.@)
1461  */
1462 BOOL WINAPI DdeUnaccessData(HDDEDATA hData)
1463 {
1464     HGLOBAL hMem = hData;
1465
1466     TRACE("(%p)\n", hData);
1467
1468     GlobalUnlock(hMem);
1469
1470     return TRUE;
1471 }
1472
1473 /*****************************************************************
1474  *            DdeFreeDataHandle   (USER32.@)
1475  */
1476 BOOL WINAPI DdeFreeDataHandle(HDDEDATA hData)
1477 {
1478     TRACE("(%p)\n", hData);
1479     return GlobalFree(hData) == 0;
1480 }
1481
1482 /******************************************************************
1483  *              WDML_IsAppOwned
1484  *
1485  *
1486  */
1487 BOOL WDML_IsAppOwned(HDDEDATA hData)
1488 {
1489     DDE_DATAHANDLE_HEAD*        pDdh;
1490     BOOL                        ret = FALSE;
1491
1492     pDdh = GlobalLock(hData);
1493     if (pDdh != NULL)
1494     {
1495         ret = pDdh->bAppOwned;
1496         GlobalUnlock(hData);
1497     }
1498     return ret;
1499 }
1500
1501 /* ================================================================
1502  *
1503  *                  Global <=> Data handle management
1504  *
1505  * ================================================================ */
1506
1507 /* Note: we use a DDEDATA, but layout of DDEDATA, DDEADVISE and DDEPOKE structures is similar:
1508  *    offset      size
1509  *    (bytes)    (bits) comment
1510  *      0          16   bit fields for options (release, ackreq, response...)
1511  *      2          16   clipboard format
1512  *      4          ?    data to be used
1513  */
1514 HDDEDATA        WDML_Global2DataHandle(WDML_CONV* pConv, HGLOBAL hMem, WINE_DDEHEAD* p)
1515 {
1516     DDEDATA*    pDd;
1517     HDDEDATA    ret = 0;
1518     DWORD       size;
1519
1520     if (hMem)
1521     {
1522         pDd = GlobalLock(hMem);
1523         size = GlobalSize(hMem) - sizeof(WINE_DDEHEAD);
1524         if (pDd)
1525         {
1526             if (p) memcpy(p, pDd, sizeof(WINE_DDEHEAD));
1527             switch (pDd->cfFormat)
1528             {
1529             default:
1530                 FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
1531                       pDd->cfFormat, hMem);
1532                 /* fall thru */
1533             case 0:
1534             case CF_TEXT:
1535                 ret = DdeCreateDataHandle(pConv->instance->instanceID, pDd->Value, size, 0, 0, pDd->cfFormat, 0);
1536                 break;
1537             case CF_BITMAP:
1538                 if (size >= sizeof(BITMAP))
1539                 {
1540                     BITMAP*     bmp = (BITMAP*)pDd->Value;
1541                     int         count = bmp->bmWidthBytes * bmp->bmHeight * bmp->bmPlanes;
1542                     if (size >= sizeof(BITMAP) + count)
1543                     {
1544                         HBITMAP hbmp;
1545
1546                         if ((hbmp = CreateBitmap(bmp->bmWidth, bmp->bmHeight,
1547                                                  bmp->bmPlanes, bmp->bmBitsPixel,
1548                                                  pDd->Value + sizeof(BITMAP))))
1549                         {
1550                             ret = DdeCreateDataHandle(pConv->instance->instanceID, (LPBYTE)&hbmp, sizeof(hbmp),
1551                                                       0, 0, CF_BITMAP, 0);
1552                         }
1553                         else ERR("Can't create bmp\n");
1554                     }
1555                     else
1556                     {
1557                         ERR("Wrong count: %u / %d\n", size, count);
1558                     }
1559                 } else ERR("No bitmap header\n");
1560                 break;
1561             }
1562             GlobalUnlock(hMem);
1563         }
1564     }
1565     return ret;
1566 }
1567
1568 /******************************************************************
1569  *              WDML_DataHandle2Global
1570  *
1571  *
1572  */
1573 HGLOBAL WDML_DataHandle2Global(HDDEDATA hDdeData, BOOL fResponse, BOOL fRelease,
1574                                BOOL fDeferUpd, BOOL fAckReq)
1575 {
1576     DDE_DATAHANDLE_HEAD*        pDdh;
1577     DWORD                       dwSize;
1578     HGLOBAL                     hMem = 0;
1579
1580     dwSize = GlobalSize(hDdeData) - sizeof(DDE_DATAHANDLE_HEAD);
1581     pDdh = GlobalLock(hDdeData);
1582     if (dwSize && pDdh)
1583     {
1584         WINE_DDEHEAD*    wdh = NULL;
1585
1586         switch (pDdh->cfFormat)
1587         {
1588         default:
1589             FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
1590                    pDdh->cfFormat, hDdeData);
1591             /* fall thru */
1592         case 0:
1593         case CF_TEXT:
1594             hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(WINE_DDEHEAD) + dwSize);
1595             if (hMem && (wdh = GlobalLock(hMem)))
1596             {
1597                 memcpy(wdh + 1, pDdh + 1, dwSize);
1598             }
1599             break;
1600         case CF_BITMAP:
1601             if (dwSize >= sizeof(HBITMAP))
1602             {
1603                 BITMAP  bmp;
1604                 DWORD   count;
1605                 HBITMAP hbmp = *(HBITMAP*)(pDdh + 1);
1606
1607                 if (GetObjectW(hbmp, sizeof(bmp), &bmp))
1608                 {
1609                     count = bmp.bmWidthBytes * bmp.bmHeight;
1610                     hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
1611                                        sizeof(WINE_DDEHEAD) + sizeof(bmp) + count);
1612                     if (hMem && (wdh = GlobalLock(hMem)))
1613                     {
1614                         memcpy(wdh + 1, &bmp, sizeof(bmp));
1615                         GetBitmapBits(hbmp, count, ((char*)(wdh + 1)) + sizeof(bmp));
1616                     }
1617                 }
1618             }
1619             break;
1620         }
1621         if (wdh)
1622         {
1623             wdh->unused = 0;
1624             wdh->fResponse = fResponse;
1625             wdh->fRelease = fRelease;
1626             wdh->fDeferUpd = fDeferUpd;
1627             wdh->fAckReq = fAckReq;
1628             wdh->cfFormat = pDdh->cfFormat;
1629             GlobalUnlock(hMem);
1630         }
1631         GlobalUnlock(hDdeData);
1632     }
1633
1634     return hMem;
1635 }
1636
1637 /* ================================================================
1638  *
1639  *                      Server management
1640  *
1641  * ================================================================ */
1642
1643 /******************************************************************
1644  *              WDML_AddServer
1645  *
1646  *
1647  */
1648 WDML_SERVER*    WDML_AddServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTopic)
1649 {
1650     static const WCHAR fmtW[] = {'%','s','(','0','x','%','0','8','l','x',')',0};
1651     WDML_SERVER*        pServer;
1652     WCHAR               buf1[256];
1653     WCHAR               buf2[256];
1654
1655     pServer = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_SERVER));
1656     if (pServer == NULL) return NULL;
1657
1658     pServer->hszService = hszService;
1659     WDML_IncHSZ(pInstance, hszService);
1660
1661     DdeQueryStringW(pInstance->instanceID, hszService, buf1, 256, CP_WINUNICODE);
1662     snprintfW(buf2, 256, fmtW, buf1, GetCurrentProcessId());
1663     pServer->hszServiceSpec = DdeCreateStringHandleW(pInstance->instanceID, buf2, CP_WINUNICODE);
1664
1665     pServer->atomService = WDML_MakeAtomFromHsz(pServer->hszService);
1666     pServer->atomServiceSpec = WDML_MakeAtomFromHsz(pServer->hszServiceSpec);
1667
1668     pServer->filterOn = TRUE;
1669
1670     pServer->next = pInstance->servers;
1671     pInstance->servers = pServer;
1672     return pServer;
1673 }
1674
1675 /******************************************************************
1676  *              WDML_RemoveServer
1677  *
1678  *
1679  */
1680 void WDML_RemoveServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTopic)
1681 {
1682     WDML_SERVER*        pPrev = NULL;
1683     WDML_SERVER*        pServer = NULL;
1684     WDML_CONV*          pConv;
1685     WDML_CONV*          pConvNext;
1686
1687     pServer = pInstance->servers;
1688
1689     while (pServer != NULL)
1690     {
1691         if (DdeCmpStringHandles(pServer->hszService, hszService) == 0)
1692         {
1693             WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_UNREGISTER,
1694                                      pServer->atomService, pServer->atomServiceSpec);
1695             /* terminate all conversations for given topic */
1696             for (pConv = pInstance->convs[WDML_SERVER_SIDE]; pConv != NULL; pConv = pConvNext)
1697             {
1698                 pConvNext = pConv->next;
1699                 if (DdeCmpStringHandles(pConv->hszService, hszService) == 0)
1700                 {
1701                     HWND client = pConv->hwndClient, server = pConv->hwndServer;
1702                     WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
1703                     /* don't care about return code (whether client window is present or not) */
1704                     PostMessageW(client, WM_DDE_TERMINATE, (WPARAM)server, 0);
1705                 }
1706             }
1707             if (pServer == pInstance->servers)
1708             {
1709                 pInstance->servers = pServer->next;
1710             }
1711             else
1712             {
1713                 pPrev->next = pServer->next;
1714             }
1715
1716             DestroyWindow(pServer->hwndServer);
1717             WDML_DecHSZ(pInstance, pServer->hszServiceSpec);
1718             WDML_DecHSZ(pInstance, pServer->hszService);
1719
1720             GlobalDeleteAtom(pServer->atomService);
1721             GlobalDeleteAtom(pServer->atomServiceSpec);
1722
1723             HeapFree(GetProcessHeap(), 0, pServer);
1724             break;
1725         }
1726
1727         pPrev = pServer;
1728         pServer = pServer->next;
1729     }
1730 }
1731
1732 /*****************************************************************************
1733  *      WDML_FindServer
1734  *
1735  *      generic routine to return a pointer to the relevant ServiceNode
1736  *      for a given service name, or NULL if the entry does not exist
1737  *
1738  */
1739 WDML_SERVER*    WDML_FindServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTopic)
1740 {
1741     WDML_SERVER*        pServer;
1742
1743     for (pServer = pInstance->servers; pServer != NULL; pServer = pServer->next)
1744     {
1745         if (hszService == pServer->hszService)
1746         {
1747             return pServer;
1748         }
1749     }
1750     TRACE("Service name missing\n");
1751     return NULL;
1752 }
1753
1754 /* ================================================================
1755  *
1756  *              Conversation management
1757  *
1758  * ================================================================ */
1759
1760 /******************************************************************
1761  *              WDML_AddConv
1762  *
1763  *
1764  */
1765 WDML_CONV*      WDML_AddConv(WDML_INSTANCE* pInstance, WDML_SIDE side,
1766                              HSZ hszService, HSZ hszTopic, HWND hwndClient, HWND hwndServer)
1767 {
1768     WDML_CONV*  pConv;
1769
1770     /* no conversation yet, add it */
1771     pConv = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_CONV));
1772     if (!pConv) return NULL;
1773
1774     pConv->instance = pInstance;
1775     WDML_IncHSZ(pInstance, pConv->hszService = hszService);
1776     WDML_IncHSZ(pInstance, pConv->hszTopic = hszTopic);
1777     pConv->magic = WDML_CONV_MAGIC;
1778     pConv->hwndServer = hwndServer;
1779     pConv->hwndClient = hwndClient;
1780     pConv->transactions = NULL;
1781     pConv->hUser = 0;
1782     pConv->wStatus = (side == WDML_CLIENT_SIDE) ? ST_CLIENT : 0L;
1783     pConv->wStatus |= pInstance->wStatus;
1784     /* check if both side of the conversation are of the same instance */
1785     if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
1786         WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
1787     {
1788         pConv->wStatus |= ST_ISSELF;
1789     }
1790     pConv->wConvst = XST_NULL;
1791
1792     pConv->next = pInstance->convs[side];
1793     pInstance->convs[side] = pConv;
1794
1795     TRACE("pConv->wStatus %04x pInstance(%p)\n", pConv->wStatus, pInstance);
1796
1797     return pConv;
1798 }
1799
1800 /******************************************************************
1801  *              WDML_FindConv
1802  *
1803  *
1804  */
1805 WDML_CONV*      WDML_FindConv(WDML_INSTANCE* pInstance, WDML_SIDE side,
1806                               HSZ hszService, HSZ hszTopic)
1807 {
1808     WDML_CONV*  pCurrent = NULL;
1809
1810     for (pCurrent = pInstance->convs[side]; pCurrent != NULL; pCurrent = pCurrent->next)
1811     {
1812         if (DdeCmpStringHandles(pCurrent->hszService, hszService) == 0 &&
1813             DdeCmpStringHandles(pCurrent->hszTopic, hszTopic) == 0)
1814         {
1815             return pCurrent;
1816         }
1817
1818     }
1819     return NULL;
1820 }
1821
1822 /******************************************************************
1823  *              WDML_RemoveConv
1824  *
1825  *
1826  */
1827 void WDML_RemoveConv(WDML_CONV* pRef, WDML_SIDE side)
1828 {
1829     WDML_CONV*  pPrev = NULL;
1830     WDML_CONV*  pCurrent;
1831     WDML_XACT*  pXAct;
1832     WDML_XACT*  pXActNext;
1833     HWND        hWnd;
1834
1835     if (!pRef)
1836         return;
1837
1838     /* remove any pending transaction */
1839     for (pXAct = pRef->transactions; pXAct != NULL; pXAct = pXActNext)
1840     {
1841         pXActNext = pXAct->next;
1842         WDML_FreeTransaction(pRef->instance, pXAct, TRUE);
1843     }
1844
1845     WDML_RemoveAllLinks(pRef->instance, pRef, side);
1846
1847     /* FIXME: should we keep the window around ? it seems so (at least on client side
1848      * to let QueryConvInfo work after conv termination, but also to implement
1849      * DdeReconnect...
1850      */
1851     /* destroy conversation window, but first remove pConv from hWnd.
1852      * this would help the wndProc do appropriate handling upon a WM_DESTROY message
1853      */
1854     hWnd = (side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer;
1855     SetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION, 0);
1856
1857     DestroyWindow((side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer);
1858
1859     WDML_DecHSZ(pRef->instance, pRef->hszService);
1860     WDML_DecHSZ(pRef->instance, pRef->hszTopic);
1861
1862     for (pCurrent = pRef->instance->convs[side]; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
1863     {
1864         if (pCurrent == pRef)
1865         {
1866             if (pCurrent == pRef->instance->convs[side])
1867             {
1868                 pRef->instance->convs[side] = pCurrent->next;
1869             }
1870             else
1871             {
1872                 pPrev->next = pCurrent->next;
1873             }
1874             pCurrent->magic = 0;
1875             HeapFree(GetProcessHeap(), 0, pCurrent);
1876             break;
1877         }
1878     }
1879 }
1880
1881 /******************************************************************
1882  *              WDML_EnableCallback
1883  */
1884 static BOOL WDML_EnableCallback(WDML_CONV *pConv, UINT wCmd)
1885 {
1886     if (wCmd == EC_DISABLE)
1887     {
1888         pConv->wStatus |= ST_BLOCKED;
1889         TRACE("EC_DISABLE: conv %p status flags %04x\n", pConv, pConv->wStatus);
1890         return TRUE;
1891     }
1892
1893     if (wCmd == EC_QUERYWAITING)
1894         return pConv->transactions ? TRUE : FALSE;
1895
1896     if (wCmd != EC_ENABLEALL && wCmd != EC_ENABLEONE)
1897     {
1898         FIXME("Unknown command code %04x\n", wCmd);
1899         return FALSE;
1900     }
1901
1902     if (wCmd == EC_ENABLEALL)
1903     {
1904         pConv->wStatus &= ~ST_BLOCKED;
1905         TRACE("EC_ENABLEALL: conv %p status flags %04x\n", pConv, pConv->wStatus);
1906     }
1907
1908     while (pConv->transactions)
1909     {
1910         WDML_XACT *pXAct = pConv->transactions;
1911
1912         if (pConv->wStatus & ST_CLIENT)
1913         {
1914             /* transaction should be in the queue until handled */
1915             WDML_ClientHandle(pConv, pXAct, 0, NULL);
1916             WDML_UnQueueTransaction(pConv, pXAct);
1917         }
1918         else
1919         {
1920             /* transaction should be removed from the queue before handling */
1921             WDML_UnQueueTransaction(pConv, pXAct);
1922             WDML_ServerHandle(pConv, pXAct);
1923         }
1924
1925         WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1926
1927         if (wCmd == EC_ENABLEONE) break;
1928     }
1929     return TRUE;
1930 }
1931
1932 /*****************************************************************
1933  *            DdeEnableCallback (USER32.@)
1934  */
1935 BOOL WINAPI DdeEnableCallback(DWORD idInst, HCONV hConv, UINT wCmd)
1936 {
1937     BOOL ret = FALSE;
1938     WDML_CONV *pConv;
1939
1940     TRACE("(%d, %p, %04x)\n", idInst, hConv, wCmd);
1941
1942     if (hConv)
1943     {
1944         pConv = WDML_GetConv(hConv, TRUE);
1945
1946         if (pConv && pConv->instance->instanceID == idInst)
1947             ret = WDML_EnableCallback(pConv, wCmd);
1948     }
1949     else
1950     {
1951         WDML_INSTANCE *pInstance = WDML_GetInstance(idInst);
1952
1953         if (!pInstance)
1954             return FALSE;
1955
1956         TRACE("adding flags %04x to instance %p\n", wCmd, pInstance);
1957         pInstance->wStatus |= wCmd;
1958
1959         if (wCmd == EC_DISABLE)
1960         {
1961             pInstance->wStatus |= ST_BLOCKED;
1962             TRACE("EC_DISABLE: inst %p status flags %04x\n", pInstance, pInstance->wStatus);
1963         }
1964         else if (wCmd == EC_ENABLEALL)
1965         {
1966             pInstance->wStatus &= ~ST_BLOCKED;
1967             TRACE("EC_ENABLEALL: inst %p status flags %04x\n", pInstance, pInstance->wStatus);
1968         }
1969
1970         ret = TRUE;
1971
1972         for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv != NULL; pConv = pConv->next)
1973         {
1974             ret = WDML_EnableCallback(pConv, wCmd);
1975             if (ret && wCmd == EC_QUERYWAITING) break;
1976         }
1977     }
1978
1979     return ret;
1980 }
1981
1982 /******************************************************************
1983  *              WDML_GetConv
1984  *
1985  *
1986  */
1987 WDML_CONV*      WDML_GetConv(HCONV hConv, BOOL checkConnected)
1988 {
1989     WDML_CONV*  pConv = (WDML_CONV*)hConv;
1990
1991     /* FIXME: should do better checking */
1992     if (pConv == NULL || pConv->magic != WDML_CONV_MAGIC) return NULL;
1993
1994     if (!pConv->instance || pConv->instance->threadID != GetCurrentThreadId())
1995     {
1996         WARN("wrong thread ID\n");
1997         pConv->instance->lastError = DMLERR_INVALIDPARAMETER; /* FIXME: check */
1998         return NULL;
1999     }
2000
2001     if (checkConnected && !(pConv->wStatus & ST_CONNECTED))
2002     {
2003         WARN("found conv but ain't connected\n");
2004         pConv->instance->lastError = DMLERR_NO_CONV_ESTABLISHED;
2005         return NULL;
2006     }
2007
2008     return pConv;
2009 }
2010
2011 /******************************************************************
2012  *              WDML_GetConvFromWnd
2013  *
2014  *
2015  */
2016 WDML_CONV*      WDML_GetConvFromWnd(HWND hWnd)
2017 {
2018     return (WDML_CONV*)GetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION);
2019 }
2020
2021 /******************************************************************
2022  *              WDML_PostAck
2023  *
2024  *
2025  */
2026 BOOL            WDML_PostAck(WDML_CONV* pConv, WDML_SIDE side, WORD appRetCode,
2027                              BOOL fBusy, BOOL fAck, UINT_PTR pmt, LPARAM lParam, UINT oldMsg)
2028 {
2029     DDEACK      ddeAck;
2030     HWND        from, to;
2031
2032     if (side == WDML_SERVER_SIDE)
2033     {
2034         from = pConv->hwndServer;
2035         to   = pConv->hwndClient;
2036     }
2037     else
2038     {
2039         to   = pConv->hwndServer;
2040         from = pConv->hwndClient;
2041     }
2042
2043     ddeAck.bAppReturnCode = appRetCode;
2044     ddeAck.reserved       = 0;
2045     ddeAck.fBusy          = fBusy;
2046     ddeAck.fAck           = fAck;
2047
2048     TRACE("Posting a %s ack\n", ddeAck.fAck ? "positive" : "negative");
2049
2050     lParam = (lParam) ? ReuseDDElParam(lParam, oldMsg, WM_DDE_ACK, *(WORD*)&ddeAck, pmt) :
2051         PackDDElParam(WM_DDE_ACK, *(WORD*)&ddeAck, pmt);
2052     if (!PostMessageW(to, WM_DDE_ACK, (WPARAM)from, lParam))
2053     {
2054         pConv->wStatus &= ~ST_CONNECTED;
2055         pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
2056         FreeDDElParam(WM_DDE_ACK, lParam);
2057         return FALSE;
2058     }
2059     return TRUE;
2060 }
2061
2062 /*****************************************************************
2063  *            DdeSetUserHandle (USER32.@)
2064  */
2065 BOOL WINAPI DdeSetUserHandle(HCONV hConv, DWORD id, DWORD hUser)
2066 {
2067     WDML_CONV*  pConv;
2068
2069     pConv = WDML_GetConv(hConv, FALSE);
2070     if (pConv == NULL)
2071         return FALSE;
2072
2073     if (id == QID_SYNC)
2074     {
2075         pConv->hUser = hUser;
2076     }
2077     else
2078     {
2079         WDML_XACT*      pXAct;
2080
2081         pXAct = WDML_FindTransaction(pConv, id);
2082         if (pXAct)
2083         {
2084             pXAct->hUser = hUser;
2085         }
2086         else
2087         {
2088             pConv->instance->lastError = DMLERR_UNFOUND_QUEUE_ID;
2089             return  FALSE;
2090         }
2091     }
2092     return TRUE;
2093 }
2094
2095 /******************************************************************
2096  *              WDML_GetLocalConvInfo
2097  *
2098  *
2099  */
2100 static  BOOL    WDML_GetLocalConvInfo(WDML_CONV* pConv, CONVINFO* ci, DWORD id)
2101 {
2102     BOOL        ret = TRUE;
2103     WDML_LINK*  pLink;
2104     WDML_SIDE   side;
2105
2106     ci->hConvPartner = (pConv->wStatus & ST_ISLOCAL) ? (HCONV)((ULONG_PTR)pConv | 1) : 0;
2107     ci->hszSvcPartner = pConv->hszService;
2108     ci->hszServiceReq = pConv->hszService; /* FIXME: they shouldn't be the same, should they ? */
2109     ci->hszTopic = pConv->hszTopic;
2110     ci->wStatus = pConv->wStatus;
2111
2112     side = (pConv->wStatus & ST_CLIENT) ? WDML_CLIENT_SIDE : WDML_SERVER_SIDE;
2113
2114     for (pLink = pConv->instance->links[side]; pLink != NULL; pLink = pLink->next)
2115     {
2116         if (pLink->hConv == (HCONV)pConv)
2117         {
2118             ci->wStatus |= ST_ADVISE;
2119             break;
2120         }
2121     }
2122
2123     /* FIXME: non handled status flags:
2124        ST_BLOCKED
2125        ST_BLOCKNEXT
2126        ST_INLIST
2127     */
2128
2129     ci->wConvst = pConv->wConvst; /* FIXME */
2130
2131     ci->wLastError = 0; /* FIXME: note it's not the instance last error */
2132     ci->hConvList = 0;
2133     ci->ConvCtxt = pConv->convContext;
2134     if (ci->wStatus & ST_CLIENT)
2135     {
2136         ci->hwnd = pConv->hwndClient;
2137         ci->hwndPartner = pConv->hwndServer;
2138     }
2139     else
2140     {
2141         ci->hwnd = pConv->hwndServer;
2142         ci->hwndPartner = pConv->hwndClient;
2143     }
2144     if (id == QID_SYNC)
2145     {
2146         ci->hUser = pConv->hUser;
2147         ci->hszItem = 0;
2148         ci->wFmt = 0;
2149         ci->wType = 0;
2150     }
2151     else
2152     {
2153         WDML_XACT*      pXAct;
2154
2155         pXAct = WDML_FindTransaction(pConv, id);
2156         if (pXAct)
2157         {
2158             ci->hUser = pXAct->hUser;
2159             ci->hszItem = pXAct->hszItem;
2160             ci->wFmt = pXAct->wFmt;
2161             ci->wType = pXAct->wType;
2162         }
2163         else
2164         {
2165             ret = 0;
2166             pConv->instance->lastError = DMLERR_UNFOUND_QUEUE_ID;
2167         }
2168     }
2169     return ret;
2170 }
2171
2172 /******************************************************************
2173  *              DdeQueryConvInfo (USER32.@)
2174  *
2175  * FIXME: Set last DDE error on failure.
2176  */
2177 UINT WINAPI DdeQueryConvInfo(HCONV hConv, DWORD id, PCONVINFO lpConvInfo)
2178 {
2179     UINT        ret = lpConvInfo->cb;
2180     CONVINFO    ci;
2181     WDML_CONV*  pConv;
2182
2183     TRACE("(%p,%x,%p)\n", hConv, id, lpConvInfo);
2184
2185     if (!hConv)
2186     {
2187         FIXME("hConv is NULL\n");
2188         return 0;
2189     }
2190
2191     pConv = WDML_GetConv(hConv, FALSE);
2192     if (pConv != NULL)
2193     {
2194         if (!WDML_GetLocalConvInfo(pConv, &ci, id))
2195             ret = 0;
2196     }
2197     else
2198     {
2199         if ((ULONG_PTR)hConv & 1)
2200         {
2201             pConv = WDML_GetConv((HCONV)((ULONG_PTR)hConv & ~1), FALSE);
2202             if (pConv != NULL)
2203                 FIXME("Request on remote conversation information is not implemented yet\n");
2204         }
2205         ret = 0;
2206     }
2207
2208     if (ret != 0)
2209         memcpy(lpConvInfo, &ci, min((size_t)lpConvInfo->cb, sizeof(ci)));
2210     return ret;
2211 }
2212
2213 /* ================================================================
2214  *
2215  *                      Link (hot & warm) management
2216  *
2217  * ================================================================ */
2218
2219 /******************************************************************
2220  *              WDML_AddLink
2221  *
2222  *
2223  */
2224 void WDML_AddLink(WDML_INSTANCE* pInstance, HCONV hConv, WDML_SIDE side,
2225                   UINT wType, HSZ hszItem, UINT wFmt)
2226 {
2227     WDML_LINK*  pLink;
2228
2229     pLink = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_LINK));
2230     if (pLink == NULL)
2231     {
2232         ERR("OOM\n");
2233         return;
2234     }
2235
2236     pLink->hConv = hConv;
2237     pLink->transactionType = wType;
2238     WDML_IncHSZ(pInstance, pLink->hszItem = hszItem);
2239     pLink->uFmt = wFmt;
2240     pLink->next = pInstance->links[side];
2241     pInstance->links[side] = pLink;
2242 }
2243
2244 /******************************************************************
2245  *              WDML_RemoveLink
2246  *
2247  *
2248  */
2249 void WDML_RemoveLink(WDML_INSTANCE* pInstance, HCONV hConv, WDML_SIDE side,
2250                      HSZ hszItem, UINT uFmt)
2251 {
2252     WDML_LINK* pPrev = NULL;
2253     WDML_LINK* pCurrent = NULL;
2254
2255     pCurrent = pInstance->links[side];
2256
2257     while (pCurrent != NULL)
2258     {
2259         if (pCurrent->hConv == hConv &&
2260             DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
2261             pCurrent->uFmt == uFmt)
2262         {
2263             if (pCurrent == pInstance->links[side])
2264             {
2265                 pInstance->links[side] = pCurrent->next;
2266             }
2267             else
2268             {
2269                 pPrev->next = pCurrent->next;
2270             }
2271
2272             WDML_DecHSZ(pInstance, pCurrent->hszItem);
2273             HeapFree(GetProcessHeap(), 0, pCurrent);
2274             break;
2275         }
2276
2277         pPrev = pCurrent;
2278         pCurrent = pCurrent->next;
2279     }
2280 }
2281
2282 /* this function is called to remove all links related to the conv.
2283    It should be called from both client and server when terminating
2284    the conversation.
2285 */
2286 /******************************************************************
2287  *              WDML_RemoveAllLinks
2288  *
2289  *
2290  */
2291 void WDML_RemoveAllLinks(WDML_INSTANCE* pInstance, WDML_CONV* pConv, WDML_SIDE side)
2292 {
2293     WDML_LINK* pPrev = NULL;
2294     WDML_LINK* pCurrent = NULL;
2295     WDML_LINK* pNext = NULL;
2296
2297     pCurrent = pInstance->links[side];
2298
2299     while (pCurrent != NULL)
2300     {
2301         if (pCurrent->hConv == (HCONV)pConv)
2302         {
2303             if (pCurrent == pInstance->links[side])
2304             {
2305                 pInstance->links[side] = pCurrent->next;
2306                 pNext = pCurrent->next;
2307             }
2308             else
2309             {
2310                 pPrev->next = pCurrent->next;
2311                 pNext = pCurrent->next;
2312             }
2313
2314             WDML_DecHSZ(pInstance, pCurrent->hszItem);
2315
2316             HeapFree(GetProcessHeap(), 0, pCurrent);
2317             pCurrent = NULL;
2318         }
2319
2320         if (pCurrent)
2321         {
2322             pPrev = pCurrent;
2323             pCurrent = pCurrent->next;
2324         }
2325         else
2326         {
2327             pCurrent = pNext;
2328         }
2329     }
2330 }
2331
2332 /******************************************************************
2333  *              WDML_FindLink
2334  *
2335  *
2336  */
2337 WDML_LINK*      WDML_FindLink(WDML_INSTANCE* pInstance, HCONV hConv, WDML_SIDE side,
2338                               HSZ hszItem, BOOL use_fmt, UINT uFmt)
2339 {
2340     WDML_LINK*  pCurrent = NULL;
2341
2342     for (pCurrent = pInstance->links[side]; pCurrent != NULL; pCurrent = pCurrent->next)
2343     {
2344         /* we don't need to check for transaction type as it can be altered */
2345
2346         if (pCurrent->hConv == hConv &&
2347             DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
2348             (!use_fmt || pCurrent->uFmt == uFmt))
2349         {
2350             break;
2351         }
2352
2353     }
2354
2355     return pCurrent;
2356 }
2357
2358 /* ================================================================
2359  *
2360  *                      Transaction management
2361  *
2362  * ================================================================ */
2363
2364 /******************************************************************
2365  *              WDML_AllocTransaction
2366  *
2367  * Alloc a transaction structure for handling the message ddeMsg
2368  */
2369 WDML_XACT*      WDML_AllocTransaction(WDML_INSTANCE* pInstance, UINT ddeMsg,
2370                                       UINT wFmt, HSZ hszItem)
2371 {
2372     WDML_XACT*          pXAct;
2373     static WORD         tid = 1;        /* FIXME: wrap around */
2374
2375     pXAct = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_XACT));
2376     if (!pXAct)
2377     {
2378         pInstance->lastError = DMLERR_MEMORY_ERROR;
2379         return NULL;
2380     }
2381
2382     pXAct->xActID = tid++;
2383     pXAct->ddeMsg = ddeMsg;
2384     pXAct->hDdeData = 0;
2385     pXAct->hUser = 0;
2386     pXAct->next = NULL;
2387     pXAct->wType = 0;
2388     pXAct->wFmt = wFmt;
2389     if ((pXAct->hszItem = hszItem)) WDML_IncHSZ(pInstance, pXAct->hszItem);
2390     pXAct->atom = 0;
2391     pXAct->hMem = 0;
2392     pXAct->lParam = 0;
2393
2394     return pXAct;
2395 }
2396
2397 /******************************************************************
2398  *              WDML_QueueTransaction
2399  *
2400  * Adds a transaction to the list of transaction
2401  */
2402 void    WDML_QueueTransaction(WDML_CONV* pConv, WDML_XACT* pXAct)
2403 {
2404     WDML_XACT** pt;
2405
2406     /* advance to last in queue */
2407     for (pt = &pConv->transactions; *pt != NULL; pt = &(*pt)->next);
2408     *pt = pXAct;
2409 }
2410
2411 /******************************************************************
2412  *              WDML_UnQueueTransaction
2413  *
2414  *
2415  */
2416 BOOL    WDML_UnQueueTransaction(WDML_CONV* pConv, WDML_XACT*  pXAct)
2417 {
2418     WDML_XACT** pt;
2419
2420     for (pt = &pConv->transactions; *pt; pt = &(*pt)->next)
2421     {
2422         if (*pt == pXAct)
2423         {
2424             *pt = pXAct->next;
2425             return TRUE;
2426         }
2427     }
2428     return FALSE;
2429 }
2430
2431 /******************************************************************
2432  *              WDML_FreeTransaction
2433  *
2434  *
2435  */
2436 void    WDML_FreeTransaction(WDML_INSTANCE* pInstance, WDML_XACT* pXAct, BOOL doFreePmt)
2437 {
2438     /* free pmt(s) in pXAct too. check against one for not deleting TRUE return values */
2439     if (doFreePmt && (ULONG_PTR)pXAct->hMem > 1)
2440     {
2441         GlobalFree(pXAct->hMem);
2442     }
2443     if (pXAct->hszItem) WDML_DecHSZ(pInstance, pXAct->hszItem);
2444
2445     HeapFree(GetProcessHeap(), 0, pXAct);
2446 }
2447
2448 /******************************************************************
2449  *              WDML_FindTransaction
2450  *
2451  *
2452  */
2453 WDML_XACT*      WDML_FindTransaction(WDML_CONV* pConv, DWORD tid)
2454 {
2455     WDML_XACT* pXAct;
2456
2457     tid = HIWORD(tid);
2458     for (pXAct = pConv->transactions; pXAct; pXAct = pXAct->next)
2459     {
2460         if (pXAct->xActID == tid)
2461             break;
2462     }
2463     return pXAct;
2464 }
2465
2466 /* ================================================================
2467  *
2468  *         Information broadcast across DDEML implementations
2469  *
2470  * ================================================================ */
2471
2472 struct tagWDML_BroadcastPmt
2473 {
2474     LPCWSTR     clsName;
2475     UINT        uMsg;
2476     WPARAM      wParam;
2477     LPARAM      lParam;
2478 };
2479
2480 /******************************************************************
2481  *              WDML_BroadcastEnumProc
2482  *
2483  *
2484  */
2485 static  BOOL CALLBACK WDML_BroadcastEnumProc(HWND hWnd, LPARAM lParam)
2486 {
2487     struct tagWDML_BroadcastPmt*        s = (struct tagWDML_BroadcastPmt*)lParam;
2488     WCHAR                               buffer[128];
2489
2490     if (GetClassNameW(hWnd, buffer, 128) > 0 &&
2491         lstrcmpiW(buffer, s->clsName) == 0)
2492     {
2493         PostMessageW(hWnd, s->uMsg, s->wParam, s->lParam);
2494     }
2495     return TRUE;
2496 }
2497
2498 /******************************************************************
2499  *              WDML_BroadcastDDEWindows
2500  *
2501  *
2502  */
2503 void WDML_BroadcastDDEWindows(LPCWSTR clsName, UINT uMsg, WPARAM wParam, LPARAM lParam)
2504 {
2505     struct tagWDML_BroadcastPmt s;
2506
2507     s.clsName = clsName;
2508     s.uMsg    = uMsg;
2509     s.wParam  = wParam;
2510     s.lParam  = lParam;
2511     EnumWindows(WDML_BroadcastEnumProc, (LPARAM)&s);
2512 }