static ArStatus
ar_read_header (GsfInput *fp, ArHeader *header)
{
size_t len;
if (fp == NULL || header == NULL)
return AR_FAILURE;
memset(header, 0, AR_HEADER_LEN);
len = gsf_input_remaining (fp);
if (len == 0)
return AR_EOF;
else if (len < AR_HEADER_LEN)
return AR_FAILURE;
else {
gsf_input_read (fp, AR_HEADER_LEN, (guint8*)header);
if (strncmp (header->fmag, AR_FMAG, 2))
return AR_FAILURE;
return AR_SUCCESS;
}
}
static psiconv_buffer
psiconv_stream_to_buffer (GsfInput *input, int maxlen)
{
psiconv_buffer buf;
gsf_off_t size;
int len;
if (!input)
return NULL;
if ((buf = psiconv_buffer_new()) == NULL)
return NULL;
if (gsf_input_seek (input, 0, G_SEEK_SET) == TRUE) {
psiconv_buffer_free(buf);
return NULL;
}
size = gsf_input_size (input);
if (maxlen > 0 && size > maxlen)
size = maxlen;
for (; size > 0 ; size -= len) {
guint8 const *chunk;
int i;
len = MIN (4096, size);
chunk = gsf_input_read (input, len, NULL);
if (chunk == NULL)
break;
for (i = 0; i<len; i++) {
if (psiconv_buffer_add(buf, chunk[i]) != 0) {
psiconv_buffer_free(buf);
return NULL;
}
}
}
return buf;
}
int read_wri_struct (struct wri_struct *cfg, GsfInput *f) {
int size, i;
unsigned char *blob;
/* first we need to calculate the size */
i = size = 0;
while (cfg[i].name) size += cfg[i++].size;
/* got the size, read the blob */
blob = static_cast<unsigned char*>(malloc (size));
if (!blob) {
fprintf (stderr, "Out of memory!\n");
return 1;
}
if (!gsf_input_read(f, size, blob)) {
fprintf (stderr, "File not big enough!\n");
return 1;
}
size = read_wri_struct_mem (cfg, blob);
free (blob);
return size;
}
static gboolean
zip_update_stream_in (GsfInfileZip *zip)
{
guint32 read_now;
guint8 const *data;
gsf_off_t pos;
if (zip->crestlen == 0)
return FALSE;
read_now = MIN (zip->crestlen, ZIP_BLOCK_SIZE);
pos = zip->vdir->dirent->data_offset + zip->stream->total_in;
if (gsf_input_seek (zip->source, pos, G_SEEK_SET))
return FALSE;
if ((data = gsf_input_read (zip->source, read_now, NULL)) == NULL)
return FALSE;
zip->crestlen -= read_now;
zip->stream->next_in = (unsigned char *) data; /* next input byte */
zip->stream->avail_in = read_now; /* number of bytes available at next_in */
return TRUE;
}
bool IE_Imp_MSWrite::read_pap (pap_t process)
{
static const char *text_align[] = {"left", "center", "right", "justify"};
int fcMac, pnPara, fcFirst, cfod, fc, fcLim;
unsigned char page[0x80];
UT_String properties, tmp, lastprops;
if (process == All) { UT_DEBUGMSG(("PAP:\n")); }
fcMac = wri_struct_value(wri_file_header, "fcMac");
pnPara = wri_struct_value(wri_file_header, "pnPara");
fcFirst = 0x80;
while (true)
{
gsf_input_seek(mFile, pnPara++ * 0x80, G_SEEK_SET);
gsf_input_read(mFile, 0x80, page);
fc = READ_DWORD(page);
cfod = page[0x7f];
if (process == All)
{
UT_DEBUGMSG((" fcFirst = %d\n", fc));
UT_DEBUGMSG((" cfod = %d\n", cfod));
}
if (fc != fcFirst) UT_WARNINGMSG(("read_pap: fcFirst wrong.\n"));
// read all FODs (format descriptors)
for (int fod = 0; fod < cfod; fod++)
{
int bfprop, cch;
int jc, dxaRight, dxaLeft, dxaLeft1, dyaLine, fGraphics;
int rhcPage, rHeaderFooter, rhcFirst;
int tabs, dxaTab[14], jcTab[14];
if (process == All) { UT_DEBUGMSG((" PAP-FOD #%02d:\n", fod + 1)); }
// read a FOD (format descriptor)
fcLim = READ_DWORD(page + 4 + fod * 6);
bfprop = READ_WORD(page + 8 + fod * 6);
if (process == All)
{
UT_DEBUGMSG((" fcLim = %d\n", fcLim));
UT_DEBUGMSG((bfprop == 0xffff ? " bfprop = 0x%04X\n" : " bfprop = %d\n", bfprop));
}
// default PAP values
jc = 0;
dxaRight = dxaLeft = dxaLeft1 = 0;
dyaLine = 240;
rhcPage = rHeaderFooter = rhcFirst = 0;
fGraphics = 0;
tabs = 0;
// if the PAP FPROPs (formatting properties) differ from the defaults, get them
if (bfprop != 0xffff && bfprop + (cch = page[bfprop + 4]) < 0x80)
{
if (process == All) { UT_DEBUGMSG((" cch = %d\n", cch)); }
if (cch >= 2) jc = page[bfprop + 6] & 3;
if (cch >= 6) dxaRight = READ_WORD(page + bfprop + 9);
if (cch >= 8) dxaLeft = READ_WORD(page + bfprop + 11);
if (cch >= 10) dxaLeft1 = READ_WORD(page + bfprop + 13);
if (cch >= 12) dyaLine = READ_WORD(page + bfprop + 15);
if (cch >= 17)
{
rhcPage = page[bfprop + 21] & 1;
rHeaderFooter = page[bfprop + 21] & 6;
rhcFirst = page[bfprop + 21] & 8;
fGraphics = page[bfprop + 21] & 0x10;
}
for (int n = 0; n < 14; n++)
{
if (cch >= 4 * (n + 1) + 26)
{
dxaTab[tabs] = READ_WORD(page + bfprop + n * 4 + 27);
jcTab[tabs] = page[bfprop + n * 4 + 29] & 3;
tabs++;
}
}
if (dxaRight & 0x8000) dxaRight = -0x10000 + dxaRight;
if (dxaLeft & 0x8000) dxaLeft = -0x10000 + dxaLeft;
if (dxaLeft1 & 0x8000) dxaLeft1 = -0x10000 + dxaLeft1;
if (dyaLine < 240) dyaLine = 240;
if (process == All && rHeaderFooter)
{
if (rhcPage)
{
if (!hasFooter)
{
hasFooter = true;
page1Footer = rhcFirst;
}
}
else
{
if (!hasHeader)
{
hasHeader = true;
page1Header = rhcFirst;
}
}
}
}
if ((process == All && !rHeaderFooter) ||
(rHeaderFooter && ((process == Header && !rhcPage) ||
(process == Footer && rhcPage))))
{
UT_DEBUGMSG((" jc = %d\n", jc));
UT_DEBUGMSG((" dxaRight = %d\n", dxaRight));
UT_DEBUGMSG((" dxaLeft = %d\n", dxaLeft));
UT_DEBUGMSG((" dxaLeft1 = %d\n", dxaLeft1));
UT_DEBUGMSG((" dyaLine = %d\n", dyaLine));
UT_DEBUGMSG((" rhcPage = %d\n", rhcPage));
UT_DEBUGMSG((" rHeaderFooter = %d\n", rHeaderFooter));
UT_DEBUGMSG((" rhcFirst = %d\n", rhcFirst));
UT_DEBUGMSG((" fGraphics = %d\n", fGraphics));
UT_LocaleTransactor lt(LC_NUMERIC, "C");
UT_String_sprintf(properties, "text-align:%s; line-height:%.1f",
text_align[jc],
static_cast<float>(dyaLine) / 240.0);
if (tabs)
{
properties += "; tabstops:";
UT_DEBUGMSG((" Tabs:\n"));
for (int n = 0; n < tabs; n++)
{
UT_String_sprintf(tmp, "%.4fin/%c0",
static_cast<float>(dxaTab[n]) / 1440.0,
jcTab[n] ? 'D' : 'L');
properties += tmp;
UT_DEBUGMSG((" #%02d dxa = %d, jcTab = %d\n", n + 1, dxaTab[n], jcTab[n]));
if (n != tabs - 1) properties += ",";
}
}
if (process == Header || process == Footer)
{
// For reasons unknown, the left and right margins from the paper
// are included in the indents of the headers and footers.
dxaLeft -= xaLeft;
dxaRight -= xaRight;
}
if (dxaLeft1)
{
UT_String_sprintf(tmp, "; text-indent:%.4fin",
static_cast<float>(dxaLeft1) / 1440.0);
properties += tmp;
}
if (dxaLeft)
{
UT_String_sprintf(tmp, "; margin-left:%.4fin",
static_cast<float>(dxaLeft) / 1440.0);
properties += tmp;
}
if (dxaRight)
{
UT_String_sprintf(tmp, "; margin-right:%.4fin",
static_cast<float>(dxaRight) / 1440.0);
properties += tmp;
}
// new attributes, only if there was a line feed or FPROPs have changed
if (lf || strcmp(properties.c_str(), lastprops.c_str()) != 0)
{
const gchar *attributes[3];
attributes[0] = PT_PROPS_ATTRIBUTE_NAME;
attributes[1] = properties.c_str();
attributes[2] = NULL;
appendStrux(PTX_Block, attributes);
lastprops = properties;
}
if (fGraphics) read_pic(fcFirst, fcLim - fcFirst);
else read_txt(fcFirst, fcLim - 1);
}
fcFirst = fcLim;
if (fcLim >= fcMac)
{
UT_DEBUGMSG((" PAP-FODs end, fcLim (%d) >= fcMac (%d)\n", fcLim, fcMac));
return true;
}
}
}
}
/**
* vba_project_read:
* @vba: #GsfInfileMSVBA
* @err: (allow-none): place to store a #GError if anything goes wrong
*
* Read an VBA dirctory and its project file.
* along the way.
*
* Returns: %FALSE on error setting @err if it is supplied.
**/
static gboolean
vba_project_read (GsfInfileMSVBA *vba, GError **err)
{
/* NOTE : This seems constant, find some confirmation */
static guint8 const signature[] = { 0xcc, 0x61 };
static struct {
guint8 const signature[4];
char const * const name;
int const vba_version;
gboolean const is_mac;
} const versions [] = {
{ { 0x5e, 0x00, 0x00, 0x01 }, "Office 97", 5, FALSE},
{ { 0x5f, 0x00, 0x00, 0x01 }, "Office 97 SR1", 5, FALSE },
{ { 0x65, 0x00, 0x00, 0x01 }, "Office 2000 alpha?", 6, FALSE },
{ { 0x6b, 0x00, 0x00, 0x01 }, "Office 2000 beta?", 6, FALSE },
{ { 0x6d, 0x00, 0x00, 0x01 }, "Office 2000", 6, FALSE },
{ { 0x6f, 0x00, 0x00, 0x01 }, "Office 2000", 6, FALSE },
{ { 0x70, 0x00, 0x00, 0x01 }, "Office XP beta 1/2", 6, FALSE },
{ { 0x73, 0x00, 0x00, 0x01 }, "Office XP", 6, FALSE },
{ { 0x76, 0x00, 0x00, 0x01 }, "Office 2003", 6, FALSE },
{ { 0x79, 0x00, 0x00, 0x01 }, "Office 2003", 6, FALSE },
{ { 0x60, 0x00, 0x00, 0x0e }, "MacOffice 98", 5, TRUE },
{ { 0x62, 0x00, 0x00, 0x0e }, "MacOffice 2001", 5, TRUE },
{ { 0x63, 0x00, 0x00, 0x0e }, "MacOffice X", 6, TRUE },
{ { 0x64, 0x00, 0x00, 0x0e }, "MacOffice 2004", 6, TRUE },
};
guint8 const *data;
unsigned i, count, len;
gunichar2 *uni_name;
char *name;
GsfInput *dir;
dir = gsf_infile_child_by_name (vba->source, "dir");
if (dir == NULL) {
if (err != NULL)
*err = g_error_new (gsf_input_error_id (), 0,
_("Can't find the VBA directory stream"));
return FALSE;
}
if (gsf_input_seek (dir, 0, G_SEEK_SET) ||
NULL == (data = gsf_input_read (dir, VBA56_DIRENT_HEADER_SIZE, NULL)) ||
0 != memcmp (data, signature, sizeof (signature))) {
if (err != NULL)
*err = g_error_new (gsf_input_error_id (), 0,
_("No VBA signature"));
return FALSE;
}
for (i = 0 ; i < G_N_ELEMENTS (versions); i++)
if (!memcmp (data+2, versions[i].signature, 4))
break;
if (i >= G_N_ELEMENTS (versions)) {
if (err != NULL)
*err = g_error_new (gsf_input_error_id (), 0,
_("Unknown VBA version signature 0x%x%x%x%x"),
data[2], data[3], data[4], data[5]);
return FALSE;
}
puts (versions[i].name);
/* these depend strings seem to come in 2 blocks */
count = GSF_LE_GET_GUINT16 (data + VBA56_DIRENT_RECORD_COUNT);
for (; count > 0 ; count--) {
if (NULL == ((data = gsf_input_read (dir, 2, NULL))))
break;
len = GSF_LE_GET_GUINT16 (data);
if (NULL == ((data = gsf_input_read (dir, len, NULL)))) {
printf ("len == 0x%x ??\n", len);
break;
}
uni_name = g_new0 (gunichar2, len/2 + 1);
/* be wary about endianness */
for (i = 0 ; i < len ; i += 2)
uni_name [i/2] = GSF_LE_GET_GUINT16 (data + i);
name = g_utf16_to_utf8 (uni_name, -1, NULL, NULL, NULL);
g_free (uni_name);
printf ("%d %s\n", count, name);
/* ignore this blob ???? */
if (!strncmp ("*\\G", name, 3)) {
if (NULL == ((data = gsf_input_read (dir, 12, NULL)))) {
printf ("len == 0x%x ??\n", len);
break;
}
}
g_free (name);
}
g_return_val_if_fail (count == 0, FALSE);
return TRUE;
}
/**
* tar_init_info :
* @tar : #GsfInfileTar
*
* Read tar headers and do some sanity checking
* along the way.
**/
static void
tar_init_info (GsfInfileTar *tar)
{
TarHeader end;
const TarHeader *header;
gsf_off_t pos0 = gsf_input_tell (tar->source);
char *pending_longname = NULL;
memset (&end, 0, sizeof (end));
while (tar->err == NULL &&
(header = (const TarHeader *)gsf_input_read (tar->source,
HEADER_SIZE,
NULL))) {
char *name;
gsf_off_t length;
gsf_off_t offset;
if (memcmp (header->filler, end.filler, sizeof (end.filler))) {
tar->err = g_error_new (gsf_input_error_id (), 0,
"Invalid tar header");
break;
}
if (memcmp (header, &end, HEADER_SIZE) == 0)
break;
if (pending_longname) {
name = pending_longname;
pending_longname = NULL;
} else
name = g_strndup (header->name, sizeof (header->name));
length = unpack_octal (tar, header->size, sizeof (header->size));
offset = gsf_input_tell (tar->source);
#if 0
g_printerr ("[%s]: %d\n", name, (int)length);
#endif
switch (header->typeflag) {
case '0': case 0: {
/* Regular file. */
GsfInfileTar *dir;
const char *n = name, *s;
TarChild c;
/* This is deliberately slash-only. */
while ((s = strchr (n, '/')))
n = s + 1;
c.name = g_strdup (n);
c.offset = offset;
c.length = length;
c.dir = NULL;
dir = tar_directory_for_file (tar, name, FALSE);
g_array_append_val (dir->children, c);
break;
}
case '5': {
/* Directory */
(void)tar_directory_for_file (tar, name, TRUE);
break;
}
case 'L': {
const char *n;
if (pending_longname ||
strcmp (name, MAGIC_LONGNAME) != 0) {
tar->err = g_error_new (gsf_input_error_id (), 0,
"Invalid longname header");
break;
}
n = gsf_input_read (tar->source, length, NULL);
if (!n) {
tar->err = g_error_new (gsf_input_error_id (), 0,
"Failed to read longname");
break;
}
pending_longname = g_strndup (n, length);
break;
}
default:
/* Other -- ignore */
break;
}
g_free (name);
/* Round up to block size */
length = (length + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE;
if (!tar->err &&
gsf_input_seek (tar->source, offset + length, G_SEEK_SET)) {
tar->err = g_error_new (gsf_input_error_id (), 0,
"Seek failed");
break;
}
}
if (pending_longname) {
if (!tar->err)
tar->err = g_error_new (gsf_input_error_id (), 0,
"Truncated archive");
g_free (pending_longname);
}
if (tar->err)
gsf_input_seek (tar->source, pos0, G_SEEK_SET);
}
/*!
* This method copies the selection defined by pDocRange to ODT format
* placed in the ByteBuf bufODT
*/
UT_Error IE_Exp_OpenDocument::copyToBuffer(PD_DocumentRange * pDocRange,UT_ByteBuf * bufODT)
{
//
// First export selected range to a tempory document
//
PD_Document * outDoc = new PD_Document();
outDoc->createRawDocument();
IE_Exp_DocRangeListener * pRangeListener = new IE_Exp_DocRangeListener(pDocRange,outDoc);
UT_DEBUGMSG(("DocumentRange low %d High %d \n",pDocRange->m_pos1,pDocRange->m_pos2));
PL_ListenerCoupleCloser* pCloser = new PL_ListenerCoupleCloser();
pDocRange->m_pDoc->tellListenerSubset(pRangeListener,pDocRange,pCloser);
if( pCloser)
delete pCloser;
//
// Grab the RDF triples while we are copying...
//
if( PD_DocumentRDFHandle outrdf = outDoc->getDocumentRDF() )
{
std::set< std::string > xmlids;
PD_DocumentRDFHandle inrdf = pDocRange->m_pDoc->getDocumentRDF();
inrdf->addRelevantIDsForRange( xmlids, pDocRange );
if( !xmlids.empty() )
{
UT_DEBUGMSG(("MIQ: ODF export creating restricted RDF model xmlids.sz:%ld \n",(long)xmlids.size()));
PD_RDFModelHandle subm = inrdf->createRestrictedModelForXMLIDs( xmlids );
PD_DocumentRDFMutationHandle m = outrdf->createMutation();
m->add( subm );
m->commit();
subm->dumpModel("copied rdf triples subm");
outrdf->dumpModel("copied rdf triples result");
}
// PD_DocumentRDFMutationHandle m = outrdf->createMutation();
// m->add( PD_URI("http://www.example.com/foo"),
// PD_URI("http://www.example.com/bar"),
// PD_Literal("copyToBuffer path") );
// m->commit();
}
outDoc->finishRawCreation();
//
// OK now we have a complete and valid document containing our selected
// content. We export this to an in memory GSF buffer
//
IE_Exp * pNewExp = NULL;
char *szTempFileName = NULL;
GError *err = NULL;
g_file_open_tmp ("XXXXXX", &szTempFileName, &err);
GsfOutput * outBuf = gsf_output_stdio_new (szTempFileName,&err);
IEFileType ftODT = IE_Exp::fileTypeForMimetype("application/vnd.oasis.opendocument.text");
UT_Error aerr = IE_Exp::constructExporter(outDoc,outBuf,
ftODT,&pNewExp);
if(pNewExp == NULL)
{
return aerr;
}
aerr = pNewExp->writeFile(szTempFileName);
if(aerr != UT_OK)
{
delete pNewExp;
delete pRangeListener;
UNREFP( outDoc);
g_remove(szTempFileName);
g_free (szTempFileName);
return aerr;
}
//
// File is closed at the end of the export. Open it again.
//
GsfInput * fData = gsf_input_stdio_new(szTempFileName,&err);
UT_DebugOnly<UT_sint32> siz = gsf_input_size(fData);
const UT_Byte * pData = gsf_input_read(fData,gsf_input_size(fData),NULL);
UT_DEBUGMSG(("Writing %d bytes to clipboard \n", (UT_sint32)siz));
bufODT->append( pData, gsf_input_size(fData));
delete pNewExp;
delete pRangeListener;
UNREFP( outDoc);
g_remove(szTempFileName);
g_free (szTempFileName);
return aerr;
}
void
html_file_open (G_GNUC_UNUSED GOFileOpener const *fo, GOIOContext *io_context,
WorkbookView *wb_view, GsfInput *input)
{
guint8 const *buf;
gsf_off_t size;
int len, bomlen;
htmlParserCtxtPtr ctxt;
htmlDocPtr doc = NULL;
xmlCharEncoding enc;
GnmHtmlTableCtxt tc;
g_return_if_fail (input != NULL);
if (gsf_input_seek (input, 0, G_SEEK_SET))
return;
size = gsf_input_size (input);
if (size >= 4) {
size -= 4;
buf = gsf_input_read (input, 4, NULL);
if (buf != NULL) {
enc = xmlDetectCharEncoding(buf, 4);
switch (enc) { /* Skip byte order mark */
case XML_CHAR_ENCODING_UCS4BE:
case XML_CHAR_ENCODING_UCS4LE:
case XML_CHAR_ENCODING_UCS4_2143:
case XML_CHAR_ENCODING_UCS4_3412:
case XML_CHAR_ENCODING_EBCDIC:
bomlen = 4;
break;
case XML_CHAR_ENCODING_UTF16BE:
case XML_CHAR_ENCODING_UTF16LE:
bomlen = 2;
break;
case XML_CHAR_ENCODING_UTF8:
if (buf[0] == 0xef)
bomlen = 3;
else if (buf[0] == 0x3c)
bomlen = 4;
else
bomlen = 0;
break;
case XML_CHAR_ENCODING_NONE:
bomlen = 0;
/* Try to detect unmarked UTF16LE
(Firefox Windows clipboard, drag data all platforms) */
if ((buf[0] >= 0x20 || g_ascii_isspace(buf[0])) &&
buf[1] == 0 &&
(buf[2] >= 0x20 || g_ascii_isspace(buf[2])) &&
buf[3] == 0)
enc = XML_CHAR_ENCODING_UTF16LE;
break;
default:
bomlen = 0;
}
ctxt = htmlCreatePushParserCtxt (
NULL, NULL, (char const *)(buf + bomlen),
4 - bomlen, gsf_input_name (input), enc);
for (; size > 0 ; size -= len) {
len = MIN (4096, size);
buf = gsf_input_read (input, len, NULL);
if (buf == NULL)
break;
htmlParseChunk (
ctxt, (char const *)buf, len, 0);
}
htmlParseChunk (ctxt, (char const *)buf, 0, 1);
doc = ctxt->myDoc;
htmlFreeParserCtxt (ctxt);
}
}
if (doc != NULL) {
xmlNodePtr ptr;
tc.sheet = NULL;
tc.row = -1;
tc.wb_view = wb_view;
for (ptr = doc->children; ptr != NULL ; ptr = ptr->next)
html_search_for_tables (ptr, doc, wb_view, &tc);
xmlFreeDoc (doc);
} else
go_io_error_info_set (io_context,
go_error_info_new_str (_("Unable to parse the html.")));
}
static gboolean
csv_tsv_probe (GOFileOpener const *fo, GsfInput *input, GOFileProbeLevel pl)
{
/* Rough and ready heuristic. If the first N bytes have no
* unprintable characters this may be text */
const gsf_off_t N = 512;
if (pl == GO_FILE_PROBE_CONTENT) {
guint8 const *header;
gsf_off_t i;
char const *enc = NULL;
GString *header_utf8;
char const *p;
gboolean ok = TRUE;
if (gsf_input_seek (input, 0, G_SEEK_SET))
return FALSE;
i = gsf_input_remaining (input);
/* If someone ships us an empty file, accept it only if
it has a proper name. */
if (i == 0)
return csv_tsv_probe (fo, input, GO_FILE_PROBE_FILE_NAME);
if (i > N) i = N;
if (NULL == (header = gsf_input_read (input, i, NULL)))
return FALSE;
enc = go_guess_encoding (header, i, NULL, &header_utf8, NULL);
if (!enc)
return FALSE;
for (p = header_utf8->str; *p; p = g_utf8_next_char (p)) {
gunichar uc = g_utf8_get_char (p);
/* isprint might not be true for these: */
if (uc == '\n' || uc == '\t' || uc == '\r')
continue;
/* Also, ignore a byte-order mark which may be used to
* indicate UTF-8; see
* http://en.wikipedia.org/wiki/Byte_Order_Mark for
* background.
*/
if (p == header_utf8->str && uc == 0x0000FEFF) {
continue;
}
if (!g_unichar_isprint (uc)) {
ok = FALSE;
break;
}
}
g_string_free (header_utf8, TRUE);
return ok;
} else {
char const *name = gsf_input_name (input);
if (name == NULL)
return FALSE;
name = gsf_extension_pointer (name);
return (name != NULL &&
(g_ascii_strcasecmp (name, "csv") == 0 ||
g_ascii_strcasecmp (name, "tsv") == 0 ||
g_ascii_strcasecmp (name, "txt") == 0));
}
}
static void make_stream (HwpHWP5File *file, GError **error)
{
GsfInput *input = NULL;
GsfInfile *ole = GSF_INFILE (file->priv->olefile);
gint n_root_entry = gsf_infile_num_children (ole);
if (n_root_entry < 1)
{
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
/* 우선 순위에 따라 스트림을 만든다 */
input = gsf_infile_child_by_name (ole, "FileHeader");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->file_header_stream = input;
input = NULL;
parse_file_header (file);
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "DocInfo");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
if (file->is_compress)
{
GInputStream *gis;
GZlibDecompressor *zd;
GInputStream *cis;
gis = (GInputStream *) gsf_input_stream_new (input);
zd = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_RAW);
cis = g_converter_input_stream_new (gis, (GConverter *) zd);
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (cis), TRUE);
file->doc_info_stream = cis;
g_object_unref (zd);
g_object_unref (gis);
input = NULL;
}
else
{
file->doc_info_stream = (GInputStream *) gsf_input_stream_new (input);
}
}
else
{
goto FAIL;
}
if (!file->is_distribute)
input = gsf_infile_child_by_name (ole, "BodyText");
else
input = gsf_infile_child_by_name (ole, "ViewText");
if (input)
{
for (gint i = 0; i < gsf_infile_num_children (GSF_INFILE (input)); i++)
{
GsfInput *section =
gsf_infile_child_by_name (GSF_INFILE (input),
g_strdup_printf("Section%d", i));
if (gsf_infile_num_children (GSF_INFILE (section)) != -1)
{
if (GSF_IS_INPUT (section))
g_object_unref (section);
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
if (file->is_distribute)
{
guint8 *data = g_malloc0 (256);
gsf_input_read (section, 4, NULL);
gsf_input_read (section, 256, data);
guint32 seed = GSF_LE_GET_GUINT32 (data);
msvc_srand (seed);
gint n = 0, val = 0, offset;
for (guint i = 0; i < 256; i++)
{
if (n == 0)
{
val = msvc_rand() & 0xff;
n = (msvc_rand() & 0xf) + 1;
}
data[i] ^= val;
n--;
}
offset = 4 + (seed & 0xf);
gchar *key = g_malloc0 (16);
memcpy (key, (const gchar *) data + offset, 16);
#ifdef HWP_ENABLE_DEBUG
gchar *sha1 = g_convert ((const gchar *) data + offset, 80,
"UTF-8", "UTF-16LE", NULL, NULL, error);
printf ("sha1: %s\n", sha1);
printf ("key: %s\n", key);
g_free (sha1);
#endif
g_free (data);
EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new ();
EVP_CIPHER_CTX_init (ctx);
EVP_DecryptInit_ex (ctx, EVP_aes_128_ecb(), NULL,
(unsigned char *) key, NULL);
g_free (key);
EVP_CIPHER_CTX_set_padding(ctx, 0); /* no padding */
gsf_off_t encrypted_data_len = gsf_input_remaining (section);
guint8 const *encrypted_data = gsf_input_read (section, encrypted_data_len, NULL);
guint8 *decrypted_data = g_malloc (encrypted_data_len);
int decrypted_data_len, len;
EVP_DecryptUpdate (ctx, decrypted_data, &len, encrypted_data, encrypted_data_len);
decrypted_data_len = len;
EVP_DecryptFinal_ex (ctx, decrypted_data + len, &len);
decrypted_data_len += len;
EVP_CIPHER_CTX_free (ctx);
g_object_unref (section);
section = gsf_input_memory_new (decrypted_data, decrypted_data_len, TRUE);
}
if (file->is_compress)
{
GInputStream *gis;
GZlibDecompressor *zd;
GInputStream *cis;
gis = (GInputStream *) gsf_input_stream_new (section);
zd = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_RAW);
cis = g_converter_input_stream_new (gis, (GConverter *) zd);
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (cis), TRUE);
g_ptr_array_add (file->section_streams, cis);
g_object_unref (zd);
g_object_unref (gis);
}
else
{
GInputStream *stream = (GInputStream *) gsf_input_stream_new (section);
g_ptr_array_add (file->section_streams, stream);
}
} /* for */
g_object_unref (input);
input = NULL;
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "\005HwpSummaryInformation");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->summary_info_stream = input;
input = NULL;
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "BinData");
if (input)
{
gint n_data = gsf_infile_num_children (GSF_INFILE (input));
for (gint i = 0; i < n_data; i++)
{
GsfInput *bin_data_input =
gsf_infile_child_by_index (GSF_INFILE (input), i);
if (gsf_infile_num_children (GSF_INFILE (bin_data_input)) != -1)
{
if (GSF_IS_INPUT (bin_data_input))
g_object_unref (bin_data_input);
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
if (file->is_compress)
{
GInputStream *gis;
GZlibDecompressor *zd;
GInputStream *cis;
gis = (GInputStream *) gsf_input_stream_new (bin_data_input);
zd = g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_RAW);
cis = g_converter_input_stream_new (gis, (GConverter *) zd);
g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (cis), TRUE);
g_ptr_array_add (file->bin_data_streams, cis);
g_object_unref (zd);
g_object_unref (gis);
}
else
{
GInputStream *stream = (GInputStream *) gsf_input_stream_new (bin_data_input);
g_ptr_array_add (file->bin_data_streams, stream);
}
}
g_object_unref (input);
input = NULL;
}
input = gsf_infile_child_by_name (ole, "PrvText");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->prv_text_stream = input;
input = NULL;
}
else
{
goto FAIL;
}
input = gsf_infile_child_by_name (ole, "PrvImage");
if (input && gsf_infile_num_children (GSF_INFILE (input)) == -1)
{
file->prv_image_stream = input;
input = NULL;
}
else
{
goto FAIL;
}
return;
FAIL:
if (GSF_IS_INPUT (input))
g_object_unref (input);
g_set_error_literal (error,
HWP_FILE_ERROR,
HWP_FILE_ERROR_INVALID,
"invalid hwp file");
return;
}
static int
test (unsigned argc, char *argv[])
{
static char const * const stream_names[] = {
"Workbook", "WORKBOOK", "workbook",
"Book", "BOOK", "book"
};
GsfInput *input, *stream, *pcache_dir;
GsfInfile *infile;
GError *err = NULL;
unsigned i, j;
for (i = 1 ; i < argc ; i++) {
fprintf( stderr, "%s\n",argv[i]);
input = gsf_input_mmap_new (argv[i], NULL);
if (input == NULL) /* Only report error if stdio fails too */
input = gsf_input_stdio_new (argv[i], &err);
if (input == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' error: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
continue;
}
input = gsf_input_uncompress (input);
infile = gsf_infile_msole_new (input, &err);
if (infile == NULL) {
g_return_val_if_fail (err != NULL, 1);
g_warning ("'%s' Not an OLE file: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
#ifdef DUMP_CONTENT
dump_biff_stream (input);
#endif
g_object_unref (G_OBJECT (input));
continue;
}
#if 0
stream = gsf_infile_child_by_name (infile, "\01CompObj");
if (stream != NULL) {
gsf_off_t len = gsf_input_size (stream);
guint8 const *data = gsf_input_read (stream, len, NULL);
if (data != NULL)
gsf_mem_dump (data, len);
g_object_unref (G_OBJECT (stream));
}
return 0;
#endif
stream = gsf_infile_child_by_name (infile, "\05SummaryInformation");
if (stream != NULL) {
GsfDocMetaData *meta_data = gsf_doc_meta_data_new ();
puts ( "SummaryInfo");
err = gsf_doc_meta_data_read_from_msole (meta_data, stream);
if (err != NULL) {
g_warning ("'%s' error: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
} else
gsf_doc_meta_dump (meta_data);
g_object_unref (meta_data);
g_object_unref (G_OBJECT (stream));
}
stream = gsf_infile_child_by_name (infile, "\05DocumentSummaryInformation");
if (stream != NULL) {
GsfDocMetaData *meta_data = gsf_doc_meta_data_new ();
puts ( "DocSummaryInfo");
err = gsf_doc_meta_data_read_from_msole (meta_data, stream);
if (err != NULL) {
g_warning ("'%s' error: %s", argv[i], err->message);
g_error_free (err);
err = NULL;
} else
gsf_doc_meta_dump (meta_data);
g_object_unref (meta_data);
g_object_unref (G_OBJECT (stream));
}
for (j = 0 ; j < G_N_ELEMENTS (stream_names) ; j++) {
stream = gsf_infile_child_by_name (infile, stream_names[j]);
if (stream != NULL) {
puts (j < 3 ? "Excel97" : "Excel95");
#ifdef DUMP_CONTENT
dump_biff_stream (stream);
#endif
g_object_unref (G_OBJECT (stream));
break;
}
}
#ifdef DUMP_CONTENT
pcache_dir = gsf_infile_child_by_name (infile, "_SX_DB_CUR"); /* Excel 97 */
if (NULL == pcache_dir)
pcache_dir = gsf_infile_child_by_name (infile, "_SX_DB"); /* Excel 95 */
if (NULL != pcache_dir) {
int i, n = gsf_infile_num_children (infile);
for (i = 0 ; i < n ; i++) {
stream = gsf_infile_child_by_index (GSF_INFILE (pcache_dir), i);
if (stream != NULL) {
printf ("=================================================\nPivot cache '%04hX'\n\n", i);
dump_biff_stream (stream);
g_object_unref (G_OBJECT (stream));
}
}
g_object_unref (G_OBJECT (pcache_dir));
}
#endif
g_object_unref (G_OBJECT (infile));
g_object_unref (G_OBJECT (input));
}
return 0;
}
static gboolean
check_header (GsfInputGZip *input)
{
if (input->raw) {
input->header_size = 0;
input->trailer_size = 0;
} else {
static guint8 const signature[2] = {0x1f, 0x8b};
guint8 const *data;
unsigned flags, len;
/* Check signature */
if (NULL == (data = gsf_input_read (input->source, 2 + 1 + 1 + 6, NULL)) ||
0 != memcmp (data, signature, sizeof (signature)))
return TRUE;
/* verify flags and compression type */
flags = data[3];
if (data[2] != Z_DEFLATED || (flags & ~GZIP_HEADER_FLAGS) != 0)
return TRUE;
/* If we have the size, don't bother seeking to the end. */
if (input->uncompressed_size < 0) {
/* Get the uncompressed size */
if (gsf_input_seek (input->source, (gsf_off_t) -4, G_SEEK_END) ||
NULL == (data = gsf_input_read (input->source, 4, NULL)))
return TRUE;
/* FIXME, but how? The size read here is modulo 2^32. */
input->uncompressed_size = GSF_LE_GET_GUINT32 (data);
if (input->uncompressed_size / 1000 > gsf_input_size (input->source)) {
g_warning ("Suspiciously well compressed file with better than 1000:1 ratio.\n"
"It is probably truncated or corrupt");
}
}
if (gsf_input_seek (input->source, 2 + 1 + 1 + 6, G_SEEK_SET))
return TRUE;
if (flags & GZIP_EXTRA_FIELD) {
if (NULL == (data = gsf_input_read (input->source, 2, NULL)))
return TRUE;
len = GSF_LE_GET_GUINT16 (data);
if (NULL == gsf_input_read (input->source, len, NULL))
return TRUE;
}
if (flags & GZIP_ORIGINAL_NAME) {
/* Skip over the filename (which is in ISO 8859-1 encoding). */
do {
if (NULL == (data = gsf_input_read (input->source, 1, NULL)))
return TRUE;
} while (*data != 0);
}
if (flags & GZIP_HAS_COMMENT) {
/* Skip over the comment (which is in ISO 8859-1 encoding). */
do {
if (NULL == (data = gsf_input_read (input->source, 1, NULL)))
return TRUE;
} while (*data != 0);
}
if (flags & GZIP_HEADER_CRC &&
NULL == (data = gsf_input_read (input->source, 2, NULL)))
return TRUE;
input->header_size = input->source->cur_offset;
/* the last 8 bytes are the crc and size. */
input->trailer_size = 8;
}
gsf_input_set_size (GSF_INPUT (input), input->uncompressed_size);
if (gsf_input_remaining (input->source) < input->trailer_size)
return TRUE; /* No room for payload */
return FALSE;
}
static guint8 const *
gsf_input_gzip_read (GsfInput *input, size_t num_bytes, guint8 *buffer)
{
GsfInputGZip *gzip = GSF_INPUT_GZIP (input);
if (buffer == NULL) {
if (gzip->buf_size < num_bytes) {
gzip->buf_size = MAX (num_bytes, 256);
g_free (gzip->buf);
gzip->buf = g_new (guint8, gzip->buf_size);
}
buffer = gzip->buf;
}
gzip->stream.next_out = buffer;
gzip->stream.avail_out = num_bytes;
while (gzip->stream.avail_out != 0) {
int zerr;
if (gzip->stream.avail_in == 0) {
gsf_off_t remain = gsf_input_remaining (gzip->source);
if (remain <= gzip->trailer_size) {
if (remain < gzip->trailer_size || gzip->stop_byte_added) {
g_clear_error (&gzip->err);
gzip->err = g_error_new
(gsf_input_error_id (), 0,
"truncated source");
return NULL;
}
/* zlib requires an extra byte. */
gzip->stream.avail_in = 1;
gzip->gzipped_data = "";
gzip->stop_byte_added = TRUE;
} else {
size_t n = MIN (remain - gzip->trailer_size,
Z_BUFSIZE);
gzip->gzipped_data =
gsf_input_read (gzip->source, n, NULL);
if (!gzip->gzipped_data) {
g_clear_error (&gzip->err);
gzip->err = g_error_new
(gsf_input_error_id (), 0,
"Failed to read from source");
return NULL;
}
gzip->stream.avail_in = n;
}
gzip->stream.next_in = (Byte *)gzip->gzipped_data;
}
zerr = inflate (&(gzip->stream), Z_NO_FLUSH);
if (zerr != Z_OK) {
if (zerr != Z_STREAM_END)
return NULL;
/* Premature end of stream. */
if (gzip->stream.avail_out != 0)
return NULL;
}
}
gzip->crc = crc32 (gzip->crc, buffer, (uInt)(gzip->stream.next_out - buffer));
return buffer;
}
bool IE_Imp_MSWrite::read_txt (int from, int to)
{
static const char *currcp;
int fcMac, pnChar, fcFirst, cfod, fc, fcLim;
unsigned char page[0x80];
UT_String properties, tmp;
int dataLen = static_cast<UT_sint32>(mData.getLength());
UT_DEBUGMSG((" TXT:\n"));
UT_DEBUGMSG((" from = %d\n", from));
UT_DEBUGMSG((" to = %d\n", to));
fcMac = wri_struct_value(wri_file_header, "fcMac");
pnChar = (fcMac + 127) / 128;
fcFirst = 0x80;
while (true)
{
gsf_input_seek(mFile, pnChar++ * 0x80, G_SEEK_SET);
gsf_input_read(mFile, 0x80, page);
fc = READ_DWORD(page);
cfod = page[0x7f];
UT_DEBUGMSG((" fcFirst = %d\n", fc));
UT_DEBUGMSG((" cfod = %d\n", cfod));
if (fc != fcFirst) UT_WARNINGMSG(("read_txt: fcFirst wrong.\n"));
// read all FODs (format descriptors)
for (int fod = 0; fod < cfod; fod++)
{
int bfprop, cch, ftc, hps, fBold, fItalic, fUline, hpsPos;
UT_DEBUGMSG((" CHP-FOD #%02d:\n", fod + 1));
// read a FOD (format descriptor)
fcLim = READ_DWORD(page + 4 + fod * 6);
bfprop = READ_WORD(page + 8 + fod * 6);
UT_DEBUGMSG((" fcLim = %d\n", fcLim));
UT_DEBUGMSG((bfprop == 0xffff ? " bfprop = 0x%04X\n" : " bfprop = %d\n", bfprop));
// default CHP values
ftc = 0;
hps = 24;
fBold = fItalic = fUline = hpsPos = 0;
// if the CHP FPROPs (formatting properties) differ from the defaults, get them
if (bfprop != 0xffff && bfprop + (cch = page[bfprop + 4]) < 0x80)
{
UT_DEBUGMSG((" cch = %d\n", cch));
if (cch >= 2) ftc = page[bfprop + 6] >> 2;
if (cch >= 5) ftc |= (page[bfprop + 9] & 3) << 6;
if (cch >= 3) hps = page[bfprop + 7];
if (cch >= 2) fBold = page[bfprop + 6] & 1;
if (cch >= 2) fItalic = page[bfprop + 6] & 2;
if (cch >= 4) fUline = page[bfprop + 8] & 1;
if (cch >= 6) hpsPos = page[bfprop + 10];
}
UT_DEBUGMSG((" ftc = %d\n", ftc));
UT_DEBUGMSG((" hps = %d\n", hps));
UT_DEBUGMSG((" fBold = %d\n", fBold));
UT_DEBUGMSG((" fItalic = %d\n", fItalic));
UT_DEBUGMSG((" fUline = %d\n", fUline));
UT_DEBUGMSG((" hpsPos = %d\n", hpsPos));
if (ftc >= wri_fonts_count)
{
UT_WARNINGMSG(("read_txt: Wrong font code.\n"));
ftc = wri_fonts_count - 1;
}
if (from < fcLim && to >= fcFirst)
{
UT_LocaleTransactor lt(LC_NUMERIC, "C");
UT_String_sprintf(properties, "font-weight:%s",
fBold ? "bold" : "normal");
if (hps != 24)
{
UT_String_sprintf(tmp, "; font-size:%dpt", hps / 2);
properties += tmp;
}
if (fItalic) properties += "; font-style:italic";
if (fUline) properties += "; text-decoration:underline";
if (hpsPos)
{
UT_String_sprintf(tmp, "; text-position:%s",
hpsPos < 128 ? "superscript" : "subscript");
properties += tmp;
}
if (wri_fonts_count)
{
UT_String_sprintf(tmp, "; font-family:%s", wri_fonts[ftc].name);
properties += tmp;
}
if (wri_fonts[ftc].codepage != currcp /*sic!*/)
{
set_codepage(wri_fonts[ftc].codepage);
currcp = wri_fonts[ftc].codepage;
}
mText.clear();
UT_DEBUGMSG((" Text: "));
while (fcFirst <= from && from < fcLim && from <= to && from - 0x80 < dataLen)
translate_char(*mData.getPointer(from++ - 0x80), mText);
UT_DEBUGMSG(("\n"));
// new attributes, only if there was text
if (mText.size() > 0)
{
const gchar *attributes[5];
const UT_UCS4Char *text = mText.ucs4_str(), *p = text;
size_t txtLen;
UT_DEBUGMSG((" Conv: %s\n", mText.utf8_str()));
attributes[0] = PT_PROPS_ATTRIBUTE_NAME;
attributes[1] = properties.c_str();
attributes[2] = NULL;
appendFmt(attributes);
// check for page number (should only be in header or footer)
while (*p && *p != (UT_UCS4Char) 0x01) p++;
if (*p)
{
if (p - text) appendSpan(text, p - text);
attributes[2] = PT_TYPE_ATTRIBUTE_NAME;
attributes[3] = "page_number";
attributes[4] = NULL;
appendObject(PTO_Field, attributes);
txtLen = mText.size() - (p - text) - 1;
p++;
}
else
{
txtLen = mText.size();
p = text;
}
if (txtLen) appendSpan(p, txtLen);
}
}
fcFirst = fcLim;
if (fcLim >= fcMac || fcFirst > to)
{
UT_DEBUGMSG((" CHP-FODs end, fcLim (%d) >= fcMac (%d) or fcFirst (%d) > to (%d)\n", fcLim, fcMac, fcFirst, to));
return true;
}
}
}
static void
clone_ (GsfInfile *in, GsfOutfile *out)
{
GsfInput *input = GSF_INPUT (in);
GsfOutput *output = GSF_OUTPUT (out);
if (gsf_input_size (input) > 0) {
size_t len;
while ((len = gsf_input_remaining (input)) > 0) {
guint8 const *data;
/* 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 ?");
break;
}
if (!gsf_output_write (output, len, data)) {
g_warning ("error writing ?");
break;
}
}
} else {
int i, n = gsf_infile_num_children (in);
for (i = 0 ; i < n; i++) {
int level;
gboolean is_dir;
char const *name = gsf_infile_name_by_index (in, i);
char *display_name = name
? g_filename_display_name (name)
: NULL;
input = gsf_infile_child_by_index (in, i);
if (NULL == input) {
g_print ("Error opening '%s, index = %d\n",
display_name ? display_name : "?", i);
g_free (display_name);
continue;
}
is_dir = gsf_infile_num_children (GSF_INFILE (input)) >= 0;
g_object_get (G_OBJECT (input), "compression-level", &level, NULL);
g_print ("%s: size=%ld, level=%d, %s\n",
display_name ? display_name : "?",
(long)gsf_input_size (input),
level,
is_dir ? "directory" : "file");
g_free (display_name);
output = gsf_outfile_new_child_full (out, name, is_dir,
"compression-level", level,
NULL);
clone_ (GSF_INFILE (input), GSF_OUTFILE (output));
}
}
gsf_output_close (GSF_OUTPUT (out));
g_object_unref (G_OBJECT (out));
g_object_unref (G_OBJECT (in));
}
/**
* tracker_gsf_parse_xml_in_zip:
* @zip_file_uri: URI of the ZIP archive
* @xml_filename: Name of the XML file stored inside the ZIP archive
* @context: Markup context to be used when parsing the XML
*
* This function reads and parses the contents of an XML file stored
* inside a ZIP compressed archive. Reading and parsing is done buffered, and
* maximum size of the uncompressed XML file is limited to be to 20MBytes.
*/
void
tracker_gsf_parse_xml_in_zip (const gchar *zip_file_uri,
const gchar *xml_filename,
GMarkupParseContext *context,
GError **err)
{
gchar *filename;
GError *error = NULL;
GsfInfile *infile = NULL;
GsfInput *src = NULL;
GsfInput *member = NULL;
FILE *file;
g_debug ("Parsing '%s' XML file contained inside zip archive...",
xml_filename);
/* Get filename from the given URI */
if ((filename = g_filename_from_uri (zip_file_uri,
NULL, &error)) == NULL) {
g_warning ("Can't get filename from uri '%s': %s",
zip_file_uri, error ? error->message : "no error given");
} else { /* Create a new Input GSF object for the given file */
file = tracker_file_open (filename);
if (!file) {
g_warning ("Can't open file from uri '%s': %s",
zip_file_uri, g_strerror (errno));
} else if ((src = gsf_input_stdio_new_FILE (filename, file, TRUE)) == NULL) {
g_warning ("Failed creating a GSF Input object for '%s': %s",
zip_file_uri, error ? error->message : "no error given");
}
/* Input object is a Zip file */
else if ((infile = gsf_infile_zip_new (src, &error)) == NULL) {
g_warning ("'%s' Not a zip file: %s",
zip_file_uri, error ? error->message : "no error given");
}
/* Look for requested filename inside the ZIP file */
else if ((member = find_member (infile, xml_filename)) == NULL) {
g_warning ("No member '%s' in zip file '%s'",
xml_filename, zip_file_uri);
}
/* Load whole contents of the internal file in the xml buffer */
else {
guint8 buf[XML_BUFFER_SIZE];
size_t remaining_size, chunk_size, accum;
/* Get whole size of the contents to read */
remaining_size = (size_t) gsf_input_size (GSF_INPUT (member));
/* Note that gsf_input_read() needs to be able to read ALL specified
* number of bytes, or it will fail */
chunk_size = MIN (remaining_size, XML_BUFFER_SIZE);
accum = 0;
while (!error &&
accum <= XML_MAX_BYTES_READ &&
chunk_size > 0 &&
gsf_input_read (GSF_INPUT (member), chunk_size, buf) != NULL) {
/* update accumulated count */
accum += chunk_size;
/* Pass the read stream to the context parser... */
g_markup_parse_context_parse (context, buf, chunk_size, &error);
/* update bytes to be read */
remaining_size -= chunk_size;
chunk_size = MIN (remaining_size, XML_BUFFER_SIZE);
}
}
if (file) {
tracker_file_close (file, FALSE);
}
}
g_free (filename);
if (error)
g_propagate_error (err, error);
if (infile)
g_object_unref (infile);
if (src)
g_object_unref (src);
if (member)
g_object_unref (member);
}
/* return value: 1 == success 0 == failure */
int
wvGetPICF (wvVersion ver, PICF * apicf, wvStream * fd)
{
U8 temp;
U32 i;
U8 *buf,*p;
size_t size;
long pos = wvStream_tell (fd);
apicf->lcb = read_32ubit (fd);
apicf->cbHeader = read_16ubit (fd);
wvTrace (("size of pic is %x (%d)\n", apicf->cbHeader, apicf->cbHeader));
apicf->mfp_mm = (S16) read_16ubit (fd);
wvTrace (("mm type is %d\n", apicf->mfp_mm));
apicf->mfp_xExt = (S16) read_16ubit (fd);
apicf->mfp_yExt = (S16) read_16ubit (fd);
apicf->mfp_hMF = (S16) read_16ubit (fd);
if (apicf->mfp_mm == 99)
wvGetBITMAP (&(apicf->obj.bitmap), fd);
else
wvGetrc (&(apicf->obj.arc), fd);
apicf->dxaGoal = (S16) read_16ubit (fd);
apicf->dyaGoal = (S16) read_16ubit (fd);
apicf->mx = read_16ubit (fd);
apicf->my = read_16ubit (fd);
apicf->dxaCropLeft = (S16) read_16ubit (fd);
apicf->dyaCropTop = (S16) read_16ubit (fd);
apicf->dxaCropRight = (S16) read_16ubit (fd);
apicf->dyaCropBottom = (S16) read_16ubit (fd);
temp = read_8ubit (fd);
apicf->brcl = temp & 0x0F;
apicf->fFrameEmpty = (temp & 0x10) >> 4;
apicf->fBitmap = (temp & 0x20) >> 5;
wvTrace (("bitmap is %d\n", apicf->fBitmap));
apicf->fDrawHatch = (temp & 0x40) >> 6;
apicf->fError = (temp & 0x80) >> 7;
apicf->bpp = read_8ubit (fd);
wvGetBRC (ver, &(apicf->brcTop), fd);
wvGetBRC (ver, &(apicf->brcLeft), fd);
wvGetBRC (ver, &(apicf->brcBottom), fd);
wvGetBRC (ver, &(apicf->brcRight), fd);
apicf->dxaOrigin = (S16) read_16ubit (fd);
apicf->dyaOrigin = (S16) read_16ubit (fd);
if (ver == WORD8)
apicf->cProps = (S16) read_16ubit (fd);
else
apicf->cProps = 0;
pos = wvStream_tell (fd) - pos;
for (i = pos; i < apicf->cbHeader; i++)
read_8ubit (fd);
wvTrace (("pos is finally %x\n", wvStream_tell (fd)));
wvTrace (("len of data is %d\n", apicf->lcb - apicf->cbHeader));
wvTrace (
("ends at %x\n",
wvStream_tell (fd) + apicf->lcb - apicf->cbHeader));
i = 0;
if (apicf->mfp_mm < 90){
MSOFBH bse_pic_amsofbh;
size_t lHeaderSize;
size_t lWordStructsSize;
U8 *pHeader;
U8 *pWordStructs;
U32 len;
U32 j;
U8 bmp_header[40];
U32 header_len;
U32 colors_used;
U16 bpp;
pWordStructs = pHeader = 0;
wvTrace (("test\n"));
len = apicf->lcb - apicf->cbHeader;
/*[email protected] store*/
pos = wvStream_tell (fd);
i = wvEatOldGraphicHeader (fd, len);
if(i!=-1)/*Found BMP */
{
wvTrace (("len is %d, header len guess is %d\n", len, i));
if (i + 2 >= len)
{
wvTrace (("all read ok methinks\n"));
apicf->rgb = NULL;
return 1;
}
len -= i;
pos = wvStream_tell (fd);
for(j=0;j< sizeof(bmp_header);j++)
bmp_header[j] = read_8ubit (fd);
bpp = bmp_header[14] + (bmp_header[15] << 8);
if ( bpp < 9)
{
colors_used = bmp_header[32]
+ (bmp_header[33] << 8)
+ (bmp_header[34] << 16)
+ (bmp_header[35] << 24);
}
else
{
colors_used = 0;
}
wvStream_goto(fd,pos);
header_len = 14 + 40 + 4 * colors_used;
/*Get Blip Header Size*/
lHeaderSize = PutWord8BitmapHeader(apicf, 0, len + i-14, header_len);
pHeader = malloc(lHeaderSize);
/*Write Blip Header*/
PutWord8BitmapHeader(apicf, pHeader, len, header_len);
/*Set Type of FBSE Header*/
bse_pic_amsofbh.ver = 0;
bse_pic_amsofbh.inst = msobiDIB;
bse_pic_amsofbh.fbt = msofbtBlipFirst + msoblipDIB;/*msoblipJPEG msoblipPNG*/
bse_pic_amsofbh.cbLength = lHeaderSize+len;
}else{/*must be WMF*/
/*Get Blip Header Size*/
lHeaderSize = PutWord8MetafileHeader(apicf, 0);
pHeader = malloc(lHeaderSize);
/*Write Blip Header*/
PutWord8MetafileHeader(apicf, pHeader);
/*Set Type of FBSE Header*/
bse_pic_amsofbh.ver = 0;
bse_pic_amsofbh.inst = msobiWMF;
bse_pic_amsofbh.fbt = msofbtBlipFirst + msoblipWMF;
bse_pic_amsofbh.cbLength = lHeaderSize+len;
i = 0;
wvStream_goto(fd,pos);
}
lWordStructsSize = PutWord8Structs(&bse_pic_amsofbh, 0,0);
pWordStructs = malloc(lWordStructsSize);
PutWord8Structs(&bse_pic_amsofbh, pWordStructs, lWordStructsSize);
size = lHeaderSize + lWordStructsSize + apicf->lcb - apicf->cbHeader;
p = buf = malloc(size);
if(!p)
{
free(pWordStructs);
free(pHeader);
return 0;
}
memcpy(p, pWordStructs, lWordStructsSize);
p+= lWordStructsSize;
memcpy(p, pHeader, lHeaderSize);
p+=lHeaderSize;
free(pWordStructs);
free(pHeader);
}
else{
size = apicf->lcb - apicf->cbHeader;
p = buf = malloc(size);
}
#if 0
for (; i < apicf->lcb - apicf->cbHeader; i++)
*p++ = read_8ubit (fd);
#endif
U32 length = apicf->lcb - apicf->cbHeader - i;
if (fd->kind == GSF_STREAM)
{
gsf_input_read (GSF_INPUT (fd->stream.gsf_stream), length, p);
p += length;
}
else if (fd->kind == FILE_STREAM)
{
fread(p, sizeof(guint8), length, fd->stream.file_stream);
p += length;
}
else
{
memorystream_read(fd->stream.memory_stream, p, length);
p += length;
}
/* f = fopen("test.dat","wb");
fwrite(buf, 1,size, f);
fclose(f);
*/
wvStream_memory_create(&apicf->rgb, (char*)buf, size);
return 1;
}
gint XAP_UnixDialog_FileOpenSaveAs::previewPicture (void)
{
UT_ASSERT (m_FC && m_preview);
UT_ASSERT(XAP_App::getApp());
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_return_val_if_fail( pSS, 0 );
// attach and clear the area immediately
GR_UnixCairoAllocInfo ai(m_preview);
GR_CairoGraphics* pGr =
(GR_CairoGraphics*) XAP_App::getApp()->newGraphics(ai);
const gchar * file_name = gtk_file_chooser_get_uri (m_FC);
GR_Font * fnt = pGr->findFont("Times New Roman",
"normal", "", "normal",
"", "12pt",
pSS->getLanguageName());
pGr->setFont(fnt);
UT_UTF8String str;
pSS->getValueUTF8(XAP_STRING_ID_DLG_IP_No_Picture_Label, str);
int answer = 0;
FG_Graphic * pGraphic = 0;
GR_Image *pImage = NULL;
double scale_factor = 0.0;
UT_sint32 scaled_width,scaled_height;
UT_sint32 iImageWidth,iImageHeight;
{
GR_Painter painter(pGr);
painter.clearArea(0, 0, pGr->tlu(m_preview->allocation.width), pGr->tlu(m_preview->allocation.height));
if (!file_name)
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
goto Cleanup;
}
// are we dealing with a file or directory here?
struct stat st;
if (!stat (file_name, &st))
{
if (!S_ISREG(st.st_mode))
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
goto Cleanup;
}
}
GsfInput * input = NULL;
UT_DEBUGMSG(("file_name %s \n",file_name));
input = UT_go_file_open (file_name, NULL);
if (!input)
goto Cleanup;
char Buf[4097] = ""; // 4096+nul ought to be enough
UT_uint32 iNumbytes = UT_MIN(4096, gsf_input_size(input));
gsf_input_read(input, iNumbytes, (guint8 *)(Buf));
Buf[iNumbytes] = '\0';
IEGraphicFileType ief = IE_ImpGraphic::fileTypeForContents(Buf,4096);
if((ief == IEGFT_Unknown) || (ief == IEGFT_Bogus))
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
g_object_unref (G_OBJECT (input));
goto Cleanup;
}
g_object_unref (G_OBJECT (input));
input = UT_go_file_open (file_name, NULL);
size_t num_bytes = gsf_input_size(input);
UT_Byte * bytes = (UT_Byte *) gsf_input_read(input, num_bytes,NULL );
if(bytes == NULL)
{
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
g_object_unref (G_OBJECT (input));
goto Cleanup;
}
UT_ByteBuf * pBB = new UT_ByteBuf();
pBB->append(bytes,num_bytes);
g_object_unref (G_OBJECT (input));
//
// OK load the data into a GdkPixbuf
//
bool bLoadFailed = false;
//
GdkPixbuf * pixbuf = pixbufForByteBuf ( pBB);
delete pBB;
if(pixbuf == NULL)
{
//
// Try a fallback loader here.
//
painter.drawChars (str.ucs4_str().ucs4_str(), 0, str.size(), pGr->tlu(12), pGr->tlu(static_cast<int>(m_preview->allocation.height / 2)) - pGr->getFontHeight(fnt)/2);
bLoadFailed = true;
goto Cleanup;
}
pImage = new GR_UnixImage(NULL,pixbuf);
iImageWidth = gdk_pixbuf_get_width (pixbuf);
iImageHeight = gdk_pixbuf_get_height (pixbuf);
if (m_preview->allocation.width >= iImageWidth && m_preview->allocation.height >= iImageHeight)
scale_factor = 1.0;
else
scale_factor = MIN( static_cast<double>(m_preview->allocation.width)/iImageWidth,
static_cast<double>(m_preview->allocation.height)/iImageHeight);
scaled_width = static_cast<int>(scale_factor * iImageWidth);
scaled_height = static_cast<int>(scale_factor * iImageHeight);
static_cast<GR_UnixImage *>(pImage)->scale(scaled_width,scaled_height);
painter.drawImage(pImage,
pGr->tlu(static_cast<int>((m_preview->allocation.width - scaled_width ) / 2)),
pGr->tlu(static_cast<int>((m_preview->allocation.height - scaled_height) / 2)));
answer = 1;
}
Cleanup:
FREEP(file_name);
DELETEP(pImage);
DELETEP(pGr);
DELETEP(pGraphic);
return answer;
}
/*!
Get next byte from file
\param b Reference to the byte
*/
bool ImportStreamFile::_getByte(unsigned char &b)
{
UT_return_val_if_fail(m_pFile, false);
return (gsf_input_read(m_pFile, 1, &b) != NULL);
}
/**
* gsf_input_textline_utf8_gets:
* @textline: #GsfInputTextline
*
* A utility routine to read things line by line from the underlying source.
* Trailing newlines and carriage returns are stripped, and the resultant buffer
* can be edited.
*
* Returns: (transfer none): the string read, or %NULL on eof.
**/
guint8 *
gsf_input_textline_utf8_gets (GsfInputTextline *textline)
{
guint8 const *ptr ,*end;
unsigned len, count = 0;
g_return_val_if_fail (textline != NULL, NULL);
while (1) {
if (textline->remainder == NULL ||
textline->remainder_size == 0) {
gsf_off_t remain = gsf_input_remaining (textline->source);
len = MIN (remain, textline->max_line_size);
textline->remainder = gsf_input_read (textline->source, len, NULL);
if (textline->remainder == NULL)
return NULL;
textline->remainder_size = len;
}
ptr = textline->remainder;
end = ptr + textline->remainder_size;
for (; ptr < end ; ptr++)
if (*ptr == '\n' || *ptr == '\r')
break;
/* copy the remains into the buffer, grow it if necessary */
len = ptr - textline->remainder;
if (count + len >= textline->buf_size) {
textline->buf_size += len;
textline->buf = g_renew (guint8, textline->buf,
textline->buf_size + 1);
}
g_return_val_if_fail (textline->buf != NULL, NULL);
memcpy (textline->buf + count, textline->remainder, len);
count += len;
if (ptr < end) {
unsigned char last = ptr[0];
/* eat the trailing eol marker: \n, \r\n, or \r. */
ptr++;
if (ptr >= end && last == '\r') {
/* be extra careful, the CR is at the bound */
if (gsf_input_remaining (textline->source) > 0) {
ptr = gsf_input_read (textline->source, 1, NULL);
if (ptr == NULL)
return NULL;
textline->remainder = ptr;
textline->remainder_size = 1;
end = ptr + 1;
} else
ptr = end = NULL;
}
if (ptr != NULL && last == '\r' && *ptr == '\n')
ptr++;
break;
} else if (gsf_input_remaining (textline->source) <= 0) {
ptr = end = NULL;
break;
} else
textline->remainder = NULL;
}
textline->remainder = ptr;
textline->remainder_size = end - ptr;
textline->buf[count] = '\0';
return textline->buf;
}
UT_Error ODc_Crypto::performDecrypt(GsfInput* pStream,
unsigned char* salt, UT_uint32 salt_length, UT_uint32 iter_count,
unsigned char* ivec, const std::string& password, UT_uint32 decrypted_size,
GsfInput** pDecryptedInput)
{
unsigned char sha1_password[PASSWORD_HASH_LEN];
char key[PBKDF2_KEYLEN];
// get the sha1 sum of the password
sha1_buffer(&password[0], password.size(), sha1_password);
// create a PBKDF2 key from the sha1 sum
int k = pbkdf2_sha1 ((const char*)sha1_password, PASSWORD_HASH_LEN, (const char*)salt, salt_length, iter_count, key, PBKDF2_KEYLEN);
if (k != 0)
return UT_ERROR;
// create the decryption key
BF_KEY bf_key;
BF_set_key(&bf_key, PBKDF2_KEYLEN, (const unsigned char*)key);
// perform the actual decryption
UT_sint32 content_size = gsf_input_size(pStream);
if (content_size == -1)
return UT_ERROR;
const unsigned char* content = gsf_input_read(pStream, content_size, NULL);
if (!content)
return UT_ERROR;
int num = 0;
unsigned char* content_decrypted = (unsigned char*)g_malloc(content_size);
BF_cfb64_encrypt(content, content_decrypted, content_size, &bf_key, ivec, &num, BF_DECRYPT);
// deflate the decrypted content
z_stream zs;
zs.zalloc = Z_NULL;
zs.zfree = Z_NULL;
zs.opaque = Z_NULL;
zs.avail_in = 0;
zs.next_in = Z_NULL;
int err;
err = inflateInit2(&zs, -MAX_WBITS);
if (err != Z_OK)
return UT_ERROR;
unsigned char* decrypted = (unsigned char*)g_malloc(decrypted_size);
zs.avail_in = content_size;
zs.avail_out = decrypted_size;
zs.next_in = content_decrypted;
zs.next_out = decrypted;
err = inflate(&zs, Z_FINISH);
FREEP(content_decrypted);
if (err != Z_STREAM_END)
{
inflateEnd(&zs);
FREEP(decrypted);
return UT_ERROR;
}
inflateEnd(&zs);
*pDecryptedInput = gsf_input_memory_new(decrypted, decrypted_size, TRUE);
return UT_OK;
}
UT_Error IE_Imp_MSWrite::parse_file ()
{
int id, size;
UT_Byte *thetext;
if (!read_wri_struct(wri_file_header, mFile)) return UT_ERROR;
UT_DEBUGMSG(("File Header:\n"));
DEBUG_WRI_STRUCT(wri_file_header);
id = wri_struct_value(wri_file_header, "wIdent");
if (id == 0137062)
{
// okay, but expect OLE objects
}
else if (id != 0137061)
{
UT_WARNINGMSG(("parse_file: Not a write file!\n"));
return UT_ERROR;
}
if (wri_struct_value(wri_file_header, "wTool") != 0125400)
{
UT_WARNINGMSG(("parse_file: Not a write file!\n"));
return UT_ERROR;
}
size = wri_struct_value(wri_file_header, "fcMac") - 0x80;
thetext = static_cast<UT_Byte *>(malloc(size));
if (!thetext)
{
UT_WARNINGMSG(("parse_file: Out of memory!\n"));
return UT_ERROR;
}
if (gsf_input_seek(mFile, 0x80, G_SEEK_SET))
{
UT_WARNINGMSG(("parse_file: Can't seek data!\n"));
return UT_ERROR;
}
gsf_input_read(mFile, size, thetext);
if (!read_ffntb())
{
free(thetext);
return UT_ERROR;
}
mData.truncate(0);
mData.append(thetext, size);
free(thetext);
read_sep();
read_pap(All);
UT_DEBUGMSG(("Header: %d, on first page: %d\n", hasHeader, page1Header));
if (hasHeader)
{
_append_hdrftr(header);
read_pap(Header);
if (!page1Header) _append_hdrftr(headerfirst); // an empty one
}
UT_DEBUGMSG(("Footer: %d, on first page: %d\n", hasFooter, page1Footer));
if (hasFooter)
{
_append_hdrftr(footer);
read_pap(Footer);
if (!page1Footer) _append_hdrftr(footerfirst); // an empty one
}
free_ffntb();
return UT_OK;
}
UT_Error IE_Imp_PalmDoc::_parseFile(GsfInput * pdfp)
{
UT_GrowBuf gbBlock(1024);
bool bEatLF = false;
bool bEmptyFile = true;
UT_UCSChar c;
UT_UCS4Char wc;
pdb_header header;
doc_record0 rec0;
bool bCompressed = false;
int num_records, rec_num;
DWord file_size, offset;
gsf_input_read( pdfp, PDB_HEADER_SIZE, (guint8*)&header);
if (strncmp( header.type, DOC_TYPE, sizeof(header.type) ) ||
strncmp( header.creator, DOC_CREATOR, sizeof(header.creator) ))
{
UT_DEBUGMSG(("This is not a DOC file!\n"));
// Create an empty paragraph.
X_ReturnNoMemIfError(appendStrux(PTX_Block, NULL));
return UT_OK;
}
num_records = _swap_Word( header.numRecords ) - 1;
gsf_input_seek( pdfp, PDB_HEADER_SIZE, G_SEEK_SET );
GET_DWord( pdfp, offset );
gsf_input_seek( pdfp, offset, G_SEEK_SET );
gsf_input_read( pdfp, sizeof(rec0), (guint8*)&rec0);
if ( _swap_Word( rec0.version ) == 2 )
bCompressed = true;
gsf_input_seek( pdfp, 0, G_SEEK_END );
file_size = gsf_input_tell( pdfp );
for (rec_num = 1; rec_num <= num_records; ++rec_num )
{
DWord next_offset;
gsf_input_seek( pdfp, PDB_HEADER_SIZE + PDB_RECORD_HEADER_SIZE * rec_num, G_SEEK_SET);
GET_DWord( pdfp, offset );
if( rec_num < num_records )
{
gsf_input_seek( pdfp, PDB_HEADER_SIZE + PDB_RECORD_HEADER_SIZE * (rec_num + 1), G_SEEK_SET);
GET_DWord( pdfp, next_offset );
}
else
next_offset = file_size;
gsf_input_seek( pdfp, offset, G_SEEK_SET );
// be overly cautious here
_zero_fill (m_buf->buf, BUFFER_SIZE);
gsf_input_read(pdfp, next_offset - offset, m_buf->buf);
m_buf->position = next_offset - offset;
if ( bCompressed )
_uncompress( m_buf );
m_buf->position = 0;
while ( (m_buf->position) < (m_buf->len) )
{
// don't copy over null chars
if (m_buf->buf[m_buf->position] == '\0')
{
++m_buf->position;
continue;
}
if( !m_Mbtowc.mbtowc( wc, m_buf->buf[m_buf->position] ) )
continue;
c = static_cast<UT_UCSChar>(wc);
switch (c)
{
case static_cast<UT_UCSChar>('\r'):
case static_cast<UT_UCSChar>('\n'):
if ((c == static_cast<UT_UCSChar>('\n')) && bEatLF)
{
bEatLF = false;
break;
}
if (c == static_cast<UT_UCSChar>('\r'))
{
bEatLF = true;
}
// we interprete either CRLF, CR, or LF as a paragraph break.
// start a paragraph and emit any text that we
// have accumulated.
X_ReturnNoMemIfError(appendStrux(PTX_Block, NULL));
bEmptyFile = false;
if (gbBlock.getLength() > 0)
{
X_ReturnNoMemIfError(appendSpan(reinterpret_cast<const UT_UCSChar*>(gbBlock.getPointer(0)), gbBlock.getLength()));
gbBlock.truncate(0);
}
break;
default:
bEatLF = false;
X_ReturnNoMemIfError(gbBlock.ins(gbBlock.getLength(),reinterpret_cast<const UT_GrowBufElement *>(&c),1));
break;
}
++m_buf->position;
}
}
if (gbBlock.getLength() > 0 || bEmptyFile)
{
// if we have text left over (without final CR/LF),
// or if we read an empty file,
// create a paragraph and emit the text now.
X_ReturnNoMemIfError(appendStrux(PTX_Block, NULL));
if (gbBlock.getLength() > 0)
X_ReturnNoMemIfError(appendSpan(reinterpret_cast<const UT_UCSChar *>(gbBlock.getPointer(0)), gbBlock.getLength()));
}
return UT_OK;
}
bool IE_Imp_MSWrite::read_ffntb ()
{
int pnFfntb, pnMac, fonts_count = 0, cbFfn, fflen;
unsigned char buf[2], ffid;
wri_font *fonts;
char *ffn;
UT_DEBUGMSG(("Fonts:\n"));
pnFfntb = wri_struct_value(wri_file_header, "pnFfntb");
pnMac = wri_struct_value(wri_file_header, "pnMac");
// if pnFfntb is the same as pnMac, there are no fonts
if (pnFfntb == pnMac)
{
UT_DEBUGMSG((" (none)\n"));
return true;
}
if (gsf_input_seek(mFile, pnFfntb++ * 0x80, G_SEEK_SET))
{
UT_WARNINGMSG(("read_ffntb: Can't seek FFNTB!\n"));
return false;
}
// the first two bytes are the number of fonts
if (!gsf_input_read(mFile, 2, buf))
{
UT_WARNINGMSG(("read_ffntb: Can't read FFNTB!\n"));
return false;
}
wri_fonts_count = READ_WORD(buf);
UT_DEBUGMSG((" reported: %d\n", wri_fonts_count));
while (true)
{
if (!gsf_input_read(mFile, 2, buf))
{
UT_WARNINGMSG(("read_ffntb: Can't read cbFfn!\n"));
wri_fonts_count = fonts_count;
free_ffntb();
return false;
}
cbFfn = READ_WORD(buf);
if (cbFfn == 0) break;
if (cbFfn == 0xffff)
{
if (gsf_input_seek(mFile, pnFfntb++ * 0x80, G_SEEK_SET))
{
UT_WARNINGMSG(("read_ffntb: Can't seek next FFNTB!\n"));
wri_fonts_count = fonts_count;
free_ffntb();
return false;
}
continue;
}
// add one more font
fonts = (wri_font *) realloc(wri_fonts, (fonts_count + 1) * sizeof(wri_font));
if (!fonts)
{
UT_WARNINGMSG(("read_ffntb: Out of memory!\n"));
wri_fonts_count = fonts_count;
free_ffntb();
return false;
}
wri_fonts = fonts;
// This is the font family identifier. It can either be FF_DONTCARE,
// FF_ROMAN, FF_SWISS, FF_MODERN, FF_SCRIPT or FF_DECORATIVE. These
// are defined in <windows.h>, but I don't know what to do with them.
if (!gsf_input_read(mFile, 1, &ffid))
{
UT_WARNINGMSG(("read_ffntb: Can't read ffid!\n"));
wri_fonts_count = fonts_count;
free_ffntb();
return false;
}
wri_fonts[fonts_count].ffid = ffid;
cbFfn--; // we've already read ffid
ffn = static_cast<char *>(malloc(cbFfn));
if (!ffn)
{
UT_WARNINGMSG(("read_ffntb: Out of memory!\n"));
wri_fonts_count = fonts_count;
free_ffntb();
return false;
}
if (!gsf_input_read(mFile, cbFfn, (guint8 *) ffn))
{
UT_WARNINGMSG(("read_ffntb: Can't read szFfn!\n"));
wri_fonts_count = fonts_count + 1;
free_ffntb();
return false;
}
wri_fonts[fonts_count].codepage = get_codepage(ffn, &fflen);
ffn[fflen] = 0;
wri_fonts[fonts_count].name = ffn;
UT_DEBUGMSG((" %2d: %s (%s)\n", fonts_count, wri_fonts[fonts_count].name, wri_fonts[fonts_count].codepage));
fonts_count++;
}
if (fonts_count != wri_fonts_count)
{
wri_fonts_count = fonts_count;
UT_WARNINGMSG(("read_ffntb: Wrong number of fonts.\n"));
}
return true;
}
bool IE_Imp_MSWrite::read_sep ()
{
int pnSep, pnSetb;
int yaMac, xaMac, yaTop, dyaText, dxaText, rStartPage, yaHeader, yaFooter;
int cch, yaBot;
unsigned char sep[0x80];
UT_DEBUGMSG(("SEP:\n"));
pnSep = wri_struct_value(wri_file_header, "pnSep");
pnSetb = wri_struct_value(wri_file_header, "pnSetb");
// default SEP values
yaMac = 15840;
xaMac = 12240;
yaTop = 1440;
dyaText = 12960;
dxaText = 8640;
xaLeft = 1800;
rStartPage = 0xFFFF;
yaHeader = 1080;
yaFooter = 15760;
// if the section properties differ from the defaults, get them
if (pnSep != pnSetb)
{
gsf_input_seek(mFile, pnSep * 0x80, G_SEEK_SET);
gsf_input_read(mFile, 0x80, sep);
cch = *sep;
UT_DEBUGMSG((" cch = %d\n", cch));
if (cch >= 4) yaMac = READ_WORD(sep + 3);
if (cch >= 6) xaMac = READ_WORD(sep + 5);
if (cch >= 8) rStartPage = READ_WORD(sep + 7);
if (cch >= 10) yaTop = READ_WORD(sep + 9);
if (cch >= 12) dyaText = READ_WORD(sep + 11);
if (cch >= 14) xaLeft = READ_WORD(sep + 13);
if (cch >= 16) dxaText = READ_WORD(sep + 15);
if (cch >= 20) yaHeader = READ_WORD(sep + 19);
if (cch >= 22) yaFooter = READ_WORD(sep + 21);
}
if (rStartPage & 0x8000) rStartPage = -0x10000 + rStartPage;
UT_DEBUGMSG((" yaMac = %d\n", yaMac));
UT_DEBUGMSG((" xaMac = %d\n", xaMac));
UT_DEBUGMSG((" rStartPage = %d\n", rStartPage));
UT_DEBUGMSG((" yaTop = %d\n", yaTop));
UT_DEBUGMSG((" dyaText = %d\n", dyaText));
UT_DEBUGMSG((" xaLeft = %d\n", xaLeft));
UT_DEBUGMSG((" dxaText = %d\n", dxaText));
UT_DEBUGMSG((" yaHeader = %d\n", yaHeader));
UT_DEBUGMSG((" yaFooter = %d\n", yaFooter));
yaBot = yaMac - yaTop - dyaText;
xaRight = xaMac - xaLeft - dxaText;
UT_String properties;
UT_LocaleTransactor lt(LC_NUMERIC, "C");
UT_String_sprintf(properties, "page-margin-header:%.4fin; "
"page-margin-right:%.4fin; "
"page-margin-left:%.4fin; "
"page-margin-top:%.4fin; "
"page-margin-bottom:%.4fin; "
"page-margin-footer:%.4fin",
static_cast<float>(yaHeader) / 1440.0,
static_cast<float>(xaRight) / 1440.0,
static_cast<float>(xaLeft) / 1440.0,
static_cast<float>(yaTop) / 1440.0,
static_cast<float>(yaBot) / 1440.0,
static_cast<float>(yaMac - yaFooter) / 1440.0);
if (rStartPage >= 0)
{
UT_String tmp;
UT_String_sprintf(tmp, "; section-restart:1"
"; section-restart-value:%d", rStartPage);
properties += tmp;
}
const gchar *attributes[11];
attributes[0] = PT_PROPS_ATTRIBUTE_NAME;
attributes[1] = properties.c_str();
attributes[2] = PT_HEADERFIRST_ATTRIBUTE_NAME;
attributes[3] = "0";
attributes[4] = PT_HEADER_ATTRIBUTE_NAME;
attributes[5] = "1";
attributes[6] = PT_FOOTERFIRST_ATTRIBUTE_NAME;
attributes[7] = "2";
attributes[8] = PT_FOOTER_ATTRIBUTE_NAME;
attributes[9] = "3";
attributes[10] = NULL;
appendStrux(PTX_Section, attributes);
return true;
}
void AbiCollabSessionManager::loadProfile()
{
UT_DEBUGMSG(("AbiCollabSessionManager::loadProfile()\n"));
gchar *s = g_build_filename(XAP_App::getApp()->getUserPrivateDirectory(),
"AbiCollab.Profile", (void*)0);
UT_UTF8String profile(s);
FREEP(s);
GsfInput* in = NULL;
char *uri = UT_go_filename_to_uri(profile.utf8_str());
UT_return_if_fail(uri);
in = UT_go_file_open(uri, NULL); // TODO: shouldn't use NULL here, but check for errors
FREEP(uri);
if (!in)
return;
guint8 const* contents = gsf_input_read(in, gsf_input_size(in), NULL);
if (contents)
{
xmlDocPtr reader = xmlReadMemory(reinterpret_cast<const char*>(contents),
strlen(reinterpret_cast<const char*>(contents)), 0, "UTF-8", 0);
if (reader)
{
xmlNode* node = xmlDocGetRootElement(reader);
if (node)
{
if (strcmp(reinterpret_cast<const char*>(node->name), "AbiCollabProfile") == 0)
{
for (xmlNode* accountNode = node->children; accountNode; accountNode = accountNode->next)
{
// TODO: check if this node is really an AccountHandler node
// find the account handler belonging to this type
xmlChar* prop = xmlGetProp(accountNode, BAD_CAST "type");
UT_UTF8String handlerType = reinterpret_cast<char *>(prop);
xmlFree(prop);
std::map<UT_UTF8String, AccountHandlerConstructor>::iterator handler_iter = m_regAccountHandlers.find(handlerType);
if (handler_iter == m_regAccountHandlers.end())
continue; // could happen for example when the sugar backend is found in the profile, which does not have a registered account handler belowing to it for now
AccountHandlerConstructor constructor = handler_iter->second;
AccountHandler* pHandler = constructor();
UT_continue_if_fail(pHandler);
for (xmlNode* accountProp = accountNode->children; accountProp; accountProp = accountProp->next)
{
if (accountProp->type == XML_ELEMENT_NODE)
{
// some node names are pre-defined...
if (strcmp(reinterpret_cast<const char*>(accountProp->name), "buddies") == 0)
{
for (xmlNode* buddyNode = accountProp->children; buddyNode; buddyNode = buddyNode->next)
{
if (buddyNode->type != XML_ELEMENT_NODE)
continue;
UT_continue_if_fail(strcmp(reinterpret_cast<const char*>(buddyNode->name), "buddy") == 0);
UT_continue_if_fail(buddyNode->children);
// read all buddy properties
PropertyMap vBuddyProps;
for (xmlNode* buddyPropertyNode = buddyNode->children; buddyPropertyNode; buddyPropertyNode = buddyPropertyNode->next)
{
UT_continue_if_fail(buddyPropertyNode->type == XML_ELEMENT_NODE);
UT_UTF8String buddyPropValue = reinterpret_cast<const char*>(xmlNodeGetContent(buddyPropertyNode));
UT_continue_if_fail(buddyPropertyNode->name && *buddyPropertyNode->name && buddyPropValue.size() > 0);
vBuddyProps.insert(PropertyMap::value_type(
reinterpret_cast<const char*>(buddyPropertyNode->name),
buddyPropValue.utf8_str())
);
}
// construct the buddy
BuddyPtr pBuddy = pHandler->constructBuddy(vBuddyProps);
if (pBuddy)
{
// add the buddy to the account handler
pHandler->addBuddy(pBuddy);
}
}
}
else
{
// ... the rest are generic properties
UT_UTF8String propValue = reinterpret_cast<const char*>(xmlNodeGetContent(accountProp));
pHandler->addProperty(reinterpret_cast<const char*>(accountProp->name), propValue.utf8_str());
}
}
}
// add the account to the account list if it is not a duplicate
if (addAccount(pHandler))
{
if (pHandler->autoConnect())
pHandler->connect();
}
else
{
_deleteAccount(pHandler);
}
}
}
}
xmlFreeDoc(reader);
}
}
g_object_unref(G_OBJECT(in));
}
