git.notmuchmail.org Git - notmuch/blob - util/gmime-extra.c

   1 #include "gmime-extra.h"
   2 #include <string.h>
   3
   4 static
   5 GMimeStream *
   6 _gzfile_maybe_filter (GMimeStream *file_stream) {
   7     char buf[4];
   8     int bytes_read;
   9
  10     if ((bytes_read = g_mime_stream_read (file_stream, buf, sizeof (buf))) < 0)
  11         return NULL;
  12
  13     if (g_mime_stream_reset (file_stream))
  14         return NULL;
  15
  16     /* check for gzipped input */
  17     if (bytes_read >= 2 && buf[0] == 0x1f && (unsigned char)buf[1] == 0x8b) {
  18         GMimeStream *gzstream;
  19         GMimeFilter *gzfilter;
  20
  21         gzfilter = g_mime_filter_gzip_new (GMIME_FILTER_GZIP_MODE_UNZIP, 0);
  22         if (! gzfilter)
  23             return NULL;
  24
  25         gzstream = g_mime_stream_filter_new (file_stream);
  26         if (! gzstream)
  27             return NULL;
  28
  29         /* ignore filter id */
  30         (void) g_mime_stream_filter_add ((GMimeStreamFilter *) gzstream, gzfilter);
  31         g_object_unref (gzfilter);
  32         g_object_unref (file_stream);
  33         return gzstream;
  34     } else {
  35         return file_stream;
  36     }
  37 }
  38
  39 GMimeStream *
  40 g_mime_stream_gzfile_new (int fd)
  41 {
  42     GMimeStream *file_stream;
  43
  44     file_stream = g_mime_stream_fs_new (fd);
  45     if (! file_stream)
  46         return NULL;
  47
  48     return _gzfile_maybe_filter (file_stream);
  49 }
  50
  51 GMimeStream *
  52 g_mime_stream_gzfile_open (const char *filename)
  53 {
  54     GMimeStream *file_stream;
  55
  56     file_stream = g_mime_stream_fs_open (filename, 0, 0, NULL);
  57     if (! file_stream)
  58         return NULL;
  59
  60     return _gzfile_maybe_filter (file_stream);
  61 }
  62
  63 GMimeStream *
  64 g_mime_stream_stdout_new()
  65 {
  66     GMimeStream *stream_stdout = NULL;
  67     GMimeStream *stream_buffered = NULL;
  68
  69     stream_stdout = g_mime_stream_pipe_new (STDOUT_FILENO);
  70     if (!stream_stdout)
  71         return NULL;
  72
  73     g_mime_stream_pipe_set_owner (GMIME_STREAM_PIPE (stream_stdout), FALSE);
  74
  75     stream_buffered = g_mime_stream_buffer_new (stream_stdout, GMIME_STREAM_BUFFER_BLOCK_WRITE);
  76
  77     g_object_unref (stream_stdout);
  78
  79     return stream_buffered;
  80 }
  81
  82 /**
  83  * copy a glib string into a talloc context, and free it.
  84  */
  85 static char*
  86 g_string_talloc_strdup (void *ctx, char *g_string)
  87 {
  88     char *new_str = talloc_strdup (ctx, g_string);
  89     g_free (g_string);
  90     return new_str;
  91 }
  92
  93 const char *
  94 g_mime_certificate_get_valid_userid (GMimeCertificate *cert)
  95 {
  96     /* output user id only if validity is FULL or ULTIMATE. */
  97     const char *uid = g_mime_certificate_get_user_id (cert);
  98     if (uid == NULL)
  99         return uid;
 100     GMimeValidity validity = g_mime_certificate_get_id_validity (cert);
 101     if (validity == GMIME_VALIDITY_FULL || validity == GMIME_VALIDITY_ULTIMATE)
 102         return uid;
 103     return NULL;
 104 }
 105
 106 const char*
 107 g_mime_certificate_get_fpr16 (GMimeCertificate *cert) {
 108     const char *fpr = g_mime_certificate_get_fingerprint (cert);
 109     if (!fpr || strlen (fpr) < 16)
 110         return fpr;
 111
 112     return fpr + (strlen (fpr) - 16);
 113 }
 114
 115 char *
 116 g_mime_message_get_address_string (GMimeMessage *message, GMimeAddressType type)
 117 {
 118     InternetAddressList *list = g_mime_message_get_addresses (message, type);
 119     return internet_address_list_to_string (list, NULL, 0);
 120 }
 121
 122 char *
 123 g_mime_message_get_date_string (void *ctx, GMimeMessage *message)
 124 {
 125     GDateTime* parsed_date = g_mime_message_get_date (message);
 126     if (parsed_date) {
 127         char *date = g_mime_utils_header_format_date (parsed_date);
 128         return g_string_talloc_strdup (ctx, date);
 129     } else {
 130         return talloc_strdup(ctx, "Thu, 01 Jan 1970 00:00:00 +0000");
 131     }
 132 }
 133
 134 InternetAddressList *
 135 g_mime_message_get_reply_to_list(GMimeMessage *message)
 136 {
 137     return g_mime_message_get_reply_to (message);
 138 }
 139
 140 const char *
 141 g_mime_message_get_from_string (GMimeMessage *message)
 142 {
 143     return g_mime_object_get_header (GMIME_OBJECT (message), "From");
 144 }
 145
 146 char *
 147 g_mime_message_get_reply_to_string (void *ctx, GMimeMessage *message)
 148 {
 149     InternetAddressList *list = g_mime_message_get_reply_to (message);
 150     return g_string_talloc_strdup (ctx, internet_address_list_to_string (list, NULL, 0));
 151 }
 152
 153 void
 154 g_mime_parser_set_scan_from (GMimeParser *parser, gboolean flag)
 155 {
 156     g_mime_parser_set_format (parser, flag ? GMIME_FORMAT_MBOX : GMIME_FORMAT_MESSAGE);
 157 }
 158
 159 /* In GMime 3.0, status GOOD and VALID both imply something about the
 160  * validity of the UIDs attached to the signing key. This forces us to
 161  * use following somewhat relaxed definition of a "good" signature to
 162  * preserve current notmuch semantics.
 163  */
 164
 165 gboolean
 166 g_mime_signature_status_good (GMimeSignatureStatus status) {
 167     return ((status  & (GMIME_SIGNATURE_STATUS_RED | GMIME_SIGNATURE_STATUS_ERROR_MASK)) == 0);
 168 }
 169
 170 gboolean
 171 g_mime_signature_status_bad (GMimeSignatureStatus status) {
 172     return (status & GMIME_SIGNATURE_STATUS_RED);
 173 }
 174
 175 gboolean
 176 g_mime_signature_status_error (GMimeSignatureStatus status) {
 177     return (status & GMIME_SIGNATURE_STATUS_ERROR_MASK);
 178 }
 179
 180 gint64
 181 g_mime_utils_header_decode_date_unix (const char *date) {
 182     GDateTime* parsed_date = g_mime_utils_header_decode_date (date);
 183     time_t ret;
 184
 185     if (parsed_date) {
 186         ret = g_date_time_to_unix (parsed_date);
 187         g_date_time_unref (parsed_date);
 188     } else {
 189         ret = 0;
 190     }
 191
 192     return ret;
 193 }