Changeset 10173 for trunk/src


Ignore:
Timestamp:
Jul 16, 2003, 5:47:24 PM (22 years ago)
Author:
sandervl
Message:

KOM: fixed potential buffer overflows in *GetErrorString functions

Location:
trunk/src/winmm
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/mci.cpp

    r8470 r10173  
    1 /* $Id: mci.cpp,v 1.8 2002-05-22 15:50:24 sandervl Exp $ */
     1/* $Id: mci.cpp,v 1.9 2003-07-16 15:47:23 sandervl Exp $ */
    22
    33/*
    … …  
    2525#include <string.h>
    2626#include <stdio.h>
    27 #include "debugtools.h" 
     27#include "debugtools.h"
    2828
    2929#include <misc.h>
    … …  
    3434#include "winmm.h"
    3535
    36 #define DBG_LOCALLOG    DBG_mci
     36#define DBG_LOCALLOG    DBG_mci
    3737#include "dbglocal.h"
    3838
    … …  
    4848              DWORD dwParam2);
    4949
    50 static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) ;
    51 static UINT     MCI_GetDriverFromString(LPCSTR lpstrName);
     50static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID) ;
     51static UINT MCI_GetDriverFromString(LPCSTR lpstrName);
    5252
    5353/****************************************************************************/
    … …  
    5757{
    5858  TRACE("Entering mciDriverNotify (%08X, %04x, %04X)\n", hwndCallback, uDeviceID, uStatus);
    59  
     59
    6060  if (!IsWindow(hwndCallback)) {
    61         WARN("bad hwnd for call back (0x%04x)\n", hwndCallback);
    62         return FALSE;
     61    WARN("bad hwnd for call back (0x%04x)\n", hwndCallback);
     62    return FALSE;
    6363  }
    6464  TRACE("before PostMessage\n");
    … …  
    127127DWORD WINAPI mciGetDriverData(UINT uDeviceID)
    128128{
    129   LPWINE_MCIDRIVER      wmd;
    130  
     129  LPWINE_MCIDRIVER  wmd;
     130
    131131  wmd = MCI_GetDriver(uDeviceID);
    132  
     132
    133133  if (!wmd) {
    134         dprintf(("WARNING: Bad uDeviceID (mciGetDriverData (mci.cpp line %d)\n",__LINE__));
     134    dprintf(("WARNING: Bad uDeviceID (mciGetDriverData (mci.cpp line %d)\n",__LINE__));
    135135    return 0L; /* Error */
    136136  }
    137    
     137
    138138  return wmd->dwPrivate;
    139139}
    … …  
    183183  char * theMsg = getWinmmMsg( mcierr );
    184184  if ( theMsg )
    185     AsciiToUnicode( theMsg, pszText );
     185    AsciiToUnicodeN( theMsg, pszText, cchText );
    186186  else
    187187  {
    188188    char errMsg[100];
    189189    sprintf( errMsg, "Unknown error number %d", mcierr );
    190     AsciiToUnicode( errMsg, pszText );
     190    AsciiToUnicodeN( errMsg, pszText, cchText );
    191191  }
    192192  return TRUE;
    … …  
    207207YIELDPROC WINAPI mciGetYieldProc(MCIDEVICEID  mciId, LPDWORD pdwYieldData)
    208208{
    209   LPWINE_MCIDRIVER      wmd;
    210  
     209  LPWINE_MCIDRIVER  wmd;
     210
    211211  TRACE("Entering mciGetYieldProc (%u, %p) - untested\n", mciId, pdwYieldData);
    212212
    213213  if (!(wmd = MCI_GetDriver(mciId))) {
    214         WARN("Bad uDeviceID\n");
    215         return NULL;
     214    WARN("Bad uDeviceID\n");
     215    return NULL;
    216216  }
    217217  if (!wmd->lpfnYieldProc) {
    218         WARN("No proc set\n");
    219         return NULL;
     218    WARN("No proc set\n");
     219    return NULL;
    220220  }
    221221  if (!wmd->bIs32) {
    222         WARN("Proc is 32 bit\n");
    223         return NULL;
     222    WARN("Proc is 32 bit\n");
     223    return NULL;
    224224  }
    225225  return wmd->lpfnYieldProc;
    … …  
    239239  DWORD dwRet;
    240240  //  dprintf(("WINMM:mciSendCommandA - entering %X %X %X %X\n", mciId, uMsg, dwParam1, dwParam2));
    241   dwRet= MCI_SendCommand((UINT) mciId,  uMsg,  dwParam1, dwParam2) & 0xFFFF;     
     241  dwRet= MCI_SendCommand((UINT) mciId,  uMsg,  dwParam1, dwParam2) & 0xFFFF;
    242242  return(dwRet);
    243243}
    … …  
    269269BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData)
    270270{
    271   LPWINE_MCIDRIVER      wmd;
    272  
     271  LPWINE_MCIDRIVER  wmd;
     272
    273273  wmd = MCI_GetDriver(uDeviceID);
    274274
    275275  if (!wmd) {
    276         dprintf(("WARNING: Bad uDeviceID (mciSetDriverData line %d)\n",__LINE__));
    277         return FALSE;
    278   }
    279  
     276    dprintf(("WARNING: Bad uDeviceID (mciSetDriverData line %d)\n",__LINE__));
     277    return FALSE;
     278  }
     279
    280280  wmd->dwPrivate = dwData;
    281281  return TRUE;
    … …  
    285285BOOL WINAPI mciSetYieldProc(MCIDEVICEID mciId, YIELDPROC fpYieldProc, DWORD dwYieldData)
    286286{
    287   LPWINE_MCIDRIVER      wmd;
    288  
     287  LPWINE_MCIDRIVER  wmd;
     288
    289289  TRACE("WINMM:mciSetYieldProc (%u, %p, %08lx) - untested\n", mciId, fpYieldProc, dwYieldData);
    290  
     290
    291291  if (!(wmd = MCI_GetDriver(mciId))) {
    292         WARN("Bad uDeviceID\n");
    293         return FALSE;
    294   }
    295  
     292    WARN("Bad uDeviceID\n");
     293    return FALSE;
     294  }
     295
    296296  wmd->lpfnYieldProc = fpYieldProc;
    297297  wmd->dwYieldData   = dwYieldData;
    298298  wmd->bIs32         = TRUE;
    299  
     299
    300300  return TRUE;
    301301}
    … …  
    319319/**************************************************************************/
    320320
    321 static LPWINE_MM_IDATA          lpFirstIData = NULL;
    322 
    323 static  LPWINE_MM_IDATA MULTIMEDIA_GetIDataNoCheck(void)
    324 {
    325     DWORD               pid = GetCurrentProcessId();
    326     LPWINE_MM_IDATA     iData;
     321static LPWINE_MM_IDATA      lpFirstIData = NULL;
     322
     323static  LPWINE_MM_IDATA MULTIMEDIA_GetIDataNoCheck(void)
     324{
     325    DWORD       pid = GetCurrentProcessId();
     326    LPWINE_MM_IDATA iData;
    327327
    328328    for (iData = lpFirstIData; iData; iData = iData->lpNextIData) {
    329329      if (iData->dwThisProcess == pid)
    330             break;
     330        break;
    331331    }
    332332    return iData;
    … …  
    334334
    335335/**************************************************************************
    336  *                      MULTIMEDIA_GetIData                     [internal]
    337  */
    338 LPWINE_MM_IDATA MULTIMEDIA_GetIData(void)
    339 {
    340     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIDataNoCheck();
     336 *          MULTIMEDIA_GetIData         [internal]
     337 */
     338LPWINE_MM_IDATA MULTIMEDIA_GetIData(void)
     339{
     340    LPWINE_MM_IDATA iData = MULTIMEDIA_GetIDataNoCheck();
    341341
    342342    if (!iData) {
    … …  
    349349
    350350/**************************************************************************
    351  *                      MULTIMEDIA_CreateIData                  [internal]
     351 *          MULTIMEDIA_CreateIData          [internal]
    352352 */
    353353BOOL MULTIMEDIA_CreateIData(HINSTANCE hInstDLL)
    354354{
    355     LPWINE_MM_IDATA     iData;
    356        
     355    LPWINE_MM_IDATA iData;
     356
    357357    iData = (LPWINE_MM_IDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WINE_MM_IDATA));
    358358
    … …  
    370370
    371371/**************************************************************************
    372  *                      MULTIMEDIA_DeleteIData                  [internal]
     372 *          MULTIMEDIA_DeleteIData          [internal]
    373373 */
    374374void MULTIMEDIA_DeleteIData(void)
    375375{
    376     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIDataNoCheck();
    377     LPWINE_MM_IDATA*    ppid;
    378            
     376    LPWINE_MM_IDATA iData = MULTIMEDIA_GetIDataNoCheck();
     377    LPWINE_MM_IDATA*    ppid;
     378
    379379    if (iData) {
    380         for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) {
    381             if (*ppid == iData) {
    382                 *ppid = iData->lpNextIData;
    383                 break;
    384             }
    385         }
    386         /* FIXME: should also free content and resources allocated
    387         * inside iData */
    388         HeapFree(GetProcessHeap(), 0, iData);
     380    for (ppid = &lpFirstIData; *ppid; ppid = &(*ppid)->lpNextIData) {
     381        if (*ppid == iData) {
     382        *ppid = iData->lpNextIData;
     383        break;
     384        }
     385    }
     386    /* FIXME: should also free content and resources allocated
     387    * inside iData */
     388    HeapFree(GetProcessHeap(), 0, iData);
    389389    }
    390390}
    … …  
    396396
    397397
    398 static  int                     MCI_InstalledCount;
    399 static  LPSTR                   MCI_lpInstallNames = NULL;
     398static  int         MCI_InstalledCount;
     399static  LPSTR           MCI_lpInstallNames = NULL;
    400400
    401401
    … …  
    405405
    406406/**************************************************************************
    407  *                              MCI_GetDriver                   [internal]
    408  */
    409 static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID)
    410 {
    411     LPWINE_MCIDRIVER    wmd = 0;
    412     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
     407 *              MCI_GetDriver           [internal]
     408 */
     409static LPWINE_MCIDRIVER MCI_GetDriver(UINT16 wDevID)
     410{
     411    LPWINE_MCIDRIVER    wmd = 0;
     412    LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
    413413
    414414    EnterCriticalSection(&iData->cs);
    415415    for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
    416         if (wmd->wDeviceID == wDevID)
    417             break;
     416    if (wmd->wDeviceID == wDevID)
     417        break;
    418418    }
    419419    LeaveCriticalSection(&iData->cs);
    … …  
    422422
    423423/**************************************************************************
    424  *                              MCI_GetDriverFromString         [internal]
    425  */
    426 static UINT     MCI_GetDriverFromString(LPCSTR lpstrName)
    427 {
    428     LPWINE_MCIDRIVER    wmd;
    429     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
    430     UINT                ret = 0;
     424 *              MCI_GetDriverFromString     [internal]
     425 */
     426static UINT MCI_GetDriverFromString(LPCSTR lpstrName)
     427{
     428    LPWINE_MCIDRIVER    wmd;
     429    LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
     430    UINT        ret = 0;
    431431
    432432    if (!lpstrName)
    433433      return 0;
    434    
     434
    435435    if (!lstrcmpiA(lpstrName, "ALL"))
    436436      return MCI_ALL_DEVICE_ID;
    437    
     437
    438438    EnterCriticalSection(&iData->cs);
    439439    for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
    440440      if (wmd->lpstrElementName && strcmp(wmd->lpstrElementName, lpstrName) == 0) {
    441             ret = wmd->wDeviceID;
    442             break;
    443       }
    444      
     441        ret = wmd->wDeviceID;
     442        break;
     443      }
     444
    445445      if (wmd->lpstrDeviceType && strcmp(wmd->lpstrDeviceType, lpstrName) == 0) {
    446             ret = wmd->wDeviceID;
    447             break;
    448       }
    449      
     446        ret = wmd->wDeviceID;
     447        break;
     448      }
     449
    450450      if (wmd->lpstrAlias && strcmp(wmd->lpstrAlias, lpstrName) == 0) {
    451             ret = wmd->wDeviceID;
    452             break;
     451        ret = wmd->wDeviceID;
     452        break;
    453453      }
    454454    }
    455455    LeaveCriticalSection(&iData->cs);
    456    
     456
    457457    return ret;
    458458}
    … …  
    460460
    461461/**************************************************************************
    462  *                              MCI_GetDevTypeFromFileName      [internal]
    463  */
    464 static  DWORD   MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
    465 {
    466     LPSTR       tmp;
     462 *              MCI_GetDevTypeFromFileName  [internal]
     463 */
     464static  DWORD   MCI_GetDevTypeFromFileName(LPCSTR fileName, LPSTR buf, UINT len)
     465{
     466    LPSTR   tmp;
    467467
    468468    if ((tmp = strrchr(fileName, '.'))) {
    469469      GetProfileStringA("mci extensions", tmp + 1, "*", buf, len);
    470470      if (strcmp(buf, "*") != 0) {
    471             return 0;
     471        return 0;
    472472      }
    473473      dprintf(("No [mci extensions] entry for '%s' found. MCI_GetDevTypeFromFileName: line %d, file 'mci.cpp'\n", tmp, __LINE__));
    … …  
    477477
    478478
    479 #define MAX_MCICMDTABLE                 20
    480 #define MCI_COMMAND_TABLE_NOT_LOADED    0xFFFE
    481 
    482 
    483 
    484 /**************************************************************************
    485  *                              MCI_DefYieldProc                [internal]
     479#define MAX_MCICMDTABLE         20
     480#define MCI_COMMAND_TABLE_NOT_LOADED    0xFFFE
     481
     482
     483
     484/**************************************************************************
     485 *              MCI_DefYieldProc            [internal]
    486486 */
    487487//UINT WINAPI MCI_DefYieldProc(MCIDEVICEID wDevID, DWORD data)
    … …  
    489489UINT16 WINAPI MCI_DefYieldProc(UINT16 wDevID, DWORD data)
    490490{
    491   INT16 ret;
    492 
    493 #if 0 
     491  INT16 ret;
     492
     493#if 0
    494494  dprintf(("(0x%04x, 0x%08lx)\n", wDevID, data));
    495 #endif 
     495#endif
    496496  if ((HIWORD(data) != 0 && GetActiveWindow() != HIWORD(data)) ||
    497497      (GetAsyncKeyState(LOWORD(data)) & 1) == 0) {
    498         /* WINE stuff removed: UserYield16();*/
    499         ret = 0;
     498    /* WINE stuff removed: UserYield16();*/
     499    ret = 0;
    500500  } else {
    501         MSG             msg;
    502    
    503         msg.hwnd = HIWORD(data);
    504         while (!PeekMessageA(&msg, HIWORD(data), WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
    505         ret = -1;
     501    MSG     msg;
     502
     503    msg.hwnd = HIWORD(data);
     504    while (!PeekMessageA(&msg, HIWORD(data), WM_KEYFIRST, WM_KEYLAST, PM_REMOVE));
     505    ret = -1;
    506506  }
    507507  return ret;
    … …  
    510510
    511511/**************************************************************************
    512  *                              MCI_UnLoadMciDriver             [internal]
    513  */
    514 static  BOOL    MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd)
    515 {
    516     LPWINE_MCIDRIVER*           tmp;
     512 *              MCI_UnLoadMciDriver     [internal]
     513 */
     514static  BOOL    MCI_UnLoadMciDriver(LPWINE_MM_IDATA iData, LPWINE_MCIDRIVER wmd)
     515{
     516    LPWINE_MCIDRIVER*       tmp;
    517517
    518518#if 0
    … …  
    522522      return TRUE;
    523523
    524     if (wmd->hDrv) 
     524    if (wmd->hDrv)
    525525      CloseDriver(wmd->hDrv, 0, 0);
    526526
    … …  
    531531    for (tmp = &iData->lpMciDrvs; *tmp; tmp = &(*tmp)->lpNext) {
    532532      if (*tmp == wmd) {
    533             *tmp = wmd->lpNext;
    534             break;
     533        *tmp = wmd->lpNext;
     534        break;
    535535      }
    536536    }
    … …  
    547547
    548548/**************************************************************************
    549  *                              MCI_LoadMciDriver               [internal]
    550  */
    551 static  DWORD   MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp,
    552                                   LPWINE_MCIDRIVER* lpwmd)
    553 {
    554     LPSTR                       strDevTyp = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp));
    555     LPWINE_MCIDRIVER            wmd = (LPWINE_MCIDRIVER)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
    556     MCI_OPEN_DRIVER_PARMSA      modp;
    557     DWORD                       dwRet = 0;
    558     HDRVR                       hDrv = 0;
     549 *              MCI_LoadMciDriver       [internal]
     550 */
     551static  DWORD   MCI_LoadMciDriver(LPWINE_MM_IDATA iData, LPCSTR _strDevTyp,
     552                  LPWINE_MCIDRIVER* lpwmd)
     553{
     554    LPSTR           strDevTyp = CharUpperA(HEAP_strdupA(GetProcessHeap(), 0, _strDevTyp));
     555    LPWINE_MCIDRIVER        wmd = (LPWINE_MCIDRIVER)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*wmd));
     556    MCI_OPEN_DRIVER_PARMSA  modp;
     557    DWORD           dwRet = 0;
     558    HDRVR           hDrv = 0;
    559559
    560560
    561561    dprintf(("Entering MCI_LoadMciDriver...\n"));
    562  
     562
    563563    if (!wmd || !strDevTyp) {
    564564      dwRet = MCIERR_OUT_OF_MEMORY;
    … …  
    579579    iData->lpMciDrvs = wmd;
    580580
    581     for (modp.wDeviceID = MCI_MAGIC; 
    582          MCI_GetDriver(modp.wDeviceID) != 0; 
     581    for (modp.wDeviceID = MCI_MAGIC;
     582         MCI_GetDriver(modp.wDeviceID) != 0;
    583583         modp.wDeviceID++);
    584584
    … …  
    592592
    593593    hDrv = OpenDriverA(strDevTyp, "mci", (LPARAM)&modp);
    594    
     594
    595595    if (!hDrv) {
    596596      dprintf(("Couldn't load driver for type %s.\n"
    … …  
    600600      dwRet = MCIERR_DEVICE_NOT_INSTALLED;
    601601      goto errCleanUp;
    602     }                           
     602    }
    603603
    604604    /* FIXME: should also check that module's description is of the form
    … …  
    611611    wmd->uTypeCmdTable = MCI_COMMAND_TABLE_NOT_LOADED;
    612612
    613     dprintf(("Loaded driver %x (%s), type is %d, cmdTable=%08x\n", 
    614           hDrv, strDevTyp, modp.wType, modp.wCustomCommandTable));
    615    
    616    
     613    dprintf(("Loaded driver %x (%s), type is %d, cmdTable=%08x\n",
     614      hDrv, strDevTyp, modp.wType, modp.wCustomCommandTable));
     615
     616
    617617    wmd->wType = modp.wType;
    618618
    619 #if 0   
    620     dprintf(("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n", 
     619#if 0
     620    dprintf(("mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n",
    621621             modp.wDeviceID, modp.wType, modp.wDeviceID));
    622622#endif
    … …  
    637637
    638638/**************************************************************************
    639  *                      MCI_SendCommandFrom32                   [internal]
     639 *          MCI_SendCommandFrom32           [internal]
    640640 */
    641641static DWORD MCI_SendCommandFrom32(UINT wDevID, UINT16 wMsg, DWORD dwParam1, DWORD dwParam2)
    642642{
    643     DWORD               dwRet = MCIERR_DEVICE_NOT_INSTALLED;
    644     LPWINE_MCIDRIVER    wmd = MCI_GetDriver(wDevID);
     643    DWORD       dwRet = MCIERR_DEVICE_NOT_INSTALLED;
     644    LPWINE_MCIDRIVER    wmd = MCI_GetDriver(wDevID);
    645645
    646646    if (!wmd) {
    … …  
    649649      switch (GetDriverFlags(wmd->hDrv) & (WINE_GDF_EXIST)) {
    650650      case WINE_GDF_EXIST:
    651             dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
    652             break;
     651        dwRet = SendDriverMessage(wmd->hDrv, wMsg, dwParam1, dwParam2);
     652        break;
    653653      default:
    654             dprintf(("Unknown driver %u\n", wmd->hDrv));
    655             dwRet = MCIERR_DRIVER_INTERNAL;
     654        dprintf(("Unknown driver %u\n", wmd->hDrv));
     655        dwRet = MCIERR_DRIVER_INTERNAL;
    656656      }
    657657    }
    658658    return dwRet;
    659659}
    660    
    661 /**************************************************************************
    662  *                      MCI_FinishOpen                          [internal]
    663  */
    664 static  DWORD   MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms,
     660
     661/**************************************************************************
     662 *          MCI_FinishOpen              [internal]
     663 */
     664static  DWORD   MCI_FinishOpen(LPWINE_MCIDRIVER wmd, LPMCI_OPEN_PARMSA lpParms,
    665665                               DWORD dwParam)
    666666{
    667667  if (dwParam & MCI_OPEN_ELEMENT)
    668         wmd->lpstrElementName = HEAP_strdupA(GetProcessHeap(), 0,
     668    wmd->lpstrElementName = HEAP_strdupA(GetProcessHeap(), 0,
    669669                                         lpParms->lpstrElementName);
    670  
     670
    671671  if (dwParam & MCI_OPEN_ALIAS)
    672         wmd->lpstrAlias = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrAlias);
    673  
     672    wmd->lpstrAlias = HEAP_strdupA(GetProcessHeap(), 0, lpParms->lpstrAlias);
     673
    674674  lpParms->wDeviceID = wmd->wDeviceID;
    675  
    676   return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam, 
     675
     676  return MCI_SendCommandFrom32(wmd->wDeviceID, MCI_OPEN_DRIVER, dwParam,
    677677                               (DWORD)lpParms);
    678678}
    679679
    680680/**************************************************************************
    681  *                      MCI_Open                                [internal]
    682  */
    683 static  DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
    684 {
    685     char                        strDevTyp[128];
    686     DWORD                       dwRet;
    687     LPWINE_MCIDRIVER            wmd = NULL;
    688 
    689     LPWINE_MM_IDATA             iData = MULTIMEDIA_GetIData();
     681 *          MCI_Open                [internal]
     682 */
     683static  DWORD MCI_Open(DWORD dwParam, LPMCI_OPEN_PARMSA lpParms)
     684{
     685    char            strDevTyp[128];
     686    DWORD           dwRet;
     687    LPWINE_MCIDRIVER        wmd = NULL;
     688
     689    LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
    690690
    691691    dprintf(("Entering MCI_OPEN...\n"));
    … …  
    694694
    695695    /* only two low bytes are generic, the other ones are dev type specific */
    696 #define WINE_MCIDRIVER_SUPP     (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
     696#define WINE_MCIDRIVER_SUPP (0xFFFF0000|MCI_OPEN_SHAREABLE|MCI_OPEN_ELEMENT| \
    697697                         MCI_OPEN_ALIAS|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID| \
    698698                         MCI_NOTIFY|MCI_WAIT)
    699699    if ((dwParam & ~WINE_MCIDRIVER_SUPP) != 0) {
    700         dprintf(("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP));
     700    dprintf(("Unsupported yet dwFlags=%08lX\n", dwParam & ~WINE_MCIDRIVER_SUPP));
    701701    }
    702702#undef WINE_MCIDRIVER_SUPP
    … …  
    706706    if (dwParam & MCI_OPEN_TYPE) {
    707707      if (dwParam & MCI_OPEN_TYPE_ID) {
    708             WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
     708        WORD uDevType = LOWORD((DWORD)lpParms->lpstrDeviceType);
    709709        if (uDevType < MCI_DEVTYPE_FIRST ||
    710710            uDevType > MCI_DEVTYPE_LAST ||
    … …  
    715715          }
    716716      } else {
    717             LPSTR       ptr;
    718             if (lpParms->lpstrDeviceType == NULL) {
     717        LPSTR   ptr;
     718        if (lpParms->lpstrDeviceType == NULL) {
    719719          dwRet = MCIERR_NULL_PARAMETER_BLOCK;
    720                 goto errCleanUp;
    721             }
    722             strcpy(strDevTyp, lpParms->lpstrDeviceType);
    723             ptr = strchr(strDevTyp, '!');
    724             if (ptr) {
    725                 /* this behavior is not documented in windows. However, since, in
    726                 * some occasions, MCI_OPEN handling is translated by WinMM into
    727                 * a call to mciSendString("open <type>"); this code shall be correct
    728                 */
    729                 if (dwParam & MCI_OPEN_ELEMENT) {
    730                     dprintf(("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
    731                         lpParms->lpstrElementName, strDevTyp));
    732                     dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
    733                     goto errCleanUp;
    734                 }
    735                 dwParam |= MCI_OPEN_ELEMENT;
    736                 *ptr++ = 0;
    737                 /* FIXME: not a good idea to write in user supplied buffer */
    738                 lpParms->lpstrElementName = ptr;
    739             }
    740                
     720        goto errCleanUp;
     721        }
     722        strcpy(strDevTyp, lpParms->lpstrDeviceType);
     723        ptr = strchr(strDevTyp, '!');
     724        if (ptr) {
     725        /* this behavior is not documented in windows. However, since, in
     726        * some occasions, MCI_OPEN handling is translated by WinMM into
     727        * a call to mciSendString("open <type>"); this code shall be correct
     728        */
     729        if (dwParam & MCI_OPEN_ELEMENT) {
     730            dprintf(("Both MCI_OPEN_ELEMENT(%s) and %s are used\n",
     731            lpParms->lpstrElementName, strDevTyp));
     732            dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
     733            goto errCleanUp;
     734        }
     735        dwParam |= MCI_OPEN_ELEMENT;
     736        *ptr++ = 0;
     737        /* FIXME: not a good idea to write in user supplied buffer */
     738        lpParms->lpstrElementName = ptr;
     739        }
     740
    741741      }
    742742      dprintf(("MCI_OPEN (MCI_OPEN_TYPE): devType='%s' !\n", strDevTyp));
    743743    }
    744    
     744
    745745    if (dwParam & MCI_OPEN_ELEMENT) {
    746746      dprintf(("lpstrElementName='%s'\n", lpParms->lpstrElementName));
    747747
    748748      if (dwParam & MCI_OPEN_ELEMENT_ID) {
    749             dprintf(("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n"));
    750             dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
    751             goto errCleanUp;
     749        dprintf(("Unsupported yet flag MCI_OPEN_ELEMENT_ID\n"));
     750        dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
     751        goto errCleanUp;
    752752      }
    753753
    754754      if (!lpParms->lpstrElementName) {
    755             dwRet = MCIERR_NULL_PARAMETER_BLOCK;
    756             goto errCleanUp;
     755        dwRet = MCIERR_NULL_PARAMETER_BLOCK;
     756        goto errCleanUp;
    757757      }
    758758
    … …  
    760760      /* Only working on my machine!! CW */
    761761      if(lpParms->lpstrElementName[0]=='N') {
    762             dprintf(("Discarding drive N:\n"));
     762        dprintf(("Discarding drive N:\n"));
    763763        dwRet = MCIERR_UNRECOGNIZED_KEYWORD;
    764             goto errCleanUp;
     764        goto errCleanUp;
    765765      }
    766766#endif
    767      
     767
    768768      /* type, if given as a parameter, supersedes file extension */
    769       if (!strDevTyp[0] && 
    770           MCI_GetDevTypeFromFileName(lpParms->lpstrElementName, 
     769      if (!strDevTyp[0] &&
     770          MCI_GetDevTypeFromFileName(lpParms->lpstrElementName,
    771771                                     strDevTyp, sizeof(strDevTyp))) {
    772772        if (GetDriveTypeA(lpParms->lpstrElementName) != DRIVE_CDROM) {
    … …  
    778778      }
    779779    }
    780    
     780
    781781    if (strDevTyp[0] == 0) {
    782782      dprintf(("Couldn't load driver (MCI_Open line %d)\n",__LINE__));
    … …  
    788788      dprintf(("MCI_OPEN_ALIAS requested\n"));
    789789      if (!lpParms->lpstrAlias) {
    790             dwRet = MCIERR_NULL_PARAMETER_BLOCK;
    791             goto errCleanUp;
     790        dwRet = MCIERR_NULL_PARAMETER_BLOCK;
     791        goto errCleanUp;
    792792      }
    793793      dprintf(("Alias='%s' !\n", lpParms->lpstrAlias));
    794794    }
    795    
     795
    796796    if ((dwRet = MCI_LoadMciDriver(iData, strDevTyp, &wmd))) {
    797797      goto errCleanUp;
    … …  
    822822      //  mciDriverNotify16(lpParms->dwCallback, 0, MCI_NOTIFY_FAILURE);
    823823      dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Open (line %d)\n",__LINE__));
    824  
     824
    825825    dprintf(("Leaving MCI_Open on error...\n"));
    826826    return dwRet;
    … …  
    829829
    830830/**************************************************************************
    831  *                      MCI_Close                               [internal]
    832  */
    833 static  DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
    834 {
    835   DWORD         dwRet;
    836   LPWINE_MCIDRIVER      wmd;
    837   LPWINE_MM_IDATA       iData = MULTIMEDIA_GetIData();
    838  
     831 *          MCI_Close               [internal]
     832 */
     833static  DWORD MCI_Close(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
     834{
     835  DWORD     dwRet;
     836  LPWINE_MCIDRIVER  wmd;
     837  LPWINE_MM_IDATA   iData = MULTIMEDIA_GetIData();
     838
    839839  //dprintf(("(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms));
    840840
    841841  if (wDevID == MCI_ALL_DEVICE_ID) {
    842         LPWINE_MCIDRIVER        next;
    843 
    844         EnterCriticalSection(&iData->cs);
    845         /* FIXME: shall I notify once after all is done, or for
    846         * each of the open drivers ? if the latest, which notif
    847         * to return when only one fails ?
    848         */
    849         for (wmd = iData->lpMciDrvs; wmd; ) {
     842    LPWINE_MCIDRIVER    next;
     843
     844    EnterCriticalSection(&iData->cs);
     845    /* FIXME: shall I notify once after all is done, or for
     846    * each of the open drivers ? if the latest, which notif
     847    * to return when only one fails ?
     848    */
     849    for (wmd = iData->lpMciDrvs; wmd; ) {
    850850      next = wmd->lpNext;
    851851      MCI_Close(wmd->wDeviceID, dwParam, lpParms);
    852852      wmd = next;
    853         }       
    854         LeaveCriticalSection(&iData->cs);
    855         return 0;
     853    }
     854    LeaveCriticalSection(&iData->cs);
     855    return 0;
    856856  }
    857857
    858858  if (!(wmd = MCI_GetDriver(wDevID))) {
    859         return MCIERR_INVALID_DEVICE_ID;
     859    return MCIERR_INVALID_DEVICE_ID;
    860860  }
    861861
    862862  dwRet = MCI_SendCommandFrom32(wDevID, MCI_CLOSE_DRIVER, dwParam, (DWORD)lpParms);
    863  
     863
    864864  MCI_UnLoadMciDriver(iData, wmd);
    865  
     865
    866866  if (dwParam & MCI_NOTIFY)
    867867    dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Close (line %d)\n",__LINE__));
    868     //  mciDriverNotify16(lpParms->dwCallback, wDevID,
     868    //  mciDriverNotify16(lpParms->dwCallback, wDevID,
    869869    //                (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
    870  
     870
    871871  return dwRet;
    872872}
    … …  
    874874
    875875/**************************************************************************
    876  *                      MCI_WriteString                         [internal]
    877  */
    878 DWORD   MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
    879 {
    880     DWORD       ret = 0;
     876 *          MCI_WriteString             [internal]
     877 */
     878DWORD   MCI_WriteString(LPSTR lpDstStr, DWORD dstSize, LPCSTR lpSrcStr)
     879{
     880    DWORD   ret = 0;
    881881
    882882    if (lpSrcStr) {
    883         if (dstSize <= strlen(lpSrcStr)) {
    884             lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
    885             ret = MCIERR_PARAM_OVERFLOW;
    886         } else {
    887             strcpy(lpDstStr, lpSrcStr);
    888         }       
     883    if (dstSize <= strlen(lpSrcStr)) {
     884        lstrcpynA(lpDstStr, lpSrcStr, dstSize - 1);
     885        ret = MCIERR_PARAM_OVERFLOW;
    889886    } else {
    890         *lpDstStr = 0;
     887        strcpy(lpDstStr, lpSrcStr);
     888    }
     889    } else {
     890    *lpDstStr = 0;
    891891    }
    892892    return ret;
    … …  
    895895
    896896/**************************************************************************
    897  *                      MCI_Sysinfo                             [internal]
    898  */
    899 static  DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
    900 {
    901     DWORD               ret = MCIERR_INVALID_DEVICE_ID;
    902     LPWINE_MCIDRIVER    wmd;
    903     LPWINE_MM_IDATA     iData = MULTIMEDIA_GetIData();
    904 
    905     if (lpParms == NULL)                        return MCIERR_NULL_PARAMETER_BLOCK;
    906 
    907     TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n", 
    908           uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
    909    
     897 *          MCI_Sysinfo             [internal]
     898 */
     899static  DWORD MCI_SysInfo(UINT uDevID, DWORD dwFlags, LPMCI_SYSINFO_PARMSA lpParms)
     900{
     901    DWORD       ret = MCIERR_INVALID_DEVICE_ID;
     902    LPWINE_MCIDRIVER    wmd;
     903    LPWINE_MM_IDATA iData = MULTIMEDIA_GetIData();
     904
     905    if (lpParms == NULL)            return MCIERR_NULL_PARAMETER_BLOCK;
     906
     907    TRACE("(%08x, %08lX, %08lX[num=%ld, wDevTyp=%u])\n",
     908      uDevID, dwFlags, (DWORD)lpParms, lpParms->dwNumber, lpParms->wDeviceType);
     909
    910910    switch (dwFlags & ~MCI_SYSINFO_OPEN) {
    911911    case MCI_SYSINFO_QUANTITY:
    912912      {
    913             DWORD       cnt = 0;
    914            
    915             if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST ||
     913        DWORD   cnt = 0;
     914
     915        if (lpParms->wDeviceType < MCI_DEVTYPE_FIRST ||
    916916            lpParms->wDeviceType > MCI_DEVTYPE_LAST) {
    917917          if (dwFlags & MCI_SYSINFO_OPEN) {
    918                     TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
    919                     EnterCriticalSection(&iData->cs);
    920                     for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
     918            TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers\n");
     919            EnterCriticalSection(&iData->cs);
     920            for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
    921921              cnt++;
    922                     }
    923                     LeaveCriticalSection(&iData->cs);
     922            }
     923            LeaveCriticalSection(&iData->cs);
    924924          } else {
    925                     TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
    926                     cnt = MCI_InstalledCount;
     925            TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers\n");
     926            cnt = MCI_InstalledCount;
    927927          }
    928             } else {
     928        } else {
    929929          if (dwFlags & MCI_SYSINFO_OPEN) {
    930                     TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n",
     930            TRACE("MCI_SYSINFO_QUANTITY: # of open MCI drivers of type %u\n",
    931931                  lpParms->wDeviceType);
    932                     EnterCriticalSection(&iData->cs);
    933                     for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
     932            EnterCriticalSection(&iData->cs);
     933            for (wmd = iData->lpMciDrvs; wmd; wmd = wmd->lpNext) {
    934934              if (wmd->wType == lpParms->wDeviceType)
    935                             cnt++;
    936                     }
    937                     LeaveCriticalSection(&iData->cs);
     935                cnt++;
     936            }
     937            LeaveCriticalSection(&iData->cs);
    938938          } else {
    939                     TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n",
     939            TRACE("MCI_SYSINFO_QUANTITY: # of installed MCI drivers of type %u\n",
    940940                  lpParms->wDeviceType);
    941                     FIXME("Don't know how to get # of MCI devices of a given type\n");
    942                     cnt = 1;
     941            FIXME("Don't know how to get # of MCI devices of a given type\n");
     942            cnt = 1;
    943943          }
    944             }
    945             *(DWORD*)lpParms->lpstrReturn = cnt;
     944        }
     945        *(DWORD*)lpParms->lpstrReturn = cnt;
    946946      }
    947947      TRACE("(%ld) => '%ld'\n", lpParms->dwNumber, *(DWORD*)lpParms->lpstrReturn);
    … …  
    951951      TRACE("MCI_SYSINFO_INSTALLNAME \n");
    952952      if ((wmd = MCI_GetDriver(uDevID))) {
    953             ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize,
     953        ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize,
    954954                              wmd->lpstrDeviceType);
    955955      } else {
    956             *lpParms->lpstrReturn = 0;
    957             ret = MCIERR_INVALID_DEVICE_ID;
     956        *lpParms->lpstrReturn = 0;
     957        ret = MCIERR_INVALID_DEVICE_ID;
    958958      }
    959959      TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
    … …  
    962962      TRACE("MCI_SYSINFO_NAME\n");
    963963      if (dwFlags & MCI_SYSINFO_OPEN) {
    964             FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
    965             ret = MCIERR_UNRECOGNIZED_COMMAND;
     964        FIXME("Don't handle MCI_SYSINFO_NAME|MCI_SYSINFO_OPEN (yet)\n");
     965        ret = MCIERR_UNRECOGNIZED_COMMAND;
    966966      } else if (lpParms->dwNumber > MCI_InstalledCount) {
    967             ret = MCIERR_OUTOFRANGE;
     967        ret = MCIERR_OUTOFRANGE;
    968968      } else {
    969             DWORD       count = lpParms->dwNumber;
    970             LPSTR       ptr = MCI_lpInstallNames;
    971        
    972             while (--count > 0) ptr += strlen(ptr) + 1;
    973             ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
     969        DWORD   count = lpParms->dwNumber;
     970        LPSTR   ptr = MCI_lpInstallNames;
     971
     972        while (--count > 0) ptr += strlen(ptr) + 1;
     973        ret = MCI_WriteString(lpParms->lpstrReturn, lpParms->dwRetSize, ptr);
    974974      }
    975975      TRACE("(%ld) => '%s'\n", lpParms->dwNumber, lpParms->lpstrReturn);
    … …  
    984984
    985985/**************************************************************************
    986  *                      MCI_Break                               [internal]
    987  */
    988 static  DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
    989 {
    990     DWORD       dwRet = 0;
    991    
    992     if (lpParms == NULL)        return MCIERR_NULL_PARAMETER_BLOCK;
     986 *          MCI_Break               [internal]
     987 */
     988static  DWORD MCI_Break(UINT wDevID, DWORD dwFlags, LPMCI_BREAK_PARMS lpParms)
     989{
     990    DWORD   dwRet = 0;
     991
     992    if (lpParms == NULL)    return MCIERR_NULL_PARAMETER_BLOCK;
    993993
    994994    if (dwFlags & MCI_NOTIFY)
    995995      dprintf(("FIXME: MCI_NOTIFY not implemented yet! MCI_Break (line %d)\n",__LINE__));
    996     //  mciDriverNotify16(lpParms->dwCallback, wDevID,
    997     //    (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
     996    //  mciDriverNotify16(lpParms->dwCallback, wDevID,
     997    //    (dwRet == 0) ? MCI_NOTIFY_SUCCESSFUL : MCI_NOTIFY_FAILURE);
    998998
    999999    return dwRet;
    10001000}
    10011001
    1002    
    1003 /**************************************************************************
    1004  *                      MCI_SendCommand                         [internal]
    1005  */
    1006 static DWORD    MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1,
    1007                         DWORD dwParam2)
    1008 {
    1009     DWORD               dwRet = MCIERR_UNRECOGNIZED_COMMAND;
     1002
     1003/**************************************************************************
     1004 *          MCI_SendCommand             [internal]
     1005 */
     1006static DWORD    MCI_SendCommand(UINT wDevID, UINT16 wMsg, DWORD dwParam1,
     1007            DWORD dwParam2)
     1008{
     1009    DWORD       dwRet = MCIERR_UNRECOGNIZED_COMMAND;
    10101010
    10111011    switch (wMsg) {
    … …  
    10291029    default:
    10301030      if (wDevID == MCI_ALL_DEVICE_ID) {
    1031             dprintf(("MCI_SendCommand: unhandled MCI_ALL_DEVICE_ID\n"));
    1032             dwRet = MCIERR_CANNOT_USE_ALL;
     1031        dprintf(("MCI_SendCommand: unhandled MCI_ALL_DEVICE_ID\n"));
     1032        dwRet = MCIERR_CANNOT_USE_ALL;
    10331033      } else {
    10341034        dwRet=MCI_SendCommandFrom32(wDevID, wMsg, dwParam1, dwParam2);
    1035       }     
     1035      }
    10361036      break;
    10371037    }
    … …  
    10431043
    10441044/**************************************************************************
    1045  *                      MULTIMEDIA_MciInit                      [internal]
     1045 *          MULTIMEDIA_MciInit          [internal]
    10461046 *
    10471047 * Initializes the MCI internal variables.
    … …  
    10501050BOOL MULTIMEDIA_MciInit(void)
    10511051{
    1052     LPSTR       ptr1, ptr2;
    1053     HKEY        hWineConf;
    1054     HKEY        hkey;
    1055     DWORD       err;
    1056     DWORD       type;
    1057     DWORD       count = 2048;
     1052    LPSTR   ptr1, ptr2;
     1053    HKEY    hWineConf;
     1054    HKEY    hkey;
     1055    DWORD   err;
     1056    DWORD   type;
     1057    DWORD   count = 2048;
    10581058
    10591059    MCI_InstalledCount = 0;
    … …  
    10771077      TRACE("Wine => '%s' \n", ptr1);
    10781078      while ((ptr2 = strchr(ptr1, ':')) != 0) {
    1079             *ptr2++ = 0;
    1080             TRACE("---> '%s' \n", ptr1);
    1081             MCI_InstalledCount++;
    1082             ptr1 = ptr2;
     1079        *ptr2++ = 0;
     1080        TRACE("---> '%s' \n", ptr1);
     1081        MCI_InstalledCount++;
     1082        ptr1 = ptr2;
    10831083      }
    10841084      MCI_InstalledCount++;
    … …  
    10881088      GetPrivateProfileStringA("mci", NULL, "", MCI_lpInstallNames, count, "SYSTEM.INI");
    10891089      while (strlen(ptr1) > 0) {
    1090             TRACE("---> '%s' \n", ptr1);
    1091             ptr1 += strlen(ptr1) + 1;
    1092             MCI_InstalledCount++;
     1090        TRACE("---> '%s' \n", ptr1);
     1091        ptr1 += strlen(ptr1) + 1;
     1092        MCI_InstalledCount++;
    10931093      }
    10941094    }

  • trunk/src/winmm/midi.cpp

    r8470 r10173  
    1 /* $Id: midi.cpp,v 1.10 2002-05-22 15:50:24 sandervl Exp $ */
     1/* $Id: midi.cpp,v 1.11 2003-07-16 15:47:24 sandervl Exp $ */
    22
    33/*
    … …  
    2828#include <wprocess.h>
    2929
    30 #define DBG_LOCALLOG    DBG_midi
     30#define DBG_LOCALLOG    DBG_midi
    3131#include "dbglocal.h"
    3232
    … …  
    262262  char * theMsg = getWinmmMsg( wError );
    263263  if ( theMsg )
    264     AsciiToUnicode( theMsg, lpText );
     264    AsciiToUnicodeN( theMsg, lpText, cchText );
    265265  else
    266266  {
    267267    char errMsg[100];
    268268    sprintf( errMsg, "Unknown error number %d", wError );
    269     AsciiToUnicode( errMsg, lpText );
     269    AsciiToUnicodeN( errMsg, lpText, cchText );
    270270  }
    271271  return MMSYSERR_NOERROR;
    … …  
    581581  char * theMsg = getWinmmMsg( wError );
    582582  if ( theMsg )
    583     AsciiToUnicode( theMsg, lpText );
     583    AsciiToUnicodeN( theMsg, lpText, cchText );
    584584  else
    585585  {
    586586    char errMsg[100];
    587587    sprintf( errMsg, "Unknown error number %d", wError );
    588     AsciiToUnicode( errMsg, lpText );
     588    AsciiToUnicodeN( errMsg, lpText, cchText );
    589589  }
    590590  return MMSYSERR_NOERROR;

  • trunk/src/winmm/wavein.cpp

    r8508 r10173  
    1 /* $Id: wavein.cpp,v 1.12 2002-05-28 14:09:24 sandervl Exp $ */
     1/* $Id: wavein.cpp,v 1.13 2003-07-16 15:47:24 sandervl Exp $ */
    22
    33/*
    … …  
    4747        return(WAVERR_BADFORMAT);
    4848
    49     if(fdwOpen & WAVE_FORMAT_QUERY) 
     49    if(fdwOpen & WAVE_FORMAT_QUERY)
    5050    {
    5151        if(DartWaveIn::queryFormat(pwfx->wFormatTag, pwfx->nChannels, pwfx->nSamplesPerSec,
    52                                    pwfx->wBitsPerSample) == TRUE) 
     52                                   pwfx->wBitsPerSample) == TRUE)
    5353        {
    5454             return(MMSYSERR_NOERROR);
    … …  
    304304    char * theMsg = getWinmmMsg( wError );
    305305    if ( theMsg )
    306         AsciiToUnicode( theMsg, lpText );
     306        AsciiToUnicodeN( theMsg, lpText, cchText );
    307307    else
    308308    {
    309309        char errMsg[100];
    310310        sprintf( errMsg, "Unknown error number %d", wError );
    311         AsciiToUnicode( errMsg, lpText );
     311        AsciiToUnicodeN( errMsg, lpText, cchText );
    312312    }
    313313    return MMSYSERR_NOERROR;

  • trunk/src/winmm/waveout.cpp

    r9916 r10173  
    1 /* $Id: waveout.cpp,v 1.26 2003-03-06 15:42:33 sandervl Exp $ */
     1/* $Id: waveout.cpp,v 1.27 2003-07-16 15:47:24 sandervl Exp $ */
    22//#undef DEBUG
    33/*
    … …  
    3939/******************************************************************************/
    4040/******************************************************************************/
    41 MMRESULT WINAPI waveOutOpen(LPHWAVEOUT phwo, UINT uDeviceID, const LPWAVEFORMATEX pwfx, 
     41MMRESULT WINAPI waveOutOpen(LPHWAVEOUT phwo, UINT uDeviceID, const LPWAVEFORMATEX pwfx,
    4242                            DWORD dwCallback, DWORD dwInstance, DWORD fdwOpen)
    4343{
    … …  
    4949        return(WAVERR_BADFORMAT);
    5050
    51     if(fdwOpen & WAVE_FORMAT_QUERY) 
     51    if(fdwOpen & WAVE_FORMAT_QUERY)
    5252    {
    5353        if(DartWaveOut::queryFormat(pwfx->wFormatTag, pwfx->nChannels, pwfx->nSamplesPerSec,
    … …  
    332332    char * theMsg = getWinmmMsg( wError );
    333333    if(theMsg) {
    334         AsciiToUnicode( theMsg, lpText );
     334        AsciiToUnicodeN( theMsg, lpText, cchText );
    335335    }
    336336    else
    … …  
    338338        char errMsg[100];
    339339        sprintf( errMsg, "Unknown error number %d", wError );
    340         AsciiToUnicode( errMsg, lpText );
     340        AsciiToUnicodeN( errMsg, lpText, cchText );
    341341    }
    342342    return MMSYSERR_NOERROR;
    … …  
    419419{
    420420    WaveOut *dwave = (WaveOut *)hwo;
    421    
     421
    422422    dprintf(("waveOutSetPlaybackRate: NOT IMPLEMENTED!!"));
    423423    if(WaveOut::find(dwave) == TRUE)
Note: See TracChangeset for help on using the changeset viewer.