2005-07-17 [colin] 1.9.12cvs75
[claws.git] / 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 }