reactos/rosapps/smartpdf/fitz/samus/sa_pack.c

388 lines
7.4 KiB
C
Raw Normal View History

/*
* Metro physical packages and parts, mapped to a zip archive.
*/
#include "fitz.h"
#include "samus.h"
typedef struct sa_default_s sa_default;
typedef struct sa_override_s sa_override;
struct sa_package_s
{
sa_zip *zip;
sa_default *defaults;
sa_override *overrides;
};
/*
* Load the [Content_Types].xml data structures
* that define content types for the parts in the package.
*/
struct sa_default_s
{
char *extension;
char *mimetype;
sa_default *next;
};
struct sa_override_s
{
char *partname;
char *mimetype;
sa_override *next;
};
static fz_error *
readcontenttypes(sa_package *pack)
{
fz_error *error;
fz_stream *zipstm;
sa_xmlparser *parser;
sa_xmlitem *item;
error = sa_openzipentry(&zipstm, pack->zip, "[Content_Types].xml");
if (error)
return error;
error = sa_openxml(&parser, zipstm, 0);
if (error)
goto cleanupzip;
item = sa_xmlnext(parser);
while (item)
{
if (!strcmp(sa_xmlname(item), "Types"))
{
sa_xmldown(parser);
item = sa_xmlnext(parser);
while (item)
{
if (!strcmp(sa_xmlname(item), "Default"))
{
char *ext = sa_xmlatt(item, "Extension");
char *type = sa_xmlatt(item, "ContentType");
if (ext && type)
{
sa_default *newdef;
if (strchr(type, ';'))
strchr(type, ';')[0] = 0;
newdef = fz_malloc(sizeof(sa_default));
if (!newdef) { error = fz_outofmem; goto cleanupxml; }
newdef->extension = fz_strdup(ext);
newdef->mimetype = fz_strdup(type);
newdef->next = pack->defaults;
pack->defaults = newdef;
}
}
if (!strcmp(sa_xmlname(item), "Override"))
{
char *name = sa_xmlatt(item, "PartName");
char *type = sa_xmlatt(item, "ContentType");
if (name && type)
{
sa_override *newovr;
if (strchr(type, ';'))
strchr(type, ';')[0] = 0;
newovr = fz_malloc(sizeof(sa_override));
if (!newovr) { error = fz_outofmem; goto cleanupxml; }
newovr->partname = fz_strdup(name);
newovr->mimetype = fz_strdup(type);
newovr->next = pack->overrides;
pack->overrides = newovr;
}
}
item = sa_xmlnext(parser);
}
sa_xmlup(parser);
}
}
sa_closexml(parser);
fz_dropstream(zipstm);
return nil;
cleanupxml:
sa_closexml(parser);
cleanupzip:
fz_dropstream(zipstm);
return error;
}
/*
* Return the type of a part, or nil if it doenst exist or has no type.
*/
char *
sa_typepart(sa_package *pack, char *partname)
{
sa_default *def;
sa_override *ovr;
char *ext;
if (partname[0] != '/')
return nil;
if (sa_accesszipentry(pack->zip, partname + 1))
{
for (ovr = pack->overrides; ovr; ovr = ovr->next)
if (!sa_strcmp(partname, ovr->partname))
return ovr->mimetype;
ext = strrchr(partname, '.');
if (ext)
{
for (def = pack->defaults; def; def = def->next)
if (!sa_strcmp(ext + 1, def->extension))
return def->mimetype;
}
}
return nil;
}
/*
* Open a package...
* Open the ZIP file.
* Load the content types.
* Load the relations for the root.
*/
fz_error *
sa_openpackage(sa_package **packp, char *filename)
{
fz_error *error;
sa_package *pack;
pack = fz_malloc(sizeof(sa_package));
if (!pack)
return fz_outofmem;
pack->zip = nil;
pack->defaults = nil;
pack->overrides = nil;
error = sa_openzip(&pack->zip, filename);
if (error)
{
sa_closepackage(pack);
return error;
}
error = readcontenttypes(pack);
if (error)
{
sa_closepackage(pack);
return error;
}
*packp = pack;
return nil;
}
void
sa_closepackage(sa_package *pack)
{
sa_default *def, *ndef;
sa_override *ovr, *novr;
if (pack->zip)
sa_closezip(pack->zip);
for (def = pack->defaults; def; def = ndef)
{
ndef = def->next;
fz_free(def->extension);
fz_free(def->mimetype);
fz_free(def);
}
for (ovr = pack->overrides; ovr; ovr = novr)
{
novr = ovr->next;
fz_free(ovr->partname);
fz_free(ovr->mimetype);
fz_free(ovr);
}
fz_free(pack);
}
void
sa_debugpackage(sa_package *pack)
{
sa_default *def;
sa_override *ovr;
printf("package\n{\n");
if (pack->zip)
sa_debugzip(pack->zip);
printf(" defaults\n {\n");
for (def = pack->defaults; def; def = def->next)
printf(" %-8s %s\n", def->extension, def->mimetype);
printf(" }\n");
printf(" overrides\n {\n");
for (ovr = pack->overrides; ovr; ovr = ovr->next)
printf(" %s\n %s\n", ovr->partname, ovr->mimetype);
printf(" }\n");
printf("}\n");
}
/*
* Open a part for reading.
* It is NOT safe to open more than one part at a time.
*/
fz_error *
sa_openpart(fz_stream **stmp, sa_package *pack, char *partname)
{
if (partname[0] != '/')
return fz_throw("ioerror: invalid part name: %s", partname);
return sa_openzipentry(stmp, pack->zip, partname + 1);
}
/*
* Load a linked list of all the relations of a part.
* This is contained in <folder>/_rels/<file>.rels
*/
fz_error *
sa_loadrelations(sa_relation **relsp, sa_package *pack, char *partname)
{
fz_error *error;
fz_stream *zipstm;
sa_xmlparser *parser;
sa_xmlitem *item;
sa_relation *rels;
int len;
char *sep;
char *relsname;
char buf[1024];
if (partname[0] != '/')
return fz_throw("ioerror: invalid part name: %s", partname);
sep = strrchr(partname, '/');
if (!sep)
return fz_throw("ioerror: invalid part name: %s", partname);
len = strlen(partname) + 11 + 1;
relsname = fz_malloc(len);
if (!relsname)
return fz_outofmem;
memcpy(relsname, partname, sep - partname + 1);
relsname[sep - partname + 1] = 0;
strcat(relsname, "_rels/");
strcat(relsname, sep + 1);
strcat(relsname, ".rels");
rels = nil;
if (!sa_accesszipentry(pack->zip, relsname + 1))
{
fz_free(relsname);
*relsp = nil;
return nil;
}
error = sa_openzipentry(&zipstm, pack->zip, relsname + 1);
if (error)
goto cleanupname;
error = sa_openxml(&parser, zipstm, 0);
if (error)
goto cleanupzip;
item = sa_xmlnext(parser);
while (item)
{
if (!strcmp(sa_xmlname(item), "Relationships"))
{
sa_xmldown(parser);
item = sa_xmlnext(parser);
while (item)
{
if (!strcmp(sa_xmlname(item), "Relationship"))
{
char *mode = sa_xmlatt(item, "TargetMode");
char *id = sa_xmlatt(item, "Id");
char *target = sa_xmlatt(item, "Target");
char *type = sa_xmlatt(item, "Type");
if (!mode)
mode = "Internal";
if (id && target && type)
{
sa_relation *newrel;
newrel = fz_malloc(sizeof(sa_relation));
if (!newrel) { error = fz_outofmem; goto cleanupxml; }
newrel->external = !strcmp(mode, "External");
newrel->id = fz_strdup(id);
newrel->type = fz_strdup(type);
newrel->next = rels;
if (newrel->external)
newrel->target = fz_strdup(target);
else
{
sa_resolvepath(buf, partname, target, sizeof buf);
newrel->target = fz_strdup(buf);
}
rels = newrel;
}
}
item = sa_xmlnext(parser);
}
sa_xmlup(parser);
}
}
sa_closexml(parser);
fz_dropstream(zipstm);
fz_free(relsname);
*relsp = rels;
return nil;
cleanupxml:
sa_closexml(parser);
cleanupzip:
fz_dropstream(zipstm);
cleanupname:
fz_free(relsname);
return error;
}
void
sa_debugrelations(sa_relation *rel)
{
printf("relations\n{\n");
while (rel)
{
printf(" %s\n", rel->type);
printf(" %s%s\n", rel->external ? "external " : "", rel->target);
rel = rel->next;
}
printf("}\n");
}
void
sa_droprelations(sa_relation *rel)
{
sa_relation *nrel;
while (rel)
{
nrel = rel->next;
fz_free(rel->target);
fz_free(rel->id);
fz_free(rel->type);
fz_free(rel);
rel = nrel;
}
}