1 /* $NetBSD: iso9660_rrip.c,v 1.11 2012/04/29 13:32:21 joerg Exp $ */
4 * Copyright (c) 2005 Daniel Watt, Walter Deignan, Ryan Gabrys, Alan
5 * Perez-Rathke and Ram Vedam. All rights reserved.
7 * This code was written by Daniel Watt, Walter Deignan, Ryan Gabrys,
8 * Alan Perez-Rathke and Ram Vedam.
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer in the documentation and/or other materials provided
18 * with the distribution.
20 * THIS SOFTWARE IS PROVIDED BY DANIEL WATT, WALTER DEIGNAN, RYAN
21 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM ``AS IS'' AND ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 * DISCLAIMED. IN NO EVENT SHALL DANIEL WATT, WALTER DEIGNAN, RYAN
25 * GABRYS, ALAN PEREZ-RATHKE AND RAM VEDAM BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
28 * USE,DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
29 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
34 /* This will hold all the function definitions
35 * defined in iso9660_rrip.h
40 #include "iso9660_rrip.h"
41 #include <sys/queue.h>
44 #include <sys/cdefs.h>
45 __FBSDID("$FreeBSD$");
47 static void cd9660_rrip_initialize_inode(cd9660node *);
48 static int cd9660_susp_handle_continuation(cd9660node *);
49 static int cd9660_susp_handle_continuation_common(cd9660node *, int);
52 cd9660_susp_initialize(cd9660node *node, cd9660node *parent,
53 cd9660node *grandparent)
58 /* Make sure the node is not NULL. If it is, there are major problems */
61 if (!(node->type & CD9660_TYPE_DOT) &&
62 !(node->type & CD9660_TYPE_DOTDOT))
63 TAILQ_INIT(&(node->head));
64 if (node->dot_record != 0)
65 TAILQ_INIT(&(node->dot_record->head));
66 if (node->dot_dot_record != 0)
67 TAILQ_INIT(&(node->dot_dot_record->head));
69 /* SUSP specific entries here */
70 if ((r = cd9660_susp_initialize_node(node)) < 0)
73 /* currently called cd9660node_rrip_init_links */
74 r = cd9660_rrip_initialize_node(node, parent, grandparent);
79 * See if we need a CE record, and set all of the
80 * associated counters.
82 * This should be called after all extensions. After
83 * this is called, no new records should be added.
85 if ((r = cd9660_susp_handle_continuation(node)) < 0)
88 /* Recurse on children. */
89 TAILQ_FOREACH(cn, &node->cn_children, cn_next_child) {
90 if ((r = cd9660_susp_initialize(cn, node, parent)) < 0)
97 cd9660_susp_finalize(cd9660node *node)
102 assert(node != NULL);
104 if (node == diskStructure.rootNode)
105 diskStructure.susp_continuation_area_current_free = 0;
107 if ((r = cd9660_susp_finalize_node(node)) < 0)
109 if ((r = cd9660_rrip_finalize_node(node)) < 0)
112 TAILQ_FOREACH(temp, &node->cn_children, cn_next_child) {
113 if ((r = cd9660_susp_finalize(temp)) < 0)
120 * If we really wanted to speed things up, we could have some sort of
121 * lookup table on the SUSP entry type that calls a functor. Or, we could
122 * combine the functions. These functions are kept separate to allow
123 * easier addition of other extensions.
125 * For the sake of simplicity and clarity, we won't be doing that for now.
129 * SUSP needs to update the following types:
130 * CE (continuation area)
133 cd9660_susp_finalize_node(cd9660node *node)
135 struct ISO_SUSP_ATTRIBUTES *t;
137 /* Handle CE counters */
138 if (node->susp_entry_ce_length > 0) {
139 node->susp_entry_ce_start =
140 diskStructure.susp_continuation_area_current_free;
141 diskStructure.susp_continuation_area_current_free +=
142 node->susp_entry_ce_length;
145 TAILQ_FOREACH(t, &node->head, rr_ll) {
146 if (t->susp_type != SUSP_TYPE_SUSP ||
147 t->entry_type != SUSP_ENTRY_SUSP_CE)
149 cd9660_bothendian_dword(
151 susp_continuation_area_start_sector,
152 t->attr.su_entry.CE.ca_sector);
154 cd9660_bothendian_dword(
156 susp_continuation_area_start_sector,
157 t->attr.su_entry.CE.ca_sector);
158 cd9660_bothendian_dword(node->susp_entry_ce_start,
159 t->attr.su_entry.CE.offset);
160 cd9660_bothendian_dword(node->susp_entry_ce_length,
161 t->attr.su_entry.CE.length);
167 cd9660_rrip_finalize_node(cd9660node *node)
169 struct ISO_SUSP_ATTRIBUTES *t;
171 TAILQ_FOREACH(t, &node->head, rr_ll) {
172 if (t->susp_type != SUSP_TYPE_RRIP)
174 switch (t->entry_type) {
175 case SUSP_ENTRY_RRIP_CL:
176 /* Look at rr_relocated*/
177 if (node->rr_relocated == NULL)
179 cd9660_bothendian_dword(
180 node->rr_relocated->fileDataSector,
182 t->attr.rr_entry.CL.dir_loc);
184 case SUSP_ENTRY_RRIP_PL:
185 /* Look at rr_real_parent */
186 if (node->parent == NULL ||
187 node->parent->rr_real_parent == NULL)
189 cd9660_bothendian_dword(
190 node->parent->rr_real_parent->fileDataSector,
192 t->attr.rr_entry.PL.dir_loc);
200 cd9660_susp_handle_continuation_common(cd9660node *node, int space)
202 int ca_used, susp_used, susp_used_pre_ce, working;
203 struct ISO_SUSP_ATTRIBUTES *temp, *pre_ce, *last, *CE, *ST;
205 pre_ce = last = NULL;
206 working = 254 - space;
207 if (node->su_tail_size > 0)
208 /* Allow 4 bytes for "ST" record. */
209 working -= node->su_tail_size + 4;
210 /* printf("There are %i bytes to work with\n",working); */
212 susp_used_pre_ce = susp_used = 0;
214 TAILQ_FOREACH(temp, &node->head, rr_ll) {
218 * printf("SUSP Entry found, length is %i\n",
219 * CD9660_SUSP_ENTRY_SIZE(temp));
221 working -= CD9660_SUSP_ENTRY_SIZE(temp);
224 susp_used += CD9660_SUSP_ENTRY_SIZE(temp);
228 * Remember the last entry after which we
229 * could insert a "CE" entry.
232 susp_used_pre_ce = susp_used;
236 /* A CE entry is needed */
238 CE = cd9660node_susp_create_node(SUSP_TYPE_SUSP,
239 SUSP_ENTRY_SUSP_CE, "CE", SUSP_LOC_ENTRY);
240 cd9660_susp_ce(CE, node);
241 /* This will automatically insert at the appropriate location */
243 TAILQ_INSERT_AFTER(&node->head, pre_ce, CE, rr_ll);
245 TAILQ_INSERT_HEAD(&node->head, CE, rr_ll);
247 susp_used = susp_used_pre_ce + 28;
248 /* Count how much CA data is necessary */
249 for (temp = TAILQ_NEXT(last, rr_ll); temp != NULL;
250 temp = TAILQ_NEXT(temp, rr_ll)) {
251 ca_used += CD9660_SUSP_ENTRY_SIZE(temp);
255 /* An ST entry is needed */
256 if (node->su_tail_size > 0) {
257 ST = cd9660node_susp_create_node(SUSP_TYPE_SUSP,
258 SUSP_ENTRY_SUSP_ST, "ST", SUSP_LOC_ENTRY);
259 cd9660_susp_st(ST, node);
261 TAILQ_INSERT_AFTER(&node->head, last, ST, rr_ll);
263 TAILQ_INSERT_HEAD(&node->head, ST, rr_ll);
268 last->last_in_suf = 1;
270 node->susp_entry_size = susp_used;
271 node->susp_entry_ce_length = ca_used;
273 diskStructure.susp_continuation_area_size += ca_used;
277 /* See if a continuation entry is needed for each of the different types */
279 cd9660_susp_handle_continuation(cd9660node *node)
281 assert (node != NULL);
284 if (cd9660_susp_handle_continuation_common(
285 node,(int)(node->isoDirRecord->length[0])) < 0)
292 cd9660_susp_initialize_node(cd9660node *node)
294 struct ISO_SUSP_ATTRIBUTES *temp;
297 * Requirements/notes:
298 * CE: is added for us where needed
299 * ST: not sure if it is even required, but if so, should be
300 * handled by the CE code
301 * PD: isn't needed (though might be added for testing)
302 * SP: is stored ONLY on the . record of the root directory
306 /* Check for root directory, add SP and ER if needed. */
307 if (node->type & CD9660_TYPE_DOT) {
308 if (node->parent == diskStructure.rootNode) {
309 temp = cd9660node_susp_create_node(SUSP_TYPE_SUSP,
310 SUSP_ENTRY_SUSP_SP, "SP", SUSP_LOC_DOT);
311 cd9660_susp_sp(temp, node);
313 /* Should be first entry. */
314 TAILQ_INSERT_HEAD(&node->head, temp, rr_ll);
321 cd9660_rrip_initialize_inode(cd9660node *node)
323 struct ISO_SUSP_ATTRIBUTES *attr;
326 * Inode dependent values - this may change,
327 * but for now virtual files and directories do
328 * not have an inode structure
331 if ((node->node != NULL) && (node->node->inode != NULL)) {
332 /* PX - POSIX attributes */
333 attr = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
334 SUSP_ENTRY_RRIP_PX, "PX", SUSP_LOC_ENTRY);
335 cd9660node_rrip_px(attr, node->node);
337 TAILQ_INSERT_TAIL(&node->head, attr, rr_ll);
340 attr = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
341 SUSP_ENTRY_RRIP_TF, "TF", SUSP_LOC_ENTRY);
342 cd9660node_rrip_tf(attr, node->node);
343 TAILQ_INSERT_TAIL(&node->head, attr, rr_ll);
345 /* SL - Symbolic link */
346 /* ?????????? Dan - why is this here? */
347 if (TAILQ_EMPTY(&node->cn_children) &&
348 node->node->inode != NULL &&
349 S_ISLNK(node->node->inode->st.st_mode))
350 cd9660_createSL(node);
352 /* PN - device number */
353 if (node->node->inode != NULL &&
354 ((S_ISCHR(node->node->inode->st.st_mode) ||
355 S_ISBLK(node->node->inode->st.st_mode)))) {
357 cd9660node_susp_create_node(SUSP_TYPE_RRIP,
358 SUSP_ENTRY_RRIP_PN, "PN",
360 cd9660node_rrip_pn(attr, node->node);
361 TAILQ_INSERT_TAIL(&node->head, attr, rr_ll);
367 cd9660_rrip_initialize_node(cd9660node *node, cd9660node *parent,
368 cd9660node *grandparent)
370 struct ISO_SUSP_ATTRIBUTES *current = NULL;
372 assert(node != NULL);
374 if (node->type & CD9660_TYPE_DOT) {
376 * Handle ER - should be the only entry to appear on
379 if (node->parent == diskStructure.rootNode) {
380 cd9660_susp_ER(node, 1, SUSP_RRIP_ER_EXT_ID,
381 SUSP_RRIP_ER_EXT_DES, SUSP_RRIP_ER_EXT_SRC);
383 if (parent != NULL && parent->node != NULL &&
384 parent->node->inode != NULL) {
385 /* PX - POSIX attributes */
386 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
387 SUSP_ENTRY_RRIP_PX, "PX", SUSP_LOC_ENTRY);
388 cd9660node_rrip_px(current, parent->node);
389 TAILQ_INSERT_TAIL(&node->head, current, rr_ll);
391 } else if (node->type & CD9660_TYPE_DOTDOT) {
392 if (grandparent != NULL && grandparent->node != NULL &&
393 grandparent->node->inode != NULL) {
394 /* PX - POSIX attributes */
395 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
396 SUSP_ENTRY_RRIP_PX, "PX", SUSP_LOC_ENTRY);
397 cd9660node_rrip_px(current, grandparent->node);
398 TAILQ_INSERT_TAIL(&node->head, current, rr_ll);
401 if (parent != NULL && parent->rr_real_parent != NULL) {
402 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
403 SUSP_ENTRY_RRIP_PL, "PL", SUSP_LOC_DOTDOT);
404 cd9660_rrip_PL(current,node);
405 TAILQ_INSERT_TAIL(&node->head, current, rr_ll);
408 cd9660_rrip_initialize_inode(node);
411 * Not every node needs a NM set - only if the name is
412 * actually different. IE: If a file is TEST -> TEST,
413 * no NM. test -> TEST, need a NM
415 * The rr_moved_dir needs to be assigned a NM record as well.
417 if (node == diskStructure.rr_moved_dir) {
418 cd9660_rrip_add_NM(node, RRIP_DEFAULT_MOVE_DIR_NAME);
420 else if ((node->node != NULL) &&
421 ((strlen(node->node->name) !=
422 (uint8_t)node->isoDirRecord->name_len[0]) ||
423 (memcmp(node->node->name,node->isoDirRecord->name,
424 (uint8_t)node->isoDirRecord->name_len[0]) != 0))) {
425 cd9660_rrip_NM(node);
430 /* Rock ridge directory relocation code here. */
432 /* First handle the CL for the placeholder file. */
433 if (node->rr_relocated != NULL) {
434 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
435 SUSP_ENTRY_RRIP_CL, "CL", SUSP_LOC_ENTRY);
436 cd9660_rrip_CL(current, node);
437 TAILQ_INSERT_TAIL(&node->head, current, rr_ll);
441 if (node->rr_real_parent != NULL) {
442 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
443 SUSP_ENTRY_RRIP_RE, "RE", SUSP_LOC_ENTRY);
444 cd9660_rrip_RE(current,node);
445 TAILQ_INSERT_TAIL(&node->head, current, rr_ll);
451 struct ISO_SUSP_ATTRIBUTES*
452 cd9660node_susp_create_node(int susp_type, int entry_type, const char *type_id,
455 struct ISO_SUSP_ATTRIBUTES* temp;
457 if ((temp = malloc(sizeof(struct ISO_SUSP_ATTRIBUTES))) == NULL) {
458 CD9660_MEM_ALLOC_ERROR("cd9660node_susp_create_node");
462 temp->susp_type = susp_type;
463 temp->entry_type = entry_type;
464 temp->last_in_suf = 0;
466 temp->type_of[0] = type_id[0];
467 temp->type_of[1] = type_id[1];
468 temp->write_location = write_loc;
471 * Since the first four bytes is common, lets go ahead and
472 * set the type identifier, since we are passing that to this
475 temp->attr.su_entry.SP.h.type[0] = type_id[0];
476 temp->attr.su_entry.SP.h.type[1] = type_id[1];
481 cd9660_rrip_PL(struct ISO_SUSP_ATTRIBUTES* p, cd9660node *node __unused)
483 p->attr.rr_entry.PL.h.length[0] = 12;
484 p->attr.rr_entry.PL.h.version[0] = 1;
489 cd9660_rrip_CL(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *node __unused)
491 p->attr.rr_entry.CL.h.length[0] = 12;
492 p->attr.rr_entry.CL.h.version[0] = 1;
497 cd9660_rrip_RE(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *node __unused)
499 p->attr.rr_entry.RE.h.length[0] = 4;
500 p->attr.rr_entry.RE.h.version[0] = 1;
505 cd9660_createSL(cd9660node *node)
507 struct ISO_SUSP_ATTRIBUTES* current;
508 int path_count, dir_count, done, i, j, dir_copied;
510 char temp_sl[255]; /* used in copying continuation entry*/
513 sl_ptr = node->node->symlink;
519 current = cd9660node_susp_create_node(SUSP_TYPE_RRIP,
520 SUSP_ENTRY_RRIP_SL, "SL", SUSP_LOC_ENTRY);
522 current->attr.rr_entry.SL.h.version[0] = 1;
523 current->attr.rr_entry.SL.flags[0] = SL_FLAGS_NONE;
525 if (*sl_ptr == '/') {
526 temp_cr[0] = SL_FLAGS_ROOT;
528 memcpy(current->attr.rr_entry.SL.component + path_count,
534 for (i = 0; i < (dir_count + 2); i++)
538 while ((*sl_ptr != '/') && (*sl_ptr != '\0')) {
540 if (*sl_ptr == '.') {
541 if ((*(sl_ptr + 1) == '/') || (*(sl_ptr + 1)
543 temp_cr[0] = SL_FLAGS_CURRENT;
545 } else if(*(sl_ptr + 1) == '.') {
546 if ((*(sl_ptr + 2) == '/') ||
547 (*(sl_ptr + 2) == '\0')) {
548 temp_cr[0] = SL_FLAGS_PARENT;
552 temp_cr[dir_count+2] = *sl_ptr;
557 temp_cr[dir_count + 2] = *sl_ptr;
563 if ((path_count + dir_count) >= 249) {
564 current->attr.rr_entry.SL.flags[0] |= SL_FLAGS_CONTINUE;
568 if (path_count <= 249) {
569 while(j != (249 - path_count)) {
570 temp_sl[j] = temp_cr[j];
573 temp_sl[0] = SL_FLAGS_CONTINUE;
576 current->attr.rr_entry.SL.component +
582 current->attr.rr_entry.SL.h.length[0] = path_count + 5;
583 TAILQ_INSERT_TAIL(&node->head, current, rr_ll);
584 current= cd9660node_susp_create_node(SUSP_TYPE_RRIP,
585 SUSP_ENTRY_RRIP_SL, "SL", SUSP_LOC_ENTRY);
586 current->attr.rr_entry.SL.h.version[0] = 1;
587 current->attr.rr_entry.SL.flags[0] = SL_FLAGS_NONE;
592 while (j != dir_count + 2) {
593 current->attr.rr_entry.SL.component[
594 path_count + 2] = temp_cr[j];
598 current->attr.rr_entry.SL.component[1]
602 while(j != dir_count) {
603 current->attr.rr_entry.SL.component[
604 path_count+2] = temp_cr[j];
610 if (dir_copied == 1) {
611 temp_cr[1] = dir_count;
612 memcpy(current->attr.rr_entry.SL.component +
614 temp_cr, dir_count + 2);
615 path_count += dir_count + 2;
619 if (*sl_ptr == '\0') {
621 current->attr.rr_entry.SL.h.length[0] = path_count + 5;
622 TAILQ_INSERT_TAIL(&node->head, current, rr_ll);
627 for(i = 0; i < 255; i++) {
635 cd9660node_rrip_px(struct ISO_SUSP_ATTRIBUTES *v, fsnode *pxinfo)
637 v->attr.rr_entry.PX.h.length[0] = 44;
638 v->attr.rr_entry.PX.h.version[0] = 1;
639 cd9660_bothendian_dword(pxinfo->inode->st.st_mode,
640 v->attr.rr_entry.PX.mode);
641 cd9660_bothendian_dword(pxinfo->inode->st.st_nlink,
642 v->attr.rr_entry.PX.links);
643 cd9660_bothendian_dword(pxinfo->inode->st.st_uid,
644 v->attr.rr_entry.PX.uid);
645 cd9660_bothendian_dword(pxinfo->inode->st.st_gid,
646 v->attr.rr_entry.PX.gid);
647 cd9660_bothendian_dword(pxinfo->inode->st.st_ino,
648 v->attr.rr_entry.PX.serial);
654 cd9660node_rrip_pn(struct ISO_SUSP_ATTRIBUTES *pn_field, fsnode *fnode)
656 pn_field->attr.rr_entry.PN.h.length[0] = 20;
657 pn_field->attr.rr_entry.PN.h.version[0] = 1;
659 if (sizeof (fnode->inode->st.st_dev) > 32)
660 cd9660_bothendian_dword((uint64_t)fnode->inode->st.st_dev >> 32,
661 pn_field->attr.rr_entry.PN.high);
663 cd9660_bothendian_dword(0, pn_field->attr.rr_entry.PN.high);
665 cd9660_bothendian_dword(fnode->inode->st.st_dev & 0xffffffff,
666 pn_field->attr.rr_entry.PN.low);
672 cd9660node_rrip_nm(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *file_node)
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;
686 cd9660node_rrip_tf(struct ISO_SUSP_ATTRIBUTES *p, fsnode *_node)
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;
693 * Need to add creation time, backup time,
694 * expiration time, and effective time.
697 cd9660_time_915(p->attr.rr_entry.TF.timestamp,
698 _node->inode->st.st_atime);
699 p->attr.rr_entry.TF.h.length[0] += 7;
701 cd9660_time_915(p->attr.rr_entry.TF.timestamp + 7,
702 _node->inode->st.st_mtime);
703 p->attr.rr_entry.TF.h.length[0] += 7;
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;
712 cd9660_susp_sp(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *spinfo __unused)
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;
723 cd9660_susp_st(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *stinfo __unused)
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;
733 cd9660_susp_ce(struct ISO_SUSP_ATTRIBUTES *p, cd9660node *spinfo __unused)
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 */
742 cd9660_susp_pd(struct ISO_SUSP_ATTRIBUTES *p __unused, int length __unused)
748 cd9660_rrip_add_NM(cd9660node *node, const char *name)
752 struct ISO_SUSP_ATTRIBUTES *r;
755 * Each NM record has 254 byes 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.
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;
770 r->attr.rr_entry.NM.flags[0] = RRIP_NM_FLAGS_CONTINUE;
774 memcpy(r->attr.rr_entry.NM.altname, p, len);
775 r->attr.rr_entry.NM.h.length[0] = 5 + len;
777 TAILQ_INSERT_TAIL(&node->head, r, rr_ll);
784 cd9660_rrip_NM(cd9660node *node)
786 cd9660_rrip_add_NM(node, node->node->name);
789 struct ISO_SUSP_ATTRIBUTES*
790 cd9660_susp_ER(cd9660node *node,
791 u_char ext_version, const char* ext_id, const char* ext_des,
795 struct ISO_SUSP_ATTRIBUTES *r;
797 r = cd9660node_susp_create_node(SUSP_TYPE_SUSP,
798 SUSP_ENTRY_SUSP_ER, "ER", SUSP_LOC_DOT);
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;
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);
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];
812 /* Everything must fit. */
813 assert(l + r->attr.su_entry.ER.h.length[0] <= 254);
815 r->attr.su_entry.ER.h.length[0] += (u_char)l;
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]);
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]);
829 TAILQ_INSERT_TAIL(&node->head, r, rr_ll);
833 struct ISO_SUSP_ATTRIBUTES*
834 cd9660_susp_ES(struct ISO_SUSP_ATTRIBUTES *last __unused, cd9660node *node __unused)