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
cd9660_susp_initialize(iso9660_disk * diskStructure,cd9660node * node,cd9660node * parent,cd9660node * grandparent)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
cd9660_susp_finalize(iso9660_disk * diskStructure,cd9660node * node)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
cd9660_susp_finalize_node(iso9660_disk * diskStructure,cd9660node * node)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
cd9660_rrip_finalize_node(cd9660node * node)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
cd9660_susp_handle_continuation_common(iso9660_disk * diskStructure,cd9660node * node,int space)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
cd9660_susp_handle_continuation(iso9660_disk * diskStructure,cd9660node * node)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
cd9660_susp_initialize_node(iso9660_disk * diskStructure,cd9660node * node)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
cd9660_rrip_initialize_inode(cd9660node * node)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
cd9660_rrip_initialize_node(iso9660_disk * diskStructure,cd9660node * node,cd9660node * parent,cd9660node * grandparent)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*
cd9660node_susp_create_node(int susp_type,int entry_type,const char * type_id,int write_loc)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
cd9660_rrip_PL(struct ISO_SUSP_ATTRIBUTES * p,cd9660node * node __unused)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
cd9660_rrip_CL(struct ISO_SUSP_ATTRIBUTES * p,cd9660node * node __unused)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
cd9660_rrip_RE(struct ISO_SUSP_ATTRIBUTES * p,cd9660node * node __unused)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
cd9660_createSL(cd9660node * node)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
cd9660node_rrip_px(struct ISO_SUSP_ATTRIBUTES * v,fsnode * pxinfo)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
cd9660node_rrip_pn(struct ISO_SUSP_ATTRIBUTES * pn_field,fsnode * fnode)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
cd9660node_rrip_tf(struct ISO_SUSP_ATTRIBUTES * p,fsnode * _node)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
cd9660_susp_sp(struct ISO_SUSP_ATTRIBUTES * p,cd9660node * spinfo __unused)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
cd9660_susp_st(struct ISO_SUSP_ATTRIBUTES * p,cd9660node * stinfo __unused)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
cd9660_susp_ce(struct ISO_SUSP_ATTRIBUTES * p,cd9660node * spinfo __unused)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
cd9660_susp_pd(struct ISO_SUSP_ATTRIBUTES * p __unused,int length __unused)745 cd9660_susp_pd(struct ISO_SUSP_ATTRIBUTES *p __unused, int length __unused)
746 {
747 return 1;
748 }
749
750 void
cd9660_rrip_add_NM(cd9660node * node,const char * name)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
cd9660_rrip_NM(cd9660node * node)787 cd9660_rrip_NM(cd9660node *node)
788 {
789 cd9660_rrip_add_NM(node, node->node->name);
790 }
791
792 struct ISO_SUSP_ATTRIBUTES*
cd9660_susp_ER(cd9660node * node,u_char ext_version,const char * ext_id,const char * ext_des,const char * ext_src)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*
cd9660_susp_ES(struct ISO_SUSP_ATTRIBUTES * last __unused,cd9660node * node __unused)837 cd9660_susp_ES(struct ISO_SUSP_ATTRIBUTES *last __unused, cd9660node *node __unused)
838 {
839 return NULL;
840 }
841