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