![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftpd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / inet / etc / ftpd|
Return to ftpd.c CVS log | Up to [Research Unix] / researchv8dc / cmd / inet / etc / ftpd |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)ftpd.c 4.28 (Berkeley) 9/22/83";
3: #endif
4:
5: /*
6: * FTP server.
7: */
8: #include <sys/param.h>
9: #include <sys/stat.h>
10: #include <sys/ioctl.h>
11: #include <sys/file.h>
12: #include <wait.h>
13:
14: #include <sys/inet/in.h>
15:
16: #include "ftp.h"
17:
18: #include <stdio.h>
19: #include <signal.h>
20: #include <pwd.h>
21: #include <setjmp.h>
22: #include <errno.h>
23:
24: /*
25: * File containing login names
26: * NOT to be used on this machine.
27: * Commonly used to disallow uucp.
28: */
29: #define FTPUSERS "/etc/ftpusers"
30:
31: extern int errno;
32: extern char *sys_errlist[];
33: extern char *crypt();
34: extern char version[];
35: extern char *home; /* pointer to home directory for glob */
36: extern FILE *popen(), *fopen();
37: extern int pclose(), fclose();
38:
39: struct socket {
40: unsigned short sport;
41: unsigned short dport;
42: long saddr;
43: long daddr;
44: } his_addr, data_dest, data_source, ctrl_addr;
45:
46: int data;
47: jmp_buf errcatch;
48: int logged_in;
49: struct passwd *pw;
50: int debug;
51: int timeout;
52: int logging;
53: int guest;
54: int type;
55: int form;
56: int stru; /* avoid C keyword */
57: int mode;
58: int usedefault = 1; /* for data transfers */
59: char hostname[32];
60: char remotehost[32];
61:
62:
63: /*
64: * Timeout intervals for retrying connections
65: * to hosts that don't accept PORT cmds. This
66: * is a kludge, but given the problems with TCP...
67: */
68: #define SWAITMAX 90 /* wait at most 90 seconds */
69: #define SWAITINT 5 /* interval between retries */
70:
71: int swaitmax = SWAITMAX;
72: int swaitint = SWAITINT;
73:
74: int lostconn();
75: int reapchild();
76: int getdatasock();
77: FILE *dataconn();
78:
79: main(argc, argv)
80: int argc;
81: char *argv[];
82: {
83: int ctrl, s, options = 0;
84: char *cp;
85: int dev;
86: struct in_service *servp;
87:
88: servp = in_service("ftp", "tcp", 0);
89: if (servp == 0) {
90: fprintf(stderr, "ftpd: ftp/tcp: unknown service\n");
91: exit(1);
92: }
93: ctrl_addr.sport = servp->port;
94: data_source.sport = servp->port - 1;
95: while (argc > 0 && *argv[0] == '-') {
96: for (cp = &argv[0][1]; *cp; cp++) switch (*cp) {
97:
98: case 'v':
99: debug = 1;
100: break;
101:
102: case 'd':
103: debug = 1;
104: break;
105:
106: case 'l':
107: logging = 1;
108: break;
109:
110: case 't':
111: timeout = atoi(++cp);
112: goto nextopt;
113: break;
114:
115: default:
116: fprintf(stderr, "Unknown flag -%c ignored.\n", *cp);
117: break;
118: }
119: nextopt:
120: argc--, argv++;
121: }
122: signal(SIGPIPE, SIG_IGN);
123: signal(SIGHUP, SIG_IGN);
124:
125: do {
126: s = tcp_sock();
127: if (s < 0) {
128: perror("ftpd: socket");;
129: sleep(5);
130: continue;
131: }
132: if (tcp_listen(s, servp->port, 0, 0) < 0) {
133: close(s);
134: s = -1;
135: sleep(30);
136: continue;
137: }
138: } while (s < 0);
139:
140: signal(SIGCHLD, reapchild);
141: for (;;) {
142: int ctrl;
143:
144: ctrl = tcp_accept(s, &his_addr.saddr, &his_addr.sport, &dev);
145: fprintf(stderr, "accept req from %s, port %d\n", inet_ntoa(his_addr.saddr), his_addr.sport);
146: if (ctrl < 0) {
147: if (errno == EINTR)
148: continue;
149: perror("ftpd: accept");
150: sleep(1);
151: continue;
152: }
153: switch(fork()) {
154: case -1:
155: printf("Out of processes\n");
156: break;
157: case 0:
158: signal (SIGCHLD, SIG_IGN);
159: dolog(&his_addr);
160: close(s);
161: dup2(ctrl, 0), close(ctrl), dup2(0, 1);
162: /*
163: * Set up default state
164: */
165: logged_in = 0;
166: data = -1;
167: type = TYPE_A;
168: form = FORM_N;
169: stru = STRU_F;
170: mode = MODE_S;
171: /* try to do this equivalently
172: (void) getsockname(0, &ctrl_addr, sizeof (ctrl_addr));
173: gethostname(hostname, sizeof (hostname));
174: */
175: reply(220, "%s FTP server (%s) ready.",
176: hostname, version);
177: for (;;) {
178: setjmp(errcatch);
179: yyparse();
180: }
181: }
182: close(ctrl);
183: }
184: }
185:
186: reapchild()
187: {
188: union wait status;
189:
190: while (wait3(&status, WNOHANG, 0) > 0)
191: ;
192: }
193:
194: lostconn()
195: {
196:
197: if (debug)
198: fprintf(stderr, "Lost connection.\n");
199: dologout(-1);
200: }
201:
202: pass(passwd)
203: char *passwd;
204: {
205: char *xpasswd, *savestr();
206: static struct passwd save;
207:
208: if (logged_in || pw == NULL) {
209: reply(503, "Login with USER first.");
210: return;
211: }
212: if (!guest) { /* "ftp" is only account allowed no password */
213: xpasswd = crypt(passwd, pw->pw_passwd);
214: if (*pw->pw_passwd == '\0' || strcmp(xpasswd, pw->pw_passwd)) {
215: reply(530, "Login incorrect.");
216: pw = NULL;
217: return;
218: }
219: }
220: setegid(pw->pw_gid);
221: /* initgroups(pw->pw_name, pw->pw_gid); */
222: if (chdir(pw->pw_dir)) {
223: reply(550, "User %s: can't change directory to $s.",
224: pw->pw_name, pw->pw_dir);
225: goto bad;
226: }
227: if (guest && chroot(pw->pw_dir) < 0) {
228: reply(550, "Can't set guest privileges.");
229: goto bad;
230: }
231: if (!guest)
232: reply(230, "User %s logged in.", pw->pw_name);
233: else
234: reply(230, "Guest login ok, access restrictions apply.");
235: logged_in = 1;
236: dologin(pw);
237: seteuid(pw->pw_uid);
238: /*
239: * Save everything so globbing doesn't
240: * clobber the fields.
241: */
242: save = *pw;
243: save.pw_name = savestr(pw->pw_name);
244: save.pw_passwd = savestr(pw->pw_passwd);
245: save.pw_comment = savestr(pw->pw_comment);
246: save.pw_gecos = savestr(pw->pw_gecos, &save.pw_gecos);
247: save.pw_dir = savestr(pw->pw_dir);
248: save.pw_shell = savestr(pw->pw_shell);
249: pw = &save;
250: home = pw->pw_dir; /* home dir for globbing */
251: return;
252: bad:
253: seteuid(0);
254: pw = NULL;
255: }
256:
257: char *
258: savestr(s)
259: char *s;
260: {
261: char *malloc();
262: char *new = malloc(strlen(s) + 1);
263:
264: if (new != NULL)
265: strcpy(new, s);
266: return (new);
267: }
268:
269: retrieve(cmd, name)
270: char *cmd, *name;
271: {
272: FILE *fin, *dout;
273: struct stat st;
274: int (*closefunc)();
275:
276: st.st_size = 0;
277: if (cmd == 0 &&
278: (stat(name, &st) < 0 || (st.st_mode&S_IFMT) != S_IFREG)) {
279: reply(550, "%s: not a plain file.", name);
280: goto done;
281: }
282: dout = dataconn(name, st.st_size, "w");
283: if (dout == NULL)
284: goto done;
285: if (cmd == 0) {
286: #ifdef notdef
287: /* no remote command execution -- it's a security hole */
288: if (*name == '|')
289: fin = popen(name + 1, "r"), closefunc = pclose;
290: else
291: #endif
292: fin = fopen(name, "r"), closefunc = fclose;
293: } else {
294: char line[BUFSIZ];
295:
296: sprintf(line, cmd, name), name = line;
297: fin = popen(line, "r"), closefunc = pclose;
298: }
299: if (fin == NULL) {
300: if (errno != 0)
301: reply(550, "%s: %s.", name, sys_errlist[errno]);
302: return;
303: }
304: if (send_data(fin, dout) || ferror(dout))
305: reply(550, "%s: %s.", name, sys_errlist[errno]);
306: else
307: reply(226, "Transfer complete.");
308: fclose(dout), data = -1;
309: done:
310: (*closefunc)(fin);
311: }
312:
313: store(name, mode)
314: char *name, *mode;
315: {
316: FILE *fout, *din;
317: int (*closefunc)(), dochown = 0;
318:
319: din = dataconn(name, (off_t)-1, "r");
320: if (din == NULL)
321: goto done;
322: #ifdef notdef
323: /* no remote command execution -- it's a security hole */
324: if (name[0] == '|')
325: fout = popen(&name[1], "w"), closefunc = pclose;
326: else
327: #endif
328: {
329: struct stat st;
330:
331: if (stat(name, &st) < 0)
332: dochown++;
333: fout = fopen(name, mode), closefunc = fclose;
334: }
335: if (fout == NULL) {
336: reply(550, "%s: %s.", name, sys_errlist[errno]);
337: return;
338: }
339: if (receive_data(din, fout) || ferror(fout))
340: reply(550, "%s: %s.", name, sys_errlist[errno]);
341: else
342: reply(226, "Transfer complete.");
343: fclose(din), data = -1;
344: done:
345: if (dochown)
346: (void) chown(name, pw->pw_uid, -1);
347: (*closefunc)(fout);
348: }
349:
350: getdatasock(mode)
351: char *mode;
352: {
353: int s;
354:
355: if (data >= 0)
356: return (data);
357: data_source.saddr = ctrl_addr.saddr;
358: s = tcp_sock();
359: if (s < 0) {
360: perror("ftpd: socket");;
361: return(NULL);
362: }
363:
364: seteuid(pw->pw_uid);
365: return (s);
366: }
367:
368: FILE *
369: dataconn(name, size, mode)
370: char *name;
371: off_t size;
372: char *mode;
373: {
374: char sizebuf[32];
375: FILE *file;
376: int retry = 0;
377:
378: if (size >= 0)
379: sprintf (sizebuf, " (%ld bytes)", size);
380: else
381: (void) strcpy(sizebuf, "");
382: if (data >= 0) {
383: reply(125, "Using existing data connection for %s%s.",
384: name, sizebuf);
385: usedefault = 1;
386: return (fdopen(data, mode));
387: }
388: if (usedefault)
389: data_dest = his_addr;
390: usedefault = 1;
391: data = getdatasock(mode);
392: if (data < 0) {
393: reply(425, "Can't create data socket (%s,%d): %s.",
394: inet_ntoa(data_source.saddr),
395: ntohs(data_source.sport),
396: sys_errlist[errno]);
397: return (NULL);
398: }
399: reply(150, "Opening data connection for %s (%s,%d)%s.",
400: name,
401: inet_ntoa(data_dest.saddr),
402: data_dest.sport, sizebuf);
403:
404: while (tcp_connect(data, 0, data_dest.saddr, data_dest.sport) < 0) {
405: data = -1;
406: if (retry < swaitmax) {
407: data = getdatasock(mode);
408: sleep(swaitint);
409: retry += swaitint;
410: continue;
411: }
412: reply(425, "Can't build data connection: %s.",
413: sys_errlist[errno]);
414: (void)fclose(file);
415: return (NULL);
416: }
417: return (fdopen(data, mode));
418: }
419:
420: /*
421: * Tranfer the contents of "instr" to
422: * "outstr" peer using the appropriate
423: * encapulation of the date subject
424: * to Mode, Structure, and Type.
425: *
426: * NB: Form isn't handled.
427: */
428: send_data(instr, outstr)
429: FILE *instr, *outstr;
430: {
431: register int c;
432: int netfd, filefd, cnt;
433: char buf[BUFSIZ];
434:
435: switch (type) {
436:
437: case TYPE_A:
438: while ((c = getc(instr)) != EOF) {
439: if (c == '\n') {
440: if (ferror (outstr))
441: return (1);
442: putc('\r', outstr);
443: }
444: putc(c, outstr);
445: if (c == '\r')
446: putc ('\0', outstr);
447: }
448: if (ferror (instr) || ferror (outstr))
449: return (1);
450: return (0);
451:
452: case TYPE_I:
453: case TYPE_L:
454: netfd = fileno(outstr);
455: filefd = fileno(instr);
456:
457: while ((cnt = read(filefd, buf, sizeof (buf))) > 0)
458: if (write(netfd, buf, cnt) < 0)
459: return (1);
460: return (cnt < 0);
461: }
462: reply(504,"Unimplemented TYPE %d in send_data", type);
463: return (1);
464: }
465:
466: /*
467: * Transfer data from peer to
468: * "outstr" using the appropriate
469: * encapulation of the data subject
470: * to Mode, Structure, and Type.
471: *
472: * N.B.: Form isn't handled.
473: */
474: receive_data(instr, outstr)
475: FILE *instr, *outstr;
476: {
477: register int c;
478: int cnt;
479: char buf[BUFSIZ];
480:
481:
482: switch (type) {
483:
484: case TYPE_I:
485: case TYPE_L:
486: while ((cnt = read(fileno(instr), buf, sizeof buf)) > 0)
487: if (write(fileno(outstr), buf, cnt) < 0)
488: return (1);
489: return (cnt < 0);
490:
491: case TYPE_E:
492: reply(504, "TYPE E not implemented.");
493: return (1);
494:
495: case TYPE_A:
496: while ((c = getc(instr)) != EOF) {
497: if (c == '\r') {
498: if (ferror (outstr))
499: return (1);
500: if ((c = getc(instr)) != '\n')
501: putc ('\r', outstr);
502: if (c == '\0')
503: continue;
504: }
505: putc (c, outstr);
506: }
507: if (ferror (instr) || ferror (outstr))
508: return (1);
509: return (0);
510: }
511: fatal("Unknown type in receive_data.");
512: /*NOTREACHED*/
513: }
514:
515: fatal(s)
516: char *s;
517: {
518: reply(451, "Error in server: %s\n", s);
519: reply(221, "Closing connection due to server error.");
520: dologout(0);
521: }
522:
523: reply(n, s, args)
524: int n;
525: char *s;
526: {
527:
528: printf("%d ", n);
529: _doprnt(s, &args, stdout);
530: printf("\r\n");
531: fflush(stdout);
532: if (debug) {
533: fprintf(stderr, "<--- %d ", n);
534: _doprnt(s, &args, stderr);
535: fprintf(stderr, "\n");
536: fflush(stderr);
537: }
538: }
539:
540: lreply(n, s, args)
541: int n;
542: char *s;
543: {
544: printf("%d-", n);
545: _doprnt(s, &args, stdout);
546: printf("\r\n");
547: fflush(stdout);
548: if (debug) {
549: fprintf(stderr, "<--- %d-", n);
550: _doprnt(s, &args, stderr);
551: fprintf(stderr, "\n");
552: }
553: }
554:
555: replystr(s)
556: char *s;
557: {
558: printf("%s\r\n", s);
559: fflush(stdout);
560: if (debug)
561: fprintf(stderr, "<--- %s\n", s);
562: }
563:
564: ack(s)
565: char *s;
566: {
567: reply(200, "%s command okay.", s);
568: }
569:
570: nack(s)
571: char *s;
572: {
573: reply(502, "%s command not implemented.", s);
574: }
575:
576: yyerror()
577: {
578: reply(500, "Command not understood.");
579: }
580:
581: delete(name)
582: char *name;
583: {
584: struct stat st;
585:
586: if (stat(name, &st) < 0) {
587: reply(550, "%s: %s.", name, sys_errlist[errno]);
588: return;
589: }
590: if ((st.st_mode&S_IFMT) == S_IFDIR) {
591: if (rmdir(name) < 0) {
592: reply(550, "%s: %s.", name, sys_errlist[errno]);
593: return;
594: }
595: goto done;
596: }
597: if (unlink(name) < 0) {
598: reply(550, "%s: %s.", name, sys_errlist[errno]);
599: return;
600: }
601: done:
602: ack("DELE");
603: }
604:
605: cwd(path)
606: char *path;
607: {
608:
609: if (chdir(path) < 0) {
610: reply(550, "%s: %s.", path, sys_errlist[errno]);
611: return;
612: }
613: ack("CWD");
614: }
615:
616: makedir(name)
617: char *name;
618: {
619: struct stat st;
620: int dochown = stat(name, &st) < 0;
621:
622: if (mkdir(name, 0777) < 0) {
623: reply(550, "%s: %s.", name, sys_errlist[errno]);
624: return;
625: }
626: if (dochown)
627: (void) chown(name, pw->pw_uid, -1);
628: ack("MKDIR");
629: }
630:
631: removedir(name)
632: char *name;
633: {
634:
635: if (rmdir(name) < 0) {
636: reply(550, "%s: %s.", name, sys_errlist[errno]);
637: return;
638: }
639: ack("RMDIR");
640: }
641:
642: #define MAXPATHLEN 256
643: pwd()
644: {
645: char path[MAXPATHLEN + 1];
646:
647: if (getwd(path) == NULL) {
648: reply(451, "%s.", path);
649: return;
650: }
651: reply(251, "\"%s\" is current directory.", path);
652: }
653:
654: char *
655: renamefrom(name)
656: char *name;
657: {
658: struct stat st;
659:
660: if (stat(name, &st) < 0) {
661: reply(550, "%s: %s.", name, sys_errlist[errno]);
662: return ((char *)0);
663: }
664: reply(350, "File exists, ready for destination name");
665: return (name);
666: }
667:
668: renamecmd(from, to)
669: char *from, *to;
670: {
671:
672: if (rename(from, to) < 0) {
673: reply(550, "rename: %s.", sys_errlist[errno]);
674: return;
675: }
676: ack("RNTO");
677: }
678:
679: dolog(addr)
680: register struct socket *addr;
681: {
682: char *h_name = (char *)in_host(addr->saddr);
683: time_t t;
684:
685: strncpy(remotehost, h_name, sizeof (remotehost));
686: if (!logging)
687: return;
688: t = time(0);
689: fprintf(stderr,"FTPD: connection from %s at %s", remotehost, ctime(&t));
690: fflush(stderr);
691: }
692:
693: #include <utmp.h>
694:
695: #define SCPYN(a, b) strncpy(a, b, sizeof (a))
696: struct utmp utmp;
697:
698: /*
699: * Record login in wtmp file.
700: */
701:
702: #define O_WRONLY 1
703: #define O_APPEND 1
704: dologin(pw)
705: struct passwd *pw;
706: {
707: int wtmp;
708: char line[32];
709:
710: wtmp = open("/usr/adm/wtmp", O_WRONLY|O_APPEND);
711: if (wtmp >= 0) {
712: /* hack, but must be unique and no tty line */
713: sprintf(line, "ftp%d", getpid());
714: SCPYN(utmp.ut_line, line);
715: SCPYN(utmp.ut_name, pw->pw_name);
716: utmp.ut_time = time(0);
717: (void) write(wtmp, (char *)&utmp, sizeof (utmp));
718: (void) close(wtmp);
719: }
720: }
721:
722: /*
723: * Record logout in wtmp file
724: * and exit with supplied status.
725: */
726: dologout(status)
727: int status;
728: {
729: int wtmp;
730:
731: if (!logged_in)
732: _exit(status);
733: seteuid(0);
734: wtmp = open("/usr/adm/wtmp", O_WRONLY|O_APPEND);
735: if (wtmp >= 0) {
736: SCPYN(utmp.ut_name, "");
737: utmp.ut_time = time(0);
738: (void) write(wtmp, (char *)&utmp, sizeof (utmp));
739: (void) close(wtmp);
740: }
741: /* beware of flushing buffers after a SIGPIPE */
742: _exit(status);
743: }
744:
745: /*
746: * Special version of popen which avoids
747: * call to shell. This insures noone may
748: * create a pipe to a hidden program as a side
749: * effect of a list or dir command.
750: */
751: #define tst(a,b) (*mode == 'r'? (b) : (a))
752: #define RDR 0
753: #define WTR 1
754: static int popen_pid[5];
755:
756: static char *
757: nextarg(cpp)
758: char *cpp;
759: {
760: register char *cp = cpp;
761:
762: if (cp == 0)
763: return (cp);
764: while (*cp && *cp != ' ' && *cp != '\t')
765: cp++;
766: if (*cp == ' ' || *cp == '\t') {
767: *cp++ = '\0';
768: while (*cp == ' ' || *cp == '\t')
769: cp++;
770: }
771: if (cp == cpp)
772: return ((char *)0);
773: return (cp);
774: }
775:
776: FILE *
777: popen(cmd, mode)
778: char *cmd, *mode;
779: {
780: int p[2], ac, gac;
781: register myside, hisside, pid;
782: char *av[20], *gav[512];
783: register char *cp;
784:
785: if (pipe(p) < 0)
786: return (NULL);
787: cp = cmd, ac = 0;
788: /* break up string into pieces */
789: do {
790: av[ac++] = cp;
791: cp = nextarg(cp);
792: } while (cp && *cp && ac < 20);
793: av[ac] = (char *)0;
794: gav[0] = av[0];
795: /* glob each piece */
796: for (gac = ac = 1; av[ac] != NULL; ac++) {
797: char **pop;
798: extern char **glob();
799:
800: pop = glob(av[ac]);
801: if (pop) {
802: av[ac] = (char *)pop; /* save to free later */
803: while (*pop && gac < 512)
804: gav[gac++] = *pop++;
805: }
806: }
807: gav[gac] = (char *)0;
808: myside = tst(p[WTR], p[RDR]);
809: hisside = tst(p[RDR], p[WTR]);
810: if ((pid = fork()) == 0) {
811: /* myside and hisside reverse roles in child */
812: close(myside);
813: dup2(hisside, tst(0, 1));
814: close(hisside);
815: execv(gav[0], gav);
816: _exit(1);
817: }
818: for (ac = 1; av[ac] != NULL; ac++)
819: blkfree((char **)av[ac]);
820: if (pid == -1)
821: return (NULL);
822: popen_pid[myside] = pid;
823: close(hisside);
824: return (fdopen(myside, mode));
825: }
826:
827: pclose(ptr)
828: FILE *ptr;
829: {
830: register f, r, (*hstat)(), (*istat)(), (*qstat)();
831: int status;
832:
833: f = fileno(ptr);
834: fclose(ptr);
835: istat = signal(SIGINT, SIG_IGN);
836: qstat = signal(SIGQUIT, SIG_IGN);
837: hstat = signal(SIGHUP, SIG_IGN);
838: while ((r = wait(&status)) != popen_pid[f] && r != -1)
839: ;
840: if (r == -1)
841: status = -1;
842: signal(SIGINT, istat);
843: signal(SIGQUIT, qstat);
844: signal(SIGHUP, hstat);
845: return (status);
846: }
847:
848: /*
849: * Check user requesting login priviledges.
850: * Disallow anyone mentioned in the file FTPUSERS
851: * to allow people such as uucp to be avoided.
852: */
853: checkuser(name)
854: register char *name;
855: {
856: char line[BUFSIZ], *index();
857: FILE *fd;
858: int found = 0;
859:
860: fd = fopen(FTPUSERS, "r");
861: if (fd == NULL)
862: return (1);
863: while (fgets(line, sizeof (line), fd) != NULL) {
864: register char *cp = index(line, '\n');
865:
866: if (cp)
867: *cp = '\0';
868: if (strcmp(line, name) == 0) {
869: found++;
870: break;
871: }
872: }
873: fclose(fd);
874: return (!found);
875: }
876: seteuid(uid)
877: {
878: return(setuid(uid));
879: }
880: setegid(gid)
881: {
882: return(setgid(gid));
883: }
884:
885: rename(from, to)
886: {
887: if (-1 == link(from, to))
888: return(-1);
889: return(unlink(from));
890: }
891: inet_ntoa(addr)
892: long addr;
893: {
894: static char b[32];
895: unsigned char *xp = (unsigned char *)&addr;
896:
897: sprintf(b, "%d.%d.%d.%d", xp[3], xp[2], xp[1], xp[0]);
898: return(b);
899: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.