2 * Copyright (c) 2009-2012 Michihiro NAKAJIMA
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"
28 #ifdef HAVE_SYS_TYPES_H
29 #include <sys/types.h>
31 #ifdef HAVE_SYS_UTSNAME_H
32 #include <sys/utsname.h>
54 #include "archive_endian.h"
55 #include "archive_entry.h"
56 #include "archive_entry_locale.h"
57 #include "archive_private.h"
58 #include "archive_rb.h"
59 #include "archive_write_private.h"
61 #if defined(_WIN32) && !defined(__CYGWIN__)
68 /* To compare to the ISO image file made by mkisofs. */
69 #define COMPAT_MKISOFS 1
72 #define LOGICAL_BLOCK_BITS 11
73 #define LOGICAL_BLOCK_SIZE 2048
74 #define PATH_TABLE_BLOCK_SIZE 4096
76 #define SYSTEM_AREA_BLOCK 16
77 #define PRIMARY_VOLUME_DESCRIPTOR_BLOCK 1
78 #define SUPPLEMENTARY_VOLUME_DESCRIPTOR_BLOCK 1
79 #define BOOT_RECORD_DESCRIPTOR_BLOCK 1
80 #define VOLUME_DESCRIPTOR_SET_TERMINATOR_BLOCK 1
81 #define NON_ISO_FILE_SYSTEM_INFORMATION_BLOCK 1
82 #define RRIP_ER_BLOCK 1
83 #define PADDING_BLOCK 150
85 #define FD_1_2M_SIZE (1024 * 1200)
86 #define FD_1_44M_SIZE (1024 * 1440)
87 #define FD_2_88M_SIZE (1024 * 2880)
88 #define MULTI_EXTENT_SIZE (ARCHIVE_LITERAL_LL(1) << 32) /* 4Gi bytes. */
90 #define RR_CE_SIZE 28 /* SUSP "CE" extension size */
92 #define FILE_FLAG_EXISTENCE 0x01
93 #define FILE_FLAG_DIRECTORY 0x02
94 #define FILE_FLAG_ASSOCIATED 0x04
95 #define FILE_FLAG_RECORD 0x08
96 #define FILE_FLAG_PROTECTION 0x10
97 #define FILE_FLAG_MULTI_EXTENT 0x80
99 static const char rrip_identifier[] =
101 static const char rrip_descriptor[] =
102 "THE ROCK RIDGE INTERCHANGE PROTOCOL PROVIDES SUPPORT FOR "
103 "POSIX FILE SYSTEM SEMANTICS";
104 static const char rrip_source[] =
105 "PLEASE CONTACT DISC PUBLISHER FOR SPECIFICATION SOURCE. "
106 "SEE PUBLISHER IDENTIFIER IN PRIMARY VOLUME DESCRIPTOR FOR "
107 "CONTACT INFORMATION.";
108 #define RRIP_ER_ID_SIZE (sizeof(rrip_identifier)-1)
109 #define RRIP_ER_DSC_SIZE (sizeof(rrip_descriptor)-1)
110 #define RRIP_ER_SRC_SIZE (sizeof(rrip_source)-1)
111 #define RRIP_ER_SIZE (8 + RRIP_ER_ID_SIZE + \
112 RRIP_ER_DSC_SIZE + RRIP_ER_SRC_SIZE)
114 static const unsigned char zisofs_magic[8] = {
115 0x37, 0xE4, 0x53, 0x96, 0xC9, 0xDB, 0xD6, 0x07
118 #define ZF_HEADER_SIZE 16 /* zisofs header size. */
119 #define ZF_LOG2_BS 15 /* log2 block size; 32K bytes. */
120 #define ZF_BLOCK_SIZE (1UL << ZF_LOG2_BS)
123 * Manage extra records.
128 unsigned char buf[LOGICAL_BLOCK_SIZE];
129 struct extr_rec *next;
132 struct ctl_extr_rec {
135 struct isoent *isoent;
136 unsigned char *ce_ptr;
143 #define DR_SAFETY RR_CE_SIZE
144 #define DR_LIMIT (254 - DR_SAFETY)
147 * The relation of struct isofile and isoent and archive_entry.
149 * Primary volume tree --> struct isoent
152 * struct isofile --> archive_entry
155 * Joliet volume tree --> struct isoent
157 * struct isoent has specific information for volume.
161 /* Used for managing struct isofile list. */
162 struct isofile *allnext;
163 struct isofile *datanext;
164 /* Used for managing a hardlinked struct isofile list. */
165 struct isofile *hlnext;
166 struct isofile *hardlink_target;
168 struct archive_entry *entry;
171 * Used for making a directory tree.
173 struct archive_string parentdir;
174 struct archive_string basename;
175 struct archive_string basename_utf16;
176 struct archive_string symlink;
177 int dircnt; /* The number of elements of
178 * its parent directory */
181 * Used for a Directory Record.
184 int64_t offset_of_temp;
189 * One extent equals one content.
190 * If this entry has multi extent, `next' variable points
193 struct content *next; /* next content */
194 } content, *cur_content;
207 unsigned char header_size;
208 unsigned char log2_bs;
209 uint32_t uncompressed_size;
214 /* Keep `rbnode' at the first member of struct isoent. */
215 struct archive_rb_node rbnode;
217 struct isofile *file;
219 struct isoent *parent;
220 /* A list of children.(use chnext) */
222 struct isoent *first;
223 struct isoent **last;
226 struct archive_rb_tree rbtree;
228 /* A list of sub directories.(use drnext) */
230 struct isoent *first;
231 struct isoent **last;
234 /* A sorted list of sub directories. */
235 struct isoent **children_sorted;
236 /* Used for managing struct isoent list. */
237 struct isoent *chnext;
238 struct isoent *drnext;
239 struct isoent *ptnext;
242 * Used for making a Directory Record.
251 uint32_t dir_location;
256 * on primary, ISO9660 file/directory name.
257 * on joliet, UCS2 file/directory name.
258 * ext_off : offset of identifier extension.
259 * ext_len : length of identifier extension.
260 * id_len : byte size of identifier.
261 * on primary, this is ext_off + ext_len + version length.
262 * on joliet, this is ext_off + ext_len.
263 * mb_len : length of multibyte-character of identifier.
264 * on primary, mb_len and id_len are always the same.
265 * on joliet, mb_len and id_len are different.
274 * Used for making a Rockridge extension.
275 * This is a part of Directory Records.
277 struct isoent *rr_parent;
278 struct isoent *rr_child;
280 /* Extra Record.(which we call in this source file)
281 * A maximum size of the Directory Record is 254.
282 * so, if generated RRIP data of a file cannot into a Directory
283 * Record because of its size, that surplus data relocate this
287 struct extr_rec *first;
288 struct extr_rec **last;
289 struct extr_rec *current;
293 /* If set to one, this file type is a directory.
294 * A convenience flag to be used as
295 * "archive_entry_filetype(isoent->file->entry) == AE_IFDIR".
301 struct archive_rb_node rbnode;
304 struct isofile *first;
305 struct isofile **last;
314 * Usage : abstract-file=<value>
315 * Type : string, max 37 bytes
316 * Default: Not specified
317 * COMPAT : mkisofs -abstract <value>
319 * Specifies Abstract Filename.
320 * This file shall be described in the Root Directory
321 * and containing a abstract statement.
323 unsigned int abstract_file:1;
324 #define OPT_ABSTRACT_FILE_DEFAULT 0 /* Not specified */
325 #define ABSTRACT_FILE_SIZE 37
328 * Usage : application-id=<value>
329 * Type : string, max 128 bytes
330 * Default: Not specified
331 * COMPAT : mkisofs -A/-appid <value>.
333 * Specifies Application Identifier.
334 * If the first byte is set to '_'(5F), the remaining
335 * bytes of this option shall specify an identifier
336 * for a file containing the identification of the
338 * This file shall be described in the Root Directory.
340 unsigned int application_id:1;
341 #define OPT_APPLICATION_ID_DEFAULT 0 /* Use default identifier */
342 #define APPLICATION_IDENTIFIER_SIZE 128
345 * Usage : !allow-vernum
348 * : Violates the ISO9660 standard if disable.
351 * Allow filenames to use version numbers.
353 unsigned int allow_vernum:1;
354 #define OPT_ALLOW_VERNUM_DEFAULT 1 /* Enabled */
357 * Usage : biblio-file=<value>
358 * Type : string, max 37 bytes
359 * Default: Not specified
360 * COMPAT : mkisofs -biblio <value>
362 * Specifies Bibliographic Filename.
363 * This file shall be described in the Root Directory
364 * and containing bibliographic records.
366 unsigned int biblio_file:1;
367 #define OPT_BIBLIO_FILE_DEFAULT 0 /* Not specified */
368 #define BIBLIO_FILE_SIZE 37
371 * Usage : boot=<value>
373 * Default: Not specified
374 * COMPAT : mkisofs -b/-eltorito-boot <value>
376 * Specifies "El Torito" boot image file to make
380 #define OPT_BOOT_DEFAULT 0 /* Not specified */
383 * Usage : boot-catalog=<value>
385 * Default: "boot.catalog"
386 * COMPAT : mkisofs -c/-eltorito-catalog <value>
388 * Specifies a fullpath of El Torito boot catalog.
390 unsigned int boot_catalog:1;
391 #define OPT_BOOT_CATALOG_DEFAULT 0 /* Not specified */
394 * Usage : boot-info-table
397 * COMPAT : mkisofs -boot-info-table
399 * Modify the boot image file specified by `boot'
400 * option; ISO writer stores boot file information
401 * into the boot file in ISO image at offset 8
404 unsigned int boot_info_table:1;
405 #define OPT_BOOT_INFO_TABLE_DEFAULT 0 /* Disabled */
408 * Usage : boot-load-seg=<value>
410 * Default: Not specified
411 * COMPAT : mkisofs -boot-load-seg <value>
413 * Specifies a load segment for boot image.
414 * This is used with no-emulation mode.
416 unsigned int boot_load_seg:1;
417 #define OPT_BOOT_LOAD_SEG_DEFAULT 0 /* Not specified */
420 * Usage : boot-load-size=<value>
422 * Default: Not specified
423 * COMPAT : mkisofs -boot-load-size <value>
425 * Specifies a sector count for boot image.
426 * This is used with no-emulation mode.
428 unsigned int boot_load_size:1;
429 #define OPT_BOOT_LOAD_SIZE_DEFAULT 0 /* Not specified */
432 * Usage : boot-type=<boot-media-type>
433 * : 'no-emulation' : 'no emulation' image
434 * : 'fd' : floppy disk image
435 * : 'hard-disk' : hard disk image
437 * Default: Auto detect
438 * : We check a size of boot image;
439 * : If the size is just 1.22M/1.44M/2.88M,
440 * : we assume boot_type is 'fd';
441 * : otherwise boot_type is 'no-emulation'.
444 * mkisofs -no-emul-boot
446 * This is a default on the mkisofs.
448 * mkisofs -hard-disk-boot
450 * Specifies a type of "El Torito" boot image.
452 unsigned int boot_type:2;
453 #define OPT_BOOT_TYPE_AUTO 0 /* auto detect */
454 #define OPT_BOOT_TYPE_NO_EMU 1 /* ``no emulation'' image */
455 #define OPT_BOOT_TYPE_FD 2 /* floppy disk image */
456 #define OPT_BOOT_TYPE_HARD_DISK 3 /* hard disk image */
457 #define OPT_BOOT_TYPE_DEFAULT OPT_BOOT_TYPE_AUTO
460 * Usage : compression-level=<value>
462 * Default: Not specified
465 * Specifies compression level for option zisofs=direct.
467 unsigned int compression_level:1;
468 #define OPT_COMPRESSION_LEVEL_DEFAULT 0 /* Not specified */
471 * Usage : copyright-file=<value>
472 * Type : string, max 37 bytes
473 * Default: Not specified
474 * COMPAT : mkisofs -copyright <value>
476 * Specifies Copyright Filename.
477 * This file shall be described in the Root Directory
478 * and containing a copyright statement.
480 unsigned int copyright_file:1;
481 #define OPT_COPYRIGHT_FILE_DEFAULT 0 /* Not specified */
482 #define COPYRIGHT_FILE_SIZE 37
485 * Usage : gid=<value>
487 * Default: Not specified
488 * COMPAT : mkisofs -gid <value>
490 * Specifies a group id to rewrite the group id of all files.
493 #define OPT_GID_DEFAULT 0 /* Not specified */
496 * Usage : iso-level=[1234]
499 * COMPAT : mkisofs -iso-level <value>
501 * Specifies ISO9600 Level.
503 * - limits each file size less than 4Gi bytes;
504 * - a File Name shall not contain more than eight
505 * d-characters or eight d1-characters;
506 * - a File Name Extension shall not contain more than
507 * three d-characters or three d1-characters;
508 * - a Directory Identifier shall not contain more
509 * than eight d-characters or eight d1-characters.
511 * - limits each file size less than 4Giga bytes;
512 * - a File Name shall not contain more than thirty
513 * d-characters or thirty d1-characters;
514 * - a File Name Extension shall not contain more than
515 * thirty d-characters or thirty d1-characters;
516 * - a Directory Identifier shall not contain more
517 * than thirty-one d-characters or thirty-one
520 * - no limit of file size; use multi extent.
522 * - this level 4 simulates mkisofs option
524 * - crate a enhanced volume as mkisofs doing;
525 * - allow a File Name to have leading dot;
526 * - allow a File Name to have all ASCII letters;
527 * - allow a File Name to have multiple dots;
528 * - allow more then 8 depths of directory trees;
529 * - disable a version number to a File Name;
530 * - disable a forced period to the tail of a File Name;
531 * - the maximum length of files and directories is raised to 193.
532 * if rockridge option is disabled, raised to 207.
534 unsigned int iso_level:3;
535 #define OPT_ISO_LEVEL_DEFAULT 1 /* ISO Level 1 */
538 * Usage : joliet[=long]
540 * : Do not generate Joliet Volume and Records.
542 * : Generates Joliet Volume and Directory Records.
543 * : [COMPAT: mkisofs -J/-joliet]
545 * : The joliet filenames are up to 103 Unicode
547 * : This option breaks the Joliet specification.
548 * : [COMPAT: mkisofs -J -joliet-long]
549 * Type : boolean/string
551 * COMPAT : mkisofs -J / -joliet-long
553 * Generates Joliet Volume and Directory Records.
555 unsigned int joliet:2;
556 #define OPT_JOLIET_DISABLE 0 /* Not generate Joliet Records. */
557 #define OPT_JOLIET_ENABLE 1 /* Generate Joliet Records. */
558 #define OPT_JOLIET_LONGNAME 2 /* Use long joliet filenames.*/
559 #define OPT_JOLIET_DEFAULT OPT_JOLIET_ENABLE
562 * Usage : !limit-depth
565 * : Violates the ISO9660 standard if disable.
566 * COMPAT : mkisofs -D/-disable-deep-relocation
568 * The number of levels in hierarchy cannot exceed eight.
570 unsigned int limit_depth:1;
571 #define OPT_LIMIT_DEPTH_DEFAULT 1 /* Enabled */
574 * Usage : !limit-dirs
577 * : Violates the ISO9660 standard if disable.
578 * COMPAT : mkisofs -no-limit-pathtables
580 * Limits the number of directories less than 65536 due
581 * to the size of the Parent Directory Number of Path
584 unsigned int limit_dirs:1;
585 #define OPT_LIMIT_DIRS_DEFAULT 1 /* Enabled */
591 * COMPAT : -pad/-no-pad
593 * Pads the end of the ISO image by null of 300Ki bytes.
596 #define OPT_PAD_DEFAULT 1 /* Enabled */
599 * Usage : publisher=<value>
600 * Type : string, max 128 bytes
601 * Default: Not specified
602 * COMPAT : mkisofs -publisher <value>
604 * Specifies Publisher Identifier.
605 * If the first byte is set to '_'(5F), the remaining
606 * bytes of this option shall specify an identifier
607 * for a file containing the identification of the user.
608 * This file shall be described in the Root Directory.
610 unsigned int publisher:1;
611 #define OPT_PUBLISHER_DEFAULT 0 /* Not specified */
612 #define PUBLISHER_IDENTIFIER_SIZE 128
617 * : disable to generate SUSP and RR records.
619 * : the same as 'rockridge=useful'.
621 * : generate SUSP and RR records.
622 * : [COMPAT: mkisofs -R]
623 * : rockridge=useful [DEFAULT]
624 * : generate SUSP and RR records.
625 * : [COMPAT: mkisofs -r]
626 * : NOTE Our rockridge=useful option does not set a zero
627 * : to uid and gid, you should use application
628 * : option such as --gid,--gname,--uid and --uname
629 * : bsdtar options instead.
630 * Type : boolean/string
631 * Default: Enabled as rockridge=useful
632 * COMPAT : mkisofs -r / -R
634 * Generates SUSP and RR records.
637 #define OPT_RR_DISABLED 0
638 #define OPT_RR_STRICT 1
639 #define OPT_RR_USEFUL 2
640 #define OPT_RR_DEFAULT OPT_RR_USEFUL
643 * Usage : volume-id=<value>
644 * Type : string, max 32 bytes
645 * Default: Not specified
646 * COMPAT : mkisofs -V <value>
648 * Specifies Volume Identifier.
650 unsigned int volume_id:1;
651 #define OPT_VOLUME_ID_DEFAULT 0 /* Use default identifier */
652 #define VOLUME_IDENTIFIER_SIZE 32
655 * Usage : !zisofs [DEFAULT]
656 * : Disable to generate RRIP 'ZF' extension.
658 * : Make files zisofs file and generate RRIP 'ZF'
659 * : extension. So you do not need mkzftree utility
660 * : for making zisofs.
661 * : When the file size is less than one Logical Block
662 * : size, that file will not zisofs'ed since it does
663 * : reduce an ISO-image size.
665 * : When you specify option 'boot=<boot-image>', that
666 * : 'boot-image' file won't be converted to zisofs file.
670 * Generates RRIP 'ZF' System Use Entry.
672 unsigned int zisofs:1;
673 #define OPT_ZISOFS_DISABLED 0
674 #define OPT_ZISOFS_DIRECT 1
675 #define OPT_ZISOFS_DEFAULT OPT_ZISOFS_DISABLED
680 /* The creation time of ISO image. */
682 /* A file stream of a temporary file, which file contents
683 * save to until ISO image can be created. */
686 struct isofile *cur_file;
687 struct isoent *cur_dirent;
688 struct archive_string cur_dirstr;
689 uint64_t bytes_remaining;
690 int need_multi_extent;
692 /* Temporary string buffer for Joliet extension. */
693 struct archive_string utf16be;
694 struct archive_string mbs;
696 struct archive_string_conv *sconv_to_utf16be;
697 struct archive_string_conv *sconv_from_utf16be;
699 /* A list of all of struct isofile entries. */
701 struct isofile *first;
702 struct isofile **last;
705 /* A list of struct isofile entries which have its
706 * contents and are not a directory, a hardlinked file
707 * and a symlink file. */
709 struct isofile *first;
710 struct isofile **last;
713 /* Used for managing to find hardlinking files. */
714 struct archive_rb_tree hardlink_rbtree;
716 /* Used for making the Path Table Record. */
718 /* the root of entry tree. */
719 struct isoent *rootent;
727 struct isoent *first;
728 struct isoent **last;
729 struct isoent **sorted;
734 int path_table_block;
736 int location_type_L_path_table;
737 int location_type_M_path_table;
741 /* Used for making a Volume Descriptor. */
742 int volume_space_size;
743 int volume_sequence_number;
744 int total_file_block;
745 struct archive_string volume_identifier;
746 struct archive_string publisher_identifier;
747 struct archive_string data_preparer_identifier;
748 struct archive_string application_identifier;
749 struct archive_string copyright_file_identifier;
750 struct archive_string abstract_file_identifier;
751 struct archive_string bibliographic_file_identifier;
753 /* Used for making rockridge extensions. */
754 int location_rrip_er;
756 /* Used for making zisofs. */
761 unsigned char magic_buffer[64];
766 * Copy a compressed file to iso9660.zisofs.temp_fd
767 * and also copy a uncompressed file(original file) to
768 * iso9660.temp_fd . If the number of logical block
769 * of the compressed file is less than the number of
770 * logical block of the uncompressed file, use it and
771 * remove the copy of the uncompressed file.
772 * but if not, we use uncompressed file and remove
773 * the copy of the compressed file.
775 uint32_t *block_pointers;
776 size_t block_pointers_allocated;
777 int block_pointers_cnt;
778 int block_pointers_idx;
780 int64_t block_offset;
785 int compression_level;
789 struct isoent *directories_too_deep;
793 #define wb_buffmax() (LOGICAL_BLOCK_SIZE * 32)
794 #define wb_remaining(a) (((struct iso9660 *)(a)->format_data)->wbuff_remaining)
795 #define wb_offset(a) (((struct iso9660 *)(a)->format_data)->wbuff_offset \
796 + wb_buffmax() - wb_remaining(a))
797 unsigned char wbuff[LOGICAL_BLOCK_SIZE * 32];
798 size_t wbuff_remaining;
803 int64_t wbuff_offset;
804 int64_t wbuff_written;
807 /* 'El Torito' boot data. */
809 /* boot catalog file */
810 struct archive_string catalog_filename;
811 struct isoent *catalog;
812 /* boot image file */
813 struct archive_string boot_filename;
816 unsigned char platform_id;
817 #define BOOT_PLATFORM_X86 0
818 #define BOOT_PLATFORM_PPC 1
819 #define BOOT_PLATFORM_MAC 2
820 struct archive_string id;
821 unsigned char media_type;
822 #define BOOT_MEDIA_NO_EMULATION 0
823 #define BOOT_MEDIA_1_2M_DISKETTE 1
824 #define BOOT_MEDIA_1_44M_DISKETTE 2
825 #define BOOT_MEDIA_2_88M_DISKETTE 3
826 #define BOOT_MEDIA_HARD_DISK 4
827 unsigned char system_type;
828 uint16_t boot_load_seg;
829 uint16_t boot_load_size;
830 #define BOOT_LOAD_SIZE 4
833 struct iso_option opt;
837 * Types of Volume Descriptor
840 VDT_BOOT_RECORD=0, /* Boot Record Volume Descriptor */
841 VDT_PRIMARY=1, /* Primary Volume Descriptor */
842 VDT_SUPPLEMENTARY=2, /* Supplementary Volume Descriptor */
843 VDT_TERMINATOR=255 /* Volume Descriptor Set Terminator */
847 * Types of Directory Record
850 DIR_REC_VD, /* Stored in Volume Descriptor. */
851 DIR_REC_SELF, /* Stored as Current Directory. */
852 DIR_REC_PARENT, /* Stored as Parent Directory. */
853 DIR_REC_NORMAL /* Stored as Child. */
857 * Kinds of Volume Descriptor Character
867 * IDentifier Resolver.
868 * Used for resolving duplicated filenames.
872 struct archive_rb_node rbnode;
873 /* Used in wait_list. */
874 struct idrent *wnext;
875 struct idrent *avail;
877 struct isoent *isoent;
883 struct archive_rb_tree rbtree;
886 struct idrent *first;
887 struct idrent **last;
904 static int iso9660_options(struct archive_write *,
905 const char *, const char *);
906 static int iso9660_write_header(struct archive_write *,
907 struct archive_entry *);
908 static ssize_t iso9660_write_data(struct archive_write *,
909 const void *, size_t);
910 static int iso9660_finish_entry(struct archive_write *);
911 static int iso9660_close(struct archive_write *);
912 static int iso9660_free(struct archive_write *);
914 static void get_system_identitier(char *, size_t);
915 static void set_str(unsigned char *, const char *, size_t, char,
917 static inline int joliet_allowed_char(unsigned char, unsigned char);
918 static int set_str_utf16be(struct archive_write *, unsigned char *,
919 const char *, size_t, uint16_t, enum vdc);
920 static int set_str_a_characters_bp(struct archive_write *,
921 unsigned char *, int, int, const char *, enum vdc);
922 static int set_str_d_characters_bp(struct archive_write *,
923 unsigned char *, int, int, const char *, enum vdc);
924 static void set_VD_bp(unsigned char *, enum VD_type, unsigned char);
925 static inline void set_unused_field_bp(unsigned char *, int, int);
927 static unsigned char *extra_open_record(unsigned char *, int,
928 struct isoent *, struct ctl_extr_rec *);
929 static void extra_close_record(struct ctl_extr_rec *, int);
930 static unsigned char * extra_next_record(struct ctl_extr_rec *, int);
931 static unsigned char *extra_get_record(struct isoent *, int *, int *, int *);
932 static void extra_tell_used_size(struct ctl_extr_rec *, int);
933 static int extra_setup_location(struct isoent *, int);
934 static int set_directory_record_rr(unsigned char *, int,
935 struct isoent *, struct iso9660 *, enum dir_rec_type);
936 static int set_directory_record(unsigned char *, size_t,
937 struct isoent *, struct iso9660 *, enum dir_rec_type,
939 static inline int get_dir_rec_size(struct iso9660 *, struct isoent *,
940 enum dir_rec_type, enum vdd_type);
941 static inline unsigned char *wb_buffptr(struct archive_write *);
942 static int wb_write_out(struct archive_write *);
943 static int wb_consume(struct archive_write *, size_t);
945 static int wb_set_offset(struct archive_write *, int64_t);
947 static int write_null(struct archive_write *, size_t);
948 static int write_VD_terminator(struct archive_write *);
949 static int set_file_identifier(unsigned char *, int, int, enum vdc,
950 struct archive_write *, struct vdd *,
951 struct archive_string *, const char *, int,
953 static int write_VD(struct archive_write *, struct vdd *);
954 static int write_VD_boot_record(struct archive_write *);
955 static int write_information_block(struct archive_write *);
956 static int write_path_table(struct archive_write *, int,
958 static int write_directory_descriptors(struct archive_write *,
960 static int write_file_descriptors(struct archive_write *);
961 static int write_rr_ER(struct archive_write *);
962 static void calculate_path_table_size(struct vdd *);
964 static void isofile_init_entry_list(struct iso9660 *);
965 static void isofile_add_entry(struct iso9660 *, struct isofile *);
966 static void isofile_free_all_entries(struct iso9660 *);
967 static void isofile_init_entry_data_file_list(struct iso9660 *);
968 static void isofile_add_data_file(struct iso9660 *, struct isofile *);
969 static struct isofile * isofile_new(struct archive_write *,
970 struct archive_entry *);
971 static void isofile_free(struct isofile *);
972 static int isofile_gen_utility_names(struct archive_write *,
974 static int isofile_register_hardlink(struct archive_write *,
976 static void isofile_connect_hardlink_files(struct iso9660 *);
977 static void isofile_init_hardlinks(struct iso9660 *);
978 static void isofile_free_hardlinks(struct iso9660 *);
980 static struct isoent *isoent_new(struct isofile *);
981 static int isoent_clone_tree(struct archive_write *,
982 struct isoent **, struct isoent *);
983 static void _isoent_free(struct isoent *isoent);
984 static void isoent_free_all(struct isoent *);
985 static struct isoent * isoent_create_virtual_dir(struct archive_write *,
986 struct iso9660 *, const char *);
987 static int isoent_cmp_node(const struct archive_rb_node *,
988 const struct archive_rb_node *);
989 static int isoent_cmp_key(const struct archive_rb_node *,
991 static int isoent_add_child_head(struct isoent *, struct isoent *);
992 static int isoent_add_child_tail(struct isoent *, struct isoent *);
993 static void isoent_remove_child(struct isoent *, struct isoent *);
994 static void isoent_setup_directory_location(struct iso9660 *,
996 static void isoent_setup_file_location(struct iso9660 *, int);
997 static int get_path_component(char *, size_t, const char *);
998 static int isoent_tree(struct archive_write *, struct isoent **);
999 static struct isoent *isoent_find_child(struct isoent *, const char *);
1000 static struct isoent *isoent_find_entry(struct isoent *, const char *);
1001 static void idr_relaxed_filenames(char *);
1002 static void idr_init(struct iso9660 *, struct vdd *, struct idr *);
1003 static void idr_cleanup(struct idr *);
1004 static int idr_ensure_poolsize(struct archive_write *, struct idr *,
1006 static int idr_start(struct archive_write *, struct idr *,
1007 int, int, int, int, const struct archive_rb_tree_ops *);
1008 static void idr_register(struct idr *, struct isoent *, int,
1010 static void idr_extend_identifier(struct idrent *, int, int);
1011 static void idr_resolve(struct idr *, void (*)(unsigned char *, int));
1012 static void idr_set_num(unsigned char *, int);
1013 static void idr_set_num_beutf16(unsigned char *, int);
1014 static int isoent_gen_iso9660_identifier(struct archive_write *,
1015 struct isoent *, struct idr *);
1016 static int isoent_gen_joliet_identifier(struct archive_write *,
1017 struct isoent *, struct idr *);
1018 static int isoent_cmp_iso9660_identifier(const struct isoent *,
1019 const struct isoent *);
1020 static int isoent_cmp_node_iso9660(const struct archive_rb_node *,
1021 const struct archive_rb_node *);
1022 static int isoent_cmp_key_iso9660(const struct archive_rb_node *,
1024 static int isoent_cmp_joliet_identifier(const struct isoent *,
1025 const struct isoent *);
1026 static int isoent_cmp_node_joliet(const struct archive_rb_node *,
1027 const struct archive_rb_node *);
1028 static int isoent_cmp_key_joliet(const struct archive_rb_node *,
1030 static inline void path_table_add_entry(struct path_table *, struct isoent *);
1031 static inline struct isoent * path_table_last_entry(struct path_table *);
1032 static int isoent_make_path_table(struct archive_write *);
1033 static int isoent_find_out_boot_file(struct archive_write *,
1035 static int isoent_create_boot_catalog(struct archive_write *,
1037 static size_t fd_boot_image_size(int);
1038 static int make_boot_catalog(struct archive_write *);
1039 static int setup_boot_information(struct archive_write *);
1041 static int zisofs_init(struct archive_write *, struct isofile *);
1042 static void zisofs_detect_magic(struct archive_write *,
1043 const void *, size_t);
1044 static int zisofs_write_to_temp(struct archive_write *,
1045 const void *, size_t);
1046 static int zisofs_finish_entry(struct archive_write *);
1047 static int zisofs_rewind_boot_file(struct archive_write *);
1048 static int zisofs_free(struct archive_write *);
1051 archive_write_set_format_iso9660(struct archive *_a)
1053 struct archive_write *a = (struct archive_write *)_a;
1054 struct iso9660 *iso9660;
1056 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
1057 ARCHIVE_STATE_NEW, "archive_write_set_format_iso9660");
1059 /* If another format was already registered, unregister it. */
1060 if (a->format_free != NULL)
1061 (a->format_free)(a);
1063 iso9660 = calloc(1, sizeof(*iso9660));
1064 if (iso9660 == NULL) {
1065 archive_set_error(&a->archive, ENOMEM,
1066 "Can't allocate iso9660 data");
1067 return (ARCHIVE_FATAL);
1069 iso9660->birth_time = 0;
1070 iso9660->temp_fd = -1;
1071 iso9660->cur_file = NULL;
1072 iso9660->primary.max_depth = 0;
1073 iso9660->primary.vdd_type = VDD_PRIMARY;
1074 iso9660->primary.pathtbl = NULL;
1075 iso9660->joliet.rootent = NULL;
1076 iso9660->joliet.max_depth = 0;
1077 iso9660->joliet.vdd_type = VDD_JOLIET;
1078 iso9660->joliet.pathtbl = NULL;
1079 isofile_init_entry_list(iso9660);
1080 isofile_init_entry_data_file_list(iso9660);
1081 isofile_init_hardlinks(iso9660);
1082 iso9660->directories_too_deep = NULL;
1083 iso9660->dircnt_max = 1;
1084 iso9660->wbuff_remaining = wb_buffmax();
1085 iso9660->wbuff_type = WB_TO_TEMP;
1086 iso9660->wbuff_offset = 0;
1087 iso9660->wbuff_written = 0;
1088 iso9660->wbuff_tail = 0;
1089 archive_string_init(&(iso9660->utf16be));
1090 archive_string_init(&(iso9660->mbs));
1093 * Init Identifiers used for PVD and SVD.
1095 archive_string_init(&(iso9660->volume_identifier));
1096 archive_strcpy(&(iso9660->volume_identifier), "CDROM");
1097 archive_string_init(&(iso9660->publisher_identifier));
1098 archive_string_init(&(iso9660->data_preparer_identifier));
1099 archive_string_init(&(iso9660->application_identifier));
1100 archive_strcpy(&(iso9660->application_identifier),
1101 archive_version_string());
1102 archive_string_init(&(iso9660->copyright_file_identifier));
1103 archive_string_init(&(iso9660->abstract_file_identifier));
1104 archive_string_init(&(iso9660->bibliographic_file_identifier));
1107 * Init El Torito bootable CD variables.
1109 archive_string_init(&(iso9660->el_torito.catalog_filename));
1110 iso9660->el_torito.catalog = NULL;
1111 /* Set default file name of boot catalog */
1112 archive_strcpy(&(iso9660->el_torito.catalog_filename),
1114 archive_string_init(&(iso9660->el_torito.boot_filename));
1115 iso9660->el_torito.boot = NULL;
1116 iso9660->el_torito.platform_id = BOOT_PLATFORM_X86;
1117 archive_string_init(&(iso9660->el_torito.id));
1118 iso9660->el_torito.boot_load_seg = 0;
1119 iso9660->el_torito.boot_load_size = BOOT_LOAD_SIZE;
1122 * Init zisofs variables.
1125 iso9660->zisofs.block_pointers = NULL;
1126 iso9660->zisofs.block_pointers_allocated = 0;
1127 iso9660->zisofs.stream_valid = 0;
1128 iso9660->zisofs.compression_level = 9;
1129 memset(&(iso9660->zisofs.stream), 0,
1130 sizeof(iso9660->zisofs.stream));
1134 * Set default value of iso9660 options.
1136 iso9660->opt.abstract_file = OPT_ABSTRACT_FILE_DEFAULT;
1137 iso9660->opt.application_id = OPT_APPLICATION_ID_DEFAULT;
1138 iso9660->opt.allow_vernum = OPT_ALLOW_VERNUM_DEFAULT;
1139 iso9660->opt.biblio_file = OPT_BIBLIO_FILE_DEFAULT;
1140 iso9660->opt.boot = OPT_BOOT_DEFAULT;
1141 iso9660->opt.boot_catalog = OPT_BOOT_CATALOG_DEFAULT;
1142 iso9660->opt.boot_info_table = OPT_BOOT_INFO_TABLE_DEFAULT;
1143 iso9660->opt.boot_load_seg = OPT_BOOT_LOAD_SEG_DEFAULT;
1144 iso9660->opt.boot_load_size = OPT_BOOT_LOAD_SIZE_DEFAULT;
1145 iso9660->opt.boot_type = OPT_BOOT_TYPE_DEFAULT;
1146 iso9660->opt.compression_level = OPT_COMPRESSION_LEVEL_DEFAULT;
1147 iso9660->opt.copyright_file = OPT_COPYRIGHT_FILE_DEFAULT;
1148 iso9660->opt.iso_level = OPT_ISO_LEVEL_DEFAULT;
1149 iso9660->opt.joliet = OPT_JOLIET_DEFAULT;
1150 iso9660->opt.limit_depth = OPT_LIMIT_DEPTH_DEFAULT;
1151 iso9660->opt.limit_dirs = OPT_LIMIT_DIRS_DEFAULT;
1152 iso9660->opt.pad = OPT_PAD_DEFAULT;
1153 iso9660->opt.publisher = OPT_PUBLISHER_DEFAULT;
1154 iso9660->opt.rr = OPT_RR_DEFAULT;
1155 iso9660->opt.volume_id = OPT_VOLUME_ID_DEFAULT;
1156 iso9660->opt.zisofs = OPT_ZISOFS_DEFAULT;
1158 /* Create the root directory. */
1159 iso9660->primary.rootent =
1160 isoent_create_virtual_dir(a, iso9660, "");
1161 if (iso9660->primary.rootent == NULL) {
1163 archive_set_error(&a->archive, ENOMEM,
1164 "Can't allocate memory");
1165 return (ARCHIVE_FATAL);
1167 iso9660->primary.rootent->parent = iso9660->primary.rootent;
1168 iso9660->cur_dirent = iso9660->primary.rootent;
1169 archive_string_init(&(iso9660->cur_dirstr));
1170 archive_string_ensure(&(iso9660->cur_dirstr), 1);
1171 iso9660->cur_dirstr.s[0] = 0;
1172 iso9660->sconv_to_utf16be = NULL;
1173 iso9660->sconv_from_utf16be = NULL;
1175 a->format_data = iso9660;
1176 a->format_name = "iso9660";
1177 a->format_options = iso9660_options;
1178 a->format_write_header = iso9660_write_header;
1179 a->format_write_data = iso9660_write_data;
1180 a->format_finish_entry = iso9660_finish_entry;
1181 a->format_close = iso9660_close;
1182 a->format_free = iso9660_free;
1183 a->archive.archive_format = ARCHIVE_FORMAT_ISO9660;
1184 a->archive.archive_format_name = "ISO9660";
1186 return (ARCHIVE_OK);
1190 get_str_opt(struct archive_write *a, struct archive_string *s,
1191 size_t maxsize, const char *key, const char *value)
1194 if (strlen(value) > maxsize) {
1195 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1196 "Value is longer than %zu characters "
1197 "for option ``%s''", maxsize, key);
1198 return (ARCHIVE_FATAL);
1200 archive_strcpy(s, value);
1201 return (ARCHIVE_OK);
1205 get_num_opt(struct archive_write *a, int *num, int high, int low,
1206 const char *key, const char *value)
1208 const char *p = value;
1213 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1214 "Invalid value(empty) for option ``%s''", key);
1215 return (ARCHIVE_FATAL);
1222 if (*p >= '0' && *p <= '9')
1223 data = data * 10 + *p - '0';
1225 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1226 "Invalid value for option ``%s''", key);
1227 return (ARCHIVE_FATAL);
1230 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1231 "Invalid value(over %d) for "
1232 "option ``%s''", high, key);
1233 return (ARCHIVE_FATAL);
1236 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1237 "Invalid value(under %d) for "
1238 "option ``%s''", low, key);
1239 return (ARCHIVE_FATAL);
1247 return (ARCHIVE_OK);
1251 iso9660_options(struct archive_write *a, const char *key, const char *value)
1253 struct iso9660 *iso9660 = a->format_data;
1259 if (strcmp(key, "abstract-file") == 0) {
1261 &(iso9660->abstract_file_identifier),
1262 ABSTRACT_FILE_SIZE, key, value);
1263 iso9660->opt.abstract_file = r == ARCHIVE_OK;
1266 if (strcmp(key, "application-id") == 0) {
1268 &(iso9660->application_identifier),
1269 APPLICATION_IDENTIFIER_SIZE, key, value);
1270 iso9660->opt.application_id = r == ARCHIVE_OK;
1273 if (strcmp(key, "allow-vernum") == 0) {
1274 iso9660->opt.allow_vernum = value != NULL;
1275 return (ARCHIVE_OK);
1279 if (strcmp(key, "biblio-file") == 0) {
1281 &(iso9660->bibliographic_file_identifier),
1282 BIBLIO_FILE_SIZE, key, value);
1283 iso9660->opt.biblio_file = r == ARCHIVE_OK;
1286 if (strcmp(key, "boot") == 0) {
1288 iso9660->opt.boot = 0;
1290 iso9660->opt.boot = 1;
1292 &(iso9660->el_torito.boot_filename),
1295 return (ARCHIVE_OK);
1297 if (strcmp(key, "boot-catalog") == 0) {
1299 &(iso9660->el_torito.catalog_filename),
1301 iso9660->opt.boot_catalog = r == ARCHIVE_OK;
1304 if (strcmp(key, "boot-info-table") == 0) {
1305 iso9660->opt.boot_info_table = value != NULL;
1306 return (ARCHIVE_OK);
1308 if (strcmp(key, "boot-load-seg") == 0) {
1311 iso9660->opt.boot_load_seg = 0;
1316 if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
1321 if (*p >= 'A' && *p <= 'F')
1322 seg += *p - 'A' + 0x0a;
1323 else if (*p >= 'a' && *p <= 'f')
1324 seg += *p - 'a' + 0x0a;
1325 else if (*p >= '0' && *p <= '9')
1330 archive_set_error(&a->archive,
1332 "Invalid value(over 0xffff) for "
1333 "option ``%s''", key);
1334 return (ARCHIVE_FATAL);
1338 iso9660->el_torito.boot_load_seg = (uint16_t)seg;
1339 iso9660->opt.boot_load_seg = 1;
1340 return (ARCHIVE_OK);
1342 if (strcmp(key, "boot-load-size") == 0) {
1344 r = get_num_opt(a, &num, 0xffff, 1, key, value);
1345 iso9660->opt.boot_load_size = r == ARCHIVE_OK;
1346 if (r != ARCHIVE_OK)
1347 return (ARCHIVE_FATAL);
1348 iso9660->el_torito.boot_load_size = (uint16_t)num;
1349 return (ARCHIVE_OK);
1351 if (strcmp(key, "boot-type") == 0) {
1354 if (strcmp(value, "no-emulation") == 0)
1355 iso9660->opt.boot_type = OPT_BOOT_TYPE_NO_EMU;
1356 else if (strcmp(value, "fd") == 0)
1357 iso9660->opt.boot_type = OPT_BOOT_TYPE_FD;
1358 else if (strcmp(value, "hard-disk") == 0)
1359 iso9660->opt.boot_type = OPT_BOOT_TYPE_HARD_DISK;
1362 return (ARCHIVE_OK);
1366 if (strcmp(key, "compression-level") == 0) {
1368 if (value == NULL ||
1369 !(value[0] >= '0' && value[0] <= '9') ||
1372 iso9660->zisofs.compression_level = value[0] - '0';
1373 iso9660->opt.compression_level = 1;
1374 return (ARCHIVE_OK);
1376 archive_set_error(&a->archive,
1379 "is not supported on this platform.", key);
1380 return (ARCHIVE_FATAL);
1383 if (strcmp(key, "copyright-file") == 0) {
1385 &(iso9660->copyright_file_identifier),
1386 COPYRIGHT_FILE_SIZE, key, value);
1387 iso9660->opt.copyright_file = r == ARCHIVE_OK;
1391 /* Specifies Volume creation date and time;
1392 * year(4),month(2),day(2),hour(2),minute(2),second(2).
1393 * e.g. "20090929033757"
1395 if (strcmp(key, "creation") == 0) {
1400 if (p == NULL || strlen(p) < 14)
1402 memset(&tm, 0, sizeof(tm));
1403 memcpy(buf, p, 4); buf[4] = '\0'; p += 4;
1404 tm.tm_year = strtol(buf, NULL, 10) - 1900;
1405 memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
1406 tm.tm_mon = strtol(buf, NULL, 10) - 1;
1407 memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
1408 tm.tm_mday = strtol(buf, NULL, 10);
1409 memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
1410 tm.tm_hour = strtol(buf, NULL, 10);
1411 memcpy(buf, p, 2); buf[2] = '\0'; p += 2;
1412 tm.tm_min = strtol(buf, NULL, 10);
1413 memcpy(buf, p, 2); buf[2] = '\0';
1414 tm.tm_sec = strtol(buf, NULL, 10);
1415 iso9660->birth_time = mktime(&tm);
1416 return (ARCHIVE_OK);
1421 if (strcmp(key, "iso-level") == 0) {
1422 if (value != NULL && value[1] == '\0' &&
1423 (value[0] >= '1' && value[0] <= '4')) {
1424 iso9660->opt.iso_level = value[0]-'0';
1425 return (ARCHIVE_OK);
1431 if (strcmp(key, "joliet") == 0) {
1433 iso9660->opt.joliet = OPT_JOLIET_DISABLE;
1434 else if (strcmp(value, "1") == 0)
1435 iso9660->opt.joliet = OPT_JOLIET_ENABLE;
1436 else if (strcmp(value, "long") == 0)
1437 iso9660->opt.joliet = OPT_JOLIET_LONGNAME;
1440 return (ARCHIVE_OK);
1444 if (strcmp(key, "limit-depth") == 0) {
1445 iso9660->opt.limit_depth = value != NULL;
1446 return (ARCHIVE_OK);
1448 if (strcmp(key, "limit-dirs") == 0) {
1449 iso9660->opt.limit_dirs = value != NULL;
1450 return (ARCHIVE_OK);
1454 if (strcmp(key, "pad") == 0) {
1455 iso9660->opt.pad = value != NULL;
1456 return (ARCHIVE_OK);
1458 if (strcmp(key, "publisher") == 0) {
1460 &(iso9660->publisher_identifier),
1461 PUBLISHER_IDENTIFIER_SIZE, key, value);
1462 iso9660->opt.publisher = r == ARCHIVE_OK;
1467 if (strcmp(key, "rockridge") == 0 ||
1468 strcmp(key, "Rockridge") == 0) {
1470 iso9660->opt.rr = OPT_RR_DISABLED;
1471 else if (strcmp(value, "1") == 0)
1472 iso9660->opt.rr = OPT_RR_USEFUL;
1473 else if (strcmp(value, "strict") == 0)
1474 iso9660->opt.rr = OPT_RR_STRICT;
1475 else if (strcmp(value, "useful") == 0)
1476 iso9660->opt.rr = OPT_RR_USEFUL;
1479 return (ARCHIVE_OK);
1483 if (strcmp(key, "volume-id") == 0) {
1484 r = get_str_opt(a, &(iso9660->volume_identifier),
1485 VOLUME_IDENTIFIER_SIZE, key, value);
1486 iso9660->opt.volume_id = r == ARCHIVE_OK;
1491 if (strcmp(key, "zisofs") == 0) {
1493 iso9660->opt.zisofs = OPT_ZISOFS_DISABLED;
1496 iso9660->opt.zisofs = OPT_ZISOFS_DIRECT;
1498 archive_set_error(&a->archive,
1501 "is not supported on this platform.");
1502 return (ARCHIVE_FATAL);
1505 return (ARCHIVE_OK);
1510 /* Note: The "warn" return is just to inform the options
1511 * supervisor that we didn't handle it. It will generate
1512 * a suitable error if no one used this option. */
1513 return (ARCHIVE_WARN);
1516 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1517 "Invalid value for option ``%s''", key);
1518 return (ARCHIVE_FAILED);
1522 iso9660_write_header(struct archive_write *a, struct archive_entry *entry)
1524 struct iso9660 *iso9660;
1525 struct isofile *file;
1526 struct isoent *isoent;
1527 int r, ret = ARCHIVE_OK;
1529 iso9660 = a->format_data;
1531 iso9660->cur_file = NULL;
1532 iso9660->bytes_remaining = 0;
1533 iso9660->need_multi_extent = 0;
1534 if (archive_entry_filetype(entry) == AE_IFLNK
1535 && iso9660->opt.rr == OPT_RR_DISABLED) {
1536 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1537 "Ignore symlink file.");
1538 iso9660->cur_file = NULL;
1539 return (ARCHIVE_WARN);
1541 if (archive_entry_filetype(entry) == AE_IFREG &&
1542 archive_entry_size(entry) >= MULTI_EXTENT_SIZE) {
1543 if (iso9660->opt.iso_level < 3) {
1544 archive_set_error(&a->archive,
1546 "Ignore over %lld bytes file. "
1547 "This file too large.",
1549 iso9660->cur_file = NULL;
1550 return (ARCHIVE_WARN);
1552 iso9660->need_multi_extent = 1;
1555 file = isofile_new(a, entry);
1557 archive_set_error(&a->archive, ENOMEM,
1558 "Can't allocate data");
1559 return (ARCHIVE_FATAL);
1561 r = isofile_gen_utility_names(a, file);
1562 if (r < ARCHIVE_WARN) {
1570 * Ignore a path which looks like the top of directory name
1571 * since we have already made the root directory of an ISO image.
1573 if (archive_strlen(&(file->parentdir)) == 0 &&
1574 archive_strlen(&(file->basename)) == 0) {
1579 isofile_add_entry(iso9660, file);
1580 isoent = isoent_new(file);
1581 if (isoent == NULL) {
1582 archive_set_error(&a->archive, ENOMEM,
1583 "Can't allocate data");
1584 return (ARCHIVE_FATAL);
1586 if (isoent->file->dircnt > iso9660->dircnt_max)
1587 iso9660->dircnt_max = isoent->file->dircnt;
1589 /* Add the current file into tree */
1590 r = isoent_tree(a, &isoent);
1591 if (r != ARCHIVE_OK)
1594 /* If there is the same file in tree and
1595 * the current file is older than the file in tree.
1596 * So we don't need the current file data anymore. */
1597 if (isoent->file != file)
1598 return (ARCHIVE_OK);
1600 /* Non regular files contents are unneeded to be saved to
1601 * temporary files. */
1602 if (archive_entry_filetype(file->entry) != AE_IFREG)
1606 * Set the current file to cur_file to read its contents.
1608 iso9660->cur_file = file;
1610 if (archive_entry_nlink(file->entry) > 1) {
1611 r = isofile_register_hardlink(a, file);
1612 if (r != ARCHIVE_OK)
1613 return (ARCHIVE_FATAL);
1617 * Prepare to save the contents of the file.
1619 if (iso9660->temp_fd < 0) {
1620 iso9660->temp_fd = __archive_mktemp(NULL);
1621 if (iso9660->temp_fd < 0) {
1622 archive_set_error(&a->archive, errno,
1623 "Couldn't create temporary file");
1624 return (ARCHIVE_FATAL);
1628 /* Save an offset of current file in temporary file. */
1629 file->content.offset_of_temp = wb_offset(a);
1630 file->cur_content = &(file->content);
1631 r = zisofs_init(a, file);
1634 iso9660->bytes_remaining = archive_entry_size(file->entry);
1640 write_to_temp(struct archive_write *a, const void *buff, size_t s)
1642 struct iso9660 *iso9660 = a->format_data;
1644 const unsigned char *b;
1646 b = (const unsigned char *)buff;
1648 written = write(iso9660->temp_fd, b, s);
1650 archive_set_error(&a->archive, errno,
1651 "Can't write to temporary file");
1652 return (ARCHIVE_FATAL);
1657 return (ARCHIVE_OK);
1661 wb_write_to_temp(struct archive_write *a, const void *buff, size_t s)
1663 const char *xp = buff;
1667 * If a written data size is big enough to use system-call
1668 * and there is no waiting data, this calls write_to_temp() in
1669 * order to reduce a extra memory copy.
1671 if (wb_remaining(a) == wb_buffmax() && s > (1024 * 16)) {
1672 struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
1673 xs = s % LOGICAL_BLOCK_SIZE;
1674 iso9660->wbuff_offset += s - xs;
1675 if (write_to_temp(a, buff, s - xs) != ARCHIVE_OK)
1676 return (ARCHIVE_FATAL);
1678 return (ARCHIVE_OK);
1684 if (size > wb_remaining(a))
1685 size = wb_remaining(a);
1686 memcpy(wb_buffptr(a), xp, size);
1687 if (wb_consume(a, size) != ARCHIVE_OK)
1688 return (ARCHIVE_FATAL);
1692 return (ARCHIVE_OK);
1696 wb_write_padding_to_temp(struct archive_write *a, int64_t csize)
1701 ns = (size_t)(csize % LOGICAL_BLOCK_SIZE);
1703 ret = write_null(a, LOGICAL_BLOCK_SIZE - ns);
1710 write_iso9660_data(struct archive_write *a, const void *buff, size_t s)
1712 struct iso9660 *iso9660 = a->format_data;
1715 if (iso9660->temp_fd < 0) {
1716 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1717 "Couldn't create temporary file");
1718 return (ARCHIVE_FATAL);
1722 if (iso9660->need_multi_extent &&
1723 (iso9660->cur_file->cur_content->size + ws) >=
1724 (MULTI_EXTENT_SIZE - LOGICAL_BLOCK_SIZE)) {
1725 struct content *con;
1728 ts = (size_t)(MULTI_EXTENT_SIZE - LOGICAL_BLOCK_SIZE -
1729 iso9660->cur_file->cur_content->size);
1731 if (iso9660->zisofs.detect_magic)
1732 zisofs_detect_magic(a, buff, ts);
1734 if (iso9660->zisofs.making) {
1735 if (zisofs_write_to_temp(a, buff, ts) != ARCHIVE_OK)
1736 return (ARCHIVE_FATAL);
1738 if (wb_write_to_temp(a, buff, ts) != ARCHIVE_OK)
1739 return (ARCHIVE_FATAL);
1740 iso9660->cur_file->cur_content->size += ts;
1743 /* Write padding. */
1744 if (wb_write_padding_to_temp(a,
1745 iso9660->cur_file->cur_content->size) != ARCHIVE_OK)
1746 return (ARCHIVE_FATAL);
1748 /* Compute the logical block number. */
1749 iso9660->cur_file->cur_content->blocks = (int)
1750 ((iso9660->cur_file->cur_content->size
1751 + LOGICAL_BLOCK_SIZE -1) >> LOGICAL_BLOCK_BITS);
1757 buff = (const void *)(((const unsigned char *)buff) + ts);
1758 /* Make a content for next extent. */
1759 con = calloc(1, sizeof(*con));
1761 archive_set_error(&a->archive, ENOMEM,
1762 "Can't allocate content data");
1763 return (ARCHIVE_FATAL);
1765 con->offset_of_temp = wb_offset(a);
1766 iso9660->cur_file->cur_content->next = con;
1767 iso9660->cur_file->cur_content = con;
1769 iso9660->zisofs.block_offset = 0;
1773 if (iso9660->zisofs.detect_magic)
1774 zisofs_detect_magic(a, buff, ws);
1776 if (iso9660->zisofs.making) {
1777 if (zisofs_write_to_temp(a, buff, ws) != ARCHIVE_OK)
1778 return (ARCHIVE_FATAL);
1780 if (wb_write_to_temp(a, buff, ws) != ARCHIVE_OK)
1781 return (ARCHIVE_FATAL);
1782 iso9660->cur_file->cur_content->size += ws;
1789 iso9660_write_data(struct archive_write *a, const void *buff, size_t s)
1791 struct iso9660 *iso9660 = a->format_data;
1794 if (iso9660->cur_file == NULL)
1796 if (archive_entry_filetype(iso9660->cur_file->entry) != AE_IFREG)
1798 if (s > iso9660->bytes_remaining)
1799 s = (size_t)iso9660->bytes_remaining;
1803 r = write_iso9660_data(a, buff, s);
1805 iso9660->bytes_remaining -= r;
1810 iso9660_finish_entry(struct archive_write *a)
1812 struct iso9660 *iso9660 = a->format_data;
1814 if (iso9660->cur_file == NULL)
1815 return (ARCHIVE_OK);
1816 if (archive_entry_filetype(iso9660->cur_file->entry) != AE_IFREG)
1817 return (ARCHIVE_OK);
1818 if (iso9660->cur_file->content.size == 0)
1819 return (ARCHIVE_OK);
1821 /* If there are unwritten data, write null data instead. */
1822 while (iso9660->bytes_remaining > 0) {
1825 s = (iso9660->bytes_remaining > a->null_length)?
1826 a->null_length: (size_t)iso9660->bytes_remaining;
1827 if (write_iso9660_data(a, a->nulls, s) < 0)
1828 return (ARCHIVE_FATAL);
1829 iso9660->bytes_remaining -= s;
1832 if (iso9660->zisofs.making && zisofs_finish_entry(a) != ARCHIVE_OK)
1833 return (ARCHIVE_FATAL);
1835 /* Write padding. */
1836 if (wb_write_padding_to_temp(a, iso9660->cur_file->cur_content->size)
1838 return (ARCHIVE_FATAL);
1840 /* Compute the logical block number. */
1841 iso9660->cur_file->cur_content->blocks = (int)
1842 ((iso9660->cur_file->cur_content->size
1843 + LOGICAL_BLOCK_SIZE -1) >> LOGICAL_BLOCK_BITS);
1845 /* Add the current file to data file list. */
1846 isofile_add_data_file(iso9660, iso9660->cur_file);
1848 return (ARCHIVE_OK);
1852 iso9660_close(struct archive_write *a)
1854 struct iso9660 *iso9660;
1857 iso9660 = a->format_data;
1860 * Write remaining data out to the temporary file.
1862 if (wb_remaining(a) > 0) {
1863 ret = wb_write_out(a);
1872 if (iso9660->birth_time == 0)
1874 time(&(iso9660->birth_time));
1877 * Prepare a bootable ISO image.
1879 if (iso9660->opt.boot) {
1880 /* Find out the boot file entry. */
1881 ret = isoent_find_out_boot_file(a, iso9660->primary.rootent);
1884 /* Reconvert the boot file from zisofs'ed form to
1886 ret = zisofs_rewind_boot_file(a);
1889 /* Write remaining data out to the temporary file. */
1890 if (wb_remaining(a) > 0) {
1891 ret = wb_write_out(a);
1895 /* Create the boot catalog. */
1896 ret = isoent_create_boot_catalog(a, iso9660->primary.rootent);
1902 * Prepare joliet extensions.
1904 if (iso9660->opt.joliet) {
1905 /* Make a new tree for joliet. */
1906 ret = isoent_clone_tree(a, &(iso9660->joliet.rootent),
1907 iso9660->primary.rootent);
1910 /* Make sure we have UTF-16BE converters.
1911 * if there is no file entry, converters are still
1913 if (iso9660->sconv_to_utf16be == NULL) {
1914 iso9660->sconv_to_utf16be =
1915 archive_string_conversion_to_charset(
1916 &(a->archive), "UTF-16BE", 1);
1917 if (iso9660->sconv_to_utf16be == NULL)
1918 /* Couldn't allocate memory */
1919 return (ARCHIVE_FATAL);
1920 iso9660->sconv_from_utf16be =
1921 archive_string_conversion_from_charset(
1922 &(a->archive), "UTF-16BE", 1);
1923 if (iso9660->sconv_from_utf16be == NULL)
1924 /* Couldn't allocate memory */
1925 return (ARCHIVE_FATAL);
1932 ret = isoent_make_path_table(a);
1937 * Calculate a total volume size and setup all locations of
1938 * contents of an iso9660 image.
1940 blocks = SYSTEM_AREA_BLOCK
1941 + PRIMARY_VOLUME_DESCRIPTOR_BLOCK
1942 + VOLUME_DESCRIPTOR_SET_TERMINATOR_BLOCK
1943 + NON_ISO_FILE_SYSTEM_INFORMATION_BLOCK;
1944 if (iso9660->opt.boot)
1945 blocks += BOOT_RECORD_DESCRIPTOR_BLOCK;
1946 if (iso9660->opt.joliet)
1947 blocks += SUPPLEMENTARY_VOLUME_DESCRIPTOR_BLOCK;
1948 if (iso9660->opt.iso_level == 4)
1949 blocks += SUPPLEMENTARY_VOLUME_DESCRIPTOR_BLOCK;
1951 /* Setup the locations of Path Table. */
1952 iso9660->primary.location_type_L_path_table = blocks;
1953 blocks += iso9660->primary.path_table_block;
1954 iso9660->primary.location_type_M_path_table = blocks;
1955 blocks += iso9660->primary.path_table_block;
1956 if (iso9660->opt.joliet) {
1957 iso9660->joliet.location_type_L_path_table = blocks;
1958 blocks += iso9660->joliet.path_table_block;
1959 iso9660->joliet.location_type_M_path_table = blocks;
1960 blocks += iso9660->joliet.path_table_block;
1963 /* Setup the locations of directories. */
1964 isoent_setup_directory_location(iso9660, blocks,
1965 &(iso9660->primary));
1966 blocks += iso9660->primary.total_dir_block;
1967 if (iso9660->opt.joliet) {
1968 isoent_setup_directory_location(iso9660, blocks,
1969 &(iso9660->joliet));
1970 blocks += iso9660->joliet.total_dir_block;
1973 if (iso9660->opt.rr) {
1974 iso9660->location_rrip_er = blocks;
1975 blocks += RRIP_ER_BLOCK;
1978 /* Setup the locations of all file contents. */
1979 isoent_setup_file_location(iso9660, blocks);
1980 blocks += iso9660->total_file_block;
1981 if (iso9660->opt.boot && iso9660->opt.boot_info_table) {
1982 ret = setup_boot_information(a);
1987 /* Now we have a total volume size. */
1988 iso9660->volume_space_size = blocks;
1989 if (iso9660->opt.pad)
1990 iso9660->volume_space_size += PADDING_BLOCK;
1991 iso9660->volume_sequence_number = 1;
1995 * Write an ISO 9660 image.
1998 /* Switch to start using wbuff as file buffer. */
1999 iso9660->wbuff_remaining = wb_buffmax();
2000 iso9660->wbuff_type = WB_TO_STREAM;
2001 iso9660->wbuff_offset = 0;
2002 iso9660->wbuff_written = 0;
2003 iso9660->wbuff_tail = 0;
2005 /* Write The System Area */
2006 ret = write_null(a, SYSTEM_AREA_BLOCK * LOGICAL_BLOCK_SIZE);
2007 if (ret != ARCHIVE_OK)
2008 return (ARCHIVE_FATAL);
2010 /* Write Primary Volume Descriptor */
2011 ret = write_VD(a, &(iso9660->primary));
2012 if (ret != ARCHIVE_OK)
2013 return (ARCHIVE_FATAL);
2015 if (iso9660->opt.boot) {
2016 /* Write Boot Record Volume Descriptor */
2017 ret = write_VD_boot_record(a);
2018 if (ret != ARCHIVE_OK)
2019 return (ARCHIVE_FATAL);
2022 if (iso9660->opt.iso_level == 4) {
2023 /* Write Enhanced Volume Descriptor */
2024 iso9660->primary.vdd_type = VDD_ENHANCED;
2025 ret = write_VD(a, &(iso9660->primary));
2026 iso9660->primary.vdd_type = VDD_PRIMARY;
2027 if (ret != ARCHIVE_OK)
2028 return (ARCHIVE_FATAL);
2031 if (iso9660->opt.joliet) {
2032 ret = write_VD(a, &(iso9660->joliet));
2033 if (ret != ARCHIVE_OK)
2034 return (ARCHIVE_FATAL);
2037 /* Write Volume Descriptor Set Terminator */
2038 ret = write_VD_terminator(a);
2039 if (ret != ARCHIVE_OK)
2040 return (ARCHIVE_FATAL);
2042 /* Write Non-ISO File System Information */
2043 ret = write_information_block(a);
2044 if (ret != ARCHIVE_OK)
2045 return (ARCHIVE_FATAL);
2047 /* Write Type L Path Table */
2048 ret = write_path_table(a, 0, &(iso9660->primary));
2049 if (ret != ARCHIVE_OK)
2050 return (ARCHIVE_FATAL);
2052 /* Write Type M Path Table */
2053 ret = write_path_table(a, 1, &(iso9660->primary));
2054 if (ret != ARCHIVE_OK)
2055 return (ARCHIVE_FATAL);
2057 if (iso9660->opt.joliet) {
2058 /* Write Type L Path Table */
2059 ret = write_path_table(a, 0, &(iso9660->joliet));
2060 if (ret != ARCHIVE_OK)
2061 return (ARCHIVE_FATAL);
2063 /* Write Type M Path Table */
2064 ret = write_path_table(a, 1, &(iso9660->joliet));
2065 if (ret != ARCHIVE_OK)
2066 return (ARCHIVE_FATAL);
2069 /* Write Directory Descriptors */
2070 ret = write_directory_descriptors(a, &(iso9660->primary));
2071 if (ret != ARCHIVE_OK)
2072 return (ARCHIVE_FATAL);
2074 if (iso9660->opt.joliet) {
2075 ret = write_directory_descriptors(a, &(iso9660->joliet));
2076 if (ret != ARCHIVE_OK)
2077 return (ARCHIVE_FATAL);
2080 if (iso9660->opt.rr) {
2081 /* Write Rockridge ER(Extensions Reference) */
2082 ret = write_rr_ER(a);
2083 if (ret != ARCHIVE_OK)
2084 return (ARCHIVE_FATAL);
2087 /* Write File Descriptors */
2088 ret = write_file_descriptors(a);
2089 if (ret != ARCHIVE_OK)
2090 return (ARCHIVE_FATAL);
2093 if (iso9660->opt.pad) {
2094 ret = write_null(a, PADDING_BLOCK * LOGICAL_BLOCK_SIZE);
2095 if (ret != ARCHIVE_OK)
2096 return (ARCHIVE_FATAL);
2099 if (iso9660->directories_too_deep != NULL) {
2100 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
2101 "%s: Directories too deep.",
2102 archive_entry_pathname(
2103 iso9660->directories_too_deep->file->entry));
2104 return (ARCHIVE_WARN);
2107 /* Write remaining data out. */
2108 ret = wb_write_out(a);
2114 iso9660_free(struct archive_write *a)
2116 struct iso9660 *iso9660;
2119 iso9660 = a->format_data;
2121 /* Close the temporary file. */
2122 if (iso9660->temp_fd >= 0)
2123 close(iso9660->temp_fd);
2125 /* Free some stuff for zisofs operations. */
2126 ret = zisofs_free(a);
2128 /* Remove directory entries in tree which includes file entries. */
2129 isoent_free_all(iso9660->primary.rootent);
2130 for (i = 0; i < iso9660->primary.max_depth; i++)
2131 free(iso9660->primary.pathtbl[i].sorted);
2132 free(iso9660->primary.pathtbl);
2134 if (iso9660->opt.joliet) {
2135 isoent_free_all(iso9660->joliet.rootent);
2136 for (i = 0; i < iso9660->joliet.max_depth; i++)
2137 free(iso9660->joliet.pathtbl[i].sorted);
2138 free(iso9660->joliet.pathtbl);
2141 /* Remove isofile entries. */
2142 isofile_free_all_entries(iso9660);
2143 isofile_free_hardlinks(iso9660);
2145 archive_string_free(&(iso9660->cur_dirstr));
2146 archive_string_free(&(iso9660->volume_identifier));
2147 archive_string_free(&(iso9660->publisher_identifier));
2148 archive_string_free(&(iso9660->data_preparer_identifier));
2149 archive_string_free(&(iso9660->application_identifier));
2150 archive_string_free(&(iso9660->copyright_file_identifier));
2151 archive_string_free(&(iso9660->abstract_file_identifier));
2152 archive_string_free(&(iso9660->bibliographic_file_identifier));
2153 archive_string_free(&(iso9660->el_torito.catalog_filename));
2154 archive_string_free(&(iso9660->el_torito.boot_filename));
2155 archive_string_free(&(iso9660->el_torito.id));
2156 archive_string_free(&(iso9660->utf16be));
2157 archive_string_free(&(iso9660->mbs));
2160 a->format_data = NULL;
2166 * Get the System Identifier
2169 get_system_identitier(char *system_id, size_t size)
2171 #if defined(HAVE_SYS_UTSNAME_H)
2175 strncpy(system_id, u.sysname, size-1);
2176 system_id[size-1] = '\0';
2177 #elif defined(_WIN32) && !defined(__CYGWIN__)
2178 strncpy(system_id, "Windows", size-1);
2179 system_id[size-1] = '\0';
2181 #error no way to get the system identifier on your platform.
2186 set_str(unsigned char *p, const char *s, size_t l, char f, const char *map)
2192 while ((c = *s++) != 0 && l > 0) {
2193 if (c >= 0x80 || map[c] == 0)
2195 /* illegal character */
2196 if (c >= 'a' && c <= 'z') {
2197 /* convert c from a-z to A-Z */
2205 /* If l isn't zero, fill p buffer by the character
2206 * which indicated by f. */
2212 joliet_allowed_char(unsigned char high, unsigned char low)
2214 int utf16 = (high << 8) | low;
2216 if (utf16 <= 0x001F)
2220 case 0x002A: /* '*' */
2221 case 0x002F: /* '/' */
2222 case 0x003A: /* ':' */
2223 case 0x003B: /* ';' */
2224 case 0x003F: /* '?' */
2225 case 0x005C: /* '\' */
2226 return (0);/* Not allowed. */
2232 set_str_utf16be(struct archive_write *a, unsigned char *p, const char *s,
2233 size_t l, uint16_t uf, enum vdc vdc)
2245 if (vdc == VDC_UCS2) {
2246 struct iso9660 *iso9660 = a->format_data;
2247 if (archive_strncpy_l(&iso9660->utf16be, s, strlen(s),
2248 iso9660->sconv_to_utf16be) != 0 && errno == ENOMEM) {
2249 archive_set_error(&a->archive, ENOMEM,
2250 "Can't allocate memory for UTF-16BE");
2251 return (ARCHIVE_FATAL);
2253 size = iso9660->utf16be.length;
2256 memcpy(p, iso9660->utf16be.s, size);
2258 const uint16_t *u16 = (const uint16_t *)s;
2267 for (i = 0; i < size; i += 2, p += 2) {
2268 if (!joliet_allowed_char(p[0], p[1]))
2269 archive_be16enc(p, 0x005F);/* '_' */
2273 archive_be16enc(p, uf);
2279 return (ARCHIVE_OK);
2282 static const char a_characters_map[0x80] = {
2283 /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
2284 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 00-0F */
2285 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 10-1F */
2286 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 20-2F */
2287 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 30-3F */
2288 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 40-4F */
2289 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,/* 50-5F */
2290 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 60-6F */
2291 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 70-7F */
2294 static const char a1_characters_map[0x80] = {
2295 /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
2296 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 00-0F */
2297 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 10-1F */
2298 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 20-2F */
2299 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 30-3F */
2300 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 40-4F */
2301 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,/* 50-5F */
2302 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 60-6F */
2303 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,/* 70-7F */
2306 static const char d_characters_map[0x80] = {
2307 /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
2308 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 00-0F */
2309 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 10-1F */
2310 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 20-2F */
2311 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,/* 30-3F */
2312 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 40-4F */
2313 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,/* 50-5F */
2314 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 60-6F */
2315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 70-7F */
2318 static const char d1_characters_map[0x80] = {
2319 /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
2320 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 00-0F */
2321 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 10-1F */
2322 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,/* 20-2F */
2323 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,/* 30-3F */
2324 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 40-4F */
2325 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,/* 50-5F */
2326 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,/* 60-6F */
2327 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,/* 70-7F */
2331 set_str_a_characters_bp(struct archive_write *a, unsigned char *bp,
2332 int from, int to, const char *s, enum vdc vdc)
2338 set_str(bp+from, s, to - from + 1, 0x20,
2343 set_str(bp+from, s, to - from + 1, 0x20,
2348 case VDC_UCS2_DIRECT:
2349 r = set_str_utf16be(a, bp+from, s, to - from + 1,
2359 set_str_d_characters_bp(struct archive_write *a, unsigned char *bp,
2360 int from, int to, const char *s, enum vdc vdc)
2366 set_str(bp+from, s, to - from + 1, 0x20,
2371 set_str(bp+from, s, to - from + 1, 0x20,
2376 case VDC_UCS2_DIRECT:
2377 r = set_str_utf16be(a, bp+from, s, to - from + 1,
2387 set_VD_bp(unsigned char *bp, enum VD_type type, unsigned char ver)
2390 /* Volume Descriptor Type */
2391 bp[1] = (unsigned char)type;
2392 /* Standard Identifier */
2393 memcpy(bp + 2, "CD001", 5);
2394 /* Volume Descriptor Version */
2399 set_unused_field_bp(unsigned char *bp, int from, int to)
2401 memset(bp + from, 0, to - from + 1);
2405 * 8-bit unsigned numerical values.
2406 * ISO9660 Standard 7.1.1
2409 set_num_711(unsigned char *p, unsigned char value)
2415 * 8-bit signed numerical values.
2416 * ISO9660 Standard 7.1.2
2419 set_num_712(unsigned char *p, char value)
2421 *((char *)p) = value;
2425 * Least significant byte first.
2426 * ISO9660 Standard 7.2.1
2429 set_num_721(unsigned char *p, uint16_t value)
2431 archive_le16enc(p, value);
2435 * Most significant byte first.
2436 * ISO9660 Standard 7.2.2
2439 set_num_722(unsigned char *p, uint16_t value)
2441 archive_be16enc(p, value);
2446 * ISO9660 Standard 7.2.3
2449 set_num_723(unsigned char *p, uint16_t value)
2451 archive_le16enc(p, value);
2452 archive_be16enc(p+2, value);
2456 * Least significant byte first.
2457 * ISO9660 Standard 7.3.1
2460 set_num_731(unsigned char *p, uint32_t value)
2462 archive_le32enc(p, value);
2466 * Most significant byte first.
2467 * ISO9660 Standard 7.3.2
2470 set_num_732(unsigned char *p, uint32_t value)
2472 archive_be32enc(p, value);
2477 * ISO9660 Standard 7.3.3
2480 set_num_733(unsigned char *p, uint32_t value)
2482 archive_le32enc(p, value);
2483 archive_be32enc(p+4, value);
2487 set_digit(unsigned char *p, size_t s, int value)
2491 p[s] = '0' + (value % 10);
2496 #if defined(HAVE_STRUCT_TM_TM_GMTOFF)
2497 #define get_gmoffset(tm) ((tm)->tm_gmtoff)
2498 #elif defined(HAVE_STRUCT_TM___TM_GMTOFF)
2499 #define get_gmoffset(tm) ((tm)->__tm_gmtoff)
2502 get_gmoffset(struct tm *tm)
2506 #if defined(HAVE__GET_TIMEZONE)
2507 _get_timezone(&offset);
2508 #elif defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
2521 get_tmfromtime(struct tm *tm, time_t *t)
2523 #if HAVE_LOCALTIME_R
2526 #elif HAVE__LOCALTIME64_S
2527 __time64_t tmp_t = (__time64_t) *t; //time_t may be shorter than 64 bits
2528 _localtime64_s(tm, &tmp_t);
2530 memcpy(tm, localtime(t), sizeof(*tm));
2535 * Date and Time Format.
2536 * ISO9660 Standard 8.4.26.1
2539 set_date_time(unsigned char *p, time_t t)
2543 get_tmfromtime(&tm, &t);
2544 set_digit(p, 4, tm.tm_year + 1900);
2545 set_digit(p+4, 2, tm.tm_mon + 1);
2546 set_digit(p+6, 2, tm.tm_mday);
2547 set_digit(p+8, 2, tm.tm_hour);
2548 set_digit(p+10, 2, tm.tm_min);
2549 set_digit(p+12, 2, tm.tm_sec);
2550 set_digit(p+14, 2, 0);
2551 set_num_712(p+16, (char)(get_gmoffset(&tm)/(60*15)));
2555 set_date_time_null(unsigned char *p)
2557 memset(p, (int)'0', 16);
2562 set_time_915(unsigned char *p, time_t t)
2566 get_tmfromtime(&tm, &t);
2567 set_num_711(p+0, tm.tm_year);
2568 set_num_711(p+1, tm.tm_mon+1);
2569 set_num_711(p+2, tm.tm_mday);
2570 set_num_711(p+3, tm.tm_hour);
2571 set_num_711(p+4, tm.tm_min);
2572 set_num_711(p+5, tm.tm_sec);
2573 set_num_712(p+6, (char)(get_gmoffset(&tm)/(60*15)));
2578 * Write SUSP "CE" System Use Entry.
2581 set_SUSP_CE(unsigned char *p, int location, int offset, int size)
2583 unsigned char *bp = p -1;
2584 /* Extend the System Use Area
2587 * +----+----+----+----+-----------+-----------+
2588 * | 'C'| 'E'| 1C | 01 | LOCATION1 | LOCATION2 |
2589 * +----+----+----+----+-----------+-----------+
2595 * LOCATION1 : Location of Continuation of System Use Area.
2596 * LOCATION2 : Offset to Start of Continuation.
2597 * LOCATION3 : Length of the Continuation.
2602 bp[3] = RR_CE_SIZE; /* length */
2603 bp[4] = 1; /* version */
2604 set_num_733(bp+5, location);
2605 set_num_733(bp+13, offset);
2606 set_num_733(bp+21, size);
2607 return (RR_CE_SIZE);
2611 * The functions, which names are beginning with extra_, are used to
2612 * control extra records.
2613 * The maximum size of a Directory Record is 254. When a filename is
2614 * very long, all of RRIP data of a file won't stored to the Directory
2615 * Record and so remaining RRIP data store to an extra record instead.
2617 static unsigned char *
2618 extra_open_record(unsigned char *bp, int dr_len, struct isoent *isoent,
2619 struct ctl_extr_rec *ctl)
2625 ctl->isoent = isoent;
2627 ctl->cur_len = ctl->dr_len = dr_len;
2628 ctl->limit = DR_LIMIT;
2634 extra_close_record(struct ctl_extr_rec *ctl, int ce_size)
2639 extra_tell_used_size(ctl, ce_size);
2641 if (ctl->cur_len & 0x01) {
2643 if (ctl->bp != NULL)
2644 ctl->bp[ctl->cur_len] = 0;
2647 if (ctl->use_extr) {
2648 if (ctl->ce_ptr != NULL)
2649 set_SUSP_CE(ctl->ce_ptr, ctl->extr_loc,
2650 ctl->extr_off, ctl->cur_len - padding);
2652 ctl->dr_len = ctl->cur_len;
2655 #define extra_space(ctl) ((ctl)->limit - (ctl)->cur_len)
2657 static unsigned char *
2658 extra_next_record(struct ctl_extr_rec *ctl, int length)
2660 int cur_len = ctl->cur_len;/* save cur_len */
2662 /* Close the current extra record or Directory Record. */
2663 extra_close_record(ctl, RR_CE_SIZE);
2665 /* Get a next extra record. */
2667 if (ctl->bp != NULL) {
2668 /* Storing data into an extra record. */
2671 /* Save the pointer where a CE extension will be
2673 ctl->ce_ptr = &ctl->bp[cur_len+1];
2674 p = extra_get_record(ctl->isoent,
2675 &ctl->limit, &ctl->extr_off, &ctl->extr_loc);
2676 ctl->bp = p - 1;/* the base of bp offset is 1. */
2678 /* Calculating the size of an extra record. */
2679 (void)extra_get_record(ctl->isoent,
2680 &ctl->limit, NULL, NULL);
2682 /* Check if an extra record is almost full.
2683 * If so, get a next one. */
2684 if (extra_space(ctl) < length)
2685 (void)extra_next_record(ctl, length);
2690 static inline struct extr_rec *
2691 extra_last_record(struct isoent *isoent)
2693 if (isoent->extr_rec_list.first == NULL)
2695 return ((struct extr_rec *)(void *)
2696 ((char *)(isoent->extr_rec_list.last)
2697 - offsetof(struct extr_rec, next)));
2700 static unsigned char *
2701 extra_get_record(struct isoent *isoent, int *space, int *off, int *loc)
2703 struct extr_rec *rec;
2705 isoent = isoent->parent;
2707 /* Storing data into an extra record. */
2708 rec = isoent->extr_rec_list.current;
2709 if (DR_SAFETY > LOGICAL_BLOCK_SIZE - rec->offset)
2712 /* Calculating the size of an extra record. */
2713 rec = extra_last_record(isoent);
2715 DR_SAFETY > LOGICAL_BLOCK_SIZE - rec->offset) {
2716 rec = malloc(sizeof(*rec));
2721 /* Insert `rec` into the tail of isoent->extr_rec_list */
2724 * Note: testing isoent->extr_rec_list.last == NULL
2725 * here is really unneeded since it has been already
2726 * initialized at isoent_new function but Clang Static
2727 * Analyzer claims that it is dereference of null
2730 if (isoent->extr_rec_list.last == NULL)
2731 isoent->extr_rec_list.last =
2732 &(isoent->extr_rec_list.first);
2733 *isoent->extr_rec_list.last = rec;
2734 isoent->extr_rec_list.last = &(rec->next);
2737 *space = LOGICAL_BLOCK_SIZE - rec->offset - DR_SAFETY;
2739 *space -= 1;/* Keep padding space. */
2743 *loc = rec->location;
2744 isoent->extr_rec_list.current = rec;
2746 return (&rec->buf[rec->offset]);
2750 extra_tell_used_size(struct ctl_extr_rec *ctl, int size)
2752 struct isoent *isoent;
2753 struct extr_rec *rec;
2755 if (ctl->use_extr) {
2756 isoent = ctl->isoent->parent;
2757 rec = isoent->extr_rec_list.current;
2759 rec->offset += size;
2761 ctl->cur_len += size;
2765 extra_setup_location(struct isoent *isoent, int location)
2767 struct extr_rec *rec;
2771 rec = isoent->extr_rec_list.first;
2772 isoent->extr_rec_list.current = rec;
2775 rec->location = location++;
2783 * Create the RRIP entries.
2786 set_directory_record_rr(unsigned char *bp, int dr_len,
2787 struct isoent *isoent, struct iso9660 *iso9660, enum dir_rec_type t)
2789 /* Flags(BP 5) of the Rockridge "RR" System Use Field */
2790 unsigned char rr_flag;
2791 #define RR_USE_PX 0x01
2792 #define RR_USE_PN 0x02
2793 #define RR_USE_SL 0x04
2794 #define RR_USE_NM 0x08
2795 #define RR_USE_CL 0x10
2796 #define RR_USE_PL 0x20
2797 #define RR_USE_RE 0x40
2798 #define RR_USE_TF 0x80
2800 struct ctl_extr_rec ctl;
2801 struct isoent *rr_parent, *pxent;
2802 struct isofile *file;
2804 bp = extra_open_record(bp, dr_len, isoent, &ctl);
2806 if (t == DIR_REC_PARENT) {
2807 rr_parent = isoent->rr_parent;
2808 pxent = isoent->parent;
2809 if (rr_parent != NULL)
2812 isoent = isoent->parent;
2817 file = isoent->file;
2819 if (t != DIR_REC_NORMAL) {
2820 rr_flag = RR_USE_PX | RR_USE_TF;
2821 if (rr_parent != NULL)
2822 rr_flag |= RR_USE_PL;
2824 rr_flag = RR_USE_PX | RR_USE_NM | RR_USE_TF;
2825 if (archive_entry_filetype(file->entry) == AE_IFLNK)
2826 rr_flag |= RR_USE_SL;
2827 if (isoent->rr_parent != NULL)
2828 rr_flag |= RR_USE_RE;
2829 if (isoent->rr_child != NULL)
2830 rr_flag |= RR_USE_CL;
2831 if (archive_entry_filetype(file->entry) == AE_IFCHR ||
2832 archive_entry_filetype(file->entry) == AE_IFBLK)
2833 rr_flag |= RR_USE_PN;
2834 #ifdef COMPAT_MKISOFS
2836 * mkisofs 2.01.01a63 records "RE" extension to
2837 * the entry of "rr_moved" directory.
2838 * I don't understand this behavior.
2840 if (isoent->virtual &&
2841 isoent->parent == iso9660->primary.rootent &&
2842 strcmp(isoent->file->basename.s, "rr_moved") == 0)
2843 rr_flag |= RR_USE_RE;
2847 /* Write "SP" System Use Entry. */
2848 if (t == DIR_REC_SELF && isoent == isoent->parent) {
2854 bp[4] = 1; /* version */
2855 bp[5] = 0xBE; /* Check Byte */
2856 bp[6] = 0xEF; /* Check Byte */
2860 extra_tell_used_size(&ctl, length);
2863 /* Write "RR" System Use Entry. */
2865 if (extra_space(&ctl) < length)
2866 bp = extra_next_record(&ctl, length);
2871 bp[4] = 1; /* version */
2875 extra_tell_used_size(&ctl, length);
2877 /* Write "NM" System Use Entry. */
2878 if (rr_flag & RR_USE_NM) {
2881 * e.g. a basename is 'foo'
2883 * +----+----+----+----+----+----+----+----+
2884 * | 'N'| 'M'| 08 | 01 | 00 | 'f'| 'o'| 'o'|
2885 * +----+----+----+----+----+----+----+----+
2886 * <----------------- len ----------------->
2888 size_t nmlen = file->basename.length;
2889 const char *nm = file->basename.s;
2892 if (extra_space(&ctl) < 6)
2893 bp = extra_next_record(&ctl, 6);
2897 bp[4] = 1; /* version */
2899 nmmax = extra_space(&ctl);
2902 while (nmlen + 5 > nmmax) {
2903 length = (int)nmmax;
2906 bp[5] = 0x01;/* Alternate Name continues
2907 * in next "NM" field */
2908 memcpy(bp+6, nm, length - 5);
2911 nmlen -= length - 5;
2913 extra_tell_used_size(&ctl, length);
2914 if (extra_space(&ctl) < 6) {
2915 bp = extra_next_record(&ctl, 6);
2916 nmmax = extra_space(&ctl);
2923 bp[4] = 1; /* version */
2926 length = 5 + (int)nmlen;
2930 memcpy(bp+6, nm, nmlen);
2933 extra_tell_used_size(&ctl, length);
2936 /* Write "PX" System Use Entry. */
2937 if (rr_flag & RR_USE_PX) {
2941 * +----+----+----+----+-----------+-----------+
2942 * | 'P'| 'X'| 2C | 01 | FILE MODE | LINKS |
2943 * +----+----+----+----+-----------+-----------+
2945 * +-----------+-----------+------------------+
2946 * | USER ID | GROUP ID |FILE SERIAL NUMBER|
2947 * +-----------+-----------+------------------+
2951 if (extra_space(&ctl) < length)
2952 bp = extra_next_record(&ctl, length);
2958 mode = archive_entry_mode(file->entry);
2959 uid = archive_entry_uid(file->entry);
2960 gid = archive_entry_gid(file->entry);
2961 if (iso9660->opt.rr == OPT_RR_USEFUL) {
2963 * This action is similar to mkisofs -r option
2964 * but our rockridge=useful option does not
2965 * set a zero to uid and gid.
2967 /* set all read bit ON */
2969 #if !defined(_WIN32) && !defined(__CYGWIN__)
2972 /* set all exec bit ON */
2974 /* clear all write bits. */
2976 /* clear setuid,setgid,sticky bits. */
2983 bp[4] = 1; /* version */
2985 set_num_733(bp+5, mode);
2986 /* file links (stat.st_nlink) */
2988 archive_entry_nlink(file->entry));
2989 set_num_733(bp+21, (uint32_t)uid);
2990 set_num_733(bp+29, (uint32_t)gid);
2991 /* File Serial Number */
2993 set_num_733(bp+37, pxent->dir_location);
2994 else if (file->hardlink_target != NULL)
2996 file->hardlink_target->cur_content->location);
2999 file->cur_content->location);
3002 extra_tell_used_size(&ctl, length);
3005 /* Write "SL" System Use Entry. */
3006 if (rr_flag & RR_USE_SL) {
3009 * e.g. a symbolic name is 'foo/bar'
3011 * +----+----+----+----+----+------------+
3012 * | 'S'| 'L'| 0F | 01 | 00 | components |
3013 * +----+----+----+----+----+-----+------+
3014 * 0 1 2 3 4 5 ...|... 15
3015 * <----------------- len --------+------>
3018 * +----+----+----+----+----+ |
3019 * | 00 | 03 | 'f'| 'o'| 'o'| <---+
3020 * +----+----+----+----+----+ |
3023 * +----+----+----+----+----+ |
3024 * | 00 | 03 | 'b'| 'a'| 'r'| <---+
3025 * +----+----+----+----+----+
3028 * - cflg : flag of component
3029 * - clen : length of component
3034 if (extra_space(&ctl) < 7)
3035 bp = extra_next_record(&ctl, 7);
3036 sl = file->symlink.s;
3041 bp[4] = 1; /* version */
3044 unsigned char *nc, *cf, *cl, cldmy = 0;
3047 slmax = extra_space(&ctl);
3056 while (*sl && sllen + 11 < slmax) {
3057 if (sl_last == '\0' && sl[0] == '/') {
3061 * | 08 | 00 | ROOT component.
3064 * Root component has to appear
3065 * at the first component only.
3069 *cf = 0x08; /* ROOT */
3078 if (((sl_last == '\0' || sl_last == '/') &&
3079 sl[0] == '.' && sl[1] == '.' &&
3080 (sl[2] == '/' || sl[2] == '\0')) ||
3082 sl[1] == '.' && sl[2] == '.' &&
3083 (sl[3] == '/' || sl[3] == '\0'))) {
3087 * | 04 | 00 | PARENT component.
3088 * +----+----+ ("..")
3092 *cf = 0x04; /* PARENT */
3097 sl += 3;/* skip "/.." */
3099 sl += 2;/* skip ".." */
3104 if (((sl_last == '\0' || sl_last == '/') &&
3106 (sl[1] == '/' || sl[1] == '\0')) ||
3107 (sl[0] == '/' && sl[1] == '.' &&
3108 (sl[2] == '/' || sl[2] == '\0'))) {
3112 * | 02 | 00 | CURRENT component.
3117 *cf = 0x02; /* CURRENT */
3122 sl += 2;/* skip "/." */
3124 sl ++; /* skip "." */
3129 if (sl[0] == '/' || cl == NULL) {
3154 * Mark flg as CONTINUE component.
3159 * +----+----+----+----+----+-
3160 * | 'S'| 'L'| XX | 01 | 01 |
3161 * +----+----+----+----+----+-
3163 * continues in next "SL"
3166 bp[5] = 0x01;/* This Symbolic Link
3171 extra_tell_used_size(&ctl, length);
3172 if (extra_space(&ctl) < 11)
3173 bp = extra_next_record(&ctl, 11);
3178 bp[4] = 1; /* version */
3187 extra_tell_used_size(&ctl, length);
3193 /* Write "TF" System Use Entry. */
3194 if (rr_flag & RR_USE_TF) {
3198 * +----+----+----+----+-----+-------------+
3199 * | 'T'| 'F'| XX | 01 |FLAGS| TIME STAMPS |
3200 * +----+----+----+----+-----+-------------+
3202 * TIME STAMPS : ISO 9660 Standard 9.1.5.
3203 * If TF_LONG_FORM FLAGS is set,
3204 * use ISO9660 Standard 8.4.26.1.
3206 #define TF_CREATION 0x01 /* Creation time recorded */
3207 #define TF_MODIFY 0x02 /* Modification time recorded */
3208 #define TF_ACCESS 0x04 /* Last Access time recorded */
3209 #define TF_ATTRIBUTES 0x08 /* Last Attribute Change time recorded */
3210 #define TF_BACKUP 0x10 /* Last Backup time recorded */
3211 #define TF_EXPIRATION 0x20 /* Expiration time recorded */
3212 #define TF_EFFECTIVE 0x40 /* Effective time recorded */
3213 #define TF_LONG_FORM 0x80 /* ISO 9660 17-byte time format used */
3214 unsigned char tf_flags;
3218 #ifndef COMPAT_MKISOFS
3219 if (archive_entry_birthtime_is_set(file->entry) &&
3220 archive_entry_birthtime(file->entry) <=
3221 archive_entry_mtime(file->entry)) {
3223 tf_flags |= TF_CREATION;
3226 if (archive_entry_mtime_is_set(file->entry)) {
3228 tf_flags |= TF_MODIFY;
3230 if (archive_entry_atime_is_set(file->entry)) {
3232 tf_flags |= TF_ACCESS;
3234 if (archive_entry_ctime_is_set(file->entry)) {
3236 tf_flags |= TF_ATTRIBUTES;
3238 if (extra_space(&ctl) < length)
3239 bp = extra_next_record(&ctl, length);
3244 bp[4] = 1; /* version */
3248 if (tf_flags & TF_CREATION) {
3250 archive_entry_birthtime(file->entry));
3253 /* Modification time */
3254 if (tf_flags & TF_MODIFY) {
3256 archive_entry_mtime(file->entry));
3259 /* Last Access time */
3260 if (tf_flags & TF_ACCESS) {
3262 archive_entry_atime(file->entry));
3265 /* Last Attribute Change time */
3266 if (tf_flags & TF_ATTRIBUTES) {
3268 archive_entry_ctime(file->entry));
3272 extra_tell_used_size(&ctl, length);
3275 /* Write "RE" System Use Entry. */
3276 if (rr_flag & RR_USE_RE) {
3280 * +----+----+----+----+
3281 * | 'R'| 'E'| 04 | 01 |
3282 * +----+----+----+----+
3286 if (extra_space(&ctl) < length)
3287 bp = extra_next_record(&ctl, length);
3292 bp[4] = 1; /* version */
3295 extra_tell_used_size(&ctl, length);
3298 /* Write "PL" System Use Entry. */
3299 if (rr_flag & RR_USE_PL) {
3303 * +----+----+----+----+------------+
3304 * | 'P'| 'L'| 0C | 01 | *LOCATION |
3305 * +----+----+----+----+------------+
3307 * *LOCATION: location of parent directory
3310 if (extra_space(&ctl) < length)
3311 bp = extra_next_record(&ctl, length);
3316 bp[4] = 1; /* version */
3318 rr_parent->dir_location);
3321 extra_tell_used_size(&ctl, length);
3324 /* Write "CL" System Use Entry. */
3325 if (rr_flag & RR_USE_CL) {
3329 * +----+----+----+----+------------+
3330 * | 'C'| 'L'| 0C | 01 | *LOCATION |
3331 * +----+----+----+----+------------+
3333 * *LOCATION: location of child directory
3336 if (extra_space(&ctl) < length)
3337 bp = extra_next_record(&ctl, length);
3342 bp[4] = 1; /* version */
3344 isoent->rr_child->dir_location);
3347 extra_tell_used_size(&ctl, length);
3350 /* Write "PN" System Use Entry. */
3351 if (rr_flag & RR_USE_PN) {
3355 * +----+----+----+----+------------+------------+
3356 * | 'P'| 'N'| 14 | 01 | dev_t high | dev_t low |
3357 * +----+----+----+----+------------+------------+
3361 if (extra_space(&ctl) < length)
3362 bp = extra_next_record(&ctl, length);
3369 bp[4] = 1; /* version */
3370 dev = (uint64_t)archive_entry_rdev(file->entry);
3371 set_num_733(bp + 5, (uint32_t)(dev >> 32));
3372 set_num_733(bp + 13, (uint32_t)(dev & 0xFFFFFFFF));
3375 extra_tell_used_size(&ctl, length);
3378 /* Write "ZF" System Use Entry. */
3379 if (file->zisofs.header_size) {
3383 * +----+----+----+----+----+----+-------------+
3384 * | 'Z'| 'F'| 10 | 01 | 'p'| 'z'| Header Size |
3385 * +----+----+----+----+----+----+-------------+
3387 * +--------------------+-------------------+
3388 * | Log2 of block Size | Uncompressed Size |
3389 * +--------------------+-------------------+
3393 if (extra_space(&ctl) < length)
3394 bp = extra_next_record(&ctl, length);
3399 bp[4] = 1; /* version */
3402 bp[7] = file->zisofs.header_size;
3403 bp[8] = file->zisofs.log2_bs;
3404 set_num_733(bp + 9, file->zisofs.uncompressed_size);
3407 extra_tell_used_size(&ctl, length);
3410 /* Write "CE" System Use Entry. */
3411 if (t == DIR_REC_SELF && isoent == isoent->parent) {
3412 length = RR_CE_SIZE;
3414 set_SUSP_CE(bp+1, iso9660->location_rrip_er,
3416 extra_tell_used_size(&ctl, length);
3419 extra_close_record(&ctl, 0);
3421 return (ctl.dr_len);
3425 * Write data of a Directory Record or calculate writing bytes itself.
3426 * If parameter `p' is NULL, calculates the size of writing data, which
3427 * a Directory Record needs to write, then it saved and return
3428 * the calculated size.
3429 * Parameter `n' is a remaining size of buffer. when parameter `p' is
3430 * not NULL, check whether that `n' is not less than the saved size.
3431 * if that `n' is small, return zero.
3433 * This format of the Directory Record is according to
3434 * ISO9660 Standard 9.1
3437 set_directory_record(unsigned char *p, size_t n, struct isoent *isoent,
3438 struct iso9660 *iso9660, enum dir_rec_type t,
3439 enum vdd_type vdd_type)
3447 * Check whether a write buffer size is less than the
3448 * saved size which is needed to write this Directory
3453 dr_len = isoent->dr_len.vd; break;
3455 dr_len = isoent->dr_len.self; break;
3456 case DIR_REC_PARENT:
3457 dr_len = isoent->dr_len.parent; break;
3458 case DIR_REC_NORMAL:
3460 dr_len = isoent->dr_len.normal; break;
3463 return (0);/* Needs more buffer size. */
3466 if (t == DIR_REC_NORMAL && isoent->identifier != NULL)
3467 fi_len = isoent->id_len;
3472 struct isoent *xisoent;
3473 struct isofile *file;
3476 if (t == DIR_REC_PARENT)
3477 xisoent = isoent->parent;
3480 file = isoent->file;
3481 if (file->hardlink_target != NULL)
3482 file = file->hardlink_target;
3483 /* Make a file flag. */
3485 flag = FILE_FLAG_DIRECTORY;
3487 if (file->cur_content->next != NULL)
3488 flag = FILE_FLAG_MULTI_EXTENT;
3494 /* Extended Attribute Record Length */
3495 set_num_711(bp+2, 0);
3496 /* Location of Extent */
3498 set_num_733(bp+3, xisoent->dir_location);
3500 set_num_733(bp+3, file->cur_content->location);
3504 xisoent->dir_block * LOGICAL_BLOCK_SIZE);
3506 set_num_733(bp+11, (uint32_t)file->cur_content->size);
3507 /* Recording Date and Time */
3509 * If a file type is symbolic link, you are seeing this
3510 * field value is different from a value mkisofs makes.
3511 * libarchive uses lstat to get this one, but it
3512 * seems mkisofs uses stat to get.
3515 archive_entry_mtime(xisoent->file->entry));
3518 /* File Unit Size */
3519 set_num_711(bp+27, 0);
3520 /* Interleave Gap Size */
3521 set_num_711(bp+28, 0);
3522 /* Volume Sequence Number */
3523 set_num_723(bp+29, iso9660->volume_sequence_number);
3524 /* Length of File Identifier */
3525 set_num_711(bp+33, (unsigned char)fi_len);
3526 /* File Identifier */
3530 set_num_711(bp+34, 0);
3532 case DIR_REC_PARENT:
3533 set_num_711(bp+34, 1);
3535 case DIR_REC_NORMAL:
3536 if (isoent->identifier != NULL)
3537 memcpy(bp+34, isoent->identifier, fi_len);
3539 set_num_711(bp+34, 0);
3544 dr_len = 33 + fi_len;
3546 if (dr_len & 0x01) {
3552 /* Volume Descriptor does not record extension. */
3553 if (t == DIR_REC_VD) {
3555 /* Length of Directory Record */
3556 set_num_711(p, (unsigned char)dr_len);
3558 isoent->dr_len.vd = (int)dr_len;
3559 return ((int)dr_len);
3563 if (iso9660->opt.rr && vdd_type != VDD_JOLIET)
3564 dr_len = set_directory_record_rr(bp, (int)dr_len,
3565 isoent, iso9660, t);
3568 /* Length of Directory Record */
3569 set_num_711(p, (unsigned char)dr_len);
3572 * Save the size which is needed to write this
3577 /* This case does not come, but compiler
3578 * complains that DIR_REC_VD not handled
3582 isoent->dr_len.self = (int)dr_len; break;
3583 case DIR_REC_PARENT:
3584 isoent->dr_len.parent = (int)dr_len; break;
3585 case DIR_REC_NORMAL:
3586 isoent->dr_len.normal = (int)dr_len; break;
3590 return ((int)dr_len);
3594 * Calculate the size of a directory record.
3597 get_dir_rec_size(struct iso9660 *iso9660, struct isoent *isoent,
3598 enum dir_rec_type t, enum vdd_type vdd_type)
3601 return (set_directory_record(NULL, SIZE_MAX,
3602 isoent, iso9660, t, vdd_type));
3606 * Manage to write ISO-image data with wbuff to reduce calling
3607 * __archive_write_output() for performance.
3611 static inline unsigned char *
3612 wb_buffptr(struct archive_write *a)
3614 struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
3616 return (&(iso9660->wbuff[sizeof(iso9660->wbuff)
3617 - iso9660->wbuff_remaining]));
3621 wb_write_out(struct archive_write *a)
3623 struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
3627 wsize = sizeof(iso9660->wbuff) - iso9660->wbuff_remaining;
3628 nw = wsize % LOGICAL_BLOCK_SIZE;
3629 if (iso9660->wbuff_type == WB_TO_STREAM)
3630 r = __archive_write_output(a, iso9660->wbuff, wsize - nw);
3632 r = write_to_temp(a, iso9660->wbuff, wsize - nw);
3633 /* Increase the offset. */
3634 iso9660->wbuff_offset += wsize - nw;
3635 if (iso9660->wbuff_offset > iso9660->wbuff_written)
3636 iso9660->wbuff_written = iso9660->wbuff_offset;
3637 iso9660->wbuff_remaining = sizeof(iso9660->wbuff);
3639 iso9660->wbuff_remaining -= nw;
3640 memmove(iso9660->wbuff, iso9660->wbuff + wsize - nw, nw);
3646 wb_consume(struct archive_write *a, size_t size)
3648 struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
3650 if (size > iso9660->wbuff_remaining ||
3651 iso9660->wbuff_remaining == 0) {
3652 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3653 "Internal Programing error: iso9660:wb_consume()"
3654 " size=%jd, wbuff_remaining=%jd",
3655 (intmax_t)size, (intmax_t)iso9660->wbuff_remaining);
3656 return (ARCHIVE_FATAL);
3658 iso9660->wbuff_remaining -= size;
3659 if (iso9660->wbuff_remaining < LOGICAL_BLOCK_SIZE)
3660 return (wb_write_out(a));
3661 return (ARCHIVE_OK);
3667 wb_set_offset(struct archive_write *a, int64_t off)
3669 struct iso9660 *iso9660 = (struct iso9660 *)a->format_data;
3670 int64_t used, ext_bytes;
3672 if (iso9660->wbuff_type != WB_TO_TEMP) {
3673 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3674 "Internal Programing error: iso9660:wb_set_offset()");
3675 return (ARCHIVE_FATAL);
3678 used = sizeof(iso9660->wbuff) - iso9660->wbuff_remaining;
3679 if (iso9660->wbuff_offset + used > iso9660->wbuff_tail)
3680 iso9660->wbuff_tail = iso9660->wbuff_offset + used;
3681 if (iso9660->wbuff_offset < iso9660->wbuff_written) {
3683 write_to_temp(a, iso9660->wbuff, (size_t)used) != ARCHIVE_OK)
3684 return (ARCHIVE_FATAL);
3685 iso9660->wbuff_offset = iso9660->wbuff_written;
3686 lseek(iso9660->temp_fd, iso9660->wbuff_offset, SEEK_SET);
3687 iso9660->wbuff_remaining = sizeof(iso9660->wbuff);
3690 if (off < iso9660->wbuff_offset) {
3692 * Write out waiting data.
3695 if (wb_write_out(a) != ARCHIVE_OK)
3696 return (ARCHIVE_FATAL);
3698 lseek(iso9660->temp_fd, off, SEEK_SET);
3699 iso9660->wbuff_offset = off;
3700 iso9660->wbuff_remaining = sizeof(iso9660->wbuff);
3701 } else if (off <= iso9660->wbuff_tail) {
3702 iso9660->wbuff_remaining = (size_t)
3703 (sizeof(iso9660->wbuff) - (off - iso9660->wbuff_offset));
3705 ext_bytes = off - iso9660->wbuff_tail;
3706 iso9660->wbuff_remaining = (size_t)(sizeof(iso9660->wbuff)
3707 - (iso9660->wbuff_tail - iso9660->wbuff_offset));
3708 while (ext_bytes >= (int64_t)iso9660->wbuff_remaining) {
3709 if (write_null(a, (size_t)iso9660->wbuff_remaining)
3711 return (ARCHIVE_FATAL);
3712 ext_bytes -= iso9660->wbuff_remaining;
3714 if (ext_bytes > 0) {
3715 if (write_null(a, (size_t)ext_bytes) != ARCHIVE_OK)
3716 return (ARCHIVE_FATAL);
3719 return (ARCHIVE_OK);
3722 #endif /* HAVE_ZLIB_H */
3725 write_null(struct archive_write *a, size_t size)
3728 unsigned char *p, *old;
3731 remaining = wb_remaining(a);
3733 if (size <= remaining) {
3735 return (wb_consume(a, size));
3737 memset(p, 0, remaining);
3738 r = wb_consume(a, remaining);
3739 if (r != ARCHIVE_OK)
3744 memset(p, 0, old - p);
3745 remaining = wb_remaining(a);
3747 size_t wsize = size;
3749 if (wsize > remaining)
3751 r = wb_consume(a, wsize);
3752 if (r != ARCHIVE_OK)
3756 return (ARCHIVE_OK);
3760 * Write Volume Descriptor Set Terminator
3763 write_VD_terminator(struct archive_write *a)
3767 bp = wb_buffptr(a) -1;
3768 set_VD_bp(bp, VDT_TERMINATOR, 1);
3769 set_unused_field_bp(bp, 8, LOGICAL_BLOCK_SIZE);
3771 return (wb_consume(a, LOGICAL_BLOCK_SIZE));
3775 set_file_identifier(unsigned char *bp, int from, int to, enum vdc vdc,
3776 struct archive_write *a, struct vdd *vdd, struct archive_string *id,
3777 const char *label, int leading_under, enum char_type char_type)
3779 char identifier[256];
3780 struct isoent *isoent;
3785 if (id->length > 0 && leading_under && id->s[0] != '_') {
3786 if (char_type == A_CHAR)
3787 r = set_str_a_characters_bp(a, bp, from, to, id->s, vdc);
3789 r = set_str_d_characters_bp(a, bp, from, to, id->s, vdc);
3790 } else if (id->length > 0) {
3794 isoent = isoent_find_entry(vdd->rootent, ids);
3795 if (isoent == NULL) {
3796 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
3797 "Not Found %s `%s'.",
3799 return (ARCHIVE_FATAL);
3801 len = isoent->ext_off + isoent->ext_len;
3802 if (vdd->vdd_type == VDD_JOLIET) {
3803 if (len > sizeof(identifier)-2)
3804 len = sizeof(identifier)-2;
3806 if (len > sizeof(identifier)-1)
3807 len = sizeof(identifier)-1;
3809 memcpy(identifier, isoent->identifier, len);
3810 identifier[len] = '\0';
3811 if (vdd->vdd_type == VDD_JOLIET) {
3812 identifier[len+1] = 0;
3813 vdc = VDC_UCS2_DIRECT;
3815 if (char_type == A_CHAR)
3816 r = set_str_a_characters_bp(a, bp, from, to,
3819 r = set_str_d_characters_bp(a, bp, from, to,
3822 if (char_type == A_CHAR)
3823 r = set_str_a_characters_bp(a, bp, from, to, NULL, vdc);
3825 r = set_str_d_characters_bp(a, bp, from, to, NULL, vdc);
3831 * Write Primary/Supplementary Volume Descriptor
3834 write_VD(struct archive_write *a, struct vdd *vdd)
3836 struct iso9660 *iso9660;
3838 uint16_t volume_set_size = 1;
3839 char identifier[256];
3842 unsigned char vd_ver, fst_ver;
3845 iso9660 = a->format_data;
3846 switch (vdd->vdd_type) {
3848 vdt = VDT_SUPPLEMENTARY;
3849 vd_ver = fst_ver = 1;
3853 vdt = VDT_SUPPLEMENTARY;
3854 vd_ver = fst_ver = 2;
3855 vdc = VDC_LOWERCASE;
3860 vd_ver = fst_ver = 1;
3861 #ifdef COMPAT_MKISOFS
3862 vdc = VDC_LOWERCASE;
3869 bp = wb_buffptr(a) -1;
3870 /* Volume Descriptor Type */
3871 set_VD_bp(bp, vdt, vd_ver);
3873 set_unused_field_bp(bp, 8, 8);
3874 /* System Identifier */
3875 get_system_identitier(identifier, sizeof(identifier));
3876 r = set_str_a_characters_bp(a, bp, 9, 40, identifier, vdc);
3877 if (r != ARCHIVE_OK)
3879 /* Volume Identifier */
3880 r = set_str_d_characters_bp(a, bp, 41, 72,
3881 iso9660->volume_identifier.s, vdc);
3882 if (r != ARCHIVE_OK)
3885 set_unused_field_bp(bp, 73, 80);
3886 /* Volume Space Size */
3887 set_num_733(bp+81, iso9660->volume_space_size);
3888 if (vdd->vdd_type == VDD_JOLIET) {
3889 /* Escape Sequences */
3890 bp[89] = 0x25;/* UCS-2 Level 3 */
3893 memset(bp + 92, 0, 120 - 92 + 1);
3896 set_unused_field_bp(bp, 89, 120);
3898 /* Volume Set Size */
3899 set_num_723(bp+121, volume_set_size);
3900 /* Volume Sequence Number */
3901 set_num_723(bp+125, iso9660->volume_sequence_number);
3902 /* Logical Block Size */
3903 set_num_723(bp+129, LOGICAL_BLOCK_SIZE);
3904 /* Path Table Size */
3905 set_num_733(bp+133, vdd->path_table_size);
3906 /* Location of Occurrence of Type L Path Table */
3907 set_num_731(bp+141, vdd->location_type_L_path_table);
3908 /* Location of Optional Occurrence of Type L Path Table */
3909 set_num_731(bp+145, 0);
3910 /* Location of Occurrence of Type M Path Table */
3911 set_num_732(bp+149, vdd->location_type_M_path_table);
3912 /* Location of Optional Occurrence of Type M Path Table */
3913 set_num_732(bp+153, 0);
3914 /* Directory Record for Root Directory(BP 157 to 190) */
3915 set_directory_record(bp+157, 190-157+1, vdd->rootent,
3916 iso9660, DIR_REC_VD, vdd->vdd_type);
3917 /* Volume Set Identifier */
3918 r = set_str_d_characters_bp(a, bp, 191, 318, "", vdc);
3919 if (r != ARCHIVE_OK)
3921 /* Publisher Identifier */
3922 r = set_file_identifier(bp, 319, 446, vdc, a, vdd,
3923 &(iso9660->publisher_identifier),
3924 "Publisher File", 1, A_CHAR);
3925 if (r != ARCHIVE_OK)
3927 /* Data Preparer Identifier */
3928 r = set_file_identifier(bp, 447, 574, vdc, a, vdd,
3929 &(iso9660->data_preparer_identifier),
3930 "Data Preparer File", 1, A_CHAR);
3931 if (r != ARCHIVE_OK)
3933 /* Application Identifier */
3934 r = set_file_identifier(bp, 575, 702, vdc, a, vdd,
3935 &(iso9660->application_identifier),
3936 "Application File", 1, A_CHAR);
3937 if (r != ARCHIVE_OK)
3939 /* Copyright File Identifier */
3940 r = set_file_identifier(bp, 703, 739, vdc, a, vdd,
3941 &(iso9660->copyright_file_identifier),
3942 "Copyright File", 0, D_CHAR);
3943 if (r != ARCHIVE_OK)
3945 /* Abstract File Identifier */
3946 r = set_file_identifier(bp, 740, 776, vdc, a, vdd,
3947 &(iso9660->abstract_file_identifier),
3948 "Abstract File", 0, D_CHAR);
3949 if (r != ARCHIVE_OK)
3951 /* Bibliographic File Identifier */
3952 r = set_file_identifier(bp, 777, 813, vdc, a, vdd,
3953 &(iso9660->bibliographic_file_identifier),
3954 "Bibliongraphic File", 0, D_CHAR);
3955 if (r != ARCHIVE_OK)
3957 /* Volume Creation Date and Time */
3958 set_date_time(bp+814, iso9660->birth_time);
3959 /* Volume Modification Date and Time */
3960 set_date_time(bp+831, iso9660->birth_time);
3961 /* Volume Expiration Date and Time(obsolete) */
3962 set_date_time_null(bp+848);
3963 /* Volume Effective Date and Time */
3964 set_date_time(bp+865, iso9660->birth_time);
3965 /* File Structure Version */
3969 /* Application Use */
3970 memset(bp + 884, 0x20, 1395 - 884 + 1);
3972 set_unused_field_bp(bp, 1396, LOGICAL_BLOCK_SIZE);
3974 return (wb_consume(a, LOGICAL_BLOCK_SIZE));
3978 * Write Boot Record Volume Descriptor
3981 write_VD_boot_record(struct archive_write *a)
3983 struct iso9660 *iso9660;
3986 iso9660 = a->format_data;
3987 bp = wb_buffptr(a) -1;
3988 /* Volume Descriptor Type */
3989 set_VD_bp(bp, VDT_BOOT_RECORD, 1);
3990 /* Boot System Identifier */
3991 memcpy(bp+8, "EL TORITO SPECIFICATION", 23);
3992 set_unused_field_bp(bp, 8+23, 39);
3994 set_unused_field_bp(bp, 40, 71);
3995 /* Absolute pointer to first sector of Boot Catalog */
3997 iso9660->el_torito.catalog->file->content.location);
3999 set_unused_field_bp(bp, 76, LOGICAL_BLOCK_SIZE);
4001 return (wb_consume(a, LOGICAL_BLOCK_SIZE));
4011 set_option_info(struct archive_string *info, int *opt, const char *key,
4012 enum keytype type, ...)
4019 prefix = (*opt==0)? ' ':',';
4023 d = va_arg(ap, int);
4024 archive_string_sprintf(info, "%c%s%s",
4025 prefix, (d == 0)?"!":"", key);
4028 s = va_arg(ap, const char *);
4029 archive_string_sprintf(info, "%c%s=%s",
4033 d = va_arg(ap, int);
4034 archive_string_sprintf(info, "%c%s=%d",
4038 d = va_arg(ap, int);
4039 archive_string_sprintf(info, "%c%s=%x",
4049 * Make Non-ISO File System Information
4052 write_information_block(struct archive_write *a)
4054 struct iso9660 *iso9660;
4058 struct archive_string info;
4059 size_t info_size = LOGICAL_BLOCK_SIZE *
4060 NON_ISO_FILE_SYSTEM_INFORMATION_BLOCK;
4062 iso9660 = (struct iso9660 *)a->format_data;
4063 if (info_size > wb_remaining(a)) {
4064 r = wb_write_out(a);
4065 if (r != ARCHIVE_OK)
4068 archive_string_init(&info);
4069 if (archive_string_ensure(&info, info_size) == NULL) {
4070 archive_set_error(&a->archive, ENOMEM,
4071 "Can't allocate memory");
4072 return (ARCHIVE_FATAL);
4074 memset(info.s, 0, info_size);
4076 #if defined(HAVE__CTIME64_S)
4078 __time64_t iso9660_birth_time_tmp = (__time64_t) iso9660->birth_time; //time_t may be shorter than 64 bits
4079 _ctime64_s(buf, sizeof(buf), &(iso9660_birth_time_tmp));
4081 #elif defined(HAVE_CTIME_R)
4082 ctime_r(&(iso9660->birth_time), buf);
4084 strncpy(buf, ctime(&(iso9660->birth_time)), sizeof(buf)-1);
4085 buf[sizeof(buf)-1] = '\0';
4087 archive_string_sprintf(&info,
4088 "INFO %s%s", buf, archive_version_string());
4089 if (iso9660->opt.abstract_file != OPT_ABSTRACT_FILE_DEFAULT)
4090 set_option_info(&info, &opt, "abstract-file",
4091 KEY_STR, iso9660->abstract_file_identifier.s);
4092 if (iso9660->opt.application_id != OPT_APPLICATION_ID_DEFAULT)
4093 set_option_info(&info, &opt, "application-id",
4094 KEY_STR, iso9660->application_identifier.s);
4095 if (iso9660->opt.allow_vernum != OPT_ALLOW_VERNUM_DEFAULT)
4096 set_option_info(&info, &opt, "allow-vernum",
4097 KEY_FLG, iso9660->opt.allow_vernum);
4098 if (iso9660->opt.biblio_file != OPT_BIBLIO_FILE_DEFAULT)
4099 set_option_info(&info, &opt, "biblio-file",
4100 KEY_STR, iso9660->bibliographic_file_identifier.s);
4101 if (iso9660->opt.boot != OPT_BOOT_DEFAULT)
4102 set_option_info(&info, &opt, "boot",
4103 KEY_STR, iso9660->el_torito.boot_filename.s);
4104 if (iso9660->opt.boot_catalog != OPT_BOOT_CATALOG_DEFAULT)
4105 set_option_info(&info, &opt, "boot-catalog",
4106 KEY_STR, iso9660->el_torito.catalog_filename.s);
4107 if (iso9660->opt.boot_info_table != OPT_BOOT_INFO_TABLE_DEFAULT)
4108 set_option_info(&info, &opt, "boot-info-table",
4109 KEY_FLG, iso9660->opt.boot_info_table);
4110 if (iso9660->opt.boot_load_seg != OPT_BOOT_LOAD_SEG_DEFAULT)
4111 set_option_info(&info, &opt, "boot-load-seg",
4112 KEY_HEX, iso9660->el_torito.boot_load_seg);
4113 if (iso9660->opt.boot_load_size != OPT_BOOT_LOAD_SIZE_DEFAULT)
4114 set_option_info(&info, &opt, "boot-load-size",
4115 KEY_INT, iso9660->el_torito.boot_load_size);
4116 if (iso9660->opt.boot_type != OPT_BOOT_TYPE_DEFAULT) {
4118 if (iso9660->opt.boot_type == OPT_BOOT_TYPE_FD)
4120 if (iso9660->opt.boot_type == OPT_BOOT_TYPE_HARD_DISK)
4122 set_option_info(&info, &opt, "boot-type",
4126 if (iso9660->opt.compression_level != OPT_COMPRESSION_LEVEL_DEFAULT)
4127 set_option_info(&info, &opt, "compression-level",
4128 KEY_INT, iso9660->zisofs.compression_level);
4130 if (iso9660->opt.copyright_file != OPT_COPYRIGHT_FILE_DEFAULT)
4131 set_option_info(&info, &opt, "copyright-file",
4132 KEY_STR, iso9660->copyright_file_identifier.s);
4133 if (iso9660->opt.iso_level != OPT_ISO_LEVEL_DEFAULT)
4134 set_option_info(&info, &opt, "iso-level",
4135 KEY_INT, iso9660->opt.iso_level);
4136 if (iso9660->opt.joliet != OPT_JOLIET_DEFAULT) {
4137 if (iso9660->opt.joliet == OPT_JOLIET_LONGNAME)
4138 set_option_info(&info, &opt, "joliet",
4141 set_option_info(&info, &opt, "joliet",
4142 KEY_FLG, iso9660->opt.joliet);
4144 if (iso9660->opt.limit_depth != OPT_LIMIT_DEPTH_DEFAULT)
4145 set_option_info(&info, &opt, "limit-depth",
4146 KEY_FLG, iso9660->opt.limit_depth);
4147 if (iso9660->opt.limit_dirs != OPT_LIMIT_DIRS_DEFAULT)
4148 set_option_info(&info, &opt, "limit-dirs",
4149 KEY_FLG, iso9660->opt.limit_dirs);
4150 if (iso9660->opt.pad != OPT_PAD_DEFAULT)
4151 set_option_info(&info, &opt, "pad",
4152 KEY_FLG, iso9660->opt.pad);
4153 if (iso9660->opt.publisher != OPT_PUBLISHER_DEFAULT)
4154 set_option_info(&info, &opt, "publisher",
4155 KEY_STR, iso9660->publisher_identifier.s);
4156 if (iso9660->opt.rr != OPT_RR_DEFAULT) {
4157 if (iso9660->opt.rr == OPT_RR_DISABLED)
4158 set_option_info(&info, &opt, "rockridge",
4159 KEY_FLG, iso9660->opt.rr);
4160 else if (iso9660->opt.rr == OPT_RR_STRICT)
4161 set_option_info(&info, &opt, "rockridge",
4163 else if (iso9660->opt.rr == OPT_RR_USEFUL)
4164 set_option_info(&info, &opt, "rockridge",
4167 if (iso9660->opt.volume_id != OPT_VOLUME_ID_DEFAULT)
4168 set_option_info(&info, &opt, "volume-id",
4169 KEY_STR, iso9660->volume_identifier.s);
4170 if (iso9660->opt.zisofs != OPT_ZISOFS_DEFAULT)
4171 set_option_info(&info, &opt, "zisofs",
4172 KEY_FLG, iso9660->opt.zisofs);
4174 memcpy(wb_buffptr(a), info.s, info_size);
4175 archive_string_free(&info);
4176 return (wb_consume(a, info_size));
4180 write_rr_ER(struct archive_write *a)
4186 memset(p, 0, LOGICAL_BLOCK_SIZE);
4190 p[2] = RRIP_ER_SIZE;
4191 p[4] = RRIP_ER_ID_SIZE;
4192 p[5] = RRIP_ER_DSC_SIZE;
4193 p[6] = RRIP_ER_SRC_SIZE;
4195 memcpy(&p[8], rrip_identifier, p[4]);
4196 memcpy(&p[8+p[4]], rrip_descriptor, p[5]);
4197 memcpy(&p[8+p[4]+p[5]], rrip_source, p[6]);
4199 return (wb_consume(a, LOGICAL_BLOCK_SIZE));
4203 calculate_path_table_size(struct vdd *vdd)
4206 struct path_table *pt;
4210 for (depth = 0; depth < vdd->max_depth; depth++) {
4211 struct isoent **ptbl;
4214 if ((cnt = pt[depth].cnt) == 0)
4217 ptbl = pt[depth].sorted;
4218 for (i = 0; i < cnt; i++) {
4221 if (ptbl[i]->identifier == NULL)
4222 len = 1; /* root directory */
4224 len = ptbl[i]->id_len;
4226 len++; /* Padding Field */
4230 vdd->path_table_size = size;
4231 vdd->path_table_block =
4232 ((size + PATH_TABLE_BLOCK_SIZE -1) /
4233 PATH_TABLE_BLOCK_SIZE) *
4234 (PATH_TABLE_BLOCK_SIZE / LOGICAL_BLOCK_SIZE);
4238 _write_path_table(struct archive_write *a, int type_m, int depth,
4241 unsigned char *bp, *wb;
4242 struct isoent **ptbl;
4246 if (vdd->pathtbl[depth].cnt == 0)
4251 wbremaining = wb_remaining(a);
4253 ptbl = vdd->pathtbl[depth].sorted;
4254 for (i = 0; i < vdd->pathtbl[depth].cnt; i++) {
4259 if (np->identifier == NULL)
4260 len = 1; /* root directory */
4263 if (wbremaining - ((bp+1) - wb) < (len + 1 + 8)) {
4264 r = wb_consume(a, (bp+1) - wb);
4268 wbremaining = wb_remaining(a);
4271 /* Length of Directory Identifier */
4272 set_num_711(bp+1, (unsigned char)len);
4273 /* Extended Attribute Record Length */
4274 set_num_711(bp+2, 0);
4275 /* Location of Extent */
4277 set_num_732(bp+3, np->dir_location);
4279 set_num_731(bp+3, np->dir_location);
4280 /* Parent Directory Number */
4282 set_num_722(bp+7, np->parent->dir_number);
4284 set_num_721(bp+7, np->parent->dir_number);
4285 /* Directory Identifier */
4286 if (np->identifier == NULL)
4289 memcpy(&bp[9], np->identifier, len);
4295 wsize += 8 + (int)len;
4298 if ((bp + 1) > wb) {
4299 r = wb_consume(a, (bp+1)-wb);
4307 write_path_table(struct archive_write *a, int type_m, struct vdd *vdd)
4310 size_t path_table_size;
4313 path_table_size = 0;
4314 for (depth = 0; depth < vdd->max_depth; depth++) {
4315 r = _write_path_table(a, type_m, depth, vdd);
4318 path_table_size += r;
4321 /* Write padding data. */
4322 path_table_size = path_table_size % PATH_TABLE_BLOCK_SIZE;
4323 if (path_table_size > 0)
4324 r = write_null(a, PATH_TABLE_BLOCK_SIZE - path_table_size);
4329 calculate_directory_descriptors(struct iso9660 *iso9660, struct vdd *vdd,
4330 struct isoent *isoent, int depth)
4332 struct isoent **enttbl;
4336 bs = get_dir_rec_size(iso9660, isoent, DIR_REC_SELF, vdd->vdd_type);
4337 bs += get_dir_rec_size(iso9660, isoent, DIR_REC_PARENT, vdd->vdd_type);
4339 if (isoent->children.cnt <= 0 || (vdd->vdd_type != VDD_JOLIET &&
4340 !iso9660->opt.rr && depth + 1 >= vdd->max_depth))
4343 enttbl = isoent->children_sorted;
4344 for (i = 0; i < isoent->children.cnt; i++) {
4345 struct isoent *np = enttbl[i];
4346 struct isofile *file;
4349 if (file->hardlink_target != NULL)
4350 file = file->hardlink_target;
4351 file->cur_content = &(file->content);
4355 dr_l = get_dir_rec_size(iso9660, np, DIR_REC_NORMAL,
4357 if ((bs + dr_l) > LOGICAL_BLOCK_SIZE) {
4362 file->cur_content = file->cur_content->next;
4363 } while (file->cur_content != NULL);
4369 _write_directory_descriptors(struct archive_write *a, struct vdd *vdd,
4370 struct isoent *isoent, int depth)
4372 struct iso9660 *iso9660 = a->format_data;
4373 struct isoent **enttbl;
4374 unsigned char *p, *wb;
4378 p = wb = wb_buffptr(a);
4379 #define WD_REMAINING (LOGICAL_BLOCK_SIZE - (p - wb))
4380 p += set_directory_record(p, WD_REMAINING, isoent,
4381 iso9660, DIR_REC_SELF, vdd->vdd_type);
4382 p += set_directory_record(p, WD_REMAINING, isoent,
4383 iso9660, DIR_REC_PARENT, vdd->vdd_type);
4385 if (isoent->children.cnt <= 0 || (vdd->vdd_type != VDD_JOLIET &&
4386 !iso9660->opt.rr && depth + 1 >= vdd->max_depth)) {
4387 memset(p, 0, WD_REMAINING);
4388 return (wb_consume(a, LOGICAL_BLOCK_SIZE));
4391 enttbl = isoent->children_sorted;
4392 for (i = 0; i < isoent->children.cnt; i++) {
4393 struct isoent *np = enttbl[i];
4394 struct isofile *file = np->file;
4396 if (file->hardlink_target != NULL)
4397 file = file->hardlink_target;
4398 file->cur_content = &(file->content);
4400 dr_l = set_directory_record(p, WD_REMAINING,
4401 np, iso9660, DIR_REC_NORMAL,
4404 memset(p, 0, WD_REMAINING);
4405 r = wb_consume(a, LOGICAL_BLOCK_SIZE);
4408 p = wb = wb_buffptr(a);
4409 dr_l = set_directory_record(p,
4410 WD_REMAINING, np, iso9660,
4411 DIR_REC_NORMAL, vdd->vdd_type);
4414 file->cur_content = file->cur_content->next;
4415 } while (file->cur_content != NULL);
4417 memset(p, 0, WD_REMAINING);
4418 return (wb_consume(a, LOGICAL_BLOCK_SIZE));
4422 write_directory_descriptors(struct archive_write *a, struct vdd *vdd)
4430 struct extr_rec *extr;
4432 r = _write_directory_descriptors(a, vdd, np, depth);
4435 if (vdd->vdd_type != VDD_JOLIET) {
4437 * This extract record is used by SUSP,RRIP.
4440 for (extr = np->extr_rec_list.first;
4442 extr = extr->next) {
4446 memcpy(wb, extr->buf, extr->offset);
4447 memset(wb + extr->offset, 0,
4448 LOGICAL_BLOCK_SIZE - extr->offset);
4449 r = wb_consume(a, LOGICAL_BLOCK_SIZE);
4455 if (np->subdirs.first != NULL && depth + 1 < vdd->max_depth) {
4456 /* Enter to sub directories. */
4457 np = np->subdirs.first;
4461 while (np != np->parent) {
4462 if (np->drnext == NULL) {
4463 /* Return to the parent directory. */
4471 } while (np != np->parent);
4473 return (ARCHIVE_OK);
4477 * Read file contents from the temporary file, and write it.
4480 write_file_contents(struct archive_write *a, int64_t offset, int64_t size)
4482 struct iso9660 *iso9660 = a->format_data;
4485 lseek(iso9660->temp_fd, offset, SEEK_SET);
4493 rsize = wb_remaining(a);
4494 if (rsize > (size_t)size)
4495 rsize = (size_t)size;
4496 rs = read(iso9660->temp_fd, wb, rsize);
4498 archive_set_error(&a->archive, errno,
4499 "Can't read temporary file(%jd)", (intmax_t)rs);
4500 return (ARCHIVE_FATAL);
4503 r = wb_consume(a, rs);
4507 return (ARCHIVE_OK);
4511 write_file_descriptors(struct archive_write *a)
4513 struct iso9660 *iso9660 = a->format_data;
4514 struct isofile *file;
4515 int64_t blocks, offset;
4521 /* Make the boot catalog contents, and write it. */
4522 if (iso9660->el_torito.catalog != NULL) {
4523 r = make_boot_catalog(a);
4528 /* Write the boot file contents. */
4529 if (iso9660->el_torito.boot != NULL) {
4530 file = iso9660->el_torito.boot->file;
4531 blocks = file->content.blocks;
4532 offset = file->content.offset_of_temp;
4534 r = write_file_contents(a, offset,
4535 blocks << LOGICAL_BLOCK_BITS);
4543 /* Write out all file contents. */
4544 for (file = iso9660->data_file_list.first;
4545 file != NULL; file = file->datanext) {
4547 if (!file->write_content)
4550 if ((offset + (blocks << LOGICAL_BLOCK_BITS)) <
4551 file->content.offset_of_temp) {
4553 r = write_file_contents(a, offset,
4554 blocks << LOGICAL_BLOCK_BITS);
4559 offset = file->content.offset_of_temp;
4562 file->cur_content = &(file->content);
4564 blocks += file->cur_content->blocks;
4566 file->cur_content = file->cur_content->next;
4567 } while (file->cur_content != NULL);
4570 /* Flush out remaining blocks. */
4572 r = write_file_contents(a, offset,
4573 blocks << LOGICAL_BLOCK_BITS);
4578 return (ARCHIVE_OK);
4582 isofile_init_entry_list(struct iso9660 *iso9660)
4584 iso9660->all_file_list.first = NULL;
4585 iso9660->all_file_list.last = &(iso9660->all_file_list.first);
4589 isofile_add_entry(struct iso9660 *iso9660, struct isofile *file)
4591 file->allnext = NULL;
4592 *iso9660->all_file_list.last = file;
4593 iso9660->all_file_list.last = &(file->allnext);
4597 isofile_free_all_entries(struct iso9660 *iso9660)
4599 struct isofile *file, *file_next;
4601 file = iso9660->all_file_list.first;
4602 while (file != NULL) {
4603 file_next = file->allnext;
4610 isofile_init_entry_data_file_list(struct iso9660 *iso9660)
4612 iso9660->data_file_list.first = NULL;
4613 iso9660->data_file_list.last = &(iso9660->data_file_list.first);
4617 isofile_add_data_file(struct iso9660 *iso9660, struct isofile *file)
4619 file->datanext = NULL;
4620 *iso9660->data_file_list.last = file;
4621 iso9660->data_file_list.last = &(file->datanext);
4625 static struct isofile *
4626 isofile_new(struct archive_write *a, struct archive_entry *entry)
4628 struct isofile *file;
4630 file = calloc(1, sizeof(*file));
4635 file->entry = archive_entry_clone(entry);
4637 file->entry = archive_entry_new2(&a->archive);
4638 if (file->entry == NULL) {
4642 archive_string_init(&(file->parentdir));
4643 archive_string_init(&(file->basename));
4644 archive_string_init(&(file->basename_utf16));
4645 archive_string_init(&(file->symlink));
4646 file->cur_content = &(file->content);
4652 isofile_free(struct isofile *file)
4654 struct content *con, *tmp;
4656 con = file->content.next;
4657 while (con != NULL) {
4662 archive_entry_free(file->entry);
4663 archive_string_free(&(file->parentdir));
4664 archive_string_free(&(file->basename));
4665 archive_string_free(&(file->basename_utf16));
4666 archive_string_free(&(file->symlink));
4670 #if defined(_WIN32) || defined(__CYGWIN__)
4672 cleanup_backslash_1(char *p)
4678 if (*(unsigned char *)p > 127)
4681 /* If we have not met any multi-byte characters,
4682 * we can replace '\' with '/'. */
4695 cleanup_backslash_2(wchar_t *p)
4698 /* Convert a path-separator from '\' to '/' */
4699 while (*p != L'\0') {
4708 * Generate a parent directory name and a base name from a pathname.
4711 isofile_gen_utility_names(struct archive_write *a, struct isofile *file)
4713 struct iso9660 *iso9660;
4714 const char *pathname;
4715 char *p, *dirname, *slash;
4717 int ret = ARCHIVE_OK;
4719 iso9660 = a->format_data;
4721 archive_string_empty(&(file->parentdir));
4722 archive_string_empty(&(file->basename));
4723 archive_string_empty(&(file->basename_utf16));
4724 archive_string_empty(&(file->symlink));
4726 pathname = archive_entry_pathname(file->entry);
4727 if (pathname == NULL || pathname[0] == '\0') {/* virtual root */
4733 * Make a UTF-16BE basename if Joliet extension enabled.
4735 if (iso9660->opt.joliet) {
4736 const char *u16, *ulast;
4737 size_t u16len, ulen_last;
4739 if (iso9660->sconv_to_utf16be == NULL) {
4740 iso9660->sconv_to_utf16be =
4741 archive_string_conversion_to_charset(
4742 &(a->archive), "UTF-16BE", 1);
4743 if (iso9660->sconv_to_utf16be == NULL)
4744 /* Couldn't allocate memory */
4745 return (ARCHIVE_FATAL);
4746 iso9660->sconv_from_utf16be =
4747 archive_string_conversion_from_charset(
4748 &(a->archive), "UTF-16BE", 1);
4749 if (iso9660->sconv_from_utf16be == NULL)
4750 /* Couldn't allocate memory */
4751 return (ARCHIVE_FATAL);
4755 * Convert a filename to UTF-16BE.
4757 if (0 > archive_entry_pathname_l(file->entry, &u16, &u16len,
4758 iso9660->sconv_to_utf16be)) {
4759 if (errno == ENOMEM) {
4760 archive_set_error(&a->archive, ENOMEM,
4761 "Can't allocate memory for UTF-16BE");
4762 return (ARCHIVE_FATAL);
4764 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
4765 "A filename cannot be converted to UTF-16BE;"
4766 "You should disable making Joliet extension");
4771 * Make sure a path separator is not in the last;
4772 * Remove trailing '/'.
4774 while (u16len >= 2) {
4775 #if defined(_WIN32) || defined(__CYGWIN__)
4776 if (u16[u16len-2] == 0 &&
4777 (u16[u16len-1] == '/' || u16[u16len-1] == '\\'))
4779 if (u16[u16len-2] == 0 && u16[u16len-1] == '/')
4788 * Find a basename in UTF-16BE.
4793 while (u16len > 0) {
4794 #if defined(_WIN32) || defined(__CYGWIN__)
4795 if (u16[0] == 0 && (u16[1] == '/' || u16[1] == '\\'))
4797 if (u16[0] == 0 && u16[1] == '/')
4801 ulen_last = u16len -1;
4807 if (archive_string_ensure(&(file->basename_utf16),
4808 ulen_last) == NULL) {
4809 archive_set_error(&a->archive, ENOMEM,
4810 "Can't allocate memory for UTF-16BE");
4811 return (ARCHIVE_FATAL);
4815 * Set UTF-16BE basename.
4817 memcpy(file->basename_utf16.s, ulast, ulen_last);
4818 file->basename_utf16.length = ulen_last;
4821 archive_strcpy(&(file->parentdir), pathname);
4822 #if defined(_WIN32) || defined(__CYGWIN__)
4824 * Convert a path-separator from '\' to '/'
4826 if (cleanup_backslash_1(file->parentdir.s) != 0) {
4827 const wchar_t *wp = archive_entry_pathname_w(file->entry);
4828 struct archive_wstring ws;
4832 archive_string_init(&ws);
4833 archive_wstrcpy(&ws, wp);
4834 cleanup_backslash_2(ws.s);
4835 archive_string_empty(&(file->parentdir));
4836 r = archive_string_append_from_wcs(&(file->parentdir),
4838 archive_wstring_free(&ws);
4839 if (r < 0 && errno == ENOMEM) {
4840 archive_set_error(&a->archive, ENOMEM,
4841 "Can't allocate memory");
4842 return (ARCHIVE_FATAL);
4848 len = file->parentdir.length;
4849 p = dirname = file->parentdir.s;
4852 * Remove leading '/', '../' and './' elements
4858 } else if (p[0] != '.')
4860 else if (p[1] == '.' && p[2] == '/') {
4863 } else if (p[1] == '/' || (p[1] == '.' && p[2] == '\0')) {
4866 } else if (p[1] == '\0') {
4873 memmove(dirname, p, len+1);
4877 * Remove "/","/." and "/.." elements from tail.
4882 if (len > 0 && p[len-1] == '/') {
4886 if (len > 1 && p[len-2] == '/' && p[len-1] == '.') {
4890 if (len > 2 && p[len-3] == '/' && p[len-2] == '.' &&
4901 /* Convert '//' --> '/' */
4903 else if (p[1] == '.' && p[2] == '/')
4904 /* Convert '/./' --> '/' */
4906 else if (p[1] == '.' && p[2] == '.' && p[3] == '/') {
4907 /* Convert 'dir/dir1/../dir2/'
4911 while (rp >= dirname) {
4920 strcpy(dirname, p+4);
4931 if (archive_entry_filetype(file->entry) == AE_IFLNK) {
4932 /* Convert symlink name too. */
4933 pathname = archive_entry_symlink(file->entry);
4934 archive_strcpy(&(file->symlink), pathname);
4935 #if defined(_WIN32) || defined(__CYGWIN__)
4937 * Convert a path-separator from '\' to '/'
4939 if (archive_strlen(&(file->symlink)) > 0 &&
4940 cleanup_backslash_1(file->symlink.s) != 0) {
4942 archive_entry_symlink_w(file->entry);
4943 struct archive_wstring ws;
4947 archive_string_init(&ws);
4948 archive_wstrcpy(&ws, wp);
4949 cleanup_backslash_2(ws.s);
4950 archive_string_empty(&(file->symlink));
4951 r = archive_string_append_from_wcs(
4954 archive_wstring_free(&ws);
4955 if (r < 0 && errno == ENOMEM) {
4956 archive_set_error(&a->archive, ENOMEM,
4957 "Can't allocate memory");
4958 return (ARCHIVE_FATAL);
4965 * - Count up directory elements.
4966 * - Find out the position which points the last position of
4967 * path separator('/').
4971 for (; *p != '\0'; p++)
4976 if (slash == NULL) {
4977 /* The pathname doesn't have a parent directory. */
4978 file->parentdir.length = len;
4979 archive_string_copy(&(file->basename), &(file->parentdir));
4980 archive_string_empty(&(file->parentdir));
4981 *file->parentdir.s = '\0';
4985 /* Make a basename from dirname and slash */
4987 file->parentdir.length = slash - dirname;
4988 archive_strcpy(&(file->basename), slash + 1);
4989 if (archive_entry_filetype(file->entry) == AE_IFDIR)
4995 * Register a entry to get a hardlink target.
4998 isofile_register_hardlink(struct archive_write *a, struct isofile *file)
5000 struct iso9660 *iso9660 = a->format_data;
5001 struct hardlink *hl;
5002 const char *pathname;
5004 archive_entry_set_nlink(file->entry, 1);
5005 pathname = archive_entry_hardlink(file->entry);
5006 if (pathname == NULL) {
5007 /* This `file` is a hardlink target. */
5008 hl = malloc(sizeof(*hl));
5010 archive_set_error(&a->archive, ENOMEM,
5011 "Can't allocate memory");
5012 return (ARCHIVE_FATAL);
5015 /* A hardlink target must be the first position. */
5016 file->hlnext = NULL;
5017 hl->file_list.first = file;
5018 hl->file_list.last = &(file->hlnext);
5019 __archive_rb_tree_insert_node(&(iso9660->hardlink_rbtree),
5020 (struct archive_rb_node *)hl);
5022 hl = (struct hardlink *)__archive_rb_tree_find_node(
5023 &(iso9660->hardlink_rbtree), pathname);
5025 /* Insert `file` entry into the tail. */
5026 file->hlnext = NULL;
5027 *hl->file_list.last = file;
5028 hl->file_list.last = &(file->hlnext);
5031 archive_entry_unset_size(file->entry);
5034 return (ARCHIVE_OK);
5038 * Hardlinked files have to have the same location of extent.
5039 * We have to find out hardlink target entries for the entries
5040 * which have a hardlink target name.
5043 isofile_connect_hardlink_files(struct iso9660 *iso9660)
5045 struct archive_rb_node *n;
5046 struct hardlink *hl;
5047 struct isofile *target, *nf;
5049 ARCHIVE_RB_TREE_FOREACH(n, &(iso9660->hardlink_rbtree)) {
5050 hl = (struct hardlink *)n;
5052 /* The first entry must be a hardlink target. */
5053 target = hl->file_list.first;
5054 archive_entry_set_nlink(target->entry, hl->nlink);
5055 /* Set a hardlink target to reference entries. */
5056 for (nf = target->hlnext;
5057 nf != NULL; nf = nf->hlnext) {
5058 nf->hardlink_target = target;
5059 archive_entry_set_nlink(nf->entry, hl->nlink);
5065 isofile_hd_cmp_node(const struct archive_rb_node *n1,
5066 const struct archive_rb_node *n2)
5068 const struct hardlink *h1 = (const struct hardlink *)n1;
5069 const struct hardlink *h2 = (const struct hardlink *)n2;
5071 return (strcmp(archive_entry_pathname(h1->file_list.first->entry),
5072 archive_entry_pathname(h2->file_list.first->entry)));
5076 isofile_hd_cmp_key(const struct archive_rb_node *n, const void *key)
5078 const struct hardlink *h = (const struct hardlink *)n;
5080 return (strcmp(archive_entry_pathname(h->file_list.first->entry),
5081 (const char *)key));
5085 isofile_init_hardlinks(struct iso9660 *iso9660)
5087 static const struct archive_rb_tree_ops rb_ops = {
5088 isofile_hd_cmp_node, isofile_hd_cmp_key,
5091 __archive_rb_tree_init(&(iso9660->hardlink_rbtree), &rb_ops);
5095 isofile_free_hardlinks(struct iso9660 *iso9660)
5097 struct archive_rb_node *n, *next;
5099 for (n = ARCHIVE_RB_TREE_MIN(&(iso9660->hardlink_rbtree)); n;) {
5100 next = __archive_rb_tree_iterate(&(iso9660->hardlink_rbtree),
5101 n, ARCHIVE_RB_DIR_RIGHT);
5107 static struct isoent *
5108 isoent_new(struct isofile *file)
5110 struct isoent *isoent;
5111 static const struct archive_rb_tree_ops rb_ops = {
5112 isoent_cmp_node, isoent_cmp_key,
5115 isoent = calloc(1, sizeof(*isoent));
5118 isoent->file = file;
5119 isoent->children.first = NULL;
5120 isoent->children.last = &(isoent->children.first);
5121 __archive_rb_tree_init(&(isoent->rbtree), &rb_ops);
5122 isoent->subdirs.first = NULL;
5123 isoent->subdirs.last = &(isoent->subdirs.first);
5124 isoent->extr_rec_list.first = NULL;
5125 isoent->extr_rec_list.last = &(isoent->extr_rec_list.first);
5126 isoent->extr_rec_list.current = NULL;
5127 if (archive_entry_filetype(file->entry) == AE_IFDIR)
5133 static inline struct isoent *
5134 isoent_clone(struct isoent *src)
5136 return (isoent_new(src->file));
5140 _isoent_free(struct isoent *isoent)
5142 struct extr_rec *er, *er_next;
5144 free(isoent->children_sorted);
5145 free(isoent->identifier);
5146 er = isoent->extr_rec_list.first;
5147 while (er != NULL) {
5156 isoent_free_all(struct isoent *isoent)
5158 struct isoent *np, *np_temp;
5165 if (np->children.first != NULL) {
5166 /* Enter to sub directories. */
5167 np = np->children.first;
5173 if (np->chnext == NULL) {
5174 /* Return to the parent directory. */
5176 _isoent_free(np_temp);
5181 _isoent_free(np_temp);
5188 static struct isoent *
5189 isoent_create_virtual_dir(struct archive_write *a, struct iso9660 *iso9660, const char *pathname)
5191 struct isofile *file;
5192 struct isoent *isoent;
5194 file = isofile_new(a, NULL);
5197 archive_entry_set_pathname(file->entry, pathname);
5198 archive_entry_unset_mtime(file->entry);
5199 archive_entry_unset_atime(file->entry);
5200 archive_entry_unset_ctime(file->entry);
5201 archive_entry_set_uid(file->entry, getuid());
5202 archive_entry_set_gid(file->entry, getgid());
5203 archive_entry_set_mode(file->entry, 0555 | AE_IFDIR);
5204 archive_entry_set_nlink(file->entry, 2);
5205 if (isofile_gen_utility_names(a, file) < ARCHIVE_WARN) {
5209 isofile_add_entry(iso9660, file);
5211 isoent = isoent_new(file);
5215 isoent->virtual = 1;
5221 isoent_cmp_node(const struct archive_rb_node *n1,
5222 const struct archive_rb_node *n2)
5224 const struct isoent *e1 = (const struct isoent *)n1;
5225 const struct isoent *e2 = (const struct isoent *)n2;
5227 return (strcmp(e1->file->basename.s, e2->file->basename.s));
5231 isoent_cmp_key(const struct archive_rb_node *n, const void *key)
5233 const struct isoent *e = (const struct isoent *)n;
5235 return (strcmp(e->file->basename.s, (const char *)key));
5239 isoent_add_child_head(struct isoent *parent, struct isoent *child)
5242 if (!__archive_rb_tree_insert_node(
5243 &(parent->rbtree), (struct archive_rb_node *)child))
5245 if ((child->chnext = parent->children.first) == NULL)
5246 parent->children.last = &(child->chnext);
5247 parent->children.first = child;
5248 parent->children.cnt++;
5249 child->parent = parent;
5251 /* Add a child to a sub-directory chain */
5253 if ((child->drnext = parent->subdirs.first) == NULL)
5254 parent->subdirs.last = &(child->drnext);
5255 parent->subdirs.first = child;
5256 parent->subdirs.cnt++;
5257 child->parent = parent;
5259 child->drnext = NULL;
5264 isoent_add_child_tail(struct isoent *parent, struct isoent *child)
5267 if (!__archive_rb_tree_insert_node(
5268 &(parent->rbtree), (struct archive_rb_node *)child))
5270 child->chnext = NULL;
5271 *parent->children.last = child;
5272 parent->children.last = &(child->chnext);
5273 parent->children.cnt++;
5274 child->parent = parent;
5276 /* Add a child to a sub-directory chain */
5277 child->drnext = NULL;
5279 *parent->subdirs.last = child;
5280 parent->subdirs.last = &(child->drnext);
5281 parent->subdirs.cnt++;
5282 child->parent = parent;
5288 isoent_remove_child(struct isoent *parent, struct isoent *child)
5292 /* Remove a child entry from children chain. */
5293 ent = parent->children.first;
5294 while (ent->chnext != child)
5296 if ((ent->chnext = ent->chnext->chnext) == NULL)
5297 parent->children.last = &(ent->chnext);
5298 parent->children.cnt--;
5301 /* Remove a child entry from sub-directory chain. */
5302 ent = parent->subdirs.first;
5303 while (ent->drnext != child)
5305 if ((ent->drnext = ent->drnext->drnext) == NULL)
5306 parent->subdirs.last = &(ent->drnext);
5307 parent->subdirs.cnt--;
5310 __archive_rb_tree_remove_node(&(parent->rbtree),
5311 (struct archive_rb_node *)child);
5315 isoent_clone_tree(struct archive_write *a, struct isoent **nroot,
5316 struct isoent *root)
5318 struct isoent *np, *xroot, *newent;
5323 newent = isoent_clone(np);
5324 if (newent == NULL) {
5325 archive_set_error(&a->archive, ENOMEM,
5326 "Can't allocate memory");
5327 return (ARCHIVE_FATAL);
5329 if (xroot == NULL) {
5330 *nroot = xroot = newent;
5331 newent->parent = xroot;
5333 isoent_add_child_tail(xroot, newent);
5334 if (np->dir && np->children.first != NULL) {
5335 /* Enter to sub directories. */
5336 np = np->children.first;
5340 while (np != np->parent) {
5341 if (np->chnext == NULL) {
5342 /* Return to the parent directory. */
5344 xroot = xroot->parent;
5350 } while (np != np->parent);
5352 return (ARCHIVE_OK);
5356 * Setup directory locations.
5359 isoent_setup_directory_location(struct iso9660 *iso9660, int location,
5365 vdd->total_dir_block = 0;
5371 np->dir_block = calculate_directory_descriptors(
5372 iso9660, vdd, np, depth);
5373 vdd->total_dir_block += np->dir_block;
5374 np->dir_location = location;
5375 location += np->dir_block;
5376 block = extra_setup_location(np, location);
5377 vdd->total_dir_block += block;
5380 if (np->subdirs.first != NULL && depth + 1 < vdd->max_depth) {
5381 /* Enter to sub directories. */
5382 np = np->subdirs.first;
5386 while (np != np->parent) {
5387 if (np->drnext == NULL) {
5388 /* Return to the parent directory. */
5396 } while (np != np->parent);
5400 _isoent_file_location(struct iso9660 *iso9660, struct isoent *isoent,
5403 struct isoent **children;
5406 if (isoent->children.cnt == 0)
5409 children = isoent->children_sorted;
5410 for (n = 0; n < isoent->children.cnt; n++) {
5412 struct isofile *file;
5417 if (np == iso9660->el_torito.boot)
5420 if (file->boot || file->hardlink_target != NULL)
5422 if (archive_entry_filetype(file->entry) == AE_IFLNK ||
5423 file->content.size == 0) {
5425 * Do not point a valid location.
5426 * Make sure entry is not hardlink file.
5428 file->content.location = (*symlocation)--;
5432 file->write_content = 1;
5437 * Setup file locations.
5440 isoent_setup_file_location(struct iso9660 *iso9660, int location)
5442 struct isoent *isoent;
5444 struct isofile *file;
5452 iso9660->total_file_block = 0;
5453 if ((isoent = iso9660->el_torito.catalog) != NULL) {
5454 isoent->file->content.location = location;
5455 block = (int)((archive_entry_size(isoent->file->entry) +
5456 LOGICAL_BLOCK_SIZE -1) >> LOGICAL_BLOCK_BITS);
5458 iso9660->total_file_block += block;
5460 if ((isoent = iso9660->el_torito.boot) != NULL) {
5461 isoent->file->content.location = location;
5462 size = fd_boot_image_size(iso9660->el_torito.media_type);
5464 size = (size_t)archive_entry_size(isoent->file->entry);
5465 block = ((int)size + LOGICAL_BLOCK_SIZE -1)
5466 >> LOGICAL_BLOCK_BITS;
5468 iso9660->total_file_block += block;
5469 isoent->file->content.blocks = block;
5474 if (!iso9660->opt.rr && iso9660->opt.joliet) {
5476 np = iso9660->joliet.rootent;
5479 np = iso9660->primary.rootent;
5482 _isoent_file_location(iso9660, np, &symlocation);
5484 if (np->subdirs.first != NULL &&
5486 ((iso9660->opt.rr == OPT_RR_DISABLED &&
5487 depth + 2 < iso9660->primary.max_depth) ||
5489 depth + 1 < iso9660->primary.max_depth)))) {
5490 /* Enter to sub directories. */
5491 np = np->subdirs.first;
5495 while (np != np->parent) {
5496 if (np->drnext == NULL) {
5497 /* Return to the parent directory. */
5505 } while (np != np->parent);
5508 for (file = iso9660->data_file_list.first;
5509 file != NULL; file = file->datanext) {
5511 if (!file->write_content)
5514 file->cur_content = &(file->content);
5516 file->cur_content->location = location;
5517 location += file->cur_content->blocks;
5518 total_block += file->cur_content->blocks;
5520 file->cur_content = file->cur_content->next;
5521 } while (file->cur_content != NULL);
5523 iso9660->total_file_block += total_block;
5527 get_path_component(char *name, size_t n, const char *fn)
5532 p = strchr(fn, '/');
5534 if ((l = strlen(fn)) == 0)
5540 memcpy(name, fn, l);
5547 * Add a new entry into the tree.
5550 isoent_tree(struct archive_write *a, struct isoent **isoentpp)
5552 #if defined(_WIN32) && !defined(__CYGWIN__)
5553 char name[_MAX_FNAME];/* Included null terminator size. */
5554 #elif defined(NAME_MAX) && NAME_MAX >= 255
5555 char name[NAME_MAX+1];
5559 struct iso9660 *iso9660 = a->format_data;
5560 struct isoent *dent, *isoent, *np;
5561 struct isofile *f1, *f2;
5566 dent = iso9660->primary.rootent;
5567 if (isoent->file->parentdir.length > 0)
5568 fn = p = isoent->file->parentdir.s;
5573 * If the path of the parent directory of `isoent' entry is
5574 * the same as the path of `cur_dirent', add isoent to
5577 if (archive_strlen(&(iso9660->cur_dirstr))
5578 == archive_strlen(&(isoent->file->parentdir)) &&
5579 strcmp(iso9660->cur_dirstr.s, fn) == 0) {
5580 if (!isoent_add_child_tail(iso9660->cur_dirent, isoent)) {
5581 np = (struct isoent *)__archive_rb_tree_find_node(
5582 &(iso9660->cur_dirent->rbtree),
5583 isoent->file->basename.s);
5586 return (ARCHIVE_OK);
5590 l = get_path_component(name, sizeof(name), fn);
5596 archive_set_error(&a->archive,
5598 "A name buffer is too small");
5599 _isoent_free(isoent);
5600 return (ARCHIVE_FATAL);
5603 np = isoent_find_child(dent, name);
5604 if (np == NULL || fn[0] == '\0')
5607 /* Find next subdirectory. */
5609 /* NOT Directory! */
5610 archive_set_error(&a->archive,
5612 "`%s' is not directory, we cannot insert `%s' ",
5613 archive_entry_pathname(np->file->entry),
5614 archive_entry_pathname(isoent->file->entry));
5615 _isoent_free(isoent);
5617 return (ARCHIVE_FAILED);
5626 * Create virtual parent directories.
5628 while (fn[0] != '\0') {
5630 struct archive_string as;
5632 archive_string_init(&as);
5633 archive_strncat(&as, p, fn - p + l);
5634 if (as.s[as.length-1] == '/') {
5635 as.s[as.length-1] = '\0';
5638 vp = isoent_create_virtual_dir(a, iso9660, as.s);
5640 archive_string_free(&as);
5641 archive_set_error(&a->archive, ENOMEM,
5642 "Can't allocate memory");
5643 _isoent_free(isoent);
5645 return (ARCHIVE_FATAL);
5647 archive_string_free(&as);
5649 if (vp->file->dircnt > iso9660->dircnt_max)
5650 iso9660->dircnt_max = vp->file->dircnt;
5651 isoent_add_child_tail(dent, vp);
5657 l = get_path_component(name, sizeof(name), fn);
5659 archive_string_free(&as);
5660 archive_set_error(&a->archive,
5662 "A name buffer is too small");
5663 _isoent_free(isoent);
5665 return (ARCHIVE_FATAL);
5670 /* Found out the parent directory where isoent can be
5672 iso9660->cur_dirent = dent;
5673 archive_string_empty(&(iso9660->cur_dirstr));
5674 archive_string_ensure(&(iso9660->cur_dirstr),
5675 archive_strlen(&(dent->file->parentdir)) +
5676 archive_strlen(&(dent->file->basename)) + 2);
5677 if (archive_strlen(&(dent->file->parentdir)) +
5678 archive_strlen(&(dent->file->basename)) == 0)
5679 iso9660->cur_dirstr.s[0] = 0;
5681 if (archive_strlen(&(dent->file->parentdir)) > 0) {
5682 archive_string_copy(&(iso9660->cur_dirstr),
5683 &(dent->file->parentdir));
5684 archive_strappend_char(&(iso9660->cur_dirstr), '/');
5686 archive_string_concat(&(iso9660->cur_dirstr),
5687 &(dent->file->basename));
5690 if (!isoent_add_child_tail(dent, isoent)) {
5691 np = (struct isoent *)__archive_rb_tree_find_node(
5692 &(dent->rbtree), isoent->file->basename.s);
5695 return (ARCHIVE_OK);
5700 * We have already has the entry the filename of which is
5706 /* If the file type of entries is different,
5707 * we cannot handle it. */
5708 if (archive_entry_filetype(f1->entry) !=
5709 archive_entry_filetype(f2->entry)) {
5710 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
5711 "Found duplicate entries `%s' and its file type is "
5713 archive_entry_pathname(f1->entry));
5714 _isoent_free(isoent);
5716 return (ARCHIVE_FAILED);
5719 /* Swap file entries. */
5724 _isoent_free(isoent);
5726 return (ARCHIVE_OK);
5730 * Find a entry from `isoent'
5732 static struct isoent *
5733 isoent_find_child(struct isoent *isoent, const char *child_name)
5737 np = (struct isoent *)__archive_rb_tree_find_node(
5738 &(isoent->rbtree), child_name);
5743 * Find a entry full-path of which is specified by `fn' parameter,
5746 static struct isoent *
5747 isoent_find_entry(struct isoent *rootent, const char *fn)
5749 #if defined(_WIN32) && !defined(__CYGWIN__)
5750 char name[_MAX_FNAME];/* Included null terminator size. */
5751 #elif defined(NAME_MAX) && NAME_MAX >= 255
5752 char name[NAME_MAX+1];
5756 struct isoent *isoent, *np;
5762 l = get_path_component(name, sizeof(name), fn);
5769 np = isoent_find_child(isoent, name);
5773 break;/* We found out the entry */
5775 /* Try sub directory. */
5779 break;/* Not directory */
5786 * Following idr_* functions are used for resolving duplicated filenames
5787 * and unreceivable filenames to generate ISO9660/Joliet Identifiers.
5791 idr_relaxed_filenames(char *map)
5795 for (i = 0x21; i <= 0x2F; i++)
5797 for (i = 0x3A; i <= 0x41; i++)
5799 for (i = 0x5B; i <= 0x5E; i++)
5802 for (i = 0x7B; i <= 0x7E; i++)
5807 idr_init(struct iso9660 *iso9660, struct vdd *vdd, struct idr *idr)
5810 idr->idrent_pool = NULL;
5812 if (vdd->vdd_type != VDD_JOLIET) {
5813 if (iso9660->opt.iso_level <= 3) {
5814 memcpy(idr->char_map, d_characters_map,
5815 sizeof(idr->char_map));
5817 memcpy(idr->char_map, d1_characters_map,
5818 sizeof(idr->char_map));
5819 idr_relaxed_filenames(idr->char_map);
5825 idr_cleanup(struct idr *idr)
5827 free(idr->idrent_pool);
5831 idr_ensure_poolsize(struct archive_write *a, struct idr *idr,
5835 if (idr->pool_size < cnt) {
5837 const int bk = (1 << 7) - 1;
5840 psize = (cnt + bk) & ~bk;
5841 p = realloc(idr->idrent_pool, sizeof(struct idrent) * psize);
5843 archive_set_error(&a->archive, ENOMEM,
5844 "Can't allocate memory");
5845 return (ARCHIVE_FATAL);
5847 idr->idrent_pool = (struct idrent *)p;
5848 idr->pool_size = psize;
5850 return (ARCHIVE_OK);
5854 idr_start(struct archive_write *a, struct idr *idr, int cnt, int ffmax,
5855 int num_size, int null_size, const struct archive_rb_tree_ops *rbt_ops)
5859 (void)ffmax; /* UNUSED */
5861 r = idr_ensure_poolsize(a, idr, cnt);
5862 if (r != ARCHIVE_OK)
5864 __archive_rb_tree_init(&(idr->rbtree), rbt_ops);
5865 idr->wait_list.first = NULL;
5866 idr->wait_list.last = &(idr->wait_list.first);
5868 idr->num_size = num_size;
5869 idr->null_size = null_size;
5870 return (ARCHIVE_OK);
5874 idr_register(struct idr *idr, struct isoent *isoent, int weight, int noff)
5876 struct idrent *idrent, *n;
5878 idrent = &(idr->idrent_pool[idr->pool_idx++]);
5879 idrent->wnext = idrent->avail = NULL;
5880 idrent->isoent = isoent;
5881 idrent->weight = weight;
5882 idrent->noff = noff;
5883 idrent->rename_num = 0;
5885 if (!__archive_rb_tree_insert_node(&(idr->rbtree), &(idrent->rbnode))) {
5886 n = (struct idrent *)__archive_rb_tree_find_node(
5887 &(idr->rbtree), idrent->isoent);
5889 /* this `idrent' needs to rename. */
5891 *idr->wait_list.last = idrent;
5892 idr->wait_list.last = &(idrent->wnext);
5898 idr_extend_identifier(struct idrent *wnp, int numsize, int nullsize)
5903 wnp_ext_off = wnp->isoent->ext_off;
5904 if (wnp->noff + numsize != wnp_ext_off) {
5905 p = (unsigned char *)wnp->isoent->identifier;
5906 /* Extend the filename; foo.c --> foo___.c */
5907 memmove(p + wnp->noff + numsize, p + wnp_ext_off,
5908 wnp->isoent->ext_len + nullsize);
5909 wnp->isoent->ext_off = wnp_ext_off = wnp->noff + numsize;
5910 wnp->isoent->id_len = wnp_ext_off + wnp->isoent->ext_len;
5915 idr_resolve(struct idr *idr, void (*fsetnum)(unsigned char *p, int num))
5920 for (n = idr->wait_list.first; n != NULL; n = n->wnext) {
5921 idr_extend_identifier(n, idr->num_size, idr->null_size);
5922 p = (unsigned char *)n->isoent->identifier + n->noff;
5924 fsetnum(p, n->avail->rename_num++);
5925 } while (!__archive_rb_tree_insert_node(
5926 &(idr->rbtree), &(n->rbnode)));
5931 idr_set_num(unsigned char *p, int num)
5933 static const char xdig[] = {
5934 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
5935 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
5936 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
5937 'U', 'V', 'W', 'X', 'Y', 'Z'
5940 num %= sizeof(xdig) * sizeof(xdig) * sizeof(xdig);
5941 p[0] = xdig[(num / (sizeof(xdig) * sizeof(xdig)))];
5942 num %= sizeof(xdig) * sizeof(xdig);
5943 p[1] = xdig[ (num / sizeof(xdig))];
5944 num %= sizeof(xdig);
5949 idr_set_num_beutf16(unsigned char *p, int num)
5951 static const uint16_t xdig[] = {
5952 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035,
5953 0x0036, 0x0037, 0x0038, 0x0039,
5954 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046,
5955 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C,
5956 0x004D, 0x004E, 0x004F, 0x0050, 0x0051, 0x0052,
5957 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058,
5960 #define XDIG_CNT (sizeof(xdig)/sizeof(xdig[0]))
5962 num %= XDIG_CNT * XDIG_CNT * XDIG_CNT;
5963 archive_be16enc(p, xdig[(num / (XDIG_CNT * XDIG_CNT))]);
5964 num %= XDIG_CNT * XDIG_CNT;
5965 archive_be16enc(p+2, xdig[ (num / XDIG_CNT)]);
5967 archive_be16enc(p+4, xdig[num]);
5971 * Generate ISO9660 Identifier.
5974 isoent_gen_iso9660_identifier(struct archive_write *a, struct isoent *isoent,
5977 struct iso9660 *iso9660;
5981 const char *char_map;
5982 char allow_ldots, allow_multidot, allow_period, allow_vernum;
5983 int fnmax, ffmax, dnmax;
5984 static const struct archive_rb_tree_ops rb_ops = {
5985 isoent_cmp_node_iso9660, isoent_cmp_key_iso9660
5988 if (isoent->children.cnt == 0)
5991 iso9660 = a->format_data;
5992 char_map = idr->char_map;
5993 if (iso9660->opt.iso_level <= 3) {
5997 allow_vernum = iso9660->opt.allow_vernum;
5998 if (iso9660->opt.iso_level == 1) {
6000 ffmax = 12;/* fnmax + '.' + 3 */
6008 allow_ldots = allow_multidot = 1;
6009 allow_period = allow_vernum = 0;
6010 if (iso9660->opt.rr)
6012 * MDR : The maximum size of Directory Record(254).
6013 * DRL : A Directory Record Length(33).
6014 * CE : A size of SUSP CE System Use Entry(28).
6015 * MDR - DRL - CE = 254 - 33 - 28 = 193.
6017 fnmax = ffmax = dnmax = 193;
6020 * XA : CD-ROM XA System Use Extension
6022 * MDR - DRL - XA = 254 - 33 -14 = 207.
6024 fnmax = ffmax = dnmax = 207;
6027 r = idr_start(a, idr, isoent->children.cnt, ffmax, 3, 1, &rb_ops);
6031 for (np = isoent->children.first; np != NULL; np = np->chnext) {
6033 int ext_off, noff, weight;
6035 l = (int)np->file->basename.length;
6036 p = malloc(l+31+2+1);
6038 archive_set_error(&a->archive, ENOMEM,
6039 "Can't allocate memory");
6040 return (ARCHIVE_FATAL);
6042 memcpy(p, np->file->basename.s, l);
6049 * If there is a '.' character at the first byte,
6050 * it has to be replaced by '_' character.
6060 if (char_map[(unsigned char)*p]) {
6061 /* if iso-level is '4', a character '.' is
6062 * allowed by char_map. */
6069 if (*p >= 'a' && *p <= 'z') {
6099 ext_off = (int)(dot - p);
6101 if (iso9660->opt.iso_level == 1) {
6103 if (strlen(dot) > 4) {
6104 /* A length of a file extension
6105 * must be less than 4 */
6118 } else if (np->dir) {
6122 if (ext_off > dnmax)
6125 } else if (l > ffmax) {
6126 int extlen = (int)strlen(dot);
6130 xdoff = (int)(xdot - p);
6134 if (extlen > 1 && xdoff < fnmax-1) {
6139 off = ffmax - extlen;
6141 /* A dot('.') character
6142 * doesn't place to the first
6143 * byte of identifier. */
6147 memmove(p+off, dot, extlen);
6151 #ifdef COMPAT_MKISOFS
6152 } else if (xdoff >= fnmax-1) {
6153 /* Simulate a bug(?) of mkisofs. */
6165 /* Save an offset of a file name extension to sort files. */
6166 np->ext_off = ext_off;
6167 np->ext_len = (int)strlen(&p[ext_off]);
6168 np->id_len = l = ext_off + np->ext_len;
6170 /* Make an offset of the number which is used to be set
6171 * hexadecimal number to avoid duplicate identifier. */
6172 if (iso9660->opt.iso_level == 1) {
6180 else if (l == ffmax-1)
6182 else if (l == ffmax-2)
6187 /* Register entry to the identifier resolver. */
6188 idr_register(idr, np, weight, noff);
6191 /* Resolve duplicate identifier. */
6192 idr_resolve(idr, idr_set_num);
6194 /* Add a period and a version number to identifiers. */
6195 for (np = isoent->children.first; np != NULL; np = np->chnext) {
6196 if (!np->dir && np->rr_child == NULL) {
6197 p = np->identifier + np->ext_off + np->ext_len;
6198 if (np->ext_len == 0 && allow_period) {
6202 if (np->ext_len == 1 && !allow_period) {
6206 np->id_len = np->ext_off + np->ext_len;
6214 np->id_len = np->ext_off + np->ext_len;
6215 np->mb_len = np->id_len;
6217 return (ARCHIVE_OK);
6221 * Generate Joliet Identifier.
6224 isoent_gen_joliet_identifier(struct archive_write *a, struct isoent *isoent,
6227 struct iso9660 *iso9660;
6232 size_t ffmax, parent_len;
6233 static const struct archive_rb_tree_ops rb_ops = {
6234 isoent_cmp_node_joliet, isoent_cmp_key_joliet
6237 if (isoent->children.cnt == 0)
6240 iso9660 = a->format_data;
6241 if (iso9660->opt.joliet == OPT_JOLIET_LONGNAME)
6246 r = idr_start(a, idr, isoent->children.cnt, (int)ffmax, 6, 2, &rb_ops);
6251 for (np = isoent; np->parent != np; np = np->parent)
6252 parent_len += np->mb_len + 1;
6254 for (np = isoent->children.first; np != NULL; np = np->chnext) {
6256 int ext_off, noff, weight;
6259 if ((l = np->file->basename_utf16.length) > ffmax)
6262 p = malloc((l+1)*2);
6264 archive_set_error(&a->archive, ENOMEM,
6265 "Can't allocate memory");
6266 return (ARCHIVE_FATAL);
6268 memcpy(p, np->file->basename_utf16.s, l);
6272 np->identifier = (char *)p;
6277 if (!joliet_allowed_char(p[0], p[1]))
6278 archive_be16enc(p, 0x005F); /* '_' */
6279 else if (p[0] == 0 && p[1] == 0x2E) /* '.' */
6284 ext_off = (int)(dot - (unsigned char *)np->identifier);
6285 np->ext_off = ext_off;
6286 np->ext_len = (int)l - ext_off;
6287 np->id_len = (int)l;
6290 * Get a length of MBS of a full-pathname.
6292 if (np->file->basename_utf16.length > ffmax) {
6293 if (archive_strncpy_l(&iso9660->mbs,
6294 (const char *)np->identifier, l,
6295 iso9660->sconv_from_utf16be) != 0 &&
6297 archive_set_error(&a->archive, errno,
6299 return (ARCHIVE_FATAL);
6301 np->mb_len = (int)iso9660->mbs.length;
6302 if (np->mb_len != (int)np->file->basename.length)
6303 weight = np->mb_len;
6305 np->mb_len = (int)np->file->basename.length;
6307 /* If a length of full-pathname is longer than 240 bytes,
6308 * it violates Joliet extensions regulation. */
6309 if (parent_len > 240
6311 || parent_len + np->mb_len > 240) {
6312 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
6313 "The regulation of Joliet extensions;"
6314 " A length of a full-pathname of `%s' is "
6315 "longer than 240 bytes, (p=%d, b=%d)",
6316 archive_entry_pathname(np->file->entry),
6317 (int)parent_len, (int)np->mb_len);
6318 return (ARCHIVE_FATAL);
6321 /* Make an offset of the number which is used to be set
6322 * hexadecimal number to avoid duplicate identifier. */
6325 else if (l == ffmax-2)
6327 else if (l == ffmax-4)
6331 /* Register entry to the identifier resolver. */
6332 idr_register(idr, np, weight, noff);
6335 /* Resolve duplicate identifier with Joliet Volume. */
6336 idr_resolve(idr, idr_set_num_beutf16);
6338 return (ARCHIVE_OK);
6342 * This comparing rule is according to ISO9660 Standard 9.3
6345 isoent_cmp_iso9660_identifier(const struct isoent *p1, const struct isoent *p2)
6347 const char *s1, *s2;
6351 s1 = p1->identifier;
6352 s2 = p2->identifier;
6354 /* Compare File Name */
6356 if (l > p2->ext_off)
6358 cmp = memcmp(s1, s2, l);
6361 if (p1->ext_off < p2->ext_off) {
6363 l = p2->ext_off - p1->ext_off;
6367 - *(const unsigned char *)(s2 - 1));
6368 } else if (p1->ext_off > p2->ext_off) {
6370 l = p1->ext_off - p2->ext_off;
6373 return (*(const unsigned char *)(s1 - 1)
6376 /* Compare File Name Extension */
6377 if (p1->ext_len == 0 && p2->ext_len == 0)
6379 if (p1->ext_len == 1 && p2->ext_len == 1)
6381 if (p1->ext_len <= 1)
6383 if (p2->ext_len <= 1)
6386 if (l > p2->ext_len)
6388 s1 = p1->identifier + p1->ext_off;
6389 s2 = p2->identifier + p2->ext_off;
6391 cmp = memcmp(s1, s2, l);
6395 if (p1->ext_len < p2->ext_len) {
6397 l = p2->ext_len - p1->ext_len;
6401 - *(const unsigned char *)(s2 - 1));
6402 } else if (p1->ext_len > p2->ext_len) {
6404 l = p1->ext_len - p2->ext_len;
6407 return (*(const unsigned char *)(s1 - 1)
6410 /* Compare File Version Number */
6411 /* No operation. The File Version Number is always one. */
6417 isoent_cmp_node_iso9660(const struct archive_rb_node *n1,
6418 const struct archive_rb_node *n2)
6420 const struct idrent *e1 = (const struct idrent *)n1;
6421 const struct idrent *e2 = (const struct idrent *)n2;
6423 return (isoent_cmp_iso9660_identifier(e2->isoent, e1->isoent));
6427 isoent_cmp_key_iso9660(const struct archive_rb_node *node, const void *key)
6429 const struct isoent *isoent = (const struct isoent *)key;
6430 const struct idrent *idrent = (const struct idrent *)node;
6432 return (isoent_cmp_iso9660_identifier(isoent, idrent->isoent));
6436 isoent_cmp_joliet_identifier(const struct isoent *p1, const struct isoent *p2)
6438 const unsigned char *s1, *s2;
6442 s1 = (const unsigned char *)p1->identifier;
6443 s2 = (const unsigned char *)p2->identifier;
6445 /* Compare File Name */
6447 if (l > p2->ext_off)
6449 cmp = memcmp(s1, s2, l);
6452 if (p1->ext_off < p2->ext_off) {
6454 l = p2->ext_off - p1->ext_off;
6457 return (- *(const unsigned char *)(s2 - 1));
6458 } else if (p1->ext_off > p2->ext_off) {
6460 l = p1->ext_off - p2->ext_off;
6463 return (*(const unsigned char *)(s1 - 1));
6465 /* Compare File Name Extension */
6466 if (p1->ext_len == 0 && p2->ext_len == 0)
6468 if (p1->ext_len == 2 && p2->ext_len == 2)
6470 if (p1->ext_len <= 2)
6472 if (p2->ext_len <= 2)
6475 if (l > p2->ext_len)
6477 s1 = (unsigned char *)(p1->identifier + p1->ext_off);
6478 s2 = (unsigned char *)(p2->identifier + p2->ext_off);
6480 cmp = memcmp(s1, s2, l);
6484 if (p1->ext_len < p2->ext_len) {
6486 l = p2->ext_len - p1->ext_len;
6489 return (- *(const unsigned char *)(s2 - 1));
6490 } else if (p1->ext_len > p2->ext_len) {
6492 l = p1->ext_len - p2->ext_len;
6495 return (*(const unsigned char *)(s1 - 1));
6497 /* Compare File Version Number */
6498 /* No operation. The File Version Number is always one. */
6504 isoent_cmp_node_joliet(const struct archive_rb_node *n1,
6505 const struct archive_rb_node *n2)
6507 const struct idrent *e1 = (const struct idrent *)n1;
6508 const struct idrent *e2 = (const struct idrent *)n2;
6510 return (isoent_cmp_joliet_identifier(e2->isoent, e1->isoent));
6514 isoent_cmp_key_joliet(const struct archive_rb_node *node, const void *key)
6516 const struct isoent *isoent = (const struct isoent *)key;
6517 const struct idrent *idrent = (const struct idrent *)node;
6519 return (isoent_cmp_joliet_identifier(isoent, idrent->isoent));
6523 isoent_make_sorted_files(struct archive_write *a, struct isoent *isoent,
6526 struct archive_rb_node *rn;
6527 struct isoent **children;
6529 children = malloc(isoent->children.cnt * sizeof(struct isoent *));
6530 if (children == NULL) {
6531 archive_set_error(&a->archive, ENOMEM,
6532 "Can't allocate memory");
6533 return (ARCHIVE_FATAL);
6535 isoent->children_sorted = children;
6537 ARCHIVE_RB_TREE_FOREACH(rn, &(idr->rbtree)) {
6538 struct idrent *idrent = (struct idrent *)rn;
6539 *children ++ = idrent->isoent;
6541 return (ARCHIVE_OK);
6545 * - Generate ISO9660 and Joliet identifiers from basenames.
6546 * - Sort files by each directory.
6549 isoent_traverse_tree(struct archive_write *a, struct vdd* vdd)
6551 struct iso9660 *iso9660 = a->format_data;
6556 int (*genid)(struct archive_write *, struct isoent *, struct idr *);
6558 idr_init(iso9660, vdd, &idr);
6561 if (vdd->vdd_type == VDD_JOLIET)
6562 genid = isoent_gen_joliet_identifier;
6564 genid = isoent_gen_iso9660_identifier;
6567 !archive_entry_mtime_is_set(np->file->entry)) {
6568 /* Set properly times to virtual directory */
6569 archive_entry_set_mtime(np->file->entry,
6570 iso9660->birth_time, 0);
6571 archive_entry_set_atime(np->file->entry,
6572 iso9660->birth_time, 0);
6573 archive_entry_set_ctime(np->file->entry,
6574 iso9660->birth_time, 0);
6576 if (np->children.first != NULL) {
6577 if (vdd->vdd_type != VDD_JOLIET &&
6578 !iso9660->opt.rr && depth + 1 >= vdd->max_depth) {
6579 if (np->children.cnt > 0)
6580 iso9660->directories_too_deep = np;
6582 /* Generate Identifier */
6583 r = genid(a, np, &idr);
6585 goto exit_traverse_tree;
6586 r = isoent_make_sorted_files(a, np, &idr);
6588 goto exit_traverse_tree;
6590 if (np->subdirs.first != NULL &&
6591 depth + 1 < vdd->max_depth) {
6592 /* Enter to sub directories. */
6593 np = np->subdirs.first;
6599 while (np != np->parent) {
6600 if (np->drnext == NULL) {
6601 /* Return to the parent directory. */
6609 } while (np != np->parent);
6619 * Collect directory entries into path_table by a directory depth.
6622 isoent_collect_dirs(struct vdd *vdd, struct isoent *rootent, int depth)
6626 if (rootent == NULL)
6627 rootent = vdd->rootent;
6630 /* Register current directory to pathtable. */
6631 path_table_add_entry(&(vdd->pathtbl[depth]), np);
6633 if (np->subdirs.first != NULL && depth + 1 < vdd->max_depth) {
6634 /* Enter to sub directories. */
6635 np = np->subdirs.first;
6639 while (np != rootent) {
6640 if (np->drnext == NULL) {
6641 /* Return to the parent directory. */
6649 } while (np != rootent);
6651 return (ARCHIVE_OK);
6655 * The entry whose number of levels in a directory hierarchy is
6656 * large than eight relocate to rr_move directory.
6659 isoent_rr_move_dir(struct archive_write *a, struct isoent **rr_moved,
6660 struct isoent *curent, struct isoent **newent)
6662 struct iso9660 *iso9660 = a->format_data;
6663 struct isoent *rrmoved, *mvent, *np;
6665 if ((rrmoved = *rr_moved) == NULL) {
6666 struct isoent *rootent = iso9660->primary.rootent;
6667 /* There isn't rr_move entry.
6668 * Create rr_move entry and insert it into the root entry.
6670 rrmoved = isoent_create_virtual_dir(a, iso9660, "rr_moved");
6671 if (rrmoved == NULL) {
6672 archive_set_error(&a->archive, ENOMEM,
6673 "Can't allocate memory");
6674 return (ARCHIVE_FATAL);
6676 /* Add "rr_moved" entry to the root entry. */
6677 isoent_add_child_head(rootent, rrmoved);
6678 archive_entry_set_nlink(rootent->file->entry,
6679 archive_entry_nlink(rootent->file->entry) + 1);
6680 /* Register "rr_moved" entry to second level pathtable. */
6681 path_table_add_entry(&(iso9660->primary.pathtbl[1]), rrmoved);
6682 /* Save rr_moved. */
6683 *rr_moved = rrmoved;
6686 * Make a clone of curent which is going to be relocated
6689 mvent = isoent_clone(curent);
6690 if (mvent == NULL) {
6691 archive_set_error(&a->archive, ENOMEM,
6692 "Can't allocate memory");
6693 return (ARCHIVE_FATAL);
6695 /* linking.. and use for creating "CL", "PL" and "RE" */
6696 mvent->rr_parent = curent->parent;
6697 curent->rr_child = mvent;
6699 * Move subdirectories from the curent to mvent
6701 if (curent->children.first != NULL) {
6702 *mvent->children.last = curent->children.first;
6703 mvent->children.last = curent->children.last;
6705 for (np = mvent->children.first; np != NULL; np = np->chnext)
6707 mvent->children.cnt = curent->children.cnt;
6708 curent->children.cnt = 0;
6709 curent->children.first = NULL;
6710 curent->children.last = &curent->children.first;
6712 if (curent->subdirs.first != NULL) {
6713 *mvent->subdirs.last = curent->subdirs.first;
6714 mvent->subdirs.last = curent->subdirs.last;
6716 mvent->subdirs.cnt = curent->subdirs.cnt;
6717 curent->subdirs.cnt = 0;
6718 curent->subdirs.first = NULL;
6719 curent->subdirs.last = &curent->subdirs.first;
6722 * The mvent becomes a child of the rr_moved entry.
6724 isoent_add_child_tail(rrmoved, mvent);
6725 archive_entry_set_nlink(rrmoved->file->entry,
6726 archive_entry_nlink(rrmoved->file->entry) + 1);
6728 * This entry which relocated to the rr_moved directory
6729 * has to set the flag as a file.
6730 * See also RRIP 4.1.5.1 Description of the "CL" System Use Entry.
6736 return (ARCHIVE_OK);
6740 isoent_rr_move(struct archive_write *a)
6742 struct iso9660 *iso9660 = a->format_data;
6743 struct path_table *pt;
6744 struct isoent *rootent, *rr_moved;
6745 struct isoent *np, *last;
6748 pt = &(iso9660->primary.pathtbl[MAX_DEPTH-1]);
6749 /* There aren't level 8 directories reaching a deeper level. */
6751 return (ARCHIVE_OK);
6753 rootent = iso9660->primary.rootent;
6754 /* If "rr_moved" directory is already existing,
6755 * we have to use it. */
6756 rr_moved = isoent_find_child(rootent, "rr_moved");
6757 if (rr_moved != NULL &&
6758 rr_moved != rootent->children.first) {
6760 * It's necessary that rr_move is the first entry
6763 /* Remove "rr_moved" entry from children chain. */
6764 isoent_remove_child(rootent, rr_moved);
6766 /* Add "rr_moved" entry into the head of children chain. */
6767 isoent_add_child_head(rootent, rr_moved);
6771 * Check level 8 path_table.
6772 * If find out sub directory entries, that entries move to rr_move.
6775 while (np != NULL) {
6776 last = path_table_last_entry(pt);
6777 for (; np != NULL; np = np->ptnext) {
6778 struct isoent *mvent;
6779 struct isoent *newent;
6783 for (mvent = np->subdirs.first;
6784 mvent != NULL; mvent = mvent->drnext) {
6785 r = isoent_rr_move_dir(a, &rr_moved,
6789 isoent_collect_dirs(&(iso9660->primary),
6793 /* If new entries are added to level 8 path_talbe,
6794 * its sub directory entries move to rr_move too.
6799 return (ARCHIVE_OK);
6803 * This comparing rule is according to ISO9660 Standard 6.9.1
6806 _compare_path_table(const void *v1, const void *v2)
6808 const struct isoent *p1, *p2;
6809 const char *s1, *s2;
6812 p1 = *((const struct isoent **)(uintptr_t)v1);
6813 p2 = *((const struct isoent **)(uintptr_t)v2);
6815 /* Compare parent directory number */
6816 cmp = p1->parent->dir_number - p2->parent->dir_number;
6820 /* Compare identifier */
6821 s1 = p1->identifier;
6822 s2 = p2->identifier;
6824 if (l > p2->ext_off)
6826 cmp = strncmp(s1, s2, l);
6829 if (p1->ext_off < p2->ext_off) {
6831 l = p2->ext_off - p1->ext_off;
6835 - *(const unsigned char *)(s2 - 1));
6836 } else if (p1->ext_off > p2->ext_off) {
6838 l = p1->ext_off - p2->ext_off;
6841 return (*(const unsigned char *)(s1 - 1)
6848 _compare_path_table_joliet(const void *v1, const void *v2)
6850 const struct isoent *p1, *p2;
6851 const unsigned char *s1, *s2;
6854 p1 = *((const struct isoent **)(uintptr_t)v1);
6855 p2 = *((const struct isoent **)(uintptr_t)v2);
6857 /* Compare parent directory number */
6858 cmp = p1->parent->dir_number - p2->parent->dir_number;
6862 /* Compare identifier */
6863 s1 = (const unsigned char *)p1->identifier;
6864 s2 = (const unsigned char *)p2->identifier;
6866 if (l > p2->ext_off)
6868 cmp = memcmp(s1, s2, l);
6871 if (p1->ext_off < p2->ext_off) {
6873 l = p2->ext_off - p1->ext_off;
6876 return (- *(const unsigned char *)(s2 - 1));
6877 } else if (p1->ext_off > p2->ext_off) {
6879 l = p1->ext_off - p2->ext_off;
6882 return (*(const unsigned char *)(s1 - 1));
6888 path_table_add_entry(struct path_table *pathtbl, struct isoent *ent)
6891 *pathtbl->last = ent;
6892 pathtbl->last = &(ent->ptnext);
6896 static inline struct isoent *
6897 path_table_last_entry(struct path_table *pathtbl)
6899 if (pathtbl->first == NULL)
6901 return (((struct isoent *)(void *)
6902 ((char *)(pathtbl->last) - offsetof(struct isoent, ptnext))));
6906 * Sort directory entries in path_table
6907 * and assign directory number to each entries.
6910 isoent_make_path_table_2(struct archive_write *a, struct vdd *vdd,
6911 int depth, int *dir_number)
6914 struct isoent **enttbl;
6915 struct path_table *pt;
6918 pt = &vdd->pathtbl[depth];
6921 return (ARCHIVE_OK);
6923 enttbl = malloc(pt->cnt * sizeof(struct isoent *));
6924 if (enttbl == NULL) {
6925 archive_set_error(&a->archive, ENOMEM,
6926 "Can't allocate memory");
6927 return (ARCHIVE_FATAL);
6929 pt->sorted = enttbl;
6930 for (np = pt->first; np != NULL; np = np->ptnext)
6932 enttbl = pt->sorted;
6934 switch (vdd->vdd_type) {
6937 #ifdef __COMPAR_FN_T
6938 qsort(enttbl, pt->cnt, sizeof(struct isoent *),
6939 (__compar_fn_t)_compare_path_table);
6941 qsort(enttbl, pt->cnt, sizeof(struct isoent *),
6942 _compare_path_table);
6946 #ifdef __COMPAR_FN_T
6947 qsort(enttbl, pt->cnt, sizeof(struct isoent *),
6948 (__compar_fn_t)_compare_path_table_joliet);
6950 qsort(enttbl, pt->cnt, sizeof(struct isoent *),
6951 _compare_path_table_joliet);
6955 for (i = 0; i < pt->cnt; i++)
6956 enttbl[i]->dir_number = (*dir_number)++;
6958 return (ARCHIVE_OK);
6962 isoent_alloc_path_table(struct archive_write *a, struct vdd *vdd,
6967 vdd->max_depth = max_depth;
6968 vdd->pathtbl = malloc(sizeof(*vdd->pathtbl) * vdd->max_depth);
6969 if (vdd->pathtbl == NULL) {
6970 archive_set_error(&a->archive, ENOMEM,
6971 "Can't allocate memory");
6972 return (ARCHIVE_FATAL);
6974 for (i = 0; i < vdd->max_depth; i++) {
6975 vdd->pathtbl[i].first = NULL;
6976 vdd->pathtbl[i].last = &(vdd->pathtbl[i].first);
6977 vdd->pathtbl[i].sorted = NULL;
6978 vdd->pathtbl[i].cnt = 0;
6980 return (ARCHIVE_OK);
6987 isoent_make_path_table(struct archive_write *a)
6989 struct iso9660 *iso9660 = a->format_data;
6996 if (iso9660->dircnt_max >= MAX_DEPTH &&
6997 (!iso9660->opt.limit_depth || iso9660->opt.iso_level == 4))
6998 r = isoent_alloc_path_table(a, &(iso9660->primary),
6999 iso9660->dircnt_max + 1);
7001 /* The number of levels in the hierarchy cannot exceed
7003 r = isoent_alloc_path_table(a, &(iso9660->primary),
7007 if (iso9660->opt.joliet) {
7008 r = isoent_alloc_path_table(a, &(iso9660->joliet),
7009 iso9660->dircnt_max + 1);
7015 * - Collect directories for primary and joliet.
7017 isoent_collect_dirs(&(iso9660->primary), NULL, 0);
7018 if (iso9660->opt.joliet)
7019 isoent_collect_dirs(&(iso9660->joliet), NULL, 0);
7021 * Rockridge; move deeper depth directories to rr_moved.
7023 if (iso9660->opt.rr) {
7024 r = isoent_rr_move(a);
7030 isofile_connect_hardlink_files(iso9660);
7033 * - Renew a value of the depth of that directories.
7034 * - Resolve hardlinks.
7035 * - Convert pathnames to ISO9660 name or UCS2(joliet).
7036 * - Sort files by each directory.
7038 r = isoent_traverse_tree(a, &(iso9660->primary));
7041 if (iso9660->opt.joliet) {
7042 r = isoent_traverse_tree(a, &(iso9660->joliet));
7048 * - Sort directories.
7049 * - Assign all directory number.
7052 for (depth = 0; depth < iso9660->primary.max_depth; depth++) {
7053 r = isoent_make_path_table_2(a, &(iso9660->primary),
7054 depth, &dir_number);
7058 if (iso9660->opt.joliet) {
7060 for (depth = 0; depth < iso9660->joliet.max_depth; depth++) {
7061 r = isoent_make_path_table_2(a, &(iso9660->joliet),
7062 depth, &dir_number);
7067 if (iso9660->opt.limit_dirs && dir_number > 0xffff) {
7069 * Maximum number of directories is 65535(0xffff)
7070 * doe to size(16bit) of Parent Directory Number of
7072 * See also ISO9660 Standard 9.4.
7074 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
7075 "Too many directories(%d) over 65535.", dir_number);
7076 return (ARCHIVE_FATAL);
7079 /* Get the size of the Path Table. */
7080 calculate_path_table_size(&(iso9660->primary));
7081 if (iso9660->opt.joliet)
7082 calculate_path_table_size(&(iso9660->joliet));
7084 return (ARCHIVE_OK);
7088 isoent_find_out_boot_file(struct archive_write *a, struct isoent *rootent)
7090 struct iso9660 *iso9660 = a->format_data;
7092 /* Find a isoent of the boot file. */
7093 iso9660->el_torito.boot = isoent_find_entry(rootent,
7094 iso9660->el_torito.boot_filename.s);
7095 if (iso9660->el_torito.boot == NULL) {
7096 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
7097 "Can't find the boot image file ``%s''",
7098 iso9660->el_torito.boot_filename.s);
7099 return (ARCHIVE_FATAL);
7101 iso9660->el_torito.boot->file->boot = BOOT_IMAGE;
7102 return (ARCHIVE_OK);
7106 isoent_create_boot_catalog(struct archive_write *a, struct isoent *rootent)
7108 struct iso9660 *iso9660 = a->format_data;
7109 struct isofile *file;
7110 struct isoent *isoent;
7111 struct archive_entry *entry;
7113 (void)rootent; /* UNUSED */
7115 * Create the entry which is the "boot.catalog" file.
7117 file = isofile_new(a, NULL);
7119 archive_set_error(&a->archive, ENOMEM,
7120 "Can't allocate memory");
7121 return (ARCHIVE_FATAL);
7123 archive_entry_set_pathname(file->entry,
7124 iso9660->el_torito.catalog_filename.s);
7125 archive_entry_set_size(file->entry, LOGICAL_BLOCK_SIZE);
7126 archive_entry_set_mtime(file->entry, iso9660->birth_time, 0);
7127 archive_entry_set_atime(file->entry, iso9660->birth_time, 0);
7128 archive_entry_set_ctime(file->entry, iso9660->birth_time, 0);
7129 archive_entry_set_uid(file->entry, getuid());
7130 archive_entry_set_gid(file->entry, getgid());
7131 archive_entry_set_mode(file->entry, AE_IFREG | 0444);
7132 archive_entry_set_nlink(file->entry, 1);
7134 if (isofile_gen_utility_names(a, file) < ARCHIVE_WARN) {
7136 return (ARCHIVE_FATAL);
7138 file->boot = BOOT_CATALOG;
7139 file->content.size = LOGICAL_BLOCK_SIZE;
7140 isofile_add_entry(iso9660, file);
7142 isoent = isoent_new(file);
7143 if (isoent == NULL) {
7144 archive_set_error(&a->archive, ENOMEM,
7145 "Can't allocate memory");
7146 return (ARCHIVE_FATAL);
7148 isoent->virtual = 1;
7150 /* Add the "boot.catalog" entry into tree */
7151 if (isoent_tree(a, &isoent) != ARCHIVE_OK)
7152 return (ARCHIVE_FATAL);
7154 iso9660->el_torito.catalog = isoent;
7156 * Get a boot media type.
7158 switch (iso9660->opt.boot_type) {
7160 case OPT_BOOT_TYPE_AUTO:
7161 /* Try detecting a media type of the boot image. */
7162 entry = iso9660->el_torito.boot->file->entry;
7163 if (archive_entry_size(entry) == FD_1_2M_SIZE)
7164 iso9660->el_torito.media_type =
7165 BOOT_MEDIA_1_2M_DISKETTE;
7166 else if (archive_entry_size(entry) == FD_1_44M_SIZE)
7167 iso9660->el_torito.media_type =
7168 BOOT_MEDIA_1_44M_DISKETTE;
7169 else if (archive_entry_size(entry) == FD_2_88M_SIZE)
7170 iso9660->el_torito.media_type =
7171 BOOT_MEDIA_2_88M_DISKETTE;
7173 /* We cannot decide whether the boot image is
7175 iso9660->el_torito.media_type =
7176 BOOT_MEDIA_NO_EMULATION;
7178 case OPT_BOOT_TYPE_NO_EMU:
7179 iso9660->el_torito.media_type = BOOT_MEDIA_NO_EMULATION;
7181 case OPT_BOOT_TYPE_HARD_DISK:
7182 iso9660->el_torito.media_type = BOOT_MEDIA_HARD_DISK;
7184 case OPT_BOOT_TYPE_FD:
7185 entry = iso9660->el_torito.boot->file->entry;
7186 if (archive_entry_size(entry) <= FD_1_2M_SIZE)
7187 iso9660->el_torito.media_type =
7188 BOOT_MEDIA_1_2M_DISKETTE;
7189 else if (archive_entry_size(entry) <= FD_1_44M_SIZE)
7190 iso9660->el_torito.media_type =
7191 BOOT_MEDIA_1_44M_DISKETTE;
7192 else if (archive_entry_size(entry) <= FD_2_88M_SIZE)
7193 iso9660->el_torito.media_type =
7194 BOOT_MEDIA_2_88M_DISKETTE;
7196 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
7197 "Boot image file(``%s'') size is too big "
7199 iso9660->el_torito.boot_filename.s);
7200 return (ARCHIVE_FATAL);
7206 * Get a system type.
7207 * TODO: `El Torito' specification says "A copy of byte 5 from the
7208 * Partition Table found in the boot image".
7210 iso9660->el_torito.system_type = 0;
7215 if (iso9660->opt.publisher)
7216 archive_string_copy(&(iso9660->el_torito.id),
7217 &(iso9660->publisher_identifier));
7220 return (ARCHIVE_OK);
7224 * If a media type is floppy, return its image size.
7225 * otherwise return 0.
7228 fd_boot_image_size(int media_type)
7230 switch (media_type) {
7231 case BOOT_MEDIA_1_2M_DISKETTE:
7232 return (FD_1_2M_SIZE);
7233 case BOOT_MEDIA_1_44M_DISKETTE:
7234 return (FD_1_44M_SIZE);
7235 case BOOT_MEDIA_2_88M_DISKETTE:
7236 return (FD_2_88M_SIZE);
7243 * Make a boot catalog image data.
7246 make_boot_catalog(struct archive_write *a)
7248 struct iso9660 *iso9660 = a->format_data;
7249 unsigned char *block;
7253 block = wb_buffptr(a);
7254 memset(block, 0, LOGICAL_BLOCK_SIZE);
7262 p[1] = iso9660->el_torito.platform_id;
7266 if (archive_strlen(&(iso9660->el_torito.id)) > 0)
7267 strncpy((char *)p+4, iso9660->el_torito.id.s, 23);
7276 wp = (uint16_t *)block;
7277 while (wp < (uint16_t *)&block[32])
7278 sum += archive_le16dec(wp++);
7279 set_num_721(&block[28], (~sum) + 1);
7282 * Initial/Default Entry
7285 /* Boot Indicator */
7287 /* Boot media type */
7288 p[1] = iso9660->el_torito.media_type;
7290 if (iso9660->el_torito.media_type == BOOT_MEDIA_NO_EMULATION)
7291 set_num_721(&p[2], iso9660->el_torito.boot_load_seg);
7293 set_num_721(&p[2], 0);
7295 p[4] = iso9660->el_torito.system_type;
7299 if (iso9660->el_torito.media_type == BOOT_MEDIA_NO_EMULATION)
7300 set_num_721(&p[6], iso9660->el_torito.boot_load_size);
7302 set_num_721(&p[6], 1);
7305 iso9660->el_torito.boot->file->content.location);
7307 memset(&p[12], 0, 20);
7309 return (wb_consume(a, LOGICAL_BLOCK_SIZE));
7313 setup_boot_information(struct archive_write *a)
7315 struct iso9660 *iso9660 = a->format_data;
7319 unsigned char buff[4096];
7321 np = iso9660->el_torito.boot;
7322 lseek(iso9660->temp_fd,
7323 np->file->content.offset_of_temp + 64, SEEK_SET);
7324 size = archive_entry_size(np->file->entry) - 64;
7326 archive_set_error(&a->archive, errno,
7327 "Boot file(%jd) is too small", (intmax_t)size + 64);
7328 return (ARCHIVE_FATAL);
7335 if (size > (int64_t)sizeof(buff))
7336 rsize = sizeof(buff);
7338 rsize = (size_t)size;
7340 rs = read(iso9660->temp_fd, buff, rsize);
7342 archive_set_error(&a->archive, errno,
7343 "Can't read temporary file(%jd)",
7345 return (ARCHIVE_FATAL);
7347 for (i = 0; i < rs; i += 4)
7348 sum += archive_le32dec(buff + i);
7351 /* Set the location of Primary Volume Descriptor. */
7352 set_num_731(buff, SYSTEM_AREA_BLOCK);
7353 /* Set the location of the boot file. */
7354 set_num_731(buff+4, np->file->content.location);
7355 /* Set the size of the boot file. */
7356 size = fd_boot_image_size(iso9660->el_torito.media_type);
7358 size = archive_entry_size(np->file->entry);
7359 set_num_731(buff+8, (uint32_t)size);
7360 /* Set the sum of the boot file. */
7361 set_num_731(buff+12, sum);
7362 /* Clear reserved bytes. */
7363 memset(buff+16, 0, 40);
7365 /* Overwrite the boot file. */
7366 lseek(iso9660->temp_fd,
7367 np->file->content.offset_of_temp + 8, SEEK_SET);
7368 return (write_to_temp(a, buff, 56));
7374 zisofs_init_zstream(struct archive_write *a)
7376 struct iso9660 *iso9660 = a->format_data;
7379 iso9660->zisofs.stream.next_in = NULL;
7380 iso9660->zisofs.stream.avail_in = 0;
7381 iso9660->zisofs.stream.total_in = 0;
7382 iso9660->zisofs.stream.total_out = 0;
7383 if (iso9660->zisofs.stream_valid)
7384 r = deflateReset(&(iso9660->zisofs.stream));
7386 r = deflateInit(&(iso9660->zisofs.stream),
7387 iso9660->zisofs.compression_level);
7388 iso9660->zisofs.stream_valid = 1;
7394 case Z_STREAM_ERROR:
7395 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
7396 "Internal error initializing "
7397 "compression library: invalid setup parameter");
7398 return (ARCHIVE_FATAL);
7400 archive_set_error(&a->archive, ENOMEM,
7401 "Internal error initializing "
7402 "compression library");
7403 return (ARCHIVE_FATAL);
7404 case Z_VERSION_ERROR:
7405 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
7406 "Internal error initializing "
7407 "compression library: invalid library version");
7408 return (ARCHIVE_FATAL);
7410 return (ARCHIVE_OK);
7413 #endif /* HAVE_ZLIB_H */
7416 zisofs_init(struct archive_write *a, struct isofile *file)
7418 struct iso9660 *iso9660 = a->format_data;
7421 size_t _ceil, bpsize;
7425 iso9660->zisofs.detect_magic = 0;
7426 iso9660->zisofs.making = 0;
7428 if (!iso9660->opt.rr || !iso9660->opt.zisofs)
7429 return (ARCHIVE_OK);
7431 if (archive_entry_size(file->entry) >= 24 &&
7432 archive_entry_size(file->entry) < MULTI_EXTENT_SIZE) {
7433 /* Acceptable file size for zisofs. */
7434 iso9660->zisofs.detect_magic = 1;
7435 iso9660->zisofs.magic_cnt = 0;
7437 if (!iso9660->zisofs.detect_magic)
7438 return (ARCHIVE_OK);
7441 /* The number of Logical Blocks which uncompressed data
7442 * will use in iso-image file is the same as the number of
7443 * Logical Blocks which zisofs(compressed) data will use
7444 * in ISO-image file. It won't reduce iso-image file size. */
7445 if (archive_entry_size(file->entry) <= LOGICAL_BLOCK_SIZE)
7446 return (ARCHIVE_OK);
7448 /* Initialize compression library */
7449 r = zisofs_init_zstream(a);
7450 if (r != ARCHIVE_OK)
7451 return (ARCHIVE_FATAL);
7453 /* Mark file->zisofs to create RRIP 'ZF' Use Entry. */
7454 file->zisofs.header_size = ZF_HEADER_SIZE >> 2;
7455 file->zisofs.log2_bs = ZF_LOG2_BS;
7456 file->zisofs.uncompressed_size =
7457 (uint32_t)archive_entry_size(file->entry);
7459 /* Calculate a size of Block Pointers of zisofs. */
7460 _ceil = (file->zisofs.uncompressed_size + ZF_BLOCK_SIZE -1)
7461 >> file->zisofs.log2_bs;
7462 iso9660->zisofs.block_pointers_cnt = (int)_ceil + 1;
7463 iso9660->zisofs.block_pointers_idx = 0;
7465 /* Ensure a buffer size used for Block Pointers */
7466 bpsize = iso9660->zisofs.block_pointers_cnt *
7467 sizeof(iso9660->zisofs.block_pointers[0]);
7468 if (iso9660->zisofs.block_pointers_allocated < bpsize) {
7469 free(iso9660->zisofs.block_pointers);
7470 iso9660->zisofs.block_pointers = malloc(bpsize);
7471 if (iso9660->zisofs.block_pointers == NULL) {
7472 archive_set_error(&a->archive, ENOMEM,
7473 "Can't allocate data");
7474 return (ARCHIVE_FATAL);
7476 iso9660->zisofs.block_pointers_allocated = bpsize;
7480 * Skip zisofs header and Block Pointers, which we will write
7481 * after all compressed data of a file written to the temporary
7484 tsize = ZF_HEADER_SIZE + bpsize;
7485 if (write_null(a, (size_t)tsize) != ARCHIVE_OK)
7486 return (ARCHIVE_FATAL);
7489 * Initialize some variables to make zisofs.
7491 archive_le32enc(&(iso9660->zisofs.block_pointers[0]),
7493 iso9660->zisofs.remaining = file->zisofs.uncompressed_size;
7494 iso9660->zisofs.making = 1;
7495 iso9660->zisofs.allzero = 1;
7496 iso9660->zisofs.block_offset = tsize;
7497 iso9660->zisofs.total_size = tsize;
7498 iso9660->cur_file->cur_content->size = tsize;
7501 return (ARCHIVE_OK);
7505 zisofs_detect_magic(struct archive_write *a, const void *buff, size_t s)
7507 struct iso9660 *iso9660 = a->format_data;
7508 struct isofile *file = iso9660->cur_file;
7509 const unsigned char *p, *endp;
7510 const unsigned char *magic_buff;
7511 uint32_t uncompressed_size;
7512 unsigned char header_size;
7513 unsigned char log2_bs;
7519 entry_size = archive_entry_size(file->entry);
7520 if ((int64_t)sizeof(iso9660->zisofs.magic_buffer) > entry_size)
7521 magic_max = (int)entry_size;
7523 magic_max = sizeof(iso9660->zisofs.magic_buffer);
7525 if (iso9660->zisofs.magic_cnt == 0 && s >= (size_t)magic_max)
7526 /* It's unnecessary we copy buffer. */
7529 if (iso9660->zisofs.magic_cnt < magic_max) {
7532 l = sizeof(iso9660->zisofs.magic_buffer)
7533 - iso9660->zisofs.magic_cnt;
7536 memcpy(iso9660->zisofs.magic_buffer
7537 + iso9660->zisofs.magic_cnt, buff, l);
7538 iso9660->zisofs.magic_cnt += (int)l;
7539 if (iso9660->zisofs.magic_cnt < magic_max)
7542 magic_buff = iso9660->zisofs.magic_buffer;
7544 iso9660->zisofs.detect_magic = 0;
7547 /* Check the magic code of zisofs. */
7548 if (memcmp(p, zisofs_magic, sizeof(zisofs_magic)) != 0)
7549 /* This is not zisofs file which made by mkzftree. */
7551 p += sizeof(zisofs_magic);
7553 /* Read a zisofs header. */
7554 uncompressed_size = archive_le32dec(p);
7557 if (uncompressed_size < 24 || header_size != 4 ||
7558 log2_bs > 30 || log2_bs < 7)
7559 return;/* Invalid or not supported header. */
7561 /* Calculate a size of Block Pointers of zisofs. */
7562 _ceil = (uncompressed_size +
7563 (ARCHIVE_LITERAL_LL(1) << log2_bs) -1) >> log2_bs;
7564 doff = (_ceil + 1) * 4 + 16;
7565 if (entry_size < (int64_t)doff)
7566 return;/* Invalid data. */
7568 /* Check every Block Pointer has valid value. */
7569 p = magic_buff + 16;
7570 endp = magic_buff + magic_max;
7571 while (_ceil && p + 8 <= endp) {
7572 bst = archive_le32dec(p);
7574 return;/* Invalid data. */
7576 bed = archive_le32dec(p);
7577 if (bed < bst || bed > entry_size)
7578 return;/* Invalid data. */
7583 file->zisofs.uncompressed_size = uncompressed_size;
7584 file->zisofs.header_size = header_size;
7585 file->zisofs.log2_bs = log2_bs;
7587 /* Disable making a zisofs image. */
7588 iso9660->zisofs.making = 0;
7594 * Compress data and write it to a temporary file.
7597 zisofs_write_to_temp(struct archive_write *a, const void *buff, size_t s)
7599 struct iso9660 *iso9660 = a->format_data;
7600 struct isofile *file = iso9660->cur_file;
7601 const unsigned char *b;
7603 size_t avail, csize;
7606 zstrm = &(iso9660->zisofs.stream);
7607 zstrm->next_out = wb_buffptr(a);
7608 zstrm->avail_out = (uInt)wb_remaining(a);
7609 b = (const unsigned char *)buff;
7611 avail = ZF_BLOCK_SIZE - zstrm->total_in;
7617 iso9660->zisofs.remaining -= avail;
7618 if (iso9660->zisofs.remaining <= 0)
7621 zstrm->next_in = (Bytef *)(uintptr_t)(const void *)b;
7622 zstrm->avail_in = (uInt)avail;
7625 * Check if current data block are all zero.
7627 if (iso9660->zisofs.allzero) {
7628 const unsigned char *nonzero = b;
7629 const unsigned char *nonzeroend = b + avail;
7631 while (nonzero < nonzeroend)
7633 iso9660->zisofs.allzero = 0;
7641 * If current data block are all zero, we do not use
7644 if (flush == Z_FINISH && iso9660->zisofs.allzero &&
7645 avail + zstrm->total_in == ZF_BLOCK_SIZE) {
7646 if (iso9660->zisofs.block_offset !=
7647 file->cur_content->size) {
7650 r = wb_set_offset(a,
7651 file->cur_content->offset_of_temp +
7652 iso9660->zisofs.block_offset);
7653 if (r != ARCHIVE_OK)
7655 diff = file->cur_content->size -
7656 iso9660->zisofs.block_offset;
7657 file->cur_content->size -= diff;
7658 iso9660->zisofs.total_size -= diff;
7660 zstrm->avail_in = 0;
7664 * Compress file data.
7666 while (zstrm->avail_in > 0) {
7667 csize = zstrm->total_out;
7668 r = deflate(zstrm, flush);
7672 csize = zstrm->total_out - csize;
7673 if (wb_consume(a, csize) != ARCHIVE_OK)
7674 return (ARCHIVE_FATAL);
7675 iso9660->zisofs.total_size += csize;
7676 iso9660->cur_file->cur_content->size += csize;
7677 zstrm->next_out = wb_buffptr(a);
7678 zstrm->avail_out = (uInt)wb_remaining(a);
7681 archive_set_error(&a->archive,
7683 "Compression failed:"
7684 " deflate() call returned status %d",
7686 return (ARCHIVE_FATAL);
7690 if (flush == Z_FINISH) {
7692 * Save the information of one zisofs block.
7694 iso9660->zisofs.block_pointers_idx ++;
7695 archive_le32enc(&(iso9660->zisofs.block_pointers[
7696 iso9660->zisofs.block_pointers_idx]),
7697 (uint32_t)iso9660->zisofs.total_size);
7698 r = zisofs_init_zstream(a);
7699 if (r != ARCHIVE_OK)
7700 return (ARCHIVE_FATAL);
7701 iso9660->zisofs.allzero = 1;
7702 iso9660->zisofs.block_offset = file->cur_content->size;
7706 return (ARCHIVE_OK);
7710 zisofs_finish_entry(struct archive_write *a)
7712 struct iso9660 *iso9660 = a->format_data;
7713 struct isofile *file = iso9660->cur_file;
7714 unsigned char buff[16];
7718 /* Direct temp file stream to zisofs temp file stream. */
7719 archive_entry_set_size(file->entry, iso9660->zisofs.total_size);
7722 * Save a file pointer which points the end of current zisofs data.
7724 tail = wb_offset(a);
7729 * +-----------------+----------------+-----------------+
7730 * | Header 16 bytes | Block Pointers | Compressed data |
7731 * +-----------------+----------------+-----------------+
7734 * 4 * (((Uncompressed file size + block_size -1) / block_size) + 1)
7736 * Write zisofs header.
7738 * +----+----+----+----+----+----+----+----+
7739 * | 37 | E4 | 53 | 96 | C9 | DB | D6 | 07 |
7740 * +----+----+----+----+----+----+----+----+
7743 * +------------------------+------------------+
7744 * | Uncompressed file size | header_size >> 2 |
7745 * +------------------------+------------------+
7748 * +-----------------+----------------+
7749 * | log2 block_size | Reserved(0000) |
7750 * +-----------------+----------------+
7753 memcpy(buff, zisofs_magic, 8);
7754 set_num_731(buff+8, file->zisofs.uncompressed_size);
7755 buff[12] = file->zisofs.header_size;
7756 buff[13] = file->zisofs.log2_bs;
7757 buff[14] = buff[15] = 0;/* Reserved */
7759 /* Move to the right position to write the header. */
7760 wb_set_offset(a, file->content.offset_of_temp);
7762 /* Write the header. */
7763 if (wb_write_to_temp(a, buff, 16) != ARCHIVE_OK)
7764 return (ARCHIVE_FATAL);
7767 * Write zisofs Block Pointers.
7769 s = iso9660->zisofs.block_pointers_cnt *
7770 sizeof(iso9660->zisofs.block_pointers[0]);
7771 if (wb_write_to_temp(a, iso9660->zisofs.block_pointers, s)
7773 return (ARCHIVE_FATAL);
7775 /* Set a file pointer back to the end of the temporary file. */
7776 wb_set_offset(a, tail);
7778 return (ARCHIVE_OK);
7782 zisofs_free(struct archive_write *a)
7784 struct iso9660 *iso9660 = a->format_data;
7785 int ret = ARCHIVE_OK;
7787 free(iso9660->zisofs.block_pointers);
7788 if (iso9660->zisofs.stream_valid &&
7789 deflateEnd(&(iso9660->zisofs.stream)) != Z_OK) {
7790 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
7791 "Failed to clean up compressor");
7792 ret = ARCHIVE_FATAL;
7794 iso9660->zisofs.block_pointers = NULL;
7795 iso9660->zisofs.stream_valid = 0;
7799 struct zisofs_extract {
7800 int pz_log2_bs; /* Log2 of block size */
7801 uint64_t pz_uncompressed_size;
7802 size_t uncompressed_buffer_size;
7805 int header_passed:1;
7808 unsigned char *block_pointers;
7809 size_t block_pointers_size;
7810 size_t block_pointers_avail;
7812 uint32_t block_avail;
7819 zisofs_extract_init(struct archive_write *a, struct zisofs_extract *zisofs,
7820 const unsigned char *p, size_t bytes)
7822 size_t avail = bytes;
7823 size_t _ceil, xsize;
7825 /* Allocate block pointers buffer. */
7826 _ceil = (size_t)((zisofs->pz_uncompressed_size +
7827 (((int64_t)1) << zisofs->pz_log2_bs) - 1)
7828 >> zisofs->pz_log2_bs);
7829 xsize = (_ceil + 1) * 4;
7830 if (zisofs->block_pointers == NULL) {
7831 size_t alloc = ((xsize >> 10) + 1) << 10;
7832 zisofs->block_pointers = malloc(alloc);
7833 if (zisofs->block_pointers == NULL) {
7834 archive_set_error(&a->archive, ENOMEM,
7835 "No memory for zisofs decompression");
7836 return (ARCHIVE_FATAL);
7839 zisofs->block_pointers_size = xsize;
7841 /* Allocate uncompressed data buffer. */
7842 zisofs->uncompressed_buffer_size = (size_t)1UL << zisofs->pz_log2_bs;
7845 * Read the file header, and check the magic code of zisofs.
7847 if (!zisofs->header_passed) {
7850 archive_set_error(&a->archive,
7851 ARCHIVE_ERRNO_FILE_FORMAT,
7852 "Illegal zisofs file body");
7853 return (ARCHIVE_FATAL);
7856 if (memcmp(p, zisofs_magic, sizeof(zisofs_magic)) != 0)
7858 else if (archive_le32dec(p + 8) != zisofs->pz_uncompressed_size)
7860 else if (p[12] != 4 || p[13] != zisofs->pz_log2_bs)
7863 archive_set_error(&a->archive,
7864 ARCHIVE_ERRNO_FILE_FORMAT,
7865 "Illegal zisofs file body");
7866 return (ARCHIVE_FATAL);
7870 zisofs->header_passed = 1;
7874 * Read block pointers.
7876 if (zisofs->header_passed &&
7877 zisofs->block_pointers_avail < zisofs->block_pointers_size) {
7878 xsize = zisofs->block_pointers_size
7879 - zisofs->block_pointers_avail;
7882 memcpy(zisofs->block_pointers
7883 + zisofs->block_pointers_avail, p, xsize);
7884 zisofs->block_pointers_avail += xsize;
7886 if (zisofs->block_pointers_avail
7887 == zisofs->block_pointers_size) {
7888 /* We've got all block pointers and initialize
7889 * related variables. */
7890 zisofs->block_off = 0;
7891 zisofs->block_avail = 0;
7892 /* Complete a initialization */
7893 zisofs->initialized = 1;
7896 return ((ssize_t)avail);
7900 zisofs_extract(struct archive_write *a, struct zisofs_extract *zisofs,
7901 const unsigned char *p, size_t bytes)
7906 if (!zisofs->initialized) {
7907 ssize_t rs = zisofs_extract_init(a, zisofs, p, bytes);
7910 if (!zisofs->initialized) {
7911 /* We need more data. */
7912 zisofs->pz_offset += (uint32_t)bytes;
7921 * Get block offsets from block pointers.
7923 if (zisofs->block_avail == 0) {
7926 if (zisofs->block_off + 4 >= zisofs->block_pointers_size) {
7927 /* There isn't a pair of offsets. */
7928 archive_set_error(&a->archive,
7929 ARCHIVE_ERRNO_FILE_FORMAT,
7930 "Illegal zisofs block pointers");
7931 return (ARCHIVE_FATAL);
7933 bst = archive_le32dec(
7934 zisofs->block_pointers + zisofs->block_off);
7935 if (bst != zisofs->pz_offset + (bytes - avail)) {
7936 archive_set_error(&a->archive,
7937 ARCHIVE_ERRNO_FILE_FORMAT,
7938 "Illegal zisofs block pointers(cannot seek)");
7939 return (ARCHIVE_FATAL);
7941 bed = archive_le32dec(
7942 zisofs->block_pointers + zisofs->block_off + 4);
7944 archive_set_error(&a->archive,
7945 ARCHIVE_ERRNO_FILE_FORMAT,
7946 "Illegal zisofs block pointers");
7947 return (ARCHIVE_FATAL);
7949 zisofs->block_avail = bed - bst;
7950 zisofs->block_off += 4;
7952 /* Initialize compression library for new block. */
7953 if (zisofs->stream_valid)
7954 r = inflateReset(&zisofs->stream);
7956 r = inflateInit(&zisofs->stream);
7958 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
7959 "Can't initialize zisofs decompression.");
7960 return (ARCHIVE_FATAL);
7962 zisofs->stream_valid = 1;
7963 zisofs->stream.total_in = 0;
7964 zisofs->stream.total_out = 0;
7968 * Make uncompressed data.
7970 if (zisofs->block_avail == 0) {
7972 * It's basically 32K bytes NUL data.
7977 size = zisofs->uncompressed_buffer_size;
7980 if (size > wb_remaining(a))
7981 wsize = wb_remaining(a);
7984 memset(wb, 0, wsize);
7985 r = wb_consume(a, wsize);
7991 zisofs->stream.next_in = (Bytef *)(uintptr_t)(const void *)p;
7992 if (avail > zisofs->block_avail)
7993 zisofs->stream.avail_in = zisofs->block_avail;
7995 zisofs->stream.avail_in = (uInt)avail;
7996 zisofs->stream.next_out = wb_buffptr(a);
7997 zisofs->stream.avail_out = (uInt)wb_remaining(a);
7999 r = inflate(&zisofs->stream, 0);
8001 case Z_OK: /* Decompressor made some progress.*/
8002 case Z_STREAM_END: /* Found end of stream. */
8005 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
8006 "zisofs decompression failed (%d)", r);
8007 return (ARCHIVE_FATAL);
8009 avail -= zisofs->stream.next_in - p;
8010 zisofs->block_avail -= (uint32_t)(zisofs->stream.next_in - p);
8011 r = wb_consume(a, wb_remaining(a) - zisofs->stream.avail_out);
8015 zisofs->pz_offset += (uint32_t)bytes;
8016 return (bytes - avail);
8020 zisofs_rewind_boot_file(struct archive_write *a)
8022 struct iso9660 *iso9660 = a->format_data;
8023 struct isofile *file;
8024 unsigned char *rbuff;
8026 size_t remaining, rbuff_size;
8027 struct zisofs_extract zext;
8028 int64_t read_offset, write_offset, new_offset;
8029 int fd, ret = ARCHIVE_OK;
8031 file = iso9660->el_torito.boot->file;
8033 * There is nothing to do if this boot file does not have
8036 if (file->zisofs.header_size == 0)
8037 return (ARCHIVE_OK);
8040 * Uncompress the zisofs'ed file contents.
8042 memset(&zext, 0, sizeof(zext));
8043 zext.pz_uncompressed_size = file->zisofs.uncompressed_size;
8044 zext.pz_log2_bs = file->zisofs.log2_bs;
8046 fd = iso9660->temp_fd;
8047 new_offset = wb_offset(a);
8048 read_offset = file->content.offset_of_temp;
8049 remaining = (size_t)file->content.size;
8050 if (remaining > 1024 * 32)
8051 rbuff_size = 1024 * 32;
8053 rbuff_size = remaining;
8055 rbuff = malloc(rbuff_size);
8056 if (rbuff == NULL) {
8057 archive_set_error(&a->archive, ENOMEM, "Can't allocate memory");
8058 return (ARCHIVE_FATAL);
8064 /* Get the current file pointer. */
8065 write_offset = lseek(fd, 0, SEEK_CUR);
8067 /* Change the file pointer to read. */
8068 lseek(fd, read_offset, SEEK_SET);
8071 if (rsize > remaining)
8073 rs = read(iso9660->temp_fd, rbuff, rsize);
8075 archive_set_error(&a->archive, errno,
8076 "Can't read temporary file(%jd)", (intmax_t)rs);
8077 ret = ARCHIVE_FATAL;
8083 /* Put the file pointer back to write. */
8084 lseek(fd, write_offset, SEEK_SET);
8086 r = zisofs_extract(a, &zext, rbuff, rs);
8093 if (ret == ARCHIVE_OK) {
8095 * Change the boot file content from zisofs'ed data
8098 file->content.offset_of_temp = new_offset;
8099 file->content.size = file->zisofs.uncompressed_size;
8100 archive_entry_set_size(file->entry, file->content.size);
8101 /* Set to be no zisofs. */
8102 file->zisofs.header_size = 0;
8103 file->zisofs.log2_bs = 0;
8104 file->zisofs.uncompressed_size = 0;
8105 r = wb_write_padding_to_temp(a, file->content.size);
8107 ret = ARCHIVE_FATAL;
8111 * Free the resource we used in this function only.
8114 free(zext.block_pointers);
8115 if (zext.stream_valid && inflateEnd(&(zext.stream)) != Z_OK) {
8116 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
8117 "Failed to clean up compressor");
8118 ret = ARCHIVE_FATAL;
8127 zisofs_write_to_temp(struct archive_write *a, const void *buff, size_t s)
8129 (void)buff; /* UNUSED */
8130 (void)s; /* UNUSED */
8131 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, "Programing error");
8132 return (ARCHIVE_FATAL);
8136 zisofs_rewind_boot_file(struct archive_write *a)
8138 struct iso9660 *iso9660 = a->format_data;
8140 if (iso9660->el_torito.boot->file->zisofs.header_size != 0) {
8141 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
8142 "We cannot extract the zisofs imaged boot file;"
8143 " this may not boot in being zisofs imaged");
8144 return (ARCHIVE_FAILED);
8146 return (ARCHIVE_OK);
8150 zisofs_finish_entry(struct archive_write *a)
8152 (void)a; /* UNUSED */
8153 return (ARCHIVE_OK);
8157 zisofs_free(struct archive_write *a)
8159 (void)a; /* UNUSED */
8160 return (ARCHIVE_OK);
8163 #endif /* HAVE_ZLIB_H */