1/* $NetBSD: iso9660_rrip.c,v 1.14 2014/05/30 13:14:47 martin Exp $ */ 2 3/*- 4 * SPDX-License-Identifier: BSD-2-Clause-NetBSD 5 * 6 * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan 7 * Perez-Rathke and Ram Vedam. All rights reserved. 8 * 9 * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys, 10 * Alan Perez-Rathke and Ram Vedam. 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above 18 * copyright notice, this list of conditions and the following 19 * disclaimer in the documentation and/or other materials provided 20 * with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN 23 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``AS IS'' AND ANY EXPRESS OR 24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 26 * DISCLAIMED. IN NO EVENT SHALL DANIEL WATT, WALTER DEIGNAN, RYAN 27 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM BE LIABLE FOR ANY DIRECT, INDIRECT, 28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 29 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 30 * USE,DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 31 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 34 * OF SUCH DAMAGE. 35 */ 36/* This will hold all the function definitions 37 * defined in iso9660_rrip.h 38 */ 39 40#include <sys/cdefs.h> 41__FBSDID("$FreeBSD$"); 42 43#include <sys/queue.h> 44#include <sys/types.h> 45#include <stdio.h> 46 47#include "makefs.h" 48#include "cd9660.h" 49#include "iso9660_rrip.h" 50#include <util.h> 51 52static void cd9660_rrip_initialize_inode(cd9660node *); 53static int cd9660_susp_handle_continuation(iso9660_disk *, cd9660node *); 54static int cd9660_susp_handle_continuation_common(iso9660_disk *, cd9660node *, 55 int); 56 57int 58cd9660_susp_initialize(iso9660_disk *diskStructure, cd9660node *node, 59 cd9660node *parent, cd9660node *grandparent) 60{ 61 cd9660node *cn; 62 int r; 63 64 /* Make sure the node is not NULL. If it is, there are major problems */ 65 assert(node != NULL); 66 67 if (!(node->type & CD9660_TYPE_DOT) && 68 !(node->type & CD9660_TYPE_DOTDOT)) 69 TAILQ_INIT(&(node->head)); 70 if (node->dot_record != 0) 71 TAILQ_INIT(&(node->dot_record->head)); 72 if (node->dot_dot_record != 0) 73 TAILQ_INIT(&(node->dot_dot_record->head)); 74 75 /* SUSP specific entries here */ 76 if ((r = cd9660_susp_initialize_node(diskStructure, node)) < 0) 77 return r; 78 79 /* currently called cd9660node_rrip_init_links */ 80 r = cd9660_rrip_initialize_node(diskStructure, node, parent, grandparent); 81 if (r < 0) 82 return r; 83 84 /* 85 * See if we need a CE record, and set all of the 86 * associated counters. 87 * 88 * This should be called after all extensions. After 89 * this is called, no new records should be added. 90 */ 91 if ((r = cd9660_susp_handle_continuation(diskStructure, node)) < 0) 92 return r; 93 94 /* Recurse on children. */ 95 TAILQ_FOREACH(cn, &node->cn_children, cn_next_child) { 96 if ((r = cd9660_susp_initialize(diskStructure, cn, node, parent)) < 0) 97 return 0; 98 } 99 return 1; 100} 101 102int 103cd9660_susp_finalize(iso9660_disk *diskStructure, cd9660node *node) 104{ 105 cd9660node *temp; 106 int r; 107 108 assert(node != NULL); 109 110 if (node == diskStructure->rootNode) 111 diskStructure->susp_continuation_area_current_free = 0; 112 113 if ((r = cd9660_susp_finalize_node(diskStructure, node)) < 0) 114 return r; 115 if ((r = cd9660_rrip_finalize_node(node)) < 0) 116 return r; 117 118 TAILQ_FOREACH(temp, &node->cn_children, cn_next_child) { 119 if ((r = cd9660_susp_finalize(diskStructure, temp)) < 0) 120 return r; 121 } 122 return 1; 123} 124 125/* 126 * If we really wanted to speed things up, we could have some sort of 127 * lookup table on the SUSP entry type that calls a functor. Or, we could 128 * combine the functions. These functions are kept separate to allow 129 * easier addition of other extensions. 130 131 * For the sake of simplicity and clarity, we won't be doing that for now. 132 */ 133 134/* 135 * SUSP needs to update the following types: 136 * CE (continuation area) 137 */ 138int 139cd9660_susp_finalize_node(iso9660_disk *diskStructure, cd9660node *node) 140{ 141 struct ISO_SUSP_ATTRIBUTES *t; 142 143 /* Handle CE counters */ 144 if (node->susp_entry_ce_length > 0) { 145 node->susp_entry_ce_start = 146 diskStructure->susp_continuation_area_current_free; 147 diskStructure->susp_continuation_area_current_free += 148 node->susp_entry_ce_length; 149 } 150 151 TAILQ_FOREACH(t, &node->head, rr_ll) { 152 if (t->susp_type != SUSP_TYPE_SUSP || 153 t->entry_type != SUSP_ENTRY_SUSP_CE) 154 continue; 155 cd9660_bothendian_dword( 156 diskStructure-> 157 susp_continuation_area_start_sector, 158 t->attr.su_entry.CE.ca_sector); 159 160 cd9660_bothendian_dword( 161 diskStructure-> 162 susp_continuation_area_start_sector, 163 t->attr.su_entry.CE.ca_sector); 164 cd9660_bothendian_dword(node->susp_entry_ce_start, 165 t->attr.su_entry.CE.offset); 166 cd9660_bothendian_dword(node->susp_entry_ce_length, 167 t->attr.su_entry.CE.length); 168 } 169 return 0; 170} 171 172int 173cd9660_rrip_finalize_node(cd9660node *node) 174{ 175 struct ISO_SUSP_ATTRIBUTES *t; 176 177 TAILQ_FOREACH(t, &node->head, rr_ll) { 178 if (t->susp_type != SUSP_TYPE_RRIP) 179 continue; 180 switch (t->entry_type) { 181 case SUSP_ENTRY_RRIP_CL: 182 /* Look at rr_relocated*/ 183 if (node->rr_relocated == NULL) 184 return -1; 185 cd9660_bothendian_dword( 186 node->rr_relocated->fileDataSector, 187 (unsigned char *) 188 t->attr.rr_entry.CL.dir_loc); 189 break; 190 case SUSP_ENTRY_RRIP_PL: 191 /* Look at rr_real_parent */ 192 if (node->parent == NULL || 193 node->parent->rr_real_parent == NULL) 194 return -1; 195 cd9660_bothendian_dword( 196 node->parent->rr_real_parent->fileDataSector, 197 (unsigned char *) 198 t->attr.rr_entry.PL.dir_loc); 199 break; 200 } 201 } 202 return 0; 203} 204 205static int 206cd9660_susp_handle_continuation_common(iso9660_disk *diskStructure, 207 cd9660node *node, int space) 208{ 209 int ca_used, susp_used, susp_used_pre_ce, working; 210 struct ISO_SUSP_ATTRIBUTES *temp, *pre_ce, *last, *CE, *ST; 211 212 pre_ce = last = NULL; 213 working = 254 - space; 214 if (node->su_tail_size > 0) 215 /* Allow 4 bytes for "ST" record. */ 216 working -= node->su_tail_size + 4; 217 /* printf("There are %i bytes to work with\n",working); */ 218 219 susp_used_pre_ce = susp_used = 0; 220 ca_used = 0; 221 TAILQ_FOREACH(temp, &node->head, rr_ll) { 222 if (working < 0) 223 break; 224 /* 225 * printf("SUSP Entry found, length is %i\n", 226 * CD9660_SUSP_ENTRY_SIZE(temp)); 227 */ 228 working -= CD9660_SUSP_ENTRY_SIZE(temp); 229 if (working >= 0) { 230 last = temp; 231 susp_used += CD9660_SUSP_ENTRY_SIZE(temp); 232 } 233 if (working >= 28) { 234 /* 235 * Remember the last entry after which we 236 * could insert a "CE" entry. 237 */ 238 pre_ce = last; 239 susp_used_pre_ce = susp_used; 240 } 241 } 242 243 /* A CE entry is needed */ 244 if (working <= 0) { 245 CE = cd9660node_susp_create_node(SUSP_TYPE_SUSP, 246 SUSP_ENTRY_SUSP_CE, "CE", SUSP_LOC_ENTRY); 247 cd9660_susp_ce(CE, node); 248 /* This will automatically insert at the appropriate location */ 249 if (pre_ce != NULL) 250 TAILQ_INSERT_AFTER(&node->head, pre_ce, CE, rr_ll); 251 else 252 TAILQ_INSERT_HEAD(&node->head, CE, rr_ll); 253 last = CE; 254 susp_used = susp_used_pre_ce + 28; 255 /* Count how much CA data is necessary */ 256 for (temp = TAILQ_NEXT(last, rr_ll); temp != NULL; 257 temp = TAILQ_NEXT(temp, rr_ll)) { 258 ca_used += CD9660_SUSP_ENTRY_SIZE(temp); 259 } 260 } 261 262 /* An ST entry is needed */ 263 if (node->su_tail_size > 0) { 264 ST = cd9660node_susp_create_node(SUSP_TYPE_SUSP, 265 SUSP_ENTRY_SUSP_ST, "ST", SUSP_LOC_ENTRY); 266 cd9660_susp_st(ST, node); 267 if (last != NULL) 268 TAILQ_INSERT_AFTER(&node->head, last, ST, rr_ll); 269 else 270 TAILQ_INSERT_HEAD(&node->head, ST, rr_ll); 271 last = ST; 272 susp_used += 4; 273 } 274 if (last != NULL) 275 last->last_in_suf = 1; 276 277 node->susp_entry_size = susp_used; 278 node->susp_entry_ce_length = ca_used; 279 280 diskStructure->susp_continuation_area_size += ca_used; 281 return 1; 282} 283 284/* See if a continuation entry is needed for each of the different types */ 285static int 286cd9660_susp_handle_continuation(iso9660_disk *diskStructure, cd9660node *node) 287{ 288 assert (node != NULL); 289 290 /* Entry */ 291 if (cd9660_susp_handle_continuation_common(diskStructure, 292 node,(int)(node->isoDirRecord->length[0])) < 0) 293 return 0; 294 295 return 1; 296} 297 298int 299cd9660_susp_initialize_node(iso9660_disk *diskStructure, cd9660node *node) 300{ 301 struct ISO_SUSP_ATTRIBUTES *temp; 302 303 /* 304 * Requirements/notes: 305 * CE: is added for us where needed 306 * ST: not sure if it is even required, but if so, should be 307 * handled by the CE code 308 * PD: isn't needed (though might be added for testing) 309 * SP: is stored ONLY on the . record of the root directory 310 * ES: not sure 311 */ 312 313 /* Check for root directory, add SP and ER if needed. */ 314 if (node->type & CD9660_TYPE_DOT) { 315 if (node->parent == diskStructure->rootNode) { 316 temp = cd9660node_susp_create_node(SUSP_TYPE_SUSP, 317 SUSP_ENTRY_SUSP_SP, "SP", SUSP_LOC_DOT); 318 cd9660_susp_sp(temp, node); 319 320 /* Should be first entry. */ 321 TAILQ_INSERT_HEAD(&node->head, temp, rr_ll); 322 } 323 } 324 return 1; 325} 326 327static void 328cd9660_rrip_initialize_inode(cd9660node *node) 329{ 330 struct ISO_SUSP_ATTRIBUTES *attr; 331 332 /* 333 * Inode dependent values - this may change, 334 * but for now virtual files and directories do 335 * not have an inode structure 336 */ 337 338 if ((node->node != NULL) && (node->node->inode != NULL)) { 339 /* PX - POSIX attributes */ 340 attr = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 341 SUSP_ENTRY_RRIP_PX, "PX", SUSP_LOC_ENTRY); 342 cd9660node_rrip_px(attr, node->node); 343 344 TAILQ_INSERT_TAIL(&node->head, attr, rr_ll); 345 346 /* TF - timestamp */ 347 attr = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 348 SUSP_ENTRY_RRIP_TF, "TF", SUSP_LOC_ENTRY); 349 cd9660node_rrip_tf(attr, node->node); 350 TAILQ_INSERT_TAIL(&node->head, attr, rr_ll); 351 352 /* SL - Symbolic link */ 353 /* ?????????? Dan - why is this here? */ 354 if (TAILQ_EMPTY(&node->cn_children) && 355 node->node->inode != NULL && 356 S_ISLNK(node->node->inode->st.st_mode)) 357 cd9660_createSL(node); 358 359 /* PN - device number */ 360 if (node->node->inode != NULL && 361 ((S_ISCHR(node->node->inode->st.st_mode) || 362 S_ISBLK(node->node->inode->st.st_mode)))) { 363 attr = 364 cd9660node_susp_create_node(SUSP_TYPE_RRIP, 365 SUSP_ENTRY_RRIP_PN, "PN", 366 SUSP_LOC_ENTRY); 367 cd9660node_rrip_pn(attr, node->node); 368 TAILQ_INSERT_TAIL(&node->head, attr, rr_ll); 369 } 370 } 371} 372 373int 374cd9660_rrip_initialize_node(iso9660_disk *diskStructure, cd9660node *node, 375 cd9660node *parent, cd9660node *grandparent) 376{ 377 struct ISO_SUSP_ATTRIBUTES *current = NULL; 378 379 assert(node != NULL); 380 381 if (node->type & CD9660_TYPE_DOT) { 382 /* 383 * Handle ER - should be the only entry to appear on 384 * a "." record 385 */ 386 if (node->parent == diskStructure->rootNode) { 387 cd9660_susp_ER(node, 1, SUSP_RRIP_ER_EXT_ID, 388 SUSP_RRIP_ER_EXT_DES, SUSP_RRIP_ER_EXT_SRC); 389 } 390 if (parent != NULL && parent->node != NULL && 391 parent->node->inode != NULL) { 392 /* PX - POSIX attributes */ 393 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 394 SUSP_ENTRY_RRIP_PX, "PX", SUSP_LOC_ENTRY); 395 cd9660node_rrip_px(current, parent->node); 396 TAILQ_INSERT_TAIL(&node->head, current, rr_ll); 397 } 398 } else if (node->type & CD9660_TYPE_DOTDOT) { 399 if (grandparent != NULL && grandparent->node != NULL && 400 grandparent->node->inode != NULL) { 401 /* PX - POSIX attributes */ 402 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 403 SUSP_ENTRY_RRIP_PX, "PX", SUSP_LOC_ENTRY); 404 cd9660node_rrip_px(current, grandparent->node); 405 TAILQ_INSERT_TAIL(&node->head, current, rr_ll); 406 } 407 /* Handle PL */ 408 if (parent != NULL && parent->rr_real_parent != NULL) { 409 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 410 SUSP_ENTRY_RRIP_PL, "PL", SUSP_LOC_DOTDOT); 411 cd9660_rrip_PL(current,node); 412 TAILQ_INSERT_TAIL(&node->head, current, rr_ll); 413 } 414 } else { 415 cd9660_rrip_initialize_inode(node); 416 417 /* 418 * Not every node needs a NM set - only if the name is 419 * actually different. IE: If a file is TEST -> TEST, 420 * no NM. test -> TEST, need a NM 421 * 422 * The rr_moved_dir needs to be assigned a NM record as well. 423 */ 424 if (node == diskStructure->rr_moved_dir) { 425 cd9660_rrip_add_NM(node, RRIP_DEFAULT_MOVE_DIR_NAME); 426 } 427 else if ((node->node != NULL) && 428 ((strlen(node->node->name) != 429 (uint8_t)node->isoDirRecord->name_len[0]) || 430 (memcmp(node->node->name,node->isoDirRecord->name, 431 (uint8_t)node->isoDirRecord->name_len[0]) != 0))) { 432 cd9660_rrip_NM(node); 433 } 434 435 436 437 /* Rock ridge directory relocation code here. */ 438 439 /* First handle the CL for the placeholder file. */ 440 if (node->rr_relocated != NULL) { 441 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 442 SUSP_ENTRY_RRIP_CL, "CL", SUSP_LOC_ENTRY); 443 cd9660_rrip_CL(current, node); 444 TAILQ_INSERT_TAIL(&node->head, current, rr_ll); 445 } 446 447 /* Handle RE*/ 448 if (node->rr_real_parent != NULL) { 449 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 450 SUSP_ENTRY_RRIP_RE, "RE", SUSP_LOC_ENTRY); 451 cd9660_rrip_RE(current,node); 452 TAILQ_INSERT_TAIL(&node->head, current, rr_ll); 453 } 454 } 455 return 1; 456} 457 458struct ISO_SUSP_ATTRIBUTES* 459cd9660node_susp_create_node(int susp_type, int entry_type, const char *type_id, 460 int write_loc) 461{ 462 struct ISO_SUSP_ATTRIBUTES* temp; 463 464 temp = emalloc(sizeof(*temp)); 465 temp->susp_type = susp_type; 466 temp->entry_type = entry_type; 467 temp->last_in_suf = 0; 468 /* Phase this out */ 469 temp->type_of[0] = type_id[0]; 470 temp->type_of[1] = type_id[1]; 471 temp->write_location = write_loc; 472 473 /* 474 * Since the first four bytes is common, lets go ahead and 475 * set the type identifier, since we are passing that to this 476 * function anyhow. 477 */ 478 temp->attr.su_entry.SP.h.type[0] = type_id[0]; 479 temp->attr.su_entry.SP.h.type[1] = type_id[1]; 480 return temp; 481} 482 483int 484cd9660_rrip_PL(struct ISO_SUSP_ATTRIBUTES* p, cd9660node *node __unused) 485{ 486 p->attr.rr_entry.PL.h.length[0] = 12; 487 p->attr.rr_entry.PL.h.version[0] = 1; 488 return 1; 489} 490 491int 492cd9660_rrip_CL(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *node __unused) 493{ 494 p->attr.rr_entry.CL.h.length[0] = 12; 495 p->attr.rr_entry.CL.h.version[0] = 1; 496 return 1; 497} 498 499int 500cd9660_rrip_RE(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *node __unused) 501{ 502 p->attr.rr_entry.RE.h.length[0] = 4; 503 p->attr.rr_entry.RE.h.version[0] = 1; 504 return 1; 505} 506 507void 508cd9660_createSL(cd9660node *node) 509{ 510 struct ISO_SUSP_ATTRIBUTES* current; 511 int path_count, dir_count, done, i, j, dir_copied; 512 char temp_cr[255]; 513 char temp_sl[255]; /* used in copying continuation entry*/ 514 char* sl_ptr; 515 516 sl_ptr = node->node->symlink; 517 518 done = 0; 519 path_count = 0; 520 dir_count = 0; 521 dir_copied = 0; 522 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 523 SUSP_ENTRY_RRIP_SL, "SL", SUSP_LOC_ENTRY); 524 525 current->attr.rr_entry.SL.h.version[0] = 1; 526 current->attr.rr_entry.SL.flags[0] = SL_FLAGS_NONE; 527 528 if (*sl_ptr == '/') { 529 temp_cr[0] = SL_FLAGS_ROOT; 530 temp_cr[1] = 0; 531 memcpy(current->attr.rr_entry.SL.component + path_count, 532 temp_cr, 2); 533 path_count += 2; 534 sl_ptr++; 535 } 536 537 for (i = 0; i < (dir_count + 2); i++) 538 temp_cr[i] = '\0'; 539 540 while (!done) { 541 while ((*sl_ptr != '/') && (*sl_ptr != '\0')) { 542 dir_copied = 1; 543 if (*sl_ptr == '.') { 544 if ((*(sl_ptr + 1) == '/') || (*(sl_ptr + 1) 545 == '\0')) { 546 temp_cr[0] = SL_FLAGS_CURRENT; 547 sl_ptr++; 548 } else if(*(sl_ptr + 1) == '.') { 549 if ((*(sl_ptr + 2) == '/') || 550 (*(sl_ptr + 2) == '\0')) { 551 temp_cr[0] = SL_FLAGS_PARENT; 552 sl_ptr += 2; 553 } 554 } else { 555 temp_cr[dir_count+2] = *sl_ptr; 556 sl_ptr++; 557 dir_count++; 558 } 559 } else { 560 temp_cr[dir_count + 2] = *sl_ptr; 561 sl_ptr++; 562 dir_count++; 563 } 564 } 565 566 if ((path_count + dir_count) >= 249) { 567 current->attr.rr_entry.SL.flags[0] |= SL_FLAGS_CONTINUE; 568 569 j = 0; 570 571 if (path_count <= 249) { 572 while(j != (249 - path_count)) { 573 temp_sl[j] = temp_cr[j]; 574 j++; 575 } 576 temp_sl[0] = SL_FLAGS_CONTINUE; 577 temp_sl[1] = j - 2; 578 memcpy( 579 current->attr.rr_entry.SL.component + 580 path_count, 581 temp_sl, j); 582 } 583 584 path_count += j; 585 current->attr.rr_entry.SL.h.length[0] = path_count + 5; 586 TAILQ_INSERT_TAIL(&node->head, current, rr_ll); 587 current= cd9660node_susp_create_node(SUSP_TYPE_RRIP, 588 SUSP_ENTRY_RRIP_SL, "SL", SUSP_LOC_ENTRY); 589 current->attr.rr_entry.SL.h.version[0] = 1; 590 current->attr.rr_entry.SL.flags[0] = SL_FLAGS_NONE; 591 592 path_count = 0; 593 594 if (dir_count > 2) { 595 while (j != dir_count + 2) { 596 current->attr.rr_entry.SL.component[ 597 path_count + 2] = temp_cr[j]; 598 j++; 599 path_count++; 600 } 601 current->attr.rr_entry.SL.component[1] 602 = path_count; 603 path_count+= 2; 604 } else { 605 while(j != dir_count) { 606 current->attr.rr_entry.SL.component[ 607 path_count+2] = temp_cr[j]; 608 j++; 609 path_count++; 610 } 611 } 612 } else { 613 if (dir_copied == 1) { 614 temp_cr[1] = dir_count; 615 memcpy(current->attr.rr_entry.SL.component + 616 path_count, 617 temp_cr, dir_count + 2); 618 path_count += dir_count + 2; 619 } 620 } 621 622 if (*sl_ptr == '\0') { 623 done = 1; 624 current->attr.rr_entry.SL.h.length[0] = path_count + 5; 625 TAILQ_INSERT_TAIL(&node->head, current, rr_ll); 626 } else { 627 sl_ptr++; 628 dir_count = 0; 629 dir_copied = 0; 630 for(i = 0; i < 255; i++) { 631 temp_cr[i] = '\0'; 632 } 633 } 634 } 635} 636 637int 638cd9660node_rrip_px(struct ISO_SUSP_ATTRIBUTES *v, fsnode *pxinfo) 639{ 640 v->attr.rr_entry.PX.h.length[0] = 44; 641 v->attr.rr_entry.PX.h.version[0] = 1; 642 cd9660_bothendian_dword(pxinfo->inode->st.st_mode, 643 v->attr.rr_entry.PX.mode); 644 cd9660_bothendian_dword(pxinfo->inode->st.st_nlink, 645 v->attr.rr_entry.PX.links); 646 cd9660_bothendian_dword(pxinfo->inode->st.st_uid, 647 v->attr.rr_entry.PX.uid); 648 cd9660_bothendian_dword(pxinfo->inode->st.st_gid, 649 v->attr.rr_entry.PX.gid); 650 cd9660_bothendian_dword(pxinfo->inode->st.st_ino, 651 v->attr.rr_entry.PX.serial); 652 653 return 1; 654} 655 656int 657cd9660node_rrip_pn(struct ISO_SUSP_ATTRIBUTES *pn_field, fsnode *fnode) 658{ 659 pn_field->attr.rr_entry.PN.h.length[0] = 20; 660 pn_field->attr.rr_entry.PN.h.version[0] = 1; 661 662 if (sizeof (fnode->inode->st.st_rdev) > 4) 663 cd9660_bothendian_dword( 664 (uint64_t)fnode->inode->st.st_rdev >> 32, 665 pn_field->attr.rr_entry.PN.high); 666 else 667 cd9660_bothendian_dword(0, pn_field->attr.rr_entry.PN.high); 668 669 cd9660_bothendian_dword(fnode->inode->st.st_rdev & 0xffffffff, 670 pn_field->attr.rr_entry.PN.low); 671 return 1; 672} 673 674#if 0 675int 676cd9660node_rrip_nm(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *file_node) 677{ 678 int nm_length = strlen(file_node->isoDirRecord->name) + 5; 679 p->attr.rr_entry.NM.h.type[0] = 'N'; 680 p->attr.rr_entry.NM.h.type[1] = 'M'; 681 sprintf(p->attr.rr_entry.NM.altname, "%s", file_node->isoDirRecord->name); 682 p->attr.rr_entry.NM.h.length[0] = (unsigned char)nm_length; 683 p->attr.rr_entry.NM.h.version[0] = (unsigned char)1; 684 p->attr.rr_entry.NM.flags[0] = (unsigned char) NM_PARENT; 685 return 1; 686} 687#endif 688 689int 690cd9660node_rrip_tf(struct ISO_SUSP_ATTRIBUTES *p, fsnode *_node) 691{ 692 p->attr.rr_entry.TF.flags[0] = TF_MODIFY | TF_ACCESS | TF_ATTRIBUTES; 693 p->attr.rr_entry.TF.h.length[0] = 5; 694 p->attr.rr_entry.TF.h.version[0] = 1; 695 696 /* 697 * Need to add creation time, backup time, 698 * expiration time, and effective time. 699 */ 700 701 cd9660_time_915(p->attr.rr_entry.TF.timestamp, 702 _node->inode->st.st_atime); 703 p->attr.rr_entry.TF.h.length[0] += 7; 704 705 cd9660_time_915(p->attr.rr_entry.TF.timestamp + 7, 706 _node->inode->st.st_mtime); 707 p->attr.rr_entry.TF.h.length[0] += 7; 708 709 cd9660_time_915(p->attr.rr_entry.TF.timestamp + 14, 710 _node->inode->st.st_ctime); 711 p->attr.rr_entry.TF.h.length[0] += 7; 712 return 1; 713} 714 715int 716cd9660_susp_sp(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *spinfo __unused) 717{ 718 p->attr.su_entry.SP.h.length[0] = 7; 719 p->attr.su_entry.SP.h.version[0] = 1; 720 p->attr.su_entry.SP.check[0] = 0xBE; 721 p->attr.su_entry.SP.check[1] = 0xEF; 722 p->attr.su_entry.SP.len_skp[0] = 0; 723 return 1; 724} 725 726int 727cd9660_susp_st(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *stinfo __unused) 728{ 729 p->attr.su_entry.ST.h.type[0] = 'S'; 730 p->attr.su_entry.ST.h.type[1] = 'T'; 731 p->attr.su_entry.ST.h.length[0] = 4; 732 p->attr.su_entry.ST.h.version[0] = 1; 733 return 1; 734} 735 736int 737cd9660_susp_ce(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *spinfo __unused) 738{ 739 p->attr.su_entry.CE.h.length[0] = 28; 740 p->attr.su_entry.CE.h.version[0] = 1; 741 /* Other attributes dont matter right now, will be updated later */ 742 return 1; 743} 744 745int 746cd9660_susp_pd(struct ISO_SUSP_ATTRIBUTES *p __unused, int length __unused) 747{ 748 return 1; 749} 750 751void 752cd9660_rrip_add_NM(cd9660node *node, const char *name) 753{ 754 int working,len; 755 const char *p; 756 struct ISO_SUSP_ATTRIBUTES *r; 757 758 /* 759 * Each NM record has 254 byes to work with. This means that 760 * the name data itself only has 249 bytes to work with. So, a 761 * name with 251 characters would require two nm records. 762 */ 763 p = name; 764 working = 1; 765 while (working) { 766 r = cd9660node_susp_create_node(SUSP_TYPE_RRIP, 767 SUSP_ENTRY_RRIP_NM, "NM", SUSP_LOC_ENTRY); 768 r->attr.rr_entry.NM.h.version[0] = 1; 769 r->attr.rr_entry.NM.flags[0] = RRIP_NM_FLAGS_NONE; 770 len = strlen(p); 771 772 if (len > 249) { 773 len = 249; 774 r->attr.rr_entry.NM.flags[0] = RRIP_NM_FLAGS_CONTINUE; 775 } else { 776 working = 0; 777 } 778 memcpy(r->attr.rr_entry.NM.altname, p, len); 779 r->attr.rr_entry.NM.h.length[0] = 5 + len; 780 781 TAILQ_INSERT_TAIL(&node->head, r, rr_ll); 782 783 p += len; 784 } 785} 786 787void 788cd9660_rrip_NM(cd9660node *node) 789{ 790 cd9660_rrip_add_NM(node, node->node->name); 791} 792 793struct ISO_SUSP_ATTRIBUTES* 794cd9660_susp_ER(cd9660node *node, 795 u_char ext_version, const char* ext_id, const char* ext_des, 796 const char* ext_src) 797{ 798 int l; 799 struct ISO_SUSP_ATTRIBUTES *r; 800 801 r = cd9660node_susp_create_node(SUSP_TYPE_SUSP, 802 SUSP_ENTRY_SUSP_ER, "ER", SUSP_LOC_DOT); 803 804 /* Fixed data is 8 bytes */ 805 r->attr.su_entry.ER.h.length[0] = 8; 806 r->attr.su_entry.ER.h.version[0] = 1; 807 808 r->attr.su_entry.ER.len_id[0] = (u_char)strlen(ext_id); 809 r->attr.su_entry.ER.len_des[0] = (u_char)strlen(ext_des); 810 r->attr.su_entry.ER.len_src[0] = (u_char)strlen(ext_src); 811 812 l = r->attr.su_entry.ER.len_id[0] + 813 r->attr.su_entry.ER.len_src[0] + 814 r->attr.su_entry.ER.len_des[0]; 815 816 /* Everything must fit. */ 817 assert(l + r->attr.su_entry.ER.h.length[0] <= 254); 818 819 r->attr.su_entry.ER.h.length[0] += (u_char)l; 820 821 822 r->attr.su_entry.ER.ext_ver[0] = ext_version; 823 memcpy(r->attr.su_entry.ER.ext_data, ext_id, 824 (int)r->attr.su_entry.ER.len_id[0]); 825 l = (int) r->attr.su_entry.ER.len_id[0]; 826 memcpy(r->attr.su_entry.ER.ext_data + l,ext_des, 827 (int)r->attr.su_entry.ER.len_des[0]); 828 829 l += (int)r->attr.su_entry.ER.len_des[0]; 830 memcpy(r->attr.su_entry.ER.ext_data + l,ext_src, 831 (int)r->attr.su_entry.ER.len_src[0]); 832 833 TAILQ_INSERT_TAIL(&node->head, r, rr_ll); 834 return r; 835} 836 837struct ISO_SUSP_ATTRIBUTES* 838cd9660_susp_ES(struct ISO_SUSP_ATTRIBUTES *last __unused, cd9660node *node __unused) 839{ 840 return NULL; 841} 842