git.oblomov.eu Git - wine/blob - dlls/user/dde/server.c

   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  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27 #include <string.h>
  28 #include "winbase.h"
  29 #include "windef.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/dde_private.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
  40
  41 static const char  szServerNameClassA[] = "DdeServerNameAnsi";
  42 const char  WDML_szServerConvClassA[] = "DdeServerConvAnsi";
  43 const WCHAR WDML_szServerConvClassW[] = {'D','d','e','S','e','r','v','e','r','C','o','n','v','U','n','i','c','o','d','e',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 (!PostMessageA(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     WNDCLASSEXA         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(DWORD);
 236         wndclass.hInstance     = 0;
 237         wndclass.hIcon         = 0;
 238         wndclass.hCursor       = 0;
 239         wndclass.hbrBackground = 0;
 240         wndclass.lpszMenuName  = NULL;
 241         wndclass.lpszClassName = szServerNameClassA;
 242         wndclass.hIconSm       = 0;
 243
 244         RegisterClassExA(&wndclass);
 245
 246         LeaveCriticalSection(&WDML_CritSect);
 247         hwndServer = CreateWindowA(szServerNameClassA, NULL,
 248                                    WS_POPUP, 0, 0, 0, 0,
 249                                    0, 0, 0, 0);
 250         EnterCriticalSection(&WDML_CritSect);
 251
 252         SetWindowLongA(hwndServer, GWL_WDML_INSTANCE, (DWORD)pInstance);
 253         SetWindowLongA(hwndServer, GWL_WDML_SERVER, (DWORD)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(DWORD);
 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(DWORD);
 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         SetWindowLongA(hwndServerConv, GWL_WDML_INSTANCE, (DWORD)pInstance);
 368         SetWindowLongA(hwndServerConv, GWL_WDML_CONVERSATION, (DWORD)pConv);
 369
 370         /* this should be the only place using SendMessage for WM_DDE_ACK */
 371         /* note: sent messages shall not use packing */
 372         SendMessageA(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                  strcmp(buf, WDML_szClientConvClassA) == 0) ||
 439                 (GetClassNameW(hwndClient, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
 440                  lstrcmpW((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*)GetWindowLongA(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, (DWORD)pcc, self);
 461                     if ((UINT)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, (DWORD)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, (DWORD)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 ((UINT)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, (DWORD)pcc, self);
 502                             }
 503                         }
 504                         DdeUnaccessData(hDdeData);
 505                     }
 506                     if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
 507                 }
 508             }
 509         }
 510
 511         return 0;
 512
 513
 514     case WM_DDE_REQUEST:
 515         FIXME("WM_DDE_REQUEST message received!\n");
 516         return 0;
 517     case WM_DDE_ADVISE:
 518         FIXME("WM_DDE_ADVISE message received!\n");
 519         return 0;
 520     case WM_DDE_UNADVISE:
 521         FIXME("WM_DDE_UNADVISE message received!\n");
 522         return 0;
 523     case WM_DDE_EXECUTE:
 524         FIXME("WM_DDE_EXECUTE message received!\n");
 525         return 0;
 526     case WM_DDE_POKE:
 527         FIXME("WM_DDE_POKE message received!\n");
 528         return 0;
 529     case WM_DDE_TERMINATE:
 530         FIXME("WM_DDE_TERMINATE message received!\n");
 531         return 0;
 532
 533     }
 534
 535     return DefWindowProcA(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     WDML_QUEUE_STATE    ret = WDML_QS_HANDLED;
 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         WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, FALSE, pXAct->atom,
 577                      pXAct->lParam, WM_DDE_REQUEST);
 578         break;
 579     case CBR_BLOCK:
 580         ret = WDML_QS_BLOCK;
 581         break;
 582     default:
 583         {
 584             HGLOBAL     hMem = WDML_DataHandle2Global(hDdeData, TRUE, FALSE, FALSE, FALSE);
 585             if (!PostMessageA(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
 586                               ReuseDDElParam(pXAct->lParam, WM_DDE_REQUEST, WM_DDE_DATA,
 587                                              (UINT_PTR)hMem, (UINT_PTR)pXAct->atom)))
 588             {
 589                 DdeFreeDataHandle(hDdeData);
 590                 GlobalFree(hMem);
 591             }
 592         }
 593         break;
 594     }
 595     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 596     return ret;
 597 }
 598
 599 /******************************************************************
 600  *              WDML_ServerQueueAdvise
 601  *
 602  *
 603  */
 604 static  WDML_XACT*      WDML_ServerQueueAdvise(WDML_CONV* pConv, LPARAM lParam)
 605 {
 606     UINT_PTR            uiLo, uiHi;
 607     WDML_XACT*          pXAct;
 608
 609     /* XTYP_ADVSTART transaction:
 610        establish link and save link info to InstanceInfoTable */
 611
 612     if (!UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLo, &uiHi))
 613         return NULL;
 614
 615     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE,
 616                                   0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
 617     if (pXAct)
 618     {
 619         pXAct->hMem = (HGLOBAL)uiLo;
 620         pXAct->atom = uiHi;
 621     }
 622     return pXAct;
 623 }
 624
 625 /******************************************************************
 626  *              WDML_ServerHandleAdvise
 627  *
 628  *
 629  */
 630 static  WDML_QUEUE_STATE WDML_ServerHandleAdvise(WDML_CONV* pConv, WDML_XACT* pXAct)
 631 {
 632     UINT                uType;
 633     WDML_LINK*          pLink;
 634     DDEADVISE*          pDdeAdvise;
 635     HDDEDATA            hDdeData;
 636     BOOL                fAck;
 637
 638     pDdeAdvise = (DDEADVISE*)GlobalLock(pXAct->hMem);
 639     uType = XTYP_ADVSTART |
 640             (pDdeAdvise->fDeferUpd ? XTYPF_NODATA : 0) |
 641             (pDdeAdvise->fAckReq ? XTYPF_ACKREQ : 0);
 642
 643     if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
 644     {
 645         hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_ADVSTART, pDdeAdvise->cfFormat,
 646                                        (HCONV)pConv, pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
 647     }
 648     else
 649     {
 650         hDdeData = 0;
 651     }
 652
 653     if ((UINT)hDdeData)
 654     {
 655         fAck           = TRUE;
 656
 657         /* billx: first to see if the link is already created. */
 658         pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 659                               pXAct->hszItem, TRUE, pDdeAdvise->cfFormat);
 660
 661         if (pLink != NULL)
 662         {
 663             /* we found a link, and only need to modify it in case it changes */
 664             pLink->transactionType = uType;
 665         }
 666         else
 667         {
 668             TRACE("Adding Link with hConv %p\n", pConv);
 669             WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 670                          uType, pXAct->hszItem, pDdeAdvise->cfFormat);
 671         }
 672     }
 673     else
 674     {
 675         TRACE("No data returned from the Callback\n");
 676         fAck = FALSE;
 677     }
 678
 679     GlobalUnlock(pXAct->hMem);
 680     if (fAck)
 681     {
 682         GlobalFree(pXAct->hMem);
 683     }
 684     pXAct->hMem = 0;
 685
 686     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_ADVISE);
 687
 688     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 689
 690     return WDML_QS_HANDLED;
 691 }
 692
 693 /******************************************************************
 694  *              WDML_ServerQueueUnadvise
 695  *
 696  *
 697  */
 698 static  WDML_XACT* WDML_ServerQueueUnadvise(WDML_CONV* pConv, LPARAM lParam)
 699 {
 700     UINT_PTR            uiLo, uiHi;
 701     WDML_XACT*          pXAct;
 702
 703     UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
 704
 705     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE,
 706                                   uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
 707     if (pXAct) pXAct->atom = uiHi;
 708     return pXAct;
 709 }
 710
 711 /******************************************************************
 712  *              WDML_ServerHandleUnadvise
 713  *
 714  *
 715  */
 716 static  WDML_QUEUE_STATE WDML_ServerHandleUnadvise(WDML_CONV* pConv, WDML_XACT* pXAct)
 717 {
 718     WDML_LINK*  pLink;
 719
 720     if (pXAct->hszItem == NULL || pXAct->wFmt == 0)
 721     {
 722         ERR("Unsupported yet options (null item or clipboard format)\n");
 723         return WDML_QS_ERROR;
 724     }
 725
 726     pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 727                           pXAct->hszItem, TRUE, pXAct->wFmt);
 728     if (pLink == NULL)
 729     {
 730         ERR("Couln'd find link for %p, dropping request\n", pXAct->hszItem);
 731         FreeDDElParam(WM_DDE_UNADVISE, pXAct->lParam);
 732         return WDML_QS_ERROR;
 733     }
 734
 735     if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
 736     {
 737         WDML_InvokeCallback(pConv->instance, XTYP_ADVSTOP, pXAct->wFmt, (HCONV)pConv,
 738                             pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
 739     }
 740
 741     WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 742                     pXAct->hszItem, pXAct->wFmt);
 743
 744     /* send back ack */
 745     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, TRUE, pXAct->atom,
 746                  pXAct->lParam, WM_DDE_UNADVISE);
 747
 748     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 749
 750     return WDML_QS_HANDLED;
 751 }
 752
 753 /******************************************************************
 754  *              WDML_QueueExecute
 755  *
 756  *
 757  */
 758 static  WDML_XACT* WDML_ServerQueueExecute(WDML_CONV* pConv, LPARAM lParam)
 759 {
 760     WDML_XACT*  pXAct;
 761
 762     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
 763     if (pXAct)
 764     {
 765         pXAct->hMem    = (HGLOBAL)lParam;
 766     }
 767     return pXAct;
 768 }
 769
 770  /******************************************************************
 771  *              WDML_ServerHandleExecute
 772  *
 773  *
 774  */
 775 static  WDML_QUEUE_STATE WDML_ServerHandleExecute(WDML_CONV* pConv, WDML_XACT* pXAct)
 776 {
 777     HDDEDATA    hDdeData = DDE_FNOTPROCESSED;
 778     BOOL        fAck = FALSE, fBusy = FALSE;
 779
 780     if (!(pConv->instance->CBFflags & CBF_FAIL_EXECUTES))
 781     {
 782         LPVOID  ptr = GlobalLock(pXAct->hMem);
 783
 784         if (ptr)
 785         {
 786             hDdeData = DdeCreateDataHandle(0, ptr, GlobalSize(pXAct->hMem),
 787                                            0, 0, CF_TEXT, 0);
 788             GlobalUnlock(pXAct->hMem);
 789         }
 790         hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_EXECUTE, 0, (HCONV)pConv,
 791                                        pConv->hszTopic, 0, hDdeData, 0L, 0L);
 792     }
 793
 794     switch ((UINT)hDdeData)
 795     {
 796     case DDE_FACK:
 797         fAck = TRUE;
 798         break;
 799     case DDE_FBUSY:
 800         fBusy = TRUE;
 801         break;
 802     default:
 803         WARN("Bad result code\n");
 804         /* fall through */
 805     case DDE_FNOTPROCESSED:
 806         break;
 807     }
 808     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, (UINT)pXAct->hMem, 0, 0);
 809
 810     return WDML_QS_HANDLED;
 811 }
 812
 813 /******************************************************************
 814  *              WDML_ServerQueuePoke
 815  *
 816  *
 817  */
 818 static  WDML_XACT* WDML_ServerQueuePoke(WDML_CONV* pConv, LPARAM lParam)
 819 {
 820     UINT_PTR            uiLo, uiHi;
 821     WDML_XACT*          pXAct;
 822
 823     UnpackDDElParam(WM_DDE_POKE, lParam, &uiLo, &uiHi);
 824
 825     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE,
 826                                   0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
 827     if (pXAct)
 828     {
 829         pXAct->atom = uiHi;
 830         pXAct->hMem = (HGLOBAL)uiLo;
 831     }
 832     return pXAct;
 833 }
 834
 835 /******************************************************************
 836  *              WDML_ServerHandlePoke
 837  *
 838  *
 839  */
 840 static  WDML_QUEUE_STATE WDML_ServerHandlePoke(WDML_CONV* pConv, WDML_XACT* pXAct)
 841 {
 842     DDEPOKE*            pDdePoke;
 843     HDDEDATA            hDdeData;
 844     BOOL                fBusy = FALSE, fAck = FALSE;
 845
 846     pDdePoke = (DDEPOKE*)GlobalLock(pXAct->hMem);
 847     if (!pDdePoke)
 848     {
 849         return WDML_QS_ERROR;
 850     }
 851
 852     if (!(pConv->instance->CBFflags & CBF_FAIL_POKES))
 853     {
 854         hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, pDdePoke->Value,
 855                                        GlobalSize(pXAct->hMem) - sizeof(DDEPOKE) + 1,
 856                                        0, 0, pDdePoke->cfFormat, 0);
 857         if (hDdeData)
 858         {
 859             HDDEDATA    hDdeDataOut;
 860
 861             hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_POKE, pDdePoke->cfFormat,
 862                                               (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
 863                                               hDdeData, 0, 0);
 864             switch ((ULONG_PTR)hDdeDataOut)
 865             {
 866             case DDE_FACK:
 867                 fAck = TRUE;
 868                 break;
 869             case DDE_FBUSY:
 870                 fBusy = TRUE;
 871                 break;
 872             default:
 873                 FIXME("Unsupported returned value %p\n", hDdeDataOut);
 874                 /* fal through */
 875             case DDE_FNOTPROCESSED:
 876                 break;
 877             }
 878             DdeFreeDataHandle(hDdeData);
 879         }
 880     }
 881     GlobalUnlock(pXAct->hMem);
 882
 883     if (!fAck)
 884     {
 885         GlobalFree(pXAct->hMem);
 886     }
 887     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, pXAct->atom, pXAct->lParam, WM_DDE_POKE);
 888
 889     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 890
 891     return WDML_QS_HANDLED;
 892 }
 893
 894 /******************************************************************
 895  *              WDML_ServerQueueTerminate
 896  *
 897  *
 898  */
 899 static  WDML_XACT*      WDML_ServerQueueTerminate(WDML_CONV* pConv, LPARAM lParam)
 900 {
 901     WDML_XACT*  pXAct;
 902
 903     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
 904     return pXAct;
 905 }
 906
 907 /******************************************************************
 908  *              WDML_ServerHandleTerminate
 909  *
 910  *
 911  */
 912 static  WDML_QUEUE_STATE WDML_ServerHandleTerminate(WDML_CONV* pConv, WDML_XACT* pXAct)
 913 {
 914     /* billx: two things to remove: the conv, and associated links.
 915      * Respond with another WM_DDE_TERMINATE iMsg.
 916      */
 917     if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
 918     {
 919         WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv, 0, 0,
 920                             0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
 921     }
 922     PostMessageA(pConv->hwndClient, WM_DDE_TERMINATE, (WPARAM)pConv->hwndServer, 0);
 923     WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
 924
 925     return WDML_QS_HANDLED;
 926 }
 927
 928 /******************************************************************
 929  *              WDML_ServerHandle
 930  *
 931  *
 932  */
 933 WDML_QUEUE_STATE WDML_ServerHandle(WDML_CONV* pConv, WDML_XACT* pXAct)
 934 {
 935     WDML_QUEUE_STATE    qs = WDML_QS_ERROR;
 936
 937     switch (pXAct->ddeMsg)
 938     {
 939     case WM_DDE_INITIATE:
 940         FIXME("WM_DDE_INITIATE shouldn't be there!\n");
 941         break;
 942     case WM_DDE_REQUEST:
 943         qs = WDML_ServerHandleRequest(pConv, pXAct);
 944         break;
 945
 946     case WM_DDE_ADVISE:
 947         qs = WDML_ServerHandleAdvise(pConv, pXAct);
 948         break;
 949
 950     case WM_DDE_UNADVISE:
 951         qs = WDML_ServerHandleUnadvise(pConv, pXAct);
 952         break;
 953
 954     case WM_DDE_EXECUTE:
 955         qs = WDML_ServerHandleExecute(pConv, pXAct);
 956         break;
 957
 958     case WM_DDE_POKE:
 959         qs = WDML_ServerHandlePoke(pConv, pXAct);
 960         break;
 961
 962     case WM_DDE_TERMINATE:
 963         qs = WDML_ServerHandleTerminate(pConv, pXAct);
 964         break;
 965
 966     case WM_DDE_ACK:
 967         WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
 968         break;
 969
 970     default:
 971         FIXME("Unsupported message %d\n", pXAct->ddeMsg);
 972     }
 973     return qs;
 974 }
 975
 976 /******************************************************************
 977  *              WDML_ServerConvProc
 978  *
 979  *
 980  */
 981 static LRESULT CALLBACK WDML_ServerConvProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
 982 {
 983     WDML_INSTANCE*      pInstance;
 984     WDML_CONV*          pConv;
 985     WDML_XACT*          pXAct = NULL;
 986
 987     if (iMsg == WM_DESTROY)
 988     {
 989         EnterCriticalSection(&WDML_CritSect);
 990         pConv = WDML_GetConvFromWnd(hwndServer);
 991         if (pConv && !(pConv->wStatus & ST_TERMINATED))
 992         {
 993             WDML_ServerHandleTerminate(pConv, NULL);
 994         }
 995         LeaveCriticalSection(&WDML_CritSect);
 996     }
 997     if (iMsg < WM_DDE_FIRST || iMsg > WM_DDE_LAST)
 998     {
 999         return DefWindowProcA(hwndServer, iMsg, wParam, lParam);
1000     }
1001
1002     EnterCriticalSection(&WDML_CritSect);
1003
1004     pInstance = WDML_GetInstanceFromWnd(hwndServer);
1005     pConv = WDML_GetConvFromWnd(hwndServer);
1006
1007     if (!pConv)
1008     {
1009         ERR("Got a message (%x) on a not known conversation, dropping request\n", iMsg);
1010         goto theError;
1011     }
1012     if (pConv->hwndClient != WIN_GetFullHandle( (HWND)wParam ) || pConv->hwndServer != hwndServer)
1013     {
1014         ERR("mismatch between C/S windows and converstation\n");
1015         goto theError;
1016     }
1017     if (pConv->instance != pInstance || pConv->instance == NULL)
1018     {
1019         ERR("mismatch in instances\n");
1020         goto theError;
1021     }
1022
1023     switch (iMsg)
1024     {
1025     case WM_DDE_INITIATE:
1026         FIXME("WM_DDE_INITIATE message received!\n");
1027         break;
1028
1029     case WM_DDE_REQUEST:
1030         pXAct = WDML_ServerQueueRequest(pConv, lParam);
1031         break;
1032
1033     case WM_DDE_ADVISE:
1034         pXAct = WDML_ServerQueueAdvise(pConv, lParam);
1035         break;
1036
1037     case WM_DDE_UNADVISE:
1038         pXAct = WDML_ServerQueueUnadvise(pConv, lParam);
1039         break;
1040
1041     case WM_DDE_EXECUTE:
1042         pXAct = WDML_ServerQueueExecute(pConv, lParam);
1043         break;
1044
1045     case WM_DDE_POKE:
1046         pXAct = WDML_ServerQueuePoke(pConv, lParam);
1047         break;
1048
1049     case WM_DDE_TERMINATE:
1050         pXAct = WDML_ServerQueueTerminate(pConv, lParam);
1051         break;
1052
1053     case WM_DDE_ACK:
1054         WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
1055         break;
1056
1057     default:
1058         FIXME("Unsupported message %x\n", iMsg);
1059     }
1060
1061     if (pXAct)
1062     {
1063         pXAct->lParam = lParam;
1064         if (WDML_ServerHandle(pConv, pXAct) == WDML_QS_BLOCK)
1065         {
1066             WDML_QueueTransaction(pConv, pXAct);
1067         }
1068         else
1069         {
1070             WDML_FreeTransaction(pInstance, pXAct, TRUE);
1071         }
1072     }
1073  theError:
1074     LeaveCriticalSection(&WDML_CritSect);
1075     return 0;
1076 }