Home | History | Annotate | Download | only in bnu
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License, Version 1.0 only
      6  * (the "License").  You may not use this file except in compliance
      7  * with the License.
      8  *
      9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
     10  * or http://www.opensolaris.org/os/licensing.
     11  * See the License for the specific language governing permissions
     12  * and limitations under the License.
     13  *
     14  * When distributing Covered Code, include this CDDL HEADER in each
     15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     16  * If applicable, add the following below this CDDL HEADER, with the
     17  * fields enclosed by brackets "[]" replaced with your own identifying
     18  * information: Portions Copyright [yyyy] [name of copyright owner]
     19  *
     20  * CDDL HEADER END
     21  */
     22 /*
     23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
     24  * Use is subject to license terms.
     25  */
     26 
     27 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
     28 /*	  All Rights Reserved  	*/
     29 
     30 
     31 #pragma ident	"%Z%%M%	%I%	%E% SMI"
     32 /*	interface( label )
     33 	provide alternate definitions for the I/O functions through global
     34 	interfaces.
     35 */
     36 #include	"uucp.h"
     37 
     38 #ifdef TLI
     39 #include	<tiuser.h>
     40 char *t_alloc();
     41 int t_bind(), t_close(), t_connect(), t_free(), t_look(), t_open(), t_rcvdis();
     42 int t_getinfo(), t_getstate(), t_look(), t_rcv(), t_snd(), t_sync(), t_unbind();
     43 #endif /*  TLI  */
     44 
     45 #ifdef DATAKIT
     46 #include	"dk.h"
     47 
     48 static int	dksetup();
     49 static int	dkteardown();
     50 #endif	/* DATAKIT */
     51 
     52 EXTERN void	sethup();
     53 EXTERN int	restline();
     54 #if defined(__STDC__)
     55 extern int	ioctl(int, int, ...);
     56 #else
     57 extern int	ioctl();
     58 #endif
     59 static int	usetup(), uteardown();
     60 
     61 GLOBAL ssize_t	(*Read)() = read,
     62 	(*Write)() = write;
     63 #if defined(__STDC__)
     64 GLOBAL int	(*Ioctl)(int,int,...) = ioctl,
     65 #else
     66 GLOBAL int	(*Ioctl)() = ioctl,
     67 #endif
     68 	(*Setup)() = usetup,
     69 	(*Teardown)() = uteardown;
     70 
     71 #ifdef TLI
     72 EXTERN void tfaillog(), show_tlook();
     73 static ssize_t	tread(), twrite();	/* TLI i/o */
     74 #ifdef __STDC__
     75 static int	tioctl(int, int, ...),
     76 #else
     77 static int	tioctl(),		/* TLI i/o control */
     78 #endif
     79 		tsetup(),		/* TLI setup without streams module */
     80 		tssetup(),		/* TLI setup with streams module */
     81 		tteardown();		/* TLI teardown, works with either setup
     82 					*/
     83 #endif /*  TLI  */
     84 /*	The IN_label in Interface[] imply different caller routines:
     85 	e.g. tlicall().
     86 	If so, the names here and the names in callers.c must match.
     87 */
     88 
     89 static
     90   struct Interface {
     91 	char	*IN_label;		/* interface name */
     92 	ssize_t	(*IN_read)();		/* read function */
     93 	ssize_t	(*IN_write)();		/* write function */
     94 #ifdef __STDC__
     95 	int	(*IN_ioctl)(int,int,...);
     96 #else
     97 	int	(*IN_ioctl)();		/* ioctl function */
     98 #endif
     99 	int	(*IN_setup)();		/* setup function, called before first
    100 					i/o operation */
    101 	int	(*IN_teardown)();	/* teardown function, called after last
    102 					i/o operation */
    103 } Interface[] = {
    104 			/* vanilla UNIX */
    105 		{ "UNIX", read, write, ioctl, usetup, uteardown },
    106 #ifdef TCP
    107 			/* TCP over sockets or UNET */
    108 		{ "TCP", read, write, ioctl, usetup, uteardown },
    109 #endif /* TCP */
    110 #ifdef SYTEK
    111 			/* Sytek network */
    112 		{ "Sytek", read, write, ioctl, usetup, uteardown },
    113 #endif /* Sytek network */
    114 #ifdef DIAL801
    115 			/* 801 auto dialers */
    116 		{ "801", read, write, ioctl, usetup, uteardown },
    117 #endif /* DIAL801 */
    118 #ifdef DIAL801
    119 			/* 212 auto dialers */
    120 		{ "212", read, write, ioctl, usetup, uteardown },
    121 #endif /* DIAL801 */
    122 #ifdef TLI
    123 			/* AT&T Transport Interface Library WITHOUT streams */
    124 		{ "TLI", tread, twrite, tioctl, tsetup, tteardown },
    125 #ifdef TLIS
    126 			/* AT&T Transport Interface Library WITH streams */
    127 		{ "TLIS", read, write, tioctl, tssetup, uteardown },
    128 #endif /*  TLIS  */
    129 #endif /*  TLI  */
    130 #ifdef DATAKIT
    131 		{ "DK", read, write, ioctl, dksetup, dkteardown },
    132 #endif /* DATAKIT */
    133 #ifdef UNET
    134 		{ "Unetserver", read, write, ioctl, usetup, uteardown },
    135 #endif
    136 		{ 0, 0, 0, 0, 0, 0 }
    137 	};
    138 
    139 
    140 GLOBAL int
    141 interface(label)
    142 char	*label;
    143 {
    144 	register int	i;
    145 
    146 	for ( i = 0;  Interface[i].IN_label;  ++i ) {
    147 		if( !strcmp( Interface[i].IN_label, label ) ) {
    148 			Read = Interface[i].IN_read;
    149 			Write = Interface[i].IN_write;
    150 			Ioctl = Interface[i].IN_ioctl;
    151 			Setup = Interface[i].IN_setup;
    152 			Teardown = Interface[i].IN_teardown;
    153 			DEBUG(5, "set interface %s\n", label);
    154 			return( 0 );
    155 		}
    156 	}
    157 	return( FAIL );
    158 }
    159 
    160 /*
    161  *	usetup - vanilla unix setup routine
    162  */
    163 static int
    164 usetup( role, fdreadp, fdwritep )
    165 int	*fdreadp, *fdwritep;
    166 {
    167 	if ( role == SLAVE )
    168 	{
    169 		*fdreadp = 0;
    170 		*fdwritep = 1;
    171 		/* 2 has been re-opened to RMTDEBUG in main() */
    172 	}
    173 	return(SUCCESS);
    174 }
    175 
    176 /*
    177  *	uteardown - vanilla unix teardown routine
    178  */
    179 static int
    180 uteardown( role, fdread, fdwrite )
    181 {
    182 	int ret;
    183 	char *ttyn;
    184 
    185 	if (role == SLAVE) {
    186 		ret = restline();
    187 		DEBUG(4, "ret restline - %d\n", ret);
    188 		if (fdread != -1)
    189 			sethup(fdread);
    190 	}
    191 	if (fdread != -1) {
    192 		ttyn = ttyname(fdread);
    193 		if (ttyn != NULL && Dev_mode != 0)
    194 			chmod(ttyn, Dev_mode);	/* can fail, but who cares? */
    195 		(void) close(fdread);
    196 		(void) close(fdwrite);
    197 	}
    198 	return(SUCCESS);
    199 }
    200 
    201 #ifdef DATAKIT
    202 /*
    203  *	dksetup - DATAKIT setup routine
    204  *
    205  * Put line in block mode.
    206  */
    207 
    208 static int
    209 dksetup (role, fdreadp, fdwritep)
    210 
    211 int	role;
    212 int *	fdreadp;
    213 int *	fdwritep;
    214 
    215 {
    216 	static short dkrmode[3] = { DKR_BLOCK | DKR_TIME, 0, 0 };
    217 	int	ret;
    218 
    219 	(void) usetup(role, fdreadp, fdwritep);
    220 	if((ret = (*Ioctl)(*fdreadp, DIOCRMODE, dkrmode)) < 0) {
    221 		DEBUG(4, "dksetup: failed to set block mode. ret=%d,\n", ret);
    222 		DEBUG(4, "read fd=%d, ", *fdreadp);
    223 		DEBUG(4, "errno=%d\n", errno);
    224 		return(FAIL);
    225 	}
    226 	return(SUCCESS);
    227 }
    228 
    229 /*
    230  *	dkteardown  -  DATAKIT teardown routine
    231  */
    232 static int
    233 dkteardown( role, fdread, fdwrite )
    234 int	role, fdread, fdwrite;
    235 {
    236 	char	*ttyn;
    237 
    238 	if ( role == MASTER ) {
    239 		ttyn = ttyname(fdread);
    240 		if ( ttyn != NULL && Dev_mode != 0 )
    241 			chmod(ttyn, Dev_mode);	/* can fail, but who cares? */
    242 	}
    243 
    244 	/*	must flush fd's for datakit	*/
    245 	/*	else close can hang		*/
    246 	if ( ioctl(fdread, DIOCFLUSH, NULL) != 0 )
    247 		DEBUG(4, "dkteardown: DIOCFLUSH of input fd %d failed", fdread);
    248 	if ( ioctl(fdwrite, DIOCFLUSH, NULL) != 0 )
    249 		DEBUG(4, "dkteardown: DIOCFLUSH of output fd %d failed", fdwrite);
    250 
    251 	(void)close(fdread);
    252 	(void)close(fdwrite);
    253 	return(SUCCESS);
    254 }
    255 #endif /* DATAKIT */
    256 
    257 
    258 #ifdef TLI
    259 /*
    260  *	tread - tli read routine
    261  */
    262 static ssize_t
    263 tread(fd, buf, nbytes)
    264 int		fd;
    265 char		*buf;
    266 unsigned	nbytes;
    267 {
    268 	int		rcvflags;
    269 
    270 	return((ssize_t)t_rcv(fd, buf, nbytes, &rcvflags));
    271 }
    272 
    273 /*
    274  *	twrite - tli write routine
    275  */
    276 #define	N_CHECK	100
    277 static ssize_t
    278 twrite(fd, buf, nbytes)
    279 int		fd;
    280 char		*buf;
    281 unsigned	nbytes;
    282 {
    283 	register int		i, ret;
    284 	static int		n_writ, got_info;
    285 	static struct t_info	info;
    286 
    287 	if ( got_info == 0 ) {
    288 		if ( t_getinfo(fd, &info) != 0 ) {
    289 			tfaillog(fd, "twrite: t_getinfo\n");
    290 			return(FAIL);
    291 		}
    292 		got_info = 1;
    293 	}
    294 
    295 	/* on every N_CHECKth call, check that are still in DATAXFER state */
    296 	if ( ++n_writ == N_CHECK ) {
    297 		n_writ = 0;
    298 		if ( t_getstate(fd) != T_DATAXFER )
    299 			return(FAIL);
    300 	}
    301 
    302 	if ( info.tsdu <= 0 || nbytes <= info.tsdu )
    303 		return(t_snd(fd, buf, nbytes, NULL));
    304 
    305 	/* if get here, then there is a limit on transmit size	*/
    306 	/* (info.tsdu > 0) and buf exceeds it			*/
    307 	i = ret = 0;
    308 	while ( nbytes >= info.tsdu ) {
    309 		if ( (ret = t_snd(fd,  &buf[i], info.tsdu, NULL)) != info.tsdu )
    310 			return( ( ret >= 0 ? (i + ret) : ret ) );
    311 		i += info.tsdu;
    312 		nbytes -= info.tsdu;
    313 	}
    314 	if ( nbytes != 0 ) {
    315 		if ( (ret = t_snd(fd,  &buf[i], nbytes, NULL)) != nbytes )
    316 			return( (ssize_t)( ret >= 0 ? (i + ret) : ret ) );
    317 		i += nbytes;
    318 	}
    319 	return((ssize_t)i);
    320 }
    321 
    322 
    323 /*
    324  *	tioctl - stub for tli ioctl routine
    325  */
    326 /*ARGSUSED*/
    327 static int
    328 #ifdef __STDC__
    329 tioctl(int fd, int request, ...)
    330 #else
    331 tioctl(fd, request, arg)
    332 int	fd, request;
    333 #endif
    334 {
    335 	return(SUCCESS);
    336 }
    337 
    338 /*
    339  *	tsetup - tli setup routine
    340  *	note blatant assumption that *fdreadp == *fdwritep == 0
    341  */
    342 static int
    343 tsetup( role, fdreadp, fdwritep )
    344 int	*fdreadp, *fdwritep;
    345 {
    346 
    347 	if ( role == SLAVE ) {
    348 		*fdreadp = 0;
    349 		*fdwritep = 1;
    350 		/* 2 has been re-opened to RMTDEBUG in main() */
    351 		errno = t_errno = 0;
    352 		if ( t_sync(*fdreadp) == -1 || t_sync(*fdwritep) == -1 ) {
    353 			tfaillog(*fdreadp, "tsetup: t_sync\n");
    354 			return(FAIL);
    355 		}
    356 	}
    357 	return(SUCCESS);
    358 }
    359 
    360 /*
    361  *	tteardown - tli shutdown routine
    362  */
    363 /*ARGSUSED*/
    364 static int
    365 tteardown( role, fdread, fdwrite )
    366 {
    367 	(void)t_unbind(fdread);
    368 	(void)t_close(fdread);
    369 	return(SUCCESS);
    370 }
    371 
    372 #ifdef TLIS
    373 /*
    374  *	tssetup - tli, with streams module, setup routine
    375  *	note blatant assumption that *fdreadp == *fdwritep
    376  */
    377 static int
    378 tssetup( role, fdreadp, fdwritep )
    379 int	role;
    380 int	*fdreadp;
    381 int	*fdwritep;
    382 {
    383 	if ( role == SLAVE ) {
    384 		*fdreadp = 0;
    385 		*fdwritep = 1;
    386 		/* 2 has been re-opened to RMTDEBUG in main() */
    387 		DEBUG(5, "tssetup: SLAVE mode: leaving ok\n%s", "");
    388 		return(SUCCESS);
    389 	}
    390 
    391 	DEBUG(4, "tssetup: MASTER mode: leaving ok\n%s", "");
    392 	return(SUCCESS);
    393 }
    394 
    395 /*
    396  *	Report why a TLI call failed.
    397  */
    398 GLOBAL void
    399 tfaillog(fd, s)
    400 int	fd;
    401 char	*s;
    402 {
    403 	char	fmt[ BUFSIZ ];
    404 
    405 	if (0 < t_errno && t_errno < t_nerr) {
    406 		sprintf( fmt, "%s: %%s\n", s );
    407 		DEBUG(5, fmt, t_errlist[t_errno]);
    408 		logent(s, t_errlist[t_errno]);
    409 		if ( t_errno == TSYSERR ) {
    410 			strcpy(fmt, "tlicall: system error: %s\n");
    411 			DEBUG(5, fmt, strerror(errno));
    412 		} else if ( t_errno == TLOOK ) {
    413 			show_tlook(fd);
    414 		}
    415 	} else {
    416 		sprintf(fmt, "unknown tli error %d", t_errno);
    417 		logent(s, fmt);
    418 		sprintf(fmt, "%s: unknown tli error %d", s, t_errno);
    419 		DEBUG(5, fmt, 0);
    420 		sprintf(fmt, "%s: %%s\n", s);
    421 		DEBUG(5, fmt, strerror(errno));
    422 	}
    423 	return;
    424 }
    425 
    426 GLOBAL void
    427 show_tlook(fd)
    428 int fd;
    429 {
    430 	register int reason;
    431 	register char *msg;
    432 	extern int	t_errno;
    433 /*
    434  * Find out the current state of the interface.
    435  */
    436 	errno = t_errno = 0;
    437 	switch( reason = t_getstate(fd) ) {
    438 	case T_UNBND:		msg = "T_UNBIND";	break;
    439 	case T_IDLE:		msg = "T_IDLE";		break;
    440 	case T_OUTCON:		msg = "T_OUTCON";	break;
    441 	case T_INCON:		msg = "T_INCON";	break;
    442 	case T_DATAXFER:	msg = "T_DATAXFER";	break;
    443 	case T_OUTREL:		msg = "T_OUTREL";	break;
    444 	case T_INREL:		msg = "T_INREL";	break;
    445 	default:		msg = NULL;		break;
    446 	}
    447 	if( msg == NULL )
    448 		return;
    449 
    450 	DEBUG(5, "state is %s", msg);
    451 	switch( reason = t_look(fd) ) {
    452 	case -1:		msg = ""; break;
    453 	case 0:			msg = "NO ERROR"; break;
    454 	case T_LISTEN:		msg = "T_LISTEN"; break;
    455 	case T_CONNECT:		msg = "T_CONNECT"; break;
    456 	case T_DATA:		msg = "T_DATA";	 break;
    457 	case T_EXDATA:		msg = "T_EXDATA"; break;
    458 	case T_DISCONNECT:	msg = "T_DISCONNECT"; break;
    459 	case T_ORDREL:		msg = "T_ORDREL"; break;
    460 	case T_ERROR:		msg = "T_ERROR"; break;
    461 	case T_UDERR:		msg = "T_UDERR"; break;
    462 	default:		msg = "UNKNOWN ERROR"; break;
    463 	}
    464 	DEBUG(4, " reason is %s\n", msg);
    465 
    466 	if ( reason == T_DISCONNECT )
    467 	{
    468 		struct t_discon	*dropped;
    469 		if ( ((dropped =
    470 			(struct t_discon *)t_alloc(fd, T_DIS, T_ALL)) == 0)
    471 		||  (t_rcvdis(fd, dropped) == -1 )) {
    472 			if (dropped)
    473 				t_free((char *)dropped, T_DIS);
    474 			return;
    475 		}
    476 		DEBUG(5, "disconnect reason #%d\n", dropped->reason);
    477 		t_free((char *)dropped, T_DIS);
    478 	}
    479 	return;
    480 }
    481 
    482 #endif /*  TLIS  */
    483 
    484 #endif /*  TLI  */
    485