src/plugins/gdata/cm_gdata_contacts.c

   1 /* GData plugin for Claws-Mail
   2  * Copyright (C) 2011 Holger Berndt
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 #  include "config.h"
  20 #  include "claws-features.h"
  21 #endif
  22
  23 #include <glib.h>
  24 #include <glib/gi18n.h>
  25
  26 #include <gtk/gtk.h>
  27
  28 #include "cm_gdata_contacts.h"
  29 #include "cm_gdata_prefs.h"
  30
  31 #include "addr_compl.h"
  32 #include "main.h"
  33 #include "prefs_common.h"
  34 #include "mainwindow.h"
  35 #include "common/log.h"
  36 #include "common/xml.h"
  37 #include "common/utils.h"
  38 #include "common/passcrypt.h"
  39 #include "gtk/gtkutils.h"
  40
  41 #include <gdata/gdata.h>
  42
  43 #define GDATA_CONTACTS_FILENAME "gdata_cache.xml"
  44
  45 #define GDATA_C1 "EOnuQt4fxED3WrO//iub3KLQMScIxXiT0VBD8RZUeKjkcm1zEBVMboeWDLYyqjJKZaL4oaZ24umWygbj19T2oJR6ZpjbCw=="
  46 #define GDATA_C2 "QYjIgZblg/4RMCnEqNQypcHZba9ePqAN"
  47 #define GDATA_C3 "XHEZEgO06YbWfQWOyYhE/ny5Q10aNOZlkQ=="
  48
  49
  50 typedef struct
  51 {
  52   const gchar *family_name;
  53   const gchar *given_name;
  54   const gchar *full_name;
  55   const gchar *address;
  56 } Contact;
  57
  58 typedef struct
  59 {
  60   GSList *contacts;
  61 } CmGDataContactsCache;
  62
  63
  64 CmGDataContactsCache contacts_cache;
  65 gboolean cm_gdata_contacts_query_running = FALSE;
  66 gchar *contacts_group_id = NULL;
  67 GDataOAuth2Authorizer *authorizer = NULL;
  68 GDataContactsService *service = NULL;
  69
  70
  71 static void protect_fields_against_NULL(Contact *contact)
  72 {
  73   g_return_if_fail(contact != NULL);
  74
  75   /* protect fields against being NULL */
  76   if(contact->full_name == NULL)
  77     contact->full_name = g_strdup("");
  78   if(contact->given_name == NULL)
  79     contact->given_name = g_strdup("");
  80   if(contact->family_name == NULL)
  81     contact->family_name = g_strdup("");
  82 }
  83
  84 typedef struct
  85 {
  86   const gchar *auth_uri;
  87   GtkWidget *entry;
  88 } AuthCodeQueryButtonData;
  89
  90
  91 static void auth_uri_link_button_clicked_cb(GtkButton *button, gpointer data)
  92 {
  93   AuthCodeQueryButtonData *auth_code_query_data = data;
  94   open_uri(auth_code_query_data->auth_uri, prefs_common_get_uri_cmd());
  95   gtk_widget_grab_focus(auth_code_query_data->entry);
  96 }
  97
  98 static void auth_code_entry_changed_cb(GtkEditable *entry, gpointer data)
  99 {
 100   gtk_widget_set_sensitive(GTK_WIDGET(data), gtk_entry_get_text_length(GTK_ENTRY(entry)) > 0);
 101 }
 102
 103
 104 /* Returns the authorization code as newly allocated string, or NULL */
 105 gchar* ask_user_for_auth_code(const gchar *auth_uri)
 106 {
 107   GtkWidget *dialog;
 108   GtkWidget *vbox;
 109   GtkWidget *table;
 110   GtkWidget *link_button;
 111   GtkWidget *label;
 112   GtkWidget *entry;
 113   gchar *str;
 114   gchar *retval = NULL;
 115   MainWindow *mainwin;
 116   gint dlg_res;
 117   GtkWidget *btn_ok;
 118   AuthCodeQueryButtonData *auth_code_query_data;
 119
 120   mainwin = mainwindow_get_mainwindow();
 121   dialog = gtk_message_dialog_new_with_markup(mainwin ? GTK_WINDOW(mainwin->window) : NULL,
 122       GTK_DIALOG_DESTROY_WITH_PARENT,
 123       GTK_MESSAGE_INFO,
 124       GTK_BUTTONS_NONE,
 125       "<span weight=\"bold\" size=\"larger\">%s</span>", _("GData plugin: Authorization required"));
 126   gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
 127       _("You need to authorize Claws Mail to access your Google contact list to use the GData plugin."
 128       "\n\nVisit Google's authorization page by pressing the button below. After you "
 129       "confirmed the authorization, you will get an authorization code. Enter that code "
 130       "in the field below to grant Claws Mail access to your Google contact list."));
 131   gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
 132   btn_ok = gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK);
 133   gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE);
 134   gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
 135
 136   gtk_widget_set_sensitive(btn_ok, FALSE);
 137
 138   table = gtk_table_new(2, 3, FALSE);
 139   gtk_table_set_row_spacings(GTK_TABLE(table), 8);
 140   gtk_table_set_col_spacings(GTK_TABLE(table), 8);
 141
 142   str = g_strconcat("<b>", _("Step 1:"), "</b>", NULL);
 143   label = gtk_label_new(str);
 144   g_free(str);
 145   gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
 146   gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, 0, 0, 0, 0);
 147
 148   link_button = gtk_button_new_with_label(_("Click here to open the Google authorization page in a browser"));
 149   auth_code_query_data = g_new0(AuthCodeQueryButtonData,1);
 150   gtk_table_attach(GTK_TABLE(table), link_button, 1, 3, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 151
 152   str = g_strconcat("<b>", _("Step 2:"), "</b>", NULL);
 153   label = gtk_label_new(str);
 154   g_free(str);
 155   gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
 156   gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, 0, 0, 0, 0);
 157
 158   gtk_table_attach(GTK_TABLE(table), gtk_label_new(_("Enter code:")), 1, 2, 1, 2, 0, 0, 0, 0);
 159
 160   entry = gtk_entry_new();
 161   g_signal_connect(G_OBJECT(entry), "changed", (GCallback)auth_code_entry_changed_cb, (gpointer)btn_ok);
 162   gtk_table_attach(GTK_TABLE(table), entry, 2, 3, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 163
 164   auth_code_query_data->auth_uri = auth_uri;
 165   auth_code_query_data->entry = entry;
 166   g_signal_connect(G_OBJECT(link_button), "clicked", (GCallback)auth_uri_link_button_clicked_cb, (gpointer)auth_code_query_data);
 167
 168   vbox = gtk_vbox_new(FALSE, 4);
 169   gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 170
 171   gtk_box_pack_start(GTK_BOX(gtk_message_dialog_get_message_area(GTK_MESSAGE_DIALOG(dialog))), vbox, FALSE, FALSE, 0);
 172
 173   gtk_widget_show_all(dialog);
 174
 175   dlg_res = gtk_dialog_run(GTK_DIALOG(dialog));
 176   switch(dlg_res)
 177   {
 178   case GTK_RESPONSE_DELETE_EVENT:
 179   case GTK_RESPONSE_CANCEL:
 180     break;
 181   case GTK_RESPONSE_OK:
 182     retval = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
 183     break;
 184   }
 185
 186   g_free(auth_code_query_data);
 187   gtk_widget_destroy(dialog);
 188
 189   return retval;
 190 }
 191
 192
 193 static void write_cache_to_file(void)
 194 {
 195   gchar *path;
 196   PrefFile *pfile;
 197   XMLTag *tag;
 198   XMLNode *xmlnode;
 199   GNode *rootnode;
 200   GNode *contactsnode;
 201   GSList *walk;
 202
 203   path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, GDATA_CONTACTS_FILENAME, NULL);
 204   pfile = prefs_write_open(path);
 205   g_free(path);
 206   if(pfile == NULL) {
 207     debug_print("GData plugin error: Cannot open file " GDATA_CONTACTS_FILENAME " for writing\n");
 208     return;
 209   }
 210
 211   /* XML declarations */
 212   xml_file_put_xml_decl(pfile->fp);
 213
 214   /* Build up XML tree */
 215
 216   /* root node */
 217   tag = xml_tag_new("gdata");
 218   xmlnode = xml_node_new(tag, NULL);
 219   rootnode = g_node_new(xmlnode);
 220
 221   /* contacts node */
 222   tag = xml_tag_new("contacts");
 223   xmlnode = xml_node_new(tag, NULL);
 224   contactsnode = g_node_new(xmlnode);
 225   g_node_append(rootnode, contactsnode);
 226
 227   /* walk contacts cache */
 228   for(walk = contacts_cache.contacts; walk; walk = walk->next)
 229   {
 230     GNode *contactnode;
 231     Contact *contact = walk->data;
 232     tag = xml_tag_new("contact");
 233     xml_tag_add_attr(tag, xml_attr_new("family_name",contact->family_name));
 234     xml_tag_add_attr(tag, xml_attr_new("given_name",contact->given_name));
 235     xml_tag_add_attr(tag, xml_attr_new("full_name",contact->full_name));
 236     xml_tag_add_attr(tag, xml_attr_new("address",contact->address));
 237     xmlnode = xml_node_new(tag, NULL);
 238     contactnode = g_node_new(xmlnode);
 239     g_node_append(contactsnode, contactnode);
 240   }
 241
 242   /* Actual writing and cleanup */
 243   xml_write_tree(rootnode, pfile->fp);
 244   if(prefs_file_close(pfile) < 0)
 245     debug_print("GData plugin error: Failed to write file " GDATA_CONTACTS_FILENAME "\n");
 246
 247   debug_print("GData plugin error: Wrote cache to file " GDATA_CONTACTS_FILENAME "\n");
 248
 249   /* Free XML tree */
 250   xml_free_tree(rootnode);
 251 }
 252
 253 static int add_gdata_contact_to_cache(GDataContactsContact *contact)
 254 {
 255   GList *walk;
 256   int retval;
 257
 258   retval = 0;
 259   for(walk = gdata_contacts_contact_get_email_addresses(contact); walk; walk = walk->next) {
 260     const gchar *email_address;
 261     GDataGDEmailAddress *address = GDATA_GD_EMAIL_ADDRESS(walk->data);
 262
 263     email_address = gdata_gd_email_address_get_address(address);
 264     if(email_address && (*email_address != '\0')) {
 265       GDataGDName *name;
 266       Contact *cached_contact;
 267
 268       name = gdata_contacts_contact_get_name(contact);
 269
 270       cached_contact = g_new0(Contact, 1);
 271       cached_contact->full_name = g_strdup(gdata_gd_name_get_full_name(name));
 272       cached_contact->given_name = g_strdup(gdata_gd_name_get_given_name(name));
 273       cached_contact->family_name = g_strdup(gdata_gd_name_get_family_name(name));
 274       cached_contact->address = g_strdup(email_address);
 275
 276       protect_fields_against_NULL(cached_contact);
 277
 278       contacts_cache.contacts = g_slist_prepend(contacts_cache.contacts, cached_contact);
 279
 280       debug_print("GData plugin: Added %s <%s>\n", cached_contact->full_name, cached_contact->address);
 281       retval = 1;
 282     }
 283   }
 284   if(retval == 0)
 285   {
 286     debug_print("GData plugin: Skipped received contact \"%s\" because it doesn't have an email address\n",
 287         gdata_gd_name_get_full_name(gdata_contacts_contact_get_name(contact)));
 288   }
 289   return retval;
 290 }
 291
 292 static void free_contact(Contact *contact)
 293 {
 294   g_free((gpointer)contact->full_name);
 295   g_free((gpointer)contact->family_name);
 296   g_free((gpointer)contact->given_name);
 297   g_free((gpointer)contact->address);
 298   g_free(contact);
 299 }
 300
 301 static void clear_contacts_cache(void)
 302 {
 303   GSList *walk;
 304   for(walk = contacts_cache.contacts; walk; walk = walk->next)
 305     free_contact(walk->data);
 306   g_slist_free(contacts_cache.contacts);
 307   contacts_cache.contacts = NULL;
 308 }
 309
 310 static void cm_gdata_query_contacts_ready(GDataContactsService *service, GAsyncResult *res, gpointer data)
 311 {
 312   GDataFeed *feed;
 313   GList *walk;
 314   GError *error = NULL;
 315   guint num_contacts = 0;
 316   guint num_contacts_added = 0;
 317         gchar *tmpstr1, *tmpstr2;
 318
 319   feed = gdata_service_query_finish(GDATA_SERVICE(service), res, &error);
 320   cm_gdata_contacts_query_running = FALSE;
 321   if(error)
 322   {
 323     g_object_unref(feed);
 324     log_error(LOG_PROTOCOL, _("GData plugin: Error querying for contacts: %s\n"), error->message);
 325     g_error_free(error);
 326     return;
 327   }
 328
 329   /* clear cache */
 330   clear_contacts_cache();
 331
 332   /* Iterate through the returned contacts and fill the cache */
 333   for(walk = gdata_feed_get_entries(feed); walk; walk = walk->next) {
 334     num_contacts_added += add_gdata_contact_to_cache(GDATA_CONTACTS_CONTACT(walk->data));
 335     num_contacts++;
 336   }
 337   g_object_unref(feed);
 338   contacts_cache.contacts = g_slist_reverse(contacts_cache.contacts);
 339         /* i18n: First part of "Added X of Y contacts to cache" */
 340   tmpstr1 = g_strdup_printf(ngettext("Added %d of", "Added %d of", num_contacts_added), num_contacts_added);
 341         /* i18n: Second part of "Added X of Y contacts to cache" */
 342   tmpstr2 = g_strdup_printf(ngettext("1 contact to the cache", "%d contacts to the cache", num_contacts), num_contacts);
 343   log_message(LOG_PROTOCOL, "%s %s\n", tmpstr1, tmpstr2);
 344         g_free(tmpstr1);
 345         g_free(tmpstr2);
 346 }
 347
 348 static void query_contacts(GDataContactsService *service)
 349 {
 350   GDataContactsQuery *query;
 351
 352   log_message(LOG_PROTOCOL, _("GData plugin: Starting async contacts query\n"));
 353
 354   query = gdata_contacts_query_new(NULL);
 355   gdata_contacts_query_set_group(query, contacts_group_id);
 356   gdata_query_set_max_results(GDATA_QUERY(query), cm_gdata_config.max_num_results);
 357   gdata_contacts_service_query_contacts_async(service, GDATA_QUERY(query), NULL, NULL, NULL,
 358   NULL, (GAsyncReadyCallback)cm_gdata_query_contacts_ready, NULL);
 359
 360   g_object_unref(query);
 361 }
 362
 363 static void cm_gdata_query_groups_ready(GDataContactsService *service, GAsyncResult *res, gpointer data)
 364 {
 365   GDataFeed *feed;
 366   GList *walk;
 367   GError *error = NULL;
 368
 369   feed = gdata_service_query_finish(GDATA_SERVICE(service), res, &error);
 370   if(error)
 371   {
 372     g_object_unref(feed);
 373     log_error(LOG_PROTOCOL, _("GData plugin: Error querying for groups: %s\n"), error->message);
 374     g_error_free(error);
 375     return;
 376   }
 377
 378   /* Iterate through the returned groups and search for Contacts group id */
 379   for(walk = gdata_feed_get_entries(feed); walk; walk = walk->next) {
 380     const gchar *system_group_id;
 381     GDataContactsGroup *group = GDATA_CONTACTS_GROUP(walk->data);
 382
 383     system_group_id = gdata_contacts_group_get_system_group_id(group);
 384     if(system_group_id && !strcmp(system_group_id, GDATA_CONTACTS_GROUP_CONTACTS)) {
 385       gchar *pos;
 386       const gchar *id;
 387
 388       id = gdata_entry_get_id(GDATA_ENTRY(group));
 389
 390       /* possibly replace projection "full" by "base" */
 391       pos = g_strrstr(id, "/full/");
 392       if(pos) {
 393         GString *str = g_string_new("\0");
 394         int off = pos-id;
 395
 396         g_string_append_len(str, id, off);
 397         g_string_append(str, "/base/");
 398         g_string_append(str, id+off+strlen("/full/"));
 399         g_string_append_c(str, '\0');
 400         contacts_group_id = str->str;
 401         g_string_free(str, FALSE);
 402       }
 403       else
 404         contacts_group_id = g_strdup(id);
 405       break;
 406     }
 407   }
 408   g_object_unref(feed);
 409
 410   log_message(LOG_PROTOCOL, _("GData plugin: Groups received\n"));
 411
 412   query_contacts(service);
 413 }
 414
 415 static void query_for_contacts_group_id(GDataAuthorizer *authorizer)
 416 {
 417   log_message(LOG_PROTOCOL, _("GData plugin: Starting async groups query\n"));
 418
 419   gdata_contacts_service_query_groups_async(service, NULL, NULL, NULL, NULL, NULL,
 420       (GAsyncReadyCallback)cm_gdata_query_groups_ready, NULL);
 421 }
 422
 423
 424 static void query_after_auth()
 425 {
 426   if(!contacts_group_id)
 427     query_for_contacts_group_id(GDATA_AUTHORIZER(authorizer));
 428   else
 429     query_contacts(service);
 430 }
 431
 432
 433 static void cm_gdata_auth_ready(GDataOAuth2Authorizer *auth, GAsyncResult *res, gpointer data)
 434 {
 435   GError *error = NULL;
 436
 437   if(gdata_oauth2_authorizer_request_authorization_finish(auth, res, &error) == FALSE)
 438   {
 439     /* Notify the user of all errors except cancellation errors */
 440     if(!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
 441     {
 442       log_error(LOG_PROTOCOL, _("GData plugin: Authorization error: %s\n"), error->message);
 443     }
 444     g_error_free(error);
 445     cm_gdata_contacts_query_running = FALSE;
 446     return;
 447   }
 448
 449   log_message(LOG_PROTOCOL, _("GData plugin: Authorization successful\n"));
 450
 451   query_after_auth();
 452 }
 453
 454 static void cm_gdata_interactive_auth()
 455 {
 456   gchar *auth_uri;
 457   gchar *auth_code;
 458
 459   log_message(LOG_PROTOCOL, _("GData plugin: Starting interactive authorization\n"));
 460
 461   auth_uri = gdata_oauth2_authorizer_build_authentication_uri(authorizer, cm_gdata_config.username, FALSE);
 462   g_return_if_fail(auth_uri);
 463
 464   auth_code = ask_user_for_auth_code(auth_uri);
 465
 466   if(auth_code)
 467   {
 468     cm_gdata_contacts_query_running = TRUE;
 469     log_message(LOG_PROTOCOL, _("GData plugin: Got authorization code, requesting authorization\n"));
 470     gdata_oauth2_authorizer_request_authorization_async(authorizer, auth_code, NULL, (GAsyncReadyCallback)cm_gdata_auth_ready, NULL);
 471     memset(auth_code, 0, strlen(auth_code));
 472     g_free(auth_code);
 473   }
 474   else
 475   {
 476     log_warning(LOG_PROTOCOL, _("GData plugin: No authorization code received, authorization request cancelled\n"));
 477   }
 478
 479   g_free(auth_uri);
 480 }
 481
 482
 483 #if GDATA_CHECK_VERSION(0,17,2)
 484 static void cm_gdata_refresh_ready(GDataOAuth2Authorizer *auth, GAsyncResult *res, gpointer data)
 485 {
 486   GError *error = NULL;
 487
 488   if(gdata_authorizer_refresh_authorization_finish(GDATA_AUTHORIZER(auth), res, &error) == FALSE)
 489   {
 490     /* Notify the user of all errors except cancellation errors */
 491     if(!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
 492     {
 493       log_error(LOG_PROTOCOL, _("GData plugin: Authorization refresh error: %s\n"), error->message);
 494     }
 495     g_error_free(error);
 496
 497     cm_gdata_interactive_auth();
 498
 499     return;
 500   }
 501
 502   log_message(LOG_PROTOCOL, _("GData plugin: Authorization refresh successful\n"));
 503
 504   query_after_auth();
 505 }
 506 #endif
 507
 508
 509 /* returns allocated string which must be freed */
 510 static guchar* decode(const gchar *in)
 511 {
 512   guchar *tmp;
 513   gsize len;
 514
 515   tmp = g_base64_decode(in, &len);
 516   passcrypt_decrypt(tmp, len);
 517   return tmp;
 518 }
 519
 520
 521 static void query()
 522 {
 523   if(cm_gdata_contacts_query_running)
 524   {
 525     debug_print("GData plugin: Network query already in progress");
 526     return;
 527   }
 528
 529   if(!authorizer)
 530   {
 531     gchar *c1 = decode(GDATA_C1);
 532     gchar *c2 = decode(GDATA_C2);
 533     gchar *c3 = decode(GDATA_C3);
 534
 535     authorizer = gdata_oauth2_authorizer_new(c1, c2, c3, GDATA_TYPE_CONTACTS_SERVICE);
 536
 537     g_free(c1);
 538     g_free(c2);
 539     g_free(c3);
 540   }
 541   g_return_if_fail(authorizer);
 542
 543   if(!service)
 544   {
 545     service = gdata_contacts_service_new(GDATA_AUTHORIZER(authorizer));
 546   }
 547   g_return_if_fail(service);
 548
 549   if(!gdata_service_is_authorized(GDATA_SERVICE(service)))
 550   {
 551 #if GDATA_CHECK_VERSION(0,17,2)
 552     /* Try to restore from saved refresh token.*/
 553     if(cm_gdata_config.oauth2_refresh_token)
 554     {
 555       log_message(LOG_PROTOCOL, _("GData plugin: Trying to refresh authorization\n"));
 556       gdata_oauth2_authorizer_set_refresh_token(authorizer, cm_gdata_config.oauth2_refresh_token);
 557       gdata_authorizer_refresh_authorization_async(GDATA_AUTHORIZER(authorizer), NULL, (GAsyncReadyCallback)cm_gdata_refresh_ready, NULL);
 558     }
 559     else
 560     {
 561       cm_gdata_interactive_auth();
 562     }
 563 #else
 564     cm_gdata_interactive_auth();
 565 #endif
 566   }
 567   else
 568   {
 569     query_after_auth();
 570   }
 571 }
 572
 573
 574 static void add_contacts_to_list(GList **address_list, GSList *contacts)
 575 {
 576   GSList *walk;
 577
 578   for(walk = contacts; walk; walk = walk->next)
 579   {
 580     address_entry *ae;
 581     Contact *contact = walk->data;
 582
 583     ae = g_new0(address_entry, 1);
 584     ae->name = g_strdup(contact->full_name);
 585     ae->address = g_strdup(contact->address);
 586     ae->grp_emails = NULL;
 587
 588     *address_list = g_list_prepend(*address_list, ae);
 589     addr_compl_add_address1(ae->address, ae);
 590
 591     if(contact->given_name && *(contact->given_name) != '\0')
 592       addr_compl_add_address1(contact->given_name, ae);
 593
 594     if(contact->family_name && *(contact->family_name) != '\0')
 595       addr_compl_add_address1(contact->family_name, ae);
 596   }
 597 }
 598
 599 void cm_gdata_add_contacts(GList **address_list)
 600 {
 601   add_contacts_to_list(address_list, contacts_cache.contacts);
 602 }
 603
 604 gboolean cm_gdata_update_contacts_cache(void)
 605 {
 606   if(prefs_common.work_offline)
 607   {
 608     debug_print("GData plugin: Offline mode\n");
 609   }
 610   else
 611   {
 612     debug_print("GData plugin: Querying contacts\n");
 613     query();
 614   }
 615   return TRUE;
 616 }
 617
 618 void cm_gdata_contacts_done(void)
 619 {
 620   g_free(contacts_group_id);
 621   contacts_group_id = NULL;
 622
 623   write_cache_to_file();
 624   if(contacts_cache.contacts && !claws_is_exiting())
 625     clear_contacts_cache();
 626
 627   if(authorizer)
 628   {
 629 #if GDATA_CHECK_VERSION(0,17,2)
 630     /* store refresh token */
 631     cm_gdata_config.oauth2_refresh_token = gdata_oauth2_authorizer_dup_refresh_token(authorizer);
 632 #endif
 633
 634     g_object_unref(G_OBJECT(authorizer));
 635     authorizer = NULL;
 636   }
 637
 638   if(service)
 639   {
 640     g_object_unref(G_OBJECT(service));
 641     service = NULL;
 642   }
 643 }
 644
 645 void cm_gdata_load_contacts_cache_from_file(void)
 646 {
 647   gchar *path;
 648   GNode *rootnode, *childnode, *contactnode;
 649   XMLNode *xmlnode;
 650
 651   path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, GDATA_CONTACTS_FILENAME, NULL);
 652   if(!is_file_exist(path)) {
 653     g_free(path);
 654     return;
 655   }
 656
 657   /* no merging; make sure the cache is empty (this should be a noop, but just to be safe...) */
 658   clear_contacts_cache();
 659
 660   rootnode = xml_parse_file(path);
 661   g_free(path);
 662   if(!rootnode)
 663     return;
 664   xmlnode = rootnode->data;
 665
 666   /* Check that root entry is "gdata" */
 667   if(strcmp2(xmlnode->tag->tag, "gdata") != 0) {
 668     g_warning("wrong gdata cache file\n");
 669     xml_free_tree(rootnode);
 670     return;
 671   }
 672
 673   for(childnode = rootnode->children; childnode; childnode = childnode->next) {
 674     GList *attributes;
 675     xmlnode = childnode->data;
 676
 677     if(strcmp2(xmlnode->tag->tag, "contacts") != 0)
 678       continue;
 679
 680     for(contactnode = childnode->children; contactnode; contactnode = contactnode->next)
 681     {
 682       Contact *cached_contact;
 683
 684       xmlnode = contactnode->data;
 685
 686       cached_contact = g_new0(Contact, 1);
 687       /* Attributes of the branch nodes */
 688       for(attributes = xmlnode->tag->attr; attributes; attributes = attributes->next) {
 689         XMLAttr *attr = attributes->data;
 690
 691         if(attr && attr->name && attr->value) {
 692           if(!strcmp2(attr->name, "full_name"))
 693             cached_contact->full_name = g_strdup(attr->value);
 694           else if(!strcmp2(attr->name, "given_name"))
 695             cached_contact->given_name = g_strdup(attr->value);
 696           else if(!strcmp2(attr->name, "family_name"))
 697             cached_contact->family_name = g_strdup(attr->value);
 698           else if(!strcmp2(attr->name, "address"))
 699             cached_contact->address = g_strdup(attr->value);
 700         }
 701       }
 702
 703       if(cached_contact->address)
 704       {
 705         protect_fields_against_NULL(cached_contact);
 706
 707         contacts_cache.contacts = g_slist_prepend(contacts_cache.contacts, cached_contact);
 708         debug_print("Read contact from cache: %s\n", cached_contact->full_name);
 709       }
 710       else {
 711         debug_print("Ignored contact without email address: %s\n", cached_contact->full_name ? cached_contact->full_name : "(null)");
 712       }
 713     }
 714   }
 715
 716   /* Free XML tree */
 717   xml_free_tree(rootnode);
 718
 719   contacts_cache.contacts = g_slist_reverse(contacts_cache.contacts);
 720 }