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