dlls/winmm/mmio.c

   1 /*
   2  * MMIO functions
   3  *
   4  * Copyright 1998 Andrew Taylor
   5  * Copyright 1998 Ove Kåven
   6  * Copyright 2000,2002 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 /* Still to be done:
  24  *      + correct handling of global/local IOProcs (and temporary IOProcs)
  25  *      + mode of mmio objects is not used (read vs write vs readwrite)
  26  *      + thread safeness
  27  *      + 32 A <=> W message mapping
  28  */
  29
  30
  31 #include <ctype.h>
  32 #include <stdarg.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <errno.h>
  36 #include <assert.h>
  37
  38 #include "ntstatus.h"
  39 #define WIN32_NO_STATUS
  40 #include "windef.h"
  41 #include "winbase.h"
  42 #include "winnls.h"
  43 #include "winternl.h"
  44 #include "ddk/ntddk.h"
  45 #include "mmsystem.h"
  46 #include "winemm.h"
  47
  48 #include "wine/debug.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(mmio);
  51
  52 static WINE_MMIO *MMIOList;
  53
  54 /* From kernel32 */
  55 static HANDLE create_file_OF( LPCSTR path, INT mode )
  56 {
  57     DWORD access, sharing, creation;
  58     char full_path[MAX_PATH];
  59
  60     if (mode & OF_CREATE)
  61     {
  62         creation = CREATE_ALWAYS;
  63         access = GENERIC_READ | GENERIC_WRITE;
  64     }
  65     else
  66     {
  67         creation = OPEN_EXISTING;
  68         switch(mode & 0x03)
  69         {
  70         case OF_READ:      access = GENERIC_READ; break;
  71         case OF_WRITE:     access = GENERIC_WRITE; break;
  72         case OF_READWRITE: access = GENERIC_READ | GENERIC_WRITE; break;
  73         default:           access = 0; break;
  74         }
  75     }
  76
  77     switch(mode & 0x70)
  78     {
  79     case OF_SHARE_EXCLUSIVE:  sharing = 0; break;
  80     case OF_SHARE_DENY_WRITE: sharing = FILE_SHARE_READ; break;
  81     case OF_SHARE_DENY_READ:  sharing = FILE_SHARE_WRITE; break;
  82     case OF_SHARE_DENY_NONE:
  83     case OF_SHARE_COMPAT:
  84     default:                  sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
  85     }
  86
  87     if (mode & OF_CREATE)
  88         return CreateFileA( path, access, sharing, NULL, creation, FILE_ATTRIBUTE_NORMAL, 0 );
  89
  90     if (!SearchPathA( NULL, path, NULL, MAX_PATH, full_path, NULL ))
  91         return INVALID_HANDLE_VALUE;
  92     return CreateFileA( full_path, access, sharing, NULL, creation, FILE_ATTRIBUTE_NORMAL, 0 );
  93 }
  94
  95 /**************************************************************************
  96  *                      mmioDosIOProc                           [internal]
  97  */
  98 static LRESULT CALLBACK mmioDosIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
  99                                       LPARAM lParam1, LPARAM lParam2)
 100 {
 101     LRESULT     ret = MMSYSERR_NOERROR;
 102
 103     TRACE("(%p, %X, 0x%Ix, 0x%Ix);\n", lpmmioinfo, uMessage, lParam1, lParam2);
 104
 105     switch (uMessage) {
 106     case MMIOM_OPEN:
 107         {
 108             /* Parameters:
 109              * lParam1 = szFileName parameter from mmioOpen
 110              * lParam2 = reserved
 111              * Returns: zero on success, error code on error
 112              * NOTE: lDiskOffset automatically set to zero
 113              */
 114             LPCSTR      szFileName = (LPCSTR)lParam1;
 115
 116             if (lpmmioinfo->dwFlags & MMIO_GETTEMP) {
 117                 FIXME("MMIO_GETTEMP not implemented\n");
 118                 return MMIOERR_CANNOTOPEN;
 119             }
 120
 121             /* if filename NULL, assume open file handle in adwInfo[0] */
 122             if (szFileName) {
 123                 HANDLE file;
 124
 125                 file = create_file_OF( szFileName, lpmmioinfo->dwFlags );
 126                 if (file != INVALID_HANDLE_VALUE)
 127                     lpmmioinfo->adwInfo[0] = HandleToLong(file);
 128                 else
 129                     lpmmioinfo->adwInfo[0] = HFILE_ERROR;
 130             }
 131             if (lpmmioinfo->adwInfo[0] == HFILE_ERROR)
 132                 ret = MMIOERR_FILENOTFOUND;
 133         }
 134         break;
 135
 136     case MMIOM_CLOSE:
 137         /* Parameters:
 138          * lParam1 = wFlags parameter from mmioClose
 139          * lParam2 = unused
 140          * Returns: zero on success, error code on error
 141          */
 142         if (!(lParam1 & MMIO_FHOPEN))
 143             _lclose((HFILE)lpmmioinfo->adwInfo[0]);
 144         break;
 145
 146     case MMIOM_READ:
 147         /* Parameters:
 148          * lParam1 = huge pointer to read buffer
 149          * lParam2 = number of bytes to read
 150          * Returns: number of bytes read, 0 for EOF, -1 for error (error code
 151          *         in wErrorRet)
 152          */
 153         ret = _lread((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
 154         if (ret != -1)
 155             lpmmioinfo->lDiskOffset += ret;
 156
 157         break;
 158
 159     case MMIOM_WRITE:
 160     case MMIOM_WRITEFLUSH:
 161         /* no internal buffering, so WRITEFLUSH handled same as WRITE */
 162
 163         /* Parameters:
 164          * lParam1 = huge pointer to write buffer
 165          * lParam2 = number of bytes to write
 166          * Returns: number of bytes written, -1 for error (error code in
 167          *              wErrorRet)
 168          */
 169         ret = _hwrite((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
 170         if (ret != -1)
 171             lpmmioinfo->lDiskOffset += ret;
 172         break;
 173
 174     case MMIOM_SEEK:
 175         /* Parameters:
 176          * lParam1 = new position
 177          * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
 178          * Returns: new file position, -1 on error
 179          */
 180         if (lParam2 == SEEK_END)
 181             ret = _llseek((HFILE)lpmmioinfo->adwInfo[0], -(LONG)lParam1, (LONG)lParam2);
 182         else
 183             ret = _llseek((HFILE)lpmmioinfo->adwInfo[0], (LONG)lParam1, (LONG)lParam2);
 184         if (ret != -1)
 185             lpmmioinfo->lDiskOffset = ret;
 186         return ret;
 187
 188     case MMIOM_RENAME:
 189         /* Parameters:
 190          * lParam1 = old name
 191          * lParam2 = new name
 192          * Returns: zero on success, non-zero on failure
 193          */
 194          if (!MoveFileA((const char*)lParam1, (const char*)lParam2))
 195              ret = MMIOERR_FILENOTFOUND;
 196          break;
 197
 198     default:
 199         FIXME("unexpected message %u\n", uMessage);
 200         return 0;
 201     }
 202
 203     return ret;
 204 }
 205
 206 /**************************************************************************
 207  *                      mmioMemIOProc                           [internal]
 208  */
 209 static LRESULT CALLBACK mmioMemIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
 210                                       LPARAM lParam1, LPARAM lParam2)
 211 {
 212     TRACE("(%p,0x%04x,0x%08Ix,0x%08Ix)\n", lpmmioinfo, uMessage, lParam1, lParam2);
 213
 214     switch (uMessage) {
 215
 216     case MMIOM_OPEN:
 217         /* Parameters:
 218          * lParam1 = filename (must be NULL)
 219          * lParam2 = reserved
 220          * Returns: zero on success, error code on error
 221          * NOTE: lDiskOffset automatically set to zero
 222          */
 223         /* FIXME: io proc shouldn't change it */
 224         if (!(lpmmioinfo->dwFlags & MMIO_CREATE))
 225             lpmmioinfo->pchEndRead = lpmmioinfo->pchEndWrite;
 226         lpmmioinfo->adwInfo[0] = HFILE_ERROR;
 227         return 0;
 228
 229     case MMIOM_CLOSE:
 230         /* Parameters:
 231          * lParam1 = wFlags parameter from mmioClose
 232          * lParam2 = unused
 233          * Returns: zero on success, error code on error
 234          */
 235         return 0;
 236
 237     case MMIOM_READ:
 238         /* Parameters:
 239          * lParam1 = huge pointer to read buffer
 240          * lParam2 = number of bytes to read
 241          * Returns: number of bytes read, 0 for EOF, -1 for error (error code
 242          *         in wErrorRet)
 243          * NOTE: lDiskOffset should be updated
 244          */
 245         FIXME("MMIOM_READ on memory files should not occur, buffer may be lost!\n");
 246         return 0;
 247
 248     case MMIOM_WRITE:
 249     case MMIOM_WRITEFLUSH:
 250         /* no internal buffering, so WRITEFLUSH handled same as WRITE */
 251
 252         /* Parameters:
 253          * lParam1 = huge pointer to write buffer
 254          * lParam2 = number of bytes to write
 255          * Returns: number of bytes written, -1 for error (error code in
 256          *              wErrorRet)
 257          * NOTE: lDiskOffset should be updated
 258          */
 259         FIXME("MMIOM_WRITE on memory files should not occur, buffer may be lost!\n");
 260         return 0;
 261
 262     case MMIOM_SEEK:
 263         /* Parameters:
 264          * lParam1 = new position
 265          * lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
 266          * Returns: new file position, -1 on error
 267          * NOTE: lDiskOffset should be updated
 268          */
 269         FIXME("MMIOM_SEEK on memory files should not occur, buffer may be lost!\n");
 270         return -1;
 271
 272     default:
 273         FIXME("unexpected message %u\n", uMessage);
 274         return 0;
 275     }
 276 }
 277
 278 /* This array will be the entire list for most apps
 279  * Note that temporary ioProcs will be stored with a 0 fourCC code
 280  */
 281
 282 static struct IOProcList defaultProcs[] = {
 283     {&defaultProcs[1], FOURCC_DOS, (LPMMIOPROC)mmioDosIOProc, FALSE, 0},
 284     {NULL,             FOURCC_MEM, (LPMMIOPROC)mmioMemIOProc, FALSE, 0},
 285 };
 286
 287 static struct IOProcList*       pIOProcListAnchor = &defaultProcs[0];
 288
 289 /****************************************************************
 290  *              MMIO_FindProcNode                       [INTERNAL]
 291  *
 292  * Finds the ProcList node associated with a given FOURCC code.
 293  */
 294 static struct IOProcList*       MMIO_FindProcNode(FOURCC fccIOProc)
 295 {
 296     struct IOProcList*  pListNode;
 297
 298     for (pListNode = pIOProcListAnchor; pListNode; pListNode = pListNode->pNext) {
 299         if (pListNode->fourCC == fccIOProc) {
 300             return pListNode;
 301         }
 302     }
 303     return NULL;
 304 }
 305
 306 /****************************************************************
 307  *              MMIO_InstallIOProc                      [INTERNAL]
 308  */
 309 static LPMMIOPROC MMIO_InstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
 310                                      DWORD dwFlags, BOOL is_unicode)
 311 {
 312     LPMMIOPROC          lpProc = NULL;
 313     struct IOProcList*  pListNode;
 314     struct IOProcList** ppListNode;
 315
 316     TRACE("(%08lx, %p, %08lX, %s)\n", fccIOProc, pIOProc, dwFlags, is_unicode ? "unicode" : "ansi");
 317
 318     if (dwFlags & MMIO_GLOBALPROC)
 319         FIXME("Global procedures not implemented\n");
 320
 321     /* just handle the known procedures for now */
 322     switch (dwFlags & (MMIO_INSTALLPROC|MMIO_REMOVEPROC|MMIO_FINDPROC)) {
 323     case MMIO_INSTALLPROC:
 324         /* Create new entry for the IOProc list */
 325         pListNode = malloc(sizeof(*pListNode));
 326         if (pListNode) {
 327             /* Fill in this node */
 328             pListNode->fourCC = fccIOProc;
 329             pListNode->pIOProc = pIOProc;
 330             pListNode->is_unicode = is_unicode;
 331             pListNode->count = 0;
 332
 333             /* Stick it on the end of the list */
 334             pListNode->pNext = pIOProcListAnchor;
 335             pIOProcListAnchor = pListNode;
 336
 337             /* Return this IOProc - that's how the caller knows we succeeded */
 338             lpProc = pIOProc;
 339         }
 340         break;
 341
 342     case MMIO_REMOVEPROC:
 343         /*
 344          * Search for the node that we're trying to remove
 345          * We search for a matching fourCC code if it's non null, or the proc
 346          * address otherwise
 347          * note that this method won't find the first item on the list, but
 348          * since the first two items on this list are ones we won't
 349          * let the user delete anyway, that's okay
 350          */
 351         ppListNode = &pIOProcListAnchor;
 352         while ((*ppListNode) &&
 353                ((fccIOProc != 0) ?
 354                 (*ppListNode)->fourCC != fccIOProc :
 355                 (*ppListNode)->pIOProc != pIOProc))
 356             ppListNode = &((*ppListNode)->pNext);
 357
 358         if (*ppListNode) { /* found it */
 359             /* FIXME: what should be done if an open mmio object uses this proc ?
 360              * shall we return an error, nuke the mmio object ?
 361              */
 362             if ((*ppListNode)->count) {
 363                 ERR("Cannot remove a mmIOProc while in use\n");
 364                 break;
 365             }
 366             /* remove it, but only if it isn't builtin */
 367             if ((*ppListNode) >= defaultProcs &&
 368                 (*ppListNode) < defaultProcs + ARRAY_SIZE(defaultProcs)) {
 369                 WARN("Tried to remove built-in mmio proc. Skipping\n");
 370             } else {
 371                 /* Okay, nuke it */
 372                 struct IOProcList*  ptmpNode = *ppListNode;
 373                 lpProc = (*ppListNode)->pIOProc;
 374                 *ppListNode = (*ppListNode)->pNext;
 375                 free(ptmpNode);
 376             }
 377         }
 378         break;
 379
 380     case MMIO_FINDPROC:
 381         if ((pListNode = MMIO_FindProcNode(fccIOProc))) {
 382             lpProc = pListNode->pIOProc;
 383         }
 384         break;
 385     }
 386
 387     return lpProc;
 388 }
 389
 390 /****************************************************************
 391  *              send_message                            [INTERNAL]
 392  */
 393 static LRESULT  send_message(struct IOProcList* ioProc, LPMMIOINFO mmioinfo,
 394                              DWORD wMsg, LPARAM lParam1,
 395                              LPARAM lParam2, BOOL is_unicode)
 396 {
 397     LRESULT             result = MMSYSERR_ERROR;
 398     LPARAM              lp1 = lParam1, lp2 = lParam2;
 399
 400     if (!ioProc) {
 401         ERR("ioProc NULL\n");
 402         return MMSYSERR_INVALPARAM;
 403     }
 404
 405     if (ioProc->is_unicode != is_unicode) {
 406         /* map (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
 407         FIXME("NIY 32 A<=>W mapping\n");
 408     }
 409     result = (ioProc->pIOProc)((LPSTR)mmioinfo, wMsg, lp1, lp2);
 410
 411 #if 0
 412     if (ioProc->is_unicode != is_unicode) {
 413             /* unmap (lParam1, lParam2) into (lp1, lp2) 32 A<=>W */
 414         }
 415 #endif
 416
 417     return result;
 418 }
 419
 420 /**************************************************************************
 421  *                              MMIO_ParseExtA                  [internal]
 422  *
 423  * Parses a filename for the extension.
 424  *
 425  * RETURNS
 426  *  The FOURCC code for the extension if found, else 0.
 427  */
 428 static FOURCC MMIO_ParseExtA(LPCSTR szFileName)
 429 {
 430     /* Filenames are of the form file.ext{+ABC}
 431        For now, we take the last '+' if present */
 432
 433     FOURCC ret = 0;
 434
 435     /* Note that ext{Start,End} point to the . and + respectively */
 436     LPCSTR extEnd;
 437     LPCSTR extStart;
 438
 439     CHAR ext[5];
 440
 441     TRACE("(%s)\n", debugstr_a(szFileName));
 442
 443     if (!szFileName)
 444         return ret;
 445
 446     /* Find the last '+' */
 447     extEnd = strrchr(szFileName,'+');
 448
 449     if (!extEnd) {
 450          /* No + so just an extension */
 451          return ret;
 452     } else {
 453         /* Find the first '.' before '+' */
 454         extStart = extEnd - 1;
 455         while (extStart >= szFileName && *extStart != '.') {
 456             extStart--;
 457         }
 458         if (extStart < szFileName) {
 459             ERR("No extension in szFileName: %s\n", debugstr_a(szFileName));
 460             return ret;
 461         }
 462     }
 463
 464     if (extEnd - extStart - 1 > 4)
 465         WARN("Extension length > 4\n");
 466     lstrcpynA(ext, extStart + 1, min(extEnd-extStart,5));
 467
 468     TRACE("Got extension: %s\n", debugstr_a(ext));
 469
 470     /* FOURCC codes identifying file-extensions must be uppercase */
 471     ret = mmioStringToFOURCCA(ext, MMIO_TOUPPER);
 472
 473     return ret;
 474 }
 475
 476 /**************************************************************************
 477  *                              MMIO_Get                        [internal]
 478  *
 479  * Retrieves the mmio object from current process
 480  */
 481 static LPWINE_MMIO      MMIO_Get(HMMIO h)
 482 {
 483     LPWINE_MMIO         wm = NULL;
 484
 485     EnterCriticalSection(&WINMM_cs);
 486     for (wm = MMIOList; wm; wm = wm->lpNext) {
 487         if (wm->info.hmmio == h)
 488             break;
 489     }
 490     LeaveCriticalSection(&WINMM_cs);
 491     return wm;
 492 }
 493
 494 /**************************************************************************
 495  *                              MMIO_Create                     [internal]
 496  *
 497  * Creates an internal representation for a mmio instance
 498  */
 499 static  LPWINE_MMIO             MMIO_Create(void)
 500 {
 501     static      WORD    MMIO_counter = 0;
 502     LPWINE_MMIO         wm;
 503
 504     wm = calloc(1, sizeof(WINE_MMIO));
 505     if (wm) {
 506         EnterCriticalSection(&WINMM_cs);
 507         /* lookup next unallocated WORD handle, with a non NULL value */
 508         while (++MMIO_counter == 0 || MMIO_Get((HMMIO)(ULONG_PTR)MMIO_counter));
 509         wm->info.hmmio = (HMMIO)(ULONG_PTR)MMIO_counter;
 510         wm->lpNext = MMIOList;
 511         MMIOList = wm;
 512         LeaveCriticalSection(&WINMM_cs);
 513     }
 514     return wm;
 515 }
 516
 517 /**************************************************************************
 518  *                              MMIO_Destroy                    [internal]
 519  *-
 520  * Destroys an internal representation for a mmio instance
 521  */
 522 static  BOOL            MMIO_Destroy(LPWINE_MMIO wm)
 523 {
 524     LPWINE_MMIO*        m;
 525
 526     EnterCriticalSection(&WINMM_cs);
 527     /* search for the matching one... */
 528     m = &MMIOList;
 529     while (*m && *m != wm) m = &(*m)->lpNext;
 530     /* ...and destroy */
 531     if (*m) {
 532         *m = (*m)->lpNext;
 533         free(wm);
 534         wm = NULL;
 535     }
 536     LeaveCriticalSection(&WINMM_cs);
 537     return !wm;
 538 }
 539
 540 /****************************************************************
 541  *                      MMIO_Flush                      [INTERNAL]
 542  */
 543 static  MMRESULT MMIO_Flush(WINE_MMIO* wm, UINT uFlags)
 544 {
 545     if (wm->info.cchBuffer && (wm->info.fccIOProc != FOURCC_MEM)) {
 546         /* not quite sure what to do here, but I'll guess */
 547         if (wm->info.dwFlags & MMIO_DIRTY) {
 548             /* FIXME: error handling */
 549             send_message(wm->ioProc, &wm->info, MMIOM_SEEK, wm->info.lBufOffset, SEEK_SET, FALSE);
 550             send_message(wm->ioProc, &wm->info, MMIOM_WRITE,
 551                          (LPARAM)wm->info.pchBuffer,
 552                          wm->info.pchNext - wm->info.pchBuffer, FALSE);
 553         }
 554         if (uFlags & MMIO_EMPTYBUF)
 555             wm->info.pchNext = wm->info.pchEndRead = wm->info.pchBuffer;
 556     }
 557     wm->info.dwFlags &= ~MMIO_DIRTY;
 558
 559     return MMSYSERR_NOERROR;
 560 }
 561
 562 /***************************************************************************
 563  *                      MMIO_GrabNextBuffer                     [INTERNAL]
 564  */
 565 static LONG     MMIO_GrabNextBuffer(LPWINE_MMIO wm, int for_read)
 566 {
 567     LONG        size = wm->info.cchBuffer;
 568
 569     TRACE("bo=%lx do=%lx\n",
 570           wm->info.lBufOffset, wm->info.lDiskOffset);
 571
 572     wm->info.lBufOffset = wm->info.lDiskOffset;
 573     wm->info.pchNext = wm->info.pchBuffer;
 574     wm->info.pchEndRead = wm->info.pchBuffer;
 575     wm->info.pchEndWrite = wm->info.pchBuffer + wm->info.cchBuffer;
 576
 577     wm->bBufferLoaded = TRUE;
 578     if (for_read) {
 579         size = send_message(wm->ioProc, &wm->info, MMIOM_READ,
 580                             (LPARAM)wm->info.pchBuffer, size, FALSE);
 581         if (size > 0)
 582             wm->info.pchEndRead += size;
 583         else
 584             wm->bBufferLoaded = FALSE;
 585     }
 586
 587     return size;
 588 }
 589
 590 /***************************************************************************
 591  *                      MMIO_SetBuffer                          [INTERNAL]
 592  */
 593 static MMRESULT MMIO_SetBuffer(WINE_MMIO* wm, void* pchBuffer, LONG cchBuffer,
 594                                UINT uFlags)
 595 {
 596     TRACE("(%p %p %ld %u)\n", wm, pchBuffer, cchBuffer, uFlags);
 597
 598     if (cchBuffer > 0xFFFF)
 599         WARN("Untested handling of huge mmio buffers (%ld >= 64k)\n", cchBuffer);
 600
 601     if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
 602         return MMIOERR_CANNOTWRITE;
 603
 604     /* free previous buffer if allocated */
 605     if (wm->info.dwFlags & MMIO_ALLOCBUF) {
 606         free(wm->info.pchBuffer);
 607         wm->info.pchBuffer = NULL;
 608         wm->info.dwFlags &= ~MMIO_ALLOCBUF;
 609     }
 610
 611     if (pchBuffer) {
 612         wm->info.pchBuffer = pchBuffer;
 613     } else if (cchBuffer) {
 614         if (!(wm->info.pchBuffer = malloc(cchBuffer)))
 615             return MMIOERR_OUTOFMEMORY;
 616         wm->info.dwFlags |= MMIO_ALLOCBUF;
 617     } else {
 618         wm->info.pchBuffer = NULL;
 619     }
 620
 621     wm->info.cchBuffer = cchBuffer;
 622     wm->info.pchNext = wm->info.pchBuffer;
 623     wm->info.pchEndRead = wm->info.pchBuffer;
 624     wm->info.pchEndWrite = wm->info.pchBuffer + cchBuffer;
 625     wm->info.lBufOffset = wm->info.lDiskOffset;
 626     wm->bBufferLoaded = (wm->info.fccIOProc == FOURCC_MEM);
 627
 628     return MMSYSERR_NOERROR;
 629 }
 630
 631 /**************************************************************************
 632  *                      MMIO_Open                               [internal]
 633  */
 634 static HMMIO MMIO_Open(LPSTR szFileName, MMIOINFO* refmminfo, DWORD dwOpenFlags, BOOL is_unicode)
 635 {
 636     LPWINE_MMIO         wm;
 637     MMIOINFO            mmioinfo;
 638     DWORD               pos;
 639
 640     TRACE("(%s, %p, %08lX, %s);\n", debugstr_a(szFileName), refmminfo, dwOpenFlags, is_unicode ? "unicode" : "ansi");
 641
 642     if (!refmminfo) {
 643         refmminfo = &mmioinfo;
 644         memset(&mmioinfo, 0, sizeof(mmioinfo));
 645         is_unicode = FALSE;
 646     }
 647
 648     if (dwOpenFlags & (MMIO_PARSE|MMIO_EXIST)) {
 649         char    buffer[MAX_PATH];
 650
 651         if (!szFileName)
 652             return (HMMIO)FALSE;
 653         if (GetFullPathNameA(szFileName, sizeof(buffer), buffer, NULL) >= sizeof(buffer))
 654             return (HMMIO)FALSE;
 655         if ((dwOpenFlags & MMIO_EXIST) && (GetFileAttributesA(buffer) == INVALID_FILE_ATTRIBUTES))
 656             return (HMMIO)FALSE;
 657         strcpy(szFileName, buffer);
 658         return (HMMIO)TRUE;
 659     }
 660
 661     if ((wm = MMIO_Create()) == NULL)
 662         return 0;
 663
 664     /* If both params are NULL, then parse the file name if available */
 665     if (refmminfo->fccIOProc == 0 && refmminfo->pIOProc == NULL) {
 666         wm->info.fccIOProc = MMIO_ParseExtA(szFileName);
 667         /* Handle any unhandled/error case. Assume DOS file */
 668         if (wm->info.fccIOProc == 0) {
 669             wm->info.fccIOProc = FOURCC_DOS;
 670             wm->ioProc = &defaultProcs[0];
 671         }
 672         else if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) {
 673             /* If not found, assume DOS file */
 674             wm->ioProc = &defaultProcs[0];
 675         }
 676         wm->bTmpIOProc = FALSE;
 677     }
 678     /* if just the four character code is present, look up IO proc */
 679     else if (refmminfo->pIOProc == NULL) {
 680         wm->info.fccIOProc = refmminfo->fccIOProc;
 681         if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
 682         wm->bTmpIOProc = FALSE;
 683     }
 684     /* if IO proc specified, use it and specified four character code */
 685     else {
 686         wm->info.fccIOProc = refmminfo->fccIOProc;
 687         MMIO_InstallIOProc(wm->info.fccIOProc, refmminfo->pIOProc,
 688                            MMIO_INSTALLPROC, is_unicode);
 689         if (!(wm->ioProc = MMIO_FindProcNode(wm->info.fccIOProc))) goto error2;
 690         assert(wm->ioProc->pIOProc == refmminfo->pIOProc);
 691         wm->bTmpIOProc = TRUE;
 692     }
 693
 694     wm->ioProc->count++;
 695     wm->info.dwFlags = dwOpenFlags;
 696     wm->info.pIOProc = wm->ioProc->pIOProc;
 697
 698     if (dwOpenFlags & MMIO_ALLOCBUF) {
 699         refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer,
 700             refmminfo->cchBuffer ? refmminfo->cchBuffer : MMIO_DEFAULTBUFFER, 0);
 701         if (refmminfo->wErrorRet != MMSYSERR_NOERROR)
 702             goto error1;
 703     } else {
 704         refmminfo->wErrorRet = MMIO_SetBuffer(wm, refmminfo->pchBuffer, refmminfo->cchBuffer, 0);
 705         if (refmminfo->wErrorRet != MMSYSERR_NOERROR)
 706             goto error1;
 707     }
 708
 709     /* see mmioDosIOProc for that one */
 710     memcpy( wm->info.adwInfo, refmminfo->adwInfo, sizeof(wm->info.adwInfo) );
 711
 712     /* call IO proc to actually open file */
 713     refmminfo->wErrorRet = send_message(wm->ioProc, &wm->info, MMIOM_OPEN,
 714                                         (LPARAM)szFileName, 0, FALSE);
 715
 716     /* update offsets and grab file size, when possible */
 717     if (wm->info.fccIOProc == FOURCC_DOS && (send_message(wm->ioProc, &wm->info, MMIOM_SEEK, 0, SEEK_CUR, FALSE)) != -1) {
 718        pos = wm->info.lBufOffset = wm->info.lDiskOffset;
 719        send_message(wm->ioProc, &wm->info, MMIOM_SEEK, 0, SEEK_END, FALSE);
 720        wm->dwFileSize = wm->info.lDiskOffset;
 721        send_message(wm->ioProc, &wm->info, MMIOM_SEEK, pos, SEEK_SET, FALSE);
 722     }
 723     else wm->dwFileSize = 0;
 724
 725     if (refmminfo->wErrorRet == 0)
 726         return wm->info.hmmio;
 727  error1:
 728     if (wm->info.dwFlags & MMIO_ALLOCBUF)
 729         free(wm->info.pchBuffer);
 730     if (wm->ioProc) wm->ioProc->count--;
 731  error2:
 732     MMIO_Destroy(wm);
 733     return 0;
 734 }
 735
 736 /**************************************************************************
 737  *                              mmioOpenW                       [WINMM.@]
 738  */
 739 HMMIO WINAPI mmioOpenW(LPWSTR szFileName, MMIOINFO* lpmmioinfo,
 740                        DWORD dwOpenFlags)
 741 {
 742     HMMIO       ret;
 743     LPSTR       szFn = NULL;
 744
 745     if (szFileName)
 746     {
 747         INT     len = WideCharToMultiByte( CP_ACP, 0, szFileName, -1, NULL, 0, NULL, NULL );
 748         if (len < MAX_PATH) len = MAX_PATH;
 749         szFn = malloc( len );
 750         if (!szFn) return NULL;
 751         WideCharToMultiByte( CP_ACP, 0, szFileName, -1, szFn, len, NULL, NULL );
 752     }
 753
 754     ret = MMIO_Open(szFn, lpmmioinfo, dwOpenFlags, TRUE);
 755
 756     free(szFn);
 757     return ret;
 758 }
 759
 760 /**************************************************************************
 761  *                              mmioOpenA                       [WINMM.@]
 762  */
 763 HMMIO WINAPI mmioOpenA(LPSTR szFileName, MMIOINFO* lpmmioinfo,
 764                        DWORD dwOpenFlags)
 765 {
 766     return  MMIO_Open(szFileName, lpmmioinfo, dwOpenFlags, FALSE);
 767 }
 768
 769 /**************************************************************************
 770  *                              mmioClose               [WINMM.@]
 771  */
 772 MMRESULT WINAPI mmioClose(HMMIO hmmio, UINT uFlags)
 773 {
 774     LPWINE_MMIO wm;
 775     MMRESULT    result;
 776
 777     TRACE("(%p, %04X);\n", hmmio, uFlags);
 778
 779     if ((wm = MMIO_Get(hmmio)) == NULL)
 780         return MMSYSERR_INVALHANDLE;
 781
 782     if ((result = MMIO_Flush(wm, 0)) != MMSYSERR_NOERROR)
 783         return result;
 784
 785     result = send_message(wm->ioProc, &wm->info, MMIOM_CLOSE, uFlags, 0, FALSE);
 786
 787     MMIO_SetBuffer(wm, NULL, 0, 0);
 788
 789     wm->ioProc->count--;
 790
 791     if (wm->bTmpIOProc)
 792         MMIO_InstallIOProc(wm->info.fccIOProc, wm->ioProc->pIOProc,
 793                            MMIO_REMOVEPROC, wm->ioProc->is_unicode);
 794
 795     MMIO_Destroy(wm);
 796
 797     return result;
 798 }
 799
 800 /**************************************************************************
 801  *                              mmioRead                [WINMM.@]
 802  */
 803 LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
 804 {
 805     LPWINE_MMIO wm;
 806     LONG        count;
 807
 808     TRACE("(%p, %p, %ld);\n", hmmio, pch, cch);
 809
 810     if ((wm = MMIO_Get(hmmio)) == NULL)
 811         return -1;
 812
 813     /* unbuffered case first */
 814     if (!wm->info.pchBuffer)
 815         return send_message(wm->ioProc, &wm->info, MMIOM_READ, (LPARAM)pch, cch, FALSE);
 816
 817     /* first try from current buffer */
 818     if (cch && wm->info.fccIOProc != FOURCC_MEM && wm->info.pchNext == wm->info.pchEndRead)
 819         MMIO_GrabNextBuffer(wm, TRUE);
 820     if (wm->info.pchNext != wm->info.pchEndRead) {
 821         count = wm->info.pchEndRead - wm->info.pchNext;
 822         if (count > cch || count < 0) count = cch;
 823         memcpy(pch, wm->info.pchNext, count);
 824         wm->info.pchNext += count;
 825         pch += count;
 826         cch -= count;
 827     } else
 828         count = 0;
 829
 830     if (cch && (wm->info.fccIOProc != FOURCC_MEM)) {
 831         assert(wm->info.cchBuffer);
 832
 833         while (cch) {
 834             LONG size;
 835
 836             size = MMIO_GrabNextBuffer(wm, TRUE);
 837             if (size <= 0) break;
 838             if (size > cch) size = cch;
 839             memcpy(pch, wm->info.pchBuffer, size);
 840             wm->info.pchNext += size;
 841             pch += size;
 842             cch -= size;
 843             count += size;
 844         }
 845         wm->bBufferLoaded = FALSE;
 846         mmioSeek(hmmio, 0, SEEK_CUR);
 847     }
 848
 849     TRACE("count=%ld\n", count);
 850     return count;
 851 }
 852
 853 /**************************************************************************
 854  *                              mmioWrite               [WINMM.@]
 855  */
 856 LONG WINAPI mmioWrite(HMMIO hmmio, HPCSTR pch, LONG cch)
 857 {
 858     LPWINE_MMIO wm;
 859     LONG        count;
 860
 861     TRACE("(%p, %p, %ld);\n", hmmio, pch, cch);
 862
 863     if ((wm = MMIO_Get(hmmio)) == NULL)
 864         return -1;
 865
 866     if (wm->info.cchBuffer) {
 867         LONG    bytesW = 0;
 868
 869         while (cch) {
 870             if (wm->info.pchNext != wm->info.pchEndWrite) {
 871                 count = wm->info.pchEndWrite - wm->info.pchNext;
 872                 if (count > cch || count < 0) count = cch;
 873                 memcpy(wm->info.pchNext, pch, count);
 874                 wm->info.pchNext += count;
 875                 pch += count;
 876                 cch -= count;
 877                 bytesW += count;
 878                 wm->info.dwFlags |= MMIO_DIRTY;
 879             } else {
 880                 if (wm->info.fccIOProc == FOURCC_MEM) {
 881                     if (wm->info.adwInfo[0]) {
 882                         /* from where would we get the memory handle? */
 883                         FIXME("memory file expansion not implemented!\n");
 884                         break;
 885                     } else break;
 886                 }
 887             }
 888
 889             if (wm->info.pchNext == wm->info.pchEndWrite)
 890             {
 891                 MMIO_Flush(wm, MMIO_EMPTYBUF);
 892                 MMIO_GrabNextBuffer(wm, FALSE);
 893             }
 894             else break;
 895         }
 896         count = bytesW;
 897     } else {
 898         count = send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)pch, cch, FALSE);
 899         wm->info.lBufOffset = wm->info.lDiskOffset;
 900     }
 901
 902     TRACE("bytes written=%ld\n", count);
 903     return count;
 904 }
 905
 906 /**************************************************************************
 907  *                              mmioSeek                [WINMM.@]
 908  */
 909 LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, INT iOrigin)
 910 {
 911     LPWINE_MMIO wm;
 912     LONG        offset;
 913
 914     TRACE("(%p, %08lX, %d);\n", hmmio, lOffset, iOrigin);
 915
 916     if ((wm = MMIO_Get(hmmio)) == NULL)
 917         return MMSYSERR_INVALHANDLE;
 918
 919     /* not buffered, direct seek on file */
 920     if (!wm->info.pchBuffer && wm->info.fccIOProc != FOURCC_MEM) {
 921         LRESULT ret = send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lOffset, iOrigin, FALSE);
 922         if (ret != -1)
 923             wm->info.lBufOffset = wm->info.lDiskOffset;
 924         return ret;
 925     }
 926
 927     switch (iOrigin) {
 928     case SEEK_SET:
 929         offset = lOffset;
 930         break;
 931     case SEEK_CUR:
 932         offset = wm->info.lBufOffset + (wm->info.pchNext - wm->info.pchBuffer) + lOffset;
 933         break;
 934     case SEEK_END:
 935         switch (wm->info.fccIOProc) {
 936         case FOURCC_MEM:
 937             offset = wm->info.cchBuffer - lOffset;
 938             break;
 939         case FOURCC_DOS:
 940             offset = wm->dwFileSize - lOffset;
 941             break;
 942         default:
 943             offset = send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lOffset, SEEK_END, FALSE);
 944             break;
 945         }
 946         break;
 947     default:
 948         return -1;
 949     }
 950
 951     /* stay in same buffer ? */
 952     /* some memory mapped buffers are defined with -1 as a size */
 953     if ((wm->info.cchBuffer > 0) &&
 954         ((offset < wm->info.lBufOffset) ||
 955          (offset > wm->info.lBufOffset + wm->info.cchBuffer) ||
 956          (offset > wm->dwFileSize && wm->info.fccIOProc == FOURCC_DOS) ||
 957          !wm->bBufferLoaded)) {
 958
 959         /* condition to change buffer */
 960         if ((wm->info.fccIOProc == FOURCC_MEM) ||
 961             MMIO_Flush(wm, 0) != MMSYSERR_NOERROR ||
 962             /* this also sets the wm->info.lDiskOffset field */
 963             send_message(wm->ioProc, &wm->info, MMIOM_SEEK,
 964                          offset, SEEK_SET, FALSE) == -1)
 965             return -1;
 966         wm->info.lBufOffset = offset;
 967         wm->bBufferLoaded = FALSE;
 968         wm->info.pchNext = wm->info.pchEndRead = wm->info.pchBuffer;
 969     }
 970     else
 971         wm->info.pchNext = wm->info.pchBuffer + (offset - wm->info.lBufOffset);
 972
 973     TRACE("=> %ld\n", offset);
 974     return offset;
 975 }
 976
 977 /**************************************************************************
 978  *                              mmioGetInfo             [WINMM.@]
 979  */
 980 MMRESULT WINAPI mmioGetInfo(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags)
 981 {
 982     LPWINE_MMIO         wm;
 983
 984     TRACE("(%p,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
 985
 986     if ((wm = MMIO_Get(hmmio)) == NULL)
 987         return MMSYSERR_INVALHANDLE;
 988
 989     *lpmmioinfo = wm->info;
 990
 991     return MMSYSERR_NOERROR;
 992 }
 993
 994 /**************************************************************************
 995  *                              mmioSetInfo             [WINMM.@]
 996  */
 997 MMRESULT WINAPI mmioSetInfo(HMMIO hmmio, const MMIOINFO* lpmmioinfo, UINT uFlags)
 998 {
 999     LPWINE_MMIO wm;
1000
1001     TRACE("(%p,%p,0x%08x)\n",hmmio,lpmmioinfo,uFlags);
1002
1003     if ((wm = MMIO_Get(hmmio)) == NULL)
1004         return MMSYSERR_INVALHANDLE;
1005
1006     /* check pointers coherence */
1007     if (lpmmioinfo->pchNext < wm->info.pchBuffer ||
1008             lpmmioinfo->pchNext > wm->info.pchBuffer + wm->info.cchBuffer ||
1009             lpmmioinfo->pchEndRead < wm->info.pchBuffer ||
1010             lpmmioinfo->pchEndRead > wm->info.pchBuffer + wm->info.cchBuffer ||
1011             lpmmioinfo->pchEndWrite < wm->info.pchBuffer ||
1012             lpmmioinfo->pchEndWrite > wm->info.pchBuffer + wm->info.cchBuffer)
1013         return MMSYSERR_INVALPARAM;
1014
1015     wm->info = *lpmmioinfo;
1016     return MMSYSERR_NOERROR;
1017 }
1018
1019 /**************************************************************************
1020 *                               mmioSetBuffer           [WINMM.@]
1021 */
1022 MMRESULT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer, UINT uFlags)
1023 {
1024     LPWINE_MMIO         wm;
1025
1026     TRACE("(hmmio=%p, pchBuf=%p, cchBuf=%ld, uFlags=%#08x)\n",
1027           hmmio, pchBuffer, cchBuffer, uFlags);
1028
1029     if ((wm = MMIO_Get(hmmio)) == NULL)
1030         return MMSYSERR_INVALHANDLE;
1031
1032     return MMIO_SetBuffer(wm, pchBuffer, cchBuffer, uFlags);
1033 }
1034
1035 /**************************************************************************
1036  *                              mmioFlush               [WINMM.@]
1037  */
1038 MMRESULT WINAPI mmioFlush(HMMIO hmmio, UINT uFlags)
1039 {
1040     LPWINE_MMIO         wm;
1041
1042     TRACE("(%p, %04X)\n", hmmio, uFlags);
1043
1044     if ((wm = MMIO_Get(hmmio)) == NULL)
1045         return MMSYSERR_INVALHANDLE;
1046
1047     return MMIO_Flush(wm, uFlags);
1048 }
1049
1050 /**************************************************************************
1051  *                              mmioAdvance             [WINMM.@]
1052  */
1053 MMRESULT WINAPI mmioAdvance(HMMIO hmmio, MMIOINFO* lpmmioinfo, UINT uFlags)
1054 {
1055     LPWINE_MMIO         wm;
1056
1057     TRACE("hmmio=%p, lpmmioinfo=%p, uFlags=%04X\n", hmmio, lpmmioinfo, uFlags);
1058
1059     /* NOTE: mmioAdvance16 heavily relies on parameters from lpmmioinfo we're using
1060      * here. be sure if you change something here to check mmioAdvance16 as well
1061      */
1062     if ((wm = MMIO_Get(hmmio)) == NULL)
1063         return MMSYSERR_INVALHANDLE;
1064
1065     if (!wm->info.cchBuffer)
1066         return MMIOERR_UNBUFFERED;
1067
1068     if (uFlags != MMIO_READ && uFlags != MMIO_WRITE)
1069         return MMSYSERR_INVALPARAM;
1070
1071     if (MMIO_Flush(wm, 0) != MMSYSERR_NOERROR)
1072         return MMIOERR_CANNOTWRITE;
1073     if (uFlags == MMIO_WRITE && (lpmmioinfo->dwFlags & MMIO_DIRTY))
1074     {
1075         send_message(wm->ioProc, &wm->info, MMIOM_SEEK, lpmmioinfo->lBufOffset, SEEK_SET, FALSE);
1076         send_message(wm->ioProc, &wm->info, MMIOM_WRITE, (LPARAM)lpmmioinfo->pchBuffer,
1077                      lpmmioinfo->pchNext - lpmmioinfo->pchBuffer, FALSE);
1078         lpmmioinfo->dwFlags &= ~MMIO_DIRTY;
1079     }
1080
1081     if (lpmmioinfo && lpmmioinfo->fccIOProc == FOURCC_DOS) {
1082         wm->dwFileSize = max(wm->dwFileSize, lpmmioinfo->lBufOffset +
1083                              (lpmmioinfo->pchNext - lpmmioinfo->pchBuffer));
1084     }
1085     MMIO_GrabNextBuffer(wm, uFlags == MMIO_READ);
1086
1087     if (lpmmioinfo) {
1088         lpmmioinfo->pchNext = lpmmioinfo->pchBuffer;
1089         lpmmioinfo->pchEndRead  = lpmmioinfo->pchBuffer +
1090             (wm->info.pchEndRead - wm->info.pchBuffer);
1091         lpmmioinfo->pchEndWrite = lpmmioinfo->pchBuffer +
1092             (wm->info.pchEndWrite - wm->info.pchBuffer);
1093         lpmmioinfo->lDiskOffset = wm->info.lDiskOffset;
1094         lpmmioinfo->lBufOffset = wm->info.lBufOffset;
1095     }
1096     return MMSYSERR_NOERROR;
1097 }
1098
1099 /**************************************************************************
1100  *                              mmioStringToFOURCCA     [WINMM.@]
1101  */
1102 FOURCC WINAPI mmioStringToFOURCCA(LPCSTR sz, UINT uFlags)
1103 {
1104     CHAR cc[4];
1105     int i = 0;
1106
1107     for (i = 0; i < 4 && sz[i]; i++) {
1108         if (uFlags & MMIO_TOUPPER) {
1109             cc[i] = RtlUpperChar(sz[i]);
1110         } else {
1111             cc[i] = sz[i];
1112         }
1113     }
1114
1115     /* Pad with spaces */
1116     while (i < 4) cc[i++] = ' ';
1117
1118     TRACE("Got %s\n",debugstr_an(cc,4));
1119     return mmioFOURCC(cc[0],cc[1],cc[2],cc[3]);
1120 }
1121
1122 /**************************************************************************
1123  *                              mmioStringToFOURCCW     [WINMM.@]
1124  */
1125 FOURCC WINAPI mmioStringToFOURCCW(LPCWSTR sz, UINT uFlags)
1126 {
1127     char        szA[4];
1128
1129     WideCharToMultiByte( CP_ACP, 0, sz, 4, szA, sizeof(szA), NULL, NULL );
1130     return mmioStringToFOURCCA(szA,uFlags);
1131 }
1132
1133 /**************************************************************************
1134  *                              mmioInstallIOProcA         [WINMM.@]
1135  */
1136 LPMMIOPROC WINAPI mmioInstallIOProcA(FOURCC fccIOProc,
1137                                      LPMMIOPROC pIOProc, DWORD dwFlags)
1138 {
1139     return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, FALSE);
1140 }
1141
1142 /**************************************************************************
1143  *                              mmioInstallIOProcW         [WINMM.@]
1144  */
1145 LPMMIOPROC WINAPI mmioInstallIOProcW(FOURCC fccIOProc,
1146                                      LPMMIOPROC pIOProc, DWORD dwFlags)
1147 {
1148     return MMIO_InstallIOProc(fccIOProc, pIOProc, dwFlags, TRUE);
1149 }
1150
1151 /******************************************************************
1152  *              MMIO_SendMessage
1153  *
1154  *
1155  */
1156 static LRESULT  MMIO_SendMessage(HMMIO hmmio, UINT uMessage, LPARAM lParam1,
1157                                  LPARAM lParam2, BOOL is_unicode)
1158 {
1159     LPWINE_MMIO         wm;
1160
1161     TRACE("(%p, %u, %Id, %Id, %s)\n", hmmio, uMessage, lParam1, lParam2, is_unicode ? "unicode" : "ansi");
1162
1163     if (uMessage < MMIOM_USER)
1164         return MMSYSERR_INVALPARAM;
1165
1166     if ((wm = MMIO_Get(hmmio)) == NULL)
1167         return MMSYSERR_INVALHANDLE;
1168
1169     return send_message(wm->ioProc, &wm->info, uMessage, lParam1, lParam2, is_unicode);
1170 }
1171
1172 /**************************************************************************
1173  *                              mmioSendMessage         [WINMM.@]
1174  */
1175 LRESULT WINAPI mmioSendMessage(HMMIO hmmio, UINT uMessage,
1176                                LPARAM lParam1, LPARAM lParam2)
1177 {
1178     return MMIO_SendMessage(hmmio, uMessage, lParam1, lParam2, FALSE);
1179 }
1180
1181 /**************************************************************************
1182  *                              mmioDescend             [WINMM.@]
1183  */
1184 MMRESULT WINAPI mmioDescend(HMMIO hmmio, LPMMCKINFO lpck,
1185                             const MMCKINFO* lpckParent, UINT uFlags)
1186 {
1187     DWORD               dwOldPos;
1188     FOURCC              srchCkId;
1189     FOURCC              srchType;
1190
1191     TRACE("(%p, %p, %p, %04X);\n", hmmio, lpck, lpckParent, uFlags);
1192
1193     if (lpck == NULL)
1194         return MMSYSERR_INVALPARAM;
1195
1196     dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1197     TRACE("dwOldPos=%ld\n", dwOldPos);
1198
1199     if (lpckParent != NULL) {
1200         TRACE("seek inside parent at %ld !\n", lpckParent->dwDataOffset);
1201         /* EPP: was dwOldPos = mmioSeek(hmmio,lpckParent->dwDataOffset,SEEK_SET); */
1202         if (dwOldPos < lpckParent->dwDataOffset ||
1203             dwOldPos >= lpckParent->dwDataOffset + lpckParent->cksize) {
1204             WARN("outside parent chunk\n");
1205             return MMIOERR_CHUNKNOTFOUND;
1206         }
1207     }
1208
1209     /* The SDK docu says 'ckid' is used for all cases. Real World
1210      * examples disagree -Marcus,990216.
1211      */
1212
1213     srchCkId = 0;
1214     srchType = 0;
1215
1216     /* find_chunk looks for 'ckid' */
1217     if (uFlags & MMIO_FINDCHUNK)
1218         srchCkId = lpck->ckid;
1219
1220     /* find_riff and find_list look for 'fccType' */
1221     if (uFlags & MMIO_FINDLIST)
1222     {
1223         srchCkId = FOURCC_LIST;
1224         srchType = lpck->fccType;
1225     }
1226
1227     if (uFlags & MMIO_FINDRIFF)
1228     {
1229         srchCkId = FOURCC_RIFF;
1230         srchType = lpck->fccType;
1231     }
1232
1233     TRACE("searching for %s.%s\n",
1234           debugstr_an((LPCSTR)&srchCkId, 4), srchType ? debugstr_an((LPCSTR)&srchType, 4) : "<any>");
1235
1236     while (TRUE)
1237     {
1238         LONG ix;
1239
1240         ix = mmioRead(hmmio, (LPSTR)lpck, 3 * sizeof(DWORD));
1241         if (ix < 0 || ix < 2*sizeof(DWORD))
1242         {
1243             mmioSeek(hmmio, dwOldPos, SEEK_SET);
1244             WARN("return ChunkNotFound\n");
1245             return MMIOERR_CHUNKNOTFOUND;
1246         }
1247
1248         lpck->dwDataOffset = dwOldPos + 2 * sizeof(DWORD);
1249         TRACE("ckid=%s fcc=%s cksize=%08lX !\n",
1250               debugstr_an((LPCSTR)&lpck->ckid, 4),
1251               srchType ? debugstr_an((LPCSTR)&lpck->fccType, 4) : "<na>",
1252               lpck->cksize);
1253         if ( (!srchCkId || (srchCkId == lpck->ckid)) &&
1254              (!srchType || (srchType == lpck->fccType)) )
1255             break;
1256
1257         dwOldPos = lpck->dwDataOffset + ((lpck->cksize + 1) & ~1);
1258         mmioSeek(hmmio, dwOldPos, SEEK_SET);
1259     }
1260
1261     lpck->dwFlags = 0;
1262     /* If we were looking for RIFF/LIST chunks, the final file position
1263      * is after the chunkid. If we were just looking for the chunk
1264      * it is after the cksize. So add 4 in RIFF/LIST case.
1265      */
1266     if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1267         mmioSeek(hmmio, lpck->dwDataOffset + sizeof(DWORD), SEEK_SET);
1268     else
1269     {
1270         mmioSeek(hmmio, lpck->dwDataOffset, SEEK_SET);
1271         lpck->fccType = 0;
1272     }
1273     TRACE("lpck: ckid=%s, cksize=%ld, dwDataOffset=%ld fccType=%08lX (%s)!\n",
1274           debugstr_an((LPSTR)&lpck->ckid, 4), lpck->cksize, lpck->dwDataOffset,
1275           lpck->fccType, srchType ? debugstr_an((LPSTR)&lpck->fccType, 4):"");
1276     return MMSYSERR_NOERROR;
1277 }
1278
1279 /**************************************************************************
1280  *                              mmioAscend              [WINMM.@]
1281  */
1282 MMRESULT WINAPI mmioAscend(HMMIO hmmio, LPMMCKINFO lpck, UINT uFlags)
1283 {
1284     TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags);
1285
1286     if (lpck->dwFlags & MMIO_DIRTY) {
1287         DWORD   dwOldPos, dwNewSize;
1288
1289         TRACE("Chunk is dirty, checking if chunk's size is correct\n");
1290         dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1291         TRACE("dwOldPos=%ld lpck->dwDataOffset = %ld\n", dwOldPos, lpck->dwDataOffset);
1292         dwNewSize = dwOldPos - lpck->dwDataOffset;
1293         if (dwNewSize != lpck->cksize) {
1294             TRACE("Nope: lpck->cksize=%ld dwNewSize=%ld\n", lpck->cksize, dwNewSize);
1295             lpck->cksize = dwNewSize;
1296
1297             /* pad odd size with 0 */
1298             if (dwNewSize & 1) {
1299                 char ch = 0;
1300                 mmioWrite(hmmio, &ch, 1);
1301             }
1302             mmioSeek(hmmio, lpck->dwDataOffset - sizeof(DWORD), SEEK_SET);
1303             mmioWrite(hmmio, (LPSTR)&dwNewSize, sizeof(DWORD));
1304         }
1305         lpck->dwFlags = 0;
1306     }
1307
1308     mmioSeek(hmmio, lpck->dwDataOffset + ((lpck->cksize + 1) & ~1), SEEK_SET);
1309
1310     return MMSYSERR_NOERROR;
1311 }
1312
1313 /**************************************************************************
1314  *                      mmioCreateChunk                         [WINMM.@]
1315  */
1316 MMRESULT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO* lpck, UINT uFlags)
1317 {
1318     DWORD       dwOldPos;
1319     LONG        size;
1320     LONG        ix;
1321
1322     TRACE("(%p, %p, %04X);\n", hmmio, lpck, uFlags);
1323
1324     dwOldPos = mmioSeek(hmmio, 0, SEEK_CUR);
1325     TRACE("dwOldPos=%ld\n", dwOldPos);
1326
1327     if (uFlags == MMIO_CREATELIST)
1328         lpck->ckid = FOURCC_LIST;
1329     else if (uFlags == MMIO_CREATERIFF)
1330         lpck->ckid = FOURCC_RIFF;
1331
1332     TRACE("ckid=%s\n", debugstr_an((LPSTR)&lpck->ckid, 4));
1333
1334     size = 2 * sizeof(DWORD);
1335     lpck->dwDataOffset = dwOldPos + size;
1336
1337     if (lpck->ckid == FOURCC_RIFF || lpck->ckid == FOURCC_LIST)
1338         size += sizeof(DWORD);
1339     lpck->dwFlags = MMIO_DIRTY;
1340
1341     ix = mmioWrite(hmmio, (LPSTR)lpck, size);
1342     TRACE("after mmioWrite ix = %ld req = %ld, errno = %d\n", ix, size, errno);
1343     if (ix != size) {
1344         mmioSeek(hmmio, dwOldPos, SEEK_SET);
1345         WARN("return CannotWrite\n");
1346         return MMIOERR_CANNOTWRITE;
1347     }
1348
1349     return MMSYSERR_NOERROR;
1350 }
1351
1352 /**************************************************************************
1353  *                              mmioRenameA                     [WINMM.@]
1354  */
1355 MMRESULT WINAPI mmioRenameA(LPCSTR szFileName, LPCSTR szNewFileName,
1356                             const MMIOINFO* lpmmioinfo, DWORD dwFlags)
1357 {
1358     struct IOProcList*  ioProc = NULL;
1359     struct IOProcList   tmp;
1360     FOURCC              fcc;
1361
1362     TRACE("(%s, %s, %p, %08lX);\n",
1363           debugstr_a(szFileName), debugstr_a(szNewFileName), lpmmioinfo, dwFlags);
1364
1365     /* If both params are NULL, then parse the file name */
1366     if (lpmmioinfo && lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL)
1367     {
1368         fcc = MMIO_ParseExtA(szFileName);
1369         if (fcc) ioProc = MMIO_FindProcNode(fcc);
1370     }
1371
1372     /* Handle any unhandled/error case from above. Assume DOS file */
1373     if (!lpmmioinfo || (lpmmioinfo->fccIOProc == 0 && lpmmioinfo->pIOProc == NULL && ioProc == NULL))
1374         ioProc = &defaultProcs[0];
1375     /* if just the four character code is present, look up IO proc */
1376     else if (lpmmioinfo->pIOProc == NULL)
1377         ioProc = MMIO_FindProcNode(lpmmioinfo->fccIOProc);
1378     else /* use relevant ioProc */
1379     {
1380         ioProc = &tmp;
1381         tmp.fourCC = lpmmioinfo->fccIOProc;
1382         tmp.pIOProc = lpmmioinfo->pIOProc;
1383         tmp.is_unicode = FALSE;
1384         tmp.count = 1;
1385     }
1386
1387     /* FIXME: should we actually pass lpmmioinfo down the drain ???
1388      * or make a copy of it because it's const ???
1389      */
1390     return send_message(ioProc, (MMIOINFO*)lpmmioinfo, MMIOM_RENAME,
1391                         (LPARAM)szFileName, (LPARAM)szNewFileName, FALSE);
1392 }
1393
1394 /**************************************************************************
1395  *                              mmioRenameW                     [WINMM.@]
1396  */
1397 MMRESULT WINAPI mmioRenameW(LPCWSTR szFileName, LPCWSTR szNewFileName,
1398                             const MMIOINFO* lpmmioinfo, DWORD dwFlags)
1399 {
1400     LPSTR       szFn = NULL;
1401     LPSTR       sznFn = NULL;
1402     UINT        ret = MMSYSERR_NOMEM;
1403     INT         len;
1404
1405     if (szFileName)
1406     {
1407         len = WideCharToMultiByte( CP_ACP, 0, szFileName, -1, NULL, 0, NULL, NULL );
1408         szFn = malloc( len );
1409         if (!szFn) goto done;
1410         WideCharToMultiByte( CP_ACP, 0, szFileName, -1, szFn, len, NULL, NULL );
1411     }
1412     if (szNewFileName)
1413     {
1414         len = WideCharToMultiByte( CP_ACP, 0, szNewFileName, -1, NULL, 0, NULL, NULL );
1415         sznFn = malloc( len );
1416         if (!sznFn) goto done;
1417         WideCharToMultiByte( CP_ACP, 0, szNewFileName, -1, sznFn, len, NULL, NULL );
1418     }
1419
1420     ret = mmioRenameA(szFn, sznFn, lpmmioinfo, dwFlags);
1421
1422 done:
1423     free(szFn);
1424     free(sznFn);
1425     return ret;
1426 }