src/timesync/timesyncd-conf.c

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