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,0x%x,0x%x)\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)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 = (HDDEDATA)NULL;
 178
 179     TRACE("(%ld,0x%x,0x%x,%d)\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)
 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=%04x 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     case DNS_FILTERON:
 276     case DNS_FILTEROFF:
 277         /*      Set filter flags on to hold notifications of connection
 278          */
 279         pServer = WDML_FindServer(pInstance, hsz1, 0);
 280         if (!pServer)
 281         {
 282             /*  trying to filter where no service names !!
 283              */
 284             pInstance->lastError = DMLERR_DLL_USAGE;
 285             goto theError;
 286         }
 287         else
 288         {
 289             pServer->filterOn = (afCmd == DNS_FILTERON);
 290         }
 291         break;
 292     }
 293     LeaveCriticalSection(&WDML_CritSect);
 294     return (HDDEDATA)TRUE;
 295
 296  theError:
 297     LeaveCriticalSection(&WDML_CritSect);
 298     return FALSE;
 299 }
 300
 301 /******************************************************************
 302  *              WDML_CreateServerConv
 303  *
 304  *
 305  */
 306 static WDML_CONV* WDML_CreateServerConv(WDML_INSTANCE* pInstance, HWND hwndClient,
 307                                         HWND hwndServerName, HSZ hszApp, HSZ hszTopic)
 308 {
 309     HWND        hwndServerConv;
 310     WDML_CONV*  pConv;
 311
 312     if (pInstance->unicode)
 313     {
 314         WNDCLASSEXW     wndclass;
 315
 316         wndclass.cbSize        = sizeof(wndclass);
 317         wndclass.style         = 0;
 318         wndclass.lpfnWndProc   = WDML_ServerConvProc;
 319         wndclass.cbClsExtra    = 0;
 320         wndclass.cbWndExtra    = 2 * sizeof(DWORD);
 321         wndclass.hInstance     = 0;
 322         wndclass.hIcon         = 0;
 323         wndclass.hCursor       = 0;
 324         wndclass.hbrBackground = 0;
 325         wndclass.lpszMenuName  = NULL;
 326         wndclass.lpszClassName = WDML_szServerConvClassW;
 327         wndclass.hIconSm       = 0;
 328
 329         RegisterClassExW(&wndclass);
 330
 331         hwndServerConv = CreateWindowW(WDML_szServerConvClassW, 0,
 332                                        WS_CHILD, 0, 0, 0, 0,
 333                                        hwndServerName, 0, 0, 0);
 334     }
 335     else
 336     {
 337         WNDCLASSEXA     wndclass;
 338
 339         wndclass.cbSize        = sizeof(wndclass);
 340         wndclass.style         = 0;
 341         wndclass.lpfnWndProc   = WDML_ServerConvProc;
 342         wndclass.cbClsExtra    = 0;
 343         wndclass.cbWndExtra    = 2 * sizeof(DWORD);
 344         wndclass.hInstance     = 0;
 345         wndclass.hIcon         = 0;
 346         wndclass.hCursor       = 0;
 347         wndclass.hbrBackground = 0;
 348         wndclass.lpszMenuName  = NULL;
 349         wndclass.lpszClassName = WDML_szServerConvClassA;
 350         wndclass.hIconSm       = 0;
 351
 352         RegisterClassExA(&wndclass);
 353
 354         hwndServerConv = CreateWindowA(WDML_szServerConvClassA, 0,
 355                                        WS_CHILD, 0, 0, 0, 0,
 356                                        hwndServerName, 0, 0, 0);
 357     }
 358
 359     TRACE("Created convServer=%04x (nameServer=%04x) for instance=%08lx\n",
 360           hwndServerConv, hwndServerName, pInstance->instanceID);
 361
 362     pConv = WDML_AddConv(pInstance, WDML_SERVER_SIDE, hszApp, hszTopic,
 363                          hwndClient, hwndServerConv);
 364     if (pConv)
 365     {
 366         SetWindowLongA(hwndServerConv, GWL_WDML_INSTANCE, (DWORD)pInstance);
 367         SetWindowLongA(hwndServerConv, GWL_WDML_CONVERSATION, (DWORD)pConv);
 368
 369         /* this should be the only place using SendMessage for WM_DDE_ACK */
 370         /* note: sent messages shall not use packing */
 371         SendMessageA(hwndClient, WM_DDE_ACK, (WPARAM)hwndServerConv,
 372                      MAKELPARAM(WDML_MakeAtomFromHsz(hszApp), WDML_MakeAtomFromHsz(hszTopic)));
 373         /* we assume we're connected since we've sent an answer...
 374          * I'm not sure what we can do... it doesn't look like the return value
 375          * of SendMessage is used... sigh...
 376          */
 377         pConv->wStatus |= ST_CONNECTED;
 378     }
 379     else
 380     {
 381         DestroyWindow(hwndServerConv);
 382     }
 383     return pConv;
 384 }
 385
 386 /******************************************************************
 387  *              WDML_ServerNameProc
 388  *
 389  *
 390  */
 391 static LRESULT CALLBACK WDML_ServerNameProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
 392 {
 393     HWND                hwndClient;
 394     HSZ                 hszApp, hszTop;
 395     HDDEDATA            hDdeData = 0;
 396     WDML_INSTANCE*      pInstance;
 397     UINT                uiLo, uiHi;
 398
 399     switch (iMsg)
 400     {
 401     case WM_DDE_INITIATE:
 402
 403         /* wParam         -- sending window handle
 404            LOWORD(lParam) -- application atom
 405            HIWORD(lParam) -- topic atom */
 406
 407         TRACE("WM_DDE_INITIATE message received!\n");
 408         hwndClient = (HWND)wParam;
 409
 410         pInstance = WDML_GetInstanceFromWnd(hwndServer);
 411         TRACE("idInst=%ld, threadID=0x%lx\n", pInstance->instanceID, GetCurrentThreadId());
 412         if (!pInstance) return 0;
 413
 414         /* don't free DDEParams, since this is a broadcast */
 415         UnpackDDElParam(WM_DDE_INITIATE, lParam, &uiLo, &uiHi);
 416
 417         hszApp = WDML_MakeHszFromAtom(pInstance, uiLo);
 418         hszTop = WDML_MakeHszFromAtom(pInstance, uiHi);
 419
 420         if (!(pInstance->CBFflags & CBF_FAIL_CONNECTIONS))
 421         {
 422             BOOL                self = FALSE;
 423             CONVCONTEXT         cc;
 424             CONVCONTEXT*        pcc = NULL;
 425             WDML_CONV*          pConv;
 426             char                buf[256];
 427
 428             if (GetWindowThreadProcessId(hwndClient, NULL) == GetWindowThreadProcessId(hwndServer, NULL) &&
 429                 WDML_GetInstanceFromWnd(hwndClient) == WDML_GetInstanceFromWnd(hwndServer))
 430             {
 431                 self = TRUE;
 432             }
 433             /* FIXME: so far, we don't grab distant convcontext, so only check if remote is
 434              * handled under DDEML, and if so build a default context
 435              */
 436             if ((GetClassNameA(hwndClient, buf, sizeof(buf)) &&
 437                  strcmp(buf, WDML_szClientConvClassA) == 0) ||
 438                 (GetClassNameW(hwndClient, (LPWSTR)buf, sizeof(buf)/sizeof(WCHAR)) &&
 439                  lstrcmpW((LPWSTR)buf, WDML_szClientConvClassW) == 0))
 440             {
 441                 pcc = &cc;
 442                 memset(pcc, 0, sizeof(*pcc));
 443                 pcc->cb = sizeof(*pcc);
 444                 pcc->iCodePage = IsWindowUnicode(hwndClient) ? CP_WINUNICODE : CP_WINANSI;
 445             }
 446             if ((pInstance->CBFflags & CBF_FAIL_SELFCONNECTIONS) && self)
 447             {
 448                 TRACE("Don't do self connection as requested\n");
 449             }
 450             else if (hszApp && hszTop)
 451             {
 452                 WDML_SERVER*    pServer = (WDML_SERVER*)GetWindowLongA(hwndServer, GWL_WDML_SERVER);
 453
 454                 /* check filters for name service */
 455                 if (!pServer->filterOn || DdeCmpStringHandles(pServer->hszService, hszApp) == 0)
 456                 {
 457                     /* pass on to the callback  */
 458                     hDdeData = WDML_InvokeCallback(pInstance, XTYP_CONNECT,
 459                                                    0, 0, hszTop, hszApp, 0, (DWORD)pcc, self);
 460                     if ((UINT)hDdeData)
 461                     {
 462                         pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
 463                                                       hszApp, hszTop);
 464                         if (pConv && pcc) pConv->wStatus |= ST_ISLOCAL;
 465                     }
 466                 }
 467             }
 468             else if (pInstance->servers)
 469             {
 470                 /* pass on to the callback  */
 471                 hDdeData = WDML_InvokeCallback(pInstance, XTYP_WILDCONNECT,
 472                                                0, 0, hszTop, hszApp, 0, (DWORD)pcc, self);
 473
 474                 if (hDdeData == (HDDEDATA)CBR_BLOCK)
 475                 {
 476                     /* MS doc is not consistent here */
 477                     FIXME("CBR_BLOCK returned for WILDCONNECT\n");
 478                 }
 479                 else if ((UINT)hDdeData != 0)
 480                 {
 481                     HSZPAIR*    hszp;
 482
 483                     hszp = (HSZPAIR*)DdeAccessData(hDdeData, NULL);
 484                     if (hszp)
 485                     {
 486                         int     i;
 487                         for (i = 0; hszp[i].hszSvc && hszp[i].hszTopic; i++)
 488                         {
 489                             pConv = WDML_CreateServerConv(pInstance, hwndClient, hwndServer,
 490                                                           hszp[i].hszSvc, hszp[i].hszTopic);
 491                             if (pConv && pcc) pConv->wStatus |= ST_ISLOCAL;
 492                         }
 493                         DdeUnaccessData(hDdeData);
 494                     }
 495                     if (!WDML_IsAppOwned(hDdeData)) DdeFreeDataHandle(hDdeData);
 496                 }
 497             }
 498         }
 499
 500         return 0;
 501
 502
 503     case WM_DDE_REQUEST:
 504         FIXME("WM_DDE_REQUEST message received!\n");
 505         return 0;
 506     case WM_DDE_ADVISE:
 507         FIXME("WM_DDE_ADVISE message received!\n");
 508         return 0;
 509     case WM_DDE_UNADVISE:
 510         FIXME("WM_DDE_UNADVISE message received!\n");
 511         return 0;
 512     case WM_DDE_EXECUTE:
 513         FIXME("WM_DDE_EXECUTE message received!\n");
 514         return 0;
 515     case WM_DDE_POKE:
 516         FIXME("WM_DDE_POKE message received!\n");
 517         return 0;
 518     case WM_DDE_TERMINATE:
 519         FIXME("WM_DDE_TERMINATE message received!\n");
 520         return 0;
 521
 522     }
 523
 524     return DefWindowProcA(hwndServer, iMsg, wParam, lParam);
 525 }
 526
 527 /******************************************************************
 528  *              WDML_ServerQueueRequest
 529  *
 530  *
 531  */
 532 static  WDML_XACT*      WDML_ServerQueueRequest(WDML_CONV* pConv, LPARAM lParam)
 533 {
 534     UINT                uiLo, uiHi;
 535     WDML_XACT*          pXAct;
 536
 537     UnpackDDElParam(WM_DDE_REQUEST, lParam, &uiLo, &uiHi);
 538
 539     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_REQUEST,
 540                                   uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
 541     if (pXAct) pXAct->atom = uiHi;
 542     return pXAct;
 543 }
 544
 545 /******************************************************************
 546  *              WDML_ServerHandleRequest
 547  *
 548  *
 549  */
 550 static  WDML_QUEUE_STATE WDML_ServerHandleRequest(WDML_CONV* pConv, WDML_XACT* pXAct)
 551 {
 552     HDDEDATA            hDdeData = 0;
 553     WDML_QUEUE_STATE    ret = WDML_QS_HANDLED;
 554
 555     if (!(pConv->instance->CBFflags & CBF_FAIL_REQUESTS))
 556     {
 557
 558         hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_REQUEST, pXAct->wFmt, (HCONV)pConv,
 559                                        pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
 560     }
 561
 562     switch ((DWORD)hDdeData)
 563     {
 564     case 0:
 565         WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, FALSE, pXAct->atom,
 566                      pXAct->lParam, WM_DDE_REQUEST);
 567         break;
 568     case CBR_BLOCK:
 569         ret = WDML_QS_BLOCK;
 570         break;
 571     default:
 572         {
 573             HGLOBAL     hMem = WDML_DataHandle2Global(hDdeData, FALSE, FALSE, FALSE, FALSE);
 574             if (!PostMessageA(pConv->hwndClient, WM_DDE_DATA, (WPARAM)pConv->hwndServer,
 575                               ReuseDDElParam(pXAct->lParam, WM_DDE_REQUEST, WM_DDE_DATA,
 576                                              (UINT)hMem, (UINT)pXAct->atom)))
 577             {
 578                 DdeFreeDataHandle(hDdeData);
 579                 GlobalFree(hMem);
 580             }
 581         }
 582         break;
 583     }
 584     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 585     return ret;
 586 }
 587
 588 /******************************************************************
 589  *              WDML_ServerQueueAdvise
 590  *
 591  *
 592  */
 593 static  WDML_XACT*      WDML_ServerQueueAdvise(WDML_CONV* pConv, LPARAM lParam)
 594 {
 595     UINT                uiLo, uiHi;
 596     WDML_XACT*          pXAct;
 597
 598     /* XTYP_ADVSTART transaction:
 599        establish link and save link info to InstanceInfoTable */
 600
 601     if (!UnpackDDElParam(WM_DDE_ADVISE, lParam, &uiLo, &uiHi))
 602         return NULL;
 603
 604     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_ADVISE,
 605                                   0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
 606     if (pXAct)
 607     {
 608         pXAct->hMem = (HGLOBAL)uiLo;
 609         pXAct->atom = uiHi;
 610     }
 611     return pXAct;
 612 }
 613
 614 /******************************************************************
 615  *              WDML_ServerHandleAdvise
 616  *
 617  *
 618  */
 619 static  WDML_QUEUE_STATE WDML_ServerHandleAdvise(WDML_CONV* pConv, WDML_XACT* pXAct)
 620 {
 621     UINT                uType;
 622     WDML_LINK*          pLink;
 623     DDEADVISE*          pDdeAdvise;
 624     HDDEDATA            hDdeData;
 625     BOOL                fAck;
 626
 627     pDdeAdvise = (DDEADVISE*)GlobalLock(pXAct->hMem);
 628     uType = XTYP_ADVSTART |
 629             (pDdeAdvise->fDeferUpd ? XTYPF_NODATA : 0) |
 630             (pDdeAdvise->fAckReq ? XTYPF_ACKREQ : 0);
 631
 632     if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
 633     {
 634         hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_ADVSTART, pDdeAdvise->cfFormat,
 635                                        (HCONV)pConv, pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
 636     }
 637     else
 638     {
 639         hDdeData = 0;
 640     }
 641
 642     if ((UINT)hDdeData)
 643     {
 644         fAck           = TRUE;
 645
 646         /* billx: first to see if the link is already created. */
 647         pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 648                               pXAct->hszItem, TRUE, pDdeAdvise->cfFormat);
 649
 650         if (pLink != NULL)
 651         {
 652             /* we found a link, and only need to modify it in case it changes */
 653             pLink->transactionType = uType;
 654         }
 655         else
 656         {
 657             TRACE("Adding Link with hConv=0x%lx\n", (DWORD)pConv);
 658             WDML_AddLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 659                          uType, pXAct->hszItem, pDdeAdvise->cfFormat);
 660         }
 661     }
 662     else
 663     {
 664         TRACE("No data returned from the Callback\n");
 665         fAck = FALSE;
 666     }
 667
 668     GlobalUnlock(pXAct->hMem);
 669     if (fAck)
 670     {
 671         GlobalFree(pXAct->hMem);
 672     }
 673     pXAct->hMem = 0;
 674
 675     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, fAck, pXAct->atom, pXAct->lParam, WM_DDE_ADVISE);
 676
 677     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 678
 679     return WDML_QS_HANDLED;
 680 }
 681
 682 /******************************************************************
 683  *              WDML_ServerQueueUnadvise
 684  *
 685  *
 686  */
 687 static  WDML_XACT* WDML_ServerQueueUnadvise(WDML_CONV* pConv, LPARAM lParam)
 688 {
 689     UINT                uiLo, uiHi;
 690     WDML_XACT*          pXAct;
 691
 692     UnpackDDElParam(WM_DDE_UNADVISE, lParam, &uiLo, &uiHi);
 693
 694     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_UNADVISE,
 695                                   uiLo, WDML_MakeHszFromAtom(pConv->instance, uiHi));
 696     if (pXAct) pXAct->atom = uiHi;
 697     return pXAct;
 698 }
 699
 700 /******************************************************************
 701  *              WDML_ServerHandleUnadvise
 702  *
 703  *
 704  */
 705 static  WDML_QUEUE_STATE WDML_ServerHandleUnadvise(WDML_CONV* pConv, WDML_XACT* pXAct)
 706 {
 707     WDML_LINK*  pLink;
 708
 709     if (pXAct->hszItem == (HSZ)0 || pXAct->wFmt == 0)
 710     {
 711         ERR("Unsupported yet options (null item or clipboard format)\n");
 712         return WDML_QS_ERROR;
 713     }
 714
 715     pLink = WDML_FindLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 716                           pXAct->hszItem, TRUE, pXAct->wFmt);
 717     if (pLink == NULL)
 718     {
 719         ERR("Couln'd find link for %08lx, dropping request\n", (DWORD)pXAct->hszItem);
 720         FreeDDElParam(WM_DDE_UNADVISE, pXAct->lParam);
 721         return WDML_QS_ERROR;
 722     }
 723
 724     if (!(pConv->instance->CBFflags & CBF_FAIL_ADVISES))
 725     {
 726         WDML_InvokeCallback(pConv->instance, XTYP_ADVSTOP, pXAct->wFmt, (HCONV)pConv,
 727                             pConv->hszTopic, pXAct->hszItem, 0, 0, 0);
 728     }
 729
 730     WDML_RemoveLink(pConv->instance, (HCONV)pConv, WDML_SERVER_SIDE,
 731                     pXAct->hszItem, pXAct->wFmt);
 732
 733     /* send back ack */
 734     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, FALSE, TRUE, pXAct->atom,
 735                  pXAct->lParam, WM_DDE_UNADVISE);
 736
 737     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 738
 739     return WDML_QS_HANDLED;
 740 }
 741
 742 /******************************************************************
 743  *              WDML_QueueExecute
 744  *
 745  *
 746  */
 747 static  WDML_XACT* WDML_ServerQueueExecute(WDML_CONV* pConv, LPARAM lParam)
 748 {
 749     WDML_XACT*  pXAct;
 750
 751     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_EXECUTE, 0, 0);
 752     if (pXAct)
 753     {
 754         pXAct->hMem    = (HGLOBAL)lParam;
 755     }
 756     return pXAct;
 757 }
 758
 759  /******************************************************************
 760  *              WDML_ServerHandleExecute
 761  *
 762  *
 763  */
 764 static  WDML_QUEUE_STATE WDML_ServerHandleExecute(WDML_CONV* pConv, WDML_XACT* pXAct)
 765 {
 766     HDDEDATA    hDdeData = DDE_FNOTPROCESSED;
 767     BOOL        fAck = FALSE, fBusy = FALSE;
 768
 769     if (!(pConv->instance->CBFflags & CBF_FAIL_EXECUTES))
 770     {
 771         LPVOID  ptr = GlobalLock(pXAct->hMem);
 772
 773         if (ptr)
 774         {
 775             hDdeData = DdeCreateDataHandle(0, ptr, GlobalSize(pXAct->hMem),
 776                                            0, 0, CF_TEXT, 0);
 777             GlobalUnlock(pXAct->hMem);
 778         }
 779         hDdeData = WDML_InvokeCallback(pConv->instance, XTYP_EXECUTE, 0, (HCONV)pConv,
 780                                        pConv->hszTopic, 0, hDdeData, 0L, 0L);
 781     }
 782
 783     switch ((UINT)hDdeData)
 784     {
 785     case DDE_FACK:
 786         fAck = TRUE;
 787         break;
 788     case DDE_FBUSY:
 789         fBusy = TRUE;
 790         break;
 791     default:
 792         WARN("Bad result code\n");
 793         /* fall through */
 794     case DDE_FNOTPROCESSED:
 795         break;
 796     }
 797     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, pXAct->hMem, 0, 0);
 798
 799     return WDML_QS_HANDLED;
 800 }
 801
 802 /******************************************************************
 803  *              WDML_ServerQueuePoke
 804  *
 805  *
 806  */
 807 static  WDML_XACT* WDML_ServerQueuePoke(WDML_CONV* pConv, LPARAM lParam)
 808 {
 809     UINT                uiLo, uiHi;
 810     WDML_XACT*          pXAct;
 811
 812     UnpackDDElParam(WM_DDE_POKE, lParam, &uiLo, &uiHi);
 813
 814     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_POKE,
 815                                   0, WDML_MakeHszFromAtom(pConv->instance, uiHi));
 816     if (pXAct)
 817     {
 818         pXAct->atom = uiHi;
 819         pXAct->hMem = (HGLOBAL)uiLo;
 820     }
 821     return pXAct;
 822 }
 823
 824 /******************************************************************
 825  *              WDML_ServerHandlePoke
 826  *
 827  *
 828  */
 829 static  WDML_QUEUE_STATE WDML_ServerHandlePoke(WDML_CONV* pConv, WDML_XACT* pXAct)
 830 {
 831     DDEPOKE*            pDdePoke;
 832     HDDEDATA            hDdeData;
 833     BOOL                fBusy = FALSE, fAck = FALSE;
 834
 835     pDdePoke = (DDEPOKE*)GlobalLock(pXAct->hMem);
 836     if (!pDdePoke)
 837     {
 838         return WDML_QS_ERROR;
 839     }
 840
 841     if (!(pConv->instance->CBFflags & CBF_FAIL_POKES))
 842     {
 843         hDdeData = DdeCreateDataHandle(pConv->instance->instanceID, pDdePoke->Value,
 844                                        GlobalSize(pXAct->hMem) - sizeof(DDEPOKE) + 1,
 845                                        0, 0, pDdePoke->cfFormat, 0);
 846         if (hDdeData)
 847         {
 848             HDDEDATA    hDdeDataOut;
 849
 850             hDdeDataOut = WDML_InvokeCallback(pConv->instance, XTYP_POKE, pDdePoke->cfFormat,
 851                                               (HCONV)pConv, pConv->hszTopic, pXAct->hszItem,
 852                                               hDdeData, 0, 0);
 853             switch ((UINT)hDdeDataOut)
 854             {
 855             case DDE_FACK:
 856                 fAck = TRUE;
 857                 break;
 858             case DDE_FBUSY:
 859                 fBusy = TRUE;
 860                 break;
 861             default:
 862                 FIXME("Unsupported returned value %08lx\n", (DWORD)hDdeDataOut);
 863                 /* fal through */
 864             case DDE_FNOTPROCESSED:
 865                 break;
 866             }
 867             DdeFreeDataHandle(hDdeData);
 868         }
 869     }
 870     GlobalUnlock(pXAct->hMem);
 871
 872     if (!fAck)
 873     {
 874         GlobalFree(pXAct->hMem);
 875     }
 876     WDML_PostAck(pConv, WDML_SERVER_SIDE, 0, fBusy, fAck, pXAct->atom, pXAct->lParam, WM_DDE_POKE);
 877
 878     WDML_DecHSZ(pConv->instance, pXAct->hszItem);
 879
 880     return WDML_QS_HANDLED;
 881 }
 882
 883 /******************************************************************
 884  *              WDML_ServerQueueTerminate
 885  *
 886  *
 887  */
 888 static  WDML_XACT*      WDML_ServerQueueTerminate(WDML_CONV* pConv, LPARAM lParam)
 889 {
 890     WDML_XACT*  pXAct;
 891
 892     pXAct = WDML_AllocTransaction(pConv->instance, WM_DDE_TERMINATE, 0, 0);
 893     return pXAct;
 894 }
 895
 896 /******************************************************************
 897  *              WDML_ServerHandleTerminate
 898  *
 899  *
 900  */
 901 static  WDML_QUEUE_STATE WDML_ServerHandleTerminate(WDML_CONV* pConv, WDML_XACT* pXAct)
 902 {
 903     /* billx: two things to remove: the conv, and associated links.
 904      * Respond with another WM_DDE_TERMINATE iMsg.
 905      */
 906     if (!(pConv->instance->CBFflags & CBF_SKIP_DISCONNECTS))
 907     {
 908         WDML_InvokeCallback(pConv->instance, XTYP_DISCONNECT, 0, (HCONV)pConv, 0, 0,
 909                             0, 0, (pConv->wStatus & ST_ISSELF) ? 1 : 0);
 910     }
 911     PostMessageA(pConv->hwndClient, WM_DDE_TERMINATE, (WPARAM)pConv->hwndServer, 0);
 912     WDML_RemoveConv(pConv, WDML_SERVER_SIDE);
 913
 914     return WDML_QS_HANDLED;
 915 }
 916
 917 /******************************************************************
 918  *              WDML_ServerHandle
 919  *
 920  *
 921  */
 922 static WDML_QUEUE_STATE WDML_ServerHandle(WDML_CONV* pConv, WDML_XACT* pXAct)
 923 {
 924     WDML_QUEUE_STATE    qs = WDML_QS_ERROR;
 925
 926     switch (pXAct->ddeMsg)
 927     {
 928     case WM_DDE_INITIATE:
 929         FIXME("WM_DDE_INITIATE shouldn't be there!\n");
 930         break;
 931     case WM_DDE_REQUEST:
 932         qs = WDML_ServerHandleRequest(pConv, pXAct);
 933         break;
 934
 935     case WM_DDE_ADVISE:
 936         qs = WDML_ServerHandleAdvise(pConv, pXAct);
 937         break;
 938
 939     case WM_DDE_UNADVISE:
 940         qs = WDML_ServerHandleUnadvise(pConv, pXAct);
 941         break;
 942
 943     case WM_DDE_EXECUTE:
 944         qs = WDML_ServerHandleExecute(pConv, pXAct);
 945         break;
 946
 947     case WM_DDE_POKE:
 948         qs = WDML_ServerHandlePoke(pConv, pXAct);
 949         break;
 950
 951     case WM_DDE_TERMINATE:
 952         qs = WDML_ServerHandleTerminate(pConv, pXAct);
 953         break;
 954
 955     case WM_DDE_ACK:
 956         WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
 957         break;
 958
 959     default:
 960         FIXME("Unsupported message %d\n", pXAct->ddeMsg);
 961     }
 962     return qs;
 963 }
 964
 965 /******************************************************************
 966  *              WDML_ServerConvProc
 967  *
 968  *
 969  */
 970 static LRESULT CALLBACK WDML_ServerConvProc(HWND hwndServer, UINT iMsg, WPARAM wParam, LPARAM lParam)
 971 {
 972     WDML_INSTANCE*      pInstance;
 973     WDML_CONV*          pConv;
 974     WDML_XACT*          pXAct = NULL;
 975
 976     if (iMsg == WM_DESTROY)
 977     {
 978         EnterCriticalSection(&WDML_CritSect);
 979         pConv = WDML_GetConvFromWnd(hwndServer);
 980         if (pConv && !(pConv->wStatus & ST_TERMINATED))
 981         {
 982             WDML_ServerHandleTerminate(pConv, NULL);
 983         }
 984         LeaveCriticalSection(&WDML_CritSect);
 985     }
 986     if (iMsg < WM_DDE_FIRST || iMsg > WM_DDE_LAST)
 987     {
 988         return DefWindowProcA(hwndServer, iMsg, wParam, lParam);
 989     }
 990
 991     EnterCriticalSection(&WDML_CritSect);
 992
 993     pInstance = WDML_GetInstanceFromWnd(hwndServer);
 994     pConv = WDML_GetConvFromWnd(hwndServer);
 995
 996     if (!pConv)
 997     {
 998         ERR("Got a message (%u) on a not known conversation, dropping request\n", iMsg);
 999         goto theError;
1000     }
1001     if (pConv->hwndClient != WIN_GetFullHandle( (HWND)wParam ) || pConv->hwndServer != hwndServer)
1002     {
1003         ERR("mismatch between C/S windows and converstation\n");
1004         goto theError;
1005     }
1006     if (pConv->instance != pInstance || pConv->instance == NULL)
1007     {
1008         ERR("mismatch in instances\n");
1009         goto theError;
1010     }
1011
1012     switch (iMsg)
1013     {
1014     case WM_DDE_INITIATE:
1015         FIXME("WM_DDE_INITIATE message received!\n");
1016         break;
1017
1018     case WM_DDE_REQUEST:
1019         pXAct = WDML_ServerQueueRequest(pConv, lParam);
1020         break;
1021
1022     case WM_DDE_ADVISE:
1023         pXAct = WDML_ServerQueueAdvise(pConv, lParam);
1024         break;
1025
1026     case WM_DDE_UNADVISE:
1027         pXAct = WDML_ServerQueueUnadvise(pConv, lParam);
1028         break;
1029
1030     case WM_DDE_EXECUTE:
1031         pXAct = WDML_ServerQueueExecute(pConv, lParam);
1032         break;
1033
1034     case WM_DDE_POKE:
1035         pXAct = WDML_ServerQueuePoke(pConv, lParam);
1036         break;
1037
1038     case WM_DDE_TERMINATE:
1039         pXAct = WDML_ServerQueueTerminate(pConv, lParam);
1040         break;
1041
1042     case WM_DDE_ACK:
1043         WARN("Shouldn't receive a ACK message (never requests them). Ignoring it\n");
1044         break;
1045
1046     default:
1047         FIXME("Unsupported message %d\n", iMsg);
1048     }
1049
1050     if (pXAct)
1051     {
1052         pXAct->lParam = lParam;
1053         if (WDML_ServerHandle(pConv, pXAct) == WDML_QS_BLOCK)
1054         {
1055             WDML_QueueTransaction(pConv, pXAct);
1056         }
1057         else
1058         {
1059             WDML_FreeTransaction(pInstance, pXAct, TRUE);
1060         }
1061     }
1062  theError:
1063     LeaveCriticalSection(&WDML_CritSect);
1064     return 0;
1065 }