git.notmuchmail.org Git - notmuch/blob - lib/open.cc

   1 #include <unistd.h>
   2 #include <libgen.h>
   3
   4 #include "database-private.h"
   5 #include "parse-time-vrp.h"
   6 #include "path-util.h"
   7
   8 #if HAVE_XAPIAN_DB_RETRY_LOCK
   9 #define DB_ACTION (Xapian::DB_CREATE_OR_OPEN | Xapian::DB_RETRY_LOCK)
  10 #else
  11 #define DB_ACTION Xapian::DB_CREATE_OR_OPEN
  12 #endif
  13
  14 notmuch_status_t
  15 notmuch_database_open (const char *path,
  16                        notmuch_database_mode_t mode,
  17                        notmuch_database_t **database)
  18 {
  19     char *status_string = NULL;
  20     notmuch_status_t status;
  21
  22     status = notmuch_database_open_with_config (path, mode, "", NULL,
  23                                                 database, &status_string);
  24     if (status_string) {
  25         fputs (status_string, stderr);
  26         free (status_string);
  27     }
  28
  29     return status;
  30 }
  31
  32 notmuch_status_t
  33 notmuch_database_open_verbose (const char *path,
  34                                notmuch_database_mode_t mode,
  35                                notmuch_database_t **database,
  36                                char **status_string)
  37 {
  38     return notmuch_database_open_with_config (path, mode, "", NULL,
  39                                               database, status_string);
  40 }
  41
  42 static const char *
  43 _xdg_dir (void *ctx,
  44           const char *xdg_root_variable,
  45           const char *xdg_prefix,
  46           const char *profile_name)
  47 {
  48     const char *xdg_root = getenv (xdg_root_variable);
  49
  50     if (! xdg_root) {
  51         const char *home = getenv ("HOME");
  52
  53         if (! home) return NULL;
  54
  55         xdg_root = talloc_asprintf (ctx,
  56                                     "%s/%s",
  57                                     home,
  58                                     xdg_prefix);
  59     }
  60
  61     if (! profile_name)
  62         profile_name = getenv ("NOTMUCH_PROFILE");
  63
  64     if (! profile_name)
  65         profile_name = "default";
  66
  67     return talloc_asprintf (ctx,
  68                             "%s/notmuch/%s",
  69                             xdg_root,
  70                             profile_name);
  71 }
  72
  73 static notmuch_status_t
  74 _choose_dir (notmuch_database_t *notmuch,
  75              const char *profile,
  76              notmuch_config_key_t key,
  77              const char *xdg_var,
  78              const char *xdg_subdir,
  79              const char *subdir,
  80              char **message = NULL)
  81 {
  82     const char *parent;
  83     const char *dir;
  84     struct stat st;
  85     int err;
  86
  87     dir = notmuch_config_get (notmuch, key);
  88
  89     if (dir)
  90         return NOTMUCH_STATUS_SUCCESS;
  91
  92     parent = _xdg_dir (notmuch, xdg_var, xdg_subdir, profile);
  93     if (! parent)
  94         return NOTMUCH_STATUS_PATH_ERROR;
  95
  96     dir = talloc_asprintf (notmuch, "%s/%s", parent, subdir);
  97
  98     err = stat (dir, &st);
  99     if (err) {
 100         if (errno == ENOENT) {
 101             char *notmuch_path = dirname (talloc_strdup (notmuch, notmuch->xapian_path));
 102             dir = talloc_asprintf (notmuch, "%s/%s", notmuch_path, subdir);
 103         } else {
 104             IGNORE_RESULT (asprintf (message, "Error: Cannot stat %s: %s.\n",
 105                                      dir, strerror (errno)));
 106             return NOTMUCH_STATUS_FILE_ERROR;
 107         }
 108     }
 109
 110     _notmuch_config_cache (notmuch, key, dir);
 111
 112     return NOTMUCH_STATUS_SUCCESS;
 113 }
 114
 115 static notmuch_status_t
 116 _load_key_file (notmuch_database_t *notmuch,
 117                 const char *path,
 118                 const char *profile,
 119                 GKeyFile **key_file)
 120 {
 121     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
 122
 123     if (path && EMPTY_STRING (path))
 124         goto DONE;
 125
 126     if (! path)
 127         path = getenv ("NOTMUCH_CONFIG");
 128
 129     if (path)
 130         path = talloc_strdup (notmuch, path);
 131     else {
 132         const char *dir = _xdg_dir (notmuch, "XDG_CONFIG_HOME", ".config", profile);
 133
 134         if (dir) {
 135             path = talloc_asprintf (notmuch, "%s/config", dir);
 136             if (access (path, R_OK) != 0)
 137                 path = NULL;
 138         }
 139     }
 140
 141     if (! path) {
 142         const char *home = getenv ("HOME");
 143
 144         path = talloc_asprintf (notmuch, "%s/.notmuch-config", home);
 145
 146         if (! profile)
 147             profile = getenv ("NOTMUCH_PROFILE");
 148
 149         if (profile)
 150             path = talloc_asprintf (notmuch, "%s.%s", path, profile);
 151     }
 152
 153     *key_file = g_key_file_new ();
 154     if (! g_key_file_load_from_file (*key_file, path, G_KEY_FILE_NONE, NULL)) {
 155         status = NOTMUCH_STATUS_NO_CONFIG;
 156     }
 157
 158   DONE:
 159     if (path)
 160         notmuch->config_path = path;
 161
 162     return status;
 163 }
 164
 165 static notmuch_status_t
 166 _db_dir_exists (const char *database_path, char **message)
 167 {
 168     struct stat st;
 169     int err;
 170
 171     err = stat (database_path, &st);
 172     if (err) {
 173         IGNORE_RESULT (asprintf (message, "Error: Cannot open database at %s: %s.\n",
 174                                  database_path, strerror (errno)));
 175         return NOTMUCH_STATUS_FILE_ERROR;
 176     }
 177
 178     if (! S_ISDIR (st.st_mode)) {
 179         IGNORE_RESULT (asprintf (message, "Error: Cannot open database at %s: "
 180                                  "Not a directory.\n",
 181                                  database_path));
 182         return NOTMUCH_STATUS_FILE_ERROR;
 183     }
 184
 185     return NOTMUCH_STATUS_SUCCESS;
 186 }
 187
 188 static notmuch_status_t
 189 _choose_database_path (notmuch_database_t *notmuch,
 190                        const char *profile,
 191                        GKeyFile *key_file,
 192                        const char **database_path,
 193                        bool *split,
 194                        char **message)
 195 {
 196     if (! *database_path) {
 197         *database_path = getenv ("NOTMUCH_DATABASE");
 198     }
 199
 200     if (! *database_path && key_file) {
 201         char *path = g_key_file_get_string (key_file, "database", "path", NULL);
 202         if (path) {
 203             if (path[0] == '/')
 204                 *database_path = talloc_strdup (notmuch, path);
 205             else
 206                 *database_path = talloc_asprintf (notmuch, "%s/%s", getenv ("HOME"), path);
 207             g_free (path);
 208         }
 209     }
 210     if (! *database_path) {
 211         notmuch_status_t status;
 212
 213         *database_path = _xdg_dir (notmuch, "XDG_DATA_HOME", ".local/share", profile);
 214         status = _db_dir_exists (*database_path, message);
 215         if (status) {
 216             *database_path = NULL;
 217         } else {
 218             *split = true;
 219         }
 220     }
 221
 222     if (! *database_path) {
 223         *database_path = getenv ("MAILDIR");
 224     }
 225
 226     if (! *database_path) {
 227         notmuch_status_t status;
 228
 229         *database_path = talloc_asprintf (notmuch, "%s/mail", getenv ("HOME"));
 230         status = _db_dir_exists (*database_path, message);
 231         if (status) {
 232             *database_path = NULL;
 233         }
 234     }
 235
 236     if (*database_path == NULL) {
 237         *message = strdup ("Error: could not locate database.\n");
 238         return NOTMUCH_STATUS_NO_DATABASE;
 239     }
 240
 241     if (*database_path[0] != '/') {
 242         *message = strdup ("Error: Database path must be absolute.\n");
 243         return NOTMUCH_STATUS_PATH_ERROR;
 244     }
 245     return NOTMUCH_STATUS_SUCCESS;
 246 }
 247
 248 static notmuch_database_t *
 249 _alloc_notmuch (const char *database_path, const char *config_path, const char *profile)
 250 {
 251     notmuch_database_t *notmuch;
 252
 253     notmuch = talloc_zero (NULL, notmuch_database_t);
 254     if (! notmuch)
 255         return NULL;
 256
 257     notmuch->exception_reported = false;
 258     notmuch->status_string = NULL;
 259     notmuch->writable_xapian_db = NULL;
 260     notmuch->config_path = NULL;
 261     notmuch->atomic_nesting = 0;
 262     notmuch->transaction_count = 0;
 263     notmuch->transaction_threshold = 0;
 264     notmuch->view = 1;
 265
 266     notmuch->params = NOTMUCH_PARAM_NONE;
 267     if (database_path)
 268         notmuch->params |= NOTMUCH_PARAM_DATABASE;
 269     if (config_path)
 270         notmuch->params |= NOTMUCH_PARAM_CONFIG;
 271     if (profile)
 272         notmuch->params |= NOTMUCH_PARAM_PROFILE;
 273
 274     return notmuch;
 275 }
 276
 277 static notmuch_status_t
 278 _trial_open (const char *xapian_path, char **message_ptr)
 279 {
 280     try {
 281         Xapian::Database db (xapian_path);
 282     } catch (const Xapian::DatabaseOpeningError &error) {
 283         IGNORE_RESULT (asprintf (message_ptr,
 284                                  "Cannot open Xapian database at %s: %s\n",
 285                                  xapian_path,
 286                                  error.get_msg ().c_str ()));
 287         return NOTMUCH_STATUS_PATH_ERROR;
 288     } catch (const Xapian::Error &error) {
 289         IGNORE_RESULT (asprintf (message_ptr,
 290                                  "A Xapian exception occurred opening database: %s\n",
 291                                  error.get_msg ().c_str ()));
 292         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 293     }
 294     return NOTMUCH_STATUS_SUCCESS;
 295 }
 296
 297 notmuch_status_t
 298 _notmuch_choose_xapian_path (void *ctx, const char *database_path,
 299                              const char **xapian_path, char **message_ptr)
 300 {
 301     notmuch_status_t status;
 302     const char *trial_path, *notmuch_path;
 303
 304     status = _db_dir_exists (database_path, message_ptr);
 305     if (status)
 306         goto DONE;
 307
 308     trial_path = talloc_asprintf (ctx, "%s/xapian", database_path);
 309     status = _trial_open (trial_path, message_ptr);
 310     if (status != NOTMUCH_STATUS_PATH_ERROR)
 311         goto DONE;
 312
 313     if (*message_ptr)
 314         free (*message_ptr);
 315
 316     notmuch_path = talloc_asprintf (ctx, "%s/.notmuch", database_path);
 317     status = _db_dir_exists (notmuch_path, message_ptr);
 318     if (status)
 319         goto DONE;
 320
 321     trial_path = talloc_asprintf (ctx, "%s/xapian", notmuch_path);
 322     status = _trial_open (trial_path, message_ptr);
 323
 324   DONE:
 325     if (status == NOTMUCH_STATUS_SUCCESS)
 326         *xapian_path = trial_path;
 327     return status;
 328 }
 329
 330 static void
 331 _set_database_path (notmuch_database_t *notmuch,
 332                     const char *database_path)
 333 {
 334     char *path = talloc_strdup (notmuch, database_path);
 335
 336     strip_trailing (path, '/');
 337
 338     _notmuch_config_cache (notmuch, NOTMUCH_CONFIG_DATABASE_PATH, path);
 339 }
 340
 341 static void
 342 _load_database_state (notmuch_database_t *notmuch)
 343 {
 344     std::string last_thread_id;
 345     std::string last_mod;
 346
 347     notmuch->last_doc_id = notmuch->xapian_db->get_lastdocid ();
 348     last_thread_id = notmuch->xapian_db->get_metadata ("last_thread_id");
 349     if (last_thread_id.empty ()) {
 350         notmuch->last_thread_id = 0;
 351     } else {
 352         const char *str;
 353         char *end;
 354
 355         str = last_thread_id.c_str ();
 356         notmuch->last_thread_id = strtoull (str, &end, 16);
 357         if (*end != '\0')
 358             INTERNAL_ERROR ("Malformed database last_thread_id: %s", str);
 359     }
 360
 361     /* Get current highest revision number. */
 362     last_mod = notmuch->xapian_db->get_value_upper_bound (
 363         NOTMUCH_VALUE_LAST_MOD);
 364     if (last_mod.empty ())
 365         notmuch->revision = 0;
 366     else
 367         notmuch->revision = Xapian::sortable_unserialise (last_mod);
 368     notmuch->uuid = talloc_strdup (
 369         notmuch, notmuch->xapian_db->get_uuid ().c_str ());
 370 }
 371
 372 static notmuch_status_t
 373 _finish_open (notmuch_database_t *notmuch,
 374               const char *profile,
 375               notmuch_database_mode_t mode,
 376               GKeyFile *key_file,
 377               char **message_ptr)
 378 {
 379     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
 380     char *incompat_features;
 381     char *message = NULL;
 382     const char *autocommit_str;
 383     char *autocommit_end;
 384     unsigned int version;
 385     const char *database_path = notmuch_database_get_path (notmuch);
 386
 387     try {
 388
 389         if (mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
 390             notmuch->writable_xapian_db = new Xapian::WritableDatabase (notmuch->xapian_path,
 391                                                                         DB_ACTION);
 392             notmuch->xapian_db = notmuch->writable_xapian_db;
 393         } else {
 394             notmuch->xapian_db = new Xapian::Database (notmuch->xapian_path);
 395         }
 396
 397         /* Check version.  As of database version 3, we represent
 398          * changes in terms of features, so assume a version bump
 399          * means a dramatically incompatible change. */
 400         version = notmuch_database_get_version (notmuch);
 401         if (version > NOTMUCH_DATABASE_VERSION) {
 402             IGNORE_RESULT (asprintf (&message,
 403                                      "Error: Notmuch database at %s\n"
 404                                      "       has a newer database format version (%u) than supported by this\n"
 405                                      "       version of notmuch (%u).\n",
 406                                      database_path, version, NOTMUCH_DATABASE_VERSION));
 407             status = NOTMUCH_STATUS_FILE_ERROR;
 408             goto DONE;
 409         }
 410
 411         /* Check features. */
 412         incompat_features = NULL;
 413         notmuch->features = _notmuch_database_parse_features (
 414             notmuch, notmuch->xapian_db->get_metadata ("features").c_str (),
 415             version, mode == NOTMUCH_DATABASE_MODE_READ_WRITE ? 'w' : 'r',
 416             &incompat_features);
 417         if (incompat_features) {
 418             IGNORE_RESULT (asprintf (&message,
 419                                      "Error: Notmuch database at %s\n"
 420                                      "       requires features (%s)\n"
 421                                      "       not supported by this version of notmuch.\n",
 422                                      database_path, incompat_features));
 423             status = NOTMUCH_STATUS_FILE_ERROR;
 424             goto DONE;
 425         }
 426
 427         _load_database_state (notmuch);
 428
 429         notmuch->query_parser = new Xapian::QueryParser;
 430         notmuch->term_gen = new Xapian::TermGenerator;
 431         notmuch->term_gen->set_stemmer (Xapian::Stem ("english"));
 432         notmuch->value_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_TIMESTAMP);
 433         notmuch->date_range_processor = new ParseTimeRangeProcessor (NOTMUCH_VALUE_TIMESTAMP,
 434                                                                      "date:");
 435         notmuch->last_mod_range_processor = new Xapian::NumberRangeProcessor (NOTMUCH_VALUE_LAST_MOD,
 436                                                                               "lastmod:");
 437         notmuch->query_parser->set_default_op (Xapian::Query::OP_AND);
 438         notmuch->query_parser->set_database (*notmuch->xapian_db);
 439         notmuch->stemmer = new Xapian::Stem ("english");
 440         notmuch->query_parser->set_stemmer (*notmuch->stemmer);
 441         notmuch->query_parser->set_stemming_strategy (Xapian::QueryParser::STEM_SOME);
 442         notmuch->query_parser->add_rangeprocessor (notmuch->value_range_processor);
 443         notmuch->query_parser->add_rangeprocessor (notmuch->date_range_processor);
 444         notmuch->query_parser->add_rangeprocessor (notmuch->last_mod_range_processor);
 445
 446         /* Configuration information is needed to set up query parser */
 447         status = _notmuch_config_load_from_database (notmuch);
 448         if (status)
 449             goto DONE;
 450
 451         if (key_file)
 452             status = _notmuch_config_load_from_file (notmuch, key_file);
 453         if (status)
 454             goto DONE;
 455
 456         status = _choose_dir (notmuch, profile,
 457                               NOTMUCH_CONFIG_HOOK_DIR,
 458                               "XDG_CONFIG_HOME",
 459                               ".config",
 460                               "hooks",
 461                               &message);
 462         if (status)
 463             goto DONE;
 464
 465         status = _choose_dir (notmuch, profile,
 466                               NOTMUCH_CONFIG_BACKUP_DIR,
 467                               "XDG_DATA_HOME",
 468                               ".local/share",
 469                               "backups",
 470                               &message);
 471         if (status)
 472             goto DONE;
 473         status = _notmuch_config_load_defaults (notmuch);
 474         if (status)
 475             goto DONE;
 476
 477         autocommit_str = notmuch_config_get (notmuch, NOTMUCH_CONFIG_AUTOCOMMIT);
 478         if (unlikely (! autocommit_str)) {
 479             INTERNAL_ERROR ("missing configuration for autocommit");
 480         }
 481         notmuch->transaction_threshold = strtoul (autocommit_str, &autocommit_end, 10);
 482         if (*autocommit_end != '\0')
 483             INTERNAL_ERROR ("Malformed database database.autocommit value: %s", autocommit_str);
 484
 485         status = _notmuch_database_setup_standard_query_fields (notmuch);
 486         if (status)
 487             goto DONE;
 488
 489         status = _notmuch_database_setup_user_query_fields (notmuch);
 490         if (status)
 491             goto DONE;
 492
 493     } catch (const Xapian::Error &error) {
 494         IGNORE_RESULT (asprintf (&message, "A Xapian exception occurred opening database: %s\n",
 495                                  error.get_msg ().c_str ()));
 496         status = NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 497     }
 498   DONE:
 499     if (message_ptr)
 500         *message_ptr = message;
 501     return status;
 502 }
 503
 504 notmuch_status_t
 505 notmuch_database_open_with_config (const char *database_path,
 506                                    notmuch_database_mode_t mode,
 507                                    const char *config_path,
 508                                    const char *profile,
 509                                    notmuch_database_t **database,
 510                                    char **status_string)
 511 {
 512     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
 513     notmuch_database_t *notmuch = NULL;
 514     char *message = NULL;
 515     GKeyFile *key_file = NULL;
 516     bool split = false;
 517
 518     _notmuch_init ();
 519
 520     notmuch = _alloc_notmuch (database_path, config_path, profile);
 521     if (! notmuch) {
 522         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
 523         goto DONE;
 524     }
 525
 526     status = _load_key_file (notmuch, config_path, profile, &key_file);
 527     if (status) {
 528         message = strdup ("Error: cannot load config file.\n");
 529         goto DONE;
 530     }
 531
 532     if ((status = _choose_database_path (notmuch, profile, key_file,
 533                                          &database_path, &split,
 534                                          &message)))
 535         goto DONE;
 536
 537     status = _db_dir_exists (database_path, &message);
 538     if (status)
 539         goto DONE;
 540
 541     _set_database_path (notmuch, database_path);
 542
 543     status = _notmuch_choose_xapian_path (notmuch, database_path,
 544                                           &notmuch->xapian_path, &message);
 545     if (status)
 546         goto DONE;
 547
 548     status = _finish_open (notmuch, profile, mode, key_file, &message);
 549
 550   DONE:
 551     if (key_file)
 552         g_key_file_free (key_file);
 553
 554     if (message) {
 555         if (status_string)
 556             *status_string = message;
 557         else
 558             free (message);
 559     }
 560
 561     if (status && notmuch) {
 562         notmuch_database_destroy (notmuch);
 563         notmuch = NULL;
 564     }
 565
 566     if (database)
 567         *database = notmuch;
 568
 569     if (notmuch)
 570         notmuch->open = true;
 571
 572     return status;
 573 }
 574
 575 notmuch_status_t
 576 notmuch_database_create (const char *path, notmuch_database_t **database)
 577 {
 578     char *status_string = NULL;
 579     notmuch_status_t status;
 580
 581     status = notmuch_database_create_verbose (path, database,
 582                                               &status_string);
 583
 584     if (status_string) {
 585         fputs (status_string, stderr);
 586         free (status_string);
 587     }
 588
 589     return status;
 590 }
 591
 592 notmuch_status_t
 593 notmuch_database_create_verbose (const char *path,
 594                                  notmuch_database_t **database,
 595                                  char **status_string)
 596 {
 597     return notmuch_database_create_with_config (path, "", NULL, database, status_string);
 598 }
 599
 600 notmuch_status_t
 601 notmuch_database_create_with_config (const char *database_path,
 602                                      const char *config_path,
 603                                      const char *profile,
 604                                      notmuch_database_t **database,
 605                                      char **status_string)
 606 {
 607     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
 608     notmuch_database_t *notmuch = NULL;
 609     const char *notmuch_path = NULL;
 610     char *message = NULL;
 611     GKeyFile *key_file = NULL;
 612     int err;
 613     bool split = false;
 614
 615     _notmuch_init ();
 616
 617     notmuch = _alloc_notmuch (database_path, config_path, profile);
 618     if (! notmuch) {
 619         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
 620         goto DONE;
 621     }
 622
 623     status = _load_key_file (notmuch, config_path, profile, &key_file);
 624     if (status) {
 625         message = strdup ("Error: cannot load config file.\n");
 626         goto DONE;
 627     }
 628
 629     if ((status = _choose_database_path (notmuch, profile, key_file,
 630                                          &database_path, &split, &message)))
 631         goto DONE;
 632
 633     status = _db_dir_exists (database_path, &message);
 634     if (status)
 635         goto DONE;
 636
 637     _set_database_path (notmuch, database_path);
 638
 639     if (key_file && ! split) {
 640         char *mail_root = notmuch_canonicalize_file_name (
 641             g_key_file_get_string (key_file, "database", "mail_root", NULL));
 642         char *db_path = notmuch_canonicalize_file_name (database_path);
 643
 644         split = (mail_root && (0 != strcmp (mail_root, db_path)));
 645
 646         free (mail_root);
 647         free (db_path);
 648     }
 649
 650     if (split) {
 651         notmuch_path = database_path;
 652     } else {
 653         if (! (notmuch_path = talloc_asprintf (notmuch, "%s/%s", database_path, ".notmuch"))) {
 654             status = NOTMUCH_STATUS_OUT_OF_MEMORY;
 655             goto DONE;
 656         }
 657
 658         err = mkdir (notmuch_path, 0755);
 659         if (err) {
 660             if (errno != EEXIST) {
 661                 IGNORE_RESULT (asprintf (&message, "Error: Cannot create directory %s: %s.\n",
 662                                          notmuch_path, strerror (errno)));
 663                 status = NOTMUCH_STATUS_FILE_ERROR;
 664                 goto DONE;
 665             }
 666         }
 667     }
 668
 669     if (! (notmuch->xapian_path = talloc_asprintf (notmuch, "%s/%s", notmuch_path, "xapian"))) {
 670         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
 671         goto DONE;
 672     }
 673
 674     status = _trial_open (notmuch->xapian_path, &message);
 675     if (status == NOTMUCH_STATUS_SUCCESS) {
 676         notmuch_database_destroy (notmuch);
 677         notmuch = NULL;
 678         status = NOTMUCH_STATUS_DATABASE_EXISTS;
 679         goto DONE;
 680     }
 681
 682     if (message)
 683         free (message);
 684
 685     status = _finish_open (notmuch,
 686                            profile,
 687                            NOTMUCH_DATABASE_MODE_READ_WRITE,
 688                            key_file,
 689                            &message);
 690     if (status)
 691         goto DONE;
 692
 693     /* Upgrade doesn't add these feature to existing databases, but
 694      * new databases have them. */
 695     notmuch->features |= NOTMUCH_FEATURE_FROM_SUBJECT_ID_VALUES;
 696     notmuch->features |= NOTMUCH_FEATURE_INDEXED_MIMETYPES;
 697     notmuch->features |= NOTMUCH_FEATURE_UNPREFIX_BODY_ONLY;
 698
 699     status = notmuch_database_upgrade (notmuch, NULL, NULL);
 700     if (status) {
 701         notmuch_database_close (notmuch);
 702         notmuch = NULL;
 703     }
 704
 705   DONE:
 706     if (key_file)
 707         g_key_file_free (key_file);
 708
 709     if (message) {
 710         if (status_string)
 711             *status_string = message;
 712         else
 713             free (message);
 714     }
 715     if (status && notmuch) {
 716         notmuch_database_destroy (notmuch);
 717         notmuch = NULL;
 718     }
 719
 720     if (database)
 721         *database = notmuch;
 722
 723     if (notmuch)
 724         notmuch->open = true;
 725     return status;
 726 }
 727
 728 notmuch_status_t
 729 notmuch_database_reopen (notmuch_database_t *notmuch,
 730                          notmuch_database_mode_t new_mode)
 731 {
 732     notmuch_database_mode_t cur_mode = _notmuch_database_mode (notmuch);
 733
 734     if (notmuch->xapian_db == NULL) {
 735         _notmuch_database_log (notmuch, "Cannot reopen closed or nonexistent database\n");
 736         return NOTMUCH_STATUS_ILLEGAL_ARGUMENT;
 737     }
 738
 739     try {
 740         if (cur_mode == new_mode &&
 741             new_mode == NOTMUCH_DATABASE_MODE_READ_ONLY) {
 742             notmuch->xapian_db->reopen ();
 743         } else {
 744             notmuch->xapian_db->close ();
 745
 746             delete notmuch->xapian_db;
 747             notmuch->xapian_db = NULL;
 748             /* no need to free the same object twice */
 749             notmuch->writable_xapian_db = NULL;
 750
 751             if (new_mode == NOTMUCH_DATABASE_MODE_READ_WRITE) {
 752                 notmuch->writable_xapian_db = new Xapian::WritableDatabase (notmuch->xapian_path,
 753                                                                             DB_ACTION);
 754                 notmuch->xapian_db = notmuch->writable_xapian_db;
 755             } else {
 756                 notmuch->xapian_db = new Xapian::Database (notmuch->xapian_path,
 757                                                            DB_ACTION);
 758             }
 759         }
 760
 761         _load_database_state (notmuch);
 762     } catch (const Xapian::Error &error) {
 763         if (! notmuch->exception_reported) {
 764             _notmuch_database_log (notmuch, "Error: A Xapian exception reopening database: %s\n",
 765                                    error.get_msg ().c_str ());
 766             notmuch->exception_reported = true;
 767         }
 768         return NOTMUCH_STATUS_XAPIAN_EXCEPTION;
 769     }
 770
 771     notmuch->view++;
 772     notmuch->open = true;
 773     return NOTMUCH_STATUS_SUCCESS;
 774 }
 775
 776 static notmuch_status_t
 777 _maybe_load_config_from_database (notmuch_database_t *notmuch,
 778                                   GKeyFile *key_file,
 779                                   const char *database_path,
 780                                   const char *profile)
 781 {
 782     char *message; /* ignored */
 783
 784     if (_db_dir_exists (database_path, &message))
 785         return NOTMUCH_STATUS_NO_DATABASE;
 786
 787     _set_database_path (notmuch, database_path);
 788
 789     if (_notmuch_choose_xapian_path (notmuch, database_path, &notmuch->xapian_path, &message))
 790         return NOTMUCH_STATUS_NO_DATABASE;
 791
 792     (void) _finish_open (notmuch, profile, NOTMUCH_DATABASE_MODE_READ_ONLY, key_file, &message);
 793
 794     return NOTMUCH_STATUS_SUCCESS;
 795 }
 796
 797 notmuch_status_t
 798 notmuch_database_load_config (const char *database_path,
 799                               const char *config_path,
 800                               const char *profile,
 801                               notmuch_database_t **database,
 802                               char **status_string)
 803 {
 804     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS, warning = NOTMUCH_STATUS_SUCCESS;
 805     notmuch_database_t *notmuch = NULL;
 806     char *message = NULL;
 807     GKeyFile *key_file = NULL;
 808     bool split = false;
 809
 810     _notmuch_init ();
 811
 812     notmuch = _alloc_notmuch (database_path, config_path, profile);
 813     if (! notmuch) {
 814         status = NOTMUCH_STATUS_OUT_OF_MEMORY;
 815         goto DONE;
 816     }
 817
 818     status = _load_key_file (notmuch, config_path, profile, &key_file);
 819     switch (status) {
 820     case NOTMUCH_STATUS_SUCCESS:
 821         break;
 822     case NOTMUCH_STATUS_NO_CONFIG:
 823         warning = status;
 824         break;
 825     default:
 826         message = strdup ("Error: cannot load config file.\n");
 827         goto DONE;
 828     }
 829
 830     status = _choose_database_path (notmuch, profile, key_file,
 831                                     &database_path, &split, &message);
 832     switch (status) {
 833     case NOTMUCH_STATUS_NO_DATABASE:
 834     case NOTMUCH_STATUS_SUCCESS:
 835         if (! warning)
 836             warning = status;
 837         break;
 838     default:
 839         goto DONE;
 840     }
 841
 842
 843     if (database_path) {
 844         status = _maybe_load_config_from_database (notmuch, key_file, database_path, profile);
 845         switch (status) {
 846         case NOTMUCH_STATUS_NO_DATABASE:
 847         case NOTMUCH_STATUS_SUCCESS:
 848             if (! warning)
 849                 warning = status;
 850             break;
 851         default:
 852             goto DONE;
 853         }
 854     }
 855
 856     if (key_file) {
 857         status = _notmuch_config_load_from_file (notmuch, key_file);
 858         if (status)
 859             goto DONE;
 860     }
 861     status = _notmuch_config_load_defaults (notmuch);
 862     if (status)
 863         goto DONE;
 864
 865   DONE:
 866     if (status_string)
 867         *status_string = message;
 868
 869     if (status &&
 870         status != NOTMUCH_STATUS_NO_DATABASE
 871         && status != NOTMUCH_STATUS_NO_CONFIG) {
 872         notmuch_database_destroy (notmuch);
 873         notmuch = NULL;
 874     }
 875
 876     if (database)
 877         *database = notmuch;
 878
 879     if (status)
 880         return status;
 881     else
 882         return warning;
 883 }