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