?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
widl: Add support for protected attribute.
[wine.git] / dlls / user32 / dde_server.c
blobecc7fbaee347261db21212d60f0e90acfdc0dc19
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 <wchar.h>
27 #include "user_private.h"
28 #include "dde_private.h"
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
32
33 const char WDML_szServerConvClassA[] = "WineDdeServerConvA";
34 const WCHAR WDML_szServerConvClassW[] = L"WineDdeServerConvW";
35
36 static LRESULT CALLBACK WDML_ServerNameProc(HWND, UINT, WPARAM, LPARAM);
37 static LRESULT CALLBACK WDML_ServerConvProc(HWND, UINT, WPARAM, LPARAM);
38
39 /******************************************************************************
40 * DdePostAdvise [USER32.@] Send transaction to DDE callback function.
41 *
42 * PARAMS
43 * idInst [I] Instance identifier
44 * hszTopic [I] Handle to topic name string
45 * hszItem [I] Handle to item name string
46 *
47 * RETURNS
48 * Success: TRUE
49 * Failure: FALSE
50 */
51 BOOL WINAPI DdePostAdvise(DWORD idInst, HSZ hszTopic, HSZ hszItem)
52 {
53 WDML_INSTANCE* pInstance;
54 WDML_LINK* pLink;
55 HDDEDATA hDdeData;
56 HGLOBAL hItemData;
57 WDML_CONV* pConv;
58 ATOM atom;
59 UINT count;
60
61 TRACE("(%ld,%p,%p)\n", idInst, hszTopic, hszItem);
62
63 pInstance = WDML_GetInstance(idInst);
64
65 if (pInstance == NULL)
66 return FALSE;
67
68 atom = WDML_MakeAtomFromHsz(hszItem);
69 if (!atom) return FALSE;
70
71 /* first compute the number of links which will trigger a message */
72 count = 0;
73 for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
74 {
75 if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
76 {
77 count++;
78 }
79 }
80 if (count >= CADV_LATEACK)
81 {
82 FIXME("too high value for count\n");
83 count &= 0xFFFF;
84 }
85
86 for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
87 {
88 if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
89 {
90 hDdeData = WDML_InvokeCallback(pInstance, XTYP_ADVREQ, pLink->uFmt, pLink->hConv,
91 hszTopic, hszItem, 0, --count, 0);
92
93 if (hDdeData == CBR_BLOCK)
94 {
95 /* MS doc is not consistent here */
96 FIXME("CBR_BLOCK returned for ADVREQ\n");
97 continue;
98 }
99 if (hDdeData)
100 {
101 if (pLink->transactionType & XTYPF_NODATA)
102 {
103 TRACE("no data\n");
104 hItemData = 0;
105 }
106 else
107 {
108 TRACE("with data\n");
109
110 hItemData = WDML_DataHandle2Global(hDdeData, FALSE, FALSE, FALSE, FALSE);
111 }
112
113 pConv = WDML_GetConv(pLink->hConv, TRUE);
114
115 if (pConv == NULL)
116 {
117 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
118 goto theError;
119 }
120
121 if (!PostMessageW(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
122 PackDDElParam(WM_DDE_DATA, (UINT_PTR)hItemData, atom)))
123 {
124 ERR("post message failed\n");
125 pConv->wStatus &= ~ST_CONNECTED;
126 pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
127 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
128 GlobalFree(hItemData);
129 goto theError;
130 }
131 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
132 }
133 }
134 }
135 return TRUE;
136
137 theError:
138 GlobalDeleteAtom(atom);
139 return FALSE;
140 }
141
142
143 /******************************************************************************
144 * DdeNameService [USER32.@] {Un}registers service name of DDE server
145 *
146 * PARAMS
147 * idInst [I] Instance identifier
148 * hsz1 [I] Handle to service name string
149 * hsz2 [I] Reserved
150 * afCmd [I] Service name flags
151 *
152 * RETURNS
153 * Success: Non-zero
154 * Failure: 0
155 */
156 HDDEDATA WINAPI DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd)
157 {
158 WDML_SERVER* pServer;
159 WDML_INSTANCE* pInstance;
160 HWND hwndServer;
161 WNDCLASSEXW wndclass;
162
163 TRACE("(%ld,%p,%p,%x)\n", idInst, hsz1, hsz2, afCmd);
164
165 /* First check instance
166 */
167 pInstance = WDML_GetInstance(idInst);
168 if (pInstance == NULL)
169 {
170 TRACE("Instance not found as initialised\n");
171 /* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
172 return NULL;
173 }
174
175 if (hsz2 != 0L)
176 {
177 /* Illegal, reserved parameter
178 */
179 pInstance->lastError = DMLERR_INVALIDPARAMETER;
180 WARN("Reserved parameter no-zero !!\n");
181 return NULL;
182 }
183 if (hsz1 == 0 && !(afCmd & DNS_UNREGISTER))
184 {
185 /* don't know if we should check this but it makes sense
186 * why supply REGISTER or filter flags if de-registering all
187 */
188 TRACE("General unregister unexpected flags\n");
189 pInstance->lastError = DMLERR_INVALIDPARAMETER;
190 return NULL;
191 }
192
193 switch (afCmd & (DNS_REGISTER | DNS_UNREGISTER))
194 {
195 case DNS_REGISTER:
196 pServer = WDML_FindServer(pInstance, hsz1, 0);
197 if (pServer)
198 {
199 ERR("Trying to register already registered service!\n");
200 pInstance->lastError = DMLERR_DLL_USAGE;
201 return NULL;
202 }
203
204 TRACE("Adding service name\n");
205
206 WDML_IncHSZ(pInstance, hsz1);
207
208 pServer = WDML_AddServer(pInstance, hsz1, 0);
209
210 WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_REGISTER,
211 pServer->atomService, pServer->atomServiceSpec);
212
213 wndclass.cbSize = sizeof(wndclass);
214 wndclass.style = 0;
215 wndclass.lpfnWndProc = WDML_ServerNameProc;
216 wndclass.cbClsExtra = 0;
217 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
218 wndclass.hInstance = 0;
219 wndclass.hIcon = 0;
220 wndclass.hCursor = 0;
221 wndclass.hbrBackground = 0;
222 wndclass.lpszMenuName = NULL;
223 wndclass.lpszClassName = L"WineDdeServerName";
224 wndclass.hIconSm = 0;
225
226 RegisterClassExW(&wndclass);
227
228 hwndServer = CreateWindowW(L"WineDdeServerName", NULL, WS_POPUP, 0, 0, 0, 0, 0, 0, 0, 0);
229 SetWindowLongPtrW(hwndServer, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
230 SetWindowLongPtrW(hwndServer, GWL_WDML_SERVER, (ULONG_PTR)pServer);
231 TRACE("Created nameServer=%p for instance=%08lx\n", hwndServer, idInst);
232
233 pServer->hwndServer = hwndServer;
234 break;
235
236 case DNS_UNREGISTER:
237 if (hsz1 == 0L)
238 {
239 /* General unregister situation
240 * terminate all server side pending conversations
241 */
242 while (pInstance->servers)
243 WDML_RemoveServer(pInstance, pInstance->servers->hszService, 0);
244 pInstance->servers = NULL;
245 TRACE("General de-register - finished\n");
246 }
247 else
248 {
249 WDML_RemoveServer(pInstance, hsz1, 0L);
250 }
251 break;
252 }
253
254 if (afCmd & (DNS_FILTERON | DNS_FILTEROFF))
255 {
256 /* Set filter flags on to hold notifications of connection
257 */
258 pServer = WDML_FindServer(pInstance, hsz1, 0);
259 if (!pServer)
260 {
261 /* trying to filter where no service names !!
262 */
263 pInstance->lastError = DMLERR_DLL_USAGE;
264 return NULL;
265 }
266 else
267 {
268 pServer->filterOn = (afCmd & DNS_FILTERON) != 0;
269 }
270 }
271 return (HDDEDATA)TRUE;
272 }
273
274 /******************************************************************
275 * WDML_CreateServerConv
276 *
277 *
278 */
279 static WDML_CONV* WDML_CreateServerConv(WDML_INSTANCE* pInstance, HWND hwndClient,
280 HWND hwndServerName, HSZ hszApp, HSZ hszTopic)
281 {
282 HWND hwndServerConv;
283 WDML_CONV* pConv;
284
285 if (pInstance->unicode)
286 {
287 WNDCLASSEXW wndclass;
288
289 wndclass.cbSize = sizeof(wndclass);
290 wndclass.style = 0;
291 wndclass.lpfnWndProc = WDML_ServerConvProc;
292 wndclass.cbClsExtra = 0;
293 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
294 wndclass.hInstance = 0;
295 wndclass.hIcon = 0;
296 wndclass.hCursor = 0;
297 wndclass.hbrBackground = 0;
298 wndclass.lpszMenuName = NULL;
299 wndclass.lpszClassName = WDML_szServerConvClassW;
300 wndclass.hIconSm = 0;
301
302 RegisterClassExW(&wndclass);
303
304 hwndServerConv = CreateWindowW(WDML_szServerConvClassW, 0,
305 WS_CHILD, 0, 0, 0, 0,
306 hwndServerName, 0, 0, 0);
307 }
308 else
309 {
310 WNDCLASSEXA wndclass;
311
312 wndclass.cbSize = sizeof(wndclass);
313 wndclass.style = 0;
314 wndclass.lpfnWndProc = WDML_ServerConvProc;
315 wndclass.cbClsExtra = 0;
316 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
317 wndclass.hInstance = 0;
318 wndclass.hIcon = 0;
319 wndclass.hCursor = 0;
320 wndclass.hbrBackground = 0;
321 wndclass.lpszMenuName = NULL;
322 wndclass.lpszClassName = WDML_szServerConvClassA;
323 wndclass.hIconSm = 0;
324
325 RegisterClassExA(&wndclass);
326
327 hwndServerConv = CreateWindowA(WDML_szServerConvClassA, 0,
328 WS_CHILD, 0, 0, 0, 0,
329 hwndServerName, 0, 0, 0);
330 }
331
332 TRACE("Created convServer=%p (nameServer=%p) for instance=%08lx unicode=%d\n",
333 hwndServerConv, hwndServerName, pInstance->instanceID, pInstance->unicode);
334
335 pConv = WDML_AddConv(pInstance, WDML_SERVER_SIDE, hszApp, hszTopic,
336 hwndClient, hwndServerConv);
337 if (pConv)
338 {
339 SetWindowLongPtrW(hwndServerConv, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
340 SetWindowLongPtrW(hwndServerConv, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
341
342 /* this should be the only place using SendMessage for WM_DDE_ACK */
343 /* note: sent messages shall not use packing */
344 SendMessageW(hwndClient, WM_DDE_ACK, (WPARAM)hwndServerConv,
345 MAKELPARAM(WDML_MakeAtomFromHsz(hszApp), WDML_MakeAtomFromHsz(hszTopic)));
346 /* we assume we're connected since we've sent an answer...
347 * I'm not sure what we can do... it doesn't look like the return value
348 * of SendMessage is used... sigh...
349 */
350 pConv->wStatus |= ST_CONNECTED;
351 }
352 else
353 {
354 NtUserDestroyWindow(hwndServerConv);
355 }
356 return pConv;
357 }
358
359 /******************************************************************
360 * WDML_ServerNameProc
361 *
362 *
363 */
364 static LRESULT CALLBACK WDML_ServerNameProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
365 {
366 HWND hwndClient;
367 HSZ hszApp, hszTop;
368 HDDEDATA hDdeData;
369 WDML_INSTANCE* pInstance;
370 UINT_PTR uiLo, uiHi;
371
372 switch (iMsg)
373 {
374 case WM_DDE_INITIATE:
375
376 /* wParam -- sending window handle
377 LOWORD(lParam) -- application atom
378 HIWORD(lParam) -- topic atom */
379
380 TRACE("WM_DDE_INITIATE message received!\n");
381 hwndClient = (HWND)wParam;
382
383 pInstance = WDML_GetInstanceFromWnd(hwndServer);
384 if (!pInstance) return 0;
385 TRACE("idInst=%ld, threadID=0x%lx\n", pInstance->instanceID, GetCurrentThreadId());
386
387 /* don't free DDEParams, since this is a broadcast */
388 UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLo, &uiHi);
389
390 hszApp = WDML_MakeHszFromAtom(pInstance, uiLo);
391 hszTop = WDML_MakeHszFromAtom(pInstance, uiHi);
392
393 if (!(pInstance->CBFflags & CBF_FAIL_CONNECTIONS))
394 {
395 BOOL self = FALSE;
396 CONVCONTEXT cc;
397 CONVCONTEXT* pcc = NULL;
398 WDML_CONV* pConv;
399 char buf[256];
400
401 if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
402 WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
403 {
404 self = TRUE;
405 }
406 /* FIXME: so far, we don't grab distant convcontext, so only check if remote is
407 * handled under DDEML, and if so build a default context
408 */
409 if ((GetClassNameA(hwndClient, buf, sizeof(buf)) &&
410 lstrcmpiA(buf, WDML_szClientConvClassA) == 0) ||
411 (GetClassNameW(hwndClient, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
412 lstrcmpiW((LPWSTR)buf, WDML_szClientConvClassW) == 0))
413 {
414 pcc = &cc;
415 memset(pcc, 0, sizeof(*pcc));
416 pcc->cb = sizeof(*pcc);
417 pcc->iCodePage = IsWindowUnicode(hwndClient) ? CP_WINUNICODE : CP_WINANSI;
418 }
419 if ((pInstance->CBFflags & CBF_FAIL_SELFCONNECTIONS) && self)
420 {
421 TRACE("Don't do self connection as requested\n");
422 }
423 else if (hszApp && hszTop)
424 {
425 WDML_SERVER* pServer = (WDML_SERVER*)GetWindowLongPtrW(hwndServer, GWL_WDML_SERVER);
426
427 /* check filters for name service */
428 if (!pServer->filterOn || DdeCmpStringHandles(pServer->hszService, hszApp) == 0)
429 {
430 /* pass on to the callback */
431 hDdeData = WDML_InvokeCallback(pInstance, XTYP_CONNECT,
432 0, 0, hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
433 if ((ULONG_PTR)hDdeData)
434 {
435 pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
436 hszApp, hszTop);
437 if (pConv)
438 {
439 if (pcc) pConv->wStatus |= ST_ISLOCAL;
440 WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
441 hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
442 }
443 }
444 }
445 }
446 else if (pInstance->servers)
447 {
448 /* pass on to the callback */
449 hDdeData = WDML_InvokeCallback(pInstance, XTYP_WILDCONNECT,
450 0, 0, hszTop, hszApp, 0, (ULONG_PTR)pcc, self);
451
452 if (hDdeData == CBR_BLOCK)
453 {
454 /* MS doc is not consistent here */
455 FIXME("CBR_BLOCK returned for WILDCONNECT\n");
456 }
457 else if ((ULONG_PTR)hDdeData != 0)
458 {
459 HSZPAIR* hszp;
460
461 hszp = (HSZPAIR*)DdeAccessData(hDdeData, NULL);
462 if (hszp)
463 {
464 int i;
465 for (i = 0; hszp[i].hszSvc && hszp[i].hszTopic; i++)
466 {
467 pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
468 hszp[i].hszSvc, hszp[i].hszTopic);
469 if (pConv)
470 {
471 if (pcc) pConv->wStatus |= ST_ISLOCAL;
472 WDML_InvokeCallback(pInstance, XTYP_CONNECT_CONFIRM, 0, (HCONV)pConv,
473 hszp[i].hszTopic, hszp[i].hszSvc, 0, (ULONG_PTR)pcc, self);
474 }
475 }
476 DdeUnaccessData(hDdeData);
477 }
478 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
479 }
480 }
481 }
482
483 return 0;
484
485 case WM_DDE_REQUEST:
486 FIXME("WM_DDE_REQUEST message received!\n");
487 return 0;
488 case WM_DDE_ADVISE:
489 FIXME("WM_DDE_ADVISE message received!\n");
490 return 0;
491 case WM_DDE_UNADVISE:
492 FIXME("WM_DDE_UNADVISE message received!\n");
493 return 0;
494 case WM_DDE_EXECUTE:
495 FIXME("WM_DDE_EXECUTE message received!\n");
496 return 0;
497 case WM_DDE_POKE:
498 FIXME("WM_DDE_POKE message received!\n");
499 return 0;
500 case WM_DDE_TERMINATE:
501 FIXME("WM_DDE_TERMINATE message received!\n");
502 return 0;
503 default:
504 break;
505 }
506
507 return DefWindowProcW(hwndServer, iMsg, wParam, lParam);
508 }
509
510 /******************************************************************
511 * WDML_ServerQueueRequest
512 *
513 *
514 */
515 static WDML_XACT* WDML_ServerQueueRequest(WDML_CONV* pConv, LPARAM lParam)
516 {
517 UINT_PTR uiLo, uiHi;
518 WDML_XACT* pXAct;
519
520 UnpackDDElParam(WM_DDE_REQUEST, lParam, &uiLo, &uiHi);
521
522 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST,
523 uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
524 if (pXAct) pXAct->atom = uiHi;
525 return pXAct;
526 }
527
528 /******************************************************************
529 * WDML_ServerHandleRequest
530 *
531 *
532 */
533 static WDML_QUEUE_STATE WDML_ServerHandleRequest(WDML_CONV* pConv, WDML_XACT* pXAct)
534 {
535 HDDEDATA hDdeData = 0;
536 BOOL fAck = TRUE;
537
538 if (!(pConv->instance->CBFflags & CBF_FAIL_REQUESTS))
539 {
540
541 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_REQUEST, pXAct->wFmt, (HCONV)pConv,
542 pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
543 }
544
545 switch ((ULONG_PTR)hDdeData)
546 {
547 case 0:
548 TRACE("No data returned from the Callback\n");
549 fAck = FALSE;
550 break;
551
552 case (ULONG_PTR)CBR_BLOCK:
553 return WDML_QS_BLOCK;
554
555 default:
556 {
557 HGLOBAL hMem = WDML_DataHandle2Global(hDdeData, TRUE, FALSE, FALSE, FALSE);
558 if (!PostMessageW(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
559 ReuseDDElParam(pXAct->lParam, WM_DDE_REQUEST, WM_DDE_DATA,
560 (UINT_PTR)hMem, (UINT_PTR)pXAct->atom)))
561 {
562 pConv->instance->lastError = DMLERR_POSTMSG_FAILED;
563 DdeFreeDataHandle(hDdeData);
564 GlobalFree(hMem);
565 fAck = FALSE;
566 }
567 }
568 break;
569 }
570
571 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_REQUEST);
572
573 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
574
575 return WDML_QS_HANDLED;
576 }
577
578 /******************************************************************
579 * WDML_ServerQueueAdvise
580 *
581 *
582 */
583 static WDML_XACT* WDML_ServerQueueAdvise(WDML_CONV* pConv, LPARAM lParam)
584 {
585 UINT_PTR uiLo, uiHi;
586 WDML_XACT* pXAct;
587
588 /* XTYP_ADVSTART transaction:
589 establish link and save link info to InstanceInfoTable */
590
591 if (!UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLo, &uiHi))
592 return NULL;
593
594 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE,
595 0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
596 if (pXAct)
597 {
598 pXAct->hMem = (HGLOBAL)uiLo;
599 pXAct->atom = uiHi;
600 }
601 return pXAct;
602 }
603
604 /******************************************************************
605 * WDML_ServerHandleAdvise
606 *
607 *
608 */
609 static WDML_QUEUE_STATE WDML_ServerHandleAdvise(WDML_CONV* pConv, WDML_XACT* pXAct)
610 {
611 UINT uType;
612 WDML_LINK* pLink;
613 DDEADVISE* pDdeAdvise;
614 HDDEDATA hDdeData = 0;
615 BOOL fAck = TRUE;
616
617 pDdeAdvise = GlobalLock(pXAct->hMem);
618 uType = XTYP_ADVSTART |
619 (pDdeAdvise->fDeferUpd ? XTYPF_NODATA : 0) |
620 (pDdeAdvise->fAckReq ? XTYPF_ACKREQ : 0);
621
622 if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
623 {
624 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_ADVSTART, pDdeAdvise->cfFormat,
625 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
626 }
627
628 switch ((ULONG_PTR)hDdeData)
629 {
630 case 0:
631 TRACE("No data returned from the Callback\n");
632 fAck = FALSE;
633 break;
634
635 case (ULONG_PTR)CBR_BLOCK:
636 return WDML_QS_BLOCK;
637
638 default:
639 /* billx: first to see if the link is already created. */
640 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
641 pXAct->hszItem, TRUE, pDdeAdvise->cfFormat);
642
643 if (pLink != NULL)
644 {
645 /* we found a link, and only need to modify it in case it changes */
646 pLink->transactionType = uType;
647 }
648 else
649 {
650 TRACE("Adding Link with hConv %p\n", pConv);
651 WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
652 uType, pXAct->hszItem, pDdeAdvise->cfFormat);
653 }
654 break;
655 }
656
657 GlobalUnlock(pXAct->hMem);
658 if (fAck)
659 {
660 GlobalFree(pXAct->hMem);
661 }
662 pXAct->hMem = 0;
663
664 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_ADVISE);
665
666 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
667
668 return WDML_QS_HANDLED;
669 }
670
671 /******************************************************************
672 * WDML_ServerQueueUnadvise
673 *
674 *
675 */
676 static WDML_XACT* WDML_ServerQueueUnadvise(WDML_CONV* pConv, LPARAM lParam)
677 {
678 UINT_PTR uiLo, uiHi;
679 WDML_XACT* pXAct;
680
681 UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
682
683 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE,
684 uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
685 if (pXAct) pXAct->atom = uiHi;
686 return pXAct;
687 }
688
689 /******************************************************************
690 * WDML_ServerHandleUnadvise
691 *
692 *
693 */
694 static WDML_QUEUE_STATE WDML_ServerHandleUnadvise(WDML_CONV* pConv, WDML_XACT* pXAct)
695 {
696 WDML_LINK* pLink;
697
698 if (pXAct->hszItem == NULL || pXAct->wFmt == 0)
699 {
700 ERR("Unsupported yet options (null item or clipboard format)\n");
701 return WDML_QS_ERROR;
702 }
703
704 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
705 pXAct->hszItem, TRUE, pXAct->wFmt);
706 if (pLink == NULL)
707 {
708 ERR("Couldn't find link for %p, dropping request\n", pXAct->hszItem);
709 FreeDDElParam(WM_DDE_UNADVISE, pXAct->lParam);
710 return WDML_QS_ERROR;
711 }
712
713 if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
714 {
715 WDML_InvokeCallback(pConv->instance, XTYP_ADVSTOP, pXAct->wFmt, (HCONV)pConv,
716 pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
717 }
718
719 WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
720 pXAct->hszItem, pXAct->wFmt);
721
722 /* send back ack */
723 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, TRUE, pXAct->atom,
724 pXAct->lParam, WM_DDE_UNADVISE);
725
726 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
727
728 return WDML_QS_HANDLED;
729 }
730
731 /******************************************************************
732 * WDML_QueueExecute
733 *
734 *
735 */
736 static WDML_XACT* WDML_ServerQueueExecute(WDML_CONV* pConv, LPARAM lParam)
737 {
738 WDML_XACT* pXAct;
739
740 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
741 if (pXAct)
742 {
743 pXAct->hMem = (HGLOBAL)lParam;
744 }
745 return pXAct;
746 }
747
748 static BOOL data_looks_unicode( const WCHAR *data, DWORD size )
749 {
750 DWORD i;
751
752 if (size % sizeof(WCHAR)) return FALSE;
753 for (i = 0; i < size / sizeof(WCHAR); i++) if (data[i] > 255) return FALSE;
754 return TRUE;
755 }
756
757 /* convert data to Unicode, unless it looks like it's already Unicode */
758 static HDDEDATA map_A_to_W( DWORD instance, void *ptr, DWORD size )
759 {
760 HDDEDATA ret;
761 DWORD len;
762 const char *end;
763
764 if (!data_looks_unicode( ptr, size ))
765 {
766 if ((end = memchr( ptr, 0, size ))) size = end + 1 - (const char *)ptr;
767 len = MultiByteToWideChar( CP_ACP, 0, ptr, size, NULL, 0 );
768 ret = DdeCreateDataHandle( instance, NULL, len * sizeof(WCHAR), 0, 0, CF_TEXT, 0);
769 MultiByteToWideChar( CP_ACP, 0, ptr, size, (WCHAR *)DdeAccessData(ret, NULL), len );
770 }
771 else ret = DdeCreateDataHandle( instance, ptr, size, 0, 0, CF_TEXT, 0 );
772
773 return ret;
774 }
775
776 /* convert data to ANSI, unless it looks like it's not in Unicode format */
777 static HDDEDATA map_W_to_A( DWORD instance, void *ptr, DWORD size )
778 {
779 HDDEDATA ret;
780 DWORD len;
781 const WCHAR *end;
782
783 if (data_looks_unicode( ptr, size ))
784 {
785 size /= sizeof(WCHAR);
786 if ((end = wmemchr( ptr, 0, size ))) size = end + 1 - (const WCHAR *)ptr;
787 len = WideCharToMultiByte( CP_ACP, 0, ptr, size, NULL, 0, NULL, NULL );
788 ret = DdeCreateDataHandle( instance, NULL, len, 0, 0, CF_TEXT, 0);
789 WideCharToMultiByte( CP_ACP, 0, ptr, size, (char *)DdeAccessData(ret, NULL), len, NULL, NULL );
790 }
791 else ret = DdeCreateDataHandle( instance, ptr, size, 0, 0, CF_TEXT, 0 );
792
793 return ret;
794 }
795
796 /******************************************************************
797 * WDML_ServerHandleExecute
798 *
799 *
800 */
801 static WDML_QUEUE_STATE WDML_ServerHandleExecute(WDML_CONV* pConv, WDML_XACT* pXAct)
802 {
803 HDDEDATA hDdeData = DDE_FNOTPROCESSED;
804 BOOL fAck = FALSE, fBusy = FALSE;
805
806 if (!(pConv->instance->CBFflags & CBF_FAIL_EXECUTES))
807 {
808 LPVOID ptr = GlobalLock(pXAct->hMem);
809 DWORD size = GlobalSize(pXAct->hMem);
810
811 if (ptr)
812 {
813 if (pConv->instance->unicode) /* Unicode server, try to map A->W */
814 hDdeData = map_A_to_W( pConv->instance->instanceID, ptr, size );
815 else if (!IsWindowUnicode( pConv->hwndClient )) /* ANSI server and client, try to map W->A */
816 hDdeData = map_W_to_A( pConv->instance->instanceID, ptr, size );
817 else
818 hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, ptr, size, 0, 0, CF_TEXT, 0);
819 GlobalUnlock(pXAct->hMem);
820 }
821 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_EXECUTE, 0, (HCONV)pConv,
822 pConv->hszTopic, 0, hDdeData, 0L, 0L);
823 }
824
825 switch ((ULONG_PTR)hDdeData)
826 {
827 case (ULONG_PTR)CBR_BLOCK:
828 return WDML_QS_BLOCK;
829
830 case DDE_FACK:
831 fAck = TRUE;
832 break;
833 case DDE_FBUSY:
834 fBusy = TRUE;
835 break;
836 default:
837 FIXME("Unsupported returned value %p\n", hDdeData);
838 /* fall through */
839 case DDE_FNOTPROCESSED:
840 break;
841 }
842 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, (UINT_PTR)pXAct->hMem, 0, 0);
843
844 return WDML_QS_HANDLED;
845 }
846
847 /******************************************************************
848 * WDML_ServerQueuePoke
849 *
850 *
851 */
852 static WDML_XACT* WDML_ServerQueuePoke(WDML_CONV* pConv, LPARAM lParam)
853 {
854 UINT_PTR uiLo, uiHi;
855 WDML_XACT* pXAct;
856
857 UnpackDDElParam(WM_DDE_POKE, lParam, &uiLo, &uiHi);
858
859 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE,
860 0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
861 if (pXAct)
862 {
863 pXAct->atom = uiHi;
864 pXAct->hMem = (HGLOBAL)uiLo;
865 }
866 return pXAct;
867 }
868
869 /******************************************************************
870 * WDML_ServerHandlePoke
871 *
872 *
873 */
874 static WDML_QUEUE_STATE WDML_ServerHandlePoke(WDML_CONV* pConv, WDML_XACT* pXAct)
875 {
876 DDEPOKE* pDdePoke;
877 HDDEDATA hDdeData;
878 BOOL fBusy = FALSE, fAck = FALSE;
879
880 pDdePoke = GlobalLock(pXAct->hMem);
881 if (!pDdePoke)
882 {
883 return WDML_QS_ERROR;
884 }
885
886 if (!(pConv->instance->CBFflags & CBF_FAIL_POKES))
887 {
888 hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, pDdePoke->Value,
889 GlobalSize(pXAct->hMem) - FIELD_OFFSET(DDEPOKE, Value),
890 0, 0, pDdePoke->cfFormat, 0);
891 if (hDdeData)
892 {
893 HDDEDATA hDdeDataOut;
894
895 hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_POKE, pDdePoke->cfFormat,
896 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
897 hDdeData, 0, 0);
898 switch ((ULONG_PTR)hDdeDataOut)
899 {
900 case DDE_FACK:
901 fAck = TRUE;
902 break;
903 case DDE_FBUSY:
904 fBusy = TRUE;
905 break;
906 default:
907 FIXME("Unsupported returned value %p\n", hDdeDataOut);
908 /* fal through */
909 case DDE_FNOTPROCESSED:
910 break;
911 }
912 DdeFreeDataHandle(hDdeData);
913 }
914 }
915 GlobalUnlock(pXAct->hMem);
916
917 if (!fAck)
918 {
919 GlobalFree(pXAct->hMem);
920 }
921 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, pXAct->atom, pXAct->lParam, WM_DDE_POKE);
922
923 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
924
925 return WDML_QS_HANDLED;
926 }
927
928 /******************************************************************
929 * WDML_ServerQueueTerminate
930 *
931 *
932 */
933 static WDML_XACT* WDML_ServerQueueTerminate(WDML_CONV* pConv, LPARAM lParam)
934 {
935 WDML_XACT* pXAct;
936
937 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
938 return pXAct;
939 }
940
941 /******************************************************************
942 * WDML_ServerHandleTerminate
943 *
944 *
945 */
946 static WDML_QUEUE_STATE WDML_ServerHandleTerminate(WDML_CONV* pConv, WDML_XACT* pXAct)
947 {
948 /* billx: two things to remove: the conv, and associated links.
949 * Respond with another WM_DDE_TERMINATE iMsg.
950 */
951 if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
952 {
953 WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv, 0, 0,
954 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
955 }
956 PostMessageW(pConv->hwndClient, WM_DDE_TERMINATE, (WPARAM)pConv->hwndServer, 0);
957 WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
958
959 return WDML_QS_HANDLED;
960 }
961
962 /******************************************************************
963 * WDML_ServerHandle
964 *
965 *
966 */
967 WDML_QUEUE_STATE WDML_ServerHandle(WDML_CONV* pConv, WDML_XACT* pXAct)
968 {
969 WDML_QUEUE_STATE qs = WDML_QS_ERROR;
970
971 switch (pXAct->ddeMsg)
972 {
973 case WM_DDE_INITIATE:
974 FIXME("WM_DDE_INITIATE shouldn't be there!\n");
975 break;
976 case WM_DDE_REQUEST:
977 qs = WDML_ServerHandleRequest(pConv, pXAct);
978 break;
979
980 case WM_DDE_ADVISE:
981 qs = WDML_ServerHandleAdvise(pConv, pXAct);
982 break;
983
984 case WM_DDE_UNADVISE:
985 qs = WDML_ServerHandleUnadvise(pConv, pXAct);
986 break;
987
988 case WM_DDE_EXECUTE:
989 qs = WDML_ServerHandleExecute(pConv, pXAct);
990 break;
991
992 case WM_DDE_POKE:
993 qs = WDML_ServerHandlePoke(pConv, pXAct);
994 break;
995
996 case WM_DDE_TERMINATE:
997 qs = WDML_ServerHandleTerminate(pConv, pXAct);
998 break;
999
1000 case WM_DDE_ACK:
1001 WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
1002 break;
1003
1004 default:
1005 FIXME("Unsupported message %d\n", pXAct->ddeMsg);
1006 }
1007 return qs;
1008 }
1009
1010 /******************************************************************
1011 * WDML_ServerConvProc
1012 *
1013 *
1014 */
1015 static LRESULT CALLBACK WDML_ServerConvProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
1016 {
1017 WDML_INSTANCE* pInstance;
1018 WDML_CONV* pConv;
1019 WDML_XACT* pXAct = NULL;
1020
1021 TRACE("%p %04x %08Ix %08Ix\n", hwndServer, iMsg, wParam, lParam);
1022
1023 if (iMsg == WM_DESTROY)
1024 {
1025 pConv = WDML_GetConvFromWnd(hwndServer);
1026 if (pConv && !(pConv->wStatus & ST_TERMINATED))
1027 {
1028 WDML_ServerHandleTerminate(pConv, NULL);
1029 }
1030 }
1031 if (iMsg < WM_DDE_FIRST || iMsg > WM_DDE_LAST)
1032 {
1033 return IsWindowUnicode(hwndServer) ? DefWindowProcW(hwndServer, iMsg, wParam, lParam) :
1034 DefWindowProcA(hwndServer, iMsg, wParam, lParam);
1035 }
1036
1037 pInstance = WDML_GetInstanceFromWnd(hwndServer);
1038 pConv = WDML_GetConvFromWnd(hwndServer);
1039
1040 if (!pConv)
1041 {
1042 ERR("Got a message (%x) on a not known conversation, dropping request\n", iMsg);
1043 return 0;
1044 }
1045 if (pConv->hwndClient != WIN_GetFullHandle( (HWND)wParam ) || pConv->hwndServer != hwndServer)
1046 {
1047 ERR("mismatch between C/S windows and conversation\n");
1048 return 0;
1049 }
1050 if (pConv->instance != pInstance || pConv->instance == NULL)
1051 {
1052 ERR("mismatch in instances\n");
1053 return 0;
1054 }
1055
1056 switch (iMsg)
1057 {
1058 case WM_DDE_INITIATE:
1059 FIXME("WM_DDE_INITIATE message received!\n");
1060 break;
1061
1062 case WM_DDE_REQUEST:
1063 pXAct = WDML_ServerQueueRequest(pConv, lParam);
1064 break;
1065
1066 case WM_DDE_ADVISE:
1067 pXAct = WDML_ServerQueueAdvise(pConv, lParam);
1068 break;
1069
1070 case WM_DDE_UNADVISE:
1071 pXAct = WDML_ServerQueueUnadvise(pConv, lParam);
1072 break;
1073
1074 case WM_DDE_EXECUTE:
1075 pXAct = WDML_ServerQueueExecute(pConv, lParam);
1076 break;
1077
1078 case WM_DDE_POKE:
1079 pXAct = WDML_ServerQueuePoke(pConv, lParam);
1080 break;
1081
1082 case WM_DDE_TERMINATE:
1083 pXAct = WDML_ServerQueueTerminate(pConv, lParam);
1084 break;
1085
1086 case WM_DDE_ACK:
1087 WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
1088 break;
1089
1090 default:
1091 FIXME("Unsupported message %x\n", iMsg);
1092 break;
1093 }
1094
1095 if (pXAct)
1096 {
1097 pXAct->lParam = lParam;
1098
1099 if ((pConv->wStatus & ST_BLOCKED) || WDML_ServerHandle(pConv, pXAct) == WDML_QS_BLOCK)
1100 {
1101 TRACE("Transactions are blocked, add to the queue and exit\n");
1102 WDML_QueueTransaction(pConv, pXAct);
1103 }
1104 else
1105 {
1106 WDML_FreeTransaction(pInstance, pXAct, TRUE);
1107 }
1108 }
1109 else
1110 pConv->instance->lastError = DMLERR_MEMORY_ERROR;
1111
1112 return 0;
1113 }
Windows API implementation