![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ts2bsd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / tsap|
Return to ts2bsd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / tsap |
1.1 root 1: /* ts2bsd.c - TPM: 4.4BSD OSI TP4 interface */
2: #define STATIC /**/
3:
4: #ifndef lint
5: static char *rcsid = "$Header: /f/osi/tsap/RCS/ts2bsd.c,v 7.9 90/07/09 14:51:13 mrose Exp $";
6: #endif
7:
8: /*
9: * $Header: /f/osi/tsap/RCS/ts2bsd.c,v 7.9 90/07/09 14:51:13 mrose Exp $
10: *
11: *
12: * $Log: ts2bsd.c,v $
13: * Revision 7.9 90/07/09 14:51:13 mrose
14: * sync
15: *
16: * Revision 7.8 90/03/23 17:31:16 mrose
17: * 8
18: *
19: * Revision 7.7 90/03/22 08:38:02 mrose
20: * touch-up
21: *
22: * Revision 7.6 89/12/19 10:18:28 mrose
23: * DLOG
24: *
25: * Revision 7.5 89/12/18 17:49:48 mrose
26: * touch-up
27: *
28: * Revision 7.4 89/12/08 16:26:47 mrose
29: * keith
30: *
31: * Revision 7.1 89/12/01 10:46:26 mrose
32: * touch-up
33: *
34: * Revision 7.0 89/11/23 22:30:36 mrose
35: * Release 6.0
36: *
37: */
38:
39: /*
40: * NOTICE
41: *
42: * Acquisition, use, and distribution of this module and related
43: * materials are subject to the restrictions of a license agreement.
44: * Consult the Preface in the User's Manual for the full terms of
45: * this agreement.
46: *
47: */
48:
49:
50: /* LINTLIBRARY */
51:
52: #include <stdio.h>
53: #include "tpkt.h"
54:
55: #ifdef TP4
56: #include "tp4.h"
57: #endif
58:
59: #ifdef BSD_TP4
60: #include <errno.h>
61: #include <sys/ioctl.h>
62: #include <sys/uio.h>
63: #include "tailor.h"
64:
65: /*#define MAXTP4 8192 /* until we have a dynamic estimate... */
66: #define MAXTP4 1024 /* until we have a dynamic estimate... */
67: #define TP4SLOP 12 /* estimate of largest DT PCI */
68:
69: /* DATA */
70:
71: STATIC struct msghdr msgs;
72: STATIC union osi_control_msg ocm;
73:
74:
75: extern int errno;
76:
77: /* Ancillary routines */
78: STATIC int sendCmsg(fd, cc, type, data)
79: int fd;
80: int cc;
81: int type;
82: char *data;
83: {
84: int result;
85: register struct msghdr *msg = &msgs;
86: register union osi_control_msg *oc = &ocm;
87:
88: bzero ((char *) msg, sizeof *msg);
89: msg -> msg_control = oc -> ocm_data;
90:
91: bzero ((char *) oc, sizeof *oc);
92: oc -> ocm_control.ocm_cmhdr.cmsg_level = SOL_TRANSPORT;
93: oc -> ocm_control.ocm_cmhdr.cmsg_type = type;
94: oc -> ocm_control.ocm_cmhdr.cmsg_len = sizeof oc -> ocm_control.ocm_cmhdr;
95:
96: if (cc) {
97: bcopy (data, oc -> ocm_control.ocm_cmdata, cc);
98: oc -> ocm_control.ocm_cmhdr.cmsg_len += cc;
99: }
100: msg -> msg_controllen = oc -> ocm_control.ocm_cmhdr.cmsg_len;
101:
102: return sendmsg (fd, msg, 0);
103: }
104:
105: int tp4getCmsg(fd, cc, type, data)
106: int fd;
107: int *cc;
108: int *type;
109: char *data;
110: {
111: int result;
112: register struct msghdr *msg = &msgs;
113: register union osi_control_msg *oc = &ocm;
114:
115: bzero ((char *) msg, sizeof *msg);
116: msg -> msg_control = oc -> ocm_data;
117: msg -> msg_controllen = sizeof oc -> ocm_data;
118:
119: bzero ((char *) oc, sizeof *oc);
120:
121: result = recvmsg (fd, msg, 0);
122: if (result >= 0 && cc && type && data) {
123: register int n =
124: (oc -> ocm_control.ocm_cmhdr.cmsg_len
125: - sizeof (oc -> ocm_control.ocm_cmhdr));
126: if (n > 0) {
127: *type = oc-> ocm_control.ocm_cmhdr.cmsg_type;
128: if (n > *cc)
129: n = *cc;
130: bcopy(oc -> ocm_control.ocm_cmdata, data, n);
131: *cc = n;
132: }
133: }
134: return (result);
135: }
136:
137: /* UPPER HALF */
138:
139: STATIC int TConnect (tb, expedited, data, cc, td)
140: register struct tsapblk *tb;
141: char *data;
142: int expedited,
143: cc;
144: struct TSAPdisconnect *td;
145: {
146: int len;
147: union sockaddr_osi sock;
148: struct sockaddr_iso *ifaddr = &sock.osi_sockaddr;
149: struct tp_conn_param tcp;
150: register struct tp_conn_param *p = &tcp;
151:
152: if (gen2tp4X (&tb -> tb_responding, &sock) == NOTOK)
153: return tsaplose (td, DR_ADDRESS, NULLCP,
154: "unable to parse remote address");
155:
156: len = sizeof *p;
157: if (getsockopt (tb -> tb_fd, SOL_TRANSPORT, TPOPT_PARAMS, (char *) p, &len)
158: == NOTOK)
159: SLOG (tsap_log, LLOG_EXCEPTIONS, "TPOPT_PARAMS", ("unable to get"));
160: else {
161: if (p -> p_xpd_service ? !expedited : expedited) {
162: p -> p_xpd_service = expedited ? 1 : 0;
163: if (setsockopt (tb -> tb_fd, SOL_TRANSPORT, TPOPT_PARAMS,
164: (char *) p, sizeof *p) == NOTOK)
165: SLOG (tsap_log, LLOG_EXCEPTIONS, "TPOPT_PARAMS",
166: ("unable to set"));
167: }
168:
169: if (expedited)
170: tb -> tb_flags |= TB_EXPD;
171: if (p -> p_tpdusize > 0) {
172: if (p -> p_tpdusize > 10)
173: p -> p_tpdusize = 10;
174: tb -> tb_tpduslop = TP4SLOP;
175: tb -> tb_tsdusize = (1 << p -> p_tpdusize) - tb -> tb_tpduslop;
176: }
177: }
178:
179: if (data &&
180: sendCmsg(tb->tb_fd, data, cc, TPOPT_CONN_DATA) == NOTOK)
181: return tsaplose (td, DR_CONGEST, "TPOPT_CONN_DATA", "unable to send");
182:
183: /*
184: this is a real hack to pass information between TConnect and TRetry:
185: if tb_srcref is 0xffff: this indicates that the connect is still
186: in progress
187:
188: if tb_srcref is 0xfffe: this indicates the connect is done
189:
190: otherwise: this indicates a TS error
191: */
192:
193: if (connect (tb -> tb_fd, (struct sockaddr *) ifaddr, ifaddr -> siso_len)
194: == NOTOK) {
195: if (errno == EINPROGRESS) {
196: tb -> tb_srcref = 0xffff;
197: return CONNECTING_1;
198: }
199:
200: if (!(errno & TP_ERROR_MASK))
201: return tsaplose (td, DR_REFUSED, "connection",
202: "unable to establish");
203:
204: tb -> tb_srcref = (errno & ~TP_ERROR_MASK) & 0xff;
205: }
206: else
207: tb -> tb_srcref = 0xfffe;
208:
209: return DONE;
210: }
211:
212: /* */
213:
214: STATIC int TRetry (tb, async, tc, td)
215: register struct tsapblk *tb;
216: int async;
217: struct TSAPconnect *tc;
218: struct TSAPdisconnect *td;
219: {
220: int len,
221: onoff,
222: flags,
223: reason;
224: union sockaddr_osi sock;
225: struct sockaddr_iso *ifaddr = &sock.osi_sockaddr;
226: struct tp_conn_param tcp;
227: int cmsgtype = 0;
228: register struct tp_conn_param *p = &tcp;
229:
230: switch (tb -> tb_srcref) {
231: case 0xfffe:
232: reason = NOTOK;
233: break;
234:
235: default:
236: reason = tb -> tb_srcref;
237:
238: case 0xffff:
239: if (async)
240: switch ((*tb -> tb_retryfnx) (tb, td)) {
241: case NOTOK:
242: goto out;
243:
244: case OK:
245: return CONNECTING_1;
246:
247: case DONE:
248: break;
249: }
250:
251: (void) gen2tp4X (&tb -> tb_responding, &sock);
252: if (connect (tb -> tb_fd, (struct sockaddr *) ifaddr,
253: ifaddr -> siso_len) == NOTOK)
254: switch (errno) {
255: case EINPROGRESS:
256: return CONNECTING_1;
257:
258: case EISCONN:
259: reason = NOTOK;
260: break;
261:
262: default:
263: /* for the moment, u.u_error limited to one byte */
264: /* this will be fixed real soon now. */
265: /* if (!(errno & TP_ERROR_MASK)) */
266: if (errno > 0) {
267: (void) tsaplose (td, DR_REFUSED, "connection",
268: "unable to establish");
269: goto out;
270: }
271: reason = (errno & ~TP_ERROR_MASK) & 0xff;
272: break;
273: }
274: break;
275: }
276:
277:
278: if (async)
279: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 0, (char *) &onoff));
280:
281: if (reason == NOTOK) {
282: tc -> tc_sd = tb -> tb_fd;
283: tc -> tc_tsdusize = tb -> tb_tsdusize = MAXTP4;
284:
285: len = sizeof sock;
286: if (getsockname (tb -> tb_fd, (struct sockaddr *) ifaddr, &len)
287: != NOTOK) {
288: ifaddr -> siso_len = len;
289: (void) tp42genX (&tb -> tb_responding, &sock);
290: }
291: else
292: SLOG (tsap_log, LLOG_EXCEPTIONS, "failed", ("getpeername"));
293: copyTSAPaddrX (&tb -> tb_responding, &tc -> tc_responding);
294:
295: len = sizeof *p;
296: if (getsockopt (tb -> tb_fd, SOL_TRANSPORT, TPOPT_PARAMS, (char *) p,
297: &len)== NOTOK)
298: SLOG (tsap_log, LLOG_EXCEPTIONS, "TPOPT_PARAMS",
299: ("unable to get"));
300: else {
301: if (!p -> p_xpd_service)
302: tb -> tb_flags &= ~TB_EXPD;
303:
304: if (p -> p_tpdusize > 0) {
305: if (p -> p_tpdusize > 10)
306: p -> p_tpdusize = 10;
307: tb -> tb_tpduslop = TP4SLOP;
308: tb -> tb_tsdusize = (1 << p -> p_tpdusize) - tb -> tb_tpduslop;
309: }
310: }
311: tc -> tc_expedited = (tb -> tb_flags & TB_EXPD) ? 1 : 0;
312: tc -> tc_cc = sizeof tc -> tc_data;
313: if (tp4getCmsg(tb->tb_fd, &cmsgtype, &tc->tc_cc, tc->tc_data) < 0) {
314: tc -> tc_cc = 0;
315: } else if (cmsgtype != TPOPT_CFRM_DATA)
316: tc -> tc_cc = 0;
317:
318: tb -> tb_flags |= TB_CONN;
319: #ifdef MGMT
320: if (tb -> tb_manfnx)
321: (*tb -> tb_manfnx) (OPREQOUT, tb);
322: #endif
323: if (tb -> tb_calling)
324: free ((char *) tb -> tb_calling), tb -> tb_calling = NULL;
325: if (tb -> tb_called)
326: free ((char *) tb -> tb_called), tb -> tb_called = NULL;
327:
328: return DONE;
329: }
330:
331: td -> td_reason = reason;
332: td -> td_cc = sizeof td -> td_data;
333: if (tp4getCmsg(tb->tb_fd, &cmsgtype, &td->td_cc, td->td_data) < 0)
334: td -> td_cc = 0;
335: else if (cmsgtype != TPOPT_DISC_DATA)
336: td -> td_cc = 0;
337:
338: out: ;
339: freetblk (tb);
340:
341: return NOTOK;
342: }
343:
344: /* */
345:
346: STATIC int TStart (tb, cp, ts, td)
347: register struct tsapblk *tb;
348: char *cp;
349: struct TSAPstart *ts;
350: struct TSAPdisconnect *td;
351: {
352: int i,
353: len;
354: struct tp_conn_param tcp;
355: register struct tp_conn_param *p = &tcp;
356:
357: len = sizeof *p;
358: if (getsockopt (tb -> tb_fd, SOL_TRANSPORT, TPOPT_PARAMS, (char *) p, &len)
359: == NOTOK)
360: SLOG (tsap_log, LLOG_EXCEPTIONS, "TPOPT_PARAMS", ("unable to get"));
361: else {
362: if (p -> p_xpd_service)
363: tb -> tb_flags |= TB_EXPD;
364: if (p -> p_tpdusize > 0) {
365: if (p -> p_tpdusize > 10)
366: p -> p_tpdusize = 10;
367: tb -> tb_tpduslop = TP4SLOP;
368: tb -> tb_tsdusize = (1 << p -> p_tpdusize) - tb -> tb_tpduslop;
369: }
370: }
371:
372: ts -> ts_sd = tb -> tb_fd;
373: copyTSAPaddrX (&tb -> tb_initiating, &ts -> ts_calling);
374: copyTSAPaddrX (&tb -> tb_responding, &ts -> ts_called);
375: ts -> ts_expedited = (tb -> tb_flags & TB_EXPD) ? 1 : 0;
376: ts -> ts_tsdusize = tb -> tb_tsdusize;
377:
378: if ((i = strlen (cp)) > 0) {
379: if (i > 2 * TS_SIZE)
380: return tsaplose (td, DR_CONNECT, NULLCP,
381: "too much initial user data");
382:
383: ts -> ts_cc = implode ((u_char *) ts -> ts_data, cp, i);
384: }
385: else
386: ts -> ts_cc = 0;
387:
388: return OK;
389: }
390:
391: /* */
392:
393: /* ARGSUSED */
394:
395: STATIC int TAccept (tb, responding, data, cc, qos, td)
396: register struct tsapblk *tb;
397: char *data;
398: int responding,
399: cc;
400: struct QOStype *qos;
401: struct TSAPdisconnect *td;
402: {
403: int len;
404: struct tp_conn_param tcp;
405: register struct tp_conn_param *p = &tcp;
406:
407: len = sizeof *p;
408: if (getsockopt (tb -> tb_fd, SOL_TRANSPORT, TPOPT_PARAMS, (char *) p, &len)
409: == NOTOK)
410: SLOG (tsap_log, LLOG_EXCEPTIONS, "TPOPT_PARAMS", ("unable to get"));
411: else {
412: if (!p -> p_xpd_service)
413: tb -> tb_flags &= ~TB_EXPD;
414: else
415: if (!(tb -> tb_flags & TB_EXPD)) {
416: p -> p_xpd_service = 0;
417: if (setsockopt (tb -> tb_fd, SOL_TRANSPORT, TPOPT_PARAMS,
418: (char *) p, sizeof *p) == NOTOK)
419: SLOG (tsap_log, LLOG_EXCEPTIONS, "TPOPT_PARAMS",
420: ("unable to set"));
421: }
422:
423: if (p -> p_tpdusize > 0) {
424: if (p -> p_tpdusize > 10)
425: p -> p_tpdusize = 10;
426: tb -> tb_tpduslop = TP4SLOP;
427: tb -> tb_tsdusize = (1 << p -> p_tpdusize) - tb -> tb_tpduslop;
428: }
429: }
430:
431: if (sendCmsg (tb -> tb_fd, cc, TPOPT_CFRM_DATA, data) == NOTOK)
432: return tsaplose (td, DR_CONGEST, "TPOPT_CFRM_DATA", "unable to send");
433:
434: tb -> tb_flags |= TB_CONN;
435: #ifdef MGMT
436: if (tb -> tb_manfnx)
437: (*tb -> tb_manfnx) (OPREQIN, tb);
438: #endif
439:
440: return OK;
441: }
442:
443: /* */
444:
445: /* life would be nice if we didn't have to worry about the maximum number of
446: bytes that can be written in a single syscall() */
447:
448: #ifndef MSG_MAXIOVLEN
449: #define MSG_MAXIOVLEN NTPUV
450: #endif
451:
452:
453: STATIC int TWrite (tb, uv, expedited, td)
454: register struct tsapblk *tb;
455: register struct udvec *uv;
456: int expedited;
457: struct TSAPdisconnect *td;
458: {
459: register int cc;
460: int flags,
461: j,
462: len;
463: #ifdef MGMT
464: int dlen;
465: #endif
466: register char *bp,
467: *ep;
468: register struct qbuf *qb;
469: register struct msghdr *msg = &msgs;
470: struct iovec iovs[MSG_MAXIOVLEN];
471: register struct iovec *vv,
472: *wv;
473:
474: bzero ((char *) msg, sizeof *msg);
475:
476: flags = expedited ? MSG_OOB : 0;
477:
478: #ifdef MGMT
479: dlen = 0;
480: #endif
481:
482: if (!expedited && (tb -> tb_flags & TB_QWRITES)) {
483: int onoff,
484: nc;
485: struct udvec *xv;
486:
487: cc = 0;
488: for (xv = uv; xv -> uv_base; xv++)
489: cc += xv -> uv_len;
490: #ifdef MGMT
491: dlen = cc;
492: #endif
493:
494: if ((qb = (struct qbuf *) malloc (sizeof *qb + (unsigned) cc))
495: == NULL) {
496: (void) tsaplose (td, DR_CONGEST, NULLCP,
497: "unable to malloc %d octets for pseudo-writev, failing...",
498: cc);
499: freetblk (tb);
500:
501: return NOTOK;
502: }
503: qb -> qb_forw = qb -> qb_back = qb;
504: qb -> qb_data = qb -> qb_base, qb -> qb_len = cc;
505:
506: bp = qb -> qb_data;
507: for (xv = uv; xv -> uv_base; xv++) {
508: bcopy (xv -> uv_base, bp, xv -> uv_len);
509: bp += xv -> uv_len;
510: }
511:
512: if (tb -> tb_qwrites.qb_forw != &tb -> tb_qwrites) {
513: nc = 0;
514: goto insert;
515: }
516:
517: vv = iovs;
518: vv -> iov_base = qb -> qb_data, vv -> iov_len = qb -> qb_len;
519: vv++;
520:
521: msg -> msg_iov = iovs;
522: msg -> msg_iovlen = vv - iovs;
523:
524: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 1, (char *) &onoff));
525:
526: nc = sendmsg (tb -> tb_fd, msg, MSG_EOR);
527:
528: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 0, (char *) &onoff));
529:
530: if (nc != cc) {
531: if (nc == NOTOK) {
532: if (errno != EWOULDBLOCK) {
533: (void) tsaplose (td, DR_CONGEST, "failed", "sendmsg");
534: goto losing;
535: }
536:
537: nc = 0;
538: }
539: if ((*tb -> tb_queuePfnx) (tb, 1, td) == NOTOK)
540: goto losing;
541:
542: qb -> qb_data += nc, qb -> qb_len -= nc;
543: insert: ;
544: insque (qb, tb -> tb_qwrites.qb_back);
545: DLOG (tsap_log, LLOG_TRACE,
546: ("queueing blocked write of %d of %d octets", nc, cc));
547: }
548: else
549: free ((char *) qb);
550: goto done;
551:
552: losing: ;
553: free ((char *) qb);
554: freetblk (tb);
555:
556: return NOTOK;
557: }
558:
559: ep = (bp = uv -> uv_base) + (cc = uv -> uv_len);
560: while (uv -> uv_base) {
561: wv = (vv = iovs) + MSG_MAXIOVLEN;
562: for (len = tb -> tb_tsdusize; len > 0 && vv < wv; len -= j) {
563: j = min (cc, len);
564: #ifdef MGMT
565: dlen += j;
566: #endif
567: vv -> iov_base = bp, vv -> iov_len = j, vv++;
568: bp += j, cc -= j;
569:
570: if (bp >= ep) {
571: if ((bp = (++uv) -> uv_base) == NULL)
572: break;
573: ep = bp + (cc = uv -> uv_len);
574: }
575: }
576:
577: if (expedited || uv -> uv_base == NULL)
578: flags |= MSG_EOR;
579:
580: msg -> msg_iov = iovs;
581: msg -> msg_iovlen = vv - iovs;
582:
583: if (sendmsg (tb -> tb_fd, msg, flags) == NOTOK) {
584: (void) tsaplose (td, DR_CONGEST, "failed", "sendmsg");
585: freetblk (tb);
586:
587: return NOTOK;
588: }
589: }
590:
591: done: ;
592: #ifdef MGMT
593: if (tb -> tb_manfnx)
594: (*tb -> tb_manfnx) (USERDT, tb, dlen);
595: #endif
596:
597: return OK;
598: }
599:
600: /* */
601:
602: STATIC int TDrain (tb, td)
603: register struct tsapblk *tb;
604: struct TSAPdisconnect *td;
605: {
606: int nc,
607: onoff,
608: result;
609: register struct qbuf *qb;
610: register struct msghdr *msg = &msgs;
611: struct iovec vvs;
612: register struct iovec *vv = &vvs;
613:
614: bzero ((char *) msg, sizeof *msg);
615: msg -> msg_iov = vv, msg -> msg_iovlen = 1;
616:
617: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 1, (char *) &onoff));
618:
619: while ((qb = tb -> tb_qwrites.qb_forw) != &tb -> tb_qwrites) {
620: vv -> iov_base = qb -> qb_data, vv -> iov_len = qb -> qb_len;
621:
622: if (nc = sendmsg (tb -> tb_fd, msg, MSG_EOR) != qb -> qb_len) {
623: if (nc == NOTOK) {
624: if (errno != EWOULDBLOCK) {
625: result = tsaplose (td, DR_NETWORK, "failed",
626: "write to network");
627: goto out;
628: }
629:
630: nc = 0;
631: }
632:
633: qb -> qb_data += nc, qb -> qb_len -= nc;
634: DLOG (tsap_log, LLOG_TRACE,
635: ("wrote %d of %d octets from blocked write", nc,
636: qb -> qb_len));
637:
638: result = OK;
639: goto out;
640: }
641:
642: DLOG (tsap_log, LLOG_TRACE,
643: ("finished blocked write of %d octets", qb -> qb_len));
644: remque (qb);
645: free ((char *) qb);
646: }
647: result = DONE;
648:
649: out: ;
650: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 0, (char *) &onoff));
651:
652: return result;
653: }
654:
655: /* */
656:
657: /* ARGSUSED */
658:
659: STATIC int TRead (tb, tx, td, async, oob)
660: register struct tsapblk *tb;
661: register struct TSAPdata *tx;
662: struct TSAPdisconnect *td;
663: int async,
664: oob;
665: {
666: int cc;
667: register struct qbuf *qb;
668: register struct msghdr *msg = &msgs;
669: register union osi_control_msg *oc = &ocm;
670: struct iovec iovs[1];
671: static struct qbuf *spare_qb = 0;
672:
673: bzero ((char *) tx, sizeof *tx);
674: tx -> tx_qbuf.qb_forw = tx -> tx_qbuf.qb_back = &tx -> tx_qbuf;
675:
676: for (;;) {
677: qb = NULL;
678: if (spare_qb) {
679: if (spare_qb -> qb_len >= tb -> tb_tsdusize)
680: qb = spare_qb;
681: else
682: free ((char *)spare_qb);
683: spare_qb = NULL;
684: }
685: if (qb == NULL && (qb = (struct qbuf *) malloc ((unsigned) (sizeof *qb
686: + tb -> tb_tsdusize)))
687: == NULL) {
688: (void) tsaplose (td, DR_CONGEST, NULLCP, NULLCP);
689: break;
690: }
691: qb -> qb_data = qb -> qb_base;
692:
693: bzero ((char *) msg, sizeof *msg);
694: msg -> msg_iov = iovs;
695: msg -> msg_iovlen = 1;
696: msg -> msg_control = oc -> ocm_data;
697: msg -> msg_controllen = sizeof oc -> ocm_data;
698:
699: iovs[0].iov_base = qb -> qb_data;
700: iovs[0].iov_len = tb -> tb_tsdusize;
701:
702: bzero ((char *) oc, sizeof *oc);
703:
704: if ((cc = recvmsg(tb -> tb_fd, msg, 0)) == NOTOK) {
705: /*if ((cc = recvmsg(tb -> tb_fd, msg, oob ? MSG_OOB : 0)) == NOTOK) */
706: if (!(errno & TP_ERROR_MASK)) {
707: (void) tsaplose (td, DR_CONGEST, "failed", "recvfrom");
708: break;
709: }
710:
711: if ((td -> td_reason = errno & ~TP_ERROR_MASK) != DR_NORMAL)
712: SLOG (tsap_log, LLOG_EXCEPTIONS, NULLCP,
713: ("TP error %d", td -> td_reason));
714: td -> td_cc = 0;
715: break;
716: }
717:
718: if (msg -> msg_controllen) {
719: if (msg -> msg_controllen < sizeof oc -> ocm_control.ocm_cmhdr) {
720: (void) tsaplose (td, DR_CONGEST, NULLCP,
721: "truncated control message, got %d expecting at least %d",
722: msg -> msg_controllen,
723: sizeof oc -> ocm_control.ocm_cmhdr);
724: break;
725: }
726:
727: if (oc -> ocm_control.ocm_cmhdr.cmsg_level != SOL_TRANSPORT) {
728: (void) tsaplose (td, DR_CONGEST, NULLCP,
729: "unexpected message (level 0x%x, type 0x%x)",
730: oc -> ocm_control.ocm_cmhdr.cmsg_level,
731: oc -> ocm_control.ocm_cmhdr.cmsg_type);
732: break;
733: }
734: if (oc -> ocm_control.ocm_cmhdr.cmsg_type == TPOPT_DISC_DATA) {
735: td -> td_reason = DR_NORMAL;
736: if ((td -> td_cc = oc -> ocm_control.ocm_cmhdr.cmsg_len
737: - sizeof oc -> ocm_control.ocm_cmhdr) > 0)
738: bcopy (oc -> ocm_control.ocm_cmdata, td -> td_data, cc);
739: break;
740: }
741: }
742:
743: if (msg -> msg_flags & MSG_OOB) {
744: if (cc > 0) {
745: insque (qb, tx -> tx_qbuf.qb_back);
746: tx -> tx_cc = (qb -> qb_len = cc);
747: }
748: else
749: free ((char *) qb);
750: tx -> tx_expedited = 1;
751:
752: return OK;
753: }
754:
755: tb -> tb_len += (qb -> qb_len = cc);
756: if (cc > 0) {
757: register struct qbuf *qb2 = tb -> tb_qbuf.qb_back;
758:
759: if (qb2 != &tb->tb_qbuf && qb2->qb_len + cc <= tb->tb_tsdusize) {
760: bcopy(qb -> qb_data, qb2 -> qb_len + qb2 -> qb_data, cc);
761: qb2 -> qb_len += cc;
762: (spare_qb = qb) -> qb_len = tb -> tb_tsdusize;
763: } else
764: insque (qb, qb2);
765: } else
766: free ((char *) qb);
767:
768: #ifdef MGMT
769: if (tb -> tb_manfnx)
770: (*tb -> tb_manfnx) (USERDR, tb, tb -> tb_len);
771: #endif
772: if (!(msg -> msg_flags & MSG_EOR)) {
773: if (async) {
774: register struct qbuf *qb2 = tb -> tb_qbuf.qb_back;
775: if (qb2 != &tb->tb_qbuf && qb2->qb_len <= tb->tb_tsdusize)
776: printf("short return %d\n", qb2->qb_len);
777: return DONE;
778: }
779: continue;
780: }
781: tx -> tx_expedited = 0;
782: if (tb -> tb_qbuf.qb_forw != &tb -> tb_qbuf) {
783: tx -> tx_qbuf = tb -> tb_qbuf; /* struct copy */
784: tx -> tx_qbuf.qb_forw -> qb_back =
785: tx -> tx_qbuf.qb_back -> qb_forw = &tx -> tx_qbuf;
786: tx -> tx_cc = tb -> tb_len;
787: tb -> tb_qbuf.qb_forw =
788: tb -> tb_qbuf.qb_back = &tb -> tb_qbuf;
789: tb -> tb_len = 0;
790: }
791:
792: {
793: register struct qbuf *qb2 = tb -> tb_qbuf.qb_back;
794: if (qb2 != &tb->tb_qbuf && qb2->qb_len <= tb->tb_tsdusize)
795: printf("short return %d\n", qb2->qb_len);
796: }
797: return OK;
798: }
799: if (qb)
800: free ((char *) qb);
801:
802: freetblk (tb);
803:
804: return NOTOK;
805: }
806:
807: /* */
808:
809: STATIC int TDisconnect (tb, data, cc, td)
810: register struct tsapblk *tb;
811: char *data;
812: int cc;
813: struct TSAPdisconnect *td;
814: {
815: int result;
816:
817: if (sendCmsg(tb -> tb_fd, cc, TPOPT_DISC_DATA, data) == NOTOK)
818: result = tsaplose (td, DR_CONGEST, "TPOPT_DISC_DATA",
819: "unable to send");
820: else
821: result = OK;
822:
823: freetblk (tb);
824:
825: return result;
826: }
827: /* */
828:
829: /* ARGSUSED */
830:
831: STATIC int TLose (tb, reason, td)
832: register struct tsapblk *tb;
833: int reason;
834: struct TSAPdisconnect *td;
835: {
836: register struct msghdr *msg = &msgs;
837: register union osi_control_msg *oc = &ocm;
838:
839: SLOG (tsap_log, LLOG_EXCEPTIONS, NULLCP, ("TPM error %d", reason));
840:
841: bzero ((char *) msg, sizeof *msg);
842: msg -> msg_control = oc -> ocm_data;
843: msg -> msg_controllen = sizeof oc -> ocm_data;
844:
845: bzero ((char *) oc, sizeof *oc);
846: oc -> ocm_control.ocm_cmhdr.cmsg_level = SOL_TRANSPORT;
847: oc -> ocm_control.ocm_cmhdr.cmsg_type = TPOPT_DISC_DATA;
848: oc -> ocm_control.ocm_cmhdr.cmsg_len = sizeof oc -> ocm_control.ocm_cmhdr;
849:
850: if (sendmsg (tb -> tb_fd, msg, 0) == NOTOK)
851: SLOG (tsap_log, LLOG_EXCEPTIONS, "TPOPT_DISC_DATA",
852: ("unable to send"));
853: }
854:
855: /* LOWER HALF */
856:
857: /* ARGSUSED */
858:
859: int tp4open (tb, local_ta, local_na, remote_ta, remote_na, td, async)
860: register struct tsapblk *tb;
861: struct TSAPaddr *local_ta,
862: *remote_ta;
863: struct NSAPaddr *local_na,
864: *remote_na;
865: struct TSAPdisconnect *td;
866: int async;
867: {
868: int fd,
869: onoff;
870: struct TSAPaddr tzs;
871: register struct TSAPaddr *tz = &tzs;
872: register struct NSAPaddr *nz = tz -> ta_addrs;
873: union sockaddr_osi sock;
874: struct sockaddr_iso *ifaddr = &sock.osi_sockaddr;
875:
876: bzero ((char *) tz, sizeof *tz);
877: if (local_ta)
878: *tz = *local_ta; /* struct copy */
879: if (local_na) {
880: *nz = *local_na; /* struct copy */
881: tz -> ta_naddr = 1;
882: }
883:
884: (void) gen2tp4 (tz, &sock);
885:
886: if ((fd = socket (AF_ISO, SOCK_SEQPACKET, 0)) == NOTOK)
887: return tsaplose (td, DR_CONGEST, "socket", "unable to start");
888:
889: if (ifaddr->siso_nlen || ifaddr->siso_tlen)
890: if (bind (fd, (struct sockaddr *) ifaddr, ifaddr -> siso_len) == NOTOK) {
891: (void) tsaplose (td, DR_ADDRESS, "socket", "unable to bind");
892: (void) close (fd);
893: return NOTOK;
894: }
895:
896: tb -> tb_fd = fd;
897: (void) tp4init (tb);
898:
899: if (async)
900: (void) ioctl (fd, FIONBIO, (onoff = 1, (char *) &onoff));
901:
902: return (async ? OK : DONE);
903: }
904:
905: /* */
906:
907: /* ARGSUSED */
908:
909: STATIC int retry_tp4_socket (tb, td)
910: register struct tsapblk *tb;
911: struct TSAPdisconnect *td;
912: {
913: fd_set mask;
914:
915: FD_ZERO (&mask);
916: FD_SET (tb -> tb_fd, &mask);
917: if (xselect (tb -> tb_fd + 1, NULLFD, &mask, NULLFD, 0) < 1)
918: return OK;
919:
920: return DONE;
921: }
922:
923: /* */
924:
925: /* ARGSUSED */
926:
927: char *tp4save (fd, td)
928: int fd;
929: struct TSAPdisconnect *td;
930: {
931: static char buffer[BUFSIZ];
932:
933: (void) sprintf (buffer, "%c%d", NT_BSD, fd);
934: return buffer;
935: }
936:
937: /* */
938:
939: int tp4restore (tb, buffer, td)
940: register struct tsapblk *tb;
941: char *buffer;
942: struct TSAPdisconnect *td;
943: {
944: int fd, len, ucdlen;
945: union sockaddr_osi sock;
946: struct sockaddr_iso *ifaddr = &sock.osi_sockaddr;
947:
948: if (sscanf (buffer, "%d", &fd) != 1 || fd < 0)
949: return tsaplose (td, DR_PARAMETER, NULLCP,
950: "bad initialization vector \"%s\"", buffer);
951:
952: tb -> tb_fd = fd;
953: (void) tp4init (tb);
954: len = sizeof sock;
955: if (getsockname (fd, (struct sockaddr *) ifaddr, &len) == NOTOK) {
956: (void) tsaplose (td, DR_CONGEST, "listen",
957: "getsockname failed for tp4restore");
958: (void) close (fd);
959: return NOTOK;
960: }
961: ifaddr -> siso_len = len;
962: (void) tp42genX (&tb -> tb_responding, &sock);
963: len = sizeof sock;
964: if (getpeername (fd, (struct sockaddr *) ifaddr, &len) == NOTOK) {
965: (void) tsaplose (td, DR_CONGEST, "listen",
966: "getpeername failed for tp4restore");
967: (void) close (fd);
968: return NOTOK;
969: }
970: ifaddr -> siso_len = len;
971: (void) tp42genX (&tb -> tb_initiating, &sock);
972: return OK;
973: }
974:
975: /* */
976:
977: int tp4init (tb)
978: register struct tsapblk *tb;
979: {
980: tb -> tb_connPfnx = TConnect;
981: tb -> tb_retryPfnx = TRetry;
982:
983: tb -> tb_startPfnx = TStart;
984: tb -> tb_acceptPfnx = TAccept;
985:
986: tb -> tb_writePfnx = TWrite;
987: tb -> tb_readPfnx = TRead;
988: tb -> tb_discPfnx = TDisconnect;
989: tb -> tb_losePfnx = TLose;
990:
991: tb -> tb_drainPfnx = TDrain;
992:
993: #ifdef MGMT
994: tb -> tb_manfnx = TManGen;
995: #endif
996:
997: tb -> tb_flags |= TB_TP4;
998:
999: tb -> tb_tsdusize = MAXTP4 - (tb -> tb_tpduslop = 0);
1000:
1001: tb -> tb_retryfnx = retry_tp4_socket;
1002:
1003: tb -> tb_closefnx = close_tp4_socket;
1004: tb -> tb_selectfnx = select_tp4_socket;
1005: }
1006:
1007: /* */
1008:
1009: /* ARGSUSED */
1010:
1011: int start_tp4_server (local_ta, backlog, opt1, opt2, td)
1012: struct TSAPaddr *local_ta;
1013: int backlog,
1014: opt1,
1015: opt2;
1016: struct TSAPdisconnect *td;
1017: {
1018: int sd,
1019: onoff;
1020: register struct NSAPaddr *na = local_ta -> ta_addrs;
1021: union sockaddr_osi sock;
1022: struct sockaddr_iso *ifaddr = &sock.osi_sockaddr;
1023:
1024: (void) gen2tp4 (local_ta, &sock);
1025:
1026: if ((sd = socket (AF_ISO, SOCK_SEQPACKET, 0)) == NOTOK)
1027: return tsaplose (td, DR_CONGEST, "socket", "unable to start");
1028:
1029: if (bind (sd, (struct sockaddr *) ifaddr, ifaddr -> siso_len) == NOTOK) {
1030: (void) tsaplose (td, DR_ADDRESS, "socket", "unable to bind");
1031: (void) close (sd);
1032: return NOTOK;
1033: }
1034:
1035: if (na -> na_addrlen == 0) { /* unique listen */
1036: int len;
1037:
1038: len = sizeof sock;
1039: if (getsockname (sd, (struct sockaddr *) ifaddr, &len) == NOTOK) {
1040: (void) tsaplose (td, DR_CONGEST, "listen",
1041: "getsockname failed for unique");
1042: (void) close (sd);
1043: return NOTOK;
1044: }
1045: ifaddr -> siso_len = len;
1046:
1047: (void) tp42gen (local_ta, &sock);
1048: }
1049:
1050: if (opt1)
1051: (void) setsockopt (sd, SOL_SOCKET, opt1, NULLCP, 0);
1052: if (opt2)
1053: (void) setsockopt (sd, SOL_SOCKET, opt2, NULLCP, 0);
1054:
1055: onoff = 1;
1056:
1057: (void) listen (sd, backlog);
1058:
1059: return sd;
1060: }
1061:
1062: /* */
1063:
1064: int join_tp4_client (fd, remote_ta, td)
1065: int fd;
1066: struct TSAPaddr *remote_ta;
1067: struct TSAPdisconnect *td;
1068: {
1069: int len,
1070: sd;
1071: union sockaddr_osi sock;
1072: struct sockaddr_iso *ifaddr = &sock.osi_sockaddr;
1073:
1074: len = sizeof sock;
1075: if ((sd = accept (fd, (struct sockaddr *) ifaddr, &len)) == NOTOK)
1076: return tsaplose (td, DR_NETWORK, "socket", "unable to accept");
1077: ifaddr -> siso_len = len;
1078:
1079: (void) tp42gen (remote_ta, &sock);
1080:
1081: return sd;
1082: }
1083:
1084: /* */
1085:
1086: STATIC int gen2tp4 (generic, specific)
1087: struct TSAPaddr *generic;
1088: union sockaddr_osi *specific;
1089: {
1090: register char *cp;
1091: struct sockaddr_iso *ifaddr = &specific -> osi_sockaddr;
1092:
1093: bzero ((char *) specific, sizeof *specific);
1094:
1095: cp = ifaddr -> siso_data;
1096:
1097: if (generic -> ta_naddr > 0) {
1098: register struct NSAPaddr *na = generic -> ta_addrs;
1099:
1100: if (ifaddr -> siso_nlen = na -> na_addrlen) {
1101: bcopy (na -> na_address, cp, na -> na_addrlen);
1102: cp += na -> na_addrlen;
1103: }
1104: }
1105:
1106: if (ifaddr -> siso_tlen = generic -> ta_selectlen) {
1107: bcopy (generic -> ta_selector, cp, generic -> ta_selectlen);
1108: cp += generic -> ta_selectlen;
1109: }
1110:
1111: if ((ifaddr -> siso_len = cp - (char *) ifaddr) < sizeof *ifaddr)
1112: ifaddr -> siso_len = sizeof *ifaddr;
1113: ifaddr -> siso_family = AF_ISO;
1114:
1115: return OK;
1116: }
1117:
1118:
1119:
1120: STATIC int gen2tp4X (generic, specific)
1121: struct tsapADDR *generic;
1122: union sockaddr_osi *specific;
1123: {
1124: struct TSAPaddr tas;
1125:
1126: copyTSAPaddrX (generic, &tas);
1127: return gen2tp4 (&tas, specific);
1128: }
1129:
1130: /* */
1131:
1132: int tp42gen (generic, specific)
1133: struct TSAPaddr *generic;
1134: union sockaddr_osi *specific;
1135: {
1136: register char *cp;
1137: register struct NSAPaddr *na = generic -> ta_addrs;
1138: struct sockaddr_iso *ifaddr = &specific -> osi_sockaddr;
1139:
1140: bzero ((char *) generic, sizeof *generic);
1141:
1142: cp = ifaddr -> siso_data;
1143: if (na -> na_addrlen = ifaddr -> siso_nlen) {
1144: na -> na_stack = NA_NSAP;
1145: na -> na_community = ts_comm_nsap_default;
1146: bcopy (cp, na -> na_address, na -> na_addrlen);
1147: cp += na -> na_addrlen;
1148:
1149: generic -> ta_naddr++;
1150: }
1151:
1152: if (generic -> ta_selectlen = ifaddr -> siso_tlen)
1153: bcopy (cp, generic -> ta_selector, generic -> ta_selectlen);
1154:
1155: return OK;
1156: }
1157:
1158:
1159: int tp42genX (generic, specific)
1160: struct tsapADDR *generic;
1161: union sockaddr_osi *specific;
1162: {
1163: int result;
1164: struct TSAPaddr tas;
1165:
1166: if ((result = tp42gen (&tas, specific)) == OK)
1167: copyTSAPaddrY (&tas, generic);
1168:
1169: return result;
1170: }
1171: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.