![[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] / researchv8dc / sys / inet|
Return to tcp_device.c CVS log | Up to [Research Unix] / researchv8dc / sys / inet |
1.1 ! root 1: /* ! 2: * tcp_device.c ! 3: */ ! 4: ! 5: #include "tcp.h" ! 6: #if NTCP ! 7: #include "../h/param.h" ! 8: #include "../h/systm.h" ! 9: #include "../h/stream.h" ! 10: #include "../h/ioctl.h" ! 11: #include "../h/ttyld.h" ! 12: #include "../h/buf.h" ! 13: #include "../h/conf.h" ! 14: #include "../h/inet/in.h" ! 15: #include "../h/inet/mbuf.h" ! 16: #include "../h/inet/tcp.h" ! 17: #include "../h/inet/tcp_timer.h" ! 18: #include "../h/inet/tcp_seq.h" ! 19: #include "../h/inet/tcp_var.h" ! 20: #include "../h/inet/tcp_user.h" ! 21: #include "../h/inet/tcp_fsm.h" ! 22: #include "../h/inet/socket.h" ! 23: ! 24: extern int tcp_busy; /* set to discourage timers & ensuing panics */ ! 25: ! 26: int nodev(), tcpdopen(), tcpdclose(), tcpdput(); ! 27: int tcpdosrv(), tcpdisrv(); ! 28: static struct qinit tcpdrinit = { nodev, tcpdisrv, tcpdopen, tcpdclose, 2048, 64 }; ! 29: /* was 1024, 64 originally */ ! 30: struct qinit tcpdwinit = { tcpdput, tcpdosrv, tcpdopen, tcpdclose, 512, 64 }; ! 31: /* was 256, 64 originally */ ! 32: struct streamtab tcpdinfo = { &tcpdrinit, &tcpdwinit }; ! 33: ! 34: int Ntcp = NTCP; /* for netstat */ ! 35: struct tcpcb tcpcb[NTCP]; ! 36: struct socket tcpsocks[NTCP]; ! 37: ! 38: tcpdopen(q, dev) ! 39: register struct queue *q; ! 40: dev_t dev; ! 41: { ! 42: struct socket *so; ! 43: ! 44: dev = minor(dev); ! 45: if(dev >= NTCP) ! 46: return(0); ! 47: so = &tcpsocks[dev]; ! 48: if((dev&01) == 0 && (so->so_state&SS_ACTIVE) == 0) ! 49: return(0); ! 50: if(so->so_state&SS_WAITING) ! 51: return(0); ! 52: if((so->so_options&SO_ACCEPTCONN) && (so->so_state&SS_OPEN)) ! 53: return(0); ! 54: if((so->so_state & (SS_ACTIVE|SS_OPEN|SS_PLEASEOPEN)) == SS_ACTIVE) ! 55: return(0); ! 56: if(q->ptr && dev&01) /* re-opening outgoing port */ ! 57: return(0); ! 58: if(q->ptr) ! 59: return(1); ! 60: tcp_busy++; ! 61: if((so->so_state & SS_PLEASEOPEN) == 0){ ! 62: bzero(so, sizeof(struct socket)); ! 63: so->so_state |= SS_WAITING; ! 64: } ! 65: so->so_state |= SS_OPEN; ! 66: so->so_dev = dev; ! 67: so->so_rq = q; ! 68: so->so_wq = WR(q); ! 69: q->ptr = (caddr_t)so; ! 70: WR(q)->flag |= QNOENB|QBIGB; ! 71: WR(q)->ptr = (caddr_t)so; ! 72: --tcp_busy; ! 73: if(so->so_state & SS_PLEASEOPEN){ ! 74: so->so_state &= ~SS_PLEASEOPEN; ! 75: qenable(WR(q)); /* to force out rcv wnd update */ ! 76: } ! 77: return(1); ! 78: } ! 79: ! 80: tcpdclose(q) ! 81: register struct queue *q; ! 82: { ! 83: struct socket *so; ! 84: struct tcpcb *tp; ! 85: ! 86: so = (struct socket *)q->ptr; ! 87: tcp_busy++; ! 88: so->so_state &= ~(SS_OPEN|SS_WAITING); ! 89: so->so_rq = so->so_wq = (struct queue *) 0; ! 90: so->so_wcount = so->so_rcount = 0; ! 91: tp = so->so_tcpcb; ! 92: if(tp == 0){ ! 93: --tcp_busy; ! 94: return; ! 95: } ! 96: if(tp->t_state > TCPS_LISTEN) ! 97: tcp_disconnect(tp); ! 98: else ! 99: tcp_close(tp); ! 100: --tcp_busy; ! 101: } ! 102: ! 103: tcpdput(q, bp) ! 104: register struct queue *q; ! 105: register struct block *bp; ! 106: { ! 107: struct socket *so; ! 108: int s, x; ! 109: register union stmsg *sp; ! 110: struct tcpcb *tp; ! 111: ! 112: so = (struct socket *)q->ptr; ! 113: switch(bp->type){ ! 114: case M_IOCTL: ! 115: sp = (union stmsg *)bp->rptr; ! 116: bp->type = M_IOCACK; ! 117: switch(sp->ioc0.com){ ! 118: case TIOCSETP: ! 119: case TIOCSETN: ! 120: x = sp->ioc1.sb.sg_ispeed; ! 121: bp->wptr = bp->rptr; ! 122: bp->type = M_IOCACK; ! 123: qreply(q, bp); ! 124: if(x == 0) ! 125: tcp_putctl(OTHERQ(q), M_HANGUP); ! 126: return; ! 127: case TIOCGETP: ! 128: sp->ioc1.sb.sg_ispeed = ! 129: sp->ioc1.sb.sg_ospeed = B9600; ! 130: break; ! 131: case TCPIOHUP: ! 132: so->so_state |= SS_HANGUP; ! 133: bp->wptr = bp->rptr; ! 134: bp->type = M_IOCACK; ! 135: qreply(q, bp); ! 136: return; ! 137: default: ! 138: bp->type = M_IOCNAK; ! 139: } ! 140: qreply(q, bp); ! 141: return; ! 142: case M_DATA: ! 143: if(socantsendmore(so)){ ! 144: freeb(bp); ! 145: return; ! 146: } ! 147: s = spl6(); ! 148: so->so_delimcnt = 0; ! 149: so->so_wcount += BLEN(bp); /* BEFORE the putq */ ! 150: putq(q, bp); ! 151: splx(s); ! 152: if((so->so_options&SO_ACCEPTCONN) == 0 ! 153: && (so->so_state&SS_WAITING) == 0 ! 154: && (tp = so->so_tcpcb)){ ! 155: /* so as to invoke tcp_output() */ ! 156: if(tp->t_state > TCPS_CLOSE_WAIT) ! 157: printf("data after CLOSE_WAIT?\n"); ! 158: qenable(q); ! 159: } ! 160: break; ! 161: case M_DELIM: ! 162: if(so->so_options&SO_ACCEPTCONN){ ! 163: printf("DELIM on listener\n"); ! 164: } else if(so->so_state & SS_WAITING){ ! 165: putq(q, bp); ! 166: /* to invoke tcpduser */ ! 167: qenable(q); ! 168: } else { ! 169: /* two back to back delims constitute logical eof */ ! 170: freeb(bp); ! 171: s = spl6(); ! 172: if(socantsendmore(so)){ ! 173: splx(s); ! 174: return; ! 175: } ! 176: if(++(so->so_delimcnt) > 1){ ! 177: splx(s); ! 178: qenable(q); ! 179: } else ! 180: splx(s); ! 181: } ! 182: break; ! 183: default: ! 184: freeb(bp); ! 185: break; ! 186: } ! 187: } ! 188: ! 189: tcpdosrv(q) ! 190: struct queue *q; ! 191: { ! 192: register struct socket *so; ! 193: register struct tcpcb *tp; ! 194: ! 195: so = (struct socket *)q->ptr; ! 196: if (so->so_state&SS_WCLOSED) ! 197: return; ! 198: tcp_busy++; ! 199: if(so->so_delimcnt > 1){ ! 200: so->so_state |= SS_WCLOSED; ! 201: if((tp = so->so_tcpcb) == 0){ ! 202: printf("delimcnt but no tp\n"); ! 203: --tcp_busy; ! 204: return; ! 205: } ! 206: tp = tcp_usrclosed(tp); ! 207: if(tp) ! 208: tcp_output(tp); ! 209: } else { ! 210: if((so->so_options&SO_ACCEPTCONN) == 0 ! 211: && (so->so_state&SS_WAITING) == 0 ! 212: && (tp = so->so_tcpcb)){ ! 213: tcp_output(tp); ! 214: } else { ! 215: tcpduser(so); ! 216: } ! 217: } ! 218: --tcp_busy; ! 219: } ! 220: ! 221: tcpdrint(bp, so) ! 222: register struct block *bp; ! 223: struct socket *so; ! 224: { ! 225: register struct block *bp1; ! 226: register struct queue *q; ! 227: ! 228: q = so->so_rq; ! 229: if(q){ ! 230: while(bp){ ! 231: bp1 = bp->next; ! 232: so->so_rcount += bp->wptr - bp->rptr; ! 233: if(bp->wptr == bp->rptr) ! 234: freeb(bp); ! 235: else ! 236: putq(q, bp); ! 237: bp = bp1; ! 238: } ! 239: } else { ! 240: printf("tcpdrint but no so->so_rq\n"); ! 241: bp_free(bp); ! 242: } ! 243: } ! 244: ! 245: tcpdisrv(q) ! 246: struct queue *q; ! 247: { ! 248: struct socket *so = (struct socket *)(q->ptr); ! 249: struct block *bp; ! 250: ! 251: while((q->next->flag&QFULL) == 0){ ! 252: if(bp = getq(q)){ ! 253: if(bp->type == M_DATA) ! 254: so->so_rcount -= bp->wptr - bp->rptr; ! 255: if(so->so_rcount < 0) ! 256: panic("so_rcount"); ! 257: (*q->next->qinfo->putp)(q->next, bp); ! 258: } else ! 259: break; ! 260: } ! 261: if(q->count <= q->qinfo->lolimit) ! 262: qenable(OTHERQ(q)); /* update remote send window */ ! 263: } ! 264: ! 265: /* ! 266: * imitation tcp_usrreq ! 267: */ ! 268: tcpduser(so) ! 269: register struct socket *so; ! 270: { ! 271: extern struct ipif *ip_ifwithaddr(); ! 272: struct tcpuser *tu; ! 273: struct block *bp, *bp1, *head; ! 274: register struct tcpcb *tp; ! 275: ! 276: bp = bp1 = head = NULL; ! 277: while(bp = getq(so->so_wq)){ ! 278: if(bp->type != M_DATA){ ! 279: freeb(bp); ! 280: } else if(bp1 == NULL){ ! 281: bp1 = head = bp; ! 282: bp->next = NULL; ! 283: } else { ! 284: bp1->next = bp; ! 285: bp1 = bp; ! 286: bp->next = NULL; ! 287: } ! 288: } ! 289: if(head == NULL) ! 290: return; ! 291: so->so_wcount = 0; ! 292: bp = head; ! 293: if(BLEN(bp) < sizeof(struct tcpuser)){ ! 294: /* ! 295: printf("tcpuser short\n"); ! 296: */ ! 297: bp_free(bp); ! 298: return; ! 299: } ! 300: tu = (struct tcpuser *)bp->rptr; ! 301: if(so->so_tcpcb) ! 302: printf("%d: tcpduser w/ tcpcb\n", so->so_dev); ! 303: switch(tu->cmd){ ! 304: case TCPC_CONNECT: ! 305: if(so->so_state&SS_ACTIVE) ! 306: goto bad; ! 307: if (tu->src != INADDR_ANY) { ! 308: /* has the user has specified a legal local address? */ ! 309: if (ip_ifwithaddr(tu->src) == 0) ! 310: goto bad; ! 311: } else { ! 312: /* pick a local address related to the destination */ ! 313: tu->src = ip_hoston(tu->dst); ! 314: if(tu->src == INADDR_ANY) ! 315: goto bad; ! 316: } ! 317: if(tcp_attach(so)) ! 318: goto bad; ! 319: if(sobind(so, tu->src, tu->sport)) ! 320: goto bad; ! 321: tp = so->so_tcpcb; ! 322: so->so_fport = tu->dport; ! 323: so->so_faddr = tu->dst; ! 324: so->so_options = 0; ! 325: tp->t_template = tcp_template(tp); ! 326: if(tp->t_template == 0) ! 327: goto bad; ! 328: soisconnecting(so); ! 329: tp->t_state = TCPS_SYN_SENT; ! 330: tp->t_timer[TCPT_KEEP] = TCPTV_KEEP; ! 331: tp->iss = tcp_iss; tcp_iss += TCP_ISSINCR/2; ! 332: tcp_sendseqinit(tp); ! 333: so->so_state &= ~SS_WAITING; ! 334: tcp_output(tp); ! 335: break; ! 336: case TCPC_LISTEN: ! 337: if(so->so_state&SS_ACTIVE) ! 338: goto bad; ! 339: if (tu->src != INADDR_ANY) { ! 340: /* has the user has specified a legal local address? */ ! 341: if (ip_ifwithaddr(tu->src) == 0) ! 342: goto bad; ! 343: } ! 344: if(tcp_attach(so)) ! 345: goto bad; ! 346: if(sobind(so, tu->src, tu->sport)) ! 347: goto bad; ! 348: tp = so->so_tcpcb; ! 349: tp->t_state = TCPS_LISTEN; ! 350: so->so_options |= SO_ACCEPTCONN; ! 351: so->so_fport = tu->dport; ! 352: so->so_state &= ~SS_WAITING; ! 353: break; ! 354: default: ! 355: goto bad; ! 356: } ! 357: bp_free(bp); ! 358: return; ! 359: bad: ! 360: bp_free(bp); ! 361: tcp_hungup(so); ! 362: } ! 363: ! 364: tcp_attach(so) ! 365: struct socket *so; ! 366: { ! 367: register struct tcpcb *tp; ! 368: extern struct tcpcb *tcp_newtcpcb(); ! 369: ! 370: tp = tcp_newtcpcb(so); ! 371: if(tp == 0) ! 372: return(1); ! 373: tp->t_socket = so; ! 374: tp->t_state = TCPS_CLOSED; ! 375: return(0); ! 376: } ! 377: ! 378: struct tcpcb * ! 379: tcp_disconnect(tp) ! 380: register struct tcpcb *tp; ! 381: { ! 382: struct socket *so = tp->t_socket; ! 383: ! 384: if(tp->t_state < TCPS_ESTABLISHED) ! 385: tp = tcp_close(tp); ! 386: else { ! 387: soisdisconnecting(so); ! 388: tp = tcp_usrclosed(tp); ! 389: if(tp) ! 390: tcp_output(tp); ! 391: } ! 392: return(tp); ! 393: } ! 394: ! 395: struct tcpcb * ! 396: tcp_usrclosed(tp) ! 397: register struct tcpcb *tp; ! 398: { ! 399: ! 400: switch(tp->t_state){ ! 401: ! 402: case TCPS_CLOSED: ! 403: case TCPS_LISTEN: ! 404: case TCPS_SYN_SENT: ! 405: tp->t_state = TCPS_CLOSED; ! 406: tp = tcp_close(tp); ! 407: break; ! 408: ! 409: case TCPS_SYN_RECEIVED: ! 410: case TCPS_ESTABLISHED: ! 411: tp->t_state = TCPS_FIN_WAIT_1; ! 412: break; ! 413: ! 414: case TCPS_CLOSE_WAIT: ! 415: tp->t_state = TCPS_LAST_ACK; ! 416: break; ! 417: } ! 418: if(tp && tp->t_state >= TCPS_FIN_WAIT_2) ! 419: soisdisconnected(tp->t_socket); ! 420: return(tp); ! 421: } ! 422: ! 423: tcp_isconnected(so) ! 424: struct socket *so; ! 425: { ! 426: struct block *bp; ! 427: struct tcpreply *tr; ! 428: struct socket *rso; ! 429: ! 430: if(so->so_head) ! 431: rso = so->so_head; ! 432: else ! 433: rso = so; ! 434: if((rso->so_state & SS_OPEN) == 0){ ! 435: printf("isconnected, no fd ref\n"); ! 436: return; ! 437: } ! 438: bp = allocb(64); ! 439: if(bp == 0) ! 440: return; ! 441: bp->next = NULL; ! 442: bp->type = M_DATA; ! 443: bp->wptr += sizeof(struct tcpreply); ! 444: tr = (struct tcpreply *)bp->rptr; ! 445: tr->reply = TCPR_OK; ! 446: tr->dport = so->so_fport; ! 447: tr->dst = so->so_faddr; ! 448: tr->src = so->so_laddr; ! 449: tr->tcpdev = so->so_dev; ! 450: tcpdrint(bp, rso); ! 451: } ! 452: ! 453: tcp_hungup(so) ! 454: register struct socket *so; ! 455: { ! 456: register struct queue *q; ! 457: ! 458: q = so->so_rq; ! 459: if(q == 0) ! 460: return; ! 461: tcp_putctl(q, M_HANGUP); ! 462: } ! 463: ! 464: /* ! 465: * find a spare odd tcp device for a new passive-end ! 466: * connection. ! 467: */ ! 468: struct socket * ! 469: tcp_newconn(so) ! 470: struct socket *so; ! 471: { ! 472: struct socket *nso; ! 473: ! 474: if(so->so_rq && (so->so_rq->flag&QFULL)){ ! 475: printf("listen %d q full\n", so->so_lport); ! 476: return(0); ! 477: } ! 478: for(nso = &tcpsocks[0]; nso < &tcpsocks[NTCP]; nso += 2){ ! 479: if((nso->so_state & (SS_OPEN|SS_ACTIVE)) == 0){ ! 480: bzero(nso, sizeof(struct socket)); ! 481: nso->so_head = so; ! 482: nso->so_dev = nso - tcpsocks; ! 483: return(nso); ! 484: } ! 485: } ! 486: return(0); ! 487: } ! 488: ! 489: struct socket * ! 490: so_lookup(faddr, fport, laddr, lport) ! 491: in_addr faddr, laddr; ! 492: tcp_port fport, lport; ! 493: { ! 494: register struct socket *so, *match = 0; ! 495: register in_addr net, host; ! 496: int matchwild = 5, wildcard; ! 497: ! 498: net = in_netof(laddr); ! 499: host = in_hostof(laddr); ! 500: for(so = &tcpsocks[0]; so < &tcpsocks[NTCP]; so++){ ! 501: if(so->so_tcpcb == 0) ! 502: continue; ! 503: if((so->so_state&(SS_OPEN|SS_ACTIVE)) == 0) ! 504: continue; ! 505: if(so->so_state & SS_WAITING) ! 506: continue; ! 507: wildcard = 0; ! 508: ! 509: if(so->so_lport != TCPPORT_ANY){ ! 510: if(so->so_lport != lport) ! 511: continue; ! 512: } else ! 513: wildcard++; /* port is wildcarded */ ! 514: ! 515: if(so->so_laddr == net){ ! 516: wildcard++; /* host is wildcarded */ ! 517: } else if(so->so_laddr != INADDR_ANY){ ! 518: if(laddr == INADDR_ANY) ! 519: wildcard += 2; /* host & net wildcarded */ ! 520: else if(so->so_laddr != laddr) ! 521: continue; ! 522: } else { ! 523: if(laddr != INADDR_ANY) ! 524: wildcard += 2; /* host & net wildcarded */ ! 525: } ! 526: if(so->so_faddr != INADDR_ANY){ ! 527: if(faddr == INADDR_ANY) ! 528: wildcard += 2; /* host & net wildcarded */ ! 529: else if(so->so_faddr != faddr || ! 530: so->so_fport != fport) ! 531: continue; ! 532: } else { ! 533: if(faddr) ! 534: wildcard += 2; /* host & net wildcarded */ ! 535: } ! 536: if(wildcard < matchwild){ ! 537: match = so; ! 538: matchwild = wildcard; ! 539: if(matchwild == 0) ! 540: break; ! 541: } ! 542: } ! 543: return(match); ! 544: } ! 545: ! 546: /* n chars were acked; drop them now */ ! 547: sbsnddrop(so, n) ! 548: register struct socket *so; ! 549: register int n; ! 550: { ! 551: register struct queue *q; ! 552: register int i; ! 553: register struct block *bp; ! 554: ! 555: q = so->so_wq; ! 556: if(q == 0) ! 557: return; ! 558: bp = 0; ! 559: while(n > 0 && (bp = getq(q))){ ! 560: i = MIN(BLEN(bp), n); ! 561: bp->rptr += i; ! 562: n -= i; ! 563: so->so_wcount -= i; ! 564: if(bp->rptr >= bp->wptr){ ! 565: freeb(bp); ! 566: bp = 0; ! 567: } else if(n > 0){ ! 568: panic("sbsnddrop"); ! 569: } ! 570: } ! 571: if(bp) ! 572: putbq(q, bp); ! 573: } ! 574: ! 575: ! 576: sobind(so, addr, port) ! 577: register struct socket *so; ! 578: register in_addr addr; ! 579: register tcp_port port; ! 580: { ! 581: register struct socket *sp; ! 582: static tcp_port next_port = 600; ! 583: ! 584: so->so_lport = 0; ! 585: if(port){ ! 586: /* what about, for instance, restarting rlogind when ! 587: * people are rlogin'd here? ! 588: */ ! 589: for(sp = &tcpsocks[0]; sp < &tcpsocks[NTCP]; sp++){ ! 590: if(sp->so_tcpcb == 0) ! 591: continue; ! 592: if((sp->so_state&(SS_OPEN|SS_ACTIVE)) == 0) ! 593: continue; ! 594: if(sp->so_lport == port && sp->so_laddr == addr) { ! 595: return(1); ! 596: } ! 597: } ! 598: so->so_lport = port; ! 599: so->so_laddr = addr; ! 600: return(0); ! 601: } ! 602: /* pick one for him */ ! 603: if(next_port >= 1024) ! 604: next_port = 600; ! 605: port = next_port; ! 606: while(1){ ! 607: if(sobind(so, addr, next_port) == 0){ ! 608: next_port++; ! 609: return(0); ! 610: } ! 611: next_port++; ! 612: if(next_port >= 1024) ! 613: next_port = 600; ! 614: if(next_port == port) /* tried them all */ ! 615: break; ! 616: } ! 617: return(1); ! 618: } ! 619: ! 620: tcp_cantrcvmore(so) ! 621: register struct socket *so; ! 622: { ! 623: register struct queue *q; ! 624: ! 625: q = so->so_rq; ! 626: if(q == NULL) ! 627: return; ! 628: if(so->so_state & SS_HANGUP) ! 629: tcp_putctl(q, M_HANGUP); ! 630: else { ! 631: /* two delims ensure a zero length read at the process */ ! 632: tcp_putctl(q, M_DELIM); ! 633: tcp_putctl(q, M_DELIM); ! 634: } ! 635: } ! 636: ! 637: tcp_putctl(q, c) ! 638: register struct queue *q; ! 639: { ! 640: register struct block *bp; ! 641: ! 642: if ((bp = allocb(0)) == NULL) { ! 643: printf("tcp_putctl: no more blocks\n"); ! 644: return(0); ! 645: } ! 646: bp->type = c; ! 647: putq(q, bp); ! 648: return(1); ! 649: } ! 650: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.