static void pump_data_through_filter (GMimeFilter *filter, const char *path, GMimeStream *ostream, gboolean is_text, gboolean inc) { GMimeStream *onebyte, *filtered, *stream; GMimeFilter *dos2unix; filtered = g_mime_stream_filter_new (ostream); if (is_text) { /* canonicalize text input */ dos2unix = g_mime_filter_dos2unix_new (FALSE); g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, dos2unix); g_object_unref (dos2unix); } g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter); if (inc) { onebyte = test_stream_onebyte_new (filtered); g_object_unref (filtered); } else { onebyte = filtered; } stream = g_mime_stream_fs_open (path, O_RDONLY, 0644, NULL); g_mime_stream_write_to_stream (stream, onebyte); g_mime_stream_flush (onebyte); g_object_unref (onebyte); g_object_unref (stream); }
static void pump_data_through_filter (GMimeFilter *filter, const char *path, GMimeStream *ostream) { GMimeStream *onebyte, *filtered, *stream; GMimeFilter *unix2dos, *dos2unix; filtered = g_mime_stream_filter_new (ostream); /* convert to DOS format before piping through the OpenPGP filter to maximize testing area */ unix2dos = g_mime_filter_unix2dos_new (FALSE); g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, unix2dos); g_object_unref (unix2dos); g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter); /* convert back to UNIX format after filtering */ dos2unix = g_mime_filter_dos2unix_new (FALSE); g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, dos2unix); g_object_unref (dos2unix); onebyte = test_stream_onebyte_new (filtered); g_object_unref (filtered); stream = g_mime_stream_fs_open (path, O_RDONLY, 0644, NULL); g_mime_stream_write_to_stream (stream, onebyte); g_mime_stream_flush (onebyte); g_object_unref (onebyte); g_object_unref (stream); }
static GByteArray * read_all_bytes (const char *path, gboolean is_text) { GMimeStream *filtered, *stream, *mem; GMimeFilter *filter; GByteArray *buffer; buffer = g_byte_array_new (); stream = g_mime_stream_fs_open (path, O_RDONLY, 0644, NULL); mem = g_mime_stream_mem_new_with_byte_array (buffer); g_mime_stream_mem_set_owner ((GMimeStreamMem *) mem, FALSE); if (is_text) { filtered = g_mime_stream_filter_new (mem); filter = g_mime_filter_dos2unix_new (FALSE); g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter); g_object_unref (filter); g_object_unref (mem); } else { filtered = mem; } g_mime_stream_write_to_stream (stream, filtered); g_mime_stream_flush (filtered); g_object_unref (filtered); g_object_unref (stream); return buffer; }
/** * g_mime_header_list_to_string: * @headers: a #GMimeHeaderList * * Allocates a string buffer containing the raw rfc822 headers * contained in @headers. * * Returns: a string containing the header block. **/ char * g_mime_header_list_to_string (const GMimeHeaderList *headers) { GMimeStream *stream; GByteArray *array; char *str; g_return_val_if_fail (headers != NULL, NULL); array = g_byte_array_new (); stream = g_mime_stream_mem_new (); g_mime_stream_mem_set_byte_array (GMIME_STREAM_MEM (stream), array); if (headers->stream) { g_mime_stream_reset (headers->stream); g_mime_stream_write_to_stream (headers->stream, stream); } else { g_mime_header_list_write_to_stream (headers, stream); } g_object_unref (stream); g_byte_array_append (array, (unsigned char *) "", 1); str = (char *) array->data; g_byte_array_free (array, FALSE); return str; }
/** * g_mime_header_list_write_to_stream: * @headers: a #GMimeHeaderList * @stream: output stream * * Write the headers to a stream. * * Returns: the number of bytes written or %-1 on fail. **/ ssize_t g_mime_header_list_write_to_stream (const GMimeHeaderList *headers, GMimeStream *stream) { ssize_t nwritten, total = 0; GMimeHeaderWriter writer; GHashTable *writers; GMimeHeader *header; g_return_val_if_fail (headers != NULL, -1); g_return_val_if_fail (stream != NULL, -1); if (headers->stream) { g_mime_stream_reset (headers->stream); return g_mime_stream_write_to_stream (headers->stream, stream); } header = (GMimeHeader *) headers->list.head; writers = headers->writers; while (header->next) { if (header->value) { if (!(writer = g_hash_table_lookup (writers, header->name))) writer = default_writer; if ((nwritten = writer (stream, header->name, header->value)) == -1) return -1; total += nwritten; } header = header->next; } return total; }
gboolean mux_message_part_write (MuxMessagePart *self, GMimeStream *ostream, GError **err) { ssize_t bytes; g_return_val_if_fail (MUX_IS_MESSAGE_PART(self), FALSE); g_return_val_if_fail (GMIME_IS_STREAM(ostream), FALSE); if (GMIME_IS_PART(self->mime_object)) { GMimeDataWrapper *wrapper; wrapper = get_data_wrapper (self->mime_object, err); if (!wrapper) return FALSE; bytes = g_mime_data_wrapper_write_to_stream ( wrapper, ostream); } else { GMimeStream *istream; istream = get_mime_stream (self->mime_object, err); if (!istream) return FALSE; bytes = g_mime_stream_write_to_stream (istream, ostream); } if (bytes == -1) { g_set_error (err, G_IO_ERROR, G_IO_ERROR_FAILED, "failed to write part to stream"); return FALSE; } bytes = g_mime_stream_flush (ostream); if (bytes == -1) { g_set_error (err, G_IO_ERROR, G_IO_ERROR_FAILED, "failed to flush stream"); return FALSE; } return TRUE; }
static void test_stream_mem (const char *filename) { /* Note: this also tests g_mime_stream_write_to_stream */ GMimeStream *stream, *fstream; int fd; if ((fd = open (filename, O_RDONLY, 0)) == -1) { v(fprintf (stderr, "failed to open %s: %s\n", filename, g_strerror (errno))); return; } testsuite_start ("GMimeStreamMem"); fstream = g_mime_stream_fs_new (fd); stream = g_mime_stream_mem_new (); testsuite_check ("GMimeStreamMem::read()"); try { if (g_mime_stream_write_to_stream (fstream, stream) == -1) throw (exception_new ("g_mime_stream_write_to_stream() failed")); if (g_mime_stream_length (stream) != g_mime_stream_length (fstream)) throw (exception_new ("stream lengths didn't match")); test_stream_read (stream, filename); testsuite_check_passed (); } catch (ex) { testsuite_check_failed ("GMimeStreamMem::read() failed: %s", ex->message); } finally; g_object_unref (fstream); g_object_unref (stream); testsuite_end (); }
static void lsv_escape_change_state(GSimpleAction * action, GVariant * state, gpointer user_data) { LibBalsaSourceViewerInfo *lsvi = g_object_get_data(G_OBJECT(user_data), "lsvi"); LibBalsaMessage *msg = lsvi->msg; GMimeStream *msg_stream; GMimeStream *mem_stream; char *raw_message; if (!msg->mailbox) { libbalsa_information(LIBBALSA_INFORMATION_WARNING, _("Mailbox closed")); return; } msg_stream = libbalsa_mailbox_get_message_stream(msg->mailbox, msg->msgno, TRUE); if (msg_stream == NULL) return; mem_stream = g_mime_stream_mem_new(); libbalsa_mailbox_lock_store(msg->mailbox); g_mime_stream_write_to_stream(msg_stream, mem_stream); libbalsa_mailbox_unlock_store(msg->mailbox); g_mime_stream_write(mem_stream, "", 1); /* close string */ raw_message = (char *) GMIME_STREAM_MEM(mem_stream)->buffer->data; *(lsvi->escape_specials) = g_variant_get_boolean(state); lsv_show_message(raw_message, lsvi, *(lsvi->escape_specials)); g_object_unref(msg_stream); g_object_unref(mem_stream); g_simple_action_set_state(action, state); }
static int gen_test_data (const char *datadir, char **stream_name) { GMimeStream *istream, *ostream, *stream; char input[256], output[256], *name, *p; gint64 start, end, len, size; int fd, i; srand (time (NULL)); name = g_stpcpy (input, datadir); *name++ = G_DIR_SEPARATOR; name = g_stpcpy (name, "input"); p = g_stpcpy (output, datadir); *p++ = G_DIR_SEPARATOR; p = g_stpcpy (p, "output"); g_mkdir_with_parents (input, 0755); g_mkdir_with_parents (output, 0755); *name++ = G_DIR_SEPARATOR; strcpy (name, "streamXXXXXX"); if ((fd = g_mkstemp (input)) == -1) return -1; *stream_name = g_strdup (name); *p++ = G_DIR_SEPARATOR; p = g_stpcpy (p, name); *p++ = '_'; istream = g_mime_stream_fs_new (fd); size = gen_random_stream (istream); for (i = 0; i < 64; i++) { retry: start = (gint64) (size * (rand () / (RAND_MAX + 1.0))); len = (gint64) (size * (rand () / (RAND_MAX + 1.0))); if (start + len > size) { len = size - start; end = -1; } else { end = start + len; } sprintf (p, "%" G_GINT64_FORMAT ",%" G_GINT64_FORMAT, start, end); if ((fd = open (output, O_CREAT | O_EXCL | O_TRUNC | O_WRONLY, 0666)) == -1) goto retry; ostream = g_mime_stream_fs_new (fd); stream = g_mime_stream_substream (istream, start, end); g_mime_stream_write_to_stream (stream, ostream); g_mime_stream_flush (ostream); g_object_unref (ostream); g_object_unref (stream); } return 0; }
static void test_cat_write (GMimeStream *whole, struct _StreamPart *parts, int bounded) { struct _StreamPart *part = parts; GMimeStream *stream, *sub, *cat; Exception *ex; int fd; cat = g_mime_stream_cat_new (); while (part != NULL) { d(fprintf (stderr, "adding %s start=%lld, end=%lld...\n", part->filename, part->pstart, part->pend)); if ((fd = open (part->filename, O_CREAT | O_TRUNC | O_WRONLY, 0666)) == -1) { ex = exception_new ("could not create `%s': %s", part->filename, g_strerror (errno)); throw (ex); } stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, part->pend); g_mime_stream_cat_add_source ((GMimeStreamCat *) cat, stream); g_object_unref (stream); part = part->next; } g_mime_stream_reset (whole); if (g_mime_stream_write_to_stream (whole, (GMimeStream *) cat) == -1) { ex = exception_new ("%s", g_strerror (errno)); g_object_unref (cat); throw (ex); } g_object_unref (cat); /* now lets check that the content matches */ d(fprintf (stderr, "checking all part streams have correct data...\n")); part = parts; while (part != NULL) { d(fprintf (stderr, "checking substream %s\n", part->filename)); if ((fd = open (part->filename, O_RDONLY, 0)) == -1) { ex = exception_new ("could not open `%s': %s", part->filename, g_strerror (errno)); throw (ex); } if (!(sub = g_mime_stream_substream (whole, part->wstart, part->wend))) { ex = exception_new ("could not substream original stream"); close (fd); throw (ex); } if (!(stream = g_mime_stream_fs_new_with_bounds (fd, part->pstart, -1))) { ex = exception_new ("could not instantiate stream for `%s'", part->filename); close (fd); throw (ex); } d(fprintf (stderr, "checking substream %s matches...\n", part->filename)); if (check_streams_match (sub, stream, part->filename, TRUE) == -1) { ex = exception_new ("streams did not match"); g_object_unref (stream); g_object_unref (sub); throw (ex); } g_object_unref (stream); g_object_unref (sub); part = part->next; } }
void AnalyseMessageParse(GMimePart * mime_part) { int ichar=0,iencode =0; if( NULL==mime_part ) { printf("empty part\n"); return ; } GMimeContentEncoding ReEncoding = g_mime_part_get_content_encoding(mime_part); char* szCharset = (char*)g_mime_object_get_content_type_parameter((GMimeObject*)mime_part,"charset"); printf("charset %s\n",szCharset); { char* szCharset = (char*)g_mime_object_get_content_type_parameter((GMimeObject*)mime_part,"name"); printf("name %s\n",szCharset); GMimeContentType* pContentType = g_mime_object_get_content_type((GMimeObject*)mime_part) ; printf("The content type is: (%s/%s)\n",pContentType->type,pContentType->subtype); const char * ppp= g_mime_object_get_disposition((GMimeObject*)mime_part); if(!ppp) { goto exits; } const char * qqq=g_mime_object_get_content_disposition_parameter((GMimeObject*)mime_part,"filename"); printf("get disposition\t%s\n%s\n",ppp,qqq); if(qqq) { FILE * ps=fopen(qqq,"w+b"); printf("\n=======write to file================\n" ); GMimeStream *stream = g_mime_stream_file_new (ps); GMimeDataWrapper * content=g_mime_part_get_content_object(mime_part); g_mime_data_wrapper_write_to_stream(content,stream); fclose(ps); printf("finish writing\n"); getchar(); return ; } } exits:{} /*decode for text/plain or html*/ GMimeDataWrapper *dataWrap = g_mime_part_get_content_object(mime_part); if(!dataWrap) printf("error in dataWrap\n" ); GMimeStream * gmime_stream= g_mime_data_wrapper_get_stream(dataWrap); //encoding转码 GMimeFilter * pAttFilter = g_mime_filter_basic_new(ReEncoding,FALSE); GMimeStream* pFilterStream = g_mime_stream_filter_new(gmime_stream); iencode = g_mime_stream_filter_add (GMIME_STREAM_FILTER (pFilterStream), pAttFilter); /*create a filter convert the charset into local type*/ GMimeFilter * secondPtr = g_mime_filter_charset_new(szCharset,g_mime_charset_locale_name()); ichar = g_mime_stream_filter_add (GMIME_STREAM_FILTER (pFilterStream), secondPtr); /*convert stream into stdout*/ GMimeStream *stream = g_mime_stream_file_new (stdout); g_mime_stream_write_to_stream(pFilterStream,stream); #if 0 /*get data from stream load into char* */ char pp[10000]= {0}; int tt=g_mime_stream_read(pFilterStream,pp,10000); printf("%d\t%s\n",tt,pp); #endif g_object_unref ( pAttFilter ); g_object_unref ( secondPtr ); g_mime_stream_filter_remove((GMimeStreamFilter*)pFilterStream,ichar); g_mime_stream_filter_remove((GMimeStreamFilter*)pFilterStream,iencode); g_object_unref (pFilterStream); //g_object_unref (gmime_stream); //g_object_unref (stream); //if(NULL==szCharset) { printf("\n====>>>>====>>>>====>>>>Finish decoding this part<<<<====<<<<====<<<<====\n"); getchar(); //return ; } return ; }
static ssize_t write_content (GMimePart *part, GMimeStream *stream) { ssize_t nwritten, total = 0; if (!part->content) return 0; /* Evil Genius's "slight" optimization: Since GMimeDataWrapper::write_to_stream() * decodes its content stream to the raw format, we can cheat by requesting its * content stream and not doing any encoding on the data if the source and * destination encodings are identical. */ if (part->encoding != g_mime_data_wrapper_get_encoding (part->content)) { GMimeStream *filtered_stream; const char *filename; GMimeFilter *filter; switch (part->encoding) { case GMIME_CONTENT_ENCODING_UUENCODE: filename = g_mime_part_get_filename (part); nwritten = g_mime_stream_printf (stream, "begin 0644 %s\n", filename ? filename : "unknown"); if (nwritten == -1) return -1; total += nwritten; /* fall thru... */ case GMIME_CONTENT_ENCODING_QUOTEDPRINTABLE: case GMIME_CONTENT_ENCODING_BASE64: filtered_stream = g_mime_stream_filter_new (stream); filter = g_mime_filter_basic_new (part->encoding, TRUE); g_mime_stream_filter_add (GMIME_STREAM_FILTER (filtered_stream), filter); g_object_unref (filter); break; default: filtered_stream = stream; g_object_ref (stream); break; } nwritten = g_mime_data_wrapper_write_to_stream (part->content, filtered_stream); g_mime_stream_flush (filtered_stream); g_object_unref (filtered_stream); if (nwritten == -1) return -1; total += nwritten; if (part->encoding == GMIME_CONTENT_ENCODING_UUENCODE) { /* FIXME: get rid of this special-case x-uuencode crap */ nwritten = g_mime_stream_write (stream, "end\n", 4); if (nwritten == -1) return -1; total += nwritten; } } else { GMimeStream *content_stream; content_stream = g_mime_data_wrapper_get_stream (part->content); g_mime_stream_reset (content_stream); nwritten = g_mime_stream_write_to_stream (content_stream, stream); g_mime_stream_reset (content_stream); if (nwritten == -1) return -1; total += nwritten; } return total; }
static void test_openpgp_filter (GMimeFilterOpenPGP *filter, const char *path, GMimeOpenPGPData data_type, gint64 begin, gint64 end) { GMimeStream *filtered, *stream, *expected, *ostream; GMimeFilter *dos2unix; GMimeOpenPGPData type; Exception *ex = NULL; GByteArray *buf[2]; char *filename; struct stat st; gint64 offset; ostream = g_mime_stream_mem_new (); pump_data_through_filter ((GMimeFilter *) filter, path, ostream); if ((type = g_mime_filter_openpgp_get_data_type (filter)) != data_type) { g_object_unref (ostream); throw (exception_new ("Incorrect OpenPGP data type detected: %s", openpgp_data_types[type])); } if ((offset = g_mime_filter_openpgp_get_begin_offset (filter)) != begin) { g_object_unref (ostream); throw (exception_new ("Incorrect begin offset: %ld", (long) offset)); } if ((offset = g_mime_filter_openpgp_get_end_offset (filter)) != end) { g_object_unref (ostream); throw (exception_new ("Incorrect end offset: %ld", (long) offset)); } filename = g_strdup_printf ("%s.openpgp-block", path); if (stat (filename, &st) == -1) { stream = g_mime_stream_fs_open (filename, O_RDWR | O_CREAT, 0644, NULL); g_mime_stream_reset (ostream); g_mime_stream_write_to_stream (ostream, stream); g_mime_stream_flush (stream); g_mime_stream_reset (stream); } else { stream = g_mime_stream_fs_open (filename, O_RDONLY, 0644, NULL); } g_free (filename); /* make sure the data is in UNIX format before comparing (might be running tests on Windows) */ expected = g_mime_stream_mem_new (); filtered = g_mime_stream_filter_new (expected); dos2unix = g_mime_filter_dos2unix_new (FALSE); g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, dos2unix); g_object_unref (dos2unix); g_mime_stream_write_to_stream (stream, filtered); g_mime_stream_flush (filtered); g_object_unref (filtered); g_object_unref (stream); buf[0] = GMIME_STREAM_MEM (expected)->buffer; buf[1] = GMIME_STREAM_MEM (ostream)->buffer; if (buf[0]->len != buf[1]->len || memcmp (buf[0]->data, buf[1]->data, buf[0]->len) != 0) ex = exception_new ("filtered data does not match the expected result"); g_object_unref (expected); g_object_unref (ostream); if (ex != NULL) throw (ex); }
static void test_export (GMimeCryptoContext *ctx, const char *path) { GMimeStream *istream, *ostream; register const char *inptr; const char *inbuf, *outbuf; size_t inlen, outlen; Exception *ex = NULL; const char *keys[2]; GError *err = NULL; int fd; if ((fd = open (path, O_RDONLY, 0)) == -1) throw (exception_new ("open() failed: %s", g_strerror (errno))); ostream = g_mime_stream_fs_new (fd); istream = g_mime_stream_mem_new (); g_mime_stream_write_to_stream (ostream, istream); g_mime_stream_reset (istream); g_object_unref (ostream); keys[0] = "*****@*****.**"; keys[1] = NULL; ostream = g_mime_stream_mem_new (); g_mime_crypto_context_export_keys (ctx, keys, ostream, &err); if (err != NULL) { ex = exception_new ("%s", err->message); g_object_unref (istream); g_object_unref (ostream); g_error_free (err); throw (ex); } inbuf = (const char *) GMIME_STREAM_MEM (istream)->buffer->data; inlen = GMIME_STREAM_MEM (istream)->buffer->len; if ((inptr = strstr (inbuf, "\n\n"))) { /* skip past the headers which may have different version numbers */ inptr += 2; inlen -= (inptr - inbuf); inbuf = inptr; } outbuf = (const char *) GMIME_STREAM_MEM (ostream)->buffer->data; outlen = GMIME_STREAM_MEM (ostream)->buffer->len; if ((inptr = strstr (outbuf, "\n\n"))) { /* skip past the headers which may have different version numbers */ inptr += 2; outlen -= (inptr - outbuf); outbuf = inptr; } if (outlen != inlen || memcmp (outbuf, inbuf, inlen) != 0) ex = exception_new ("exported key does not match original key"); g_object_unref (istream); g_object_unref (ostream); if (ex != NULL) throw (ex); }
static int uuencode (const char *progname, int argc, char **argv) { GMimeStream *istream, *ostream, *fstream; GMimeContentEncoding encoding; const char *filename, *name; GMimeFilter *filter; gboolean base64; struct stat st; int fd, opt; base64 = FALSE; encoding = GMIME_CONTENT_ENCODING_UUENCODE; while ((opt = getopt_long (argc, argv, "hvm", longopts, NULL)) != -1) { switch (opt) { case 'h': usage (progname); return 0; case 'v': version (progname); return 0; case 'm': base64 = TRUE; encoding = GMIME_CONTENT_ENCODING_BASE64; break; default: printf ("Try `%s --help' for more information.\n", progname); return -1; } } if (optind >= argc) { printf ("Try `%s --help' for more information.\n", progname); return -1; } if (optind + 1 < argc) filename = argv[optind++]; else filename = NULL; name = argv[optind]; /* open our input file... */ if ((fd = filename ? open (filename, O_RDONLY, 0) : dup (0)) == -1) { fprintf (stderr, "%s: %s: %s\n", progname, filename ? filename : "stdin", g_strerror (errno)); return -1; } /* stat() our input file for file mode permissions */ if (fstat (fd, &st) == -1) { fprintf (stderr, "%s: %s: %s\n", progname, filename ? filename : "stdin", g_strerror (errno)); close (fd); return -1; } printf ("begin%s %.3o %s\n", base64 ? "-base64" : "", st.st_mode & 0777, name); fflush (stdout); istream = g_mime_stream_fs_new (fd); /* open our output stream */ ostream = g_mime_stream_fs_new (1); g_mime_stream_fs_set_owner ((GMimeStreamFs *) ostream, FALSE); fstream = g_mime_stream_filter_new (ostream); /* attach an encode filter */ filter = g_mime_filter_basic_new (encoding, TRUE); g_mime_stream_filter_add ((GMimeStreamFilter *) fstream, filter); g_object_unref (filter); if (g_mime_stream_write_to_stream (istream, fstream) == -1) { fprintf (stderr, "%s: %s\n", progname, g_strerror (errno)); g_object_unref (fstream); g_object_unref (istream); g_object_unref (ostream); return -1; } g_mime_stream_flush (fstream); g_object_unref (fstream); g_object_unref (istream); if (g_mime_stream_write_string (ostream, base64 ? "====\n" : "end\n") == -1) { fprintf (stderr, "%s: %s\n", progname, g_strerror (errno)); g_object_unref (ostream); return -1; } g_object_unref (ostream); return 0; }