![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to inetd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc|
Return to inetd.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: char copyright[] = ! 9: "@(#) Copyright (c) 1983 Regents of the University of California.\n\ ! 10: All rights reserved.\n"; ! 11: #endif not lint ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)inetd.c 5.6 (Berkeley) 4/29/86"; ! 15: #endif not lint ! 16: ! 17: /* ! 18: * Inetd - Internet super-server ! 19: * ! 20: * This program invokes all internet services as needed. ! 21: * connection-oriented services are invoked each time a ! 22: * connection is made, by creating a process. This process ! 23: * is passed the connection as file descriptor 0 and is ! 24: * expected to do a getpeername to find out the source host ! 25: * and port. ! 26: * ! 27: * Datagram oriented services are invoked when a datagram ! 28: * arrives; a process is created and passed a pending message ! 29: * on file descriptor 0. Datagram servers may either connect ! 30: * to their peer, freeing up the original socket for inetd ! 31: * to receive further messages on, or ``take over the socket'', ! 32: * processing all arriving datagrams and, eventually, timing ! 33: * out. The first type of server is said to be ``multi-threaded''; ! 34: * the second type of server ``single-threaded''. ! 35: * ! 36: * Inetd uses a configuration file which is read at startup ! 37: * and, possibly, at some later time in response to a hangup signal. ! 38: * The configuration file is ``free format'' with fields given in the ! 39: * order shown below. Continuation lines for an entry must being with ! 40: * a space or tab. All fields must be present in each entry. ! 41: * ! 42: * service name must be in /etc/services ! 43: * socket type stream/dgram/raw/rdm/seqpacket ! 44: * protocol must be in /etc/protocols ! 45: * wait/nowait single-threaded/multi-threaded ! 46: * user user to run daemon as ! 47: * server program full path name ! 48: * server program arguments maximum of MAXARGS (5) ! 49: * ! 50: * Comment lines are indicated by a `#' in column 1. ! 51: */ ! 52: #include <sys/param.h> ! 53: #include <sys/stat.h> ! 54: #include <sys/ioctl.h> ! 55: #include <sys/socket.h> ! 56: #include <sys/file.h> ! 57: #include <sys/wait.h> ! 58: #include <sys/time.h> ! 59: #include <sys/resource.h> ! 60: ! 61: #include <netinet/in.h> ! 62: #include <arpa/inet.h> ! 63: ! 64: #include <errno.h> ! 65: #include <stdio.h> ! 66: #include <signal.h> ! 67: #include <netdb.h> ! 68: #include <syslog.h> ! 69: #include <pwd.h> ! 70: ! 71: #define TOOMANY 40 /* don't start more than TOOMANY */ ! 72: #define CNT_INTVL 60 /* servers in CNT_INTVL sec. */ ! 73: #define RETRYTIME (60*10) /* retry after bind or server fail */ ! 74: ! 75: #define SIGBLOCK (sigmask(SIGCHLD)|sigmask(SIGHUP)|sigmask(SIGALRM)) ! 76: ! 77: extern int errno; ! 78: ! 79: int reapchild(), retry(); ! 80: char *index(); ! 81: char *malloc(); ! 82: ! 83: int debug = 0; ! 84: int nsock, maxsock; ! 85: fd_set allsock; ! 86: int options; ! 87: int timingout; ! 88: struct servent *sp; ! 89: ! 90: struct servtab { ! 91: char *se_service; /* name of service */ ! 92: int se_socktype; /* type of socket to use */ ! 93: char *se_proto; /* protocol used */ ! 94: short se_wait; /* single threaded server */ ! 95: short se_checked; /* looked at during merge */ ! 96: char *se_user; /* user name to run as */ ! 97: struct biltin *se_bi; /* if built-in, description */ ! 98: char *se_server; /* server program */ ! 99: #define MAXARGV 5 ! 100: char *se_argv[MAXARGV+1]; /* program arguments */ ! 101: int se_fd; /* open descriptor */ ! 102: struct sockaddr_in se_ctrladdr;/* bound address */ ! 103: int se_count; /* number started since se_time */ ! 104: struct timeval se_time; /* start of se_count */ ! 105: struct servtab *se_next; ! 106: } *servtab; ! 107: ! 108: int echo_stream(), discard_stream(), machtime_stream(); ! 109: int daytime_stream(), chargen_stream(); ! 110: int echo_dg(), discard_dg(), machtime_dg(), daytime_dg(), chargen_dg(); ! 111: ! 112: struct biltin { ! 113: char *bi_service; /* internally provided service name */ ! 114: int bi_socktype; /* type of socket supported */ ! 115: short bi_fork; /* 1 if should fork before call */ ! 116: short bi_wait; /* 1 if should wait for child */ ! 117: int (*bi_fn)(); /* function which performs it */ ! 118: } biltins[] = { ! 119: /* Echo received data */ ! 120: "echo", SOCK_STREAM, 1, 0, echo_stream, ! 121: "echo", SOCK_DGRAM, 0, 0, echo_dg, ! 122: ! 123: /* Internet /dev/null */ ! 124: "discard", SOCK_STREAM, 1, 0, discard_stream, ! 125: "discard", SOCK_DGRAM, 0, 0, discard_dg, ! 126: ! 127: /* Return 32 bit time since 1970 */ ! 128: "time", SOCK_STREAM, 0, 0, machtime_stream, ! 129: "time", SOCK_DGRAM, 0, 0, machtime_dg, ! 130: ! 131: /* Return human-readable time */ ! 132: "daytime", SOCK_STREAM, 0, 0, daytime_stream, ! 133: "daytime", SOCK_DGRAM, 0, 0, daytime_dg, ! 134: ! 135: /* Familiar character generator */ ! 136: "chargen", SOCK_STREAM, 1, 0, chargen_stream, ! 137: "chargen", SOCK_DGRAM, 0, 0, chargen_dg, ! 138: 0 ! 139: }; ! 140: ! 141: #define NUMINT (sizeof(intab) / sizeof(struct inent)) ! 142: char *CONFIG = "/etc/inetd.conf"; ! 143: char **Argv; ! 144: char *LastArg; ! 145: ! 146: main(argc, argv, envp) ! 147: int argc; ! 148: char *argv[], *envp[]; ! 149: { ! 150: register struct servtab *sep; ! 151: register struct passwd *pwd; ! 152: char *cp, buf[50]; ! 153: int pid, i, dofork; ! 154: struct sigvec sv; ! 155: ! 156: Argv = argv; ! 157: if (envp == 0 || *envp == 0) ! 158: envp = argv; ! 159: while (*envp) ! 160: envp++; ! 161: LastArg = envp[-1] + strlen(envp[-1]); ! 162: argc--, argv++; ! 163: while (argc > 0 && *argv[0] == '-') { ! 164: for (cp = &argv[0][1]; *cp; cp++) switch (*cp) { ! 165: ! 166: case 'd': ! 167: debug = 1; ! 168: options |= SO_DEBUG; ! 169: break; ! 170: ! 171: default: ! 172: fprintf(stderr, ! 173: "inetd: Unknown flag -%c ignored.\n", *cp); ! 174: break; ! 175: } ! 176: nextopt: ! 177: argc--, argv++; ! 178: } ! 179: if (argc > 0) ! 180: CONFIG = argv[0]; ! 181: #ifndef DEBUG ! 182: if (fork()) ! 183: exit(0); ! 184: { int s; ! 185: for (s = 0; s < 10; s++) ! 186: (void) close(s); ! 187: } ! 188: (void) open("/", O_RDONLY); ! 189: (void) dup2(0, 1); ! 190: (void) dup2(0, 2); ! 191: { int tt = open("/dev/tty", O_RDWR); ! 192: if (tt > 0) { ! 193: ioctl(tt, TIOCNOTTY, (char *)0); ! 194: close(tt); ! 195: } ! 196: } ! 197: #endif ! 198: openlog("inetd", LOG_PID | LOG_NOWAIT, LOG_DAEMON); ! 199: bzero((char *)&sv, sizeof(sv)); ! 200: sv.sv_mask = SIGBLOCK; ! 201: sv.sv_handler = retry; ! 202: sigvec(SIGALRM, &sv, (struct sigvec *)0); ! 203: config(); ! 204: sv.sv_handler = config; ! 205: sigvec(SIGHUP, &sv, (struct sigvec *)0); ! 206: sv.sv_handler = reapchild; ! 207: sigvec(SIGCHLD, &sv, (struct sigvec *)0); ! 208: ! 209: for (;;) { ! 210: int s, ctrl, n; ! 211: fd_set readable; ! 212: ! 213: while (nsock == 0) ! 214: sigpause(0); ! 215: readable = allsock; ! 216: if ((n = select(maxsock + 1, &readable, (fd_set *)0, ! 217: (fd_set *)0, (struct timeval *)0)) <= 0) { ! 218: if (n < 0 && errno != EINTR) ! 219: syslog(LOG_WARNING, "select: %m\n"); ! 220: sleep(1); ! 221: continue; ! 222: } ! 223: for (sep = servtab; n && sep; sep = sep->se_next) ! 224: if (FD_ISSET(sep->se_fd, &readable)) { ! 225: n--; ! 226: if (debug) ! 227: fprintf(stderr, "someone wants %s\n", sep->se_service); ! 228: if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) { ! 229: ctrl = accept(sep->se_fd, (struct sockaddr *)0, ! 230: (int *)0); ! 231: if (debug) ! 232: fprintf(stderr, "accept, ctrl %d\n", ctrl); ! 233: if (ctrl < 0) { ! 234: if (errno == EINTR) ! 235: continue; ! 236: syslog(LOG_WARNING, "accept: %m"); ! 237: continue; ! 238: } ! 239: } else ! 240: ctrl = sep->se_fd; ! 241: (void) sigblock(SIGBLOCK); ! 242: pid = 0; ! 243: dofork = (sep->se_bi == 0 || sep->se_bi->bi_fork); ! 244: if (dofork) { ! 245: if (sep->se_count++ == 0) ! 246: (void)gettimeofday(&sep->se_time, ! 247: (struct timezone *)0); ! 248: else if (sep->se_count >= TOOMANY) { ! 249: struct timeval now; ! 250: ! 251: (void)gettimeofday(&now, (struct timezone *)0); ! 252: if (now.tv_sec - sep->se_time.tv_sec > ! 253: CNT_INTVL) { ! 254: sep->se_time = now; ! 255: sep->se_count = 1; ! 256: } else { ! 257: syslog(LOG_ERR, ! 258: "%s/%s server failing (looping), service terminated\n", ! 259: sep->se_service, sep->se_proto); ! 260: FD_CLR(sep->se_fd, &allsock); ! 261: (void) close(sep->se_fd); ! 262: sep->se_fd = -1; ! 263: sep->se_count = 0; ! 264: nsock--; ! 265: sigsetmask(0); ! 266: if (!timingout) { ! 267: timingout = 1; ! 268: alarm(RETRYTIME); ! 269: } ! 270: continue; ! 271: } ! 272: } ! 273: pid = fork(); ! 274: } ! 275: if (pid < 0) { ! 276: if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) ! 277: close(ctrl); ! 278: sigsetmask(0); ! 279: sleep(1); ! 280: continue; ! 281: } ! 282: if (pid && sep->se_wait) { ! 283: sep->se_wait = pid; ! 284: FD_CLR(sep->se_fd, &allsock); ! 285: nsock--; ! 286: } ! 287: sigsetmask(0); ! 288: if (pid == 0) { ! 289: #ifdef DEBUG ! 290: int tt; ! 291: ! 292: if (dofork && (tt = open("/dev/tty", O_RDWR)) > 0) { ! 293: ioctl(tt, TIOCNOTTY, 0); ! 294: close(tt); ! 295: } ! 296: #endif ! 297: if (dofork) ! 298: for (i = getdtablesize(); --i > 2; ) ! 299: if (i != ctrl) ! 300: close(i); ! 301: if (sep->se_bi) ! 302: (*sep->se_bi->bi_fn)(ctrl, sep); ! 303: else { ! 304: dup2(ctrl, 0); ! 305: close(ctrl); ! 306: dup2(0, 1); ! 307: dup2(0, 2); ! 308: if ((pwd = getpwnam(sep->se_user)) == NULL) { ! 309: syslog(LOG_ERR, ! 310: "getpwnam: %s: No such user", ! 311: sep->se_user); ! 312: if (sep->se_socktype != SOCK_STREAM) ! 313: recv(0, buf, sizeof (buf), 0); ! 314: _exit(1); ! 315: } ! 316: if (pwd->pw_uid) { ! 317: (void) setgid((gid_t)pwd->pw_gid); ! 318: initgroups(pwd->pw_name, pwd->pw_gid); ! 319: (void) setuid((uid_t)pwd->pw_uid); ! 320: } ! 321: if (debug) ! 322: fprintf(stderr, "%d execl %s\n", ! 323: getpid(), sep->se_server); ! 324: execv(sep->se_server, sep->se_argv); ! 325: if (sep->se_socktype != SOCK_STREAM) ! 326: recv(0, buf, sizeof (buf), 0); ! 327: syslog(LOG_ERR, "execv %s: %m", sep->se_server); ! 328: _exit(1); ! 329: } ! 330: } ! 331: if (!sep->se_wait && sep->se_socktype == SOCK_STREAM) ! 332: close(ctrl); ! 333: } ! 334: } ! 335: } ! 336: ! 337: reapchild() ! 338: { ! 339: union wait status; ! 340: int pid; ! 341: register struct servtab *sep; ! 342: ! 343: for (;;) { ! 344: pid = wait3(&status, WNOHANG, (struct rusage *)0); ! 345: if (pid <= 0) ! 346: break; ! 347: if (debug) ! 348: fprintf(stderr, "%d reaped\n", pid); ! 349: for (sep = servtab; sep; sep = sep->se_next) ! 350: if (sep->se_wait == pid) { ! 351: if (status.w_status) ! 352: syslog(LOG_WARNING, ! 353: "%s: exit status 0x%x", ! 354: sep->se_server, status); ! 355: if (debug) ! 356: fprintf(stderr, "restored %s, fd %d\n", ! 357: sep->se_service, sep->se_fd); ! 358: FD_SET(sep->se_fd, &allsock); ! 359: nsock++; ! 360: sep->se_wait = 1; ! 361: } ! 362: } ! 363: } ! 364: ! 365: config() ! 366: { ! 367: register struct servtab *sep, *cp, **sepp; ! 368: struct servtab *getconfigent(), *enter(); ! 369: int omask; ! 370: ! 371: if (!setconfig()) { ! 372: syslog(LOG_ERR, "%s: %m", CONFIG); ! 373: return; ! 374: } ! 375: for (sep = servtab; sep; sep = sep->se_next) ! 376: sep->se_checked = 0; ! 377: while (cp = getconfigent()) { ! 378: for (sep = servtab; sep; sep = sep->se_next) ! 379: if (strcmp(sep->se_service, cp->se_service) == 0 && ! 380: strcmp(sep->se_proto, cp->se_proto) == 0) ! 381: break; ! 382: if (sep != 0) { ! 383: int i; ! 384: ! 385: omask = sigblock(SIGBLOCK); ! 386: if (cp->se_bi == 0) ! 387: sep->se_wait = cp->se_wait; ! 388: #define SWAP(a, b) { char *c = a; a = b; b = c; } ! 389: if (cp->se_user) ! 390: SWAP(sep->se_user, cp->se_user); ! 391: if (cp->se_server) ! 392: SWAP(sep->se_server, cp->se_server); ! 393: for (i = 0; i < MAXARGV; i++) ! 394: SWAP(sep->se_argv[i], cp->se_argv[i]); ! 395: sigsetmask(omask); ! 396: freeconfig(cp); ! 397: } else ! 398: sep = enter(cp); ! 399: sep->se_checked = 1; ! 400: sp = getservbyname(sep->se_service, sep->se_proto); ! 401: if (sp == 0) { ! 402: syslog(LOG_ERR, "%s/%s: unknown service", ! 403: sep->se_service, sep->se_proto); ! 404: continue; ! 405: } ! 406: if (sp->s_port != sep->se_ctrladdr.sin_port) { ! 407: sep->se_ctrladdr.sin_port = sp->s_port; ! 408: if (sep->se_fd != -1) ! 409: (void) close(sep->se_fd); ! 410: sep->se_fd = -1; ! 411: } ! 412: if (sep->se_fd == -1) ! 413: setup(sep); ! 414: } ! 415: endconfig(); ! 416: /* ! 417: * Purge anything not looked at above. ! 418: */ ! 419: omask = sigblock(SIGBLOCK); ! 420: sepp = &servtab; ! 421: while (sep = *sepp) { ! 422: if (sep->se_checked) { ! 423: sepp = &sep->se_next; ! 424: continue; ! 425: } ! 426: *sepp = sep->se_next; ! 427: if (sep->se_fd != -1) { ! 428: FD_CLR(sep->se_fd, &allsock); ! 429: nsock--; ! 430: (void) close(sep->se_fd); ! 431: } ! 432: freeconfig(sep); ! 433: free((char *)sep); ! 434: } ! 435: (void) sigsetmask(omask); ! 436: } ! 437: ! 438: retry() ! 439: { ! 440: register struct servtab *sep; ! 441: ! 442: timingout = 0; ! 443: for (sep = servtab; sep; sep = sep->se_next) ! 444: if (sep->se_fd == -1) ! 445: setup(sep); ! 446: } ! 447: ! 448: setup(sep) ! 449: register struct servtab *sep; ! 450: { ! 451: int on = 1; ! 452: ! 453: if ((sep->se_fd = socket(AF_INET, sep->se_socktype, 0)) < 0) { ! 454: syslog(LOG_ERR, "%s/%s: socket: %m", ! 455: sep->se_service, sep->se_proto); ! 456: return; ! 457: } ! 458: #define turnon(fd, opt) \ ! 459: setsockopt(fd, SOL_SOCKET, opt, (char *)&on, sizeof (on)) ! 460: if (strcmp(sep->se_proto, "tcp") == 0 && (options & SO_DEBUG) && ! 461: turnon(sep->se_fd, SO_DEBUG) < 0) ! 462: syslog(LOG_ERR, "setsockopt (SO_DEBUG): %m"); ! 463: if (turnon(sep->se_fd, SO_REUSEADDR) < 0) ! 464: syslog(LOG_ERR, "setsockopt (SO_REUSEADDR): %m"); ! 465: #undef turnon ! 466: if (bind(sep->se_fd, &sep->se_ctrladdr, ! 467: sizeof (sep->se_ctrladdr)) < 0) { ! 468: syslog(LOG_ERR, "%s/%s: bind: %m", ! 469: sep->se_service, sep->se_proto); ! 470: (void) close(sep->se_fd); ! 471: sep->se_fd = -1; ! 472: if (!timingout) { ! 473: timingout = 1; ! 474: alarm(RETRYTIME); ! 475: } ! 476: return; ! 477: } ! 478: if (sep->se_socktype == SOCK_STREAM) ! 479: listen(sep->se_fd, 10); ! 480: FD_SET(sep->se_fd, &allsock); ! 481: nsock++; ! 482: if (sep->se_fd > maxsock) ! 483: maxsock = sep->se_fd; ! 484: } ! 485: ! 486: struct servtab * ! 487: enter(cp) ! 488: struct servtab *cp; ! 489: { ! 490: register struct servtab *sep; ! 491: int omask; ! 492: char *strdup(); ! 493: ! 494: sep = (struct servtab *)malloc(sizeof (*sep)); ! 495: if (sep == (struct servtab *)0) { ! 496: syslog(LOG_ERR, "Out of memory."); ! 497: exit(-1); ! 498: } ! 499: *sep = *cp; ! 500: sep->se_fd = -1; ! 501: omask = sigblock(SIGBLOCK); ! 502: sep->se_next = servtab; ! 503: servtab = sep; ! 504: sigsetmask(omask); ! 505: return (sep); ! 506: } ! 507: ! 508: FILE *fconfig = NULL; ! 509: struct servtab serv; ! 510: char line[256]; ! 511: char *skip(), *nextline(); ! 512: ! 513: setconfig() ! 514: { ! 515: ! 516: if (fconfig != NULL) { ! 517: fseek(fconfig, 0L, L_SET); ! 518: return (1); ! 519: } ! 520: fconfig = fopen(CONFIG, "r"); ! 521: return (fconfig != NULL); ! 522: } ! 523: ! 524: endconfig() ! 525: { ! 526: ! 527: if (fconfig == NULL) ! 528: return; ! 529: fclose(fconfig); ! 530: fconfig = NULL; ! 531: } ! 532: ! 533: struct servtab * ! 534: getconfigent() ! 535: { ! 536: register struct servtab *sep = &serv; ! 537: char *cp, *arg; ! 538: int argc; ! 539: ! 540: more: ! 541: while ((cp = nextline(fconfig)) && *cp == '#') ! 542: ; ! 543: if (cp == NULL) ! 544: return ((struct servtab *)0); ! 545: sep->se_service = strdup(skip(&cp)); ! 546: arg = skip(&cp); ! 547: if (strcmp(arg, "stream") == 0) ! 548: sep->se_socktype = SOCK_STREAM; ! 549: else if (strcmp(arg, "dgram") == 0) ! 550: sep->se_socktype = SOCK_DGRAM; ! 551: else if (strcmp(arg, "rdm") == 0) ! 552: sep->se_socktype = SOCK_RDM; ! 553: else if (strcmp(arg, "seqpacket") == 0) ! 554: sep->se_socktype = SOCK_SEQPACKET; ! 555: else if (strcmp(arg, "raw") == 0) ! 556: sep->se_socktype = SOCK_RAW; ! 557: else ! 558: sep->se_socktype = -1; ! 559: sep->se_proto = strdup(skip(&cp)); ! 560: arg = skip(&cp); ! 561: sep->se_wait = strcmp(arg, "wait") == 0; ! 562: sep->se_user = strdup(skip(&cp)); ! 563: sep->se_server = strdup(skip(&cp)); ! 564: if (strcmp(sep->se_server, "internal") == 0) { ! 565: register struct biltin *bi; ! 566: ! 567: for (bi = biltins; bi->bi_service; bi++) ! 568: if (bi->bi_socktype == sep->se_socktype && ! 569: strcmp(bi->bi_service, sep->se_service) == 0) ! 570: break; ! 571: if (bi->bi_service == 0) { ! 572: syslog(LOG_ERR, "internal service %s unknown\n", ! 573: sep->se_service); ! 574: goto more; ! 575: } ! 576: sep->se_bi = bi; ! 577: sep->se_wait = bi->bi_wait; ! 578: } ! 579: argc = 0; ! 580: for (arg = skip(&cp); cp; arg = skip(&cp)) ! 581: if (argc < MAXARGV) ! 582: sep->se_argv[argc++] = strdup(arg); ! 583: while (argc <= MAXARGV) ! 584: sep->se_argv[argc++] = NULL; ! 585: return (sep); ! 586: } ! 587: ! 588: freeconfig(cp) ! 589: register struct servtab *cp; ! 590: { ! 591: int i; ! 592: ! 593: if (cp->se_service) ! 594: free(cp->se_service); ! 595: if (cp->se_proto) ! 596: free(cp->se_proto); ! 597: if (cp->se_user) ! 598: free(cp->se_user); ! 599: if (cp->se_server) ! 600: free(cp->se_server); ! 601: for (i = 0; i < MAXARGV; i++) ! 602: if (cp->se_argv[i]) ! 603: free(cp->se_argv[i]); ! 604: } ! 605: ! 606: char * ! 607: skip(cpp) ! 608: char **cpp; ! 609: { ! 610: register char *cp = *cpp; ! 611: char *start; ! 612: ! 613: again: ! 614: while (*cp == ' ' || *cp == '\t') ! 615: cp++; ! 616: if (*cp == '\0') { ! 617: char c; ! 618: ! 619: c = getc(fconfig); ! 620: ungetc(c, fconfig); ! 621: if (c == ' ' || c == '\t') ! 622: if (cp = nextline(fconfig)) ! 623: goto again; ! 624: *cpp = (char *)0; ! 625: return ((char *)0); ! 626: } ! 627: start = cp; ! 628: while (*cp && *cp != ' ' && *cp != '\t') ! 629: cp++; ! 630: if (*cp != '\0') ! 631: *cp++ = '\0'; ! 632: *cpp = cp; ! 633: return (start); ! 634: } ! 635: ! 636: char * ! 637: nextline(fd) ! 638: FILE *fd; ! 639: { ! 640: char *cp; ! 641: ! 642: if (fgets(line, sizeof (line), fd) == NULL) ! 643: return ((char *)0); ! 644: cp = index(line, '\n'); ! 645: if (cp) ! 646: *cp = '\0'; ! 647: return (line); ! 648: } ! 649: ! 650: char * ! 651: strdup(cp) ! 652: char *cp; ! 653: { ! 654: char *new; ! 655: ! 656: if (cp == NULL) ! 657: cp = ""; ! 658: new = malloc((unsigned)(strlen(cp) + 1)); ! 659: if (new == (char *)0) { ! 660: syslog(LOG_ERR, "Out of memory."); ! 661: exit(-1); ! 662: } ! 663: strcpy(new, cp); ! 664: return (new); ! 665: } ! 666: ! 667: setproctitle(a, s) ! 668: char *a; ! 669: int s; ! 670: { ! 671: int size; ! 672: register char *cp; ! 673: struct sockaddr_in sin; ! 674: char buf[80]; ! 675: ! 676: cp = Argv[0]; ! 677: size = sizeof(sin); ! 678: if (getpeername(s, &sin, &size) == 0) ! 679: sprintf(buf, "-%s [%s]", a, inet_ntoa(sin.sin_addr)); ! 680: else ! 681: sprintf(buf, "-%s", a); ! 682: strncpy(cp, buf, LastArg - cp); ! 683: cp += strlen(cp); ! 684: while (cp < LastArg) ! 685: *cp++ = ' '; ! 686: } ! 687: ! 688: /* ! 689: * Internet services provided internally by inetd: ! 690: */ ! 691: ! 692: /* ARGSUSED */ ! 693: echo_stream(s, sep) /* Echo service -- echo data back */ ! 694: int s; ! 695: struct servtab *sep; ! 696: { ! 697: char buffer[BUFSIZ]; ! 698: int i; ! 699: ! 700: setproctitle("echo", s); ! 701: while ((i = read(s, buffer, sizeof(buffer))) > 0 && ! 702: write(s, buffer, i) > 0) ! 703: ; ! 704: exit(0); ! 705: } ! 706: ! 707: /* ARGSUSED */ ! 708: echo_dg(s, sep) /* Echo service -- echo data back */ ! 709: int s; ! 710: struct servtab *sep; ! 711: { ! 712: char buffer[BUFSIZ]; ! 713: int i, size; ! 714: struct sockaddr sa; ! 715: ! 716: size = sizeof(sa); ! 717: if ((i = recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size)) < 0) ! 718: return; ! 719: (void) sendto(s, buffer, i, 0, &sa, sizeof(sa)); ! 720: } ! 721: ! 722: /* ARGSUSED */ ! 723: discard_stream(s, sep) /* Discard service -- ignore data */ ! 724: int s; ! 725: struct servtab *sep; ! 726: { ! 727: char buffer[BUFSIZ]; ! 728: ! 729: setproctitle("discard", s); ! 730: while (1) { ! 731: while (read(s, buffer, sizeof(buffer)) > 0) ! 732: ; ! 733: if (errno != EINTR) ! 734: break; ! 735: } ! 736: exit(0); ! 737: } ! 738: ! 739: /* ARGSUSED */ ! 740: discard_dg(s, sep) /* Discard service -- ignore data */ ! 741: int s; ! 742: struct servtab *sep; ! 743: { ! 744: char buffer[BUFSIZ]; ! 745: ! 746: (void) read(s, buffer, sizeof(buffer)); ! 747: } ! 748: ! 749: #include <ctype.h> ! 750: #define LINESIZ 72 ! 751: char ring[128]; ! 752: char *endring; ! 753: ! 754: initring() ! 755: { ! 756: register int i; ! 757: ! 758: endring = ring; ! 759: ! 760: for (i = 0; i <= 128; ++i) ! 761: if (isprint(i)) ! 762: *endring++ = i; ! 763: } ! 764: ! 765: /* ARGSUSED */ ! 766: chargen_stream(s, sep) /* Character generator */ ! 767: int s; ! 768: struct servtab *sep; ! 769: { ! 770: char text[LINESIZ+2]; ! 771: register int i; ! 772: register char *rp, *rs, *dp; ! 773: ! 774: setproctitle("discard", s); ! 775: if (endring == 0) ! 776: initring(); ! 777: ! 778: for (rs = ring; ; ++rs) { ! 779: if (rs >= endring) ! 780: rs = ring; ! 781: rp = rs; ! 782: dp = text; ! 783: i = MIN(LINESIZ, endring - rp); ! 784: bcopy(rp, dp, i); ! 785: dp += i; ! 786: if ((rp += i) >= endring) ! 787: rp = ring; ! 788: if (i < LINESIZ) { ! 789: i = LINESIZ - i; ! 790: bcopy(rp, dp, i); ! 791: dp += i; ! 792: if ((rp += i) >= endring) ! 793: rp = ring; ! 794: } ! 795: *dp++ = '\r'; ! 796: *dp++ = '\n'; ! 797: ! 798: if (write(s, text, dp - text) != dp - text) ! 799: break; ! 800: } ! 801: exit(0); ! 802: } ! 803: ! 804: /* ARGSUSED */ ! 805: chargen_dg(s, sep) /* Character generator */ ! 806: int s; ! 807: struct servtab *sep; ! 808: { ! 809: char text[LINESIZ+2]; ! 810: register int i; ! 811: register char *rp; ! 812: static char *rs = ring; ! 813: struct sockaddr sa; ! 814: int size; ! 815: ! 816: if (endring == 0) ! 817: initring(); ! 818: ! 819: size = sizeof(sa); ! 820: if (recvfrom(s, text, sizeof(text), 0, &sa, &size) < 0) ! 821: return; ! 822: rp = rs; ! 823: if (rs++ >= endring) ! 824: rs = ring; ! 825: i = MIN(LINESIZ - 2, endring - rp); ! 826: bcopy(rp, text, i); ! 827: if ((rp += i) >= endring) ! 828: rp = ring; ! 829: if (i < LINESIZ - 2) { ! 830: bcopy(rp, text, i); ! 831: if ((rp += i) >= endring) ! 832: rp = ring; ! 833: } ! 834: text[LINESIZ - 2] = '\r'; ! 835: text[LINESIZ - 1] = '\n'; ! 836: ! 837: (void) sendto(s, text, sizeof(text), 0, &sa, sizeof(sa)); ! 838: } ! 839: ! 840: /* ! 841: * Return a machine readable date and time, in the form of the ! 842: * number of seconds since midnight, Jan 1, 1900. Since gettimeofday ! 843: * returns the number of seconds since midnight, Jan 1, 1970, ! 844: * we must add 2208988800 seconds to this figure to make up for ! 845: * some seventy years Bell Labs was asleep. ! 846: */ ! 847: ! 848: long ! 849: machtime() ! 850: { ! 851: struct timeval tv; ! 852: ! 853: if (gettimeofday(&tv, (struct timezone *)0) < 0) { ! 854: fprintf(stderr, "Unable to get time of day\n"); ! 855: return (0L); ! 856: } ! 857: return (htonl((long)tv.tv_sec + 2208988800)); ! 858: } ! 859: ! 860: /* ARGSUSED */ ! 861: machtime_stream(s, sep) ! 862: int s; ! 863: struct servtab *sep; ! 864: { ! 865: long result; ! 866: ! 867: result = machtime(); ! 868: (void) write(s, (char *) &result, sizeof(result)); ! 869: } ! 870: ! 871: /* ARGSUSED */ ! 872: machtime_dg(s, sep) ! 873: int s; ! 874: struct servtab *sep; ! 875: { ! 876: long result; ! 877: struct sockaddr sa; ! 878: int size; ! 879: ! 880: size = sizeof(sa); ! 881: if (recvfrom(s, (char *)&result, sizeof(result), 0, &sa, &size) < 0) ! 882: return; ! 883: result = machtime(); ! 884: (void) sendto(s, (char *) &result, sizeof(result), 0, &sa, sizeof(sa)); ! 885: } ! 886: ! 887: /* ARGSUSED */ ! 888: daytime_stream(s, sep) /* Return human-readable time of day */ ! 889: int s; ! 890: struct servtab *sep; ! 891: { ! 892: char buffer[256]; ! 893: time_t time(), clock; ! 894: char *ctime(); ! 895: ! 896: clock = time((time_t *) 0); ! 897: ! 898: sprintf(buffer, "%s\r", ctime(&clock)); ! 899: (void) write(s, buffer, strlen(buffer)); ! 900: } ! 901: ! 902: /* ARGSUSED */ ! 903: daytime_dg(s, sep) /* Return human-readable time of day */ ! 904: int s; ! 905: struct servtab *sep; ! 906: { ! 907: char buffer[256]; ! 908: time_t time(), clock; ! 909: struct sockaddr sa; ! 910: int size; ! 911: char *ctime(); ! 912: ! 913: clock = time((time_t *) 0); ! 914: ! 915: size = sizeof(sa); ! 916: if (recvfrom(s, buffer, sizeof(buffer), 0, &sa, &size) < 0) ! 917: return; ! 918: sprintf(buffer, "%s\r", ctime(&clock)); ! 919: (void) sendto(s, buffer, strlen(buffer), 0, &sa, sizeof(sa)); ! 920: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.