2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2009 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))
155 static void msginfo_set_signed_flag(GNode *node, gpointer data)
157 struct SignedState *sstate = (struct SignedState *)data;
158 MsgInfo *msginfo = sstate->msginfo;
159 MimeInfo *mimeinfo = node->data;
161 if (privacy_mimeinfo_is_signed(mimeinfo)) {
162 procmsg_msginfo_set_flags(msginfo, 0, MSG_SIGNED);
163 if (sstate->system && !*(sstate->system) && mimeinfo->privacy)
164 *(sstate->system) = g_strdup(mimeinfo->privacy->system->id);
166 if (privacy_mimeinfo_is_encrypted(mimeinfo)) {
167 procmsg_msginfo_set_flags(msginfo, 0, MSG_ENCRYPTED);
168 if (sstate->system && !*(sstate->system) && mimeinfo->privacy)
169 *(sstate->system) = g_strdup(mimeinfo->privacy->system->id);
171 /* searching inside encrypted parts doesn't really make sense */
172 g_node_children_foreach(mimeinfo->node, G_TRAVERSE_ALL, msginfo_set_signed_flag, sstate);
176 void privacy_msginfo_get_signed_state(MsgInfo *msginfo, gchar **system)
178 struct SignedState sstate;
179 MimeInfo *mimeinfo = procmime_scan_message(msginfo);
181 sstate.msginfo = msginfo;
182 sstate.system = system;
183 g_node_children_foreach(mimeinfo->node, G_TRAVERSE_ALL, msginfo_set_signed_flag, &sstate);
187 * Check the signature of a MimeInfo. privacy_mimeinfo_is_signed
188 * should be called before otherwise it is done by this function.
189 * If the MimeInfo is not signed an error code will be returned.
191 * \return Error code indicating the result of the check,
192 * < 0 if an error occured
194 gint privacy_mimeinfo_check_signature(MimeInfo *mimeinfo)
196 PrivacySystem *system;
198 g_return_val_if_fail(mimeinfo != NULL, -1);
200 if (mimeinfo->privacy == NULL)
201 privacy_mimeinfo_is_signed(mimeinfo);
203 if (mimeinfo->privacy == NULL)
206 system = privacy_data_get_system(mimeinfo->privacy);
210 if (system->check_signature == NULL)
213 return system->check_signature(mimeinfo);
216 SignatureStatus privacy_mimeinfo_get_sig_status(MimeInfo *mimeinfo)
218 PrivacySystem *system;
220 g_return_val_if_fail(mimeinfo != NULL, -1);
222 if (mimeinfo->privacy == NULL)
223 privacy_mimeinfo_is_signed(mimeinfo);
225 if (mimeinfo->privacy == NULL)
226 return SIGNATURE_UNCHECKED;
228 system = privacy_data_get_system(mimeinfo->privacy);
230 return SIGNATURE_UNCHECKED;
231 if (system->get_sig_status == NULL)
232 return SIGNATURE_UNCHECKED;
234 return system->get_sig_status(mimeinfo);
237 gchar *privacy_mimeinfo_sig_info_short(MimeInfo *mimeinfo)
239 PrivacySystem *system;
241 g_return_val_if_fail(mimeinfo != NULL, NULL);
243 if (mimeinfo->privacy == NULL)
244 privacy_mimeinfo_is_signed(mimeinfo);
246 if (mimeinfo->privacy == NULL)
247 return g_strdup(_("No signature found"));
249 system = privacy_data_get_system(mimeinfo->privacy);
251 return g_strdup(_("No signature found"));
252 if (system->get_sig_info_short == NULL)
253 return g_strdup(_("No information available"));
255 return system->get_sig_info_short(mimeinfo);
258 gchar *privacy_mimeinfo_sig_info_full(MimeInfo *mimeinfo)
260 PrivacySystem *system;
262 g_return_val_if_fail(mimeinfo != NULL, NULL);
264 if (mimeinfo->privacy == NULL)
265 privacy_mimeinfo_is_signed(mimeinfo);
267 if (mimeinfo->privacy == NULL)
268 return g_strdup(_("No signature found"));
270 system = privacy_data_get_system(mimeinfo->privacy);
272 return g_strdup(_("No signature found"));
273 if (system->get_sig_info_full == NULL)
274 return g_strdup(_("No information available"));
276 return system->get_sig_info_full(mimeinfo);
279 gboolean privacy_mimeinfo_is_encrypted(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))
294 static gint decrypt(MimeInfo *mimeinfo, PrivacySystem *system)
296 MimeInfo *decryptedinfo, *parentinfo;
299 g_return_val_if_fail(system->decrypt != NULL, -1);
301 decryptedinfo = system->decrypt(mimeinfo);
302 if (decryptedinfo == NULL)
305 parentinfo = procmime_mimeinfo_parent(mimeinfo);
306 childnumber = g_node_child_index(parentinfo->node, mimeinfo);
308 procmime_mimeinfo_free_all(mimeinfo);
310 g_node_insert(parentinfo->node, childnumber, decryptedinfo->node);
315 gint privacy_mimeinfo_decrypt(MimeInfo *mimeinfo)
318 g_return_val_if_fail(mimeinfo != NULL, FALSE);
320 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
321 PrivacySystem *system = (PrivacySystem *) cur->data;
323 if(system->is_encrypted != NULL && system->is_encrypted(mimeinfo))
324 return decrypt(mimeinfo, system);
330 GSList *privacy_get_system_ids()
335 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
336 PrivacySystem *system = (PrivacySystem *) cur->data;
338 ret = g_slist_append(ret, g_strdup(system->id));
344 static PrivacySystem *privacy_get_system(const gchar *id)
348 g_return_val_if_fail(id != NULL, NULL);
350 for(cur = systems; cur != NULL; cur = g_slist_next(cur)) {
351 PrivacySystem *system = (PrivacySystem *) cur->data;
353 if(strcmp(id, system->id) == 0)
360 const gchar *privacy_system_get_name(const gchar *id)
362 PrivacySystem *system;
364 g_return_val_if_fail(id != NULL, NULL);
366 system = privacy_get_system(id);
373 gboolean privacy_system_can_sign(const gchar *id)
375 PrivacySystem *system;
377 g_return_val_if_fail(id != NULL, FALSE);
379 system = privacy_get_system(id);
383 return system->can_sign;
386 gboolean privacy_system_can_encrypt(const gchar *id)
388 PrivacySystem *system;
390 g_return_val_if_fail(id != NULL, FALSE);
392 system = privacy_get_system(id);
396 return system->can_encrypt;
399 gboolean privacy_sign(const gchar *id, MimeInfo *target, PrefsAccount *account, const gchar *from_addr)
401 PrivacySystem *system;
403 g_return_val_if_fail(id != NULL, FALSE);
404 g_return_val_if_fail(target != NULL, FALSE);
406 system = privacy_get_system(id);
409 if (!system->can_sign)
411 if (system->sign == NULL)
414 return system->sign(target, account, from_addr);
417 gchar *privacy_get_encrypt_data(const gchar *id, GSList *recp_names)
419 PrivacySystem *system;
421 g_return_val_if_fail(id != NULL, NULL);
422 g_return_val_if_fail(recp_names != NULL, NULL);
424 system = privacy_get_system(id);
427 if (!system->can_encrypt)
429 if (system->get_encrypt_data == NULL)
432 return system->get_encrypt_data(recp_names);
435 const gchar *privacy_get_encrypt_warning(const gchar *id)
437 PrivacySystem *system;
439 g_return_val_if_fail(id != NULL, NULL);
441 system = privacy_get_system(id);
444 if (!system->can_encrypt)
446 if (system->get_encrypt_warning == NULL)
449 return system->get_encrypt_warning();
452 void privacy_inhibit_encrypt_warning(const gchar *id, gboolean inhibit)
454 PrivacySystem *system;
456 g_return_if_fail(id != NULL);
458 system = privacy_get_system(id);
461 if (!system->can_encrypt)
463 if (system->inhibit_encrypt_warning == NULL)
466 system->inhibit_encrypt_warning(inhibit);
469 gboolean privacy_encrypt(const gchar *id, MimeInfo *mimeinfo, const gchar *encdata)
471 PrivacySystem *system;
473 g_return_val_if_fail(id != NULL, FALSE);
474 g_return_val_if_fail(mimeinfo != NULL, FALSE);
475 if (encdata == NULL) {
476 privacy_set_error(_("No recipient keys defined."));
480 system = privacy_get_system(id);
483 if (!system->can_encrypt)
485 if (system->encrypt == NULL)
488 return system->encrypt(mimeinfo, encdata);