conf: throw on error
[ncmpc-debian.git] / src / conf.cxx
1 /* ncmpc (Ncurses MPD Client)
2  * (c) 2004-2019 The Music Player Daemon Project
3  * Project homepage: http://musicpd.org
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 2 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 along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  */
19
20 #include "conf.hxx"
21 #include "config.h"
22 #include "Bindings.hxx"
23 #include "GlobalBindings.hxx"
24 #include "defaults.hxx"
25 #include "i18n.h"
26 #include "Command.hxx"
27 #include "Styles.hxx"
28 #include "BasicColors.hxx"
29 #include "CustomColors.hxx"
30 #include "screen_list.hxx"
31 #include "PageMeta.hxx"
32 #include "Options.hxx"
33 #include "io/Path.hxx"
34 #include "util/CharUtil.hxx"
35 #include "util/PrintException.hxx"
36 #include "util/RuntimeError.hxx"
37 #include "util/StringStrip.hxx"
38
39 #include <assert.h>
40 #include <sys/stat.h>
41 #include <ctype.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45
46 #ifdef _WIN32
47 #include <glib.h>
48 #endif
49
50 #define MAX_LINE_LENGTH 1024
51 #define COMMENT_TOKEN '#'
52
53 /* configuration field names */
54 #define CONF_ENABLE_COLORS "enable-colors"
55 #define CONF_SCROLL_OFFSET "scroll-offset"
56 #define CONF_AUTO_CENTER "auto-center"
57 #define CONF_WIDE_CURSOR "wide-cursor"
58 #define CONF_KEY_DEFINITION "key"
59 #define CONF_COLOR "color"
60 #define CONF_COLOR_DEFINITION "colordef"
61 #define CONF_LIST_FORMAT "list-format"
62 #define CONF_SEARCH_FORMAT "search-format"
63 #define CONF_STATUS_FORMAT "status-format"
64 #define CONF_XTERM_TITLE_FORMAT "xterm-title-format"
65 #define CONF_LIST_WRAP "wrap-around"
66 #define CONF_FIND_WRAP "find-wrap"
67 #define CONF_FIND_SHOW_LAST "find-show-last"
68 #define CONF_AUDIBLE_BELL "audible-bell"
69 #define CONF_VISIBLE_BELL "visible-bell"
70 #define CONF_BELL_ON_WRAP "bell-on-wrap"
71 #define CONF_STATUS_MESSAGE_TIME "status-message-time"
72 #define CONF_XTERM_TITLE "set-xterm-title"
73 #define CONF_ENABLE_MOUSE "enable-mouse"
74 #define CONF_CROSSFADE_TIME "crossfade-time"
75 #define CONF_SEARCH_MODE "search-mode"
76 #define CONF_HIDE_CURSOR "hide-cursor"
77 #define CONF_SEEK_TIME "seek-time"
78 #define CONF_LIBRARY_PAGE_TAGS "library-page-tags"
79 #define CONF_SCREEN_LIST "screen-list"
80 #define CONF_TIMEDISPLAY_TYPE "timedisplay-type"
81 #define CONF_HOST "host"
82 #define CONF_PORT "port"
83 #define CONF_PASSWORD "password"
84 #define CONF_TIMEOUT "timeout"
85 #define CONF_LYRICS_TIMEOUT "lyrics-timeout"
86 #define CONF_SCROLL "scroll"
87 #define CONF_SCROLL_SEP "scroll-sep"
88 #define CONF_VISIBLE_BITRATE "visible-bitrate"
89 #define CONF_HARDWARE_CURSOR "hardware-cursor"
90 #define CONF_WELCOME_SCREEN_LIST "welcome-screen-list"
91 #define CONF_DISPLAY_TIME "display-time"
92 #define CONF_JUMP_PREFIX_ONLY "jump-prefix-only"
93 #define CONF_LYRICS_AUTOSAVE "lyrics-autosave"
94 #define CONF_LYRICS_SHOW_PLUGIN "lyrics-show-plugin"
95 #define CONF_TEXT_EDITOR "text-editor"
96 #define CONF_TEXT_EDITOR_ASK "text-editor-ask"
97 #define CONF_CHAT_PREFIX "chat-prefix"
98 #define CONF_SECOND_COLUMN "second-column"
99
100 #ifdef _WIN32
101 #define CONFIG_FILENAME "ncmpc.conf"
102 #define KEYS_FILENAME "keys.conf"
103 #else
104 #define CONFIG_FILENAME "config"
105 #define KEYS_FILENAME "keys"
106 #endif
107
108 gcc_pure
109 static bool
110 str2bool(char *str) noexcept
111 {
112         return strcasecmp(str, "yes") == 0 || strcasecmp(str, "true") == 0 ||
113                 strcasecmp(str, "on") == 0 || strcasecmp(str, "1") == 0;
114 }
115
116 static constexpr bool
117 is_word_char(char ch) noexcept
118 {
119         return IsAlphaNumericASCII(ch) || ch == '-' || ch == '_';
120 }
121
122 static char *
123 after_unquoted_word(char *p)
124 {
125         if (!is_word_char(*p))
126                 throw FormatRuntimeError("%s: %s",
127                                          _("Word expected"), p);
128
129         ++p;
130
131         while (is_word_char(*p))
132                 ++p;
133
134         return p;
135 }
136
137 /**
138  * Throws on error.
139  */
140 static int
141 parse_key_value(char *str, char **end)
142 {
143         if (*str == '\'') {
144                 if (str[1] == '\\' && str[2] == '\'' && str[3] == '\'') {
145                         /* the single quote can be escaped with a
146                            backslash */
147                         *end = str + 4;
148                         return str[2];
149                 }
150
151                 if (str[1] == '\'' || str[2] != '\'')
152                         throw FormatRuntimeError("%s: %s",
153                                                  _("Malformed hotkey definition"),
154                                                  str);
155
156                 *end = str + 3;
157                 return str[1];
158         } else {
159                 long value = strtol(str, end, 0);
160                 if (*end == str)
161                         throw FormatRuntimeError("%s: %s",
162                                                  _("Malformed hotkey definition"),
163                                                  str);
164
165                 return (int)value;
166         }
167 }
168
169 /**
170  * Throws on error.
171  */
172 static void
173 parse_key_definition(char *str)
174 {
175         /* get the command name */
176         char *eq = strchr(str, '=');
177         if (eq == nullptr)
178                 /* the hotkey configuration line is incomplete */
179                 throw FormatRuntimeError("%s: %s",
180                                          _("Incomplete hotkey configuration"),
181                                          str);
182
183         char *command_name = str;
184         str = StripLeft(eq + 1);
185
186         *eq = '\0';
187         StripRight(command_name);
188         const auto cmd = get_key_command_from_name(command_name);
189         if (cmd == Command::NONE)
190                 /* the hotkey configuration contains an unknown
191                    command */
192                 throw FormatRuntimeError("%s: %s",
193                                          _("Unknown command"), command_name);
194
195         /* parse key values */
196         size_t i = 0;
197         char *p = str;
198
199         std::array<int, MAX_COMMAND_KEYS> keys{0};
200         while (i < MAX_COMMAND_KEYS && *p != 0) {
201                 keys[i++] = parse_key_value(p, &p);
202                 while (*p==',' || *p==' ' || *p=='\t')
203                         p++;
204         }
205
206         GetGlobalKeyBindings().SetKey(cmd, keys);
207 }
208
209 /**
210  * Throws on error.
211  */
212 static bool
213 parse_timedisplay_type(const char *str)
214 {
215         if (strcmp(str, "elapsed") == 0)
216                 return false;
217         else if (strcmp(str, "remaining") == 0)
218                 return true;
219         else {
220                 /* translators: ncmpc supports displaying the
221                    "elapsed" or "remaining" time of a song being
222                    played; in this case, the configuration file
223                    contained an invalid setting */
224                 throw FormatRuntimeError("%s: %s",
225                                          _("Bad time display type"), str);
226                 return false;
227         }
228 }
229
230 #ifdef ENABLE_COLORS
231 /**
232  * Throws on error.
233  */
234 static char *
235 separate_value(char *p)
236 {
237         char *value = strchr(p, '=');
238         if (value == nullptr)
239                 /* an equals sign '=' was expected while parsing a
240                    configuration file line */
241                 throw std::runtime_error(_("Missing '='"));
242
243         *StripRight(p, value++) = '\0';
244
245         return Strip(value);
246 }
247
248 /**
249  * Throws on error.
250  */
251 static void
252 parse_color(char *str)
253 {
254         char *value = separate_value(str);
255         ModifyStyle(str, value);
256 }
257
258 /**
259  * Returns the first non-whitespace character after the next comma
260  * character, or the end of the string.  This is used to parse comma
261  * separated values.
262  */
263 static char *
264 after_comma(char *p) noexcept
265 {
266         char *comma = strchr(p, ',');
267
268         if (comma != nullptr) {
269                 *comma++ = 0;
270                 comma = StripLeft(comma);
271         } else
272                 comma = p + strlen(p);
273
274         StripRight(p);
275         return comma;
276 }
277
278 /**
279  * Throws on error.
280  */
281 static void
282 parse_color_definition(char *str)
283 {
284         char *value = separate_value(str);
285
286         /* get the command name */
287         short color = ParseColorNameOrNumber(str);
288         if (color < 0)
289                 throw FormatRuntimeError("%s: %s",
290                                          _("Bad color name"), str);
291
292         /* parse r,g,b values */
293
294         short rgb[3];
295         for (unsigned i = 0; i < 3; ++i) {
296                 char *next = after_comma(value), *endptr;
297                 if (*value == 0)
298                         throw FormatRuntimeError("%s: %s",
299                                                  _("Incomplete color definition"),
300                                                  str);
301
302                 rgb[i] = strtol(value, &endptr, 0);
303                 if (endptr == value || *endptr != 0)
304                         throw FormatRuntimeError("%s: %s",
305                                                  _("Invalid number"), value);
306
307                 value = next;
308         }
309
310         if (*value != 0)
311                 throw FormatRuntimeError("%s: %s",
312                                          _("Malformed color definition"), str);
313
314         colors_define(color, rgb[0], rgb[1], rgb[2]);
315 }
316 #endif
317
318 static std::string
319 GetStringValue(const char *s) noexcept
320 {
321         size_t length = strlen(s);
322
323         if (s[0] == '\"' && s[length - 1] == '\"') {
324                 length -= 2;
325                 ++s;
326         }
327
328         return {s, length};
329 }
330
331 static constexpr bool
332 IsListSeparator(char ch) noexcept
333 {
334         return IsWhitespaceFast(ch) || ch == ',';
335 }
336
337 static char *
338 NextItem(char *&src) noexcept
339 {
340         while (*src && IsListSeparator(*src))
341                 ++src;
342
343         if (!*src)
344                 return nullptr;
345
346         char *value = src;
347
348         while (!IsListSeparator(*src))
349                 ++src;
350
351         if (*src)
352                 *src++ = 0;
353
354         return value;
355 }
356
357 /**
358  * Throws on error.
359  */
360 static std::vector<std::string>
361 check_screen_list(char *value)
362 {
363         std::vector<std::string> screen;
364
365         while (char *name = NextItem(value)) {
366                 std::transform(name, name + strlen(name), name, tolower);
367
368                 const auto *page_meta = screen_lookup_name(name);
369                 if (page_meta == nullptr)
370                         /* an unknown screen name was specified in the
371                            configuration file */
372                         throw FormatRuntimeError("%s: %s",
373                                                  _("Unknown screen name"),
374                                                  name);
375
376                 /* use PageMeta::name because
377                    screen_lookup_name() may have translated a
378                    deprecated name */
379                 screen.emplace_back(page_meta->name);
380         }
381
382         if (screen.empty())
383                 screen = DEFAULT_SCREEN_LIST;
384
385         return screen;
386 }
387
388 #ifdef ENABLE_LIBRARY_PAGE
389
390 /**
391  * Throws on error.
392  */
393 static auto
394 ParseTagList(char *value)
395 {
396         std::vector<enum mpd_tag_type> result;
397
398         while (char *name = NextItem(value)) {
399                 auto type = mpd_tag_name_iparse(name);
400                 if (type == MPD_TAG_UNKNOWN)
401                         throw FormatRuntimeError("%s: %s",
402                                                  _("Unknown MPD tag"), name);
403
404                 result.emplace_back(type);
405         }
406
407         if (result.empty())
408                 throw std::runtime_error("Empty tag list");
409
410         return result;
411 }
412
413 #endif
414
415 /**
416  * Throws on error.
417  */
418 static int
419 get_search_mode(char *value)
420 {
421         char * test;
422         const int mode = strtol(value, &test, 10);
423         if (*test == '\0')
424         {
425                 if (0 <= mode && mode <= 4)
426                         return mode;
427                 else
428                         throw FormatRuntimeError("%s: %s",
429                                                  _("Invalid search mode"),value);
430         }
431         else
432         {
433                 // TODO: modify screen_search so that its own list of modes can be used
434                 // for comparison instead of specifying them here
435                 if (strcasecmp(value, "title") == 0)
436                         return 0;
437                 else if (strcasecmp(value, "artist") == 0)
438                         return 1;
439                 else if (strcasecmp(value, "album") == 0)
440                         return 2;
441                 else if (strcasecmp(value, "filename") == 0)
442                         return 3;
443                 else if (strcasecmp(value, "artist+album") == 0)
444                         return 4;
445                 else
446                         throw FormatRuntimeError("%s: %s",
447                                                  _("Unknown search mode"),
448                                                  value);
449         }
450 }
451
452 /**
453  * Throws on error.
454  */
455 static void
456 parse_line(char *line)
457 {
458         /* get the name part */
459         char *const name = line;
460         char *const name_end = after_unquoted_word(line);
461
462         line = StripLeft(name_end);
463         if (*line == '=') {
464                 ++line;
465                 line = StripLeft(line);
466         } else if (line == name_end) {
467                 throw FormatRuntimeError("%s: %s",
468                                          _("Missing '='"), name_end);
469         }
470
471         *name_end = 0;
472
473         /* get the value part */
474         char *const value = line;
475
476         /* key definition */
477         if (!strcasecmp(CONF_KEY_DEFINITION, name))
478                 parse_key_definition(value);
479         /* enable colors */
480         else if(!strcasecmp(CONF_ENABLE_COLORS, name))
481 #ifdef ENABLE_COLORS
482                 options.enable_colors = str2bool(value);
483 #else
484         {}
485 #endif
486         else if (!strcasecmp(CONF_SCROLL_OFFSET, name))
487                 options.scroll_offset = atoi(value);
488         /* auto center */
489         else if (!strcasecmp(CONF_AUTO_CENTER, name))
490                 options.auto_center = str2bool(value);
491         /* color assignment */
492         else if (!strcasecmp(CONF_COLOR, name))
493 #ifdef ENABLE_COLORS
494                 parse_color(value);
495 #else
496         {}
497 #endif
498         /* wide cursor */
499         else if (!strcasecmp(CONF_WIDE_CURSOR, name))
500                 options.wide_cursor = str2bool(value);
501         else if (strcasecmp(name, CONF_HARDWARE_CURSOR) == 0)
502                 options.hardware_cursor = str2bool(value);
503         /* welcome screen list */
504         else if (!strcasecmp(CONF_WELCOME_SCREEN_LIST, name))
505                 options.welcome_screen_list = str2bool(value);
506         /* visible bitrate */
507         else if (!strcasecmp(CONF_VISIBLE_BITRATE, name))
508                 options.visible_bitrate = str2bool(value);
509         /* timer display type */
510         else if (!strcasecmp(CONF_TIMEDISPLAY_TYPE, name))
511                 options.display_remaining_time = parse_timedisplay_type(value);
512                 /* color definition */
513         else if (!strcasecmp(CONF_COLOR_DEFINITION, name))
514 #ifdef ENABLE_COLORS
515                 parse_color_definition(value);
516 #else
517         {}
518 #endif
519         /* list format string */
520         else if (!strcasecmp(CONF_LIST_FORMAT, name)) {
521                 options.list_format = GetStringValue(value);
522                 /* search format string */
523         } else if (!strcasecmp(CONF_SEARCH_FORMAT, name)) {
524                 options.search_format = GetStringValue(value);
525                 /* status format string */
526         } else if (!strcasecmp(CONF_STATUS_FORMAT, name)) {
527                 options.status_format = GetStringValue(value);
528                 /* xterm title format string */
529         } else if (!strcasecmp(CONF_XTERM_TITLE_FORMAT, name)) {
530                 options.xterm_title_format = GetStringValue(value);
531         } else if (!strcasecmp(CONF_LIST_WRAP, name))
532                 options.list_wrap = str2bool(value);
533         else if (!strcasecmp(CONF_FIND_WRAP, name))
534                 options.find_wrap = str2bool(value);
535         else if (!strcasecmp(CONF_FIND_SHOW_LAST,name))
536                 options.find_show_last_pattern = str2bool(value);
537         else if (!strcasecmp(CONF_AUDIBLE_BELL, name))
538                 options.audible_bell = str2bool(value);
539         else if (!strcasecmp(CONF_VISIBLE_BELL, name))
540                 options.visible_bell = str2bool(value);
541         else if (!strcasecmp(CONF_BELL_ON_WRAP, name))
542                 options.bell_on_wrap = str2bool(value);
543         else if (!strcasecmp(CONF_STATUS_MESSAGE_TIME, name))
544                 options.status_message_time = std::chrono::seconds(atoi(value));
545         else if (!strcasecmp(CONF_XTERM_TITLE, name))
546                 options.enable_xterm_title = str2bool(value);
547         else if (!strcasecmp(CONF_ENABLE_MOUSE, name))
548 #ifdef HAVE_GETMOUSE
549                 options.enable_mouse = str2bool(value);
550 #else
551         {}
552 #endif
553         else if (!strcasecmp(CONF_CROSSFADE_TIME, name))
554                 options.crossfade_time = atoi(value);
555         else if (!strcasecmp(CONF_SEARCH_MODE, name))
556                 options.search_mode = get_search_mode(value);
557         else if (!strcasecmp(CONF_HIDE_CURSOR, name))
558                 options.hide_cursor = std::chrono::seconds(atoi(value));
559         else if (!strcasecmp(CONF_SEEK_TIME, name))
560                 options.seek_time = atoi(value);
561         else if (!strcasecmp(CONF_LIBRARY_PAGE_TAGS, name)) {
562 #ifdef ENABLE_LIBRARY_PAGE
563                 options.library_page_tags = ParseTagList(value);
564 #endif
565         } else if (!strcasecmp(CONF_SCREEN_LIST, name)) {
566                 options.screen_list = check_screen_list(value);
567         } else if (!strcasecmp(CONF_HOST, name))
568                 options.host = GetStringValue(value);
569         else if (!strcasecmp(CONF_PORT, name))
570                 options.port = atoi(GetStringValue(value).c_str());
571         else if (!strcasecmp(CONF_PASSWORD, name))
572                 options.password = GetStringValue(value);
573         else if (!strcasecmp(CONF_TIMEOUT, name))
574                 options.timeout_ms = atoi(GetStringValue(value).c_str())
575                                      * 1000 /* seconds -> milliseconds */;
576         else if (!strcasecmp(CONF_LYRICS_TIMEOUT, name))
577 #ifdef ENABLE_LYRICS_SCREEN
578                 options.lyrics_timeout = std::chrono::seconds(atoi(GetStringValue(value).c_str()));
579 #else
580         {}
581 #endif
582         else if (!strcasecmp(CONF_SCROLL, name))
583                 options.scroll = str2bool(value);
584         else if (!strcasecmp(CONF_SCROLL_SEP, name)) {
585                 options.scroll_sep = GetStringValue(value);
586         } else if (!strcasecmp(CONF_DISPLAY_TIME, name))
587                 /* obsolete, ignore */
588                 {}
589         else if (!strcasecmp(CONF_JUMP_PREFIX_ONLY, name))
590 #ifdef NCMPC_MINI
591                 {}
592 #else
593                 options.jump_prefix_only = str2bool(value);
594 #endif
595         else if (!strcasecmp(CONF_LYRICS_AUTOSAVE, name))
596 #ifdef ENABLE_LYRICS_SCREEN
597                 options.lyrics_autosave = str2bool(value);
598 #else
599         {}
600 #endif
601         else if (!strcasecmp(CONF_LYRICS_SHOW_PLUGIN, name))
602 #ifdef ENABLE_LYRICS_SCREEN
603                 options.lyrics_show_plugin = str2bool(value);
604 #else
605                 {}
606 #endif
607         else if (!strcasecmp(name, CONF_TEXT_EDITOR))
608 #ifdef ENABLE_LYRICS_SCREEN
609                 {
610                         options.text_editor = GetStringValue(value);
611                 }
612 #else
613                 {}
614 #endif
615         else if (!strcasecmp(name, CONF_TEXT_EDITOR_ASK))
616 #ifdef ENABLE_LYRICS_SCREEN
617                 options.text_editor_ask = str2bool(value);
618 #else
619                 {}
620 #endif
621         else if (!strcasecmp(name, CONF_CHAT_PREFIX))
622 #ifdef ENABLE_CHAT_SCREEN
623                 options.chat_prefix = GetStringValue(value);
624 #else
625                 {}
626 #endif
627         else if (!strcasecmp(CONF_SECOND_COLUMN, name))
628 #ifdef NCMPC_MINI
629                 {}
630 #else
631                 options.second_column = str2bool(value);
632 #endif
633         else
634                 throw FormatRuntimeError("%s: %s",
635                                          _("Unknown configuration parameter"),
636                                          name);
637 }
638
639 static bool
640 read_rc_file(const char *filename)
641 {
642         assert(filename != nullptr);
643
644         FILE *file = fopen(filename, "r");
645         if (file == nullptr) {
646                 perror(filename);
647                 return false;
648         }
649
650         char line[MAX_LINE_LENGTH];
651         while (fgets(line, sizeof(line), file) != nullptr) {
652                 char *p = StripLeft(line);
653
654                 if (*p != 0 && *p != COMMENT_TOKEN) {
655                         StripRight(p);
656
657                         try {
658                                 parse_line(p);
659                         } catch (...) {
660                                 PrintException(std::current_exception());
661                         }
662                 }
663         }
664
665         fclose(file);
666         return true;
667 }
668
669 gcc_pure
670 static bool
671 IsFile(const char *path) noexcept
672 {
673         struct stat st;
674         return stat(path, &st) == 0 && S_ISREG(st.st_mode);
675 }
676
677 gcc_pure
678 static bool
679 IsDirectory(const char *path) noexcept
680 {
681         struct stat st;
682         return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
683 }
684
685 #ifndef _WIN32
686
687 gcc_const
688 static const char *
689 GetHomeDirectory() noexcept
690 {
691         return getenv("HOME");
692 }
693
694 gcc_const
695 static std::string
696 GetHomeConfigDirectory() noexcept
697 {
698         const char *config_home = getenv("XDG_CONFIG_HOME");
699         if (config_home != nullptr && *config_home != 0)
700                 return config_home;
701
702         const char *home = GetHomeDirectory();
703         if (home != nullptr)
704                 return BuildPath(home, ".config");
705
706         return {};
707 }
708
709 gcc_pure
710 static std::string
711 GetHomeConfigDirectory(const char *package) noexcept
712 {
713         const auto dir = GetHomeConfigDirectory();
714         if (dir.empty())
715                 return {};
716
717         return BuildPath(dir, package);
718 }
719
720 #endif
721
722 /**
723  * Find or create the directory for writing configuration files.
724  *
725  * @return the absolute path; an empty string indicates that no
726  * directory could be created
727  */
728 static std::string
729 MakeUserConfigPath(const char *filename)
730 {
731         const auto directory = GetHomeConfigDirectory(PACKAGE);
732         if (directory.empty())
733                 return {};
734
735         return IsDirectory(directory.c_str()) ||
736                 mkdir(directory.c_str(), 0755) == 0
737                 ? BuildPath(directory, filename)
738                 : std::string();
739 }
740
741 std::string
742 MakeKeysPath()
743 {
744         return MakeUserConfigPath(KEYS_FILENAME);
745 }
746
747 #ifndef _WIN32
748
749 std::string
750 GetHomeConfigPath() noexcept
751 {
752         const char *home = GetHomeDirectory();
753         if (home == nullptr)
754                 return {};
755
756         return BuildPath(home, "." PACKAGE, CONFIG_FILENAME);
757 }
758
759 #endif
760
761 std::string
762 GetUserConfigPath() noexcept
763 {
764         const auto dir = GetHomeConfigDirectory();
765         if (dir.empty())
766                 return {};
767
768         return BuildPath(dir, PACKAGE, CONFIG_FILENAME);
769 }
770
771 std::string
772 GetSystemConfigPath() noexcept
773 {
774 #ifdef _WIN32
775         const gchar* const *system_data_dirs;
776
777         for (system_data_dirs = g_get_system_config_dirs (); *system_data_dirs != nullptr; system_data_dirs++)
778         {
779                 auto path = BuildPath(*system_data_dirs, PACKAGE, CONFIG_FILENAME);
780                 if (IsFile(path.c_str()))
781                         return path;
782         }
783         return {};
784 #else
785         return BuildPath(SYSCONFDIR, PACKAGE, CONFIG_FILENAME);
786 #endif
787 }
788
789 #ifndef _WIN32
790
791 gcc_pure
792 static std::string
793 GetHomeKeysPath() noexcept
794 {
795         const char *home = GetHomeDirectory();
796         if (home == nullptr)
797                 return {};
798
799         return BuildPath(home, "." PACKAGE, KEYS_FILENAME);
800 }
801
802 #endif
803
804 gcc_pure
805 static std::string
806 GetUserKeysPath() noexcept
807 {
808         const auto dir = GetHomeConfigDirectory();
809         if (dir.empty())
810                 return {};
811
812         return BuildPath(dir, PACKAGE, KEYS_FILENAME);
813 }
814
815 gcc_pure
816 static std::string
817 GetSystemKeysPath() noexcept
818 {
819 #ifdef _WIN32
820         const gchar* const *system_data_dirs;
821
822         for (system_data_dirs = g_get_system_config_dirs (); *system_data_dirs != nullptr; system_data_dirs++)
823         {
824                 auto path = BuildPath(*system_data_dirs, PACKAGE, KEYS_FILENAME);
825                 if (IsFile(pathname.c_str()))
826                         return path;
827         }
828         return {}
829 #else
830         return BuildPath(SYSCONFDIR, PACKAGE, KEYS_FILENAME);
831 #endif
832 }
833
834 static std::string
835 find_config_file() noexcept
836 {
837         /* check for command line configuration file */
838         if (!options.config_file.empty())
839                 return options.config_file;
840
841         /* check for user configuration ~/.config/ncmpc/config */
842         auto filename = GetUserConfigPath();
843         if (!filename.empty() && IsFile(filename.c_str()))
844                 return filename;
845
846 #ifndef _WIN32
847         /* check for user configuration ~/.ncmpc/config */
848         filename = GetHomeConfigPath();
849         if (!filename.empty() && IsFile(filename.c_str()))
850                 return filename;
851 #endif
852
853         /* check for  global configuration SYSCONFDIR/ncmpc/config */
854         filename = GetSystemConfigPath();
855         if (IsFile(filename.c_str()))
856                 return filename;
857
858         return {};
859 }
860
861 static std::string
862 find_keys_file() noexcept
863 {
864         /* check for command line key binding file */
865         if (!options.key_file.empty())
866                 return options.key_file;
867
868         /* check for user key bindings ~/.config/ncmpc/keys */
869         auto filename = GetUserKeysPath();
870         if (!filename.empty() && IsFile(filename.c_str()))
871                 return filename;
872
873 #ifndef _WIN32
874         /* check for  user key bindings ~/.ncmpc/keys */
875         filename = GetHomeKeysPath();
876         if (!filename.empty() && IsFile(filename.c_str()))
877                 return filename;
878 #endif
879
880         /* check for  global key bindings SYSCONFDIR/ncmpc/keys */
881         filename = GetSystemKeysPath();
882         if (IsFile(filename.c_str()))
883                 return filename;
884
885         return {};
886 }
887
888 void
889 read_configuration()
890 {
891         /* load configuration */
892         auto filename = find_config_file();
893         if (!filename.empty())
894                 read_rc_file(filename.c_str());
895
896         /* load key bindings */
897         filename = find_keys_file();
898         if (!filename.empty())
899                 read_rc_file(filename.c_str());
900 }