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