![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gaptelnetd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / xns / examples / gap|
Return to gaptelnetd.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / xns / examples / gap |
1.1 root 1: #ifndef lint
2: static char RCSid[] = "$Header: gaptelnetd.c,v 2.0 85/11/21 07:23:06 jqj Exp $";
3: #endif
4: /*
5: * server for GAP-style (TransportObject=server,teletype) telnet connections
6: * Note that we support only GAP version 3
7: */
8:
9: /* $Log: gaptelnetd.c,v $
10: * Revision 2.0 85/11/21 07:23:06 jqj
11: * 4.3BSD standard release
12: *
13: * Revision 1.3 85/11/21 06:53:22 jqj
14: * symbolic values for connection type
15: *
16: * Revision 1.2 85/11/08 17:17:13 bill
17: * version on bullwinkle
18: *
19: * Revision 1.3 85/08/05 09:58:00 jqj
20: * fixed for Interlisp -- data from Interlisp appears with dt==0 (wrong!)
21: * also, Interlisp trys to connect to a tty rather than a ttyHost.
22: * increased inactivity timeout to 4 hrs
23: *
24: * Revision 1.2 85/05/23 06:22:18 jqj
25: * *** empty log message ***
26: *
27: * Revision 1.1 85/05/22 09:46:52 jqj
28: * Initial revision
29: */
30: #include <stdio.h>
31: #include <signal.h>
32: #include <sgtty.h>
33: #include <sys/types.h>
34: #include <sys/time.h>
35: #include <sys/uio.h>
36: #include <sys/socket.h>
37: #include <netns/ns.h>
38: #include <netns/idp.h>
39: #include <netns/sp.h>
40: #include <sys/wait.h>
41: #include <xnscourier/realcourierconnection.h>
42: #include "GAP3.h"
43: #include "gapcontrols.h"
44: #include <xnscourier/except.h>
45: #include <errno.h>
46:
47: #define BELL '\07'
48: #define BANNER "\r\n\r\n4.3 BSD UNIX (%s)\r\n\r\r\n\r"
49:
50: int pty, net;
51: extern CourierConnection *_serverConnection;
52: char buf[sizeof(struct sphdr)+SPPMAXDATA];
53: struct sphdr our_sphdr;
54: struct iovec our_iovec[2] = {{((caddr_t)&our_sphdr), sizeof(our_sphdr)}};
55: /*
56: * I/O data buffers, pointers, and counters.
57: */
58: char ptyibuf[512], *ptyip = ptyibuf;
59: char ptyobuf[BUFSIZ], *pfrontp = ptyobuf, *pbackp = ptyobuf;
60: char *netip = buf;
61: char netobuf[512], *nfrontp = netobuf, *nbackp = netobuf;
62: int pcc, ncc;
63: char line[12];
64: extern char **environ;
65: extern int errno;
66:
67: char *envinit[3];
68: char wsenv[50];
69:
70: /*
71: * session parameters
72: */
73: Cardinal frametimeout; /* 0 or time in seconds to wait */
74:
75:
76: /*
77: * This modified version of the server is necessary since GAP specifies
78: * that the telnet data-transfer session occurs after the RPC to create
79: * it has returned!
80: */
81: Server(skipcount,skippedwords)
82: int skipcount;
83: Unspecified skippedwords[];
84: {
85: Cardinal _procedure;
86: register Unspecified *_buf;
87: LongCardinal programnum;
88: Cardinal versionnum;
89: Cardinal _n;
90:
91: #ifdef DEBUG
92: BUGOUT("Server: %d %d",skipcount,skippedwords);
93: #endif
94: for (;;) {
95: _buf = ReceiveCallMessage(&_procedure, skipcount, skippedwords);
96: DURING switch (_procedure) {
97: case 3:
98: server_GAP3_Delete(_buf);
99: break;
100: case 2:
101: server_GAP3_Create(_buf);
102: net = _serverConnection->fd;
103: gaptelnet(); /* returns on connection close */
104: break;
105: case 0:
106: server_GAP3_Reset(_buf);
107: break;
108: default:
109: NoSuchProcedureValue("GAP", _procedure);
110: break;
111: } HANDLER {
112: Deallocate(_buf);
113: switch (Exception.Code) {
114: case GAP3_serviceNotFound:
115: case GAP3_userNotAuthorized:
116: case GAP3_userNotAuthenticated:
117: case GAP3_serviceTooBusy:
118: case GAP3_terminalAddressInvalid:
119: case GAP3_terminalAddressInUse:
120: case GAP3_controllerDoesNotExist:
121: case GAP3_controllerAlreadyExists:
122: case GAP3_gapCommunicationError:
123: case GAP3_gapNotExported:
124: case GAP3_bugInGAPCode:
125: case GAP3_tooManyGateStreams:
126: case GAP3_inconsistentParams:
127: case GAP3_transmissionMediumUnavailable:
128: case GAP3_dialingHardwareProblem:
129: case GAP3_noDialingHardware:
130: case GAP3_badAddressFormat:
131: case GAP3_mediumConnectFailed:
132: case GAP3_illegalTransport:
133: case GAP3_noCommunicationHardware:
134: case GAP3_unimplemented:
135: _buf = Allocate(0);
136: SendAbortMessage(Exception.Code-ERROR_OFFSET, 0, _buf);
137: break;
138: default:
139: _buf = Allocate(0);
140: SendRejectMessage(unspecifiedError, 0, _buf);
141: break;
142: }
143: } END_HANDLER;
144: Deallocate(_buf);
145: for (;;) {
146: skipcount = LookAheadCallMsg(&programnum, &versionnum,
147: skippedwords);
148: if (skipcount < 0) return(0); /* timed out */
149: if (programnum != 3 || versionnum != 3)
150: ExecCourierProgram(programnum, versionnum,
151: skipcount, skippedwords);
152: } /* loop if can't exec that program */
153: }
154: }
155:
156: void
157: GAP3_Delete(session)
158: GAP3_SessionHandle session;
159: {
160: }
161:
162: void
163: GAP3_Reset()
164: {
165: }
166:
167: GAP3_CreateResults
168: GAP3_Create(conn, BDTproc, sessionparams, transports,
169: createTimeout, credentials, verifier)
170: CourierConnection *conn;
171: int BDTproc;
172: GAP3_SessionParameterObject sessionparams;
173: struct {Cardinal length;
174: GAP3_TransportObject *sequence;
175: } transports;
176: GAP3_WaitTime createTimeout;
177: Authentication1_Credentials credentials;
178: Authentication1_Verifier verifier;
179: {
180: GAP3_CreateResults result;
181: char *c1, *c2, *host;
182: int t, pid;
183: struct sgttyb b;
184: char *xntoa(), *wsname();
185: struct sockaddr_ns who;
186: int whosize = sizeof(who);
187: LongCardinal servicetype;
188: GAP3_CommParamObject *cp;
189: GAP3_Duplexity duplexity; /* fullDuplex, halfDuplex */
190:
191: #ifdef DEBUG
192: BUGOUT("CREATE");
193: #endif
194: switch (sessionparams.designator) {
195: case oldTty:
196: case oldTtyHost:
197: frametimeout = sessionparams.oldTtyHost_case.frameTimeout/1000;
198: /* could set other parameters here */
199: break;
200: case tty:
201: case ttyHost:
202: frametimeout = sessionparams.ttyHost_case.frameTimeout/1000;
203: /* could set other parameters here */
204: break;
205: default:
206: raise(GAP3_unimplemented, 0);
207: /*NOTREACHED*/
208: }
209: if (transports.length != 2) {
210: raise(GAP3_illegalTransport);
211: /*NOTREACHED*/
212: }
213: switch (transports.sequence[0].designator) {
214: case service:
215: servicetype = transports.sequence[0].service_case.id;
216: switch (servicetype) {
217: case TTYService_any: /* 0 */
218: servicetype = TTYService_sa;
219: case TTYService_sa: /* 1 */
220: case TTYService_exec: /* 2 */
221: case TTYService_its: /* 3 */
222: break;
223: default:
224: raise(GAP3_serviceNotFound, 0);
225: /*NOTREACHED*/
226: }
227: duplexity = fullduplex;/* services are allways fulldup */
228: break;
229: case rs232c: /* maybe some day */
230: cp = &transports.sequence[0].rs232c_case.commParams;
231: if (cp->accessDetail.designator == directConn) {
232: duplexity = cp->accessDetail.directConn_case.duplex;
233: servicetype = TTYService_sa; /* fake it */
234: break;
235: }
236: raise(GAP3_noCommunicationHardware, 0);
237: /*NOTREACHED*/
238: default:
239: raise(GAP3_illegalTransport, 0);
240: /*NOTREACHED*/
241: }
242: if (transports.sequence[1].designator != teletype)
243: raise(GAP3_illegalTransport, 0);
244: /* ignore createTimeout */
245: /* ignore credentials and verifier */
246:
247: for (c1 = "pq"; *c1 != 0; c1++)
248: for (c2 = "0123456789abcdef"; *c2 != 0; c2++) {
249: sprintf(line, "/dev/pty%c%c", *c1, *c2);
250: pty = open(line, 2);
251: if (pty < 0) continue;
252: line[strlen("/dev/")] = 't';
253: t = open(line, 2);
254: if (t > 0) goto gotpty;
255: close(pty);
256: }
257: raise(GAP3_serviceTooBusy, 0);
258: /*NOTREACHED*/
259: gotpty:
260: getpeername(_serverConnection->fd, &who, &whosize);
261: host = wsname(who.sns_addr);
262: #ifdef DEBUG
263: BUGOUT("gotpty <%s> %d <%s>",line, pty, host);
264: #endif
265: ioctl(t, TIOCGETP, &b);
266: b.sg_flags = CRMOD|XTABS|ANYP;
267: ioctl(t, TIOCSETP, &b);
268: ioctl(pty, TIOCGETP, &b);
269: if (duplexity == fullduplex)
270: b.sg_flags |= ECHO;
271: else
272: b.sg_flags &= ~ECHO;
273: ioctl(pty, TIOCSETP, &b);
274: /* we do the fork now so we can return failures as REPORTS */
275: pid = fork();
276: if (pid < 0) {
277: close(pty); close(t);
278: raise(GAP3_serviceTooBusy, 0);
279: /*NOTREACHED*/
280: }
281: else if (pid == 0) { /* in the execed fork */
282: sleep(1); /* let parent get ready for us */
283: close(_serverConnection->fd); /* close net */
284: close(pty);
285: dup2(t, 0);
286: dup2(t, 1);
287: dup2(t, 2);
288: if (t > 2) close(t);
289: envinit[0] = "TERM=network";
290: envinit[1] = sprintf(wsenv, "WORKSTATION=%s",
291: xntoa(who.sns_addr));
292: envinit[2] = (char*) 0;
293: #ifdef DEBUG
294: BUGOUT("about to exec /bin/login");
295: #endif
296: execl("/bin/login","login", "-h", host, 0);
297: #ifdef DEBUG
298: BUGOUT("exec of /bin/login failed");
299: #endif
300: perror("/bin/login");
301: exit(1);
302: /*NOTREACHED*/
303: }
304: close(t);
305: #ifdef DEBUG
306: BUGOUT("fork successful");
307: #endif
308: result.session[0] = pid;
309: return(result);
310: }
311:
312: jmp_buf childdiedbuf;
313:
314: /*
315: * Main loop. Select from pty and network, and
316: * hand data to telnet receiver finite state machine.
317: * Returns 0 on orderly shutdown, 1 on abnormal shutdown.
318: */
319: gaptelnet()
320: {
321: int on = 1;
322: char hostname[32];
323: int childdied();
324: int ibits = 0, obits = 0;
325: register int c;
326: struct sphdr *si = (struct sphdr *)buf;
327: static struct timeval timeout = {600,0};
328: int keepalives = 0;
329: int i;
330:
331: #ifdef DEBUG
332: BUGOUT("gaptelnet net=%d,pty=%d",net,pty);
333: #endif
334: if (setjmp(childdiedbuf) != 0)
335: return(0); /* child died */
336: signal(SIGCHLD, childdied);
337: signal(SIGTSTP, SIG_IGN);
338: ioctl(net, FIONBIO, &on);
339: ioctl(pty, FIONBIO, &on);
340:
341:
342: /*
343: * Show banner that getty never gave.
344: */
345: gethostname(hostname, sizeof (hostname));
346: sprintf(nfrontp, BANNER, hostname);
347: nfrontp += strlen(nfrontp);
348: /*
349: * Send status message indicating we're ready to go
350: */
351: changeSPPopts(net, GAPCTLnone, 1);
352: sendoobdata(GAPCTLmediumUp);
353: for (;;) {
354: #ifdef DEBUG
355: BUGOUT("looping in gaptelnet");
356: #endif
357: ibits = obits = 0;
358: /*
359: * Never look for input if there's still
360: * stuff in the corresponding output buffer
361: */
362: if (nfrontp - nbackp || pcc > 0)
363: obits |= (1 << net);
364: else
365: ibits |= (1 << pty);
366: if (pfrontp - pbackp || ncc > 0)
367: obits |= (1 << pty);
368: else
369: ibits |= (1 << net);
370: if (ncc < 0 && pcc < 0)
371: break;
372: timeout.tv_sec = 14400; /* 4 hrs. */
373: timeout.tv_usec = 0;
374: select(16, &ibits, &obits, 0, &timeout);
375: if (ibits == 0 && obits == 0) {
376: /* timeout means no activity for a long time */
377: #ifdef DEBUG
378: BUGOUT("timeout from select");
379: #endif
380: if (keepalives++ < 2) {
381: /* first time through send warning */
382: if (nfrontp == nbackp && pcc == 0) {
383: /* but only if not blocked on output */
384: #define WARNING "\r\nYou've been idle much too long. Respond or log off.\r\n"
385: strcpy(nfrontp, WARNING);
386: nfrontp += sizeof(WARNING);
387: }
388: sleep(5);
389: continue;
390: }
391: #ifdef DEBUG
392: BUGOUT("keepalive expired -- calling cleanup");
393: #endif
394: /* keepalive count has expired */
395: cleanup();
396: return(1);
397: }
398:
399: /*
400: * Something to read from the network...
401: */
402: if (ibits & (1 << net)) {
403: ncc = read(net, buf, sizeof(buf));
404: #ifdef DEBUG
405: BUGOUT("read %d from net, cc=0%o,dt=0%o",
406: ncc-sizeof(struct sphdr), si->sp_cc, si->sp_dt);
407: #endif
408: if (ncc < 0 && errno == EWOULDBLOCK)
409: ncc = 0;
410: else if (ncc < sizeof(struct sphdr)) {
411: #ifdef DEBUG
412: BUGOUT("short read, %d. calling cleanup",ncc);
413: #endif
414: cleanup(); /* will probably fail or block */
415: return(1);
416: }
417: else if (si->sp_cc & SP_OB) {
418: #ifdef DEBUG
419: BUGOUT("Got OOB control 0%o",
420: (u_char) buf[sizeof(struct sphdr)]);
421: #endif
422: /* a status or OOB control */
423: switch ((u_char) buf[sizeof(struct sphdr)]) {
424: case GAPCTLinterrupt:
425: /* shove interrupt char in buffer */
426: interrupt();
427: break; /* from switch */
428: case GAPCTLareYouThere:
429: sendoobdata(GAPCTLiAmHere);
430: break; /* from switch */
431: default:
432: /* Ignore other controls instead of:
433: * sendoobdata(
434: * GAPCTLunexpectedRemoteBehavior);
435: */
436: break; /* from switch */
437: }
438: ncc = 0; /* no chars here */
439: }
440: else if (si->sp_dt==GAPCTLnone ||
441: si->sp_dt==0) {
442: /* the normal case */
443: /* N.B. the standard says dt should be 0300
444: * i.e. GAPCTLnone, but Interlisp CHAT
445: * generates 0, so we accept that too.
446: */
447: ncc -= sizeof(struct sphdr);
448: #ifdef DEBUG
449: BUGOUT("Now ncc == %d",ncc);
450: #endif
451: netip = buf + sizeof(struct sphdr);
452: keepalives = 0;
453: }
454: else if(si->sp_dt==GAPCTLcleanup) {
455: #ifdef DEBUG
456: BUGOUT("got CLEANUP packet. Done");
457: #endif
458: cleanup(); /* normal termination */
459: return(0);
460: }
461: else if (si->sp_dt==SPPSST_END) {
462: /* got premature termination */
463: quitquit(net, pty);
464: return(1);
465: }
466: else {
467: /* some other inband ctl */
468: #ifdef DEBUG
469: BUGOUT("ignoring IB packet, data = 0%o...",
470: (u_char) buf[sizeof(struct sphdr)]);
471: #endif
472: }
473: }
474:
475: /*
476: * Something to read from the pty...
477: */
478: if (ibits & (1 << pty)) {
479: if (frametimeout > 0) sleep(frametimeout);
480: pcc = read(pty, ptyibuf, sizeof(ptyibuf));
481: #ifdef DEBUG
482: BUGOUT("read from pty %d",pcc);
483: #endif
484: if (pcc < 0 && errno == EWOULDBLOCK)
485: pcc = 0;
486: else if (pcc <= 0) {
487: #ifdef DEBUG
488: BUGOUT("short read from pty. Calling cleanup");
489: #endif
490: cleanup();
491: return(1); /* ?? abnormal termination */
492: }
493: ptyip = ptyibuf;
494: }
495:
496: while (pcc > 0) {
497: if ((&netobuf[sizeof(netobuf)] - nfrontp) < 2)
498: break;
499: *nfrontp++ = *ptyip++ & 0377; pcc--;
500: }
501: if ((obits & (1 << net)) && (nfrontp - nbackp) > 0)
502: netflush();
503: while (ncc > 0) {
504: if ((&ptyobuf[sizeof(ptyobuf)] - pfrontp) < 2) break;
505: *pfrontp++ = *netip++ & 0377;
506: ncc--;
507: }
508: if ((obits & (1 << pty)) && (pfrontp - pbackp) > 0)
509: ptyflush();
510: }
511: /* we should never get to here */
512: #ifdef DEBUG
513: BUGOUT("broke out of for(;;) somehow. calling cleanup");
514: #endif
515: cleanup();
516: return(0);
517: }
518:
519: /*
520: * Send out of band data to other end of network
521: */
522: sendoobdata(value)
523: u_char value;
524: {
525: struct {
526: struct sphdr hdr;
527: char val;
528: } oob;
529: oob.hdr = our_sphdr;
530: oob.val = value;
531: #ifdef DEBUG
532: BUGOUT("sendoobdata 0%o",value);
533: #endif
534: send(net, &oob, sizeof(oob), MSG_OOB);
535: }
536:
537: /*
538: * Send interrupt to process on other side of pty.
539: * If it is in raw mode, just write NULL;
540: * otherwise, write intr char.
541: */
542: interrupt()
543: {
544: struct sgttyb b;
545: struct tchars tchars;
546:
547: ptyflush(); /* half-hearted */
548: ioctl(pty, TIOCGETP, &b);
549: if (b.sg_flags & RAW) {
550: *pfrontp++ = '\0';
551: return;
552: }
553: *pfrontp++ = ioctl(pty, TIOCGETC, &tchars) < 0 ?
554: '\177' : tchars.t_intrc;
555: }
556:
557: ptyflush()
558: {
559: register int n;
560:
561: if ((n = pfrontp - pbackp) > 0)
562: n = write(pty, pbackp, n);
563: #ifdef DEBUG
564: BUGOUT("ptyflush wrote %d",n);
565: #endif
566: if (n < 0)
567: return;
568: pbackp += n;
569: if (pbackp >= pfrontp) /* actually, > is an error */
570: pbackp = pfrontp = ptyobuf;
571: }
572:
573: netflush()
574: {
575: register int n;
576:
577: if ((n = nfrontp - nbackp) > 0) {
578: our_iovec[1].iov_len = ((n > SPPMAXDATA) ? SPPMAXDATA : n);
579: our_iovec[1].iov_base = nbackp;
580: n = writev(net, our_iovec, 2) - sizeof(struct sphdr);
581: }
582: #ifdef DEBUG
583: BUGOUT("netflush wrote %d",n);
584: if (our_iovec[0].iov_base != (char*)&our_sphdr)
585: BUGOUT("Oops: our_iovec clobbered");
586: BUGOUT("header: %d %d, %d %d %d %d %d %d",
587: our_sphdr.sp_cc, our_sphdr.sp_dt,
588: our_sphdr.sp_sid, our_sphdr.sp_did, our_sphdr.sp_seq,
589: our_sphdr.sp_ack, our_sphdr.sp_alo);
590: #endif
591: if (n < 0) {
592: if (errno == EWOULDBLOCK)
593: return;
594: /* should blow this guy away... */
595: return;
596: }
597: nbackp += n;
598: if (nbackp >= nfrontp) /* actually , > is an error */
599: nbackp = nfrontp = netobuf;
600: }
601:
602: /*
603: * handle receipt of an SPPSST_END packet
604: * This is currently an error, since client didn't send "cleanup" first
605: */
606: quitquit()
607: {
608: #ifdef DEBUG
609: BUGOUT("quitquit");
610: #endif
611: changeSPPopts(net, SPPSST_ENDREPLY, 1);
612: write(net, &our_sphdr, sizeof(our_sphdr));
613: sleep(3);
614:
615: rmut();
616: vhangup(); /* XXX */
617: shutdown(net, 1);
618: close(net);
619: }
620:
621: /*
622: * shut down the data connection for one reason or another
623: */
624: cleanup()
625: {
626: int fdmask;
627: struct timeval timeout;
628: struct sphdr *si = (struct sphdr *)buf;
629: int off = 0;
630:
631: signal(SIGCHLD, SIG_IGN);
632: sendoobdata(GAPCTLcleanup);
633: changeSPPopts(net, SPPSST_END, 1);
634: if (write(net, &our_sphdr, sizeof(our_sphdr)) < 0) {
635: fdmask = 1<<net;
636: timeout.tv_sec = 10;
637: while (select(net+1,&fdmask,(int*)0, (int*)0, &timeout) > 0 &&
638: read(net,buf,sizeof(buf)) >= sizeof(struct sphdr)) {
639: #ifdef DEBUG
640: BUGOUT("cleanup -- got packet");
641: #endif
642: if ((!(si->sp_cc & SP_OB))
643: && si->sp_dt == SPPSST_ENDREPLY) {
644: changeSPPopts(net, SPPSST_ENDREPLY, 1);
645: write(net, &our_sphdr, sizeof(our_sphdr));
646: #ifdef DEBUG
647: BUGOUT("cleanup -- wrote ENDREPLY");
648: #endif
649: sleep(1);
650: changeSPPopts(net,0,0);
651: ioctl(net, FIONBIO, &off);
652: rmut();
653: vhangup(); /* XXX */
654: return;
655: }
656: /* loop: ignore everything except ENDREPLY */
657: fdmask = 1<<net;
658: timeout.tv_sec = 10;
659: }
660: /* timed out or read failed */
661: changeSPPopts(net, SPPSST_ENDREPLY, 1);
662: write(net, &our_sphdr, sizeof(our_sphdr));
663: sleep(1);
664: }
665: shutdown(net, 1);
666: close(net);
667: rmut();
668: vhangup(); /* XXX */
669: }
670:
671: /*
672: * SIGCHLD interrupt handler
673: */
674: childdied()
675: {
676: #ifdef DEBUG
677: BUGOUT("child died");
678: #endif
679: cleanup();
680: longjmp(childdiedbuf, -1);
681: }
682:
683: changeSPPopts(s, stream, eom)
684: int s; /* SPP socket */
685: u_char stream; /* datastream type */
686: char eom; /* Boolean EOM */
687: {
688: our_sphdr.sp_dt = stream;
689: our_sphdr.sp_cc = (eom ? SP_EM : 0);
690: }
691:
692:
693: #include <utmp.h>
694:
695: struct utmp wtmp;
696: char wtmpf[] = "/usr/adm/wtmp";
697: char utmp[] = "/etc/utmp";
698: #define SCPYN(a, b) strncpy(a, b, sizeof (a))
699: #define SCMPN(a, b) strncmp(a, b, sizeof (a))
700:
701: rmut()
702: {
703: register f;
704: int found = 0;
705:
706: f = open(utmp, 2);
707: if (f >= 0) {
708: while(read(f, (char *)&wtmp, sizeof (wtmp)) == sizeof (wtmp)) {
709: if (SCMPN(wtmp.ut_line, line+5) || wtmp.ut_name[0]==0)
710: continue;
711: lseek(f, -(long)sizeof (wtmp), 1);
712: SCPYN(wtmp.ut_name, "");
713: SCPYN(wtmp.ut_host, "");
714: time(&wtmp.ut_time);
715: write(f, (char *)&wtmp, sizeof (wtmp));
716: found++;
717: }
718: close(f);
719: }
720: if (found) {
721: f = open(wtmpf, 1);
722: if (f >= 0) {
723: SCPYN(wtmp.ut_line, line+5);
724: SCPYN(wtmp.ut_name, "");
725: SCPYN(wtmp.ut_host, "");
726: time(&wtmp.ut_time);
727: lseek(f, (long)0, 2);
728: write(f, (char *)&wtmp, sizeof (wtmp));
729: close(f);
730: }
731: }
732: chmod(line, 0666);
733: chown(line, 0, 0);
734: line[strlen("/dev/")] = 'p';
735: chmod(line, 0666);
736: chown(line, 0, 0);
737: }
738:
739: /*
740: * Convert network-format xns address
741: * to ascii
742: * --Replace this with a clearinghouse name lookup someday.
743: */
744: char *
745: wsname(addr)
746: struct ns_addr addr;
747: {
748: static char b[50];
749: char temp[10];
750: int i;
751:
752: /* net */
753: sprintf(b, "%D.", ntohl(ns_netof(addr)));
754: /* skip leading zeros */
755: for(i=0; (addr.x_host.c_host[i] == (char) 0); i++) ;
756: /* print the rest */
757: for(; i < 6; i++) {
758: sprintf(temp,"%x", addr.x_host.c_host[i]);
759: strcat(b, temp);
760: if(i != 5) strcat(b, ":");
761: }
762: return (b);
763: }
764:
765: /*
766: * generate an xns address that "DE" can parse.
767: * This goes in the environment. Should be the same as above
768: */
769: char *
770: xntoa(addr)
771: struct ns_addr addr;
772: {
773: static char b[50];
774: char temp[10];
775: int i;
776:
777: /* net */
778: sprintf(b, "%X#", ntohl(ns_netof(addr)));
779: /* print the rest */
780: for(i=0; i < 6; i++) {
781: sprintf(temp,"%x", addr.x_host.c_host[i]);
782: strcat(b, temp);
783: if(i != 5) strcat(b, ".");
784: }
785: return (b);
786: }
787:
788: #ifdef DEBUG
789: BUGOUT(str,a,b,c,d,e,f,g,h)
790: char *str;
791: {
792: FILE *fd;
793: fd = fopen("/tmp/GAP3d.log","a");
794: fprintf(fd,str,a,b,c,d,e,f,g,h);
795: putc('\n',fd);
796: fclose(fd);
797: }
798: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.