git.notmuchmail.org Git - notmuch/blob - notmuch-config.c

   1 /* notmuch - Not much of an email program, (just index and search)
   2  *
   3  * Copyright © 2009 Carl Worth
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see http://www.gnu.org/licenses/ .
  17  *
  18  * Author: Carl Worth <cworth@cworth.org>
  19  */
  20
  21 #include "notmuch-client.h"
  22
  23 #include <pwd.h>
  24 #include <netdb.h>
  25
  26 static const char toplevel_config_comment[] =
  27     " .notmuch-config - Configuration file for the notmuch mail system\n"
  28     "\n"
  29     " For more information about notmuch, see http://notmuchmail.org";
  30
  31 static const char database_config_comment[] =
  32     " Database configuration\n"
  33     "\n"
  34     " The only value supported here is 'path' which should be the top-level\n"
  35     " directory where your mail currently exists and to where mail will be\n"
  36     " delivered in the future. Files should be individual email messages.\n"
  37     " Notmuch will store its database within a sub-directory of the path\n"
  38     " configured here named \".notmuch\".\n";
  39
  40 static const char user_config_comment[] =
  41     " User configuration\n"
  42     "\n"
  43     " Here is where you can let notmuch know how you would like to be\n"
  44     " addressed. Valid settings are\n"
  45     "\n"
  46     "\tname             Your full name.\n"
  47     "\tprimary_email    Your primary email address.\n"
  48     "\tother_email      A list (separated by ';') of other email addresses\n"
  49     "\t         at which you receive email.\n"
  50     "\n"
  51     " Notmuch will use the various email addresses configured here when\n"
  52     " formatting replies. It will avoid including your own addresses in the\n"
  53     " recipient list of replies, and will set the From address based on the\n"
  54     " address to which the original email was addressed.\n";
  55
  56 struct _notmuch_config {
  57     char *filename;
  58     GKeyFile *key_file;
  59
  60     char *database_path;
  61     char *user_name;
  62     char *user_primary_email;
  63     char **user_other_email;
  64     size_t user_other_email_length;
  65 };
  66
  67 static int
  68 notmuch_config_destructor (notmuch_config_t *config)
  69 {
  70     if (config->key_file)
  71         g_key_file_free (config->key_file);
  72
  73     return 0;
  74 }
  75
  76 static char *
  77 get_name_from_passwd_file (void *ctx)
  78 {
  79     long pw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
  80     char *pw_buf = talloc_zero_size (ctx, pw_buf_size);
  81     struct passwd passwd, *ignored;
  82     char *name;
  83
  84     if (getpwuid_r (getuid (), &passwd, pw_buf, pw_buf_size, &ignored) == 0) {
  85         char *comma = strchr (passwd.pw_gecos, ',');
  86         if (comma)
  87             name = talloc_strndup (ctx, passwd.pw_gecos,
  88                                    comma - passwd.pw_gecos);
  89         else
  90             name = talloc_strdup (ctx, passwd.pw_gecos);
  91     } else {
  92         name = talloc_strdup (ctx, "");
  93     }
  94
  95     talloc_free (pw_buf);
  96
  97     return name;
  98 }
  99
 100 static char *
 101 get_username_from_passwd_file (void *ctx)
 102 {
 103     long pw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
 104     char *pw_buf = talloc_zero_size (ctx, pw_buf_size);
 105     struct passwd passwd, *ignored;
 106     char *name;
 107
 108     if (getpwuid_r (getuid (), &passwd, pw_buf, pw_buf_size, &ignored) == 0)
 109         name = talloc_strdup (ctx, passwd.pw_name);
 110     else
 111         name = talloc_strdup (ctx, "");
 112
 113     talloc_free (pw_buf);
 114
 115     return name;
 116 }
 117
 118 /* Open the named notmuch configuration file. A filename of NULL will
 119  * be interpreted as the default configuration file
 120  * ($HOME/.notmuch-config).
 121  *
 122  * If any error occurs, (out of memory, or a permission-denied error,
 123  * etc.), this function will print a message to stderr and return
 124  * NULL.
 125  *
 126  * Note: It is *not* an error if the specified configuration file does
 127  * not exist. In this case, a default configuration will be created
 128  * and returned. Subsequently calling notmuch_config_save will cause
 129  * the configuration to be written to the filename specified at the
 130  * time of notmuch_config_open.
 131  *
 132  * The default configuration settings are determined as follows:
 133  *
 134  *      database_path:          $HOME/mail
 135  *
 136  *      user_name:              From /etc/passwd
 137  *
 138  *      user_primary_mail:      $EMAIL variable if set, otherwise
 139  *                              constructed from the username and
 140  *                              hostname of the current machine.
 141  *
 142  *      user_other_email:       Not set.
 143  *
 144  * The default configuration also contains comments to guide the user
 145  * in editing the file directly.
 146  */
 147 notmuch_config_t *
 148 notmuch_config_open (void *ctx, const char *filename)
 149 {
 150     GError *error = NULL;
 151     int config_file_is_new = 0;
 152
 153     notmuch_config_t *config = talloc (ctx, notmuch_config_t);
 154     if (config == NULL) {
 155         fprintf (stderr, "Out of memory.\n");
 156         return NULL;
 157     }
 158
 159     talloc_set_destructor (config, notmuch_config_destructor);
 160
 161     if (filename)
 162         config->filename = talloc_strdup (config, filename);
 163     else
 164         config->filename = talloc_asprintf (config, "%s/.notmuch-config",
 165                                             getenv ("HOME"));
 166
 167     config->key_file = g_key_file_new ();
 168
 169     config->database_path = NULL;
 170     config->user_name = NULL;
 171     config->user_primary_email = NULL;
 172     config->user_other_email = NULL;
 173     config->user_other_email_length = 0;
 174
 175     if (! g_key_file_load_from_file (config->key_file,
 176                                      config->filename,
 177                                      G_KEY_FILE_KEEP_COMMENTS,
 178                                      &error))
 179     {
 180         /* We are capable of dealing with a non-existent configuration
 181          * file, so be silent about that. */
 182         if (!(error->domain == G_FILE_ERROR &&
 183               error->code == G_FILE_ERROR_NOENT))
 184         {
 185             fprintf (stderr, "Error reading configuration file %s: %s\n",
 186                      config->filename, error->message);
 187             talloc_free (config);
 188             return NULL;
 189         }
 190
 191         config_file_is_new = 1;
 192     }
 193
 194     if (notmuch_config_get_database_path (config) == NULL) {
 195         char *path = talloc_asprintf (config, "%s/mail",
 196                                       getenv ("HOME"));
 197         notmuch_config_set_database_path (config, path);
 198         talloc_free (path);
 199     }
 200
 201     if (notmuch_config_get_user_name (config) == NULL) {
 202         char *name = get_name_from_passwd_file (config);
 203         notmuch_config_set_user_name (config, name);
 204         talloc_free (name);
 205     }
 206
 207     if (notmuch_config_get_user_primary_email (config) == NULL) {
 208         char *email = getenv ("EMAIL");
 209         if (email) {
 210             notmuch_config_set_user_primary_email (config, email);
 211         } else {
 212             char hostname[256];
 213             struct hostent *hostent;
 214             const char *domainname;
 215
 216             char *username = get_username_from_passwd_file (config);
 217
 218             gethostname (hostname, 256);
 219             hostname[255] = '\0';
 220
 221             hostent = gethostbyname (hostname);
 222             if (hostent && (domainname = strchr (hostent->h_name, '.')))
 223                 domainname += 1;
 224             else
 225                 domainname = "(none)";
 226
 227             email = talloc_asprintf (config, "%s@%s.%s",
 228                                      username, hostname, domainname);
 229
 230             notmuch_config_set_user_primary_email (config, email);
 231
 232             talloc_free (username);
 233             talloc_free (email);
 234         }
 235     }
 236
 237     /* When we create a new configuration file here, we  add some
 238      * comments to help the user understand what can be done. */
 239     if (config_file_is_new) {
 240         g_key_file_set_comment (config->key_file, NULL, NULL,
 241                                 toplevel_config_comment, NULL);
 242         g_key_file_set_comment (config->key_file, "database", NULL,
 243                                 database_config_comment, NULL);
 244         g_key_file_set_comment (config->key_file, "user", NULL,
 245                                 user_config_comment, NULL);
 246     }
 247
 248     return config;
 249 }
 250
 251 /* Close the given notmuch_config_t object, freeing all resources.
 252  *
 253  * Note: Any changes made to the configuration are *not* saved by this
 254  * function. To save changes, call notmuch_config_save before
 255  * notmuch_config_close.
 256 */
 257 void
 258 notmuch_config_close (notmuch_config_t *config)
 259 {
 260     talloc_free (config);
 261 }
 262
 263 /* Save any changes made to the notmuch configuration.
 264  *
 265  * Any comments originally in the file will be preserved.
 266  *
 267  * Returns 0 if successful, and 1 in case of any error, (after
 268  * printing a description of the error to stderr).
 269  */
 270 int
 271 notmuch_config_save (notmuch_config_t *config)
 272 {
 273     size_t length;
 274     char *data;
 275     GError *error = NULL;
 276
 277     data = g_key_file_to_data (config->key_file, &length, NULL);
 278     if (data == NULL) {
 279         fprintf (stderr, "Out of memory.\n");
 280         return 1;
 281     }
 282
 283     if (! g_file_set_contents (config->filename, data, length, &error)) {
 284         fprintf (stderr, "Error saving configuration to %s: %s\n",
 285                  config->filename, error->message);
 286         return 1;
 287     }
 288
 289     return 0;
 290 }
 291
 292 const char *
 293 notmuch_config_get_database_path (notmuch_config_t *config)
 294 {
 295     char *path;
 296
 297     if (config->database_path == NULL) {
 298         path = g_key_file_get_string (config->key_file,
 299                                       "database", "path", NULL);
 300         if (path) {
 301             config->database_path = talloc_strdup (config, path);
 302             free (path);
 303         }
 304     }
 305
 306     return config->database_path;
 307 }
 308
 309 void
 310 notmuch_config_set_database_path (notmuch_config_t *config,
 311                                   const char *database_path)
 312 {
 313     g_key_file_set_string (config->key_file,
 314                            "database", "path", database_path);
 315
 316     talloc_free (config->database_path);
 317     config->database_path = NULL;
 318 }
 319
 320 const char *
 321 notmuch_config_get_user_name (notmuch_config_t *config)
 322 {
 323     char *name;
 324
 325     if (config->user_name == NULL) {
 326         name = g_key_file_get_string (config->key_file,
 327                                       "user", "name", NULL);
 328         if (name) {
 329             config->user_name = talloc_strdup (config, name);
 330             free (name);
 331         }
 332     }
 333
 334     return config->user_name;
 335 }
 336
 337 void
 338 notmuch_config_set_user_name (notmuch_config_t *config,
 339                               const char *user_name)
 340 {
 341     g_key_file_set_string (config->key_file,
 342                            "user", "name", user_name);
 343
 344     talloc_free (config->user_name);
 345     config->user_name = NULL;
 346 }
 347
 348 const char *
 349 notmuch_config_get_user_primary_email (notmuch_config_t *config)
 350 {
 351     char *email;
 352
 353     if (config->user_primary_email == NULL) {
 354         email = g_key_file_get_string (config->key_file,
 355                                        "user", "primary_email", NULL);
 356         if (email) {
 357             config->user_primary_email = talloc_strdup (config, email);
 358             free (email);
 359         }
 360     }
 361
 362     return config->user_primary_email;
 363 }
 364
 365 void
 366 notmuch_config_set_user_primary_email (notmuch_config_t *config,
 367                                        const char *primary_email)
 368 {
 369     g_key_file_set_string (config->key_file,
 370                            "user", "primary_email", primary_email);
 371
 372     talloc_free (config->user_primary_email);
 373     config->user_primary_email = NULL;
 374 }
 375
 376 char **
 377 notmuch_config_get_user_other_email (notmuch_config_t *config,
 378                                      size_t *length)
 379 {
 380     char **emails;
 381     size_t emails_length;
 382     unsigned int i;
 383
 384     if (config->user_other_email == NULL) {
 385         emails = g_key_file_get_string_list (config->key_file,
 386                                              "user", "other_email",
 387                                              &emails_length, NULL);
 388         if (emails) {
 389             config->user_other_email = talloc_size (config,
 390                                                     sizeof (char *) *
 391                                                     (emails_length + 1));
 392             for (i = 0; i < emails_length; i++)
 393                 config->user_other_email[i] = talloc_strdup (config->user_other_email,
 394                                                              emails[i]);
 395             config->user_other_email[i] = NULL;
 396
 397             g_strfreev (emails);
 398
 399             config->user_other_email_length = emails_length;
 400         }
 401     }
 402
 403     *length = config->user_other_email_length;
 404     return config->user_other_email;
 405 }
 406
 407 void
 408 notmuch_config_set_user_other_email (notmuch_config_t *config,
 409                                      const char *other_email[],
 410                                      size_t length)
 411 {
 412     g_key_file_set_string_list (config->key_file,
 413                                 "user", "other_email",
 414                                 other_email, length);
 415
 416     talloc_free (config->user_other_email);
 417     config->user_other_email = NULL;
 418 }