src/system/boot/loader/file_systems/fat/Directory.cpp

   1 /*
   2  * Copyright 2003-2013, Axel Dörfler, axeld@pinc-software.de.
   3  * Copyright 2008, François Revol <revol@free.fr>
   4  * Distributed under the terms of the MIT License.
   5  */
   6
   7
   8 #include "Directory.h"
   9
  10 #include <stdint.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <strings.h>
  14 #include <unistd.h>
  15
  16 #include <new>
  17
  18 #include <StorageDefs.h>
  19
  20 #include "CachedBlock.h"
  21 #include "File.h"
  22 #include "Volume.h"
  23
  24
  25 //#define TRACE(x) dprintf x
  26 #define TRACE(x) do {} while (0)
  27
  28
  29 using std::nothrow;
  30
  31
  32 namespace FATFS {
  33
  34
  35 struct dir_entry {
  36         void *Buffer() const { return (void *)fName; };
  37         const char *BaseName() const { return fName; };
  38         const char *Extension() const { return fExt; };
  39         uint8           Flags() const { return fFlags; };
  40         uint32          Cluster(int32 fatBits) const;
  41         void            SetCluster(uint32 cluster, int32 fatBits);
  42         uint32          Size() const { return B_LENDIAN_TO_HOST_INT32(fSize); };
  43         void            SetSize(uint32 size);
  44         bool            IsFile() const;
  45         bool            IsDir() const;
  46
  47         char fName[8];
  48         char fExt[3];
  49         uint8 fFlags;
  50         uint8 fReserved1;
  51         uint8 fCreateTime10ms;
  52         uint16 fCreateTime;
  53         uint16 fCreateDate;
  54         uint16 fAccessDate;
  55         uint16 fClusterMSB;
  56         uint16 fModifiedTime;
  57         uint16 fModifiedDate;
  58         uint16 fClusterLSB;
  59         uint32 fSize;
  60 } _PACKED;
  61
  62
  63 uint32
  64 dir_entry::Cluster(int32 fatBits) const
  65 {
  66         uint32 c = B_LENDIAN_TO_HOST_INT16(fClusterLSB);
  67         if (fatBits == 32)
  68                 c += ((uint32)B_LENDIAN_TO_HOST_INT16(fClusterMSB) << 16);
  69         return c;
  70 }
  71
  72
  73 void
  74 dir_entry::SetCluster(uint32 cluster, int32 fatBits)
  75 {
  76         fClusterLSB = B_HOST_TO_LENDIAN_INT16((uint16)cluster);
  77         if (fatBits == 32)
  78                 fClusterMSB = B_HOST_TO_LENDIAN_INT16(cluster >> 16);
  79 }
  80
  81
  82 void
  83 dir_entry::SetSize(uint32 size)
  84 {
  85         fSize = B_HOST_TO_LENDIAN_INT32(size);
  86 }
  87
  88
  89 bool
  90 dir_entry::IsFile() const
  91 {
  92         return ((Flags() & (FAT_VOLUME|FAT_SUBDIR)) == 0);
  93 }
  94
  95
  96 bool
  97 dir_entry::IsDir() const
  98 {
  99         return ((Flags() & (FAT_VOLUME|FAT_SUBDIR)) == FAT_SUBDIR);
 100 }
 101
 102
 103 struct dir_cookie {
 104         enum {
 105                 MAX_UTF16_NAME_LENGTH = 255
 106         };
 107
 108         int32   index;
 109         struct dir_entry entry;
 110         off_t   entryOffset;
 111         uint16  nameBuffer[MAX_UTF16_NAME_LENGTH];
 112         uint32  nameLength;
 113
 114         off_t   Offset() const { return index * sizeof(struct dir_entry); }
 115         char*   Name()  { return (char*)nameBuffer; }
 116
 117         void    ResetName();
 118         bool    AddNameChars(const uint16* chars, uint32 count);
 119         bool    ConvertNameToUTF8();
 120         void    Set8_3Name(const char* baseName, const char* extension);
 121 };
 122
 123
 124 void
 125 dir_cookie::ResetName()
 126 {
 127         nameLength = 0;
 128 }
 129
 130
 131 bool
 132 dir_cookie::AddNameChars(const uint16* chars, uint32 count)
 133 {
 134         // If there is a null character, we ignore it and all subsequent characters.
 135         for (uint32 i = 0; i < count; i++) {
 136                 if (chars[i] == 0) {
 137                         count = i;
 138                         break;
 139                 }
 140         }
 141
 142         if (count > 0) {
 143                 if (count > (MAX_UTF16_NAME_LENGTH - nameLength))
 144                         return false;
 145
 146                 nameLength += count;
 147                 memcpy(nameBuffer + (MAX_UTF16_NAME_LENGTH - nameLength),
 148                         chars, count * 2);
 149         }
 150
 151         return true;
 152 }
 153
 154
 155 bool
 156 dir_cookie::ConvertNameToUTF8()
 157 {
 158         char name[B_FILE_NAME_LENGTH];
 159         uint32 nameOffset = 0;
 160
 161         const uint16* utf16 = nameBuffer + (MAX_UTF16_NAME_LENGTH - nameLength);
 162
 163         for (uint32 i = 0; i < nameLength; i++) {
 164                 uint8 utf8[4];
 165                 uint32 count;
 166                 uint16 c = B_LENDIAN_TO_HOST_INT16(utf16[i]);
 167                 if (c < 0x80) {
 168                         utf8[0] = c;
 169                         count = 1;
 170                 } else if (c < 0xff80) {
 171                         utf8[0] = 0xc0 | (c >> 6);
 172                         utf8[1] = 0x80 | (c & 0x3f);
 173                         count = 2;
 174                 } else if ((c & 0xfc00) != 0xd800) {
 175                         utf8[0] = 0xe0 | (c >> 12);
 176                         utf8[1] = 0x80 | ((c >> 6) & 0x3f);
 177                         utf8[2] = 0x80 | (c & 0x3f);
 178                         count = 3;
 179                 } else {
 180                         // surrogate pair
 181                         if (i + 1 >= nameLength)
 182                                 return false;
 183
 184                         uint16 c2 = B_LENDIAN_TO_HOST_INT16(utf16[++i]);
 185                         if ((c2 & 0xfc00) != 0xdc00)
 186                                 return false;
 187
 188                         uint32 value = ((c - 0xd7c0) << 10) | (c2 & 0x3ff);
 189                         utf8[0] = 0xf0 | (value >> 18);
 190                         utf8[1] = 0x80 | ((value >> 12) & 0x3f);
 191                         utf8[2] = 0x80 | ((value >> 6) & 0x3f);
 192                         utf8[3] = 0x80 | (value & 0x3f);
 193                         count = 4;
 194                 }
 195
 196                 if (nameOffset + count >= sizeof(name))
 197                         return false;
 198
 199                 memcpy(name + nameOffset, utf8, count);
 200                 nameOffset += count;
 201         }
 202
 203         name[nameOffset] = '\0';
 204         strlcpy(Name(), name, sizeof(nameBuffer));
 205         return true;
 206 }
 207
 208
 209 void
 210 dir_cookie::Set8_3Name(const char* baseName, const char* extension)
 211 {
 212         // trim base name
 213         uint32 baseNameLength = 8;
 214         while (baseNameLength > 0 && baseName[baseNameLength - 1] == ' ')
 215                 baseNameLength--;
 216
 217         // trim extension
 218         uint32 extensionLength = 3;
 219         while (extensionLength > 0 && extension[extensionLength - 1] == ' ')
 220                 extensionLength--;
 221
 222         // compose the name
 223         char* name = Name();
 224         memcpy(name, baseName, baseNameLength);
 225
 226         if (extensionLength > 0) {
 227                 name[baseNameLength] = '.';
 228                 memcpy(name + baseNameLength + 1, extension, extensionLength);
 229                 name[baseNameLength + 1 + extensionLength] = '\0';
 230         } else
 231                 name[baseNameLength] = '\0';
 232 }
 233
 234
 235 // #pragma mark -
 236
 237
 238 static bool
 239 is_valid_8_3_file_name_char(char c)
 240 {
 241         if ((uint8)c >= 128)
 242                 return true;
 243
 244         if ((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
 245                 return true;
 246
 247         return strchr("*!#$%&'()-@^_`{}~ ", c) != NULL;
 248 }
 249
 250
 251 static bool
 252 check_valid_8_3_file_name(const char* name, const char*& _baseName,
 253         uint32& _baseNameLength, const char*& _extension, uint32& _extensionLength)
 254 {
 255         // check length of base name and extension
 256         size_t nameLength = strlen(name);
 257         const char* extension = strchr(name, '.');
 258         size_t baseNameLength;
 259         size_t extensionLength;
 260         if (extension != NULL) {
 261                 baseNameLength = extension - name;
 262                 extensionLength = nameLength - baseNameLength - 1;
 263                 if (extensionLength > 0)
 264                         extension++;
 265                 else
 266                         extension = NULL;
 267         } else {
 268                 baseNameLength = nameLength;
 269                 extensionLength = 0;
 270         }
 271
 272         // trim trailing space
 273         while (baseNameLength > 0 && name[baseNameLength - 1] == ' ')
 274                 baseNameLength--;
 275         while (extensionLength > 0 && extension[extensionLength - 1] == ' ')
 276                 extensionLength--;
 277
 278         if (baseNameLength == 0 || baseNameLength > 8 || extensionLength > 3)
 279                 return false;
 280
 281         // check the chars
 282         for (size_t i = 0; i < baseNameLength; i++) {
 283                 if (!is_valid_8_3_file_name_char(name[i]))
 284                         return false;
 285         }
 286
 287         for (size_t i = 0; i < extensionLength; i++) {
 288                 if (!is_valid_8_3_file_name_char(extension[i]))
 289                         return false;
 290         }
 291
 292         _baseName = name;
 293         _baseNameLength = baseNameLength;
 294         _extension = extension;
 295         _extensionLength = extensionLength;
 296
 297         return true;
 298 }
 299
 300
 301 // #pragma mark - Directory
 302
 303 Directory::Directory(Volume &volume, off_t dirEntryOffset, uint32 cluster,
 304         const char *name)
 305         :
 306         fVolume(volume),
 307         fStream(volume, cluster, UINT32_MAX, name),
 308         fDirEntryOffset(dirEntryOffset)
 309 {
 310         TRACE(("FASFS::Directory::(, %lu, %s)\n", cluster, name));
 311 }
 312
 313
 314 Directory::~Directory()
 315 {
 316         TRACE(("FASFS::Directory::~()\n"));
 317 }
 318
 319
 320 status_t
 321 Directory::InitCheck()
 322 {
 323         status_t err;
 324         err = fStream.InitCheck();
 325         if (err < B_OK)
 326                 return err;
 327         return B_OK;
 328 }
 329
 330
 331 status_t
 332 Directory::Open(void **_cookie, int mode)
 333 {
 334         TRACE(("FASFS::Directory::%s(, %d)\n", __FUNCTION__, mode));
 335         _inherited::Open(_cookie, mode);
 336
 337         dir_cookie *c = new(nothrow) dir_cookie;
 338         if (c == NULL)
 339                 return B_NO_MEMORY;
 340
 341         c->index = -1;
 342         c->entryOffset = 0;
 343
 344         *_cookie = (void *)c;
 345         return B_OK;
 346 }
 347
 348
 349 status_t
 350 Directory::Close(void *cookie)
 351 {
 352         TRACE(("FASFS::Directory::%s()\n", __FUNCTION__));
 353         _inherited::Close(cookie);
 354
 355         delete (struct dir_cookie *)cookie;
 356         return B_OK;
 357 }
 358
 359
 360 Node*
 361 Directory::LookupDontTraverse(const char* name)
 362 {
 363         TRACE(("FASFS::Directory::%s('%s')\n", __FUNCTION__, name));
 364         if (!strcmp(name, ".")) {
 365                 Acquire();
 366                 return this;
 367         }
 368
 369         status_t err;
 370         struct dir_cookie cookie;
 371         struct dir_cookie *c = &cookie;
 372         c->index = -1;
 373         c->entryOffset = 0;
 374
 375         do {
 376                 err = GetNextEntry(c);
 377                 if (err < B_OK)
 378                         return NULL;
 379                 TRACE(("FASFS::Directory::%s: %s <> '%s'\n", __FUNCTION__,
 380                         name, c->Name()));
 381                 if (strcasecmp(name, c->Name()) == 0) {
 382                         TRACE(("GOT IT!\n"));
 383                         break;
 384                 }
 385         } while (true);
 386
 387         if (c->entry.IsFile()) {
 388                 TRACE(("IS FILE\n"));
 389                 return new File(fVolume, c->entryOffset,
 390                         c->entry.Cluster(fVolume.FatBits()), c->entry.Size(), name);
 391         }
 392         if (c->entry.IsDir()) {
 393                 TRACE(("IS DIR\n"));
 394                 return new Directory(fVolume, c->entryOffset,
 395                         c->entry.Cluster(fVolume.FatBits()), name);
 396         }
 397         return NULL;
 398 }
 399
 400
 401 status_t
 402 Directory::GetNextEntry(void *cookie, char *name, size_t size)
 403 {
 404         TRACE(("FASFS::Directory::%s()\n", __FUNCTION__));
 405         struct dir_cookie *c = (struct dir_cookie *)cookie;
 406         status_t err;
 407
 408         err = GetNextEntry(cookie);
 409         if (err < B_OK)
 410                 return err;
 411
 412         strlcpy(name, c->Name(), size);
 413         return B_OK;
 414 }
 415
 416
 417 status_t
 418 Directory::GetNextNode(void *cookie, Node **_node)
 419 {
 420         return B_ERROR;
 421 }
 422
 423
 424 status_t
 425 Directory::Rewind(void *cookie)
 426 {
 427         TRACE(("FASFS::Directory::%s()\n", __FUNCTION__));
 428         struct dir_cookie *c = (struct dir_cookie *)cookie;
 429         c->index = -1;
 430         c->entryOffset = 0;
 431
 432         return B_OK;
 433 }
 434
 435
 436 bool
 437 Directory::IsEmpty()
 438 {
 439         TRACE(("FASFS::Directory::%s()\n", __FUNCTION__));
 440         struct dir_cookie cookie;
 441         struct dir_cookie *c = &cookie;
 442         c->index = -1;
 443         c->entryOffset = 0;
 444         if (GetNextEntry(c) == B_OK)
 445                 return false;
 446         return true;
 447 }
 448
 449
 450 status_t
 451 Directory::GetName(char *name, size_t size) const
 452 {
 453         TRACE(("FASFS::Directory::%s()\n", __FUNCTION__));
 454         if (this == fVolume.Root())
 455                 return fVolume.GetName(name, size);
 456         return fStream.GetName(name, size);
 457 }
 458
 459
 460 ino_t
 461 Directory::Inode() const
 462 {
 463         TRACE(("FASFS::Directory::%s()\n", __FUNCTION__));
 464         return fStream.FirstCluster() << 16;
 465 }
 466
 467
 468 status_t
 469 Directory::CreateFile(const char* name, mode_t permissions, Node** _node)
 470 {
 471         if (Node* node = Lookup(name, false)) {
 472                 node->Release();
 473                 return B_FILE_EXISTS;
 474         }
 475
 476         // We only support 8.3 file names ATM.
 477         const char* baseName;
 478         const char* extension;
 479         uint32 baseNameLength;
 480         uint32 extensionLength;
 481         if (!check_valid_8_3_file_name(name, baseName, baseNameLength, extension,
 482                         extensionLength)) {
 483                 return B_UNSUPPORTED;
 484         }
 485
 486         // prepare a directory entry for the new file
 487         dir_entry entry;
 488
 489         memset(entry.fName, ' ', sizeof(entry.fName));
 490         memset(entry.fExt, ' ', sizeof(entry.fExt));
 491                 // clear both base name and extension
 492         memcpy(entry.fName, baseName, baseNameLength);
 493         if (extensionLength > 0)
 494                 memcpy(entry.fExt, extension, extensionLength);
 495
 496         entry.fFlags = 0;
 497         entry.fReserved1 = 0;
 498         entry.fCreateTime10ms = 199;
 499         entry.fCreateTime = B_HOST_TO_LENDIAN_INT16((23 << 11) | (59 << 5) | 29);
 500                 // 23:59:59.9
 501         entry.fCreateDate = B_HOST_TO_LENDIAN_INT16((127 << 9) | (12 << 5) | 31);
 502                 // 2107-12-31
 503         entry.fAccessDate = entry.fCreateDate;
 504         entry.fClusterMSB = 0;
 505         entry.fModifiedTime = entry.fCreateTime;
 506         entry.fModifiedDate = entry.fCreateDate;
 507         entry.fClusterLSB = 0;
 508         entry.fSize = 0;
 509
 510         // add the entry to the directory
 511         off_t entryOffset;
 512         status_t error = _AddEntry(entry, entryOffset);
 513         if (error != B_OK)
 514                 return error;
 515
 516         // create a File object
 517         File* file = new(nothrow) File(fVolume, entryOffset,
 518                 entry.Cluster(fVolume.FatBits()), entry.Size(), name);
 519         if (file == NULL)
 520                 return B_NO_MEMORY;
 521
 522         *_node = file;
 523         return B_OK;
 524 }
 525
 526
 527 /*static*/ status_t
 528 Directory::UpdateDirEntry(Volume& volume, off_t dirEntryOffset,
 529         uint32 firstCluster, uint32 size)
 530 {
 531         if (dirEntryOffset == 0)
 532                 return B_BAD_VALUE;
 533
 534         CachedBlock cachedBlock(volume);
 535         off_t block = volume.ToBlock(dirEntryOffset);
 536
 537         status_t error = cachedBlock.SetTo(block, CachedBlock::READ);
 538         if (error != B_OK)
 539                 return error;
 540
 541         dir_entry* entry = (dir_entry*)(cachedBlock.Block()
 542                 + dirEntryOffset % volume.BlockSize());
 543
 544         entry->SetCluster(firstCluster, volume.FatBits());
 545         entry->SetSize(size);
 546
 547         return cachedBlock.Flush();
 548 }
 549
 550
 551 status_t
 552 Directory::GetNextEntry(void *cookie, uint8 mask, uint8 match)
 553 {
 554         TRACE(("FASFS::Directory::%s(, %02x, %02x)\n", __FUNCTION__, mask, match));
 555         struct dir_cookie *c = (struct dir_cookie *)cookie;
 556
 557         bool hasLongName = false;
 558         bool longNameValid = false;
 559
 560         do {
 561                 c->index++;
 562                 size_t len = sizeof(c->entry);
 563                 if (fStream.ReadAt(c->Offset(), (uint8 *)&c->entry, &len,
 564                                 &c->entryOffset) != B_OK || len != sizeof(c->entry)) {
 565                         return B_ENTRY_NOT_FOUND;
 566                 }
 567
 568                 TRACE(("FASFS::Directory::%s: got one entry\n", __FUNCTION__));
 569                 if ((uint8)c->entry.fName[0] == 0x00) // last one
 570                         return B_ENTRY_NOT_FOUND;
 571                 if ((uint8)c->entry.fName[0] == 0xe5) // deleted
 572                         continue;
 573                 if (c->entry.Flags() == 0x0f) { // LFN entry
 574                         uint8* nameEntry = (uint8*)&c->entry;
 575                         if ((*nameEntry & 0x40) != 0) {
 576                                 c->ResetName();
 577                                 hasLongName = true;
 578                                 longNameValid = true;
 579                         }
 580
 581                         uint16 nameChars[13];
 582                         memcpy(nameChars, nameEntry + 0x01, 10);
 583                         memcpy(nameChars + 5, nameEntry + 0x0e, 12);
 584                         memcpy(nameChars + 11, nameEntry + 0x1c, 4);
 585                         longNameValid |= c->AddNameChars(nameChars, 13);
 586                         continue;
 587                 }
 588                 if ((c->entry.Flags() & (FAT_VOLUME|FAT_SUBDIR)) == FAT_VOLUME) {
 589                         // TODO handle Volume name (set fVolume's name)
 590                         continue;
 591                 }
 592                 TRACE(("FASFS::Directory::%s: checking '%8.8s.%3.3s', %02x\n", __FUNCTION__,
 593                         c->entry.BaseName(), c->entry.Extension(), c->entry.Flags()));
 594                 if ((c->entry.Flags() & mask) == match) {
 595                         if (longNameValid)
 596                                 longNameValid = c->ConvertNameToUTF8();
 597                         if (!longNameValid) {
 598                                 // copy 8.3 name to name buffer
 599                                 c->Set8_3Name(c->entry.BaseName(), c->entry.Extension());
 600                         }
 601                         break;
 602                 }
 603         } while (true);
 604         TRACE(("FATFS::Directory::%s: '%8.8s.%3.3s'\n", __FUNCTION__,
 605                 c->entry.BaseName(), c->entry.Extension()));
 606         return B_OK;
 607 }
 608
 609
 610 status_t
 611 Directory::_AddEntry(dir_entry& entry, off_t& _entryOffset)
 612 {
 613         off_t dirSize = _GetStreamSize();
 614         if (dirSize < 0)
 615                 return dirSize;
 616
 617         uint32 firstCluster = fStream.FirstCluster();
 618
 619         // First null-terminate the new entry list, so we don't leave the list in
 620         // a broken state, if writing the actual entry fails. We only need to do
 621         // that when the entry is not at the end of a cluster.
 622         if ((dirSize + sizeof(entry)) % fVolume.ClusterSize() != 0) {
 623                 // TODO: Rather zero the complete remainder of the cluster?
 624                 size_t size = 1;
 625                 char terminator = 0;
 626                 status_t error = fStream.WriteAt(dirSize + sizeof(entry), &terminator,
 627                         &size);
 628                 if (error != B_OK)
 629                         return error;
 630                 if (size != 1)
 631                         return B_ERROR;
 632         }
 633
 634         // write the entry
 635         size_t size = sizeof(entry);
 636         status_t error = fStream.WriteAt(dirSize, &entry, &size, &_entryOffset);
 637         if (error != B_OK)
 638                 return error;
 639         if (size != sizeof(entry))
 640                 return B_ERROR;
 641                 // TODO: Undo changes!
 642
 643         fStream.SetSize(dirSize + sizeof(entry));
 644
 645         // If the directory cluster has changed (which should only happen, if the
 646         // directory was empty before), we need to adjust the directory entry.
 647         if (firstCluster != fStream.FirstCluster()) {
 648                 error = UpdateDirEntry(fVolume, fDirEntryOffset, fStream.FirstCluster(),
 649                         0);
 650                 if (error != B_OK)
 651                         return error;
 652                         // TODO: Undo changes!
 653         }
 654
 655         return B_OK;
 656 }
 657
 658
 659 off_t
 660 Directory::_GetStreamSize()
 661 {
 662         off_t size = fStream.Size();
 663         if (size != UINT32_MAX)
 664                 return size;
 665
 666         // iterate to the end of the directory
 667         size = 0;
 668         while (true) {
 669                 dir_entry entry;
 670                 size_t entrySize = sizeof(entry);
 671                 status_t error = fStream.ReadAt(size, &entry, &entrySize);
 672                 if (error != B_OK)
 673                         return error;
 674
 675                 if (entrySize != sizeof(entry) || entry.fName[0] == 0)
 676                         break;
 677
 678                 size += sizeof(entry);
 679         }
 680
 681         fStream.SetSize(size);
 682         return size;
 683 }
 684
 685
 686 }       // namespace FATFS