![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp_device.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / inet|
Return to tcp_device.c CVS log | Up to [Research Unix] / researchv10no / sys / inet |
1.1 ! root 1: /* ! 2: * tcp_device.c ! 3: */ ! 4: ! 5: #include "sys/param.h" ! 6: #include "sys/stream.h" ! 7: #include "sys/inio.h" ! 8: #include "sys/ttyio.h" ! 9: #include "sys/conf.h" ! 10: #include "sys/user.h" ! 11: #include "sys/inet/in.h" ! 12: #include "sys/inet/ip_var.h" ! 13: #include "sys/inet/tcp.h" ! 14: #include "sys/inet/tcp_timer.h" ! 15: #include "sys/inet/tcp_seq.h" ! 16: #include "sys/inet/tcp_var.h" ! 17: #include "sys/inet/tcpip.h" ! 18: #include "sys/inet/tcp_user.h" ! 19: #include "sys/inet/tcp_fsm.h" ! 20: ! 21: extern int tcp_busy; /* set to discourage timers & ensuing panics */ ! 22: extern int tcp_maxseg; ! 23: ! 24: long tcpdopen(); ! 25: int tcpdclose(), tcpdput(); ! 26: int tcpdosrv(), tcpdisrv(); ! 27: static struct qinit tcpdrinit = { noput, tcpdisrv, tcpdopen, tcpdclose, 2048, 64 }; ! 28: struct qinit tcpdwinit = { tcpdput, tcpdosrv, tcpdopen, tcpdclose, 2048, 64}; ! 29: struct streamtab tcpdinfo = { &tcpdrinit, &tcpdwinit }; ! 30: ! 31: struct cdevsw tcpcdev = cstrinit(&tcpdinfo); ! 32: ! 33: extern int tcpcnt; ! 34: extern struct tcpcb tcpcb[]; ! 35: ! 36: long ! 37: tcpdopen(q, dev) ! 38: register struct queue *q; ! 39: dev_t dev; ! 40: { ! 41: struct tcpcb *tp; ! 42: ! 43: dev = minor(dev); ! 44: if(dev >= tcpcnt) ! 45: return(0); ! 46: tp = &tcpcb[dev]; ! 47: if(dev&01){ ! 48: /* outgoing channel */ ! 49: /* ! 50: * disallow if active ! 51: */ ! 52: if(tp->t_state != TCPS_CLOSED) ! 53: return(0); ! 54: /* ! 55: * only one opener at a time for outgoing channels ! 56: */ ! 57: if(q->ptr) ! 58: return(0); ! 59: } else { ! 60: /* incoming channel */ ! 61: /* ! 62: * disallow if inactive ! 63: */ ! 64: if(tp->t_state == TCPS_CLOSED) { ! 65: printf("tcp%d closed\n", dev); ! 66: return(0); ! 67: } ! 68: /* ! 69: * disallow if it's not open or waiting to be opened ! 70: */ ! 71: if((tp->so_state&(SS_OPEN|SS_PLEASEOPEN))==0) { ! 72: printf("tcp%d state %x\n", dev, tp->so_state); ! 73: return(0); ! 74: } ! 75: /* ! 76: * if already open, just accept ! 77: */ ! 78: if(q->ptr) ! 79: return(1); ! 80: } ! 81: tcp_busy++; ! 82: if((tp->so_state & SS_PLEASEOPEN) == 0){ ! 83: tp->so_rcount = tp->so_wcount = tp->so_options = 0; ! 84: tp->so_laddr = tp->so_faddr = (in_addr)0; ! 85: tp->so_lport = tp->so_fport = (tcp_port)0; ! 86: tp->so_oobmark = tp->so_delimcnt = 0; ! 87: tp->so_head = (struct tcpcb *)0; ! 88: tp->so_state = SS_WAITING; ! 89: tp->t_maxseg = TCP_DEFMAXSEG; /* until changed by other end */ ! 90: } ! 91: tp->so_state |= SS_OPEN; ! 92: tp->so_dev = dev; ! 93: tp->so_rq = q; ! 94: tp->so_wq = WR(q); ! 95: q->ptr = (caddr_t)tp; ! 96: WR(q)->flag |= QBIGB; ! 97: WR(q)->ptr = (caddr_t)tp; ! 98: --tcp_busy; ! 99: if(tp->so_state & SS_PLEASEOPEN){ ! 100: tp->so_state &= ~SS_PLEASEOPEN; ! 101: qenable(WR(q)); /* to force out rcv wnd update */ ! 102: } ! 103: return(1); ! 104: } ! 105: ! 106: tcpdclose(q) ! 107: register struct queue *q; ! 108: { ! 109: struct tcpcb *tp; ! 110: ! 111: tp = (struct tcpcb *)q->ptr; ! 112: tcp_busy++; ! 113: if(tp == 0){ ! 114: --tcp_busy; ! 115: return; ! 116: } ! 117: tp->so_state &= ~(SS_OPEN|SS_WAITING); ! 118: tp->so_rq = tp->so_wq = (struct queue *) 0; ! 119: tp->so_wcount = tp->so_rcount = 0; ! 120: if(tp->t_state > TCPS_LISTEN) ! 121: tcp_disconnect(tp); ! 122: else ! 123: tcp_close(tp); ! 124: --tcp_busy; ! 125: } ! 126: ! 127: tcpdput(q, bp) ! 128: register struct queue *q; ! 129: register struct block *bp; ! 130: { ! 131: int s, x; ! 132: struct tcpcb *tp; ! 133: struct block *nbp; ! 134: struct foo { ! 135: int com; ! 136: struct tcpuser rep; ! 137: }; ! 138: struct foo *fp; ! 139: ! 140: tp = (struct tcpcb *)q->ptr; ! 141: switch(bp->type){ ! 142: case M_IOCTL: ! 143: bp->type = M_IOCACK; ! 144: switch(stiocom(bp)){ ! 145: case TIOCSETP: ! 146: case TIOCSETN: ! 147: x = ((struct ttydevb *)stiodata(bp))->ispeed; ! 148: bp->wptr = bp->rptr; ! 149: bp->type = M_IOCACK; ! 150: qreply(q, bp); ! 151: if(x == 0) ! 152: qpctl(OTHERQ(q), M_HANGUP); ! 153: return; ! 154: case TIOCGETP: ! 155: ((struct ttydevb *)stiodata(bp))->ispeed = ! 156: ((struct ttydevb *)stiodata(bp))->ospeed = B9600; ! 157: break; ! 158: case TCPGETADDR: ! 159: nbp = allocb(sizeof(struct foo)); ! 160: if (nbp == NULL) { ! 161: bp->type = M_IOCNAK; ! 162: break; ! 163: } ! 164: nbp->type = M_IOCACK; ! 165: fp = (struct foo *)nbp->rptr; ! 166: fp->com = stiocom(bp); ! 167: fp->rep.lport = tp->so_lport; ! 168: fp->rep.fport = tp->so_fport; ! 169: fp->rep.laddr = tp->so_laddr; ! 170: fp->rep.faddr = tp->so_faddr; ! 171: nbp->wptr = nbp->rptr + sizeof(struct foo); ! 172: freeb(bp); ! 173: bp = nbp; ! 174: break; ! 175: case TCPIOHUP: ! 176: tp->so_state |= SS_HANGUP; ! 177: bp->wptr = bp->rptr; ! 178: bp->type = M_IOCACK; ! 179: qreply(q, bp); ! 180: return; ! 181: default: ! 182: bp->type = M_IOCNAK; ! 183: } ! 184: qreply(q, bp); ! 185: return; ! 186: case M_DATA: ! 187: if(socantsendmore(tp)){ ! 188: freeb(bp); ! 189: return; ! 190: } ! 191: s = spl6(); ! 192: if (bp->wptr!=bp->rptr) ! 193: tp->so_delimcnt = 0; ! 194: if (bp->class&S_DELIM) ! 195: tp->so_delimcnt++; /* 2 delims are logical EOF */ ! 196: if (bp->wptr==bp->rptr){ ! 197: freeb(bp); ! 198: } else { ! 199: tp->so_wcount += BLEN(bp); /* BEFORE the putq */ ! 200: putq(q, bp); ! 201: } ! 202: splx(s); ! 203: if(tp->so_delimcnt ! 204: || (tp->so_options&(SO_ACCEPTCONN|SS_WAITING)) == 0) ! 205: qenable(q); ! 206: break; ! 207: default: ! 208: freeb(bp); ! 209: break; ! 210: } ! 211: } ! 212: ! 213: tcpdosrv(q) ! 214: struct queue *q; ! 215: { ! 216: register struct tcpcb *tp; ! 217: ! 218: if((tp = (struct tcpcb *)q->ptr) == 0) ! 219: return; ! 220: if (tp->so_state&SS_WCLOSED) ! 221: return; ! 222: tcp_busy++; ! 223: if(tp->so_delimcnt > 1){ ! 224: tp->so_state |= SS_WCLOSED; ! 225: tp = tcp_usrclosed(tp); ! 226: if(tp) ! 227: tcp_output(tp); ! 228: } else if ((tp->so_options & SO_ACCEPTCONN) == 0 ! 229: && (tp->so_state & SS_WAITING) == 0) ! 230: tcp_output(tp); ! 231: else ! 232: tcpduser(tp); ! 233: --tcp_busy; ! 234: } ! 235: ! 236: tcpdrint(bp, tp) ! 237: register struct block *bp; ! 238: register struct tcpcb *tp; ! 239: { ! 240: register struct block *bp1; ! 241: ! 242: if (tp->so_rq == NULL) { ! 243: printf("tcpdrint but no tp->so_rq\n"); ! 244: bp_free(bp); ! 245: return -1; ! 246: } ! 247: while(bp){ ! 248: bp1 = bp->next; ! 249: tp->so_rcount += bp->wptr - bp->rptr; ! 250: if(bp->wptr <= bp->rptr) ! 251: freeb(bp); ! 252: else ! 253: putq(tp->so_rq, bp); ! 254: bp = bp1; ! 255: } ! 256: return 0; ! 257: } ! 258: ! 259: tcpdisrv(q) ! 260: register struct queue *q; ! 261: { ! 262: register struct tcpcb *tp = (struct tcpcb *)(q->ptr); ! 263: register struct block *bp; ! 264: ! 265: while ((q->next->flag&QFULL) == 0 && (bp = getq(q)) != NULL) { ! 266: if(bp->type == M_DATA) ! 267: tp->so_rcount -= bp->wptr - bp->rptr; ! 268: if(tp->so_rcount < 0){ ! 269: printf("so_rcount %d\n", tp->so_rcount); ! 270: if(tp->so_state & SS_OPEN) ! 271: panic("so_rcount"); ! 272: } ! 273: (*q->next->qinfo->putp)(q->next, bp); ! 274: } ! 275: if(q->count <= q->qinfo->lolimit) ! 276: qenable(OTHERQ(q)); /* update remote send window */ ! 277: } ! 278: ! 279: /* ! 280: * here if channel isn't connected yet: ! 281: * output `data' is a user command ! 282: * grab all the data written so far, ! 283: * even though we'll discard the part we don't use ! 284: */ ! 285: tcpduser(tp) ! 286: register struct tcpcb *tp; ! 287: { ! 288: extern struct ipif *ip_ifwithaddr(); ! 289: struct tcpuser *tu; ! 290: struct block *bp, *tail, *head; ! 291: ! 292: tail = head = NULL; ! 293: while(bp = getq(tp->so_wq)){ ! 294: if(bp->type != M_DATA){ ! 295: freeb(bp); ! 296: continue; ! 297: } ! 298: bp->next = NULL; ! 299: if (head == NULL) ! 300: head = bp; ! 301: else ! 302: tail->next = bp; ! 303: tail = bp; ! 304: } ! 305: if(head == NULL) ! 306: return; ! 307: tp->so_wcount = 0; ! 308: bp = head; ! 309: if(BLEN(bp) < sizeof(struct tcpuser)){ ! 310: bp_free(bp); ! 311: return; ! 312: } ! 313: ! 314: /* ! 315: * tu->code is a request to bind this channel ! 316: */ ! 317: tu = (struct tcpuser *)bp->rptr; ! 318: switch(tu->code){ ! 319: case TCPC_CONNECT: ! 320: if(tp->t_state != TCPS_CLOSED){ ! 321: tu->code = TCPC_BADDEV; ! 322: goto bad; ! 323: } ! 324: if (tu->laddr != INADDR_ANY) { ! 325: /* has the user specified a legal local address? */ ! 326: if (ip_ifwithaddr(tu->laddr) == 0) { ! 327: tu->code = TCPC_BADLOCAL; ! 328: goto bad; ! 329: } ! 330: } else { ! 331: /* pick a local address related to the destination */ ! 332: tu->laddr = ip_hoston(tu->faddr); ! 333: if(tu->laddr == INADDR_ANY) { ! 334: tu->code = TCPC_NOROUTE; ! 335: goto bad; ! 336: } ! 337: } ! 338: tp->so_options = tu->param & ~SO_ACCEPTCONN; ! 339: if(tcpcb_bind(tp, tu->laddr, tu->lport)) { ! 340: tu->code = TCPC_BOUND; ! 341: goto bad; ! 342: } ! 343: tp->so_fport = tu->fport; ! 344: tp->so_faddr = tu->faddr; ! 345: tcp_template(tp); ! 346: if(tp->t_template == (struct block *)0) { ! 347: printf("no template - "); ! 348: tu->code = TCPC_BADDEV; ! 349: goto bad; ! 350: } ! 351: if (tp->so_options & SO_KEEPALIVE) ! 352: tcp_timers(tp, TCPT_KEEP); ! 353: tp->t_state = TCPS_SYN_SENT; ! 354: tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2; ! 355: tcp_sendseqinit(tp); ! 356: tp->so_state &= ~SS_WAITING; ! 357: tcp_output(tp); ! 358: break; ! 359: case TCPC_LISTEN: ! 360: if(tp->t_state != TCPS_CLOSED){ ! 361: tu->code = TCPC_BADDEV; ! 362: goto bad; ! 363: } ! 364: if (tu->laddr != INADDR_ANY) { ! 365: /* has the user specified a legal local address? */ ! 366: if (ip_ifwithaddr(tu->laddr) == 0) { ! 367: tu->code = TCPC_BADLOCAL; ! 368: goto bad; ! 369: } ! 370: } ! 371: tp->so_options = tu->param & ~SO_ACCEPTCONN; ! 372: if(tcpcb_bind(tp, tu->laddr, tu->lport)) { ! 373: tu->code = TCPC_BOUND; ! 374: goto bad; ! 375: } ! 376: tp->t_state = TCPS_LISTEN; ! 377: tp->so_options |= SO_ACCEPTCONN; ! 378: tp->so_fport = tu->fport==0 ? TCPPORT_ANY : tu->fport; ! 379: tp->so_faddr = tu->faddr; ! 380: tcp_template(tp); ! 381: if(tp->t_template == 0) { ! 382: tu->code = TCPC_BADDEV; ! 383: printf("no template - "); ! 384: goto bad; ! 385: } ! 386: tp->so_state &= ~SS_WAITING; ! 387: if (tcp_isconnected(tp)<0) { ! 388: tu->code = TCPC_BADDEV; ! 389: goto bad; ! 390: } ! 391: break; ! 392: default: ! 393: tu->code = TCPC_SORRY; ! 394: goto bad; ! 395: } ! 396: bp_free(bp); ! 397: return; ! 398: bad: ! 399: /* ! 400: * send reason for failure back to user. ! 401: */ ! 402: if(bp->next) { ! 403: bp_free(bp->next); ! 404: bp->next = 0; ! 405: } ! 406: (*tp->so_rq->next->qinfo->putp)(tp->so_rq->next, bp); ! 407: tcp_hungup(tp); ! 408: } ! 409: ! 410: struct tcpcb * ! 411: tcp_disconnect(tp) ! 412: register struct tcpcb *tp; ! 413: { ! 414: ! 415: if(tp->t_state < TCPS_ESTABLISHED) ! 416: tp = tcp_close(tp); ! 417: else { ! 418: tp->so_state &= ~SS_PLEASEOPEN; ! 419: tcp_hungup(tp); /* sends M_HANGUP */ ! 420: tp = tcp_usrclosed(tp); ! 421: if(tp) ! 422: tcp_output(tp); ! 423: } ! 424: return(tp); ! 425: } ! 426: ! 427: struct tcpcb * ! 428: tcp_usrclosed(tp) ! 429: register struct tcpcb *tp; ! 430: { ! 431: ! 432: switch(tp->t_state){ ! 433: ! 434: case TCPS_CLOSED: ! 435: case TCPS_LISTEN: ! 436: case TCPS_SYN_SENT: ! 437: tp->t_state = TCPS_CLOSED; ! 438: tp = tcp_close(tp); ! 439: break; ! 440: ! 441: case TCPS_SYN_RECEIVED: ! 442: case TCPS_ESTABLISHED: ! 443: tp->t_state = TCPS_FIN_WAIT_1; ! 444: tp->so_options |= SO_KEEPALIVE; ! 445: tcp_timers(tp, TCPT_KEEP); ! 446: break; ! 447: ! 448: case TCPS_CLOSE_WAIT: ! 449: tp->t_state = TCPS_LAST_ACK; ! 450: tp->so_options |= SO_KEEPALIVE; ! 451: tcp_timers(tp, TCPT_KEEP); ! 452: break; ! 453: } ! 454: if(tp && tp->t_state >= TCPS_FIN_WAIT_2) { ! 455: tp->so_state &= ~(SS_PLEASEOPEN|SS_RCVATMARK); ! 456: if(tp->so_state&SS_OPEN && !(tp->so_state&SS_HUNGUP)) { ! 457: tp->so_state |= SS_HUNGUP; ! 458: tcp_hungup(tp); ! 459: } ! 460: } ! 461: return(tp); ! 462: } ! 463: ! 464: tcp_isconnected(tp) ! 465: struct tcpcb *tp; ! 466: { ! 467: struct block *bp; ! 468: struct tcpuser *tu; ! 469: struct tcpcb *rtp; ! 470: ! 471: if(tp->so_head) ! 472: rtp = tp->so_head; ! 473: else ! 474: rtp = tp; ! 475: if((rtp->so_state & SS_OPEN) == 0){ ! 476: printf("isconnected, no fd ref\n"); ! 477: return -1; ! 478: } ! 479: bp = allocb(sizeof(struct tcpuser)); ! 480: if(bp == 0) ! 481: return -1; ! 482: bp->wptr += sizeof(struct tcpuser); ! 483: tu = (struct tcpuser *)bp->rptr; ! 484: tu->code = TCPC_OK; ! 485: tu->fport = tp->so_fport; ! 486: tu->faddr = tp->so_faddr; ! 487: tu->lport = tp->so_lport; ! 488: tu->laddr = tp->so_laddr; ! 489: tu->param = tp->so_dev; ! 490: bp->class |= S_DELIM; ! 491: return tcpdrint(bp, rtp); ! 492: } ! 493: ! 494: tcp_hungup(tp) ! 495: register struct tcpcb *tp; ! 496: { ! 497: register struct queue *q; ! 498: ! 499: q = tp->so_rq; ! 500: if(q == 0) ! 501: return; ! 502: qpctl(q, M_HANGUP); ! 503: } ! 504: ! 505: /* ! 506: * find a spare even-numbered tcp device for a new passive-end ! 507: * connection. ! 508: */ ! 509: struct tcpcb * ! 510: tcp_newconn(tp) ! 511: register struct tcpcb *tp; ! 512: { ! 513: register struct tcpcb *ntp; ! 514: register struct tcpcb *tend; ! 515: ! 516: if(tp->so_rq && (tp->so_rq->flag&QFULL)){ ! 517: printf("listen %d q full\n", tp->so_lport); ! 518: return(0); ! 519: } ! 520: tend = &tcpcb[tcpcnt]; ! 521: for(ntp = &tcpcb[0]; ntp < tend; ntp += 2){ ! 522: if(ntp->t_state == TCPS_CLOSED){ ! 523: bzero(ntp, sizeof(struct tcpcb)); ! 524: ntp->t_maxseg = TCP_DEFMAXSEG; ! 525: ntp->so_options = tp->so_options & SO_KEEPALIVE; ! 526: ntp->so_head = tp; ! 527: ntp->so_dev = ntp - tcpcb; ! 528: return(ntp); ! 529: } ! 530: } ! 531: return(0); ! 532: } ! 533: ! 534: struct tcpcb * ! 535: tcpcb_lookup(faddr, fport, laddr, lport) ! 536: register in_addr faddr, laddr; ! 537: register tcp_port fport, lport; ! 538: { ! 539: register struct tcpcb *tp; ! 540: int highscore = 0, score; ! 541: struct tcpcb *match = 0; ! 542: struct tcpcb *tend; ! 543: ! 544: tend = &tcpcb[tcpcnt]; ! 545: for(tp = &tcpcb[0]; tp < tend; tp++){ ! 546: if(tp->t_state == TCPS_CLOSED) ! 547: continue; ! 548: score = 22; ! 549: if(tp->so_faddr != faddr) { ! 550: if(tp->so_faddr != INADDR_ANY) ! 551: continue; ! 552: else ! 553: score -=8; ! 554: } ! 555: if(tp->so_fport != fport) { ! 556: if(tp->so_fport != TCPPORT_ANY) ! 557: continue; ! 558: else ! 559: score -=8; ! 560: } ! 561: if(tp->so_laddr != laddr) { ! 562: if(tp->so_laddr == in_netof(laddr)) ! 563: score -=1; ! 564: else if(tp->so_laddr != INADDR_ANY) ! 565: continue; ! 566: else ! 567: score -=2; ! 568: } ! 569: if(tp->so_lport != lport) { ! 570: if(tp->so_lport != TCPPORT_ANY) ! 571: continue; ! 572: else ! 573: score -=4; ! 574: } ! 575: if (score==22) ! 576: return tp; ! 577: if (score<highscore) ! 578: continue; ! 579: match = tp; ! 580: highscore = score; ! 581: } ! 582: return(match); ! 583: } ! 584: ! 585: /* n chars were acked; drop them now */ ! 586: sbsnddrop(tp, n) ! 587: register struct tcpcb *tp; ! 588: register int n; ! 589: { ! 590: register struct queue *q; ! 591: register int i; ! 592: register struct block *bp; ! 593: ! 594: q = tp->so_wq; ! 595: if(q == 0) ! 596: return; ! 597: bp = 0; ! 598: while(n > 0 && (bp = getq(q))){ ! 599: i = MIN(BLEN(bp), n); ! 600: bp->rptr += i; ! 601: n -= i; ! 602: tp->so_wcount -= i; ! 603: if(bp->rptr >= bp->wptr){ ! 604: freeb(bp); ! 605: bp = 0; ! 606: } else if(n > 0){ ! 607: panic("sbsnddrop"); ! 608: } ! 609: } ! 610: if(bp) ! 611: putbq(q, bp); ! 612: } ! 613: ! 614: static tcp_port portnext[] = { 600, 1024 }; ! 615: static tcp_port portlow[] = { 600, 1024 }; ! 616: static tcp_port porthigh[] = { 1024, 2048 }; ! 617: ! 618: tcpcb_bind(tp, addr, port) ! 619: register struct tcpcb *tp; ! 620: register in_addr addr; ! 621: register tcp_port port; ! 622: { ! 623: register int i; ! 624: ! 625: tp->so_lport = 0; ! 626: if(port){ ! 627: /* ! 628: * Don't let just anyone get a trusted port. ! 629: */ ! 630: if(port<porthigh[0] && u.u_uid!=0) ! 631: return(1); ! 632: tp->so_lport = port; ! 633: tp->so_laddr = addr; ! 634: return(0); ! 635: } ! 636: /* ! 637: * No specific port, pick one. Root only gets a trusted ! 638: * port if explicitly requested, so privileged programs ! 639: * can make non-privileged calls. ! 640: */ ! 641: i = (u.u_uid==0 && (tp->so_options&SO_TRUSTED)) ? 0 : 1; ! 642: if(portnext[i] >= porthigh[i]) ! 643: portnext[i] = portlow[i]; ! 644: port = portnext[i]; ! 645: while(1){ ! 646: if(tcpcb_bind(tp, addr, portnext[i]) == 0){ ! 647: portnext[i]++; ! 648: return(0); ! 649: } ! 650: portnext[i]++; ! 651: if(portnext[i] >= porthigh[i]) ! 652: portnext[i] = portlow[i]; ! 653: if(portnext[i] == port) /* tried them all */ ! 654: break; ! 655: } ! 656: return(1); ! 657: } ! 658: ! 659: tcp_cantrcvmore(tp) ! 660: register struct tcpcb *tp; ! 661: { ! 662: register struct queue *q; ! 663: ! 664: q = tp->so_rq; ! 665: if(q == NULL) ! 666: return; ! 667: if(tp->so_state & SS_HANGUP) ! 668: qpctl(q, M_HANGUP); ! 669: else { ! 670: /* two delims ensure a zero length read at the process */ ! 671: qpctld(q, M_DATA); ! 672: qpctld(q, M_DATA); ! 673: } ! 674: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.