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