1//---------------------------------------------------------------------- 2// This software is part of the OpenBeOS distribution and is covered 3// by the OpenBeOS license. 4// 5// Copyright (c) 2003 Tyler Dauwalder, tyler@dauwalder.net 6//---------------------------------------------------------------------- 7 8/*! \file UdfBuilder.cpp 9 10 Main UDF image building class implementation. 11*/ 12 13#include "UdfBuilder.h" 14 15#include <Directory.h> 16#include <Entry.h> 17#include <Node.h> 18#include <OS.h> 19#include <Path.h> 20#include <stdio.h> 21#include <string> 22#include <sys/stat.h> 23 24#include "DString.h" 25#include "ExtentStream.h" 26#include "MemoryChunk.h" 27#include "UdfDebug.h" 28#include "Utils.h" 29 30using Udf::bool_to_string; 31using Udf::check_size_error; 32 33//! Application identifier entity_id 34static const Udf::entity_id kApplicationId(0, "*OpenBeOS makeudfimage"); 35 36static const Udf::logical_block_address kNullLogicalBlock(0, 0); 37static const Udf::extent_address kNullExtent(0, 0); 38static const Udf::long_address kNullAddress(0, 0, 0, 0); 39 40/*! \brief Returns the number of the block in which the byte offset specified 41 by \a pos resides in the data space specified by the extents in \a dataSpace. 42 43 Used to figure out the value for Udf::file_id_descriptor::tag::location fields. 44 45 \param block Output parameter into which the block number of interest is stored. 46*/ 47static 48status_t 49block_for_offset(off_t pos, std::list<Udf::long_address> &dataSpace, uint32 blockSize, 50 uint32 &block) 51{ 52 status_t error = pos >= 0 ? B_OK : B_BAD_VALUE; 53 if (!error) { 54 off_t streamPos = 0; 55 for (std::list<Udf::long_address>::const_iterator i = dataSpace.begin(); 56 i != dataSpace.end(); 57 i++) 58 { 59 if (streamPos <= pos && pos < streamPos+i->length()) { 60 // Found it 61 off_t difference = pos - streamPos; 62 block = i->block() + difference / blockSize; 63 return B_OK; 64 } else { 65 streamPos += i->length(); 66 } 67 } 68 // Didn't find it, so pos is past the end of the data space 69 error = B_ERROR; 70 } 71 return error; 72} 73 74/*! \brief Creates a new UdfBuilder object. 75 76 \param udfRevision The UDF revision to write, formatted as in the UDF 77 domain id suffix, i.e. UDF 2.50 is represented by 0x0250. 78*/ 79UdfBuilder::UdfBuilder(const char *outputFile, uint32 blockSize, bool doUdf, 80 const char *udfVolumeName, uint16 udfRevision, bool doIso, 81 const char *isoVolumeName, const char *rootDirectory, 82 const ProgressListener &listener, bool truncate) 83 : fInitStatus(B_NO_INIT) 84 , fOutputFile(outputFile, B_READ_WRITE | B_CREATE_FILE | (truncate ? B_ERASE_FILE : 0)) 85 , fOutputFilename(outputFile) 86 , fBlockSize(blockSize) 87 , fBlockShift(0) 88 , fDoUdf(doUdf) 89 , fUdfVolumeName(udfVolumeName) 90 , fUdfRevision(udfRevision) 91 , fUdfDescriptorVersion(udfRevision <= 0x0150 ? 2 : 3) 92 , fUdfDomainId(udfRevision == 0x0150 ? Udf::kDomainId150 : Udf::kDomainId201) 93 , fDoIso(doIso) 94 , fIsoVolumeName(isoVolumeName) 95 , fRootDirectory(rootDirectory ? rootDirectory : "") 96 , fRootDirectoryName(rootDirectory) 97 , fListener(listener) 98 , fAllocator(blockSize) 99 , fPartitionAllocator(0, 257, fAllocator) 100 , fStatistics() 101 , fBuildTime(0) // set at start of Build() 102 , fBuildTimeStamp() // ditto 103 , fNextUniqueId(16) // Starts at 16 thanks to MacOS... See UDF-2.50 3.2.1 104 , f32BitIdsNoLongerUnique(false) // Set to true once fNextUniqueId requires > 32bits 105{ 106 DEBUG_INIT_ETC("UdfBuilder", ("blockSize: %ld, doUdf: %s, doIso: %s", 107 blockSize, bool_to_string(doUdf), bool_to_string(doIso))); 108 109 // Check the output file 110 status_t error = _OutputFile().InitCheck(); 111 if (error) { 112 _PrintError("Error opening output file: 0x%lx, `%s'", error, 113 strerror(error)); 114 } 115 // Check the allocator 116 if (!error) { 117 error = _Allocator().InitCheck(); 118 if (error) { 119 _PrintError("Error creating block allocator: 0x%lx, `%s'", error, 120 strerror(error)); 121 } 122 } 123 // Check the block size 124 if (!error) { 125 error = Udf::get_block_shift(_BlockSize(), fBlockShift); 126 if (!error) 127 error = _BlockSize() >= 512 ? B_OK : B_BAD_VALUE; 128 if (error) 129 _PrintError("Invalid block size: %ld", blockSize); 130 } 131 // Check that at least one type of filesystem has 132 // been requested 133 if (!error) { 134 error = _DoUdf() || _DoIso() ? B_OK : B_BAD_VALUE; 135 if (error) 136 _PrintError("No filesystems requested."); 137 } 138 // Check the volume names 139 if (!error) { 140 if (_UdfVolumeName().Utf8Length() == 0) 141 _UdfVolumeName().SetTo("(Unnamed UDF Volume)"); 142 if (_IsoVolumeName().Utf8Length() == 0) 143 _IsoVolumeName().SetTo("UNNAMED_ISO"); 144 if (_DoUdf()) { 145 error = _UdfVolumeName().Cs0Length() <= 128 ? B_OK : B_ERROR; 146 if (error) { 147 _PrintError("Udf volume name too long (%ld bytes, max " 148 "length is 128 bytes.", 149 _UdfVolumeName().Cs0Length()); 150 } 151 } 152 if (!error && _DoIso()) { 153 error = _IsoVolumeName().Utf8Length() <= 32 ? B_OK : B_ERROR; 154 // ToDo: Should also check for illegal characters 155 if (error) { 156 _PrintError("Iso volume name too long (%ld bytes, max " 157 "length is 32 bytes.", 158 _IsoVolumeName().Cs0Length()); 159 } 160 } 161 } 162 // Check the udf revision 163 if (!error) { 164 error = _UdfRevision() == 0x0150 || _UdfRevision() == 0x0201 165 ? B_OK : B_ERROR; 166 if (error) { 167 _PrintError("Invalid UDF revision 0x%04x", _UdfRevision()); 168 } 169 } 170 // Check the root directory 171 if (!error) { 172 error = _RootDirectory().InitCheck(); 173 if (error) { 174 _PrintError("Error initializing root directory entry: 0x%lx, `%s'", 175 error, strerror(error)); 176 } 177 } 178 179 if (!error) { 180 fInitStatus = B_OK; 181 } 182} 183 184status_t 185UdfBuilder::InitCheck() const 186{ 187 return fInitStatus; 188} 189 190/*! \brief Builds the disc image. 191*/ 192status_t 193UdfBuilder::Build() 194{ 195 DEBUG_INIT("UdfBuilder"); 196 status_t error = InitCheck(); 197 if (error) 198 RETURN(error); 199 200 // Note the time at which we're starting 201 fStatistics.Reset(); 202 _SetBuildTime(_Stats().StartTime()); 203 204 // Udf variables 205 uint16 partitionNumber = 0; 206 Udf::anchor_volume_descriptor anchor256; 207 Udf::anchor_volume_descriptor anchorN; 208 Udf::extent_address primaryVdsExtent; 209 Udf::extent_address reserveVdsExtent; 210 Udf::primary_volume_descriptor primary; 211 Udf::partition_descriptor partition; 212 Udf::unallocated_space_descriptor freespace; 213 Udf::logical_volume_descriptor logical; 214 Udf::implementation_use_descriptor implementationUse; 215 Udf::long_address filesetAddress; 216 Udf::extent_address filesetExtent; 217 Udf::extent_address integrityExtent; 218 Udf::file_set_descriptor fileset; 219 node_data rootNode; 220 221 // Iso variables 222// Udf::extent_address rootDirentExtent; 223 224 225 _OutputFile().Seek(0, SEEK_SET); 226 fListener.OnStart(fRootDirectoryName.c_str(), fOutputFilename.c_str(), 227 _UdfVolumeName().Utf8(), _UdfRevision()); 228 229 _PrintUpdate(VERBOSITY_LOW, "Initializing volume"); 230 231 // Reserve the first 32KB and zero them out. 232 if (!error) { 233 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing reserved area"); 234 const int reservedAreaSize = 32 * 1024; 235 Udf::extent_address extent(0, reservedAreaSize); 236 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for reserved area"); 237 error = _Allocator().GetExtent(extent); 238 if (!error) { 239 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 240 extent.location(), extent.length()); 241 ssize_t bytes = _OutputFile().Zero(reservedAreaSize); 242 error = check_size_error(bytes, reservedAreaSize); 243 } 244 // Error check 245 if (error) { 246 _PrintError("Error creating reserved area: 0x%lx, `%s'", 247 error, strerror(error)); 248 } 249 } 250 251 const int vrsBlockSize = 2048; 252 253 // Write the iso portion of the vrs 254 if (!error && _DoIso()) { 255 _PrintUpdate(VERBOSITY_MEDIUM, "iso: Writing primary volume descriptor"); 256 257 // Error check 258 if (error) { 259 _PrintError("Error writing iso vrs: 0x%lx, `%s'", 260 error, strerror(error)); 261 } 262 } 263 264 // Write the udf portion of the vrs 265 if (!error && _DoUdf()) { 266 Udf::extent_address extent; 267 // Bea 268 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing bea descriptor"); 269 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for bea descriptor"); 270 Udf::volume_structure_descriptor_header bea(0, Udf::kVSDID_BEA, 1); 271 error = _Allocator().GetNextExtent(vrsBlockSize, true, extent); 272 if (!error) { 273 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 274 extent.location(), extent.length()); 275 ssize_t bytes = _OutputFile().Write(&bea, sizeof(bea)); 276 error = check_size_error(bytes, sizeof(bea)); 277 if (!error) { 278 bytes = _OutputFile().Zero(vrsBlockSize-sizeof(bea)); 279 error = check_size_error(bytes, vrsBlockSize-sizeof(bea)); 280 } 281 } 282 // Nsr 283 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing nsr descriptor"); 284 Udf::volume_structure_descriptor_header nsr(0, _UdfRevision() <= 0x0150 285 ? Udf::kVSDID_ECMA167_2 286 : Udf::kVSDID_ECMA167_3, 287 1); 288 if (!error) { 289 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for nsr descriptor"); 290 _Allocator().GetNextExtent(vrsBlockSize, true, extent); 291 } 292 if (!error) { 293 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 294 extent.location(), extent.length()); 295 ssize_t bytes = _OutputFile().Write(&nsr, sizeof(nsr)); 296 error = check_size_error(bytes, sizeof(nsr)); 297 if (!error) { 298 bytes = _OutputFile().Zero(vrsBlockSize-sizeof(nsr)); 299 error = check_size_error(bytes, vrsBlockSize-sizeof(nsr)); 300 } 301 } 302 // Tea 303 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing tea descriptor"); 304 Udf::volume_structure_descriptor_header tea(0, Udf::kVSDID_TEA, 1); 305 if (!error) { 306 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for tea descriptor"); 307 error = _Allocator().GetNextExtent(vrsBlockSize, true, extent); 308 } 309 if (!error) { 310 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 311 extent.location(), extent.length()); 312 ssize_t bytes = _OutputFile().Write(&tea, sizeof(tea)); 313 error = check_size_error(bytes, sizeof(tea)); 314 if (!error) { 315 bytes = _OutputFile().Zero(vrsBlockSize-sizeof(tea)); 316 error = check_size_error(bytes, vrsBlockSize-sizeof(tea)); 317 } 318 } 319 // Error check 320 if (error) { 321 _PrintError("Error writing udf vrs: 0x%lx, `%s'", 322 error, strerror(error)); 323 } 324 } 325 326 // Write the udf anchor256 and volume descriptor sequences 327 if (!error && _DoUdf()) { 328 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing anchor256"); 329 // reserve anchor256 330 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for anchor256"); 331 error = _Allocator().GetBlock(256); 332 if (!error) 333 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 334 256, _BlockSize()); 335 // reserve primary vds (min length = 16 blocks, which is plenty for us) 336 if (!error) { 337 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for primary vds"); 338 error = _Allocator().GetNextExtent(off_t(16) << _BlockShift(), true, primaryVdsExtent); 339 if (!error) { 340 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 341 primaryVdsExtent.location(), primaryVdsExtent.length()); 342 ssize_t bytes = _OutputFile().ZeroAt(off_t(primaryVdsExtent.location()) << _BlockShift(), 343 primaryVdsExtent.length()); 344 error = check_size_error(bytes, primaryVdsExtent.length()); 345 } 346 } 347 // reserve reserve vds. try to grab the 16 blocks preceding block 256. if 348 // that fails, just grab any 16. most commercial discs just put the reserve 349 // vds immediately following the primary vds, which seems a bit stupid to me, 350 // now that I think about it... 351 if (!error) { 352 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for reserve vds"); 353 reserveVdsExtent.set_location(256-16); 354 reserveVdsExtent.set_length(off_t(16) << _BlockShift()); 355 error = _Allocator().GetExtent(reserveVdsExtent); 356 if (error) 357 error = _Allocator().GetNextExtent(off_t(16) << _BlockShift(), true, reserveVdsExtent); 358 if (!error) { 359 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 360 reserveVdsExtent.location(), reserveVdsExtent.length()); 361 ssize_t bytes = _OutputFile().ZeroAt(off_t(reserveVdsExtent.location()) << _BlockShift(), 362 reserveVdsExtent.length()); 363 error = check_size_error(bytes, reserveVdsExtent.length()); 364 } 365 } 366 // write anchor_256 367 if (!error) { 368 anchor256.main_vds() = primaryVdsExtent; 369 anchor256.reserve_vds() = reserveVdsExtent; 370 Udf::descriptor_tag &tag = anchor256.tag(); 371 tag.set_id(Udf::TAGID_ANCHOR_VOLUME_DESCRIPTOR_POINTER); 372 tag.set_version(_UdfDescriptorVersion()); 373 tag.set_serial_number(0); 374 tag.set_location(256); 375 tag.set_checksums(anchor256); 376 _OutputFile().Seek(off_t(256) << _BlockShift(), SEEK_SET); 377 ssize_t bytes = _OutputFile().Write(&anchor256, sizeof(anchor256)); 378 error = check_size_error(bytes, sizeof(anchor256)); 379 if (!error && bytes < ssize_t(_BlockSize())) { 380 bytes = _OutputFile().Zero(_BlockSize()-sizeof(anchor256)); 381 error = check_size_error(bytes, _BlockSize()-sizeof(anchor256)); 382 } 383 } 384 uint32 vdsNumber = 0; 385 // write primary_vd 386 if (!error) { 387 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing primary volume descriptor"); 388 // build primary_vd 389 primary.set_vds_number(vdsNumber); 390 primary.set_primary_volume_descriptor_number(0); 391 uint32 nameLength = _UdfVolumeName().Cs0Length(); 392 if (nameLength > primary.volume_identifier().size()-1) { 393 _PrintWarning("udf: Truncating volume name as stored in primary " 394 "volume descriptor to 31 byte limit. This shouldn't matter, " 395 "as the complete name is %d bytes long, which is short enough " 396 "to fit completely in the logical volume descriptor.", 397 nameLength); 398 } 399 Udf::DString volumeIdField(_UdfVolumeName(), 400 primary.volume_identifier().size()); 401 memcpy(primary.volume_identifier().data, volumeIdField.String(), 402 primary.volume_identifier().size()); 403 primary.set_volume_sequence_number(1); 404 primary.set_max_volume_sequence_number(1); 405 primary.set_interchange_level(2); 406 primary.set_max_interchange_level(3); 407 primary.set_character_set_list(1); 408 primary.set_max_character_set_list(1); 409 // first 16 chars of volume set id must be unique. first 8 must be 410 // a hex representation of a timestamp 411 char timestamp[9]; 412 sprintf(timestamp, "%08lX", _BuildTime()); 413 std::string volumeSetId(timestamp); 414 volumeSetId = volumeSetId + "--------" + "(unnamed volume set)"; 415 Udf::DString volumeSetIdField(volumeSetId.c_str(), 416 primary.volume_set_identifier().size()); 417 memcpy(primary.volume_set_identifier().data, volumeSetIdField.String(), 418 primary.volume_set_identifier().size()); 419 primary.descriptor_character_set() = Udf::kCs0CharacterSet; 420 primary.explanatory_character_set() = Udf::kCs0CharacterSet; 421 primary.volume_abstract() = kNullExtent; 422 primary.volume_copyright_notice() = kNullExtent; 423 primary.application_id() = kApplicationId; 424 primary.recording_date_and_time() = _BuildTimeStamp(); 425 primary.implementation_id() = Udf::kImplementationId; 426 memset(primary.implementation_use().data, 0, 427 primary.implementation_use().size()); 428 primary.set_predecessor_volume_descriptor_sequence_location(0); 429 primary.set_flags(0); // ToDo: maybe 1 is more appropriate? 430 memset(primary.reserved().data, 0, primary.reserved().size()); 431 primary.tag().set_id(Udf::TAGID_PRIMARY_VOLUME_DESCRIPTOR); 432 primary.tag().set_version(_UdfDescriptorVersion()); 433 primary.tag().set_serial_number(0); 434 // note that the checksums haven't been set yet, since the 435 // location is dependent on which sequence (primary or reserve) 436 // the descriptor is currently being written to. Thus we have to 437 // recalculate the checksums for each sequence. 438 DUMP(primary); 439 // write primary_vd to primary vds 440 primary.tag().set_location(primaryVdsExtent.location()+vdsNumber); 441 primary.tag().set_checksums(primary); 442 ssize_t bytes = _OutputFile().WriteAt(off_t(primary.tag().location()) << _BlockShift(), 443 &primary, sizeof(primary)); 444 error = check_size_error(bytes, sizeof(primary)); 445 if (!error && bytes < ssize_t(_BlockSize())) { 446 ssize_t bytesLeft = _BlockSize() - bytes; 447 bytes = _OutputFile().ZeroAt((off_t(primary.tag().location()) << _BlockShift()) 448 + bytes, bytesLeft); 449 error = check_size_error(bytes, bytesLeft); 450 } 451 // write primary_vd to reserve vds 452 if (!error) { 453 primary.tag().set_location(reserveVdsExtent.location()+vdsNumber); 454 primary.tag().set_checksums(primary); 455 ssize_t bytes = _OutputFile().WriteAt(off_t(primary.tag().location()) << _BlockShift(), 456 &primary, sizeof(primary)); 457 error = check_size_error(bytes, sizeof(primary)); 458 if (!error && bytes < ssize_t(_BlockSize())) { 459 ssize_t bytesLeft = _BlockSize() - bytes; 460 bytes = _OutputFile().ZeroAt(off_t((primary.tag().location()) << _BlockShift()) 461 + bytes, bytesLeft); 462 error = check_size_error(bytes, bytesLeft); 463 } 464 } 465 } 466 467 // write partition descriptor 468 if (!error) { 469 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing partition descriptor"); 470 // build partition descriptor 471 vdsNumber++; 472 partition.set_vds_number(vdsNumber); 473 partition.set_partition_flags(1); 474 partition.set_partition_number(partitionNumber); 475 partition.partition_contents() = _UdfRevision() <= 0x0150 476 ? Udf::kPartitionContentsId1xx 477 : Udf::kPartitionContentsId2xx; 478 memset(partition.partition_contents_use().data, 0, 479 partition.partition_contents_use().size()); 480 partition.set_access_type(Udf::ACCESS_READ_ONLY); 481 partition.set_start(_Allocator().Tail()); 482 partition.set_length(0); 483 // Can't set the length till we've built most of rest of the image, 484 // so we'll set it to 0 now and fix it once we know how big 485 // the partition really is. 486 partition.implementation_id() = Udf::kImplementationId; 487 memset(partition.implementation_use().data, 0, 488 partition.implementation_use().size()); 489 memset(partition.reserved().data, 0, 490 partition.reserved().size()); 491 partition.tag().set_id(Udf::TAGID_PARTITION_DESCRIPTOR); 492 partition.tag().set_version(_UdfDescriptorVersion()); 493 partition.tag().set_serial_number(0); 494 // note that the checksums haven't been set yet, since the 495 // location is dependent on which sequence (primary or reserve) 496 // the descriptor is currently being written to. Thus we have to 497 // recalculate the checksums for each sequence. 498 DUMP(partition); 499 // write partition descriptor to primary vds 500 partition.tag().set_location(primaryVdsExtent.location()+vdsNumber); 501 partition.tag().set_checksums(partition); 502 ssize_t bytes = _OutputFile().WriteAt(off_t(partition.tag().location()) << _BlockShift(), 503 &partition, sizeof(partition)); 504 error = check_size_error(bytes, sizeof(partition)); 505 if (!error && bytes < ssize_t(_BlockSize())) { 506 ssize_t bytesLeft = _BlockSize() - bytes; 507 bytes = _OutputFile().ZeroAt((off_t(partition.tag().location()) << _BlockShift()) 508 + bytes, bytesLeft); 509 error = check_size_error(bytes, bytesLeft); 510 } 511 // write partition descriptor to reserve vds 512 if (!error) { 513 partition.tag().set_location(reserveVdsExtent.location()+vdsNumber); 514 partition.tag().set_checksums(partition); 515 ssize_t bytes = _OutputFile().WriteAt(off_t(partition.tag().location()) << _BlockShift(), 516 &partition, sizeof(partition)); 517 error = check_size_error(bytes, sizeof(partition)); 518 if (!error && bytes < ssize_t(_BlockSize())) { 519 ssize_t bytesLeft = _BlockSize() - bytes; 520 bytes = _OutputFile().ZeroAt((off_t(partition.tag().location()) << _BlockShift()) 521 + bytes, bytesLeft); 522 error = check_size_error(bytes, bytesLeft); 523 } 524 } 525 } 526 527 // write unallocated space descriptor 528 if (!error) { 529 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing unallocated space descriptor"); 530 // build freespace descriptor 531 vdsNumber++; 532 freespace.set_vds_number(vdsNumber); 533 freespace.set_allocation_descriptor_count(0); 534 freespace.tag().set_id(Udf::TAGID_UNALLOCATED_SPACE_DESCRIPTOR); 535 freespace.tag().set_version(_UdfDescriptorVersion()); 536 freespace.tag().set_serial_number(0); 537 // note that the checksums haven't been set yet, since the 538 // location is dependent on which sequence (primary or reserve) 539 // the descriptor is currently being written to. Thus we have to 540 // recalculate the checksums for each sequence. 541 DUMP(freespace); 542 // write freespace descriptor to primary vds 543 freespace.tag().set_location(primaryVdsExtent.location()+vdsNumber); 544 freespace.tag().set_checksums(freespace); 545 ssize_t bytes = _OutputFile().WriteAt(off_t(freespace.tag().location()) << _BlockShift(), 546 &freespace, sizeof(freespace)); 547 error = check_size_error(bytes, sizeof(freespace)); 548 if (!error && bytes < ssize_t(_BlockSize())) { 549 ssize_t bytesLeft = _BlockSize() - bytes; 550 bytes = _OutputFile().ZeroAt((off_t(freespace.tag().location()) << _BlockShift()) 551 + bytes, bytesLeft); 552 error = check_size_error(bytes, bytesLeft); 553 } 554 // write freespace descriptor to reserve vds 555 if (!error) { 556 freespace.tag().set_location(reserveVdsExtent.location()+vdsNumber); 557 freespace.tag().set_checksums(freespace); 558 ssize_t bytes = _OutputFile().WriteAt(off_t(freespace.tag().location()) << _BlockShift(), 559 &freespace, sizeof(freespace)); 560 error = check_size_error(bytes, sizeof(freespace)); 561 if (!error && bytes < ssize_t(_BlockSize())) { 562 ssize_t bytesLeft = _BlockSize() - bytes; 563 bytes = _OutputFile().ZeroAt((off_t(freespace.tag().location()) << _BlockShift()) 564 + bytes, bytesLeft); 565 error = check_size_error(bytes, bytesLeft); 566 } 567 } 568 } 569 570 // write logical_vd 571 if (!error) { 572 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing logical volume descriptor"); 573 // build logical_vd 574 vdsNumber++; 575 logical.set_vds_number(vdsNumber); 576 logical.character_set() = Udf::kCs0CharacterSet; 577 error = (_UdfVolumeName().Cs0Length() <= 578 logical.logical_volume_identifier().size()) 579 ? B_OK : B_ERROR; 580 // We check the length in the constructor, so this should never 581 // trigger an error, but just to be safe... 582 if (!error) { 583 Udf::DString volumeIdField(_UdfVolumeName(), 584 logical.logical_volume_identifier().size()); 585 memcpy(logical.logical_volume_identifier().data, volumeIdField.String(), 586 logical.logical_volume_identifier().size()); 587 logical.set_logical_block_size(_BlockSize()); 588 logical.domain_id() = _UdfDomainId(); 589 memset(logical.logical_volume_contents_use().data, 0, 590 logical.logical_volume_contents_use().size()); 591 // Allocate a block for the file set descriptor 592 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for file set descriptor"); 593 error = _PartitionAllocator().GetNextExtent(_BlockSize(), true, 594 filesetAddress, filesetExtent); 595 if (!error) { 596 _PrintUpdate(VERBOSITY_HIGH, "udf: (partition: %d, location: %ld, " 597 "length: %ld) => (location: %ld, length: %ld)", 598 filesetAddress.partition(), filesetAddress.block(), 599 filesetAddress.length(), filesetExtent.location(), 600 filesetExtent.length()); 601 } 602 } 603 if (!error) { 604 logical.file_set_address() = filesetAddress; 605 logical.set_map_table_length(sizeof(Udf::physical_partition_map)); 606 logical.set_partition_map_count(1); 607 logical.implementation_id() = Udf::kImplementationId; 608 memset(logical.implementation_use().data, 0, 609 logical.implementation_use().size()); 610 // Allocate a couple of blocks for the integrity sequence 611 error = _Allocator().GetNextExtent(_BlockSize()*2, true, 612 integrityExtent); 613 } 614 if (!error) { 615 logical.integrity_sequence_extent() = integrityExtent; 616 Udf::physical_partition_map map; 617 map.set_type(1); 618 map.set_length(6); 619 map.set_volume_sequence_number(1); 620 map.set_partition_number(partitionNumber); 621 memcpy(logical.partition_maps(), &map, sizeof(map)); 622 logical.tag().set_id(Udf::TAGID_LOGICAL_VOLUME_DESCRIPTOR); 623 logical.tag().set_version(_UdfDescriptorVersion()); 624 logical.tag().set_serial_number(0); 625 // note that the checksums haven't been set yet, since the 626 // location is dependent on which sequence (primary or reserve) 627 // the descriptor is currently being written to. Thus we have to 628 // recalculate the checksums for each sequence. 629 DUMP(logical); 630 // write partition descriptor to primary vds 631 uint32 logicalSize = Udf::kLogicalVolumeDescriptorBaseSize + sizeof(map); 632 logical.tag().set_location(primaryVdsExtent.location()+vdsNumber); 633 logical.tag().set_checksums(logical, logicalSize); 634 ssize_t bytes = _OutputFile().WriteAt(off_t(logical.tag().location()) << _BlockShift(), 635 &logical, logicalSize); 636 error = check_size_error(bytes, logicalSize); 637 if (!error && bytes < ssize_t(_BlockSize())) { 638 ssize_t bytesLeft = _BlockSize() - bytes; 639 bytes = _OutputFile().ZeroAt((off_t(logical.tag().location()) << _BlockShift()) 640 + bytes, bytesLeft); 641 error = check_size_error(bytes, bytesLeft); 642 } 643 // write logical descriptor to reserve vds 644 if (!error) { 645 logical.tag().set_location(reserveVdsExtent.location()+vdsNumber); 646 logical.tag().set_checksums(logical, logicalSize); 647 ssize_t bytes = _OutputFile().WriteAt(off_t(logical.tag().location()) << _BlockShift(), 648 &logical, sizeof(logical)); 649 error = check_size_error(bytes, sizeof(logical)); 650 if (!error && bytes < ssize_t(_BlockSize())) { 651 ssize_t bytesLeft = _BlockSize() - bytes; 652 bytes = _OutputFile().ZeroAt((off_t(logical.tag().location()) << _BlockShift()) 653 + bytes, bytesLeft); 654 error = check_size_error(bytes, bytesLeft); 655 } 656 } 657 } 658 } 659 660 // write implementation use descriptor 661 if (!error) { 662 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing implementation use descriptor"); 663 // build implementationUse descriptor 664 vdsNumber++; 665 implementationUse.set_vds_number(vdsNumber); 666 switch (_UdfRevision()) { 667 case 0x0150: 668 implementationUse.implementation_id() = Udf::kLogicalVolumeInfoId150; 669 break; 670 case 0x0201: 671 implementationUse.implementation_id() = Udf::kLogicalVolumeInfoId201; 672 break; 673 default: 674 _PrintError("Invalid udf revision: 0x04x", _UdfRevision()); 675 error = B_ERROR; 676 } 677 ssize_t bytes = 0; 678 if (!error) { 679 Udf::logical_volume_info &info = implementationUse.info(); 680 info.character_set() = Udf::kCs0CharacterSet; 681 Udf::DString logicalVolumeId(_UdfVolumeName(), 682 info.logical_volume_id().size()); 683 memcpy(info.logical_volume_id().data, logicalVolumeId.String(), 684 info.logical_volume_id().size()); 685 Udf::DString info1("Logical Volume Info #1", 686 info.logical_volume_info_1().size()); 687 memcpy(info.logical_volume_info_1().data, info1.String(), 688 info.logical_volume_info_1().size()); 689 Udf::DString info2("Logical Volume Info #2", 690 info.logical_volume_info_2().size()); 691 memcpy(info.logical_volume_info_2().data, info2.String(), 692 info.logical_volume_info_2().size()); 693 Udf::DString info3("Logical Volume Info #3", 694 info.logical_volume_info_3().size()); 695 memcpy(info.logical_volume_info_3().data, info3.String(), 696 info.logical_volume_info_3().size()); 697 info.implementation_id() = Udf::kImplementationId; 698 memset(info.implementation_use().data, 0, info.implementation_use().size()); 699 implementationUse.tag().set_id(Udf::TAGID_IMPLEMENTATION_USE_VOLUME_DESCRIPTOR); 700 implementationUse.tag().set_version(_UdfDescriptorVersion()); 701 implementationUse.tag().set_serial_number(0); 702 // note that the checksums haven't been set yet, since the 703 // location is dependent on which sequence (primary or reserve) 704 // the descriptor is currently being written to. Thus we have to 705 // recalculate the checksums for each sequence. 706 DUMP(implementationUse); 707 // write implementationUse descriptor to primary vds 708 implementationUse.tag().set_location(primaryVdsExtent.location()+vdsNumber); 709 implementationUse.tag().set_checksums(implementationUse); 710 bytes = _OutputFile().WriteAt(off_t(implementationUse.tag().location()) << _BlockShift(), 711 &implementationUse, sizeof(implementationUse)); 712 error = check_size_error(bytes, sizeof(implementationUse)); 713 } 714 if (!error && bytes < ssize_t(_BlockSize())) { 715 ssize_t bytesLeft = _BlockSize() - bytes; 716 bytes = _OutputFile().ZeroAt((off_t(implementationUse.tag().location()) << _BlockShift()) 717 + bytes, bytesLeft); 718 error = check_size_error(bytes, bytesLeft); 719 } 720 // write implementationUse descriptor to reserve vds 721 if (!error) { 722 implementationUse.tag().set_location(reserveVdsExtent.location()+vdsNumber); 723 implementationUse.tag().set_checksums(implementationUse); 724 ssize_t bytes = _OutputFile().WriteAt(off_t(implementationUse.tag().location()) << _BlockShift(), 725 &implementationUse, sizeof(implementationUse)); 726 error = check_size_error(bytes, sizeof(implementationUse)); 727 if (!error && bytes < ssize_t(_BlockSize())) { 728 ssize_t bytesLeft = _BlockSize() - bytes; 729 bytes = _OutputFile().ZeroAt((off_t(implementationUse.tag().location()) << _BlockShift()) 730 + bytes, bytesLeft); 731 error = check_size_error(bytes, bytesLeft); 732 } 733 } 734 } 735 736 // write terminating descriptor 737 if (!error) { 738 vdsNumber++; 739 Udf::terminating_descriptor terminator; 740 terminator.tag().set_id(Udf::TAGID_TERMINATING_DESCRIPTOR); 741 terminator.tag().set_version(_UdfDescriptorVersion()); 742 terminator.tag().set_serial_number(0); 743 terminator.tag().set_location(integrityExtent.location()+1); 744 terminator.tag().set_checksums(terminator); 745 DUMP(terminator); 746 // write terminator to primary vds 747 terminator.tag().set_location(primaryVdsExtent.location()+vdsNumber); 748 terminator.tag().set_checksums(terminator); 749 ssize_t bytes = _OutputFile().WriteAt(off_t(terminator.tag().location()) << _BlockShift(), 750 &terminator, sizeof(terminator)); 751 error = check_size_error(bytes, sizeof(terminator)); 752 if (!error && bytes < ssize_t(_BlockSize())) { 753 ssize_t bytesLeft = _BlockSize() - bytes; 754 bytes = _OutputFile().ZeroAt((off_t(terminator.tag().location()) << _BlockShift()) 755 + bytes, bytesLeft); 756 error = check_size_error(bytes, bytesLeft); 757 } 758 // write terminator to reserve vds 759 if (!error) { 760 terminator.tag().set_location(reserveVdsExtent.location()+vdsNumber); 761 terminator.tag().set_checksums(terminator); 762 ssize_t bytes = _OutputFile().WriteAt(off_t(terminator.tag().location()) << _BlockShift(), 763 &terminator, sizeof(terminator)); 764 error = check_size_error(bytes, sizeof(terminator)); 765 if (!error && bytes < ssize_t(_BlockSize())) { 766 ssize_t bytesLeft = _BlockSize() - bytes; 767 bytes = _OutputFile().ZeroAt((off_t(terminator.tag().location()) << _BlockShift()) 768 + bytes, bytesLeft); 769 error = check_size_error(bytes, bytesLeft); 770 } 771 } 772 } 773 774 // Error check 775 if (error) { 776 _PrintError("Error writing udf vds: 0x%lx, `%s'", 777 error, strerror(error)); 778 } 779 } 780 781 // Write the file set descriptor 782 if (!error) { 783 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing file set descriptor"); 784 fileset.recording_date_and_time() = _BuildTimeStamp(); 785 fileset.set_interchange_level(3); 786 fileset.set_max_interchange_level(3); 787 fileset.set_character_set_list(1); 788 fileset.set_max_character_set_list(1); 789 fileset.set_file_set_number(0); 790 fileset.set_file_set_descriptor_number(0); 791 fileset.logical_volume_id_character_set() = Udf::kCs0CharacterSet; 792 Udf::DString volumeIdField(_UdfVolumeName(), 793 fileset.logical_volume_id().size()); 794 memcpy(fileset.logical_volume_id().data, volumeIdField.String(), 795 fileset.logical_volume_id().size()); 796 fileset.file_set_id_character_set() = Udf::kCs0CharacterSet; 797 Udf::DString filesetIdField(_UdfVolumeName(), 798 fileset.file_set_id().size()); 799 memcpy(fileset.file_set_id().data, filesetIdField.String(), 800 fileset.file_set_id().size()); 801 memset(fileset.copyright_file_id().data, 0, 802 fileset.copyright_file_id().size()); 803 memset(fileset.abstract_file_id().data, 0, 804 fileset.abstract_file_id().size()); 805 fileset.root_directory_icb() = kNullAddress; 806 fileset.domain_id() = _UdfDomainId(); 807 fileset.next_extent() = kNullAddress; 808 fileset.system_stream_directory_icb() = kNullAddress; 809 memset(fileset.reserved().data, 0, 810 fileset.reserved().size()); 811 fileset.tag().set_id(Udf::TAGID_FILE_SET_DESCRIPTOR); 812 fileset.tag().set_version(_UdfDescriptorVersion()); 813 fileset.tag().set_serial_number(0); 814 fileset.tag().set_location(filesetAddress.block()); 815 fileset.tag().set_checksums(fileset); 816 DUMP(fileset); 817 // write fsd 818 ssize_t bytes = _OutputFile().WriteAt(off_t(filesetExtent.location()) << _BlockShift(), 819 &fileset, sizeof(fileset)); 820 error = check_size_error(bytes, sizeof(fileset)); 821 if (!error && bytes < ssize_t(_BlockSize())) { 822 ssize_t bytesLeft = _BlockSize() - bytes; 823 bytes = _OutputFile().ZeroAt((off_t(filesetExtent.location()) << _BlockShift()) 824 + bytes, bytesLeft); 825 error = check_size_error(bytes, bytesLeft); 826 } 827 } 828 829 // Build the rest of the image 830 if (!error) { 831 struct stat rootStats; 832 error = _RootDirectory().GetStat(&rootStats); 833 if (!error) 834 error = _ProcessDirectory(_RootDirectory(), "/", rootStats, rootNode, 835 kNullAddress, true); 836 } 837 838 if (!error) 839 _PrintUpdate(VERBOSITY_LOW, "Finalizing volume"); 840 841 // Rewrite the fsd with the root dir icb 842 if (!error) { 843 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Finalizing file set descriptor"); 844 fileset.root_directory_icb() = rootNode.icbAddress; 845 fileset.tag().set_checksums(fileset); 846 DUMP(fileset); 847 // write fsd 848 ssize_t bytes = _OutputFile().WriteAt(off_t(filesetExtent.location()) << _BlockShift(), 849 &fileset, sizeof(fileset)); 850 error = check_size_error(bytes, sizeof(fileset)); 851 if (!error && bytes < ssize_t(_BlockSize())) { 852 ssize_t bytesLeft = _BlockSize() - bytes; 853 bytes = _OutputFile().ZeroAt((off_t(filesetExtent.location()) << _BlockShift()) 854 + bytes, bytesLeft); 855 error = check_size_error(bytes, bytesLeft); 856 } 857 } 858 859 // Set the final partition length and rewrite the partition descriptor 860 if (!error) { 861 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Finalizing partition descriptor"); 862 partition.set_length(_PartitionAllocator().Length()); 863 DUMP(partition); 864 // write partition descriptor to primary vds 865 partition.tag().set_location(primaryVdsExtent.location()+partition.vds_number()); 866 partition.tag().set_checksums(partition); 867 ssize_t bytes = _OutputFile().WriteAt(off_t(partition.tag().location()) << _BlockShift(), 868 &partition, sizeof(partition)); 869 error = check_size_error(bytes, sizeof(partition)); 870 if (!error && bytes < ssize_t(_BlockSize())) { 871 ssize_t bytesLeft = _BlockSize() - bytes; 872 bytes = _OutputFile().ZeroAt((off_t(partition.tag().location()) << _BlockShift()) 873 + bytes, bytesLeft); 874 error = check_size_error(bytes, bytesLeft); 875 } 876 // write partition descriptor to reserve vds 877 if (!error) { 878 partition.tag().set_location(reserveVdsExtent.location()+partition.vds_number()); 879 partition.tag().set_checksums(partition); 880 ssize_t bytes = _OutputFile().WriteAt(off_t(partition.tag().location()) << _BlockShift(), 881 &partition, sizeof(partition)); 882 error = check_size_error(bytes, sizeof(partition)); 883 if (!error && bytes < ssize_t(_BlockSize())) { 884 ssize_t bytesLeft = _BlockSize() - bytes; 885 bytes = _OutputFile().ZeroAt((off_t(partition.tag().location()) << _BlockShift()) 886 + bytes, bytesLeft); 887 error = check_size_error(bytes, bytesLeft); 888 } 889 } 890 // Error check 891 if (error) { 892 _PrintError("Error writing udf vds: 0x%lx, `%s'", 893 error, strerror(error)); 894 } 895 } 896 897 // Write the integrity sequence 898 if (!error && _DoUdf()) { 899 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing logical volume integrity sequence"); 900 Udf::MemoryChunk chunk(_BlockSize()); 901 error = chunk.InitCheck(); 902 // write closed integrity descriptor 903 if (!error) { 904 memset(chunk.Data(), 0, _BlockSize()); 905 Udf::logical_volume_integrity_descriptor *lvid = 906 reinterpret_cast<Udf::logical_volume_integrity_descriptor*>(chunk.Data()); 907 lvid->recording_time() = Udf::timestamp(real_time_clock()); 908 // recording time must be later than all file access times 909 lvid->set_integrity_type(Udf::INTEGRITY_CLOSED); 910 lvid->next_integrity_extent() = kNullExtent; 911 memset(lvid->logical_volume_contents_use().data, 0, 912 lvid->logical_volume_contents_use().size()); 913 lvid->set_next_unique_id(_NextUniqueId()); 914 lvid->set_partition_count(1); 915 lvid->set_implementation_use_length( 916 Udf::logical_volume_integrity_descriptor::minimum_implementation_use_length); 917 lvid->free_space_table()[0] = 0; 918 lvid->size_table()[0] = _PartitionAllocator().Length(); 919 lvid->implementation_id() = Udf::kImplementationId; 920 lvid->set_file_count(_Stats().Files()); 921 lvid->set_directory_count(_Stats().Directories()); 922 lvid->set_minimum_udf_read_revision(_UdfRevision()); 923 lvid->set_minimum_udf_write_revision(_UdfRevision()); 924 lvid->set_maximum_udf_write_revision(_UdfRevision()); 925 lvid->tag().set_id(Udf::TAGID_LOGICAL_VOLUME_INTEGRITY_DESCRIPTOR); 926 lvid->tag().set_version(_UdfDescriptorVersion()); 927 lvid->tag().set_serial_number(0); 928 lvid->tag().set_location(integrityExtent.location()); 929 lvid->tag().set_checksums(*lvid, lvid->descriptor_size()); 930 PDUMP(lvid); 931 // write lvid 932 ssize_t bytes = _OutputFile().WriteAt(off_t(integrityExtent.location()) << _BlockShift(), 933 lvid, _BlockSize()); 934 error = check_size_error(bytes, _BlockSize()); 935 } 936 // write terminating descriptor 937 if (!error) { 938 memset(chunk.Data(), 0, _BlockSize()); 939 Udf::terminating_descriptor *terminator = 940 reinterpret_cast<Udf::terminating_descriptor*>(chunk.Data()); 941 terminator->tag().set_id(Udf::TAGID_TERMINATING_DESCRIPTOR); 942 terminator->tag().set_version(_UdfDescriptorVersion()); 943 terminator->tag().set_serial_number(0); 944 terminator->tag().set_location(integrityExtent.location()+1); 945 terminator->tag().set_checksums(*terminator); 946 PDUMP(terminator); 947 // write terminator 948 ssize_t bytes = _OutputFile().WriteAt(off_t((integrityExtent.location()+1)) << _BlockShift(), 949 terminator, _BlockSize()); 950 error = check_size_error(bytes, _BlockSize()); 951 } 952 } 953 954 // reserve and write anchorN 955 if (!error) { 956 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Writing anchorN"); 957 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserving space for anchorN"); 958 uint32 blockN = _Allocator().Tail(); 959 error = _Allocator().GetBlock(blockN); 960 if (!error) 961 _PrintUpdate(VERBOSITY_HIGH, "udf: (location: %ld, length: %ld)", 962 blockN, _BlockSize()); 963 if (!error) { 964 anchorN.main_vds() = primaryVdsExtent; 965 anchorN.reserve_vds() = reserveVdsExtent; 966 Udf::descriptor_tag &tag = anchorN.tag(); 967 tag.set_id(Udf::TAGID_ANCHOR_VOLUME_DESCRIPTOR_POINTER); 968 tag.set_version(_UdfDescriptorVersion()); 969 tag.set_serial_number(0); 970 tag.set_location(blockN); 971 tag.set_checksums(anchorN); 972 _OutputFile().Seek(off_t(blockN) << _BlockShift(), SEEK_SET); 973 ssize_t bytes = _OutputFile().Write(&anchorN, sizeof(anchorN)); 974 error = check_size_error(bytes, sizeof(anchorN)); 975 if (!error && bytes < ssize_t(_BlockSize())) { 976 bytes = _OutputFile().Zero(_BlockSize()-sizeof(anchorN)); 977 error = check_size_error(bytes, _BlockSize()-sizeof(anchorN)); 978 } 979 } 980 } 981 982 // NOTE: After this point, no more blocks may be allocated without jacking 983 // up anchorN's position as the last block in the volume. So don't allocate 984 // any, damn it. 985 986 // Pad the end of the file to an even multiple of the block 987 // size, if necessary 988 if (!error) { 989 _OutputFile().Seek(0, SEEK_END); 990 uint32 tail = _OutputFile().Position() % _BlockSize(); 991 if (tail > 0) { 992 uint32 padding = _BlockSize() - tail; 993 ssize_t bytes = _OutputFile().Zero(padding); 994 error = check_size_error(bytes, padding); 995 } 996 if (!error) 997 _Stats().SetImageSize(_OutputFile().Position()); 998 } 999 1000 if (!error) { 1001 _PrintUpdate(VERBOSITY_LOW, "Flushing image data"); 1002 _OutputFile().Flush(); 1003 } 1004 1005 fListener.OnCompletion(error, _Stats()); 1006 RETURN(error); 1007} 1008 1009/*! \brief Returns the next unique id, then increments the id (the lower 1010 32-bits of which wrap to 16 instead of 0, per UDF-2.50 3.2.1.1). 1011*/ 1012uint64 1013UdfBuilder::_NextUniqueId() 1014{ 1015 uint64 result = fNextUniqueId++; 1016 if ((fNextUniqueId & 0xffffffff) == 0) { 1017 fNextUniqueId |= 0x10; 1018 f32BitIdsNoLongerUnique = true; 1019 } 1020 return result; 1021} 1022 1023/*! \brief Sets the time at which image building began. 1024*/ 1025void 1026UdfBuilder::_SetBuildTime(time_t time) 1027{ 1028 fBuildTime = time; 1029 Udf::timestamp stamp(time); 1030 fBuildTimeStamp = stamp; 1031} 1032 1033/*! \brief Uses vsprintf() to output the given format string and arguments 1034 into the given message string. 1035 1036 va_start() must be called prior to calling this function to obtain the 1037 \a arguments parameter, but va_end() must *not* be called upon return, 1038 as this function takes the liberty of doing so for you. 1039*/ 1040status_t 1041UdfBuilder::_FormatString(char *message, const char *formatString, va_list arguments) const 1042{ 1043 status_t error = message && formatString ? B_OK : B_BAD_VALUE; 1044 if (!error) { 1045 vsprintf(message, formatString, arguments); 1046 va_end(arguments); 1047 } 1048 return error; 1049} 1050 1051/*! \brief Outputs a printf()-style error message to the listener. 1052*/ 1053void 1054UdfBuilder::_PrintError(const char *formatString, ...) const 1055{ 1056 if (!formatString) { 1057 DEBUG_INIT_ETC("UdfBuilder", ("formatString: `%s'", formatString)); 1058 PRINT(("ERROR: _PrintError() called with NULL format string!\n")); 1059 return; 1060 } 1061 char message[kMaxUpdateStringLength]; 1062 va_list arguments; 1063 va_start(arguments, formatString); 1064 status_t error = _FormatString(message, formatString, arguments); 1065 if (!error) 1066 fListener.OnError(message); 1067} 1068 1069/*! \brief Outputs a printf()-style warning message to the listener. 1070*/ 1071void 1072UdfBuilder::_PrintWarning(const char *formatString, ...) const 1073{ 1074 if (!formatString) { 1075 DEBUG_INIT_ETC("UdfBuilder", ("formatString: `%s'", formatString)); 1076 PRINT(("ERROR: _PrintWarning() called with NULL format string!\n")); 1077 return; 1078 } 1079 char message[kMaxUpdateStringLength]; 1080 va_list arguments; 1081 va_start(arguments, formatString); 1082 status_t error = _FormatString(message, formatString, arguments); 1083 if (!error) 1084 fListener.OnWarning(message); 1085} 1086 1087/*! \brief Outputs a printf()-style update message to the listener 1088 at the given verbosity level. 1089*/ 1090void 1091UdfBuilder::_PrintUpdate(VerbosityLevel level, const char *formatString, ...) const 1092{ 1093 if (!formatString) { 1094 DEBUG_INIT_ETC("UdfBuilder", ("level: %d, formatString: `%s'", 1095 level, formatString)); 1096 PRINT(("ERROR: _PrintUpdate() called with NULL format string!\n")); 1097 return; 1098 } 1099 char message[kMaxUpdateStringLength]; 1100 va_list arguments; 1101 va_start(arguments, formatString); 1102 status_t error = _FormatString(message, formatString, arguments); 1103 if (!error) 1104 fListener.OnUpdate(level, message); 1105} 1106 1107/*! \brief Processes the given directory and its children. 1108 1109 \param entry The directory to process. 1110 \param path Pathname of the directory with respect to the fileset 1111 in construction. 1112 \param node Output parameter into which the icb address and dataspace 1113 information for the processed directory is placed. 1114 \param isRootDirectory Used to signal that the directory being processed 1115 is the root directory, since said directory has 1116 a special unique id assigned to it. 1117*/ 1118status_t 1119UdfBuilder::_ProcessDirectory(BEntry &entry, const char *path, struct stat stats, 1120 node_data &node, Udf::long_address parentIcbAddress, 1121 bool isRootDirectory) 1122{ 1123 DEBUG_INIT_ETC("UdfBuilder", ("path: `%s'", path)); 1124 uint32 udfDataLength = 0; 1125 uint64 udfUniqueId = isRootDirectory ? 0 : _NextUniqueId(); 1126 // file entry id must be numerically lower than unique id's 1127 // in all fids that reference it, thus we allocate it now. 1128 status_t error = entry.InitCheck() == B_OK && path ? B_OK : B_BAD_VALUE; 1129 if (!error) { 1130 _PrintUpdate(VERBOSITY_LOW, "Adding `%s'", path); 1131 BDirectory directory(&entry); 1132 error = directory.InitCheck(); 1133 if (!error) { 1134 1135 // Max length of a udf file identifier Cs0 string 1136 const uint32 maxUdfIdLength = _BlockSize() - (38); 1137 1138 _PrintUpdate(VERBOSITY_MEDIUM, "Gathering statistics"); 1139 1140 // Figure out how many file identifier characters we have 1141 // for each filesystem 1142 uint32 entries = 0; 1143 //uint32 isoChars = 0; 1144 while (error == B_OK) { 1145 BEntry childEntry; 1146 error = directory.GetNextEntry(&childEntry); 1147 if (error == B_ENTRY_NOT_FOUND) { 1148 error = B_OK; 1149 break; 1150 } 1151 if (!error) 1152 error = childEntry.InitCheck(); 1153 if (!error) { 1154 BPath childPath; 1155 error = childEntry.GetPath(&childPath); 1156 if (!error) 1157 error = childPath.InitCheck(); 1158 // Skip symlinks until we add symlink support; this 1159 // allows graceful skipping of them later on instead 1160 // of stopping with a fatal error 1161 struct stat childStats; 1162 if (!error) 1163 error = childEntry.GetStat(&childStats); 1164 if (!error && S_ISLNK(childStats.st_mode)) 1165 continue; 1166 if (!error) { 1167 _PrintUpdate(VERBOSITY_MEDIUM, "found child: `%s'", childPath.Leaf()); 1168 entries++; 1169 // Determine udf char count 1170 Udf::String name(childPath.Leaf()); 1171 uint32 udfLength = name.Cs0Length(); 1172 udfLength = maxUdfIdLength >= udfLength 1173 ? udfLength : maxUdfIdLength; 1174 Udf::file_id_descriptor id; 1175 id.set_id_length(udfLength); 1176 id.set_implementation_use_length(0); 1177 udfDataLength += id.total_length(); 1178 // Determine iso char count 1179 // isoChars += ??? 1180 } 1181 } 1182 } 1183 1184// entries = 0; 1185// udfChars = 0; 1186 1187 // Include parent directory entry in data length calculation 1188 if (!error) { 1189 Udf::file_id_descriptor id; 1190 id.set_id_length(0); 1191 id.set_implementation_use_length(0); 1192 udfDataLength += id.total_length(); 1193 } 1194 1195 _PrintUpdate(VERBOSITY_MEDIUM, "children: %ld", entries); 1196 _PrintUpdate(VERBOSITY_MEDIUM, "udf: data length: %ld", udfDataLength); 1197 1198 // Reserve iso dir entry space 1199 1200 // Reserve udf icb space 1201 Udf::long_address icbAddress; 1202 Udf::extent_address icbExtent; 1203 if (!error && _DoUdf()) { 1204 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Reserving space for icb"); 1205 error = _PartitionAllocator().GetNextExtent(_BlockSize(), true, icbAddress, 1206 icbExtent); 1207 if (!error) { 1208 _PrintUpdate(VERBOSITY_HIGH, "udf: (partition: %d, location: %ld, " 1209 "length: %ld) => (location: %ld, length: %ld)", 1210 icbAddress.partition(), icbAddress.block(), 1211 icbAddress.length(), icbExtent.location(), 1212 icbExtent.length()); 1213 node.icbAddress = icbAddress; 1214 } 1215 } 1216 1217 DataStream *udfData = NULL; 1218 std::list<Udf::extent_address> udfDataExtents; 1219 std::list<Udf::long_address> &udfDataAddresses = node.udfData; 1220 1221 // Reserve udf dir data space 1222 if (!error && _DoUdf()) { 1223 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Reserving space for directory data"); 1224 error = _PartitionAllocator().GetNextExtents(udfDataLength, udfDataAddresses, 1225 udfDataExtents); 1226 if (!error) { 1227 int extents = udfDataAddresses.size(); 1228 if (extents > 1) 1229 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserved %d extents", 1230 extents); 1231 std::list<Udf::long_address>::iterator a; 1232 std::list<Udf::extent_address>::iterator e; 1233 for (a = udfDataAddresses.begin(), e = udfDataExtents.begin(); 1234 a != udfDataAddresses.end() && e != udfDataExtents.end(); 1235 a++, e++) 1236 { 1237 _PrintUpdate(VERBOSITY_HIGH, "udf: (partition: %d, location: %ld, " 1238 "length: %ld) => (location: %ld, length: %ld)", 1239 a->partition(), a->block(), a->length(), e->location(), 1240 e->length()); 1241 } 1242 } 1243 if (!error) { 1244 udfData = new(nothrow) ExtentStream(_OutputFile(), udfDataExtents, _BlockSize()); 1245 error = udfData ? B_OK : B_NO_MEMORY; 1246 } 1247 } 1248 1249 uint32 udfAllocationDescriptorsLength = udfDataAddresses.size() 1250 * sizeof(Udf::long_address); 1251 1252 // Process attributes 1253 uint16 attributeCount = 0; 1254 1255 // Write iso parent directory 1256 1257 // Write udf parent directory fid 1258 if (!error && _DoUdf()) { 1259 Udf::MemoryChunk chunk((38) + 4); 1260 error = chunk.InitCheck(); 1261 if (!error) { 1262 memset(chunk.Data(), 0, (38) + 4); 1263 Udf::file_id_descriptor *parent = 1264 reinterpret_cast<Udf::file_id_descriptor*>(chunk.Data()); 1265 parent->set_version_number(1); 1266 // Clear characteristics to false, then set 1267 // those that need to be true 1268 parent->set_characteristics(0); 1269 parent->set_is_directory(true); 1270 parent->set_is_parent(true); 1271 parent->set_id_length(0); 1272 parent->icb() = isRootDirectory ? icbAddress : parentIcbAddress; 1273 if (!isRootDirectory) 1274 parent->icb().set_unique_id(uint32(_NextUniqueId())); 1275 parent->set_implementation_use_length(0); 1276 parent->tag().set_id(Udf::TAGID_FILE_ID_DESCRIPTOR); 1277 parent->tag().set_version(_UdfDescriptorVersion()); 1278 parent->tag().set_serial_number(0); 1279 uint32 block; 1280 error = block_for_offset(udfData->Position(), udfDataAddresses, 1281 _BlockSize(), block); 1282 if (!error) { 1283 parent->tag().set_location(block); 1284 parent->tag().set_checksums(*parent, parent->descriptor_size()); 1285 ssize_t bytes = udfData->Write(parent, parent->total_length()); 1286 error = check_size_error(bytes, parent->total_length()); 1287 } 1288 } 1289 } 1290 1291 // Process children 1292 uint16 childDirCount = 0; 1293 if (!error) 1294 error = directory.Rewind(); 1295 while (error == B_OK) { 1296 BEntry childEntry; 1297 error = directory.GetNextEntry(&childEntry); 1298 if (error == B_ENTRY_NOT_FOUND) { 1299 error = B_OK; 1300 break; 1301 } 1302 if (!error) 1303 error = childEntry.InitCheck(); 1304 if (!error) { 1305 BPath childPath; 1306 error = childEntry.GetPath(&childPath); 1307 if (!error) 1308 error = childPath.InitCheck(); 1309 struct stat childStats; 1310 if (!error) 1311 error = childEntry.GetStat(&childStats); 1312 if (!error) { 1313 node_data childNode; 1314 std::string childImagePath(path); 1315 childImagePath += (childImagePath[childImagePath.length()-1] == '/' 1316 ? "" : "/"); 1317 childImagePath += childPath.Leaf(); 1318 // Process child 1319 if (S_ISREG(childStats.st_mode)) { 1320 // Regular file 1321 error = _ProcessFile(childEntry, childImagePath.c_str(), 1322 childStats, childNode); 1323 } else if (S_ISDIR(childStats.st_mode)) { 1324 // Directory 1325 error = _ProcessDirectory(childEntry, childImagePath.c_str(), 1326 childStats, childNode, icbAddress); 1327 if (!error) 1328 childDirCount++; 1329 } else if (S_ISLNK(childStats.st_mode)) { 1330 // Symlink 1331 // For now, skip it 1332 _Stats().AddSymlink(); 1333 _PrintWarning("No symlink support yet; skipping symlink: `%s'", 1334 childImagePath.c_str()); 1335 continue; 1336 } 1337 1338 // Write iso direntry 1339 1340 // Write udf fid 1341 if (!error) { 1342 Udf::String udfName(childPath.Leaf()); 1343 uint32 udfNameLength = udfName.Cs0Length(); 1344 uint32 idLength = (38) 1345 + udfNameLength; 1346 Udf::MemoryChunk chunk(idLength + 4); 1347 error = chunk.InitCheck(); 1348 if (!error) { 1349 memset(chunk.Data(), 0, idLength + 4); 1350 Udf::file_id_descriptor *id = 1351 reinterpret_cast<Udf::file_id_descriptor*>(chunk.Data()); 1352 id->set_version_number(1); 1353 // Clear characteristics to false, then set 1354 // those that need to be true 1355 id->set_characteristics(0); 1356 id->set_is_directory(S_ISDIR(childStats.st_mode)); 1357 id->set_is_parent(false); 1358 id->set_id_length(udfNameLength); 1359 id->icb() = childNode.icbAddress; 1360 id->icb().set_unique_id(uint32(_NextUniqueId())); 1361 id->set_implementation_use_length(0); 1362 memcpy(id->id(), udfName.Cs0(), udfNameLength); 1363 id->tag().set_id(Udf::TAGID_FILE_ID_DESCRIPTOR); 1364 id->tag().set_version(_UdfDescriptorVersion()); 1365 id->tag().set_serial_number(0); 1366 uint32 block; 1367 error = block_for_offset(udfData->Position(), udfDataAddresses, 1368 _BlockSize(), block); 1369 if (!error) { 1370 id->tag().set_location(block); 1371 id->tag().set_checksums(*id, id->descriptor_size()); 1372 PDUMP(id); 1373 PRINT(("pos: %Ld\n", udfData->Position())); 1374 ssize_t bytes = udfData->Write(id, id->total_length()); 1375 PRINT(("pos: %Ld\n", udfData->Position())); 1376 error = check_size_error(bytes, id->total_length()); 1377 } 1378 } 1379 } 1380 } 1381 } 1382 } 1383 1384 // Build and write udf icb 1385 Udf::MemoryChunk chunk(_BlockSize()); 1386 if (!error) 1387 error = chunk.InitCheck(); 1388 if (!error) { 1389 memset(chunk.Data(), 0, _BlockSize()); 1390 uint8 fileType = Udf::ICB_TYPE_DIRECTORY; 1391 uint16 linkCount = 1 + attributeCount + childDirCount; 1392 if (_UdfRevision() <= 0x0150) { 1393 error = _WriteFileEntry( 1394 reinterpret_cast<Udf::file_icb_entry*>(chunk.Data()), 1395 fileType, linkCount, udfDataLength, udfDataLength, 1396 stats, udfUniqueId, udfAllocationDescriptorsLength, 1397 Udf::TAGID_FILE_ENTRY, 1398 icbAddress, icbExtent, udfDataAddresses 1399 ); 1400 } else { 1401 error = _WriteFileEntry( 1402 reinterpret_cast<Udf::extended_file_icb_entry*>(chunk.Data()), 1403 fileType, linkCount, udfDataLength, udfDataLength, 1404 stats, udfUniqueId, udfAllocationDescriptorsLength, 1405 Udf::TAGID_EXTENDED_FILE_ENTRY, 1406 icbAddress, icbExtent, udfDataAddresses 1407 ); 1408 } 1409 } 1410 1411 delete udfData; 1412 udfData = NULL; 1413 } 1414 } 1415 1416 if (!error) { 1417 _Stats().AddDirectory(); 1418 uint32 totalLength = udfDataLength + _BlockSize(); 1419 _Stats().AddDirectoryBytes(totalLength); 1420 } 1421 RETURN(error); 1422} 1423 1424status_t 1425UdfBuilder::_ProcessFile(BEntry &entry, const char *path, struct stat stats, 1426 node_data &node) 1427{ 1428 DEBUG_INIT_ETC("UdfBuilder", ("path: `%s'", path)); 1429 status_t error = entry.InitCheck() == B_OK && path ? B_OK : B_BAD_VALUE; 1430 off_t udfDataLength = stats.st_size; 1431 if (udfDataLength > ULONG_MAX && _DoIso()) { 1432 _PrintError("File `%s' too large for iso9660 filesystem (filesize: %Lu bytes, max: %lu bytes)", 1433 path, udfDataLength, ULONG_MAX); 1434 error = B_ERROR; 1435 } 1436 if (!error) { 1437 _PrintUpdate(VERBOSITY_LOW, "Adding `%s' (%s)", path, 1438 bytes_to_string(stats.st_size).c_str()); 1439 BFile file(&entry, B_READ_ONLY); 1440 error = file.InitCheck(); 1441 if (!error) { 1442 // Reserve udf icb space 1443 Udf::long_address icbAddress; 1444 Udf::extent_address icbExtent; 1445 if (!error && _DoUdf()) { 1446 _PrintUpdate(VERBOSITY_MEDIUM, "udf: Reserving space for icb"); 1447 error = _PartitionAllocator().GetNextExtent(_BlockSize(), true, icbAddress, 1448 icbExtent); 1449 if (!error) { 1450 _PrintUpdate(VERBOSITY_HIGH, "udf: (partition: %d, location: %ld, " 1451 "length: %ld) => (location: %ld, length: %ld)", 1452 icbAddress.partition(), icbAddress.block(), 1453 icbAddress.length(), icbExtent.location(), 1454 icbExtent.length()); 1455 node.icbAddress = icbAddress; 1456 } 1457 } 1458 1459 DataStream *udfData = NULL; 1460 std::list<Udf::extent_address> udfDataExtents; 1461 std::list<Udf::long_address> &udfDataAddresses = node.udfData; 1462 1463 // Reserve iso/udf data space 1464 if (!error) { 1465 _PrintUpdate(VERBOSITY_MEDIUM, "Reserving space for file data"); 1466 if (_DoIso()) { 1467 // Reserve a contiguous extent, as iso requires 1468 Udf::long_address address; 1469 Udf::extent_address extent; 1470 error = _PartitionAllocator().GetNextExtent(udfDataLength, true, address, extent); 1471 if (!error) { 1472 udfDataAddresses.empty(); // just in case 1473 udfDataAddresses.push_back(address); 1474 udfDataExtents.push_back(extent); 1475 } 1476 } else { 1477 // Udf can handle multiple extents if necessary 1478 error = _PartitionAllocator().GetNextExtents(udfDataLength, udfDataAddresses, 1479 udfDataExtents); 1480 } 1481 if (!error) { 1482 int extents = udfDataAddresses.size(); 1483 if (extents > 1) 1484 _PrintUpdate(VERBOSITY_HIGH, "udf: Reserved %d extents", 1485 extents); 1486 std::list<Udf::long_address>::iterator a; 1487 std::list<Udf::extent_address>::iterator e; 1488 for (a = udfDataAddresses.begin(), e = udfDataExtents.begin(); 1489 a != udfDataAddresses.end() && e != udfDataExtents.end(); 1490 a++, e++) 1491 { 1492 _PrintUpdate(VERBOSITY_HIGH, "udf: (partition: %d, location: %ld, " 1493 "length: %ld) => (location: %ld, length: %ld)", 1494 a->partition(), a->block(), a->length(), e->location(), 1495 e->length()); 1496 } 1497 } 1498 if (!error) { 1499 udfData = new(nothrow) ExtentStream(_OutputFile(), udfDataExtents, _BlockSize()); 1500 error = udfData ? B_OK : B_NO_MEMORY; 1501 } 1502 } 1503 1504 uint32 udfAllocationDescriptorsLength = udfDataAddresses.size() 1505 * sizeof(Udf::long_address); 1506 1507 // Process attributes 1508 uint16 attributeCount = 0; 1509 1510 // Write file data 1511 if (!error) { 1512 _PrintUpdate(VERBOSITY_MEDIUM, "Writing file data"); 1513 ssize_t bytes = udfData->Write(file, udfDataLength); 1514 error = check_size_error(bytes, udfDataLength); 1515 } 1516 1517 // Build and write udf icb 1518 Udf::MemoryChunk chunk(_BlockSize()); 1519 if (!error) 1520 error = chunk.InitCheck(); 1521 if (!error) { 1522 memset(chunk.Data(), 0, _BlockSize()); 1523 uint8 fileType = Udf::ICB_TYPE_REGULAR_FILE; 1524 uint16 linkCount = 1 + attributeCount; 1525 uint64 uniqueId = _NextUniqueId(); 1526 if (_UdfRevision() <= 0x0150) { 1527 error = _WriteFileEntry( 1528 reinterpret_cast<Udf::file_icb_entry*>(chunk.Data()), 1529 fileType, linkCount, udfDataLength, udfDataLength, 1530 stats, uniqueId, udfAllocationDescriptorsLength, 1531 Udf::TAGID_FILE_ENTRY, 1532 icbAddress, icbExtent, udfDataAddresses 1533 ); 1534 } else { 1535 error = _WriteFileEntry( 1536 reinterpret_cast<Udf::extended_file_icb_entry*>(chunk.Data()), 1537 fileType, linkCount, udfDataLength, udfDataLength, 1538 stats, uniqueId, udfAllocationDescriptorsLength, 1539 Udf::TAGID_EXTENDED_FILE_ENTRY, 1540 icbAddress, icbExtent, udfDataAddresses 1541 ); 1542 } 1543 } 1544 1545 delete udfData; 1546 udfData = NULL; 1547 } 1548 } 1549 1550 if (!error) { 1551 _Stats().AddFile(); 1552 off_t totalLength = udfDataLength + _BlockSize(); 1553 _Stats().AddFileBytes(totalLength); 1554 } 1555 RETURN(error); 1556} 1557 1558