libisofs 1.5.6
libisofs.h
Go to the documentation of this file.
1
2#ifndef LIBISO_LIBISOFS_H_
3#define LIBISO_LIBISOFS_H_
4
5/*
6 * Copyright (c) 2007-2008 Vreixo Formoso, Mario Danic
7 * Copyright (c) 2009-2023 Thomas Schmitt
8 *
9 * This file is part of the libisofs project; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version 2
11 * or later as published by the Free Software Foundation.
12 * See COPYING file for details.
13 */
14
15/* Important: If you add a public API function then add its name to file
16 libisofs/libisofs.ver
17*/
18
19#ifdef __cplusplus
20extern "C" {
21#endif
22
23/*
24 *
25 * Applications must use 64 bit off_t.
26 * E.g. on 32-bit GNU/Linux by defining
27 * #define _LARGEFILE_SOURCE
28 * #define _FILE_OFFSET_BITS 64
29 * The minimum requirement is to interface with the library by 64 bit signed
30 * integers where libisofs.h or libisoburn.h prescribe off_t.
31 * Failure to do so may result in surprising malfunction or memory faults.
32 *
33 * Application files which include libisofs/libisofs.h must provide
34 * definitions for uint32_t and uint8_t.
35 * This can be achieved either:
36 * - by using autotools which will define HAVE_STDINT_H or HAVE_INTTYPES_H
37 * according to its ./configure tests,
38 * - or by defining the macros HAVE_STDINT_H or HAVE_INTTYPES_H according
39 * to the local situation,
40 * - or by appropriately defining uint32_t and uint8_t by other means,
41 * e.g. by including inttypes.h before including libisofs.h
42 */
43#ifdef HAVE_STDINT_H
44#include <stdint.h>
45#else
46#ifdef HAVE_INTTYPES_H
47#include <inttypes.h>
48#endif
49#endif
50
51
52/*
53 * Normally this API is operated via public functions and opaque object
54 * handles. But it also exposes several C structures which may be used to
55 * provide custom functionality for the objects of the API. The same
56 * structures are used for internal objects of libisofs, too.
57 * You are not supposed to manipulate the entrails of such objects if they
58 * are not your own custom extensions.
59 *
60 * See for an example IsoStream = struct iso_stream below.
61 */
62
63
64#include <sys/stat.h>
65
66#include <stdlib.h>
67
68/* Because AIX defines "open" as "open64".
69 There are struct members named "open" in libisofs.h which get affected.
70 So all includers of libisofs.h must get included fcntl.h to see the same.
71*/
72#include <fcntl.h>
73
74
75/**
76 * The following two functions and three macros are utilities to help ensuring
77 * version match of application, compile time header, and runtime library.
78 */
79/**
80 * These three release version numbers tell the revision of this header file
81 * and of the API it describes. They are memorized by applications at
82 * compile time.
83 * They must show the same values as these symbols in ./configure.ac
84 * LIBISOFS_MAJOR_VERSION=...
85 * LIBISOFS_MINOR_VERSION=...
86 * LIBISOFS_MICRO_VERSION=...
87 * Note to anybody who does own work inside libisofs:
88 * Any change of configure.ac or libisofs.h has to keep up this equality !
89 *
90 * Before usage of these macros on your code, please read the usage discussion
91 * below.
92 *
93 * @since 0.6.2
94 */
95#define iso_lib_header_version_major 1
96#define iso_lib_header_version_minor 5
97#define iso_lib_header_version_micro 6
98
99/**
100 * Get version of the libisofs library at runtime.
101 * NOTE: This function may be called before iso_init().
102 *
103 * @since 0.6.2
104 */
105void iso_lib_version(int *major, int *minor, int *micro);
106
107/**
108 * Check at runtime if the library is ABI compatible with the given version.
109 * NOTE: This function may be called before iso_init().
110 *
111 * @return
112 * 1 lib is compatible, 0 is not.
113 *
114 * @since 0.6.2
115 */
116int iso_lib_is_compatible(int major, int minor, int micro);
117
118/**
119 * Usage discussion:
120 *
121 * Some developers of the libburnia project have differing opinions how to
122 * ensure the compatibility of libraries and applications.
123 *
124 * It is about whether to use at compile time and at runtime the version
125 * numbers provided here. Thomas Schmitt advises to use them. Vreixo Formoso
126 * advises to use other means.
127 *
128 * At compile time:
129 *
130 * Vreixo Formoso advises to leave proper version matching to properly
131 * programmed checks in the the application's build system, which will
132 * eventually refuse compilation.
133 *
134 * Thomas Schmitt advises to use the macros defined here for comparison with
135 * the application's requirements of library revisions and to eventually
136 * break compilation.
137 *
138 * Both advises are combinable. I.e. be master of your build system and have
139 * #if checks in the source code of your application, nevertheless.
140 *
141 * At runtime (via iso_lib_is_compatible()):
142 *
143 * Vreixo Formoso advises to compare the application's requirements of
144 * library revisions with the runtime library. This is to allow runtime
145 * libraries which are young enough for the application but too old for
146 * the lib*.h files seen at compile time.
147 *
148 * Thomas Schmitt advises to compare the header revisions defined here with
149 * the runtime library. This is to enforce a strictly monotonous chain of
150 * revisions from app to header to library, at the cost of excluding some older
151 * libraries.
152 *
153 * These two advises are mutually exclusive.
154 */
155
156struct burn_source;
157
158/**
159 * Context for image creation. It holds the files that will be added to image,
160 * and several options to control libisofs behavior.
161 *
162 * @since 0.6.2
163 */
164typedef struct Iso_Image IsoImage;
165
166/*
167 * A node in the iso tree, i.e. a file that will be written to image.
168 *
169 * It can represent any kind of files. When needed, you can get the type with
170 * iso_node_get_type() and cast it to the appropriate subtype. Useful macros
171 * are provided, see below.
172 *
173 * @since 0.6.2
174 */
175typedef struct Iso_Node IsoNode;
176
177/**
178 * A directory in the iso tree. It is an special type of IsoNode and can be
179 * casted to it in any case.
180 *
181 * @since 0.6.2
182 */
183typedef struct Iso_Dir IsoDir;
184
185/**
186 * A symbolic link in the iso tree. It is an special type of IsoNode and can be
187 * casted to it in any case.
188 *
189 * @since 0.6.2
190 */
191typedef struct Iso_Symlink IsoSymlink;
192
193/**
194 * A regular file in the iso tree. It is an special type of IsoNode and can be
195 * casted to it in any case.
196 *
197 * @since 0.6.2
198 */
199typedef struct Iso_File IsoFile;
200
201/**
202 * An special file in the iso tree. This is used to represent any POSIX file
203 * other that regular files, directories or symlinks, i.e.: socket, block and
204 * character devices, and fifos.
205 * It is an special type of IsoNode and can be casted to it in any case.
206 *
207 * @since 0.6.2
208 */
209typedef struct Iso_Special IsoSpecial;
210
211/**
212 * The type of an IsoNode.
213 *
214 * When an user gets an IsoNode from an image, (s)he can use
215 * iso_node_get_type() to get the current type of the node, and then
216 * cast to the appropriate subtype. For example:
217 *
218 * ...
219 * IsoNode *node;
220 * res = iso_dir_iter_next(iter, &node);
221 * if (res == 1 && iso_node_get_type(node) == LIBISO_DIR) {
222 * IsoDir *dir = (IsoDir *)node;
223 * ...
224 * }
225 *
226 * @since 0.6.2
227 */
235
236/* macros to check node type */
237#define ISO_NODE_IS_DIR(n) (iso_node_get_type(n) == LIBISO_DIR)
238#define ISO_NODE_IS_FILE(n) (iso_node_get_type(n) == LIBISO_FILE)
239#define ISO_NODE_IS_SYMLINK(n) (iso_node_get_type(n) == LIBISO_SYMLINK)
240#define ISO_NODE_IS_SPECIAL(n) (iso_node_get_type(n) == LIBISO_SPECIAL)
241#define ISO_NODE_IS_BOOTCAT(n) (iso_node_get_type(n) == LIBISO_BOOT)
242
243/* macros for safe downcasting */
244#define ISO_DIR(n) ((IsoDir*)(ISO_NODE_IS_DIR(n) ? n : NULL))
245#define ISO_FILE(n) ((IsoFile*)(ISO_NODE_IS_FILE(n) ? n : NULL))
246#define ISO_SYMLINK(n) ((IsoSymlink*)(ISO_NODE_IS_SYMLINK(n) ? n : NULL))
247#define ISO_SPECIAL(n) ((IsoSpecial*)(ISO_NODE_IS_SPECIAL(n) ? n : NULL))
248
249#define ISO_NODE(n) ((IsoNode*)n)
250
251/**
252 * File section in an old image.
253 *
254 * @since 0.6.8
255 */
257{
258 uint32_t block;
259 uint32_t size;
260};
261
262/* If you get here because of a compilation error like
263
264 /usr/include/libisofs/libisofs.h:166: error:
265 expected specifier-qualifier-list before 'uint32_t'
266
267 then see the paragraph above about the definition of uint32_t.
268*/
269
270
271/**
272 * Context for iterate on directory children.
273 * @see iso_dir_get_children()
274 *
275 * @since 0.6.2
276 */
277typedef struct Iso_Dir_Iter IsoDirIter;
278
279/**
280 * It represents an El-Torito boot image.
281 *
282 * @since 0.6.2
283 */
284typedef struct el_torito_boot_image ElToritoBootImage;
285
286/**
287 * An special type of IsoNode that acts as a placeholder for an El-Torito
288 * boot catalog. Once written, it will appear as a regular file.
289 *
290 * @since 0.6.2
291 */
292typedef struct Iso_Boot IsoBoot;
293
294/**
295 * Flag used to hide a file in the RR/ISO or Joliet tree.
296 *
297 * @see iso_node_set_hidden
298 * @since 0.6.2
299 */
301 /** Hide the node in the ECMA-119 / RR tree */
303 /** Hide the node in the Joliet tree, if Joliet extension are enabled */
305 /** Hide the node in the ISO-9660:1999 tree, if that format is enabled */
307
308 /** Hide the node in the HFS+ tree, if that format is enabled.
309 @since 1.2.4
310 */
312
313 /** Hide the node in the FAT tree, if that format is enabled.
314 @since 1.2.4
315 */
317
318 /** With IsoNode and IsoBoot: Write data content even if the node is
319 * not visible in any tree.
320 * With directory nodes : Write data content of IsoNode and IsoBoot
321 * in the directory's tree unless they are
322 * explicitly marked LIBISO_HIDE_ON_RR
323 * without LIBISO_HIDE_BUT_WRITE.
324 * @since 0.6.34
325 */
326 LIBISO_HIDE_BUT_WRITE = 1 << 3
328
329/**
330 * El-Torito bootable image type.
331 *
332 * @since 0.6.2
333 */
339
340/**
341 * Replace mode used when adding a node to a directory.
342 * This controls how libisofs will act when you tried to add to a dir a file
343 * with the same name that an existing file.
344 *
345 * @since 0.6.2
346 */
348 /**
349 * Never replace an existing node, and instead fail with
350 * ISO_NODE_NAME_NOT_UNIQUE.
351 */
353 /**
354 * Always replace the old node with the new.
355 */
357 /**
358 * Replace with the new node if it is the same file type
359 */
361 /**
362 * Replace with the new node if it is the same file type and its ctime
363 * is newer than the old one.
364 */
366 /**
367 * Replace with the new node if its ctime is newer than the old one.
368 */
370 /*
371 * TODO #00006 define more values
372 * -if both are dirs, add contents (and what to do with conflicts?)
373 */
375
376/**
377 * Options for image written.
378 * @see iso_write_opts_new()
379 * @since 0.6.2
380 */
381typedef struct iso_write_opts IsoWriteOpts;
382
383/**
384 * Options for image reading or import.
385 * @see iso_read_opts_new()
386 * @since 0.6.2
387 */
388typedef struct iso_read_opts IsoReadOpts;
389
390/**
391 * Source for image reading.
392 *
393 * @see struct iso_data_source
394 * @since 0.6.2
395 */
397
398/**
399 * Data source used by libisofs for reading an existing image.
400 *
401 * It offers homogeneous read access to arbitrary blocks to different sources
402 * for images, such as .iso files, CD/DVD drives, etc...
403 *
404 * To create a multisession image, libisofs needs a IsoDataSource, that the
405 * user must provide. The function iso_data_source_new_from_file() constructs
406 * an IsoDataSource that uses POSIX I/O functions to access data. You can use
407 * it with regular .iso images, and also with block devices that represent a
408 * drive.
409 *
410 * @since 0.6.2
411 */
413{
414
415 /* reserved for future usage, set to 0 */
417
418 /**
419 * Reference count for the data source. Should be 1 when a new source
420 * is created. Don't access it directly, but with iso_data_source_ref()
421 * and iso_data_source_unref() functions.
422 */
423 unsigned int refcount;
424
425 /**
426 * Opens the given source. You must open() the source before any attempt
427 * to read data from it. The open is the right place for grabbing the
428 * underlying resources.
429 *
430 * @return
431 * 1 if success, < 0 on error (has to be a valid libisofs error code)
432 */
433 int (*open)(IsoDataSource *src);
434
435 /**
436 * Close a given source, freeing all system resources previously grabbed in
437 * open().
438 *
439 * @return
440 * 1 if success, < 0 on error (has to be a valid libisofs error code)
441 */
442 int (*close)(IsoDataSource *src);
443
444 /**
445 * Read an arbitrary block (2048 bytes) of data from the source.
446 *
447 * @param lba
448 * Block to be read.
449 * @param buffer
450 * Buffer where the data will be written. It should have at least
451 * 2048 bytes.
452 * @return
453 * 1 if success,
454 * < 0 if error. This function has to emit a valid libisofs error code.
455 * Predefined (but not mandatory) for this purpose are:
456 * ISO_DATA_SOURCE_SORRY , ISO_DATA_SOURCE_MISHAP,
457 * ISO_DATA_SOURCE_FAILURE , ISO_DATA_SOURCE_FATAL
458 */
459 int (*read_block)(IsoDataSource *src, uint32_t lba, uint8_t *buffer);
460
461 /**
462 * Clean up the source specific data. Never call this directly, it is
463 * automatically called by iso_data_source_unref() when refcount reach
464 * 0.
465 */
467
468 /** Source specific data */
469 void *data;
470};
471
472/**
473 * Return information for image. This is optionally allocated by libisofs,
474 * as a way to inform user about the features of an existing image, such as
475 * extensions present, size, ...
476 *
477 * @see iso_image_import()
478 * @since 0.6.2
479 */
480typedef struct iso_read_image_features IsoReadImageFeatures;
481
482/**
483 * POSIX abstraction for source files.
484 *
485 * @see struct iso_file_source
486 * @since 0.6.2
487 */
489
490/**
491 * Abstract for source filesystems.
492 *
493 * @see struct iso_filesystem
494 * @since 0.6.2
495 */
497
498/**
499 * Interface that defines the operations (methods) available for an
500 * IsoFileSource.
501 *
502 * @see struct IsoFileSource_Iface
503 * @since 0.6.2
504 */
506
507/**
508 * IsoFilesystem implementation to deal with ISO images, and to offer a way to
509 * access specific information of the image, such as several volume attributes,
510 * extensions being used, El-Torito artifacts...
511 *
512 * @since 0.6.2
513 */
515
516/**
517 * See IsoFilesystem->get_id() for info about this.
518 * @since 0.6.2
519 */
520extern unsigned int iso_fs_global_id;
521
522/**
523 * An IsoFilesystem is a handler for a source of files, or a "filesystem".
524 * That is defined as a set of files that are organized in a hierarchical
525 * structure.
526 *
527 * A filesystem allows libisofs to access files from several sources in
528 * an homogeneous way, thus abstracting the underlying operations needed to
529 * access and read file contents. Note that this doesn't need to be tied
530 * to the disc filesystem used in the partition being accessed. For example,
531 * we have an IsoFilesystem implementation to access any mounted filesystem,
532 * using standard POSIX functions. It is also legal, of course, to implement
533 * an IsoFilesystem to deal with a specific filesystem over raw partitions.
534 * That is what we do, for example, to access an ISO Image.
535 *
536 * Each file inside an IsoFilesystem is represented as an IsoFileSource object,
537 * that defines POSIX-like interface for accessing files.
538 *
539 * @since 0.6.2
540 */
542{
543 /**
544 * Type of filesystem.
545 * "file" -> local filesystem
546 * "iso " -> iso image filesystem
547 */
548 char type[4];
549
550 /* reserved for future usage, set to 0 */
552
553 /**
554 * Get the root of a filesystem.
555 *
556 * @return
557 * 1 on success, < 0 on error (has to be a valid libisofs error code)
558 */
560
561 /**
562 * Retrieve a file from its absolute path inside the filesystem.
563 * @param file
564 * Returns a pointer to a IsoFileSource object representing the
565 * file. It has to be disposed by iso_file_source_unref() when
566 * no longer needed.
567 * @return
568 * 1 success, < 0 error (has to be a valid libisofs error code)
569 * Error codes:
570 * ISO_FILE_ACCESS_DENIED
571 * ISO_FILE_BAD_PATH
572 * ISO_FILE_DOESNT_EXIST
573 * ISO_OUT_OF_MEM
574 * ISO_FILE_ERROR
575 * ISO_NULL_POINTER
576 */
577 int (*get_by_path)(IsoFilesystem *fs, const char *path,
578 IsoFileSource **file);
579
580 /**
581 * Get filesystem identifier.
582 *
583 * If the filesystem is able to generate correct values of the st_dev
584 * and st_ino fields for the struct stat of each file, this should
585 * return an unique number, greater than 0.
586 *
587 * To get a identifier for your filesystem implementation you should
588 * use iso_fs_global_id, incrementing it by one each time.
589 *
590 * Otherwise, if you can't ensure values in the struct stat are valid,
591 * this should return 0.
592 */
593 unsigned int (*get_id)(IsoFilesystem *fs);
594
595 /**
596 * Opens the filesystem for several read operations. Calling this function
597 * is not needed at all, each time that the underlying system resource
598 * needs to be accessed, it is opened property.
599 * However, if you plan to execute several operations on the filesystem,
600 * it is a good idea to open it previously, to prevent several open/close
601 * operations to occur.
602 *
603 * @return 1 on success, < 0 on error (has to be a valid libisofs error code)
604 */
605 int (*open)(IsoFilesystem *fs);
606
607 /**
608 * Close the filesystem, thus freeing all system resources. You should
609 * call this function if you have previously open() it.
610 * Note that you can open()/close() a filesystem several times.
611 *
612 * @return 1 on success, < 0 on error (has to be a valid libisofs error code)
613 */
614 int (*close)(IsoFilesystem *fs);
615
616 /**
617 * Free implementation specific data. Should never be called by user.
618 * Use iso_filesystem_unref() instead.
619 */
620 void (*free)(IsoFilesystem *fs);
621
622 /* internal usage, do never access them directly */
623 unsigned int refcount;
624 void *data;
625};
626
627/**
628 * Interface definition for an IsoFileSource. Defines the POSIX-like function
629 * to access files and abstract underlying source.
630 *
631 * @since 0.6.2
632 */
634{
635 /**
636 * Tells the version of the interface:
637 * Version 0 provides functions up to (*lseek)().
638 * @since 0.6.2
639 * Version 1 additionally provides function *(get_aa_string)().
640 * @since 0.6.14
641 * Version 2 additionally provides function *(clone_src)().
642 * @since 1.0.2
643 */
645
646 /**
647 * Get the absolute path in the filesystem this file source belongs to.
648 *
649 * @return
650 * the path of the FileSource inside the filesystem, it should be
651 * freed when no more needed.
652 */
653 char* (*get_path)(IsoFileSource *src);
654
655 /**
656 * Get the name of the file, with the dir component of the path.
657 *
658 * @return
659 * the name of the file, it should be freed when no more needed.
660 */
661 char* (*get_name)(IsoFileSource *src);
662
663 /**
664 * Get information about the file. It is equivalent to lstat(2).
665 *
666 * @return
667 * 1 success, < 0 error (has to be a valid libisofs error code)
668 * Error codes:
669 * ISO_FILE_ACCESS_DENIED
670 * ISO_FILE_BAD_PATH
671 * ISO_FILE_DOESNT_EXIST
672 * ISO_OUT_OF_MEM
673 * ISO_FILE_ERROR
674 * ISO_NULL_POINTER
675 */
676 int (*lstat)(IsoFileSource *src, struct stat *info);
677
678 /**
679 * Get information about the file. If the file is a symlink, the info
680 * returned refers to the destination. It is equivalent to stat(2).
681 *
682 * @return
683 * 1 success, < 0 error
684 * Error codes:
685 * ISO_FILE_ACCESS_DENIED
686 * ISO_FILE_BAD_PATH
687 * ISO_FILE_DOESNT_EXIST
688 * ISO_OUT_OF_MEM
689 * ISO_FILE_ERROR
690 * ISO_NULL_POINTER
691 */
692 int (*stat)(IsoFileSource *src, struct stat *info);
693
694 /**
695 * Check if the process has access to read file contents. Note that this
696 * is not necessarily related with (l)stat functions. For example, in a
697 * filesystem implementation to deal with an ISO image, if the user has
698 * read access to the image it will be able to read all files inside it,
699 * despite of the particular permission of each file in the RR tree, that
700 * are what the above functions return.
701 *
702 * @return
703 * 1 if process has read access, < 0 on error (has to be a valid
704 * libisofs error code)
705 * Error codes:
706 * ISO_FILE_ACCESS_DENIED
707 * ISO_FILE_BAD_PATH
708 * ISO_FILE_DOESNT_EXIST
709 * ISO_OUT_OF_MEM
710 * ISO_FILE_ERROR
711 * ISO_NULL_POINTER
712 */
713 int (*access)(IsoFileSource *src);
714
715 /**
716 * Opens the source.
717 * @return 1 on success, < 0 on error (has to be a valid libisofs error code)
718 * Error codes:
719 * ISO_FILE_ALREADY_OPENED
720 * ISO_FILE_ACCESS_DENIED
721 * ISO_FILE_BAD_PATH
722 * ISO_FILE_DOESNT_EXIST
723 * ISO_OUT_OF_MEM
724 * ISO_FILE_ERROR
725 * ISO_NULL_POINTER
726 */
727 int (*open)(IsoFileSource *src);
728
729 /**
730 * Close a previously opened file
731 * @return 1 on success, < 0 on error
732 * Error codes:
733 * ISO_FILE_ERROR
734 * ISO_NULL_POINTER
735 * ISO_FILE_NOT_OPENED
736 */
737 int (*close)(IsoFileSource *src);
738
739 /**
740 * Attempts to read up to count bytes from the given source into
741 * the buffer starting at buf.
742 *
743 * The file src must be open() before calling this, and close() when no
744 * more needed. Not valid for dirs. On symlinks it reads the destination
745 * file.
746 *
747 * @return
748 * number of bytes read, 0 if EOF, < 0 on error (has to be a valid
749 * libisofs error code)
750 * Error codes:
751 * ISO_FILE_ERROR
752 * ISO_NULL_POINTER
753 * ISO_FILE_NOT_OPENED
754 * ISO_WRONG_ARG_VALUE -> if count == 0
755 * ISO_FILE_IS_DIR
756 * ISO_OUT_OF_MEM
757 * ISO_INTERRUPTED
758 */
759 int (*read)(IsoFileSource *src, void *buf, size_t count);
760
761 /**
762 * Read a directory.
763 *
764 * Each call to this function will return a new children, until we reach
765 * the end of file (i.e, no more children), in that case it returns 0.
766 *
767 * The dir must be open() before calling this, and close() when no more
768 * needed. Only valid for dirs.
769 *
770 * Note that "." and ".." children MUST NOT BE returned.
771 *
772 * @param child
773 * pointer to be filled with the given child. Undefined on error or OEF
774 * @return
775 * 1 on success, 0 if EOF (no more children), < 0 on error (has to be
776 * a valid libisofs error code)
777 * Error codes:
778 * ISO_FILE_ERROR
779 * ISO_NULL_POINTER
780 * ISO_FILE_NOT_OPENED
781 * ISO_FILE_IS_NOT_DIR
782 * ISO_OUT_OF_MEM
783 */
784 int (*readdir)(IsoFileSource *src, IsoFileSource **child);
785
786 /**
787 * Read the destination of a symlink. You don't need to open the file
788 * to call this.
789 *
790 * @param buf
791 * allocated buffer of at least bufsiz bytes.
792 * The dest. will be copied there, and it will be NULL-terminated
793 * @param bufsiz
794 * characters to be copied. Destination link will be truncated if
795 * it is larger than given size. This include the 0x0 character.
796 * @return
797 * 1 on success, < 0 on error (has to be a valid libisofs error code)
798 * Error codes:
799 * ISO_FILE_ERROR
800 * ISO_NULL_POINTER
801 * ISO_WRONG_ARG_VALUE -> if bufsiz <= 0
802 * ISO_FILE_IS_NOT_SYMLINK
803 * ISO_OUT_OF_MEM
804 * ISO_FILE_BAD_PATH
805 * ISO_FILE_DOESNT_EXIST
806 *
807 */
808 int (*readlink)(IsoFileSource *src, char *buf, size_t bufsiz);
809
810 /**
811 * Get the filesystem for this source. No extra ref is added, so you
812 * must not unref the IsoFilesystem.
813 *
814 * @return
815 * The filesystem, NULL on error
816 */
817 IsoFilesystem* (*get_filesystem)(IsoFileSource *src);
818
819 /**
820 * Free implementation specific data. Should never be called by user.
821 * Use iso_file_source_unref() instead.
822 */
823 void (*free)(IsoFileSource *src);
824
825 /**
826 * Repositions the offset of the IsoFileSource (must be opened) to the
827 * given offset according to the value of flag.
828 *
829 * @param offset
830 * in bytes
831 * @param flag
832 * 0 The offset is set to offset bytes (SEEK_SET)
833 * 1 The offset is set to its current location plus offset bytes
834 * (SEEK_CUR)
835 * 2 The offset is set to the size of the file plus offset bytes
836 * (SEEK_END).
837 * @return
838 * Absolute offset position of the file, or < 0 on error. Cast the
839 * returning value to int to get a valid libisofs error.
840 *
841 * @since 0.6.4
842 */
843 off_t (*lseek)(IsoFileSource *src, off_t offset, int flag);
844
845 /* Add-ons of .version 1 begin here */
846
847 /**
848 * Valid only if .version is > 0. See above.
849 * Get the AAIP string with encoded ACL and xattr.
850 * (Not to be confused with ECMA-119 Extended Attributes).
851 *
852 * bit1 and bit2 of flag should be implemented so that freshly fetched
853 * info does not include the undesired ACL or xattr. Nevertheless if the
854 * aa_string is cached, then it is permissible that ACL and xattr are still
855 * delivered.
856 *
857 * @param flag Bitfield for control purposes
858 * bit0= Transfer ownership of AAIP string data.
859 * src will free the eventual cached data and might
860 * not be able to produce it again.
861 * bit1= No need to get ACL (no guarantee of exclusion)
862 * bit2= No need to get xattr (no guarantee of exclusion)
863 * @param aa_string Returns a pointer to the AAIP string data. If no AAIP
864 * string is available, *aa_string becomes NULL.
865 * (See doc/susp_aaip_*_*.txt for the meaning of AAIP and
866 * libisofs/aaip_0_2.h for encoding and decoding.)
867 * The caller is responsible for finally calling free()
868 * on non-NULL results.
869 * @return 1 means success (*aa_string == NULL is possible)
870 * 2 means success, but it is possible that attributes
871 * exist in non-user namespaces which could not be
872 * explored due to lack of permission.
873 * @since 1.5.0
874 * <0 means failure and must b a valid libisofs error code
875 * (e.g. ISO_FILE_ERROR if no better one can be found).
876 * @since 0.6.14
877 */
879 unsigned char **aa_string, int flag);
880
881 /**
882 * Produce a copy of a source. It must be possible to operate both source
883 * objects concurrently.
884 *
885 * @param old_src
886 * The existing source object to be copied
887 * @param new_stream
888 * Will return a pointer to the copy
889 * @param flag
890 * Bitfield for control purposes. Submit 0 for now.
891 * The function shall return ISO_STREAM_NO_CLONE on unknown flag bits.
892 *
893 * @since 1.0.2
894 * Present if .version is 2 or higher.
895 */
896 int (*clone_src)(IsoFileSource *old_src, IsoFileSource **new_src,
897 int flag);
898
899 /*
900 * TODO #00004 Add a get_mime_type() function.
901 * This can be useful for GUI apps, to choose the icon of the file
902 */
903};
904
905#ifndef __cplusplus
906#ifndef Libisofs_h_as_cpluspluS
907
908/**
909 * An IsoFile Source is a POSIX abstraction of a file.
910 *
911 * @since 0.6.2
912 */
914{
915 const IsoFileSourceIface *class;
917 void *data;
918};
919
920#endif /* ! Libisofs_h_as_cpluspluS */
921#endif /* ! __cplusplus */
922
923
924/* A class of IsoStream is implemented by a class description
925 * IsoStreamIface = struct IsoStream_Iface
926 * and a structure of data storage for each instance of IsoStream.
927 * This structure shall be known to the functions of the IsoStreamIface.
928 * To create a custom IsoStream class:
929 * - Define the structure of the custom instance data.
930 * - Implement the methods which are described by the definition of
931 * struct IsoStream_Iface (see below),
932 * - Create a static instance of IsoStreamIface which lists the methods as
933 * C function pointers. (Example in libisofs/stream.c : fsrc_stream_class)
934 * To create an instance of that class:
935 * - Allocate sizeof(IsoStream) bytes of memory and initialize it as
936 * struct iso_stream :
937 * - Point to the custom IsoStreamIface by member .class .
938 * - Set member .refcount to 1.
939 * - Let member .data point to the custom instance data.
940 *
941 * Regrettably the choice of the structure member name "class" makes it
942 * impossible to implement this generic interface in C++ language directly.
943 * If C++ is absolutely necessary then you will have to make own copies
944 * of the public API structures. Use other names but take care to maintain
945 * the same memory layout.
946 */
947
948/**
949 * Representation of file contents. It is an stream of bytes, functionally
950 * like a pipe.
951 *
952 * @since 0.6.4
953 */
954typedef struct iso_stream IsoStream;
955
956/**
957 * Interface that defines the operations (methods) available for an
958 * IsoStream.
959 *
960 * @see struct IsoStream_Iface
961 * @since 0.6.4
962 */
964
965/**
966 * Serial number to be used when you can't get a valid id for a Stream by other
967 * means. If you use this, both fs_id and dev_id should be set to 0.
968 * This must be incremented each time you get a reference to it.
969 *
970 * @see IsoStreamIface->get_id()
971 * @since 0.6.4
972 */
973extern ino_t serial_id;
974
975/**
976 * Interface definition for IsoStream methods. It is public to allow
977 * implementation of own stream types.
978 * The methods defined here typically make use of stream.data which points
979 * to the individual state data of stream instances.
980 *
981 * @since 0.6.4
982 */
983
985{
986 /*
987 * Current version of the interface.
988 * Version 0 (since 0.6.4)
989 * deprecated but still valid.
990 * Version 1 (since 0.6.8)
991 * update_size() added.
992 * Version 2 (since 0.6.18)
993 * get_input_stream() added.
994 * A filter stream must have version 2 at least.
995 * Version 3 (since 0.6.20)
996 * cmp_ino() added.
997 * A filter stream should have version 3 at least.
998 * Version 4 (since 1.0.2)
999 * clone_stream() added.
1000 */
1002
1003 /**
1004 * Type of Stream.
1005 * "fsrc" -> Read from file source
1006 * "cout" -> Cut out interval from disk file
1007 * "mem " -> Read from memory
1008 * "boot" -> Boot catalog
1009 * "extf" -> External filter program
1010 * "ziso" -> zisofs compression
1011 * "osiz" -> zisofs uncompression
1012 * "gzip" -> gzip compression
1013 * "pizg" -> gzip uncompression (gunzip)
1014 * "user" -> User supplied stream
1015 */
1016 char type[4];
1017
1018 /**
1019 * Opens the stream.
1020 *
1021 * @return
1022 * 1 on success, 2 file greater than expected, 3 file smaller than
1023 * expected, < 0 on error (has to be a valid libisofs error code)
1024 */
1025 int (*open)(IsoStream *stream);
1026
1027 /**
1028 * Close the Stream.
1029 * @return
1030 * 1 on success, < 0 on error (has to be a valid libisofs error code)
1031 */
1032 int (*close)(IsoStream *stream);
1033
1034 /**
1035 * Get the size (in bytes) of the stream. This function should always
1036 * return the same size, even if the underlying source size changes,
1037 * unless you call update_size() method.
1038 */
1039 off_t (*get_size)(IsoStream *stream);
1040
1041 /**
1042 * Attempt to read up to count bytes from the given stream into
1043 * the buffer starting at buf. The implementation has to make sure that
1044 * either the full desired count of bytes is delivered or that the
1045 * next call to this function will return EOF or error.
1046 * I.e. only the last read block may be shorter than parameter count.
1047 *
1048 * The stream must be open() before calling this, and close() when no
1049 * more needed.
1050 *
1051 * @return
1052 * number of bytes read, 0 if EOF, < 0 on error (has to be a valid
1053 * libisofs error code)
1054 */
1055 int (*read)(IsoStream *stream, void *buf, size_t count);
1056
1057 /**
1058 * Tell whether this IsoStream can be read several times, with the same
1059 * results. For example, a regular file is repeatable, you can read it
1060 * as many times as you want. However, a pipe is not.
1061 *
1062 * @return
1063 * 1 if stream is repeatable, 0 if not,
1064 * < 0 on error (has to be a valid libisofs error code)
1065 */
1066 int (*is_repeatable)(IsoStream *stream);
1067
1068 /**
1069 * Get an unique identifier for the IsoStream.
1070 */
1071 void (*get_id)(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id,
1072 ino_t *ino_id);
1073
1074 /**
1075 * Free implementation specific data. Should never be called by user.
1076 * Use iso_stream_unref() instead.
1077 */
1078 void (*free)(IsoStream *stream);
1079
1080 /**
1081 * Update the size of the IsoStream with the current size of the underlying
1082 * source, if the source is prone to size changes. After calling this,
1083 * get_size() shall eventually return the new size.
1084 * This will never be called after iso_image_create_burn_source() was
1085 * called and before the image was completely written.
1086 * (The API call to update the size of all files in the image is
1087 * iso_image_update_sizes()).
1088 *
1089 * @return
1090 * 1 if ok, < 0 on error (has to be a valid libisofs error code)
1091 *
1092 * @since 0.6.8
1093 * Present if .version is 1 or higher.
1094 */
1095 int (*update_size)(IsoStream *stream);
1096
1097 /**
1098 * Retrieve the eventual input stream of a filter stream.
1099 *
1100 * @param stream
1101 * The eventual filter stream to be inquired.
1102 * @param flag
1103 * Bitfield for control purposes. 0 means normal behavior.
1104 * @return
1105 * The input stream, if one exists. Elsewise NULL.
1106 * No extra reference to the stream shall be taken by this call.
1107 *
1108 * @since 0.6.18
1109 * Present if .version is 2 or higher.
1110 */
1111 IsoStream *(*get_input_stream)(IsoStream *stream, int flag);
1112
1113 /**
1114 * Compare two streams whether they are based on the same input and will
1115 * produce the same output. If in any doubt, then this comparison should
1116 * indicate no match. A match might allow hardlinking of IsoFile objects.
1117 *
1118 * A pointer value of NULL is permissible. In this case, function
1119 * iso_stream_cmp_ino() will decide on its own.
1120 *
1121 * If not NULL, this function .cmp_ino() will be called by
1122 * iso_stream_cmp_ino() if both compared streams point to it, and if not
1123 * flag bit0 of iso_stream_cmp_ino() prevents it.
1124 * So a .cmp_ino() function must be able to compare any pair of streams
1125 * which name it as their .cmp_ino(). A fallback to iso_stream_cmp_ino(,,1)
1126 * would endanger transitivity of iso_stream_cmp_ino(,,0).
1127 *
1128 * With filter streams, the decision whether the underlying chains of
1129 * streams match, should be delegated to
1130 * iso_stream_cmp_ino(iso_stream_get_input_stream(s1, 0),
1131 * iso_stream_get_input_stream(s2, 0), 0);
1132 *
1133 * The stream.cmp_ino() function has to establish an equivalence and order
1134 * relation:
1135 * cmp_ino(A,A) == 0
1136 * cmp_ino(A,B) == -cmp_ino(B,A)
1137 * if cmp_ino(A,B) == 0 && cmp_ino(B,C) == 0 then cmp_ino(A,C) == 0
1138 * Most tricky is the demand for transitivity:
1139 * if cmp_ino(A,B) < 0 && cmp_ino(B,C) < 0 then cmp_ino(A,C) < 0
1140 *
1141 * @param s1
1142 * The first stream to compare. Expect foreign stream types.
1143 * @param s2
1144 * The second stream to compare. Expect foreign stream types.
1145 * @return
1146 * -1 if s1 is smaller s2 , 0 if s1 matches s2 , 1 if s1 is larger s2
1147 *
1148 * @since 0.6.20
1149 * Present if .version is 3 or higher.
1150 */
1151 int (*cmp_ino)(IsoStream *s1, IsoStream *s2);
1152
1153 /**
1154 * Produce a copy of a stream. It must be possible to operate both stream
1155 * objects concurrently.
1156 *
1157 * @param old_stream
1158 * The existing stream object to be copied
1159 * @param new_stream
1160 * Will return a pointer to the copy
1161 * @param flag
1162 * Bitfield for control purposes. 0 means normal behavior.
1163 * The function shall return ISO_STREAM_NO_CLONE on unknown flag bits.
1164 * @return
1165 * 1 in case of success, or an error code < 0
1166 *
1167 * @since 1.0.2
1168 * Present if .version is 4 or higher.
1169 */
1170 int (*clone_stream)(IsoStream *old_stream, IsoStream **new_stream,
1171 int flag);
1172
1173};
1174
1175#ifndef __cplusplus
1176#ifndef Libisofs_h_as_cpluspluS
1177
1178/**
1179 * Representation of file contents as a stream of bytes.
1180 *
1181 * @since 0.6.4
1182 */
1184{
1187 void *data;
1188};
1189
1190#endif /* ! Libisofs_h_as_cpluspluS */
1191#endif /* ! __cplusplus */
1192
1193
1194/**
1195 * Initialize libisofs. Before any usage of the library you must either call
1196 * this function or iso_init_with_flag().
1197 * Only exception from this rule: iso_lib_version(), iso_lib_is_compatible().
1198 * @return 1 on success, < 0 on error
1199 *
1200 * @since 0.6.2
1201 */
1203
1204/**
1205 * Initialize libisofs. Before any usage of the library you must either call
1206 * this function or iso_init() which is equivalent to iso_init_with_flag(0).
1207 * Only exception from this rule: iso_lib_version(), iso_lib_is_compatible().
1208 * @param flag
1209 * Bitfield for control purposes
1210 * bit0= do not set up locale by LC_* environment variables
1211 * @return 1 on success, < 0 on error
1212 *
1213 * @since 0.6.18
1214 */
1216
1217/**
1218 * Finalize libisofs.
1219 *
1220 * @since 0.6.2
1221 */
1223
1224/**
1225 * Override the reply of libc function nl_langinfo(CODESET) which may or may
1226 * not give the name of the character set which is in effect for your
1227 * environment. So this call can compensate for inconsistent terminal setups.
1228 * Another use case is to choose UTF-8 as intermediate character set for a
1229 * conversion from an exotic input character set to an exotic output set.
1230 *
1231 * @param name
1232 * Name of the character set to be assumed as "local" one.
1233 * @param flag
1234 * Unused yet. Submit 0.
1235 * @return
1236 * 1 indicates success, <=0 failure
1237 *
1238 * @since 0.6.12
1239 */
1240int iso_set_local_charset(char *name, int flag);
1241
1242/**
1243 * Obtain the local charset as currently assumed by libisofs.
1244 * The result points to internal memory. It is volatile and must not be
1245 * altered.
1246 *
1247 * @param flag
1248 * Unused yet. Submit 0.
1249 *
1250 * @since 0.6.12
1251 */
1253
1254/**
1255 * Inquire and maybe define the time which is considered to be "now" and
1256 * used for timestamps of freshly created ISO nodes and as default of
1257 * image timestamps.
1258 * If ever, this should normally be enabled and defined before iso_image_new().
1259 * If it is disabled, time(NULL) is considered to be "now".
1260 *
1261 * @param now
1262 * Returns the "now" value and maybe submits it as definition.
1263 * @param flag
1264 * Bitfield for control purposes
1265 * bit0= *now contains the time to be set as nowtime override.
1266 Enable the override if not bit1 is set, too.
1267 * bit1= Disable the nowtime override
1268 * @return 1= *now is not overridden , 2= *now is overridden
1269 *
1270 * @since 1.5.2
1271 */
1272int iso_nowtime(time_t *now, int flag);
1273
1274
1275/**
1276 * Create a new image, empty.
1277 *
1278 * The image will be owned by you and should be unref() when no more needed.
1279 *
1280 * @param name
1281 * Name of the image. This will be used as volset_id and volume_id.
1282 * @param image
1283 * Location where the image pointer will be stored.
1284 * @return
1285 * 1 success, < 0 error
1286 *
1287 * @since 0.6.2
1288 */
1289int iso_image_new(const char *name, IsoImage **image);
1290
1291
1292/**
1293 * Control whether ACL and xattr will be imported from external filesystems
1294 * (typically the local POSIX filesystem) when new nodes get inserted. If
1295 * enabled by iso_write_opts_set_aaip() they will later be written into the
1296 * image as AAIP extension fields.
1297 *
1298 * A change of this setting does neither affect existing IsoNode objects
1299 * nor the way how ACL and xattr are handled when loading an ISO image.
1300 * The latter is controlled by iso_read_opts_set_no_aaip().
1301 *
1302 * @param image
1303 * The image of which the behavior is to be controlled
1304 * @param what
1305 * A bit field which sets the behavior:
1306 * bit0= ignore ACLs if the external file object bears some
1307 * bit1= ignore xattr if the external file object bears some
1308 * bit3= if not bit1: import all xattr namespaces, not only "user."
1309 * @since 1.5.0
1310 * all other bits are reserved
1311 *
1312 * @since 0.6.14
1313 */
1315
1316
1317/**
1318 * Obtain the current setting of iso_image_set_ignore_aclea().
1319 *
1320 * @param image
1321 * The image to be inquired
1322 * @return
1323 * The currently set value.
1324 *
1325 * @since 1.5.0
1326 */
1328
1329
1330/**
1331 * Creates an IsoWriteOpts for writing an image. You should set the options
1332 * desired with the correspondent setters.
1333 *
1334 * Options by default are determined by the selected profile. Fifo size is set
1335 * by default to 2 MB.
1336 *
1337 * @param opts
1338 * Pointer to the location where the newly created IsoWriteOpts will be
1339 * stored. You should free it with iso_write_opts_free() when no more
1340 * needed.
1341 * @param profile
1342 * Default profile for image creation. For now the following values are
1343 * defined:
1344 * ---> 0 [BASIC]
1345 * No extensions are enabled, and ISO level is set to 1. Only suitable
1346 * for usage for very old and limited systems (like MS-DOS), or by a
1347 * start point from which to set your custom options.
1348 * ---> 1 [BACKUP]
1349 * POSIX compatibility for backup. Simple settings, ISO level is set to
1350 * 3 and RR extensions are enabled. Useful for backup purposes.
1351 * Note that ACL and xattr are not enabled by default.
1352 * If you enable them, expect them not to show up in the mounted image.
1353 * They will have to be retrieved by libisofs applications like xorriso.
1354 * ---> 2 [DISTRIBUTION]
1355 * Setting for information distribution. Both RR and Joliet are enabled
1356 * to maximize compatibility with most systems. Permissions are set to
1357 * default values, and timestamps to the time of recording.
1358 * @return
1359 * 1 success, < 0 error
1360 *
1361 * @since 0.6.2
1362 */
1363int iso_write_opts_new(IsoWriteOpts **opts, int profile);
1364
1365/**
1366 * Free an IsoWriteOpts previously allocated with iso_write_opts_new().
1367 *
1368 * @since 0.6.2
1369 */
1371
1372/**
1373 * Announce that only the image size is desired, that the struct burn_source
1374 * which is set to consume the image output stream will stay inactive,
1375 * and that the write thread will be cancelled anyway by the .cancel() method
1376 * of the struct burn_source.
1377 * This avoids to create a write thread which would begin production of the
1378 * image stream and would generate a MISHAP event when burn_source.cancel()
1379 * gets into effect.
1380 *
1381 * @param opts
1382 * The option set to be manipulated.
1383 * @param will_cancel
1384 * 0= normal image generation
1385 * 1= prepare for being canceled before image stream output is completed
1386 * @return
1387 * 1 success, < 0 error
1388 *
1389 * @since 0.6.40
1390 */
1392
1393/**
1394 * Set the ISO-9960 level to write at.
1395 *
1396 * @param opts
1397 * The option set to be manipulated.
1398 * @param level
1399 * -> 1 for higher compatibility with old systems. With this level
1400 * filenames are restricted to 8.3 characters.
1401 * -> 2 to allow up to 31 filename characters.
1402 * -> 3 to allow files greater than 4GB
1403 * @return
1404 * 1 success, < 0 error
1405 *
1406 * @since 0.6.2
1407 */
1409
1410/**
1411 * Whether to use or not Rock Ridge extensions.
1412 *
1413 * This are standard extensions to ECMA-119, intended to add POSIX filesystem
1414 * features to ECMA-119 images. Thus, usage of this flag is highly recommended
1415 * for images used on GNU/Linux systems. With the usage of RR extension, the
1416 * resulting image will have long filenames (up to 255 characters), deeper
1417 * directory structure, POSIX permissions and owner info on files and
1418 * directories, support for symbolic links or special files... All that
1419 * attributes can be modified/set with the appropriate function.
1420 *
1421 * @param opts
1422 * The option set to be manipulated.
1423 * @param enable
1424 * 1 to enable RR extension, 0 to not add them
1425 * @return
1426 * 1 success, < 0 error
1427 *
1428 * @since 0.6.2
1429 */
1431
1432/**
1433 * Whether to add the non-standard Joliet extension to the image.
1434 *
1435 * This extensions are heavily used in Microsoft Windows systems, so if you
1436 * plan to use your disc on such a system you should add this extension.
1437 * Usage of Joliet supplies longer filesystem length (up to 64 unicode
1438 * characters), and deeper directory structure.
1439 *
1440 * @param opts
1441 * The option set to be manipulated.
1442 * @param enable
1443 * 1 to enable Joliet extension, 0 to not add them
1444 * @return
1445 * 1 success, < 0 error
1446 *
1447 * @since 0.6.2
1448 */
1450
1451/**
1452 * Whether to add a HFS+ filesystem to the image which points to the same
1453 * file content as the other directory trees.
1454 * It will get marked by an Apple Partition Map in the System Area of the ISO
1455 * image. This may collide with data submitted by
1456 * iso_write_opts_set_system_area()
1457 * and with settings made by
1458 * el_torito_set_isolinux_options()
1459 * The first 8 bytes of the System Area get overwritten by
1460 * {0x45, 0x52, 0x08 0x00, 0xeb, 0x02, 0xff, 0xff}
1461 * which can be executed as x86 machine code without negative effects.
1462 * So if an MBR gets combined with this feature, then its first 8 bytes
1463 * should contain no essential commands.
1464 * The next blocks of 2 KiB in the System Area will be occupied by APM entries.
1465 * The first one covers the part of the ISO image before the HFS+ filesystem
1466 * metadata. The second one marks the range from HFS+ metadata to the end
1467 * of file content data. If more ISO image data follow, then a third partition
1468 * entry gets produced. Other features of libisofs might cause the need for
1469 * more APM entries.
1470 *
1471 * @param opts
1472 * The option set to be manipulated.
1473 * @param enable
1474 * 1 to enable HFS+ extension, 0 to not add HFS+ metadata and APM
1475 * @return
1476 * 1 success, < 0 error
1477 *
1478 * @since 1.2.4
1479 */
1481
1482/**
1483 * >>> Production of FAT32 is not implemented yet.
1484 * >>> This call exists only as preparation for implementation.
1485 *
1486 * Whether to add a FAT32 filesystem to the image which points to the same
1487 * file content as the other directory trees.
1488 *
1489 * >>> FAT32 is planned to get implemented in co-existence with HFS+
1490 * >>> Describe impact on MBR
1491 *
1492 * @param opts
1493 * The option set to be manipulated.
1494 * @param enable
1495 * 1 to enable FAT32 extension, 0 to not add FAT metadata
1496 * @return
1497 * 1 success, < 0 error
1498 *
1499 * @since 1.2.4
1500 */
1502
1503/**
1504 * Supply a serial number for the HFS+ extension of the emerging image.
1505 *
1506 * @param opts
1507 * The option set to be manipulated.
1508 * @param serial_number
1509 * 8 bytes which should be unique to the image.
1510 * If all bytes are 0, then the serial number will be generated as
1511 * random number by libisofs. This is the default setting.
1512 * @return
1513 * 1 success, < 0 error
1514 *
1515 * @since 1.2.4
1516 */
1518 uint8_t serial_number[8]);
1519
1520/**
1521 * Set the block size for Apple Partition Map and for HFS+.
1522 *
1523 * @param opts
1524 * The option set to be manipulated.
1525 * @param hfsp_block_size
1526 * The allocation block size to be used by the HFS+ filesystem.
1527 * 0, 512, or 2048
1528 * @param apm_block_size
1529 * The block size to be used for and within the Apple Partition Map.
1530 * 0, 512, or 2048.
1531 * Size 512 is not compatible with options which produce GPT.
1532 * @return
1533 * 1 success, < 0 error
1534 *
1535 * @since 1.2.4
1536 */
1538 int hfsp_block_size, int apm_block_size);
1539
1540
1541/**
1542 * Whether to use newer ISO-9660:1999 version.
1543 *
1544 * This is the second version of ISO-9660. It allows longer filenames and has
1545 * less restrictions than old ISO-9660. However, nobody is using it so there
1546 * are no much reasons to enable this.
1547 *
1548 * @since 0.6.2
1549 */
1551
1552/**
1553 * Control generation of non-unique inode numbers for the emerging image.
1554 * Inode numbers get written as "file serial number" with PX entries as of
1555 * RRIP-1.12. They may mark families of hardlinks.
1556 * RRIP-1.10 prescribes a PX entry without file serial number.If not overridden
1557 * by iso_write_opts_set_rrip_1_10_px_ino() there will be no file serial number
1558 * written into RRIP-1.10 images.
1559 *
1560 * Inode number generation does not affect IsoNode objects which imported their
1561 * inode numbers from the old ISO image (see iso_read_opts_set_new_inos())
1562 * and which have not been altered since import. It rather applies to IsoNode
1563 * objects which were newly added to the image, or to IsoNode which brought no
1564 * inode number from the old image, or to IsoNode where certain properties
1565 * have been altered since image import.
1566 *
1567 * If two IsoNode are found with same imported inode number but differing
1568 * properties, then one of them will get assigned a new unique inode number.
1569 * I.e. the hardlink relation between both IsoNode objects ends.
1570 *
1571 * @param opts
1572 * The option set to be manipulated.
1573 * @param enable
1574 * 1 = Collect IsoNode objects which have identical data sources and
1575 * properties.
1576 * 0 = Generate unique inode numbers for all IsoNode objects which do not
1577 * have a valid inode number from an imported ISO image.
1578 * All other values are reserved.
1579 *
1580 * @since 0.6.20
1581 */
1583
1584/**
1585 * Control writing of AAIP information for ACL and xattr.
1586 * For importing ACL and xattr when inserting nodes from external filesystems
1587 * (e.g. the local POSIX filesystem) see iso_image_set_ignore_aclea().
1588 * For loading of this information from images see iso_read_opts_set_no_aaip().
1589 *
1590 * @param opts
1591 * The option set to be manipulated.
1592 * @param enable
1593 * 1 = write AAIP information from nodes into the image
1594 * 0 = do not write AAIP information into the image
1595 * All other values are reserved.
1596 *
1597 * @since 0.6.14
1598 */
1600
1601/**
1602 * Use this only if you need to reproduce a suboptimal behavior of older
1603 * versions of libisofs. They used address 0 for links and device files,
1604 * and the address of the Volume Descriptor Set Terminator for empty data
1605 * files.
1606 * New versions let symbolic links, device files, and empty data files point
1607 * to a dedicated block of zero-bytes after the end of the directory trees.
1608 * (Single-pass reader libarchive needs to see all directory info before
1609 * processing any data files.)
1610 *
1611 * @param opts
1612 * The option set to be manipulated.
1613 * @param enable
1614 * 1 = use the suboptimal block addresses in the range of 0 to 115.
1615 * 0 = use the address of a block after the directory tree. (Default)
1616 *
1617 * @since 1.0.2
1618 */
1620
1621/**
1622 * Caution: This option breaks any assumptions about names that
1623 * are supported by ECMA-119 specifications.
1624 * Try to omit any translation which would make a file name compliant to the
1625 * ECMA-119 rules. This includes and exceeds omit_version_numbers,
1626 * max_37_char_filenames, no_force_dots bit0, allow_full_ascii. Further it
1627 * prevents the conversion from local character set to ASCII.
1628 * The maximum name length is given by this call. If a filename exceeds
1629 * this length or cannot be recorded untranslated for other reasons, then
1630 * image production is aborted with ISO_NAME_NEEDS_TRANSL.
1631 * Currently the length limit is 96 characters, because an ECMA-119 directory
1632 * record may at most have 254 bytes and up to 158 other bytes must fit into
1633 * the record. Probably 96 more bytes can be made free for the name in future.
1634 * @param opts
1635 * The option set to be manipulated.
1636 * @param len
1637 * 0 = disable this feature and perform name translation according to
1638 * other settings.
1639 * >0 = Omit any translation. Eventually abort image production
1640 * if a name is longer than the given value.
1641 * -1 = Like >0. Allow maximum possible length (currently 96)
1642 * @return >=0 success, <0 failure
1643 * In case of >=0 the return value tells the effectively set len.
1644 * E.g. 96 after using len == -1.
1645 * @since 1.0.0
1646 */
1648
1649/**
1650 * Convert directory names for ECMA-119 similar to other file names, but do
1651 * not force a dot or add a version number.
1652 * This violates ECMA-119 by allowing one "." and especially ISO level 1
1653 * by allowing DOS style 8.3 names rather than only 8 characters.
1654 * (mkisofs and its clones seem to do this violation.)
1655 * @param opts
1656 * The option set to be manipulated.
1657 * @param allow
1658 * 1= allow dots , 0= disallow dots and convert them
1659 * @return
1660 * 1 success, < 0 error
1661 * @since 1.0.0
1662 */
1664
1665/**
1666 * Omit the version number (";1") at the end of the ISO-9660 identifiers.
1667 * This breaks ECMA-119 specification, but version numbers are usually not
1668 * used, so it should work on most systems. Use with caution.
1669 * @param opts
1670 * The option set to be manipulated.
1671 * @param omit
1672 * bit0= omit version number with ECMA-119 and Joliet
1673 * bit1= omit version number with Joliet alone (@since 0.6.30)
1674 * @since 0.6.2
1675 */
1677
1678/**
1679 * Allow ISO-9660 directory hierarchy to be deeper than 8 levels.
1680 * This breaks ECMA-119 specification. Use with caution.
1681 *
1682 * @since 0.6.2
1683 */
1685
1686/**
1687 * This call describes the directory where to store Rock Ridge relocated
1688 * directories.
1689 * If not iso_write_opts_set_allow_deep_paths(,1) is in effect, then it may
1690 * become necessary to relocate directories so that no ECMA-119 file path
1691 * has more than 8 components. These directories are grafted into either
1692 * the root directory of the ISO image or into a dedicated relocation
1693 * directory.
1694 * For Rock Ridge, the relocated directories are linked forth and back to
1695 * placeholders at their original positions in path level 8. Directories
1696 * marked by Rock Ridge entry RE are to be considered artefacts of relocation
1697 * and shall not be read into a Rock Ridge tree. Instead they are to be read
1698 * via their placeholders and their links.
1699 * For plain ECMA-119, the relocation directory and the relocated directories
1700 * are just normal directories which contain normal files and directories.
1701 * @param opts
1702 * The option set to be manipulated.
1703 * @param name
1704 * The name of the relocation directory in the root directory. Do not
1705 * prepend "/". An empty name or NULL will direct relocated directories
1706 * into the root directory. This is the default.
1707 * If the given name does not exist in the root directory when
1708 * iso_image_create_burn_source() is called, and if there are directories
1709 * at path level 8, then directory /name will be created automatically.
1710 * The name given by this call will be compared with iso_node_get_name()
1711 * of the directories in the root directory, not with the final ECMA-119
1712 * names of those directories.
1713 * @param flags
1714 * Bitfield for control purposes.
1715 * bit0= Mark the relocation directory by a Rock Ridge RE entry, if it
1716 * gets created during iso_image_create_burn_source(). This will
1717 * make it invisible for most Rock Ridge readers.
1718 * bit1= not settable via API (used internally)
1719 * @return
1720 * 1 success, < 0 error
1721 * @since 1.2.2
1722*/
1723int iso_write_opts_set_rr_reloc(IsoWriteOpts *opts, char *name, int flags);
1724
1725/**
1726 * Allow path in the ISO-9660 tree to have more than 255 characters.
1727 * This breaks ECMA-119 specification. Use with caution.
1728 *
1729 * @since 0.6.2
1730 */
1732
1733/**
1734 * Allow a single file or directory identifier to have up to 37 characters.
1735 * This is larger than the 31 characters allowed by ISO level 2, and the
1736 * extra space is taken from the version number, so this also forces
1737 * omit_version_numbers.
1738 * This breaks ECMA-119 specification and could lead to buffer overflow
1739 * problems on old systems. Use with caution.
1740 *
1741 * @since 0.6.2
1742 */
1744
1745/**
1746 * ISO-9660 forces filenames to have a ".", that separates file name from
1747 * extension. libisofs adds it if original filename doesn't has one. Set
1748 * this to 1 to prevent this behavior.
1749 * This breaks ECMA-119 specification. Use with caution.
1750 *
1751 * @param opts
1752 * The option set to be manipulated.
1753 * @param no
1754 * bit0= no forced dot with ECMA-119
1755 * bit1= no forced dot with Joliet (@since 0.6.30)
1756 *
1757 * @since 0.6.2
1758 */
1760
1761/**
1762 * Allow lowercase characters in ISO-9660 filenames. By default, only
1763 * uppercase characters, numbers and a few other characters are allowed.
1764 * This breaks ECMA-119 specification. Use with caution.
1765 * If lowercase is not allowed then those letters get mapped to uppercase
1766 * letters.
1767 *
1768 * @since 0.6.2
1769 */
1771
1772/**
1773 * Allow all 8-bit characters to appear on an ISO-9660 filename. Note
1774 * that "/" and 0x0 characters are never allowed, even in RR names.
1775 * This breaks ECMA-119 specification. Use with caution.
1776 *
1777 * @since 0.6.2
1778 */
1780
1781/**
1782 * If not iso_write_opts_set_allow_full_ascii() is set to 1:
1783 * Allow all 7-bit characters that would be allowed by allow_full_ascii, but
1784 * map lowercase to uppercase if iso_write_opts_set_allow_lowercase()
1785 * is not set to 1.
1786 * @param opts
1787 * The option set to be manipulated.
1788 * @param allow
1789 * If not zero, then allow what is described above.
1790 *
1791 * @since 1.2.2
1792 */
1794
1795/**
1796 * Allow all characters to be part of Volume and Volset identifiers on
1797 * the Primary Volume Descriptor. This breaks ISO-9660 constraints, but
1798 * should work on modern systems.
1799 *
1800 * @since 0.6.2
1801 */
1803
1804/**
1805 * Allow paths in the Joliet tree to have more than 240 characters.
1806 * This breaks Joliet specification. Use with caution.
1807 *
1808 * @since 0.6.2
1809 */
1811
1812/**
1813 * Allow leaf names in the Joliet tree to have up to 103 characters.
1814 * Normal limit is 64.
1815 * This breaks Joliet specification. Use with caution.
1816 *
1817 * @since 1.0.6
1818 */
1820
1821/**
1822 * Use character set UTF-16BE with Joliet, which is a superset of the
1823 * actually prescribed character set UCS-2.
1824 * This breaks Joliet specification with exotic characters which would
1825 * elsewise be mapped to underscore '_'. Use with caution.
1826 *
1827 * @since 1.3.6
1828 */
1830
1831/**
1832 * Write Rock Ridge info as of specification RRIP-1.10 rather than RRIP-1.12:
1833 * signature "RRIP_1991A" rather than "IEEE_1282", field PX without file
1834 * serial number.
1835 *
1836 * @since 0.6.12
1837 */
1839
1840/**
1841 * Write field PX with file serial number (i.e. inode number) even if
1842 * iso_write_opts_set_rrip_version_1_10(,1) is in effect.
1843 * This clearly violates the RRIP-1.10 specs. But it is done by mkisofs since
1844 * a while and no widespread protest is visible in the web.
1845 * If this option is not enabled, then iso_write_opts_set_hardlinks() will
1846 * only have an effect with iso_write_opts_set_rrip_version_1_10(,0).
1847 *
1848 * @since 0.6.20
1849 */
1851
1852/**
1853 * Write AAIP as extension according to SUSP 1.10 rather than SUSP 1.12.
1854 * I.e. without announcing it by an ER field and thus without the need
1855 * to precede the RRIP fields and the AAIP field by ES fields.
1856 * This saves 5 to 10 bytes per file and might avoid problems with readers
1857 * which dislike ER fields other than the ones for RRIP.
1858 * On the other hand, SUSP 1.12 frowns on such unannounced extensions
1859 * and prescribes ER and ES. It does this since the year 1994.
1860 *
1861 * In effect only if above iso_write_opts_set_aaip() enables writing of AAIP.
1862 *
1863 * @since 0.6.14
1864 */
1866
1867/**
1868 * Store as ECMA-119 Directory Record timestamp the mtime of the source node
1869 * rather than the image creation time.
1870 * If storing of mtime is enabled, then the settings of
1871 * iso_write_opts_set_replace_timestamps() apply. (replace==1 will revoke,
1872 * replace==2 will override mtime by iso_write_opts_set_default_timestamp().
1873 *
1874 * Since version 1.2.0 this may apply also to Joliet and ISO 9660:1999. To
1875 * reduce the probability of unwanted behavior changes between pre-1.2.0 and
1876 * post-1.2.0, the bits for Joliet and ISO 9660:1999 also enable ECMA-119.
1877 * The hopefully unlikely bit14 may then be used to disable mtime for ECMA-119.
1878 *
1879 * To enable mtime for all three directory trees, submit 7.
1880 * To disable this feature completely, submit 0.
1881 *
1882 * @param opts
1883 * The option set to be manipulated.
1884 * @param allow
1885 * If this parameter is negative, then mtime is enabled only for ECMA-119.
1886 * With positive numbers, the parameter is interpreted as bit field :
1887 * bit0= enable mtime for ECMA-119
1888 * bit1= enable mtime for Joliet and ECMA-119
1889 * bit2= enable mtime for ISO 9660:1999 and ECMA-119
1890 * bit14= disable mtime for ECMA-119 although some of the other bits
1891 * would enable it
1892 * @since 1.2.0
1893 * Before version 1.2.0 this applied only to ECMA-119 :
1894 * 0 stored image creation time in ECMA-119 tree.
1895 * Any other value caused storing of mtime.
1896 * Joliet and ISO 9660:1999 always stored the image creation time.
1897 * @since 0.6.12
1898 */
1900
1901/**
1902 * Whether to sort files based on their weight.
1903 *
1904 * @see iso_node_set_sort_weight
1905 * @since 0.6.2
1906 */
1908
1909/**
1910 * Whether to compute and record MD5 checksums for the whole session and/or
1911 * for each single IsoFile object. The checksums represent the data as they
1912 * were written into the image output stream, not necessarily as they were
1913 * on hard disk at any point of time.
1914 * See also calls iso_image_get_session_md5() and iso_file_get_md5().
1915 * @param opts
1916 * The option set to be manipulated.
1917 * @param session
1918 * If bit0 set: Compute session checksum
1919 * @param files
1920 * If bit0 set: Compute a checksum for each single IsoFile object which
1921 * gets its data content written into the session. Copy
1922 * checksums from files which keep their data in older
1923 * sessions.
1924 * If bit1 set: Check content stability (only with bit0). I.e. before
1925 * writing the file content into to image stream, read it
1926 * once and compute a MD5. Do a second reading for writing
1927 * into the image stream. Afterwards compare both MD5 and
1928 * issue a MISHAP event ISO_MD5_STREAM_CHANGE if they do not
1929 * match.
1930 * Such a mismatch indicates content changes between the
1931 * time point when the first MD5 reading started and the
1932 * time point when the last block was read for writing.
1933 * So there is high risk that the image stream was fed from
1934 * changing and possibly inconsistent file content.
1935 *
1936 * @since 0.6.22
1937 */
1938int iso_write_opts_set_record_md5(IsoWriteOpts *opts, int session, int files);
1939
1940/**
1941 * Set the parameters "name" and "timestamp" for a scdbackup checksum tag.
1942 * It will be appended to the libisofs session tag if the image starts at
1943 * LBA 0 (see iso_write_opts_set_ms_block()). The scdbackup tag can be used
1944 * to verify the image by command scdbackup_verify device -auto_end.
1945 * See scdbackup/README appendix VERIFY for its inner details.
1946 *
1947 * @param opts
1948 * The option set to be manipulated.
1949 * @param name
1950 * A word of up to 80 characters. Typically volno_totalno telling
1951 * that this is volume volno of a total of totalno volumes.
1952 * @param timestamp
1953 * A string of 13 characters YYMMDD.hhmmss (e.g. A90831.190324).
1954 * A9 = 2009, B0 = 2010, B1 = 2011, ... C0 = 2020, ...
1955 * @param tag_written
1956 * Either NULL or the address of an array with at least 512 characters.
1957 * In the latter case the eventually produced scdbackup tag will be
1958 * copied to this array when the image gets written. This call sets
1959 * scdbackup_tag_written[0] = 0 to mark its preliminary invalidity.
1960 * @return
1961 * 1 indicates success, <0 is error
1962 *
1963 * @since 0.6.24
1964 */
1966 char *name, char *timestamp,
1967 char *tag_written);
1968
1969/**
1970 * Whether to set default values for files and directory permissions, gid and
1971 * uid. All these take one of three values: 0, 1 or 2.
1972 *
1973 * If 0, the corresponding attribute will be kept as set in the IsoNode.
1974 * Unless you have changed it, it corresponds to the value on disc, so it
1975 * is suitable for backup purposes. If set to 1, the corresponding attrib.
1976 * will be changed by a default suitable value. Finally, if you set it to
1977 * 2, the attrib. will be changed with the value specified by the functioins
1978 * below. Note that for mode attributes, only the permissions are set, the
1979 * file type remains unchanged.
1980 *
1981 * @see iso_write_opts_set_default_dir_mode
1982 * @see iso_write_opts_set_default_file_mode
1983 * @see iso_write_opts_set_default_uid
1984 * @see iso_write_opts_set_default_gid
1985 * @since 0.6.2
1986 */
1988 int file_mode, int uid, int gid);
1989
1990/**
1991 * Set the mode to use on dirs when you set the replace_mode of dirs to 2.
1992 *
1993 * @see iso_write_opts_set_replace_mode
1994 * @since 0.6.2
1995 */
1997
1998/**
1999 * Set the mode to use on files when you set the replace_mode of files to 2.
2000 *
2001 * @see iso_write_opts_set_replace_mode
2002 * @since 0.6.2
2003 */
2005
2006/**
2007 * Set the uid to use when you set the replace_uid to 2.
2008 *
2009 * @see iso_write_opts_set_replace_mode
2010 * @since 0.6.2
2011 */
2013
2014/**
2015 * Set the gid to use when you set the replace_gid to 2.
2016 *
2017 * @see iso_write_opts_set_replace_mode
2018 * @since 0.6.2
2019 */
2021
2022/**
2023 * 0 to use IsoNode timestamps, 1 to use recording time, 2 to use
2024 * values from timestamp field. This applies to the timestamps of Rock Ridge
2025 * and if the use of mtime is enabled by iso_write_opts_set_dir_rec_mtime().
2026 * In the latter case, value 1 will revoke the recording of mtime, value
2027 * 2 will override mtime by iso_write_opts_set_default_timestamp().
2028 *
2029 * @see iso_write_opts_set_default_timestamp
2030 * @since 0.6.2
2031 */
2033
2034/**
2035 * Set the timestamp to use when you set the replace_timestamps to 2.
2036 *
2037 * @see iso_write_opts_set_replace_timestamps
2038 * @since 0.6.2
2039 */
2041
2042/**
2043 * Whether to always record timestamps in GMT.
2044 *
2045 * By default, libisofs stores local time information on image. You can set
2046 * this to always store timestamps converted to GMT. This prevents any
2047 * discrimination of the timezone of the image preparer by the image reader.
2048 *
2049 * It is useful if you want to hide your timezone, or you live in a timezone
2050 * that can't be represented in ECMA-119. These are timezones with an offset
2051 * from GMT greater than +13 hours, lower than -12 hours, or not a multiple
2052 * of 15 minutes.
2053 * Negative timezones (west of GMT) can trigger bugs in some operating systems
2054 * which typically appear in mounted ISO images as if the timezone shift from
2055 * GMT was applied twice (e.g. in New York 22:36 becomes 17:36).
2056 *
2057 * @since 0.6.2
2058 */
2060
2061/**
2062 * Set the charset to use for the RR names of the files that will be created
2063 * on the image.
2064 * NULL to use default charset, that is the locale charset.
2065 * You can obtain the list of charsets supported on your system executing
2066 * "iconv -l" in a shell.
2067 *
2068 * @since 0.6.2
2069 */
2070int iso_write_opts_set_output_charset(IsoWriteOpts *opts, const char *charset);
2071
2072/**
2073 * Set the type of image creation in case there was already an existing
2074 * image imported. Libisofs supports two types of creation:
2075 * stand-alone and appended.
2076 *
2077 * A stand-alone image is an image that does not need the old image any more
2078 * for being mounted by the operating system or imported by libisofs. It may
2079 * be written beginning with byte 0 of optical media or disk file objects.
2080 * There will be no distinction between files from the old image and those
2081 * which have been added by the new image generation.
2082 *
2083 * On the other side, an appended image is not self contained. It may refer
2084 * to files that stay stored in the imported existing image.
2085 * This usage model is inspired by CD multi-session. It demands that the
2086 * appended image is finally written to the same media or disk file
2087 * as the imported image at an address behind the end of that imported image.
2088 * The exact address may depend on media peculiarities and thus has to be
2089 * announced by the application via iso_write_opts_set_ms_block().
2090 * The real address where the data will be written is under control of the
2091 * consumer of the struct burn_source which takes the output of libisofs
2092 * image generation. It may be the one announced to libisofs or an intermediate
2093 * one. Nevertheless, the image will be readable only at the announced address.
2094 *
2095 * If you have not imported a previous image by iso_image_import(), then the
2096 * image will always be a stand-alone image, as there is no previous data to
2097 * refer to.
2098 *
2099 * @param opts
2100 * The option set to be manipulated.
2101 * @param append
2102 * 1 to create an appended image, 0 for an stand-alone one.
2103 *
2104 * @since 0.6.2
2105 */
2107
2108/**
2109 * Set the start block of the image. It is supposed to be the lba where the
2110 * first block of the image will be written on disc. All references inside the
2111 * ISO image will take this into account, thus providing a mountable image.
2112 *
2113 * For appendable images, that are written to a new session, you should
2114 * pass here the lba of the next writable address on disc.
2115 *
2116 * In stand alone images this is usually 0. However, you may want to
2117 * provide a different ms_block if you don't plan to burn the image in the
2118 * first session on disc, such as in some CD-Extra disc whether the data
2119 * image is written in a new session after some audio tracks.
2120 *
2121 * @since 0.6.2
2122 */
2123int iso_write_opts_set_ms_block(IsoWriteOpts *opts, uint32_t ms_block);
2124
2125/**
2126 * Sets the buffer where to store the descriptors which shall be written
2127 * at the beginning of an overwritable media to point to the newly written
2128 * image.
2129 * This is needed if the write start address of the image is not 0.
2130 * In this case the first 64 KiB of the media have to be overwritten
2131 * by the buffer content after the session was written and the buffer
2132 * was updated by libisofs. Otherwise the new session would not be
2133 * found by operating system function mount() or by libisoburn.
2134 * (One could still mount that session if its start address is known.)
2135 *
2136 * If you do not need this information, for example because you are creating a
2137 * new image for LBA 0 or because you will create an image for a true
2138 * multisession media, just do not use this call or set buffer to NULL.
2139 *
2140 * Use cases:
2141 *
2142 * - Together with iso_write_opts_set_appendable(opts, 1) the buffer serves
2143 * for the growing of an image as done in growisofs by Andy Polyakov.
2144 * This allows appending of a new session to non-multisession media, such
2145 * as DVD+RW. The new session will refer to the data of previous sessions
2146 * on the same media.
2147 * libisoburn emulates multisession appendability on overwritable media
2148 * and disk files by performing this use case.
2149 *
2150 * - Together with iso_write_opts_set_appendable(opts, 0) the buffer allows
2151 * to write the first session on overwritable media to start addresses
2152 * other than 0.
2153 * This address must not be smaller than 32 blocks plus the eventual
2154 * partition offset as defined by iso_write_opts_set_part_offset().
2155 * libisoburn in most cases writes the first session on overwritable media
2156 * and disk files to LBA (32 + partition_offset) in order to preserve its
2157 * descriptors from the subsequent overwriting by the descriptor buffer of
2158 * later sessions.
2159 *
2160 * @param opts
2161 * The option set to be manipulated.
2162 * @param overwrite
2163 * When not NULL, it should point to at least 64KiB of memory, where
2164 * libisofs will install the contents that shall be written at the
2165 * beginning of overwritable media.
2166 * You should initialize the buffer either with 0s, or with the contents
2167 * of the first 32 blocks of the image you are growing. In most cases,
2168 * 0 is good enough.
2169 * IMPORTANT: If you use iso_write_opts_set_part_offset() then the
2170 * overwrite buffer must be larger by the offset defined there.
2171 *
2172 * @since 0.6.2
2173 */
2174int iso_write_opts_set_overwrite_buf(IsoWriteOpts *opts, uint8_t *overwrite);
2175
2176/**
2177 * Set the size, in number of blocks, of the ring buffer used between the
2178 * writer thread and the burn_source. You have to provide at least a 32
2179 * blocks buffer. Default value is set to 2MB, if that is ok for you, you
2180 * don't need to call this function.
2181 *
2182 * @since 0.6.2
2183 */
2184int iso_write_opts_set_fifo_size(IsoWriteOpts *opts, size_t fifo_size);
2185
2186/*
2187 * Attach 32 kB of binary data which shall get written to the first 32 kB
2188 * of the ISO image, the ECMA-119 System Area. This space is intended for
2189 * system dependent boot software, e.g. a Master Boot Record which allows to
2190 * boot from USB sticks or hard disks. ECMA-119 makes no own assumptions or
2191 * prescriptions about the byte content.
2192 *
2193 * If system area data are given or options bit0 is set, then bit1 of
2194 * el_torito_set_isolinux_options() is automatically disabled.
2195 *
2196 * @param opts
2197 * The option set to be manipulated.
2198 * @param data
2199 * Either NULL or 32 kB of data. Do not submit less bytes !
2200 * @param options
2201 * Can cause manipulations of submitted data before they get written:
2202 * bit0= Only with System area type 0 = MBR
2203 * Apply a --protective-msdos-label as of grub-mkisofs.
2204 * This means to patch bytes 446 to 512 of the system area so
2205 * that one partition is defined which begins at the second
2206 * 512-byte block of the image and ends where the image ends.
2207 * This works with and without system_area_data.
2208 * Modern GRUB2 system areas get also treated by bit14. See below.
2209 * bit1= Only with System area type 0 = MBR
2210 * Apply isohybrid MBR patching to the system area.
2211 * This works only with system area data from SYSLINUX plus an
2212 * ISOLINUX boot image as first submitted boot image
2213 * (see iso_image_set_boot_image()) and only if not bit0 is set.
2214 * bit2-7= System area type
2215 * 0= with bit0 or bit1: MBR
2216 * else: type depends on bits bit10-13: System area sub type
2217 * 1= MIPS Big Endian Volume Header
2218 * @since 0.6.38
2219 * Submit up to 15 MIPS Big Endian boot files by
2220 * iso_image_add_mips_boot_file().
2221 * This will overwrite the first 512 bytes of the submitted
2222 * data.
2223 * 2= DEC Boot Block for MIPS Little Endian
2224 * @since 0.6.38
2225 * The first boot file submitted by
2226 * iso_image_add_mips_boot_file() will be activated.
2227 * This will overwrite the first 512 bytes of the submitted
2228 * data.
2229 * 3= SUN Disk Label for SUN SPARC
2230 * @since 0.6.40
2231 * Submit up to 7 SPARC boot images by
2232 * iso_write_opts_set_partition_img() for partition numbers 2
2233 * to 8.
2234 * This will overwrite the first 512 bytes of the submitted
2235 * data.
2236 * 4= HP-PA PALO boot sector version 4 for HP PA-RISC
2237 * @since 1.3.8
2238 * Suitable for older PALO of e.g. Debian 4 and 5.
2239 * Submit all five parameters of iso_image_set_hppa_palo():
2240 * cmdline, bootloader, kernel_32, kernel_64, ramdisk
2241 * 5= HP-PA PALO boot sector version 5 for HP PA-RISC
2242 * @since 1.3.8
2243 * Suitable for newer PALO, where PALOHDRVERSION in
2244 * lib/common.h is defined as 5.
2245 * Submit all five parameters of iso_image_set_hppa_palo():
2246 * cmdline, bootloader, kernel_32, kernel_64, ramdisk
2247 * 6= DEC Alpha SRM boot sector
2248 * @since 1.4.0
2249 * Submit bootloader path in ISO by iso_image_set_alpha_boot().
2250 * bit8-9= Only with System area type 0 = MBR
2251 * @since 1.0.4
2252 * Cylinder alignment mode eventually pads the image to make it
2253 * end at a cylinder boundary.
2254 * 0 = auto (align if bit1)
2255 * 1 = always align to cylinder boundary
2256 * 2 = never align to cylinder boundary
2257 * 3 = always align, additionally pad up and align partitions
2258 * which were appended by iso_write_opts_set_partition_img()
2259 * @since 1.2.6
2260 * bit10-13= System area sub type
2261 * @since 1.2.4
2262 * With type 0:
2263 * if options bit0 ... MBR with partition start at block 1
2264 * if options bit1 ... ISOLINUX isohybrid MBR
2265 * else:
2266 * 0 = no particular sub type, use unaltered
2267 * 1 = CHRP: A single MBR partition of type 0x96 covers the
2268 * ISO image. Not compatible with any other feature
2269 * which needs to have own MBR partition entries.
2270 * 2 = generic MBR @since 1.3.8
2271 * bit14= Only with System area type 0 = MBR
2272 * GRUB2 boot provisions:
2273 * @since 1.3.0
2274 * Patch system area at byte 0x1b0 to 0x1b7 with
2275 * (512-block address + 4) of the first boot image file.
2276 * Little-endian 8-byte.
2277 * Is normally combined with options bit0.
2278 * Will not be in effect if options bit1 is set.
2279 * bit15= Only with System area type MBR but not with CHRP
2280 * @since 1.4.4
2281 * Enforce MBR "bootable/active" flag. In worst case by dummy
2282 * partition of type 0x00 which occupies block 0.
2283 * bit16= "Legacy BIOS bootable" in GPT
2284 * @since 1.5.6
2285 * If this bit is set and a GPT partition for the ISO 9660
2286 * filesystem gets written, then set the GPT partition flags bit 2
2287 * "Legacy BIOS bootable".
2288 * bit17= ISO not read-only
2289 * @since 1.5.6
2290 * Do not set GPT partition flag bit 60 "read-only" for the
2291 * ISO 9660 filesystem partition, if such a partition gets
2292 * written.
2293 * @param flag
2294 * bit0 = invalidate any attached system area data. Same as data == NULL
2295 * (This re-activates eventually loaded image System Area data.
2296 * To erase those, submit 32 kB of zeros without flag bit0.)
2297 * bit1 = keep data unaltered
2298 * bit2 = keep options unaltered
2299 * @return
2300 * ISO_SUCCESS or error
2301 * @since 0.6.30
2302 */
2304 int options, int flag);
2305
2306/**
2307 * Set a name for the system area. This setting is ignored unless system area
2308 * type 3 "SUN Disk Label" is in effect by iso_write_opts_set_system_area().
2309 * In this case it will replace the default text at the start of the image:
2310 * "CD-ROM Disc with Sun sparc boot created by libisofs"
2311 *
2312 * @param opts
2313 * The option set to be manipulated.
2314 * @param label
2315 * A text of up to 128 characters.
2316 * @return
2317 * ISO_SUCCESS or error
2318 * @since 0.6.40
2319*/
2321
2322/**
2323 * Explicitly set the four timestamps of the emerging Primary Volume
2324 * Descriptor and in the volume descriptors of Joliet and ISO 9660:1999,
2325 * if those are to be generated.
2326 * Default with all parameters is 0.
2327 *
2328 * ECMA-119 defines them as:
2329 * @param opts
2330 * The option set to be manipulated.
2331 * @param vol_creation_time
2332 * When "the information in the volume was created."
2333 * A value of 0 means that the timepoint of write start is to be used.
2334 * @param vol_modification_time
2335 * When "the information in the volume was last modified."
2336 * A value of 0 means that the timepoint of write start is to be used.
2337 * @param vol_expiration_time
2338 * When "the information in the volume may be regarded as obsolete."
2339 * A value of 0 means that the information never shall expire.
2340 * @param vol_effective_time
2341 * When "the information in the volume may be used."
2342 * A value of 0 means that not such retention is intended.
2343 * @param vol_uuid
2344 * If this text is not empty, then it overrides vol_creation_time and
2345 * vol_modification_time by copying the first 16 decimal digits from
2346 * uuid, eventually padding up with decimal '1', and writing a NUL-byte
2347 * as timezone.
2348 * Other than with vol_*_time the resulting string in the ISO image
2349 * is fully predictable and free of timezone pitfalls.
2350 * It should express a reasonable time in form YYYYMMDDhhmmsscc.
2351 * The timezone will always be recorded as GMT.
2352 * E.g.: "2010040711405800" = 7 Apr 2010 11:40:58 (+0 centiseconds)
2353 * @return
2354 * ISO_SUCCESS or error
2355 *
2356 * @since 0.6.30
2357 */
2359 time_t vol_creation_time, time_t vol_modification_time,
2360 time_t vol_expiration_time, time_t vol_effective_time,
2361 char *vol_uuid);
2362
2363
2364/*
2365 * Control production of a second set of volume descriptors (superblock)
2366 * and directory trees, together with a partition table in the MBR where the
2367 * first partition has non-zero start address and the others are zeroed.
2368 * The first partition stretches to the end of the whole ISO image.
2369 * The additional volume descriptor set and trees will allow to mount the
2370 * ISO image at the start of the first partition, while it is still possible
2371 * to mount it via the normal first volume descriptor set and tree at the
2372 * start of the image or storage device.
2373 * This makes few sense on optical media. But on USB sticks it creates a
2374 * conventional partition table which makes it mountable on e.g. Linux via
2375 * /dev/sdb and /dev/sdb1 alike.
2376 * IMPORTANT: When submitting memory by iso_write_opts_set_overwrite_buf()
2377 * then its size must be at least 64 KiB + partition offset.
2378 *
2379 * @param opts
2380 * The option set to be manipulated.
2381 * @param block_offset_2k
2382 * The offset of the partition start relative to device start.
2383 * This is counted in 2 kB blocks. The partition table will show the
2384 * according number of 512 byte sectors.
2385 * Default is 0 which causes no special partition table preparations.
2386 * If it is not 0 then it must not be smaller than 16.
2387 * @param secs_512_per_head
2388 * Number of 512 byte sectors per head. 1 to 63. 0=automatic.
2389 * @param heads_per_cyl
2390 * Number of heads per cylinder. 1 to 255. 0=automatic.
2391 * @return
2392 * ISO_SUCCESS or error
2393 *
2394 * @since 0.6.36
2395 */
2397 uint32_t block_offset_2k,
2398 int secs_512_per_head, int heads_per_cyl);
2399
2400
2401/** The minimum version of libjte to be used with this version of libisofs
2402 at compile time. The use of libjte is optional and depends on configure
2403 tests. It can be prevented by ./configure option --disable-libjte .
2404 @since 0.6.38
2405*/
2406#define iso_libjte_req_major 2
2407#define iso_libjte_req_minor 0
2408#define iso_libjte_req_micro 0
2409
2410/**
2411 * Associate a libjte environment object to the upcoming write run.
2412 * libjte implements Jigdo Template Extraction as of Steve McIntyre and
2413 * Richard Atterer.
2414 * The call will fail if no libjte support was enabled at compile time.
2415 * @param opts
2416 * The option set to be manipulated.
2417 * @param libjte_handle
2418 * Pointer to a struct libjte_env e.g. created by libjte_new().
2419 * It must stay existent from the start of image generation by
2420 * iso_image_create_burn_source() until the write thread has ended.
2421 * This can be inquired by iso_image_generator_is_running().
2422 * In order to keep the libisofs API identical with and without
2423 * libjte support the parameter type is (void *).
2424 * @return
2425 * ISO_SUCCESS or error
2426 *
2427 * @since 0.6.38
2428*/
2429int iso_write_opts_attach_jte(IsoWriteOpts *opts, void *libjte_handle);
2430
2431/**
2432 * Remove eventual association to a libjte environment handle.
2433 * The call will fail if no libjte support was enabled at compile time.
2434 * @param opts
2435 * The option set to be manipulated.
2436 * @param libjte_handle
2437 * If not submitted as NULL, this will return the previously set
2438 * libjte handle.
2439 * @return
2440 * ISO_SUCCESS or error
2441 *
2442 * @since 0.6.38
2443*/
2444int iso_write_opts_detach_jte(IsoWriteOpts *opts, void **libjte_handle);
2445
2446
2447/**
2448 * Cause a number of blocks with zero bytes to be written after the payload
2449 * data, but before the eventual checksum data. Unlike libburn tail padding,
2450 * these blocks are counted as part of the image and covered by eventual
2451 * image checksums.
2452 * A reason for such padding can be the wish to prevent the Linux read-ahead
2453 * bug by sacrificial data which still belong to image and Jigdo template.
2454 * Normally such padding would be the job of the burn program which should know
2455 * that it is needed with CD write type TAO if Linux read(2) shall be able
2456 * to read all payload blocks.
2457 * 150 blocks = 300 kB is the traditional sacrifice to the Linux kernel.
2458 * @param opts
2459 * The option set to be manipulated.
2460 * @param num_blocks
2461 * Number of extra 2 kB blocks to be written.
2462 * @return
2463 * ISO_SUCCESS or error
2464 *
2465 * @since 0.6.38
2466 */
2467int iso_write_opts_set_tail_blocks(IsoWriteOpts *opts, uint32_t num_blocks);
2468
2469
2470/**
2471 * The libisofs interval reader is used internally and offered by libisofs API:
2472 * @since 1.4.0
2473 * The functions iso_write_opts_set_prep_img(), iso_write_opts_set_efi_bootp(),
2474 * and iso_write_opts_set_partition_img() accept with their flag bit0 an
2475 * interval reader description string instead of a disk path.
2476 * The API calls are iso_interval_reader_new(), iso_interval_reader_read(),
2477 * and iso_interval_reader_destroy().
2478 * The data may be cut out and optionally partly zeroized.
2479 *
2480 * An interval reader description string has the form:
2481 * $flags:$interval:$zeroizers:$source
2482 * The component $flags modifies the further interpretation:
2483 * "local_fs" ....... demands to read from a file depicted by the path in
2484 * $source.
2485 * "imported_iso" ... demands to read from the IsoDataSource object that was
2486 * used with iso_image_import() when
2487 * iso_read_opts_keep_import_src() was enabled.
2488 * The text in $source is ignored.
2489 * The application has to ensure that reading from the
2490 * import source does not disturb production of the new
2491 * ISO session. Especially this would be the case if the
2492 * import source is the same libburn drive with a
2493 * sequential optical medium to which the new session shall
2494 * get burned.
2495 * The component $interval consists of two byte address numbers separated
2496 * by a "-" character. E.g. "0-429" means to read bytes 0 to 429.
2497 * The component $zeroizers consists of zero or more comma separated strings.
2498 * They define which part of the read data to zeroize. Byte number 0 means
2499 * the byte read from the $interval start address.
2500 * Each string may be either
2501 * "zero_mbrpt" ..... demands to zeroize bytes 446 to 509 of the read data if
2502 * bytes 510 and 511 bear the MBR signature 0x55 0xaa.
2503 * "zero_gpt" ....... demands to check for a GPT header in bytes 512 to 1023,
2504 * to zeroize it and its partition table blocks.
2505 * "zero_apm" ....... demands to check for an APM block 0 and to zeroize
2506 * its partition table blocks. But not the block 0 itself,
2507 * because it could be actually MBR x86 machine code.
2508 * $zero_start"-"$zero_end ... demands to zeroize the read-in bytes beginning
2509 * with number $zero_start and ending after $zero_end.
2510 * The component $source is the file path with "local_fs", and ignored with
2511 * "imported_iso".
2512 * Byte numbers may be scaled by a suffix out of {k,m,g,t,s,d} meaning
2513 * multiplication by {1024, 1024k, 1024m, 1024g, 2048, 512}. A scaled value
2514 * as end number depicts the last byte of the scaled range.
2515 * E.g. "0d-0d" is "0-511".
2516 * Examples:
2517 * "local_fs:0-32767:zero_mbrpt,zero_gpt,440-443:/tmp/template.iso"
2518 * "imported_iso:45056d-47103d::"
2519 */
2520struct iso_interval_reader;
2521
2522/**
2523 * Create an interval reader object.
2524 *
2525 * @param img
2526 * The IsoImage object which can provide the "imported_iso" data source.
2527 * @param path
2528 * The interval reader description string. See above.
2529 * @param ivr
2530 * Returns in case of success a pointer to the created object.
2531 * Dispose it by iso_interval_reader_destroy() when no longer needed.
2532 * @param byte_count
2533 * Returns in case of success the number of bytes in the interval.
2534 * @param flag
2535 * bit0= tolerate (src == NULL) with "imported_iso".
2536 * (Will immediately cause eof of interval input.)
2537 * @return
2538 * ISO_SUCCESS or error (which is < 0)
2539 *
2540 * @since 1.4.0
2541 */
2543 struct iso_interval_reader **ivr,
2544 off_t *byte_count, int flag);
2545
2546/**
2547 * Dispose an interval reader object.
2548 *
2549 * @param ivr
2550 * The reader object to be disposed. *ivr will be set to NULL.
2551 * @param flag
2552 * Unused yet. Submit 0.
2553 * @return
2554 * ISO_SUCCESS or error (which is < 0)
2555 *
2556 * @since 1.4.0
2557 */
2558int iso_interval_reader_destroy(struct iso_interval_reader **ivr, int flag);
2559
2560/**
2561 * Read the next block of 2048 bytes from an interval reader object.
2562 * If end-of-input happens, the interval will get filled up with 0 bytes.
2563 *
2564 * @param ivr
2565 * The object to read from.
2566 * @param buf
2567 * Pointer to memory for filling in at least 2048 bytes.
2568 * @param buf_fill
2569 * Will in case of success return the number of valid bytes.
2570 * If this is smaller than 2048, then end-of-interval has occurred.
2571 * @param flag
2572 * Unused yet. Submit 0.
2573 * @return
2574 * ISO_SUCCESS if data were read, 0 if not, < 0 if error
2575 *
2576 * @since 1.4.0
2577 */
2578int iso_interval_reader_read(struct iso_interval_reader *ivr, uint8_t *buf,
2579 int *buf_fill, int flag);
2580
2581
2582/**
2583 * Copy a data file from the local filesystem into the emerging ISO image.
2584 * Mark it by an MBR partition entry as PreP partition and also cause
2585 * protective MBR partition entries before and after this partition.
2586 * Vladimir Serbinenko stated aboy PreP = PowerPC Reference Platform :
2587 * "PreP [...] refers mainly to IBM hardware. PreP boot is a partition
2588 * containing only raw ELF and having type 0x41."
2589 *
2590 * This feature is only combinable with system area type 0
2591 * and currently not combinable with ISOLINUX isohybrid production.
2592 * It overrides --protective-msdos-label. See iso_write_opts_set_system_area().
2593 * Only partition 4 stays available for iso_write_opts_set_partition_img().
2594 * It is compatible with HFS+/FAT production by storing the PreP partition
2595 * before the start of the HFS+/FAT partition.
2596 *
2597 * @param opts
2598 * The option set to be manipulated.
2599 * @param image_path
2600 * File address in the local file system or instructions for interval
2601 * reader. See flag bit0.
2602 * NULL revokes production of the PreP partition.
2603 * @param flag
2604 * bit0= The path contains instructions for the interval reader.
2605 * See above.
2606 * @since 1.4.0
2607 * All other bits are reserved for future usage. Set them to 0.
2608 * @return
2609 * ISO_SUCCESS or error
2610 *
2611 * @since 1.2.4
2612 */
2613int iso_write_opts_set_prep_img(IsoWriteOpts *opts, char *image_path,
2614 int flag);
2615
2616/**
2617 * Copy a data file from the local filesystem into the emerging ISO image.
2618 * Mark it by an GPT partition entry as EFI System partition, and also cause
2619 * protective GPT partition entries before and after the partition.
2620 * GPT = Globally Unique Identifier Partition Table
2621 *
2622 * This feature may collide with data submitted by
2623 * iso_write_opts_set_system_area()
2624 * and with settings made by
2625 * el_torito_set_isolinux_options()
2626 * It is compatible with HFS+/FAT production by storing the EFI partition
2627 * before the start of the HFS+/FAT partition.
2628 * The GPT overwrites byte 0x0200 to 0x03ff of the system area and all
2629 * further bytes above 0x0800 which are not used by an Apple Partition Map.
2630 *
2631 * @param opts
2632 * The option set to be manipulated.
2633 * @param image_path
2634 * File address in the local file system or instructions for interval
2635 * reader. See flag bit0.
2636 * NULL revokes production of the EFI boot partition.
2637 * @param flag
2638 * bit0= The path contains instructions for the interval reader
2639 * See above.
2640 * @since 1.4.0
2641 * All other bits are reserved for future usage. Set them to 0.
2642 * @return
2643 * ISO_SUCCESS or error
2644 *
2645 * @since 1.2.4
2646 */
2647int iso_write_opts_set_efi_bootp(IsoWriteOpts *opts, char *image_path,
2648 int flag);
2649
2650/**
2651 * Control whether the emerging GPT gets a pseudo-randomly generated disk GUID
2652 * or whether it gets a user supplied GUID.
2653 * The partition GUIDs will be generated in a reproducible way by exoring the
2654 * little-endian 32 bit partition number with the disk GUID beginning at byte
2655 * offset 9.
2656 *
2657 * @param opts
2658 * The option set to be manipulated.
2659 * @param guid
2660 * 16 bytes of user supplied GUID. Readily byte-swapped from the text
2661 * form as prescribed by UEFI specs:
2662 * 4 byte, 2 byte, 2 byte as little-endian.
2663 * 2 byte, 6 byte as big-endian.
2664 * The upper 4 bit of guid[7] should bear the value 4 to express the
2665 * RFC 4122 version 4. Bit 7 of byte[8] should be set to 1 and bit 6
2666 * be set to 0, in order to express the RFC 4122 variant of UUID,
2667 * where version 4 means "pseudo-random uuid".
2668 * @param mode
2669 * 0 = ignore parameter guid and produce the GPT disk GUID by a
2670 * pseudo-random algorithm. This is the default setting.
2671 * 1 = use parameter guid as GPT disk GUID
2672 * 2 = ignore parameter guid and derive the GPT disk GUID from
2673 * parameter vol_uuid of iso_write_opts_set_pvd_times().
2674 * The 16 bytes of vol_uuid get copied and bytes 7, 8 get their
2675 * upper bits changed to comply to RFC 4122 and UEFI.
2676 * Error ISO_GPT_NO_VOL_UUID will occur if image production begins
2677 * before vol_uuid was set.
2678 *
2679 * @return
2680 * ISO_SUCCESS or ISO_BAD_GPT_GUID_MODE
2681 *
2682 * @since 1.4.6
2683 */
2684int iso_write_opts_set_gpt_guid(IsoWriteOpts *opts, uint8_t guid[16],
2685 int mode);
2686
2687/**
2688 * Set the maximum number of SUSP CE entries and thus continuation areas.
2689 * Each continuation area can hold at most 2048 bytes of SUSP data (Rock Ridge
2690 * or AAIP). The first area can be smaller. There might be some waste at the
2691 * end of each area.
2692 * When the maximum number is exceeded during ISO filesystem production
2693 * then possibly xattr and ACL get removed or error ISO_TOO_MANY_CE gets
2694 * reported and filesystem production is prevented.
2695 *
2696 * Files with 32 or more CE entries do not show up in mounted filesystems on
2697 * Linux. So the default setting is 31 with drop mode 2. If a higher limit is
2698 * chosen and 31 gets surpassed, then a warning message gets reported.
2699 *
2700 * @param opts
2701 * The option set to be manipulated.
2702 * @param num
2703 * The maximum number of CE entries per file.
2704 * Not more than 100000 may be set here.
2705 * 0 gets silently mapped to 1, because the root directory needs one CE.
2706 * @param flag
2707 * bit0-bit3 = Drop mode: What to do with AAIP data on too many CE:
2708 * 0 = throw ISO_TOO_MANY_CE, without dropping anything
2709 * 1 = permanently drop non-isofs fattr from IsoNode and
2710 * retry filesystem production
2711 * 2 = drop ACL if dropping non-isofs fattr does not suffice
2712 * @return
2713 * ISO_SUCCESS or ISO_TOO_MANY_CE
2714 *
2715 * @since 1.5.6
2716*/
2718 int flag);
2719
2720/**
2721 * Generate a pseudo-random GUID suitable for iso_write_opts_set_gpt_guid().
2722 *
2723 * @param guid
2724 * Will be filled by 16 bytes of generated GUID.
2725 *
2726 * @since 1.4.6
2727 */
2728void iso_generate_gpt_guid(uint8_t guid[16]);
2729
2730/**
2731 * Cause an arbitrary data file to be appended to the ISO image and to be
2732 * described by a partition table entry in an MBR or SUN Disk Label at the
2733 * start of the ISO image.
2734 * The partition entry will bear the size of the image file rounded up to
2735 * the next multiple of 2048 bytes.
2736 * MBR or SUN Disk Label are selected by iso_write_opts_set_system_area()
2737 * system area type: 0 selects MBR partition table. 3 selects a SUN partition
2738 * table with 320 kB start alignment.
2739 *
2740 * @param opts
2741 * The option set to be manipulated.
2742 * @param partition_number
2743 * Depicts the partition table entry which shall describe the
2744 * appended image.
2745 * Range with MBR: 1 to 4. 1 will cause the whole ISO image to be
2746 * unclaimable space before partition 1.
2747 * Range with SUN Disk Label: 2 to 8.
2748 * @param partition_type
2749 * The MBR partition type. E.g. FAT12 = 0x01 , FAT16 = 0x06,
2750 * Linux Native Partition = 0x83. See fdisk command L.
2751 * This parameter is ignored with SUN Disk Label.
2752 * @param image_path
2753 * File address in the local file system or instructions for interval
2754 * reader. See flag bit0.
2755 * With SUN Disk Label: an empty name causes the partition to become
2756 * a copy of the next lower partition.
2757 * @param flag
2758 * bit0= The path contains instructions for the interval reader
2759 * See above.
2760 * @since 1.4.0
2761 * All other bits are reserved for future usage. Set them to 0.
2762 * @return
2763 * ISO_SUCCESS or error
2764 *
2765 * @since 0.6.38
2766 */
2767int iso_write_opts_set_partition_img(IsoWriteOpts *opts, int partition_number,
2768 uint8_t partition_type, char *image_path, int flag);
2769
2770/**
2771 * Control whether partitions created by iso_write_opts_set_partition_img()
2772 * are to be represented in MBR or as GPT partitions.
2773 *
2774 * @param opts
2775 * The option set to be manipulated.
2776 * @param gpt
2777 * 0= represent as MBR partition; as GPT only if other GPT partitions
2778 * are present
2779 * 1= represent as GPT partition and cause protective MBR with a single
2780 * partition which covers the whole output data.
2781 * This may fail if other settings demand MBR partitions.
2782 * @return
2783 * ISO_SUCCESS or error
2784 *
2785 * @since 1.4.0
2786 */
2788
2789/**
2790 * Set the GPT Type GUID for a partition defined by
2791 * iso_write_opts_set_partition_img().
2792 *
2793 * @param opts
2794 * The option set to be manipulated.
2795 * @param partition_number
2796 * Depicts the partition table entry which shall get the Type GUID.
2797 * @param guid
2798 * 16 bytes of user supplied GUID. Readily byte-swapped from the text
2799 * form as prescribed by UEFI specs:
2800 * 4 byte, 2 byte, 2 byte as little-endian.
2801 * 2 byte, 6 byte as big-endian.
2802 * @param valid
2803 * Set to 1 to make this Type GUID valid.
2804 * Set to 0 in order to invalidate a previously made setting. In this
2805 * case MBR type 0xEF will become the EFI Type GUID. All others will
2806 * become the Basic Data Partition Type GUID.
2807 * @return
2808 * ISO_SUCCESS or error
2809 *
2810 * @since 1.5.2
2811 */
2812int iso_write_opts_set_part_type_guid(IsoWriteOpts *opts, int partition_number,
2813 uint8_t guid[16], int valid);
2814
2815/**
2816 * Control whether partitions created by iso_write_opts_set_partition_img()
2817 * are to be represented in Apple Partition Map.
2818 *
2819 * @param opts
2820 * The option set to be manipulated.
2821 * @param apm
2822 * 0= do not represent appended partitions in APM
2823 * 1= represent in APM, even if not
2824 * iso_write_opts_set_part_like_isohybrid() enables it and no
2825 * other APM partitions emerge.
2826 * @return
2827 * ISO_SUCCESS or error
2828 *
2829 * @since 1.4.4
2830 */
2832
2833/**
2834 * Control whether bits 2 to 8 of el_torito_set_isolinux_options()
2835 * shall apply even if not isohybrid MBR patching is enabled (bit1 of
2836 * parameter options of iso_write_opts_set_system_area()):
2837 * - Mentioning of El Torito boot images in GPT.
2838 * - Mentioning of El Torito boot images in APM.
2839 *
2840 * In this case some other behavior from isohybrid processing will apply too:
2841 * - No MBR partition of type 0xee emerges, even if GPT gets produced.
2842 * - Gaps between GPT and APM partitions will not be filled by more partitions.
2843 *
2844 * An extra feature towards isohybrid is enabled:
2845 * - Appended partitions get mentioned in APM if other APM partitions emerge.
2846 *
2847 * @param opts
2848 * The option set to be manipulated.
2849 * @param alike
2850 * 0= Apply the described behavior only with ISOLINUX isohybrid.
2851 * Do not mention appended partitions in APM unless
2852 * iso_write_opts_set_appended_as_apm() is enabled.
2853 * 1= Apply the described behavior even without ISOLINUX isohybrid.
2854 *
2855 * @return
2856 * ISO_SUCCESS or error
2857 *
2858 * @since 1.4.4
2859 */
2861
2862/**
2863 * Set the partition type of the MBR partition which represents the ISO
2864 * filesystem or at least protects it.
2865 * This is without effect if no such partition emerges by other settings or
2866 * if the partition type is prescribed mandatorily like 0xee for GPT protective
2867 * MBR or 0x96 for CHRP.
2868 * @param opts
2869 * The option set to be manipulated.
2870 * @param part_type
2871 * 0x00 to 0xff as desired partition type.
2872 * Any other value (e.g. -1) enables the default types of the various
2873 * occasions.
2874 * @return
2875 * ISO_SUCCESS or error
2876 * @since 1.4.8
2877 */
2879
2880/**
2881 * Set the GPT Type GUID for the partition which represents the ISO 9660
2882 * filesystem, if such a partition emerges in GPT.
2883 * @param opts
2884 * The option set to be manipulated.
2885 * @param guid
2886 * 16 bytes of user supplied GUID. Readily byte-swapped from the text
2887 * form as prescribed by UEFI specs:
2888 * 4 byte, 2 byte, 2 byte as little-endian.
2889 * 2 byte, 6 byte as big-endian.
2890 * @param valid
2891 * Set to 1 to make this Type GUID valid.
2892 * Set to 0 in order to invalidate a previously made setting. In this
2893 * case the setting of iso_write_opts_set_iso_mbr_part_type() or its
2894 * default will get into effect.
2895 * @return
2896 * ISO_SUCCESS or error
2897 *
2898 * @since 1.5.2
2899 */
2901 int valid);
2902
2903/**
2904 * Inquire the start address of the file data blocks after having used
2905 * IsoWriteOpts with iso_image_create_burn_source().
2906 * @param opts
2907 * The option set that was used when starting image creation
2908 * @param data_start
2909 * Returns the logical block address if it is already valid
2910 * @param flag
2911 * Reserved for future usage, set to 0.
2912 * @return
2913 * 1 indicates valid data_start, <0 indicates invalid data_start
2914 *
2915 * @since 0.6.16
2916 */
2917int iso_write_opts_get_data_start(IsoWriteOpts *opts, uint32_t *data_start,
2918 int flag);
2919
2920/**
2921 * Update the sizes of all files added to image.
2922 *
2923 * This may be called just before iso_image_create_burn_source() to force
2924 * libisofs to check the file sizes again (they're already checked when added
2925 * to IsoImage). It is useful if you have changed some files after adding then
2926 * to the image.
2927 *
2928 * @return
2929 * 1 on success, < 0 on error
2930 * @since 0.6.8
2931 */
2933
2934/**
2935 * Create a burn_source and a thread which immediately begins to generate
2936 * the image. That burn_source can be used with libburn as a data source
2937 * for a track. A copy of its public declaration in libburn.h can be found
2938 * further below in this text.
2939 *
2940 * If image generation shall be aborted by the application program, then
2941 * the .cancel() method of the burn_source must be called to end the
2942 * generation thread: burn_src->cancel(burn_src);
2943 *
2944 * @param image
2945 * The image to write.
2946 * @param opts
2947 * The options for image generation. All needed data will be copied, so
2948 * you can free the given struct once this function returns.
2949 * @param burn_src
2950 * Location where the pointer to the burn_source will be stored
2951 * @return
2952 * 1 on success, < 0 on error
2953 *
2954 * @since 0.6.2
2955 */
2957 struct burn_source **burn_src);
2958
2959/**
2960 * Inquire whether the image generator thread is still at work. As soon as the
2961 * reply is 0, the caller of iso_image_create_burn_source() may assume that
2962 * the image generation has ended.
2963 * Nevertheless there may still be readily formatted output data pending in
2964 * the burn_source or its consumers. So the final delivery of the image has
2965 * also to be checked at the data consumer side,e.g. by burn_drive_get_status()
2966 * in case of libburn as consumer.
2967 * @param image
2968 * The image to inquire.
2969 * @return
2970 * 1 generating of image stream is still in progress
2971 * 0 generating of image stream has ended meanwhile
2972 *
2973 * @since 0.6.38
2974 */
2976
2977/**
2978 * Creates an IsoReadOpts for reading an existent image. You should set the
2979 * options desired with the correspondent setters. Note that you may want to
2980 * set the start block value.
2981 *
2982 * Options by default are determined by the selected profile.
2983 *
2984 * @param opts
2985 * Pointer to the location where the newly created IsoReadOpts will be
2986 * stored. You should free it with iso_read_opts_free() when no more
2987 * needed.
2988 * @param profile
2989 * Default profile for image reading. For now the following values are
2990 * defined:
2991 * ---> 0 [STANDARD]
2992 * Suitable for most situations. Most extension are read. When both
2993 * Joliet and RR extension are present, RR is used.
2994 * AAIP for ACL and xattr is not enabled by default.
2995 * @return
2996 * 1 success, < 0 error
2997 *
2998 * @since 0.6.2
2999 */
3000int iso_read_opts_new(IsoReadOpts **opts, int profile);
3001
3002/**
3003 * Free an IsoReadOpts previously allocated with iso_read_opts_new().
3004 *
3005 * @since 0.6.2
3006 */
3008
3009/**
3010 * Set the block where the image begins. It is usually 0, but may be different
3011 * on a multisession disc.
3012 *
3013 * @since 0.6.2
3014 */
3016
3017/**
3018 * Do not read Rock Ridge extensions.
3019 * In most cases you don't want to use this. It could be useful if RR info
3020 * is damaged, or if you want to use the Joliet tree.
3021 *
3022 * @since 0.6.2
3023 */
3025
3026/**
3027 * Do not read Joliet extensions.
3028 *
3029 * @since 0.6.2
3030 */
3032
3033/**
3034 * Do not read ISO 9660:1999 enhanced tree
3035 *
3036 * @since 0.6.2
3037 */
3039
3040/**
3041 * Control reading of AAIP information about ACL and xattr when loading
3042 * existing images.
3043 * For importing ACL and xattr when inserting nodes from external filesystems
3044 * (e.g. the local POSIX filesystem) see iso_image_set_ignore_aclea().
3045 * For eventual writing of this information see iso_write_opts_set_aaip().
3046 *
3047 * @param opts
3048 * The option set to be manipulated
3049 * @param noaaip
3050 * 1 = Do not read AAIP information
3051 * 0 = Read AAIP information if available
3052 * All other values are reserved.
3053 * @since 0.6.14
3054 */
3056
3057/**
3058 * Control reading of an array of MD5 checksums which is eventually stored
3059 * at the end of a session. See also iso_write_opts_set_record_md5().
3060 * Important: Loading of the MD5 array will only work if AAIP is enabled
3061 * because its position and layout is recorded in xattr "isofs.ca".
3062 *
3063 * @param opts
3064 * The option set to be manipulated
3065 * @param no_md5
3066 * 0 = Read MD5 array if available, refuse on non-matching MD5 tags
3067 * 1 = Do not read MD5 checksum array
3068 * 2 = Read MD5 array, but do not check MD5 tags
3069 * @since 1.0.4
3070 * All other values are reserved.
3071 *
3072 * @since 0.6.22
3073 */
3075
3076
3077/**
3078 * Control discarding of eventual inode numbers from existing images.
3079 * Such numbers may come from RRIP 1.12 entries PX. If not discarded they
3080 * get written unchanged when the file object gets written into an ISO image.
3081 * If this inode number is missing with a file in the imported image,
3082 * or if it has been discarded during image reading, then a unique inode number
3083 * will be generated at some time before the file gets written into an ISO
3084 * image.
3085 * Two image nodes which have the same inode number represent two hardlinks
3086 * of the same file object. So discarding the numbers splits hardlinks.
3087 *
3088 * @param opts
3089 * The option set to be manipulated
3090 * @param new_inos
3091 * 1 = Discard imported inode numbers and finally hand out a unique new
3092 * one to each single file before it gets written into an ISO image.
3093 * 0 = Keep eventual inode numbers from PX entries.
3094 * All other values are reserved.
3095 * @since 0.6.20
3096 */
3098
3099/**
3100 * Whether to prefer Joliet over RR. libisofs usually prefers RR over
3101 * Joliet, as it give us much more info about files. So, if both extensions
3102 * are present, RR is used. You can set this if you prefer Joliet, but
3103 * note that this is not very recommended. This doesn't mean than RR
3104 * extensions are not read: if no Joliet is present, libisofs will read
3105 * RR tree.
3106 *
3107 * @since 0.6.2
3108 */
3109int iso_read_opts_set_preferjoliet(IsoReadOpts *opts, int preferjoliet);
3110
3111/**
3112 * How to convert file names if neither Rock Ridge nor Joliet names
3113 * are present and acceptable.
3114 *
3115 * @param opts
3116 * The option set to be manipulated
3117 * @param ecma119_map
3118 * The conversion mode to apply:
3119 * 0 = unmapped: Take name as recorded in ECMA-119 directory record
3120 * (not suitable for writing it to a new ISO filesystem)
3121 * 1 = stripped: Like unmapped, but strip off trailing ";1" or ".;1"
3122 * 2 = uppercase: Like stripped, but map {a-z} to {A-Z}
3123 * 3 = lowercase: Like stripped, but map {A-Z} to {a-z}
3124 * @return
3125 * ISO_SUCCESS if ecma119_map was accepted
3126 * 0 if the value was out of range
3127 * < 0 if other error
3128 *
3129 * @since 1.4.2
3130 */
3131int iso_read_opts_set_ecma119_map(IsoReadOpts *opts, int ecma119_map);
3132
3133/**
3134 * How to convert Joliet file names.
3135 *
3136 * @param opts
3137 * The option set to be manipulated
3138 * @param ecma119_map
3139 * The conversion mode to apply:
3140 * 0 = unmapped: Take name as recorded in Joliet directory record
3141 * (not suitable for writing it to a new ISO filesystem)
3142 * 1 = stripped: Strip off trailing ";1" or ".;1"
3143 * @return
3144 * ISO_SUCCESS if joliet_map was accepted
3145 * 0 if the value was out of range
3146 * < 0 if other error
3147 *
3148 * @since 1.5.4
3149 */
3151
3152/**
3153 * Set default uid for files when RR extensions are not present.
3154 *
3155 * @since 0.6.2
3156 */
3158
3159/**
3160 * Set default gid for files when RR extensions are not present.
3161 *
3162 * @since 0.6.2
3163 */
3165
3166/**
3167 * Set default permissions for files when RR extensions are not present.
3168 *
3169 * @param opts
3170 * The option set to be manipulated
3171 * @param file_perm
3172 * Permissions for files.
3173 * @param dir_perm
3174 * Permissions for directories.
3175 *
3176 * @since 0.6.2
3177 */
3179 mode_t dir_perm);
3180
3181/**
3182 * Set the input charset of the file names on the image. NULL to use locale
3183 * charset. You have to specify a charset if the image filenames are encoded
3184 * in a charset different that the local one. This could happen, for example,
3185 * if the image was created on a system with different charset.
3186 *
3187 * @param opts
3188 * The option set to be manipulated
3189 * @param charset
3190 * The charset to use as input charset. You can obtain the list of
3191 * charsets supported on your system executing "iconv -l" in a shell.
3192 *
3193 * @since 0.6.2
3194 */
3195int iso_read_opts_set_input_charset(IsoReadOpts *opts, const char *charset);
3196
3197/**
3198 * Enable or disable methods to automatically choose an input charset.
3199 * This eventually overrides the name set via iso_read_opts_set_input_charset()
3200 *
3201 * @param opts
3202 * The option set to be manipulated
3203 * @param mode
3204 * Bitfield for control purposes:
3205 * bit0= Allow to use the input character set name which is eventually
3206 * stored in attribute "isofs.cs" of the root directory.
3207 * Applications may attach this xattr by iso_node_set_attrs() to
3208 * the root node, call iso_write_opts_set_output_charset() with the
3209 * same name and enable iso_write_opts_set_aaip() when writing
3210 * an image.
3211 * Submit any other bits with value 0.
3212 *
3213 * @since 0.6.18
3214 *
3215 */
3217
3218/**
3219 * Enable or disable loading of the first 32768 bytes of the session.
3220 *
3221 * @param opts
3222 * The option set to be manipulated
3223 * @param mode
3224 * Bitfield for control purposes:
3225 * bit0= Load System Area data and attach them to the image so that they
3226 * get written by the next session, if not overridden by
3227 * iso_write_opts_set_system_area().
3228 * Submit any other bits with value 0.
3229 *
3230 * @since 0.6.30
3231 *
3232 */
3234
3235/**
3236 * Control whether to keep a reference to the IsoDataSource object which
3237 * allows access to the blocks of the imported ISO 9660 filesystem.
3238 * This is needed if the interval reader shall read from "imported_iso".
3239 *
3240 * @param opts
3241 * The option set to be manipulated
3242 * @param mode
3243 * Bitfield for control purposes:
3244 * bit0= Keep a reference to the IsoDataSource until the IsoImage object
3245 * gets disposed by its final iso_image_unref().
3246 * Submit any other bits with value 0.
3247 *
3248 * @since 1.4.0
3249 *
3250 */
3252
3253/**
3254 * Import a previous session or image, for growing or modify.
3255 *
3256 * @param image
3257 * The image context to which old image will be imported. Note that all
3258 * files added to image, and image attributes, will be replaced with the
3259 * contents of the old image.
3260 * TODO #00025 support for merging old image files
3261 * @param src
3262 * Data Source from which old image will be read. A extra reference is
3263 * added, so you still need to iso_data_source_unref() yours.
3264 * @param opts
3265 * Options for image import. All needed data will be copied, so you
3266 * can free the given struct once this function returns.
3267 * @param features
3268 * If not NULL, a new IsoReadImageFeatures will be allocated and filled
3269 * with the features of the old image. It should be freed with
3270 * iso_read_image_features_destroy() when no more needed. You can pass
3271 * NULL if you're not interested on them.
3272 * @return
3273 * 1 on success, < 0 on error
3274 *
3275 * @since 0.6.2
3276 */
3278 IsoReadImageFeatures **features);
3279
3280/**
3281 * Assess features of the importable directory trees of src and an estimation
3282 * of the write options which would cause the recognized features.
3283 * This goes deeper than the feature assessment of iso_image_import(), e.g. by
3284 * inspecting file names.
3285 *
3286 * For the parameters "src", "opts", and "features" see also the description of
3287 * iso_image_import().
3288 *
3289 * @param src
3290 * Data Source from which old image will be read.
3291 * @param opts
3292 * Options for image import. Settings about tree choice will be ignored.
3293 * @param features
3294 * Returns the pointer to a newly allocated and filled IsoReadImageFeatures
3295 * object. NULL is not allowed, other than with iso_image_import().
3296 * If *features is returned as non-NULL, then it should be freed with
3297 * iso_read_image_features_destroy() when no more needed.
3298 * @param write_opts
3299 * Returns the pointer to a newly allocated and filled IsoWriteOpts object.
3300 * If *write_opts is returned as non-NULL, then it should be freed with
3301 * iso_write_opts_free() when no more needed.
3302 *
3303 * @return
3304 * 1 on success, < 0 on error
3305 *
3306 * @since 1.5.6
3307 */
3309 IsoReadImageFeatures **features,
3310 IsoWriteOpts **write_opts);
3311
3312/**
3313 * Destroy an IsoReadImageFeatures object obtained with iso_image_import() or
3314 * iso_assess_written_features().
3315 *
3316 * @since 0.6.2
3317 */
3319
3320/**
3321 * Get the size (in 2048 byte block) of the image, as reported in the PVM.
3322 *
3323 * @since 0.6.2
3324 */
3326
3327/**
3328 * Whether RockRidge extensions are present in the image imported.
3329 *
3330 * @since 0.6.2
3331 */
3333
3334/**
3335 * Whether Joliet extensions are present in the image imported.
3336 *
3337 * @since 0.6.2
3338 */
3340
3341/**
3342 * Whether the image is recorded according to ISO 9660:1999, i.e. it has
3343 * a version 2 Enhanced Volume Descriptor.
3344 *
3345 * @since 0.6.2
3346 */
3348
3349/**
3350 * Whether El-Torito boot record is present present in the image imported.
3351 *
3352 * @since 0.6.2
3353 */
3355
3356/**
3357 * Tells what directory tree was loaded:
3358 * 0= ISO 9660 , 1 = Joliet , 2 = ISO 9660:1999
3359 *
3360 * @since 1.5.4
3361 */
3363
3364/**
3365 * Tells whether Rock Ridge information was used while loading the tree:
3366 * 1= yes, 0= no
3367 *
3368 * @since 1.5.4
3369 */
3371
3372/**
3373 * Get a named feature as text, num_value, or pt_value depending on its type.
3374 * The set of named features includes the features which can be inquired by
3375 * own iso_read_image_features_*() functions:
3376 * size See iso_read_image_features_get_size()
3377 * rockridge See iso_read_image_features_has_rockridge()
3378 * iso_write_opts_set_rockridge()
3379 * joliet See iso_read_image_features_has_joliet()
3380 * iso_write_opts_set_joliet()
3381 * iso1999 See iso_read_image_features_has_iso1999()
3382 * iso_write_opts_set_iso1999()
3383 * eltorito See iso_read_image_features_has_eltorito()
3384 * tree_loaded See iso_read_image_features_tree_loaded()
3385 * rr_loaded See iso_read_image_features_rr_loaded()
3386 * Other named features are:
3387 * tree_loaded_text Text form of "tree_loaded":
3388 * 0="ISO9660", 1="Joliet", 2="ISO9660:1999"
3389 * aaip 1=AAIP information was seen, 0= no AAIP seen
3390 * Detected traces of potential write option settings:
3391 * iso_level See iso_write_opts_set_iso_level()
3392 * untranslated_name_len See iso_write_opts_set_untranslated_name_len()
3393 * allow_dir_id_ext See iso_write_opts_set_allow_dir_id_ext()
3394 * omit_version_numbers See iso_write_opts_set_omit_version_numbers()
3395 * allow_deep_paths See iso_write_opts_set_allow_deep_paths()
3396 * allow_longer_paths See iso_write_opts_set_allow_longer_paths()
3397 * max_37_char_filenames See iso_write_opts_set_max_37_char_filenames()
3398 * no_force_dots See iso_write_opts_set_no_force_dots()
3399 * allow_lowercase See iso_write_opts_set_allow_lowercase()
3400 * allow_full_ascii See iso_write_opts_set_allow_full_ascii()
3401 * relaxed_vol_atts See iso_write_opts_set_relaxed_vol_atts()
3402 * joliet_longer_paths See iso_write_opts_set_joliet_longer_paths()
3403 * joliet_long_names See iso_write_opts_set_joliet_long_names()
3404 * joliet_utf16 See iso_write_opts_set_joliet_utf16()
3405 * rrip_version_1_10 See iso_write_opts_set_rrip_version_1_10()
3406 * rrip_1_10_px_ino See iso_write_opts_set_rrip_1_10_px_ino()
3407 * aaip_susp_1_10 See iso_write_opts_set_aaip_susp_1_10()
3408 * record_md5_session See iso_write_opts_set_record_md5() param session
3409 * record_md5_files See iso_write_opts_set_record_md5() param files
3410 *
3411 * @param f
3412 * A features object returned by iso_image_import() or
3413 * iso_assess_written_features().
3414 * @param name
3415 * The name of the feature to be inquired.
3416 * @param text
3417 * If text is not NULL, *text returns a textual representation of the
3418 * reply. Dispose *text by free(2) when no longer needed.
3419 * @param type
3420 * Returns which of num_value or pt_value is valid:
3421 * 0= *num_value is valid
3422 * 1= *pt_value is valid
3423 * @param num_value
3424 * Returns the numerical value of the feature if type == 0.
3425 * @param pt_value
3426 * Returns a pointer to a memory area inside the features object if type
3427 * is 1. The area is not necessarily 0-terminated.
3428 * Do _not_ dispose *pt_value and do not use it after f was disposed.
3429 * @param pt_size
3430 * Returns the size of the pt_value memory area if type is 1.
3431 * This counting includes a terminating 0-byte if it is present.
3432 * @return
3433 * 0 = Feature was not yet examined. Reply is not valid.
3434 * 1 = Reply is valid
3435 * ISO_UNDEF_READ_FEATURE = Given name is not known
3436 * <0 = other error
3437 *
3438 * @since 1.5.6
3439 */
3441 char **text, int *type,
3442 int64_t *num_value, void **pt_value,
3443 size_t *pt_size);
3444
3445/**
3446 * Get all validly assessed named features as one single 0-terminated string
3447 * consisting of single lines for each feature.
3448 *
3449 * @param f
3450 * A features object returned by iso_image_import() or
3451 * iso_assess_written_features().
3452 * @param with_values
3453 * If set to 1: return lines of form name=value\n
3454 * If set to 0: return lines of form name\n
3455 * @param feature_text
3456 * Returns the result string. Dispose by free(2) when no longer needed.
3457 * @return
3458 * 1 = result is valid, <0 indicates error
3459 *
3460 * @since 1.5.6
3461 */
3463 char **feature_text);
3464
3465/**
3466 * Increments the reference counting of the given image.
3467 *
3468 * @since 0.6.2
3469 */
3471
3472/**
3473 * Decrements the reference counting of the given image.
3474 * If it reaches 0, the image is free, together with its tree nodes (whether
3475 * their refcount reach 0 too, of course).
3476 *
3477 * @since 0.6.2
3478 */
3480
3481/**
3482 * Attach user defined data to the image. Use this if your application needs
3483 * to store addition info together with the IsoImage. If the image already
3484 * has data attached, the old data will be freed.
3485 *
3486 * @param image
3487 * The image to which data shall be attached.
3488 * @param data
3489 * Pointer to application defined data that will be attached to the
3490 * image. You can pass NULL to remove any already attached data.
3491 * @param give_up
3492 * Function that will be called when the image does not need the data
3493 * any more. It receives the data pointer as an argumente, and eventually
3494 * causes data to be freed. It can be NULL if you don't need it.
3495 * @return
3496 * 1 on success, < 0 on error
3497 *
3498 * @since 0.6.2
3499 */
3500int iso_image_attach_data(IsoImage *image, void *data, void (*give_up)(void*));
3501
3502/**
3503 * The the data previously attached with iso_image_attach_data()
3504 *
3505 * @since 0.6.2
3506 */
3508
3509/**
3510 * Set the name truncation mode and the maximum name length for nodes from
3511 * image importing, creation of new IsoNode objects, and name changing image
3512 * manipulations.
3513 *
3514 * Truncated names are supposed to be nearly unique because they end by the MD5
3515 * of the first 4095 characters of the untruncated name. One should treat them
3516 * as if they were the untruncated original names.
3517 *
3518 * For proper processing of truncated names it is necessary to use
3519 * iso_image_set_node_name() instead of iso_node_set_name()
3520 * iso_image_add_new_dir() iso_tree_add_new_dir()
3521 * iso_image_add_new_file() iso_tree_add_new_file()
3522 * iso_image_add_new_special() iso_tree_add_new_special()
3523 * iso_image_add_new_symlink() iso_tree_add_new_symlink()
3524 * iso_image_tree_clone() iso_tree_clone()
3525 * iso_image_dir_get_node() iso_dir_get_node()
3526 * iso_image_path_to_node() iso_tree_path_to_node()
3527 *
3528 * Beware of ambiguities if both, the full name and the truncated name,
3529 * exist in the same directory. Best is to only set truncation parameters
3530 * once with an ISO filesystem and to never change them later.
3531 *
3532 * If writing of AAIP is enabled, then the mode and length are recorded in
3533 * xattr "isofs.nt" of the root node.
3534 * If reading of AAIP is enabled and "isofs.nt" is found, then it gets into
3535 * effect if both, the truncate mode value from "isofs.nt" and the current
3536 * truncate mode of the IsoImage are 1, and the length is between 64 and 255.
3537 *
3538 * @param img
3539 * The image which shall be manipulated.
3540 * @param mode
3541 * 0= Do not truncate but throw error ISO_RR_NAME_TOO_LONG if a file name
3542 * is longer than parameter length.
3543 * 1= Truncate to length and overwrite the last 33 bytes of that length
3544 * by a colon ':' and the hex representation of the MD5 of the first
3545 * 4095 bytes of the whole oversized name.
3546 * Potential incomplete UTF-8 characters will get their leading bytes
3547 * replaced by '_'.
3548 * Mode 1 is the default.
3549 * @param length
3550 * Maximum byte count of a file name. Permissible values are 64 to 255.
3551 * Default is 255.
3552 * @return
3553 * ISO_SUCCESS or ISO_WRONG_ARG_VALUE
3554 *
3555 * @since 1.4.2
3556 */
3557int iso_image_set_truncate_mode(IsoImage *img, int mode, int length);
3558
3559/**
3560 * Inquire the current setting of iso_image_set_truncate_mode().
3561 *
3562 * @param img
3563 * The image which shall be inquired.
3564 * @param mode
3565 * Returns the mode value.
3566 * @param length
3567 * Returns the length value.
3568 * @return
3569 * ISO_SUCCESS or <0 = error
3570 *
3571 * @since 1.4.2
3572 */
3573int iso_image_get_truncate_mode(IsoImage *img, int *mode, int *length);
3574
3575/**
3576 * Immediately apply the given truncate mode and length to the given string.
3577 *
3578 * @param mode
3579 * See iso_image_set_truncate_mode()
3580 * @param length
3581 * See iso_image_set_truncate_mode()
3582 * @param name
3583 * The string to be inspected and truncated if mode says so.
3584 * @param flag
3585 * Bitfield for control purposes. Unused yet. Submit 0.
3586 * @return
3587 * ISO_SUCCESS, ISO_WRONG_ARG_VALUE, ISO_RR_NAME_TOO_LONG
3588 *
3589 * @since 1.4.2
3590 */
3591int iso_truncate_leaf_name(int mode, int length, char *name, int flag);
3592
3593/**
3594 * Get the root directory of the image.
3595 * No extra ref is added to it, so you must not unref it. Use iso_node_ref()
3596 * if you want to get your own reference.
3597 *
3598 * @since 0.6.2
3599 */
3601
3602/**
3603 * Fill in the volset identifier for a image.
3604 *
3605 * @since 0.6.2
3606 */
3607void iso_image_set_volset_id(IsoImage *image, const char *volset_id);
3608
3609/**
3610 * Get the volset identifier.
3611 * The returned string is owned by the image and must not be freed nor
3612 * changed.
3613 *
3614 * @since 0.6.2
3615 */
3616const char *iso_image_get_volset_id(const IsoImage *image);
3617
3618/**
3619 * Fill in the volume identifier for a image.
3620 *
3621 * @since 0.6.2
3622 */
3623void iso_image_set_volume_id(IsoImage *image, const char *volume_id);
3624
3625/**
3626 * Get the volume identifier.
3627 * The returned string is owned by the image and must not be freed nor
3628 * changed.
3629 *
3630 * @since 0.6.2
3631 */
3632const char *iso_image_get_volume_id(const IsoImage *image);
3633
3634/**
3635 * Fill in the publisher for a image.
3636 *
3637 * @since 0.6.2
3638 */
3639void iso_image_set_publisher_id(IsoImage *image, const char *publisher_id);
3640
3641/**
3642 * Get the publisher of a image.
3643 * The returned string is owned by the image and must not be freed nor
3644 * changed.
3645 *
3646 * @since 0.6.2
3647 */
3648const char *iso_image_get_publisher_id(const IsoImage *image);
3649
3650/**
3651 * Fill in the data preparer for a image.
3652 *
3653 * @since 0.6.2
3654 */
3656 const char *data_preparer_id);
3657
3658/**
3659 * Get the data preparer of a image.
3660 * The returned string is owned by the image and must not be freed nor
3661 * changed.
3662 *
3663 * @since 0.6.2
3664 */
3666
3667/**
3668 * Fill in the system id for a image. Up to 32 characters.
3669 *
3670 * @since 0.6.2
3671 */
3672void iso_image_set_system_id(IsoImage *image, const char *system_id);
3673
3674/**
3675 * Get the system id of a image.
3676 * The returned string is owned by the image and must not be freed nor
3677 * changed.
3678 *
3679 * @since 0.6.2
3680 */
3681const char *iso_image_get_system_id(const IsoImage *image);
3682
3683/**
3684 * Fill in the application id for a image. Up to 128 chars.
3685 *
3686 * @since 0.6.2
3687 */
3688void iso_image_set_application_id(IsoImage *image, const char *application_id);
3689
3690/**
3691 * Get the application id of a image.
3692 * The returned string is owned by the image and must not be freed nor
3693 * changed.
3694 *
3695 * @since 0.6.2
3696 */
3697const char *iso_image_get_application_id(const IsoImage *image);
3698
3699/**
3700 * Fill copyright information for the image. Usually this refers
3701 * to a file on disc. Up to 37 characters.
3702 *
3703 * @since 0.6.2
3704 */
3706 const char *copyright_file_id);
3707
3708/**
3709 * Get the copyright information of a image.
3710 * The returned string is owned by the image and must not be freed nor
3711 * changed.
3712 *
3713 * @since 0.6.2
3714 */
3716
3717/**
3718 * Fill abstract information for the image. Usually this refers
3719 * to a file on disc. Up to 37 characters.
3720 *
3721 * @since 0.6.2
3722 */
3724 const char *abstract_file_id);
3725
3726/**
3727 * Get the abstract information of a image.
3728 * The returned string is owned by the image and must not be freed nor
3729 * changed.
3730 *
3731 * @since 0.6.2
3732 */
3734
3735/**
3736 * Fill biblio information for the image. Usually this refers
3737 * to a file on disc. Up to 37 characters.
3738 *
3739 * @since 0.6.2
3740 */
3741void iso_image_set_biblio_file_id(IsoImage *image, const char *biblio_file_id);
3742
3743/**
3744 * Get the biblio information of a image.
3745 * The returned string is owned by the image and must not be freed or changed.
3746 *
3747 * @since 0.6.2
3748 */
3749const char *iso_image_get_biblio_file_id(const IsoImage *image);
3750
3751/**
3752 * Fill Application Use field of the Primary Volume Descriptor.
3753 * ECMA-119 8.4.32 Application Use (BP 884 to 1395)
3754 * "This field shall be reserved for application use. Its content
3755 * is not specified by this Standard."
3756 *
3757 * @param image
3758 * The image to manipulate.
3759 * @param app_use_data
3760 * Up to 512 bytes of data.
3761 * @param count
3762 * The number of bytes in app_use_data. If the number is smaller than 512,
3763 * then the remaining bytes will be set to 0.
3764 * @since 1.3.2
3765 */
3766void iso_image_set_app_use(IsoImage *image, const char *app_use_data,
3767 int count);
3768
3769/**
3770 * Get the current setting for the Application Use field of the Primary Volume
3771 * Descriptor.
3772 * The returned char array of 512 bytes is owned by the image and must not
3773 * be freed or changed.
3774 *
3775 * @param image
3776 * The image to inquire
3777 * @since 1.3.2
3778 */
3780
3781/**
3782 * Get the four timestamps from the Primary Volume Descriptor of the imported
3783 * ISO image. The timestamps are strings which are either empty or consist
3784 * of 16 digits of the form YYYYMMDDhhmmsscc, plus a signed byte in the range
3785 * of -48 to +52, which gives the timezone offset in steps of 15 minutes.
3786 * None of the returned string pointers shall be used for altering or freeing
3787 * data. They are just for reading.
3788 *
3789 * @param image
3790 * The image to be inquired.
3791 * @param creation_time
3792 * Returns a pointer to the Volume Creation time:
3793 * When "the information in the volume was created."
3794 * @param modification_time
3795 * Returns a pointer to Volume Modification time:
3796 * When "the information in the volume was last modified."
3797 * @param expiration_time
3798 * Returns a pointer to Volume Expiration time:
3799 * When "the information in the volume may be regarded as obsolete."
3800 * @param effective_time
3801 * Returns a pointer to Volume Expiration time:
3802 * When "the information in the volume may be used."
3803 * @return
3804 * ISO_SUCCESS or error
3805 *
3806 * @since 1.2.8
3807 */
3809 char **creation_time, char **modification_time,
3810 char **expiration_time, char **effective_time);
3811
3812/**
3813 * Create a new set of El-Torito bootable images by adding a boot catalog
3814 * and the default boot image.
3815 * Further boot images may then be added by iso_image_add_boot_image().
3816 *
3817 * @param image
3818 * The image to make bootable. If it was already bootable this function
3819 * returns an error and the image remains unmodified.
3820 * @param image_path
3821 * The absolute path of a IsoFile to be used as default boot image or
3822 * --interval:appended_partition_$number[_start_$start_size_$size]:...
3823 * if type is ELTORITO_NO_EMUL. $number gives the partition number.
3824 * If _start_$start_size_$size is present, then it overrides the 2 KiB
3825 * start block of the partition and the partition size counted in
3826 * blocks of 512 bytes.
3827 * @param type
3828 * The boot media type. This can be one of 3 types:
3829 * - ELTORITO_FLOPPY_EMUL.
3830 * Floppy emulation: Boot image file must be exactly
3831 * 1200 KiB, 1440 KiB or 2880 KiB.
3832 * - ELTORITO_HARD_DISC_EMUL.
3833 * Hard disc emulation: The image must begin with a master
3834 * boot record with a single image.
3835 * - ELTORITO_NO_EMUL.
3836 * No emulation. You should specify load segment and load size
3837 * of image.
3838 * @param catalog_path
3839 * The absolute path in the image tree where the catalog will be stored.
3840 * The directory component of this path must be a directory existent on
3841 * the image tree, and the filename component must be unique among all
3842 * children of that directory on image. Otherwise a correspodent error
3843 * code will be returned. This function will add an IsoBoot node that acts
3844 * as a placeholder for the real catalog, that will be generated at image
3845 * creation time.
3846 * @param boot
3847 * Location where a pointer to the added boot image will be stored. That
3848 * object is owned by the IsoImage and must not be freed by the user,
3849 * nor dereferenced once the last reference to the IsoImage was disposed
3850 * via iso_image_unref(). A NULL value is allowed if you don't need a
3851 * reference to the boot image.
3852 * @return
3853 * 1 on success, < 0 on error
3854 *
3855 * @since 0.6.2
3856 */
3857int iso_image_set_boot_image(IsoImage *image, const char *image_path,
3858 enum eltorito_boot_media_type type,
3859 const char *catalog_path,
3860 ElToritoBootImage **boot);
3861
3862/**
3863 * Add a further boot image to the set of El-Torito bootable images.
3864 * This set has already to be created by iso_image_set_boot_image().
3865 * Up to 31 further boot images may be added.
3866 *
3867 * @param image
3868 * The image to which the boot image shall be added.
3869 * returns an error and the image remains unmodified.
3870 * @param image_path
3871 * The absolute path of a IsoFile to be used as boot image or
3872 * --interval:appended_partition_$number[_start_$start_size_$size]:...
3873 * if type is ELTORITO_NO_EMUL. See iso_image_set_boot_image.
3874 * @param type
3875 * The boot media type. See iso_image_set_boot_image.
3876 * @param flag
3877 * Bitfield for control purposes. Unused yet. Submit 0.
3878 * @param boot
3879 * Location where a pointer to the added boot image will be stored.
3880 * See iso_image_set_boot_image
3881 * @return
3882 * 1 on success, < 0 on error
3883 * ISO_BOOT_NO_CATALOG means iso_image_set_boot_image()
3884 * was not called first.
3885 *
3886 * @since 0.6.32
3887 */
3888int iso_image_add_boot_image(IsoImage *image, const char *image_path,
3889 enum eltorito_boot_media_type type, int flag,
3890 ElToritoBootImage **boot);
3891
3892/**
3893 * Get the El-Torito boot catalog and the default boot image of an ISO image.
3894 *
3895 * This can be useful, for example, to check if a volume read from a previous
3896 * session or an existing image is bootable. It can also be useful to get
3897 * the image and catalog tree nodes. An application would want those, for
3898 * example, to prevent the user removing it.
3899 *
3900 * Both nodes are owned by libisofs and must not be freed. You can get your
3901 * own ref with iso_node_ref(). You can also check if the node is already
3902 * on the tree by getting its parent (note that when reading El-Torito info
3903 * from a previous image, the nodes might not be on the tree even if you haven't
3904 * removed them). Remember that you'll need to get a new ref
3905 * (with iso_node_ref()) before inserting them again to the tree, and probably
3906 * you will also need to set the name or permissions.
3907 *
3908 * @param image
3909 * The image from which to get the boot image.
3910 * @param boot
3911 * If not NULL, it will be filled with a pointer to the boot image, if
3912 * any. That object is owned by the IsoImage and must not be freed by
3913 * the user, nor dereferenced once the last reference to the IsoImage was
3914 * disposed via iso_image_unref().
3915 * @param imgnode
3916 * When not NULL, it will be filled with the image tree node. No extra ref
3917 * is added, you can use iso_node_ref() to get one if you need it.
3918 * The returned value is NULL if the boot image source is no IsoFile.
3919 * @param catnode
3920 * When not NULL, it will be filled with the catnode tree node. No extra
3921 * ref is added, you can use iso_node_ref() to get one if you need it.
3922 * @return
3923 * 1 on success, 0 is the image is not bootable (i.e., it has no El-Torito
3924 * image), < 0 error.
3925 *
3926 * @since 0.6.2
3927 */
3929 IsoFile **imgnode, IsoBoot **catnode);
3930
3931/**
3932 * Get detailed information about the boot catalog that was loaded from
3933 * an ISO image.
3934 * The boot catalog links the El Torito boot record at LBA 17 with the
3935 * boot images which are IsoFile objects in the image. The boot catalog
3936 * itself is not a regular file and thus will not deliver an IsoStream.
3937 * Its content is usually quite short and can be obtained by this call.
3938 *
3939 * @param image
3940 * The image to inquire.
3941 * @param catnode
3942 * Will return the boot catalog tree node. No extra ref is taken.
3943 * @param lba
3944 * Will return the block address of the boot catalog in the image.
3945 * @param content
3946 * Will return either NULL or an allocated memory buffer with the
3947 * content bytes of the boot catalog.
3948 * Dispose it by free() when no longer needed.
3949 * @param size
3950 * Will return the number of bytes in content.
3951 * @return
3952 * 1 if reply is valid, 0 if not boot catalog was loaded, < 0 on error.
3953 *
3954 * @since 1.1.2
3955 */
3956int iso_image_get_bootcat(IsoImage *image, IsoBoot **catnode, uint32_t *lba,
3957 char **content, off_t *size);
3958
3959
3960/**
3961 * Get all El-Torito boot images of an ISO image.
3962 *
3963 * The first of these boot images is the same as returned by
3964 * iso_image_get_boot_image(). The others are alternative boot images.
3965 *
3966 * @param image
3967 * The image from which to get the boot images.
3968 * @param num_boots
3969 * The number of available array elements in boots and bootnodes.
3970 * @param boots
3971 * Returns NULL or an allocated array of pointers to boot images.
3972 * Apply system call free(boots) to dispose it.
3973 * @param bootnodes
3974 * Returns NULL or an allocated array of pointers to the IsoFile nodes
3975 * which bear the content of the boot images in boots.
3976 * An array entry is NULL if the boot image source is no IsoFile.
3977
3978>>> Need getter for partition index
3979
3980 * @param flag
3981 * Bitfield for control purposes. Unused yet. Submit 0.
3982 * @return
3983 * 1 on success, 0 no El-Torito catalog and boot image attached,
3984 * < 0 error.
3985 *
3986 * @since 0.6.32
3987 */
3988int iso_image_get_all_boot_imgs(IsoImage *image, int *num_boots,
3989 ElToritoBootImage ***boots, IsoFile ***bootnodes, int flag);
3990
3991
3992/**
3993 * Removes all El-Torito boot images from the ISO image.
3994 *
3995 * The IsoBoot node that acts as placeholder for the catalog is also removed
3996 * for the image tree, if there.
3997 * If the image is not bootable (don't have el-torito boot image) this function
3998 * just returns.
3999 *
4000 * @since 0.6.2
4001 */
4003
4004/**
4005 * Sets the sort weight of the boot catalog that is attached to an IsoImage.
4006 *
4007 * For the meaning of sort weights see iso_node_set_sort_weight().
4008 * That function cannot be applied to the emerging boot catalog because
4009 * it is not represented by an IsoFile.
4010 *
4011 * @param image
4012 * The image to manipulate.
4013 * @param sort_weight
4014 * The larger this value, the lower will be the block address of the
4015 * boot catalog record.
4016 * @return
4017 * 0= no boot catalog attached , 1= ok , <0 = error
4018 *
4019 * @since 0.6.32
4020 */
4021int iso_image_set_boot_catalog_weight(IsoImage *image, int sort_weight);
4022
4023/**
4024 * Hides the boot catalog file from directory trees.
4025 *
4026 * For the meaning of hiding files see iso_node_set_hidden().
4027 *
4028 *
4029 * @param image
4030 * The image to manipulate.
4031 * @param hide_attrs
4032 * Or-combination of values from enum IsoHideNodeFlag to set the trees
4033 * in which the record.
4034 * @return
4035 * 0= no boot catalog attached , 1= ok , <0 = error
4036 *
4037 * @since 0.6.34
4038 */
4040
4041
4042/**
4043 * Get the boot media type as of parameter "type" of iso_image_set_boot_image()
4044 * or iso_image_add_boot_image().
4045 *
4046 * @param bootimg
4047 * The image to inquire
4048 * @param media_type
4049 * Returns the media type
4050 * @return
4051 * 1 = ok , < 0 = error
4052 *
4053 * @since 0.6.32
4054 */
4056 enum eltorito_boot_media_type *media_type);
4057
4058/**
4059 * Sets the platform ID of the boot image.
4060 *
4061 * The Platform ID gets written into the boot catalog at byte 1 of the
4062 * Validation Entry, or at byte 1 of a Section Header Entry.
4063 * If Platform ID and ID String of two consecutive bootimages are the same
4064 *
4065 * @param bootimg
4066 * The image to manipulate.
4067 * @param id
4068 * A Platform ID as of
4069 * El Torito 1.0 : 0x00= 80x86, 0x01= PowerPC, 0x02= Mac
4070 * Others : 0xef= EFI
4071 * @return
4072 * 1 ok , <=0 error
4073 *
4074 * @since 0.6.32
4075 */
4077
4078/**
4079 * Get the platform ID value. See el_torito_set_boot_platform_id().
4080 *
4081 * @param bootimg
4082 * The image to inquire
4083 * @return
4084 * 0 - 255 : The platform ID
4085 * < 0 : error
4086 *
4087 * @since 0.6.32
4088 */
4090
4091/**
4092 * Sets the load segment for the initial boot image. This is only for
4093 * no emulation boot images, and is a NOP for other image types.
4094 *
4095 * @param bootimg
4096 * The image to to manipulate
4097 * @param segment
4098 * Load segment address.
4099 * The data type of this parameter is not fully suitable. You may submit
4100 * negative numbers in the range ((short) 0x8000) to ((short) 0xffff)
4101 * in order to express the non-negative numbers 0x8000 to 0xffff.
4102 *
4103 * @since 0.6.2
4104 */
4105void el_torito_set_load_seg(ElToritoBootImage *bootimg, short segment);
4106
4107/**
4108 * Get the load segment value. See el_torito_set_load_seg().
4109 *
4110 * @param bootimg
4111 * The image to inquire
4112 * @return
4113 * 0 - 65535 : The load segment value
4114 * < 0 : error
4115 *
4116 * @since 0.6.32
4117 */
4119
4120/**
4121 * Sets the number of sectors (512b) to be load at load segment during
4122 * the initial boot procedure. This is only for
4123 * no emulation boot images, and is a NOP for other image types.
4124 *
4125 * @param bootimg
4126 * The image to to manipulate
4127 * @param sectors
4128 * Number of 512-byte blocks to be loaded by the BIOS.
4129 * The data type of this parameter is not fully suitable. You may submit
4130 * negative numbers in the range ((short) 0x8000) to ((short) 0xffff)
4131 * in order to express the non-negative numbers 0x8000 to 0xffff.
4132 *
4133 * @since 0.6.2
4134 */
4135void el_torito_set_load_size(ElToritoBootImage *bootimg, short sectors);
4136
4137/**
4138 * Get the load size. See el_torito_set_load_size().
4139 *
4140 * @param bootimg
4141 * The image to inquire
4142 * @return
4143 * 0 - 65535 : The load size value
4144 * < 0 : error
4145 *
4146 * @since 0.6.32
4147 */
4149
4150/**
4151 * State that the load size shall be the size of the boot image automatically.
4152 * This overrides el_torito_set_load_size().
4153 * @param bootimg
4154 * The image to to manipulate
4155 * @param mode
4156 * 0= use value of el_torito_set_load_size()
4157 * 1= determine value from boot image
4158 */
4160
4161/**
4162 * Inquire the setting of el_torito_set_full_load().
4163 * @param bootimg
4164 * The image to inquire
4165 * @return
4166 * The mode set with el_torito_set_full_load().
4167 */
4169
4170/**
4171 * Marks the specified boot image as not bootable
4172 *
4173 * @since 0.6.2
4174 */
4176
4177/**
4178 * Get the bootability flag. See el_torito_set_no_bootable().
4179 *
4180 * @param bootimg
4181 * The image to inquire
4182 * @return
4183 * 0 = not bootable, 1 = bootable , <0 = error
4184 *
4185 * @since 0.6.32
4186 */
4188
4189/**
4190 * Set the id_string of the Validation Entry or Sector Header Entry which
4191 * will govern the boot image Section Entry in the El Torito Catalog.
4192 *
4193 * @param bootimg
4194 * The image to manipulate.
4195 * @param id_string
4196 * The first boot image puts 24 bytes of ID string into the Validation
4197 * Entry, where they shall "identify the manufacturer/developer of
4198 * the CD-ROM".
4199 * Further boot images put 28 bytes into their Section Header.
4200 * El Torito 1.0 states that "If the BIOS understands the ID string, it
4201 * may choose to boot the system using one of these entries in place
4202 * of the INITIAL/DEFAULT entry." (The INITIAL/DEFAULT entry points to the
4203 * first boot image.)
4204 * @return
4205 * 1 = ok , <0 = error
4206 *
4207 * @since 0.6.32
4208 */
4209int el_torito_set_id_string(ElToritoBootImage *bootimg, uint8_t id_string[28]);
4210
4211/**
4212 * Get the id_string as of el_torito_set_id_string().
4213 *
4214 * @param bootimg
4215 * The image to inquire
4216 * @param id_string
4217 * Returns 28 bytes of id string
4218 * @return
4219 * 1 = ok , <0 = error
4220 *
4221 * @since 0.6.32
4222 */
4223int el_torito_get_id_string(ElToritoBootImage *bootimg, uint8_t id_string[28]);
4224
4225/**
4226 * Set the Selection Criteria of a boot image.
4227 *
4228 * @param bootimg
4229 * The image to manipulate.
4230 * @param crit
4231 * The first boot image has no selection criteria. They will be ignored.
4232 * Further boot images put 1 byte of Selection Criteria Type and 19
4233 * bytes of data into their Section Entry.
4234 * El Torito 1.0 states that "The format of the selection criteria is
4235 * a function of the BIOS vendor. In the case of a foreign language
4236 * BIOS three bytes would be used to identify the language".
4237 * Type byte == 0 means "no criteria",
4238 * type byte == 1 means "Language and Version Information (IBM)".
4239 * @return
4240 * 1 = ok , <0 = error
4241 *
4242 * @since 0.6.32
4243 */
4244int el_torito_set_selection_crit(ElToritoBootImage *bootimg, uint8_t crit[20]);
4245
4246/**
4247 * Get the Selection Criteria bytes as of el_torito_set_selection_crit().
4248 *
4249 * @param bootimg
4250 * The image to inquire
4251 * @param crit
4252 * Returns 20 bytes of type and data
4253 * @return
4254 * 1 = ok , <0 = error
4255 *
4256 * @since 0.6.32
4257 */
4258int el_torito_get_selection_crit(ElToritoBootImage *bootimg, uint8_t crit[20]);
4259
4260
4261/**
4262 * Makes a guess whether the boot image was patched by a boot information
4263 * table. It is advisable to patch such boot images if their content gets
4264 * copied to a new location. See el_torito_set_isolinux_options().
4265 * Note: The reply can be positive only if the boot image was imported
4266 * from an existing ISO image.
4267 *
4268 * @param bootimg
4269 * The image to inquire
4270 * @param flag
4271 * Bitfield for control purposes:
4272 * bit0 - bit3= mode
4273 * 0 = inquire for classic boot info table as described in man mkisofs
4274 * @since 0.6.32
4275 * 1 = inquire for GRUB2 boot info as of bit9 of options of
4276 * el_torito_set_isolinux_options()
4277 * @since 1.3.0
4278 * @return
4279 * 1 = seems to contain the inquired boot info, 0 = quite surely not
4280 * @since 0.6.32
4281 */
4283
4284/**
4285 * Specifies options for ISOLINUX or GRUB boot images. This should only be used
4286 * if the type of boot image is known.
4287 *
4288 * @param bootimg
4289 * The image to set options on
4290 * @param options
4291 * bitmask style flag. The following values are defined:
4292 *
4293 * bit0= Patch the boot info table of the boot image.
4294 * This does the same as mkisofs option -boot-info-table.
4295 * Needed for ISOLINUX or GRUB boot images with platform ID 0.
4296 * The table is located at byte 8 of the boot image file.
4297 * Its size is 56 bytes.
4298 * The original boot image file on disk will not be modified.
4299 *
4300 * One may use el_torito_seems_boot_info_table() for a
4301 * qualified guess whether a boot info table is present in
4302 * the boot image. If the result is 1 then it should get bit0
4303 * set if its content gets copied to a new LBA.
4304 *
4305 * bit1= Generate a ISOLINUX isohybrid image with MBR.
4306 * ----------------------------------------------------------
4307 * @deprecated since 31 Mar 2010:
4308 * The author of syslinux, H. Peter Anvin requested that this
4309 * feature shall not be used any more. He intends to cease
4310 * support for the MBR template that is included in libisofs.
4311 * ----------------------------------------------------------
4312 * A hybrid image is a boot image that boots from either
4313 * CD/DVD media or from disk-like media, e.g. USB stick.
4314 * For that you need isolinux.bin from SYSLINUX 3.72 or later.
4315 * IMPORTANT: The application has to take care that the image
4316 * on media gets padded up to the next full MB.
4317 * Under seiveral circumstances it might get aligned
4318 * automatically. But there is no warranty.
4319 * bit2-7= Mentioning in isohybrid GPT
4320 * 0= Do not mention in GPT
4321 * 1= Mention as Basic Data partition.
4322 * This cannot be combined with GPT partitions as of
4323 * iso_write_opts_set_efi_bootp()
4324 * @since 1.2.4
4325 * 2= Mention as HFS+ partition.
4326 * This cannot be combined with HFS+ production by
4327 * iso_write_opts_set_hfsplus().
4328 * @since 1.2.4
4329 * Primary GPT and backup GPT get written if at least one
4330 * ElToritoBootImage shall be mentioned.
4331 * The first three mentioned GPT partitions get mirrored in the
4332 * the partition table of the isohybrid MBR. They get type 0xfe.
4333 * The MBR partition entry for PC-BIOS gets type 0x00 rather
4334 * than 0x17.
4335 * Often it is one of the further MBR partitions which actually
4336 * gets used by EFI.
4337 * @since 1.2.4
4338 * bit8= Mention in isohybrid Apple partition map
4339 * APM get written if at least one ElToritoBootImage shall be
4340 * mentioned. The ISOLINUX MBR must look suitable or else an error
4341 * event will happen at image generation time.
4342 * @since 1.2.4
4343 * bit9= GRUB2 boot info
4344 * Patch the boot image file at byte 1012 with the 512-block
4345 * address + 2. Two little endian 32-bit words. Low word first.
4346 * This is combinable with bit0.
4347 * @since 1.3.0
4348 * @param flag
4349 * Reserved for future usage, set to 0.
4350 * @return
4351 * 1 success, < 0 on error
4352 * @since 0.6.12
4353 */
4355 int options, int flag);
4356
4357/**
4358 * Get the options as of el_torito_set_isolinux_options().
4359 *
4360 * @param bootimg
4361 * The image to inquire
4362 * @param flag
4363 * Reserved for future usage, set to 0.
4364 * @return
4365 * >= 0 returned option bits , <0 = error
4366 *
4367 * @since 0.6.32
4368 */
4370
4371/** Deprecated:
4372 * Specifies that this image needs to be patched. This involves the writing
4373 * of a 16 bytes boot information table at offset 8 of the boot image file.
4374 * The original boot image file won't be modified.
4375 * This is needed for isolinux boot images.
4376 *
4377 * @since 0.6.2
4378 * @deprecated Use el_torito_set_isolinux_options() instead
4379 */
4381
4382/**
4383 * Obtain a copy of the eventually loaded first 32768 bytes of the imported
4384 * session, the System Area.
4385 * It will be written to the start of the next session unless it gets
4386 * overwritten by iso_write_opts_set_system_area().
4387 *
4388 * @param img
4389 * The image to be inquired.
4390 * @param data
4391 * A byte array of at least 32768 bytes to take the loaded bytes.
4392 * @param options
4393 * The option bits which will be applied if not overridden by
4394 * iso_write_opts_set_system_area(). See there.
4395 * @param flag
4396 * Bitfield for control purposes, unused yet, submit 0
4397 * @return
4398 * 1 on success, 0 if no System Area was loaded, < 0 error.
4399 * @since 0.6.30
4400 */
4401int iso_image_get_system_area(IsoImage *img, char data[32768],
4402 int *options, int flag);
4403
4404/**
4405 * The maximum length of a single line in the output of function
4406 * iso_image_report_system_area() and iso_image_report_el_torito().
4407 * This number includes the trailing 0.
4408 * @since 1.3.8
4409 */
4410#define ISO_MAX_SYSAREA_LINE_LENGTH 4096
4411
4412/**
4413 * Texts which describe the output format of iso_image_report_system_area().
4414 * They are publicly defined here only as part of the API description.
4415 * Do not use these macros in your application but rather call
4416 * iso_image_report_system_area() with flag bit0.
4417 */
4418#define ISO_SYSAREA_REPORT_DOC \
4419\
4420"Report format for recognized System Area data.", \
4421"", \
4422"No text will be reported if no System Area was loaded or if it was", \
4423"entirely filled with 0-bytes.", \
4424"Else there will be at least these three lines:", \
4425" System area options: hex", \
4426" see libisofs.h, parameter of iso_write_opts_set_system_area().", \
4427" System area summary: word ... word", \
4428" human readable interpretation of system area options and other info", \
4429" The words are from the set:", \
4430" { MBR, CHRP, PReP, GPT, APM, MIPS-Big-Endian, MIPS-Little-Endian,", \
4431" SUN-SPARC-Disk-Label, HP-PA-PALO, DEC-Alpha, ", \
4432" protective-msdos-label, isohybrid, grub2-mbr,", \
4433" cyl-align-{auto,on,off,all}, not-recognized, }", \
4434" The acronyms indicate boot data for particular hardware/firmware.", \
4435" protective-msdos-label is an MBR conformant to specs of GPT.", \
4436" isohybrid is an MBR implementing ISOLINUX isohybrid functionality.", \
4437" grub2-mbr is an MBR with GRUB2 64 bit address patching.", \
4438" cyl-align-on indicates that the ISO image MBR partition ends at a", \
4439" cylinder boundary. cyl-align-all means that more MBR partitions", \
4440" exist and all end at a cylinder boundary.", \
4441" not-recognized tells about unrecognized non-zero system area data.", \
4442" ISO image size/512 : decimal", \
4443" size of ISO image in block units of 512 bytes.", \
4444""
4445#define ISO_SYSAREA_REPORT_DOC_MBR \
4446\
4447"If an MBR is detected, with at least one partition entry of non-zero size,", \
4448"then there may be:", \
4449" Partition offset : decimal", \
4450" if not 0 then a second ISO 9660 superblock was found to which", \
4451" MBR partition 1 or GPT partition 1 is pointing.", \
4452" MBR heads per cyl : decimal", \
4453" conversion factor between MBR C/H/S address and LBA. 0=inconsistent.", \
4454" MBR secs per head : decimal", \
4455" conversion factor between MBR C/H/S address and LBA. 0=inconsistent.", \
4456" MBR partition table: N Status Type Start Blocks", \
4457" headline for MBR partition table.", \
4458" MBR partition : X hex hex decimal decimal", \
4459" gives partition number, status byte, type byte, start block,", \
4460" and number of blocks. 512 bytes per block.", \
4461" MBR partition path : X path", \
4462" the path of a file in the ISO image which begins at the partition", \
4463" start block of partition X.", \
4464" PReP boot partition: decimal decimal", \
4465" gives start block and size of a PReP boot partition in ISO 9660", \
4466" block units of 2048 bytes.", \
4467""
4468#define ISO_SYSAREA_REPORT_DOC_GPT1 \
4469\
4470"GUID Partition Table can coexist with MBR:", \
4471" GPT : N Info", \
4472" headline for GPT partition table. The fields are too wide for a", \
4473" neat table. So they are listed with a partition number and a text.", \
4474" GPT CRC should be : <hex> to match first 92 GPT header block bytes", \
4475" GPT CRC found : <hex> matches all 512 bytes of GPT header block", \
4476" libisofs-1.2.4 to 1.2.8 had a bug with the GPT header CRC. So", \
4477" libisofs is willing to recognize GPT with the buggy CRC. These", \
4478" two lines inform that most partition editors will not accept it.", \
4479" GPT array CRC wrong: should be <hex>, found <hex>", \
4480" GPT entry arrays are accepted even if their CRC does not match.", \
4481" In this case, both CRCs are reported by this line.", \
4482" GPT backup problems: text", \
4483" reports about inconsistencies between main GPT and backup GPT.", \
4484" The statements are comma separated:", \
4485" Implausible header LBA <decimal>", \
4486" Cannot read header block at 2k LBA <decimal>", \
4487" Not a GPT 1.0 header of 92 bytes for 128 bytes per entry", \
4488" Head CRC <hex> wrong. Should be <hex>", \
4489" Head CRC <hex> wrong. Should be <hex>. Matches all 512 block bytes", \
4490" Disk GUID differs (<hex_digits>)", \
4491" Cannot read array block at 2k LBA <decimal>", \
4492" Array CRC <hex> wrong. Should be <hex>", \
4493" Entries differ for partitions <decimal> [... <decimal>]", \
4494" GPT disk GUID : hex_digits", \
4495" 32 hex digits giving the byte string of the disk's GUID", \
4496" GPT entry array : decimal decimal word", \
4497" start block of partition entry array and number of entries. 512 bytes", \
4498" per block. The word may be \"separated\" if partitions are disjoint,", \
4499" \"overlapping\" if they are not. In future there may be \"nested\"", \
4500" as special case where all overlapping partitions are superset and", \
4501" subset, and \"covering\" as special case of disjoint partitions", \
4502" covering the whole GPT block range for partitions.", \
4503" GPT lba range : decimal decimal decimal", \
4504" addresses of first payload block, last payload block, and of the", \
4505" GPT backup header block. 512 bytes per block." \
4506
4507#define ISO_SYSAREA_REPORT_DOC_GPT2 \
4508\
4509" GPT partition name : X hex_digits", \
4510" up to 144 hex digits giving the UTF-16LE name byte string of", \
4511" partition X. Trailing 16 bit 0-characters are omitted.", \
4512" GPT partname local : X text", \
4513" the name of partition X converted to the local character set.", \
4514" This line may be missing if the name cannot be converted, or is", \
4515" empty.", \
4516" GPT partition GUID : X hex_digits", \
4517" 32 hex digits giving the byte string of the GUID of partition X.", \
4518" GPT type GUID : X hex_digits", \
4519" 32 hex digits giving the byte string of the type GUID of partition X.", \
4520" GPT partition flags: X hex", \
4521" 64 flag bits of partition X in hex representation.", \
4522" Known bit meanings are:", \
4523" bit0 = \"System Partition\" Do not alter.", \
4524" bit2 = Legacy BIOS bootable (MBR partition type 0x80)", \
4525" bit60= read-only", \
4526" GPT start and size : X decimal decimal", \
4527" start block and number of blocks of partition X. 512 bytes per block.", \
4528" GPT partition path : X path", \
4529" the path of a file in the ISO image which begins at the partition", \
4530" start block of partition X.", \
4531""
4532#define ISO_SYSAREA_REPORT_DOC_APM \
4533\
4534"Apple partition map can coexist with MBR and GPT:", \
4535" APM : N Info", \
4536" headline for human readers.", \
4537" APM block size : decimal", \
4538" block size of Apple Partition Map. 512 or 2048. This applies to", \
4539" start address and size of all partitions in the APM.", \
4540" APM gap fillers : decimal", \
4541" tells the number of partitions with name \"Gap[0-9[0-9]]\" and type", \
4542" \"ISO9660_data\".", \
4543" APM partition name : X text", \
4544" the name of partition X. Up to 32 characters.", \
4545" APM partition type : X text", \
4546" the type string of partition X. Up to 32 characters.", \
4547" APM start and size : X decimal decimal", \
4548" start block and number of blocks of partition X.", \
4549" APM partition path : X path", \
4550" the path of a file in the ISO image which begins at the partition", \
4551" start block of partition X.", \
4552""
4553#define ISO_SYSAREA_REPORT_DOC_MIPS \
4554\
4555"If a MIPS Big Endian Volume Header is detected, there may be:", \
4556" MIPS-BE volume dir : N Name Block Bytes", \
4557" headline for human readers.", \
4558" MIPS-BE boot entry : X upto8chr decimal decimal", \
4559" tells name, 512-byte block address, and byte count of boot entry X.", \
4560" MIPS-BE boot path : X path", \
4561" tells the path to the boot image file in the ISO image which belongs", \
4562" to the block address given by boot entry X.", \
4563"", \
4564"If a DEC Boot Block for MIPS Little Endian is detected, there may be:", \
4565" MIPS-LE boot map : LoadAddr ExecAddr SegmentSize SegmentStart", \
4566" headline for human readers.", \
4567" MIPS-LE boot params: decimal decimal decimal decimal", \
4568" tells four numbers which are originally derived from the ELF header", \
4569" of the boot file. The first two are counted in bytes, the other two", \
4570" are counted in blocks of 512 bytes.", \
4571" MIPS-LE boot path : path", \
4572" tells the path to the boot file in the ISO image which belongs to the", \
4573" address given by SegmentStart.", \
4574" MIPS-LE elf offset : decimal", \
4575" tells the relative 512-byte block offset inside the boot file:", \
4576" SegmentStart - FileStartBlock", \
4577""
4578#define ISO_SYSAREA_REPORT_DOC_SUN \
4579\
4580"If a SUN SPARC Disk Label is present:", \
4581" SUN SPARC disklabel: text", \
4582" tells the disk label text.", \
4583" SUN SPARC secs/head: decimal", \
4584" tells the number of sectors per head.", \
4585" SUN SPARC heads/cyl: decimal", \
4586" tells the number of heads per cylinder.", \
4587" SUN SPARC partmap : N IdTag Perms StartCyl NumBlock", \
4588" headline for human readers.", \
4589" SUN SPARC partition: X hex hex decimal decimal", \
4590" gives partition number, type word, permission word, start cylinder,", \
4591" and number of of blocks. 512 bytes per block. Type word may be: ", \
4592" 0=unused, 2=root partition with boot, 4=user partition.", \
4593" Permission word is 0x10 = read-only.", \
4594" SPARC GRUB2 core : decimal decimal", \
4595" tells byte address and byte count of the GRUB2 SPARC core file.", \
4596" SPARC GRUB2 path : path", \
4597" tells the path to the data file in the ISO image which belongs to the", \
4598" address given by core.", \
4599""
4600#define ISO_SYSAREA_REPORT_DOC_HPPA \
4601\
4602"If a HP-PA PALO boot sector version 4 or 5 is present:", \
4603" PALO header version: decimal", \
4604" tells the PALO header version: 4 or 5.", \
4605" HP-PA cmdline : text", \
4606" tells the command line for the kernels.", \
4607" HP-PA boot files : ByteAddr ByteSize Path", \
4608" headline for human readers.", \
4609" HP-PA 32-bit kernel: decimal decimal path", \
4610" tells start byte, byte count, and file path of the 32-bit kernel.", \
4611" HP-PA 64-bit kernel: decimal decimal path", \
4612" tells the same for the 64-bit kernel.", \
4613" HP-PA ramdisk : decimal decimal path", \
4614" tells the same for the ramdisk file.", \
4615" HP-PA bootloader : decimal decimal path", \
4616" tells the same for the bootloader file.", \
4617""
4618#define ISO_SYSAREA_REPORT_DOC_ALPHA \
4619"If a DEC Alpha SRM boot sector is present:", \
4620" DEC Alpha ldr size : decimal", \
4621" tells the number of 512-byte blocks in DEC Alpha Secondary Bootstrap", \
4622" Loader file.", \
4623" DEC Alpha ldr adr : decimal", \
4624" tells the start of the loader file in units of 512-byte blocks.", \
4625" DEC Alpha ldr path : path", \
4626" tells the path of a file in the ISO image which starts at the loader", \
4627" start address."
4628
4629/**
4630 * Obtain an array of texts describing the detected properties of the
4631 * eventually loaded System Area.
4632 * The array will be NULL if no System Area was loaded. It will be non-NULL
4633 * with zero line count if the System Area was loaded and contains only
4634 * 0-bytes.
4635 * Else it will consist of lines as described in ISO_SYSAREA_REPORT_DOC above.
4636 *
4637 * File paths and other long texts are reported as "(too long to show here)"
4638 * if their length plus preceding text plus trailing 0-byte exceeds the
4639 * line length limit of ISO_MAX_SYSAREA_LINE_LENGTH bytes.
4640 * Texts which may contain whitespace or unprintable characters will start
4641 * at fixed positions and extend to the end of the line.
4642 * Note that newline characters may well appearing in the middle of a "line".
4643 *
4644 * @param image
4645 * The image to be inquired.
4646 * @param reply
4647 * Will return an array of pointers to the result text lines or NULL.
4648 * Dispose a non-NULL reply by a call to iso_image_report_system_area()
4649 * with flag bit15, when no longer needed.
4650 * Be prepared for a long text with up to ISO_MAX_SYSAREA_LINE_LENGTH
4651 * characters per line.
4652 * @param line_count
4653 * Will return the number of valid pointers in reply.
4654 * @param flag
4655 * Bitfield for control purposes
4656 * bit0= do not report system area but rather reply a copy of
4657 * above text line arrays ISO_SYSAREA_REPORT_DOC*.
4658 * With this bit it is permissible to submit image as NULL.
4659 * bit15= dispose result from previous call.
4660 * @return
4661 * 1 on success, 0 if no System Area was loaded, < 0 error.
4662 * @since 1.3.8
4663 */
4665 char ***reply, int *line_count, int flag);
4666
4667/**
4668 * Text which describes the output format of iso_image_report_el_torito().
4669 * It is publicly defined here only as part of the API description.
4670 * Do not use it as macro in your application but rather call
4671 * iso_image_report_el_torito() with flag bit0.
4672 */
4673#define ISO_ELTORITO_REPORT_DOC \
4674"Report format for recognized El Torito boot information.", \
4675"", \
4676"No text will be reported if no El Torito information was found.", \
4677"Else there will be at least these three lines", \
4678" El Torito catalog : decimal decimal", \
4679" tells the block address and number of 2048-blocks of the boot catalog.", \
4680" El Torito images : N Pltf B Emul Ld_seg Hdpt Ldsiz LBA", \
4681" is the headline of the boot image list.", \
4682" El Torito boot img : X word char word hex hex decimal decimal", \
4683" tells about boot image number X:", \
4684" - Platform Id: \"BIOS\", \"PPC\", \"Mac\", \"UEFI\" or a hex number.", \
4685" - Bootability: either \"y\" or \"n\".", \
4686" - Emulation: \"none\", \"fd1.2\", \"fd1.4\", \"fd2.8\", \"hd\"", \
4687" for no emulation, three floppy MB sizes, hard disk.", \
4688" - Load Segment: start offset in boot image. 0x0000 means 0x07c0.", \
4689" - Hard disk emulation partition type: MBR partition type code.", \
4690" - Load size: number of 512-blocks to load with emulation mode \"none\".", \
4691" - LBA: start block number in ISO filesystem (2048-block).", \
4692"", \
4693"The following lines appear conditionally:", \
4694" El Torito cat path : iso_rr_path", \
4695" tells the path to the data file in the ISO image which belongs to", \
4696" the block address where the boot catalog starts.", \
4697" (This line is not reported if no path points to that block.)", \
4698" El Torito img path : X iso_rr_path", \
4699" tells the path to the data file in the ISO image which belongs to", \
4700" the block address given by LBA of boot image X.", \
4701" (This line is not reported if no path points to that block.)", \
4702" El Torito img opts : X word ... word", \
4703" tells the presence of extra features:", \
4704" \"boot-info-table\" image got boot info table patching.", \
4705" \"isohybrid-suitable\" image is suitable for ISOLINUX isohybrid MBR.", \
4706" \"grub2-boot-info\" image got GRUB2 boot info patching.", \
4707" (This line is not reported if no such options were detected.)", \
4708" El Torito id string: X hex_digits", \
4709" tells the id string of the catalog section which hosts boot image X.", \
4710" (This line is not reported if the id string is all zero.)", \
4711" El Torito sel crit : X hex_digits", \
4712" tells the selection criterion of boot image X.", \
4713" (This line is not reported if the criterion is all zero.)", \
4714" El Torito img blks : X decimal", \
4715" gives an upper limit of the number of 2048-blocks in the boot image", \
4716" if it is not accessible via a path in the ISO directory tree.", \
4717" The boot image is supposed to end before the start block of any", \
4718" other entity of the ISO filesystem.", \
4719" (This line is not reported if no limiting entity is found.)", \
4720" El Torito hdsiz/512: X decimal", \
4721" gives with a boot image of emulation type \"hd\" the lowest block", \
4722" number which is above any partition end in the boot image's MBR", \
4723" partition table. This can be considered the claimed size of the", \
4724" emulated hard disk given in blocks of 512 bytes.", \
4725" (This line is not reported if no partition is found in the image.)", \
4726""
4727
4728/**
4729 * Obtain an array of texts describing the detected properties of the
4730 * eventually loaded El Torito boot information.
4731 * The array will be NULL if no El Torito info was loaded.
4732 * Else it will consist of lines as described in ISO_ELTORITO_REPORT_DOC above.
4733 *
4734 * The lines have the same length restrictions and whitespace rules as the ones
4735 * returned by iso_image_report_system_area().
4736 *
4737 * @param image
4738 * The image to be inquired.
4739 * @param reply
4740 * Will return an array of pointers to the result text lines or NULL.
4741 * Dispose a non-NULL reply by a call to iso_image_report_el_torito()
4742 * with flag bit15, when no longer needed.
4743 * Be prepared for a long text with up to ISO_MAX_SYSAREA_LINE_LENGTH
4744 * characters per line.
4745 * @param line_count
4746 * Will return the number of valid pointers in reply.
4747 * @param flag
4748 * Bitfield for control purposes
4749 * bit0= do not report system area but rather reply a copy of
4750 * above text line array ISO_ELTORITO_REPORT_DOC.
4751 * With this bit it is permissible to submit image as NULL.
4752 * bit15= dispose result from previous call.
4753 * @return
4754 * 1 on success, 0 if no El Torito information was loaded, < 0 error.
4755 * @since 1.3.8
4756 */
4758 char ***reply, int *line_count, int flag);
4759
4760
4761/**
4762 * Compute a CRC number as expected in the GPT main and backup header blocks.
4763 *
4764 * The CRC at byte offset 88 is supposed to cover the array of partition
4765 * entries.
4766 * The CRC at byte offset 16 is supposed to cover the readily produced
4767 * first 92 bytes of the header block while its bytes 16 to 19 are still
4768 * set to 0.
4769 * Block size is 512 bytes. Numbers are stored little-endian.
4770 * See doc/boot_sectors.txt for the byte layout of GPT.
4771 *
4772 * This might be helpful for applications which want to manipulate GPT
4773 * directly. The function is in libisofs/system_area.c and self-contained.
4774 * So if you want to copy+paste it under the license of that file: Be invited.
4775 * Be warned that this implementation works bit-wise and thus is much slower
4776 * than table-driven ones. For less than 32 KiB, it fully suffices, though.
4777 *
4778 * @param data
4779 * The memory buffer with the data to sum up.
4780 * @param count
4781 * Number of bytes in data.
4782 * @param flag
4783 * Bitfield for control purposes. Submit 0.
4784 * @return
4785 * The CRC of data.
4786 * @since 1.3.8
4787 */
4788uint32_t iso_crc32_gpt(unsigned char *data, int count, int flag);
4789
4790/**
4791 * Add a MIPS boot file path to the image.
4792 * Up to 15 such files can be written into a MIPS Big Endian Volume Header
4793 * if this is enabled by value 1 in iso_write_opts_set_system_area() option
4794 * bits 2 to 7.
4795 * A single file can be written into a DEC Boot Block if this is enabled by
4796 * value 2 in iso_write_opts_set_system_area() option bits 2 to 7. So only
4797 * the first added file gets into effect with this system area type.
4798 * The data files which shall serve as MIPS boot files have to be brought into
4799 * the image by the normal means.
4800 * @param image
4801 * The image to be manipulated.
4802 * @param path
4803 * Absolute path of the boot file in the ISO 9660 Rock Ridge tree.
4804 * @param flag
4805 * Bitfield for control purposes, unused yet, submit 0
4806 * @return
4807 * 1 on success, < 0 error
4808 * @since 0.6.38
4809 */
4810int iso_image_add_mips_boot_file(IsoImage *image, char *path, int flag);
4811
4812/**
4813 * Obtain the number of added MIPS Big Endian boot files and pointers to
4814 * their paths in the ISO 9660 Rock Ridge tree.
4815 * @param image
4816 * The image to be inquired.
4817 * @param paths
4818 * An array of pointers to be set to the registered boot file paths.
4819 * This are just pointers to data inside IsoImage. Do not free() them.
4820 * Eventually make own copies of the data before manipulating the image.
4821 * @param flag
4822 * Bitfield for control purposes, unused yet, submit 0
4823 * @return
4824 * >= 0 is the number of valid path pointers , <0 means error
4825 * @since 0.6.38
4826 */
4827int iso_image_get_mips_boot_files(IsoImage *image, char *paths[15], int flag);
4828
4829/**
4830 * Clear the list of MIPS Big Endian boot file paths.
4831 * @param image
4832 * The image to be manipulated.
4833 * @param flag
4834 * Bitfield for control purposes, unused yet, submit 0
4835 * @return
4836 * 1 is success , <0 means error
4837 * @since 0.6.38
4838 */
4840
4841/**
4842 * Designate a data file in the ISO image of which the position and size
4843 * shall be written after the SUN Disk Label. The position is written as
4844 * 64-bit big-endian number to byte position 0x228. The size is written
4845 * as 32-bit big-endian to 0x230.
4846 * This setting has an effect only if system area type is set to 3
4847 * with iso_write_opts_set_system_area().
4848 *
4849 * @param img
4850 * The image to be manipulated.
4851 * @param sparc_core
4852 * The IsoFile which shall be mentioned after the SUN Disk label.
4853 * NULL is a permissible value. It disables this feature.
4854 * @param flag
4855 * Bitfield for control purposes, unused yet, submit 0
4856 * @return
4857 * 1 is success , <0 means error
4858 * @since 1.3.0
4859 */
4860int iso_image_set_sparc_core(IsoImage *img, IsoFile *sparc_core, int flag);
4861
4862/**
4863 * Obtain the current setting of iso_image_set_sparc_core().
4864 *
4865 * @param img
4866 * The image to be inquired.
4867 * @param sparc_core
4868 * Will return a pointer to the IsoFile (or NULL, which is not an error)
4869 * @param flag
4870 * Bitfield for control purposes, unused yet, submit 0
4871 * @return
4872 * 1 is success , <0 means error
4873 * @since 1.3.0
4874 */
4875int iso_image_get_sparc_core(IsoImage *img, IsoFile **sparc_core, int flag);
4876
4877/**
4878 * Define a command line and submit the paths of four mandatory files for
4879 * production of a HP-PA PALO boot sector for PA-RISC machines.
4880 * The paths must lead to already existing data files in the ISO image
4881 * which stay with these paths until image production.
4882 *
4883 * @param img
4884 * The image to be manipulated.
4885 * @param cmdline
4886 * Up to 127 characters of command line.
4887 * @param bootloader
4888 * Absolute path of a data file in the ISO image.
4889 * @param kernel_32
4890 * Absolute path of a data file in the ISO image which serves as
4891 * 32 bit kernel.
4892 * @param kernel_64
4893 * Absolute path of a data file in the ISO image which serves as
4894 * 64 bit kernel.
4895 * @param ramdisk
4896 * Absolute path of a data file in the ISO image.
4897 * @param flag
4898 * Bitfield for control purposes
4899 * bit0= Let NULL parameters free the corresponding image properties.
4900 * Else only the non-NULL parameters of this call have an effect
4901 * @return
4902 * 1 is success , <0 means error
4903 * @since 1.3.8
4904 */
4905int iso_image_set_hppa_palo(IsoImage *img, char *cmdline, char *bootloader,
4906 char *kernel_32, char *kernel_64, char *ramdisk,
4907 int flag);
4908
4909/**
4910 * Inquire the current settings of iso_image_set_hppa_palo().
4911 * Do not free() the returned pointers.
4912 *
4913 * @param img
4914 * The image to be inquired.
4915 * @param cmdline
4916 * Will return the command line.
4917 * @param bootloader
4918 * Will return the absolute path of the bootloader file.
4919 * @param kernel_32
4920 * Will return the absolute path of the 32 bit kernel file.
4921 * @param kernel_64
4922 * Will return the absolute path of the 64 bit kernel file.
4923 * @param ramdisk
4924 * Will return the absolute path of the RAM disk file.
4925 * @return
4926 * 1 is success , <0 means error
4927 * @since 1.3.8
4928 */
4929int iso_image_get_hppa_palo(IsoImage *img, char **cmdline, char **bootloader,
4930 char **kernel_32, char **kernel_64, char **ramdisk);
4931
4932
4933/**
4934 * Submit the path of the DEC Alpha Secondary Bootstrap Loader file.
4935 * The path must lead to an already existing data file in the ISO image
4936 * which stays with this path until image production.
4937 * This setting has an effect only if system area type is set to 6
4938 * with iso_write_opts_set_system_area().
4939 *
4940 * @param img
4941 * The image to be manipulated.
4942 * @param boot_loader_path
4943 * Absolute path of a data file in the ISO image.
4944 * Submit NULL to free this image property.
4945 * @param flag
4946 * Bitfield for control purposes. Unused yet. Submit 0.
4947 * @return
4948 * 1 is success , <0 means error
4949 * @since 1.4.0
4950 */
4951int iso_image_set_alpha_boot(IsoImage *img, char *boot_loader_path, int flag);
4952
4953/**
4954 * Inquire the path submitted by iso_image_set_alpha_boot()
4955 * Do not free() the returned pointer.
4956 *
4957 * @param img
4958 * The image to be inquired.
4959 * @param boot_loader_path
4960 * Will return the path. NULL if none is currently submitted.
4961 * @return
4962 * 1 is success , <0 means error
4963 * @since 1.4.0
4964 */
4965int iso_image_get_alpha_boot(IsoImage *img, char **boot_loader_path);
4966
4967
4968/**
4969 * Increments the reference counting of the given node.
4970 *
4971 * @since 0.6.2
4972 */
4974
4975/**
4976 * Decrements the reference counting of the given node.
4977 * If it reach 0, the node is free, and, if the node is a directory,
4978 * its children will be unref() too.
4979 *
4980 * @since 0.6.2
4981 */
4983
4984/**
4985 * Get the type of an IsoNode.
4986 *
4987 * @since 0.6.2
4988 */
4990
4991/**
4992 * Class of functions to handle particular extended information. A function
4993 * instance acts as an identifier for the type of the information. Structs
4994 * with same information type must use a pointer to the same function.
4995 *
4996 * @param data
4997 * Attached data
4998 * @param flag
4999 * What to do with the data. At this time the following values are
5000 * defined:
5001 * -> 1 the data must be freed
5002 * @return
5003 * 1 in any case.
5004 *
5005 * @since 0.6.4
5006 */
5007typedef int (*iso_node_xinfo_func)(void *data, int flag);
5008
5009/**
5010 * Add extended information to the given node. Extended info allows
5011 * applications (and libisofs itself) to add more information to an IsoNode.
5012 * You can use this facilities to associate temporary information with a given
5013 * node. This information is not written into the ISO 9660 image on media
5014 * and thus does not persist longer than the node memory object.
5015 *
5016 * Each node keeps a list of added extended info, meaning you can add several
5017 * extended info data to each node. Each extended info you add is identified
5018 * by the proc parameter, a pointer to a function that knows how to manage
5019 * the external info data. Thus, in order to add several types of extended
5020 * info, you need to define a "proc" function for each type.
5021 *
5022 * @param node
5023 * The node where to add the extended info
5024 * @param proc
5025 * A function pointer used to identify the type of the data, and that
5026 * knows how to manage it
5027 * @param data
5028 * Extended info to add.
5029 * @return
5030 * 1 if success, 0 if the given node already has extended info of the
5031 * type defined by the "proc" function, < 0 on error
5032 *
5033 * @since 0.6.4
5034 */
5036
5037/**
5038 * Remove the given extended info (defined by the proc function) from the
5039 * given node.
5040 *
5041 * @return
5042 * 1 on success, 0 if node does not have extended info of the requested
5043 * type, < 0 on error
5044 *
5045 * @since 0.6.4
5046 */
5048
5049/**
5050 * Remove all extended information from the given node.
5051 *
5052 * @param node
5053 * The node where to remove all extended info
5054 * @param flag
5055 * Bitfield for control purposes, unused yet, submit 0
5056 * @return
5057 * 1 on success, < 0 on error
5058 *
5059 * @since 1.0.2
5060 */
5062
5063/**
5064 * Get the given extended info (defined by the proc function) from the
5065 * given node.
5066 *
5067 * @param node
5068 * The node to inquire
5069 * @param proc
5070 * The function pointer which serves as key
5071 * @param data
5072 * Will after successful call point to the xinfo data corresponding
5073 * to the given proc. This is a pointer, not a feeable data copy.
5074 * @return
5075 * 1 on success, 0 if node does not have extended info of the requested
5076 * type, < 0 on error
5077 *
5078 * @since 0.6.4
5079 */
5080int iso_node_get_xinfo(IsoNode *node, iso_node_xinfo_func proc, void **data);
5081
5082
5083/**
5084 * Get the next pair of function pointer and data of an iteration of the
5085 * list of extended information. Like:
5086 * iso_node_xinfo_func proc;
5087 * void *handle = NULL, *data;
5088 * while (iso_node_get_next_xinfo(node, &handle, &proc, &data) == 1) {
5089 * ... make use of proc and data ...
5090 * }
5091 * The iteration allocates no memory. So you may end it without any disposal
5092 * action.
5093 * IMPORTANT: Do not continue iterations after manipulating the extended
5094 * information of a node. Memory corruption hazard !
5095 * @param node
5096 * The node to inquire
5097 * @param handle
5098 * The opaque iteration handle. Initialize iteration by submitting
5099 * a pointer to a void pointer with value NULL.
5100 * Do not alter its content until iteration has ended.
5101 * @param proc
5102 * The function pointer which serves as key
5103 * @param data
5104 * Will be filled with the extended info corresponding to the given proc
5105 * function
5106 * @return
5107 * 1 on success
5108 * 0 if iteration has ended (proc and data are invalid then)
5109 * < 0 on error
5110 *
5111 * @since 1.0.2
5112 */
5113int iso_node_get_next_xinfo(IsoNode *node, void **handle,
5114 iso_node_xinfo_func *proc, void **data);
5115
5116
5117/**
5118 * Class of functions to clone extended information. A function instance gets
5119 * associated to a particular iso_node_xinfo_func instance by function
5120 * iso_node_xinfo_make_clonable(). This is a precondition to have IsoNode
5121 * objects clonable which carry data for a particular iso_node_xinfo_func.
5122 *
5123 * @param old_data
5124 * Data item to be cloned
5125 * @param new_data
5126 * Shall return the cloned data item
5127 * @param flag
5128 * Unused yet, submit 0
5129 * The function shall return ISO_XINFO_NO_CLONE on unknown flag bits.
5130 * @return
5131 * > 0 number of allocated bytes
5132 * 0 no size info is available
5133 * < 0 error
5134 *
5135 * @since 1.0.2
5136 */
5137typedef int (*iso_node_xinfo_cloner)(void *old_data, void **new_data,int flag);
5138
5139/**
5140 * Associate a iso_node_xinfo_cloner to a particular class of extended
5141 * information in order to make it clonable.
5142 *
5143 * @param proc
5144 * The key and disposal function which identifies the particular
5145 * extended information class.
5146 * @param cloner
5147 * The cloner function which shall be associated with proc.
5148 * @param flag
5149 * Unused yet, submit 0
5150 * @return
5151 * 1 success, < 0 error
5152 *
5153 * @since 1.0.2
5154 */
5156 iso_node_xinfo_cloner cloner, int flag);
5157
5158/**
5159 * Inquire the registered cloner function for a particular class of
5160 * extended information.
5161 *
5162 * @param proc
5163 * The key and disposal function which identifies the particular
5164 * extended information class.
5165 * @param cloner
5166 * Will return the cloner function which is associated with proc, or NULL.
5167 * @param flag
5168 * Unused yet, submit 0
5169 * @return
5170 * 1 success, 0 no cloner registered for proc, < 0 error
5171 *
5172 * @since 1.0.2
5173 */
5175 iso_node_xinfo_cloner *cloner, int flag);
5176
5177/**
5178 * Set the name of a node. Note that if the node is already added to a dir
5179 * this can fail if dir already contains a node with the new name.
5180 * The IsoImage context defines a maximum permissible name length and a mode
5181 * how to react on oversized names. See iso_image_set_truncate_mode().
5182 *
5183 * @param image
5184 * The image object to which the node belongs or shall belong in future.
5185 * @param node
5186 * The node of which you want to change the name. One cannot change the
5187 * name of the root directory.
5188 * @param name
5189 * The new name for the node. It may not be empty. If it is oversized
5190 * then it will be handled according to iso_image_set_truncate_mode().
5191 * @param flag
5192 * bit0= issue warning in case of truncation
5193 * @return
5194 * 1 on success, < 0 on error
5195 *
5196 * @since 1.4.2
5197 */
5198int iso_image_set_node_name(IsoImage *image, IsoNode *node, const char *name,
5199 int flag);
5200
5201/**
5202 * *** Deprecated ***
5203 * use iso_image_set_node_name() instead
5204 *
5205 * Set the name of a node without taking into respect name truncation mode of
5206 * an IsoImage.
5207 *
5208 * @param node
5209 * The node whose name you want to change. Note that you can't change
5210 * the name of the root.
5211 * @param name
5212 * The name for the node. If you supply an empty string or a
5213 * name greater than 255 characters this returns with failure, and
5214 * node name is not modified.
5215 * @return
5216 * 1 on success, < 0 on error
5217 *
5218 * @since 0.6.2
5219 */
5220int iso_node_set_name(IsoNode *node, const char *name);
5221
5222
5223/**
5224 * Get the name of a node.
5225 * The returned string belongs to the node and must not be modified nor
5226 * freed. Use strdup if you really need your own copy.
5227 *
5228 * Up to version 1.4.2 inquiry of the root directory name returned NULL,
5229 * which is a bug in the light of above description.
5230 * Since 1.4.2 the return value is an empty string.
5231 *
5232 * @since 0.6.2
5233 */
5234const char *iso_node_get_name(const IsoNode *node);
5235
5236/**
5237 * Set the permissions for the node. This attribute is only useful when
5238 * Rock Ridge extensions are enabled.
5239 *
5240 * @param node
5241 * The node to change
5242 * @param mode
5243 * bitmask with the permissions of the node, as specified in 'man 2 stat'.
5244 * The file type bitfields will be ignored, only file permissions will be
5245 * modified.
5246 *
5247 * @since 0.6.2
5248 */
5249void iso_node_set_permissions(IsoNode *node, mode_t mode);
5250
5251/**
5252 * Get the permissions for the node
5253 *
5254 * @since 0.6.2
5255 */
5257
5258/**
5259 * Get the mode of the node, both permissions and file type, as specified in
5260 * 'man 2 stat'.
5261 *
5262 * @since 0.6.2
5263 */
5264mode_t iso_node_get_mode(const IsoNode *node);
5265
5266/**
5267 * Set the user id for the node. This attribute is only useful when
5268 * Rock Ridge extensions are enabled.
5269 *
5270 * @since 0.6.2
5271 */
5272void iso_node_set_uid(IsoNode *node, uid_t uid);
5273
5274/**
5275 * Get the user id of the node.
5276 *
5277 * @since 0.6.2
5278 */
5279uid_t iso_node_get_uid(const IsoNode *node);
5280
5281/**
5282 * Set the group id for the node. This attribute is only useful when
5283 * Rock Ridge extensions are enabled.
5284 *
5285 * @since 0.6.2
5286 */
5287void iso_node_set_gid(IsoNode *node, gid_t gid);
5288
5289/**
5290 * Get the group id of the node.
5291 *
5292 * @since 0.6.2
5293 */
5294gid_t iso_node_get_gid(const IsoNode *node);
5295
5296/**
5297 * Set the time of last modification of the file
5298 *
5299 * @since 0.6.2
5300 */
5301void iso_node_set_mtime(IsoNode *node, time_t time);
5302
5303/**
5304 * Get the time of last modification of the file
5305 *
5306 * @since 0.6.2
5307 */
5308time_t iso_node_get_mtime(const IsoNode *node);
5309
5310/**
5311 * Set the time of last access to the file
5312 *
5313 * @since 0.6.2
5314 */
5315void iso_node_set_atime(IsoNode *node, time_t time);
5316
5317/**
5318 * Get the time of last access to the file
5319 *
5320 * @since 0.6.2
5321 */
5322time_t iso_node_get_atime(const IsoNode *node);
5323
5324/**
5325 * Set the time of last status change of the file
5326 *
5327 * @since 0.6.2
5328 */
5329void iso_node_set_ctime(IsoNode *node, time_t time);
5330
5331/**
5332 * Get the time of last status change of the file
5333 *
5334 * @since 0.6.2
5335 */
5336time_t iso_node_get_ctime(const IsoNode *node);
5337
5338/**
5339 * Set whether the node will be hidden in the directory trees of RR/ISO 9660,
5340 * or of Joliet (if enabled at all), or of ISO-9660:1999 (if enabled at all).
5341 *
5342 * A hidden file does not show up by name in the affected directory tree.
5343 * For example, if a file is hidden only in Joliet, it will normally
5344 * not be visible on Windows systems, while being shown on GNU/Linux.
5345 *
5346 * If a file is not shown in any of the enabled trees, then its content will
5347 * not be written to the image, unless LIBISO_HIDE_BUT_WRITE is given (which
5348 * is available only since release 0.6.34).
5349 *
5350 * @param node
5351 * The node that is to be hidden.
5352 * @param hide_attrs
5353 * Or-combination of values from enum IsoHideNodeFlag to set the trees
5354 * in which the node's name shall be hidden.
5355 *
5356 * @since 0.6.2
5357 */
5358void iso_node_set_hidden(IsoNode *node, int hide_attrs);
5359
5360/**
5361 * Get the hide_attrs as eventually set by iso_node_set_hidden().
5362 *
5363 * @param node
5364 * The node to inquire.
5365 * @return
5366 * Or-combination of values from enum IsoHideNodeFlag which are
5367 * currently set for the node.
5368 *
5369 * @since 0.6.34
5370 */
5372
5373/**
5374 * Compare two nodes whether they are based on the same input and
5375 * can be considered as hardlinks to the same file objects.
5376 *
5377 * @param n1
5378 * The first node to compare.
5379 * @param n2
5380 * The second node to compare.
5381 * @return
5382 * -1 if n1 is smaller n2 , 0 if n1 matches n2 , 1 if n1 is larger n2
5383 * @param flag
5384 * Bitfield for control purposes, unused yet, submit 0
5385 * @since 0.6.20
5386 */
5387int iso_node_cmp_ino(IsoNode *n1, IsoNode *n2, int flag);
5388
5389/**
5390 * Add a new node to a dir. Note that this function don't add a new ref to
5391 * the node, so you don't need to free it, it will be automatically freed
5392 * when the dir is deleted. Of course, if you want to keep using the node
5393 * after the dir life, you need to iso_node_ref() it.
5394 *
5395 * @param dir
5396 * the dir where to add the node
5397 * @param child
5398 * the node to add. You must ensure that the node hasn't previously added
5399 * to other dir, and that the node name is unique inside the child.
5400 * Otherwise this function will return a failure, and the child won't be
5401 * inserted.
5402 * @param replace
5403 * if the dir already contains a node with the same name, whether to
5404 * replace or not the old node with this.
5405 * @return
5406 * number of nodes in dir if success, < 0 otherwise
5407 * Possible errors:
5408 * ISO_NULL_POINTER, if dir or child are NULL
5409 * ISO_NODE_ALREADY_ADDED, if child is already added to other dir
5410 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
5411 * ISO_WRONG_ARG_VALUE, if child == dir, or replace != (0,1)
5412 *
5413 * @since 0.6.2
5414 */
5416 enum iso_replace_mode replace);
5417
5418/**
5419 * Locate a node inside a given dir.
5420 *
5421 * The IsoImage context defines a maximum permissible name length and a mode
5422 * how to react on oversized names. See iso_image_set_truncate_mode().
5423 * If the caller looks for an oversized name and image truncate mode is 1,
5424 * then this call looks for the truncated name among the nodes of dir.
5425 *
5426 * @param image
5427 * The image object to which dir belongs.
5428 * @param dir
5429 * The dir where to look for the node.
5430 * @param name
5431 * The name of the node. (Will not be changed if truncation happens.)
5432 * @param node
5433 * Location for a pointer to the node, it will filled with NULL if the dir
5434 * doesn't have a child with the given name.
5435 * The node will be owned by the dir and shouldn't be unref(). Just call
5436 * iso_node_ref() to get your own reference to the node.
5437 * Note that you can pass NULL is the only thing you want to do is check
5438 * if a node with such name already exists on dir.
5439 * @param flag
5440 * Bitfield for control purposes.
5441 * bit0= do not truncate name but lookup exactly as given.
5442 * @return
5443 * 1 node found
5444 * 0 no name truncation was needed, name not found in dir
5445 * 2 name truncation happened, truncated name not found in dir
5446 * < 0 error, see iso_dir_get_node().
5447 *
5448 * @since 1.4.2
5449 */
5451 const char *name, IsoNode **node, int flag);
5452
5453/**
5454 * *** Deprecated ***
5455 * In most cases use iso_image_dir_get_node() instead.
5456 *
5457 * Locate a node inside a given dir without taking into respect name truncation
5458 * mode of an IsoImage.
5459 *
5460 * @param dir
5461 * The dir where to look for the node.
5462 * @param name
5463 * The name of the node
5464 * @param node
5465 * Location for a pointer to the node. See iso_image_get_node().
5466 * @return
5467 * 1 node found, 0 child has no such node, < 0 error
5468 * Possible errors:
5469 * ISO_NULL_POINTER, if dir or name are NULL
5470 *
5471 * @since 0.6.2
5472 */
5473int iso_dir_get_node(IsoDir *dir, const char *name, IsoNode **node);
5474
5475/**
5476 * Get the number of children of a directory.
5477 *
5478 * @return
5479 * >= 0 number of items, < 0 error
5480 * Possible errors:
5481 * ISO_NULL_POINTER, if dir is NULL
5482 *
5483 * @since 0.6.2
5484 */
5486
5487/**
5488 * Removes a child from a directory.
5489 * The child is not freed, so you will become the owner of the node. Later
5490 * you can add the node to another dir (calling iso_dir_add_node), or free
5491 * it if you don't need it (with iso_node_unref).
5492 *
5493 * @return
5494 * 1 on success, < 0 error
5495 * Possible errors:
5496 * ISO_NULL_POINTER, if node is NULL
5497 * ISO_NODE_NOT_ADDED_TO_DIR, if node doesn't belong to a dir
5498 *
5499 * @since 0.6.2
5500 */
5502
5503/**
5504 * Removes a child from a directory and free (unref) it.
5505 * If you want to keep the child alive, you need to iso_node_ref() it
5506 * before this call, but in that case iso_node_take() is a better
5507 * alternative.
5508 *
5509 * @return
5510 * 1 on success, < 0 error
5511 *
5512 * @since 0.6.2
5513 */
5515
5516/*
5517 * Get the parent of the given iso tree node. No extra ref is added to the
5518 * returned directory, you must take your ref. with iso_node_ref() if you
5519 * need it.
5520 *
5521 * If node is the root node, the same node will be returned as its parent.
5522 *
5523 * This returns NULL if the node doesn't pertain to any tree
5524 * (it was removed/taken).
5525 *
5526 * @since 0.6.2
5527 */
5529
5530/**
5531 * Get an iterator for the children of the given dir.
5532 *
5533 * You can iterate over the children with iso_dir_iter_next. When finished,
5534 * you should free the iterator with iso_dir_iter_free.
5535 * You must not delete a child of the same dir, using iso_node_take() or
5536 * iso_node_remove(), while you're using the iterator. You can use
5537 * iso_dir_iter_take() or iso_dir_iter_remove() instead.
5538 *
5539 * You can use the iterator in the way like this
5540 *
5541 * IsoDirIter *iter;
5542 * IsoNode *node;
5543 * if ( iso_dir_get_children(dir, &iter) != 1 ) {
5544 * // handle error
5545 * }
5546 * while ( iso_dir_iter_next(iter, &node) == 1 ) {
5547 * // do something with the child
5548 * }
5549 * iso_dir_iter_free(iter);
5550 *
5551 * An iterator is intended to be used in a single iteration over the
5552 * children of a dir. Thus, it should be treated as a temporary object,
5553 * and free as soon as possible.
5554 *
5555 * @return
5556 * 1 success, < 0 error
5557 * Possible errors:
5558 * ISO_NULL_POINTER, if dir or iter are NULL
5559 * ISO_OUT_OF_MEM
5560 *
5561 * @since 0.6.2
5562 */
5564
5565/**
5566 * Get the next child.
5567 * Take care that the node is owned by its parent, and will be unref() when
5568 * the parent is freed. If you want your own ref to it, call iso_node_ref()
5569 * on it.
5570 *
5571 * @return
5572 * 1 success, 0 if dir has no more elements, < 0 error
5573 * Possible errors:
5574 * ISO_NULL_POINTER, if node or iter are NULL
5575 * ISO_ERROR, on wrong iter usage, usual caused by modiying the
5576 * dir during iteration
5577 *
5578 * @since 0.6.2
5579 */
5581
5582/**
5583 * Check if there're more children.
5584 *
5585 * @return
5586 * 1 dir has more elements, 0 no, < 0 error
5587 * Possible errors:
5588 * ISO_NULL_POINTER, if iter is NULL
5589 *
5590 * @since 0.6.2
5591 */
5593
5594/**
5595 * Free a dir iterator.
5596 *
5597 * @since 0.6.2
5598 */
5600
5601/**
5602 * Removes a child from a directory during an iteration, without freeing it.
5603 * It's like iso_node_take(), but to be used during a directory iteration.
5604 * The node removed will be the last returned by the iteration.
5605 *
5606 * If you call this function twice without calling iso_dir_iter_next between
5607 * them is not allowed and you will get an ISO_ERROR in second call.
5608 *
5609 * @return
5610 * 1 on success, < 0 error
5611 * Possible errors:
5612 * ISO_NULL_POINTER, if iter is NULL
5613 * ISO_ERROR, on wrong iter usage, for example by call this before
5614 * iso_dir_iter_next.
5615 *
5616 * @since 0.6.2
5617 */
5619
5620/**
5621 * Removes a child from a directory during an iteration and unref() it.
5622 * Like iso_node_remove(), but to be used during a directory iteration.
5623 * The node removed will be the one returned by the previous iteration.
5624 *
5625 * It is not allowed to call this function twice without calling
5626 * iso_dir_iter_next between the calls.
5627 *
5628 * @return
5629 * 1 on success, < 0 error
5630 * Possible errors:
5631 * ISO_NULL_POINTER, if iter is NULL
5632 * ISO_ERROR, on wrong iter usage, for example by calling this before
5633 * iso_dir_iter_next.
5634 *
5635 * @since 0.6.2
5636 */
5638
5639/**
5640 * Removes a node by iso_node_remove() or iso_dir_iter_remove(). If the node
5641 * is a directory then the whole tree of nodes underneath is removed too.
5642 *
5643 * @param node
5644 * The node to be removed.
5645 * @param boss_iter
5646 * If not NULL, then the node will be removed by
5647 * iso_dir_iter_remove(boss_iter)
5648 * else it will be removed by iso_node_remove(node).
5649 * @return
5650 * 1 is success, <0 indicates error
5651 *
5652 * @since 1.0.2
5653 */
5655
5656
5657/**
5658 * @since 0.6.4
5659 */
5660typedef struct iso_find_condition IsoFindCondition;
5661
5662/**
5663 * Create a new condition that checks if the node name matches the given
5664 * wildcard.
5665 *
5666 * @param wildcard
5667 * @result
5668 * The created IsoFindCondition, NULL on error.
5669 *
5670 * @since 0.6.4
5671 */
5673
5674/**
5675 * Create a new condition that checks the node mode against a mode mask. It
5676 * can be used to check both file type and permissions.
5677 *
5678 * For example:
5679 *
5680 * iso_new_find_conditions_mode(S_IFREG) : search for regular files
5681 * iso_new_find_conditions_mode(S_IFCHR | S_IWUSR) : search for character
5682 * devices where owner has write permissions.
5683 *
5684 * @param mask
5685 * Mode mask to AND against node mode.
5686 * @result
5687 * The created IsoFindCondition, NULL on error.
5688 *
5689 * @since 0.6.4
5690 */
5692
5693/**
5694 * Create a new condition that checks the node gid.
5695 *
5696 * @param gid
5697 * Desired Group Id.
5698 * @result
5699 * The created IsoFindCondition, NULL on error.
5700 *
5701 * @since 0.6.4
5702 */
5704
5705/**
5706 * Create a new condition that checks the node uid.
5707 *
5708 * @param uid
5709 * Desired User Id.
5710 * @result
5711 * The created IsoFindCondition, NULL on error.
5712 *
5713 * @since 0.6.4
5714 */
5716
5717/**
5718 * Possible comparison between IsoNode and given conditions.
5719 *
5720 * @since 0.6.4
5721 */
5729
5730/**
5731 * Create a new condition that checks the time of last access.
5732 *
5733 * @param time
5734 * Time to compare against IsoNode atime.
5735 * @param comparison
5736 * Comparison to be done between IsoNode atime and submitted time.
5737 * Note that ISO_FIND_COND_GREATER, for example, is true if the node
5738 * time is greater than the submitted time.
5739 * @result
5740 * The created IsoFindCondition, NULL on error.
5741 *
5742 * @since 0.6.4
5743 */
5745 enum iso_find_comparisons comparison);
5746
5747/**
5748 * Create a new condition that checks the time of last modification.
5749 *
5750 * @param time
5751 * Time to compare against IsoNode mtime.
5752 * @param comparison
5753 * Comparison to be done between IsoNode mtime and submitted time.
5754 * Note that ISO_FIND_COND_GREATER, for example, is true if the node
5755 * time is greater than the submitted time.
5756 * @result
5757 * The created IsoFindCondition, NULL on error.
5758 *
5759 * @since 0.6.4
5760 */
5762 enum iso_find_comparisons comparison);
5763
5764/**
5765 * Create a new condition that checks the time of last status change.
5766 *
5767 * @param time
5768 * Time to compare against IsoNode ctime.
5769 * @param comparison
5770 * Comparison to be done between IsoNode ctime and submitted time.
5771 * Note that ISO_FIND_COND_GREATER, for example, is true if the node
5772 * time is greater than the submitted time.
5773 * @result
5774 * The created IsoFindCondition, NULL on error.
5775 *
5776 * @since 0.6.4
5777 */
5779 enum iso_find_comparisons comparison);
5780
5781/**
5782 * Create a new condition that check if the two given conditions are
5783 * valid.
5784 *
5785 * @param a
5786 * @param b
5787 * IsoFindCondition to compare
5788 * @result
5789 * The created IsoFindCondition, NULL on error.
5790 *
5791 * @since 0.6.4
5792 */
5794 IsoFindCondition *b);
5795
5796/**
5797 * Create a new condition that check if at least one the two given conditions
5798 * is valid.
5799 *
5800 * @param a
5801 * @param b
5802 * IsoFindCondition to compare
5803 * @result
5804 * The created IsoFindCondition, NULL on error.
5805 *
5806 * @since 0.6.4
5807 */
5809 IsoFindCondition *b);
5810
5811/**
5812 * Create a new condition that check if the given conditions is false.
5813 *
5814 * @param negate
5815 * @result
5816 * The created IsoFindCondition, NULL on error.
5817 *
5818 * @since 0.6.4
5819 */
5821
5822/**
5823 * Find all directory children that match the given condition.
5824 *
5825 * @param dir
5826 * Directory where we will search children.
5827 * @param cond
5828 * Condition that the children must match in order to be returned.
5829 * It will be free together with the iterator. Remember to delete it
5830 * if this function return error.
5831 * @param iter
5832 * Iterator that returns only the children that match condition.
5833 * @return
5834 * 1 on success, < 0 on error
5835 *
5836 * @since 0.6.4
5837 */
5839 IsoDirIter **iter);
5840
5841/**
5842 * Get the destination of a node.
5843 * The returned string belongs to the node and must not be modified nor
5844 * freed. Use strdup if you really need your own copy.
5845 *
5846 * @since 0.6.2
5847 */
5848const char *iso_symlink_get_dest(const IsoSymlink *link);
5849
5850/**
5851 * Set the destination of a symbolic
5852 *
5853 * @param link
5854 * The link node to be manipulated
5855 * @param dest
5856 * New destination for the link. It must be a non-empty string, otherwise
5857 * this function doesn't modify previous destination.
5858 * @return
5859 * 1 on success, < 0 on error
5860 *
5861 * @since 0.6.2
5862 */
5863int iso_symlink_set_dest(IsoSymlink *link, const char *dest);
5864
5865/**
5866 * Sets the order in which a node will be written on image. The data content
5867 * of files with high weight will be written to low block addresses.
5868 *
5869 * @param node
5870 * The node which weight will be changed. If it's a dir, this function
5871 * will change the weight of all its children. For nodes other that dirs
5872 * or regular files, this function has no effect.
5873 * @param w
5874 * The weight as a integer number, the greater this value is, the
5875 * closer from the beginning of image the file will be written.
5876 * Default value at IsoNode creation is 0.
5877 *
5878 * @since 0.6.2
5879 */
5881
5882/**
5883 * Get the sort weight of a file.
5884 *
5885 * @since 0.6.2
5886 */
5888
5889/**
5890 * Get the size of the file, in bytes
5891 *
5892 * @since 0.6.2
5893 */
5895
5896/**
5897 * Get the device id (major/minor numbers) of the given block or
5898 * character device file. The result is undefined for other kind
5899 * of special files, of first be sure iso_node_get_mode() returns either
5900 * S_IFBLK or S_IFCHR.
5901 *
5902 * @since 0.6.6
5903 */
5905
5906/**
5907 * Get the IsoStream that represents the contents of the given IsoFile.
5908 * The stream may be a filter stream which itself get its input from a
5909 * further stream. This may be inquired by iso_stream_get_input_stream().
5910 *
5911 * If you iso_stream_open() the stream, iso_stream_close() it before
5912 * image generation begins.
5913 *
5914 * @return
5915 * The IsoStream. No extra ref is added, so the IsoStream belongs to the
5916 * IsoFile, and it may be freed together with it. Add your own ref with
5917 * iso_stream_ref() if you need it.
5918 *
5919 * @since 0.6.4
5920 */
5922
5923/**
5924 * Get the block lba of a file node, if it was imported from an old image.
5925 *
5926 * @param file
5927 * The file
5928 * @param lba
5929 * Will be filled with the kba
5930 * @param flag
5931 * Reserved for future usage, submit 0
5932 * @return
5933 * 1 if lba is valid (file comes from old image and has only one section),
5934 * 0 if file was newly added, i.e. it does not come from an old image,
5935 * < 0 error, especially ISO_WRONG_ARG_VALUE if the file has more than
5936 * one file section.
5937 *
5938 * @since 0.6.4
5939 *
5940 * @deprecated Use iso_file_get_old_image_sections(), as this function does
5941 * not work with multi-extend files.
5942 */
5943int iso_file_get_old_image_lba(IsoFile *file, uint32_t *lba, int flag);
5944
5945/**
5946 * Get the start addresses and the sizes of the data extents of a file node
5947 * if it was imported from an old image.
5948 *
5949 * @param file
5950 * The file
5951 * @param section_count
5952 * Returns the number of extent entries in sections array.
5953 * @param sections
5954 * Returns the array of file sections if section_count > 0.
5955 * In this case, apply free() to dispose it.
5956 * @param flag
5957 * Reserved for future usage, submit 0
5958 * @return
5959 * 1 if there are valid extents (file comes from old image),
5960 * 0 if file was newly added, i.e. it does not come from an old image,
5961 * < 0 error
5962 *
5963 * @since 0.6.8
5964 */
5965int iso_file_get_old_image_sections(IsoFile *file, int *section_count,
5966 struct iso_file_section **sections,
5967 int flag);
5968
5969/*
5970 * Like iso_file_get_old_image_lba(), but take an IsoNode.
5971 *
5972 * @return
5973 * 1 if lba is valid (file comes from old image), 0 if file was newly
5974 * added, i.e. it does not come from an old image, 2 node type has no
5975 * LBA (no regular file), < 0 error
5976 *
5977 * @since 0.6.4
5978 */
5979int iso_node_get_old_image_lba(IsoNode *node, uint32_t *lba, int flag);
5980
5981/**
5982 * Add a new directory to the iso tree. Permissions, owner and hidden atts
5983 * are taken from parent, you can modify them later.
5984 *
5985 * @param image
5986 * The image object to which the new directory shall belong.
5987 * @param parent
5988 * The directory node where the new directory will be grafted in.
5989 * @param name
5990 * Name for the new directory. If truncation mode is set to 1,
5991 * an oversized name gets truncated before further processing.
5992 * If a node with same name already exists on parent, this function
5993 * fails with ISO_NODE_NAME_NOT_UNIQUE.
5994 * @param dir
5995 * place where to store a pointer to the newly created dir. No extra
5996 * ref is added, so you will need to call iso_node_ref() if you really
5997 * need it. You can pass NULL in this parameter if you don't need the
5998 * pointer.
5999 * @return
6000 * number of nodes in parent if success, < 0 otherwise
6001 * Possible errors:
6002 * ISO_NULL_POINTER, if parent or name are NULL
6003 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6004 * ISO_OUT_OF_MEM
6005 * ISO_RR_NAME_TOO_LONG
6006 *
6007 * @since 1.4.2
6008 */
6009int iso_image_add_new_dir(IsoImage *image, IsoDir *parent, const char *name,
6010 IsoDir **dir);
6011
6012/**
6013 * *** Deprecated ***
6014 * use iso_image_add_new_dir() instead
6015 *
6016 * Add a new directory to the iso tree without taking into respect name
6017 * truncation mode of an IsoImage.
6018 * For detailed description of parameters, see above iso_image_add_new_dir().
6019 *
6020 * @param parent
6021 * the dir where the new directory will be created
6022 * @param name
6023 * name for the new dir.
6024 * @param dir
6025 * place where to store a pointer to the newly created dir.i
6026 * @return
6027 * number of nodes in parent if success, < 0 otherwise
6028 * Possible errors:
6029 * ISO_NULL_POINTER, if parent or name are NULL
6030 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6031 * ISO_OUT_OF_MEM
6032 *
6033 * @since 0.6.2
6034 */
6035int iso_tree_add_new_dir(IsoDir *parent, const char *name, IsoDir **dir);
6036
6037/**
6038 * Add a new regular file to the iso tree. Permissions are set to 0444,
6039 * owner and hidden atts are taken from parent. You can modify any of them
6040 * later.
6041 *
6042 * @param image
6043 * The image object to which the new file shall belong.
6044 * @param parent
6045 * The directory node where the new directory will be grafted in.
6046 * @param name
6047 * Name for the new file. If truncation mode is set to 1,
6048 * an oversized name gets truncated before further processing.
6049 * If a node with same name already exists on parent, this function
6050 * fails with ISO_NODE_NAME_NOT_UNIQUE.
6051 * @param stream
6052 * IsoStream for the contents of the file. The reference will be taken
6053 * by the newly created file, you will need to take an extra ref to it
6054 * if you need it.
6055 * @param file
6056 * place where to store a pointer to the newly created file. No extra
6057 * ref is added, so you will need to call iso_node_ref() if you really
6058 * need it. You can pass NULL in this parameter if you don't need the
6059 * pointer
6060 * @return
6061 * number of nodes in parent if success, < 0 otherwise
6062 * Possible errors:
6063 * ISO_NULL_POINTER, if parent, name or dest are NULL
6064 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6065 * ISO_OUT_OF_MEM
6066 * ISO_RR_NAME_TOO_LONG
6067 *
6068 * @since 1.4.2
6069 */
6070int iso_image_add_new_file(IsoImage *image, IsoDir *parent, const char *name,
6071 IsoStream *stream, IsoFile **file);
6072
6073/**
6074 * *** Deprecated ***
6075 * use iso_image_add_new_file() instead
6076 *
6077 * Add a new regular file to the iso tree without taking into respect name
6078 * truncation mode of an IsoImage.
6079 * For detailed description of parameters, see above iso_image_add_new_file().
6080 *
6081 * @param parent
6082 * the dir where the new file will be created
6083 * @param name
6084 * name for the new file.
6085 * @param stream
6086 * IsoStream for the contents of the file.
6087 * @param file
6088 * place where to store a pointer to the newly created file.
6089 * @return
6090 * number of nodes in parent if success, < 0 otherwise
6091 * Possible errors:
6092 * ISO_NULL_POINTER, if parent, name or dest are NULL
6093 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6094 * ISO_OUT_OF_MEM
6095 *
6096 * @since 0.6.4
6097 */
6098int iso_tree_add_new_file(IsoDir *parent, const char *name, IsoStream *stream,
6099 IsoFile **file);
6100
6101/**
6102 * Create an IsoStream object from content which is stored in a dynamically
6103 * allocated memory buffer. The new stream will become owner of the buffer
6104 * and apply free() to it when the stream finally gets destroyed itself.
6105 *
6106 * @param buf
6107 * The dynamically allocated memory buffer with the stream content.
6108 * @param size
6109 * The number of bytes which may be read from buf.
6110 * @param stream
6111 * Will return a reference to the newly created stream.
6112 * @return
6113 * ISO_SUCCESS or <0 for error. E.g. ISO_NULL_POINTER, ISO_OUT_OF_MEM.
6114 *
6115 * @since 1.0.0
6116 */
6117int iso_memory_stream_new(unsigned char *buf, size_t size, IsoStream **stream);
6118
6119/**
6120 * Add a new symbolic link to the directory tree. Permissions are set to 0777,
6121 * owner and hidden atts are taken from parent. You can modify any of them
6122 * later.
6123 *
6124 * @param image
6125 * The image object to which the new directory shall belong.
6126 * @param parent
6127 * The directory node where the new symlink will be grafted in.
6128 * @param name
6129 * Name for the new symlink. If truncation mode is set to 1,
6130 * an oversized name gets truncated before further processing.
6131 * If a node with same name already exists on parent, this function
6132 * fails with ISO_NODE_NAME_NOT_UNIQUE.
6133 * @param dest
6134 * The destination path of the link. The components of this path are
6135 * not checked for being oversized.
6136 * @param link
6137 * Place where to store a pointer to the newly created link. No extra
6138 * ref is added, so you will need to call iso_node_ref() if you really
6139 * need it. You can pass NULL in this parameter if you don't need the
6140 * pointer
6141 * @return
6142 * number of nodes in parent if success, < 0 otherwise
6143 * Possible errors:
6144 * ISO_NULL_POINTER, if parent, name or dest are NULL
6145 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6146 * ISO_OUT_OF_MEM
6147 * ISO_RR_NAME_TOO_LONG
6148 *
6149 * @since 1.4.2
6150 */
6152 const char *name, const char *dest,
6153 IsoSymlink **link);
6154
6155/**
6156 * *** Deprecated ***
6157 * use iso_image_add_new_symlink() instead
6158 *
6159 * Add a new symlink to the directory tree without taking into respect name
6160 * truncation mode of an IsoImage.
6161 * For detailed description of parameters, see above
6162 * iso_image_add_new_isymlink().
6163 *
6164 * @param parent
6165 * the dir where the new symlink will be created
6166 * @param name
6167 * name for the new symlink.
6168 * @param dest
6169 * destination of the link
6170 * @param link
6171 * place where to store a pointer to the newly created link.
6172 * @return
6173 * number of nodes in parent if success, < 0 otherwise
6174 * Possible errors:
6175 * ISO_NULL_POINTER, if parent, name or dest are NULL
6176 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6177 * ISO_OUT_OF_MEM
6178 *
6179 * @since 0.6.2
6180 */
6181int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
6182 const char *dest, IsoSymlink **link);
6183
6184/**
6185 * Add a new special file to the directory tree. As far as libisofs concerns,
6186 * a special file is a block device, a character device, a FIFO (named pipe)
6187 * or a socket. You can choose the specific kind of file you want to add
6188 * by setting mode properly (see man 2 stat).
6189 *
6190 * Note that special files are only written to image when Rock Ridge
6191 * extensions are enabled. Moreover, a special file is just a directory entry
6192 * in the image tree, no data is written beyond that.
6193 *
6194 * Owner and hidden atts are taken from parent. You can modify any of them
6195 * later.
6196 *
6197 * @param image
6198 * The image object to which the new special file shall belong.
6199 * @param parent
6200 * The directory node where the new special file will be grafted in.
6201 * @param name
6202 * Name for the new special file. If truncation mode is set to 1,
6203 * an oversized name gets truncated before further processing.
6204 * If a node with same name already exists on parent, this function
6205 * fails with ISO_NODE_NAME_NOT_UNIQUE.
6206 * @param mode
6207 * File type and permissions for the new node. Note that only the file
6208 * types S_IFSOCK, S_IFBLK, S_IFCHR, and S_IFIFO are allowed.
6209 * S_IFLNK, S_IFREG, or S_IFDIR are not.
6210 * @param dev
6211 * Device ID, equivalent to the st_rdev field in man 2 stat.
6212 * @param special
6213 * Place where to store a pointer to the newly created special file. No
6214 * extra ref is added, so you will need to call iso_node_ref() if you
6215 * really need it. You can pass NULL in this parameter if you don't need
6216 * the pointer.
6217 * @return
6218 * Number of nodes in parent if success, < 0 otherwise
6219 * Possible errors:
6220 * ISO_NULL_POINTER, if parent, name or dest are NULL
6221 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6222 * ISO_WRONG_ARG_VALUE if you select a incorrect mode
6223 * ISO_OUT_OF_MEM
6224 * ISO_RR_NAME_TOO_LONG
6225 *
6226 * @since 1.4.2
6227 */
6229 const char *name, mode_t mode,
6230 dev_t dev, IsoSpecial **special);
6231
6232/**
6233 * *** Deprecated ***
6234 * use iso_image_add_new_special() instead
6235 *
6236 * Add a new special file to the directory tree without taking into respect name
6237 * truncation mode of an IsoImage.
6238 * For detailed description of parameters, see above
6239 * iso_image_add_new_special().
6240 *
6241 * @param parent
6242 * the dir where the new special file will be created
6243 * @param name
6244 * name for the new special file.
6245 * @param mode
6246 * file type and permissions for the new node.
6247 * @param dev
6248 * device ID, equivalent to the st_rdev field in man 2 stat.
6249 * @param special
6250 * place where to store a pointer to the newly created special file.
6251 * @return
6252 * number of nodes in parent if success, < 0 otherwise
6253 * Possible errors:
6254 * ISO_NULL_POINTER, if parent, name or dest are NULL
6255 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6256 * ISO_WRONG_ARG_VALUE if you select a incorrect mode
6257 * ISO_OUT_OF_MEM
6258 *
6259 * @since 0.6.2
6260 */
6261int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
6262 dev_t dev, IsoSpecial **special);
6263
6264/**
6265 * Set whether to follow or not symbolic links when added a file from a source
6266 * to IsoImage. Default behavior is to not follow symlinks.
6267 *
6268 * @since 0.6.2
6269 */
6271
6272/**
6273 * Get current setting for follow_symlinks.
6274 *
6275 * @see iso_tree_set_follow_symlinks
6276 * @since 0.6.2
6277 */
6279
6280/**
6281 * Set whether to skip or not disk files with names beginning by '.'
6282 * when adding a directory recursively.
6283 * Default behavior is to not ignore them.
6284 *
6285 * Clarification: This is not related to the IsoNode property to be hidden
6286 * in one or more of the resulting image trees as of
6287 * IsoHideNodeFlag and iso_node_set_hidden().
6288 *
6289 * @since 0.6.2
6290 */
6292
6293/**
6294 * Get current setting for ignore_hidden.
6295 *
6296 * @see iso_tree_set_ignore_hidden
6297 * @since 0.6.2
6298 */
6300
6301/**
6302 * Set the replace mode, that defines the behavior of libisofs when adding
6303 * a node whit the same name that an existent one, during a recursive
6304 * directory addition.
6305 *
6306 * @since 0.6.2
6307 */
6309
6310/**
6311 * Get current setting for replace_mode.
6312 *
6313 * @see iso_tree_set_replace_mode
6314 * @since 0.6.2
6315 */
6317
6318/**
6319 * Set whether to skip or not special files. Default behavior is to not skip
6320 * them. Note that, despite of this setting, special files will never be added
6321 * to an image unless RR extensions were enabled.
6322 *
6323 * @param image
6324 * The image to manipulate.
6325 * @param skip
6326 * Bitmask to determine what kind of special files will be skipped:
6327 * bit0: ignore FIFOs
6328 * bit1: ignore Sockets
6329 * bit2: ignore char devices
6330 * bit3: ignore block devices
6331 *
6332 * @since 0.6.2
6333 */
6335
6336/**
6337 * Get current setting for ignore_special.
6338 *
6339 * @see iso_tree_set_ignore_special
6340 * @since 0.6.2
6341 */
6343
6344/**
6345 * Add a excluded path. These are paths that won't never added to image, and
6346 * will be excluded even when adding recursively its parent directory.
6347 *
6348 * For example, in
6349 *
6350 * iso_tree_add_exclude(image, "/home/user/data/private");
6351 * iso_tree_add_dir_rec(image, root, "/home/user/data");
6352 *
6353 * the directory /home/user/data/private won't be added to image.
6354 *
6355 * However, if you explicitly add a deeper dir, it won't be excluded. i.e.,
6356 * in the following example.
6357 *
6358 * iso_tree_add_exclude(image, "/home/user/data");
6359 * iso_tree_add_dir_rec(image, root, "/home/user/data/private");
6360 *
6361 * the directory /home/user/data/private is added. On the other, side, and
6362 * following the example above,
6363 *
6364 * iso_tree_add_dir_rec(image, root, "/home/user");
6365 *
6366 * will exclude the directory "/home/user/data".
6367 *
6368 * Absolute paths are not mandatory, you can, for example, add a relative
6369 * path such as:
6370 *
6371 * iso_tree_add_exclude(image, "private");
6372 * iso_tree_add_exclude(image, "user/data");
6373 *
6374 * to exclude, respectively, all files or dirs named private, and also all
6375 * files or dirs named data that belong to a folder named "user". Note that the
6376 * above rule about deeper dirs is still valid. i.e., if you call
6377 *
6378 * iso_tree_add_dir_rec(image, root, "/home/user/data/music");
6379 *
6380 * it is included even containing "user/data" string. However, a possible
6381 * "/home/user/data/music/user/data" is not added.
6382 *
6383 * Usual wildcards, such as * or ? are also supported, with the usual meaning
6384 * as stated in "man 7 glob". For example
6385 *
6386 * // to exclude backup text files
6387 * iso_tree_add_exclude(image, "*.~");
6388 *
6389 * @return
6390 * 1 on success, < 0 on error
6391 *
6392 * @since 0.6.2
6393 */
6394int iso_tree_add_exclude(IsoImage *image, const char *path);
6395
6396/**
6397 * Remove a previously added exclude.
6398 *
6399 * @see iso_tree_add_exclude
6400 * @return
6401 * 1 on success, 0 exclude do not exists, < 0 on error
6402 *
6403 * @since 0.6.2
6404 */
6405int iso_tree_remove_exclude(IsoImage *image, const char *path);
6406
6407/**
6408 * Set a callback function that libisofs will call for each file that is
6409 * added to the given image by a recursive addition function. This includes
6410 * image import.
6411 *
6412 * @param image
6413 * The image to manipulate.
6414 * @param report
6415 * pointer to a function that will be called just before a file will be
6416 * added to the image. You can control whether the file will be in fact
6417 * added or ignored.
6418 * This function should return 1 to add the file, 0 to ignore it and
6419 * continue, < 0 to abort the process
6420 * NULL is allowed if you don't want any callback.
6421 *
6422 * @since 0.6.2
6423 */
6425 int (*report)(IsoImage*, IsoFileSource*));
6426
6427/**
6428 * Add a new node to the image tree, from an existing file.
6429 *
6430 * TODO comment Builder and Filesystem related issues when exposing both
6431 *
6432 * All attributes will be taken from the source file. The appropriate file
6433 * type will be created.
6434 *
6435 * @param image
6436 * The image
6437 * @param parent
6438 * The directory in the image tree where the node will be added.
6439 * @param path
6440 * The absolute path of the file in the local filesystem.
6441 * The node will have the same leaf name as the file on disk, possibly
6442 * truncated according to iso_image_set_truncate_mode().
6443 * Its directory path depends on the parent node.
6444 * @param node
6445 * place where to store a pointer to the newly added file. No
6446 * extra ref is added, so you will need to call iso_node_ref() if you
6447 * really need it. You can pass NULL in this parameter if you don't need
6448 * the pointer.
6449 * @return
6450 * number of nodes in parent if success, < 0 otherwise
6451 * Possible errors:
6452 * ISO_NULL_POINTER, if image, parent or path are NULL
6453 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6454 * ISO_OUT_OF_MEM
6455 * ISO_RR_NAME_TOO_LONG
6456 *
6457 * @since 0.6.2
6458 */
6459int iso_tree_add_node(IsoImage *image, IsoDir *parent, const char *path,
6460 IsoNode **node);
6461
6462/**
6463 * This is a more versatile form of iso_tree_add_node which allows to set
6464 * the node name in ISO image already when it gets added.
6465 *
6466 * Add a new node to the image tree, from an existing file, and with the
6467 * given name, that must not exist on dir.
6468 *
6469 * @param image
6470 * The image
6471 * @param parent
6472 * The directory in the image tree where the node will be added.
6473 * @param name
6474 * The leaf name that the node will have on image, possibly truncated
6475 * according to iso_image_set_truncate_mode().
6476 * Its directory path depends on the parent node.
6477 * @param path
6478 * The absolute path of the file in the local filesystem.
6479 * @param node
6480 * place where to store a pointer to the newly added file. No
6481 * extra ref is added, so you will need to call iso_node_ref() if you
6482 * really need it. You can pass NULL in this parameter if you don't need
6483 * the pointer.
6484 * @return
6485 * number of nodes in parent if success, < 0 otherwise
6486 * Possible errors:
6487 * ISO_NULL_POINTER, if image, parent or path are NULL
6488 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6489 * ISO_OUT_OF_MEM
6490 * ISO_RR_NAME_TOO_LONG
6491 *
6492 * @since 0.6.4
6493 */
6494int iso_tree_add_new_node(IsoImage *image, IsoDir *parent, const char *name,
6495 const char *path, IsoNode **node);
6496
6497/**
6498 * Add a new node to the image tree with the given name that must not exist
6499 * on dir. The node data content will be a byte interval out of the data
6500 * content of a file in the local filesystem.
6501 *
6502 * @param image
6503 * The image
6504 * @param parent
6505 * The directory in the image tree where the node will be added.
6506 * @param name
6507 * The leaf name that the node will have on image, possibly truncated
6508 * according to iso_image_set_truncate_mode().
6509 * Its directory path depends on the parent node.
6510 * @param path
6511 * The absolute path of the random-access capable file in the local
6512 * filesystem. Only regular files and device files are supported.
6513 * On Linux, only regular files and block device offer random-access.
6514 * @param offset
6515 * Byte number in the given file from where to start reading data.
6516 * @param size
6517 * Max size of the file. This may be more than actually available from
6518 * byte offset to the end of the file in the local filesystem.
6519 * @param node
6520 * place where to store a pointer to the newly added file. No
6521 * extra ref is added, so you will need to call iso_node_ref() if you
6522 * really need it. You can pass NULL in this parameter if you don't need
6523 * the pointer.
6524 * @return
6525 * number of nodes in parent if success, < 0 otherwise
6526 * Possible errors:
6527 * ISO_NULL_POINTER, if image, parent or path are NULL
6528 * ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
6529 * ISO_OUT_OF_MEM
6530 * ISO_RR_NAME_TOO_LONG
6531 * ISO_WRONG_ARG_VALUE, if path is not suitable for random access
6532 *
6533 * @since 0.6.4
6534 *
6535 * Device files as path: @since 1.5.6
6536 */
6538 const char *name, const char *path,
6539 off_t offset, off_t size,
6540 IsoNode **node);
6541
6542/**
6543 * Create a copy of the given node under a different path. If the node is
6544 * actually a directory then clone its whole subtree.
6545 * This call may fail because an IsoFile is encountered which gets fed by an
6546 * IsoStream which cannot be cloned. See also IsoStream_Iface method
6547 * clone_stream().
6548 * Surely clonable node types are:
6549 * IsoDir,
6550 * IsoSymlink,
6551 * IsoSpecial,
6552 * IsoFile from a loaded ISO image,
6553 * IsoFile referring to local filesystem files,
6554 * IsoFile created by iso_tree_add_new_file
6555 * from a stream created by iso_memory_stream_new(),
6556 * IsoFile created by iso_tree_add_new_cut_out_node()
6557 * Silently ignored are nodes of type IsoBoot.
6558 * An IsoFile node with IsoStream filters can be cloned if all those filters
6559 * are clonable and the node would be clonable without filter.
6560 * Clonable IsoStream filters are created by:
6561 * iso_file_add_zisofs_filter()
6562 * iso_file_add_gzip_filter()
6563 * iso_file_add_external_filter()
6564 * An IsoNode with extended information as of iso_node_add_xinfo() can only be
6565 * cloned if each of the iso_node_xinfo_func instances is associated to a
6566 * clone function. See iso_node_xinfo_make_clonable().
6567 * All internally used classes of extended information are clonable.
6568 *
6569 * The IsoImage context defines a maximum permissible name length and a mode
6570 * how to react on oversized names. See iso_image_set_truncate_mode().
6571 *
6572 * @param image
6573 * The image object to which the node belongs.
6574 * @param node
6575 * The node to be cloned.
6576 * @param new_parent
6577 * The existing directory node where to insert the cloned node.
6578 * @param new_name
6579 * The name for the cloned node. It must not yet exist in new_parent,
6580 * unless it is a directory and node is a directory and flag bit0 is set.
6581 * @param new_node
6582 * Will return a pointer (without reference) to the newly created clone.
6583 * @param flag
6584 * Bitfield for control purposes. Submit any undefined bits as 0.
6585 * bit0= Merge directories rather than returning ISO_NODE_NAME_NOT_UNIQUE.
6586 * This will not allow to overwrite any existing node.
6587 * Attributes of existing directories will not be overwritten.
6588 * bit1= issue warning in case of new_name truncation
6589 * @return
6590 * <0 means error, 1 = new node created,
6591 * 2 = if flag bit0 is set: new_node is a directory which already existed.
6592 *
6593 * @since 1.4.2
6594 */
6595int iso_image_tree_clone(IsoImage *image, IsoNode *node, IsoDir *new_parent,
6596 char *new_name, IsoNode **new_node, int flag);
6597
6598/**
6599 * *** Deprecated ***
6600 * use iso_image_tree_clone() instead
6601 *
6602 * Create a copy of the given node under a different path without taking
6603 * into respect name truncation mode of an IsoImage.
6604 *
6605 * @param node
6606 * The node to be cloned.
6607 * @param new_parent
6608 * The existing directory node where to insert the cloned node.
6609 * @param new_name
6610 * The name for the cloned node. It must not yet exist in new_parent,
6611 * unless it is a directory and node is a directory and flag bit0 is set.
6612 * @param new_node
6613 * Will return a pointer (without reference) to the newly created clone.
6614 * @param flag
6615 * Bitfield for control purposes. Submit any undefined bits as 0.
6616 * bit0= Merge directories rather than returning ISO_NODE_NAME_NOT_UNIQUE.
6617 * This will not allow to overwrite any existing node.
6618 * Attributes of existing directories will not be overwritten.
6619 * @return
6620 * <0 means error, 1 = new node created,
6621 * 2 = if flag bit0 is set: new_node is a directory which already existed.
6622 *
6623 * @since 1.0.2
6624 */
6626 IsoDir *new_parent, char *new_name, IsoNode **new_node,
6627 int flag);
6628
6629/**
6630 * Add the contents of a dir to a given directory of the iso tree.
6631 *
6632 * There are several options to control what files are added or how they are
6633 * managed. Take a look at iso_tree_set_* functions to see different options
6634 * for recursive directory addition.
6635 *
6636 * TODO comment Builder and Filesystem related issues when exposing both
6637 *
6638 * @param image
6639 * The image to which the directory belongs.
6640 * @param parent
6641 * Directory on the image tree where to add the contents of the dir
6642 * @param dir
6643 * Path to a dir in the filesystem
6644 * @return
6645 * number of nodes in parent if success, < 0 otherwise
6646 *
6647 * @since 0.6.2
6648 */
6649int iso_tree_add_dir_rec(IsoImage *image, IsoDir *parent, const char *dir);
6650
6651/**
6652 * Inquire whether some local filesystem xattr namespace could not be explored
6653 * during node building.This may happen due to lack of administrator privileges
6654 * e.g. on FreeBSD namespace "system".
6655 * It may well be that the processed local files have no attributes which
6656 * would require special privileges. But already their existence was neither
6657 * denied nor confirmed.
6658 *
6659 * @param image
6660 * The image to inquire.
6661 * @param flag
6662 * Bitfield for control purposes:
6663 * bit0 = reset internal value to 0
6664 * @return
6665 * 1 = Exploration was prevented
6666 * 0 = No such prevention occurred
6667 *
6668 * @since 1.5.0
6669 */
6671
6672
6673/**
6674 * Locate a node by its absolute path in the image.
6675 * The IsoImage context defines a maximum permissible name length and a mode
6676 * how to react on oversized names. See iso_image_set_truncate_mode().
6677 *
6678 * @param image
6679 * The image to which the node belongs.
6680 * @param path
6681 * File path beginning at the root directory of image. If truncation mode
6682 * is set to 1, oversized path components will be truncated before lookup.
6683 * @param node
6684 * Location for a pointer to the node, it will be filled with NULL if the
6685 * given path does not exists on image.
6686 * The node will be owned by the image and shouldn't be unref(). Just call
6687 * iso_node_ref() to get your own reference to the node.
6688 * Note that you can pass NULL is the only thing you want to do is check
6689 * if a node with such path really exists.
6690 *
6691 * @return
6692 * 1 node found
6693 * 0 no truncation was needed, path not found in image
6694 * 2 truncation happened, truncated path component not found in parent dir
6695 * < 0 error, see iso_dir_get_node().
6696 *
6697 * @since 1.4.2
6698 */
6699int iso_image_path_to_node(IsoImage *image, const char *path, IsoNode **node);
6700
6701/**
6702 * *** Deprecated ***
6703 * In most cases use iso_image_path_to_node() instead
6704 *
6705 * Locate a node by its absolute path on image without taking into respect
6706 * name truncation mode of the image.
6707 *
6708 * @param image
6709 * The image to which the node belongs.
6710 * @param path
6711 * File path beginning at the root directory of image. No truncation will
6712 * happen.
6713 * @param node
6714 * Location for a pointer to the node, it will be filled with NULL if the
6715 * given path does not exists on image. See iso_image_path_to_node().
6716 * @return
6717 * 1 found, 0 not found, < 0 error
6718 *
6719 * @since 0.6.2
6720 */
6721int iso_tree_path_to_node(IsoImage *image, const char *path, IsoNode **node);
6722
6723/**
6724 * Get the absolute path on image of the given node.
6725 *
6726 * @return
6727 * The path on the image, that must be freed when no more needed. If the
6728 * given node is not added to any image, this returns NULL.
6729 * @since 0.6.4
6730 */
6732
6733/**
6734 * Get the destination node of a symbolic link within the IsoImage.
6735 *
6736 * @param img
6737 * The image wherein to try resolving the link.
6738 * @param sym
6739 * The symbolic link node which to resolve.
6740 * @param res
6741 * Will return the found destination node, in case of success.
6742 * Call iso_node_ref() / iso_node_unref() if you intend to use the node
6743 * over API calls which might in any event delete it.
6744 * @param depth
6745 * Prevents endless loops. Submit as 0.
6746 * @param flag
6747 * Bitfield for control purposes. Submit 0 for now.
6748 * @return
6749 * 1 on success,
6750 * < 0 on failure, especially ISO_DEEP_SYMLINK and ISO_DEAD_SYMLINK
6751 *
6752 * @since 1.2.4
6753 */
6755 int *depth, int flag);
6756
6757/* Maximum number link resolution steps before ISO_DEEP_SYMLINK gets
6758 * returned by iso_tree_resolve_symlink().
6759 *
6760 * @since 1.2.4
6761*/
6762#define LIBISO_MAX_LINK_DEPTH 100
6763
6764/**
6765 * Increments the reference counting of the given IsoDataSource.
6766 *
6767 * @since 0.6.2
6768 */
6770
6771/**
6772 * Decrements the reference counting of the given IsoDataSource, freeing it
6773 * if refcount reach 0.
6774 *
6775 * @since 0.6.2
6776 */
6778
6779/**
6780 * Create a new IsoDataSource from a local file. This is suitable for
6781 * accessing regular files or block devices with ISO images.
6782 *
6783 * @param path
6784 * The absolute path of the file
6785 * @param src
6786 * Will be filled with the pointer to the newly created data source.
6787 * @return
6788 * 1 on success, < 0 on error.
6789 *
6790 * @since 0.6.2
6791 */
6793
6794/**
6795 * Get the status of the buffer used by a burn_source.
6796 *
6797 * @param b
6798 * A burn_source previously obtained with
6799 * iso_image_create_burn_source().
6800 * @param size
6801 * Will be filled with the total size of the buffer, in bytes
6802 * @param free_bytes
6803 * Will be filled with the bytes currently available in buffer
6804 * @return
6805 * < 0 error, > 0 state:
6806 * 1="active" : input and consumption are active
6807 * 2="ending" : input has ended without error
6808 * 3="failing" : input had error and ended,
6809 * 5="abandoned" : consumption has ended prematurely
6810 * 6="ended" : consumption has ended without input error
6811 * 7="aborted" : consumption has ended after input error
6812 *
6813 * @since 0.6.2
6814 */
6815int iso_ring_buffer_get_status(struct burn_source *b, size_t *size,
6816 size_t *free_bytes);
6817
6818#define ISO_MSGS_MESSAGE_LEN 4096
6819
6820/**
6821 * Control queueing and stderr printing of messages from libisofs.
6822 * Severity may be one of "NEVER", "FATAL", "SORRY", "WARNING", "HINT",
6823 * "NOTE", "UPDATE", "DEBUG", "ALL".
6824 *
6825 * @param queue_severity Gives the minimum limit for messages to be queued.
6826 * Default: "NEVER". If you queue messages then you
6827 * must consume them by iso_obtain_msgs().
6828 * @param print_severity Does the same for messages to be printed directly
6829 * to stderr.
6830 * @param print_id A text prefix to be printed before the message.
6831 * @return >0 for success, <=0 for error
6832 *
6833 * @since 0.6.2
6834 */
6835int iso_set_msgs_severities(char *queue_severity, char *print_severity,
6836 char *print_id);
6837
6838/**
6839 * Obtain the oldest pending libisofs message from the queue which has at
6840 * least the given minimum_severity. This message and any older message of
6841 * lower severity will get discarded from the queue and is then lost forever.
6842 *
6843 * Severity may be one of "NEVER", "FATAL", "SORRY", "WARNING", "HINT",
6844 * "NOTE", "UPDATE", "DEBUG", "ALL". To call with minimum_severity "NEVER"
6845 * will discard the whole queue.
6846 *
6847 * @param minimum_severity
6848 * Threshold
6849 * @param error_code
6850 * Will become a unique error code as listed at the end of this header
6851 * @param imgid
6852 * Id of the image that was issued the message.
6853 * @param msg_text
6854 * Must provide at least ISO_MSGS_MESSAGE_LEN bytes.
6855 * @param severity
6856 * Will become the severity related to the message and should provide at
6857 * least 80 bytes.
6858 * @return
6859 * 1 if a matching item was found, 0 if not, <0 for severe errors
6860 *
6861 * @since 0.6.2
6862 */
6863int iso_obtain_msgs(char *minimum_severity, int *error_code, int *imgid,
6864 char msg_text[], char severity[]);
6865
6866
6867/**
6868 * Submit a message to the libisofs queueing system. It will be queued or
6869 * printed as if it was generated by libisofs itself.
6870 *
6871 * @param error_code
6872 * The unique error code of your message.
6873 * Submit 0 if you do not have reserved error codes within the libburnia
6874 * project.
6875 * @param msg_text
6876 * Not more than ISO_MSGS_MESSAGE_LEN characters of message text.
6877 * @param os_errno
6878 * Eventual errno related to the message. Submit 0 if the message is not
6879 * related to a operating system error.
6880 * @param severity
6881 * One of "ABORT", "FATAL", "FAILURE", "SORRY", "WARNING", "HINT", "NOTE",
6882 * "UPDATE", "DEBUG". Defaults to "FATAL".
6883 * @param origin
6884 * Submit 0 for now.
6885 * @return
6886 * 1 if message was delivered, <=0 if failure
6887 *
6888 * @since 0.6.4
6889 */
6890int iso_msgs_submit(int error_code, char msg_text[], int os_errno,
6891 char severity[], int origin);
6892
6893
6894/**
6895 * Convert a severity name into a severity number, which gives the severity
6896 * rank of the name.
6897 *
6898 * @param severity_name
6899 * A name as with iso_msgs_submit(), e.g. "SORRY".
6900 * @param severity_number
6901 * The rank number: the higher, the more severe.
6902 * @return
6903 * >0 success, <=0 failure
6904 *
6905 * @since 0.6.4
6906 */
6907int iso_text_to_sev(char *severity_name, int *severity_number);
6908
6909
6910/**
6911 * Convert a severity number into a severity name
6912 *
6913 * @param severity_number
6914 * The rank number: the higher, the more severe.
6915 * @param severity_name
6916 * A name as with iso_msgs_submit(), e.g. "SORRY".
6917 *
6918 * @since 0.6.4
6919 */
6920int iso_sev_to_text(int severity_number, char **severity_name);
6921
6922
6923/**
6924 * Get the id of an IsoImage, used for message reporting. This message id,
6925 * retrieved with iso_obtain_msgs(), can be used to distinguish what
6926 * IsoImage has issued a given message.
6927 *
6928 * @since 0.6.2
6929 */
6931
6932/**
6933 * Get a textual description of a libisofs error.
6934 *
6935 * @since 0.6.2
6936 */
6937const char *iso_error_to_msg(int errcode);
6938
6939/**
6940 * Get the severity of a given error code
6941 * @return
6942 * 0x10000000 -> DEBUG
6943 * 0x20000000 -> UPDATE
6944 * 0x30000000 -> NOTE
6945 * 0x40000000 -> HINT
6946 * 0x50000000 -> WARNING
6947 * 0x60000000 -> SORRY
6948 * 0x64000000 -> MISHAP
6949 * 0x68000000 -> FAILURE
6950 * 0x70000000 -> FATAL
6951 * 0x71000000 -> ABORT
6952 *
6953 * @since 0.6.2
6954 */
6956
6957/**
6958 * Get the priority of a given error.
6959 * @return
6960 * 0x00000000 -> ZERO
6961 * 0x10000000 -> LOW
6962 * 0x20000000 -> MEDIUM
6963 * 0x30000000 -> HIGH
6964 *
6965 * @since 0.6.2
6966 */
6968
6969/**
6970 * Get the message queue code of a libisofs error.
6971 */
6973
6974/**
6975 * Set the minimum error severity that causes a libisofs operation to
6976 * be aborted as soon as possible.
6977 *
6978 * @param severity
6979 * one of "FAILURE", "MISHAP", "SORRY", "WARNING", "HINT", "NOTE".
6980 * Severities greater or equal than FAILURE always cause program to abort.
6981 * Severities under NOTE won't never cause function abort.
6982 * @return
6983 * Previous abort priority on success, < 0 on error.
6984 *
6985 * @since 0.6.2
6986 */
6987int iso_set_abort_severity(char *severity);
6988
6989/**
6990 * Return the messenger object handle used by libisofs. This handle
6991 * may be used by related libraries to their own compatible
6992 * messenger objects and thus to direct their messages to the libisofs
6993 * message queue. See also: libburn, API function burn_set_messenger().
6994 *
6995 * @return the handle. Do only use with compatible
6996 *
6997 * @since 0.6.2
6998 */
7000
7001/**
7002 * Take a ref to the given IsoFileSource.
7003 *
7004 * @since 0.6.2
7005 */
7007
7008/**
7009 * Drop your ref to the given IsoFileSource, eventually freeing the associated
7010 * system resources.
7011 *
7012 * @since 0.6.2
7013 */
7015
7016/*
7017 * this are just helpers to invoque methods in class
7018 */
7019
7020/**
7021 * Get the absolute path in the filesystem this file source belongs to.
7022 *
7023 * @return
7024 * the path of the FileSource inside the filesystem, it should be
7025 * freed when no more needed.
7026 *
7027 * @since 0.6.2
7028 */
7030
7031/**
7032 * Get the name of the file, with the dir component of the path.
7033 *
7034 * @return
7035 * the name of the file, it should be freed when no more needed.
7036 *
7037 * @since 0.6.2
7038 */
7040
7041/**
7042 * Get information about the file.
7043 * @return
7044 * 1 success, < 0 error
7045 * Error codes:
7046 * ISO_FILE_ACCESS_DENIED
7047 * ISO_FILE_BAD_PATH
7048 * ISO_FILE_DOESNT_EXIST
7049 * ISO_OUT_OF_MEM
7050 * ISO_FILE_ERROR
7051 * ISO_NULL_POINTER
7052 *
7053 * @since 0.6.2
7054 */
7055int iso_file_source_lstat(IsoFileSource *src, struct stat *info);
7056
7057/**
7058 * Check if the process has access to read file contents. Note that this
7059 * is not necessarily related with (l)stat functions. For example, in a
7060 * filesystem implementation to deal with an ISO image, if the user has
7061 * read access to the image it will be able to read all files inside it,
7062 * despite of the particular permission of each file in the RR tree, that
7063 * are what the above functions return.
7064 *
7065 * @return
7066 * 1 if process has read access, < 0 on error
7067 * Error codes:
7068 * ISO_FILE_ACCESS_DENIED
7069 * ISO_FILE_BAD_PATH
7070 * ISO_FILE_DOESNT_EXIST
7071 * ISO_OUT_OF_MEM
7072 * ISO_FILE_ERROR
7073 * ISO_NULL_POINTER
7074 *
7075 * @since 0.6.2
7076 */
7078
7079/**
7080 * Get information about the file. If the file is a symlink, the info
7081 * returned refers to the destination.
7082 *
7083 * @return
7084 * 1 success, < 0 error
7085 * Error codes:
7086 * ISO_FILE_ACCESS_DENIED
7087 * ISO_FILE_BAD_PATH
7088 * ISO_FILE_DOESNT_EXIST
7089 * ISO_OUT_OF_MEM
7090 * ISO_FILE_ERROR
7091 * ISO_NULL_POINTER
7092 *
7093 * @since 0.6.2
7094 */
7095int iso_file_source_stat(IsoFileSource *src, struct stat *info);
7096
7097/**
7098 * Opens the source.
7099 * @return 1 on success, < 0 on error
7100 * Error codes:
7101 * ISO_FILE_ALREADY_OPENED
7102 * ISO_FILE_ACCESS_DENIED
7103 * ISO_FILE_BAD_PATH
7104 * ISO_FILE_DOESNT_EXIST
7105 * ISO_OUT_OF_MEM
7106 * ISO_FILE_ERROR
7107 * ISO_NULL_POINTER
7108 *
7109 * @since 0.6.2
7110 */
7112
7113/**
7114 * Close a previously opened file
7115 * @return 1 on success, < 0 on error
7116 * Error codes:
7117 * ISO_FILE_ERROR
7118 * ISO_NULL_POINTER
7119 * ISO_FILE_NOT_OPENED
7120 *
7121 * @since 0.6.2
7122 */
7124
7125/**
7126 * Attempts to read up to count bytes from the given source into
7127 * the buffer starting at buf.
7128 *
7129 * The file src must be open() before calling this, and close() when no
7130 * more needed. Not valid for dirs. On symlinks it reads the destination
7131 * file.
7132 *
7133 * @param src
7134 * The given source
7135 * @param buf
7136 * Pointer to a buffer of at least count bytes where the read data will be
7137 * stored
7138 * @param count
7139 * Bytes to read
7140 * @return
7141 * number of bytes read, 0 if EOF, < 0 on error
7142 * Error codes:
7143 * ISO_FILE_ERROR
7144 * ISO_NULL_POINTER
7145 * ISO_FILE_NOT_OPENED
7146 * ISO_WRONG_ARG_VALUE -> if count == 0
7147 * ISO_FILE_IS_DIR
7148 * ISO_OUT_OF_MEM
7149 * ISO_INTERRUPTED
7150 *
7151 * @since 0.6.2
7152 */
7153int iso_file_source_read(IsoFileSource *src, void *buf, size_t count);
7154
7155/**
7156 * Repositions the offset of the given IsoFileSource (must be opened) to the
7157 * given offset according to the value of flag.
7158 *
7159 * @param src
7160 * The given source
7161 * @param offset
7162 * in bytes
7163 * @param flag
7164 * 0 The offset is set to offset bytes (SEEK_SET)
7165 * 1 The offset is set to its current location plus offset bytes
7166 * (SEEK_CUR)
7167 * 2 The offset is set to the size of the file plus offset bytes
7168 * (SEEK_END).
7169 * @return
7170 * Absolute offset position on the file, or < 0 on error. Cast the
7171 * returning value to int to get a valid libisofs error.
7172 * @since 0.6.4
7173 */
7174off_t iso_file_source_lseek(IsoFileSource *src, off_t offset, int flag);
7175
7176/**
7177 * Read a directory.
7178 *
7179 * Each call to this function will return a new child, until we reach
7180 * the end of file (i.e, no more children), in that case it returns 0.
7181 *
7182 * The dir must be open() before calling this, and close() when no more
7183 * needed. Only valid for dirs.
7184 *
7185 * Note that "." and ".." children MUST NOT BE returned.
7186 *
7187 * @param src
7188 * The given source
7189 * @param child
7190 * pointer to be filled with the given child. Undefined on error or OEF
7191 * @return
7192 * 1 on success, 0 if EOF (no more children), < 0 on error
7193 * Error codes:
7194 * ISO_FILE_ERROR
7195 * ISO_NULL_POINTER
7196 * ISO_FILE_NOT_OPENED
7197 * ISO_FILE_IS_NOT_DIR
7198 * ISO_OUT_OF_MEM
7199 *
7200 * @since 0.6.2
7201 */
7203
7204/**
7205 * Read the destination of a symlink. You don't need to open the file
7206 * to call this.
7207 *
7208 * @param src
7209 * An IsoFileSource corresponding to a symbolic link.
7210 * @param buf
7211 * Allocated buffer of at least bufsiz bytes.
7212 * The destination string will be copied there, and it will be 0-terminated
7213 * if the return value indicates success or ISO_RR_PATH_TOO_LONG.
7214 * @param bufsiz
7215 * Maximum number of buf characters + 1. The string will be truncated if
7216 * it is larger than bufsiz - 1 and ISO_RR_PATH_TOO_LONG. will be returned.
7217 * @return
7218 * 1 on success, < 0 on error
7219 * Error codes:
7220 * ISO_FILE_ERROR
7221 * ISO_NULL_POINTER
7222 * ISO_WRONG_ARG_VALUE -> if bufsiz <= 0
7223 * ISO_FILE_IS_NOT_SYMLINK
7224 * ISO_OUT_OF_MEM
7225 * ISO_FILE_BAD_PATH
7226 * ISO_FILE_DOESNT_EXIST
7227 * ISO_RR_PATH_TOO_LONG (@since 1.0.6)
7228 *
7229 * @since 0.6.2
7230 */
7231int iso_file_source_readlink(IsoFileSource *src, char *buf, size_t bufsiz);
7232
7233
7234/**
7235 * Get the AAIP string with encoded ACL and xattr.
7236 * (Not to be confused with ECMA-119 Extended Attributes).
7237 * @param src The file source object to be inquired.
7238 * @param aa_string Returns a pointer to the AAIP string data. If no AAIP
7239 * string is available, *aa_string becomes NULL.
7240 * (See doc/susp_aaip_2_0.txt for the meaning of AAIP.)
7241 * The caller is responsible for finally calling free()
7242 * on non-NULL results.
7243 * @param flag Bitfield for control purposes
7244 * bit0= Transfer ownership of AAIP string data.
7245 * src will free the eventual cached data and might
7246 * not be able to produce it again.
7247 * bit1= No need to get ACL (but no guarantee of exclusion)
7248 * bit2= No need to get xattr (but no guarantee of exclusion)
7249 * bit3= if not bit2: import all xattr namespaces from
7250 * local filesystem, not only "user."
7251 * @since 1.5.0
7252 * @return 1 means success (*aa_string == NULL is possible)
7253 * <0 means failure and must b a valid libisofs error code
7254 * (e.g. ISO_FILE_ERROR if no better one can be found).
7255 * @since 0.6.14
7256 */
7258 unsigned char **aa_string, int flag);
7259
7260/**
7261 * Get the filesystem for this source. No extra ref is added, so you
7262 * must not unref the IsoFilesystem.
7263 *
7264 * @return
7265 * The filesystem, NULL on error
7266 *
7267 * @since 0.6.2
7268 */
7270
7271/**
7272 * Take a ref to the given IsoFilesystem
7273 *
7274 * @since 0.6.2
7275 */
7277
7278/**
7279 * Drop your ref to the given IsoFilesystem, evetually freeing associated
7280 * resources.
7281 *
7282 * @since 0.6.2
7283 */
7285
7286/**
7287 * Create a new IsoFilesystem to access a existent ISO image.
7288 *
7289 * @param src
7290 * Data source to access data.
7291 * @param opts
7292 * Image read options
7293 * @param msgid
7294 * An image identifier, obtained with iso_image_get_msg_id(), used to
7295 * associated messages issued by the filesystem implementation with an
7296 * existent image. If you are not using this filesystem in relation with
7297 * any image context, just use 0x1fffff as the value for this parameter.
7298 * @param fs
7299 * Will be filled with a pointer to the filesystem that can be used
7300 * to access image contents.
7301 * @return
7302 * 1 on success, < 0 on error
7303 *
7304 * @since 0.6.2
7305 */
7307 IsoImageFilesystem **fs);
7308
7309/**
7310 * Get the volset identifier for an existent image. The returned string belong
7311 * to the IsoImageFilesystem and shouldn't be free() nor modified.
7312 *
7313 * @since 0.6.2
7314 */
7316
7317/**
7318 * Get the volume identifier for an existent image. The returned string belong
7319 * to the IsoImageFilesystem and shouldn't be free() nor modified.
7320 *
7321 * @since 0.6.2
7322 */
7324
7325/**
7326 * Get the publisher identifier for an existent image. The returned string
7327 * belong to the IsoImageFilesystem and shouldn't be free() nor modified.
7328 *
7329 * @since 0.6.2
7330 */
7332
7333/**
7334 * Get the data preparer identifier for an existent image. The returned string
7335 * belong to the IsoImageFilesystem and shouldn't be free() nor modified.
7336 *
7337 * @since 0.6.2
7338 */
7340
7341/**
7342 * Get the system identifier for an existent image. The returned string belong
7343 * to the IsoImageFilesystem and shouldn't be free() nor modified.
7344 *
7345 * @since 0.6.2
7346 */
7348
7349/**
7350 * Get the application identifier for an existent image. The returned string
7351 * belong to the IsoImageFilesystem and shouldn't be free() nor modified.
7352 *
7353 * @since 0.6.2
7354 */
7356
7357/**
7358 * Get the copyright file identifier for an existent image. The returned string
7359 * belong to the IsoImageFilesystem and shouldn't be free() nor modified.
7360 *
7361 * @since 0.6.2
7362 */
7364
7365/**
7366 * Get the abstract file identifier for an existent image. The returned string
7367 * belong to the IsoImageFilesystem and shouldn't be free() nor modified.
7368 *
7369 * @since 0.6.2
7370 */
7372
7373/**
7374 * Get the biblio file identifier for an existent image. The returned string
7375 * belong to the IsoImageFilesystem and shouldn't be free() nor modified.
7376 *
7377 * @since 0.6.2
7378 */
7380
7381/**
7382 * Increment reference count of an IsoStream.
7383 *
7384 * @since 0.6.4
7385 */
7387
7388/**
7389 * Decrement reference count of an IsoStream, and eventually free it if
7390 * refcount reach 0.
7391 *
7392 * @since 0.6.4
7393 */
7395
7396/**
7397 * Opens the given stream. Remember to close the Stream before writing the
7398 * image.
7399 *
7400 * @return
7401 * 1 on success, 2 file greater than expected, 3 file smaller than
7402 * expected, < 0 on error
7403 *
7404 * @since 0.6.4
7405 */
7407
7408/**
7409 * Close a previously opened IsoStream.
7410 *
7411 * @return
7412 * 1 on success, < 0 on error
7413 *
7414 * @since 0.6.4
7415 */
7417
7418/**
7419 * Get the size of a given stream. This function should always return the same
7420 * size, even if the underlying source size changes, unless you call
7421 * iso_stream_update_size().
7422 *
7423 * @return
7424 * IsoStream size in bytes
7425 *
7426 * @since 0.6.4
7427 */
7429
7430/**
7431 * Attempts to read up to count bytes from the given stream into
7432 * the buffer starting at buf.
7433 *
7434 * The stream must be open() before calling this, and close() when no
7435 * more needed.
7436 *
7437 * @return
7438 * number of bytes read, 0 if EOF, < 0 on error
7439 *
7440 * @since 0.6.4
7441 */
7442int iso_stream_read(IsoStream *stream, void *buf, size_t count);
7443
7444/**
7445 * Whether the given IsoStream can be read several times, with the same
7446 * results.
7447 * For example, a regular file is repeatable, you can read it as many
7448 * times as you want. However, a pipe isn't.
7449 *
7450 * This function doesn't take into account if the file has been modified
7451 * between the two reads.
7452 *
7453 * @return
7454 * 1 if stream is repeatable, 0 if not, < 0 on error
7455 *
7456 * @since 0.6.4
7457 */
7459
7460/**
7461 * Updates the size of the IsoStream with the current size of the
7462 * underlying source.
7463 *
7464 * @return
7465 * 1 if ok, < 0 on error (has to be a valid libisofs error code),
7466 * 0 if the IsoStream does not support this function.
7467 * @since 0.6.8
7468 */
7470
7471/**
7472 * Get an unique identifier for a given IsoStream.
7473 *
7474 * @since 0.6.4
7475 */
7476void iso_stream_get_id(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id,
7477 ino_t *ino_id);
7478
7479/**
7480 * Try to get eventual source path string of a stream. Meaning and availability
7481 * of this string depends on the stream.class . Expect valid results with
7482 * types "fsrc" and "cout". Result formats are
7483 * fsrc: result of file_source_get_path()
7484 * cout: result of file_source_get_path() " " offset " " size
7485 * @param stream
7486 * The stream to be inquired.
7487 * @param flag
7488 * Bitfield for control purposes, unused yet, submit 0
7489 * @return
7490 * A copy of the path string. Apply free() when no longer needed.
7491 * NULL if no path string is available.
7492 *
7493 * @since 0.6.18
7494 */
7495char *iso_stream_get_source_path(IsoStream *stream, int flag);
7496
7497/**
7498 * Compare two streams whether they are based on the same input and will
7499 * produce the same output. If in any doubt, then this comparison will
7500 * indicate no match.
7501 *
7502 * @param s1
7503 * The first stream to compare.
7504 * @param s2
7505 * The second stream to compare.
7506 * @return
7507 * -1 if s1 is smaller s2 , 0 if s1 matches s2 , 1 if s1 is larger s2
7508 * @param flag
7509 * bit0= do not use s1->class->cmp_ino() even if available
7510 *
7511 * @since 0.6.20
7512 */
7514
7515
7516/**
7517 * Produce a copy of a stream. It must be possible to operate both stream
7518 * objects concurrently. The success of this function depends on the
7519 * existence of a IsoStream_Iface.clone_stream() method with the stream
7520 * and with its eventual subordinate streams.
7521 * See iso_tree_clone() for a list of surely clonable built-in streams.
7522 *
7523 * @param old_stream
7524 * The existing stream object to be copied
7525 * @param new_stream
7526 * Will return a pointer to the copy
7527 * @param flag
7528 * Bitfield for control purposes. Submit 0 for now.
7529 * @return
7530 * >0 means success
7531 * ISO_STREAM_NO_CLONE is issued if no .clone_stream() exists
7532 * other error return values < 0 may occur depending on kind of stream
7533 *
7534 * @since 1.0.2
7535 */
7536int iso_stream_clone(IsoStream *old_stream, IsoStream **new_stream, int flag);
7537
7538
7539/* --------------------------------- AAIP --------------------------------- */
7540
7541/**
7542 * Function to identify and manage AAIP strings as xinfo of IsoNode.
7543 *
7544 * An AAIP string contains the Attribute List with the xattr and ACL of a node
7545 * in the image tree. It is formatted according to libisofs specification
7546 * AAIP-2.0 and ready to be written into the System Use Area or Continuation
7547 * Area of a directory entry in an ISO image.
7548 *
7549 * Applications are not supposed to manipulate AAIP strings directly.
7550 * They should rather make use of the appropriate iso_node_get_* and
7551 * iso_node_set_* calls.
7552 *
7553 * AAIP represents ACLs as xattr with empty name and AAIP-specific binary
7554 * content. Local filesystems may represent ACLs as xattr with names like
7555 * "system.posix_acl_access". libisofs does not interpret those local
7556 * xattr representations of ACL directly but rather uses the ACL interface of
7557 * the local system. By default the local xattr representations of ACL will
7558 * not become part of the AAIP Attribute List via iso_local_get_attrs() and
7559 * not be attached to local files via iso_local_set_attrs().
7560 *
7561 * @since 0.6.14
7562 */
7563int aaip_xinfo_func(void *data, int flag);
7564
7565/**
7566 * The iso_node_xinfo_cloner function which gets associated to aaip_xinfo_func
7567 * by iso_init() or iso_init_with_flag() via iso_node_xinfo_make_clonable().
7568 * @since 1.0.2
7569 */
7570int aaip_xinfo_cloner(void *old_data, void **new_data, int flag);
7571
7572/**
7573 * Get the eventual ACLs which are associated with the node.
7574 * The result will be in "long" text form as of man acl and acl_to_text().
7575 * Call this function with flag bit15 to finally release the memory
7576 * occupied by an ACL inquiry.
7577 *
7578 * @param node
7579 * The node that is to be inquired.
7580 * @param access_text
7581 * Will return a pointer to the eventual "access" ACL text or NULL if it
7582 * is not available and flag bit 4 is set.
7583 * @param default_text
7584 * Will return a pointer to the eventual "default" ACL or NULL if it
7585 * is not available.
7586 * (GNU/Linux directories can have a "default" ACL which influences
7587 * the permissions of newly created files.)
7588 * @param flag
7589 * Bitfield for control purposes
7590 * bit4= if no "access" ACL is available: return *access_text == NULL
7591 * else: produce ACL from stat(2) permissions
7592 * bit15= free memory and return 1 (node may be NULL)
7593 * @return
7594 * 2 *access_text was produced from stat(2) permissions
7595 * 1 *access_text was produced from ACL of node
7596 * 0 if flag bit4 is set and no ACL is available
7597 * < 0 on error
7598 *
7599 * @since 0.6.14
7600 */
7602 char **access_text, char **default_text, int flag);
7603
7604
7605/**
7606 * Set the ACLs of the given node to the lists in parameters access_text and
7607 * default_text or delete them.
7608 *
7609 * The stat(2) permission bits get updated according to the new "access" ACL if
7610 * neither bit1 of parameter flag is set nor parameter access_text is NULL.
7611 * Note that S_IRWXG permission bits correspond to ACL mask permissions
7612 * if a "mask::" entry exists in the ACL. Only if there is no "mask::" then
7613 * the "group::" entry corresponds to to S_IRWXG.
7614 *
7615 * @param node
7616 * The node that is to be manipulated.
7617 * @param access_text
7618 * The text to be set into effect as "access" ACL. NULL will delete an
7619 * eventually existing "access" ACL of the node.
7620 * @param default_text
7621 * The text to be set into effect as "default" ACL. NULL will delete an
7622 * eventually existing "default" ACL of the node.
7623 * (GNU/Linux directories can have a "default" ACL which influences
7624 * the permissions of newly created files.)
7625 * @param flag
7626 * Bitfield for control purposes
7627 * bit0= Do not change the stat(2) permissions.
7628 * Caution: This can make the node's permission set inconsistent.
7629 * bit1= Ignore text parameters but rather update the "access" ACL
7630 * to the stat(2) permissions of node. If no "access" ACL exists,
7631 * then do nothing and return success.
7632 * bit2= Be verbose about failure causes.
7633 * @since 1.5.2
7634 * @return
7635 * > 0 success
7636 * < 0 failure
7637 *
7638 * @since 0.6.14
7639 */
7641 char *access_text, char *default_text, int flag);
7642
7643/**
7644 * Like iso_node_get_permissions but reflecting ACL entry "group::" in S_IRWXG
7645 * rather than ACL entry "mask::". This is necessary if the permissions of a
7646 * node with ACL shall be restored to a filesystem without restoring the ACL.
7647 * The same mapping happens internally when the ACL of a node is deleted.
7648 * If the node has no ACL then the result is iso_node_get_permissions(node).
7649 * @param node
7650 * The node that is to be inquired.
7651 * @return
7652 * Permission bits as of stat(2)
7653 *
7654 * @since 0.6.14
7655 */
7657
7658
7659/**
7660 * Get the list of xattr which is associated with the node.
7661 * The resulting data may finally be disposed by a call to this function
7662 * with flag bit15 set, or its components may be freed one-by-one.
7663 * The following values are either NULL or malloc() memory:
7664 * *names, *value_lengths, *values, (*names)[i], (*values)[i]
7665 * with 0 <= i < *num_attrs.
7666 * It is allowed to replace or reallocate those memory items in order to
7667 * to manipulate the attribute list before submitting it to other calls.
7668 *
7669 * If enabled by flag bit0, this list possibly includes the ACLs of the node.
7670 * They are eventually encoded in a pair with empty name. It is not advisable
7671 * to alter the value or name of that pair. One may decide to erase both ACLs
7672 * by deleting this pair or to copy both ACLs by copying the content of this
7673 * pair to an empty named pair of another node.
7674 * For all other ACL purposes use iso_node_get_acl_text().
7675 *
7676 * @param node
7677 * The node that is to be inquired.
7678 * @param num_attrs
7679 * Will return the number of name-value pairs
7680 * @param names
7681 * Will return an array of pointers to 0-terminated names
7682 * @param value_lengths
7683 * Will return an array with the lengths of values
7684 * @param values
7685 * Will return an array of pointers to strings of 8-bit bytes
7686 * @param flag
7687 * Bitfield for control purposes
7688 * bit0= obtain eventual ACLs as attribute with empty name
7689 * bit2= with bit0: do not obtain attributes other than ACLs
7690 * bit15= free memory (node may be NULL)
7691 * @return
7692 * 1 = ok (but *num_attrs may be 0)
7693 * < 0 = error
7694 *
7695 * @since 0.6.14
7696 */
7697int iso_node_get_attrs(IsoNode *node, size_t *num_attrs,
7698 char ***names, size_t **value_lengths, char ***values, int flag);
7699
7700
7701/**
7702 * Obtain the value of a particular xattr name. Eventually make a copy of
7703 * that value and add a trailing 0 byte for caller convenience.
7704 * @param node
7705 * The node that is to be inquired.
7706 * @param name
7707 * The xattr name that shall be looked up.
7708 * @param value_length
7709 * Will return the length of value
7710 * @param value
7711 * Will return a string of 8-bit bytes. free() it when no longer needed.
7712 * @param flag
7713 * Bitfield for control purposes, unused yet, submit 0
7714 * @return
7715 * 1= name found , 0= name not found , <0 indicates error
7716 *
7717 * @since 0.6.18
7718 */
7719int iso_node_lookup_attr(IsoNode *node, char *name,
7720 size_t *value_length, char **value, int flag);
7721
7722/**
7723 * Set the list of xattr which is associated with the node.
7724 * The data get copied so that you may dispose your input data afterwards.
7725 *
7726 * If enabled by flag bit0 then the submitted list of attributes will not only
7727 * overwrite xattr but also both eventual ACLs of the node. Eventual ACL in
7728 * the submitted list have to reside in an attribute with empty name.
7729 *
7730 * @param node
7731 * The node that is to be manipulated.
7732 * @param num_attrs
7733 * Number of attributes
7734 * @param names
7735 * Array of pointers to 0 terminated name strings
7736 * @param value_lengths
7737 * Array of byte lengths for each value
7738 * @param values
7739 * Array of pointers to the value bytes
7740 * @param flag
7741 * Bitfield for control purposes
7742 * bit0= Do not maintain eventual existing ACL of the node.
7743 * Set eventual new ACL from value of empty name.
7744 * bit1= Do not clear the existing attribute list but merge it with
7745 * the list given by this call.
7746 * The given values override the values of their eventually existing
7747 * names. If no xattr with a given name exists, then it will be
7748 * added as new xattr. So this bit can be used to set a single
7749 * xattr without inquiring any other xattr of the node.
7750 * bit2= Delete the attributes with the given names
7751 * bit3= Allow to affect non-user attributes.
7752 * I.e. those with a non-empty name which does not begin by "user."
7753 * (The empty name is always allowed and governed by bit0.) This
7754 * deletes all previously existing attributes if not bit1 is set.
7755 * bit4= Do not affect attributes from namespace "isofs".
7756 * To be combined with bit3 for copying attributes from local
7757 * filesystem to ISO image.
7758 * @since 1.2.4
7759 * @return
7760 * 1 = ok
7761 * < 0 = error
7762 *
7763 * @since 0.6.14
7764 */
7765int iso_node_set_attrs(IsoNode *node, size_t num_attrs, char **names,
7766 size_t *value_lengths, char **values, int flag);
7767
7768
7769/* ----- This is an interface to ACL and xattr of the local filesystem ----- */
7770
7771/**
7772 * libisofs has an internal system dependent adapter to ACL and xattr
7773 * operations. For the sake of completeness and simplicity it exposes this
7774 * functionality to its applications which might want to get and set ACLs
7775 * from local files.
7776 */
7777
7778/**
7779 * Inquire whether local filesystem operations with ACL or xattr are enabled
7780 * inside libisofs. They may be disabled because of compile time decisions.
7781 * E.g. because the operating system does not support these features or
7782 * because libisofs has not yet an adapter to use them.
7783 *
7784 * @param flag
7785 * Bitfield for control purposes
7786 * bit0= inquire availability of ACL
7787 * bit1= inquire availability of xattr
7788 * bit2 - bit7= Reserved for future types.
7789 * It is permissibile to set them to 1 already now.
7790 * bit8 and higher: reserved, submit 0
7791 * @return
7792 * Bitfield corresponding to flag.
7793 * bit0= ACL adapter is enabled
7794 * bit1= xattr adapter is enabled
7795 * bit2 - bit7= Reserved for future types.
7796 * bit8 and higher: reserved, do not interpret these
7797 *
7798 * @since 1.1.6
7799 */
7801
7802/**
7803 * Get an ACL of the given file in the local filesystem in long text form.
7804 *
7805 * @param disk_path
7806 * Absolute path to the file
7807 * @param text
7808 * Will return a pointer to the ACL text. If not NULL the text will be
7809 * 0 terminated and finally has to be disposed by a call to this function
7810 * with bit15 set.
7811 * @param flag
7812 * Bitfield for control purposes
7813 * bit0= get "default" ACL rather than "access" ACL
7814 * bit4= set *text = NULL and return 2
7815 * if the ACL matches st_mode permissions.
7816 * bit5= in case of symbolic link: inquire link target
7817 * bit15= free text and return 1
7818 * @return
7819 * 1 ok
7820 * 2 ok, trivial ACL found while bit4 is set, *text is NULL
7821 * 0 no ACL manipulation adapter available / ACL not supported on fs
7822 * -1 failure of system ACL service (see errno)
7823 * -2 attempt to inquire ACL of a symbolic link without bit4 or bit5
7824 * or with no suitable link target
7825 *
7826 * @since 0.6.14
7827 */
7828int iso_local_get_acl_text(char *disk_path, char **text, int flag);
7829
7830
7831/**
7832 * Set the ACL of the given file in the local filesystem to a given list
7833 * in long text form.
7834 *
7835 * @param disk_path
7836 * Absolute path to the file
7837 * @param text
7838 * The input text (0 terminated, ACL long text form)
7839 * @param flag
7840 * Bitfield for control purposes
7841 * bit0= set "default" ACL rather than "access" ACL
7842 * bit5= in case of symbolic link: manipulate link target
7843 * @return
7844 * > 0 ok
7845 * 0 no ACL manipulation adapter available for desired ACL type
7846 * -1 failure of system ACL service (see errno)
7847 * -2 attempt to manipulate ACL of a symbolic link without bit5
7848 * or with no suitable link target
7849 *
7850 * @since 0.6.14
7851 */
7852int iso_local_set_acl_text(char *disk_path, char *text, int flag);
7853
7854
7855/**
7856 * Obtain permissions of a file in the local filesystem which shall reflect
7857 * ACL entry "group::" in S_IRWXG rather than ACL entry "mask::". This is
7858 * necessary if the permissions of a disk file with ACL shall be copied to
7859 * an object which has no ACL.
7860 * @param disk_path
7861 * Absolute path to the local file which may have an "access" ACL or not.
7862 * @param flag
7863 * Bitfield for control purposes
7864 * bit5= in case of symbolic link: inquire link target
7865 * @param st_mode
7866 * Returns permission bits as of stat(2)
7867 * @return
7868 * 1 success
7869 * -1 failure of lstat() or stat() (see errno)
7870 *
7871 * @since 0.6.14
7872 */
7873int iso_local_get_perms_wo_acl(char *disk_path, mode_t *st_mode, int flag);
7874
7875
7876/**
7877 * Get xattr and non-trivial ACLs of the given file in the local filesystem.
7878 * The resulting data has finally to be disposed by a call to this function
7879 * with flag bit15 set.
7880 *
7881 * Eventual ACLs will get encoded as attribute pair with empty name if this is
7882 * enabled by flag bit0. An ACL which simply replects stat(2) permissions
7883 * will not be put into the result.
7884 *
7885 * @param disk_path
7886 * Absolute path to the file
7887 * @param num_attrs
7888 * Will return the number of name-value pairs
7889 * @param names
7890 * Will return an array of pointers to 0-terminated names
7891 * @param value_lengths
7892 * Will return an array with the lengths of values
7893 * @param values
7894 * Will return an array of pointers to 8-bit values
7895 * @param flag
7896 * Bitfield for control purposes
7897 * bit0= obtain eventual ACLs as attribute with empty name
7898 * bit2= do not obtain attributes other than ACLs
7899 * bit3= do not ignore eventual non-user attributes.
7900 * I.e. those with a name which does not begin by "user."
7901 * bit5= in case of symbolic link: inquire link target
7902 * bit15= free memory
7903 * @return
7904 * 1 ok
7905 * 2 ok, but it is possible that attributes exist in non-user namespaces
7906 * which could not be explored due to lack of permission.
7907 * @since 1.5.0
7908 * < 0 failure
7909 *
7910 * @since 0.6.14
7911 */
7912int iso_local_get_attrs(char *disk_path, size_t *num_attrs, char ***names,
7913 size_t **value_lengths, char ***values, int flag);
7914
7915
7916/**
7917 * Attach a list of xattr and ACLs to the given file in the local filesystem.
7918 *
7919 * Eventual ACLs have to be encoded as attribute pair with empty name.
7920 *
7921 * @param disk_path
7922 * Absolute path to the file
7923 * @param num_attrs
7924 * Number of attributes
7925 * @param names
7926 * Array of pointers to 0 terminated name strings
7927 * @param value_lengths
7928 * Array of byte lengths for each attribute payload
7929 * @param values
7930 * Array of pointers to the attribute payload bytes
7931 * @param errnos
7932 * Array of integers to return error numbers if encountered at the attempt
7933 * to process the name-value pair at the given array index number:
7934 * 0 = no error , -1 = unknown error
7935 * >0 = errno as of local system calls to set xattr and ACLs
7936 * @param flag
7937 * Bitfield for control purposes
7938 * bit0= do not attach ACLs from an eventual attribute with empty name
7939 * bit3= do not ignore eventual non-user attributes.
7940 * I.e. those with a name which does not begin by "user."
7941 * bit5= in case of symbolic link: manipulate link target
7942 * bit6= @since 1.1.6
7943 * tolerate inappropriate presence or absence of
7944 * directory "default" ACL
7945 * bit7= @since 1.5.0
7946 * avoid setting a name value pair if it already exists and
7947 * has the desired value.
7948 * @return
7949 * 1 = ok
7950 * < 0 = error
7951 *
7952 * @since 1.5.0
7953 */
7954int iso_local_set_attrs_errno(char *disk_path, size_t num_attrs, char **names,
7955 size_t *value_lengths, char **values,
7956 int *errnos, int flag);
7957/**
7958 * Older version of iso_local_set_attrs_errno() without the errnos array.
7959 * All other parameters and the return value have the same meaning.
7960 *
7961 * @since 0.6.14
7962 */
7963int iso_local_set_attrs(char *disk_path, size_t num_attrs, char **names,
7964 size_t *value_lengths, char **values, int flag);
7965
7966
7967/* Default in case that the compile environment has no macro PATH_MAX.
7968*/
7969#define Libisofs_default_path_maX 4096
7970
7971
7972/* --------------------------- Filters in General -------------------------- */
7973
7974/*
7975 * A filter is an IsoStream which uses another IsoStream as input. It gets
7976 * attached to an IsoFile by specialized calls iso_file_add_*_filter() which
7977 * replace its current IsoStream by the filter stream which takes over the
7978 * current IsoStream as input.
7979 * The consequences are:
7980 * iso_file_get_stream() will return the filter stream.
7981 * iso_stream_get_size() will return the (cached) size of the filtered data,
7982 * iso_stream_open() will start eventual child processes,
7983 * iso_stream_close() will kill eventual child processes,
7984 * iso_stream_read() will return filtered data. E.g. as data file content
7985 * during ISO image generation.
7986 *
7987 * There are external filters which run child processes
7988 * iso_file_add_external_filter()
7989 * and internal filters
7990 * iso_file_add_zisofs_filter()
7991 * iso_file_add_gzip_filter()
7992 * which may or may not be available depending on compile time settings and
7993 * installed software packages like libz.
7994 *
7995 * During image generation filters get not in effect if the original IsoStream
7996 * is an "fsrc" stream based on a file in the loaded ISO image and if the
7997 * image generation type is set to 1 by iso_write_opts_set_appendable().
7998 */
7999
8000/**
8001 * Delete the top filter stream from a data file. This is the most recent one
8002 * which was added by iso_file_add_*_filter().
8003 * Caution: One should not do this while the IsoStream of the file is opened.
8004 * For now there is no general way to determine this state.
8005 * Filter stream implementations are urged to eventually call .close()
8006 * inside method .free() . This will close the input stream too.
8007 * @param file
8008 * The data file node which shall get rid of one layer of content
8009 * filtering.
8010 * @param flag
8011 * Bitfield for control purposes, unused yet, submit 0.
8012 * @return
8013 * 1 on success, 0 if no filter was present
8014 * <0 on error
8015 *
8016 * @since 0.6.18
8017 */
8018int iso_file_remove_filter(IsoFile *file, int flag);
8019
8020/**
8021 * Obtain the eventual input stream of a filter stream.
8022 * @param stream
8023 * The eventual filter stream to be inquired.
8024 * @param flag
8025 * Bitfield for control purposes.
8026 * bit0= Follow the chain of input streams and return the one at the
8027 * end of the chain.
8028 * @since 1.3.2
8029 * @return
8030 * The input stream, if one exists. Elsewise NULL.
8031 * No extra reference to the stream is taken by this call.
8032 *
8033 * @since 0.6.18
8034 */
8036
8037
8038/* ---------------------------- External Filters --------------------------- */
8039
8040/**
8041 * Representation of an external program that shall serve as filter for
8042 * an IsoStream. This object may be shared among many IsoStream objects.
8043 * It is to be created and disposed by the application.
8044 *
8045 * The filter will act as proxy between the original IsoStream of an IsoFile.
8046 * Up to completed image generation it will be run at least twice:
8047 * for IsoStream.class.get_size() and for .open() with subsequent .read().
8048 * So the original IsoStream has to return 1 by its .class.is_repeatable().
8049 * The filter program has to be repeateable too. I.e. it must produce the same
8050 * output on the same input.
8051 *
8052 * @since 0.6.18
8053 */
8055{
8056 /* Will indicate future extensions. It has to be 0 for now. */
8058
8059 /* Tells how many IsoStream objects depend on this command object.
8060 * One may only dispose an IsoExternalFilterCommand when this count is 0.
8061 * Initially this value has to be 0.
8062 */
8064
8065 /* An optional instance id.
8066 * Set to empty text if no individual name for this object is intended.
8067 */
8068 char *name;
8069
8070 /* Absolute local filesystem path to the executable program. */
8071 char *path;
8072
8073 /* Tells the number of arguments. */
8074 int argc;
8075
8076 /* NULL terminated list suitable for system call execv(3).
8077 * I.e. argv[0] points to the alleged program name,
8078 * argv[1] to argv[argc] point to program arguments (if argc > 0)
8079 * argv[argc+1] is NULL
8080 */
8081 char **argv;
8082
8083 /* A bit field which controls behavior variations:
8084 * bit0= Do not install filter if the input has size 0.
8085 * bit1= Do not install filter if the output is not smaller than the input.
8086 * bit2= Do not install filter if the number of output blocks is
8087 * not smaller than the number of input blocks. Block size is 2048.
8088 * Assume that non-empty input yields non-empty output and thus do
8089 * not attempt to attach a filter to files smaller than 2049 bytes.
8090 * bit3= suffix removed rather than added.
8091 * (Removal and adding suffixes is the task of the application.
8092 * This behavior bit serves only as reminder for the application.)
8093 */
8095
8096 /* The eventual suffix which is supposed to be added to the IsoFile name
8097 * or to be removed from the name.
8098 * (This is to be done by the application, not by calls
8099 * iso_file_add_external_filter() or iso_file_remove_filter().
8100 * The value recorded here serves only as reminder for the application.)
8101 */
8102 char *suffix;
8103};
8104
8106
8107/**
8108 * Install an external filter command on top of the content stream of a data
8109 * file. The filter process must be repeatable. It will be run once by this
8110 * call in order to cache the output size.
8111 * @param file
8112 * The data file node which shall show filtered content.
8113 * @param cmd
8114 * The external program and its arguments which shall do the filtering.
8115 * @param flag
8116 * Bitfield for control purposes, unused yet, submit 0.
8117 * @return
8118 * 1 on success, 2 if filter installation revoked (e.g. cmd.behavior bit1)
8119 * <0 on error
8120 *
8121 * @since 0.6.18
8122 */
8124 int flag);
8125
8126/**
8127 * Obtain the IsoExternalFilterCommand which is eventually associated with the
8128 * given stream. (Typically obtained from an IsoFile by iso_file_get_stream()
8129 * or from an IsoStream by iso_stream_get_input_stream()).
8130 * @param stream
8131 * The stream to be inquired.
8132 * @param cmd
8133 * Will return the external IsoExternalFilterCommand. Valid only if
8134 * the call returns 1. This does not increment cmd->refcount.
8135 * @param flag
8136 * Bitfield for control purposes, unused yet, submit 0.
8137 * @return
8138 * 1 on success, 0 if the stream is not an external filter
8139 * <0 on error
8140 *
8141 * @since 0.6.18
8142 */
8144 IsoExternalFilterCommand **cmd, int flag);
8145
8146
8147/* ---------------------------- Internal Filters --------------------------- */
8148
8149
8150/**
8151 * Install a zisofs filter on top of the content stream of a data file.
8152 * zisofs is a compression format which is decompressed by some Linux kernels.
8153 * See also doc/zisofs_format.txt and doc/zisofs2_format.txt.
8154 * The filter will not be installed if its output size is not smaller than
8155 * the size of the input stream.
8156 * This is only enabled if the use of libz was enabled at compile time.
8157 * @param file
8158 * The data file node which shall show filtered content.
8159 * @param flag
8160 * Bitfield for control purposes
8161 * bit0= Do not install filter if the number of output blocks is
8162 * not smaller than the number of input blocks. Block size is 2048.
8163 * bit1= Install a decompression filter rather than one for compression.
8164 * bit2= Only inquire availability of zisofs filtering. file may be NULL.
8165 * If available return 2, else return error.
8166 * bit3= is reserved for internal use and will be forced to 0
8167 * @return
8168 * 1 on success, 2 if filter available but installation revoked
8169 * <0 on error, e.g. ISO_ZLIB_NOT_ENABLED
8170 *
8171 * @since 0.6.18
8172 */
8174
8175
8176/**
8177 * Obtain the parameters of a zisofs filter stream.
8178 * @param stream
8179 * The stream to be inquired.
8180 * @param stream_type
8181 * 1=compressing ("ziso")
8182 * -1=uncompressing ("osiz")
8183 * 0 other (any obtained parameters have invalid content)
8184 * @param zisofs_algo
8185 * Algorithm as of ZF field:
8186 * {'p', 'z'} = zisofs version 1 (Zlib)
8187 * {'P', 'Z'} = zisofs version 2 (Zlib)
8188 * @param algo_num
8189 * Algorithm as of zisofs header:
8190 * 0 = zisofs version 1 (Zlib)
8191 * 1 = zisofs version 2 (Zlib)
8192 * @param block_size_log2
8193 * Log2 of the compression block size
8194 * 15 = 32 kiB , 16 = 64 kiB , 17 = 128 kiB, ...
8195 * @param flag
8196 * Bitfield for control purposes, unused yet, submit 0
8197 * @return
8198 * 1 on success, 0 if the stream has not class->type "ziso" or "osiz"
8199 * <0 on error
8200 * @since 1.5.4
8201 */
8202int iso_stream_get_zisofs_par(IsoStream *stream, int *stream_type,
8203 uint8_t zisofs_algo[2], uint8_t* algo_num,
8204 int *block_size_log2, int flag);
8205
8206
8207/**
8208 * Discard the buffered zisofs compression block pointers of a stream, if the
8209 * stream is a zisofs compression stream and not currently opened.
8210 * @param stream
8211 * The stream to be manipulated.
8212 * @param flag
8213 * Bitfield for control purposes, unused yet, submit 0
8214 * @return
8215 * 1 on success, 0 if no block pointers were reoved, <0 on error
8216 * @since 1.5.4
8217 */
8219
8220/**
8221 * Discard all buffered zisofs compression block pointers of streams in the
8222 * given image, which are zisofs compression streams and not currently opened.
8223 * @param image
8224 * The image to be manipulated.
8225 * @param flag
8226 * Bitfield for control purposes, unused yet, submit 0
8227 * @return
8228 * ISO_SUCCESS on success, <0 on error
8229 * @since 1.5.4
8230 */
8232
8233
8234/**
8235 * Inquire the number of zisofs compression and uncompression filters which
8236 * are in use.
8237 * @param ziso_count
8238 * Will return the number of currently installed compression filters.
8239 * @param osiz_count
8240 * Will return the number of currently installed uncompression filters.
8241 * @param flag
8242 * Bitfield for control purposes, unused yet, submit 0
8243 * @return
8244 * 1 on success, <0 on error
8245 *
8246 * @since 0.6.18
8247 */
8248int iso_zisofs_get_refcounts(off_t *ziso_count, off_t *osiz_count, int flag);
8249
8250
8251/**
8252 * Parameter set for iso_zisofs_set_params().
8253 *
8254 * @since 0.6.18
8255 */
8257
8258 /* Set to 0 or 1 for this version of the structure
8259 * 0 = only members up to .block_size_log2 are valid
8260 * 1 = members up to .bpt_discard_free_ratio are valid
8261 * @since 1.5.4
8262 */
8264
8265 /* Compression level for zlib function compress2(). From <zlib.h>:
8266 * "between 0 and 9:
8267 * 1 gives best speed, 9 gives best compression, 0 gives no compression"
8268 * Default is 6.
8269 */
8271
8272 /* Log2 of the block size for compression filters of zisofs version 1.
8273 * Allowed values are:
8274 * 15 = 32 kiB , 16 = 64 kiB , 17 = 128 kiB
8275 */
8277
8278 /* ------------------- Only valid with .version >= 1 ------------------- */
8279
8280 /*
8281 * Whether to produce zisofs2 (zisofs version 2) file headers and ZF
8282 * entries for files which get compressed:
8283 * 0 = do not produce zisofs2,
8284 * do not recognize zisofs2 file headers by magic
8285 * This is the default.
8286 * 1 = zisofs2 is enabled for file size 4 GiB or more
8287 * 2 = zisofs2 shall be used if zisofs is used at all
8288 * @since 1.5.4
8289 */
8291
8292 /*
8293 * Log2 of block size for zisofs2 files. 0 keeps current setting.
8294 * Allowed are 15 = 32 kiB to 20 = 1024 kiB.
8295 * @since 1.5.4
8296 */
8298
8299 /*
8300 * Maximum overall number of blocklist pointers. 0 keeps current setting.
8301 * @since 1.5.4
8302 */
8304
8305 /*
8306 * Ignored as input value: Number of allocated zisofs block pointers.
8307 * @since 1.5.4
8308 */
8310
8311 /*
8312 * Maximum number of blocklist pointers per file. 0 keeps current setting.
8313 * @since 1.5.4
8314 */
8316
8317 /*
8318 * Number of block pointers of a file, which is considered low enough to
8319 * justify a reduction of block size. If this number is > 0, then the
8320 * lowest permissible block size is used, with which not more than the
8321 * given number of block pointers gets produced. Upper limit is the
8322 * setting of block size log2.
8323 * The inavoidable end block pointer counts. E.g. a file of 55 KiB has
8324 * 3 blocks pointers with block size log2 15, and 2 blocks pointers with
8325 * block size log2 16.
8326 * -1 disables this automatic block size adjustment.
8327 * 0 keeps the current setting.
8328 * @since 1.5.4
8329 */
8331
8332 /*
8333 * The number of blocks from which on the block pointer list shall be
8334 * discarded on iso_stream_close() of a compressing stream. This means that
8335 * the pointers have to be determined again on next ziso_stream_compress(),
8336 * so that adding a zisofs compression filter and writing the compressed
8337 * stream needs in the sum three read runs of the input stream.
8338 * 0 keeps the current setting.
8339 * < 0 disables this file size based discarding.
8340 * @since 1.5.4
8341 */
8343
8344 /*
8345 * A ratio describing the part of max_file_blocks which shall be kept free
8346 * by intermediate discarding of block pointers.
8347 * See above bpt_discard_file_blocks .
8348 * It makes sense to set this to 1.0 if max_file_blocks is substantially
8349 * smaller than max_total_blocks.
8350 * 0.0 keeps the current setting.
8351 * < 0.0 disables this memory consumption based discarding.
8352 * @since 1.5.4
8353 */
8355
8356};
8357
8358/**
8359 * Set the global parameters for zisofs filtering.
8360 * This is only allowed while no zisofs compression filters are installed.
8361 * i.e. ziso_count returned by iso_zisofs_get_refcounts() has to be 0.
8362 * @param params
8363 * Pointer to a structure with the intended settings.
8364 * The caller sets params->version to indicate which set of members
8365 * has been filled. I.e. params->version == 0 causes all members after
8366 * params->block_size_log2 to be ignored.
8367 * @param flag
8368 * Bitfield for control purposes, unused yet, submit 0
8369 * @return
8370 * 1 on success, <0 on error
8371 *
8372 * @since 0.6.18
8373 */
8374int iso_zisofs_set_params(struct iso_zisofs_ctrl *params, int flag);
8375
8376/**
8377 * Get the current global parameters for zisofs filtering.
8378 * @param params
8379 * Pointer to a caller provided structure which shall take the settings.
8380 * The caller sets params->version to indicate which set of members
8381 * shall be filled. I.e. params->version == 0 leaves all members after
8382 * params->block_size_log2 untouched.
8383 * @param flag
8384 * Bitfield for control purposes, unused yet, submit 0
8385 * @return
8386 * 1 on success, <0 on error
8387 *
8388 * @since 0.6.18
8389 */
8390int iso_zisofs_get_params(struct iso_zisofs_ctrl *params, int flag);
8391
8392
8393/**
8394 * Enable or disable the production of "Z2" SUSP entries instead of "ZF"
8395 * entries for zisofs2 compressed files.
8396 * "ZF" with zisofs2 causes unaware Linux kernels to complain like:
8397 * isofs: Unknown ZF compression algorithm: PZ
8398 * "Z2" is silently ignored by unaware Linux kernels.
8399 * @param enable
8400 * 1 = produce "Z2" , 0 = only "ZF" , -1 = do not change
8401 * @return
8402 * 1 = enabled , 0 = not enabled
8403 * @since 1.5.4
8404 */
8406
8407
8408/**
8409 * Check for the given node or for its subtree whether the data file content
8410 * effectively bears zisofs file headers and eventually mark the outcome
8411 * by an xinfo data record if not already marked by a zisofs compressor filter.
8412 * This does not install any filter but only a hint for image generation
8413 * that the already compressed files shall get written with zisofs ZF entries.
8414 * Use this if you insert the compressed results of program mkzftree from disk
8415 * into the image.
8416 * @param node
8417 * The node which shall be checked and, if appropriate, be marked.
8418 * @param flag
8419 * Bitfield for control purposes
8420 * bit0= prepare for a run with iso_write_opts_set_appendable(,1).
8421 * Take into account that files from the imported image
8422 * do not get their content filtered.
8423 * bit1= permission to overwrite existing zisofs_zf_info
8424 * bit2= if no zisofs header is found:
8425 * create xinfo with parameters which indicate no zisofs
8426 * bit3= no tree recursion if node is a directory
8427 * bit4= skip files which stem from the imported image
8428 * bit8-bit15= maximum zisofs version to be recognized (0 means 1)
8429 * @return
8430 * 0= no zisofs data found
8431 * 1= zf xinfo added
8432 * 2= found existing zf xinfo and flag bit1 was not set
8433 * 3= both encountered: 1 and 2
8434 * <0 means error
8435 *
8436 * @since 0.6.18
8437 */
8438int iso_node_zf_by_magic(IsoNode *node, int flag);
8439
8440
8441/**
8442 * Install a gzip or gunzip filter on top of the content stream of a data file.
8443 * gzip is a compression format which is used by programs gzip and gunzip.
8444 * The filter will not be installed if its output size is not smaller than
8445 * the size of the input stream.
8446 * This is only enabled if the use of libz was enabled at compile time.
8447 * @param file
8448 * The data file node which shall show filtered content.
8449 * @param flag
8450 * Bitfield for control purposes
8451 * bit0= Do not install filter if the number of output blocks is
8452 * not smaller than the number of input blocks. Block size is 2048.
8453 * bit1= Install a decompression filter rather than one for compression.
8454 * bit2= Only inquire availability of gzip filtering. file may be NULL.
8455 * If available return 2, else return error.
8456 * bit3= is reserved for internal use and will be forced to 0
8457 * @return
8458 * 1 on success, 2 if filter available but installation revoked
8459 * <0 on error, e.g. ISO_ZLIB_NOT_ENABLED
8460 *
8461 * @since 0.6.18
8462 */
8464
8465
8466/**
8467 * Inquire the number of gzip compression and uncompression filters which
8468 * are in use.
8469 * @param gzip_count
8470 * Will return the number of currently installed compression filters.
8471 * @param gunzip_count
8472 * Will return the number of currently installed uncompression filters.
8473 * @param flag
8474 * Bitfield for control purposes, unused yet, submit 0
8475 * @return
8476 * 1 on success, <0 on error
8477 *
8478 * @since 0.6.18
8479 */
8480int iso_gzip_get_refcounts(off_t *gzip_count, off_t *gunzip_count, int flag);
8481
8482
8483/* ---------------------------- MD5 Checksums --------------------------- */
8484
8485/* Production and loading of MD5 checksums is controlled by calls
8486 iso_write_opts_set_record_md5() and iso_read_opts_set_no_md5().
8487 For data representation details see doc/checksums.txt .
8488*/
8489
8490/**
8491 * Obtain the recorded MD5 checksum of the session which was
8492 * loaded as ISO image. Such a checksum may be stored together with others
8493 * in a contiguous array at the end of the session. The session checksum
8494 * covers the data blocks from address start_lba to address end_lba - 1.
8495 * It does not cover the recorded array of md5 checksums.
8496 * Layout, size, and position of the checksum array is recorded in the xattr
8497 * "isofs.ca" of the session root node.
8498 * @param image
8499 * The image to inquire
8500 * @param start_lba
8501 * Returns the first block address covered by md5
8502 * @param end_lba
8503 * Returns the first block address not covered by md5 any more
8504 * @param md5
8505 * Returns 16 byte of MD5 checksum
8506 * @param flag
8507 * Bitfield for control purposes, unused yet, submit 0
8508 * @return
8509 * 1= md5 found
8510 * 0= no md5 available (i.e. start_lba, end_lba, md5 are invalid)
8511 * <0 indicates error
8512 *
8513 * @since 0.6.22
8514 */
8515int iso_image_get_session_md5(IsoImage *image, uint32_t *start_lba,
8516 uint32_t *end_lba, char md5[16], int flag);
8517
8518/**
8519 * Eventually obtain the recorded MD5 checksum of a data file from the loaded
8520 * ISO image. Such a checksum may be stored with others in a contiguous
8521 * array at the end of the loaded session. The data file eventually has an
8522 * xattr "isofs.cx" which gives the index in that array.
8523 * @param image
8524 * The image from which file stems.
8525 * @param file
8526 * The file object to inquire
8527 * @param md5
8528 * Eventually returns 16 byte of MD5 checksum
8529 * @param flag
8530 * Bitfield for control purposes
8531 * bit0= only determine return value, do not touch parameter md5
8532 * @return
8533 * 1= md5 found , 0= no md5 available , <0 indicates error
8534 *
8535 * @since 0.6.22
8536 */
8537int iso_file_get_md5(IsoImage *image, IsoFile *file, char md5[16], int flag);
8538
8539/**
8540 * Read the content of an IsoFile object, compute its MD5 and attach it to
8541 * the IsoFile. It can then be inquired by iso_file_get_md5() and will get
8542 * written into the next session if this is enabled at write time and if the
8543 * image write process does not compute an MD5 from content which it copies.
8544 * So this call can be used to equip nodes from the old image with checksums
8545 * or to make available checksums of newly added files before the session gets
8546 * written.
8547 * @param file
8548 * The file object to read data from and to which to attach the checksum.
8549 * If the file is from the imported image, then its most original stream
8550 * will be checksummed. Else the eventual filter streams will get into
8551 * effect.
8552 * @param flag
8553 * Bitfield for control purposes. Unused yet. Submit 0.
8554 * @return
8555 * 1= ok, MD5 is computed and attached , <0 indicates error
8556 *
8557 * @since 0.6.22
8558 */
8559int iso_file_make_md5(IsoFile *file, int flag);
8560
8561/**
8562 * Check a data block whether it is a libisofs session checksum tag and
8563 * eventually obtain its recorded parameters. These tags get written after
8564 * volume descriptors, directory tree and checksum array and can be detected
8565 * without loading the image tree.
8566 * One may start reading and computing MD5 at the suspected image session
8567 * start and look out for a session tag on the fly. See doc/checksum.txt .
8568 * @param data
8569 * A complete and aligned data block read from an ISO image session.
8570 * @param tag_type
8571 * 0= no tag
8572 * 1= session tag
8573 * 2= superblock tag
8574 * 3= tree tag
8575 * 4= relocated 64 kB superblock tag (at LBA 0 of overwritable media)
8576 * @param pos
8577 * Returns the LBA where the tag supposes itself to be stored.
8578 * If this does not match the data block LBA then the tag might be
8579 * image data payload and should be ignored for image checksumming.
8580 * @param range_start
8581 * Returns the block address where the session is supposed to start.
8582 * If this does not match the session start on media then the image
8583 * volume descriptors have been been relocated.
8584 * A proper checksum will only emerge if computing started at range_start.
8585 * @param range_size
8586 * Returns the number of blocks beginning at range_start which are
8587 * covered by parameter md5.
8588 * @param next_tag
8589 * Returns the predicted block address of the next tag.
8590 * next_tag is valid only if not 0 and only with return values 2, 3, 4.
8591 * With tag types 2 and 3, reading shall go on sequentially and the MD5
8592 * computation shall continue up to that address.
8593 * With tag type 4, reading shall resume either at LBA 32 for the first
8594 * session or at the given address for the session which is to be loaded
8595 * by default. In both cases the MD5 computation shall be re-started from
8596 * scratch.
8597 * @param md5
8598 * Returns 16 byte of MD5 checksum.
8599 * @param flag
8600 * Bitfield for control purposes:
8601 * bit0-bit7= tag type being looked for
8602 * 0= any checksum tag
8603 * 1= session tag
8604 * 2= superblock tag
8605 * 3= tree tag
8606 * 4= relocated superblock tag
8607 * @return
8608 * 0= not a checksum tag, return parameters are invalid
8609 * 1= checksum tag found, return parameters are valid
8610 * <0= error
8611 * (return parameters are valid with error ISO_MD5_AREA_CORRUPTED
8612 * but not trustworthy because the tag seems corrupted)
8613 *
8614 * @since 0.6.22
8615 */
8616int iso_util_decode_md5_tag(char data[2048], int *tag_type, uint32_t *pos,
8617 uint32_t *range_start, uint32_t *range_size,
8618 uint32_t *next_tag, char md5[16], int flag);
8619
8620
8621/* The following functions allow to do own MD5 computations. E.g for
8622 comparing the result with a recorded checksum.
8623*/
8624/**
8625 * Create a MD5 computation context and hand out an opaque handle.
8626 *
8627 * @param md5_context
8628 * Returns the opaque handle. Submitted *md5_context must be NULL or
8629 * point to freeable memory.
8630 * @return
8631 * 1= success , <0 indicates error
8632 *
8633 * @since 0.6.22
8634 */
8635int iso_md5_start(void **md5_context);
8636
8637/**
8638 * Advance the computation of a MD5 checksum by a chunk of data bytes.
8639 *
8640 * @param md5_context
8641 * An opaque handle once returned by iso_md5_start() or iso_md5_clone().
8642 * @param data
8643 * The bytes which shall be processed into to the checksum.
8644 * @param datalen
8645 * The number of bytes to be processed.
8646 * @return
8647 * 1= success , <0 indicates error
8648 *
8649 * @since 0.6.22
8650 */
8651int iso_md5_compute(void *md5_context, char *data, int datalen);
8652
8653/**
8654 * Create a MD5 computation context as clone of an existing one. One may call
8655 * iso_md5_clone(old, &new, 0) and then iso_md5_end(&new, result, 0) in order
8656 * to obtain an intermediate MD5 sum before the computation goes on.
8657 *
8658 * @param old_md5_context
8659 * An opaque handle once returned by iso_md5_start() or iso_md5_clone().
8660 * @param new_md5_context
8661 * Returns the opaque handle to the new MD5 context. Submitted
8662 * *md5_context must be NULL or point to freeable memory.
8663 * @return
8664 * 1= success , <0 indicates error
8665 *
8666 * @since 0.6.22
8667 */
8668int iso_md5_clone(void *old_md5_context, void **new_md5_context);
8669
8670/**
8671 * Obtain the MD5 checksum from a MD5 computation context and dispose this
8672 * context. (If you want to keep the context then call iso_md5_clone() and
8673 * apply iso_md5_end() to the clone.)
8674 *
8675 * @param md5_context
8676 * A pointer to an opaque handle once returned by iso_md5_start() or
8677 * iso_md5_clone(). *md5_context will be set to NULL in this call.
8678 * @param result
8679 * Gets filled with the 16 bytes of MD5 checksum.
8680 * @return
8681 * 1= success , <0 indicates error
8682 *
8683 * @since 0.6.22
8684 */
8685int iso_md5_end(void **md5_context, char result[16]);
8686
8687/**
8688 * Inquire whether two MD5 checksums match. (This is trivial but such a call
8689 * is convenient and completes the interface.)
8690 * @param first_md5
8691 * A MD5 byte string as returned by iso_md5_end()
8692 * @param second_md5
8693 * A MD5 byte string as returned by iso_md5_end()
8694 * @return
8695 * 1= match , 0= mismatch
8696 *
8697 * @since 0.6.22
8698 */
8699int iso_md5_match(char first_md5[16], char second_md5[16]);
8700
8701
8702/* -------------------------------- For HFS+ ------------------------------- */
8703
8704
8705/**
8706 * HFS+ attributes which may be attached to IsoNode objects as data parameter
8707 * of iso_node_add_xinfo(). As parameter proc use iso_hfsplus_xinfo_func().
8708 * Create instances of this struct by iso_hfsplus_xinfo_new().
8709 *
8710 * @since 1.2.4
8711 */
8713
8714 /* Currently set to 0 by iso_hfsplus_xinfo_new() */
8716
8717 /* Attributes available with version 0.
8718 * See: http://en.wikipedia.org/wiki/Creator_code , .../Type_code
8719 * @since 1.2.4
8720 */
8721 uint8_t creator_code[4];
8722 uint8_t type_code[4];
8723};
8724
8725/**
8726 * The function that is used to mark struct iso_hfsplus_xinfo_data at IsoNodes
8727 * and finally disposes such structs when their IsoNodes get disposed.
8728 * Usually an application does not call this function, but only uses it as
8729 * parameter of xinfo calls like iso_node_add_xinfo() or iso_node_get_xinfo().
8730 *
8731 * @since 1.2.4
8732 */
8733int iso_hfsplus_xinfo_func(void *data, int flag);
8734
8735/**
8736 * Create an instance of struct iso_hfsplus_xinfo_new().
8737 *
8738 * @param flag
8739 * Bitfield for control purposes. Unused yet. Submit 0.
8740 * @return
8741 * A pointer to the new object
8742 * NULL indicates failure to allocate memory
8743 *
8744 * @since 1.2.4
8745 */
8747
8748
8749/**
8750 * HFS+ blessings are relationships between HFS+ enhanced ISO images and
8751 * particular files in such images. Except for ISO_HFSPLUS_BLESS_INTEL_BOOTFILE
8752 * and ISO_HFSPLUS_BLESS_MAX, these files have to be directories.
8753 * No file may have more than one blessing. Each blessing can only be issued
8754 * to one file.
8755 *
8756 * @since 1.2.4
8757 */
8759 /* The blessing that is issued by mkisofs option -hfs-bless. */
8761
8762 /* To be applied to a data file */
8764
8765 /* Further blessings for directories */
8769
8770 /* Not a blessing, but telling the number of blessings in this list */
8773
8774/**
8775 * Issue a blessing to a particular IsoNode. If the blessing is already issued
8776 * to some file, then it gets revoked from that one.
8777 *
8778 * @param img
8779 * The image to manipulate.
8780 * @param blessing
8781 * The kind of blessing to be issued.
8782 * @param node
8783 * The file that shall be blessed. It must actually be an IsoDir or
8784 * IsoFile as is appropriate for the kind of blessing. (See above enum.)
8785 * The node may not yet bear a blessing other than the desired one.
8786 * If node is NULL, then the blessing will be revoked from any node
8787 * which bears it.
8788 * @param flag
8789 * Bitfield for control purposes.
8790 * bit0= Revoke blessing if node != NULL bears it.
8791 * bit1= Revoke any blessing of the node, regardless of parameter
8792 * blessing. If node is NULL, then revoke all blessings in
8793 * the image.
8794 * @return
8795 * 1 means successful blessing or revokation of an existing blessing.
8796 * 0 means the node already bears another blessing, or is of wrong type,
8797 * or that the node was not blessed and revokation was desired.
8798 * <0 is one of the listed error codes.
8799 *
8800 * @since 1.2.4
8801 */
8803 IsoNode *node, int flag);
8804
8805/**
8806 * Get the array of nodes which are currently blessed.
8807 * Array indice correspond to enum IsoHfsplusBlessings.
8808 * Array element value NULL means that no node bears that blessing.
8809 *
8810 * Several usage restrictions apply. See parameter blessed_nodes.
8811 *
8812 * @param img
8813 * The image to inquire.
8814 * @param blessed_nodes
8815 * Will return a pointer to an internal node array of image.
8816 * This pointer is valid only as long as image exists and only until
8817 * iso_image_hfsplus_bless() gets used to manipulate the blessings.
8818 * Do not free() this array. Do not alter the content of the array
8819 * directly, but rather use iso_image_hfsplus_bless() and re-inquire
8820 * by iso_image_hfsplus_get_blessed().
8821 * This call does not impose an extra reference on the nodes in the
8822 * array. So do not iso_node_unref() them.
8823 * Nodes listed here are not necessarily grafted into the tree of
8824 * the IsoImage.
8825 * @param bless_max
8826 * Will return the number of elements in the array.
8827 * It is unlikely but not outruled that it will be larger than
8828 * ISO_HFSPLUS_BLESS_MAX in this libisofs.h file.
8829 * @param flag
8830 * Bitfield for control purposes. Submit 0.
8831 * @return
8832 * 1 means success, <0 means error
8833 *
8834 * @since 1.2.4
8835 */
8837 int *bless_max, int flag);
8838
8839
8840/* ----------------------------- Character sets ---------------------------- */
8841
8842/**
8843 * Convert the characters in name from local charset to another charset or
8844 * convert name to the representation of a particular ISO image name space.
8845 * In the latter case it is assumed that the conversion result does not
8846 * collide with any other converted name in the same directory.
8847 * I.e. this function does not take into respect possible name changes
8848 * due to collision handling.
8849 *
8850 * @param opts
8851 * Defines output charset, UCS-2 versus UTF-16 for Joliet,
8852 * and naming restrictions.
8853 * @param name
8854 * The input text which shall be converted.
8855 * @param name_len
8856 * The number of bytes in input text.
8857 * @param result
8858 * Will return the conversion result in case of success. Terminated by
8859 * a trailing zero byte.
8860 * Use free() to dispose it when no longer needed.
8861 * @param result_len
8862 * Will return the number of bytes in result (excluding trailing zero)
8863 * @param flag
8864 * Bitfield for control purposes.
8865 * bit0-bit7= Name space
8866 * 0= generic (output charset is used,
8867 * no reserved characters, no length limits)
8868 * 1= Rock Ridge (output charset is used)
8869 * 2= Joliet (output charset gets overridden by UCS-2 or
8870 * UTF-16)
8871 * 3= ECMA-119 (output charset gets overridden by the
8872 * dull ISO 9660 subset of ASCII)
8873 * 4= HFS+ (output charset gets overridden by UTF-16BE)
8874 * bit8= Treat input text as directory name
8875 * (matters for Joliet and ECMA-119)
8876 * bit9= Do not issue error messages
8877 * bit15= Reverse operation (best to be done only with results of
8878 * previous conversions)
8879 * @return
8880 * 1 means success, <0 means error
8881 *
8882 * @since 1.3.6
8883 */
8884int iso_conv_name_chars(IsoWriteOpts *opts, char *name, size_t name_len,
8885 char **result, size_t *result_len, int flag);
8886
8887
8888
8889/************ Error codes and return values for libisofs ********************/
8890
8891/** successfully execution */
8892#define ISO_SUCCESS 1
8893
8894/**
8895 * special return value, it could be or not an error depending on the
8896 * context.
8897 */
8898#define ISO_NONE 0
8899
8900/** Operation canceled (FAILURE,HIGH, -1) */
8901#define ISO_CANCELED 0xE830FFFF
8902
8903/** Unknown or unexpected fatal error (FATAL,HIGH, -2) */
8904#define ISO_FATAL_ERROR 0xF030FFFE
8905
8906/** Unknown or unexpected error (FAILURE,HIGH, -3) */
8907#define ISO_ERROR 0xE830FFFD
8908
8909/** Internal programming error. Please report this bug (FATAL,HIGH, -4) */
8910#define ISO_ASSERT_FAILURE 0xF030FFFC
8911
8912/**
8913 * NULL pointer as value for an arg. that doesn't allow NULL (FAILURE,HIGH, -5)
8914 */
8915#define ISO_NULL_POINTER 0xE830FFFB
8916
8917/** Memory allocation error (FATAL,HIGH, -6) */
8918#define ISO_OUT_OF_MEM 0xF030FFFA
8919
8920/** Interrupted by a signal (FATAL,HIGH, -7) */
8921#define ISO_INTERRUPTED 0xF030FFF9
8922
8923/** Invalid parameter value (FAILURE,HIGH, -8) */
8924#define ISO_WRONG_ARG_VALUE 0xE830FFF8
8925
8926/** Can't create a needed thread (FATAL,HIGH, -9) */
8927#define ISO_THREAD_ERROR 0xF030FFF7
8928
8929/** Write error (FAILURE,HIGH, -10) */
8930#define ISO_WRITE_ERROR 0xE830FFF6
8931
8932/** Buffer read error (FAILURE,HIGH, -11) */
8933#define ISO_BUF_READ_ERROR 0xE830FFF5
8934
8935/** Trying to add to a dir a node already added to a dir (FAILURE,HIGH, -64) */
8936#define ISO_NODE_ALREADY_ADDED 0xE830FFC0
8937
8938/** Node with same name already exists (FAILURE,HIGH, -65) */
8939#define ISO_NODE_NAME_NOT_UNIQUE 0xE830FFBF
8940
8941/** Trying to remove a node that was not added to dir (FAILURE,HIGH, -65) */
8942#define ISO_NODE_NOT_ADDED_TO_DIR 0xE830FFBE
8943
8944/** A requested node does not exist (FAILURE,HIGH, -66) */
8945#define ISO_NODE_DOESNT_EXIST 0xE830FFBD
8946
8947/**
8948 * Try to set the boot image of an already bootable image (FAILURE,HIGH, -67)
8949 */
8950#define ISO_IMAGE_ALREADY_BOOTABLE 0xE830FFBC
8951
8952/** Trying to use an invalid file as boot image (FAILURE,HIGH, -68) */
8953#define ISO_BOOT_IMAGE_NOT_VALID 0xE830FFBB
8954
8955/** Too many boot images (FAILURE,HIGH, -69) */
8956#define ISO_BOOT_IMAGE_OVERFLOW 0xE830FFBA
8957
8958/** No boot catalog created yet ((FAILURE,HIGH, -70) */ /* @since 0.6.34 */
8959#define ISO_BOOT_NO_CATALOG 0xE830FFB9
8960
8961
8962/**
8963 * Error on file operation (FAILURE,HIGH, -128)
8964 * (take a look at more specified error codes below)
8965 */
8966#define ISO_FILE_ERROR 0xE830FF80
8967
8968/** Trying to open an already opened file (FAILURE,HIGH, -129) */
8969#define ISO_FILE_ALREADY_OPENED 0xE830FF7F
8970
8971/* @deprecated use ISO_FILE_ALREADY_OPENED instead */
8972#define ISO_FILE_ALREADY_OPENNED 0xE830FF7F
8973
8974/** Access to file is not allowed (FAILURE,HIGH, -130) */
8975#define ISO_FILE_ACCESS_DENIED 0xE830FF7E
8976
8977/** Incorrect path to file (FAILURE,HIGH, -131) */
8978#define ISO_FILE_BAD_PATH 0xE830FF7D
8979
8980/** The file does not exist in the filesystem (FAILURE,HIGH, -132) */
8981#define ISO_FILE_DOESNT_EXIST 0xE830FF7C
8982
8983/** Trying to read or close a file not opened (FAILURE,HIGH, -133) */
8984#define ISO_FILE_NOT_OPENED 0xE830FF7B
8985
8986/* @deprecated use ISO_FILE_NOT_OPENED instead */
8987#define ISO_FILE_NOT_OPENNED ISO_FILE_NOT_OPENED
8988
8989/** Directory used where no dir is expected (FAILURE,HIGH, -134) */
8990#define ISO_FILE_IS_DIR 0xE830FF7A
8991
8992/** Read error (FAILURE,HIGH, -135) */
8993#define ISO_FILE_READ_ERROR 0xE830FF79
8994
8995/** Not dir used where a dir is expected (FAILURE,HIGH, -136) */
8996#define ISO_FILE_IS_NOT_DIR 0xE830FF78
8997
8998/** Not symlink used where a symlink is expected (FAILURE,HIGH, -137) */
8999#define ISO_FILE_IS_NOT_SYMLINK 0xE830FF77
9000
9001/** Can't seek to specified location (FAILURE,HIGH, -138) */
9002#define ISO_FILE_SEEK_ERROR 0xE830FF76
9003
9004/** File not supported in ECMA-119 tree and thus ignored (WARNING,MEDIUM, -139) */
9005#define ISO_FILE_IGNORED 0xD020FF75
9006
9007/* A file is bigger than supported by used standard (FAILURE,HIGH, -140) */
9008#define ISO_FILE_TOO_BIG 0xE830FF74
9009
9010/* File read error during image creation (MISHAP,HIGH, -141) */
9011#define ISO_FILE_CANT_WRITE 0xE430FF73
9012
9013/* Can't convert filename to requested charset (WARNING,MEDIUM, -142) */
9014#define ISO_FILENAME_WRONG_CHARSET 0xD020FF72
9015/* This was once a HINT. Deprecated now. */
9016#define ISO_FILENAME_WRONG_CHARSET_OLD 0xC020FF72
9017
9018/* File can't be added to the tree (SORRY,HIGH, -143) */
9019#define ISO_FILE_CANT_ADD 0xE030FF71
9020
9021/**
9022 * File path break specification constraints and will be ignored
9023 * (WARNING,MEDIUM, -144)
9024 */
9025#define ISO_FILE_IMGPATH_WRONG 0xD020FF70
9026
9027/**
9028 * Offset greater than file size (FAILURE,HIGH, -150)
9029 * @since 0.6.4
9030 */
9031#define ISO_FILE_OFFSET_TOO_BIG 0xE830FF6A
9032
9033
9034/** Charset conversion error (FAILURE,HIGH, -256) */
9035#define ISO_CHARSET_CONV_ERROR 0xE830FF00
9036
9037/**
9038 * Too many files to mangle, i.e. we cannot guarantee unique file names
9039 * (FAILURE,HIGH, -257)
9040 */
9041#define ISO_MANGLE_TOO_MUCH_FILES 0xE830FEFF
9042
9043/* image related errors */
9044
9045/**
9046 * Wrong or damaged Primary Volume Descriptor (FAILURE,HIGH, -320)
9047 * This could mean that the file is not a valid ISO image.
9048 */
9049#define ISO_WRONG_PVD 0xE830FEC0
9050
9051/** Wrong or damaged RR entry (SORRY,HIGH, -321) */
9052#define ISO_WRONG_RR 0xE030FEBF
9053
9054/** Unsupported RR feature (SORRY,HIGH, -322) */
9055#define ISO_UNSUPPORTED_RR 0xE030FEBE
9056
9057/** Wrong or damaged ECMA-119 (FAILURE,HIGH, -323) */
9058#define ISO_WRONG_ECMA119 0xE830FEBD
9059
9060/** Unsupported ECMA-119 feature (FAILURE,HIGH, -324) */
9061#define ISO_UNSUPPORTED_ECMA119 0xE830FEBC
9062
9063/** Wrong or damaged El-Torito catalog (WARN,HIGH, -325) */
9064#define ISO_WRONG_EL_TORITO 0xD030FEBB
9065
9066/** Unsupported El-Torito feature (WARN,HIGH, -326) */
9067#define ISO_UNSUPPORTED_EL_TORITO 0xD030FEBA
9068
9069/** Can't patch an isolinux boot image (SORRY,HIGH, -327) */
9070#define ISO_ISOLINUX_CANT_PATCH 0xE030FEB9
9071
9072/** Unsupported SUSP feature (SORRY,HIGH, -328) */
9073#define ISO_UNSUPPORTED_SUSP 0xE030FEB8
9074
9075/** Error on a RR entry that can be ignored (WARNING,HIGH, -329) */
9076#define ISO_WRONG_RR_WARN 0xD030FEB7
9077
9078/** Error on a RR entry that can be ignored (HINT,MEDIUM, -330) */
9079#define ISO_SUSP_UNHANDLED 0xC020FEB6
9080
9081/** Multiple ER SUSP entries found (WARNING,HIGH, -331) */
9082#define ISO_SUSP_MULTIPLE_ER 0xD030FEB5
9083
9084/** Unsupported volume descriptor found (HINT,MEDIUM, -332) */
9085#define ISO_UNSUPPORTED_VD 0xC020FEB4
9086
9087/** El-Torito related warning (WARNING,HIGH, -333) */
9088#define ISO_EL_TORITO_WARN 0xD030FEB3
9089
9090/** Image write cancelled (MISHAP,HIGH, -334) */
9091#define ISO_IMAGE_WRITE_CANCELED 0xE430FEB2
9092
9093/** El-Torito image is hidden (WARNING,HIGH, -335) */
9094#define ISO_EL_TORITO_HIDDEN 0xD030FEB1
9095
9096
9097/** AAIP info with ACL or xattr in ISO image will be ignored
9098 (NOTE, HIGH, -336) */
9099#define ISO_AAIP_IGNORED 0xB030FEB0
9100
9101/** Error with decoding ACL from AAIP info (FAILURE, HIGH, -337) */
9102#define ISO_AAIP_BAD_ACL 0xE830FEAF
9103
9104/** Error with encoding ACL for AAIP (FAILURE, HIGH, -338) */
9105#define ISO_AAIP_BAD_ACL_TEXT 0xE830FEAE
9106
9107/** AAIP processing for ACL or xattr not enabled at compile time
9108 (FAILURE, HIGH, -339) */
9109#define ISO_AAIP_NOT_ENABLED 0xE830FEAD
9110
9111/** Error with decoding AAIP info for ACL or xattr (FAILURE, HIGH, -340) */
9112#define ISO_AAIP_BAD_AASTRING 0xE830FEAC
9113
9114/** Error with reading ACL or xattr from local file (FAILURE, HIGH, -341) */
9115#define ISO_AAIP_NO_GET_LOCAL 0xE830FEAB
9116/** Error with reading ACL or xattr from local file (SORRY, HIGH, -341) */
9117#define ISO_AAIP_NO_GET_LOCAL_S 0xE030FEAB
9118
9119/** Error with attaching ACL or xattr to local file (FAILURE, HIGH, -342) */
9120#define ISO_AAIP_NO_SET_LOCAL 0xE830FEAA
9121/** Error with attaching ACL or xattr to local file (SORRY, HIGH, -342) */
9122#define ISO_AAIP_NO_SET_LOCAL_S 0xE030FEAA
9123
9124/** Unallowed attempt to set an xattr with non-userspace name
9125 (FAILURE, HIGH, -343) */
9126#define ISO_AAIP_NON_USER_NAME 0xE830FEA9
9127
9128/** Too many references on a single IsoExternalFilterCommand
9129 (FAILURE, HIGH, -344) */
9130#define ISO_EXTF_TOO_OFTEN 0xE830FEA8
9131
9132/** Use of zlib was not enabled at compile time (FAILURE, HIGH, -345) */
9133#define ISO_ZLIB_NOT_ENABLED 0xE830FEA7
9134
9135/** File too large. Cannot apply zisofs filter. (FAILURE, HIGH, -346) */
9136#define ISO_ZISOFS_TOO_LARGE 0xE830FEA6
9137
9138/** Filter input differs from previous run (FAILURE, HIGH, -347) */
9139#define ISO_FILTER_WRONG_INPUT 0xE830FEA5
9140
9141/** zlib compression/decompression error (FAILURE, HIGH, -348) */
9142#define ISO_ZLIB_COMPR_ERR 0xE830FEA4
9143
9144/** Input stream is not in a supported zisofs format (FAILURE, HIGH, -349) */
9145#define ISO_ZISOFS_WRONG_INPUT 0xE830FEA3
9146
9147/** Cannot set global zisofs parameters while filters exist
9148 (FAILURE, HIGH, -350) */
9149#define ISO_ZISOFS_PARAM_LOCK 0xE830FEA2
9150
9151/** Premature EOF of zlib input stream (FAILURE, HIGH, -351) */
9152#define ISO_ZLIB_EARLY_EOF 0xE830FEA1
9153
9154/**
9155 * Checksum area or checksum tag appear corrupted (WARNING,HIGH, -352)
9156 * @since 0.6.22
9157*/
9158#define ISO_MD5_AREA_CORRUPTED 0xD030FEA0
9159
9160/**
9161 * Checksum mismatch between checksum tag and data blocks
9162 * (FAILURE, HIGH, -353)
9163 * @since 0.6.22
9164*/
9165#define ISO_MD5_TAG_MISMATCH 0xE830FE9F
9166
9167/**
9168 * Checksum mismatch in System Area, Volume Descriptors, or directory tree.
9169 * (FAILURE, HIGH, -354)
9170 * @since 0.6.22
9171*/
9172#define ISO_SB_TREE_CORRUPTED 0xE830FE9E
9173
9174/**
9175 * Unexpected checksum tag type encountered. (WARNING, HIGH, -355)
9176 * @since 0.6.22
9177*/
9178#define ISO_MD5_TAG_UNEXPECTED 0xD030FE9D
9179
9180/**
9181 * Misplaced checksum tag encountered. (WARNING, HIGH, -356)
9182 * @since 0.6.22
9183*/
9184#define ISO_MD5_TAG_MISPLACED 0xD030FE9C
9185
9186/**
9187 * Checksum tag with unexpected address range encountered.
9188 * (WARNING, HIGH, -357)
9189 * @since 0.6.22
9190*/
9191#define ISO_MD5_TAG_OTHER_RANGE 0xD030FE9B
9192
9193/**
9194 * Detected file content changes while it was written into the image.
9195 * (MISHAP, HIGH, -358)
9196 * @since 0.6.22
9197*/
9198#define ISO_MD5_STREAM_CHANGE 0xE430FE9A
9199
9200/**
9201 * Session does not start at LBA 0. scdbackup checksum tag not written.
9202 * (WARNING, HIGH, -359)
9203 * @since 0.6.24
9204*/
9205#define ISO_SCDBACKUP_TAG_NOT_0 0xD030FE99
9206
9207/**
9208 * The setting of iso_write_opts_set_ms_block() leaves not enough room
9209 * for the prescibed size of iso_write_opts_set_overwrite_buf().
9210 * (FAILURE, HIGH, -360)
9211 * @since 0.6.36
9212 */
9213#define ISO_OVWRT_MS_TOO_SMALL 0xE830FE98
9214
9215/**
9216 * The partition offset is not 0 and leaves not not enough room for
9217 * system area, volume descriptors, and checksum tags of the first tree.
9218 * (FAILURE, HIGH, -361)
9219 */
9220#define ISO_PART_OFFST_TOO_SMALL 0xE830FE97
9221
9222/**
9223 * The ring buffer is smaller than 64 kB + partition offset.
9224 * (FAILURE, HIGH, -362)
9225 */
9226#define ISO_OVWRT_FIFO_TOO_SMALL 0xE830FE96
9227
9228/** Use of libjte was not enabled at compile time (FAILURE, HIGH, -363) */
9229#define ISO_LIBJTE_NOT_ENABLED 0xE830FE95
9230
9231/** Failed to start up Jigdo Template Extraction (FAILURE, HIGH, -364) */
9232#define ISO_LIBJTE_START_FAILED 0xE830FE94
9233
9234/** Failed to finish Jigdo Template Extraction (FAILURE, HIGH, -365) */
9235#define ISO_LIBJTE_END_FAILED 0xE830FE93
9236
9237/** Failed to process file for Jigdo Template Extraction
9238 (MISHAP, HIGH, -366) */
9239#define ISO_LIBJTE_FILE_FAILED 0xE430FE92
9240
9241/** Too many MIPS Big Endian boot files given (max. 15) (FAILURE, HIGH, -367)*/
9242#define ISO_BOOT_TOO_MANY_MIPS 0xE830FE91
9243
9244/** Boot file missing in image (MISHAP, HIGH, -368) */
9245#define ISO_BOOT_FILE_MISSING 0xE430FE90
9246
9247/** Partition number out of range (FAILURE, HIGH, -369) */
9248#define ISO_BAD_PARTITION_NO 0xE830FE8F
9249
9250/** Cannot open data file for appended partition (FAILURE, HIGH, -370) */
9251#define ISO_BAD_PARTITION_FILE 0xE830FE8E
9252
9253/** May not combine MBR partition with non-MBR system area
9254 (FAILURE, HIGH, -371) */
9255#define ISO_NON_MBR_SYS_AREA 0xE830FE8D
9256
9257/** Displacement offset leads outside 32 bit range (FAILURE, HIGH, -372) */
9258#define ISO_DISPLACE_ROLLOVER 0xE830FE8C
9259
9260/** File name cannot be written into ECMA-119 untranslated
9261 (FAILURE, HIGH, -373) */
9262#define ISO_NAME_NEEDS_TRANSL 0xE830FE8B
9263
9264/** Data file input stream object offers no cloning method
9265 (FAILURE, HIGH, -374) */
9266#define ISO_STREAM_NO_CLONE 0xE830FE8A
9267
9268/** Extended information class offers no cloning method
9269 (FAILURE, HIGH, -375) */
9270#define ISO_XINFO_NO_CLONE 0xE830FE89
9271
9272/** Found copied superblock checksum tag (WARNING, HIGH, -376) */
9273#define ISO_MD5_TAG_COPIED 0xD030FE88
9274
9275/** Rock Ridge leaf name too long (FAILURE, HIGH, -377) */
9276#define ISO_RR_NAME_TOO_LONG 0xE830FE87
9277
9278/** Reserved Rock Ridge leaf name (FAILURE, HIGH, -378) */
9279#define ISO_RR_NAME_RESERVED 0xE830FE86
9280
9281/** Rock Ridge path too long (FAILURE, HIGH, -379) */
9282#define ISO_RR_PATH_TOO_LONG 0xE830FE85
9283
9284/** Attribute name cannot be represented (FAILURE, HIGH, -380) */
9285#define ISO_AAIP_BAD_ATTR_NAME 0xE830FE84
9286
9287/** ACL text contains multiple entries of user::, group::, other::
9288 (FAILURE, HIGH, -381) */
9289#define ISO_AAIP_ACL_MULT_OBJ 0xE830FE83
9290
9291/** File sections do not form consecutive array of blocks
9292 (FAILURE, HIGH, -382) */
9293#define ISO_SECT_SCATTERED 0xE830FE82
9294
9295/** Too many Apple Partition Map entries requested (FAILURE, HIGH, -383) */
9296#define ISO_BOOT_TOO_MANY_APM 0xE830FE81
9297
9298/** Overlapping Apple Partition Map entries requested (FAILURE, HIGH, -384) */
9299#define ISO_BOOT_APM_OVERLAP 0xE830FE80
9300
9301/** Too many GPT entries requested (FAILURE, HIGH, -385) */
9302#define ISO_BOOT_TOO_MANY_GPT 0xE830FE7F
9303
9304/** Overlapping GPT entries requested (FAILURE, HIGH, -386) */
9305#define ISO_BOOT_GPT_OVERLAP 0xE830FE7E
9306
9307/** Too many MBR partition entries requested (FAILURE, HIGH, -387) */
9308#define ISO_BOOT_TOO_MANY_MBR 0xE830FE7D
9309
9310/** Overlapping MBR partition entries requested (FAILURE, HIGH, -388) */
9311#define ISO_BOOT_MBR_OVERLAP 0xE830FE7C
9312
9313/** Attempt to use an MBR partition entry twice (FAILURE, HIGH, -389) */
9314#define ISO_BOOT_MBR_COLLISION 0xE830FE7B
9315
9316/** No suitable El Torito EFI boot image for exposure as GPT partition
9317 (FAILURE, HIGH, -390) */
9318#define ISO_BOOT_NO_EFI_ELTO 0xE830FE7A
9319
9320/** Not a supported HFS+ or APM block size (FAILURE, HIGH, -391) */
9321#define ISO_BOOT_HFSP_BAD_BSIZE 0xE830FE79
9322
9323/** APM block size prevents coexistence with GPT (FAILURE, HIGH, -392) */
9324#define ISO_BOOT_APM_GPT_BSIZE 0xE830FE78
9325
9326/** Name collision in HFS+, mangling not possible (FAILURE, HIGH, -393) */
9327#define ISO_HFSP_NO_MANGLE 0xE830FE77
9328
9329/** Symbolic link cannot be resolved (FAILURE, HIGH, -394) */
9330#define ISO_DEAD_SYMLINK 0xE830FE76
9331
9332/** Too many chained symbolic links (FAILURE, HIGH, -395) */
9333#define ISO_DEEP_SYMLINK 0xE830FE75
9334
9335/** Unrecognized file type in ISO image (FAILURE, HIGH, -396) */
9336#define ISO_BAD_ISO_FILETYPE 0xE830FE74
9337
9338/** Filename not suitable for character set UCS-2 (WARNING, HIGH, -397) */
9339#define ISO_NAME_NOT_UCS2 0xD030FE73
9340
9341/** File name collision during ISO image import (WARNING, HIGH, -398) */
9342#define ISO_IMPORT_COLLISION 0xD030FE72
9343
9344/** Incomplete HP-PA PALO boot parameters (FAILURE, HIGH, -399) */
9345#define ISO_HPPA_PALO_INCOMPL 0xE830FE71
9346
9347/** HP-PA PALO boot address exceeds 2 GB (FAILURE, HIGH, -400) */
9348#define ISO_HPPA_PALO_OFLOW 0xE830FE70
9349
9350/** HP-PA PALO file is not a data file (FAILURE, HIGH, -401) */
9351#define ISO_HPPA_PALO_NOTREG 0xE830FE6F
9352
9353/** HP-PA PALO command line too long (FAILURE, HIGH, -402) */
9354#define ISO_HPPA_PALO_CMDLEN 0xE830FE6E
9355
9356/** Problems encountered during inspection of System Area (WARN, HIGH, -403) */
9357#define ISO_SYSAREA_PROBLEMS 0xD030FE6D
9358
9359/** Unrecognized inquiry for system area property (FAILURE, HIGH, -404) */
9360#define ISO_INQ_SYSAREA_PROP 0xE830FE6C
9361
9362/** DEC Alpha Boot Loader file is not a data file (FAILURE, HIGH, -405) */
9363#define ISO_ALPHA_BOOT_NOTREG 0xE830FE6B
9364
9365/** No data source of imported ISO image available (WARNING, HIGH, -406) */
9366#define ISO_NO_KEPT_DATA_SRC 0xD030FE6A
9367
9368/** Malformed description string for interval reader (FAILURE, HIGH, -407) */
9369#define ISO_MALFORMED_READ_INTVL 0xE830FE69
9370
9371/** Unreadable file, premature EOF, or failure to seek for interval reader
9372 (WARNING, HIGH, -408) */
9373#define ISO_INTVL_READ_PROBLEM 0xD030FE68
9374
9375/** Cannot arrange content of data files in surely reproducible way
9376 (NOTE, HIGH, -409) */
9377#define ISO_NOT_REPRODUCIBLE 0xB030FE67
9378
9379/** May not write boot info into filtered stream of boot image
9380 (FAILURE, HIGH, -410) */
9381#define ISO_PATCH_FILTERED_BOOT 0xE830FE66
9382
9383/** Boot image to large to buffer for writing boot info
9384 (FAILURE, HIGH, -411) */
9385#define ISO_PATCH_OVERSIZED_BOOT 0xE830FE65
9386
9387/** File name had to be truncated and MD5 marked (WARNING, HIGH, -412) */
9388#define ISO_RR_NAME_TRUNCATED 0xD030FE64
9389
9390/** File name truncation length changed by loaded image info
9391 (NOTE, HIGH, -413) */
9392#define ISO_TRUNCATE_ISOFSNT 0xB030FE63
9393
9394/** General note (NOTE, HIGH, -414) */
9395#define ISO_GENERAL_NOTE 0xB030FE62
9396
9397/** Unrecognized file type of IsoFileSrc object (SORRY, HIGH, -415) */
9398#define ISO_BAD_FSRC_FILETYPE 0xE030FE61
9399
9400/** Cannot derive GPT GUID from undefined pseudo-UUID volume timestamp
9401 (FAILURE, HIGH, -416) */
9402#define ISO_GPT_NO_VOL_UUID 0xE830FE60
9403
9404/** Unrecognized GPT disk GUID setup mode
9405 (FAILURE, HIGH, -417) */
9406#define ISO_BAD_GPT_GUID_MODE 0xE830FE5F
9407
9408/** Unable to obtain root directory (FATAL,HIGH, -418) */
9409#define ISO_NO_ROOT_DIR 0xF030FE5E
9410
9411/** Zero sized, oversized, or mislocated SUSP CE area found
9412 (FAILURE, HIGH, -419) */
9413#define ISO_SUSP_WRONG_CE_SIZE 0xE830FE5D
9414
9415/** Multi-session would overwrite imported_iso interval
9416 (FAILURE, HIGH, -420) */
9417#define ISO_MULTI_OVER_IMPORTED 0xE830FE5C
9418
9419/** El-Torito EFI image is hidden (NOTE,HIGH, -421) */
9420#define ISO_ELTO_EFI_HIDDEN 0xB030FE5B
9421
9422/** Too many files in HFS+ directory tree (FAILURE, HIGH, -422) */
9423#define ISO_HFSPLUS_TOO_MANY_FILES 0xE830FE5A
9424
9425/** Too many zisofs block pointers needed overall (FAILURE, HIGH, -423) */
9426#define ISO_ZISOFS_TOO_MANY_PTR 0xE830FE59
9427
9428/** Prevented zisofs block pointer counter underrun (WARNING,MEDIUM, -424) */
9429#define ISO_ZISOFS_BPT_UNDERRUN 0xD020FE58
9430
9431/** Cannot obtain size of zisofs compressed stream (FAILURE, HIGH, -425) */
9432#define ISO_ZISOFS_UNKNOWN_SIZE 0xE830FE57
9433
9434/** Undefined IsoReadImageFeatures name (SORRY, HIGH, -426) */
9435#define ISO_UNDEF_READ_FEATURE 0xE030FE56
9436
9437/** Too many CE entries for single file (FAILURE,HIGH, -427) */
9438#define ISO_TOO_MANY_CE 0xE830FE55
9439
9440/** Too many CE entries for single file when mounted by Linux
9441 (WARNING,HIGH, -428) */
9442#define ISO_TOO_MANY_CE_FOR_LINUX 0xD030FE54
9443
9444/** Too many CE entries for single file, omitting attributes
9445 (WARNING,HIGH, -429) */
9446#define ISO_CE_REMOVING_ATTR 0xD030FE53
9447
9448
9449/* Internal developer note:
9450 Place new error codes directly above this comment.
9451 Newly introduced errors must get a message entry in
9452 libisofs/messages.c, function iso_error_to_msg()
9453*/
9454
9455/* ! PLACE NEW ERROR CODES ABOVE. NOT AFTER THIS LINE ! */
9456
9457
9458/** Read error occurred with IsoDataSource (SORRY,HIGH, -513) */
9459#define ISO_DATA_SOURCE_SORRY 0xE030FCFF
9460
9461/** Read error occurred with IsoDataSource (MISHAP,HIGH, -513) */
9462#define ISO_DATA_SOURCE_MISHAP 0xE430FCFF
9463
9464/** Read error occurred with IsoDataSource (FAILURE,HIGH, -513) */
9465#define ISO_DATA_SOURCE_FAILURE 0xE830FCFF
9466
9467/** Read error occurred with IsoDataSource (FATAL,HIGH, -513) */
9468#define ISO_DATA_SOURCE_FATAL 0xF030FCFF
9469
9470
9471/* ! PLACE NEW ERROR CODES SEVERAL LINES ABOVE. NOT HERE ! */
9472
9473
9474/* ------------------------------------------------------------------------- */
9475
9476#ifdef LIBISOFS_WITHOUT_LIBBURN
9477
9478/**
9479 This is a copy from the API of libburn-0.6.0 (under GPL).
9480 It is supposed to be as stable as any overall include of libburn.h.
9481 I.e. if this definition is out of sync then you cannot rely on any
9482 contract that was made with libburn.h.
9483
9484 Libisofs does not need to be linked with libburn at all. But if it is
9485 linked with libburn then it must be libburn-0.4.2 or later.
9486
9487 An application that provides own struct burn_source objects and does not
9488 include libburn/libburn.h has to define LIBISOFS_WITHOUT_LIBBURN before
9489 including libisofs/libisofs.h in order to make this copy available.
9490*/
9491
9492
9493/** Data source interface for tracks.
9494 This allows to use arbitrary program code as provider of track input data.
9495
9496 Objects compliant to this interface are either provided by the application
9497 or by API calls of libburn: burn_fd_source_new(), burn_file_source_new(),
9498 and burn_fifo_source_new().
9499
9500 libisofs acts as "application" and implements an own class of burn_source.
9501 Instances of that class are handed out by iso_image_create_burn_source().
9502
9503*/
9504struct burn_source {
9505
9506 /** Reference count for the data source. MUST be 1 when a new source
9507 is created and thus the first reference is handed out. Increment
9508 it to take more references for yourself. Use burn_source_free()
9509 to destroy your references to it. */
9510 int refcount;
9511
9512
9513 /** Read data from the source. Semantics like with read(2), but MUST
9514 either deliver the full buffer as defined by size or MUST deliver
9515 EOF (return 0) or failure (return -1) at this call or at the
9516 next following call. I.e. the only incomplete buffer may be the
9517 last one from that source.
9518 libburn will read a single sector by each call to (*read).
9519 The size of a sector depends on BURN_MODE_*. The known range is
9520 2048 to 2352.
9521
9522 If this call is reading from a pipe then it will learn
9523 about the end of data only when that pipe gets closed on the
9524 feeder side. So if the track size is not fixed or if the pipe
9525 delivers less than the predicted amount or if the size is not
9526 block aligned, then burning will halt until the input process
9527 closes the pipe.
9528
9529 IMPORTANT:
9530 If this function pointer is NULL, then the struct burn_source is of
9531 version >= 1 and the job of .(*read)() is done by .(*read_xt)().
9532 See below, member .version.
9533 */
9534 int (*read)(struct burn_source *, unsigned char *buffer, int size);
9535
9536
9537 /** Read subchannel data from the source (NULL if lib generated)
9538 WARNING: This is an obscure feature with CD raw write modes.
9539 Unless you checked the libburn code for correctness in that aspect
9540 you should not rely on raw writing with own subchannels.
9541 ADVICE: Set this pointer to NULL.
9542 */
9543 int (*read_sub)(struct burn_source *, unsigned char *buffer, int size);
9544
9545
9546 /** Get the size of the source's data. Return 0 means unpredictable
9547 size. If application provided (*get_size) allows return 0, then
9548 the application MUST provide a fully functional (*set_size).
9549 */
9550 off_t (*get_size)(struct burn_source *);
9551
9552
9553 /* @since 0.3.2 */
9554 /** Program the reply of (*get_size) to a fixed value. It is advised
9555 to implement this by a attribute off_t fixed_size; in *data .
9556 The read() function does not have to take into respect this fake
9557 setting. It is rather a note of libburn to itself. Eventually
9558 necessary truncation or padding is done in libburn. Truncation
9559 is usually considered a misburn. Padding is considered ok.
9560
9561 libburn is supposed to work even if (*get_size) ignores the
9562 setting by (*set_size). But your application will not be able to
9563 enforce fixed track sizes by burn_track_set_size() and possibly
9564 even padding might be left out.
9565 */
9566 int (*set_size)(struct burn_source *source, off_t size);
9567
9568
9569 /** Clean up the source specific data. This function will be called
9570 once by burn_source_free() when the last referer disposes the
9571 source.
9572 */
9573 void (*free_data)(struct burn_source *);
9574
9575
9576 /** Next source, for when a source runs dry and padding is disabled
9577 WARNING: This is an obscure feature. Set to NULL at creation and
9578 from then on leave untouched and uninterpreted.
9579 */
9580 struct burn_source *next;
9581
9582
9583 /** Source specific data. Here the various source classes express their
9584 specific properties and the instance objects store their individual
9585 management data.
9586 E.g. data could point to a struct like this:
9587 struct app_burn_source
9588 {
9589 struct my_app *app_handle;
9590 ... other individual source parameters ...
9591 off_t fixed_size;
9592 };
9593
9594 Function (*free_data) has to be prepared to clean up and free
9595 the struct.
9596 */
9597 void *data;
9598
9599
9600 /* @since 0.4.2 */
9601 /** Valid only if above member .(*read)() is NULL. This indicates a
9602 version of struct burn_source younger than 0.
9603 From then on, member .version tells which further members exist
9604 in the memory layout of struct burn_source. libburn will only touch
9605 those announced extensions.
9606
9607 Versions:
9608 0 has .(*read)() != NULL, not even .version is present.
9609 1 has .version, .(*read_xt)(), .(*cancel)()
9610 */
9611 int version;
9612
9613 /** This substitutes for (*read)() in versions above 0. */
9614 int (*read_xt)(struct burn_source *, unsigned char *buffer, int size);
9615
9616 /** Informs the burn_source that the consumer of data prematurely
9617 ended reading. This call may or may not be issued by libburn
9618 before (*free_data)() is called.
9619 */
9620 int (*cancel)(struct burn_source *source);
9621};
9622
9623#endif /* LIBISOFS_WITHOUT_LIBBURN */
9624
9625/* ----------------------------- Bug Fixes ----------------------------- */
9626
9627/* currently none being tested */
9628
9629
9630/* ---------------------------- Improvements --------------------------- */
9631
9632/* currently none being tested */
9633
9634
9635/* ---------------------------- Experiments ---------------------------- */
9636
9637
9638/* Experiment: Write obsolete RR entries with Rock Ridge.
9639 I suspect Solaris wants to see them.
9640 DID NOT HELP: Solaris knows only RRIP_1991A.
9641
9642 #define Libisofs_with_rrip_rR yes
9643*/
9644
9645#ifdef __cplusplus
9646} /* extern "C" */
9647#endif
9648
9649#endif /*LIBISO_LIBISOFS_H_*/
int iso_image_get_all_boot_imgs(IsoImage *image, int *num_boots, ElToritoBootImage ***boots, IsoFile ***bootnodes, int flag)
Get all El-Torito boot images of an ISO image.
off_t iso_file_source_lseek(IsoFileSource *src, off_t offset, int flag)
Repositions the offset of the given IsoFileSource (must be opened) to the given offset according to t...
void iso_node_set_permissions(IsoNode *node, mode_t mode)
Set the permissions for the node.
int iso_write_opts_set_efi_bootp(IsoWriteOpts *opts, char *image_path, int flag)
Copy a data file from the local filesystem into the emerging ISO image.
int iso_write_opts_set_hfsplus(IsoWriteOpts *opts, int enable)
Whether to add a HFS+ filesystem to the image which points to the same file content as the other dire...
int iso_image_update_sizes(IsoImage *image)
Update the sizes of all files added to image.
int iso_file_get_md5(IsoImage *image, IsoFile *file, char md5[16], int flag)
Eventually obtain the recorded MD5 checksum of a data file from the loaded ISO image.
int iso_file_get_old_image_lba(IsoFile *file, uint32_t *lba, int flag)
Get the block lba of a file node, if it was imported from an old image.
const char * iso_image_get_volume_id(const IsoImage *image)
Get the volume identifier.
int iso_image_report_el_torito(IsoImage *image, char ***reply, int *line_count, int flag)
Obtain an array of texts describing the detected properties of the eventually loaded El Torito boot i...
struct Iso_Symlink IsoSymlink
A symbolic link in the iso tree.
Definition libisofs.h:191
void iso_tree_set_follow_symlinks(IsoImage *image, int follow)
Set whether to follow or not symbolic links when added a file from a source to IsoImage.
int iso_local_attr_support(int flag)
libisofs has an internal system dependent adapter to ACL and xattr operations.
IsoFindCondition * iso_new_find_conditions_mode(mode_t mask)
Create a new condition that checks the node mode against a mode mask.
int iso_image_set_sparc_core(IsoImage *img, IsoFile *sparc_core, int flag)
Designate a data file in the ISO image of which the position and size shall be written after the SUN ...
int iso_sev_to_text(int severity_number, char **severity_name)
Convert a severity number into a severity name.
int iso_local_set_attrs(char *disk_path, size_t num_attrs, char **names, size_t *value_lengths, char **values, int flag)
Older version of iso_local_set_attrs_errno() without the errnos array.
void iso_tree_set_ignore_hidden(IsoImage *image, int skip)
Set whether to skip or not disk files with names beginning by '.
int iso_write_opts_set_default_uid(IsoWriteOpts *opts, uid_t uid)
Set the uid to use when you set the replace_uid to 2.
IsoFilesystem * iso_file_source_get_filesystem(IsoFileSource *src)
Get the filesystem for this source.
int iso_read_opts_auto_input_charset(IsoReadOpts *opts, int mode)
Enable or disable methods to automatically choose an input charset.
int iso_interval_reader_new(IsoImage *img, char *path, struct iso_interval_reader **ivr, off_t *byte_count, int flag)
Create an interval reader object.
int iso_write_opts_set_joliet_utf16(IsoWriteOpts *opts, int allow)
Use character set UTF-16BE with Joliet, which is a superset of the actually prescribed character set ...
int iso_interval_reader_read(struct iso_interval_reader *ivr, uint8_t *buf, int *buf_fill, int flag)
Read the next block of 2048 bytes from an interval reader object.
int iso_image_add_mips_boot_file(IsoImage *image, char *path, int flag)
Add a MIPS boot file path to the image.
void iso_lib_version(int *major, int *minor, int *micro)
Get version of the libisofs library at runtime.
int iso_node_lookup_attr(IsoNode *node, char *name, size_t *value_length, char **value, int flag)
Obtain the value of a particular xattr name.
int iso_image_path_to_node(IsoImage *image, const char *path, IsoNode **node)
Locate a node by its absolute path in the image.
struct iso_read_image_features IsoReadImageFeatures
Return information for image.
Definition libisofs.h:480
int iso_image_set_boot_catalog_hidden(IsoImage *image, int hide_attrs)
Hides the boot catalog file from directory trees.
int iso_assess_written_features(IsoDataSource *src, IsoReadOpts *opts, IsoReadImageFeatures **features, IsoWriteOpts **write_opts)
Assess features of the importable directory trees of src and an estimation of the write options which...
IsoFindCondition * iso_new_find_conditions_or(IsoFindCondition *a, IsoFindCondition *b)
Create a new condition that check if at least one the two given conditions is valid.
int iso_image_add_new_symlink(IsoImage *image, IsoDir *parent, const char *name, const char *dest, IsoSymlink **link)
Add a new symbolic link to the directory tree.
int iso_image_add_boot_image(IsoImage *image, const char *image_path, enum eltorito_boot_media_type type, int flag, ElToritoBootImage **boot)
Add a further boot image to the set of El-Torito bootable images.
int iso_write_opts_set_fifo_size(IsoWriteOpts *opts, size_t fifo_size)
Set the size, in number of blocks, of the ring buffer used between the writer thread and the burn_sou...
enum iso_replace_mode iso_tree_get_replace_mode(IsoImage *image)
Get current setting for replace_mode.
int iso_md5_clone(void *old_md5_context, void **new_md5_context)
Create a MD5 computation context as clone of an existing one.
int iso_conv_name_chars(IsoWriteOpts *opts, char *name, size_t name_len, char **result, size_t *result_len, int flag)
Convert the characters in name from local charset to another charset or convert name to the represent...
int iso_read_opts_set_no_rockridge(IsoReadOpts *opts, int norr)
Do not read Rock Ridge extensions.
int iso_write_opts_set_disc_label(IsoWriteOpts *opts, char *label)
Set a name for the system area.
int iso_file_source_lstat(IsoFileSource *src, struct stat *info)
Get information about the file.
int el_torito_set_boot_platform_id(ElToritoBootImage *bootimg, uint8_t id)
Sets the platform ID of the boot image.
int iso_write_opts_set_no_force_dots(IsoWriteOpts *opts, int no)
ISO-9660 forces filenames to have a ".", that separates file name from extension.
int iso_image_set_boot_image(IsoImage *image, const char *image_path, enum eltorito_boot_media_type type, const char *catalog_path, ElToritoBootImage **boot)
Create a new set of El-Torito bootable images by adding a boot catalog and the default boot image.
const char * iso_image_fs_get_application_id(IsoImageFilesystem *fs)
Get the application identifier for an existent image.
int iso_node_zf_by_magic(IsoNode *node, int flag)
Check for the given node or for its subtree whether the data file content effectively bears zisofs fi...
int iso_write_opts_set_allow_dir_id_ext(IsoWriteOpts *opts, int allow)
Convert directory names for ECMA-119 similar to other file names, but do not force a dot or add a ver...
int iso_image_get_truncate_mode(IsoImage *img, int *mode, int *length)
Inquire the current setting of iso_image_set_truncate_mode().
int iso_write_opts_set_part_offset(IsoWriteOpts *opts, uint32_t block_offset_2k, int secs_512_per_head, int heads_per_cyl)
int iso_file_source_get_aa_string(IsoFileSource *src, unsigned char **aa_string, int flag)
Get the AAIP string with encoded ACL and xattr.
int iso_md5_end(void **md5_context, char result[16])
Obtain the MD5 checksum from a MD5 computation context and dispose this context.
IsoFindCondition * iso_new_find_conditions_not(IsoFindCondition *negate)
Create a new condition that check if the given conditions is false.
int aaip_xinfo_cloner(void *old_data, void **new_data, int flag)
The iso_node_xinfo_cloner function which gets associated to aaip_xinfo_func by iso_init() or iso_init...
int el_torito_get_boot_platform_id(ElToritoBootImage *bootimg)
Get the platform ID value.
int iso_node_get_attrs(IsoNode *node, size_t *num_attrs, char ***names, size_t **value_lengths, char ***values, int flag)
Get the list of xattr which is associated with the node.
int iso_image_add_new_dir(IsoImage *image, IsoDir *parent, const char *name, IsoDir **dir)
Add a new directory to the iso tree.
void iso_node_unref(IsoNode *node)
Decrements the reference counting of the given node.
eltorito_boot_media_type
El-Torito bootable image type.
Definition libisofs.h:334
@ ELTORITO_HARD_DISC_EMUL
Definition libisofs.h:336
@ ELTORITO_FLOPPY_EMUL
Definition libisofs.h:335
@ ELTORITO_NO_EMUL
Definition libisofs.h:337
int iso_local_get_perms_wo_acl(char *disk_path, mode_t *st_mode, int flag)
Obtain permissions of a file in the local filesystem which shall reflect ACL entry "group::" in S_IRW...
int iso_write_opts_set_always_gmt(IsoWriteOpts *opts, int gmt)
Whether to always record timestamps in GMT.
int iso_file_source_read(IsoFileSource *src, void *buf, size_t count)
Attempts to read up to count bytes from the given source into the buffer starting at buf.
int iso_write_opts_new(IsoWriteOpts **opts, int profile)
Creates an IsoWriteOpts for writing an image.
struct Iso_File IsoFile
A regular file in the iso tree.
Definition libisofs.h:199
int iso_set_msgs_severities(char *queue_severity, char *print_severity, char *print_id)
Control queueing and stderr printing of messages from libisofs.
void iso_image_set_app_use(IsoImage *image, const char *app_use_data, int count)
Fill Application Use field of the Primary Volume Descriptor.
int iso_write_opts_set_appended_as_apm(IsoWriteOpts *opts, int apm)
Control whether partitions created by iso_write_opts_set_partition_img() are to be represented in App...
int iso_tree_get_ignore_special(IsoImage *image)
Get current setting for ignore_special.
IsoFindCondition * iso_new_find_conditions_ctime(time_t time, enum iso_find_comparisons comparison)
Create a new condition that checks the time of last status change.
int iso_zisofs_set_params(struct iso_zisofs_ctrl *params, int flag)
Set the global parameters for zisofs filtering.
int iso_write_opts_set_joliet(IsoWriteOpts *opts, int enable)
Whether to add the non-standard Joliet extension to the image.
int iso_write_opts_set_default_file_mode(IsoWriteOpts *opts, mode_t file_mode)
Set the mode to use on files when you set the replace_mode of files to 2.
const char * iso_node_get_name(const IsoNode *node)
Get the name of a node.
int iso_image_tree_clone(IsoImage *image, IsoNode *node, IsoDir *new_parent, char *new_name, IsoNode **new_node, int flag)
Create a copy of the given node under a different path.
int iso_node_set_attrs(IsoNode *node, size_t num_attrs, char **names, size_t *value_lengths, char **values, int flag)
Set the list of xattr which is associated with the node.
int iso_write_opts_set_allow_deep_paths(IsoWriteOpts *opts, int allow)
Allow ISO-9660 directory hierarchy to be deeper than 8 levels.
int iso_error_get_severity(int e)
Get the severity of a given error code.
void * iso_get_messenger()
Return the messenger object handle used by libisofs.
int iso_read_opts_set_no_md5(IsoReadOpts *opts, int no_md5)
Control reading of an array of MD5 checksums which is eventually stored at the end of a session.
int iso_write_opts_set_replace_mode(IsoWriteOpts *opts, int dir_mode, int file_mode, int uid, int gid)
Whether to set default values for files and directory permissions, gid and uid.
void iso_image_unref(IsoImage *image)
Decrements the reference counting of the given image.
int iso_write_opts_set_output_charset(IsoWriteOpts *opts, const char *charset)
Set the charset to use for the RR names of the files that will be created on the image.
int iso_file_source_readdir(IsoFileSource *src, IsoFileSource **child)
Read a directory.
IsoNodeType
The type of an IsoNode.
Definition libisofs.h:228
@ LIBISO_BOOT
Definition libisofs.h:233
@ LIBISO_DIR
Definition libisofs.h:229
@ LIBISO_FILE
Definition libisofs.h:230
@ LIBISO_SYMLINK
Definition libisofs.h:231
@ LIBISO_SPECIAL
Definition libisofs.h:232
int iso_write_opts_set_dir_rec_mtime(IsoWriteOpts *opts, int allow)
Store as ECMA-119 Directory Record timestamp the mtime of the source node rather than the image creat...
void iso_data_source_unref(IsoDataSource *src)
Decrements the reference counting of the given IsoDataSource, freeing it if refcount reach 0.
int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode, dev_t dev, IsoSpecial **special)
int iso_write_opts_set_iso_level(IsoWriteOpts *opts, int level)
Set the ISO-9960 level to write at.
int el_torito_get_boot_media_type(ElToritoBootImage *bootimg, enum eltorito_boot_media_type *media_type)
Get the boot media type as of parameter "type" of iso_image_set_boot_image() or iso_image_add_boot_im...
struct iso_read_opts IsoReadOpts
Options for image reading or import.
Definition libisofs.h:388
IsoFindCondition * iso_new_find_conditions_gid(gid_t gid)
Create a new condition that checks the node gid.
int iso_write_opts_set_tail_blocks(IsoWriteOpts *opts, uint32_t num_blocks)
Cause a number of blocks with zero bytes to be written after the payload data, but before the eventua...
int iso_dir_get_node(IsoDir *dir, const char *name, IsoNode **node)
int iso_image_add_new_special(IsoImage *image, IsoDir *parent, const char *name, mode_t mode, dev_t dev, IsoSpecial **special)
Add a new special file to the directory tree.
const char * iso_image_fs_get_system_id(IsoImageFilesystem *fs)
Get the system identifier for an existent image.
struct Iso_Dir IsoDir
A directory in the iso tree.
Definition libisofs.h:183
int el_torito_set_id_string(ElToritoBootImage *bootimg, uint8_t id_string[28])
Set the id_string of the Validation Entry or Sector Header Entry which will govern the boot image Sec...
int iso_stream_update_size(IsoStream *stream)
Updates the size of the IsoStream with the current size of the underlying source.
int iso_dir_get_children(const IsoDir *dir, IsoDirIter **iter)
Get an iterator for the children of the given dir.
int iso_image_add_new_file(IsoImage *image, IsoDir *parent, const char *name, IsoStream *stream, IsoFile **file)
Add a new regular file to the iso tree.
off_t iso_file_get_size(IsoFile *file)
Get the size of the file, in bytes.
void iso_data_source_ref(IsoDataSource *src)
Increments the reference counting of the given IsoDataSource.
int iso_tree_add_new_file(IsoDir *parent, const char *name, IsoStream *stream, IsoFile **file)
const char * iso_error_to_msg(int errcode)
Get a textual description of a libisofs error.
int iso_write_opts_set_scdbackup_tag(IsoWriteOpts *opts, char *name, char *timestamp, char *tag_written)
Set the parameters "name" and "timestamp" for a scdbackup checksum tag.
int iso_write_opts_set_rrip_version_1_10(IsoWriteOpts *opts, int oldvers)
Write Rock Ridge info as of specification RRIP-1.10 rather than RRIP-1.12: signature "RRIP_1991A" rat...
int iso_read_image_features_has_eltorito(IsoReadImageFeatures *f)
Whether El-Torito boot record is present present in the image imported.
struct el_torito_boot_image ElToritoBootImage
It represents an El-Torito boot image.
Definition libisofs.h:284
void iso_filesystem_ref(IsoFilesystem *fs)
Take a ref to the given IsoFilesystem.
int iso_read_opts_set_no_iso1999(IsoReadOpts *opts, int noiso1999)
Do not read ISO 9660:1999 enhanced tree.
int iso_image_create_burn_source(IsoImage *image, IsoWriteOpts *opts, struct burn_source **burn_src)
Create a burn_source and a thread which immediately begins to generate the image.
int iso_stream_clone(IsoStream *old_stream, IsoStream **new_stream, int flag)
Produce a copy of a stream.
int iso_write_opts_set_appended_as_gpt(IsoWriteOpts *opts, int gpt)
Control whether partitions created by iso_write_opts_set_partition_img() are to be represented in MBR...
void iso_file_source_unref(IsoFileSource *src)
Drop your ref to the given IsoFileSource, eventually freeing the associated system resources.
unsigned int iso_fs_global_id
See IsoFilesystem->get_id() for info about this.
int iso_node_remove_xinfo(IsoNode *node, iso_node_xinfo_func proc)
Remove the given extended info (defined by the proc function) from the given node.
int iso_image_generator_is_running(IsoImage *image)
Inquire whether the image generator thread is still at work.
int iso_nowtime(time_t *now, int flag)
Inquire and maybe define the time which is considered to be "now" and used for timestamps of freshly ...
int iso_read_image_features_has_rockridge(IsoReadImageFeatures *f)
Whether RockRidge extensions are present in the image imported.
int iso_stream_open(IsoStream *stream)
Opens the given stream.
int iso_image_set_hppa_palo(IsoImage *img, char *cmdline, char *bootloader, char *kernel_32, char *kernel_64, char *ramdisk, int flag)
Define a command line and submit the paths of four mandatory files for production of a HP-PA PALO boo...
int iso_write_opts_set_hfsp_block_size(IsoWriteOpts *opts, int hfsp_block_size, int apm_block_size)
Set the block size for Apple Partition Map and for HFS+.
int iso_util_decode_md5_tag(char data[2048], int *tag_type, uint32_t *pos, uint32_t *range_start, uint32_t *range_size, uint32_t *next_tag, char md5[16], int flag)
Check a data block whether it is a libisofs session checksum tag and eventually obtain its recorded p...
int iso_write_opts_set_relaxed_vol_atts(IsoWriteOpts *opts, int allow)
Allow all characters to be part of Volume and Volset identifiers on the Primary Volume Descriptor.
int iso_init_with_flag(int flag)
Initialize libisofs.
int iso_file_remove_filter(IsoFile *file, int flag)
Delete the top filter stream from a data file.
int iso_write_opts_set_prep_img(IsoWriteOpts *opts, char *image_path, int flag)
Copy a data file from the local filesystem into the emerging ISO image.
const char * iso_image_get_data_preparer_id(const IsoImage *image)
Get the data preparer of a image.
const char * iso_image_fs_get_copyright_file_id(IsoImageFilesystem *fs)
Get the copyright file identifier for an existent image.
mode_t iso_node_get_mode(const IsoNode *node)
Get the mode of the node, both permissions and file type, as specified in 'man 2 stat'.
int iso_tree_get_follow_symlinks(IsoImage *image)
Get current setting for follow_symlinks.
int iso_write_opts_set_joliet_longer_paths(IsoWriteOpts *opts, int allow)
Allow paths in the Joliet tree to have more than 240 characters.
int iso_tree_add_dir_rec(IsoImage *image, IsoDir *parent, const char *dir)
Add the contents of a dir to a given directory of the iso tree.
int iso_image_report_system_area(IsoImage *image, char ***reply, int *line_count, int flag)
Obtain an array of texts describing the detected properties of the eventually loaded System Area.
int iso_write_opts_set_hfsp_serial_number(IsoWriteOpts *opts, uint8_t serial_number[8])
Supply a serial number for the HFS+ extension of the emerging image.
int iso_node_get_xinfo(IsoNode *node, iso_node_xinfo_func proc, void **data)
Get the given extended info (defined by the proc function) from the given node.
int(* iso_node_xinfo_func)(void *data, int flag)
Class of functions to handle particular extended information.
Definition libisofs.h:5007
const char * iso_image_fs_get_publisher_id(IsoImageFilesystem *fs)
Get the publisher identifier for an existent image.
int iso_file_add_gzip_filter(IsoFile *file, int flag)
Install a gzip or gunzip filter on top of the content stream of a data file.
void iso_image_set_copyright_file_id(IsoImage *image, const char *copyright_file_id)
Fill copyright information for the image.
int iso_node_set_acl_text(IsoNode *node, char *access_text, char *default_text, int flag)
Set the ACLs of the given node to the lists in parameters access_text and default_text or delete them...
int iso_image_get_pvd_times(IsoImage *image, char **creation_time, char **modification_time, char **expiration_time, char **effective_time)
Get the four timestamps from the Primary Volume Descriptor of the imported ISO image.
int iso_image_get_system_area(IsoImage *img, char data[32768], int *options, int flag)
Obtain a copy of the eventually loaded first 32768 bytes of the imported session, the System Area.
int iso_read_opts_set_no_joliet(IsoReadOpts *opts, int nojoliet)
Do not read Joliet extensions.
int iso_image_get_boot_image(IsoImage *image, ElToritoBootImage **boot, IsoFile **imgnode, IsoBoot **catnode)
Get the El-Torito boot catalog and the default boot image of an ISO image.
int iso_file_source_access(IsoFileSource *src)
Check if the process has access to read file contents.
int iso_memory_stream_new(unsigned char *buf, size_t size, IsoStream **stream)
Create an IsoStream object from content which is stored in a dynamically allocated memory buffer.
const char * iso_image_get_system_id(const IsoImage *image)
Get the system id of a image.
void iso_read_image_features_destroy(IsoReadImageFeatures *f)
Destroy an IsoReadImageFeatures object obtained with iso_image_import() or iso_assess_written_feature...
int el_torito_get_full_load(ElToritoBootImage *bootimg)
Inquire the setting of el_torito_set_full_load().
int iso_write_opts_set_default_dir_mode(IsoWriteOpts *opts, mode_t dir_mode)
Set the mode to use on dirs when you set the replace_mode of dirs to 2.
int el_torito_get_load_seg(ElToritoBootImage *bootimg)
Get the load segment value.
int iso_node_xinfo_make_clonable(iso_node_xinfo_func proc, iso_node_xinfo_cloner cloner, int flag)
Associate a iso_node_xinfo_cloner to a particular class of extended information in order to make it c...
int iso_tree_add_exclude(IsoImage *image, const char *path)
Add a excluded path.
void iso_finish()
Finalize libisofs.
void iso_image_set_biblio_file_id(IsoImage *image, const char *biblio_file_id)
Fill biblio information for the image.
struct iso_write_opts IsoWriteOpts
Options for image written.
Definition libisofs.h:381
int iso_file_add_external_filter(IsoFile *file, IsoExternalFilterCommand *cmd, int flag)
Install an external filter command on top of the content stream of a data file.
void iso_tree_set_ignore_special(IsoImage *image, int skip)
Set whether to skip or not special files.
int iso_write_opts_set_default_gid(IsoWriteOpts *opts, gid_t gid)
Set the gid to use when you set the replace_gid to 2.
int iso_node_take(IsoNode *node)
Removes a child from a directory.
int iso_zisofs_ctrl_susp_z2(int enable)
Enable or disable the production of "Z2" SUSP entries instead of "ZF" entries for zisofs2 compressed ...
void iso_tree_set_replace_mode(IsoImage *image, enum iso_replace_mode mode)
Set the replace mode, that defines the behavior of libisofs when adding a node whit the same name tha...
void iso_filesystem_unref(IsoFilesystem *fs)
Drop your ref to the given IsoFilesystem, evetually freeing associated resources.
int iso_local_set_attrs_errno(char *disk_path, size_t num_attrs, char **names, size_t *value_lengths, char **values, int *errnos, int flag)
Attach a list of xattr and ACLs to the given file in the local filesystem.
int iso_tree_get_ignore_hidden(IsoImage *image)
Get current setting for ignore_hidden.
off_t iso_stream_get_size(IsoStream *stream)
Get the size of a given stream.
int iso_text_to_sev(char *severity_name, int *severity_number)
Convert a severity name into a severity number, which gives the severity rank of the name.
void iso_node_set_gid(IsoNode *node, gid_t gid)
Set the group id for the node.
int iso_file_source_close(IsoFileSource *src)
Close a previously opened file.
int iso_node_remove_tree(IsoNode *node, IsoDirIter *boss_iter)
Removes a node by iso_node_remove() or iso_dir_iter_remove().
int el_torito_get_selection_crit(ElToritoBootImage *bootimg, uint8_t crit[20])
Get the Selection Criteria bytes as of el_torito_set_selection_crit().
int iso_dir_add_node(IsoDir *dir, IsoNode *child, enum iso_replace_mode replace)
Add a new node to a dir.
int iso_write_opts_set_replace_timestamps(IsoWriteOpts *opts, int replace)
0 to use IsoNode timestamps, 1 to use recording time, 2 to use values from timestamp field.
int iso_tree_add_new_dir(IsoDir *parent, const char *name, IsoDir **dir)
int iso_dir_iter_remove(IsoDirIter *iter)
Removes a child from a directory during an iteration and unref() it.
int iso_read_opts_set_default_uid(IsoReadOpts *opts, uid_t uid)
Set default uid for files when RR extensions are not present.
int iso_local_get_acl_text(char *disk_path, char **text, int flag)
Get an ACL of the given file in the local filesystem in long text form.
const char * iso_image_get_copyright_file_id(const IsoImage *image)
Get the copyright information of a image.
int iso_write_opts_set_omit_version_numbers(IsoWriteOpts *opts, int omit)
Omit the version number (";1") at the end of the ISO-9660 identifiers.
const char * iso_image_fs_get_data_preparer_id(IsoImageFilesystem *fs)
Get the data preparer identifier for an existent image.
int iso_file_source_stat(IsoFileSource *src, struct stat *info)
Get information about the file.
int iso_read_opts_set_default_gid(IsoReadOpts *opts, gid_t gid)
Set default gid for files when RR extensions are not present.
int iso_set_abort_severity(char *severity)
Set the minimum error severity that causes a libisofs operation to be aborted as soon as possible.
void iso_image_set_abstract_file_id(IsoImage *image, const char *abstract_file_id)
Fill abstract information for the image.
int iso_write_opts_set_iso1999(IsoWriteOpts *opts, int enable)
Whether to use newer ISO-9660:1999 version.
int iso_write_opts_get_data_start(IsoWriteOpts *opts, uint32_t *data_start, int flag)
Inquire the start address of the file data blocks after having used IsoWriteOpts with iso_image_creat...
int iso_write_opts_set_max_ce_entries(IsoWriteOpts *opts, uint32_t num, int flag)
Set the maximum number of SUSP CE entries and thus continuation areas.
void iso_node_set_ctime(IsoNode *node, time_t time)
Set the time of last status change of the file.
int iso_tree_clone(IsoNode *node, IsoDir *new_parent, char *new_name, IsoNode **new_node, int flag)
int iso_stream_get_external_filter(IsoStream *stream, IsoExternalFilterCommand **cmd, int flag)
Obtain the IsoExternalFilterCommand which is eventually associated with the given stream.
iso_replace_mode
Replace mode used when adding a node to a directory.
Definition libisofs.h:347
@ ISO_REPLACE_IF_SAME_TYPE_AND_NEWER
Replace with the new node if it is the same file type and its ctime is newer than the old one.
Definition libisofs.h:365
@ ISO_REPLACE_ALWAYS
Always replace the old node with the new.
Definition libisofs.h:356
@ ISO_REPLACE_IF_NEWER
Replace with the new node if its ctime is newer than the old one.
Definition libisofs.h:369
@ ISO_REPLACE_IF_SAME_TYPE
Replace with the new node if it is the same file type.
Definition libisofs.h:360
@ ISO_REPLACE_NEVER
Never replace an existing node, and instead fail with ISO_NODE_NAME_NOT_UNIQUE.
Definition libisofs.h:352
int iso_write_opts_set_gpt_guid(IsoWriteOpts *opts, uint8_t guid[16], int mode)
Control whether the emerging GPT gets a pseudo-randomly generated disk GUID or whether it gets a user...
int iso_write_opts_set_part_like_isohybrid(IsoWriteOpts *opts, int alike)
Control whether bits 2 to 8 of el_torito_set_isolinux_options() shall apply even if not isohybrid MBR...
int iso_write_opts_set_iso_type_guid(IsoWriteOpts *opts, uint8_t guid[16], int valid)
Set the GPT Type GUID for the partition which represents the ISO 9660 filesystem, if such a partition...
int iso_interval_reader_destroy(struct iso_interval_reader **ivr, int flag)
Dispose an interval reader object.
int iso_write_opts_set_untranslated_name_len(IsoWriteOpts *opts, int len)
Caution: This option breaks any assumptions about names that are supported by ECMA-119 specifications...
int iso_dir_iter_take(IsoDirIter *iter)
Removes a child from a directory during an iteration, without freeing it.
int iso_image_get_hppa_palo(IsoImage *img, char **cmdline, char **bootloader, char **kernel_32, char **kernel_64, char **ramdisk)
Inquire the current settings of iso_image_set_hppa_palo().
int iso_tree_remove_exclude(IsoImage *image, const char *path)
Remove a previously added exclude.
int iso_image_get_session_md5(IsoImage *image, uint32_t *start_lba, uint32_t *end_lba, char md5[16], int flag)
Obtain the recorded MD5 checksum of the session which was loaded as ISO image.
int iso_image_import(IsoImage *image, IsoDataSource *src, IsoReadOpts *opts, IsoReadImageFeatures **features)
Import a previous session or image, for growing or modify.
int iso_write_opts_set_fat(IsoWriteOpts *opts, int enable)
‍Production of FAT32 is not implemented yet.
void iso_file_source_ref(IsoFileSource *src)
Take a ref to the given IsoFileSource.
int iso_lib_is_compatible(int major, int minor, int micro)
Check at runtime if the library is ABI compatible with the given version.
void iso_node_set_hidden(IsoNode *node, int hide_attrs)
Set whether the node will be hidden in the directory trees of RR/ISO 9660, or of Joliet (if enabled a...
time_t iso_node_get_atime(const IsoNode *node)
Get the time of last access to the file.
int iso_local_set_acl_text(char *disk_path, char *text, int flag)
Set the ACL of the given file in the local filesystem to a given list in long text form.
void el_torito_set_load_seg(ElToritoBootImage *bootimg, short segment)
Sets the load segment for the initial boot image.
char * iso_get_local_charset(int flag)
Obtain the local charset as currently assumed by libisofs.
int el_torito_set_selection_crit(ElToritoBootImage *bootimg, uint8_t crit[20])
Set the Selection Criteria of a boot image.
const char * iso_image_fs_get_biblio_file_id(IsoImageFilesystem *fs)
Get the biblio file identifier for an existent image.
IsoStream * iso_stream_get_input_stream(IsoStream *stream, int flag)
Obtain the eventual input stream of a filter stream.
int iso_node_set_name(IsoNode *node, const char *name)
int iso_write_opts_set_appendable(IsoWriteOpts *opts, int append)
Set the type of image creation in case there was already an existing image imported.
void iso_node_set_mtime(IsoNode *node, time_t time)
Set the time of last modification of the file.
int iso_ring_buffer_get_status(struct burn_source *b, size_t *size, size_t *free_bytes)
Get the status of the buffer used by a burn_source.
uint32_t iso_crc32_gpt(unsigned char *data, int count, int flag)
Compute a CRC number as expected in the GPT main and backup header blocks.
int iso_zisofs_get_refcounts(off_t *ziso_count, off_t *osiz_count, int flag)
Inquire the number of zisofs compression and uncompression filters which are in use.
struct Iso_Boot IsoBoot
An special type of IsoNode that acts as a placeholder for an El-Torito boot catalog.
Definition libisofs.h:292
int iso_node_get_next_xinfo(IsoNode *node, void **handle, iso_node_xinfo_func *proc, void **data)
Get the next pair of function pointer and data of an iteration of the list of extended information.
char * iso_tree_get_node_path(IsoNode *node)
Get the absolute path on image of the given node.
const char * iso_symlink_get_dest(const IsoSymlink *link)
Get the destination of a node.
int iso_image_get_msg_id(IsoImage *image)
Get the id of an IsoImage, used for message reporting.
int iso_read_image_features_tree_loaded(IsoReadImageFeatures *f)
Tells what directory tree was loaded: 0= ISO 9660 , 1 = Joliet , 2 = ISO 9660:1999.
int iso_error_get_code(int e)
Get the message queue code of a libisofs error.
IsoFindCondition * iso_new_find_conditions_mtime(time_t time, enum iso_find_comparisons comparison)
Create a new condition that checks the time of last modification.
int iso_write_opts_set_pvd_times(IsoWriteOpts *opts, time_t vol_creation_time, time_t vol_modification_time, time_t vol_expiration_time, time_t vol_effective_time, char *vol_uuid)
Explicitly set the four timestamps of the emerging Primary Volume Descriptor and in the volume descri...
void iso_image_set_volset_id(IsoImage *image, const char *volset_id)
Fill in the volset identifier for a image.
int iso_stream_get_zisofs_par(IsoStream *stream, int *stream_type, uint8_t zisofs_algo[2], uint8_t *algo_num, int *block_size_log2, int flag)
Obtain the parameters of a zisofs filter stream.
IsoDir * iso_node_get_parent(IsoNode *node)
int iso_read_opts_set_joliet_map(IsoReadOpts *opts, int joliet_map)
How to convert Joliet file names.
int iso_write_opts_attach_jte(IsoWriteOpts *opts, void *libjte_handle)
Associate a libjte environment object to the upcoming write run.
int iso_md5_match(char first_md5[16], char second_md5[16])
Inquire whether two MD5 checksums match.
int iso_write_opts_set_joliet_long_names(IsoWriteOpts *opts, int allow)
Allow leaf names in the Joliet tree to have up to 103 characters.
void iso_image_set_publisher_id(IsoImage *image, const char *publisher_id)
Fill in the publisher for a image.
int iso_error_get_priority(int e)
Get the priority of a given error.
int iso_read_opts_set_preferjoliet(IsoReadOpts *opts, int preferjoliet)
Whether to prefer Joliet over RR.
int iso_write_opts_set_aaip(IsoWriteOpts *opts, int enable)
Control writing of AAIP information for ACL and xattr.
int iso_init()
Initialize libisofs.
void iso_stream_get_id(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id, ino_t *ino_id)
Get an unique identifier for a given IsoStream.
time_t iso_node_get_ctime(const IsoNode *node)
Get the time of last status change of the file.
int el_torito_get_id_string(ElToritoBootImage *bootimg, uint8_t id_string[28])
Get the id_string as of el_torito_set_id_string().
int iso_stream_read(IsoStream *stream, void *buf, size_t count)
Attempts to read up to count bytes from the given stream into the buffer starting at buf.
int el_torito_get_isolinux_options(ElToritoBootImage *bootimg, int flag)
Get the options as of el_torito_set_isolinux_options().
void iso_tree_set_report_callback(IsoImage *image, int(*report)(IsoImage *, IsoFileSource *))
Set a callback function that libisofs will call for each file that is added to the given image by a r...
int iso_write_opts_set_aaip_susp_1_10(IsoWriteOpts *opts, int oldvers)
Write AAIP as extension according to SUSP 1.10 rather than SUSP 1.12.
void iso_node_ref(IsoNode *node)
Increments the reference counting of the given node.
int iso_file_get_sort_weight(IsoFile *file)
Get the sort weight of a file.
char * iso_file_source_get_path(IsoFileSource *src)
Get the absolute path in the filesystem this file source belongs to.
int aaip_xinfo_func(void *data, int flag)
Function to identify and manage AAIP strings as xinfo of IsoNode.
int iso_image_set_boot_catalog_weight(IsoImage *image, int sort_weight)
Sets the sort weight of the boot catalog that is attached to an IsoImage.
void el_torito_set_no_bootable(ElToritoBootImage *bootimg)
Marks the specified boot image as not bootable.
int(* iso_node_xinfo_cloner)(void *old_data, void **new_data, int flag)
Class of functions to clone extended information.
Definition libisofs.h:5137
int iso_node_add_xinfo(IsoNode *node, iso_node_xinfo_func proc, void *data)
Add extended information to the given node.
int iso_dir_iter_next(IsoDirIter *iter, IsoNode **node)
Get the next child.
int iso_zisofs_get_params(struct iso_zisofs_ctrl *params, int flag)
Get the current global parameters for zisofs filtering.
int iso_dir_find_children(IsoDir *dir, IsoFindCondition *cond, IsoDirIter **iter)
Find all directory children that match the given condition.
int iso_msgs_submit(int error_code, char msg_text[], int os_errno, char severity[], int origin)
Submit a message to the libisofs queueing system.
int iso_image_get_ignore_aclea(IsoImage *image)
Obtain the current setting of iso_image_set_ignore_aclea().
int iso_write_opts_set_hardlinks(IsoWriteOpts *opts, int enable)
Control generation of non-unique inode numbers for the emerging image.
uint32_t iso_read_image_features_get_size(IsoReadImageFeatures *f)
Get the size (in 2048 byte block) of the image, as reported in the PVM.
int iso_read_opts_new(IsoReadOpts **opts, int profile)
Creates an IsoReadOpts for reading an existent image.
int el_torito_seems_boot_info_table(ElToritoBootImage *bootimg, int flag)
Makes a guess whether the boot image was patched by a boot information table.
int iso_set_local_charset(char *name, int flag)
Override the reply of libc function nl_langinfo(CODESET) which may or may not give the name of the ch...
IsoFindCondition * iso_new_find_conditions_atime(time_t time, enum iso_find_comparisons comparison)
Create a new condition that checks the time of last access.
ino_t serial_id
Serial number to be used when you can't get a valid id for a Stream by other means.
IsoHideNodeFlag
Flag used to hide a file in the RR/ISO or Joliet tree.
Definition libisofs.h:300
@ LIBISO_HIDE_ON_JOLIET
Hide the node in the Joliet tree, if Joliet extension are enabled.
Definition libisofs.h:304
@ LIBISO_HIDE_BUT_WRITE
With IsoNode and IsoBoot: Write data content even if the node is not visible in any tree.
Definition libisofs.h:326
@ LIBISO_HIDE_ON_1999
Hide the node in the ISO-9660:1999 tree, if that format is enabled.
Definition libisofs.h:306
@ LIBISO_HIDE_ON_HFSPLUS
Hide the node in the HFS+ tree, if that format is enabled.
Definition libisofs.h:311
@ LIBISO_HIDE_ON_RR
Hide the node in the ECMA-119 / RR tree.
Definition libisofs.h:302
@ LIBISO_HIDE_ON_FAT
Hide the node in the FAT tree, if that format is enabled.
Definition libisofs.h:316
void * iso_image_get_attached_data(IsoImage *image)
The the data previously attached with iso_image_attach_data()
int iso_image_attach_data(IsoImage *image, void *data, void(*give_up)(void *))
Attach user defined data to the image.
int iso_stream_cmp_ino(IsoStream *s1, IsoStream *s2, int flag)
Compare two streams whether they are based on the same input and will produce the same output.
mode_t iso_node_get_permissions(const IsoNode *node)
Get the permissions for the node.
int iso_write_opts_set_overwrite_buf(IsoWriteOpts *opts, uint8_t *overwrite)
Sets the buffer where to store the descriptors which shall be written at the beginning of an overwrit...
int iso_image_dir_get_node(IsoImage *image, IsoDir *dir, const char *name, IsoNode **node, int flag)
Locate a node inside a given dir.
int el_torito_get_bootable(ElToritoBootImage *bootimg)
Get the bootability flag.
void el_torito_patch_isolinux_image(ElToritoBootImage *bootimg)
Deprecated: Specifies that this image needs to be patched.
int iso_tree_add_new_symlink(IsoDir *parent, const char *name, const char *dest, IsoSymlink **link)
const char * iso_image_get_biblio_file_id(const IsoImage *image)
Get the biblio information of a image.
int iso_write_opts_set_record_md5(IsoWriteOpts *opts, int session, int files)
Whether to compute and record MD5 checksums for the whole session and/or for each single IsoFile obje...
const char * iso_image_fs_get_volume_id(IsoImageFilesystem *fs)
Get the volume identifier for an existent image.
int iso_node_remove_all_xinfo(IsoNode *node, int flag)
Remove all extended information from the given node.
int iso_image_get_bootcat(IsoImage *image, IsoBoot **catnode, uint32_t *lba, char **content, off_t *size)
Get detailed information about the boot catalog that was loaded from an ISO image.
const char * iso_image_get_application_id(const IsoImage *image)
Get the application id of a image.
int iso_local_get_attrs(char *disk_path, size_t *num_attrs, char ***names, size_t **value_lengths, char ***values, int flag)
Get xattr and non-trivial ACLs of the given file in the local filesystem.
mode_t iso_node_get_perms_wo_acl(const IsoNode *node)
Like iso_node_get_permissions but reflecting ACL entry "group::" in S_IRWXG rather than ACL entry "ma...
const char * iso_image_get_publisher_id(const IsoImage *image)
Get the publisher of a image.
int iso_read_opts_set_no_aaip(IsoReadOpts *opts, int noaaip)
Control reading of AAIP information about ACL and xattr when loading existing images.
void iso_generate_gpt_guid(uint8_t guid[16])
Generate a pseudo-random GUID suitable for iso_write_opts_set_gpt_guid().
int iso_image_hfsplus_bless(IsoImage *img, enum IsoHfsplusBlessings blessing, IsoNode *node, int flag)
Issue a blessing to a particular IsoNode.
int iso_read_image_features_has_joliet(IsoReadImageFeatures *f)
Whether Joliet extensions are present in the image imported.
int iso_tree_resolve_symlink(IsoImage *img, IsoSymlink *sym, IsoNode **res, int *depth, int flag)
Get the destination node of a symbolic link within the IsoImage.
int iso_write_opts_set_max_37_char_filenames(IsoWriteOpts *opts, int allow)
Allow a single file or directory identifier to have up to 37 characters.
const char * iso_image_get_app_use(IsoImage *image)
Get the current setting for the Application Use field of the Primary Volume Descriptor.
int iso_image_filesystem_new(IsoDataSource *src, IsoReadOpts *opts, int msgid, IsoImageFilesystem **fs)
Create a new IsoFilesystem to access a existent ISO image.
int iso_write_opts_set_iso_mbr_part_type(IsoWriteOpts *opts, int part_type)
Set the partition type of the MBR partition which represents the ISO filesystem or at least protects ...
gid_t iso_node_get_gid(const IsoNode *node)
Get the group id of the node.
int iso_tree_path_to_node(IsoImage *image, const char *path, IsoNode **node)
int iso_image_give_up_mips_boot(IsoImage *image, int flag)
Clear the list of MIPS Big Endian boot file paths.
void iso_stream_unref(IsoStream *stream)
Decrement reference count of an IsoStream, and eventually free it if refcount reach 0.
void iso_node_set_atime(IsoNode *node, time_t time)
Set the time of last access to the file.
int iso_write_opts_set_old_empty(IsoWriteOpts *opts, int enable)
Use this only if you need to reproduce a suboptimal behavior of older versions of libisofs.
void iso_dir_iter_free(IsoDirIter *iter)
Free a dir iterator.
int iso_image_get_alpha_boot(IsoImage *img, char **boot_loader_path)
Inquire the path submitted by iso_image_set_alpha_boot() Do not free() the returned pointer.
IsoFindCondition * iso_new_find_conditions_and(IsoFindCondition *a, IsoFindCondition *b)
Create a new condition that check if the two given conditions are valid.
void iso_image_set_application_id(IsoImage *image, const char *application_id)
Fill in the application id for a image.
enum IsoNodeType iso_node_get_type(IsoNode *node)
Get the type of an IsoNode.
const char * iso_image_fs_get_abstract_file_id(IsoImageFilesystem *fs)
Get the abstract file identifier for an existent image.
int iso_gzip_get_refcounts(off_t *gzip_count, off_t *gunzip_count, int flag)
Inquire the number of gzip compression and uncompression filters which are in use.
int iso_read_opts_set_start_block(IsoReadOpts *opts, uint32_t block)
Set the block where the image begins.
int iso_read_opts_load_system_area(IsoReadOpts *opts, int mode)
Enable or disable loading of the first 32768 bytes of the session.
int iso_tree_add_node(IsoImage *image, IsoDir *parent, const char *path, IsoNode **node)
Add a new node to the image tree, from an existing file.
int iso_md5_start(void **md5_context)
Create a MD5 computation context and hand out an opaque handle.
int el_torito_get_load_size(ElToritoBootImage *bootimg)
Get the load size.
struct Iso_Node IsoNode
Definition libisofs.h:175
int iso_dir_iter_has_next(IsoDirIter *iter)
Check if there're more children.
int iso_file_get_old_image_sections(IsoFile *file, int *section_count, struct iso_file_section **sections, int flag)
Get the start addresses and the sizes of the data extents of a file node if it was imported from an o...
void el_torito_set_full_load(ElToritoBootImage *bootimg, int mode)
State that the load size shall be the size of the boot image automatically.
int iso_write_opts_set_allow_longer_paths(IsoWriteOpts *opts, int allow)
Allow path in the ISO-9660 tree to have more than 255 characters.
int iso_write_opts_set_part_type_guid(IsoWriteOpts *opts, int partition_number, uint8_t guid[16], int valid)
Set the GPT Type GUID for a partition defined by iso_write_opts_set_partition_img().
int iso_write_opts_set_system_area(IsoWriteOpts *opts, char data[32768], int options, int flag)
void iso_image_set_volume_id(IsoImage *image, const char *volume_id)
Fill in the volume identifier for a image.
int iso_node_get_hidden(IsoNode *node)
Get the hide_attrs as eventually set by iso_node_set_hidden().
int iso_node_get_old_image_lba(IsoNode *node, uint32_t *lba, int flag)
int iso_write_opts_set_rrip_1_10_px_ino(IsoWriteOpts *opts, int enable)
Write field PX with file serial number (i.e.
int iso_read_image_features_rr_loaded(IsoReadImageFeatures *f)
Tells whether Rock Ridge information was used while loading the tree: 1= yes, 0= no.
int iso_read_opts_set_new_inos(IsoReadOpts *opts, int new_inos)
Control discarding of eventual inode numbers from existing images.
int iso_file_source_open(IsoFileSource *src)
Opens the source.
int iso_symlink_set_dest(IsoSymlink *link, const char *dest)
Set the destination of a symbolic.
void iso_node_set_uid(IsoNode *node, uid_t uid)
Set the user id for the node.
int iso_node_xinfo_get_cloner(iso_node_xinfo_func proc, iso_node_xinfo_cloner *cloner, int flag)
Inquire the registered cloner function for a particular class of extended information.
int iso_write_opts_set_allow_full_ascii(IsoWriteOpts *opts, int allow)
Allow all 8-bit characters to appear on an ISO-9660 filename.
int iso_data_source_new_from_file(const char *path, IsoDataSource **src)
Create a new IsoDataSource from a local file.
void el_torito_set_load_size(ElToritoBootImage *bootimg, short sectors)
Sets the number of sectors (512b) to be load at load segment during the initial boot procedure.
IsoHfsplusBlessings
HFS+ blessings are relationships between HFS+ enhanced ISO images and particular files in such images...
Definition libisofs.h:8758
@ ISO_HFSPLUS_BLESS_SHOWFOLDER
Definition libisofs.h:8766
@ ISO_HFSPLUS_BLESS_OSX_FOLDER
Definition libisofs.h:8768
@ ISO_HFSPLUS_BLESS_PPC_BOOTDIR
Definition libisofs.h:8760
@ ISO_HFSPLUS_BLESS_MAX
Definition libisofs.h:8771
@ ISO_HFSPLUS_BLESS_INTEL_BOOTFILE
Definition libisofs.h:8763
@ ISO_HFSPLUS_BLESS_OS9_FOLDER
Definition libisofs.h:8767
void iso_image_ref(IsoImage *image)
Increments the reference counting of the given image.
const char * iso_image_get_abstract_file_id(const IsoImage *image)
Get the abstract information of a image.
void iso_image_set_ignore_aclea(IsoImage *image, int what)
Control whether ACL and xattr will be imported from external filesystems (typically the local POSIX f...
int iso_read_image_feature_named(IsoReadImageFeatures *f, char *name, char **text, int *type, int64_t *num_value, void **pt_value, size_t *pt_size)
Get a named feature as text, num_value, or pt_value depending on its type.
int iso_image_new(const char *name, IsoImage **image)
Create a new image, empty.
int iso_dir_get_children_count(IsoDir *dir)
Get the number of children of a directory.
int iso_file_source_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
Read the destination of a symlink.
int iso_node_remove(IsoNode *node)
Removes a child from a directory and free (unref) it.
IsoFilesystem IsoImageFilesystem
IsoFilesystem implementation to deal with ISO images, and to offer a way to access specific informati...
Definition libisofs.h:514
int iso_stream_close(IsoStream *stream)
Close a previously opened IsoStream.
void iso_image_set_system_id(IsoImage *image, const char *system_id)
Fill in the system id for a image.
void iso_image_remove_boot_image(IsoImage *image)
Removes all El-Torito boot images from the ISO image.
struct Iso_Dir_Iter IsoDirIter
Context for iterate on directory children.
Definition libisofs.h:277
int iso_image_zisofs_discard_bpt(IsoImage *image, int flag)
Discard all buffered zisofs compression block pointers of streams in the given image,...
int iso_file_add_zisofs_filter(IsoFile *file, int flag)
Install a zisofs filter on top of the content stream of a data file.
int iso_write_opts_set_default_timestamp(IsoWriteOpts *opts, time_t timestamp)
Set the timestamp to use when you set the replace_timestamps to 2.
int iso_md5_compute(void *md5_context, char *data, int datalen)
Advance the computation of a MD5 checksum by a chunk of data bytes.
int el_torito_set_isolinux_options(ElToritoBootImage *bootimg, int options, int flag)
Specifies options for ISOLINUX or GRUB boot images.
int iso_hfsplus_xinfo_func(void *data, int flag)
The function that is used to mark struct iso_hfsplus_xinfo_data at IsoNodes and finally disposes such...
IsoDir * iso_image_get_root(const IsoImage *image)
Get the root directory of the image.
IsoFindCondition * iso_new_find_conditions_name(const char *wildcard)
Create a new condition that checks if the node name matches the given wildcard.
int iso_image_hfsplus_get_blessed(IsoImage *img, IsoNode ***blessed_nodes, int *bless_max, int flag)
Get the array of nodes which are currently blessed.
int iso_stream_zisofs_discard_bpt(IsoStream *stream, int flag)
Discard the buffered zisofs compression block pointers of a stream, if the stream is a zisofs compres...
time_t iso_node_get_mtime(const IsoNode *node)
Get the time of last modification of the file.
int iso_image_set_node_name(IsoImage *image, IsoNode *node, const char *name, int flag)
Set the name of a node.
int iso_tree_add_new_node(IsoImage *image, IsoDir *parent, const char *name, const char *path, IsoNode **node)
This is a more versatile form of iso_tree_add_node which allows to set the node name in ISO image alr...
int iso_image_get_mips_boot_files(IsoImage *image, char *paths[15], int flag)
Obtain the number of added MIPS Big Endian boot files and pointers to their paths in the ISO 9660 Roc...
int iso_truncate_leaf_name(int mode, int length, char *name, int flag)
Immediately apply the given truncate mode and length to the given string.
IsoFindCondition * iso_new_find_conditions_uid(uid_t uid)
Create a new condition that checks the node uid.
dev_t iso_special_get_dev(IsoSpecial *special)
Get the device id (major/minor numbers) of the given block or character device file.
int iso_write_opts_detach_jte(IsoWriteOpts *opts, void **libjte_handle)
Remove eventual association to a libjte environment handle.
iso_find_comparisons
Possible comparison between IsoNode and given conditions.
Definition libisofs.h:5722
@ ISO_FIND_COND_LESS
Definition libisofs.h:5726
@ ISO_FIND_COND_EQUAL
Definition libisofs.h:5725
@ ISO_FIND_COND_LESS_OR_EQUAL
Definition libisofs.h:5727
@ ISO_FIND_COND_GREATER_OR_EQUAL
Definition libisofs.h:5724
@ ISO_FIND_COND_GREATER
Definition libisofs.h:5723
int iso_read_opts_set_default_permissions(IsoReadOpts *opts, mode_t file_perm, mode_t dir_perm)
Set default permissions for files when RR extensions are not present.
int iso_write_opts_set_partition_img(IsoWriteOpts *opts, int partition_number, uint8_t partition_type, char *image_path, int flag)
Cause an arbitrary data file to be appended to the ISO image and to be described by a partition table...
int iso_image_was_blind_attrs(IsoImage *image, int flag)
Inquire whether some local filesystem xattr namespace could not be explored during node building....
char * iso_file_source_get_name(IsoFileSource *src)
Get the name of the file, with the dir component of the path.
int iso_read_image_features_has_iso1999(IsoReadImageFeatures *f)
Whether the image is recorded according to ISO 9660:1999, i.e.
struct Iso_Special IsoSpecial
An special file in the iso tree.
Definition libisofs.h:209
int iso_write_opts_set_rr_reloc(IsoWriteOpts *opts, char *name, int flags)
This call describes the directory where to store Rock Ridge relocated directories.
int iso_read_opts_set_ecma119_map(IsoReadOpts *opts, int ecma119_map)
How to convert file names if neither Rock Ridge nor Joliet names are present and acceptable.
int iso_image_set_truncate_mode(IsoImage *img, int mode, int length)
Set the name truncation mode and the maximum name length for nodes from image importing,...
void iso_image_set_data_preparer_id(IsoImage *image, const char *data_preparer_id)
Fill in the data preparer for a image.
void iso_read_opts_free(IsoReadOpts *opts)
Free an IsoReadOpts previously allocated with iso_read_opts_new().
int iso_write_opts_set_allow_7bit_ascii(IsoWriteOpts *opts, int allow)
If not iso_write_opts_set_allow_full_ascii() is set to 1: Allow all 7-bit characters that would be al...
int iso_obtain_msgs(char *minimum_severity, int *error_code, int *imgid, char msg_text[], char severity[])
Obtain the oldest pending libisofs message from the queue which has at least the given minimum_severi...
const char * iso_image_fs_get_volset_id(IsoImageFilesystem *fs)
Get the volset identifier for an existent image.
void iso_write_opts_free(IsoWriteOpts *opts)
Free an IsoWriteOpts previously allocated with iso_write_opts_new().
int iso_write_opts_set_allow_lowercase(IsoWriteOpts *opts, int allow)
Allow lowercase characters in ISO-9660 filenames.
const char * iso_image_get_volset_id(const IsoImage *image)
Get the volset identifier.
int iso_node_get_acl_text(IsoNode *node, char **access_text, char **default_text, int flag)
Get the eventual ACLs which are associated with the node.
int iso_write_opts_set_will_cancel(IsoWriteOpts *opts, int will_cancel)
Announce that only the image size is desired, that the struct burn_source which is set to consume the...
void iso_stream_ref(IsoStream *stream)
Increment reference count of an IsoStream.
char * iso_stream_get_source_path(IsoStream *stream, int flag)
Try to get eventual source path string of a stream.
int iso_file_make_md5(IsoFile *file, int flag)
Read the content of an IsoFile object, compute its MD5 and attach it to the IsoFile.
int iso_node_cmp_ino(IsoNode *n1, IsoNode *n2, int flag)
Compare two nodes whether they are based on the same input and can be considered as hardlinks to the ...
struct iso_hfsplus_xinfo_data * iso_hfsplus_xinfo_new(int flag)
Create an instance of struct iso_hfsplus_xinfo_new().
int iso_image_set_alpha_boot(IsoImage *img, char *boot_loader_path, int flag)
Submit the path of the DEC Alpha Secondary Bootstrap Loader file.
struct Iso_Image IsoImage
Context for image creation.
Definition libisofs.h:164
void iso_node_set_sort_weight(IsoNode *node, int w)
Sets the order in which a node will be written on image.
int iso_stream_is_repeatable(IsoStream *stream)
Whether the given IsoStream can be read several times, with the same results.
int iso_write_opts_set_ms_block(IsoWriteOpts *opts, uint32_t ms_block)
Set the start block of the image.
int iso_read_opts_keep_import_src(IsoReadOpts *opts, int mode)
Control whether to keep a reference to the IsoDataSource object which allows access to the blocks of ...
int iso_tree_add_new_cut_out_node(IsoImage *image, IsoDir *parent, const char *name, const char *path, off_t offset, off_t size, IsoNode **node)
Add a new node to the image tree with the given name that must not exist on dir.
int iso_read_image_features_text(IsoReadImageFeatures *f, int with_values, char **feature_text)
Get all validly assessed named features as one single 0-terminated string consisting of single lines ...
struct iso_find_condition IsoFindCondition
Definition libisofs.h:5660
int iso_write_opts_set_rockridge(IsoWriteOpts *opts, int enable)
Whether to use or not Rock Ridge extensions.
int iso_read_opts_set_input_charset(IsoReadOpts *opts, const char *charset)
Set the input charset of the file names on the image.
uid_t iso_node_get_uid(const IsoNode *node)
Get the user id of the node.
int iso_image_get_sparc_core(IsoImage *img, IsoFile **sparc_core, int flag)
Obtain the current setting of iso_image_set_sparc_core().
IsoStream * iso_file_get_stream(IsoFile *file)
Get the IsoStream that represents the contents of the given IsoFile.
int iso_write_opts_set_sort_files(IsoWriteOpts *opts, int sort)
Whether to sort files based on their weight.
Interface definition for an IsoFileSource.
Definition libisofs.h:634
void(* free)(IsoFileSource *src)
Free implementation specific data.
Definition libisofs.h:823
int(* access)(IsoFileSource *src)
Check if the process has access to read file contents.
Definition libisofs.h:713
int(* close)(IsoFileSource *src)
Close a previously opened file.
Definition libisofs.h:737
int(* stat)(IsoFileSource *src, struct stat *info)
Get information about the file.
Definition libisofs.h:692
int(* open)(IsoFileSource *src)
Opens the source.
Definition libisofs.h:727
off_t(* lseek)(IsoFileSource *src, off_t offset, int flag)
Repositions the offset of the IsoFileSource (must be opened) to the given offset according to the val...
Definition libisofs.h:843
int(* get_aa_string)(IsoFileSource *src, unsigned char **aa_string, int flag)
Valid only if .version is > 0.
Definition libisofs.h:878
int(* read)(IsoFileSource *src, void *buf, size_t count)
Attempts to read up to count bytes from the given source into the buffer starting at buf.
Definition libisofs.h:759
int(* readlink)(IsoFileSource *src, char *buf, size_t bufsiz)
Read the destination of a symlink.
Definition libisofs.h:808
int version
Tells the version of the interface: Version 0 provides functions up to (*lseek)().
Definition libisofs.h:644
int(* readdir)(IsoFileSource *src, IsoFileSource **child)
Read a directory.
Definition libisofs.h:784
int(* lstat)(IsoFileSource *src, struct stat *info)
Get information about the file.
Definition libisofs.h:676
int(* clone_src)(IsoFileSource *old_src, IsoFileSource **new_src, int flag)
Produce a copy of a source.
Definition libisofs.h:896
Interface definition for IsoStream methods.
Definition libisofs.h:985
void(* get_id)(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id, ino_t *ino_id)
Get an unique identifier for the IsoStream.
Definition libisofs.h:1071
int(* cmp_ino)(IsoStream *s1, IsoStream *s2)
Compare two streams whether they are based on the same input and will produce the same output.
Definition libisofs.h:1151
int(* clone_stream)(IsoStream *old_stream, IsoStream **new_stream, int flag)
Produce a copy of a stream.
Definition libisofs.h:1170
char type[4]
Type of Stream.
Definition libisofs.h:1016
int(* is_repeatable)(IsoStream *stream)
Tell whether this IsoStream can be read several times, with the same results.
Definition libisofs.h:1066
off_t(* get_size)(IsoStream *stream)
Get the size (in bytes) of the stream.
Definition libisofs.h:1039
int(* update_size)(IsoStream *stream)
Update the size of the IsoStream with the current size of the underlying source, if the source is pro...
Definition libisofs.h:1095
int(* close)(IsoStream *stream)
Close the Stream.
Definition libisofs.h:1032
void(* free)(IsoStream *stream)
Free implementation specific data.
Definition libisofs.h:1078
int(* open)(IsoStream *stream)
Opens the stream.
Definition libisofs.h:1025
int(* read)(IsoStream *stream, void *buf, size_t count)
Attempt to read up to count bytes from the given stream into the buffer starting at buf.
Definition libisofs.h:1055
Data source used by libisofs for reading an existing image.
Definition libisofs.h:413
int(* close)(IsoDataSource *src)
Close a given source, freeing all system resources previously grabbed in open().
Definition libisofs.h:442
int(* open)(IsoDataSource *src)
Opens the given source.
Definition libisofs.h:433
int(* read_block)(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
Read an arbitrary block (2048 bytes) of data from the source.
Definition libisofs.h:459
unsigned int refcount
Reference count for the data source.
Definition libisofs.h:423
void * data
Source specific data.
Definition libisofs.h:469
void(* free_data)(IsoDataSource *src)
Clean up the source specific data.
Definition libisofs.h:466
Representation of an external program that shall serve as filter for an IsoStream.
Definition libisofs.h:8055
File section in an old image.
Definition libisofs.h:257
uint32_t size
Definition libisofs.h:259
uint32_t block
Definition libisofs.h:258
An IsoFile Source is a POSIX abstraction of a file.
Definition libisofs.h:914
An IsoFilesystem is a handler for a source of files, or a "filesystem".
Definition libisofs.h:542
unsigned int(* get_id)(IsoFilesystem *fs)
Get filesystem identifier.
Definition libisofs.h:593
int(* open)(IsoFilesystem *fs)
Opens the filesystem for several read operations.
Definition libisofs.h:605
unsigned int refcount
Definition libisofs.h:623
int(* get_root)(IsoFilesystem *fs, IsoFileSource **root)
Get the root of a filesystem.
Definition libisofs.h:559
int(* get_by_path)(IsoFilesystem *fs, const char *path, IsoFileSource **file)
Retrieve a file from its absolute path inside the filesystem.
Definition libisofs.h:577
int(* close)(IsoFilesystem *fs)
Close the filesystem, thus freeing all system resources.
Definition libisofs.h:614
void(* free)(IsoFilesystem *fs)
Free implementation specific data.
Definition libisofs.h:620
char type[4]
Type of filesystem.
Definition libisofs.h:548
HFS+ attributes which may be attached to IsoNode objects as data parameter of iso_node_add_xinfo().
Definition libisofs.h:8712
uint8_t creator_code[4]
Definition libisofs.h:8721
Representation of file contents as a stream of bytes.
Definition libisofs.h:1184
void * data
Definition libisofs.h:1187
Parameter set for iso_zisofs_set_params().
Definition libisofs.h:8256
uint64_t max_total_blocks
Definition libisofs.h:8303
uint64_t current_total_blocks
Definition libisofs.h:8309
uint8_t v2_block_size_log2
Definition libisofs.h:8297
int64_t bpt_discard_file_blocks
Definition libisofs.h:8342
double bpt_discard_free_ratio
Definition libisofs.h:8354
uint64_t max_file_blocks
Definition libisofs.h:8315
int64_t block_number_target
Definition libisofs.h:8330
uint8_t block_size_log2
Definition libisofs.h:8276

Generated for libisofs by  doxygen 1.10.0