"Fossies" - the Fresh Open Source Software Archive

Member "xorriso-1.5.4/xorriso/xorriso.h" (6 Feb 2021, 93598 Bytes) of package /linux/misc/xorriso-1.5.4.pl02.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "xorriso.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.5.4_vs_1.5.4.pl02.

    1 
    2 /* xorriso - libisoburn higher level API which creates, loads, manipulates
    3              and burns ISO 9660 filesystem images.
    4 
    5    Copyright 2007-2021 Thomas Schmitt, <scdbackup@gmx.net>
    6 
    7    Provided under GPL version 2 or later.
    8 
    9    This file contains the public API of xorriso which covers all of its
   10    operations.
   11 
   12    An example of its usage is xorriso_main.c which checks version compatibility,
   13    creates a xorriso object, initializes the libraries, and runs the command
   14    interpreters of the API to constitute the command line oriented batch and
   15    dialog tool xorriso.
   16 
   17    Alternatively to command interpreters it is possible to run all options of
   18    xorriso directly via the calls of the "Command API". 
   19    The "Problem Status and Message API" shall then be used to obtain the
   20    text output of the options.
   21 
   22    Mandatory calls are:
   23      Xorriso_new(), Xorriso_startup_libraries(), Xorriso_destroy()
   24 
   25    This architecture is fully public since version 0.5.8. From then on, new
   26    features get marked by
   27      @since major.minor.micro
   28    The option calls may have older "since" marks which then tell when the
   29    corresponding command was introduced in the command interpreter.
   30 
   31    Please note that struct XorrisO and its API calls are _not_ thread-safe in
   32    general. It is not permissible to run two API calls on the same
   33    XorrisO object concurrently.
   34    The only exception is
   35      Xorriso_fetch_outlists()
   36    in order to learn about the ongoing text output of other API calls.
   37 
   38 
   39    There is a lower level of API which consists of libisofs.h, libburn.h and
   40    libisoburn.h. One should not mix those calls with the ones of xorriso.h .
   41 */
   42 
   43 /* Important: If you add a public API function then add its name to file
   44                   libisoburn/libisoburn.ver
   45 */
   46 
   47 
   48 #ifndef Xorriso_includeD
   49 #define Xorriso_includeD yes
   50 
   51 #ifdef __cplusplus
   52 extern "C" {
   53 #endif
   54 
   55 
   56 /** Opaque handle of the xorriso runtime context */
   57 struct XorrisO; 
   58 
   59 
   60 
   61 /* Create GNU xorriso
   62    under GPLv3+ derived from above GPLv2+.
   63 */
   64 #define Xorriso_GNU_xorrisO yes
   65 
   66 
   67 /* --------------------- Fundamental Management ------------------- */
   68 
   69 
   70 /** These three release version numbers tell the revision of this header file
   71     and of the API which it describes. They shall be memorized by applications
   72     at build time.
   73     @since 0.5.8
   74 */
   75 #define Xorriso_header_version_majoR  1
   76 #define Xorriso_header_version_minoR  5
   77 #define Xorriso_header_version_micrO  4
   78 
   79 
   80 /** If needed: Something like ".pl01" to indicate a bug fix. Normally empty.
   81     @since 0.5.8
   82 */
   83 #define Xorriso_program_patch_leveL ".pl02"
   84 
   85 
   86 /** Obtain the three release version numbers of the library. These are the
   87     numbers encountered by the application when linking with libisoburn,
   88     i.e. possibly not before run time.
   89     Better do not base the fundamental compatibility decision of an application
   90     on these numbers. For a reliable check use Xorriso__is_compatible().
   91     @since 0.5.8
   92     @param major The maturity version (0 for now, as we are still learning)
   93     @param minor The development goal version.
   94     @param micro The development step version. This has an additional meaning:
   95 
   96                  Pare numbers indicate a version with frozen API. I.e. you can
   97                  rely on the same set of features to be present in all
   98                  published releases with that major.minor.micro combination.
   99                  Features of a pare release will stay available and ABI
  100                  compatible as long as the SONAME of libisoburn stays "1".
  101                  Currently there are no plans to ever change the SONAME.
  102                   
  103                  Odd numbers indicate that API upgrades are in progress.
  104                  I.e. new features might be already present or they might
  105                  be still missing. Newly introduced features may be changed
  106                  incompatibly or even be revoked before release of a pare
  107                  version.
  108                  So micro revisions {1,3,5,7,9} should never be used for
  109                  dynamic linking unless the proper library match can be
  110                  guaranteed by external circumstances.
  111 
  112     @return 1 success, <=0 might in future become an error indication
  113 */
  114 void Xorriso__version(int *major, int *minor, int *micro);
  115 
  116 
  117 /** Check whether all features of header file xorriso.h from the given
  118     major.minor.micro revision triple can be delivered by the library version
  119     which is performing this call.
  120         if (! Xorriso__is_compatible(Xorriso_header_version_majoR,
  121                                      Xorriso_header_version_minoR,
  122                                      Xorriso_header_version_micrO, 0))
  123            ...refuse to start the program with this dynamic library version...
  124     @since 0.5.8
  125     @param major obtained at build time
  126     @param minor obtained at build time
  127     @param micro obtained at build time
  128     @param flag Bitfield for control purposes. Unused yet. Submit 0.
  129     @return 1= library can work for caller
  130             0= library is not usable in some aspects. Caller must restrict
  131                itself to an earlier API version or must not use this library
  132                at all.
  133 */
  134 int Xorriso__is_compatible(int major, int minor, int micro, int flag);
  135 
  136 
  137 /* Get the patch level text (e.g. "" or ".pl01") of the program code.
  138    @param flag     unused yet, submit 0
  139    @return         readonly character string
  140 */
  141 char *Xorriso__get_patch_level_text(int flag);
  142 
  143 
  144 /* Choose how Xorriso_startup_libraries() and the XorrisO object shall
  145    prepare for eventual signals.
  146    @param behavior Default is behavior 1.
  147                    0= no own signal handling. The main application has to do
  148                       that. Do not start burn runs without any handling !
  149                    1= use libburn signal handler. Most time with action
  150                       0. During writing, formatting, blanking: 0x30.
  151                       Only usable with a single xorriso object.
  152                    2= Enable system default reaction on all signals
  153                       @since 1.0.9
  154                    3= Try to ignore nearly all signals
  155                       @since 1.0.9
  156    @param flag     unused yet, submit 0
  157    @return         <= 0 is error, >0 is success
  158 */
  159 int Xorriso__preset_signal_behavior(int behavior, int flag);
  160 
  161 
  162 /* Mandatory call:
  163    Create a new xorriso object and tell it the program name to be used
  164    with messages and for decision of special behavior.
  165    @param xorriso  returns the newly created XorrisO object 
  166    @param progname typically argv[0] of main(). Some leafnames of the progname
  167                    path have special meaning and trigger special behavior:
  168                     "osirrox"    allows image-to-disk copying: -osirrox "on" 
  169                     "xorrisofs"  activates -as "mkisofs" emulation from start
  170                     "genisofs"   alias of "xorrisofs"
  171                     "mkisofs"    alias of "xorrisofs"
  172                     "genisoimage"  alias of "xorrisofs"
  173                     "xorrecord"  activates -as "cdrecord" emulation from start
  174                     "cdrecord"   alias of "xorrecord"
  175                     "wodim"      alias of "xorrecord"
  176                     "cdrskin"    alias of "xorrecord"
  177    @param flag     unused yet, submit 0
  178    @return         >0 success , <=0 failure, no object created
  179 */
  180 int Xorriso_new(struct XorrisO ** xorriso, char *progname, int flag);
  181 
  182 
  183 /* Note: Between Xorriso_new() and the next call Xorriso_startup_libraries()
  184          there may be called the special command interpreter
  185          Xorriso_prescan_args().
  186          The other command interpreters may be used only after
  187          Xorriso_startup_libraries(). The same restriction applies to the
  188          calls of the Command API further below.
  189 */
  190 
  191 
  192 /* Mandatory call:
  193    It has to be made before calling any function listed below this point.
  194    Only exception is the special command interpreter Xorriso_prescan_args().
  195 
  196    Make global library initializations.
  197    This must be done with the first xorriso object that gets created and
  198    with the first xorriso object that gets created after Xorriso_destroy(,1).
  199    @param xorriso The context object.
  200    @param flag    unused yet, submit 0
  201    @return        <=0 error , >0 success
  202 */ 
  203 int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
  204 
  205 
  206 /* Note: After library startup, you may run Command Interpreters or call
  207          functions from the Command API.
  208 
  209          Wenn all desired activities are done, you may check whether there are
  210          uncommitted changes pending, compute an exit value, destroy the
  211          XorrisO object, and exit your program.
  212 */
  213 
  214 
  215 /* Inquire whether option -commit would make sense.
  216    @param xorriso The context object to inquire.
  217    @param flag    @since 0.6.6
  218                   bit0= do not return 1 if -as mkisofs -print-size was
  219                         performed on the current image.
  220    @return        0= -commit would have nothing to do
  221                   1= a new image session would emerge at -commit
  222 */
  223 int Xorriso_change_is_pending(struct XorrisO *xorriso, int flag);
  224 
  225 
  226 /* Compute the exit value from the recorded maximum event severity.
  227    @param xorriso The context object to inquire.
  228    @param flag    unused yet, submit 0
  229    @return        The computed exit value
  230 */
  231 int Xorriso_make_return_value(struct XorrisO *xorriso, int flag);
  232 
  233 
  234 /* Mandatory call:
  235    Destroy xorriso object when it is no longer needed.
  236    @param xorriso  The context object to destroy. *xorriso will become NULL.
  237    @param flag     bit0= Perform global library shutdown.
  238                          Use only with last xorriso object to be destroyed.
  239    @return         <=0 error, >0 success
  240 */
  241 int Xorriso_destroy(struct XorrisO **xorriso, int flag);
  242 
  243 
  244 /* --------------------- Command Interpreters ------------------- */
  245 
  246 
  247 /* This special interpreter may be called between Xorriso_new() and
  248    Xorriso_startup_libraries(). It interprets certain commands which shall
  249    get into effect before the libraries get initialized:
  250      -abort_on , -report_about , -return_with ,
  251      -scsi_log , -signal_handling
  252    This is the only occasion where command -x has an effect:
  253      -x
  254    Some commands get executed only if they are the only command in argv:
  255      -prog_help , -help
  256    The following is recognized only if it is the first of all arguments:
  257      -no_rc
  258    Some get examined for the need to redirect stdout messages:
  259      -dev , -outdev , -indev , -as 
  260    Commands
  261      -backslash_codes , -list_delimiter , -add_plainly
  262    get into effect during this call. But their setting at begin of the call
  263    gets restored before the call returns.
  264    @param xorriso The context object in which to perform the commands.
  265    @param argc    Number of arguments.
  266    @param argv    The arguments. argv[0] contains the program name.
  267                   argv[1] to argv[argc-1] contain commands and parameters.
  268    @param idx     Argument cursor. When this function is called, *idx must
  269                   be at least 1, argv[*idx] must be a command.
  270                   *idx will iterate over commands and parameters until this
  271                   function aborts or until argc is reached.
  272    @param flag    bit0= do not interpret argv[1]
  273                   bit1= produce FAILURE events on unknown commands
  274                         @since 1.1.0
  275    @return        <0 error
  276                    0 end program
  277                    1 ok, go on 
  278 */
  279 int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv,
  280                          int flag);
  281 
  282 
  283 /* Read and interpret commands from eventual startup files as listed in
  284    man xorriso.
  285    @param xorriso The context object in which to perform the commands.
  286    @param flag    unused yet, submit 0
  287    @return <=0 = error
  288              1 = success
  289              3 = end program run (e.g. because command -end was encountered)
  290 */
  291 int Xorriso_read_rc(struct XorrisO *xorriso, int flag);
  292 
  293 
  294 /* Check whether program arguments shall be backslash decoded. If so, then
  295    replace *argv by a new argument vector. The old one will not be freed
  296    by this call. If it is dynamic memory then you need to keep a copy of
  297    the pointer and free it yourself after this call.
  298 
  299    @since 1.3.2:
  300    This call internally interprets the commands -backslash_codes and
  301    -list_delimiter if it encounters them among the arguments. The
  302    decoding of backslashes can thus be enabled and disabled by the
  303    arguments themselves. The state of the xorriso object in respect
  304    to these commands gets preserved at the start of the call and restored
  305    when the call ends.
  306    (*argv)[0] never gets decoded.
  307    The old *argv will always be replaced by a new one.
  308 
  309    @param xorriso The context object
  310    @param argc    Number of arguments.
  311    @param argv    The arguments. (*argv)[0] contains the program name.
  312                   (*argv)[1] to (*argv)[argc-1] contain commands and parameters
  313                   If argv after the call differs from argv before the call,
  314                   then one should dispose it later by:
  315                     Xorriso__dispose_words(argc, argv);
  316    @param flag    unused yet, submit 0
  317    @return        <= 0 error , > 0 success
  318 */
  319 int Xorriso_program_arg_bsl(struct XorrisO *xorriso, int argc, char ***argv,
  320                             int flag);
  321 
  322 
  323 /* Interpret argv as xorriso command options and their parameters.
  324    (An alternative is to call functions of the options API directly and to
  325     perform own error status evaluation. See below: Command API.) 
  326    After the first command and its parameters there may be more commands and
  327    parameters. All parameters must be given in the same call as their command.
  328    @since 1.2.2:
  329    Commands may get arranged in a sequence that is most likely to make sense.
  330    E.g. image loading settings before drive aquiration, then commands for
  331    adding files, then settings for writing, then writing.
  332    This feature may be enabled by command "-x" in Xorriso_prescan_args()
  333    or by parameter flag of this call.
  334    @param xorriso The context object in which to perform the commands.
  335    @param argc    Number of arguments.
  336    @param argv    The arguments. argv[0] contains the program name.
  337                   argv[1] to argv[argc-1] contain commands and parameters.
  338    @param idx     Argument cursor. When this function is called, *idx must
  339                   be at least 1, argv[*idx] must be a command.
  340                   *idx will iterate over commands and parameters until this
  341                   function aborts, or until argc is reached, or only once if
  342                   flag bit2 is set.
  343    @param flag    bit0= reserved. Indicates recursion. Submit 0. 
  344                   bit1= Indicates that these are the main() program start
  345                         arguments. This enables their use with emulations
  346                         which where set with Xorriso_new(), or argument
  347                         arranging.
  348                   bit2= Only execute the one command argv[*idx] and advance
  349                         *idx to the next command if successful. Then return.
  350                         This prevents any argument arranging.
  351                         @since 1.2.2
  352                   bit3= With bit1 and not bit2:
  353                         Enable argument arranging as with
  354                         Xorriso_prescan_args() and command "-x".
  355                         @since 1.2.2
  356                   bit4= With bit1:
  357                         Surely disable argument arranging.
  358                         @since 1.2.2
  359    @return <=0 = error
  360              1 = success
  361              2 = problem event ignored
  362              3 = end program run (e.g. because command -end was encountered)
  363 */
  364 int Xorriso_interpreter(struct XorrisO *xorriso,
  365                         int argc, char **argv, int *idx, int flag);
  366 
  367 
  368 /* Parse a command line into words and use them as argv for a call of
  369    Xorriso_interpreter(). Put out some info lines about the outcome.
  370    @param xorriso The context object in which to perform the commands.
  371    @param line    A text of one or more words according to man xorriso
  372                   paragraph "Command processing" up to and including
  373                   "Backslash Interpretation".
  374    @param flag    bit0 to bit15 are forwarded to Xorriso_interpreter()
  375                   bit16= no pageing of info lines
  376                   bit17= print === bar even if xorriso->found<0
  377    @return        see return of Xorriso_interpreter()
  378 */
  379 int Xorriso_execute_option(struct XorrisO *xorriso, char *line, int flag);
  380 
  381 
  382 /* Parse a text line into words. This parsing obeys the same rules as
  383    command line parsing but allows to skip a prefix, to use a user provided
  384    set of separator characters, and to restrict the number of parsed words.
  385 
  386    If parameter xorriso is NULL, then this call is safe for usage by
  387    a concurrent thread while a xorriso API call is being executed.
  388 
  389    @since 1.2.6
  390    @param xorriso     The context object which provides settings for parsing
  391                       and output channels for error messages.
  392                       May be NULL in order to allow concurrent execution e.g.
  393                       by a callback function of Xorriso_start_msg_watcher().
  394                       If xorriso is NULL then:
  395                         flag bit1-bit4 are in effect even if bit0 is not set.
  396                         flag bit5 and bit6 may not be set.
  397    @param line        A text of one or more words according to man xorriso
  398                       paragraph "Command processing" up to and including
  399                       "Backslash Interpretation".
  400    @param prefix      If not empty then the line will only be parsed if it
  401                       begins by the prefix text. Parsing will then begin after
  402                       the end of the prefix.
  403                       If the prefix does not match, then 0 will be returned
  404                       in *argc, argv will be NULL, and the return value will
  405                       be 2.
  406    @param separators  If not empty this overrides the default list of word
  407                       separating characters. Default set is the one of
  408                       isspace(3).
  409    @param max_words   If not 0: Maximum number of words to parse. If there
  410                       remains line text after the last parsed word and its
  411                       following separators, then this remainder is copied
  412                       unparsed into a final result word. In this case *argc
  413                       will be larger than max_words by one. Note that trailing
  414                       separators are considered to be followed by an empty
  415                       word.
  416    @param argc        Will return the number of allocated and filled word
  417                       strings.
  418    @param argv        Will return the array of word strings.
  419                       Do not forget to dispose the allocated memory by a
  420                       call to Xorriso__dispose_words().
  421    @param flag        Bitfield for control purposes
  422                       bit0=   Override setting of -backslash_codes.
  423                       bit1-4= With bit0: backslash behavior
  424                               0= off
  425                               1= in_double_quotes
  426                               2= in_quotes
  427                               3= with_quoted_input
  428                       bit5=   Prepend the program name as (*argv)[0], so that
  429                               *argv is suitable for Xorriso_interpreter()
  430                               and other calls which expect this.
  431                               Not allowed if xorriso is NULL.
  432                       bit6=   Issue failure message in case of return 0
  433                               Not allowed if xorriso is NULL.
  434    @return            <=0 means error and invalidity of *argv:
  435                               0 = Input format error. E.g. bad quotation mark.
  436                              -1 = Lack of resources. E.g. memory.
  437                              -2 = Improper combination of call parameters.
  438                       >0 means success but not necessarily a valid result:
  439                               1 = Result in argc and argv is valid (but may
  440                                   be empty by argc == 0, argv == NULL).
  441                               2 = Line did not match prefix. Result is invalid
  442                                   and empty.
  443 */
  444 int Xorriso_parse_line(struct XorrisO *xorriso, char *line,
  445                        char *prefix, char *separators, int max_words,
  446                        int *argc, char ***argv, int flag);
  447 
  448 
  449 /* Dispose a list of strings as allocated by Xorriso_parse_line() or
  450    Xorriso_program_arg_bsl(), or Xorriso_sieve_get_result().
  451    @since 1.2.6
  452    @param argc        A pointer to the number of allocated and filled word
  453                       strings. *argc will be set to 0 by this call.
  454    @param argv        A pointer to the array of word strings.
  455                       *argv will be set to NULL by this call.
  456 */
  457 void Xorriso__dispose_words(int *argc, char ***argv);
  458 
  459 
  460 /* Enter xorriso command line dialog mode, using libreadline if configured
  461    at build time and not disabled at run time.
  462    This call returns immediately if not option -dialog "on" was performed
  463    before.
  464    @param xorriso The context object in which to perform the commands.
  465    @param flag    unused yet, submit 0
  466    @return        <=0 error, 1= dialog mode ended normally ,
  467                   3= dialog mode ended normally,interpreter asks to end program
  468 */
  469 /* @since 0.1.0 */
  470 int Xorriso_dialog(struct XorrisO *xorriso, int flag);
  471 
  472 
  473 /* --------------------- Problem Status and Message API ------------------- */
  474 
  475 
  476 /** Submit a problem message to the xorriso problem reporting and handling
  477     system. This will eventually increase problem status rank, which may
  478     at certain stages in the program be pardoned and reset to 0.
  479     The pardon is governed by Xorriso_option_abort_on() and by the anger
  480     of the affected program part. If no pardon has been given, then the problem
  481     status reaches the caller of option functions.
  482     Problem status should be inquired by Xorriso_eval_problem_status() and be
  483     reset before next option execution by Xorriso_set_problem_status().
  484     The problem status itself does not cause the failure of option functions.
  485     But in case of failures for other reasons, a remnant overly severe problem
  486     status can cause overly harsh program reactions.
  487     @param xorriso    The environment handle
  488     @param error_code The unique error code of your message.
  489                       Submit 0 if you do not have reserved error codes within
  490                       the libburnia project.
  491     @param msg_text   Not more than 8196 characters of message text.
  492                       A final newline character gets appended automatically.
  493     @param os_errno   Eventual errno related to the message. Submit 0 if
  494                       the message is not related to a operating system error.
  495     @param severity   One of "ABORT", "FATAL", "FAILURE", "MISHAP", "SORRY",
  496                       "WARNING", "HINT", "NOTE", "UPDATE", "DEBUG".
  497                       Defaults to "FATAL".
  498     @param flag       Bitfield for control purposes
  499                         bit0= use pager (as with result)
  500                         bit1= permission to suppress output
  501     @return           1 if message was delivered, <=0 if failure
  502 */
  503 int Xorriso_msgs_submit(struct XorrisO *xorriso,
  504                         int error_code, char msg_text[], int os_errno,
  505                         char severity[], int flag);
  506 
  507 /** Alternative call interface of Xorriso_msgs_submit with void* instead
  508     of struct XorrisO*
  509 */
  510 int Xorriso_msgs_submit_void(void *xorriso,
  511                         int error_code, char msg_text[], int os_errno,
  512                         char severity[], int flag);
  513 
  514 
  515 /** Evaluate an advise whether to abort or whether to go on with option
  516     processing. This should be called after any option function was processed.
  517     It updates the problem status by processing the library message queues
  518     and then it uses this status and the submitted return value of the
  519     option function to evaluate the situation.
  520     @param xorriso    The environment handle
  521     @param ret        The return value of the previously called option function
  522     @param flag       bit0= do not issue own event messages
  523                       bit1= take xorriso->request_to_abort as reason for abort
  524     @return           Gives the advice:
  525                         2= pardon was given, go on
  526                         1= no problem, go on
  527                         0= function failed but xorriso would not abort, go on
  528                        <0= do abort
  529                            -1 = due to xorriso->problem_status
  530                                 or due to ret<0
  531                            -2 = due to xorriso->request_to_abort
  532 */
  533 int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag);
  534 
  535 
  536 /** Set the current problem status of the xorriso handle.
  537     @param xorriso    The environment handle
  538     @param severity   A severity text. Empty text resets to "No Problem". 
  539     @param flag       Unused yet. Submit 0.
  540     @return           <=0 failure (e.g. wrong severity text), 1 success.
  541 */
  542 int Xorriso_set_problem_status(struct XorrisO *xorriso, char *severity,
  543                                int flag);
  544 
  545 
  546 /* The next three functions are part of Xorriso_eval_problem_status().
  547    You may use them to build an own advisor function.
  548 */
  549 
  550 /** Compare two severity texts for their severeness.
  551     Unknown severity texts get defaulted to "FATAL".
  552     @since 1.2.6
  553     @param sev1  First severity text to compare
  554     @param sev2  Second severity text to compare
  555     @return      -1 sev1 is less severe than sev2
  556                   0 sev1 is equally severe to sev2
  557                   1 sev1 is more severe than sev2
  558 */
  559 int Xorriso__severity_cmp(char *sev1, char *sev2);
  560 
  561 
  562 /** Return a blank separated list of severity names. Sorted from low
  563     to high severity.
  564     @since 1.2.6
  565     @param flag Bitfield for control purposes (unused yet, submit 0)
  566     @return  A constant string with the severity names
  567 */
  568 char *Xorriso__severity_list(int flag);
  569 
  570 
  571 
  572 /** Obtain the current problem status of the xorriso handle.
  573     @param xorriso    The environment handle
  574     @param severity   The severity text matching the current problem status
  575     @param flag       Unused yet. Submit 0.
  576     @return           The severity rank number. 0= no problem occurred.
  577 */
  578 int Xorriso_get_problem_status(struct XorrisO *xorriso, char severity[80],
  579                                int flag);
  580 
  581 
  582 /** Forward any pending messages from the library message queues to the
  583     xorriso message system which puts out on info channel. This registers
  584     the severity of the library events like the severity of a message submitted
  585     via Xorriso_msgs_submit().
  586     xorriso sets the message queues of the libraries to queuing "ALL".
  587     Many inner functions of xorriso call Xorriso_process_msg_queues() on their
  588     own because they expect library output pending. Nevertheless, a loop of
  589     xorriso option calls should either call Xorriso_eval_problem_status() or
  590     Xorriso_process_msg_queues() with each cycle.
  591     @param xorriso    The environment handle
  592     @param flag       Unused yet. Submit 0.
  593     @return           1 on success, <=0 if failure
  594 */
  595 int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag);
  596 
  597 
  598 /** Write a message for option -errfile_log. 
  599     @param xorriso    The environment handle
  600     @param error_code The unique error code of your message.
  601                       Submit 0 if you do not have reserved error codes within
  602                       the libburnia project.
  603     @param msg_text   Not more than 8196 characters of message text.
  604     @param os_errno   Eventual errno related to the message. Submit 0 if
  605                       the message is not related to a operating system error.
  606     @param flag       bit0-7= meaning of msg_text
  607                       ( 0= ERRFILE path , for internal use mainly )
  608                         1= mark line text (only to be put out if enabled)
  609     @return <=0 error , >0 success
  610 */
  611 int Xorriso_process_errfile(struct XorrisO *xorriso,
  612                             int error_code, char msg_text[], int os_errno,
  613                             int flag);
  614 
  615 
  616 /*
  617                            Message output evaluation
  618 
  619    xorriso is basically a dialog software which reacts on commands by
  620    side effects and by messages. The side effects manipulate the state of
  621    the ISO image model and of drives. This state can be inquired by commands
  622    which emit messages.
  623 
  624    There are several approaches how a program that uses xorriso via this API
  625    can receive and use the message output of xorriso.
  626 
  627    - The message sieve may be programmed to pick certain information snippets
  628      out of the visible message stream. This covers all messages on the
  629      result channel and those info channel messages which get not suppressed
  630      by command -report_about. All important info messages have severity NOTE
  631      or higher.
  632      Much of the message interpretation is supposed to happen by the sieve
  633      filter rules which describe the interesting message lines and the
  634      positions of the interesting message parts.
  635      The call Xorriso_sieve_big() installs a sieve that looks out for most
  636      model state messages which xorriso can emit. After a few commands
  637      the user will ask the sieve for certain text pieces that might have been
  638      caught.
  639 
  640    - The outlist stack may be used to catch messages in linked lists rather
  641      than putting them out on the message channels.
  642      All interpretation of the messages has to be done by the user of the
  643      xorriso API. Function Xorriso_parse_line() is intended to help with
  644      splitting up messages into words.
  645      The outlist stack is handy for catching the results of information
  646      commands with large uniform output or no well recognizable message
  647      prefix. Like -lsl, -getfacl, -status, -find ... -exec get_md5.
  648      One should push the stack before the command, pull it afterwards, examine
  649      the text list by Xorriso_lst_get_*(), and finally dispose the list.
  650 
  651    - The message watcher is a separate program thread which uses the outlist
  652      stack to catch the messages and to call user provided handler functions.
  653      These functions can use Xorriso_parse_line() too, if they submit the
  654      xorriso parameter as NULL. They may not use the struct XorrisO object
  655      in any way.
  656      Synchronization between watcher and emitters of commands can be achieved
  657      by Xorriso_peek_outlists().
  658      The main motivation for the message watcher is to inspect and display
  659      messages of long lasting xorriso commands while they are still executing.
  660      E.g. of -commit, -blank, -format.
  661      One would normally start it before such a command and stop it afterwards.
  662      But of course, the watcher can stay activated all the time and process
  663      all message output via its handler calls.
  664 
  665    The message sieve does not interfere with outlists and message watcher.
  666    The message watcher will only see messages which are not caught by outlists
  667    which were enabled after the watcher thread was started.
  668      
  669 */
  670 
  671 /* The programmable message sieve picks words out of the program messages
  672    of xorriso.
  673    The sieve is a collection of filter rules. Each one is defined by a call of
  674    Xorriso_sieve_add_filter(). The sieve watches the given output channels for
  675    messages which begin by the given text prefixes of the filters.
  676    Matching lines get split into words by Xorriso_parse_line() using
  677    the given separators. The words described by the filter's word index array
  678    get recorded by the filter and can be inquired by Xorriso_sieve_get_result()
  679    after one or more xorriso commands have been performed.
  680    The recorded results may be disposed by Xorriso_sieve_clear_results without
  681    giving up the sieve.
  682    The whole sieve may be disposed by Xorriso_sieve_dispose().
  683    Default at library start is an inactive sieve without any filter rules.
  684 */
  685 
  686 /** Add a filter rule to the message sieve.
  687     Start watching output messages, if this is not already enabled.
  688     @since 1.2.6
  689     @param xorriso    The environment handle
  690     @param name       The filter name by which its recorded results shall
  691                       be inquired via Xorriso_sieve_get_result()
  692     @param channels   Which of the output channels the filter shall watch
  693                       bit0= result channel
  694                       bit1= info channel
  695                       bit2= mark channel
  696     @param prefix     The line start to watch for. Will also be handed over
  697                       to Xorriso_parse_line(). Empty text matches all lines. 
  698                       If the prefix begins by '?' characters, then these
  699                       match any character at the beginning of a message.
  700                       The prefix of the filter rule will then be adapted
  701                       to really match the line, before it gets handed over
  702                       to Xorriso_parse_line().
  703     @param separators List of separator characters for Xorriso_parse_line()
  704     @param num_words  Number of word indice in word_idx
  705     @param word_idx   Array with the argv indice to be picked from the
  706                       the result of Xorriso_parse_line(). Must at least
  707                       contain num_words elements.
  708     @param max_results If not 0, then the maximum number of line results that
  709                       shall be recorded by the filter. When this number is
  710                       exceeded, then results of older lines get discarded
  711                       when new results get recorded.
  712     @param flag       Bitfield for control purposes
  713                       bit0= Last result word shall contain the remainder of
  714                             the message line
  715     @return           <=0 error , >0 success
  716 */
  717 int Xorriso_sieve_add_filter(struct XorrisO *xorriso, char *name,
  718                              int channels, char *prefix, char *separators,
  719                              int num_words, int *word_idx, int max_results,
  720                              int flag);
  721 
  722 
  723 /** Inquire recorded results from a particular filter rule.
  724     @param xorriso    The environment handle
  725     @param name       The filter name as given by Xorriso_sieve_add_filter()
  726     @param argc       Will return the number of allocated and filled word
  727                       strings.
  728     @param argv       Will return the array of word strings.
  729                       Do not forget to dispose the allocated memory by a
  730                       call to Xorriso__dispose_words().
  731     @param available  Will return the number of results which are still
  732                       available for further calls of Xorriso_sieve_get_result()
  733                       with the given name.
  734     @param flag       Bitfield for control purposes:
  735                       bit0= Reset reading to first matching result.
  736                       bit1= Only inquire number of available results.
  737                             Do not allocate memory.
  738                       bit2= If *argv is not NULL, then free it before attaching
  739                             new memory.
  740                       bit3= Do not read recorded data but rather list all
  741                             filter names.
  742     @return           <0 error: -1 = memory shortage
  743                                 -2 = no filter rule found
  744                        0 No more data available for the given name
  745                          With bit3: No filter rules installed.
  746                       >0 argc and argv are valid
  747 */
  748 int Xorriso_sieve_get_result(struct XorrisO *xorriso, char *name,
  749                              int *argc, char ***argv, int *available,
  750                              int flag);
  751 
  752 
  753 /** Dispose all recorded results. Keep filter rules. Continue watching
  754     and recording.
  755     @since 1.2.6
  756     @param xorriso    The environment handle
  757     @param flag       Unused yet. Submit 0.
  758     @return           <=0 error , >0 success
  759 */
  760 int Xorriso_sieve_clear_results(struct XorrisO *xorriso, int flag);
  761 
  762 
  763 /** Dispose all filter rules. End watching and recording.
  764     This is the default state at library startup.
  765     @since 1.2.6
  766     @param xorriso    The environment handle
  767     @param flag       Unused yet. Submit 0.
  768     @return           <=0 error , >0 success
  769 */
  770 int Xorriso_sieve_dispose(struct XorrisO *xorriso, int flag);
  771 
  772 
  773 /** Install a large sieve with filters for about any interesting message
  774     of xorriso. The filter rule names are mostly the same as the prefixes they
  775     search for. If you do not find the message prefix of your desire, then
  776     you may add a filter rule by Xorriso_sieve_add_filter().
  777     If you do not want all these filter any more, call Xorriso_sieve_dispose().
  778 
  779     You should obtain your recorded data often and then call
  780     Xorriso_sieve_clear_results(). It is nevertheless ok to perform several
  781     different xorriso information commands and to then obtain results from the
  782     sieve.
  783 
  784     The installed filters in particular:
  785     Name             Recorded values, returned by Xorriso_sieve_get_result()
  786     ------------------------------------------------------------------------
  787     "-changes_pending" up to 1 result from -changes_pending show_status
  788                      argv[0]= "yes" or "no"
  789     "?  -dev"        up to 10 results from -devices or -device_links
  790                      (records drives with single digit index number)
  791                      argv[0]= drive address
  792                      argv[1]= permissions
  793                      argv[2]= drive vendor
  794                      argv[3]= product id
  795     "??  -dev"       up to 90 results from -devices or -device_links
  796                      (records drives with double digit index number)
  797                      argv[0]= drive address
  798                      argv[1]= permissions
  799                      argv[2]= drive vendor
  800                      argv[3]= product id
  801     "Abstract File:" up to 1 result from -pvd_info
  802                      argv[0]= file name
  803                      (Note: prefix is "Abstract File: ")
  804     "After commit :" up to 1 result from -tell_media_space
  805                      argv[0]= number of blocks with "s" appended
  806     "App Id       :" up to 1 result from -pvd_info
  807                      argv[0]= id
  808                      (Note: prefix is "App Id       : ")
  809     "Biblio File  :" up to 1 result from -pvd_info
  810                      argv[0]= file name
  811                      (Note: prefix is "Biblio File  : ")
  812     "Build timestamp   :" up to 1 result from -version
  813                      argv[0]= timestamp
  814                      (Note: prefix is "Build timestamp   :  ")
  815     "CopyrightFile:" up to 1 result from -pvd_info
  816                      argv[0]= file name
  817                      (Note: prefix is "CopyrightFile: ")
  818     "Creation Time:" up to 1 result from -pvd_info
  819                      argv[0]= YYYYMMDDhhmmsscc
  820                      (Note: prefix is "Creation Time: ")
  821     "DVD obs 64 kB:" up to 1 result from -list_extras
  822                      argv[0]= "yes" or "no"
  823     "Drive access: " up to 2 result from -dev, -indev, -toc
  824                      argv[0]= "exclusive", "shared"
  825                      argv[1]= "readonly","restricted"
  826     "Drive current:" up to 2 results from -dev, -indev, -toc, others
  827                      argv[0]= command ("-dev", "-outdev", "-indev")
  828                      argv[1]= drive address
  829     "Drive type   :" up to 2 results from -toc
  830                      argv[0]= vendor
  831                      argv[1]= product
  832                      argv[2]= revision
  833     "Eff. Time    :" up to 1 result from -pvd_info
  834                      argv[0]= YYYYMMDDhhmmsscc
  835                      (Note: prefix is "EffectiveTime: ")
  836     "Expir. Time  :" up to 1 result from -pvd_info
  837                      argv[0]= YYYYMMDDhhmmsscc
  838                      (Note: prefix is "Expir. Time  : ")
  839     "Ext. filters :" up to 1 result from -list_extras
  840                      argv[0]= "yes" or "no" , possibly more info
  841                      (Note: prefix is "Ext. filters : ")
  842     "File damaged :" up to 10000 results from -find ... -exec report_damage
  843                      argv[0]= damage start byte in file
  844                      argv[1]= damage range size in file
  845                      argv[2]= file size
  846                      argv[3]= path in ISO image
  847     "File data lba:" up to 10000 results from -find ... -exec report_lba
  848                      argv[0]= extent number (all extents of same path together
  849                               are the content of one file)
  850                      argv[1]= start block number of extent
  851                      argv[2]= number of blocks of extent
  852                      argv[3]= overall file content size in all extents
  853                      argv[4]= path in ISO image
  854     "Format idx   :" up to 100 results from -list_formats
  855                      argv[0]= index
  856                      argv[1]= MMC code
  857                      argv[2]= number of blocks with "s" appended
  858                      argv[3]= roughly the size in MiB
  859                      (Note: prefix is "Format idx ")
  860     "Format status:" up to 1 result from -list_formats
  861                      argv[0]= status
  862                      argv[1]= capacity
  863     "ISO session  :" up to 10000 results from -toc
  864                      argv[0]= Idx
  865                      argv[1]= sbsector
  866                      argv[2]= Size
  867                      argv[3]= Volume Id
  868     "Image size   :" up to 1 result from -print_size
  869                      argv[0]= number of blocks with "s" appended
  870     "Jigdo files  :" up to 1 result from -list_extras
  871                      argv[0]= "yes" or "no"
  872     "Local ACL    :" up to 1 result from -list_extras
  873                      argv[0]= "yes" or "no"
  874     "Local xattr  :" up to 1 result from -list_extras
  875                      argv[0]= "yes" or "no"
  876     "MD5 MISMATCH:"  up to 10000 results from -check_md5*
  877                      argv[0]= path of mismatching file
  878     "MD5 tag range:" up to 10000 results from -check_media
  879                      argv[0]= lba
  880                      argv[1]= size in blocks
  881                      argv[2]= result text (starting with "+", "-", or "0")
  882     "Media blocks :" up to 2 results from -toc
  883                      argv[0]= readable
  884                      argv[1]= writable
  885                      argv[2]= overall
  886     "Media current:" up to 2 results from -dev, -indev, -toc, others
  887                      argv[0]= media type / MMC profile name
  888                      (Note: prefix is "Media current: " which eats extra blank)
  889     "Media nwa    :" up to 1 result from -toc
  890                      argv[0]= next writable address
  891     "Media product:" up to 2 results from -toc
  892                      argv[0]= product id
  893                      argv[1]= manufacturer
  894     "Media region :" up to 10000 results from -check_media
  895                      argv[0]= lba
  896                      argv[1]= size in blocks
  897                      argv[2]= quality text (starting with "+", "-", or "0")
  898     "Media space  :" up to 1 result from -tell_media_space
  899                      argv[0]= number of blocks with "s" appended
  900     "Media status :" up to 2 results from -dev, -indev, -toc, others
  901                      argv[0]= status description
  902                      (Note: prefix is "Media status : ")
  903     "Media summary:" up to 2 results from -dev, -indev, -toc, others 
  904                      argv[0]= sessions
  905                      argv[1]= data blocks (full count)
  906                      argv[2]= data (with unit letter k,m,g)
  907                      argv[3]= free (with unit letter k,m,g)
  908     "Modif. Time  :" up to 1 result from -pvd_info
  909                      argv[0]= YYYYMMDDhhmmsscc
  910                      (Note: prefix is "Modif. Time  : ")
  911     "PVD address  :" up to 1 result from -pvd_info
  912                      argv[0]= block address with "s" appended
  913     "Preparer Id  :" up to 1 result from -pvd_info
  914                      argv[0]= id
  915                      (Note: prefix is "Preparer Id  : ")
  916     "Profile      :" up to 256 results from -list_profiles
  917                      argv[0]= MMC code
  918                      argv[1]= profile name in round brackets
  919                               possibly appended: " (current)"
  920     "Publisher Id :" up to 1 result from -pvd_info
  921                      argv[0]= id
  922                      (Note: prefix is "Publisher Id : ")
  923     "Readline     :" up to 1 result from -list_extras
  924                      argv[0]= "yes" or "no"
  925     "Size lower   :" up to 1 result from -findx ... -exec estimate_size
  926                      argv[0]= size with appended "s"
  927     "Size upper   :" up to 1 result from -findx ... -exec estimate_size
  928                      argv[0]= size with appended "s"
  929     "System Id    :" up to 1 result from -pvd_info
  930                      argv[0]= id
  931                      (Note: prefix is "System Id    : ")
  932     "Version timestamp :" up to 1 result from -version
  933                      argv[0]= timestamp
  934     "Volume Id    :" up to 1 result from -pvd_info
  935                      argv[0]= id
  936                      (Note: Not output from -dev or -toc but from -pvd_info)
  937     "Volume Set Id:" up to 1 result from -pvd_info
  938                      argv[0]= id
  939                      (Note: prefix is "Volume Set Id: ")
  940     "Volume id    :" up to 2 results from -dev, -indev, -toc, others
  941                      argv[0]= volume id
  942                      (Note: Not output from -pvd_info but from -dev or -toc)
  943     "Write speed  :" up to 100 results from -list_speeds
  944                      argv[0]= kilobytes per second
  945                      argv[1]= speed factor
  946     "Write speed H:" up to 1 result from -list_speeds
  947                      see "Write speed  :" 
  948     "Write speed L:" up to 1 result from -list_speeds
  949                      see "Write speed  :" 
  950     "Write speed h:" up to 1 result from -list_speeds
  951                      see "Write speed  :" 
  952     "Write speed l:" up to 1 result from -list_speeds
  953                      see "Write speed  :" 
  954     "libburn    in use :" up to 1 result from -version
  955                      argv[0]= version text
  956                      argv[1]= minimum version requirement
  957     "libburn OS adapter:" up to 1 result from -version
  958                      argv[0]= adapter description
  959                      (Note: prefix is "libburn OS adapter:  ")
  960     "libisoburn in use :" up to 1 result from -version
  961                      argv[0]= version text
  962                      argv[1]= minimum version requirement
  963     "libisofs   in use :" up to 1 result from -version
  964                      argv[0]= version text
  965                      argv[1]= minimum version requirement
  966     "libjte     in use :" up to 1 result from -version
  967                      argv[0]= version text
  968                      argv[1]= minimum version requirement
  969     "xorriso version   :" up to 1 result from -version
  970                      argv[0]= version text
  971     "zisofs       :" up to 1 result from -list_extras
  972                      argv[0]= "yes" or "no"
  973     ------------------------------------------------------------------------
  974 
  975     @since 1.2.6
  976     @param xorriso    The environment handle
  977     @param flag       Unused yet. Submit 0.
  978     @return           <=0 error , >0 success
  979 */
  980 int Xorriso_sieve_big(struct XorrisO *xorriso, int flag);
  981 
  982 
  983 /* The outlist stack allows to redirect the info and result messages from
  984    their normal channels into a pair of string lists which can at some
  985    later time be retrieved by the application.
  986    These redirection caches can be stacked to allow stacked applications.
  987    xorriso itself uses them for internal purposes. 
  988 
  989    The call Xorriso_start_msg_watcher() starts a concurrent thread which
  990    uses outlists to collect messages and to hand them over by calling
  991    application provided functions.
  992 */
  993 
  994 /* A list item able of forming double chained lists */
  995 struct Xorriso_lsT;
  996 
  997 /** Maximum number of stacked redirections */
  998 #define Xorriso_max_outlist_stacK 32
  999 
 1000 /** Enable a new redirection of info and/or result channel. The normal message
 1001     output and eventual older redirections will not see new messages until
 1002     the redirection is ended by a call to Xorriso_pull_outlists() with the
 1003     stack_handle value returned by this call.
 1004     If Xorriso_option_pkt_output() is set to "on", then it will consolidate
 1005     output in the result_list of Xorriso_fetch_outlists() and
 1006     Xorriso_pull_outlists().
 1007     @param xorriso      The environment handle
 1008     @param stack_handle returns an id number which is unique as long as
 1009                         its redirection is stacked. Do not interpret it and
 1010                         do not use it after its redirection was pulled from
 1011                         the stack.
 1012     @param flag         Bitfield for control purposes
 1013                          bit0= redirect result channel
 1014                          bit1= redirect info channel
 1015                         If bit0 and bit1 are 0, both channels get redirected.
 1016     @return           1 on success, <=0 if failure
 1017 */
 1018 int Xorriso_push_outlists(struct XorrisO *xorriso, int *stack_handle,
 1019                           int flag);
 1020 
 1021 
 1022 /** Obtain the currently collected text messages of redirected info and
 1023     result channel. 
 1024     The messages are handed out as two lists. Both lists have to be disposed
 1025     via Xorriso_lst_destroy_all() when they are no longer needed.
 1026     The message lists are either NULL or represented by their first
 1027     Xorriso_lsT item.
 1028 
 1029     This call is safe for being used by a concurrent thread while a
 1030     xorriso API call is being executed on the same struct XorrisO.
 1031     In such a situation, it should not be used with high frequency in order
 1032     not to hamper the ongoing xorriso operation by blocking its message
 1033     output facility. A hundred times per second should be enough.
 1034 
 1035     @since 1.2.6
 1036     @param xorriso       The environment handle
 1037     @param stack_handle  An id number returned by Xorriso_push_outlists()
 1038                          and not yet revoked by Xorriso_pull_outlists().
 1039                          Submit -1 to address the most recent valid id.
 1040     @param result_list   Result and mark messages (usually directed to stdout)
 1041     @param info_list     Info and mark messages (usually directed to stderr)
 1042     @param flag          Bitfield for control purposes
 1043                           bit0= fetch result channel
 1044                           bit1= fetch info channel
 1045                          If bit0 and bit1 are 0, both channels get fetched.
 1046     @return              1 on success, <=0 if failure
 1047 */
 1048 int Xorriso_fetch_outlists(struct XorrisO *xorriso, int stack_handle,
 1049                            struct Xorriso_lsT **result_list,
 1050                            struct Xorriso_lsT **info_list, int flag);
 1051 
 1052 
 1053 /** Inquire whether messages are pending in redirected result and info channel.
 1054     This may be used to determine whether a concurrent message watcher already
 1055     has obtained all pending messages.
 1056     @since 1.2.6
 1057     @param xorriso       The environment handle
 1058     @param stack_handle  An id number returned by Xorriso_push_outlists()
 1059                          and not yet revoked by Xorriso_pull_outlists().
 1060                          Submit -1 to address the most recent valid id.
 1061     @param timeout       Number of seconds after which to return despite
 1062                          flag bit 2
 1063     @param flag          Bitfield for control purposes
 1064                           bit0= fetch result channel
 1065                           bit1= fetch info channel
 1066                           bit2= wait and retry until return is 0 or -1
 1067                          If bit0 and bit1 are 0, both channels get fetched.
 1068     @return              If > 0:
 1069                            bit0= messages are pending in outlists
 1070                            bit1= message watcher is processing fetched messages
 1071                          Else:
 1072                           0= no messages are pending anywhere
 1073                          -1= inappropriate stack_handle
 1074                          -2= locking failed
 1075 */
 1076 int Xorriso_peek_outlists(struct XorrisO *xorriso, int stack_handle,
 1077                           int timeout, int flag);
 1078 
 1079 
 1080 /** Disable the redirection given by stack_handle. If it was the current
 1081     receiver of messages then switch output to the next older redirection,
 1082     or to the normal channels if no redirections are stacked any more.
 1083     The messages collected by the disabled redirection are handed out as
 1084     two lists. Both lists have to be disposed via Xorriso_lst_destroy_all() 
 1085     when they are no longer needed.
 1086     The message lists are either NULL or represented by their first
 1087     Xorriso_lsT item.
 1088     @param xorriso       The environment handle
 1089     @param stack_handle  An id number returned by Xorriso_push_outlists()
 1090                          and not yet revoked by Xorriso_pull_outlists().
 1091                          This handle is invalid after the call.
 1092                          Submit -1 to address the most recent valid id.
 1093     @param result_list   Result and mark messages (usually directed to stdout)
 1094     @param info_list     Info and mark messages (usually directed to stderr)
 1095     @param flag          unused yet, submit 0
 1096     @return              1 on success, <=0 if failure
 1097 */
 1098 int Xorriso_pull_outlists(struct XorrisO *xorriso, int stack_handle,
 1099                           struct Xorriso_lsT **result_list,
 1100                           struct Xorriso_lsT **info_list, int flag);
 1101 
 1102 
 1103 /** Redirect output by Xorriso_push_outlists() and start a thread which
 1104     fetches this output and performs a call of a given function with each
 1105     message that is obtained.
 1106     @since 1.2.6
 1107     @param xorriso        The environment handle
 1108     @param result_handler Pointer to the function which shall be called with
 1109                           each result message. A NULL pointer causes output
 1110                           to be directed to stdout or to be interpreted
 1111                           as -pkt_output format if this is enabled by
 1112                           Xorriso_option_pkt_output().
 1113                           The function should return 1. A return value of -1
 1114                           urges not to call again with further lines.
 1115     @param result_handle  The first argument of (*result_handler)(). It shall
 1116                           point to a memory object that knows all necessary
 1117                           external parameters for running (*result_handler)().
 1118                           Submit NULL if result_handler is NULL.
 1119     @param info_handler   Pointer to the function which shall be called with
 1120                           each info message. A NULL pointer causes output to
 1121                           be directed to stderr or to -as mkisofs -log-file.
 1122                           The function should return 1. A return value of -1
 1123                           urges not to call again with further lines.
 1124     @param info_handle    The first argument of (*info_handler)(). It shall
 1125                           point to a memory object that knows all necessary
 1126                           external parameters for running (*info_handler)().
 1127                           Submit NULL if info_handler is NULL.
 1128     @param flag           unused yet, submit 0
 1129     @return               1 on success, <=0 if failure (e.g. there is already
 1130                                                         a watcher active)
 1131 */
 1132 int Xorriso_start_msg_watcher(struct XorrisO *xorriso,
 1133                     int (*result_handler)(void *handle, char *text),
 1134                     void *result_handle,
 1135                     int (*info_handler)(void *handle, char *text),
 1136                     void *info_handle,
 1137                     int flag);
 1138 
 1139 
 1140 /** Revoke output redirection by Xorriso_start_msg_watcher() and end the
 1141     watcher thread. If text messages are delivered when Xorriso_pull_outlists()
 1142     is called, then they get put out through the active handler functions.
 1143     @since 1.2.6
 1144     @param xorriso        The environment handle
 1145     @param flag           Bitfield for control purposes:
 1146                           bit0= do not issue SORRY message if no message
 1147                                 watcher is active
 1148     @return               1 on success, <=0 if failure
 1149 */
 1150 int Xorriso_stop_msg_watcher(struct XorrisO *xorriso, int flag);
 1151 
 1152 
 1153 /** Obtain the text message from the current list item.
 1154     @param entry    The current list item
 1155     @param flag     unused yet, submit 0
 1156     @return         Pointer to the text content of the list item.
 1157                     This pointer does not have to be freed.
 1158 */
 1159 char *Xorriso_lst_get_text(struct Xorriso_lsT *entry, int flag);
 1160 
 1161 
 1162 /** Obtain the address of the next item in the chain of messages.
 1163     An iteration over the output of Xorriso_pull_outlists() starts at the
 1164     returned result_list or info_list and ends when this function returns
 1165     NULL.
 1166     @param entry    The current list item
 1167     @param flag     unused yet, submit 0
 1168     @return         Pointer to the next list item or NULL if end of list.
 1169                     This pointer does not have to be freed.
 1170 */
 1171 struct Xorriso_lsT *Xorriso_lst_get_next(struct Xorriso_lsT *entry, int flag);
 1172 
 1173 
 1174 /** Obtain the address of the previous item in the chain of messages.
 1175     @param entry    The current list item
 1176     @param flag     unused yet, submit 0
 1177     @return         Pointer to the previous list item or NULL if start of list.
 1178                     This pointer does not have to be freed.
 1179 */
 1180 struct Xorriso_lsT *Xorriso_lst_get_prev(struct Xorriso_lsT *entry, int flag);
 1181 
 1182 
 1183 /** Destroy all list items which are directly or indirectly connected to
 1184     the given link item.
 1185     All pointers obtained by Xorriso_lst_get_text() become invalid by this.
 1186     Apply this to each of the two list handles obtained by 
 1187     Xorriso_pull_outlists() when the lists are no longer needed.
 1188     @param lstring  *lstring will be freed and set to NULL.
 1189                     It is not dangerous to submit a pointer to a NULL-pointer.
 1190     @param flag     unused yet, submit 0
 1191     @return         -1= lstring was NULL (i.e. wrong use of this call),
 1192                      0= *lstring was already NULL,
 1193                      1= item actually disposed
 1194 */
 1195 int Xorriso_lst_destroy_all(struct Xorriso_lsT **lstring, int flag);
 1196 
 1197 
 1198 
 1199 /* ---------------------------- Command API ------------------------ */
 1200 /*    See man 1 xorriso for explanation of the particular commands   */
 1201 /*
 1202    Before each call to a command function, there should happen:
 1203    Xorriso_set_problem_status() with empty severity text.
 1204 
 1205    After each call to a command function, there should happen:
 1206    Xorriso_eval_problem_status()
 1207    One should follow its eventual advice to abort.
 1208 
 1209    Commands with a varying number of arguments get then passed like
 1210    Xorriso_interpreter(). E.g.:
 1211      int Xorriso_option_add(struct XorrisO *xorriso, int argc, char **argv,
 1212                             int *idx, int flag);
 1213    The command functions will begin to read the arguments at position *idx
 1214    and will see the list end either at the next argv which contains the
 1215    -list_delimiter text or at argv[argc-1].
 1216    After the call, *idx will be the index of the first not yet interpreted
 1217    argv.
 1218 
 1219    Do not set any flag bits which are not described by "@param flag".
 1220    I.e. if flag is not mentioned, then submit 0.
 1221    Yet undefined flag bits might get a meaning in future. Unset bits will
 1222    then produce the traditional behavior, whereas set bits might bring
 1223    surprises to inadverted callers.
 1224 
 1225    The API is available
 1226      @since 0.5.8
 1227    Earlier "since" marks refer to availability in the command interpreter.
 1228 */
 1229 
 1230 
 1231 /* Command -abort_on */
 1232 /* @since 0.1.0 */
 1233 int Xorriso_option_abort_on(struct XorrisO *xorriso, char *severity, int flag);
 1234 
 1235 /* Command -abstract_file */
 1236 /* @since 0.6.0 */
 1237 int Xorriso_option_abstract_file(struct XorrisO *xorriso, char *name,
 1238                                  int flag);
 1239 
 1240 /* Command -acl "on"|"off" */
 1241 /* @since 0.3.4 */
 1242 int Xorriso_option_acl(struct XorrisO *xorriso, char *mode, int flag);
 1243 
 1244 /* Command -add */
 1245 /* @param flag bit0=do not report the added item
 1246                bit1=do not reset pacifier, no final pacifier message
 1247 */
 1248 /* @since 0.1.0 */
 1249 int Xorriso_option_add(struct XorrisO *xorriso, int argc, char **argv,
 1250                        int *idx, int flag);
 1251 
 1252 /* Command -add_plainly "on"|"off" */
 1253 /* @since 0.1.0 */
 1254 int Xorriso_option_add_plainly(struct XorrisO *xorriso, char *mode,
 1255                                    int flag);
 1256 
 1257 /* Command -alter_date, -alter_date_r */
 1258 /* @param flag bit0=recursive (-alter_date_r)
 1259 */
 1260 /* @since 0.1.0 */
 1261 int Xorriso_option_alter_date(struct XorrisO *xorriso, 
 1262                               char *time_type, char *timestring,
 1263                               int argc, char **argv, int *idx, int flag);
 1264 
 1265 /* Command -append_partition */
 1266 /* @since 0.6.4 */
 1267 int Xorriso_option_append_partition(struct XorrisO *xorriso, char *partno_text,
 1268                                   char *type_text, char *image_path, int flag);
 1269 
 1270 /* Command -application_id */
 1271 /* @since 0.3.0 */
 1272 int Xorriso_option_application_id(struct XorrisO *xorriso, char *name, 
 1273                                   int flag);
 1274 
 1275 /* Command -application_use */
 1276 /* @since 1.3.2 */
 1277 int Xorriso_option_application_use(struct XorrisO *xorriso, char *path,
 1278                                    int flag);
 1279 
 1280 /* Command -as */
 1281 /* @param flag bit0=do not report the added item
 1282                bit1=do not reset pacifier, no final pacifier message
 1283 */  
 1284 /* @since 0.1.2 */
 1285 int Xorriso_option_as(struct XorrisO *xorriso, int argc, char **argv,
 1286                       int *idx, int flag);
 1287 
 1288 /* Command -assert_volid */
 1289 /* @since 0.3.2 */
 1290 int Xorriso_option_assert_volid(struct XorrisO *xorriso, char *pattern,
 1291                                 char *severity, int flag);
 1292 
 1293 /* Command -auto_charset "on"|"off" */
 1294 /* @since 0.3.8 */
 1295 int Xorriso_option_auto_charset(struct XorrisO *xorriso, char *mode, int flag);
 1296 
 1297 /* Command -backslash_codes */
 1298 /* @since 0.3.0 */
 1299 int Xorriso_option_backslash_codes(struct XorrisO *xorriso, char *mode,
 1300                                    int flag);
 1301 
 1302 /* Command -ban_stdio_write */
 1303 /* @since 0.1.0 */
 1304 int Xorriso_option_ban_stdio_write(struct XorrisO *xorriso, int flag);
 1305 
 1306 /* Command -biblio_file */
 1307 /* @since 0.6.0 */
 1308 int Xorriso_option_biblio_file(struct XorrisO *xorriso, char *name, int flag);
 1309 
 1310 /* Command -blank and -format */
 1311 /* @param flag bit0= format rather than blank
 1312    @return <=0 error , 1 success, 2 revoked by -reassure
 1313 */
 1314 /* @since 0.1.0 */
 1315 int Xorriso_option_blank(struct XorrisO *xorriso, char *mode, int flag);
 1316 
 1317 /* Command -boot_image */
 1318 /* @since 0.1.0 */
 1319 int Xorriso_option_boot_image(struct XorrisO *xorriso, char *form,
 1320                               char *treatment, int flag);
 1321 
 1322 /* Command -calm_drive */
 1323 /* @since 0.4.2 */
 1324 int Xorriso_option_calm_drive(struct XorrisO *xorriso, char *which, int flag);
 1325 
 1326 /* Command -cd alias -cdi */
 1327 /* @since 0.1.0 */
 1328 int Xorriso_option_cdi(struct XorrisO *xorriso, char *iso_rr_path, int flag);
 1329 
 1330 /* Command -cdx */
 1331 /* @since 0.1.0 */
 1332 int Xorriso_option_cdx(struct XorrisO *xorriso, char *disk_path, int flag);
 1333 
 1334 /* Command -changes_pending */
 1335 /* @since 1.2.2 */
 1336 int Xorriso_option_changes_pending(struct XorrisO *xorriso, char *state,
 1337                                    int flag);
 1338 
 1339 /* Commands -charset, -in_charset, -out_charset, -local_charset */
 1340 /* @param flag bit0= set in_charset
 1341                bit1= set out_charset
 1342                bit2= set local_charset
 1343 */
 1344 /* @since 0.3.0 */
 1345 int Xorriso_option_charset(struct XorrisO *xorriso, char *name, int flag);
 1346 
 1347 /* Command -check_md5 and -check_md5_r
 1348    @param flag bit0= issue summary message
 1349                bit1= do not reset pacifier, no final pacifier message
 1350                bit2= do not issue pacifier messages at all
 1351                bit3= recursive: -check_md5_r
 1352 */
 1353 /* @since 0.4.2 */
 1354 int Xorriso_option_check_md5(struct XorrisO *xorriso,
 1355                              int argc, char **argv, int *idx, int flag);
 1356 
 1357 /* Command -check_media */
 1358 /* @since 0.2.4 */
 1359 int Xorriso_option_check_media(struct XorrisO *xorriso,
 1360                                int argc, char **argv, int *idx, int flag);
 1361 
 1362 /* Command -check_media_defaults */
 1363 /* @since 0.2.6 */
 1364 int Xorriso_option_check_media_defaults(struct XorrisO *xorriso,
 1365                                     int argc, char **argv, int *idx, int flag);
 1366 
 1367 /* Command -chgrp alias -chgrpi , chgrp_r alias chgrp_ri */
 1368 /* @param flag bit0=recursive (-chgrp_r)
 1369 */
 1370 /* @since 0.1.0 */
 1371 int Xorriso_option_chgrpi(struct XorrisO *xorriso, char *gid,
 1372                           int argc, char **argv, int *idx, int flag);
 1373 
 1374 /* Command -chmod alias -chmodi , -chmod_r alias chmod_ri */
 1375 /* @param flag bit0=recursive (-chmod_r)
 1376 */
 1377 /* @since 0.1.0 */
 1378 int Xorriso_option_chmodi(struct XorrisO *xorriso, char *mode,
 1379                           int argc, char **argv, int *idx, int flag);
 1380 
 1381 /* Command -chown alias -chowni , chown_r alias chown_ri */
 1382 /* @param flag bit0=recursive (-chown_r)
 1383 */
 1384 /* @since 0.1.0 */
 1385 int Xorriso_option_chowni(struct XorrisO *xorriso, char *uid,
 1386                           int argc, char **argv, int *idx, int flag);
 1387 
 1388 /* Command -clone */
 1389 /* @since 1.0.2 */
 1390 int Xorriso_option_clone(struct XorrisO *xorriso, char *origin, char *dest,
 1391                          int flag);
 1392 
 1393 /* Command -close "on"|"off"| @since 1.3.4 "as_needed" */
 1394 /* @since 0.1.0 */
 1395 int Xorriso_option_close(struct XorrisO *xorriso, char *mode, int flag);
 1396 
 1397 /* Command -close_damaged */
 1398 /* @since 1.1.0 */
 1399 int Xorriso_option_close_damaged(struct XorrisO *xorriso, char *mode,
 1400                                  int flag);
 1401 
 1402 /* Command -close_filter_list */
 1403 /* @since 0.3.8 */
 1404 int Xorriso_option_close_filter_list(struct XorrisO *xorriso, int flag);
 1405 
 1406 /* Command -commit */
 1407 /* @param flag bit0= leave indrive and outdrive acquired as they were,
 1408                      i.e. do not acquire outdrive as new in-out-drive
 1409                bit1= do not perform eventual -reassure
 1410    @return <=0 error , 1 success, 2 revoked by -reassure
 1411 */
 1412 /* @since 0.1.0 */
 1413 int Xorriso_option_commit(struct XorrisO *xorriso, int flag);
 1414 
 1415 /* Command -commit_eject  */
 1416 /* @return <=0 error , 1 success, 2 revoked by -reassure
 1417 */
 1418 /* @since 0.1.0 */
 1419 int Xorriso_option_commit_eject(struct XorrisO *xorriso, char *which, int flag);
 1420 
 1421 /* Command -compare and -compare_r
 1422    @param flag bit0= issue summary message
 1423                bit1= do not reset pacifier, no final pacifier message
 1424                bit2= do not issue pacifier messages at all
 1425                bit3= recursive: -compare_r
 1426 */
 1427 /* @since 0.1.2 */
 1428 int Xorriso_option_compare(struct XorrisO *xorriso, char *disk_path,
 1429                            char *iso_path, int flag);
 1430 
 1431 /* Command -compliance */
 1432 /* @since 0.3.0 */
 1433 int Xorriso_option_compliance(struct XorrisO *xorriso, char *mode, int flag);
 1434 
 1435 /* Command -concat */
 1436 /* @since 1.3.8 */
 1437 int Xorriso_option_concat(struct XorrisO *xorriso,
 1438                           int argc, char **argv, int *idx, int flag);
 1439 
 1440 /* Command -copyright_file */
 1441 /* @since 0.6.0 */
 1442 int Xorriso_option_copyright_file(struct XorrisO *xorriso, char *name,
 1443                                   int flag);
 1444 
 1445 /* Command -cp_clone */
 1446 /* @since 1.0.2 */
 1447 int Xorriso_option_cp_clone(struct XorrisO *xorriso, int argc, char **argv,
 1448                             int *idx, int flag);
 1449 
 1450 /* Command -cpr alias -cpri */
 1451 /* @since 0.1.0 */
 1452 int Xorriso_option_cpri( struct XorrisO *xorriso, int argc, char **argv,
 1453                          int *idx, int flag);
 1454 
 1455 /* Command -cpx , -cpax, -cp_rx , -cp_rax */
 1456 /* @param flag bit0= recursive (-cp_rx, -cp_rax)
 1457                      @since 0.2.0
 1458                bit1= full property restore (-cpax, -cp_rax)
 1459                      @since 0.2.0
 1460 */
 1461 /* @since 0.1.8 */
 1462 int Xorriso_option_cpx(struct XorrisO *xorriso, int argc, char **argv,
 1463                          int *idx, int flag);
 1464 
 1465 /* Command -cut_out */
 1466 /* @since 0.1.2 */
 1467 int Xorriso_option_cut_out(struct XorrisO *xorriso, char *disk_path,
 1468                 char *start, char *count, char *iso_rr_path, int flag);
 1469 
 1470 /* Command -dev , -indev, -outdev */
 1471 /* @param flag bit0=use as indev , bit1= use as outdev
 1472    @return <=0 error , 1 success, 2 revoked by -reassure
 1473 */
 1474 /* @since 0.1.0 */
 1475 int Xorriso_option_dev(struct XorrisO *xorriso, char *adr, int flag);
 1476 
 1477 /* Command -data_cache_size */
 1478 /* @since 1.2.2 */
 1479 int Xorriso_option_data_cache_size(struct XorrisO *xorriso, char *num_tiles,
 1480                                    char *tile_blocks, int flag);
 1481 
 1482 /* Command -devices */
 1483 /* @param flag bit0= perform -device_links rather than -devices
 1484                      @since 1.1.4
 1485    @return <=0 error , 1 success, 2 revoked by -reassure
 1486 */
 1487 /* @since 0.1.0 */
 1488 int Xorriso_option_devices(struct XorrisO *xorriso, int flag);
 1489 
 1490 /* Command -dialog "on"|"off" */
 1491 /* @since 0.2.8 */
 1492 /* (since 0.1.0 there was -dialog and -dialog_reset without arg) */
 1493 int Xorriso_option_dialog(struct XorrisO *xorriso, char *mode, int flag);
 1494 
 1495 /* Command -disk_dev_ino "on"|"off" */
 1496 /* @since 0.3.4 */
 1497 int Xorriso_option_disk_dev_ino(struct XorrisO *xorriso, char *mode, int flag);
 1498 
 1499 /* Command -disk_pattern "on"|"ls"|"off" */
 1500 /* @since 0.1.0 */
 1501 int Xorriso_option_disk_pattern(struct XorrisO *xorriso, char *mode, int flag);
 1502 
 1503 /* Command -displacement [-]offset */
 1504 /* @since 0.6.6 */
 1505 int Xorriso_option_displacement(struct XorrisO *xorriso, char *value,
 1506                                 int flag);
 1507 
 1508 /* Command -drive_access "exclusive"|"shared":"readonly"|"unrestricted" */
 1509 /* @since 1.5.2 */
 1510 int Xorriso_option_drive_access(struct XorrisO *xorriso, char *mode, int flag);
 1511 
 1512 /* Command -drive_class */
 1513 /* @since 0.3.2 */
 1514 int Xorriso_option_drive_class(struct XorrisO *xorriso,
 1515                                char *d_class, char *pattern, int flag);
 1516 
 1517 /* Command -dummy "on"|"off" */
 1518 /* @since 0.1.0 */
 1519 int Xorriso_option_dummy(struct XorrisO *xorriso, char *mode, int flag);
 1520 
 1521 /* Command -dvd_obs "default"|"32k"|"64k" */
 1522 /* @since 0.4.8 */
 1523 int Xorriso_option_dvd_obs(struct XorrisO *xorriso, char *obs, int flag);
 1524 
 1525 /* Command -early_stdio_test */
 1526 /* @since 1.0.6 */
 1527 int Xorriso_option_early_stdio_test(struct XorrisO *xorriso, char *mode,
 1528                                     int flag);
 1529 
 1530 /* Command -ecma119_map */
 1531 /* @since 1.4.2 */
 1532 int Xorriso_option_ecma119_map(struct XorrisO *xorriso, char *mode, int flag);
 1533 
 1534 /* Command -eject */
 1535 /* @param flag bit0=do not report toc of eventually remaining drives
 1536 */
 1537 /* @since 0.1.0 */
 1538 int Xorriso_option_eject(struct XorrisO *xorriso, char *which, int flag);
 1539 
 1540 /* Command -end , and -rollback_end */
 1541 /* @param flag bit0= discard pending changes 
 1542    @return <=0 error , 1 success, 2 revoked by -reassure
 1543 */
 1544 /* @since 0.1.0 */
 1545 int Xorriso_option_end(struct XorrisO *xorriso, int flag);
 1546 
 1547 /* Command -errfile_log marked|plain  path|-|"" */
 1548 /* @since 0.1.2 */
 1549 int Xorriso_option_errfile_log(struct XorrisO *xorriso,
 1550                                char *mode, char *path, int flag);
 1551 
 1552 /* Command -error_behavior */
 1553 /* @since 0.1.6 */
 1554 int Xorriso_option_error_behavior(struct XorrisO *xorriso, 
 1555                                   char *occasion, char *behavior, int flag);
 1556 
 1557 /* Command -external_filter */
 1558 /* @since 0.3.8 */
 1559 int Xorriso_option_external_filter(struct XorrisO *xorriso,
 1560                                    int argc, char **argv, int *idx, int flag);
 1561 
 1562 /* Command -extract , -extract_single */
 1563 /* @param flag bit0=do not report the restored item
 1564                bit1=do not reset pacifier, no final pacifier message
 1565                bit5= -extract_single: do not insert directory tree
 1566 */
 1567 /* @since 0.2.0 */
 1568 int Xorriso_option_extract(struct XorrisO *xorriso, char *disk_path,
 1569                        char *iso_path, int flag);
 1570 
 1571 /* Command -extract_boot_images */
 1572 /* @sice 1.5.4 */
 1573 int Xorriso_option_extract_boot_images(struct XorrisO *xorriso,
 1574                                        char *disk_dir_path, int flag);
 1575 
 1576 /* Command -extract_cut */
 1577 /* @since 0.2.6 */
 1578 int Xorriso_option_extract_cut(struct XorrisO *xorriso, char *iso_rr_path,
 1579                           char *start, char *count, char *disk_path, int flag);
 1580 
 1581 /* Command -file_name_limit */
 1582 /* @since 1.4.2 */
 1583 int Xorriso_option_file_name_limit(struct XorrisO *xorriso, char *value,
 1584                                    int flag);
 1585 
 1586 /* Command -file_size_limit */
 1587 /* @since 0.2.6 */
 1588 int Xorriso_option_file_size_limit(struct XorrisO *xorriso,
 1589                                    int argc, char **argv, int *idx, int flag);
 1590 
 1591 
 1592 /* Command -find alias -findi, and -findx */
 1593 /* @param flag bit0= -findx rather than -findi
 1594                bit1= do not reset pacifier, no final pacifier message
 1595                      do not reset find_compare_result
 1596 */ 
 1597 /* @since 0.1.0 */
 1598 int Xorriso_option_find(struct XorrisO *xorriso, int argc, char **argv,
 1599                        int *idx, int flag);
 1600 
 1601 /* Command -follow */
 1602 /* @since 0.1.0 */
 1603 int Xorriso_option_follow(struct XorrisO *xorriso, char *mode, int flag);
 1604 
 1605 /* Command -for_backup is a shortcut for
 1606      Xorriso_option_hardlinks(xorriso, "on", 0);
 1607      Xorriso_option_acl(xorriso, "on", 0);
 1608      Xorriso_option_xattr(xorriso, "any", 0);
 1609      Xorriso_option_md5(xorriso, "on", 0);
 1610 */
 1611 /* @since 0.4.0 */
 1612 /* xattr "any"
 1613    @since 1.5.0
 1614 */
 1615 
 1616 /* Command -fs */
 1617 /* @since 0.1.0 */
 1618 int Xorriso_option_fs(struct XorrisO *xorriso, char *size, int flag);
 1619 
 1620 /* Commands -getfacl alias -getfacli, -getfacl_r alias -getfacl_ri
 1621             -getfattr alias getfattri
 1622  */
 1623 /* @param flag bit0=recursive -getfacl_r
 1624                bit1= getfattr rather than getfacl
 1625                bit3= with bit1: do not ignore eventual non-user attributes
 1626 */
 1627 /* @since 0.3.4 */
 1628 int Xorriso_option_getfacli(struct XorrisO *xorriso,
 1629                             int argc, char **argv, int *idx, int flag);
 1630 
 1631 /* Command -gid */
 1632 /* @since 0.1.0 */
 1633 int Xorriso_option_gid(struct XorrisO *xorriso, char *gid, int flag);
 1634 
 1635 /* Command -grow_blindly */
 1636 /* @since 0.2.2 */
 1637 int Xorriso_option_grow_blindly(struct XorrisO *xorriso, char *msc2, int flag);
 1638 
 1639 /* Command -hardlinks "on"|"off" */
 1640 /* @since 0.4.0 */
 1641 int Xorriso_option_hardlinks(struct XorrisO *xorriso, char *mode, int flag);
 1642 
 1643 /* Command -help and part of -prog_help */
 1644 /* @since 0.1.0 */
 1645 int Xorriso_option_help(struct XorrisO *xorriso, int flag);
 1646 
 1647 /* Option -hfsplus "on"|"off" */
 1648 /* @since 1.2.4 */
 1649 int Xorriso_option_hfsplus(struct XorrisO *xorriso, char *mode, int flag);
 1650 
 1651 /* Command -hide */
 1652 /* @since 0.6.0 */
 1653 int Xorriso_option_hide(struct XorrisO *xorriso, char *hide_state,
 1654                         int argc, char **argv, int *idx, int flag);
 1655 
 1656 /* Command -history */
 1657 /* @since 0.1.0 */
 1658 int Xorriso_option_history(struct XorrisO *xorriso, char *line, int flag);
 1659 
 1660 /* Command -iso_nowtime "dynamic"|timespec */
 1661 /* @since 1.5.2 */
 1662 int Xorriso_option_iso_nowtime(struct XorrisO *xorriso, char *text, int flag);
 1663 
 1664 /* Command -iso_rr_pattern "on"|"ls"|"off" */
 1665 /* @since 0.1.0 */
 1666 int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode,
 1667                                   int flag);
 1668 
 1669 /* Command -jigdo aspect argument */
 1670 /* @since 0.6.4 */
 1671 int Xorriso_option_jigdo(struct XorrisO *xorriso, char *aspect, char *arg,
 1672                          int flag);
 1673 
 1674 /* Command -joliet "on"|"off" */
 1675 /* @since 0.1.0 */
 1676 int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag);
 1677 
 1678 /* Command -joliet_map "unmapped" | "stripped" */
 1679 int Xorriso_option_joliet_map(struct XorrisO *xorriso, char *mode, int flag);
 1680 
 1681 /* Command -launch_frontend */
 1682 /* @since 1.2.6 */
 1683 int Xorriso_option_launch_frontend(struct XorrisO *xorriso,
 1684                                    int argc, char **argv, int *idx, int flag);
 1685 
 1686 /* Command -list_arg_sorting */
 1687 /* @since 1.2.2 */
 1688 int Xorriso_option_list_arg_sorting(struct XorrisO *xorriso, int flag);
 1689 
 1690 /* Command -list_delimiter */
 1691 /* @since 0.2.6 */
 1692 int Xorriso_option_list_delimiter(struct XorrisO *xorriso, char *text,
 1693                                   int flag);
 1694 
 1695 /* Command -list_extras */
 1696 /* @since 1.1.6 */
 1697 int Xorriso_option_list_extras(struct XorrisO *xorriso, char *mode, int flag);
 1698 
 1699 /* Command -list_formats */
 1700 /* @since 0.1.6 */
 1701 int Xorriso_option_list_formats(struct XorrisO *xorriso, int flag);
 1702 
 1703 /* Command -list_profiles */
 1704 /* @since 0.4.2 */
 1705 int Xorriso_option_list_profiles(struct XorrisO *xorriso, char *which,
 1706                                  int flag);
 1707 
 1708 /* Command -list_speeds */
 1709 /* @since 1.1.2 */
 1710 int Xorriso_option_list_speeds(struct XorrisO *xorriso, int flag);
 1711 
 1712 /* Command -lns alias -lnsi */
 1713 /* @since 1.2.6 */
 1714 int Xorriso_option_lnsi(struct XorrisO *xorriso, char *target, char *path,
 1715                         int flag);
 1716 
 1717 /* Command -load session|track|sbsector value */
 1718 /* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
 1719    @return <=0 error , 1 success, 2 revoked by -reassure
 1720 */
 1721 /* @since 0.1.6 */
 1722 int Xorriso_option_load(struct XorrisO *xorriso, char *adr_mode,
 1723                           char *adr_value, int flag);
 1724 
 1725 /* Command -logfile */
 1726 /* @since 0.1.0 */
 1727 int Xorriso_option_logfile(struct XorrisO *xorriso, char *channel, 
 1728                                                       char *fileadr, int flag);
 1729 
 1730 /* Command -ls  alias -lsi   and -lsl  alias -lsli
 1731        and -lsd alias -lsdi  and -lsdl alias -lsdli
 1732        and -du  alias -dui   and -dus  alias -dusi
 1733    @param flag bit0= long format (-lsl , -du, not -dus, not -ls)
 1734                bit1= do not expand patterns but use literally
 1735                bit2= -du rather than -ls
 1736                bit3= list directories as themselves (-lsd)  
 1737 */
 1738 /* @since 0.1.0 */
 1739 int Xorriso_option_lsi(struct XorrisO *xorriso, int argc, char **argv,
 1740                       int *idx, int flag);
 1741 
 1742 /* Command -lsx, -lslx, -lsdx , -lsdlx , -dux , -dusx
 1743    @param flag bit0= long format (-lslx , -dux)
 1744                bit1= do not expand patterns but use literally
 1745                bit2= du rather than ls
 1746                bit3= list directories as themselves (ls -d)
 1747 */
 1748 /* @since 0.1.0 */
 1749 int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv,
 1750                       int *idx, int flag);
 1751 
 1752 /* Commandis -map , -map_single */
 1753 /* @param flag bit0=do not report the added item
 1754                bit1=do not reset pacifier, no final pacifier message
 1755                bit5= -map_single: do not insert directory tree
 1756 */
 1757 /* @since 0.1.6 */
 1758 int Xorriso_option_map(struct XorrisO *xorriso, char *disk_path,
 1759                        char *iso_path, int flag);
 1760 
 1761 /* Command -map_l , -compare_l , -update_l , -extract_l */
 1762 /* @param flag bit8-11= mode 0= -map_l
 1763                              1= -compare_l
 1764                              2= -update_l
 1765                              3= -extract_l
 1766                              4= -update_lxi  @since 1.4.8
 1767                              5= -update_li   @since 1.4.8
 1768 */
 1769 /* @since 0.2.0 */
 1770 int Xorriso_option_map_l(struct XorrisO *xorriso, int argc, char **argv,
 1771                          int *idx, int flag);
 1772 
 1773 /* Command -mark */
 1774 /* @since 0.1.0 */
 1775 int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag);
 1776 
 1777 /* Command -md5 */
 1778 /* @since 0.4.2 */
 1779 int Xorriso_option_md5(struct XorrisO *xorriso, char *mode, int flag);
 1780 
 1781 /* Command -mkdir alias -mkdiri */
 1782 /* @since 0.1.0 */
 1783 int Xorriso_option_mkdiri(struct XorrisO *xorriso, int argc, char **argv,
 1784                           int *idx, int flag);
 1785 
 1786 /* Command -modesty_on_drive */
 1787 /* @since 1.4.2 */
 1788 int Xorriso_option_modesty_on_drive(struct XorrisO *xorriso, char *mode,
 1789                                     int flag);
 1790 
 1791 /* Command -mount , -mount_cmd , -session_string */
 1792 /* @param bit0= -mount_cmd: print mount command to result channel rather
 1793                             than performing it
 1794           bit1= perform -session_string rather than -mount_cmd
 1795 */ 
 1796 /* @since 0.3.2 */
 1797 int Xorriso_option_mount(struct XorrisO *xorriso, char *dev, char *adr_mode,
 1798                          char *adr, char *cmd, int flag);
 1799 
 1800 /* Command -mount_opts option[:...] */
 1801 /* @since 0.4.4 */
 1802 int Xorriso_option_mount_opts(struct XorrisO *xorriso, char *mode, int flag);
 1803 
 1804 /* Command -move */
 1805 /* @since 1.2.8 */
 1806 int Xorriso_option_move(struct XorrisO *xorriso, char *origin, char *dest,
 1807                         int flag);
 1808 
 1809 /* Command -msg_op */
 1810 /* @since 1.2.6 */
 1811 int Xorriso_option_msg_op(struct XorrisO *xorriso, char *what, char *arg,
 1812                           int flag);
 1813 
 1814 /* Command -mv alias -mvi */
 1815 /* @since 0.1.0 */
 1816 int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv,
 1817                       int *idx, int flag);
 1818 
 1819 /* Option -named_pipe_loop */
 1820 /* @since 1.3.2 */
 1821 int Xorriso_option_named_pipe_loop(struct XorrisO *xorriso, char *mode,
 1822                                    char *stdin_pipe, char *stdout_pipe,
 1823                                    char *stderr_pipe, int flag);
 1824 
 1825 /* Command -no_rc */
 1826 /* @since 0.1.0 */
 1827 int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag);
 1828 
 1829 /* Command -not_leaf , -as mkisofs -hide without '/' */
 1830 /* @param flag  bit0= add to iso_rr hide list rather than to disk exclusions
 1831                       @since 0.6.0
 1832                 bit1= add to joliet hide list rather than disk exclusions
 1833                       @since 0.6.0
 1834                 bit2= add to HFS+ hide list rather than disk exclusions
 1835                       @since 1.2.4
 1836 */
 1837 /* @since 0.1.6 */
 1838 int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag);
 1839 
 1840 /* Command -not_list , -quoted_not_list */
 1841 /* @param flag bit0= -quoted_not_list
 1842                      @since 0.3.0
 1843  */
 1844 /* @since 0.1.6 */
 1845 int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag);
 1846 
 1847 /* Command -not_mgt */
 1848 /* @since 0.1.6 */
 1849 int Xorriso_option_not_mgt(struct XorrisO *xorriso, char *setting, int flag);
 1850 
 1851 /* Command -not_paths , -as mkisofs -hide with '/' */
 1852 /* @param flag  bit0= add to iso_rr hide list rather than to disk exclusions
 1853                       @since 0.6.0
 1854                 bit1= add to joliet hide list rather than disk exclusions
 1855                       @since 0.6.0
 1856                 bit2= enable disk pattern expansion regardless of -disk_pattern
 1857                 bit8-13= consolidated hide state bits, duplicating bit0-1
 1858                          @since 1.2.4
 1859                    bit8= add to iso_rr_hidings, same as bit0
 1860                    bit9= add to joliet_hidings, same as bit1
 1861                   bit10= add to hfsplus_hidings
 1862 */ 
 1863 /* @since 0.1.6 */
 1864 int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv,
 1865                              int *idx, int flag);
 1866 
 1867 /* Command -options_from_file */
 1868 /* @return <=0 error , 1 = success , 3 = request to end program run */
 1869 /* @since 0.1.0 */
 1870 int Xorriso_option_options_from_file(struct XorrisO *xorriso, char *adr,
 1871                                      int flag);
 1872 
 1873 /* Command -osirrox "on"|"off" */
 1874 /* @since 0.1.8 */
 1875 int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag);
 1876 
 1877 /* Command -overwrite "on"|"nondir"|"off" */
 1878 /* @since 0.1.0 */
 1879 int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag);
 1880 
 1881 /* Command -pacifier */
 1882 /* @since 0.2.2 */
 1883 int Xorriso_option_pacifier(struct XorrisO *xorriso, char *style, int flag);
 1884 
 1885 /* Command -padding */
 1886 /* @since 0.1.0 */
 1887 int Xorriso_option_padding(struct XorrisO *xorriso, char *size, int flag);
 1888 
 1889 /* Command -page */
 1890 /* @since 0.1.0 */
 1891 int Xorriso_option_page(struct XorrisO *xorriso, int len, int width, int flag);
 1892 
 1893 /* Command -paste_in */
 1894 /* @since 0.2.0 */
 1895 int Xorriso_option_paste_in(struct XorrisO *xorriso, char *iso_rr_path,
 1896                           char *disk_path, char *start, char *count, int flag);
 1897 
 1898 /* Command -path_list , -quoted_path_list */
 1899 /* @param flag bit0= -quoted_path_list @since 0.3.0
 1900 */
 1901 /* @since 0.1.0 */
 1902 int Xorriso_option_path_list(struct XorrisO *xorriso, char *adr, int flag);
 1903 
 1904 /* Command -pathspecs */
 1905 /* @since 0.1.0 */
 1906 int Xorriso_option_pathspecs(struct XorrisO *xorriso, char *mode, int flag);
 1907 
 1908 /* Command -pkt_output */
 1909 /* Note: If output is redirected by Xorriso_push_outlists() then mode "on"
 1910          consolidates output in the result output list, not on stdout.
 1911 */
 1912 /* @since 0.1.0 */
 1913 int Xorriso_option_pkt_output(struct XorrisO *xorriso, char *mode, int flag);
 1914 
 1915 /* Command -preparer_id */
 1916 /* @since 0.6.2 */
 1917 int Xorriso_option_preparer_id(struct XorrisO *xorriso, char *name, int flag);
 1918 
 1919 /* Command -print, -print_info , -print_mark */
 1920 /* @param flag bit0-1= output channel:
 1921                        0= result channel
 1922                        1= info channel @since 1.0.6
 1923                        2= mark channel @since 1.0.6
 1924 */
 1925 /* @since 1.0.6 */
 1926 int Xorriso_option_print(struct XorrisO *xorriso, char *text, int flag);
 1927 
 1928 /* Command -print_size
 1929    @param flag bit0= report in mkisofs compatible form on real stdout
 1930 */
 1931 /* @since 0.1.0 */
 1932 int Xorriso_option_print_size(struct XorrisO *xorriso, int flag);
 1933 
 1934 /* Command -prog */
 1935 /* @since 0.1.0 */
 1936 int Xorriso_option_prog(struct XorrisO *xorriso, char *name, int flag);
 1937 
 1938 /* Command -prompt */
 1939 /* @since 0.1.0 */
 1940 int Xorriso_option_prompt(struct XorrisO *xorriso, char *text, int flag);
 1941 
 1942 /* Command -prog_help */
 1943 /* @since 0.1.0 */
 1944 int Xorriso_option_prog_help(struct XorrisO *xorriso, char *name, int flag);
 1945 
 1946 /* Command -publisher */
 1947 /* @since 0.1.2 */
 1948 int Xorriso_option_publisher(struct XorrisO *xorriso, char *name, int flag);
 1949 
 1950 /* Command -pvd_info */
 1951 /* @since 0.4.4 */
 1952 int Xorriso_option_pvd_info(struct XorrisO *xorriso, int flag);
 1953 
 1954 /* Command -pwd alias -pwdi */
 1955 /* @since 0.1.0 */
 1956 int Xorriso_option_pwdi(struct XorrisO *xorriso, int flag);
 1957 
 1958 /* Command -pwdx */
 1959 /* @since 0.1.0 */
 1960 int Xorriso_option_pwdx(struct XorrisO *xorriso, int flag);
 1961 
 1962 /* Command -read_fs */
 1963 /* @since 1.4.2 */
 1964 int Xorriso_option_read_fs(struct XorrisO *xorriso, char *mode, int flag);
 1965 
 1966 /* Command -read_mkisofsrc */
 1967 /* @since 0.6.0 */
 1968 int Xorriso_option_read_mkisofsrc(struct XorrisO *xorriso, int flag);
 1969 
 1970 /* Command -reassure "on"|"tree"|"off" */
 1971 /* @since 0.1.0 */
 1972 int Xorriso_option_reassure(struct XorrisO *xorriso, char *mode, int flag);
 1973 
 1974 /* Command -report_about */
 1975 /* @since 0.1.0 */
 1976 int Xorriso_option_report_about(struct XorrisO *xorriso, char *severity, 
 1977                                 int flag);
 1978 
 1979 /* Command -report_el_torito */
 1980 /* @since 1.3.8 */
 1981 int Xorriso_option_report_el_torito(struct XorrisO *xorriso,
 1982                                     char *form, int flag);
 1983 
 1984 /* Command -report_system_area */
 1985 /* @since 1.3.8 */
 1986 int Xorriso_option_report_system_area(struct XorrisO *xorriso,
 1987                                       char *form, int flag);
 1988 
 1989 /* Command -return_with */
 1990 /* @since 0.1.0 */
 1991 int Xorriso_option_return_with(struct XorrisO *xorriso, char *severity,
 1992                                int exit_value, int flag);
 1993 
 1994 /* Command -rm alias -rmi , -rm_r alias -rm_ri , -rmdir alias -rmdiri */
 1995 /* @param flag bit0=recursive
 1996                bit2= remove empty directory: rmdiri
 1997  */
 1998 /* @since 0.1.0 */
 1999 int Xorriso_option_rmi(struct XorrisO *xorriso, int argc, char **argv,
 2000                        int *idx, int flag);
 2001 
 2002 /* Command -rockridge "on"|"off" */
 2003 /* @since 1.2.4 */
 2004 int Xorriso_option_rockridge(struct XorrisO *xorriso, char *mode, int flag);
 2005 
 2006 /* Command -rollback */
 2007 /* @param flag bit0= do not -reassure
 2008    @return <=0 error , 1 success, 2 revoked by -reassure
 2009 */
 2010 /* @since 0.1.0 */
 2011 int Xorriso_option_rollback(struct XorrisO *xorriso, int flag);
 2012 
 2013 /* Command -rom_toc_scan */
 2014 /* @since 0.1.6 */
 2015 int Xorriso_option_rom_toc_scan(struct XorrisO *xorriso, char *mode, int flag);
 2016 
 2017 /* Command -rr_reloc_dir */
 2018 /* @since 1.2.2 */
 2019 int Xorriso_option_rr_reloc_dir(struct XorrisO *xorriso, char *name, int flag);
 2020 
 2021 /* Command -scdbackup_tag */
 2022 /* @since 0.4.4 */
 2023 int Xorriso_option_scdbackup_tag(struct XorrisO *xorriso, char *list_path,
 2024                                  char *record_name, int flag);
 2025 
 2026 /* Command -scsi_dev_family */
 2027 /* @since 1.4.4 */
 2028 int Xorriso_option_scsi_dev_family(struct XorrisO *xorriso, char *mode,
 2029                                    int flag);
 2030 
 2031 /* Command -scsi_log */
 2032 /* @since 0.5.0 */
 2033 int Xorriso_option_scsi_log(struct XorrisO *xorriso, char *mode, int flag);
 2034 
 2035 /* Command -session_log */
 2036 /* @since 0.1.4 */
 2037 int Xorriso_option_session_log(struct XorrisO *xorriso, char *path, int flag);
 2038 
 2039 /* Command -setfacl_list alias -setfacl_listi */
 2040 /* @since 0.3.4 */
 2041 int Xorriso_option_setfacl_listi(struct XorrisO *xorriso, char *disk_path,
 2042                                  int flag);
 2043 
 2044 /* Command -setfacl alias -setfacli , -setfacl_r  alias -setfacl_ri */
 2045 /* @param flag bit0=recursive -setfacl_r */
 2046 /* @since 0.3.4 */
 2047 int Xorriso_option_setfacli(struct XorrisO *xorriso, char *acl_text,
 2048                             int argc, char **argv, int *idx, int flag);
 2049 
 2050 /* Command -setfattr alias -setfattri, -setfattr_r alias -setfattr_ri */
 2051 /* @param flag   bit0=recursive -setfattr_r */
 2052 /* @since 0.3.4 */
 2053 int Xorriso_option_setfattri(struct XorrisO *xorriso, char *name, char *value,
 2054                             int argc, char **argv, int *idx, int flag);
 2055 
 2056 /* Command -setfattr_list alias -setfattr_listi */
 2057 /* @since 0.3.4 */
 2058 int Xorriso_option_setfattr_listi(struct XorrisO *xorriso, char *path, 
 2059                                   int flag);
 2060 
 2061 /* Command -set_filter , -set_filter_r , -show_stream , -show_stream_r  */ 
 2062 /* @param flag   bit0=recursive -set_filter_r
 2063                  bit1= do not reset pacifier, no final pacifier message
 2064                  bit2= -show_stream rather than -set_filter
 2065  */
 2066 /* @since 0.3.8 */
 2067 int Xorriso_option_set_filter(struct XorrisO *xorriso, char *name,
 2068                               int argc, char **argv, int *idx, int flag);
 2069 
 2070 /* Option -sh_style_result */
 2071 /* @since 1.3.2 */
 2072 int Xorriso_option_sh_style_result(struct XorrisO *xorriso, char *mode,
 2073                                    int flag);
 2074 
 2075 /* Command -signal_handling */
 2076 /* @param flag bit0= do not yet install the eventual handler
 2077    @since 1.1.0
 2078 */
 2079 int Xorriso_option_signal_handling(struct XorrisO *xorriso, char *mode,
 2080                                    int flag);
 2081 
 2082 /* Command -sleep */
 2083 /* @since 1.1.8 */
 2084 int Xorriso_option_sleep(struct XorrisO *xorriso, char *duration, int flag);
 2085 
 2086 /* Command -speed , -read_speed */
 2087 /* @param flag bit0= @since 1.3.4
 2088                      -read_speed rather than -speed */ 
 2089 /* @since 0.1.0 */
 2090 int Xorriso_option_speed(struct XorrisO *xorriso, char *speed, int flag);
 2091 
 2092 /* Command -split_size */
 2093 /* @since 0.1.4 */
 2094 int Xorriso_option_split_size(struct XorrisO *xorriso, char *s, int flag);
 2095 
 2096 /* Command -status */
 2097 /* @since 0.1.0 */
 2098 int Xorriso_option_status(struct XorrisO *xorriso, char *mode, int flag);
 2099 
 2100 /* Command -status_history_max */
 2101 /* @since 0.1.0 */
 2102 int Xorriso_option_status_history_max(struct XorrisO *xorriso, int num1, 
 2103                                       int flag);
 2104 
 2105 /* Command -stdio_sync "on"|"off"|"end"|size */
 2106 /* @since 0.4.6 */
 2107 int Xorriso_option_stdio_sync(struct XorrisO *xorriso, char *rhythm, int flag);
 2108 
 2109 /* Command -stream_recording */
 2110 /* @since 0.1.8 */
 2111 int Xorriso_option_stream_recording(struct XorrisO *xorriso, char *mode,
 2112                                     int flag);
 2113 
 2114 /* Command -system_id */
 2115 /* @since 0.4.4 */
 2116 int Xorriso_option_system_id(struct XorrisO *xorriso, char *name, int flag);
 2117 
 2118 /* Command -tell_media_space */
 2119 /* @since 0.1.0 */
 2120 int Xorriso_option_tell_media_space(struct XorrisO *xorriso, int flag);
 2121 
 2122 /* Command -temp_mem_limit */
 2123 /* @since 0.1.0 */
 2124 int Xorriso_option_temp_mem_limit(struct XorrisO *xorriso, char *size, 
 2125                                   int flag);
 2126 
 2127 /* Command -toc */
 2128 /* @param flag   bit0= short report form as with -dev, no table-of-content
 2129 */
 2130 /* @since 0.1.0 */
 2131 int Xorriso_option_toc(struct XorrisO *xorriso, int flag);
 2132 
 2133 /* Command -toc_of */
 2134 /* @since 1.2.6 */
 2135 int Xorriso_option_toc_of(struct XorrisO *xorriso, char *which, int flag);
 2136 
 2137 /* Command -truncate_overwritable */
 2138 /* @since 1.5.4 */
 2139 int Xorriso_option_truncate_overwritable(struct XorrisO *xorriso,
 2140                                          char *adr_mode, char *adr_value,
 2141                                          char *adjust, int flag);
 2142 
 2143 /* Command -uid */
 2144 /* @since 0.1.0 */
 2145 int Xorriso_option_uid(struct XorrisO *xorriso, char *uid, int flag);
 2146 
 2147 /* Command -unregister_filter */
 2148 /* @since 0.3.8 */
 2149 int Xorriso_option_unregister_filter(struct XorrisO *xorriso, char *name,
 2150                                      int flag);
 2151 
 2152 /* Command -update and -update_r
 2153    @param flag bit0= issue summary message
 2154                bit1= do not reset pacifier, no final pacifier message
 2155                bit2= do not issue pacifier messages at all
 2156                bit3= recursive: -update_r
 2157 */ 
 2158 /* @since 0.1.2 */
 2159 int Xorriso_option_update(struct XorrisO *xorriso, char *disk_path,
 2160                           char *iso_path, int flag);
 2161 
 2162 /* Command -use_readline */
 2163 /* @since 0.1.0 */
 2164 int Xorriso_option_use_readline(struct XorrisO *xorriso, char *mode, int flag);
 2165 
 2166 /* Command -use_immed_bit */
 2167 /* @since 1.4.6 */
 2168 int Xorriso_option_use_immed_bit(struct XorrisO *xorriso, char *mode,
 2169                                  int flag);
 2170 
 2171 /* Command -version */
 2172 /* @since 0.1.0 */
 2173 int Xorriso_option_version(struct XorrisO *xorriso, int flag);
 2174 
 2175 /* Command -volid */
 2176 /* @param flag bit0= do not warn of problematic volid
 2177 */
 2178 int Xorriso_option_volid(struct XorrisO *xorriso, char *volid, int flag);
 2179 
 2180 /* Command -volset_id */
 2181 /* @since 0.4.4 */
 2182 int Xorriso_option_volset_id(struct XorrisO *xorriso, char *name, int flag);
 2183 
 2184 /* Command -volume_date */
 2185 /* @since 0.5.4 */
 2186 int Xorriso_option_volume_date(struct XorrisO *xorriso,
 2187                                char *time_type, char *timestring, int flag);
 2188 
 2189 /* Command -write_type */
 2190 /* @since 1.2.4 */
 2191 int Xorriso_option_write_type(struct XorrisO *xorriso, char *mode, int flag);
 2192 
 2193 /* There is no Xorriso_option_x() because -x has an effect only in
 2194    Xorriso_prescan_args(). Use the flag bits of Xorriso_interpreter() if
 2195    you want to impose command sorting on your own.
 2196    @since 1.2.2
 2197 */
 2198 
 2199 /* Command -xattr "on"|"off" */
 2200 /* @since 0.3.4 */
 2201 int Xorriso_option_xattr(struct XorrisO *xorriso, char *mode, int flag);
 2202 
 2203 /* Command -zisofs */
 2204 /* @since 0.3.8 */
 2205 int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag);
 2206 
 2207 #ifdef __cplusplus
 2208 } /* extern "C" */
 2209 #endif
 2210 
 2211 #endif /* Xorriso_includeD */
 2212 
 2213