2 * Copyright (c) 2003-2007 Tim Kientzle
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_support_format_iso9660.c,v 1.20 2007/03/03 07:37:36 kientzle Exp $");
29 #ifdef HAVE_SYS_STAT_H
36 /* #include <stdint.h> */ /* See archive_platform.h */
50 #include "archive_entry.h"
51 #include "archive_private.h"
52 #include "archive_read_private.h"
53 #include "archive_string.h"
56 * An overview of ISO 9660 format:
58 * Each disk is laid out as follows:
59 * * 32k reserved for private use
60 * * Volume descriptor table. Each volume descriptor
61 * is 2k and specifies basic format information.
62 * The "Primary Volume Descriptor" (PVD) is defined by the
63 * standard and should always be present; other volume
64 * descriptors include various vendor-specific extensions.
65 * * Files and directories. Each file/dir is specified by
66 * an "extent" (starting sector and length in bytes).
67 * Dirs are just files with directory records packed one
68 * after another. The PVD contains a single dir entry
69 * specifying the location of the root directory. Everything
70 * else follows from there.
72 * This module works by first reading the volume descriptors, then
73 * building a list of directory entries, sorted by starting
74 * sector. At each step, I look for the earliest dir entry that
75 * hasn't yet been read, seek forward to that location and read
76 * that entry. If it's a dir, I slurp in the new dir entries and
77 * add them to the heap; if it's a regular file, I return the
78 * corresponding archive_entry and wait for the client to request
79 * the file body. This strategy allows us to read most compliant
80 * CDs with a single pass through the data, as required by libarchive.
83 /* Structure of on-disk primary volume descriptor. */
84 #define PVD_type_offset 0
85 #define PVD_type_size 1
86 #define PVD_id_offset (PVD_type_offset + PVD_type_size)
88 #define PVD_version_offset (PVD_id_offset + PVD_id_size)
89 #define PVD_version_size 1
90 #define PVD_reserved1_offset (PVD_version_offset + PVD_version_size)
91 #define PVD_reserved1_size 1
92 #define PVD_system_id_offset (PVD_reserved1_offset + PVD_reserved1_size)
93 #define PVD_system_id_size 32
94 #define PVD_volume_id_offset (PVD_system_id_offset + PVD_system_id_size)
95 #define PVD_volume_id_size 32
96 #define PVD_reserved2_offset (PVD_volume_id_offset + PVD_volume_id_size)
97 #define PVD_reserved2_size 8
98 #define PVD_volume_space_size_offset (PVD_reserved2_offset + PVD_reserved2_size)
99 #define PVD_volume_space_size_size 8
100 #define PVD_reserved3_offset (PVD_volume_space_size_offset + PVD_volume_space_size_size)
101 #define PVD_reserved3_size 32
102 #define PVD_volume_set_size_offset (PVD_reserved3_offset + PVD_reserved3_size)
103 #define PVD_volume_set_size_size 4
104 #define PVD_volume_sequence_number_offset (PVD_volume_set_size_offset + PVD_volume_set_size_size)
105 #define PVD_volume_sequence_number_size 4
106 #define PVD_logical_block_size_offset (PVD_volume_sequence_number_offset + PVD_volume_sequence_number_size)
107 #define PVD_logical_block_size_size 4
108 #define PVD_path_table_size_offset (PVD_logical_block_size_offset + PVD_logical_block_size_size)
109 #define PVD_path_table_size_size 8
110 #define PVD_type_1_path_table_offset (PVD_path_table_size_offset + PVD_path_table_size_size)
111 #define PVD_type_1_path_table_size 4
112 #define PVD_opt_type_1_path_table_offset (PVD_type_1_path_table_offset + PVD_type_1_path_table_size)
113 #define PVD_opt_type_1_path_table_size 4
114 #define PVD_type_m_path_table_offset (PVD_opt_type_1_path_table_offset + PVD_opt_type_1_path_table_size)
115 #define PVD_type_m_path_table_size 4
116 #define PVD_opt_type_m_path_table_offset (PVD_type_m_path_table_offset + PVD_type_m_path_table_size)
117 #define PVD_opt_type_m_path_table_size 4
118 #define PVD_root_directory_record_offset (PVD_opt_type_m_path_table_offset + PVD_opt_type_m_path_table_size)
119 #define PVD_root_directory_record_size 34
120 #define PVD_volume_set_id_offset (PVD_root_directory_record_offset + PVD_root_directory_record_size)
121 #define PVD_volume_set_id_size 128
122 #define PVD_publisher_id_offset (PVD_volume_set_id_offset + PVD_volume_set_id_size)
123 #define PVD_publisher_id_size 128
124 #define PVD_preparer_id_offset (PVD_publisher_id_offset + PVD_publisher_id_size)
125 #define PVD_preparer_id_size 128
126 #define PVD_application_id_offset (PVD_preparer_id_offset + PVD_preparer_id_size)
127 #define PVD_application_id_size 128
128 #define PVD_copyright_file_id_offset (PVD_application_id_offset + PVD_application_id_size)
129 #define PVD_copyright_file_id_size 37
130 #define PVD_abstract_file_id_offset (PVD_copyright_file_id_offset + PVD_copyright_file_id_size)
131 #define PVD_abstract_file_id_size 37
132 #define PVD_bibliographic_file_id_offset (PVD_abstract_file_id_offset + PVD_abstract_file_id_size)
133 #define PVD_bibliographic_file_id_size 37
134 #define PVD_creation_date_offset (PVD_bibliographic_file_id_offset + PVD_bibliographic_file_id_size)
135 #define PVD_creation_date_size 17
136 #define PVD_modification_date_offset (PVD_creation_date_offset + PVD_creation_date_size)
137 #define PVD_modification_date_size 17
138 #define PVD_expiration_date_offset (PVD_modification_date_offset + PVD_modification_date_size)
139 #define PVD_expiration_date_size 17
140 #define PVD_effective_date_offset (PVD_expiration_date_offset + PVD_expiration_date_size)
141 #define PVD_effective_date_size 17
142 #define PVD_file_structure_version_offset (PVD_effective_date_offset + PVD_effective_date_size)
143 #define PVD_file_structure_version_size 1
144 #define PVD_reserved4_offset (PVD_file_structure_version_offset + PVD_file_structure_version_size)
145 #define PVD_reserved4_size 1
146 #define PVD_application_data_offset (PVD_reserved4_offset + PVD_reserved4_size)
147 #define PVD_application_data_size 512
149 /* Structure of an on-disk directory record. */
150 /* Note: ISO9660 stores each multi-byte integer twice, once in
151 * each byte order. The sizes here are the size of just one
152 * of the two integers. (This is why the offset of a field isn't
153 * the same as the offset+size of the previous field.) */
154 #define DR_length_offset 0
155 #define DR_length_size 1
156 #define DR_ext_attr_length_offset 1
157 #define DR_ext_attr_length_size 1
158 #define DR_extent_offset 2
159 #define DR_extent_size 4
160 #define DR_size_offset 10
161 #define DR_size_size 4
162 #define DR_date_offset 18
163 #define DR_date_size 7
164 #define DR_flags_offset 25
165 #define DR_flags_size 1
166 #define DR_file_unit_size_offset 26
167 #define DR_file_unit_size_size 1
168 #define DR_interleave_offset 27
169 #define DR_interleave_size 1
170 #define DR_volume_sequence_number_offset 28
171 #define DR_volume_sequence_number_size 2
172 #define DR_name_len_offset 32
173 #define DR_name_len_size 1
174 #define DR_name_offset 33
180 /* In-memory storage for a directory record. */
182 struct file_info
*parent
;
184 uint64_t offset
; /* Offset on disk. */
185 uint64_t size
; /* File size in bytes. */
186 uint64_t ce_offset
; /* Offset of CE */
187 uint64_t ce_size
; /* Size of CE */
188 time_t mtime
; /* File last modified time. */
189 time_t atime
; /* File last accessed time. */
190 time_t ctime
; /* File creation time. */
196 char *name
; /* Null-terminated filename. */
197 struct archive_string symlink
;
203 #define ISO9660_MAGIC 0x96609660
204 int bid
; /* If non-zero, return this as our bid. */
205 struct archive_string pathname
;
206 char seenRockridge
; /* Set true if RR extensions are used. */
207 unsigned char suspOffset
;
209 uint64_t previous_offset
;
210 uint64_t previous_size
;
211 struct archive_string previous_pathname
;
213 /* TODO: Make this a heap for fast inserts and deletions. */
214 struct file_info
**pending_files
;
215 int pending_files_allocated
;
216 int pending_files_used
;
218 uint64_t current_position
;
219 ssize_t logical_block_size
;
221 off_t entry_sparse_offset
;
222 int64_t entry_bytes_remaining
;
225 static void add_entry(struct iso9660
*iso9660
, struct file_info
*file
);
226 static int archive_read_format_iso9660_bid(struct archive_read
*);
227 static int archive_read_format_iso9660_cleanup(struct archive_read
*);
228 static int archive_read_format_iso9660_read_data(struct archive_read
*,
229 const void **, size_t *, off_t
*);
230 static int archive_read_format_iso9660_read_data_skip(struct archive_read
*);
231 static int archive_read_format_iso9660_read_header(struct archive_read
*,
232 struct archive_entry
*);
233 static const char *build_pathname(struct archive_string
*, struct file_info
*);
234 static void dump_isodirrec(FILE *, const unsigned char *isodirrec
);
235 static time_t time_from_tm(struct tm
*);
236 static time_t isodate17(const unsigned char *);
237 static time_t isodate7(const unsigned char *);
238 static int isPVD(struct iso9660
*, const unsigned char *);
239 static struct file_info
*next_entry(struct iso9660
*);
240 static int next_entry_seek(struct archive_read
*a
, struct iso9660
*iso9660
,
241 struct file_info
**pfile
);
242 static struct file_info
*
243 parse_file_info(struct iso9660
*iso9660
,
244 struct file_info
*parent
, const unsigned char *isodirrec
);
245 static void parse_rockridge(struct iso9660
*iso9660
,
246 struct file_info
*file
, const unsigned char *start
,
247 const unsigned char *end
);
248 static void release_file(struct iso9660
*, struct file_info
*);
249 static unsigned toi(const void *p
, int n
);
252 archive_read_support_format_iso9660(struct archive
*_a
)
254 struct archive_read
*a
= (struct archive_read
*)_a
;
255 struct iso9660
*iso9660
;
258 iso9660
= (struct iso9660
*)malloc(sizeof(*iso9660
));
259 if (iso9660
== NULL
) {
260 archive_set_error(&a
->archive
, ENOMEM
, "Can't allocate iso9660 data");
261 return (ARCHIVE_FATAL
);
263 memset(iso9660
, 0, sizeof(*iso9660
));
264 iso9660
->magic
= ISO9660_MAGIC
;
265 iso9660
->bid
= -1; /* We haven't yet bid. */
267 r
= __archive_read_register_format(a
,
269 archive_read_format_iso9660_bid
,
270 archive_read_format_iso9660_read_header
,
271 archive_read_format_iso9660_read_data
,
272 archive_read_format_iso9660_read_data_skip
,
273 archive_read_format_iso9660_cleanup
);
275 if (r
!= ARCHIVE_OK
) {
284 archive_read_format_iso9660_bid(struct archive_read
*a
)
286 struct iso9660
*iso9660
;
291 iso9660
= (struct iso9660
*)*(a
->pformat_data
);
293 if (iso9660
->bid
>= 0)
294 return (iso9660
->bid
);
297 * Skip the first 32k (reserved area) and get the first
298 * 8 sectors of the volume descriptor table. Of course,
299 * if the I/O layer gives us more, we'll take it.
301 bytes_read
= (a
->compression_read_ahead
)(a
, &h
, 32768 + 8*2048);
302 if (bytes_read
< 32768 + 8*2048)
303 return (iso9660
->bid
= -1);
306 /* Skip the reserved area. */
310 /* Check each volume descriptor to locate the PVD. */
311 for (; bytes_read
> 2048; bytes_read
-= 2048, p
+= 2048) {
312 iso9660
->bid
= isPVD(iso9660
, p
);
313 if (iso9660
->bid
> 0)
314 return (iso9660
->bid
);
315 if (*p
== '\xff') /* End-of-volume-descriptor marker. */
319 /* We didn't find a valid PVD; return a bid of zero. */
321 return (iso9660
->bid
);
325 isPVD(struct iso9660
*iso9660
, const unsigned char *h
)
327 struct file_info
*file
;
331 if (memcmp(h
+1, "CD001", 5) != 0)
334 iso9660
->logical_block_size
= toi(h
+ PVD_logical_block_size_offset
, 2);
336 /* Store the root directory in the pending list. */
337 file
= parse_file_info(iso9660
, NULL
, h
+ PVD_root_directory_record_offset
);
338 add_entry(iso9660
, file
);
343 archive_read_format_iso9660_read_header(struct archive_read
*a
,
344 struct archive_entry
*entry
)
347 struct iso9660
*iso9660
;
348 struct file_info
*file
;
352 iso9660
= (struct iso9660
*)*(a
->pformat_data
);
354 if (!a
->archive
.archive_format
) {
355 a
->archive
.archive_format
= ARCHIVE_FORMAT_ISO9660
;
356 a
->archive
.archive_format_name
= "ISO9660";
359 /* Get the next entry that appears after the current offset. */
360 r
= next_entry_seek(a
, iso9660
, &file
);
364 iso9660
->entry_bytes_remaining
= file
->size
;
365 iso9660
->entry_sparse_offset
= 0; /* Offset for sparse-file-aware clients. */
367 /* Set up the entry structure with information about this entry. */
368 memset(&st
, 0, sizeof(st
));
369 st
.st_mode
= file
->mode
;
370 st
.st_uid
= file
->uid
;
371 st
.st_gid
= file
->gid
;
372 st
.st_nlink
= file
->nlinks
;
373 st
.st_ino
= file
->inode
;
374 st
.st_mtime
= file
->mtime
;
375 st
.st_ctime
= file
->ctime
;
376 st
.st_atime
= file
->atime
;
377 st
.st_size
= iso9660
->entry_bytes_remaining
;
378 archive_entry_copy_stat(entry
, &st
);
379 archive_string_empty(&iso9660
->pathname
);
380 archive_entry_set_pathname(entry
,
381 build_pathname(&iso9660
->pathname
, file
));
382 if (file
->symlink
.s
!= NULL
)
383 archive_entry_copy_symlink(entry
, file
->symlink
.s
);
385 /* If this entry points to the same data as the previous
386 * entry, convert this into a hardlink to that entry.
387 * But don't bother for zero-length files. */
388 if (file
->offset
== iso9660
->previous_offset
389 && file
->size
== iso9660
->previous_size
391 archive_entry_set_hardlink(entry
,
392 iso9660
->previous_pathname
.s
);
393 iso9660
->entry_bytes_remaining
= 0;
394 iso9660
->entry_sparse_offset
= 0;
395 release_file(iso9660
, file
);
399 /* If the offset is before our current position, we can't
400 * seek backwards to extract it, so issue a warning. */
401 if (file
->offset
< iso9660
->current_position
) {
402 archive_set_error(&a
->archive
, ARCHIVE_ERRNO_MISC
,
403 "Ignoring out-of-order file");
404 iso9660
->entry_bytes_remaining
= 0;
405 iso9660
->entry_sparse_offset
= 0;
406 release_file(iso9660
, file
);
407 return (ARCHIVE_WARN
);
410 iso9660
->previous_size
= file
->size
;
411 iso9660
->previous_offset
= file
->offset
;
412 archive_strcpy(&iso9660
->previous_pathname
, iso9660
->pathname
.s
);
414 /* If this is a directory, read in all of the entries right now. */
415 if (S_ISDIR(st
.st_mode
)) {
416 while (iso9660
->entry_bytes_remaining
> 0) {
418 const unsigned char *p
;
419 ssize_t step
= iso9660
->logical_block_size
;
420 if (step
> iso9660
->entry_bytes_remaining
)
421 step
= iso9660
->entry_bytes_remaining
;
422 bytes_read
= (a
->compression_read_ahead
)(a
, &block
, step
);
423 if (bytes_read
< step
) {
424 archive_set_error(&a
->archive
, ARCHIVE_ERRNO_MISC
,
425 "Failed to read full block when scanning ISO9660 directory list");
426 release_file(iso9660
, file
);
427 return (ARCHIVE_FATAL
);
429 if (bytes_read
> step
)
431 (a
->compression_read_consume
)(a
, bytes_read
);
432 iso9660
->current_position
+= bytes_read
;
433 iso9660
->entry_bytes_remaining
-= bytes_read
;
434 for (p
= (const unsigned char *)block
;
435 *p
!= 0 && p
< (const unsigned char *)block
+ bytes_read
;
437 struct file_info
*child
;
439 /* Skip '.' entry. */
440 if (*(p
+ DR_name_len_offset
) == 1
441 && *(p
+ DR_name_offset
) == '\0')
443 /* Skip '..' entry. */
444 if (*(p
+ DR_name_len_offset
) == 1
445 && *(p
+ DR_name_offset
) == '\001')
447 child
= parse_file_info(iso9660
, file
, p
);
448 add_entry(iso9660
, child
);
449 if (iso9660
->seenRockridge
) {
450 a
->archive
.archive_format
=
451 ARCHIVE_FORMAT_ISO9660_ROCKRIDGE
;
452 a
->archive
.archive_format_name
=
453 "ISO9660 with Rockridge extensions";
459 release_file(iso9660
, file
);
464 archive_read_format_iso9660_read_data_skip(struct archive_read
*a
)
466 /* Because read_next_header always does an explicit skip
467 * to the next entry, we don't need to do anything here. */
468 (void)a
; /* UNUSED */
473 archive_read_format_iso9660_read_data(struct archive_read
*a
,
474 const void **buff
, size_t *size
, off_t
*offset
)
477 struct iso9660
*iso9660
;
479 iso9660
= (struct iso9660
*)*(a
->pformat_data
);
480 if (iso9660
->entry_bytes_remaining
<= 0) {
483 *offset
= iso9660
->entry_sparse_offset
;
484 return (ARCHIVE_EOF
);
487 bytes_read
= (a
->compression_read_ahead
)(a
, buff
, 1);
489 archive_set_error(&a
->archive
, ARCHIVE_ERRNO_MISC
,
490 "Truncated input file");
492 return (ARCHIVE_FATAL
);
493 if (bytes_read
> iso9660
->entry_bytes_remaining
)
494 bytes_read
= iso9660
->entry_bytes_remaining
;
496 *offset
= iso9660
->entry_sparse_offset
;
497 iso9660
->entry_sparse_offset
+= bytes_read
;
498 iso9660
->entry_bytes_remaining
-= bytes_read
;
499 iso9660
->current_position
+= bytes_read
;
500 (a
->compression_read_consume
)(a
, bytes_read
);
505 archive_read_format_iso9660_cleanup(struct archive_read
*a
)
507 struct iso9660
*iso9660
;
508 struct file_info
*file
;
510 iso9660
= (struct iso9660
*)*(a
->pformat_data
);
511 while ((file
= next_entry(iso9660
)) != NULL
)
512 release_file(iso9660
, file
);
513 archive_string_free(&iso9660
->pathname
);
514 archive_string_free(&iso9660
->previous_pathname
);
516 *(a
->pformat_data
) = NULL
;
521 * This routine parses a single ISO directory record, makes sense
522 * of any extensions, and stores the result in memory.
524 static struct file_info
*
525 parse_file_info(struct iso9660
*iso9660
, struct file_info
*parent
,
526 const unsigned char *isodirrec
)
528 struct file_info
*file
;
532 /* TODO: Sanity check that name_len doesn't exceed length, etc. */
534 /* Create a new file entry and copy data from the ISO dir record. */
535 file
= (struct file_info
*)malloc(sizeof(*file
));
538 memset(file
, 0, sizeof(*file
));
539 file
->parent
= parent
;
542 file
->offset
= toi(isodirrec
+ DR_extent_offset
, DR_extent_size
)
543 * iso9660
->logical_block_size
;
544 file
->size
= toi(isodirrec
+ DR_size_offset
, DR_size_size
);
545 file
->mtime
= isodate7(isodirrec
+ DR_date_offset
);
546 file
->ctime
= file
->atime
= file
->mtime
;
547 name_len
= (size_t)*(const unsigned char *)(isodirrec
+ DR_name_len_offset
);
548 file
->name
= (char *)malloc(name_len
+ 1);
549 if (file
->name
== NULL
) {
553 memcpy(file
->name
, isodirrec
+ DR_name_offset
, name_len
);
554 file
->name
[name_len
] = '\0';
555 flags
= *(isodirrec
+ DR_flags_offset
);
557 file
->mode
= S_IFDIR
| 0700;
559 file
->mode
= S_IFREG
| 0400;
561 /* Rockridge extensions overwrite information from above. */
563 const unsigned char *rr_start
, *rr_end
;
564 rr_end
= (const unsigned char *)isodirrec
565 + *(isodirrec
+ DR_length_offset
);
566 rr_start
= (const unsigned char *)(isodirrec
+ DR_name_offset
568 if ((name_len
& 1) == 0)
570 rr_start
+= iso9660
->suspOffset
;
571 parse_rockridge(iso9660
, file
, rr_start
, rr_end
);
574 /* DEBUGGING: Warn about attributes I don't yet fully support. */
575 if ((flags
& ~0x02) != 0) {
576 fprintf(stderr
, "\n ** Unrecognized flag: ");
577 dump_isodirrec(stderr
, isodirrec
);
578 fprintf(stderr
, "\n");
579 } else if (toi(isodirrec
+ DR_volume_sequence_number_offset
, 2) != 1) {
580 fprintf(stderr
, "\n ** Unrecognized sequence number: ");
581 dump_isodirrec(stderr
, isodirrec
);
582 fprintf(stderr
, "\n");
583 } else if (*(isodirrec
+ DR_file_unit_size_offset
) != 0) {
584 fprintf(stderr
, "\n ** Unexpected file unit size: ");
585 dump_isodirrec(stderr
, isodirrec
);
586 fprintf(stderr
, "\n");
587 } else if (*(isodirrec
+ DR_interleave_offset
) != 0) {
588 fprintf(stderr
, "\n ** Unexpected interleave: ");
589 dump_isodirrec(stderr
, isodirrec
);
590 fprintf(stderr
, "\n");
591 } else if (*(isodirrec
+ DR_ext_attr_length_offset
) != 0) {
592 fprintf(stderr
, "\n ** Unexpected extended attribute length: ");
593 dump_isodirrec(stderr
, isodirrec
);
594 fprintf(stderr
, "\n");
601 add_entry(struct iso9660
*iso9660
, struct file_info
*file
)
603 /* Expand our pending files list as necessary. */
604 if (iso9660
->pending_files_used
>= iso9660
->pending_files_allocated
) {
605 struct file_info
**new_pending_files
;
606 int new_size
= iso9660
->pending_files_allocated
* 2;
610 new_pending_files
= (struct file_info
**)malloc(new_size
* sizeof(new_pending_files
[0]));
611 if (new_pending_files
== NULL
)
612 __archive_errx(1, "Out of memory");
613 memcpy(new_pending_files
, iso9660
->pending_files
,
614 iso9660
->pending_files_allocated
* sizeof(new_pending_files
[0]));
615 if (iso9660
->pending_files
!= NULL
)
616 free(iso9660
->pending_files
);
617 iso9660
->pending_files
= new_pending_files
;
618 iso9660
->pending_files_allocated
= new_size
;
621 iso9660
->pending_files
[iso9660
->pending_files_used
++] = file
;
625 parse_rockridge(struct iso9660
*iso9660
, struct file_info
*file
,
626 const unsigned char *p
, const unsigned char *end
)
628 (void)iso9660
; /* UNUSED */
630 while (p
+ 4 < end
/* Enough space for another entry. */
631 && p
[0] >= 'A' && p
[0] <= 'Z' /* Sanity-check 1st char of name. */
632 && p
[1] >= 'A' && p
[1] <= 'Z' /* Sanity-check 2nd char of name. */
633 && p
+ p
[2] <= end
) { /* Sanity-check length. */
634 const unsigned char *data
= p
+ 4;
635 int data_length
= p
[2] - 4;
639 * Yes, each 'if' here does test p[0] again.
640 * Otherwise, the fall-through handling to catch
641 * unsupported extensions doesn't work.
645 if (p
[0] == 'C' && p
[1] == 'E' && version
== 1) {
647 * CE extension comprises:
648 * 8 byte sector containing extension
649 * 8 byte offset w/in above sector
650 * 8 byte length of continuation
652 file
->ce_offset
= toi(data
, 4)
653 * iso9660
->logical_block_size
655 file
->ce_size
= toi(data
+ 16, 4);
660 if (p
[0] == 'N' && p
[1] == 'M' && version
== 1
662 /* NM extension with flag byte == 0 */
664 * NM extension comprises:
668 /* TODO: Obey flags. */
669 char *old_name
= file
->name
;
671 data
++; /* Skip flag byte. */
673 file
->name
= (char *)malloc(data_length
+ 1);
674 if (file
->name
!= NULL
) {
676 memcpy(file
->name
, data
, data_length
);
677 file
->name
[data_length
] = '\0';
679 file
->name
= old_name
;
684 if (p
[0] == 'P' && p
[1] == 'D' && version
== 1) {
686 * PD extension is padding;
687 * contents are always ignored.
691 if (p
[0] == 'P' && p
[1] == 'X' && version
== 1) {
693 * PX extension comprises:
695 * 8 bytes for nlinks,
700 if (data_length
== 32) {
701 file
->mode
= toi(data
, 4);
702 file
->nlinks
= toi(data
+ 8, 4);
703 file
->uid
= toi(data
+ 16, 4);
704 file
->gid
= toi(data
+ 24, 4);
705 file
->inode
= toi(data
+ 32, 4);
711 if (p
[0] == 'R' && p
[1] == 'R' && version
== 1) {
712 iso9660
->seenRockridge
= 1;
714 * RR extension comprises:
715 * one byte flag value
717 /* TODO: Handle RR extension. */
722 if (p
[0] == 'S' && p
[1] == 'L' && version
== 1
725 /* SL extension with flags == 0 */
726 /* TODO: handle non-zero flag values. */
727 data
++; /* Skip flag byte. */
729 while (data_length
> 0) {
730 unsigned char flag
= *data
++;
731 unsigned char nlen
= *data
++;
735 archive_strcat(&file
->symlink
, "/");
739 case 0x01: /* Continue */
740 archive_strncat(&file
->symlink
,
741 (const char *)data
, nlen
);
744 case 0x02: /* Current */
745 archive_strcat(&file
->symlink
, ".");
747 case 0x04: /* Parent */
748 archive_strcat(&file
->symlink
, "..");
750 case 0x08: /* Root */
751 case 0x10: /* Volume root */
752 archive_string_empty(&file
->symlink
);
754 case 0x20: /* Hostname */
755 archive_strcat(&file
->symlink
, "hostname");
758 archive_strncat(&file
->symlink
,
759 (const char *)data
, nlen
);
762 /* TODO: issue a warning ? */
770 if (p
[0] == 'S' && p
[1] == 'P'
771 && version
== 1 && data_length
== 7
772 && data
[0] == (unsigned char)'\xbe'
773 && data
[1] == (unsigned char)'\xef') {
775 * SP extension stores the suspOffset
776 * (Number of bytes to skip between
777 * filename and SUSP records.)
778 * It is mandatory by the SUSP standard
781 * It allows SUSP to coexist with
782 * non-SUSP uses of the System
783 * Use Area by placing non-SUSP data
786 * TODO: Add a check for 'SP' in
787 * first directory entry, disable all SUSP
788 * processing if not found.
790 iso9660
->suspOffset
= data
[2];
793 if (p
[0] == 'S' && p
[1] == 'T'
794 && data_length
== 0 && version
== 1) {
796 * ST extension marks end of this
797 * block of SUSP entries.
799 * It allows SUSP to coexist with
800 * non-SUSP uses of the System
801 * Use Area by placing non-SUSP data
807 if (p
[0] == 'T' && p
[1] == 'F' && version
== 1) {
810 * TF extension comprises:
812 * create time (optional)
813 * modify time (optional)
814 * access time (optional)
815 * attribute time (optional)
816 * Time format and presence of fields
817 * is controlled by flag bits.
821 /* Use 17-byte time format. */
822 if (flag
& 1) /* Create time. */
824 if (flag
& 2) { /* Modify time. */
825 file
->mtime
= isodate17(data
);
828 if (flag
& 4) { /* Access time. */
829 file
->atime
= isodate17(data
);
832 if (flag
& 8) { /* Attribute time. */
833 file
->ctime
= isodate17(data
);
837 /* Use 7-byte time format. */
838 if (flag
& 1) /* Create time. */
840 if (flag
& 2) { /* Modify time. */
841 file
->mtime
= isodate7(data
);
844 if (flag
& 4) { /* Access time. */
845 file
->atime
= isodate7(data
);
848 if (flag
& 8) { /* Attribute time. */
849 file
->ctime
= isodate7(data
);
857 /* The FALLTHROUGHs above leave us here for
858 * any unsupported extension. */
860 const unsigned char *t
;
861 fprintf(stderr
, "\nUnsupported RRIP extension for %s\n", file
->name
);
862 fprintf(stderr
, " %c%c(%d):", p
[0], p
[1], data_length
);
863 for (t
= data
; t
< data
+ data_length
&& t
< data
+ 16; t
++)
864 fprintf(stderr
, " %02x", *t
);
865 fprintf(stderr
, "\n");
876 release_file(struct iso9660
*iso9660
, struct file_info
*file
)
878 struct file_info
*parent
;
880 if (file
->refcount
== 0) {
881 parent
= file
->parent
;
884 archive_string_free(&file
->symlink
);
886 if (parent
!= NULL
) {
888 release_file(iso9660
, parent
);
894 next_entry_seek(struct archive_read
*a
, struct iso9660
*iso9660
,
895 struct file_info
**pfile
)
897 struct file_info
*file
;
902 *pfile
= file
= next_entry(iso9660
);
904 return (ARCHIVE_EOF
);
906 /* CE area precedes actual file data? Ignore it. */
907 if (file
->ce_offset
> file
->offset
) {
908 fprintf(stderr
, " *** Discarding CE data.\n");
913 /* If CE exists, find and read it now. */
914 if (file
->ce_offset
> 0)
915 offset
= file
->ce_offset
;
917 offset
= file
->offset
;
919 /* Seek forward to the start of the entry. */
920 /* Use fast compression_skip if it's available. */
921 if (iso9660
->current_position
< offset
922 && a
->compression_skip
!= NULL
) {
923 off_t step
= offset
- iso9660
->current_position
;
925 bytes_read
= (a
->compression_skip
)(a
, step
);
926 iso9660
->current_position
+= bytes_read
;
929 /* Use a series of reads if compression_skip didn't
930 * get us all the way there. */
931 while (iso9660
->current_position
< offset
) {
932 ssize_t step
= offset
- iso9660
->current_position
;
936 if (step
> iso9660
->logical_block_size
)
937 step
= iso9660
->logical_block_size
;
938 bytes_read
= (a
->compression_read_ahead
)(a
, &buff
, step
);
939 if (bytes_read
<= 0) {
940 release_file(iso9660
, file
);
941 return (ARCHIVE_FATAL
);
943 if (bytes_read
> step
)
945 iso9660
->current_position
+= bytes_read
;
946 (a
->compression_read_consume
)(a
, bytes_read
);
949 /* We found body of file; handle it now. */
950 if (offset
== file
->offset
)
953 /* Found CE? Process it and push the file back onto list. */
954 if (offset
== file
->ce_offset
) {
956 ssize_t size
= file
->ce_size
;
958 const unsigned char *rr_start
;
962 bytes_read
= (a
->compression_read_ahead
)(a
, &p
, size
);
963 if (bytes_read
> size
)
965 rr_start
= (const unsigned char *)p
;
966 parse_rockridge(iso9660
, file
, rr_start
,
967 rr_start
+ bytes_read
);
968 (a
->compression_read_consume
)(a
, bytes_read
);
969 iso9660
->current_position
+= bytes_read
;
970 add_entry(iso9660
, file
);
975 static struct file_info
*
976 next_entry(struct iso9660
*iso9660
)
979 uint64_t least_end_offset
;
983 if (iso9660
->pending_files_used
< 1)
986 /* Assume the first file in the list is the earliest on disk. */
988 least_end_offset
= iso9660
->pending_files
[0]->offset
989 + iso9660
->pending_files
[0]->size
;
991 /* Now, try to find an earlier one. */
992 for (i
= 0; i
< iso9660
->pending_files_used
; i
++) {
993 /* Use the position of the file *end* as our comparison. */
994 uint64_t end_offset
= iso9660
->pending_files
[i
]->offset
995 + iso9660
->pending_files
[i
]->size
;
996 if (iso9660
->pending_files
[i
]->ce_offset
> 0
997 && iso9660
->pending_files
[i
]->ce_offset
< iso9660
->pending_files
[i
]->offset
)
998 end_offset
= iso9660
->pending_files
[i
]->ce_offset
999 + iso9660
->pending_files
[i
]->ce_size
;
1000 if (least_end_offset
> end_offset
) {
1002 least_end_offset
= end_offset
;
1005 r
= iso9660
->pending_files
[least_index
];
1006 iso9660
->pending_files
[least_index
]
1007 = iso9660
->pending_files
[--iso9660
->pending_files_used
];
1012 toi(const void *p
, int n
)
1014 const unsigned char *v
= (const unsigned char *)p
;
1016 return v
[0] + 256 * toi(v
+ 1, n
- 1);
1023 isodate7(const unsigned char *v
)
1027 memset(&tm
, 0, sizeof(tm
));
1029 tm
.tm_mon
= v
[1] - 1;
1034 /* v[6] is the signed timezone offset, in 1/4-hour increments. */
1035 offset
= ((const signed char *)v
)[6];
1036 if (offset
> -48 && offset
< 52) {
1037 tm
.tm_hour
-= offset
/ 4;
1038 tm
.tm_min
-= (offset
% 4) * 15;
1040 return (time_from_tm(&tm
));
1044 isodate17(const unsigned char *v
)
1048 memset(&tm
, 0, sizeof(tm
));
1049 tm
.tm_year
= (v
[0] - '0') * 1000 + (v
[1] - '0') * 100
1050 + (v
[2] - '0') * 10 + (v
[3] - '0')
1052 tm
.tm_mon
= (v
[4] - '0') * 10 + (v
[5] - '0');
1053 tm
.tm_mday
= (v
[6] - '0') * 10 + (v
[7] - '0');
1054 tm
.tm_hour
= (v
[8] - '0') * 10 + (v
[9] - '0');
1055 tm
.tm_min
= (v
[10] - '0') * 10 + (v
[11] - '0');
1056 tm
.tm_sec
= (v
[12] - '0') * 10 + (v
[13] - '0');
1057 /* v[16] is the signed timezone offset, in 1/4-hour increments. */
1058 offset
= ((const signed char *)v
)[16];
1059 if (offset
> -48 && offset
< 52) {
1060 tm
.tm_hour
-= offset
/ 4;
1061 tm
.tm_min
-= (offset
% 4) * 15;
1063 return (time_from_tm(&tm
));
1067 * timegm() converts a struct tm to a time_t, except it isn't standard,
1068 * so I provide my own function here that (ideally) is just a wrapper
1072 time_from_tm(struct tm
*t
)
1078 * Unfortunately, timegm() isn't standard. The standard
1079 * mktime() function is a close match, except that it uses
1080 * local timezone instead of GMT. Close enough for now.
1081 * Note that it is not possible to emulate timegm() using
1082 * completely standard interfaces:
1083 * * ANSI C90 does not even guarantee that time_t is
1084 * an arithmetic type, so time adjustments can only be
1085 * done by manipulating struct tm elements. You cannot
1086 * portably calculate time_t values.
1087 * * POSIX does promise that time_t is an arithmetic type
1088 * measured in seconds, so you can do time_t calculations
1089 * while remaining POSIX-compliant.
1090 * * Neither ANSI nor POSIX provides an easy way to measure
1091 * the timezone offset, so you can't adjust mktime() to
1092 * work like timegm().
1093 * * POSIX does not promise that the epoch begins in 1970,
1094 * so you can't write a portable timegm() function from
1096 * In practice, of course, mktime() is a reasonable approximation
1097 * and most POSIX systems do use seconds since 1970, so you
1098 * can roll your own and have it work on all but a few pretty
1101 time_t result
= mktime(t
);
1102 /* TODO: Find a way to improve this approximation to timegm(). */
1108 build_pathname(struct archive_string
*as
, struct file_info
*file
)
1110 if (file
->parent
!= NULL
&& file
->parent
->name
[0] != '\0') {
1111 build_pathname(as
, file
->parent
);
1112 archive_strcat(as
, "/");
1114 if (file
->name
[0] == '\0')
1115 archive_strcat(as
, ".");
1117 archive_strcat(as
, file
->name
);
1122 dump_isodirrec(FILE *out
, const unsigned char *isodirrec
)
1124 fprintf(out
, " l %d,",
1125 toi(isodirrec
+ DR_length_offset
, DR_length_size
));
1126 fprintf(out
, " a %d,",
1127 toi(isodirrec
+ DR_ext_attr_length_offset
, DR_ext_attr_length_size
));
1128 fprintf(out
, " ext 0x%x,",
1129 toi(isodirrec
+ DR_extent_offset
, DR_extent_size
));
1130 fprintf(out
, " s %d,",
1131 toi(isodirrec
+ DR_size_offset
, DR_extent_size
));
1132 fprintf(out
, " f 0x%02x,",
1133 toi(isodirrec
+ DR_flags_offset
, DR_flags_size
));
1134 fprintf(out
, " u %d,",
1135 toi(isodirrec
+ DR_file_unit_size_offset
, DR_file_unit_size_size
));
1136 fprintf(out
, " ilv %d,",
1137 toi(isodirrec
+ DR_interleave_offset
, DR_interleave_size
));
1138 fprintf(out
, " seq %d,",
1139 toi(isodirrec
+ DR_volume_sequence_number_offset
, DR_volume_sequence_number_size
));
1140 fprintf(out
, " nl %d:",
1141 toi(isodirrec
+ DR_name_len_offset
, DR_name_len_size
));
1142 fprintf(out
, " `%.*s'",
1143 toi(isodirrec
+ DR_name_len_offset
, DR_name_len_size
), isodirrec
+ DR_name_offset
);