src/kits/mail/MailSettings.cpp

   1 /*
   2  * Copyright 2004-2015, Haiku Inc. All rights reserved.
   3  * Copyright 2001-2003 Dr. Zoidberg Enterprises. All rights reserved.
   4  *
   5  * Distributed under the terms of the MIT License.
   6  */
   7
   8
   9 //!     The mail daemon's settings
  10
  11
  12 #include <MailSettings.h>
  13
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <stdlib.h>
  17
  18 #include <Directory.h>
  19 #include <Entry.h>
  20 #include <File.h>
  21 #include <FindDirectory.h>
  22 #include <MailDaemon.h>
  23 #include <Message.h>
  24 #include <Messenger.h>
  25 #include <Path.h>
  26 #include <PathFinder.h>
  27 #include <String.h>
  28 #include <Window.h>
  29
  30 #include <MailPrivate.h>
  31
  32
  33 //      #pragma mark - BMailSettings
  34
  35
  36 BMailSettings::BMailSettings()
  37 {
  38         Reload();
  39 }
  40
  41
  42 BMailSettings::~BMailSettings()
  43 {
  44 }
  45
  46
  47 status_t
  48 BMailSettings::InitCheck() const
  49 {
  50         return B_OK;
  51 }
  52
  53
  54 status_t
  55 BMailSettings::Save()
  56 {
  57         BPath path;
  58         status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
  59         if (status != B_OK) {
  60                 fprintf(stderr, "Couldn't find user settings directory: %s\n",
  61                         strerror(status));
  62                 return status;
  63         }
  64
  65         path.Append("Mail");
  66
  67         status = BPrivate::WriteMessageFile(fData, path, "new_mail_daemon");
  68         if (status != B_OK)
  69                 return status;
  70
  71         BMessenger(B_MAIL_DAEMON_SIGNATURE).SendMessage(
  72                 BPrivate::kMsgSettingsUpdated);
  73         return B_OK;
  74 }
  75
  76
  77 status_t
  78 BMailSettings::Reload()
  79 {
  80         // Try directories from most specific to least
  81         directory_which which[] = {
  82                 B_USER_SETTINGS_DIRECTORY,
  83                 B_SYSTEM_SETTINGS_DIRECTORY};
  84         status_t status = B_ENTRY_NOT_FOUND;
  85
  86         for (size_t i = 0; i < sizeof(which) / sizeof(which[0]); i++) {
  87                 BPath path;
  88                 status = find_directory(which[i], &path);
  89                 if (status != B_OK)
  90                         continue;
  91
  92                 path.Append("Mail/new_mail_daemon");
  93                 BFile file;
  94                 status = file.SetTo(path.Path(), B_READ_ONLY);
  95                 if (status != B_OK)
  96                         continue;
  97
  98                 // read settings
  99                 BMessage settings;
 100                 status = settings.Unflatten(&file);
 101                 if (status != B_OK) {
 102                         fprintf(stderr, "Couldn't read settings from '%s': %s\n",
 103                                 path.Path(), strerror(status));
 104                         continue;
 105                 }
 106
 107                 // clobber old settings
 108                 fData = settings;
 109                 return B_OK;
 110         }
 111
 112         return status;
 113 }
 114
 115
 116 //      # pragma mark - Global settings
 117
 118
 119 int32
 120 BMailSettings::WindowFollowsCorner()
 121 {
 122         return fData.FindInt32("WindowFollowsCorner");
 123 }
 124
 125
 126 void
 127 BMailSettings::SetWindowFollowsCorner(int32 whichCorner)
 128 {
 129         if (fData.ReplaceInt32("WindowFollowsCorner", whichCorner) != B_OK)
 130                 fData.AddInt32("WindowFollowsCorner", whichCorner);
 131 }
 132
 133
 134 uint32
 135 BMailSettings::ShowStatusWindow()
 136 {
 137         int32 showStatusWindow;
 138         if (fData.FindInt32("ShowStatusWindow", &showStatusWindow) != B_OK) {
 139                 // show during send and receive
 140                 return 2;
 141         }
 142
 143         return showStatusWindow;
 144 }
 145
 146
 147 void
 148 BMailSettings::SetShowStatusWindow(uint32 mode)
 149 {
 150         if (fData.ReplaceInt32("ShowStatusWindow", mode) != B_OK)
 151                 fData.AddInt32("ShowStatusWindow", mode);
 152 }
 153
 154
 155 bool
 156 BMailSettings::DaemonAutoStarts()
 157 {
 158         return fData.FindBool("DaemonAutoStarts");
 159 }
 160
 161
 162 void
 163 BMailSettings::SetDaemonAutoStarts(bool startIt)
 164 {
 165         if (fData.ReplaceBool("DaemonAutoStarts", startIt) != B_OK)
 166                 fData.AddBool("DaemonAutoStarts", startIt);
 167 }
 168
 169
 170 BRect
 171 BMailSettings::ConfigWindowFrame()
 172 {
 173         return fData.FindRect("ConfigWindowFrame");
 174 }
 175
 176
 177 void
 178 BMailSettings::SetConfigWindowFrame(BRect frame)
 179 {
 180         if (fData.ReplaceRect("ConfigWindowFrame", frame) != B_OK)
 181                 fData.AddRect("ConfigWindowFrame", frame);
 182 }
 183
 184
 185 BRect
 186 BMailSettings::StatusWindowFrame()
 187 {
 188         BRect frame;
 189         if (fData.FindRect("StatusWindowFrame", &frame) != B_OK)
 190                 return BRect(100, 100, 200, 120);
 191
 192         return frame;
 193 }
 194
 195
 196 void
 197 BMailSettings::SetStatusWindowFrame(BRect frame)
 198 {
 199         if (fData.ReplaceRect("StatusWindowFrame", frame) != B_OK)
 200                 fData.AddRect("StatusWindowFrame", frame);
 201 }
 202
 203
 204 int32
 205 BMailSettings::StatusWindowWorkspaces()
 206 {
 207         uint32 workspaces;
 208         if (fData.FindInt32("StatusWindowWorkSpace", (int32*)&workspaces) != B_OK)
 209                 return B_ALL_WORKSPACES;
 210
 211         return workspaces;
 212 }
 213
 214
 215 void
 216 BMailSettings::SetStatusWindowWorkspaces(int32 workspace)
 217 {
 218         if (fData.ReplaceInt32("StatusWindowWorkSpace", workspace) != B_OK)
 219                 fData.AddInt32("StatusWindowWorkSpace", workspace);
 220
 221         BMessage msg('wsch');
 222         msg.AddInt32("StatusWindowWorkSpace",workspace);
 223         BMessenger(B_MAIL_DAEMON_SIGNATURE).SendMessage(&msg);
 224 }
 225
 226
 227 int32
 228 BMailSettings::StatusWindowLook()
 229 {
 230         return fData.FindInt32("StatusWindowLook");
 231 }
 232
 233
 234 void
 235 BMailSettings::SetStatusWindowLook(int32 look)
 236 {
 237         if (fData.ReplaceInt32("StatusWindowLook", look) != B_OK)
 238                 fData.AddInt32("StatusWindowLook", look);
 239
 240         BMessage msg('lkch');
 241         msg.AddInt32("StatusWindowLook", look);
 242         BMessenger(B_MAIL_DAEMON_SIGNATURE).SendMessage(&msg);
 243 }
 244
 245
 246 bigtime_t
 247 BMailSettings::AutoCheckInterval()
 248 {
 249         bigtime_t value;
 250         if (fData.FindInt64("AutoCheckInterval", &value) != B_OK) {
 251                 // every 5 min
 252                 return 5 * 60 * 1000 * 1000;
 253         }
 254         return value;
 255 }
 256
 257
 258 void
 259 BMailSettings::SetAutoCheckInterval(bigtime_t interval)
 260 {
 261         if (fData.ReplaceInt64("AutoCheckInterval", interval) != B_OK)
 262                 fData.AddInt64("AutoCheckInterval", interval);
 263 }
 264
 265
 266 bool
 267 BMailSettings::CheckOnlyIfPPPUp()
 268 {
 269         return fData.FindBool("CheckOnlyIfPPPUp");
 270 }
 271
 272
 273 void
 274 BMailSettings::SetCheckOnlyIfPPPUp(bool yes)
 275 {
 276         if (fData.ReplaceBool("CheckOnlyIfPPPUp", yes))
 277                 fData.AddBool("CheckOnlyIfPPPUp", yes);
 278 }
 279
 280
 281 bool
 282 BMailSettings::SendOnlyIfPPPUp()
 283 {
 284         return fData.FindBool("SendOnlyIfPPPUp");
 285 }
 286
 287
 288 void
 289 BMailSettings::SetSendOnlyIfPPPUp(bool yes)
 290 {
 291         if (fData.ReplaceBool("SendOnlyIfPPPUp", yes))
 292                 fData.AddBool("SendOnlyIfPPPUp", yes);
 293 }
 294
 295
 296 int32
 297 BMailSettings::DefaultOutboundAccount()
 298 {
 299         return fData.FindInt32("DefaultOutboundAccount");
 300 }
 301
 302
 303 void
 304 BMailSettings::SetDefaultOutboundAccount(int32 to)
 305 {
 306         if (fData.ReplaceInt32("DefaultOutboundAccount", to) != B_OK)
 307                 fData.AddInt32("DefaultOutboundAccount", to);
 308 }
 309
 310
 311 // #pragma mark -
 312
 313
 314 BMailAccounts::BMailAccounts()
 315 {
 316         BPath path;
 317         status_t status = AccountsPath(path);
 318         if (status != B_OK)
 319                 return;
 320
 321         BDirectory dir(path.Path());
 322         if (dir.InitCheck() != B_OK)
 323                 return;
 324
 325         std::vector<time_t> creationTimeList;
 326         BEntry entry;
 327         while (dir.GetNextEntry(&entry) != B_ENTRY_NOT_FOUND) {
 328                 BNode node(&entry);
 329                 time_t creationTime;
 330                 if (node.GetCreationTime(&creationTime) != B_OK)
 331                         continue;
 332
 333                 BMailAccountSettings* account = new BMailAccountSettings(entry);
 334                 if (account->InitCheck() != B_OK) {
 335                         delete account;
 336                         continue;
 337                 }
 338
 339                 // sort by creation time
 340                 int insertIndex = -1;
 341                 for (unsigned int i = 0; i < creationTimeList.size(); i++) {
 342                         if (creationTimeList[i] > creationTime) {
 343                                 insertIndex = i;
 344                                 break;
 345                         }
 346                 }
 347                 if (insertIndex < 0) {
 348                         fAccounts.AddItem(account);
 349                         creationTimeList.push_back(creationTime);
 350                 } else {
 351                         fAccounts.AddItem(account, insertIndex);
 352                         creationTimeList.insert(creationTimeList.begin() + insertIndex,
 353                                 creationTime);
 354                 }
 355         }
 356 }
 357
 358
 359 status_t
 360 BMailAccounts::AccountsPath(BPath& path)
 361 {
 362         status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
 363         if (status != B_OK)
 364                 return status;
 365         return path.Append("Mail/accounts");
 366 }
 367
 368
 369 BMailAccounts::~BMailAccounts()
 370 {
 371         for (int i = 0; i < fAccounts.CountItems(); i++)
 372                 delete fAccounts.ItemAt(i);
 373 }
 374
 375
 376 int32
 377 BMailAccounts::CountAccounts()
 378 {
 379         return fAccounts.CountItems();
 380 }
 381
 382
 383 BMailAccountSettings*
 384 BMailAccounts::AccountAt(int32 index)
 385 {
 386         return fAccounts.ItemAt(index);
 387 }
 388
 389
 390 BMailAccountSettings*
 391 BMailAccounts::AccountByID(int32 id)
 392 {
 393         for (int i = 0; i < fAccounts.CountItems(); i++) {
 394                 BMailAccountSettings* account = fAccounts.ItemAt(i);
 395                 if (account->AccountID() == id)
 396                         return account;
 397         }
 398         return NULL;
 399 }
 400
 401
 402 BMailAccountSettings*
 403 BMailAccounts::AccountByName(const char* name)
 404 {
 405         for (int i = 0; i < fAccounts.CountItems(); i++) {
 406                 BMailAccountSettings* account = fAccounts.ItemAt(i);
 407                 if (strcmp(account->Name(), name) == 0)
 408                         return account;
 409         }
 410         return NULL;
 411 }
 412
 413
 414 // #pragma mark -
 415
 416
 417 BMailAddOnSettings::BMailAddOnSettings()
 418 {
 419 }
 420
 421
 422 BMailAddOnSettings::~BMailAddOnSettings()
 423 {
 424 }
 425
 426
 427 status_t
 428 BMailAddOnSettings::Load(const BMessage& message)
 429 {
 430         const char* pathString = NULL;
 431         if (message.FindString("add-on path", &pathString) != B_OK)
 432                 return B_BAD_VALUE;
 433
 434         BPath path(pathString);
 435
 436         if (!path.IsAbsolute()) {
 437                 BStringList paths;
 438                 BPathFinder().FindPaths(B_FIND_PATH_ADD_ONS_DIRECTORY, "mail_daemon",
 439                         paths);
 440
 441                 status_t status = B_ENTRY_NOT_FOUND;
 442
 443                 for (int32 i = 0; i < paths.CountStrings(); i++) {
 444                         path.SetTo(paths.StringAt(i), pathString);
 445                         BEntry entry(path.Path());
 446                         if (entry.Exists()) {
 447                                 status = B_OK;
 448                                 break;
 449                         }
 450                 }
 451                 if (status != B_OK)
 452                         return status;
 453         }
 454
 455         status_t status = get_ref_for_path(path.Path(), &fRef);
 456         if (status != B_OK)
 457                 return status;
 458
 459         BMessage settings;
 460         message.FindMessage("settings", &settings);
 461
 462         MakeEmpty();
 463         Append(settings);
 464
 465         fOriginalSettings = *this;
 466         fOriginalRef = fRef;
 467         return B_OK;
 468 }
 469
 470
 471 status_t
 472 BMailAddOnSettings::Save(BMessage& message)
 473 {
 474         BPath path(&fRef);
 475         status_t status = message.AddString("add-on path", _RelativizePath(path));
 476         if (status == B_OK)
 477                 status = message.AddMessage("settings", this);
 478         if (status != B_OK)
 479                 return status;
 480
 481         fOriginalSettings = *this;
 482         fOriginalRef = fRef;
 483         return B_OK;
 484 }
 485
 486
 487 void
 488 BMailAddOnSettings::SetAddOnRef(const entry_ref& ref)
 489 {
 490         fRef = ref;
 491 }
 492
 493
 494 const entry_ref&
 495 BMailAddOnSettings::AddOnRef() const
 496 {
 497         return fRef;
 498 }
 499
 500
 501 bool
 502 BMailAddOnSettings::HasBeenModified() const
 503 {
 504         return fRef != fOriginalRef
 505                 || !fOriginalSettings.HasSameData(*this, true, true);
 506 }
 507
 508
 509 /*!     Cuts off the ".../add-ons/mail_daemon" part of the provided \a path
 510         in case it exists. Otherwise, the complete path will be returned.
 511 */
 512 const char*
 513 BMailAddOnSettings::_RelativizePath(const BPath& path) const
 514 {
 515         const char* string = path.Path();
 516         const char* parentDirectory = "/mail_daemon/";
 517         const char* at = strstr(string, parentDirectory);
 518         if (at == NULL)
 519                 return string;
 520
 521         return at + strlen(parentDirectory);
 522 }
 523
 524
 525 // #pragma mark -
 526
 527
 528 BMailProtocolSettings::BMailProtocolSettings()
 529         :
 530         fFiltersSettings(5, true)
 531 {
 532 }
 533
 534
 535 BMailProtocolSettings::~BMailProtocolSettings()
 536 {
 537 }
 538
 539
 540 status_t
 541 BMailProtocolSettings::Load(const BMessage& message)
 542 {
 543         status_t status = BMailAddOnSettings::Load(message);
 544         if (status != B_OK)
 545                 return status;
 546
 547         type_code typeFound;
 548         int32 countFound;
 549         message.GetInfo("filters", &typeFound, &countFound);
 550         if (typeFound != B_MESSAGE_TYPE)
 551                 return B_BAD_VALUE;
 552
 553         for (int i = 0; i < countFound; i++) {
 554                 int32 index = AddFilterSettings();
 555                 if (index < 0)
 556                         return B_NO_MEMORY;
 557
 558                 BMailAddOnSettings* filterSettings = fFiltersSettings.ItemAt(index);
 559
 560                 BMessage filterMessage;
 561                 message.FindMessage("filters", i, &filterMessage);
 562                 if (filterSettings->Load(filterMessage) != B_OK)
 563                         RemoveFilterSettings(index);
 564         }
 565         return B_OK;
 566 }
 567
 568
 569 status_t
 570 BMailProtocolSettings::Save(BMessage& message)
 571 {
 572         status_t status = BMailAddOnSettings::Save(message);
 573         if (status != B_OK)
 574                 return status;
 575
 576         for (int i = 0; i < CountFilterSettings(); i++) {
 577                 BMessage filter;
 578                 BMailAddOnSettings* filterSettings = fFiltersSettings.ItemAt(i);
 579                 filterSettings->Save(filter);
 580                 message.AddMessage("filters", &filter);
 581         }
 582         return B_OK;
 583 }
 584
 585
 586 int32
 587 BMailProtocolSettings::CountFilterSettings() const
 588 {
 589         return fFiltersSettings.CountItems();
 590 }
 591
 592
 593 int32
 594 BMailProtocolSettings::AddFilterSettings(const entry_ref* ref)
 595 {
 596         BMailAddOnSettings* filterSettings = new BMailAddOnSettings();
 597         if (ref != NULL)
 598                 filterSettings->SetAddOnRef(*ref);
 599
 600         if (fFiltersSettings.AddItem(filterSettings))
 601                 return fFiltersSettings.CountItems() - 1;
 602
 603         delete filterSettings;
 604         return -1;
 605 }
 606
 607
 608 void
 609 BMailProtocolSettings::RemoveFilterSettings(int32 index)
 610 {
 611         fFiltersSettings.RemoveItemAt(index);
 612 }
 613
 614
 615 bool
 616 BMailProtocolSettings::MoveFilterSettings(int32 from, int32 to)
 617 {
 618         if (from < 0 || from >= (int32)CountFilterSettings() || to < 0
 619                 || to >= (int32)CountFilterSettings())
 620                 return false;
 621         if (from == to)
 622                 return true;
 623
 624         BMailAddOnSettings* settings = fFiltersSettings.RemoveItemAt(from);
 625         fFiltersSettings.AddItem(settings, to);
 626         return true;
 627 }
 628
 629
 630 BMailAddOnSettings*
 631 BMailProtocolSettings::FilterSettingsAt(int32 index) const
 632 {
 633         return fFiltersSettings.ItemAt(index);
 634 }
 635
 636
 637 bool
 638 BMailProtocolSettings::HasBeenModified() const
 639 {
 640         if (BMailAddOnSettings::HasBeenModified())
 641                 return true;
 642         for (int32 i = 0; i < CountFilterSettings(); i++) {
 643                 if (FilterSettingsAt(i)->HasBeenModified())
 644                         return true;
 645         }
 646         return false;
 647 }
 648
 649
 650 //      #pragma mark -
 651
 652
 653 BMailAccountSettings::BMailAccountSettings()
 654         :
 655         fStatus(B_OK),
 656         fInboundEnabled(true),
 657         fOutboundEnabled(true),
 658         fModified(true)
 659 {
 660         fAccountID = real_time_clock();
 661 }
 662
 663
 664 BMailAccountSettings::BMailAccountSettings(BEntry account)
 665         :
 666         fAccountFile(account),
 667         fModified(false)
 668 {
 669         fStatus = Reload();
 670 }
 671
 672
 673 BMailAccountSettings::~BMailAccountSettings()
 674 {
 675
 676 }
 677
 678
 679 void
 680 BMailAccountSettings::SetAccountID(int32 id)
 681 {
 682         fModified = true;
 683         fAccountID = id;
 684 }
 685
 686
 687 int32
 688 BMailAccountSettings::AccountID() const
 689 {
 690         return fAccountID;
 691 }
 692
 693
 694 void
 695 BMailAccountSettings::SetName(const char* name)
 696 {
 697         fModified = true;
 698         fAccountName = name;
 699 }
 700
 701
 702 const char*
 703 BMailAccountSettings::Name() const
 704 {
 705         return fAccountName;
 706 }
 707
 708
 709 void
 710 BMailAccountSettings::SetRealName(const char* realName)
 711 {
 712         fModified = true;
 713         fRealName = realName;
 714 }
 715
 716
 717 const char*
 718 BMailAccountSettings::RealName() const
 719 {
 720         return fRealName;
 721 }
 722
 723
 724 void
 725 BMailAccountSettings::SetReturnAddress(const char* returnAddress)
 726 {
 727         fModified = true;
 728         fReturnAdress = returnAddress;
 729 }
 730
 731
 732 const char*
 733 BMailAccountSettings::ReturnAddress() const
 734 {
 735         return fReturnAdress;
 736 }
 737
 738
 739 bool
 740 BMailAccountSettings::SetInboundAddOn(const char* name)
 741 {
 742         entry_ref ref;
 743         if (_GetAddOnRef("mail_daemon/inbound_protocols", name, ref) != B_OK)
 744                 return false;
 745
 746         fInboundSettings.SetAddOnRef(ref);
 747         return true;
 748 }
 749
 750
 751 bool
 752 BMailAccountSettings::SetOutboundAddOn(const char* name)
 753 {
 754         entry_ref ref;
 755         if (_GetAddOnRef("mail_daemon/outbound_protocols", name, ref) != B_OK)
 756                 return false;
 757
 758         fOutboundSettings.SetAddOnRef(ref);
 759         return true;
 760 }
 761
 762
 763 const entry_ref&
 764 BMailAccountSettings::InboundAddOnRef() const
 765 {
 766         return fInboundSettings.AddOnRef();
 767 }
 768
 769
 770 const entry_ref&
 771 BMailAccountSettings::OutboundAddOnRef() const
 772 {
 773         return fOutboundSettings.AddOnRef();
 774 }
 775
 776
 777 BMailProtocolSettings&
 778 BMailAccountSettings::InboundSettings()
 779 {
 780         return fInboundSettings;
 781 }
 782
 783
 784 const BMailProtocolSettings&
 785 BMailAccountSettings::InboundSettings() const
 786 {
 787         return fInboundSettings;
 788 }
 789
 790
 791 BMailProtocolSettings&
 792 BMailAccountSettings::OutboundSettings()
 793 {
 794         return fOutboundSettings;
 795 }
 796
 797
 798 const BMailProtocolSettings&
 799 BMailAccountSettings::OutboundSettings() const
 800 {
 801         return fOutboundSettings;
 802 }
 803
 804
 805 bool
 806 BMailAccountSettings::HasInbound()
 807 {
 808         return BEntry(&fInboundSettings.AddOnRef()).Exists();
 809 }
 810
 811
 812 bool
 813 BMailAccountSettings::HasOutbound()
 814 {
 815         return BEntry(&fOutboundSettings.AddOnRef()).Exists();
 816 }
 817
 818
 819 void
 820 BMailAccountSettings::SetInboundEnabled(bool enabled)
 821 {
 822         fInboundEnabled = enabled;
 823         fModified = true;
 824 }
 825
 826
 827 bool
 828 BMailAccountSettings::IsInboundEnabled() const
 829 {
 830         return fInboundEnabled;
 831 }
 832
 833
 834 void
 835 BMailAccountSettings::SetOutboundEnabled(bool enabled)
 836 {
 837         fOutboundEnabled = enabled;
 838         fModified = true;
 839 }
 840
 841
 842 bool
 843 BMailAccountSettings::IsOutboundEnabled() const
 844 {
 845         return fOutboundEnabled;
 846 }
 847
 848
 849 status_t
 850 BMailAccountSettings::Reload()
 851 {
 852         BFile file(&fAccountFile, B_READ_ONLY);
 853         status_t status = file.InitCheck();
 854         if (status != B_OK)
 855                 return status;
 856         BMessage settings;
 857         settings.Unflatten(&file);
 858
 859         int32 id;
 860         if (settings.FindInt32("id", &id) == B_OK)
 861                 fAccountID = id;
 862         settings.FindString("name", &fAccountName);
 863         settings.FindString("real_name", &fRealName);
 864         settings.FindString("return_address", &fReturnAdress);
 865
 866         BMessage inboundSettings;
 867         settings.FindMessage("inbound", &inboundSettings);
 868         fInboundSettings.Load(inboundSettings);
 869         BMessage outboundSettings;
 870         settings.FindMessage("outbound", &outboundSettings);
 871         fOutboundSettings.Load(outboundSettings);
 872
 873         if (settings.FindBool("inbound_enabled", &fInboundEnabled) != B_OK)
 874                 fInboundEnabled = true;
 875         if (settings.FindBool("outbound_enabled", &fOutboundEnabled) != B_OK)
 876                 fOutboundEnabled = true;
 877
 878         fModified = false;
 879         return B_OK;
 880 }
 881
 882
 883 status_t
 884 BMailAccountSettings::Save()
 885 {
 886         fModified = false;
 887
 888         BMessage settings;
 889         settings.AddInt32("id", fAccountID);
 890         settings.AddString("name", fAccountName);
 891         settings.AddString("real_name", fRealName);
 892         settings.AddString("return_address", fReturnAdress);
 893
 894         BMessage inboundSettings;
 895         fInboundSettings.Save(inboundSettings);
 896         settings.AddMessage("inbound", &inboundSettings);
 897         BMessage outboundSettings;
 898         fOutboundSettings.Save(outboundSettings);
 899         settings.AddMessage("outbound", &outboundSettings);
 900
 901         settings.AddBool("inbound_enabled", fInboundEnabled);
 902         settings.AddBool("outbound_enabled", fOutboundEnabled);
 903
 904         status_t status = _CreateAccountFilePath();
 905         if (status != B_OK)
 906                 return status;
 907
 908         BFile file(&fAccountFile, B_READ_WRITE | B_CREATE_FILE | B_ERASE_FILE);
 909         status = file.InitCheck();
 910         if (status != B_OK)
 911                 return status;
 912         return settings.Flatten(&file);
 913 }
 914
 915
 916 status_t
 917 BMailAccountSettings::Delete()
 918 {
 919         return fAccountFile.Remove();
 920 }
 921
 922
 923 bool
 924 BMailAccountSettings::HasBeenModified() const
 925 {
 926         return fModified
 927                 || fInboundSettings.HasBeenModified()
 928                 || fOutboundSettings.HasBeenModified();
 929 }
 930
 931
 932 const BEntry&
 933 BMailAccountSettings::AccountFile() const
 934 {
 935         return fAccountFile;
 936 }
 937
 938
 939 status_t
 940 BMailAccountSettings::_CreateAccountFilePath()
 941 {
 942         BPath path;
 943         status_t status = find_directory(B_USER_SETTINGS_DIRECTORY, &path);
 944         if (status != B_OK)
 945                 return status;
 946         path.Append("Mail/accounts");
 947         create_directory(path.Path(), 777);
 948
 949         if (fAccountFile.InitCheck() == B_OK)
 950                 return B_OK;
 951
 952         BString fileName = fAccountName;
 953         if (fileName == "")
 954                 fileName << fAccountID;
 955         for (int i = 0; ; i++) {
 956                 BString testFileName = fileName;
 957                 if (i != 0) {
 958                         testFileName += "_";
 959                         testFileName << i;
 960                 }
 961                 BPath testPath(path);
 962                 testPath.Append(testFileName);
 963                 BEntry testEntry(testPath.Path());
 964                 if (!testEntry.Exists()) {
 965                         fileName = testFileName;
 966                         break;
 967                 }
 968         }
 969
 970         path.Append(fileName);
 971         return fAccountFile.SetTo(path.Path());
 972 }
 973
 974
 975 status_t
 976 BMailAccountSettings::_GetAddOnRef(const char* subPath, const char* name,
 977         entry_ref& ref)
 978 {
 979         BStringList paths;
 980         BPathFinder().FindPaths(B_FIND_PATH_ADD_ONS_DIRECTORY, subPath, paths);
 981
 982         for (int32 i = 0; i < paths.CountStrings(); i++) {
 983                 BPath path(paths.StringAt(i), name);
 984                 BEntry entry(path.Path());
 985                 if (entry.Exists()) {
 986                         if (entry.GetRef(&ref) == B_OK)
 987                                 return B_OK;
 988                 }
 989         }
 990         return B_ENTRY_NOT_FOUND;
 991 }