31418cb014eddc4912d37296c4c6c1db3b49680d
[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/StringStrip.hxx"
36
37 #include <assert.h>
38 #include <sys/stat.h>
39 #include <ctype.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43
44 #ifdef _WIN32
45 #include <glib.h>
46 #endif
47
48 #define MAX_LINE_LENGTH 1024
49 #define COMMENT_TOKEN '#'
50
51 /* configuration field names */
52 #define CONF_ENABLE_COLORS "enable-colors"
53 #define CONF_SCROLL_OFFSET "scroll-offset"
54 #define CONF_AUTO_CENTER "auto-center"
55 #define CONF_WIDE_CURSOR "wide-cursor"
56 #define CONF_KEY_DEFINITION "key"
57 #define CONF_COLOR "color"
58 #define CONF_COLOR_DEFINITION "colordef"
59 #define CONF_LIST_FORMAT "list-format"
60 #define CONF_SEARCH_FORMAT "search-format"
61 #define CONF_STATUS_FORMAT "status-format"
62 #define CONF_XTERM_TITLE_FORMAT "xterm-title-format"
63 #define CONF_LIST_WRAP "wrap-around"
64 #define CONF_FIND_WRAP "find-wrap"
65 #define CONF_FIND_SHOW_LAST "find-show-last"
66 #define CONF_AUDIBLE_BELL "audible-bell"
67 #define CONF_VISIBLE_BELL "visible-bell"
68 #define CONF_BELL_ON_WRAP "bell-on-wrap"
69 #define CONF_STATUS_MESSAGE_TIME "status-message-time"
70 #define CONF_XTERM_TITLE "set-xterm-title"
71 #define CONF_ENABLE_MOUSE "enable-mouse"
72 #define CONF_CROSSFADE_TIME "crossfade-time"
73 #define CONF_SEARCH_MODE "search-mode"
74 #define CONF_HIDE_CURSOR "hide-cursor"
75 #define CONF_SEEK_TIME "seek-time"
76 #define CONF_LIBRARY_PAGE_TAGS "library-page-tags"
77 #define CONF_SCREEN_LIST "screen-list"
78 #define CONF_TIMEDISPLAY_TYPE "timedisplay-type"
79 #define CONF_HOST "host"
80 #define CONF_PORT "port"
81 #define CONF_PASSWORD "password"
82 #define CONF_TIMEOUT "timeout"
83 #define CONF_LYRICS_TIMEOUT "lyrics-timeout"
84 #define CONF_SCROLL "scroll"
85 #define CONF_SCROLL_SEP "scroll-sep"
86 #define CONF_VISIBLE_BITRATE "visible-bitrate"
87 #define CONF_HARDWARE_CURSOR "hardware-cursor"
88 #define CONF_WELCOME_SCREEN_LIST "welcome-screen-list"
89 #define CONF_DISPLAY_TIME "display-time"
90 #define CONF_JUMP_PREFIX_ONLY "jump-prefix-only"
91 #define CONF_LYRICS_AUTOSAVE "lyrics-autosave"
92 #define CONF_LYRICS_SHOW_PLUGIN "lyrics-show-plugin"
93 #define CONF_TEXT_EDITOR "text-editor"
94 #define CONF_TEXT_EDITOR_ASK "text-editor-ask"
95 #define CONF_CHAT_PREFIX "chat-prefix"
96 #define CONF_SECOND_COLUMN "second-column"
97
98 #ifdef _WIN32
99 #define CONFIG_FILENAME "ncmpc.conf"
100 #define KEYS_FILENAME "keys.conf"
101 #else
102 #define CONFIG_FILENAME "config"
103 #define KEYS_FILENAME "keys"
104 #endif
105
106 gcc_pure
107 static bool
108 str2bool(char *str) noexcept
109 {
110         return strcasecmp(str, "yes") == 0 || strcasecmp(str, "true") == 0 ||
111                 strcasecmp(str, "on") == 0 || strcasecmp(str, "1") == 0;
112 }
113
114 static void
115 print_error(const char *msg, const char *input) noexcept
116 {
117         fprintf(stderr, "%s: %s ('%s')\n",
118                 /* To translators: prefix for error messages */
119                 _("Error"), msg, input);
120 }
121
122 static constexpr bool
123 is_word_char(char ch) noexcept
124 {
125         return IsAlphaNumericASCII(ch) || ch == '-' || ch == '_';
126 }
127
128 static char *
129 after_unquoted_word(char *p)
130 {
131         if (!is_word_char(*p)) {
132                 print_error(_("Word expected"), p);
133                 return nullptr;
134         }
135
136         ++p;
137
138         while (is_word_char(*p))
139                 ++p;
140
141         return p;
142 }
143
144 static int
145 parse_key_value(char *str, char **end)
146 {
147         if (*str == '\'') {
148                 if (str[1] == '\\' && str[2] == '\'' && str[3] == '\'') {
149                         /* the single quote can be escaped with a
150                            backslash */
151                         *end = str + 4;
152                         return str[2];
153                 }
154
155                 if (str[1] == '\'' || str[2] != '\'') {
156                         print_error(_("Malformed hotkey definition"), str);
157                         return -1;
158                 }
159
160                 *end = str + 3;
161                 return str[1];
162         } else {
163                 long value = strtol(str, end, 0);
164                 if (*end == str) {
165                         print_error(_("Malformed hotkey definition"), str);
166                         return -1;
167                 }
168
169                 return (int)value;
170         }
171 }
172
173 static bool
174 parse_key_definition(char *str)
175 {
176         /* get the command name */
177         char *eq = strchr(str, '=');
178         if (eq == nullptr) {
179                 /* the hotkey configuration line is incomplete */
180                 print_error(_("Incomplete hotkey configuration"), str);
181                 return false;
182         }
183
184         char *command_name = str;
185         str = StripLeft(eq + 1);
186
187         *eq = '\0';
188         StripRight(command_name);
189         const auto cmd = get_key_command_from_name(command_name);
190         if(cmd == Command::NONE) {
191                 /* the hotkey configuration contains an unknown
192                    command */
193                 print_error(_("Unknown command"), command_name);
194                 return false;
195         }
196
197         /* parse key values */
198         size_t i = 0;
199         int key = 0;
200         char *p = str;
201
202         std::array<int, MAX_COMMAND_KEYS> keys{0};
203         while (i < MAX_COMMAND_KEYS && *p != 0 &&
204                (key = parse_key_value(p, &p)) >= 0) {
205                 keys[i++] = key;
206                 while (*p==',' || *p==' ' || *p=='\t')
207                         p++;
208         }
209
210         if (key < 0)
211                 return false;
212
213         GetGlobalKeyBindings().SetKey(cmd, keys);
214         return true;
215 }
216
217 static bool
218 parse_timedisplay_type(const char *str)
219 {
220         if (strcmp(str, "elapsed") == 0)
221                 return false;
222         else if (strcmp(str, "remaining") == 0)
223                 return true;
224         else {
225                 /* translators: ncmpc supports displaying the
226                    "elapsed" or "remaining" time of a song being
227                    played; in this case, the configuration file
228                    contained an invalid setting */
229                 print_error(_("Bad time display type"), str);
230                 return false;
231         }
232 }
233
234 #ifdef ENABLE_COLORS
235 static char *
236 separate_value(char *p)
237 {
238         char *value = strchr(p, '=');
239         if (value == nullptr) {
240                 /* an equals sign '=' was expected while parsing a
241                    configuration file line */
242                 fprintf(stderr, "%s\n", _("Missing '='"));
243                 return nullptr;
244         }
245
246         *StripRight(p, value++) = '\0';
247
248         return Strip(value);
249 }
250
251 static bool
252 parse_color(char *str)
253 {
254         char *value = separate_value(str);
255         if (value == nullptr)
256                 return false;
257
258         return ModifyStyle(str, value);
259 }
260
261 /**
262  * Returns the first non-whitespace character after the next comma
263  * character, or the end of the string.  This is used to parse comma
264  * separated values.
265  */
266 static char *
267 after_comma(char *p) noexcept
268 {
269         char *comma = strchr(p, ',');
270
271         if (comma != nullptr) {
272                 *comma++ = 0;
273                 comma = StripLeft(comma);
274         } else
275                 comma = p + strlen(p);
276
277         StripRight(p);
278         return comma;
279 }
280
281 static bool
282 parse_color_definition(char *str)
283 {
284         char *value = separate_value(str);
285         if (value == nullptr)
286                 return false;
287
288         /* get the command name */
289         short color = ParseColorNameOrNumber(str);
290         if (color < 0) {
291                 char buf[MAX_LINE_LENGTH];
292                 print_error(_("Bad color name"), buf);
293                 return false;
294         }
295
296         /* parse r,g,b values */
297
298         short rgb[3];
299         for (unsigned i = 0; i < 3; ++i) {
300                 char *next = after_comma(value), *endptr;
301                 if (*value == 0) {
302                         print_error(_("Incomplete color definition"), str);
303                         return false;
304                 }
305
306                 rgb[i] = strtol(value, &endptr, 0);
307                 if (endptr == value || *endptr != 0) {
308                         print_error(_("Invalid number"), value);
309                         return false;
310                 }
311
312                 value = next;
313         }
314
315         if (*value != 0) {
316                 print_error(_("Malformed color definition"), str);
317                 return false;
318         }
319
320         colors_define(color, rgb[0], rgb[1], rgb[2]);
321         return true;
322 }
323 #endif
324
325 static std::string
326 GetStringValue(const char *s) noexcept
327 {
328         size_t length = strlen(s);
329
330         if (s[0] == '\"' && s[length - 1] == '\"') {
331                 length -= 2;
332                 ++s;
333         }
334
335         return {s, length};
336 }
337
338 static constexpr bool
339 IsListSeparator(char ch) noexcept
340 {
341         return IsWhitespaceFast(ch) || ch == ',';
342 }
343
344 static char *
345 NextItem(char *&src) noexcept
346 {
347         while (*src && IsListSeparator(*src))
348                 ++src;
349
350         if (!*src)
351                 return nullptr;
352
353         char *value = src;
354
355         while (!IsListSeparator(*src))
356                 ++src;
357
358         if (*src)
359                 *src++ = 0;
360
361         return value;
362 }
363
364 static std::vector<std::string>
365 check_screen_list(char *value)
366 {
367         std::vector<std::string> screen;
368
369         while (char *name = NextItem(value)) {
370                 std::transform(name, name + strlen(name), name, tolower);
371
372                 const auto *page_meta = screen_lookup_name(name);
373                 if (page_meta == nullptr) {
374                         /* an unknown screen name was specified in the
375                            configuration file */
376                         print_error(_("Unknown screen name"), name);
377                 } else {
378                         /* use PageMeta::name because
379                            screen_lookup_name() may have translated a
380                            deprecated name */
381                         screen.emplace_back(page_meta->name);
382                 }
383         }
384
385         if (screen.empty())
386                 screen = DEFAULT_SCREEN_LIST;
387
388         return screen;
389 }
390
391 #ifdef ENABLE_LIBRARY_PAGE
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                         print_error(_("Unknown MPD tag"), name);
402                         result.clear();
403                         return result;
404                 }
405
406                 result.emplace_back(type);
407         }
408
409         if (result.empty())
410                 fprintf(stderr, "Empty tag list\n");
411
412         return result;
413 }
414
415 #endif
416
417 static int
418 get_search_mode(char *value)
419 {
420         char * test;
421         const int mode = strtol(value, &test, 10);
422         if (*test == '\0')
423         {
424                 if (0 <= mode && mode <= 4)
425                         return mode;
426                 else
427                 {
428                         print_error(_("Invalid search mode"),value);
429                         return 0;
430                 }
431         }
432         else
433         {
434                 // TODO: modify screen_search so that its own list of modes can be used
435                 // for comparison instead of specifying them here
436                 if (strcasecmp(value, "title") == 0)
437                         return 0;
438                 else if (strcasecmp(value, "artist") == 0)
439                         return 1;
440                 else if (strcasecmp(value, "album") == 0)
441                         return 2;
442                 else if (strcasecmp(value, "filename") == 0)
443                         return 3;
444                 else if (strcasecmp(value, "artist+album") == 0)
445                         return 4;
446                 else
447                 {
448                         print_error(_("Unknown search mode"),value);
449                         return 0;
450                 }
451         }
452 }
453
454 static bool
455 parse_line(char *line)
456 {
457         /* get the name part */
458         char *const name = line;
459         char *const name_end = after_unquoted_word(line);
460         if (name_end == nullptr)
461                 return false;
462
463         line = StripLeft(name_end);
464         if (*line == '=') {
465                 ++line;
466                 line = StripLeft(line);
467         } else if (line == name_end) {
468                 print_error(_("Missing '='"), name_end);
469                 return false;
470         }
471
472         *name_end = 0;
473
474         /* get the value part */
475         char *const value = line;
476
477         /* key definition */
478         if (!strcasecmp(CONF_KEY_DEFINITION, name))
479                 parse_key_definition(value);
480         /* enable colors */
481         else if(!strcasecmp(CONF_ENABLE_COLORS, name))
482 #ifdef ENABLE_COLORS
483                 options.enable_colors = str2bool(value);
484 #else
485         {}
486 #endif
487         else if (!strcasecmp(CONF_SCROLL_OFFSET, name))
488                 options.scroll_offset = atoi(value);
489         /* auto center */
490         else if (!strcasecmp(CONF_AUTO_CENTER, name))
491                 options.auto_center = str2bool(value);
492         /* color assignment */
493         else if (!strcasecmp(CONF_COLOR, name))
494 #ifdef ENABLE_COLORS
495                 parse_color(value);
496 #else
497         {}
498 #endif
499         /* wide cursor */
500         else if (!strcasecmp(CONF_WIDE_CURSOR, name))
501                 options.wide_cursor = str2bool(value);
502         else if (strcasecmp(name, CONF_HARDWARE_CURSOR) == 0)
503                 options.hardware_cursor = str2bool(value);
504         /* welcome screen list */
505         else if (!strcasecmp(CONF_WELCOME_SCREEN_LIST, name))
506                 options.welcome_screen_list = str2bool(value);
507         /* visible bitrate */
508         else if (!strcasecmp(CONF_VISIBLE_BITRATE, name))
509                 options.visible_bitrate = str2bool(value);
510         /* timer display type */
511         else if (!strcasecmp(CONF_TIMEDISPLAY_TYPE, name))
512                 options.display_remaining_time = parse_timedisplay_type(value);
513                 /* color definition */
514         else if (!strcasecmp(CONF_COLOR_DEFINITION, name))
515 #ifdef ENABLE_COLORS
516                 parse_color_definition(value);
517 #else
518         {}
519 #endif
520         /* list format string */
521         else if (!strcasecmp(CONF_LIST_FORMAT, name)) {
522                 options.list_format = GetStringValue(value);
523                 /* search format string */
524         } else if (!strcasecmp(CONF_SEARCH_FORMAT, name)) {
525                 options.search_format = GetStringValue(value);
526                 /* status format string */
527         } else if (!strcasecmp(CONF_STATUS_FORMAT, name)) {
528                 options.status_format = GetStringValue(value);
529                 /* xterm title format string */
530         } else if (!strcasecmp(CONF_XTERM_TITLE_FORMAT, name)) {
531                 options.xterm_title_format = GetStringValue(value);
532         } else if (!strcasecmp(CONF_LIST_WRAP, name))
533                 options.list_wrap = str2bool(value);
534         else if (!strcasecmp(CONF_FIND_WRAP, name))
535                 options.find_wrap = str2bool(value);
536         else if (!strcasecmp(CONF_FIND_SHOW_LAST,name))
537                 options.find_show_last_pattern = str2bool(value);
538         else if (!strcasecmp(CONF_AUDIBLE_BELL, name))
539                 options.audible_bell = str2bool(value);
540         else if (!strcasecmp(CONF_VISIBLE_BELL, name))
541                 options.visible_bell = str2bool(value);
542         else if (!strcasecmp(CONF_BELL_ON_WRAP, name))
543                 options.bell_on_wrap = str2bool(value);
544         else if (!strcasecmp(CONF_STATUS_MESSAGE_TIME, name))
545                 options.status_message_time = std::chrono::seconds(atoi(value));
546         else if (!strcasecmp(CONF_XTERM_TITLE, name))
547                 options.enable_xterm_title = str2bool(value);
548         else if (!strcasecmp(CONF_ENABLE_MOUSE, name))
549 #ifdef HAVE_GETMOUSE
550                 options.enable_mouse = str2bool(value);
551 #else
552         {}
553 #endif
554         else if (!strcasecmp(CONF_CROSSFADE_TIME, name))
555                 options.crossfade_time = atoi(value);
556         else if (!strcasecmp(CONF_SEARCH_MODE, name))
557                 options.search_mode = get_search_mode(value);
558         else if (!strcasecmp(CONF_HIDE_CURSOR, name))
559                 options.hide_cursor = std::chrono::seconds(atoi(value));
560         else if (!strcasecmp(CONF_SEEK_TIME, name))
561                 options.seek_time = atoi(value);
562         else if (!strcasecmp(CONF_LIBRARY_PAGE_TAGS, name)) {
563 #ifdef ENABLE_LIBRARY_PAGE
564                 options.library_page_tags = ParseTagList(value);
565                 if (options.library_page_tags.empty())
566                         return false;
567 #endif
568         } else if (!strcasecmp(CONF_SCREEN_LIST, name)) {
569                 options.screen_list = check_screen_list(value);
570         } else if (!strcasecmp(CONF_HOST, name))
571                 options.host = GetStringValue(value);
572         else if (!strcasecmp(CONF_PORT, name))
573                 options.port = atoi(GetStringValue(value).c_str());
574         else if (!strcasecmp(CONF_PASSWORD, name))
575                 options.password = GetStringValue(value);
576         else if (!strcasecmp(CONF_TIMEOUT, name))
577                 options.timeout_ms = atoi(GetStringValue(value).c_str())
578                                      * 1000 /* seconds -> milliseconds */;
579         else if (!strcasecmp(CONF_LYRICS_TIMEOUT, name))
580 #ifdef ENABLE_LYRICS_SCREEN
581                 options.lyrics_timeout = std::chrono::seconds(atoi(GetStringValue(value).c_str()));
582 #else
583         {}
584 #endif
585         else if (!strcasecmp(CONF_SCROLL, name))
586                 options.scroll = str2bool(value);
587         else if (!strcasecmp(CONF_SCROLL_SEP, name)) {
588                 options.scroll_sep = GetStringValue(value);
589         } else if (!strcasecmp(CONF_DISPLAY_TIME, name))
590                 /* obsolete, ignore */
591                 {}
592         else if (!strcasecmp(CONF_JUMP_PREFIX_ONLY, name))
593 #ifdef NCMPC_MINI
594                 {}
595 #else
596                 options.jump_prefix_only = str2bool(value);
597 #endif
598         else if (!strcasecmp(CONF_LYRICS_AUTOSAVE, name))
599 #ifdef ENABLE_LYRICS_SCREEN
600                 options.lyrics_autosave = str2bool(value);
601 #else
602         {}
603 #endif
604         else if (!strcasecmp(CONF_LYRICS_SHOW_PLUGIN, name))
605 #ifdef ENABLE_LYRICS_SCREEN
606                 options.lyrics_show_plugin = str2bool(value);
607 #else
608                 {}
609 #endif
610         else if (!strcasecmp(name, CONF_TEXT_EDITOR))
611 #ifdef ENABLE_LYRICS_SCREEN
612                 {
613                         options.text_editor = GetStringValue(value);
614                 }
615 #else
616                 {}
617 #endif
618         else if (!strcasecmp(name, CONF_TEXT_EDITOR_ASK))
619 #ifdef ENABLE_LYRICS_SCREEN
620                 options.text_editor_ask = str2bool(value);
621 #else
622                 {}
623 #endif
624         else if (!strcasecmp(name, CONF_CHAT_PREFIX))
625 #ifdef ENABLE_CHAT_SCREEN
626                 options.chat_prefix = GetStringValue(value);
627 #else
628                 {}
629 #endif
630         else if (!strcasecmp(CONF_SECOND_COLUMN, name))
631 #ifdef NCMPC_MINI
632                 {}
633 #else
634                 options.second_column = str2bool(value);
635 #endif
636         else {
637                 print_error(_("Unknown configuration parameter"), name);
638                 return false;
639         }
640
641         return true;
642 }
643
644 static bool
645 read_rc_file(const char *filename)
646 {
647         assert(filename != nullptr);
648
649         FILE *file = fopen(filename, "r");
650         if (file == nullptr) {
651                 perror(filename);
652                 return false;
653         }
654
655         char line[MAX_LINE_LENGTH];
656         while (fgets(line, sizeof(line), file) != nullptr) {
657                 char *p = StripLeft(line);
658
659                 if (*p != 0 && *p != COMMENT_TOKEN) {
660                         StripRight(p);
661                         parse_line(p);
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 }