Annotation of embedaddon/ntp/libntp/iosignal.c, revision 1.1
1.1 ! misho 1: /*
! 2: * iosignal.c - input/output routines for ntpd. The socket-opening code
! 3: * was shamelessly stolen from ntpd.
! 4: */
! 5:
! 6: /*
! 7: * [Bug 158]
! 8: * Do the #includes differently, as under some versions of Linux
! 9: * sys/param.h has a #undef CONFIG_PHONE line in it.
! 10: *
! 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.
! 13: */
! 14:
! 15: #ifdef HAVE_CONFIG_H
! 16: # include <config.h>
! 17: #endif
! 18:
! 19: #include <stdio.h>
! 20: #include <signal.h>
! 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>
! 26: #endif
! 27:
! 28: #include <arpa/inet.h>
! 29:
! 30: #if _BSDI_VERSION >= 199510
! 31: # include <ifaddrs.h>
! 32: #endif
! 33:
! 34: # ifdef __QNXNTO__
! 35: # include <fcntl.h>
! 36: # include <unix.h>
! 37: # define FNDELAY O_NDELAY
! 38: # endif
! 39:
! 40: #include "ntp_machine.h"
! 41: #include "ntpd.h"
! 42: #include "ntp_io.h"
! 43: #include "ntp_if.h"
! 44: #include "ntp_stdlib.h"
! 45: #include "iosignal.h"
! 46:
! 47: #if defined(HAVE_SIGNALED_IO)
! 48: static int sigio_block_count = 0;
! 49: # if defined(HAVE_SIGACTION)
! 50: /*
! 51: * If sigaction() is used for signal handling and a signal is
! 52: * pending then the kernel blocks the signal before it calls
! 53: * the signal handler.
! 54: *
! 55: * The variable below is used to take care that the SIGIO signal
! 56: * is not unintentionally unblocked inside the sigio_handler()
! 57: * if the handler executes a piece of code that is normally
! 58: * bracketed by BLOCKIO()/UNBLOCKIO() calls.
! 59: */
! 60: static int sigio_handler_active = 0;
! 61: # endif
! 62: extern void input_handler (l_fp *);
! 63:
! 64: /*
! 65: * SIGPOLL and SIGIO ROUTINES.
! 66: */
! 67:
! 68: /*
! 69: * Some systems (MOST) define SIGPOLL == SIGIO, others SIGIO == SIGPOLL, and
! 70: * a few have separate SIGIO and SIGPOLL signals. This code checks for the
! 71: * SIGIO == SIGPOLL case at compile time.
! 72: * Do not define USE_SIGPOLL or USE_SIGIO.
! 73: * these are interal only to iosignal.c!
! 74: */
! 75: # if defined(USE_SIGPOLL)
! 76: # undef USE_SIGPOLL
! 77: # endif
! 78: # if defined(USE_SIGIO)
! 79: # undef USE_SIGIO
! 80: # endif
! 81:
! 82: # if defined(USE_TTY_SIGPOLL) || defined(USE_UDP_SIGPOLL)
! 83: # define USE_SIGPOLL
! 84: # endif
! 85:
! 86: # if !defined(USE_TTY_SIGPOLL) || !defined(USE_UDP_SIGPOLL)
! 87: # define USE_SIGIO
! 88: # endif
! 89:
! 90: # if defined(USE_SIGIO) && defined(USE_SIGPOLL)
! 91: # if SIGIO == SIGPOLL
! 92: # define USE_SIGIO
! 93: # undef USE_SIGPOLL
! 94: # endif /* SIGIO == SIGPOLL */
! 95: # endif /* USE_SIGIO && USE_SIGIO */
! 96:
! 97:
! 98: /*
! 99: * TTY initialization routines.
! 100: */
! 101: int
! 102: init_clock_sig(
! 103: struct refclockio *rio
! 104: )
! 105: {
! 106: # ifdef USE_TTY_SIGPOLL
! 107: {
! 108: /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
! 109: if (ioctl(rio->fd, I_SETSIG, S_INPUT) < 0)
! 110: {
! 111: msyslog(LOG_ERR,
! 112: "init_clock_sig: ioctl(I_SETSIG, S_INPUT) failed: %m");
! 113: return 1;
! 114: }
! 115: return 0;
! 116: }
! 117: # else
! 118: /*
! 119: * Special cases first!
! 120: */
! 121: /* Was: defined(SYS_HPUX) */
! 122: # if defined(FIOSSAIOOWN) && defined(FIOSNBIO) && defined(FIOSSAIOSTAT)
! 123: #define CLOCK_DONE
! 124: {
! 125: int pgrp, on = 1;
! 126:
! 127: /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
! 128: pgrp = getpid();
! 129: if (ioctl(rio->fd, FIOSSAIOOWN, (char *)&pgrp) == -1)
! 130: {
! 131: msyslog(LOG_ERR, "ioctl(FIOSSAIOOWN) fails for clock I/O: %m");
! 132: exit(1);
! 133: /*NOTREACHED*/
! 134: }
! 135:
! 136: /*
! 137: * set non-blocking, async I/O on the descriptor
! 138: */
! 139: if (ioctl(rio->fd, FIOSNBIO, (char *)&on) == -1)
! 140: {
! 141: msyslog(LOG_ERR, "ioctl(FIOSNBIO) fails for clock I/O: %m");
! 142: exit(1);
! 143: /*NOTREACHED*/
! 144: }
! 145:
! 146: if (ioctl(rio->fd, FIOSSAIOSTAT, (char *)&on) == -1)
! 147: {
! 148: msyslog(LOG_ERR, "ioctl(FIOSSAIOSTAT) fails for clock I/O: %m");
! 149: exit(1);
! 150: /*NOTREACHED*/
! 151: }
! 152: return 0;
! 153: }
! 154: # endif /* SYS_HPUX: FIOSSAIOOWN && FIOSNBIO && FIOSSAIOSTAT */
! 155: /* Was: defined(SYS_AIX) && !defined(_BSD) */
! 156: # if !defined(_BSD) && defined(_AIX) && defined(FIOASYNC) && defined(FIOSETOWN)
! 157: /*
! 158: * SYSV compatibility mode under AIX.
! 159: */
! 160: #define CLOCK_DONE
! 161: {
! 162: int pgrp, on = 1;
! 163:
! 164: /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
! 165: if (ioctl(rio->fd, FIOASYNC, (char *)&on) == -1)
! 166: {
! 167: msyslog(LOG_ERR, "ioctl(FIOASYNC) fails for clock I/O: %m");
! 168: return 1;
! 169: }
! 170: pgrp = -getpid();
! 171: if (ioctl(rio->fd, FIOSETOWN, (char*)&pgrp) == -1)
! 172: {
! 173: msyslog(LOG_ERR, "ioctl(FIOSETOWN) fails for clock I/O: %m");
! 174: return 1;
! 175: }
! 176:
! 177: if (fcntl(rio->fd, F_SETFL, FNDELAY|FASYNC) < 0)
! 178: {
! 179: msyslog(LOG_ERR, "fcntl(FNDELAY|FASYNC) fails for clock I/O: %m");
! 180: return 1;
! 181: }
! 182: return 0;
! 183: }
! 184: # endif /* AIX && !BSD: !_BSD && FIOASYNC && FIOSETOWN */
! 185: # ifndef CLOCK_DONE
! 186: {
! 187: /* DO NOT ATTEMPT TO MAKE CLOCK-FD A CTTY: not portable, unreliable */
! 188: # if defined(TIOCSCTTY) && defined(USE_FSETOWNCTTY)
! 189: /*
! 190: * there are, however, always exceptions to the rules
! 191: * one is, that OSF accepts SETOWN on TTY fd's only, iff they are
! 192: * CTTYs. SunOS and HPUX do not semm to have this restriction.
! 193: * another question is: how can you do multiple SIGIO from several
! 194: * ttys (as they all should be CTTYs), wondering...
! 195: *
! 196: * kd 95-07-16
! 197: */
! 198: if (ioctl(rio->fd, TIOCSCTTY, 0) == -1)
! 199: {
! 200: msyslog(LOG_ERR, "ioctl(TIOCSCTTY, 0) fails for clock I/O: %m");
! 201: return 1;
! 202: }
! 203: # endif /* TIOCSCTTY && USE_FSETOWNCTTY */
! 204:
! 205: if (fcntl(rio->fd, F_SETOWN, getpid()) == -1)
! 206: {
! 207: msyslog(LOG_ERR, "fcntl(F_SETOWN) fails for clock I/O: %m");
! 208: return 1;
! 209: }
! 210:
! 211: if (fcntl(rio->fd, F_SETFL, FNDELAY|FASYNC) < 0)
! 212: {
! 213: msyslog(LOG_ERR,
! 214: "fcntl(FNDELAY|FASYNC) fails for clock I/O: %m");
! 215: return 1;
! 216: }
! 217: return 0;
! 218: }
! 219: # endif /* CLOCK_DONE */
! 220: # endif /* !USE_TTY_SIGPOLL */
! 221: }
! 222:
! 223:
! 224:
! 225: void
! 226: init_socket_sig(
! 227: int fd
! 228: )
! 229: {
! 230: # ifdef USE_UDP_SIGPOLL
! 231: {
! 232: if (ioctl(fd, I_SETSIG, S_INPUT) < 0)
! 233: {
! 234: msyslog(LOG_ERR,
! 235: "init_socket_sig: ioctl(I_SETSIG, S_INPUT) failed: %m");
! 236: exit(1);
! 237: }
! 238: }
! 239: # else /* USE_UDP_SIGPOLL */
! 240: {
! 241: int pgrp;
! 242: # ifdef FIOASYNC
! 243: int on = 1;
! 244: # endif
! 245:
! 246: # if defined(FIOASYNC)
! 247: if (ioctl(fd, FIOASYNC, (char *)&on) == -1)
! 248: {
! 249: msyslog(LOG_ERR, "ioctl(FIOASYNC) fails: %m");
! 250: exit(1);
! 251: /*NOTREACHED*/
! 252: }
! 253: # elif defined(FASYNC)
! 254: {
! 255: int flags;
! 256:
! 257: if ((flags = fcntl(fd, F_GETFL, 0)) == -1)
! 258: {
! 259: msyslog(LOG_ERR, "fcntl(F_GETFL) fails: %m");
! 260: exit(1);
! 261: /*NOTREACHED*/
! 262: }
! 263: if (fcntl(fd, F_SETFL, flags|FASYNC) < 0)
! 264: {
! 265: msyslog(LOG_ERR, "fcntl(...|FASYNC) fails: %m");
! 266: exit(1);
! 267: /*NOTREACHED*/
! 268: }
! 269: }
! 270: # else
! 271: # include "Bletch: Need asynchronous I/O!"
! 272: # endif
! 273:
! 274: # ifdef UDP_BACKWARDS_SETOWN
! 275: pgrp = -getpid();
! 276: # else
! 277: pgrp = getpid();
! 278: # endif
! 279:
! 280: # if defined(SIOCSPGRP)
! 281: if (ioctl(fd, SIOCSPGRP, (char *)&pgrp) == -1)
! 282: {
! 283: msyslog(LOG_ERR, "ioctl(SIOCSPGRP) fails: %m");
! 284: exit(1);
! 285: /*NOTREACHED*/
! 286: }
! 287: # elif defined(FIOSETOWN)
! 288: if (ioctl(fd, FIOSETOWN, (char*)&pgrp) == -1)
! 289: {
! 290: msyslog(LOG_ERR, "ioctl(FIOSETOWN) fails: %m");
! 291: exit(1);
! 292: /*NOTREACHED*/
! 293: }
! 294: # elif defined(F_SETOWN)
! 295: if (fcntl(fd, F_SETOWN, pgrp) == -1)
! 296: {
! 297: msyslog(LOG_ERR, "fcntl(F_SETOWN) fails: %m");
! 298: exit(1);
! 299: /*NOTREACHED*/
! 300: }
! 301: # else
! 302: # include "Bletch: Need to set process(group) to receive SIG(IO|POLL)"
! 303: # endif
! 304: }
! 305: # endif /* USE_UDP_SIGPOLL */
! 306: }
! 307:
! 308: RETSIGTYPE
! 309: sigio_handler(
! 310: int sig
! 311: )
! 312: {
! 313: int saved_errno = errno;
! 314: l_fp ts;
! 315:
! 316: get_systime(&ts);
! 317:
! 318: # if defined(HAVE_SIGACTION)
! 319: sigio_handler_active++;
! 320: if (sigio_handler_active != 1) /* This should never happen! */
! 321: msyslog(LOG_ERR, "sigio_handler: sigio_handler_active != 1");
! 322: # endif
! 323:
! 324: (void)input_handler(&ts);
! 325:
! 326: # if defined(HAVE_SIGACTION)
! 327: sigio_handler_active--;
! 328: if (sigio_handler_active != 0) /* This should never happen! */
! 329: msyslog(LOG_ERR, "sigio_handler: sigio_handler_active != 0");
! 330: # endif
! 331:
! 332: errno = saved_errno;
! 333: }
! 334:
! 335: /*
! 336: * Signal support routines.
! 337: */
! 338: # ifdef HAVE_SIGACTION
! 339: void
! 340: set_signal(void)
! 341: {
! 342: # ifdef USE_SIGIO
! 343: (void) signal_no_reset(SIGIO, sigio_handler);
! 344: # endif
! 345: # ifdef USE_SIGPOLL
! 346: (void) signal_no_reset(SIGPOLL, sigio_handler);
! 347: # endif
! 348: }
! 349:
! 350: void
! 351: block_io_and_alarm(void)
! 352: {
! 353: sigset_t set;
! 354:
! 355: if (sigemptyset(&set))
! 356: msyslog(LOG_ERR, "block_io_and_alarm: sigemptyset() failed: %m");
! 357: # if defined(USE_SIGIO)
! 358: if (sigaddset(&set, SIGIO))
! 359: msyslog(LOG_ERR, "block_io_and_alarm: sigaddset(SIGIO) failed: %m");
! 360: # endif
! 361: # if defined(USE_SIGPOLL)
! 362: if (sigaddset(&set, SIGPOLL))
! 363: msyslog(LOG_ERR, "block_io_and_alarm: sigaddset(SIGPOLL) failed: %m");
! 364: # endif
! 365: if (sigaddset(&set, SIGALRM))
! 366: msyslog(LOG_ERR, "block_io_and_alarm: sigaddset(SIGALRM) failed: %m");
! 367:
! 368: if (sigprocmask(SIG_BLOCK, &set, NULL))
! 369: msyslog(LOG_ERR, "block_io_and_alarm: sigprocmask() failed: %m");
! 370: }
! 371:
! 372: void
! 373: block_sigio(void)
! 374: {
! 375: if ( sigio_handler_active == 0 ) /* not called from within signal handler */
! 376: {
! 377: sigset_t set;
! 378:
! 379: ++sigio_block_count;
! 380: if (sigio_block_count > 1)
! 381: msyslog(LOG_INFO, "block_sigio: sigio_block_count > 1");
! 382: if (sigio_block_count < 1)
! 383: msyslog(LOG_INFO, "block_sigio: sigio_block_count < 1");
! 384:
! 385: if (sigemptyset(&set))
! 386: msyslog(LOG_ERR, "block_sigio: sigemptyset() failed: %m");
! 387: # if defined(USE_SIGIO)
! 388: if (sigaddset(&set, SIGIO))
! 389: msyslog(LOG_ERR, "block_sigio: sigaddset(SIGIO) failed: %m");
! 390: # endif
! 391: # if defined(USE_SIGPOLL)
! 392: if (sigaddset(&set, SIGPOLL))
! 393: msyslog(LOG_ERR, "block_sigio: sigaddset(SIGPOLL) failed: %m");
! 394: # endif
! 395:
! 396: if (sigprocmask(SIG_BLOCK, &set, NULL))
! 397: msyslog(LOG_ERR, "block_sigio: sigprocmask() failed: %m");
! 398: }
! 399: }
! 400:
! 401: void
! 402: unblock_io_and_alarm(void)
! 403: {
! 404: sigset_t unset;
! 405:
! 406: if (sigemptyset(&unset))
! 407: msyslog(LOG_ERR, "unblock_io_and_alarm: sigemptyset() failed: %m");
! 408:
! 409: # if defined(USE_SIGIO)
! 410: if (sigaddset(&unset, SIGIO))
! 411: msyslog(LOG_ERR, "unblock_io_and_alarm: sigaddset(SIGIO) failed: %m");
! 412: # endif
! 413: # if defined(USE_SIGPOLL)
! 414: if (sigaddset(&unset, SIGPOLL))
! 415: msyslog(LOG_ERR, "unblock_io_and_alarm: sigaddset(SIGPOLL) failed: %m");
! 416: # endif
! 417: if (sigaddset(&unset, SIGALRM))
! 418: msyslog(LOG_ERR, "unblock_io_and_alarm: sigaddset(SIGALRM) failed: %m");
! 419:
! 420: if (sigprocmask(SIG_UNBLOCK, &unset, NULL))
! 421: msyslog(LOG_ERR, "unblock_io_and_alarm: sigprocmask() failed: %m");
! 422: }
! 423:
! 424: void
! 425: unblock_sigio(void)
! 426: {
! 427: if ( sigio_handler_active == 0 ) /* not called from within signal handler */
! 428: {
! 429: sigset_t unset;
! 430:
! 431: --sigio_block_count;
! 432: if (sigio_block_count > 0)
! 433: msyslog(LOG_INFO, "unblock_sigio: sigio_block_count > 0");
! 434: if (sigio_block_count < 0)
! 435: msyslog(LOG_INFO, "unblock_sigio: sigio_block_count < 0");
! 436:
! 437: if (sigemptyset(&unset))
! 438: msyslog(LOG_ERR, "unblock_sigio: sigemptyset() failed: %m");
! 439:
! 440: # if defined(USE_SIGIO)
! 441: if (sigaddset(&unset, SIGIO))
! 442: msyslog(LOG_ERR, "unblock_sigio: sigaddset(SIGIO) failed: %m");
! 443: # endif
! 444: # if defined(USE_SIGPOLL)
! 445: if (sigaddset(&unset, SIGPOLL))
! 446: msyslog(LOG_ERR, "unblock_sigio: sigaddset(SIGPOLL) failed: %m");
! 447: # endif
! 448:
! 449: if (sigprocmask(SIG_UNBLOCK, &unset, NULL))
! 450: msyslog(LOG_ERR, "unblock_sigio: sigprocmask() failed: %m");
! 451: }
! 452: }
! 453:
! 454: void
! 455: wait_for_signal(void)
! 456: {
! 457: sigset_t old;
! 458:
! 459: if (sigprocmask(SIG_UNBLOCK, NULL, &old))
! 460: msyslog(LOG_ERR, "wait_for_signal: sigprocmask() failed: %m");
! 461:
! 462: # if defined(USE_SIGIO)
! 463: if (sigdelset(&old, SIGIO))
! 464: msyslog(LOG_ERR, "wait_for_signal: sigdelset(SIGIO) failed: %m");
! 465: # endif
! 466: # if defined(USE_SIGPOLL)
! 467: if (sigdelset(&old, SIGPOLL))
! 468: msyslog(LOG_ERR, "wait_for_signal: sigdelset(SIGPOLL) failed: %m");
! 469: # endif
! 470: if (sigdelset(&old, SIGALRM))
! 471: msyslog(LOG_ERR, "wait_for_signal: sigdelset(SIGALRM) failed: %m");
! 472:
! 473: if (sigsuspend(&old) && (errno != EINTR))
! 474: msyslog(LOG_ERR, "wait_for_signal: sigsuspend() failed: %m");
! 475: }
! 476:
! 477: # else /* !HAVE_SIGACTION */
! 478: /*
! 479: * Must be an old bsd system.
! 480: * We assume there is no SIGPOLL.
! 481: */
! 482:
! 483: void
! 484: block_io_and_alarm(void)
! 485: {
! 486: int mask;
! 487:
! 488: mask = sigmask(SIGIO) | sigmask(SIGALRM);
! 489: if (sigblock(mask))
! 490: msyslog(LOG_ERR, "block_io_and_alarm: sigblock() failed: %m");
! 491: }
! 492:
! 493: void
! 494: block_sigio(void)
! 495: {
! 496: int mask;
! 497:
! 498: ++sigio_block_count;
! 499: if (sigio_block_count > 1)
! 500: msyslog(LOG_INFO, "block_sigio: sigio_block_count > 1");
! 501: if (sigio_block_count < 1)
! 502: msyslog(LOG_INFO, "block_sigio: sigio_block_count < 1");
! 503:
! 504: mask = sigmask(SIGIO);
! 505: if (sigblock(mask))
! 506: msyslog(LOG_ERR, "block_sigio: sigblock() failed: %m");
! 507: }
! 508:
! 509: void
! 510: set_signal(void)
! 511: {
! 512: (void) signal_no_reset(SIGIO, sigio_handler);
! 513: }
! 514:
! 515: void
! 516: unblock_io_and_alarm(void)
! 517: {
! 518: int mask, omask;
! 519:
! 520: mask = sigmask(SIGIO) | sigmask(SIGALRM);
! 521: omask = sigblock(0);
! 522: omask &= ~mask;
! 523: (void) sigsetmask(omask);
! 524: }
! 525:
! 526: void
! 527: unblock_sigio(void)
! 528: {
! 529: int mask, omask;
! 530:
! 531: --sigio_block_count;
! 532: if (sigio_block_count > 0)
! 533: msyslog(LOG_INFO, "unblock_sigio: sigio_block_count > 0");
! 534: if (sigio_block_count < 0)
! 535: msyslog(LOG_INFO, "unblock_sigio: sigio_block_count < 0");
! 536: mask = sigmask(SIGIO);
! 537: omask = sigblock(0);
! 538: omask &= ~mask;
! 539: (void) sigsetmask(omask);
! 540: }
! 541:
! 542: void
! 543: wait_for_signal(void)
! 544: {
! 545: int mask, omask;
! 546:
! 547: mask = sigmask(SIGIO) | sigmask(SIGALRM);
! 548: omask = sigblock(0);
! 549: omask &= ~mask;
! 550: if (sigpause(omask) && (errno != EINTR))
! 551: msyslog(LOG_ERR, "wait_for_signal: sigspause() failed: %m");
! 552: }
! 553:
! 554: # endif /* HAVE_SIGACTION */
! 555: #else
! 556: int NotAnEmptyCompilationUnit;
! 557: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iosignal.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libntp