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