Branch data     Line data    Source code

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