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)
 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->nodeList = NULL; /* node will be added later */
 381     pInstance->monitorFlags = afCmd & MF_MASK;
 382     pInstance->wStatus = 0;
 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 %X\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(ULONG_PTR);
 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         RegisterClassExW(&wndclass);
 496
 497         pInstance->hwndEvent = CreateWindowW(WDML_szEventClass, NULL,
 498                                                 WS_POPUP, 0, 0, 0, 0,
 499                                                 0, 0, 0, 0);
 500
 501         SetWindowLongPtrW(pInstance->hwndEvent, GWL_WDML_INSTANCE, (ULONG_PTR)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%x,%d): stub\n", pidInst, pfnCallback, afCmd, ulRes);
 509
 510         EnterCriticalSection(&WDML_CritSect);
 511
 512         if (WDML_InstanceList == NULL)
 513         {
 514             ret = DMLERR_INVALIDPARAMETER;
 515             goto theError;
 516         }
 517         /* can't reinitialise if we have initialised nothing !! */
 518         reference_inst = WDML_InstanceList;
 519         /* must first check if we have been given a valid instance to re-initialise !!  how do we do that ? */
 520         /*
 521          *      MS allows initialisation without specifying a callback, should we allow addition of the
 522          *      callback by a later call to initialise ? - if so this lot will have to change
 523          */
 524         while (reference_inst->next != NULL)
 525         {
 526             if (*pidInst == reference_inst->instanceID && pfnCallback == reference_inst->callback)
 527             {
 528                 /* Check 1 - cannot change client-only mode if set via APPCMD_CLIENTONLY */
 529
 530                 if (reference_inst->clientOnly)
 531                 {
 532                     if  ((reference_inst->CBFflags & CBF_FAIL_ALLSVRXACTIONS) != CBF_FAIL_ALLSVRXACTIONS)
 533                     {
 534                                 /* i.e. Was set to Client-only and through APPCMD_CLIENTONLY */
 535
 536                         if (!(afCmd & APPCMD_CLIENTONLY))
 537                         {
 538                             ret = DMLERR_INVALIDPARAMETER;
 539                             goto theError;
 540                         }
 541                     }
 542                 }
 543                 /* Check 2 - cannot change monitor modes */
 544
 545                 if (pInstance->monitor != reference_inst->monitor)
 546                 {
 547                     ret = DMLERR_INVALIDPARAMETER;
 548                     goto theError;
 549                 }
 550
 551                 /* Check 3 - trying to set Client-only via APPCMD when not set so previously */
 552
 553                 if ((afCmd&APPCMD_CLIENTONLY) && !reference_inst->clientOnly)
 554                 {
 555                     ret = DMLERR_INVALIDPARAMETER;
 556                     goto theError;
 557                 }
 558                 break;
 559             }
 560             reference_inst = reference_inst->next;
 561         }
 562         if (reference_inst->next == NULL)
 563         {
 564             ret = DMLERR_INVALIDPARAMETER;
 565             goto theError;
 566         }
 567         /* All checked - change relevant flags */
 568
 569         reference_inst->CBFflags = pInstance->CBFflags;
 570         reference_inst->clientOnly = pInstance->clientOnly;
 571         reference_inst->monitorFlags = pInstance->monitorFlags;
 572
 573         HeapFree(GetProcessHeap(), 0, pInstance); /* finished - release heap space used as work store */
 574
 575         LeaveCriticalSection(&WDML_CritSect);
 576     }
 577
 578     return DMLERR_NO_ERROR;
 579  theError:
 580     HeapFree(GetProcessHeap(), 0, pInstance);
 581     LeaveCriticalSection(&WDML_CritSect);
 582     return ret;
 583 }
 584
 585 /******************************************************************************
 586  *            DdeInitializeA   (USER32.@)
 587  *
 588  * See DdeInitializeW.
 589  */
 590 UINT WINAPI DdeInitializeA(LPDWORD pidInst, PFNCALLBACK pfnCallback,
 591                            DWORD afCmd, DWORD ulRes)
 592 {
 593     return WDML_Initialize(pidInst, pfnCallback, afCmd, ulRes, 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);
 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("(%d)\n", idInst);
 636
 637     /*  First check instance
 638      */
 639     pInstance = WDML_GetInstance(idInst);
 640     if (pInstance == NULL)
 641     {
 642         /*
 643          *      Needs something here to record NOT_INITIALIZED ready for DdeGetLastError
 644          */
 645         return FALSE;
 646     }
 647
 648     /* first terminate all conversations client side
 649      * this shall close existing links...
 650      */
 651     for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv != NULL; pConv = pConvNext)
 652     {
 653         pConvNext = pConv->next;
 654         DdeDisconnect((HCONV)pConv);
 655     }
 656     if (pInstance->convs[WDML_CLIENT_SIDE])
 657         FIXME("still pending conversations\n");
 658
 659     /* then unregister all known service names */
 660     DdeNameService(idInst, 0, 0, DNS_UNREGISTER);
 661
 662     /* Free the nodes that were not freed by this instance
 663      * and remove the nodes from the list of HSZ nodes.
 664      */
 665     WDML_FreeAllHSZ(pInstance);
 666
 667     DestroyWindow(pInstance->hwndEvent);
 668
 669     /* OK now delete the instance handle itself */
 670
 671     if (WDML_InstanceList == pInstance)
 672     {
 673         /* special case - the first/only entry */
 674         WDML_InstanceList = pInstance->next;
 675     }
 676     else
 677     {
 678         /* general case, remove entry */
 679         WDML_INSTANCE*  inst;
 680
 681         for (inst = WDML_InstanceList; inst->next != pInstance; inst = inst->next);
 682         inst->next = pInstance->next;
 683     }
 684     /* release the heap entry
 685      */
 686     HeapFree(GetProcessHeap(), 0, pInstance);
 687
 688     return TRUE;
 689 }
 690
 691 /******************************************************************
 692  *              WDML_NotifyThreadExit
 693  *
 694  *
 695  */
 696 void WDML_NotifyThreadDetach(void)
 697 {
 698     WDML_INSTANCE*      pInstance;
 699     WDML_INSTANCE*      next;
 700     DWORD               tid = GetCurrentThreadId();
 701
 702     EnterCriticalSection(&WDML_CritSect);
 703     for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = next)
 704     {
 705         next = pInstance->next;
 706         if (pInstance->threadID == tid)
 707         {
 708             LeaveCriticalSection(&WDML_CritSect);
 709             DdeUninitialize(pInstance->instanceID);
 710             EnterCriticalSection(&WDML_CritSect);
 711         }
 712     }
 713     LeaveCriticalSection(&WDML_CritSect);
 714 }
 715
 716 /******************************************************************
 717  *              WDML_InvokeCallback
 718  *
 719  *
 720  */
 721 HDDEDATA        WDML_InvokeCallback(WDML_INSTANCE* pInstance, UINT uType, UINT uFmt, HCONV hConv,
 722                                     HSZ hsz1, HSZ hsz2, HDDEDATA hdata,
 723                                     ULONG_PTR dwData1, ULONG_PTR dwData2)
 724 {
 725     HDDEDATA    ret;
 726
 727     if (pInstance == NULL)
 728         return NULL;
 729
 730     TRACE("invoking CB[%p] (%x %x %p %p %p %p %lx %lx)\n",
 731           pInstance->callback, uType, uFmt,
 732           hConv, hsz1, hsz2, hdata, dwData1, dwData2);
 733     ret = pInstance->callback(uType, uFmt, hConv, hsz1, hsz2, hdata, dwData1, dwData2);
 734     TRACE("done => %p\n", ret);
 735     return ret;
 736 }
 737
 738 /*****************************************************************************
 739  *      WDML_GetInstance
 740  *
 741  *      generic routine to return a pointer to the relevant DDE_HANDLE_ENTRY
 742  *      for an instance Id, or NULL if the entry does not exist
 743  *
 744  */
 745 WDML_INSTANCE*  WDML_GetInstance(DWORD instId)
 746 {
 747     WDML_INSTANCE*      pInstance;
 748
 749     EnterCriticalSection(&WDML_CritSect);
 750
 751     for (pInstance = WDML_InstanceList; pInstance != NULL; pInstance = pInstance->next)
 752     {
 753         if (pInstance->instanceID == instId)
 754         {
 755             if (GetCurrentThreadId() != pInstance->threadID)
 756             {
 757                 FIXME("Tried to get instance from wrong thread\n");
 758                 continue;
 759             }
 760             break;
 761         }
 762     }
 763
 764     LeaveCriticalSection(&WDML_CritSect);
 765
 766     if (!pInstance)
 767         WARN("Instance entry missing for id %04x\n", instId);
 768     return pInstance;
 769 }
 770
 771 /******************************************************************
 772  *              WDML_GetInstanceFromWnd
 773  *
 774  *
 775  */
 776 WDML_INSTANCE*  WDML_GetInstanceFromWnd(HWND hWnd)
 777 {
 778     return (WDML_INSTANCE*)GetWindowLongPtrW(hWnd, GWL_WDML_INSTANCE);
 779 }
 780
 781 /******************************************************************************
 782  * DdeGetLastError [USER32.@]  Gets most recent error code
 783  *
 784  * PARAMS
 785  *    idInst [I] Instance identifier
 786  *
 787  * RETURNS
 788  *    Last error code
 789  */
 790 UINT WINAPI DdeGetLastError(DWORD idInst)
 791 {
 792     DWORD               error_code;
 793     WDML_INSTANCE*      pInstance;
 794
 795     /*  First check instance
 796      */
 797     pInstance = WDML_GetInstance(idInst);
 798     if  (pInstance == NULL)
 799     {
 800         error_code = DMLERR_INVALIDPARAMETER;
 801     }
 802     else
 803     {
 804         error_code = pInstance->lastError;
 805         pInstance->lastError = 0;
 806     }
 807
 808     return error_code;
 809 }
 810
 811 /******************************************************************
 812  *              WDML_SetAllLastError
 813  *
 814  *
 815  */
 816 static void     WDML_SetAllLastError(DWORD lastError)
 817 {
 818     DWORD               threadID;
 819     WDML_INSTANCE*      pInstance;
 820     threadID = GetCurrentThreadId();
 821     pInstance = WDML_InstanceList;
 822     while (pInstance)
 823     {
 824         if (pInstance->threadID == threadID)
 825             pInstance->lastError = lastError;
 826         pInstance = pInstance->next;
 827     }
 828 }
 829
 830 /* ================================================================
 831  *
 832  *                      String management
 833  *
 834  * ================================================================ */
 835
 836
 837 /******************************************************************
 838  *              WDML_FindNode
 839  *
 840  *
 841  */
 842 static HSZNode* WDML_FindNode(WDML_INSTANCE* pInstance, HSZ hsz)
 843 {
 844     HSZNode*    pNode;
 845
 846     if (pInstance == NULL) return NULL;
 847
 848     for (pNode = pInstance->nodeList; pNode != NULL; pNode = pNode->next)
 849     {
 850         if (pNode->hsz == hsz) break;
 851     }
 852     if (!pNode) WARN("HSZ %p not found\n", hsz);
 853     return pNode;
 854 }
 855
 856 /******************************************************************
 857  *              WDML_MakeAtomFromHsz
 858  *
 859  * Creates a global atom from an existing HSZ
 860  * Generally used before sending an HSZ as an atom to a remote app
 861  */
 862 ATOM    WDML_MakeAtomFromHsz(HSZ hsz)
 863 {
 864     WCHAR nameBuffer[MAX_BUFFER_LEN];
 865
 866     if (GetAtomNameW(HSZ2ATOM(hsz), nameBuffer, MAX_BUFFER_LEN))
 867         return GlobalAddAtomW(nameBuffer);
 868     WARN("HSZ %p not found\n", hsz);
 869     return 0;
 870 }
 871
 872 /******************************************************************
 873  *              WDML_MakeHszFromAtom
 874  *
 875  * Creates a HSZ from an existing global atom
 876  * Generally used while receiving a global atom and transforming it
 877  * into an HSZ
 878  */
 879 HSZ     WDML_MakeHszFromAtom(const WDML_INSTANCE* pInstance, ATOM atom)
 880 {
 881     WCHAR nameBuffer[MAX_BUFFER_LEN];
 882
 883     if (!atom) return NULL;
 884
 885     if (GlobalGetAtomNameW(atom, nameBuffer, MAX_BUFFER_LEN))
 886     {
 887         TRACE("%x => %s\n", atom, debugstr_w(nameBuffer));
 888         return DdeCreateStringHandleW(pInstance->instanceID, nameBuffer, CP_WINUNICODE);
 889     }
 890     WARN("ATOM 0x%x not found\n", atom);
 891     return 0;
 892 }
 893
 894 /******************************************************************
 895  *              WDML_IncHSZ
 896  *
 897  *
 898  */
 899 BOOL WDML_IncHSZ(WDML_INSTANCE* pInstance, HSZ hsz)
 900 {
 901     HSZNode*    pNode;
 902
 903     pNode = WDML_FindNode(pInstance, hsz);
 904     if (!pNode) return FALSE;
 905
 906     pNode->refCount++;
 907     return TRUE;
 908 }
 909
 910 /******************************************************************************
 911  *           WDML_DecHSZ    (INTERNAL)
 912  *
 913  * Decrease the ref count of an HSZ. If it reaches 0, the node is removed from the list
 914  * of HSZ nodes
 915  * Returns -1 is the HSZ isn't found, otherwise it's the current (after --) of the ref count
 916  */
 917 BOOL WDML_DecHSZ(WDML_INSTANCE* pInstance, HSZ hsz)
 918 {
 919     HSZNode*    pPrev = NULL;
 920     HSZNode*    pCurrent;
 921
 922     for (pCurrent = pInstance->nodeList; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
 923     {
 924         /* If we found the node we were looking for and its ref count is one,
 925          * we can remove it
 926          */
 927         if (pCurrent->hsz == hsz)
 928         {
 929             if (--pCurrent->refCount == 0)
 930             {
 931                 if (pCurrent == pInstance->nodeList)
 932                 {
 933                     pInstance->nodeList = pCurrent->next;
 934                 }
 935                 else
 936                 {
 937                     pPrev->next = pCurrent->next;
 938                 }
 939                 HeapFree(GetProcessHeap(), 0, pCurrent);
 940                 DeleteAtom(HSZ2ATOM(hsz));
 941             }
 942             return TRUE;
 943         }
 944     }
 945     WARN("HSZ %p not found\n", hsz);
 946
 947     return FALSE;
 948 }
 949
 950 /******************************************************************************
 951  *            WDML_FreeAllHSZ    (INTERNAL)
 952  *
 953  * Frees up all the strings still allocated in the list and
 954  * remove all the nodes from the list of HSZ nodes.
 955  */
 956 void WDML_FreeAllHSZ(WDML_INSTANCE* pInstance)
 957 {
 958     /* Free any strings created in this instance.
 959      */
 960     while (pInstance->nodeList != NULL)
 961     {
 962         DdeFreeStringHandle(pInstance->instanceID, pInstance->nodeList->hsz);
 963     }
 964 }
 965
 966 /******************************************************************************
 967  *            InsertHSZNode    (INTERNAL)
 968  *
 969  * Insert a node to the head of the list.
 970  */
 971 static void WDML_InsertHSZNode(WDML_INSTANCE* pInstance, HSZ hsz)
 972 {
 973     if (hsz != 0)
 974     {
 975         HSZNode* pNew = NULL;
 976         /* Create a new node for this HSZ.
 977          */
 978         pNew = HeapAlloc(GetProcessHeap(), 0, sizeof(HSZNode));
 979         if (pNew != NULL)
 980         {
 981             pNew->hsz      = hsz;
 982             pNew->next     = pInstance->nodeList;
 983             pNew->refCount = 1;
 984             pInstance->nodeList = pNew;
 985         }
 986         else
 987         {
 988             ERR("Primary HSZ Node allocation failed - out of memory\n");
 989         }
 990     }
 991 }
 992
 993 /******************************************************************
 994  *              WDML_QueryString
 995  *
 996  *
 997  */
 998 static int      WDML_QueryString(WDML_INSTANCE* pInstance, HSZ hsz, LPVOID ptr, DWORD cchMax,
 999                                  int codepage)
1000 {
1001     WCHAR       pString[MAX_BUFFER_LEN];
1002     int         ret;
1003     /* If psz is null, we have to return only the length
1004      * of the string.
1005      */
1006     if (ptr == NULL)
1007     {
1008         ptr = pString;
1009         cchMax = MAX_BUFFER_LEN;
1010     }
1011
1012     /* if there is no input windows returns a NULL string */
1013     if (hsz == NULL)
1014     {
1015         CHAR *t_ptr = ptr;
1016         *t_ptr = '\0';
1017         return 1;
1018     }
1019
1020     switch (codepage)
1021     {
1022     case CP_WINANSI:
1023         ret = GetAtomNameA(HSZ2ATOM(hsz), ptr, cchMax);
1024         break;
1025     case CP_WINUNICODE:
1026         ret = GetAtomNameW(HSZ2ATOM(hsz), ptr, cchMax);
1027         break;
1028     default:
1029         ERR("Unknown code page %d\n", codepage);
1030         ret = 0;
1031     }
1032     return ret;
1033 }
1034
1035 /*****************************************************************
1036  * DdeQueryStringA [USER32.@]
1037  */
1038 DWORD WINAPI DdeQueryStringA(DWORD idInst, HSZ hsz, LPSTR psz, DWORD cchMax, INT iCodePage)
1039 {
1040     DWORD               ret = 0;
1041     WDML_INSTANCE*      pInstance;
1042
1043     TRACE("(%d, %p, %p, %d, %d)\n", idInst, hsz, psz, cchMax, iCodePage);
1044
1045     /*  First check instance
1046      */
1047     pInstance = WDML_GetInstance(idInst);
1048     if (pInstance != NULL)
1049     {
1050         if (iCodePage == 0) iCodePage = CP_WINANSI;
1051         ret = WDML_QueryString(pInstance, hsz, psz, cchMax, iCodePage);
1052     }
1053
1054     TRACE("returning %d (%s)\n", ret, debugstr_a(psz));
1055     return ret;
1056 }
1057
1058 /*****************************************************************
1059  * DdeQueryStringW [USER32.@]
1060  */
1061
1062 DWORD WINAPI DdeQueryStringW(DWORD idInst, HSZ hsz, LPWSTR psz, DWORD cchMax, INT iCodePage)
1063 {
1064     DWORD               ret = 0;
1065     WDML_INSTANCE*      pInstance;
1066
1067     TRACE("(%d, %p, %p, %d, %d)\n", idInst, hsz, psz, cchMax, iCodePage);
1068
1069     /*  First check instance
1070      */
1071     pInstance = WDML_GetInstance(idInst);
1072     if (pInstance != NULL)
1073     {
1074         if (iCodePage == 0) iCodePage = CP_WINUNICODE;
1075         ret = WDML_QueryString(pInstance, hsz, psz, cchMax, iCodePage);
1076     }
1077
1078     TRACE("returning %d (%s)\n", ret, debugstr_w(psz));
1079     return ret;
1080 }
1081
1082 /******************************************************************
1083  *              DML_CreateString
1084  *
1085  *
1086  */
1087 static  HSZ     WDML_CreateString(WDML_INSTANCE* pInstance, LPCVOID ptr, int codepage)
1088 {
1089     HSZ         hsz;
1090
1091     switch (codepage)
1092     {
1093     case CP_WINANSI:
1094         hsz = ATOM2HSZ(AddAtomA(ptr));
1095         TRACE("added atom %s with HSZ %p,\n", debugstr_a(ptr), hsz);
1096         break;
1097     case CP_WINUNICODE:
1098         hsz = ATOM2HSZ(AddAtomW(ptr));
1099         TRACE("added atom %s with HSZ %p,\n", debugstr_w(ptr), hsz);
1100         break;
1101     default:
1102         ERR("Unknown code page %d\n", codepage);
1103         return 0;
1104     }
1105     WDML_InsertHSZNode(pInstance, hsz);
1106     return hsz;
1107 }
1108
1109 /*****************************************************************
1110  * DdeCreateStringHandleA [USER32.@]
1111  *
1112  * See DdeCreateStringHandleW.
1113  */
1114 HSZ WINAPI DdeCreateStringHandleA(DWORD idInst, LPCSTR psz, INT codepage)
1115 {
1116     HSZ                 hsz = 0;
1117     WDML_INSTANCE*      pInstance;
1118
1119     TRACE("(%d,%s,%d)\n", idInst, debugstr_a(psz), codepage);
1120
1121     pInstance = WDML_GetInstance(idInst);
1122     if (pInstance == NULL)
1123         WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
1124     else
1125     {
1126         if (codepage == 0) codepage = CP_WINANSI;
1127         hsz = WDML_CreateString(pInstance, psz, codepage);
1128     }
1129
1130     return hsz;
1131 }
1132
1133
1134 /******************************************************************************
1135  * DdeCreateStringHandleW [USER32.@]  Creates handle to identify string
1136  *
1137  * PARAMS
1138  *      idInst   [I] Instance identifier
1139  *      psz      [I] Pointer to string
1140  *      codepage [I] Code page identifier
1141  * RETURNS
1142  *    Success: String handle
1143  *    Failure: 0
1144  */
1145 HSZ WINAPI DdeCreateStringHandleW(DWORD idInst, LPCWSTR psz, INT codepage)
1146 {
1147     WDML_INSTANCE*      pInstance;
1148     HSZ                 hsz = 0;
1149
1150     pInstance = WDML_GetInstance(idInst);
1151     if (pInstance == NULL)
1152         WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
1153     else
1154     {
1155         if (codepage == 0) codepage = CP_WINUNICODE;
1156         hsz = WDML_CreateString(pInstance, psz, codepage);
1157     }
1158
1159     return hsz;
1160 }
1161
1162 /*****************************************************************
1163  *            DdeFreeStringHandle   (USER32.@)
1164  * RETURNS
1165  *  success: nonzero
1166  *  fail:    zero
1167  */
1168 BOOL WINAPI DdeFreeStringHandle(DWORD idInst, HSZ hsz)
1169 {
1170     WDML_INSTANCE*      pInstance;
1171     BOOL                ret = FALSE;
1172
1173     TRACE("(%d,%p):\n", idInst, hsz);
1174
1175     /*  First check instance
1176      */
1177     pInstance = WDML_GetInstance(idInst);
1178     if (pInstance)
1179         ret = WDML_DecHSZ(pInstance, hsz);
1180
1181     return ret;
1182 }
1183
1184 /*****************************************************************
1185  *            DdeKeepStringHandle  (USER32.@)
1186  *
1187  * RETURNS
1188  *  success: nonzero
1189  *  fail:    zero
1190  */
1191 BOOL WINAPI DdeKeepStringHandle(DWORD idInst, HSZ hsz)
1192 {
1193     WDML_INSTANCE*      pInstance;
1194     BOOL                ret = FALSE;
1195
1196     TRACE("(%d,%p):\n", idInst, hsz);
1197
1198     /*  First check instance
1199      */
1200     pInstance = WDML_GetInstance(idInst);
1201     if (pInstance)
1202         ret = WDML_IncHSZ(pInstance, hsz);
1203
1204     return ret;
1205 }
1206
1207 /*****************************************************************
1208  *            DdeCmpStringHandles (USER32.@)
1209  *
1210  * Compares the value of two string handles.  This comparison is
1211  * not case sensitive.
1212  *
1213  * PARAMS
1214  *  hsz1    [I] Handle to the first string
1215  *  hsz2    [I] Handle to the second string
1216  *
1217  * RETURNS
1218  *  -1 The value of hsz1 is zero or less than hsz2
1219  *  0  The values of hsz 1 and 2 are the same or both zero.
1220  *  1  The value of hsz2 is zero of less than hsz1
1221  */
1222 INT WINAPI DdeCmpStringHandles(HSZ hsz1, HSZ hsz2)
1223 {
1224     WCHAR       psz1[MAX_BUFFER_LEN];
1225     WCHAR       psz2[MAX_BUFFER_LEN];
1226     int         ret = 0;
1227     int         ret1, ret2;
1228
1229     ret1 = GetAtomNameW(HSZ2ATOM(hsz1), psz1, MAX_BUFFER_LEN);
1230     ret2 = GetAtomNameW(HSZ2ATOM(hsz2), psz2, MAX_BUFFER_LEN);
1231
1232     TRACE("(%p<%s> %p<%s>);\n", hsz1, debugstr_w(psz1), hsz2, debugstr_w(psz2));
1233
1234     /* Make sure we found both strings. */
1235     if (ret1 == 0 && ret2 == 0)
1236     {
1237         /* If both are not found, return both  "zero strings". */
1238         ret = 0;
1239     }
1240     else if (ret1 == 0)
1241     {
1242         /* If hsz1 is a not found, return hsz1 is "zero string". */
1243         ret = -1;
1244     }
1245     else if (ret2 == 0)
1246     {
1247         /* If hsz2 is a not found, return hsz2 is "zero string". */
1248         ret = 1;
1249     }
1250     else
1251     {
1252         /* Compare the two strings we got (case insensitive). */
1253         ret = lstrcmpiW(psz1, psz2);
1254         /* Since strcmp returns any number smaller than
1255          * 0 when the first string is found to be less than
1256          * the second one we must make sure we are returning
1257          * the proper values.
1258          */
1259         if (ret < 0)
1260         {
1261             ret = -1;
1262         }
1263         else if (ret > 0)
1264         {
1265             ret = 1;
1266         }
1267     }
1268
1269     return ret;
1270 }
1271
1272 /* ================================================================
1273  *
1274  *                      Data handle management
1275  *
1276  * ================================================================ */
1277
1278 /*****************************************************************
1279  *            DdeCreateDataHandle (USER32.@)
1280  */
1281 HDDEDATA WINAPI DdeCreateDataHandle(DWORD idInst, LPBYTE pSrc, DWORD cb, DWORD cbOff,
1282                                     HSZ hszItem, UINT wFmt, UINT afCmd)
1283 {
1284
1285     /* Other than check for validity we will ignore for now idInst, hszItem.
1286      * The purpose of these arguments still need to be investigated.
1287      */
1288
1289     WDML_INSTANCE*              pInstance;
1290     HGLOBAL                     hMem;
1291     LPBYTE                      pByte;
1292     DDE_DATAHANDLE_HEAD*        pDdh;
1293     WCHAR psz[MAX_BUFFER_LEN];
1294
1295     pInstance = WDML_GetInstance(idInst);
1296     if (pInstance == NULL)
1297     {
1298         WDML_SetAllLastError(DMLERR_INVALIDPARAMETER);
1299         return NULL;
1300     }
1301
1302     if (!GetAtomNameW(HSZ2ATOM(hszItem), psz, MAX_BUFFER_LEN))
1303     {
1304         psz[0] = HSZ2ATOM(hszItem);
1305         psz[1] = 0;
1306     }
1307
1308     TRACE("(%d,%p,cb %d, cbOff %d,%p <%s>,fmt %04x,%x)\n",
1309           idInst, pSrc, cb, cbOff, hszItem, debugstr_w(psz), wFmt, afCmd);
1310
1311     if (afCmd != 0 && afCmd != HDATA_APPOWNED)
1312         return 0;
1313
1314     /* we use the first 4 bytes to store the size */
1315     if (!(hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, cb + cbOff + sizeof(DDE_DATAHANDLE_HEAD))))
1316     {
1317         ERR("GlobalAlloc failed\n");
1318         return 0;
1319     }
1320
1321     pDdh = GlobalLock(hMem);
1322     if (!pDdh)
1323     {
1324         GlobalFree(hMem);
1325         return 0;
1326     }
1327
1328     pDdh->cfFormat = wFmt;
1329     pDdh->bAppOwned = (afCmd == HDATA_APPOWNED);
1330
1331     pByte = (LPBYTE)(pDdh + 1);
1332     if (pSrc)
1333     {
1334         memcpy(pByte, pSrc + cbOff, cb);
1335     }
1336     GlobalUnlock(hMem);
1337
1338     TRACE("=> %p\n", hMem);
1339     return hMem;
1340 }
1341
1342 /*****************************************************************
1343  *
1344  *            DdeAddData (USER32.@)
1345  */
1346 HDDEDATA WINAPI DdeAddData(HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff)
1347 {
1348     DWORD       old_sz, new_sz;
1349     LPBYTE      pDst;
1350
1351     TRACE("(%p,%p,cb %d, cbOff %d)\n", hData, pSrc, cb, cbOff);
1352
1353     pDst = DdeAccessData(hData, &old_sz);
1354     if (!pDst) return 0;
1355
1356     new_sz = cb + cbOff;
1357     if (new_sz > old_sz)
1358     {
1359         DdeUnaccessData(hData);
1360         hData = GlobalReAlloc(hData, new_sz + sizeof(DDE_DATAHANDLE_HEAD),
1361                               GMEM_MOVEABLE | GMEM_DDESHARE);
1362         pDst = DdeAccessData(hData, &old_sz);
1363     }
1364
1365     if (!pDst) return 0;
1366
1367     memcpy(pDst + cbOff, pSrc, cb);
1368     DdeUnaccessData(hData);
1369     return hData;
1370 }
1371
1372 /******************************************************************************
1373  * DdeGetData [USER32.@]  Copies data from DDE object to local buffer
1374  *
1375  *
1376  * PARAMS
1377  * hData        [I] Handle to DDE object
1378  * pDst         [I] Pointer to destination buffer
1379  * cbMax        [I] Amount of data to copy
1380  * cbOff        [I] Offset to beginning of data
1381  *
1382  * RETURNS
1383  *    Size of memory object associated with handle
1384  */
1385 DWORD WINAPI DdeGetData(HDDEDATA hData, LPBYTE pDst, DWORD cbMax, DWORD cbOff)
1386 {
1387     DWORD   dwSize, dwRet;
1388     LPBYTE  pByte;
1389
1390     TRACE("(%p,%p,%d,%d)\n", hData, pDst, cbMax, cbOff);
1391
1392     pByte = DdeAccessData(hData, &dwSize);
1393
1394     if (pByte)
1395     {
1396         if (!pDst)
1397         {
1398             dwRet = dwSize;
1399         }
1400         else if (cbOff + cbMax < dwSize)
1401         {
1402             dwRet = cbMax;
1403         }
1404         else if (cbOff < dwSize)
1405         {
1406             dwRet = dwSize - cbOff;
1407         }
1408         else
1409         {
1410             dwRet = 0;
1411         }
1412         if (pDst && dwRet != 0)
1413         {
1414             memcpy(pDst, pByte + cbOff, dwRet);
1415         }
1416         DdeUnaccessData(hData);
1417     }
1418     else
1419     {
1420         dwRet = 0;
1421     }
1422     return dwRet;
1423 }
1424
1425 /*****************************************************************
1426  *            DdeAccessData (USER32.@)
1427  */
1428 LPBYTE WINAPI DdeAccessData(HDDEDATA hData, LPDWORD pcbDataSize)
1429 {
1430     HGLOBAL                     hMem = hData;
1431     DDE_DATAHANDLE_HEAD*        pDdh;
1432
1433     TRACE("(%p,%p)\n", hData, pcbDataSize);
1434
1435     pDdh = GlobalLock(hMem);
1436     if (pDdh == NULL)
1437     {
1438         ERR("Failed on GlobalLock(%p)\n", hMem);
1439         return 0;
1440     }
1441
1442     if (pcbDataSize != NULL)
1443     {
1444         *pcbDataSize = GlobalSize(hMem) - sizeof(DDE_DATAHANDLE_HEAD);
1445     }
1446     TRACE("=> %p (%lu) fmt %04x\n", pDdh + 1, GlobalSize(hMem) - sizeof(DDE_DATAHANDLE_HEAD), pDdh->cfFormat);
1447     return (LPBYTE)(pDdh + 1);
1448 }
1449
1450 /*****************************************************************
1451  *            DdeUnaccessData (USER32.@)
1452  */
1453 BOOL WINAPI DdeUnaccessData(HDDEDATA hData)
1454 {
1455     HGLOBAL hMem = hData;
1456
1457     TRACE("(%p)\n", hData);
1458
1459     GlobalUnlock(hMem);
1460
1461     return TRUE;
1462 }
1463
1464 /*****************************************************************
1465  *            DdeFreeDataHandle   (USER32.@)
1466  */
1467 BOOL WINAPI DdeFreeDataHandle(HDDEDATA hData)
1468 {
1469     TRACE("(%p)\n", hData);
1470     return GlobalFree(hData) == 0;
1471 }
1472
1473 /******************************************************************
1474  *              WDML_IsAppOwned
1475  *
1476  *
1477  */
1478 BOOL WDML_IsAppOwned(HDDEDATA hData)
1479 {
1480     DDE_DATAHANDLE_HEAD*        pDdh;
1481     BOOL                        ret = FALSE;
1482
1483     pDdh = GlobalLock(hData);
1484     if (pDdh != NULL)
1485     {
1486         ret = pDdh->bAppOwned;
1487         GlobalUnlock(hData);
1488     }
1489     return ret;
1490 }
1491
1492 /* ================================================================
1493  *
1494  *                  Global <=> Data handle management
1495  *
1496  * ================================================================ */
1497
1498 /* Note: we use a DDEDATA, but layout of DDEDATA, DDEADVISE and DDEPOKE structures is similar:
1499  *    offset      size
1500  *    (bytes)    (bits) comment
1501  *      0          16   bit fields for options (release, ackreq, response...)
1502  *      2          16   clipboard format
1503  *      4          ?    data to be used
1504  */
1505 HDDEDATA        WDML_Global2DataHandle(WDML_CONV* pConv, HGLOBAL hMem, WINE_DDEHEAD* p)
1506 {
1507     DDEDATA*    pDd;
1508     HDDEDATA    ret = 0;
1509     DWORD       size;
1510
1511     if (hMem)
1512     {
1513         pDd = GlobalLock(hMem);
1514         size = GlobalSize(hMem) - sizeof(WINE_DDEHEAD);
1515         if (pDd)
1516         {
1517             if (p) memcpy(p, pDd, sizeof(WINE_DDEHEAD));
1518             switch (pDd->cfFormat)
1519             {
1520             default:
1521                 FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
1522                       pDd->cfFormat, hMem);
1523                 /* fall thru */
1524             case 0:
1525             case CF_TEXT:
1526                 ret = DdeCreateDataHandle(pConv->instance->instanceID, pDd->Value, size, 0, 0, pDd->cfFormat, 0);
1527                 break;
1528             case CF_BITMAP:
1529                 if (size >= sizeof(BITMAP))
1530                 {
1531                     BITMAP*     bmp = (BITMAP*)pDd->Value;
1532                     int         count = bmp->bmWidthBytes * bmp->bmHeight * bmp->bmPlanes;
1533                     if (size >= sizeof(BITMAP) + count)
1534                     {
1535                         HBITMAP hbmp;
1536
1537                         if ((hbmp = CreateBitmap(bmp->bmWidth, bmp->bmHeight,
1538                                                  bmp->bmPlanes, bmp->bmBitsPixel,
1539                                                  pDd->Value + sizeof(BITMAP))))
1540                         {
1541                             ret = DdeCreateDataHandle(pConv->instance->instanceID, (LPBYTE)&hbmp, sizeof(hbmp),
1542                                                       0, 0, CF_BITMAP, 0);
1543                         }
1544                         else ERR("Can't create bmp\n");
1545                     }
1546                     else
1547                     {
1548                         ERR("Wrong count: %u / %d\n", size, count);
1549                     }
1550                 } else ERR("No bitmap header\n");
1551                 break;
1552             }
1553             GlobalUnlock(hMem);
1554         }
1555     }
1556     return ret;
1557 }
1558
1559 /******************************************************************
1560  *              WDML_DataHandle2Global
1561  *
1562  *
1563  */
1564 HGLOBAL WDML_DataHandle2Global(HDDEDATA hDdeData, BOOL fResponse, BOOL fRelease,
1565                                BOOL fDeferUpd, BOOL fAckReq)
1566 {
1567     DDE_DATAHANDLE_HEAD*        pDdh;
1568     DWORD                       dwSize;
1569     HGLOBAL                     hMem = 0;
1570
1571     dwSize = GlobalSize(hDdeData) - sizeof(DDE_DATAHANDLE_HEAD);
1572     pDdh = GlobalLock(hDdeData);
1573     if (dwSize && pDdh)
1574     {
1575         WINE_DDEHEAD*    wdh = NULL;
1576
1577         switch (pDdh->cfFormat)
1578         {
1579         default:
1580             FIXME("Unsupported format (%04x) for data %p, passing raw information\n",
1581                    pDdh->cfFormat, hDdeData);
1582             /* fall thru */
1583         case 0:
1584         case CF_TEXT:
1585             hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, sizeof(WINE_DDEHEAD) + dwSize);
1586             if (hMem && (wdh = GlobalLock(hMem)))
1587             {
1588                 memcpy(wdh + 1, pDdh + 1, dwSize);
1589             }
1590             break;
1591         case CF_BITMAP:
1592             if (dwSize >= sizeof(HBITMAP))
1593             {
1594                 BITMAP  bmp;
1595                 DWORD   count;
1596                 HBITMAP hbmp = *(HBITMAP*)(pDdh + 1);
1597
1598                 if (GetObjectW(hbmp, sizeof(bmp), &bmp))
1599                 {
1600                     count = bmp.bmWidthBytes * bmp.bmHeight;
1601                     hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE,
1602                                        sizeof(WINE_DDEHEAD) + sizeof(bmp) + count);
1603                     if (hMem && (wdh = GlobalLock(hMem)))
1604                     {
1605                         memcpy(wdh + 1, &bmp, sizeof(bmp));
1606                         GetBitmapBits(hbmp, count, ((char*)(wdh + 1)) + sizeof(bmp));
1607                     }
1608                 }
1609             }
1610             break;
1611         }
1612         if (wdh)
1613         {
1614             wdh->unused = 0;
1615             wdh->fResponse = fResponse;
1616             wdh->fRelease = fRelease;
1617             wdh->fDeferUpd = fDeferUpd;
1618             wdh->fAckReq = fAckReq;
1619             wdh->cfFormat = pDdh->cfFormat;
1620             GlobalUnlock(hMem);
1621         }
1622         GlobalUnlock(hDdeData);
1623     }
1624
1625     return hMem;
1626 }
1627
1628 /* ================================================================
1629  *
1630  *                      Server management
1631  *
1632  * ================================================================ */
1633
1634 /******************************************************************
1635  *              WDML_AddServer
1636  *
1637  *
1638  */
1639 WDML_SERVER*    WDML_AddServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTopic)
1640 {
1641     static const WCHAR fmtW[] = {'%','s','(','0','x','%','*','x',')',0};
1642     WDML_SERVER*        pServer;
1643     WCHAR               buf1[256];
1644     WCHAR               buf2[256];
1645
1646     pServer = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_SERVER));
1647     if (pServer == NULL) return NULL;
1648
1649     pServer->hszService = hszService;
1650     WDML_IncHSZ(pInstance, hszService);
1651
1652     DdeQueryStringW(pInstance->instanceID, hszService, buf1, 256, CP_WINUNICODE);
1653     snprintfW(buf2, 256, fmtW, buf1, 2*sizeof(ULONG_PTR), GetCurrentProcessId());
1654     pServer->hszServiceSpec = DdeCreateStringHandleW(pInstance->instanceID, buf2, CP_WINUNICODE);
1655
1656     pServer->atomService = WDML_MakeAtomFromHsz(pServer->hszService);
1657     pServer->atomServiceSpec = WDML_MakeAtomFromHsz(pServer->hszServiceSpec);
1658
1659     pServer->filterOn = TRUE;
1660
1661     pServer->next = pInstance->servers;
1662     pInstance->servers = pServer;
1663     return pServer;
1664 }
1665
1666 /******************************************************************
1667  *              WDML_RemoveServer
1668  *
1669  *
1670  */
1671 void WDML_RemoveServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTopic)
1672 {
1673     WDML_SERVER*        pPrev = NULL;
1674     WDML_SERVER*        pServer = NULL;
1675     WDML_CONV*          pConv;
1676     WDML_CONV*          pConvNext;
1677
1678     pServer = pInstance->servers;
1679
1680     while (pServer != NULL)
1681     {
1682         if (DdeCmpStringHandles(pServer->hszService, hszService) == 0)
1683         {
1684             WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_UNREGISTER,
1685                                      pServer->atomService, pServer->atomServiceSpec);
1686             /* terminate all conversations for given topic */
1687             for (pConv = pInstance->convs[WDML_SERVER_SIDE]; pConv != NULL; pConv = pConvNext)
1688             {
1689                 pConvNext = pConv->next;
1690                 if (DdeCmpStringHandles(pConv->hszService, hszService) == 0)
1691                 {
1692                     HWND client = pConv->hwndClient, server = pConv->hwndServer;
1693                     WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
1694                     /* don't care about return code (whether client window is present or not) */
1695                     PostMessageW(client, WM_DDE_TERMINATE, (WPARAM)server, 0);
1696                 }
1697             }
1698             if (pServer == pInstance->servers)
1699             {
1700                 pInstance->servers = pServer->next;
1701             }
1702             else
1703             {
1704                 pPrev->next = pServer->next;
1705             }
1706
1707             DestroyWindow(pServer->hwndServer);
1708             WDML_DecHSZ(pInstance, pServer->hszServiceSpec);
1709             WDML_DecHSZ(pInstance, pServer->hszService);
1710
1711             GlobalDeleteAtom(pServer->atomService);
1712             GlobalDeleteAtom(pServer->atomServiceSpec);
1713
1714             HeapFree(GetProcessHeap(), 0, pServer);
1715             break;
1716         }
1717
1718         pPrev = pServer;
1719         pServer = pServer->next;
1720     }
1721 }
1722
1723 /*****************************************************************************
1724  *      WDML_FindServer
1725  *
1726  *      generic routine to return a pointer to the relevant ServiceNode
1727  *      for a given service name, or NULL if the entry does not exist
1728  *
1729  */
1730 WDML_SERVER*    WDML_FindServer(WDML_INSTANCE* pInstance, HSZ hszService, HSZ hszTopic)
1731 {
1732     WDML_SERVER*        pServer;
1733
1734     for (pServer = pInstance->servers; pServer != NULL; pServer = pServer->next)
1735     {
1736         if (hszService == pServer->hszService)
1737         {
1738             return pServer;
1739         }
1740     }
1741     TRACE("Service name missing\n");
1742     return NULL;
1743 }
1744
1745 /* ================================================================
1746  *
1747  *              Conversation management
1748  *
1749  * ================================================================ */
1750
1751 /******************************************************************
1752  *              WDML_AddConv
1753  *
1754  *
1755  */
1756 WDML_CONV*      WDML_AddConv(WDML_INSTANCE* pInstance, WDML_SIDE side,
1757                              HSZ hszService, HSZ hszTopic, HWND hwndClient, HWND hwndServer)
1758 {
1759     WDML_CONV*  pConv;
1760
1761     /* no conversation yet, add it */
1762     pConv = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_CONV));
1763     if (!pConv) return NULL;
1764
1765     pConv->instance = pInstance;
1766     WDML_IncHSZ(pInstance, pConv->hszService = hszService);
1767     WDML_IncHSZ(pInstance, pConv->hszTopic = hszTopic);
1768     pConv->magic = WDML_CONV_MAGIC;
1769     pConv->hwndServer = hwndServer;
1770     pConv->hwndClient = hwndClient;
1771     pConv->transactions = NULL;
1772     pConv->hUser = 0;
1773     pConv->wStatus = (side == WDML_CLIENT_SIDE) ? ST_CLIENT : 0L;
1774     pConv->wStatus |= pInstance->wStatus;
1775     /* check if both side of the conversation are of the same instance */
1776     if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
1777         WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
1778     {
1779         pConv->wStatus |= ST_ISSELF;
1780     }
1781     pConv->wConvst = XST_NULL;
1782
1783     pConv->next = pInstance->convs[side];
1784     pInstance->convs[side] = pConv;
1785
1786     TRACE("pConv->wStatus %04x pInstance(%p)\n", pConv->wStatus, pInstance);
1787
1788     return pConv;
1789 }
1790
1791 /******************************************************************
1792  *              WDML_FindConv
1793  *
1794  *
1795  */
1796 WDML_CONV*      WDML_FindConv(WDML_INSTANCE* pInstance, WDML_SIDE side,
1797                               HSZ hszService, HSZ hszTopic)
1798 {
1799     WDML_CONV*  pCurrent = NULL;
1800
1801     for (pCurrent = pInstance->convs[side]; pCurrent != NULL; pCurrent = pCurrent->next)
1802     {
1803         if (DdeCmpStringHandles(pCurrent->hszService, hszService) == 0 &&
1804             DdeCmpStringHandles(pCurrent->hszTopic, hszTopic) == 0)
1805         {
1806             return pCurrent;
1807         }
1808
1809     }
1810     return NULL;
1811 }
1812
1813 /******************************************************************
1814  *              WDML_RemoveConv
1815  *
1816  *
1817  */
1818 void WDML_RemoveConv(WDML_CONV* pRef, WDML_SIDE side)
1819 {
1820     WDML_CONV*  pPrev = NULL;
1821     WDML_CONV*  pCurrent;
1822     WDML_XACT*  pXAct;
1823     WDML_XACT*  pXActNext;
1824     HWND        hWnd;
1825
1826     if (!pRef)
1827         return;
1828
1829     /* remove any pending transaction */
1830     for (pXAct = pRef->transactions; pXAct != NULL; pXAct = pXActNext)
1831     {
1832         pXActNext = pXAct->next;
1833         WDML_FreeTransaction(pRef->instance, pXAct, TRUE);
1834     }
1835
1836     WDML_RemoveAllLinks(pRef->instance, pRef, side);
1837
1838     /* FIXME: should we keep the window around ? it seems so (at least on client side
1839      * to let QueryConvInfo work after conv termination, but also to implement
1840      * DdeReconnect...
1841      */
1842     /* destroy conversation window, but first remove pConv from hWnd.
1843      * this would help the wndProc do appropriate handling upon a WM_DESTROY message
1844      */
1845     hWnd = (side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer;
1846     SetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION, 0);
1847
1848     DestroyWindow((side == WDML_CLIENT_SIDE) ? pRef->hwndClient : pRef->hwndServer);
1849
1850     WDML_DecHSZ(pRef->instance, pRef->hszService);
1851     WDML_DecHSZ(pRef->instance, pRef->hszTopic);
1852
1853     for (pCurrent = pRef->instance->convs[side]; pCurrent != NULL; pCurrent = (pPrev = pCurrent)->next)
1854     {
1855         if (pCurrent == pRef)
1856         {
1857             if (pCurrent == pRef->instance->convs[side])
1858             {
1859                 pRef->instance->convs[side] = pCurrent->next;
1860             }
1861             else
1862             {
1863                 pPrev->next = pCurrent->next;
1864             }
1865             pCurrent->magic = 0;
1866             HeapFree(GetProcessHeap(), 0, pCurrent);
1867             break;
1868         }
1869     }
1870 }
1871
1872 /******************************************************************
1873  *              WDML_EnableCallback
1874  */
1875 static BOOL WDML_EnableCallback(WDML_CONV *pConv, UINT wCmd)
1876 {
1877     if (wCmd == EC_DISABLE)
1878     {
1879         pConv->wStatus |= ST_BLOCKED;
1880         TRACE("EC_DISABLE: conv %p status flags %04x\n", pConv, pConv->wStatus);
1881         return TRUE;
1882     }
1883
1884     if (wCmd == EC_QUERYWAITING)
1885         return pConv->transactions ? TRUE : FALSE;
1886
1887     if (wCmd != EC_ENABLEALL && wCmd != EC_ENABLEONE)
1888     {
1889         FIXME("Unknown command code %04x\n", wCmd);
1890         return FALSE;
1891     }
1892
1893     if (wCmd == EC_ENABLEALL)
1894     {
1895         pConv->wStatus &= ~ST_BLOCKED;
1896         TRACE("EC_ENABLEALL: conv %p status flags %04x\n", pConv, pConv->wStatus);
1897     }
1898
1899     while (pConv->transactions)
1900     {
1901         WDML_XACT *pXAct = pConv->transactions;
1902
1903         if (pConv->wStatus & ST_CLIENT)
1904         {
1905             /* transaction should be in the queue until handled */
1906             WDML_ClientHandle(pConv, pXAct, 0, NULL);
1907             WDML_UnQueueTransaction(pConv, pXAct);
1908         }
1909         else
1910         {
1911             /* transaction should be removed from the queue before handling */
1912             WDML_UnQueueTransaction(pConv, pXAct);
1913             WDML_ServerHandle(pConv, pXAct);
1914         }
1915
1916         WDML_FreeTransaction(pConv->instance, pXAct, TRUE);
1917
1918         if (wCmd == EC_ENABLEONE) break;
1919     }
1920     return TRUE;
1921 }
1922
1923 /*****************************************************************
1924  *            DdeEnableCallback (USER32.@)
1925  */
1926 BOOL WINAPI DdeEnableCallback(DWORD idInst, HCONV hConv, UINT wCmd)
1927 {
1928     BOOL ret = FALSE;
1929     WDML_CONV *pConv;
1930
1931     TRACE("(%d, %p, %04x)\n", idInst, hConv, wCmd);
1932
1933     if (hConv)
1934     {
1935         pConv = WDML_GetConv(hConv, TRUE);
1936
1937         if (pConv && pConv->instance->instanceID == idInst)
1938             ret = WDML_EnableCallback(pConv, wCmd);
1939     }
1940     else
1941     {
1942         WDML_INSTANCE *pInstance = WDML_GetInstance(idInst);
1943
1944         if (!pInstance)
1945             return FALSE;
1946
1947         TRACE("adding flags %04x to instance %p\n", wCmd, pInstance);
1948         pInstance->wStatus |= wCmd;
1949
1950         if (wCmd == EC_DISABLE)
1951         {
1952             pInstance->wStatus |= ST_BLOCKED;
1953             TRACE("EC_DISABLE: inst %p status flags %04x\n", pInstance, pInstance->wStatus);
1954         }
1955         else if (wCmd == EC_ENABLEALL)
1956         {
1957             pInstance->wStatus &= ~ST_BLOCKED;
1958             TRACE("EC_ENABLEALL: inst %p status flags %04x\n", pInstance, pInstance->wStatus);
1959         }
1960
1961         ret = TRUE;
1962
1963         for (pConv = pInstance->convs[WDML_CLIENT_SIDE]; pConv != NULL; pConv = pConv->next)
1964         {
1965             ret = WDML_EnableCallback(pConv, wCmd);
1966             if (ret && wCmd == EC_QUERYWAITING) break;
1967         }
1968     }
1969
1970     return ret;
1971 }
1972
1973 /******************************************************************
1974  *              WDML_GetConv
1975  *
1976  *
1977  */
1978 WDML_CONV*      WDML_GetConv(HCONV hConv, BOOL checkConnected)
1979 {
1980     WDML_CONV*  pConv = (WDML_CONV*)hConv;
1981
1982     /* FIXME: should do better checking */
1983     if (pConv == NULL || pConv->magic != WDML_CONV_MAGIC) return NULL;
1984
1985     if (!pConv->instance || pConv->instance->threadID != GetCurrentThreadId())
1986     {
1987         WARN("wrong thread ID\n");
1988         pConv->instance->lastError = DMLERR_INVALIDPARAMETER; /* FIXME: check */
1989         return NULL;
1990     }
1991
1992     if (checkConnected && !(pConv->wStatus & ST_CONNECTED))
1993     {
1994         WARN("found conv but ain't connected\n");
1995         pConv->instance->lastError = DMLERR_NO_CONV_ESTABLISHED;
1996         return NULL;
1997     }
1998
1999     return pConv;
2000 }
2001
2002 /******************************************************************
2003  *              WDML_GetConvFromWnd
2004  *
2005  *
2006  */
2007 WDML_CONV*      WDML_GetConvFromWnd(HWND hWnd)
2008 {
2009     return (WDML_CONV*)GetWindowLongPtrW(hWnd, GWL_WDML_CONVERSATION);
2010 }
2011
2012 /******************************************************************
2013  *              WDML_PostAck
2014  *
2015  *
2016  */
2017 BOOL            WDML_PostAck(WDML_CONV* pConv, WDML_SIDE side, WORD appRetCode,
2018                              BOOL fBusy, BOOL fAck, UINT_PTR pmt, LPARAM lParam, UINT oldMsg)
2019 {
2020     DDEACK      ddeAck;
2021     HWND        from, to;
2022
2023     if (side == WDML_SERVER_SIDE)
2024     {
2025         from = pConv->hwndServer;
2026         to   = pConv->hwndClient;
2027     }
2028     else
2029     {
2030         to   = pConv->hwndServer;
2031         from = pConv->hwndClient;
2032     }
2033
2034     ddeAck.bAppReturnCode = appRetCode;
2035     ddeAck.reserved       = 0;
2036     ddeAck.fBusy          = fBusy;
2037     ddeAck.fAck           = fAck;
2038
2039     TRACE("Posting a %s ack\n", ddeAck.fAck ? "positive" : "negative");
2040
2041     lParam = (lParam) ? ReuseDDElParam(lParam, oldMsg, WM_DDE_ACK, *(WORD*)&ddeAck, pmt) :
2042         PackDDElParam(WM_DDE_ACK, *(WORD*)&ddeAck, pmt);
2043     if (!PostMessageW(to, WM_DDE_ACK, (WPARAM)from, lParam))
2044     {
2045         pConv->wStatus &= ~ST_CONNECTED;
2046         pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
2047         FreeDDElParam(WM_DDE_ACK, lParam);
2048         return FALSE;
2049     }
2050     return TRUE;
2051 }
2052
2053 /*****************************************************************
2054  *            DdeSetUserHandle (USER32.@)
2055  */
2056 BOOL WINAPI DdeSetUserHandle(HCONV hConv, DWORD id, DWORD hUser)
2057 {
2058     WDML_CONV*  pConv;
2059
2060     pConv = WDML_GetConv(hConv, FALSE);
2061     if (pConv == NULL)
2062         return FALSE;
2063
2064     if (id == QID_SYNC)
2065     {
2066         pConv->hUser = hUser;
2067     }
2068     else
2069     {
2070         WDML_XACT*      pXAct;
2071
2072         pXAct = WDML_FindTransaction(pConv, id);
2073         if (pXAct)
2074         {
2075             pXAct->hUser = hUser;
2076         }
2077         else
2078         {
2079             pConv->instance->lastError = DMLERR_UNFOUND_QUEUE_ID;
2080             return  FALSE;
2081         }
2082     }
2083     return TRUE;
2084 }
2085
2086 /******************************************************************
2087  *              WDML_GetLocalConvInfo
2088  *
2089  *
2090  */
2091 static  BOOL    WDML_GetLocalConvInfo(WDML_CONV* pConv, CONVINFO* ci, DWORD id)
2092 {
2093     BOOL        ret = TRUE;
2094     WDML_LINK*  pLink;
2095     WDML_SIDE   side;
2096
2097     ci->hConvPartner = (pConv->wStatus & ST_ISLOCAL) ? (HCONV)((ULONG_PTR)pConv | 1) : 0;
2098     ci->hszSvcPartner = pConv->hszService;
2099     ci->hszServiceReq = pConv->hszService; /* FIXME: they shouldn't be the same, should they ? */
2100     ci->hszTopic = pConv->hszTopic;
2101     ci->wStatus = pConv->wStatus;
2102
2103     side = (pConv->wStatus & ST_CLIENT) ? WDML_CLIENT_SIDE : WDML_SERVER_SIDE;
2104
2105     for (pLink = pConv->instance->links[side]; pLink != NULL; pLink = pLink->next)
2106     {
2107         if (pLink->hConv == (HCONV)pConv)
2108         {
2109             ci->wStatus |= ST_ADVISE;
2110             break;
2111         }
2112     }
2113
2114     /* FIXME: non handled status flags:
2115        ST_BLOCKED
2116        ST_BLOCKNEXT
2117        ST_INLIST
2118     */
2119
2120     ci->wConvst = pConv->wConvst; /* FIXME */
2121
2122     ci->wLastError = 0; /* FIXME: note it's not the instance last error */
2123     ci->hConvList = 0;
2124     ci->ConvCtxt = pConv->convContext;
2125     if (ci->wStatus & ST_CLIENT)
2126     {
2127         ci->hwnd = pConv->hwndClient;
2128         ci->hwndPartner = pConv->hwndServer;
2129     }
2130     else
2131     {
2132         ci->hwnd = pConv->hwndServer;
2133         ci->hwndPartner = pConv->hwndClient;
2134     }
2135     if (id == QID_SYNC)
2136     {
2137         ci->hUser = pConv->hUser;
2138         ci->hszItem = 0;
2139         ci->wFmt = 0;
2140         ci->wType = 0;
2141     }
2142     else
2143     {
2144         WDML_XACT*      pXAct;
2145
2146         pXAct = WDML_FindTransaction(pConv, id);
2147         if (pXAct)
2148         {
2149             ci->hUser = pXAct->hUser;
2150             ci->hszItem = pXAct->hszItem;
2151             ci->wFmt = pXAct->wFmt;
2152             ci->wType = pXAct->wType;
2153         }
2154         else
2155         {
2156             ret = 0;
2157             pConv->instance->lastError = DMLERR_UNFOUND_QUEUE_ID;
2158         }
2159     }
2160     return ret;
2161 }
2162
2163 /******************************************************************
2164  *              DdeQueryConvInfo (USER32.@)
2165  *
2166  * FIXME: Set last DDE error on failure.
2167  */
2168 UINT WINAPI DdeQueryConvInfo(HCONV hConv, DWORD id, PCONVINFO lpConvInfo)
2169 {
2170     UINT        ret = lpConvInfo->cb;
2171     CONVINFO    ci;
2172     WDML_CONV*  pConv;
2173
2174     TRACE("(%p,%x,%p)\n", hConv, id, lpConvInfo);
2175
2176     if (!hConv)
2177     {
2178         FIXME("hConv is NULL\n");
2179         return 0;
2180     }
2181
2182     pConv = WDML_GetConv(hConv, FALSE);
2183     if (pConv != NULL)
2184     {
2185         if (!WDML_GetLocalConvInfo(pConv, &ci, id))
2186             ret = 0;
2187     }
2188     else
2189     {
2190         if ((ULONG_PTR)hConv & 1)
2191         {
2192             pConv = WDML_GetConv((HCONV)((ULONG_PTR)hConv & ~1), FALSE);
2193             if (pConv != NULL)
2194                 FIXME("Request on remote conversation information is not implemented yet\n");
2195         }
2196         ret = 0;
2197     }
2198
2199     if (ret != 0)
2200         memcpy(lpConvInfo, &ci, min((size_t)lpConvInfo->cb, sizeof(ci)));
2201     return ret;
2202 }
2203
2204 /* ================================================================
2205  *
2206  *                      Link (hot & warm) management
2207  *
2208  * ================================================================ */
2209
2210 /******************************************************************
2211  *              WDML_AddLink
2212  *
2213  *
2214  */
2215 void WDML_AddLink(WDML_INSTANCE* pInstance, HCONV hConv, WDML_SIDE side,
2216                   UINT wType, HSZ hszItem, UINT wFmt)
2217 {
2218     WDML_LINK*  pLink;
2219
2220     pLink = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_LINK));
2221     if (pLink == NULL)
2222     {
2223         ERR("OOM\n");
2224         return;
2225     }
2226
2227     pLink->hConv = hConv;
2228     pLink->transactionType = wType;
2229     WDML_IncHSZ(pInstance, pLink->hszItem = hszItem);
2230     pLink->uFmt = wFmt;
2231     pLink->next = pInstance->links[side];
2232     pInstance->links[side] = pLink;
2233 }
2234
2235 /******************************************************************
2236  *              WDML_RemoveLink
2237  *
2238  *
2239  */
2240 void WDML_RemoveLink(WDML_INSTANCE* pInstance, HCONV hConv, WDML_SIDE side,
2241                      HSZ hszItem, UINT uFmt)
2242 {
2243     WDML_LINK* pPrev = NULL;
2244     WDML_LINK* pCurrent = NULL;
2245
2246     pCurrent = pInstance->links[side];
2247
2248     while (pCurrent != NULL)
2249     {
2250         if (pCurrent->hConv == hConv &&
2251             DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
2252             pCurrent->uFmt == uFmt)
2253         {
2254             if (pCurrent == pInstance->links[side])
2255             {
2256                 pInstance->links[side] = pCurrent->next;
2257             }
2258             else
2259             {
2260                 pPrev->next = pCurrent->next;
2261             }
2262
2263             WDML_DecHSZ(pInstance, pCurrent->hszItem);
2264             HeapFree(GetProcessHeap(), 0, pCurrent);
2265             break;
2266         }
2267
2268         pPrev = pCurrent;
2269         pCurrent = pCurrent->next;
2270     }
2271 }
2272
2273 /* this function is called to remove all links related to the conv.
2274    It should be called from both client and server when terminating
2275    the conversation.
2276 */
2277 /******************************************************************
2278  *              WDML_RemoveAllLinks
2279  *
2280  *
2281  */
2282 void WDML_RemoveAllLinks(WDML_INSTANCE* pInstance, WDML_CONV* pConv, WDML_SIDE side)
2283 {
2284     WDML_LINK* pPrev = NULL;
2285     WDML_LINK* pCurrent = NULL;
2286     WDML_LINK* pNext = NULL;
2287
2288     pCurrent = pInstance->links[side];
2289
2290     while (pCurrent != NULL)
2291     {
2292         if (pCurrent->hConv == (HCONV)pConv)
2293         {
2294             if (pCurrent == pInstance->links[side])
2295             {
2296                 pInstance->links[side] = pCurrent->next;
2297                 pNext = pCurrent->next;
2298             }
2299             else
2300             {
2301                 pPrev->next = pCurrent->next;
2302                 pNext = pCurrent->next;
2303             }
2304
2305             WDML_DecHSZ(pInstance, pCurrent->hszItem);
2306
2307             HeapFree(GetProcessHeap(), 0, pCurrent);
2308             pCurrent = NULL;
2309         }
2310
2311         if (pCurrent)
2312         {
2313             pPrev = pCurrent;
2314             pCurrent = pCurrent->next;
2315         }
2316         else
2317         {
2318             pCurrent = pNext;
2319         }
2320     }
2321 }
2322
2323 /******************************************************************
2324  *              WDML_FindLink
2325  *
2326  *
2327  */
2328 WDML_LINK*      WDML_FindLink(WDML_INSTANCE* pInstance, HCONV hConv, WDML_SIDE side,
2329                               HSZ hszItem, BOOL use_fmt, UINT uFmt)
2330 {
2331     WDML_LINK*  pCurrent = NULL;
2332
2333     for (pCurrent = pInstance->links[side]; pCurrent != NULL; pCurrent = pCurrent->next)
2334     {
2335         /* we don't need to check for transaction type as it can be altered */
2336
2337         if (pCurrent->hConv == hConv &&
2338             DdeCmpStringHandles(pCurrent->hszItem, hszItem) == 0 &&
2339             (!use_fmt || pCurrent->uFmt == uFmt))
2340         {
2341             break;
2342         }
2343
2344     }
2345
2346     return pCurrent;
2347 }
2348
2349 /* ================================================================
2350  *
2351  *                      Transaction management
2352  *
2353  * ================================================================ */
2354
2355 /******************************************************************
2356  *              WDML_AllocTransaction
2357  *
2358  * Alloc a transaction structure for handling the message ddeMsg
2359  */
2360 WDML_XACT*      WDML_AllocTransaction(WDML_INSTANCE* pInstance, UINT ddeMsg,
2361                                       UINT wFmt, HSZ hszItem)
2362 {
2363     WDML_XACT*          pXAct;
2364     static WORD         tid = 1;        /* FIXME: wrap around */
2365
2366     pXAct = HeapAlloc(GetProcessHeap(), 0, sizeof(WDML_XACT));
2367     if (!pXAct)
2368     {
2369         pInstance->lastError = DMLERR_MEMORY_ERROR;
2370         return NULL;
2371     }
2372
2373     pXAct->xActID = tid++;
2374     pXAct->ddeMsg = ddeMsg;
2375     pXAct->hDdeData = 0;
2376     pXAct->hUser = 0;
2377     pXAct->next = NULL;
2378     pXAct->wType = 0;
2379     pXAct->wFmt = wFmt;
2380     if ((pXAct->hszItem = hszItem)) WDML_IncHSZ(pInstance, pXAct->hszItem);
2381     pXAct->atom = 0;
2382     pXAct->hMem = 0;
2383     pXAct->lParam = 0;
2384
2385     return pXAct;
2386 }
2387
2388 /******************************************************************
2389  *              WDML_QueueTransaction
2390  *
2391  * Adds a transaction to the list of transaction
2392  */
2393 void    WDML_QueueTransaction(WDML_CONV* pConv, WDML_XACT* pXAct)
2394 {
2395     WDML_XACT** pt;
2396
2397     /* advance to last in queue */
2398     for (pt = &pConv->transactions; *pt != NULL; pt = &(*pt)->next);
2399     *pt = pXAct;
2400 }
2401
2402 /******************************************************************
2403  *              WDML_UnQueueTransaction
2404  *
2405  *
2406  */
2407 BOOL    WDML_UnQueueTransaction(WDML_CONV* pConv, WDML_XACT*  pXAct)
2408 {
2409     WDML_XACT** pt;
2410
2411     for (pt = &pConv->transactions; *pt; pt = &(*pt)->next)
2412     {
2413         if (*pt == pXAct)
2414         {
2415             *pt = pXAct->next;
2416             return TRUE;
2417         }
2418     }
2419     return FALSE;
2420 }
2421
2422 /******************************************************************
2423  *              WDML_FreeTransaction
2424  *
2425  *
2426  */
2427 void    WDML_FreeTransaction(WDML_INSTANCE* pInstance, WDML_XACT* pXAct, BOOL doFreePmt)
2428 {
2429     /* free pmt(s) in pXAct too. check against one for not deleting TRUE return values */
2430     if (doFreePmt && (ULONG_PTR)pXAct->hMem > 1)
2431     {
2432         GlobalFree(pXAct->hMem);
2433     }
2434     if (pXAct->hszItem) WDML_DecHSZ(pInstance, pXAct->hszItem);
2435
2436     HeapFree(GetProcessHeap(), 0, pXAct);
2437 }
2438
2439 /******************************************************************
2440  *              WDML_FindTransaction
2441  *
2442  *
2443  */
2444 WDML_XACT*      WDML_FindTransaction(WDML_CONV* pConv, DWORD tid)
2445 {
2446     WDML_XACT* pXAct;
2447
2448     tid = HIWORD(tid);
2449     for (pXAct = pConv->transactions; pXAct; pXAct = pXAct->next)
2450     {
2451         if (pXAct->xActID == tid)
2452             break;
2453     }
2454     return pXAct;
2455 }
2456
2457 /* ================================================================
2458  *
2459  *         Information broadcast across DDEML implementations
2460  *
2461  * ================================================================ */
2462
2463 struct tagWDML_BroadcastPmt
2464 {
2465     LPCWSTR     clsName;
2466     UINT        uMsg;
2467     WPARAM      wParam;
2468     LPARAM      lParam;
2469 };
2470
2471 /******************************************************************
2472  *              WDML_BroadcastEnumProc
2473  *
2474  *
2475  */
2476 static  BOOL CALLBACK WDML_BroadcastEnumProc(HWND hWnd, LPARAM lParam)
2477 {
2478     struct tagWDML_BroadcastPmt*        s = (struct tagWDML_BroadcastPmt*)lParam;
2479     WCHAR                               buffer[128];
2480
2481     if (GetClassNameW(hWnd, buffer, 128) > 0 &&
2482         lstrcmpiW(buffer, s->clsName) == 0)
2483     {
2484         PostMessageW(hWnd, s->uMsg, s->wParam, s->lParam);
2485     }
2486     return TRUE;
2487 }
2488
2489 /******************************************************************
2490  *              WDML_BroadcastDDEWindows
2491  *
2492  *
2493  */
2494 void WDML_BroadcastDDEWindows(LPCWSTR clsName, UINT uMsg, WPARAM wParam, LPARAM lParam)
2495 {
2496     struct tagWDML_BroadcastPmt s;
2497
2498     s.clsName = clsName;
2499     s.uMsg    = uMsg;
2500     s.wParam  = wParam;
2501     s.lParam  = lParam;
2502     EnumWindows(WDML_BroadcastEnumProc, (LPARAM)&s);
2503 }