2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2006 Hiroyuki Yamamoto & the Sylpheed-Claws 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 2 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, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
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 const gchar *privacy_get_error (void)
45 if (privacy_last_error) {
46 strncpy2(tmp_privacy_error, privacy_last_error, BUFSIZ-1);
47 g_free(privacy_last_error);
48 privacy_last_error = NULL;
49 return tmp_privacy_error;
51 return _("Unknown error");
55 PrivacySystem *privacy_data_get_system(PrivacyData *data)
57 /* Make sure the cached system is still registered */
58 if (data->system && g_slist_find(systems, data->system))
64 * Register a new Privacy System
66 * \param system The Privacy System that should be registered
68 void privacy_register_system(PrivacySystem *system)
70 systems = g_slist_append(systems, system);
74 * Unregister a new Privacy System. The system must not be in
75 * use anymore when it is unregistered.
77 * \param system The Privacy System that should be unregistered
79 void privacy_unregister_system(PrivacySystem *system)
81 systems = g_slist_remove(systems, system);
85 * Free a PrivacyData of a PrivacySystem
87 * \param privacydata The data to free
89 void privacy_free_privacydata(PrivacyData *privacydata)
91 PrivacySystem *system = NULL;
93 g_return_if_fail(privacydata != NULL);
95 system = privacy_data_get_system(privacydata);
98 system->free_privacydata(privacydata);
102 * Check if a MimeInfo is signed with one of the available
103 * privacy system. If a privacydata is set in the MimeInfo
104 * it will directory return the return value by the system
105 * set in the privacy data or check all available privacy
108 * \return True if the MimeInfo has a signature
110 gboolean privacy_mimeinfo_is_signed(MimeInfo *mimeinfo)
113 g_return_val_if_fail(mimeinfo != NULL, FALSE);
115 if (mimeinfo->privacy != NULL) {
116 PrivacySystem *system =
117 privacy_data_get_system(mimeinfo->privacy);
119 if (system == NULL) {
120 mimeinfo->privacy = NULL;
124 if (system->is_signed != NULL)
125 return system->is_signed(mimeinfo);
130 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
131 PrivacySystem *system = (PrivacySystem *) cur->data;
133 if(system->is_signed != NULL && system->is_signed(mimeinfo))
141 * Check the signature of a MimeInfo. privacy_mimeinfo_is_signed
142 * should be called before otherwise it is done by this function.
143 * If the MimeInfo is not signed an error code will be returned.
145 * \return Error code indicating the result of the check,
146 * < 0 if an error occured
148 gint privacy_mimeinfo_check_signature(MimeInfo *mimeinfo)
150 PrivacySystem *system;
152 g_return_val_if_fail(mimeinfo != NULL, -1);
154 if (mimeinfo->privacy == NULL)
155 privacy_mimeinfo_is_signed(mimeinfo);
157 if (mimeinfo->privacy == NULL)
160 system = privacy_data_get_system(mimeinfo->privacy);
164 if (system->check_signature == NULL)
167 return system->check_signature(mimeinfo);
170 SignatureStatus privacy_mimeinfo_get_sig_status(MimeInfo *mimeinfo)
172 PrivacySystem *system;
174 g_return_val_if_fail(mimeinfo != NULL, -1);
176 if (mimeinfo->privacy == NULL)
177 privacy_mimeinfo_is_signed(mimeinfo);
179 if (mimeinfo->privacy == NULL)
180 return SIGNATURE_UNCHECKED;
182 system = privacy_data_get_system(mimeinfo->privacy);
184 return SIGNATURE_UNCHECKED;
185 if (system->get_sig_status == NULL)
186 return SIGNATURE_UNCHECKED;
188 return system->get_sig_status(mimeinfo);
191 gchar *privacy_mimeinfo_sig_info_short(MimeInfo *mimeinfo)
193 PrivacySystem *system;
195 g_return_val_if_fail(mimeinfo != NULL, NULL);
197 if (mimeinfo->privacy == NULL)
198 privacy_mimeinfo_is_signed(mimeinfo);
200 if (mimeinfo->privacy == NULL)
201 return g_strdup(_("No signature found"));
203 system = privacy_data_get_system(mimeinfo->privacy);
205 return g_strdup(_("No signature found"));
206 if (system->get_sig_info_short == NULL)
207 return g_strdup(_("No information available"));
209 return system->get_sig_info_short(mimeinfo);
212 gchar *privacy_mimeinfo_sig_info_full(MimeInfo *mimeinfo)
214 PrivacySystem *system;
216 g_return_val_if_fail(mimeinfo != NULL, NULL);
218 if (mimeinfo->privacy == NULL)
219 privacy_mimeinfo_is_signed(mimeinfo);
221 if (mimeinfo->privacy == NULL)
222 return g_strdup(_("No signature found"));
224 system = privacy_data_get_system(mimeinfo->privacy);
226 return g_strdup(_("No signature found"));
227 if (system->get_sig_info_full == NULL)
228 return g_strdup(_("No information available"));
230 return system->get_sig_info_full(mimeinfo);
233 gboolean privacy_mimeinfo_is_encrypted(MimeInfo *mimeinfo)
236 g_return_val_if_fail(mimeinfo != NULL, FALSE);
238 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
239 PrivacySystem *system = (PrivacySystem *) cur->data;
241 if(system->is_encrypted != NULL && system->is_encrypted(mimeinfo))
248 static gint decrypt(MimeInfo *mimeinfo, PrivacySystem *system)
250 MimeInfo *decryptedinfo, *parentinfo;
253 g_return_val_if_fail(system->decrypt != NULL, -1);
255 decryptedinfo = system->decrypt(mimeinfo);
256 if (decryptedinfo == NULL)
259 parentinfo = procmime_mimeinfo_parent(mimeinfo);
260 childnumber = g_node_child_index(parentinfo->node, mimeinfo);
262 procmime_mimeinfo_free_all(mimeinfo);
264 g_node_insert(parentinfo->node, childnumber, decryptedinfo->node);
269 gint privacy_mimeinfo_decrypt(MimeInfo *mimeinfo)
272 g_return_val_if_fail(mimeinfo != NULL, FALSE);
274 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
275 PrivacySystem *system = (PrivacySystem *) cur->data;
277 if(system->is_encrypted != NULL && system->is_encrypted(mimeinfo))
278 return decrypt(mimeinfo, system);
284 GSList *privacy_get_system_ids()
289 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
290 PrivacySystem *system = (PrivacySystem *) cur->data;
292 ret = g_slist_append(ret, g_strdup(system->id));
298 static PrivacySystem *privacy_get_system(const gchar *id)
302 g_return_val_if_fail(id != NULL, NULL);
304 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
305 PrivacySystem *system = (PrivacySystem *) cur->data;
307 if(strcmp(id, system->id) == 0)
314 const gchar *privacy_system_get_name(const gchar *id)
316 PrivacySystem *system;
318 g_return_val_if_fail(id != NULL, NULL);
320 system = privacy_get_system(id);
327 gboolean privacy_system_can_sign(const gchar *id)
329 PrivacySystem *system;
331 g_return_val_if_fail(id != NULL, FALSE);
333 system = privacy_get_system(id);
337 return system->can_sign;
340 gboolean privacy_system_can_encrypt(const gchar *id)
342 PrivacySystem *system;
344 g_return_val_if_fail(id != NULL, FALSE);
346 system = privacy_get_system(id);
350 return system->can_encrypt;
353 gboolean privacy_sign(const gchar *id, MimeInfo *target, PrefsAccount *account)
355 PrivacySystem *system;
357 g_return_val_if_fail(id != NULL, FALSE);
358 g_return_val_if_fail(target != NULL, FALSE);
360 system = privacy_get_system(id);
363 if (!system->can_sign)
365 if (system->sign == NULL)
368 return system->sign(target, account);
371 gchar *privacy_get_encrypt_data(const gchar *id, GSList *recp_names)
373 PrivacySystem *system;
375 g_return_val_if_fail(id != NULL, NULL);
376 g_return_val_if_fail(recp_names != NULL, NULL);
378 system = privacy_get_system(id);
381 if (!system->can_encrypt)
383 if (system->get_encrypt_data == NULL)
386 return system->get_encrypt_data(recp_names);
389 gboolean privacy_encrypt(const gchar *id, MimeInfo *mimeinfo, const gchar *encdata)
391 PrivacySystem *system;
393 g_return_val_if_fail(id != NULL, FALSE);
394 g_return_val_if_fail(mimeinfo != NULL, FALSE);
395 if (encdata == NULL) {
396 privacy_set_error(_("No recipient keys defined."));
400 system = privacy_get_system(id);
403 if (!system->can_encrypt)
405 if (system->encrypt == NULL)
408 return system->encrypt(mimeinfo, encdata);