writer.h File Reference

#include "ecma119.h"

Include dependency graph for writer.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Iso_Image_Writer

Functions
int	iso_write (Ecma119Image *target, void *buf, size_t count)
	This is the function all Writers should call to write data to image. More...
int	ecma119_writer_create (Ecma119Image *target)

Function Documentation

ecma119_writer_create()

int ecma119_writer_create

(

Ecma119Image *

target

)

Definition at line 984 of file ecma119.c.

{
    int ret;
    IsoImageWriter *writer;
 
    writer = malloc(sizeof(IsoImageWriter));
    if (writer == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    writer->compute_data_blocks = ecma119_writer_compute_data_blocks;
    writer->write_vol_desc = ecma119_writer_write_vol_desc;
    writer->write_data = ecma119_writer_write_data;
    writer->free_data = ecma119_writer_free_data;
    writer->data = NULL;
    writer->target = target;
 
    /* add this writer to image */
    target->writers[target->nwriters++] = writer;
 
    iso_msg_debug(target->image->id, "Creating low level ECMA-119 tree...");
    ret = ecma119_tree_create(target);
    if (ret < 0) {
        return ret;
    }
 
    if (target->image->sparc_core_node != NULL) {
        /* Obtain a duplicate of the IsoFile's Ecma119Node->file */
        ret = iso_file_src_create(target, target->image->sparc_core_node,
                                  &target->sparc_core_src);
        if (ret < 0)
            return ret;
    }
 
    if(target->opts->partition_offset > 0) {
        /* Create second tree */
        target->eff_partition_offset = target->opts->partition_offset;
        ret = ecma119_tree_create(target);
        target->eff_partition_offset = 0;
        if (ret < 0)
            return ret;
    }
 
    /* we need the volume descriptor */
    target->curblock++;
    return ISO_SUCCESS;
}

References Iso_Image_Writer::compute_data_blocks, ecma119_image::curblock, Iso_Image_Writer::data, ecma119_tree_create(), ecma119_writer_compute_data_blocks(), ecma119_writer_free_data(), ecma119_writer_write_data(), ecma119_writer_write_vol_desc(), ecma119_image::eff_partition_offset, Iso_Image_Writer::free_data, Iso_Image::id, ecma119_image::image, iso_file_src_create(), iso_msg_debug(), ISO_OUT_OF_MEM, ISO_SUCCESS, ecma119_image::nwriters, ecma119_image::opts, iso_write_opts::partition_offset, Iso_Image::sparc_core_node, ecma119_image::sparc_core_src, 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_write()

int iso_write	(	Ecma119Image *	target,
		void *	buf,
		size_t	count
	)

This is the function all Writers should call to write data to image.

Currently, it is just a wrapper for write(2) Unix system call.

It is implemented in ecma119.c

Returns

1 on success, < 0 error

Definition at line 3471 of file ecma119.c.

{
    int ret;
 
    if (target->bytes_written + (off_t) count > target->total_size) {
        iso_msg_submit(target->image->id, ISO_ASSERT_FAILURE, 0,
                       "ISO overwrite");
        return ISO_ASSERT_FAILURE;
    }
 
    ret = iso_ring_buffer_write(target->buffer, buf, count);
    if (ret == 0) {
        /* reader cancelled */
        return ISO_CANCELED;
    }
    if (ret < 0)
        return ret;
    if (target->checksum_ctx != NULL) {
        /* Add to image checksum */
        target->checksum_counter += count;
        iso_md5_compute(target->checksum_ctx, (char *) buf, (int) count);
    }
 
    ret = show_chunk_to_jte(target, buf, count);
    if (ret != ISO_SUCCESS)
        return ret;
 
    /* total size is 0 when writing the overwrite buffer */
    if (target->total_size != (off_t) 0){
        unsigned int kbw, kbt;
        int percent;
 
        target->bytes_written += (off_t) count;
        kbw = (unsigned int) (target->bytes_written >> 10);
        kbt = (unsigned int) (target->total_size >> 10);
        percent = (kbw * 100) / kbt;
 
        /* only report in 5% chunks */
        if (percent >= target->percent_written + 5) {
            iso_msg_debug(target->image->id, "Processed %u of %u KB (%d %%)",
                          kbw, kbt, percent);
            target->percent_written = percent;
        }
    }
 
    return ISO_SUCCESS;
}

References ecma119_image::buffer, ecma119_image::bytes_written, ecma119_image::checksum_counter, ecma119_image::checksum_ctx, Iso_Image::id, ecma119_image::image, ISO_ASSERT_FAILURE, ISO_CANCELED, iso_md5_compute(), iso_msg_debug(), iso_msg_submit(), iso_ring_buffer_write(), ISO_SUCCESS, ecma119_image::percent_written, show_chunk_to_jte(), and ecma119_image::total_size.

Referenced by checksum_writer_write_data(), ecma119_writer_write_vol_desc(), eltorito_writer_write_vol_desc(), filesrc_writer_write_data(), gpt_tail_writer_write_data(), hfsplus_tail_writer_write_data(), hfsplus_writer_write_data(), iso1999_writer_write_vol_desc(), iso_filesrc_write_data(), iso_md5_write_tag(), iso_write_partition_file(), joliet_writer_write_vol_desc(), mspad_writer_write_data(), pad_up_block(), rrip_write_ce_fields(), write_head_part1(), write_head_part2(), write_one_dir(), write_path_table(), write_sb(), write_vol_desc_terminator(), and zero_writer_write_data().