You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2183 lines
90 KiB
2183 lines
90 KiB
|
|
/* xorriso - libisoburn higher level API which creates, loads, manipulates |
|
and burns ISO 9660 filesystem images. |
|
|
|
Copyright 2007-2016 Thomas Schmitt, <scdbackup@gmx.net> |
|
|
|
Provided under GPL version 2 or later. |
|
|
|
This file contains the public API of xorriso which covers all of its |
|
operations. |
|
|
|
An example of its usage is xorriso_main.c which checks version compatibility, |
|
creates a xorriso object, initializes the libraries, and runs the command |
|
interpreters of the API to constitute the command line oriented batch and |
|
dialog tool xorriso. |
|
|
|
Alternatively to command interpreters it is possible to run all options of |
|
xorriso directly via the calls of the "Command API". |
|
The "Problem Status and Message API" shall then be used to obtain the |
|
text output of the options. |
|
|
|
Mandatory calls are: |
|
Xorriso_new(), Xorriso_startup_libraries(), Xorriso_destroy() |
|
|
|
This architecture is fully public since version 0.5.8. From then on, new |
|
features get marked by |
|
@since major.minor.micro |
|
The option calls may have older "since" marks which then tell when the |
|
corresponding command was introduced in the command interpreter. |
|
|
|
Please note that struct XorrisO and its API calls are _not_ thread-safe in |
|
general. It is not permissible to run two API calls on the same |
|
XorrisO object concurrently. |
|
The only exception is |
|
Xorriso_fetch_outlists() |
|
in order to learn about the ongoing text output of other API calls. |
|
|
|
|
|
There is a lower level of API which consists of libisofs.h, libburn.h and |
|
libisoburn.h. One should not mix those calls with the ones of xorriso.h . |
|
*/ |
|
|
|
/* Important: If you add a public API function then add its name to file |
|
libisoburn/libisoburn.ver |
|
*/ |
|
|
|
|
|
#ifndef Xorriso_includeD |
|
#define Xorriso_includeD yes |
|
|
|
#ifdef __cplusplus |
|
extern "C" { |
|
#endif |
|
|
|
|
|
/** Opaque handle of the xorriso runtime context */ |
|
struct XorrisO; |
|
|
|
|
|
|
|
/* This may be changed to Xorriso_GNU_xorrisO in order to create GNU xorriso |
|
under GPLv3+ derived from above GPLv2+. |
|
*/ |
|
#define Xorriso_libburnia_xorrisO yes |
|
|
|
|
|
/* --------------------- Fundamental Management ------------------- */ |
|
|
|
|
|
/** These three release version numbers tell the revision of this header file |
|
and of the API which it describes. They shall be memorized by applications |
|
at build time. |
|
@since 0.5.8 |
|
*/ |
|
#define Xorriso_header_version_majoR 1 |
|
#define Xorriso_header_version_minoR 4 |
|
#define Xorriso_header_version_micrO 7 |
|
|
|
|
|
/** If needed: Something like ".pl01" to indicate a bug fix. Normally empty. |
|
@since 0.5.8 |
|
*/ |
|
#define Xorriso_program_patch_leveL "" |
|
|
|
|
|
/** Obtain the three release version numbers of the library. These are the |
|
numbers encountered by the application when linking with libisoburn, |
|
i.e. possibly not before run time. |
|
Better do not base the fundamental compatibility decision of an application |
|
on these numbers. For a reliable check use Xorriso__is_compatible(). |
|
@since 0.5.8 |
|
@param major The maturity version (0 for now, as we are still learning) |
|
@param minor The development goal version. |
|
@param micro The development step version. This has an additional meaning: |
|
|
|
Pare numbers indicate a version with frozen API. I.e. you can |
|
rely on the same set of features to be present in all |
|
published releases with that major.minor.micro combination. |
|
Features of a pare release will stay available and ABI |
|
compatible as long as the SONAME of libisoburn stays "1". |
|
Currently there are no plans to ever change the SONAME. |
|
|
|
Odd numbers indicate that API upgrades are in progress. |
|
I.e. new features might be already present or they might |
|
be still missing. Newly introduced features may be changed |
|
incompatibly or even be revoked before release of a pare |
|
version. |
|
So micro revisions {1,3,5,7,9} should never be used for |
|
dynamic linking unless the proper library match can be |
|
guaranteed by external circumstances. |
|
|
|
@return 1 success, <=0 might in future become an error indication |
|
*/ |
|
void Xorriso__version(int *major, int *minor, int *micro); |
|
|
|
|
|
/** Check whether all features of header file xorriso.h from the given |
|
major.minor.micro revision triple can be delivered by the library version |
|
which is performing this call. |
|
if (! Xorriso__is_compatible(Xorriso_header_version_majoR, |
|
Xorriso_header_version_minoR, |
|
Xorriso_header_version_micrO, 0)) |
|
...refuse to start the program with this dynamic library version... |
|
@since 0.5.8 |
|
@param major obtained at build time |
|
@param minor obtained at build time |
|
@param micro obtained at build time |
|
@param flag Bitfield for control purposes. Unused yet. Submit 0. |
|
@return 1= library can work for caller |
|
0= library is not usable in some aspects. Caller must restrict |
|
itself to an earlier API version or must not use this library |
|
at all. |
|
*/ |
|
int Xorriso__is_compatible(int major, int minor, int micro, int flag); |
|
|
|
|
|
/* Get the patch level text (e.g. "" or ".pl01") of the program code. |
|
@param flag unused yet, submit 0 |
|
@return readonly character string |
|
*/ |
|
char *Xorriso__get_patch_level_text(int flag); |
|
|
|
|
|
/* Choose how Xorriso_startup_libraries() and the XorrisO object shall |
|
prepare for eventual signals. |
|
@param behavior Default is behavior 1. |
|
0= no own signal handling. The main application has to do |
|
that. Do not start burn runs without any handling ! |
|
1= use libburn signal handler. Most time with action |
|
0. During writing, formatting, blanking: 0x30. |
|
Only usable with a single xorriso object. |
|
2= Enable system default reaction on all signals |
|
@since 1.0.9 |
|
3= Try to ignore nearly all signals |
|
@since 1.0.9 |
|
@param flag unused yet, submit 0 |
|
@return <= 0 is error, >0 is success |
|
*/ |
|
int Xorriso__preset_signal_behavior(int behavior, int flag); |
|
|
|
|
|
/* Mandatory call: |
|
Create a new xorriso object and tell it the program name to be used |
|
with messages and for decision of special behavior. |
|
@param xorriso returns the newly created XorrisO object |
|
@param progname typically argv[0] of main(). Some leafnames of the progname |
|
path have special meaning and trigger special behavior: |
|
"osirrox" allows image-to-disk copying: -osirrox "on" |
|
"xorrisofs" activates -as "mkisofs" emulation from start |
|
"genisofs" alias of "xorrisofs" |
|
"mkisofs" alias of "xorrisofs" |
|
"genisoimage" alias of "xorrisofs" |
|
"xorrecord" activates -as "cdrecord" emulation from start |
|
"cdrecord" alias of "xorrecord" |
|
"wodim" alias of "xorrecord" |
|
"cdrskin" alias of "xorrecord" |
|
@param flag unused yet, submit 0 |
|
@return >0 success , <=0 failure, no object created |
|
*/ |
|
int Xorriso_new(struct XorrisO ** xorriso, char *progname, int flag); |
|
|
|
|
|
/* Note: Between Xorriso_new() and the next call Xorriso_startup_libraries() |
|
there may be called the special command interpreter |
|
Xorriso_prescan_args(). |
|
The other command interpreters may be used only after |
|
Xorriso_startup_libraries(). The same restriction applies to the |
|
calls of the Command API further below. |
|
*/ |
|
|
|
|
|
/* Mandatory call: |
|
It has to be made before calling any function listed below this point. |
|
Only exception is the special command interpreter Xorriso_prescan_args(). |
|
|
|
Make global library initializations. |
|
This must be done with the first xorriso object that gets created and |
|
with the first xorriso object that gets created after Xorriso_destroy(,1). |
|
@param xorriso The context object. |
|
@param flag unused yet, submit 0 |
|
@return <=0 error , >0 success |
|
*/ |
|
int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/* Note: After library startup, you may run Command Interpreters or call |
|
functions from the Command API. |
|
|
|
Wenn all desired activities are done, you may check whether there are |
|
uncommited changes pending, compute an exit value, destroy the XorrisO |
|
object, and exit your program. |
|
*/ |
|
|
|
|
|
/* Inquire whether option -commit would make sense. |
|
@param xorriso The context object to inquire. |
|
@param flag @since 0.6.6 |
|
bit0= do not return 1 if -as mkisofs -print-size was |
|
performed on the current image. |
|
@return 0= -commit would have nothing to do |
|
1= a new image session would emerge at -commit |
|
*/ |
|
int Xorriso_change_is_pending(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/* Compute the exit value from the recorded maximum event severity. |
|
@param xorriso The context object to inquire. |
|
@param flag unused yet, submit 0 |
|
@return The computed exit value |
|
*/ |
|
int Xorriso_make_return_value(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/* Mandatory call: |
|
Destroy xorriso object when it is no longer needed. |
|
@param xorriso The context object to destroy. *xorriso will become NULL. |
|
@param flag bit0= Perform global library shutdown. |
|
Use only with last xorriso object to be destroyed. |
|
@return <=0 error, >0 success |
|
*/ |
|
int Xorriso_destroy(struct XorrisO **xorriso, int flag); |
|
|
|
|
|
/* --------------------- Command Interpreters ------------------- */ |
|
|
|
|
|
/* This special interpreter may be called between Xorriso_new() and |
|
Xorriso_startup_libraries(). It interprets certain commands which shall |
|
get into effect before the libraries get initialized: |
|
-abort_on , -report_about , -return_with , |
|
-scsi_log , -signal_handling |
|
This is the only occasion where command -x has an effect: |
|
-x |
|
Some commands get executed only if they are the only command in argv: |
|
-prog_help , -help |
|
The following is recognized only if it is the first of all arguments: |
|
-no_rc |
|
Some get examined for the need to redirect stdout messages: |
|
-dev , -outdev , -indev , -as |
|
Commands |
|
-backslash_codes , -list_delimiter , -add_plainly |
|
get into effect during this call. But their setting at begin of the call |
|
gets restored before the call returns. |
|
@param xorriso The context object in which to perform the commands. |
|
@param argc Number of arguments. |
|
@param argv The arguments. argv[0] contains the program name. |
|
argv[1] to argv[argc-1] contain commands and parameters. |
|
@param idx Argument cursor. When this function is called, *idx must |
|
be at least 1, argv[*idx] must be a command. |
|
*idx will iterate over commands and parameters until this |
|
function aborts or until argc is reached. |
|
@param flag bit0= do not interpret argv[1] |
|
bit1= produce FAILURE events on unknown commands |
|
@since 1.1.0 |
|
@return <0 error |
|
0 end program |
|
1 ok, go on |
|
*/ |
|
int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv, |
|
int flag); |
|
|
|
|
|
/* Read and interpret commands from eventual startup files as listed in |
|
man xorriso. |
|
@param xorriso The context object in which to perform the commands. |
|
@param flag unused yet, submit 0 |
|
@return <=0 = error |
|
1 = success |
|
3 = end program run (e.g. because command -end was encountered) |
|
*/ |
|
int Xorriso_read_rc(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/* Check whether program arguments shall be backslash decoded. If so, then |
|
replace *argv by a new argument vector. The old one will not be freed |
|
by this call. If it is dynamic memory then you need to keep a copy of |
|
the pointer and free it yourself after this call. |
|
|
|
@since 1.3.2: |
|
This call internally interprets the commands -backslash_codes and |
|
-list_delimiter if it encounters them among the arguments. The |
|
decoding of backslashes can thus be enabled and disabled by the |
|
arguments themselves. The state of the xorriso object in respect |
|
to these commands gets preserved at the start of the call and restored |
|
when the call ends. |
|
(*argv)[0] never gets decoded. |
|
The old *argv will always be replaced by a new one. |
|
|
|
@param xorriso The context object |
|
@param argc Number of arguments. |
|
@param argv The arguments. (*argv)[0] contains the program name. |
|
(*argv)[1] to (*argv)[argc-1] contain commands and parameters |
|
If argv after the call differs from argv before the call, |
|
then one should dispose it later by: |
|
Xorriso__dispose_words(argc, argv); |
|
@param flag unused yet, submit 0 |
|
@return <= 0 error , > 0 success |
|
*/ |
|
int Xorriso_program_arg_bsl(struct XorrisO *xorriso, int argc, char ***argv, |
|
int flag); |
|
|
|
|
|
/* Interpret argv as xorriso command options and their parameters. |
|
(An alternative is to call functions of the options API directly and to |
|
perform own error status evaluation. See below: Command API.) |
|
After the first command and its parameters there may be more commands and |
|
parameters. All parameters must be given in the same call as their command. |
|
@since 1.2.2: |
|
Commands may get arranged in a sequence that is most likely to make sense. |
|
E.g. image loading settings before drive aquiration, then commands for |
|
adding files, then settings for writing, then writing. |
|
This feature may be enabled by command "-x" in Xorriso_prescan_args() |
|
or by parameter flag of this call. |
|
@param xorriso The context object in which to perform the commands. |
|
@param argc Number of arguments. |
|
@param argv The arguments. argv[0] contains the program name. |
|
argv[1] to argv[argc-1] contain commands and parameters. |
|
@param idx Argument cursor. When this function is called, *idx must |
|
be at least 1, argv[*idx] must be a command. |
|
*idx will iterate over commands and parameters until this |
|
function aborts, or until argc is reached, or only once if |
|
flag bit2 is set. |
|
@param flag bit0= reserved. Indicates recursion. Submit 0. |
|
bit1= Indicates that these are the main() program start |
|
arguments. This enables their use with emulations |
|
which where set with Xorriso_new(), or argument |
|
arranging. |
|
bit2= Only execute the one command argv[*idx] and advance |
|
*idx to the next command if successful. Then return. |
|
This prevents any argument arranging. |
|
@since 1.2.2 |
|
bit3= With bit1 and not bit2: |
|
Enable argument arranging as with |
|
Xorriso_prescan_args() and command "-x". |
|
@since 1.2.2 |
|
bit4= With bit1: |
|
Surely disable argument arranging. |
|
@since 1.2.2 |
|
@return <=0 = error |
|
1 = success |
|
2 = problem event ignored |
|
3 = end program run (e.g. because command -end was encountered) |
|
*/ |
|
int Xorriso_interpreter(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
|
|
/* Parse a command line into words and use them as argv for a call of |
|
Xorriso_interpreter(). Put out some info lines about the outcome. |
|
@param xorriso The context object in which to perform the commands. |
|
@param line A text of one or more words according to man xorriso |
|
paragraph "Command processing" up to and including |
|
"Backslash Interpretation". |
|
@param flag bit0 to bit15 are forwarded to Xorriso_interpreter() |
|
bit16= no pageing of info lines |
|
bit17= print === bar even if xorriso->found<0 |
|
@return see return of Xorriso_interpreter() |
|
*/ |
|
int Xorriso_execute_option(struct XorrisO *xorriso, char *line, int flag); |
|
|
|
|
|
/* Parse a text line into words. This parsing obeys the same rules as |
|
command line parsing but allows to skip a prefix, to use a user provided |
|
set of separator characters, and to restrict the number of parsed words. |
|
|
|
If parameter xorriso is NULL, then this call is safe for usage by |
|
a concurrent thread while a xorriso API call is being executed. |
|
|
|
@since 1.2.6 |
|
@param xorriso The context object which provides settings for parsing |
|
and output channels for error messages. |
|
May be NULL in order to allow concurrent execution e.g. |
|
by a callback function of Xorriso_start_msg_watcher(). |
|
If xorriso is NULL then: |
|
flag bit1-bit4 are in effect even if bit0 is not set. |
|
flag bit5 and bit6 may not be set. |
|
@param line A text of one or more words according to man xorriso |
|
paragraph "Command processing" up to and including |
|
"Backslash Interpretation". |
|
@param prefix If not empty then the line will only be parsed if it |
|
begins by the prefix text. Parsing will then begin after |
|
the end of the prefix. |
|
If the prefix does not match, then 0 will be returned |
|
in *argc, argv will be NULL, and the return value will |
|
be 2. |
|
@param separators If not empty this overrides the default list of word |
|
separating characters. Default set is the one of |
|
isspace(3). |
|
@param max_words If not 0: Maximum number of words to parse. If there |
|
remains line text after the last parsed word and its |
|
following separators, then this remainder is copied |
|
unparsed into a final result word. In this case *argc |
|
will be larger than max_words by one. Note that trailing |
|
separators are considered to be followed by an empty |
|
word. |
|
@param argc Will return the number of allocated and filled word |
|
strings. |
|
@param argv Will return the array of word strings. |
|
Do not forget to dispose the allocated memory by a |
|
call to Xorriso__dispose_words(). |
|
@param flag Bitfield for control purposes |
|
bit0= Override setting of -backslash_codes. |
|
bit1-4= With bit0: backslash behavior |
|
0= off |
|
1= in_double_quotes |
|
2= in_quotes |
|
3= with_quoted_input |
|
bit5= Prepend the program name as (*argv)[0], so that |
|
*argv is suitable for Xorriso_interpreter() |
|
and other calls which expect this. |
|
Not allowed if xorriso is NULL. |
|
bit6= Issue failure message in case of return 0 |
|
Not allowed if xorriso is NULL. |
|
@return <=0 means error and invalidity of *argv: |
|
0 = Input format error. E.g. bad quotation mark. |
|
-1 = Lack of resources. E.g. memory. |
|
-2 = Improper combination of call parameters. |
|
>0 means success but not necessarily a valid result: |
|
1 = Result in argc and argv is valid (but may |
|
be empty by argc == 0, argv == NULL). |
|
2 = Line did not match prefix. Result is invalid |
|
and empty. |
|
*/ |
|
int Xorriso_parse_line(struct XorrisO *xorriso, char *line, |
|
char *prefix, char *separators, int max_words, |
|
int *argc, char ***argv, int flag); |
|
|
|
|
|
/* Dispose a list of strings as allocated by Xorriso_parse_line() or |
|
Xorriso_program_arg_bsl(), or Xorriso_sieve_get_result(). |
|
@since 1.2.6 |
|
@param argc A pointer to the number of allocated and filled word |
|
strings. *argc will be set to 0 by this call. |
|
@param argv A pointer to the array of word strings. |
|
*argv will be set to NULL by this call. |
|
*/ |
|
void Xorriso__dispose_words(int *argc, char ***argv); |
|
|
|
|
|
/* Enter xorriso command line dialog mode, using libreadline if configured |
|
at build time and not disabled at run time. |
|
This call returns immediately if not option -dialog "on" was performed |
|
before. |
|
@param xorriso The context object in which to perform the commands. |
|
@param flag unused yet, submit 0 |
|
@return <=0 error, 1= dialog mode ended normally , |
|
3= dialog mode ended normally,interpreter asks to end program |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_dialog(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/* --------------------- Problem Status and Message API ------------------- */ |
|
|
|
|
|
/** Submit a problem message to the xorriso problem reporting and handling |
|
system. This will eventually increase problem status rank, which may |
|
at certain stages in the program be pardoned and reset to 0. |
|
The pardon is governed by Xorriso_option_abort_on() and by the anger |
|
of the affected program part. If no pardon has been given, then the problem |
|
status reaches the caller of option functions. |
|
Problem status should be inquired by Xorriso_eval_problem_status() and be |
|
reset before next option execution by Xorriso_set_problem_status(). |
|
The problem status itself does not cause the failure of option functions. |
|
But in case of failures for other reasons, a remnant overly severe problem |
|
status can cause overly harsh program reactions. |
|
@param xorriso The environment handle |
|
@param error_code The unique error code of your message. |
|
Submit 0 if you do not have reserved error codes within |
|
the libburnia project. |
|
@param msg_text Not more than 8196 characters of message text. |
|
A final newline character gets appended automatically. |
|
@param os_errno Eventual errno related to the message. Submit 0 if |
|
the message is not related to a operating system error. |
|
@param severity One of "ABORT", "FATAL", "FAILURE", "MISHAP", "SORRY", |
|
"WARNING", "HINT", "NOTE", "UPDATE", "DEBUG". |
|
Defaults to "FATAL". |
|
@param flag Bitfield for control purposes |
|
bit0= use pager (as with result) |
|
bit1= permission to suppress output |
|
@return 1 if message was delivered, <=0 if failure |
|
*/ |
|
int Xorriso_msgs_submit(struct XorrisO *xorriso, |
|
int error_code, char msg_text[], int os_errno, |
|
char severity[], int flag); |
|
|
|
/** Alternative call interface of Xorriso_msgs_submit with void* instead |
|
of struct XorrisO* |
|
*/ |
|
int Xorriso_msgs_submit_void(void *xorriso, |
|
int error_code, char msg_text[], int os_errno, |
|
char severity[], int flag); |
|
|
|
|
|
/** Evaluate an advise whether to abort or whether to go on with option |
|
processing. This should be called after any option function was processed. |
|
It updates the problem status by processing the library message queues |
|
and then it uses this status and the submitted return value of the |
|
option function to evaluate the situation. |
|
@param xorriso The environment handle |
|
@param ret The return value of the previously called option function |
|
@param flag bit0= do not issue own event messages |
|
bit1= take xorriso->request_to_abort as reason for abort |
|
@return Gives the advice: |
|
2= pardon was given, go on |
|
1= no problem, go on |
|
0= function failed but xorriso would not abort, go on |
|
<0= do abort |
|
-1 = due to xorriso->problem_status |
|
or due to ret<0 |
|
-2 = due to xorriso->request_to_abort |
|
*/ |
|
int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag); |
|
|
|
|
|
/** Set the current problem status of the xorriso handle. |
|
@param xorriso The environment handle |
|
@param severity A severity text. Empty text resets to "No Problem". |
|
@param flag Unused yet. Submit 0. |
|
@return <=0 failure (e.g. wrong severity text), 1 success. |
|
*/ |
|
int Xorriso_set_problem_status(struct XorrisO *xorriso, char *severity, |
|
int flag); |
|
|
|
|
|
/* The next three functions are part of Xorriso_eval_problem_status(). |
|
You may use them to build an own advisor function. |
|
*/ |
|
|
|
/** Compare two severity texts for their severeness. |
|
Unknown severity texts get defaulted to "FATAL". |
|
@since 1.2.6 |
|
@param sev1 First severity text to compare |
|
@param sev2 Second severity text to compare |
|
@return -1 sev1 is less severe than sev2 |
|
0 sev1 is equally severe to sev2 |
|
1 sev1 is more severe than sev2 |
|
*/ |
|
int Xorriso__severity_cmp(char *sev1, char *sev2); |
|
|
|
|
|
/** Return a blank separated list of severity names. Sorted from low |
|
to high severity. |
|
@since 1.2.6 |
|
@param flag Bitfield for control purposes (unused yet, submit 0) |
|
@return A constant string with the severity names |
|
*/ |
|
char *Xorriso__severity_list(int flag); |
|
|
|
|
|
|
|
/** Obtain the current problem status of the xorriso handle. |
|
@param xorriso The environment handle |
|
@param severity The severity text matching the current problem status |
|
@param flag Unused yet. Submit 0. |
|
@return The severity rank number. 0= no problem occurred. |
|
*/ |
|
int Xorriso_get_problem_status(struct XorrisO *xorriso, char severity[80], |
|
int flag); |
|
|
|
|
|
/** Forward any pending messages from the library message queues to the |
|
xorriso message system which puts out on info channel. This registers |
|
the severity of the library events like the severity of a message submitted |
|
via Xorriso_msgs_submit(). |
|
xorriso sets the message queues of the libraries to queuing "ALL". |
|
Many inner functions of xorriso call Xorriso_process_msg_queues() on their |
|
own because they expect library output pending. Nevertheless, a loop of |
|
xorriso option calls should either call Xorriso_eval_problem_status() or |
|
Xorriso_process_msg_queues() with each cycle. |
|
@param xorriso The environment handle |
|
@param flag Unused yet. Submit 0. |
|
@return 1 on success, <=0 if failure |
|
*/ |
|
int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/** Write a message for option -errfile_log. |
|
@param xorriso The environment handle |
|
@param error_code The unique error code of your message. |
|
Submit 0 if you do not have reserved error codes within |
|
the libburnia project. |
|
@param msg_text Not more than 8196 characters of message text. |
|
@param os_errno Eventual errno related to the message. Submit 0 if |
|
the message is not related to a operating system error. |
|
@param flag bit0-7= meaning of msg_text |
|
( 0= ERRFILE path , for internal use mainly ) |
|
1= mark line text (only to be put out if enabled) |
|
@return <=0 error , >0 success |
|
*/ |
|
int Xorriso_process_errfile(struct XorrisO *xorriso, |
|
int error_code, char msg_text[], int os_errno, |
|
int flag); |
|
|
|
|
|
/* |
|
Message output evaluation |
|
|
|
xorriso is basically a dialog software which reacts on commands by |
|
side effects and by messages. The side effects manipulate the state of |
|
the ISO image model and of drives. This state can be inquired by commands |
|
which emit messages. |
|
|
|
There are several approaches how a program that uses xorriso via this API |
|
can receive and use the message output of xorriso. |
|
|
|
- The message sieve may be programmed to pick certain information snippets |
|
out of the visible message stream. This covers all messages on the |
|
result channel and those info channel messages which get not suppressed |
|
by command -report_about. All important info messages have severity NOTE |
|
or higher. |
|
Much of the message interpretation is supposed to happen by the sieve |
|
filter rules which describe the interesting message lines and the |
|
positions of the interesting message parts. |
|
The call Xorriso_sieve_big() installs a sieve that looks out for most |
|
model state messages which xorriso can emit. After a few commands |
|
the user will ask the sieve for certain text pieces that might have been |
|
caught. |
|
|
|
- The outlist stack may be used to catch messages in linked lists rather |
|
than putting them out on the message channels. |
|
All interpretation of the messages has to be done by the user of the |
|
xorriso API. Function Xorriso_parse_line() is intended to help with |
|
splitting up messages into words. |
|
The outlist stack is handy for catching the results of information |
|
commands with large uniform output or no well recognizable message |
|
prefix. Like -lsl, -getfacl, -status, -find ... -exec get_md5. |
|
One should push the stack before the command, pull it afterwards, examine |
|
the text list by Xorriso_lst_get_*(), and finally dispose the list. |
|
|
|
- The message watcher is a separate program thread which uses the outlist |
|
stack to catch the messages and to call user provided handler functions. |
|
These functions can use Xorriso_parse_line() too, if they submit the |
|
xorriso parameter as NULL. They may not use the struct XorrisO object |
|
in any way. |
|
Synchronization between watcher and emitters of commands can be achieved |
|
by Xorriso_peek_outlists(). |
|
The main motivation for the message watcher is to inspect and display |
|
messages of long lasting xorriso commands while they are still executing. |
|
E.g. of -commit, -blank, -format. |
|
One would normally start it before such a command and stop it afterwards. |
|
But of course, the watcher can stay activated all the time and process |
|
all message output via its handler calls. |
|
|
|
The message sieve does not interfere with outlists and message watcher. |
|
The message watcher will only see messages which are not caught by outlists |
|
which were enabled after the watcher thread was started. |
|
|
|
*/ |
|
|
|
/* The programmable message sieve picks words out of the program messages |
|
of xorriso. |
|
The sieve is a collection of filter rules. Each one is defined by a call of |
|
Xorriso_sieve_add_filter(). The sieve watches the given output channels for |
|
messages which begin by the given text prefixes of the filters. |
|
Matching lines get split into words by Xorriso_parse_line() using |
|
the given separators. The words described by the filter's word index array |
|
get recorded by the filter and can be inquired by Xorriso_sieve_get_result() |
|
after one or more xorriso commands have been performed. |
|
The recorded results may be disposed by Xorriso_sieve_clear_results without |
|
giving up the sieve. |
|
The whole sieve may be disposed by Xorriso_sieve_dispose(). |
|
Default at library start is an inactive sieve without any filter rules. |
|
*/ |
|
|
|
/** Add a filter rule to the message sieve. |
|
Start watching output messages, if this is not already enabled. |
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param name The filter name by which its recorded results shall |
|
be inquired via Xorriso_sieve_get_result() |
|
@param channels Which of the output channels the filter shall watch |
|
bit0= result channel |
|
bit1= info channel |
|
bit2= mark channel |
|
@param prefix The line start to watch for. Will also be handed over |
|
to Xorriso_parse_line(). Empty text matches all lines. |
|
If the prefix begins by '?' characters, then these |
|
match any character at the beginning of a message. |
|
The prefix of the filter rule will then be adapted |
|
to really match the line, before it gets handed over |
|
to Xorriso_parse_line(). |
|
@param separators List of separator characters for Xorriso_parse_line() |
|
@param num_words Number of word indice in word_idx |
|
@param word_idx Array with the argv indice to be picked from the |
|
the result of Xorriso_parse_line(). Must at least |
|
contain num_words elements. |
|
@param max_results If not 0, then the maximum number of line results that |
|
shall be recorded by the filter. When this number is |
|
exceeded, then results of older lines get discarded |
|
when new results get recorded. |
|
@param flag Bitfield for control purposes |
|
bit0= Last result word shall contain the remainder of |
|
the message line |
|
@return <=0 error , >0 success |
|
*/ |
|
int Xorriso_sieve_add_filter(struct XorrisO *xorriso, char *name, |
|
int channels, char *prefix, char *separators, |
|
int num_words, int *word_idx, int max_results, |
|
int flag); |
|
|
|
|
|
/** Inquire recorded results from a particular filter rule. |
|
@param xorriso The environment handle |
|
@param name The filter name as given by Xorriso_sieve_add_filter() |
|
@param argc Will return the number of allocated and filled word |
|
strings. |
|
@param argv Will return the array of word strings. |
|
Do not forget to dispose the allocated memory by a |
|
call to Xorriso__dispose_words(). |
|
@param available Will return the number of results which are still |
|
available for further calls of Xorriso_sieve_get_result() |
|
with the given name. |
|
@param flag Bitfield for control purposes: |
|
bit0= Reset reading to first matching result. |
|
bit1= Only inquire number of available results. |
|
Do not allocate memory. |
|
bit2= If *argv is not NULL, then free it before attaching |
|
new memory. |
|
bit3= Do not read recorded data but rather list all |
|
filter names. |
|
@return <0 error: -1 = memory shortage |
|
-2 = no filter rule found |
|
0 No more data available for the given name |
|
With bit3: No filter rules installed. |
|
>0 argc and argv are valid |
|
*/ |
|
int Xorriso_sieve_get_result(struct XorrisO *xorriso, char *name, |
|
int *argc, char ***argv, int *available, |
|
int flag); |
|
|
|
|
|
/** Dispose all recorded results. Keep filter rules. Continue watching |
|
and recording. |
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param flag Unused yet. Submit 0. |
|
@return <=0 error , >0 success |
|
*/ |
|
int Xorriso_sieve_clear_results(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/** Dispose all filter rules. End watching and recording. |
|
This is the default state at library startup. |
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param flag Unused yet. Submit 0. |
|
@return <=0 error , >0 success |
|
*/ |
|
int Xorriso_sieve_dispose(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/** Install a large sieve with filters for about any interesting message |
|
of xorriso. The filter rule names are mostly the same as the prefixes they |
|
search for. If you do not find the message prefix of your desire, then |
|
you may add a filter rule by Xorriso_sieve_add_filter(). |
|
If you do not want all these filter any more, call Xorriso_sieve_dispose(). |
|
|
|
You should obtain your recorded data often and then call |
|
Xorriso_sieve_clear_results(). It is nevertheless ok to perform several |
|
different xorriso information commands and to then obtain results from the |
|
sieve. |
|
|
|
The installed filters in particular: |
|
Name Recorded values, returned by Xorriso_sieve_get_result() |
|
------------------------------------------------------------------------ |
|
"-changes_pending" up to 1 result from -changes_pending show_status |
|
argv[0]= "yes" or "no" |
|
"? -dev" up to 10 results from -devices or -device_links |
|
(records drives with single digit index number) |
|
argv[0]= drive address |
|
argv[1]= permissions |
|
argv[2]= drive vendor |
|
argv[3]= product id |
|
"?? -dev" up to 90 results from -devices or -device_links |
|
(records drives with double digit index number) |
|
argv[0]= drive address |
|
argv[1]= permissions |
|
argv[2]= drive vendor |
|
argv[3]= product id |
|
"Abstract File:" up to 1 result from -pvd_info |
|
argv[0]= file name |
|
(Note: prefix is "Abstract File: ") |
|
"After commit :" up to 1 result from -tell_media_space |
|
argv[0]= number of blocks with "s" appended |
|
"App Id :" up to 1 result from -pvd_info |
|
argv[0]= id |
|
(Note: prefix is "App Id : ") |
|
"Biblio File :" up to 1 result from -pvd_info |
|
argv[0]= file name |
|
(Note: prefix is "Biblio File : ") |
|
"Build timestamp :" up to 1 result from -version |
|
argv[0]= timestamp |
|
(Note: prefix is "Build timestamp : ") |
|
"CopyrightFile:" up to 1 result from -pvd_info |
|
argv[0]= file name |
|
(Note: prefix is "CopyrightFile: ") |
|
"Creation Time:" up to 1 result from -pvd_info |
|
argv[0]= YYYYMMDDhhmmsscc |
|
(Note: prefix is "Creation Time: ") |
|
"DVD obs 64 kB:" up to 1 result from -list_extras |
|
argv[0]= "yes" or "no" |
|
"Drive current:" up to 2 results from -dev, -indev, -toc, others |
|
argv[0]= command ("-dev", "-outdev", "-indev") |
|
argv[1]= drive address |
|
"Drive type :" up to 2 results from -toc |
|
argv[0]= vendor |
|
argv[1]= product |
|
argv[2]= revision |
|
"Eff. Time :" up to 1 result from -pvd_info |
|
argv[0]= YYYYMMDDhhmmsscc |
|
(Note: prefix is "EffectiveTime: ") |
|
"Expir. Time :" up to 1 result from -pvd_info |
|
argv[0]= YYYYMMDDhhmmsscc |
|
(Note: prefix is "Expir. Time : ") |
|
"Ext. filters :" up to 1 result from -list_extras |
|
argv[0]= "yes" or "no" , possibly more info |
|
(Note: prefix is "Ext. filters : ") |
|
"File damaged :" up to 10000 results from -find ... -exec report_damage |
|
argv[0]= damage start byte in file |
|
argv[1]= damage range size in file |
|
argv[2]= file size |
|
argv[3]= path in ISO image |
|
"File data lba:" up to 10000 results from -find ... -exec report_lba |
|
argv[0]= extent number (all extents of same path together |
|
are the content of one file) |
|
argv[1]= start block number of extent |
|
argv[2]= number of blocks of extent |
|
argv[3]= overall file content size in all extents |
|
argv[4]= path in ISO image |
|
"Format idx :" up to 100 results from -list_formats |
|
argv[0]= index |
|
argv[1]= MMC code |
|
argv[2]= number of blocks with "s" appended |
|
argv[3]= roughly the size in MiB |
|
(Note: prefix is "Format idx ") |
|
"Format status:" up to 1 result from -list_formats |
|
argv[0]= status |
|
argv[1]= capacity |
|
"ISO session :" up to 10000 results from -toc |
|
argv[0]= Idx |
|
argv[1]= sbsector |
|
argv[2]= Size |
|
argv[3]= Volume Id |
|
"Image size :" up to 1 result from -print_size |
|
argv[0]= number of blocks with "s" appended |
|
"Jigdo files :" up to 1 result from -list_extras |
|
argv[0]= "yes" or "no" |
|
"Local ACL :" up to 1 result from -list_extras |
|
argv[0]= "yes" or "no" |
|
"Local xattr :" up to 1 result from -list_extras |
|
argv[0]= "yes" or "no" |
|
"MD5 MISMATCH:" up to 10000 results from -check_md5* |
|
argv[0]= path of mismatching file |
|
"MD5 tag range:" up to 10000 results from -check_media |
|
argv[0]= lba |
|
argv[1]= size in blocks |
|
argv[2]= result text (starting with "+", "-", or "0") |
|
"Media blocks :" up to 2 results from -toc |
|
argv[0]= readable |
|
argv[1]= writable |
|
argv[2]= overall |
|
"Media current:" up to 2 results from -dev, -indev, -toc, others |
|
argv[0]= media type / MMC profile name |
|
(Note: prefix is "Media current: " which eats extra blank) |
|
"Media nwa :" up to 1 result from -toc |
|
argv[0]= next writable address |
|
"Media product:" up to 2 results from -toc |
|
argv[0]= product id |
|
argv[1]= manufacturer |
|
"Media region :" up to 10000 results from -check_media |
|
argv[0]= lba |
|
argv[1]= size in blocks |
|
argv[2]= quality text (starting with "+", "-", or "0") |
|
"Media space :" up to 1 result from -tell_media_space |
|
argv[0]= number of blocks with "s" appended |
|
"Media status :" up to 2 results from -dev, -indev, -toc, others |
|
argv[0]= status description |
|
(Note: prefix is "Media status : ") |
|
"Media summary:" up to 2 results from -dev, -indev, -toc, others |
|
argv[0]= sessions |
|
argv[1]= data blocks (full count) |
|
argv[2]= data (with unit letter k,m,g) |
|
argv[3]= free (with unit letter k,m,g) |
|
"Modif. Time :" up to 1 result from -pvd_info |
|
argv[0]= YYYYMMDDhhmmsscc |
|
(Note: prefix is "Modif. Time : ") |
|
"PVD address :" up to 1 result from -pvd_info |
|
argv[0]= block address with "s" appended |
|
"Preparer Id :" up to 1 result from -pvd_info |
|
argv[0]= id |
|
(Note: prefix is "Preparer Id : ") |
|
"Profile :" up to 256 results from -list_profiles |
|
argv[0]= MMC code |
|
argv[1]= profile name in round brackets |
|
possibly appended: " (current)" |
|
"Publisher Id :" up to 1 result from -pvd_info |
|
argv[0]= id |
|
(Note: prefix is "Publisher Id : ") |
|
"Readline :" up to 1 result from -list_extras |
|
argv[0]= "yes" or "no" |
|
"Size lower :" up to 1 result from -findx ... -exec estimate_size |
|
argv[0]= size with appended "s" |
|
"Size upper :" up to 1 result from -findx ... -exec estimate_size |
|
argv[0]= size with appended "s" |
|
"System Id :" up to 1 result from -pvd_info |
|
argv[0]= id |
|
(Note: prefix is "System Id : ") |
|
"Version timestamp :" up to 1 result from -version |
|
argv[0]= timestamp |
|
"Volume Id :" up to 1 result from -pvd_info |
|
argv[0]= id |
|
(Note: Not output from -dev or -toc but from -pvd_info) |
|
"Volume Set Id:" up to 1 result from -pvd_info |
|
argv[0]= id |
|
(Note: prefix is "Volume Set Id: ") |
|
"Volume id :" up to 2 results from -dev, -indev, -toc, others |
|
argv[0]= volume id |
|
(Note: Not output from -pvd_info but from -dev or -toc) |
|
"Write speed :" up to 100 results from -list_speeds |
|
argv[0]= kilobytes per second |
|
argv[1]= speed factor |
|
"Write speed H:" up to 1 result from -list_speeds |
|
see "Write speed :" |
|
"Write speed L:" up to 1 result from -list_speeds |
|
see "Write speed :" |
|
"Write speed h:" up to 1 result from -list_speeds |
|
see "Write speed :" |
|
"Write speed l:" up to 1 result from -list_speeds |
|
see "Write speed :" |
|
"libburn in use :" up to 1 result from -version |
|
argv[0]= version text |
|
argv[1]= minimum version requirement |
|
"libburn OS adapter:" up to 1 result from -version |
|
argv[0]= adapter description |
|
(Note: prefix is "libburn OS adapter: ") |
|
"libisoburn in use :" up to 1 result from -version |
|
argv[0]= version text |
|
argv[1]= minimum version requirement |
|
"libisofs in use :" up to 1 result from -version |
|
argv[0]= version text |
|
argv[1]= minimum version requirement |
|
"libjte in use :" up to 1 result from -version |
|
argv[0]= version text |
|
argv[1]= minimum version requirement |
|
"xorriso version :" up to 1 result from -version |
|
argv[0]= version text |
|
"zisofs :" up to 1 result from -list_extras |
|
argv[0]= "yes" or "no" |
|
------------------------------------------------------------------------ |
|
|
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param flag Unused yet. Submit 0. |
|
@return <=0 error , >0 success |
|
*/ |
|
int Xorriso_sieve_big(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/* The outlist stack allows to redirect the info and result messages from |
|
their normal channels into a pair of string lists which can at some |
|
later time be retrieved by the application. |
|
These redirection caches can be stacked to allow stacked applications. |
|
xorriso itself uses them for internal purposes. |
|
|
|
The call Xorriso_start_msg_watcher() starts a concurrent thread which |
|
uses outlists to collect messages and to hand them over by calling |
|
application provided functions. |
|
*/ |
|
|
|
/* A list item able of forming double chained lists */ |
|
struct Xorriso_lsT; |
|
|
|
/** Maximum number of stacked redirections */ |
|
#define Xorriso_max_outlist_stacK 32 |
|
|
|
/** Enable a new redirection of info and/or result channel. The normal message |
|
output and eventual older redirections will not see new messages until |
|
the redirection is ended by a call to Xorriso_pull_outlists() with the |
|
stack_handle value returned by this call. |
|
If Xorriso_option_pkt_output() is set to "on", then it will consolidate |
|
output in the result_list of Xorriso_fetch_outlists() and |
|
Xorriso_pull_outlists(). |
|
@param xorriso The environment handle |
|
@param stack_handle returns an id number which is unique as long as |
|
its redirection is stacked. Do not interpret it and |
|
do not use it after its redirection was pulled from |
|
the stack. |
|
@param flag Bitfield for control purposes |
|
bit0= redirect result channel |
|
bit1= redirect info channel |
|
If bit0 and bit1 are 0, both channels get redirected. |
|
@return 1 on success, <=0 if failure |
|
*/ |
|
int Xorriso_push_outlists(struct XorrisO *xorriso, int *stack_handle, |
|
int flag); |
|
|
|
|
|
/** Obtain the currently collected text messages of redirected info and |
|
result channel. |
|
The messages are handed out as two lists. Both lists have to be disposed |
|
via Xorriso_lst_destroy_all() when they are no longer needed. |
|
The message lists are either NULL or represented by their first |
|
Xorriso_lsT item. |
|
|
|
This call is safe for being used by a concurrent thread while a |
|
xorriso API call is being executed on the same struct XorrisO. |
|
In such a situation, it should not be used with high frequency in order |
|
not to hamper the ongoing xorriso operation by blocking its message |
|
output facility. A hundred times per second should be enough. |
|
|
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param stack_handle An id number returned by Xorriso_push_outlists() |
|
and not yet revoked by Xorriso_pull_outlists(). |
|
Submit -1 to address the most recent valid id. |
|
@param result_list Result and mark messages (usually directed to stdout) |
|
@param info_list Info and mark messages (usually directed to stderr) |
|
@param flag Bitfield for control purposes |
|
bit0= fetch result channel |
|
bit1= fetch info channel |
|
If bit0 and bit1 are 0, both channels get fetched. |
|
@return 1 on success, <=0 if failure |
|
*/ |
|
int Xorriso_fetch_outlists(struct XorrisO *xorriso, int stack_handle, |
|
struct Xorriso_lsT **result_list, |
|
struct Xorriso_lsT **info_list, int flag); |
|
|
|
|
|
/** Inquire whether messages are pending in redirected result and info channel. |
|
This may be used to determine whether a concurrent message watcher already |
|
has obtained all pending messages. |
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param stack_handle An id number returned by Xorriso_push_outlists() |
|
and not yet revoked by Xorriso_pull_outlists(). |
|
Submit -1 to address the most recent valid id. |
|
@param timeout Number of seconds after which to return despite |
|
flag bit 2 |
|
@param flag Bitfield for control purposes |
|
bit0= fetch result channel |
|
bit1= fetch info channel |
|
bit2= wait and retry until return is 0 or -1 |
|
If bit0 and bit1 are 0, both channels get fetched. |
|
@return If > 0: |
|
bit0= messages are pending in outlists |
|
bit1= message watcher is processing fetched messages |
|
Else: |
|
0= no messages are pending anywhere |
|
-1= inappropriate stack_handle |
|
-2= locking failed |
|
*/ |
|
int Xorriso_peek_outlists(struct XorrisO *xorriso, int stack_handle, |
|
int timeout, int flag); |
|
|
|
|
|
/** Disable the redirection given by stack_handle. If it was the current |
|
receiver of messages then switch output to the next older redirection, |
|
or to the normal channels if no redirections are stacked any more. |
|
The messages collected by the disabled redirection are handed out as |
|
two lists. Both lists have to be disposed via Xorriso_lst_destroy_all() |
|
when they are no longer needed. |
|
The message lists are either NULL or represented by their first |
|
Xorriso_lsT item. |
|
@param xorriso The environment handle |
|
@param stack_handle An id number returned by Xorriso_push_outlists() |
|
and not yet revoked by Xorriso_pull_outlists(). |
|
This handle is invalid after the call. |
|
Submit -1 to address the most recent valid id. |
|
@param result_list Result and mark messages (usually directed to stdout) |
|
@param info_list Info and mark messages (usually directed to stderr) |
|
@param flag unused yet, submit 0 |
|
@return 1 on success, <=0 if failure |
|
*/ |
|
int Xorriso_pull_outlists(struct XorrisO *xorriso, int stack_handle, |
|
struct Xorriso_lsT **result_list, |
|
struct Xorriso_lsT **info_list, int flag); |
|
|
|
|
|
/** Redirect output by Xorriso_push_outlists() and start a thread which |
|
fetches this output and performs a call of a given function with each |
|
message that is obtained. |
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param result_handler Pointer to the function which shall be called with |
|
each result message. A NULL pointer causes output |
|
to be directed to stdout or to be interpreted |
|
as -pkt_output format if this is enabled by |
|
Xorriso_option_pkt_output(). |
|
The function should return 1. A return value of -1 |
|
urges not to call again with further lines. |
|
@param result_handle The first argument of (*result_handler)(). It shall |
|
point to a memory object that knows all necessary |
|
external parameters for running (*result_handler)(). |
|
Submit NULL if result_handler is NULL. |
|
@param info_handler Pointer to the function which shall be called with |
|
each info message. A NULL pointer causes output to |
|
be directed to stderr or to -as mkisofs -log-file. |
|
The function should return 1. A return value of -1 |
|
urges not to call again with further lines. |
|
@param info_handle The first argument of (*info_handler)(). It shall |
|
point to a memory object that knows all necessary |
|
external parameters for running (*info_handler)(). |
|
Submit NULL if info_handler is NULL. |
|
@param flag unused yet, submit 0 |
|
@return 1 on success, <=0 if failure (e.g. there is already |
|
a watcher active) |
|
*/ |
|
int Xorriso_start_msg_watcher(struct XorrisO *xorriso, |
|
int (*result_handler)(void *handle, char *text), |
|
void *result_handle, |
|
int (*info_handler)(void *handle, char *text), |
|
void *info_handle, |
|
int flag); |
|
|
|
|
|
/** Revoke output redirection by Xorriso_start_msg_watcher() and end the |
|
watcher thread. If text messages are delivered when Xorriso_pull_outlists() |
|
is called, then they get put out through the active handler functions. |
|
@since 1.2.6 |
|
@param xorriso The environment handle |
|
@param flag Bitfield for control purposes: |
|
bit0= do not issue SORRY message if no message |
|
watcher is active |
|
@return 1 on success, <=0 if failure |
|
*/ |
|
int Xorriso_stop_msg_watcher(struct XorrisO *xorriso, int flag); |
|
|
|
|
|
/** Obtain the text message from the current list item. |
|
@param entry The current list item |
|
@param flag unused yet, submit 0 |
|
@return Pointer to the text content of the list item. |
|
This pointer does not have to be freed. |
|
*/ |
|
char *Xorriso_lst_get_text(struct Xorriso_lsT *entry, int flag); |
|
|
|
|
|
/** Obtain the address of the next item in the chain of messages. |
|
An iteration over the output of Xorriso_pull_outlists() starts at the |
|
returned result_list or info_list and ends when this function returns |
|
NULL. |
|
@param entry The current list item |
|
@param flag unused yet, submit 0 |
|
@return Pointer to the next list item or NULL if end of list. |
|
This pointer does not have to be freed. |
|
*/ |
|
struct Xorriso_lsT *Xorriso_lst_get_next(struct Xorriso_lsT *entry, int flag); |
|
|
|
|
|
/** Obtain the address of the previous item in the chain of messages. |
|
@param entry The current list item |
|
@param flag unused yet, submit 0 |
|
@return Pointer to the previous list item or NULL if start of list. |
|
This pointer does not have to be freed. |
|
*/ |
|
struct Xorriso_lsT *Xorriso_lst_get_prev(struct Xorriso_lsT *entry, int flag); |
|
|
|
|
|
/** Destroy all list items which are directly or indirectly connected to |
|
the given link item. |
|
All pointers obtained by Xorriso_lst_get_text() become invalid by this. |
|
Apply this to each of the two list handles obtained by |
|
Xorriso_pull_outlists() when the lists are no longer needed. |
|
@param lstring *lstring will be freed and set to NULL. |
|
It is not dangerous to submit a pointer to a NULL-pointer. |
|
@param flag unused yet, submit 0 |
|
@return -1= lstring was NULL (i.e. wrong use of this call), |
|
0= *lstring was already NULL, |
|
1= item actually disposed |
|
*/ |
|
int Xorriso_lst_destroy_all(struct Xorriso_lsT **lstring, int flag); |
|
|
|
|
|
|
|
/* ---------------------------- Command API ------------------------ */ |
|
/* See man 1 xorriso for explanation of the particular commands */ |
|
/* |
|
Before each call to a command function, there should happen: |
|
Xorriso_set_problem_status() with empty severity text. |
|
|
|
After each call to a command function, there should happen: |
|
Xorriso_eval_problem_status() |
|
One should follow its eventual advice to abort. |
|
|
|
Commands with a varying number of arguments get then passed like |
|
Xorriso_interpreter(). E.g.: |
|
int Xorriso_option_add(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
The command functions will begin to read the arguments at position *idx |
|
and will see the list end either at the next argv which contains the |
|
-list_delimiter text or at argv[argc-1]. |
|
After the call, *idx will be the index of the first not yet interpreted |
|
argv. |
|
|
|
Do not set any flag bits which are not described by "@param flag". |
|
I.e. if flag is not mentioned, then submit 0. |
|
Yet undefined flag bits might get a meaning in future. Unset bits will |
|
then produce the traditional behavior, whereas set bits might bring |
|
surprises to inadverted callers. |
|
|
|
The API is available |
|
@since 0.5.8 |
|
Earlier "since" marks refer to availability in the command interpreter. |
|
*/ |
|
|
|
|
|
/* Command -abort_on */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_abort_on(struct XorrisO *xorriso, char *severity, int flag); |
|
|
|
/* Command -abstract_file */ |
|
/* @since 0.6.0 */ |
|
int Xorriso_option_abstract_file(struct XorrisO *xorriso, char *name, |
|
int flag); |
|
|
|
/* Command -acl "on"|"off" */ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_acl(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -add */ |
|
/* @param flag bit0=do not report the added item |
|
bit1=do not reset pacifier, no final pacifier message |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_add(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -add_plainly "on"|"off" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_add_plainly(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -alter_date, -alter_date_r */ |
|
/* @param flag bit0=recursive (-alter_date_r) |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_alter_date(struct XorrisO *xorriso, |
|
char *time_type, char *timestring, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -append_partition */ |
|
/* @since 0.6.4 */ |
|
int Xorriso_option_append_partition(struct XorrisO *xorriso, char *partno_text, |
|
char *type_text, char *image_path, int flag); |
|
|
|
/* Command -application_id */ |
|
/* @since 0.3.0 */ |
|
int Xorriso_option_application_id(struct XorrisO *xorriso, char *name, |
|
int flag); |
|
|
|
/* Command -application_use */ |
|
/* @since 1.3.2 */ |
|
int Xorriso_option_application_use(struct XorrisO *xorriso, char *path, |
|
int flag); |
|
|
|
/* Command -as */ |
|
/* @param flag bit0=do not report the added item |
|
bit1=do not reset pacifier, no final pacifier message |
|
*/ |
|
/* @since 0.1.2 */ |
|
int Xorriso_option_as(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -assert_volid */ |
|
/* @since 0.3.2 */ |
|
int Xorriso_option_assert_volid(struct XorrisO *xorriso, char *pattern, |
|
char *severity, int flag); |
|
|
|
/* Command -auto_charset "on"|"off" */ |
|
/* @since 0.3.8 */ |
|
int Xorriso_option_auto_charset(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -backslash_codes */ |
|
/* @since 0.3.0 */ |
|
int Xorriso_option_backslash_codes(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -ban_stdio_write */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_ban_stdio_write(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -biblio_file */ |
|
/* @since 0.6.0 */ |
|
int Xorriso_option_biblio_file(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -blank and -format */ |
|
/* @param flag bit0= format rather than blank |
|
@return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_blank(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -boot_image */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_boot_image(struct XorrisO *xorriso, char *form, |
|
char *treatment, int flag); |
|
|
|
/* Command -calm_drive */ |
|
/* @since 0.4.2 */ |
|
int Xorriso_option_calm_drive(struct XorrisO *xorriso, char *which, int flag); |
|
|
|
/* Command -cd alias -cdi */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_cdi(struct XorrisO *xorriso, char *iso_rr_path, int flag); |
|
|
|
/* Command -cdx */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_cdx(struct XorrisO *xorriso, char *disk_path, int flag); |
|
|
|
/* Command -changes_pending */ |
|
/* @since 1.2.2 */ |
|
int Xorriso_option_changes_pending(struct XorrisO *xorriso, char *state, |
|
int flag); |
|
|
|
/* Commands -charset, -in_charset, -out_charset, -local_charset */ |
|
/* @param flag bit0= set in_charset |
|
bit1= set out_charset |
|
bit2= set local_charset |
|
*/ |
|
/* @since 0.3.0 */ |
|
int Xorriso_option_charset(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -check_md5 and -check_md5_r |
|
@param flag bit0= issue summary message |
|
bit1= do not reset pacifier, no final pacifier message |
|
bit2= do not issue pacifier messages at all |
|
bit3= recursive: -check_md5_r |
|
*/ |
|
/* @since 0.4.2 */ |
|
int Xorriso_option_check_md5(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -check_media */ |
|
/* @since 0.2.4 */ |
|
int Xorriso_option_check_media(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -check_media_defaults */ |
|
/* @since 0.2.6 */ |
|
int Xorriso_option_check_media_defaults(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -chgrp alias -chgrpi , chgrp_r alias chgrp_ri */ |
|
/* @param flag bit0=recursive (-chgrp_r) |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_chgrpi(struct XorrisO *xorriso, char *gid, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -chmod alias -chmodi , -chmod_r alias chmod_ri */ |
|
/* @param flag bit0=recursive (-chmod_r) |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_chmodi(struct XorrisO *xorriso, char *mode, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -chown alias -chowni , chown_r alias chown_ri */ |
|
/* @param flag bit0=recursive (-chown_r) |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_chowni(struct XorrisO *xorriso, char *uid, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -clone */ |
|
/* @since 1.0.2 */ |
|
int Xorriso_option_clone(struct XorrisO *xorriso, char *origin, char *dest, |
|
int flag); |
|
|
|
/* Command -close "on"|"off"| @since 1.3.4 "as_needed" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_close(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -close_damaged */ |
|
/* @since 1.1.0 */ |
|
int Xorriso_option_close_damaged(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -close_filter_list */ |
|
/* @since 0.3.8 */ |
|
int Xorriso_option_close_filter_list(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -commit */ |
|
/* @param flag bit0= leave indrive and outdrive acquired as they were, |
|
i.e. do not acquire outdrive as new in-out-drive |
|
bit1= do not perform eventual -reassure |
|
@return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_commit(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -commit_eject */ |
|
/* @return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_commit_eject(struct XorrisO *xorriso, char *which, int flag); |
|
|
|
/* Command -compare and -compare_r |
|
@param flag bit0= issue summary message |
|
bit1= do not reset pacifier, no final pacifier message |
|
bit2= do not issue pacifier messages at all |
|
bit3= recursive: -compare_r |
|
*/ |
|
/* @since 0.1.2 */ |
|
int Xorriso_option_compare(struct XorrisO *xorriso, char *disk_path, |
|
char *iso_path, int flag); |
|
|
|
/* Command -compliance */ |
|
/* @since 0.3.0 */ |
|
int Xorriso_option_compliance(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -concat */ |
|
/* @since 1.3.8 */ |
|
int Xorriso_option_concat(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -copyright_file */ |
|
/* @since 0.6.0 */ |
|
int Xorriso_option_copyright_file(struct XorrisO *xorriso, char *name, |
|
int flag); |
|
|
|
/* Command -cp_clone */ |
|
/* @since 1.0.2 */ |
|
int Xorriso_option_cp_clone(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -cpr alias -cpri */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_cpri( struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -cpx , -cpax, -cp_rx , -cp_rax */ |
|
/* @param flag bit0= recursive (-cp_rx, -cp_rax) |
|
@since 0.2.0 |
|
bit1= full property restore (-cpax, -cp_rax) |
|
@since 0.2.0 |
|
*/ |
|
/* @since 0.1.8 */ |
|
int Xorriso_option_cpx(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -cut_out */ |
|
/* @since 0.1.2 */ |
|
int Xorriso_option_cut_out(struct XorrisO *xorriso, char *disk_path, |
|
char *start, char *count, char *iso_rr_path, int flag); |
|
|
|
/* Command -dev , -indev, -outdev */ |
|
/* @param flag bit0=use as indev , bit1= use as outdev |
|
@return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_dev(struct XorrisO *xorriso, char *adr, int flag); |
|
|
|
/* Command -data_cache_size */ |
|
/* @since 1.2.2 */ |
|
int Xorriso_option_data_cache_size(struct XorrisO *xorriso, char *num_tiles, |
|
char *tile_blocks, int flag); |
|
|
|
/* Command -devices */ |
|
/* @param flag bit0= perform -device_links rather than -devices |
|
@since 1.1.4 |
|
@return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_devices(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -dialog "on"|"off" */ |
|
/* @since 0.2.8 */ |
|
/* (since 0.1.0 there was -dialog and -dialog_reset without arg) */ |
|
int Xorriso_option_dialog(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -disk_dev_ino "on"|"off" */ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_disk_dev_ino(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -disk_pattern "on"|"ls"|"off" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_disk_pattern(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -displacement [-]offset */ |
|
/* @since 0.6.6 */ |
|
int Xorriso_option_displacement(struct XorrisO *xorriso, char *value, |
|
int flag); |
|
|
|
/* Command -drive_class */ |
|
/* @since 0.3.2 */ |
|
int Xorriso_option_drive_class(struct XorrisO *xorriso, |
|
char *d_class, char *pattern, int flag); |
|
|
|
/* Command -dummy "on"|"off" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_dummy(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -dvd_obs "default"|"32k"|"64k" */ |
|
/* @since 0.4.8 */ |
|
int Xorriso_option_dvd_obs(struct XorrisO *xorriso, char *obs, int flag); |
|
|
|
/* Command -early_stdio_test */ |
|
/* @since 1.0.6 */ |
|
int Xorriso_option_early_stdio_test(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -ecma119_map */ |
|
/* @since 1.4.2 */ |
|
int Xorriso_option_ecma119_map(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -eject */ |
|
/* @param flag bit0=do not report toc of eventually remaining drives |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_eject(struct XorrisO *xorriso, char *which, int flag); |
|
|
|
/* Command -end , and -rollback_end */ |
|
/* @param flag bit0= discard pending changes |
|
@return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_end(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -errfile_log marked|plain path|-|"" */ |
|
/* @since 0.1.2 */ |
|
int Xorriso_option_errfile_log(struct XorrisO *xorriso, |
|
char *mode, char *path, int flag); |
|
|
|
/* Command -error_behavior */ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_error_behavior(struct XorrisO *xorriso, |
|
char *occasion, char *behavior, int flag); |
|
|
|
/* Command -external_filter */ |
|
/* @since 0.3.8 */ |
|
int Xorriso_option_external_filter(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -extract , -extract_single */ |
|
/* @param flag bit0=do not report the restored item |
|
bit1=do not reset pacifier, no final pacifier message |
|
bit5= -extract_single: do not insert directory tree |
|
*/ |
|
/* @since 0.2.0 */ |
|
int Xorriso_option_extract(struct XorrisO *xorriso, char *disk_path, |
|
char *iso_path, int flag); |
|
|
|
/* Command -extract_cut */ |
|
/* @since 0.2.6 */ |
|
int Xorriso_option_extract_cut(struct XorrisO *xorriso, char *iso_rr_path, |
|
char *start, char *count, char *disk_path, int flag); |
|
|
|
/* Command -file_name_limit */ |
|
/* @since 1.4.2 */ |
|
int Xorriso_option_file_name_limit(struct XorrisO *xorriso, char *value, |
|
int flag); |
|
|
|
/* Command -file_size_limit */ |
|
/* @since 0.2.6 */ |
|
int Xorriso_option_file_size_limit(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
|
|
/* Command -find alias -findi, and -findx */ |
|
/* @param flag bit0= -findx rather than -findi |
|
bit1= do not reset pacifier, no final pacifier message |
|
do not reset find_compare_result |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_find(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -follow */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_follow(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -for_backup is a shortcut for |
|
Xorriso_option_hardlinks(xorriso, "on", 0); |
|
Xorriso_option_acl(xorriso, "on", 0); |
|
Xorriso_option_xattr(xorriso, "on", 0); |
|
Xorriso_option_md5(xorriso, "on", 0); |
|
*/ |
|
/* @since 0.4.0 */ |
|
|
|
/* Command -fs */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_fs(struct XorrisO *xorriso, char *size, int flag); |
|
|
|
/* Commands -getfacl alias -getfacli, -getfacl_r alias -getfacl_ri |
|
-getfattr alias getfattri |
|
*/ |
|
/* @param flag bit0=recursive -getfacl_r |
|
bit1= getfattr rather than getfacl |
|
bit3= with bit1: do not ignore eventual non-user attributes |
|
*/ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_getfacli(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -gid */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_gid(struct XorrisO *xorriso, char *gid, int flag); |
|
|
|
/* Command -grow_blindly */ |
|
/* @since 0.2.2 */ |
|
int Xorriso_option_grow_blindly(struct XorrisO *xorriso, char *msc2, int flag); |
|
|
|
/* Command -hardlinks "on"|"off" */ |
|
/* @since 0.4.0 */ |
|
int Xorriso_option_hardlinks(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -help and part of -prog_help */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_help(struct XorrisO *xorriso, int flag); |
|
|
|
/* Option -hfsplus "on"|"off" */ |
|
/* @since 1.2.4 */ |
|
int Xorriso_option_hfsplus(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -hide */ |
|
/* @since 0.6.0 */ |
|
int Xorriso_option_hide(struct XorrisO *xorriso, char *hide_state, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -history */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_history(struct XorrisO *xorriso, char *line, int flag); |
|
|
|
/* Command -iso_rr_pattern "on"|"ls"|"off" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -jigdo aspect argument */ |
|
/* @since 0.6.4 */ |
|
int Xorriso_option_jigdo(struct XorrisO *xorriso, char *aspect, char *arg, |
|
int flag); |
|
|
|
/* Command -joliet "on"|"off" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -launch_frontend */ |
|
/* @since 1.2.6 */ |
|
int Xorriso_option_launch_frontend(struct XorrisO *xorriso, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -list_arg_sorting */ |
|
/* @since 1.2.2 */ |
|
int Xorriso_option_list_arg_sorting(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -list_delimiter */ |
|
/* @since 0.2.6 */ |
|
int Xorriso_option_list_delimiter(struct XorrisO *xorriso, char *text, |
|
int flag); |
|
|
|
/* Command -list_extras */ |
|
/* @since 1.1.6 */ |
|
int Xorriso_option_list_extras(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -list_formats */ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_list_formats(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -list_profiles */ |
|
/* @since 0.4.2 */ |
|
int Xorriso_option_list_profiles(struct XorrisO *xorriso, char *which, |
|
int flag); |
|
|
|
/* Command -list_speeds */ |
|
/* @since 1.1.2 */ |
|
int Xorriso_option_list_speeds(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -lns alias -lnsi */ |
|
/* @since 1.2.6 */ |
|
int Xorriso_option_lnsi(struct XorrisO *xorriso, char *target, char *path, |
|
int flag); |
|
|
|
/* Command -load session|track|sbsector value */ |
|
/* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high |
|
@return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_load(struct XorrisO *xorriso, char *adr_mode, |
|
char *adr_value, int flag); |
|
|
|
/* Command -logfile */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_logfile(struct XorrisO *xorriso, char *channel, |
|
char *fileadr, int flag); |
|
|
|
/* Command -ls alias -lsi and -lsl alias -lsli |
|
and -lsd alias -lsdi and -lsdl alias -lsdli |
|
and -du alias -dui and -dus alias -dusi |
|
@param flag bit0= long format (-lsl , -du, not -dus, not -ls) |
|
bit1= do not expand patterns but use literally |
|
bit2= -du rather than -ls |
|
bit3= list directories as themselves (-lsd) |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_lsi(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -lsx, -lslx, -lsdx , -lsdlx , -dux , -dusx |
|
@param flag bit0= long format (-lslx , -dux) |
|
bit1= do not expand patterns but use literally |
|
bit2= du rather than ls |
|
bit3= list directories as themselves (ls -d) |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Commandis -map , -map_single */ |
|
/* @param flag bit0=do not report the added item |
|
bit1=do not reset pacifier, no final pacifier message |
|
bit5= -map_single: do not insert directory tree |
|
*/ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_map(struct XorrisO *xorriso, char *disk_path, |
|
char *iso_path, int flag); |
|
|
|
/* Command -map_l , -compare_l , -update_l , -extract_l */ |
|
/* @param flag bit8-11= mode 0= -map_l |
|
1= -compare_l |
|
2= -update_l |
|
3= -extract_l |
|
*/ |
|
/* @since 0.2.0 */ |
|
int Xorriso_option_map_l(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -mark */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag); |
|
|
|
/* Command -md5 */ |
|
/* @since 0.4.2 */ |
|
int Xorriso_option_md5(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -mkdir alias -mkdiri */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_mkdiri(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -modesty_on_drive */ |
|
/* @since 1.4.2 */ |
|
int Xorriso_option_modesty_on_drive(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -mount , -mount_cmd , -session_string */ |
|
/* @param bit0= -mount_cmd: print mount command to result channel rather |
|
than performing it |
|
bit1= perform -session_string rather than -mount_cmd |
|
*/ |
|
/* @since 0.3.2 */ |
|
int Xorriso_option_mount(struct XorrisO *xorriso, char *dev, char *adr_mode, |
|
char *adr, char *cmd, int flag); |
|
|
|
/* Command -mount_opts option[:...] */ |
|
/* @since 0.4.4 */ |
|
int Xorriso_option_mount_opts(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -move */ |
|
/* @since 1.2.8 */ |
|
int Xorriso_option_move(struct XorrisO *xorriso, char *origin, char *dest, |
|
int flag); |
|
|
|
/* Command -msg_op */ |
|
/* @since 1.2.6 */ |
|
int Xorriso_option_msg_op(struct XorrisO *xorriso, char *what, char *arg, |
|
int flag); |
|
|
|
/* Command -mv alias -mvi */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Option -named_pipe_loop */ |
|
/* @since 1.3.2 */ |
|
int Xorriso_option_named_pipe_loop(struct XorrisO *xorriso, char *mode, |
|
char *stdin_pipe, char *stdout_pipe, |
|
char *stderr_pipe, int flag); |
|
|
|
/* Command -no_rc */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -not_leaf , -as mkisofs -hide without '/' */ |
|
/* @param flag bit0= add to iso_rr hide list rather than to disk exclusions |
|
@since 0.6.0 |
|
bit1= add to joliet hide list rather than disk exclusions |
|
@since 0.6.0 |
|
bit2= add to HFS+ hide list rather than disk exclusions |
|
@since 1.2.4 |
|
*/ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag); |
|
|
|
/* Command -not_list , -quoted_not_list */ |
|
/* @param flag bit0= -quoted_not_list |
|
@since 0.3.0 |
|
*/ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag); |
|
|
|
/* Command -not_mgt */ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_not_mgt(struct XorrisO *xorriso, char *setting, int flag); |
|
|
|
/* Command -not_paths , -as mkisofs -hide with '/' */ |
|
/* @param flag bit0= add to iso_rr hide list rather than to disk exclusions |
|
@since 0.6.0 |
|
bit1= add to joliet hide list rather than disk exclusions |
|
@since 0.6.0 |
|
bit2= enable disk pattern expansion regardless of -disk_pattern |
|
bit8-13= consolidated hide state bits, duplicating bit0-1 |
|
@since 1.2.4 |
|
bit8= add to iso_rr_hidings, same as bit0 |
|
bit9= add to joliet_hidings, same as bit1 |
|
bit10= add to hfsplus_hidings |
|
*/ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -options_from_file */ |
|
/* @return <=0 error , 1 = success , 3 = request to end program run */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_options_from_file(struct XorrisO *xorriso, char *adr, |
|
int flag); |
|
|
|
/* Command -osirrox "on"|"off" */ |
|
/* @since 0.1.8 */ |
|
int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -overwrite "on"|"nondir"|"off" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -pacifier */ |
|
/* @since 0.2.2 */ |
|
int Xorriso_option_pacifier(struct XorrisO *xorriso, char *style, int flag); |
|
|
|
/* Command -padding */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_padding(struct XorrisO *xorriso, char *size, int flag); |
|
|
|
/* Command -page */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_page(struct XorrisO *xorriso, int len, int width, int flag); |
|
|
|
/* Command -paste_in */ |
|
/* @since 0.2.0 */ |
|
int Xorriso_option_paste_in(struct XorrisO *xorriso, char *iso_rr_path, |
|
char *disk_path, char *start, char *count, int flag); |
|
|
|
/* Command -path_list , -quoted_path_list */ |
|
/* @param flag bit0= -quoted_path_list @since 0.3.0 |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_path_list(struct XorrisO *xorriso, char *adr, int flag); |
|
|
|
/* Command -pathspecs */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_pathspecs(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -pkt_output */ |
|
/* Note: If output is redirected by Xorriso_push_outlists() then mode "on" |
|
consolidates output in the result output list, not on stdout. |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_pkt_output(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -preparer_id */ |
|
/* @since 0.6.2 */ |
|
int Xorriso_option_preparer_id(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -print, -print_info , -print_mark */ |
|
/* @param flag bit0-1= output channel: |
|
0= result channel |
|
1= info channel @since 1.0.6 |
|
2= mark channel @since 1.0.6 |
|
*/ |
|
/* @since 1.0.6 */ |
|
int Xorriso_option_print(struct XorrisO *xorriso, char *text, int flag); |
|
|
|
/* Command -print_size |
|
@param flag bit0= report in mkisofs compatible form on real stdout |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_print_size(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -prog */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_prog(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -prompt */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_prompt(struct XorrisO *xorriso, char *text, int flag); |
|
|
|
/* Command -prog_help */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_prog_help(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -publisher */ |
|
/* @since 0.1.2 */ |
|
int Xorriso_option_publisher(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -pvd_info */ |
|
/* @since 0.4.4 */ |
|
int Xorriso_option_pvd_info(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -pwd alias -pwdi */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_pwdi(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -pwdx */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_pwdx(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -read_fs */ |
|
/* @since 1.4.2 */ |
|
int Xorriso_option_read_fs(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -read_mkisofsrc */ |
|
/* @since 0.6.0 */ |
|
int Xorriso_option_read_mkisofsrc(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -reassure "on"|"tree"|"off" */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_reassure(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -report_about */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_report_about(struct XorrisO *xorriso, char *severity, |
|
int flag); |
|
|
|
/* Command -report_el_torito */ |
|
/* @since 1.3.8 */ |
|
int Xorriso_option_report_el_torito(struct XorrisO *xorriso, |
|
char *form, int flag); |
|
|
|
/* Command -report_system_area */ |
|
/* @since 1.3.8 */ |
|
int Xorriso_option_report_system_area(struct XorrisO *xorriso, |
|
char *form, int flag); |
|
|
|
/* Command -return_with */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_return_with(struct XorrisO *xorriso, char *severity, |
|
int exit_value, int flag); |
|
|
|
/* Command -rm alias -rmi , -rm_r alias -rm_ri , -rmdir alias -rmdiri */ |
|
/* @param flag bit0=recursive |
|
bit2= remove empty directory: rmdiri |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_rmi(struct XorrisO *xorriso, int argc, char **argv, |
|
int *idx, int flag); |
|
|
|
/* Command -rockridge "on"|"off" */ |
|
/* @since 1.2.4 */ |
|
int Xorriso_option_rockridge(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -rollback */ |
|
/* @param flag bit0= do not -reassure |
|
@return <=0 error , 1 success, 2 revoked by -reassure |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_rollback(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -rom_toc_scan */ |
|
/* @since 0.1.6 */ |
|
int Xorriso_option_rom_toc_scan(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -rr_reloc_dir */ |
|
/* @since 1.2.2 */ |
|
int Xorriso_option_rr_reloc_dir(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -scdbackup_tag */ |
|
/* @since 0.4.4 */ |
|
int Xorriso_option_scdbackup_tag(struct XorrisO *xorriso, char *list_path, |
|
char *record_name, int flag); |
|
|
|
/* Command -scsi_dev_family */ |
|
/* @since 1.4.4 */ |
|
int Xorriso_option_scsi_dev_family(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -scsi_log */ |
|
/* @since 0.5.0 */ |
|
int Xorriso_option_scsi_log(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -session_log */ |
|
/* @since 0.1.4 */ |
|
int Xorriso_option_session_log(struct XorrisO *xorriso, char *path, int flag); |
|
|
|
/* Command -setfacl_list alias -setfacl_listi */ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_setfacl_listi(struct XorrisO *xorriso, char *disk_path, |
|
int flag); |
|
|
|
/* Command -setfacl alias -setfacli , -setfacl_r alias -setfacl_ri */ |
|
/* @param flag bit0=recursive -setfacl_r */ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_setfacli(struct XorrisO *xorriso, char *acl_text, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -setfattr alias -setfattri, -setfattr_r alias -setfattr_ri */ |
|
/* @param flag bit0=recursive -setfattr_r */ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_setfattri(struct XorrisO *xorriso, char *name, char *value, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Command -setfattr_list alias -setfattr_listi */ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_setfattr_listi(struct XorrisO *xorriso, char *path, |
|
int flag); |
|
|
|
/* Command -set_filter , -set_filter_r , -show_stream , -show_stream_r */ |
|
/* @param flag bit0=recursive -set_filter_r |
|
bit1= do not reset pacifier, no final pacifier message |
|
bit2= -show_stream rather than -set_filter |
|
*/ |
|
/* @since 0.3.8 */ |
|
int Xorriso_option_set_filter(struct XorrisO *xorriso, char *name, |
|
int argc, char **argv, int *idx, int flag); |
|
|
|
/* Option -sh_style_result */ |
|
/* @since 1.3.2 */ |
|
int Xorriso_option_sh_style_result(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -signal_handling */ |
|
/* @param flag bit0= do not yet install the eventual handler |
|
@since 1.1.0 |
|
*/ |
|
int Xorriso_option_signal_handling(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -sleep */ |
|
/* @since 1.1.8 */ |
|
int Xorriso_option_sleep(struct XorrisO *xorriso, char *duration, int flag); |
|
|
|
/* Command -speed , -read_speed */ |
|
/* @param flag bit0= @since 1.3.4 |
|
-read_speed rather than -speed */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_speed(struct XorrisO *xorriso, char *speed, int flag); |
|
|
|
/* Command -split_size */ |
|
/* @since 0.1.4 */ |
|
int Xorriso_option_split_size(struct XorrisO *xorriso, char *s, int flag); |
|
|
|
/* Command -status */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_status(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -status_history_max */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_status_history_max(struct XorrisO *xorriso, int num1, |
|
int flag); |
|
|
|
/* Command -stdio_sync "on"|"off"|"end"|size */ |
|
/* @since 0.4.6 */ |
|
int Xorriso_option_stdio_sync(struct XorrisO *xorriso, char *rythm, int flag); |
|
|
|
/* Command -stream_recording */ |
|
/* @since 0.1.8 */ |
|
int Xorriso_option_stream_recording(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -system_id */ |
|
/* @since 0.4.4 */ |
|
int Xorriso_option_system_id(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -tell_media_space */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_tell_media_space(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -temp_mem_limit */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_temp_mem_limit(struct XorrisO *xorriso, char *size, |
|
int flag); |
|
|
|
/* Command -toc */ |
|
/* @param flag bit0= short report form as with -dev, no table-of-content |
|
*/ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_toc(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -toc_of */ |
|
/* @since 1.2.6 */ |
|
int Xorriso_option_toc_of(struct XorrisO *xorriso, char *which, int flag); |
|
|
|
/* Command -uid */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_uid(struct XorrisO *xorriso, char *uid, int flag); |
|
|
|
/* Command -unregister_filter */ |
|
/* @since 0.3.8 */ |
|
int Xorriso_option_unregister_filter(struct XorrisO *xorriso, char *name, |
|
int flag); |
|
|
|
/* Command -update and -update_r |
|
@param flag bit0= issue summary message |
|
bit1= do not reset pacifier, no final pacifier message |
|
bit2= do not issue pacifier messages at all |
|
bit3= recursive: -update_r |
|
*/ |
|
/* @since 0.1.2 */ |
|
int Xorriso_option_update(struct XorrisO *xorriso, char *disk_path, |
|
char *iso_path, int flag); |
|
|
|
/* Command -use_readline */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_use_readline(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -use_immed_bit */ |
|
/* @since 1.4.6 */ |
|
int Xorriso_option_use_immed_bit(struct XorrisO *xorriso, char *mode, |
|
int flag); |
|
|
|
/* Command -version */ |
|
/* @since 0.1.0 */ |
|
int Xorriso_option_version(struct XorrisO *xorriso, int flag); |
|
|
|
/* Command -volid */ |
|
/* @param flag bit0= do not warn of problematic volid |
|
*/ |
|
int Xorriso_option_volid(struct XorrisO *xorriso, char *volid, int flag); |
|
|
|
/* Command -volset_id */ |
|
/* @since 0.4.4 */ |
|
int Xorriso_option_volset_id(struct XorrisO *xorriso, char *name, int flag); |
|
|
|
/* Command -volume_date */ |
|
/* @since 0.5.4 */ |
|
int Xorriso_option_volume_date(struct XorrisO *xorriso, |
|
char *time_type, char *timestring, int flag); |
|
|
|
/* Command -write_type */ |
|
/* @since 1.2.4 */ |
|
int Xorriso_option_write_type(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* There is no Xorriso_option_x() because -x has an effect only in |
|
Xorriso_prescan_args(). Use the flag bits of Xorriso_interpreter() if |
|
you want to impose command sorting on your own. |
|
@since 1.2.2 |
|
*/ |
|
|
|
/* Command -xattr "on"|"off" */ |
|
/* @since 0.3.4 */ |
|
int Xorriso_option_xattr(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
/* Command -zisofs */ |
|
/* @since 0.3.8 */ |
|
int Xorriso_option_zisofs(struct XorrisO *xorriso, char *mode, int flag); |
|
|
|
#ifdef __cplusplus |
|
} /* extern "C" */ |
|
#endif |
|
|
|
#endif /* Xorriso_includeD */ |
|
|
|
|
|
|