?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implement NtAccessCheck.
[wine/gsoc-2012-control.git] / dlls / user / dde / server.c
blob39b5c5d86ce0cf798f2135f5e29af13d519f00c4
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * DDEML library
5 *
6 * Copyright 1997 Alexandre Julliard
7 * Copyright 1997 Len White
8 * Copyright 1999 Keith Matthews
9 * Copyright 2000 Corel
10 * Copyright 2001 Eric Pouech
11 * Copyright 2003, 2004, 2005 Dmitry Timoshkov
12 *
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28 #include <stdarg.h>
29 #include <string.h>
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "winerror.h"
35 #include "dde.h"
36 #include "ddeml.h"
37 #include "win.h"
38 #include "wine/debug.h"
39 #include "dde/dde_private.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
42
43 static const WCHAR szServerNameClass[] = {'W','i','n','e','D','d','e','S','e','r','v','e','r','N','a','m','e',0};
44 const WCHAR WDML_szServerConvClass[] = {'W','i','n','e','D','d','e','S','e','r','v','e','r','C','o','n','v',0};
45
46 static LRESULT CALLBACK WDML_ServerNameProc(HWND, UINT, WPARAM, LPARAM);
47 static LRESULT CALLBACK WDML_ServerConvProc(HWND, UINT, WPARAM, LPARAM);
48
49 /******************************************************************************
50 * DdePostAdvise [USER32.@] Send transaction to DDE callback function.
51 *
52 * PARAMS
53 * idInst [I] Instance identifier
54 * hszTopic [I] Handle to topic name string
55 * hszItem [I] Handle to item name string
56 *
57 * RETURNS
58 * Success: TRUE
59 * Failure: FALSE
60 */
61 BOOL WINAPI DdePostAdvise(DWORD idInst, HSZ hszTopic, HSZ hszItem)
62 {
63 WDML_INSTANCE* pInstance = NULL;
64 WDML_LINK* pLink = NULL;
65 HDDEDATA hDdeData = 0;
66 HGLOBAL hItemData = 0;
67 WDML_CONV* pConv = NULL;
68 ATOM atom = 0;
69 UINT count;
70
71 TRACE("(%ld,%p,%p)\n", idInst, hszTopic, hszItem);
72
73 EnterCriticalSection(&WDML_CritSect);
74
75 pInstance = WDML_GetInstance(idInst);
76
77 if (pInstance == NULL || pInstance->links == NULL)
78 {
79 goto theError;
80 }
81
82 atom = WDML_MakeAtomFromHsz(hszItem);
83 if (!atom) goto theError;
84
85 /* first compute the number of links which will trigger a message */
86 count = 0;
87 for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
88 {
89 if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
90 {
91 count++;
92 }
93 }
94 if (count >= CADV_LATEACK)
95 {
96 FIXME("too high value for count\n");
97 count &= 0xFFFF;
98 }
99
100 for (pLink = pInstance->links[WDML_SERVER_SIDE]; pLink != NULL; pLink = pLink->next)
101 {
102 if (DdeCmpStringHandles(hszItem, pLink->hszItem) == 0)
103 {
104 hDdeData = WDML_InvokeCallback(pInstance, XTYP_ADVREQ, pLink->uFmt, pLink->hConv,
105 hszTopic, hszItem, 0, --count, 0);
106
107 if (hDdeData == (HDDEDATA)CBR_BLOCK)
108 {
109 /* MS doc is not consistent here */
110 FIXME("CBR_BLOCK returned for ADVREQ\n");
111 continue;
112 }
113 if (hDdeData)
114 {
115 if (pLink->transactionType & XTYPF_NODATA)
116 {
117 TRACE("no data\n");
118 hItemData = 0;
119 }
120 else
121 {
122 TRACE("with data\n");
123
124 hItemData = WDML_DataHandle2Global(hDdeData, FALSE, FALSE, FALSE, FALSE);
125 }
126
127 pConv = WDML_GetConv(pLink->hConv, TRUE);
128
129 if (pConv == NULL)
130 {
131 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
132 goto theError;
133 }
134
135 if (!PostMessageW(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
136 PackDDElParam(WM_DDE_DATA, (UINT_PTR)hItemData, atom)))
137 {
138 ERR("post message failed\n");
139 pConv->wStatus &= ~ST_CONNECTED;
140 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
141 GlobalFree(hItemData);
142 goto theError;
143 }
144 if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
145 }
146 }
147 }
148 LeaveCriticalSection(&WDML_CritSect);
149 return TRUE;
150 theError:
151 LeaveCriticalSection(&WDML_CritSect);
152 if (atom) GlobalDeleteAtom(atom);
153 return FALSE;
154 }
155
156
157 /******************************************************************************
158 * DdeNameService [USER32.@] {Un}registers service name of DDE server
159 *
160 * PARAMS
161 * idInst [I] Instance identifier
162 * hsz1 [I] Handle to service name string
163 * hsz2 [I] Reserved
164 * afCmd [I] Service name flags
165 *
166 * RETURNS
167 * Success: Non-zero
168 * Failure: 0
169 */
170 HDDEDATA WINAPI DdeNameService(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT afCmd)
171 {
172 WDML_SERVER* pServer;
173 WDML_INSTANCE* pInstance;
174 HDDEDATA hDdeData;
175 HWND hwndServer;
176 WNDCLASSEXW wndclass;
177
178 hDdeData = NULL;
179
180 TRACE("(%ld,%p,%p,%x)\n", idInst, hsz1, hsz2, afCmd);
181
182 EnterCriticalSection(&WDML_CritSect);
183
184 /* First check instance
185 */
186 pInstance = WDML_GetInstance(idInst);
187 if (pInstance == NULL)
188 {
189 TRACE("Instance not found as initialised\n");
190 /* Nothing has been initialised - exit now ! can return TRUE since effect is the same */
191 goto theError;
192 }
193
194 if (hsz2 != 0L)
195 {
196 /* Illegal, reserved parameter
197 */
198 pInstance->lastError = DMLERR_INVALIDPARAMETER;
199 WARN("Reserved parameter no-zero !!\n");
200 goto theError;
201 }
202 if (hsz1 == 0 && !(afCmd & DNS_UNREGISTER))
203 {
204 /* don't know if we should check this but it makes sense
205 * why supply REGISTER or filter flags if de-registering all
206 */
207 TRACE("General unregister unexpected flags\n");
208 pInstance->lastError = DMLERR_INVALIDPARAMETER;
209 goto theError;
210 }
211
212 switch (afCmd & (DNS_REGISTER | DNS_UNREGISTER))
213 {
214 case DNS_REGISTER:
215 pServer = WDML_FindServer(pInstance, hsz1, 0);
216 if (pServer)
217 {
218 ERR("Trying to register already registered service!\n");
219 pInstance->lastError = DMLERR_DLL_USAGE;
220 goto theError;
221 }
222
223 TRACE("Adding service name\n");
224
225 WDML_IncHSZ(pInstance, hsz1);
226
227 pServer = WDML_AddServer(pInstance, hsz1, 0);
228
229 WDML_BroadcastDDEWindows(WDML_szEventClass, WM_WDML_REGISTER,
230 pServer->atomService, pServer->atomServiceSpec);
231
232 wndclass.cbSize = sizeof(wndclass);
233 wndclass.style = 0;
234 wndclass.lpfnWndProc = WDML_ServerNameProc;
235 wndclass.cbClsExtra = 0;
236 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
237 wndclass.hInstance = 0;
238 wndclass.hIcon = 0;
239 wndclass.hCursor = 0;
240 wndclass.hbrBackground = 0;
241 wndclass.lpszMenuName = NULL;
242 wndclass.lpszClassName = szServerNameClass;
243 wndclass.hIconSm = 0;
244
245 RegisterClassExW(&wndclass);
246
247 LeaveCriticalSection(&WDML_CritSect);
248 hwndServer = CreateWindowW(szServerNameClass, NULL,
249 WS_POPUP, 0, 0, 0, 0,
250 0, 0, 0, 0);
251 EnterCriticalSection(&WDML_CritSect);
252
253 SetWindowLongPtrW(hwndServer, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
254 SetWindowLongPtrW(hwndServer, GWL_WDML_SERVER, (ULONG_PTR)pServer);
255 TRACE("Created nameServer=%p for instance=%08lx\n", hwndServer, idInst);
256
257 pServer->hwndServer = hwndServer;
258 break;
259
260 case DNS_UNREGISTER:
261 if (hsz1 == 0L)
262 {
263 /* General unregister situation
264 * terminate all server side pending conversations
265 */
266 while (pInstance->servers)
267 WDML_RemoveServer(pInstance, pInstance->servers->hszService, 0);
268 pInstance->servers = NULL;
269 TRACE("General de-register - finished\n");
270 }
271 else
272 {
273 WDML_RemoveServer(pInstance, hsz1, 0L);
274 }
275 break;
276 }
277
278 if (afCmd & (DNS_FILTERON | DNS_FILTEROFF))
279 {
280 /* Set filter flags on to hold notifications of connection
281 */
282 pServer = WDML_FindServer(pInstance, hsz1, 0);
283 if (!pServer)
284 {
285 /* trying to filter where no service names !!
286 */
287 pInstance->lastError = DMLERR_DLL_USAGE;
288 goto theError;
289 }
290 else
291 {
292 pServer->filterOn = (afCmd & DNS_FILTERON) != 0;
293 }
294 }
295 LeaveCriticalSection(&WDML_CritSect);
296 return (HDDEDATA)TRUE;
297
298 theError:
299 LeaveCriticalSection(&WDML_CritSect);
300 return FALSE;
301 }
302
303 /******************************************************************
304 * WDML_CreateServerConv
305 *
306 *
307 */
308 static WDML_CONV* WDML_CreateServerConv(WDML_INSTANCE* pInstance, HWND hwndClient,
309 HWND hwndServerName, HSZ hszApp, HSZ hszTopic)
310 {
311 HWND hwndServerConv;
312 WDML_CONV* pConv;
313 WNDCLASSEXW wndclass;
314
315 wndclass.cbSize = sizeof(wndclass);
316 wndclass.style = 0;
317 wndclass.lpfnWndProc = WDML_ServerConvProc;
318 wndclass.cbClsExtra = 0;
319 wndclass.cbWndExtra = 2 * sizeof(ULONG_PTR);
320 wndclass.hInstance = 0;
321 wndclass.hIcon = 0;
322 wndclass.hCursor = 0;
323 wndclass.hbrBackground = 0;
324 wndclass.lpszMenuName = NULL;
325 wndclass.lpszClassName = WDML_szServerConvClass;
326 wndclass.hIconSm = 0;
327
328 RegisterClassExW(&wndclass);
329
330 hwndServerConv = CreateWindowW(WDML_szServerConvClass, 0,
331 WS_CHILD, 0, 0, 0, 0,
332 hwndServerName, 0, 0, 0);
333
334 TRACE("Created convServer=%p (nameServer=%p) for instance=%08lx\n",
335 hwndServerConv, hwndServerName, pInstance->instanceID);
336
337 pConv = WDML_AddConv(pInstance, WDML_SERVER_SIDE, hszApp, hszTopic,
338 hwndClient, hwndServerConv);
339 if (pConv)
340 {
341 SetWindowLongPtrW(hwndServerConv, GWL_WDML_INSTANCE, (ULONG_PTR)pInstance);
342 SetWindowLongPtrW(hwndServerConv, GWL_WDML_CONVERSATION, (ULONG_PTR)pConv);
343
344 /* this should be the only place using SendMessage for WM_DDE_ACK */
345 /* note: sent messages shall not use packing */
346 SendMessageW(hwndClient, WM_DDE_ACK, (WPARAM)hwndServerConv,
347 MAKELPARAM(WDML_MakeAtomFromHsz(hszApp), WDML_MakeAtomFromHsz(hszTopic)));
348 /* we assume we're connected since we've sent an answer...
349 * I'm not sure what we can do... it doesn't look like the return value
350 * of SendMessage is used... sigh...
351 */
352 pConv->wStatus |= ST_CONNECTED;
353 }
354 else
355 {
356 DestroyWindow(hwndServerConv);
357 }
358 return pConv;
359 }
360
361 /******************************************************************
362 * WDML_ServerNameProc
363 *
364 *
365 */
366 static LRESULT CALLBACK WDML_ServerNameProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
367 {
368 HWND hwndClient;
369 HSZ hszApp, hszTop;
370 HDDEDATA hDdeData = 0;
371 WDML_INSTANCE* pInstance;
372 UINT_PTR uiLo, uiHi;
373
374 switch (iMsg)
375 {
376 case WM_DDE_INITIATE:
377
378 /* wParam -- sending window handle
379 LOWORD(lParam) -- application atom
380 HIWORD(lParam) -- topic atom */
381
382 TRACE("WM_DDE_INITIATE message received!\n");
383 hwndClient = (HWND)wParam;
384
385 pInstance = WDML_GetInstanceFromWnd(hwndServer);
386 TRACE("idInst=%ld, threadID=0x%lx\n", pInstance->instanceID, GetCurrentThreadId());
387 if (!pInstance) return 0;
388
389 /* don't free DDEParams, since this is a broadcast */
390 UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLo, &uiHi);
391
392 hszApp = WDML_MakeHszFromAtom(pInstance, uiLo);
393 hszTop = WDML_MakeHszFromAtom(pInstance, uiHi);
394
395 if (!(pInstance->CBFflags & CBF_FAIL_CONNECTIONS))
396 {
397 BOOL self = FALSE;
398 CONVCONTEXT cc;
399 CONVCONTEXT* pcc = NULL;
400 WDML_CONV* pConv;
401 WCHAR buf[256];
402
403 if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
404 WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
405 {
406 self = TRUE;
407 }
408 /* FIXME: so far, we don't grab distant convcontext, so only check if remote is
409 * handled under DDEML, and if so build a default context
410 */
411 if (GetClassNameW(hwndClient, buf, sizeof(buf)/sizeof(WCHAR)) &&
412 lstrcmpiW(buf, WDML_szClientConvClass) == 0)
413 {
414 pcc = &cc;
415 memset(pcc, 0, sizeof(*pcc));
416 pcc->cb = sizeof(*pcc);
417 pcc->iCodePage = CP_WINUNICODE;
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 == (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 DdeFreeDataHandle(hDdeData);
563 GlobalFree(hMem);
564 fAck = FALSE;
565 }
566 }
567 break;
568 }
569
570 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_REQUEST);
571
572 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
573
574 return WDML_QS_HANDLED;
575 }
576
577 /******************************************************************
578 * WDML_ServerQueueAdvise
579 *
580 *
581 */
582 static WDML_XACT* WDML_ServerQueueAdvise(WDML_CONV* pConv, LPARAM lParam)
583 {
584 UINT_PTR uiLo, uiHi;
585 WDML_XACT* pXAct;
586
587 /* XTYP_ADVSTART transaction:
588 establish link and save link info to InstanceInfoTable */
589
590 if (!UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLo, &uiHi))
591 return NULL;
592
593 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE,
594 0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
595 if (pXAct)
596 {
597 pXAct->hMem = (HGLOBAL)uiLo;
598 pXAct->atom = uiHi;
599 }
600 return pXAct;
601 }
602
603 /******************************************************************
604 * WDML_ServerHandleAdvise
605 *
606 *
607 */
608 static WDML_QUEUE_STATE WDML_ServerHandleAdvise(WDML_CONV* pConv, WDML_XACT* pXAct)
609 {
610 UINT uType;
611 WDML_LINK* pLink;
612 DDEADVISE* pDdeAdvise;
613 HDDEDATA hDdeData = 0;
614 BOOL fAck = TRUE;
615
616 pDdeAdvise = (DDEADVISE*)GlobalLock(pXAct->hMem);
617 uType = XTYP_ADVSTART |
618 (pDdeAdvise->fDeferUpd ? XTYPF_NODATA : 0) |
619 (pDdeAdvise->fAckReq ? XTYPF_ACKREQ : 0);
620
621 if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
622 {
623 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_ADVSTART, pDdeAdvise->cfFormat,
624 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
625 }
626
627 switch ((ULONG_PTR)hDdeData)
628 {
629 case 0:
630 TRACE("No data returned from the Callback\n");
631 fAck = FALSE;
632 break;
633
634 case (ULONG_PTR)CBR_BLOCK:
635 return WDML_QS_BLOCK;
636
637 default:
638 /* billx: first to see if the link is already created. */
639 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
640 pXAct->hszItem, TRUE, pDdeAdvise->cfFormat);
641
642 if (pLink != NULL)
643 {
644 /* we found a link, and only need to modify it in case it changes */
645 pLink->transactionType = uType;
646 }
647 else
648 {
649 TRACE("Adding Link with hConv %p\n", pConv);
650 WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
651 uType, pXAct->hszItem, pDdeAdvise->cfFormat);
652 }
653 break;
654 }
655
656 GlobalUnlock(pXAct->hMem);
657 if (fAck)
658 {
659 GlobalFree(pXAct->hMem);
660 }
661 pXAct->hMem = 0;
662
663 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_ADVISE);
664
665 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
666
667 return WDML_QS_HANDLED;
668 }
669
670 /******************************************************************
671 * WDML_ServerQueueUnadvise
672 *
673 *
674 */
675 static WDML_XACT* WDML_ServerQueueUnadvise(WDML_CONV* pConv, LPARAM lParam)
676 {
677 UINT_PTR uiLo, uiHi;
678 WDML_XACT* pXAct;
679
680 UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
681
682 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE,
683 uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
684 if (pXAct) pXAct->atom = uiHi;
685 return pXAct;
686 }
687
688 /******************************************************************
689 * WDML_ServerHandleUnadvise
690 *
691 *
692 */
693 static WDML_QUEUE_STATE WDML_ServerHandleUnadvise(WDML_CONV* pConv, WDML_XACT* pXAct)
694 {
695 WDML_LINK* pLink;
696
697 if (pXAct->hszItem == NULL || pXAct->wFmt == 0)
698 {
699 ERR("Unsupported yet options (null item or clipboard format)\n");
700 return WDML_QS_ERROR;
701 }
702
703 pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
704 pXAct->hszItem, TRUE, pXAct->wFmt);
705 if (pLink == NULL)
706 {
707 ERR("Couln'd find link for %p, dropping request\n", pXAct->hszItem);
708 FreeDDElParam(WM_DDE_UNADVISE, pXAct->lParam);
709 return WDML_QS_ERROR;
710 }
711
712 if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
713 {
714 WDML_InvokeCallback(pConv->instance, XTYP_ADVSTOP, pXAct->wFmt, (HCONV)pConv,
715 pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
716 }
717
718 WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
719 pXAct->hszItem, pXAct->wFmt);
720
721 /* send back ack */
722 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, TRUE, pXAct->atom,
723 pXAct->lParam, WM_DDE_UNADVISE);
724
725 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
726
727 return WDML_QS_HANDLED;
728 }
729
730 /******************************************************************
731 * WDML_QueueExecute
732 *
733 *
734 */
735 static WDML_XACT* WDML_ServerQueueExecute(WDML_CONV* pConv, LPARAM lParam)
736 {
737 WDML_XACT* pXAct;
738
739 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
740 if (pXAct)
741 {
742 pXAct->hMem = (HGLOBAL)lParam;
743 }
744 return pXAct;
745 }
746
747 /******************************************************************
748 * WDML_ServerHandleExecute
749 *
750 *
751 */
752 static WDML_QUEUE_STATE WDML_ServerHandleExecute(WDML_CONV* pConv, WDML_XACT* pXAct)
753 {
754 HDDEDATA hDdeData = DDE_FNOTPROCESSED;
755 BOOL fAck = FALSE, fBusy = FALSE;
756
757 if (!(pConv->instance->CBFflags & CBF_FAIL_EXECUTES))
758 {
759 LPVOID ptr = GlobalLock(pXAct->hMem);
760
761 if (ptr)
762 {
763 hDdeData = DdeCreateDataHandle(0, ptr, GlobalSize(pXAct->hMem),
764 0, 0, CF_TEXT, 0);
765 GlobalUnlock(pXAct->hMem);
766 }
767 hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_EXECUTE, 0, (HCONV)pConv,
768 pConv->hszTopic, 0, hDdeData, 0L, 0L);
769 }
770
771 switch ((ULONG_PTR)hDdeData)
772 {
773 case (ULONG_PTR)CBR_BLOCK:
774 return WDML_QS_BLOCK;
775
776 case DDE_FACK:
777 fAck = TRUE;
778 break;
779 case DDE_FBUSY:
780 fBusy = TRUE;
781 break;
782 default:
783 FIXME("Unsupported returned value %p\n", hDdeData);
784 /* fall through */
785 case DDE_FNOTPROCESSED:
786 break;
787 }
788 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, (UINT)pXAct->hMem, 0, 0);
789
790 return WDML_QS_HANDLED;
791 }
792
793 /******************************************************************
794 * WDML_ServerQueuePoke
795 *
796 *
797 */
798 static WDML_XACT* WDML_ServerQueuePoke(WDML_CONV* pConv, LPARAM lParam)
799 {
800 UINT_PTR uiLo, uiHi;
801 WDML_XACT* pXAct;
802
803 UnpackDDElParam(WM_DDE_POKE, lParam, &uiLo, &uiHi);
804
805 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE,
806 0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
807 if (pXAct)
808 {
809 pXAct->atom = uiHi;
810 pXAct->hMem = (HGLOBAL)uiLo;
811 }
812 return pXAct;
813 }
814
815 /******************************************************************
816 * WDML_ServerHandlePoke
817 *
818 *
819 */
820 static WDML_QUEUE_STATE WDML_ServerHandlePoke(WDML_CONV* pConv, WDML_XACT* pXAct)
821 {
822 DDEPOKE* pDdePoke;
823 HDDEDATA hDdeData;
824 BOOL fBusy = FALSE, fAck = FALSE;
825
826 pDdePoke = (DDEPOKE*)GlobalLock(pXAct->hMem);
827 if (!pDdePoke)
828 {
829 return WDML_QS_ERROR;
830 }
831
832 if (!(pConv->instance->CBFflags & CBF_FAIL_POKES))
833 {
834 hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, pDdePoke->Value,
835 GlobalSize(pXAct->hMem) - sizeof(DDEPOKE) + 1,
836 0, 0, pDdePoke->cfFormat, 0);
837 if (hDdeData)
838 {
839 HDDEDATA hDdeDataOut;
840
841 hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_POKE, pDdePoke->cfFormat,
842 (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
843 hDdeData, 0, 0);
844 switch ((ULONG_PTR)hDdeDataOut)
845 {
846 case DDE_FACK:
847 fAck = TRUE;
848 break;
849 case DDE_FBUSY:
850 fBusy = TRUE;
851 break;
852 default:
853 FIXME("Unsupported returned value %p\n", hDdeDataOut);
854 /* fal through */
855 case DDE_FNOTPROCESSED:
856 break;
857 }
858 DdeFreeDataHandle(hDdeData);
859 }
860 }
861 GlobalUnlock(pXAct->hMem);
862
863 if (!fAck)
864 {
865 GlobalFree(pXAct->hMem);
866 }
867 WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, pXAct->atom, pXAct->lParam, WM_DDE_POKE);
868
869 WDML_DecHSZ(pConv->instance, pXAct->hszItem);
870
871 return WDML_QS_HANDLED;
872 }
873
874 /******************************************************************
875 * WDML_ServerQueueTerminate
876 *
877 *
878 */
879 static WDML_XACT* WDML_ServerQueueTerminate(WDML_CONV* pConv, LPARAM lParam)
880 {
881 WDML_XACT* pXAct;
882
883 pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
884 return pXAct;
885 }
886
887 /******************************************************************
888 * WDML_ServerHandleTerminate
889 *
890 *
891 */
892 static WDML_QUEUE_STATE WDML_ServerHandleTerminate(WDML_CONV* pConv, WDML_XACT* pXAct)
893 {
894 /* billx: two things to remove: the conv, and associated links.
895 * Respond with another WM_DDE_TERMINATE iMsg.
896 */
897 if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
898 {
899 WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv, 0, 0,
900 0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
901 }
902 PostMessageW(pConv->hwndClient, WM_DDE_TERMINATE, (WPARAM)pConv->hwndServer, 0);
903 WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
904
905 return WDML_QS_HANDLED;
906 }
907
908 /******************************************************************
909 * WDML_ServerHandle
910 *
911 *
912 */
913 WDML_QUEUE_STATE WDML_ServerHandle(WDML_CONV* pConv, WDML_XACT* pXAct)
914 {
915 WDML_QUEUE_STATE qs = WDML_QS_ERROR;
916
917 switch (pXAct->ddeMsg)
918 {
919 case WM_DDE_INITIATE:
920 FIXME("WM_DDE_INITIATE shouldn't be there!\n");
921 break;
922 case WM_DDE_REQUEST:
923 qs = WDML_ServerHandleRequest(pConv, pXAct);
924 break;
925
926 case WM_DDE_ADVISE:
927 qs = WDML_ServerHandleAdvise(pConv, pXAct);
928 break;
929
930 case WM_DDE_UNADVISE:
931 qs = WDML_ServerHandleUnadvise(pConv, pXAct);
932 break;
933
934 case WM_DDE_EXECUTE:
935 qs = WDML_ServerHandleExecute(pConv, pXAct);
936 break;
937
938 case WM_DDE_POKE:
939 qs = WDML_ServerHandlePoke(pConv, pXAct);
940 break;
941
942 case WM_DDE_TERMINATE:
943 qs = WDML_ServerHandleTerminate(pConv, pXAct);
944 break;
945
946 case WM_DDE_ACK:
947 WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
948 break;
949
950 default:
951 FIXME("Unsupported message %d\n", pXAct->ddeMsg);
952 }
953 return qs;
954 }
955
956 /******************************************************************
957 * WDML_ServerConvProc
958 *
959 *
960 */
961 static LRESULT CALLBACK WDML_ServerConvProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
962 {
963 WDML_INSTANCE* pInstance;
964 WDML_CONV* pConv;
965 WDML_XACT* pXAct = NULL;
966
967 TRACE("%p %04x %08x %08lx\n", hwndServer, iMsg, wParam , lParam);
968
969 if (iMsg == WM_DESTROY)
970 {
971 EnterCriticalSection(&WDML_CritSect);
972 pConv = WDML_GetConvFromWnd(hwndServer);
973 if (pConv && !(pConv->wStatus & ST_TERMINATED))
974 {
975 WDML_ServerHandleTerminate(pConv, NULL);
976 }
977 LeaveCriticalSection(&WDML_CritSect);
978 }
979 if (iMsg < WM_DDE_FIRST || iMsg > WM_DDE_LAST)
980 {
981 return DefWindowProcW(hwndServer, iMsg, wParam, lParam);
982 }
983
984 EnterCriticalSection(&WDML_CritSect);
985
986 pInstance = WDML_GetInstanceFromWnd(hwndServer);
987 pConv = WDML_GetConvFromWnd(hwndServer);
988
989 if (!pConv)
990 {
991 ERR("Got a message (%x) on a not known conversation, dropping request\n", iMsg);
992 goto theError;
993 }
994 if (pConv->hwndClient != WIN_GetFullHandle( (HWND)wParam ) || pConv->hwndServer != hwndServer)
995 {
996 ERR("mismatch between C/S windows and converstation\n");
997 goto theError;
998 }
999 if (pConv->instance != pInstance || pConv->instance == NULL)
1000 {
1001 ERR("mismatch in instances\n");
1002 goto theError;
1003 }
1004
1005 switch (iMsg)
1006 {
1007 case WM_DDE_INITIATE:
1008 FIXME("WM_DDE_INITIATE message received!\n");
1009 break;
1010
1011 case WM_DDE_REQUEST:
1012 pXAct = WDML_ServerQueueRequest(pConv, lParam);
1013 break;
1014
1015 case WM_DDE_ADVISE:
1016 pXAct = WDML_ServerQueueAdvise(pConv, lParam);
1017 break;
1018
1019 case WM_DDE_UNADVISE:
1020 pXAct = WDML_ServerQueueUnadvise(pConv, lParam);
1021 break;
1022
1023 case WM_DDE_EXECUTE:
1024 pXAct = WDML_ServerQueueExecute(pConv, lParam);
1025 break;
1026
1027 case WM_DDE_POKE:
1028 pXAct = WDML_ServerQueuePoke(pConv, lParam);
1029 break;
1030
1031 case WM_DDE_TERMINATE:
1032 pXAct = WDML_ServerQueueTerminate(pConv, lParam);
1033 break;
1034
1035 case WM_DDE_ACK:
1036 WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
1037 break;
1038
1039 default:
1040 FIXME("Unsupported message %x\n", iMsg);
1041 }
1042
1043 if (pXAct)
1044 {
1045 pXAct->lParam = lParam;
1046 if (WDML_ServerHandle(pConv, pXAct) == WDML_QS_BLOCK)
1047 {
1048 WDML_QueueTransaction(pConv, pXAct);
1049 }
1050 else
1051 {
1052 WDML_FreeTransaction(pInstance, pXAct, TRUE);
1053 }
1054 }
1055 theError:
1056 LeaveCriticalSection(&WDML_CritSect);
1057 return 0;
1058 }
GSOC 2012 project to enhance the control panel