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