git.oblomov.eu Git - wine/blob - dlls/ddeml.dll16/ddeml.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,2002,2009 Eric Pouech
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wine/windef16.h"
  33 #include "wine/winbase16.h"
  34 #include "wownt32.h"
  35 #include "dde.h"
  36 #include "ddeml.h"
  37 #include "wine/debug.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(ddeml);
  40
  41
  42 typedef HDDEDATA (CALLBACK *PFNCALLBACK16)(UINT16,UINT16,HCONV,HSZ,HSZ,HDDEDATA,
  43                                            DWORD,DWORD);
  44
  45 typedef struct
  46 {
  47     UINT16  cb;
  48     UINT16  wFlags;
  49     UINT16  wCountryID;
  50     INT16   iCodePage;
  51     DWORD   dwLangID;
  52     DWORD   dwSecurity;
  53 } CONVCONTEXT16, *LPCONVCONTEXT16;
  54
  55 typedef struct
  56 {
  57     DWORD          cb;
  58     DWORD          hUser;
  59     HCONV          hConvPartner;
  60     HSZ            hszSvcPartner;
  61     HSZ            hszServiceReq;
  62     HSZ            hszTopic;
  63     HSZ            hszItem;
  64     UINT16         wFmt;
  65     UINT16         wType;
  66     UINT16         wStatus;
  67     UINT16         wConvst;
  68     UINT16         wLastError;
  69     HCONVLIST      hConvList;
  70     CONVCONTEXT16  ConvCtxt;
  71 } CONVINFO16, *LPCONVINFO16;
  72
  73 static void map1632_conv_context(CONVCONTEXT* cc32, const CONVCONTEXT16* cc16)
  74 {
  75     cc32->cb = sizeof(*cc32);
  76     cc32->wFlags = cc16->wFlags;
  77     cc32->wCountryID = cc16->wCountryID;
  78     cc32->iCodePage = cc16->iCodePage;
  79     cc32->dwLangID = cc16->dwLangID;
  80     cc32->dwSecurity = cc16->dwSecurity;
  81 }
  82
  83 static void map3216_conv_context(CONVCONTEXT16* cc16, const CONVCONTEXT* cc32)
  84 {
  85     cc16->cb = sizeof(*cc16);
  86     cc16->wFlags = cc32->wFlags;
  87     cc16->wCountryID = cc32->wCountryID;
  88     cc16->iCodePage = cc32->iCodePage;
  89     cc16->dwLangID = cc32->dwLangID;
  90     cc16->dwSecurity = cc32->dwSecurity;
  91 }
  92
  93 /******************************************************************
  94  *              WDML_InvokeCallback16
  95  *
  96  *
  97  */
  98 static HDDEDATA CALLBACK WDML_InvokeCallback16(DWORD pfn16, UINT uType, UINT uFmt,
  99                                                HCONV hConv, HSZ hsz1, HSZ hsz2,
 100                                                HDDEDATA hdata, ULONG_PTR dwData1, ULONG_PTR dwData2)
 101 {
 102     DWORD               d1 = 0;
 103     HDDEDATA            ret;
 104     CONVCONTEXT16       cc16;
 105     WORD args[16];
 106
 107     switch (uType)
 108     {
 109     case XTYP_CONNECT:
 110     case XTYP_WILDCONNECT:
 111         if (dwData1)
 112         {
 113             map3216_conv_context(&cc16, (const CONVCONTEXT*)dwData1);
 114             d1 = MapLS(&cc16);
 115         }
 116         else
 117         break;
 118     default:
 119         d1 = dwData1;
 120         break;
 121     }
 122     args[15] = HIWORD(uType);
 123     args[14] = LOWORD(uType);
 124     args[13] = HIWORD(uFmt);
 125     args[12] = LOWORD(uFmt);
 126     args[11] = HIWORD(hConv);
 127     args[10] = LOWORD(hConv);
 128     args[9]  = HIWORD(hsz1);
 129     args[8]  = LOWORD(hsz1);
 130     args[7]  = HIWORD(hsz2);
 131     args[6]  = LOWORD(hsz2);
 132     args[5]  = HIWORD(hdata);
 133     args[4]  = LOWORD(hdata);
 134     args[3]  = HIWORD(d1);
 135     args[2]  = LOWORD(d1);
 136     args[1]  = HIWORD(dwData2);
 137     args[0]  = LOWORD(dwData2);
 138     WOWCallback16Ex(pfn16, WCB16_PASCAL, sizeof(args), args, (DWORD *)&ret);
 139
 140     switch (uType)
 141     {
 142     case XTYP_CONNECT:
 143     case XTYP_WILDCONNECT:
 144         if (d1 != 0) UnMapLS(d1);
 145         break;
 146     }
 147     return ret;
 148 }
 149
 150 #define MAX_THUNKS      32
 151 /* As DDEML doesn't provide a way to get back to an InstanceID when
 152  * a callback is run, we use thunk in order to implement simply the
 153  * 32bit->16bit callback mechanism.
 154  * For each 16bit instance, we create a thunk, which will be passed as
 155  * a 32bit callback. This thunk also stores (in the code!) the 16bit
 156  * address of the 16bit callback, and passes it back to
 157  * WDML_InvokeCallback16.
 158  * The code below is mainly to create the thunks themselved
 159  */
 160 #include "pshpack1.h"
 161 static struct ddeml_thunk
 162 {
 163     BYTE        popl_eax;        /* popl  %eax (return address) */
 164     BYTE        pushl_func;      /* pushl $pfn16 (16bit callback function) */
 165     SEGPTR      pfn16;
 166     BYTE        pushl_eax;       /* pushl %eax */
 167     BYTE        jmp;             /* ljmp WDML_InvokeCallback16 */
 168     DWORD       callback;
 169     DWORD       instId;          /* instance ID */
 170 } *DDEML16_Thunks;
 171 #include "poppack.h"
 172
 173 static CRITICAL_SECTION ddeml_cs;
 174 static CRITICAL_SECTION_DEBUG critsect_debug =
 175 {
 176     0, 0, &ddeml_cs,
 177     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 178       0, 0, { (DWORD_PTR)(__FILE__ ": ddeml_cs") }
 179 };
 180 static CRITICAL_SECTION ddeml_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 181
 182 static struct ddeml_thunk*      DDEML_AddThunk(DWORD instId, DWORD pfn16)
 183 {
 184     struct ddeml_thunk* thunk;
 185
 186     if (!DDEML16_Thunks)
 187     {
 188         DDEML16_Thunks = VirtualAlloc(NULL, MAX_THUNKS * sizeof(*DDEML16_Thunks), MEM_COMMIT,
 189                                       PAGE_EXECUTE_READWRITE);
 190         if (!DDEML16_Thunks) return NULL;
 191         for (thunk = DDEML16_Thunks; thunk < &DDEML16_Thunks[MAX_THUNKS]; thunk++)
 192         {
 193             thunk->popl_eax     = 0x58;   /* popl  %eax */
 194             thunk->pushl_func   = 0x68;   /* pushl $pfn16 */
 195             thunk->pfn16        = 0;
 196             thunk->pushl_eax    = 0x50;   /* pushl %eax */
 197             thunk->jmp          = 0xe9;   /* jmp WDML_InvokeCallback16 */
 198             thunk->callback     = (char *)WDML_InvokeCallback16 - (char *)(&thunk->callback + 1);
 199             thunk->instId       = 0;
 200         }
 201     }
 202     for (thunk = DDEML16_Thunks; thunk < &DDEML16_Thunks[MAX_THUNKS]; thunk++)
 203     {
 204         /* either instId is 0, and we're looking for an empty slot, or
 205          * instId is an already existing instance, and we should find its thunk
 206          */
 207         if (thunk->instId == instId)
 208         {
 209             thunk->pfn16 = pfn16;
 210             return thunk;
 211         }
 212     }
 213     FIXME("Out of ddeml-thunks. Bump MAX_THUNKS\n");
 214     return NULL;
 215 }
 216
 217 /******************************************************************************
 218  *            DdeInitialize   (DDEML.2)
 219  */
 220 UINT16 WINAPI DdeInitialize16(LPDWORD pidInst, PFNCALLBACK16 pfnCallback,
 221                               DWORD afCmd, DWORD ulRes)
 222 {
 223     UINT16 ret;
 224     struct ddeml_thunk* thunk;
 225
 226     EnterCriticalSection(&ddeml_cs);
 227     if ((thunk = DDEML_AddThunk(*pidInst, (DWORD)pfnCallback)))
 228     {
 229         ret = DdeInitializeA(pidInst, (PFNCALLBACK)thunk, afCmd, ulRes);
 230         if (ret == DMLERR_NO_ERROR) thunk->instId = *pidInst;
 231     }
 232     else ret = DMLERR_SYS_ERROR;
 233     LeaveCriticalSection(&ddeml_cs);
 234     return ret;
 235 }
 236
 237 /*****************************************************************
 238  *            DdeUninitialize   (DDEML.3)
 239  */
 240 BOOL16 WINAPI DdeUninitialize16(DWORD idInst)
 241 {
 242     struct ddeml_thunk* thunk;
 243     BOOL16              ret = FALSE;
 244
 245     if (!DdeUninitialize(idInst)) return FALSE;
 246     EnterCriticalSection(&ddeml_cs);
 247     for (thunk = DDEML16_Thunks; thunk < &DDEML16_Thunks[MAX_THUNKS]; thunk++)
 248     {
 249         if (thunk->instId == idInst)
 250         {
 251             thunk->instId = 0;
 252             ret = TRUE;
 253             break;
 254         }
 255     }
 256     LeaveCriticalSection(&ddeml_cs);
 257     if (!ret) FIXME("Should never happen\n");
 258     return ret;
 259 }
 260
 261 /*****************************************************************
 262  * DdeConnectList [DDEML.4]
 263  */
 264
 265 HCONVLIST WINAPI DdeConnectList16(DWORD idInst, HSZ hszService, HSZ hszTopic,
 266                                   HCONVLIST hConvList, LPCONVCONTEXT16 pCC16)
 267 {
 268     CONVCONTEXT         cc;
 269     CONVCONTEXT*        pCC = NULL;
 270
 271     if (pCC16)
 272         map1632_conv_context(pCC = &cc, pCC16);
 273     return DdeConnectList(idInst, hszService, hszTopic, hConvList, pCC);
 274 }
 275
 276 /*****************************************************************
 277  * DdeQueryNextServer [DDEML.5]
 278  */
 279 HCONV WINAPI DdeQueryNextServer16(HCONVLIST hConvList, HCONV hConvPrev)
 280 {
 281     return DdeQueryNextServer(hConvList, hConvPrev);
 282 }
 283
 284 /*****************************************************************
 285  *            DdeDisconnectList (DDEML.6)
 286  */
 287 BOOL16 WINAPI DdeDisconnectList16(HCONVLIST hConvList)
 288 {
 289     return (BOOL16)DdeDisconnectList(hConvList);
 290 }
 291
 292
 293 /*****************************************************************
 294  *              DdeQueryString (DDEML.23)
 295  */
 296 DWORD WINAPI DdeQueryString16(DWORD idInst, HSZ hsz, LPSTR lpsz, DWORD cchMax,
 297                               INT16 codepage)
 298 {
 299     return DdeQueryStringA(idInst, hsz, lpsz, cchMax, codepage);
 300 }
 301
 302 /*****************************************************************
 303  *            DdeConnect   (DDEML.7)
 304  */
 305 HCONV WINAPI DdeConnect16(DWORD idInst, HSZ hszService, HSZ hszTopic,
 306                           LPCONVCONTEXT16 pCC16)
 307 {
 308     CONVCONTEXT         cc;
 309     CONVCONTEXT*        pCC = NULL;
 310
 311     if (pCC16)
 312         map1632_conv_context(pCC = &cc, pCC16);
 313     return DdeConnect(idInst, hszService, hszTopic, pCC);
 314 }
 315
 316 /*****************************************************************
 317  *            DdeDisconnect   (DDEML.8)
 318  */
 319 BOOL16 WINAPI DdeDisconnect16(HCONV hConv)
 320 {
 321     return (BOOL16)DdeDisconnect(hConv);
 322 }
 323
 324 /*****************************************************************
 325  *            DdeSetUserHandle (DDEML.10)
 326  */
 327 BOOL16 WINAPI DdeSetUserHandle16(HCONV hConv, DWORD id, DWORD hUser)
 328 {
 329     return DdeSetUserHandle(hConv, id, hUser);
 330 }
 331
 332 /*****************************************************************
 333  *            DdeCreateDataHandle (DDEML.14)
 334  */
 335 HDDEDATA WINAPI DdeCreateDataHandle16(DWORD idInst, LPBYTE pSrc, DWORD cb,
 336                                       DWORD cbOff, HSZ hszItem, UINT16 wFmt,
 337                                       UINT16 afCmd)
 338 {
 339     return DdeCreateDataHandle(idInst, pSrc, cb, cbOff, hszItem, wFmt, afCmd);
 340 }
 341
 342 /*****************************************************************
 343  *            DdeCreateStringHandle   (DDEML.21)
 344  */
 345 HSZ WINAPI DdeCreateStringHandle16(DWORD idInst, LPCSTR str, INT16 codepage)
 346 {
 347     if  (codepage)
 348     {
 349         return DdeCreateStringHandleA(idInst, str, codepage);
 350     }
 351     else
 352     {
 353         TRACE("Default codepage supplied\n");
 354         return DdeCreateStringHandleA(idInst, str, CP_WINANSI);
 355     }
 356 }
 357
 358 /*****************************************************************
 359  *            DdeFreeStringHandle   (DDEML.22)
 360  */
 361 BOOL16 WINAPI DdeFreeStringHandle16(DWORD idInst, HSZ hsz)
 362 {
 363     return (BOOL16)DdeFreeStringHandle(idInst, hsz);
 364 }
 365
 366 /*****************************************************************
 367  *            DdeFreeDataHandle   (DDEML.19)
 368  */
 369 BOOL16 WINAPI DdeFreeDataHandle16(HDDEDATA hData)
 370 {
 371     return (BOOL16)DdeFreeDataHandle(hData);
 372 }
 373
 374 /*****************************************************************
 375  *            DdeKeepStringHandle   (DDEML.24)
 376  */
 377 BOOL16 WINAPI DdeKeepStringHandle16(DWORD idInst, HSZ hsz)
 378 {
 379     return DdeKeepStringHandle(idInst, hsz);
 380 }
 381
 382 /*****************************************************************
 383  *            DdeClientTransaction  (DDEML.11)
 384  */
 385 HDDEDATA WINAPI DdeClientTransaction16(LPVOID pData, DWORD cbData, HCONV hConv,
 386                                        HSZ hszItem, UINT16 wFmt, UINT16 wType,
 387                                        DWORD dwTimeout, LPDWORD pdwResult)
 388 {
 389     if (cbData != (DWORD)-1)
 390     {
 391         /* pData is not a pointer if cbData is -1, so we linearize the address
 392          * here rather than in the calling code. */
 393         pData = MapSL((SEGPTR)pData);
 394     }
 395     return DdeClientTransaction(pData, cbData, hConv, hszItem,
 396                                 wFmt, wType, dwTimeout, pdwResult);
 397 }
 398
 399 /*****************************************************************
 400  *
 401  *            DdeAbandonTransaction (DDEML.12)
 402  *
 403  */
 404 BOOL16 WINAPI DdeAbandonTransaction16(DWORD idInst, HCONV hConv, DWORD idTransaction)
 405 {
 406     return (BOOL16)DdeAbandonTransaction(idInst, hConv, idTransaction);
 407 }
 408
 409 /*****************************************************************
 410  * DdePostAdvise [DDEML.13]
 411  */
 412 BOOL16 WINAPI DdePostAdvise16(DWORD idInst, HSZ hszTopic, HSZ hszItem)
 413 {
 414     return (BOOL16)DdePostAdvise(idInst, hszTopic, hszItem);
 415 }
 416
 417 /*****************************************************************
 418  *            DdeAddData (DDEML.15)
 419  */
 420 HDDEDATA WINAPI DdeAddData16(HDDEDATA hData, LPBYTE pSrc, DWORD cb, DWORD cbOff)
 421 {
 422     return DdeAddData(hData, pSrc, cb, cbOff);
 423 }
 424
 425 /*****************************************************************
 426  * DdeGetData [DDEML.16]
 427  */
 428 DWORD WINAPI DdeGetData16(HDDEDATA hData, LPBYTE pDst, DWORD cbMax, DWORD cbOff)
 429 {
 430     return DdeGetData(hData, pDst, cbMax, cbOff);
 431 }
 432
 433 /*****************************************************************
 434  *            DdeAccessData (DDEML.17)
 435  */
 436 LPBYTE WINAPI DdeAccessData16(HDDEDATA hData, LPDWORD pcbDataSize)
 437 {
 438     FIXME("expect trouble\n");
 439     /* FIXME: there's a memory leak here... */
 440     return (LPBYTE)MapLS(DdeAccessData(hData, pcbDataSize));
 441 }
 442
 443 /*****************************************************************
 444  *            DdeUnaccessData (DDEML.18)
 445  */
 446 BOOL16 WINAPI DdeUnaccessData16(HDDEDATA hData)
 447 {
 448     return DdeUnaccessData(hData);
 449 }
 450
 451 /*****************************************************************
 452  *            DdeEnableCallback (DDEML.26)
 453  */
 454 BOOL16 WINAPI DdeEnableCallback16(DWORD idInst, HCONV hConv, UINT16 wCmd)
 455 {
 456     return DdeEnableCallback(idInst, hConv, wCmd);
 457 }
 458
 459 /*****************************************************************
 460  *            DdeNameService  (DDEML.27)
 461  */
 462 HDDEDATA WINAPI DdeNameService16(DWORD idInst, HSZ hsz1, HSZ hsz2, UINT16 afCmd)
 463 {
 464     return DdeNameService(idInst, hsz1, hsz2, afCmd);
 465 }
 466
 467 /*****************************************************************
 468  *            DdeGetLastError  (DDEML.20)
 469  */
 470 UINT16 WINAPI DdeGetLastError16(DWORD idInst)
 471 {
 472     return (UINT16)DdeGetLastError(idInst);
 473 }
 474
 475 /*****************************************************************
 476  *            DdeCmpStringHandles (DDEML.36)
 477  */
 478 INT16 WINAPI DdeCmpStringHandles16(HSZ hsz1, HSZ hsz2)
 479 {
 480     return DdeCmpStringHandles(hsz1, hsz2);
 481 }
 482
 483 /******************************************************************
 484  *              DdeQueryConvInfo (DDEML.9)
 485  *
 486  */
 487 UINT16 WINAPI DdeQueryConvInfo16(HCONV hConv, DWORD idTransaction,
 488                                  LPCONVINFO16 lpConvInfo)
 489 {
 490     CONVINFO    ci32;
 491     CONVINFO16  ci16;
 492     UINT        ret;
 493
 494     ci32.cb = sizeof(ci32);
 495     ci32.ConvCtxt.cb = sizeof(ci32.ConvCtxt);
 496
 497     ret = DdeQueryConvInfo(hConv, idTransaction, &ci32);
 498     if (ret == 0) return 0;
 499
 500     ci16.hUser = ci32.hUser;
 501     ci16.hConvPartner = ci32.hConvPartner;
 502     ci16.hszSvcPartner = ci32.hszSvcPartner;
 503     ci16.hszServiceReq = ci32.hszServiceReq;
 504     ci16.hszTopic = ci32.hszTopic;
 505     ci16.hszItem = ci32.hszItem;
 506     ci16.wFmt = ci32.wFmt;
 507     ci16.wType = ci32.wType;
 508     ci16.wStatus = ci32.wStatus;
 509     ci16.wConvst = ci32.wConvst;
 510     ci16.wLastError = ci32.wLastError;
 511     ci16.hConvList = ci32.hConvList;
 512
 513     map3216_conv_context(&ci16.ConvCtxt, &ci32.ConvCtxt);
 514
 515     memcpy(lpConvInfo, &ci16, lpConvInfo->cb);
 516     return lpConvInfo->cb;
 517 }