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