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