12490 lines
386 KiB
C
12490 lines
386 KiB
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-2009 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>
|
|
#include <time.h>
|
|
#include <fcntl.h>
|
|
#include <utime.h>
|
|
#include <sys/wait.h>
|
|
#include <pwd.h>
|
|
#include <grp.h>
|
|
|
|
/* for -charset */
|
|
#include <iconv.h>
|
|
#include <langinfo.h>
|
|
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
#ifndef Xorriso_standalonE
|
|
|
|
/* 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 official xorriso options API. "No shortcuts" */
|
|
#include "xorriso.h"
|
|
|
|
/* The inner description of XorrisO */
|
|
#include "xorriso_private.h"
|
|
|
|
/* The inner isofs- and burn-library interface */
|
|
#include "xorrisoburn.h"
|
|
|
|
#else /* ! Xorriso_standalonE */
|
|
|
|
#include "../libisofs/libisofs.h"
|
|
#include "../libburn/libburn.h"
|
|
#include "../libisoburn/libisoburn.h"
|
|
#include "xorriso.h"
|
|
#include "xorriso_private.h"
|
|
#include "xorrisoburn.h"
|
|
|
|
#endif /* Xorriso_standalonE */
|
|
|
|
|
|
/* Some private in advance declarations */
|
|
int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
|
|
int flag);
|
|
|
|
int Xorriso__read_pacifier(IsoImage *image, IsoFileSource *filesource);
|
|
|
|
int Xorriso_tree_graft_node(struct XorrisO *xorriso, IsoImage *volume,
|
|
IsoDir *dir, char *disk_path, char *img_name,
|
|
char *nominal_source, char *nominal_target,
|
|
off_t offset, off_t cut_size,
|
|
IsoNode **node, int flag);
|
|
|
|
int Xorriso_findi_iter(struct XorrisO *xorriso, IsoDir *dir_node, off_t *mem,
|
|
IsoDirIter **iter,
|
|
IsoNode ***node_array, int *node_count, int *node_idx,
|
|
IsoNode **iterated_node, int flag);
|
|
|
|
int Xorriso__file_start_lba(IsoNode *node, int *lba, int flag);
|
|
|
|
int Xorriso_read_file_data(struct XorrisO *xorriso, IsoNode *node,
|
|
char *img_path, char *disk_path,
|
|
off_t img_offset, off_t disk_offset,
|
|
off_t bytes, int flag);
|
|
|
|
int Xorriso_path_from_node(struct XorrisO *xorriso, IsoNode *in_node,
|
|
char path[SfileadrL], int flag);
|
|
|
|
int Xorriso_node_from_path(struct XorrisO *xorriso, IsoImage *volume,
|
|
char *path, IsoNode **node, int flag);
|
|
|
|
int Xorriso_path_from_lba(struct XorrisO *xorriso, IsoNode *node, int lba,
|
|
char path[SfileadrL], int flag);
|
|
|
|
int Xorriso__node_lba_cmp(const void *node1, const void *node2);
|
|
|
|
int Xorriso_search_hardlinks(struct XorrisO *xorriso, IsoNode *node,
|
|
int *node_idx, int *min_hl, int *max_hl, int flag);
|
|
|
|
|
|
#define LIBISO_ISDIR(node) (iso_node_get_type(node) == LIBISO_DIR)
|
|
#define LIBISO_ISREG(node) (iso_node_get_type(node) == LIBISO_FILE)
|
|
#define LIBISO_ISLNK(node) (iso_node_get_type(node) == LIBISO_SYMLINK)
|
|
#define LIBISO_ISCHR(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
|
|
S_ISCHR(iso_node_get_mode(node)))
|
|
#define LIBISO_ISBLK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
|
|
S_ISBLK(iso_node_get_mode(node)))
|
|
#define LIBISO_ISFIFO(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
|
|
S_ISFIFO(iso_node_get_mode(node)))
|
|
#define LIBISO_ISSOCK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
|
|
S_ISSOCK(iso_node_get_mode(node)))
|
|
#define LIBISO_ISBOOT(node) (iso_node_get_type(node) == LIBISO_BOOT)
|
|
|
|
|
|
/* CD specs say one shall not write tracks < 600 kiB */
|
|
#define Xorriso_cd_min_track_sizE 300
|
|
|
|
|
|
/* Default setting for -compliance */
|
|
#define Xorriso_relax_compliance_defaulT \
|
|
(isoburn_igopt_allow_deep_paths | isoburn_igopt_allow_longer_paths | \
|
|
isoburn_igopt_always_gmt | \
|
|
isoburn_igopt_rrip_version_1_10 | isoburn_igopt_aaip_susp_1_10 )
|
|
|
|
#ifdef NIX
|
|
/* <<< */
|
|
unsigned long Xorriso_get_di_counteR= 0;
|
|
#endif /* NIX */
|
|
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
|
|
int Xorriso_destroy_node_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int i;
|
|
|
|
if(xorriso->node_array != NULL) {
|
|
for(i= 0; i < xorriso->node_counter; i++)
|
|
iso_node_unref((IsoNode *) xorriso->node_array[i]);
|
|
free(xorriso->node_array);
|
|
}
|
|
xorriso->node_array= NULL;
|
|
xorriso->node_counter= xorriso->node_array_size= 0;
|
|
Xorriso_lst_destroy_all(&(xorriso->node_disk_prefixes), 0);
|
|
Xorriso_lst_destroy_all(&(xorriso->node_img_prefixes), 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not destroy hln_array but only hln_targets
|
|
*/
|
|
int Xorriso_destroy_hln_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int i;
|
|
|
|
|
|
if(xorriso->hln_array != NULL && !(flag & 1)) {
|
|
for(i= 0; i < xorriso->hln_count; i++)
|
|
iso_node_unref((IsoNode *) xorriso->hln_array[i]);
|
|
free(xorriso->hln_array);
|
|
xorriso->hln_array= NULL;
|
|
xorriso->hln_count= 0;
|
|
}
|
|
if(xorriso->hln_targets != NULL) {
|
|
for(i= 0; i < xorriso->hln_count; i++)
|
|
if(xorriso->hln_targets[i] != NULL)
|
|
free(xorriso->hln_targets[i]);
|
|
free(xorriso->hln_targets);
|
|
xorriso->hln_targets= NULL;
|
|
}
|
|
xorriso->node_targets_availmem= 0;
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_destroy_di_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int i;
|
|
|
|
if(xorriso->di_array != NULL) {
|
|
for(i= 0; i < xorriso->di_count; i++)
|
|
if(xorriso->di_array[i] != NULL)
|
|
iso_node_unref((IsoNode *) xorriso->di_array[i]);
|
|
free(xorriso->di_array);
|
|
xorriso->di_array= NULL;
|
|
}
|
|
if(xorriso->di_do_widen != NULL) {
|
|
free(xorriso->di_do_widen);
|
|
xorriso->di_do_widen= NULL;
|
|
}
|
|
Xorriso_lst_destroy_all(&(xorriso->di_disk_paths), 0);
|
|
Xorriso_lst_destroy_all(&(xorriso->di_iso_paths), 0);
|
|
xorriso->di_count= 0;
|
|
|
|
#ifdef NIX
|
|
/* <<< */
|
|
fprintf(stderr, "xorriso_DEBUG: get_di_count= %lu\n",
|
|
Xorriso_get_di_counteR);
|
|
#endif /* NIX */
|
|
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_new_node_array(struct XorrisO *xorriso, off_t mem_limit,
|
|
int addon_nodes, int flag)
|
|
{
|
|
int i;
|
|
|
|
if(xorriso->node_counter <= 0)
|
|
return(1);
|
|
|
|
xorriso->node_array= calloc(xorriso->node_counter + addon_nodes,
|
|
sizeof(IsoNode *));
|
|
if(xorriso->node_array == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
return(-1);
|
|
}
|
|
for(i= 0; i < xorriso->node_counter + addon_nodes; i++)
|
|
xorriso->node_array[i]= NULL;
|
|
xorriso->node_array_size= xorriso->node_counter + addon_nodes;
|
|
xorriso->node_counter= 0;
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not allocate hln_array but only hln_targets
|
|
*/
|
|
int Xorriso_new_hln_array(struct XorrisO *xorriso, off_t mem_limit, int flag)
|
|
{
|
|
int i;
|
|
|
|
Xorriso_destroy_hln_array(xorriso, flag & 1);
|
|
if(xorriso->hln_count <= 0)
|
|
return(1);
|
|
|
|
if(!(flag & 1)) {
|
|
xorriso->hln_array= calloc(xorriso->hln_count, sizeof(char *));
|
|
if(xorriso->hln_array == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
return(-1);
|
|
}
|
|
for(i= 0; i < xorriso->hln_count; i++)
|
|
xorriso->hln_array[i]= NULL;
|
|
}
|
|
|
|
xorriso->hln_targets= calloc(xorriso->hln_count, sizeof(char *));
|
|
if(xorriso->hln_targets == NULL) {
|
|
if(!(flag & 1)) {
|
|
free(xorriso->hln_array);
|
|
xorriso->hln_array= NULL;
|
|
}
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
return(-1);
|
|
}
|
|
for(i= 0; i < xorriso->hln_count; i++)
|
|
xorriso->hln_targets[i]= NULL;
|
|
xorriso->node_targets_availmem= mem_limit
|
|
- xorriso->hln_count * sizeof(void *)
|
|
- xorriso->hln_count * sizeof(char *);
|
|
if(xorriso->node_targets_availmem < 0)
|
|
xorriso->node_targets_availmem= 0;
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso__findi_sorted_ino_cmp(const void *p1, const void *p2)
|
|
{
|
|
int ret;
|
|
IsoNode *n1, *n2;
|
|
|
|
n1= *((IsoNode **) p1);
|
|
n2= *((IsoNode **) p2);
|
|
|
|
ret= Xorriso__node_lba_cmp(&n1, &n2);
|
|
if(ret)
|
|
return (ret > 0 ? 1 : -1);
|
|
ret= iso_node_cmp_ino(n1, n2, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* Not suitable for qsort() but for cross-array comparisons.
|
|
p1 and p2 are actually IsoNode *p1, IsoNode *p2
|
|
*/
|
|
int Xorriso__hln_cmp(const void *p1, const void *p2)
|
|
{
|
|
int ret;
|
|
|
|
ret= Xorriso__findi_sorted_ino_cmp(&p1, &p2);
|
|
if(ret)
|
|
return (ret > 0 ? 1 : -1);
|
|
if(p1 != p2)
|
|
return(p1 < p2 ? -1 : 1);
|
|
return(0);
|
|
}
|
|
|
|
|
|
/*
|
|
p1 and p2 are actually IsoNode **p1, IsoNode **p2
|
|
*/
|
|
int Xorriso__findi_sorted_cmp(const void *p1, const void *p2)
|
|
{
|
|
int ret;
|
|
|
|
ret= Xorriso__findi_sorted_ino_cmp(p1, p2);
|
|
if(ret)
|
|
return (ret > 0 ? 1 : -1);
|
|
if(p1 != p2)
|
|
return(p1 < p2 ? -1 : 1);
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso_sort_node_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
if(xorriso->node_counter <= 0)
|
|
return(0);
|
|
qsort(xorriso->node_array, xorriso->node_counter, sizeof(IsoNode *),
|
|
Xorriso__findi_sorted_cmp);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso__search_node(void *node_array[], int n,
|
|
int (*cmp)(const void *p1, const void *p2),
|
|
void *node, int *idx, int flag)
|
|
{
|
|
int ret, l, r, p, pos;
|
|
|
|
if(n == 0)
|
|
return(0);
|
|
l= 0;
|
|
r= n + 1;
|
|
while(1) {
|
|
p= (r - l) / 2;
|
|
if(p == 0)
|
|
break;
|
|
p+= l;
|
|
|
|
/* NULL elements may indicate invalid nodes. Their first valid right neigbor
|
|
will serve as proxy. If none exists, then the test pushes leftwards.
|
|
*/
|
|
for(pos= p - 1; pos < n; pos++)
|
|
if(node_array[pos] != NULL)
|
|
break;
|
|
if(pos < n)
|
|
ret= (*cmp)(&(node_array[pos]), &node);
|
|
else
|
|
ret= 1;
|
|
|
|
if(ret < 0)
|
|
l= p;
|
|
else if(ret > 0)
|
|
r= p;
|
|
else {
|
|
*idx= pos;
|
|
return(1);
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso_search_in_hln_array(struct XorrisO *xorriso,
|
|
void *node, int *idx, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if(xorriso->hln_array == NULL || xorriso->hln_count <= 0)
|
|
return(0);
|
|
ret= Xorriso__search_node(xorriso->hln_array, xorriso->hln_count,
|
|
Xorriso__findi_sorted_ino_cmp, node, idx, 0);
|
|
return ret;
|
|
}
|
|
|
|
|
|
int Xorriso__get_di(IsoNode *node, dev_t *dev, ino_t *ino, int flag)
|
|
{
|
|
int ret, i, i_end, imgid, error_code;
|
|
size_t value_length= 0;
|
|
char *value= NULL, msg[ISO_MSGS_MESSAGE_LEN], severity[80];
|
|
unsigned char *vpt;
|
|
static char *name= "isofs.di";
|
|
|
|
#ifdef NIX
|
|
/* <<< */
|
|
Xorriso_get_di_counteR++;
|
|
#endif /* NIX */
|
|
|
|
*dev= 0;
|
|
*ino= 0;
|
|
ret= iso_node_lookup_attr(node, name, &value_length, &value, 0);
|
|
if(ret <= 0) {
|
|
/* Drop any pending messages because there is no xorriso to take them */
|
|
iso_obtain_msgs("NEVER", &error_code, &imgid, msg, severity);
|
|
return(ret);
|
|
}
|
|
vpt= (unsigned char *) value;
|
|
for(i= 1; i <= vpt[0] && i < value_length; i++)
|
|
*dev= ((*dev) << 8) | vpt[i];
|
|
i_end= i + vpt[i] + 1;
|
|
for(i++; i < i_end && i < value_length; i++)
|
|
*ino= ((*ino) << 8) | vpt[i];
|
|
free(value);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso__di_ino_cmp(const void *p1, const void *p2)
|
|
{
|
|
int ret;
|
|
IsoNode *n1, *n2;
|
|
dev_t d1, d2;
|
|
ino_t i1, i2;
|
|
|
|
n1= *((IsoNode **) p1);
|
|
n2= *((IsoNode **) p2);
|
|
|
|
ret= Xorriso__get_di(n1, &d1, &i1, 0);
|
|
if(ret <= 0)
|
|
{d1= 0; i1= 0;}
|
|
ret= Xorriso__get_di(n2, &d2, &i2, 0);
|
|
if(ret <= 0)
|
|
{d2= 0; i2= 0;}
|
|
|
|
if(d1 < d2)
|
|
return(-1);
|
|
if(d1 > d2)
|
|
return(1);
|
|
if(i1 < i2)
|
|
return(-1);
|
|
if(i1 > i2)
|
|
return(1);
|
|
if(d1 == 0 && i1 == 0 && n1 != n2)
|
|
return(n1 < n2 ? -1 : 1);
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso__di_cmp(const void *p1, const void *p2)
|
|
{
|
|
int ret;
|
|
IsoNode *n1, *n2;
|
|
|
|
ret= Xorriso__di_ino_cmp(p1, p2);
|
|
if(ret)
|
|
return(ret);
|
|
n1= *((IsoNode **) p1);
|
|
n2= *((IsoNode **) p2);
|
|
if(n1 != n2)
|
|
return(n1 < n2 ? -1 : 1);
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso__sort_di(void *node_array[], int count, int flag)
|
|
{
|
|
if(count <= 0)
|
|
return(0);
|
|
qsort(node_array, count, sizeof(IsoNode *), Xorriso__di_cmp);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_invalidate_di_item(struct XorrisO *xorriso, IsoNode *node,
|
|
int flag)
|
|
{
|
|
int ret, idx;
|
|
|
|
if(xorriso->di_array == NULL)
|
|
return(1);
|
|
ret= Xorriso__search_node(xorriso->di_array, xorriso->di_count,
|
|
Xorriso__di_cmp, node, &idx, 0);
|
|
if(ret <= 0)
|
|
return(ret == 0);
|
|
if(xorriso->di_array[idx] != NULL)
|
|
iso_node_unref(xorriso->di_array[idx]);
|
|
xorriso->di_array[idx]= NULL;
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= return 1 even if matching nodes were found but node is
|
|
not among them
|
|
bit1= use Xorriso__di_cmp() rather than Xorriso__di_ino_cmp()
|
|
*/
|
|
int Xorriso_search_di_range(struct XorrisO *xorriso, IsoNode *node,
|
|
int *idx, int *low, int *high, int flag)
|
|
{
|
|
int ret, i, found;
|
|
int (*cmp)(const void *p1, const void *p2)= Xorriso__di_ino_cmp;
|
|
|
|
if(flag & 2)
|
|
cmp= Xorriso__di_cmp;
|
|
|
|
*high= *low= *idx= -1;
|
|
ret= Xorriso__search_node(xorriso->di_array, xorriso->di_count,
|
|
cmp, node, &found, 0);
|
|
if(ret <= 0)
|
|
return(0);
|
|
*low= *high= found;
|
|
for(i= found + 1; i < xorriso->di_count; i++)
|
|
if(xorriso->di_array[i] != NULL) {
|
|
if((*cmp)(&node, &(xorriso->di_array[i])) != 0)
|
|
break;
|
|
*high= i;
|
|
}
|
|
for(i= found - 1; i >= 0; i--)
|
|
if(xorriso->di_array[i] != NULL) {
|
|
if((*cmp)(&node, &(xorriso->di_array[i])) != 0)
|
|
break;
|
|
*low= i;
|
|
}
|
|
for(i= *low; i <= *high; i++)
|
|
if(xorriso->di_array[i] == node) {
|
|
*idx= i;
|
|
break;
|
|
}
|
|
return(*idx >= 0 || (flag & 1));
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
|
|
int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, major, minor, micro;
|
|
char *handler_prefix= NULL;
|
|
char *queue_sev, *print_sev, reason[1024];
|
|
struct iso_zisofs_ctrl zisofs_ctrl= {0, 6, 15};
|
|
|
|
|
|
/* First an ugly compile time check for header version compatibility.
|
|
If everthing matches, then no C code is produced. In case of mismatch,
|
|
intentionally faulty C code will be inserted.
|
|
*/
|
|
|
|
/* The minimum requirement of xorriso towards the libisoburn header
|
|
at compile time is defined in xorriso/xorrisoburn.h
|
|
xorriso_libisoburn_req_major
|
|
xorriso_libisoburn_req_minor
|
|
xorriso_libisoburn_req_micro
|
|
It gets compared against the version macros in libburn/libburn.h :
|
|
isoburn_header_version_major
|
|
isoburn_header_version_minor
|
|
isoburn_header_version_micro
|
|
If the header is too old then the following code shall cause failure of
|
|
cdrskin compilation rather than to allow production of a program with
|
|
unpredictable bugs or memory corruption.
|
|
The compiler messages supposed to appear in this case are:
|
|
error: 'LIBISOBURN_MISCONFIGURATION' undeclared (first use in this function)
|
|
error: 'INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisoburn_dot_h_TOO_OLD__SEE_xorrisoburn_dot_c' undeclared (first use in this function)
|
|
error: 'LIBISOBURN_MISCONFIGURATION_' undeclared (first use in this function)
|
|
*/
|
|
/* The indendation is an advise of man gcc to help old compilers ignoring */
|
|
#if xorriso_libisoburn_req_major > isoburn_header_version_major
|
|
#define Isoburn_libisoburn_dot_h_too_olD 1
|
|
#endif
|
|
#if xorriso_libisoburn_req_major == isoburn_header_version_major && xorriso_libisoburn_req_minor > isoburn_header_version_minor
|
|
#define Isoburn_libisoburn_dot_h_too_olD 1
|
|
#endif
|
|
#if xorriso_libisoburn_req_minor == isoburn_header_version_minor && xorriso_libisoburn_req_micro > isoburn_header_version_micro
|
|
#define Isoburn_libisoburn_dot_h_too_olD 1
|
|
#endif
|
|
|
|
#ifdef Isoburn_libisoburn_dot_h_too_olD
|
|
LIBISOBURN_MISCONFIGURATION = 0;
|
|
INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisoburn_dot_h_TOO_OLD__SEE_xorrisoburn_dot_c = 0;
|
|
LIBISOBURN_MISCONFIGURATION_ = 0;
|
|
#endif
|
|
|
|
/* End of ugly compile time test (scroll up for explanation) */
|
|
|
|
handler_prefix= calloc(strlen(xorriso->progname)+3+1, 1);
|
|
if(handler_prefix==NULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot allocate memory for initializing libraries");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
reason[0]= 0;
|
|
ret= isoburn_initialize(reason, 0);
|
|
if(ret==0) {
|
|
sprintf(xorriso->info_text, "Cannot initialize libraries");
|
|
if(reason[0])
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
". Reason given:\n%s", reason);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
free(handler_prefix);
|
|
return(0);
|
|
}
|
|
ret= isoburn_is_compatible(isoburn_header_version_major,
|
|
isoburn_header_version_minor,
|
|
isoburn_header_version_micro, 0);
|
|
if(ret<=0) {
|
|
isoburn_version(&major, &minor, µ);
|
|
sprintf(xorriso->info_text,
|
|
"libisoburn version too old: %d.%d.%d . Need at least: %d.%d.%d .\n",
|
|
major, minor, micro,
|
|
isoburn_header_version_major, isoburn_header_version_minor,
|
|
isoburn_header_version_micro);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
|
|
xorriso->libs_are_started= 1;
|
|
|
|
queue_sev= "ALL";
|
|
if(xorriso->library_msg_direct_print) {
|
|
|
|
/* >>> need option for controlling this in XorrisO.
|
|
See also Xorriso_msgs_submit */;
|
|
|
|
print_sev= xorriso->report_about_text;
|
|
} else
|
|
print_sev= "NEVER";
|
|
|
|
iso_set_msgs_severities(queue_sev, print_sev, "libsofs : ");
|
|
burn_msgs_set_severities(queue_sev, print_sev, "libburn : ");
|
|
|
|
/* ??? >>> do we want united queues ? */
|
|
/* burn_set_messenger(iso_get_messenger()); */
|
|
|
|
isoburn_set_msgs_submit(Xorriso_msgs_submit_void, (void *) xorriso,
|
|
(3<<2) | 128 , 0);
|
|
|
|
sprintf(handler_prefix, "%s : ", xorriso->progname);
|
|
burn_set_signal_handling(handler_prefix, NULL, 0);
|
|
|
|
ret = iso_zisofs_get_params(&zisofs_ctrl, 0);
|
|
if (ret == 1) {
|
|
xorriso->zisofs_block_size= xorriso->zisofs_block_size_default=
|
|
(1 << zisofs_ctrl.block_size_log2);
|
|
xorriso->zlib_level= xorriso->zlib_level_default=
|
|
zisofs_ctrl.compression_level;
|
|
}
|
|
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(reason[0]) {
|
|
sprintf(xorriso->info_text, "%s", reason);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
free(handler_prefix);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= global shutdown of libraries */
|
|
int Xorriso_detach_libraries(struct XorrisO *xorriso, int flag)
|
|
{
|
|
Xorriso_give_up_drive(xorriso, 3);
|
|
if(xorriso->in_volset_handle!=NULL) { /* standalone image */
|
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle);
|
|
xorriso->in_volset_handle= NULL;
|
|
Sectorbitmap_destroy(&(xorriso->in_sector_map), 0);
|
|
Xorriso_destroy_di_array(xorriso, 0);
|
|
Xorriso_destroy_hln_array(xorriso, 0);
|
|
}
|
|
if(flag&1) {
|
|
if(xorriso->libs_are_started==0)
|
|
return(0);
|
|
isoburn_finish();
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit1= obtain outdrive, else indrive */
|
|
int Xorriso_get_drive_handles(struct XorrisO *xorriso,
|
|
struct burn_drive_info **dinfo,
|
|
struct burn_drive **drive,
|
|
char *attempt, int flag)
|
|
{
|
|
if(flag&2)
|
|
*dinfo= (struct burn_drive_info *) xorriso->out_drive_handle;
|
|
else
|
|
*dinfo= (struct burn_drive_info *) xorriso->in_drive_handle;
|
|
if(*dinfo==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text, "No %s drive aquired %s",
|
|
(flag&2 ? "output" : "input"), attempt);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
*drive= (*dinfo)[0].drive;
|
|
return((*drive)!=NULL);
|
|
}
|
|
|
|
|
|
int Xorriso__sev_to_text(int severity, char **severity_name,
|
|
int flag)
|
|
{
|
|
int ret;
|
|
|
|
ret= iso_sev_to_text(severity, severity_name);
|
|
if(ret>0)
|
|
return(ret);
|
|
ret= burn_sev_to_text(severity, severity_name, 0);
|
|
if(ret>0)
|
|
return(ret);
|
|
*severity_name= "";
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso__text_to_sev(char *severity_name, int *severity_number, int flag)
|
|
{
|
|
int ret= 1;
|
|
|
|
ret= iso_text_to_sev(severity_name, severity_number);
|
|
if(ret>0)
|
|
return(ret);
|
|
ret= burn_text_to_sev(severity_name, severity_number, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= report libisofs error text
|
|
bit1= victim is disk_path
|
|
bit2= do not inquire libisofs, report msg_text and min_severity
|
|
*/
|
|
int Xorriso_report_iso_error(struct XorrisO *xorriso, char *victim,
|
|
int iso_error_code, char msg_text[], int os_errno,
|
|
char min_severity[], int flag)
|
|
{
|
|
int error_code, iso_sev, min_sev, ret;
|
|
char *sev_text_pt, *msg_text_pt= NULL;
|
|
char sfe[6*SfileadrL];
|
|
static int sorry_sev= -1;
|
|
|
|
if(sorry_sev<0)
|
|
Xorriso__text_to_sev("SORRY", &sorry_sev, 0);
|
|
|
|
if(flag&4) {
|
|
error_code= 0x00050000;
|
|
Xorriso__text_to_sev(min_severity, &iso_sev, 0);
|
|
} else {
|
|
error_code= iso_error_get_code(iso_error_code);
|
|
if(error_code < 0x00030000 || error_code >= 0x00040000)
|
|
error_code= (error_code & 0xffff) | 0x00050000;
|
|
if(flag&1)
|
|
msg_text_pt= (char *) iso_error_to_msg(iso_error_code);
|
|
iso_sev= iso_error_get_severity(iso_error_code);
|
|
}
|
|
if(msg_text_pt==NULL)
|
|
msg_text_pt= msg_text;
|
|
|
|
if(iso_sev >= sorry_sev && (flag & 2) && victim[0])
|
|
Xorriso_msgs_submit(xorriso, 0, victim, 0, "ERRFILE", 0);
|
|
sev_text_pt= min_severity;
|
|
Xorriso__text_to_sev(min_severity, &min_sev, 0);
|
|
if(min_sev < iso_sev && !(flag&4))
|
|
Xorriso__sev_to_text(iso_sev, &sev_text_pt, 0);
|
|
strcpy(sfe, msg_text_pt);
|
|
if(victim[0]) {
|
|
strcat(sfe, ": ");
|
|
Text_shellsafe(victim, sfe+strlen(sfe), 0);
|
|
}
|
|
ret= Xorriso_msgs_submit(xorriso, error_code, sfe, os_errno, sev_text_pt, 4);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= suppress messages below UPDATE
|
|
bit1= suppress messages below FAILURE
|
|
*/
|
|
int Xorriso_set_image_severities(struct XorrisO *xorriso, int flag)
|
|
{
|
|
char *queue_sev, *print_sev;
|
|
|
|
if(flag&2)
|
|
queue_sev= "FAILURE";
|
|
else if(flag&1)
|
|
queue_sev= "UPDATE";
|
|
else
|
|
queue_sev= "ALL";
|
|
if(xorriso->library_msg_direct_print)
|
|
print_sev= xorriso->report_about_text;
|
|
else
|
|
print_sev= "NEVER";
|
|
iso_set_msgs_severities(queue_sev, print_sev, "libisofs : ");
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_update_volid(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int gret, sret= 1;
|
|
|
|
gret= Xorriso_get_volid(xorriso, xorriso->loaded_volid, 0);
|
|
if(gret<=0 || (!xorriso->volid_default) || xorriso->loaded_volid[0]==0)
|
|
sret= Xorriso_set_volid(xorriso, xorriso->volid, 1);
|
|
return(gret>0 && sret>0);
|
|
}
|
|
|
|
|
|
int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
IsoImage *volset;
|
|
struct isoburn_read_opts *ropts;
|
|
struct burn_drive_info *dinfo= NULL;
|
|
struct burn_drive *drive= NULL;
|
|
|
|
if(xorriso->out_drive_handle != NULL) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to attach volset to drive", 2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
if(xorriso->in_volset_handle!=NULL) {
|
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle);
|
|
xorriso->in_volset_handle= NULL;
|
|
Sectorbitmap_destroy(&(xorriso->in_sector_map), 0);
|
|
Xorriso_destroy_di_array(xorriso, 0);
|
|
Xorriso_destroy_hln_array(xorriso, 0);
|
|
xorriso->loaded_volid[0]= 0;
|
|
xorriso->volset_change_pending= 0;
|
|
xorriso->no_volset_present= 0;
|
|
}
|
|
|
|
ret= isoburn_ropt_new(&ropts, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
/* Note: no return before isoburn_ropt_destroy() */
|
|
isoburn_ropt_set_extensions(ropts, isoburn_ropt_pretend_blank);
|
|
isoburn_ropt_set_input_charset(ropts, xorriso->in_charset);
|
|
isoburn_set_read_pacifier(drive, NULL, NULL);
|
|
ret= isoburn_read_image(drive, ropts, &volset);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
isoburn_ropt_destroy(&ropts, 0);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text, "Failed to create new empty ISO image object");
|
|
Xorriso_report_iso_error(xorriso, "", ret, xorriso->info_text, 0, "FATAL",
|
|
0);
|
|
return(-1);
|
|
}
|
|
xorriso->in_volset_handle= (void *) volset;
|
|
xorriso->in_sector_map= NULL;
|
|
Xorriso_update_volid(xorriso, 0);
|
|
xorriso->volset_change_pending= 0;
|
|
xorriso->no_volset_present= 0;
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_record_boot_info(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
IsoImage *image;
|
|
ElToritoBootImage *bootimg;
|
|
IsoFile *bootimg_node;
|
|
IsoBoot *bootcat_node;
|
|
|
|
xorriso->loaded_boot_bin_lba= -1;
|
|
xorriso->loaded_boot_cat_path[0]= 0;
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to record boot LBAs", 0);
|
|
if(ret<=0)
|
|
return(0);
|
|
image= isoburn_get_attached_image(drive);
|
|
if(image == NULL)
|
|
return(0);
|
|
ret= iso_image_get_boot_image(image, &bootimg,
|
|
&bootimg_node, &bootcat_node);
|
|
iso_image_unref(image); /* release obtained reference */
|
|
if(ret != 1)
|
|
return(0);
|
|
if(bootimg_node != NULL)
|
|
Xorriso__file_start_lba((IsoNode *) bootimg_node,
|
|
&(xorriso->loaded_boot_bin_lba), 0);
|
|
if(bootcat_node != NULL)
|
|
Xorriso_path_from_lba(xorriso, (IsoNode *) bootcat_node, 0,
|
|
xorriso->loaded_boot_cat_path, 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_assert_volid(struct XorrisO *xorriso, int msc1, int flag)
|
|
{
|
|
int ret, image_blocks;
|
|
char volid[33];
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
|
|
if(xorriso->assert_volid[0] == 0)
|
|
return(1);
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to perform -assert_volid", 0);
|
|
if(ret<=0)
|
|
return(0);
|
|
ret= isoburn_read_iso_head(drive, msc1, &image_blocks, volid, 1);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret <= 0) {
|
|
sprintf(xorriso->info_text,
|
|
"-assert_volid: Cannot determine Volume Id at LBA %d.", msc1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
|
|
xorriso->assert_volid_sev, 0);
|
|
return(0);
|
|
}
|
|
ret= Sregex_match(xorriso->assert_volid, volid, 0);
|
|
if(ret < 0)
|
|
return(2);
|
|
if(ret == 0) {
|
|
strcpy(xorriso->info_text,
|
|
"-assert_volid: Volume id does not match pattern: ");
|
|
Text_shellsafe(xorriso->assert_volid, xorriso->info_text, 1);
|
|
strcat(xorriso->info_text, " <> ");
|
|
Text_shellsafe(volid, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
|
|
xorriso->assert_volid_sev, 0);
|
|
return(0);
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= aquire as isoburn input drive
|
|
bit1= aquire as libburn output drive (as isoburn drive if bit0)
|
|
bit2= regard overwriteable media as blank
|
|
bit3= if the drive is a regular disk file: truncate it to
|
|
the write start address
|
|
bit5= do not print toc
|
|
@return <=0 failure , 1= ok
|
|
2=success, but not writeable with bit1
|
|
3=success, but not blank and not ISO with bit0
|
|
*/
|
|
int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag)
|
|
{
|
|
int ret, hret, not_writeable= 0, has_what, aquire_flag, load_lba, ext;
|
|
int lba, track, session, params_flag, adr_mode, read_ret;
|
|
uint32_t size;
|
|
struct burn_drive_info *dinfo= NULL, *out_dinfo, *in_dinfo;
|
|
struct burn_drive *drive, *out_drive, *in_drive;
|
|
enum burn_disc_status state;
|
|
IsoImage *volset = NULL;
|
|
IsoNode *root_node;
|
|
struct isoburn_read_opts *ropts= NULL;
|
|
char libburn_adr[SfileadrL], *boot_fate, *sev;
|
|
size_t value_length;
|
|
char *value= NULL;
|
|
double num;
|
|
char volid[33], adr_data[163], *adr_pt;
|
|
|
|
if((flag&3)==0) {
|
|
sprintf(xorriso->info_text,
|
|
"XORRISOBURN program error : Xorriso_aquire_drive bit0+bit1 not set");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
ret= Xorriso_give_up_drive(xorriso, (flag&3)|8);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(flag & 1)
|
|
xorriso->isofs_st_out= time(0) - 1;
|
|
|
|
ret= Xorriso_auto_driveadr(xorriso, adr, libburn_adr, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
if(strcmp(libburn_adr,"stdio:/dev/fd/1")==0) {
|
|
if(xorriso->dev_fd_1<0) {
|
|
sprintf(xorriso->info_text,
|
|
"-*dev \"stdio:/dev/fd/1\" was not a start argument. Cannot use it now.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
} else {
|
|
sprintf(libburn_adr, "stdio:/dev/fd/%d", xorriso->dev_fd_1);
|
|
}
|
|
}
|
|
|
|
if((flag&3)==1 && xorriso->out_drive_handle!=NULL) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive,
|
|
"on attempt to compare new indev with outdev", 2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= burn_drive_equals_adr(out_drive, libburn_adr, 1);
|
|
if(ret==1)
|
|
dinfo= out_dinfo;
|
|
} else if((flag&3)==2 && xorriso->in_drive_handle!=NULL) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &in_dinfo, &in_drive,
|
|
"on attempt to compare new outdev with indev", 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= burn_drive_equals_adr(in_drive, libburn_adr, 1);
|
|
if(ret==1)
|
|
dinfo= in_dinfo;
|
|
}
|
|
|
|
if(dinfo==NULL) {
|
|
aquire_flag= 1 | ((flag&(8|4))>>1) | ((xorriso->toc_emulation_flag & 3)<<3);
|
|
if(!(xorriso->do_aaip & 1))
|
|
aquire_flag|= 32;
|
|
if((xorriso->ino_behavior & (1 | 2)) && !(xorriso->do_aaip & (4 | 32)))
|
|
aquire_flag|= 64;
|
|
ret= isoburn_drive_aquire(&dinfo, libburn_adr, aquire_flag);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text,"Cannot aquire drive '%s'", adr);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(flag&1)
|
|
if(xorriso->image_start_mode&(1<<31)) /* used up setting */
|
|
xorriso->image_start_mode= 0; /* no need to perform auto setting */
|
|
}
|
|
drive= dinfo[0].drive;
|
|
if(flag&1) {
|
|
if(xorriso->image_start_mode&(1<<31)) /* used up setting */
|
|
xorriso->image_start_mode&= ~0xffff; /* perform auto setting */
|
|
if((xorriso->image_start_mode&(1<<30))) { /* if enabled at all */
|
|
adr_pt= xorriso->image_start_value;
|
|
adr_mode= xorriso->image_start_mode & 0xffff;
|
|
if(adr_mode == 4 && strlen(adr_pt) <= 80) {
|
|
/* Convert volid search expression into lba */
|
|
params_flag= 0;
|
|
ret= Xorriso__bourne_to_reg(xorriso->image_start_value, adr_data, 0);
|
|
if(ret == 1)
|
|
params_flag|= 4;
|
|
ret= isoburn_get_mount_params(drive, 4, adr_data, &lba, &track,
|
|
&session, volid, params_flag);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(session <= 0 || track <= 0 || ret == 2) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"-load : Given address does not point to an ISO 9660 session",
|
|
0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
sprintf(volid, "%d", lba);
|
|
adr_pt= volid;
|
|
adr_mode= 3;
|
|
}
|
|
ret= isoburn_set_msc1(drive, adr_mode, adr_pt,
|
|
!!(xorriso->image_start_mode & (1<<16)));
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(xorriso->image_start_mode&(1<<31))
|
|
xorriso->image_start_mode= 0; /* disable msc1 setting completely */
|
|
else
|
|
xorriso->image_start_mode|= (1<<31); /* mark as used up */
|
|
}
|
|
}
|
|
state= isoburn_disc_get_status(drive);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(flag&1) {
|
|
volset= isoburn_get_attached_image(drive);
|
|
if(volset != NULL) { /* The image object is already created */
|
|
iso_image_unref(volset);
|
|
}
|
|
}
|
|
|
|
if(flag&2) {
|
|
xorriso->out_drive_handle= dinfo;
|
|
if(Sfile_str(xorriso->outdev, adr, 0)<=0)
|
|
{ret= -1; goto ex;}
|
|
if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {
|
|
sprintf(xorriso->info_text, "Disc status unsuitable for writing");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
not_writeable= 1;
|
|
}
|
|
}
|
|
if(flag&1) {
|
|
xorriso->in_drive_handle= dinfo;
|
|
if(Sfile_str(xorriso->indev, adr, 0)<=0)
|
|
{ret= -1; goto ex;}
|
|
} else if(flag&2) {
|
|
if(xorriso->in_volset_handle==NULL) {
|
|
/* No volume loaded: create empty one */
|
|
ret= Xorriso_create_empty_iso(xorriso, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
} else {
|
|
iso_image_ref((IsoImage *) xorriso->in_volset_handle);
|
|
ret= isoburn_attach_image(drive, (IsoImage *) xorriso->in_volset_handle);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text,
|
|
"Failed to attach ISO image object to outdev");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
}
|
|
if(!(flag&32))
|
|
Xorriso_toc(xorriso, 1 | 2 | 8);
|
|
{ret= 1+not_writeable; goto ex;}
|
|
}
|
|
|
|
if(xorriso->in_volset_handle!=NULL)
|
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle);
|
|
xorriso->in_volset_handle= NULL;
|
|
Sectorbitmap_destroy(&(xorriso->in_sector_map), 0);
|
|
Xorriso_destroy_hln_array(xorriso, 0);
|
|
Xorriso_destroy_di_array(xorriso, 0);
|
|
|
|
/* check for invalid state */
|
|
if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE &&
|
|
state != BURN_DISC_FULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Disc status not blank and unsuitable for reading");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
/* fill read opts */
|
|
ret= isoburn_ropt_new(&ropts, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
ext= isoburn_ropt_noiso1999;
|
|
if((xorriso->ino_behavior & (1 | 2)) && !(xorriso->do_aaip & (1 | 4 | 32))
|
|
&& !(xorriso->do_md5 & 1))
|
|
ext|= isoburn_ropt_noaaip;
|
|
if(!(xorriso->do_aaip & 1))
|
|
ext|= isoburn_ropt_noacl;
|
|
if(!(xorriso->do_aaip & 4))
|
|
ext|= isoburn_ropt_noea;
|
|
if(xorriso->ino_behavior & 1)
|
|
ext|= isoburn_ropt_noino;
|
|
|
|
#ifdef isoburn_ropt_nomd5
|
|
if(!(xorriso->do_md5 & 1))
|
|
ext|= isoburn_ropt_nomd5;
|
|
#endif
|
|
|
|
isoburn_ropt_set_extensions(ropts, ext);
|
|
|
|
isoburn_ropt_set_default_perms(ropts, (uid_t) 0, (gid_t) 0, (mode_t) 0555);
|
|
isoburn_ropt_set_input_charset(ropts, xorriso->in_charset);
|
|
isoburn_ropt_set_auto_incharset(ropts, !!(xorriso->do_aaip & 512));
|
|
|
|
Xorriso_set_image_severities(xorriso, 1); /* No DEBUG messages */
|
|
Xorriso_pacifier_reset(xorriso, 0);
|
|
isoburn_set_read_pacifier(drive, Xorriso__read_pacifier, (void *) xorriso);
|
|
|
|
/* <<< Trying to work around too much tolerance on bad image trees.
|
|
Better would be a chance to instruct libisofs what to do in
|
|
case of image read errors. There is a risk to mistake other SORRYs.
|
|
*/
|
|
if(xorriso->img_read_error_mode>0)
|
|
iso_set_abort_severity("SORRY");
|
|
|
|
if(state != BURN_DISC_BLANK) {
|
|
ret= isoburn_disc_get_msc1(drive, &load_lba);
|
|
if(ret > 0) {
|
|
sprintf(xorriso->info_text,
|
|
"Loading ISO image tree from LBA %d", load_lba);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
ret= Xorriso_assert_volid(xorriso, load_lba, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
|
|
read_ret= ret= isoburn_read_image(drive, ropts, &volset);
|
|
|
|
/* <<< Resetting to normal thresholds */
|
|
if(xorriso->img_read_error_mode>0)
|
|
Xorriso_set_abort_severity(xorriso, 0);
|
|
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_set_image_severities(xorriso, 0);
|
|
Xorriso_give_up_drive(xorriso, 1|((flag&32)>>2));
|
|
sprintf(xorriso->info_text,"Cannot read ISO image tree");
|
|
sev= "FAILURE";
|
|
if(xorriso->img_read_error_mode==2)
|
|
sev= "FATAL";
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, sev, 0);
|
|
if(read_ret == ISO_SB_TREE_CORRUPTED && (xorriso->do_md5 & 1)) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"You might get a questionable ISO image tree by option -md5 'off'.",
|
|
0, "HINT", 0);
|
|
} else if(xorriso->img_read_error_mode!=0) {
|
|
Xorriso_msgs_submit(xorriso, 0, "You might get a partial or altered ISO image tree by option -error_behavior 'image_loading' 'best_effort' if -abort_on is set to be tolerant enough.",
|
|
0, "HINT", 0);
|
|
}
|
|
|
|
|
|
ret= 3; goto ex;
|
|
}
|
|
Xorriso_pacifier_callback(xorriso, "nodes read", xorriso->pacifier_count, 0,
|
|
"", 1); /* report end count */
|
|
xorriso->in_volset_handle= (void *) volset;
|
|
xorriso->in_sector_map= NULL;
|
|
Xorriso_set_image_severities(xorriso, 0);
|
|
Xorriso_update_volid(xorriso, 0);
|
|
|
|
if(xorriso->out_drive_handle != NULL &&
|
|
xorriso->out_drive_handle != xorriso->in_drive_handle) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive,
|
|
"on attempt to attach ISO image volset to outdev", 2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
iso_image_ref((IsoImage *) xorriso->in_volset_handle);
|
|
isoburn_attach_image(out_drive, xorriso->in_volset_handle);
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
isoburn_ropt_get_size_what(ropts, &size, &has_what);
|
|
if(has_what & isoburn_ropt_has_el_torito) {
|
|
if(xorriso->boot_image_bin_path[0])
|
|
boot_fate= "replaced by an isolinux image";
|
|
else if(xorriso->patch_isolinux_image)
|
|
boot_fate= "patched as isolinux image";
|
|
else if(xorriso->keep_boot_image)
|
|
boot_fate= "kept unchanged";
|
|
else
|
|
boot_fate= "discarded";
|
|
sprintf(xorriso->info_text,
|
|
"Detected El-Torito boot information which currently is set to be %s",
|
|
boot_fate);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
Xorriso_record_boot_info(xorriso, 0);
|
|
}
|
|
|
|
if(flag & 1) {
|
|
/* Look for isofs.st and put it into xorriso->isofs_st_in */;
|
|
root_node= (IsoNode *) iso_image_get_root(volset);
|
|
ret= iso_node_lookup_attr(root_node, "isofs.st", &value_length, &value, 0);
|
|
if(ret > 0) {
|
|
if(value_length > 0) {
|
|
sscanf(value, "%lf", &num);
|
|
if(num > 0)
|
|
xorriso->isofs_st_in= num;
|
|
}
|
|
free(value);
|
|
}
|
|
}
|
|
|
|
if(!(flag&32)) {
|
|
Xorriso_toc(xorriso, 1 | 8);
|
|
if(xorriso->loaded_volid[0]!=0) {
|
|
sprintf(xorriso->info_text,"Volume id : '%s'\n",
|
|
xorriso->loaded_volid);
|
|
Xorriso_info(xorriso, 0);
|
|
if(strcmp(xorriso->loaded_volid, xorriso->volid) != 0 &&
|
|
!xorriso->volid_default) {
|
|
sprintf(xorriso->info_text, "New volume id: '%s'\n", xorriso->volid);
|
|
Xorriso_info(xorriso, 0);
|
|
}
|
|
}
|
|
}
|
|
ret= 1+not_writeable;
|
|
ex:
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret<=0) {
|
|
hret= Xorriso_give_up_drive(xorriso, (flag&3)|((flag&32)>>2));
|
|
if(hret<ret)
|
|
ret= hret;
|
|
}
|
|
if(ropts!=NULL)
|
|
isoburn_ropt_destroy(&ropts, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0=input drive
|
|
bit1=output drive
|
|
bit2=eject
|
|
bit3=no info message or toc
|
|
*/
|
|
int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int in_is_out_too, ret;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
char sfe[5*SfileadrL];
|
|
|
|
in_is_out_too= (xorriso->in_drive_handle == xorriso->out_drive_handle);
|
|
if((flag&4) && in_is_out_too && (flag&(1|2))) {
|
|
if((flag&3)!=3) {
|
|
sprintf(xorriso->info_text,"Giving up for -eject whole -dev %s",
|
|
Text_shellsafe(xorriso->indev, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
flag|= 3; /* give up in/out drive to eject it */
|
|
}
|
|
|
|
if((flag&1) && xorriso->in_drive_handle != NULL) {
|
|
Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to give up drive", 0);
|
|
|
|
if(!in_is_out_too) {
|
|
if(drive!=NULL)
|
|
isoburn_drive_release(drive,!!(flag&4));
|
|
if(dinfo!=NULL)
|
|
burn_drive_info_free(dinfo);
|
|
}
|
|
xorriso->in_drive_handle= NULL;
|
|
xorriso->indev[0]= 0;
|
|
|
|
if(xorriso->in_volset_handle!=NULL)
|
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle);
|
|
xorriso->in_volset_handle= NULL;
|
|
Sectorbitmap_destroy(&(xorriso->in_sector_map), 0);
|
|
Xorriso_destroy_di_array(xorriso, 0);
|
|
Xorriso_destroy_hln_array(xorriso, 0);
|
|
xorriso->loaded_volid[0]= 0;
|
|
xorriso->isofs_st_out= time(0) - 1;
|
|
xorriso->isofs_st_in= 0;
|
|
xorriso->volset_change_pending= 0;
|
|
xorriso->no_volset_present= 0;
|
|
xorriso->loaded_boot_bin_lba= 0;
|
|
xorriso->loaded_boot_cat_path[0]= 0;
|
|
in_is_out_too= 0;
|
|
}
|
|
if((flag&2) && xorriso->out_drive_handle!=NULL) {
|
|
Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to give up drive", 2);
|
|
if(!in_is_out_too) {
|
|
if(drive!=NULL)
|
|
isoburn_drive_release(drive,!!(flag&4));
|
|
if(dinfo!=NULL)
|
|
burn_drive_info_free(dinfo);
|
|
}
|
|
xorriso->out_drive_handle= NULL;
|
|
xorriso->outdev[0]= 0;
|
|
} else if((flag&1) && xorriso->out_drive_handle!=NULL) {
|
|
ret= Xorriso_create_empty_iso(xorriso, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(!(flag&8)) {
|
|
sprintf(xorriso->info_text,
|
|
"Only the output drive remains. Created empty ISO image.\n");
|
|
Xorriso_info(xorriso, 0);
|
|
Xorriso_toc(xorriso, 1 | 2 | 8);
|
|
}
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_make_write_options(
|
|
struct XorrisO *xorriso, struct burn_drive *drive,
|
|
struct burn_write_opts **burn_options, int flag)
|
|
{
|
|
int drive_role, stream_mode= 0;
|
|
|
|
*burn_options= burn_write_opts_new(drive);
|
|
if(*burn_options==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,"Cannot allocate option set");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
burn_write_opts_set_simulate(*burn_options, !!xorriso->do_dummy);
|
|
drive_role= burn_drive_get_drive_role(drive);
|
|
burn_write_opts_set_multi(*burn_options,
|
|
!(xorriso->do_close || drive_role==0 || drive_role==3));
|
|
burn_drive_set_speed(drive, xorriso->speed, xorriso->speed);
|
|
if(xorriso->do_stream_recording == 1)
|
|
stream_mode= 1;
|
|
else if(xorriso->do_stream_recording == 2)
|
|
stream_mode= 51200; /* 100 MB */
|
|
else if(xorriso->do_stream_recording >= 16)
|
|
stream_mode= xorriso->do_stream_recording;
|
|
burn_write_opts_set_stream_recording(*burn_options, stream_mode);
|
|
burn_write_opts_set_underrun_proof(*burn_options, 1);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not write but only prepare and return size in sectors
|
|
bit1= do not use isoburn wrappers
|
|
*/
|
|
int Xorriso_sanitize_image_size(struct XorrisO *xorriso,
|
|
struct burn_drive *drive, struct burn_disc *disc,
|
|
struct burn_write_opts *burn_options, int flag)
|
|
{
|
|
int ret, img_sectors, num_sessions= 0, num_tracks= 0, padding= 0, profile;
|
|
int media_space, lba, nwa;
|
|
char profile_name[80];
|
|
struct burn_session **sessions;
|
|
struct burn_track **tracks;
|
|
|
|
img_sectors= burn_disc_get_sectors(disc);
|
|
|
|
sessions= burn_disc_get_sessions(disc, &num_sessions);
|
|
if(sessions==NULL || num_sessions < 1) {
|
|
no_track:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,"Program error : no track in prepared disc");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
tracks= burn_session_get_tracks(sessions[0], &num_tracks);
|
|
if(tracks==NULL || num_tracks < 1)
|
|
goto no_track;
|
|
|
|
padding= 0;
|
|
ret= burn_disc_get_profile(drive, &profile, profile_name);
|
|
padding= xorriso->padding / 2048;
|
|
if(xorriso->padding > padding * 2048)
|
|
padding++;
|
|
if(img_sectors>0 && ret>0 &&
|
|
(profile==0x09 || profile==0x0a)) { /* CD-R , CD-RW */
|
|
if(img_sectors + padding < Xorriso_cd_min_track_sizE) {
|
|
padding= Xorriso_cd_min_track_sizE - img_sectors;
|
|
sprintf(xorriso->info_text,
|
|
"Expanded track to minimum size of %d sectors",
|
|
Xorriso_cd_min_track_sizE);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
}
|
|
if(xorriso->alignment > 0) {
|
|
if(img_sectors > 0) {
|
|
ret= isoburn_disc_track_lba_nwa(drive, burn_options, 0, &lba, &nwa);
|
|
if(ret <= 0)
|
|
nwa= 0;
|
|
lba= (nwa + img_sectors + padding) % xorriso->alignment;
|
|
if(lba > 0)
|
|
padding+= xorriso->alignment - lba;
|
|
} else if(padding < xorriso->alignment)
|
|
padding= xorriso->alignment;
|
|
}
|
|
burn_track_define_data(tracks[0], 0, padding * 2048, 0, BURN_MODE1);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
if(flag&2)
|
|
media_space= burn_disc_available_space(drive, burn_options) /
|
|
(off_t) 2048;
|
|
else
|
|
media_space= isoburn_disc_available_space(drive, burn_options) /
|
|
(off_t) 2048;
|
|
if(media_space < img_sectors + padding) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,"Image size %ds exceeds free space on media %ds",
|
|
img_sectors + padding, media_space);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(flag&1) {
|
|
ret= img_sectors+padding;
|
|
} else
|
|
ret= 1;
|
|
ex:;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @return <0 yes , 0 no , <0 error */
|
|
int Xorriso_is_isohybrid(struct XorrisO *xorriso, IsoFile *bootimg_node,
|
|
int flag)
|
|
{
|
|
int ret;
|
|
unsigned char buf[68];
|
|
void *data_stream= NULL;
|
|
|
|
ret= Xorriso_iso_file_open(xorriso, "", (void *) bootimg_node,
|
|
&data_stream, 1);
|
|
if(ret <= 0)
|
|
return(-1);
|
|
ret= Xorriso_iso_file_read(xorriso, data_stream, (char *) buf, 68, 0);
|
|
Xorriso_iso_file_close(xorriso, &data_stream, 0);
|
|
if(ret <= 0)
|
|
return(0);
|
|
if(buf[64] == 0xfb && buf[65] == 0xc0 && buf[66] == 0x78 && buf[67] == 0x70)
|
|
return(1);
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso_set_isolinux_options(struct XorrisO *xorriso,
|
|
IsoImage *image, int flag)
|
|
{
|
|
int make_isohybrid_mbr= 0, ret;
|
|
ElToritoBootImage *bootimg;
|
|
IsoFile *bootimg_node;
|
|
|
|
ret= iso_image_get_boot_image(image, &bootimg, &bootimg_node, NULL);
|
|
if(ret != 1) {
|
|
sprintf(xorriso->info_text, "Programming error: No boot image available in Xorriso_set_isolinux_options()");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
|
|
if(xorriso->boot_image_isohybrid == 0) {
|
|
ret= el_torito_set_isolinux_options(bootimg, 1, 0);
|
|
return(ret == 1);
|
|
}
|
|
if(xorriso->boot_image_isohybrid == 3) {
|
|
make_isohybrid_mbr= 1;
|
|
} else {
|
|
ret= Xorriso_is_isohybrid(xorriso, bootimg_node, 0);
|
|
if(ret < 0)
|
|
return(0);
|
|
if(ret > 0)
|
|
make_isohybrid_mbr= 1;
|
|
}
|
|
|
|
if(xorriso->boot_image_isohybrid == 2 && !make_isohybrid_mbr) {
|
|
sprintf(xorriso->info_text,
|
|
"Isohybrid signature is demanded but not found in boot image file.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
if(make_isohybrid_mbr) {
|
|
sprintf(xorriso->info_text, "Will write isohybrid MBR.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
xorriso->alignment= 512;
|
|
}
|
|
|
|
ret= el_torito_set_isolinux_options(bootimg, 1 | (make_isohybrid_mbr << 1),0);
|
|
return(ret == 1);
|
|
}
|
|
|
|
|
|
int Xorriso_auto_format(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, profile, status, num_formats;
|
|
char profile_name[80];
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
off_t size;
|
|
unsigned dummy;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to autoformat", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
ret= burn_disc_get_profile(drive, &profile, profile_name);
|
|
if(ret>0 && (profile==0x12 || profile==0x43)) { /* DVD-RAM or BD-RE */
|
|
ret= burn_disc_get_formats(drive, &status, &size, &dummy, &num_formats);
|
|
if(ret>0 && status==BURN_FORMAT_IS_UNFORMATTED) {
|
|
sprintf(xorriso->info_text,
|
|
"Unformatted %s media detected. Trying -format fast.",
|
|
profile_name);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= Xorriso_format_media(xorriso, (off_t) 0, 1 | 4);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text, "Automatic formatting of %s failed",
|
|
profile_name);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(ret);
|
|
}
|
|
}
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
#define Xorriso_with_make_isohybrid_mbR 1
|
|
|
|
|
|
/* @param flag bit0= do not write but only prepare and return size in sectors
|
|
*/
|
|
int Xorriso_write_session(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, relax= 0, i, pacifier_speed= 0, data_lba, ext;
|
|
int major, minor, micro;
|
|
char xorriso_id[256], *img_id, sfe[5*SfileadrL], *cpt, *out_cs;
|
|
struct isoburn_imgen_opts *sopts= NULL;
|
|
struct burn_drive_info *dinfo, *source_dinfo;
|
|
struct burn_drive *drive, *source_drive;
|
|
struct burn_disc *disc= NULL;
|
|
struct burn_write_opts *burn_options;
|
|
off_t readcounter= 0,writecounter= 0;
|
|
int num_sessions= 0, num_tracks= 0;
|
|
struct burn_session **sessions;
|
|
struct burn_track **tracks;
|
|
enum burn_disc_status s;
|
|
IsoImage *image= NULL;
|
|
IsoNode *node, *root_node;
|
|
ElToritoBootImage *bootimg;
|
|
enum eltorito_boot_media_type emul_type= ELTORITO_NO_EMUL;
|
|
int profile_number;
|
|
char profile_name[80];
|
|
|
|
ret= Xorriso_finish_hl_update(xorriso, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
|
|
out_cs= xorriso->out_charset;
|
|
if(out_cs == NULL)
|
|
Xorriso_get_local_charset(xorriso, &out_cs, 0);
|
|
|
|
if(!(flag & 1)) {
|
|
ret= Xorriso_auto_format(xorriso, 0);
|
|
if(ret <=0 )
|
|
return(0);
|
|
}
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to write", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
if(xorriso->out_drive_handle == xorriso->in_drive_handle) {
|
|
source_drive= drive;
|
|
} else {
|
|
if(xorriso->in_drive_handle == NULL) {
|
|
source_drive= drive;
|
|
} else {
|
|
ret= Xorriso_get_drive_handles(xorriso, &source_dinfo, &source_drive,
|
|
"on attempt to get source for write", 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
s= isoburn_disc_get_status(drive);
|
|
if(s!=BURN_DISC_BLANK) {
|
|
s= burn_disc_get_status(drive);
|
|
if(s!=BURN_DISC_BLANK)
|
|
sprintf(xorriso->info_text,
|
|
"-indev differs from -outdev and -outdev media is not blank");
|
|
else
|
|
sprintf(xorriso->info_text,
|
|
"-indev differs from -outdev and -outdev media holds non-zero data");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
ret= Xorriso_get_profile(xorriso, &profile_number, profile_name, 2);
|
|
if(ret == 2)
|
|
pacifier_speed= 1;
|
|
else if(ret == 3)
|
|
pacifier_speed= 2;
|
|
|
|
ret= isoburn_igopt_new(&sopts, 0);
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
return(ret);
|
|
}
|
|
relax= xorriso->relax_compliance;
|
|
|
|
xorriso->alignment= 0;
|
|
image= isoburn_get_attached_image(source_drive);
|
|
if(image != NULL) {
|
|
iso_image_set_application_id(image, xorriso->application_id);
|
|
iso_image_set_publisher_id(image, xorriso->publisher);
|
|
}
|
|
|
|
if((xorriso->do_aaip & 256) && out_cs != NULL) {
|
|
static char *names = "isofs.cs";
|
|
size_t value_lengths[1];
|
|
|
|
value_lengths[0]= strlen(out_cs);
|
|
ret= Xorriso_setfattr(xorriso, NULL, "/",
|
|
(size_t) 1, &names, value_lengths, &out_cs, 2 | 8);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
|
|
/* Activate, adjust or discard boot image */
|
|
/* >>> ??? move down to libisoburn ? */
|
|
if(image!=NULL && !(flag&1)) {
|
|
ret= iso_image_get_boot_image(image, &bootimg, NULL, NULL);
|
|
|
|
if(xorriso->boot_image_bin_path[0]) {
|
|
/* discard old boot image, set new one */
|
|
if(ret == 1)
|
|
iso_image_remove_boot_image(image);
|
|
if(xorriso->boot_image_emul == 1)
|
|
emul_type= ELTORITO_HARD_DISC_EMUL;
|
|
else if(xorriso->boot_image_emul == 2)
|
|
emul_type= ELTORITO_FLOPPY_EMUL;
|
|
if(xorriso->boot_image_cat_path[0] == 0) {
|
|
strcpy(xorriso->boot_image_cat_path, xorriso->boot_image_bin_path);
|
|
cpt= strrchr(xorriso->boot_image_cat_path, '/');
|
|
if(cpt == NULL)
|
|
cpt= xorriso->boot_image_cat_path;
|
|
else
|
|
cpt++;
|
|
strcpy(cpt, "boot.cat");
|
|
}
|
|
sprintf(xorriso->info_text, "Activating alleged isolinux boot image %s",
|
|
Text_shellsafe(xorriso->boot_image_bin_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
sprintf(xorriso->info_text, "Creating El Torito boot catalog file %s",
|
|
Text_shellsafe(xorriso->boot_image_cat_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
|
|
ret= Xorriso_node_from_path(xorriso, image, xorriso->boot_image_bin_path,
|
|
&node, 1);
|
|
if(ret <= 0) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot find in ISO image: -boot_image ... bin_path=%s",
|
|
Text_shellsafe(xorriso->boot_image_bin_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
ret= Xorriso_node_from_path(xorriso, image, xorriso->boot_image_cat_path,
|
|
&node, 1);
|
|
if(ret > 0) {
|
|
if(!xorriso->do_overwrite) {
|
|
sprintf(xorriso->info_text,
|
|
"May not overwite existing -boot_image ... cat_path=%s",
|
|
Text_shellsafe(xorriso->boot_image_cat_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
ret= Xorriso_rmi(xorriso, NULL, (off_t) 0, xorriso->boot_image_cat_path,
|
|
8 | (xorriso->do_overwrite == 1));
|
|
if(ret != 1) {
|
|
sprintf(xorriso->info_text,
|
|
"Could not remove existing -boot_image cat_path=%s",
|
|
Text_shellsafe(xorriso->boot_image_cat_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
|
|
ret= iso_image_set_boot_image(image, xorriso->boot_image_bin_path,
|
|
emul_type, xorriso->boot_image_cat_path,
|
|
&bootimg);
|
|
if(ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when attaching El-Torito boot image to ISO 9660 image",
|
|
0, "FAILURE", 1);
|
|
sprintf(xorriso->info_text,
|
|
"Could not attach El-Torito boot image to ISO 9660 image");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
el_torito_set_load_size(bootimg, xorriso->boot_image_load_size / 512);
|
|
|
|
#ifdef Xorriso_with_make_isohybrid_mbR
|
|
|
|
ret= Xorriso_set_isolinux_options(xorriso, image, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
|
|
#else
|
|
el_torito_patch_isolinux_image(bootimg);
|
|
#endif
|
|
|
|
} else if(xorriso->patch_isolinux_image) {
|
|
if(ret==1) {
|
|
relax|= isoburn_igopt_allow_full_ascii;
|
|
sprintf(xorriso->info_text, "Patching alleged isolinux boot image");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
|
|
ret= Xorriso_path_from_lba(xorriso, NULL, xorriso->loaded_boot_bin_lba,
|
|
sfe, 1);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot patch boot image: no file found for its LBA.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Probably the loaded boot image file was deleted in this session.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Use -boot_image \"any\" \"discard\" or set new boot image");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
|
|
goto ex;
|
|
}
|
|
|
|
#ifdef Xorriso_with_make_isohybrid_mbR
|
|
|
|
ret= Xorriso_set_isolinux_options(xorriso, image, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
|
|
#else
|
|
el_torito_patch_isolinux_image(bootimg);
|
|
#endif
|
|
|
|
} else {
|
|
sprintf(xorriso->info_text,
|
|
"Could not find any boot image for -boot_image isolinux patch");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
}
|
|
} else if(xorriso->keep_boot_image && ret==1) {
|
|
relax|= isoburn_igopt_allow_full_ascii;
|
|
sprintf(xorriso->info_text, "Keeping boot image unchanged");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
} else if(ret==1) {
|
|
iso_image_remove_boot_image(image);
|
|
sprintf(xorriso->info_text, "Discarded boot image from old session");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
}
|
|
|
|
if((xorriso->do_aaip & 16) || !(xorriso->ino_behavior & 2)) {
|
|
/* Overwrite isofs.st of root node by xorriso->isofs_st_out */
|
|
char *name= "isofs.st";
|
|
char timestamp[16], *value= timestamp;
|
|
size_t value_length;
|
|
|
|
sprintf(timestamp, "%.f", (double) xorriso->isofs_st_out);
|
|
value_length= strlen(timestamp);
|
|
Xorriso_setfattr(xorriso, NULL, "/", (size_t) 1, &name,
|
|
&value_length, &value, 2 | 8);
|
|
}
|
|
|
|
isoburn_igopt_set_level(sopts, 3);
|
|
ext= isoburn_igopt_rockridge |
|
|
((!!xorriso->do_joliet) * isoburn_igopt_joliet) |
|
|
(( !(xorriso->ino_behavior & 2)) * isoburn_igopt_hardlinks) |
|
|
(( (!(xorriso->ino_behavior & 2)) ||
|
|
(xorriso->do_aaip & (2 | 8 | 16 | 256)) ||
|
|
(xorriso->do_md5 & (2 | 4))
|
|
) * isoburn_igopt_aaip) |
|
|
((!!(xorriso->do_md5 & 2)) * isoburn_igopt_session_md5) |
|
|
((!!(xorriso->do_md5 & 4)) * isoburn_igopt_file_md5) |
|
|
((!!(xorriso->do_md5 & 8)) * isoburn_igopt_file_stability);
|
|
isoburn_igopt_set_extensions(sopts, ext);
|
|
isoburn_igopt_set_relaxed(sopts, relax);
|
|
isoburn_igopt_set_sort_files(sopts, 1);
|
|
isoburn_igopt_set_over_mode(sopts, 0, 0, (mode_t) 0, (mode_t) 0);
|
|
isoburn_igopt_set_over_ugid(sopts, 0, 0, (uid_t) 0, (gid_t) 0);
|
|
isoburn_igopt_set_out_charset(sopts, out_cs);
|
|
isoburn_igopt_set_fifo_size(sopts, xorriso->fs * 2048);
|
|
|
|
if(image!=NULL &&
|
|
strlen(Xorriso_program_versioN)+strlen(Xorriso_timestamP)<80) {
|
|
sprintf(xorriso_id, "XORRISO-%s %s",
|
|
Xorriso_program_versioN, Xorriso_timestamP);
|
|
isoburn_version(&major, &minor, µ);
|
|
if(strlen(xorriso_id)<80)
|
|
sprintf(xorriso_id+strlen(xorriso_id),
|
|
", LIBISOBURN-%d.%d.%d", major, minor, micro);
|
|
iso_lib_version(&major, &minor, µ);
|
|
if(strlen(xorriso_id)<80)
|
|
sprintf(xorriso_id+strlen(xorriso_id),
|
|
", LIBISOFS-%d.%d.%d", major, minor, micro);
|
|
burn_version(&major, &minor, µ);
|
|
if(strlen(xorriso_id)<80)
|
|
sprintf(xorriso_id+strlen(xorriso_id),
|
|
", LIBBURN-%d.%d.%d", major, minor, micro);
|
|
xorriso_id[128]= 0;
|
|
img_id= (char *) iso_image_get_data_preparer_id(image);
|
|
if(img_id!=NULL) {
|
|
for(i= strlen(img_id)-1; i>=0 && img_id[i]==' '; i--);
|
|
if(i>0) {
|
|
sprintf(xorriso->info_text, "Overwrote previous preparer id '%s'",
|
|
img_id);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
}
|
|
iso_image_set_data_preparer_id(image, xorriso_id);
|
|
}
|
|
|
|
/* Make final abort check before starting expensive activities */
|
|
ret= Xorriso_eval_problem_status(xorriso, 1, 0);
|
|
if(ret<0)
|
|
{ret= 0; goto ex;}
|
|
|
|
if(xorriso->zisofs_by_magic) {
|
|
sprintf(xorriso->info_text,
|
|
"Checking disk file content for zisofs compression headers.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
|
|
root_node= (IsoNode *) iso_image_get_root(image);
|
|
ret= iso_node_zf_by_magic(root_node,
|
|
(xorriso->out_drive_handle == xorriso->in_drive_handle) | 2 | 16);
|
|
if(ret<0) {
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when examining file content for zisofs headers",
|
|
0, "FAILURE", 1);
|
|
}
|
|
ret= Xorriso_eval_problem_status(xorriso, 1, 0);
|
|
if(ret<0)
|
|
{ret= 0; goto ex;}
|
|
sprintf(xorriso->info_text,
|
|
"Check for zisofs compression headers done.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
|
|
}
|
|
|
|
/* >>> omit iso_image_update_sizes if the image was filled up very quickly */;
|
|
|
|
ret= iso_image_update_sizes(image);
|
|
if(ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
if(ret<0) {
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when updating file sizes",
|
|
0, "FAILURE", 1);
|
|
}
|
|
ret= Xorriso_eval_problem_status(xorriso, 1, 0);
|
|
if(ret<0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
Xorriso_set_abort_severity(xorriso, 1);
|
|
if (xorriso->grow_blindly_msc2 >= 0 &&
|
|
xorriso->out_drive_handle != xorriso->in_drive_handle) {
|
|
ret= isoburn_prepare_blind_grow(source_drive, &disc, sopts, drive,
|
|
xorriso->grow_blindly_msc2);
|
|
if(ret>0) {
|
|
/* Allow the consumer of output to access the input drive */
|
|
source_drive= NULL;
|
|
ret= Xorriso_give_up_drive(xorriso, 1|8);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
} else if(xorriso->out_drive_handle == xorriso->in_drive_handle ||
|
|
xorriso->in_drive_handle == NULL) {
|
|
ret= isoburn_prepare_disc(source_drive, &disc, sopts);
|
|
} else {
|
|
ret= isoburn_prepare_new_image(source_drive, &disc, sopts, drive);
|
|
}
|
|
if(ret <= 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,"Failed to prepare session write run");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
isoburn_igopt_get_effective_lba(sopts, &(xorriso->session_lba));
|
|
if(xorriso->do_stream_recording == 2) {
|
|
ret= isoburn_igopt_get_data_start(sopts, &data_lba);
|
|
if(ret > 0 && data_lba >= 16)
|
|
burn_write_opts_set_stream_recording(burn_options, data_lba);
|
|
}
|
|
|
|
ret= Xorriso_sanitize_image_size(xorriso, drive, disc, burn_options, flag&1);
|
|
if(ret<=0 || (flag&1)) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(flag&1) /* set queue severity to FAILURE */
|
|
Xorriso_set_image_severities(xorriso, 2);
|
|
isoburn_cancel_prepared_write(source_drive, drive, 0);
|
|
if(flag&1) /* reset queue severity */
|
|
Xorriso_set_image_severities(xorriso, 0);
|
|
goto ex;
|
|
}
|
|
|
|
xorriso->run_state= 1; /* Indicate that burning has started */
|
|
isoburn_disc_write(burn_options, disc);
|
|
burn_write_opts_free(burn_options);
|
|
|
|
ret= Xorriso_pacifier_loop(xorriso, drive, pacifier_speed << 4);
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(!isoburn_drive_wrote_well(drive)) {
|
|
isoburn_cancel_prepared_write(source_drive, drive, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"libburn indicates failure with writing.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
sessions= burn_disc_get_sessions(disc, &num_sessions);
|
|
if(num_sessions>0) {
|
|
tracks= burn_session_get_tracks(sessions[0], &num_tracks);
|
|
if(tracks!=NULL && num_tracks>0) {
|
|
burn_track_get_counters(tracks[0],&readcounter,&writecounter);
|
|
xorriso->session_blocks= (int) (writecounter/ (off_t) 2048);
|
|
sprintf(xorriso->info_text,
|
|
"ISO image produced: %d sectors\nWritten to media : %d sectors at LBA %d\n",
|
|
(int) (readcounter/ (off_t) 2048),
|
|
xorriso->session_blocks, xorriso->session_lba);
|
|
Xorriso_info(xorriso, 0);
|
|
}
|
|
}
|
|
ret= isoburn_activate_session(drive);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text,
|
|
"Could not write new set of volume descriptors");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
goto ex;
|
|
}
|
|
/* Done early to free any reference to the libisofs resources via disc */
|
|
if(disc!=NULL)
|
|
burn_disc_free(disc);
|
|
disc= NULL;
|
|
/* To wait for the end of the libisofs threads and their messages. */
|
|
isoburn_sync_after_write(source_drive, drive, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
sprintf(xorriso->info_text, "Writing to %s completed sucessfully.\n\n",
|
|
Text_shellsafe(xorriso->outdev,sfe,0));
|
|
Xorriso_info(xorriso, 0);
|
|
ret= 1;
|
|
ex:;
|
|
xorriso->run_state= 0; /* Indicate that burning has ended */
|
|
Xorriso_set_abort_severity(xorriso, 0);
|
|
|
|
if(ret<=0) {
|
|
|
|
/* >>> ??? revive discarded boot image */;
|
|
|
|
}
|
|
if(disc!=NULL)
|
|
burn_disc_free(disc);
|
|
if(image != NULL)
|
|
iso_image_unref(image);
|
|
isoburn_igopt_destroy(&sopts, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_check_burn_abort(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
|
|
if(xorriso->run_state!=1)
|
|
return(0);
|
|
ret= Xorriso_eval_problem_status(xorriso, 1, 1);
|
|
if(ret>=0)
|
|
return(0);
|
|
sprintf(xorriso->info_text,
|
|
"-abort_on '%s' encountered '%s' during image writing",
|
|
xorriso->abort_on_text, xorriso->problem_status_text);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
|
|
xorriso->problem_status_text, 0);
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to abort burn run", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
burn_drive_cancel(drive);
|
|
sprintf(xorriso->info_text,
|
|
"libburn has now been urged to cancel its operation");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* This loop watches burn runs until they end.
|
|
It issues pacifying update messages to the user.
|
|
@param flag bit0-3 = emulation mode
|
|
0= xorriso
|
|
1= mkisofs
|
|
2= cdrecord
|
|
bit4= report speed in CD units
|
|
bit5= report speed in BD units
|
|
*/
|
|
int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
|
|
int flag)
|
|
{
|
|
int ret, size, free_bytes, i, aborting= 0, emul, buffer_fill= 50, last_sector;
|
|
struct burn_progress progress;
|
|
char *status_text, date_text[80], *speed_unit, mem_text[8];
|
|
enum burn_drive_status drive_status;
|
|
double start_time, current_time, last_time, base_time= 0.0, base_count= 0.0;
|
|
double next_base_time= 0.0, next_base_count= 0.0, first_base_time= 0.0;
|
|
double first_base_count= 0.0, norm= 0.0, now_time, fract_offset= 0.0;
|
|
double measured_speed, speed_factor= 1385000, quot;
|
|
time_t time_prediction;
|
|
|
|
start_time= Sfile_microtime(0);
|
|
while(burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING)
|
|
usleep(100002);
|
|
|
|
emul= flag&15;
|
|
fract_offset= 0.2 * (double) emul - ((int) (0.2 * (double) emul));
|
|
if(emul==0)
|
|
emul= xorriso->pacifier_style;
|
|
speed_unit= "D";
|
|
if(flag&16) {
|
|
speed_factor= 150.0*1024;
|
|
speed_unit= "C";
|
|
} else if(flag & 32) {
|
|
speed_factor= 4495625;
|
|
speed_unit= "B";
|
|
}
|
|
progress.sector= 0;
|
|
current_time= Sfile_microtime(0);
|
|
measured_speed= 0.0;
|
|
while(1) {
|
|
last_time= current_time;
|
|
last_sector= progress.sector;
|
|
drive_status= burn_drive_get_status(drive, &progress);
|
|
if(drive_status == BURN_DRIVE_IDLE)
|
|
break;
|
|
current_time= Sfile_microtime(0);
|
|
if(drive_status == BURN_DRIVE_WRITING && progress.sectors > 0) {
|
|
if(current_time-last_time>0.2)
|
|
measured_speed= (progress.sector - last_sector) * 2048.0 /
|
|
(current_time - last_time);
|
|
buffer_fill= 50;
|
|
if(progress.buffer_capacity>0)
|
|
buffer_fill= (double) (progress.buffer_capacity
|
|
- progress.buffer_available) * 100.0
|
|
/ (double) progress.buffer_capacity;
|
|
if(emul==2) {
|
|
if(progress.sector<=progress.sectors)
|
|
sprintf(xorriso->info_text, "%4d of %4d MB written",
|
|
progress.sector / 512, progress.sectors / 512);
|
|
else
|
|
sprintf(xorriso->info_text, "%4d MB written",
|
|
progress.sector / 512);
|
|
|
|
if(xorriso->pacifier_fifo!=NULL)
|
|
ret= burn_fifo_inquire_status(xorriso->pacifier_fifo,
|
|
&size, &free_bytes, &status_text);
|
|
else
|
|
ret= isoburn_get_fifo_status(drive, &size, &free_bytes, &status_text);
|
|
if(ret>0 )
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
" (fifo %2d%%)",
|
|
(int) (100.0-100.0*((double) free_bytes)/(double) size));
|
|
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), " [buf %3d%%]",
|
|
buffer_fill);
|
|
|
|
if(current_time-last_time>0.2)
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), " %4.1fx.",
|
|
measured_speed/speed_factor);
|
|
|
|
} else if(emul == 1 &&
|
|
progress.sectors > 0 && progress.sector <= progress.sectors) {
|
|
/* "37.87% done, estimate finish Tue Jul 15 18:55:07 2008" */
|
|
|
|
quot= ((double) progress.sector) / ((double) progress.sectors);
|
|
sprintf(xorriso->info_text, " %2.2f%% done", quot*100.0);
|
|
if(current_time - start_time >= 2 && quot > 0.0 &&
|
|
(quot >= 0.02 || progress.sector >= 5*1024)) {
|
|
if(base_time == 0.0 && progress.sector >= 16*1024) {
|
|
first_base_time= base_time= next_base_time= current_time;
|
|
first_base_count= next_base_count= progress.sector;
|
|
} else if(next_base_time > 0 && current_time - next_base_time >= 10) {
|
|
base_time= next_base_time;
|
|
base_count= next_base_count;
|
|
next_base_time= current_time;
|
|
next_base_count= progress.sector;
|
|
}
|
|
if(first_base_time > 0 &&
|
|
current_time - first_base_time >= 10 &&
|
|
progress.sectors > first_base_count &&
|
|
progress.sector > first_base_count) {
|
|
norm= (1.0 - quot);
|
|
if(norm < 0.0001)
|
|
norm= 0.0001;
|
|
quot= ((double) progress.sector - first_base_count)
|
|
/ ((double) progress.sectors - first_base_count);
|
|
time_prediction= norm * (1.0 - quot) / quot
|
|
* (current_time - first_base_time);
|
|
} else {
|
|
time_prediction= (1.0 - quot) / quot * (current_time - start_time);
|
|
norm= 1.0;
|
|
}
|
|
if(base_time > 0 &&
|
|
current_time - base_time >= 10 && progress.sectors > base_count) {
|
|
quot= ((double) progress.sector - base_count)
|
|
/ ((double) progress.sectors - base_count);
|
|
time_prediction+= (1.0 - quot) / quot * (current_time - base_time);
|
|
norm+= 1.0;
|
|
}
|
|
time_prediction/= norm;
|
|
if(time_prediction < 30*86400 && time_prediction > 0) {
|
|
time_prediction+= current_time + 1;
|
|
Ftimetxt(time_prediction, date_text, 4);
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
", estimate finish %s", date_text);
|
|
}
|
|
}
|
|
} else {
|
|
if(progress.sector<=progress.sectors) {
|
|
if(progress.sectors <= 0)
|
|
strcpy(mem_text, " 99.9");
|
|
else
|
|
sprintf(mem_text, "%5.1f",
|
|
100.0 * ((double) progress.sector) / ((double) progress.sectors));
|
|
mem_text[5]= 0;
|
|
sprintf(xorriso->info_text, "Writing: %10ds %s%% ",
|
|
progress.sector, mem_text);
|
|
} else {
|
|
Sfile_scale(2048.0 * (double) progress.sector, mem_text, 5, 1e4, 1);
|
|
sprintf(xorriso->info_text, "Writing: %10ds %s ",
|
|
progress.sector, mem_text);
|
|
}
|
|
ret= isoburn_get_fifo_status(drive, &size, &free_bytes, &status_text);
|
|
if(ret>0 )
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
" fifo %3d%% buf %3d%%",
|
|
(int) (100.0-100.0*((double) free_bytes)/(double) size),
|
|
buffer_fill);
|
|
if(current_time-last_time>0.2)
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), " %5.1fx%s ",
|
|
measured_speed/speed_factor, speed_unit);
|
|
}
|
|
} else if(drive_status == BURN_DRIVE_CLOSING_SESSION ||
|
|
drive_status == BURN_DRIVE_CLOSING_TRACK)
|
|
sprintf(xorriso->info_text,
|
|
"Closing track/session. Working since %.f seconds",
|
|
current_time-start_time);
|
|
else if(drive_status == BURN_DRIVE_FORMATTING)
|
|
sprintf(xorriso->info_text, "Formatting. Working since %.f seconds",
|
|
current_time-start_time);
|
|
else
|
|
sprintf(xorriso->info_text,
|
|
"Thank you for being patient. Working since %.f seconds.",
|
|
current_time-start_time);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
|
|
|
|
for(i= 0; i<12; i++) { /* 2 usleeps more than supposed to be needed */
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
if(aborting<=0)
|
|
aborting= Xorriso_check_burn_abort(xorriso, 0);
|
|
usleep(100000);
|
|
now_time= Sfile_microtime(0);
|
|
if(((time_t) now_time) - ((time_t) current_time) >= 1 &&
|
|
now_time - ((time_t) now_time) >= fract_offset)
|
|
break;
|
|
}
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso__read_pacifier(IsoImage *image, IsoFileSource *filesource)
|
|
{
|
|
struct XorrisO *xorriso;
|
|
|
|
xorriso= (struct XorrisO *) iso_image_get_attached_data(image);
|
|
if(xorriso==NULL)
|
|
return(1);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
xorriso->pacifier_count++;
|
|
if(xorriso->pacifier_count%10)
|
|
return(1);
|
|
Xorriso_pacifier_callback(xorriso, "nodes read", xorriso->pacifier_count, 0,
|
|
"", 0);
|
|
return(1);
|
|
}
|
|
|
|
/* @param flag bit0=silently return 0 if no volume/image is present
|
|
*/
|
|
int Xorriso_get_volume(struct XorrisO *xorriso, IsoImage **volume,
|
|
int flag)
|
|
{
|
|
if(xorriso->in_volset_handle==NULL) {
|
|
if(flag & 1)
|
|
return(0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,"No ISO image present.");
|
|
if(xorriso->indev[0]==0 && xorriso->outdev[0]==0)
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
" No -dev, -indev, or -outdev selected.");
|
|
else
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
" Possible program error with drive '%s'.", xorriso->indev);
|
|
|
|
if(!xorriso->no_volset_present)
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
xorriso->no_volset_present= 1;
|
|
return(0);
|
|
}
|
|
*volume= (IsoImage *) xorriso->in_volset_handle;
|
|
xorriso->no_volset_present= 0;
|
|
return(*volume != NULL);
|
|
}
|
|
|
|
|
|
/* @param flag bit0=do not complain about non existent node */
|
|
int Xorriso_node_from_path(struct XorrisO *xorriso, IsoImage *volume,
|
|
char *path, IsoNode **node, int flag)
|
|
{
|
|
int ret;
|
|
char sfe[5*SfileadrL], *path_pt;
|
|
|
|
path_pt= path;
|
|
if(path[0]==0)
|
|
path_pt= "/";
|
|
if(volume == NULL) {
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
}
|
|
*node= NULL;
|
|
ret= iso_tree_path_to_node(volume, path_pt, node);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret<=0 || (*node)==NULL) {
|
|
if(!(flag&1)) {
|
|
sprintf(xorriso->info_text, "Cannot find path %s in loaded ISO image",
|
|
Text_shellsafe(path_pt, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
}
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @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
|
|
bit3= return root directory as "/" and not as ""
|
|
bit4= (with bit2) determine type of disk file eff_path
|
|
and return 0 if not existing
|
|
bit5= (with bit3) this is not a parameter
|
|
bit6= insist in having an ISO image, even with bits1+2
|
|
@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)
|
|
{
|
|
int ret, is_dir= 0, done= 0;
|
|
IsoImage *volume;
|
|
IsoDir *dir= NULL;
|
|
IsoNode *node= NULL;
|
|
char path[SfileadrL], *apt, *npt, sfe[5*SfileadrL], *cpt;
|
|
|
|
if((flag&64) || !(flag&2)) {
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
|
|
eff_path[0]= 0;
|
|
if(img_path[0]==0) {
|
|
if(flag&8)
|
|
strcpy(eff_path, "/");
|
|
return(2); /* root directory */
|
|
}
|
|
|
|
apt= npt= path;
|
|
if(img_path[0]!='/') {
|
|
strcpy(path, wd);
|
|
ret= Sfile_add_to_path(path, img_path, 0);
|
|
if(ret<=0)
|
|
goto much_too_long;
|
|
} else
|
|
if(Sfile_str(path, img_path, 0)<=0)
|
|
return(-1);
|
|
|
|
if(path[0]!='/') {
|
|
sprintf(xorriso->info_text,
|
|
"Internal error: Unresolvable relative addressing in iso_rr_path '%s'",
|
|
img_path);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FATAL", 0);
|
|
return(-1);
|
|
} else if(path[1]==0) {
|
|
if(flag&8)
|
|
strcpy(eff_path, "/");
|
|
return(2); /* root directory */
|
|
}
|
|
|
|
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++;
|
|
if(done)
|
|
break;
|
|
continue;
|
|
}
|
|
if(strcmp(apt,".")==0) {
|
|
is_dir= 1;
|
|
continue;
|
|
}
|
|
if(strcmp(apt,"..")==0) {
|
|
if(!(flag&2)) {
|
|
node= (IsoNode *) dir;
|
|
if(node==NULL) {
|
|
bonked_root:;
|
|
sprintf(xorriso->info_text,
|
|
"Relative addressing in path exceeds root directory: %s",
|
|
Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(-1);
|
|
}
|
|
dir= iso_node_get_parent(node);
|
|
}
|
|
/* truncate eff_path */;
|
|
cpt= strrchr(eff_path, '/');
|
|
if(cpt==NULL) /* ??? if not flag&2 then this is a bug */
|
|
goto bonked_root;
|
|
*cpt= 0;
|
|
is_dir= 1;
|
|
continue;
|
|
}
|
|
ret= Sfile_add_to_path(eff_path, apt, 0);
|
|
if(ret<=0) {
|
|
much_too_long:;
|
|
sprintf(xorriso->info_text, "Effective path gets much too long (%d)",
|
|
(int) (strlen(eff_path)+strlen(apt)+1));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(-1);
|
|
}
|
|
if(!(flag&2)) {
|
|
dir= (IsoDir *) node;
|
|
ret= Xorriso_node_from_path(xorriso, volume, eff_path, &node, flag&1);
|
|
if(ret<=0)
|
|
return(0);
|
|
if(dir==NULL) /* could be false with "/dir/.." */
|
|
dir= iso_node_get_parent(node);
|
|
is_dir= LIBISO_ISDIR(node);
|
|
}
|
|
}
|
|
if(flag&16) {
|
|
ret= Sfile_type(eff_path,
|
|
1|(4*(xorriso->do_follow_links || (xorriso->do_follow_param && !(flag&32)))
|
|
));
|
|
if(ret<0)
|
|
return(0);
|
|
if(ret==2)
|
|
is_dir= 1;
|
|
}
|
|
return(1+!!is_dir);
|
|
}
|
|
|
|
|
|
int Xorriso_get_node_by_path(struct XorrisO *xorriso,
|
|
char *in_path, char *eff_path,
|
|
IsoNode **node, int flag)
|
|
{
|
|
int ret;
|
|
char path[SfileadrL];
|
|
IsoImage *volume;
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, in_path, path, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(eff_path!=NULL)
|
|
strcpy(eff_path, path);
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_node_from_path(xorriso, volume, path, node, 0);
|
|
if(ret<=0)
|
|
return(0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag
|
|
*/
|
|
int Xorriso_node_get_dev(struct XorrisO *xorriso, IsoNode *node,
|
|
char *path, dev_t *dev, int flag)
|
|
{
|
|
*dev= iso_special_get_dev((IsoSpecial *) node);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= *node is already valid
|
|
bit1= add extra block for size estimation
|
|
bit2= complain loudely if path is missing in image
|
|
bit3= stbuf is to be used without eventual ACL
|
|
bit4= try to obtain a better st_nlink count if hardlinks
|
|
are enabled
|
|
*/
|
|
int Xorriso_fake_stbuf(struct XorrisO *xorriso, char *path, struct stat *stbuf,
|
|
IsoNode **node, int flag)
|
|
{
|
|
int ret, min_hl, max_hl, node_idx, i;
|
|
IsoImage *volume;
|
|
|
|
memset((char *) stbuf, 0, sizeof(struct stat));
|
|
if(!(flag&1)) {
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(-1);
|
|
ret= Xorriso_node_from_path(xorriso, volume, path, node, !(flag&4));
|
|
if(ret<=0)
|
|
*node= NULL;
|
|
}
|
|
if(*node==NULL)
|
|
return(0);
|
|
|
|
/* >>> stbuf->st_dev */
|
|
/* >>> stbuf->st_ino */
|
|
|
|
if(flag & 8)
|
|
stbuf->st_mode= iso_node_get_perms_wo_acl(*node) & 07777;
|
|
else
|
|
stbuf->st_mode= iso_node_get_permissions(*node) & 07777;
|
|
if(LIBISO_ISDIR(*node))
|
|
stbuf->st_mode|= S_IFDIR;
|
|
else if(LIBISO_ISREG(*node))
|
|
stbuf->st_mode|= S_IFREG;
|
|
else if(LIBISO_ISLNK(*node))
|
|
stbuf->st_mode|= S_IFLNK;
|
|
else if(LIBISO_ISCHR(*node)) {
|
|
stbuf->st_mode|= S_IFCHR;
|
|
Xorriso_node_get_dev(xorriso, *node, path, &(stbuf->st_rdev), 0);
|
|
} else if(LIBISO_ISBLK(*node)) {
|
|
stbuf->st_mode|= S_IFBLK;
|
|
Xorriso_node_get_dev(xorriso, *node, path, &(stbuf->st_rdev), 0);
|
|
} else if(LIBISO_ISFIFO(*node))
|
|
stbuf->st_mode|= S_IFIFO;
|
|
else if(LIBISO_ISSOCK(*node))
|
|
stbuf->st_mode|= S_IFSOCK;
|
|
else if(LIBISO_ISBOOT(*node))
|
|
stbuf->st_mode|= Xorriso_IFBOOT;
|
|
|
|
/* >>> With directories this should be : number of subdirs + 2 */
|
|
/* >>> ??? How to obtain RR hardlink number for other types ? */
|
|
/* This may get overriden farther down */
|
|
stbuf->st_nlink= 1;
|
|
|
|
stbuf->st_uid= iso_node_get_uid(*node);
|
|
stbuf->st_gid= iso_node_get_gid(*node);
|
|
|
|
if(LIBISO_ISREG(*node))
|
|
stbuf->st_size= iso_file_get_size((IsoFile *) *node)+ (2048 * !!(flag&2));
|
|
else
|
|
stbuf->st_size= 0;
|
|
|
|
stbuf->st_blksize= 2048;
|
|
stbuf->st_blocks= stbuf->st_size / (off_t) 2048;
|
|
if(stbuf->st_blocks * (off_t) 2048 != stbuf->st_size)
|
|
stbuf->st_blocks++;
|
|
|
|
stbuf->st_atime= iso_node_get_atime(*node);
|
|
stbuf->st_mtime= iso_node_get_mtime(*node);
|
|
stbuf->st_ctime= iso_node_get_ctime(*node);
|
|
|
|
if(LIBISO_ISDIR(*node) || (xorriso->ino_behavior & 1) || (!(flag & 16)) ||
|
|
xorriso->hln_array == NULL)
|
|
return(1);
|
|
|
|
/* Try to obtain a better link count */
|
|
ret= Xorriso_search_hardlinks(xorriso, *node, &node_idx, &min_hl, &max_hl, 0);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret > 0 && node_idx >= 0) {
|
|
for(i= min_hl; i <= max_hl; i++) {
|
|
if(i == node_idx)
|
|
continue;
|
|
/* Check whether node is still valid */
|
|
if(iso_node_get_parent(xorriso->hln_array[i]) != NULL)
|
|
stbuf->st_nlink++;
|
|
}
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag >>> bit0= follow links (i.e. stat() rather than lstat()
|
|
bit1= do not return -2 on severe errors
|
|
bit2= complain loudely if path is missing in image
|
|
*/
|
|
int Xorriso_iso_lstat(struct XorrisO *xorriso, char *path, struct stat *stbuf,
|
|
int flag)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
|
|
if(flag&1) {
|
|
|
|
/* >>> follow link in ISO image */;
|
|
|
|
}
|
|
|
|
ret= Xorriso_fake_stbuf(xorriso, path, stbuf, &node, flag&4);
|
|
if(ret>0)
|
|
return(0);
|
|
if(ret<0 && !(flag&2))
|
|
return(-2);
|
|
return(-1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= give directory x-permission where is r-permission
|
|
bit1= do not transfer ACL or xattr
|
|
bit2= record dev,inode (only if enabled by xorriso)
|
|
bit5= transfer ACL or xattr from eventual link target
|
|
*/
|
|
int Xorriso_transfer_properties(struct XorrisO *xorriso, struct stat *stbuf,
|
|
char *disk_path, IsoNode *node, int flag)
|
|
{
|
|
mode_t mode;
|
|
int ret= 1;
|
|
size_t num_attrs= 0, *value_lengths= NULL;
|
|
char **names= NULL, **values= NULL;
|
|
|
|
mode= stbuf->st_mode;
|
|
|
|
if((!(flag & 2)) && !(xorriso->do_aaip & 1))
|
|
/* Will drop ACL. Update mode S_IRWXG by eventual group:: ACL entry */
|
|
iso_local_get_perms_wo_acl(disk_path, &mode, flag & 32);
|
|
|
|
if((flag&1) && S_ISDIR(mode)) {
|
|
if(mode&S_IRUSR)
|
|
mode|= S_IXUSR;
|
|
if(mode&S_IRGRP)
|
|
mode|= S_IXGRP;
|
|
if(mode&S_IROTH)
|
|
mode|= S_IXOTH;
|
|
}
|
|
iso_node_set_permissions(node, mode & 07777);
|
|
iso_node_set_uid(node, stbuf->st_uid);
|
|
iso_node_set_gid(node, stbuf->st_gid);
|
|
iso_node_set_atime(node, stbuf->st_atime);
|
|
iso_node_set_mtime(node, stbuf->st_mtime);
|
|
iso_node_set_ctime(node, stbuf->st_ctime);
|
|
|
|
if((xorriso->do_aaip & 5) && !(flag & 2)) {
|
|
ret= iso_local_get_attrs(disk_path, &num_attrs, &names, &value_lengths,
|
|
&values, ((xorriso->do_aaip & 1) && !(flag & 2))
|
|
| ((!(xorriso->do_aaip & 4)) << 2)
|
|
| (flag & 32));
|
|
if(ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, disk_path, ret,
|
|
"Error when obtaining local ACL and xattr", 0,
|
|
"FAILURE", 1 | 2);
|
|
ret= 0; goto ex;
|
|
}
|
|
ret= iso_node_set_attrs(node, num_attrs, names, value_lengths, values,
|
|
1 | 8);
|
|
if(ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when setting ACL and xattr to image node",
|
|
0, "FAILURE", 1);
|
|
ret= 0; goto ex;
|
|
}
|
|
}
|
|
|
|
if((flag & 4) && ((xorriso->do_aaip & 16) || !(xorriso->ino_behavior & 2))) {
|
|
ret= Xorriso_record_dev_inode(xorriso, disk_path, (dev_t) 0, (ino_t) 0,
|
|
(void *) node, "", flag & 32);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
iso_local_get_attrs(disk_path, &num_attrs, &names, &value_lengths,
|
|
&values, 1 << 15); /* free memory */
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_graft_split(struct XorrisO *xorriso, IsoImage *volume,
|
|
IsoDir *dir, char *disk_path, char *img_name,
|
|
char *nominal_source, char *nominal_target,
|
|
off_t size, IsoNode **node, int flag)
|
|
{
|
|
int ret;
|
|
IsoDir *new_dir= NULL;
|
|
IsoNode *part_node;
|
|
int partno, total_parts;
|
|
off_t offset;
|
|
char part_name[SfileadrL], sfe[5*SfileadrL];
|
|
|
|
ret= iso_tree_add_new_dir(dir, img_name, &new_dir);
|
|
if(ret<0)
|
|
return(ret);
|
|
*node= (IsoNode *) new_dir;
|
|
|
|
total_parts= size / xorriso->split_size;
|
|
if(size % xorriso->split_size)
|
|
total_parts++;
|
|
for(partno= 1; partno<=total_parts; partno++) {
|
|
offset = xorriso->split_size * (off_t) (partno-1);
|
|
Splitpart__compose(part_name, partno, total_parts, offset,
|
|
xorriso->split_size, size, 0);
|
|
ret= Xorriso_tree_graft_node(xorriso, volume,
|
|
new_dir, disk_path, part_name,
|
|
nominal_source, nominal_target,
|
|
offset, xorriso->split_size,
|
|
&part_node, 8);
|
|
if(ret<=0)
|
|
return(0);
|
|
}
|
|
sprintf(xorriso->info_text, "Split into %d parts: %s",
|
|
total_parts, Text_shellsafe(nominal_target, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit3= cut_out_node: offset and size are valid
|
|
*/
|
|
int Xorriso_tree_graft_node(struct XorrisO *xorriso, IsoImage *volume,
|
|
IsoDir *dir, char *disk_path, char *img_name,
|
|
char *nominal_source, char *nominal_target,
|
|
off_t offset, off_t cut_size,
|
|
IsoNode **node, int flag)
|
|
{
|
|
int ret, stbuf_valid= 0;
|
|
struct stat stbuf;
|
|
char sfe[5*SfileadrL];
|
|
off_t size= 0;
|
|
|
|
if(lstat(disk_path, &stbuf) != -1) {
|
|
stbuf_valid= 1;
|
|
if(S_ISREG(stbuf.st_mode))
|
|
size= stbuf.st_size;
|
|
}
|
|
if(flag&8) {
|
|
if(cut_size > xorriso->file_size_limit && xorriso->file_size_limit > 0) {
|
|
sprintf(xorriso->info_text,
|
|
"File piece exceeds size limit of %.f bytes: %.f from %s\n",
|
|
(double) xorriso->file_size_limit, (double) cut_size,
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
ret= iso_tree_add_new_cut_out_node(volume, dir, img_name, disk_path,
|
|
offset, cut_size, node);
|
|
if(ret<0)
|
|
goto ex;
|
|
} else {
|
|
if(xorriso->split_size > 0 && size > xorriso->split_size) {
|
|
ret= Xorriso_graft_split(xorriso, volume, dir, disk_path, img_name,
|
|
nominal_source, nominal_target, size,
|
|
node, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
return(1);
|
|
} else if(size > xorriso->file_size_limit && xorriso->file_size_limit > 0) {
|
|
sprintf(xorriso->info_text,
|
|
"File exceeds size limit of %.f bytes: %s\n",
|
|
(double) xorriso->file_size_limit,
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
ret= iso_tree_add_new_node(volume, dir, img_name, disk_path, node);
|
|
if(ret<0)
|
|
goto ex;
|
|
}
|
|
|
|
if(stbuf_valid && ((xorriso->do_aaip & 16) || !(xorriso->ino_behavior & 2))) {
|
|
ret= Xorriso_record_dev_inode(xorriso, disk_path,
|
|
stbuf.st_dev, stbuf.st_ino, (void *) *node, "", 1);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
|
|
ex:;
|
|
if(ret<0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, nominal_source, ret,
|
|
"Cannot add node to tree", 0, "FAILURE", 1|2);
|
|
return(ret);
|
|
}
|
|
if(LIBISO_ISREG(*node))
|
|
xorriso->pacifier_byte_count+= iso_file_get_size((IsoFile *) *node);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= recursion is active
|
|
bit1= do not report added files
|
|
bit6= do not delete eventually existing node from di_array
|
|
*/
|
|
int Xorriso_add_tree(struct XorrisO *xorriso, IsoDir *dir,
|
|
char *img_dir_path, char *disk_dir_path,
|
|
struct LinkiteM *link_stack, int flag)
|
|
{
|
|
IsoImage *volume;
|
|
IsoNode *node;
|
|
int ret, target_is_dir, source_is_dir, source_is_link, fret, was_failure= 0;
|
|
int do_not_dive, target_is_split= 0;
|
|
struct DirseQ *dirseq= NULL;
|
|
char *name, *img_name, *srcpt, *stbuf_src= "";
|
|
struct stat stbuf, hstbuf;
|
|
dev_t dir_dev;
|
|
struct LinkiteM *own_link_stack;
|
|
char *sfe= NULL, *sfe2= NULL;
|
|
char *disk_path= NULL, *img_path= NULL, *link_target= NULL;
|
|
|
|
/* Avoiding large local memory objects in order to save stack space */
|
|
sfe= malloc(5*SfileadrL);
|
|
sfe2= malloc(5*SfileadrL);
|
|
disk_path= malloc(2*SfileadrL);
|
|
img_path= malloc(2*SfileadrL);
|
|
link_target= calloc(SfileadrL, 1);
|
|
if(sfe==NULL || sfe2==NULL || disk_path==NULL || img_path==NULL ||
|
|
link_target==NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, &sfe, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
own_link_stack= link_stack;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
stbuf_src= disk_dir_path;
|
|
if(lstat(disk_dir_path, &stbuf)==-1)
|
|
goto cannot_open_dir;
|
|
dir_dev= stbuf.st_dev;
|
|
if(S_ISLNK(stbuf.st_mode)) {
|
|
if(!(xorriso->do_follow_links || (xorriso->do_follow_param && !(flag&1))))
|
|
{ret= 2; goto ex;}
|
|
stbuf_src= disk_dir_path;
|
|
if(stat(disk_dir_path, &stbuf)==-1)
|
|
goto cannot_open_dir;
|
|
if(dir_dev != stbuf.st_dev &&
|
|
!(xorriso->do_follow_mount || (xorriso->do_follow_param && !(flag&1))))
|
|
{ret= 2; goto ex;}
|
|
}
|
|
ret= Dirseq_new(&dirseq, disk_dir_path, 1);
|
|
if(ret<0) {
|
|
sprintf(xorriso->info_text,"Failed to create source filesystem iterator");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
if(ret==0) {
|
|
cannot_open_dir:;
|
|
Xorriso_msgs_submit(xorriso, 0, disk_dir_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,"Cannot open as source directory: %s",
|
|
Text_shellsafe(disk_dir_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
if(Sfile_str(disk_path, disk_dir_path,0)<=0)
|
|
{ret= -1; goto ex;}
|
|
if(disk_path[0]==0 || disk_path[strlen(disk_path)-1]!='/')
|
|
strcat(disk_path,"/");
|
|
name= disk_path+strlen(disk_path);
|
|
if(Sfile_str(img_path, img_dir_path, 0)<=0)
|
|
{ret= -1; goto ex;}
|
|
if(img_path[0] || img_path[strlen(img_path)-1]!='/')
|
|
strcat(img_path,"/");
|
|
img_name= img_path+strlen(img_path);
|
|
|
|
while(1) { /* loop over directory content */
|
|
stbuf_src= "";
|
|
Linkitem_reset_stack(&own_link_stack, link_stack, 0);
|
|
srcpt= disk_path;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
ret= Dirseq_next_adr(dirseq,name,0); /* name is a pointer into disk_path */
|
|
if(ret==0)
|
|
break;
|
|
if(ret<0) {
|
|
sprintf(xorriso->info_text,"Failed to obtain next directory entry");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
/* compare exclusions against disk_path resp. name */
|
|
ret= Xorriso_path_is_excluded(xorriso, disk_path, 0); /* (is never param) */
|
|
if(ret<0)
|
|
{ret= -1; goto ex;}
|
|
if(ret>0)
|
|
continue;
|
|
|
|
strcpy(img_name, name);
|
|
if(Xorriso_much_too_long(xorriso, strlen(img_path), 0)<=0)
|
|
{ret= 0; goto was_problem;}
|
|
if(Xorriso_much_too_long(xorriso, strlen(srcpt), 0)<=0)
|
|
{ret= 0; goto was_problem;}
|
|
stbuf_src= srcpt;
|
|
if(lstat(srcpt, &stbuf)==-1) {
|
|
cannot_lstat:;
|
|
Xorriso_msgs_submit(xorriso, 0, srcpt, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot determine attributes of source file %s",
|
|
Text_shellsafe(srcpt, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
ret= 0; goto was_problem;
|
|
}
|
|
source_is_dir= 0;
|
|
source_is_link= S_ISLNK(stbuf.st_mode);
|
|
if(xorriso->do_follow_links && source_is_link) {
|
|
/* Xorriso_hop_link checks for wide link loops */
|
|
ret= Xorriso_hop_link(xorriso, srcpt, &own_link_stack, &hstbuf, 0);
|
|
if(ret<0)
|
|
goto was_problem;
|
|
if(ret==1) {
|
|
ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 0);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
srcpt= link_target;
|
|
stbuf_src= srcpt;
|
|
if(lstat(srcpt, &stbuf)==-1)
|
|
goto cannot_lstat;
|
|
} else {
|
|
if(Xorriso_eval_problem_status(xorriso, 0, 1|2)<0)
|
|
{ret= 0; goto was_problem;}
|
|
ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 1);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
}
|
|
} else if (S_ISLNK(stbuf.st_mode)) {
|
|
ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 1);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
}
|
|
do_not_dive= 0;
|
|
if(S_ISDIR(stbuf.st_mode)) {
|
|
source_is_dir= 1;
|
|
if(dir_dev != stbuf.st_dev && !xorriso->do_follow_mount)
|
|
do_not_dive= 1;
|
|
}
|
|
|
|
/* does a node exist with this name ? */
|
|
node= NULL;
|
|
ret= Xorriso_node_from_path(xorriso, volume, img_path, &node, 1);
|
|
if(ret>0) {
|
|
target_is_dir= LIBISO_ISDIR(node);
|
|
target_is_split= 0;
|
|
if(target_is_dir)
|
|
target_is_split= Xorriso_is_split(xorriso, "", (void *) node, 1);
|
|
|
|
if(!((target_is_dir && !target_is_split) && source_is_dir)) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
/* handle overwrite situation */;
|
|
if(xorriso->do_overwrite==1 ||
|
|
(xorriso->do_overwrite==2 && !(target_is_dir && !target_is_split))) {
|
|
ret= Xorriso_rmi(xorriso, NULL, (off_t) 0, img_path,
|
|
1 | 8 | (flag & 64));
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
if(ret==3) {
|
|
sprintf(xorriso->info_text, "User revoked adding of: %s",
|
|
Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= 0; goto was_problem;
|
|
}
|
|
node= NULL;
|
|
} else {
|
|
Xorriso_msgs_submit(xorriso, 0, srcpt, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"While grafting %s : file object exists and may not be overwritten by %s",
|
|
Text_shellsafe(img_path,sfe,0), Text_shellsafe(stbuf_src,sfe2,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto was_problem;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(node==NULL) {
|
|
ret= Xorriso_tree_graft_node(xorriso, volume, dir, srcpt, img_name,
|
|
"", img_path, (off_t) 0, (off_t) 0,
|
|
&node, 0);
|
|
}
|
|
if(node==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_msgs_submit(xorriso, 0, stbuf_src, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text, "Grafting failed: %s = %s",
|
|
Text_shellsafe(img_path,sfe,0), Text_shellsafe(stbuf_src,sfe2,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto was_problem;
|
|
}
|
|
|
|
xorriso->pacifier_count++;
|
|
if((xorriso->pacifier_count%100)==0)
|
|
Xorriso_pacifier_callback(xorriso, "files added", xorriso->pacifier_count,
|
|
xorriso->pacifier_total, "", 0);
|
|
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
if(source_is_dir) {
|
|
if(do_not_dive) {
|
|
sprintf(xorriso->info_text, "Did not follow mount point : %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
} else {
|
|
ret= Xorriso_add_tree(xorriso, (IsoDir *) node,
|
|
img_path, disk_path, own_link_stack,
|
|
1 | (flag & (2 | 64)));
|
|
}
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
}
|
|
|
|
continue; /* regular bottom of loop */
|
|
was_problem:;
|
|
was_failure= 1;
|
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
|
|
if(fret<0)
|
|
goto ex;
|
|
}
|
|
|
|
ret= 1;
|
|
ex:
|
|
if(sfe!=NULL)
|
|
free(sfe);
|
|
if(sfe2!=NULL)
|
|
free(sfe2);
|
|
if(disk_path!=NULL)
|
|
free(disk_path);
|
|
if(img_path!=NULL)
|
|
free(img_path);
|
|
if(link_target!=NULL)
|
|
free(link_target);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Linkitem_reset_stack(&own_link_stack, link_stack, 0);
|
|
Dirseq_destroy(&dirseq, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
return(!was_failure);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= cut_out mode : base on leaf parent directory
|
|
*/
|
|
int Xorriso_copy_implicit_properties(struct XorrisO *xorriso, IsoDir *dir,
|
|
char *full_img_path, char *img_path, char *full_disk_path, int flag)
|
|
{
|
|
int ret, nfic, nic, nfdc, d, i;
|
|
char nfi[SfileadrL], ni[SfileadrL], nfd[SfileadrL], *cpt;
|
|
char sfe[5*SfileadrL];
|
|
struct stat stbuf;
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, full_img_path, nfi,
|
|
1|2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, img_path, ni, 1|2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, full_disk_path, nfd,
|
|
1|2|4);
|
|
if(ret<=0)
|
|
return(ret);
|
|
nfic= Sfile_count_components(nfi, 0);
|
|
nic= Sfile_count_components(ni, 0);
|
|
nfdc= Sfile_count_components(nfd, 0);
|
|
d= nfic-(flag&1)-nic;
|
|
if(d<0)
|
|
return(-1);
|
|
if(d>nfdc)
|
|
return(0);
|
|
for(i= 0; i<d; i++) {
|
|
cpt= strrchr(nfd, '/');
|
|
if(cpt==NULL)
|
|
return(-1); /* should not happen */
|
|
*cpt= 0;
|
|
}
|
|
if(nfd[0]==0)
|
|
strcpy(nfd, "/");
|
|
if(stat(nfd, &stbuf)==-1)
|
|
return(0);
|
|
Xorriso_transfer_properties(xorriso, &stbuf, nfd, (IsoNode *) dir,
|
|
((flag&1) && d==0) | 4 | 32);
|
|
sprintf(xorriso->info_text,
|
|
"Copied properties for %s", Text_shellsafe(ni, sfe, 0));
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
" from %s", Text_shellsafe(nfd, sfe, 0));
|
|
if(!((flag&1) && d==0))
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param bit0= copy link target properties rather than link properties
|
|
bit1= give directory x-permission where is r-permission
|
|
bit2= record dev,inode (only if enabled by xorriso)
|
|
*/
|
|
int Xorriso_copy_properties(struct XorrisO *xorriso,
|
|
char *disk_path, char *img_path, int flag)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
struct stat stbuf;
|
|
|
|
ret= Xorriso_get_node_by_path(xorriso, img_path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(flag & 1) {
|
|
if(stat(disk_path, &stbuf)==-1)
|
|
return(0);
|
|
} else {
|
|
if(lstat(disk_path, &stbuf)==-1)
|
|
return(0);
|
|
}
|
|
Xorriso_transfer_properties(xorriso, &stbuf, disk_path, node,
|
|
((flag & 2) >> 1) | ((flag & 1) << 5) | (flag & 4));
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @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
|
|
bit2= -follow, -not_*: this is not a command parameter
|
|
bit3= use offset and cut_size for cut_out_node
|
|
bit4= return 3 on rejection by exclusion or user
|
|
bit5= if directory then do not add sub tree
|
|
bit6= do not delete eventually existing node from di_array
|
|
bit7= no special handling of split file directories
|
|
@return <=0 = error , 1 = added simple node , 2 = added directory ,
|
|
3 = rejected
|
|
*/
|
|
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)
|
|
{
|
|
IsoImage *volume;
|
|
char path[SfileadrL], *apt, *npt, *cpt, sfe[5*SfileadrL], sfe2[5*SfileadrL];
|
|
char *disk_path_pt, resolved_disk_path[SfileadrL];
|
|
IsoDir *dir, *hdir;
|
|
IsoNode *node;
|
|
int done= 0, is_dir= 0, l, ret, target_is_dir, source_is_dir, resolve_link= 0;
|
|
int target_is_split;
|
|
struct stat stbuf;
|
|
|
|
ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&4));
|
|
if(ret<0)
|
|
return(ret);
|
|
if(ret>0)
|
|
return(3*!!(flag&16));
|
|
|
|
for(cpt= img_path; 1; cpt++) {
|
|
cpt= strstr(cpt,"/.");
|
|
if(cpt==NULL)
|
|
break;
|
|
if(cpt[2]=='.') {
|
|
if(cpt[3]=='/' || cpt[3]==0)
|
|
break;
|
|
} else if(cpt[2]=='/' || cpt[2]==0)
|
|
break;
|
|
}
|
|
if(cpt!=NULL) {
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Unsupported relative addressing in iso_rr_path %s (disk: %s)",
|
|
Text_shellsafe(img_path, sfe, 0), Text_shellsafe(disk_path, sfe2, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
strncpy(path, img_path, sizeof(path)-1);
|
|
path[sizeof(path)-1]= 0;
|
|
apt= npt= path;
|
|
|
|
if(!(flag&1)) {
|
|
ret= lstat(disk_path, &stbuf);
|
|
if(ret!=-1) {
|
|
if(S_ISDIR(stbuf.st_mode))
|
|
is_dir= 1;
|
|
else if((stbuf.st_mode&S_IFMT)==S_IFLNK &&
|
|
(xorriso->do_follow_links ||
|
|
(xorriso->do_follow_param && !(flag&4)))) {
|
|
resolve_link= 1;
|
|
ret= stat(disk_path, &stbuf);
|
|
if(ret!=-1) {
|
|
if(S_ISDIR(stbuf.st_mode))
|
|
is_dir= 1;
|
|
}
|
|
}
|
|
}
|
|
if(ret == -1) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot determine attributes of source file %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
if(S_ISDIR(stbuf.st_mode)) {
|
|
is_dir= 1;
|
|
} else {
|
|
l= strlen(img_path);
|
|
if(l>0)
|
|
if(img_path[l-1]=='/')
|
|
l= 0;
|
|
if(l==0) {
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Source '%s' is not a directory. Target '%s' would be.",
|
|
Text_shellsafe(disk_path, sfe, 0), Text_shellsafe(img_path, sfe2, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
dir= iso_image_get_root(volume);
|
|
if(dir==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"While grafting '%s' : no root node available", img_path);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
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++;
|
|
if(done)
|
|
goto attach_source;
|
|
continue;
|
|
}
|
|
source_is_dir= (is_dir || (flag&1) || !done);
|
|
ret= Xorriso_node_from_path(xorriso, volume, path, &node, 1);
|
|
if(ret>0) {
|
|
target_is_dir= LIBISO_ISDIR(node);
|
|
|
|
target_is_split= 0;
|
|
if(target_is_dir && !(flag&128))
|
|
target_is_split= Xorriso_is_split(xorriso, "", (void *) node, 1);
|
|
|
|
if(!((target_is_dir && !target_is_split) && source_is_dir)) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
/* handle overwrite situation */;
|
|
if(xorriso->do_overwrite==1 ||
|
|
(xorriso->do_overwrite==2 && !(target_is_dir && !target_is_split))) {
|
|
ret= Xorriso_rmi(xorriso, boss_iter, (off_t) 0, path,
|
|
1 | 8 | (flag & 64));
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(ret==3) {
|
|
sprintf(xorriso->info_text, "User revoked adding of: %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(3*!!(flag&16));
|
|
}
|
|
node= NULL;
|
|
goto handle_path_node;
|
|
}
|
|
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"While grafting '%s' : '%s' exists and may not be overwritten",
|
|
img_path, path);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
dir= (IsoDir *) node;
|
|
}
|
|
|
|
handle_path_node:;
|
|
if(node==NULL && source_is_dir) { /* make a directory */
|
|
ret= iso_tree_add_new_dir(dir, apt, &hdir);
|
|
if(ret<0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
Xorriso_report_iso_error(xorriso, img_path, ret,
|
|
"Cannot create directory", 0, "FAILURE", 1);
|
|
sprintf(xorriso->info_text,
|
|
"While grafting '%s' : could not insert '%s'", img_path, path);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
dir= hdir;
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
iso_node_set_ctime((IsoNode *) dir, time(NULL));
|
|
iso_node_set_uid((IsoNode *) dir, geteuid());
|
|
iso_node_set_gid((IsoNode *) dir, getegid());
|
|
|
|
if(disk_path!=NULL && !done)
|
|
Xorriso_copy_implicit_properties(xorriso, dir, img_path, path, disk_path,
|
|
!!(flag&8));
|
|
|
|
}
|
|
if(done) {
|
|
attach_source:;
|
|
if(flag&1) {
|
|
/* directory node was created above */;
|
|
|
|
} else if(is_dir) {
|
|
Xorriso_transfer_properties(xorriso, &stbuf, disk_path,
|
|
(IsoNode *) dir, 4 | 32);
|
|
if(!(flag&32)) {
|
|
ret= Xorriso_add_tree(xorriso, dir, img_path, disk_path, NULL,
|
|
flag & (2 | 64));
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
} else {
|
|
if(resolve_link) {
|
|
ret= Xorriso_resolve_link(xorriso, disk_path, resolved_disk_path, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
disk_path_pt= resolved_disk_path;
|
|
} else
|
|
disk_path_pt= disk_path;
|
|
|
|
ret= Xorriso_tree_graft_node(xorriso, volume, dir, disk_path_pt, apt,
|
|
disk_path, img_path,
|
|
offset, cut_size, &node, flag&8);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text, "Grafting failed: %s = %s",
|
|
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
iso_node_set_name(node, apt);
|
|
|
|
xorriso->pacifier_count++;
|
|
if(xorriso->pacifier_count%100 && !(flag&2))
|
|
Xorriso_pacifier_callback(xorriso, "files added",
|
|
xorriso->pacifier_count,
|
|
xorriso->pacifier_total, "", 0);
|
|
}
|
|
} else
|
|
*npt= '/';
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1+!!is_dir);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= -follow: disk_path is not a command parameter
|
|
*/
|
|
int Xorriso_cut_out(struct XorrisO *xorriso, char *disk_path,
|
|
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag)
|
|
{
|
|
int ret;
|
|
char eff_source[SfileadrL], eff_dest[SfileadrL], sfe[SfileadrL*5];
|
|
struct stat stbuf;
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_source,
|
|
2|4);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&1));
|
|
if(ret!=0)
|
|
return(0);
|
|
|
|
if(lstat(eff_source, &stbuf)==-1) {
|
|
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text, "-cut_out: Cannot determine type of %s",
|
|
Text_shellsafe(eff_source, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
if((stbuf.st_mode&S_IFMT) == S_IFLNK) {
|
|
if(!(xorriso->do_follow_links || (xorriso->do_follow_param && !(flag&1))))
|
|
goto unsupported_type;
|
|
if(stat(eff_source, &stbuf)==-1) {
|
|
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"-cut_out: Cannot determine link target type of %s",
|
|
Text_shellsafe(eff_source, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
return(0);
|
|
}
|
|
}
|
|
if(S_ISREG(stbuf.st_mode)) {
|
|
if(stbuf.st_size<startbyte) {
|
|
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"-cut_out: Byte offset %.f larger than file size %.f",
|
|
(double) startbyte, (double) stbuf.st_size);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0);
|
|
return(0);
|
|
}
|
|
} else {
|
|
unsupported_type:;
|
|
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text, "-cut_out: Unsupported file type (%s) with %s",
|
|
Ftypetxt(stbuf.st_mode, 0), Text_shellsafe(eff_source, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, iso_rr_path, eff_dest,
|
|
2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
ret= Xorriso_graft_in(xorriso, NULL, eff_source, eff_dest,
|
|
startbyte, bytecount, 8);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= in_node is valid, do not resolve img_path
|
|
bit1= test mode: print DEBUG messages
|
|
@return <0 = error,
|
|
0 = surely not identical regular files ,
|
|
1 = surely identical
|
|
2 = potentially depending on unknown disk file (e.g. -cut_out)
|
|
*/
|
|
int Xorriso_restore_is_identical(struct XorrisO *xorriso, void *in_node,
|
|
char *img_path, char *disk_path,
|
|
char type_text[5], int flag)
|
|
{
|
|
int ret;
|
|
unsigned int fs_id;
|
|
dev_t dev_id;
|
|
ino_t ino_id;
|
|
IsoStream *stream;
|
|
IsoImage *volume;
|
|
IsoNode *node;
|
|
struct stat stbuf;
|
|
int dummy;
|
|
|
|
memset(type_text, 0, 5);
|
|
if(!xorriso->volset_change_pending)
|
|
return(0);
|
|
if(flag&1) {
|
|
node= (IsoNode *) in_node;
|
|
} else {
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(-1);
|
|
ret= Xorriso_node_from_path(xorriso, volume, img_path, &node, 1);
|
|
if(ret<=0)
|
|
return(-1);
|
|
}
|
|
ret= Xorriso__file_start_lba(node, &dummy, 0);
|
|
if(ret != 0) {
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
return(0);
|
|
}
|
|
if(!LIBISO_ISREG(node))
|
|
return(0);
|
|
stream= iso_file_get_stream((IsoFile *) node);
|
|
memcpy(type_text, stream->class->type, 4);
|
|
iso_stream_get_id(stream, &fs_id, &dev_id, &ino_id);
|
|
if(flag&2) {
|
|
sprintf(xorriso->info_text, "%s : fs=%d dev=%.f ino=%.f (%s)",
|
|
img_path, fs_id, (double) dev_id, (double) ino_id, type_text);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
ret= stat(disk_path, &stbuf);
|
|
if(ret==-1)
|
|
return(0);
|
|
if(flag&2) {
|
|
sprintf(xorriso->info_text, "%s : dev=%.f ino=%.f",
|
|
disk_path, (double) stbuf.st_dev, (double) stbuf.st_ino);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
if(fs_id!=1)
|
|
return(2);
|
|
|
|
/* >>> obtain underlying dev_t ino_t of type "cout" */;
|
|
|
|
if(strcmp(type_text, "fsrc")!=0)
|
|
return(2);
|
|
if(stbuf.st_dev==dev_id && stbuf.st_ino==ino_id)
|
|
return(1);
|
|
return(0);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= minimal transfer: access permissions only
|
|
bit1= keep directory open: keep owner, allow rwx for owner
|
|
and push directory onto xorriso->perm_stack
|
|
*/
|
|
int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
|
|
IsoNode *node, int flag)
|
|
{
|
|
int ret, is_dir= 0;
|
|
mode_t mode;
|
|
uid_t uid;
|
|
gid_t gid;
|
|
struct utimbuf utime_buffer;
|
|
char sfe[5*SfileadrL];
|
|
struct stat stbuf;
|
|
size_t num_attrs= 0, *value_lengths= NULL;
|
|
char **names= NULL, **values= NULL;
|
|
|
|
ret= lstat(disk_path, &stbuf);
|
|
if(ret==-1) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot obtain properties of disk file %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
uid= stbuf.st_uid;
|
|
|
|
is_dir= S_ISDIR(stbuf.st_mode);
|
|
|
|
mode= iso_node_get_permissions(node);
|
|
|
|
if(xorriso->do_aaip & (2 | 8 | 16)) {
|
|
ret= iso_node_get_attrs(node, &num_attrs, &names, &value_lengths, &values,
|
|
(!!(xorriso->do_aaip & 2)) | (!(xorriso->do_aaip & (8 | 16))) << 2);
|
|
if (ret < 0) {
|
|
strcpy(xorriso->info_text, "Error with obtaining ACL and xattr for ");
|
|
Text_shellsafe(disk_path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(num_attrs > 0) {
|
|
ret= iso_local_set_attrs(disk_path, num_attrs, names, value_lengths,
|
|
values, 0);
|
|
if(ret < 0) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot change ACL or xattr of disk file %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
}
|
|
if(!(xorriso->do_aaip & 2))
|
|
mode= iso_node_get_perms_wo_acl(node);
|
|
|
|
if(is_dir && (flag&2)) {
|
|
ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node,
|
|
1 | ((!!(xorriso->do_aaip & 2)) << 3));
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
ret= Permstack_push(&(xorriso->perm_stack), disk_path, &stbuf, 0);
|
|
if(ret<=0) {
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
strcpy(xorriso->info_text,
|
|
"Cannot memorize permissions for disk directory");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
mode|= S_IRUSR|S_IWUSR|S_IXUSR;
|
|
}
|
|
ret= chmod(disk_path, mode);
|
|
if(ret==-1) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot change access permissions of disk file %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
if(flag&1)
|
|
{ret= 1; goto ex;}
|
|
|
|
gid= iso_node_get_gid(node);
|
|
if(!(S_ISDIR(stbuf.st_mode) && (flag&2)))
|
|
uid= iso_node_get_uid(node);
|
|
chown(disk_path, uid, gid); /* don't complain if it fails */
|
|
utime_buffer.actime= iso_node_get_atime(node);
|
|
utime_buffer.modtime= iso_node_get_mtime(node);
|
|
ret= utime(disk_path,&utime_buffer);
|
|
if(ret==-1) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot change atime, mtime of disk file %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
iso_node_get_attrs(node, &num_attrs, &names, &value_lengths, &values,1 << 15);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag
|
|
bit1= minimal transfer: access permissions only
|
|
bit2= keep directory open: keep owner, allow rwx for owner
|
|
push to xorriso->perm_stack
|
|
*/
|
|
int Xorriso_restore_implicit_properties(struct XorrisO *xorriso,
|
|
char *full_disk_path, char *disk_path, char *full_img_path, int flag)
|
|
{
|
|
int ret, nfic, ndc, nfdc, d, i;
|
|
char nfi[SfileadrL], nd[SfileadrL], nfd[SfileadrL], *cpt;
|
|
char sfe[5*SfileadrL];
|
|
struct stat stbuf;
|
|
IsoNode *node;
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, full_disk_path, nfd,
|
|
1|2|4);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, nd, 1|2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, full_img_path, nfi,
|
|
1|2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
nfdc= Sfile_count_components(nfd, 0);
|
|
ndc= Sfile_count_components(nd, 0);
|
|
nfic= Sfile_count_components(nfi, 0);
|
|
d= nfdc-ndc;
|
|
if(d<0)
|
|
return(-1);
|
|
if(d>nfic)
|
|
return(0);
|
|
for(i= 0; i<d; i++) {
|
|
cpt= strrchr(nfi, '/');
|
|
if(cpt==NULL)
|
|
return(-1); /* should not happen */
|
|
*cpt= 0;
|
|
}
|
|
if(nfi[0]==0)
|
|
strcpy(nfi, "/");
|
|
ret= Xorriso_fake_stbuf(xorriso, nfi, &stbuf, &node, 0);
|
|
if(ret<=0)
|
|
return(0);
|
|
ret= Xorriso_restore_properties(xorriso, nd, node, ((flag>>1)&3));
|
|
if(ret<=0)
|
|
return(ret);
|
|
sprintf(xorriso->info_text,
|
|
"Restored properties for %s", Text_shellsafe(nd, sfe, 0));
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
" from %s", Text_shellsafe(nfi, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_is_plain_image_file(struct XorrisO *xorriso, IsoNode *node,
|
|
int flag)
|
|
{
|
|
int ret, lba;
|
|
IsoStream *stream;
|
|
|
|
ret= Xorriso__file_start_lba(node, &lba, 0);
|
|
if(ret > 0) { /* Stream source is from loaded image */
|
|
stream= iso_file_get_stream((IsoFile *) node);
|
|
if(stream != NULL)
|
|
if(iso_stream_get_input_stream(stream, 0) == NULL)
|
|
return(1);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= Minimal transfer: access permissions only
|
|
bit1= *_offset and bytes are valid for writing to regular file
|
|
bit2= This is not a parameter. Do not report if ignored
|
|
bit3= do not restore properties
|
|
bit4= issue pacifier messages with long lasting copying
|
|
bit7= return 4 if restore fails from denied permission
|
|
do not issue error message
|
|
@return <0 severe error , 0 failure , 1 success ,
|
|
2 regularly not installed (disallowed device, UNIX domain socket)
|
|
4 with bit7: permission to restore was denied
|
|
*/
|
|
int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
|
|
char *img_path, off_t img_offset,
|
|
char *disk_path, off_t disk_offset, off_t bytes,
|
|
int flag)
|
|
{
|
|
int ret= 0, write_fd= -1, wanted, wret, open_flags, l_errno= 0;
|
|
int target_deleted= 0;
|
|
char *what= "[unknown filetype]", sfe[5*SfileadrL], sfe2[5*SfileadrL];
|
|
char buf[32*1024], type_text[5], temp_path[SfileadrL], *buf_pt;
|
|
char *link_target, *open_path_pt= NULL;
|
|
off_t todo= 0, size, seek_ret, last_p_count= 0, already_done, read_count= 0;
|
|
void *data_stream= NULL;
|
|
mode_t mode;
|
|
dev_t dev= 0;
|
|
struct stat stbuf;
|
|
struct utimbuf utime_buffer;
|
|
|
|
if(LIBISO_ISDIR(node)) {
|
|
what= "directory";
|
|
ret= mkdir(disk_path, 0777);
|
|
l_errno= errno;
|
|
|
|
} else if(LIBISO_ISREG(node)) {
|
|
what= "regular file";
|
|
ret= Xorriso_iso_file_open(xorriso, img_path, (void *) node, &data_stream,
|
|
1);
|
|
if(ret<=0)
|
|
goto ex;
|
|
open_path_pt= disk_path;
|
|
ret= stat(open_path_pt, &stbuf);
|
|
if(ret == -1 && errno == EACCES && (flag & 128))
|
|
{ret= 4; goto ex;}
|
|
if(flag&2) {
|
|
if(ret!=-1 && !S_ISREG(stbuf.st_mode)) {
|
|
sprintf(xorriso->info_text,
|
|
"Restore offset demanded. But filesystem path leads to non-data file %s",
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
l_errno= 0;
|
|
goto cannot_restore;
|
|
}
|
|
} else {
|
|
/* If source and target are the same disk file then do not copy content */
|
|
ret= Xorriso_restore_is_identical(xorriso, (void *) node, img_path,
|
|
disk_path, type_text, 1);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==1) {
|
|
/* preliminarily emulate touch (might get overridden later) */
|
|
utime_buffer.actime= stbuf.st_atime;
|
|
utime_buffer.modtime= time(0);
|
|
utime(disk_path,&utime_buffer);
|
|
goto restore_properties;
|
|
}
|
|
if(ret==2) {
|
|
/* Extract to temporary file and rename only after copying */
|
|
ret= Xorriso_make_tmp_path(xorriso, disk_path, temp_path, &write_fd,
|
|
128);
|
|
if(ret <= 0 || ret == 4)
|
|
goto ex;
|
|
open_path_pt= temp_path;
|
|
}
|
|
}
|
|
if(write_fd==-1) {
|
|
open_flags= O_WRONLY|O_CREAT;
|
|
if(disk_offset==0 || !(flag&2))
|
|
open_flags|= O_EXCL;
|
|
write_fd= open(open_path_pt, open_flags, S_IRUSR|S_IWUSR);
|
|
l_errno= errno;
|
|
if(write_fd == -1 && errno == EACCES && (flag & 128))
|
|
{ret= 4; goto ex;}
|
|
if(write_fd==-1)
|
|
goto cannot_restore;
|
|
}
|
|
todo= size= iso_file_get_size((IsoFile *) node);
|
|
if(flag&2) {
|
|
if(bytes<size)
|
|
todo= size= bytes;
|
|
seek_ret= lseek(write_fd, disk_offset, SEEK_SET);
|
|
l_errno= errno;
|
|
if(seek_ret == -1) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot address byte %.f in filesystem path %s",
|
|
(double) disk_offset, Text_shellsafe(open_path_pt, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
goto cannot_restore;
|
|
}
|
|
}
|
|
while(todo>0) {
|
|
wanted= sizeof(buf);
|
|
if(wanted>todo)
|
|
wanted= todo;
|
|
ret= Xorriso_iso_file_read(xorriso, data_stream, buf, wanted, 0);
|
|
if(ret<=0) {
|
|
if(xorriso->extract_error_mode == 0 &&
|
|
Xorriso_is_plain_image_file(xorriso, node, 0)) {
|
|
close(write_fd);
|
|
write_fd= -1;
|
|
already_done= (size - todo) / (off_t) 2048;
|
|
already_done*= (off_t) 2048;
|
|
sprintf(xorriso->info_text,
|
|
"Starting best_effort handling on ISO file %s at byte %.f",
|
|
Text_shellsafe(img_path, sfe, 0), (double) already_done);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= Xorriso_read_file_data(xorriso, node, img_path, open_path_pt,
|
|
already_done, already_done, size - already_done, 2);
|
|
if(ret >= 0)
|
|
xorriso->pacifier_byte_count+= todo;
|
|
if(ret > 0)
|
|
todo= 0;
|
|
else
|
|
todo= -1;
|
|
}
|
|
if(ret <= 0) {
|
|
sprintf(xorriso->info_text, "Cannot read all bytes from ISO file %s",
|
|
Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
}
|
|
break;
|
|
}
|
|
read_count+= ret;
|
|
buf_pt= buf;
|
|
|
|
if(img_offset > read_count - ret) {
|
|
/* skip the desired amount of bytes */
|
|
if(read_count <= img_offset)
|
|
continue;
|
|
buf_pt= buf + (img_offset - (read_count - ret));
|
|
ret= read_count - img_offset;
|
|
}
|
|
|
|
wret= write(write_fd, buf_pt, ret);
|
|
if(wret>=0) {
|
|
todo-= wret;
|
|
xorriso->pacifier_byte_count+= wret;
|
|
if((flag&16) &&
|
|
xorriso->pacifier_byte_count - last_p_count >= 128*1024) {
|
|
Xorriso_pacifier_callback(xorriso, "files restored",
|
|
xorriso->pacifier_count,
|
|
xorriso->pacifier_total, "", 2|4);
|
|
last_p_count= xorriso->pacifier_byte_count;
|
|
}
|
|
}
|
|
if(wret != ret) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot write all bytes to disk filesystem path %s",
|
|
Text_shellsafe(open_path_pt, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
break;
|
|
}
|
|
}
|
|
if(write_fd > 0)
|
|
close(write_fd);
|
|
write_fd= -1;
|
|
if(todo > 0 && xorriso->extract_error_mode == 2 && open_path_pt != NULL) {
|
|
unlink(open_path_pt);
|
|
target_deleted= 1;
|
|
}
|
|
Xorriso_iso_file_close(xorriso, &data_stream, 0);
|
|
data_stream= NULL;
|
|
if(temp_path==open_path_pt && !target_deleted) {
|
|
ret= rename(temp_path, disk_path);
|
|
if(ret==-1) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot rename temporary path %s to final disk path %s",
|
|
Text_shellsafe(temp_path, sfe, 0),
|
|
Text_shellsafe(disk_path, sfe2, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
unlink(temp_path);
|
|
ret= 0; goto ex;
|
|
}
|
|
}
|
|
ret= -(todo > 0);
|
|
l_errno= 0;
|
|
|
|
} else if(LIBISO_ISLNK(node)) {
|
|
what= "symbolic link";
|
|
link_target= (char *) iso_symlink_get_dest((IsoSymlink *) node);
|
|
ret= symlink(link_target, disk_path);
|
|
l_errno= errno;
|
|
|
|
} else if(LIBISO_ISCHR(node)) {
|
|
what= "character device";
|
|
if(xorriso->allow_restore!=2) {
|
|
ignored:;
|
|
if(!(flag&4)) {
|
|
sprintf(xorriso->info_text, "Ignored file type: %s %s = %s", what,
|
|
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
{ret= 2; goto ex;}
|
|
}
|
|
mode= S_IFCHR | 0777;
|
|
ret= Xorriso_node_get_dev(xorriso, node, img_path, &dev, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(dev == (dev_t) 1) {
|
|
probably_damaged:;
|
|
sprintf(xorriso->info_text,
|
|
"Most probably damaged device file not restored: mknod %s %s 0 1",
|
|
Text_shellsafe(disk_path, sfe, 0), LIBISO_ISCHR(node) ? "c" : "b");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
ret= mknod(disk_path, mode, dev);
|
|
l_errno= errno;
|
|
|
|
} else if(LIBISO_ISBLK(node)) {
|
|
what= "block device";
|
|
if(xorriso->allow_restore!=2)
|
|
goto ignored;
|
|
mode= S_IFBLK | 0777;
|
|
ret= Xorriso_node_get_dev(xorriso, node, img_path, &dev, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(dev == (dev_t) 1)
|
|
goto probably_damaged;
|
|
ret= mknod(disk_path, mode, dev);
|
|
l_errno= errno;
|
|
|
|
} else if(LIBISO_ISFIFO(node)) {
|
|
what= "named pipe";
|
|
mode= S_IFIFO | 0777;
|
|
ret= mknod(disk_path, mode, dev);
|
|
l_errno= errno;
|
|
|
|
} else if(LIBISO_ISSOCK(node)) {
|
|
what= "unix socket";
|
|
/* Restoring a socket file is not possible. One rather needs to restart
|
|
the service which temporarily created the socket. */
|
|
goto ignored;
|
|
|
|
} else {
|
|
sprintf(xorriso->info_text, "Cannot restore file type '%s'", what);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(ret == -1 && l_errno == EACCES && (flag & 128))
|
|
{ret= 4; goto ex;}
|
|
if(ret==-1) {
|
|
cannot_restore:;
|
|
sprintf(xorriso->info_text,
|
|
"Cannot restore %s to disk filesystem: %s",
|
|
what, Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, l_errno, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
restore_properties:;
|
|
if((flag&8) || LIBISO_ISLNK(node))
|
|
ret= 1;
|
|
else
|
|
ret= Xorriso_restore_properties(xorriso, disk_path, node, flag&1);
|
|
if(todo < 0)
|
|
ret= 0;
|
|
ex:;
|
|
if(write_fd >= 0) {
|
|
close(write_fd);
|
|
if(ret <= 0 && xorriso->extract_error_mode == 2 && open_path_pt != NULL)
|
|
unlink(open_path_pt);
|
|
}
|
|
if(data_stream!=NULL)
|
|
Xorriso_iso_file_close(xorriso, &data_stream, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* Handle overwrite situation in disk filesystem.
|
|
@param node intended source of overwriting or NULL
|
|
@param flag
|
|
bit4= return 3 on rejection by exclusion or user
|
|
bit6= permission to call Xorriso_make_accessible()
|
|
*/
|
|
int Xorriso_restore_overwrite(struct XorrisO *xorriso,
|
|
IsoNode *node, char *img_path,
|
|
char *path, char *nominal_path,
|
|
struct stat *stbuf, int flag)
|
|
{
|
|
int ret;
|
|
char sfe[5*SfileadrL], sfe2[5*SfileadrL], type_text[5];
|
|
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(xorriso->do_overwrite==1 ||
|
|
(xorriso->do_overwrite==2 && !S_ISDIR(stbuf->st_mode))) {
|
|
|
|
ret= Xorriso_restore_is_identical(xorriso, (void *) node, img_path,
|
|
path, type_text, (node!=NULL));
|
|
if(ret<0)
|
|
return(ret);
|
|
if(ret>0) /* will be handled properly by restore functions */
|
|
ret= Xorriso_reassure_restore(xorriso, path, 8);
|
|
else
|
|
ret= Xorriso_rmx(xorriso, (off_t) 0, path, 8 | (flag & 64));
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(ret==3) {
|
|
sprintf(xorriso->info_text, "User revoked restoring of (ISO) file: %s",
|
|
Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(3*!!(flag&16));
|
|
}
|
|
return(1);
|
|
}
|
|
Xorriso_msgs_submit(xorriso, 0, nominal_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"While restoring %s : %s exists and may not be overwritten",
|
|
Text_shellsafe(nominal_path, sfe, 0), strcmp(nominal_path, path)==0 ?
|
|
"file object" : Text_shellsafe(path, sfe2, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not accept hln_targets[i] != NULL as *node_idx
|
|
bit1= use *node_idx as found index rather than searching it
|
|
bit2= with bit1: use xorriso->node_array rather than hln_array
|
|
*/
|
|
int Xorriso_search_hardlinks(struct XorrisO *xorriso, IsoNode *node,
|
|
int *node_idx, int *min_hl, int *max_hl, int flag)
|
|
{
|
|
int idx, ret, i, node_count;
|
|
void *np, **node_array;
|
|
|
|
node_array= xorriso->hln_array;
|
|
node_count= xorriso->hln_count;
|
|
*min_hl= *max_hl= -1;
|
|
np= node;
|
|
if(flag & 2) {
|
|
idx= *node_idx;
|
|
if(flag & 4) {
|
|
node_array= xorriso->node_array;
|
|
node_count= xorriso->node_counter;
|
|
}
|
|
} else {
|
|
*node_idx= -1;
|
|
ret= Xorriso_search_in_hln_array(xorriso, np, &idx, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
}
|
|
for(i= idx - 1; i >= 0 ; i--)
|
|
if(Xorriso__findi_sorted_ino_cmp(&(node_array[i]), &np) != 0)
|
|
break;
|
|
*min_hl= i + 1;
|
|
for(i= idx + 1; i < node_count; i++)
|
|
if(Xorriso__findi_sorted_ino_cmp(&(node_array[i]), &np) != 0)
|
|
break;
|
|
*max_hl= i - 1;
|
|
|
|
/* Search for *node_idx */
|
|
if(flag & 2)
|
|
return(1);
|
|
for(i= *min_hl; i <= *max_hl; i++)
|
|
if(node_array[i] == np) {
|
|
if((flag & 1) && xorriso->hln_targets != NULL && !(flag & 4))
|
|
if(xorriso->hln_targets[i] != NULL)
|
|
continue;
|
|
*node_idx= i;
|
|
break;
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/*
|
|
@return <0 error,
|
|
bit0= hardlink created
|
|
bit1= siblings with target NULL found
|
|
bit2= siblings with non-NULL target found
|
|
*/
|
|
int Xorriso_restore_target_hl(struct XorrisO *xorriso, IsoNode *node,
|
|
char *disk_path, int *node_idx, int flag)
|
|
{
|
|
int ret, min_hl, max_hl, i, null_target_sibling= 0, link_sibling= 0;
|
|
|
|
if(xorriso->hln_targets == NULL)
|
|
return(0);
|
|
ret= Xorriso_search_hardlinks(xorriso, node, node_idx, &min_hl, &max_hl, 1);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret == 0 || *node_idx < 0 || min_hl == max_hl)
|
|
return(0);
|
|
for(i= min_hl; i <= max_hl; i++) {
|
|
if(xorriso->hln_targets[i] == NULL) {
|
|
if(i != *node_idx)
|
|
null_target_sibling= 1;
|
|
continue;
|
|
}
|
|
link_sibling= 1;
|
|
ret= Xorriso_restore_make_hl(xorriso, xorriso->hln_targets[i], disk_path,
|
|
!!xorriso->do_auto_chmod);
|
|
if(ret > 0)
|
|
return(1);
|
|
}
|
|
return((null_target_sibling << 1) | (link_sibling << 2));
|
|
}
|
|
|
|
|
|
/*
|
|
@return <0 error,
|
|
bit0= hardlink created
|
|
bit2= siblings lower index found
|
|
*/
|
|
int Xorriso_restore_prefix_hl(struct XorrisO *xorriso, IsoNode *node,
|
|
char *disk_path, int node_idx, int flag)
|
|
{
|
|
int ret, min_hl, max_hl, i, link_sibling= 0, hflag;
|
|
char old_path[SfileadrL], img_path[SfileadrL];
|
|
struct Xorriso_lsT *img_prefixes= NULL, *disk_prefixes= NULL;
|
|
|
|
ret= Xorriso_search_hardlinks(xorriso, node, &node_idx, &min_hl, &max_hl,
|
|
2 | 4);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret == 0 || min_hl == max_hl)
|
|
return(0);
|
|
|
|
for(i= min_hl; i < node_idx; i++) {
|
|
link_sibling= 1;
|
|
ret= Xorriso_path_from_node(xorriso, xorriso->node_array[i], img_path, 0);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret == 0)
|
|
continue; /* Node is deleted from tree (Should not happen here) */
|
|
hflag= 1;
|
|
if(i == min_hl) {
|
|
hflag= 0;
|
|
} else if(xorriso->node_array[i] != xorriso->node_array[i - 1]) {
|
|
hflag= 0;
|
|
}
|
|
if(hflag == 0) {
|
|
img_prefixes= xorriso->node_img_prefixes;
|
|
disk_prefixes= xorriso->node_disk_prefixes;
|
|
}
|
|
ret= Xorriso_make_restore_path(xorriso, &img_prefixes, &disk_prefixes,
|
|
img_path, old_path, hflag);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
ret= Xorriso_restore_make_hl(xorriso, old_path, disk_path,
|
|
!!xorriso->do_auto_chmod);
|
|
if(ret > 0)
|
|
return(1);
|
|
}
|
|
return(link_sibling << 2);
|
|
}
|
|
|
|
|
|
/* @return <0 = error , 0 = availmem exhausted first time , 1 = ok
|
|
2 = availmem exhausted repeated
|
|
*/
|
|
int Xorriso_register_node_target(struct XorrisO *xorriso, int node_idx,
|
|
char *disk_path, int flag)
|
|
{
|
|
int l;
|
|
|
|
if(xorriso->node_targets_availmem == 0)
|
|
return(2);
|
|
if(xorriso->hln_targets == NULL || node_idx < 0 ||
|
|
node_idx >= xorriso->hln_count)
|
|
return(0);
|
|
if(xorriso->hln_targets[node_idx] != NULL) {
|
|
xorriso->node_targets_availmem+= strlen(xorriso->hln_targets[node_idx]) +1;
|
|
free(xorriso->hln_targets[node_idx]);
|
|
}
|
|
l= strlen(disk_path);
|
|
if(xorriso->node_targets_availmem <= l + 1) {
|
|
sprintf(xorriso->info_text,
|
|
"Hardlink target buffer exceeds -temp_mem_limit. Hardlinks may get divided.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
xorriso->node_targets_availmem= 0;
|
|
return(0);
|
|
}
|
|
xorriso->hln_targets[node_idx]= strdup(disk_path);
|
|
if(xorriso->hln_targets[node_idx] == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
return(-1);
|
|
}
|
|
xorriso->node_targets_availmem-= (l + 1);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= offset and bytes is valid for writing to regular file
|
|
bit1= do not report copied files
|
|
bit2= -follow, -not_*: this is not a command parameter
|
|
bit3= keep directory open: keep owner, allow rwx for owner
|
|
bit4= do not look for hardlinks even if enabled
|
|
bit6= this is a copy action: do not fake times and ownership
|
|
bit7= return 4 if restore fails from denied permission
|
|
do not issue error message
|
|
@return <=0 = error , 1 = added leaf file object , 2 = added directory ,
|
|
3= regularly not installed (disallowed device, UNIX domain socket)
|
|
4 = with bit7: permission to restore was denied
|
|
*/
|
|
int Xorriso_restore_disk_object(struct XorrisO *xorriso,
|
|
char *img_path, IsoNode *node,
|
|
char *disk_path,
|
|
off_t offset, off_t bytes, int flag)
|
|
{
|
|
int ret, i, split_count= 0, partno, total_parts, leaf_is_split= 0;
|
|
int record_hl_path= 0, node_idx, cannot_register= 0;
|
|
off_t total_bytes, was_byte_count;
|
|
char *part_name, part_path[SfileadrL], *img_path_pt;
|
|
char sfe[5*SfileadrL], sfe2[5*SfileadrL];
|
|
IsoImage *volume;
|
|
IsoNode *part_node, *first_part_node= NULL;
|
|
struct SplitparT *split_parts= NULL;
|
|
struct stat stbuf;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
was_byte_count= xorriso->pacifier_byte_count;
|
|
|
|
if(LIBISO_ISDIR(node) && xorriso->do_concat_split)
|
|
leaf_is_split= Xorriso_identify_split(xorriso, img_path, node,
|
|
&split_parts, &split_count, &stbuf, 1|2);
|
|
if(leaf_is_split) {
|
|
/* map all files in directory img_path into regular file disk_path */
|
|
|
|
for(i=0 ; i<split_count; i++) {
|
|
Splitparts_get(split_parts, i, &part_name, &partno, &total_parts,
|
|
&offset, &bytes, &total_bytes, 0);
|
|
|
|
strcpy(part_path, img_path);
|
|
if(Sfile_add_to_path(part_path, part_name, 0)<=0) {
|
|
Xorriso_much_too_long(xorriso, strlen(img_path)+strlen(part_name)+1, 2);
|
|
goto restoring_failed;
|
|
}
|
|
ret= Xorriso_node_from_path(xorriso, volume, part_path, &part_node, 0);
|
|
if(ret<=0)
|
|
goto restoring_failed;
|
|
if(i==0)
|
|
first_part_node= part_node;
|
|
if(offset+bytes>total_bytes)
|
|
bytes= total_bytes-offset;
|
|
ret= Xorriso_tree_restore_node(xorriso, part_node, part_path, (off_t) 0,
|
|
disk_path, offset, bytes,
|
|
(!!(flag&64)) | 2 | (flag & (4 | 128)) | 8 | ( 16 * !(flag&2)));
|
|
if(ret<=0)
|
|
goto restoring_failed;
|
|
if(ret == 4)
|
|
goto ex;
|
|
}
|
|
if(first_part_node!=NULL)
|
|
Xorriso_restore_properties(xorriso, disk_path, first_part_node,
|
|
!!(flag&64));
|
|
goto went_well;
|
|
}
|
|
|
|
#ifdef Osirrox_not_yeT
|
|
|
|
if(resolve_link) {
|
|
ret= Xorriso_resolve_link(xorriso, disk_path, resolved_disk_path, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
disk_path_pt= resolved_disk_path;
|
|
} else
|
|
|
|
#endif /* Osirrox_not_yeT */
|
|
|
|
img_path_pt= img_path;
|
|
|
|
if(!((xorriso->ino_behavior & 4) || (flag & (1 | 16)) || LIBISO_ISDIR(node))){
|
|
/* Try to restore as hardlink */
|
|
ret= Xorriso_restore_target_hl(xorriso, node, disk_path, &node_idx,
|
|
!!xorriso->do_auto_chmod);
|
|
if(ret < 0) {
|
|
goto ex;
|
|
} else if(ret & 1) {
|
|
/* Success, hardlink was created */
|
|
goto went_well;
|
|
} else if(ret & 2) {
|
|
/* Did not establish hardlink. Hardlink siblings with target NULL found.*/
|
|
record_hl_path= 1;
|
|
}
|
|
if(ret & 4) {
|
|
/* Found siblings with non-NULL target, but did not link. */
|
|
ret= Xorriso_eval_problem_status(xorriso, 1, 0);
|
|
if(ret < 0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
|
|
ret= Xorriso_tree_restore_node(xorriso, node, img_path_pt, (off_t) 0,
|
|
disk_path, offset, bytes,
|
|
(flag&(4 | 8 | 128)) | (!!(flag&64)) | ((flag&1)<<1) | ( 16 * !(flag&2)));
|
|
if(ret == 4)
|
|
goto ex;
|
|
if(ret>0 && (flag&8))
|
|
ret= Xorriso_restore_properties(xorriso, disk_path, node, 2 | !!(flag&64));
|
|
if(ret<=0) {
|
|
restoring_failed:;
|
|
sprintf(xorriso->info_text, "Restoring failed: %s = %s",
|
|
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(ret==2)
|
|
{ret= 3; goto ex;}
|
|
if(record_hl_path) { /* Start of a disk hardlink family */
|
|
ret= Xorriso_register_node_target(xorriso, node_idx, disk_path, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0)
|
|
cannot_register= 1;
|
|
}
|
|
|
|
went_well:;
|
|
xorriso->pacifier_count++;
|
|
if(!(flag&2))
|
|
Xorriso_pacifier_callback(xorriso, "files restored",
|
|
xorriso->pacifier_count,
|
|
xorriso->pacifier_total, "", 4);
|
|
ret= 1;
|
|
ex:;
|
|
if(split_parts!=NULL)
|
|
Splitparts_destroy(&split_parts, split_count, 0);
|
|
if(ret > 0 && cannot_register)
|
|
ret= 0;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= source is a directory and not to be restored as split file
|
|
>>> bit6= permission to call Xorriso_make_accessible()
|
|
@return <=0 error , 1=collision handled , 2=no collision , 3=revoked by user
|
|
*/
|
|
int Xorriso_handle_collision(struct XorrisO *xorriso,
|
|
IsoNode *node, char *img_path,
|
|
char *disk_path, char *nominal_disk_path,
|
|
int *stbuf_ret, int flag)
|
|
{
|
|
int ret, target_is_dir= 0, target_is_link= 0, stat_ret, made_accessible= 0;
|
|
struct stat target_stbuf, lt_stbuf;
|
|
struct PermiteM *perm_stack_mem;
|
|
|
|
perm_stack_mem= xorriso->perm_stack;
|
|
|
|
/* does a disk file exist with this name ? */
|
|
*stbuf_ret= lstat(disk_path, &target_stbuf);
|
|
if(*stbuf_ret==-1) {
|
|
if((flag & 64) && errno == EACCES) {
|
|
ret= Xorriso_make_accessible(xorriso, disk_path, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
made_accessible= 1;
|
|
*stbuf_ret= lstat(disk_path, &target_stbuf);
|
|
}
|
|
if(*stbuf_ret==-1)
|
|
{ret= 2; goto ex;}
|
|
}
|
|
target_is_link= S_ISLNK(target_stbuf.st_mode);
|
|
if(target_is_link) {
|
|
stat_ret= stat(disk_path, <_stbuf);
|
|
if(stat_ret == -1) {
|
|
if((flag & 64) && errno == EACCES && !made_accessible) {
|
|
ret= Xorriso_make_accessible(xorriso, disk_path, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
made_accessible= 1;
|
|
stat_ret= stat(disk_path, <_stbuf);
|
|
}
|
|
}
|
|
if(stat_ret != -1)
|
|
target_is_dir= S_ISDIR(lt_stbuf.st_mode);
|
|
} else {
|
|
target_is_dir= S_ISDIR(target_stbuf.st_mode);
|
|
}
|
|
if(target_is_dir && (!target_is_link) && !(flag&1)) {
|
|
strcpy(xorriso->info_text, "Attempt to replace DISK directory ");
|
|
Text_shellsafe(nominal_disk_path,
|
|
xorriso->info_text+strlen(xorriso->info_text), 0);
|
|
strcat(xorriso->info_text, " by ISO file ");
|
|
Text_shellsafe(img_path, xorriso->info_text+strlen(xorriso->info_text), 0);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
if(!(target_is_dir && (flag&1))) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
ret= Xorriso_restore_overwrite(xorriso, node, img_path, disk_path,
|
|
nominal_disk_path, &target_stbuf, 16 | (flag & 64));
|
|
if(ret==3)
|
|
{ret= 3; goto ex;}
|
|
if(ret<=0)
|
|
goto ex;
|
|
*stbuf_ret= -1; /* It might still exist but will be handled properly */
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(made_accessible)
|
|
Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= recursion is active
|
|
bit1= do not report restored files
|
|
bit6= this is a copy action: do not fake times and ownership
|
|
bit8= only register non-directory nodes in xorriso->node_array
|
|
bit7+8=
|
|
0= direct operation
|
|
1= create only directories,
|
|
count nodes in xorriso->node_counter
|
|
2= only register non-directory nodes in
|
|
xorriso->node_array
|
|
3= count nodes in xorriso->node_counter,
|
|
create no directory
|
|
*/
|
|
int Xorriso_restore_tree(struct XorrisO *xorriso, IsoDir *dir,
|
|
char *img_dir_path, char *disk_dir_path,
|
|
off_t boss_mem,
|
|
struct LinkiteM *link_stack, int flag)
|
|
{
|
|
IsoImage *volume;
|
|
IsoNode *node;
|
|
IsoDirIter *iter= NULL;
|
|
IsoNode **node_array= NULL;
|
|
int node_count, node_idx;
|
|
int ret, source_is_dir, source_is_link, fret, was_failure= 0;
|
|
int do_not_dive, source_is_split= 0, len_dp, len_ip, stbuf_ret, hflag, hret;
|
|
char *name, *disk_name, *leaf_name, *srcpt, *stbuf_src= "";
|
|
struct LinkiteM *own_link_stack;
|
|
char *sfe= NULL, *sfe2= NULL;
|
|
char *disk_path= NULL, *img_path= NULL, *link_target= NULL;
|
|
off_t mem;
|
|
struct PermiteM *perm_stack_mem;
|
|
struct stat stbuf;
|
|
int dir_create= 0, node_register= 0, do_node_count= 0, normal_mode= 0;
|
|
|
|
perm_stack_mem= xorriso->perm_stack;
|
|
switch((flag >> 7) & 3) {
|
|
case 0: normal_mode= 1;
|
|
break; case 1: dir_create= 1;
|
|
break; case 2: node_register= 1;
|
|
break; case 3: do_node_count= 1;
|
|
}
|
|
|
|
/* Avoiding large local memory objects in order to save stack space */
|
|
sfe= malloc(5*SfileadrL);
|
|
sfe2= malloc(5*SfileadrL);
|
|
disk_path= malloc(2*SfileadrL);
|
|
img_path= malloc(2*SfileadrL);
|
|
link_target= malloc(SfileadrL);
|
|
if(sfe==NULL || sfe2==NULL || disk_path==NULL || img_path==NULL ||
|
|
link_target==NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, &sfe, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
own_link_stack= link_stack;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
stbuf_src= img_dir_path;
|
|
node= (IsoNode *) dir;
|
|
ret= Xorriso_fake_stbuf(xorriso, stbuf_src, &stbuf, &node, 1);
|
|
if(ret<=0) {
|
|
Xorriso_msgs_submit(xorriso, 0, disk_dir_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,"Cannot open as (ISO) source directory: %s",
|
|
Text_shellsafe(img_dir_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
#ifdef Osirrox_not_yeT
|
|
|
|
dev_t dir_dev;
|
|
dir_dev= stbuf.st_dev;
|
|
|
|
if(S_ISLNK(stbuf.st_mode)) {
|
|
if(!(xorriso->do_follow_links || (xorriso->do_follow_param && !(flag&1))))
|
|
{ret= 2; goto ex;}
|
|
stbuf_src= disk_dir_path;
|
|
if(stat(disk_dir_path, &stbuf)==-1)
|
|
goto cannot_open_dir;
|
|
if(dir_dev != stbuf.st_dev &&
|
|
!(xorriso->do_follow_mount || (xorriso->do_follow_param && !(flag&1))))
|
|
{ret= 2; goto ex;}
|
|
}
|
|
|
|
#endif /* Osirrox_not_yeT */
|
|
|
|
if(!S_ISDIR(stbuf.st_mode)) {
|
|
Xorriso_msgs_submit(xorriso, 0, disk_dir_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,"Is not a directory in ISO image: %s",
|
|
Text_shellsafe(img_dir_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
mem= boss_mem;
|
|
ret= Xorriso_findi_iter(xorriso, dir, &mem, &iter, &node_array, &node_count,
|
|
&node_idx, &node,
|
|
1 | 4 * (normal_mode && (xorriso->ino_behavior & 4)));
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
if(Sfile_str(img_path, img_dir_path,0)<=0) {
|
|
much_too_long:;
|
|
Xorriso_much_too_long(xorriso, SfileadrL, 2);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(img_path[0]==0 || img_path[strlen(img_path)-1]!='/')
|
|
strcat(img_path,"/");
|
|
name= img_path+strlen(img_path);
|
|
if(Sfile_str(disk_path, disk_dir_path, 0)<=0)
|
|
goto much_too_long;
|
|
if(disk_path[0]==0 || disk_path[strlen(disk_path)-1]!='/')
|
|
strcat(disk_path,"/");
|
|
disk_name= disk_path+strlen(disk_path);
|
|
|
|
len_dp= strlen(disk_path);
|
|
len_ip= strlen(img_path);
|
|
|
|
while(1) { /* loop over ISO directory content */
|
|
stbuf_src= "";
|
|
|
|
#ifdef Osirrox_not_yeT
|
|
|
|
Linkitem_reset_stack(&own_link_stack, link_stack, 0);
|
|
|
|
#endif
|
|
|
|
srcpt= img_path;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
ret= Xorriso_findi_iter(xorriso, dir, &mem, &iter, &node_array, &node_count,
|
|
&node_idx, &node, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0 || xorriso->request_to_abort)
|
|
break;
|
|
leaf_name= (char *) iso_node_get_name(node);
|
|
if(Xorriso_much_too_long(xorriso, len_dp + strlen(leaf_name)+1, 0)<=0)
|
|
{ret= 0; goto was_problem;}
|
|
if(Xorriso_much_too_long(xorriso, len_ip + strlen(leaf_name)+1, 0)<=0)
|
|
{ret= 0; goto was_problem;}
|
|
/* name is a pointer into img_path */
|
|
strcpy(name, leaf_name);
|
|
strcpy(disk_name, leaf_name);
|
|
|
|
stbuf_src= srcpt;
|
|
ret= Xorriso_fake_stbuf(xorriso, img_path, &stbuf, &node, 1);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
source_is_dir= 0;
|
|
source_is_link= S_ISLNK(stbuf.st_mode);
|
|
|
|
#ifdef Osirrox_not_yeT
|
|
|
|
/* ??? Link following in the image would cause severe problems
|
|
with Xorriso_path_from_node() */
|
|
|
|
if(xorriso->do_follow_links && source_is_link) {
|
|
/* Xorriso_hop_link checks for wide link loops */
|
|
ret= Xorriso_hop_link(xorriso, srcpt, &own_link_stack, &hstbuf, 0);
|
|
if(ret<0)
|
|
goto was_problem;
|
|
if(ret==1) {
|
|
ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 0);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
srcpt= link_target;
|
|
stbuf_src= srcpt;
|
|
if(lstat(srcpt, &stbuf)==-1)
|
|
goto cannot_lstat;
|
|
} else {
|
|
if(Xorriso_eval_problem_status(xorriso, 0, 1|2)<0)
|
|
{ret= 0; goto was_problem;}
|
|
}
|
|
} else if (S_ISLNK(stbuf.st_mode)) {
|
|
ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 1);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
}
|
|
|
|
#endif /* Osirrox_not_yeT */
|
|
|
|
do_not_dive= 0;
|
|
if(S_ISDIR(stbuf.st_mode))
|
|
source_is_dir= 1;
|
|
source_is_split= 0;
|
|
if(source_is_dir)
|
|
source_is_split= Xorriso_is_split(xorriso, img_path, node, 1|2);
|
|
if(source_is_split)
|
|
do_not_dive= 1;
|
|
|
|
if(source_is_dir || !(dir_create || do_node_count || node_register)) {
|
|
ret= Xorriso_handle_collision(xorriso, node, img_path,
|
|
disk_path, disk_path, &stbuf_ret,
|
|
(source_is_dir && !source_is_split));
|
|
if(ret<=0 || ret==3)
|
|
goto was_problem;
|
|
} else {
|
|
stbuf_ret= -1;
|
|
}
|
|
|
|
if(stbuf_ret!=-1) { /* (Can only happen with directory) */
|
|
Xorriso_auto_chmod(xorriso, disk_path, 0);
|
|
} else {
|
|
hflag= 4 | (flag & (2|64));
|
|
if(source_is_dir && !do_not_dive)
|
|
hflag|= 8; /* keep directory open for user */
|
|
if((dir_create || do_node_count) && !source_is_dir) {
|
|
xorriso->node_counter++;
|
|
} else if(node_register && !source_is_dir) {
|
|
if(xorriso->node_counter < xorriso->node_array_size) {
|
|
xorriso->node_array[xorriso->node_counter++]= (void *) node;
|
|
iso_node_ref(node);
|
|
}
|
|
} else if(node_register || do_node_count) {
|
|
ret= 1;
|
|
} else {
|
|
ret= Xorriso_restore_disk_object(xorriso, img_path, node, disk_path,
|
|
(off_t) 0, (off_t) 0, hflag);
|
|
}
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
}
|
|
if(source_is_dir && !do_not_dive) {
|
|
ret= Xorriso_restore_tree(xorriso, (IsoDir *) node,
|
|
img_path, disk_path, mem,
|
|
own_link_stack, 1 | (flag & (2 | (3 << 7))));
|
|
/* eventually restore exact access permissions of directory */
|
|
hret= Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso,
|
|
!!(flag&64));
|
|
if(hret<=0 && hret<ret)
|
|
ret= hret;
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
}
|
|
|
|
continue; /* regular bottom of loop */
|
|
was_problem:;
|
|
was_failure= 1;
|
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
|
|
if(fret<0)
|
|
goto ex;
|
|
Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, !!(flag&64));
|
|
}
|
|
|
|
ret= 1;
|
|
ex:
|
|
Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, !!(flag&64));
|
|
if(sfe!=NULL)
|
|
free(sfe);
|
|
if(sfe2!=NULL)
|
|
free(sfe2);
|
|
if(disk_path!=NULL)
|
|
free(disk_path);
|
|
if(img_path!=NULL)
|
|
free(img_path);
|
|
if(link_target!=NULL)
|
|
free(link_target);
|
|
Xorriso_findi_iter(xorriso, dir, &mem, &iter, &node_array, &node_count,
|
|
&node_idx, &node, (1<<31));
|
|
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
#ifdef Osirrox_not_yeT
|
|
|
|
Linkitem_reset_stack(&own_link_stack, link_stack, 0);
|
|
|
|
#endif
|
|
|
|
if(ret<=0)
|
|
return(ret);
|
|
return(!was_failure);
|
|
}
|
|
|
|
|
|
/*
|
|
@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
|
|
bit7+8= operation mode
|
|
0= direct operation
|
|
1= create only directories,
|
|
count nodes in xorriso->node_counter
|
|
2= only register non-directory nodes in
|
|
xorriso->node_array
|
|
3= count nodes in xorriso->node_counter,
|
|
create no directory
|
|
bit9= with operation mode 1 do net register prefixes
|
|
@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 bytes, int flag)
|
|
{
|
|
IsoImage *volume;
|
|
char path[SfileadrL], *apt, *npt, sfe[5*SfileadrL];
|
|
IsoNode *node= NULL;
|
|
int done= 0, is_dir= 0, ret, source_is_dir, stbuf_ret, hret;
|
|
int dir_create= 0, node_count= 0, node_register= 0;
|
|
int leaf_is_split= 0, source_is_split= 0, new_dir_made= 0;
|
|
struct stat stbuf;
|
|
struct PermiteM *perm_stack_mem;
|
|
|
|
perm_stack_mem= xorriso->perm_stack;
|
|
switch((flag >> 7) & 3) {
|
|
case 1: dir_create= 1;
|
|
break; case 2: node_register= 1;
|
|
break; case 3: node_count= 1;
|
|
}
|
|
|
|
if(dir_create && !(flag & (1 << 9))) {
|
|
ret= Xorriso_lst_append_binary(&(xorriso->node_disk_prefixes),
|
|
disk_path, strlen(disk_path) + 1, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= Xorriso_lst_append_binary(&(xorriso->node_img_prefixes),
|
|
img_path, strlen(img_path) + 1, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
|
|
ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&4));
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret>0)
|
|
{ret= 3*!!(flag&16); goto ex;}
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
strncpy(path, disk_path, sizeof(path)-1);
|
|
path[sizeof(path)-1]= 0;
|
|
apt= npt= path;
|
|
|
|
if(!(flag&1)) {
|
|
ret= Xorriso_fake_stbuf(xorriso, img_path, &stbuf, &node, 0);
|
|
if(ret>0) {
|
|
if(S_ISDIR(stbuf.st_mode))
|
|
is_dir= 1;
|
|
|
|
#ifdef Osirrox_not_yeT
|
|
|
|
/* ??? this would cause severe problems with Xorriso_path_from_node() */
|
|
|
|
else if((stbuf.st_mode&S_IFMT)==S_IFLNK &&
|
|
(xorriso->do_follow_links ||
|
|
(xorriso->do_follow_param && !(flag&4)))) {
|
|
resolve_link= 1;
|
|
ret= Xorriso_iso_lstat(xorriso, img_path, &stbuf, 1|2);
|
|
if(ret!=-1) {
|
|
if(S_ISDIR(stbuf.st_mode))
|
|
is_dir= 1;
|
|
}
|
|
}
|
|
#endif /* Osirrox_not_yeT */
|
|
|
|
} else {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot determine attributes of (ISO) source file %s",
|
|
Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(is_dir && xorriso->do_concat_split)
|
|
leaf_is_split= Xorriso_is_split(xorriso, img_path, node, 1|2);
|
|
}
|
|
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++;
|
|
if(done)
|
|
goto attach_source;
|
|
continue;
|
|
}
|
|
source_is_dir= (is_dir || (flag&1) || !done);
|
|
source_is_split= done && leaf_is_split;
|
|
|
|
stbuf_ret= -1;
|
|
if((flag&8) && done) {
|
|
|
|
/* ??? move down from Xorriso_paste_in() :
|
|
check whether target does not exist or both are regular */;
|
|
|
|
} else if(source_is_dir || !(dir_create || node_count || node_register)) {
|
|
ret= Xorriso_handle_collision(xorriso, node, img_path, path, disk_path,
|
|
&stbuf_ret, (source_is_dir && !source_is_split));
|
|
if(ret<=0 || ret==3)
|
|
goto ex;
|
|
}
|
|
|
|
new_dir_made= 0;
|
|
if(stbuf_ret==-1 && (source_is_dir && !source_is_split) &&
|
|
!(node_count || node_register)) {
|
|
/* make a directory */
|
|
ret= mkdir(path, 0777);
|
|
if(ret==-1) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"While restoring '%s' : could not insert '%s'", disk_path, path);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
if(!done) {
|
|
/* keep rwx for the owner */
|
|
Xorriso_restore_implicit_properties(xorriso, disk_path, path,
|
|
img_path, 4);
|
|
}
|
|
new_dir_made= 1;
|
|
} else if((source_is_dir && !source_is_split)) {
|
|
if(!(node_count || node_register))
|
|
Xorriso_auto_chmod(xorriso, path, 0);
|
|
}
|
|
if(done) {
|
|
attach_source:;
|
|
|
|
if(flag&1) {
|
|
/* directory was created above */;
|
|
|
|
} else if(is_dir && !source_is_split) {
|
|
|
|
if(!node_register) {
|
|
if(new_dir_made) /* keep open and push to Permstack */
|
|
Xorriso_restore_properties(xorriso, disk_path, node,
|
|
2 | !!(flag&64));
|
|
}
|
|
if(!(flag&32)) {
|
|
ret= Xorriso_restore_tree(xorriso, (IsoDir *) node, img_path, path,
|
|
(off_t) 0, NULL, flag & (2 | 64 | (3 << 7)));
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(new_dir_made && !(flag&64))
|
|
/* set timestamps which Permstack_pop() will not set */
|
|
Xorriso_restore_properties(xorriso, disk_path, node, 2);
|
|
}
|
|
} else {
|
|
if(dir_create || node_count) {
|
|
xorriso->node_counter++;
|
|
} else if(node_register) {
|
|
if(xorriso->node_counter < xorriso->node_array_size) {
|
|
xorriso->node_array[xorriso->node_counter++]= (void *) node;
|
|
iso_node_ref(node);
|
|
}
|
|
} else {
|
|
ret= Xorriso_restore_disk_object(xorriso, img_path, node, path,
|
|
offset, bytes, (flag & (2|4|64)) | !!(flag&8));
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
}
|
|
} else
|
|
*npt= '/';
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
ret= 1 + (is_dir && !leaf_is_split);
|
|
ex:;
|
|
/* restore exact access permissions of stacked paths */
|
|
hret= Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso,
|
|
2 | !!(flag&64));
|
|
if(hret<=0 && hret<ret)
|
|
ret= hret;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_restore_node_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int i, ret, was_failure= 0, fret, hflag, stbuf_ret, faulty_family= 0;
|
|
struct PermiteM *perm_stack_mem;
|
|
char img_path[SfileadrL], disk_path[SfileadrL];
|
|
IsoNode *node;
|
|
struct Xorriso_lsT *img_prefixes= NULL, *disk_prefixes= NULL;
|
|
|
|
perm_stack_mem= xorriso->perm_stack;
|
|
|
|
Xorriso_sort_node_array(xorriso, 0);
|
|
|
|
disk_path[0]= 0;
|
|
for(i= 0; i < xorriso->node_counter; i++) {
|
|
node= (IsoNode *) xorriso->node_array[i];
|
|
ret= Xorriso_path_from_node(xorriso, node, img_path, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0)
|
|
continue; /* Node is deleted from tree (Should not happen here) */
|
|
hflag= 1;
|
|
if(i == 0) {
|
|
hflag= 0;
|
|
} else if(node != xorriso->node_array[i - 1]) {
|
|
hflag= 0;
|
|
}
|
|
if(hflag == 0) {
|
|
img_prefixes= xorriso->node_img_prefixes;
|
|
disk_prefixes= xorriso->node_disk_prefixes;
|
|
}
|
|
ret= Xorriso_make_restore_path(xorriso, &img_prefixes, &disk_prefixes,
|
|
img_path, disk_path, hflag);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
|
|
ret= Xorriso_handle_collision(xorriso, node, img_path, disk_path, disk_path,
|
|
&stbuf_ret, 64);
|
|
if(ret<=0 || ret==3)
|
|
goto was_problem;
|
|
if(xorriso->hln_array != NULL && !(xorriso->ino_behavior & 16)) {
|
|
/* Eventual lookup of hardlinks will be done in
|
|
Xorriso_restore_disk_object() */;
|
|
} else if(i > 0 && !(xorriso->ino_behavior & 4)) {
|
|
if(Xorriso__findi_sorted_ino_cmp(&(xorriso->node_array[i-1]),
|
|
&(xorriso->node_array[i])) == 0) {
|
|
if(faulty_family) {
|
|
sprintf(xorriso->info_text, "Hardlinking omitted with ");
|
|
Text_shellsafe(disk_path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
} else {
|
|
/* Try to install hardlink to a sibling */
|
|
ret= Xorriso_restore_prefix_hl(xorriso, node, disk_path, i, 0);
|
|
if(ret < 0) {
|
|
goto was_problem;
|
|
} else if(ret & 1) {
|
|
/* Success, hardlink was created */
|
|
xorriso->pacifier_count++;
|
|
continue;
|
|
}
|
|
if(ret & 4) {
|
|
/* Found elder siblings, but did not link. */
|
|
ret= Xorriso_eval_problem_status(xorriso, 1, 0);
|
|
if(ret < 0)
|
|
{ret= 0; goto ex;}
|
|
}
|
|
}
|
|
} else
|
|
faulty_family= 0;
|
|
}
|
|
|
|
ret= Xorriso_restore_disk_object(xorriso, img_path, node, disk_path,
|
|
(off_t) 0, (off_t) 0,
|
|
4 | (xorriso->ino_behavior & 16) | 128);
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
if(ret == 4) {
|
|
/* Failed from lack of permission */
|
|
ret= Xorriso_make_accessible(xorriso, disk_path, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
ret= Xorriso_restore_disk_object(xorriso, img_path, node, disk_path,
|
|
(off_t) 0, (off_t) 0, 4 | (xorriso->ino_behavior & 16));
|
|
if(ret<=0)
|
|
goto was_problem;
|
|
Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, 0);
|
|
}
|
|
|
|
continue; /* regular bottom of loop */
|
|
was_problem:;
|
|
faulty_family= 1;
|
|
was_failure= 1;
|
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
|
|
if(fret<0)
|
|
goto ex;
|
|
Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, 0);
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= -follow, -not: disk_path is not a command parameter
|
|
*/
|
|
int Xorriso_paste_in(struct XorrisO *xorriso, char *disk_path,
|
|
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag)
|
|
{
|
|
int ret;
|
|
char eff_source[SfileadrL], eff_dest[SfileadrL], sfe[SfileadrL*5];
|
|
struct stat stbuf;
|
|
IsoNode *node;
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_dest,
|
|
2|4);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&1));
|
|
if(ret!=0)
|
|
return(0);
|
|
ret= stat(eff_dest, &stbuf);
|
|
if(ret!=-1 && !S_ISREG(stbuf.st_mode)) {
|
|
Xorriso_msgs_submit(xorriso, 0, eff_dest, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"-paste_in: DISK file %s exists and is not a data file",
|
|
Text_shellsafe(eff_source, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, iso_rr_path,
|
|
eff_source, 2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_fake_stbuf(xorriso, eff_source, &stbuf, &node, 4);
|
|
if(ret<=0)
|
|
return(0);
|
|
if(!S_ISREG(stbuf.st_mode)) {
|
|
Xorriso_msgs_submit(xorriso, 0, eff_dest, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text, "-paste_in: ISO file %s is not a data file",
|
|
Text_shellsafe(eff_source, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
/* >>> eventually obtain parameters from file name */;
|
|
|
|
ret= Xorriso_restore(xorriso, eff_source, eff_dest, startbyte, bytecount, 8);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, error_code= 0, os_errno= 0, count= 0, pass, imgid, tunneled;
|
|
char severity[80];
|
|
|
|
if(!xorriso->libs_are_started)
|
|
return(1);
|
|
for(pass= 0; pass< 2; pass++) {
|
|
while(1) {
|
|
tunneled= 0;
|
|
if(pass==0)
|
|
ret= iso_obtain_msgs("ALL", &error_code, &imgid,
|
|
xorriso->info_text, severity);
|
|
else {
|
|
ret= burn_msgs_obtain("ALL", &error_code, xorriso->info_text, &os_errno,
|
|
severity);
|
|
if((error_code>=0x00030000 && error_code<0x00040000) ||
|
|
(error_code>=0x00050000 && error_code<0x00060000))
|
|
tunneled= -1; /* "libisofs:" */
|
|
else if(error_code>=0x00060000 && error_code<0x00070000)
|
|
tunneled= 1; /* "libisoburn:" */
|
|
}
|
|
if(ret<=0)
|
|
break;
|
|
|
|
/* <<< tunneled MISHAP from libisoburn through libburn
|
|
or well known error codes of MISHAP events
|
|
With libburn-0.4.4 this is not necessary */
|
|
if(error_code==0x5ff73 || error_code==0x3ff73 ||
|
|
error_code==0x3feb9 || error_code==0x3feb2)
|
|
strcpy(severity, "MISHAP");
|
|
else if(error_code==0x51001)
|
|
strcpy(severity, "ERRFILE");
|
|
|
|
Xorriso_msgs_submit(xorriso, error_code, xorriso->info_text, os_errno,
|
|
severity, ((pass+tunneled)+1)<<2);
|
|
count++;
|
|
}
|
|
}
|
|
if(xorriso->library_msg_direct_print && count>0) {
|
|
sprintf(xorriso->info_text," (%d library messages repeated by xorriso)\n",
|
|
count);
|
|
Xorriso_info(xorriso, 0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag
|
|
bit3=report to info channel (else to result channel)
|
|
*/
|
|
int Xorriso_toc_line(struct XorrisO *xorriso, int flag)
|
|
{
|
|
if(!(flag & 8)) {
|
|
Xorriso_result(xorriso,0);
|
|
return(1);
|
|
}
|
|
strcpy(xorriso->info_text, xorriso->result_line);
|
|
Xorriso_info(xorriso, 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= no output if no boot record was found
|
|
bit1= short form
|
|
bit3= report to info channel (else to result channel)
|
|
*/
|
|
int Xorriso_show_boot_info(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, bin_path_valid= 0,has_isolinux_mbr= 0, i;
|
|
unsigned int mbr_lba= 0;
|
|
off_t lb0_count;
|
|
char *respt, sfe[5*SfileadrL], path[SfileadrL];
|
|
unsigned char lb0[2048];
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
IsoImage *image= NULL;
|
|
ElToritoBootImage *bootimg;
|
|
IsoFile *bootimg_node;
|
|
IsoBoot *bootcat_node;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to print boot info", 0);
|
|
if(ret<=0)
|
|
return(0);
|
|
respt= xorriso->result_line;
|
|
image= isoburn_get_attached_image(drive);
|
|
if(image == NULL) {
|
|
ret= 0;
|
|
no_boot:;
|
|
if(!(flag & 1)) {
|
|
sprintf(respt, "Boot record : none\n");
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
}
|
|
return(ret);
|
|
}
|
|
/* Important: no return before iso_image_unref(image); */
|
|
|
|
/* Using the nodes with extreme care . They might be deleted meanwhile. */
|
|
ret= iso_image_get_boot_image(image, &bootimg, &bootimg_node, &bootcat_node);
|
|
iso_image_unref(image); /* release obtained reference */
|
|
image= NULL;
|
|
if(ret != 1)
|
|
goto no_boot;
|
|
ret= Xorriso_path_from_lba(xorriso, NULL, xorriso->loaded_boot_bin_lba,
|
|
path, 1);
|
|
if(ret > 0)
|
|
bin_path_valid= 1;
|
|
sprintf(respt, "Boot record : El Torito");
|
|
if(bin_path_valid)
|
|
ret= Xorriso_is_isohybrid(xorriso, bootimg_node, 0);
|
|
else
|
|
ret= 0;
|
|
if(ret > 0) {
|
|
/* Load and examine potential MBR */
|
|
ret= burn_read_data(drive, (off_t) 0, (char *) lb0, (off_t) 2048,
|
|
&lb0_count, 2);
|
|
if(ret > 0) {
|
|
has_isolinux_mbr= 1;
|
|
if(lb0[510] != 0x55 || lb0[511] != 0xaa)
|
|
has_isolinux_mbr= 0;
|
|
mbr_lba= lb0[432] | (lb0[433] << 8) | (lb0[434] << 16) | (lb0[435] << 24);
|
|
mbr_lba/= 4;
|
|
if(mbr_lba != xorriso->loaded_boot_bin_lba)
|
|
has_isolinux_mbr= 0;
|
|
if(has_isolinux_mbr) {
|
|
for(i= 0; i < 426; i++)
|
|
if(strncmp((char *) (lb0 + i), "isolinux", 8) == 0)
|
|
break;
|
|
if(i >= 426)
|
|
has_isolinux_mbr= 0;
|
|
}
|
|
for(i= 462; i < 510; i++)
|
|
if(lb0[i])
|
|
break;
|
|
if(i < 510)
|
|
has_isolinux_mbr= 0;
|
|
}
|
|
if(has_isolinux_mbr)
|
|
strcat(respt, " , ISOLINUX isohybrid MBR pointing to boot image");
|
|
else
|
|
strcat(respt, " , ISOLINUX boot image capable of isohybrid");
|
|
}
|
|
strcat(respt, "\n");
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
if(flag & 2)
|
|
return(1);
|
|
if(bin_path_valid)
|
|
sprintf(respt, "Boot bin_path: %s\n", Text_shellsafe(path, sfe, 0));
|
|
else if(xorriso->loaded_boot_bin_lba <= 0)
|
|
sprintf(respt, "Boot bin_path: -not-found-at-load-time-\n");
|
|
else
|
|
sprintf(respt, "Boot bin_path: -not-found-any-more-by-lba=%d\n",
|
|
xorriso->loaded_boot_bin_lba);
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
if(xorriso->loaded_boot_cat_path[0])
|
|
sprintf(respt, "Boot cat_path: %s\n",
|
|
Text_shellsafe(xorriso->loaded_boot_cat_path, sfe, 0));
|
|
else
|
|
sprintf(respt, "Boot cat_path: -not-found-at-load-time-\n");
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0=short report form
|
|
bit1=report about output drive
|
|
bit2=do not try to read ISO heads
|
|
bit3=report to info channel (else to result channel)
|
|
*/
|
|
int Xorriso_toc(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int num_sessions= 0, num_tracks= 0, lba= 0, nwa= -1, pmin, psec, pframe, ret;
|
|
int track_count= 0, session_no, track_no, profile_no= -1, track_size;
|
|
int last_track_start= 0, last_track_size= -1, num_data= 0, is_data= 0;
|
|
int is_inout_drive= 0, drive_role, status, num_formats, emul_lba;
|
|
int num_payload= 0, num_wasted= 0, num_nondata= 0;
|
|
char profile_name[80],*respt,*devadr, *typetext= "";
|
|
struct burn_toc_entry toc_entry;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
enum burn_disc_status s;
|
|
char mem_text[80];
|
|
off_t start_byte= 0, num_free= 0, size;
|
|
unsigned dummy;
|
|
struct isoburn_toc_disc *disc= NULL;
|
|
struct isoburn_toc_session **sessions;
|
|
struct isoburn_toc_track **tracks;
|
|
int image_blocks;
|
|
char volume_id[33];
|
|
struct burn_toc_entry next_toc_entry;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to print Table Of Content", flag&2);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
respt= xorriso->result_line;
|
|
|
|
if(strcmp(xorriso->indev, xorriso->outdev)==0)
|
|
is_inout_drive= 1;
|
|
if(flag&2)
|
|
devadr= xorriso->outdev;
|
|
else
|
|
devadr= xorriso->indev;
|
|
sprintf(respt, "Drive current: %s '%s'\n",
|
|
(is_inout_drive ? "-dev" : (flag&2 ? "-outdev" : "-indev")),
|
|
devadr);
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
sprintf(respt, "Drive type : vendor '%s' product '%s' revision '%s'\n",
|
|
dinfo[0].vendor, dinfo[0].product, dinfo[0].revision);
|
|
if(!(flag&1))
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
|
|
sprintf(respt, "Media current: ");
|
|
ret= burn_disc_get_profile(drive, &profile_no, profile_name);
|
|
if (profile_no > 0 && ret > 0) {
|
|
if (profile_name[0])
|
|
sprintf(respt+strlen(respt), "%s", profile_name);
|
|
else
|
|
sprintf(respt+strlen(respt), "%4.4Xh", profile_no);
|
|
drive_role= burn_drive_get_drive_role(drive);
|
|
if(drive_role==2)
|
|
sprintf(respt+strlen(respt), ", overwriteable");
|
|
else if(drive_role==0 || drive_role==3)
|
|
sprintf(respt+strlen(respt), ", sequential");
|
|
strcat(respt, "\n");
|
|
} else
|
|
sprintf(respt+strlen(respt), "is not recognizable\n");
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
|
|
sprintf(respt, "Media status : ");
|
|
s= isoburn_disc_get_status(drive);
|
|
if (s == BURN_DISC_FULL) {
|
|
sprintf(respt+strlen(respt), "is written , is closed\n");
|
|
} else if (s == BURN_DISC_APPENDABLE) {
|
|
sprintf(respt+strlen(respt), "is written , is appendable\n");
|
|
} else if (s == BURN_DISC_BLANK) {
|
|
sprintf(respt+strlen(respt), "is blank\n");
|
|
} else if (s == BURN_DISC_EMPTY)
|
|
sprintf(respt+strlen(respt), "is not present\n");
|
|
else
|
|
sprintf(respt+strlen(respt), "is not recognizable\n");
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
|
|
if(s == BURN_DISC_BLANK) {
|
|
sprintf(respt, "Media summary: 0 sessions, 0 data blocks, 0 data");
|
|
num_free= isoburn_disc_available_space(drive, NULL);
|
|
Sfile_scale((double) num_free, mem_text,5,1e4,1);
|
|
sprintf(respt+strlen(respt), ", %s free\n", mem_text);
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
}
|
|
if(s != BURN_DISC_FULL && s != BURN_DISC_APPENDABLE)
|
|
return(1);
|
|
if(xorriso->request_to_abort)
|
|
return(1);
|
|
|
|
if(!(flag & 2))
|
|
Xorriso_show_boot_info(xorriso, 1 | (flag & 8) | ((flag & 1) << 1));
|
|
|
|
disc= isoburn_toc_drive_get_disc(drive);
|
|
if(flag & 4)
|
|
sprintf(respt, "TOC layout : %3s , %9s , %10s\n",
|
|
"Idx", "sbsector", "Size");
|
|
else
|
|
sprintf(respt, "TOC layout : %3s , %9s , %10s , %s\n",
|
|
"Idx", "sbsector", "Size", "Volume Id");
|
|
if(!(flag&1))
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
|
|
if (disc==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
ret= isoburn_get_min_start_byte(drive, &start_byte, 0);
|
|
nwa= start_byte / 2048;
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(flag&1)
|
|
return(0);
|
|
sprintf(xorriso->info_text, "Cannot obtain Table Of Content");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
return(0);
|
|
}
|
|
|
|
/* fabricate TOC */
|
|
typetext= "Other session";
|
|
if(flag & 4) {
|
|
ret= 0;
|
|
typetext= "Session ";
|
|
} else
|
|
ret= isoburn_read_iso_head(drive, 0, &image_blocks, volume_id, 1);
|
|
if(ret>0) {
|
|
sprintf(respt, "ISO session : %3d , %9d , %9ds , %s\n",
|
|
1, 0, image_blocks, volume_id);
|
|
nwa= image_blocks;
|
|
} else {
|
|
nwa= 0;
|
|
ret= burn_disc_get_formats(drive, &status, &size, &dummy,
|
|
&num_formats);
|
|
if(ret>0 && status==BURN_FORMAT_IS_FORMATTED)
|
|
nwa= size/2048;
|
|
sprintf(respt, "%13s: %3d , %9d , %9ds , \n",
|
|
typetext, 1, 0, nwa);
|
|
}
|
|
if(!(flag&1))
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
last_track_start= lba;
|
|
num_payload= num_data= last_track_size= nwa;
|
|
num_sessions= 1;
|
|
} else {
|
|
sessions= isoburn_toc_disc_get_sessions(disc, &num_sessions);
|
|
for (session_no= 0; session_no<num_sessions && !(xorriso->request_to_abort);
|
|
session_no++) {
|
|
tracks= isoburn_toc_session_get_tracks(sessions[session_no], &num_tracks);
|
|
if (tracks==NULL)
|
|
continue;
|
|
for(track_no= 0; track_no<num_tracks && !(xorriso->request_to_abort);
|
|
track_no++) {
|
|
track_count++;
|
|
is_data= 0;
|
|
isoburn_toc_track_get_entry(tracks[track_no], &toc_entry);
|
|
if (toc_entry.extensions_valid & 1) {
|
|
/* DVD extension valid */
|
|
lba= toc_entry.start_lba;
|
|
track_size= toc_entry.track_blocks;
|
|
} else {
|
|
lba= burn_msf_to_lba(toc_entry.pmin, toc_entry.psec,
|
|
toc_entry.pframe);
|
|
if(track_no==num_tracks-1) {
|
|
isoburn_toc_session_get_leadout_entry(sessions[session_no],
|
|
&next_toc_entry);
|
|
} else {
|
|
isoburn_toc_track_get_entry(tracks[track_no+1], &next_toc_entry);
|
|
}
|
|
track_size= burn_msf_to_lba(next_toc_entry.pmin, next_toc_entry.psec,
|
|
next_toc_entry.pframe) - lba;
|
|
}
|
|
if(flag&(1|4))
|
|
ret= 0;
|
|
else {
|
|
ret= isoburn_toc_track_get_emul(tracks[track_no], &emul_lba,
|
|
&image_blocks, volume_id, 0);
|
|
if(ret <= 0)
|
|
ret= isoburn_read_iso_head(drive, lba, &image_blocks, volume_id, 1);
|
|
if(image_blocks > track_size) {
|
|
sprintf(xorriso->info_text,
|
|
"Session %d bears ISO image size %ds larger than track size %ds",
|
|
session_no + 1, image_blocks, track_size);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING",
|
|
0);
|
|
image_blocks= track_size;
|
|
}
|
|
}
|
|
if(ret>0 && track_no==0) {
|
|
sprintf(respt, "ISO session : %3d , %9d , %9ds , %s\n",
|
|
session_no+1, lba, image_blocks , volume_id);
|
|
} else if(ret>0) {
|
|
sprintf(respt, "ISO track : %3d , %9d , %9ds , %s\n",
|
|
track_count, lba, image_blocks , volume_id);
|
|
} else if(track_no==0) {
|
|
typetext= "Other session";
|
|
if(flag & 4)
|
|
typetext= "Session ";
|
|
sprintf(respt, "%13s: %3d , %9d , %9ds , \n",
|
|
typetext, session_no+1, lba, track_size);
|
|
} else {
|
|
typetext= "Other track ";
|
|
if(flag & 4)
|
|
typetext= "Track ";
|
|
sprintf(respt, "%13s: %3d , %9d , %9ds , \n",
|
|
typetext, track_count, lba, track_size);
|
|
}
|
|
if(!(flag&1))
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
if(track_no>0)
|
|
num_payload+= lba - last_track_start;
|
|
last_track_start= lba;
|
|
if((toc_entry.control&7)>=4) /* data track */
|
|
is_data= 1;
|
|
}
|
|
isoburn_toc_session_get_leadout_entry(sessions[session_no], &toc_entry);
|
|
if (toc_entry.extensions_valid & 1) {
|
|
lba= toc_entry.start_lba;
|
|
burn_lba_to_msf(lba, &pmin, &psec, &pframe);
|
|
} else {
|
|
lba= burn_msf_to_lba(pmin, psec, pframe);
|
|
lba= burn_msf_to_lba(toc_entry.pmin, toc_entry.psec, toc_entry.pframe);
|
|
}
|
|
last_track_size= lba - last_track_start;
|
|
num_payload+= last_track_size;
|
|
if(is_data)
|
|
num_data+= last_track_size;
|
|
}
|
|
}
|
|
if(xorriso->request_to_abort)
|
|
return(1);
|
|
num_wasted= lba - num_payload;
|
|
num_nondata= lba - num_data;
|
|
Sfile_scale(((double) num_data) * 2048.0, mem_text,5,1e4,1);
|
|
|
|
sprintf(respt, "Media summary: %d session%s, %d data blocks, %s data",
|
|
num_sessions, (num_sessions==1 ? "" : "s"), num_data, mem_text);
|
|
num_free= isoburn_disc_available_space(drive, NULL);
|
|
Sfile_scale((double) num_free, mem_text,5,1e4,1);
|
|
sprintf(respt+strlen(respt), ", %s free", mem_text);
|
|
|
|
sprintf(respt+strlen(respt), "\n");
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
|
|
if (s==BURN_DISC_APPENDABLE && nwa!=0) {
|
|
ret= isoburn_disc_track_lba_nwa(drive, NULL, 0, &lba, &nwa);
|
|
if(ret>0) {
|
|
sprintf(respt, "Media nwa : %ds\n", nwa);
|
|
if(!(flag&1))
|
|
Xorriso_toc_line(xorriso, flag & 8);
|
|
}
|
|
}
|
|
|
|
if (disc!=NULL)
|
|
isoburn_toc_disc_free(disc);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_show_devices(struct XorrisO *xorriso, int flag)
|
|
{
|
|
char adr[BURN_DRIVE_ADR_LEN];
|
|
int i, j, max_dev_len= 1, pad;
|
|
struct burn_drive_info *drive_list= NULL;
|
|
unsigned int drive_count;
|
|
char *respt, perms[8];
|
|
struct stat stbuf;
|
|
|
|
sprintf(xorriso->info_text, "Beginning to scan for devices ...\n");
|
|
Xorriso_info(xorriso,0);
|
|
|
|
burn_drive_clear_whitelist();
|
|
while(!burn_drive_scan(&drive_list, &drive_count)) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
usleep(100000);
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(drive_count <= 0) {
|
|
|
|
/* >>> was a drive_list created at all ? */
|
|
/* >>> must it be freed ? */
|
|
|
|
sprintf(xorriso->info_text, "No drives found");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
return(0);
|
|
}
|
|
sprintf(xorriso->info_text, "Full drive scan done\n");
|
|
Xorriso_info(xorriso,0);
|
|
|
|
sprintf(xorriso->info_text, "-----------------------------------------------------------------------------\n");
|
|
Xorriso_info(xorriso,0);
|
|
respt= xorriso->result_line;
|
|
for(i= 0; i < drive_count && !(xorriso->request_to_abort); i++) {
|
|
if(burn_drive_get_adr(&(drive_list[i]), adr)<=0)
|
|
strcpy(adr, "-get_adr_failed-");
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(strlen(adr)>max_dev_len)
|
|
max_dev_len= strlen(adr);
|
|
}
|
|
for(i= 0; i < drive_count && !(xorriso->request_to_abort); i++) {
|
|
if(burn_drive_get_adr(&(drive_list[i]), adr)<=0)
|
|
strcpy(adr, "-get_adr_failed-");
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(stat(adr,&stbuf)==-1) {
|
|
sprintf(perms,"errno=%d",errno);
|
|
} else {
|
|
strcpy(perms,"------");
|
|
if(stbuf.st_mode&S_IRUSR) perms[0]= 'r';
|
|
if(stbuf.st_mode&S_IWUSR) perms[1]= 'w';
|
|
if(stbuf.st_mode&S_IRGRP) perms[2]= 'r';
|
|
if(stbuf.st_mode&S_IWGRP) perms[3]= 'w';
|
|
if(stbuf.st_mode&S_IROTH) perms[4]= 'r';
|
|
if(stbuf.st_mode&S_IWOTH) perms[5]= 'w';
|
|
}
|
|
sprintf(respt, "%d -dev '%s' ", i, adr);
|
|
pad= max_dev_len-strlen(adr);
|
|
if(pad>0)
|
|
for(j= 0; j<pad; j++)
|
|
strcat(respt, " ");
|
|
sprintf(respt+strlen(respt), "%s : '%-8.8s' '%s' \n",
|
|
perms, drive_list[i].vendor, drive_list[i].product);
|
|
Xorriso_result(xorriso,0);
|
|
}
|
|
sprintf(xorriso->info_text, "-----------------------------------------------------------------------------\n");
|
|
Xorriso_info(xorriso,0);
|
|
|
|
burn_drive_info_free(drive_list);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_tell_media_space(struct XorrisO *xorriso,
|
|
int *media_space, int *free_space, int flag)
|
|
{
|
|
int ret;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
struct burn_write_opts *burn_options;
|
|
|
|
(*free_space)= (*media_space)= 0;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to -tell_media_space", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0);
|
|
if(ret<=0)
|
|
return(-1);
|
|
(*free_space)= (*media_space)=
|
|
isoburn_disc_available_space(drive, burn_options) / (off_t) 2048;
|
|
burn_write_opts_free(burn_options);
|
|
|
|
if(xorriso->volset_change_pending) {
|
|
ret= Xorriso_write_session(xorriso, 1);
|
|
if(ret>0)
|
|
(*free_space)-= ret;
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= fast
|
|
bit1= deformat
|
|
bit2= do not re-aquire drive
|
|
@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)
|
|
{
|
|
int ret, do_deformat= 0;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
enum burn_disc_status disc_state;
|
|
struct burn_progress p;
|
|
double percent = 1.0;
|
|
int current_profile;
|
|
char current_profile_name[80];
|
|
time_t start_time;
|
|
char mode_names[4][80]= {"all", "fast", "deformat", "deformat_quickest"};
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to -blank", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
burn_disc_get_profile(drive, ¤t_profile, current_profile_name);
|
|
|
|
disc_state = isoburn_disc_get_status(drive);
|
|
if(current_profile == 0x13) { /* overwriteable DVD-RW */
|
|
/* Depending on flag bit1 formatted DVD-RW will get blanked to sequential
|
|
state or pseudo blanked by invalidating an eventual ISO image. */
|
|
if(flag&2)
|
|
do_deformat= 1;
|
|
} else if(current_profile == 0x14) { /* sequential DVD-RW */
|
|
if((flag&1) && !(flag&2)) {
|
|
sprintf(xorriso->info_text,
|
|
"-blank: DVD-RW present. Mode 'fast' defaulted to mode 'all'.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"Mode 'deformat_quickest' produces single-session-only media.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
|
|
flag&= ~1;
|
|
}
|
|
} else if(disc_state == BURN_DISC_BLANK) {
|
|
sprintf(xorriso->info_text,"Blank media detected. Will leave it untouched");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return 2;
|
|
} else if(disc_state==BURN_DISC_FULL || disc_state==BURN_DISC_APPENDABLE) {
|
|
;
|
|
} else if(disc_state == BURN_DISC_EMPTY) {
|
|
sprintf(xorriso->info_text,"No media detected in drive");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return 0;
|
|
} else {
|
|
sprintf(xorriso->info_text, "Unsuitable drive and media state");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return 0;
|
|
}
|
|
if(!isoburn_disc_erasable(drive)) {
|
|
sprintf(xorriso->info_text, "Media is not of erasable type");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return 0;
|
|
}
|
|
if(xorriso->do_dummy) {
|
|
sprintf(xorriso->info_text,
|
|
"-dummy mode prevents blanking of media in mode '%s'.",
|
|
mode_names[flag&3]);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(1);
|
|
}
|
|
sprintf(xorriso->info_text, "Beginning to blank media in mode '%s'.\n",
|
|
mode_names[flag&3]);
|
|
Xorriso_info(xorriso,0);
|
|
|
|
if(do_deformat)
|
|
burn_disc_erase(drive, (flag&1));
|
|
else
|
|
isoburn_disc_erase(drive, (flag&1));
|
|
start_time= time(0);
|
|
usleep(1000000);
|
|
while (burn_drive_get_status(drive, &p) != BURN_DRIVE_IDLE) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(p.sectors>0 && p.sector>=0) /* display 1 to 99 percent */
|
|
percent = 1.0 + ((double) p.sector+1.0) / ((double) p.sectors) * 98.0;
|
|
sprintf(xorriso->info_text, "Blanking ( %.1f%% done in %d seconds )",
|
|
percent, (int) (time(0) - start_time));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
|
|
usleep(1000000);
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text, "Blanking done\n");
|
|
Xorriso_info(xorriso,0);
|
|
if(!(flag & 4)) {
|
|
ret= Xorriso_reaquire_outdev(xorriso,
|
|
2 + (xorriso->in_drive_handle == xorriso->out_drive_handle));
|
|
if(ret <= 0)
|
|
return(-1);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= try to achieve faster formatting
|
|
bit1= use parameter size (else use default size)
|
|
bit2= do not re-aquire drive
|
|
bit7= by_index mode:
|
|
bit8 to bit15 contain the index of the format to use.
|
|
@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, off_t in_size, int flag)
|
|
{
|
|
int ret, mode_flag= 0, index, status, num_formats;
|
|
unsigned dummy;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
struct burn_progress p;
|
|
double percent = 1.0;
|
|
int current_profile;
|
|
char current_profile_name[80];
|
|
off_t size= 0;
|
|
time_t start_time;
|
|
enum burn_disc_status disc_state;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to -format", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
if(flag & 2) {
|
|
mode_flag= 0; /* format to given size */
|
|
} else {
|
|
mode_flag= 4; /* format to full size */
|
|
}
|
|
burn_disc_get_profile(drive, ¤t_profile, current_profile_name);
|
|
|
|
if(flag&128) { /* by_index */
|
|
index= (flag>>8) & 0xff;
|
|
ret= burn_disc_get_formats(drive, &status, &size, &dummy, &num_formats);
|
|
if(ret<=0)
|
|
num_formats= 0;
|
|
if(ret<=0 || index<0 || index>=num_formats) {
|
|
if(num_formats>0)
|
|
sprintf(xorriso->info_text,
|
|
"-format by_index_%d: format descriptors range from index 0 to %d",
|
|
index, num_formats-1);
|
|
else
|
|
sprintf(xorriso->info_text,
|
|
"-format by_index_%d: no format descriptors available", index);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
mode_flag|= (flag & 0xff80);
|
|
if(flag&1)
|
|
mode_flag|= (1<<6);
|
|
|
|
} else if(current_profile == 0x12) { /* DVD+RAM */
|
|
if(!(flag & 2))
|
|
mode_flag= 6; /* format to default payload size */
|
|
if(flag&1)
|
|
mode_flag|= (1<<6);
|
|
|
|
} else if(current_profile == 0x13) { /* DVD-RW */
|
|
if(flag&1) {
|
|
sprintf(xorriso->info_text,
|
|
"Detected formatted DVD-RW. Thus omitting desired fast format run.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(2);
|
|
}
|
|
|
|
} else if(current_profile == 0x14) { /* DVD-RW sequential */
|
|
if(flag & 1) {
|
|
size= 128*1024*1024;
|
|
mode_flag= 1; /* format to size, then write size of zeros */
|
|
} else
|
|
mode_flag= 4;
|
|
|
|
} else if(current_profile == 0x1a) { /* DVD+RW */
|
|
if(flag&1) {
|
|
sprintf(xorriso->info_text,
|
|
"Detected DVD+RW. Thus omitting desired fast format run.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(2);
|
|
}
|
|
|
|
} else if(current_profile == 0x41) { /* BD-R SRM */
|
|
if(!(flag & 2))
|
|
mode_flag= 6; /* format to default payload size */
|
|
if(flag&1)
|
|
mode_flag|= (1<<6);
|
|
|
|
} else if(current_profile == 0x43) { /* BD-RE */
|
|
if(!(flag & 2))
|
|
mode_flag= 6; /* format to default payload size */
|
|
if(flag&1)
|
|
mode_flag|= (1<<6);
|
|
|
|
} else {
|
|
sprintf(xorriso->info_text,
|
|
"-format: Unsuitable media detected.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
sprintf(xorriso->info_text,"Media current: %s (%4.4xh)",
|
|
current_profile_name, current_profile);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(0);
|
|
}
|
|
if(!(flag & 1))
|
|
mode_flag|= 16; /* enable re-formatting */
|
|
|
|
if(xorriso->do_dummy) {
|
|
sprintf(xorriso->info_text, "-dummy mode prevents formatting of media.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(1);
|
|
}
|
|
sprintf(xorriso->info_text, "Beginning to format media.\n");
|
|
Xorriso_info(xorriso, 0);
|
|
if(flag & 2)
|
|
size= in_size;
|
|
burn_disc_format(drive, size, mode_flag);
|
|
|
|
start_time= time(0);
|
|
usleep(1000000);
|
|
while (burn_drive_get_status(drive, &p) != BURN_DRIVE_IDLE) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(p.sectors>0 && p.sector>=0) /* display 1 to 99 percent */
|
|
percent = 1.0 + ((double) p.sector+1.0) / ((double) p.sectors) * 98.0;
|
|
sprintf(xorriso->info_text, "Formatting ( %.1f%% done in %d seconds )",
|
|
percent, (int) (time(0) - start_time));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
|
|
usleep(1000000);
|
|
}
|
|
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
if(burn_drive_wrote_well(drive)) {
|
|
sprintf(xorriso->info_text, "Formatting done\n");
|
|
Xorriso_info(xorriso,0);
|
|
} else {
|
|
sprintf(xorriso->info_text,
|
|
"libburn indicates failure with formatting.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(-1);
|
|
}
|
|
|
|
if(!(flag & 4)) {
|
|
ret= Xorriso_reaquire_outdev(xorriso,
|
|
2 + (xorriso->in_drive_handle == xorriso->out_drive_handle));
|
|
if(ret <= 0)
|
|
return(-1);
|
|
}
|
|
disc_state = isoburn_disc_get_status(drive);
|
|
if(disc_state==BURN_DISC_FULL && !(flag&1)) {
|
|
/* Blank because full format certification pattern might be non-zero */
|
|
ret= Xorriso_blank_media(xorriso, 1);
|
|
if(ret <= 0)
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @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)
|
|
{
|
|
int ret, is_formatted= -1, status, num_formats, did_work= 0;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
enum burn_disc_status disc_state;
|
|
unsigned dummy;
|
|
int current_profile;
|
|
char current_profile_name[80];
|
|
off_t size;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to blank or format", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
burn_disc_get_profile(drive, ¤t_profile, current_profile_name);
|
|
|
|
ret= burn_disc_get_formats(drive, &status, &size, &dummy, &num_formats);
|
|
if(ret>0) {
|
|
if(status==BURN_FORMAT_IS_FORMATTED)
|
|
is_formatted= 1;
|
|
else if(status == BURN_FORMAT_IS_UNFORMATTED)
|
|
is_formatted= 0;
|
|
}
|
|
if(current_profile == 0x12 || current_profile == 0x43) { /* DVD+RAM , BD-RE */
|
|
if(is_formatted<0) {
|
|
sprintf(xorriso->info_text,
|
|
"-blank or -format: Unclear formatting status of %s",
|
|
current_profile_name);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
if(!is_formatted) {
|
|
ret= Xorriso_format_media(xorriso, (off_t) 0, (current_profile == 0x43));
|
|
if(ret <= 0)
|
|
return(ret);
|
|
did_work= (ret == 1);
|
|
}
|
|
} else if(current_profile == 0x14 && (flag&4)) { /* DVD-RW sequential */
|
|
ret= Xorriso_format_media(xorriso, (off_t) 0, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
did_work= (ret == 1);
|
|
} else if(current_profile == 0x41) { /* BD-R SRM */
|
|
if(!is_formatted) {
|
|
ret= Xorriso_format_media(xorriso, (off_t) 0, 1);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
did_work= (ret == 1);
|
|
}
|
|
}
|
|
|
|
disc_state = isoburn_disc_get_status(drive);
|
|
if(disc_state != BURN_DISC_BLANK && !(flag&4)) {
|
|
ret= Xorriso_blank_media(xorriso, 1);
|
|
return(ret);
|
|
}
|
|
if(did_work)
|
|
return(1);
|
|
sprintf(xorriso->info_text, "%s as_needed: no need for action detected",
|
|
(flag&4) ? "-format" : "-blank");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(2);
|
|
}
|
|
|
|
|
|
/* @return <=0 error, 1 success
|
|
*/
|
|
int Xorriso_list_formats(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, i, status, num_formats, profile_no, type;
|
|
off_t size;
|
|
unsigned dummy;
|
|
char status_text[80], profile_name[90], *respt;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
|
|
respt= xorriso->result_line;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to obtain format descriptor list", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
|
|
ret= burn_drive_get_drive_role(drive);
|
|
if(ret!=1) {
|
|
sprintf(xorriso->info_text,
|
|
"output device is not an MMC drive. -list_format does not apply");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= 2; goto ex;
|
|
}
|
|
|
|
ret = burn_disc_get_formats(drive, &status, &size, &dummy,
|
|
&num_formats);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text, "Cannot obtain format list info");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
ret= Xorriso_toc(xorriso, 3);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= burn_disc_get_profile(drive, &profile_no, profile_name);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
if(status == BURN_FORMAT_IS_UNFORMATTED)
|
|
sprintf(status_text, "unformatted, up to %.1f MiB",
|
|
((double) size) / 1024.0 / 1024.0);
|
|
else if(status == BURN_FORMAT_IS_FORMATTED) {
|
|
if(profile_no==0x12 || profile_no==0x13 || profile_no==0x1a ||
|
|
profile_no==0x43)
|
|
sprintf(status_text, "formatted, with %.1f MiB",
|
|
((double) size) / 1024.0 / 1024.0);
|
|
else
|
|
sprintf(status_text, "written, with %.1f MiB",
|
|
((double) size) / 1024.0 / 1024.0);
|
|
} else if(status == BURN_FORMAT_IS_UNKNOWN) {
|
|
if (profile_no > 0)
|
|
sprintf(status_text, "intermediate or unknown");
|
|
else
|
|
sprintf(status_text, "no media or unknown media");
|
|
} else
|
|
sprintf(status_text, "illegal status according to MMC-5");
|
|
sprintf(respt, "Format status: %s\n", status_text);
|
|
Xorriso_result(xorriso,0);
|
|
|
|
for (i= 0; i < num_formats; i++) {
|
|
ret= burn_disc_get_format_descr(drive, i, &type, &size, &dummy);
|
|
if (ret <= 0)
|
|
continue;
|
|
sprintf(respt, "Format idx %-2d: %2.2Xh , %.fs , %.1f MiB\n",
|
|
i, type, ((double) size) / 2048.0, ((double) size) / 1024.0/1024.0);
|
|
Xorriso_result(xorriso,0);
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_cannot_create_iter(struct XorrisO *xorriso, int iso_error,int flag)
|
|
{
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, "", iso_error, "Cannot create iter", 0,
|
|
"FATAL", 1);
|
|
sprintf(xorriso->info_text, "Cannot create IsoDirIter object");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso__node_lba_cmp(const void *node1, const void *node2)
|
|
{
|
|
int ret;
|
|
int lba1= 0, lba2= 0;
|
|
|
|
ret= Xorriso__file_start_lba(*((IsoNode **) node1), &lba1, 0);
|
|
if(ret!=1)
|
|
lba1= 0;
|
|
ret= Xorriso__file_start_lba(*((IsoNode **) node2), &lba2, 0);
|
|
if(ret!=1)
|
|
lba2= 0;
|
|
return(lba1-lba2);
|
|
}
|
|
|
|
/* The caller shall make no assumptions about the meaning of iter, node_array,
|
|
node_count, node_idx ! They are just opaque handles for which the caller
|
|
provides the memory of proper type.
|
|
@param flag bit0= initialize iteration
|
|
bit1= action needs full freedom of object manipulation
|
|
bit2= action needs LBA sorted iteration
|
|
bit31= end iteration (mandatory !)
|
|
*/
|
|
int Xorriso_findi_iter(struct XorrisO *xorriso, IsoDir *dir_node, off_t *mem,
|
|
IsoDirIter **iter,
|
|
IsoNode ***node_array, int *node_count, int *node_idx,
|
|
IsoNode **iterated_node, int flag)
|
|
{
|
|
int ret, i;
|
|
IsoNode *node;
|
|
off_t new_mem= 0;
|
|
char mem_text[80], limit_text[80];
|
|
|
|
if(flag&1) {
|
|
*node_array= NULL;
|
|
*node_count= -1;
|
|
*node_idx= 0;
|
|
*iter= NULL;
|
|
ret= iso_dir_get_children(dir_node, iter);
|
|
if(ret<0) {
|
|
cannot_iter:;
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
return(-1);
|
|
}
|
|
if((flag&2)|(flag&4)) {
|
|
/* copy list of nodes and prepare soft iterator */
|
|
*node_count= 0;
|
|
while(iso_dir_iter_next(*iter, &node) == 1)
|
|
(*node_count)++;
|
|
iso_dir_iter_free(*iter);
|
|
*iter= NULL;
|
|
|
|
new_mem= ((*node_count)+1) * sizeof(IsoNode *);
|
|
if(new_mem > xorriso->temp_mem_limit) {
|
|
Sfile_scale((double) new_mem, mem_text, 5,1e4, 0);
|
|
Sfile_scale((double) xorriso->temp_mem_limit, limit_text, 5,1e4, 0);
|
|
sprintf(xorriso->info_text,
|
|
"Stacked directory snapshots exceed -temp_mem_limit (%s > %s)",
|
|
mem_text, limit_text);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
*node_count= -1;
|
|
return(-1);
|
|
}
|
|
(*node_array)= (IsoNode **) calloc((*node_count)+1, sizeof(IsoNode *));
|
|
if(*node_array == NULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Could not allocate inode list of %.f bytes",
|
|
((double) (*node_count)+1) * (double) sizeof(IsoNode *));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
*node_count= -1;
|
|
return(-1);
|
|
}
|
|
*mem= new_mem;
|
|
ret= iso_dir_get_children(dir_node, iter);
|
|
if(ret<0)
|
|
goto cannot_iter;
|
|
while(iso_dir_iter_next(*iter, &node) == 1 && *node_idx < *node_count) {
|
|
(*node_array)[*node_idx]= node;
|
|
iso_node_ref(node);
|
|
(*node_idx)++;
|
|
}
|
|
iso_dir_iter_free(*iter);
|
|
*iter= NULL;
|
|
*node_count= *node_idx;
|
|
*node_idx= 0;
|
|
if((flag&4) && *node_count>1)
|
|
qsort(*node_array, *node_count, sizeof(IsoNode *),
|
|
Xorriso__node_lba_cmp);
|
|
}
|
|
}
|
|
|
|
if(flag&(1<<31)) {
|
|
if(*node_count>=0 && *node_array!=NULL) {
|
|
for(i= 0; i<*node_count; i++)
|
|
iso_node_unref((*node_array)[i]);
|
|
free(*node_array);
|
|
*node_array= NULL;
|
|
*node_count= -1;
|
|
*node_idx= 0;
|
|
} else {
|
|
if(*iter!=NULL)
|
|
iso_dir_iter_free(*iter);
|
|
*iter= NULL;
|
|
}
|
|
}
|
|
|
|
if(flag&(1|(1<<31)))
|
|
return(1);
|
|
if(*node_count>=0) {
|
|
/* return next node_array element */
|
|
if(*node_idx>=*node_count)
|
|
return(0);
|
|
*iterated_node= (*node_array)[*node_idx];
|
|
(*node_idx)++;
|
|
} else {
|
|
ret= iso_dir_iter_next(*iter, iterated_node);
|
|
return(ret == 1);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param boss_iter 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
|
|
bit4= count deleted files in xorriso->pacifier_count
|
|
bit5= with bit0 only remove directory content, not the directory
|
|
bit6= do not delete eventually existing node from di_array
|
|
@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)
|
|
{
|
|
int ret, is_dir= 0, pl, not_removed= 0, fret;
|
|
IsoNode *victim_node, *node;
|
|
IsoDir *boss_node, *root_dir;
|
|
IsoDirIter *iter= NULL;
|
|
IsoImage *volume;
|
|
char *sub_name, *name;
|
|
char *sfe= NULL, *sub_path= NULL;
|
|
off_t mem;
|
|
IsoNode **node_array= NULL;
|
|
int node_count= 0, node_idx;
|
|
|
|
/* Avoiding large local memory objects in order to save stack space */
|
|
sfe= malloc(5*SfileadrL);
|
|
sub_path= malloc(2*SfileadrL);
|
|
if(sfe==NULL || sub_path==NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, &sfe, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
#ifndef Libisofs_iso_dir_iter_sufficienT
|
|
/* Ticket 127: A80301 - A80302
|
|
I do not not deem IsoDirIter safe for node list manipulations.
|
|
The parameter boss_iter once was intended to allow such but
|
|
has now been downgraded to a mere check for eventual programming bugs.
|
|
*/
|
|
if(boss_iter!=NULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Program error: Xorriso_rmi() was requested to delete iterated node %s",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
#endif /* Libisofs_iso_dir_iter_sufficienT */
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
if(Xorriso_much_too_long(xorriso, strlen(path), 0)<=0)
|
|
{ret= 0; goto ex;}
|
|
ret= Xorriso_node_from_path(xorriso, volume, path, &victim_node, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
root_dir= iso_image_get_root(volume);
|
|
if(((void *) root_dir) == ((void *) victim_node)) {
|
|
sprintf(xorriso->info_text, "May not delete root directory");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
|
|
if(LIBISO_ISDIR(victim_node))
|
|
is_dir= 1;
|
|
if(!is_dir) {
|
|
if(flag&2) { /* rmdir */
|
|
sprintf(xorriso->info_text, "%s in loaded ISO image is not a directory",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
} else {
|
|
if(flag&1) { /* rm -r */
|
|
if((xorriso->do_reassure==1 && !xorriso->request_not_to_ask) ||
|
|
(flag&32)) {
|
|
/* Iterate over subordinates and delete them */
|
|
mem= boss_mem;
|
|
|
|
ret= Xorriso_findi_iter(xorriso, (IsoDir *) victim_node, &mem,
|
|
&iter, &node_array, &node_count, &node_idx,
|
|
&node, 1|2);
|
|
if(ret<=0) {
|
|
cannot_create_iter:;
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
pl= strlen(path);
|
|
strcpy(sub_path, path);
|
|
if(pl==0 || sub_path[pl-1]!='/') {
|
|
sub_path[pl++]= '/';
|
|
sub_path[pl]= 0;
|
|
}
|
|
sub_name= sub_path+pl;
|
|
while(1) {
|
|
ret= Xorriso_findi_iter(xorriso, (IsoDir *) victim_node, &mem, &iter,
|
|
&node_array, &node_count, &node_idx, &node, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0 || xorriso->request_to_abort)
|
|
break;
|
|
name= (char *) iso_node_get_name(node);
|
|
if(Xorriso_much_too_long(xorriso, pl+1+strlen(name), 0)<=0)
|
|
{ret= 0; goto rm_r_problem_handler;}
|
|
strcpy(sub_name, name);
|
|
ret= Xorriso_rmi(xorriso, iter, mem, sub_path,
|
|
(flag & ( 1 | 2 | 8 | 16 | 64)) | 4);
|
|
if(ret==3 || ret<=0 || xorriso->request_to_abort) {
|
|
rm_r_problem_handler:;
|
|
not_removed= 1;
|
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
|
|
if(fret<0)
|
|
goto dir_not_removed;
|
|
}
|
|
}
|
|
if(flag&32)
|
|
{ret= 2; goto ex;}
|
|
|
|
if(not_removed) {
|
|
dir_not_removed:;
|
|
sprintf(xorriso->info_text, "Directory not removed: %s",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
if(ret>0)
|
|
ret= 3;
|
|
goto ex;
|
|
}
|
|
}
|
|
} else {
|
|
if(!(flag&2)) { /* not rmdir */
|
|
sprintf(xorriso->info_text, "%s in loaded ISO image is a directory",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
ret= iso_dir_get_children((IsoDir *) victim_node, &iter);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret<0)
|
|
goto cannot_create_iter;
|
|
if(ret>0) {
|
|
if(iso_dir_iter_next(iter, &node) == 1) {
|
|
sprintf(xorriso->info_text,
|
|
"Directory not empty on attempt to delete: %s",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(xorriso->request_to_abort)
|
|
{ret= 3; goto ex;}
|
|
boss_node= iso_node_get_parent(victim_node);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(boss_node==NULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot find parent node of %s in loaded ISO image",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
while((xorriso->do_reassure==1 || (xorriso->do_reassure==2 && !(flag&4)))
|
|
&& !xorriso->request_not_to_ask) {
|
|
/* ls -ld */
|
|
Xorriso_ls_filev(xorriso, xorriso->wdi, 1, &path, (off_t) 0, 1|2|8);
|
|
if(is_dir) /* du -s */
|
|
Xorriso_ls_filev(xorriso, xorriso->wdi, 1, &path, (off_t) 0, 2|4);
|
|
if(flag&8)
|
|
sprintf(xorriso->info_text,
|
|
"File exists. Remove ? n= keep old, y= remove, x= abort, @= stop asking\n");
|
|
else
|
|
sprintf(xorriso->info_text,
|
|
"Remove above file ? n= keep it, y= remove it, x= abort, @= stop asking\n");
|
|
Xorriso_info(xorriso, 4);
|
|
ret= Xorriso_request_confirmation(xorriso, 1|2|4|16);
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(xorriso->request_to_abort) {
|
|
sprintf(xorriso->info_text,
|
|
"Removal operation aborted by user before file: %s",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= 3; goto ex;
|
|
}
|
|
if(ret==3)
|
|
continue;
|
|
if(ret==6) /* yes */
|
|
break;
|
|
if(ret==4) { /* yes, do not ask again */
|
|
xorriso->request_not_to_ask= 1;
|
|
break;
|
|
}
|
|
if(ret==1) { /* no */
|
|
sprintf(xorriso->info_text, "Kept in existing state: %s",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= 3; goto ex;
|
|
}
|
|
}
|
|
|
|
if(!(flag & 64))
|
|
Xorriso_invalidate_di_item(xorriso, victim_node, 0);
|
|
|
|
#ifdef Libisofs_iso_dir_iter_sufficienT
|
|
|
|
if(boss_iter!=NULL) {
|
|
ret= iso_dir_iter_remove((IsoDirIter *) boss_iter);
|
|
if(ret<0)
|
|
ret= -1;
|
|
} else
|
|
ret= iso_node_remove(victim_node);
|
|
|
|
#else /* ! Libisofs_iso_dir_iter_sufficienT */
|
|
|
|
ret= iso_node_remove(victim_node);
|
|
|
|
#endif /* Libisofs_iso_dir_iter_sufficienT */
|
|
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret<0) {
|
|
Xorriso_report_iso_error(xorriso, path, ret, "Cannot remove node", 0,
|
|
"FATAL", 1);
|
|
sprintf(xorriso->info_text,
|
|
"Internal failure to remove %s from loaded ISO image",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
|
|
if(flag&16)
|
|
xorriso->pacifier_count++;
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
ret= 1+!!is_dir;
|
|
ex:;
|
|
if(sfe!=NULL)
|
|
free(sfe);
|
|
if(sub_path!=NULL)
|
|
free(sub_path);
|
|
Xorriso_findi_iter(xorriso, (IsoDir *) victim_node, &mem, &iter,
|
|
&node_array, &node_count, &node_idx, &node, (1<<31));
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso__node_name_cmp(const void *node1, const void *node2)
|
|
{
|
|
char *name1, *name2;
|
|
|
|
name1= (char *) iso_node_get_name(*((IsoNode **) node1));
|
|
name2= (char *) iso_node_get_name(*((IsoNode **) node2));
|
|
return(strcmp(name1,name2));
|
|
}
|
|
|
|
|
|
/* @param flag bit0= only accept directory nodes
|
|
bit1= do not report memory usage as DEBUG
|
|
bit2= do not apply search pattern but accept any node
|
|
*/
|
|
int Xorriso_sorted_node_array(struct XorrisO *xorriso,
|
|
IsoDir *dir_node,
|
|
int *nodec, IsoNode ***node_array,
|
|
off_t boss_mem, int flag)
|
|
{
|
|
int i, ret, failed_at;
|
|
char *npt;
|
|
IsoDirIter *iter= NULL;
|
|
IsoNode *node;
|
|
off_t mem;
|
|
|
|
mem= ((*nodec)+1)*sizeof(IsoNode *);
|
|
ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, flag&2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
*node_array= calloc(sizeof(IsoNode *), (*nodec)+1);
|
|
if(*node_array==NULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot allocate memory for %d directory entries", *nodec);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0) {
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
return(-1);
|
|
}
|
|
|
|
for(i= 0; iso_dir_iter_next(iter, &node) == 1 && i<*nodec; ) {
|
|
npt= (char *) iso_node_get_name(node);
|
|
if(!(flag&4)) {
|
|
ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
|
|
if(ret)
|
|
continue; /* no match */
|
|
}
|
|
if(flag&1)
|
|
if(!LIBISO_ISDIR(node))
|
|
continue;
|
|
(*node_array)[i++]= node;
|
|
}
|
|
iso_dir_iter_free(iter);
|
|
*nodec= i;
|
|
if(*nodec<=0)
|
|
return(1);
|
|
qsort(*node_array, *nodec, sizeof(IsoNode *), Xorriso__node_name_cmp);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not only sum up sizes but also print subdirs
|
|
*/
|
|
int Xorriso_show_du_subs(struct XorrisO *xorriso, IsoDir *dir_node,
|
|
char *abs_path, char *rel_path, off_t *size,
|
|
off_t boss_mem, int flag)
|
|
{
|
|
int i, ret, no_sort= 0, filec= 0, l;
|
|
IsoDirIter *iter= NULL;
|
|
IsoNode *node, **node_array= NULL;
|
|
char *name;
|
|
off_t sub_size, report_size, mem= 0;
|
|
char *path= NULL, *show_path= NULL, *sfe= NULL;
|
|
|
|
sfe= malloc(5*SfileadrL);
|
|
path= malloc(SfileadrL);
|
|
show_path= malloc(SfileadrL);
|
|
if(path==NULL || show_path==NULL || sfe==NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, &sfe, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
*size= 0;
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0) {
|
|
cannot_create_iter:;
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
for(i= 0; iso_dir_iter_next(iter, &node) == 1; ) {
|
|
sub_size= 0;
|
|
name= (char *) iso_node_get_name(node);
|
|
strcpy(show_path, rel_path);
|
|
if(Sfile_add_to_path(show_path, name, 0)<=0)
|
|
goto much_too_long;
|
|
if(LIBISO_ISDIR(node)) {
|
|
strcpy(path, abs_path);
|
|
if(Sfile_add_to_path(path, name, 0)<=0) {
|
|
much_too_long:;
|
|
Xorriso_much_too_long(xorriso, strlen(path)+strlen(name)+1, 2);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
filec++;
|
|
l= strlen(rel_path)+1;
|
|
mem+= l;
|
|
if(l % sizeof(char *))
|
|
mem+= sizeof(char *)-(l % sizeof(char *));
|
|
if(flag&1) /* diving and counting is done further below */
|
|
continue;
|
|
ret= Xorriso_show_du_subs(xorriso, (IsoDir *) node,
|
|
path, show_path, &sub_size, boss_mem, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0)
|
|
continue;
|
|
}
|
|
|
|
if(LIBISO_ISREG(node)) {
|
|
sub_size+= iso_file_get_size((IsoFile *) node)+2048;
|
|
/*
|
|
sub_size+= iso_file_get_size((IsoFile *) node)+strlen(name)+1;
|
|
*/
|
|
}
|
|
|
|
if(sub_size>0)
|
|
(*size)+= sub_size;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
}
|
|
|
|
if(filec<=0 || !(flag&1))
|
|
{ret= 1; goto ex;}
|
|
|
|
/* Reset iteration */
|
|
iso_dir_iter_free(iter);
|
|
iter= NULL;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
ret= Xorriso_sorted_node_array(xorriso, dir_node, &filec, &node_array,
|
|
boss_mem, 1|2|4);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0) {
|
|
no_sort= 1;
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0)
|
|
goto cannot_create_iter;
|
|
}
|
|
|
|
for(i= 0; (no_sort || i<filec) && !(xorriso->request_to_abort); i++) {
|
|
if(no_sort) {
|
|
ret= iso_dir_iter_next(iter, &node);
|
|
if(ret!=1)
|
|
break;
|
|
if(!LIBISO_ISDIR(node))
|
|
continue;
|
|
} else
|
|
node= node_array[i];
|
|
|
|
sub_size= 0;
|
|
name= (char *) iso_node_get_name(node);
|
|
strcpy(show_path, rel_path);
|
|
if(Sfile_add_to_path(show_path, name, 0)<=0)
|
|
goto much_too_long;
|
|
strcpy(path, abs_path);
|
|
if(Sfile_add_to_path(path, name, 0)<=0)
|
|
goto much_too_long;
|
|
ret= Xorriso_show_du_subs(xorriso, (IsoDir *) node,
|
|
path, show_path, &sub_size, boss_mem+mem, flag&1);
|
|
if(ret<0)
|
|
goto ex;
|
|
|
|
if(LIBISO_ISREG(node)) {
|
|
sub_size+= iso_file_get_size((IsoFile *) node)+2048;
|
|
/*
|
|
sub_size+= iso_tree_node_get_size((IsoFile *) node)+strlen(name)+1;
|
|
*/
|
|
}
|
|
if(sub_size>0)
|
|
(*size)+= sub_size;
|
|
report_size= sub_size/1024;
|
|
if(report_size*1024<sub_size)
|
|
report_size++;
|
|
sprintf(xorriso->result_line, "%7.f ",(double) (report_size));
|
|
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
|
|
Text_shellsafe(show_path, sfe, 0));
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(sfe!=NULL)
|
|
free(sfe);
|
|
if(path!=NULL)
|
|
free(path);
|
|
if(show_path!=NULL)
|
|
free(show_path);
|
|
if(iter!=NULL)
|
|
iso_dir_iter_free(iter);
|
|
if(node_array!=NULL)
|
|
free((char *) node_array);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_sorted_dir_i(struct XorrisO *xorriso, IsoDir *dir_node,
|
|
int *filec, char ***filev, off_t boss_mem, int flag)
|
|
{
|
|
int i,j,ret;
|
|
IsoDirIter *iter= NULL;
|
|
IsoNode *node;
|
|
char *name;
|
|
off_t mem;
|
|
|
|
(*filec)= 0;
|
|
(*filev)= NULL;
|
|
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0) {
|
|
cannot_iter:;
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
mem= 0;
|
|
for(i= 0; iso_dir_iter_next(iter, &node) == 1; ) {
|
|
name= (char *) iso_node_get_name(node);
|
|
mem+= sizeof(char *)+strlen(name)+8;
|
|
(*filec)++;
|
|
}
|
|
iso_dir_iter_free(iter);
|
|
iter= NULL;
|
|
if(*filec==0)
|
|
{ret= 1; goto ex;}
|
|
|
|
ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, 2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
(*filev)= (char **) calloc(*filec, sizeof(char *));
|
|
if(*filev==NULL)
|
|
{ret= -1; goto ex; }
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0)
|
|
goto cannot_iter;
|
|
for(i= 0; i<*filec; i++) {
|
|
ret= iso_dir_iter_next(iter, &node);
|
|
if(ret!=1)
|
|
break;
|
|
name= (char *) iso_node_get_name(node);
|
|
(*filev)[i]= strdup(name);
|
|
if((*filev)[i]==NULL) {
|
|
for(j= 0; j<i; j++)
|
|
if((*filev)[j]!=NULL)
|
|
free((*filev)[j]);
|
|
free((char *) (*filev));
|
|
ret= -1; goto ex;
|
|
}
|
|
}
|
|
Sort_argv(*filec, *filev, 0);
|
|
ret= 1;
|
|
ex:;
|
|
if(iter!=NULL)
|
|
iso_dir_iter_free(iter);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @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)
|
|
{
|
|
int i, ret, was_error= 0, dfilec= 0, pass, passes;
|
|
IsoNode *node;
|
|
IsoImage *volume;
|
|
char sfe[5*SfileadrL], sfe2[5*SfileadrL], path[SfileadrL];
|
|
char link_target[SfileadrL], *rpt, **dfilev= NULL;
|
|
char *a_text= NULL, *d_text= NULL;
|
|
off_t size;
|
|
struct stat stbuf;
|
|
|
|
rpt= xorriso->result_line;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
Sort_argv(filec, filev, 0);
|
|
|
|
/* Count valid nodes, warn of invalid ones */
|
|
for(i= 0; i<filec; i++) {
|
|
ret= Xorriso_make_abs_adr(xorriso, wd, filev[i], path, 1|2|4);
|
|
if(ret<=0) {
|
|
was_error++;
|
|
continue;
|
|
}
|
|
ret= Xorriso_node_from_path(xorriso, volume, path, &node, 1);
|
|
if(ret<=0) {
|
|
sprintf(xorriso->info_text, "Not found in ISO image: %s",
|
|
Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
was_error++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if((flag&8) && !(flag&(2|4))) {
|
|
sprintf(xorriso->info_text, "Valid ISO nodes found: %d\n", filec-was_error);
|
|
Xorriso_info(xorriso,1);
|
|
if(filec-was_error<=0)
|
|
return(!was_error);
|
|
}
|
|
|
|
passes= 1+!(flag&(4|8));
|
|
for(pass= 0; pass<passes; pass++)
|
|
for(i= 0; i<filec && !(xorriso->request_to_abort); i++) {
|
|
rpt[0]= 0;
|
|
ret= Xorriso_make_abs_adr(xorriso, wd, filev[i], path, 1|2|4);
|
|
if(ret<=0)
|
|
continue;
|
|
ret= Xorriso_fake_stbuf(xorriso, path, &stbuf, &node, ((flag&4) >> 1) | 16);
|
|
if(ret<=0)
|
|
continue;
|
|
if(LIBISO_ISDIR(node) && !(flag&(4|8))) {
|
|
if(pass==0)
|
|
continue;
|
|
if(filec>1) {
|
|
strcpy(xorriso->result_line, "\n");
|
|
Xorriso_result(xorriso,0);
|
|
sprintf(xorriso->result_line, "%s:\n", Text_shellsafe(filev[i], sfe,0));
|
|
Xorriso_result(xorriso,0);
|
|
}
|
|
ret= Xorriso_sorted_dir_i(xorriso,
|
|
(IsoDir *) node, &dfilec, &dfilev, boss_mem, 0);
|
|
if(ret<=0) {
|
|
|
|
/* >>> libisofs iterator loop and single item Xorriso_lsx_filev() */;
|
|
|
|
} else {
|
|
if(flag&1) {
|
|
sprintf(xorriso->result_line, "total %d\n", dfilec);
|
|
Xorriso_result(xorriso,0);
|
|
}
|
|
Xorriso_ls_filev(xorriso, path,
|
|
dfilec, dfilev, boss_mem, (flag&1)|2|8);
|
|
}
|
|
if(dfilec>0)
|
|
Sfile_destroy_argv(&dfilec, &dfilev, 0);
|
|
continue;
|
|
} else
|
|
if(pass>0)
|
|
continue;
|
|
link_target[0]= 0;
|
|
if((flag&5)==1) { /* -ls_l */
|
|
iso_node_get_acl_text(node, &a_text, &d_text, 16);
|
|
ret= Xorriso_format_ls_l(xorriso, &stbuf,
|
|
1 | ((a_text != NULL || d_text != NULL) << 1));
|
|
iso_node_get_acl_text(node, &a_text, &d_text, 1 << 15);
|
|
if(ret<=0)
|
|
continue;
|
|
if(LIBISO_ISLNK(node)) {
|
|
if(Sfile_str(link_target, (char *) iso_symlink_get_dest(
|
|
(IsoSymlink *) node), 0)<=0)
|
|
link_target[0]= 0;
|
|
}
|
|
} else if(flag&4) { /* -du or -dus */
|
|
size= stbuf.st_size;
|
|
if(S_ISDIR(stbuf.st_mode)) {
|
|
ret= Xorriso_show_du_subs(xorriso, (IsoDir *) node,
|
|
path, filev[i], &size, boss_mem, flag&1);
|
|
if(ret<0)
|
|
return(-1);
|
|
if(ret==0)
|
|
continue;
|
|
}
|
|
sprintf(rpt, "%7.f ",(double) (size/1024));
|
|
}
|
|
if(link_target[0] && (flag&5)==1)
|
|
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s -> %s\n",
|
|
Text_shellsafe(filev[i], sfe, 0),
|
|
Text_shellsafe(link_target, sfe2, 0));
|
|
else
|
|
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
|
|
Text_shellsafe(filev[i], sfe, 0));
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
return(!was_error);
|
|
}
|
|
|
|
|
|
/* This function needs less buffer memory than Xorriso_ls_filev() but cannot
|
|
perform structured pattern matching as done by Xorriso_expand_pattern()
|
|
for subsequent Xorriso_ls_filev().
|
|
@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)
|
|
{
|
|
int ret, is_dir= 0, i, filec= 0, failed_at, no_sort= 0;
|
|
IsoNode *node, **node_array= NULL;
|
|
IsoDir *dir_node;
|
|
IsoImage *volume;
|
|
IsoDirIter *iter= NULL;
|
|
char sfe[5*SfileadrL], sfe2[5*SfileadrL], link_target[SfileadrL], *npt, *rpt;
|
|
struct stat stbuf;
|
|
|
|
rpt= xorriso->result_line;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
ret= Xorriso_node_from_path(xorriso, volume, xorriso->wdi, &node, 0);
|
|
if(ret<=0)
|
|
goto wdi_is_not_a_dir;
|
|
if(LIBISO_ISDIR(node))
|
|
is_dir= 1;
|
|
if(!is_dir) {
|
|
wdi_is_not_a_dir:;
|
|
sprintf(xorriso->info_text,
|
|
"Working directory path does not lead to a directory in ISO image");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(flag&2)
|
|
{ret= 1; goto ex;}
|
|
|
|
dir_node= (IsoDir *) node;
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0) {
|
|
cannot_create_iter:;
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
for(i= 0; iso_dir_iter_next(iter, &node) == 1; ) {
|
|
npt= (char *) iso_node_get_name(node);
|
|
if(!(flag&4)) {
|
|
ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
|
|
if(ret)
|
|
continue; /* no match */
|
|
}
|
|
filec++;
|
|
}
|
|
/* Reset iteration */
|
|
iso_dir_iter_free(iter);
|
|
iter= NULL;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(flag&8)
|
|
{ret= filec; goto ex;}
|
|
sprintf(xorriso->info_text, "Valid ISO nodes found: %d\n", filec);
|
|
Xorriso_info(xorriso,1);
|
|
|
|
ret= Xorriso_sorted_node_array(xorriso, dir_node, &filec, &node_array, 0,
|
|
flag&4);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0) {
|
|
no_sort= 1;
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0)
|
|
goto cannot_create_iter;
|
|
}
|
|
|
|
for(i= 0; i<filec && !(xorriso->request_to_abort); i++) {
|
|
if(no_sort) {
|
|
ret= iso_dir_iter_next(iter, &node);
|
|
if(ret!=1)
|
|
break;
|
|
npt= (char *) iso_node_get_name(node);
|
|
if(!(flag&4)) {
|
|
ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
|
|
if(ret)
|
|
continue; /* no match */
|
|
}
|
|
} else
|
|
node= node_array[i];
|
|
|
|
npt= (char *) iso_node_get_name(node);
|
|
link_target[0]= 0;
|
|
if(LIBISO_ISLNK(node)) {
|
|
if(Sfile_str(link_target, (char *) iso_symlink_get_dest(
|
|
(IsoSymlink *) node), 0)<=0)
|
|
link_target[0]= 0;
|
|
}
|
|
rpt[0]= 0;
|
|
if(flag&1) {
|
|
ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
|
|
if(ret<=0)
|
|
continue;
|
|
ret= Xorriso_format_ls_l(xorriso, &stbuf, 1);
|
|
if(ret<=0)
|
|
continue;
|
|
}
|
|
if(link_target[0] && (flag&1))
|
|
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s -> %s\n",
|
|
Text_shellsafe(npt, sfe, 0),
|
|
Text_shellsafe(link_target, sfe2, 0));
|
|
else
|
|
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
|
|
Text_shellsafe(npt, sfe, 0));
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(iter!=NULL)
|
|
iso_dir_iter_free(iter);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(node_array!=NULL)
|
|
free((char *) node_array);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @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)
|
|
{
|
|
int ret, ol, dest_ret;
|
|
char sfe[5*SfileadrL], eff_dest[SfileadrL], dir_adr[SfileadrL], *cpt;
|
|
char *leafname, eff_origin[SfileadrL], sfe2[5*SfileadrL], *old_leafname;
|
|
IsoImage *volume;
|
|
IsoDir *origin_dir, *dest_dir;
|
|
IsoNode *node, *iso_node;
|
|
|
|
#ifndef Libisofs_iso_dir_iter_sufficienT
|
|
/* Ticket 127: A80301 - A80302
|
|
I do not not deem IsoDirIter safe for node list manipulations.
|
|
The parameter boss_iter once was intended to allow such but
|
|
has now been downgraded to a mere check for eventual programming bugs.
|
|
*/
|
|
if(boss_iter!=NULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Program error: Xorriso_rename() was requested to delete iterated node %s",
|
|
Text_shellsafe(origin, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
#endif /* Libisofs_iso_dir_iter_sufficienT */
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, origin, eff_origin, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
dest_ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest,1);
|
|
if(dest_ret<0)
|
|
return(dest_ret);
|
|
if(dest_ret==0) { /* obtain eff_dest address despite it does not exist */
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest, 2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
|
|
/* Prevent that destination is a subordinate of origin
|
|
(that would be a black hole plopping out of the universe) */
|
|
ol= strlen(eff_origin);
|
|
if(ol==0) {
|
|
sprintf(xorriso->info_text, "May not rename root directory");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
} else if(strcmp(eff_origin, eff_dest)==0) {
|
|
sprintf(xorriso->info_text, "Ignored attempt to rename %s to itself",
|
|
Text_shellsafe(eff_origin,sfe,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
return(0);
|
|
} else if(strncmp(eff_origin, eff_dest, ol)==0 &&
|
|
(eff_dest[ol]==0 || eff_dest[ol]=='/')) {
|
|
sprintf(xorriso->info_text,
|
|
"May not rename %s to its own sub address %s",
|
|
Text_shellsafe(eff_origin,sfe,0), Text_shellsafe(eff_dest,sfe2,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
/* Check whether destination exists and may be not overwriteable */
|
|
if(dest_ret==2 && xorriso->do_overwrite!=1) {
|
|
sprintf(xorriso->info_text, "Renaming may not overwrite directory: %s",
|
|
Text_shellsafe(eff_dest, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
} else if (dest_ret==1 && !xorriso->do_overwrite) {
|
|
sprintf(xorriso->info_text, "Renaming may not overwite: %s",
|
|
Text_shellsafe(eff_dest, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
} else if(dest_ret>0) {
|
|
ret= Xorriso_rmi(xorriso, boss_iter, (off_t) 0, eff_dest, 1|8);
|
|
if(ret<=0)
|
|
return(0);
|
|
if(ret==3) {
|
|
sprintf(xorriso->info_text, "User revoked renaming of: %s",
|
|
Text_shellsafe(eff_origin, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
/* Ensure existence of destination directory */
|
|
strcpy(dir_adr, eff_dest);
|
|
cpt= strrchr(dir_adr, '/');
|
|
if(cpt==NULL)
|
|
cpt= dir_adr+strlen(dir_adr);
|
|
*cpt= 0;
|
|
if(dir_adr[0]!=0) {
|
|
ret= Xorriso_graft_in(xorriso, boss_iter, NULL, dir_adr,
|
|
(off_t) 0, (off_t) 0, 1);
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
|
|
/* Move node */
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
Xorriso_node_from_path(xorriso, volume, dir_adr, &iso_node, 0);
|
|
dest_dir= (IsoDir *) iso_node;
|
|
strcpy(dir_adr, eff_origin);
|
|
cpt= strrchr(dir_adr, '/');
|
|
if(cpt==NULL)
|
|
cpt= dir_adr+strlen(dir_adr);
|
|
*cpt= 0;
|
|
Xorriso_node_from_path(xorriso, volume, dir_adr, &iso_node, 0);
|
|
origin_dir= (IsoDir *) iso_node;
|
|
Xorriso_node_from_path(xorriso, volume, eff_origin, &node, 0);
|
|
if(dest_dir==NULL || origin_dir==NULL || node==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Internal error on rename: confirmed node turns out as NULL");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
ret= iso_node_take(node);
|
|
if(ret<0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, eff_dest, 0, "Cannot take", 0, "FATAL",1);
|
|
sprintf(xorriso->info_text,
|
|
"Internal error on rename: failed to take node");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
leafname= strrchr(eff_dest, '/');
|
|
if(leafname==NULL)
|
|
leafname= eff_dest;
|
|
else
|
|
leafname++;
|
|
|
|
old_leafname= (char *) iso_node_get_name(node);
|
|
if(strcmp(leafname, old_leafname)!=0)
|
|
ret= iso_node_set_name(node, leafname);
|
|
else
|
|
ret= 1;
|
|
if(ret<0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, eff_dest, 0, "Cannot set name", 0,
|
|
"FAILURE", 1);
|
|
return(-1);
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
ret= iso_dir_add_node(dest_dir, node, 0);
|
|
if(ret<0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, eff_dest, 0, "Cannot add", 0, "FATAL", 1);
|
|
sprintf(xorriso->info_text,
|
|
"Internal error on rename: failed to insert node");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(-1);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not produce info message on success
|
|
@return 1=success,
|
|
0=was already directory, -1=was other type, -2=other error
|
|
*/
|
|
int Xorriso_mkdir(struct XorrisO *xorriso, char *path, int flag)
|
|
{
|
|
int ret;
|
|
char eff_path[SfileadrL], sfe[5*SfileadrL];
|
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 1);
|
|
if(ret<0)
|
|
return(-2);
|
|
if(ret>0) {
|
|
sprintf(xorriso->info_text,"-mkdir: Address already existing %s",
|
|
Text_shellsafe(eff_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
|
|
(ret==2 ? "WARNING" : "FAILURE"), 0);
|
|
return(-1+(ret==2));
|
|
}
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 2);
|
|
if(ret<0)
|
|
return(-2);
|
|
ret= Xorriso_graft_in(xorriso, NULL, NULL, eff_path, (off_t) 0, (off_t) 0, 1);
|
|
if(ret<=0)
|
|
return(-2);
|
|
if(!(flag&1)) {
|
|
sprintf(xorriso->info_text, "Created directory in ISO image: %s\n",
|
|
Text_shellsafe(eff_path,sfe,0));
|
|
Xorriso_info(xorriso, 0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= count results rather than storing them
|
|
bit1= this is a recursion
|
|
bit2= prepend wd (automatically done if wd[0]!=0)
|
|
*/
|
|
int Xorriso_obtain_pattern_files_i(
|
|
struct XorrisO *xorriso, char *wd, IsoDir *dir,
|
|
int *filec, char **filev, int count_limit, off_t *mem,
|
|
int *dive_count, int flag)
|
|
{
|
|
int ret, failed_at;
|
|
IsoDirIter *iter= NULL;
|
|
IsoNode *node;
|
|
char *name;
|
|
char *adr= NULL;
|
|
|
|
adr= malloc(SfileadrL);
|
|
if(adr==NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, &adr, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
if(!(flag&2))
|
|
*dive_count= 0;
|
|
else
|
|
(*dive_count)++;
|
|
ret= Xorriso_check_for_root_pattern(xorriso, filec, filev, count_limit,
|
|
mem, (flag&1)|2);
|
|
if(ret!=2)
|
|
goto ex;
|
|
|
|
ret= iso_dir_get_children(dir, &iter);
|
|
if(ret<0) {
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
while(iso_dir_iter_next(iter, &node) == 1) {
|
|
name= (char *) iso_node_get_name(node);
|
|
ret= Xorriso_make_abs_adr(xorriso, wd, name, adr, flag&4);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= Xorriso_regexec(xorriso, adr, &failed_at, 1);
|
|
if(ret) { /* no match */
|
|
if(failed_at <= *dive_count) /* no hope for a match */
|
|
continue;
|
|
|
|
if(!LIBISO_ISDIR(node)) {
|
|
|
|
/* >>> How to deal with softlinks ? */
|
|
|
|
continue;
|
|
}
|
|
/* dive deeper */
|
|
ret= Xorriso_obtain_pattern_files_i(
|
|
xorriso, adr, (IsoDir *) node,
|
|
filec, filev, count_limit, mem, dive_count, flag|2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
} else {
|
|
ret= Xorriso_register_matched_adr(xorriso, adr, count_limit,
|
|
filec, filev, mem, (flag&1)|2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(adr!=NULL)
|
|
free(adr);
|
|
if(flag&2)
|
|
(*dive_count)--;
|
|
if(iter != NULL)
|
|
iso_dir_iter_free(iter);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= a match count !=1 is a FAILURE event
|
|
bit1= with bit0 tolerate 0 matches if pattern is a constant
|
|
*/
|
|
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 ret, count= 0, abs_adr= 0, i, was_count, was_filec;
|
|
int nonconst_mismatches= 0, dive_count= 0;
|
|
char sfe[5*SfileadrL];
|
|
IsoImage *volume;
|
|
IsoDir *dir= NULL, *root_dir;
|
|
IsoNode *iso_node;
|
|
|
|
*filec= 0;
|
|
*filev= NULL;
|
|
|
|
xorriso->search_mode= 3;
|
|
xorriso->structured_search= 1;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
root_dir= iso_image_get_root(volume);
|
|
if(root_dir==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"While expanding pattern : Cannot obtain root node of ISO image");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
|
|
for(i= 0; i<num_patterns; i++) {
|
|
ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(ret==2)
|
|
abs_adr= 4;
|
|
if(patterns[i][0]=='/' || abs_adr) {
|
|
dir= root_dir;
|
|
abs_adr= 4;
|
|
} else {
|
|
/* This is done so late to allow the following:
|
|
It is not an error if xorriso->wdi does not exist yet, but one may
|
|
not use it as base for relative address searches.
|
|
*/
|
|
ret= Xorriso_node_from_path(xorriso, volume, xorriso->wdi, &iso_node, 1);
|
|
dir= (IsoDir *) iso_node;
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"While expanding pattern %s : Working directory does not exist in ISO image",
|
|
Text_shellsafe(patterns[i], sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(!LIBISO_ISDIR((IsoNode *) dir)) {
|
|
sprintf(xorriso->info_text,
|
|
"Working directory path does not lead to a directory in ISO image");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
}
|
|
|
|
/* count the matches */
|
|
was_count= count;
|
|
ret= Xorriso_obtain_pattern_files_i(xorriso, "", dir, &count, NULL, 0,
|
|
mem, &dive_count, 1 | abs_adr);
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(was_count==count && strcmp(patterns[i],"*")!=0 && (flag&3)!=1) {
|
|
count++;
|
|
Xorriso_eval_nonmatch(xorriso, patterns[i], &nonconst_mismatches, mem, 0);
|
|
}
|
|
}
|
|
|
|
ret= Xorriso_check_matchcount(xorriso, count, nonconst_mismatches,
|
|
num_patterns, patterns, (flag&1)|2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
count+= extra_filec;
|
|
mem+= extra_filec*sizeof(char *);
|
|
if(count<=0)
|
|
{ret= 0; goto ex;}
|
|
ret= Xorriso_alloc_pattern_mem(xorriso, *mem, count, filev, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
/* now store addresses */
|
|
for(i= 0; i<num_patterns; i++) {
|
|
ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(ret==2)
|
|
abs_adr= 4;
|
|
|
|
was_filec= *filec;
|
|
ret= Xorriso_obtain_pattern_files_i(xorriso, "", dir, filec, *filev, count,
|
|
mem, &dive_count, abs_adr);
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(was_filec == *filec && strcmp(patterns[i],"*")!=0) {
|
|
(*filev)[*filec]= strdup(patterns[i]);
|
|
if((*filev)[*filec]==NULL) {
|
|
(*mem)= strlen(patterns[i])+1;
|
|
Xorriso_no_pattern_memory(xorriso, *mem, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
(*filec)++;
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(ret<=0) {
|
|
if(filev!=NULL)
|
|
Sfile_destroy_argv(&count, filev, 0);
|
|
*filec= 0;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_set_st_mode(struct XorrisO *xorriso, char *in_path,
|
|
mode_t mode_and, mode_t mode_or, int flag)
|
|
{
|
|
mode_t mode= 0;
|
|
int ret;
|
|
IsoNode *node;
|
|
char sfe[5*SfileadrL], path[SfileadrL];
|
|
|
|
ret= Xorriso_get_node_by_path(xorriso, in_path, path, &node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
mode= iso_node_get_permissions(node);
|
|
mode= (mode & mode_and) | mode_or;
|
|
iso_node_set_permissions(node, mode);
|
|
iso_node_set_ctime(node, time(NULL));
|
|
sprintf(xorriso->info_text,"Permissions now: %-5.5o %s",
|
|
(unsigned int) (mode & 0xffff), Text_shellsafe(path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_set_uid(struct XorrisO *xorriso, char *in_path, uid_t uid,
|
|
int flag)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
|
|
ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
iso_node_set_uid(node, uid);
|
|
iso_node_set_ctime(node, time(NULL));
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_set_gid(struct XorrisO *xorriso, char *in_path, gid_t gid,
|
|
int flag)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
|
|
ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
iso_node_set_gid(node, gid);
|
|
iso_node_set_ctime(node, time(NULL));
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @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)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
|
|
ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(flag&1)
|
|
iso_node_set_atime(node, t);
|
|
if(flag&2)
|
|
iso_node_set_ctime(node, t);
|
|
if(flag&4)
|
|
iso_node_set_mtime(node, t);
|
|
if(!(flag&(2|256)))
|
|
iso_node_set_ctime(node, time(NULL));
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso__start_end_lbas(IsoNode *node,
|
|
int *lba_count, int **start_lbas, int **end_lbas,
|
|
off_t *size, int flag)
|
|
{
|
|
int section_count= 0, ret, i;
|
|
struct iso_file_section *sections= NULL;
|
|
|
|
*lba_count= 0;
|
|
*start_lbas= *end_lbas= NULL;
|
|
*size= 0;
|
|
if(!LIBISO_ISREG(node))
|
|
return(0);
|
|
*size= iso_file_get_size((IsoFile *) node);
|
|
ret= iso_file_get_old_image_sections((IsoFile *) node, §ion_count,
|
|
§ions, 0);
|
|
if(ret < 0)
|
|
{ret= -1; goto ex;}
|
|
if(ret != 1 || section_count <= 0)
|
|
{ret= 0; goto ex;}
|
|
*start_lbas= calloc(section_count, sizeof(int));
|
|
*end_lbas= calloc(section_count, sizeof(int));
|
|
if(*start_lbas == NULL || *end_lbas == NULL)
|
|
{ret= -1; goto ex;}
|
|
for(i= 0; i < section_count; i++) {
|
|
(*start_lbas)[i]= sections[i].block;
|
|
(*end_lbas)[i]= sections[i].block + sections[i].size / 2048 - 1;
|
|
if(sections[i].size % 2048)
|
|
(*end_lbas)[i]++;
|
|
}
|
|
*lba_count= section_count;
|
|
ret= 1;
|
|
ex:;
|
|
if(sections != NULL)
|
|
free((char *) sections);
|
|
if(ret <= 0) {
|
|
if((*start_lbas) != NULL)
|
|
free((char *) *start_lbas);
|
|
if((*end_lbas) != NULL)
|
|
free((char *) *end_lbas);
|
|
*start_lbas= *end_lbas= NULL;
|
|
*lba_count= 0;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso__file_start_lba(IsoNode *node,
|
|
int *lba, int flag)
|
|
{
|
|
int *start_lbas= NULL, *end_lbas= NULL, lba_count= 0, i, ret;
|
|
off_t size;
|
|
|
|
*lba= -1;
|
|
ret= Xorriso__start_end_lbas(node, &lba_count, &start_lbas, &end_lbas,
|
|
&size, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
for(i= 0; i < lba_count; i++) {
|
|
if(*lba < 0 || start_lbas[i] < *lba)
|
|
*lba= start_lbas[i];
|
|
}
|
|
if(start_lbas != NULL)
|
|
free((char *) start_lbas);
|
|
if(end_lbas != NULL)
|
|
free((char *) end_lbas);
|
|
if(*lba < 0)
|
|
return(0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param damage_start Returns first damaged byte address
|
|
@param damage_end Returns first byte address after last damaged byte
|
|
@return <0 error, 0=undamaged , 1=damaged
|
|
*/
|
|
int Xorriso_file_eval_damage(struct XorrisO *xorriso, IsoNode *node,
|
|
off_t *damage_start, off_t *damage_end,
|
|
int flag)
|
|
{
|
|
int *start_lbas= NULL, *end_lbas= NULL, lba_count= 0, sect;
|
|
int i, sectors, sector_size, ret;
|
|
off_t sect_base= 0, size= 0, byte;
|
|
struct SectorbitmaP *map;
|
|
|
|
*damage_start= *damage_end= -1;
|
|
map= xorriso->in_sector_map;
|
|
if(map == NULL)
|
|
return(0);
|
|
Sectorbitmap_get_layout(map, §ors, §or_size, 0);
|
|
sector_size/= 2048;
|
|
|
|
ret= Xorriso__start_end_lbas(node, &lba_count, &start_lbas, &end_lbas,
|
|
&size, 0);
|
|
if(ret <= 0) {
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
return(ret);
|
|
}
|
|
for(sect= 0; sect < lba_count; sect++) {
|
|
for(i= start_lbas[sect]; i <= end_lbas[sect]; i+= sector_size) {
|
|
if(Sectorbitmap_is_set(map, i / sector_size, 0) == 0) {
|
|
byte= ((off_t) 2048) * ((off_t) (i - start_lbas[sect])) + sect_base;
|
|
if(*damage_start < 0 || byte < *damage_start)
|
|
*damage_start= byte;
|
|
if(byte + (off_t) 2048 > *damage_end)
|
|
*damage_end= byte + (off_t) 2048;
|
|
}
|
|
}
|
|
sect_base+= ((off_t) 2048) *
|
|
((off_t) (end_lbas[sect] - start_lbas[sect] + 1));
|
|
}
|
|
if(*damage_end > size)
|
|
*damage_end= size;
|
|
if(start_lbas != NULL)
|
|
free((char *) start_lbas);
|
|
if(end_lbas != NULL)
|
|
free((char *) end_lbas);
|
|
if(*damage_start < 0)
|
|
return(0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_report_lba(struct XorrisO *xorriso, char *show_path,
|
|
IsoNode *node, int flag)
|
|
{
|
|
int ret, *start_lbas= NULL, *end_lbas= NULL, lba_count, i;
|
|
off_t size;
|
|
char sfe[5*SfileadrL];
|
|
|
|
ret= Xorriso__start_end_lbas(node, &lba_count, &start_lbas, &end_lbas,
|
|
&size, 0);
|
|
if(ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
if(ret == 0)
|
|
{ret= 1; goto ex;} /* it is ok to ignore other types */
|
|
for(i= 0; i < lba_count; i++) {
|
|
sprintf(xorriso->result_line,
|
|
"File data lba: %2d , %8d , %8d , %8.f , %s\n",
|
|
i, start_lbas[i], end_lbas[i] + 1 - start_lbas[i], (double) size,
|
|
Text_shellsafe(show_path, sfe, 0));
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(start_lbas != NULL)
|
|
free((char *) start_lbas);
|
|
if(end_lbas != NULL)
|
|
free((char *) end_lbas);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_report_damage(struct XorrisO *xorriso, char *show_path,
|
|
IsoNode *node, int flag)
|
|
{
|
|
int ret;
|
|
off_t size= 0, damage_start, damage_end;
|
|
char sfe[5*SfileadrL];
|
|
|
|
ret= Xorriso_file_eval_damage(xorriso, node, &damage_start, &damage_end, 0);
|
|
if(ret < 0)
|
|
return(0);
|
|
|
|
if(LIBISO_ISREG(node))
|
|
size= iso_file_get_size((IsoFile *) node);
|
|
if(ret > 0) {
|
|
sprintf(xorriso->result_line, "File damaged : %8.f , %8.f , %8.f , %s\n",
|
|
(double) damage_start, (double) (damage_end - damage_start) ,
|
|
(double) size, Text_shellsafe(show_path, sfe, 0));
|
|
Xorriso_result(xorriso, 0);
|
|
} else {
|
|
sprintf(xorriso->result_line, "File seems ok: %8.f , %8.f , %8.f , %s\n",
|
|
-1.0, -1.0, (double) size, Text_shellsafe(show_path, sfe, 0));
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @return see Xorriso_update_interpreter()
|
|
*/
|
|
int Xorriso_widen_hardlink(struct XorrisO *xorriso, void * boss_iter,
|
|
IsoNode *node,
|
|
char *abs_path, char *iso_prefix, char *disk_prefix,
|
|
int flag)
|
|
{
|
|
int ret= 0, idx, low, high, i, do_widen= 0, compare_result= 0;
|
|
char disk_path[SfileadrL];
|
|
|
|
/* Lookup all di_array instances of node */
|
|
if(LIBISO_ISDIR(node))
|
|
return(1);
|
|
ret= Xorriso_search_di_range(xorriso, node, &idx, &low, &high, 2);
|
|
if(ret <= 0)
|
|
return(1);
|
|
/* Check and reset di_do_widen bits */
|
|
for(i= low; i <= high; i++) {
|
|
if(node != xorriso->di_array[i]) /* might be NULL */
|
|
continue;
|
|
if(xorriso->di_do_widen[i / 8] & (1 << (i % 8)))
|
|
do_widen= 1;
|
|
xorriso->di_do_widen[i / 8]&= ~(1 << (i % 8));
|
|
}
|
|
if(idx < 0 || !do_widen)
|
|
return(1);
|
|
|
|
ret= Xorriso_pfx_disk_path(xorriso, abs_path, iso_prefix, disk_prefix,
|
|
disk_path, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
|
|
/* >>> compare_result bit17 = is_split */;
|
|
|
|
ret= Xorriso_update_interpreter(xorriso, boss_iter, compare_result, disk_path,
|
|
abs_path, 1);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= not a command parameter (directory iteration or recursion)
|
|
bit1= do not count deleted files with rm and rm_r
|
|
@return <=0 error,
|
|
1=ok
|
|
2=ok, node has been deleted,
|
|
3=ok, do not dive into directory (e.g. because it is a split file)
|
|
*/
|
|
int Xorriso_findi_action(struct XorrisO *xorriso, struct FindjoB *job,
|
|
IsoDirIter *boss_iter, off_t boss_mem,
|
|
char *abs_path, char *show_path,
|
|
IsoNode *node, int depth, int flag)
|
|
{
|
|
int ret= 0, type, action= 0, hflag, deleted= 0, no_dive= 0;
|
|
uid_t user= 0;
|
|
gid_t group= 0;
|
|
time_t date= 0;
|
|
mode_t mode_or= 0, mode_and= ~1;
|
|
char *target, *text_2, sfe[5*SfileadrL], *iso_prefix, md5[16];
|
|
struct FindjoB *subjob;
|
|
struct stat dir_stbuf;
|
|
|
|
action= Findjob_get_action_parms(job, &target, &text_2, &user, &group,
|
|
&mode_and, &mode_or, &type, &date, &subjob, 0);
|
|
if(action<0)
|
|
action= 0;
|
|
|
|
hflag= 16*!(flag&2);
|
|
ret= 1;
|
|
if(action==1) { /* rm (including rmdir) */
|
|
ret= Xorriso_fake_stbuf(xorriso, abs_path, &dir_stbuf, &node, 1);
|
|
if(ret>0) {
|
|
if(S_ISDIR(dir_stbuf.st_mode))
|
|
hflag= 2;
|
|
ret= Xorriso_rmi(xorriso, boss_iter, boss_mem, abs_path, hflag);
|
|
deleted= 1;
|
|
}
|
|
} else if(action==2) { /* rm_r */
|
|
ret= Xorriso_rmi(xorriso, boss_iter, boss_mem, abs_path, 1|hflag);
|
|
deleted= 1;
|
|
} else if(action==3) {
|
|
|
|
/* >>> mv target */;
|
|
|
|
} else if(action==4) { /* chown */
|
|
ret= Xorriso_set_uid(xorriso, abs_path, user, 0);
|
|
} else if(action==5) { /* chgrp */
|
|
ret= Xorriso_set_gid(xorriso, abs_path, group, 0);
|
|
} else if(action==6) { /* chmod */
|
|
ret= Xorriso_set_st_mode(xorriso, abs_path, mode_and, mode_or, 0);
|
|
} else if(action==7) { /* alter_date */
|
|
ret= Xorriso_set_time(xorriso, abs_path, date, type&7);
|
|
} else if(action==8) { /* lsdl */
|
|
ret= Xorriso_ls_filev(xorriso, "", 1, &abs_path, (off_t) 0, 1|2|8);
|
|
} else if(action>=9 && action<=13) { /* actions which have own findjobs */
|
|
Findjob_set_start_path(subjob, abs_path, 0);
|
|
ret= Xorriso_findi(xorriso, subjob, boss_iter, boss_mem, NULL,
|
|
abs_path, &dir_stbuf, depth, 1);
|
|
} else if(action==14 || action==17) { /* compare , update */
|
|
Findjob_get_start_path(job, &iso_prefix, 0);
|
|
ret= Xorriso_find_compare(xorriso, (void *) boss_iter, abs_path,
|
|
iso_prefix, target, (action==17)|((flag&1)<<1));
|
|
if(ret==2)
|
|
deleted= 1;
|
|
if(ret==3)
|
|
no_dive= 1;
|
|
if(ret>=0)
|
|
ret= 1;
|
|
} else if(action==16 || action==18) { /* not_in_iso , add_missing */
|
|
;
|
|
} else if(action == 21) { /* report_damage */
|
|
ret= Xorriso_report_damage(xorriso, show_path, node, 0);
|
|
} else if(action == 22) {
|
|
ret= Xorriso_report_lba(xorriso, show_path, node, 0);
|
|
} else if(action == 23) { /* internal: memorize path of last matching node */
|
|
ret= Findjob_set_found_path(job, show_path, 0);
|
|
} else if(action == 24) {
|
|
ret= Xorriso_getfacl(xorriso, (void *) node, show_path, NULL, 0);
|
|
} else if(action == 25) {
|
|
if(target == NULL || target[0] || text_2 == NULL || text_2[0])
|
|
ret= Xorriso_setfacl(xorriso, (void *) node, show_path, target, text_2,0);
|
|
} else if(action == 26) {
|
|
ret= Xorriso_getfattr(xorriso, (void *) node, show_path, NULL, 0);
|
|
} else if(action == 27) {
|
|
ret= Xorriso_path_setfattr(xorriso, (void *) node, show_path,
|
|
target, strlen(text_2), text_2, 0);
|
|
} else if(action == 28) { /* set_filter */
|
|
ret= Xorriso_set_filter(xorriso, (void *) node, show_path, target, 1 | 2);
|
|
} else if(action == 29) { /* show_stream */
|
|
ret= Xorriso_show_stream(xorriso, (void *) node, show_path, 1 | 2);
|
|
} else if(action == 30) { /* internal: count */
|
|
xorriso->node_counter++;
|
|
} else if(action == 31) { /* internal: register */
|
|
if(xorriso->node_counter < xorriso->node_array_size) {
|
|
xorriso->node_array[xorriso->node_counter++]= (void *) node;
|
|
iso_node_ref(node); /* In case node gets deleted from tree during
|
|
the lifetime of xorriso->node_array */
|
|
}
|
|
} else if(action == 32) { /* internal: widen_hardlinks disk_equiv */
|
|
Findjob_get_start_path(job, &iso_prefix, 0);
|
|
ret= Xorriso_widen_hardlink(xorriso, (void *) boss_iter, node, abs_path,
|
|
iso_prefix, target, 0);
|
|
if(ret==2)
|
|
deleted= 1;
|
|
} else if(action == 33) { /* get_any_xattr */
|
|
ret= Xorriso_getfattr(xorriso, (void *) node, show_path, NULL, 8);
|
|
} else if(action == 34) { /* get_md5 */
|
|
ret= Xorriso_get_md5(xorriso, (void *) node, show_path, md5, 0);
|
|
if(ret >= 0)
|
|
ret= 1;
|
|
} else if(action == 35) { /* check_md5 */
|
|
ret= Xorriso_check_md5(xorriso, (void *) node, show_path, 2);
|
|
if(ret == 0)
|
|
xorriso->find_check_md5_result|= 1;
|
|
else if(ret < 0)
|
|
xorriso->find_check_md5_result|= 2;
|
|
else if(ret == 1)
|
|
xorriso->find_check_md5_result|= 8;
|
|
else if(ret == 2)
|
|
xorriso->find_check_md5_result|= 4;
|
|
if(ret >= 0)
|
|
ret= 1;
|
|
} else { /* includes : 15 in_iso */
|
|
sprintf(xorriso->result_line, "%s\n", Text_shellsafe(show_path, sfe, 0));
|
|
Xorriso_result(xorriso, 0);
|
|
ret= 1;
|
|
}
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(deleted)
|
|
return(2);
|
|
if(no_dive)
|
|
return(3);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Exprtest_match(struct XorrisO *xorriso, struct ExprtesT *ftest,
|
|
void *node_pt, char *name, char *path,
|
|
struct stat *boss_stbuf, struct stat *stbuf, int flag)
|
|
/*
|
|
return:
|
|
<0 = error
|
|
0 = does not match
|
|
1 = does match
|
|
2 = immediate decision : does not match
|
|
3 = immediate decision : does match
|
|
*/
|
|
{
|
|
int value=0, ret, start_lba, end_lba;
|
|
int lba_count, *file_end_lbas= NULL, *file_start_lbas= NULL, i;
|
|
void *arg1, *arg2;
|
|
char ft, *decision, md5[16];
|
|
regmatch_t name_match;
|
|
off_t damage_start, damage_end, size;
|
|
void *xinfo_dummy;
|
|
IsoNode *node;
|
|
IsoStream *stream;
|
|
|
|
if(ftest == NULL)
|
|
return(1);
|
|
|
|
node= (IsoNode *) node_pt;
|
|
arg1= ftest->arg1;
|
|
arg2= ftest->arg2;
|
|
|
|
if(node == NULL) {
|
|
if(ftest->test_type > 2 && ftest->test_type != 4) {
|
|
value= 0;
|
|
goto ex;
|
|
}
|
|
}
|
|
|
|
switch(ftest->test_type) {
|
|
case 0: /* -false */
|
|
value= 0;
|
|
|
|
break; case 1: /* -name *arg1 (regex in *arg2) */
|
|
ret= regexec(arg2, name, 1, &name_match, 0);
|
|
value= !ret;
|
|
|
|
break; case 2: /* -type *arg1 */
|
|
value= 1;
|
|
ft= *((char *) arg1);
|
|
if(ft!=0) {
|
|
if(S_ISBLK(stbuf->st_mode)) {
|
|
if(ft!='b')
|
|
value= 0;
|
|
} else if(S_ISCHR(stbuf->st_mode)) {
|
|
if(ft!='c')
|
|
value= 0;
|
|
} else if(S_ISDIR(stbuf->st_mode)) {
|
|
if(ft=='m') {
|
|
if(node != NULL)
|
|
value= 0;
|
|
else if(boss_stbuf==NULL)
|
|
value= 0;
|
|
else if(boss_stbuf->st_dev == stbuf->st_dev)
|
|
value= 0;
|
|
} else if(ft!='d')
|
|
value= 0;
|
|
} else if(S_ISFIFO(stbuf->st_mode)) {
|
|
if(ft!='p')
|
|
value= 0;
|
|
} else if(S_ISREG(stbuf->st_mode)) {
|
|
if(ft!='f' && ft!='-')
|
|
value= 0;
|
|
} else if(((stbuf->st_mode)&S_IFMT)==S_IFLNK) {
|
|
if(ft!='l')
|
|
value= 0;
|
|
} else if(((stbuf->st_mode)&S_IFMT)==S_IFSOCK) {
|
|
if(ft!='s')
|
|
value= 0;
|
|
} else if((flag & 1) && ((stbuf->st_mode) & S_IFMT) == Xorriso_IFBOOT) {
|
|
if(ft!='e' || node == NULL)
|
|
value= 0;
|
|
} else {
|
|
if(ft!='X')
|
|
value= 0;
|
|
}
|
|
}
|
|
|
|
break; case 3: /* -damaged */;
|
|
value= Xorriso_file_eval_damage(xorriso, node, &damage_start, &damage_end,
|
|
0);
|
|
if(value > 0)
|
|
value= 1;
|
|
|
|
break; case 4: /* -lba_range *arg1 *arg2 */
|
|
if(node == NULL) {
|
|
value= !(start_lba >= 0);
|
|
goto ex;
|
|
}
|
|
value= 1;
|
|
start_lba= *((int *) ftest->arg1);
|
|
end_lba= *((int *) ftest->arg2);
|
|
ret= Xorriso__start_end_lbas(node, &lba_count,
|
|
&file_start_lbas, &file_end_lbas, &size, 0);
|
|
if(ret <= 0) {
|
|
if(ret < 0)
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
if(start_lba >= 0)
|
|
value= 0;
|
|
} else {
|
|
for(i= 0; i < lba_count; i++) {
|
|
if(start_lba >= 0) {
|
|
if(file_end_lbas[i] < start_lba || file_start_lbas[i] > end_lba)
|
|
value= 0;
|
|
} else {
|
|
if(file_end_lbas[i] >= -start_lba && file_start_lbas[i] <= -end_lba)
|
|
value= 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
break; case 5: /* -has_acl */
|
|
ret = Xorriso_getfacl(xorriso, (void *) node, "", NULL, 2);
|
|
if(ret <= 0) {
|
|
value= -1;
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
goto ex;
|
|
}
|
|
value= (ret == 1);
|
|
|
|
break; case 6: /* -has_xattr */
|
|
case 14: /* -has_any_xattr */
|
|
ret = Xorriso_getfattr(xorriso, (void *) node, "", NULL,
|
|
64 | (8 * (ftest->test_type == 14)));
|
|
if(ret < 0) {
|
|
value= -1;
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
goto ex;
|
|
}
|
|
value= (ret > 0);
|
|
|
|
break; case 7: /* -has_aaip */
|
|
ret= iso_node_get_xinfo(node, aaip_xinfo_func, &xinfo_dummy);
|
|
if(ret < 0) {
|
|
value= -1;
|
|
Xorriso_process_msg_queues(xorriso, 0);
|
|
goto ex;
|
|
}
|
|
value= (ret > 0);
|
|
|
|
break; case 8: /* -has_filter */
|
|
value= 0;
|
|
if(LIBISO_ISREG(node)) {
|
|
stream= iso_file_get_stream((IsoFile *) node);
|
|
if(iso_stream_get_input_stream(stream, 0) != NULL)
|
|
value= 1;
|
|
}
|
|
|
|
break; case 9: /* -wanted_node arg1 (for internal use) */
|
|
value= (((IsoNode *) arg1) == node);
|
|
|
|
break; case 10: /* -pending_data */
|
|
value= 1;
|
|
if(!LIBISO_ISREG(node)) {
|
|
value= 0;
|
|
} else {
|
|
ret= Xorriso__file_start_lba(node, &start_lba, 0);
|
|
if(ret > 0 && start_lba >= 0)
|
|
value= 0;
|
|
}
|
|
|
|
break; case 11: /* -decision */
|
|
value= 2;
|
|
decision= (char *) arg1;
|
|
if(strcmp(decision, "yes") == 0 || strcmp(decision, "true") == 0)
|
|
value= 3;
|
|
|
|
break; case 12: /* -prune */
|
|
value= 1;
|
|
ftest->boss->prune= 1;
|
|
|
|
break; case 13: /* -wholename *arg1 (regex in *arg2) */
|
|
ret= regexec(arg2, path, 1, &name_match, 0);
|
|
value= !ret;
|
|
|
|
break; case 15: /* -has_md5 */
|
|
ret= Xorriso_get_md5(xorriso, node, path, md5, 1);
|
|
value= (ret > 0);
|
|
|
|
break; default:
|
|
|
|
/* >>> complain about unknown test type */;
|
|
|
|
value= -1;
|
|
|
|
}
|
|
|
|
ex:;
|
|
if(ftest->invert && value<=1 && value>=0)
|
|
value= !value;
|
|
if(file_start_lbas != NULL)
|
|
free((char *) file_start_lbas);
|
|
if(file_end_lbas != NULL)
|
|
free((char *) file_end_lbas);
|
|
return(value);
|
|
}
|
|
|
|
|
|
/* @return <0 = error , 0 = no match , 1 = match */
|
|
int Xorriso_findi_test(struct XorrisO *xorriso, struct FindjoB *job,
|
|
IsoNode *node, char *name, char *path,
|
|
struct stat *boss_stbuf, struct stat *stbuf,
|
|
int depth, int flag)
|
|
{
|
|
int ret;
|
|
|
|
job->prune= 0;
|
|
ret= Findjob_test_2(xorriso, job, node, name, path, boss_stbuf, stbuf, 1);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= recursion
|
|
bit1= do not count deleted files with rm and rm_r
|
|
@return <=0 error, 1= ok , 2= dir node and path has been deleted
|
|
*/
|
|
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)
|
|
{
|
|
int ret, action= 0, hflag, deleted= 0, no_dive= 0;
|
|
IsoDirIter *iter= NULL;
|
|
IsoDir *dir_node= NULL;
|
|
IsoNode *node, *iso_node;
|
|
IsoImage *volume= NULL;
|
|
struct stat stbuf;
|
|
char *name;
|
|
off_t mem;
|
|
IsoNode **node_array= NULL;
|
|
int node_count, node_idx;
|
|
char *path= NULL, *abs_path= NULL;
|
|
|
|
if(xorriso->request_to_abort)
|
|
{ret= 0; goto ex;}
|
|
|
|
path= malloc(SfileadrL);
|
|
abs_path= malloc(SfileadrL);
|
|
if(path==NULL || abs_path==NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, &path, 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
|
|
action= Findjob_get_action(job, 0);
|
|
if(action<0)
|
|
action= 0;
|
|
if(!(flag & 1)) {
|
|
if(action == 21) {
|
|
sprintf(xorriso->result_line, "Report layout: %8s , %8s , %8s , %s\n",
|
|
"at byte", "Range", "Filesize", "ISO image path");
|
|
Xorriso_result(xorriso, 0);
|
|
} else if(action == 22) {
|
|
sprintf(xorriso->result_line,
|
|
"Report layout: %2s , %8s , %8s , %8s , %s\n",
|
|
"xt", "Startlba", "Blocks", "Filesize", "ISO image path");
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
}
|
|
|
|
dir_node= (IsoDir *) dir_node_generic;
|
|
if(dir_node==NULL) {
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
{ret= -1; goto ex;}
|
|
ret= Xorriso_make_abs_adr(xorriso, xorriso->wdi, dir_path, path, 1|2|4);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= Xorriso_node_from_path(xorriso, volume, path, &iso_node, 0);
|
|
dir_node= (IsoDir *) iso_node;
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
ret= Xorriso_fake_stbuf(xorriso, "", dir_stbuf, &iso_node, 1);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
name= strrchr(dir_path, '/');
|
|
if(name==NULL)
|
|
name= dir_path;
|
|
else
|
|
name++;
|
|
|
|
ret= Xorriso_findi_test(xorriso, job, iso_node, name, path, NULL, dir_stbuf,
|
|
depth, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(job->prune)
|
|
no_dive= 1;
|
|
if(ret>0) {
|
|
ret= Xorriso_findi_action(xorriso, job,
|
|
(IsoDirIter *) boss_iter, boss_mem,
|
|
path, dir_path, (IsoNode *) dir_node, depth,
|
|
flag&(1|2));
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(xorriso->request_to_abort)
|
|
{ret= 0; goto ex;}
|
|
if(ret==2) {
|
|
/* re-determine dir_node in case it has a new persona */
|
|
ret= Xorriso_node_from_path(xorriso, volume, path, &iso_node, 1);
|
|
if(ret==0) {
|
|
deleted= 1;
|
|
{ret= 2; goto ex;}
|
|
}
|
|
if(ret<0)
|
|
{ret= 0; goto ex;}
|
|
dir_node= (IsoDir *) iso_node;
|
|
ret= Xorriso_fake_stbuf(xorriso, "", dir_stbuf, &iso_node, 1);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
if(ret==3)
|
|
no_dive= 1;
|
|
}
|
|
}
|
|
if(no_dive || !LIBISO_ISDIR((IsoNode *) dir_node))
|
|
{ret= 1; goto ex;}
|
|
if(Xorriso_is_split(xorriso, dir_path, (IsoNode *) dir_node, 1)>0)
|
|
{ret= 1; goto ex;}
|
|
|
|
mem= boss_mem;
|
|
hflag= 1;
|
|
if(action==1 || action==2 || action==3 || action==17 || action == 28 ||
|
|
action == 32)
|
|
hflag|= 2; /* need freedom to manipulate image */
|
|
if(action==14 || action==17 || action == 28)
|
|
hflag|= 4; /* need LBA sorted iteration for good data reading performance */
|
|
ret= Xorriso_findi_iter(xorriso, dir_node, &mem,
|
|
&iter, &node_array, &node_count, &node_idx,
|
|
&node, hflag);
|
|
if(ret<=0)
|
|
goto ex;
|
|
while(1) {
|
|
ret= Xorriso_findi_iter(xorriso, dir_node, &mem, &iter,
|
|
&node_array, &node_count, &node_idx, &node, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0)
|
|
break;
|
|
name= (char *) iso_node_get_name(node);
|
|
ret= Xorriso_make_abs_adr(xorriso, dir_path, name, path, 4);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0)
|
|
continue;
|
|
|
|
/* ??? This seems to be redundant with the single test above
|
|
??? Should i dive in unconditionally and leave out test and action here ?
|
|
??? Then do above test unconditionally ?
|
|
--- Seems that the current configuration represents the special
|
|
handling of the find start path with mount points. Dangerous to change.
|
|
*/
|
|
|
|
ret= Xorriso_findi_test(xorriso, job, node, name, path, dir_stbuf, &stbuf,
|
|
depth, 0);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(job->prune)
|
|
no_dive= 1;
|
|
if(ret>0) {
|
|
ret= Xorriso_make_abs_adr(xorriso, xorriso->wdi, path, abs_path, 1|2|4);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= Xorriso_findi_action(xorriso, job, iter, mem,
|
|
abs_path, path, node, depth, 1|(flag&2));
|
|
if(xorriso->request_to_abort)
|
|
{ret= 0; goto ex;}
|
|
if(ret==2) { /* node has been deleted */
|
|
/* re-determine node in case it has a new persona */
|
|
if(volume==NULL) {
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
{ret= -1; goto ex;}
|
|
}
|
|
ret= Xorriso_node_from_path(xorriso, volume, abs_path, &node, 1);
|
|
if(ret==0)
|
|
continue;
|
|
if(ret<0)
|
|
{ret= 0; goto ex;}
|
|
ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
|
|
if(ret<0)
|
|
goto ex;
|
|
if(ret==0)
|
|
continue;
|
|
}
|
|
no_dive= (ret==3);
|
|
if(ret<=0) {
|
|
if(Xorriso_eval_problem_status(xorriso, ret, 1|2)<0)
|
|
goto ex;
|
|
}
|
|
}
|
|
|
|
if(S_ISDIR(stbuf.st_mode) && !no_dive) {
|
|
ret= Xorriso_findi(xorriso, job, (void *) iter, mem,
|
|
(void *) node, path, &stbuf, depth+1, flag|1);
|
|
if(ret<0)
|
|
goto ex;
|
|
}
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(path!=NULL)
|
|
free(path);
|
|
if(abs_path!=NULL)
|
|
free(abs_path);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
Xorriso_findi_iter(xorriso, dir_node, &mem, &iter, &node_array, &node_count,
|
|
&node_idx, &node, (1<<31));
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(deleted)
|
|
return(2);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_node_is_valid(struct XorrisO *xorriso, IsoNode *in_node, int flag)
|
|
{
|
|
IsoNode *node, *parent;
|
|
|
|
for(node= in_node; 1; node= parent) {
|
|
parent= (IsoNode *) iso_node_get_parent(node);
|
|
if(parent == node)
|
|
break;
|
|
if(parent == NULL)
|
|
return(0); /* Node is not in the tree (any more) */
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_path_from_node(struct XorrisO *xorriso, IsoNode *in_node,
|
|
char path[SfileadrL], int flag)
|
|
{
|
|
int ret, i, comp_count= 0;
|
|
IsoNode *node, *parent, **components= NULL;
|
|
char *wpt, *npt;
|
|
|
|
for(node= in_node; 1; node= parent) {
|
|
parent= (IsoNode *) iso_node_get_parent(node);
|
|
if(parent == node)
|
|
break;
|
|
if(parent == NULL)
|
|
return(0); /* Node is not in the tree (any more) */
|
|
comp_count++;
|
|
}
|
|
if(comp_count == 0) {
|
|
strcpy(path, "/");
|
|
return(1);
|
|
}
|
|
components= calloc(comp_count, sizeof(IsoNode *));
|
|
if(components == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
i= comp_count;
|
|
for(node= in_node; 1; node= parent) {
|
|
parent= (IsoNode *) iso_node_get_parent(node);
|
|
if(parent == node)
|
|
break;
|
|
components[--i]= node;
|
|
}
|
|
|
|
wpt= path;
|
|
for(i= 0; i < comp_count; i++) {
|
|
npt= (char *) iso_node_get_name(components[i]);
|
|
if((wpt - path) + strlen(npt) + 1 >= SfileadrL) {
|
|
|
|
/* >>> path is getting much too long */;
|
|
|
|
ret= -1; goto ex;
|
|
}
|
|
*(wpt++)= '/';
|
|
strcpy(wpt, npt);
|
|
wpt+= strlen(npt);
|
|
*wpt= 0;
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(components != NULL)
|
|
free(components);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* <<< The lookup from node pointer will be done by Xorriso_path_from_node()
|
|
(Currently it runs a full tree traversal)
|
|
Parameter node and flag bit0 will vanish then
|
|
*/
|
|
/* @param flag bit0= use lba rather than node pointer
|
|
*/
|
|
int Xorriso_path_from_lba(struct XorrisO *xorriso, IsoNode *node, int lba,
|
|
char path[SfileadrL], int flag)
|
|
{
|
|
int ret;
|
|
struct FindjoB *job= NULL;
|
|
struct stat dir_stbuf;
|
|
char *found_path;
|
|
|
|
path[0]= 0;
|
|
if((flag & 1) && lba <= 0)
|
|
return(0);
|
|
|
|
ret= Findjob_new(&job, "/", 0);
|
|
if(ret <= 0) {
|
|
Xorriso_no_findjob(xorriso, "path_from_node", 0);
|
|
return(ret);
|
|
}
|
|
if(flag & 1)
|
|
Findjob_set_lba_range(job, lba, 1, 0);
|
|
else
|
|
Findjob_set_wanted_node(job, (void *) node, 0);
|
|
Findjob_set_action_found_path(job, 0);
|
|
ret= Xorriso_findi(xorriso, job, NULL, (off_t) 0,
|
|
NULL, "/", &dir_stbuf, 0, 0);
|
|
if(ret > 0) {
|
|
ret= 1;
|
|
Findjob_get_found_path(job, &found_path, 0);
|
|
if(found_path == NULL)
|
|
ret= 0;
|
|
else if(Sfile_str(path, found_path, 0) <= 0)
|
|
ret= -1;
|
|
}
|
|
Findjob_destroy(&job, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not dive into trees
|
|
bit1= do not perform job->action on resulting node array
|
|
bit2= do not free node_array after all actions are done
|
|
bit3= eventually issue MD5 mismatch event
|
|
*/
|
|
int Xorriso_findi_sorted(struct XorrisO *xorriso, struct FindjoB *job,
|
|
off_t boss_mem, int filec, char **filev, int flag)
|
|
{
|
|
int i, ret;
|
|
struct FindjoB array_job, *proxy_job= NULL, *hindmost= NULL, *hmboss= NULL;
|
|
struct stat dir_stbuf;
|
|
IsoNode *node;
|
|
char abs_path[SfileadrL];
|
|
off_t mem_needed= 0;
|
|
|
|
array_job.start_path= NULL;
|
|
|
|
if((flag & 8) && job->action == 35)
|
|
xorriso->find_check_md5_result= 0;
|
|
if(job->action>=9 && job->action<=13) { /* actions which have own findjobs */
|
|
/* array_job replaces the hindmost job in the chain */
|
|
for(hindmost= job; hindmost->subjob != NULL; hindmost= hindmost->subjob)
|
|
hmboss= hindmost;
|
|
if(hmboss == NULL)
|
|
{ret= -1; goto ex;}
|
|
memcpy(&array_job, hindmost, sizeof(struct FindjoB));
|
|
hmboss->subjob= &array_job;
|
|
proxy_job= job;
|
|
} else {
|
|
memcpy(&array_job, job, sizeof(struct FindjoB));
|
|
proxy_job= &array_job;
|
|
hindmost= job;
|
|
}
|
|
array_job.start_path= NULL; /* is owned by the original, not by array_job */
|
|
|
|
/* Count matching nodes */
|
|
Xorriso_destroy_node_array(xorriso, 0);
|
|
array_job.action= 30; /* internal: count */
|
|
for(i= 0; i < filec; i++) {
|
|
if(flag & 1) {
|
|
xorriso->node_counter++;
|
|
continue;
|
|
}
|
|
ret= Findjob_set_start_path(proxy_job, filev[i], 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= Xorriso_findi(xorriso, proxy_job, NULL, boss_mem, NULL,
|
|
filev[i], &dir_stbuf, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
if(xorriso->node_counter <= 0)
|
|
{ret= 1; goto ex;}
|
|
|
|
mem_needed= boss_mem + xorriso->node_counter * sizeof(IsoNode *);
|
|
if(!(flag &1)) {
|
|
ret= Xorriso_check_temp_mem_limit(xorriso, mem_needed, 0);
|
|
if(ret <= 0) {
|
|
/* Memory curbed : Perform unsorted find jobs */
|
|
if(hmboss != NULL)
|
|
hmboss->subjob= hindmost;
|
|
for(i= 0; i < filec; i++) {
|
|
ret= Findjob_set_start_path(job, filev[i], 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= Xorriso_findi(xorriso, job, NULL, boss_mem, NULL,
|
|
filev[i], &dir_stbuf, 0, 0);
|
|
if(ret <= 0)
|
|
if(Xorriso_eval_problem_status(xorriso, ret, 1|2)<0)
|
|
goto ex;
|
|
}
|
|
{ret= 1; goto ex;}
|
|
}
|
|
}
|
|
|
|
/* Copy matching nodes into allocated array */
|
|
ret= Xorriso_new_node_array(xorriso, xorriso->temp_mem_limit, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
array_job.action= 31; /* internal: register */
|
|
xorriso->node_counter= 0;
|
|
for(i= 0; i < filec; i++) {
|
|
if(flag & 1) {
|
|
ret= Xorriso_get_node_by_path(xorriso, filev[i], NULL, &node, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(xorriso->node_counter < xorriso->node_array_size) {
|
|
xorriso->node_array[xorriso->node_counter++]= (void *) node;
|
|
iso_node_ref(node);
|
|
}
|
|
continue;
|
|
}
|
|
ret= Findjob_set_start_path(proxy_job, filev[i], 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= Xorriso_findi(xorriso, proxy_job, NULL, mem_needed, NULL,
|
|
filev[i], &dir_stbuf, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
|
|
Xorriso_sort_node_array(xorriso, 0);
|
|
if(flag & 2)
|
|
{ret= 1; goto ex;}
|
|
|
|
/* Perform job->action on xorriso->node_array */
|
|
for(i= 0; i < xorriso->node_counter; i++) {
|
|
node= xorriso->node_array[i];
|
|
ret= Xorriso_path_from_node(xorriso, node, abs_path, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0)
|
|
continue; /* node is deleted from tree meanwhile */
|
|
|
|
ret= Xorriso_findi_action(xorriso, hindmost, NULL, (off_t) 0,
|
|
abs_path, abs_path, node, 0, 1);
|
|
if(ret <= 0)
|
|
if(Xorriso_eval_problem_status(xorriso, ret, 1|2)<0)
|
|
goto ex;
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if((flag & 8) && job->action == 35)
|
|
Xorriso_report_md5_outcome(xorriso, job->target, 0);
|
|
if(!(flag & (2 | 4)))
|
|
Xorriso_destroy_node_array(xorriso, 0);
|
|
if(hmboss != NULL)
|
|
hmboss->subjob= hindmost;
|
|
if(array_job.start_path != NULL)
|
|
free(array_job.start_path);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not mark image as changed */
|
|
int Xorriso_set_volid(struct XorrisO *xorriso, char *volid, int flag)
|
|
{
|
|
int ret;
|
|
IsoImage *volume;
|
|
|
|
if(xorriso->in_volset_handle == NULL)
|
|
return(2);
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
iso_image_set_volume_id(volume, volid);
|
|
if(!(flag&1))
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,"Volume ID: '%s'",iso_image_get_volume_id(volume));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_get_volid(struct XorrisO *xorriso, char volid[33], int flag)
|
|
{
|
|
int ret;
|
|
IsoImage *volume;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
strncpy(volid, iso_image_get_volume_id(volume), 32);
|
|
volid[32]= 0;
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0=prepare for a burn run */
|
|
int Xorriso_set_abort_severity(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, abort_on_number;
|
|
char *sev_text;
|
|
static int note_number= -1, failure_number= -1;
|
|
|
|
if(note_number==-1)
|
|
Xorriso__text_to_sev("NOTE", ¬e_number, 0);
|
|
if(failure_number==-1)
|
|
Xorriso__text_to_sev("FAILURE", &failure_number, 0);
|
|
sev_text= xorriso->abort_on_text;
|
|
ret= Xorriso__text_to_sev(xorriso->abort_on_text, &abort_on_number, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(abort_on_number<note_number)
|
|
sev_text= "NOTE";
|
|
else if(abort_on_number>failure_number)
|
|
sev_text= "FAILURE";
|
|
ret= iso_set_abort_severity(sev_text);
|
|
return(ret>=0);
|
|
}
|
|
|
|
|
|
int Xorriso_report_lib_versions(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int major, minor, micro;
|
|
int req_major, req_minor, req_micro;
|
|
|
|
iso_lib_version(&major, &minor, µ);
|
|
isoburn_libisofs_req(&req_major, &req_minor, &req_micro);
|
|
sprintf(xorriso->result_line,
|
|
"libisofs in use : %d.%d.%d (min. %d.%d.%d)\n",
|
|
major, minor, micro, req_major, req_minor, req_micro);
|
|
Xorriso_result(xorriso, 0);
|
|
burn_version(&major, &minor, µ);
|
|
isoburn_libburn_req(&req_major, &req_minor, &req_micro);
|
|
sprintf(xorriso->result_line,
|
|
"libburn in use : %d.%d.%d (min. %d.%d.%d)\n",
|
|
major, minor, micro, req_major, req_minor, req_micro);
|
|
Xorriso_result(xorriso, 0);
|
|
isoburn_version(&major, &minor, µ);
|
|
sprintf(xorriso->result_line,
|
|
"libisoburn in use : %d.%d.%d (min. %d.%d.%d)\n",
|
|
major, minor, micro,
|
|
isoburn_header_version_major, isoburn_header_version_minor,
|
|
isoburn_header_version_micro);
|
|
Xorriso_result(xorriso, 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= -inq
|
|
bit1= -checkdrive
|
|
*/
|
|
int Xorriso_atip(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, profile_number= 0;
|
|
char *respt, profile_name[80];
|
|
double x_speed_max, x_speed_min= -1.0;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
enum burn_disc_status s;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to print drive and media info", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
respt= xorriso->result_line;
|
|
sprintf(respt, "Device type : ");
|
|
ret= burn_drive_get_drive_role(drive);
|
|
if(ret==0)
|
|
sprintf(respt+strlen(respt), "%s\n", "Emulated (null-drive)");
|
|
else if(ret==2)
|
|
sprintf(respt+strlen(respt), "%s\n",
|
|
"Emulated (stdio-drive, 2k random read-write)");
|
|
else if(ret==3)
|
|
sprintf(respt+strlen(respt), "%s\n",
|
|
"Emulated (stdio-drive, sequential write-only)");
|
|
else if(ret!=1)
|
|
sprintf(respt+strlen(respt), "%s\n","Emulated (stdio-drive)");
|
|
else
|
|
sprintf(respt+strlen(respt), "%s\n","Removable CD-ROM");
|
|
sprintf(respt+strlen(respt), "Vendor_info : '%s'\n",dinfo->vendor);
|
|
sprintf(respt+strlen(respt), "Identifikation : '%s'\n",dinfo->product);
|
|
sprintf(respt+strlen(respt), "Revision : '%s'\n",dinfo->revision);
|
|
Xorriso_result(xorriso,1);
|
|
if(flag&1)
|
|
return(1);
|
|
sprintf(respt, "Driver flags : BURNFREE\n");
|
|
sprintf(respt+strlen(respt), "Supported modes: SAO TAO\n");
|
|
Xorriso_result(xorriso,1);
|
|
if(flag&2)
|
|
return(1);
|
|
|
|
s= burn_disc_get_status(drive);
|
|
ret= burn_disc_get_profile(drive,&profile_number,profile_name);
|
|
if(ret<=0) {
|
|
profile_number= 0;
|
|
strcpy(profile_name, "-unidentified-");
|
|
}
|
|
if(s != BURN_DISC_UNSUITABLE) {
|
|
ret= burn_disc_read_atip(drive);
|
|
if(ret>0) {
|
|
ret= burn_drive_get_min_write_speed(drive);
|
|
x_speed_min= ((double) ret)/176.4;
|
|
}
|
|
}
|
|
if(s==BURN_DISC_EMPTY) {
|
|
sprintf(respt, "Current: none\n");
|
|
Xorriso_result(xorriso,1);
|
|
return(1);
|
|
} else
|
|
sprintf(respt, "Current: %s\n",profile_name);
|
|
Xorriso_result(xorriso,1);
|
|
if(strstr(profile_name,"DVD")==profile_name) {
|
|
sprintf(respt, "book type: %s (emulated booktype)\n", profile_name);
|
|
Xorriso_result(xorriso,1);
|
|
if(profile_number == 0x13) {
|
|
sprintf(respt, "xorriso: message for sdvdbackup: \"(growisofs mode Restricted Overwrite)\"\n");
|
|
Xorriso_result(xorriso,1);
|
|
}
|
|
} else {
|
|
sprintf(respt, "ATIP info from disk:\n");
|
|
Xorriso_result(xorriso,1);
|
|
if(burn_disc_erasable(drive))
|
|
sprintf(respt, " Is erasable\n");
|
|
else
|
|
sprintf(respt, " Is not erasable\n");
|
|
Xorriso_result(xorriso,1);
|
|
{ int start_lba,end_lba,min,sec,fr;
|
|
ret= burn_drive_get_start_end_lba(drive,&start_lba,&end_lba,0);
|
|
if(ret>0) {
|
|
burn_lba_to_msf(start_lba,&min,&sec,&fr);
|
|
sprintf(respt, " ATIP start of lead in: %d (%-2.2d:%-2.2d/%-2.2d)\n",
|
|
start_lba,min,sec,fr);
|
|
Xorriso_result(xorriso,1);
|
|
burn_lba_to_msf(end_lba,&min,&sec,&fr);
|
|
sprintf(respt, " ATIP start of lead out: %d (%-2.2d:%-2.2d/%-2.2d)\n",
|
|
end_lba,min,sec,fr);
|
|
Xorriso_result(xorriso,1);
|
|
}
|
|
}
|
|
ret= burn_drive_get_write_speed(drive);
|
|
x_speed_max= ((double) ret)/176.4;
|
|
if(x_speed_min<0)
|
|
x_speed_min= x_speed_max;
|
|
sprintf(respt,
|
|
" 1T speed low: %.f 1T speed high: %.f\n",x_speed_min,x_speed_max);
|
|
Xorriso_result(xorriso,1);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_update_in_sector_map(struct XorrisO *xorriso,
|
|
struct SpotlisT *spotlist, int read_chunk,
|
|
struct CheckmediajoB *job, int flag)
|
|
{
|
|
int sectors, sector_size, sector_blocks, ret;
|
|
struct SectorbitmaP *map;
|
|
|
|
Sectorbitmap_destroy(&(xorriso->in_sector_map), 0);
|
|
if(job->use_dev == 1)
|
|
return(1);
|
|
map= job->sector_map;
|
|
sectors= Spotlist_block_count(spotlist, 0);
|
|
if(sectors <= 0)
|
|
return(0);
|
|
sector_size= Spotlist_sector_size(spotlist, read_chunk, 0);
|
|
sector_blocks= sector_size / 2048;
|
|
if(sector_blocks > 1)
|
|
sectors= sectors / sector_blocks + !!(sectors % sector_blocks);
|
|
ret= Sectorbitmap_new(&(xorriso->in_sector_map), sectors, sector_size, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
if(map != NULL)
|
|
Sectorbitmap_copy(map, xorriso->in_sector_map, 0);
|
|
ret= Xorriso_spotlist_to_sectormap(xorriso, spotlist, read_chunk,
|
|
&(xorriso->in_sector_map), 1);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@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)
|
|
{
|
|
int ret, full_size, i;
|
|
char *headpt;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
off_t seek_ret;
|
|
|
|
if(flag & 1) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to learn current session lba", 1);
|
|
if(ret<=0)
|
|
return(0);
|
|
ret= isoburn_disc_get_msc1(drive, &iso_lba);
|
|
if(ret<=0)
|
|
return(0);
|
|
drive= NULL; /* indev will not be used furtherly */
|
|
}
|
|
if(job == NULL) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to update at lba 0 to 31", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
}
|
|
if(iso_lba < 32)
|
|
return(2);
|
|
if(!(flag & 2)) {
|
|
/* head_buffer was not filled yet. Read it from output media. */
|
|
if(job != NULL && job->data_to_fd >= 0) {
|
|
if((flag & 8) && job->sector_map != NULL) {
|
|
ret= Sectorbitmap_bytes_are_set(job->sector_map,
|
|
((off_t) iso_lba) * (off_t) 2048,
|
|
((off_t) (iso_lba + 32)) * ((off_t) 2048) - (off_t) 1, 0);
|
|
if(ret <= 0) {
|
|
sprintf(xorriso->info_text,
|
|
"ISO image head at lba %d is marked as invalid blocks in file copy",
|
|
iso_lba);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",
|
|
0);
|
|
return(0);
|
|
}
|
|
}
|
|
seek_ret= lseek(job->data_to_fd, ((off_t) 2048) * (off_t) iso_lba,
|
|
SEEK_SET);
|
|
if(seek_ret == -1)
|
|
ret= 0;
|
|
else
|
|
ret= read(job->data_to_fd, head_buffer, 64 * 1024);
|
|
if(ret < 64 * 1024) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot read ISO image head from file copy");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
return(0);
|
|
}
|
|
} else {
|
|
ret= isoburn_read_iso_head(drive, iso_lba, &isosize, head_buffer, 2);
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot read freshly written ISO image head");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
}
|
|
}
|
|
/* patch ISO header */
|
|
full_size= iso_lba + isosize;
|
|
headpt= head_buffer + 32*1024;
|
|
for(i=0;i<4;i++)
|
|
headpt[87-i]= headpt[80+i]= (full_size >> (8*i)) & 0xff;
|
|
|
|
if(job != NULL) {
|
|
seek_ret= lseek(job->data_to_fd, (off_t) 0, SEEK_SET);
|
|
if(seek_ret == -1)
|
|
ret= 0;
|
|
else
|
|
ret= write(job->data_to_fd, head_buffer, 64 * 1024);
|
|
if(ret < 64 * 1024) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot write ISO image head to file copy");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
|
|
return(0);
|
|
}
|
|
} else {
|
|
ret= burn_random_access_write(drive, (off_t) 0, head_buffer,
|
|
(off_t) (64*1024), 1);
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot write new ISO image head to LBA 0");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
}
|
|
if(flag & 4) {
|
|
sprintf(xorriso->info_text,
|
|
"Overwrote LBA 0 to 31 by 64 KiB from LBA %d", iso_lba);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @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)
|
|
{
|
|
int ret, fd, unpredicted_size, profile_number, is_cd= 0, dummy, nwa= -1;
|
|
int isosize= -1, do_isosize, is_bd= 0;
|
|
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
struct burn_write_opts *burn_options;
|
|
struct burn_disc *disc= NULL;
|
|
struct burn_session *session;
|
|
struct burn_track *track;
|
|
struct stat stbuf;
|
|
off_t fixed_size= 0;
|
|
struct burn_source *data_src, *fifo_src;
|
|
enum burn_disc_status disc_state;
|
|
char reasons[BURN_REASONS_LEN], sfe[5*SfileadrL], profile_name[80];
|
|
char head_buffer[64*1024];
|
|
|
|
ret= Xorriso_auto_format(xorriso, 0);
|
|
if(ret <=0 )
|
|
return(0);
|
|
|
|
do_isosize= !!(flag&2);
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to burn track", 2);
|
|
if(ret<=0)
|
|
return(0);
|
|
ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
disc= burn_disc_create();
|
|
session= burn_session_create();
|
|
ret= burn_disc_add_session(disc,session,BURN_POS_END);
|
|
if(ret==0) {
|
|
sprintf(xorriso->info_text, "Cannot add session object to disc object.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
goto ex;
|
|
}
|
|
track= burn_track_create();
|
|
if(track_source[0] == '-' && track_source[1] == 0) {
|
|
fd= 0;
|
|
} else {
|
|
fd= open(track_source, O_RDONLY);
|
|
if(fd>=0)
|
|
if(fstat(fd,&stbuf)!=-1)
|
|
if((stbuf.st_mode&S_IFMT)==S_IFREG)
|
|
fixed_size= stbuf.st_size;
|
|
}
|
|
if(fixed_size==0)
|
|
unpredicted_size= 1;
|
|
|
|
data_src= NULL;
|
|
if(fd>=0)
|
|
data_src= burn_fd_source_new(fd, -1, fixed_size);
|
|
if(data_src==NULL) {
|
|
sprintf(xorriso->info_text, "Could not open data source %s",
|
|
Text_shellsafe(track_source,sfe,0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(do_isosize && xorriso->fs < 64)
|
|
xorriso->fs= 64;
|
|
fifo_src= burn_fifo_source_new(data_src, 2048, xorriso->fs, 0);
|
|
if(fifo_src == NULL) {
|
|
sprintf(xorriso->info_text, "Could not create fifo object of 4 MB");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
xorriso->pacifier_fifo= fifo_src;
|
|
if(burn_track_set_source(track, fifo_src)!=BURN_SOURCE_OK) {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot attach source object to track object");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
burn_session_add_track(session, track, BURN_POS_END);
|
|
burn_source_free(data_src);
|
|
|
|
if(flag&1)
|
|
/* consider overwriteables with ISO as appendable */
|
|
disc_state= isoburn_disc_get_status(drive);
|
|
else
|
|
/* handle overwriteables as always blank */
|
|
disc_state= burn_disc_get_status(drive);
|
|
|
|
if(disc_state == BURN_DISC_BLANK || disc_state == BURN_DISC_APPENDABLE) {
|
|
/* ok */;
|
|
} else {
|
|
if(disc_state == BURN_DISC_FULL) {
|
|
sprintf(xorriso->info_text,
|
|
"Closed media with data detected. Need blank or appendable media.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
if(burn_disc_erasable(drive)) {
|
|
sprintf(xorriso->info_text, "Try -blank as_needed\n");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
|
|
}
|
|
} else if(disc_state == BURN_DISC_EMPTY) {
|
|
sprintf(xorriso->info_text, "No media detected in drive");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
} else {
|
|
sprintf(xorriso->info_text,
|
|
"Cannot recognize state of drive and media");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
}
|
|
ret= 0; goto ex;
|
|
}
|
|
if(isoburn_needs_emulation(drive))
|
|
burn_write_opts_set_multi(burn_options, 0);
|
|
|
|
if(tsize > 0) {
|
|
fixed_size= tsize;
|
|
burn_track_set_size(track, fixed_size);
|
|
}
|
|
if(do_isosize) {
|
|
ret= burn_fifo_peek_data(xorriso->pacifier_fifo, head_buffer, 64*1024, 0);
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot obtain first 64 kB from input stream.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
/* read isosize from head_buffer, not from media*/
|
|
ret= isoburn_read_iso_head(drive, 0, &isosize, head_buffer, (1<<13));
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Option -isosize given but data stream seems not to be ISO 9660");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
sprintf(xorriso->info_text, "Size of ISO 9660 image: %ds", isosize);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
fixed_size= ((off_t) (isosize)) * (off_t) 2048;
|
|
burn_track_set_size(track, fixed_size);
|
|
}
|
|
|
|
ret= Xorriso_get_profile(xorriso, &profile_number, profile_name, 2);
|
|
is_cd= (ret==2);
|
|
is_bd= (ret == 3);
|
|
|
|
if(isoburn_needs_emulation(drive)) {
|
|
if(flag&1) {
|
|
ret= isoburn_disc_track_lba_nwa(drive, burn_options, 0, &dummy, &nwa);
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Cannot obtain next writeable address of emulated multi-session media\n");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(nwa==32)
|
|
nwa= 0; /* No automatic toc emulation. Formatter might not be aware. */
|
|
burn_write_opts_set_start_byte(burn_options,((off_t) nwa) * (off_t) 2048);
|
|
} else {
|
|
nwa= 0;
|
|
burn_write_opts_set_start_byte(burn_options, (off_t) 0);
|
|
}
|
|
}
|
|
|
|
if(write_start_address>=0) {
|
|
nwa= write_start_address / (off_t) 2048;
|
|
if(((off_t) nwa) * (off_t) 2048 < write_start_address )
|
|
nwa++;
|
|
burn_write_opts_set_start_byte(burn_options, ((off_t) nwa) * (off_t) 2048);
|
|
}
|
|
|
|
if(burn_write_opts_auto_write_type(burn_options, disc, reasons, 0) ==
|
|
BURN_WRITE_NONE) {
|
|
sprintf(xorriso->info_text,
|
|
"Failed to find a suitable write mode with this media.\n");
|
|
sprintf(xorriso->info_text+strlen(xorriso->info_text),
|
|
"Reasons given:\n%s", reasons);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
ret= Xorriso_sanitize_image_size(xorriso, drive, disc, burn_options, 2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
xorriso->run_state= 1; /* Indicate that burning has started */
|
|
burn_disc_write(burn_options, disc);
|
|
|
|
ret= Xorriso_pacifier_loop(xorriso, drive, 2 | (is_cd << 4) | (is_bd << 5));
|
|
if(ret<=0)
|
|
goto ex;
|
|
if(!burn_drive_wrote_well(drive)) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"libburn indicates failure with writing.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
if(flag & 1) {
|
|
ret= Xorriso_update_iso_lba0(xorriso, nwa, isosize, head_buffer, NULL,
|
|
flag & 2);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
sprintf(xorriso->info_text, "Writing to %s completed sucessfully.\n\n",
|
|
Text_shellsafe(xorriso->outdev,sfe,0));
|
|
Xorriso_info(xorriso, 0);
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(disc!=NULL)
|
|
burn_disc_free(disc);
|
|
if(xorriso->pacifier_fifo!=NULL)
|
|
burn_source_free(xorriso->pacifier_fifo);
|
|
xorriso->pacifier_fifo= NULL;
|
|
xorriso->run_state= 0; /* Indicate that burning has ended */
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit1= outdev rather than indev
|
|
@return <0 error, 0 = no profile to see , 1= ok , 2= ok, is CD profile
|
|
3= ok, is BD profile
|
|
*/
|
|
int Xorriso_get_profile(struct XorrisO *xorriso, int *profile_number,
|
|
char profile_name[80], int flag)
|
|
{
|
|
int ret;
|
|
struct burn_drive_info *dinfo;
|
|
struct burn_drive *drive;
|
|
|
|
*profile_number= 0;
|
|
profile_name[0]= 0;
|
|
if(((flag&2) && xorriso->out_drive_handle==NULL) ||
|
|
((!(flag&2)) && xorriso->in_drive_handle==NULL))
|
|
return(0);
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to determine media type", flag&2);
|
|
if(ret<=0)
|
|
return(0);
|
|
ret=burn_disc_get_profile(drive, profile_number, profile_name);
|
|
if(ret<=0)
|
|
return(ret);
|
|
if(*profile_number==0x08 || *profile_number==0x09 || *profile_number==0x0a)
|
|
return(2);
|
|
if(*profile_number == 0x40 || *profile_number == 0x41 ||
|
|
*profile_number == 0x42 || *profile_number == 0x43)
|
|
return(3);
|
|
return(0);
|
|
}
|
|
|
|
|
|
|
|
int Xorriso_iso_file_open(struct XorrisO *xorriso, char *pathname,
|
|
void *node_pt, void **stream, int flag)
|
|
{
|
|
int ret;
|
|
char eff_path[SfileadrL];
|
|
IsoNode *node= NULL;
|
|
IsoFile *filenode= NULL;
|
|
IsoStream *iso_stream= NULL, *input_stream;
|
|
|
|
*stream= NULL;
|
|
if(flag&1) {
|
|
node= (IsoNode *) node_pt;
|
|
} else {
|
|
ret= Xorriso_get_node_by_path(xorriso, pathname, eff_path, &node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
if(!LIBISO_ISREG(node)) {
|
|
sprintf(xorriso->info_text,
|
|
"Given path does not lead to a regular data file in the image");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
filenode= (IsoFile *) node;
|
|
iso_stream= iso_file_get_stream(filenode);
|
|
if(iso_stream==NULL) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"Could not obtain source stream of file in the image for reading");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
if(flag & 2) {
|
|
/* Dig out the most original stream */
|
|
while(1) {
|
|
input_stream= iso_stream_get_input_stream(iso_stream, 0);
|
|
if(input_stream == NULL)
|
|
break;
|
|
iso_stream= input_stream;
|
|
}
|
|
}
|
|
if(!iso_stream_is_repeatable(iso_stream)) {
|
|
sprintf(xorriso->info_text,
|
|
"The data production of the file in the image is one-time only");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
ret= iso_stream_open(iso_stream);
|
|
if(ret<0) {
|
|
sprintf(xorriso->info_text,
|
|
"Could not open data file in the image for reading");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
*stream= iso_stream;
|
|
|
|
#ifdef NIX
|
|
/* <<< */
|
|
{
|
|
unsigned int fs_id;
|
|
dev_t dev_id;
|
|
ino_t ino;
|
|
|
|
iso_stream_get_id(iso_stream, &fs_id, &dev_id, &ino);
|
|
fprintf(stderr, "xorriso_debug: iso_ino= %ld\n", (long int) ino);
|
|
}
|
|
#endif
|
|
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_iso_file_read(struct XorrisO *xorriso, void *stream, char *buf,
|
|
int count, int flag)
|
|
{
|
|
int ret, rcnt= 0;
|
|
IsoStream *stream_pt;
|
|
|
|
stream_pt= (IsoStream *) stream;
|
|
|
|
while(rcnt<count) {
|
|
ret= iso_stream_read(stream_pt, (void *) (buf+rcnt), (size_t) (count-rcnt));
|
|
if(ret==0) /* EOF */
|
|
break;
|
|
if(ret<0) { /* error */
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, "", ret, "Error on read",
|
|
0, "FAILURE", 1 | ((ret == -1)<<2) );
|
|
return(-1);
|
|
}
|
|
rcnt+= ret;
|
|
}
|
|
return(rcnt);
|
|
}
|
|
|
|
|
|
int Xorriso_iso_file_close(struct XorrisO *xorriso, void **stream, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if(*stream==NULL)
|
|
return(0);
|
|
ret= iso_stream_close(*stream);
|
|
if(ret==1)
|
|
*stream= NULL;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= in_node is valid, do not resolve iso_adr
|
|
bit1= insist in complete collection of part files
|
|
*/
|
|
int Xorriso_identify_split(struct XorrisO *xorriso, char *iso_adr,
|
|
void *in_node,
|
|
struct SplitparT **parts, int *count,
|
|
struct stat *total_stbuf, int flag)
|
|
{
|
|
int ret, i, incomplete= 0, overlapping= 0;
|
|
int partno, total_parts, first_total_parts= -1;
|
|
off_t offset, bytes, total_bytes, first_total_bytes= -1, first_bytes= -1;
|
|
off_t size, covered;
|
|
|
|
IsoImage *volume;
|
|
IsoDir *dir_node;
|
|
IsoDirIter *iter= NULL;
|
|
IsoNode *node;
|
|
char *name;
|
|
struct stat stbuf, first_stbuf;
|
|
|
|
*count= 0;
|
|
*parts= NULL;
|
|
|
|
if(flag&1) {
|
|
node= (IsoNode *) in_node;
|
|
} else {
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(-1);
|
|
ret= Xorriso_node_from_path(xorriso, volume, iso_adr, &node, 1);
|
|
if(ret<=0)
|
|
return(-1);
|
|
}
|
|
if(!LIBISO_ISDIR(node))
|
|
return(0);
|
|
dir_node= (IsoDir *) node;
|
|
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0) {
|
|
cannot_iter:;
|
|
Xorriso_cannot_create_iter(xorriso, ret, 0);
|
|
return(-1);
|
|
}
|
|
|
|
for(i= 0; iso_dir_iter_next(iter, &node) == 1; i++) {
|
|
name= (char *) iso_node_get_name(node);
|
|
ret= Splitpart__parse(name, &partno, &total_parts,
|
|
&offset, &bytes, &total_bytes, 0);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
if(i==0) {
|
|
first_total_parts= total_parts;
|
|
first_bytes= bytes;
|
|
first_total_bytes= total_bytes;
|
|
Xorriso_fake_stbuf(xorriso, "", &first_stbuf, &node, 1);
|
|
size= first_stbuf.st_size;
|
|
} else {
|
|
if(first_total_parts!=total_parts || first_total_bytes!=total_bytes ||
|
|
(first_bytes!=bytes && partno!=total_parts))
|
|
{ret= 0; goto ex;}
|
|
Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
|
|
if(first_stbuf.st_mode != stbuf.st_mode ||
|
|
first_stbuf.st_uid != stbuf.st_uid ||
|
|
first_stbuf.st_gid != stbuf.st_gid ||
|
|
first_stbuf.st_mtime != stbuf.st_mtime ||
|
|
first_stbuf.st_ctime != stbuf.st_ctime)
|
|
{ret= 0; goto ex;}
|
|
size= stbuf.st_size;
|
|
}
|
|
/* check for plausible size */
|
|
if(!((partno<total_parts && size==bytes) ||
|
|
(partno==total_parts && size<=bytes)))
|
|
{ret= 0; goto ex;}
|
|
(*count)++;
|
|
}
|
|
if((*count)<=0)
|
|
{ret= 0; goto ex;}
|
|
|
|
ret= Splitparts_new(parts, (*count)+1, 0); /* (have one end marker item) */
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
iso_dir_iter_free(iter);
|
|
ret= iso_dir_get_children(dir_node, &iter);
|
|
if(ret<0)
|
|
goto cannot_iter;
|
|
for(i= 0; i<*count; i++) {
|
|
ret= iso_dir_iter_next(iter, &node);
|
|
if(ret!=1)
|
|
break;
|
|
name= (char *) iso_node_get_name(node);
|
|
ret= Splitpart__parse(name, &partno, &total_parts,
|
|
&offset, &bytes, &total_bytes, 0);
|
|
if(ret<=0)
|
|
{ret= 0; goto ex;}
|
|
ret= Splitparts_set(*parts, i, name, partno, total_parts, offset, bytes,
|
|
total_bytes, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
|
|
Splitparts_sort(*parts, *count, 0);
|
|
|
|
covered= 0;
|
|
for(i= 0; i<*count; i++) {
|
|
Splitparts_get(*parts, i, &name, &partno, &total_parts, &offset, &bytes,
|
|
&total_bytes, 0);
|
|
if(offset>covered)
|
|
incomplete= 1;
|
|
else if(offset<covered)
|
|
overlapping= 1;
|
|
if(offset+bytes > covered)
|
|
covered= offset+bytes;
|
|
}
|
|
if(total_bytes>covered)
|
|
incomplete= 1;
|
|
memcpy(total_stbuf, &first_stbuf, sizeof(struct stat));
|
|
total_stbuf->st_size= total_bytes;
|
|
ret= !(overlapping || ((flag&2)&&incomplete));
|
|
ex:;
|
|
if(iter!=NULL)
|
|
iso_dir_iter_free(iter);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @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)
|
|
{
|
|
struct SplitparT *split_parts= NULL;
|
|
int split_count= 0, ret;
|
|
struct stat stbuf;
|
|
|
|
ret= Xorriso_identify_split(xorriso, path, node, &split_parts,
|
|
&split_count, &stbuf, flag & 3);
|
|
if(split_parts!=NULL)
|
|
Splitparts_destroy(&split_parts, split_count, 0);
|
|
return(ret>0);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= grow_overwriteable_iso
|
|
bit1= obtain info from outdev
|
|
*/
|
|
int Xorriso_msinfo(struct XorrisO *xorriso, int *msc1, int *msc2, int flag)
|
|
{
|
|
int ret, dummy;
|
|
struct burn_drive *drive;
|
|
struct burn_drive_info *dinfo;
|
|
enum burn_disc_status disc_state;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to obtain msinfo", flag&2);
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
if(flag&1)
|
|
disc_state= isoburn_disc_get_status(drive);
|
|
else
|
|
disc_state= burn_disc_get_status(drive);
|
|
if(disc_state != BURN_DISC_APPENDABLE) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"%s media is not appendable. Cannot obtain -msinfo.",
|
|
(flag&2) ? "Output" : "Input");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
ret= isoburn_disc_get_msc1(drive, msc1);
|
|
if(ret<=0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text, "Cannot obtain address of most recent session");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
ret= isoburn_disc_track_lba_nwa(drive, NULL, 0, &dummy, msc2);
|
|
if(ret<0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text, "Cannot obtain next writeable address on media");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
/* @param flag bit0= this is a follow-up session (i.e. on CD: TAO)
|
|
bit1= no pacifier messages
|
|
bit2= compute stream MD5 and look out for checksum tag
|
|
@return <=0 error, 1= done, 2= aborted due to limit
|
|
*/
|
|
int Xorriso_check_interval(struct XorrisO *xorriso, struct SpotlisT *spotlist,
|
|
struct CheckmediajoB *job,
|
|
int from_lba, int block_count, int read_chunk,
|
|
int md5_start, int flag)
|
|
{
|
|
int i, j, ret, total_count= 0, sectors= -1, sector_size= -1, skip_reading;
|
|
int prev_quality= -1, quality= -1, retry= 0, profile_no, is_cd= 0;
|
|
int start_sec, end_sec, first_value, fret;
|
|
char profile_name[80];
|
|
int start_lba= 0;
|
|
struct burn_drive *drive;
|
|
struct burn_drive_info *dinfo;
|
|
char data[64*1024], sfe[5*SfileadrL];
|
|
off_t data_count, to_read, read_count= 0, write_amount;
|
|
double pre_read_time, post_read_time, time_diff, total_time_diff= 0;
|
|
double last_abort_file_time= 0;
|
|
struct stat stbuf;
|
|
void *ctx= NULL, *cloned_ctx= NULL;
|
|
char md5[16], tag_md5[16];
|
|
uint32_t pos, range_start, range_size, next_tag= 0, lba, md5_spot_lba= 0;
|
|
int md5_spot_value= Xorriso_read_quality_untesteD, chain_broken= 0;
|
|
int tag_type= 0, valid, was_sb_tag= 0, in_track_gap= 0;
|
|
char *comparison= "", *sev_text= "DEBUG", *tag_type_name= "";
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to check media readability",
|
|
2 * !!job->use_dev);
|
|
if(ret<=0)
|
|
goto ex;
|
|
ret= burn_disc_get_profile(drive, &profile_no, profile_name);
|
|
if(ret > 0)
|
|
if(profile_no >= 0x08 && profile_no <= 0x0a)
|
|
is_cd= 1;
|
|
|
|
if(job->sector_map != NULL) {
|
|
Sectorbitmap_get_layout(job->sector_map, §ors, §or_size, 0);
|
|
sector_size/= 2048;
|
|
}
|
|
|
|
if(job->retry > 0)
|
|
retry= 1;
|
|
else if(job->retry == 0 && is_cd)
|
|
retry= 1;
|
|
|
|
if(flag & 4) {
|
|
ret= iso_md5_start(&ctx);
|
|
if(ret < 0) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
}
|
|
|
|
start_lba= from_lba;
|
|
to_read= read_chunk;
|
|
post_read_time= Sfile_microtime(0);
|
|
for(i= 0; i < block_count; i+= to_read) {
|
|
skip_reading= 0;
|
|
|
|
if(job->abort_file_path[0]) {
|
|
if(post_read_time - last_abort_file_time >= 0.1) {
|
|
if(stat(job->abort_file_path, &stbuf) != -1) {
|
|
if(stbuf.st_mtime >= xorriso->start_time) {
|
|
sprintf(xorriso->info_text,
|
|
"-check_media: Found fresh abort_file=%s",
|
|
job->abort_file_path);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
goto abort_check;
|
|
}
|
|
}
|
|
last_abort_file_time= post_read_time;
|
|
}
|
|
}
|
|
if(job->item_limit > 0 &&
|
|
Spotlist_count(spotlist, 0) + 2 >= job->item_limit) {
|
|
sprintf(xorriso->info_text, "-check_media: Reached item_limit=%d",
|
|
job->item_limit);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
goto abort_check;
|
|
}
|
|
pre_read_time= Sfile_microtime(0);
|
|
if(job->time_limit > 0
|
|
&& job->start_time + job->time_limit < pre_read_time) {
|
|
sprintf(xorriso->info_text, "-check_media: Reached time_limit=%d",
|
|
job->time_limit);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
abort_check:;
|
|
if(prev_quality >= 0) {
|
|
ret= Spotlist_add_item(spotlist, start_lba, i + from_lba - start_lba,
|
|
prev_quality, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
ret= Spotlist_add_item(spotlist, i + from_lba, block_count - i,
|
|
Xorriso_read_quality_untesteD, 0);
|
|
if(ret > 0)
|
|
ret= 2;
|
|
goto ex;
|
|
}
|
|
|
|
to_read= read_chunk;
|
|
if(i + to_read > block_count)
|
|
to_read= block_count - i;
|
|
if(is_cd && i + to_read + 2 >= block_count) {
|
|
/* Read last 2 blocks of CD track separately, because with TAO tracks
|
|
they are always unreadable but with SAO tracks they contain data.
|
|
*/
|
|
if(to_read > 2)
|
|
to_read-= 2;
|
|
else if(to_read > 1) {
|
|
if(flag & 1) {
|
|
quality= Xorriso_read_quality_tao_enD;
|
|
skip_reading= 1;
|
|
} else
|
|
to_read--;
|
|
}
|
|
}
|
|
|
|
if(sector_size == read_chunk && from_lba % read_chunk == 0
|
|
&& !skip_reading) {
|
|
if(Sectorbitmap_is_set(job->sector_map, (i + from_lba) / sector_size, 0)){
|
|
quality= Xorriso_read_quality_valiD;
|
|
skip_reading= 1;
|
|
}
|
|
} else if(sector_size > 0 && !skip_reading) {
|
|
start_sec= (i + from_lba) / sector_size;
|
|
end_sec= (i + to_read + from_lba) / sector_size;
|
|
first_value= Sectorbitmap_is_set(job->sector_map, start_sec, 0);
|
|
for(j= start_sec; j < end_sec; j++)
|
|
if(Sectorbitmap_is_set(job->sector_map, j, 0) != first_value)
|
|
break;
|
|
to_read= j * sector_size - i - from_lba;
|
|
skip_reading= !!first_value;
|
|
if(skip_reading)
|
|
quality= Xorriso_read_quality_valiD;
|
|
}
|
|
|
|
if(skip_reading) {
|
|
pre_read_time= post_read_time= Sfile_microtime(0);
|
|
} else {
|
|
data_count= 0;
|
|
pre_read_time= Sfile_microtime(0);
|
|
ret= burn_read_data(drive, ((off_t) (i + from_lba)) * (off_t) 2048, data,
|
|
to_read * (off_t) 2048, &data_count, 4 * !retry);
|
|
post_read_time= Sfile_microtime(0);
|
|
time_diff= post_read_time - pre_read_time;
|
|
total_time_diff+= time_diff;
|
|
total_count++;
|
|
if(ret <= 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(data_count / 2048 < to_read) {
|
|
if(data_count > 0 && retry) {
|
|
if(prev_quality >= 0) {
|
|
ret= Spotlist_add_item(spotlist, start_lba,
|
|
i + from_lba - start_lba, prev_quality, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
ret= Spotlist_add_item(spotlist, i + from_lba, data_count / 2048,
|
|
Xorriso_read_quality_partiaL, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
start_lba= i + from_lba + data_count / 2048;
|
|
prev_quality= Xorriso_read_quality_unreadablE;
|
|
}
|
|
quality= Xorriso_read_quality_unreadablE;
|
|
if(retry)
|
|
to_read= data_count / 2048 + 1;
|
|
} else
|
|
quality= Xorriso_read_quality_partiaL;
|
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
|
|
if(fret<0)
|
|
goto ex;
|
|
} else {
|
|
quality= Xorriso_read_quality_gooD;
|
|
|
|
/* >>> find better threshold than 1.0 */
|
|
|
|
if(time_diff > 1.0 && i > 0)
|
|
quality= Xorriso_read_quality_sloW;
|
|
}
|
|
|
|
/* MD5 checksumming */
|
|
if(ctx != NULL) {
|
|
for(j= 0; j < to_read; j++) {
|
|
lba= i + j + from_lba;
|
|
if(lba < md5_start)
|
|
continue;
|
|
ret= 0;
|
|
if(lba > md5_start + 16 &&
|
|
(next_tag == 0 || chain_broken || lba == next_tag)) {
|
|
ret= iso_util_decode_md5_tag(data + j * 2048, &tag_type,
|
|
&pos, &range_start, &range_size,
|
|
&next_tag, tag_md5, !!chain_broken);
|
|
}
|
|
valid= (ret == 1 || ret == ISO_MD5_AREA_CORRUPTED) && pos == lba;
|
|
if(valid && tag_type == 2 && (lba < md5_start + 32 || in_track_gap)) {
|
|
tag_type_name= "superblock";
|
|
was_sb_tag= 1;
|
|
if(in_track_gap && range_start != md5_start && range_start < lba &&
|
|
lba - range_start <= j) {
|
|
/* Looking for next session : start computing in hindsight.
|
|
Session start and superblock tag are supposed to be in the
|
|
same 64 kB chunk.
|
|
*/
|
|
iso_md5_end(&ctx, md5);
|
|
ret= iso_md5_start(&ctx);
|
|
if(ret < 0) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
iso_md5_compute(&ctx, data + (j - (lba - range_start)) * 2048,
|
|
(lba - range_start) * 2048);
|
|
md5_start= range_start;
|
|
in_track_gap= 0;
|
|
}
|
|
} else if(valid && tag_type == 4 && lba < 32) {
|
|
tag_type_name= "relocated 64kB superblock";
|
|
}else if(valid && tag_type == 3 && was_sb_tag) {
|
|
tag_type_name= "tree";
|
|
}else if(valid && tag_type == 1) {
|
|
|
|
/* >>> ??? allow this without superblock and tree tag ? */
|
|
|
|
tag_type_name= "session";
|
|
} else {
|
|
tag_type_name= "";
|
|
}
|
|
if (tag_type_name[0]) {
|
|
if(range_start != md5_start) {
|
|
sprintf(xorriso->info_text,
|
|
"Found MD5 %s tag which covers different data range",
|
|
tag_type_name);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE",0);
|
|
sprintf(xorriso->info_text,
|
|
" Expected: %u Found: %u",
|
|
(unsigned int) md5_start, range_start);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE",0);
|
|
chain_broken= 1;
|
|
valid= 0;
|
|
} else {
|
|
ret= iso_md5_clone(ctx, &cloned_ctx);
|
|
if(ret <= 0) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
iso_md5_end(&cloned_ctx, md5);
|
|
|
|
if(ret == ISO_MD5_AREA_CORRUPTED) {
|
|
comparison= "CORRUPTED";
|
|
sev_text= "WARNING";
|
|
md5_spot_value= Xorriso_read_quality_md5_mismatcH;
|
|
chain_broken= 1;
|
|
} else if(! iso_md5_match(tag_md5, md5)) {
|
|
comparison= "NON-MATCHING";
|
|
sev_text= "WARNING";
|
|
md5_spot_value= Xorriso_read_quality_md5_mismatcH;
|
|
chain_broken= 1;
|
|
} else {
|
|
comparison= "matching";
|
|
sev_text= "UPDATE";
|
|
md5_spot_value= Xorriso_read_quality_md5_matcH;
|
|
}
|
|
md5_spot_lba= lba;
|
|
sprintf(xorriso->info_text,
|
|
"Found %s MD5 %s tag: start=%d size=%d",
|
|
comparison, tag_type_name, md5_start, lba - md5_start);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
|
|
sev_text, 0);
|
|
}
|
|
if(valid && (tag_type == 1 ||
|
|
(tag_type == 4 && pos == lba && lba < 32))) {
|
|
if(md5_spot_value != Xorriso_read_quality_untesteD) {
|
|
ret= Spotlist_add_item(spotlist, md5_start,
|
|
md5_spot_lba - md5_start, md5_spot_value, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
md5_spot_value= Xorriso_read_quality_untesteD;
|
|
md5_start = lba + 1;
|
|
if (md5_start % 32)
|
|
md5_start= md5_start + (32 - (md5_start % 32));
|
|
next_tag= 0;
|
|
|
|
iso_md5_end(&ctx, md5);
|
|
ret= iso_md5_start(&ctx);
|
|
if(ret < 0) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
if(tag_type == 1)
|
|
in_track_gap= 1;
|
|
continue;
|
|
}
|
|
}
|
|
iso_md5_compute(ctx, data + j * 2048, 2048);
|
|
}
|
|
}
|
|
|
|
write_amount= data_count;
|
|
if(data_count > 0) {
|
|
read_count+= data_count;
|
|
if(job->data_to_limit >= 0 && read_count > job->data_to_limit)
|
|
write_amount-= (read_count - job->data_to_limit);
|
|
}
|
|
if(write_amount > 0) {
|
|
if(job->data_to_fd >= 0) {
|
|
ret= lseek(job->data_to_fd,
|
|
((off_t) (i + from_lba)) * (off_t) 2048 + job->data_to_offset,
|
|
SEEK_SET);
|
|
if(ret == -1) {
|
|
failed_to_write:;
|
|
sprintf(xorriso->info_text, "Cannot write %d bytes to lba %d of %s",
|
|
(int) data_count, i + from_lba,
|
|
Text_shellsafe(job->data_to_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno,
|
|
"FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
ret= write(job->data_to_fd, data, write_amount);
|
|
if(ret == -1)
|
|
goto failed_to_write;
|
|
}
|
|
}
|
|
}
|
|
if(quality != prev_quality) {
|
|
if(prev_quality >= 0) {
|
|
ret= Spotlist_add_item(spotlist, start_lba, i + from_lba - start_lba,
|
|
prev_quality, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
start_lba= i + from_lba;
|
|
prev_quality= quality;
|
|
}
|
|
if(!(flag & 2)) {
|
|
xorriso->pacifier_count+= to_read;
|
|
if(post_read_time - xorriso->last_update_time >=
|
|
xorriso->pacifier_interval)
|
|
Xorriso_pacifier_callback(xorriso, "sectors examined",
|
|
xorriso->pacifier_count, xorriso->pacifier_total, "", 0);
|
|
}
|
|
}
|
|
if(prev_quality >= 0) {
|
|
ret= Spotlist_add_item(spotlist, start_lba,
|
|
block_count + from_lba - start_lba, prev_quality, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
|
|
/* <<< for calibration of quality */
|
|
if(total_count > 0) {
|
|
sprintf(xorriso->info_text, "Xorriso_check_interval: %.1f s / %d = %f",
|
|
total_time_diff, total_count, total_time_diff / total_count);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
}
|
|
|
|
|
|
/* MD5 checksumming : register result */
|
|
|
|
/* >>> ??? allow chain_broken to be a match ? */
|
|
|
|
if(next_tag > 0) {
|
|
sprintf(xorriso->info_text, "Missing announced MD5 tag: start=%d pos=%d",
|
|
md5_start, next_tag);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
md5_spot_value= Xorriso_read_quality_md5_mismatcH;
|
|
md5_spot_lba= next_tag;
|
|
}
|
|
if(md5_spot_value != Xorriso_read_quality_untesteD) {
|
|
ret= Spotlist_add_item(spotlist, md5_start, md5_spot_lba - md5_start,
|
|
md5_spot_value, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
|
|
ret= 1;
|
|
ex:
|
|
if(ctx != NULL)
|
|
iso_md5_end(&ctx, md5);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_check_media(struct XorrisO *xorriso, struct SpotlisT **spotlist,
|
|
struct CheckmediajoB *job, int flag)
|
|
{
|
|
int media_blocks= 0, read_chunk= 16, ret, mode, start_lba= 0;
|
|
int blocks, os_errno, i, j, last_track_end= -1, track_blocks, track_lba;
|
|
int num_sessions, num_tracks, declare_untested= 0, md5_start;
|
|
char *toc_info= NULL;
|
|
struct burn_drive *drive;
|
|
struct burn_drive_info *dinfo;
|
|
struct isoburn_toc_disc *isoburn_disc= NULL;
|
|
struct isoburn_toc_session **isoburn_sessions;
|
|
struct isoburn_toc_track **iso_burn_tracks;
|
|
struct burn_toc_entry isoburn_entry;
|
|
struct stat stbuf;
|
|
struct burn_multi_caps *caps= NULL;
|
|
|
|
*spotlist= NULL;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to check media readability",
|
|
2 * !!job->use_dev);
|
|
if(ret<=0)
|
|
goto ex;
|
|
|
|
/* >>> determine media type dependent blocking factor:
|
|
32 kB for CD (with 2kB retry) and DVD, 64 kB for BD
|
|
eventually adjust read_chunk
|
|
*/;
|
|
|
|
ret= Spotlist_new(spotlist, 0);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
|
|
if(job->sector_map_path[0]) {
|
|
Sectorbitmap_destroy(&(job->sector_map), 0);
|
|
if(stat(job->sector_map_path, &stbuf) != -1) {
|
|
ret= Sectorbitmap_from_file(&(job->sector_map), job->sector_map_path,
|
|
xorriso->info_text, &os_errno, 0);
|
|
if(ret <= 0) {
|
|
if(xorriso->info_text[0])
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, os_errno,
|
|
"FAILURE", 0);
|
|
goto ex;
|
|
}
|
|
}
|
|
Xorriso_toc_to_string(xorriso, &toc_info, 4 * !job->map_with_volid);
|
|
}
|
|
ret= Xorriso_open_job_data_to(xorriso, job, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
Xorriso_pacifier_reset(xorriso, 0);
|
|
job->start_time= time(NULL);
|
|
mode= job->mode;
|
|
if(job->min_lba > 0) {
|
|
start_lba= job->min_lba;
|
|
ret= Spotlist_add_item(*spotlist, 0, job->min_lba,
|
|
Xorriso_read_quality_untesteD, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
if(job->max_lba >= 0) {
|
|
blocks= job->max_lba + 1 - start_lba;
|
|
xorriso->pacifier_total= blocks;
|
|
ret= Xorriso_check_interval(xorriso, *spotlist, job, start_lba, blocks,
|
|
read_chunk, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
|
|
} else if(mode == 0) { /* track by track */
|
|
isoburn_disc= isoburn_toc_drive_get_disc(drive);
|
|
if(isoburn_disc == NULL)
|
|
goto no_content_visible;
|
|
isoburn_sessions=
|
|
isoburn_toc_disc_get_sessions(isoburn_disc, &num_sessions);
|
|
for(i= 0; i < num_sessions; i++) {
|
|
iso_burn_tracks= isoburn_toc_session_get_tracks(isoburn_sessions[i],
|
|
&num_tracks);
|
|
for(j= 0; j < num_tracks; j++) {
|
|
isoburn_toc_track_get_entry(iso_burn_tracks[j], &isoburn_entry);
|
|
if(!(isoburn_entry.extensions_valid & 1)) /* should not happen */
|
|
continue;
|
|
track_lba= isoburn_entry.start_lba;
|
|
track_blocks= isoburn_entry.track_blocks;
|
|
md5_start= track_lba;
|
|
if(i == 0 && j == 0) {
|
|
if(track_lba == 32) {
|
|
ret= burn_disc_get_multi_caps(drive, BURN_WRITE_NONE, &caps, 0);
|
|
if(ret > 0) {
|
|
if(caps->start_adr) {
|
|
/* block 0 to 31 are the overall mount entry of overwriteable */
|
|
track_lba= 0;
|
|
track_blocks+= 32;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(last_track_end >= 0 && last_track_end < track_lba &&
|
|
last_track_end >= start_lba) {
|
|
ret= Spotlist_add_item(*spotlist, last_track_end,
|
|
track_lba - last_track_end,
|
|
Xorriso_read_quality_off_tracK, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
xorriso->pacifier_count+= track_lba - last_track_end;
|
|
}
|
|
last_track_end= track_lba + track_blocks;
|
|
|
|
if(track_lba < start_lba) {
|
|
track_blocks-= start_lba - track_lba;
|
|
track_lba= start_lba;
|
|
}
|
|
if(track_blocks <= 0)
|
|
continue;
|
|
if(declare_untested) {
|
|
ret= Spotlist_add_item(*spotlist, track_lba, track_blocks,
|
|
Xorriso_read_quality_untesteD, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
} else {
|
|
ret= Xorriso_check_interval(xorriso, *spotlist, job, track_lba,
|
|
track_blocks, read_chunk, md5_start,
|
|
(i > 0) | (4 * (xorriso->do_md5 & 1)));
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(ret == 2)
|
|
declare_untested= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if(mode == 1) { /* isoburn disc capacity */
|
|
isoburn_disc= isoburn_toc_drive_get_disc(drive);
|
|
if(isoburn_disc == NULL) {
|
|
no_content_visible:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text, "No content detected on media");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
{ret= 0; goto ex;}
|
|
}
|
|
blocks= media_blocks= isoburn_toc_disc_get_sectors(isoburn_disc);
|
|
if(start_lba >= 0)
|
|
blocks-= start_lba;
|
|
if(media_blocks <= 0)
|
|
goto no_content_visible;
|
|
xorriso->pacifier_total= blocks;
|
|
ret= Xorriso_check_interval(xorriso, *spotlist, job, start_lba, blocks,
|
|
read_chunk, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
} else if(mode == 2) {
|
|
|
|
/* >>> single sweep over libburn media capacity */;
|
|
|
|
}
|
|
|
|
Xorriso_pacifier_callback(xorriso, "sectors examined",
|
|
xorriso->pacifier_count, xorriso->pacifier_total, "", 1);
|
|
ret= 1;
|
|
ex:;
|
|
|
|
if(job->data_to_fd != -1)
|
|
close(job->data_to_fd);
|
|
job->data_to_fd= -1;
|
|
|
|
if(ret > 0)
|
|
ret= Xorriso_update_in_sector_map(xorriso, *spotlist, read_chunk, job, 0);
|
|
|
|
if(ret > 0) {
|
|
ret= Xorriso_spotlist_to_sectormap(xorriso, *spotlist, read_chunk,
|
|
&(job->sector_map), 0);
|
|
if(ret > 0 && job->sector_map_path[0]) {
|
|
ret= Sectorbitmap_to_file(job->sector_map, job->sector_map_path, toc_info,
|
|
xorriso->info_text, &os_errno, 0);
|
|
if(ret <= 0) {
|
|
if(xorriso->info_text[0])
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, os_errno,
|
|
"FAILURE", 0);
|
|
}
|
|
}
|
|
}
|
|
if(toc_info != NULL)
|
|
free(toc_info);
|
|
if(ret <= 0)
|
|
Spotlist_destroy(spotlist, 0);
|
|
if(caps!=NULL)
|
|
burn_disc_free_multi_caps(&caps);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit1= for Xorriso_check_interval(): no pacifier messages
|
|
*/
|
|
int Xorriso_read_file_data(struct XorrisO *xorriso, IsoNode *node,
|
|
char *img_path, char *disk_path,
|
|
off_t img_offset, off_t disk_offset,
|
|
off_t bytes, int flag)
|
|
{
|
|
int ret, i, lba_count= 0, *start_lbas= NULL, *end_lbas= NULL, read_chunk= 16;
|
|
int lba, count, blocks, quality, spot, bad_extract= 0;
|
|
off_t size= 0, file_base_bytes= 0, file_processed_bytes= 0, img_adr;
|
|
off_t new_file_base_bytes, upto_file_bytes, start_byte= 0;
|
|
char sfe[5*SfileadrL];
|
|
struct SpotlisT *spotlist= NULL;
|
|
struct CheckmediajoB *job= NULL;
|
|
|
|
upto_file_bytes= img_offset + bytes;
|
|
|
|
/* >>> make Xorriso_check_interval() ready for copying in byte granularity */
|
|
if(img_offset % (off_t) 2048) {
|
|
sprintf(xorriso->info_text,
|
|
"Image address offset is not a multiple of 2048");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
ret= Xorriso__start_end_lbas(node, &lba_count, &start_lbas, &end_lbas, &size,
|
|
0);
|
|
if(ret <= 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
sprintf(xorriso->info_text,
|
|
"File object %s is currently not a data file from the loaded image",
|
|
Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
goto ex;
|
|
}
|
|
if(img_offset + bytes < size && bytes > 0)
|
|
size= img_offset + bytes;
|
|
|
|
ret= Checkmediajob_new(&job, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(xorriso->check_media_default != NULL)
|
|
Checkmediajob_copy(xorriso->check_media_default, job, 0);
|
|
job->min_lba= -1;
|
|
job->max_lba= -1;
|
|
job->sector_map_path[0]= 0;
|
|
|
|
ret= Spotlist_new(&spotlist, 0);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
|
|
if(Sfile_str(job->data_to_path, disk_path, 0) <= 0)
|
|
{ret= -1; goto ex;}
|
|
Xorriso_open_job_data_to(xorriso, job, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
|
|
for(i= 0; i < lba_count && file_base_bytes < upto_file_bytes; i++) {
|
|
lba= start_lbas[i];
|
|
count= end_lbas[i] + 1 - start_lbas[i];
|
|
new_file_base_bytes= file_base_bytes + ((off_t) count) * (off_t) 2048;
|
|
|
|
/* skip intervals before img_offset */
|
|
if(new_file_base_bytes <= img_offset) {
|
|
file_base_bytes= new_file_base_bytes;
|
|
continue;
|
|
}
|
|
/* Eventually adjust first interval start */
|
|
img_adr= ((off_t) lba) * (off_t) 2048;
|
|
if(file_base_bytes < img_offset) {
|
|
img_adr+= img_offset - file_base_bytes;
|
|
lba= img_adr / (off_t) 2048;
|
|
count= end_lbas[i] + 1 - lba;
|
|
file_base_bytes= img_offset;
|
|
}
|
|
|
|
/* Eventually omit surplus blocks */
|
|
if(new_file_base_bytes > upto_file_bytes)
|
|
count-= (new_file_base_bytes - upto_file_bytes) / (off_t) 2048;
|
|
/* Adjust job */
|
|
job->data_to_offset= file_processed_bytes - img_adr + disk_offset;
|
|
job->data_to_limit= size - file_base_bytes;
|
|
|
|
file_processed_bytes+= ((off_t) count) * (off_t) 2048;
|
|
ret= Xorriso_check_interval(xorriso, spotlist, job, lba, count, read_chunk,
|
|
0, (flag & 2));
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if (ret == 2) {
|
|
sprintf(xorriso->info_text, "Attempt aborted to extract data from %s",
|
|
Text_shellsafe(img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
file_base_bytes= new_file_base_bytes;
|
|
}
|
|
|
|
/* Use spotlist to evaluate damage */
|
|
file_base_bytes= 0;
|
|
count= Spotlist_count(spotlist, 0);
|
|
for(spot= 0; spot < count; spot++) {
|
|
ret= Spotlist_get_item(spotlist, spot, &lba, &blocks, &quality, 0);
|
|
if(ret <= 0)
|
|
continue;
|
|
if(quality < Xorriso_read_quality_valiD) {
|
|
for(i= 0; i < lba_count; i++) {
|
|
if(start_lbas[i] <= lba && end_lbas[i] >= lba) {
|
|
start_byte= (lba - start_lbas[i]) * (off_t) 2048 + file_base_bytes;
|
|
break;
|
|
}
|
|
file_base_bytes+= ((off_t) (end_lbas[i] + 1 - start_lbas[i]))
|
|
* (off_t) 2048;
|
|
}
|
|
if(i < lba_count) {
|
|
sprintf(xorriso->info_text, "Bad extract : %14.f , %14.f , %s\n",
|
|
(double) start_byte, ((double) blocks) * 2048.0,
|
|
Text_shellsafe(disk_path, sfe, 0));
|
|
Xorriso_info(xorriso, 0);
|
|
bad_extract= 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
ret= !bad_extract;
|
|
ex:;
|
|
if(start_lbas != NULL)
|
|
free((char *) start_lbas);
|
|
if(end_lbas != NULL)
|
|
free((char *) end_lbas);
|
|
Spotlist_destroy(&spotlist, 0);
|
|
Checkmediajob_destroy(&job, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_extract_cut(struct XorrisO *xorriso,
|
|
char *img_path, char *disk_path,
|
|
off_t img_offset, off_t bytes, int flag)
|
|
{
|
|
int ret, stbuf_ret, read_raw;
|
|
double mem_lut= 0.0;
|
|
char eff_img_path[SfileadrL], eff_disk_path[SfileadrL], sfe[SfileadrL*5];
|
|
IsoImage *volume;
|
|
IsoNode *node;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi,
|
|
img_path, eff_img_path, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_node_from_path(xorriso, volume, eff_img_path, &node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx,
|
|
disk_path, eff_disk_path, 2 | 4);
|
|
if(ret<=0)
|
|
return(ret);
|
|
Xorriso_pacifier_reset(xorriso, 0);
|
|
mem_lut= xorriso->last_update_time;
|
|
|
|
ret= Xorriso_handle_collision(xorriso, node, img_path, eff_disk_path,
|
|
disk_path, &stbuf_ret, 0);
|
|
if(ret<=0 || ret==3)
|
|
return(0);
|
|
|
|
/* If it is a non-filtered stream from the ISO image
|
|
and img_offset is a multiple of 2048
|
|
then use Xorriso_read_file_data() for random access offset.
|
|
*/
|
|
if(!LIBISO_ISREG(node)) {
|
|
Xorriso_msgs_submit(xorriso, 0, eff_disk_path, 0, "ERRFILE", 0);
|
|
sprintf(xorriso->info_text, "-extract_cut: ISO file %s is not a data file",
|
|
Text_shellsafe(eff_img_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
read_raw= 0;
|
|
if((img_offset % 2048) == 0) {
|
|
ret= Xorriso_is_plain_image_file(xorriso, node, 0);
|
|
if(ret > 0)
|
|
read_raw= 1;
|
|
}
|
|
if (read_raw) {
|
|
ret= Xorriso_read_file_data(xorriso, node, eff_img_path, eff_disk_path,
|
|
img_offset, (off_t) 0, bytes, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
} else {
|
|
ret= Xorriso_tree_restore_node(xorriso, node, eff_img_path, img_offset,
|
|
eff_disk_path, (off_t) 0, bytes, 2 | 8);
|
|
if(ret<=0)
|
|
return(ret);
|
|
}
|
|
|
|
ret= Xorriso_restore_properties(xorriso, eff_disk_path, node, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
|
|
if(mem_lut != xorriso->last_update_time)
|
|
Xorriso_pacifier_callback(xorriso, "sectors examined",
|
|
xorriso->pacifier_count, 0, "", 1);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_get_local_charset(struct XorrisO *xorriso, char **name, int flag)
|
|
{
|
|
(*name)= iso_get_local_charset(0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_set_local_charset(struct XorrisO *xorriso, char *name, int flag)
|
|
{
|
|
int ret;
|
|
char *nl_charset, sfe[5 * SfileadrL];
|
|
iconv_t iconv_ret= (iconv_t) -1;
|
|
|
|
nl_charset= nl_langinfo(CODESET);
|
|
if(name == NULL)
|
|
name= nl_charset;
|
|
|
|
if(name != NULL) {
|
|
iconv_ret= iconv_open(nl_charset, name);
|
|
if(iconv_ret == (iconv_t) -1)
|
|
goto cannot;
|
|
else
|
|
iconv_close(iconv_ret);
|
|
}
|
|
ret= iso_set_local_charset(name, 0);
|
|
if(ret <= 0) {
|
|
cannot:;
|
|
sprintf(xorriso->info_text,
|
|
"-local_charset: Cannot assume as local character set: %s",
|
|
Text_shellsafe(name, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(0);
|
|
}
|
|
sprintf(xorriso->info_text, "Local character set is now assumed as: %s",
|
|
Text_shellsafe(name, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_relax_compliance(struct XorrisO *xorriso, char *mode,
|
|
int flag)
|
|
{
|
|
char *npt, *cpt;
|
|
int l, was;
|
|
|
|
was= xorriso->relax_compliance;
|
|
npt= cpt= mode;
|
|
for(; npt!=NULL; cpt= npt+1) {
|
|
npt= strchr(cpt,':');
|
|
if(npt==NULL)
|
|
l= strlen(cpt);
|
|
else
|
|
l= npt-cpt;
|
|
if(l == 0)
|
|
continue;
|
|
if((l == 6 && strncmp(cpt, "strict", l) == 0) ||
|
|
(l == 5 && strncmp(cpt, "clear", l) == 0)) {
|
|
xorriso->relax_compliance= 0;
|
|
} else if(l == 7 && strncmp(cpt, "default", l) == 0) {
|
|
xorriso->relax_compliance= Xorriso_relax_compliance_defaulT;
|
|
|
|
} else if((l == 12 && strncmp(cpt, "omit_version", l) == 0) ||
|
|
(l == 15 && strncmp(cpt, "omit_version_on", l) == 0) ) {
|
|
xorriso->relax_compliance|= isoburn_igopt_omit_version_numbers;
|
|
} else if((l == 16 && strncmp(cpt, "omit_version_off", l) == 0)) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_omit_version_numbers;
|
|
|
|
} else if((l == 10 && strncmp(cpt, "deep_paths", l) == 0) ||
|
|
(l == 13 && strncmp(cpt, "deep_paths_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_allow_deep_paths;
|
|
} else if(l == 14 && strncmp(cpt, "deep_paths_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_allow_deep_paths;
|
|
|
|
} else if((l == 10 && strncmp(cpt, "long_paths", l) == 0) ||
|
|
(l == 13 && strncmp(cpt, "long_paths_on", l) == 0) ) {
|
|
xorriso->relax_compliance|= isoburn_igopt_allow_longer_paths;
|
|
} else if(l == 14 && strncmp(cpt, "long_paths_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_allow_longer_paths;
|
|
|
|
} else if((l == 10 && strncmp(cpt, "long_names", l) == 0) ||
|
|
(l == 13 && strncmp(cpt, "long_names_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_max_37_char_filenames;
|
|
} else if(l == 14 && strncmp(cpt, "long_names_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_max_37_char_filenames;
|
|
|
|
} else if((l == 13 && strncmp(cpt, "no_force_dots", l) == 0) ||
|
|
(l == 16 && strncmp(cpt, "no_force_dots_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_no_force_dots;
|
|
} else if(l == 17 && strncmp(cpt, "no_force_dots_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_no_force_dots;
|
|
|
|
} else if((l == 9 && strncmp(cpt, "lowercase", l) == 0) ||
|
|
(l == 12 && strncmp(cpt, "lowercase_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_allow_lowercase;
|
|
} else if(l == 13 && strncmp(cpt, "lowercase_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_allow_lowercase;
|
|
|
|
} else if((l == 10 && strncmp(cpt, "full_ascii", l) == 0) ||
|
|
(l == 13 && strncmp(cpt, "full_ascii_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_allow_full_ascii;
|
|
} else if(l == 14 && strncmp(cpt, "full_ascii_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_allow_full_ascii;
|
|
|
|
} else if((l == 17 && strncmp(cpt, "joliet_long_paths", l) == 0) ||
|
|
(l == 20 && strncmp(cpt, "joliet_long_paths_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_joliet_longer_paths;
|
|
} else if(l == 21 && strncmp(cpt, "joliet_long_paths_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_joliet_longer_paths;
|
|
|
|
} else if((l == 10 && strncmp(cpt, "always_gmt", l) == 0) ||
|
|
(l == 13 && strncmp(cpt, "always_gmt_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_always_gmt;
|
|
} else if(l == 14 && strncmp(cpt, "always_gmt_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_always_gmt;
|
|
|
|
} else if((l == 9 && strncmp(cpt, "rec_mtime", l) == 0) ||
|
|
(l == 12 && strncmp(cpt, "rec_mtime_on", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_dir_rec_mtime;
|
|
} else if(l == 13 && strncmp(cpt, "rec_mtime_off", l) == 0) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_dir_rec_mtime;
|
|
|
|
} else if((l == 6 && strncmp(cpt, "old_rr", l) == 0) ||
|
|
(l == 9 && strncmp(cpt, "old_rr_on", l) == 0) ||
|
|
(l == 10 && strncmp(cpt, "new_rr_off", l) == 0)) {
|
|
xorriso->relax_compliance|=
|
|
isoburn_igopt_rrip_version_1_10 | isoburn_igopt_aaip_susp_1_10;
|
|
} else if((l == 10 && strncmp(cpt, "old_rr_off", l) == 0) ||
|
|
(l == 9 && strncmp(cpt, "new_rr_on", l) == 0) ||
|
|
(l == 6 && strncmp(cpt, "new_rr", l) == 0)) {
|
|
xorriso->relax_compliance&=
|
|
~(isoburn_igopt_rrip_version_1_10 | isoburn_igopt_aaip_susp_1_10);
|
|
|
|
} else if((l == 14 && strncmp(cpt, "aaip_susp_1_10", l) == 0) ||
|
|
(l == 17 && strncmp(cpt, "aaip_susp_1_10_on", l) == 0) ||
|
|
(l == 18 && strncmp(cpt, "aaip_susp_1_12_off", l) == 0)) {
|
|
xorriso->relax_compliance|= isoburn_igopt_aaip_susp_1_10;
|
|
} else if((l == 18 && strncmp(cpt, "aaip_susp_1_10_off", l) == 0) ||
|
|
(l == 17 && strncmp(cpt, "aaip_susp_1_12_on", l) == 0) ||
|
|
(l == 14 && strncmp(cpt, "aaip_susp_1_12", l) == 0)) {
|
|
xorriso->relax_compliance&= ~isoburn_igopt_aaip_susp_1_10;
|
|
|
|
} else if((l == 8 && strncmp(cpt, "iso_9660", l) == 0) ||
|
|
(l == 11 && strncmp(cpt, "iso_9660_on", l) == 0)) {
|
|
/* may have a meaning in future */;
|
|
} else if(l == 12 && strncmp(cpt, "iso_9660_off", l) == 0) {
|
|
/* may have a meaning in future */;
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"-compliance -iso_9660_off : Cannot do anything else but ISO 9660",
|
|
0, "FAILURE", 0);
|
|
|
|
} else {
|
|
if(l<SfileadrL)
|
|
sprintf(xorriso->info_text, "-compliance: unknown rule '%s'",
|
|
cpt);
|
|
else
|
|
sprintf(xorriso->info_text,
|
|
"-compliance: oversized rule parameter (%d)", l);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
xorriso->relax_compliance= was;
|
|
return(0);
|
|
}
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @return 1=ok 2=ok, is default setting */
|
|
int Xorriso_get_relax_text(struct XorrisO *xorriso, char mode[1024],
|
|
int flag)
|
|
{
|
|
int r;
|
|
|
|
r= xorriso->relax_compliance;
|
|
if(r == 0) {
|
|
strcpy(mode, "strict");
|
|
return(1);
|
|
}
|
|
strcpy(mode, "clear");
|
|
if(r & isoburn_igopt_omit_version_numbers)
|
|
strcat(mode, ":omit_version");
|
|
if(r & isoburn_igopt_allow_deep_paths)
|
|
strcat(mode, ":deep_paths");
|
|
if(r & isoburn_igopt_allow_longer_paths)
|
|
strcat(mode, ":long_paths");
|
|
if(r & isoburn_igopt_max_37_char_filenames)
|
|
strcat(mode, ":long_names");
|
|
if(r & isoburn_igopt_no_force_dots)
|
|
strcat(mode, ":no_force_dots");
|
|
if(r & isoburn_igopt_allow_lowercase)
|
|
strcat(mode, ":lowercase");
|
|
if(r & isoburn_igopt_allow_full_ascii)
|
|
strcat(mode, ":full_ascii");
|
|
if(r & isoburn_igopt_joliet_longer_paths)
|
|
strcat(mode, ":joliet_long_paths");
|
|
if(r & isoburn_igopt_always_gmt)
|
|
strcat(mode, ":always_gmt");
|
|
if(r & isoburn_igopt_dir_rec_mtime)
|
|
strcat(mode, ":rec_mtime");
|
|
if(r & isoburn_igopt_rrip_version_1_10) {
|
|
strcat(mode, ":old_rr");
|
|
if(!(r & isoburn_igopt_aaip_susp_1_10))
|
|
strcat(mode, ":aaip_susp_1_10_off");
|
|
} else {
|
|
strcat(mode, ":new_rr");
|
|
if(r & isoburn_igopt_aaip_susp_1_10)
|
|
strcat(mode, ":aaip_susp_1_10");
|
|
}
|
|
|
|
return(1 + (r == Xorriso_relax_compliance_defaulT));
|
|
}
|
|
|
|
|
|
/**
|
|
@param flag bit0= print mount command to result channel rather than
|
|
performing it
|
|
bit1= do not allow prefixes with cmd
|
|
bit2= interpret unprefixed cmd as shell:
|
|
*/
|
|
int Xorriso_mount(struct XorrisO *xorriso, char *dev, int adr_mode,
|
|
char *adr_value, char *cmd, int flag)
|
|
{
|
|
int ret, lba, track, session, params_flag= 0, is_safe= 0, is_extra_drive= 0;
|
|
int give_up= 0, mount_chardev= 0, status;
|
|
char volid[33], *devadr, mount_command[SfileadrL], adr_data[163], *adr_pt;
|
|
char *dev_path, libburn_adr[BURN_DRIVE_ADR_LEN + SfileadrL];
|
|
char sfe[5 * SfileadrL], *dpt, *sysname= "";
|
|
struct stat stbuf;
|
|
struct burn_drive_info *dinfo= NULL;
|
|
struct burn_drive *drive= NULL;
|
|
|
|
devadr= dev;
|
|
adr_pt= adr_value;
|
|
if(strcmp(dev, "indev") == 0) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to perform -mount \"indev\"", 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
dev_path= devadr= xorriso->indev;
|
|
if(strncmp(dev_path, "stdio:", 6) == 0)
|
|
dev_path+= 6;
|
|
if(xorriso->in_drive_handle == xorriso->out_drive_handle)
|
|
give_up= 3;
|
|
else
|
|
give_up= 1;
|
|
} else if(strcmp(dev, "outdev") == 0) {
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to perform -mount \"outdev\"",
|
|
2);
|
|
if(ret<=0)
|
|
goto ex;
|
|
dev_path= devadr= xorriso->outdev;
|
|
if(strncmp(dev_path, "stdio:", 6) == 0)
|
|
dev_path+= 6;
|
|
if(xorriso->in_drive_handle == xorriso->out_drive_handle)
|
|
give_up= 3;
|
|
else
|
|
give_up= 2;
|
|
} else {
|
|
is_extra_drive= 1;
|
|
dev_path= dev;
|
|
if(strncmp(dev_path, "stdio:", 6) == 0)
|
|
dev_path+= 6;
|
|
|
|
/* do only accept regular files and block devices */
|
|
ret= stat(dev_path, &stbuf);
|
|
if(ret == -1) {
|
|
sprintf(xorriso->info_text, "Cannot determine properties of file %s",
|
|
Text_shellsafe(dev_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
ret= System_uname(&sysname, NULL, NULL, NULL, 0);
|
|
if(ret > 0 && strcmp(sysname, "FreeBSD") == 0)
|
|
mount_chardev= 1;
|
|
if(!(S_ISREG(stbuf.st_mode) || (S_ISBLK(stbuf.st_mode) && !mount_chardev)
|
|
|| (S_ISCHR(stbuf.st_mode) && !mount_chardev))) {
|
|
sprintf(xorriso->info_text,
|
|
"File object is not suitable as mount device: %s",
|
|
Text_shellsafe(dev_path, sfe, 0));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
/* Aquire drive as direct libburn address or via stdio: prefix */
|
|
ret= burn_drive_convert_fs_adr(dev, libburn_adr);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret < 0)
|
|
{ret= -1; goto ex;}
|
|
if(ret == 0 && strncmp(dev, "stdio:", 6) != 0)
|
|
sprintf(libburn_adr, "stdio:%s", dev);
|
|
ret= isoburn_drive_aquire(&dinfo, libburn_adr, 1);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret <= 0)
|
|
{ret= 0; goto ex;}
|
|
drive= dinfo[0].drive;
|
|
}
|
|
|
|
if(adr_mode == 4 && strlen(adr_pt) <= 80) {
|
|
ret= Xorriso__bourne_to_reg(adr_pt, adr_data, 0);
|
|
if(ret == 1) {
|
|
params_flag|= 4;
|
|
adr_pt= adr_data;
|
|
}
|
|
}
|
|
ret= isoburn_get_mount_params(drive, adr_mode, adr_pt, &lba, &track,
|
|
&session, volid, params_flag);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(session <= 0 || track <= 0 || ret == 2) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"-mount : Given address does not point to an ISO 9660 session",
|
|
0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(strstr(devadr, "stdio:") == devadr)
|
|
devadr+= 6;
|
|
ret= Xorriso_make_mount_cmd(xorriso, cmd, lba, track, session, volid, devadr,
|
|
mount_command, flag & (2 | 4));
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(ret == 2)
|
|
is_safe= 1;
|
|
|
|
if(is_extra_drive) {
|
|
isoburn_drive_release(drive, 0);
|
|
burn_drive_info_free(dinfo);
|
|
drive= NULL;
|
|
} else if(give_up > 0 && !(flag & 1)) {
|
|
Xorriso_give_up_drive(xorriso, give_up);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
sprintf(xorriso->info_text, "Volume id : %s\n",
|
|
Text_shellsafe(volid, sfe, 0));
|
|
Xorriso_info(xorriso, 0);
|
|
if(flag & 1) {
|
|
sprintf(xorriso->result_line, "%s\n", mount_command);
|
|
Xorriso_result(xorriso,0);
|
|
} else {
|
|
sprintf(xorriso->info_text, "Mount command: %s\n", mount_command);
|
|
Xorriso_info(xorriso, 0);
|
|
if(!is_safe) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"-mount : Will not perform mount command which stems from command template.",
|
|
0, "SORRY", 0);
|
|
sprintf(xorriso->result_line, "%s\n", mount_command);
|
|
Xorriso_result(xorriso,0);
|
|
} else {
|
|
ret= Xorriso_execv(xorriso, mount_command, "/bin:/sbin", &status, 1);
|
|
if(WIFEXITED(status) && WEXITSTATUS(status) != 0) {
|
|
sprintf(xorriso->info_text,
|
|
"-mount : mount command failed with exit value %d",
|
|
(int) WEXITSTATUS(ret));
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
sprintf(xorriso->info_text, "\nMounted session %d of device %s",
|
|
session, Text_shellsafe(dev_path, sfe, 0));
|
|
dpt= strchr(cmd, ':');
|
|
if(dpt == NULL)
|
|
dpt= cmd ;
|
|
else
|
|
dpt++;
|
|
sprintf(xorriso->info_text + strlen(xorriso->info_text),
|
|
" as directory %s\n", Text_shellsafe(dpt, sfe, 0));
|
|
Xorriso_info(xorriso, 0);
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(is_extra_drive && drive != NULL) {
|
|
isoburn_drive_release(drive, 0);
|
|
burn_drive_info_free(dinfo);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_auto_driveadr(struct XorrisO *xorriso, char *adr, char *result,
|
|
int flag)
|
|
{
|
|
int ret, is_known_mmc= 0;
|
|
char *path_pt, libburn_adr[BURN_DRIVE_ADR_LEN + SfileadrL];
|
|
char *abs_pt, abs_adr[SfileadrL];
|
|
|
|
path_pt= adr;
|
|
if(strncmp(adr, "stdio:", 6) == 0)
|
|
path_pt= adr + 6;
|
|
else if(strncmp(adr, "mmc:", 4) == 0)
|
|
path_pt= adr + 4;
|
|
|
|
|
|
/* <<< replace by Xorriso_normalize_img_path() ? */;
|
|
|
|
if(path_pt[0] != '/') {
|
|
abs_pt= getcwd(abs_adr, SfileadrL - 1);
|
|
if(abs_pt == NULL) {
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"Relative drive path given. Cannot determine working directory.",
|
|
errno, "FAILURE", 0);
|
|
return(-1);
|
|
}
|
|
ret= Sfile_add_to_path(abs_adr, path_pt, 0);
|
|
if(ret <= 0)
|
|
return(-1);
|
|
}
|
|
|
|
is_known_mmc= burn_drive_convert_fs_adr(path_pt, libburn_adr);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
|
|
ret= Xorriso_is_in_patternlist(xorriso, xorriso->drive_whitelist, path_pt, 0);
|
|
if(ret > 0)
|
|
goto ok;
|
|
ret= Xorriso_is_in_patternlist(xorriso, xorriso->drive_blacklist, path_pt, 0);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret) {
|
|
strcpy(xorriso->info_text, "Drive address ");
|
|
Text_shellsafe(adr, xorriso->info_text, 1);
|
|
strcat(xorriso->info_text,
|
|
" rejected because: -drive_class 'banned' ");
|
|
Text_shellsafe(Xorriso_get_pattern(xorriso, xorriso->drive_blacklist,
|
|
ret - 1, 0),
|
|
xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
/* if in greylist and not MMC and not stdio prefix: reject */
|
|
if(is_known_mmc < 0)
|
|
return(ret);
|
|
if(adr == path_pt && !is_known_mmc) { /* no prefix, no MMC */
|
|
ret= Xorriso_is_in_patternlist(xorriso, xorriso->drive_greylist, path_pt,0);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret) {
|
|
strcpy(xorriso->info_text, "Drive address ");
|
|
Text_shellsafe(adr, xorriso->info_text, 1);
|
|
strcat(xorriso->info_text,
|
|
" rejected because: not MMC and -drive_class 'risky' ");
|
|
Text_shellsafe(Xorriso_get_pattern(xorriso,xorriso->drive_greylist,
|
|
ret - 1, 0),
|
|
xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
Xorriso_msgs_submit(xorriso, 0,
|
|
"If the address is a legitimate target, prepend \"stdio:\"",
|
|
0, "HINT", 0);
|
|
return(0);
|
|
}
|
|
}
|
|
ok:;
|
|
if(strncmp(adr, "mmc:", 4) == 0) {
|
|
if(Sfile_str(result, path_pt, 0) <= 0)
|
|
return(0);
|
|
} else if(adr == path_pt && is_known_mmc <= 0) {
|
|
Sfile_str(result, "stdio:", 0);
|
|
if(Sfile_str(result, adr, 1) <= 0)
|
|
return(0);
|
|
} else {
|
|
if(Sfile_str(result, adr, 0) <= 0)
|
|
return(0);
|
|
}
|
|
if(strncmp(result, "stdio:", 6)==0) {
|
|
if(xorriso->ban_stdio_write) {
|
|
strcpy(xorriso->info_text, "Drive address banned by -ban_stdio_write : ");
|
|
Text_shellsafe(result, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= do not remove leading slash
|
|
bit1= append flatly to result_line and put out
|
|
*/
|
|
int Xorriso_getfname(struct XorrisO *xorriso, char *path, int flag)
|
|
{
|
|
int ret, path_offset= 0, bsl_mem;
|
|
char *bsl_path= NULL;
|
|
|
|
if(path[0] == '/' && !(flag & 1))
|
|
path_offset= 1;
|
|
|
|
/* backslash escaped path rather than shellsafe path */
|
|
ret= Sfile_bsl_encoder(&bsl_path, path + path_offset,
|
|
strlen(path + path_offset), 8);
|
|
if(ret <= 0)
|
|
return(-1);
|
|
if(flag & 2) {
|
|
sprintf(xorriso->result_line + strlen(xorriso->result_line),
|
|
"%s\n", bsl_path[0] ? bsl_path : ".");
|
|
} else {
|
|
sprintf(xorriso->result_line, "# file: %s\n", bsl_path[0] ? bsl_path : ".");
|
|
}
|
|
free(bsl_path);
|
|
bsl_path= NULL;
|
|
/* temporarily disable -backslash_codes with result output */
|
|
bsl_mem= xorriso->bsl_interpretation;
|
|
xorriso->bsl_interpretation= 0;
|
|
Xorriso_result(xorriso, 0);
|
|
xorriso->bsl_interpretation= bsl_mem;
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param node Opaque handle to IsoNode which is to be inquired instead of path if it is not NULL.
|
|
@param path is used as address if node is NULL.
|
|
@param acl_text if acl_text is not NULL, then *acl_text will be set to the
|
|
ACL text (without comments) of the file object. In this
|
|
case it finally has to be freed by the caller.
|
|
@param flag bit0= do not report to result but only retrieve ACL text
|
|
bit1= check for existence of true ACL (not fabricated),
|
|
do not allocate and set acl_text but return 1 or 2
|
|
bit2-3: what ALC to retrieve:
|
|
0= "access" and "default", mark "default:"
|
|
1= "access" only
|
|
2= "default" only, do not mark "default:"
|
|
bit4= get "access" ACL only if not trivial
|
|
@return 2 ok, no ACL available, eventual *acl_text will be NULL
|
|
1 ok, ACL available, eventual *acl_text stems from malloc()
|
|
<=0 error
|
|
*/
|
|
int Xorriso_getfacl(struct XorrisO *xorriso, void *in_node, char *path,
|
|
char **acl_text, int flag)
|
|
{
|
|
int ret, d_ret, result_len= 0, pass, what;
|
|
IsoNode *node;
|
|
char *text= NULL, *d_text= NULL, *cpt, *npt;
|
|
uid_t uid;
|
|
gid_t gid;
|
|
struct passwd *pwd;
|
|
struct group *grp;
|
|
|
|
what= (flag >> 2) & 3;
|
|
if(acl_text != NULL)
|
|
*acl_text= NULL;
|
|
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
ret= iso_node_get_acl_text(node, &text, &d_text, flag & 16);
|
|
d_ret= (d_text != NULL);
|
|
if(ret < 0 || d_ret < 0) {
|
|
if(path != NULL && path[0] != 0) {
|
|
strcpy(xorriso->info_text, "Error with obtaining ACL of ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
}
|
|
ret= 0; goto ex;
|
|
}
|
|
if(flag & 2) {
|
|
ret= 1 + (ret != 1 && d_ret == 0);
|
|
goto ex;
|
|
}
|
|
if((ret == 0 || ret == 2) && d_ret == 0) {
|
|
if(flag & 1) {
|
|
ret= 1 + (ret == 0);
|
|
goto ex;
|
|
}
|
|
strcpy(xorriso->info_text, "No ACL associated with ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
|
|
if(ret == 0)
|
|
{ret= 2; goto ex;}
|
|
}
|
|
|
|
if(!(flag & 1)) {
|
|
ret= Xorriso_getfname(xorriso, path, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
uid= iso_node_get_uid(node);
|
|
pwd= getpwuid(uid);
|
|
if(pwd == NULL)
|
|
sprintf(xorriso->result_line, "# owner: %.f\n", (double) uid);
|
|
else
|
|
sprintf(xorriso->result_line, "# owner: %s\n", pwd->pw_name);
|
|
Xorriso_result(xorriso, 0);
|
|
gid= iso_node_get_gid(node);
|
|
grp= getgrgid(gid);
|
|
if(grp == NULL)
|
|
sprintf(xorriso->result_line, "# group: %.f\n", (double) gid);
|
|
else
|
|
sprintf(xorriso->result_line, "# group: %s\n", grp->gr_name);
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
|
|
for(pass= 0; pass < 1 + (acl_text != NULL && !(flag & 2)); pass++) {
|
|
if(pass) {
|
|
*acl_text= calloc(result_len + 1, 1);
|
|
if(*acl_text == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
}
|
|
if(text != NULL && what <= 1) {
|
|
for(npt= cpt= text; npt != NULL; cpt= npt + 1) {
|
|
npt= strchr(cpt, '\n');
|
|
if(npt != NULL)
|
|
*npt= 0;
|
|
if(*cpt == 0) {
|
|
if(d_text != NULL || pass) {
|
|
if(npt != NULL)
|
|
*npt= '\n';
|
|
continue;
|
|
}
|
|
} else
|
|
result_len+= strlen(cpt) + 1;
|
|
if(pass) {
|
|
sprintf(*acl_text + strlen(*acl_text), "%s\n", cpt);
|
|
} else if(!(flag & 1)) {
|
|
Sfile_str(xorriso->result_line, cpt, 0);
|
|
strcat(xorriso->result_line, "\n");
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
if(npt != NULL)
|
|
*npt= '\n';
|
|
}
|
|
}
|
|
if(d_text != NULL && (what == 0 || what == 2)) {
|
|
for(npt= cpt= d_text; npt != NULL; cpt= npt + 1) {
|
|
npt= strchr(cpt, '\n');
|
|
if(npt != NULL)
|
|
*npt= 0;
|
|
if(*cpt != 0) {
|
|
if(pass) {
|
|
if(what == 0)
|
|
sprintf(*acl_text + strlen(*acl_text), "default:%s\n", cpt);
|
|
else
|
|
sprintf(*acl_text + strlen(*acl_text), "%s\n", cpt);
|
|
} else {
|
|
xorriso->result_line[0]= 0;
|
|
if(what == 0)
|
|
Sfile_str(xorriso->result_line, "default:", 0);
|
|
Sfile_str(xorriso->result_line, cpt, 1);
|
|
result_len+= strlen(cpt) + 9;
|
|
}
|
|
} else
|
|
xorriso->result_line[0]= 0;
|
|
if(pass== 0 && !(flag & 1)) {
|
|
strcat(xorriso->result_line, "\n");
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
if(npt != NULL)
|
|
*npt= '\n';
|
|
}
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
iso_node_get_acl_text(node, &text, &d_text, 1 << 15);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_set_ignore_aclea(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, hflag;
|
|
IsoImage *volume;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 1);
|
|
if(ret<=0)
|
|
return(ret);
|
|
hflag= (~xorriso->do_aaip) & 1;
|
|
if((xorriso->ino_behavior & (1 | 2)) && !(xorriso->do_aaip & (4 | 16)))
|
|
hflag|= 2;
|
|
iso_image_set_ignore_aclea(volume, hflag);
|
|
return(1);
|
|
}
|
|
|
|
|
|
/* @param node Opaque handle to IsoNode which is to be manipulated
|
|
instead of path if it is not NULL.
|
|
@param path is used as address if node is NULL.
|
|
@param access_text "access" ACL in long text form
|
|
@param default_text "default" ACL in long text form
|
|
@param flag bit0= do not warn of root directory if not capable of AAIP
|
|
@return >0 success , <=0 failure
|
|
*/
|
|
int Xorriso_setfacl(struct XorrisO *xorriso, void *in_node, char *path,
|
|
char *access_text, char *default_text, int flag)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
ret= iso_node_set_acl_text(node, access_text, default_text, 0);
|
|
if(ret <= 0) {
|
|
if(path != NULL && path[0] != 0) {
|
|
strcpy(xorriso->info_text, "Error with setting ACL of ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
}
|
|
ret= 0; goto ex;
|
|
}
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= do not report to result but only retrieve attr text
|
|
bit1= path is disk_path
|
|
bit3= do not ignore eventual non-user attributes.
|
|
bit5= in case of symbolic link on disk: inquire link target
|
|
bit6= check for existence of xattr, return 0 or 1
|
|
(depends also on bit3)
|
|
*/
|
|
int Xorriso_getfattr(struct XorrisO *xorriso, void *in_node, char *path,
|
|
char **attr_text, int flag)
|
|
{
|
|
int ret= 1, i, bsl_mem, result_len= 0, pass;
|
|
size_t num_attrs= 0, *value_lengths= NULL;
|
|
char **names= NULL, **values= NULL, *bsl;
|
|
|
|
if(attr_text != NULL)
|
|
*attr_text= NULL;
|
|
ret= Xorriso_get_attrs(xorriso, in_node, path, &num_attrs, &names,
|
|
&value_lengths, &values, flag & (2 | 8 | 32));
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(flag & 64) {
|
|
ret= (num_attrs > 0);
|
|
goto ex;
|
|
}
|
|
if(num_attrs == 0)
|
|
{ret= 2; goto ex;}
|
|
|
|
if(!(flag & 1)) {
|
|
ret= Xorriso_getfname(xorriso, path, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
for(pass= 0; pass < 1 + (attr_text != NULL); pass++) {
|
|
if(pass) {
|
|
*attr_text= calloc(result_len + 1, 1);
|
|
if(*attr_text == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
}
|
|
for(i= 0; i < num_attrs; i++) {
|
|
if(strlen(names[i]) + value_lengths[i] >= SfileadrL) {
|
|
sprintf(xorriso->result_line, "# oversized: name %d , value %d bytes\n",
|
|
(int) strlen(names[i]), (int) value_lengths[i]);
|
|
} else {
|
|
ret= Sfile_bsl_encoder(&bsl, names[i], strlen(names[i]), 8);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
strcpy(xorriso->result_line, bsl);
|
|
free(bsl);
|
|
ret= Sfile_bsl_encoder(&bsl, values[i], value_lengths[i], 8);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
sprintf(xorriso->result_line + strlen(xorriso->result_line),
|
|
"=\"%s\"\n", bsl);
|
|
free(bsl);
|
|
}
|
|
/* temporarily disable -backslash_codes with result output */
|
|
result_len+= strlen(xorriso->result_line);
|
|
if(pass) {
|
|
strcat(*attr_text, xorriso->result_line);
|
|
} else if(!(flag & 1)) {
|
|
bsl_mem= xorriso->bsl_interpretation;
|
|
xorriso->bsl_interpretation= 0;
|
|
Xorriso_result(xorriso, 0);
|
|
xorriso->bsl_interpretation= bsl_mem;
|
|
}
|
|
}
|
|
}
|
|
if(!(flag & 1)) {
|
|
strcpy(xorriso->result_line, "\n");
|
|
Xorriso_result(xorriso, 0);
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_get_attrs(xorriso, in_node, path, &num_attrs, &names,
|
|
&value_lengths, &values, 1 << 15);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param in_node Opaque handle to IsoNode which is to be manipulated
|
|
instead of path if it is not NULL.
|
|
@param path is used as address if node is NULL.
|
|
@param num_attrs Number of attributes
|
|
@param names Array of pointers to 0 terminated name strings
|
|
@param value_lengths Array of byte lengths for each attribute payload
|
|
@param values Array of pointers to the attribute payload bytes
|
|
@param flag bit0= Do not maintain eventual existing ACL of the node
|
|
bit1= Do not clear the existing attribute list
|
|
bit2= Delete the attributes with the given names
|
|
bit3= Allow non-user attributes.
|
|
bit4= do not warn of root if incapable of AAIP
|
|
@return >0 success , <=0 failure
|
|
*/
|
|
int Xorriso_setfattr(struct XorrisO *xorriso, void *in_node, char *path,
|
|
size_t num_attrs, char **names,
|
|
size_t *value_lengths, char **values, int flag)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
ret= iso_node_set_attrs(node, num_attrs, names, value_lengths, values,
|
|
flag & (1 | 2 | 4 | 8));
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret <= 0) {
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when setting ACL and xattr to image node",
|
|
0, "FAILURE", 1);
|
|
if(path != NULL && path[0] != 0) {
|
|
strcpy(xorriso->info_text, "Error with setting xattr of ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
}
|
|
ret= 0; goto ex;
|
|
}
|
|
Xorriso_set_change_pending(xorriso, 0);
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag
|
|
Bitfield for control purposes
|
|
bit0= get default ACL rather than access ACL
|
|
bit4= set *text = NULL and return 2
|
|
if the ACL matches st_mode permissions.
|
|
bit5= in case of symbolic link: inquire link target
|
|
bit15= free text and return 1
|
|
@return
|
|
1 ok
|
|
2 ok, trivial ACL found while bit4 is set, *text is NULL
|
|
0 no ACL manipulation adapter available
|
|
-1 failure of system ACL service (see errno)
|
|
-2 attempt to inquire ACL of a symbolic link without bit4 or bit5
|
|
resp. with no suitable link target
|
|
*/
|
|
int Xorriso_local_getfacl(struct XorrisO *xorriso, char *disk_path,
|
|
char **text, int flag)
|
|
{
|
|
int ret, skip= 0, colons= 0, countdown= 0;
|
|
char *acl= NULL, *cpt, *wpt;
|
|
|
|
if(flag & (1 << 15)) {
|
|
if(*text != NULL)
|
|
free(*text);
|
|
*text= NULL;
|
|
return(1);
|
|
}
|
|
*text= NULL;
|
|
ret= iso_local_get_acl_text(disk_path, &acl, flag & (1 | 16 | 32));
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret < 0 || ret == 2)
|
|
return(ret);
|
|
if(acl == NULL)
|
|
return(0);
|
|
*text= strdup(acl);
|
|
iso_local_get_acl_text(disk_path, &acl, 1 << 15);
|
|
if(*text == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
return(-1);
|
|
}
|
|
|
|
/* Garbage collection about trailing remarks after 3 permission chars */
|
|
wpt= *text;
|
|
for(cpt= *text; *cpt; cpt++) {
|
|
if(skip) {
|
|
if(*cpt == '\n')
|
|
skip= 0;
|
|
else
|
|
continue;
|
|
}
|
|
if(*cpt == ':' && !countdown) {
|
|
colons++;
|
|
if(colons == 2) {
|
|
countdown= 4;
|
|
colons= 0;
|
|
}
|
|
}
|
|
if(countdown > 0) {
|
|
countdown--;
|
|
if(countdown == 0)
|
|
skip= 1;
|
|
}
|
|
*wpt= *cpt;
|
|
wpt++;
|
|
}
|
|
*wpt= 0;
|
|
|
|
return(1);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag
|
|
bit1= path is disk_path
|
|
bit3= do not ignore eventual non-user attributes.
|
|
bit5= in case of symbolic link on disk: inquire link target
|
|
bit15= free memory
|
|
*/
|
|
int Xorriso_get_attrs(struct XorrisO *xorriso, void *in_node, char *path,
|
|
size_t *num_attrs, char ***names,
|
|
size_t **value_lengths, char ***values, int flag)
|
|
{
|
|
int ret, i, widx;
|
|
IsoNode *node;
|
|
|
|
if(flag & (1 << 15)) {
|
|
if(flag & 2) {
|
|
iso_local_get_attrs(NULL, num_attrs, names, value_lengths, values,
|
|
1 << 15);
|
|
} else {
|
|
iso_node_get_attrs(NULL, num_attrs, names, value_lengths, values,
|
|
1 << 15);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
*num_attrs= 0;
|
|
if(flag & 2) {
|
|
ret= iso_local_get_attrs(path, num_attrs, names, value_lengths, values,
|
|
flag & (8 | 32));
|
|
if(ret < 0) {
|
|
strcpy(xorriso->info_text, "Error with reading xattr of disk file ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
|
|
}
|
|
} else {
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
ret= iso_node_get_attrs(node, num_attrs, names, value_lengths, values,
|
|
0);
|
|
if(ret < 0) {
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when obtaining xattr of ISO node", 0, "FAILURE", 1);
|
|
goto ex;
|
|
}
|
|
|
|
if(!(flag & 8)) {
|
|
/* Filter away any non-userspace xattr */;
|
|
widx= 0;
|
|
for(i= 0; i < *num_attrs; i++) {
|
|
if(strncmp((*names)[i], "user.", 5) != 0) {
|
|
free((*names)[i]);
|
|
(*names)[i]= NULL;
|
|
if((*values)[i] != NULL) {
|
|
free((*values)[i]);
|
|
(*values)[i]= NULL;
|
|
}
|
|
} else {
|
|
if(widx != i) {
|
|
(*names)[widx]= (*names)[i];
|
|
(*value_lengths)[widx]= (*value_lengths)[i];
|
|
(*values)[widx]= (*values)[i];
|
|
(*names)[i]= NULL;
|
|
(*value_lengths)[i]= 0;
|
|
(*values)[i]= NULL;
|
|
}
|
|
widx++;
|
|
}
|
|
}
|
|
*num_attrs= widx;
|
|
}
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_get_attr_value(struct XorrisO *xorriso, void *in_node, char *path,
|
|
char *name, size_t *value_length, char **value, int flag)
|
|
{
|
|
int ret;
|
|
size_t num_attrs= 0, *value_lengths= NULL, i;
|
|
char **names = NULL, **values= NULL;
|
|
|
|
*value= NULL;
|
|
*value_length= 0;
|
|
ret= Xorriso_get_attrs(xorriso, in_node, path, &num_attrs, &names,
|
|
&value_lengths, &values, 8);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
|
|
for(i= 0; i < num_attrs; i++) {
|
|
if(strcmp(name, names[i]) != 0)
|
|
continue;
|
|
*value= calloc(value_lengths[i] + 1, 1);
|
|
if(*value == NULL)
|
|
{ret= -1; goto ex;}
|
|
memcpy(*value, values[i], value_lengths[i]);
|
|
(*value)[value_lengths[i]]= 0;
|
|
*value_length= value_lengths[i];
|
|
ret= 1; goto ex;
|
|
}
|
|
ret= 0;
|
|
ex:
|
|
Xorriso_get_attrs(xorriso, in_node, path, &num_attrs, &names,
|
|
&value_lengths, &values, 1 << 15);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= use parameters dev,ino rather than disk_path
|
|
bit1= compare attribute rather than setting it
|
|
return: 0=dev,ino match, 1=mismatch, 2=no node attribute
|
|
-1=error
|
|
bit5= if not bit0:
|
|
transfer dev,inode from eventual link target
|
|
bit7= omit dev check mit bit1
|
|
*/
|
|
int Xorriso_record_dev_inode(struct XorrisO *xorriso, char *disk_path,
|
|
dev_t dev, ino_t ino,
|
|
void *in_node, char *iso_path, int flag)
|
|
{
|
|
size_t l, di_l= 0;
|
|
int i, ret;
|
|
dev_t hdev;
|
|
ino_t hino;
|
|
char buf[66], *bufpt, *wpt, *di= NULL;
|
|
static char *name= "isofs.di";
|
|
struct stat stbuf;
|
|
|
|
if(!(flag & 1)) {
|
|
if(flag & 32) {
|
|
if(stat(disk_path, &stbuf) == -1)
|
|
return(-1);
|
|
} else {
|
|
if(lstat(disk_path, &stbuf) == -1)
|
|
return(-1);
|
|
}
|
|
dev= stbuf.st_dev;
|
|
ino= stbuf.st_ino;
|
|
}
|
|
|
|
wpt= buf;
|
|
hdev= dev;
|
|
for(i= 0; hdev != 0; i++)
|
|
hdev= hdev >> 8;
|
|
l= i;
|
|
*(wpt++)= l;
|
|
for(i= 0; i < l; i++)
|
|
*(wpt++)= dev >> (8 * (l - i - 1));
|
|
hino= ino;
|
|
for(i= 0; hino != 0; i++)
|
|
hino= hino >> 8;
|
|
l= i;
|
|
*(wpt++)= l;
|
|
for(i= 0; i < l; i++)
|
|
*(wpt++)= ino >> (8 * (l - i - 1));
|
|
l= wpt - buf;
|
|
bufpt= buf;
|
|
|
|
if(flag & 2) {
|
|
/* Compare node attribute with bufpt,l */
|
|
ret= Xorriso_get_attr_value(xorriso, in_node, iso_path,
|
|
"isofs.di", &di_l, &di, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0)
|
|
{ret= 2; goto ex;}
|
|
if(flag & 128) {
|
|
if(di_l <= 0)
|
|
{ret= 1; goto ex;}
|
|
hino= 0;
|
|
for(i= di[0] + 2; i < di_l && i - di[0] - 2 < di[(int) di[0] + 1]; i++)
|
|
hino= (hino << 8) | ((unsigned char *) di)[i];
|
|
if(hino != ino)
|
|
{ret= 1; goto ex;}
|
|
} else {
|
|
if(l != di_l)
|
|
{ret= 1; goto ex;}
|
|
for(i= 0; i < l; i++)
|
|
if(di[i] != buf[i])
|
|
{ret= 1; goto ex;}
|
|
}
|
|
ret= 0;
|
|
} else {
|
|
ret= Xorriso_setfattr(xorriso, in_node, iso_path,
|
|
(size_t) 1, &name, &l, &bufpt, 2 | 8);
|
|
}
|
|
ex:;
|
|
if(di != NULL)
|
|
free(di);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
struct Xorriso_extF {
|
|
|
|
int flag; /* unused yet */
|
|
|
|
IsoExternalFilterCommand *cmd;
|
|
|
|
};
|
|
|
|
int Xorriso_extf_destroy(struct XorrisO *xorriso, struct Xorriso_extF **filter,
|
|
int flag);
|
|
|
|
|
|
/* @param flag see struct Xorriso_extF.flag */
|
|
int Xorriso_extf_new(struct XorrisO *xorriso, struct Xorriso_extF **filter,
|
|
char *path, int argc, char **argv, int behavior,
|
|
char *suffix, char *name, int flag)
|
|
{
|
|
int i;
|
|
struct Xorriso_extF *o= NULL;
|
|
IsoExternalFilterCommand *cmd;
|
|
|
|
*filter= o= calloc(sizeof(struct Xorriso_extF), 1);
|
|
if(o == NULL)
|
|
goto failure;
|
|
o->flag= flag;
|
|
o->cmd= NULL;
|
|
o->cmd= cmd= calloc(sizeof(IsoExternalFilterCommand), 1);
|
|
if(cmd == NULL)
|
|
goto failure;
|
|
cmd->version= 0;
|
|
cmd->refcount= 0;
|
|
cmd->name= NULL;
|
|
cmd->path= NULL;
|
|
cmd->argv= NULL;
|
|
cmd->argc= argc + 1;
|
|
cmd->behavior= behavior;
|
|
cmd->suffix= NULL;
|
|
cmd->suffix= strdup(suffix);
|
|
if(cmd->suffix == NULL)
|
|
goto failure;
|
|
|
|
cmd->path= strdup(path);
|
|
if(cmd->path == NULL)
|
|
goto failure;
|
|
cmd->argv= calloc(sizeof(char *), argc + 2);
|
|
if(cmd->argv == NULL)
|
|
goto failure;
|
|
for(i= 0; i < argc + 2; i++)
|
|
cmd->argv[i]= NULL;
|
|
cmd->argv[0]= strdup(path);
|
|
if(cmd->argv[0] == NULL)
|
|
goto failure;
|
|
for(i= 0; i < argc; i++) {
|
|
cmd->argv[i + 1]= strdup(argv[i]);
|
|
if(cmd->argv[i] == NULL)
|
|
goto failure;
|
|
}
|
|
cmd->name= strdup(name);
|
|
if(cmd->name == NULL)
|
|
goto failure;
|
|
return(1);
|
|
failure:;
|
|
Xorriso_extf_destroy(xorriso, filter, 0);
|
|
return(-1);
|
|
}
|
|
|
|
|
|
int Xorriso_extf_destroy(struct XorrisO *xorriso, struct Xorriso_extF **filter,
|
|
int flag)
|
|
{
|
|
int i;
|
|
IsoExternalFilterCommand *cmd;
|
|
|
|
if(*filter == NULL)
|
|
return(0);
|
|
cmd= (*filter)->cmd;
|
|
if(cmd != NULL) {
|
|
if(cmd->refcount > 0)
|
|
return(0);
|
|
if(cmd->suffix != NULL)
|
|
free(cmd->suffix);
|
|
if(cmd->argv != NULL) {
|
|
for(i= 0; i < cmd->argc; i++)
|
|
if(cmd->argv[i] != NULL)
|
|
free(cmd->argv[i]);
|
|
free((char *) cmd->argv);
|
|
}
|
|
if(cmd->name != NULL)
|
|
free(cmd->name);
|
|
}
|
|
free((char *) *filter);
|
|
*filter= NULL;
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_lookup_extf(struct XorrisO *xorriso, char *name,
|
|
struct Xorriso_lsT **found_lst, int flag)
|
|
{
|
|
struct Xorriso_extF *filter;
|
|
struct Xorriso_lsT *lst;
|
|
|
|
for(lst= xorriso->filters; lst != NULL; lst= Xorriso_lst_get_next(lst, 0)) {
|
|
filter= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
|
|
if(strcmp(filter->cmd->name, name) == 0) {
|
|
*found_lst= lst;
|
|
return(1);
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
int Xorriso_destroy_all_extf(struct XorrisO *xorriso, int flag)
|
|
{
|
|
struct Xorriso_extF *filter;
|
|
struct Xorriso_lsT *lst, *next_lst;
|
|
|
|
for(lst= xorriso->filters; lst != NULL; lst= next_lst) {
|
|
filter= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
|
|
Xorriso_lst_detach_text(lst, 0);
|
|
next_lst= Xorriso_lst_get_next(lst, 0);
|
|
Xorriso_lst_destroy(&lst, 0);
|
|
Xorriso_extf_destroy(xorriso, &filter, 0);
|
|
}
|
|
xorriso->filters= NULL;
|
|
return(1);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= return 2 if renaming is not possible by libisofs
|
|
(always: if demanded strip suffix is missing
|
|
or if suffix makes name length > 255)
|
|
bit1= strip suffix rather than appending it
|
|
*/
|
|
int Xorriso_rename_suffix(struct XorrisO *xorriso, IsoNode *node, char *suffix,
|
|
char *show_path, char new_name[], int flag)
|
|
{
|
|
int ret, lo= 0, ls= 0, strip_suffix;
|
|
char *old_name= NULL, *show_name;
|
|
|
|
strip_suffix= !!(flag & 2);
|
|
|
|
old_name= strdup((char *) iso_node_get_name(node));
|
|
show_name= old_name;
|
|
if(show_path != NULL)
|
|
if(show_path[0] != 0)
|
|
show_name= show_path;
|
|
lo= strlen(old_name);
|
|
ls= strlen(suffix);
|
|
if(strip_suffix) {
|
|
if(lo <= ls) {
|
|
/* refuse gracefully */
|
|
ret= 2; goto ex;
|
|
}
|
|
if(strcmp(old_name + lo - ls, suffix) != 0) {
|
|
ret= 2; goto ex;
|
|
}
|
|
if(lo >= SfileadrL)
|
|
goto cannot_remove_suffix;
|
|
strcpy(new_name, old_name);
|
|
new_name[lo - ls]= 0;
|
|
ret = iso_node_set_name(node, new_name);
|
|
if (ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if (!(flag & 1))
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when renaming ISO node", 0, "FAILURE", 1);
|
|
cannot_remove_suffix:;
|
|
strcpy(xorriso->info_text, "-set_filter: Cannot remove suffix from ");
|
|
Text_shellsafe(show_name, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
|
|
(flag & 1) ? "WARNING" : "FAILURE", 0);
|
|
ret= 2 * (flag & 1); goto ex;
|
|
}
|
|
} else {
|
|
/* check whether suffix already present */
|
|
if(lo >= ls)
|
|
if(strcmp(old_name + lo - ls, suffix) == 0) {
|
|
/* refuse gracefully */
|
|
ret= 2; goto ex;
|
|
}
|
|
if(lo + ls > 255) {
|
|
cannot_append_suffix:;
|
|
strcpy(xorriso->info_text, "-set_filter: Cannot append suffix to ");
|
|
Text_shellsafe(show_name, xorriso->info_text, 1);
|
|
strcat(xorriso->info_text, ". Left unfiltered.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
|
|
(flag & 1) ? "WARNING" : "FAILURE", 0);
|
|
ret= 2 * (flag & 1); goto ex;
|
|
}
|
|
sprintf(new_name, "%s%s", old_name, suffix);
|
|
ret = iso_node_set_name(node, new_name);
|
|
if (ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if (!(flag & 1))
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when renaming ISO node", 0, "FAILURE", 1);
|
|
goto cannot_append_suffix;
|
|
}
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(old_name != NULL)
|
|
free(old_name);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= return 2 if renaming is not possible
|
|
bit1= print pacifier messages
|
|
*/
|
|
int Xorriso_set_filter(struct XorrisO *xorriso, void *in_node,
|
|
char *path, char *filter_name, int flag)
|
|
{
|
|
int ret, strip_suffix= 0, strip_filter= 0, filter_ret= 0;
|
|
int explicit_suffix= 0, internal_filter= 0;
|
|
IsoNode *node;
|
|
IsoFile *file;
|
|
struct Xorriso_lsT *found_lst;
|
|
struct Xorriso_extF *found_filter;
|
|
IsoExternalFilterCommand *cmd = NULL;
|
|
char *old_name= NULL, new_name[SfileadrL], *suffix= "";
|
|
IsoStream *stream;
|
|
int is_renamed= 0;
|
|
|
|
new_name[0]= 0;
|
|
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
if(!LIBISO_ISREG(node)) {
|
|
strcpy(xorriso->info_text, "-set_filter: Not a regular data file node ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
file= (IsoFile *) node;
|
|
|
|
if(strncmp(filter_name, "--remove-all-filters", 20) == 0) {
|
|
strip_filter= 1;
|
|
strip_suffix= 1;
|
|
if(strlen(filter_name) > 21) {
|
|
strip_suffix= (filter_name[20] != '+');
|
|
suffix= filter_name + 21;
|
|
explicit_suffix= 1;
|
|
}
|
|
} else if(strcmp(filter_name, "--zisofs") == 0) {
|
|
internal_filter= 1;
|
|
} else if(strcmp(filter_name, "--zisofs-decode") == 0) {
|
|
internal_filter= 2;
|
|
} else if(strcmp(filter_name, "--gzip") == 0) {
|
|
internal_filter= 3;
|
|
suffix= ".gz";
|
|
strip_suffix= 0;
|
|
explicit_suffix= 1;
|
|
} else if(strcmp(filter_name, "--gunzip") == 0 ||
|
|
strcmp(filter_name, "--gzip-decode") == 0) {
|
|
internal_filter= 4;
|
|
suffix= ".gz";
|
|
strip_suffix= 1;
|
|
explicit_suffix= 1;
|
|
} else {
|
|
ret= Xorriso_lookup_extf(xorriso, filter_name, &found_lst, 0);
|
|
if(ret < 0)
|
|
goto ex;
|
|
if(ret == 0) {
|
|
strcpy(xorriso->info_text, "-set_filter: Not a registered filter name ");
|
|
Text_shellsafe(filter_name, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
found_filter= (struct Xorriso_extF *) Xorriso_lst_get_text(found_lst, 0);
|
|
cmd= found_filter->cmd;
|
|
suffix= cmd->suffix;
|
|
strip_suffix= cmd->behavior & 8;
|
|
}
|
|
|
|
if(suffix[0]) {
|
|
|
|
/* >>> would need full iso_rr_path of node for showing */;
|
|
|
|
old_name= strdup((char *) iso_node_get_name(node));
|
|
ret= Xorriso_rename_suffix(xorriso, node, suffix, path, new_name,
|
|
(flag & 1) | (strip_suffix ? 2 : 0));
|
|
if(ret <= 0 || ret == 2)
|
|
goto ex;
|
|
is_renamed= 1;
|
|
}
|
|
|
|
if(strip_filter) {
|
|
while(1) {
|
|
if(!explicit_suffix) {
|
|
stream= iso_file_get_stream(file);
|
|
|
|
if(strncmp(stream->class->type, "gzip", 4) == 0) {
|
|
suffix= ".gz";
|
|
strip_suffix= 1;
|
|
} else if(strncmp(stream->class->type, "pizg", 4) == 0) {
|
|
suffix= ".gz";
|
|
strip_suffix= 0;
|
|
} else {
|
|
ret= iso_stream_get_external_filter(stream, &cmd, 0);
|
|
if(ret > 0) {
|
|
suffix= cmd->suffix;
|
|
strip_suffix= !(cmd->behavior & 8);
|
|
}
|
|
}
|
|
if(suffix[0]) {
|
|
|
|
/* >>> would need the current renaming state of path */;
|
|
|
|
ret= Xorriso_rename_suffix(xorriso, node, suffix, NULL, new_name,
|
|
(flag & 1) | (strip_suffix << 1));
|
|
if(ret <= 0 || ret == 2)
|
|
goto ex;
|
|
}
|
|
}
|
|
ret= iso_file_remove_filter(file, 0);
|
|
if(ret != 1)
|
|
break;
|
|
}
|
|
filter_ret= 1;
|
|
} else if (internal_filter == 1 || internal_filter == 2) {
|
|
filter_ret = iso_file_add_zisofs_filter(file, 1 | (internal_filter & 2));
|
|
if(filter_ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(!(internal_filter == 2 && filter_ret == ISO_ZISOFS_WRONG_INPUT))
|
|
Xorriso_report_iso_error(xorriso, "", filter_ret,
|
|
"Error when setting filter to ISO node", 0, "FAILURE", 1);
|
|
}
|
|
} else if (internal_filter == 3 || internal_filter == 4) {
|
|
filter_ret = iso_file_add_gzip_filter(file,
|
|
1 | ((internal_filter == 4) << 1));
|
|
if(filter_ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, "", filter_ret,
|
|
"Error when setting filter to ISO node", 0, "FAILURE", 1);
|
|
}
|
|
} else {
|
|
|
|
#ifndef Xorriso_allow_extf_suiD
|
|
/* This is a final safety precaution before iso_file_add_external_filter()
|
|
performs fork() and executes the alleged filter program.
|
|
*/
|
|
if(getuid() != geteuid()) {
|
|
sprintf(xorriso->info_text,
|
|
"-set_filter: UID and EUID differ. Will not run external programs.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
return(0);
|
|
}
|
|
#endif /* ! Xorriso_allow_extf_suiD */
|
|
|
|
filter_ret = iso_file_add_external_filter(file, cmd, 0);
|
|
if(filter_ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, "", filter_ret,
|
|
"Error when setting filter to ISO node", 0, "FAILURE", 1);
|
|
}
|
|
}
|
|
if(filter_ret != 1 && new_name[0] && old_name != NULL) {
|
|
ret = iso_node_set_name(node, old_name);
|
|
if (ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if (!(flag & 1))
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when renaming ISO node", 0, "FAILURE", 1);
|
|
}
|
|
}
|
|
if(flag & 2) {
|
|
xorriso->pacifier_count++;
|
|
Xorriso_pacifier_callback(xorriso, "file filters processed",
|
|
xorriso->pacifier_count, xorriso->pacifier_total, "", 0);
|
|
}
|
|
if(filter_ret < 0) {
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
ret= filter_ret;
|
|
ex:;
|
|
if(old_name != NULL)
|
|
free(old_name);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= delete filter with the given name
|
|
*/
|
|
int Xorriso_external_filter(struct XorrisO *xorriso,
|
|
char *name, char *options, char *path,
|
|
int argc, char **argv, int flag)
|
|
{
|
|
int ret, delete= 0, behavior= 0, extf_flag= 0, is_banned= 0;
|
|
char *what, *what_next, *suffix= "";
|
|
struct Xorriso_lsT *lst;
|
|
struct Xorriso_extF *found_filter, *new_filter= NULL;
|
|
|
|
#ifndef Xorriso_allow_external_filterS
|
|
/* To be controlled by: configure --enable-external-filters */
|
|
|
|
sprintf(xorriso->info_text, "%s : Banned at compile time.",
|
|
flag & 1 ? "-unregister_filter" : "-external_filter");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
sprintf(xorriso->info_text,
|
|
"This may be changed at compile time by ./configure option --enable-external-filters");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
|
|
is_banned= 1;
|
|
|
|
#endif /* ! Xorriso_allow_external_filterS */
|
|
|
|
#ifndef Xorriso_allow_extf_suiD
|
|
/* To be controlled by: configure --enable-external-filters-setuid */
|
|
|
|
if(getuid() != geteuid()) {
|
|
sprintf(xorriso->info_text,
|
|
"-set_filter: UID and EUID differ. Will not run external programs.");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
|
|
sprintf(xorriso->info_text,
|
|
"This may be changed at compile time by ./configure option --enable-external-filters-setuid");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
|
|
is_banned= 1;
|
|
}
|
|
#endif /* ! Xorriso_allow_extf_suiD */
|
|
|
|
if(is_banned)
|
|
return(0);
|
|
|
|
if(xorriso->filter_list_closed) {
|
|
sprintf(xorriso->info_text,
|
|
"%s : Banned by previous command -close_filter_list",
|
|
flag & 1 ? "-unregister_filter" : "-external_filter");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
if((!(flag & 1)) && path[0] != '/') {
|
|
sprintf(xorriso->info_text,
|
|
"-external_filter : Given command path does not begin by '/' : ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
return(0);
|
|
}
|
|
|
|
|
|
delete= flag & 1;
|
|
ret= Xorriso_lookup_extf(xorriso, name, &lst, 0);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret > 0) {
|
|
if(delete) {
|
|
found_filter= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
|
|
if(found_filter->cmd->refcount > 0) {
|
|
sprintf(xorriso->info_text,
|
|
"-external_filter: Cannot remove filter because it is in use by %.f nodes : ",
|
|
(double) found_filter->cmd->refcount);
|
|
Text_shellsafe(name, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
Xorriso_lst_detach_text(lst, 0);
|
|
if(xorriso->filters == lst)
|
|
xorriso->filters= Xorriso_lst_get_next(lst, 0);
|
|
Xorriso_lst_destroy(&lst, 0);
|
|
Xorriso_extf_destroy(xorriso, &found_filter, 0);
|
|
ret= 1; goto ex;
|
|
}
|
|
strcpy(xorriso->info_text,
|
|
"-external_filter: filter with given name already existing: ");
|
|
Text_shellsafe(name, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(delete) {
|
|
strcpy(xorriso->info_text,
|
|
"-external_filter: filter with given name does not exist: ");
|
|
Text_shellsafe(name, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
|
|
for(what= options; what!=NULL; what= what_next) {
|
|
what_next= strchr(what, ':');
|
|
if(what_next!=NULL) {
|
|
*what_next= 0;
|
|
what_next++;
|
|
}
|
|
if(strncmp(what, "default", 7) == 0) {
|
|
suffix= "";
|
|
behavior= 0;
|
|
} else if(strncmp(what, "suffix=", 7) == 0) {
|
|
suffix= what + 7;
|
|
} else if(strcmp(what, "remove_suffix") == 0) {
|
|
behavior|= 8;
|
|
} else if(strcmp(what, "if_nonempty") == 0) {
|
|
behavior|= 1;
|
|
} else if(strcmp(what, "if_reduction") == 0) {
|
|
behavior|= 2;
|
|
} else if(strcmp(what, "if_block_reduction") == 0) {
|
|
behavior|= 4;
|
|
} else if(strncmp(what, "used=", 5) == 0) {
|
|
; /* this is informational output from -status */
|
|
} else if(what[0]) {
|
|
strcpy(xorriso->info_text,
|
|
"-external_filter: unknown option ");
|
|
Text_shellsafe(what, xorriso->info_text, 1);
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
ret= 0; goto ex;
|
|
}
|
|
}
|
|
|
|
ret= Xorriso_extf_new(xorriso, &new_filter, path, argc, argv, behavior,
|
|
suffix, name, extf_flag);
|
|
if(ret <= 0) {
|
|
could_not_create:;
|
|
strcpy(xorriso->info_text,
|
|
"-external_filter: Could not create filter object");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
|
|
goto ex;
|
|
}
|
|
ret= Xorriso_lst_append_binary(&(xorriso->filters), (char *) new_filter,0, 4);
|
|
if(ret <= 0)
|
|
goto could_not_create;
|
|
ret= 1;
|
|
ex:;
|
|
if(ret <= 0) {
|
|
if(new_filter != NULL)
|
|
Xorriso_extf_destroy(xorriso, &new_filter, 0);
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_status_extf(struct XorrisO *xorriso, char *filter, FILE *fp,
|
|
int flag)
|
|
/*
|
|
bit1= do only report to fp
|
|
*/
|
|
{
|
|
int i, maxl= 4 * SfileadrL;
|
|
struct Xorriso_extF *extf;
|
|
struct Xorriso_lsT *lst;
|
|
char *line;
|
|
|
|
line= xorriso->result_line;
|
|
for(lst= xorriso->filters; lst != NULL; lst= Xorriso_lst_get_next(lst, 0)) {
|
|
extf= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
|
|
|
|
strcpy(xorriso->result_line, "-external_filter ");
|
|
Text_shellsafe(extf->cmd->name, line, 1);
|
|
if(strlen(line) > maxl)
|
|
continue;
|
|
strcat(line, " ");
|
|
if(extf->cmd->suffix[0]) {
|
|
strcat(line, "suffix=");
|
|
Text_shellsafe(extf->cmd->suffix, line, 1);
|
|
if(strlen(line) > maxl)
|
|
continue;
|
|
strcat(line, ":");
|
|
}
|
|
if(extf->cmd->behavior & 8)
|
|
strcat(line, "remove_suffix:");
|
|
if(extf->cmd->behavior & 1)
|
|
strcat(line, "if_nonempty:");
|
|
if(extf->cmd->behavior & 2)
|
|
strcat(line, "if_reduction:");
|
|
if(extf->cmd->behavior & 4)
|
|
strcat(line, "if_block_reduction:");
|
|
sprintf(line + strlen(line), "used=%.f ", (double) extf->cmd->refcount);
|
|
if(strlen(line) > maxl)
|
|
continue;
|
|
Text_shellsafe(extf->cmd->path, line, 1);
|
|
if(strlen(line) > maxl)
|
|
continue;
|
|
for(i= 1; i < extf->cmd->argc; i++) {
|
|
strcat(line, " ");
|
|
Text_shellsafe(extf->cmd->argv[i], line, 1);
|
|
if(strlen(line) > maxl)
|
|
break;
|
|
}
|
|
if(i < extf->cmd->argc)
|
|
continue;
|
|
strcat(line, " --\n");
|
|
Xorriso_status_result(xorriso, filter, fp, flag&2);
|
|
}
|
|
if(xorriso->filter_list_closed) {
|
|
strcpy(line, "-close_filter_list\n");
|
|
Xorriso_status_result(xorriso, filter, fp, flag&2);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_stream_type(struct XorrisO *xorriso, IsoNode *node,
|
|
IsoStream *stream, char type_text[], int flag)
|
|
{
|
|
int ret, lba;
|
|
char text[5];
|
|
|
|
strncpy(text, stream->class->type, 4);
|
|
text[4]= 0;
|
|
if(strcmp(text, "fsrc") == 0) {
|
|
ret= Xorriso__file_start_lba(node, &lba, 0);
|
|
if(ret > 0 && lba > 0)
|
|
strcpy(type_text, "image");
|
|
else
|
|
strcpy(type_text, "disk");
|
|
} else if(strcmp(text, "ziso") == 0) {
|
|
strcpy(type_text, "--zisofs");
|
|
} else if(strcmp(text, "osiz") == 0) {
|
|
strcpy(type_text, "--zisofs-decode");
|
|
} else if(strcmp(text, "gzip") == 0) {
|
|
strcpy(type_text, "--gzip");
|
|
} else if(strcmp(text, "pizg") == 0) {
|
|
strcpy(type_text, "--gunzip");
|
|
} else if(strcmp(text, "cout") == 0 || strcmp(text, "boot") == 0 ||
|
|
strcmp(text, "user") == 0 || strcmp(text, "extf") == 0) {
|
|
strcpy(type_text, text);
|
|
} else {
|
|
Text_shellsafe(text, type_text, 0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
int Xorriso_show_stream(struct XorrisO *xorriso, void *in_node,
|
|
char *path, int flag)
|
|
{
|
|
int ret;
|
|
IsoNode *node;
|
|
IsoFile *file;
|
|
IsoStream *stream= NULL, *input_stream;
|
|
IsoExternalFilterCommand *cmd;
|
|
char type_text[16], *source_path= NULL;
|
|
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
}
|
|
if(!LIBISO_ISREG(node))
|
|
{ret= 2; goto ex;}
|
|
file= (IsoFile *) node;
|
|
input_stream= iso_file_get_stream(file);
|
|
Text_shellsafe(path, xorriso->result_line, 0);
|
|
while(1) {
|
|
stream= input_stream;
|
|
input_stream= iso_stream_get_input_stream(stream, 0);
|
|
if(input_stream == NULL)
|
|
break;
|
|
strcat(xorriso->result_line, " < ");
|
|
Xorriso_stream_type(xorriso, node, stream, type_text, 0);
|
|
strcat(xorriso->result_line, type_text);
|
|
ret= iso_stream_get_external_filter(stream, &cmd, 0);
|
|
if(ret < 0) {
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when inquiring filter command of node", 0, "FAILURE", 1);
|
|
ret= 0; goto ex;
|
|
}
|
|
if(ret > 0) {
|
|
strcat(xorriso->result_line, ":");
|
|
Text_shellsafe(cmd->name, xorriso->result_line, 1);
|
|
}
|
|
if(strlen(xorriso->result_line) > SfileadrL) {
|
|
Xorriso_result(xorriso, 0);
|
|
xorriso->result_line[0]= 0;
|
|
}
|
|
}
|
|
strcat(xorriso->result_line, " < ");
|
|
Xorriso_stream_type(xorriso, node, stream, type_text, 0);
|
|
strcat(xorriso->result_line, type_text);
|
|
|
|
source_path= iso_stream_get_source_path(stream, 0);
|
|
if(source_path != NULL) {
|
|
strcat(xorriso->result_line, ":");
|
|
Text_shellsafe(source_path, xorriso->result_line, 1);
|
|
}
|
|
|
|
strcat(xorriso->result_line, "\n");
|
|
Xorriso_result(xorriso, 0);
|
|
ret= 1;
|
|
ex:;
|
|
if(source_path != NULL)
|
|
free(source_path);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
struct iso_zisofs_ctrl ctrl;
|
|
|
|
ctrl.version= 0;
|
|
ctrl.compression_level= xorriso->zlib_level;
|
|
if(xorriso->zisofs_block_size == (1 << 16))
|
|
ctrl.block_size_log2= 16;
|
|
else if(xorriso->zisofs_block_size == (1 << 17))
|
|
ctrl.block_size_log2= 17;
|
|
else
|
|
ctrl.block_size_log2= 15;
|
|
ret= iso_zisofs_set_params(&ctrl, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret < 0) {
|
|
Xorriso_report_iso_error(xorriso, "", ret,
|
|
"Error when setting zisofs parameters", 0, "FAILURE", 1);
|
|
return(0);
|
|
}
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_status_zisofs(struct XorrisO *xorriso, char *filter, FILE *fp,
|
|
int flag)
|
|
/*
|
|
bit0= do only report non-default settings
|
|
bit1= do only report to fp
|
|
*/
|
|
{
|
|
off_t ziso_count= 0, osiz_count= 0;
|
|
off_t gzip_count= 0, gunzip_count= 0;
|
|
|
|
iso_zisofs_get_refcounts(&ziso_count, &osiz_count, 0);
|
|
iso_gzip_get_refcounts(&gzip_count, &gunzip_count, 0);
|
|
if((flag & 1) && xorriso->zlib_level == xorriso->zlib_level_default &&
|
|
xorriso->zisofs_block_size == xorriso->zisofs_block_size_default &&
|
|
xorriso->zisofs_by_magic == 0 &&
|
|
ziso_count == 0 && osiz_count == 0 &&
|
|
gzip_count == 0 && gunzip_count == 0) {
|
|
if(filter == NULL)
|
|
return(2);
|
|
if(filter[0] == 0)
|
|
return 2;
|
|
}
|
|
sprintf(xorriso->result_line,
|
|
"-zisofs level=%d:block_size=%dk:by_magic=%s:ziso_used=%.f:osiz_used=%.f",
|
|
xorriso->zlib_level, xorriso->zisofs_block_size / 1024,
|
|
xorriso->zisofs_by_magic ? "on" : "off",
|
|
(double) ziso_count, (double) osiz_count);
|
|
sprintf(xorriso->result_line + strlen(xorriso->result_line),
|
|
":gzip_used=%.f:gunzip_used=%.f\n",
|
|
(double) gzip_count, (double) gunzip_count);
|
|
Xorriso_status_result(xorriso, filter, fp, flag&2);
|
|
return(1);
|
|
}
|
|
|
|
|
|
int Xorriso_all_node_array(struct XorrisO *xorriso, int addon_nodes, int flag)
|
|
{
|
|
int ret;
|
|
struct FindjoB *job= NULL;
|
|
struct stat dir_stbuf;
|
|
|
|
ret= Findjob_new(&job, "/", 0);
|
|
if(ret<=0) {
|
|
Xorriso_no_findjob(xorriso, "xorriso", 0);
|
|
{ret= -1; goto ex;}
|
|
}
|
|
Findjob_set_action_target(job, 30, NULL, 0);
|
|
Xorriso_destroy_node_array(xorriso, 0);
|
|
ret= Xorriso_findi(xorriso, job, NULL, (off_t) 0, NULL, "/",
|
|
&dir_stbuf, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= Xorriso_new_node_array(xorriso, xorriso->temp_mem_limit, addon_nodes, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
Findjob_set_action_target(job, 31, NULL, 0);
|
|
ret= Xorriso_findi(xorriso, job, NULL, (off_t) 0, NULL, "/",
|
|
&dir_stbuf, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= 1;
|
|
ex:;
|
|
Findjob_destroy(&job, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_remake_hln_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, addon_nodes= 0, i, old_count, old_pt, new_pt;
|
|
IsoNode **old_nodes;
|
|
char **old_targets;
|
|
|
|
/* Count hln_targets of which the node has been deleted meanwhile */
|
|
for(i= 0; i < xorriso->hln_count; i++) {
|
|
if(xorriso->hln_targets[i] == NULL)
|
|
continue;
|
|
if(Xorriso_node_is_valid(xorriso, xorriso->hln_array[i], 0))
|
|
continue;
|
|
addon_nodes++;
|
|
}
|
|
ret= Xorriso_all_node_array(xorriso, addon_nodes, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(addon_nodes > 0) {
|
|
/* Transfer delete nodes with hln_target to node array */
|
|
for(i= 0; i < xorriso->hln_count; i++) {
|
|
if(xorriso->hln_targets[i] == NULL)
|
|
continue;
|
|
if(Xorriso_node_is_valid(xorriso, xorriso->hln_array[i], 0))
|
|
continue;
|
|
if(xorriso->node_counter < xorriso->node_array_size) {
|
|
xorriso->node_array[xorriso->node_counter++]= xorriso->hln_array[i];
|
|
iso_node_ref(xorriso->node_array[xorriso->node_counter - 1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
Xorriso_sort_node_array(xorriso, 0);
|
|
old_nodes= (IsoNode **) xorriso->hln_array;
|
|
old_targets= (char **) xorriso->hln_targets;
|
|
old_count= xorriso->hln_count;
|
|
xorriso->hln_array= 0;
|
|
xorriso->hln_targets= NULL;
|
|
|
|
/* Transfer node_array to di_array without unrefering nodes */
|
|
xorriso->hln_count= xorriso->node_counter;
|
|
xorriso->hln_array= xorriso->node_array;
|
|
xorriso->node_counter= 0;
|
|
xorriso->node_array_size= 0;
|
|
xorriso->node_array= NULL;
|
|
|
|
/* Allocate hln_targets */
|
|
ret= Xorriso_new_hln_array(xorriso, xorriso->temp_mem_limit, 1);
|
|
if(ret<=0)
|
|
goto ex;
|
|
xorriso->node_targets_availmem= xorriso->temp_mem_limit;
|
|
if(old_targets != NULL) {
|
|
/* Transfer targets from old target array */;
|
|
new_pt= old_pt= 0;
|
|
while(new_pt < xorriso->hln_count && old_pt < old_count) {
|
|
ret= Xorriso__hln_cmp(xorriso->hln_array[new_pt], old_nodes[old_pt]);
|
|
if(ret < 0) {
|
|
new_pt++;
|
|
} else if(ret > 0) {
|
|
old_pt++;
|
|
} else {
|
|
xorriso->hln_targets[new_pt]= old_targets[old_pt];
|
|
if(old_targets[old_pt] != NULL)
|
|
xorriso->temp_mem_limit-= strlen(old_targets[old_pt]) + 1;
|
|
old_targets[old_pt]= NULL;
|
|
new_pt++;
|
|
old_pt++;
|
|
}
|
|
}
|
|
for(old_pt= 0; old_pt < old_count; old_pt++)
|
|
if(old_targets[old_pt] != NULL) /* (should not happen) */
|
|
free(old_targets[old_pt]);
|
|
free((char *) old_targets);
|
|
}
|
|
if(old_nodes != NULL) {
|
|
for(old_pt= 0; old_pt < old_count; old_pt++)
|
|
if(old_nodes[old_pt] != NULL)
|
|
iso_node_unref(old_nodes[old_pt]);
|
|
free((char *) old_nodes);
|
|
}
|
|
xorriso->hln_change_pending= 0;
|
|
ret= 1;
|
|
ex:;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= overwrite existing hln_array (else return 2)
|
|
*/
|
|
int Xorriso_make_hln_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
|
|
if(xorriso->hln_array != NULL && !(flag & 1)) {
|
|
/* If no fresh image manipulations occured: keep old array */
|
|
if(!xorriso->hln_change_pending)
|
|
return(2);
|
|
ret= Xorriso_remake_hln_array(xorriso, 0);
|
|
return(ret);
|
|
}
|
|
Xorriso_destroy_hln_array(xorriso, 0);
|
|
|
|
ret= Xorriso_all_node_array(xorriso, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
Xorriso_sort_node_array(xorriso, 0);
|
|
|
|
/* Transfer node_array to di_array without unrefering nodes */
|
|
xorriso->hln_count= xorriso->node_counter;
|
|
xorriso->hln_array= xorriso->node_array;
|
|
xorriso->node_counter= 0;
|
|
xorriso->node_array_size= 0;
|
|
xorriso->node_array= NULL;
|
|
|
|
/* Allocate hln_targets */
|
|
ret= Xorriso_new_hln_array(xorriso, xorriso->temp_mem_limit, 1);
|
|
if(ret<=0) {
|
|
Xorriso_destroy_hln_array(xorriso, 0);
|
|
goto ex;
|
|
}
|
|
xorriso->node_targets_availmem= xorriso->temp_mem_limit;
|
|
xorriso->hln_change_pending= 0;
|
|
ret= 1;
|
|
ex:;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= overwrite existing di_array (else return 2)
|
|
bit1= make di_array despite xorriso->ino_behavior bit 3
|
|
*/
|
|
int Xorriso_make_di_array(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, bytes;
|
|
|
|
#ifdef NIX
|
|
/* <<< */
|
|
unsigned long old_gdic;
|
|
old_gdic= Xorriso_get_di_counteR;
|
|
#endif /* NIX */
|
|
|
|
if((xorriso->ino_behavior & 8 ) && !(flag & 2))
|
|
return(2);
|
|
if(xorriso->di_array != NULL && !(flag & 1))
|
|
return(2);
|
|
Xorriso_finish_hl_update(xorriso, 0);
|
|
|
|
ret= Xorriso_all_node_array(xorriso, 0, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
bytes= xorriso->node_array_size / 8 + 1;
|
|
xorriso->di_do_widen= calloc(bytes, 1);
|
|
if(xorriso->di_do_widen == NULL) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
ret= -1; goto ex;
|
|
}
|
|
|
|
/* Transfer node_array to di_array without unrefering nodes */
|
|
xorriso->di_count= xorriso->node_counter;
|
|
xorriso->di_array= xorriso->node_array;
|
|
xorriso->node_counter= 0;
|
|
xorriso->node_array_size= 0;
|
|
xorriso->node_array= NULL;
|
|
|
|
Xorriso__sort_di((void *) xorriso->di_array, xorriso->di_count, 0);
|
|
|
|
ret= 1;
|
|
ex:;
|
|
|
|
#ifdef NIX
|
|
/* <<< */
|
|
fprintf(stderr, "xorriso_DEBUG: sort_count= %lu\n",
|
|
Xorriso_get_di_counteR - old_gdic);
|
|
#endif /* NIX */
|
|
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= iso_rr_path is freshly added and up to date
|
|
bit2= -follow: this is not a command parameter
|
|
@return -1= severe error
|
|
0= not applicable for hard links
|
|
1= go on with processing
|
|
2= iso_rr_path is fully updated
|
|
*/
|
|
int Xorriso_hardlink_update(struct XorrisO *xorriso, int *compare_result,
|
|
char *disk_path, char *iso_rr_path, int flag)
|
|
{
|
|
int ret, hret, idx, low, high, i, do_overwrite= 0, did_fake_di= 0;
|
|
int follow_links, old_idx= -1;
|
|
IsoNode *node;
|
|
struct stat stbuf;
|
|
dev_t old_dev;
|
|
ino_t old_ino;
|
|
|
|
if(xorriso->di_array == NULL)
|
|
return(1);
|
|
follow_links= xorriso->do_follow_links ||
|
|
(xorriso->do_follow_param && !(flag & 4));
|
|
ret= Xorriso_node_from_path(xorriso, NULL, iso_rr_path, &node, 0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
if(LIBISO_ISDIR(node))
|
|
return(1);
|
|
|
|
/* Handle eventual hardlink split : */
|
|
/* This is achieved by setting the content change bit. Reason:
|
|
The node needs to be removed from di_array because its di is
|
|
not matching its array index any more. So it becomes invisible for
|
|
the join check of eventual later hardlink siblings. Therefore
|
|
it must be updated now, even if it has currently no siblings
|
|
which it leaves or which it joins.
|
|
*/
|
|
if(!(flag & 1))
|
|
do_overwrite= 1;
|
|
|
|
Xorriso__get_di(node, &old_dev, &old_ino, 0);
|
|
ret= Xorriso__search_node(xorriso->di_array, xorriso->di_count,
|
|
Xorriso__di_cmp, node, &idx, 0);
|
|
if(ret < 0)
|
|
{ret= 0; goto ex;}
|
|
if(ret > 0)
|
|
old_idx= idx;
|
|
|
|
/* Handle eventual hardlink joining : */
|
|
|
|
if(follow_links)
|
|
ret= stat(disk_path, &stbuf);
|
|
else
|
|
ret= lstat(disk_path, &stbuf);
|
|
if(ret==-1)
|
|
{ret= 0; goto ex;}
|
|
|
|
/* Are there new dev-ino-siblings in the image ? */
|
|
/* Fake isofs.di */
|
|
if(!(flag & 1)) {
|
|
ret= Xorriso_record_dev_inode(xorriso, disk_path, stbuf.st_dev,
|
|
stbuf.st_ino, node, iso_rr_path, 1);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
did_fake_di= 1;
|
|
/* temporarily remove node from di_array so it does not disturb
|
|
search by its fake di info */;
|
|
if(old_idx >= 0)
|
|
xorriso->di_array[old_idx]= NULL;
|
|
}
|
|
ret= Xorriso_search_di_range(xorriso, node, &idx, &low, &high, 1);
|
|
if(did_fake_di) {
|
|
/* Revoke fake of isofs.di */
|
|
hret= Xorriso_record_dev_inode(xorriso, disk_path, old_dev, old_ino,
|
|
node, iso_rr_path, 1);
|
|
if(hret <= 0)
|
|
{ret= -1; goto ex;}
|
|
if(old_idx >= 0)
|
|
xorriso->di_array[old_idx]= node;
|
|
}
|
|
if(ret == 0)
|
|
{ret= 1; goto ex;}
|
|
if(ret < 0)
|
|
{ret= 0; goto ex;}
|
|
|
|
|
|
#ifdef Xorriso_hardlink_update_debuG
|
|
/* <<< */
|
|
if(low < high || idx < 0) {
|
|
fprintf(stderr,
|
|
"xorriso_DEBUG: old_idx= %d , low= %d , high= %d , iso= '%s' , disk='%s'\n",
|
|
old_idx, low, high, iso_rr_path, disk_path);
|
|
fprintf(stderr,
|
|
"xorriso_DEBUG: old_dev= %lu , old_ino= %lu , dev= %lu , ino= %lu\n",
|
|
(unsigned long) old_dev, (unsigned long) old_ino,
|
|
(unsigned long) stbuf.st_dev, (unsigned long) stbuf.st_ino);
|
|
|
|
if(idx >= 0 && idx != old_idx)
|
|
fprintf(stderr, "xorriso_DEBUG: idx= %d , old_idx = %d\n", idx, old_idx);
|
|
}
|
|
#endif /* Xorriso_hardlink_update_debuG */
|
|
|
|
/* Overwrite all valid siblings : */
|
|
for(i= low; i <= high; i++) {
|
|
if(i == idx || xorriso->di_array[i] == NULL)
|
|
continue;
|
|
|
|
#ifdef Xorriso_hardlink_update_debuG
|
|
/* <<< */
|
|
{
|
|
ino_t ino;
|
|
dev_t dev;
|
|
|
|
Xorriso__get_di(xorriso->di_array[i], &dev, &ino, 0);
|
|
fprintf(stderr, "xorriso_DEBUG: iso_sibling= '%s' , dev= %lu , ino= %lu\n",
|
|
node_path, (unsigned long) dev, (unsigned long) ino);
|
|
}
|
|
#endif /* Xorriso_hardlink_update_debuG */
|
|
|
|
xorriso->di_do_widen[i / 8]|= 1 << (i % 8);
|
|
}
|
|
|
|
ret= 1;
|
|
ex:;
|
|
if(do_overwrite)
|
|
*compare_result|= (1<<15);
|
|
if(old_idx >= 0 && (*compare_result & (3 << 21))) {
|
|
/* The old di info is obsolete */
|
|
if(xorriso->di_array[old_idx] != NULL)
|
|
iso_node_unref(xorriso->di_array[old_idx]);
|
|
xorriso->di_array[old_idx]= NULL;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param flag bit0= do not destroy di_array
|
|
*/
|
|
int Xorriso_finish_hl_update(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret, zero= 0;
|
|
char *argv[4];
|
|
struct Xorriso_lsT *disk_lst, *iso_lst;
|
|
|
|
if(xorriso->di_array == NULL)
|
|
{ret= 1; goto ex;}
|
|
disk_lst= xorriso->di_disk_paths;
|
|
iso_lst= xorriso->di_iso_paths;
|
|
while(disk_lst != NULL && iso_lst != NULL) {
|
|
argv[0]= Xorriso_lst_get_text(iso_lst, 0);
|
|
argv[1]= "-exec";
|
|
argv[2]= "widen_hardlinks";
|
|
argv[3]= Xorriso_lst_get_text(disk_lst, 0);
|
|
zero= 0;
|
|
ret= Xorriso_option_find(xorriso, 4, argv, &zero, 0); /* -findi */
|
|
if(ret < 0)
|
|
goto ex;
|
|
disk_lst= Xorriso_lst_get_next(disk_lst, 0);
|
|
iso_lst= Xorriso_lst_get_next(iso_lst, 0);
|
|
}
|
|
ret= 1;
|
|
ex:;
|
|
if(!(flag & 1))
|
|
Xorriso_destroy_di_array(xorriso, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
@param flag bit0= do not report to result but only retrieve md5 text
|
|
@return 1= ok, 0= no md5 available, <0= other error
|
|
*/
|
|
int Xorriso_get_md5(struct XorrisO *xorriso, void *in_node, char *path,
|
|
char md5[16], int flag)
|
|
{
|
|
int ret= 1, i;
|
|
char *wpt;
|
|
IsoImage *image;
|
|
IsoNode *node;
|
|
|
|
ret= Xorriso_get_volume(xorriso, &image, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
goto ex;
|
|
}
|
|
if(!LIBISO_ISREG(node))
|
|
return(0);
|
|
ret= iso_file_get_md5(image, (IsoFile *) node, md5, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
if(flag & 1)
|
|
{ret= 1; goto ex;}
|
|
|
|
wpt= xorriso->result_line;
|
|
for(i= 0; i < 16; i++) {
|
|
sprintf(wpt, "%2.2x", ((unsigned char *) md5)[i]);
|
|
wpt+= 2;
|
|
}
|
|
strcpy(wpt, " ");
|
|
wpt+= 2;
|
|
Xorriso_getfname(xorriso, path, 1 | 2);
|
|
ret= 1;
|
|
ex:;
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/* @param node Opaque handle to IsoNode which is to be inquired instead of path if it is not NULL.
|
|
@param path is used as address if node is NULL.
|
|
@param flag bit0= do not report to result but only indicate outcome
|
|
by return value
|
|
bit1= silently ignore nodes without MD5
|
|
bit2= do not only report mismatches but also matches
|
|
@return 3= not a data file
|
|
2= no MD5 attached to node
|
|
1= ok, MD5 compared and matching
|
|
0= not ok, MD5 mismatch
|
|
<0= other error
|
|
*/
|
|
int Xorriso_check_md5(struct XorrisO *xorriso, void *in_node, char *path,
|
|
int flag)
|
|
{
|
|
int ret, wanted, rret;
|
|
IsoImage *image;
|
|
IsoNode *node;
|
|
IsoFile *file;
|
|
char node_md5[16], data_md5[16], buffer[64 * 1024];
|
|
void *stream= NULL, *ctx= NULL;
|
|
off_t todo;
|
|
|
|
node= (IsoNode *) in_node;
|
|
if(node == NULL) {
|
|
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
|
|
if(ret<=0)
|
|
{ret= -1; goto ex;}
|
|
}
|
|
if(!LIBISO_ISREG(node)) {
|
|
strcpy(xorriso->info_text, "-check_md5: Not a data file: ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
if(!(flag & 2))
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= 3; goto ex;
|
|
}
|
|
file= (IsoFile *) node;
|
|
|
|
/* obtain MD5 */
|
|
ret= Xorriso_get_volume(xorriso, &image, 0);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
ret= iso_file_get_md5(image, file, node_md5, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret < 0)
|
|
{ret= -1; goto ex;}
|
|
if(ret == 0) {
|
|
strcpy(xorriso->info_text, "-check_md5: No MD5 recorded with file: ");
|
|
Text_shellsafe(path, xorriso->info_text, 1);
|
|
if(!(flag & 2))
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
|
|
ret= 2; goto ex;
|
|
}
|
|
|
|
/* Read file and compute MD5 */;
|
|
ret= Xorriso_iso_file_open(xorriso, path, (void *) node, &stream, 1 | 2);
|
|
if(ret <= 0)
|
|
{ret= -1; goto ex;}
|
|
ret= iso_md5_start(&ctx);
|
|
if(ret < 0)
|
|
goto ex;
|
|
todo= iso_stream_get_size(stream);
|
|
while(todo > 0) {
|
|
if(todo < sizeof(buffer))
|
|
wanted= todo;
|
|
else
|
|
wanted= sizeof(buffer);
|
|
rret = Xorriso_iso_file_read(xorriso, stream, buffer, wanted, 0);
|
|
if(rret <= 0)
|
|
{ret= -1; goto ex;}
|
|
todo-= rret;
|
|
ret = iso_md5_compute(ctx, buffer, rret);
|
|
if(ret < 0)
|
|
goto ex;
|
|
xorriso->pacifier_count+= rret;
|
|
xorriso->pacifier_byte_count+= rret;
|
|
Xorriso_pacifier_callback(xorriso, "content bytes read",
|
|
xorriso->pacifier_count, 0, "", 0);
|
|
}
|
|
ret= iso_md5_end(&ctx, data_md5);
|
|
if(ret < 0)
|
|
goto ex;
|
|
|
|
/* Report outcome */
|
|
if(! iso_md5_match(node_md5, data_md5)) {
|
|
sprintf(xorriso->result_line, "MD5 MISMATCH: ");
|
|
Text_shellsafe(path, xorriso->result_line, 1);
|
|
strcat(xorriso->result_line, "\n");
|
|
if(!(flag & 1))
|
|
Xorriso_result(xorriso,0);
|
|
ret= 0;
|
|
} else {
|
|
sprintf(xorriso->result_line, "md5 match : ");
|
|
Text_shellsafe(path, xorriso->result_line, 1);
|
|
strcat(xorriso->result_line, "\n");
|
|
if(flag & 4)
|
|
Xorriso_result(xorriso,0);
|
|
ret= 1;
|
|
}
|
|
|
|
ex:;
|
|
Xorriso_iso_file_close(xorriso, &stream, 0);
|
|
if(ctx != NULL)
|
|
iso_md5_end(&ctx, data_md5);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_check_md5_range(struct XorrisO *xorriso, off_t start_lba,
|
|
off_t end_lba, char md5[16], int flag)
|
|
{
|
|
int ret;
|
|
struct burn_drive_info *dinfo= NULL;
|
|
struct burn_drive *drive= NULL;
|
|
off_t pos, data_count, to_read;
|
|
char data[64 * 1024], data_md5[16];
|
|
void *ctx = NULL;
|
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
|
|
"on attempt to check session MD5 checksum", 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
ret= iso_md5_start(&ctx);
|
|
if(ret <= 0) {
|
|
Xorriso_no_malloc_memory(xorriso, NULL, 0);
|
|
goto ex;
|
|
}
|
|
for(pos= start_lba; pos < end_lba; pos+= 32) {
|
|
to_read= 32;
|
|
if(pos + to_read > end_lba)
|
|
to_read= end_lba - pos;
|
|
ret= burn_read_data(drive, pos * (off_t) 2048, data,
|
|
to_read * (off_t) 2048, &data_count, 0);
|
|
if(ret <= 0)
|
|
goto ex;
|
|
iso_md5_compute(ctx, data, (int) data_count);
|
|
xorriso->pacifier_count+= data_count;
|
|
xorriso->pacifier_byte_count+= data_count;
|
|
Xorriso_pacifier_callback(xorriso, "content bytes read",
|
|
xorriso->pacifier_count, 0, "", 0);
|
|
}
|
|
iso_md5_end(&ctx, data_md5);
|
|
ret= 1;
|
|
if(! iso_md5_match(md5, data_md5))
|
|
ret= 0;
|
|
ex:;
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ctx != NULL)
|
|
iso_md5_end(&ctx, data_md5);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_check_session_md5(struct XorrisO *xorriso, char *severity,
|
|
int flag)
|
|
{
|
|
int ret, i;
|
|
IsoImage *image;
|
|
uint32_t start_lba, end_lba;
|
|
char md5[16], md5_text[33];
|
|
|
|
ret= Xorriso_get_volume(xorriso, &image, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= iso_image_get_session_md5(image, &start_lba, &end_lba, md5, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret < 0)
|
|
return(ret);
|
|
if(ret == 0) {
|
|
sprintf(xorriso->info_text,
|
|
"No session MD5 is recorded with the loaded session");
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
|
|
return(0);
|
|
}
|
|
|
|
sprintf(xorriso->info_text, "Checking loaded session by its recorded MD5.\n");
|
|
Xorriso_info(xorriso, 0);
|
|
for(i= 0; i < 16; i++)
|
|
sprintf(md5_text + 2 * i, "%2.2x", ((unsigned char *) md5)[i]);
|
|
sprintf(xorriso->result_line,
|
|
"Session MD5 %s , LBA %.f , %.f blocks\n",
|
|
md5_text, (double) start_lba, (double) end_lba - start_lba);
|
|
Xorriso_result(xorriso,0);
|
|
ret= Xorriso_check_md5_range(xorriso, (off_t) start_lba, (off_t) end_lba,
|
|
md5, 0);
|
|
return(ret);
|
|
}
|
|
|
|
|
|
int Xorriso_image_has_md5(struct XorrisO *xorriso, int flag)
|
|
{
|
|
int ret;
|
|
IsoImage *image;
|
|
uint32_t start_lba, end_lba;
|
|
char md5[16];
|
|
|
|
ret= Xorriso_get_volume(xorriso, &image, 0);
|
|
if(ret<=0)
|
|
return(ret);
|
|
ret= iso_image_get_session_md5(image, &start_lba, &end_lba, md5, 0);
|
|
Xorriso_process_msg_queues(xorriso,0);
|
|
if(ret <= 0)
|
|
return(ret);
|
|
return(1);
|
|
}
|