![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_subr2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to tp_subr2.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 ! root 1: /*********************************************************** ! 2: Copyright IBM Corporation 1987 ! 3: ! 4: All Rights Reserved ! 5: ! 6: Permission to use, copy, modify, and distribute this software and its ! 7: documentation for any purpose and without fee is hereby granted, ! 8: provided that the above copyright notice appear in all copies and that ! 9: both that copyright notice and this permission notice appear in ! 10: supporting documentation, and that the name of IBM not be ! 11: used in advertising or publicity pertaining to distribution of the ! 12: software without specific, written prior permission. ! 13: ! 14: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 15: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 16: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 17: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 18: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 19: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 20: SOFTWARE. ! 21: ! 22: ******************************************************************/ ! 23: ! 24: /* ! 25: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 26: */ ! 27: /* ! 28: * ARGO TP ! 29: * ! 30: * $Header: tp_subr2.c,v 5.5 88/11/18 17:28:55 nhall Exp $ ! 31: * $Source: /usr/argo/sys/netiso/RCS/tp_subr2.c,v $ ! 32: * @(#)tp_subr2.c 7.4 (Berkeley) 9/22/89 ! 33: * ! 34: * Some auxiliary routines: ! 35: * tp_protocol_error: required by xebec- called when a combo of state, ! 36: * event, predicate isn't covered for by the transition file. ! 37: * tp_indicate: gives indications(signals) to the user process ! 38: * tp_getoptions: initializes variables that are affected by the options ! 39: * chosen. ! 40: */ ! 41: ! 42: #ifndef lint ! 43: static char *rcsid = "$Header: tp_subr2.c,v 5.5 88/11/18 17:28:55 nhall Exp $"; ! 44: #endif lint ! 45: ! 46: #include "argoxtwentyfive.h" ! 47: ! 48: /* this def'n is to cause the expansion of this macro in the ! 49: * routine tp_local_credit : ! 50: */ ! 51: #define LOCAL_CREDIT_EXPAND ! 52: ! 53: #include "param.h" ! 54: #include "mbuf.h" ! 55: #include "socket.h" ! 56: #include "socketvar.h" ! 57: #include "domain.h" ! 58: #include "protosw.h" ! 59: #include "errno.h" ! 60: #include "types.h" ! 61: #include "time.h" ! 62: #include "kernel.h" ! 63: #undef MNULL ! 64: #include "argo_debug.h" ! 65: #include "tp_param.h" ! 66: #include "tp_ip.h" ! 67: #include "iso.h" ! 68: #include "iso_errno.h" ! 69: #include "iso_pcb.h" ! 70: #include "tp_timer.h" ! 71: #include "tp_stat.h" ! 72: #include "tp_tpdu.h" ! 73: #include "tp_pcb.h" ! 74: #include "tp_seq.h" ! 75: #include "tp_trace.h" ! 76: #include "tp_user.h" ! 77: #include "cons.h" ! 78: ! 79: /* ! 80: * NAME: tp_local_credit() ! 81: * ! 82: * CALLED FROM: ! 83: * tp_emit(), tp_usrreq() ! 84: * ! 85: * FUNCTION and ARGUMENTS: ! 86: * Computes the local credit and stashes it in tpcb->tp_lcredit. ! 87: * It's a macro in the production system rather than a procdure. ! 88: * ! 89: * RETURNS: ! 90: * ! 91: * SIDE EFFECTS: ! 92: * ! 93: * NOTES: ! 94: * This doesn't actually get called in a production system - ! 95: * the macro gets expanded instead in place of calls to this proc. ! 96: * But for debugging, we call this and that allows us to add ! 97: * debugging messages easily here. ! 98: */ ! 99: void ! 100: tp_local_credit(tpcb) ! 101: struct tp_pcb *tpcb; ! 102: { ! 103: LOCAL_CREDIT(tpcb); ! 104: IFDEBUG(D_CREDIT) ! 105: printf("ref 0x%x lcdt 0x%x l_tpdusize 0x%x decbit 0x%x\n", ! 106: tpcb->tp_refp - tp_ref, ! 107: tpcb->tp_lcredit, ! 108: tpcb->tp_l_tpdusize, ! 109: tpcb->tp_decbit, ! 110: tpcb->tp_cong_win ! 111: ); ! 112: ENDDEBUG ! 113: IFTRACE(D_CREDIT) ! 114: tptraceTPCB(TPPTmisc, ! 115: "lcdt tpdusz \n", ! 116: tpcb->tp_lcredit, tpcb->tp_l_tpdusize, 0, 0); ! 117: ENDTRACE ! 118: } ! 119: ! 120: /* ! 121: * NAME: tp_protocol_error() ! 122: * ! 123: * CALLED FROM: ! 124: * tp_driver(), when it doesn't know what to do with ! 125: * a combo of event, state, predicate ! 126: * ! 127: * FUNCTION and ARGUMENTS: ! 128: * print error mesg ! 129: * ! 130: * RETURN VALUE: ! 131: * EIO - always ! 132: * ! 133: * SIDE EFFECTS: ! 134: * ! 135: * NOTES: ! 136: */ ! 137: int ! 138: tp_protocol_error(e,tpcb) ! 139: struct tp_event *e; ! 140: struct tp_pcb *tpcb; ! 141: { ! 142: printf("TP PROTOCOL ERROR! tpcb 0x%x event 0x%x, state 0x%x\n", ! 143: tpcb, e->ev_number, tpcb->tp_state); ! 144: IFTRACE(D_DRIVER) ! 145: tptraceTPCB(TPPTmisc, "PROTOCOL ERROR tpcb event state", ! 146: tpcb, e->ev_number, tpcb->tp_state, 0 ); ! 147: ENDTRACE ! 148: return EIO; /* for lack of anything better */ ! 149: } ! 150: ! 151: ! 152: /* Not used at the moment */ ! 153: ProtoHook ! 154: tp_drain() ! 155: { ! 156: return 0; ! 157: } ! 158: ! 159: ! 160: /* ! 161: * NAME: tp_indicate() ! 162: * ! 163: * CALLED FROM: ! 164: * tp.trans when XPD arrive, when a connection is being disconnected by ! 165: * the arrival of a DR or ER, and when a connection times out. ! 166: * ! 167: * FUNCTION and ARGUMENTS: ! 168: * (ind) is the type of indication : T_DISCONNECT, T_XPD ! 169: * (error) is an E* value that will be put in the socket structure ! 170: * to be passed along to the user later. ! 171: * Gives a SIGURG to the user process or group indicated by the socket ! 172: * attached to the tpcb. ! 173: * ! 174: * RETURNS: Rien ! 175: * ! 176: * SIDE EFFECTS: ! 177: * ! 178: * NOTES: ! 179: */ ! 180: void ! 181: tp_indicate(ind, tpcb, error) ! 182: int ind; ! 183: u_short error; ! 184: register struct tp_pcb *tpcb; ! 185: { ! 186: register struct socket *so = tpcb->tp_sock; ! 187: IFTRACE(D_INDICATION) ! 188: tptraceTPCB(TPPTindicate, ind, *(u_short *)(tpcb->tp_lsuffix), ! 189: *(u_short *)(tpcb->tp_fsuffix), error,so->so_pgid); ! 190: ENDTRACE ! 191: IFDEBUG(D_INDICATION) ! 192: char *ls, *fs; ! 193: ls = tpcb->tp_lsuffix, ! 194: fs = tpcb->tp_fsuffix, ! 195: ! 196: printf( ! 197: "indicate 0x%x lsuf 0x%02x%02x fsuf 0x%02x%02x err 0x%x noind 0x%x ref 0x%x\n", ! 198: ind, ! 199: *ls, *(ls+1), *fs, *(fs+1), ! 200: error, /*so->so_pgrp,*/ ! 201: tpcb->tp_no_disc_indications, ! 202: tpcb->tp_lref); ! 203: ENDDEBUG ! 204: ! 205: so->so_error = error; ! 206: ! 207: if (ind == T_DISCONNECT) { ! 208: if ( tpcb->tp_no_disc_indications ) ! 209: return; ! 210: } ! 211: IFTRACE(D_INDICATION) ! 212: tptraceTPCB(TPPTmisc, "doing sohasoutofband(so)", so,0,0,0); ! 213: ENDTRACE ! 214: sohasoutofband(so); ! 215: } ! 216: ! 217: /* ! 218: * NAME : tp_getoptions() ! 219: * ! 220: * CALLED FROM: ! 221: * tp.trans whenever we go into OPEN state ! 222: * ! 223: * FUNCTION and ARGUMENTS: ! 224: * sets the proper flags and values in the tpcb, to control ! 225: * the appropriate actions for the given class, options, ! 226: * sequence space, etc, etc. ! 227: * ! 228: * RETURNS: Nada ! 229: * ! 230: * SIDE EFFECTS: ! 231: * ! 232: * NOTES: ! 233: */ ! 234: void ! 235: tp_getoptions(tpcb) ! 236: struct tp_pcb *tpcb; ! 237: { ! 238: tpcb->tp_seqmask = ! 239: tpcb->tp_xtd_format ? TP_XTD_FMT_MASK : TP_NML_FMT_MASK ; ! 240: tpcb->tp_seqbit = ! 241: tpcb->tp_xtd_format ? TP_XTD_FMT_BIT : TP_NML_FMT_BIT ; ! 242: tpcb->tp_seqhalf = tpcb->tp_seqbit >> 1; ! 243: tpcb->tp_dt_ticks = ! 244: MAX(tpcb->tp_dt_ticks, (tpcb->tp_peer_acktime + 2)); ! 245: ! 246: } ! 247: ! 248: /* ! 249: * NAME: tp_recycle_tsuffix() ! 250: * ! 251: * CALLED FROM: ! 252: * Called when a ref is frozen. ! 253: * ! 254: * FUNCTION and ARGUMENTS: ! 255: * allows the suffix to be reused. ! 256: * ! 257: * RETURNS: zilch ! 258: * ! 259: * SIDE EFFECTS: ! 260: * ! 261: * NOTES: ! 262: */ ! 263: void ! 264: tp_recycle_tsuffix(tpcb) ! 265: struct tp_pcb *tpcb; ! 266: { ! 267: bzero((caddr_t)tpcb->tp_lsuffix, sizeof( tpcb->tp_lsuffix)); ! 268: bzero((caddr_t)tpcb->tp_fsuffix, sizeof( tpcb->tp_fsuffix)); ! 269: tpcb->tp_fsuffixlen = tpcb->tp_lsuffixlen = 0; ! 270: ! 271: (tpcb->tp_nlproto->nlp_recycle_suffix)(tpcb->tp_npcb); ! 272: } ! 273: ! 274: /* ! 275: * NAME: tp_quench() ! 276: * ! 277: * CALLED FROM: ! 278: * tp{af}_quench() when ICMP source quench or similar thing arrives. ! 279: * ! 280: * FUNCTION and ARGUMENTS: ! 281: * Drop the congestion window back to 1. ! 282: * Congestion window scheme: ! 283: * Initial value is 1. ("slow start" as Nagle, et. al. call it) ! 284: * For each good ack that arrives, the congestion window is increased ! 285: * by 1 (up to max size of logical infinity, which is to say, ! 286: * it doesn't wrap around). ! 287: * Source quench causes it to drop back to 1. ! 288: * tp_send() uses the smaller of (regular window, congestion window). ! 289: * One retransmission strategy option is to have any retransmission ! 290: * cause reset the congestion window back to 1. ! 291: * ! 292: * (cmd) is either PRC_QUENCH: source quench, or ! 293: * PRC_QUENCH2: dest. quench (dec bit) ! 294: * ! 295: * RETURNS: ! 296: * ! 297: * SIDE EFFECTS: ! 298: * ! 299: * NOTES: ! 300: */ ! 301: void ! 302: tp_quench( tpcb, cmd ) ! 303: struct tp_pcb *tpcb; ! 304: int cmd; ! 305: { ! 306: IFDEBUG(D_QUENCH) ! 307: printf("tp_quench tpcb 0x%x ref 0x%x sufx 0x%x\n", ! 308: tpcb, tpcb->tp_lref, *(u_short *)(tpcb->tp_lsuffix)); ! 309: printf("cong_win 0x%x decbit 0x%x \n", ! 310: tpcb->tp_cong_win, tpcb->tp_decbit); ! 311: ENDDEBUG ! 312: switch(cmd) { ! 313: case PRC_QUENCH: ! 314: tpcb->tp_cong_win = 1; ! 315: IncStat(ts_quench); ! 316: break; ! 317: case PRC_QUENCH2: ! 318: tpcb->tp_cong_win = 1; /* might as well quench source also */ ! 319: tpcb->tp_decbit = TP_DECBIT_CLEAR_COUNT; ! 320: IncStat(ts_rcvdecbit); ! 321: break; ! 322: } ! 323: } ! 324: ! 325: ! 326: /* ! 327: * NAME: tp_netcmd() ! 328: * ! 329: * CALLED FROM: ! 330: * ! 331: * FUNCTION and ARGUMENTS: ! 332: * ! 333: * RETURNS: ! 334: * ! 335: * SIDE EFFECTS: ! 336: * ! 337: * NOTES: ! 338: */ ! 339: tp_netcmd( tpcb, cmd ) ! 340: struct tp_pcb *tpcb; ! 341: int cmd; ! 342: { ! 343: #if NARGOXTWENTYFIVE > 0 ! 344: switch (cmd) { ! 345: ! 346: case CONN_CLOSE: ! 347: case CONN_REFUSE: ! 348: cons_netcmd( cmd, tpcb->tp_npcb, 0, tpcb->tp_class == TP_CLASS_4); ! 349: /* TODO: can this last param be replaced by ! 350: * tpcb->tp_netserv != ISO_CONS?) ! 351: */ ! 352: break; ! 353: ! 354: default: ! 355: printf("tp_netcmd(0x%x, 0x%x) NOT IMPLEMENTED\n", tpcb, cmd); ! 356: break; ! 357: } ! 358: #else NARGOXTWENTYFIVE ! 359: printf("tp_netcmd(): X25 NOT CONFIGURED!!\n"); ! 360: #endif NARGOXTWENTYFIVE > 0 ! 361: } ! 362: /* ! 363: * CALLED FROM: ! 364: * tp_ctloutput() and tp_emit() ! 365: * FUNCTION and ARGUMENTS: ! 366: * Convert a class mask to the highest numeric value it represents. ! 367: */ ! 368: ! 369: int ! 370: tp_mask_to_num(x) ! 371: u_char x; ! 372: { ! 373: register int j; ! 374: ! 375: for(j = 4; j>=0 ;j--) { ! 376: if(x & (1<<j)) ! 377: break; ! 378: } ! 379: ASSERT( (j == 4) || (j == 0) ); /* for now */ ! 380: if( (j != 4) && (j != 0) ) { ! 381: printf("ASSERTION ERROR: tp_mask_to_num: x 0x%x j %d\n", ! 382: x, j); ! 383: } ! 384: IFTRACE(D_TPINPUT) ! 385: tptrace(TPPTmisc, "tp_mask_to_num(x) returns j", x, j, 0, 0); ! 386: ENDTRACE ! 387: IFDEBUG(D_TPINPUT) ! 388: printf("tp_mask_to_num(0x%x) returns 0x%x\n", x, j); ! 389: ENDDEBUG ! 390: return j; ! 391: } ! 392: ! 393: static ! 394: copyQOSparms(src, dst) ! 395: struct tp_conn_param *src, *dst; ! 396: { ! 397: /* copy all but the bits stuff at the end */ ! 398: #define COPYSIZE (12 * sizeof(short)) ! 399: ! 400: bcopy((caddr_t)src, (caddr_t)dst, COPYSIZE); ! 401: dst->p_tpdusize = src->p_tpdusize; ! 402: dst->p_ack_strat = src->p_ack_strat; ! 403: dst->p_rx_strat = src->p_rx_strat; ! 404: #undef COPYSIZE ! 405: } ! 406: ! 407: /* ! 408: * CALLED FROM: ! 409: * tp_usrreq on PRU_CONNECT and tp_input on receipt of CR ! 410: * ! 411: * FUNCTION and ARGUMENTS: ! 412: * route directly to x.25 if the address is type 37 - GROT. ! 413: * furthermore, let TP0 handle only type-37 addresses ! 414: * ! 415: * Since this assumes that its address argument is in a mbuf, the ! 416: * parameter was changed to reflect this assumtion. This also ! 417: * implies that an mbuf must be allocated when this is ! 418: * called from tp_input ! 419: * ! 420: * RETURNS: ! 421: * errno value : ! 422: * EAFNOSUPPORT if can't find an nl_protosw for x.25 (really could panic) ! 423: * ECONNREFUSED if trying to run TP0 with non-type 37 address ! 424: * possibly other E* returned from cons_netcmd() ! 425: * NOTE: ! 426: * Would like to eliminate as much of this as possible -- ! 427: * only one set of defaults (let the user set the parms according ! 428: * to parameters provided in the directory service). ! 429: * Left here for now 'cause we don't yet have a clean way to handle ! 430: * it on the passive end. ! 431: */ ! 432: int ! 433: tp_route_to( m, tpcb, channel) ! 434: struct mbuf *m; ! 435: register struct tp_pcb *tpcb; ! 436: u_int channel; ! 437: { ! 438: register struct sockaddr_iso *siso; /* NOTE: this may be a sockaddr_in */ ! 439: extern struct tp_conn_param tp_conn_param[]; ! 440: int error = 0; ! 441: int vc_to_kill = 0; /* kludge */ ! 442: ! 443: siso = mtod(m, struct sockaddr_iso *); ! 444: IFTRACE(D_CONN) ! 445: tptraceTPCB(TPPTmisc, ! 446: "route_to: so afi netservice class", ! 447: tpcb->tp_sock, siso->siso_addr.isoa_genaddr[0], tpcb->tp_netservice, ! 448: tpcb->tp_class); ! 449: ENDTRACE ! 450: IFDEBUG(D_CONN) ! 451: printf("tp_route_to( m x%x, channel 0x%x, tpcb 0x%x netserv 0x%x)\n", ! 452: m, channel, tpcb, tpcb->tp_netservice); ! 453: printf("m->mlen x%x, m->m_data:\n", m->m_len); ! 454: dump_buf(mtod(m, caddr_t), m->m_len); ! 455: ENDDEBUG ! 456: if( siso->siso_family != tpcb->tp_domain ) { ! 457: error = EAFNOSUPPORT; ! 458: goto done; ! 459: } ! 460: IFDEBUG(D_CONN) ! 461: printf("tp_route_to calling nlp_pcbconn, netserv %d\n", ! 462: tpcb->tp_netservice); ! 463: ENDDEBUG ! 464: error = (tpcb->tp_nlproto->nlp_pcbconn)(tpcb->tp_sock->so_pcb, m); ! 465: if( error ) ! 466: goto done; ! 467: ! 468: { ! 469: register int save_netservice = tpcb->tp_netservice; ! 470: ! 471: switch(tpcb->tp_netservice) { ! 472: case ISO_COSNS: ! 473: case ISO_CLNS: ! 474: /* This is a kludge but seems necessary so the passive end ! 475: * can get long enough timers. sigh. ! 476: if( siso->siso_addr.osinet_idi[1] == (u_char)IDI_OSINET ) ! 477: */ ! 478: #define IDI_OSINET 0x0004 /* bcd of "0004" */ ! 479: if( siso->siso_addr.isoa_genaddr[2] == (char)IDI_OSINET ) { ! 480: if( tpcb->tp_dont_change_params == 0) { ! 481: copyQOSparms( &tp_conn_param[ISO_COSNS], ! 482: &tpcb->_tp_param); ! 483: } ! 484: tpcb->tp_flags |= TPF_NLQOS_PDN; ! 485: } ! 486: /* drop through to IN_CLNS*/ ! 487: case IN_CLNS: ! 488: if (iso_localifa(siso)) ! 489: tpcb->tp_flags |= TPF_PEER_ON_SAMENET; ! 490: if( (tpcb->tp_class & TP_CLASS_4)==0 ) { ! 491: error = EPROTOTYPE; ! 492: break; ! 493: } ! 494: tpcb->tp_class = TP_CLASS_4; /* IGNORE dont_change_parms */ ! 495: break; ! 496: ! 497: case ISO_CONS: ! 498: #if NARGOXTWENTYFIVE > 0 ! 499: tpcb->tp_flags |= TPF_NLQOS_PDN; ! 500: if( tpcb->tp_dont_change_params == 0 ) { ! 501: copyQOSparms( &tp_conn_param[ISO_CONS], ! 502: &tpcb->_tp_param); ! 503: } ! 504: /* ! 505: * for use over x.25 really need a small receive window, ! 506: * need to start slowly, need small max negotiable tpdu size, ! 507: * and need to use the congestion window to the max ! 508: * IGNORES tp_dont_change_params for these! ! 509: */ ! 510: if( tpcb->tp_sock->so_snd.sb_hiwat > 512 ) { ! 511: (void) soreserve(tpcb->tp_sock, 512, 512 );/* GAG */ ! 512: } ! 513: tpcb->tp_rx_strat = TPRX_USE_CW; ! 514: ! 515: if( (tpcb->tp_nlproto != &nl_protosw[ISO_CONS]) ) { ! 516: /* if the listener was restricting us to clns, ! 517: * ( we never get here if the listener isn't af_iso ) ! 518: * refuse the connection : ! 519: * but we don't have a way to restrict thus - it's ! 520: * utterly permissive. ! 521: if(channel) { ! 522: (void) cons_netcmd(CONN_REFUSE, tpcb->tp_npcb, ! 523: channel, tpcb->tp_class == TP_CLASS_4); ! 524: error = EPFNOSUPPORT; ! 525: goto done; ! 526: } ! 527: */ ! 528: IFDEBUG(D_CONN) ! 529: printf( ! 530: "tp_route_to( CHANGING nlproto old 0x%x new 0x%x)\n", ! 531: tpcb->tp_nlproto , &nl_protosw[ISO_CONS]); ! 532: ENDDEBUG ! 533: tpcb->tp_nlproto = &nl_protosw[ISO_CONS]; ! 534: } ! 535: /* Now we've got the right nl_protosw. ! 536: * If we already have a channel (we were called from tp_input()) ! 537: * tell cons that we'll hang onto this channel. ! 538: * If we don't already have one (we were called from usrreq()) ! 539: * -and if it's TP0 open a net connection and wait for it to finish. ! 540: */ ! 541: if( channel ) { ! 542: error = cons_netcmd( CONN_CONFIRM, tpcb->tp_npcb, ! 543: channel, tpcb->tp_class == TP_CLASS_4); ! 544: vc_to_kill ++; ! 545: } else if( tpcb->tp_class != TP_CLASS_4 /* class 4 only */) { ! 546: /* better open vc if any possibility of ending up ! 547: * in non-multiplexing class ! 548: */ ! 549: error = cons_openvc(tpcb->tp_npcb, siso, tpcb->tp_sock); ! 550: vc_to_kill ++; ! 551: } ! 552: /* class 4 doesn't need to open a vc now - may use one already ! 553: * opened or may open one only when it sends a pkt. ! 554: */ ! 555: #else NARGOXTWENTYFIVE > 0 ! 556: error = ECONNREFUSED; ! 557: #endif NARGOXTWENTYFIVE > 0 ! 558: break; ! 559: default: ! 560: error = EPROTOTYPE; ! 561: } ! 562: ! 563: ASSERT( save_netservice == tpcb->tp_netservice); ! 564: } ! 565: if( error && vc_to_kill ) { ! 566: tp_netcmd( tpcb, CONN_CLOSE); ! 567: goto done; ! 568: } ! 569: { /* start with the global rtt, rtv stats */ ! 570: register int i = ! 571: (int) tpcb->tp_flags & (TPF_PEER_ON_SAMENET | TPF_NLQOS_PDN); ! 572: ! 573: tpcb->tp_rtt = tp_stat.ts_rtt[i]; ! 574: tpcb->tp_rtv = tp_stat.ts_rtv[i]; ! 575: } ! 576: done: ! 577: IFDEBUG(D_CONN) ! 578: printf("tp_route_to returns 0x%x\n", error); ! 579: ENDDEBUG ! 580: IFTRACE(D_CONN) ! 581: tptraceTPCB(TPPTmisc, "route_to: returns: error netserv class", error, ! 582: tpcb->tp_netservice, tpcb->tp_class, 0); ! 583: ENDTRACE ! 584: return error; ! 585: } ! 586: ! 587: #ifdef TP_PERF_MEAS ! 588: /* ! 589: * CALLED FROM: ! 590: * tp_ctloutput() when the user sets TPOPT_PERF_MEAS on ! 591: * and tp_newsocket() when a new connection is made from ! 592: * a listening socket with tp_perf_on == true. ! 593: * FUNCTION and ARGUMENTS: ! 594: * (tpcb) is the usual; this procedure gets a clear cluster mbuf for ! 595: * a tp_pmeas structure, and makes tpcb->tp_p_meas point to it. ! 596: * RETURN VALUE: ! 597: * ENOBUFS if it cannot get a cluster mbuf. ! 598: */ ! 599: ! 600: int ! 601: tp_setup_perf(tpcb) ! 602: register struct tp_pcb *tpcb; ! 603: { ! 604: register struct mbuf *q; ! 605: ! 606: if( tpcb->tp_p_meas == 0 ) { ! 607: MGET(q, M_WAITOK, MT_PCB); ! 608: if (q == 0) ! 609: return ENOBUFS; ! 610: MCLGET(q, M_WAITOK); ! 611: if ((q->m_flags & M_EXT) == 0) { ! 612: (void) m_free(q); ! 613: return ENOBUFS; ! 614: } ! 615: q->m_len = sizeof (struct tp_pmeas); ! 616: tpcb->tp_p_mbuf = q; ! 617: tpcb->tp_p_meas = mtod(q, struct tp_pmeas *); ! 618: bzero( (caddr_t)tpcb->tp_p_meas, sizeof (struct tp_pmeas) ); ! 619: IFDEBUG(D_PERF_MEAS) ! 620: printf( ! 621: "tpcb 0x%x so 0x%x ref 0x%x tp_p_meas 0x%x tp_perf_on 0x%x\n", ! 622: tpcb, tpcb->tp_sock, tpcb->tp_lref, ! 623: tpcb->tp_p_meas, tpcb->tp_perf_on); ! 624: ENDDEBUG ! 625: tpcb->tp_perf_on = 1; ! 626: } ! 627: return 0; ! 628: } ! 629: #endif TP_PERF_MEAS ! 630: ! 631: #ifdef ARGO_DEBUG ! 632: dump_addr (addr) ! 633: register struct sockaddr *addr; ! 634: { ! 635: switch( addr->sa_family ) { ! 636: case AF_INET: ! 637: dump_inaddr((struct sockaddr_in *)addr); ! 638: break; ! 639: #ifdef ISO ! 640: case AF_ISO: ! 641: dump_isoaddr((struct sockaddr_iso *)addr); ! 642: break; ! 643: #endif ISO ! 644: default: ! 645: printf("BAD AF: 0x%x\n", addr->sa_family); ! 646: break; ! 647: } ! 648: } ! 649: ! 650: #define MAX_COLUMNS 8 ! 651: /* ! 652: * Dump the buffer to the screen in a readable format. Format is: ! 653: * ! 654: * hex/dec where hex is the hex format, dec is the decimal format. ! 655: * columns of hex/dec numbers will be printed, followed by the ! 656: * character representations (if printable). ! 657: */ ! 658: Dump_buf(buf, len) ! 659: caddr_t buf; ! 660: int len; ! 661: { ! 662: int i,j; ! 663: ! 664: printf("Dump buf 0x%x len 0x%x\n", buf, len); ! 665: for (i = 0; i < len; i += MAX_COLUMNS) { ! 666: printf("+%d:\t", i); ! 667: for (j = 0; j < MAX_COLUMNS; j++) { ! 668: if (i + j < len) { ! 669: printf("%x/%d\t", buf[i+j]&0xff, buf[i+j]); ! 670: } else { ! 671: printf(" "); ! 672: } ! 673: } ! 674: ! 675: for (j = 0; j < MAX_COLUMNS; j++) { ! 676: if (i + j < len) { ! 677: if (((buf[i+j]) > 31) && ((buf[i+j]) < 128)) ! 678: printf("%c", buf[i+j]&0xff); ! 679: else ! 680: printf("."); ! 681: } ! 682: } ! 683: printf("\n"); ! 684: } ! 685: } ! 686: ! 687: ! 688: #endif ARGO_DEBUG ! 689:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.