2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2007 Hiroyuki Yamamoto & the Claws Mail team
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 3 of the License, or
8 * (at your option) any later version.
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.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include <glib/gi18n.h>
26 static GSList *systems = NULL;
27 static gchar *privacy_last_error = NULL;
29 void privacy_set_error(const gchar *format, ...)
34 va_start(args, format);
35 g_vsnprintf(buf, BUFSIZ, format, args);
37 g_free(privacy_last_error);
38 privacy_last_error = g_strdup(buf);
41 static gchar tmp_privacy_error[BUFSIZ];
43 void privacy_reset_error(void)
45 g_free(privacy_last_error);
46 privacy_last_error = NULL;
49 gboolean privacy_peek_error(void)
51 return (privacy_last_error != NULL);
54 const gchar *privacy_get_error (void)
56 if (privacy_last_error) {
57 strncpy2(tmp_privacy_error, privacy_last_error, BUFSIZ-1);
58 privacy_reset_error();
59 return tmp_privacy_error;
61 return _("Unknown error");
65 static PrivacySystem *privacy_data_get_system(PrivacyData *data)
67 /* Make sure the cached system is still registered */
68 if (data->system && g_slist_find(systems, data->system))
74 * Register a new Privacy System
76 * \param system The Privacy System that should be registered
78 void privacy_register_system(PrivacySystem *system)
80 systems = g_slist_append(systems, system);
84 * Unregister a new Privacy System. The system must not be in
85 * use anymore when it is unregistered.
87 * \param system The Privacy System that should be unregistered
89 void privacy_unregister_system(PrivacySystem *system)
91 systems = g_slist_remove(systems, system);
95 * Free a PrivacyData of a PrivacySystem
97 * \param privacydata The data to free
99 void privacy_free_privacydata(PrivacyData *privacydata)
101 PrivacySystem *system = NULL;
103 g_return_if_fail(privacydata != NULL);
105 system = privacy_data_get_system(privacydata);
108 system->free_privacydata(privacydata);
112 * Check if a MimeInfo is signed with one of the available
113 * privacy system. If a privacydata is set in the MimeInfo
114 * it will directory return the return value by the system
115 * set in the privacy data or check all available privacy
118 * \return True if the MimeInfo has a signature
120 gboolean privacy_mimeinfo_is_signed(MimeInfo *mimeinfo)
123 g_return_val_if_fail(mimeinfo != NULL, FALSE);
125 if (mimeinfo->privacy != NULL) {
126 PrivacySystem *system =
127 privacy_data_get_system(mimeinfo->privacy);
129 if (system == NULL) {
130 mimeinfo->privacy = NULL;
134 if (system->is_signed != NULL)
135 return system->is_signed(mimeinfo);
140 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
141 PrivacySystem *system = (PrivacySystem *) cur->data;
143 if(system->is_signed != NULL && system->is_signed(mimeinfo))
151 * Check the signature of a MimeInfo. privacy_mimeinfo_is_signed
152 * should be called before otherwise it is done by this function.
153 * If the MimeInfo is not signed an error code will be returned.
155 * \return Error code indicating the result of the check,
156 * < 0 if an error occured
158 gint privacy_mimeinfo_check_signature(MimeInfo *mimeinfo)
160 PrivacySystem *system;
162 g_return_val_if_fail(mimeinfo != NULL, -1);
164 if (mimeinfo->privacy == NULL)
165 privacy_mimeinfo_is_signed(mimeinfo);
167 if (mimeinfo->privacy == NULL)
170 system = privacy_data_get_system(mimeinfo->privacy);
174 if (system->check_signature == NULL)
177 return system->check_signature(mimeinfo);
180 SignatureStatus privacy_mimeinfo_get_sig_status(MimeInfo *mimeinfo)
182 PrivacySystem *system;
184 g_return_val_if_fail(mimeinfo != NULL, -1);
186 if (mimeinfo->privacy == NULL)
187 privacy_mimeinfo_is_signed(mimeinfo);
189 if (mimeinfo->privacy == NULL)
190 return SIGNATURE_UNCHECKED;
192 system = privacy_data_get_system(mimeinfo->privacy);
194 return SIGNATURE_UNCHECKED;
195 if (system->get_sig_status == NULL)
196 return SIGNATURE_UNCHECKED;
198 return system->get_sig_status(mimeinfo);
201 gchar *privacy_mimeinfo_sig_info_short(MimeInfo *mimeinfo)
203 PrivacySystem *system;
205 g_return_val_if_fail(mimeinfo != NULL, NULL);
207 if (mimeinfo->privacy == NULL)
208 privacy_mimeinfo_is_signed(mimeinfo);
210 if (mimeinfo->privacy == NULL)
211 return g_strdup(_("No signature found"));
213 system = privacy_data_get_system(mimeinfo->privacy);
215 return g_strdup(_("No signature found"));
216 if (system->get_sig_info_short == NULL)
217 return g_strdup(_("No information available"));
219 return system->get_sig_info_short(mimeinfo);
222 gchar *privacy_mimeinfo_sig_info_full(MimeInfo *mimeinfo)
224 PrivacySystem *system;
226 g_return_val_if_fail(mimeinfo != NULL, NULL);
228 if (mimeinfo->privacy == NULL)
229 privacy_mimeinfo_is_signed(mimeinfo);
231 if (mimeinfo->privacy == NULL)
232 return g_strdup(_("No signature found"));
234 system = privacy_data_get_system(mimeinfo->privacy);
236 return g_strdup(_("No signature found"));
237 if (system->get_sig_info_full == NULL)
238 return g_strdup(_("No information available"));
240 return system->get_sig_info_full(mimeinfo);
243 gboolean privacy_mimeinfo_is_encrypted(MimeInfo *mimeinfo)
246 g_return_val_if_fail(mimeinfo != NULL, FALSE);
248 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
249 PrivacySystem *system = (PrivacySystem *) cur->data;
251 if(system->is_encrypted != NULL && system->is_encrypted(mimeinfo))
258 static gint decrypt(MimeInfo *mimeinfo, PrivacySystem *system)
260 MimeInfo *decryptedinfo, *parentinfo;
263 g_return_val_if_fail(system->decrypt != NULL, -1);
265 decryptedinfo = system->decrypt(mimeinfo);
266 if (decryptedinfo == NULL)
269 parentinfo = procmime_mimeinfo_parent(mimeinfo);
270 childnumber = g_node_child_index(parentinfo->node, mimeinfo);
272 procmime_mimeinfo_free_all(mimeinfo);
274 g_node_insert(parentinfo->node, childnumber, decryptedinfo->node);
279 gint privacy_mimeinfo_decrypt(MimeInfo *mimeinfo)
282 g_return_val_if_fail(mimeinfo != NULL, FALSE);
284 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
285 PrivacySystem *system = (PrivacySystem *) cur->data;
287 if(system->is_encrypted != NULL && system->is_encrypted(mimeinfo))
288 return decrypt(mimeinfo, system);
294 GSList *privacy_get_system_ids()
299 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
300 PrivacySystem *system = (PrivacySystem *) cur->data;
302 ret = g_slist_append(ret, g_strdup(system->id));
308 static PrivacySystem *privacy_get_system(const gchar *id)
312 g_return_val_if_fail(id != NULL, NULL);
314 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
315 PrivacySystem *system = (PrivacySystem *) cur->data;
317 if(strcmp(id, system->id) == 0)
324 const gchar *privacy_system_get_name(const gchar *id)
326 PrivacySystem *system;
328 g_return_val_if_fail(id != NULL, NULL);
330 system = privacy_get_system(id);
337 gboolean privacy_system_can_sign(const gchar *id)
339 PrivacySystem *system;
341 g_return_val_if_fail(id != NULL, FALSE);
343 system = privacy_get_system(id);
347 return system->can_sign;
350 gboolean privacy_system_can_encrypt(const gchar *id)
352 PrivacySystem *system;
354 g_return_val_if_fail(id != NULL, FALSE);
356 system = privacy_get_system(id);
360 return system->can_encrypt;
363 gboolean privacy_sign(const gchar *id, MimeInfo *target, PrefsAccount *account)
365 PrivacySystem *system;
367 g_return_val_if_fail(id != NULL, FALSE);
368 g_return_val_if_fail(target != NULL, FALSE);
370 system = privacy_get_system(id);
373 if (!system->can_sign)
375 if (system->sign == NULL)
378 return system->sign(target, account);
381 gchar *privacy_get_encrypt_data(const gchar *id, GSList *recp_names)
383 PrivacySystem *system;
385 g_return_val_if_fail(id != NULL, NULL);
386 g_return_val_if_fail(recp_names != NULL, NULL);
388 system = privacy_get_system(id);
391 if (!system->can_encrypt)
393 if (system->get_encrypt_data == NULL)
396 return system->get_encrypt_data(recp_names);
399 const gchar *privacy_get_encrypt_warning(const gchar *id)
401 PrivacySystem *system;
403 g_return_val_if_fail(id != NULL, NULL);
405 system = privacy_get_system(id);
408 if (!system->can_encrypt)
410 if (system->get_encrypt_warning == NULL)
413 return system->get_encrypt_warning();
416 void privacy_inhibit_encrypt_warning(const gchar *id, gboolean inhibit)
418 PrivacySystem *system;
420 g_return_if_fail(id != NULL);
422 system = privacy_get_system(id);
425 if (!system->can_encrypt)
427 if (system->inhibit_encrypt_warning == NULL)
430 system->inhibit_encrypt_warning(inhibit);
433 gboolean privacy_encrypt(const gchar *id, MimeInfo *mimeinfo, const gchar *encdata)
435 PrivacySystem *system;
437 g_return_val_if_fail(id != NULL, FALSE);
438 g_return_val_if_fail(mimeinfo != NULL, FALSE);
439 if (encdata == NULL) {
440 privacy_set_error(_("No recipient keys defined."));
444 system = privacy_get_system(id);
447 if (!system->can_encrypt)
449 if (system->encrypt == NULL)
452 return system->encrypt(mimeinfo, encdata);