src/timesync/timesyncd-conf.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "alloc-util.h"
   4 #include "def.h"
   5 #include "dns-domain.h"
   6 #include "extract-word.h"
   7 #include "string-util.h"
   8 #include "timesyncd-conf.h"
   9 #include "timesyncd-manager.h"
  10 #include "timesyncd-server.h"
  11
  12 int manager_parse_server_string(Manager *m, ServerType type, const char *string) {
  13         ServerName *first;
  14         int r;
  15
  16         assert(m);
  17         assert(string);
  18
  19         first = type == SERVER_FALLBACK ? m->fallback_servers : m->system_servers;
  20
  21         if (type == SERVER_FALLBACK)
  22                  m->have_fallbacks = true;
  23
  24         for (;;) {
  25                 _cleanup_free_ char *word = NULL;
  26                 bool found = false;
  27                 ServerName *n;
  28
  29                 r = extract_first_word(&string, &word, NULL, 0);
  30                 if (r < 0)
  31                         return log_error_errno(r, "Failed to parse timesyncd server syntax \"%s\": %m", string);
  32                 if (r == 0)
  33                         break;
  34
  35                 r = dns_name_is_valid_or_address(word);
  36                 if (r < 0)
  37                         return log_error_errno(r, "Failed to check validity of NTP server name or address '%s': %m", word);
  38                 if (r == 0) {
  39                         log_error("Invalid NTP server name or address, ignoring: %s", word);
  40                         continue;
  41                 }
  42
  43                 /* Filter out duplicates */
  44                 LIST_FOREACH(names, n, first)
  45                         if (streq_ptr(n->string, word)) {
  46                                 found = true;
  47                                 break;
  48                         }
  49
  50                 if (found)
  51                         continue;
  52
  53                 r = server_name_new(m, NULL, type, word);
  54                 if (r < 0)
  55                         return r;
  56         }
  57
  58         return 0;
  59 }
  60
  61 int manager_parse_fallback_string(Manager *m, const char *string) {
  62         if (m->have_fallbacks)
  63                 return 0;
  64
  65         return manager_parse_server_string(m, SERVER_FALLBACK, string);
  66 }
  67
  68 int config_parse_servers(
  69                 const char *unit,
  70                 const char *filename,
  71                 unsigned line,
  72                 const char *section,
  73                 unsigned section_line,
  74                 const char *lvalue,
  75                 int ltype,
  76                 const char *rvalue,
  77                 void *data,
  78                 void *userdata) {
  79
  80         Manager *m = userdata;
  81         int r;
  82
  83         assert(filename);
  84         assert(lvalue);
  85         assert(rvalue);
  86
  87         if (isempty(rvalue))
  88                 manager_flush_server_names(m, ltype);
  89         else {
  90                 r = manager_parse_server_string(m, ltype, rvalue);
  91                 if (r < 0) {
  92                         log_syntax(unit, LOG_WARNING, filename, line, r,
  93                                    "Failed to parse NTP server string '%s', ignoring: %m", rvalue);
  94                         return 0;
  95                 }
  96         }
  97
  98         return 0;
  99 }
 100
 101 int manager_parse_config_file(Manager *m) {
 102         int r;
 103
 104         assert(m);
 105
 106         r = config_parse_many_nulstr(
 107                         PKGSYSCONFDIR "/timesyncd.conf",
 108                         CONF_PATHS_NULSTR("systemd/timesyncd.conf.d"),
 109                         "Time\0",
 110                         config_item_perf_lookup, timesyncd_gperf_lookup,
 111                         CONFIG_PARSE_WARN,
 112                         m,
 113                         NULL);
 114         if (r < 0)
 115                 return r;
 116
 117         if (m->poll_interval_min_usec < 16 * USEC_PER_SEC) {
 118                 log_warning("Invalid PollIntervalMinSec=. Using default value.");
 119                 m->poll_interval_min_usec = NTP_POLL_INTERVAL_MIN_USEC;
 120         }
 121
 122         if (m->poll_interval_max_usec < m->poll_interval_min_usec) {
 123                 log_warning("PollIntervalMaxSec= is smaller than PollIntervalMinSec=. Using default value.");
 124                 m->poll_interval_max_usec = MAX(NTP_POLL_INTERVAL_MAX_USEC, m->poll_interval_min_usec * 32);
 125         }
 126
 127         return r;
 128 }