usr.sbin/makefs/cd9660/iso9660_rrip.c

   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
  52 static void cd9660_rrip_initialize_inode(cd9660node *);
  53 static int cd9660_susp_handle_continuation(iso9660_disk *, cd9660node *);
  54 static int cd9660_susp_handle_continuation_common(iso9660_disk *, cd9660node *,
  55     int);
  56
  57 int
  58 cd9660_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
 102 int
 103 cd9660_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  */
 138 int
 139 cd9660_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
 172 int
 173 cd9660_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
 205 static int
 206 cd9660_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 */
 285 static int
 286 cd9660_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
 298 int
 299 cd9660_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
 327 static void
 328 cd9660_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
 373 int
 374 cd9660_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
 458 struct ISO_SUSP_ATTRIBUTES*
 459 cd9660node_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
 483 int
 484 cd9660_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
 491 int
 492 cd9660_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
 499 int
 500 cd9660_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
 507 void
 508 cd9660_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
 637 int
 638 cd9660node_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
 656 int
 657 cd9660node_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
 675 int
 676 cd9660node_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
 689 int
 690 cd9660node_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
 715 int
 716 cd9660_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
 726 int
 727 cd9660_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
 736 int
 737 cd9660_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
 745 int
 746 cd9660_susp_pd(struct ISO_SUSP_ATTRIBUTES *p __unused, int length __unused)
 747 {
 748         return 1;
 749 }
 750
 751 void
 752 cd9660_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
 787 void
 788 cd9660_rrip_NM(cd9660node *node)
 789 {
 790         cd9660_rrip_add_NM(node, node->node->name);
 791 }
 792
 793 struct ISO_SUSP_ATTRIBUTES*
 794 cd9660_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
 837 struct ISO_SUSP_ATTRIBUTES*
 838 cd9660_susp_ES(struct ISO_SUSP_ATTRIBUTES *last __unused, cd9660node *node __unused)
 839 {
 840         return NULL;
 841 }