/* Decompress infile in dest_dir. */
static void
decompress_infile (GsfInfile *infile,
gchar *dest_dir)
{
GError *err = (GError *) NULL;
int j = 0;
for (j = 0; j < gsf_infile_num_children (infile); j++)
{
GsfInput *child = gsf_infile_child_by_index (infile, j);
char const* filename = gsf_input_name (child);
gboolean is_dir = gsf_infile_num_children (GSF_INFILE (child)) >= 0;
if (is_dir)
{
gchar *dir_path = g_build_filename (dest_dir, filename, (gchar *) 0);
decompress_infile (GSF_INFILE (child), dir_path);
g_free (dir_path);
}
else
{
gchar *file_path = g_build_filename (dest_dir, filename, (gchar *) 0);
GsfOutput *output = GSF_OUTPUT (gsf_output_stdio_new (file_path, &err));
gsf_input_copy (child, output);
gsf_output_close (output);
g_object_unref (output);
g_free (file_path);
}
g_object_unref (G_OBJECT (child));
}
}
static void
ls_R (GsfInput *input)
{
char const *name = gsf_input_name (input);
gboolean is_dir = GSF_IS_INFILE (input) &&
(gsf_infile_num_children (GSF_INFILE (input)) >= 0);
/* Please see the comment on is_dir in test-cp-msole.c. */
printf ("%c '%s'\t\t%" GSF_OFF_T_FORMAT "\n",
(is_dir ? 'd' : ' '),
(name != NULL) ? name : "",
gsf_input_size (input));
if (is_dir) {
GsfInfile *infile = GSF_INFILE (input);
int i;
puts ("{");
for (i = 0 ; i < gsf_infile_num_children (infile) ; i++)
ls_R (gsf_infile_child_by_index (infile, i));
puts ("}");
}
g_object_unref (G_OBJECT (input));
}
const char * AbiWordperfectInputStream::subStreamName(unsigned id)
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
if ((int)id >= gsf_infile_num_children(m_ole))
{
return 0;
}
std::map<unsigned, std::string>::iterator i = m_substreams.lower_bound(id);
if (i == m_substreams.end() || m_substreams.key_comp()(id, i->first))
{
std::string name = gsf_infile_name_by_index(m_ole, (int)id);
i = m_substreams.insert(i, std::map<unsigned, std::string>::value_type(id, name));
}
return i->second.c_str();
}
return 0;
}
/**
* gsf_structured_blob_read:
* @input: An input (potentially a GsfInfile) holding the blob
*
* Create a tree of binary blobs with unknown content from a #GsfInput or
* #GsfInfile and store it in a newly created #GsfStructuredBlob.
*
* Returns: (transfer full): a new #GsfStructuredBlob object which the caller is responsible for.
**/
GsfStructuredBlob *
gsf_structured_blob_read (GsfInput *input)
{
GsfStructuredBlob *blob;
gsf_off_t content_size;
int i = 0;
g_return_val_if_fail (GSF_IS_INPUT (input), NULL);
blob = g_object_new (GSF_STRUCTURED_BLOB_TYPE, NULL);
content_size = gsf_input_remaining (input);
if (content_size > 0) {
guint8 *buf = (guint8*)g_try_malloc (content_size);
if (buf == NULL) {
g_warning ("Failed attempting to allocate %" GSF_OFF_T_FORMAT " bytes",
content_size);
g_object_unref (blob);
return NULL;
}
gsf_input_read (input, content_size, buf);
blob->data = gsf_shared_memory_new (buf, content_size, TRUE);
}
gsf_input_set_name (GSF_INPUT (blob), gsf_input_name (input));
if (GSF_IS_INFILE (input))
i = gsf_infile_num_children (GSF_INFILE (input));
if (i > 0) {
GsfInput *child;
GsfStructuredBlob *child_blob;
blob->children = g_ptr_array_sized_new (i);
g_ptr_array_set_size (blob->children, i);
while (i-- > 0) {
child = gsf_infile_child_by_index (GSF_INFILE (input), i);
child_blob = gsf_structured_blob_read (child);
g_object_unref (child);
g_ptr_array_index (blob->children, i) = child_blob;
#if 0
/*
* We don't need this, and setting it causes circular
* links.
*/
gsf_input_set_container (GSF_INPUT (child_blob),
GSF_INFILE (blob));
#endif
}
}
return blob;
}
bool AbiWordperfectInputStream::isStructured()
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
return true;
return false;
}
static void
clone (GsfInput *input, GsfOutput *output)
{
guint8 const *data;
size_t len;
int i;
if (gsf_input_size (input) > 0) {
while ((len = gsf_input_remaining (input)) > 0) {
/* copy in odd sized chunks to exercise system */
if (len > 314)
len = 314;
if (NULL == (data = gsf_input_read (input, len, NULL))) {
g_warning ("error reading ?");
return;
}
if (!gsf_output_write (output, len, data)) {
g_warning ("error writing ?");
return;
}
}
}
/* See test-cp-msole.c for explanation how to distinct directories
* from regular files.
*/
if (GSF_IS_INFILE (input) &&
gsf_infile_num_children (GSF_INFILE (input)) > 0) {
GsfInfile *in = GSF_INFILE (input);
GsfOutfile *out = GSF_OUTFILE (output);
GsfInput *src;
GsfOutput *dst;
gboolean is_dir;
for (i = 0 ; i < gsf_infile_num_children (in) ; i++) {
src = gsf_infile_child_by_index (in, i);
is_dir = GSF_IS_INFILE (src) &&
gsf_infile_num_children (GSF_INFILE (src)) >= 0;
dst = gsf_outfile_new_child (out,
gsf_infile_name_by_index (in, i),
is_dir);
clone (src, dst);
}
}
gsf_output_close (output);
g_object_unref (G_OBJECT (output));
g_object_unref (G_OBJECT (input));
}
/**
* based on find_member() from vsd_utils.c:
* http://vsdump.sourcearchive.com/documentation/0.0.44/vsd__utils_8c-source.html
*/
static GsfInput *
find_member (GsfInfile *arch,
gchar const *name)
{
gchar const *slash;
slash = strchr (name, '/');
if (slash) {
gchar *dirname;
GsfInput *member;
dirname = g_strndup (name, slash - name);
/**
* Ignore if the directory is the current one that is ".".
* Go to next direcotry if exists
*/
if (strcmp (dirname, ".") == 0) {
member = find_member (arch, slash + 1);
} else if ((member = gsf_infile_child_by_name (arch, dirname)) != NULL) {
GsfInfile *dir;
dir = GSF_INFILE (member);
member = find_member (dir, slash + 1);
g_object_unref (dir);
}
g_free (dirname);
return member;
} else {
return gsf_infile_child_by_name (arch, name);
}
}
static void
clone_dir (GsfInfile *in, GsfOutfile *out)
{
GsfInput *new_input;
GsfOutput *new_output;
gboolean is_dir;
int i;
for (i = 0 ; i < gsf_infile_num_children (in) ; i++) {
new_input = gsf_infile_child_by_index (in, i);
/* In theory, if new_file is a regular file (not directory),
* it should be GsfInput only, not GsfInfile, as it is not
* structured. However, having each Infile define a 2nd class
* that only inherited from Input was cumbersome. So in
* practice, the convention is that new_input is always
* GsfInfile, but regular file is distinguished by having -1
* children.
*/
is_dir = GSF_IS_INFILE (new_input) &&
gsf_infile_num_children (GSF_INFILE (new_input)) >= 0;
new_output = gsf_outfile_new_child (out,
gsf_infile_name_by_index (in, i),
is_dir);
clone (new_input, new_output);
}
/* An observation: when you think about the explanation to is_dir
* above, you realize that clone_dir is called even for regular files.
* But nothing bad happens, as the loop is never entered.
*/
}
static void
clone (GsfInput *input, GsfOutput *output)
{
if (gsf_input_size (input) > 0) {
guint8 const *data;
size_t len;
while ((len = gsf_input_remaining (input)) > 0) {
/* copy in odd sized chunks to exercise system */
if (len > 314)
len = 314;
if (NULL == (data = gsf_input_read (input, len, NULL))) {
g_warning ("error reading ?");
return;
}
if (!gsf_output_write (output, len, data)) {
g_warning ("error writing ?");
return;
}
}
} else if (GSF_IS_INFILE(input))
clone_dir (GSF_INFILE(input), GSF_OUTFILE(output));
gsf_output_close (output);
g_object_unref (G_OBJECT (output));
g_object_unref (G_OBJECT (input));
}
static GsfInput *
gsf_infile_zip_new_child (GsfInfileZip *parent, GsfZipVDir *vdir, GError **err)
{
GsfInfileZip *child;
GsfZipDirent *dirent = vdir->dirent;
child = zip_dup (parent, err);
if (child == NULL)
return NULL;
gsf_input_set_name (GSF_INPUT (child), vdir->name);
gsf_input_set_container (GSF_INPUT (child), GSF_INFILE (parent));
child->vdir = vdir;
if (dirent) {
gsf_input_set_size (GSF_INPUT (child),
(gsf_off_t) dirent->usize);
if (zip_child_init (child, err) != FALSE) {
g_object_unref (child);
return NULL;
}
} else
gsf_input_set_size (GSF_INPUT (child), 0);
return GSF_INPUT (child);
}
/**
* Handle the manifest file.
*/
UT_Error IE_Imp_OpenDocument::_handleManifestStream() {
// clear the cryptography state
m_cryptoInfo.clear();
m_sPassword = "";
GsfInput* pMetaInf = gsf_infile_child_by_name(m_pGsfInfile, "META-INF");
ODi_ManifestStream_ListenerState manifestListener(getDoc(),
*(m_pStreamListener->getElementStack()),
m_cryptoInfo);
m_pStreamListener->setState(&manifestListener, false);
UT_Error error = _handleStream (GSF_INFILE(pMetaInf), "manifest.xml", *m_pStreamListener);
g_object_unref (G_OBJECT (pMetaInf));
if (error != UT_OK) {
return error;
}
if (m_cryptoInfo.size() > 0) {
// there is at least one entry in the manifest that is encrypted, so
// ask the user for a password
m_sPassword = GetPassword();
if (m_sPassword.size() == 0)
return UT_IE_PROTECTED;
}
return UT_OK;
}
/**
* gsf_open_pkg_open_rel:
* @opkg: #GsfInput
* @rel: #GsfOpenPkgRel
* @err: #GError.
*
* Returns: (transfer full): a new #GsfInput which the called needs to unref, or %NULL and sets @err
**/
GsfInput *
gsf_open_pkg_open_rel (GsfInput *opkg, GsfOpenPkgRel const *rel,
G_GNUC_UNUSED GError **err /* just in case we need it one day */ )
{
GsfInput *res = NULL;
GsfInfile *parent, *prev_parent;
gchar **elems;
unsigned i;
g_return_val_if_fail (rel != NULL, NULL);
g_return_val_if_fail (opkg != NULL, NULL);
/* References from the root use children of opkg
* References from a child are relative to siblings of opkg */
parent = gsf_input_name (opkg)
? gsf_input_container (opkg) : GSF_INFILE (opkg);
g_object_ref (parent);
elems = g_strsplit (rel->target, "/", 0);
for (i = 0 ; elems[i] && NULL != parent ; i++) {
if (0 == strcmp (elems[i], ".") || '\0' == *elems[i])
continue; /* ignore '.' and empty */
prev_parent = parent;
if (0 == strcmp (elems[i], "..")) {
parent = gsf_input_container (GSF_INPUT (parent));
res = NULL; /* only return newly created children */
if (NULL != parent) {
/* check for attempt to gain access outside the zip file */
if (G_OBJECT_TYPE (parent) == G_OBJECT_TYPE (prev_parent))
g_object_ref (parent);
else
parent = NULL;
}
} else {
res = gsf_infile_child_by_name (parent, elems[i]);
if (NULL != elems[i+1]) {
g_return_val_if_fail (GSF_IS_INFILE (res), NULL);
parent = GSF_INFILE (res);
}
}
g_object_unref (prev_parent);
}
g_strfreev (elems);
return res;
}
unsigned AbiWordperfectInputStream::subStreamCount()
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
int numChildren = gsf_infile_num_children(m_ole);
if (numChildren > 0)
return numChildren;
return 0;
}
return 0;
}
bool AbiWordperfectInputStream::existsSubStream(const char * name)
{
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
GsfInput *document = gsf_infile_child_by_name(m_ole, name);
if (document)
{
g_object_unref(G_OBJECT (document));
return true;
}
}
return false;
}
UT_Error IE_Imp_EPUB::readMetadata()
{
GsfInput* metaInf = gsf_infile_child_by_name(m_epub, "META-INF");
if (metaInf == NULL)
{
UT_DEBUGMSG(("Can`t open container META-INF dir\n"));
return UT_ERROR;
}
GsfInput* meta = gsf_infile_child_by_name(GSF_INFILE(metaInf),
"container.xml");
if (meta == NULL)
{
UT_DEBUGMSG(("Can`t open container metadata\n"));
return UT_ERROR;
}
size_t metaSize = gsf_input_size(meta);
if (metaSize == 0)
{
UT_DEBUGMSG(("Container metadata file is empty\n"));
return UT_ERROR;
}
gchar* metaXml = (gchar*) gsf_input_read(meta, metaSize, NULL);
std::string rootfilePath;
UT_XML metaParser;
ContainerListener containerListener;
metaParser.setListener(&containerListener);
if (metaParser.sniff(metaXml, metaSize, "container"))
{
UT_DEBUGMSG(("Parsing container.xml file\n"));
metaParser.parse(metaXml, metaSize);
}
else
{
UT_DEBUGMSG(("Incorrect container.xml file\n"));
return UT_ERROR;
}
m_rootfilePath = containerListener.getRootFilePath();
g_object_unref(G_OBJECT(meta));
g_object_unref(G_OBJECT(metaInf));
return UT_OK;
}
librevenge::RVNGInputStream * AbiWordperfectInputStream::getSubStreamById(unsigned id)
{
librevenge::RVNGInputStream *documentStream = NULL;
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_zip_new (m_input, NULL));
if (m_ole)
{
GsfInput *document = gsf_infile_child_by_index(m_ole, (int)id);
if (document)
{
documentStream = new AbiWordperfectInputStream(document);
g_object_unref(G_OBJECT (document)); // the only reference should be encapsulated within the new stream
}
}
return documentStream;
}
UT_Error IE_Imp_Hancom::_loadFile(GsfInput * input) {
mDoc = GSF_INFILE(gsf_infile_msole_new (input, NULL));
if (!mDoc)
return UT_IE_BOGUSDOCUMENT;
GsfInput *textStream = gsf_infile_child_by_name(mDoc, "/PrvText");
if (!textStream)
return UT_IE_BOGUSDOCUMENT;
size_t len = gsf_input_size(textStream);
UT_DEBUGMSG(("HANCOM: Text length = %zd bytes\n", len));
unsigned char* buf = new unsigned char[len];
if (!buf) {
g_object_unref (G_OBJECT (textStream));
return UT_IE_NOMEMORY;
}
gsf_input_read(textStream, len, buf);
g_object_unref (G_OBJECT (textStream));
UT_uint32 length;
UT_UCS4Char* text = reinterpret_cast<UT_UCS4Char*>(UT_convert((const char *)buf, len, "UCS-2LE",
UCS_INTERNAL, NULL, &length));
delete[] buf;
if (!text)
return UT_IE_NOMEMORY;
UT_DEBUGMSG(("HANCOM: Text successfully converted.\n"));
if (!appendStrux(PTX_Section, NULL)) {
FREEP(text);
return UT_IE_NOMEMORY;
}
if (!appendStrux(PTX_Block, NULL)) {
FREEP(text);
return UT_IE_NOMEMORY;
}
if (!appendSpan(text, length/4)) {
FREEP(text);
return UT_IE_NOMEMORY;
}
FREEP(text);
return UT_OK;
}
static void
ls_R (GsfInput *input, char const *prefix)
{
char const *name = gsf_input_name (input);
GsfInfile *infile = GSF_IS_INFILE (input) ? GSF_INFILE (input) : NULL;
gboolean is_dir = infile && gsf_infile_num_children (infile) > 0;
char *full_name;
char *new_prefix;
if (prefix) {
char *display_name = name ?
g_filename_display_name (name)
: g_strdup ("?");
full_name = g_strconcat (prefix,
display_name,
NULL);
new_prefix = g_strconcat (full_name, "/", NULL);
g_free (display_name);
} else {
full_name = g_strdup ("*root*");
new_prefix = g_strdup ("");
}
g_print ("%c %10" GSF_OFF_T_FORMAT " %s\n",
(is_dir ? 'd' : 'f'),
gsf_input_size (input),
full_name);
if (is_dir) {
int i;
for (i = 0 ; i < gsf_infile_num_children (infile) ; i++) {
GsfInput *child = gsf_infile_child_by_index (infile, i);
/* We can get NULL here in case of file corruption. */
if (child) {
ls_R (child, new_prefix);
g_object_unref (child);
}
}
}
g_free (full_name);
g_free (new_prefix);
}
WPXInputStream * AbiWordperfectInputStream::getDocumentOLEStream(const char * name)
{
WPXInputStream *documentStream = NULL;
if (!m_ole)
m_ole = GSF_INFILE(gsf_infile_msole_new (m_input, NULL));
if (m_ole)
{
GsfInput *document = gsf_infile_child_by_name(m_ole, name);
if (document)
{
documentStream = new AbiWordperfectInputStream(document);
g_object_unref(G_OBJECT (document)); // the only reference should be encapsulated within the new stream
}
}
return documentStream;
}
/**
* gsf_input_find_vba:
* @input: #GsfInput
* @err: #GError, optionally %NULL.
*
* A utility routine that attempts to find the VBA file withint a stream.
*
* Returns: (transfer full): a GsfInfile
**/
GsfInfileMSVBA *
gsf_input_find_vba (GsfInput *input, GError **err)
{
GsfInput *vba = NULL;
GsfInfile *infile;
if (NULL != (infile = gsf_infile_msole_new (input, NULL))) {
/* 1) Try XLS */
vba = gsf_infile_child_by_vname (infile, "_VBA_PROJECT_CUR", "VBA", NULL);
/* 2) DOC */
if (NULL == vba)
vba = gsf_infile_child_by_vname (infile, "Macros", "VBA", NULL);
/* TODO : PPT is more complex */
g_object_unref (infile);
} else if (NULL != (infile = gsf_infile_zip_new (input, NULL))) {
GsfInput *main_part = gsf_open_pkg_open_rel_by_type (GSF_INPUT (infile),
"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
NULL);
if (NULL != main_part) {
GsfInput *vba_stream = gsf_open_pkg_open_rel_by_type (main_part,
"http://schemas.microsoft.com/office/2006/relationships/vbaProject",
NULL);
if (NULL != vba_stream) {
GsfInfile *ole = gsf_infile_msole_new (vba_stream, err);
if (NULL != ole) {
vba = gsf_infile_child_by_vname (ole, "VBA", NULL);
g_object_unref (ole);
}
g_object_unref (vba_stream);
}
g_object_unref (main_part);
}
g_object_unref (infile);
}
if (NULL != vba)
return (GsfInfileMSVBA *)
gsf_infile_msvba_new (GSF_INFILE (vba), err);
return NULL;
}
static GsfOpenPkgRels *
gsf_open_pkg_get_rels (GsfInput *opkg)
{
GsfOpenPkgRels *rels = NULL;
g_return_val_if_fail (opkg != NULL, NULL);
if (NULL == (rels = g_object_get_data (G_OBJECT (opkg), "OpenPkgRels"))) {
char const *part_name = gsf_input_name (opkg);
GsfXMLInDoc *rel_doc;
GsfInput *rel_stream;
if (NULL != part_name) {
GsfInfile *container = gsf_input_container (opkg);
char *rel_name;
g_return_val_if_fail (container != NULL, NULL);
rel_name = g_strconcat (part_name, ".rels", NULL);
rel_stream = gsf_infile_child_by_vname (container, "_rels", rel_name, NULL);
g_free (rel_name);
} else /* the root */
rel_stream = gsf_infile_child_by_vname (GSF_INFILE (opkg), "_rels", ".rels", NULL);
if (NULL != rel_stream) {
rels = g_new (GsfOpenPkgRels, 1);
rels->by_id = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify)gsf_open_pkg_rel_free);
rels->by_type = g_hash_table_new (g_str_hash, g_str_equal);
rel_doc = gsf_xml_in_doc_new (open_pkg_rel_dtd, open_pkg_ns);
(void) gsf_xml_in_doc_parse (rel_doc, rel_stream, rels);
gsf_xml_in_doc_free (rel_doc);
g_object_unref (rel_stream);
}
g_object_set_data_full (G_OBJECT (opkg), "OpenPkgRels", rels,
(GDestroyNotify) gsf_open_pkg_rels_free);
}
return rels;
}
UT_Error IE_Imp_EPUB::uncompress()
{
m_tmpDir = UT_go_filename_to_uri(g_get_tmp_dir());
m_tmpDir += G_DIR_SEPARATOR_S;
m_tmpDir += getDoc()->getDocUUIDString();
if (!UT_go_directory_create(m_tmpDir.c_str(), 0644, NULL))
{
UT_DEBUGMSG(("Can`t create temporary directory\n"));
return UT_ERROR;
}
GsfInput *opsDirInput = gsf_infile_child_by_name(m_epub,
m_opsDir.c_str());
UT_DEBUGMSG(("Child count : %d", gsf_infile_num_children(m_epub)));
if (opsDirInput == NULL)
{
UT_DEBUGMSG(("Failed to open OPS dir\n"));
return UT_ERROR;
}
for (std::map<std::string, std::string>::iterator i =
m_manifestItems.begin(); i != m_manifestItems.end(); i++)
{
gchar *itemFileName = UT_go_filename_from_uri(
(m_tmpDir + G_DIR_SEPARATOR_S + (*i).second).c_str());
gchar** aname =
g_strsplit((*i).second.c_str(), G_DIR_SEPARATOR_S, 0);
GsfInput* itemInput = gsf_infile_child_by_aname(
GSF_INFILE(opsDirInput), (const char**) aname);
GsfOutput* itemOutput = createFileByPath(itemFileName);
gsf_input_seek(itemInput, 0, G_SEEK_SET);
gsf_input_copy(itemInput, itemOutput);
g_strfreev(aname);
g_free(itemFileName);
g_object_unref(G_OBJECT(itemInput));
gsf_output_close(itemOutput);
}
g_object_unref(G_OBJECT(opsDirInput));
return UT_OK;
}
static GsfInfileTar *
tar_directory_for_file (GsfInfileTar *dir, const char *name, gboolean last)
{
const char *s = name;
while (1) {
const char *s0 = s;
char *dirname;
/* Find a directory component, if any. */
while (1) {
if (*s == 0) {
if (last && s != s0)
break;
else
return dir;
}
/* This is deliberately slash-only. */
if (*s == '/')
break;
s++;
}
dirname = g_strndup (s0, s - s0);
while (*s == '/')
s++;
if (strcmp (dirname, ".") != 0) {
GsfInput *subdir =
gsf_infile_child_by_name (GSF_INFILE (dir),
dirname);
if (subdir) {
/* Undo the ref. */
g_object_unref (subdir);
dir = GSF_INFILE_TAR (subdir);
} else
dir = tar_create_dir (dir, dirname);
}
g_free (dirname);
}
}
/**
* gsf_infile_tar_new :
* @source: A base #GsfInput
* @err: A #GError, optionally %null
*
* Opens the root directory of a Tar file.
* <note>This adds a reference to @source.</note>
*
* Returns: the new tar file handler
**/
GsfInfile *
gsf_infile_tar_new (GsfInput *source, GError **err)
{
GsfInfileTar *tar;
g_return_val_if_fail (GSF_IS_INPUT (source), NULL);
tar = g_object_new (GSF_INFILE_TAR_TYPE,
"source", source,
NULL);
if (tar->err) {
if (err)
*err = g_error_copy (tar->err);
g_object_unref (tar);
return NULL;
}
return GSF_INFILE (tar);
}
HRESULT STDMETHODCALLTYPE
OMGSFIStorage::StgOpenStorageEx( const TCHAR FAR* in_filename,
OMFile::OMAccessMode in_accessMode,
void **out_storage)
{
TRACE("OMGSFIStorage::StgOpenStorageEx");
PRECONDITION("Valid access mode", in_accessMode == OMFile::readOnlyMode);
GsfStorage *storage = 0;
*out_storage = 0;
char storageName[FILENAME_MAX];
#ifndef OM_UNICODE_APIS
strncpy (storageName, in_filename, sizeof(storageName) -1);
storageName[sizeof(storageName) -1] = '\0';
#else
convertWideStringToString (storageName, in_filename, FILENAME_MAX);
#endif
GError *err;
int status = GSTG_OK;
GsfInput *input = GSF_INPUT (gsf_input_stdio_new (storageName, &err));
if (input != NULL)
{
input = gsf_input_uncompress (input);
storage = GSF_INFILE (gsf_infile_msole_new (input, &err));
g_object_unref (G_OBJECT (input));
}
else
status = GSTG_ERROR;
if (status == GSTG_OK)
{
OMGSFIStorage *newStorage = new OMGSFIStorage (storage, GSF_READ, storageName);
*out_storage = newStorage;
}
return makeStatus(status);
}
/**
* gsf_infile_zip_new :
* @source: A base #GsfInput
* @err: A #GError, optionally %null
*
* Opens the root directory of a Zip file.
* <note>This adds a reference to @source.</note>
*
* Returns: the new zip file handler
**/
GsfInfile *
gsf_infile_zip_new (GsfInput *source, GError **err)
{
GsfInfileZip *zip;
g_return_val_if_fail (GSF_IS_INPUT (source), NULL);
zip = g_object_new (GSF_INFILE_ZIP_TYPE,
"source", source,
NULL);
if (G_UNLIKELY (NULL == zip)) return NULL;
if (zip->err) {
if (err)
*err = g_error_copy (zip->err);
g_object_unref (zip);
return NULL;
}
return GSF_INFILE (zip);
}
/**
* gsf_infile_ar_new :
* @source: #GsfInput
* @err: #Gerror
*
* Opens the root directory of a Ar file.
* <note>This adds a reference to @source.</note>
*
* Returns: the new AR file handler
**/
GsfInfile *
gsf_infile_ar_new (GsfInput *source, GError **err)
{
GsfInfileAr *ar;
g_return_val_if_fail (GSF_IS_INPUT (source), NULL);
ar = g_object_new (GSF_INFILE_AR_TYPE, NULL);
if (G_UNLIKELY (NULL == ar)) return NULL;
g_object_ref (source);
ar->input = source;
gsf_input_set_size (GSF_INPUT (ar), 0);
if (ar_init_info (ar, err)) {
g_object_unref (ar);
return NULL;
}
ar->vdir = ar->info->vdir;
return GSF_INFILE (ar);
}
gboolean
qpro_file_probe (GOFileOpener const *fo, GsfInput *input, GOFileProbeLevel pl)
{
GsfInfile *ole;
GsfInput *stream;
gboolean res = FALSE;
/* check for >= QPro 6.0 which is OLE based */
ole = gsf_infile_msole_new (input, NULL);
if (ole != NULL) {
stream = gsf_infile_child_by_name (GSF_INFILE (ole),
"PerfectOffice_MAIN");
if (stream != NULL) {
res = qpro_check_signature (stream);
g_object_unref (stream);
}
g_object_unref (ole);
} else
res = qpro_check_signature (input);
return res;
}
static GsfInput *
find_member (GsfInfile *arch, char const *name)
{
char const *slash = strchr (name, '/');
if (slash) {
char *dirname = g_strndup (name, slash - name);
GsfInput *member;
GsfInfile *dir;
member = gsf_infile_child_by_name (arch, dirname);
g_free (dirname);
if (!member)
return NULL;
dir = GSF_INFILE (member);
member = find_member (dir, slash + 1);
g_object_unref (dir);
return member;
} else {
return gsf_infile_child_by_name (arch, name);
}
}
/**
* gsf_infile_stdio_new:
* @root: in locale dependent encoding
* @err: optionally %NULL.
*
* Returns: a new file or %NULL.
**/
GsfInfile *
gsf_infile_stdio_new (char const *root, GError **err)
{
GsfInfileStdio *ifs;
GDir *dir;
char const *child;
dir = g_dir_open (root, 0, err);
if (dir == NULL)
return NULL;
ifs = g_object_new (GSF_INFILE_STDIO_TYPE, NULL);
ifs->root = g_strdup (root);
while ((child = g_dir_read_name (dir)))
g_ptr_array_add (ifs->children, g_strdup (child));
g_dir_close (dir);
gsf_input_set_name_from_filename (GSF_INPUT (ifs), root);
return GSF_INFILE (ifs);
}
