evolution/wvexcconn.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  *           Hubert Figuiere <hub@nit.ca>
   8  *
   9  * Copyright 2003-2004, Net Integration Technologies, Inc.
  10  *
  11  * This program is free software; you can redistribute it and/or
  12  * modify it under the terms of version 2 of the GNU General Public
  13  * License as published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  23  * USA
  24  */
  25
  26 #include "wvexcconn.h"
  27 #include "wvunixsocket.h"
  28 #include "wvtimeoutstream.h"
  29 #include "wvexcconnmanager.h"
  30 #include "wvtcp.h"
  31 #include "wvlog.h"
  32 #include "wvbuf.h"
  33 #include "strutils.h"
  34 #include "wvbase64.h"
  35 #include "wvsslstream.h"
  36 #include "wvstringlist.h"
  37 #include "wvencoderstream.h"
  38 #include "wvautorelease.h"
  39 #include "createfolder.h"
  40 #include "deletefolder.h"
  41 #include "listfolders.h"
  42 #include "listusers.h"
  43 #include "update.h"
  44 #include "delete.h"
  45 #include "setacl.h"
  46 #include "getacl.h"
  47 #include "sync.h"
  48 #include "eituniconfkeys.h"
  49
  50
  51 static int wvstrcmp(const WvString *l, const WvString *r)
  52 {
  53     return strcmp(*l, *r);
  54 }
  55
  56 WvExcConn::WvExcConn(WvStream *conn, UniConf _config,
  57                      WvExcConnManager *_conn_manager,
  58                      ExchangeItStorage *_storage,
  59                      const int _protocol_version) :
  60     WvStreamClone(conn),
  61     log(WvString("WvExcConn-%s", (long)this), WvLog::Debug1),
  62     sock(NULL),
  63     cmd_tag(1),
  64     num_retries(0),
  65     transaction_complete(false),
  66     nosend(false),
  67     have_progress_cb(false),
  68     progress(0),
  69     conn_manager(_conn_manager),
  70     storage(_storage),
  71     config(_config),
  72     state(Authenticate),
  73     protocol_version(_protocol_version)
  74 {
  75 #ifndef NOCS
  76     uses_continue_select = true;
  77 #endif
  78     assert(storage);
  79     assert(conn_manager);
  80
  81     setclosecallback(IWvStreamCallback(conn_manager,
  82                                        &WvExcConnManager::conn_closed));
  83     setclone(conn);
  84
  85     log("Connecting using protocol version %s\n",
  86         protocol_version);
  87
  88     alarm(50);
  89     // CB almost immediately to authenticate and do initial folder sync
  90     // FIXME: is this the best way of doing this?
  91 }
  92
  93 WvExcConn::~WvExcConn()
  94 {
  95 #ifndef NOCS
  96     terminate_continue_select();
  97 #endif
  98
  99     if (!isok())
 100     {
 101         log(WvLog::Error, "Aborted. Error was: %s\n", errstr());
 102         if (!transaction_complete && sock)
 103         {
 104             uint32_t failure = 65535;
 105             sock->write(&failure, sizeof(uint32_t));
 106         }
 107     }
 108     else
 109         log(WvLog::Info, "Done.\n");
 110
 111     WVRELEASE(sock);
 112 }
 113
 114 // Notify our camel provider of the progress we're making
 115 void WvExcConn::progress_notify(int percent)
 116 {
 117     if (!have_progress_cb)
 118         return;
 119
 120     if (progress < 0 || progress > 100)
 121         return;
 122
 123     if (percent > 0)
 124         progress = percent;
 125
 126     progress_cb(progress);
 127 }
 128
 129 ErrorType WvExcConn::authenticate()
 130 {
 131     ErrorType result = AuthOK;
 132     log("authenticate()\n");
 133
 134     WvString username = config[USERNAME_KEY].getme();
 135     WvString password = config[PASSWORD_KEY].getme();
 136     WvString serverid = config[SERVERID_KEY].getme();
 137
 138     // we are compatible with both versions 2 (3.76) and
 139     // 3 (3.80) of the exchangeit protocol
 140     WvString auth("%s:%s", username, password);
 141     WvString authenc = WvBase64Encoder().strflushstr(auth, true);
 142
 143     // Prod the server with the Auth Information..
 144     // We pick up the answer the first time into execute()
 145     print("Version: %s\n", protocol_version);
 146     log(">>> (Version: %s)\n", protocol_version);
 147     print("Authenticate: %s\n\n", authenc);
 148     log(">>> (Authenticate: %s)\n", authenc);
 149
 150     if (!isok())
 151     {
 152         if (result == AuthOK)
 153         {
 154             result = ConnError;
 155         }
 156         log("Sorry, cannot even start authentication.\n");
 157         return result;
 158     }
 159
 160     consume_newlines();
 161
 162     // FIXME: Ideally want something more robust than a timeout
 163     WvString line;
 164     while(!!(line = blocking_getline(AUTH_TIMEOUT)))
 165     {
 166         log("<< (%s)\n", line);
 167         if (line.len() >= 11 && !strncmp(line, "* ERROR 401", 11))
 168         {
 169             result = AuthFailed;
 170             seterr("Authentication failed");
 171             break;
 172         }
 173
 174         if (line.len() >= 7 && !strncmp(line, "* ERROR", 7))
 175         {
 176             result = ProtocolError;
 177             seterr("Response bad: %s", line);
 178             break;
 179         }
 180
 181         // actually this is dangerous as I'm not sure if headers are case sensitive
 182         // or not. Probably safer to use strnicmp(). See bug 7277
 183         if (!strncmp(line, "Server-ID:", 10))
 184         {
 185             WvStringList parts;
 186             parts.split(line, " ");
 187
 188             if (parts.count() != 2)
 189             {
 190                 result = ProtocolError;
 191                 log("Wow, that's a messed up Server-Id header:\n%s\n",
 192                     parts.join(" "));
 193                 seterr("Response bad: invalid Server-Id header");
 194                 break;
 195             }
 196
 197             parts.popstr();
 198             WvString newid = parts.popstr();
 199
 200             if (!!serverid && newid != serverid)
 201             {
 202                 log("First time connecting to a new server; migrating.\n");
 203                 config[OLD_SERVERID_KEY].setme(serverid);
 204                 config[SERVERID_KEY].setme(newid);
 205             }
 206         }
 207
 208         consume_newlines();
 209     }
 210
 211     drain();
 212
 213     if (!isok())
 214     {
 215         if (result == AuthOK)
 216         {
 217             result = ConnError;
 218         }
 219         log("Sorry, cannot continue after authentication.\n");
 220         close();
 221         return result;
 222     }
 223
 224     conn_manager->save_protocol_version(protocol_version);
 225     log("No obvious errors in response (so far)\n");
 226     return result;
 227 }
 228
 229 // returns true on success, false on (non-critical) failure
 230 bool WvExcConn::migrate_account()
 231 {
 232     log("Detected change in account info. Migrating account information.\n");
 233
 234     if (!storage->migrate_account(config[USERNAME_KEY].getme()))
 235         return false;
 236
 237     if (config[OLD_USERNAME_KEY].exists())
 238         config[OLD_USERNAME_KEY].remove();
 239
 240     if (config[OLD_SERVERID_KEY].exists())
 241         config[OLD_SERVERID_KEY].remove();
 242
 243     return true;
 244 }
 245
 246 bool WvExcConn::initial_folder_sync()
 247 {
 248     send_listfolders();
 249     if (!apply_pending_responses(false))
 250         return false;
 251
 252     // Create a toplevel "Calendar", "Contacts", and "Tasks" folders,
 253     // if these don't exist already
 254     WvString calendar_folder("%s.Calendar", storage->get_owner());
 255     if (!config[FOLDERS_KEY][calendar_folder].exists())
 256         storage->add_folder(calendar_folder, EXCHANGEIT_CALENDAR_TYPE, true);
 257
 258     WvString contacts_folder("%s.Contacts", storage->get_owner());
 259     if (!config[FOLDERS_KEY][contacts_folder].exists())
 260         storage->add_folder(contacts_folder, EXCHANGEIT_CONTACTS_TYPE, true);
 261
 262     WvString tasks_folder("%s.Tasks", storage->get_owner());
 263     if (!config[FOLDERS_KEY][tasks_folder].exists())
 264         storage->add_folder(tasks_folder, EXCHANGEIT_TASKS_TYPE, true);
 265
 266     return true;
 267 }
 268
 269 void WvExcConn::send_folder_commands()
 270 {
 271     cmd_tag = 1;
 272     send_createfolders();
 273     send_deletefolders();
 274     send_listfolders();
 275 }
 276
 277 // Here we send all the commands needed for a full sync of all folders.
 278 // We do not parse/apply responses.
 279 void WvExcConn::send_sync_commands()
 280 {
 281     // We were disconnected; retry remaining commands
 282     CommandHash *commands = conn_manager->get_commands();
 283     WvAutorelease<CommandHash> autoreleaser(commands);
 284
 285     log("send_sync_commands(): have progress_cb %s\n", have_progress_cb);
 286
 287     if (commands->count())
 288     {
 289         CommandHash::Iter i(*commands);
 290         int curr_cmd = 1;
 291         int total_cmds = commands->count();
 292
 293         log("Found %s unfinished commands. Retrying them.\n",
 294             total_cmds);
 295
 296         for (i.rewind(); i.next(); )
 297         {
 298             send_command(i().data, i().key);
 299             progress_notify(50 * curr_cmd++ / total_cmds);
 300         }
 301     }
 302     // We're good; do a full normal sync
 303     else
 304     {
 305         // The progress indications here are pretty cheesy;
 306         // is anybody going to care though?
 307         cmd_tag = 1;
 308         progress_notify(15);
 309
 310         send_listusers();
 311         send_setacls();
 312         send_getacls();
 313         progress_notify(30);
 314
 315         send_deletes();
 316         send_updates();
 317         send_syncs();
 318         progress_notify(50);
 319     }
 320 }
 321
 322 // Here we read from the stream, and apply any responses we receive.
 323 // (commands read the data they need now, not us)
 324 bool WvExcConn::apply_pending_responses(bool show_progress)
 325 {
 326     CommandHash *commands = conn_manager->get_commands();
 327     WvAutorelease<CommandHash> autoreleaser(commands);
 328     log("apply_pending_responses\n");
 329
 330     if (!commands)
 331     {
 332         log("Command hash is gone; unable to apply repsonses\n");
 333         return false;
 334     }
 335
 336     int cmd_num;
 337     int curr_cmd = 1;
 338     int total_cmds = commands->count();
 339     TaggedCommand *tagged_command;
 340     WvString tag;
 341     WvString command;
 342     WvString response;
 343     WvStringList parts;
 344
 345     // We call consume_newlines() at the end of each iteration to
 346     // make this loop work.
 347     while (!!(response = blocking_getline(TIMEOUT)))
 348     {
 349         log("<< (%s)\n", response);
 350         parts.zap();
 351         parts.split(response, " ");
 352         tag = parts.popstr();
 353         tagged_command = NULL;
 354
 355         log("Applying response for command %s\n", tag);
 356
 357         if (tag == "*")
 358         {
 359             command = parts.popstr();
 360             GenericCommand *generic_command =
 361                 GenericCommand::get_command(command);
 362
 363             if (!generic_command)
 364                 log("Didn't get a command for %s!\n", command);
 365
 366             if (!generic_command ||
 367                 !generic_command->apply_response(parts, *this, storage))
 368                 log("Applying generic command %s failed!\n", command);
 369
 370             delete generic_command;
 371         }
 372         else
 373         {
 374             cmd_num = tag.num();
 375             if (commands->exists(cmd_num))
 376             {
 377                 log("Found command %s in table\n", cmd_num);
 378                 tagged_command = *commands->find(cmd_num);
 379             }
 380
 381             if (tagged_command &&
 382                 tagged_command->apply_response(parts, *this, storage))
 383                 commands->remove(cmd_num);
 384             else
 385                 log("Applying response to command %s failed!\n", tag);
 386
 387             if (show_progress)
 388             {
 389                 progress_notify(50 + (50 * curr_cmd++ / total_cmds));
 390             }
 391         }
 392
 393         if (commands->isempty() || (curr_cmd-1) == total_cmds)
 394         {
 395             drain();
 396             break;
 397         }
 398         else
 399             consume_newlines();
 400
 401         config.commit(); // commit the results of this iteration
 402     }
 403
 404     log("%s commands left after application\n", commands->count());
 405     num_retries++;
 406
 407     // This is important, because it tells our camel "provider"
 408     // to complete its operation
 409     if (show_progress)
 410     {
 411         progress_notify(100);
 412     }
 413     bool isempty = commands->isempty();
 414     return isempty;
 415 }
 416
 417 void WvExcConn::send_listusers()
 418 {
 419     send_command(new ListUsers(storage->get_state()[USERS_KEY]));
 420 }
 421
 422 template <class Command>
 423 void WvExcConn::send_acl_cmds(UniConf cfg)
 424 {
 425     UniConf::Iter i(cfg);
 426     Command *command = NULL;
 427     WvString folder;
 428     WvString type;
 429
 430     for (i.rewind(); i.next(); )
 431     {
 432         folder = i().key().printable();
 433         if (storage->get_dict()[folder])
 434             type = *storage->get_dict()[folder]->get_type();
 435         else
 436             type = "UNKNOWN"; // uh-oh...
 437
 438         command = new Command(folder, type, storage);
 439         send_command(command);
 440         command = NULL;
 441     }
 442 }
 443
 444 void WvExcConn::send_setacls()
 445 {
 446     send_acl_cmds<SetACL>(storage->get_state()[SETACL_KEY]);
 447 }
 448
 449 void WvExcConn::send_getacls()
 450 {
 451     send_acl_cmds<GetACL>(storage->get_state()[GETACL_KEY]);
 452 }
 453
 454 void WvExcConn::send_createfolders()
 455 {
 456     CreateFolder *create_folder = NULL;
 457     WvString name;
 458     WvString type;
 459     WvStringList folders_toadd;
 460
 461     UniConf folders_toadd_key = storage->get_state()[FOLDERS_KEY][TOADD_KEY];
 462     UniConf::Iter i(folders_toadd_key);
 463     for (i.rewind(); i.next();)
 464         folders_toadd.append(i().key().printable());
 465
 466     // Create folders in sorted order so that nested folders get created
 467     // parent-first
 468     WvStringList::Sorter s(folders_toadd, &::wvstrcmp);
 469     for (s.rewind(); s.next(); )
 470     {
 471         name = s();
 472         type = folders_toadd_key[name].getme();
 473
 474         log("Folder add. Name: %s Type: %s\n", name, type);
 475
 476         create_folder = new CreateFolder(name, type);
 477         send_command(create_folder);
 478         create_folder = NULL;
 479     }
 480 }
 481
 482 void WvExcConn::send_deletefolders()
 483 {
 484     DeleteFolder *delete_folder = NULL;
 485     WvString name;
 486     WvString type;
 487     WvStringList folders_todelete;
 488
 489     UniConf folders_todelete_key = storage->get_state()[FOLDERS_KEY][TODELETE_KEY];
 490     UniConf::Iter j(folders_todelete_key);
 491     for (j.rewind(); j.next(); )
 492     {
 493         log("Folder delete. Name: %s\n", j().key().printable());
 494
 495         delete_folder = new DeleteFolder(j().key().printable(), j().getme());
 496         send_command(delete_folder);
 497         delete_folder = NULL;
 498
 499         // Unconditionally remove the 'todelete' key: If we didn't succeed,
 500         // the folder should be recreated the next time we sync
 501         folders_todelete.append(j().key().printable());
 502     }
 503
 504     WvStringList::Iter i(folders_todelete);
 505     for (i.rewind(); i.next(); )
 506         folders_todelete_key[i()].remove();
 507 }
 508
 509 void WvExcConn::send_listfolders()
 510 {
 511     send_command(new ListFolders(storage));
 512 }
 513
 514 template <class Command>
 515 void WvExcConn::send_item_cmds(WvStringParm action)
 516 {
 517     Command *command = NULL;
 518
 519     ExchangeItAdaptorDict::Iter dict = storage->get_dict();
 520     for (dict.rewind(); dict.next(); )
 521     {
 522         if (dict().is_ready())
 523         {
 524             if (dict().get_may_have_local_only_items())
 525                 dict().sync_local_items();
 526
 527             WvStringList *item_list = dict().get_item_uids(action);
 528             log("Found %s items in %s for folder %s\n",
 529                 item_list->count(), action, dict().key);
 530
 531             WvStringList::Iter i(*item_list);
 532             for (i.rewind(); i.next();)
 533             {
 534                 log("Item %s for folder %s: %s\n", action, dict().key, i());
 535
 536                 command = new Command(&dict(), i());
 537                 send_command(command);
 538                 command = NULL;
 539             }
 540
 541             delete item_list;
 542         }
 543     }
 544 }
 545
 546 void WvExcConn::send_deletes()
 547 {
 548     send_item_cmds<Delete>("todelete");
 549 }
 550
 551 void WvExcConn::send_updates()
 552 {
 553     send_item_cmds<Update>("tosend");
 554 }
 555
 556 void WvExcConn::send_syncs()
 557 {
 558     Sync *sync_command = NULL;
 559
 560     ExchangeItAdaptorDict::Iter dict = storage->get_dict();
 561     for (dict.rewind(); dict.next(); )
 562     {
 563         if (dict().is_ready())
 564         {
 565             sync_command = new Sync(&dict());
 566             send_command(sync_command);
 567             sync_command = NULL;
 568         }
 569     }
 570 }
 571
 572 /**
 573    @param tagged_command it deleted by the callee !
 574  */
 575 void WvExcConn::send_command(TaggedCommand *tagged_command, int tag)
 576 {
 577     if (!tagged_command)
 578         log("Got a NULL command to send!\n");
 579
 580     CommandHash *commands = conn_manager->get_commands();
 581     WvAutorelease<CommandHash> autoreleaser(commands);
 582
 583     if (!commands)
 584         log("Command hash is gone; unable to send commands\n");
 585
 586     // Check if the user tried to cancel the sync
 587     uint32_t msg = 1;
 588     if (sock && sizeof(uint32_t) == sock->read(&msg, sizeof(uint32_t)))
 589         if (!msg) nosend = true;
 590
 591     if (nosend || !tagged_command || !commands)
 592     {
 593         delete tagged_command;
 594         return;
 595     }
 596
 597     WvString line;
 598     WvString command;
 599     WvString server_command;
 600     WvStringList lines;
 601     WvStringList params;
 602
 603     tagged_command->get_command(command, params, lines);
 604
 605     // Tag is only to be set for commands being retried
 606     if (tag)
 607     {
 608         log("Retrying a %s command\n", command);
 609         server_command.append("%s %s", tag, command);
 610     }
 611     else
 612         server_command.append("%s %s", cmd_tag, command);
 613
 614     if (params.count())
 615         server_command.append(" %s", params.join(" "));
 616
 617     print("%s\n", server_command);
 618     log(">>> (%s)\n", server_command);
 619
 620     while (lines.count())
 621     {
 622         line = lines.popstr();
 623         print("%s\n", line);
 624         log(">>> (%s)\n", line);
 625     }
 626
 627     if (tagged_command->has_data())
 628         tagged_command->send_data(*this);
 629
 630     print("\n");
 631
 632     // Only insert command if we're not retrying
 633     if (!tag)
 634         commands->add(cmd_tag++, tagged_command, true);
 635 }
 636
 637 // Silly function to eat remaining blank lines from the stream. Helps us
 638 // work around borken servers, and simplifies apply_resonse() functions.
 639 void WvExcConn::consume_newlines()
 640 {
 641     WvDynBuf buf;
 642     unsigned char c = 0;
 643     int num = 0;
 644
 645     read(buf, 512);
 646     while (buf.used())
 647     {
 648         c = buf.get();
 649         if (c != '\n' && c != '\r')
 650         {
 651             buf.unget(1);
 652             break;
 653         }
 654         num++;
 655     }
 656
 657     log("Found %s newlines and ate them\n", num);
 658     unread(buf, buf.used());
 659 }
 660
 661 bool WvExcConn::start_sync_cb()
 662 {
 663     if (state == Idle)
 664     {
 665         progress = 0;
 666         nosend = false;
 667         state = Syncing;
 668         alarm(0);
 669         return true;
 670     }
 671     else
 672         return false;
 673 }
 674
 675 void WvExcConn::cancel_sync_cb()
 676 {
 677     log("cancel_sync_cb\n");
 678     nosend = true;
 679     have_progress_cb = false;
 680 }
 681
 682 void WvExcConn::unlink_commands()
 683 {
 684     // FIXME: this used to invalidate the commands member, but now
 685     // that this is moved to WcExcConnManager, this is made useless
 686     // I don't really know we should do.
 687     terminate_continue_select();
 688 }
 689
 690 bool WvExcConn::pre_select(SelectInfo &si)
 691 {
 692     bool ret = WvStreamClone::pre_select(si);
 693     bool want_close = false;
 694
 695     progress_notify(); // this will talk to camel,
 696                        // which should let us know if we need to quit or not
 697
 698     // If we've tried too many times OR the user cancels the sync, then reconnect
 699     if (num_retries >= MAX_RETRIES || nosend)
 700     {
 701         want_close = true;
 702         num_retries = 0;
 703     }
 704
 705     // Unless we've completed a transaction, or we're still
 706     // authenticating
 707     if (transaction_complete || state == Authenticate)
 708     {
 709         want_close = false;
 710         transaction_complete = false;
 711         num_retries = 0;
 712     }
 713
 714     if (want_close)
 715     {
 716         if (!nosend)
 717             seterr("Failed to apply pending responses");
 718         terminate_continue_select();
 719         return false;
 720     }
 721
 722
 723     return ret;
 724 }
 725
 726 void WvExcConn::execute()
 727 {
 728     WvStreamClone::execute();
 729
 730     CommandHash *commands = conn_manager->get_commands();
 731     WvAutorelease<CommandHash> autoreleaser(commands);
 732
 733     if (!commands)
 734     {
 735         log("Command hash is gone; not doing anything.\n");
 736         return;
 737     }
 738
 739     // we have to authenticate before we can do anything else
 740     if (state == Authenticate)
 741     {
 742         ErrorType auth_result;
 743
 744         log("Authenticating\n");
 745         auth_result = authenticate();
 746         if (auth_result != AuthOK)
 747         {
 748             // assume the server's gone and try again later
 749             // FIXME: should tell the user, and actually differentiate
 750             // between connection problems and authentication problems
 751             set_errcode(auth_result);
 752             log("Authentication failed !!\n");
 753             return;
 754         }
 755
 756         storage->load_folders(); // load (cached) folder list into memory
 757         if (commands->count())
 758             state = Syncing;
 759         else
 760             state = InitialFolderSync;
 761     }
 762
 763     if (state == InitialFolderSync)
 764     {
 765         if (!!config[OLD_USERNAME_KEY].getme() || !!config[OLD_SERVERID_KEY].getme())
 766         {
 767             if (!migrate_account())
 768             {
 769                 // call back later: not ready
 770                 alarm(2000);
 771             }
 772         }
 773
 774         log("Syncing folders for the first time!\n");
 775         if (!initial_folder_sync())
 776         {
 777             commands->zap();
 778             seterr("Couldn't perform initial folder sync");
 779         }
 780
 781         state = Idle;
 782     }
 783
 784     if (state == Syncing)
 785     {
 786         log("Syncing\n");
 787
 788         if (commands->isempty())
 789         {
 790             send_folder_commands();
 791             apply_pending_responses(false);
 792         }
 793
 794         send_sync_commands();
 795         bool success = apply_pending_responses();
 796
 797         if (!transaction_complete)
 798             transaction_complete = success;
 799
 800         state = Idle;
 801     }
 802
 803     config.commit();
 804 }