svn_error_t *
svn_fs_fs__read_noderev(node_revision_t **noderev_p,
svn_stream_t *stream,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_hash_t *headers;
node_revision_t *noderev;
char *value;
const char *noderev_id;
SVN_ERR(read_header_block(&headers, stream, scratch_pool));
noderev = apr_pcalloc(result_pool, sizeof(*noderev));
/* Read the node-rev id. */
value = svn_hash_gets(headers, HEADER_ID);
if (value == NULL)
/* ### More information: filename/offset coordinates */
return svn_error_create(SVN_ERR_FS_CORRUPT, NULL,
_("Missing id field in node-rev"));
SVN_ERR(svn_stream_close(stream));
SVN_ERR(svn_fs_fs__id_parse(&noderev->id, value, result_pool));
noderev_id = value; /* for error messages later */
/* Read the type. */
value = svn_hash_gets(headers, HEADER_TYPE);
if ((value == NULL) ||
( strcmp(value, SVN_FS_FS__KIND_FILE)
&& strcmp(value, SVN_FS_FS__KIND_DIR)))
/* ### s/kind/type/ */
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Missing kind field in node-rev '%s'"),
noderev_id);
noderev->kind = (strcmp(value, SVN_FS_FS__KIND_FILE) == 0)
? svn_node_file
: svn_node_dir;
/* Read the 'count' field. */
value = svn_hash_gets(headers, HEADER_COUNT);
if (value)
SVN_ERR(svn_cstring_atoi(&noderev->predecessor_count, value));
else
noderev->predecessor_count = 0;
/* Get the properties location. */
value = svn_hash_gets(headers, HEADER_PROPS);
if (value)
{
SVN_ERR(read_rep_offsets(&noderev->prop_rep, value,
noderev->id, result_pool, scratch_pool));
}
/* Get the data location. */
value = svn_hash_gets(headers, HEADER_TEXT);
if (value)
{
SVN_ERR(read_rep_offsets(&noderev->data_rep, value,
noderev->id, result_pool, scratch_pool));
}
/* Get the created path. */
value = svn_hash_gets(headers, HEADER_CPATH);
if (value == NULL)
{
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Missing cpath field in node-rev '%s'"),
noderev_id);
}
else
{
if (!svn_fspath__is_canonical(value))
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Non-canonical cpath field in node-rev '%s'"),
noderev_id);
noderev->created_path = apr_pstrdup(result_pool, value);
}
/* Get the predecessor ID. */
value = svn_hash_gets(headers, HEADER_PRED);
if (value)
SVN_ERR(svn_fs_fs__id_parse(&noderev->predecessor_id, value,
result_pool));
/* Get the copyroot. */
value = svn_hash_gets(headers, HEADER_COPYROOT);
if (value == NULL)
{
noderev->copyroot_path = apr_pstrdup(result_pool, noderev->created_path);
noderev->copyroot_rev = svn_fs_fs__id_rev(noderev->id);
}
else
{
SVN_ERR(parse_revnum(&noderev->copyroot_rev, (const char **)&value));
if (!svn_fspath__is_canonical(value))
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Malformed copyroot line in node-rev '%s'"),
noderev_id);
noderev->copyroot_path = apr_pstrdup(result_pool, value);
}
/* Get the copyfrom. */
value = svn_hash_gets(headers, HEADER_COPYFROM);
if (value == NULL)
{
noderev->copyfrom_path = NULL;
noderev->copyfrom_rev = SVN_INVALID_REVNUM;
}
else
{
SVN_ERR(parse_revnum(&noderev->copyfrom_rev, (const char **)&value));
if (*value == 0)
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Malformed copyfrom line in node-rev '%s'"),
noderev_id);
noderev->copyfrom_path = apr_pstrdup(result_pool, value);
}
/* Get whether this is a fresh txn root. */
value = svn_hash_gets(headers, HEADER_FRESHTXNRT);
noderev->is_fresh_txn_root = (value != NULL);
/* Get the mergeinfo count. */
value = svn_hash_gets(headers, HEADER_MINFO_CNT);
if (value)
SVN_ERR(svn_cstring_atoi64(&noderev->mergeinfo_count, value));
else
noderev->mergeinfo_count = 0;
/* Get whether *this* node has mergeinfo. */
value = svn_hash_gets(headers, HEADER_MINFO_HERE);
noderev->has_mergeinfo = (value != NULL);
*noderev_p = noderev;
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_parse_dumpstream3(svn_stream_t *stream,
const svn_repos_parse_fns3_t *parse_fns,
void *parse_baton,
svn_boolean_t deltas_are_text,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
svn_boolean_t eof;
svn_stringbuf_t *linebuf;
void *rev_baton = NULL;
char *buffer = apr_palloc(pool, SVN__STREAM_CHUNK_SIZE);
apr_size_t buflen = SVN__STREAM_CHUNK_SIZE;
apr_pool_t *linepool = svn_pool_create(pool);
apr_pool_t *revpool = svn_pool_create(pool);
apr_pool_t *nodepool = svn_pool_create(pool);
int version;
SVN_ERR(svn_stream_readline(stream, &linebuf, "\n", &eof, linepool));
if (eof)
return stream_ran_dry();
/* The first two lines of the stream are the dumpfile-format version
number, and a blank line. To preserve backward compatibility,
don't assume the existence of newer parser-vtable functions. */
SVN_ERR(parse_format_version(&version, linebuf->data));
if (parse_fns->magic_header_record != NULL)
SVN_ERR(parse_fns->magic_header_record(version, parse_baton, pool));
/* A dumpfile "record" is defined to be a header-block of
rfc822-style headers, possibly followed by a content-block.
- A header-block is always terminated by a single blank line (\n\n)
- We know whether the record has a content-block by looking for
a 'Content-length:' header. The content-block will always be
of a specific length, plus an extra newline.
Once a record is fully sucked from the stream, an indeterminate
number of blank lines (or lines that begin with whitespace) may
follow before the next record (or the end of the stream.)
*/
while (1)
{
apr_hash_t *headers;
void *node_baton;
svn_boolean_t found_node = FALSE;
svn_boolean_t old_v1_with_cl = FALSE;
const char *content_length;
const char *prop_cl;
const char *text_cl;
const char *value;
svn_filesize_t actual_prop_length;
/* Clear our per-line pool. */
svn_pool_clear(linepool);
/* Check for cancellation. */
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Keep reading blank lines until we discover a new record, or until
the stream runs out. */
SVN_ERR(svn_stream_readline(stream, &linebuf, "\n", &eof, linepool));
if (eof)
{
if (svn_stringbuf_isempty(linebuf))
break; /* end of stream, go home. */
else
return stream_ran_dry();
}
if ((linebuf->len == 0) || (svn_ctype_isspace(linebuf->data[0])))
continue; /* empty line ... loop */
/*** Found the beginning of a new record. ***/
/* The last line we read better be a header of some sort.
Read the whole header-block into a hash. */
SVN_ERR(read_header_block(stream, linebuf, &headers, linepool));
/*** Handle the various header blocks. ***/
/* Is this a revision record? */
if (svn_hash_gets(headers, SVN_REPOS_DUMPFILE_REVISION_NUMBER))
{
/* If we already have a rev_baton open, we need to close it
and clear the per-revision subpool. */
if (rev_baton != NULL)
{
SVN_ERR(parse_fns->close_revision(rev_baton));
svn_pool_clear(revpool);
}
SVN_ERR(parse_fns->new_revision_record(&rev_baton,
headers, parse_baton,
revpool));
}
/* Or is this, perhaps, a node record? */
else if (svn_hash_gets(headers, SVN_REPOS_DUMPFILE_NODE_PATH))
{
SVN_ERR(parse_fns->new_node_record(&node_baton,
headers,
rev_baton,
nodepool));
found_node = TRUE;
}
/* Or is this the repos UUID? */
else if ((value = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_UUID)))
{
SVN_ERR(parse_fns->uuid_record(value, parse_baton, pool));
}
/* Or perhaps a dumpfile format? */
/* ### TODO: use parse_format_version */
else if ((value = svn_hash_gets(headers,
SVN_REPOS_DUMPFILE_MAGIC_HEADER)))
{
/* ### someday, switch modes of operation here. */
SVN_ERR(svn_cstring_atoi(&version, value));
}
/* Or is this bogosity?! */
else
{
/* What the heck is this record?!? */
return svn_error_create(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
_("Unrecognized record type in stream"));
}
/* Need 3 values below to determine v1 dump type
Old (pre 0.14?) v1 dumps don't have Prop-content-length
and Text-content-length fields, but always have a properties
block in a block with Content-Length > 0 */
content_length = svn_hash_gets(headers,
SVN_REPOS_DUMPFILE_CONTENT_LENGTH);
prop_cl = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH);
text_cl = svn_hash_gets(headers, SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH);
old_v1_with_cl =
version == 1 && content_length && ! prop_cl && ! text_cl;
/* Is there a props content-block to parse? */
if (prop_cl || old_v1_with_cl)
{
const char *delta = svn_hash_gets(headers,
SVN_REPOS_DUMPFILE_PROP_DELTA);
svn_boolean_t is_delta = (delta && strcmp(delta, "true") == 0);
/* First, remove all node properties, unless this is a delta
property block. */
if (found_node && !is_delta)
SVN_ERR(parse_fns->remove_node_props(node_baton));
SVN_ERR(parse_property_block
(stream,
svn__atoui64(prop_cl ? prop_cl : content_length),
parse_fns,
found_node ? node_baton : rev_baton,
parse_baton,
found_node,
&actual_prop_length,
found_node ? nodepool : revpool));
}
/* Is there a text content-block to parse? */
if (text_cl)
{
const char *delta = svn_hash_gets(headers,
SVN_REPOS_DUMPFILE_TEXT_DELTA);
svn_boolean_t is_delta = FALSE;
if (! deltas_are_text)
is_delta = (delta && strcmp(delta, "true") == 0);
SVN_ERR(parse_text_block(stream,
svn__atoui64(text_cl),
is_delta,
parse_fns,
found_node ? node_baton : rev_baton,
buffer,
buflen,
found_node ? nodepool : revpool));
}
else if (old_v1_with_cl)
{
/* An old-v1 block with a Content-length might have a text block.
If the property block did not consume all the bytes of the
Content-length, then it clearly does have a text block.
If not, then we must deduce whether we have an *empty* text
block or an *absent* text block. The rules are:
- "Node-kind: file" blocks have an empty (i.e. present, but
zero-length) text block, since they represent a file
modification. Note that file-copied-text-unmodified blocks
have no Content-length - even if they should have contained
a modified property block, the pre-0.14 dumper forgets to
dump the modified properties.
- If it is not a file node, then it is a revision or directory,
and so has an absent text block.
*/
const char *node_kind;
svn_filesize_t cl_value = svn__atoui64(content_length)
- actual_prop_length;
if (cl_value ||
((node_kind = svn_hash_gets(headers,
SVN_REPOS_DUMPFILE_NODE_KIND))
&& strcmp(node_kind, "file") == 0)
)
SVN_ERR(parse_text_block(stream,
cl_value,
FALSE,
parse_fns,
found_node ? node_baton : rev_baton,
buffer,
buflen,
found_node ? nodepool : revpool));
}
/* if we have a content-length header, did we read all of it?
in case of an old v1, we *always* read all of it, because
text-content-length == content-length - prop-content-length
*/
if (content_length && ! old_v1_with_cl)
{
apr_size_t rlen, num_to_read;
svn_filesize_t remaining =
svn__atoui64(content_length) -
(prop_cl ? svn__atoui64(prop_cl) : 0) -
(text_cl ? svn__atoui64(text_cl) : 0);
if (remaining < 0)
return svn_error_create(SVN_ERR_STREAM_MALFORMED_DATA, NULL,
_("Sum of subblock sizes larger than "
"total block content length"));
/* Consume remaining bytes in this content block */
while (remaining > 0)
{
if (remaining >= (svn_filesize_t)buflen)
rlen = buflen;
else
rlen = (apr_size_t) remaining;
num_to_read = rlen;
SVN_ERR(svn_stream_read(stream, buffer, &rlen));
remaining -= rlen;
if (rlen != num_to_read)
return stream_ran_dry();
}
}
/* If we just finished processing a node record, we need to
close the node record and clear the per-node subpool. */
if (found_node)
{
SVN_ERR(parse_fns->close_node(node_baton));
svn_pool_clear(nodepool);
}
/*** End of processing for one record. ***/
} /* end of stream */
/* Close out whatever revision we're in. */
if (rev_baton != NULL)
SVN_ERR(parse_fns->close_revision(rev_baton));
svn_pool_destroy(linepool);
svn_pool_destroy(revpool);
svn_pool_destroy(nodepool);
return SVN_NO_ERROR;
}
/* Main file load function */
gint32
load_thumbnail_image (const gchar *filename,
gint *width,
gint *height,
GError **load_error)
{
FILE *f;
struct stat st;
PSDimage img_a;
gint32 image_id = -1;
GError *error = NULL;
/* ----- Open PSD file ----- */
if (g_stat (filename, &st) == -1)
return -1;
IFDBG(1) g_debug ("Open file %s", gimp_filename_to_utf8 (filename));
f = g_fopen (filename, "rb");
if (f == NULL)
{
g_set_error (load_error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return -1;
}
gimp_progress_init_printf (_("Opening thumbnail for '%s'"),
gimp_filename_to_utf8 (filename));
/* ----- Read the PSD file Header block ----- */
IFDBG(2) g_debug ("Read header block");
if (read_header_block (&img_a, f, &error) < 0)
goto load_error;
gimp_progress_update (0.2);
/* ----- Read the PSD file Colour Mode block ----- */
IFDBG(2) g_debug ("Read colour mode block");
if (read_color_mode_block (&img_a, f, &error) < 0)
goto load_error;
gimp_progress_update (0.4);
/* ----- Read the PSD file Image Resource block ----- */
IFDBG(2) g_debug ("Read image resource block");
if (read_image_resource_block (&img_a, f, &error) < 0)
goto load_error;
gimp_progress_update (0.6);
/* ----- Create GIMP image ----- */
IFDBG(2) g_debug ("Create GIMP image");
image_id = create_gimp_image (&img_a, filename);
if (image_id < 0)
goto load_error;
/* ----- Add image resources ----- */
IFDBG(2) g_debug ("Add image resources");
if (add_image_resources (image_id, &img_a, f, &error) < 1)
goto load_error;
gimp_progress_update (1.0);
gimp_image_clean_all (image_id);
gimp_image_undo_enable (image_id);
fclose (f);
*width = img_a.columns;
*height = img_a.rows;
return image_id;
/* ----- Process load errors ----- */
load_error:
if (error)
{
g_set_error (load_error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Error loading PSD file: %s"), error->message);
g_error_free (error);
}
/* Delete partially loaded image */
if (image_id > 0)
gimp_image_delete (image_id);
/* Close file if Open */
if (! (f == NULL))
fclose (f);
return -1;
}
