AddressKeeper: fix copyright and g_warning strings
[claws.git] / src / plugins / address_keeper / address_keeper.c
1 /*
2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2009-2015 Ricardo Mones and the Claws Mail 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 3 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, see <http://www.gnu.org/licenses/>. 
17  */
18
19 #ifdef HAVE_CONFIG_H
20 #  include "config.h"
21 #include "claws-features.h"
22 #endif
23
24 #include <glib.h>
25 #include <glib/gi18n.h>
26
27 #include "version.h"
28 #include "address_keeper.h"
29 #include "address_keeper_prefs.h"
30 #include "addr_compl.h"
31 #include "addrbook.h"
32 #include "codeconv.h"
33 #include "prefs_common.h"
34
35 /** Identifier for the hook. */
36 static guint hook_id;
37
38 /**
39  * Extracts name from an address.
40  *
41  * @param addr The full address.
42  * @return The name found in the address as a newly allocated string, or NULL if
43  * not found.
44  */
45 gchar *get_name_from_addr(const gchar *addr)
46 {
47         gchar *name = NULL;
48
49         if (addr == NULL || *addr == '\0')
50                 return NULL;
51         name = strchr(addr, '@');
52         if (name == NULL)
53                 return NULL;
54         --name;
55         while (name >= addr && !g_ascii_isspace(*name)) --name;
56         while (name >= addr && g_ascii_isspace(*name)) --name;
57         if (name > addr) {
58                 ++name; /* recover non-space char */
59                 return g_strndup(addr, name - addr);
60         }
61         return NULL;
62 }
63
64 /**
65  * Extracts comment from an address.
66  *
67  * @param addr The full address.
68  * @return The comment found in the address as a newly allocated string, or NULL if
69  * not found.
70  */
71 gchar *get_comment_from_addr(const gchar *addr)
72 {
73         gchar *comm = NULL;
74
75         if (addr == NULL || *addr == '\0')
76                 return NULL;
77         comm = strchr(addr, '@');
78         if (comm == NULL)
79                 return NULL;
80         ++comm;
81         while (*comm && !g_ascii_isspace(*comm)) ++comm;
82         while (*comm && g_ascii_isspace(*comm)) ++comm;
83         if (*comm)
84                 return g_strdup(comm);
85         return NULL;
86 }
87
88 /**
89  * Checks an address for matching a blocked address pattern.
90  *
91  * @param addr The full address.
92  * @param blocked The regexp matching blocked addresses.
93  *
94  * @return TRUE if given address matches any of the patterns, FALSE otherwise.
95  */
96 gboolean matches_blocked_address(gchar *addr, MatcherList *blocked)
97 {
98         if (blocked != NULL) {
99                 MsgInfo info;
100
101                 info.subject = addr;
102                 return matcherlist_match(blocked, &info);
103         }
104         return FALSE;
105 }
106
107 /**
108  * Saves an address to the configured addressbook folder if not known.
109  *
110  * @param abf The address book file containing target folder.
111  * @param folder The address book folder where addresses are added.
112  * @param addr The address to be added.
113  * @param blocked The regexp matching blocked addresses.
114  */
115 void keep_if_unknown(AddressBookFile * abf, ItemFolder * folder, gchar *addr, MatcherList *blocked)
116 {
117         gchar *clean_addr = NULL;
118         gchar *keepto = addkeeperprefs.addressbook_folder;
119
120         debug_print("checking addr '%s'\n", addr);
121         if (matches_blocked_address(addr, blocked)) {
122                 debug_print("addr '%s' is blocked by regexp\n", addr);
123                 return;
124         }
125         clean_addr = g_strdup(addr);
126         extract_address(clean_addr);
127         start_address_completion(NULL);
128         if (complete_matches_found(clean_addr) == 0) {
129                 gchar *a_name;
130                 gchar *a_comment;
131                 debug_print("adding addr '%s' to addressbook '%s'\n",
132                             clean_addr, keepto);
133                 a_name = get_name_from_addr(addr);
134                 a_comment = get_comment_from_addr(addr);
135                 if (!addrbook_add_contact(abf, folder, a_name, clean_addr, a_comment)) {
136                         g_warning("contact could not be added");
137                 } else {
138                         addressbook_refresh();
139                 }
140                 if (a_name != NULL)
141                         g_free(a_name);
142                 if (a_comment != NULL)
143                         g_free(a_comment);
144         } else {
145                 debug_print("found addr '%s' in addressbook '%s', skipping\n",
146                             clean_addr, keepto);
147         }
148         end_address_completion();
149         g_free(clean_addr);
150 }
151
152 /**
153  * Callback function to be called before sending the mail.
154  * 
155  * @param source The composer to be checked.
156  * @param data Additional data.
157  *
158  * @return FALSE always: we're only annotating addresses.
159  */
160 static gboolean addrk_before_send_hook(gpointer source, gpointer data)
161 {
162         Compose *compose = (Compose *)source;
163         AddressDataSource *book = NULL;
164         AddressBookFile *abf = NULL;
165         ItemFolder *folder = NULL;
166         gchar *keepto = addkeeperprefs.addressbook_folder;
167         GSList *cur;
168         const gchar *to_hdr;
169         const gchar *cc_hdr;
170         const gchar *bcc_hdr;
171         MatcherList *blocked = NULL;
172
173         debug_print("address_keeper invoked!\n");
174         if (compose->batch)
175                 return FALSE;   /* do not check while queuing */
176
177         if (keepto == NULL || *keepto == '\0') {
178                 g_warning("addressbook folder not configured");
179                 return FALSE;
180         }
181
182         if (!addressbook_peek_folder_exists(keepto, &book, &folder)) {
183                 g_warning("addressbook folder not found '%s'", keepto);
184                 return FALSE;
185         }
186         if (!book) {
187                 g_warning("addressbook_peek_folder_exists: NULL book");
188                 return FALSE;
189         }
190         abf = book->rawDataSource;
191
192         to_hdr = prefs_common_translated_header_name("To:");
193         cc_hdr = prefs_common_translated_header_name("Cc:");
194         bcc_hdr = prefs_common_translated_header_name("Bcc:");
195
196         if (addkeeperprefs.block_matching_addrs != NULL
197                         && addkeeperprefs.block_matching_addrs[0] != '\0') {
198                 blocked = matcherlist_new_from_lines(addkeeperprefs.block_matching_addrs, FALSE, FALSE);
199                 if (blocked == NULL)
200                         g_warning("couldn't allocate matcher");
201         }
202         for (cur = compose->header_list; cur != NULL; cur = cur->next) {
203                 gchar *header;
204                 gchar *entry;
205                 header = gtk_editable_get_chars(GTK_EDITABLE(
206                                 gtk_bin_get_child(GTK_BIN(
207                                         (((ComposeHeaderEntry *)cur->data)->combo)))), 0, -1);
208                 entry = gtk_editable_get_chars(GTK_EDITABLE(
209                                 ((ComposeHeaderEntry *)cur->data)->entry), 0, -1);
210                 g_strstrip(entry);
211                 g_strstrip(header);
212                 if (*entry != '\0') {
213                         if (!g_ascii_strcasecmp(header, to_hdr)
214                                 && addkeeperprefs.keep_to_addrs == TRUE) {
215                                 keep_if_unknown(abf, folder, entry, blocked);
216                         }
217                         if (!g_ascii_strcasecmp(header, cc_hdr)
218                                 && addkeeperprefs.keep_cc_addrs == TRUE) {
219                                 keep_if_unknown(abf, folder, entry, blocked);
220                         }
221                         if (!g_ascii_strcasecmp(header, bcc_hdr)
222                                 && addkeeperprefs.keep_bcc_addrs == TRUE) {
223                                 keep_if_unknown(abf, folder, entry, blocked);
224                         }
225                 }
226                 g_free(header);
227                 g_free(entry);
228         }
229         if (blocked != NULL)    
230                 matcherlist_free(blocked);
231
232         return FALSE;   /* continue sending */
233 }
234
235 /**
236  * Initialize plugin.
237  *
238  * @param error  For storing the returned error message.
239  *
240  * @return 0 if initialization succeeds, -1 on failure.
241  */
242 gint plugin_init(gchar **error)
243 {
244         if (!check_plugin_version(MAKE_NUMERIC_VERSION(2,9,2,72),
245                                   VERSION_NUMERIC, PLUGIN_NAME, error))
246                 return -1;
247
248         hook_id = hooks_register_hook(COMPOSE_CHECK_BEFORE_SEND_HOOKLIST, 
249                                       addrk_before_send_hook, NULL);
250         
251         if (hook_id == -1) {
252                 *error = g_strdup(_("Failed to register check before send hook"));
253                 return -1;
254         }
255
256         address_keeper_prefs_init();
257
258         debug_print("Address Keeper plugin loaded\n");
259
260         return 0;
261 }
262
263 /**
264  * Destructor for the plugin.
265  * Unregister the callback function and frees matcher.
266  */
267 gboolean plugin_done(void)
268 {       
269         hooks_unregister_hook(COMPOSE_CHECK_BEFORE_SEND_HOOKLIST, hook_id);
270         address_keeper_prefs_done();
271         debug_print("Address Keeper plugin unloaded\n");
272         return TRUE;
273 }
274
275 /**
276  * Get the name of the plugin.
277  *
278  * @return The plugin name (maybe translated).
279  */
280 const gchar *plugin_name(void)
281 {
282         return PLUGIN_NAME;
283 }
284
285 /**
286  * Get the description of the plugin.
287  *
288  * @return The plugin description (maybe translated).
289  */
290 const gchar *plugin_desc(void)
291 {
292         return _("Keeps all recipient addresses in an addressbook folder.");
293 }
294
295 /**
296  * Get the kind of plugin.
297  *
298  * @return The "GTK2" constant.
299  */
300 const gchar *plugin_type(void)
301 {
302         return "GTK2";
303 }
304
305 /**
306  * Get the license acronym the plugin is released under.
307  *
308  * @return The "GPL3+" constant.
309  */
310 const gchar *plugin_licence(void)
311 {
312         return "GPL3+";
313 }
314
315 /**
316  * Get the version of the plugin.
317  *
318  * @return The current version string.
319  */
320 const gchar *plugin_version(void)
321 {
322         return VERSION;
323 }
324
325 /**
326  * Get the features implemented by the plugin.
327  *
328  * @return A constant PluginFeature structure with the features.
329  */
330 struct PluginFeature *plugin_provides(void)
331 {
332         static struct PluginFeature features[] = 
333                 { {PLUGIN_OTHER, N_("Address Keeper")},
334                   {PLUGIN_NOTHING, NULL}};
335
336         return features;
337 }
338