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