![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp0ts.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 tp0ts.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / tsap |
1.1 root 1: /* tp0ts.c - TPM: TP0 engine */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/tsap/RCS/tp0ts.c,v 7.6 90/07/27 08:48:10 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/tsap/RCS/tp0ts.c,v 7.6 90/07/27 08:48:10 mrose Exp $
9: *
10: *
11: * $Log: tp0ts.c,v $
12: * Revision 7.6 90/07/27 08:48:10 mrose
13: * update
14: *
15: * Revision 7.5 90/03/23 17:31:10 mrose
16: * 8
17: *
18: * Revision 7.4 89/12/19 10:18:22 mrose
19: * DLOG
20: *
21: * Revision 7.3 89/12/08 09:41:23 mrose
22: * touch-up
23: *
24: * Revision 7.2 89/12/07 22:15:39 mrose
25: * touch-up
26: *
27: * Revision 7.1 89/12/07 01:07:30 mrose
28: * queued writes
29: *
30: * Revision 7.0 89/11/23 22:30:33 mrose
31: * Release 6.0
32: *
33: */
34:
35: /*
36: * NOTICE
37: *
38: * Acquisition, use, and distribution of this module and related
39: * materials are subject to the restrictions of a license agreement.
40: * Consult the Preface in the User's Manual for the full terms of
41: * this agreement.
42: *
43: */
44:
45:
46: /* LINTLIBRARY */
47:
48: #include <stdio.h>
49: #include "tpkt.h"
50: #include "mpkt.h"
51: #include "tailor.h"
52:
53:
54: #if defined(TCP) || defined(X25)
55:
56: /* */
57:
58: static int TConnect (tb, expedited, data, cc, td)
59: register struct tsapblk *tb;
60: char *data;
61: int expedited,
62: cc;
63: struct TSAPdisconnect *td;
64: {
65: register struct tsapkt *t;
66:
67: if (!(tb -> tb_flags & TB_TCP)) {
68: expedited = 0;
69: if (cc > 0)
70: return tsaplose (td, DR_PARAMETER, NULLCP,
71: "initial user data not allowed with class 0");
72: }
73:
74: tb -> tb_srcref = htons ((u_short) (getpid () & 0xffff));
75: tb -> tb_dstref = htons ((u_short) 0);
76:
77: if ((t = newtpkt (TPDU_CR)) == NULL)
78: return tsaplose (td, DR_CONGEST, NULLCP, "out of memory");
79:
80: t -> t_cr.cr_dstref = tb -> tb_dstref;
81: t -> t_cr.cr_srcref = tb -> tb_srcref;
82: t -> t_cr.cr_class = CR_CLASS_TP0;
83: if (!(tb -> tb_flags & TB_TCP)) {
84: register int i,
85: j;
86: int k;
87:
88: i = k = tb -> tb_tsdusize + tb -> tb_tpduslop;
89: for (j = 0; i > 0; j++)
90: i >>= 1;
91: if (k == (1 << (j - 1)))
92: j--;
93: if (j > SIZE_MAXTP0) {
94: j = SIZE_MAXTP0;
95: tb -> tb_tsdusize = (1 << j) - tb -> tb_tpduslop;
96: }
97: if (j != SIZE_DFLT)
98: t -> t_tpdusize = j;
99: }
100: bcopy (tb -> tb_initiating.ta_selector, t -> t_calling,
101: t -> t_callinglen = tb -> tb_initiating.ta_selectlen);
102:
103: bcopy (tb -> tb_responding.ta_selector, t -> t_called,
104: t -> t_calledlen = tb -> tb_responding.ta_selectlen);
105: if (expedited) {
106: tb -> tb_flags |= TB_EXPD;
107: t -> t_options |= OPT_TEXPEDITE;
108: }
109:
110: copyTPKTdata (t, data, cc); /* XXX: user musn't touch! */
111:
112: tb -> tb_retry = t;
113:
114: return OK;
115: }
116:
117: /* */
118:
119: static int TRetry (tb, async, tc, td)
120: register struct tsapblk *tb;
121: int async;
122: struct TSAPconnect *tc;
123: struct TSAPdisconnect *td;
124: {
125: int len;
126: register struct tsapkt *t;
127:
128: if (t = tb -> tb_retry) {
129: tb -> tb_retry = NULL;
130:
131: if (async)
132: switch ((*tb -> tb_retryfnx) (tb, td)) {
133: case NOTOK:
134: goto out;
135:
136: case OK:
137: tb -> tb_retry = t;
138: return CONNECTING_1;
139:
140: case DONE:
141: break;
142: }
143:
144: if (tpkt2fd (tb, t, tb -> tb_writefnx) == NOTOK) {
145: (void) tsaplose (td, t -> t_errno, NULLCP, NULLCP);
146: goto out;
147: }
148:
149: freetpkt (t), t = NULL;
150: }
151:
152: if (async) {
153: fd_set mask;
154:
155: FD_ZERO (&mask);
156: FD_SET (tb -> tb_fd, &mask);
157:
158: if (xselect (tb -> tb_fd + 1, &mask, NULLFD, NULLFD, 0) == OK)
159: return CONNECTING_2;
160: }
161:
162: if ((t = fd2tpkt (tb -> tb_fd, tb -> tb_initfnx, tb -> tb_readfnx)) == NULL
163: || t -> t_errno != OK) {
164: (void) tsaplose (td, t ? t -> t_errno : DR_CONGEST, NULLCP, NULLCP);
165: goto out;
166: }
167:
168: switch (TPDU_CODE (t)) {
169: case TPDU_CC:
170: tc -> tc_sd = tb -> tb_fd;
171: if (CR_CLASS (t) != CR_CLASS_TP0) {
172: (void) tpktlose (tb, td, DR_PROTOCOL, NULLCP,
173: "proposed class 0, got back 0x%x", CR_CLASS (t));
174: goto out;
175: }
176: if (tb -> tb_srcref != t -> t_cc.cc_dstref) {
177: (void) tpktlose (tb, td, DR_MISMATCH, NULLCP,
178: "sent srcref of 0x%x, got 0x%x",
179: ntohs (tb -> tb_srcref), ntohs (t -> t_cc.cc_dstref));
180: goto out;
181: }
182: tb -> tb_dstref = t -> t_cc.cc_srcref;
183: if (!(tb -> tb_flags & TB_TCP)) {
184: if (t -> t_tpdusize == 0)
185: t -> t_tpdusize = SIZE_DFLT;
186: else
187: if (t -> t_tpdusize > SIZE_MAXTP0)
188: t -> t_tpdusize = SIZE_MAXTP0;
189: tb -> tb_tpdusize = 1 << t -> t_tpdusize;
190: tb -> tb_tsdusize = tb -> tb_tpdusize - tb -> tb_tpduslop;
191: }
192: if ((len = t -> t_calledlen) > 0) {
193: if (len > sizeof tb -> tb_responding.ta_selector)
194: len = sizeof tb -> tb_responding.ta_selector;
195: bcopy (t -> t_called, tb -> tb_responding.ta_selector,
196: tb -> tb_responding.ta_selectlen = len);
197: }
198: copyTSAPaddrX (&tb -> tb_responding, &tc -> tc_responding);
199: if (!(t -> t_options & OPT_TEXPEDITE)
200: || !(tb -> tb_flags & TB_TCP))
201: tb -> tb_flags &= ~TB_EXPD;
202: tc -> tc_expedited = (tb -> tb_flags & TB_EXPD) ? 1 : 0;
203: tc -> tc_tsdusize = tb -> tb_tsdusize;
204: tc -> tc_qos = tb -> tb_qos; /* struct copy */
205: if (t -> t_qbuf) {
206: copyTSAPdata (t -> t_qbuf -> qb_data, t -> t_qbuf -> qb_len,
207: tc);
208: }
209: else
210: tc -> tc_cc = 0;
211:
212: freetpkt (t);
213: tb -> tb_flags |= TB_CONN;
214: #ifdef MGMT
215: if (tb -> tb_manfnx)
216: (*tb -> tb_manfnx) (OPREQOUT, tb);
217: #endif
218: if (tb -> tb_calling)
219: free ((char *) tb -> tb_calling), tb -> tb_calling = NULL;
220: if (tb -> tb_called)
221: free ((char *) tb -> tb_called), tb -> tb_called = NULL;
222:
223: return DONE;
224:
225: case TPDU_DR:
226: td -> td_reason = t -> t_dr.dr_reason;
227: if (t -> t_qbuf) {
228: copyTSAPdata (t -> t_qbuf -> qb_data, t -> t_qbuf -> qb_len,
229: td);
230: }
231: else
232: td -> td_cc = 0;
233: goto out;
234:
235: case TPDU_ER:
236: switch (t -> t_er.er_reject) {
237: case ER_REJ_NOTSPECIFIED:
238: default:
239: td -> td_reason = DR_CONNECT;
240: break;
241:
242: case ER_REJ_CODE:
243: case ER_REJ_TPDU:
244: case ER_REJ_VALUE:
245: td -> td_reason = DR_PROTOCOL;
246: break;
247: }
248: td -> td_cc = 0;
249: goto out;
250:
251: default:
252: (void) tpktlose (tb, td, DR_PROTOCOL, NULLCP,
253: "transport protocol mangled: expecting 0x%x, got 0x%x",
254: TPDU_CC, TPDU_CODE (t));
255: goto out;
256: }
257:
258: out: ;
259: freetpkt (t);
260: /* freetblk (tb); */
261:
262: return NOTOK;
263: }
264:
265: /* */
266:
267: static int TStart (tb, cp, ts, td)
268: register struct tsapblk *tb;
269: char *cp;
270: struct TSAPstart *ts;
271: struct TSAPdisconnect *td;
272: {
273: int len,
274: result;
275: register struct tsapkt *t;
276:
277: if ((t = str2tpkt (cp)) == NULL || t -> t_errno != OK) {
278: result = tsaplose (td, DR_PARAMETER, NULLCP,
279: "bad initialization vector");
280: goto out;
281: }
282:
283: if (CR_CLASS (t) != CR_CLASS_TP0) {
284: if (t -> t_cr.cr_alternate & (ALT_TP0 | ALT_TP1))
285: t -> t_cr.cr_class = CR_CLASS_TP0;
286: else {
287: result = tpktlose (tb, td, DR_CONNECT, NULLCP,
288: "only class 0 supported, not 0x%x", CR_CLASS (t));
289: goto out;
290: }
291: }
292:
293: tb -> tb_srcref = htons ((u_short) (getpid () & 0xffff));
294: tb -> tb_dstref = t -> t_cr.cr_srcref;
295: if (!(tb -> tb_flags & TB_TCP)) {
296: if (t -> t_tpdusize == 0)
297: t -> t_tpdusize = SIZE_DFLT;
298: else
299: if (t -> t_tpdusize > SIZE_MAXTP0)
300: t -> t_tpdusize = SIZE_MAXTP0;
301: tb -> tb_tpdusize = 1 << t -> t_tpdusize;
302: tb -> tb_tsdusize = tb -> tb_tpdusize - tb -> tb_tpduslop;
303: }
304: if ((len = t -> t_callinglen) > 0) {
305: if (len > sizeof tb -> tb_initiating.ta_selector)
306: len = sizeof tb -> tb_initiating.ta_selector;
307: bcopy (t -> t_calling, tb -> tb_initiating.ta_selector,
308: tb -> tb_initiating.ta_selectlen = len);
309: }
310: if ((len = t -> t_calledlen) > 0) {
311: if (len > sizeof tb -> tb_responding.ta_selector)
312: len = sizeof tb -> tb_responding.ta_selector;
313: bcopy (t -> t_called, tb -> tb_responding.ta_selector,
314: tb -> tb_responding.ta_selectlen = len);
315: }
316: if ((t -> t_options & OPT_TEXPEDITE) && (tb -> tb_flags & TB_TCP))
317: tb -> tb_flags |= TB_EXPD;
318:
319: ts -> ts_sd = tb -> tb_fd;
320: copyTSAPaddrX (&tb -> tb_initiating, &ts -> ts_calling);
321: copyTSAPaddrX (&tb -> tb_responding, &ts -> ts_called);
322: ts -> ts_expedited = (tb -> tb_flags & TB_EXPD) ? 1 : 0;
323: ts -> ts_tsdusize = tb -> tb_tsdusize;
324: ts -> ts_qos = tb -> tb_qos; /* struct copy */
325:
326: if (t -> t_qbuf) {
327: copyTSAPdata (t -> t_qbuf -> qb_data, t -> t_qbuf -> qb_len, ts);
328: }
329: else
330: ts -> ts_cc = 0;
331:
332: result = OK;
333:
334: out: ;
335: freetpkt (t);
336:
337: return result;
338: }
339:
340: /* */
341:
342: /* ARGSUSED */
343:
344: static int TAccept (tb, responding, data, cc, qos, td)
345: register struct tsapblk *tb;
346: char *data;
347: int responding,
348: cc;
349: struct QOStype *qos;
350: struct TSAPdisconnect *td;
351: {
352: int result;
353: register struct tsapkt *t;
354:
355: if (!(tb -> tb_flags & TB_TCP) && cc > 0)
356: return tsaplose (td, DR_PARAMETER, NULLCP,
357: "initial user data not allowed with class 0");
358:
359: if ((t = newtpkt (TPDU_CC)) == NULL)
360: return tsaplose (td, DR_CONGEST, NULLCP, "out of memory");
361:
362: t -> t_cc.cc_dstref = tb -> tb_dstref;
363: t -> t_cc.cc_srcref = tb -> tb_srcref;
364: t -> t_cc.cc_class = CR_CLASS_TP0;
365: if (!(tb -> tb_flags & TB_TCP)) {
366: register int i,
367: j;
368: int k;
369:
370: i = k = tb -> tb_tsdusize + tb -> tb_tpduslop;
371: for (j = 0; i > 0; j++)
372: i >>= 1;
373: if (k == (1 << (j - 1)))
374: j--;
375: if (j > SIZE_MAXTP0) {
376: j = SIZE_MAXTP0;
377: tb -> tb_tsdusize = (1 << j) - tb -> tb_tpduslop;
378: }
379: if (j != SIZE_DFLT)
380: t -> t_tpdusize = j;
381: }
382: if (responding)
383: bcopy (tb -> tb_responding.ta_selector, t -> t_called,
384: t -> t_calledlen = tb -> tb_responding.ta_selectlen);
385: if (tb -> tb_flags & TB_EXPD)
386: t -> t_options |= OPT_TEXPEDITE;
387: copyTPKTdata (t, data, cc);
388:
389: if ((result = tpkt2fd (tb, t, tb -> tb_writefnx)) == NOTOK)
390: (void) tsaplose (td, t -> t_errno, NULLCP, NULLCP);
391: else {
392: tb -> tb_flags |= TB_CONN;
393: #ifdef MGMT
394: if (tb -> tb_manfnx)
395: (*tb -> tb_manfnx) (OPREQIN, tb);
396: #endif
397: }
398:
399: freetpkt (t);
400:
401: return result;
402: }
403:
404: /* */
405:
406: static int TWrite (tb, uv, expedited, td)
407: register struct tsapblk *tb;
408: register struct udvec *uv;
409: int expedited;
410: struct TSAPdisconnect *td;
411: {
412: int cc,
413: j,
414: len,
415: result;
416: #if defined(X25) || defined(MGMT)
417: int dlen;
418: #endif
419: register char *bp,
420: *ep;
421: register struct tsapkt *t;
422: register struct udvec *vv,
423: *wv;
424:
425: #if defined(X25) || defined(MGMT)
426: dlen = 0;
427: #endif
428:
429: ep = (bp = uv -> uv_base) + (cc = uv -> uv_len);
430: while (uv -> uv_base) {
431: if ((t = newtpkt (expedited ? TPDU_ED : TPDU_DT)) == NULL)
432: return tsaplose (td, DR_CONGEST, NULLCP, "out of memory");
433:
434: wv = (vv = t -> t_udvec) + NTPUV - 1;
435: len = tb -> tb_tpdusize ? (tb -> tb_tpdusize - tb -> tb_tpduslop)
436: : tb -> tb_tsdusize;
437: for (; len > 0 && vv < wv; len -= j) {
438: j = min (cc, len);
439: #if defined(X25) || defined(MGMT)
440: dlen += j;
441: #endif
442: vv -> uv_base = bp, vv -> uv_len = j, vv++;
443: bp += j, cc -= j;
444:
445: if (bp >= ep) {
446: if ((bp = (++uv) -> uv_base) == NULL)
447: break;
448: ep = bp + (cc = uv -> uv_len);
449: }
450: }
451:
452: if (uv -> uv_base == NULL)
453: t -> t_dt.dt_nr |= DT_EOT;
454:
455: if ((result = tpkt2fd (tb, t, tb -> tb_writefnx)) == NOTOK) {
456: (void) tsaplose (td, t -> t_errno, NULLCP, NULLCP);
457: #ifdef X25
458: if (tb -> tb_flags & TB_X25)
459: LLOG (x25_log, LLOG_NOTICE,
460: ("connection %d broken, %d/%d octets sent/recv",
461: tb -> tb_fd, tb -> tb_sent, tb -> tb_recv));
462: #endif
463: freetblk (tb);
464: }
465:
466: freetpkt (t);
467: if (result == NOTOK)
468: return NOTOK;
469: }
470:
471: #ifdef X25
472: tb -> tb_sent += dlen;
473: #endif
474: #ifdef MGMT
475: if (tb -> tb_manfnx)
476: (*tb -> tb_manfnx) (USERDT, tb, dlen);
477: #endif
478:
479: return OK;
480: }
481:
482: /* */
483:
484: /* ARGSUSED */
485:
486: static int TRead (tb, tx, td, async, oob)
487: register struct tsapblk *tb;
488: register struct TSAPdata *tx;
489: struct TSAPdisconnect *td;
490: int async,
491: oob;
492: {
493: int eot;
494: register struct tsapkt *t;
495:
496: bzero ((char *) tx, sizeof *tx);
497: tx -> tx_qbuf.qb_forw = tx -> tx_qbuf.qb_back = &tx -> tx_qbuf;
498:
499: for (;;) {
500: if ((t = fd2tpkt (tb -> tb_fd, tb -> tb_initfnx, tb -> tb_readfnx))
501: == NULL
502: || t -> t_errno != OK) {
503: (void) tsaplose (td, t ? t -> t_errno : DR_CONGEST, NULLCP,
504: NULLCP);
505: #ifdef X25
506: if (tb -> tb_flags & TB_X25)
507: LLOG (x25_log, LLOG_NOTICE,
508: ("connection %d broken, %d/%d octets sent/recv",
509: tb -> tb_fd, tb -> tb_sent, tb -> tb_recv));
510: #endif
511: break;
512: }
513:
514: switch (TPDU_CODE (t)) {
515: case TPDU_DT:
516: eot = t -> t_dt.dt_nr & DT_EOT;
517: if (t -> t_qbuf) {
518: insque (t -> t_qbuf, tb -> tb_qbuf.qb_back);
519: tb -> tb_len += t -> t_qbuf -> qb_len;
520: #ifdef X25
521: tb -> tb_recv += t -> t_qbuf -> qb_len;
522: #endif
523: t -> t_qbuf = NULL;
524: }
525: freetpkt (t);
526: #ifdef MGMT
527: if (tb -> tb_manfnx)
528: (*tb -> tb_manfnx) (USERDR, tb, tb -> tb_len);
529: #endif
530: if (!eot) {
531: if (async)
532: return DONE;
533:
534: continue;
535: }
536: tx -> tx_expedited = 0;
537: if (tb -> tb_qbuf.qb_forw != &tb -> tb_qbuf) {
538: tx -> tx_qbuf = tb -> tb_qbuf;/* struct copy */
539: tx -> tx_qbuf.qb_forw -> qb_back =
540: tx -> tx_qbuf.qb_back -> qb_forw = &tx -> tx_qbuf;
541: tx -> tx_cc = tb -> tb_len;
542: tb -> tb_qbuf.qb_forw =
543: tb -> tb_qbuf.qb_back = &tb -> tb_qbuf;
544: tb -> tb_len = 0;
545: }
546: return OK;
547:
548: case TPDU_ED:
549: if (t -> t_qbuf) {
550: insque (t -> t_qbuf, tx -> tx_qbuf.qb_back);
551: tx -> tx_cc = t -> t_qbuf -> qb_len;
552: t -> t_qbuf = NULL;
553: }
554: freetpkt (t);
555: tx -> tx_expedited = 1;
556: return OK;
557:
558: case TPDU_DR:
559: td -> td_reason = t -> t_dr.dr_reason;
560: if (t -> t_qbuf) {
561: copyTSAPdata (t -> t_qbuf -> qb_data,
562: t -> t_qbuf -> qb_len, td);
563: }
564: else
565: td -> td_cc = 0;
566: break;
567:
568: case TPDU_ER:
569: switch (t -> t_er.er_reject) {
570: case ER_REJ_NOTSPECIFIED:
571: default:
572: td -> td_reason = DR_UNKNOWN;
573: break;
574:
575: case ER_REJ_CODE:
576: case ER_REJ_TPDU:
577: case ER_REJ_VALUE:
578: td -> td_reason = DR_PROTOCOL;
579: break;
580: }
581: td -> td_cc = 0;
582: break;
583:
584: default:
585: (void) tpktlose (tb, td, DR_PROTOCOL, NULLCP,
586: "transport protocol mangled: not expecting 0x%x",
587: TPDU_CODE (t));
588: break;
589: }
590: break;
591: }
592:
593: freetpkt (t);
594: freetblk (tb);
595:
596: return NOTOK;
597: }
598:
599: /* */
600:
601: static int TDisconnect (tb, data, cc, td)
602: register struct tsapblk *tb;
603: char *data;
604: int cc;
605: struct TSAPdisconnect *td;
606: {
607: int result;
608: #ifdef TCP
609: register struct tsapkt *t;
610: #endif
611:
612: result = OK;
613: #ifdef TCP
614: if (tb -> tb_flags & TB_TCP) {
615: if (t = newtpkt (TPDU_DR)) {
616: t -> t_dr.dr_srcref = tb -> tb_srcref;
617: t -> t_dr.dr_dstref = tb -> tb_dstref;
618: t -> t_dr.dr_reason = DR_NORMAL;
619: copyTPKTdata (t, data, cc);
620:
621: if ((result = tpkt2fd (tb, t, tb -> tb_writefnx)) == NOTOK)
622: (void) tsaplose (td, t -> t_errno, NULLCP, NULLCP);
623:
624: freetpkt (t);
625: }
626: else
627: result = tsaplose (td, DR_CONGEST, NULLCP, "out of memory");
628: }
629: #endif
630: #ifdef X25
631: if (tb -> tb_flags & TB_X25)
632: LLOG (x25_log, LLOG_NOTICE,
633: ("connection %d closed, %d/%d octets sent/recv",
634: tb -> tb_fd, tb -> tb_sent, tb -> tb_recv));
635: #endif
636: freetblk (tb);
637:
638: return result;
639: }
640:
641: /* */
642:
643: static TLose (tb, reason, td)
644: register struct tsapblk *tb;
645: int reason;
646: struct TSAPdisconnect *td;
647: {
648: struct tsapkt *t;
649:
650: switch (reason) {
651: case DR_UNKNOWN:
652: case DR_CONGEST:
653: case DR_SESSION:
654: case DR_ADDRESS:
655: if ((t = newtpkt (TPDU_DR)) == NULLPKT)
656: break;
657:
658: t -> t_dr.dr_srcref = tb -> tb_srcref;
659: t -> t_dr.dr_dstref = tb -> tb_dstref;
660: t -> t_dr.dr_reason = reason;
661: copyTPKTdata (t, td -> td_data, td -> td_cc);
662: break;
663:
664: default:
665: if ((t = newtpkt (TPDU_ER)) == NULLPKT)
666: break;
667:
668: t -> t_er.er_dstref = tb -> tb_dstref;
669: switch (reason) {
670: case DR_PROTOCOL:
671: t -> t_er.er_reject = ER_REJ_TPDU;
672: break;
673:
674: default:
675: t -> t_er.er_reject = ER_REJ_NOTSPECIFIED;
676: break;
677: }
678: break;
679: }
680: if (t) {
681: (void) tpkt2fd (tb, t, tb -> tb_writefnx);
682: freetpkt (t);
683: }
684: }
685:
686: /* */
687:
688: /* at present, used by TCP, X.25 and BRG back-ends... */
689:
690: #ifndef TCP
691: #undef WRITEV
692: #endif
693:
694: #include <errno.h>
695: #include <sys/ioctl.h>
696: #ifdef WRITEV
697: #include <sys/uio.h>
698: #endif
699: #ifdef TCP
700: #include "internet.h"
701: #else
702: #define write_tcp_socket NULLIFP
703: #endif
704: #ifdef X25
705: #include "x25.h"
706: #else
707: #define write_x25_socket NULLIFP
708: #endif
709:
710:
711: extern int errno;
712:
713: /* */
714:
715: int tp0write (tb, t, cp, n)
716: register struct tsapblk *tb;
717: register struct tsapkt *t;
718: char *cp;
719: int n;
720: {
721: register int cc;
722: register char *p,
723: *q;
724: register struct qbuf *qb;
725: register struct udvec *uv;
726: #if defined(WRITEV) || defined(SUN_X25) || defined(CAMTEC_CCL)
727: struct iovec iovs[NTPUV + 4];
728: register struct iovec *iov;
729: #endif
730:
731: #if defined(WRITEV) || defined(SUN_X25) || defined(CAMTEC_CCL)
732: #ifdef FIONBIO
733: if (tb -> tb_flags & TB_QWRITES)
734: goto single;
735: #endif
736: iov = iovs;
737: cc = 0;
738:
739: if (tb -> tb_flags & TB_X25) {
740: iov -> iov_base = (char *) &t -> t_li;
741: cc += (iov -> iov_len = sizeof t -> t_li);
742: iov++;
743:
744: iov -> iov_base = (char *) &t -> t_code;
745: cc += (iov -> iov_len = sizeof t -> t_code);
746: iov++;
747:
748: }
749: else {
750: iov -> iov_base = (char *) &t -> t_pkthdr;
751: cc += (iov -> iov_len = TPKT_HDRLEN (t));
752: iov++;
753: }
754:
755: iov -> iov_base = cp;
756: cc += (iov -> iov_len = n);
757: iov++;
758:
759: if (t -> t_vdata) {
760: iov -> iov_base = t -> t_vdata;
761: cc += (iov -> iov_len = t -> t_vlen);
762: iov++;
763: }
764:
765: for (uv = t -> t_udvec; uv -> uv_base; uv++) {
766: iov -> iov_base = uv -> uv_base;
767: cc += (iov -> iov_len = uv -> uv_len);
768: iov++;
769: }
770:
771: if ((n = writev (tb -> tb_fd, iovs, iov - iovs)) != cc) {
772: cc = NOTOK;
773: #ifdef SUN_X25
774: if (tb -> tb_flags & TB_X25
775: && compat_log -> ll_events & LLOG_EXCEPTIONS)
776: (void) log_cause_and_diag (tb -> tb_fd);
777: #endif
778: }
779: else
780: if (tb -> tb_flags & TB_X25) {
781: DLOG (compat_log, LLOG_DEBUG, ("X.25 write %d bytes", cc));
782: }
783: goto out;
784:
785: single: ;
786: #endif
787:
788: cc = ((tb -> tb_flags & TB_X25) ? sizeof t -> t_li + sizeof t -> t_code
789: : TPKT_HDRLEN (t))
790: + n;
791: if (t -> t_vdata)
792: cc += t -> t_vlen;
793: for (uv = t -> t_udvec; uv -> uv_base; uv++)
794: cc += uv -> uv_len;
795:
796: if (p = malloc (sizeof *qb + (unsigned) cc)) {
797: int nc,
798: onoff;
799: IFP wfnx = (tb -> tb_flags & TB_X25) ? write_x25_socket
800: : write_tcp_socket;
801:
802: #ifdef FIONBIO
803: if (tb -> tb_flags & TB_QWRITES) {
804: qb = (struct qbuf *) p;
805: qb -> qb_forw = qb -> qb_back = qb;
806: qb -> qb_data = qb -> qb_base, qb -> qb_len = cc;
807: p = qb -> qb_data;
808: }
809: #endif
810:
811: if (tb -> tb_flags & TB_X25) {
812: bcopy ((char *) &t -> t_li, q = p, sizeof t -> t_li);
813: q += sizeof t -> t_li;
814:
815: bcopy ((char *) &t -> t_code, q, sizeof t -> t_code);
816: q += sizeof t -> t_code;
817: }
818: else {
819: bcopy ((char *) &t -> t_pkthdr, q = p, TPKT_HDRLEN (t));
820: q += TPKT_HDRLEN (t);
821: }
822:
823: bcopy (cp, q, n);
824: q += n;
825:
826: if (t -> t_vdata) {
827: bcopy (t -> t_vdata, q, t -> t_vlen);
828: q += t -> t_vlen;
829: }
830:
831: for (uv = t -> t_udvec; uv -> uv_base; uv++) {
832: bcopy (uv -> uv_base, q, uv -> uv_len);
833: q += uv -> uv_len;
834: }
835:
836: #ifdef FIONBIO
837: if (tb -> tb_qwrites.qb_forw != &tb -> tb_qwrites) {
838: nc = 0;
839: goto insert;
840: }
841:
842: if (tb -> tb_flags & TB_QWRITES)
843: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 1, (char *) &onoff));
844: #endif
845:
846: nc = (*wfnx) (tb -> tb_fd, p, cc);
847:
848: #ifdef FIONBIO
849: if (tb -> tb_flags & TB_QWRITES)
850: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 0, (char *) &onoff));
851: #endif
852:
853: if (nc != cc) {
854: #ifdef FIONBIO
855: if (tb -> tb_flags & TB_QWRITES) {
856: if (nc == NOTOK) {
857: if (errno != EWOULDBLOCK)
858: goto losing;
859: nc = 0;
860: }
861: else
862: if (nc > 0 && (tb -> tb_flags & TB_X25)) {
863: SLOG (tsap_log, LLOG_EXCEPTIONS, NULLCP,
864: ("partial write (%d of %d octets) to X.25",
865: nc, cc));
866: goto losing;
867: }
868:
869: if ((*tb -> tb_queuePfnx) (tb, 1, (struct TSAPdisconnect *) 0)
870: == NOTOK)
871: goto losing;
872:
873: qb -> qb_data += nc, qb -> qb_len -= nc;
874: insert: ;
875: insque (qb, tb -> tb_qwrites.qb_back);
876: DLOG (tsap_log, LLOG_TRACE,
877: ("queueing blocked write of %d of %d octets", nc, cc));
878: qb = NULL;
879: }
880: else
881: #endif
882: {
883: losing: ;
884: cc = NOTOK;
885: }
886: }
887:
888: #ifdef FIONBIO
889: if (tb -> tb_flags & TB_QWRITES) {
890: if (qb)
891: free ((char *) qb);
892: }
893: else
894: #endif
895: free (p);
896: goto out;
897: }
898: if ((tb -> tb_flags & TB_X25) || tb -> tb_flags & TB_QWRITES) {
899: SLOG (tsap_log, LLOG_EXCEPTIONS, NULLCP,
900: ("unable to malloc %d octets for pseudo-writev, failing...",
901: cc));
902:
903: cc = NOTOK;
904: goto out;
905: }
906:
907: #ifdef TCP
908: SLOG (tsap_log, LLOG_EXCEPTIONS, NULLCP,
909: ("unable to malloc %d octets for pseudo-writev, continuing...",
910: cc));
911:
912: cc = TPKT_HDRLEN (t);
913: if (write_tcp_socket (tb -> tb_fd, (char *) &t -> t_pkthdr, cc) != cc) {
914: err: ;
915: cc = NOTOK;
916: goto out;
917: }
918:
919: if (write_tcp_socket (tb -> tb_fd, cp, n) != n)
920: goto err;
921: cc += n;
922:
923: if (t -> t_vdata
924: && write_tcp_socket (tb -> tb_fd, t -> t_vdata, t -> t_vlen)
925: != t -> t_vlen)
926: goto err;
927: cc += t -> t_vlen;
928:
929: for (uv = t -> t_udvec; uv -> uv_base; uv++) {
930: if (write_tcp_socket (tb -> tb_fd, uv -> uv_base, uv -> uv_len)
931: != uv -> uv_len)
932: goto err;
933: cc += uv -> uv_len;
934: }
935: #endif
936:
937: out: ;
938:
939: return cc;
940: }
941:
942: /* */
943:
944: #ifdef FIONBIO
945: static int TDrain (tb, td)
946: register struct tsapblk *tb;
947: struct TSAPdisconnect *td;
948: {
949: int nc,
950: onoff,
951: result;
952: register struct qbuf *qb;
953: IFP wfnx = (tb -> tb_flags & TB_X25) ? write_x25_socket
954: : write_tcp_socket;
955:
956: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 1, (char *) &onoff));
957:
958: while ((qb = tb -> tb_qwrites.qb_forw) != &tb -> tb_qwrites) {
959: if ((nc = (*wfnx) (tb -> tb_fd, qb -> qb_data, qb -> qb_len))
960: != qb -> qb_len) {
961: if (nc == NOTOK) {
962: if (errno != EWOULDBLOCK) {
963: result = tsaplose (td, DR_NETWORK, "failed",
964: "write to network");
965: goto out;
966: }
967:
968: nc = 0;
969: }
970: else
971: if (nc > 0 && (tb -> tb_flags & TB_X25)) {
972: SLOG (tsap_log, LLOG_EXCEPTIONS, NULLCP,
973: ("partial write (%d of %d octets) to X.25",
974: nc, qb -> qb_len));
975: result = tsaplose (td, DR_NETWORK, NULLCP,
976: "partial write (%d of %d octets) to X.25",
977: nc, qb -> qb_len);
978: goto out;
979: }
980:
981: DLOG (tsap_log, LLOG_TRACE,
982: ("wrote %d of %d octets from blocked write", nc,
983: qb -> qb_len));
984: qb -> qb_data += nc, qb -> qb_len -= nc;
985:
986: result = OK;
987: goto out;
988: }
989:
990: DLOG (tsap_log, LLOG_TRACE,
991: ("finished blocked write of %d octets", qb -> qb_len));
992: remque (qb);
993: free ((char *) qb);
994: }
995: result = DONE;
996:
997: out: ;
998: (void) ioctl (tb -> tb_fd, FIONBIO, (onoff = 0, (char *) &onoff));
999:
1000: return result;
1001: }
1002: #endif
1003:
1004: /* */
1005:
1006: int tp0init (tb)
1007: register struct tsapblk *tb;
1008: {
1009: tb -> tb_connPfnx = TConnect;
1010: tb -> tb_retryPfnx = TRetry;
1011:
1012: tb -> tb_startPfnx = TStart;
1013: tb -> tb_acceptPfnx = TAccept;
1014:
1015: tb -> tb_writePfnx = TWrite;
1016: tb -> tb_readPfnx = TRead;
1017: tb -> tb_discPfnx = TDisconnect;
1018: tb -> tb_losePfnx = TLose;
1019:
1020: #ifdef FIONBIO
1021: tb -> tb_drainPfnx = TDrain;
1022: #endif
1023:
1024: #ifdef MGMT
1025: tb -> tb_manfnx = TManGen;
1026: #endif
1027: }
1028: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.