xref: /illumos-gate/usr/src/cmd/bnu/interface.c (revision 09f57ade)
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 2014 Gary Mills
24  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
29 /*	  All Rights Reserved  	*/
30 
31 /*
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 #endif /*  TLI  */
83 /*
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 */
100 					/* first i/o operation */
101 	int	(*IN_teardown)();	/* teardown function, called after */
102 					/* last 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
interface(label)141 interface(label)
142 char	*label;
143 {
144 	register int	i;
145 
146 	for (i = 0;  Interface[i].IN_label;  ++i) {
147 		if (0 == 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
usetup(role,fdreadp,fdwritep)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
uteardown(role,fdread,fdwrite)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
dksetup(role,fdreadp,fdwritep)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
dkteardown(role,fdread,fdwrite)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",
248 		    fdread);
249 	if (ioctl(fdwrite, DIOCFLUSH, NULL) != 0)
250 		DEBUG(4, "dkteardown: DIOCFLUSH of output fd %d failed",
251 		    fdwrite);
252 
253 	(void) close(fdread);
254 	(void) close(fdwrite);
255 	return (SUCCESS);
256 }
257 #endif /* DATAKIT */
258 
259 
260 #ifdef TLI
261 /*
262  *	tread - tli read routine
263  */
264 static ssize_t
tread(fd,buf,nbytes)265 tread(fd, buf, nbytes)
266 int		fd;
267 char		*buf;
268 unsigned	nbytes;
269 {
270 	int		rcvflags;
271 
272 	return ((ssize_t)t_rcv(fd, buf, nbytes, &rcvflags));
273 }
274 
275 /*
276  *	twrite - tli write routine
277  */
278 #define	N_CHECK	100
279 static ssize_t
twrite(fd,buf,nbytes)280 twrite(fd, buf, nbytes)
281 int		fd;
282 char		*buf;
283 unsigned	nbytes;
284 {
285 	register int		i, ret;
286 	static int		n_writ, got_info;
287 	static struct t_info	info;
288 
289 	if (got_info == 0) {
290 		if (t_getinfo(fd, &info) != 0) {
291 			tfaillog(fd, "twrite: t_getinfo\n");
292 			return (FAIL);
293 		}
294 		got_info = 1;
295 	}
296 
297 	/* on every N_CHECKth call, check that are still in DATAXFER state */
298 	if (++n_writ == N_CHECK) {
299 		n_writ = 0;
300 		if (t_getstate(fd) != T_DATAXFER)
301 			return (FAIL);
302 	}
303 
304 	if (info.tsdu <= 0 || nbytes <= info.tsdu)
305 		return (t_snd(fd, buf, nbytes, 0));
306 
307 	/* if get here, then there is a limit on transmit size	*/
308 	/* (info.tsdu > 0) and buf exceeds it			*/
309 	i = ret = 0;
310 	while (nbytes >= info.tsdu) {
311 		if ((ret = t_snd(fd,  &buf[i], info.tsdu, 0)) != info.tsdu)
312 			return ((ret >= 0 ? (i + ret) : ret));
313 		i += info.tsdu;
314 		nbytes -= info.tsdu;
315 	}
316 	if (nbytes != 0) {
317 		if ((ret = t_snd(fd,  &buf[i], nbytes, 0)) != nbytes)
318 			return ((ssize_t)(ret >= 0 ? (i + ret) : ret));
319 		i += nbytes;
320 	}
321 	return ((ssize_t)i);
322 }
323 
324 
325 /*
326  *	tioctl - stub for tli ioctl routine
327  */
328 /*ARGSUSED*/
329 static int
330 #ifdef __STDC__
tioctl(int fd,int request,...)331 tioctl(int fd, int request, ...)
332 #else
333 tioctl(fd, request, arg)
334 int	fd, request;
335 #endif
336 {
337 	return (SUCCESS);
338 }
339 
340 /*
341  *	tsetup - tli setup routine
342  *	note blatant assumption that *fdreadp == *fdwritep == 0
343  */
344 static int
tsetup(role,fdreadp,fdwritep)345 tsetup(role, fdreadp, fdwritep)
346 int	*fdreadp, *fdwritep;
347 {
348 
349 	if (role == SLAVE) {
350 		*fdreadp = 0;
351 		*fdwritep = 1;
352 		/* 2 has been re-opened to RMTDEBUG in main() */
353 		errno = t_errno = 0;
354 		if (t_sync(*fdreadp) == -1 || t_sync(*fdwritep) == -1) {
355 			tfaillog(*fdreadp, "tsetup: t_sync\n");
356 			return (FAIL);
357 		}
358 	}
359 	return (SUCCESS);
360 }
361 
362 /*
363  *	tteardown - tli shutdown routine
364  */
365 /*ARGSUSED*/
366 static int
tteardown(role,fdread,fdwrite)367 tteardown(role, fdread, fdwrite)
368 {
369 	(void) t_unbind(fdread);
370 	(void) t_close(fdread);
371 	return (SUCCESS);
372 }
373 
374 #ifdef TLIS
375 /*
376  *	tssetup - tli, with streams module, setup routine
377  *	note blatant assumption that *fdreadp == *fdwritep
378  */
379 static int
tssetup(role,fdreadp,fdwritep)380 tssetup(role, fdreadp, fdwritep)
381 int	role;
382 int	*fdreadp;
383 int	*fdwritep;
384 {
385 	if (role == SLAVE) {
386 		*fdreadp = 0;
387 		*fdwritep = 1;
388 		/* 2 has been re-opened to RMTDEBUG in main() */
389 		DEBUG(5, "tssetup: SLAVE mode: leaving ok\n%s", "");
390 		return (SUCCESS);
391 	}
392 
393 	DEBUG(4, "tssetup: MASTER mode: leaving ok\n%s", "");
394 	return (SUCCESS);
395 }
396 
397 /*
398  *	Report why a TLI call failed.
399  */
400 GLOBAL void
tfaillog(fd,s)401 tfaillog(fd, s)
402 int	fd;
403 char	*s;
404 {
405 	char	fmt[ BUFSIZ ];
406 
407 	if (0 < t_errno && t_errno < t_nerr) {
408 		sprintf(fmt, "%s: %%s\n", s);
409 		DEBUG(5, fmt, t_errlist[t_errno]);
410 		logent(s, t_errlist[t_errno]);
411 		if (t_errno == TSYSERR) {
412 			strcpy(fmt, "tlicall: system error: %s\n");
413 			DEBUG(5, fmt, strerror(errno));
414 		} else if (t_errno == TLOOK) {
415 			show_tlook(fd);
416 		}
417 	} else {
418 		sprintf(fmt, "unknown tli error %d", t_errno);
419 		logent(s, fmt);
420 		sprintf(fmt, "%s: unknown tli error %d", s, t_errno);
421 		DEBUG(5, fmt, 0);
422 		sprintf(fmt, "%s: %%s\n", s);
423 		DEBUG(5, fmt, strerror(errno));
424 	}
425 }
426 
427 GLOBAL void
show_tlook(fd)428 show_tlook(fd)
429 int fd;
430 {
431 	register int reason;
432 	register char *msg;
433 	extern int	t_errno;
434 /*
435  * Find out the current state of the interface.
436  */
437 	errno = t_errno = 0;
438 	switch (reason = t_getstate(fd)) {
439 	case T_UNBND:		msg = "T_UNBIND";	break;
440 	case T_IDLE:		msg = "T_IDLE";		break;
441 	case T_OUTCON:		msg = "T_OUTCON";	break;
442 	case T_INCON:		msg = "T_INCON";	break;
443 	case T_DATAXFER:	msg = "T_DATAXFER";	break;
444 	case T_OUTREL:		msg = "T_OUTREL";	break;
445 	case T_INREL:		msg = "T_INREL";	break;
446 	default:		msg = NULL;		break;
447 	}
448 	if (msg == NULL)
449 		return;
450 
451 	DEBUG(5, "state is %s", msg);
452 	switch (reason = t_look(fd)) {
453 	case -1:		msg = ""; break;
454 	case 0:			msg = "NO ERROR"; break;
455 	case T_LISTEN:		msg = "T_LISTEN"; break;
456 	case T_CONNECT:		msg = "T_CONNECT"; break;
457 	case T_DATA:		msg = "T_DATA";	 break;
458 	case T_EXDATA:		msg = "T_EXDATA"; break;
459 	case T_DISCONNECT:	msg = "T_DISCONNECT"; break;
460 	case T_ORDREL:		msg = "T_ORDREL"; 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 }
480 
481 #endif /*  TLIS  */
482 
483 #endif /*  TLI  */
484