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