camel/camel-nntp-address.c

   1 /*
   2  * Copyright (C) 2005 Novell Inc.
   3  *
   4  * Authors: Michael Zucchi <notzed@ximian.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of version 2 of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation.
   9  *
  10  * This program 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  * 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 program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include <stdio.h>
  22 #include <string.h>
  23
  24 #include "camel-mime-utils.h"
  25 #include "camel-nntp-address.h"
  26
  27 #define d(x)
  28
  29 static int    nntp_decode               (CamelAddress *, const char *raw);
  30 static char * nntp_encode               (CamelAddress *);
  31 static int    nntp_cat          (CamelAddress *dest, const CamelAddress *source);
  32 static void   nntp_remove               (CamelAddress *, int index);
  33
  34 static void camel_nntp_address_class_init (CamelNNTPAddressClass *klass);
  35 static void camel_nntp_address_init       (CamelNNTPAddress *obj);
  36
  37 static CamelAddressClass *camel_nntp_address_parent;
  38
  39 struct _address {
  40         char *name;
  41         char *address;
  42 };
  43
  44 static void
  45 camel_nntp_address_class_init(CamelNNTPAddressClass *klass)
  46 {
  47         CamelAddressClass *address = (CamelAddressClass *) klass;
  48
  49         camel_nntp_address_parent = CAMEL_ADDRESS_CLASS(camel_type_get_global_classfuncs(camel_address_get_type()));
  50
  51         address->decode = nntp_decode;
  52         address->encode = nntp_encode;
  53         address->unformat = nntp_decode;
  54         address->format = nntp_encode;
  55         address->remove = nntp_remove;
  56         address->cat = nntp_cat;
  57 }
  58
  59 static void
  60 camel_nntp_address_init(CamelNNTPAddress *obj)
  61 {
  62 }
  63
  64 CamelType
  65 camel_nntp_address_get_type(void)
  66 {
  67         static CamelType type = CAMEL_INVALID_TYPE;
  68
  69         if (type == CAMEL_INVALID_TYPE) {
  70                 type = camel_type_register(camel_address_get_type(), "CamelNNTPAddress",
  71                                            sizeof (CamelNNTPAddress),
  72                                            sizeof (CamelNNTPAddressClass),
  73                                            (CamelObjectClassInitFunc) camel_nntp_address_class_init,
  74                                            NULL,
  75                                            (CamelObjectInitFunc) camel_nntp_address_init,
  76                                            NULL);
  77         }
  78
  79         return type;
  80 }
  81
  82 /* since newsgropus are 7bit ascii, decode/unformat are the same */
  83 static int
  84 nntp_decode(CamelAddress *a, const char *raw)
  85 {
  86         struct _camel_header_newsgroup *ha, *n;
  87         int count = a->addresses->len;
  88
  89         ha = camel_header_newsgroups_decode(raw);
  90         if (ha) {
  91                 for (n = ha;n;n=n->next)
  92                         camel_nntp_address_add((CamelNNTPAddress *)a, n->newsgroup);
  93                 camel_header_newsgroups_free(ha);
  94         }
  95
  96         return a->addresses->len - count;
  97 }
  98
  99 /* since newsgropus are 7bit ascii, encode/format are the same */
 100 static char *
 101 nntp_encode(CamelAddress *a)
 102 {
 103         int i;
 104         GString *out;
 105         char *ret;
 106
 107         if (a->addresses->len == 0)
 108                 return NULL;
 109
 110         out = g_string_new("");
 111
 112         for (i = 0;i < a->addresses->len; i++) {
 113                 if (i != 0)
 114                         g_string_append(out, ", ");
 115
 116                 g_string_append(out, g_ptr_array_index(a->addresses, i));
 117         }
 118
 119         ret = out->str;
 120         g_string_free(out, FALSE);
 121
 122         return ret;
 123 }
 124
 125 static int
 126 nntp_cat (CamelAddress *dest, const CamelAddress *source)
 127 {
 128         int i;
 129
 130         g_assert(CAMEL_IS_NNTP_ADDRESS(source));
 131
 132         for (i=0;i<source->addresses->len;i++)
 133                 camel_nntp_address_add((CamelNNTPAddress *)dest, g_ptr_array_index(source->addresses, i));
 134
 135         return i;
 136 }
 137
 138 static void
 139 nntp_remove     (CamelAddress *a, int index)
 140 {
 141         if (index < 0 || index >= a->addresses->len)
 142                 return;
 143
 144         g_free(g_ptr_array_index(a->addresses, index));
 145         g_ptr_array_remove_index(a->addresses, index);
 146 }
 147
 148 /**
 149  * camel_nntp_address_new:
 150  *
 151  * Create a new CamelNNTPAddress object.
 152  *
 153  * Return value: A new CamelNNTPAddress object.
 154  **/
 155 CamelNNTPAddress *
 156 camel_nntp_address_new (void)
 157 {
 158         CamelNNTPAddress *new = CAMEL_NNTP_ADDRESS(camel_object_new(camel_nntp_address_get_type()));
 159         return new;
 160 }
 161
 162 /**
 163  * camel_nntp_address_add:
 164  * @a: nntp address object
 165  * @name:
 166  *
 167  * Add a new nntp address to the address object.  Duplicates are not added twice.
 168  *
 169  * Return value: Index of added entry, or existing matching entry.
 170  **/
 171 int
 172 camel_nntp_address_add (CamelNNTPAddress *a, const char *name)
 173 {
 174         int index, i;
 175
 176         g_assert(CAMEL_IS_NNTP_ADDRESS(a));
 177
 178         index = ((CamelAddress *)a)->addresses->len;
 179         for (i=0;i<index;i++)
 180                 if (!strcmp(g_ptr_array_index(((CamelAddress *)a)->addresses, i), name))
 181                         return i;
 182
 183         g_ptr_array_add(((CamelAddress *)a)->addresses, g_strdup(name));
 184
 185         return index;
 186 }
 187
 188 /**
 189  * camel_nntp_address_get:
 190  * @a: nntp address object
 191  * @index: address's array index
 192  * @addressp: Holder for the returned address, or NULL, if not required.
 193  *
 194  * Get the address at @index.
 195  *
 196  * Return value: TRUE if such an address exists, or FALSE otherwise.
 197  **/
 198 gboolean
 199 camel_nntp_address_get (const CamelNNTPAddress *a, int index, const char **namep)
 200 {
 201         g_assert(CAMEL_IS_NNTP_ADDRESS(a));
 202
 203         if (index < 0 || index >= ((CamelAddress *)a)->addresses->len)
 204                 return FALSE;
 205
 206         if (namep)
 207                 *namep = g_ptr_array_index( ((CamelAddress *)a)->addresses, index);
 208
 209         return TRUE;
 210 }