![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckcnet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / ckermit|
Return to ckcnet.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / ckermit |
1.1 root 1: char *cknetv = "Network support, 5A(015) 23 Nov 92";
2:
3: /* C K C N E T -- Network support */
4: /*
5: Authors:
6:
7: Frank da Cruz ([email protected], [email protected]),
8: Columbia University Center for Computing Activities.
9: netopen() routine for TCP/IP originally by Ken Yap, Rochester University
10: ([email protected]) (no longer at that address).
11: Missing pieces for Excelan sockets library from William Bader, Moravian
12: College <[email protected]>.
13: TELNET protocol by Frank da Cruz.
14: TGV MultiNet code by Frank da Cruz.
15: MultiNet code adapted to WIN/TCP by Ray Hunter of TWG.
16: MultiNet code adapted to DEC TCP/IP by Lee Tibbert of DEC and Frank da Cruz.
17: SunLink X.25 support by Marcello Frutig, Catholic University,
18: Rio de Janeiro, Brazil ([email protected]) with fixes from
19: Stefaan Eeckels, Eurokom, Luxembourg.
20: Other contributions as indicated below.
21:
22: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
23: York. Permission is granted to any individual or institution to use this
24: software as long as it is not sold for profit. This copyright notice must be
25: retained. This software may not be included in commercial products without
26: written permission of Columbia University.
27: */
28:
29: #include "ckcdeb.h"
30: #include "ckcker.h"
31: #ifdef I386IX /* Has to come before ckcnet.h in */
32: #include <errno.h> /* this version, but after in others */
33: #endif /* I386IX */
34: #include "ckcnet.h"
35:
36: #ifdef NETCONN
37: /* Don't need these if there is no network support. */
38:
39: #ifdef WINTCP
40:
41: #include <errno.h>
42: #include <setjmp.h>
43: #include <signal.h>
44: /*
45: * The WIN/TCP code path is the same as that for Multinet. Only the routine
46: * names have changed ...
47: */
48: #define socket_errno errno
49: #define socket_read netread
50: #define socket_ioctl ioctl
51: #define socket_write netwrite
52: #define socket_perror win$perror
53: #define socket_close netclose
54:
55: #else /* Not WINTCP */
56: #ifndef I386IX
57: #include <errno.h>
58: #endif /* I386IX */
59: #include <signal.h>
60: #ifndef ZILOG
61: #include <setjmp.h>
62: #else
63: #include <setret.h>
64: #endif /* ZILOG */
65: #endif /* WINTCP */
66:
67: #ifdef datageneral /* Data General AOS/VS */
68: #include <:usr:include:vs_tcp_errno.h>
69: #include <:usr:include:sys:vs_tcp_types.h>
70: #include <:usr:include:sys:socket.h>
71: #include <:usr:include:netinet:in.h>
72: #include <:usr:include:netdb.h>
73: #endif /* datageneral */
74:
75: extern SIGTYP (*saval)(); /* For saving alarm handler */
76:
77: _PROTOTYP( VOID bgchk, (void) );
78:
79: extern int /* External variables */
80: duplex, debses, seslog, ttyfd, quiet, msgflg;
81:
82: #ifdef SVR4
83: /*
84: These suggested by Rob Healey, [email protected], to avoid
85: bugs in Berkeley compatibility library on Sys V R4 systems, but untested
86: by me (fdc). Remove this bit if it gives you trouble.
87: (Later corrected by Marc Boucher <[email protected]> because
88: bzero/bcopy are not argument-compatible with memset/memcpy|memmove.)
89: */
90: #define bzero(s,n) memset(s,0,n)
91: #define bcopy(h,a,l) memmove(a,h,l)
92: #else
93: #ifdef PTX /* Sequent DYNIX PTX 1.3 */
94: #define bzero(s,n) memset(s,0,n)
95: #define bcopy(h,a,l) memcpy(a,h,l)
96: #endif /* PTX */
97: #endif /* SVR4 */
98:
99: #define NAMECPYL 100 /* Local copy of hostname */
100: static char namecopy[NAMECPYL];
101:
102: char ipaddr[20] = { '\0' }; /* Global copy of IP address */
103:
104: /*
105: VMSTCPIP means "DEC_TCPIP or MULTINET or WINTCP" (defined in ckcnet.h).
106: */
107: #ifdef VMSTCPIP
108: /*
109: General global variables, but so far used only by MultiNet and WIN/TCP.
110: Kept within #ifdef MULTINET..#endif to keep strict compilers (and lint)
111: from complaining about unused variables.
112: */
113: static jmp_buf njbuf; /* For timeout longjumps */
114: #endif /* VMSTCPIP */
115:
116: #endif /* NETCONN */
117:
118: int ttnet = NET_NONE; /* Network type */
119: int ttnproto = NP_NONE; /* Network virtual terminal protocol */
120: int tn_init = 0; /* Telnet protocol initialized flag */
121: int tn_duplex = 1; /* Initial echo status */
122: char *tn_term = NULL; /* Terminal type override */
123: int tn_nlm = 1; /* Telnet CR -> CR LF mode */
124:
125: #ifndef NETCONN
126: /*
127: Network support not defined.
128: Dummy functions here in case #ifdef's forgotten elsewhere.
129: */
130: int /* Open network connection */
131: netopen(name, lcl, nett) char *name; int *lcl, nett; {
132: return(-1);
133: }
134: int /* Close network connection */
135: netclos() {
136: return(-1);
137: }
138: int /* Check network input buffer */
139: nettchk() {
140: return(-1);
141: }
142: int /* Flush network input buffer */
143: netflui() {
144: return(-1);
145: }
146: int /* Send network BREAK */
147: netbreak() {
148: return(-1);
149: }
150: int /* Input character from network */
151: netinc(timo) int timo; {
152: }
153: int /* Output character to network */
154: #ifdef CK_ANSIC
155: nettoc(char c)
156: #else
157: nettoc(c) char c;
158: #endif /* CK_ANSIC */
159: /* nettoc */ {
160: return(-1);
161: }
162: int
163: nettol(s,n) char *s; int n; {
164: return(-1);
165: }
166:
167: #else /* NETCONN is defined (rest of this module...) */
168:
169: #ifdef VMSTCPIP
170:
171: /* For buffered network reads... */
172: /*
173: If the buffering code is written right, it shouldn't matter how long this
174: buffer is -- it could even be shorter than a Kermit packet.
175: */
176: #define TTIBUFL 8192 /* Maybe 8K?... */
177:
178: CHAR ttibuf[TTIBUFL+1];
179: int ttibp = 0, ttibn = 0;
180: /*
181: Read bytes from network into internal buffer ttibuf[].
182: To be called when input buffer is empty, i.e. when ttibn == 0.
183:
184: Other network reading routines, like ttinc, ttinl, ttxin, should check the
185: internal buffer first, and call this routine for a refill if necessary.
186:
187: Returns -1 on error, 0 if nothing happens. When data is read successfully,
188: returns number of bytes read, and sets global ttibn to that number and
189: ttibp (the buffer pointer) to zero.
190: */
191: int
192: ttbufr() { /* TT Buffer Read */
193: int count;
194:
195: if (ttnet != NET_TCPB) { /* First make sure current net is */
196: return(-1); /* TCP/IP; if not, do nothing. */
197: } else {
198: if (ttibn > 0) /* Out internal buffer is not empty, */
199: return(ttibn); /* so keep using it. */
200: #ifdef WINTCP
201: count = 512; /* This works for WIN/TCP */
202: #else /* Not WINTCP, i.e it's Multinet */
203: #ifdef DEC_TCPIP
204: count = 512; /* This works for WIN/TCP */
205: #else /* Not WINTCP, i.e it's Multinet */
206: count = nettchk(); /* Check network input buffer, */
207: if (ttibn > 0) return(ttibn); /* which can put a char there! */
208: if (count < 0) /* Read error */
209: return(-1);
210: else if (count > TTIBUFL) /* Too many to read */
211: count = TTIBUFL;
212: else if (count == 0) /* None, so force blocking read */
213: count = 1;
214: #endif /* DEC_TCPIP */
215: #endif /* WINTCP */
216: debug(F101,"ttbufr count 1","",count);
217:
218: #ifdef COMMENT
219: /*
220: This is for nonblocking reads, which we don't do any more. This code didn't
221: work anyway, in the sense that a broken connection was never sensed.
222: */
223: if ((count = socket_read(ttyfd,ttibuf,count)) < 1) {
224: if (count == -1 && socket_errno == EWOULDBLOCK) {
225: debug(F100,"ttbufr finds nothing","",0);
226: return(0);
227: } else if (count == 0) {
228: debug(F100,"ttbufr socket eof","",0);
229: return(-1);
230: } else {
231: debug(F101,"ttbufr socket_read error","",socket_errno);
232: return(-1);
233: }
234: }
235: #else
236: /* This is for blocking reads */
237: if ((count = socket_read(ttyfd,ttibuf,count)) < 1) {
238: debug(F101,"ttbufr socket_read","",count);
239: debug(F101,"ttbufr socket_errno","",socket_errno);
240: return(-1);
241: }
242: #endif /* COMMENT */
243: ttibp = 0; /* Reset buffer pointer. */
244: ttibn = count;
245: #ifdef DEBUG
246: debug(F101,"ttbufr count 2","",count); /* Got some bytes. */
247: if (count > 0) ttibuf[count] = '\0';
248: debug(F111,"ttbufr ttibuf",ttibuf,ttibp);
249: #endif /* DEBUG */
250: return(ttibn); /* Return buffer count. */
251: }
252: }
253: #endif /* VMSTCPIP */
254:
255: /*
256: C-Kermit network open/close functions for BSD-sockets.
257: Much of this code shared by SunLink X.25, which also uses the socket library.
258: */
259:
260: /* N E T O P E N -- Open a network connection. */
261:
262: /* Returns 0 on success, -1 on failure. */
263:
264: #define TELNET_PORT 23 /* Should do lookup, but it won't change */
265:
266: /* This symbol is not known to, e.g., Ultrix 2.0 */
267: #ifndef TELOPT_TTYPE
268: #define TELOPT_TTYPE 24
269: #endif /* TELOPT_TTYPE */
270:
271: /* N E T O P N -- Open a network connection. */
272: /*
273: Call with:
274: name of host (or host:service),
275: lcl - local-mode flag to be set if this function succeeds,
276: network type - value defined in ckunet.h.
277: */
278:
279: #ifdef EXCELAN
280: /*
281: Most other BSD sockets implementations define these in header files
282: and libraries.
283: */
284: struct servent {
285: unsigned short s_port;
286: };
287:
288: struct hostent {
289: short h_addrtype;
290: struct in_addr h_addr;
291: int h_length;
292: };
293:
294: struct servent *
295: getservbyname(service, connection) char *service,*connection; {
296: static struct servent servrec;
297: int port;
298:
299: port = 0;
300: if (strcmp(service, "telnet") == 0) port = 23;
301: else if (strcmp(service, "smtp") == 0) port = 25;
302: else port = atoi(service);
303:
304: debug(F101,"getservbyname return port ","",port);
305:
306: if (port > 0) {
307: servrec.s_port = htons(port);
308: return( &servrec );
309: }
310: return( (struct servent *) NULL );
311: }
312:
313: struct hostent *
314: gethostbyname(hostname) char *hostname; {
315: return( (struct hostent *) NULL );
316: }
317:
318: unsigned long
319: inet_addr(name) char *name; {
320: unsigned long addr;
321:
322: addr = rhost(&name);
323: debug(F111,"inet_addr ",name,(int)addr);
324: return(addr);
325: }
326:
327: char *
328: inet_ntoa(in) struct in_addr in; {
329: static char name[80];
330: sprintf(name, "%d.%d.%d.%d", in.s_net, in.s_host, in.s_lh, in.s_impno);
331: return(name);
332: }
333: #endif /* EXCELAN */
334:
335: /* N E T O P E N -- Open a network connection */
336: /*
337: Calling conventions same as ttopen(), except third argument is network
338: type rather than modem type. Designed to be called from within ttopen.
339: */
340: int
341: netopen(name, lcl, nett) char *name; int *lcl, nett; {
342: char *p;
343: #ifdef SO_OOBINLINE
344: int on = 1;
345: #endif /* SO_OOBINLINE */
346: int i, x;
347: struct servent *service, servrec;
348: struct hostent *host;
349: struct sockaddr_in saddr;
350: #ifdef EXCELAN
351: struct sockaddr_in send_socket;
352: #endif /* EXCELAN */
353:
354: #ifdef SUNX25 /* Code for SunLink X.25 support */
355: #define X29PID 1 /* X.29 Protocol ID */
356: VOID x25oobh();
357: CONN_DB x25host;
358: FACILITY_DB x25facil;
359: static int needh = 1;
360: PID_T pid;
361: extern int linkid, lcn, x25ver;
362: extern int revcall, closgr, cudata;
363: extern char udata[MAXCUDATA];
364: #endif /* SUNX25 */
365:
366: debug(F101,"netopen nett","",nett);
367: *ipaddr = '\0'; /* Initialize IP address string */
368:
369: #ifdef SUNX25
370: if (nett == NET_SX25) { /* If network type is X.25 */
371: netclos(); /* Close any previous net connection */
372: ttnproto = NP_NONE; /* No protocol selected yet */
373:
374: /* Set up host structure */
375: bzero ((char *)&x25host,sizeof(x25host));
376: if ((x25host.hostlen = pkx121 (name,x25host.host)) < 0) {
377: fprintf (stderr,"Invalid X.121 host address %s\n",name);
378: errno = 0;
379: return (-1);
380: }
381: x25host.datalen = X29PIDLEN;
382: x25host.data[0] = X29PID;
383:
384: /* Set call user data if specified */
385: if (cudata) {
386: strncpy(x25host.data+X29PIDLEN,udata,(int)strlen(udata));
387: x25host.datalen += (int)strlen(udata);
388: }
389:
390: /* Open SunLink X.25 socket */
391: if ((ttyfd = socket (AF_X25, SOCK_STREAM, 0)) < 0) {
392: debug(F101,"netopen socket error","",errno);
393: perror ("X.25 connect socket error");
394: return (-1);
395: }
396:
397: /* Setting X.25 out-of-band data handler */
398: pid = getpid();
399: if (ioctl(ttyfd,SIOCSPGRP,&pid)) {
400: perror("Setting process group id");
401: return(-1);
402: }
403: (VOID) signal(SIGURG,x25oobh);
404:
405: /* Set reverse charge call and closed user group if requested */
406: bzero ((char *)&x25facil,sizeof(x25facil));
407: if (revcall) x25facil.reverse_charge = revcall;
408: if (closgr > -1) {
409: x25facil.cug_req = 1;
410: x25facil.cug_index = closgr;
411: }
412: if (ioctl(ttyfd,X25_WR_FACILITY,&x25facil) < 0) {
413: perror ("Setting X.25 facilities");
414: return (-1);
415: }
416:
417: /* Need X.25 header with bits Q and M */
418: if (ioctl (ttyfd,X25_HEADER,&needh) < 0) {
419: perror ("Setting X.25 header");
420: return (-1);
421: }
422:
423: /* Connects to remote host via SunLink X.25 */
424: if (connect(ttyfd,&x25host,sizeof(x25host)) < 0) {
425: debug(F101,"netopen connect errno","",errno);
426: i = errno;
427: if (errno) {
428: perror("netopen");
429: x25diag();
430: }
431: (VOID) close (ttyfd);
432: ttyfd = -1;
433: errno = i;
434: return (-1);
435: }
436:
437: /* Get X.25 link identification used for the connection */
438: if (ioctl(ttyfd,X25_GET_LINK,&linkid) < 0) {
439: perror ("Getting X.25 link id");
440: return (-1);
441: }
442:
443: /* Get X.25 logical channel number used for the connection */
444: if (ioctl(ttyfd,X25_RD_LCGN,&lcn) < 0) {
445: perror ("Getting X.25 lcn");
446: return (-1);
447: }
448:
449: /* Get SunLink X.25 version */
450: if (ioctl(ttyfd,X25_VERSION,&x25ver) < 0) {
451: perror ("Getting SunLink X.25 version");
452: return (-1);
453: }
454: ttnet = nett; /* Sunlink X.25 network */
455: ttnproto = NP_X3; /* PAD X.3, X.28, X.29 protocol */
456: if (*lcl < 0) *lcl = 1; /* Local mode */
457: return(0);
458: } else /* Note that SUNX25 support can coexist with TCP/IP support. */
459: #endif /* SUNX25 */
460: /*
461: Add support for other networks here.
462: */
463: if (nett != NET_TCPB) return(-1); /* BSD socket support */
464:
465: netclos(); /* Close any previous connection. */
466: strncpy(namecopy, name, NAMECPYL); /* Copy the hostname. */
467: ttnproto = NP_NONE; /* No protocol selected yet. */
468: debug(F110,"netopen namecopy",namecopy,0);
469:
470: p = namecopy; /* Was a service requested? */
471: while (*p != '\0' && *p != ':') p++; /* Look for colon */
472: if (*p == ':') { /* Have a colon */
473: *p++ = '\0'; /* Get service name or number */
474: } else { /* Otherwise use telnet */
475: p = "telnet";
476: }
477: debug(F110,"netopen service requested",p,0);
478: if (isdigit(*p)) { /* Use socket number without lookup */
479: service = &servrec;
480: service->s_port = htons((unsigned short)atoi(p));
481: } else { /* Otherwise lookup the service name */
482: service = getservbyname(p, "tcp");
483: }
484: if (!service) {
485: fprintf(stderr, "Cannot find port for service %s\n", p);
486: #ifdef MULTINET
487: debug(F101,"netopen can't get service","",socket_errno);
488: #else
489: debug(F101,"netopen can't get service","",errno);
490: #endif /* MULTINET */
491: errno = 0; /* rather than mislead */
492: return(-1);
493: }
494: /* Set up socket structure and get host address */
495:
496: bzero((char *)&saddr, sizeof(saddr));
497: if ((host = gethostbyname(namecopy)) != NULL) {
498: saddr.sin_family = host->h_addrtype;
499: bcopy(host->h_addr, (caddr_t)&saddr.sin_addr, host->h_length);
500: } else {
501: #ifdef INADDRX
502: /* inet_addr() is of type struct in_addr */
503: struct in_addr ina;
504: unsigned long uu;
505: #ifdef datageneral
506: extern struct in_addr inet_addr();
507: #endif /* datageneral */
508: ina = inet_addr(namecopy);
509: uu = *(unsigned long *)&ina;
510: #else /* Not INADDRX */
511: /* inet_addr() is unsigned long */
512: unsigned long uu;
513: uu = inet_addr(namecopy);
514: #endif /* INADDRX */
515: if ((saddr.sin_addr.s_addr = uu) != ((unsigned long)-1))
516: saddr.sin_family = AF_INET;
517: else {
518: fprintf(stderr, "Can't get address for %s\n", namecopy);
519: #ifdef MULTINET
520: debug(F101,"netopen can't get address","",socket_errno);
521: #else
522: debug(F101,"netopen can't get address","",errno);
523: #endif /* MULTINET */
524: errno = 0; /* rather than mislead */
525: return(-1);
526: }
527: }
528:
529: /* Get a file descriptor for the connection. */
530:
531: saddr.sin_port = service->s_port;
532: sprintf(ipaddr,"%s", inet_ntoa(saddr.sin_addr));
533: if (!quiet && *ipaddr) printf(" Trying %s...\n", ipaddr);
534:
535: #ifdef EXCELAN
536: send_socket.sin_family = AF_INET;
537: send_socket.sin_addr.s_addr = 0;
538: send_socket.sin_port = 0;
539: if ((ttyfd = socket(SOCK_STREAM, (struct sockproto *)0,
540: &send_socket, SO_REUSEADDR)) < 0)
541: #else
542: if ((ttyfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
543: #endif /* EXCELAN */
544: {
545: #ifdef EXCELAN
546: experror("TCP socket error");
547: #else
548: #ifdef MULTINET
549: socket_perror("TCP socket error");
550: debug(F101,"netopen socket error","",socket_errno);
551: #else
552: perror("TCP socket error");
553: debug(F101,"netopen socket error","",errno);
554: #endif /* MULTINET */
555: #endif /* EXCELAN */
556: return (-1);
557: }
558: errno = 0;
559:
560: /* Now connect to the socket on the other end. */
561:
562: #ifdef EXCELAN
563: if (connect(ttyfd, &saddr) < 0)
564: #else
565: if (connect(ttyfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
566: #endif /* EXCELAN */
567: {
568: i = errno; /* save error code */
569: close(ttyfd);
570: ttyfd = -1;
571: errno = i; /* and report this error */
572: #ifdef EXCELAN
573: if (errno) experror("netopen connect");
574: #else
575: #ifdef MULTINET
576: debug(F101,"netopen connect error","",socket_errno);
577: if (errno) socket_perror("netopen connect");
578: #else
579: debug(F101,"netopen connect errno","",errno);
580: #ifdef WINTCP
581: perror("netopen connect");
582: #endif /* WINTCP */
583: #ifdef DEC_TCPIP
584: perror("netopen connect");
585: #endif /* DEC_TCPIP */
586: #endif /* MULTINET */
587: #endif /* EXCELAN */
588: return(-1);
589: }
590: #ifdef SO_OOBINLINE
591: /*
592: The symbol SO_OOBINLINE is not known to Ultrix 2.0.
593: It means "leave out of band data inline". The normal value is 0x0100,
594: but don't try this on systems where the symbol is undefined.
595: */
596: #ifdef datageneral
597: setsockopt(ttyfd, SOL_SOCKET, SO_OOBINLINE,(char *) &on, sizeof on);
598: #else
599: #ifdef BSD43
600: setsockopt(ttyfd, SOL_SOCKET, SO_OOBINLINE,(char *) &on, sizeof on);
601: #else
602: #ifdef OSF1
603: setsockopt(ttyfd, SOL_SOCKET, SO_OOBINLINE,(char *) &on, sizeof on);
604: #else
605: #ifdef POSIX
606: setsockopt(ttyfd, SOL_SOCKET, SO_OOBINLINE,(char *) &on, sizeof on);
607: #else
608: #ifdef SOLARIS
609: /*
610: Maybe this applies to all SVR4 versions, but the other (else) way has been
611: compiling and working fine on all the others, so best not to change it.
612: */
613: setsockopt(ttyfd, SOL_SOCKET, SO_OOBINLINE,(char *) &on, sizeof on);
614: #else
615: setsockopt(ttyfd, SOL_SOCKET, SO_OOBINLINE, &on, sizeof on);
616: #endif /* SOLARIS */
617: #endif /* POSIX */
618: #endif /* BSD43 */
619: #endif /* OSF1 */
620: #endif /* datageneral */
621: #endif /* SO_OOBINLINE */
622:
623: /* See if the service is TELNET. */
624: if ((x = ntohs((unsigned short)service->s_port)) == TELNET_PORT)
625: ttnproto = NP_TELNET; /* Yes, set global flag. */
626: debug(F101,"netopen service","",x);
627: ttnet = nett; /* TCP/IP (sockets) network */
628: tn_init = 0; /* Telnet protocol not init'd yet */
629: if (*lcl < 0) *lcl = 1; /* Local mode. */
630: return(0); /* Done. */
631: }
632:
633: /* N E T C L O S -- Close current network connection. */
634:
635: int
636: netclos() {
637: int x = 0;
638: if (ttyfd < 0) /* Was open? */
639: return(0); /* Wasn't. */
640: if (ttyfd > -1) /* Was. */
641: #ifdef VMSTCPIP
642: x = socket_close(ttyfd); /* Close it. */
643: #else
644: x = close(ttyfd);
645: #endif /* VMSTCPIP */
646: ttyfd = -1; /* Mark it as closed. */
647: tn_init = 0; /* Remember about telnet protocol... */
648: *ipaddr = '\0'; /* Zero the IP address string */
649: return(x);
650: }
651:
652: /* N E T T C H K -- Check if network up, and how many bytes can be read */
653: /*
654: Returns number of bytes waiting, or -1 if connection has been dropped.
655: */
656: int /* Check how many bytes are ready */
657: nettchk() { /* for reading from network */
658: #ifdef VMSTCPIP
659: unsigned int count;
660: int x, y;
661: char c;
662:
663: debug(F101,"nettchk entry ttibn","",ttibn);
664: debug(F101,"nettchk entry ttibp","",ttibp);
665: socket_errno = 0;
666: /*
667: Note: this socket_ioctl() call does NOT return an error if the
668: connection has been broken. (At least not in Multinet.)
669: */
670: if (socket_ioctl(ttyfd,FIONREAD,&count) < 0) {
671: debug(F101,"nettchk socket_ioctl error","",socket_errno);
672: if (ttibn < 1) return(-1);
673: else return(ttibn);
674: }
675: debug(F101,"nettchk count","",count);
676:
677: #ifndef DEC_TCPIP
678: /*
679: Let's see if we can skip this for UCX, since it seems to cause trouble.
680: */
681: if (count == 0) {
682: /*
683: Here we need to tell the difference between a 0 count on an active
684: connection, and a 0 count because the remote end of the socket broke the
685: connection. There is no mechanism in TGV MultiNet (or WIN/TCP?) to query
686: the status of the connection, so we have to do a read. -1 means there was
687: no data available (socket_errno == EWOULDBLOCK), 0 means the connection is
688: down. But if, by chance, we actually get a character, we have to put it
689: where it won't be lost.
690: */
691: y = 1; /* Turn on nonblocking reads */
692: debug(F101,"nettchk before FIONBIO","",x);
693: x = socket_ioctl(ttyfd,FIONBIO,&y);
694: debug(F101,"nettchk FIONBIO","",x);
695: x = socket_read(ttyfd,&c,1); /* Returns -1 if no data */
696: debug(F101,"nettchk socket_read","",x);
697: y = 0; /* Turn them back off */
698: socket_ioctl(ttyfd,FIONBIO,&y);
699: if (x == 0) return(-1); /* Connection is broken. */
700: if (x == 1) { /* Oops, actually got a byte? */
701: debug(F101,"nettchk socket_read char","",c);
702: debug(F101,"nettchk ttibp","",ttibp);
703: debug(F101,"nettchk ttibn","",ttibn);
704: /*
705: So put the byte we got into the buffer at the current position.
706: Increment the buffer count, but DON'T increment the buffer pointer.
707: */
708: ttibuf[ttibp+ttibn] = c;
709: ttibn++;
710: #ifdef DEBUG
711: ttibuf[ttibp+ttibn] = '\0';
712: debug(F111,"nettchk ttibn",ttibuf,ttibn);
713: #endif /* DEBUG */
714: }
715: }
716: #endif /* DEC_TCPIP */
717: debug(F101,"nettchk returns","",count+ttibn);
718: return(count + ttibn);
719:
720: #else /* Not VMSTCPIP */
721: /*
722: UNIX just uses ttchk(), in which the ioctl() calls on the file descriptor
723: seem to work OK.
724: */
725: return(0);
726: #endif /* VMSTCPIP */
727: /*
728: But what about X.25?
729: */
730: }
731:
732: /* N E T I N C -- Input character from network */
733:
734: int
735: netinc(timo) int timo; {
736: #ifdef VMSTCPIP
737: int x; unsigned char c; /* The locals. */
738:
739: if (ttibn > 0) { /* Something in internal buffer? */
740: debug(F100,"netinc char in buf","",0); /* Yes. */
741: x = 0; /* Success. */
742: } else { /* Else must read from network. */
743: x = -1; /* Assume failure. */
744: #ifdef DEBUG
745: debug(F101,"netinc goes to net, timo","",timo);
746: ttibuf[ttibp+1] = '\0';
747: debug(F111,"netinc ttibuf",ttibuf,ttibp);
748: #endif /* DEBUG */
749: if (timo <= 0) { /* Untimed case. */
750: while (1) { /* Wait forever if necessary. */
751: if (ttbufr() < 0) /* Refill buffer. */
752: break; /* Error, fail. */
753: if (ttibn > 0) { /* Success. */
754: x = 0;
755: break;
756: }
757: }
758: } else { /* Timed case... */
759: saval = signal(SIGALRM,ttimoff); /* Enable timer interrupt */
760: alarm(timo); /* for requested interval. */
761: if (setjmp(njbuf)) { /* Timer went off? */
762: x = -1; /* Yes, fail. */
763: } else {
764: while (1) {
765: if (ttbufr() < 0) /* Keep trying to refill it. */
766: break; /* Till we get an error. */
767: if (ttibn > 0) { /* Or we get a character. */
768: x = 0;
769: break;
770: }
771: }
772: }
773: ttimoff(); /* Timer off. */
774: }
775: }
776: if (x < 0) { /* Return -1 if we failed. */
777: debug(F100,"netinc timed out","",0);
778: return(-1);
779: } else { /* Otherwise */
780: ttibn--; /* Return what we got. */
781: c = ttibuf[ttibp++];
782: debug(F101,"netinc returning","",c);
783: return((c & 0xff));
784: }
785: #else /* Not MULTINET or WINTCP */
786: return(-1);
787: #endif /* VMSTCPIP */
788: }
789:
790: /* N E T T O L -- Output a string of bytes to the network */
791: /*
792: Call with s = pointer to string, n = length.
793: Returns number of bytes actually written on success, or
794: -1 on i/o error, -2 if called improperly.
795: */
796: int
797: nettol(s,n) char *s; int n; {
798: #ifdef VMSTCPIP
799: int count;
800: if (ttnet == NET_TCPB) {
801: if ((count = socket_write(ttyfd,s,n)) < 1) {
802: debug(F101,"nettol socket_write error","",socket_errno);
803: return(-1);
804: }
805: debug(F111,"nettol socket_write",s,count);
806: return(count);
807: } else return(-2);
808: #else
809: debug(F100,"nettol VMSTCPIP not defined","",0);
810: return(-2);
811: #endif /* VMSTCPIP */
812: }
813:
814: /* N E T T O C -- Output character to network */
815: /*
816: Call with character to be transmitted.
817: Returns 0 if transmission was successful, or
818: -1 upon i/o error, or -2 if called improperly.
819: */
820: int
821: #ifdef CK_ANSIC
822: nettoc(char c)
823: #else
824: nettoc(c) char c;
825: #endif /* CK_ANSIC */
826: /* nettoc */ {
827: #ifdef VMSTCPIP
828: unsigned char cc;
829: cc = c;
830: if (ttnet == NET_TCPB) {
831: debug(F101,"nettoc cc","",cc);
832: if (socket_write(ttyfd,&cc,1) < 1) {
833: debug(F101,"nettoc socket_write error","",socket_errno);
834: return(-1);
835: }
836: debug(F101,"nettoc socket_write","", cc);
837: return(0);
838: } else return(-2);
839: #else
840: return(-2);
841: #endif /* MULTINET */
842: }
843:
844: /* N E T F L U I -- Flush network input buffer */
845:
846: int
847: netflui() {
848: int n;
849: #ifdef VMSTCPIP
850: ttibuf[ttibp+1] = '\0';
851: debug(F111,"netflui 1",ttibuf,ttibn);
852: ttibn = ttibp = 0; /* Flush internal buffer *FIRST* */
853: if ((n = nettchk()) > 0) { /* Now see what's waiting on the net */
854: if (n > TTIBUFL) n = TTIBUFL; /* and sponge it up */
855: debug(F101,"netflui 2","",n); /* ... */
856: n = socket_read(ttyfd,ttibuf,n) ; /* into our buffer */
857: if (n >= 0) ttibuf[n] = '\0';
858: debug(F111,"netflui 3",ttibuf,n);
859: ttibuf[0] = '\0';
860: }
861: #else
862: /*
863: It seems the UNIX ioctl()s don't do the trick, so we have to read the
864: stuff ourselves. This should be pretty much portable, if not elegant.
865: */
866: if ((n = ttchk()) > 0) {
867: debug(F101,"netflui","",n);
868: while ((n--) && ttinc(0) > -1) ; /* Don't worry, it's buffered. */
869: }
870: #endif /* VMSTCPIP */
871: return(0);
872: }
873:
874: #ifdef TNCODE /* Compile in telnet support code */
875:
876: /* TCP/IP Telnet negotiation support code */
877:
878: static int sgaflg = 0; /* telnet SGA flag */
879: static int wttflg = 0; /* telnet terminal type flag */
880:
881: #ifndef TELCMDS
882: char *telcmds[] = {
883: "SE", "NOP", "DMARK", "BRK", "IP", "AO", "AYT", "EC",
884: "EL", "GA", "SB", "WILL", "WONT", "DO", "DONT", "IAC",
885: };
886: int ntelcmds = sizeof(telcmds) / sizeof(char *);
887: #endif /* TELCMDS */
888:
889: #ifndef TELOPTS
890: char *telopts[] = {
891: "BINARY", "ECHO", "RCP", "SUPPRESS GO AHEAD", "NAME",
892: "STATUS", "TIMING MARK", "RCTE", "NAOL", "NAOP",
893: "NAOCRD", "NAOHTS", "NAOHTD", "NAOFFD", "NAOVTS",
894: "NAOVTD", "NAOLFD", "EXTEND ASCII", "LOGOUT", "BYTE MACRO",
895: "DATA ENTRY TERMINAL", "SUPDUP", "SUPDUP OUTPUT",
896: "SEND LOCATION", "TERMINAL TYPE", "END OF RECORD"
897: #ifdef TELOPT_TUID
898: ,"TACACS UID"
899: #ifdef TELOPT_OUTMRK
900: ,"OUTPUT MARKING"
901: #ifdef TELOPT_TTYLOC
902: ,"TTYLOC"
903: #ifdef TELOPT_3270REGIME
904: ,"3270 REGIME"
905: #ifdef TELOPT_X3PAD
906: ,"X.3 PAD"
907: #ifdef TELOPT_NAWS
908: ,"NAWS"
909: #ifdef TELOPT_TSPEED
910: ,"TSPEED"
911: #ifdef TELOPT_LFLOW
912: ,"LFLOW"
913: #ifdef TELOPT_LINEMODE
914: ,"LINEMODE"
915: #endif
916: #endif
917: #endif
918: #endif
919: #endif
920: #endif
921: #endif
922: #endif
923: #endif
924: };
925: #endif /* TELOPTS */
926:
927: int ntelopts = sizeof(telopts) / sizeof(char *);
928: #endif /* TNCODE */
929:
930:
931: /* Send network BREAK */
932: /*
933: Returns -1 on error, 0 if nothing happens, 1 if BREAK sent successfully.
934: */
935: int
936: netbreak() {
937: CHAR buf[3];
938: if (ttnet == NET_TCPB) {
939: if (ttnproto == NP_TELNET) {
940: #ifdef TNCODE
941: buf[0] = (CHAR) IAC; buf[1] = (CHAR) BREAK;
942: if (ttol(buf,2) < 2) return(-1);
943: debug(F101,"telnet BREAK ok","",BREAK);
944: return(1);
945: #else
946: debug(F100,"netbreak no TNCODE","",0);
947: return(0);
948: #endif /* TNCODE */
949: }
950: /* Insert other TCP/IP protocols here */
951: }
952: /* Insert other networks here */
953: return(0);
954: }
955:
956: /* Send a telnet option, avoid loops. */
957: /* Returns 1 if command was sent, 0 if not, -1 on error */
958:
959: int
960: tn_sopt(cmd,opt) int cmd, opt; { /* TELNET SEND OPTION */
961: CHAR buf[4];
962: int n;
963: if (ttnet != NET_TCPB) return(0); /* Must be TCP/IP */
964: if (ttnproto != NP_TELNET) return(0); /* Must be telnet protocol */
965: n = cmd - SE;
966: if (n < 0 || n > ntelcmds) return(0);
967: #ifdef TNCODE
968: buf[0] = (CHAR) IAC;
969: buf[1] = (CHAR) cmd & 0xff;
970: buf[2] = (CHAR) opt & 0xff;
971: if (ttol(buf,3) < 3)
972: return(-1);
973: debug(F111,"telnet cmd >",telcmds[n],cmd);
974: debug(F111,"telnet opt >",
975: (opt < ntelopts) ? telopts[opt] : "UNKNOWN", opt );
976: if (debses && cmd != SB)
977: printf("[%s %s]",telcmds[n],
978: (opt < ntelopts) ? telopts[opt] : "UNKNOWN");
979: return(1);
980: #else
981: debug(F100,"tn_sopt no TNCODE","",0);
982: return(0);
983: #endif /* TNCODE */
984: }
985:
986: /* Initialize a telnet connection. */
987: /* Returns -1 on error, 0 if nothing happens, 1 if init msgs sent ok */
988:
989: int
990: tn_ini() {
991: #ifndef TNCODE
992: debug(F100,"tn_ini no TNCODE","",0);
993: return(0);
994: #else /* TELNET protocol support */
995: debug(F101,"tn_ini ttnproto","",ttnproto);
996: debug(F101,"tn_ini tn_init","",tn_init);
997:
998: if (ttnet != NET_TCPB) /* Make sure connection is TCP/IP. */
999: return(0);
1000: if (tn_init) /* Have we done this already? */
1001: return(0); /* Don't do it again. */
1002: debug(F101,"tn_ini tn_duplex","",tn_duplex);
1003: duplex = tn_duplex; /* Assume local echo. */
1004: sgaflg = 0; /* Assume Go-Ahead suppressed. */
1005: wttflg = 0; /* Did not send WILL TERM TYPE yet. */
1006: if (ttnproto == NP_NONE) { /* If not talking to a telnet port, */
1007: ttnproto = NP_TELNET; /* pretend it's telnet anyway, */
1008: tn_init = 1; /* but don't send initial options. */
1009: debug(F100,"tn_ini skipping telnet negotiations","",0);
1010: return(0);
1011: }
1012: /* Talking to telnet port, so send WILL TERMINAL TYPE and DO SGA */
1013:
1014: if (tn_sopt(WILL,TELOPT_TTYPE) < 0) /* Will send terminal type. */
1015: return(-1);
1016: wttflg = 1; /* Remember I said I would. */
1017: if (tn_sopt(DO,TELOPT_SGA) < 0) /* Please suppress go-ahead. */
1018: return(-1);
1019: #ifdef COMMENT
1020: if (tn_sopt(DO,TELOPT_ECHO) < 0) /* Ask the server to echo, since */
1021: return(-1); /* I'm assuming it will. */
1022: #endif /* COMMENT */
1023: tn_init = 1; /* Set telnet-initialized flag. */
1024:
1025: /* Don't send anthing else! */
1026:
1027: debug(F101,"tn_ini duplex","",duplex);
1028: return(1);
1029: #endif /* TNCODE */
1030: }
1031:
1032: /*
1033: Process in-band Telnet negotiation characters from the remote host.
1034: Call with the telnet IAC character and the current duplex setting
1035: (0 = remote echo, 1 = local echo).
1036: Returns:
1037: 3 if server has sent us a quoted IAC
1038: 2 if local echo must be changed to remote
1039: 1 if remote echo must be changed to local
1040: 0 if nothing happens or no action necessary
1041: -1 on failure (= internal or i/o error)
1042: */
1043:
1044: #define TSBUFSIZ 41
1045: char sb[TSBUFSIZ]; /* Buffer for subnegotiations */
1046:
1047: int
1048: #ifdef CK_ANSIC /* TELNET DO OPTION */
1049: tn_doop( CHAR z, int echo, int (*fn)(int) )
1050: #else
1051: tn_doop(z, echo, fn) CHAR z; int echo; int (*fn)();
1052: #endif /* CK_ANSIC */
1053: /* tn_doop */ {
1054: int c, x, y, n, m, flag;
1055:
1056: #ifndef TNCODE
1057: debug(F100,"tn_doop no TNCODE","",0);
1058: return(0);
1059: #else
1060: if (z != (CHAR) IAC) {
1061: debug(F101,"tn_doop bad call","",z);
1062: return(-1);
1063: }
1064: if (ttnet != NET_TCPB) return(0);
1065: if (ttnproto != NP_TELNET) return(0); /* Check protocol */
1066:
1067: /* Have IAC, read command character. */
1068:
1069: c = (*fn)(0) & 0xff; /* Read command character */
1070: m = c - SE; /* Check validity */
1071: if (m < 0 || m > ntelcmds) {
1072: debug(F101,"tn_doop bad cmd","",c);
1073: return(0);
1074: }
1075: if (seslog) { /* Copy to session log, if any. */
1076: if (zchout(ZSFILE, (char) z) < 0) seslog = 0; /* Log IAC. */
1077: else if (zchout(ZSFILE, (char) c) < 0) seslog = 0; /* Log command */
1078: }
1079: debug(F111,"telnet cmd <",telcmds[m],c); /* Debug log. */
1080:
1081: if (c == (CHAR) IAC) return(3); /* Quoted IAC */
1082: if (c < SB) return(0); /* Other command with no arguments. */
1083:
1084: /* SB, WILL, WONT, DO, or DONT need more bytes... */
1085:
1086: if ((x = (*fn)(0)) < 0) return(-1); /* Get the option. */
1087: x &= 0xff; /* Trim to 8 bits. */
1088:
1089: debug(F111,"telnet opt <",
1090: (x < ntelopts) ? telopts[x] : "UNKNOWN", x );
1091: if (seslog) /* Session log */
1092: if (zchout(ZSFILE, (char) x) < 0) seslog = 0;
1093:
1094: /* Now handle the command */
1095:
1096: if (debses && c != SB) /* Debug to screen. */
1097: printf("<%s %s>",telcmds[m],
1098: (x < ntelopts) ? telopts[x] : "UNKNOWN" );
1099: switch (x) {
1100: case TELOPT_ECHO: /* ECHO negotiation. */
1101: switch (c) { /* Command */
1102: case WILL: /* Host says it will echo. */
1103: if (echo) /* Only reply if change required. */
1104: return((tn_sopt(DO,x) < 0) ? -1 : 2); /* Please do. */
1105: else return(0); /* Otherwise no change. */
1106: case WONT: /* Host says it won't echo. */
1107: if (!echo) /* If I'm full duplex */
1108: return ((tn_sopt(DONT,x) < 0) ? -1 : 1); /* Switch to half */
1109: else return(0); /* Otherwise, no change. */
1110: case DO: /* Host wants me to echo */
1111: if (tn_sopt(WONT,x) < 0) /* but the client never echoes */
1112: return(-1); /* back to the server. */
1113: default: /* Don't reply to anything else */
1114: return(0);
1115: }
1116:
1117: case TELOPT_SGA: /* Suppress Go-Ahead */
1118: switch (c) { /* Command... */
1119: case WONT: /* Host says it won't. */
1120: if (!sgaflg) {
1121: sgaflg = 1; /* Remember. */
1122: if (tn_sopt(DONT,x) < 0) /* acknowledge, */
1123: return(-1);
1124: }
1125: return(echo ? 0 : 1); /* Switch to half duplex */
1126: case WILL: /* Server says it will SGA */
1127: if (sgaflg) { /* ACK only if necessary */
1128: if (tn_sopt(DO,x) < 0)
1129: return(-1);
1130: sgaflg = 0; /* Remember new SGA state. */
1131: }
1132: return(0); /* But don't change echo state. */
1133: }
1134:
1135: #ifdef TELOPT_TTYPE
1136: case TELOPT_TTYPE: /* Terminal Type */
1137: switch (c) {
1138: case DO: /* DO terminal type. */
1139: if (wttflg == 0) { /* If I haven't said so before, */
1140: if (tn_sopt((CHAR)WILL,x) < 0) /* say I'll send it if asked. */
1141: return(-1);
1142: wttflg++;
1143: }
1144: return(0);
1145: case SB:
1146: debug(F100,"TELNET subnegotiation:","",0);
1147: n = flag = 0; /* Flag for when done reading SB */
1148: while (n < TSBUFSIZ) { /* Loop looking for IAC SE */
1149: if ((y = (*fn)(0)) < 0) /* Read a byte */
1150: return(-1);
1151: y &= 0xff; /* Make sure it's just 8 bits. */
1152: sb[n++] = y; /* Deposit in buffer. */
1153: if (seslog) /* Take care of session log */
1154: if (zchout(ZSFILE, (char) y) < 0)
1155: seslog = 0;
1156: if (y == IAC) { /* If this is an IAC */
1157: if (flag) { /* If previous char was IAC */
1158: n--; /* it's quoted, keep one IAC */
1159: flag = 0; /* and turn off the flag. */
1160: } else flag = 1; /* Otherwise set the flag. */
1161: } else if (flag) { /* Something else following IAC */
1162: if (y != SE) /* If not SE, it's a protocol error */
1163: flag = 0;
1164: break;
1165: }
1166: }
1167: if (!flag) { /* Make sure we got a valid SB */
1168: debug(F100, "TELNET Subnegotian prematurely broken", "",0);
1169: return(-1);
1170: }
1171: if (debses) { /* Debug to screen. */
1172: int i;
1173: printf("<SB %s ",telopts[TELOPT_TTYPE]);
1174: for (i = 0; i < n-2; i++) printf("%02x",sb[i]);
1175: printf(" IAC SE>");
1176: }
1177: debug(F101,"TELNET suboption<","",sb[0]);
1178: if (sb[0] == 1) { /* SEND terminal type? */
1179: if (tn_sttyp() < 0) /* Yes, so send it. */
1180: return(-1);
1181: }
1182: default: /* Others, ignore */
1183: return(0);
1184: }
1185: #endif /* TELOPT_TTYPE */
1186:
1187: default: /* All others: refuse */
1188: switch(c) {
1189: case WILL: /* You will? */
1190: if (tn_sopt(DONT,x) < 0) /* Please don't. */
1191: return(-1); /* (Could this cause a loop?) */
1192: break;
1193: case DO: /* You want me to? */
1194: if (tn_sopt(WONT,x) < 0) /* I won't. */
1195: return(-1);
1196: break;
1197: case DONT: /* You don't want me to? */
1198: if (tn_sopt(WONT,x) < 0) /* I won't. */
1199: return(-1); /* (Could this cause a loop?) */
1200: case WONT: /* You won't? */
1201: break; /* I didn't want you to. */
1202: } /* Anything else, treat as user data */
1203: return(0);
1204: }
1205: #endif /* TNCODE */
1206: }
1207:
1208: /* Telnet send terminal type */
1209: /* Returns -1 on error, 0 if nothing happens, 1 if type sent successfully */
1210:
1211: int
1212: tn_sttyp() { /* Send telnet terminal type. */
1213: #ifndef TNCODE
1214: debug(F100,"tn_sttyp no TNCODE","",0);
1215: return(0);
1216: #else
1217: char *ttn; int ttl, i; /* Name & length of terminal type. */
1218:
1219: if (ttnet != NET_TCPB) return(0);
1220: if (ttnproto != NP_TELNET) return(0);
1221:
1222: ttn = NULL;
1223:
1224: if (tn_term) { /* Terminal type override? */
1225: debug(F110,"tn_sttyp",tn_term,0);
1226: if (*tn_term) ttn = tn_term;
1227: } else debug(F100,"tn_sttyp no term override","",0);
1228: #ifndef datageneral
1229: if (!ttn) /* If no override, */
1230: ttn = getenv("TERM"); /* get it from the environment. */
1231: #endif /* datageneral */
1232: if ((ttn == ((char *)0)) || ((ttl = (int)strlen(ttn)) >= TSBUFSIZ)) {
1233: ttn = "UNKNOWN";
1234: ttl = 7;
1235: }
1236: sb[0] = IAC; /* I Am a Command */
1237: sb[1] = SB; /* Subnegotiation */
1238: sb[2] = TELOPT_TTYPE; /* Terminal Type */
1239: sb[3] = (CHAR) 0; /* Is... */
1240: for (i = 4; *ttn; ttn++,i++) /* Copy and uppercase it */
1241: sb[i] = (islower(*ttn)) ? toupper(*ttn) : *ttn;
1242: ttn = sb; /* Point back to beginning */
1243: sb[i++] = IAC; /* End of Subnegotiation */
1244: sb[i++] = SE; /* marked by IAC SE */
1245: if (ttol((CHAR *)sb,i) < 0) /* Send it. */
1246: return(-1);
1247: #ifdef DEBUG
1248: sb[i-2] = '\0'; /* For debugging */
1249: debug(F111,"telnet SB sent ttype",sb+4,ttl);
1250: #endif /* DEBUG */
1251: if (debses) /* Debug to screen. */
1252: printf("[SB TERMINAL TYPE 00 %s IAC SE]",sb+4);
1253: return(1);
1254: #endif /* TNCODE */
1255: }
1256:
1257: #ifdef SUNX25
1258: /*
1259: SunLink X.25 support by Marcello Frutig, Catholic University,
1260: Rio de Janeiro, Brazil, 1990.
1261: */
1262:
1263: /* PAD X.3, X.28 and X.29 support */
1264:
1265: static CHAR x29err [MAXPADPARMS+3] = { X29_ERROR, INVALID_PAD_PARM, '\0' };
1266:
1267:
1268: /* Initialize PAD */
1269:
1270: extern CHAR padparms[MAXPADPARMS+1];
1271:
1272: VOID
1273: initpad() {
1274: padparms[PAD_BREAK_CHARACTER] = 0; /* Break character */
1275: padparms[PAD_ESCAPE] = 1; /* Escape permitted */
1276: padparms[PAD_ECHO] = 1; /* Kermit PAD does echo */
1277: padparms[PAD_DATA_FORWARD_CHAR] = 2; /* forward character CR */
1278: padparms[PAD_DATA_FORWARD_TIMEOUT] = 0; /* no timeout forward condition */
1279: padparms[PAD_FLOW_CONTROL_BY_PAD] = 0; /* not used */
1280: padparms[PAD_SUPPRESSION_OF_SIGNALS] = 1; /* allow PAD service signals */
1281: padparms[PAD_BREAK_ACTION] = 21; /* brk action: INT pk + brk ind*/
1282: padparms[PAD_SUPPRESSION_OF_DATA] = 0; /* no supression of user data */
1283: padparms[PAD_PADDING_AFTER_CR] = 0; /* no padding after CR */
1284: padparms[PAD_LINE_FOLDING] = 0; /* no line fold */
1285: padparms[PAD_LINE_SPEED] = 0; /* line speed - don't care */
1286: padparms[PAD_FLOW_CONTROL_BY_USER] = 0; /* flow cont of PAD - not used */
1287: padparms[PAD_LF_AFTER_CR] = 0; /* no LF insertion after CR */
1288: padparms[PAD_PADDING_AFTER_LF] = 0; /* no padding after LF */
1289: padparms[PAD_EDITING] = 1; /* can edit */
1290: padparms[PAD_CHAR_DELETE_CHAR] = 8; /* character delete character */
1291: padparms[PAD_BUFFER_DELETE_CHAR] = 21; /* buffer delete character */
1292: padparms[PAD_BUFFER_DISPLAY_CHAR] = 18; /* buffer display character */
1293: }
1294:
1295:
1296: /* Set PAD parameters */
1297:
1298: VOID
1299: setpad(s,n) CHAR *s; int n; {
1300: int i;
1301: CHAR *ps = s;
1302:
1303: for (i = 0; i < n; i++) {
1304: if (*ps > MAXPADPARMS)
1305: x29err[i+2] = *ps;
1306: else
1307: padparms[*ps] = *(ps+1);
1308: ps += 2;
1309: }
1310: }
1311:
1312: /* Read PAD parameters */
1313:
1314: VOID
1315: readpad(s,n,r) CHAR *s; int n; CHAR *r; {
1316: int i;
1317: CHAR *ps = s;
1318: CHAR *pr = r;
1319:
1320: *pr++ = X29_PARAMETER_INDICATION;
1321: for (i = 0; i < n; i++, ps++) {
1322: if (*ps > MAXPADPARMS) {
1323: x29err[i+2] = *ps++;
1324: } else {
1325: *pr++ = *ps;
1326: *pr++ = padparms[*ps++];
1327: }
1328: }
1329: }
1330:
1331: int
1332: qbitpkt(s,n) CHAR *s; int n; {
1333: CHAR *ps = s;
1334: int x29cmd = *ps;
1335: CHAR *psa = s+1;
1336: CHAR x29resp[(MAXPADPARMS*2)+1];
1337:
1338: switch (x29cmd) {
1339:
1340: case X29_SET_PARMS:
1341: setpad (ps+1,n/2);
1342: if ((int)strlen(x29err) > 2) {
1343: ttol (x29err,(int)strlen(x29err));
1344: x29err[2] = '\0';
1345: }
1346: return (-2);
1347: case X29_READ_PARMS:
1348: readpad (ps+1,n/2,x29resp);
1349: setqbit ();
1350: ttol (x29resp,n+1);
1351: if ((int)strlen(x29err) > 2) {
1352: ttol (x29err,(int)strlen(x29err));
1353: x29err[2] = '\0';
1354: }
1355: resetqbit();
1356: break;
1357: case X29_SET_AND_READ_PARMS:
1358: setpad (ps+1,n/2);
1359: readpad (ps+1,n/2,x29resp);
1360: setqbit();
1361: ttol (x29resp,n+1);
1362: if ((int)strlen(x29err) > 2) {
1363: ttol (x29err,(int)strlen(x29err));
1364: x29err [2] = '\0';
1365: }
1366: resetqbit();
1367: return (-2);
1368: case X29_INVITATION_TO_CLEAR:
1369: (VOID) x25clear();
1370: return (-1) ;
1371: case X29_INDICATION_OF_BREAK:
1372: break;
1373: }
1374: return (0);
1375: }
1376:
1377: /* PAD break action processor */
1378:
1379: VOID
1380: breakact() {
1381: extern char x25obuf[MAXOX25];
1382: extern int obufl;
1383: extern int active;
1384: extern unsigned char tosend;
1385: static CHAR indbrk[3] = {
1386: X29_INDICATION_OF_BREAK,
1387: PAD_SUPPRESSION_OF_DATA,
1388: 1
1389: };
1390: CHAR intudat, cause, diag;
1391:
1392: if (x25stat() < 0) return(0); /* Ignore if no virtual call established */
1393:
1394: if (padparms[PAD_BREAK_ACTION] != 0) /* Forward condition */
1395: if (ttol(x25obuf,obufl) < 0) {
1396: perror ("\r\nCan't send characters");
1397: active = 0;
1398: } else {
1399: bzero (x25obuf,sizeof(x25obuf));
1400: obufl = 0;
1401: tosend = 0;
1402: };
1403:
1404: switch (padparms[PAD_BREAK_ACTION]) {
1405:
1406: case 0 : break; /* do nothing */
1407: case 1 : /* send interrupt packet with interrupt user data field = 1 */
1408: intudat = 1;
1409: x25intr (intudat);
1410: break;
1411: case 2 : /* send reset packet with cause and diag = 0 */
1412: cause = diag = 0;
1413: x25reset (cause,diag);
1414: break;
1415: case 5 : /* send interrupt packet with interrupt user data field = 0 */
1416: intudat = 0;
1417: x25intr (intudat) ;
1418: setqbit ();
1419: /* send indication of break without a parameter field */
1420: ttoc(X29_INDICATION_OF_BREAK);
1421: resetqbit ();
1422: break;
1423: case 8 : active = 0; /* leave data transfer */
1424: conol ("\r\n");
1425: break;
1426: case 21: /* send interrupt packet with interrupt user data field = 0 */
1427: intudat = 0;
1428: x25intr (intudat);
1429: setpad (indbrk+1,2); /* set pad to discard input */
1430: setqbit ();
1431: /* send indication of break with parameter field */
1432: ttol (indbrk,sizeof(indbrk));
1433: resetqbit ();
1434: break;
1435: }
1436: }
1437:
1438: /* X.25 support functions */
1439:
1440: X25_CAUSE_DIAG diag;
1441:
1442: /*
1443: Convert a null-terminated string representing an X.121 address
1444: to a packed BCD form.
1445: */
1446:
1447: int
1448: pkx121(str,bcd) char *str; CHAR *bcd; {
1449: int i, j;
1450: u_char c;
1451:
1452: i = j = 0;
1453: while (str[i]) {
1454: if ( i >= 15 || str [i] < '0' || str [i] > '9' )
1455: return (-1);
1456: c = str [i] - '0';
1457: if ( i & 1 )
1458: bcd [j++] |= c;
1459: else
1460: bcd [j] = c << 4;
1461: i++;
1462: }
1463: return (i);
1464: }
1465:
1466: /* Reads and prints X.25 diagnostic */
1467:
1468: int
1469: x25diag () {
1470: int i;
1471:
1472: bzero ((char *)&diag,sizeof(diag));
1473: if (ioctl(ttyfd,X25_RD_CAUSE_DIAG,&diag)) {
1474: perror ("Reading X.25 diagnostic");
1475: return(-1);
1476: }
1477: if (diag.datalen > 0) {
1478: printf ("X.25 Diagnostic :");
1479: for (i = 0; i < diag.datalen; i++) printf (" %02x",diag.data[i]);
1480: printf ("\r\n");
1481: }
1482: return(0);
1483: }
1484:
1485: /* X.25 Out-of-Band Signal Handler */
1486:
1487: VOID
1488: x25oobh() {
1489: int oobtype;
1490: u_char oobdata;
1491:
1492: (VOID) signal(SIGURG,x25oobh);
1493: do {
1494: if (ioctl(ttyfd,X25_OOB_TYPE,&oobtype)) {
1495: perror ("Getting signal type");
1496: return;
1497: }
1498: switch (oobtype) {
1499: case INT_DATA:
1500: if (recv(ttyfd,oobdata,1,MSG_OOB) < 0) {
1501: perror ("Receiving X.25 interrupt data");
1502: return;
1503: }
1504: printf ("\r\nInterrupt received, data = %d\r\n", oobdata);
1505: break;
1506: case VC_RESET:
1507: printf ("\r\nVirtual circuit reset\r\n");
1508: x25diag ();
1509: break;
1510: case N_RESETS:
1511: printf ("\r\nReset timeout\r\n");
1512: break;
1513: case N_CLEARS:
1514: printf ("\r\nClear timeout\r\n");
1515: break;
1516: case MSG_TOO_LONG:
1517: printf ("\r\nMessage discarded, too long\r\n");
1518: break;
1519: default:
1520: if (oobtype) printf("\r\nUnknown oob type %d\r\n",oobtype);
1521: break;
1522: }
1523: } while (oobtype);
1524: }
1525:
1526: /* Send a X.25 interrupt packet */
1527:
1528: int
1529: #ifdef CK_ANSIC
1530: x25intr(char intr)
1531: #else
1532: x25intr(intr) char intr;
1533: #endif /* CK_ANSIC */
1534: /* x25intr */ {
1535: if (send(ttyfd,&intr,1,MSG_OOB) < 0) return(-1);
1536: debug(F100,"X.25 intr","",0);
1537: return(0);
1538: }
1539:
1540: /* Reset X.25 virtual circuit */
1541: int
1542: #ifdef CK_ANSIC
1543: x25reset(char cause, char diagn)
1544: #else
1545: x25reset(cause, diagn) char cause; char diagn;
1546: #endif /* CK_ANSIC */
1547: /* x25reset */ {
1548: bzero ((char *)&diag,sizeof(diag));
1549: diag.flags = 0;
1550: diag.datalen = 2;
1551: diag.data[0] = cause;
1552: diag.data[1] = diagn;
1553: if (ioctl(ttyfd,X25_WR_CAUSE_DIAG,&diag) < 0)
1554: return(-1);
1555: debug(F100,"X.25 reset","",0);
1556: return(0);
1557: }
1558:
1559: /* Clear X.25 virtual circuit */
1560: int
1561: x25clear() {
1562: int i;
1563: debug(F100,"X.25 clear","",0);
1564: bzero ((char *)&diag,sizeof(diag));
1565: diag.flags = (1 << DIAG_TYPE);
1566: diag.datalen = 2;
1567: diag.data[0] = 0;
1568: diag.data[1] = 0;
1569: ioctl (ttyfd,X25_WR_CAUSE_DIAG,&diag); /* Send Clear Request */
1570: return(ttclos(0)); /* Close socket */
1571: }
1572:
1573: /* X.25 status */
1574: int
1575: x25stat() {
1576: if (ttyfd < 0) return (-1);
1577: return(0);
1578: }
1579:
1580: /* Set Q_BIT on */
1581: VOID
1582: setqbit() {
1583: static int qbiton = 1 << Q_BIT;
1584: ioctl (ttyfd,X25_SEND_TYPE,&qbiton);
1585: }
1586:
1587: /* Set Q_BIT off */
1588: VOID
1589: resetqbit() {
1590: static int qbitoff = 0;
1591: ioctl (ttyfd,X25_SEND_TYPE,&qbitoff);
1592: }
1593:
1594: /* Read n characters from X.25 circuit into buf */
1595:
1596: int
1597: x25xin(n,buf) int n; CHAR *buf; {
1598: register int x, c;
1599: int qpkt;
1600:
1601: do {
1602: x = read(ttyfd,buf,n);
1603: if (buf[0] & (1 << Q_BIT)) { /* If Q_BIT packet, process it */
1604: /* If return -1 : invitation to clear; -2 : PAD changes */
1605: if ((c=qbitpkt(buf+1,x-2)) < 0) return(c);
1606: qpkt = 1;
1607: } else qpkt = 0;
1608: } while (qpkt);
1609: if (x > 0) buf[x] = '\0';
1610: if (x < 1) x = -1;
1611: debug(F101,"x25xin x","",x);
1612:
1613: return(x);
1614: }
1615:
1616: #ifdef COMMENT /* NO LONGER NEEDED! */
1617: /* X.25 read a line */
1618:
1619: int
1620: #ifdef PARSENSE
1621: #ifdef CK_ANSIC
1622: x25inl(CHAR *dest, int max,int timo, CHAR eol, CHAR start)
1623: #else
1624: x25inl(dest,max,timo,eol,start) int max,timo; CHAR *dest, eol, start;
1625: #endif /* CK_ANSIC */
1626: #else /* not PARSENSE */
1627: #ifdef CK_ANSIC
1628: x25inl(CHAR *dest, int max,int timo, CHAR eol)
1629: #else
1630: x25inl(dest,max,timo,eol) int max,timo; CHAR *dest, eol;
1631: #endif /* __SDTC__ */
1632: #endif /* PARSENSE */
1633: /* x25inl */ {
1634: CHAR *pdest;
1635: int pktype, goteol, rest, n;
1636: int i, flag = 0;
1637: extern int ttprty, ttpflg;
1638: int ttpmsk;
1639:
1640: ttpmsk = (ttprty) ? 0177 : 0377; /* Set parity stripping mask */
1641:
1642: debug(F101,"x25inl max","",max);
1643: debug(F101,"x25inl eol","",eol);
1644: pdest = dest;
1645: rest = max;
1646: goteol = 0;
1647: do {
1648: n = read(ttyfd,pdest,rest);
1649: n--;
1650: pktype = *pdest & 0x7f;
1651: switch (pktype) {
1652: case 1 << Q_BIT:
1653: if (qbitpkt(pdest+1,--n) < 0) return(-2);
1654: break;
1655: default:
1656: if (flag == 0) { /* if not in packet, search start */
1657: for (i = 1; (i < n) &&
1658: !(flag = ((dest[i] & 0x7f) == start));
1659: i++);
1660: if (flag == 0) { /* not found, discard junk */
1661: debug(F101,"x25inl skipping","",n);
1662: continue;
1663: } else { /* found, discard junk before start */
1664: int k;
1665: n = n - i + 1;
1666: for (k = 1; k <= n; k++, i++) dest[k] = dest[i];
1667: }
1668: }
1669: for (i = 0; (i < n) && /* search for eol */
1670: !(goteol=(((*pdest = *(pdest+1)&ttpmsk)&0x7f)== eol));
1671: i++,pdest++);
1672: *pdest = '\0';
1673: rest -= n;
1674: }
1675: } while ( (rest > 0) && (!goteol) );
1676:
1677: if (goteol) {
1678: n = max - rest;
1679: debug (F111,"x25inl X.25 got",(char *) dest,n);
1680: if (timo) ttimoff();
1681: if (ttpflg++ == 0 && ttprty == 0) {
1682: if ((ttprty = parchk(dest,start,n)) > 0) {
1683: int j;
1684: debug(F101,"x25inl senses parity","",ttprty);
1685: debug(F110,"x25inl packet before",(char *)dest,0);
1686: ttpmsk = 0x7f;
1687: for (j = 0; j < n; j++)
1688: dest[j] &= 0x7f; /* Strip parity from packet */
1689: debug(F110,"x25inl packet after ",dest,0);
1690: } else {
1691: debug(F101,"parchk","",ttprty);
1692: if (ttprty < 0) { ttprty = 0; n = -1; }
1693: }
1694: }
1695: ttimoff();
1696: return(n);
1697: }
1698: ttimoff();
1699: return(-1);
1700: }
1701: #endif /* COMMENT */
1702: #endif /* SUNX25 */
1703:
1704: #endif /* NETCONN */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.