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)); }