int main (int argc, char* argv[]) { if (argc < 2) { fprintf(stderr, "Usage: %s MSG_FILE\n", argv[0]); return 1; } g_mime_init(0); FILE* fp = fopen(argv[1], "r"); if (fp == NULL) { fprintf(stderr, "Cannot open the file %s\n", argv[1]); return 1; } GMimeStream* stream = g_mime_stream_file_new(fp); GMimeParser* parser = g_mime_parser_new_with_stream(stream); GMimeMessage* message = g_mime_parser_construct_message(parser); if (message == NULL) { fprintf(stderr, "Cannot construct message\n"); return 1; } printf("Date : %s\n", g_mime_message_get_date_as_string(message)); printf("Subject : %s\n", g_mime_message_get_subject(message)); printf("From : %s\n", g_mime_message_get_sender(message)); printf("To : %s\n", internet_address_list_to_string( g_mime_message_get_all_recipients(message), FALSE)); fclose(fp); return 0; }
int main(int argc, char **argv) { GByteArray *garray; GMimeStream *stream; GMimeParser *parse; GMimeMessage *message; char buf[1]; int len; g_mime_init(0); garray = g_byte_array_new(); while (!feof(stdin)) { len = fread(buf, 1, 1, stdin); if (len == 1) g_byte_array_append(garray, buf, len); } stream = g_mime_stream_mem_new_with_byte_array(garray); parse = g_mime_parser_new_with_stream(stream); message = g_mime_parser_construct_message(parse); remove_message(message); printf(g_mime_object_to_string((GMimeObject*)message)); g_object_unref(message); g_object_unref(parse); g_object_unref(stream); return 0; }
MNMessage * mn_message_new_from_mime_stream_full (GType type, MNMailbox *mailbox, GMimeStream *mime_stream, const char *mid, const char *uri, MNMessageFlags flags, gboolean handle_status, GError **err) { GMimeParser *parser; GMimeMessage *mime_message; MNMessage *message = NULL; g_return_val_if_fail(type != 0, NULL); g_return_val_if_fail(MN_IS_MAILBOX(mailbox), NULL); g_return_val_if_fail(GMIME_IS_STREAM(mime_stream), NULL); parser = g_mime_parser_new_with_stream(mime_stream); mime_message = g_mime_parser_construct_message(parser); g_object_unref(parser); if (mime_message) { message = mn_message_new_from_mime_message_full(type, mailbox, mime_message, mid, uri, flags, handle_status); g_object_unref(mime_message); } else g_set_error(err, 0, 0, _("unable to parse MIME message")); return message; }
int main (int argc, const char* argv[]) { GMimeMessage *message; GMimeParser *parser; GMimeStream *stream; const char *file = argv[1]; int fd; if (argc < 2) { printf("No file name given\n"); return 1; } if (argc == 3) { text_only = 1; file = argv[2]; } g_mime_init(0); g_mime_iconv_init(); if ((fd = open(file, O_RDONLY)) == -1) { printf("Error opening file %s\n", file); return 1; } stream = g_mime_stream_fs_new(fd); parser = g_mime_parser_new_with_stream(stream); g_mime_parser_set_scan_from(parser, FALSE); g_object_unref(stream); message = g_mime_parser_construct_message(parser); g_object_unref(parser); if (message) { write_part(message->mime_part); } else { printf("Error constructing message\n"); return 1; } g_mime_iconv_shutdown(); return 0; }
static GMimeMessage* gmime_message_from_stream(GMimeStream *stream) { g_return_val_if_fail(stream != NULL, NULL); GMimeParser *parser = g_mime_parser_new_with_stream(stream); if (!parser) { g_printerr("failed to create parser\r\n"); return NULL; } GMimeMessage *message = g_mime_parser_construct_message(parser); g_object_unref (parser); if (!message) { g_printerr("failed to construct message\r\n"); return NULL; } return message; }
static GMimeMessage *parse_message(FILE *f) { GMimeMessage *message; GMimeParser *parser; GMimeStream *stream; stream = g_mime_stream_file_new(f); parser = g_mime_parser_new_with_stream(stream); g_mime_parser_set_respect_content_length(parser, 1); g_object_unref(stream); message = g_mime_parser_construct_message(parser); g_object_unref(parser); return message; }
parsed_article *parse_file(const char *file_name) { static parsed_article pa; GMimeStream *stream; GMimeMessage *msg = NULL; int offset; int file; printf("%s\n", file_name); if ((file = open(file_name, O_RDONLY|O_STREAMING)) == -1) { fprintf(stderr, "Can't open %s\n", file_name); return NULL; } stream = g_mime_stream_fs_new(file); msg = g_mime_parser_construct_message(stream); g_mime_stream_unref(stream); if (msg != 0) { hstrcpy(pa.from, g_mime_message_get_header(msg, "From")); hstrcpy(pa.subject, g_mime_message_get_subject(msg)); hstrcpy(pa.message_id, g_mime_message_get_message_id(msg)); hstrcpy(pa.references, g_mime_message_get_header(msg, "references")); hstrcpy(pa.xref, g_mime_message_get_header(msg, "xref")); hstrcpy(pa.original_message_id, g_mime_message_get_header(msg, "original-message-id")); g_mime_message_get_date(msg, &pa.date, &offset); if (pa.xref != NULL && strstr(pa.xref, "gmane.spam.detected") != NULL) pa.spamp = 1; else pa.spamp = 0; g_mime_message_foreach_part(msg, count_part, (gpointer) &pa); g_mime_object_unref(GMIME_OBJECT(msg)); } close(file); return &pa; }
static gboolean test_stream (GMimeStream *stream, GMimeStream *out_stream) { GMimeParser *parser; GMimeMessage *msg; gboolean rv; parser = NULL; msg = NULL; parser = g_mime_parser_new_with_stream (stream); if (!parser) { g_warning ("failed to create parser"); rv = FALSE; goto leave; } msg = g_mime_parser_construct_message (parser); if (!msg) { g_warning ("failed to construct message"); rv = FALSE; goto leave; } extract_headers(msg, out_stream); leave: if (parser) g_object_unref (parser); else g_object_unref (stream); if (msg) g_object_unref (msg); return rv; }
/** * Output a list of the parts included in the current message. */ void dump_mail( char *filename ) { std::string result; GMimeMessage *m_message; GMimeParser *parser; GMimeStream *stream; int fd; std::cout << "File: " << filename << std::endl; if ((fd = open( filename, O_RDONLY, 0)) == -1) { std::cout << "Opening failed ..." << std::endl; return; } stream = g_mime_stream_fs_new (fd); parser = g_mime_parser_new_with_stream (stream); g_object_unref (stream); m_message = g_mime_parser_construct_message (parser); g_object_unref (parser); /** * Create an iterator */ GMimePartIter *iter = g_mime_part_iter_new ((GMimeObject *) m_message); int count = 1; /** * Iterate over the message. */ do { GMimeObject *part = g_mime_part_iter_get_current (iter); if ( ( GMIME_IS_OBJECT( part ) ) && ( GMIME_IS_PART(part) ) ) { /** * Get the content-type */ GMimeContentType *content_type = g_mime_object_get_content_type (part); const char *filename = g_mime_object_get_content_disposition_parameter(part, "filename"); gchar *type = g_mime_content_type_to_string ( content_type ); std::cout << count << " " << type << std::endl; if ( filename ) std::cout << "\t[This is an attachment with file-name " << filename << "]" << std::endl; } /** * Highlight inline parts - which are not attachments. */ GMimeContentDisposition *disp = g_mime_object_get_content_disposition(part); if ( disp != NULL ) { const char *str = g_mime_content_disposition_get_disposition (disp); std::cout << "\tNOTE: Content-Disposition: " << str << std::endl; } count += 1; } while (g_mime_part_iter_next (iter)); g_mime_part_iter_free (iter); g_object_unref(m_message); }
document* parse_file(const char *file_name) { int tallied_length = 0; GMimeStream *stream; GMimeMessage *msg = 0; // struct stat stat_buf; const char *author, *subject, *xref, *xref_end; time_t date; int offset; int num_words = 0; int file; InternetAddress *iaddr; InternetAddressList *iaddr_list; char *address; #if DEBUG printf("%s\n", file_name); #endif /* if ((file = stat(file_name, &stat_buf)) == -1) { perror("tokenizer"); return NULL; } */ // |O_STREAMING if ((file = open(file_name, O_RDONLY|O_STREAMING)) == -1) { perror("tokenizer"); return NULL; } #ifdef POSIX_FADV_NOREUSE no_reuse(file); #endif stream = g_mime_stream_fs_new(file); msg = g_mime_parser_construct_message(stream); g_mime_stream_unref(stream); if (msg != 0) { table = g_hash_table_new(g_str_hash, g_str_equal); bufp = buffer; dword_table[0].word = NULL; bzero(saved_body, MAX_SAVED_BODY_LENGTH); saved_body_length = 0; author = g_mime_message_get_sender(msg); subject = g_mime_message_get_subject(msg); xref = g_mime_message_get_header(msg, "Xref"); g_mime_message_get_date(msg, &date, &offset); if (author != NULL && subject != NULL && xref != NULL) { tallied_length = tally_string(author, tallied_length); strncpy(doc.author, author, MAX_HEADER_LENGTH-1); /* Get the address from the From header. */ if ((iaddr_list = internet_address_parse_string(author)) != NULL) { iaddr = iaddr_list->address; internet_address_set_name(iaddr, NULL); address = internet_address_to_string(iaddr, FALSE); strncpy(doc.address, address, MAX_HEADER_LENGTH-1); downcase_string(doc.address); free(address); internet_address_list_destroy(iaddr_list); } else { *doc.address = 0; } tallied_length = tally_string(subject, tallied_length); strncpy(doc.subject, subject, MAX_HEADER_LENGTH-1); doc.time = date; if ((xref = strchr(xref, ' ')) != NULL) { xref++; xref_end = strchr(xref, ':'); *doc.group = 0; strncat(doc.group, xref, min(xref_end-xref, MAX_HEADER_LENGTH-1)); xref_end++; sscanf(xref_end, "%d", &doc.article); } g_mime_message_foreach_part(msg, partFound, (gpointer) &tallied_length); strncpy(doc.body, saved_body, MAX_SAVED_BODY_LENGTH); g_hash_table_foreach(table, add_word_to_table, (gpointer) &num_words); dword_table[num_words].word = NULL; g_hash_table_destroy(table); g_mime_object_unref(GMIME_OBJECT(msg)); } else { close(file); return NULL; } } close(file); doc.words = dword_table; doc.num_words = num_words; return &doc; }
static void test_parser (GMimeParser *parser, GMimeStream *mbox, GMimeStream *summary) { gint64 message_begin, message_end, headers_begin, headers_end; GMimeFormatOptions *format = g_mime_format_options_get_default (); InternetAddressList *list; GMimeMessage *message; char *marker, *buf; const char *subject; GMimeObject *body; GDateTime *date; int nmsg = 0; while (!g_mime_parser_eos (parser)) { message_begin = g_mime_parser_tell (parser); if (!(message = g_mime_parser_construct_message (parser, NULL))) throw (exception_new ("failed to parse message #%d", nmsg)); message_end = g_mime_parser_tell (parser); headers_begin = g_mime_parser_get_headers_begin (parser); headers_end = g_mime_parser_get_headers_end (parser); g_mime_stream_printf (summary, "message offsets: %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT "\n", message_begin, message_end); g_mime_stream_printf (summary, "header offsets: %" G_GINT64_FORMAT ", %" G_GINT64_FORMAT "\n", headers_begin, headers_end); marker = g_mime_parser_get_mbox_marker (parser); g_mime_stream_printf (summary, "%s\n", marker); if ((list = g_mime_message_get_from (message)) != NULL && internet_address_list_length (list) > 0) { buf = internet_address_list_to_string (list, format, FALSE); g_mime_stream_printf (summary, "From: %s\n", buf); g_free (buf); } if ((list = g_mime_message_get_addresses (message, GMIME_ADDRESS_TYPE_TO)) != NULL && internet_address_list_length (list) > 0) { buf = internet_address_list_to_string (list, format, FALSE); g_mime_stream_printf (summary, "To: %s\n", buf); g_free (buf); } if (!(subject = g_mime_message_get_subject (message))) subject = ""; g_mime_stream_printf (summary, "Subject: %s\n", subject); if (!(date = g_mime_message_get_date (message))) { date = g_date_time_new_from_unix_utc (0); } else { g_date_time_ref (date); } buf = g_mime_utils_header_format_date (date); g_mime_stream_printf (summary, "Date: %s\n", buf); g_date_time_unref (date); g_free (buf); body = g_mime_message_get_mime_part (message); print_mime_struct (summary, body, 0); g_mime_stream_write (summary, "\n", 1); if (mbox) { if (nmsg > 0) g_mime_stream_write (mbox, "\n", 1); g_mime_stream_printf (mbox, "%s\n", marker); g_mime_object_write_to_stream ((GMimeObject *) message, format, mbox); } g_object_unref (message); g_free (marker); nmsg++; } }
static void rspamd_process_file (struct rspamd_config *cfg, const gchar *fname, gint mode) { struct rspamd_task *task; gint fd; gpointer map; struct stat st; GError *err = NULL; #if 0 GMimeMessage *message; GMimeParser *parser; GMimeStream *stream; GByteArray tmp; #endif struct rspamd_mime_part *part; guint i; gdouble ts1, ts2; fd = open (fname, O_RDONLY); if (fd == -1) { rspamd_fprintf (stderr, "cannot open %s: %s\n", fname, strerror (errno)); exit (EXIT_FAILURE); } if (fstat (fd, &st) == -1) { rspamd_fprintf (stderr, "cannot stat %s: %s\n", fname, strerror (errno)); exit (EXIT_FAILURE); } map = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0); close (fd); if (map == MAP_FAILED) { rspamd_fprintf (stderr, "cannot mmap %s: %s\n", fname, strerror (errno)); exit (EXIT_FAILURE); } task = rspamd_task_new (NULL, cfg); task->msg.begin = map; task->msg.len = st.st_size; ts1 = rspamd_get_ticks (); if (mode == MODE_NORMAL) { if (!rspamd_mime_parse_task (task, &err)) { rspamd_fprintf (stderr, "cannot parse %s: %e\n", fname, err); g_error_free (err); } } #if 0 else if (mode == MODE_GMIME) { tmp.data = map; tmp.len = st.st_size; stream = g_mime_stream_mem_new_with_byte_array (&tmp); g_mime_stream_mem_set_owner (GMIME_STREAM_MEM (stream), FALSE); parser = g_mime_parser_new_with_stream (stream); message = g_mime_parser_construct_message (parser); } #endif ts2 = rspamd_get_ticks (); total_time += ts2 - ts1; if (mode == MODE_NORMAL) { for (i = 0; i < task->parts->len; i ++) { part = g_ptr_array_index (task->parts, i); if (part->ct->flags & RSPAMD_CONTENT_TYPE_MULTIPART) { rspamd_show_multipart (part); } else if (part->ct->flags & RSPAMD_CONTENT_TYPE_MESSAGE) { rspamd_show_message (part); } else { rspamd_show_normal (part); } } } #if 0 else if (mode == MODE_GMIME) { g_mime_message_foreach (message, mime_foreach_callback, NULL); } #endif rspamd_task_free (task); munmap (map, st.st_size); #if 0 if (mode == MODE_GMIME) { g_object_unref (message); } #endif }