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