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