![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to devip.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to devip.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 ! root 1: #include "u.h" ! 2: #include "../port/lib.h" ! 3: #include "mem.h" ! 4: #include "dat.h" ! 5: #include "fns.h" ! 6: #include "../port/error.h" ! 7: #include "arp.h" ! 8: #include "../port/ipdat.h" ! 9: ! 10: #include "devtab.h" ! 11: ! 12: enum ! 13: { ! 14: Nrprotocol = 4, /* Number of protocols supported by this driver */ ! 15: Nipsubdir = 4, /* Number of subdirectory entries per connection */ ! 16: Nfrag = 32, /* Ip reassembly queue entries */ ! 17: Nifc = 4, /* max interfaces */ ! 18: }; ! 19: ! 20: int udpsum = 1; ! 21: Ipifc *ipifc[Nrprotocol+1]; ! 22: QLock ipalloc; /* Protocol port allocation lock */ ! 23: Ipconv **tcpbase; ! 24: ! 25: Streamput udpstiput, udpstoput, tcpstiput, tcpstoput; ! 26: Streamput iliput, iloput, bsdiput, bsdoput; ! 27: Streamopen udpstopen, tcpstopen, ilopen, bsdopen; ! 28: Streamclose udpstclose, tcpstclose, ilclose, bsdclose; ! 29: ! 30: Qinfo tcpinfo = { tcpstiput, tcpstoput, tcpstopen, tcpstclose, "tcp", 0, 1 }; ! 31: Qinfo udpinfo = { udpstiput, udpstoput, udpstopen, udpstclose, "udp" }; ! 32: Qinfo ilinfo = { iliput, iloput, ilopen, ilclose, "il" }; ! 33: Qinfo bsdinfo = { bsdiput, bsdoput, bsdopen, bsdclose, "bsd", 0, 1 }; ! 34: ! 35: Qinfo *protocols[] = { &tcpinfo, &udpinfo, &ilinfo, 0 }; ! 36: ! 37: void ! 38: ipinitifc(Ipifc *ifc, Qinfo *stproto) ! 39: { ! 40: ifc->conv = xalloc(Nipconv * sizeof(Ipconv*)); ! 41: ifc->protop = stproto; ! 42: ifc->nconv = Nipconv; ! 43: ifc->devp = &ipconvinfo; ! 44: if(stproto != &udpinfo) ! 45: ifc->listen = iplisten; ! 46: ifc->clone = ipclonecon; ! 47: ifc->ninfo = 3; ! 48: ifc->info[0].name = "remote"; ! 49: ifc->info[0].fill = ipremotefill; ! 50: ifc->info[1].name = "local"; ! 51: ifc->info[1].fill = iplocalfill; ! 52: ifc->info[2].name = "status"; ! 53: ifc->info[2].fill = ipstatusfill; ! 54: ifc->name = stproto->name; ! 55: } ! 56: ! 57: void ! 58: ipreset(void) ! 59: { ! 60: int i; ! 61: ! 62: for(i = 0; protocols[i]; i++) { ! 63: ipifc[i] = xalloc(sizeof(Ipifc)); ! 64: ipinitifc(ipifc[i], protocols[i]); ! 65: newqinfo(protocols[i]); ! 66: } ! 67: ! 68: initfrag(Nfrag); ! 69: } ! 70: ! 71: void ! 72: ipinit(void) ! 73: { ! 74: } ! 75: ! 76: Chan * ! 77: ipattach(char *spec) ! 78: { ! 79: int i; ! 80: Chan *c; ! 81: ! 82: if(ipd[0].q == 0) ! 83: error("no ip multiplexor"); ! 84: ! 85: for(i = 0; protocols[i]; i++) { ! 86: if(strcmp(spec, protocols[i]->name) == 0) { ! 87: c = devattach('I', spec); ! 88: c->dev = i; ! 89: ! 90: return (c); ! 91: } ! 92: } ! 93: ! 94: error(Enoproto); ! 95: return 0; /* not reached */ ! 96: } ! 97: ! 98: Chan * ! 99: ipclone(Chan *c, Chan *nc) ! 100: { ! 101: return devclone(c, nc); ! 102: } ! 103: ! 104: int ! 105: ipwalk(Chan *c, char *name) ! 106: { ! 107: return netwalk(c, name, ipifc[c->dev]); ! 108: } ! 109: ! 110: void ! 111: ipstat(Chan *c, char *db) ! 112: { ! 113: netstat(c, db, ipifc[c->dev]); ! 114: } ! 115: ! 116: Chan * ! 117: ipopen(Chan *c, int omode) ! 118: { ! 119: return netopen(c, omode, ipifc[c->dev]); ! 120: } ! 121: ! 122: int ! 123: ipclonecon(Chan *c) ! 124: { ! 125: Ipconv *new; ! 126: ! 127: new = ipincoming(ipifc[c->dev], 0); ! 128: if(new == 0) ! 129: error(Enodev); ! 130: return new->id; ! 131: } ! 132: ! 133: /* ! 134: * create a new conversation structure if none exists for this conversation slot ! 135: */ ! 136: Ipconv* ! 137: ipcreateconv(Ipifc *ifc, int id) ! 138: { ! 139: Ipconv **p; ! 140: Ipconv *new; ! 141: ! 142: p = &ifc->conv[id]; ! 143: if(*p) ! 144: return *p; ! 145: qlock(ifc); ! 146: p = &ifc->conv[id]; ! 147: if(*p){ ! 148: qunlock(ifc); ! 149: return *p; ! 150: } ! 151: if(waserror()){ ! 152: qunlock(ifc); ! 153: nexterror(); ! 154: } ! 155: new = smalloc(sizeof(Ipconv)); ! 156: new->ifc = ifc; ! 157: netadd(ifc, new, p - ifc->conv); ! 158: new->ref = 1; ! 159: *p = new; ! 160: qunlock(ifc); ! 161: poperror(); ! 162: return new; ! 163: } ! 164: ! 165: /* ! 166: * allocate a conversation structure. ! 167: */ ! 168: Ipconv* ! 169: ipincoming(Ipifc *ifc, Ipconv *from) ! 170: { ! 171: Ipconv *new; ! 172: Ipconv **p, **etab; ! 173: ! 174: /* look for an unused existing conversation */ ! 175: etab = &ifc->conv[Nipconv]; ! 176: for(p = ifc->conv; p < etab; p++) { ! 177: new = *p; ! 178: if(new == 0) ! 179: break; ! 180: if(new->ref == 0 && canqlock(new)) { ! 181: if(new->ref || ipconbusy(new)) { ! 182: qunlock(new); ! 183: continue; ! 184: } ! 185: if(from) /* copy ownership from listening channel */ ! 186: netown(new, from->owner, 0); ! 187: else /* current user becomes owner */ ! 188: netown(new, u->p->user, 0); ! 189: ! 190: new->ref = 1; ! 191: qunlock(new); ! 192: return new; ! 193: } ! 194: } ! 195: ! 196: /* create one */ ! 197: qlock(ifc); ! 198: etab = &ifc->conv[Nipconv]; ! 199: for(p = ifc->conv; ; p++){ ! 200: if(p == etab){ ! 201: qunlock(ifc); ! 202: return 0; ! 203: } ! 204: if(*p == 0) ! 205: break; ! 206: } ! 207: if(waserror()){ ! 208: qunlock(ifc); ! 209: nexterror(); ! 210: } ! 211: new = smalloc(sizeof(Ipconv)); ! 212: new->ifc = ifc; ! 213: netadd(ifc, new, p - ifc->conv); ! 214: qlock(new); ! 215: *p = new; ! 216: qunlock(ifc); ! 217: poperror(); ! 218: if(from) /* copy ownership from listening channel */ ! 219: netown(new, from->owner, 0); ! 220: else /* current user becomes owner */ ! 221: netown(new, u->p->user, 0); ! 222: new->ref = 1; ! 223: qunlock(new); ! 224: return new; ! 225: } ! 226: ! 227: void ! 228: ipcreate(Chan *c, char *name, int omode, ulong perm) ! 229: { ! 230: USED(c, name, omode, perm); ! 231: error(Eperm); ! 232: } ! 233: ! 234: void ! 235: ipremove(Chan *c) ! 236: { ! 237: USED(c); ! 238: error(Eperm); ! 239: } ! 240: ! 241: void ! 242: ipwstat(Chan *c, char *dp) ! 243: { ! 244: netwstat(c, dp, ipifc[c->dev]); ! 245: } ! 246: ! 247: void ! 248: ipclose(Chan *c) ! 249: { ! 250: if(c->stream) ! 251: streamclose(c); ! 252: } ! 253: ! 254: long ! 255: ipread(Chan *c, void *a, long n, ulong offset) ! 256: { ! 257: return netread(c, a, n, offset, ipifc[c->dev]); ! 258: } ! 259: ! 260: long ! 261: ipwrite(Chan *c, char *a, long n, ulong offset) ! 262: { ! 263: int m, backlog, type, priv; ! 264: char *field[5], *ctlarg[5], buf[256]; ! 265: Port port; ! 266: Ipconv *cp; ! 267: uchar dst[4]; ! 268: ! 269: USED(offset); ! 270: type = STREAMTYPE(c->qid.path); ! 271: if (type == Sdataqid) ! 272: return streamwrite(c, a, n, 0); ! 273: ! 274: if (type != Sctlqid) ! 275: error(Eperm); ! 276: ! 277: cp = ipcreateconv(ipifc[c->dev], STREAMID(c->qid.path)); ! 278: ! 279: m = n; ! 280: if(m > sizeof(buf)-1) ! 281: m = sizeof(buf)-1; ! 282: strncpy(buf, a, m); ! 283: buf[m] = '\0'; ! 284: ! 285: m = getfields(buf, field, 5, " "); ! 286: if(m < 1) ! 287: error(Ebadarg); ! 288: ! 289: if(strncmp(field[0], "connect", 7) == 0) { ! 290: if(ipconbusy(cp)) ! 291: error(Enetbusy); ! 292: ! 293: if(m < 2) ! 294: error(Ebadarg); ! 295: ! 296: switch(getfields(field[1], ctlarg, 5, "!")) { ! 297: default: ! 298: error(Eneedservice); ! 299: case 2: ! 300: priv = 0; ! 301: break; ! 302: case 3: ! 303: if(strcmp(ctlarg[2], "r") != 0) ! 304: error(Eperm); ! 305: priv = 1; ! 306: break; ! 307: } ! 308: cp->dst = ipparse(ctlarg[0]); ! 309: hnputl(dst, cp->dst); ! 310: cp->src = ipgetsrc(dst); ! 311: cp->pdst = atoi(ctlarg[1]); ! 312: ! 313: /* If we have no local port assign one */ ! 314: qlock(&ipalloc); ! 315: if(m == 3){ ! 316: port = atoi(field[2]); ! 317: if(portused(ipifc[c->dev], cp->psrc)){ ! 318: qunlock(&ipalloc); ! 319: error(Einuse); ! 320: } ! 321: cp->psrc = port; ! 322: } ! 323: if(cp->psrc == 0) ! 324: cp->psrc = nextport(ipifc[c->dev], priv); ! 325: qunlock(&ipalloc); ! 326: ! 327: if(cp->ifc->protop == &tcpinfo) ! 328: tcpstart(cp, TCP_ACTIVE, Streamhi, 0); ! 329: else if(cp->ifc->protop == &ilinfo) ! 330: ilstart(cp, IL_ACTIVE, 20); ! 331: ! 332: /* ! 333: * stupid hack for BSD port's 512, 513, & 514 ! 334: * to make it harder for user to lie about his ! 335: * identity. -- presotto ! 336: */ ! 337: switch(cp->pdst){ ! 338: case 512: ! 339: case 513: ! 340: case 514: ! 341: pushq(c->stream, &bsdinfo); ! 342: break; ! 343: } ! 344: ! 345: memmove(cp->text, u->p->text, NAMELEN); ! 346: } ! 347: else if(strncmp(field[0], "disconnect", 10) == 0) { ! 348: if(cp->ifc->protop != &udpinfo) ! 349: error(Eperm); ! 350: ! 351: cp->dst = 0; ! 352: cp->pdst = 0; ! 353: } ! 354: else if(strncmp(field[0], "bind", 4) == 0) { ! 355: if(ipconbusy(cp)) ! 356: error(Enetbusy); ! 357: ! 358: port = atoi(field[1]); ! 359: ! 360: if(port){ ! 361: qlock(&ipalloc); ! 362: if(portused(ipifc[c->dev], port)) { ! 363: qunlock(&ipalloc); ! 364: error(Einuse); ! 365: } ! 366: cp->psrc = port; ! 367: qunlock(&ipalloc); ! 368: } else if(*field[1] != '*'){ ! 369: qlock(&ipalloc); ! 370: cp->psrc = nextport(ipifc[c->dev], 0); ! 371: qunlock(&ipalloc); ! 372: } else ! 373: cp->psrc = 0; ! 374: } ! 375: else if(strncmp(field[0], "announce", 8) == 0) { ! 376: if(ipconbusy(cp)) ! 377: error(Enetbusy); ! 378: ! 379: if(m != 2) ! 380: error(Ebadarg); ! 381: ! 382: port = atoi(field[1]); ! 383: ! 384: if(port){ ! 385: qlock(&ipalloc); ! 386: if(portused(ipifc[c->dev], port)) { ! 387: qunlock(&ipalloc); ! 388: error(Einuse); ! 389: } ! 390: cp->psrc = port; ! 391: qunlock(&ipalloc); ! 392: } else if(*field[1] != '*'){ ! 393: qlock(&ipalloc); ! 394: cp->psrc = nextport(ipifc[c->dev], 0); ! 395: qunlock(&ipalloc); ! 396: } else ! 397: cp->psrc = 0; ! 398: ! 399: if(cp->ifc->protop == &tcpinfo) ! 400: tcpstart(cp, TCP_PASSIVE, Streamhi, 0); ! 401: else if(cp->ifc->protop == &ilinfo) ! 402: ilstart(cp, IL_PASSIVE, 10); ! 403: ! 404: if(cp->backlog == 0) ! 405: cp->backlog = 3; ! 406: ! 407: memmove(cp->text, u->p->text, NAMELEN); ! 408: } ! 409: else if(strncmp(field[0], "backlog", 7) == 0) { ! 410: if(m != 2) ! 411: error(Ebadarg); ! 412: backlog = atoi(field[1]); ! 413: if(backlog == 0) ! 414: error(Ebadarg); ! 415: if(backlog > 5) ! 416: backlog = 5; ! 417: cp->backlog = backlog; ! 418: } ! 419: else if(strncmp(field[0], "headers", 7) == 0) { ! 420: cp->headers = 1; /* include addr/port in user packet */ ! 421: } ! 422: else ! 423: return streamwrite(c, a, n, 0); ! 424: ! 425: return n; ! 426: } ! 427: ! 428: int ! 429: ipconbusy(Ipconv *cp) ! 430: { ! 431: if(cp->ifc->protop == &tcpinfo) ! 432: if(cp->tcpctl.state != Closed) ! 433: return 1; ! 434: ! 435: if(cp->ifc->protop == &ilinfo) ! 436: if(cp->ilctl.state != Ilclosed) ! 437: return 1; ! 438: ! 439: return 0; ! 440: } ! 441: ! 442: void ! 443: udpstiput(Queue *q, Block *bp) ! 444: { ! 445: PUTNEXT(q, bp); ! 446: } ! 447: ! 448: /* ! 449: * udprcvmsg - called by stip to multiplex udp ports onto conversations ! 450: */ ! 451: void ! 452: udprcvmsg(Ipifc *ifc, Block *bp) ! 453: { ! 454: Ipconv *cp, **p, **etab; ! 455: Udphdr *uh; ! 456: Port dport, sport; ! 457: ushort sum, len; ! 458: Ipaddr addr; ! 459: Block *nbp; ! 460: ! 461: uh = (Udphdr *)(bp->rptr); ! 462: ! 463: /* Put back pseudo header for checksum */ ! 464: uh->Unused = 0; ! 465: len = nhgets(uh->udplen); ! 466: hnputs(uh->udpplen, len); ! 467: ! 468: addr = nhgetl(uh->udpsrc); ! 469: ! 470: if(udpsum && nhgets(uh->udpcksum)) { ! 471: if(sum = ptcl_csum(bp, UDP_EHSIZE, len+UDP_PHDRSIZE)) { ! 472: print("udp: checksum error %x (%d.%d.%d.%d)\n", ! 473: sum, fmtaddr(addr)); ! 474: ! 475: freeb(bp); ! 476: return; ! 477: } ! 478: } ! 479: ! 480: dport = nhgets(uh->udpdport); ! 481: sport = nhgets(uh->udpsport); ! 482: ! 483: /* Look for a conversation structure for this port */ ! 484: etab = &ifc->conv[Nipconv]; ! 485: for(p = ifc->conv; p < etab; p++) { ! 486: cp = *p; ! 487: if(cp == 0) ! 488: break; ! 489: if(cp->ref) ! 490: if(cp->psrc == dport) ! 491: if(cp->pdst == 0 || cp->pdst == sport) { ! 492: /* Trim the packet down to data size */ ! 493: len = len - (UDP_HDRSIZE-UDP_PHDRSIZE); ! 494: bp = btrim(bp, UDP_EHSIZE+UDP_HDRSIZE, len); ! 495: if(bp == 0) ! 496: return; ! 497: ! 498: if(cp->headers){ ! 499: /* pass the src address to the stream head */ ! 500: nbp = allocb(Udphdrsize); ! 501: nbp->next = bp; ! 502: bp = nbp; ! 503: hnputl(bp->wptr, addr); ! 504: bp->wptr += 4; ! 505: hnputs(bp->wptr, sport); ! 506: bp->wptr += 2; ! 507: } else { ! 508: /* save the src address in the conversation struct */ ! 509: cp->dst = addr; ! 510: cp->pdst = sport; ! 511: } ! 512: cp->src = 0; ! 513: PUTNEXT(cp->readq, bp); ! 514: return; ! 515: } ! 516: } ! 517: ! 518: freeb(bp); ! 519: } ! 520: ! 521: void ! 522: udpstoput(Queue *q, Block *bp) ! 523: { ! 524: Ipconv *cp; ! 525: Udphdr *uh; ! 526: int dlen, ptcllen, newlen; ! 527: Ipaddr addr; ! 528: Port port; ! 529: if(bp->type == M_CTL) { ! 530: PUTNEXT(q, bp); ! 531: return; ! 532: } ! 533: ! 534: cp = (Ipconv *)(q->ptr); ! 535: if(cp->psrc == 0){ ! 536: freeb(bp); ! 537: error(Enoport); ! 538: } ! 539: ! 540: if(bp->type != M_DATA) { ! 541: freeb(bp); ! 542: error(Ebadctl); ! 543: } ! 544: ! 545: /* Only allow atomic udp writes to form datagrams */ ! 546: if(!(bp->flags & S_DELIM)) { ! 547: freeb(bp); ! 548: error(Emsgsize); ! 549: } ! 550: ! 551: /* ! 552: * if we're in header mode, rip off the first 64 bytes as the ! 553: * destination. The destination is in ascii in the form ! 554: * %d.%d.%d.%d!%d ! 555: */ ! 556: if(cp->headers){ ! 557: /* get user specified addresses */ ! 558: bp = pullup(bp, Udphdrsize); ! 559: if(bp == 0){ ! 560: freeb(bp); ! 561: error(Emsgsize); ! 562: } ! 563: addr = nhgetl(bp->rptr); ! 564: bp->rptr += 4; ! 565: port = nhgets(bp->rptr); ! 566: bp->rptr += 2; ! 567: } else ! 568: addr = port = 0; ! 569: ! 570: /* Round packet up to even number of bytes and check we can ! 571: * send it ! 572: */ ! 573: dlen = blen(bp); ! 574: if(dlen > UDP_DATMAX) { ! 575: freeb(bp); ! 576: error(Emsgsize); ! 577: } ! 578: newlen = dlen /*bround(bp, 1)*/; ! 579: ! 580: /* Make space to fit udp & ip & ethernet header */ ! 581: bp = padb(bp, UDP_EHSIZE + UDP_HDRSIZE); ! 582: ! 583: uh = (Udphdr *)(bp->rptr); ! 584: ! 585: ptcllen = dlen + (UDP_HDRSIZE-UDP_PHDRSIZE); ! 586: uh->Unused = 0; ! 587: uh->udpproto = IP_UDPPROTO; ! 588: uh->frag[0] = 0; ! 589: uh->frag[1] = 0; ! 590: hnputs(uh->udpplen, ptcllen); ! 591: hnputs(uh->udpsport, cp->psrc); ! 592: if(cp->headers) { ! 593: hnputl(uh->udpdst, addr); ! 594: hnputs(uh->udpdport, port); ! 595: } ! 596: else { ! 597: hnputl(uh->udpdst, cp->dst); ! 598: hnputs(uh->udpdport, cp->pdst); ! 599: } ! 600: if(cp->src == 0) ! 601: cp->src = ipgetsrc(uh->udpdst); ! 602: hnputl(uh->udpsrc, cp->src); ! 603: hnputs(uh->udplen, ptcllen); ! 604: uh->udpcksum[0] = 0; ! 605: uh->udpcksum[1] = 0; ! 606: ! 607: hnputs(uh->udpcksum, ptcl_csum(bp, UDP_EHSIZE, newlen+UDP_HDRSIZE)); ! 608: PUTNEXT(q, bp); ! 609: } ! 610: ! 611: void ! 612: udpstclose(Queue *q) ! 613: { ! 614: Ipconv *ipc; ! 615: ! 616: ipc = (Ipconv *)(q->ptr); ! 617: ! 618: ipc->headers = 0; ! 619: ipc->psrc = 0; ! 620: ipc->pdst = 0; ! 621: ipc->dst = 0; ! 622: } ! 623: ! 624: void ! 625: udpstopen(Queue *q, Stream *s) ! 626: { ! 627: Ipconv *ipc; ! 628: ! 629: ipc = ipcreateconv(ipifc[s->dev], s->id); ! 630: initipifc(ipifc[s->dev], IP_UDPPROTO, udprcvmsg); ! 631: ! 632: ipc->readq = RD(q); ! 633: RD(q)->ptr = (void *)ipc; ! 634: WR(q)->next->ptr = (void *)ipc->ifc; ! 635: WR(q)->ptr = (void *)ipc; ! 636: } ! 637: ! 638: void ! 639: tcpstiput(Queue *q, Block *bp) ! 640: { ! 641: PUTNEXT(q, bp); ! 642: } ! 643: ! 644: tcproominq(void *a) ! 645: { ! 646: return !((Tcpctl *)a)->sndfull; ! 647: } ! 648: ! 649: void ! 650: tcpstoput(Queue *q, Block *bp) ! 651: { ! 652: Ipconv *s; ! 653: Tcpctl *tcb; ! 654: Block *f; ! 655: ! 656: s = (Ipconv *)(q->ptr); ! 657: tcb = &s->tcpctl; ! 658: ! 659: if(bp->type == M_CTL) { ! 660: PUTNEXT(q, bp); ! 661: return; ! 662: } ! 663: ! 664: if(s->psrc == 0) ! 665: error(Enoport); ! 666: ! 667: /* Report asynchronous errors */ ! 668: if(s->err) ! 669: error(s->err); ! 670: ! 671: switch(tcb->state) { ! 672: case Listen: ! 673: tcb->flags |= ACTIVE; ! 674: tcpsndsyn(tcb); ! 675: tcpsetstate(s, Syn_sent); ! 676: ! 677: /* No break */ ! 678: case Syn_sent: ! 679: case Syn_received: ! 680: case Established: ! 681: /* ! 682: * Process flow control ! 683: */ ! 684: if(tcb->sndfull){ ! 685: qlock(&tcb->sndrlock); ! 686: if(waserror()) { ! 687: qunlock(&tcb->sndrlock); ! 688: freeb(bp); ! 689: nexterror(); ! 690: } ! 691: sleep(&tcb->sndr, tcproominq, tcb); ! 692: poperror(); ! 693: qunlock(&tcb->sndrlock); ! 694: } ! 695: ! 696: /* ! 697: * Push data ! 698: */ ! 699: qlock(tcb); ! 700: if(waserror()) { ! 701: qunlock(tcb); ! 702: nexterror(); ! 703: } ! 704: ! 705: /* make sure we don't queue onto something that just closed */ ! 706: switch(tcb->state) { ! 707: case Syn_sent: ! 708: case Syn_received: ! 709: case Established: ! 710: break; ! 711: default: ! 712: freeb(bp); ! 713: error(Ehungup); ! 714: } ! 715: ! 716: tcb->sndcnt += blen(bp); ! 717: if(tcb->sndcnt > Streamhi) ! 718: tcb->sndfull = 1; ! 719: if(tcb->sndq == 0) ! 720: tcb->sndq = bp; ! 721: else { ! 722: for(f = tcb->sndq; f->next; f = f->next) ! 723: ; ! 724: f->next = bp; ! 725: } ! 726: tcprcvwin(s); ! 727: tcpoutput(s); ! 728: poperror(); ! 729: qunlock(tcb); ! 730: break; ! 731: ! 732: case Close_wait: ! 733: default: ! 734: freeb(bp); ! 735: error(Ehungup); ! 736: } ! 737: } ! 738: ! 739: void ! 740: tcpstopen(Queue *q, Stream *s) ! 741: { ! 742: Ipconv *ipc; ! 743: Ipifc *ifc; ! 744: Tcpctl *tcb; ! 745: Block *bp; ! 746: static int tcpkprocs; ! 747: ! 748: /* Flow control and tcp timer processes */ ! 749: if(tcpkprocs == 0) { ! 750: tcpkprocs = 1; ! 751: kproc("tcpack", tcpackproc, 0); ! 752: kproc("tcpflow", tcpflow, ipifc[s->dev]); ! 753: ! 754: } ! 755: ! 756: if(tcpbase == 0) ! 757: tcpbase = ipifc[s->dev]->conv; ! 758: ifc = ipifc[s->dev]; ! 759: initipifc(ifc, IP_TCPPROTO, tcpinput); ! 760: ipc = ipcreateconv(ifc, s->id); ! 761: ! 762: ipc->readq = RD(q); ! 763: ipc->readq->rp = &tcpflowr; ! 764: ipc->err = 0; ! 765: ! 766: RD(q)->ptr = (void *)ipc; ! 767: WR(q)->ptr = (void *)ipc; ! 768: ! 769: /* pass any waiting data upstream */ ! 770: tcb = &ipc->tcpctl; ! 771: qlock(tcb); ! 772: while(bp = getb(&tcb->rcvq)) ! 773: PUTNEXT(ipc->readq, bp); ! 774: qunlock(tcb); ! 775: } ! 776: ! 777: void ! 778: ipremotefill(Chan *c, char *buf, int len) ! 779: { ! 780: Ipconv *cp; ! 781: ! 782: if(len < 24) ! 783: error(Ebadarg); ! 784: cp = ipcreateconv(ipifc[c->dev], STREAMID(c->qid.path)); ! 785: sprint(buf, "%d.%d.%d.%d!%d\n", fmtaddr(cp->dst), cp->pdst); ! 786: } ! 787: ! 788: void ! 789: iplocalfill(Chan *c, char *buf, int len) ! 790: { ! 791: Ipconv *cp; ! 792: ! 793: if(len < 24) ! 794: error(Ebadarg); ! 795: cp = ipcreateconv(ipifc[c->dev], STREAMID(c->qid.path)); ! 796: sprint(buf, "%d.%d.%d.%d!%d\n", fmtaddr(ipd[0].Myip[Myself]), cp->psrc); ! 797: } ! 798: ! 799: void ! 800: ipstatusfill(Chan *c, char *buf, int len) ! 801: { ! 802: Ipconv *cp; ! 803: int connection; ! 804: ! 805: if(len < 64) ! 806: error(Ebadarg); ! 807: connection = STREAMID(c->qid.path); ! 808: cp = ipcreateconv(ipifc[c->dev], connection); ! 809: if(cp->ifc->protop == &tcpinfo) ! 810: sprint(buf, "tcp/%d %d %s %s %s %d+%d\n", connection, cp->ref, ! 811: tcpstate[cp->tcpctl.state], ! 812: cp->tcpctl.flags & CLONE ? "listen" : "connect", ! 813: cp->text, ! 814: cp->tcpctl.srtt, cp->tcpctl.mdev); ! 815: else if(cp->ifc->protop == &ilinfo) ! 816: sprint(buf, "il/%d %d %s rtt %d ms %d csum\n", connection, cp->ref, ! 817: ilstate[cp->ilctl.state], cp->ilctl.rtt, ! 818: cp->ifc ? cp->ifc->chkerrs : 0); ! 819: else ! 820: sprint(buf, "%s/%d %d Datagram\n", ! 821: cp->ifc->protop->name, connection, cp->ref); ! 822: } ! 823: ! 824: int ! 825: iphavecon(Ipconv *s) ! 826: { ! 827: return s->curlog; ! 828: } ! 829: ! 830: int ! 831: iplisten(Chan *c) ! 832: { ! 833: Ipconv *s; ! 834: int connection; ! 835: Ipconv **p, **etab, *new; ! 836: ! 837: connection = STREAMID(c->qid.path); ! 838: s = ipcreateconv(ipifc[c->dev], connection); ! 839: ! 840: if(s->ifc->protop == &tcpinfo) ! 841: if(s->tcpctl.state != Listen) ! 842: error(Enolisten); ! 843: ! 844: if(s->ifc->protop == &ilinfo) ! 845: if(s->ilctl.state != Illistening) ! 846: error(Enolisten); ! 847: ! 848: for(;;) { ! 849: qlock(&s->listenq); /* single thread for the sleep */ ! 850: if(waserror()) { ! 851: qunlock(&s->listenq); ! 852: nexterror(); ! 853: } ! 854: sleep(&s->listenr, iphavecon, s); ! 855: poperror(); ! 856: etab = &ipifc[c->dev]->conv[Nipconv]; ! 857: for(p = ipifc[c->dev]->conv; p < etab; p++) { ! 858: new = *p; ! 859: if(new == 0) ! 860: break; ! 861: if(new->newcon == s) { ! 862: qlock(s); ! 863: s->curlog--; ! 864: qunlock(s); ! 865: new->newcon = 0; ! 866: qunlock(&s->listenq); ! 867: return new->id; ! 868: } ! 869: } ! 870: qunlock(&s->listenq); ! 871: print("iplisten: no newcon\n"); ! 872: } ! 873: return -1; /* not reached */ ! 874: } ! 875: ! 876: void ! 877: tcpstclose(Queue *q) ! 878: { ! 879: Ipconv *s, *new; ! 880: Ipconv **etab, **p; ! 881: Tcpctl *tcb; ! 882: ! 883: s = (Ipconv *)(q->ptr); ! 884: tcb = &s->tcpctl; ! 885: ! 886: /* Not interested in data anymore */ ! 887: qlock(s); ! 888: s->readq = 0; ! 889: qunlock(s); ! 890: ! 891: switch(tcb->state){ ! 892: case Listen: ! 893: /* ! 894: * reset any incoming calls to this listener ! 895: */ ! 896: qlock(s); ! 897: s->backlog = 0; ! 898: s->curlog = 0; ! 899: etab = &tcpbase[Nipconv]; ! 900: for(p = tcpbase; p < etab; p++){ ! 901: new = *p; ! 902: if(new == 0) ! 903: break; ! 904: if(new->newcon == s){ ! 905: new->newcon = 0; ! 906: tcpflushincoming(new); ! 907: new->ref = 0; ! 908: } ! 909: } ! 910: qunlock(s); ! 911: ! 912: qlock(tcb); ! 913: localclose(s, 0); ! 914: qunlock(tcb); ! 915: break; ! 916: ! 917: case Closed: ! 918: case Syn_sent: ! 919: qlock(tcb); ! 920: localclose(s, 0); ! 921: qunlock(tcb); ! 922: break; ! 923: ! 924: case Syn_received: ! 925: case Established: ! 926: tcb->sndcnt++; ! 927: tcb->snd.nxt++; ! 928: tcpsetstate(s, Finwait1); ! 929: goto output; ! 930: ! 931: case Close_wait: ! 932: tcb->sndcnt++; ! 933: tcb->snd.nxt++; ! 934: tcpsetstate(s, Last_ack); ! 935: output: ! 936: qlock(tcb); ! 937: if(waserror()) { ! 938: qunlock(tcb); ! 939: nexterror(); ! 940: } ! 941: tcpoutput(s); ! 942: poperror(); ! 943: qunlock(tcb); ! 944: break; ! 945: } ! 946: } ! 947: ! 948: ! 949: static short endian = 1; ! 950: static char* aendian = (char*)&endian; ! 951: #define LITTLE *aendian ! 952: ! 953: ushort ! 954: ptcl_bsum(uchar *addr, int len) ! 955: { ! 956: ulong losum, hisum, mdsum, x; ! 957: ulong t1, t2; ! 958: ! 959: losum = 0; ! 960: hisum = 0; ! 961: mdsum = 0; ! 962: ! 963: x = 0; ! 964: if((ulong)addr & 1) { ! 965: if(len) { ! 966: hisum += addr[0]; ! 967: len--; ! 968: addr++; ! 969: } ! 970: x = 1; ! 971: } ! 972: while(len >= 16) { ! 973: t1 = *(ushort*)(addr+0); ! 974: t2 = *(ushort*)(addr+2); mdsum += t1; ! 975: t1 = *(ushort*)(addr+4); mdsum += t2; ! 976: t2 = *(ushort*)(addr+6); mdsum += t1; ! 977: t1 = *(ushort*)(addr+8); mdsum += t2; ! 978: t2 = *(ushort*)(addr+10); mdsum += t1; ! 979: t1 = *(ushort*)(addr+12); mdsum += t2; ! 980: t2 = *(ushort*)(addr+14); mdsum += t1; ! 981: mdsum += t2; ! 982: len -= 16; ! 983: addr += 16; ! 984: } ! 985: while(len >= 2) { ! 986: mdsum += *(ushort*)addr; ! 987: len -= 2; ! 988: addr += 2; ! 989: } ! 990: if(x) { ! 991: if(len) ! 992: losum += addr[0]; ! 993: if(LITTLE) ! 994: losum += mdsum; ! 995: else ! 996: hisum += mdsum; ! 997: } else { ! 998: if(len) ! 999: hisum += addr[0]; ! 1000: if(LITTLE) ! 1001: hisum += mdsum; ! 1002: else ! 1003: losum += mdsum; ! 1004: } ! 1005: ! 1006: losum += hisum >> 8; ! 1007: losum += (hisum & 0xff) << 8; ! 1008: while(hisum = losum>>16) ! 1009: losum = hisum + (losum & 0xffff); ! 1010: ! 1011: return losum & 0xffff; ! 1012: } ! 1013: ! 1014: ushort ! 1015: ptcl_csum(Block *bp, int offset, int len) ! 1016: { ! 1017: uchar *addr; ! 1018: ulong losum, hisum; ! 1019: ushort csum; ! 1020: int odd, blen, x; ! 1021: ! 1022: /* Correct to front of data area */ ! 1023: while(bp && offset && offset >= BLEN(bp)) { ! 1024: offset -= BLEN(bp); ! 1025: bp = bp->next; ! 1026: } ! 1027: if(bp == 0) ! 1028: return 0; ! 1029: ! 1030: addr = bp->rptr + offset; ! 1031: blen = BLEN(bp) - offset; ! 1032: ! 1033: if(bp->next == 0) ! 1034: return ~ptcl_bsum(addr, MIN(len, blen)) & 0xffff; ! 1035: ! 1036: losum = 0; ! 1037: hisum = 0; ! 1038: ! 1039: odd = 0; ! 1040: while(len) { ! 1041: x = MIN(len, blen); ! 1042: csum = ptcl_bsum(addr, x); ! 1043: if(odd) ! 1044: hisum += csum; ! 1045: else ! 1046: losum += csum; ! 1047: odd = (odd+x) & 1; ! 1048: len -= x; ! 1049: ! 1050: bp = bp->next; ! 1051: if(bp == 0) ! 1052: break; ! 1053: blen = BLEN(bp); ! 1054: addr = bp->rptr; ! 1055: } ! 1056: ! 1057: losum += hisum>>8; ! 1058: losum += (hisum&0xff)<<8; ! 1059: while((csum = losum>>16) != 0) ! 1060: losum = csum + (losum & 0xffff); ! 1061: ! 1062: return ~losum & 0xffff; ! 1063: } ! 1064: ! 1065: Block * ! 1066: btrim(Block *bp, int offset, int len) ! 1067: { ! 1068: Block *nb, *startb; ! 1069: ulong l; ! 1070: ! 1071: if(blen(bp) < offset+len) { ! 1072: freeb(bp); ! 1073: return 0; ! 1074: } ! 1075: ! 1076: while((l = BLEN(bp)) < offset) { ! 1077: offset -= l; ! 1078: nb = bp->next; ! 1079: bp->next = 0; ! 1080: freeb(bp); ! 1081: bp = nb; ! 1082: } ! 1083: ! 1084: startb = bp; ! 1085: bp->rptr += offset; ! 1086: ! 1087: while((l = BLEN(bp)) < len) { ! 1088: len -= l; ! 1089: bp = bp->next; ! 1090: } ! 1091: ! 1092: bp->wptr -= (BLEN(bp) - len); ! 1093: bp->flags |= S_DELIM; ! 1094: ! 1095: if(bp->next) { ! 1096: freeb(bp->next); ! 1097: bp->next = 0; ! 1098: } ! 1099: ! 1100: return(startb); ! 1101: } ! 1102: ! 1103: Ipconv * ! 1104: portused(Ipifc *ifc, Port port) ! 1105: { ! 1106: Ipconv **p, **etab; ! 1107: Ipconv *cp; ! 1108: ! 1109: if(port == 0) ! 1110: return 0; ! 1111: ! 1112: etab = &ifc->conv[Nipconv]; ! 1113: for(p = ifc->conv; p < etab; p++){ ! 1114: cp = *p; ! 1115: if(cp == 0) ! 1116: break; ! 1117: if(cp->psrc == port) ! 1118: return cp; ! 1119: } ! 1120: ! 1121: return 0; ! 1122: } ! 1123: ! 1124: static Port lastport[2] = { PORTALLOC-1, PRIVPORTALLOC-1 }; ! 1125: ! 1126: Port ! 1127: nextport(Ipifc *ifc, int priv) ! 1128: { ! 1129: Port base; ! 1130: Port max; ! 1131: Port *p; ! 1132: Port i; ! 1133: ! 1134: if(priv){ ! 1135: base = PRIVPORTALLOC; ! 1136: max = UNPRIVPORTALLOC; ! 1137: p = &lastport[1]; ! 1138: } else { ! 1139: base = PORTALLOC; ! 1140: max = PORTMAX; ! 1141: p = &lastport[0]; ! 1142: } ! 1143: ! 1144: for(i = *p + 1; i < max; i++) ! 1145: if(!portused(ifc, i)) ! 1146: return(*p = i); ! 1147: for(i = base ; i <= *p; i++) ! 1148: if(!portused(ifc, i)) ! 1149: return(*p = i); ! 1150: ! 1151: return(0); ! 1152: } ! 1153: ! 1154: /* NEEDS HASHING ! */ ! 1155: ! 1156: Ipconv* ! 1157: ip_conn(Ipifc *ifc, Port dst, Port src, Ipaddr dest) ! 1158: { ! 1159: Ipconv **p, *s, **etab; ! 1160: ! 1161: /* Look for a conversation structure for this port */ ! 1162: etab = &ifc->conv[Nipconv]; ! 1163: for(p = ifc->conv; p < etab; p++) { ! 1164: s = *p; ! 1165: if(s == 0) ! 1166: break; ! 1167: if(s->psrc == dst) ! 1168: if(s->pdst == src) ! 1169: if(s->dst == dest || dest == 0) ! 1170: return s; ! 1171: } ! 1172: ! 1173: return 0; ! 1174: } ! 1175: ! 1176: /* ! 1177: * ! 1178: * BSD authentication protocol, used on ports 512, 513, & 514. ! 1179: * This makes sure that a user can only write the REAL user id. ! 1180: * ! 1181: * q->ptr is number of nulls seen ! 1182: */ ! 1183: void ! 1184: bsdopen(Queue *q, Stream *s) ! 1185: { ! 1186: USED(s); ! 1187: RD(q)->ptr = q; ! 1188: WR(q)->ptr = q; ! 1189: } ! 1190: void ! 1191: bsdclose(Queue *q) ! 1192: { ! 1193: Block *bp; ! 1194: ! 1195: bp = allocb(0); ! 1196: bp->type = M_HANGUP; ! 1197: PUTNEXT(q->other, bp); ! 1198: } ! 1199: void ! 1200: bsdiput(Queue *q, Block *bp) ! 1201: { ! 1202: PUTNEXT(q, bp); ! 1203: } ! 1204: void ! 1205: bsdoput(Queue *q, Block *bp) ! 1206: { ! 1207: uchar *luser; ! 1208: Block *nbp; ! 1209: ! 1210: /* just pass it on if we've done authentication */ ! 1211: if(q->ptr == 0 || bp->type != M_DATA){ ! 1212: PUTNEXT(q, bp); ! 1213: return; ! 1214: } ! 1215: ! 1216: /* collect into a single block */ ! 1217: qlock(&q->rlock); ! 1218: if(q->first == 0) ! 1219: q->first = pullup(bp, blen(bp)); ! 1220: else{ ! 1221: nbp = q->first; ! 1222: nbp->next = bp; ! 1223: q->first = pullup(nbp, blen(nbp)); ! 1224: } ! 1225: bp = q->first; ! 1226: if(bp == 0){ ! 1227: qunlock(&q->rlock); ! 1228: bsdclose(q); ! 1229: return; ! 1230: } ! 1231: ! 1232: /* look for 2 nulls to indicate stderr port and local user */ ! 1233: luser = memchr(bp->rptr, 0, BLEN(bp)); ! 1234: if(luser == 0){ ! 1235: qunlock(&q->rlock); ! 1236: return; ! 1237: } ! 1238: luser++; ! 1239: if(memchr(luser, 0, bp->wptr - luser) == 0){ ! 1240: qunlock(&q->rlock); ! 1241: return; ! 1242: } ! 1243: ! 1244: /* if luser is a lie, hangup */ ! 1245: if(memcmp(luser, u->p->user, strlen(u->p->user)+1) != 0) ! 1246: bsdclose(q); ! 1247: ! 1248: /* mark queue as authenticated and pass data to remote side */ ! 1249: q->ptr = 0; ! 1250: q->first = 0; ! 1251: bp->flags |= S_DELIM; ! 1252: PUTNEXT(q, bp); ! 1253: qunlock(&q->rlock); ! 1254: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.