2 * iosignal.c - input/output routines for ntpd. The socket-opening code
3 * was shamelessly stolen from ntpd.
8 * Do the #includes differently, as under some versions of Linux
9 * sys/param.h has a #undef CONFIG_PHONE line in it.
11 * As we have ~40 CONFIG_ variables, I don't feel like renaming them
12 * every time somebody adds a new macro to some system header.
21 #ifdef HAVE_SYS_PARAM_H
22 # include <sys/param.h>
23 #endif /* HAVE_SYS_PARAM_H */
24 #ifdef HAVE_SYS_IOCTL_H
25 # include <sys/ioctl.h>
28 #include <arpa/inet.h>
30 #if _BSDI_VERSION >= 199510
37 # define FNDELAY O_NDELAY
40 #include "ntp_machine.h"
44 #include "ntp_stdlib.h"
47 #if defined(HAVE_SIGNALED_IO)
48 static RETSIGTYPE sigio_handler (int);
50 /* consistency safegurad to catch BLOCK/UNBLOCK oversights */
51 static int sigio_block_count = 0;
53 /* main inputhandler to be called on SIGIO */
54 static input_handler_t *input_handler_callback = NULL;
56 # if defined(HAVE_SIGACTION)
58 * If sigaction() is used for signal handling and a signal is
59 * pending then the kernel blocks the signal before it calls
62 * The variable below is used to take care that the SIGIO signal
63 * is not unintentionally unblocked inside the sigio_handler()
64 * if the handler executes a piece of code that is normally
65 * bracketed by BLOCKIO()/UNBLOCKIO() calls.
67 static int sigio_handler_active = 0;
71 * SIGPOLL and SIGIO ROUTINES.
77 * TTY initialization routines.
81 struct refclockio *rio
84 # ifdef USE_TTY_SIGPOLL
86 /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
87 if (ioctl(rio->fd, I_SETSIG, S_INPUT) < 0)
90 "init_clock_sig: ioctl(I_SETSIG, S_INPUT) failed: %m");
97 * Special cases first!
99 /* Was: defined(SYS_HPUX) */
100 # if defined(FIOSSAIOOWN) && defined(FIOSNBIO) && defined(FIOSSAIOSTAT)
105 /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
107 if (ioctl(rio->fd, FIOSSAIOOWN, (char *)&pgrp) == -1)
109 msyslog(LOG_ERR, "ioctl(FIOSSAIOOWN) fails for clock I/O: %m - EXITING");
115 * set non-blocking, async I/O on the descriptor
117 if (ioctl(rio->fd, FIOSNBIO, (char *)&on) == -1)
119 msyslog(LOG_ERR, "ioctl(FIOSNBIO) fails for clock I/O: %m - EXITING");
124 if (ioctl(rio->fd, FIOSSAIOSTAT, (char *)&on) == -1)
126 msyslog(LOG_ERR, "ioctl(FIOSSAIOSTAT) fails for clock I/O: %m - EXITING");
132 # endif /* SYS_HPUX: FIOSSAIOOWN && FIOSNBIO && FIOSSAIOSTAT */
133 /* Was: defined(SYS_AIX) && !defined(_BSD) */
134 # if !defined(_BSD) && defined(_AIX) && defined(FIOASYNC) && defined(FIOSETOWN)
136 * SYSV compatibility mode under AIX.
142 /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
143 if (ioctl(rio->fd, FIOASYNC, (char *)&on) == -1)
145 msyslog(LOG_ERR, "ioctl(FIOASYNC) fails for clock I/O: %m");
149 if (ioctl(rio->fd, FIOSETOWN, (char*)&pgrp) == -1)
151 msyslog(LOG_ERR, "ioctl(FIOSETOWN) fails for clock I/O: %m");
155 if (fcntl(rio->fd, F_SETFL, FNDELAY|FASYNC) < 0)
157 msyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails for clock I/O: %m");
162 # endif /* AIX && !BSD: !_BSD && FIOASYNC && FIOSETOWN */
165 /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
166 # if defined(TIOCSCTTY) && defined(USE_FSETOWNCTTY)
168 * there are, however, always exceptions to the rules
169 * one is, that OSF accepts SETOWN on TTY fd's only, iff they are
170 * CTTYs. SunOS and HPUX do not semm to have this restriction.
171 * another question is: how can you do multiple SIGIO from several
172 * ttys (as they all should be CTTYs), wondering...
176 if (ioctl(rio->fd, TIOCSCTTY, 0) == -1)
178 msyslog(LOG_ERR, "ioctl(TIOCSCTTY, 0) fails for clock I/O: %m");
181 # endif /* TIOCSCTTY && USE_FSETOWNCTTY */
183 if (fcntl(rio->fd, F_SETOWN, getpid()) == -1)
185 msyslog(LOG_ERR, "fcntl(F_SETOWN) fails for clock I/O: %m");
189 if (fcntl(rio->fd, F_SETFL, FNDELAY|FASYNC) < 0)
192 "fcntl(FNDELAY|FASYNC) fails for clock I/O: %m");
197 # endif /* CLOCK_DONE */
198 # endif /* !USE_TTY_SIGPOLL */
208 # ifdef USE_UDP_SIGPOLL
210 if (ioctl(fd, I_SETSIG, S_INPUT) < 0)
213 "init_socket_sig: ioctl(I_SETSIG, S_INPUT) failed: %m - EXITING");
217 # else /* USE_UDP_SIGPOLL */
224 # if defined(FIOASYNC)
225 if (ioctl(fd, FIOASYNC, (char *)&on) == -1)
227 msyslog(LOG_ERR, "ioctl(FIOASYNC) fails: %m - EXITING");
231 # elif defined(FASYNC)
235 if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
237 msyslog(LOG_ERR, "fcntl(F_GETFL) fails: %m - EXITING");
241 if (fcntl(fd, F_SETFL, flags|FASYNC) < 0)
243 msyslog(LOG_ERR, "fcntl(...|FASYNC) fails: %m - EXITING");
249 # include "Bletch: Need asynchronous I/O!"
252 # ifdef UDP_BACKWARDS_SETOWN
258 # if defined(SIOCSPGRP)
259 if (ioctl(fd, SIOCSPGRP, (char *)&pgrp) == -1)
261 msyslog(LOG_ERR, "ioctl(SIOCSPGRP) fails: %m - EXITING");
265 # elif defined(FIOSETOWN)
266 if (ioctl(fd, FIOSETOWN, (char*)&pgrp) == -1)
268 msyslog(LOG_ERR, "ioctl(FIOSETOWN) fails: %m - EXITING");
272 # elif defined(F_SETOWN)
273 if (fcntl(fd, F_SETOWN, pgrp) == -1)
275 msyslog(LOG_ERR, "fcntl(F_SETOWN) fails: %m - EXITING");
280 # include "Bletch: Need to set process(group) to receive SIG(IO|POLL)"
283 # endif /* USE_UDP_SIGPOLL */
291 int saved_errno = errno;
296 # if defined(HAVE_SIGACTION)
297 sigio_handler_active++;
298 if (sigio_handler_active != 1) /* This should never happen! */
299 msyslog(LOG_ERR, "sigio_handler: sigio_handler_active != 1");
302 INSIST(input_handler_callback != NULL);
303 (*input_handler_callback)(&ts);
305 # if defined(HAVE_SIGACTION)
306 sigio_handler_active--;
307 if (sigio_handler_active != 0) /* This should never happen! */
308 msyslog(LOG_ERR, "sigio_handler: sigio_handler_active != 0");
315 * Signal support routines.
317 # ifdef HAVE_SIGACTION
319 set_signal(input_handler_t *input)
321 INSIST(input != NULL);
323 input_handler_callback = input;
327 (void) signal_no_reset(SIGIO, sigio_handler);
330 (void) signal_no_reset(SIGPOLL, sigio_handler);
335 block_io_and_alarm(void)
339 if (sigemptyset(&set))
340 msyslog(LOG_ERR, "block_io_and_alarm: sigemptyset() failed: %m");
341 # if defined(USE_SIGIO)
342 if (sigaddset(&set, SIGIO))
343 msyslog(LOG_ERR, "block_io_and_alarm: sigaddset(SIGIO) failed: %m");
345 # if defined(USE_SIGPOLL)
346 if (sigaddset(&set, SIGPOLL))
347 msyslog(LOG_ERR, "block_io_and_alarm: sigaddset(SIGPOLL) failed: %m");
349 if (sigaddset(&set, SIGALRM))
350 msyslog(LOG_ERR, "block_io_and_alarm: sigaddset(SIGALRM) failed: %m");
352 if (sigprocmask(SIG_BLOCK, &set, NULL))
353 msyslog(LOG_ERR, "block_io_and_alarm: sigprocmask() failed: %m");
359 if ( sigio_handler_active == 0 ) /* not called from within signal handler */
364 if (sigio_block_count > 1)
365 msyslog(LOG_INFO, "block_sigio: sigio_block_count > 1");
366 if (sigio_block_count < 1)
367 msyslog(LOG_INFO, "block_sigio: sigio_block_count < 1");
369 if (sigemptyset(&set))
370 msyslog(LOG_ERR, "block_sigio: sigemptyset() failed: %m");
371 # if defined(USE_SIGIO)
372 if (sigaddset(&set, SIGIO))
373 msyslog(LOG_ERR, "block_sigio: sigaddset(SIGIO) failed: %m");
375 # if defined(USE_SIGPOLL)
376 if (sigaddset(&set, SIGPOLL))
377 msyslog(LOG_ERR, "block_sigio: sigaddset(SIGPOLL) failed: %m");
380 if (sigprocmask(SIG_BLOCK, &set, NULL))
381 msyslog(LOG_ERR, "block_sigio: sigprocmask() failed: %m");
386 unblock_io_and_alarm(void)
390 if (sigemptyset(&unset))
391 msyslog(LOG_ERR, "unblock_io_and_alarm: sigemptyset() failed: %m");
393 # if defined(USE_SIGIO)
394 if (sigaddset(&unset, SIGIO))
395 msyslog(LOG_ERR, "unblock_io_and_alarm: sigaddset(SIGIO) failed: %m");
397 # if defined(USE_SIGPOLL)
398 if (sigaddset(&unset, SIGPOLL))
399 msyslog(LOG_ERR, "unblock_io_and_alarm: sigaddset(SIGPOLL) failed: %m");
401 if (sigaddset(&unset, SIGALRM))
402 msyslog(LOG_ERR, "unblock_io_and_alarm: sigaddset(SIGALRM) failed: %m");
404 if (sigprocmask(SIG_UNBLOCK, &unset, NULL))
405 msyslog(LOG_ERR, "unblock_io_and_alarm: sigprocmask() failed: %m");
411 if ( sigio_handler_active == 0 ) /* not called from within signal handler */
416 if (sigio_block_count > 0)
417 msyslog(LOG_INFO, "unblock_sigio: sigio_block_count > 0");
418 if (sigio_block_count < 0)
419 msyslog(LOG_INFO, "unblock_sigio: sigio_block_count < 0");
421 if (sigemptyset(&unset))
422 msyslog(LOG_ERR, "unblock_sigio: sigemptyset() failed: %m");
424 # if defined(USE_SIGIO)
425 if (sigaddset(&unset, SIGIO))
426 msyslog(LOG_ERR, "unblock_sigio: sigaddset(SIGIO) failed: %m");
428 # if defined(USE_SIGPOLL)
429 if (sigaddset(&unset, SIGPOLL))
430 msyslog(LOG_ERR, "unblock_sigio: sigaddset(SIGPOLL) failed: %m");
433 if (sigprocmask(SIG_UNBLOCK, &unset, NULL))
434 msyslog(LOG_ERR, "unblock_sigio: sigprocmask() failed: %m");
439 wait_for_signal(void)
443 if (sigprocmask(SIG_UNBLOCK, NULL, &old))
444 msyslog(LOG_ERR, "wait_for_signal: sigprocmask() failed: %m");
446 # if defined(USE_SIGIO)
447 if (sigdelset(&old, SIGIO))
448 msyslog(LOG_ERR, "wait_for_signal: sigdelset(SIGIO) failed: %m");
450 # if defined(USE_SIGPOLL)
451 if (sigdelset(&old, SIGPOLL))
452 msyslog(LOG_ERR, "wait_for_signal: sigdelset(SIGPOLL) failed: %m");
454 if (sigdelset(&old, SIGALRM))
455 msyslog(LOG_ERR, "wait_for_signal: sigdelset(SIGALRM) failed: %m");
457 if (sigsuspend(&old) && (errno != EINTR))
458 msyslog(LOG_ERR, "wait_for_signal: sigsuspend() failed: %m");
461 # else /* !HAVE_SIGACTION */
463 * Must be an old bsd system.
464 * We assume there is no SIGPOLL.
468 block_io_and_alarm(void)
472 mask = sigmask(SIGIO) | sigmask(SIGALRM);
474 msyslog(LOG_ERR, "block_io_and_alarm: sigblock() failed: %m");
483 if (sigio_block_count > 1)
484 msyslog(LOG_INFO, "block_sigio: sigio_block_count > 1");
485 if (sigio_block_count < 1)
486 msyslog(LOG_INFO, "block_sigio: sigio_block_count < 1");
488 mask = sigmask(SIGIO);
490 msyslog(LOG_ERR, "block_sigio: sigblock() failed: %m");
494 set_signal(input_handler_t *input)
496 INSIST(input != NULL);
498 input_handler_callback = input;
501 (void) signal_no_reset(SIGIO, sigio_handler);
505 unblock_io_and_alarm(void)
509 mask = sigmask(SIGIO) | sigmask(SIGALRM);
512 (void) sigsetmask(omask);
521 if (sigio_block_count > 0)
522 msyslog(LOG_INFO, "unblock_sigio: sigio_block_count > 0");
523 if (sigio_block_count < 0)
524 msyslog(LOG_INFO, "unblock_sigio: sigio_block_count < 0");
525 mask = sigmask(SIGIO);
528 (void) sigsetmask(omask);
532 wait_for_signal(void)
536 mask = sigmask(SIGIO) | sigmask(SIGALRM);
539 if (sigpause(omask) && (errno != EINTR))
540 msyslog(LOG_ERR, "wait_for_signal: sigspause() failed: %m");
543 # endif /* HAVE_SIGACTION */
545 int NotAnEmptyCompilationUnit;