legacy/libisoburn/trunk/test/xorrisoburn.c

/* 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 Thomas Schmitt, <scdbackup@gmx.net>

   Provided under GPL version 2.
*/

#include <ctype.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>


/* ------------------------------------------------------------------------ */


/* The library which does the ISO 9660 / RockRidge manipulations */
#include <libisofs/libisofs.h>

/* The library which does MMC optical drive operations */
#include <libburn/libburn.h>

/* The library which enhances overwriteable media with ISO 9660 multi-session
   capabilities via the method invented by Andy Polyakov for growisofs */
#include <libisoburn/libisoburn.h>

/* The inner description of XorrisO */
#include "xorriso_private.h"

/* The inner isofs- and burn-library interface */
#include "xorrisoburn.h"


/* ------------------------------------------------------------------------ */


int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag)
{
 int ret;
 char *handler_prefix= NULL;

 /* >>> rather send this to msg system of xorriso */;
 fprintf(stderr, "Starting up libraries ...\n");

 handler_prefix= calloc(strlen(xorriso->progname)+3+1, 1);
 if(handler_prefix==NULL) {

   /* >>> rather send this to msg system of xorriso */;
   fprintf(stderr, "--- Cannot allocate memory for initializing libraries\n");

   return(-1);
 }
 ret= isoburn_initialize();
 if(ret==0) {

   /* >>> rather send this to msg system of xorriso */;
   fprintf(stderr, "--- Cannot initialize libraries\n");
   free(handler_prefix);
   return(0);
 }

 /* >>> need option for controlling this in XorrisO */
 iso_msgs_set_severities("NEVER", "DEBUG", "libisofs : ");
 burn_msgs_set_severities("NEVER", "DEBUG", "libburn : ");
 sprintf(handler_prefix, "%s : ", xorriso->progname);
 burn_set_signal_handling(handler_prefix, NULL, 0);
 
 fprintf(stderr,"Library startup done.\n");
 free(handler_prefix);
 return(1);
}


/* @param flag bit0=aquire as isoburn input drive
               bit1=aquire as libburn output drive (as isoburn drive if bit0)
*/
int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag)
{
 int ret;
 struct burn_drive_info *dinfo= NULL;
 struct burn_drive *drive;
 enum burn_disc_status state;
 struct iso_volset *volset;
 struct isoburn_read_opts ropts;


 if((flag&3)!=3) { 
   fprintf(stderr,">>> XORRISOBURN: Xorriso_aquire_drive bit0+bit1 not set\n");
   return(0);
 }
 ret= Xorriso_give_up_drive(xorriso, flag&3);
 if(ret<=0)
   return(ret);

 ret= isoburn_drive_scan_and_grab(&dinfo, adr, 1);
 if(ret<=0) {
   fprintf(stderr,"--- Cannot aquire drive '%s'\n", adr); 
   return(0);
 }
 if(flag&2)
   xorriso->out_drive_handle= dinfo;
 if(flag&1)
   xorriso->in_drive_handle= dinfo;
 else
   return(1);

 drive= dinfo[0].drive;

 /* check for invalid state */
 state= isoburn_disc_get_status(drive);

 /* >>> show drive and media status */;

 if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {

   /* >>> rather send this to msg system of xorriso */;
   fprintf(stderr, "Unsuitable disc status\n");

   ret= 0; goto ex;
 }
 /* fill read opts */ 
 ropts.norock= 0;
 ropts.nojoliet= 0;
 ropts.preferjoliet= 0;
 ropts.uid= 0;
 ropts.gid= 0;
 ropts.mode= 0555;

 if(isoburn_read_volset(drive, &ropts, &volset) <= 0) {

    /* >>> rather send this to msg system of xorriso */;
    fprintf(stderr, "Can't read volset\n");

   ret= 0; goto ex;
 }
 xorriso->in_volset_handle= volset;
 ret= 1;
ex:
 if(ret<=0) {

   /* >>> ??? give up not-so-suitable drive ? */;

 }
 return(ret);
}


/* @param flag bit0=input drive
               bit1=output drive
*/
int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag)
{
 int in_is_out_too;
 struct burn_drive_info *dinfo;
 struct burn_drive *drive;
 
 in_is_out_too= (xorriso->in_drive_handle == xorriso->out_drive_handle);
   
 if((flag&1) && xorriso->in_drive_handle != NULL) {
   dinfo= (struct burn_drive_info *) xorriso->in_drive_handle;
   drive= dinfo[0].drive;
   isoburn_drive_release(drive,0);

   /* >>> this should be an official reference for this pointer which was
          handed out by isoburn_read_volset() and attached to invisible
          struct isoburn. Then to be processed by: iso_volset_free(volset);
   */
   xorriso->in_volset_handle= NULL; /* destroyed by isoburn_drive_release() */

   burn_drive_info_free(dinfo);
   xorriso->in_drive_handle= NULL;
   if(in_is_out_too)
     xorriso->out_drive_handle= NULL;
 }
 if((flag&2) && xorriso->out_drive_handle!=NULL) {
   dinfo= (struct burn_drive_info *) xorriso->out_drive_handle;
   drive= dinfo[0].drive;
   isoburn_drive_release(drive,0);
   burn_drive_info_free(dinfo);
   xorriso->out_drive_handle= NULL;

 }
 return(1);
}

int Xorriso_write_growing(struct XorrisO *xorriso, int flag)
{
 int ret;
 struct isoburn_source_opts sopts;
 struct burn_drive_info *dinfo;
 struct burn_drive *drive;
 struct burn_disc *disc;
 struct burn_write_opts *burn_options;

 dinfo= (struct burn_drive_info *) xorriso->in_drive_handle;
 if(dinfo==NULL) {

   /* >>> */
   fprintf(stderr, "--- No drive aquired\n");

   return(0);
 }
 drive= dinfo[0].drive;

 sopts.level= 2;
 sopts.flags= ECMA119_ROCKRIDGE;
 if(xorriso->do_joliet)
   sopts.flags|= ECMA119_ROCKRIDGE;
 sopts.relaxed_constraints= 0;
 sopts.copy_eltorito= 1;
 sopts.no_cache_inodes= 0;
 sopts.sort_files= 1;
 sopts.default_mode= 0;
 sopts.replace_dir_mode= 0;
 sopts.dir_mode= 0555;
 sopts.replace_file_mode= 0;
 sopts.file_mode= 0444;
 sopts.replace_uid= (xorriso->do_global_uid);
 sopts.uid= xorriso->global_uid;
 sopts.replace_gid= (xorriso->do_global_gid);
 sopts.gid= xorriso->global_gid;
 sopts.input_charset= NULL;
 sopts.ouput_charset= NULL;

 /* >>> -fs : isoburn_prepare_disc() needs fifo parameters */

 if (isoburn_prepare_disc(drive, &disc, &sopts) <= 0) {

   /* >>> */
   fprintf(stderr, "--- Cannot prepare disc\n");

   return(0);
 }

 burn_options= burn_write_opts_new(drive);
 if(burn_options==NULL) {

   /* >>> */
   fprintf(stderr, "--- Cannot allocate option set\n");

   return(0);
 }
 burn_write_opts_set_simulate(burn_options, !!xorriso->do_dummy);
 burn_write_opts_set_multi(burn_options, !xorriso->do_close);
 burn_drive_set_speed(drive, xorriso->speed, xorriso->speed);
 burn_write_opts_set_underrun_proof(burn_options, 1);
 
 isoburn_disc_write(burn_options, disc);
 burn_write_opts_free(burn_options);

 ret= Xorriso_pacifier_loop(xorriso, drive, 0);
 if(ret<=0)
   return(ret);

 ret= isoburn_activate_session(drive);
 if(ret<=0) {
   fprintf(stderr, "--- Could not write new set olf volume descriptors\n");
   return(ret);
 }

 /* >>> cleanup disc ? */

 return(1);
} 


int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
                          int flag)
{
 int ret, size, free_bytes, i;
 struct burn_progress progress;
 char *status_text;


 while(burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING)
   usleep(100002);

 while(burn_drive_get_status(drive, &progress) != BURN_DRIVE_IDLE) {

   /* >>> make this output go into xorriso info channel */;

   printf("Writing: sector %d of %d",
          progress.sector, progress.sectors);
   ret= isoburn_get_fifo_status(drive, &size, &free_bytes, &status_text);
   if(ret>0 )
      printf("  [fifo %s, %2d%% fill]", status_text,
             (int) (100.0-100.0*((double) free_bytes)/(double) size));
   printf("\n");

   for(i= 0; i<10; i++) {

     /* >>> check message system of libburn */;

     usleep(100000);
   }
 }
 return(1);
}


int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
                     int flag)
{
 struct iso_volume *volume;
 struct iso_tree_radd_dir_behavior behav= {NULL, 0, 0};
 char path[SfileadrL], *apt, *npt;
 struct iso_tree_node_dir *dir;
 struct iso_tree_node *node;
 int done= 0, is_dir= 0;
 struct stat stbuf;

 strncpy(path, img_path, sizeof(path)-1);
 path[sizeof(path)-1]= 0;
 apt= npt= path;
 volume= iso_volset_get_volume(
                           (struct iso_volset *) xorriso->in_volset_handle, 0);

 if(lstat(disk_path, &stbuf) == -1) {

   /* >>> */
   fprintf(stderr, "--- Cannot determine attributes of '%s' : %s (%d)\n",
           disk_path, (errno > 0 ? strerror(errno) : "unknown error"), errno);

   return(0);
 }
 if(S_ISDIR(stbuf.st_mode)) 
   is_dir= 1; 
 else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) {

   /* >>> */
   fprintf(stderr, "--- File object '%s' is of non-supported file type\n",
           disk_path);

   return(0);
 }

 dir= iso_volume_get_root(volume);
 if(dir==NULL) {

   /* >>> */
   fprintf(stderr, "--- While grafting '%s' : no root node available\n",
           img_path);

   return(0);
 }
 for(npt= apt; !done; apt= npt+1) {
   npt= strchr(apt, '/');
   if(npt==NULL) {
     npt= apt+strlen(apt);
     done= 1;
   } else
     *npt= 0;
   if(*apt==0) {
     *apt= '/';
     apt++;
 continue;
   }
   node= iso_tree_volume_path_to_node(volume,path);
   if(node!=NULL) {
     if(iso_tree_node_get_type(node)!=LIBISO_NODE_DIR) {

       /* >>> */
       fprintf(stderr, "--- While grafting '%s' : '%s' is not a directory\n",
               img_path, path);

       return(0);
     }
     dir= (struct iso_tree_node_dir *) node;
   } else {
     dir= iso_tree_add_dir(dir, apt);
     if(dir==NULL) {

       /* >>> */
       fprintf(stderr, "--- While grafting '%s' : could not insert '%s'\n",
               img_path, path);

       return(0);
     }
   }
   if(done) {
     if(is_dir) {
       iso_tree_radd_dir(dir, disk_path, &behav);
     } else {
       node= iso_tree_add_node(dir, disk_path);
       if(node == NULL) {

         /* >>> */
         fprintf(stderr, "While grafting '%s'='%s' : libisofs_errno = %d\n",
               img_path, disk_path, libisofs_errno);

         return(0);
       }
     }
   } else
     *npt= '/';
 }
 fprintf(stderr, "NOTE: added %s '%s'='%s'\n", (is_dir ? "directory" : "node"),
                 img_path, disk_path);
 xorriso->volset_change_pending= 1;
 return(1);
}