static void display_part(GMimeObject *part, const GMimeContentType *ct) { GMimeStream *ostream, *fstream; GMimeFilter *basic; GMimeDataWrapper *content; GMimeFilter *charset, *html; GMimePartEncodingType encoding; encoding = g_mime_part_get_encoding(GMIME_PART(part)); fstream = g_mime_stream_file_new(stdout); ostream = g_mime_stream_filter_new_with_stream(fstream); g_mime_stream_unref(fstream); /* Encoding filter, always on */ if (charset = g_mime_filter_charset_new(g_mime_content_type_get_parameter(ct, "charset"), "utf-8")) { g_mime_stream_filter_add(GMIME_STREAM_FILTER(ostream), charset); g_object_unref(charset); } if (g_mime_content_type_is_type(ct, "text", "plain")) { if (text_only == 0) { html = g_mime_filter_html_new ( GMIME_FILTER_HTML_CONVERT_SPACES | GMIME_FILTER_HTML_CONVERT_URLS | GMIME_FILTER_HTML_MARK_CITATION | GMIME_FILTER_HTML_CITE, 0); g_mime_stream_filter_add(GMIME_STREAM_FILTER(ostream), html); g_object_unref(html); } content = g_mime_part_get_content_object(GMIME_PART(part)); g_mime_data_wrapper_write_to_stream(content, ostream); g_mime_stream_flush(ostream); g_object_unref(content); // GMimeFilterBasic (base64, quopri) // GMimeFilterCharset // GMimeFilterHTML // GMimeFilterEnriched (text/enriched, text/rtf) } else if (g_mime_content_type_is_type(ct, "text", "html")) { content = g_mime_part_get_content_object(GMIME_PART(part)); g_mime_data_wrapper_write_to_stream(content, ostream); g_mime_stream_flush(ostream); g_object_unref(content); } else if (strcmp(ct->type, "image") == 0) { display_image(part); } }
QNetworkReply* MailNetworkManager::makeReply(const QNetworkRequest& req, GMimeObject* content) { auto ctype = g_mime_object_get_content_type(content); char *mtstr = g_mime_content_type_to_string(ctype); QString mediaType = QString::fromUtf8(mtstr); g_free(mtstr); const char *enc = g_mime_content_type_get_parameter(ctype, "charset"); if (enc != NULL) { mediaType += "; charset=\""; mediaType += QString::fromUtf8(enc); mediaType += "\""; } g_return_val_if_fail(GMIME_IS_PART(content), NULL); GMimeStream *stream = g_mime_stream_mem_new(); GMimeDataWrapper *wrapper = g_mime_part_get_content_object(GMIME_PART(content)); g_mime_data_wrapper_write_to_stream(wrapper, stream); GByteArray *bytes = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(stream)); QByteArray buffer((const char*) bytes->data, bytes->len); g_object_unref(stream); qDebug() <<"making reply of length" <<buffer.size() <<"and type" <<mediaType; return StaticHTTPReply::ok(req, buffer, mediaType); }
static void post_raw(GMimePart *part, const char *post_dir, const char *fn) { char filename[PATH_MAX]; GMimeDataWrapper *content; GMimeStream *stream; int fd; snprintf(filename, sizeof(filename), "%s/%s", post_dir, fn); ast_debug(1, "Posting raw data to %s\n", filename); if ((fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666)) == -1) { ast_log(LOG_WARNING, "Unable to open %s for writing file from a POST!\n", filename); return; } stream = g_mime_stream_fs_new(fd); content = g_mime_part_get_content_object(part); g_mime_data_wrapper_write_to_stream(content, stream); g_mime_stream_flush(stream); #ifndef AST_GMIME_VER_24 g_object_unref(content); #endif g_object_unref(stream); }
static void format_part_content_raw (GMimeObject *part) { if (! GMIME_IS_PART (part)) return; GMimeStream *stream_stdout; GMimeStream *stream_filter = NULL; GMimeDataWrapper *wrapper; stream_stdout = g_mime_stream_file_new (stdout); g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE); stream_filter = g_mime_stream_filter_new (stream_stdout); wrapper = g_mime_part_get_content_object (GMIME_PART (part)); if (wrapper && stream_filter) g_mime_data_wrapper_write_to_stream (wrapper, stream_filter); if (stream_filter) g_object_unref (stream_filter); if (stream_stdout) g_object_unref(stream_stdout); }
/** * g_mime_part_get_best_content_encoding: * @mime_part: a #GMimePart object * @constraint: a #GMimeEncodingConstraint * * Calculates the most efficient content encoding for the @mime_part * given the @constraint. * * Returns: the best content encoding for the specified mime part. **/ GMimeContentEncoding g_mime_part_get_best_content_encoding (GMimePart *mime_part, GMimeEncodingConstraint constraint) { GMimeStream *filtered, *stream; GMimeContentEncoding encoding; GMimeFilterBest *best; GMimeFilter *filter; g_return_val_if_fail (GMIME_IS_PART (mime_part), GMIME_CONTENT_ENCODING_DEFAULT); stream = g_mime_stream_null_new (); filtered = g_mime_stream_filter_new (stream); g_object_unref (stream); filter = g_mime_filter_best_new (GMIME_FILTER_BEST_ENCODING); g_mime_stream_filter_add ((GMimeStreamFilter *) filtered, filter); best = (GMimeFilterBest *) filter; g_mime_data_wrapper_write_to_stream (mime_part->content, filtered); g_mime_stream_flush (filtered); g_object_unref (filtered); encoding = g_mime_filter_best_encoding (best, constraint); g_object_unref (best); return encoding; }
static void reply_part_content (GMimeObject *part) { GMimeContentType *content_type = g_mime_object_get_content_type (GMIME_OBJECT (part)); GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (part); if (g_mime_content_type_is_type (content_type, "multipart", "*") || g_mime_content_type_is_type (content_type, "message", "rfc822")) { /* Output nothing, since multipart subparts will be handled individually. */ } else if (g_mime_content_type_is_type (content_type, "application", "pgp-encrypted") || g_mime_content_type_is_type (content_type, "application", "pgp-signature")) { /* Ignore PGP/MIME cruft parts */ } else if (g_mime_content_type_is_type (content_type, "text", "*") && !g_mime_content_type_is_type (content_type, "text", "html")) { GMimeStream *stream_stdout = NULL, *stream_filter = NULL; GMimeDataWrapper *wrapper; const char *charset; charset = g_mime_object_get_content_type_parameter (part, "charset"); stream_stdout = g_mime_stream_file_new (stdout); if (stream_stdout) { g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE); stream_filter = g_mime_stream_filter_new(stream_stdout); if (charset) { g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter), g_mime_filter_charset_new(charset, "UTF-8")); } } g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter), g_mime_filter_reply_new(TRUE)); wrapper = g_mime_part_get_content_object (GMIME_PART (part)); if (wrapper && stream_filter) g_mime_data_wrapper_write_to_stream (wrapper, stream_filter); if (stream_filter) g_object_unref(stream_filter); if (stream_stdout) g_object_unref(stream_stdout); } else { if (disposition && strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0) { const char *filename = g_mime_part_get_filename (GMIME_PART (part)); printf ("Attachment: %s (%s)\n", filename, g_mime_content_type_to_string (content_type)); } else { printf ("Non-text part: %s\n", g_mime_content_type_to_string (content_type)); } } }
static void extract_part(GMimeObject *part, PartExtractorData *a_data) { GMimeDataWrapper *attachment_wrapper = g_mime_part_get_content_object(GMIME_PART(part)); GMimeStream *attachment_mem_stream = g_mime_stream_mem_new(); g_mime_stream_mem_set_owner(GMIME_STREAM_MEM(attachment_mem_stream), FALSE); g_mime_data_wrapper_write_to_stream(attachment_wrapper, attachment_mem_stream); g_mime_stream_flush(attachment_mem_stream); a_data->content = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(attachment_mem_stream)); g_object_unref(attachment_mem_stream); }
/** * g_mime_part_set_content_md5: * @mime_part: a #GMimePart object * @content_md5: content md5 or %NULL to generate the md5 digest. * * Set the content md5 for the specified mime part. **/ void g_mime_part_set_content_md5 (GMimePart *mime_part, const char *content_md5) { unsigned char digest[16], b64digest[32]; GMimeStreamFilter *filtered_stream; GMimeContentType *content_type; GMimeFilter *md5_filter; GMimeStream *stream; guint32 save = 0; int state = 0; size_t len; g_return_if_fail (GMIME_IS_PART (mime_part)); g_free (mime_part->content_md5); if (!content_md5) { /* compute a md5sum */ stream = g_mime_stream_null_new (); filtered_stream = (GMimeStreamFilter *) g_mime_stream_filter_new (stream); g_object_unref (stream); content_type = g_mime_object_get_content_type ((GMimeObject *) mime_part); if (g_mime_content_type_is_type (content_type, "text", "*")) { GMimeFilter *crlf_filter; crlf_filter = g_mime_filter_crlf_new (TRUE, FALSE); g_mime_stream_filter_add (filtered_stream, crlf_filter); g_object_unref (crlf_filter); } md5_filter = g_mime_filter_md5_new (); g_mime_stream_filter_add (filtered_stream, md5_filter); stream = (GMimeStream *) filtered_stream; g_mime_data_wrapper_write_to_stream (mime_part->content, stream); g_object_unref (stream); memset (digest, 0, 16); g_mime_filter_md5_get_digest ((GMimeFilterMd5 *) md5_filter, digest); g_object_unref (md5_filter); len = g_mime_encoding_base64_encode_close (digest, 16, b64digest, &state, &save); b64digest[len] = '\0'; g_strstrip ((char *) b64digest); content_md5 = (const char *) b64digest; } mime_part->content_md5 = g_strdup (content_md5); g_mime_header_list_set (GMIME_OBJECT (mime_part)->headers, "Content-Md5", content_md5); }
/* Write a MIME text part out to the given stream. * * If (flags & NOTMUCH_SHOW_TEXT_PART_REPLY), this prepends "> " to * each output line. * * Both line-ending conversion (CRLF->LF) and charset conversion ( -> * UTF-8) will be performed, so it is inappropriate to call this * function with a non-text part. Doing so will trigger an internal * error. */ void show_text_part_content (GMimeObject *part, GMimeStream *stream_out, notmuch_show_text_part_flags flags) { GMimeContentType *content_type = g_mime_object_get_content_type (GMIME_OBJECT (part)); GMimeStream *stream_filter = NULL; GMimeDataWrapper *wrapper; const char *charset; if (! g_mime_content_type_is_type (content_type, "text", "*")) INTERNAL_ERROR ("Illegal request to format non-text part (%s) as text.", g_mime_content_type_to_string (content_type)); if (stream_out == NULL) return; stream_filter = g_mime_stream_filter_new (stream_out); g_mime_stream_filter_add(GMIME_STREAM_FILTER (stream_filter), g_mime_filter_crlf_new (FALSE, FALSE)); charset = g_mime_object_get_content_type_parameter (part, "charset"); if (charset) { GMimeFilter *charset_filter; charset_filter = g_mime_filter_charset_new (charset, "UTF-8"); /* This result can be NULL for things like "unknown-8bit". * Don't set a NULL filter as that makes GMime print * annoying assertion-failure messages on stderr. */ if (charset_filter) { g_mime_stream_filter_add (GMIME_STREAM_FILTER (stream_filter), charset_filter); g_object_unref (charset_filter); } } if (flags & NOTMUCH_SHOW_TEXT_PART_REPLY) { GMimeFilter *reply_filter; reply_filter = g_mime_filter_reply_new (TRUE); if (reply_filter) { g_mime_stream_filter_add (GMIME_STREAM_FILTER (stream_filter), reply_filter); g_object_unref (reply_filter); } } wrapper = g_mime_part_get_content_object (GMIME_PART (part)); if (wrapper && stream_filter) g_mime_data_wrapper_write_to_stream (wrapper, stream_filter); if (stream_filter) g_object_unref(stream_filter); }
static void reply_part_content (GMimeObject *part) { GMimeContentType *content_type = g_mime_object_get_content_type (GMIME_OBJECT (part)); GMimeContentDisposition *disposition = g_mime_object_get_content_disposition (part); if (g_mime_content_type_is_type (content_type, "text", "*") && !g_mime_content_type_is_type (content_type, "text", "html")) { GMimeStream *stream_stdout = NULL, *stream_filter = NULL; GMimeDataWrapper *wrapper; const char *charset; charset = g_mime_object_get_content_type_parameter (part, "charset"); stream_stdout = g_mime_stream_file_new (stdout); if (stream_stdout) { g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE); stream_filter = g_mime_stream_filter_new(stream_stdout); if (charset) { g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter), g_mime_filter_charset_new(charset, "UTF-8")); } } g_mime_stream_filter_add(GMIME_STREAM_FILTER(stream_filter), g_mime_filter_reply_new(TRUE)); wrapper = g_mime_part_get_content_object (GMIME_PART (part)); if (wrapper && stream_filter) g_mime_data_wrapper_write_to_stream (wrapper, stream_filter); if (stream_filter) g_object_unref(stream_filter); if (stream_stdout) g_object_unref(stream_stdout); } else { if (disposition && strcmp (disposition->disposition, GMIME_DISPOSITION_ATTACHMENT) == 0) { const char *filename = g_mime_part_get_filename (GMIME_PART (part)); printf ("Attachment: %s (%s)\n", filename, g_mime_content_type_to_string (content_type)); } else { printf ("Non-text part: %s\n", g_mime_content_type_to_string (content_type)); } } }
/** * g_mime_part_verify_content_md5: * @mime_part: a #GMimePart object * * Verify the content md5 for the specified mime part. * * Returns: %TRUE if the md5 is valid or %FALSE otherwise. Note: will * return %FALSE if the mime part does not contain a Content-MD5. **/ gboolean g_mime_part_verify_content_md5 (GMimePart *mime_part) { unsigned char digest[16], b64digest[32]; GMimeStreamFilter *filtered_stream; GMimeContentType *content_type; GMimeFilter *md5_filter; GMimeStream *stream; guint32 save = 0; int state = 0; size_t len; g_return_val_if_fail (GMIME_IS_PART (mime_part), FALSE); g_return_val_if_fail (mime_part->content != NULL, FALSE); if (!mime_part->content_md5) return FALSE; stream = g_mime_stream_null_new (); filtered_stream = (GMimeStreamFilter *) g_mime_stream_filter_new (stream); g_object_unref (stream); content_type = g_mime_object_get_content_type ((GMimeObject *) mime_part); if (g_mime_content_type_is_type (content_type, "text", "*")) { GMimeFilter *crlf_filter; crlf_filter = g_mime_filter_crlf_new (TRUE, FALSE); g_mime_stream_filter_add (filtered_stream, crlf_filter); g_object_unref (crlf_filter); } md5_filter = g_mime_filter_md5_new (); g_mime_stream_filter_add (filtered_stream, md5_filter); stream = (GMimeStream *) filtered_stream; g_mime_data_wrapper_write_to_stream (mime_part->content, stream); g_object_unref (stream); memset (digest, 0, 16); g_mime_filter_md5_get_digest ((GMimeFilterMd5 *) md5_filter, digest); g_object_unref (md5_filter); len = g_mime_encoding_base64_encode_close (digest, 16, b64digest, &state, &save); b64digest[len] = '\0'; g_strstrip ((char *) b64digest); return !strcmp ((char *) b64digest, mime_part->content_md5); }
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; }
gboolean write_part_to_fd (GMimePart *part, int fd, GError **err) { GMimeStream *stream; GMimeDataWrapper *wrapper; gboolean rv; stream = g_mime_stream_fs_new (fd); if (!GMIME_IS_STREAM(stream)) { g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME, "failed to create stream"); return FALSE; } g_mime_stream_fs_set_owner (GMIME_STREAM_FS(stream), FALSE); wrapper = g_mime_part_get_content_object (part); if (!GMIME_IS_DATA_WRAPPER(wrapper)) { g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME, "failed to create wrapper"); g_object_unref (stream); return FALSE; } g_object_ref (part); /* FIXME: otherwise, the unrefs below * give errors...*/ if (g_mime_data_wrapper_write_to_stream (wrapper, stream) == -1) { rv = FALSE; g_set_error (err, MU_ERROR_DOMAIN, MU_ERROR_GMIME, "failed to write to stream"); } else rv = TRUE; g_object_unref (wrapper); g_object_unref (stream); return rv; }
static notmuch_status_t format_part_raw (unused (const void *ctx), mime_node_t *node, unused (int indent), unused (const notmuch_show_params_t *params)) { if (node->envelope_file) { /* Special case the entire message to avoid MIME parsing. */ const char *filename; FILE *file; size_t size; char buf[4096]; filename = notmuch_message_get_filename (node->envelope_file); if (filename == NULL) { fprintf (stderr, "Error: Cannot get message filename.\n"); return NOTMUCH_STATUS_FILE_ERROR; } file = fopen (filename, "r"); if (file == NULL) { fprintf (stderr, "Error: Cannot open file %s: %s\n", filename, strerror (errno)); return NOTMUCH_STATUS_FILE_ERROR; } while (!feof (file)) { size = fread (buf, 1, sizeof (buf), file); if (ferror (file)) { fprintf (stderr, "Error: Read failed from %s\n", filename); fclose (file); return NOTMUCH_STATUS_FILE_ERROR; } if (fwrite (buf, size, 1, stdout) != 1) { fprintf (stderr, "Error: Write failed\n"); fclose (file); return NOTMUCH_STATUS_FILE_ERROR; } } fclose (file); return NOTMUCH_STATUS_SUCCESS; } GMimeStream *stream_stdout; GMimeStream *stream_filter = NULL; stream_stdout = g_mime_stream_file_new (stdout); g_mime_stream_file_set_owner (GMIME_STREAM_FILE (stream_stdout), FALSE); stream_filter = g_mime_stream_filter_new (stream_stdout); if (GMIME_IS_PART (node->part)) { /* For leaf parts, we emit only the transfer-decoded * body. */ GMimeDataWrapper *wrapper; wrapper = g_mime_part_get_content_object (GMIME_PART (node->part)); if (wrapper && stream_filter) g_mime_data_wrapper_write_to_stream (wrapper, stream_filter); } else { /* Write out the whole part. For message parts (the root * part and embedded message parts), this will be the * message including its headers (but not the * encapsulating part's headers). For multipart parts, * this will include the headers. */ if (stream_filter) g_mime_object_write_to_stream (node->part, stream_filter); } if (stream_filter) g_object_unref (stream_filter); if (stream_stdout) g_object_unref(stream_stdout); return NOTMUCH_STATUS_SUCCESS; }
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 collect_part(GMimeObject *part, PartCollectorData *fdata, gboolean multipart_parent) { GMimeContentType *content_type = g_mime_object_get_content_type(part); GMimeContentDisposition *disposition = g_mime_object_get_content_disposition(part); if (!content_type) return; GMimeDataWrapper *wrapper = g_mime_part_get_content_object(GMIME_PART(part)); if (!wrapper) return; // All the information will be collected in the CollectedPart CollectedPart *c_part = new_collected_part(fdata->part_id); gboolean is_attachment = FALSE; if (disposition) { c_part->disposition = g_ascii_strdown(disposition->disposition, -1); is_attachment = !g_ascii_strcasecmp(disposition->disposition, GMIME_DISPOSITION_ATTACHMENT); } // If a filename is given, collect it always const gchar *filename = g_mime_part_get_filename(GMIME_PART(part)); if (filename) c_part->filename = g_strdup(filename); // If a contentID is given, collect it always const char* content_id = g_mime_part_get_content_id (GMIME_PART(part)); if (content_id) c_part->content_id = g_strdup(content_id); // Get the contentType in lowercase gchar *content_type_str = g_mime_content_type_to_string(content_type); c_part->content_type = g_ascii_strdown(content_type_str, -1); g_free(content_type_str); // To qualify as a message body, a MIME entity MUST NOT have a Content-Disposition header with the value "attachment". if (!is_attachment && g_mime_content_type_is_type(content_type, "text", "*")) { gboolean is_text_plain = g_mime_content_type_is_type(content_type, "text", "plain"); gboolean is_text_html = g_mime_content_type_is_type(content_type, "text", "html"); gboolean is_text_rtf = g_mime_content_type_is_type(content_type, "text", "rtf"); gboolean is_text_enriched = g_mime_content_type_is_type(content_type, "text", "enriched"); gboolean is_new_text = !fdata->text_part && is_text_plain; gboolean is_new_html = !fdata->html_part && (is_text_html || is_text_enriched || is_text_rtf); GMimeStream *mem_stream = g_mime_stream_mem_new(); g_mime_stream_mem_set_owner(GMIME_STREAM_MEM(mem_stream), FALSE); GMimeStream *filtered_mem_stream = g_mime_stream_filter_new(mem_stream); const gchar *charset = g_mime_object_get_content_type_parameter(part, "charset"); if (charset && g_ascii_strcasecmp(charset, UTF8_CHARSET)) { GMimeFilter *utf8_charset_filter = g_mime_filter_charset_new(charset, UTF8_CHARSET); g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), utf8_charset_filter); g_object_unref(utf8_charset_filter); } if (!fdata->raw && is_new_text) { GMimeFilter *strip_filter = g_mime_filter_strip_new(); g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), strip_filter); g_object_unref(strip_filter); GMimeFilter *crlf_filter = g_mime_filter_crlf_new(FALSE, FALSE); g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), crlf_filter); g_object_unref(crlf_filter); GMimeFilter *html_filter = g_mime_filter_html_new( GMIME_FILTER_HTML_CONVERT_NL | GMIME_FILTER_HTML_CONVERT_SPACES | GMIME_FILTER_HTML_CONVERT_URLS | GMIME_FILTER_HTML_MARK_CITATION | GMIME_FILTER_HTML_CONVERT_ADDRESSES | GMIME_FILTER_HTML_CITE, CITATION_COLOUR); g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), html_filter); g_object_unref(html_filter); } if (!fdata->raw && (is_new_text || is_new_html)) { GMimeFilter *from_filter = g_mime_filter_from_new(GMIME_FILTER_FROM_MODE_ESCAPE); g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), from_filter); g_object_unref(from_filter); } // Add Enriched/RTF filter for this content if (!fdata->raw && (is_new_html && (is_text_enriched || is_text_rtf))) { guint flags = 0; if (is_text_rtf) flags = GMIME_FILTER_ENRICHED_IS_RICHTEXT; GMimeFilter *enriched_filter = g_mime_filter_enriched_new(flags); g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_mem_stream), enriched_filter); g_object_unref(enriched_filter); } g_mime_data_wrapper_write_to_stream(wrapper, filtered_mem_stream); // Very important! Flush the the stream and get all content through. g_mime_stream_flush(filtered_mem_stream); // Freed by the mem_stream on its own (owner) [transfer none] c_part->content = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(mem_stream)); // After we unref the mem_stream, part_content is NOT available anymore g_object_unref(filtered_mem_stream); g_object_unref(mem_stream); // Without content, the collected body part is of no use, so we ignore it. if (c_part->content->len == 0) { free_collected_part(c_part); return; } // We accept only the first text and first html content, everything // else is considered an alternative body if (is_new_text) { fdata->text_part = c_part; } else if (is_new_html) { fdata->html_part = c_part; } else { g_ptr_array_add(fdata->alternative_bodies, c_part); } } else { GMimeStream *attachment_mem_stream = g_mime_stream_mem_new(); g_mime_stream_mem_set_owner (GMIME_STREAM_MEM(attachment_mem_stream), FALSE); g_mime_data_wrapper_write_to_stream(wrapper, attachment_mem_stream); g_mime_stream_flush(attachment_mem_stream); c_part->content = g_mime_stream_mem_get_byte_array(GMIME_STREAM_MEM(attachment_mem_stream)); g_object_unref(attachment_mem_stream); // Some content may not have disposition defined so we need to determine better what it is if ((disposition && !g_ascii_strcasecmp(disposition->disposition, GMIME_DISPOSITION_INLINE)) || g_mime_part_get_content_id(GMIME_PART(part))) { g_ptr_array_add(fdata->inlines, c_part); } else { // All other disposition should be kept within attachments g_ptr_array_add(fdata->attachments, c_part); } } }
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 ; }
GMimeGpgmeSigstat * g_mime_gpgme_mps_verify(GMimeMultipartSigned * mps, GError ** error) { const gchar *protocol; gpgme_protocol_t crypto_prot; gchar *content_type; GMimeObject *content; GMimeObject *signature; GMimeStream *stream; GMimeStream *filtered_stream; GMimeFilter *crlf_filter; GMimeDataWrapper *wrapper; GMimeStream *sigstream; GMimeGpgmeSigstat *result; g_return_val_if_fail(GMIME_IS_MULTIPART_SIGNED(mps), NULL); if (g_mime_multipart_get_count(GMIME_MULTIPART(mps)) < 2) { g_set_error(error, GMIME_ERROR, GMIME_ERROR_PARSE_ERROR, "%s", _ ("Cannot verify multipart/signed part due to missing subparts.")); return NULL; } /* grab the protocol so we can configure the GpgME context */ protocol = g_mime_object_get_content_type_parameter(GMIME_OBJECT(mps), "protocol"); if (protocol) { if (g_ascii_strcasecmp("application/pgp-signature", protocol) == 0) crypto_prot = GPGME_PROTOCOL_OpenPGP; else if (g_ascii_strcasecmp ("application/pkcs7-signature", protocol) == 0 || g_ascii_strcasecmp("application/x-pkcs7-signature", protocol) == 0) crypto_prot = GPGME_PROTOCOL_CMS; else crypto_prot = GPGME_PROTOCOL_UNKNOWN; } else crypto_prot = GPGME_PROTOCOL_UNKNOWN; /* eject on unknown protocols */ if (crypto_prot == GPGME_PROTOCOL_UNKNOWN) { g_set_error(error, GPGME_ERROR_QUARK, GPG_ERR_INV_VALUE, _("unsupported protocol “%s”"), protocol); return NULL; } signature = g_mime_multipart_get_part(GMIME_MULTIPART(mps), GMIME_MULTIPART_SIGNED_SIGNATURE); /* make sure the protocol matches the signature content-type */ content_type = g_mime_content_type_to_string(signature->content_type); if (g_ascii_strcasecmp(content_type, protocol) != 0) { g_set_error(error, GMIME_ERROR, GMIME_ERROR_PARSE_ERROR, "%s", _ ("Cannot verify multipart/signed part: signature content-type does not match protocol.")); g_free(content_type); return NULL; } g_free(content_type); content = g_mime_multipart_get_part(GMIME_MULTIPART(mps), GMIME_MULTIPART_SIGNED_CONTENT); /* get the content stream */ stream = g_mime_stream_mem_new(); filtered_stream = g_mime_stream_filter_new(stream); /* Note: see rfc2015 or rfc3156, section 5.1 */ crlf_filter = g_mime_filter_crlf_new(TRUE, FALSE); g_mime_stream_filter_add(GMIME_STREAM_FILTER(filtered_stream), crlf_filter); g_object_unref(crlf_filter); g_mime_object_write_to_stream(content, filtered_stream); g_mime_stream_flush(filtered_stream); g_object_unref(filtered_stream); g_mime_stream_reset(stream); /* get the signature stream */ wrapper = g_mime_part_get_content_object(GMIME_PART(signature)); /* a s/mime signature is always encoded, a pgp signature shouldn't, * but there exist implementations which encode it... */ sigstream = g_mime_stream_mem_new(); g_mime_data_wrapper_write_to_stream(wrapper, sigstream); g_mime_stream_reset(sigstream); /* verify the signature */ result = libbalsa_gpgme_verify(stream, sigstream, crypto_prot, FALSE, error); g_object_unref(stream); g_object_unref(sigstream); return result; }