## diffname port/tcpinput.c 1991/0424
## diff -e /dev/null /n/bootesdump/1991/0424/sys/src/9/port/tcpinput.c
0a
#include "u.h"
#include "lib.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
#include "errno.h"
#include "arp.h"
#include "ipdat.h"
int tcpdbg = 0;
#define DPRINT if(tcpdbg) print
#define LPRINT print
extern Queue *Tcpoutput;
QLock reseqlock;
Reseq *reseqfree;
char *tcpstate[] = {
"Closed", "Listen", "Syn_sent", "Syn_received",
"Established", "Finwait1", "Finwait2", "Close_wait",
"Closing", "Last_ack", "Time_wait" };
void
tcp_input(Ipconv *ipc, Block *bp)
{
Ipconv *s, *new, *etab;
Tcpctl *tcb;
Tcphdr *h;
Tcp seg;
int hdrlen;
Block *oobbp;
Ipaddr source, dest;
char tos;
ushort length;
DPRINT("tcp_input.\n");
h = (Tcphdr *)(bp->rptr);
dest = nhgetl(h->tcpdst);
source = nhgetl(h->tcpsrc);
tos = h->tos;
length = nhgets(h->length);
if (dest == source) {
if (!(bp = copyb(bp, blen(bp)))) {
print("tcpin: allocb failure.");
return;
}
DPRINT("tcpin: Duplicate packet %lux\n", bp);
}
h->Unused = 0;
hnputs(h->tcplen, length - (TCP_IPLEN+TCP_PHDRSIZE));
if(ptcl_csum(bp, TCP_EHSIZE+TCP_IPLEN, length - TCP_IPLEN)) {
DPRINT("tcpin: Bad checksum.\n");
freeb(bp);
return;
}
if((hdrlen = ntohtcp(&seg, &bp)) < 0)
return;
/* Adjust the data length */
length -= (hdrlen+TCP_IPLEN+TCP_PHDRSIZE);
DPRINT("tcpin: lport = %d, rport = %d hdrlen %d",
seg.dest, seg.source, hdrlen);
DPRINT(" flags = 0x%lux, seqo = %d, seqi = %d len %d\n",
seg.flags, seg.seq, seg.ack, length);
/* Trim the packet down to just the data */
bp = btrim(bp, hdrlen+TCP_PKT, length);
if(bp == 0)
return;
if (!(s = ip_conn(ipc, seg.dest, seg.source, source, IP_TCPPROTO))) {
LPRINT("tcpin: look for listen on %d\n", seg.dest);
if(!(seg.flags & SYN)) {
LPRINT("tcpin: No SYN\n");
clear:
LPRINT("tcpin: call cleared\n");
freeb(bp);
reset(source, dest, tos, length, &seg);
return;
}
if(!(s = ip_conn(ipc, seg.dest, 0, 0, IP_TCPPROTO))) {
LPRINT("tcpin: No socket dest on %d\n", seg.dest);
goto clear;
}
if(s->curlog >= s->backlog) {
LPRINT("too many pending\n");
goto clear;
}
/* Find a conversation to clone onto */
etab = &ipc[conf.ip];
for(new = ipc; new < etab; new++) {
if(new->ref == 0 && canqlock(new)) {
if(new->ref || new->tcpctl.state != CLOSED) {
qunlock(new);
continue;
}
new->ref++;
qunlock(new);
break;
}
}
if(new == etab)
goto clear;
s->curlog++;
LPRINT("tcpin: cloning socket\n");
new->psrc = s->psrc;
new->pdst = seg.source;
new->dst = source;
memmove(&new->tcpctl, &s->tcpctl, sizeof(Tcpctl));
new->tcpctl.flags &= ~CLONE;
new->tcpctl.timer.arg = new;
new->tcpctl.timer.state = TIMER_STOP;
new->tcpctl.acktimer.arg = new;
new->tcpctl.acktimer.state = TIMER_STOP;
new->ipinterface = s->ipinterface;
s->ipinterface->ref++;
/* Wake the sleeping dodo */
wakeup(&s->listenr);
s = new;
}
tcb = &s->tcpctl;
qlock(tcb);
switch(tcb->state) {
case CLOSED:
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
case LISTEN:
if(seg.flags & RST) {
freeb(bp);
goto done;
}
if(seg.flags & ACK) {
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
}
if(seg.flags & SYN) {
proc_syn(s, tos, &seg);
send_syn(tcb);
setstate(s, SYN_RECEIVED);
if(length != 0 || (seg.flags & FIN))
break;
freeb(bp);
goto output;
}
freeb(bp);
goto done;
case SYN_SENT:
if(seg.flags & ACK) {
if(!seq_within(seg.ack, tcb->iss+1, tcb->snd.nxt)) {
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
}
}
if(seg.flags & RST) {
if(seg.flags & ACK)
close_self(s, Econrefused);
freeb(bp);
goto done;
}
if((seg.flags & ACK) && PREC(tos) != PREC(tcb->tos)){
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
}
if(seg.flags & SYN) {
proc_syn(s, tos, &seg);
if(seg.flags & ACK){
update(s, &seg);
setstate(s, ESTABLISHED);
}
else
setstate(s, SYN_RECEIVED);
if(length != 0 || (seg.flags & FIN))
break;
freeb(bp);
goto output;
}
else
freeb(bp);
goto done;
}
/* Trim segment to fit receive window. */
if(trim(tcb, &seg, &bp, &length) == -1) {
if(!(seg.flags & RST)) {
tcb->flags |= FORCE;
goto output;
}
goto done;
}
/* If we have no opens and the other end is sending data then
* reply with a reset
*/
if(s->readq == 0 && length) {
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
}
if(seg.seq != tcb->rcv.nxt
&& (length != 0 || (seg.flags & (SYN|FIN)) )) {
add_reseq(tcb, tos, &seg, bp, length);
tcb->flags |= FORCE;
goto output;
}
for(;;) {
if(seg.flags & RST) {
if(tcb->state == SYN_RECEIVED
&& !(tcb->flags & (CLONE|ACTIVE)))
setstate(s, LISTEN);
else
close_self(s, Econrefused);
freeb(bp);
goto done;
}
if(PREC(tos) != PREC(tcb->tos) || (seg.flags & SYN)){
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
}
if(!(seg.flags & ACK)) {
freeb(bp);
goto done;
}
switch(tcb->state) {
case SYN_RECEIVED:
if(seq_within(seg.ack, tcb->snd.una+1, tcb->snd.nxt)){
update(s, &seg);
setstate(s, ESTABLISHED);
}
else {
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
}
break;
case ESTABLISHED:
case CLOSE_WAIT:
update(s, &seg);
break;
case FINWAIT1:
update(s, &seg);
if(tcb->sndcnt == 0)
setstate(s, FINWAIT2);
break;
case FINWAIT2:
update(s, &seg);
break;
case CLOSING:
update(s, &seg);
if(tcb->sndcnt == 0){
setstate(s, TIME_WAIT);
tcb->timer.start = MSL2 * (1000 / MSPTICK);
start_timer(&tcb->timer);
}
break;
case LAST_ACK:
update(s, &seg);
if(tcb->sndcnt == 0) {
close_self(s, 0);
goto done;
}
case TIME_WAIT:
tcb->flags |= FORCE;
start_timer(&tcb->timer);
}
if ((seg.flags&URG) && seg.up) {
DPRINT("tcpin: oob: up = %u seq = %u rcv.up = %u\n",
seg.up, seg.seq, tcb->rcv.up);
if (seq_gt(seg.up + seg.seq, tcb->rcv.up)) {
tcb->rcv.up = seg.up + seg.seq;
tcb->oobflags &= ~(TCPOOB_HAVEDATA|TCPOOB_HADDATA);
extract_oob(&bp, &oobbp, &seg);
if (oobbp) {
DPRINT("tcpin: oob delivered\n");
appendb(&tcb->rcvoobq, oobbp);
tcb->rcvoobcnt += blen(oobbp);
tcb->oobmark = tcb->rcvcnt;
tcb->oobflags |= TCPOOB_HAVEDATA;
#ifdef NOTIFY
urg_signal(s);
#endif
}
}
}
else if (seq_gt(tcb->rcv.nxt, tcb->rcv.up))
tcb->rcv.up = tcb->rcv.nxt;
DPRINT("tcpin: Append pkt len=%d state=%s\n",
length, tcpstate[tcb->state]);
if(length != 0){
switch(tcb->state){
case SYN_RECEIVED:
case ESTABLISHED:
case FINWAIT1:
case FINWAIT2:
/* Place on receive queue */
tcb->rcvcnt += blen(bp);
if(s->readq && bp) {
PUTNEXT(s->readq, bp);
bp = 0;
}
tcb->rcv.nxt += length;
tcprcvwin(s);
start_timer(&tcb->acktimer);
if (tcb->max_snd <= tcb->rcv.nxt-tcb->last_ack)
tcb->flags |= FORCE;
break;
default:
/* Ignore segment text */
freeb(bp);
break;
}
}
if(seg.flags & FIN) {
tcb->flags |= FORCE;
switch(tcb->state) {
case SYN_RECEIVED:
case ESTABLISHED:
tcb->rcv.nxt++;
setstate(s, CLOSE_WAIT);
break;
case FINWAIT1:
tcb->rcv.nxt++;
if(tcb->sndcnt == 0) {
setstate(s, TIME_WAIT);
tcb->timer.start = MSL2 * (1000/MSPTICK);
start_timer(&tcb->timer);
}
else
setstate(s, CLOSING);
break;
case FINWAIT2:
tcb->rcv.nxt++;
setstate(s, TIME_WAIT);
tcb->timer.start = MSL2 * (1000/MSPTICK);
start_timer(&tcb->timer);
break;
case CLOSE_WAIT:
case CLOSING:
case LAST_ACK:
break;
case TIME_WAIT:
start_timer(&tcb->timer);
break;
}
}
while(tcb->reseq != 0 &&
seq_ge(tcb->rcv.nxt, tcb->reseq->seg.seq)){
get_reseq(tcb, &tos, &seg, &bp, &length);
if(trim(tcb, &seg, &bp, &length) == 0)
goto gotone;
}
break;
gotone:;
}
output:
tcp_output(s);
done:
qunlock(tcb);
}
void
tcp_icmp(Ipconv *ipc, Ipaddr source, Ipaddr dest, char type, char code, Block **bpp)
{
Tcp seg;
Tcpctl *tcb;
Ipconv *s;
ntohtcp(&seg, bpp);
if(!(s = ip_conn(ipc, seg.source, seg.dest, dest, IP_TCPPROTO)))
return;
tcb = &s->tcpctl;
if(!seq_within(seg.seq, tcb->snd.una, tcb->snd.nxt))
return;
switch((uchar)type) {
case ICMP_UNREACH:
tcb->type = type;
tcb->code = code;
if(tcb->state == SYN_SENT || tcb->state == SYN_RECEIVED)
close_self(s, Enetunreach);
break;
case ICMP_TIMXCEED:
tcb->type = type;
tcb->code = code;
if(tcb->state == SYN_SENT || tcb->state == SYN_RECEIVED)
close_self(s, Etimedout);
break;
case ICMP_SOURCEQUENCH:
tcb->cwind /= 2;
tcb->cwind = MAX(tcb->mss,tcb->cwind);
break;
}
}
void
reset(Ipaddr source, Ipaddr dest, char tos, ushort length, Tcp *seg)
{
Block *hbp;
Port tmp;
char rflags;
Tcphdr ph;
if(seg->flags & RST)
return;
hnputl(ph.tcpsrc, dest);
hnputl(ph.tcpdst, source);
ph.proto = IP_TCPPROTO;
hnputs(ph.tcplen, TCP_HDRSIZE);
/* Swap port numbers */
tmp = seg->dest;
seg->dest = seg->source;
seg->source = tmp;
rflags = RST;
if(seg->flags & ACK) {
/* This reset is being sent to clear a half-open connection.
* Set the sequence number of the RST to the incoming ACK
* so it will be acceptable.
*/
seg->seq = seg->ack;
seg->ack = 0;
}
else {
/* We're rejecting a connect request (SYN) from LISTEN state
* so we have to "acknowledge" their SYN.
*/
rflags |= ACK;
seg->ack = seg->seq;
seg->seq = 0;
if(seg->flags & SYN)
seg->ack++;
seg->ack += length;
if(seg->flags & FIN)
seg->ack++;
}
seg->flags = rflags;
seg->wnd = 0;
seg->up = 0;
seg->mss = 0;
if((hbp = htontcp(seg, 0, &ph)) == 0)
return;
DPRINT("Reset: seq = %lux ack = %d flags = %lux\n",
seg->seq, seg->ack, seg->flags);
PUTNEXT(Tcpoutput, hbp);
}
void
update(Ipconv *s, Tcp *seg)
{
ushort acked;
ushort oobacked;
ushort expand;
Tcpctl *tcb = &s->tcpctl;
if(seq_gt(seg->ack, tcb->snd.nxt)) {
tcb->flags |= FORCE;
return;
}
if(seq_gt(seg->seq,tcb->snd.wl1) || ((seg->seq == tcb->snd.wl1)
&& seq_ge(seg->ack,tcb->snd.wl2))) {
if(tcb->snd.wnd == 0 && seg->wnd != 0)
tcb->snd.ptr = tcb->snd.una;
tcb->snd.wnd = seg->wnd;
tcb->snd.wl1 = seg->seq;
tcb->snd.wl2 = seg->ack;
}
if(!seq_gt(seg->ack, tcb->snd.una))
return;
acked = seg->ack - tcb->snd.una;
if(tcb->cwind < tcb->snd.wnd) {
if(tcb->cwind < tcb->ssthresh)
expand = MIN(acked,tcb->mss);
else
expand = ((long)tcb->mss * tcb->mss) / tcb->cwind;
if(tcb->cwind + expand < tcb->cwind)
expand = 65535 - tcb->cwind;
if(tcb->cwind + expand > tcb->snd.wnd)
expand = tcb->snd.wnd - tcb->cwind;
if(expand != 0)
tcb->cwind += expand;
}
/* Round trip time estimation */
if(run_timer(&tcb->rtt_timer) && seq_ge(seg->ack, tcb->rttseq)) {
stop_timer(&tcb->rtt_timer);
if(!(tcb->flags & RETRAN)) {
int rtt; /* measured round trip time */
int abserr; /* abs(rtt - srtt) */
rtt = tcb->rtt_timer.start - tcb->rtt_timer.count;
rtt *= MSPTICK;
if(rtt > tcb->srtt &&
(tcb->state == SYN_SENT || tcb->state == SYN_RECEIVED))
tcb->srtt = rtt;
else {
abserr = (rtt > tcb->srtt) ? rtt - tcb->srtt : tcb->srtt - rtt;
tcb->srtt = ((AGAIN-1)*tcb->srtt + rtt) / AGAIN;
tcb->mdev = ((DGAIN-1)*tcb->mdev + abserr) / DGAIN;
DPRINT("tcpout: rtt %d, srtt %d, mdev %d\n",
rtt, tcb->srtt, tcb->mdev);
}
tcb->backoff = 0;
}
}
/* If we're waiting for an ack of our SYN, note it and adjust count */
if(!(tcb->flags & SYNACK)){
tcb->flags |= SYNACK;
acked--;
tcb->sndcnt--;
}
/* Acking some oob data if relevant */
if(tcb->sndoobq && seq_ge(tcb->snd.up,tcb->snd.una) &&
seq_gt(seg->ack, tcb->snd.up)) {
oobacked = seg->ack - tcb->snd.up;
acked -= oobacked;
copyupb(&tcb->sndoobq, 0, oobacked);
tcb->sndoobcnt -= oobacked;
DPRINT("update: oobacked = %d\n", oobacked);
}
copyupb(&tcb->sndq, 0, acked);
/* This will include the FIN if there is one */
tcb->sndcnt -= acked;
tcb->snd.una = seg->ack;
/* If ack includes some out-of-band data then update urgent pointer */
if (seq_gt(seg->ack, tcb->snd.up))
tcb->snd.up = seg->ack;
/* Stop retransmission timer, but restart it if there is still
* unacknowledged data.
*/
stop_timer(&tcb->timer);
if(tcb->snd.una != tcb->snd.nxt)
start_timer(&tcb->timer);
/* If retransmissions have been occurring, make sure the
* send pointer doesn't repeat ancient history
*/
if(seq_lt(tcb->snd.ptr, tcb->snd.una))
tcb->snd.ptr = tcb->snd.una;
/* Clear the retransmission flag since the oldest
* unacknowledged segment (the only one that is ever retransmitted)
* has now been acked.
*/
tcb->flags &= ~RETRAN;
tcb->backoff = 0;
}
int
in_window(Tcpctl *tcb, int seq)
{
return seq_within(seq, tcb->rcv.nxt,
(int)(tcb->rcv.nxt+tcb->rcv.wnd-1));
}
void
proc_syn(Ipconv *s, char tos, Tcp *seg)
{
Tcpctl *tcb = &s->tcpctl;
ushort mtu;
tcb->flags |= FORCE;
if(PREC(tos) > PREC(tcb->tos))
tcb->tos = tos;
tcb->rcv.up = tcb->rcv.nxt = seg->seq + 1; /* p 68 */
tcb->snd.wl1 = tcb->irs = seg->seq;
tcb->snd.wnd = seg->wnd;
if(seg->mss != 0)
tcb->mss = seg->mss;
tcb->max_snd = seg->wnd;
if((mtu = s->ipinterface->maxmtu) != 0) {
mtu -= TCP_HDRSIZE + TCP_EHSIZE + TCP_PHDRSIZE;
tcb->cwind = tcb->mss = MIN(mtu, tcb->mss);
}
}
/* Generate an initial sequence number and put a SYN on the send queue */
void
send_syn(Tcpctl *tcb)
{
tcb->iss = iss();
tcb->rttseq = tcb->snd.wl2 = tcb->snd.una = tcb->iss;
tcb->snd.ptr = tcb->snd.nxt = tcb->rttseq;
tcb->sndcnt++;
tcb->flags |= FORCE;
}
void
add_reseq(Tcpctl *tcb, char tos, Tcp *seg, Block *bp, ushort length)
{
Reseq *rp, *rp1;
qlock(&reseqlock);
if(!reseqfree) {
qunlock(&reseqlock);
print("tcp: no resequence descriptors\n");
freeb(bp);
return;
}
rp = reseqfree;
reseqfree = rp->next;
qunlock(&reseqlock);
rp->seg = *seg;
rp->tos = tos;
rp->bp = bp;
rp->length = length;
/* Place on reassembly list sorting by starting seq number */
rp1 = tcb->reseq;
if(rp1 == 0 || seq_lt(seg->seq, rp1->seg.seq)) {
rp->next = rp1;
tcb->reseq = rp;
}
else {
for(;;){
if(rp1->next == 0 ||
seq_lt(seg->seq, rp1->next->seg.seq)) {
rp->next = rp1->next;
rp1->next = rp;
break;
}
rp1 = rp1->next;
}
}
}
void
get_reseq(Tcpctl *tcb, char *tos, Tcp *seg, Block **bp, ushort *length)
{
Reseq *rp;
if((rp = tcb->reseq) == 0)
return;
tcb->reseq = rp->next;
*tos = rp->tos;
*seg = rp->seg;
*bp = rp->bp;
*length = rp->length;
qlock(&reseqlock);
rp->next = reseqfree;
reseqfree = rp;
qunlock(&reseqlock);
}
int
trim(Tcpctl *tcb, Tcp *seg, Block **bp, ushort *length)
{
Block *nbp;
long dupcnt,excess;
ushort len; /* Segment length including flags */
char accept;
accept = 0;
len = *length;
if(seg->flags & SYN)
len++;
if(seg->flags & FIN)
len++;
/* Acceptability tests */
if(tcb->rcv.wnd == 0) {
if(seg->seq == tcb->rcv.nxt && len == 0)
return 0;
} else {
/* Some part of the segment must be in the window */
if(in_window(tcb,seg->seq)) {
accept++;
}
else if(len != 0) {
if(in_window(tcb, (int)(seg->seq+len-1)) ||
seq_within(tcb->rcv.nxt, seg->seq,(int)(seg->seq+len-1)))
accept++;
}
}
if(!accept) {
freeb(*bp);
return -1;
}
dupcnt = tcb->rcv.nxt - seg->seq;
if(dupcnt > 0){
tcb->rerecv += dupcnt;
if(seg->flags & SYN){
seg->flags &= ~SYN;
seg->seq++;
if (seg->up > 1)
seg->up--;
else
seg->flags &= ~URG;
dupcnt--;
}
if(dupcnt > 0){
copyupb(bp, 0, (ushort)dupcnt);
seg->seq += dupcnt;
*length -= dupcnt;
if (seg->up > dupcnt)
seg->up -= dupcnt;
else {
seg->flags &= ~URG;
seg->up = 0;
}
}
}
excess = seg->seq + *length - (tcb->rcv.nxt + tcb->rcv.wnd);
if(excess > 0){
tcb->rerecv += excess;
*length -= excess;
nbp = copyb(*bp, *length);
freeb(*bp);
*bp = nbp;
seg->flags &= ~FIN;
}
return 0;
}
void
extract_oob(Block **bp, Block **oobbp, Tcp *seg)
{
DPRINT("extract_oob: size = %u\n", seg->up);
if (*oobbp = allocb(seg->up))
(*oobbp)->wptr = (*oobbp)->wptr +
copyupb(bp, (*oobbp)->rptr, seg->up);
else
copyupb(bp, 0, seg->up);
}
int
copyupb(Block **bph, uchar *data, int count)
{
int n, bytes;
Block *bp;
bytes = 0;
if(bph == 0)
return 0;
while(*bph && count != 0) {
bp = *bph;
n = MIN(count, BLEN(bp));
if(data && n) {
memmove(data, bp->rptr, n);
data += n;
}
bytes += n;
count -= n;
bp->rptr += n;
if(BLEN(bp) == 0) {
*bph = bp->next;
bp->next = 0;
freeb(bp);
}
}
return bytes;
}
void
appendb(Block **list, Block *bp)
{
Block *f;
if(f = *list) {
while(f->next)
f = f->next;
f->next = bp;
}
else
*list = bp;
bp->next = 0;
}
int
dupb(Block **hp, Block *bp, int offset, int count)
{
int i, blen, bytes = 0;
uchar *addr;
*hp = allocb(count);
if(*hp == 0)
return 0;
/* Correct to front of data area */
while(bp && offset && offset >= BLEN(bp)) {
offset -= BLEN(bp);
bp = bp->next;
}
if(bp == 0)
return 0;
addr = bp->rptr + offset;
blen = BLEN(bp) - offset;
while(count) {
i = MIN(count, blen);
memmove((*hp)->wptr, addr, i);
(*hp)->wptr += i;
bytes += i;
count -= i;
bp = bp->next;
if(!bp)
break;
blen = BLEN(bp);
addr = bp->rptr;
}
return bytes;
}
Block *
copyb(Block *bp, int count)
{
Block *nbp;
int i;
nbp = allocb(count);
if(nbp == 0)
return 0;
while(bp && count) {
i = MIN(count, BLEN(bp));
memmove(nbp->wptr, bp->rptr, i);
nbp->wptr += i;
count -= i;
bp = bp->next;
}
return nbp;
}
ushort tcp_mss = DEF_MSS; /* Maximum segment size to be sent with SYN */
int tcp_irtt = DEF_RTT; /* Initial guess at round trip time */
void
init_tcpctl(Ipconv *s)
{
Tcpctl *tcb = &s->tcpctl;
memset(tcb, 0, sizeof(Tcpctl));
tcb->cwind = tcb->mss = tcp_mss;
tcb->ssthresh = 65535;
tcb->srtt = tcp_irtt;
/* Initialize timer intervals */
tcb->timer.start = tcb->srtt / MSPTICK;
tcb->timer.func = (void(*)(void*))tcp_timeout;
tcb->timer.arg = (void *)s;
tcb->rtt_timer.start = MAX_TIME;
/* Initialise ack timer */
tcb->acktimer.start = TCP_ACK / MSPTICK;
tcb->acktimer.func = (void(*)(void*))tcp_acktimer;
tcb->acktimer.arg = (void *)s;
}
void
close_self(Ipconv *s, int reason)
{
Reseq *rp,*rp1;
Tcpctl *tcb = &s->tcpctl;
stop_timer(&tcb->timer);
stop_timer(&tcb->rtt_timer);
s->err = reason;
/* Flush reassembly queue; nothing more can arrive */
for(rp = tcb->reseq;rp != 0;rp = rp1){
rp1 = rp->next;
freeb(rp->bp);
qlock(&reseqlock);
rp->next = reseqfree;
reseqfree = rp;
qunlock(&reseqlock);
}
tcb->reseq = 0;
s->err = reason;
setstate(s, CLOSED);
}
int
iss(void)
{
static int seq;
seq += 250000;
return seq;
}
int
seq_within(int x, int low, int high)
{
if(low <= high){
if(low <= x && x <= high)
return 1;
} else {
if(low >= x && x >= high)
return 1;
}
return 0;
}
int
seq_lt(int x, int y)
{
return (long)(x-y) < 0;
}
int
seq_le(int x, int y)
{
return (long)(x-y) <= 0;
}
int
seq_gt(int x, int y)
{
return (long)(x-y) > 0;
}
int
seq_ge(int x, int y)
{
return (long)(x-y) >= 0;
}
void
setstate(Ipconv *s, char newstate)
{
char oldstate;
Tcpctl *tcb = &s->tcpctl;
oldstate = tcb->state;
tcb->state = newstate;
state_upcall(s, oldstate, newstate);
}
Block *
htontcp(Tcp *tcph, Block *data, Tcphdr *ph)
{
ushort hdrlen;
int dlen;
ushort csum;
Tcphdr *h;
Block *bp;
hdrlen = TCP_HDRSIZE;
if(tcph->mss)
hdrlen += MSS_LENGTH;
if(data) {
dlen = blen(data);
if((data = padb(data, hdrlen + TCP_PKT)) == 0)
return 0;
/* If we collected blocks delimit the end of the chain */
for(bp = data; bp->next; bp = bp->next)
bp->flags &= ~S_DELIM;
bp->flags |= S_DELIM;
}
else {
dlen = 0;
data = allocb(hdrlen + TCP_PKT);
if(data == 0)
return 0;
data->wptr += hdrlen + TCP_PKT;
data->flags |= S_DELIM;
}
memmove(data->rptr, ph, TCP_PKT);
h = (Tcphdr *)(data->rptr);
h->proto = IP_TCPPROTO;
hnputs(h->tcplen, hdrlen + dlen);
hnputs(h->tcpsport, tcph->source);
hnputs(h->tcpdport, tcph->dest);
hnputl(h->tcpseq, tcph->seq);
hnputl(h->tcpack, tcph->ack);
hnputs(h->tcpflag, (hdrlen<<10) | tcph->flags);
hnputs(h->tcpwin, tcph->wnd);
h->tcpcksum[0] = 0;
h->tcpcksum[1] = 0;
h->Unused = 0;
hnputs(h->tcpurg, tcph->up);
if(tcph->mss != 0){
h->tcpopt[0] = MSS_KIND;
h->tcpopt[1] = MSS_LENGTH;
hnputs(h->tcpmss, tcph->mss);
}
csum = ptcl_csum(data, TCP_EHSIZE+TCP_IPLEN, hdrlen+dlen+TCP_PHDRSIZE);
hnputs(h->tcpcksum, csum);
return data;
}
int
ntohtcp(Tcp *tcph, Block **bpp)
{
ushort hdrlen;
ushort i, optlen;
Block *nbp;
Tcphdr *h;
uchar *optr;
*bpp = pullup(*bpp, TCP_PKT+TCP_HDRSIZE);
if(*bpp == 0)
return -1;
h = (Tcphdr *)((*bpp)->rptr);
tcph->source = nhgets(h->tcpsport);
tcph->dest = nhgets(h->tcpdport);
tcph->seq = nhgetl(h->tcpseq);
tcph->ack = nhgetl(h->tcpack);
hdrlen = (h->tcpflag[0] & 0xf0) >> 2;
if(hdrlen < TCP_HDRSIZE) {
freeb(*bpp);
return -1;
}
tcph->flags = h->tcpflag[1];
tcph->wnd = nhgets(h->tcpwin);
tcph->up = nhgets(h->tcpurg);
tcph->mss = 0;
*bpp = pullup(*bpp, hdrlen+TCP_PKT);
if(!*bpp)
return -1;
for(optr = h->tcpopt, i = TCP_HDRSIZE; i < hdrlen;) {
switch(*optr++){
case EOL_KIND:
goto eol;
case NOOP_KIND:
i++;
break;
case MSS_KIND:
optlen = *optr++;
if(optlen == MSS_LENGTH)
tcph->mss = nhgets(optr);
i += optlen;
break;
}
}
eol:
return hdrlen;
}
.
## diffname port/tcpinput.c 1991/0625
## diff -e /n/bootesdump/1991/0424/sys/src/9/port/tcpinput.c /n/bootesdump/1991/0625/sys/src/9/port/tcpinput.c
660d
## diffname port/tcpinput.c 1991/0705
## diff -e /n/bootesdump/1991/0625/sys/src/9/port/tcpinput.c /n/bootesdump/1991/0705/sys/src/9/port/tcpinput.c
659a
print("tcp: no resequence descriptors\n");
.
23a
tcpinit(void)
{
Reseq *r;
reseqfree = ialloc(sizeof(Reseq)*Nreseq, 0);
for(r = reseqfree; r < &reseqfree[Nreseq-1]; r++)
r->next = r+1;
r->next = 0;
}
void
.
## diffname port/tcpinput.c 1991/0727
## diff -e /n/bootesdump/1991/0705/sys/src/9/port/tcpinput.c /n/bootesdump/1991/0727/sys/src/9/port/tcpinput.c
12c
#define LPRINT if(tcpdbg) print
.
## diffname port/tcpinput.c 1991/0926
## diff -e /n/bootesdump/1991/0727/sys/src/9/port/tcpinput.c /n/bootesdump/1991/0926/sys/src/9/port/tcpinput.c
441c
tcb->cwind = tcb->cwind/2;
.
## diffname port/tcpinput.c 1991/1019
## diff -e /n/bootesdump/1991/0926/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1019/sys/src/9/port/tcpinput.c
500c
PUTNEXT(Ipoutput, hbp);
.
14d
## diffname port/tcpinput.c 1991/1023
## diff -e /n/bootesdump/1991/1019/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1023/sys/src/9/port/tcpinput.c
144a
.
142,143d
139a
new->newcon = 1;
.
111,125c
new = ipincoming(ipc);
if(new == 0)
.
37c
Ipconv *s, *new;
.
## diffname port/tcpinput.c 1991/1030
## diff -e /n/bootesdump/1991/1023/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1030/sys/src/9/port/tcpinput.c
1122d
1110c
return hdrlen;
.
1010d
971c
}
else {
.
952d
824d
785,797d
774c
if(excess > 0) {
.
732c
}
else {
.
691d
680,681c
if(rp1->next == 0 || seq_lt(seg->seq, rp1->next->seg.seq)) {
.
632d
608,609c
return seq_within(seq, tcb->rcv.nxt, (int)(tcb->rcv.nxt+tcb->rcv.wnd-1));
.
591,593d
580d
577d
565,574d
559c
if((tcb->flags & SYNACK) == 0){
.
542d
537,538d
530d
527d
524d
515d
495a
int rtt;
int abserr;
.
493d
389c
gotone:;
.
300,311c
copyupb(&bp, 0, seg.up);
.
296,297d
42d
## diffname port/tcpinput.c 1991/1102
## diff -e /n/bootesdump/1991/1030/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1102/sys/src/9/port/tcpinput.c
133c
process:
.
131c
s = new;
goto process;
}
}
clear:
LPRINT("tcpin: call cleared\n");
freeb(bp);
reset(source, dest, tos, length, &seg);
return;
.
126,129c
new->newcon = 1;
new->ipinterface = s->ipinterface;
s->ipinterface->ref++;
wakeup(&s->listenr);
.
114,124c
s->curlog++;
LPRINT("tcpin: cloning socket\n");
new->psrc = seg.dest;
new->pdst = seg.source;
new->dst = source;
memmove(&new->tcpctl, &s->tcpctl, sizeof(Tcpctl));
new->tcpctl.flags &= ~CLONE;
new->tcpctl.timer.arg = new;
new->tcpctl.timer.state = TIMER_STOP;
new->tcpctl.acktimer.arg = new;
new->tcpctl.acktimer.state = TIMER_STOP;
.
110,112c
new = ipincoming(ipc);
if(new == 0)
goto clear;
.
105,108c
e = &ipc[conf.ip];
for(s = ipc; s < e; s++) {
if(s->tcpctl.state == LISTEN)
if(s->pdst == 0)
if(s->dst == 0) {
if(s->curlog >= s->backlog)
goto clear;
.
103d
91,101c
if((seg.flags & SYN) == 0)
.
88c
s = ip_conn(ipc, seg.dest, seg.source, source, IP_TCPPROTO);
if (s == 0) {
.
37c
Ipconv *s, *e, *new;
.
## diffname port/tcpinput.c 1991/1104
## diff -e /n/bootesdump/1991/1102/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1104/sys/src/9/port/tcpinput.c
469,471d
369,370c
while(tcb->reseq != 0 && seq_ge(tcb->rcv.nxt, tcb->reseq->seg.seq)) {
.
304,306d
222,223c
if(seg.seq != tcb->rcv.nxt && (length != 0 || (seg.flags & (SYN|FIN)) )) {
.
129d
123d
120a
.
118d
108d
90,91d
77,83d
67d
65d
60d
## diffname port/tcpinput.c 1991/1106
## diff -e /n/bootesdump/1991/1104/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1106/sys/src/9/port/tcpinput.c
55,61d
## diffname port/tcpinput.c 1991/1115
## diff -e /n/bootesdump/1991/1106/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1115/sys/src/9/port/tcpinput.c
84c
new = ipincoming(ipc, s);
.
## diffname port/tcpinput.c 1991/1122
## diff -e /n/bootesdump/1991/1115/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1122/sys/src/9/port/tcpinput.c
818c
return head;
.
814a
if(head == 0)
head = nbp;
else
tail->next = nbp;
tail = nbp;
.
811c
i = BLEN(bp);
nbp = allocb(i);
if(i > nbp->lim-nbp->wptr) {
if(head)
freeb(head);
return 0;
}
.
806,809c
head = 0;
.
803c
Block *nbp, *head, *tail;
.
## diffname port/tcpinput.c 1991/1126
## diff -e /n/bootesdump/1991/1122/sys/src/9/port/tcpinput.c /n/bootesdump/1991/1126/sys/src/9/port/tcpinput.c
806c
head = tail = 0;
.
747,762d
## diffname port/tcpinput.c 1991/12171
## diff -e /n/bootesdump/1991/1126/sys/src/9/port/tcpinput.c /n/bootesdump/1991/12171/sys/src/9/port/tcpinput.c
864c
setstate(s, Closed);
.
495c
(tcb->state == Syn_sent || tcb->state == Syn_received))
.
383c
if(tcb->state == Syn_sent || tcb->state == Syn_received)
.
377c
if(tcb->state == Syn_sent || tcb->state == Syn_received)
.
338c
case Time_wait:
.
334,336c
case Close_wait:
case Closing:
case Last_ack:
.
330c
setstate(s, Time_wait);
.
328c
case Finwait2:
.
326c
setstate(s, Closing);
.
321c
setstate(s, Time_wait);
.
318c
case Finwait1:
.
316c
setstate(s, Close_wait);
.
313,314c
case Syn_received:
case Established:
.
283,286c
case Syn_received:
case Established:
case Finwait1:
case Finwait2:
.
267c
case Time_wait:
.
261c
case Last_ack:
.
256c
setstate(s, Time_wait);
.
253c
case Closing:
.
250c
case Finwait2:
.
248c
setstate(s, Finwait2);
.
245c
case Finwait1:
.
241,242c
case Established:
case Close_wait:
.
233c
setstate(s, Established);
.
230c
case Syn_received:
.
210c
setstate(s, Listen);
.
208c
if(tcb->state == Syn_received
.
169c
setstate(s, Syn_received);
.
166c
setstate(s, Established);
.
142c
case Syn_sent:
.
134c
setstate(s, Syn_received);
.
121c
case Listen:
.
117c
case Closed:
.
78c
if(s->tcpctl.state == Listen)
.
## diffname port/tcpinput.c 1992/0105
## diff -e /n/bootesdump/1991/12171/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0105/sys/src/9/port/tcpinput.c
810,811c
if(count) {
nb = allocb(count);
if(nb == 0)
panic("copyb.2");
memset(nb->wptr, 0, count);
nb->wptr += count;
*p = nb;
}
if(blen(head) == 0)
print("copyb: zero length\n");
return head;
.
808a
if(bp == 0)
break;
.
790,807c
p = &head;
while(count) {
l = BLEN(bp);
if(count < l)
l = count;
nb = allocb(l);
if(nb == 0)
panic("copyb.1");
memmove(nb->wptr, bp->rptr, l);
nb->wptr += l;
count -= l;
*p = nb;
p = &nb->next;
.
787,788c
Block *nb, *head, **p;
int l;
.
## diffname port/tcpinput.c 1992/0106
## diff -e /n/bootesdump/1992/0105/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0106/sys/src/9/port/tcpinput.c
966a
h->frag[0] = 0;
h->frag[1] = 0;
.
816a
.
812a
nb->flags |= S_DELIM;
.
800a
if(bp->flags & S_DELIM)
nb->flags |= S_DELIM;
.
## diffname port/tcpinput.c 1992/0111
## diff -e /n/bootesdump/1992/0106/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0111/sys/src/9/port/tcpinput.c
852c
close_self(Ipconv *s, char reason[])
.
264c
close_self(s, Enoerror);
.
6c
#include "../port/error.h"
.
## diffname port/tcpinput.c 1992/0128
## diff -e /n/bootesdump/1992/0111/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0128/sys/src/9/port/tcpinput.c
833c
cleartcp(tcb);
.
826a
static void
cleartcp(struct Tctl *a)
{
memset(a, 0, sizeof(struct Tctl));
}
.
## diffname port/tcpinput.c 1992/0306
## diff -e /n/bootesdump/1992/0128/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0306/sys/src/9/port/tcpinput.c
88a
qunlock(s);
.
87a
qlock(s);
.
## diffname port/tcpinput.c 1992/0310
## diff -e /n/bootesdump/1992/0306/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0310/sys/src/9/port/tcpinput.c
662d
651,652c
long dupcnt;
long excess;
ushort len;
.
561c
tcb->rcv.up = tcb->rcv.nxt = seg->seq + 1;
.
535,538c
/* All data is acked now */
.
426,428d
418,421d
416a
/* convince the other end that this reset is in band */
.
304,307d
301c
if(tcb->max_snd <= tcb->rcv.nxt-tcb->last_ack)
.
284a
default:
/* Ignore segment text */
freeb(bp);
break;
.
283c
if(length != 0) {
.
280c
else if(seq_gt(tcb->rcv.nxt, tcb->rcv.up))
.
274,275c
if((seg.flags&URG) && seg.up) {
if(seq_gt(seg.up + seg.seq, tcb->rcv.up)) {
.
257c
if(tcb->sndcnt == 0) {
.
202c
if(seg.seq != tcb->rcv.nxt)
if(length != 0 || (seg.flags & (SYN|FIN))) {
.
## diffname port/tcpinput.c 1992/0313
## diff -e /n/bootesdump/1992/0310/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0313/sys/src/9/port/tcpinput.c
657c
if(len == 0)
if(seg->seq == tcb->rcv.nxt)
.
489a
if(!(tcb->flags & RETRAN)) {
.
488d
486c
if(run_timer(&tcb->rtt_timer))
if(seq_ge(seg->ack, tcb->rttseq)) {
.
461a
.
458,460c
if(seq_ge(seg->ack,tcb->snd.wl2))
if(seq_gt(seg->seq,tcb->snd.wl1) || (seg->seq == tcb->snd.wl1)) {
if(seg->wnd != 0)
if(tcb->snd.wnd == 0)
.
361,396d
296c
if(bp)
if(s->readq) {
.
196c
if(length)
if(s->readq == 0) {
.
163a
.
159c
if(seg.flags & ACK)
if(PREC(tos) != PREC(tcb->tos)){
.
## diffname port/tcpinput.c 1992/0318
## diff -e /n/bootesdump/1992/0313/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0318/sys/src/9/port/tcpinput.c
751,790d
## diffname port/tcpinput.c 1992/0319
## diff -e /n/bootesdump/1992/0318/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0319/sys/src/9/port/tcpinput.c
978a
}
void
tcpdumpconv(Ipconv *c)
{
if(c->tcpctl.state == Closed)
return;
print("%s %d -> %d.%d.%d.%d/%d snd %d recv %d una %d nxt %d ptr %d wnd %d\n",
tcpstate[c->tcpctl.state],
c->psrc,
fmtaddr(c->dst),
c->pdst,
c->tcpctl.sndcnt,
c->tcpctl.rcvcnt,
c->tcpctl.snd.una,
c->tcpctl.snd.nxt,
c->tcpctl.snd.ptr,
c->tcpctl.snd.wnd);
}
void
tcpdump(void)
{
Ipifc *ep, *ifp;
Ipconv *cp, *ecp;
extern Ipifc *ipifc;
ep = &ipifc[conf.ipif];
for(ifp = ipifc; ifp < ep; ifp++)
if(strcmp(ifp->name, "TCP") == 0) {
ecp = &ifp->connections[conf.ip];
for(cp = ifp->connections; cp < ecp; cp++)
tcpdumpconv(cp);
break;
}
.
883c
data = padb(data, hdrlen + TCP_PKT);
if(data == 0)
.
350c
while(tcb->reseq != 0) {
if(seq_ge(tcb->rcv.nxt, tcb->reseq->seg.seq) == 0)
break;
.
300a
print("bl %d ty %d\n", blen(bp), bp->rptr[0]);
for(f = bp; bp->next; f = f->next)
;
if((f->flags&S_DELIM) == 0) {
print("No delim upstream rcp");
f->flags |= S_DELIM;
}
.
292a
.
44a
Block *f;
.
## diffname port/tcpinput.c 1992/0320
## diff -e /n/bootesdump/1992/0319/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0320/sys/src/9/port/tcpinput.c
991,1026d
484d
478c
if(rtt > tcb->srtt)
abserr = rtt - tcb->srtt;
else
abserr = tcb->srtt - rtt;
.
470,471c
if((tcb->flags&RETRAN) == 0) {
.
303,309d
47,48d
45d
## diffname port/tcpinput.c 1992/0321
## diff -e /n/bootesdump/1992/0320/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0321/sys/src/9/port/tcpinput.c
2c
#include "../port/lib.h"
.
## diffname port/tcpinput.c 1992/0325
## diff -e /n/bootesdump/1992/0321/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0325/sys/src/9/port/tcpinput.c
810,818d
700,703d
688c
pullb(Block **bph, int count)
.
663c
pullb(bp, (ushort)dupcnt);
.
545,546c
static int start;
start += 250000;
tcb->iss = start;
tcb->rttseq = tcb->iss;
tcb->snd.wl2 = tcb->iss;
tcb->snd.una = tcb->iss;
.
487c
pullb(&tcb->sndq, acked);
.
366,413d
279c
pullb(&bp, seg.up);
.
193,195c
/* If we dont understand answer with a rst */
.
112c
process:
/* The rest of the input state machine is run with the control block
* locked
*/
.
68c
/* Look for a connection, failing that attempt to establish a listen */
.
34a
reset(Ipaddr source, Ipaddr dest, char tos, ushort length, Tcp *seg)
{
Block *hbp;
Port tmp;
char rflags;
Tcphdr ph;
if(seg->flags & RST)
return;
hnputl(ph.tcpsrc, dest);
hnputl(ph.tcpdst, source);
ph.proto = IP_TCPPROTO;
hnputs(ph.tcplen, TCP_HDRSIZE);
/* Swap port numbers */
tmp = seg->dest;
seg->dest = seg->source;
seg->source = tmp;
rflags = RST;
/* convince the other end that this reset is in band */
if(seg->flags & ACK) {
seg->seq = seg->ack;
seg->ack = 0;
}
else {
rflags |= ACK;
seg->ack = seg->seq;
seg->seq = 0;
if(seg->flags & SYN)
seg->ack++;
seg->ack += length;
if(seg->flags & FIN)
seg->ack++;
}
seg->flags = rflags;
seg->wnd = 0;
seg->up = 0;
seg->mss = 0;
if((hbp = htontcp(seg, 0, &ph)) == 0)
return;
PUTNEXT(Ipoutput, hbp);
}
void
.
## diffname port/tcpinput.c 1992/0406
## diff -e /n/bootesdump/1992/0325/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0406/sys/src/9/port/tcpinput.c
161c
.
156,159c
if(s == 0){
freeb(bp);
reset(source, dest, tos, length, &seg);
return;
}
.
154a
if(spec)
s = tcpincoming(ipc, spec, &seg, source);
else if(gen)
s = tcpincoming(ipc, gen, &seg, source);
else
s = 0;
.
120,153c
if(seg.flags & SYN){
/*
* find a listener specific to this port (spec) or,
* failing that, a general one (gen)
*/
spec = 0;
gen = 0;
e = &ipc[conf.ip];
for(s = ipc; s < e; s++) {
if(s->tcpctl.state == Listen)
if(s->pdst == 0)
if(s->dst == 0) {
if(s->psrc == seg.dest){
spec = s;
break;
}
if(s->psrc == 0)
gen = s;
}
.
85c
Ipconv *s, *e;
Ipconv *spec, *gen;
.
81a
Ipconv*
tcpincoming(Ipconv *ipc, Ipconv *s, Tcp *segp, Ipaddr source)
{
Ipconv *new;
if(s->curlog >= s->backlog)
return 0;
new = ipincoming(ipc, s);
if(new == 0)
return 0;
qlock(s);
s->curlog++;
qunlock(s);
new->psrc = segp->dest;
new->pdst = segp->source;
new->dst = source;
memmove(&new->tcpctl, &s->tcpctl, sizeof(Tcpctl));
new->tcpctl.flags &= ~CLONE;
new->tcpctl.timer.arg = new;
new->tcpctl.timer.state = TIMER_STOP;
new->tcpctl.acktimer.arg = new;
new->tcpctl.acktimer.state = TIMER_STOP;
new->newcon = 1;
new->ipinterface = s->ipinterface;
s->ipinterface->ref++;
wakeup(&s->listenr);
return new;
}
.
## diffname port/tcpinput.c 1992/0414
## diff -e /n/bootesdump/1992/0406/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0414/sys/src/9/port/tcpinput.c
106c
new->newcon = s;
.
## diffname port/tcpinput.c 1992/0416
## diff -e /n/bootesdump/1992/0414/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0416/sys/src/9/port/tcpinput.c
822a
/* flush receive queue */
while(bp = getb(&tcb->rcvq))
freeb(bp);
.
818a
Block *bp;
.
813a
/*
* called with tcb locked
*/
.
373,375c
if(bp){
if(s->readq)
PUTNEXT(s->readq, bp);
else
putb(&tcb->rcvq, bp);
.
272c
if(s->readq == 0)
if(tcb->state == Closed) {
.
100c
tcpmove(&new->tcpctl, &s->tcpctl);
.
94d
92a
}
.
91c
if(new == 0){
qunlock(s);
.
88a
}
.
87c
qlock(s);
if(s->curlog >= s->backlog){
qunlock(s);
.
81a
/*
* flush an incoming call; send a reset to the remote side and close the
* conversation
*/
void
tcpflushincoming(Ipconv *s)
{
Tcp seg;
Tcpctl *tcb;
tcb = &s->tcpctl;
seg.source = s->pdst;
seg.dest = s->psrc;
seg.flags = ACK;
seg.seq = tcb->snd.ptr;
seg.ack = tcb->last_ack = tcb->rcv.nxt;
reset(s->dst, Myip[Myself], 0, 0, &seg);
close_self(s, 0);
}
static void
tcpmove(struct Tctl *to, struct Tctl *from)
{
memmove(to, from, sizeof(struct Tctl));
}
.
## diffname port/tcpinput.c 1992/0512
## diff -e /n/bootesdump/1992/0416/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0512/sys/src/9/port/tcpinput.c
392c
if(length == 0)
freeb(bp);
else {
.
374a
freeb(bp);
.
## diffname port/tcpinput.c 1992/0527
## diff -e /n/bootesdump/1992/0512/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0527/sys/src/9/port/tcpinput.c
399c
if(bp)
freeb(bp);
.
393,395c
if(length == 0){
if(bp)
freeb(bp);
} else {
.
## diffname port/tcpinput.c 1992/0606
## diff -e /n/bootesdump/1992/0527/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0606/sys/src/9/port/tcpinput.c
631c
if((dropped++%256) == 0)
print("tcp: no resequence descriptors\n");
.
626a
static int dropped;
.
## diffname port/tcpinput.c 1992/0619
## diff -e /n/bootesdump/1992/0606/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0619/sys/src/9/port/tcpinput.c
877,881c
free(rp);
.
680,683c
free(rp);
.
638,641d
636d
629,634c
rp = malloc(sizeof(Reseq));
if(rp == 0)
.
627d
23,34d
14,16d
## diffname port/tcpinput.c 1992/0626
## diff -e /n/bootesdump/1992/0619/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0626/sys/src/9/port/tcpinput.c
586c
if((mtu = s->ifc->maxmtu) != 0) {
.
192c
s = tcpincoming(ifc, gen, &seg, source);
.
190c
s = tcpincoming(ifc, spec, &seg, source);
.
176,177c
etab = &ifc->conv[Nipconv];
for(p = ifc->conv; p < etab && *p; p++) {
s = *p;
.
167c
s = ip_conn(ifc, seg.dest, seg.source, source, IP_TCPPROTO);
.
133c
Ipconv *s, **p, **etab;
.
131c
tcp_input(Ipifc *ifc, Block *bp)
.
125d
123d
105c
new = ipincoming(ifc, s);
.
95c
tcpincoming(Ipifc *ifc, Ipconv *s, Tcp *segp, Ipaddr source)
.
## diffname port/tcpinput.c 1992/0711
## diff -e /n/bootesdump/1992/0626/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0711/sys/src/9/port/tcpinput.c
972d
165c
s = ip_conn(ifc, seg.dest, seg.source, source);
.
26a
USED(tos); /* is this right??? */
.
## diffname port/tcpinput.c 1992/0724
## diff -e /n/bootesdump/1992/0711/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0724/sys/src/9/port/tcpinput.c
616a
}
.
615c
if(rp == 0){
freeb(bp); /* bp always consumed by add_reseq */
.
411a
case Finwait2:
/* no process to read the data, send a reset */
if(bp)
freeb(bp);
reset(source, dest, tos, length, &seg);
goto done;
.
393d
166c
/* Look for a connection. failing that look for a listener. */
.
## diffname port/tcpinput.c 1992/0807
## diff -e /n/bootesdump/1992/0724/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0807/sys/src/9/port/tcpinput.c
382c
}
else {
.
17c
"Closing", "Last_ack", "Time_wait"
};
.
14c
char *tcpstate[] =
{
.
## diffname port/tcpinput.c 1992/0826
## diff -e /n/bootesdump/1992/0807/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0826/sys/src/9/port/tcpinput.c
842c
localclose(Ipconv *s, char reason[])
.
691c
/* Some part of the segment should be in the window */
.
564d
554,556d
551c
if(seq_gt(seg->ack, tcb->snd.up))
.
540d
536d
532,534c
rtt = abs(rtt - tcb->srtt);
tcb->mdev = ((DGAIN-1)*tcb->mdev + rtt) / DGAIN;
.
527,530d
522c
rtt *= MSPTICK;
.
520a
tcb->backoff = 0;
.
516c
/* Adjust the timers acorrding to the round trip time */
.
500a
/* Compute the new send window size */
.
479,480d
475a
int rtt;
.
465d
462c
break;
.
460a
.
459a
.
456a
.
418c
sndrst(source, dest, tos, length, &seg);
.
396c
/* If we still have some data place on receive queue */
.
364c
localclose(s, Enoerror);
.
336c
sndrst(source, dest, tos, length, &seg);
.
319c
sndrst(source, dest, tos, length, &seg);
.
311c
localclose(s, Econrefused);
.
297a
/* The segment is beyond the current receive pointer so
* queue the data in the resequence queue
*/
.
294c
sndrst(source, dest, tos, length, &seg);
.
289c
/* Cannot accept so answer with a rst */
.
280c
/* Cut the data to fit the receive window */
.
256c
sndrst(source, dest, tos, length, &seg);
.
248c
localclose(s, Econrefused);
.
242c
sndrst(source, dest, tos, length, &seg);
.
224c
sndrst(source, dest, tos, length, &seg);
.
215c
sndrst(source, dest, tos, length, &seg);
.
201c
sndrst(source, dest, tos, length, &seg);
.
162c
/* trim the packet to the size claimed by the datagram */
.
88,89c
sndrst(s->dst, Myip[Myself], 0, 0, &seg);
localclose(s, 0);
.
22c
sndrst(Ipaddr source, Ipaddr dest, char tos, ushort length, Tcp *seg)
.
## diffname port/tcpinput.c 1992/0903
## diff -e /n/bootesdump/1992/0826/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0903/sys/src/9/port/tcpinput.c
1007c
optr = h->tcpopt;
for(i = TCP_HDRSIZE; i < hdrlen;) {
.
909c
tcpxstate(s, oldstate, newstate);
.
902c
tcpsetstate(Ipconv *s, char newstate)
.
860c
tcpsetstate(s, Closed);
.
843,844c
tcphalt(&tcb->timer);
tcphalt(&tcb->rtt_timer);
.
829,830c
tcb->acktimer.func = tcpacktimer;
tcb->acktimer.arg = s;
.
826,827d
823,824c
tcb->timer.func = tcptimeout;
tcb->timer.arg = s;
.
821d
651c
rp = tcb->reseq;
if(rp == 0)
.
642a
rp1 = rp1->next;
.
633,641c
return;
}
for(;;) {
if(rp1->next == 0 || seq_lt(seg->seq, rp1->next->seg.seq)) {
rp->next = rp1->next;
rp1->next = rp;
break;
.
598c
tcpsndsyn(Tcpctl *tcb)
.
555c
tcpgo(&tcb->timer);
.
553c
tcphalt(&tcb->timer);
.
524c
tcphalt(&tcb->rtt_timer);
.
473c
tcpoutput(s);
.
461c
while(tcb->reseq) {
.
456c
tcpgo(&tcb->timer);
.
449c
tcpgo(&tcb->timer);
.
447c
tcpsetstate(s, Time_wait);
.
443c
tcpsetstate(s, Closing);
.
440c
tcpgo(&tcb->timer);
.
438c
tcpsetstate(s, Time_wait);
.
433c
tcpsetstate(s, Close_wait);
.
421c
sndrst(source, dest, length, &seg);
.
412c
tcpgo(&tcb->acktimer);
.
372c
tcpgo(&tcb->timer);
.
360c
tcpgo(&tcb->timer);
.
358c
tcpsetstate(s, Time_wait);
.
350c
tcpsetstate(s, Finwait2);
.
342c
update(s, &seg);
tcpsetstate(s, Established);
.
339c
sndrst(source, dest, length, &seg);
.
333,337c
if(!seq_within(seg.ack, tcb->snd.una+1, tcb->snd.nxt)){
.
322c
sndrst(source, dest, length, &seg);
.
319a
/* This tos stuff should be removed */
.
312c
tcpsetstate(s, Listen);
.
294c
sndrst(source, dest, length, &seg);
.
267c
tcpsetstate(s, Syn_received);
.
264c
tcpsetstate(s, Established);
.
256c
sndrst(source, dest, length, &seg);
.
242c
sndrst(source, dest, length, &seg);
.
229,230c
tcpsndsyn(tcb);
tcpsetstate(s, Syn_received);
.
224c
sndrst(source, dest, length, &seg);
.
215c
sndrst(source, dest, length, &seg);
.
201c
sndrst(source, dest, length, &seg);
.
133c
tcpinput(Ipifc *ifc, Block *bp)
.
88c
sndrst(s->dst, Myip[Myself], 0, &seg);
.
29,30d
22c
sndrst(Ipaddr source, Ipaddr dest, ushort length, Tcp *seg)
.
## diffname port/tcpinput.c 1992/0906
## diff -e /n/bootesdump/1992/0903/sys/src/9/port/tcpinput.c /n/bootesdump/1992/0906/sys/src/9/port/tcpinput.c
913a
ushort csum;
ushort hdrlen;
.
911d
909d
900a
tcb = &s->tcpctl;
.
899d
897a
Tcpctl *tcb;
.
797,799d
686,687c
else
if(len != 0) {
.
684c
if(in_window(tcb,seg->seq))
.
205c
* locked and implements the state machine directly out of the RFC
* Out-of-band data is ignored - it was always a bad idea.
.
141a
Ipconv *spec, *gen;
Ipaddr source, dest;
Ipconv *s, **p, **etab;
.
140a
Tcphdr *h;
int hdrlen;
Tcpctl *tcb;
.
138,139d
133,136d
123c
new->tcpctl.acktimer.state = TimerOFF;
.
121c
new->tcpctl.timer.state = TimerOFF;
.
10c
int tcpdbg = 0;
ushort tcp_mss = DEF_MSS; /* Maximum segment size to be sent with SYN */
int tcp_irtt = DEF_RTT; /* Initial guess at round trip time */
.
## diffname port/tcpinput.c 1992/1221
## diff -e /n/bootesdump/1992/0906/sys/src/9/port/tcpinput.c /n/bootesdump/1992/1221/sys/src/9/port/tcpinput.c
561a
if(tcb->sndfull && tcb->sndcnt < Streamhi/2){
wakeup(&tcb->sndr);
tcb->sndfull = 0;
}
.
## diffname port/tcpinput.c 1993/0218
## diff -e /n/bootesdump/1992/1221/sys/src/9/port/tcpinput.c /n/bootesdump/1993/0218/sys/src/9/port/tcpinput.c
415a
.
414c
if(tcb->rcv.nxt-tcb->last_ack > Streamhi/2)
.
412c
if(tcb->acktimer.state != TimerON)
tcpgo(&tcb->acktimer);
.
87c
tcb->last_ack = tcb->rcv.nxt;
seg.ack = tcb->rcv.nxt;
.
## diffname port/tcpinput.c 1993/0220
## diff -e /n/bootesdump/1993/0218/sys/src/9/port/tcpinput.c /n/bootesdump/1993/0220/sys/src/9/port/tcpinput.c
901c
return x >= y;
.
899c
seq_ge(ulong x, ulong y)
.
895c
return x > y;
.
893c
seq_gt(ulong x, ulong y)
.
889c
return x <= y;
.
887c
seq_le(ulong x, ulong y)
.
883c
return x < y;
.
881c
seq_lt(ulong x, ulong y)
.
867c
seq_within(ulong x, ulong low, ulong high)
.
700,701c
if(in_window(tcb, seg->seq+len-1) ||
seq_within(tcb->rcv.nxt, seg->seq,seg->seq+len-1))
.
575c
return seq_within(seq, tcb->rcv.nxt, tcb->rcv.nxt+tcb->rcv.wnd-1);
.
473d
466c
goto output;
.
464c
/*
* get next adjacent segment from the requence queue.
* dump/trim any overlapping segments
*/
for(;;) {
if(tcb->reseq == 0)
goto output;
.
310a
/*
* keep looping till we've processed this packet plus any
* adjacent packets in the resequence queue
*/
.
## diffname port/tcpinput.c 1993/0501
## diff -e /n/bootesdump/1993/0220/sys/src/9/port/tcpinput.c /n/fornaxdump/1993/0501/sys/src/brazil/port/tcpinput.c
911c
return (long)(x-y) >= 0;
.
909c
seq_ge(int x, int y)
.
905c
return (long)(x-y) > 0;
.
903c
seq_gt(int x, int y)
.
899c
return (long)(x-y) <= 0;
.
897c
seq_le(int x, int y)
.
893c
return (long)(x-y) < 0;
.
891c
seq_lt(int x, int y)
.
877c
seq_within(int x, int low, int high)
.
710,711c
if(in_window(tcb, (int)(seg->seq+len-1)) ||
seq_within(tcb->rcv.nxt, seg->seq,(int)(seg->seq+len-1)))
.
585c
return seq_within(seq, tcb->rcv.nxt, (int)(tcb->rcv.nxt+tcb->rcv.wnd-1));
.
483a
break;
.
477c
break;
.
468,475c
while(tcb->reseq) {
.
422d
420c
if(tcb->max_snd <= tcb->rcv.nxt-tcb->last_ack)
.
417,418c
tcpgo(&tcb->acktimer);
.
311,314d
87,88c
seg.ack = tcb->last_ack = tcb->rcv.nxt;
.
## diffname port/tcpinput.c 1993/0804 # deleted
## diff -e /n/fornaxdump/1993/0501/sys/src/brazil/port/tcpinput.c /n/fornaxdump/1993/0804/sys/src/brazil/port/tcpinput.c
1,1026d
|
