1 /*
2 * Copyright (c) 2005 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include "defs.h"
36
37 static void usage(const char *av0);
38 static void dotest(const char *target);
39 static void add_server(const char *target);
40 static void process_config_file(const char *path);
41 static pid_t check_pid(void);
42 static void set_pid(const char *av0);
43 static void sigint_handler(int signo __unused);
44
45 static struct server_info **servers;
46 static int nservers;
47 static int maxservers;
48
49 int daemon_opt = 1;
50 int debug_opt = 0;
51 int debug_level = -1; /* (set to default later) */
52 int quickset_opt = 0; /* immediately set time of day on startup */
53 int no_update_opt = 0; /* do not make any actual updates */
54 int min_sleep_opt = 5; /* 5 seconds minimum poll interval */
55 int nom_sleep_opt = 300; /* 5 minutes nominal poll interval */
56 int max_sleep_opt = 1800; /* 30 minutes maximum poll interval */
57 int family = PF_UNSPEC; /* Address family */
58 double insane_deviation = 0.5; /* 0.5 seconds of deviation == insane */
59 const char *config_opt; /* config file */
60 const char *pid_opt = "/var/run/dntpd.pid";
61
62 int
main(int ac,char ** av)63 main(int ac, char **av)
64 {
65 int test_opt = 0;
66 pid_t pid;
67 int ch;
68 int i;
69
70 /*
71 * Really randomize
72 */
73 srandomdev();
74
75 /*
76 * Process Options
77 */
78 while ((ch = getopt(ac, av, "46df:i:l:np:qstFL:QST:")) != -1) {
79 switch(ch) {
80 case '4':
81 family = PF_INET;
82 break;
83 case '6':
84 family = PF_INET6;
85 break;
86 case 'd':
87 debug_opt = 1;
88 daemon_opt = 0;
89 if (debug_level < 0)
90 debug_level = 99;
91 if (config_opt == NULL)
92 config_opt = "/dev/null";
93 break;
94 case 'p':
95 pid_opt = optarg;
96 break;
97 case 'f':
98 config_opt = optarg;
99 break;
100 case 'i':
101 insane_deviation = strtod(optarg, NULL);
102 break;
103 case 'l':
104 debug_level = strtol(optarg, NULL, 0);
105 break;
106 case 'n':
107 no_update_opt = 1;
108 break;
109 case 'q':
110 debug_level = 0;
111 break;
112 case 's':
113 quickset_opt = 1;
114 break;
115 case 'S':
116 quickset_opt = 0;
117 break;
118 case 't':
119 test_opt = 1;
120 debug_opt = 1;
121 daemon_opt = 0;
122 if (debug_level < 0)
123 debug_level = 99;
124 if (config_opt == NULL)
125 config_opt = "/dev/null";
126 break;
127 case 'F':
128 daemon_opt = 0;
129 break;
130 case 'L':
131 max_sleep_opt = strtol(optarg, NULL, 0);
132 break;
133 case 'T':
134 nom_sleep_opt = strtol(optarg, NULL, 0);
135 if (nom_sleep_opt < 1) {
136 fprintf(stderr, "Warning: nominal poll interval too small, "
137 "limiting to 1 second\n");
138 nom_sleep_opt = 1;
139 }
140 if (nom_sleep_opt > 24 * 60 * 60) {
141 fprintf(stderr, "Warning: nominal poll interval too large, "
142 "limiting to 24 hours\n");
143 nom_sleep_opt = 24 * 60 * 60;
144 }
145 if (min_sleep_opt > nom_sleep_opt)
146 min_sleep_opt = nom_sleep_opt;
147 if (max_sleep_opt < nom_sleep_opt * 5)
148 max_sleep_opt = nom_sleep_opt * 5;
149 break;
150 case 'Q':
151 if ((pid = check_pid()) != 0) {
152 fprintf(stderr, "%s: killing old daemon\n", av[0]);
153 kill(pid, SIGINT);
154 usleep(100000);
155 if (check_pid())
156 sleep(1);
157 if (check_pid())
158 sleep(9);
159 if (check_pid()) {
160 fprintf(stderr, "%s: Unable to kill running daemon.\n", av[0]);
161 } else {
162 fprintf(stderr, "%s: Running daemon has been terminated.\n", av[0]);
163 }
164 } else {
165 fprintf(stderr, "%s: There is no daemon running to kill.\n", av[0]);
166 }
167 exit(0);
168 break;
169 case 'h':
170 default:
171 usage(av[0]);
172 /* not reached */
173 }
174 }
175
176 /*
177 * Make sure min and nom intervals are less then or equal to the maximum
178 * interval.
179 */
180 if (min_sleep_opt > max_sleep_opt)
181 min_sleep_opt = max_sleep_opt;
182 if (nom_sleep_opt > max_sleep_opt)
183 nom_sleep_opt = max_sleep_opt;
184
185 /*
186 * Set default config file
187 */
188 if (config_opt == NULL) {
189 if (optind != ac)
190 config_opt = "/dev/null";
191 else
192 config_opt = "/etc/dntpd.conf";
193 }
194
195 if (debug_level < 0)
196 debug_level = 1;
197
198 process_config_file(config_opt);
199
200 if (debug_opt == 0)
201 openlog("dntpd", LOG_CONS|LOG_PID, LOG_DAEMON);
202
203 if (test_opt) {
204 if (optind != ac - 1)
205 usage(av[0]);
206 dotest(av[optind]);
207 /* not reached */
208 }
209
210 /*
211 * Add additional hosts.
212 */
213 for (i = optind; i < ac; ++i) {
214 add_server(av[i]);
215 }
216 if (nservers == 0) {
217 usage(av[0]);
218 /* not reached */
219 }
220
221 /*
222 * Do an initial course time setting if requested using the first
223 * host successfully polled.
224 */
225 /* XXX */
226
227 /*
228 * Daemonize, stop logging to stderr.
229 */
230 if (daemon_opt) {
231 if ((pid = check_pid()) != 0) {
232 logerrstr("%s: NOTE: killing old daemon and starting a new one",
233 av[0]);
234 kill(pid, SIGINT);
235 usleep(100000);
236 if (check_pid())
237 sleep(1);
238 if (check_pid())
239 sleep(9);
240 if (check_pid()) {
241 logerrstr("%s: Unable to kill running daemon, exiting", av[0]);
242 exit(1);
243 }
244 }
245 daemon(0, 0);
246 } else if (check_pid() != 0) {
247 logerrstr("%s: A background dntpd is running, you must kill it first",
248 av[0]);
249 exit(1);
250 }
251 if (debug_opt == 0) {
252 log_stderr = 0;
253 set_pid(av[0]);
254 signal(SIGINT, sigint_handler);
255 logdebug(0, "dntpd version %s started\n", DNTPD_VERSION);
256 }
257
258 /*
259 * And go.
260 */
261 sysntp_clear_alternative_corrections();
262 client_init();
263 client_check_duplicate_ips(servers, nservers);
264 client_main(servers, nservers);
265 return(0);
266 }
267
268 static
269 void
usage(const char * av0)270 usage(const char *av0)
271 {
272 fprintf(stderr, "%s [-dnqstFSQ] [-f config_file] [-l log_level] [-T poll_interval] [-L poll_limit] [additional_targets]\n", av0);
273 fprintf(stderr,
274 "\t-d\tDebugging mode, implies -F, -l 99, and logs to stderr\n"
275 "\t-f file\tSpecify the config file (/etc/dntpd.conf)\n"
276 "\t-l int\tSet log level (0-4), default 1\n"
277 "\t-n\tNo-update mode. No offset or frequency corrections are made\n"
278 "\t-q\tQuiet-mode, same as -L 0\n"
279 "\t-s\tSet the time immediately on startup\n"
280 "\t-t\tTest mode, implies -F, -l 99, -n, logs to stderr\n"
281 "\t-F\tRun in foreground (log still goes to syslog)\n"
282 "\t-L int\tMaximum polling interval\n"
283 "\t-S\tDo not set the time immediately on startup\n"
284 "\t-T int\tNominal polling interval\n"
285 "\t-Q\tTerminate any running background daemon\n"
286 "\n"
287 "\t\tNOTE: in debug and test modes -f must be specified if\n"
288 "\t\tyou want to use a config file.\n"
289 );
290 exit(1);
291 }
292
293 static
294 void
dotest(const char * target)295 dotest(const char *target)
296 {
297 struct server_info info;
298
299 bzero(&info, sizeof(info));
300 info.sam = (struct sockaddr *)&info.sam_st;
301 info.fd = udp_socket(target, 123, info.sam, LOG_DNS_ERROR);
302 if (info.fd < 0) {
303 logerrstr("unable to create UDP socket for %s", target);
304 return;
305 }
306 info.target = strdup(target);
307 client_init();
308
309 fprintf(stderr,
310 "Will run %d-second polls until interrupted.\n", nom_sleep_opt);
311
312 for (;;) {
313 client_poll(&info, nom_sleep_opt, 1);
314 sleep(nom_sleep_opt);
315 }
316 /* not reached */
317 }
318
319 static char *
myaddr2ascii(struct sockaddr * sa)320 myaddr2ascii(struct sockaddr *sa)
321 {
322 static char str[INET6_ADDRSTRLEN];
323 struct sockaddr_in *soin;
324 struct sockaddr_in6 *sin6;
325
326 switch (sa->sa_family) {
327 case AF_INET:
328 soin = (struct sockaddr_in *) sa;
329 inet_ntop(AF_INET, &soin->sin_addr, str, sizeof(str));
330 break;
331 case AF_INET6:
332 sin6 = (struct sockaddr_in6 *) sa;
333 inet_ntop(AF_INET6, &sin6->sin6_addr, str, sizeof(str));
334 break;
335 }
336 return (str);
337 }
338
339 static void
add_server(const char * target)340 add_server(const char *target)
341 {
342 server_info_t info;
343
344 if (nservers == maxservers) {
345 maxservers += 16;
346 servers = realloc(servers, maxservers * sizeof(server_info_t));
347 assert(servers != NULL);
348 }
349 info = malloc(sizeof(struct server_info));
350 servers[nservers] = info;
351 bzero(info, sizeof(struct server_info));
352 info->sam = (struct sockaddr *)&info->sam_st;
353 info->target = strdup(target);
354 /*
355 * Postpone socket opening and server name resolution until we are in main
356 * loop to avoid hang during init if network down.
357 */
358 info->fd = -1;
359 info->server_state = -1;
360 ++nservers;
361 }
362
363 void
disconnect_server(server_info_t info)364 disconnect_server(server_info_t info)
365 {
366 if (info->fd >= 0)
367 close(info->fd);
368 info->fd = -1;
369 if (info->ipstr) {
370 free(info->ipstr);
371 info->ipstr = NULL;
372 }
373 }
374
375 void
reconnect_server(server_info_t info)376 reconnect_server(server_info_t info)
377 {
378 const char *ipstr;
379 dns_error_policy_t policy;
380
381 /*
382 * Ignore DNS errors if never connected before to handle the case where
383 * we're started before network up.
384 */
385 policy = IGNORE_DNS_ERROR;
386 if (info->fd >= 0) {
387 close(info->fd);
388 policy = LOG_DNS_ERROR;
389 }
390 if (info->ipstr) {
391 free(info->ipstr);
392 info->ipstr = NULL;
393 }
394 info->sam = (struct sockaddr *)&info->sam_st;
395 info->fd = udp_socket(info->target, 123, info->sam, policy);
396 if (info->fd >= 0) {
397 ipstr = myaddr2ascii(info->sam);
398 info->ipstr = strdup(ipstr);
399 }
400 }
401
402 static void
process_config_file(const char * path)403 process_config_file(const char *path)
404 {
405 const char *ws = " \t\r\n";
406 char buf[1024];
407 char *keyword;
408 char *data;
409 int line;
410 FILE *fi;
411
412 if ((fi = fopen(path, "r")) != NULL) {
413 line = 1;
414 while (fgets(buf, sizeof(buf), fi) != NULL) {
415 if (strchr(buf, '#'))
416 *strchr(buf, '#') = 0;
417 if ((keyword = strtok(buf, ws)) != NULL) {
418 data = strtok(NULL, ws);
419 if (strcmp(keyword, "server") == 0) {
420 if (data == NULL) {
421 logerr("%s:%d server missing host specification",
422 path, line);
423 } else {
424 add_server(data);
425 }
426 } else {
427 logerr("%s:%d unknown keyword %s", path, line, keyword);
428 }
429 }
430 ++line;
431 }
432 fclose(fi);
433 } else {
434 logerr("Unable to open %s", path);
435 exit(1);
436 }
437 }
438
439 static
440 pid_t
check_pid(void)441 check_pid(void)
442 {
443 char buf[32];
444 pid_t pid;
445 FILE *fi;
446
447 pid = 0;
448 if ((fi = fopen(pid_opt, "r")) != NULL) {
449 if (fgets(buf, sizeof(buf), fi) != NULL) {
450 pid = strtol(buf, NULL, 0);
451 if (kill(pid, 0) != 0)
452 pid = 0;
453 }
454 fclose(fi);
455 }
456 return(pid);
457 }
458
459 static
460 void
set_pid(const char * av0)461 set_pid(const char *av0)
462 {
463 pid_t pid;
464 FILE *fo;
465
466 pid = getpid();
467 if ((fo = fopen(pid_opt, "w")) != NULL) {
468 fprintf(fo, "%d\n", (int)pid);
469 fclose(fo);
470 } else {
471 logerr("%s: Unable to create %s, continuing anyway.", av0, pid_opt);
472 }
473 }
474
475 static
476 void
sigint_handler(int signo __unused)477 sigint_handler(int signo __unused)
478 {
479 remove(pid_opt);
480 /* dangerous, but we are exiting anyway so pray... */
481 logdebug(0, "dntpd version %s stopped\n", DNTPD_VERSION);
482 exit(0);
483 }
484
485