?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
server: Added access rights mapping to token objects.
[wine/multimedia.git] / dlls / user / dde_misc.c
blobe25319d3e46b1028639ea9d29bdc261e4178dd1b
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 }
Maarten's multimedia branch