libisoburn/xorriso/xorriso_private.h

/* Command line oriented batch and dialog tool which creates, loads,
   manipulates and burns ISO 9660 filesystem images.

   Copyright 2007-2020 Thomas Schmitt, <scdbackup@gmx.net>

   Provided under GPL version 2 or later.

   This file contains inner declarations of xorriso.
   The public interface is in xorriso.h
*/


/* For now, #ifdef Xorriso_is_xorriso_selF  has no meaning.
   But it is already now to be set only by the xorriso.c module.
*/

#ifndef Xorriso_private_includeD
#define Xorriso_private_includeD yes


/* <<< Disable this to disable pthread_mutex locking on message and result
       output.
*/
#define Xorriso_fetch_with_msg_queueS yes


/* for uint32_t */
#ifdef HAVE_STDINT_H
#include <stdint.h>
#else
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#endif

/* for pthread_mutex_t on OpenBSD */
#include <pthread.h>


/** The source code release timestamp */
#include "xorriso_timestamp.h"
#ifndef Xorriso_timestamP
#define Xorriso_timestamP "-none-given-"
#endif

/** The binary build timestamp is to be set externally by the compiler
    or by a macro definition in xorriso_buildstamp.h.
*/
#include "xorriso_buildstamp.h"
#ifndef Xorriso_build_timestamP
#define Xorriso_build_timestamP "-none-given-"
#endif


#include "sfile.h"
#include "misc_funct.h"


struct ExclusionS;        /* List of -not_* conditions */
struct PermiteM;          /* Stack of temporarily altered access permissions */
struct CheckmediajoB;     /* Parameters for Xorriso_check_media() */
struct SectorbitmaP;      /* Distiniction between valid and invalid sectors */
struct FindjoB;           /* Program and status of a find run */


/* maximum number of history lines to be reported with -status:long_history */
#define Xorriso_status_history_maX 100


/** The list of startup file names */
#define Xorriso_rc_nuM 4


/* Default setting for the size limit of single data files:
   100 extents with 4 GB - 2 kB each = 400 GB - 200 kB
*/
#define Xorriso_default_file_size_limiT \
        (((off_t) 400) * ((off_t) 1024*1024*1024) - (off_t) 204800)


/* Maximum number of appended partitions. Effectively usable number depends
   on system area type.
*/
#define Xorriso_max_appended_partitionS 8


/*
  Maximum length of a disc label text plus 1.
*/
#define Xorriso_disc_label_sizE 129


struct XorrisO { /* the global context of xorriso */

 int libs_are_started;

 /* source */
 char progname[SfileadrL];
 char initial_wdx[SfileadrL];
 int no_rc;

 /* Command line argument emulations:
      0=xorriso mode
      1=mkisofs mode
      2=cdrecord mode
 */
 int argument_emulation;

 /** List of startupfiles */
 char rc_filenames[Xorriso_rc_nuM][SfileadrL];
 int rc_filename_count;

 int arrange_args;

 /* Whether .mkisofsrc has already been read */
 int mkisofsrc_done;

 char wdi[SfileadrL];
 char wdx[SfileadrL];
 int did_something_useful;

 int add_plainly;
 off_t split_size;

 char list_delimiter[81];

 /* >>> put libisofs aspects here <<< */

 int ino_behavior; /* bit0= at image load time:
                            Do not load PX inode numbers but generate new
                            unique ones for all loaded IsoNode.
                      bit1= at image generation time:
                            Do not consolidate suitable nodes to hardlinks.
                      bit2= at restore-to-disk time:
                            Do not consolidate suitable nodes to hardlinks.
                      bit3= with update:
                            Do not try to detect hardlink splits and joinings.
                      bit4= with extract:
                            Do not create or use hln arrays if sort_lba_on
                      bit5= with command -lsl
                            Do not create hln array for hard link count
                    */

 int iso_level;
 int iso_level_is_default;
 int do_joliet;
 int do_hfsplus;
 int do_fat;
 int do_rockridge;
 int do_iso1999;
 int ecma119_map;     /* 0=unmapped , 1=stripped , 2=uppercase , 3=lowercase */

 int do_aaip; /* bit0= ACL in
                 bit1= ACL out
                 bit2= EA in
                 bit3= EA out
                 bit4= record dev,inode per node, isofs_st_out in root
                 bit5= check dev,inode,isofs_st_in
                 bit6= omit content check if bit5 check is conclusive
                 bit7= omit dev check with bit5
                 bit8= store output charset in xattr "isofs.cs"
                 bit9= set input charset from xattr "isofs.cs"
                bit10= if bit2: import from local filesystem all xattr
                                namespaces, not only "user."
                       if bit3: export to local filesystem all xattr
                                namespaces, not only "user."
              */

 int do_md5;  /* bit0= read MD5 array
                 bit1= write session MD5
                 bit2= write MD5 for each data file
                 bit3= make file content stability check by double reading
                 bit4= use recorded MD5 as proxy of ISO file
                 bit5= with bit0: do not check tags of superblock,tree,session
                 bit6= during extraction verify file content by recorded MD5
                 bit7= with bit6: take lack of MD5 as error
               */

 int no_emul_toc; /* bit0= On overwritables: 
                           write first session to LBA 0 rather than 32.
                  */

 int do_old_empty; /* See -compliance old_empty
                      own data content: range [0,31]. The new way is to have
                      a dedicated block to which all such files will point.
                    */

 char scdbackup_tag_name[81];
 char scdbackup_tag_time[19];
 char scdbackup_tag_written[512];
 char scdbackup_tag_listname[SfileadrL];

 int relax_compliance;        /* opaque bitfield to be set by xorrisoburn */
 int allow_dir_id_ext_dflt; /* -compliance allow_dir_id_ext still on default */
 char rr_reloc_dir[256];
 int rr_reloc_flags;
 int untranslated_name_len;
 int do_follow_pattern;
 int do_follow_param;
 int do_follow_links;
 int follow_link_limit;
 int resolve_link_rec_count;
 int resolve_link_rec_limit;
 int do_follow_concat;
 int do_follow_mount;
 int do_global_uid;
 uid_t global_uid;
 int do_global_gid;
 gid_t global_gid;
 int do_global_mode;
 mode_t global_dir_mode;
 mode_t global_file_mode;

 int do_tao; /* 1= Use TAO or Incremental
               -1= Use SAO or DAO
                0= let libburn choose */

 struct Xorriso_lsT *filters;
 int filter_list_closed;

 int zlib_level;
 int zlib_level_default;
 int zisofs_block_size;
 int zisofs_block_size_default;
 int zisofs_by_magic;
 int zisofs_v2_enabled;  /* 0=no, 1=as_needed, 2=force */
 uint64_t zisofs_max_total_blocks;
 uint64_t zisofs_max_total_blocks_default;
 uint64_t zisofs_max_file_blocks;
 uint64_t zisofs_max_file_blocks_default;
 int zisofs_v2_block_size;
 int zisofs_v2_block_size_default;
 int64_t zisofs_block_number_target;
 double zisofs_bpt_discard_free_ratio;
 double zisofs_bpt_discard_free_ratio_default;
 int zisofs_susp_z2;
 int zisofs_susp_z2_default;

 int do_overwrite; /* 0=off, 1=on, 2=nondir */
 int do_reassure;  /* 0=off, 1=on, 2=tree */

 char volid[33];
 int volid_default;
 char loaded_volid[33];
 char assert_volid[SfileadrL];
 char assert_volid_sev[80];

 char preparer_id[129];

 char publisher[129];
 char application_id[129];
 char system_id[33];
 char volset_id[129];

 char copyright_file[38];
 char biblio_file[38];
 char abstract_file[38];

 char application_use[SfileadrL];

 char session_logfile[SfileadrL];
 int session_lba;
 int session_blocks;

 /* >>> put libburn/isoburn aspects here */

 struct Xorriso_lsT *drive_blacklist;
 struct Xorriso_lsT *drive_greylist;
 struct Xorriso_lsT *drive_whitelist;

 int toc_emulation_flag; /* bit0= bit3 for isoburn_drive_aquire()
                                  scan -ROM profiles for ISO sessions
                            bit1= bit4 for isoburn_drive_aquire()
                                  do not emulate TOC on overwritable media
                            bit2= bit7 for isoburn_drive_aquire()
                                  pretend any media to be -ROM
                            bit3= bit9 for isoburn_drive_aquire()
                                  Ignore enclosing session at LBA 0
                         */

 int image_start_mode;  /* From what address to load the ISO image
                           bit0-15= addressing mode
                            0= automatic lba as deduced from media
                            1= value is session number
                            2= value is track number
                            3= value is lba
                           bit16= with mode 3 : value is possibly 16 too high.
                                  Let isoburn_set_msc1() adjust it.
                           bit30= interference with normal msc1 processing
                                  is enabled. Without this bit,
                                  isoburn_set_msc1() will not be called.
                           bit31= image loading has happened,
                                  setting is kept for rollback only.
                                  Always apply as 0=auto.
                        */
 char image_start_value[81]; /* value according image_start_mode */

 uint32_t displacement;
 int displacement_sign;

 int read_fs;            /* bit0=norock , bit1=nojoliet */

 int drives_exclusive;   /* burn_preset_device_open() param exclusive */
 int drives_access;      /* 0=readonly , 1=unrestricted */

 int linux_scsi_dev_family; /* 0= default, 1= sr, 2= scd, (3= st), 4= sg */

 int early_stdio_test;   /* For burn_allow_drive_role_4():
                            bit1= Test whether a stdio drive can be opened for
                                  read-write resp. read-only resp. write only.
                            bit2= Classify files which cannot be opened at all
                                  as role 0 : useless dummy.
                            bit3= Classify non-empty role 5 drives as
                                  BURN_DISC_APPENDABLE with NWA after the
                                  end of the file. It is nevertheless
                                  possible to change this address by call
                                  burn_write_opts_set_start_byte().
                          */

 int cache_num_tiles;     /* -data_cache_size */
 int cache_tile_blocks;
 int cache_default;       /* bit0= cache_num_tiles, bit1= cache_tile_blocks */

 int do_calm_drive;      /* bit0= calm down drive after acquiring it */

 char indev[SfileadrL];
 void *in_drive_handle;  /* interpreted only by libburnia oriented modules */
 void *in_volset_handle; /* interpreted only by libburnia oriented modules */
 char *in_charset;       /* The charset to interpret the filename bytes */
 int indev_is_exclusive;
 int indev_access;              /* see drives_access */
 char indev_off_adr[SfileadrL]; /* Result of burn_drive_convert_fs_adr(indev)
                                   when indev gets acquired. */

 time_t isofs_st_out;    /* A time point at least 1 second before image
                            composition began. To be stored with image as
                            xattr "isofs.st". */
 time_t isofs_st_in;     /* That time point as read from "isofs.st" of the
                            loaded image. */

 int volset_change_pending; /* whether -commit would make sense
                               0= no change pending
                               1= change pending
                               2= change pending, but -as misofs -print-size
                                  was performed on the changed image model
                               3= change pending, but the attempt to write it
                                  failed
                             */
 int no_volset_present;     /* set to 1 on first failure */

 struct CheckmediajoB *check_media_default;
 int check_media_bad_limit;      /* values defined as Xorriso_read_quality_* */
 struct SectorbitmaP *in_sector_map; /* eventual sector validity bitmap */


 char outdev[SfileadrL];
 void *out_drive_handle; /* interpreted only by xorrisoburn.c */
 char *out_charset;      /* The charset to produce the filename bytes for */
 int dev_fd_1; /* The fd which substitutes for /dev/fd/1 and is
                     connected to externaly perveived stdout.
                  */
 int outdev_is_exclusive;
 int outdev_access;              /* see drives_access */
 char outdev_off_adr[SfileadrL]; /* Result of burn_drive_convert_fs_adr(outdev)
		        	    when outdev gets acquired. */

 int grow_blindly_msc2; /* if >= 0 this causes growing from drive to drive.
                           The value is used as block address offset for
                           image generation. Like in: mkisofs -C msc1,msc2
                         */

 int ban_stdio_write;
 int do_dummy;
 int do_close;
 int auto_close;     /* Whether to let do_close depend on media state */

 int write_speed;    /* Write speed in libburn units : 1000 bytes/second ,
                                           0 = Max, -1 = Min, -2= do not set */
 int read_speed;     /* Read speed. See above */
 int read_speed_force;   /* >0 : use burn_nominal_slowdown() in
                                 Xorriso_check_interval() */
 int read_speed_corr;    /* parameter max_corr for burn_nominal_slowdown */

 int fs;        /* fifo size in 2048 byte chunks : at most 1 GB */
 int padding;   /* number of bytes to add after ISO 9660 image */
 int do_padding_by_libisofs; /* 0= by libburn , 1= by libisofs */

 int alignment; /* if > 0 : output size alignment in 2048 byte blocks.
                            This is always done by libburn, i.e. attached
                            outside the image. Eventual inner alignment of
                            the image end happens first.
                */

 int do_stream_recording; /* 0=no, 1=yes, 2=for data, not for dir
                             >=16 means yes with number as start LBA  */

 int dvd_obs;                 /* DVD write chunk size: 0, 32k or 64k */

 int modesty_on_drive;        /* "enable" of burn_drive_set_buffer_waiting()
                                 0= disable , 1= enable waiting ,
                                 (-1 = do not change setting)
                               */
 int min_buffer_usec;         /* The other parameters for this function */
 int max_buffer_usec;
 int buffer_timeout_sec;
 int min_buffer_percent;
 int max_buffer_percent;

 int use_immed_bit;           /* 1= on , 0= default , -1 = off */
 int use_immed_bit_default;   /* 1= on , 0= yet undefined , -1 = off */

 int stdio_sync;              /* stdio fsync interval: -1, 0, >=32 */
 int stdio_sync_is_default;   /* 1= is still default , 0= has been set */

 int keep_boot_image;
 char boot_image_cat_path[SfileadrL];
 int boot_image_cat_hidden;   /* bit0= hidden in ISO/RR , bit1= in Joliet ,
                                 bit2= in HFS+ */
 int boot_count; /* number of already attached boot images */

 char boot_image_bin_path[SfileadrL];
 char boot_image_bin_form[16];
 int boot_platform_id; 
 int patch_isolinux_image; /* bit0= boot-info-table , bit1= not with EFI
                              bit2-7= Mentioning in isohybrid GPT
                                      1=EFI, 2=HFS+
                              bit8= Mention in isohybrid Apple Partition Map
                              bit9= GRUB2 boot provisions (patch at byte 1012)
                            */
 int boot_image_emul; /* 0=no emulation
                         1=emulation as hard disk
                         2=emulation as floppy
                      */
 int boot_emul_default;  /* 1= boot_image_emul is still default */
 off_t boot_image_load_size;
 int boot_img_size_default;  /* 1= boot_image_load_size is still default */
 int boot_img_full_size;  /* 1= override boot_image_load_size by image size */
 unsigned char boot_id_string[29];
 unsigned char boot_selection_crit[21];

 int boot_image_isohybrid; /* 0=off , deprecated: 1=auto , 2=on , 3=force */

 int boot_efi_default; /* 0= no effect ,
                          1= apply --efi-boot parameters when attaching to img
                        */

 char system_area_disk_path[SfileadrL];
 int system_area_clear_loaded;
 int system_area_options;             /* bit0= "GRUB protective msdos label"
                                               (a simple partition table)
                                         bit1= isohybrid boot image pointer
                                               and partition table
                                         bit2-7= System area type
                                               0= with bit0 or bit1: MBR
                                                  else: unspecified type 
                                               1= MIPS Big Endian Volume Header
                                               2= MIPS Little Endian Boot Block
                                               3= SUN Disk Label for SUN SPARC
                                               4= HP-PA PALO boot sector
                                                  header version 4
                                               5= HP-PA PALO boot sector
                                                  header version 5
                                         bit8-9= Only with System area type 0
                                               Cylinder alignment mode
                                               0 = auto (align if bit1)
                                               1 = always align
                                               2 = never align
                                               3 = align external partitions
                                         bit10-13= System area sub type
                                               With type 0 = MBR:
                                               Gets overridden by bit0 and bit1.
                                               0 = no particular sub type
                                               1 = CHRP: A single MBR partition
                                                   of type 0x96 covers the ISO
                                                   image. Not compatible with 
                                                   any other feature which
                                                   needs to have own MBR
                                                   partition entries.
                                               2 = generic MBR
                                         bit14= Only with System area type 0
                                               GRUB2 boot provisions:
                                               Patch system area at byte 92 to
                                               99 with 512-block address + 1
                                               of the first boot image file.
                                               Little-endian 8-byte.
                                               Should be combined with
                                               options bit0.
                                         bit15= Only with MBR:
                                               Enforce MBR "bootable/active"
                                               flag. In worst case by dummy
                                               partition of type 0x00 which
                                               occupies block 0.
                                       */
 int patch_system_area;               /* Bits as of system_area_options.
                                         to be applied to the loaded system
                                         area of the image, if no 
                                         system_area_disk_path and no
                                         system_area_options are set.
                                       */

 /* The number of unclaimed 2K blocks before start of partition 1 as of
    the MBR in system area.
    If not 0 this will cause double volume descriptor sets and double tree.
 */
 uint32_t partition_offset;
 /* Partition table parameter: 1 to 63, 0= disabled/default */
 int partition_secs_per_head;
 /* 1 to 255, 0= disabled/default */
 int partition_heads_per_cyl;

 /* Disk file paths of content of PreP partition and EFI system partition */
 char prep_partition[SfileadrL];
 char efi_boot_partition[SfileadrL];

 /* Path and type of image files to be appended as MBR partitions */
 char *appended_partitions[Xorriso_max_appended_partitionS];
 uint8_t appended_part_types[Xorriso_max_appended_partitionS];
 uint8_t appended_part_type_guids[Xorriso_max_appended_partitionS][16];
 /* Flags in case that appended partitions show up in GPT:
    bit0= appended_part_type_guids is valid
 */
 uint8_t appended_part_gpt_flags[Xorriso_max_appended_partitionS];
 /* If 1: With appended partitions: create protective MBR and mark by GPT */
 int appended_as_gpt;
 /* If 1: With appended partitions: mark by APM */
 int appended_as_apm;

 /* If 1: Apply isohybrid gestures to non-isohybrid situations */
 int part_like_isohybrid;

 /* MBR partition type of ISO filesystem partition or protective partition
    if not real GPT or CHRP.
 */
 int iso_mbr_part_type;
 uint8_t iso_gpt_type_guid[16];
 int iso_mbr_part_flag;
 /* Flags in case that the partition table is GPT:
    bit0= iso_gpt_type_guid is valid
 */

 /* See libisoburn.h isoburn_igopt_set_gpt_guid() */
 uint8_t gpt_guid[16];
 int gpt_guid_mode;

 /* Eventual name of the non-ISO aspect of the image. E.g. SUN ASCII label.
 */
 char ascii_disc_label[Xorriso_disc_label_sizE];

 /* A data file of which the position and size shall be written after
    a SUN Disk Label.
 */
 char grub2_sparc_core[SfileadrL];

 /* HFS+ image serial number.
    00...00 means that it shall be generated by libisofs.
 */
 uint8_t hfsp_serial_number[8];

 /* Allocation block size of HFS+  and APM : 0= auto , 512, or 2048
 */
 int hfsp_block_size;
 int apm_block_size;

 /* User settable PVD time stamps */
 time_t vol_creation_time;
 time_t vol_modification_time;
 time_t vol_expiration_time;
 time_t vol_effective_time;
 /* To eventually override vol_modification_time by unconverted string
    and timezone 0 */
 char vol_uuid[17];
 /* To flatly set all file timestamps to the same value
    Special value: "set_to_mtime", see -find action "set_to_mtime"
  */
 char all_file_dates[80];

 /* Timestamp for ISO files which have no origin file on disk and thus
    normally get time(NULL) as timestamps
 */
 int do_override_now_time;
 time_t now_time_override;

#ifdef Xorriso_with_libjtE
 /* Parameters and state of Jigdo Template Export environment */
 struct libjte_env *libjte_handle;
#endif

 /* List of -jigdo parameters since the most recent -jigdo clear */
 struct Xorriso_lsT *jigdo_params;
 struct Xorriso_lsT *jigdo_values;
 int libjte_params_given; /* bits: 0= outfile , 1= verbosity , 2= template_path
                                   3= jigdo_path , 4= checksum_path
                                   5= min_size , 6= checksum_iso
                                   7= checksum_template , 8= compression
                                   9= exclude , 10= demand_checksum
                                  11= mapping , 12= checksum_algorithm
                          */

 /* LBA of boot image after image loading */
 int loaded_boot_bin_lba;
 /* Path of the catalog node after image loading */
 char loaded_boot_cat_path[SfileadrL];

 /* XORRISO options */
 int allow_graft_points;   /* if not zero: yes
                              special options:
                              bit1= unescape '\\' too,
                                    continue unescaping after first real '='
                            */

 int allow_restore; /* -2=disallowed until special mode "unblock"
                       -1=permanently disallowed
                        0=disallowed, 1=allowed, 2=device files allowed */
 int do_concat_split;  /* 1= restore complete split file directories as
                             regular files
                        */
 int do_auto_chmod;    /* 1= eventually temporarily open access permissions
                             of self-owned directories during restore
                        */
 int do_restore_sort_lba; /* 1= restore via node_array rather than via
                                tree traversal. Better read performance,
                                no directory mtime restore, needs do_auto_chmod
                           */
 int do_strict_acl;       /* bit0= do not tolerate inappropriate presence or
                                   absence of directory "default" ACL
                          */

 int mount_opts_flag; /* bit0= "shared" = not "exclusive"
                               Try to emit non-exclusive mount command.
                               Do not give up drives.
                               Linux: use loop device even on block devices
                               in order to circumvent the ban to mount a
                               device twice (with different sbsector=)
                               FreeBSD: ?
                       */

 int dialog;  /* 0=off , 1=single-line , 2=multi-line */

 struct Xorriso_lsT *buffered_dialog; /* If not NULL : read by dialog */

 int bsl_interpretation;
                     /* whether to run input through Sfile_bsl_interpreter():
                        bit0-1= dialog and quoted file reading
                          0= no interpretation, leave unchanged
                          1= only inside double quotes
                          2= outside single quotes
                          3= everywhere
                        bit2-3= reserved as future expansion of bit0-1
                        bit4= interpretation within program start arguments
                        bit5= perform backslash encoding with results
                        bit6= perform backslash encoding with info texts
                     */

 int sh_style_result; /* Whether not to wrap into quotation marks the file
                         addresses reported by:
                           pwd pwdx ls lsd lsl lsdl lsx lsdx lslx lsdlx
                           du dus dux dusx findx find
                         and to make du* numbers left adjusted,
                         and not to append "/" to pwd* 
                       */

 /* Pattern matching facility. It still carries legacy from scdbackup/askme.c
    but is fully functional for xorriso.
 */
 int search_mode;
 /* 0= start text
    1= fgrep , 
    2= regular expression
    3= (eventually structured) shell parser expression
    4= shell parser expression for leaf name
 */

 int structured_search;
 /* 0= flat text search
    1= '/' is a significant separator that cannot be matched by wildcards
    ( 2= like 1 : but report only occurrence in tree, no payload, no location )
    ( 3= like 2 : but report first content level of matching directories )
    4= actually not structured but unique find mode (with search_mode 4)
 */

 int do_iso_rr_pattern; /* 0=off, 1=on, 2=ls */
 int do_disk_pattern;   /* 0=off, 1=on, 2=ls */

 int temp_mem_limit;

 off_t file_size_limit;
 int file_name_limit;

 struct ExclusionS *disk_exclusions;
 int disk_excl_mode; /* bit0= on (else off)
                        bit1= parameter too (else recursion only)
                        bit2= whole subtree banned (else only exact path)
                        bit3= when comparing ignore excluded files rather
                              than to treat them as truly missing on disk
                     */

 struct ExclusionS *iso_rr_hidings;
 struct ExclusionS *joliet_hidings;
 struct ExclusionS *hfsplus_hidings;

 int use_stdin; /* use raw stdin even if readline support is compiled */
 int tolerate_stdin_eof;  /* Do not abort on EOF in Xorriso_dialog_input
                             but rather return -2. */
 int result_page_length;
 int result_page_width;
 char mark_text[SfileadrL]; /* ( stdout+stderr, M: ) */
 int packet_output;
 char logfile[4][SfileadrL];
 FILE *logfile_fp[4];
 FILE *pktlog_fp;
 FILE *stderr_fp;
 struct Xorriso_lsT *result_msglists[Xorriso_max_outlist_stacK];
 struct Xorriso_lsT *info_msglists[Xorriso_max_outlist_stacK];
 int msglist_flags[Xorriso_max_outlist_stacK]; /* bit0= result is redirected
                                                  bit1= info is redirected
                                               */
 int msglist_stackfill;

 int lib_msg_queue_lock_ini;
 int result_msglists_lock_ini;
 pthread_mutex_t lib_msg_queue_lock;
 pthread_mutex_t result_msglists_lock;

 int write_to_channel_lock_ini;
 pthread_mutex_t write_to_channel_lock;

 int msg_watcher_lock_ini;
 pthread_mutex_t msg_watcher_lock;
 int msg_watcher_state; /* 0= inactive
                           1= registered
                           2= started
                           3= request to end
                        */
 int (*msgw_result_handler)(void *handle, char *text);
 void *msgw_result_handle;
 int (*msgw_info_handler)(void *handle, char *text);
 void *msgw_info_handle;
 int msgw_stack_handle;
 int msgw_msg_pending; /* 0=no, 1=fetching(i.e. maybe) , 2=yes */
 int msgw_fetch_lock_ini;
 pthread_mutex_t msgw_fetch_lock;

 struct Xorriso_msg_sievE *msg_sieve;
 int msg_sieve_disabled;

 int status_history_max; /* for -status long_history */
 
 /* 0= no logging of SCSI commands, 1= to stderr */
 int scsi_log;

 char report_about_text[20];
 int report_about_severity;
 int library_msg_direct_print;
 char abort_on_text[20];
 int abort_on_severity; /* A severity rank number as threshold */
 int abort_on_is_default; /* will be set to 0 by first -abort_on */
 int problem_status; /* Severity rank number. 0= no abort condition present */
 char problem_status_text[20];
 int problem_status_lock_ini;
 pthread_mutex_t problem_status_lock;

 char errfile_log[SfileadrL]; /* for -errfile_log */
 int errfile_mode; /* bit0= marked */
 FILE *errfile_fp;

 int img_read_error_mode; /* 0=best_effort , 1=failure , 2=fatal */
 int extract_error_mode; /* 0=best_effort , 1=keep , 2=delete */

 char return_with_text[20];
 int return_with_severity;
 int return_with_value;
 int eternal_problem_status;
 char eternal_problem_status_text[20];

 /* temporary search facilities */
 regex_t *re;
 regmatch_t match[1]; 
 char **re_constants;
 int re_count;
 int re_fill;
 char reg_expr[2*SfileadrL];

 /* run state */
 int run_state; /* 0=preparing , 1=writing image */
 int is_dialog;
 int bar_is_fresh;
 char pending_option[SfileadrL]; /* eventual option entered at page prompt */
 int request_to_abort; /* abort a single operation like -ls, not the program */
 int request_not_to_ask; /* suppress reassure and pager */
 double idle_time;
 int re_failed_at; /* mismatch position with structured_search */
 int prepended_wd;
 double insert_count;
 double insert_bytes;
 double error_count; /* double will not roll over */
 int launch_frontend_banned;

 /* pacifiers */
 int pacifier_style; /* 0= xorriso, 1=mkisofs 2=cdrecord */
 double pacifier_interval;
 double start_time;
 double last_update_time;
 /* optional global counters for brain reduced callback functions */
 off_t pacifier_count;
 off_t pacifier_total;
 off_t pacifier_byte_count; /* auxiliary counter for data bytes */
 off_t pacifier_prev_count; /* internal counter for speed measurement */

 void *pacifier_fifo;

 int find_compare_result; /* 1=everything matches , 0=mismatch , -1=error */ 
 int find_check_md5_result; /* bit0= seen mismatch
                               bit1= seen error
                               bit2= seen data file without MD5
                               bit3= seen match
                             */
 int find_unique_trunc_result; /* 0= some names are not uniquely truncatable
                                  1= all names are uniquely truncatable
                                  2= no names need truncation
                                */

 double last_abort_file_time; /* most recent check for aborting -check_md5 */

 /* Tree node collection and LBA sorting facility */
 int node_counter;
 int node_array_size;
 void **node_array;
 struct Xorriso_lsT *node_disk_prefixes;
 struct Xorriso_lsT *node_img_prefixes;

 /* Hardlink matching at restore time memorizes hardlink target paths.
    Array of nodes sorted by LBA. */
 int hln_count;
 void **hln_array;
 void **hln_targets;
 int hln_change_pending; /* whether a change was made since hln creation */

 /* >>> this should count all temp_mem and thus change its name */
 off_t node_targets_availmem;

 /* Hardlink matching at update time:
    Array of all nodes in the tree, sorted by disk dev,ino.
    Bitmap of nodes which possibly got new hardlink siblings.
    List of involved disk-iso path pairs. */
 int di_count;
 void **di_array;
 char *di_do_widen;
 struct Xorriso_lsT *di_disk_paths;
 struct Xorriso_lsT *di_iso_paths;

 struct PermiteM *perm_stack; /* Temporarily altered dir access permissions */

 /* bit0= update_merge active: mark all newly added nodes as visited+found
 */
 int update_flags;

 /* For find jobs show_hfs_cmd , show_hfs_as_mkisofs 
 */
 /* bit0= do not record but only count
    bit1= as_mkisofs mode
 */
 int show_hfs_cmd_flag;
 int show_hfs_cmd_count;
 char **show_hfs_cmds;

 /* Extraction to sparse files */
 off_t sparse_min_gap;

 /* result (stdout, R: ) */
 char result_line[10*SfileadrL];
 int result_line_counter;
 int result_page_counter;
 int result_open_line_len;


 /* info (stderr, I:) */
 char info_text[10*SfileadrL];

};


#include "base_obj.h"
#include "aux_objects.h"
#include "findjob.h"
#include "check_media.h"
#include "misc_funct.h"
#include "text_io.h"
#include "match.h"
#include "emulators.h"
#include "disk_ops.h"
#include "cmp_update.h"
#include "parse_exec.h"


#endif /* Xorriso_private_includeD */