evolution/exchangeitstorage.cc

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * Authors : Patrick Patterson <ppatters@nit.ca>
   4  *           Peter Colijn <pcolijn@nit.ca>
   5  *           Scott MacLean <scott@nit.ca>
   6  *           William Lachance <wlach@nit.ca>
   7  *
   8  * Copyright 2003-2004, Net Integration Technologies, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of version 2 of the GNU General Public
  12  * License as published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22  * USA
  23  */
  24
  25 extern "C" {
  26 #define delete _delete
  27 #include <ebook/e-book.h>
  28 #undef delete
  29 }
  30
  31 #include "exchangeitstorage.h"
  32 #include "localstorage.h"
  33 #include "calendaradaptor.h"
  34 #include "contactsadaptor.h"
  35 #include "tasksadaptor.h"
  36 #include "evoutils.h"
  37 #include "eituniconfkeys.h"
  38
  39 #include "wvfile.h"
  40
  41 #include <glib.h>
  42 #include <sys/stat.h>
  43 #include <sys/types.h>
  44
  45 WvString get_folder_owner(WvStringParm folder_name)
  46 {
  47     WvStringList keysplit;
  48
  49     keysplit.split(folder_name, ".");
  50
  51     if (keysplit.count() >= 1)
  52         return *(keysplit.first());
  53
  54     return WvString::null;
  55 }
  56
  57 WvString reparent_folder_name(WvStringParm folder_name, WvStringParm new_owner)
  58 {
  59     WvString new_folder_name = new_owner;
  60     WvStringList keysplit;
  61
  62     keysplit.split(folder_name, ".");
  63     if (keysplit.count() < 1)
  64         return WvString::null;
  65
  66     WvStringList::Iter i(keysplit);
  67     i.rewind(); i.next(); // skip the old folder owner
  68     while (i.next())
  69     {
  70         new_folder_name.append(".%s", i());
  71     }
  72
  73     return new_folder_name;
  74 }
  75
  76 bool is_folder_local(WvStringParm folder_name, WvStringParm storage_owner)
  77 {
  78     WvStringList keysplit;
  79
  80     keysplit.split(folder_name, ".");
  81
  82     if (keysplit.count() >= 1 && *(keysplit.first()) == storage_owner)
  83         return true;
  84
  85     return false;
  86 }
  87
  88 bool is_folder_valid(WvStringParm folder_name)
  89 {
  90     WvStringList keysplit;
  91
  92     keysplit.split(folder_name, ".");
  93     if (keysplit.count() > 1)
  94         return true;
  95
  96     return false;
  97 }
  98
  99 ExchangeItStorage::ExchangeItStorage(EvolutionStorage *evo_stor,
 100                                      WvStringParm _base_path,
 101                                      WvStringParm _owner,
 102                                      UniConf root) :
 103     evo_storage(evo_stor),
 104     base_path(_base_path),
 105     log("ExchangeItStorage", WvLog::Debug1),
 106     dict(100),
 107     owner(_owner),
 108     state(root)
 109 {
 110 }
 111
 112 ExchangeItStorage::~ExchangeItStorage()
 113 {
 114     state.commit();
 115 }
 116
 117 bool ExchangeItStorage::is_ready() const
 118 {
 119     ExchangeItAdaptorDict::Iter i(dict);
 120     for (i.rewind(); i.next(); )
 121     {
 122         if (!i->is_ready())
 123             return false;
 124     }
 125
 126     return true;
 127 }
 128
 129 bool ExchangeItStorage::migrate_account(WvStringParm new_owner)
 130 {
 131     WvStringList folders_to_be_migrated;
 132     WvStringList folders_to_be_removed;
 133
 134     log("Migrating account\n");
 135     if (!is_ready())
 136     {
 137         log("Not ready to migrate account; not all adaptors are ready!\n");
 138         return false;
 139     }
 140
 141     UniConf::Iter i(state[FOLDERS_KEY]);
 142     for (i.rewind(); i.next(); )
 143     {
 144         WvString folder = i().key().printable();
 145
 146         if((strncmp(owner, folder, owner.len()) == 0) &&
 147            (folder.len() > owner.len()) &&
 148            (folder[owner.len()] == '.'))
 149         {
 150             log("Folder %s belonged to user %s (the old user). "
 151                 "Keeping it as part of acct migration\n",
 152                 folder, owner);
 153             folders_to_be_migrated.append(folder);
 154         }
 155         else if (((strncmp(owner, folder, owner.len()) == 0) &&
 156                   (folder.len() == owner.len())))
 157         {
 158             log("Folder %s is the root folder of user %s (the old user). "
 159                 "It will be destroyed automatically.\n",
 160                 folder, owner);
 161         }
 162         else
 163         {
 164             log("Folder %s didn't belong to user %s (%s %s %s). "
 165                 "Deleting it as part of acct migration.\n",
 166                 folder, owner,
 167                 (strncmp(owner, folder, owner.len()) == 0),
 168                 (folder.len() > owner.len()),
 169                 (folder[owner.len()] == '.'));
 170
 171             folders_to_be_removed.append(folder);
 172
 173         }
 174     }
 175
 176     // all the folders which belonged to the old owner should
 177     // be renamed and reallocated to the new owner
 178     WvStringList::Iter j(folders_to_be_migrated);
 179     for (j.rewind(); j.next();)
 180     {
 181         WvStringParm old_owner = get_folder_owner(j());
 182         WvString new_folder_name = j();
 183         if (old_owner != new_owner)
 184         {
 185             log("Folder %s belonged to user %s (the old user). "
 186                 "Renaming it to belong to the new owner.\n",
 187                 j(), owner);
 188             new_folder_name = reparent_folder_name(j(), new_owner);
 189             log("rename_local_folder(%s, %s) (new owner: %s)\n",
 190                 j(), new_folder_name,
 191                 new_owner);
 192             if (!!new_folder_name)
 193                 rename_local_folder(j(), new_folder_name); // should never fail
 194             else
 195                 log("Not renaming folder (%s): it has no name!\n",
 196                     j(), WvLog::Warning);
 197         }
 198     }
 199
 200     // Remove public folders that belong to the "old"
 201     // so we won't have any weird "public" folders laying about
 202     log("Purging any public folders belonging to the old user\n");
 203     WvStringList::Iter k(folders_to_be_removed);
 204     for (k.rewind(); k.next();)
 205     {
 206         if (!remove_folder(k()))
 207             log("Couldn't remove folder?\n");
 208     }
 209
 210     ExchangeItAdaptorDict::Iter l(dict);
 211     for (l.rewind(); l.next();)
 212     {
 213         WvStringList *uids = l->get_item_uids("all");
 214         WvStringList::Iter m(*uids);
 215         for (m.rewind(); m.next();)
 216         {
 217             log("Queing item %s in folder %s to be resent to the server\n",
 218                 m(), l->get_key());
 219             state[l->get_key()][TOSEND_KEY][m()].setmeint(1);
 220         }
 221         delete uids;
 222     }
 223
 224     owner = new_owner;
 225     return true;
 226 }
 227
 228 bool ExchangeItStorage::rename_local_folder(WvStringParm old_key,
 229                                             WvStringParm new_key)
 230 {
 231     ExchangeItAdaptor *adaptor = dict[old_key];
 232     if (!adaptor)
 233         return false;
 234
 235     dict.set_autofree(adaptor, false);
 236     dict.remove(adaptor);
 237     adaptor->set_key(new_key);
 238     dict.add(adaptor, true);
 239
 240     WvStringParm type = state[FOLDERS_KEY][old_key].getme();
 241     state[FOLDERS_KEY][old_key].remove();
 242     state[FOLDERS_KEY][new_key].setme(type);
 243
 244     state[new_key][VERSION_KEY].setmeint(0);
 245     UniConf::Iter j(state[old_key][CL2SRV_KEY]);
 246     for (j.rewind(); j.next(); )
 247     {
 248         state[new_key][CL2SRV_KEY][j().key()].setme(j().getme());
 249     }
 250
 251     log("rename_local_folder: version of old key is now: %s\n",
 252         state[old_key][VERSION_KEY].getme());
 253     state[old_key][VERSION_KEY].remove();
 254     state[old_key].remove();
 255     log("rename_local_folder: version of old key is now: %s\n",
 256         state[old_key][VERSION_KEY].getme());
 257
 258     state[FOLDERS_KEY][TOADD_KEY][new_key].setme(dict[new_key]->get_type());
 259
 260     return true;
 261 }
 262
 263 void ExchangeItStorage::clean_folder_hierarchy_upwards(WvStringParm path)
 264 {
 265     UniConf folder_info = state[EVO_FOLDERS_KEY][path];
 266
 267     unsigned int num_keys = 0;
 268     UniConf::Iter c(folder_info);
 269     for (c.rewind(); c.next(); )
 270         ++num_keys;
 271
 272     WvString type = folder_info[TYPE_KEY].getme();
 273
 274     if ((type == WvString::null && num_keys == 0)
 275      || (type == "folder" && num_keys <= 3))
 276     {
 277         evolution_storage_removed_folder(evo_storage, path);
 278         folder_info.setme(WvString::null);
 279
 280         WvString parent;
 281         WvStringList folders;
 282         folders.split(path, "/");
 283         folders.popstr(); // stupid leading blank (from the leading slash)
 284         while (folders.count() > 1)
 285             parent.append("/%s", folders.popstr());
 286
 287         if (!!parent)
 288             clean_folder_hierarchy_upwards(parent);
 289     }
 290 }
 291
 292 void ExchangeItStorage::sync_folder_hierarchy(WvStringParm path)
 293 {
 294     if (evolution_storage_folder_exists(evo_storage, path))
 295         evolution_storage_removed_folder(evo_storage, path);
 296
 297     UniConf folder_info = state[EVO_FOLDERS_KEY][path];
 298
 299     WvString type = folder_info[TYPE_KEY].getme();
 300     WvString desc = folder_info[DESC_KEY].getme();
 301     WvString icon = folder_info[ICON_KEY].getme();
 302
 303     if (type == WvString::null)
 304     {
 305         if (path == "/Public Folders")
 306         {
 307             type = "public-folder";
 308             desc = "public-folder";
 309             icon = "public-folder";
 310         }
 311         else
 312         {
 313             type = "folder";
 314             desc = "folder";
 315             icon = "folder";
 316         }
 317     }
 318
 319     WvString phys_uri("file://%s%s", base_path, path);
 320     mkdir(phys_uri.cstr() + 7, 0770);
 321
 322     if (type == "mail")
 323     {
 324         WvString mbox("%s/mbox", phys_uri.cstr() + 7);
 325         FILE *fp = fopen(mbox.cstr(), "at");
 326         if (!fp)
 327             log("Cannot create dummy mailbox (uri: %s)\n", mbox, WvLog::Error);
 328         else
 329             fclose(fp);
 330     }
 331
 332     const char *path_top = strrchr(path, '/');
 333     assert(path_top && *(path_top + 1));
 334     evolution_storage_new_folder(evo_storage, path, path_top + 1,
 335                                  type, phys_uri, desc, icon, 0, FALSE, 0);
 336
 337     UniConf::Iter i(folder_info);
 338     for (i.rewind(); i.next(); )
 339     {
 340         WvString key = i().key().printable();
 341
 342         if (key == "desc" || key == "type" || key == "icon")
 343             continue;
 344
 345         WvString build_path("%s/%s", path, key);
 346         sync_folder_hierarchy(build_path);
 347     }
 348 }
 349
 350 bool ExchangeItStorage::load_folders()
 351 {
 352     UniConf::Iter i(state[FOLDERS_KEY]);
 353     for (i.rewind(); i.next(); )
 354     {
 355         log("load_local_folders(): adding folder %s (type: %s)\n",
 356             i().key().printable(), i().getme());
 357
 358         //if (is_folder_local(i().key().printable(), owner))
 359         add_folder(i().key().printable(), i().getme());
 360     }
 361
 362     return true;
 363 }
 364
 365 bool ExchangeItStorage::add_folder(WvStringParm key, WvStringParm type,
 366                                    const bool by_client_request)
 367 {
 368     if (!is_folder_valid(key))
 369         return false;
 370
 371     if (dict[key]) // already loaded, do nothing
 372         return true;
 373
 374     WvString path = convert_eitpath_to_evopath(key, owner);
 375     WvString rebuild_path = path;
 376     const bool local = is_folder_local(key, owner);
 377
 378     if (!local)
 379     {
 380         WvStringList folders;
 381         folders.split(path, "/");
 382         WvStringList::Iter i(folders);
 383         rebuild_path = "";
 384         for (i.rewind(); i.next(); )
 385         {
 386             if (i() != "")
 387             {
 388                 rebuild_path.append("/%s", i());
 389                 if (!state[EVO_FOLDERS_KEY][rebuild_path].exists())
 390                     break;
 391             }
 392         }
 393     }
 394
 395     WvString evo_type;
 396     WvString desc;
 397     if (type == CALENDAR_TYPE)
 398     {
 399         evo_type = "calendar";
 400         desc = "Calendar Items";
 401     }
 402     else if (type == CONTACTS_TYPE)
 403     {
 404         evo_type = "contacts";
 405         desc = "Contacts";
 406     }
 407     else if (type == TASKS_TYPE)
 408     {
 409         evo_type = "tasks";
 410         desc = "Tasks";
 411     }
 412     else
 413     {
 414         evo_type = "mail";
 415         desc = "Mail";
 416     }
 417
 418     state[FOLDERS_KEY][key].setme(type);
 419     if (by_client_request)
 420         state[FOLDERS_KEY][TOADD_KEY][key].setme(type);
 421
 422     state[EVO_FOLDERS_KEY][path][TYPE_KEY].setme(evo_type);
 423     state[EVO_FOLDERS_KEY][path][DESC_KEY].setme(desc);
 424     state[EVO_FOLDERS_KEY][path][ICON_KEY].setme("");
 425
 426     sync_folder_hierarchy(rebuild_path);
 427
 428     WvString phys_path("%s%s", base_path, path);
 429
 430     ExchangeItAdaptor *adaptor = NULL;
 431     if (type == CALENDAR_TYPE)
 432     {
 433         adaptor = new CalendarAdaptor(key, phys_path, state);
 434         if (key == WvString("%s.Calendar", owner))
 435         {
 436             if(!state[CALENDAR_LOCAL_IMPORTED_KEY].getmeint())
 437             {
 438                 log("migrating calendars !!\n");
 439                 import_local_calendar(static_cast<CalendarAdaptor *>(adaptor),
 440                                          WvString("file://%s/evolution/local/Calendar/calendar.ics",
 441                                                   WvString(g_get_home_dir())));
 442
 443             }
 444         }
 445     }
 446     else if (type == CONTACTS_TYPE)
 447     {
 448         adaptor = new ContactsAdaptor(key, phys_path, state);
 449         if (key == WvString("%s.Contacts", owner))
 450         {
 451             if(!state[CONTACTS_LOCAL_IMPORTED_KEY].getmeint())
 452             {
 453                 log("migrating contacts !!\n");
 454                 /*
 455                   Here, we hardcode the local contact DB path name
 456                   Don't worry, this is how it is done in
 457                       evolution/addressbook/backend/ebook/load-gnomecard-addressbook.c
 458                   -- hub
 459                  */
 460                 import_local_contacts(static_cast<ContactsAdaptor *>(adaptor),
 461                                       WvString("file://%s/evolution/local/Contacts/addressbook.db",
 462                                                WvString(g_get_home_dir())));
 463             }
 464         }
 465     }
 466     else if (type == TASKS_TYPE)
 467     {
 468         adaptor = new TasksAdaptor(key, phys_path, state);
 469         if (key == WvString("%s.Tasks", owner))
 470         {
 471             if(!state[TASKS_LOCAL_IMPORTED_KEY].getmeint())
 472             {
 473                 log("migrating tasks !!\n");
 474                 import_local_calendar(static_cast<CalendarAdaptor *>(adaptor),
 475                                       WvString("file://%s/evolution/local/Tasks/tasks.ics",
 476                                                WvString(g_get_home_dir())));
 477
 478             }
 479         }
 480     }
 481     else
 482         adaptor = new NullAdaptor(key, phys_path, state);
 483
 484     if (adaptor)
 485         dict.add(adaptor, true);
 486
 487     return true;
 488 }
 489
 490 bool ExchangeItStorage::remove_folder(WvStringParm key,
 491                                       const bool by_client_request)
 492 {
 493     log("removing folder %s (by client request: %s)\n",
 494         key, by_client_request);
 495     bool retval = true;
 496
 497     ExchangeItAdaptor *adaptor = dict[key];
 498     if (adaptor)
 499         dict.remove(adaptor);
 500
 501     WvString path;
 502     WvString phys_path;
 503     path = convert_eitpath_to_evopath(key, owner);
 504     if (!path)
 505     {
 506         // a path with a single token: exchangeit will send us these
 507         // suckers, but we shouldn't actually be doing anything with
 508         // them. its existence is a non-critical error
 509         log("Tried to remove a folder with one (or less) token. "
 510             "Shouldn't happen. eitpath: %s owner: %s\n",
 511             key, owner, WvLog::Warning);
 512         return false;
 513     }
 514     state[FOLDERS_KEY][key].setme(WvString::null);
 515     state[key].setme(WvString::null);
 516
 517     phys_path = WvString("%s%s", base_path, path);
 518
 519     // if this was done by client request (we assume that any other client
 520     // was sane enough to do this itself) purge any folders which lie below
 521     // this one in the hierarchy (if it turns out we do not have sufficient
 522     // permission to do so, we can always recreate them later)
 523     if (by_client_request)
 524     {
 525         UniConf::Iter i(state[FOLDERS_KEY]);
 526         for (i.rewind(); i.next(); )
 527         {
 528             WvStringParm key2 = i().key().printable();
 529
 530             // WLACH: this should be safe
 531             if (key2.len() > key.len() &&
 532                 !strncmp(key.cstr(), key2.cstr(), key.len()),
 533                 key2.cstr()[key.len()] == '.')
 534             {
 535                 if (!remove_folder(key2, false))
 536                     retval = false;
 537
 538                 state[FOLDERS_KEY][TODELETE_KEY][key2].setmeint(1);
 539             }
 540         }
 541     }
 542
 543     state[EVO_FOLDERS_KEY][path].setme(WvString::null);
 544     if (by_client_request)
 545         state[FOLDERS_KEY][TODELETE_KEY][key].setmeint(1);
 546     log("remove_folder: removing storage folder: %s\n", path);
 547     evolution_storage_removed_folder(evo_storage, path);
 548     log("remove_folder: removing phys path: %s\n", phys_path);
 549     destroy_dir(phys_path);
 550
 551     clean_folder_hierarchy_upwards(path);
 552
 553     return retval;
 554 }
 555
 556 bool ExchangeItStorage::folder_exists(WvStringParm key)
 557 {
 558     ExchangeItAdaptor *adaptor = dict[key];
 559     if (adaptor)
 560         return true;
 561
 562     return false;
 563 }
 564
 565
 566 /** open callback for the CalClient to migrate data from
 567  */
 568 static void import_opened_cb (CalClient *local_client, CalClientOpenStatus status, gpointer data)
 569 {
 570     CalendarAdaptor *adaptor = static_cast<CalendarAdaptor *>(data);
 571     if (status != CAL_CLIENT_OPEN_SUCCESS)
 572     {
 573         g_object_unref(local_client);
 574         return;
 575     }
 576     adaptor->merge_into_calendar(local_client);
 577 }
 578
 579
 580
 581 /** Copy over local calendar data to ExchangeIt.
 582  * @param local_cal the uri of the .ics file to be merged
 583  * with ExchangeIt data.
 584  */
 585 void ExchangeItStorage::import_local_calendar(CalendarAdaptor *adaptor,
 586                                               WvStringParm local_cal)
 587 {
 588     CalClient *local_client = cal_client_new();
 589
 590     g_signal_connect (local_client, "cal_opened",
 591                       G_CALLBACK(import_opened_cb),
 592                       static_cast<void*>(adaptor));
 593
 594     if (!cal_client_open_calendar(local_client, local_cal, true))
 595     {
 596         log("%s do not exist. No migration needed.\n");
 597     }
 598 }
 599
 600
 601 static void import_ebook_opened_cb(EBook *book, EBookStatus status,
 602                                    gpointer data)
 603 {
 604     ContactsAdaptor *adaptor = static_cast<ContactsAdaptor *>(data);
 605     if (status != E_BOOK_STATUS_SUCCESS)
 606     {
 607         g_object_unref(book);
 608         return;
 609     }
 610     adaptor->merge_into_contacts(book);
 611 }
 612
 613 void ExchangeItStorage::import_local_contacts(ContactsAdaptor *adaptor,
 614                                               WvStringParm local_ebook)
 615 {
 616     EBook *book = e_book_new();
 617
 618     e_book_load_uri(book, local_ebook, import_ebook_opened_cb, adaptor);
 619 }