dlls/kernel32/volume.c

   1 /*
   2  * Volume management functions
   3  *
   4  * Copyright 1993 Erik Bos
   5  * Copyright 1996, 2004 Alexandre Julliard
   6  * Copyright 1999 Petr Tomasek
   7  * Copyright 2000 Andreas Mohr
   8  * Copyright 2003 Eric Pouech
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winnls.h"
  34 #include "winternl.h"
  35 #include "winioctl.h"
  36 #include "ntddcdrm.h"
  37 #include "ddk/wdm.h"
  38 #include "kernel_private.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(volume);
  42
  43 #define BLOCK_SIZE 2048
  44 #define SUPERBLOCK_SIZE BLOCK_SIZE
  45
  46 #define GETWORD(buf,off)  MAKEWORD(buf[(off)],buf[(off+1)])
  47 #define GETLONG(buf,off)  MAKELONG(GETWORD(buf,off),GETWORD(buf,off+2))
  48
  49 enum fs_type
  50 {
  51     FS_ERROR,    /* error accessing the device */
  52     FS_UNKNOWN,  /* unknown file system */
  53     FS_FAT1216,
  54     FS_FAT32,
  55     FS_ISO9660,
  56     FS_UDF       /* For reference [E] = Ecma-167.pdf, [U] = udf260.pdf */
  57 };
  58
  59 /******************************************************************
  60  *              VOLUME_FindCdRomDataBestVoldesc
  61  */
  62 static DWORD VOLUME_FindCdRomDataBestVoldesc( HANDLE handle )
  63 {
  64     BYTE cur_vd_type, max_vd_type = 0;
  65     BYTE buffer[0x800];
  66     DWORD size, offs, best_offs = 0, extra_offs = 0;
  67
  68     for (offs = 0x8000; offs <= 0x9800; offs += 0x800)
  69     {
  70         /* if 'CDROM' occurs at position 8, this is a pre-iso9660 cd, and
  71          * the volume label is displaced forward by 8
  72          */
  73         if (SetFilePointer( handle, offs, NULL, FILE_BEGIN ) != offs) break;
  74         if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL )) break;
  75         if (size != sizeof(buffer)) break;
  76         /* check for non-ISO9660 signature */
  77         if (!memcmp( buffer + 11, "ROM", 3 )) extra_offs = 8;
  78         cur_vd_type = buffer[extra_offs];
  79         if (cur_vd_type == 0xff) /* voldesc set terminator */
  80             break;
  81         if (cur_vd_type > max_vd_type)
  82         {
  83             max_vd_type = cur_vd_type;
  84             best_offs = offs + extra_offs;
  85         }
  86     }
  87     return best_offs;
  88 }
  89
  90
  91 /***********************************************************************
  92  *           VOLUME_ReadFATSuperblock
  93  */
  94 static enum fs_type VOLUME_ReadFATSuperblock( HANDLE handle, BYTE *buff )
  95 {
  96     DWORD size;
  97
  98     /* try a fixed disk, with a FAT partition */
  99     if (SetFilePointer( handle, 0, NULL, FILE_BEGIN ) != 0 ||
 100         !ReadFile( handle, buff, SUPERBLOCK_SIZE, &size, NULL ))
 101     {
 102         if (GetLastError() == ERROR_BAD_DEV_TYPE) return FS_UNKNOWN;  /* not a real device */
 103         return FS_ERROR;
 104     }
 105
 106     if (size < SUPERBLOCK_SIZE) return FS_UNKNOWN;
 107
 108     /* FIXME: do really all FAT have their name beginning with
 109      * "FAT" ? (At least FAT12, FAT16 and FAT32 have :)
 110      */
 111     if (!memcmp(buff+0x36, "FAT", 3) || !memcmp(buff+0x52, "FAT", 3))
 112     {
 113         /* guess which type of FAT we have */
 114         int reasonable;
 115         unsigned int sectors,
 116                      sect_per_fat,
 117                      total_sectors,
 118                      num_boot_sectors,
 119                      num_fats,
 120                      num_root_dir_ents,
 121                      bytes_per_sector,
 122                      sectors_per_cluster,
 123                      nclust;
 124         sect_per_fat = GETWORD(buff, 0x16);
 125         if (!sect_per_fat) sect_per_fat = GETLONG(buff, 0x24);
 126         total_sectors = GETWORD(buff, 0x13);
 127         if (!total_sectors)
 128             total_sectors = GETLONG(buff, 0x20);
 129         num_boot_sectors = GETWORD(buff, 0x0e);
 130         num_fats =  buff[0x10];
 131         num_root_dir_ents = GETWORD(buff, 0x11);
 132         bytes_per_sector = GETWORD(buff, 0x0b);
 133         sectors_per_cluster = buff[0x0d];
 134         /* check if the parameters are reasonable and will not cause
 135          * arithmetic errors in the calculation */
 136         reasonable = num_boot_sectors < total_sectors &&
 137                      num_fats < 16 &&
 138                      bytes_per_sector >= 512 && bytes_per_sector % 512 == 0 &&
 139                      sectors_per_cluster >= 1;
 140         if (!reasonable) return FS_UNKNOWN;
 141         sectors =  total_sectors - num_boot_sectors - num_fats * sect_per_fat -
 142             (num_root_dir_ents * 32 + bytes_per_sector - 1) / bytes_per_sector;
 143         nclust = sectors / sectors_per_cluster;
 144         if ((buff[0x42] == 0x28 || buff[0x42] == 0x29) &&
 145                 !memcmp(buff+0x52, "FAT", 3)) return FS_FAT32;
 146         if (nclust < 65525)
 147         {
 148             if ((buff[0x26] == 0x28 || buff[0x26] == 0x29) &&
 149                     !memcmp(buff+0x36, "FAT", 3))
 150                 return FS_FAT1216;
 151         }
 152     }
 153     return FS_UNKNOWN;
 154 }
 155
 156
 157 /***********************************************************************
 158  *           VOLUME_ReadCDBlock
 159  */
 160 static BOOL VOLUME_ReadCDBlock( HANDLE handle, BYTE *buff, INT offs )
 161 {
 162     DWORD size, whence = offs >= 0 ? FILE_BEGIN : FILE_END;
 163
 164     if (SetFilePointer( handle, offs, NULL, whence ) != offs ||
 165         !ReadFile( handle, buff, SUPERBLOCK_SIZE, &size, NULL ) ||
 166         size != SUPERBLOCK_SIZE)
 167         return FALSE;
 168
 169     return TRUE;
 170 }
 171
 172
 173 /***********************************************************************
 174  *           VOLUME_ReadCDSuperblock
 175  */
 176 static enum fs_type VOLUME_ReadCDSuperblock( HANDLE handle, BYTE *buff )
 177 {
 178     int i;
 179     DWORD offs;
 180
 181     /* Check UDF first as UDF and ISO9660 structures can coexist on the same medium
 182      *  Starting from sector 16, we may find :
 183      *  - a CD-ROM Volume Descriptor Set (ISO9660) containing one or more Volume Descriptors
 184      *  - an Extended Area (UDF) -- [E] 2/8.3.1 and [U] 2.1.7
 185      *  There is no explicit end so read 16 sectors and then give up */
 186     for( i=16; i<16+16; i++)
 187     {
 188         if (!VOLUME_ReadCDBlock(handle, buff, i*BLOCK_SIZE))
 189             continue;
 190
 191         /* We are supposed to check "BEA01", "NSR0x" and "TEA01" IDs + verify tag checksum
 192          *  but we assume the volume is well-formatted */
 193         if (!memcmp(&buff[1], "BEA01", 5)) return FS_UDF;
 194     }
 195
 196     offs = VOLUME_FindCdRomDataBestVoldesc( handle );
 197     if (!offs) return FS_UNKNOWN;
 198
 199     if (!VOLUME_ReadCDBlock(handle, buff, offs))
 200         return FS_ERROR;
 201
 202     /* check for the iso9660 identifier */
 203     if (!memcmp(&buff[1], "CD001", 5)) return FS_ISO9660;
 204     return FS_UNKNOWN;
 205 }
 206
 207
 208 /***********************************************************************
 209  *           SetVolumeLabelW   (KERNEL32.@)
 210  */
 211 BOOL WINAPI SetVolumeLabelW( LPCWSTR root, LPCWSTR label )
 212 {
 213     WCHAR device[] = L"\\\\.\\A:";
 214     HANDLE handle;
 215     enum fs_type type = FS_UNKNOWN;
 216
 217     if (!root)
 218     {
 219         WCHAR path[MAX_PATH];
 220         GetCurrentDirectoryW( MAX_PATH, path );
 221         device[4] = path[0];
 222     }
 223     else
 224     {
 225         if (!root[0] || root[1] != ':')
 226         {
 227             SetLastError( ERROR_INVALID_NAME );
 228             return FALSE;
 229         }
 230         device[4] = root[0];
 231     }
 232
 233     /* try to open the device */
 234
 235     handle = CreateFileW( device, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
 236                           NULL, OPEN_EXISTING, 0, 0 );
 237     if (handle != INVALID_HANDLE_VALUE)
 238     {
 239         BYTE superblock[SUPERBLOCK_SIZE];
 240
 241         type = VOLUME_ReadFATSuperblock( handle, superblock );
 242         if (type == FS_UNKNOWN) type = VOLUME_ReadCDSuperblock( handle, superblock );
 243         CloseHandle( handle );
 244         if (type != FS_UNKNOWN)
 245         {
 246             /* we can't set the label on FAT or CDROM file systems */
 247             TRACE( "cannot set label on device %s type %d\n", debugstr_w(device), type );
 248             SetLastError( ERROR_ACCESS_DENIED );
 249             return FALSE;
 250         }
 251     }
 252     else
 253     {
 254         TRACE( "cannot open device %s: err %d\n", debugstr_w(device), GetLastError() );
 255         if (GetLastError() == ERROR_ACCESS_DENIED) return FALSE;
 256     }
 257
 258     /* we couldn't open the device, fallback to default strategy */
 259
 260     switch(GetDriveTypeW( root ))
 261     {
 262     case DRIVE_UNKNOWN:
 263     case DRIVE_NO_ROOT_DIR:
 264         SetLastError( ERROR_NOT_READY );
 265         break;
 266     case DRIVE_REMOVABLE:
 267     case DRIVE_FIXED:
 268         {
 269             WCHAR labelW[] = L"A:\\.windows-label";
 270
 271             labelW[0] = device[4];
 272
 273             if (!label[0])  /* delete label file when setting an empty label */
 274                 return DeleteFileW( labelW ) || GetLastError() == ERROR_FILE_NOT_FOUND;
 275
 276             handle = CreateFileW( labelW, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 277                                   CREATE_ALWAYS, 0, 0 );
 278             if (handle != INVALID_HANDLE_VALUE)
 279             {
 280                 char buffer[64];
 281                 DWORD size;
 282
 283                 if (!WideCharToMultiByte( CP_UNIXCP, 0, label, -1, buffer, sizeof(buffer)-1, NULL, NULL ))
 284                     buffer[sizeof(buffer)-2] = 0;
 285                 strcat( buffer, "\n" );
 286                 WriteFile( handle, buffer, strlen(buffer), &size, NULL );
 287                 CloseHandle( handle );
 288                 return TRUE;
 289             }
 290             break;
 291         }
 292     case DRIVE_REMOTE:
 293     case DRIVE_RAMDISK:
 294     case DRIVE_CDROM:
 295         SetLastError( ERROR_ACCESS_DENIED );
 296         break;
 297     }
 298     return FALSE;
 299 }
 300
 301 /***********************************************************************
 302  *           SetVolumeLabelA   (KERNEL32.@)
 303  */
 304 BOOL WINAPI SetVolumeLabelA(LPCSTR root, LPCSTR volname)
 305 {
 306     WCHAR *rootW = NULL, *volnameW = NULL;
 307     BOOL ret;
 308
 309     if (root && !(rootW = FILE_name_AtoW( root, FALSE ))) return FALSE;
 310     if (volname && !(volnameW = FILE_name_AtoW( volname, TRUE ))) return FALSE;
 311     ret = SetVolumeLabelW( rootW, volnameW );
 312     HeapFree( GetProcessHeap(), 0, volnameW );
 313     return ret;
 314 }
 315
 316
 317 /***********************************************************************
 318  *           GetVolumeNameForVolumeMountPointA   (KERNEL32.@)
 319  */
 320 BOOL WINAPI GetVolumeNameForVolumeMountPointA( LPCSTR path, LPSTR volume, DWORD size )
 321 {
 322     BOOL ret;
 323     WCHAR volumeW[50], *pathW = NULL;
 324     DWORD len = min(ARRAY_SIZE(volumeW), size );
 325
 326     TRACE("(%s, %p, %x)\n", debugstr_a(path), volume, size);
 327
 328     if (!path || !(pathW = FILE_name_AtoW( path, TRUE )))
 329         return FALSE;
 330
 331     if ((ret = GetVolumeNameForVolumeMountPointW( pathW, volumeW, len )))
 332         FILE_name_WtoA( volumeW, -1, volume, len );
 333
 334     HeapFree( GetProcessHeap(), 0, pathW );
 335     return ret;
 336 }
 337
 338
 339 /***********************************************************************
 340  *           DefineDosDeviceA       (KERNEL32.@)
 341  */
 342 BOOL WINAPI DefineDosDeviceA(DWORD flags, LPCSTR devname, LPCSTR targetpath)
 343 {
 344     WCHAR *devW, *targetW = NULL;
 345     BOOL ret;
 346
 347     if (!(devW = FILE_name_AtoW( devname, FALSE ))) return FALSE;
 348     if (targetpath && !(targetW = FILE_name_AtoW( targetpath, TRUE ))) return FALSE;
 349     ret = DefineDosDeviceW(flags, devW, targetW);
 350     HeapFree( GetProcessHeap(), 0, targetW );
 351     return ret;
 352 }
 353
 354
 355 /***********************************************************************
 356  *           QueryDosDeviceA   (KERNEL32.@)
 357  *
 358  * returns array of strings terminated by \0, terminated by \0
 359  */
 360 DWORD WINAPI QueryDosDeviceA( LPCSTR devname, LPSTR target, DWORD bufsize )
 361 {
 362     DWORD ret = 0, retW;
 363     WCHAR *devnameW = NULL;
 364     LPWSTR targetW;
 365
 366     if (devname && !(devnameW = FILE_name_AtoW( devname, FALSE ))) return 0;
 367
 368     targetW = HeapAlloc( GetProcessHeap(),0, bufsize * sizeof(WCHAR) );
 369     if (!targetW)
 370     {
 371         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 372         return 0;
 373     }
 374
 375     retW = QueryDosDeviceW(devnameW, targetW, bufsize);
 376
 377     ret = FILE_name_WtoA( targetW, retW, target, bufsize );
 378
 379     HeapFree(GetProcessHeap(), 0, targetW);
 380     return ret;
 381 }
 382
 383
 384 /***********************************************************************
 385  *           GetLogicalDriveStringsA   (KERNEL32.@)
 386  */
 387 UINT WINAPI GetLogicalDriveStringsA( UINT len, LPSTR buffer )
 388 {
 389     DWORD drives = GetLogicalDrives();
 390     UINT drive, count;
 391
 392     for (drive = count = 0; drive < 26; drive++) if (drives & (1 << drive)) count++;
 393     if ((count * 4) + 1 > len) return count * 4 + 1;
 394
 395     for (drive = 0; drive < 26; drive++)
 396     {
 397         if (drives & (1 << drive))
 398         {
 399             *buffer++ = 'A' + drive;
 400             *buffer++ = ':';
 401             *buffer++ = '\\';
 402             *buffer++ = 0;
 403         }
 404     }
 405     *buffer = 0;
 406     return count * 4;
 407 }
 408
 409
 410 /***********************************************************************
 411  *           GetVolumePathNameA   (KERNEL32.@)
 412  */
 413 BOOL WINAPI GetVolumePathNameA(LPCSTR filename, LPSTR volumepathname, DWORD buflen)
 414 {
 415     BOOL ret;
 416     WCHAR *filenameW = NULL, *volumeW = NULL;
 417
 418     TRACE("(%s, %p, %d)\n", debugstr_a(filename), volumepathname, buflen);
 419
 420     if (filename && !(filenameW = FILE_name_AtoW( filename, FALSE )))
 421         return FALSE;
 422     if (volumepathname && !(volumeW = HeapAlloc( GetProcessHeap(), 0, buflen * sizeof(WCHAR) )))
 423         return FALSE;
 424
 425     if ((ret = GetVolumePathNameW( filenameW, volumeW, buflen )))
 426         FILE_name_WtoA( volumeW, -1, volumepathname, buflen );
 427
 428     HeapFree( GetProcessHeap(), 0, volumeW );
 429     return ret;
 430 }
 431
 432
 433 /***********************************************************************
 434  *           GetVolumePathNamesForVolumeNameA   (KERNEL32.@)
 435  */
 436 BOOL WINAPI GetVolumePathNamesForVolumeNameA(LPCSTR volumename, LPSTR volumepathname, DWORD buflen, PDWORD returnlen)
 437 {
 438     BOOL ret;
 439     WCHAR *volumenameW = NULL, *volumepathnameW;
 440
 441     if (volumename && !(volumenameW = FILE_name_AtoW( volumename, TRUE ))) return FALSE;
 442     if (!(volumepathnameW = HeapAlloc( GetProcessHeap(), 0, buflen * sizeof(WCHAR) )))
 443     {
 444         HeapFree( GetProcessHeap(), 0, volumenameW );
 445         return FALSE;
 446     }
 447     if ((ret = GetVolumePathNamesForVolumeNameW( volumenameW, volumepathnameW, buflen, returnlen )))
 448     {
 449         char *path = volumepathname;
 450         const WCHAR *pathW = volumepathnameW;
 451
 452         while (*pathW)
 453         {
 454             int len = lstrlenW( pathW ) + 1;
 455             FILE_name_WtoA( pathW, len, path, buflen );
 456             buflen -= len;
 457             pathW += len;
 458             path += len;
 459         }
 460         path[0] = 0;
 461     }
 462     HeapFree( GetProcessHeap(), 0, volumenameW );
 463     HeapFree( GetProcessHeap(), 0, volumepathnameW );
 464     return ret;
 465 }
 466
 467
 468 /***********************************************************************
 469  *           FindFirstVolumeA   (KERNEL32.@)
 470  */
 471 HANDLE WINAPI FindFirstVolumeA(LPSTR volume, DWORD len)
 472 {
 473     WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 474     HANDLE handle = FindFirstVolumeW( buffer, len );
 475
 476     if (handle != INVALID_HANDLE_VALUE)
 477     {
 478         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL ))
 479         {
 480             FindVolumeClose( handle );
 481             handle = INVALID_HANDLE_VALUE;
 482         }
 483     }
 484     HeapFree( GetProcessHeap(), 0, buffer );
 485     return handle;
 486 }
 487
 488 /***********************************************************************
 489  *           FindNextVolumeA   (KERNEL32.@)
 490  */
 491 BOOL WINAPI FindNextVolumeA( HANDLE handle, LPSTR volume, DWORD len )
 492 {
 493     WCHAR *buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 494     BOOL ret;
 495
 496     if ((ret = FindNextVolumeW( handle, buffer, len )))
 497     {
 498         if (!WideCharToMultiByte( CP_ACP, 0, buffer, -1, volume, len, NULL, NULL )) ret = FALSE;
 499     }
 500     HeapFree( GetProcessHeap(), 0, buffer );
 501     return ret;
 502 }
 503
 504 /***********************************************************************
 505  *           FindFirstVolumeMountPointA   (KERNEL32.@)
 506  */
 507 HANDLE WINAPI FindFirstVolumeMountPointA(LPCSTR root, LPSTR mount_point, DWORD len)
 508 {
 509     FIXME("(%s, %p, %d), stub!\n", debugstr_a(root), mount_point, len);
 510     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 511     return INVALID_HANDLE_VALUE;
 512 }
 513
 514 /***********************************************************************
 515  *           FindFirstVolumeMountPointW   (KERNEL32.@)
 516  */
 517 HANDLE WINAPI FindFirstVolumeMountPointW(LPCWSTR root, LPWSTR mount_point, DWORD len)
 518 {
 519     FIXME("(%s, %p, %d), stub!\n", debugstr_w(root), mount_point, len);
 520     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 521     return INVALID_HANDLE_VALUE;
 522 }
 523
 524 /***********************************************************************
 525  *           FindVolumeMountPointClose   (KERNEL32.@)
 526  */
 527 BOOL WINAPI FindVolumeMountPointClose(HANDLE h)
 528 {
 529     FIXME("(%p), stub!\n", h);
 530     return FALSE;
 531 }
 532
 533 /***********************************************************************
 534  *           DeleteVolumeMountPointA   (KERNEL32.@)
 535  */
 536 BOOL WINAPI DeleteVolumeMountPointA(LPCSTR mountpoint)
 537 {
 538     FIXME("(%s), stub!\n", debugstr_a(mountpoint));
 539     return FALSE;
 540 }
 541
 542 /***********************************************************************
 543  *           SetVolumeMountPointA (KERNEL32.@)
 544  */
 545 BOOL WINAPI SetVolumeMountPointA(LPCSTR path, LPCSTR volume)
 546 {
 547     FIXME("(%s, %s), stub!\n", debugstr_a(path), debugstr_a(volume));
 548     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 549     return FALSE;
 550 }
 551
 552 /***********************************************************************
 553  *           SetVolumeMountPointW (KERNEL32.@)
 554  */
 555 BOOL WINAPI SetVolumeMountPointW(LPCWSTR path, LPCWSTR volume)
 556 {
 557     FIXME("(%s, %s), stub!\n", debugstr_w(path), debugstr_w(volume));
 558     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 559     return FALSE;
 560 }