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