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.
302 lines
6.6 KiB
302 lines
6.6 KiB
/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */ |
|
/* vim: set ts=8 sts=8 sw=8 noet : */ |
|
|
|
#define _GNU_SOURCE |
|
|
|
#include "libisofs.h" |
|
#include "libburn/libburn.h" |
|
#include <getopt.h> |
|
#include <stdlib.h> |
|
#include <stdio.h> |
|
#include <unistd.h> |
|
#include <sys/types.h> |
|
#include <sys/stat.h> |
|
#include <fcntl.h> |
|
#include <assert.h> |
|
#include <sys/types.h> |
|
#include <dirent.h> |
|
#include <string.h> |
|
#include <err.h> |
|
|
|
#define SECSIZE 2048 |
|
|
|
const char * const optstring = "JRL:h"; |
|
extern char *optarg; |
|
extern int optind; |
|
|
|
static struct data_source *libburn_data_source_new(struct burn_drive *d); |
|
|
|
void usage() |
|
{ |
|
printf("test [OPTIONS] DISC DIRECTORY\n"); |
|
} |
|
|
|
void help() |
|
{ |
|
printf( |
|
"Options:\n" |
|
" -J Add Joliet support\n" |
|
" -R Add Rock Ridge support\n" |
|
" -L <num> Set the ISO level (1 or 2)\n" |
|
" -h Print this message\n" |
|
); |
|
} |
|
|
|
int main(int argc, char **argv) |
|
{ |
|
struct burn_drive_info *drives; |
|
struct burn_drive *drive; |
|
struct ecma119_source_opts wopts; |
|
struct ecma119_read_opts ropts; |
|
struct data_source *rsrc; |
|
struct iso_volset *volset; |
|
struct iso_tree_node_dir *root; |
|
struct burn_source *wsrc; |
|
int c; |
|
struct iso_tree_radd_dir_behavior behav = {0,0,0}; |
|
int level=1, flags=0; |
|
int ret = 0; |
|
|
|
while ((c = getopt(argc, argv, optstring)) != -1) { |
|
switch(c) { |
|
case 'h': |
|
usage(); |
|
help(); |
|
exit(0); |
|
break; |
|
case 'J': |
|
flags |= ECMA119_JOLIET; |
|
break; |
|
case 'R': |
|
flags |= ECMA119_ROCKRIDGE; |
|
break; |
|
case 'L': |
|
level = atoi(optarg); |
|
break; |
|
case '?': |
|
usage(); |
|
exit(1); |
|
break; |
|
} |
|
} |
|
|
|
if (argc < optind + 1) { |
|
printf ("Please supply device name\n"); |
|
usage(); |
|
return 1; |
|
} |
|
if (argc < optind + 2) { |
|
printf ("Please supply directory to add to disc\n"); |
|
usage(); |
|
return 1; |
|
} |
|
|
|
if (!iso_init()) { |
|
err(1, "Can't init libisofs"); |
|
} |
|
if (!burn_initialize()) { |
|
err(1, "Can't init libburn"); |
|
} |
|
iso_msgs_set_severities("NEVER", "ALL", ""); |
|
burn_msgs_set_severities("NEVER", "SORRY", "libburner : "); |
|
|
|
printf("Reading from %s\n", argv[optind]); |
|
|
|
if (burn_drive_scan_and_grab(&drives, argv[optind], 0) != 1) { |
|
err(1, "Can't open device. Are you sure it is a valid drive?\n"); |
|
} |
|
|
|
drive = drives[0].drive; |
|
|
|
{ |
|
/* some check before going on */ |
|
enum burn_disc_status state; |
|
int pno; |
|
char name[80]; |
|
|
|
state = burn_disc_get_status(drive); |
|
burn_disc_get_profile(drive, &pno, name); |
|
|
|
// my drives report BURN_DISC_BLANK on a DVD+RW with data. |
|
// is that correct? |
|
if ( (pno != 0x1a) /*|| (state != BURN_DISC_FULL)*/ ) { |
|
printf("You need to insert a DVD+RW with some data.\n"); |
|
printf("Profile: %x, state: %d.\n", pno, state); |
|
ret = 1; |
|
goto exit_cleanup; |
|
} |
|
} |
|
|
|
rsrc = libburn_data_source_new(drive); |
|
if (rsrc == NULL) { |
|
printf ("Can't create data source.\n"); |
|
ret = 1; |
|
goto exit_cleanup; |
|
} |
|
|
|
ropts.block = 0; /* image always start on first block */ |
|
ropts.norock = 0; |
|
ropts.nojoliet = 0; |
|
ropts.preferjoliet = 0; |
|
ropts.mode = 0555; |
|
ropts.uid = 0; |
|
ropts.gid = 0; |
|
volset = iso_volset_read(rsrc, &ropts); |
|
|
|
if (volset == NULL) { |
|
printf ("Error reading image\n"); |
|
ret = 1; |
|
goto exit_cleanup; |
|
} |
|
|
|
printf("Image size: %d blocks.\n", ropts.size); |
|
|
|
/* close source, no more needed */ |
|
data_source_free(rsrc); |
|
|
|
root = iso_volume_get_root(iso_volset_get_volume(volset, 0)); |
|
|
|
/* add a new dir */ |
|
iso_tree_radd_dir(root, argv[optind+1], &behav); |
|
|
|
memset(&wopts, 0, sizeof(struct ecma119_source_opts)); |
|
wopts.level = level; |
|
wopts.flags = flags; |
|
wopts.relaxed_constraints = 0; |
|
wopts.input_charset = "UTF-8"; |
|
wopts.ouput_charset = "UTF-8"; |
|
/* round up to 32kb aligment = 16 block*/ |
|
wopts.ms_block = ((ropts.size + 15) / 16 ) * 16; |
|
wopts.overwrite = calloc(32, 2048); |
|
|
|
wsrc = iso_source_new_ecma119(volset, &wopts); |
|
|
|
/* a. write the new image */ |
|
printf("Adding new data...\n"); |
|
{ |
|
struct burn_disc *target_disc; |
|
struct burn_session *session; |
|
struct burn_write_opts *burn_options; |
|
struct burn_track *track; |
|
struct burn_progress progress; |
|
char reasons[BURN_REASONS_LEN]; |
|
|
|
target_disc = burn_disc_create(); |
|
session = burn_session_create(); |
|
burn_disc_add_session(target_disc, session, BURN_POS_END); |
|
|
|
track = burn_track_create(); |
|
burn_track_set_source(track, wsrc); |
|
burn_session_add_track(session, track, BURN_POS_END); |
|
|
|
burn_options = burn_write_opts_new(drive); |
|
burn_drive_set_speed(drive, 0, 0); |
|
burn_write_opts_set_underrun_proof(burn_options, 1); |
|
|
|
//mmm, check for 32K alignment? |
|
burn_write_opts_set_start_byte(burn_options, wopts.ms_block * 2048); |
|
|
|
if (burn_write_opts_auto_write_type(burn_options, target_disc, |
|
reasons, 0) == BURN_WRITE_NONE) { |
|
printf("Failed to find a suitable write mode:\n%s\n", reasons); |
|
ret = 1; |
|
goto exit_cleanup; |
|
} |
|
|
|
/* ok, write the new track */ |
|
burn_disc_write(burn_options, target_disc); |
|
burn_write_opts_free(burn_options); |
|
|
|
while (burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING) |
|
usleep(1002); |
|
|
|
while (burn_drive_get_status(drive, &progress) != BURN_DRIVE_IDLE) { |
|
printf("Writing: sector %d of %d\n", progress.sector, progress.sectors); |
|
sleep(1); |
|
} |
|
|
|
} |
|
|
|
/* b. write the new vol desc */ |
|
printf("Writing the new vol desc...\n"); |
|
if ( burn_random_access_write(drive, 0, wopts.overwrite, 32*2048, 0) != 1) { |
|
printf("Ups, new vol desc write failed\n"); |
|
} |
|
|
|
free(wopts.overwrite); |
|
iso_volset_free(volset); |
|
|
|
exit_cleanup:; |
|
burn_drive_release(drives[0].drive, 0); |
|
burn_finish(); |
|
iso_finish(); |
|
|
|
exit(ret); |
|
} |
|
|
|
struct disc_data_src { |
|
struct burn_drive *d; |
|
int nblocks; |
|
}; |
|
|
|
static int |
|
libburn_ds_read_block(struct data_source *src, int lba, unsigned char *buffer) |
|
{ |
|
struct disc_data_src *data; |
|
off_t data_count; |
|
|
|
assert(src && buffer); |
|
|
|
data = (struct disc_data_src*)src->data; |
|
|
|
/* if (lba >= data->nblocks) |
|
* return BLOCK_OUT_OF_FILE; |
|
*/ |
|
|
|
if ( burn_read_data(data->d, (off_t) lba * (off_t) 2048, buffer, 2048, |
|
&data_count, 0) < 0 ) { |
|
return -1; //error |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int |
|
libburn_ds_get_size(struct data_source *src) |
|
{ |
|
struct disc_data_src *data; |
|
|
|
assert(src); |
|
|
|
data = (struct disc_data_src*)src->data; |
|
return data->nblocks; |
|
} |
|
|
|
static void |
|
libburn_ds_free_data(struct data_source *src) |
|
{ |
|
free(src->data); |
|
} |
|
|
|
static struct data_source * |
|
libburn_data_source_new(struct burn_drive *d) |
|
{ |
|
struct disc_data_src *data; |
|
struct data_source *ret; |
|
|
|
assert(d); |
|
|
|
data = malloc(sizeof(struct disc_data_src)); |
|
data->d = d; |
|
|
|
//should be filled with the size of disc (or track?) |
|
data->nblocks = 0; |
|
|
|
ret = malloc(sizeof(struct data_source)); |
|
ret->refcount = 1; |
|
ret->read_block = libburn_ds_read_block; |
|
ret->get_size = libburn_ds_get_size; |
|
ret->free_data = libburn_ds_free_data; |
|
ret->data = data; |
|
return ret; |
|
}
|
|
|