gmime/gmime-filter-basic.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*  GMime
   3  *  Copyright (C) 2000-2012 Jeffrey Stedfast
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Lesser General Public License
   7  *  as published by the Free Software Foundation; either version 2.1
   8  *  of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  Lesser General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Lesser General Public
  16  *  License along with this library; if not, write to the Free
  17  *  Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  18  *  02110-1301, USA.
  19  */
  20
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <string.h>
  27
  28 #include "gmime-filter-basic.h"
  29 #include "gmime-utils.h"
  30
  31
  32 /**
  33  * SECTION: gmime-filter-basic
  34  * @title: GMimeFilterBasic
  35  * @short_description: Basic transfer encoding filter
  36  * @see_also: #GMimeFilter
  37  *
  38  * A #GMimeFilter which can encode or decode basic MIME encodings such
  39  * as Quoted-Printable, Base64 and UUEncode.
  40  **/
  41
  42
  43 static void g_mime_filter_basic_class_init (GMimeFilterBasicClass *klass);
  44 static void g_mime_filter_basic_init (GMimeFilterBasic *filter, GMimeFilterBasicClass *klass);
  45 static void g_mime_filter_basic_finalize (GObject *object);
  46
  47 static GMimeFilter *filter_copy (GMimeFilter *filter);
  48 static void filter_filter (GMimeFilter *filter, char *in, size_t len, size_t prespace,
  49                            char **out, size_t *outlen, size_t *outprespace);
  50 static void filter_complete (GMimeFilter *filter, char *in, size_t len, size_t prespace,
  51                              char **out, size_t *outlen, size_t *outprespace);
  52 static void filter_reset (GMimeFilter *filter);
  53
  54
  55 static GMimeFilterClass *parent_class = NULL;
  56
  57
  58 GType
  59 g_mime_filter_basic_get_type (void)
  60 {
  61         static GType type = 0;
  62
  63         if (!type) {
  64                 static const GTypeInfo info = {
  65                         sizeof (GMimeFilterBasicClass),
  66                         NULL, /* base_class_init */
  67                         NULL, /* base_class_finalize */
  68                         (GClassInitFunc) g_mime_filter_basic_class_init,
  69                         NULL, /* class_finalize */
  70                         NULL, /* class_data */
  71                         sizeof (GMimeFilterBasic),
  72                         0,    /* n_preallocs */
  73                         (GInstanceInitFunc) g_mime_filter_basic_init,
  74                 };
  75
  76                 type = g_type_register_static (GMIME_TYPE_FILTER, "GMimeFilterBasic", &info, 0);
  77         }
  78
  79         return type;
  80 }
  81
  82
  83 static void
  84 g_mime_filter_basic_class_init (GMimeFilterBasicClass *klass)
  85 {
  86         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  87         GMimeFilterClass *filter_class = GMIME_FILTER_CLASS (klass);
  88
  89         parent_class = g_type_class_ref (GMIME_TYPE_FILTER);
  90
  91         object_class->finalize = g_mime_filter_basic_finalize;
  92
  93         filter_class->copy = filter_copy;
  94         filter_class->filter = filter_filter;
  95         filter_class->complete = filter_complete;
  96         filter_class->reset = filter_reset;
  97 }
  98
  99 static void
 100 g_mime_filter_basic_init (GMimeFilterBasic *filter, GMimeFilterBasicClass *klass)
 101 {
 102
 103 }
 104
 105 static void
 106 g_mime_filter_basic_finalize (GObject *object)
 107 {
 108         G_OBJECT_CLASS (parent_class)->finalize (object);
 109 }
 110
 111
 112 static GMimeFilter *
 113 filter_copy (GMimeFilter *filter)
 114 {
 115         GMimeFilterBasic *basic = (GMimeFilterBasic *) filter;
 116         GMimeEncoding *encoder = &basic->encoder;
 117
 118         return g_mime_filter_basic_new (encoder->encoding, encoder->encode);
 119 }
 120
 121 /* here we do all of the basic mime filtering */
 122 static void
 123 filter_filter (GMimeFilter *filter, char *inbuf, size_t inlen, size_t prespace,
 124                char **outbuf, size_t *outlen, size_t *outprespace)
 125 {
 126         GMimeFilterBasic *basic = (GMimeFilterBasic *) filter;
 127         GMimeEncoding *encoder = &basic->encoder;
 128         size_t nwritten = 0;
 129         size_t len;
 130
 131         if (!encoder->encode && encoder->encoding == GMIME_CONTENT_ENCODING_UUENCODE) {
 132                 if (!(encoder->state & GMIME_UUDECODE_STATE_BEGIN)) {
 133                         register char *inptr, *inend;
 134                         size_t left;
 135
 136                         inend = inbuf + inlen;
 137                         inptr = inbuf;
 138
 139                         while (inptr < inend) {
 140                                 left = inend - inptr;
 141                                 if (left < 6) {
 142                                         if (!strncmp (inptr, "begin ", left))
 143                                                 g_mime_filter_backup (filter, inptr, left);
 144                                         break;
 145                                 } else if (!strncmp (inptr, "begin ", 6)) {
 146                                         inbuf = inptr;
 147                                         while (inptr < inend && *inptr != '\n')
 148                                                 inptr++;
 149
 150                                         if (inptr < inend) {
 151                                                 inptr++;
 152                                                 encoder->state |= GMIME_UUDECODE_STATE_BEGIN;
 153                                                 /* we can start uudecoding... */
 154                                                 inlen = inend - inptr;
 155                                                 inbuf = inptr;
 156                                         } else {
 157                                                 g_mime_filter_backup (filter, inbuf, left);
 158                                         }
 159                                         break;
 160                                 }
 161
 162                                 /* go to the next line */
 163                                 while (inptr < inend && *inptr != '\n')
 164                                         inptr++;
 165
 166                                 if (inptr < inend)
 167                                         inptr++;
 168                         }
 169                 }
 170
 171                 switch (encoder->state & GMIME_UUDECODE_STATE_MASK) {
 172                 case GMIME_UUDECODE_STATE_BEGIN:
 173                         /* "begin <mode> <filename>\n" has been found and not yet seen the end */
 174                         break;
 175                 default:
 176                         /* either we haven't seen the begin-line or we've finished decoding */
 177                         goto done;
 178                 }
 179         }
 180
 181         len = g_mime_encoding_outlen (encoder, inlen);
 182         g_mime_filter_set_size (filter, len, FALSE);
 183         nwritten = g_mime_encoding_step (encoder, inbuf, inlen, filter->outbuf);
 184         g_assert (nwritten <= len);
 185
 186  done:
 187         *outprespace = filter->outpre;
 188         *outbuf = filter->outbuf;
 189         *outlen = nwritten;
 190 }
 191
 192 static void
 193 filter_complete (GMimeFilter *filter, char *inbuf, size_t inlen, size_t prespace,
 194                  char **outbuf, size_t *outlen, size_t *outprespace)
 195 {
 196         GMimeFilterBasic *basic = (GMimeFilterBasic *) filter;
 197         GMimeEncoding *encoder = &basic->encoder;
 198         size_t nwritten = 0;
 199         size_t len;
 200
 201         if (!encoder->encode && encoder->encoding == GMIME_CONTENT_ENCODING_UUENCODE) {
 202                 switch (encoder->state & GMIME_UUDECODE_STATE_MASK) {
 203                 case GMIME_UUDECODE_STATE_BEGIN:
 204                         /* "begin <mode> <filename>\n" has been found and not yet seen the end */
 205                         break;
 206                 default:
 207                         /* either we haven't seen the begin-line or we've finished decoding */
 208                         goto done;
 209                 }
 210         }
 211
 212         len = g_mime_encoding_outlen (encoder, inlen);
 213         g_mime_filter_set_size (filter, len, FALSE);
 214         nwritten = g_mime_encoding_flush (encoder, inbuf, inlen, filter->outbuf);
 215         g_assert (nwritten <= len);
 216
 217  done:
 218
 219         *outprespace = filter->outpre;
 220         *outbuf = filter->outbuf;
 221         *outlen = nwritten;
 222 }
 223
 224 /* should this 'flush' outstanding state/data bytes? */
 225 static void
 226 filter_reset (GMimeFilter *filter)
 227 {
 228         GMimeFilterBasic *basic = (GMimeFilterBasic *) filter;
 229
 230         g_mime_encoding_reset (&basic->encoder);
 231 }
 232
 233
 234 /**
 235  * g_mime_filter_basic_new:
 236  * @encoding: a #GMimeContentEncoding
 237  * @encode: %TRUE to encode or %FALSE to decode
 238  *
 239  * Creates a new basic filter for @encoding.
 240  *
 241  * Returns: a new basic encoder filter.
 242  **/
 243 GMimeFilter *
 244 g_mime_filter_basic_new (GMimeContentEncoding encoding, gboolean encode)
 245 {
 246         GMimeFilterBasic *basic;
 247
 248         basic = g_object_newv (GMIME_TYPE_FILTER_BASIC, 0, NULL);
 249
 250         if (encode)
 251                 g_mime_encoding_init_encode (&basic->encoder, encoding);
 252         else
 253                 g_mime_encoding_init_decode (&basic->encoder, encoding);
 254
 255         return (GMimeFilter *) basic;
 256 }