![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ns_main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / named|
Return to ns_main.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.sbin / named |
1.1 ! root 1: /* ! 2: * Copyright (c) 1986, 1989, 1990 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted provided ! 6: * that: (1) source distributions retain this entire copyright notice and ! 7: * comment, and (2) distributions including binaries display the following ! 8: * acknowledgement: ``This product includes software developed by the ! 9: * University of California, Berkeley and its contributors'' in the ! 10: * documentation or other materials provided with the distribution and in ! 11: * all advertising materials mentioning features or use of this software. ! 12: * Neither the name of the University nor the names of its contributors may ! 13: * be used to endorse or promote products derived from this software without ! 14: * specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #ifndef lint ! 21: char copyright[] = ! 22: "@(#) Copyright (c) 1986, 1989, 1990 Regents of the University of California.\n\ ! 23: All rights reserved.\n"; ! 24: #endif /* not lint */ ! 25: ! 26: #ifndef lint ! 27: static char sccsid[] = "@(#)ns_main.c 4.50 (Berkeley) 6/29/90"; ! 28: #endif /* not lint */ ! 29: ! 30: /* ! 31: * Internet Name server (see rfc883 & others). ! 32: */ ! 33: ! 34: #include <sys/param.h> ! 35: #if defined(SYSV) ! 36: #include <fcntl.h> ! 37: #endif SYSV ! 38: #include <sys/file.h> ! 39: #include <sys/time.h> ! 40: #if !defined(SYSV) ! 41: #include <sys/wait.h> ! 42: #endif !SYSV ! 43: #include <sys/resource.h> ! 44: #include <sys/ioctl.h> ! 45: #include <sys/socket.h> ! 46: #include <netinet/in.h> ! 47: #include <net/if.h> ! 48: #include <stdio.h> ! 49: #include <syslog.h> ! 50: #include <errno.h> ! 51: #include <signal.h> ! 52: #include <netdb.h> ! 53: #include <arpa/nameser.h> ! 54: #include <arpa/inet.h> ! 55: #include <resolv.h> ! 56: #undef nsaddr /* XXX */ ! 57: #include "ns.h" ! 58: #include "db.h" ! 59: #include "pathnames.h" ! 60: ! 61: #ifdef BOOTFILE /* default boot file */ ! 62: char *bootfile = BOOTFILE; ! 63: #else ! 64: char *bootfile = _PATH_BOOT; ! 65: #endif ! 66: ! 67: #ifdef DEBUGFILE /* default debug output file */ ! 68: char *debugfile = DEBUGFILE; ! 69: #else ! 70: char *debugfile = _PATH_DEBUG; ! 71: #endif ! 72: ! 73: #ifdef PIDFILE /* file to store current named PID */ ! 74: char *PidFile = PIDFILE; ! 75: #else ! 76: char *PidFile = _PATH_PIDFILE; ! 77: #endif ! 78: ! 79: #ifndef FD_SET ! 80: #define NFDBITS 32 ! 81: #define FD_SETSIZE 32 ! 82: #define FD_SET(n, p) ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS))) ! 83: #define FD_CLR(n, p) ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS))) ! 84: #define FD_ISSET(n, p) ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS))) ! 85: #define FD_ZERO(p) bzero((char *)(p), sizeof(*(p))) ! 86: #endif ! 87: ! 88: FILE *fp; /* file descriptor for pid file */ ! 89: ! 90: #ifdef DEBUG ! 91: FILE *ddt; ! 92: #endif ! 93: ! 94: int debug = 0; /* debugging flag */ ! 95: int ds; /* datagram socket */ ! 96: int needreload = 0; /* received SIGHUP, need to reload db */ ! 97: int needmaint = 0; /* need to call ns_maint()*/ ! 98: int needzoneload = 0; /* need to reload secondary zone(s) */ ! 99: int needToDoadump = 0; /* need to dump database */ ! 100: int needToChkpt = 0; /* need to checkpoint cache */ ! 101: int needStatsDump = 0; /* need to dump statistics */ ! 102: #ifdef ALLOW_UPDATES ! 103: int needToExit = 0; /* need to exit (may need to doadump ! 104: * first, if database has changed since ! 105: * it was last dumped/booted). Gets ! 106: * set by shutdown signal handler ! 107: * (onintr) ! 108: */ ! 109: #endif ALLOW_UPDATES ! 110: ! 111: int priming = 0; /* is cache being primed */ ! 112: ! 113: #ifdef SO_RCVBUF ! 114: int rbufsize = 8 * 1024; /* UDP recive buffer size */ ! 115: #endif ! 116: ! 117: struct qstream *streamq = QSTREAM_NULL; /* list of open streams */ ! 118: struct qdatagram *datagramq = QDATAGRAM_NULL; /* list of datagram interfaces */ ! 119: struct sockaddr_in nsaddr; ! 120: struct timeval tt; ! 121: /* ! 122: * We keep a list of favored networks headed by nettab. ! 123: * There are three (possibly empty) parts to this list, in this order: ! 124: * 1. directly attached (sub)nets. ! 125: * 2. logical networks for directly attached subnetted networks. ! 126: * 3. networks from the sort list. ! 127: * The value (*elocal) points at the first entry in the second part of the list, ! 128: * if any, while (*enettab) points at the first entry in the sort list. ! 129: */ ! 130: struct netinfo *nettab = NULL; ! 131: struct netinfo **elocal = &nettab; ! 132: struct netinfo **enettab = &nettab; ! 133: struct netinfo netloop; ! 134: struct netinfo *findnetinfo(); ! 135: u_long net_mask(); ! 136: u_short ns_port; ! 137: struct sockaddr_in from_addr; /* Source addr of last packet */ ! 138: int from_len; /* Source addr size of last packet */ ! 139: time_t boottime, resettime; /* Used by ns_stats */ ! 140: static fd_set mask; /* select mask of open descriptors */ ! 141: static int vs; /* listening TCP socket */ ! 142: ! 143: char **Argv = NULL; /* pointer to argument vector */ ! 144: char *LastArg = NULL; /* end of argv */ ! 145: ! 146: extern int errno; ! 147: ! 148: #if defined(SYSV) ! 149: getdtablesize() ! 150: { ! 151: return(FD_SETSIZE); ! 152: } ! 153: #endif SYSV ! 154: ! 155: main(argc, argv, envp) ! 156: int argc; ! 157: char *argv[], *envp[]; ! 158: { ! 159: register int n, udpcnt; ! 160: register char *arg; ! 161: register struct qstream *sp; ! 162: register struct qdatagram *dqp; ! 163: struct qstream *nextsp; ! 164: int nfds; ! 165: int on = 1; ! 166: int rfd, size; ! 167: u_long lasttime, maxctime; ! 168: char buf[BUFSIZ]; ! 169: #ifndef SYSV ! 170: struct sigvec vec; ! 171: #endif ! 172: ! 173: fd_set tmpmask; ! 174: ! 175: struct timeval t, *tp; ! 176: struct qstream *candidate = QSTREAM_NULL; ! 177: extern VOID onintr(), maint_alarm(), endxfer(); ! 178: extern VOID setdumpflg(), onhup(); ! 179: extern VOID setIncrDbgFlg(), setNoDbgFlg(), sigprof(); ! 180: extern VOID setchkptflg(), setstatsflg(); ! 181: extern int loadxfer(); ! 182: extern struct qstream *sqadd(); ! 183: extern struct qinfo *qhead; ! 184: extern char Version[]; ! 185: ! 186: ns_port = htons(NAMESERVER_PORT); ! 187: ! 188: /* ! 189: ** Save start and extent of argv for setproctitle. ! 190: */ ! 191: ! 192: Argv = argv; ! 193: if (envp == 0 || *envp == 0) ! 194: envp = argv; ! 195: while (*envp) ! 196: envp++; ! 197: LastArg = envp[-1] + strlen(envp[-1]); ! 198: ! 199: (void) umask(022); ! 200: while (--argc > 0) { ! 201: arg = *++argv; ! 202: if (*arg == '-') { ! 203: while (*++arg) ! 204: switch (*arg) { ! 205: case 'b': ! 206: if (--argc <= 0) ! 207: usage(); ! 208: bootfile = *++argv; ! 209: break; ! 210: ! 211: case 'd': ! 212: ++argv; ! 213: ! 214: if (*argv != 0) { ! 215: if (**argv == '-') { ! 216: argv--; ! 217: break; ! 218: } ! 219: debug = atoi(*argv); ! 220: --argc; ! 221: } ! 222: if (debug <= 0) ! 223: debug = 1; ! 224: setdebug(1); ! 225: break; ! 226: ! 227: case 'p': ! 228: if (--argc <= 0) ! 229: usage(); ! 230: ns_port = htons((u_short)atoi(*++argv)); ! 231: break; ! 232: ! 233: default: ! 234: usage(); ! 235: } ! 236: } else ! 237: bootfile = *argv; ! 238: } ! 239: ! 240: if (!debug) ! 241: for (n = getdtablesize() - 1; n > 2; n--) ! 242: (void) close(n); ! 243: #ifdef DEBUG ! 244: else { ! 245: fprintf(ddt,"Debug turned ON, Level %d\n",debug); ! 246: fprintf(ddt,"Version = %s\t",Version); ! 247: fprintf(ddt,"bootfile = %s\n",bootfile); ! 248: } ! 249: #endif ! 250: ! 251: #ifdef LOG_DAEMON ! 252: openlog("named", LOG_PID|LOG_CONS|LOG_NDELAY, LOG_DAEMON); ! 253: #else ! 254: openlog("named", LOG_PID); ! 255: #endif ! 256: ! 257: /* tuck my process id away */ ! 258: fp = fopen(PidFile, "w"); ! 259: if (fp != NULL) { ! 260: fprintf(fp, "%d\n", getpid()); ! 261: (void) fclose(fp); ! 262: } ! 263: syslog(LOG_NOTICE, "restarted\n"); ! 264: ! 265: _res.options &= ~(RES_DEFNAMES | RES_DNSRCH | RES_RECURSE); ! 266: ! 267: nsaddr.sin_family = AF_INET; ! 268: nsaddr.sin_addr.s_addr = INADDR_ANY; ! 269: nsaddr.sin_port = ns_port; ! 270: ! 271: /* ! 272: ** Open stream port. ! 273: */ ! 274: if ((vs = socket(AF_INET, SOCK_STREAM, 0)) < 0) { ! 275: syslog(LOG_ERR, "socket(SOCK_STREAM): %m"); ! 276: exit(1); ! 277: } ! 278: (void)setsockopt(vs, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)); ! 279: if (bind(vs, (struct sockaddr *)&nsaddr, sizeof(nsaddr))) { ! 280: syslog(LOG_ERR, "bind(vs, %s[%d]): %m", ! 281: inet_ntoa(nsaddr.sin_addr), ntohs(nsaddr.sin_port)); ! 282: exit(1); ! 283: } ! 284: (void) listen(vs, 5); ! 285: ! 286: /* ! 287: * Get list of local addresses and set up datagram sockets. ! 288: */ ! 289: getnetconf(); ! 290: ! 291: /* ! 292: ** Initialize and load database. ! 293: */ ! 294: gettime(&tt); ! 295: buildservicelist(); ! 296: buildprotolist(); ! 297: ns_init(bootfile); ! 298: #ifdef DEBUG ! 299: if (debug) { ! 300: fprintf(ddt, "Network and sort list:\n"); ! 301: printnetinfo(nettab); ! 302: } ! 303: #endif DEBUG ! 304: ! 305: time(&boottime); ! 306: resettime = boottime; ! 307: ! 308: (void) signal(SIGHUP, onhup); ! 309: #if defined(SYSV) ! 310: (void) signal(SIGCLD, endxfer); ! 311: (void) signal(SIGALRM, maint_alarm); ! 312: #else ! 313: bzero((char *)&vec, sizeof(vec)); ! 314: vec.sv_handler = maint_alarm; ! 315: vec.sv_mask = sigmask(SIGCHLD); ! 316: (void) sigvec(SIGALRM, &vec, (struct sigvec *)NULL); ! 317: ! 318: vec.sv_handler = endxfer; ! 319: vec.sv_mask = sigmask(SIGALRM); ! 320: (void) sigvec(SIGCHLD, &vec, (struct sigvec *)NULL); ! 321: #endif SYSV ! 322: (void) signal(SIGPIPE, SIG_IGN); ! 323: (void) signal(SIGSYS, sigprof); ! 324: (void) signal(SIGINT, setdumpflg); ! 325: (void) signal(SIGQUIT, setchkptflg); ! 326: (void) signal(SIGIOT, setstatsflg); ! 327: ! 328: #ifdef ALLOW_UPDATES ! 329: /* Catch SIGTERM so we can dump the database upon shutdown if it ! 330: has changed since it was last dumped/booted */ ! 331: (void) signal(SIGTERM, onintr); ! 332: #endif ALLOW_UPDATES ! 333: ! 334: #if defined(SIGUSR1) && defined(SIGUSR2) ! 335: (void) signal(SIGUSR1, setIncrDbgFlg); ! 336: (void) signal(SIGUSR2, setNoDbgFlg); ! 337: #else SIGUSR1&&SIGUSR2 ! 338: (void) signal(SIGEMT, setIncrDbgFlg); ! 339: (void) signal(SIGFPE, setNoDbgFlg); ! 340: #endif SIGUSR1&&SIGUSR2 ! 341: ! 342: #ifdef DEBUG ! 343: if (debug) { ! 344: fprintf(ddt,"database initialized\n"); ! 345: } ! 346: #endif ! 347: ! 348: t.tv_usec = 0; ! 349: ! 350: /* ! 351: * Fork and go into background now that ! 352: * we've done any slow initialization ! 353: * and are ready to answer queries. ! 354: */ ! 355: if (!debug) { ! 356: #if defined(BSD) && BSD >= 199006 ! 357: daemon(1, 0); ! 358: #else ! 359: if (fork() > 0) ! 360: exit(0); ! 361: n = open(_PATH_DEVNULL, O_RDONLY); ! 362: (void) dup2(n, 0); ! 363: (void) dup2(n, 1); ! 364: (void) dup2(n, 2); ! 365: if (n > 2) ! 366: (void) close(n); ! 367: #ifdef SYSV ! 368: setpgrp(); ! 369: #else ! 370: { ! 371: struct itimerval ival; ! 372: ! 373: /* ! 374: * The open below may hang on pseudo ttys if the person ! 375: * who starts named logs out before this point. ! 376: * ! 377: * needmaint may get set inapropriately if the open ! 378: * hangs, but all that will happen is we will see that ! 379: * no maintenance is required. ! 380: */ ! 381: bzero((char *)&ival, sizeof(ival)); ! 382: ival.it_value.tv_sec = 120; ! 383: (void) setitimer(ITIMER_REAL, &ival, ! 384: (struct itimerval *)NULL); ! 385: n = open(_PATH_TTY, O_RDWR); ! 386: ival.it_value.tv_sec = 0; ! 387: (void) setitimer(ITIMER_REAL, &ival, ! 388: (struct itimerval *)NULL); ! 389: if (n > 0) { ! 390: (void) ioctl(n, TIOCNOTTY, (char *)NULL); ! 391: (void) close(n); ! 392: } ! 393: } ! 394: #endif /* SYSV */ ! 395: #endif /* BSD > 199006 */ ! 396: } ! 397: /* tuck my process id away again */ ! 398: fp = fopen(PidFile, "w"); ! 399: if (fp != NULL) { ! 400: fprintf(fp, "%d\n", getpid()); ! 401: (void) fclose(fp); ! 402: } ! 403: ! 404: #ifdef DEBUG ! 405: if (debug) ! 406: fprintf(ddt,"Ready to answer queries.\n"); ! 407: #endif ! 408: prime_cache(); ! 409: nfds = getdtablesize(); /* get the number of file descriptors */ ! 410: if (nfds > FD_SETSIZE) { ! 411: nfds = FD_SETSIZE; /* Bulletproofing */ ! 412: syslog(LOG_ERR, "Return from getdtablesize() > FD_SETSIZE"); ! 413: #ifdef DEBUG ! 414: if (debug) ! 415: fprintf(ddt,"Return from getdtablesize() > FD_SETSIZE\n"); ! 416: #endif ! 417: } ! 418: FD_ZERO(&mask); ! 419: FD_SET(vs, &mask); ! 420: for (dqp = datagramq; dqp != QDATAGRAM_NULL; dqp = dqp->dq_next) ! 421: FD_SET(dqp->dq_dfd, &mask); ! 422: for (;;) { ! 423: #ifdef DEBUG ! 424: if (ddt && debug == 0) { ! 425: fprintf(ddt,"Debug turned OFF\n"); ! 426: (void) fclose(ddt); ! 427: ddt = 0; ! 428: } ! 429: #endif ! 430: #ifdef ALLOW_UPDATES ! 431: if (needToExit) { ! 432: struct zoneinfo *zp; ! 433: sigblock(~0); /* ! 434: * Block all blockable signals ! 435: * to ensure a consistant ! 436: * state during final dump ! 437: */ ! 438: #ifdef DEBUG ! 439: if (debug) ! 440: fprintf(ddt, "Received shutdown signal\n"); ! 441: #endif DEBUG ! 442: for (zp = zones; zp < &zones[nzones]; zp++) { ! 443: if (zp->hasChanged) ! 444: zonedump(zp); ! 445: } ! 446: exit(0); ! 447: } ! 448: #endif ALLOW_UPDATES ! 449: if (needreload) { ! 450: needreload = 0; ! 451: db_reload(); ! 452: } ! 453: #ifdef STATS ! 454: if (needStatsDump) { ! 455: needStatsDump = 0; ! 456: ns_stats(); ! 457: } ! 458: #endif STATS ! 459: if (needzoneload) { ! 460: needzoneload = 0; ! 461: loadxfer(); ! 462: } ! 463: if (needmaint) { ! 464: needmaint = 0; ! 465: ns_maint(); ! 466: } ! 467: if(needToChkpt) { ! 468: needToChkpt = 0; ! 469: doachkpt(); ! 470: } ! 471: if(needToDoadump) { ! 472: needToDoadump = 0; ! 473: doadump(); ! 474: } ! 475: /* ! 476: ** Wait until a query arrives ! 477: */ ! 478: if (retryqp != NULL) { ! 479: gettime(&tt); ! 480: t.tv_sec = (long) retryqp->q_time - tt.tv_sec; ! 481: if (t.tv_sec <= 0) { ! 482: retry(retryqp); ! 483: continue; ! 484: } ! 485: tp = &t; ! 486: } else ! 487: tp = NULL; ! 488: tmpmask = mask; ! 489: n = select(nfds, &tmpmask, (fd_set *)NULL, (fd_set *)NULL, tp); ! 490: if (n < 0) { ! 491: if (errno == EINTR) ! 492: continue; ! 493: syslog(LOG_ERR, "select: %m"); ! 494: #ifdef DEBUG ! 495: if (debug) ! 496: fprintf(ddt,"select error\n"); ! 497: #endif ! 498: ; ! 499: } ! 500: if (n == 0) ! 501: continue; ! 502: ! 503: for (dqp = datagramq; dqp != QDATAGRAM_NULL; ! 504: dqp = dqp->dq_next) { ! 505: if (FD_ISSET(dqp->dq_dfd, &tmpmask)) ! 506: for(udpcnt = 0; udpcnt < 25; udpcnt++) { ! 507: from_len = sizeof(from_addr); ! 508: if ((n = recvfrom(dqp->dq_dfd, buf, sizeof(buf), 0, ! 509: (struct sockaddr *)&from_addr, &from_len)) < 0) ! 510: { ! 511: if ((n == -1) && (errno == EWOULDBLOCK)) ! 512: break; ! 513: syslog(LOG_WARNING, "recvfrom: %m"); ! 514: break; ! 515: } ! 516: #ifdef STATS ! 517: stats[S_INPKTS].cnt++; ! 518: #endif ! 519: #ifdef DEBUG ! 520: if (debug) ! 521: fprintf(ddt, ! 522: "\ndatagram from %s port %d, fd %d, len %d\n", ! 523: inet_ntoa(from_addr.sin_addr), ! 524: ntohs(from_addr.sin_port), dqp->dq_dfd, n); ! 525: if (debug >= 10) ! 526: fp_query(buf, ddt); ! 527: #endif ! 528: /* ! 529: * Consult database to get the answer. ! 530: */ ! 531: gettime(&tt); ! 532: ns_req(buf, n, PACKETSZ, QSTREAM_NULL, &from_addr, ! 533: dqp->dq_dfd); ! 534: } ! 535: } ! 536: /* ! 537: ** Process stream connection ! 538: */ ! 539: if (FD_ISSET(vs, &tmpmask)) { ! 540: from_len = sizeof(from_addr); ! 541: rfd = accept(vs, (struct sockaddr *)&from_addr, &from_len); ! 542: gettime(&tt); ! 543: if (rfd < 0 && errno == EMFILE && streamq != NULL) { ! 544: maxctime = 0; ! 545: candidate = QSTREAM_NULL; ! 546: for (sp = streamq; sp != QSTREAM_NULL; ! 547: sp = nextsp) { ! 548: nextsp = sp->s_next; ! 549: if (sp->s_refcnt != 0) ! 550: continue; ! 551: lasttime = tt.tv_sec - sp->s_time; ! 552: if (lasttime >= 900) ! 553: sqrm(sp); ! 554: else if (lasttime > maxctime) { ! 555: candidate = sp; ! 556: maxctime = lasttime; ! 557: } ! 558: } ! 559: rfd = accept(vs, (struct sockaddr *)&from_addr, &from_len); ! 560: if ((rfd < 0) && (errno == EMFILE) && ! 561: candidate != QSTREAM_NULL) { ! 562: sqrm(candidate); ! 563: rfd = accept(vs, (struct sockaddr *)&from_addr, &from_len); ! 564: } ! 565: } ! 566: if (rfd < 0) { ! 567: syslog(LOG_WARNING, "accept: %m"); ! 568: continue; ! 569: } ! 570: (void) fcntl(rfd, F_SETFL, FNDELAY); ! 571: (void) setsockopt(rfd, SOL_SOCKET, SO_KEEPALIVE, ! 572: (char *)&on, sizeof(on)); ! 573: if ((sp = sqadd()) == QSTREAM_NULL) { ! 574: (void) close(rfd); ! 575: continue; ! 576: } ! 577: sp->s_rfd = rfd; /* stream file descriptor */ ! 578: sp->s_size = -1; /* amount of data to receive */ ! 579: gettime(&tt); ! 580: sp->s_time = tt.tv_sec; /* last transaction time */ ! 581: sp->s_from = from_addr; /* address to respond to */ ! 582: sp->s_bufp = (char *)&sp->s_tempsize; ! 583: FD_SET(rfd, &mask); ! 584: FD_SET(rfd, &tmpmask); ! 585: #ifdef DEBUG ! 586: if (debug) { ! 587: fprintf(ddt, ! 588: "\nTCP connection from %s port %d (fd %d)\n", ! 589: inet_ntoa(sp->s_from.sin_addr), ! 590: ntohs(sp->s_from.sin_port), rfd); ! 591: } ! 592: #endif ! 593: } ! 594: #ifdef DEBUG ! 595: if (debug > 2 && streamq) ! 596: fprintf(ddt,"streamq = x%x\n",streamq); ! 597: #endif ! 598: if (streamq != NULL) { ! 599: for (sp = streamq; sp != QSTREAM_NULL; sp = nextsp) { ! 600: nextsp = sp->s_next; ! 601: if (FD_ISSET(sp->s_rfd, &tmpmask)) { ! 602: #ifdef DEBUG ! 603: if (debug > 5) { ! 604: fprintf(ddt, ! 605: "sp x%x rfd %d size %d time %d ", ! 606: sp, sp->s_rfd, sp->s_size, ! 607: sp->s_time ); ! 608: fprintf(ddt," next x%x \n", sp->s_next ); ! 609: fprintf(ddt,"\tbufsize %d",sp->s_bufsize); ! 610: fprintf(ddt," buf x%x ",sp->s_buf); ! 611: fprintf(ddt," bufp x%x\n",sp->s_bufp); ! 612: } ! 613: #endif DEBUG ! 614: if (sp->s_size < 0) { ! 615: size = sizeof(u_short) - ! 616: (sp->s_bufp - (char *)&sp->s_tempsize); ! 617: while (size > 0 && ! 618: (n = read(sp->s_rfd, sp->s_bufp, size)) > 0){ ! 619: sp->s_bufp += n; ! 620: size -= n; ! 621: } ! 622: if ((n == -1) && (errno == EWOULDBLOCK)) ! 623: continue; ! 624: if (n <= 0) { ! 625: sqrm(sp); ! 626: continue; ! 627: } ! 628: if ((sp->s_bufp - (char *)&sp->s_tempsize) == ! 629: sizeof(u_short)) { ! 630: sp->s_size = htons(sp->s_tempsize); ! 631: if (sp->s_bufsize == 0) { ! 632: if ( (sp->s_buf = malloc(BUFSIZ)) ! 633: == NULL) { ! 634: sp->s_buf = buf; ! 635: sp->s_size = sizeof(buf); ! 636: } else { ! 637: sp->s_bufsize = BUFSIZ; ! 638: } ! 639: } ! 640: if (sp->s_size > sp->s_bufsize && ! 641: sp->s_bufsize != 0) { ! 642: if ((sp->s_buf = realloc( ! 643: (char *)sp->s_buf, ! 644: (unsigned)sp->s_size)) == NULL){ ! 645: sp->s_buf = buf; ! 646: sp->s_bufsize = 0; ! 647: sp->s_size = sizeof(buf); ! 648: } else { ! 649: sp->s_bufsize = sp->s_size; ! 650: } ! 651: } ! 652: sp->s_bufp = sp->s_buf; ! 653: } ! 654: } ! 655: gettime(&tt); ! 656: sp->s_time = tt.tv_sec; ! 657: while (sp->s_size > 0 && ! 658: (n = read(sp->s_rfd, sp->s_bufp, sp->s_size)) > 0) ! 659: { ! 660: sp->s_bufp += n; ! 661: sp->s_size -= n; ! 662: } ! 663: /* ! 664: * we don't have enough memory for the query. ! 665: * if we have a query id, then we will send an ! 666: * error back to the user. ! 667: */ ! 668: if (sp->s_bufsize == 0 && ! 669: (sp->s_bufp - sp->s_buf > sizeof(u_short))) { ! 670: HEADER *hp; ! 671: ! 672: hp = (HEADER *)sp->s_buf; ! 673: hp->qr = 1; ! 674: hp->ra = 1; ! 675: hp->ancount = 0; ! 676: hp->qdcount = 0; ! 677: hp->nscount = 0; ! 678: hp->arcount = 0; ! 679: hp->rcode = SERVFAIL; ! 680: (void) writemsg(sp->s_rfd, sp->s_buf, ! 681: sizeof(HEADER)); ! 682: continue; ! 683: } ! 684: if ((n == -1) && (errno == EWOULDBLOCK)) ! 685: continue; ! 686: if (n <= 0) { ! 687: sqrm(sp); ! 688: continue; ! 689: } ! 690: /* ! 691: * Consult database to get the answer. ! 692: */ ! 693: if (sp->s_size == 0) { ! 694: sq_query(sp); ! 695: ns_req(sp->s_buf, ! 696: sp->s_bufp - sp->s_buf, ! 697: sp->s_bufsize, sp, ! 698: &sp->s_from, -1); ! 699: sp->s_bufp = (char *)&sp->s_tempsize; ! 700: sp->s_size = -1; ! 701: continue; ! 702: } ! 703: } ! 704: } ! 705: } ! 706: } ! 707: /* NOTREACHED */ ! 708: } ! 709: ! 710: usage() ! 711: { ! 712: fprintf(stderr, "Usage: named [-d #] [-p port] [{-b} bootfile]\n"); ! 713: exit(1); ! 714: } ! 715: ! 716: getnetconf() ! 717: { ! 718: register struct netinfo *ntp; ! 719: struct netinfo *ontp; ! 720: struct ifconf ifc; ! 721: struct ifreq ifreq, *ifr; ! 722: struct qdatagram *dqp; ! 723: static int first = 1; ! 724: char buf[BUFSIZ], *cp, *cplim; ! 725: u_long nm; ! 726: ! 727: ifc.ifc_len = sizeof(buf); ! 728: ifc.ifc_buf = buf; ! 729: if (ioctl(vs, SIOCGIFCONF, (char *)&ifc) < 0) { ! 730: syslog(LOG_ERR, "get interface configuration: %m"); ! 731: exit(1); ! 732: } ! 733: ntp = NULL; ! 734: #ifdef AF_LINK ! 735: #define max(a, b) (a > b ? a : b) ! 736: #define size(p) max((p).sa_len, sizeof(p)) ! 737: #else ! 738: #define size(p) (sizeof (p)) ! 739: #endif ! 740: cplim = buf + ifc.ifc_len; /*skip over if's with big ifr_addr's */ ! 741: for (cp = buf; cp < cplim; ! 742: cp += sizeof (ifr->ifr_name) + size(ifr->ifr_addr)) { ! 743: #undef size ! 744: ifr = (struct ifreq *)cp; ! 745: if (ifr->ifr_addr.sa_family != AF_INET) ! 746: continue; ! 747: ifreq = *ifr; ! 748: /* ! 749: * Don't test IFF_UP, packets may still be received at this ! 750: * address if any other interface is up. ! 751: */ ! 752: if (ioctl(vs, SIOCGIFADDR, (char *)&ifreq) < 0) { ! 753: syslog(LOG_ERR, "get interface addr: %m"); ! 754: continue; ! 755: } ! 756: /* build datagram queue */ ! 757: /* ! 758: * look for an already existing source interface address. ! 759: * This happens mostly when reinitializing. Also, if ! 760: * the machine has multiple point to point interfaces, then ! 761: * the local address may appear more than once. ! 762: */ ! 763: for (dqp=datagramq; dqp != NULL; dqp = dqp->dq_next) ! 764: if (((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr ! 765: == dqp->dq_addr.s_addr) { ! 766: #ifdef DEBUG ! 767: if (debug) ! 768: fprintf(ddt, "dup interface address %s on %s\n", ! 769: inet_ntoa(dqp->dq_addr), ifreq.ifr_name); ! 770: #endif ! 771: break; ! 772: } ! 773: if (dqp != NULL) ! 774: continue; ! 775: ! 776: if ((dqp = (struct qdatagram *)calloc(1, ! 777: sizeof(struct qdatagram))) == NULL) { ! 778: #ifdef DEBUG ! 779: if (debug >= 5) ! 780: fprintf(ddt,"getnetconf: malloc error\n"); ! 781: #endif ! 782: syslog(LOG_ERR, "getnetconf: Out Of Memory"); ! 783: exit(12); ! 784: } ! 785: dqp->dq_next = datagramq; ! 786: datagramq = dqp; ! 787: dqp->dq_addr = ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr; ! 788: opensocket(dqp); ! 789: ! 790: /* ! 791: * Add interface to list of directly-attached (sub)nets ! 792: * for use in sorting addresses. ! 793: */ ! 794: if (ntp == NULL) ! 795: ntp = (struct netinfo *)malloc(sizeof(struct netinfo)); ! 796: ntp->my_addr = ! 797: ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr; ! 798: #ifdef SIOCGIFNETMASK ! 799: if (ioctl(vs, SIOCGIFNETMASK, (char *)&ifreq) < 0) { ! 800: syslog(LOG_ERR, "get netmask: %m"); ! 801: ntp->mask = net_mask(ntp->my_addr); ! 802: } else ! 803: ntp->mask = ((struct sockaddr_in *) ! 804: &ifreq.ifr_addr)->sin_addr.s_addr; ! 805: #else ! 806: /* 4.2 does not support subnets */ ! 807: ntp->mask = net_mask(ntp->my_addr); ! 808: #endif ! 809: if (ioctl(vs, SIOCGIFFLAGS, (char *)&ifreq) < 0) { ! 810: syslog(LOG_ERR, "get interface flags: %m"); ! 811: continue; ! 812: } ! 813: #ifdef IFF_LOOPBACK ! 814: if (ifreq.ifr_flags & IFF_LOOPBACK) ! 815: #else ! 816: /* test against 127.0.0.1 (yuck!!) */ ! 817: if (ntp->my_addr.s_addr == htonl(0x7F000001)) ! 818: #endif ! 819: { ! 820: if (netloop.my_addr.s_addr == 0) { ! 821: netloop.my_addr = ntp->my_addr; ! 822: netloop.mask = 0xffffffff; ! 823: netloop.net = ntp->my_addr.s_addr; ! 824: #ifdef DEBUG ! 825: if (debug) ! 826: fprintf(ddt,"loopback address: x%lx\n", ! 827: netloop.my_addr.s_addr); ! 828: #endif DEBUG ! 829: } ! 830: continue; ! 831: } else if ((ifreq.ifr_flags & IFF_POINTOPOINT)) { ! 832: if (ioctl(vs, SIOCGIFDSTADDR, (char *)&ifreq) < 0) { ! 833: syslog(LOG_ERR, "get dst addr: %m"); ! 834: continue; ! 835: } ! 836: ntp->mask = 0xffffffff; ! 837: ntp->net = ((struct sockaddr_in *) ! 838: &ifreq.ifr_addr)->sin_addr.s_addr; ! 839: } else { ! 840: ntp->net = ntp->mask & ntp->my_addr.s_addr; ! 841: } ! 842: /* ! 843: * Place on end of list of locally-attached (sub)nets, ! 844: * but before logical nets for subnetted nets. ! 845: */ ! 846: ntp->next = *elocal; ! 847: *elocal = ntp; ! 848: if (elocal == enettab) ! 849: enettab = &ntp->next; ! 850: elocal = &ntp->next; ! 851: ntp = NULL; ! 852: } ! 853: if (ntp) ! 854: (void) free((char *)ntp); ! 855: ! 856: /* ! 857: * Create separate qdatagram structure for socket ! 858: * wildcard address. ! 859: */ ! 860: if (first) { ! 861: if ((dqp = (struct qdatagram *)calloc(1, sizeof(*dqp))) == NULL) { ! 862: #ifdef DEBUG ! 863: if (debug >= 5) ! 864: fprintf(ddt,"getnetconf: malloc error\n"); ! 865: #endif ! 866: syslog(LOG_ERR, "getnetconf: Out Of Memory"); ! 867: exit(12); ! 868: } ! 869: dqp->dq_next = datagramq; ! 870: datagramq = dqp; ! 871: dqp->dq_addr.s_addr = INADDR_ANY; ! 872: opensocket(dqp); ! 873: ds = dqp->dq_dfd; /* used externally */ ! 874: } ! 875: ! 876: /* ! 877: * Compute logical networks to which we're connected ! 878: * based on attached subnets; ! 879: * used for sorting based on network configuration. ! 880: */ ! 881: for (ntp = nettab; ntp != NULL; ntp = ntp->next) { ! 882: nm = net_mask(ntp->my_addr); ! 883: if (nm != ntp->mask) { ! 884: if (findnetinfo(ntp->my_addr)) ! 885: continue; ! 886: ontp = (struct netinfo *)malloc(sizeof(struct netinfo)); ! 887: if (ontp == NULL) { ! 888: #ifdef DEBUG ! 889: if (debug >= 5) ! 890: fprintf(ddt,"getnetconf: malloc error\n"); ! 891: #endif ! 892: syslog(LOG_ERR, "getnetconf: Out Of Memory"); ! 893: exit(12); ! 894: } ! 895: ontp->my_addr = ntp->my_addr; ! 896: ontp->mask = nm; ! 897: ontp->net = ontp->my_addr.s_addr & nm; ! 898: ontp->next = *enettab; ! 899: *enettab = ontp; ! 900: enettab = &ontp->next; ! 901: } ! 902: } ! 903: first = 0; ! 904: } ! 905: ! 906: /* ! 907: * Find netinfo structure for logical network implied by address "addr", ! 908: * if it's on list of local/favored networks. ! 909: */ ! 910: struct netinfo * ! 911: findnetinfo(addr) ! 912: struct in_addr addr; ! 913: { ! 914: register struct netinfo *ntp; ! 915: u_long net, mask; ! 916: ! 917: mask = net_mask(addr); ! 918: net = addr.s_addr & mask; ! 919: for (ntp = nettab; ntp != NULL; ntp = ntp->next) ! 920: if (ntp->net == net && ntp->mask == mask) ! 921: return (ntp); ! 922: return ((struct netinfo *) NULL); ! 923: } ! 924: ! 925: #ifdef DEBUG ! 926: printnetinfo(ntp) ! 927: register struct netinfo *ntp; ! 928: { ! 929: for ( ; ntp != NULL; ntp = ntp->next) { ! 930: fprintf(ddt,"net x%lx mask x%lx", ntp->net, ntp->mask); ! 931: fprintf(ddt," my_addr x%lx", ntp->my_addr.s_addr); ! 932: fprintf(ddt," %s\n", inet_ntoa(ntp->my_addr)); ! 933: } ! 934: } ! 935: #endif ! 936: ! 937: opensocket(dqp) ! 938: register struct qdatagram *dqp; ! 939: { ! 940: int on = 1; ! 941: ! 942: /* ! 943: * Open datagram sockets bound to interface address. ! 944: */ ! 945: if ((dqp->dq_dfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { ! 946: syslog(LOG_ERR, "socket(SOCK_DGRAM): %m"); ! 947: exit(1); ! 948: } ! 949: #ifdef DEBUG ! 950: if (debug) ! 951: fprintf(ddt,"dqp->dq_addr %s d_dfd %d\n", ! 952: inet_ntoa(dqp->dq_addr), dqp->dq_dfd); ! 953: #endif DEBUG ! 954: (void)setsockopt(dqp->dq_dfd, SOL_SOCKET, SO_REUSEADDR, ! 955: (char *)&on, sizeof(on)); ! 956: #ifdef SO_RCVBUF ! 957: (void)setsockopt(dqp->dq_dfd, SOL_SOCKET, SO_RCVBUF, ! 958: (char *)&rbufsize, sizeof(rbufsize)); ! 959: #endif SO_RCVBUF ! 960: (void) fcntl(dqp->dq_dfd, F_SETFL, FNDELAY); ! 961: /* ! 962: * NOTE: Some versions of SunOS have problems with the following ! 963: * call to bind. Bind still seems to function on these systems ! 964: * if you comment out the exit inside the if. This may cause ! 965: * Suns with multiple interfaces to reply strangely. ! 966: */ ! 967: nsaddr.sin_addr = dqp->dq_addr; ! 968: if (bind(dqp->dq_dfd, (struct sockaddr *)&nsaddr, sizeof(nsaddr))) { ! 969: syslog(LOG_ERR, "bind(dfd %d, %s[%d]): %m", ! 970: dqp->dq_dfd, inet_ntoa(nsaddr.sin_addr), ! 971: ntohs(nsaddr.sin_port)); ! 972: #if !defined(sun) ! 973: exit(1); ! 974: #endif ! 975: } ! 976: } ! 977: ! 978: /* ! 979: ** Set flag saying to reload database upon receiving SIGHUP. ! 980: ** Must make sure that someone isn't walking through a data ! 981: ** structure at the time. ! 982: */ ! 983: ! 984: VOID ! 985: onhup() ! 986: { ! 987: #if defined(SYSV) ! 988: (void)signal(SIGHUP, onhup); ! 989: #endif SYSV ! 990: needreload = 1; ! 991: } ! 992: ! 993: /* ! 994: ** Set flag saying to call ns_maint() ! 995: ** Must make sure that someone isn't walking through a data ! 996: ** structure at the time. ! 997: */ ! 998: ! 999: VOID ! 1000: maint_alarm() ! 1001: { ! 1002: #if defined(SYSV) ! 1003: (void)signal(SIGALRM, maint_alarm); ! 1004: #endif SYSV ! 1005: needmaint = 1; ! 1006: } ! 1007: ! 1008: ! 1009: #ifdef ALLOW_UPDATES ! 1010: /* ! 1011: * Signal handler to schedule shutdown. Just set flag, to ensure a consistent ! 1012: * state during dump. ! 1013: */ ! 1014: VOID ! 1015: onintr() ! 1016: { ! 1017: needToExit = 1; ! 1018: } ! 1019: #endif ALLOW_UPDATES ! 1020: ! 1021: /* ! 1022: * Signal handler to schedule a data base dump. Do this instead of dumping the ! 1023: * data base immediately, to avoid seeing it in a possibly inconsistent state ! 1024: * (due to updates), and to avoid long disk I/O delays at signal-handler ! 1025: * level ! 1026: */ ! 1027: VOID ! 1028: setdumpflg() ! 1029: { ! 1030: #if defined(SYSV) ! 1031: (void)signal(SIGINT, setdumpflg); ! 1032: #endif SYSV ! 1033: needToDoadump = 1; ! 1034: } ! 1035: ! 1036: /* ! 1037: ** Turn on or off debuging by open or closeing the debug file ! 1038: */ ! 1039: ! 1040: setdebug(code) ! 1041: int code; ! 1042: { ! 1043: #if defined(lint) && !defined(DEBUG) ! 1044: code = code; ! 1045: #endif ! 1046: #ifdef DEBUG ! 1047: ! 1048: if (code) { ! 1049: ddt = freopen(debugfile, "w+", stderr); ! 1050: if ( ddt == NULL) { ! 1051: syslog(LOG_WARNING, "can't open debug file %s: %m", ! 1052: debugfile); ! 1053: debug = 0; ! 1054: } else { ! 1055: #if defined(SYSV) ! 1056: setvbuf(ddt, NULL, _IOLBF, BUFSIZ); ! 1057: #else ! 1058: setlinebuf(ddt); ! 1059: #endif ! 1060: (void) fcntl(fileno(ddt), F_SETFL, FAPPEND); ! 1061: } ! 1062: } else ! 1063: debug = 0; ! 1064: /* delay closing ddt, we might interrupt someone */ ! 1065: #endif ! 1066: } ! 1067: ! 1068: /* ! 1069: ** Catch a special signal and set debug level. ! 1070: ** ! 1071: ** If debuging is off then turn on debuging else increment the level. ! 1072: ** ! 1073: ** Handy for looking in on long running name servers. ! 1074: */ ! 1075: ! 1076: VOID ! 1077: setIncrDbgFlg() ! 1078: { ! 1079: #if defined(SYSV) ! 1080: (void)signal(SIGUSR1, setIncrDbgFlg); ! 1081: #endif SYSV ! 1082: #ifdef DEBUG ! 1083: if (debug == 0) { ! 1084: debug++; ! 1085: setdebug(1); ! 1086: } ! 1087: else { ! 1088: debug++; ! 1089: } ! 1090: fprintf(ddt,"Debug turned ON, Level %d\n",debug); ! 1091: #endif ! 1092: } ! 1093: ! 1094: /* ! 1095: ** Catch a special signal to turn off debugging ! 1096: */ ! 1097: ! 1098: VOID ! 1099: setNoDbgFlg() ! 1100: { ! 1101: #if defined(SYSV) ! 1102: (void)signal(SIGUSR2, setNoDbgFlg); ! 1103: #endif SYSV ! 1104: setdebug(0); ! 1105: } ! 1106: ! 1107: /* ! 1108: ** Set flag for statistics dump ! 1109: */ ! 1110: VOID ! 1111: setstatsflg() ! 1112: { ! 1113: #if defined(SYSV) ! 1114: (void)signal(SIGIOT, setstatsflg); ! 1115: #endif SYSV ! 1116: needStatsDump = 1; ! 1117: } ! 1118: ! 1119: VOID ! 1120: setchkptflg() ! 1121: { ! 1122: #if defined(SYSV) ! 1123: (void)signal(SIGQUIT, setchkptflg); ! 1124: #endif SYSV ! 1125: needToChkpt = 1; ! 1126: } ! 1127: ! 1128: /* ! 1129: ** Catch a special signal SIGSYS ! 1130: ** ! 1131: ** this is setup to fork and exit to drop to /usr/tmp/gmon.out ! 1132: ** and keep the server running ! 1133: */ ! 1134: ! 1135: VOID ! 1136: sigprof() ! 1137: { ! 1138: #if defined(SYSV) ! 1139: (void)signal(SIGSYS, sigprof); ! 1140: #endif SYSV ! 1141: #ifdef DEBUG ! 1142: if (debug) ! 1143: fprintf(ddt,"sigprof()\n"); ! 1144: #endif ! 1145: if ( fork() == 0) ! 1146: { ! 1147: (void) chdir(_PATH_TMPDIR); ! 1148: exit(1); ! 1149: } ! 1150: } ! 1151: ! 1152: /* ! 1153: ** Routines for managing stream queue ! 1154: */ ! 1155: ! 1156: struct qstream * ! 1157: sqadd() ! 1158: { ! 1159: register struct qstream *sqp; ! 1160: ! 1161: if ((sqp = (struct qstream *)calloc(1, sizeof(struct qstream))) ! 1162: == NULL ) { ! 1163: #ifdef DEBUG ! 1164: if (debug >= 5) ! 1165: fprintf(ddt,"sqadd: malloc error\n"); ! 1166: #endif ! 1167: syslog(LOG_ERR, "sqadd: Out Of Memory"); ! 1168: return(QSTREAM_NULL); ! 1169: } ! 1170: #ifdef DEBUG ! 1171: if (debug > 3) ! 1172: fprintf(ddt,"sqadd(x%x)\n", sqp); ! 1173: #endif ! 1174: ! 1175: sqp->s_next = streamq; ! 1176: streamq = sqp; ! 1177: return(sqp); ! 1178: } ! 1179: ! 1180: /* ! 1181: * Remove stream queue structure. ! 1182: * No current queries may refer to this stream when it is removed. ! 1183: */ ! 1184: sqrm(qp) ! 1185: register struct qstream *qp; ! 1186: { ! 1187: register struct qstream *qsp; ! 1188: ! 1189: #ifdef DEBUG ! 1190: if (debug > 1) { ! 1191: fprintf(ddt,"sqrm(%#x, %d ) rfcnt=%d\n", ! 1192: qp, qp->s_rfd, qp->s_refcnt); ! 1193: } ! 1194: #endif ! 1195: ! 1196: if (qp->s_bufsize != 0) ! 1197: (void) free(qp->s_buf); ! 1198: FD_CLR(qp->s_rfd, &mask); ! 1199: (void) close(qp->s_rfd); ! 1200: if (qp == streamq) { ! 1201: streamq = qp->s_next; ! 1202: } else { ! 1203: for (qsp = streamq; qsp->s_next != qp; qsp = qsp->s_next) ! 1204: ; ! 1205: qsp->s_next = qp->s_next; ! 1206: } ! 1207: (void)free((char *)qp); ! 1208: } ! 1209: ! 1210: sqflush() ! 1211: { ! 1212: register struct qstream *sp, *spnext; ! 1213: ! 1214: for (sp = streamq; sp != QSTREAM_NULL; sp = spnext) { ! 1215: spnext = sp->s_next; ! 1216: sqrm(sp); ! 1217: } ! 1218: } ! 1219: ! 1220: /* ! 1221: * Initiate query on stream; ! 1222: * mark as referenced and stop selecting for input. ! 1223: */ ! 1224: sq_query(sp) ! 1225: register struct qstream *sp; ! 1226: { ! 1227: sp->s_refcnt++; ! 1228: FD_CLR(sp->s_rfd, &mask); ! 1229: } ! 1230: ! 1231: /* ! 1232: * Note that the current request on a stream has completed, ! 1233: * and that we should continue looking for requests on the stream. ! 1234: */ ! 1235: sq_done(sp) ! 1236: register struct qstream *sp; ! 1237: { ! 1238: ! 1239: sp->s_refcnt = 0; ! 1240: sp->s_time = tt.tv_sec; ! 1241: FD_SET(sp->s_rfd, &mask); ! 1242: } ! 1243: ! 1244: setproctitle(a, s) ! 1245: char *a; ! 1246: int s; ! 1247: { ! 1248: int size; ! 1249: register char *cp; ! 1250: struct sockaddr_in sin; ! 1251: char buf[80]; ! 1252: ! 1253: cp = Argv[0]; ! 1254: size = sizeof(sin); ! 1255: if (getpeername(s, (struct sockaddr *)&sin, &size) == 0) ! 1256: (void) sprintf(buf, "-%s [%s]", a, inet_ntoa(sin.sin_addr)); ! 1257: else { ! 1258: syslog(LOG_DEBUG, "getpeername: %m"); ! 1259: (void) sprintf(buf, "-%s", a); ! 1260: } ! 1261: (void) strncpy(cp, buf, LastArg - cp); ! 1262: cp += strlen(cp); ! 1263: while (cp < LastArg) ! 1264: *cp++ = ' '; ! 1265: } ! 1266: ! 1267: u_long ! 1268: net_mask(in) ! 1269: struct in_addr in; ! 1270: { ! 1271: register u_long i = ntohl(in.s_addr); ! 1272: ! 1273: if (IN_CLASSA(i)) ! 1274: return (htonl(IN_CLASSA_NET)); ! 1275: else if (IN_CLASSB(i)) ! 1276: return (htonl(IN_CLASSB_NET)); ! 1277: else ! 1278: return (htonl(IN_CLASSC_NET)); ! 1279: } ! 1280: ! 1281: gettime(ttp) ! 1282: struct timeval *ttp; ! 1283: { ! 1284: if (gettimeofday(ttp, (struct timezone *)0) < 0) ! 1285: syslog(LOG_ERR, "gettimeofday failed: %m"); ! 1286: return; ! 1287: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.