legacy/libisoburn/branches/ZeroTwoEight/xorriso/xorrisoburn.h

/* Adapter to libisoburn, libisofs and libburn for xorriso,
   a command line oriented batch and dialog tool which creates, loads,
   manipulates and burns ISO 9660 filesystem images.

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

   Provided under GPL version 2.

   This file contains the inner isofs- and burn-library interface of xorriso.
*/

#ifndef Xorrisoburn_includeD
#define Xorrisoburn_includeD yes


/* The minimum version of libisoburn to be used with this version of xorriso
*/
#define xorriso_libisoburn_req_major  0
#define xorriso_libisoburn_req_minor  2
#define xorriso_libisoburn_req_micro  8

int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);

/* @param flag bit0= global shutdown of libraries */
int Xorriso_detach_libraries(struct XorrisO *xorriso, int flag);

int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag);

/* @param flag bit0=aquire as isoburn input drive
               bit1=aquire as libburn output drive (as isoburn drive if bit0)
   @return <=0 failure , 1=success , 2=neither readable or writeable
*/
int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag);

int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag);

int Xorriso_write_session(struct XorrisO *xorriso, int flag);

/* @param boss_iter Opaque handle to be forwarded to actions in ISO image
                    Set to NULL if calling this function from outside ISO world
   @param flag bit0= mkdir: graft in as empty directory, not as copy from disk
               bit1= do not report added files
   @return <=0 = error , 1 = added simple node , 2 = added directory 
*/
int Xorriso_graft_in(struct XorrisO *xorriso, void *boss_iter,       
                     char *disk_path, char *img_path,
                     off_t offset, off_t cut_size, int flag);

int Xorriso__text_to_sev(char *severity_name, int *severity_number,int flag);

/* @param flag bit0=report about output drive 
               bit1=short report form
*/
int Xorriso_toc(struct XorrisO *xorriso, int flag);

int Xorriso_show_devices(struct XorrisO *xorriso, int flag);

int Xorriso_tell_media_space(struct XorrisO *xorriso,
                             int *media_space, int *free_space, int flag);

/* @param flag bit0=fast , bit1=deformat
   @return 0=failure, did not touch media , -1=failure, altered media
           1=success, altered media       ,  2=success, did not touch media
*/
int Xorriso_blank_media(struct XorrisO *xorriso, int flag);

/* @param flag bit0= try to achieve faster formatting
   @return 0=failure, did not touch media , -1=failure, altered media
           1=success, altered media       ,  2=success, did not touch media
*/
int Xorriso_format_media(struct XorrisO *xorriso, int flag);

/* @return <=0 error, 1 success
*/
int Xorriso_list_formats(struct XorrisO *xorriso, int flag);

/* @param flag bit2= formatting rather than blanking
   @return 0=failure, did not touch media , -1=failure, altered media
           1=success, altered media       ,  2=success, did not touch media
*/ 
int Xorriso_blank_as_needed(struct XorrisO *xorriso, int flag);


/* @param boss_iter  Opaque internal handle. Use NULL outside xorrisoburn.c :
               If not NULL then this is an iterator suitable for
               iso_dir_iter_remove() which is then to be used instead
               of iso_node_remove().
   @param flag bit0= remove whole sub tree: rm -r
               bit1= remove empty directory: rmdir
               bit2= recursion: do not reassure in mode 2 "tree"
               bit3= this is for overwriting and not for plain removal
   @return   <=0 = error
               1 = removed simple node
               2 = removed directory or tree
               3 = did not remove on user revocation
*/
int Xorriso_rmi(struct XorrisO *xorriso, void *boss_iter, off_t boss_mem,
                char *path, int flag);

/* @param flag bit0= long format
               bit1= do not print count of nodes
               bit2= du format
               bit3= print directories as themselves (ls -d)
*/
int Xorriso_ls_filev(struct XorrisO *xorriso, char *wd, 
                     int filec, char **filev, off_t boss_mem, int flag);

/* This function needs less buffer memory than Xorriso_ls_filev() but cannot
   perform structured pattern matching.
   @param flag bit0= long format
               bit1= only check for directory existence
               bit2= do not apply search pattern but accept any file
               bit3= just count nodes and return number
*/
int Xorriso_ls(struct XorrisO *xorriso, int flag);

/* @param wd        Path to prepend in case img_path is not absolute
   @param img_path  Absolute or relative path to be normalized
   @param eff_path  returns resulting effective path.
                    Must provide at least SfileadrL bytes of storage.
   @param flag bit0= do not produce problem events (unless faulty path format)
               bit1= work purely literally, do not use libisofs
               bit2= (with bit1) this is an address in the disk world
   @return -1 = faulty path format, 0 = not found ,
            1 = found simple node , 2 = found directory
*/
int Xorriso_normalize_img_path(struct XorrisO *xorriso, char *wd,
                               char *img_path, char eff_path[], int flag);

/* @param boss_iter Opaque handle to be forwarded to actions in ISO image
                    Set to NULL if calling this function from outside ISO world
*/
int Xorriso_rename(struct XorrisO *xorriso, void *boss_iter,
                   char *origin, char *dest, int flag);

/* @param flag bit0= do not produce info message on success
   @return 1=success, 0=was already directory, -1=was other type, -2=bad path
*/
int Xorriso_mkdir(struct XorrisO *xorriso, char *img_path, int flag);

/* @param flag bit0= a match count !=1 is a SORRY event */
int Xorriso_expand_pattern(struct XorrisO *xorriso,
                           int num_patterns, char **patterns, int extra_filec,
                           int *filec, char ***filev, off_t *mem, int flag);

int Xorriso_set_st_mode(struct XorrisO *xorriso, char *path,
                        mode_t mode_and, mode_t mode_or, int flag);

int Xorriso_set_uid(struct XorrisO *xorriso, char *in_path, uid_t uid,
                    int flag);

int Xorriso_set_gid(struct XorrisO *xorriso, char *in_path, gid_t gid,
                    int flag);

/* @parm flag  bit0= atime, bit1= ctime, bit2= mtime, bit8=no auto ctime */
int Xorriso_set_time(struct XorrisO *xorriso, char *in_path, time_t t,
                    int flag);

/* @param flag bit0= recursion
               bit1= do not count deleted files with rm and rm_r
*/
int Xorriso_findi(struct XorrisO *xorriso, struct FindjoB *job,
                  void *boss_iter, off_t boss_mem,
                  void *dir_node_generic, char *dir_path,
                  struct stat *dir_stbuf, int depth, int flag);

/* @param flag bit0= do not mark image as changed */
int Xorriso_set_volid(struct XorrisO *xorriso, char *volid, int flag);

int Xorriso_get_volid(struct XorrisO *xorriso, char volid[33], int flag);

int Xorriso_set_abort_severity(struct XorrisO *xorriso, int flag);

int Xorriso_report_lib_versions(struct XorrisO *xorriso, int flag);

/* @return 0= stbuf content is valid ,
          -1 = path not found , -2 = severe error occured
*/
int Xorriso_iso_lstat(struct XorrisO *xorriso, char *path, struct stat *stbuf,
                      int flag);

/* @param flag bit0= -inq
               bit1= -checkdrive
*/
int Xorriso_atip(struct XorrisO *xorriso, int flag);

/* @param write_start_address  is valid if >=0 
   @param tsize is valid if >0
   @param flag bit0= grow_overwriteable_iso
               bit1= do_isosize
*/
int Xorriso_burn_track(struct XorrisO *xorriso, off_t write_start_address,
                       char *track_source, off_t tsize, int flag);

/* @param flag bit1= outdev rather than indev
   @return <=0 = failure , 1= ok , 2= ok, is CD profile
*/ 
int Xorriso_get_profile(struct XorrisO *xorriso, int *profile_number,
                        char profile_name[80], int flag);

/* @param flag bit0= do not mark image as changed */
int Xorriso_set_publisher(struct XorrisO *xorriso, char *name, int flag);


/* @param flag bit0= node_pt is a valid ISO object handle, ignore pathname
*/
int Xorriso_iso_file_open(struct XorrisO *xorriso, char *pathname,
                          void *node_pt, void **stream, int flag);

int Xorriso_iso_file_read(struct XorrisO *xorriso, void *stream, char *buf,
                          int count, int flag);

int Xorriso_iso_file_close(struct XorrisO *xorriso, void **stream, int flag);

/* @param bit0= copy link target properties rather than link properties
*/
int Xorriso_copy_properties(struct XorrisO *xorriso,
                            char *disk_path, char *img_path, int flag);

int Xorriso_cut_out(struct XorrisO *xorriso, char *disk_path,
                off_t startbyte, off_t bytecount, char *iso_rr_path, int flag);

int Xorriso_paste_in(struct XorrisO *xorriso, char *disk_path,
                off_t startbyte, off_t bytecount, char *iso_rr_path, int flag);

struct SplitparT;

/* @param flag bit0= in_node is valid, do not resolve iso_adr
*/
int Xorriso_identify_split(struct XorrisO *xorriso, char *iso_adr,
                           void *in_node,
                           struct SplitparT **parts, int *count,
                           struct stat *total_stbuf, int flag);

/* @param flag bit0= node is valid, do not resolve path
               bit1= insist in complete collection of part files
*/
int Xorriso_is_split(struct XorrisO *xorriso, char *path, void *node,
                     int flag);


/* @param flag
           >>> bit0= mkdir: graft in as empty directory, not as copy from iso
               bit1= do not report copied files
               bit2= -follow, -not_*: this is not a command parameter
               bit3= use offset and cut_size for -paste_in
               bit4= return 3 on rejection by exclusion or user
               bit5= if directory then do not add sub tree
               bit6= this is a copy action: do not fake times and ownership
   @return <=0 = error , 1 = added leaf file object , 2 = added directory ,
                         3 = rejected
*/
int Xorriso_restore(struct XorrisO *xorriso,
                    char *img_path, char *disk_path,
                    off_t offset, off_t cut_size, int flag);


/* @param flag bit0= in_node is valid, do not resolve img_path
*/
int Xorriso_restore_is_identical(struct XorrisO *xorriso, void *in_node,
                                 char *img_path, char *disk_path,
                                 char type_text[5], int flag);


/* Return the official libburn address of an address string. This may fail
   if the string does not constitute a valid drive address.
   @param official_adr must offer SfileadrL bytes of reply buffer
   @return 1 = success , 0 = failure , -1 = severe error
*/
int Xorriso_libburn_adr(struct XorrisO *xorriso, char *address_string,
                        char official_adr[], int flag);


/* @param flag bit1= obtain info from outdev
*/
int Xorriso_msinfo(struct XorrisO *xorriso, int *msc1, int *msc2, int flag);

/*
   @param flag bit0= obtain iso_lba from indev
               bit1= head_buffer already contains a valid head
               bit2= issue message about success
               bit3= check whether source blocks are banned by in_sector_map
*/
int Xorriso_update_iso_lba0(struct XorrisO *xorriso, int iso_lba, int isosize,
                            char *head_buffer, struct CheckmediajoB *job,
                            int flag);


struct CheckmediajoB {
 int use_dev;        /* 0= use indev , 1= use outdev , 2= use sector map*/

 int min_lba;        /* if >=0 : begin checking at this address */
 int max_lba;        /* if >=0 : read up to this address, else use mode */

 int min_block_size; /* >>> not yet implemented:
                            granularity desired by user
                     */
 int mode;           /* 0= track by track
                        1= single sweep over libisoburn media capacity
                        >>> 2= single sweep over libburn media capacity
                     */
 time_t start_time;
 int time_limit;     /* Number of seconds after which to abort */

 int item_limit;     /* Maximum number of media check list items as result */

 char abort_file_path[SfileadrL];

 char data_to_path[SfileadrL];
 int data_to_fd;
 off_t data_to_offset; /* usually 0 with image copy, negative with file copy */
 off_t data_to_limit;  /* used with file copy */
 int patch_lba0;
 int patch_lba0_msc1;

 char sector_map_path[SfileadrL];
 struct SectorbitmaP *sector_map;
 int map_with_volid;  /* 0=add quick toc to map file,
                         1=read ISO heads for toc
                      */

 int retry;          /* -1= only try full read_chunk, 1=retry with 2k blocks
                         0= retry with CD, full chunk else
                      */

 int report_mode;    /* 0= print MCL items
                        1= print damaged files
                     */

};

int Xorriso_check_media(struct XorrisO *xorriso, struct SpotlisT **spotlist,
                        struct CheckmediajoB *job, int flag);

int Xorriso_extract_cut(struct XorrisO *xorriso,
                        char *img_path, char *disk_path,
                        off_t img_offset, off_t bytes, int flag);


/* A pseudo file type for El-Torito bootsectors as in man 2 stat :
   For now take the highest possible value.
*/
#define Xorriso_IFBOOT S_IFMT


#endif /* Xorrisoburn_includeD */