filesrc.c File Reference

#include "libisofs.h"
#include "filesrc.h"
#include "node.h"
#include "util.h"
#include "writer.h"
#include "messages.h"
#include "image.h"
#include "stream.h"
#include "md5.h"
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>

Include dependency graph for filesrc.c:

Go to the source code of this file.

Macros
#define	PATH_MAX   Libisofs_default_path_maX

Functions
int	iso_file_src_cmp (const void *n1, const void *n2)
int	iso_file_src_create (Ecma119Image *img, IsoFile *file, IsoFileSrc **src)
	Create a new IsoFileSrc to get data from a specific IsoFile. More...
int	iso_file_src_add (Ecma119Image *img, IsoFileSrc *new, IsoFileSrc **src)
	Add a given IsoFileSrc to the given image target. More...
void	iso_file_src_free (void *node)
	Free the IsoFileSrc especific data. More...
off_t	iso_file_src_get_size (IsoFileSrc *file)
	Get the size of the file this IsoFileSrc represents. More...
static int	cmp_by_weight (const void *f1, const void *f2)
static int	shall_be_written (void *arg)
static int	shall_be_written_if_not_taken (void *arg)
int	filesrc_writer_pre_compute (IsoImageWriter *writer)
	Determine number of filesrc blocks in the image and compute extent addresses relative to start of the file source writer area. More...
static int	filesrc_writer_compute_data_blocks (IsoImageWriter *writer)
static int	filesrc_writer_write_vol_desc (IsoImageWriter *writer)
static int	filesrc_open (IsoFileSrc *file)
static int	filesrc_close (IsoFileSrc *file)
static int	filesrc_read (IsoFileSrc *file, char *buf, size_t count)
static int	filesrc_make_md5 (Ecma119Image *t, IsoFileSrc *file, char md5[16], int flag)
int	iso_filesrc_write_data (Ecma119Image *t, IsoFileSrc *file, char *name, char *buffer, int flag)
	Write the content of file into the output stream of t. More...
static int	filesrc_writer_write_data (IsoImageWriter *writer)
static int	filesrc_writer_free_data (IsoImageWriter *writer)
int	iso_file_src_writer_create (Ecma119Image *target)
	Create a Writer for file contents. More...

Macro Definition Documentation

PATH_MAX

#define PATH_MAX   Libisofs_default_path_maX

Definition at line 48 of file filesrc.c.

Function Documentation

cmp_by_weight()

static int cmp_by_weight ( const void *  f1, const void *  f2  )

static

Definition at line 217 of file filesrc.c.

{
    IsoFileSrc *f = *((IsoFileSrc**)f1);
    IsoFileSrc *g = *((IsoFileSrc**)f2);
    /* higher weighted first */
    return g->sort_weight - f->sort_weight;
}

References Iso_File_Src::sort_weight.

Referenced by filesrc_writer_pre_compute().

filesrc_close()

static int filesrc_close ( IsoFileSrc *  file )

inlinestatic

Definition at line 400 of file filesrc.c.

{
    return iso_stream_close(file->stream);
}

References iso_stream_close(), and Iso_File_Src::stream.

Referenced by iso_filesrc_write_data().

filesrc_make_md5()

static int filesrc_make_md5 ( Ecma119Image *  t, IsoFileSrc *  file, char  md5[16], int  flag  )

static

Definition at line 422 of file filesrc.c.

{
    return iso_stream_make_md5(file->stream, md5, 0);
}

References iso_stream_make_md5(), and Iso_File_Src::stream.

Referenced by iso_filesrc_write_data().

filesrc_open()

static int filesrc_open ( IsoFileSrc *  file )

inlinestatic

Definition at line 394 of file filesrc.c.

{
    return iso_stream_open(file->stream);
}

References iso_stream_open(), and Iso_File_Src::stream.

Referenced by iso_filesrc_write_data().

filesrc_read()

static int filesrc_read ( IsoFileSrc *  file, char *  buf, size_t  count  )

static

Returns

1 ok, 0 EOF, < 0 error

Definition at line 410 of file filesrc.c.

{
    size_t got;
 
    return iso_stream_read_buffer(file->stream, buf, count, &got);
}

References iso_stream_read_buffer(), and Iso_File_Src::stream.

Referenced by iso_filesrc_write_data().

filesrc_writer_compute_data_blocks()

static int filesrc_writer_compute_data_blocks ( IsoImageWriter *  writer )

static

Definition at line 346 of file filesrc.c.

{
    Ecma119Image *t;
    int extent = 0;
    size_t  i;
    IsoFileSrc *file;
    IsoFileSrc **filelist;
 
    if (writer == NULL) {
        return ISO_ASSERT_FAILURE;
    }
    t = writer->target;
    filelist = (IsoFileSrc **) writer->data;
 
    /* >>> HFS: need to align to allocation block size */;
    /* >>> HFS: ??? how to handle multi-extent files ? */;
 
    t->filesrc_start = t->curblock;
 
    /* Give all extent addresses their final absolute value */
    i = 0;
    while ((file = filelist[i++]) != NULL) {
 
       /* Skip external partitions */ 
       if (file->no_write)
    continue;
 
       for (extent = 0; extent < file->nsections; ++extent) {
            if (file->sections[extent].block == 0xffffffff)
                file->sections[extent].block = t->empty_file_block;
            else
                file->sections[extent].block += t->curblock;
       }
    }
 
    t->curblock += t->filesrc_blocks;
    return ISO_SUCCESS;
}

References iso_file_section::block, ecma119_image::curblock, Iso_Image_Writer::data, ecma119_image::empty_file_block, ecma119_image::filesrc_blocks, ecma119_image::filesrc_start, ISO_ASSERT_FAILURE, ISO_SUCCESS, Iso_File_Src::no_write, Iso_File_Src::nsections, Iso_File_Src::sections, and Iso_Image_Writer::target.

Referenced by iso_file_src_writer_create().

filesrc_writer_free_data()

static int filesrc_writer_free_data ( IsoImageWriter *  writer )

static

Definition at line 714 of file filesrc.c.

{
    /* free the list of files (contents are free together with the tree) */
    free(writer->data);
    return ISO_SUCCESS;
}

References Iso_Image_Writer::data, and ISO_SUCCESS.

Referenced by iso_file_src_writer_create().

filesrc_writer_pre_compute()

int filesrc_writer_pre_compute

(

IsoImageWriter *

writer

)

Determine number of filesrc blocks in the image and compute extent addresses relative to start of the file source writer area.

filesrc_writer_compute_data_blocks() later makes them absolute.

Definition at line 239 of file filesrc.c.

{
    size_t i, size, is_external;
    Ecma119Image *t;
    IsoFileSrc **filelist;
    int (*inc_item)(void *);
    size_t omitted_count;
    IsoFileSrc **iso_ecma119_to_filesrc_array(Ecma119Image *t,
                                              int (*include_item)(void *),
                                              size_t *size);
 
    if (writer == NULL) {
        return ISO_ASSERT_FAILURE;
    }
 
    t = writer->target;
    t->filesrc_blocks = 0;
 
    /* Normally reserve a single zeroed block for all files which have
       no block address: symbolic links, device files, empty data files.
    */
    if (! t->opts->old_empty)
        t->filesrc_blocks++;
 
    /* on appendable images, ms files shouldn't be included */
    if (t->opts->appendable) {
        inc_item = shall_be_written;
    } else {
        inc_item = NULL;
    }
 
    /* store the filesrcs in a array */
    filelist = (IsoFileSrc**) iso_ecma119_to_filesrc_array(t, inc_item, &size);
    omitted_count = iso_rbtree_count_array(t->files, (size_t) 0,
                                           shall_be_written_if_not_taken);
    if (omitted_count > 0) {
        iso_msg_submit(t->image->id, ISO_NOT_REPRODUCIBLE, 0,
            "Cannot arrange content of data files in surely reproducible way");
        LIBISO_FREE_MEM(filelist);
        filelist = (IsoFileSrc**)iso_rbtree_to_array(
                                                    t->files, inc_item, &size);
    }
    if (filelist == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    /* sort files by weight, if needed */
    if (t->opts->sort_files) {
        qsort(filelist, size, sizeof(void*), cmp_by_weight);
    }
 
    /* fill block value */
    for (i = 0; i < size; ++i) {
        int extent = 0;
        IsoFileSrc *file = filelist[i];
        off_t section_size;
 
        /* 0xfffffffe in emerging image means that this is an external
           partition. Only assess extent sizes but do not count as part
           of filesrc_writer output.
        */
        is_external = (file->no_write == 0 &&
                       file->sections[0].block == 0xfffffffe);
 
        section_size = iso_stream_get_size(file->stream);
        for (extent = 0; extent < file->nsections - 1; ++extent) {
            file->sections[extent].block = t->filesrc_blocks + extent *
                        (ISO_EXTENT_SIZE / BLOCK_SIZE);
            file->sections[extent].size = ISO_EXTENT_SIZE;
            section_size -= (off_t) ISO_EXTENT_SIZE;
        }
 
        /*
         * final section
         */
        if (section_size <= 0) {
            /* Will become t->empty_file_block
               in filesrc_writer_compute_data_blocks()
               Special use of 0xffffffe0 to 0xffffffff is covered by
               mspad_writer which enforces a minimum start of filesrc at
               block 0x00000020.
            */
            file->sections[extent].block = 0xffffffff;
        } else {
            file->sections[extent].block =
                   t->filesrc_blocks + extent * (ISO_EXTENT_SIZE / BLOCK_SIZE);
        }
        file->sections[extent].size = (uint32_t)section_size;
 
        /* 0xfffffffe in emerging image means that this is an external
           partition. Others will take care of the content data.
        */
        if (is_external) {
            file->sections[0].block = 0xfffffffe;
            file->no_write = 1; /* Ban for filesrc_writer */
    continue;
        }
 
        t->filesrc_blocks += DIV_UP(iso_file_src_get_size(file), BLOCK_SIZE);
    }
 
    /* the list is only needed by this writer, store locally */
    writer->data = filelist;
    return ISO_SUCCESS;
}

References iso_write_opts::appendable, iso_file_section::block, BLOCK_SIZE, cmp_by_weight(), Iso_Image_Writer::data, DIV_UP, ecma119_image::files, ecma119_image::filesrc_blocks, Iso_Image::id, ecma119_image::image, ISO_ASSERT_FAILURE, iso_ecma119_to_filesrc_array(), ISO_EXTENT_SIZE, iso_file_src_get_size(), iso_msg_submit(), ISO_NOT_REPRODUCIBLE, ISO_OUT_OF_MEM, iso_rbtree_count_array(), iso_rbtree_to_array(), iso_stream_get_size(), ISO_SUCCESS, LIBISO_FREE_MEM, Iso_File_Src::no_write, Iso_File_Src::nsections, iso_write_opts::old_empty, ecma119_image::opts, Iso_File_Src::sections, shall_be_written(), shall_be_written_if_not_taken(), iso_file_section::size, iso_write_opts::sort_files, Iso_File_Src::stream, and Iso_Image_Writer::target.

Referenced by ecma119_image_new().

filesrc_writer_write_data()

static int filesrc_writer_write_data ( IsoImageWriter *  writer )

static

Definition at line 658 of file filesrc.c.

{
    int ret;
    size_t i;
    Ecma119Image *t = NULL;
    IsoFileSrc *file;
    IsoFileSrc **filelist;
    char *name = NULL;
    char *buffer = NULL;
 
    if (writer == NULL) {
        ret = ISO_ASSERT_FAILURE; goto ex;
    }
 
    LIBISO_ALLOC_MEM(name, char, PATH_MAX);
    LIBISO_ALLOC_MEM(buffer, char, BLOCK_SIZE);
    t = writer->target;
    filelist = writer->data;
 
    iso_msg_debug(t->image->id, "Writing Files...");
 
    /* Normally write a single zeroed block as block address target for all
       files which have no block address:
       symbolic links, device files, empty data files.
    */
    if (! t->opts->old_empty) {
        ret = iso_write(t, buffer, BLOCK_SIZE);
        if (ret < 0)
            goto ex;
    }
 
    i = 0;
    while ((file = filelist[i++]) != NULL) {
        if (file->no_write) {
            /* Do not write external partitions */
            iso_msg_debug(t->image->id,
                          "filesrc_writer: Skipping no_write-src [%.f , %.f]",
                          (double) file->sections[0].block, 
                          (double) (file->sections[0].block - 1 +
                                (file->sections[0].size + 2047) / BLOCK_SIZE));
    continue;
        }
        ret = iso_filesrc_write_data(t, file, name, buffer, 0);
        if (ret < 0)
            goto ex;
    }
 
    ret = ISO_SUCCESS;
ex:;
    LIBISO_FREE_MEM(buffer);
    LIBISO_FREE_MEM(name);
    return ret;
}

References iso_file_section::block, BLOCK_SIZE, Iso_Image_Writer::data, Iso_Image::id, ecma119_image::image, ISO_ASSERT_FAILURE, iso_filesrc_write_data(), iso_msg_debug(), ISO_SUCCESS, iso_write(), LIBISO_ALLOC_MEM, LIBISO_FREE_MEM, Iso_File_Src::no_write, iso_write_opts::old_empty, ecma119_image::opts, PATH_MAX, Iso_File_Src::sections, iso_file_section::size, and Iso_Image_Writer::target.

Referenced by iso_file_src_writer_create().

filesrc_writer_write_vol_desc()

static int filesrc_writer_write_vol_desc ( IsoImageWriter *  writer )

static

Definition at line 386 of file filesrc.c.

{
    /* nothing needed */
    return ISO_SUCCESS;
}

References ISO_SUCCESS.

Referenced by iso_file_src_writer_create().

iso_file_src_add()

int iso_file_src_add	(	Ecma119Image *	img,
		IsoFileSrc *	new,
		IsoFileSrc **	src
	)

Add a given IsoFileSrc to the given image target.

The IsoFileSrc will be cached in a tree to prevent the same file for being written several times to image. If you call again this function with a node that refers to the same source file, the previously created one will be returned.

Parameters

img	The image where this file is to be written
new	The IsoFileSrc to add
src	Will be filled with a pointer to the IsoFileSrc really present in the tree. It could be different than new if the same file already exists in the tree.

Returns

1 on success, 0 if file already exists on tree, < 0 error

Definition at line 192 of file filesrc.c.

{
    int ret;
 
    if (img == NULL || new == NULL || src == NULL) {
        return ISO_NULL_POINTER;
    }
 
    /* insert the filesrc in the tree */
    ret = iso_rbtree_insert(img->files, new, (void**)src);
    return ret;
}

References ecma119_image::files, ISO_NULL_POINTER, and iso_rbtree_insert().

Referenced by el_torito_catalog_file_src_create().

iso_file_src_cmp()

int iso_file_src_cmp	(	const void *	n1,
		const void *	n2
	)

Definition at line 52 of file filesrc.c.

{
    int ret;
    const IsoFileSrc *f1, *f2;
 
    if (n1 == n2) {
        return 0; /* Normally just a shortcut.
                     But important if Libisofs_file_src_cmp_non_zerO */
    }
 
    f1 = (const IsoFileSrc *)n1;
    f2 = (const IsoFileSrc *)n2;
 
    ret = iso_stream_cmp_ino(f1->stream, f2->stream, 0);
    return ret;
}

References iso_stream_cmp_ino(), and Iso_File_Src::stream.

Referenced by ecma119_image_new().

iso_file_src_create()

int iso_file_src_create	(	Ecma119Image *	img,
		IsoFile *	file,
		IsoFileSrc **	src
	)

Create a new IsoFileSrc to get data from a specific IsoFile.

The IsoFileSrc will be cached in a tree to prevent the same file for being written several times to image. If you call again this function with a node that refers to the same source file, the previously created one will be returned. No new IsoFileSrc is created in that case.

Parameters

img	The image where this file is to be written
file	The IsoNode we want to write
src	Will be filled with a pointer to the IsoFileSrc

Returns

1 if new object was created, 0 if object existed, < 0 on error

Definition at line 69 of file filesrc.c.

{
    int ret, i;
    IsoFileSrc *fsrc;
    unsigned int fs_id;
    dev_t dev_id;
    ino_t ino_id;
    int cret, no_md5= 0;
    void *xipt = NULL;
 
    if (img == NULL || file == NULL || src == NULL) {
        return ISO_NULL_POINTER;
    }
 
    iso_stream_get_id(file->stream, &fs_id, &dev_id, &ino_id);
 
    fsrc = calloc(1, sizeof(IsoFileSrc));
    if (fsrc == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    /* fill key and other atts */
    fsrc->no_write = (file->from_old_session && img->opts->appendable);
    if (file->from_old_session && img->opts->appendable) {
        /*
         * On multisession discs we keep file sections from old image.
         */
        int ret = iso_file_get_old_image_sections(file, &(fsrc->nsections),
                                                  &(fsrc->sections), 0);
        if (ret < 0) {
            free(fsrc);
            return ISO_OUT_OF_MEM;
        }
    } else {
 
        /*
         * For new files, or for image copy, we compute our own file sections.
         * Block and size of each section will be filled later.
         */
        off_t section_size = iso_stream_get_size(file->stream);
        if (section_size > (off_t) MAX_ISO_FILE_SECTION_SIZE) {
            fsrc->nsections = DIV_UP(section_size - (off_t) MAX_ISO_FILE_SECTION_SIZE,
                                     (off_t)ISO_EXTENT_SIZE) + 1;
        } else {
            fsrc->nsections = 1;
        }
        fsrc->sections = calloc(fsrc->nsections,
                                sizeof(struct iso_file_section));
        if (fsrc->sections == NULL) {
            free(fsrc);
            return ISO_OUT_OF_MEM;
        }
        for (i = 0; i < fsrc->nsections; i++)
            fsrc->sections[i].block = 0;
    }
    fsrc->sort_weight = file->sort_weight;
    fsrc->stream = file->stream;
 
    /* insert the filesrc in the tree */
    ret = iso_rbtree_insert(img->files, fsrc, (void**)src);
    if (ret <= 0) {
        if (ret == 0 && (*src)->checksum_index > 0 &&
            !img->opts->will_cancel) {
            /* Duplicate file source was mapped to previously registered source
            */
            cret = iso_file_set_isofscx(file, (*src)->checksum_index, 0);
            if (cret < 0)
                ret = cret;
        }
        free(fsrc->sections);
        free(fsrc);
        return ret;
    }
    iso_stream_ref(fsrc->stream);
 
    if ((img->opts->md5_file_checksums & 1) &&
        file->from_old_session && img->opts->appendable) {
        ret = iso_node_get_xinfo((IsoNode *) file, checksum_md5_xinfo_func,
                                  &xipt);
        if (ret <= 0)
            ret = iso_node_get_xinfo((IsoNode *) file, checksum_cx_xinfo_func,
                                      &xipt);
        if (ret <= 0)
            /* Omit MD5 indexing with old image nodes which have no MD5 */
            no_md5 = 1;
    }
 
    if ((img->opts->md5_file_checksums & 1) &&
        !(no_md5 || img->opts->will_cancel)) {
        img->checksum_idx_counter++;
        if (img->checksum_idx_counter < 0x7fffffff) {
            fsrc->checksum_index = img->checksum_idx_counter;
        } else {
            fsrc->checksum_index= 0;
            img->checksum_idx_counter= 0x7ffffffe; /* keep from rolling over */
        }
        cret = iso_file_set_isofscx(file, (*src)->checksum_index, 0);
        if (cret < 0)
            return cret;
    }
 
    return ISO_SUCCESS;
}

References iso_write_opts::appendable, iso_file_section::block, checksum_cx_xinfo_func(), ecma119_image::checksum_idx_counter, Iso_File_Src::checksum_index, checksum_md5_xinfo_func(), DIV_UP, ecma119_image::files, Iso_File::from_old_session, ISO_EXTENT_SIZE, iso_file_get_old_image_sections(), iso_file_set_isofscx(), iso_node_get_xinfo(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, iso_rbtree_insert(), iso_stream_get_id(), iso_stream_get_size(), iso_stream_ref(), ISO_SUCCESS, MAX_ISO_FILE_SECTION_SIZE, iso_write_opts::md5_file_checksums, Iso_File_Src::no_write, Iso_File_Src::nsections, ecma119_image::opts, Iso_File_Src::sections, Iso_File_Src::sort_weight, Iso_File::sort_weight, Iso_File_Src::stream, Iso_File::stream, and iso_write_opts::will_cancel.

Referenced by create_file_src(), create_node(), create_tree(), ecma119_writer_create(), and eltorito_writer_create().

iso_file_src_free()

void iso_file_src_free

(

void *

node

)

Free the IsoFileSrc especific data.

Definition at line 205 of file filesrc.c.

{
    iso_stream_unref(((IsoFileSrc*)node)->stream);
    free(((IsoFileSrc*)node)->sections);
    free(node);
}

References iso_stream_unref().

Referenced by ecma119_image_free().

iso_file_src_get_size()

off_t iso_file_src_get_size

(

IsoFileSrc *

file

)

Get the size of the file this IsoFileSrc represents.

Definition at line 212 of file filesrc.c.

{
    return iso_stream_get_size(file->stream);
}

References iso_stream_get_size(), and Iso_File_Src::stream.

Referenced by filesrc_writer_pre_compute(), and iso_filesrc_write_data().

iso_file_src_writer_create()

int iso_file_src_writer_create

(

Ecma119Image *

target

)

Create a Writer for file contents.

It takes care of written the files in the correct order.

Definition at line 721 of file filesrc.c.

{
    IsoImageWriter *writer;
 
    writer = calloc(1, sizeof(IsoImageWriter));
    if (writer == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    writer->compute_data_blocks = filesrc_writer_compute_data_blocks;
    writer->write_vol_desc = filesrc_writer_write_vol_desc;
    writer->write_data = filesrc_writer_write_data;
    writer->free_data = filesrc_writer_free_data;
    writer->data = NULL;
    writer->target = target;
 
    /* add this writer to image */
    target->writers[target->nwriters++] = writer;
 
    return ISO_SUCCESS;
}

References Iso_Image_Writer::compute_data_blocks, Iso_Image_Writer::data, filesrc_writer_compute_data_blocks(), filesrc_writer_free_data(), filesrc_writer_write_data(), filesrc_writer_write_vol_desc(), Iso_Image_Writer::free_data, ISO_OUT_OF_MEM, ISO_SUCCESS, ecma119_image::nwriters, Iso_Image_Writer::target, Iso_Image_Writer::write_data, Iso_Image_Writer::write_vol_desc, and ecma119_image::writers.

Referenced by ecma119_image_new().

iso_filesrc_write_data()

int iso_filesrc_write_data	(	Ecma119Image *	t,
		IsoFileSrc *	file,
		char *	name,
		char *	buffer,
		int	flag
	)

Write the content of file into the output stream of t.

name must be NULL or offer at least PATH_MAX characters of storage. buffer must be NULL or offer at least BLOCK_SIZE characters of storage. flag is not used yet, submit 0.

Definition at line 430 of file filesrc.c.

{
    int res, ret, was_error;
    char *name_data = NULL;
    char *buffer_data = NULL;
    size_t b;
    off_t file_size;
    uint32_t nblocks;
    void *ctx= NULL;
    char md5[16], pre_md5[16];
    int pre_md5_valid = 0;
    IsoStream *stream, *inp;
 
#ifdef Libisofs_with_libjtE
    int jte_begun = 0;
#endif
 
    if (name == NULL) {
        LIBISO_ALLOC_MEM(name_data, char, PATH_MAX);
        name = name_data;
    }
    if (buffer == NULL) {
        LIBISO_ALLOC_MEM(buffer_data, char, BLOCK_SIZE);
        buffer = buffer_data;
    }
 
    was_error = 0;
    file_size = iso_file_src_get_size(file);
    nblocks = DIV_UP(file_size, BLOCK_SIZE);
    pre_md5_valid = 0; 
    if (file->checksum_index > 0 && (t->opts->md5_file_checksums & 2)) {
        /* Obtain an MD5 of content by a first read pass */
        pre_md5_valid = filesrc_make_md5(t, file, pre_md5, 0);
    }
    res = filesrc_open(file);
 
    /* Get file name from end of filter chain */
    for (stream = file->stream; ; stream = inp) {
        inp = iso_stream_get_input_stream(stream, 0);
        if (inp == NULL)
    break;
    }
    iso_stream_get_file_name(stream, name);
    if (res < 0) {
        /*
         * UPS, very ugly error, the best we can do is just to write
         * 0's to image
         */
        iso_report_errfile(name, ISO_FILE_CANT_WRITE, 0, 0);
        was_error = 1;
        res = iso_msg_submit(t->image->id, ISO_FILE_CANT_WRITE, res,
                  "File \"%s\" can't be opened. Filling with 0s.", name);
        if (res < 0) {
            ret = res; /* aborted due to error severity */
            goto ex;
        }
        memset(buffer, 0, BLOCK_SIZE);
        for (b = 0; b < nblocks; ++b) {
            res = iso_write(t, buffer, BLOCK_SIZE);
            if (res < 0) {
                /* ko, writer error, we need to go out! */
                ret = res;
                goto ex;
            }
        }
        ret = ISO_SUCCESS;
        goto ex;
    } else if (res > 1) {
        iso_report_errfile(name, ISO_FILE_CANT_WRITE, 0, 0);
        was_error = 1;
        res = iso_msg_submit(t->image->id, ISO_FILE_CANT_WRITE, 0,
                  "Size of file \"%s\" has changed. It will be %s", name,
                  (res == 2 ? "truncated" : "padded with 0's"));
        if (res < 0) {
            filesrc_close(file);
            ret = res; /* aborted due to error severity */
            goto ex;
        }
    }
#ifdef LIBISOFS_VERBOSE_DEBUG
    else {
        iso_msg_debug(t->image->id, "Writing file %s", name);
    }
#endif
 
    /* >>> HFS: need to align to allocation block size */;
 
#ifdef Libisofs_with_libjtE
    if (t->opts->libjte_handle != NULL) {
        res = libjte_begin_data_file(t->opts->libjte_handle, name,
                                     BLOCK_SIZE, file_size);
        if (res <= 0) {
            res = iso_libjte_forward_msgs(t->opts->libjte_handle, t->image->id,
                                    ISO_LIBJTE_FILE_FAILED, 0);
            if (res < 0) {
                filesrc_close(file);
                ret = ISO_LIBJTE_FILE_FAILED;
                goto ex;
            }
        }
        jte_begun = 1;
    }
#endif /* Libisofs_with_libjtE */
 
    if (file->checksum_index > 0) {
        /* initialize file checksum */
        res = iso_md5_start(&ctx);
        if (res <= 0)
            file->checksum_index = 0;
    }
    /* write file contents to image */
    for (b = 0; b < nblocks; ++b) {
        int wres;
        res = filesrc_read(file, buffer, BLOCK_SIZE);
        if (res < 0) {
            /* read error */
            break;
        }
        wres = iso_write(t, buffer, BLOCK_SIZE);
        if (wres < 0) {
            /* ko, writer error, we need to go out! */
            filesrc_close(file);
            ret = wres;
            goto ex;
        }
        if (file->checksum_index > 0) {
            /* Add to file checksum */
            if (file_size - b * BLOCK_SIZE > BLOCK_SIZE)
                res = BLOCK_SIZE;
            else
                res = file_size - b * BLOCK_SIZE;
            res = iso_md5_compute(ctx, buffer, res);
            if (res <= 0)
                file->checksum_index = 0;
        }
    }
 
    filesrc_close(file);
 
    if (b < nblocks) {
        /* premature end of file, due to error or eof */
        iso_report_errfile(name, ISO_FILE_CANT_WRITE, 0, 0);
        was_error = 1;
        if (res < 0) {
            /* error */
            res = iso_msg_submit(t->image->id, ISO_FILE_CANT_WRITE, res,
                           "Read error in file %s.", name);
        } else {
            /* eof */
            res = iso_msg_submit(t->image->id, ISO_FILE_CANT_WRITE, 0,
                          "Premature end of file %s.", name);
        }
 
        if (res < 0) {
            ret = res; /* aborted due error severity */
            goto ex;
        }
 
        /* fill with 0s */
        iso_msg_submit(t->image->id, ISO_FILE_CANT_WRITE, 0,
                       "Filling with 0");
        memset(buffer, 0, BLOCK_SIZE);
        while (b++ < nblocks) {
            res = iso_write(t, buffer, BLOCK_SIZE);
            if (res < 0) {
                /* ko, writer error, we need to go out! */
                ret = res;
                goto ex;
            }
            if (file->checksum_index > 0) {
                /* Add to file checksum */
                if (file_size - b * BLOCK_SIZE > BLOCK_SIZE)
                    res = BLOCK_SIZE;
                else
                    res = file_size - b * BLOCK_SIZE;
                res = iso_md5_compute(ctx, buffer, res);
                if (res <= 0)
                    file->checksum_index = 0;
            }
        }
    }
    if (file->checksum_index > 0 &&
        file->checksum_index <= t->checksum_idx_counter) {
        /* Obtain checksum and dispose checksum context */
        res = iso_md5_end(&ctx, md5);
        if (res <= 0)
            file->checksum_index = 0;
        if ((t->opts->md5_file_checksums & 2) && pre_md5_valid > 0 &&
            !was_error) {
            if (! iso_md5_match(md5, pre_md5)) {
                /* Issue MISHAP event */
                iso_report_errfile(name, ISO_MD5_STREAM_CHANGE, 0, 0);
                was_error = 1;
                res = iso_msg_submit(t->image->id, ISO_MD5_STREAM_CHANGE,0,
       "Content of file '%s' changed while it was written into the image.",
                                     name);
                if (res < 0) {
                    ret = res; /* aborted due to error severity */
                    goto ex;
                }
            }
        }
        /* Write md5 into checksum buffer at file->checksum_index */
        memcpy(t->checksum_buffer + 16 * file->checksum_index, md5, 16);
    }
 
    ret = ISO_SUCCESS;
ex:;
    if (ctx != NULL) /* avoid any memory leak */
        iso_md5_end(&ctx, md5);
 
#ifdef Libisofs_with_libjtE
    if (jte_begun) {
        res = libjte_end_data_file(t->opts->libjte_handle);
        iso_libjte_forward_msgs(t->opts->libjte_handle, t->image->id,
                                ISO_LIBJTE_END_FAILED, 0);
        if (res <= 0 && ret >= 0)
            ret = ISO_LIBJTE_FILE_FAILED;
    }
#endif /* Libisofs_with_libjtE */
 
    LIBISO_FREE_MEM(buffer_data);
    LIBISO_FREE_MEM(name_data);
    return ret;
}

References BLOCK_SIZE, ecma119_image::checksum_buffer, ecma119_image::checksum_idx_counter, Iso_File_Src::checksum_index, DIV_UP, filesrc_close(), filesrc_make_md5(), filesrc_open(), filesrc_read(), Iso_Image::id, ecma119_image::image, ISO_FILE_CANT_WRITE, iso_file_src_get_size(), ISO_LIBJTE_END_FAILED, ISO_LIBJTE_FILE_FAILED, iso_libjte_forward_msgs(), iso_md5_compute(), iso_md5_end(), iso_md5_match(), iso_md5_start(), ISO_MD5_STREAM_CHANGE, iso_msg_debug(), iso_msg_submit(), iso_report_errfile(), iso_stream_get_file_name(), iso_stream_get_input_stream(), ISO_SUCCESS, iso_write(), LIBISO_ALLOC_MEM, LIBISO_FREE_MEM, iso_write_opts::md5_file_checksums, ecma119_image::opts, PATH_MAX, and Iso_File_Src::stream.

Referenced by filesrc_writer_write_data(), and partprepend_writer_write_data().

shall_be_written()

static int shall_be_written ( void *  arg )

static

Definition at line 226 of file filesrc.c.

{
    IsoFileSrc *f = (IsoFileSrc *)arg;
    return f->no_write ? 0 : 1;
}

References Iso_File_Src::no_write.

Referenced by filesrc_writer_pre_compute().

shall_be_written_if_not_taken()

static int shall_be_written_if_not_taken ( void *  arg )

static

Definition at line 233 of file filesrc.c.

{
    IsoFileSrc *f = (IsoFileSrc *)arg;
    return f->no_write || f->taken ? 0 : 1;
}

References Iso_File_Src::no_write, and Iso_File_Src::taken.

Referenced by filesrc_writer_pre_compute().