libburnia/libisofs
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Define code style formatter for eclipse and apply it to source.

Browse Source
This commit is contained in:
Vreixo Formoso 2007-12-28 22:10:17 +01:00
parent 1ecb735e7c
commit 4c9d83f051
31 changed files with 1018 additions and 1019 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.cproject
View File

@ -313,6 +313,7 @@
</profile>
</scannerConfigBuildInfo>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.language.mapping"/>
</cconfiguration>
<cconfiguration id="converted.config.2029700129.1058518760.974771800">
<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="converted.config.2029700129.1058518760.974771800" moduleId="org.eclipse.cdt.core.settings" name="test">
@ -624,6 +625,7 @@
</profile>
</scannerConfigBuildInfo>
</storageModule>
<storageModule moduleId="org.eclipse.cdt.core.language.mapping"/>
</cconfiguration>
</storageModule>
<storageModule moduleId="cdtBuildSystem" version="4.0.0">

2
.settings/org.eclipse.cdt.core.prefs
View File

@ -1,4 +1,4 @@
#Fri Dec 28 17:36:33 CET 2007
#Fri Dec 28 21:07:56 CET 2007
eclipse.preferences.version=1
indexer/filesToParseUpFront=
indexer/indexAllFiles=true

63
demo/cat_buffer.c
View File

@ -22,7 +22,8 @@
* the libisofs ring buffer as intermediate memory
*/
struct th_data {
struct th_data
{
IsoRingBuffer *rbuf;
char *path;
};
@ -37,34 +38,34 @@ void *write_function(void *arg)
int res;
unsigned char tmp[WRITE_CHUNK];
struct th_data *data = (struct th_data *) arg;
int fd = open(data->path, O_RDONLY);
if (fd < 0) {
fprintf(stderr, "Writer thread error: Can't open file");
iso_ring_buffer_writer_close(data->rbuf);
pthread_exit(NULL);
}
res = 1;
while ( (bytes = read(fd, tmp, WRITE_CHUNK)) > 0 ) {
while ( (bytes = read(fd, tmp, WRITE_CHUNK)) > 0) {
res = iso_ring_buffer_write(data->rbuf, tmp, bytes);
if (res <= 0) {
break;
}
/* To test premature reader exit >>>>>>>>>>>
iso_ring_buffer_writer_close(data->rbuf);
pthread_exit(NULL);
<<<<<<<<<<<<<<<<<<<<<<<<< */
// if (rand() > 2000000000) {
// fprintf(stderr, "Writer sleeping\n");
// sleep(1);
// }
iso_ring_buffer_writer_close(data->rbuf);
pthread_exit(NULL);
<<<<<<<<<<<<<<<<<<<<<<<<< */
// if (rand() > 2000000000) {
// fprintf(stderr, "Writer sleeping\n");
// sleep(1);
// }
}
fprintf(stderr, "Writer finish: %d\n", res);
close(fd);
iso_ring_buffer_writer_close(data->rbuf);
pthread_exit(NULL);
pthread_exit(NULL);
}
static
@ -73,22 +74,22 @@ void *read_function(void *arg)
unsigned char tmp[READ_CHUNK];
int res = 1;
struct th_data *data = (struct th_data *) arg;
while ( (res = iso_ring_buffer_read(data->rbuf, tmp, READ_CHUNK)) > 0 ) {
while ( (res = iso_ring_buffer_read(data->rbuf, tmp, READ_CHUNK)) > 0) {
write(1, tmp, READ_CHUNK);
/* To test premature reader exit >>>>>>>>>>>
iso_ring_buffer_reader_close(data->rbuf);
pthread_exit(NULL);
<<<<<<<<<<<<<<<<<<<<<<<<< */
// if (rand() > 2000000000) {
// fprintf(stderr, "Reader sleeping\n");
// sleep(1);
// }
iso_ring_buffer_reader_close(data->rbuf);
pthread_exit(NULL);
<<<<<<<<<<<<<<<<<<<<<<<<< */
// if (rand() > 2000000000) {
// fprintf(stderr, "Reader sleeping\n");
// sleep(1);
// }
}
fprintf(stderr, "Reader finish: %d\n", res);
iso_ring_buffer_reader_close(data->rbuf);
pthread_exit(NULL);
}
@ -103,24 +104,24 @@ int main(int argc, char **argv)
fprintf(stderr, "Usage: catbuffer /path/to/file\n");
return 1;
}
res = iso_ring_buffer_new(&data.rbuf);
if (res < 0) {
fprintf(stderr, "Can't create buffer\n");
return 1;
}
data.path = argv[1];
res = pthread_create(&writer, NULL, write_function, (void *) &data);
res = pthread_create(&reader, NULL, read_function, (void *) &data);
pthread_join(writer, NULL);
pthread_join(reader, NULL);
fprintf(stderr, "Buffer was %d times full and %d times empty.\n",
iso_ring_buffer_get_times_full(data.rbuf),
iso_ring_buffer_get_times_empty(data.rbuf));
iso_ring_buffer_get_times_full(data.rbuf),
iso_ring_buffer_get_times_empty(data.rbuf));
free(data.rbuf);
return 0;
}

91
doc/devel/codestyle.xml Normal file
View File

@ -0,0 +1,91 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<profiles version="1">
<profile kind="CodeFormatterProfile" name="nglibisofs" version="1">
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.continuation_indentation" value="2"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_new_line_in_empty_block" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.lineSplit" value="80"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.alignment_for_conditional_expression" value="16"/>
<setting id="org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_switch" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.indent_access_specifier_compare_to_type_header" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_access_specifier" value="true"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.indent_body_declarations_compare_to_namespace_header" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.tabulation.size" value="4"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.indent_statements_compare_to_body" value="true"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.indent_statements_compare_to_block" value="true"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.indent_empty_lines" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.tabulation.char" value="space"/>
<setting id="org.eclipse.cdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
<setting id="org.eclipse.cdt.core.formatter.keep_empty_array_initializer_on_one_line" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.put_empty_statement_on_new_line" value="true"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.brace_position_for_method_declaration" value="next_line"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.brace_position_for_block_in_case" value="next_line_shifted"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.compact_else_if" value="true"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.brace_position_for_switch" value="end_of_line"/>
<setting id="org.eclipse.cdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
<setting id="org.eclipse.cdt.core.formatter.alignment_for_arguments_in_method_invocation" value="18"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.alignment_for_parameters_in_method_declaration" value="18"/>
<setting id="org.eclipse.cdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
<setting id="org.eclipse.cdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.indentation.size" value="4"/>
<setting id="org.eclipse.cdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.brace_position_for_namespace_declaration" value="end_of_line"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
<setting id="org.eclipse.cdt.core.formatter.brace_position_for_array_initializer" value="end_of_line"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_brace_in_namespace_declaration" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
<setting id="org.eclipse.cdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
<setting id="org.eclipse.cdt.core.formatter.brace_position_for_block" value="end_of_line"/>
<setting id="org.eclipse.cdt.core.formatter.brace_position_for_type_declaration" value="next_line"/>
</profile>
</profiles>

63
src/buffer.c
View File

@ -14,7 +14,7 @@
* there's enought space/data at the beginning
* - pre-buffer for writes < BLOCK_SIZE
*
*/
*/
#include "buffer.h"
#include "error.h"
@ -28,26 +28,27 @@
# define MIN(a, b) (((a) < (b)) ? (a) : (b))
#endif
struct iso_ring_buffer {
struct iso_ring_buffer
{
uint8_t buf[BLOCK_SIZE * BUFFER_SIZE];
/*
* Number of bytes available.
*/
size_t size;
/* position for reading and writing, offset from buf */
size_t rpos;
size_t wpos;
/* flags to report if read or writer threads ends execution */
unsigned int rend:1;
unsigned int wend:1;
unsigned int rend :1;
unsigned int wend :1;
/* just for statistical purposes */
unsigned int times_full;
unsigned int times_empty;
pthread_mutex_t mutex;
pthread_cond_t empty;
pthread_cond_t full;
@ -64,30 +65,30 @@ struct iso_ring_buffer {
int iso_ring_buffer_new(IsoRingBuffer **rbuf)
{
IsoRingBuffer *buffer;
if (rbuf == NULL) {
return ISO_NULL_POINTER;
}
buffer = malloc(sizeof(IsoRingBuffer));
if (buffer == NULL) {
return ISO_MEM_ERROR;
}
buffer->size = 0;
buffer->wpos = 0;
buffer->rpos = 0;
buffer->times_full = 0;
buffer->times_empty = 0;
buffer->rend = buffer->wend = 0;
/* init mutex and waiting queues */
pthread_mutex_init(&buffer->mutex, NULL);
pthread_cond_init(&buffer->empty, NULL);
pthread_cond_init(&buffer->full, NULL);
*rbuf = buffer;
return ISO_SUCCESS;
}
@ -118,15 +119,15 @@ int iso_ring_buffer_write(IsoRingBuffer *buf, uint8_t *data, size_t count)
{
size_t len;
int bytes_write = 0;
if (buf == NULL || data == NULL) {
return ISO_NULL_POINTER;
}
while (bytes_write < count) {
pthread_mutex_lock(&buf->mutex);
while (buf->size == BUFFER_CAPACITY) {
/*
@ -134,7 +135,7 @@ int iso_ring_buffer_write(IsoRingBuffer *buf, uint8_t *data, size_t count)
* Thus, the while(buf->size == BUFFER_CAPACITY) is used here
* only to propertly detect the reader has been cancelled
*/
if (buf->rend) {
/* the read procces has been finished */
pthread_mutex_unlock(&buf->mutex);
@ -144,7 +145,7 @@ int iso_ring_buffer_write(IsoRingBuffer *buf, uint8_t *data, size_t count)
/* wait until space available */
pthread_cond_wait(&buf->full, &buf->mutex);
}
len = MIN(count - bytes_write, BUFFER_CAPACITY - buf->size);
if (buf->wpos + len > BUFFER_CAPACITY) {
len = BUFFER_CAPACITY - buf->wpos;
@ -153,7 +154,7 @@ int iso_ring_buffer_write(IsoRingBuffer *buf, uint8_t *data, size_t count)
buf->wpos = (buf->wpos + len) % (BUFFER_CAPACITY);
bytes_write += len;
buf->size += len;
/* wake up reader */
pthread_cond_signal(&buf->empty);
pthread_mutex_unlock(&buf->mutex);
@ -174,14 +175,14 @@ int iso_ring_buffer_read(IsoRingBuffer *buf, uint8_t *dest, size_t count)
{
size_t len;
int bytes_read = 0;
if (buf == NULL || dest == NULL) {
return ISO_NULL_POINTER;
}
while (bytes_read < count) {
pthread_mutex_lock(&buf->mutex);
while (buf->size == 0) {
/*
* Note. There's only a reader, so we have no race conditions.
@ -189,7 +190,7 @@ int iso_ring_buffer_read(IsoRingBuffer *buf, uint8_t *dest, size_t count)
* a reader detects the EOF propertly if the writer has been
* canceled while the reader was waiting
*/
if (buf->wend) {
/* the writer procces has been finished */
pthread_mutex_unlock(&buf->mutex);
@ -199,7 +200,7 @@ int iso_ring_buffer_read(IsoRingBuffer *buf, uint8_t *dest, size_t count)
/* wait until data available */
pthread_cond_wait(&buf->empty, &buf->mutex);
}
len = MIN(count - bytes_read, buf->size);
if (buf->rpos + len > BUFFER_CAPACITY) {
len = BUFFER_CAPACITY - buf->rpos;
@ -208,7 +209,7 @@ int iso_ring_buffer_read(IsoRingBuffer *buf, uint8_t *dest, size_t count)
buf->rpos = (buf->rpos + len) % (BUFFER_CAPACITY);
bytes_read += len;
buf->size -= len;
/* wake up the writer */
pthread_cond_signal(&buf->full);
pthread_mutex_unlock(&buf->mutex);
@ -220,7 +221,7 @@ void iso_ring_buffer_writer_close(IsoRingBuffer *buf)
{
pthread_mutex_lock(&buf->mutex);
buf->wend = 1;
/* ensure no reader is waiting */
pthread_cond_signal(&buf->empty);
pthread_mutex_unlock(&buf->mutex);
@ -230,7 +231,7 @@ void iso_ring_buffer_reader_close(IsoRingBuffer *buf)
{
pthread_mutex_lock(&buf->mutex);
buf->rend = 1;
/* ensure no writer is waiting */
pthread_cond_signal(&buf->full);
pthread_mutex_unlock(&buf->mutex);

42
src/builder.c
View File

@ -31,29 +31,29 @@ void iso_node_builder_unref(IsoNodeBuilder *builder)
}
static
int default_create_file(IsoNodeBuilder *builder, IsoImage *image,
int default_create_file(IsoNodeBuilder *builder, IsoImage *image,
IsoFileSource *src, IsoFile **file)
{
int res;
struct stat info;
IsoStream *stream;
IsoFile *node;
if (builder == NULL || src == NULL || file == NULL) {
return ISO_NULL_POINTER;
}
res = iso_file_source_stat(src, &info);
if (res < 0) {
return res;
}
/* this will fail if src is a dir, is not accessible... */
res = iso_file_source_stream_new(src, &stream);
if (res < 0) {
return res;
}
node = malloc(sizeof(IsoFile));
if (node == NULL) {
/* the stream has taken our ref to src, so we need to add one */
@ -61,7 +61,7 @@ int default_create_file(IsoNodeBuilder *builder, IsoImage *image,
iso_stream_unref(stream);
return ISO_MEM_ERROR;
}
/* fill node fields */
node->node.refcount = 1;
node->node.type = LIBISO_FILE;
@ -78,26 +78,26 @@ int default_create_file(IsoNodeBuilder *builder, IsoImage *image,
node->sort_weight = 0;
node->stream = stream;
node->msblock = 0;
*file = node;
return ISO_SUCCESS;
}
static
int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
IsoFileSource *src, IsoNode **node)
{
int result;
struct stat info;
IsoNode *new;
char *name;
if (builder == NULL || src == NULL || node == NULL) {
return ISO_NULL_POINTER;
}
name = iso_file_source_get_name(src);
/* get info about source */
if (image->recOpts->follow_symlinks) {
result = iso_file_source_stat(src, &info);
@ -107,7 +107,7 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
if (result < 0) {
return result;
}
new = NULL;
switch (info.st_mode & S_IFMT) {
case S_IFREG:
@ -148,7 +148,7 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
/* source is a symbolic link */
char dest[PATH_MAX];
IsoSymlink *link;
result = iso_file_source_readlink(src, dest, PATH_MAX);
if (result < 0) {
return result;
@ -179,7 +179,7 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
}
break;
}
/* fill fields */
new->refcount = 1;
new->name = strdup(name);
@ -189,12 +189,12 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
new->atime = info.st_atime;
new->mtime = info.st_mtime;
new->ctime = info.st_ctime;
new->hidden = 0;
new->parent = NULL;
new->next = NULL;
*node = new;
return ISO_SUCCESS;
}
@ -208,23 +208,23 @@ void default_free(IsoNodeBuilder *builder)
int iso_node_basic_builder_new(IsoNodeBuilder **builder)
{
IsoNodeBuilder *b;
if (builder == NULL) {
return ISO_NULL_POINTER;
}
b = malloc(sizeof(IsoNodeBuilder));
if (b == NULL) {
return ISO_MEM_ERROR;
}
b->refcount = 1;
b->create_file_data = NULL;
b->create_node_data = NULL;
b->create_file = default_create_file;
b->create_node = default_create_node;
b->free = default_free;
*builder = b;
return ISO_SUCCESS;
}

10
src/builder.h
View File

@ -40,9 +40,9 @@ struct Iso_Node_Builder
* @return
* 1 on success, < 0 on error
*/
int (*create_file)(IsoNodeBuilder *builder, IsoImage *image,
int (*create_file)(IsoNodeBuilder *builder, IsoImage *image,
IsoFileSource *src, IsoFile **file);
/**
* Create a new IsoNode from a IsoFileSource. The type of the node to be
* created is determined from the type of the file source. Name,
@ -53,15 +53,15 @@ struct Iso_Node_Builder
* @return
* 1 on success, < 0 on error
*/
int (*create_node)(IsoNodeBuilder *builder, IsoImage *image,
int (*create_node)(IsoNodeBuilder *builder, IsoImage *image,
IsoFileSource *src, IsoNode **node);
/**
* Free implementation specific data. Should never be called by user.
* Use iso_node_builder_unref() instead.
*/
void (*free)(IsoNodeBuilder *builder);
int refcount;
void *create_file_data;
void *create_node_data;

248
src/ecma119.c
View File

@ -30,12 +30,12 @@ static
void ecma119_image_free(Ecma119Image *t)
{
size_t i;
ecma119_node_free(t->root);
iso_image_unref(t->image);
iso_rbtree_destroy(t->files, iso_file_src_free);
iso_ring_buffer_free(t->buffer);
for (i = 0; i < t->nwriters; ++i) {
IsoImageWriter *writer = t->writers[i];
writer->free_data(writer);
@ -73,7 +73,8 @@ size_t calc_dirent_len(Ecma119Image *t, Ecma119Node *n)
if (need_version_number(t, n)) {
ret += 2; /* take into account version numbers */
}
if (ret % 2) ret++;
if (ret % 2)
ret++;
return ret;
}
@ -90,12 +91,12 @@ size_t calc_dirent_len(Ecma119Image *t, Ecma119Node *n)
* The size needed for all dir entries of the given dir, without
* taking into account the continuation areas.
*/
static
static
size_t calc_dir_size(Ecma119Image *t, Ecma119Node *dir, size_t *ce)
{
size_t i, len;
size_t ce_len = 0;
/* size of "." and ".." entries */
len = 34 + 34;
if (t->rockridge) {
@ -104,14 +105,13 @@ size_t calc_dir_size(Ecma119Image *t, Ecma119Node *dir, size_t *ce)
len += rrip_calc_len(t, dir, 2, 255 - 34, &ce_len);
*ce += ce_len;
}
for (i = 0; i < dir->info.dir.nchildren; ++i) {
size_t remaining;
Ecma119Node *child = dir->info.dir.children[i];
size_t dirent_len = calc_dirent_len(t, child);
if (t->rockridge) {
dirent_len += rrip_calc_len(t, child, 0, 255 - dirent_len,
&ce_len);
dirent_len += rrip_calc_len(t, child, 0, 255 - dirent_len, &ce_len);
*ce += ce_len;
}
remaining = BLOCK_SIZE - (len % BLOCK_SIZE);
@ -127,7 +127,7 @@ size_t calc_dir_size(Ecma119Image *t, Ecma119Node *dir, size_t *ce)
return len;
}
static
static
void calc_dir_pos(Ecma119Image *t, Ecma119Node *dir)
{
size_t i, len;
@ -156,12 +156,12 @@ uint32_t calc_path_table_size(Ecma119Node *dir)
{
uint32_t size;
size_t i;
/* size of path table for this entry */
size = 8;
size += dir->iso_name ? strlen(dir->iso_name) : 1;
size += (size % 2);
/* and recurse */
for (i = 0; i < dir->info.dir.nchildren; i++) {
Ecma119Node *child = dir->info.dir.children[i];
@ -177,29 +177,29 @@ int ecma119_writer_compute_data_blocks(IsoImageWriter *writer)
{
Ecma119Image *target;
uint32_t path_table_size;
if (writer == NULL) {
return ISO_MEM_ERROR;
}
target = writer->target;
/* compute position of directories */
iso_msg_debug(target->image, "Computing position of dir structure");
target->ndirs = 0;
calc_dir_pos(target, target->root);
/* compute length of pathlist */
iso_msg_debug(target->image, "Computing length of pathlist");
path_table_size = calc_path_table_size(target->root);
/* compute location for path tables */
target->l_path_table_pos = target->curblock;
target->curblock += div_up(path_table_size, BLOCK_SIZE);
target->m_path_table_pos = target->curblock;
target->curblock += div_up(path_table_size, BLOCK_SIZE);
target->path_table_size = path_table_size;
return ISO_SUCCESS;
}
@ -216,28 +216,28 @@ int ecma119_writer_compute_data_blocks(IsoImageWriter *writer)
* root directory record in the PVD (ECMA-119, 8.4.18) (in order to
* distinguish it from the "." entry in the root directory)
*/
static
static
void write_one_dir_record(Ecma119Image *t, Ecma119Node *node, int file_id,
uint8_t *buf, size_t len_fi, struct susp_info *info)
uint8_t *buf, size_t len_fi, struct susp_info *info)
{
uint32_t len;
uint32_t block;
uint8_t len_dr; /*< size of dir entry without SUSP fields */
uint8_t *name = (file_id >= 0) ? (uint8_t*)&file_id :
(uint8_t*)node->iso_name;
uint8_t *name = (file_id >= 0) ? (uint8_t*)&file_id
: (uint8_t*)node->iso_name;
struct ecma119_dir_record *rec = (struct ecma119_dir_record*)buf;
len_dr = 33 + len_fi + (len_fi % 2 ? 0 : 1);
memcpy(rec->file_id, name, len_fi);
if (need_version_number(t, node)) {
len_dr += 2;
rec->file_id[len_fi++] = ';';
rec->file_id[len_fi++] = '1';
}
if (node->type == ECMA119_DIR) {
/* use the cached length */
len = node->info.dir.len;
@ -253,7 +253,7 @@ void write_one_dir_record(Ecma119Image *t, Ecma119Node *node, int file_id,
len = 0;
block = 0;
}
/*
* For ".." entry we need to write the parent info!
*/
@ -267,7 +267,7 @@ void write_one_dir_record(Ecma119Image *t, Ecma119Node *node, int file_id,
rec->flags[0] = (node->type == ECMA119_DIR) ? 2 : 0;
iso_bb(rec->vol_seq_number, 1, 2);
rec->len_fi[0] = len_fi;
/* and finally write the SUSP fields */
if (info != NULL) {
rrip_write_susp_fields(t, info, buf + len_dr);
@ -283,33 +283,33 @@ int ecma119_writer_write_vol_desc(IsoImageWriter *writer)
IsoImage *image;
Ecma119Image *t;
struct ecma119_pri_vol_desc vol;
char *vol_id, *pub_id, *data_id, *volset_id;
char *system_id, *application_id, *copyright_file_id;
char *abstract_file_id, *biblio_file_id;
if (writer == NULL) {
return ISO_MEM_ERROR;
}
t = writer->target;
image = t->image;
iso_msg_debug(image, "Write Primary Volume Descriptor");
memset(&vol, 0, sizeof(struct ecma119_pri_vol_desc));
str2d_char(t->input_charset, image->volume_id, &vol_id);
str2a_char(t->input_charset, image->publisher_id, &pub_id);
str2a_char(t->input_charset, image->data_preparer_id, &data_id);
str2d_char(t->input_charset, image->volset_id, &volset_id);
str2a_char(t->input_charset, image->system_id, &system_id);
str2a_char(t->input_charset, image->application_id, &application_id);
str2d_char(t->input_charset, image->copyright_file_id, &copyright_file_id);
str2d_char(t->input_charset, image->abstract_file_id, &abstract_file_id);
str2d_char(t->input_charset, image->biblio_file_id, &biblio_file_id);
vol.vol_desc_type[0] = 1;
memcpy(vol.std_identifier, "CD001", 5);
vol.vol_desc_version[0] = 1;
@ -318,7 +318,7 @@ int ecma119_writer_write_vol_desc(IsoImageWriter *writer)
} else {
/* put linux by default? */
memcpy(vol.system_id, "LINUX", 5);
}
}
if (vol_id) {
strncpy((char*)vol.volume_id, vol_id, 32);
}
@ -338,7 +338,7 @@ int ecma119_writer_write_vol_desc(IsoImageWriter *writer)
strncpy((char*)vol.publisher_id, pub_id, 128);
if (data_id)
strncpy((char*)vol.data_prep_id, data_id, 128);
if (application_id)
strncpy((char*)vol.application_id, application_id, 128);
if (copyright_file_id)
@ -362,12 +362,12 @@ int ecma119_writer_write_vol_desc(IsoImageWriter *writer)
free(copyright_file_id);
free(abstract_file_id);
free(biblio_file_id);
/* Finally write the Volume Descriptor */
return iso_write(t, &vol, sizeof(struct ecma119_pri_vol_desc));
}
static
static
int write_one_dir(Ecma119Image *t, Ecma119Node *dir)
{
int ret;
@ -375,13 +375,13 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir)
size_t i;
size_t fi_len, len;
struct susp_info info;
/* buf will point to current write position on buffer */
uint8_t *buf = buffer;
/* initialize buffer with 0s */
memset(buffer, 0, BLOCK_SIZE);
/*
* set susp_info to 0's, this way code for both plain ECMA-119 and
* RR is very similar
@ -416,14 +416,14 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir)
for (i = 0; i < dir->info.dir.nchildren; i++) {
Ecma119Node *child = dir->info.dir.children[i];
/* compute len of directory entry */
fi_len = strlen(child->iso_name);
len = fi_len + 33 + (fi_len % 2 ? 0 : 1);
if (need_version_number(t, child)) {
len += 2;
}
/* get the SUSP fields if rockridge is enabled */
if (t->rockridge) {
ret = rrip_get_susp_fields(t, child, 0, 255 - len, &info);
@ -432,8 +432,8 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir)
}
len += info.suf_len;
}
if ( (buf + len - buffer) > BLOCK_SIZE ) {
if ( (buf + len - buffer) > BLOCK_SIZE) {
/* dir doesn't fit in current block */
ret = iso_write(t, buffer, BLOCK_SIZE);
if (ret < 0) {
@ -446,33 +446,33 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir)
write_one_dir_record(t, child, -1, buf, fi_len, &info);
buf += len;
}
/* write the last block */
ret = iso_write(t, buffer, BLOCK_SIZE);
if (ret < 0) {
return ret;
}
/* write the Continuation Area if needed */
if (info.ce_len > 0) {
ret = rrip_write_ce_fields(t, &info);
}
return ret;
}
static
static
int write_dirs(Ecma119Image *t, Ecma119Node *root)
{
int ret;
size_t i;
/* write all directory entries for this dir */
ret = write_one_dir(t, root);
if (ret < 0) {
return ret;
}
/* recurse */
for (i = 0; i < root->info.dir.nchildren; i++) {
Ecma119Node *child = root->info.dir.children[i];
@ -486,7 +486,7 @@ int write_dirs(Ecma119Image *t, Ecma119Node *root)
return ISO_SUCCESS;
}
static
static
int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
{
size_t i, len;
@ -496,8 +496,8 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
Ecma119Node *dir;
uint32_t path_table_size;
int parent = 0;
int ret = ISO_SUCCESS;
int ret= ISO_SUCCESS;
path_table_size = 0;
write_int = l_type ? iso_lsb : iso_msb;
@ -527,7 +527,7 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
}
path_table_size += len;
}
/* we need to fill the last block with zeros */
path_table_size %= BLOCK_SIZE;
if (path_table_size) {
@ -539,15 +539,15 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
return ret;
}
static
static
int write_path_tables(Ecma119Image *t)
{
int ret;
size_t i, j, cur;
Ecma119Node **pathlist;
iso_msg_debug(t->image, "Writing ISO Path tables");
/* allocate temporal pathlist */
pathlist = malloc(sizeof(void*) * t->ndirs);
if (pathlist == NULL) {
@ -565,17 +565,17 @@ int write_path_tables(Ecma119Image *t)
}
}
}
/* Write L Path Table */
ret = write_path_table(t, pathlist, 1);
if (ret < 0) {
goto write_path_tables_exit;
}
/* Write L Path Table */
ret = write_path_table(t, pathlist, 0);
write_path_tables_exit:;
write_path_tables_exit: ;
free(pathlist);
return ret;
}
@ -589,21 +589,21 @@ int ecma119_writer_write_data(IsoImageWriter *writer)
{
int ret;
Ecma119Image *t;
if (writer == NULL) {
return ISO_MEM_ERROR;
}
t = writer->target;
/* first of all, we write the directory structure */
ret = write_dirs(t, t->root);
if (ret < 0) {
return ret;
}
/* and write the path tables */
ret = write_path_tables(t);
return ret;
}
@ -618,28 +618,28 @@ int ecma119_writer_create(Ecma119Image *target)
{
int ret;
IsoImageWriter *writer;
writer = malloc(sizeof(IsoImageWriter));
if (writer == NULL) {
return ISO_MEM_ERROR;
}
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, "Creating low level ECMA-119 tree...");
ret = ecma119_tree_create(target);
if (ret < 0) {
return ret;
}
/* we need the volume descriptor */
target->curblock++;
return ISO_SUCCESS;
@ -652,10 +652,10 @@ void *write_function(void *arg)
size_t i;
uint8_t buf[BLOCK_SIZE];
IsoImageWriter *writer;
Ecma119Image *target = (Ecma119Image*)arg;
iso_msg_debug(target->image, "Starting image writing...");
/* Write System Area, 16 blocks of zeros (ECMA-119, 6.2.1) */
memset(buf, 0, BLOCK_SIZE);
for (i = 0; i < 16; ++i) {
@ -664,7 +664,7 @@ void *write_function(void *arg)
goto write_error;
}
}
/* write volume descriptors, one per writer */
iso_msg_debug(target->image, "Write volume descriptors");
for (i = 0; i < target->nwriters; ++i) {
@ -674,22 +674,22 @@ void *write_function(void *arg)
goto write_error;
}
}
/* write Volume Descriptor Set Terminator (ECMA-119, 8.3) */
{
struct ecma119_vol_desc_terminator *vol;
vol = (struct ecma119_vol_desc_terminator *) buf;
vol->vol_desc_type[0] = 255;
memcpy(vol->std_identifier, "CD001", 5);
vol->vol_desc_version[0] = 1;
res = iso_write(target, buf, BLOCK_SIZE);
if (res < 0) {
goto write_error;
}
}
/* write data for each writer */
for (i = 0; i < target->nwriters; ++i) {
writer = target->writers[i];
@ -698,40 +698,39 @@ void *write_function(void *arg)
goto write_error;
}
}
iso_ring_buffer_writer_close(target->buffer);
pthread_exit(NULL);
write_error:;
iso_msg_fatal(target->image, LIBISO_WRITE_ERROR,
write_error: ;
iso_msg_fatal(target->image, LIBISO_WRITE_ERROR,
"Image write error, code %d", res);
iso_ring_buffer_writer_close(target->buffer);
pthread_exit(NULL);
}
static
int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
Ecma119Image **img)
static
int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts, Ecma119Image **img)
{
int ret, i;
Ecma119Image *target;
/* 1. Allocate target and copy opts there */
target = calloc(1, sizeof(Ecma119Image));
if (target == NULL) {
return ISO_MEM_ERROR;
}
/* create the tree for file caching */
ret = iso_rbtree_new(iso_file_src_cmp, &(target->files));
if (ret < 0) {
free(target);
return ret;
}
target->image = src;
iso_image_ref(src);
target->iso_level = opts->level;
target->rockridge = opts->rockridge;
target->ino = 0;
@ -748,7 +747,7 @@ int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
target->gid = opts->replace_gid == 2 ? opts->gid : 0;
target->dir_mode = opts->replace_dir_mode == 2 ? opts->dir_mode : 0555;
target->file_mode = opts->replace_file_mode == 2 ? opts->file_mode : 0444;
target->now = time(NULL);
target->ms_block = 0;
@ -760,7 +759,7 @@ int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
free(target);
return ISO_MEM_ERROR;
}
if (opts->output_charset != NULL) {
target->output_charset = strdup(opts->output_charset);
} else {
@ -771,7 +770,7 @@ int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
free(target);
return ISO_MEM_ERROR;
}
/*
* 2. Based on those options, create needed writers: iso, joliet...
* Each writer inits its structures and stores needed info into
@ -780,8 +779,8 @@ int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
* current block.
* Finally, create Writer for files.
*/
target->curblock = target->ms_block + 16;
target->curblock = target->ms_block + 16;
/* the number of writers is dependent of the extensions */
target->writers = malloc(2 * sizeof(void*));
if (target->writers == NULL) {
@ -789,22 +788,22 @@ int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
free(target);
return ISO_MEM_ERROR;
}
/* create writer for ECMA-119 structure */
ret = ecma119_writer_create(target);
if (ret < 0) {
goto target_cleanup;
}
/* Volume Descriptor Set Terminator */
target->curblock++;
/* create writer for file contents */
ret = iso_file_src_writer_create(target);
if (ret < 0) {
goto target_cleanup;
}
/*
* 3.
* Call compute_data_blocks() in each Writer.
@ -818,27 +817,27 @@ int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
goto target_cleanup;
}
}
/*
* The volume space size is just the size of the last session, in
* case of ms images.
*/
target->total_size = (target->curblock - target->ms_block) * BLOCK_SIZE;
target->vol_space_size = target->curblock - target->ms_block;
/* 4. Create and start writting thread */
/* create the ring buffer */
ret = iso_ring_buffer_new(&target->buffer);
if (ret < 0) {
goto target_cleanup;
}
/* ensure the thread is created joinable */
pthread_attr_init(&(target->th_attr));
pthread_attr_setdetachstate(&(target->th_attr), PTHREAD_CREATE_JOINABLE);
ret = pthread_create(&(target->wthread), &(target->th_attr),
ret = pthread_create(&(target->wthread), &(target->th_attr),
write_function, (void *) target);
if (ret != 0) {
iso_msg_fatal(target->image, LIBISO_THREAD_ERROR,
@ -846,24 +845,23 @@ int ecma119_image_new(IsoImage *src, Ecma119WriteOpts *opts,
ret = ISO_THREAD_ERROR;
goto target_cleanup;
}
/*
* Notice that once we reach this point, target belongs to the writer
* thread and should not be modified until the writer thread finished.
* There're however, specific fields in target that can be accessed, or
* even modified by the read thread (look inside bs_* functions)
*/
*img = target;
return ISO_SUCCESS;
target_cleanup:;
target_cleanup: ;
ecma119_image_free(target);
return ret;
}
static int
bs_read(struct burn_source *bs, unsigned char *buf, int size)
static int bs_read(struct burn_source *bs, unsigned char *buf, int size)
{
int ret;
Ecma119Image *t = (Ecma119Image*)bs->data;
@ -881,29 +879,27 @@ bs_read(struct burn_source *bs, unsigned char *buf, int size)
}
}
static off_t
bs_get_size(struct burn_source *bs)
static off_t bs_get_size(struct burn_source *bs)
{
Ecma119Image *target = (Ecma119Image*)bs->data;
return target->total_size;
}
static void
bs_free_data(struct burn_source *bs)
static void bs_free_data(struct burn_source *bs)
{
Ecma119Image *target = (Ecma119Image*)bs->data;
/* forces writer to stop if it is still running */
iso_ring_buffer_reader_close(target->buffer);
/* wait until writer thread finishes */
pthread_join(target->wthread, NULL);
iso_msg_debug(target->image, "Writer thread joined");
iso_msg_debug(target->image, "Ring buffer was %d times full and %d times "
"empty", iso_ring_buffer_get_times_full(target->buffer),
iso_ring_buffer_get_times_empty(target->buffer));
/* now we can safety free target */
ecma119_image_free(target);
}
@ -912,7 +908,7 @@ static
int bs_set_size(struct burn_source *bs, off_t size)
{
Ecma119Image *target = (Ecma119Image*)bs->data;
/*
* just set the value to be returned by get_size. This is not used at
* all by libisofs, it is here just for helping libburn to correctly pad
@ -927,30 +923,30 @@ int iso_image_create(IsoImage *image, Ecma119WriteOpts *opts,
{
int ret;
struct burn_source *source;
Ecma119Image *target = NULL;
Ecma119Image *target= NULL;
if (image == NULL || opts == NULL || burn_src == NULL) {
return ISO_NULL_POINTER;
}
source = calloc(1, sizeof(struct burn_source));
if (source == NULL) {
return ISO_MEM_ERROR;
}
ret = ecma119_image_new(image, opts, &target);
if (ret < 0) {
free(source);
return ret;
}
source->refcount = 1;
source->read = bs_read;
source->get_size = bs_get_size;
source->set_size = bs_set_size;
source->free_data = bs_free_data;
source->data = target;
*burn_src = source;
return ISO_SUCCESS;
}
@ -958,7 +954,7 @@ int iso_image_create(IsoImage *image, Ecma119WriteOpts *opts,
int iso_write(Ecma119Image *target, void *buf, size_t count)
{
int ret;
ret = iso_ring_buffer_write(target->buffer, buf, count);
if (ret == 0) {
/* reader cancelled */

54
src/ecma119.h
View File

@ -23,50 +23,54 @@ typedef struct ecma119_node Ecma119Node;
typedef struct Iso_File_Src IsoFileSrc;
typedef struct Iso_Image_Writer IsoImageWriter;
struct ecma119_image {
struct ecma119_image
{
IsoImage *image;
Ecma119Node *root;
unsigned int iso_level:2;
unsigned int iso_level :2;
/* extensions */
unsigned int rockridge:1;
unsigned int rockridge :1;
/* relaxed constraints */
unsigned int omit_version_numbers:1;
unsigned int allow_deep_paths:1;
// int relaxed_constraints; /**< see ecma119_relaxed_constraints_flag */
unsigned int omit_version_numbers :1;
unsigned int allow_deep_paths :1;
// int relaxed_constraints; /**< see ecma119_relaxed_constraints_flag */
/*
* Mode replace. If one of these flags is set, the correspodent values are
* replaced with values below.
*/
unsigned int replace_uid:1;
unsigned int replace_gid:1;
unsigned int replace_file_mode:1;
unsigned int replace_dir_mode:1;
unsigned int replace_uid :1;
unsigned int replace_gid :1;
unsigned int replace_file_mode :1;
unsigned int replace_dir_mode :1;
uid_t uid;
gid_t gid;
mode_t file_mode;
mode_t dir_mode;
int sort_files; /**< if sort files or not. Sorting is based of
* the weight of each file */
/**
* if sort files or not. Sorting is based of the weight of each file
*/
int sort_files;
/**
* In the CD, each file must have an unique inode number. So each
* time we add a new file, this is incremented.
*/
ino_t ino;
char *input_charset;
char *output_charset;
uint32_t ms_block; /**< start block for a ms image */
time_t now; /**< Time at which writing began. */
off_t total_size; /**< Total size of the output. This only
* includes the current volume. */
time_t now; /**< Time at which writing began. */
/** Total size of the output. This only includes the current volume. */
off_t total_size;
uint32_t vol_space_size;
/*
@ -83,16 +87,16 @@ struct ecma119_image {
uint32_t path_table_size;
uint32_t l_path_table_pos;
uint32_t m_path_table_pos;
size_t nwriters;
IsoImageWriter **writers;
/* tree of files sources */
IsoRBTree *files;
/* Buffer for communication between burn_source and writer thread */
IsoRingBuffer *buffer;
/* writer thread descriptor */
pthread_t wthread;
pthread_attr_t th_attr;

128
src/ecma119_tree.c
View File

@ -25,7 +25,7 @@ int get_iso_name(Ecma119Image *img, IsoNode *iso, char **name)
{
int ret;
char *ascii_name;
char *isoname = NULL;
char *isoname= NULL;
if (iso->name == NULL) {
/* it is not necessarily an error, it can be the root */
@ -61,7 +61,7 @@ int get_iso_name(Ecma119Image *img, IsoNode *iso, char **name)
* only possible if mem error, as check for empty names is done
* in public tree
*/
return ISO_MEM_ERROR;
return ISO_MEM_ERROR;
}
}
@ -82,7 +82,7 @@ int create_ecma119_node(Ecma119Image *img, IsoNode *iso, Ecma119Node **node)
// TODO better handling of this, add support for harlinks
ecma->nlink = 1;
ecma->ino = ++img->ino;
*node = ecma;
return ISO_SUCCESS;
}
@ -126,9 +126,9 @@ int create_file(Ecma119Image *img, IsoFile *iso, Ecma119Node **node)
size = iso_stream_get_size(iso->stream);
if (size > (off_t)0xffffffff) {
iso_msg_note(img->image, LIBISO_FILE_IGNORED,
iso_msg_note(img->image, LIBISO_FILE_IGNORED,
"File \"%s\" can't be added to image because is "
"greater than 4GB", iso->node.name);
"greater than 4GB", iso->node.name);
return 0;
}
@ -147,7 +147,7 @@ int create_file(Ecma119Image *img, IsoFile *iso, Ecma119Node **node)
}
(*node)->type = ECMA119_FILE;
(*node)->info.file = src;
return ret;
}
@ -208,13 +208,13 @@ void ecma119_node_free(Ecma119Node *node)
*
*/
static
int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
int depth, int pathlen)
{
int ret;
Ecma119Node *node;
int max_path;
char *iso_name = NULL;
char *iso_name= NULL;
if (image == NULL || iso == NULL || tree == NULL) {
return ISO_NULL_POINTER;
@ -231,15 +231,15 @@ int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
max_path = pathlen + 1 + (iso_name ? strlen(iso_name) : 0);
if (!image->rockridge && !image->allow_deep_paths) {
if ((iso->type == LIBISO_DIR && depth > 8) || max_path > 255) {
iso_msg_note(image->image, LIBISO_FILE_IGNORED,
iso_msg_note(image->image, LIBISO_FILE_IGNORED,
"File \"%s\" can't be added, because depth > 8 "
"or path length over 255", iso->name);
"or path length over 255", iso->name);
free(iso_name);
return 0;
}
}
switch(iso->type) {
switch (iso->type) {
case LIBISO_FILE:
ret = create_file(image, (IsoFile*)iso, &node);
break;
@ -249,8 +249,7 @@ int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
} else {
/* symlinks are only supported when RR is enabled */
iso_msg_note(image->image, LIBISO_FILE_IGNORED, "File \"%s\" "
"ignored. Symlinks need RockRidge extensions.",
iso->name);
"ignored. Symlinks need RockRidge extensions.", iso->name);
ret = 0;
}
break;
@ -260,8 +259,7 @@ int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
} else {
/* symlinks are only supported when RR is enabled */
iso_msg_note(image->image, LIBISO_FILE_IGNORED, "File \"%s\" "
"ignored. Special files need RockRidge extensions.",
iso->name);
"ignored. Special files need RockRidge extensions.", iso->name);
ret = 0;
}
break;
@ -270,7 +268,7 @@ int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
free(iso_name);
return 0;
break;
case LIBISO_DIR:
case LIBISO_DIR:
{
IsoNode *pos;
IsoDir *dir = (IsoDir*)iso;
@ -314,7 +312,7 @@ int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
/**
* Compare the iso name of two ECMA-119 nodes
*/
static
static
int cmp_node_name(const void *f1, const void *f2)
{
Ecma119Node *f = *((Ecma119Node**)f1);
@ -326,13 +324,13 @@ int cmp_node_name(const void *f1, const void *f2)
* Sorts a the children of each directory in the ECMA-119 tree represented
* by \p root, acording to the order specified in ECMA-119, section 9.3.
*/
static
static
void sort_tree(Ecma119Node *root)
{
size_t i;
qsort(root->info.dir.children, root->info.dir.nchildren,
sizeof(void*), cmp_node_name);
qsort(root->info.dir.children, root->info.dir.nchildren, sizeof(void*),
cmp_node_name);
for (i = 0; i < root->info.dir.nchildren; i++) {
if (root->info.dir.children[i]->type == ECMA119_DIR)
sort_tree(root->info.dir.children[i]);
@ -360,33 +358,33 @@ int contains_name(Ecma119Node *dir, const char *name)
* but never under 3 characters.
*/
static
int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
int max_dir_len)
int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
int max_dir_len)
{
int i, nchildren;
Ecma119Node **children;
int need_sort = 0;
nchildren = dir->info.dir.nchildren;
children = dir->info.dir.children;
for (i = 0; i < nchildren; ++i) {
char *name, *ext;
char full_name[40];
int max; /* computed max len for name, without extension */
int j = i;
int j = i;
int digits = 1; /* characters to change per name */
/* first, find all child with same name */
while (j + 1 < nchildren &&
!cmp_node_name(children + i, children + j + 1)) {
while (j + 1 < nchildren && !cmp_node_name(children + i, children + j
+ 1)) {
++j;
}
if (j == i) {
/* name is unique */
continue;
}
/*
* A max of 7 characters is good enought, it allows handling up to
* 9,999,999 files with same name. We can increment this to
@ -397,14 +395,14 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
int ok, k;
char *dot;
int change = 0; /* number to be written */
/* copy name to buffer */
strcpy(full_name, children[i]->iso_name);
/* compute name and extension */
dot = strrchr(full_name, '.');
if (dot != NULL && children[i]->type != ECMA119_DIR) {
/*
* File (not dir) with extension
* Note that we don't need to check for placeholders, as
@ -415,7 +413,7 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
full_name[dot - full_name] = '\0';
name = full_name;
ext = dot + 1;
/*
* For iso level 1 we force ext len to be 3, as name
* can't grow on the extension space
@ -459,7 +457,7 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
/* let ext be an empty string */
ext = name + strlen(name);
}
ok = 1;
/* change name of each file */
for (k = i; k <= j; ++k) {
@ -487,7 +485,7 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
if (new == NULL) {
return ISO_MEM_ERROR;
}
iso_msg_debug(img->image, "\"%s\" renamed to \"%s\"",
iso_msg_debug(img->image, "\"%s\" renamed to \"%s\"",
children[k]->iso_name, new);
free(children[k]->iso_name);
children[k]->iso_name = new;
@ -516,30 +514,30 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
/*
* If needed, sort again the files inside dir
*/
if (need_sort) {
if (need_sort) {
qsort(children, nchildren, sizeof(void*), cmp_node_name);
}
return ISO_SUCCESS;
}
static
int mangle_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
int mangle_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
int max_dir_len)
{
int ret;
size_t i;
ret = mangle_single_dir(img, dir, max_file_len, max_dir_len);
if (ret < 0) {
return ret;
}
/* recurse */
for (i = 0; i < dir->info.dir.nchildren; ++i) {
if (dir->info.dir.children[i]->type == ECMA119_DIR) {
ret = mangle_dir(img, dir->info.dir.children[i],
max_file_len, max_dir_len);
ret = mangle_dir(img, dir->info.dir.children[i], max_file_len,
max_dir_len);
if (ret < 0) {
/* error */
return ret;
@ -553,7 +551,7 @@ static
int mangle_tree(Ecma119Image *img, int recurse)
{
int max_file, max_dir;
// TODO take care about relaxed constraints
if (img->iso_level == 1) {
max_file = 12; /* 8 + 3 + 1 */
@ -574,9 +572,9 @@ int mangle_tree(Ecma119Image *img, int recurse)
*
* See IEEE P1282, section 4.1.5 for details
*/
static
int create_placeholder(Ecma119Node *parent,
Ecma119Node *real, Ecma119Node **node)
static
int create_placeholder(Ecma119Node *parent, Ecma119Node *real,
Ecma119Node **node)
{
Ecma119Node *ret;
@ -584,7 +582,7 @@ int create_placeholder(Ecma119Node *parent,
if (ret == NULL) {
return ISO_MEM_ERROR;
}
/*
* TODO
* If real is a dir, while placeholder is a file, ISO name restricctions
@ -595,7 +593,7 @@ int create_placeholder(Ecma119Node *parent,
free(ret);
return ISO_MEM_ERROR;
}
/* take a ref to the IsoNode */
ret->node = real->node;
iso_node_ref(real->node);
@ -604,12 +602,12 @@ int create_placeholder(Ecma119Node *parent,
ret->info.real_me = real;
ret->ino = real->ino;
ret->nlink = real->nlink;
*node = ret;
return ISO_SUCCESS;
}
static
static
size_t max_child_name_len(Ecma119Node *dir)
{
size_t ret = 0, i;
@ -626,7 +624,7 @@ size_t max_child_name_len(Ecma119Node *dir)
* on a directory hierarchy exceeds 8, or the length of a path is higher
* than 255 characters, as specified in ECMA-119, section 6.8.2.1
*/
static
static
int reparent(Ecma119Node *child, Ecma119Node *parent)
{
int ret;
@ -634,7 +632,7 @@ int reparent(Ecma119Node *child, Ecma119Node *parent)
Ecma119Node *placeholder;
/* replace the child in the original parent with a placeholder */
for ( i = 0; i < child->parent->info.dir.nchildren; i++) {
for (i = 0; i < child->parent->info.dir.nchildren; i++) {
if (child->parent->info.dir.children[i] == child) {
ret = create_placeholder(child->parent, child, &placeholder);
if (ret < 0) {
@ -644,7 +642,7 @@ int reparent(Ecma119Node *child, Ecma119Node *parent)
break;
}
}
/* just for debug, this should never happen... */
if (i == child->parent->info.dir.nchildren) {
return ISO_ERROR;
@ -652,12 +650,12 @@ int reparent(Ecma119Node *child, Ecma119Node *parent)
/* keep track of the real parent */
child->info.dir.real_parent = child->parent;
/* add the child to its new parent */
child->parent = parent;
parent->info.dir.nchildren++;
parent->info.dir.children = realloc( parent->info.dir.children,
sizeof(void*) * parent->info.dir.nchildren );
parent->info.dir.children = realloc(parent->info.dir.children,
sizeof(void*) * parent->info.dir.nchildren);
parent->info.dir.children[parent->info.dir.nchildren - 1] = child;
return ISO_SUCCESS;
}
@ -677,7 +675,7 @@ int reparent(Ecma119Node *child, Ecma119Node *parent)
* @return
* 1 success, < 0 error
*/
static
static
int reorder_tree(Ecma119Image *img, Ecma119Node *dir, int level, int pathlen)
{
int ret;
@ -690,7 +688,7 @@ int reorder_tree(Ecma119Image *img, Ecma119Node *dir, int level, int pathlen)
if (ret < 0) {
return ret;
}
/*
* we are appended to the root's children now, so there is no
* need to recurse (the root will hit us again)
@ -716,7 +714,7 @@ int ecma119_tree_create(Ecma119Image *img)
{
int ret;
Ecma119Node *root;
ret = create_tree(img, (IsoNode*)img->image->root, &root, 1, 0);
if (ret <= 0) {
if (ret == 0) {
@ -726,24 +724,24 @@ int ecma119_tree_create(Ecma119Image *img)
return ret;
}
img->root = root;
iso_msg_debug(img->image, "Sorting the low level tree...");
sort_tree(root);
iso_msg_debug(img->image, "Mangling names...");
ret = mangle_tree(img, 1);
if (ret < 0) {
return ret;
}
if (img->rockridge && !img->allow_deep_paths) {
/* reorder the tree, acording to RRIP, 4.1.5 */
ret = reorder_tree(img, img->root, 1, 0);
if (ret < 0) {
return ret;
}
/*
* and we need to remangle the root directory, as the function
* above could insert new directories into the root.
@ -754,6 +752,6 @@ int ecma119_tree_create(Ecma119Image *img)
return ret;
}
}
return ISO_SUCCESS;
}

24
src/ecma119_tree.h
View File

@ -23,22 +23,23 @@ enum ecma119_node_type {
/**
* Struct with info about a node representing a tree
*/
struct ecma119_dir_info {
struct ecma119_dir_info
{
/* Block where the directory entries will be written on image */
size_t block;
size_t nchildren;
Ecma119Node **children;
/*
* Size of the dir, i.e., sum of the lengths of all directory records.
* It is computed by calc_dir_size() [ecma119.c].
* Note that this don't include the length of any SUSP Continuation
* Area needed by the dir, but it includes the size of the SUSP entries
* than fit in the directory records System Use Field.
*/
*/
size_t len;
/**
* Real parent if the dir has been reallocated. NULL otherwise.
*/
@ -56,24 +57,25 @@ struct ecma119_node
* Version number is not include, it is added on the fly
*/
char *iso_name;
Ecma119Node *parent;
IsoNode *node; /*< reference to the iso node */
// TODO add true support for this
ino_t ino;
nlink_t nlink;
/**< file, symlink, special, directory or placeholder */
enum ecma119_node_type type;
union {
enum ecma119_node_type type;
union
{
IsoFileSrc *file;
// TODO this wastes too much memory, as dirs have much more
// atts than other kind of files. Replace with a pointer.
struct ecma119_dir_info dir;
/** this field points to the relocated directory. */
Ecma119Node *real_me;
Ecma119Node *real_me;
} info;
};

94
src/filesrc.c
View File

@ -23,15 +23,15 @@ int iso_file_src_cmp(const void *n1, const void *n2)
unsigned int fs_id1, fs_id2;
dev_t dev_id1, dev_id2;
ino_t ino_id1, ino_id2;
f1 = (const IsoFileSrc *)n1;
f2 = (const IsoFileSrc *)n2;
res = iso_stream_get_id(f1->stream, &fs_id1, &dev_id1, &ino_id1);
res = iso_stream_get_id(f2->stream, &fs_id2, &dev_id2, &ino_id2);
//TODO take care about res <= 0
if (fs_id1 < fs_id2) {
return -1;
} else if (fs_id1 > fs_id2) {
@ -44,8 +44,7 @@ int iso_file_src_cmp(const void *n1, const void *n2)
return 1;
} else {
/* files belong to same device in same fs */
return (ino_id1 < ino_id2) ? -1 :
(ino_id1 > ino_id2) ? 1 : 0;
return (ino_id1 < ino_id2) ? -1 : (ino_id1 > ino_id2) ? 1 : 0;
}
}
}
@ -57,11 +56,11 @@ int iso_file_src_create(Ecma119Image *img, IsoFile *file, IsoFileSrc **src)
unsigned int fs_id;
dev_t dev_id;
ino_t ino_id;
if (img == NULL || file == NULL || src == NULL) {
return ISO_NULL_POINTER;
}
res = iso_stream_get_id(file->stream, &fs_id, &dev_id, &ino_id);
if (res < 0) {
return res;
@ -73,18 +72,18 @@ int iso_file_src_create(Ecma119Image *img, IsoFile *file, IsoFileSrc **src)
return ISO_ERROR;
} else {
int ret;
fsrc = malloc(sizeof(IsoFileSrc));
if (fsrc == NULL) {
return ISO_MEM_ERROR;
}
/* fill key and other atts */
fsrc->prev_img = file->msblock ? 1 : 0;
fsrc->block = file->msblock;
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) {
@ -105,8 +104,7 @@ off_t iso_file_src_get_size(IsoFileSrc *file)
return iso_stream_get_size(file->stream);
}
static int
cmp_by_weight(const void *f1, const void *f2)
static int cmp_by_weight(const void *f1, const void *f2)
{
IsoFileSrc *f = *((IsoFileSrc**)f1);
IsoFileSrc *g = *((IsoFileSrc**)f2);
@ -120,33 +118,33 @@ int filesrc_writer_compute_data_blocks(IsoImageWriter *writer)
size_t i, size;
Ecma119Image *t;
IsoFileSrc **filelist;
if (writer == NULL) {
return ISO_MEM_ERROR;
}
t = writer->target;
/* store the filesrcs in a array */
filelist = (IsoFileSrc**)iso_rbtree_to_array(t->files);
if (filelist == NULL) {
return ISO_MEM_ERROR;
}
size = iso_rbtree_get_size(t->files);
/* sort files by weight, if needed */
/* sort files by weight, if needed */
if (t->sort_files) {
qsort(t->files, size, sizeof(void*), cmp_by_weight);
qsort(t->files, size, sizeof(void*), cmp_by_weight);
}
/* fill block value */
for (i = 0; i < size; ++i) {
IsoFileSrc *file = filelist[i];
file->block = t->curblock;
t->curblock += 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;
@ -176,25 +174,25 @@ int filesrc_close(IsoFileSrc *file)
* @return
* 1 ok, 0 EOF, < 0 error
*/
static
static
int filesrc_read(IsoFileSrc *file, char *buf, size_t count)
{
size_t bytes = 0;
/* loop to ensure the full buffer is filled */
do {
ssize_t result;
result = iso_stream_read(file->stream, buf + bytes, count - bytes);
if (result < 0) {
/* fill buffer with 0s and return */
if (result < 0) {
/* fill buffer with 0s and return */
memset(buf + bytes, 0, count - bytes);
return result;
}
if (result == 0)
break;
bytes += result;
bytes += result;
} while (bytes < count);
if (bytes < count) {
/* eof */
memset(buf + bytes, 0, count - bytes);
@ -212,16 +210,16 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
Ecma119Image *t;
IsoFileSrc **filelist;
char buffer[BLOCK_SIZE];
if (writer == NULL) {
return ISO_MEM_ERROR;
}
t = writer->target;
filelist = writer->data;
iso_msg_debug(t->image, "Writing Files...");
nfiles = iso_rbtree_get_size(t->files);
for (i = 0; i < nfiles; ++i) {
IsoFileSrc *file = filelist[i];
@ -239,20 +237,20 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
* UPS, very ugly error, the best we can do is just to write
* 0's to image
*/
// TODO Stream needs a get_path function
iso_msg_sorry(t->image, LIBISO_FILE_CANT_WRITE,
"File XXX can't be openned. Filling with 0s.");
memset(buffer, 0, BLOCK_SIZE);
for (b = 0; b < nblocks; ++b) {
// TODO Stream needs a get_path function
iso_msg_sorry(t->image, LIBISO_FILE_CANT_WRITE,
"File XXX can't be openned. Filling with 0s.");
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! */
return res;
}
}
continue;
}
continue;
}
/* write file contents to image */
for (b = 0; b < nblocks; ++b) {
int wres;
@ -263,16 +261,16 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
return wres;
}
}
if (b < nblocks) {
/* premature end of file, due to error or eof */
if (res < 0) {
/* error */
iso_msg_sorry(t->image, LIBISO_FILE_CANT_WRITE,
iso_msg_sorry(t->image, LIBISO_FILE_CANT_WRITE,
"Read error in file XXXXX.");
} else {
/* eof */
iso_msg_sorry(t->image, LIBISO_FILE_CANT_WRITE,
iso_msg_sorry(t->image, LIBISO_FILE_CANT_WRITE,
"Premature end of file XXXXX.");
}
/* fill with 0s */
@ -286,10 +284,10 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
}
}
}
filesrc_close(file);
}
return ISO_SUCCESS;
}
@ -304,19 +302,19 @@ int filesrc_writer_free_data(IsoImageWriter *writer)
int iso_file_src_writer_create(Ecma119Image *target)
{
IsoImageWriter *writer;
writer = malloc(sizeof(IsoImageWriter));
if (writer == NULL) {
return ISO_MEM_ERROR;
}
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;

5
src/filesrc.h
View File

@ -14,8 +14,9 @@
#include <stdint.h>
struct Iso_File_Src {
unsigned int prev_img:1; /**< if the file comes from a previous image */
struct Iso_File_Src
{
unsigned int prev_img :1; /**< if the file comes from a previous image */
uint32_t block; /**< Block where this file will be written on image */
int sort_weight;
IsoStream *stream;

62
src/fs_local.c
View File

@ -6,7 +6,6 @@
* published by the Free Software Foundation. See COPYING file for details.
*/
/*
* Filesystem/FileSource implementation to access the local filesystem.
*/
@ -29,15 +28,16 @@
/*
* We can share a local filesystem object, as it has no private atts.
*/
IsoFilesystem *lfs = NULL;
IsoFilesystem *lfs= NULL;
typedef struct
{
/* IsoFilesystem *fs; It seems not needed */
char *path;
unsigned int openned:2; /* 0: not openned, 1: file, 2:dir */
union {
unsigned int openned :2; /* 0: not openned, 1: file, 2:dir */
union
{
int fd;
DIR *dir;
} info;
@ -59,10 +59,10 @@ char* lfs_get_name(IsoFileSource *src)
data = src->data;
p = strdup(data->path); /* because basename() might modify its arg */
name = strdup(basename(p));
free(p);
free(p);
return name;
}
static
int lfs_lstat(IsoFileSource *src, struct stat *info)
{
@ -77,7 +77,7 @@ int lfs_lstat(IsoFileSource *src, struct stat *info)
int err;
/* error, choose an appropriate return code */
switch(errno) {
switch (errno) {
case EACCES:
err = ISO_FILE_ACCESS_DENIED;
break;
@ -101,7 +101,7 @@ int lfs_lstat(IsoFileSource *src, struct stat *info)
}
return ISO_SUCCESS;
}
static
int lfs_stat(IsoFileSource *src, struct stat *info)
{
@ -116,7 +116,7 @@ int lfs_stat(IsoFileSource *src, struct stat *info)
int err;
/* error, choose an appropriate return code */
switch(errno) {
switch (errno) {
case EACCES:
err = ISO_FILE_ACCESS_DENIED;
break;
@ -176,7 +176,7 @@ int lfs_open(IsoFileSource *src)
* parsed in the lstat call above
*/
if (data->openned == 0) {
switch(errno) {
switch (errno) {
case EACCES:
err = ISO_FILE_ACCESS_DENIED;
break;
@ -205,7 +205,7 @@ int lfs_close(IsoFileSource *src)
}
data = src->data;
switch(data->openned) {
switch (data->openned) {
case 1: /* not dir */
ret = close(data->info.fd) == 0 ? ISO_SUCCESS : ISO_FILE_ERROR;
break;
@ -232,14 +232,14 @@ int lfs_read(IsoFileSource *src, void *buf, size_t count)
}
data = src->data;
switch(data->openned) {
switch (data->openned) {
case 1: /* not dir */
{
int ret;
ret = read(data->info.fd, buf, count);
if (ret < 0) {
/* error on read */
switch(errno) {
switch (errno) {
case EINTR:
ret = ISO_INTERRUPTED;
break;
@ -273,7 +273,7 @@ int lfs_readdir(IsoFileSource *src, IsoFileSource **child)
}
data = src->data;
switch(data->openned) {
switch (data->openned) {
case 1: /* not dir */
return ISO_FILE_IS_NOT_DIR;
case 2: /* directory */
@ -292,7 +292,7 @@ int lfs_readdir(IsoFileSource *src, IsoFileSource **child)
else
return 0; /* EOF */
}
if (strcmp(entry->d_name,".") && strcmp(entry->d_name,"..")) {
if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
break;
}
}
@ -342,7 +342,7 @@ int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
size = readlink(data->path, buf, bufsiz - 1);
if (size < 0) {
/* error */
switch(errno) {
switch (errno) {
case EACCES:
return ISO_FILE_ACCESS_DENIED;
case ENOTDIR:
@ -389,7 +389,7 @@ void lfs_free(IsoFileSource *src)
iso_filesystem_unref(lfs);
}
IsoFileSourceIface lfs_class = {
IsoFileSourceIface lfs_class = {
lfs_get_path,
lfs_get_name,
lfs_lstat,
@ -450,7 +450,7 @@ int iso_file_source_new_lfs(const char *path, IsoFileSource **src)
lfs_src->refcount = 1;
lfs_src->data = data;
lfs_src->class = &lfs_class;
/* take a ref to local filesystem */
iso_filesystem_ref(lfs);
@ -462,19 +462,19 @@ int iso_file_source_new_lfs(const char *path, IsoFileSource **src)
static
int lfs_get_root(IsoFilesystem *fs, IsoFileSource **root)
{
if (fs == NULL || root == NULL) {
if (fs == NULL || root == NULL) {
return ISO_NULL_POINTER;
}
return iso_file_source_new_lfs("/", root);
return iso_file_source_new_lfs("/", root);
}
static
int lfs_get_by_path(IsoFilesystem *fs, const char *path, IsoFileSource **file)
{
if (fs == NULL || path == NULL || file == NULL) {
if (fs == NULL || path == NULL || file == NULL) {
return ISO_NULL_POINTER;
}
return iso_file_source_new_lfs(path, file);
return iso_file_source_new_lfs(path, file);
}
static
@ -486,25 +486,25 @@ unsigned int lfs_get_id(IsoFilesystem *fs)
static
void lfs_fs_free(IsoFilesystem *fs)
{
lfs = NULL;
lfs = NULL;
}
int iso_local_filesystem_new(IsoFilesystem **fs)
{
if (fs == NULL) {
if (fs == NULL) {
return ISO_NULL_POINTER;
}
if (lfs != NULL) {
/* just take a new ref */
iso_filesystem_ref(lfs);
} else {
lfs = malloc(sizeof(IsoFilesystem));
lfs = malloc(sizeof(IsoFilesystem));
if (lfs == NULL) {
return ISO_OUT_OF_MEM;
}
/* fill struct */
lfs->refcount = 1;
lfs->data = NULL; /* we don't need private data */
@ -513,6 +513,6 @@ int iso_local_filesystem_new(IsoFilesystem **fs)
lfs->get_id = lfs_get_id;
lfs->free = lfs_fs_free;
}
*fs = lfs;
return ISO_SUCCESS;
*fs = lfs;
return ISO_SUCCESS;
}

20
src/fsource.c
View File

@ -16,26 +16,26 @@ unsigned int iso_fs_global_id = 100;
void iso_file_source_ref(IsoFileSource *src)
{
++src->refcount;
++src->refcount;
}
void iso_file_source_unref(IsoFileSource *src)
{
if (--src->refcount == 0) {
src->class->free(src);
free(src);
}
if (--src->refcount == 0) {
src->class->free(src);
free(src);
}
}
void iso_filesystem_ref(IsoFilesystem *fs)
{
++fs->refcount;
++fs->refcount;
}
void iso_filesystem_unref(IsoFilesystem *fs)
{
if (--fs->refcount == 0) {
fs->free(fs);
free(fs);
}
if (--fs->refcount == 0) {
fs->free(fs);
free(fs);
}
}

63
src/fsource.h
View File

@ -14,8 +14,7 @@
*/
/*
* Some functions here will be moved to libisofs.h when we expose
* Sources.
* Some functions here will be moved to libisofs.h when we expose Sources.
*/
#include <sys/stat.h>
@ -43,9 +42,9 @@ struct Iso_Filesystem
* @return
* 1 success, < 0 error
*/
int (*get_by_path)(IsoFilesystem *fs, const char *path,
int (*get_by_path)(IsoFilesystem *fs, const char *path,
IsoFileSource **file);
/**
* Get filesystem identifier.
*
@ -81,7 +80,7 @@ typedef struct IsoFileSource_Iface
* freed by the user.
*/
const char* (*get_path)(IsoFileSource *src);
/**
* Get the name of the file, with the dir component of the path.
*
@ -103,7 +102,7 @@ typedef struct IsoFileSource_Iface
* ISO_NULL_POINTER
*/
int (*lstat)(IsoFileSource *src, struct stat *info);
/**
* Get information about the file. If the file is a symlink, the info
* returned refers to the destination.
@ -211,7 +210,7 @@ typedef struct IsoFileSource_Iface
*
*/
int (*readlink)(IsoFileSource *src, char *buf, size_t bufsiz);
/**
* Get the filesystem for this source. No extra ref is added, so you
* musn't unref the IsoFilesystem.
@ -233,7 +232,8 @@ typedef struct IsoFileSource_Iface
*/
} IsoFileSourceIface;
struct Iso_File_Source {
struct Iso_File_Source
{
const IsoFileSourceIface *class;
int refcount;
void *data;
@ -245,54 +245,63 @@ void iso_file_source_unref(IsoFileSource *src);
/*
* this are just helpers to invoque methods in class
*/
extern inline
const char* iso_file_source_get_path(IsoFileSource *src) {
extern inline
const char* iso_file_source_get_path(IsoFileSource *src)
{
return src->class->get_path(src);
}
extern inline
char* iso_file_source_get_name(IsoFileSource *src) {
extern inline
char* iso_file_source_get_name(IsoFileSource *src)
{
return src->class->get_name(src);
}
extern inline
int iso_file_source_lstat(IsoFileSource *src, struct stat *info) {
extern inline
int iso_file_source_lstat(IsoFileSource *src, struct stat *info)
{
return src->class->lstat(src, info);
}
extern inline
int iso_file_source_stat(IsoFileSource *src, struct stat *info) {
extern inline
int iso_file_source_stat(IsoFileSource *src, struct stat *info)
{
return src->class->stat(src, info);
}
extern inline
int iso_file_source_open(IsoFileSource *src) {
extern inline
int iso_file_source_open(IsoFileSource *src)
{
return src->class->open(src);
}
extern inline
int iso_file_source_close(IsoFileSource *src) {
extern inline
int iso_file_source_close(IsoFileSource *src)
{
return src->class->close(src);
}
extern inline
int iso_file_source_read(IsoFileSource *src, void *buf, size_t count) {
extern inline
int iso_file_source_read(IsoFileSource *src, void *buf, size_t count)
{
return src->class->read(src, buf, count);
}
extern inline
extern inline
int iso_file_source_readdir(IsoFileSource *src, IsoFileSource **child)
{
return src->class->readdir(src, child);
}
extern inline
int iso_file_source_readlink(IsoFileSource *src, char *buf, size_t bufsiz) {
extern inline
int iso_file_source_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
{
return src->class->readlink(src, buf, bufsiz);
}
extern inline
IsoFilesystem* iso_file_source_get_filesystem(IsoFileSource *src) {
extern inline
IsoFilesystem* iso_file_source_get_filesystem(IsoFileSource *src)
{
return src->class->get_filesystem(src);
}

27
src/image.c
View File

@ -31,23 +31,23 @@ int iso_image_new(const char *name, IsoImage **image)
{
int res;
IsoImage *img;
if (image == NULL) {
return ISO_NULL_POINTER;
}
img = calloc(1, sizeof(IsoImage));
if (img == NULL) {
return ISO_MEM_ERROR;
}
/* local filesystem will be used by default */
res = iso_local_filesystem_new(&(img->fs));
if (res < 0) {
free(img);
return ISO_MEM_ERROR;
}
/* use basic builder as default */
res = iso_node_basic_builder_new(&(img->builder));
if (res < 0) {
@ -55,7 +55,7 @@ int iso_image_new(const char *name, IsoImage **image)
free(img);
return ISO_MEM_ERROR;
}
/* create message messenger */
res = libiso_msgs_new(&img->messenger, 0);
if (res <= 0) {
@ -64,9 +64,9 @@ int iso_image_new(const char *name, IsoImage **image)
free(img);
return ISO_MEM_ERROR;
}
libiso_msgs_set_severities(img->messenger, LIBISO_MSGS_SEV_NEVER,
libiso_msgs_set_severities(img->messenger, LIBISO_MSGS_SEV_NEVER,
LIBISO_MSGS_SEV_FATAL, name, 0);
/* fill image fields */
res = iso_node_new_root(&img->root);
if (res < 0) {
@ -77,7 +77,7 @@ int iso_image_new(const char *name, IsoImage **image)
return res;
}
img->refcount = 1;
img->recOpts = calloc(1,sizeof(IsoImageRecOpts));
img->recOpts = calloc(1, sizeof(IsoImageRecOpts));
if (img->recOpts == NULL) {
libiso_msgs_destroy(&img->messenger, 0);
iso_node_builder_unref(img->builder);
@ -86,7 +86,7 @@ int iso_image_new(const char *name, IsoImage **image)
free(img);
return ISO_MEM_ERROR;
}
if (name != NULL) {
img->volset_id = strdup(name);
img->volume_id = strdup(name);
@ -167,7 +167,7 @@ const char *iso_image_get_publisher_id(const IsoImage *image)
}
void iso_image_set_data_preparer_id(IsoImage *image,
const char *data_preparer_id)
const char *data_preparer_id)
{
free(image->data_preparer_id);
image->data_preparer_id = strdup(data_preparer_id);
@ -201,7 +201,7 @@ const char *iso_image_get_application_id(const IsoImage *image)
}
void iso_image_set_copyright_file_id(IsoImage *image,
const char *copyright_file_id)
const char *copyright_file_id)
{
free(image->copyright_file_id);
image->copyright_file_id = strdup(copyright_file_id);
@ -213,7 +213,7 @@ const char *iso_image_get_copyright_file_id(const IsoImage *image)
}
void iso_image_set_abstract_file_id(IsoImage *image,
const char *abstract_file_id)
const char *abstract_file_id)
{
free(image->abstract_file_id);
image->abstract_file_id = strdup(abstract_file_id);
@ -224,8 +224,7 @@ const char *iso_image_get_abstract_file_id(const IsoImage *image)
return image->abstract_file_id;
}
void iso_image_set_biblio_file_id(IsoImage *image,
const char *biblio_file_id)
void iso_image_set_biblio_file_id(IsoImage *image, const char *biblio_file_id)
{
free(image->biblio_file_id);
image->biblio_file_id = strdup(biblio_file_id);

44
src/image.h
View File

@ -21,39 +21,40 @@
* (Usefull, for example, in Multiple-Document-Interface GUI apps.
* [The stuff we have in init belongs really to image!]
*/
typedef struct Iso_Image_Rec_Opts IsoImageRecOpts;
struct Iso_Image {
struct Iso_Image
{
int refcount;
IsoDir *root;
char *volset_id;
char *volume_id; /**< Volume identifier. */
char *publisher_id; /**< Volume publisher. */
char *volume_id; /**< Volume identifier. */
char *publisher_id; /**< Volume publisher. */
char *data_preparer_id; /**< Volume data preparer. */
char *system_id; /**< Volume system identifier. */
char *application_id; /**< Volume application id */
char *system_id; /**< Volume system identifier. */
char *application_id; /**< Volume application id */
char *copyright_file_id;
char *abstract_file_id;
char *biblio_file_id;
/* message messenger for the image */
struct libiso_msgs *messenger;
/**
* Default filesystem to use when adding files to the image tree.
*/
IsoFilesystem *fs;
/*
* Default builder to use when adding files to the image tree.
*/
IsoNodeBuilder *builder;
/**
* Options for recursive directory addition
*/
@ -63,30 +64,31 @@ struct Iso_Image {
/**
* Options for recursive directory addition
*/
struct Iso_Image_Rec_Opts {
struct Iso_Image_Rec_Opts
{
/**
* Whether to follow symlinks or just add them as symlinks
*/
unsigned int follow_symlinks;
/**
* Whether to skip hidden files
*/
unsigned int ignore_hidden;
/**
* Whether to stop on an error. Some errors, such as memory errors,
* always cause a stop
*/
unsigned int stop_on_error;
/**
* Files to exclude
* TODO add wildcard support
*/
char** excludes;
/**
* if the dir already contains a node with the same name, whether to
* replace or not the old node with the new.
@ -97,7 +99,7 @@ struct Iso_Image_Rec_Opts {
* if both are dirs, add contents (and what to do with conflicts?)
*/
int replace;
/**
* When this is not NULL, it is a pointer to a function that will
* be called just before a file will be added, or when an error occurs.

122
src/libisofs.h
View File

@ -58,28 +58,29 @@ enum IsoHideNodeFlag {
/**
* Holds the options for the image generation.
*/
typedef struct {
int level; /**< ISO level to write at. */
typedef struct
{
int level; /**< ISO level to write at. */
/** Which extensions to support. */
unsigned int rockridge:1;
unsigned int rockridge :1;
/* relaxed constraints */
unsigned int omit_version_numbers:1;
unsigned int allow_deep_paths:1;
unsigned int omit_version_numbers :1;
unsigned int allow_deep_paths :1;
//int relaxed_constraints; /**< see ecma119_relaxed_constraints_flag */
//unsigned int copy_eltorito:1;
/**<
* In multisession discs, select whether to copy el-torito catalog
* and boot image. Copy is needed for isolinux images, that need to
* be patched. However, it can lead to problems when the image is
* not present in the iso filesystem, because we can't figure out
* its size. In those cases, we only copy 1 block of data.
*/
/**<
* In multisession discs, select whether to copy el-torito catalog
* and boot image. Copy is needed for isolinux images, that need to
* be patched. However, it can lead to problems when the image is
* not present in the iso filesystem, because we can't figure out
* its size. In those cases, we only copy 1 block of data.
*/
/**< If files should be sorted based on their weight. */
unsigned int sort_files:1;
unsigned int sort_files :1;
/**
* The following options set the default values for files and directory
@ -92,10 +93,10 @@ typedef struct {
* below. Note that for mode attributes, only the permissions are set, the
* file type remains unchanged.
*/
unsigned int replace_dir_mode:2;
unsigned int replace_file_mode:2;
unsigned int replace_uid:2;
unsigned int replace_gid:2;
unsigned int replace_dir_mode :2;
unsigned int replace_file_mode :2;
unsigned int replace_uid :2;
unsigned int replace_gid :2;
mode_t dir_mode; /** Mode to use on dirs when replace_dir_mode == 2. */
mode_t file_mode; /** Mode to use on files when replace_file_mode == 2. */
@ -103,35 +104,35 @@ typedef struct {
gid_t gid; /** gid to use when replace_gid == 2. */
char *output_charset; /**< NULL to use default charset */
// uint32_t ms_block;
/**<
* Start block for multisession. When this is greater than 0,
* it's suppossed to be the lba of the next writable address
* on disc; all block lba on image will take this into account,
* and files from a previous session will not be written on
* image. This behavior is only suitable for images to be
* appended to a multisession disc.
* When this is 0, no multisession image will be created. If
* some files are taken from a previous image, its contents
* will be written again to the new image. Use this with new
* images or if you plan to modify an existin image.
*/
// struct data_source* src;
// /**<
// * When modifying a image, this is the source of the original
// * image, used to read file contents.
// * Otherwise it can be NULL.
// */
// uint8_t *overwrite;
// /**<
// * When not NULL, it should point to a buffer of at least
// * 64KiB, where libisofs will write the contents that should
// * be written at the beginning of a overwriteable media, to
// * grow the image.
// * You shoudl initialize the buffer either with 0s, or with
// * the contents of the first blocks of the image you're
// * growing. In most cases, 0 is good enought.
// */
// uint32_t ms_block;
/**<
* Start block for multisession. When this is greater than 0,
* it's suppossed to be the lba of the next writable address
* on disc; all block lba on image will take this into account,
* and files from a previous session will not be written on
* image. This behavior is only suitable for images to be
* appended to a multisession disc.
* When this is 0, no multisession image will be created. If
* some files are taken from a previous image, its contents
* will be written again to the new image. Use this with new
* images or if you plan to modify an existin image.
*/
// struct data_source* src;
// /**<
// * When modifying a image, this is the source of the original
// * image, used to read file contents.
// * Otherwise it can be NULL.
// */
// uint8_t *overwrite;
// /**<
// * When not NULL, it should point to a buffer of at least
// * 64KiB, where libisofs will write the contents that should
// * be written at the beginning of a overwriteable media, to
// * grow the image.
// * You shoudl initialize the buffer either with 0s, or with
// * the contents of the first blocks of the image you're
// * growing. In most cases, 0 is good enought.
// */
} Ecma119WriteOpts;
/**
@ -210,7 +211,7 @@ const char *iso_image_get_publisher_id(const IsoImage *image);
* Fill in the data preparer for a image.
*/
void iso_image_set_data_preparer_id(IsoImage *image,
const char *data_preparer_id);
const char *data_preparer_id);
/**
* Get the data preparer of a image.
@ -248,7 +249,7 @@ const char *iso_image_get_application_id(const IsoImage *image);
* to a file on disc. Up to 37 characters.
*/
void iso_image_set_copyright_file_id(IsoImage *image,
const char *copyright_file_id);
const char *copyright_file_id);
/**
* Get the copyright information of a image.
@ -262,7 +263,7 @@ const char *iso_image_get_copyright_file_id(const IsoImage *image);
* to a file on disc. Up to 37 characters.
*/
void iso_image_set_abstract_file_id(IsoImage *image,
const char *abstract_file_id);
const char *abstract_file_id);
/**
* Get the abstract information of a image.
@ -275,8 +276,7 @@ const char *iso_image_get_abstract_file_id(const IsoImage *image);
* Fill biblio information for the image. Usually this refers
* to a file on disc. Up to 37 characters.
*/
void iso_image_set_biblio_file_id(IsoImage *image,
const char *biblio_file_id);
void iso_image_set_biblio_file_id(IsoImage *image, const char *biblio_file_id);
/**
* Get the biblio information of a image.
@ -659,9 +659,9 @@ int iso_file_get_sort_weight(IsoFile *file);
int iso_tree_add_new_dir(IsoDir *parent, const char *name, IsoDir **dir);
/*
TODO #00007 expose Strem and thi function:
int iso_tree_add_new_file(IsoDir *parent, const char *name, stream, file)
*/
TODO #00007 expose Strem and thi function:
int iso_tree_add_new_file(IsoDir *parent, const char *name, stream, file)
*/
/**
* Add a new symlink to the directory tree. Permissions are set to 0777,
@ -687,7 +687,7 @@ int iso_tree_add_new_file(IsoDir *parent, const char *name, stream, file)
* ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
* ISO_MEM_ERROR
*/
int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
const char *dest, IsoSymlink **link);
/**
@ -728,7 +728,7 @@ int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
* ISO_WRONG_ARG_VALUE if you select a incorrect mode
* ISO_MEM_ERROR
*/
int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
dev_t dev, IsoSpecial **special);
/**
@ -757,7 +757,7 @@ int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
* ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
* ISO_MEM_ERROR
*/
int iso_tree_add_node(IsoImage *image, IsoDir *parent, const char *path,
int iso_tree_add_node(IsoImage *image, IsoDir *parent, const char *path,
IsoNode **node);
/**
@ -808,7 +808,7 @@ int iso_tree_path_to_node(IsoImage *image, const char *path, IsoNode **node);
* @return >0 for success, <=0 for error
*/
int iso_image_set_msgs_severities(IsoImage *img, char *queue_severity,
char *print_severity, char *print_id);
char *print_severity, char *print_id);
/**
* Obtain the oldest pending message from a IsoImage message queue which has at
* least the given minimum_severity. This message and any older message of

141
src/messages.c
View File

@ -20,81 +20,78 @@ void iso_msg_debug(IsoImage *img, const char *fmt, ...)
{
char msg[MAX_MSG_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(msg, MAX_MSG_LEN, fmt, ap);
va_end(ap);
libiso_msgs_submit(img->messenger, -1, 0x00000002, LIBISO_MSGS_SEV_DEBUG,
libiso_msgs_submit(img->messenger, -1, 0x00000002, LIBISO_MSGS_SEV_DEBUG,
LIBISO_MSGS_PRIO_ZERO, msg, 0, 0);
}
void iso_msg_note(IsoImage *img, int error_code, const char *fmt, ...)
{
char msg[MAX_MSG_LEN];
char msg[MAX_MSG_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(msg, MAX_MSG_LEN, fmt, ap);
va_end(ap);
libiso_msgs_submit(img->messenger, -1, error_code, LIBISO_MSGS_SEV_NOTE,
LIBISO_MSGS_PRIO_MEDIUM, msg, 0, 0);
}
void iso_msg_hint(IsoImage *img, int error_code, const char *fmt, ...)
{
char msg[MAX_MSG_LEN];
char msg[MAX_MSG_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(msg, MAX_MSG_LEN, fmt, ap);
va_end(ap);
libiso_msgs_submit(img->messenger, -1, error_code, LIBISO_MSGS_SEV_HINT,
LIBISO_MSGS_PRIO_MEDIUM, msg, 0, 0);
}
void iso_msg_warn(IsoImage *img, int error_code, const char *fmt, ...)
{
char msg[MAX_MSG_LEN];
char msg[MAX_MSG_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(msg, MAX_MSG_LEN, fmt, ap);
va_end(ap);
libiso_msgs_submit(img->messenger, -1, error_code,
LIBISO_MSGS_SEV_WARNING, LIBISO_MSGS_PRIO_MEDIUM,
msg, 0, 0);
libiso_msgs_submit(img->messenger, -1, error_code, LIBISO_MSGS_SEV_WARNING,
LIBISO_MSGS_PRIO_MEDIUM, msg, 0, 0);
}
void iso_msg_sorry(IsoImage *img, int error_code, const char *fmt, ...)
{
char msg[MAX_MSG_LEN];
char msg[MAX_MSG_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(msg, MAX_MSG_LEN, fmt, ap);
va_end(ap);
libiso_msgs_submit(img->messenger, -1, error_code,
LIBISO_MSGS_SEV_SORRY, LIBISO_MSGS_PRIO_HIGH,
msg, 0, 0);
libiso_msgs_submit(img->messenger, -1, error_code, LIBISO_MSGS_SEV_SORRY,
LIBISO_MSGS_PRIO_HIGH, msg, 0, 0);
}
void iso_msg_fatal(IsoImage *img, int error_code, const char *fmt, ...)
{
char msg[MAX_MSG_LEN];
char msg[MAX_MSG_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(msg, MAX_MSG_LEN, fmt, ap);
va_end(ap);
libiso_msgs_submit(img->messenger, -1, error_code,
LIBISO_MSGS_SEV_FATAL, LIBISO_MSGS_PRIO_HIGH,
msg, 0, 0);
libiso_msgs_submit(img->messenger, -1, error_code, LIBISO_MSGS_SEV_FATAL,
LIBISO_MSGS_PRIO_HIGH, msg, 0, 0);
}
/**
@ -113,19 +110,19 @@ void iso_msg_fatal(IsoImage *img, int error_code, const char *fmt, ...)
int iso_image_set_msgs_severities(IsoImage *img, char *queue_severity,
char *print_severity, char *print_id)
{
int ret, queue_sevno, print_sevno;
int ret, queue_sevno, print_sevno;
ret = libiso_msgs__text_to_sev(queue_severity, &queue_sevno, 0);
if (ret <= 0)
return 0;
ret = libiso_msgs__text_to_sev(print_severity, &print_sevno, 0);
if (ret <= 0)
return 0;
ret = libiso_msgs_set_severities(img->messenger, queue_sevno,
print_sevno, print_id, 0);
if (ret <= 0)
return 0;
return 1;
ret = libiso_msgs__text_to_sev(queue_severity, &queue_sevno, 0);
if (ret <= 0)
return 0;
ret = libiso_msgs__text_to_sev(print_severity, &print_sevno, 0);
if (ret <= 0)
return 0;
ret = libiso_msgs_set_severities(img->messenger, queue_sevno, print_sevno,
print_id, 0);
if (ret <= 0)
return 0;
return 1;
}
#define ISO_MSGS_MESSAGE_LEN 4096
@ -147,47 +144,47 @@ int iso_image_set_msgs_severities(IsoImage *img, char *queue_severity,
* @return 1 if a matching item was found, 0 if not, <0 for severe errors
*/
int iso_image_obtain_msgs(IsoImage *img, char *minimum_severity,
int *error_code, char msg_text[], int *os_errno,
char severity[])
int *error_code, char msg_text[], int *os_errno,
char severity[])
{
int ret, minimum_sevno, sevno, priority;
char *textpt, *sev_name;
struct libiso_msgs_item *item = NULL;
int ret, minimum_sevno, sevno, priority;
char *textpt, *sev_name;
struct libiso_msgs_item *item= NULL;
if (img == NULL)
return 0;
if (img == NULL)
return 0;
ret = libiso_msgs__text_to_sev(minimum_severity, &minimum_sevno, 0);
if (ret <= 0)
return 0;
ret = libiso_msgs_obtain(img->messenger, &item, minimum_sevno,
LIBISO_MSGS_PRIO_ZERO, 0);
if (ret <= 0)
goto ex;
ret = libiso_msgs_item_get_msg(item, error_code, &textpt, os_errno, 0);
if (ret <= 0)
goto ex;
strncpy(msg_text, textpt, ISO_MSGS_MESSAGE_LEN-1);
if(strlen(textpt) >= ISO_MSGS_MESSAGE_LEN)
msg_text[ISO_MSGS_MESSAGE_LEN-1] = 0;
ret = libiso_msgs__text_to_sev(minimum_severity, &minimum_sevno, 0);
if (ret <= 0)
return 0;
ret = libiso_msgs_obtain(img->messenger, &item, minimum_sevno,
LIBISO_MSGS_PRIO_ZERO, 0);
if (ret <= 0)
goto ex;
ret = libiso_msgs_item_get_msg(item, error_code, &textpt, os_errno, 0);
if (ret <= 0)
goto ex;
strncpy(msg_text, textpt, ISO_MSGS_MESSAGE_LEN-1);
if (strlen(textpt) >= ISO_MSGS_MESSAGE_LEN)
msg_text[ISO_MSGS_MESSAGE_LEN-1] = 0;
severity[0]= 0;
ret = libiso_msgs_item_get_rank(item, &sevno, &priority, 0);
if(ret <= 0)
goto ex;
ret = libiso_msgs__sev_to_text(sevno, &sev_name, 0);
if(ret <= 0)
goto ex;
strcpy(severity,sev_name);
severity[0]= 0;
ret = libiso_msgs_item_get_rank(item, &sevno, &priority, 0);
if (ret <= 0)
goto ex;
ret = libiso_msgs__sev_to_text(sevno, &sev_name, 0);
if (ret <= 0)
goto ex;
strcpy(severity, sev_name);
ret = 1;
ex:
libiso_msgs_destroy_item(img->messenger, &item, 0);
return ret;
ret = 1;
ex: ;
libiso_msgs_destroy_item(img->messenger, &item, 0);
return ret;
}
void *iso_image_get_messenger(IsoImage *img)
{
return img->messenger;
return img->messenger;
}

4
src/messages.h
View File

@ -47,11 +47,11 @@
/** Can't read previous image file */
#define LIBISO_CANT_READ_IMG 0x00031003
/* Unsupported SUSP entry */
/* Unsupported SUSP entry */
#define LIBISO_SUSP_UNHANLED 0x00030101
/* Wrong SUSP entry, that cause RR to be ignored */
#define LIBISO_SUSP_WRONG 0x00030102
/* Unsupported multiple SUSP ER entries where found */
/* Unsupported multiple SUSP ER entries where found */
#define LIBISO_SUSP_MULTIPLE_ER 0x00030103
/** Unsupported RR feature. */
#define LIBISO_RR_UNSUPPORTED 0x00030111

48
src/node.c
View File

@ -31,7 +31,7 @@ void iso_node_ref(IsoNode *node)
void iso_node_unref(IsoNode *node)
{
if (--node->refcount == 0) {
switch(node->type) {
switch (node->type) {
case LIBISO_DIR:
{
IsoNode *child = ((IsoDir*)node)->children;
@ -56,7 +56,7 @@ void iso_node_unref(IsoNode *node)
}
default:
/* TODO #00002 handle deletion of each kind of node */
break;
break;
}
free(node->name);
free(node);
@ -79,12 +79,12 @@ enum IsoNodeType iso_node_get_type(IsoNode *node)
int iso_node_set_name(IsoNode *node, const char *name)
{
char *new;
/* guard against the empty string or big names... */
if (name[0] == '\0' || strlen(name) > 255) {
return ISO_WRONG_ARG_VALUE;
}
/* ...against "." and ".." names... */
if (!strcmp(name, ".") || !strcmp(name, "..")) {
return ISO_WRONG_ARG_VALUE;
@ -99,7 +99,7 @@ int iso_node_set_name(IsoNode *node, const char *name)
/* you can't change name of the root node */
return ISO_WRONG_ARG_VALUE;
}
new = strdup(name);
if (new == NULL) {
return ISO_MEM_ERROR;
@ -124,7 +124,7 @@ int iso_node_set_name(IsoNode *node, const char *name)
return res;
}
}
return ISO_SUCCESS;
return ISO_SUCCESS;
}
/**
@ -168,7 +168,6 @@ mode_t iso_node_get_mode(const IsoNode *node)
return node->mode;
}
/**
* Set the user id for the node. This attribute is only useful when
* Rock Ridge extensions are enabled.
@ -275,14 +274,14 @@ void iso_node_set_hidden(IsoNode *node, int hide_attrs)
int iso_dir_add_node(IsoDir *dir, IsoNode *child, int replace)
{
IsoNode **pos;
if (dir == NULL || child == NULL) {
return ISO_NULL_POINTER;
}
if ((IsoNode*)dir == child) {
return ISO_WRONG_ARG_VALUE;
}
/*
* check if child is already added to another dir, or if child
* is the root node, where parent == itself
@ -290,7 +289,7 @@ int iso_dir_add_node(IsoDir *dir, IsoNode *child, int replace)
if (child->parent != NULL || child->parent == (IsoDir*)child) {
return ISO_NODE_ALREADY_ADDED;
}
pos = &(dir->children);
while (*pos != NULL && strcmp((*pos)->name, child->name) < 0) {
pos = &((*pos)->next);
@ -311,11 +310,11 @@ int iso_dir_add_node(IsoDir *dir, IsoNode *child, int replace)
return ISO_WRONG_ARG_VALUE;
}
}
child->next = *pos;
*pos = child;
child->parent = dir;
return ++dir->nchildren;
}
@ -342,19 +341,19 @@ int iso_dir_get_node(IsoDir *dir, const char *name, IsoNode **node)
if (dir == NULL || name == NULL) {
return ISO_NULL_POINTER;
}
pos = dir->children;
while (pos != NULL && strcmp(pos->name, name) < 0) {
pos = pos->next;
}
if (pos == NULL || strcmp(pos->name, name)) {
if (node) {
*node = NULL;
}
return 0; /* node not found */
}
if (node) {
*node = pos;
}
@ -380,7 +379,7 @@ int iso_dir_get_nchildren(IsoDir *dir)
int iso_dir_get_children(const IsoDir *dir, IsoDirIter **iter)
{
IsoDirIter *it;
if (dir == NULL || iter == NULL) {
return ISO_NULL_POINTER;
}
@ -388,10 +387,10 @@ int iso_dir_get_children(const IsoDir *dir, IsoDirIter **iter)
if (it == NULL) {
return ISO_OUT_OF_MEM;
}
it->dir = dir;
it->pos = dir->children;
*iter = it;
return ISO_SUCCESS;
}
@ -437,14 +436,13 @@ void iso_dir_iter_free(IsoDirIter *iter)
free(iter);
}
static IsoNode**
iso_dir_find_node(IsoDir *dir, IsoNode *node)
static IsoNode** iso_dir_find_node(IsoDir *dir, IsoNode *node)
{
IsoNode **pos;
pos = &(dir->children);
while (*pos != NULL && *pos != node) {
pos = &((*pos)->next);
}
}
return pos;
}
@ -461,7 +459,7 @@ int iso_node_take(IsoNode *node)
{
IsoNode **pos;
IsoDir* dir;
if (node == NULL) {
return ISO_NULL_POINTER;
}
@ -507,7 +505,7 @@ int iso_dir_iter_take(IsoDirIter *iter)
if (iter == NULL) {
return ISO_NULL_POINTER;
}
pos = iter->dir->children;
if (iter->pos == pos) {
return ISO_ERROR;
@ -599,7 +597,7 @@ int iso_file_get_sort_weight(IsoFile *file)
int iso_node_new_root(IsoDir **root)
{
IsoDir *dir;
dir = calloc(1, sizeof(IsoDir));
if (dir == NULL) {
return ISO_MEM_ERROR;
@ -608,7 +606,7 @@ int iso_node_new_root(IsoDir **root)
dir->node.type = LIBISO_DIR;
dir->node.atime = dir->node.ctime = dir->node.mtime = time(NULL);
dir->node.mode = S_IFDIR | 0555;
/* set parent to itself, to prevent root to be added to another dir */
dir->node.parent = dir;
*root = dir;

22
src/node.h
View File

@ -34,21 +34,21 @@ struct Iso_Node
*/
int refcount;
/**< Type of the IsoNode, do not confuse with mode */
/** Type of the IsoNode, do not confuse with mode */
enum IsoNodeType type;
char *name; /**< Real name, in default charset */
mode_t mode; /**< protection */
uid_t uid; /**< user ID of owner */
gid_t gid; /**< group ID of owner */
uid_t uid; /**< user ID of owner */
gid_t gid; /**< group ID of owner */
/* TODO #00001 : consider adding new timestamps */
time_t atime; /**< time of last access */
time_t mtime; /**< time of last modification */
time_t ctime; /**< time of last status change */
int hidden; /**< whether the node will be hidden, see IsoHideNodeFlag */
int hidden; /**< whether the node will be hidden, see IsoHideNodeFlag */
IsoDir *parent; /**< parent node, NULL for root */
@ -69,16 +69,16 @@ struct Iso_Dir
struct Iso_File
{
IsoNode node;
/**
* Location of a file extent in a ms disc, 0 for newly added file
*/
uint32_t msblock;
/**
* It sorts the order in which the file data is written to the CD image.
* Higher weighting files are written at the beginning of image
*/
/**
* It sorts the order in which the file data is written to the CD image.
* Higher weighting files are written at the beginning of image
*/
int sort_weight;
IsoStream *stream;
};
@ -86,7 +86,7 @@ struct Iso_File
struct Iso_Symlink
{
IsoNode node;
char *dest;
};

215
src/rockridge.c
View File

@ -20,8 +20,8 @@ static
int susp_append(Ecma119Image *t, struct susp_info *susp, uint8_t *data)
{
susp->n_susp_fields++;
susp->susp_fields = realloc(susp->susp_fields,
sizeof(void*) * susp->n_susp_fields);
susp->susp_fields = realloc(susp->susp_fields, sizeof(void*)
* susp->n_susp_fields);
if (susp->susp_fields == NULL) {
return ISO_MEM_ERROR;
}
@ -34,8 +34,8 @@ static
int susp_append_ce(Ecma119Image *t, struct susp_info *susp, uint8_t *data)
{
susp->n_ce_susp_fields++;
susp->ce_susp_fields = realloc(susp->ce_susp_fields,
sizeof(void*) * susp->n_ce_susp_fields);
susp->ce_susp_fields = realloc(susp->ce_susp_fields, sizeof(void*)
* susp->n_ce_susp_fields);
if (susp->ce_susp_fields == NULL) {
return ISO_MEM_ERROR;
}
@ -101,7 +101,7 @@ int rrip_add_PX(Ecma119Image *t, Ecma119Node *n, struct susp_info *susp)
iso_bb(&PX[20], px_get_uid(t, n), 4);
iso_bb(&PX[28], px_get_gid(t, n), 4);
iso_bb(&PX[36], n->ino, 4);
return susp_append(t, susp, PX);
}
@ -142,12 +142,12 @@ static
int rrip_add_PL(Ecma119Image *t, Ecma119Node *n, struct susp_info *susp)
{
uint8_t *PL;
if (n->type != ECMA119_DIR || n->info.dir.real_parent == NULL) {
/* should never occur */
return ISO_ERROR;
}
PL = malloc(12);
if (PL == NULL) {
return ISO_MEM_ERROR;
@ -157,7 +157,7 @@ int rrip_add_PL(Ecma119Image *t, Ecma119Node *n, struct susp_info *susp)
PL[1] = 'L';
PL[2] = 12;
PL[3] = 1;
/* write the location of the real parent, already computed */
iso_bb(&PL[4], n->info.dir.real_parent->info.dir.block, 4);
return susp_append(t, susp, PL);
@ -199,13 +199,13 @@ int rrip_add_PN(Ecma119Image *t, Ecma119Node *n, struct susp_info *susp)
{
IsoSpecial *node;
uint8_t *PN;
node = (IsoSpecial*)n->node;
if (node->node.type != LIBISO_SPECIAL) {
/* should never occur */
return ISO_ERROR;
}
PN = malloc(20);
if (PN == NULL) {
return ISO_MEM_ERROR;
@ -252,22 +252,22 @@ char *get_rr_name(Ecma119Image *t, Ecma119Node *n)
{
int ret;
char *name;
if (!strcmp(t->input_charset, t->output_charset)) {
/* no conversion needed */
return strdup(n->node->name);
}
ret = strconv(n->node->name, t->input_charset, t->output_charset, &name);
if (ret < 0) {
iso_msg_sorry(t->image, LIBISO_CHARSET_ERROR,
"Charset conversion error. Can't convert %s from %s to %s",
n->node->name, t->input_charset, t->output_charset);
iso_msg_sorry(t->image, LIBISO_CHARSET_ERROR,
"Charset conversion error. Can't convert %s from %s to %s",
n->node->name, t->input_charset, t->output_charset);
/* use the original name, it's the best we can do */
name = strdup(n->node->name);
}
return name;
}
@ -285,8 +285,8 @@ char *get_rr_name(Ecma119Image *t, Ecma119Node *n)
* Whether to add or not to CE
*/
static
int rrip_add_NM(Ecma119Image *t, struct susp_info *susp,
char *name, int size, int flags, int ce)
int rrip_add_NM(Ecma119Image *t, struct susp_info *susp, char *name, int size,
int flags, int ce)
{
uint8_t *NM = malloc(size + 5);
if (NM == NULL) {
@ -324,9 +324,8 @@ int rrip_add_NM(Ecma119Image *t, struct susp_info *susp,
* @return
* 1 on success, < 0 on error
*/
static
int rrip_SL_append_comp(size_t *n, uint8_t ***comps,
char *s, int size, char fl)
static
int rrip_SL_append_comp(size_t *n, uint8_t ***comps, char *s, int size, char fl)
{
uint8_t *comp = malloc(size + 2);
if (comp == NULL) {
@ -363,8 +362,8 @@ int rrip_SL_append_comp(size_t *n, uint8_t ***comps,
* Whether to add to a continuation area or system use field.
*/
static
int rrip_add_SL(Ecma119Image *t, struct susp_info *susp,
uint8_t **comp, size_t n, int ce)
int rrip_add_SL(Ecma119Image *t, struct susp_info *susp, uint8_t **comp,
size_t n, int ce)
{
int ret, i, j;
@ -374,7 +373,7 @@ int rrip_add_SL(Ecma119Image *t, struct susp_info *susp,
uint8_t *SL;
for (i = 0; i < n; i++) {
total_comp_len += comp[i][1] + 2;
if (total_comp_len > 250) {
/* we need a new SL entry */
@ -383,18 +382,18 @@ int rrip_add_SL(Ecma119Image *t, struct susp_info *susp,
if (SL == NULL) {
return ISO_MEM_ERROR;
}
SL[0] = 'S';
SL[1] = 'L';
SL[2] = total_comp_len + 5;
SL[3] = 1;
SL[4] = 1; /* CONTINUE */
SL[4] = 1; /* CONTINUE */
pos = 5;
for (j = written; j < i; j++) {
memcpy(&SL[pos], comp[j], comp[j][1] + 2);
pos += comp[j][1] + 2;
}
/*
* In this case we are sure we're writting to CE. Check for
* debug purposes
@ -410,12 +409,12 @@ int rrip_add_SL(Ecma119Image *t, struct susp_info *susp,
total_comp_len = comp[i][1] + 2;
}
}
SL = malloc(total_comp_len + 5);
if (SL == NULL) {
return ISO_MEM_ERROR;
}
SL[0] = 'S';
SL[1] = 'L';
SL[2] = total_comp_len + 5;
@ -462,10 +461,10 @@ int rrip_add_ER(Ecma119Image *t, struct susp_info *susp)
ER[7] = 1;
memcpy(&ER[8], "IEEE_1282", 9);
memcpy(&ER[17], "THE IEEE 1282 PROTOCOL PROVIDES SUPPORT FOR POSIX "
"FILE SYSTEM SEMANTICS.", 72);
"FILE SYSTEM SEMANTICS.", 72);
memcpy(&ER[89], "PLEASE CONTACT THE IEEE STANDARDS DEPARTMENT, "
"PISCATAWAY, NJ, USA FOR THE 1282 SPECIFICATION.", 93);
"PISCATAWAY, NJ, USA FOR THE 1282 SPECIFICATION.", 93);
/** This always goes to continuation area */
return susp_append_ce(t, susp, ER);
}
@ -490,7 +489,7 @@ int susp_add_CE(Ecma119Image *t, size_t ce_len, struct susp_info *susp)
iso_bb(&CE[4], susp->ce_block, 4);
iso_bb(&CE[12], susp->ce_len, 4);
iso_bb(&CE[20], ce_len, 4);
return susp_append(t, susp, CE);
}
@ -531,11 +530,11 @@ int susp_add_SP(Ecma119Image *t, struct susp_info *susp)
* @return
* The size needed for the RR entries in the System Use Area
*/
size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
size_t space, size_t *ce)
size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t space,
size_t *ce)
{
size_t su_size;
/* space min is 255 - 33 - 37 = 185
* At the same time, it is always an odd number, but we need to pad it
* propertly to ensure the length of a directory record is a even number
@ -543,10 +542,10 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
*/
space--;
*ce = 0;
/* PX and TF, we are sure they always fit in SUA */
su_size = 44 + 26;
if (n->type == ECMA119_DIR) {
if (n->info.dir.real_parent != NULL) {
/* it is a reallocated entry */
@ -562,17 +561,17 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
if (S_ISBLK(n->node->mode) || S_ISCHR(n->node->mode)) {
/* block or char device, we need a PN entry */
su_size += 20;
}
}
} else if (n->type == ECMA119_PLACEHOLDER) {
/* we need the CL entry */
su_size += 12;
}
if (type == 0) {
char *name = get_rr_name(t, n);
size_t namelen = strlen(name);
free(name);
/* NM entry */
if (su_size + 5 + namelen <= space) {
/* ok, it fits in System Use Area */
@ -590,7 +589,7 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
char *cur, *prev;
size_t sl_len = 5;
int cew = (*ce != 0); /* are we writing to CE? */
prev = ((IsoSymlink*)n->node)->dest;
cur = strchr(prev, '/');
while (1) {
@ -601,16 +600,16 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
/* last component */
clen = strlen(prev);
}
if (clen == 1 && prev[0] == '.') {
clen = 0;
} else if (clen == 2 && prev[0] == '.' && prev[1] == '.') {
clen = 0;
}
/* flags and len for each component record (RRIP, 4.1.3.1) */
clen += 2;
if (!cew) {
/* we are still writing to the SUA */
if (su_size + sl_len + clen > space) {
@ -631,7 +630,7 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
} else {
sl_len += clen;
}
}
}
if (cew) {
if (sl_len + clen > 255) {
/* we need an additional SL entry */
@ -671,7 +670,7 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
sl_len += clen;
}
}
if (!cur || cur[1] == '\0') {
/* cur[1] can be \0 if dest ends with '/' */
break;
@ -679,7 +678,7 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
prev = cur + 1;
cur = strchr(prev, '/');
}
/* and finally write the pending SL field */
if (!cew) {
/* the whole SL fits into the SUA */
@ -687,10 +686,10 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
} else {
*ce += sl_len;
}
}
} else {
/* "." or ".." entry */
su_size += 5; /* NM field */
if (type == 1 && n->parent == NULL) {
@ -703,7 +702,7 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
*ce = 182; /* ER */
}
}
/*
* The System Use field inside the directory record must be padded if
* it is an odd number (ECMA-119, 9.1.13)
@ -719,12 +718,12 @@ static
void susp_info_free(struct susp_info* susp)
{
size_t i;
for (i = 0; i < susp->n_susp_fields; ++i) {
free(susp->susp_fields[i]);
}
free(susp->susp_fields);
for (i = 0; i < susp->n_ce_susp_fields; ++i) {
free(susp->ce_susp_fields[i]);
}
@ -748,14 +747,14 @@ void susp_info_free(struct susp_info* susp)
* @return
* 1 success, < 0 error
*/
int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
size_t space, struct susp_info *info)
{
int ret;
size_t i;
Ecma119Node *node;
char *name = NULL;
char *name= NULL;
if (t == NULL || n == NULL || info == NULL) {
return ISO_NULL_POINTER;
}
@ -763,20 +762,20 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
/* space min is 255 - 33 - 37 = 185 */
return ISO_WRONG_ARG_VALUE;
}
if (type == 2 && n->parent != NULL) {
node = n->parent;
} else {
node = n;
}
/* space min is 255 - 33 - 37 = 185
* At the same time, it is always an odd number, but we need to pad it
* propertly to ensure the length of a directory record is a even number
* (ECMA-119, 9.1.13). Thus, in fact the real space is always space - 1
*/
space--;
/*
* SP must be the first entry for the "." record of the root directory
* (SUSP, 5.3)
@ -787,7 +786,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
goto add_susp_cleanup;
}
}
/* PX and TF, we are sure they always fit in SUA */
ret = rrip_add_PX(t, node, info);
if (ret < 0) {
@ -797,7 +796,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
if (ret < 0) {
goto add_susp_cleanup;
}
if (n->type == ECMA119_DIR) {
if (n->info.dir.real_parent != NULL) {
/* it is a reallocated entry */
@ -825,7 +824,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
if (ret < 0) {
goto add_susp_cleanup;
}
}
}
} else if (n->type == ECMA119_PLACEHOLDER) {
/* we need the CL entry */
ret = rrip_add_CL(t, node, info);
@ -833,22 +832,22 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
goto add_susp_cleanup;
}
}
if (type == 0) {
size_t sua_free; /* free space in the SUA */
int nm_type = 0; /* 0 whole entry in SUA, 1 part in CE */
size_t ce_len = 0; /* len of the CE */
size_t namelen;
/* this two are only defined for symlinks */
uint8_t **comps = NULL; /* components of the SL field */
uint8_t **comps= NULL; /* components of the SL field */
size_t n_comp = 0; /* number of components */
name = get_rr_name(t, n);
namelen = strlen(name);
sua_free = space - info->suf_len;
/* NM entry */
if (5 + namelen <= sua_free) {
/* ok, it fits in System Use Area */
@ -868,7 +867,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
char *cur, *prev;
size_t sl_len = 5;
int cew = (nm_type == 1); /* are we writing to CE? */
prev = ((IsoSymlink*)n->node)->dest;
cur = strchr(prev, '/');
while (1) {
@ -880,21 +879,22 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
/* last component */
clen = strlen(prev);
}
if (clen == 0) {
/* this refers to the roor directory, '/' */
cflag = 1 << 3;
} if (clen == 1 && prev[0] == '.') {
}
if (clen == 1 && prev[0] == '.') {
clen = 0;
cflag = 1 << 1;
} else if (clen == 2 && prev[0] == '.' && prev[1] == '.') {
clen = 0;
cflag = 1 << 2;
}
/* flags and len for each component record (RRIP, 4.1.3.1) */
clen += 2;
if (!cew) {
/* we are still writing to the SUA */
if (sl_len + clen > sua_free) {
@ -923,7 +923,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
}
sl_len += clen;
}
}
}
if (cew) {
if (sl_len + clen > 255) {
/* we need an addition SL entry */
@ -943,7 +943,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
* the component can be divided between this
* and another SL entry
*/
ret = rrip_SL_append_comp(&n_comp, &comps,
ret = rrip_SL_append_comp(&n_comp, &comps,
prev, fit, 0x01);
if (ret < 0) {
goto add_susp_cleanup;
@ -952,10 +952,8 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
* and another component, that will go in
* other SL entry
*/
ret = rrip_SL_append_comp(&n_comp, &comps,
prev + fit,
clen - fit - 2,
0);
ret = rrip_SL_append_comp(&n_comp, &comps, prev
+ fit, clen - fit - 2, 0);
if (ret < 0) {
goto add_susp_cleanup;
}
@ -967,15 +965,13 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
* any case, so we prefer to don't write
* anything in this SL
*/
ret = rrip_SL_append_comp(&n_comp, &comps,
ret = rrip_SL_append_comp(&n_comp, &comps,
prev, 248, 0x01);
if (ret < 0) {
goto add_susp_cleanup;
}
ret = rrip_SL_append_comp(&n_comp, &comps,
prev + 248,
strlen(prev + 248),
0x00);
ret = rrip_SL_append_comp(&n_comp, &comps, prev
+ 248, strlen(prev + 248), 0x00);
if (ret < 0) {
goto add_susp_cleanup;
}
@ -984,7 +980,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
}
} else {
/* case 2, create a new SL entry */
ret = rrip_SL_append_comp(&n_comp, &comps, prev,
ret = rrip_SL_append_comp(&n_comp, &comps, prev,
clen - 2, cflag);
if (ret < 0) {
goto add_susp_cleanup;
@ -1002,7 +998,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
sl_len += clen;
}
}
if (!cur || cur[1] == '\0') {
/* cur[1] can be \0 if dest ends with '/' */
break;
@ -1010,19 +1006,19 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
prev = cur + 1;
cur = strchr(prev, '/');
}
if (cew) {
ce_len += sl_len;
}
}
/*
* We we reach here:
* - We know if NM fill in the SUA (nm_type == 0)
* - If SL needs an to be written in CE (ce_len > 0)
* - The components for SL entry (or entries)
*/
if (nm_type == 0) {
/* the full NM fills in SUA */
ret = rrip_add_NM(t, info, name, strlen(name), 0, 0);
@ -1040,7 +1036,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
goto add_susp_cleanup;
}
}
if (ce_len > 0) {
/* Add the CE entry */
ret = susp_add_CE(t, ce_len, info);
@ -1061,26 +1057,25 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
}
if (n->type == ECMA119_SYMLINK) {
/* add the SL entry (or entries) */
ret = rrip_add_SL(t, info, comps, n_comp, (ce_len > 0));
/* free the components */
for (i = 0; i < n_comp; i++) {
free(comps[i]);
}
free(comps);
if (ret < 0) {
goto add_susp_cleanup;
}
}
} else {
/* "." or ".." entry */
/* write the NM entry */
ret = rrip_add_NM(t, info, NULL, 0, 1 << type, 0);
if (ret < 0) {
@ -1103,17 +1098,17 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
}
}
}
/*
* The System Use field inside the directory record must be padded if
* it is an odd number (ECMA-119, 9.1.13)
*/
info->suf_len += (info->suf_len % 2);
free(name);
return ISO_SUCCESS;
add_susp_cleanup:;
add_susp_cleanup: ;
free(name);
susp_info_free(info);
return ret;
@ -1126,12 +1121,12 @@ add_susp_cleanup:;
* After written, the info susp_fields array will be freed, and the counters
* updated propertly.
*/
void rrip_write_susp_fields(Ecma119Image *t, struct susp_info *info,
void rrip_write_susp_fields(Ecma119Image *t, struct susp_info *info,
uint8_t *buf)
{
size_t i;
size_t pos = 0;
if (info->n_susp_fields == 0) {
return;
}
@ -1140,7 +1135,7 @@ void rrip_write_susp_fields(Ecma119Image *t, struct susp_info *info,
memcpy(buf + pos, info->susp_fields[i], info->susp_fields[i][2]);
pos += info->susp_fields[i][2];
}
/* free susp_fields */
for (i = 0; i < info->n_susp_fields; ++i) {
free(info->susp_fields[i]);
@ -1160,8 +1155,8 @@ int rrip_write_ce_fields(Ecma119Image *t, struct susp_info *info)
{
size_t i;
uint8_t padding[BLOCK_SIZE];
int ret = ISO_SUCCESS;
int ret= ISO_SUCCESS;
if (info->n_ce_susp_fields == 0) {
return ret;
}
@ -1173,15 +1168,15 @@ int rrip_write_ce_fields(Ecma119Image *t, struct susp_info *info)
goto write_ce_field_cleanup;
}
}
/* pad continuation area until block size */
i = BLOCK_SIZE - (info->ce_len % BLOCK_SIZE);
if (i > 0 && i < BLOCK_SIZE) {
memset(padding, 0, i);
ret = iso_write(t, padding, i);
}
write_ce_field_cleanup:;
write_ce_field_cleanup: ;
/* free ce_susp_fields */
for (i = 0; i < info->n_ce_susp_fields; ++i) {
free(info->ce_susp_fields[i]);

9
src/rockridge.h
View File

@ -28,7 +28,6 @@
#include "ecma119.h"
/**
* This contains the information about the System Use Fields (SUSP, 4.1),
* that will be written in the System Use Areas, both in the ISO directory
@ -66,8 +65,8 @@ struct susp_info
* @return
* The size needed for the RR entries in the System Use Area
*/
size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
size_t space, size_t *ce);
size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t space,
size_t *ce);
/**
* Fill a struct susp_info with the RR/SUSP entries needed for a given
@ -86,7 +85,7 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type,
* @return
* 1 success, < 0 error
*/
int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
size_t space, struct susp_info *info);
/**
@ -96,7 +95,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
* After written, the info susp_fields array will be freed, and the counters
* updated propertly.
*/
void rrip_write_susp_fields(Ecma119Image *t, struct susp_info *info,
void rrip_write_susp_fields(Ecma119Image *t, struct susp_info *info,
uint8_t *buf);
/**

28
src/stream.c
View File

@ -50,11 +50,11 @@ off_t fsrc_get_size(IsoStream *stream)
{
FSrcStreamData *data;
data = (FSrcStreamData*)stream->data;
return data->size;
}
static
static
int fsrc_read(IsoStream *stream, void *buf, size_t count)
{
IsoFileSource *src;
@ -65,7 +65,7 @@ int fsrc_read(IsoStream *stream, void *buf, size_t count)
return iso_file_source_read(src, buf, count);
}
static
static
int fsrc_is_repeatable(IsoStream *stream)
{
int ret;
@ -75,11 +75,11 @@ int fsrc_is_repeatable(IsoStream *stream)
return ISO_NULL_POINTER;
}
data = (FSrcStreamData*)stream->data;
/* mode is not cached, this function is only useful for filters */
ret = iso_file_source_stat(data->src, &info);
if (ret < 0) {
return ret;
return ret;
}
if (S_ISREG(info.st_mode) || S_ISBLK(info.st_mode)) {
return 1;
@ -89,24 +89,24 @@ int fsrc_is_repeatable(IsoStream *stream)
}
static
int fsrc_get_id(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id,
int fsrc_get_id(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id,
ino_t *ino_id)
{
FSrcStreamData *data;
IsoFilesystem *fs;
if (stream == NULL || fs_id == NULL || dev_id == NULL || ino_id == NULL) {
return ISO_NULL_POINTER;
}
data = (FSrcStreamData*)stream->data;
fs = iso_file_source_get_filesystem(data->src);
*fs_id = fs->get_id(fs);
if (fs_id == 0) {
return 0;
}
*dev_id = data->dev_id;
*ino_id = data->ino_id;
return ISO_SUCCESS;
@ -141,7 +141,7 @@ int iso_file_source_stream_new(IsoFileSource *src, IsoStream **stream)
if (src == NULL || stream == NULL) {
return ISO_NULL_POINTER;
}
r = iso_file_source_stat(src, &info);
if (r < 0) {
return r;
@ -149,7 +149,7 @@ int iso_file_source_stream_new(IsoFileSource *src, IsoStream **stream)
if (S_ISDIR(info.st_mode)) {
return ISO_FILE_IS_DIR;
}
str = malloc(sizeof(IsoStream));
if (str == NULL) {
return ISO_MEM_ERROR;
@ -165,11 +165,11 @@ int iso_file_source_stream_new(IsoFileSource *src, IsoStream **stream)
data->dev_id = info.st_dev;
data->ino_id = info.st_ino;
data->size = info.st_size;
str->refcount = 1;
str->data = data;
str->class = &fsrc_stream_class;
*stream = str;
return ISO_SUCCESS;
}

30
src/stream.h
View File

@ -55,7 +55,7 @@ typedef struct IsoStream_Iface
* number of bytes read, 0 if EOF, < 0 on error
*/
int (*read)(IsoStream *stream, void *buf, size_t count);
/**
* Whether this Stram can be read several times, with the same results.
* For example, a regular file is repeatable, you can read it as many
@ -68,7 +68,7 @@ typedef struct IsoStream_Iface
* 1 if stream is repeatable, 0 if not, < 0 on error
*/
int (*is_repeatable)(IsoStream *stream);
/**
* Get an unique identifier for the IsoStream. If your implementation
* is unable to return a valid identifier, this function should return
@ -77,7 +77,7 @@ typedef struct IsoStream_Iface
* @return
* 1 on success, 0 if idenfier is not valid, < 0 error
*/
int (*get_id)(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id,
int (*get_id)(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id,
ino_t *ino_id);
/**
@ -91,43 +91,49 @@ struct Iso_Stream
{
IsoStreamIface *class;
int refcount;
void *data;
void *data;
};
void iso_stream_ref(IsoStream *stream);
void iso_stream_unref(IsoStream *stream);
extern inline
int iso_stream_open(IsoStream *stream) {
int iso_stream_open(IsoStream *stream)
{
return stream->class->open(stream);
}
extern inline
int iso_stream_close(IsoStream *stream) {
int iso_stream_close(IsoStream *stream)
{
return stream->class->close(stream);
}
extern inline
off_t iso_stream_get_size(IsoStream *stream) {
off_t iso_stream_get_size(IsoStream *stream)
{
return stream->class->get_size(stream);
}
extern inline
int iso_stream_read(IsoStream *stream, void *buf, size_t count) {
int iso_stream_read(IsoStream *stream, void *buf, size_t count)
{
return stream->class->read(stream, buf, count);
}
extern inline
int iso_stream_is_repeatable(IsoStream *stream) {
int iso_stream_is_repeatable(IsoStream *stream)
{
return stream->class->is_repeatable(stream);
}
extern inline
int iso_stream_get_id(IsoStream *stream, unsigned int *fs_id,
dev_t *dev_id, ino_t *ino_id) {
int iso_stream_get_id(IsoStream *stream, unsigned int *fs_id, dev_t *dev_id,
ino_t *ino_id)
{
return stream->class->get_id(stream, fs_id, dev_id, ino_id);
}
/**
* Create a stream to read from a IsoFileSource.
* The stream will take the ref. to the IsoFileSource, so after a successfully

134
src/tree.c
View File

@ -48,14 +48,14 @@ int iso_tree_add_new_dir(IsoDir *parent, const char *name, IsoDir **dir)
IsoDir *node;
IsoNode **pos;
time_t now;
if (parent == NULL || name == NULL) {
return ISO_NULL_POINTER;
}
if (dir) {
*dir = NULL;
}
/* find place where to insert */
pos = &(parent->children);
while (*pos != NULL && strcmp((*pos)->name, name) < 0) {
@ -65,12 +65,12 @@ int iso_tree_add_new_dir(IsoDir *parent, const char *name, IsoDir **dir)
/* a node with same name already exists */
return ISO_NODE_NAME_NOT_UNIQUE;
}
node = calloc(1, sizeof(IsoDir));
if (node == NULL) {
return ISO_MEM_ERROR;
}
node->node.refcount = 1;
node->node.type = LIBISO_DIR;
node->node.name = strdup(name);
@ -78,24 +78,24 @@ int iso_tree_add_new_dir(IsoDir *parent, const char *name, IsoDir **dir)
free(node);
return ISO_MEM_ERROR;
}
/* permissions from parent */
node->node.mode = parent->node.mode;
node->node.uid = parent->node.uid;
node->node.gid = parent->node.gid;
node->node.hidden = parent->node.hidden;
/* current time */
now = time(NULL);
node->node.atime = now;
node->node.ctime = now;
node->node.mtime = now;
/* add to dir */
node->node.parent = parent;
node->node.next = *pos;
*pos = (IsoNode*)node;
if (dir) {
*dir = node;
}
@ -126,20 +126,20 @@ int iso_tree_add_new_dir(IsoDir *parent, const char *name, IsoDir **dir)
* ISO_NODE_NAME_NOT_UNIQUE, a node with same name already exists
* ISO_MEM_ERROR
*/
int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
const char *dest, IsoSymlink **link)
{
IsoSymlink *node;
IsoNode **pos;
time_t now;
if (parent == NULL || name == NULL || dest == NULL) {
return ISO_NULL_POINTER;
}
if (link) {
*link = NULL;
}
/* find place where to insert */
pos = &(parent->children);
while (*pos != NULL && strcmp((*pos)->name, name) < 0) {
@ -149,12 +149,12 @@ int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
/* a node with same name already exists */
return ISO_NODE_NAME_NOT_UNIQUE;
}
node = calloc(1, sizeof(IsoSymlink));
if (node == NULL) {
return ISO_MEM_ERROR;
}
node->node.refcount = 1;
node->node.type = LIBISO_SYMLINK;
node->node.name = strdup(name);
@ -162,31 +162,31 @@ int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
free(node);
return ISO_MEM_ERROR;
}
node->dest = strdup(dest);
if (node->dest == NULL) {
free(node->node.name);
free(node);
return ISO_MEM_ERROR;
}
/* permissions from parent */
node->node.mode = S_IFLNK | 0777;
node->node.uid = parent->node.uid;
node->node.gid = parent->node.gid;
node->node.hidden = parent->node.hidden;
/* current time */
now = time(NULL);
node->node.atime = now;
node->node.ctime = now;
node->node.mtime = now;
/* add to dir */
node->node.parent = parent;
node->node.next = *pos;
*pos = (IsoNode*)node;
if (link) {
*link = node;
}
@ -231,13 +231,13 @@ int iso_tree_add_new_symlink(IsoDir *parent, const char *name,
* ISO_MEM_ERROR
*
*/
int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
dev_t dev, IsoSpecial **special)
{
IsoSpecial *node;
IsoNode **pos;
time_t now;
if (parent == NULL || name == NULL) {
return ISO_NULL_POINTER;
}
@ -247,7 +247,7 @@ int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
if (special) {
*special = NULL;
}
/* find place where to insert */
pos = &(parent->children);
while (*pos != NULL && strcmp((*pos)->name, name) < 0) {
@ -257,12 +257,12 @@ int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
/* a node with same name already exists */
return ISO_NODE_NAME_NOT_UNIQUE;
}
node = calloc(1, sizeof(IsoSpecial));
if (node == NULL) {
return ISO_MEM_ERROR;
}
node->node.refcount = 1;
node->node.type = LIBISO_SPECIAL;
node->node.name = strdup(name);
@ -270,51 +270,51 @@ int iso_tree_add_new_special(IsoDir *parent, const char *name, mode_t mode,
free(node);
return ISO_MEM_ERROR;
}
node->node.mode = mode;
node->dev = dev;
/* atts from parent */
node->node.uid = parent->node.uid;
node->node.gid = parent->node.gid;
node->node.hidden = parent->node.hidden;
/* current time */
now = time(NULL);
node->node.atime = now;
node->node.ctime = now;
node->node.mtime = now;
/* add to dir */
node->node.parent = parent;
node->node.next = *pos;
*pos = (IsoNode*)node;
if (special) {
*special = node;
}
return ++parent->nchildren;
}
static
int iso_tree_add_node_builder(IsoImage *image, IsoDir *parent,
IsoFileSource *src, IsoNodeBuilder *builder,
static
int iso_tree_add_node_builder(IsoImage *image, IsoDir *parent,
IsoFileSource *src, IsoNodeBuilder *builder,
IsoNode **node)
{
int result;
IsoNode *new;
IsoNode **pos;
char *name;
if (parent == NULL || src == NULL || builder == NULL) {
return ISO_NULL_POINTER;
}
if (node) {
*node = NULL;
}
name = iso_file_source_get_name(src);
/* find place where to insert */
pos = &(parent->children);
while (*pos != NULL && strcmp((*pos)->name, name) < 0) {
@ -324,43 +324,43 @@ int iso_tree_add_node_builder(IsoImage *image, IsoDir *parent,
/* a node with same name already exists */
return ISO_NODE_NAME_NOT_UNIQUE;
}
result = builder->create_node(builder, image, src, &new);
if (result < 0) {
return result;
}
/* finally, add node to parent */
new->parent = parent;
new->next = *pos;
*pos = new;
if (node) {
*node = new;
}
return ++parent->nchildren;
}
int iso_tree_add_node(IsoImage *image, IsoDir *parent, const char *path,
int iso_tree_add_node(IsoImage *image, IsoDir *parent, const char *path,
IsoNode **node)
{
int result;
IsoFilesystem *fs;
IsoFileSource *file;
if (image == NULL || parent == NULL || path == NULL) {
return ISO_NULL_POINTER;
}
fs = image->fs;
result = fs->get_by_path(fs, path, &file);
if (result < 0) {
return result;
}
result = iso_tree_add_node_builder(image, parent, file, image->builder,
result = iso_tree_add_node_builder(image, parent, file, image->builder,
node);
/* free the file */
iso_file_source_unref(file);
iso_file_source_unref(file);
return result;
}
@ -381,7 +381,7 @@ int check_excludes(IsoImage *image, const char *path)
return 0;
}
static
static
int check_hidden(IsoImage *image, const char *name)
{
return (image->recOpts->ignore_hidden && name[0] == '.');
@ -399,25 +399,25 @@ int iso_add_dir_aux(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
IsoNodeBuilder *builder;
IsoFileSource *file;
IsoNode **pos;
result = iso_file_source_open(dir);
if (result < 0) {
iso_msg_debug(image, "Can't open dir %s",
iso_file_source_get_path(dir));
return result;
}
builder = image->builder;
action = 1;
while ( (result = iso_file_source_readdir(dir, &file)) == 1) {
int flag;
char *name;
IsoNode *new;
iso_msg_debug(image, "Adding file %s", iso_file_source_get_path(file));
name = iso_file_source_get_name(file);
if (check_excludes(image, iso_file_source_get_path(file))) {
action = 2;
} else if (check_hidden(image, name)) {
@ -425,7 +425,7 @@ int iso_add_dir_aux(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
} else {
action = 1;
}
/* find place where to insert */
flag = 0;
pos = &(parent->children);
@ -438,12 +438,12 @@ int iso_add_dir_aux(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
action = 2;
}
}
/* ask user if callback has been set */
if (image->recOpts->report) {
action = image->recOpts->report(file, action, flag);
}
if (action == 2) {
/* skip file */
iso_file_source_unref(file);
@ -453,23 +453,23 @@ int iso_add_dir_aux(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
iso_file_source_unref(file);
break;
}
/* ok, file will be added */
result = builder->create_node(builder, image, file, &new);
if (result < 0) {
iso_msg_debug(image, "Error %d when adding file %s",
result, iso_file_source_get_path(file));
iso_msg_debug(image, "Error %d when adding file %s", result,
iso_file_source_get_path(file));
if (image->recOpts->report) {
action = image->recOpts->report(file, result, flag);
} else {
action = image->recOpts->stop_on_error ? 3 : 1;
}
/* free file */
iso_file_source_unref(file);
if (action == 3) {
result = 1; /* prevent error to be passing up */
break;
@ -478,7 +478,7 @@ int iso_add_dir_aux(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
continue;
}
}
/* ok, node has correctly created, we need to add it */
if (flag) {
/* replace node */
@ -495,7 +495,7 @@ int iso_add_dir_aux(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
new->parent = parent;
++parent->nchildren;
}
/* finally, if the node is a directory we need to recurse */
if (new->type == LIBISO_DIR) {
result = iso_add_dir_aux(image, (IsoDir*)new, file);
@ -516,12 +516,12 @@ int iso_add_dir_aux(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
iso_file_source_unref(file);
}
}
if (result < 0) {
// TODO printf message
action = result;
}
result = iso_file_source_close(dir);
if (result < 0) {
return result;
@ -541,24 +541,24 @@ int iso_tree_add_dir_rec(IsoImage *image, IsoDir *parent, const char *dir)
struct stat info;
IsoFilesystem *fs;
IsoFileSource *file;
if (image == NULL || parent == NULL || dir == NULL) {
return ISO_NULL_POINTER;
}
fs = image->fs;
result = fs->get_by_path(fs, dir, &file);
if (result < 0) {
return result;
}
/* we also allow dir path to be a symlink to a dir */
result = iso_file_source_stat(file, &info);
if (result < 0) {
iso_file_source_unref(file);
return result;
}
if (!S_ISDIR(info.st_mode)) {
iso_file_source_unref(file);
return ISO_FILE_IS_NOT_DIR;
@ -591,7 +591,7 @@ int iso_tree_path_to_node(IsoImage *image, const char *path, IsoNode **node)
ptr = strdup(path);
result = 0;
/* get the first component of the path */
component = strtok_r(ptr, "/", &brk_info);
while (component) {

189
src/util.c
View File

@ -28,7 +28,6 @@ int int_pow(int base, int power)
return result;
}
int strconv(const char *str, const char *icharset, const char *ocharset,
char **output)
{
@ -74,8 +73,8 @@ int strconv(const char *str, const char *icharset, const char *ocharset,
* @return
* 1 success, < 0 error
*/
static
int str2wchar(const char *icharset, const char *input, wchar_t **output)
static
int str2wchar(const char *icharset, const char *input, wchar_t **output)
{
iconv_t conv;
size_t inbytes;
@ -84,7 +83,7 @@ int str2wchar(const char *icharset, const char *input, wchar_t **output)
char *src;
wchar_t *wstr;
size_t n;
if (icharset == NULL || input == NULL || output == NULL) {
return ISO_NULL_POINTER;
}
@ -93,7 +92,7 @@ int str2wchar(const char *icharset, const char *input, wchar_t **output)
if (conv == (iconv_t)-1) {
return ISO_CHARSET_CONV_ERROR;
}
inbytes = strlen(input);
outbytes = (inbytes + 1) * sizeof(wchar_t);
@ -107,7 +106,7 @@ int str2wchar(const char *icharset, const char *input, wchar_t **output)
n = iconv(conv, &src, &inbytes, &ret, &outbytes);
while (n == -1) {
if (errno == E2BIG) {
/* error, should never occur */
iconv_close(conv);
@ -115,7 +114,7 @@ int str2wchar(const char *icharset, const char *input, wchar_t **output)
return ISO_CHARSET_CONV_ERROR;
} else {
wchar_t *wret;
/*
* Invalid input string charset.
* This can happen if input is in fact encoded in a charset
@ -126,7 +125,7 @@ int str2wchar(const char *icharset, const char *input, wchar_t **output)
/* printf("String %s is not encoded in %s\n", str, codeset); */
inbytes--;
src++;
wret = (wchar_t*) ret;
*wret++ = (wchar_t) '_';
ret = (char *) wret;
@ -138,7 +137,7 @@ int str2wchar(const char *icharset, const char *input, wchar_t **output)
}
}
iconv_close(conv);
*( (wchar_t *)ret )='\0';
*output = wstr;
return ISO_SUCCESS;
@ -156,7 +155,7 @@ int str2ascii(const char *icharset, const char *input, char **output)
size_t outbytes;
size_t inbytes;
size_t n;
if (icharset == NULL || input == NULL || output == NULL) {
return ISO_NULL_POINTER;
}
@ -171,7 +170,7 @@ int str2ascii(const char *icharset, const char *input, char **output)
}
src = (char *)wsrc_;
numchars = wcslen(wsrc_);
inbytes = numchars * sizeof(wchar_t);
ret_ = malloc(numchars + 1);
@ -190,7 +189,7 @@ int str2ascii(const char *icharset, const char *input, char **output)
}
n = iconv(conv, &src, &inbytes, &ret, &outbytes);
while(n == -1) {
while (n == -1) {
/* The destination buffer is too small. Stops here. */
if (errno == E2BIG)
break;
@ -226,7 +225,7 @@ int str2ascii(const char *icharset, const char *input, char **output)
*ret='\0';
free(wsrc_);
*output = ret_;
return ISO_SUCCESS;
}
@ -238,25 +237,25 @@ static int valid_d_char(char c)
static int valid_a_char(char c)
{
return (c >= ' ' && c <= '"') || (c >= '%' && c <= '?')
|| (c >= 'A' && c <= 'Z') || (c == '_');
return (c >= ' ' && c <= '"') || (c >= '%' && c <= '?') ||
(c >= 'A' && c <= 'Z') || (c == '_');
}
static
static
char *iso_dirid(const char *src, int size)
{
size_t len, i;
char name[32];
len = strlen(src);
if (len > size) {
len = size;
}
for (i = 0; i < len; i++) {
char c = toupper(src[i]);
char c= toupper(src[i]);
name[i] = valid_d_char(c) ? c : '_';
}
name[len] = '\0';
return strdup(name);
}
@ -274,7 +273,7 @@ char *iso_2_dirid(const char *src)
char *iso_1_fileid(const char *src)
{
char *dot; /* Position of the last dot in the filename, will be used
to calculate lname and lext. */
* to calculate lname and lext. */
int lname, lext, pos, i;
char dest[13]; /* 13 = 8 (name) + 1 (.) + 3 (ext) + 1 (\0) */
@ -292,24 +291,24 @@ char *iso_1_fileid(const char *src)
}
pos = 0;
/* Convert up to 8 characters of the filename. */
for (i = 0; i < lname && i < 8; i++) {
char c = toupper(src[i]);
char c= toupper(src[i]);
dest[pos++] = valid_d_char(c) ? c : '_';
}
/* This dot is mandatory, even if there is no extension. */
dest[pos++] = '.';
/* Convert up to 3 characters of the extension, if any. */
for (i = 0; i < lext && i < 3; i++) {
char c = toupper(src[lname + 1 + i]);
char c= toupper(src[lname + 1 + i]);
dest[pos++] = valid_d_char(c) ? c : '_';
}
dest[pos] = '\0';
return strdup(dest);
}
@ -339,8 +338,8 @@ char *iso_2_fileid(const char *src)
} else {
lext = strlen(dot + 1);
lname = strlen(src) - lext - 1;
lnext = (strlen(src) > 31 && lext > 3)
? (lname < 27 ? 30 - lname : 3) : lext;
lnext = (strlen(src) > 31 && lext > 3) ? (lname < 27 ? 30 - lname : 3)
: lext;
lnname = (strlen(src) > 31) ? 30 - lnext : lname;
}
@ -349,18 +348,18 @@ char *iso_2_fileid(const char *src)
}
pos = 0;
/* Convert up to lnname characters of the filename. */
for (i = 0; i < lnname; i++) {
char c = toupper(src[i]);
char c= toupper(src[i]);
dest[pos++] = valid_d_char(c) ? c : '_';
}
dest[pos++] = '.';
/* Convert up to lnext characters of the extension, if any. */
for (i = 0; i < lnext; i++) {
char c = toupper(src[lname + 1 + i]);
char c= toupper(src[lname + 1 + i]);
dest[pos++] = valid_d_char(c) ? c : '_';
}
@ -368,166 +367,70 @@ char *iso_2_fileid(const char *src)
return strdup(dest);
}
//void iso_dirid(char *src, int maxlen)
//{
// size_t len, i;
//
// len = strlen(src);
// if (len > maxlen) {
// src[maxlen] = '\0';
// len = maxlen;
// }
// for (i = 0; i < len; i++) {
// char c = toupper(src[i]);
// src[i] = valid_d_char(c) ? c : '_';
// }
//}
//void iso_1_fileid(char *src)
//{
// char *dot; /* Position of the last dot in the filename, will be used to
// calculate lname and lext. */
// int lname, lext, pos, i;
//
// dot = strrchr(src, '.');
//
// lext = dot ? strlen(dot + 1) : 0;
// lname = strlen(src) - lext - (dot ? 1 : 0);
//
// /* If we can't build a filename, return. */
// if (lname == 0 && lext == 0) {
// return;
// }
//
// pos = 0;
// /* Convert up to 8 characters of the filename. */
// for (i = 0; i < lname && i < 8; i++) {
// char c = toupper(src[i]);
// src[pos++] = valid_d_char(c) ? c : '_';
// }
//
// /* This dot is mandatory, even if there is no extension. */
// src[pos++] = '.';
//
// /* Convert up to 3 characters of the extension, if any. */
// for (i = 0; i < lext && i < 3; i++) {
// char c = toupper(src[lname + 1 + i]);
// src[pos++] = valid_d_char(c) ? c : '_';
// }
// src[pos] = '\0';
//}
//
//void iso_2_fileid(char *src)
//{
// char *dot;
// int lname, lext, lnname, lnext, pos, i;
//
// if (!src)
// return;
//
// dot = strrchr(src, '.');
//
// /*
// * Since the maximum length can be divided freely over the name and
// * extension, we need to calculate their new lengths (lnname and
// * lnext). If the original filename is too long, we start by trimming
// * the extension, but keep a minimum extension length of 3.
// */
// if (dot == NULL || *(dot + 1) == '\0') {
// lname = strlen(src);
// lnname = (lname > 30) ? 30 : lname;
// lext = lnext = 0;
// } else {
// lext = strlen(dot + 1);
// lname = strlen(src) - lext - 1;
// lnext = (strlen(src) > 31 && lext > 3)
// ? (lname < 27 ? 30 - lname : 3) : lext;
// lnname = (strlen(src) > 31) ? 30 - lnext : lname;
// }
//
// if (lnname == 0 && lnext == 0) {
// return;
// }
//
// pos = 0;
// /* Convert up to lnname characters of the filename. */
// for (i = 0; i < lnname; i++) {
// char c = toupper(src[i]);
// src[pos++] = valid_d_char(c) ? c : '_';
// }
// src[pos++] = '.';
// /* Convert up to lnext characters of the extension, if any. */
// for (i = 0; i < lnext; i++) {
// char c = toupper(src[lname + 1 + i]);
// src[pos++] = valid_d_char(c) ? c : '_';
// }
// src[pos] = '\0';
//}
int str2d_char(const char *icharset, const char *input, char **output)
{
int ret;
char *ascii;
size_t len, i;
if (output == NULL) {
return ISO_MEM_ERROR;
}
/** allow NULL input */
if (input == NULL) {
*output = NULL;
return 0;
}
/* this checks for NULL parameters */
ret = str2ascii(icharset, input, &ascii);
if (ret < 0) {
*output = NULL;
return ret;
}
len = strlen(ascii);
for (i = 0; i < len; ++i) {
char c = toupper(ascii[i]);
char c= toupper(ascii[i]);
ascii[i] = valid_d_char(c) ? c : '_';
}
*output = ascii;
return ISO_SUCCESS;
}
int str2a_char(const char *icharset, const char *input, char **output)
{
int ret;
char *ascii;
size_t len, i;
if (output == NULL) {
return ISO_MEM_ERROR;
}
/** allow NULL input */
if (input == NULL) {
*output = NULL;
return 0;
}
/* this checks for NULL parameters */
ret = str2ascii(icharset, input, &ascii);
if (ret < 0) {
*output = NULL;
return ret;
}
len = strlen(ascii);
for (i = 0; i < len; ++i) {
char c = toupper(ascii[i]);
char c= toupper(ascii[i]);
ascii[i] = valid_a_char(c) ? c : '_';
}
*output = ascii;
return ISO_SUCCESS;
}

42
src/util_rbtree.c
View File

@ -16,13 +16,15 @@
* implementation of Julienne Walker.
*/
struct iso_rbnode {
struct iso_rbnode
{
void *data;
struct iso_rbnode *ch[2];
unsigned int red:1;
unsigned int red :1;
};
struct iso_rbtree {
struct iso_rbtree
{
struct iso_rbnode *root;
size_t size;
int (*compare)(const void *a, const void *b);
@ -40,8 +42,7 @@ struct iso_rbtree {
* @param tree
* Location where the tree structure will be stored.
*/
int
iso_rbtree_new(int (*compare)(const void*, const void*), IsoRBTree **tree)
int iso_rbtree_new(int (*compare)(const void*, const void*), IsoRBTree **tree)
{
if (compare == NULL || tree == NULL) {
return ISO_NULL_POINTER;
@ -75,8 +76,7 @@ void rbtree_destroy_aux(struct iso_rbnode *root, void (*free_data)(void *))
* should provide a valid free_data function. It will be called for each
* element of the tree, so you can use it to free any related data.
*/
void
iso_rbtree_destroy(IsoRBTree *tree, void (*free_data)(void *))
void iso_rbtree_destroy(IsoRBTree *tree, void (*free_data)(void *))
{
if (tree == NULL) {
return;
@ -115,14 +115,14 @@ static
struct iso_rbnode *iso_rbnode_new(void *data)
{
struct iso_rbnode *rn = malloc(sizeof(struct iso_rbnode));
if ( rn != NULL ) {
if (rn != NULL) {
rn->data = data;
rn->red = 1;
rn->ch[0] = NULL;
rn->ch[1] = NULL;
}
return rn;
}
@ -154,23 +154,23 @@ int iso_rbtree_insert(IsoRBTree *tree, void *data, void **item)
/* Empty tree case */
tree->root = iso_rbnode_new(data);
if (tree->root == NULL) {
return ISO_MEM_ERROR;
return ISO_MEM_ERROR;
}
new = data;
added = 1;
} else {
struct iso_rbnode head = {0}; /* False tree root */
struct iso_rbnode head = { 0 }; /* False tree root */
struct iso_rbnode *g, *t; /* Grandparent & parent */
struct iso_rbnode *p, *q; /* Iterator & parent */
struct iso_rbnode *g, *t; /* Grandparent & parent */
struct iso_rbnode *p, *q; /* Iterator & parent */
int dir = 0, last = 0;
int comp;
/* Set up helpers */
t = &head;
g = p = NULL;
q = t->ch[1] = tree->root;
/* Search down the tree */
while (1) {
if (q == NULL) {
@ -186,7 +186,7 @@ int iso_rbtree_insert(IsoRBTree *tree, void *data, void **item)
q->ch[0]->red = 0;
q->ch[1]->red = 0;
}
/* Fix red violation */
if (is_red(q) && is_red(p)) {
int dir2 = (t->ch[1] == g);
@ -208,7 +208,7 @@ int iso_rbtree_insert(IsoRBTree *tree, void *data, void **item)
last = dir;
dir = (comp < 0);
/* Update helpers */
if (g != NULL)
t = g;
@ -219,7 +219,7 @@ int iso_rbtree_insert(IsoRBTree *tree, void *data, void **item)
/* Update root */
tree->root = head.ch[1];
}
/* Make root black */
tree->root->red = 0;
@ -243,7 +243,6 @@ size_t iso_rbtree_get_size(IsoRBTree *tree)
return tree->size;
}
static
int rbtree_to_array_aux(struct iso_rbnode *root, void **array, size_t pos)
{
@ -265,8 +264,7 @@ int rbtree_to_array_aux(struct iso_rbnode *root, void **array, size_t pos)
* no more needed. Note that the array is NULL-terminated, and thus it
* has size + 1 length.
*/
void **
iso_rbtree_to_array(IsoRBTree *tree)
void ** iso_rbtree_to_array(IsoRBTree *tree)
{
void **array;

11
src/writer.h
View File

@ -16,20 +16,19 @@ struct Iso_Image_Writer
*
*/
int (*compute_data_blocks)(IsoImageWriter *writer);
int (*write_vol_desc)(IsoImageWriter *writer);
int (*write_data)(IsoImageWriter *writer);
int (*free_data)(IsoImageWriter *writer);
void *data;
Ecma119Image *target;
};
/**
* This is the function all Writers shoudl call to write data to
* image.
* This is the function all Writers shoudl call to write data to image.
* Currently, it is just a wrapper for write(2) Unix system call.
*
* It is implemented in ecma119.c