src/privacy.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 1999-2003 Hiroyuki Yamamoto & the Sylpheed-Claws team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   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
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <glib.h>
  21 #include <glib/gi18n.h>
  22
  23 #include "privacy.h"
  24 #include "procmime.h"
  25
  26 static GSList *systems = NULL;
  27
  28 PrivacySystem *privacy_data_get_system(PrivacyData *data)
  29 {
  30         /* Make sure the cached system is still registered */
  31         if (data->system && g_slist_find(systems, data->system))
  32                 return data->system;
  33         else
  34                 return NULL;
  35 }
  36 /**
  37  * Register a new Privacy System
  38  *
  39  * \param system The Privacy System that should be registered
  40  */
  41 void privacy_register_system(PrivacySystem *system)
  42 {
  43         systems = g_slist_append(systems, system);
  44 }
  45
  46 /**
  47  * Unregister a new Privacy System. The system must not be in
  48  * use anymore when it is unregistered.
  49  *
  50  * \param system The Privacy System that should be unregistered
  51  */
  52 void privacy_unregister_system(PrivacySystem *system)
  53 {
  54         systems = g_slist_remove(systems, system);
  55 }
  56
  57 /**
  58  * Free a PrivacyData of a PrivacySystem
  59  *
  60  * \param privacydata The data to free
  61  */
  62 void privacy_free_privacydata(PrivacyData *privacydata)
  63 {
  64         PrivacySystem *system = NULL;
  65
  66         g_return_if_fail(privacydata != NULL);
  67
  68         system = privacy_data_get_system(privacydata);
  69         if (!system)
  70                 return;
  71         system->free_privacydata(privacydata);
  72 }
  73
  74 /**
  75  * Check if a MimeInfo is signed with one of the available
  76  * privacy system. If a privacydata is set in the MimeInfo
  77  * it will directory return the return value by the system
  78  * set in the privacy data or check all available privacy
  79  * systems otherwise.
  80  *
  81  * \return True if the MimeInfo has a signature
  82  */
  83 gboolean privacy_mimeinfo_is_signed(MimeInfo *mimeinfo)
  84 {
  85         GSList *cur;
  86         g_return_val_if_fail(mimeinfo != NULL, FALSE);
  87
  88         if (mimeinfo->privacy != NULL) {
  89                 PrivacySystem *system =
  90                         privacy_data_get_system(mimeinfo->privacy);
  91
  92                 if (system == NULL) {
  93                         mimeinfo->privacy = NULL;
  94                         goto try_others;
  95                 }
  96
  97                 if (system->is_signed != NULL)
  98                         return system->is_signed(mimeinfo);
  99                 else
 100                         return FALSE;
 101         }
 102 try_others:
 103         for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
 104                 PrivacySystem *system = (PrivacySystem *) cur->data;
 105
 106                 if(system->is_signed != NULL && system->is_signed(mimeinfo))
 107                         return TRUE;
 108         }
 109
 110         return FALSE;
 111 }
 112
 113 /**
 114  * Check the signature of a MimeInfo. privacy_mimeinfo_is_signed
 115  * should be called before otherwise it is done by this function.
 116  * If the MimeInfo is not signed an error code will be returned.
 117  *
 118  * \return Error code indicating the result of the check,
 119  *         < 0 if an error occured
 120  */
 121 gint privacy_mimeinfo_check_signature(MimeInfo *mimeinfo)
 122 {
 123         PrivacySystem *system;
 124
 125         g_return_val_if_fail(mimeinfo != NULL, -1);
 126
 127         if (mimeinfo->privacy == NULL)
 128                 privacy_mimeinfo_is_signed(mimeinfo);
 129
 130         if (mimeinfo->privacy == NULL)
 131                 return -1;
 132
 133         system = privacy_data_get_system(mimeinfo->privacy);
 134         if (system == NULL)
 135                 return -1;
 136
 137         if (system->check_signature == NULL)
 138                 return -1;
 139
 140         return system->check_signature(mimeinfo);
 141 }
 142
 143 SignatureStatus privacy_mimeinfo_get_sig_status(MimeInfo *mimeinfo)
 144 {
 145         PrivacySystem *system;
 146
 147         g_return_val_if_fail(mimeinfo != NULL, -1);
 148
 149         if (mimeinfo->privacy == NULL)
 150                 privacy_mimeinfo_is_signed(mimeinfo);
 151
 152         if (mimeinfo->privacy == NULL)
 153                 return SIGNATURE_UNCHECKED;
 154
 155         system = privacy_data_get_system(mimeinfo->privacy);
 156         if (system == NULL)
 157                 return SIGNATURE_UNCHECKED;
 158         if (system->get_sig_status == NULL)
 159                 return SIGNATURE_UNCHECKED;
 160
 161         return system->get_sig_status(mimeinfo);
 162 }
 163
 164 gchar *privacy_mimeinfo_sig_info_short(MimeInfo *mimeinfo)
 165 {
 166         PrivacySystem *system;
 167
 168         g_return_val_if_fail(mimeinfo != NULL, NULL);
 169
 170         if (mimeinfo->privacy == NULL)
 171                 privacy_mimeinfo_is_signed(mimeinfo);
 172
 173         if (mimeinfo->privacy == NULL)
 174                 return g_strdup(_("No signature found"));
 175
 176         system = privacy_data_get_system(mimeinfo->privacy);
 177         if (system == NULL)
 178                 return g_strdup(_("No signature found"));
 179         if (system->get_sig_info_short == NULL)
 180                 return g_strdup(_("No information available"));
 181
 182         return system->get_sig_info_short(mimeinfo);
 183 }
 184
 185 gchar *privacy_mimeinfo_sig_info_full(MimeInfo *mimeinfo)
 186 {
 187         PrivacySystem *system;
 188
 189         g_return_val_if_fail(mimeinfo != NULL, NULL);
 190
 191         if (mimeinfo->privacy == NULL)
 192                 privacy_mimeinfo_is_signed(mimeinfo);
 193
 194         if (mimeinfo->privacy == NULL)
 195                 return g_strdup(_("No signature found"));
 196
 197         system = privacy_data_get_system(mimeinfo->privacy);
 198         if (system == NULL)
 199                 return g_strdup(_("No signature found"));
 200         if (system->get_sig_info_full == NULL)
 201                 return g_strdup(_("No information available"));
 202
 203         return system->get_sig_info_full(mimeinfo);
 204 }
 205
 206 gboolean privacy_mimeinfo_is_encrypted(MimeInfo *mimeinfo)
 207 {
 208         GSList *cur;
 209         g_return_val_if_fail(mimeinfo != NULL, FALSE);
 210
 211         for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
 212                 PrivacySystem *system = (PrivacySystem *) cur->data;
 213
 214                 if(system->is_encrypted != NULL && system->is_encrypted(mimeinfo))
 215                         return TRUE;
 216         }
 217
 218         return FALSE;
 219 }
 220
 221 static gint decrypt(MimeInfo *mimeinfo, PrivacySystem *system)
 222 {
 223         MimeInfo *decryptedinfo, *parentinfo;
 224         gint childnumber;
 225
 226         g_return_val_if_fail(system->decrypt != NULL, -1);
 227
 228         decryptedinfo = system->decrypt(mimeinfo);
 229         if (decryptedinfo == NULL)
 230                 return -1;
 231
 232         parentinfo = procmime_mimeinfo_parent(mimeinfo);
 233         childnumber = g_node_child_index(parentinfo->node, mimeinfo);
 234
 235         procmime_mimeinfo_free_all(mimeinfo);
 236
 237         g_node_insert(parentinfo->node, childnumber, decryptedinfo->node);
 238
 239         return 0;
 240 }
 241
 242 gint privacy_mimeinfo_decrypt(MimeInfo *mimeinfo)
 243 {
 244         GSList *cur;
 245         g_return_val_if_fail(mimeinfo != NULL, FALSE);
 246
 247         for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
 248                 PrivacySystem *system = (PrivacySystem *) cur->data;
 249
 250                 if(system->is_encrypted != NULL && system->is_encrypted(mimeinfo))
 251                         return decrypt(mimeinfo, system);
 252         }
 253
 254         return -1;
 255 }
 256
 257 GSList *privacy_get_system_ids()
 258 {
 259         GSList *cur;
 260         GSList *ret = NULL;
 261
 262         for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
 263                 PrivacySystem *system = (PrivacySystem *) cur->data;
 264
 265                 ret = g_slist_append(ret, g_strdup(system->id));
 266         }
 267
 268         return ret;
 269 }
 270
 271 static PrivacySystem *privacy_get_system(const gchar *id)
 272 {
 273         GSList *cur;
 274
 275         g_return_val_if_fail(id != NULL, NULL);
 276
 277         for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
 278                 PrivacySystem *system = (PrivacySystem *) cur->data;
 279
 280                 if(strcmp(id, system->id) == 0)
 281                         return system;
 282         }
 283
 284         return NULL;
 285 }
 286
 287 const gchar *privacy_system_get_name(const gchar *id)
 288 {
 289         PrivacySystem *system;
 290
 291         g_return_val_if_fail(id != NULL, NULL);
 292
 293         system = privacy_get_system(id);
 294         if (system == NULL)
 295                 return NULL;
 296
 297         return system->name;
 298 }
 299
 300 gboolean privacy_system_can_sign(const gchar *id)
 301 {
 302         PrivacySystem *system;
 303
 304         g_return_val_if_fail(id != NULL, FALSE);
 305
 306         system = privacy_get_system(id);
 307         if (system == NULL)
 308                 return FALSE;
 309
 310         return system->can_sign;
 311 }
 312
 313 gboolean privacy_system_can_encrypt(const gchar *id)
 314 {
 315         PrivacySystem *system;
 316
 317         g_return_val_if_fail(id != NULL, FALSE);
 318
 319         system = privacy_get_system(id);
 320         if (system == NULL)
 321                 return FALSE;
 322
 323         return system->can_encrypt;
 324 }
 325
 326 gboolean privacy_sign(const gchar *id, MimeInfo *target, PrefsAccount *account)
 327 {
 328         PrivacySystem *system;
 329
 330         g_return_val_if_fail(id != NULL, FALSE);
 331         g_return_val_if_fail(target != NULL, FALSE);
 332
 333         system = privacy_get_system(id);
 334         if (system == NULL)
 335                 return FALSE;
 336         if (!system->can_sign)
 337                 return FALSE;
 338         if (system->sign == NULL)
 339                 return FALSE;
 340
 341         return system->sign(target, account);
 342 }
 343
 344 gchar *privacy_get_encrypt_data(const gchar *id, GSList *recp_names)
 345 {
 346         PrivacySystem *system;
 347
 348         g_return_val_if_fail(id != NULL, NULL);
 349         g_return_val_if_fail(recp_names != NULL, NULL);
 350
 351         system = privacy_get_system(id);
 352         if (system == NULL)
 353                 return NULL;
 354         if (!system->can_encrypt)
 355                 return NULL;
 356         if (system->get_encrypt_data == NULL)
 357                 return NULL;
 358
 359         return system->get_encrypt_data(recp_names);
 360 }
 361
 362 gboolean privacy_encrypt(const gchar *id, MimeInfo *mimeinfo, const gchar *encdata)
 363 {
 364         PrivacySystem *system;
 365
 366         g_return_val_if_fail(id != NULL, FALSE);
 367         g_return_val_if_fail(mimeinfo != NULL, FALSE);
 368         g_return_val_if_fail(encdata != NULL, FALSE);
 369
 370         system = privacy_get_system(id);
 371         if (system == NULL)
 372                 return FALSE;
 373         if (!system->can_encrypt)
 374                 return FALSE;
 375         if (system->encrypt == NULL)
 376                 return FALSE;
 377
 378         return system->encrypt(mimeinfo, encdata);
 379 }