ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/slirp/tcp_input.c
Revision: 1.4
Committed: 2012-03-30T01:10:28Z (12 years, 7 months ago) by asvitkine
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 1.3: +1 -5 lines
Log Message: 
Switch slirp to 3-clause BSD license. This change went in upstream to QEMU's
version of slirp (where this code comes from), with the following checkin:

commit 2f5f89963186d42a7ded253bc6cf5b32abb45cec
Author: aliguori <aliguori@c046a42c-6fe2-441c-8c8c-71466251a162>
Date:   Mon Jan 26 19:37:41 2009 +0000

    Remove the advertising clause from the slirp license

    According to the FSF, the 4-clause BSD license, which slirp is covered under,
    is not compatible with the GPL or LGPL[1].

    [1] http://www.fsf.org/licensing/licenses/index_html#GPLIncompatibleLicenses

    There are three declared copyright holders in slirp that use the 4-clause
    BSD license, the Regents of UC Berkley, Danny Gasparovski, and Kelly Price.
    Below are the appropriate permissions to remove the advertise clause from slirp
    from each party.

    Special thanks go to Richard Fontana from Red Hat for contacting all of the
    necessary authors to resolve this issue!

    Regents of UC Berkley:
    From ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change

    July 22, 1999

    To All Licensees, Distributors of Any Version of BSD:

    As you know, certain of the Berkeley Software Distribution ("BSD") source
    code files require that further distributions of products containing all or
    portions of the software, acknowledge within their advertising materials
    that such products contain software developed by UC Berkeley and its
    contributors.

    Specifically, the provision reads:

    "     * 3. All advertising materials mentioning features or use of this software
          *    must display the following acknowledgement:
          *    This product includes software developed by the University of
          *    California, Berkeley and its contributors."

    Effective immediately, licensees and distributors are no longer required to
    include the acknowledgement within advertising materials.  Accordingly, the
    foregoing paragraph of those BSD Unix files containing it is hereby deleted
    in its entirety.

    William Hoskins
    Director, Office of Technology Licensing
    University of California, Berkeley

    Danny Gasparovski:

    Subject: RE: Slirp license
    Date: Thu, 8 Jan 2009 10:51:00 +1100
    From: "Gasparovski, Daniel" <Daniel.Gasparovski@ato.gov.au>
    To: "Richard Fontana" <rfontana@redhat.com>

    Hi Richard,

    I have no objection to having Slirp code in QEMU be licensed under the
    3-clause BSD license.

    Thanks for taking the effort to consult me about this.


    Dan ...

    Kelly Price:

    Date: Thu, 8 Jan 2009 19:38:56 -0500
    From: "Kelly Price" <strredwolf@gmail.com>
    To: "Richard Fontana" <rfontana@redhat.com>
    Subject: Re: Slirp license

    Thanks for contacting me, Richard.  I'm glad you were able to find
    Dan, as I've been "keeping the light on" for Slirp.  I have no use for
    it now, and I have little time for it (now holding onto Keenspot's
    Comic Genesis and having a regular US state government position). If
    Dan would like to return to the project, I'd love to give it back to
    him.

    As for copyright, I don't own all of it.  Dan does, so I will defer to
    him.  Any of my patches I will gladly license to the 3-part BSD
    license.  My interest in re-licensing was because we didn't have ready
    info to contact Dan.  If Dan would like to port Slirp back out of
    QEMU, a lot of us 64-bit users would be grateful.

    Feel free to share this email address with Dan.  I will be glad to
    effect a transfer of the project to him and Mr. Bellard of the QEMU
    project.

    Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>


    git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6451 c046a42c-6fe2-441c-8c8c-71466251a162

File Contents

# User Rev Content
1 gbeauche 1.1 /*
2     * Copyright (c) 1982, 1986, 1988, 1990, 1993, 1994
3     * The Regents of the University of California. All rights reserved.
4     *
5     * Redistribution and use in source and binary forms, with or without
6     * modification, are permitted provided that the following conditions
7     * are met:
8     * 1. Redistributions of source code must retain the above copyright
9     * notice, this list of conditions and the following disclaimer.
10     * 2. Redistributions in binary form must reproduce the above copyright
11     * notice, this list of conditions and the following disclaimer in the
12     * documentation and/or other materials provided with the distribution.
13 asvitkine 1.4 * 3. Neither the name of the University nor the names of its contributors
14 gbeauche 1.1 * may be used to endorse or promote products derived from this software
15     * without specific prior written permission.
16     *
17     * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20     * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26     * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27     * SUCH DAMAGE.
28     *
29     * @(#)tcp_input.c 8.5 (Berkeley) 4/10/94
30     * tcp_input.c,v 1.10 1994/10/13 18:36:32 wollman Exp
31     */
32    
33     /*
34     * Changes and additions relating to SLiRP
35     * Copyright (c) 1995 Danny Gasparovski.
36     *
37     * Please read the file COPYRIGHT for the
38     * terms and conditions of the copyright.
39     */
40    
41 asvitkine 1.3 #include <stdlib.h>
42 gbeauche 1.1 #include <slirp.h>
43     #include "ip_icmp.h"
44    
45     struct socket tcb;
46    
47     int tcprexmtthresh = 3;
48     struct socket *tcp_last_so = &tcb;
49    
50     tcp_seq tcp_iss; /* tcp initial send seq # */
51    
52     #define TCP_PAWS_IDLE (24 * 24 * 60 * 60 * PR_SLOWHZ)
53    
54     /* for modulo comparisons of timestamps */
55     #define TSTMP_LT(a,b) ((int)((a)-(b)) < 0)
56     #define TSTMP_GEQ(a,b) ((int)((a)-(b)) >= 0)
57    
58     /*
59     * Insert segment ti into reassembly queue of tcp with
60     * control block tp. Return TH_FIN if reassembly now includes
61     * a segment with FIN. The macro form does the common case inline
62     * (segment is the next to be received on an established connection,
63     * and the queue is empty), avoiding linkage into and removal
64     * from the queue and repetition of various conversions.
65     * Set DELACK for segments received in order, but ack immediately
66     * when segments are out of order (so fast retransmit can work).
67     */
68     #ifdef TCP_ACK_HACK
69     #define TCP_REASS(tp, ti, m, so, flags) {\
70     if ((ti)->ti_seq == (tp)->rcv_nxt && \
71     (tp)->seg_next == (tcpiphdrp_32)(tp) && \
72     (tp)->t_state == TCPS_ESTABLISHED) {\
73     if (ti->ti_flags & TH_PUSH) \
74     tp->t_flags |= TF_ACKNOW; \
75     else \
76     tp->t_flags |= TF_DELACK; \
77     (tp)->rcv_nxt += (ti)->ti_len; \
78     flags = (ti)->ti_flags & TH_FIN; \
79     tcpstat.tcps_rcvpack++;\
80     tcpstat.tcps_rcvbyte += (ti)->ti_len;\
81     if (so->so_emu) { \
82     if (tcp_emu((so),(m))) sbappend((so), (m)); \
83     } else \
84     sbappend((so), (m)); \
85     /* sorwakeup(so); */ \
86     } else {\
87     (flags) = tcp_reass((tp), (ti), (m)); \
88     tp->t_flags |= TF_ACKNOW; \
89     } \
90     }
91     #else
92     #define TCP_REASS(tp, ti, m, so, flags) { \
93     if ((ti)->ti_seq == (tp)->rcv_nxt && \
94     (tp)->seg_next == (tcpiphdrp_32)(tp) && \
95     (tp)->t_state == TCPS_ESTABLISHED) { \
96     tp->t_flags |= TF_DELACK; \
97     (tp)->rcv_nxt += (ti)->ti_len; \
98     flags = (ti)->ti_flags & TH_FIN; \
99     tcpstat.tcps_rcvpack++;\
100     tcpstat.tcps_rcvbyte += (ti)->ti_len;\
101     if (so->so_emu) { \
102     if (tcp_emu((so),(m))) sbappend(so, (m)); \
103     } else \
104     sbappend((so), (m)); \
105     /* sorwakeup(so); */ \
106     } else { \
107     (flags) = tcp_reass((tp), (ti), (m)); \
108     tp->t_flags |= TF_ACKNOW; \
109     } \
110     }
111     #endif
112    
113     int
114     tcp_reass(tp, ti, m)
115     register struct tcpcb *tp;
116     register struct tcpiphdr *ti;
117     struct mbuf *m;
118     {
119     register struct tcpiphdr *q;
120     struct socket *so = tp->t_socket;
121     int flags;
122    
123     /*
124     * Call with ti==0 after become established to
125     * force pre-ESTABLISHED data up to user socket.
126     */
127     if (ti == 0)
128     goto present;
129    
130     /*
131     * Find a segment which begins after this one does.
132     */
133     for (q = (struct tcpiphdr *)tp->seg_next; q != (struct tcpiphdr *)tp;
134     q = (struct tcpiphdr *)q->ti_next)
135     if (SEQ_GT(q->ti_seq, ti->ti_seq))
136     break;
137    
138     /*
139     * If there is a preceding segment, it may provide some of
140     * our data already. If so, drop the data from the incoming
141     * segment. If it provides all of our data, drop us.
142     */
143     if ((struct tcpiphdr *)q->ti_prev != (struct tcpiphdr *)tp) {
144     register int i;
145     q = (struct tcpiphdr *)q->ti_prev;
146     /* conversion to int (in i) handles seq wraparound */
147     i = q->ti_seq + q->ti_len - ti->ti_seq;
148     if (i > 0) {
149     if (i >= ti->ti_len) {
150     tcpstat.tcps_rcvduppack++;
151     tcpstat.tcps_rcvdupbyte += ti->ti_len;
152     m_freem(m);
153     /*
154     * Try to present any queued data
155     * at the left window edge to the user.
156     * This is needed after the 3-WHS
157     * completes.
158     */
159     goto present; /* ??? */
160     }
161     m_adj(m, i);
162     ti->ti_len -= i;
163     ti->ti_seq += i;
164     }
165     q = (struct tcpiphdr *)(q->ti_next);
166     }
167     tcpstat.tcps_rcvoopack++;
168     tcpstat.tcps_rcvoobyte += ti->ti_len;
169     REASS_MBUF(ti) = (mbufp_32) m; /* XXX */
170    
171     /*
172     * While we overlap succeeding segments trim them or,
173     * if they are completely covered, dequeue them.
174     */
175     while (q != (struct tcpiphdr *)tp) {
176     register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;
177     if (i <= 0)
178     break;
179     if (i < q->ti_len) {
180     q->ti_seq += i;
181     q->ti_len -= i;
182     m_adj((struct mbuf *) REASS_MBUF(q), i);
183     break;
184     }
185     q = (struct tcpiphdr *)q->ti_next;
186     m = (struct mbuf *) REASS_MBUF((struct tcpiphdr *)q->ti_prev);
187     remque_32((void *)(q->ti_prev));
188     m_freem(m);
189     }
190    
191     /*
192     * Stick new segment in its place.
193     */
194     insque_32(ti, (void *)(q->ti_prev));
195    
196     present:
197     /*
198     * Present data to user, advancing rcv_nxt through
199     * completed sequence space.
200     */
201     if (!TCPS_HAVEESTABLISHED(tp->t_state))
202     return (0);
203     ti = (struct tcpiphdr *) tp->seg_next;
204     if (ti == (struct tcpiphdr *)tp || ti->ti_seq != tp->rcv_nxt)
205     return (0);
206     if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)
207     return (0);
208     do {
209     tp->rcv_nxt += ti->ti_len;
210     flags = ti->ti_flags & TH_FIN;
211     remque_32(ti);
212     m = (struct mbuf *) REASS_MBUF(ti); /* XXX */
213     ti = (struct tcpiphdr *)ti->ti_next;
214     /* if (so->so_state & SS_FCANTRCVMORE) */
215     if (so->so_state & SS_FCANTSENDMORE)
216     m_freem(m);
217     else {
218     if (so->so_emu) {
219     if (tcp_emu(so,m)) sbappend(so, m);
220     } else
221     sbappend(so, m);
222     }
223     } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
224     /* sorwakeup(so); */
225     return (flags);
226     }
227    
228     /*
229     * TCP input routine, follows pages 65-76 of the
230     * protocol specification dated September, 1981 very closely.
231     */
232     void
233     tcp_input(m, iphlen, inso)
234     register struct mbuf *m;
235     int iphlen;
236     struct socket *inso;
237     {
238     struct ip save_ip, *ip;
239     register struct tcpiphdr *ti;
240     caddr_t optp = NULL;
241     int optlen = 0;
242     int len, tlen, off;
243     register struct tcpcb *tp = 0;
244     register int tiflags;
245     struct socket *so = 0;
246     int todrop, acked, ourfinisacked, needoutput = 0;
247     /* int dropsocket = 0; */
248     int iss = 0;
249     u_long tiwin;
250     int ret;
251     /* int ts_present = 0; */
252    
253     DEBUG_CALL("tcp_input");
254     DEBUG_ARGS((dfd," m = %8lx iphlen = %2d inso = %lx\n",
255     (long )m, iphlen, (long )inso ));
256    
257     /*
258     * If called with m == 0, then we're continuing the connect
259     */
260     if (m == NULL) {
261     so = inso;
262    
263     /* Re-set a few variables */
264     tp = sototcpcb(so);
265     m = so->so_m;
266     so->so_m = 0;
267     ti = so->so_ti;
268     tiwin = ti->ti_win;
269     tiflags = ti->ti_flags;
270    
271     goto cont_conn;
272     }
273    
274    
275     tcpstat.tcps_rcvtotal++;
276     /*
277     * Get IP and TCP header together in first mbuf.
278     * Note: IP leaves IP header in first mbuf.
279     */
280     ti = mtod(m, struct tcpiphdr *);
281     if (iphlen > sizeof(struct ip )) {
282     ip_stripoptions(m, (struct mbuf *)0);
283     iphlen=sizeof(struct ip );
284     }
285     /* XXX Check if too short */
286    
287    
288     /*
289     * Save a copy of the IP header in case we want restore it
290     * for sending an ICMP error message in response.
291     */
292     ip=mtod(m, struct ip *);
293     save_ip = *ip;
294     save_ip.ip_len+= iphlen;
295    
296     /*
297     * Checksum extended TCP header and data.
298     */
299     tlen = ((struct ip *)ti)->ip_len;
300     ti->ti_next = ti->ti_prev = 0;
301     ti->ti_x1 = 0;
302     ti->ti_len = htons((u_int16_t)tlen);
303     len = sizeof(struct ip ) + tlen;
304     /* keep checksum for ICMP reply
305     * ti->ti_sum = cksum(m, len);
306     * if (ti->ti_sum) { */
307     if(cksum(m, len)) {
308     tcpstat.tcps_rcvbadsum++;
309     goto drop;
310     }
311    
312     /*
313     * Check that TCP offset makes sense,
314     * pull out TCP options and adjust length. XXX
315     */
316     off = ti->ti_off << 2;
317     if (off < sizeof (struct tcphdr) || off > tlen) {
318     tcpstat.tcps_rcvbadoff++;
319     goto drop;
320     }
321     tlen -= off;
322     ti->ti_len = tlen;
323     if (off > sizeof (struct tcphdr)) {
324     optlen = off - sizeof (struct tcphdr);
325     optp = mtod(m, caddr_t) + sizeof (struct tcpiphdr);
326    
327     /*
328     * Do quick retrieval of timestamp options ("options
329     * prediction?"). If timestamp is the only option and it's
330     * formatted as recommended in RFC 1323 appendix A, we
331     * quickly get the values now and not bother calling
332     * tcp_dooptions(), etc.
333     */
334     /* if ((optlen == TCPOLEN_TSTAMP_APPA ||
335     * (optlen > TCPOLEN_TSTAMP_APPA &&
336     * optp[TCPOLEN_TSTAMP_APPA] == TCPOPT_EOL)) &&
337     * *(u_int32_t *)optp == htonl(TCPOPT_TSTAMP_HDR) &&
338     * (ti->ti_flags & TH_SYN) == 0) {
339     * ts_present = 1;
340     * ts_val = ntohl(*(u_int32_t *)(optp + 4));
341     * ts_ecr = ntohl(*(u_int32_t *)(optp + 8));
342     * optp = NULL; / * we've parsed the options * /
343     * }
344     */
345     }
346     tiflags = ti->ti_flags;
347    
348     /*
349     * Convert TCP protocol specific fields to host format.
350     */
351     NTOHL(ti->ti_seq);
352     NTOHL(ti->ti_ack);
353     NTOHS(ti->ti_win);
354     NTOHS(ti->ti_urp);
355    
356     /*
357     * Drop TCP, IP headers and TCP options.
358     */
359     m->m_data += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
360     m->m_len -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
361    
362     /*
363     * Locate pcb for segment.
364     */
365     findso:
366     so = tcp_last_so;
367     if (so->so_fport != ti->ti_dport ||
368     so->so_lport != ti->ti_sport ||
369     so->so_laddr.s_addr != ti->ti_src.s_addr ||
370     so->so_faddr.s_addr != ti->ti_dst.s_addr) {
371     so = solookup(&tcb, ti->ti_src, ti->ti_sport,
372     ti->ti_dst, ti->ti_dport);
373     if (so)
374     tcp_last_so = so;
375     ++tcpstat.tcps_socachemiss;
376     }
377    
378     /*
379     * If the state is CLOSED (i.e., TCB does not exist) then
380     * all data in the incoming segment is discarded.
381     * If the TCB exists but is in CLOSED state, it is embryonic,
382     * but should either do a listen or a connect soon.
383     *
384     * state == CLOSED means we've done socreate() but haven't
385     * attached it to a protocol yet...
386     *
387     * XXX If a TCB does not exist, and the TH_SYN flag is
388     * the only flag set, then create a session, mark it
389     * as if it was LISTENING, and continue...
390     */
391     if (so == 0) {
392     if ((tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) != TH_SYN)
393     goto dropwithreset;
394    
395     if ((so = socreate()) == NULL)
396     goto dropwithreset;
397     if (tcp_attach(so) < 0) {
398     free(so); /* Not sofree (if it failed, it's not insqued) */
399     goto dropwithreset;
400     }
401    
402     sbreserve(&so->so_snd, tcp_sndspace);
403     sbreserve(&so->so_rcv, tcp_rcvspace);
404    
405     /* tcp_last_so = so; */ /* XXX ? */
406     /* tp = sototcpcb(so); */
407    
408     so->so_laddr = ti->ti_src;
409     so->so_lport = ti->ti_sport;
410     so->so_faddr = ti->ti_dst;
411     so->so_fport = ti->ti_dport;
412    
413     if ((so->so_iptos = tcp_tos(so)) == 0)
414     so->so_iptos = ((struct ip *)ti)->ip_tos;
415    
416     tp = sototcpcb(so);
417     tp->t_state = TCPS_LISTEN;
418     }
419    
420     /*
421     * If this is a still-connecting socket, this probably
422     * a retransmit of the SYN. Whether it's a retransmit SYN
423     * or something else, we nuke it.
424     */
425     if (so->so_state & SS_ISFCONNECTING)
426     goto drop;
427    
428     tp = sototcpcb(so);
429    
430     /* XXX Should never fail */
431     if (tp == 0)
432     goto dropwithreset;
433     if (tp->t_state == TCPS_CLOSED)
434     goto drop;
435    
436     /* Unscale the window into a 32-bit value. */
437     /* if ((tiflags & TH_SYN) == 0)
438     * tiwin = ti->ti_win << tp->snd_scale;
439     * else
440     */
441     tiwin = ti->ti_win;
442    
443     /*
444     * Segment received on connection.
445     * Reset idle time and keep-alive timer.
446     */
447     tp->t_idle = 0;
448     if (so_options)
449     tp->t_timer[TCPT_KEEP] = tcp_keepintvl;
450     else
451     tp->t_timer[TCPT_KEEP] = tcp_keepidle;
452    
453     /*
454     * Process options if not in LISTEN state,
455     * else do it below (after getting remote address).
456     */
457     if (optp && tp->t_state != TCPS_LISTEN)
458     tcp_dooptions(tp, (u_char *)optp, optlen, ti);
459     /* , */
460     /* &ts_present, &ts_val, &ts_ecr); */
461    
462     /*
463     * Header prediction: check for the two common cases
464     * of a uni-directional data xfer. If the packet has
465     * no control flags, is in-sequence, the window didn't
466     * change and we're not retransmitting, it's a
467     * candidate. If the length is zero and the ack moved
468     * forward, we're the sender side of the xfer. Just
469     * free the data acked & wake any higher level process
470     * that was blocked waiting for space. If the length
471     * is non-zero and the ack didn't move, we're the
472     * receiver side. If we're getting packets in-order
473     * (the reassembly queue is empty), add the data to
474     * the socket buffer and note that we need a delayed ack.
475     *
476     * XXX Some of these tests are not needed
477     * eg: the tiwin == tp->snd_wnd prevents many more
478     * predictions.. with no *real* advantage..
479     */
480     if (tp->t_state == TCPS_ESTABLISHED &&
481     (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
482     /* (!ts_present || TSTMP_GEQ(ts_val, tp->ts_recent)) && */
483     ti->ti_seq == tp->rcv_nxt &&
484     tiwin && tiwin == tp->snd_wnd &&
485     tp->snd_nxt == tp->snd_max) {
486     /*
487     * If last ACK falls within this segment's sequence numbers,
488     * record the timestamp.
489     */
490     /* if (ts_present && SEQ_LEQ(ti->ti_seq, tp->last_ack_sent) &&
491     * SEQ_LT(tp->last_ack_sent, ti->ti_seq + ti->ti_len)) {
492     * tp->ts_recent_age = tcp_now;
493     * tp->ts_recent = ts_val;
494     * }
495     */
496     if (ti->ti_len == 0) {
497     if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
498     SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
499     tp->snd_cwnd >= tp->snd_wnd) {
500     /*
501     * this is a pure ack for outstanding data.
502     */
503     ++tcpstat.tcps_predack;
504     /* if (ts_present)
505     * tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
506     * else
507     */ if (tp->t_rtt &&
508     SEQ_GT(ti->ti_ack, tp->t_rtseq))
509     tcp_xmit_timer(tp, tp->t_rtt);
510     acked = ti->ti_ack - tp->snd_una;
511     tcpstat.tcps_rcvackpack++;
512     tcpstat.tcps_rcvackbyte += acked;
513     sbdrop(&so->so_snd, acked);
514     tp->snd_una = ti->ti_ack;
515     m_freem(m);
516    
517     /*
518     * If all outstanding data are acked, stop
519     * retransmit timer, otherwise restart timer
520     * using current (possibly backed-off) value.
521     * If process is waiting for space,
522     * wakeup/selwakeup/signal. If data
523     * are ready to send, let tcp_output
524     * decide between more output or persist.
525     */
526     if (tp->snd_una == tp->snd_max)
527     tp->t_timer[TCPT_REXMT] = 0;
528     else if (tp->t_timer[TCPT_PERSIST] == 0)
529     tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
530    
531     /*
532     * There's room in so_snd, sowwakup will read()
533     * from the socket if we can
534     */
535     /* if (so->so_snd.sb_flags & SB_NOTIFY)
536     * sowwakeup(so);
537     */
538     /*
539     * This is called because sowwakeup might have
540     * put data into so_snd. Since we don't so sowwakeup,
541     * we don't need this.. XXX???
542     */
543     if (so->so_snd.sb_cc)
544     (void) tcp_output(tp);
545    
546     return;
547     }
548     } else if (ti->ti_ack == tp->snd_una &&
549     tp->seg_next == (tcpiphdrp_32)tp &&
550     ti->ti_len <= sbspace(&so->so_rcv)) {
551     /*
552     * this is a pure, in-sequence data packet
553     * with nothing on the reassembly queue and
554     * we have enough buffer space to take it.
555     */
556     ++tcpstat.tcps_preddat;
557     tp->rcv_nxt += ti->ti_len;
558     tcpstat.tcps_rcvpack++;
559     tcpstat.tcps_rcvbyte += ti->ti_len;
560     /*
561     * Add data to socket buffer.
562     */
563     if (so->so_emu) {
564     if (tcp_emu(so,m)) sbappend(so, m);
565     } else
566     sbappend(so, m);
567    
568     /*
569     * XXX This is called when data arrives. Later, check
570     * if we can actually write() to the socket
571     * XXX Need to check? It's be NON_BLOCKING
572     */
573     /* sorwakeup(so); */
574    
575     /*
576     * If this is a short packet, then ACK now - with Nagel
577     * congestion avoidance sender won't send more until
578     * he gets an ACK.
579     *
580 gbeauche 1.2 * It is better to not delay acks at all to maximize
581     * TCP throughput. See RFC 2581.
582 gbeauche 1.1 */
583 gbeauche 1.2 tp->t_flags |= TF_ACKNOW;
584     tcp_output(tp);
585 gbeauche 1.1 return;
586     }
587     } /* header prediction */
588     /*
589     * Calculate amount of space in receive window,
590     * and then do TCP input processing.
591     * Receive window is amount of space in rcv queue,
592     * but not less than advertised window.
593     */
594     { int win;
595     win = sbspace(&so->so_rcv);
596     if (win < 0)
597     win = 0;
598     tp->rcv_wnd = max(win, (int)(tp->rcv_adv - tp->rcv_nxt));
599     }
600    
601     switch (tp->t_state) {
602    
603     /*
604     * If the state is LISTEN then ignore segment if it contains an RST.
605     * If the segment contains an ACK then it is bad and send a RST.
606     * If it does not contain a SYN then it is not interesting; drop it.
607     * Don't bother responding if the destination was a broadcast.
608     * Otherwise initialize tp->rcv_nxt, and tp->irs, select an initial
609     * tp->iss, and send a segment:
610     * <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>
611     * Also initialize tp->snd_nxt to tp->iss+1 and tp->snd_una to tp->iss.
612     * Fill in remote peer address fields if not previously specified.
613     * Enter SYN_RECEIVED state, and process any other fields of this
614     * segment in this state.
615     */
616     case TCPS_LISTEN: {
617    
618     if (tiflags & TH_RST)
619     goto drop;
620     if (tiflags & TH_ACK)
621     goto dropwithreset;
622     if ((tiflags & TH_SYN) == 0)
623     goto drop;
624    
625     /*
626     * This has way too many gotos...
627     * But a bit of spaghetti code never hurt anybody :)
628     */
629    
630     /*
631     * If this is destined for the control address, then flag to
632     * tcp_ctl once connected, otherwise connect
633     */
634     if ((so->so_faddr.s_addr&htonl(0xffffff00)) == special_addr.s_addr) {
635     int lastbyte=ntohl(so->so_faddr.s_addr) & 0xff;
636     if (lastbyte!=CTL_ALIAS && lastbyte!=CTL_DNS) {
637     #if 0
638     if(lastbyte==CTL_CMD || lastbyte==CTL_EXEC) {
639     /* Command or exec adress */
640     so->so_state |= SS_CTL;
641     } else
642     #endif
643     {
644     /* May be an add exec */
645     struct ex_list *ex_ptr;
646     for(ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
647     if(ex_ptr->ex_fport == so->so_fport &&
648     lastbyte == ex_ptr->ex_addr) {
649     so->so_state |= SS_CTL;
650     break;
651     }
652     }
653     }
654     if(so->so_state & SS_CTL) goto cont_input;
655     }
656     /* CTL_ALIAS: Do nothing, tcp_fconnect will be called on it */
657     }
658    
659     if (so->so_emu & EMU_NOCONNECT) {
660     so->so_emu &= ~EMU_NOCONNECT;
661     goto cont_input;
662     }
663    
664     if((tcp_fconnect(so) == -1) && (errno != EINPROGRESS) && (errno != EWOULDBLOCK)) {
665     u_char code=ICMP_UNREACH_NET;
666     DEBUG_MISC((dfd," tcp fconnect errno = %d-%s\n",
667     errno,strerror(errno)));
668     if(errno == ECONNREFUSED) {
669     /* ACK the SYN, send RST to refuse the connection */
670     tcp_respond(tp, ti, m, ti->ti_seq+1, (tcp_seq)0,
671     TH_RST|TH_ACK);
672     } else {
673     if(errno == EHOSTUNREACH) code=ICMP_UNREACH_HOST;
674     HTONL(ti->ti_seq); /* restore tcp header */
675     HTONL(ti->ti_ack);
676     HTONS(ti->ti_win);
677     HTONS(ti->ti_urp);
678     m->m_data -= sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
679     m->m_len += sizeof(struct tcpiphdr)+off-sizeof(struct tcphdr);
680     *ip=save_ip;
681     icmp_error(m, ICMP_UNREACH,code, 0,strerror(errno));
682     }
683     tp = tcp_close(tp);
684     m_free(m);
685     } else {
686     /*
687     * Haven't connected yet, save the current mbuf
688     * and ti, and return
689     * XXX Some OS's don't tell us whether the connect()
690     * succeeded or not. So we must time it out.
691     */
692     so->so_m = m;
693     so->so_ti = ti;
694     tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
695     tp->t_state = TCPS_SYN_RECEIVED;
696     }
697     return;
698    
699     cont_conn:
700     /* m==NULL
701     * Check if the connect succeeded
702     */
703     if (so->so_state & SS_NOFDREF) {
704     tp = tcp_close(tp);
705     goto dropwithreset;
706     }
707     cont_input:
708     tcp_template(tp);
709    
710     if (optp)
711     tcp_dooptions(tp, (u_char *)optp, optlen, ti);
712     /* , */
713     /* &ts_present, &ts_val, &ts_ecr); */
714    
715     if (iss)
716     tp->iss = iss;
717     else
718     tp->iss = tcp_iss;
719     tcp_iss += TCP_ISSINCR/2;
720     tp->irs = ti->ti_seq;
721     tcp_sendseqinit(tp);
722     tcp_rcvseqinit(tp);
723     tp->t_flags |= TF_ACKNOW;
724     tp->t_state = TCPS_SYN_RECEIVED;
725     tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
726     tcpstat.tcps_accepts++;
727     goto trimthenstep6;
728     } /* case TCPS_LISTEN */
729    
730     /*
731     * If the state is SYN_SENT:
732     * if seg contains an ACK, but not for our SYN, drop the input.
733     * if seg contains a RST, then drop the connection.
734     * if seg does not contain SYN, then drop it.
735     * Otherwise this is an acceptable SYN segment
736     * initialize tp->rcv_nxt and tp->irs
737     * if seg contains ack then advance tp->snd_una
738     * if SYN has been acked change to ESTABLISHED else SYN_RCVD state
739     * arrange for segment to be acked (eventually)
740     * continue processing rest of data/controls, beginning with URG
741     */
742     case TCPS_SYN_SENT:
743     if ((tiflags & TH_ACK) &&
744     (SEQ_LEQ(ti->ti_ack, tp->iss) ||
745     SEQ_GT(ti->ti_ack, tp->snd_max)))
746     goto dropwithreset;
747    
748     if (tiflags & TH_RST) {
749     if (tiflags & TH_ACK)
750     tp = tcp_drop(tp,0); /* XXX Check t_softerror! */
751     goto drop;
752     }
753    
754     if ((tiflags & TH_SYN) == 0)
755     goto drop;
756     if (tiflags & TH_ACK) {
757     tp->snd_una = ti->ti_ack;
758     if (SEQ_LT(tp->snd_nxt, tp->snd_una))
759     tp->snd_nxt = tp->snd_una;
760     }
761    
762     tp->t_timer[TCPT_REXMT] = 0;
763     tp->irs = ti->ti_seq;
764     tcp_rcvseqinit(tp);
765     tp->t_flags |= TF_ACKNOW;
766     if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {
767     tcpstat.tcps_connects++;
768     soisfconnected(so);
769     tp->t_state = TCPS_ESTABLISHED;
770    
771     /* Do window scaling on this connection? */
772     /* if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==
773     * (TF_RCVD_SCALE|TF_REQ_SCALE)) {
774     * tp->snd_scale = tp->requested_s_scale;
775     * tp->rcv_scale = tp->request_r_scale;
776     * }
777     */
778     (void) tcp_reass(tp, (struct tcpiphdr *)0,
779     (struct mbuf *)0);
780     /*
781     * if we didn't have to retransmit the SYN,
782     * use its rtt as our initial srtt & rtt var.
783     */
784     if (tp->t_rtt)
785     tcp_xmit_timer(tp, tp->t_rtt);
786     } else
787     tp->t_state = TCPS_SYN_RECEIVED;
788    
789     trimthenstep6:
790     /*
791     * Advance ti->ti_seq to correspond to first data byte.
792     * If data, trim to stay within window,
793     * dropping FIN if necessary.
794     */
795     ti->ti_seq++;
796     if (ti->ti_len > tp->rcv_wnd) {
797     todrop = ti->ti_len - tp->rcv_wnd;
798     m_adj(m, -todrop);
799     ti->ti_len = tp->rcv_wnd;
800     tiflags &= ~TH_FIN;
801     tcpstat.tcps_rcvpackafterwin++;
802     tcpstat.tcps_rcvbyteafterwin += todrop;
803     }
804     tp->snd_wl1 = ti->ti_seq - 1;
805     tp->rcv_up = ti->ti_seq;
806     goto step6;
807     } /* switch tp->t_state */
808     /*
809     * States other than LISTEN or SYN_SENT.
810     * First check timestamp, if present.
811     * Then check that at least some bytes of segment are within
812     * receive window. If segment begins before rcv_nxt,
813     * drop leading data (and SYN); if nothing left, just ack.
814     *
815     * RFC 1323 PAWS: If we have a timestamp reply on this segment
816     * and it's less than ts_recent, drop it.
817     */
818     /* if (ts_present && (tiflags & TH_RST) == 0 && tp->ts_recent &&
819     * TSTMP_LT(ts_val, tp->ts_recent)) {
820     *
821     */ /* Check to see if ts_recent is over 24 days old. */
822     /* if ((int)(tcp_now - tp->ts_recent_age) > TCP_PAWS_IDLE) {
823     */ /*
824     * * Invalidate ts_recent. If this segment updates
825     * * ts_recent, the age will be reset later and ts_recent
826     * * will get a valid value. If it does not, setting
827     * * ts_recent to zero will at least satisfy the
828     * * requirement that zero be placed in the timestamp
829     * * echo reply when ts_recent isn't valid. The
830     * * age isn't reset until we get a valid ts_recent
831     * * because we don't want out-of-order segments to be
832     * * dropped when ts_recent is old.
833     * */
834     /* tp->ts_recent = 0;
835     * } else {
836     * tcpstat.tcps_rcvduppack++;
837     * tcpstat.tcps_rcvdupbyte += ti->ti_len;
838     * tcpstat.tcps_pawsdrop++;
839     * goto dropafterack;
840     * }
841     * }
842     */
843    
844     todrop = tp->rcv_nxt - ti->ti_seq;
845     if (todrop > 0) {
846     if (tiflags & TH_SYN) {
847     tiflags &= ~TH_SYN;
848     ti->ti_seq++;
849     if (ti->ti_urp > 1)
850     ti->ti_urp--;
851     else
852     tiflags &= ~TH_URG;
853     todrop--;
854     }
855     /*
856     * Following if statement from Stevens, vol. 2, p. 960.
857     */
858     if (todrop > ti->ti_len
859     || (todrop == ti->ti_len && (tiflags & TH_FIN) == 0)) {
860     /*
861     * Any valid FIN must be to the left of the window.
862     * At this point the FIN must be a duplicate or out
863     * of sequence; drop it.
864     */
865     tiflags &= ~TH_FIN;
866    
867     /*
868     * Send an ACK to resynchronize and drop any data.
869     * But keep on processing for RST or ACK.
870     */
871     tp->t_flags |= TF_ACKNOW;
872     todrop = ti->ti_len;
873     tcpstat.tcps_rcvduppack++;
874     tcpstat.tcps_rcvdupbyte += todrop;
875     } else {
876     tcpstat.tcps_rcvpartduppack++;
877     tcpstat.tcps_rcvpartdupbyte += todrop;
878     }
879     m_adj(m, todrop);
880     ti->ti_seq += todrop;
881     ti->ti_len -= todrop;
882     if (ti->ti_urp > todrop)
883     ti->ti_urp -= todrop;
884     else {
885     tiflags &= ~TH_URG;
886     ti->ti_urp = 0;
887     }
888     }
889     /*
890     * If new data are received on a connection after the
891     * user processes are gone, then RST the other end.
892     */
893     if ((so->so_state & SS_NOFDREF) &&
894     tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
895     tp = tcp_close(tp);
896     tcpstat.tcps_rcvafterclose++;
897     goto dropwithreset;
898     }
899    
900     /*
901     * If segment ends after window, drop trailing data
902     * (and PUSH and FIN); if nothing left, just ACK.
903     */
904     todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
905     if (todrop > 0) {
906     tcpstat.tcps_rcvpackafterwin++;
907     if (todrop >= ti->ti_len) {
908     tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
909     /*
910     * If a new connection request is received
911     * while in TIME_WAIT, drop the old connection
912     * and start over if the sequence numbers
913     * are above the previous ones.
914     */
915     if (tiflags & TH_SYN &&
916     tp->t_state == TCPS_TIME_WAIT &&
917     SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
918     iss = tp->rcv_nxt + TCP_ISSINCR;
919     tp = tcp_close(tp);
920     goto findso;
921     }
922     /*
923     * If window is closed can only take segments at
924     * window edge, and have to drop data and PUSH from
925     * incoming segments. Continue processing, but
926     * remember to ack. Otherwise, drop segment
927     * and ack.
928     */
929     if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
930     tp->t_flags |= TF_ACKNOW;
931     tcpstat.tcps_rcvwinprobe++;
932     } else
933     goto dropafterack;
934     } else
935     tcpstat.tcps_rcvbyteafterwin += todrop;
936     m_adj(m, -todrop);
937     ti->ti_len -= todrop;
938     tiflags &= ~(TH_PUSH|TH_FIN);
939     }
940    
941     /*
942     * If last ACK falls within this segment's sequence numbers,
943     * record its timestamp.
944     */
945     /* if (ts_present && SEQ_LEQ(ti->ti_seq, tp->last_ack_sent) &&
946     * SEQ_LT(tp->last_ack_sent, ti->ti_seq + ti->ti_len +
947     * ((tiflags & (TH_SYN|TH_FIN)) != 0))) {
948     * tp->ts_recent_age = tcp_now;
949     * tp->ts_recent = ts_val;
950     * }
951     */
952    
953     /*
954     * If the RST bit is set examine the state:
955     * SYN_RECEIVED STATE:
956     * If passive open, return to LISTEN state.
957     * If active open, inform user that connection was refused.
958     * ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:
959     * Inform user that connection was reset, and close tcb.
960     * CLOSING, LAST_ACK, TIME_WAIT STATES
961     * Close the tcb.
962     */
963     if (tiflags&TH_RST) switch (tp->t_state) {
964    
965     case TCPS_SYN_RECEIVED:
966     /* so->so_error = ECONNREFUSED; */
967     goto close;
968    
969     case TCPS_ESTABLISHED:
970     case TCPS_FIN_WAIT_1:
971     case TCPS_FIN_WAIT_2:
972     case TCPS_CLOSE_WAIT:
973     /* so->so_error = ECONNRESET; */
974     close:
975     tp->t_state = TCPS_CLOSED;
976     tcpstat.tcps_drops++;
977     tp = tcp_close(tp);
978     goto drop;
979    
980     case TCPS_CLOSING:
981     case TCPS_LAST_ACK:
982     case TCPS_TIME_WAIT:
983     tp = tcp_close(tp);
984     goto drop;
985     }
986    
987     /*
988     * If a SYN is in the window, then this is an
989     * error and we send an RST and drop the connection.
990     */
991     if (tiflags & TH_SYN) {
992     tp = tcp_drop(tp,0);
993     goto dropwithreset;
994     }
995    
996     /*
997     * If the ACK bit is off we drop the segment and return.
998     */
999     if ((tiflags & TH_ACK) == 0) goto drop;
1000    
1001     /*
1002     * Ack processing.
1003     */
1004     switch (tp->t_state) {
1005     /*
1006     * In SYN_RECEIVED state if the ack ACKs our SYN then enter
1007     * ESTABLISHED state and continue processing, otherwise
1008     * send an RST. una<=ack<=max
1009     */
1010     case TCPS_SYN_RECEIVED:
1011    
1012     if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
1013     SEQ_GT(ti->ti_ack, tp->snd_max))
1014     goto dropwithreset;
1015     tcpstat.tcps_connects++;
1016     tp->t_state = TCPS_ESTABLISHED;
1017     /*
1018     * The sent SYN is ack'ed with our sequence number +1
1019     * The first data byte already in the buffer will get
1020     * lost if no correction is made. This is only needed for
1021     * SS_CTL since the buffer is empty otherwise.
1022     * tp->snd_una++; or:
1023     */
1024     tp->snd_una=ti->ti_ack;
1025     if (so->so_state & SS_CTL) {
1026     /* So tcp_ctl reports the right state */
1027     ret = tcp_ctl(so);
1028     if (ret == 1) {
1029     soisfconnected(so);
1030     so->so_state &= ~SS_CTL; /* success XXX */
1031     } else if (ret == 2) {
1032     so->so_state = SS_NOFDREF; /* CTL_CMD */
1033     } else {
1034     needoutput = 1;
1035     tp->t_state = TCPS_FIN_WAIT_1;
1036     }
1037     } else {
1038     soisfconnected(so);
1039     }
1040    
1041     /* Do window scaling? */
1042     /* if ((tp->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) ==
1043     * (TF_RCVD_SCALE|TF_REQ_SCALE)) {
1044     * tp->snd_scale = tp->requested_s_scale;
1045     * tp->rcv_scale = tp->request_r_scale;
1046     * }
1047     */
1048     (void) tcp_reass(tp, (struct tcpiphdr *)0, (struct mbuf *)0);
1049     tp->snd_wl1 = ti->ti_seq - 1;
1050     /* Avoid ack processing; snd_una==ti_ack => dup ack */
1051     goto synrx_to_est;
1052     /* fall into ... */
1053    
1054     /*
1055     * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
1056     * ACKs. If the ack is in the range
1057     * tp->snd_una < ti->ti_ack <= tp->snd_max
1058     * then advance tp->snd_una to ti->ti_ack and drop
1059     * data from the retransmission queue. If this ACK reflects
1060     * more up to date window information we update our window information.
1061     */
1062     case TCPS_ESTABLISHED:
1063     case TCPS_FIN_WAIT_1:
1064     case TCPS_FIN_WAIT_2:
1065     case TCPS_CLOSE_WAIT:
1066     case TCPS_CLOSING:
1067     case TCPS_LAST_ACK:
1068     case TCPS_TIME_WAIT:
1069    
1070     if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
1071     if (ti->ti_len == 0 && tiwin == tp->snd_wnd) {
1072     tcpstat.tcps_rcvdupack++;
1073     DEBUG_MISC((dfd," dup ack m = %lx so = %lx \n",
1074     (long )m, (long )so));
1075     /*
1076     * If we have outstanding data (other than
1077     * a window probe), this is a completely
1078     * duplicate ack (ie, window info didn't
1079     * change), the ack is the biggest we've
1080     * seen and we've seen exactly our rexmt
1081     * threshold of them, assume a packet
1082     * has been dropped and retransmit it.
1083     * Kludge snd_nxt & the congestion
1084     * window so we send only this one
1085     * packet.
1086     *
1087     * We know we're losing at the current
1088     * window size so do congestion avoidance
1089     * (set ssthresh to half the current window
1090     * and pull our congestion window back to
1091     * the new ssthresh).
1092     *
1093     * Dup acks mean that packets have left the
1094     * network (they're now cached at the receiver)
1095     * so bump cwnd by the amount in the receiver
1096     * to keep a constant cwnd packets in the
1097     * network.
1098     */
1099     if (tp->t_timer[TCPT_REXMT] == 0 ||
1100     ti->ti_ack != tp->snd_una)
1101     tp->t_dupacks = 0;
1102     else if (++tp->t_dupacks == tcprexmtthresh) {
1103     tcp_seq onxt = tp->snd_nxt;
1104     u_int win =
1105     min(tp->snd_wnd, tp->snd_cwnd) / 2 /
1106     tp->t_maxseg;
1107    
1108     if (win < 2)
1109     win = 2;
1110     tp->snd_ssthresh = win * tp->t_maxseg;
1111     tp->t_timer[TCPT_REXMT] = 0;
1112     tp->t_rtt = 0;
1113     tp->snd_nxt = ti->ti_ack;
1114     tp->snd_cwnd = tp->t_maxseg;
1115     (void) tcp_output(tp);
1116     tp->snd_cwnd = tp->snd_ssthresh +
1117     tp->t_maxseg * tp->t_dupacks;
1118     if (SEQ_GT(onxt, tp->snd_nxt))
1119     tp->snd_nxt = onxt;
1120     goto drop;
1121     } else if (tp->t_dupacks > tcprexmtthresh) {
1122     tp->snd_cwnd += tp->t_maxseg;
1123     (void) tcp_output(tp);
1124     goto drop;
1125     }
1126     } else
1127     tp->t_dupacks = 0;
1128     break;
1129     }
1130     synrx_to_est:
1131     /*
1132     * If the congestion window was inflated to account
1133     * for the other side's cached packets, retract it.
1134     */
1135     if (tp->t_dupacks > tcprexmtthresh &&
1136     tp->snd_cwnd > tp->snd_ssthresh)
1137     tp->snd_cwnd = tp->snd_ssthresh;
1138     tp->t_dupacks = 0;
1139     if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
1140     tcpstat.tcps_rcvacktoomuch++;
1141     goto dropafterack;
1142     }
1143     acked = ti->ti_ack - tp->snd_una;
1144     tcpstat.tcps_rcvackpack++;
1145     tcpstat.tcps_rcvackbyte += acked;
1146    
1147     /*
1148     * If we have a timestamp reply, update smoothed
1149     * round trip time. If no timestamp is present but
1150     * transmit timer is running and timed sequence
1151     * number was acked, update smoothed round trip time.
1152     * Since we now have an rtt measurement, cancel the
1153     * timer backoff (cf., Phil Karn's retransmit alg.).
1154     * Recompute the initial retransmit timer.
1155     */
1156     /* if (ts_present)
1157     * tcp_xmit_timer(tp, tcp_now-ts_ecr+1);
1158     * else
1159     */
1160     if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
1161     tcp_xmit_timer(tp,tp->t_rtt);
1162    
1163     /*
1164     * If all outstanding data is acked, stop retransmit
1165     * timer and remember to restart (more output or persist).
1166     * If there is more data to be acked, restart retransmit
1167     * timer, using current (possibly backed-off) value.
1168     */
1169     if (ti->ti_ack == tp->snd_max) {
1170     tp->t_timer[TCPT_REXMT] = 0;
1171     needoutput = 1;
1172     } else if (tp->t_timer[TCPT_PERSIST] == 0)
1173     tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
1174     /*
1175     * When new data is acked, open the congestion window.
1176     * If the window gives us less than ssthresh packets
1177     * in flight, open exponentially (maxseg per packet).
1178     * Otherwise open linearly: maxseg per window
1179     * (maxseg^2 / cwnd per packet).
1180     */
1181     {
1182     register u_int cw = tp->snd_cwnd;
1183     register u_int incr = tp->t_maxseg;
1184    
1185     if (cw > tp->snd_ssthresh)
1186     incr = incr * incr / cw;
1187     tp->snd_cwnd = min(cw + incr, TCP_MAXWIN<<tp->snd_scale);
1188     }
1189     if (acked > so->so_snd.sb_cc) {
1190     tp->snd_wnd -= so->so_snd.sb_cc;
1191     sbdrop(&so->so_snd, (int )so->so_snd.sb_cc);
1192     ourfinisacked = 1;
1193     } else {
1194     sbdrop(&so->so_snd, acked);
1195     tp->snd_wnd -= acked;
1196     ourfinisacked = 0;
1197     }
1198     /*
1199     * XXX sowwakup is called when data is acked and there's room for
1200     * for more data... it should read() the socket
1201     */
1202     /* if (so->so_snd.sb_flags & SB_NOTIFY)
1203     * sowwakeup(so);
1204     */
1205     tp->snd_una = ti->ti_ack;
1206     if (SEQ_LT(tp->snd_nxt, tp->snd_una))
1207     tp->snd_nxt = tp->snd_una;
1208    
1209     switch (tp->t_state) {
1210    
1211     /*
1212     * In FIN_WAIT_1 STATE in addition to the processing
1213     * for the ESTABLISHED state if our FIN is now acknowledged
1214     * then enter FIN_WAIT_2.
1215     */
1216     case TCPS_FIN_WAIT_1:
1217     if (ourfinisacked) {
1218     /*
1219     * If we can't receive any more
1220     * data, then closing user can proceed.
1221     * Starting the timer is contrary to the
1222     * specification, but if we don't get a FIN
1223     * we'll hang forever.
1224     */
1225     if (so->so_state & SS_FCANTRCVMORE) {
1226     soisfdisconnected(so);
1227     tp->t_timer[TCPT_2MSL] = tcp_maxidle;
1228     }
1229     tp->t_state = TCPS_FIN_WAIT_2;
1230     }
1231     break;
1232    
1233     /*
1234     * In CLOSING STATE in addition to the processing for
1235     * the ESTABLISHED state if the ACK acknowledges our FIN
1236     * then enter the TIME-WAIT state, otherwise ignore
1237     * the segment.
1238     */
1239     case TCPS_CLOSING:
1240     if (ourfinisacked) {
1241     tp->t_state = TCPS_TIME_WAIT;
1242     tcp_canceltimers(tp);
1243     tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1244     soisfdisconnected(so);
1245     }
1246     break;
1247    
1248     /*
1249     * In LAST_ACK, we may still be waiting for data to drain
1250     * and/or to be acked, as well as for the ack of our FIN.
1251     * If our FIN is now acknowledged, delete the TCB,
1252     * enter the closed state and return.
1253     */
1254     case TCPS_LAST_ACK:
1255     if (ourfinisacked) {
1256     tp = tcp_close(tp);
1257     goto drop;
1258     }
1259     break;
1260    
1261     /*
1262     * In TIME_WAIT state the only thing that should arrive
1263     * is a retransmission of the remote FIN. Acknowledge
1264     * it and restart the finack timer.
1265     */
1266     case TCPS_TIME_WAIT:
1267     tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1268     goto dropafterack;
1269     }
1270     } /* switch(tp->t_state) */
1271    
1272     step6:
1273     /*
1274     * Update window information.
1275     * Don't look at window if no ACK: TAC's send garbage on first SYN.
1276     */
1277     if ((tiflags & TH_ACK) &&
1278     (SEQ_LT(tp->snd_wl1, ti->ti_seq) ||
1279     (tp->snd_wl1 == ti->ti_seq && (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
1280     (tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd))))) {
1281     /* keep track of pure window updates */
1282     if (ti->ti_len == 0 &&
1283     tp->snd_wl2 == ti->ti_ack && tiwin > tp->snd_wnd)
1284     tcpstat.tcps_rcvwinupd++;
1285     tp->snd_wnd = tiwin;
1286     tp->snd_wl1 = ti->ti_seq;
1287     tp->snd_wl2 = ti->ti_ack;
1288     if (tp->snd_wnd > tp->max_sndwnd)
1289     tp->max_sndwnd = tp->snd_wnd;
1290     needoutput = 1;
1291     }
1292    
1293     /*
1294     * Process segments with URG.
1295     */
1296     if ((tiflags & TH_URG) && ti->ti_urp &&
1297     TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1298     /*
1299     * This is a kludge, but if we receive and accept
1300     * random urgent pointers, we'll crash in
1301     * soreceive. It's hard to imagine someone
1302     * actually wanting to send this much urgent data.
1303     */
1304     if (ti->ti_urp + so->so_rcv.sb_cc > so->so_rcv.sb_datalen) {
1305     ti->ti_urp = 0;
1306     tiflags &= ~TH_URG;
1307     goto dodata;
1308     }
1309     /*
1310     * If this segment advances the known urgent pointer,
1311     * then mark the data stream. This should not happen
1312     * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since
1313     * a FIN has been received from the remote side.
1314     * In these states we ignore the URG.
1315     *
1316     * According to RFC961 (Assigned Protocols),
1317     * the urgent pointer points to the last octet
1318     * of urgent data. We continue, however,
1319     * to consider it to indicate the first octet
1320     * of data past the urgent section as the original
1321     * spec states (in one of two places).
1322     */
1323     if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
1324     tp->rcv_up = ti->ti_seq + ti->ti_urp;
1325     so->so_urgc = so->so_rcv.sb_cc +
1326     (tp->rcv_up - tp->rcv_nxt); /* -1; */
1327     tp->rcv_up = ti->ti_seq + ti->ti_urp;
1328    
1329     }
1330     } else
1331     /*
1332     * If no out of band data is expected,
1333     * pull receive urgent pointer along
1334     * with the receive window.
1335     */
1336     if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))
1337     tp->rcv_up = tp->rcv_nxt;
1338     dodata:
1339    
1340     /*
1341     * Process the segment text, merging it into the TCP sequencing queue,
1342     * and arranging for acknowledgment of receipt if necessary.
1343     * This process logically involves adjusting tp->rcv_wnd as data
1344     * is presented to the user (this happens in tcp_usrreq.c,
1345     * case PRU_RCVD). If a FIN has already been received on this
1346     * connection then we just ignore the text.
1347     */
1348     if ((ti->ti_len || (tiflags&TH_FIN)) &&
1349     TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1350     TCP_REASS(tp, ti, m, so, tiflags);
1351     /*
1352     * Note the amount of data that peer has sent into
1353     * our window, in order to estimate the sender's
1354     * buffer size.
1355     */
1356     len = so->so_rcv.sb_datalen - (tp->rcv_adv - tp->rcv_nxt);
1357     } else {
1358     m_free(m);
1359     tiflags &= ~TH_FIN;
1360     }
1361    
1362     /*
1363     * If FIN is received ACK the FIN and let the user know
1364     * that the connection is closing.
1365     */
1366     if (tiflags & TH_FIN) {
1367     if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {
1368     /*
1369     * If we receive a FIN we can't send more data,
1370     * set it SS_FDRAIN
1371     * Shutdown the socket if there is no rx data in the
1372     * buffer.
1373     * soread() is called on completion of shutdown() and
1374     * will got to TCPS_LAST_ACK, and use tcp_output()
1375     * to send the FIN.
1376     */
1377     /* sofcantrcvmore(so); */
1378     sofwdrain(so);
1379    
1380     tp->t_flags |= TF_ACKNOW;
1381     tp->rcv_nxt++;
1382     }
1383     switch (tp->t_state) {
1384    
1385     /*
1386     * In SYN_RECEIVED and ESTABLISHED STATES
1387     * enter the CLOSE_WAIT state.
1388     */
1389     case TCPS_SYN_RECEIVED:
1390     case TCPS_ESTABLISHED:
1391     if(so->so_emu == EMU_CTL) /* no shutdown on socket */
1392     tp->t_state = TCPS_LAST_ACK;
1393     else
1394     tp->t_state = TCPS_CLOSE_WAIT;
1395     break;
1396    
1397     /*
1398     * If still in FIN_WAIT_1 STATE FIN has not been acked so
1399     * enter the CLOSING state.
1400     */
1401     case TCPS_FIN_WAIT_1:
1402     tp->t_state = TCPS_CLOSING;
1403     break;
1404    
1405     /*
1406     * In FIN_WAIT_2 state enter the TIME_WAIT state,
1407     * starting the time-wait timer, turning off the other
1408     * standard timers.
1409     */
1410     case TCPS_FIN_WAIT_2:
1411     tp->t_state = TCPS_TIME_WAIT;
1412     tcp_canceltimers(tp);
1413     tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1414     soisfdisconnected(so);
1415     break;
1416    
1417     /*
1418     * In TIME_WAIT state restart the 2 MSL time_wait timer.
1419     */
1420     case TCPS_TIME_WAIT:
1421     tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
1422     break;
1423     }
1424     }
1425    
1426     /*
1427     * If this is a small packet, then ACK now - with Nagel
1428     * congestion avoidance sender won't send more until
1429     * he gets an ACK.
1430     *
1431     * See above.
1432     */
1433     /* if (ti->ti_len && (unsigned)ti->ti_len < tp->t_maxseg) {
1434     */
1435     /* if ((ti->ti_len && (unsigned)ti->ti_len < tp->t_maxseg &&
1436     * (so->so_iptos & IPTOS_LOWDELAY) == 0) ||
1437     * ((so->so_iptos & IPTOS_LOWDELAY) &&
1438     * ((struct tcpiphdr_2 *)ti)->first_char == (char)27)) {
1439     */
1440     if (ti->ti_len && (unsigned)ti->ti_len <= 5 &&
1441     ((struct tcpiphdr_2 *)ti)->first_char == (char)27) {
1442     tp->t_flags |= TF_ACKNOW;
1443     }
1444    
1445     /*
1446     * Return any desired output.
1447     */
1448     if (needoutput || (tp->t_flags & TF_ACKNOW)) {
1449     (void) tcp_output(tp);
1450     }
1451     return;
1452    
1453     dropafterack:
1454     /*
1455     * Generate an ACK dropping incoming segment if it occupies
1456     * sequence space, where the ACK reflects our state.
1457     */
1458     if (tiflags & TH_RST)
1459     goto drop;
1460     m_freem(m);
1461     tp->t_flags |= TF_ACKNOW;
1462     (void) tcp_output(tp);
1463     return;
1464    
1465     dropwithreset:
1466     /* reuses m if m!=NULL, m_free() unnecessary */
1467     if (tiflags & TH_ACK)
1468     tcp_respond(tp, ti, m, (tcp_seq)0, ti->ti_ack, TH_RST);
1469     else {
1470     if (tiflags & TH_SYN) ti->ti_len++;
1471     tcp_respond(tp, ti, m, ti->ti_seq+ti->ti_len, (tcp_seq)0,
1472     TH_RST|TH_ACK);
1473     }
1474    
1475     return;
1476    
1477     drop:
1478     /*
1479     * Drop space held by incoming segment and return.
1480     */
1481     m_free(m);
1482    
1483     return;
1484     }
1485    
1486     /* , ts_present, ts_val, ts_ecr) */
1487     /* int *ts_present;
1488     * u_int32_t *ts_val, *ts_ecr;
1489     */
1490     void
1491     tcp_dooptions(tp, cp, cnt, ti)
1492     struct tcpcb *tp;
1493     u_char *cp;
1494     int cnt;
1495     struct tcpiphdr *ti;
1496     {
1497     u_int16_t mss;
1498     int opt, optlen;
1499    
1500     DEBUG_CALL("tcp_dooptions");
1501     DEBUG_ARGS((dfd," tp = %lx cnt=%i \n", (long )tp, cnt));
1502    
1503     for (; cnt > 0; cnt -= optlen, cp += optlen) {
1504     opt = cp[0];
1505     if (opt == TCPOPT_EOL)
1506     break;
1507     if (opt == TCPOPT_NOP)
1508     optlen = 1;
1509     else {
1510     optlen = cp[1];
1511     if (optlen <= 0)
1512     break;
1513     }
1514     switch (opt) {
1515    
1516     default:
1517     continue;
1518    
1519     case TCPOPT_MAXSEG:
1520     if (optlen != TCPOLEN_MAXSEG)
1521     continue;
1522     if (!(ti->ti_flags & TH_SYN))
1523     continue;
1524     memcpy((char *) &mss, (char *) cp + 2, sizeof(mss));
1525     NTOHS(mss);
1526     (void) tcp_mss(tp, mss); /* sets t_maxseg */
1527     break;
1528    
1529     /* case TCPOPT_WINDOW:
1530     * if (optlen != TCPOLEN_WINDOW)
1531     * continue;
1532     * if (!(ti->ti_flags & TH_SYN))
1533     * continue;
1534     * tp->t_flags |= TF_RCVD_SCALE;
1535     * tp->requested_s_scale = min(cp[2], TCP_MAX_WINSHIFT);
1536     * break;
1537     */
1538     /* case TCPOPT_TIMESTAMP:
1539     * if (optlen != TCPOLEN_TIMESTAMP)
1540     * continue;
1541     * *ts_present = 1;
1542     * memcpy((char *) ts_val, (char *)cp + 2, sizeof(*ts_val));
1543     * NTOHL(*ts_val);
1544     * memcpy((char *) ts_ecr, (char *)cp + 6, sizeof(*ts_ecr));
1545     * NTOHL(*ts_ecr);
1546     *
1547     */ /*
1548     * * A timestamp received in a SYN makes
1549     * * it ok to send timestamp requests and replies.
1550     * */
1551     /* if (ti->ti_flags & TH_SYN) {
1552     * tp->t_flags |= TF_RCVD_TSTMP;
1553     * tp->ts_recent = *ts_val;
1554     * tp->ts_recent_age = tcp_now;
1555     * }
1556     */ break;
1557     }
1558     }
1559     }
1560    
1561    
1562     /*
1563     * Pull out of band byte out of a segment so
1564     * it doesn't appear in the user's data queue.
1565     * It is still reflected in the segment length for
1566     * sequencing purposes.
1567     */
1568    
1569     #ifdef notdef
1570    
1571     void
1572     tcp_pulloutofband(so, ti, m)
1573     struct socket *so;
1574     struct tcpiphdr *ti;
1575     register struct mbuf *m;
1576     {
1577     int cnt = ti->ti_urp - 1;
1578    
1579     while (cnt >= 0) {
1580     if (m->m_len > cnt) {
1581     char *cp = mtod(m, caddr_t) + cnt;
1582     struct tcpcb *tp = sototcpcb(so);
1583    
1584     tp->t_iobc = *cp;
1585     tp->t_oobflags |= TCPOOB_HAVEDATA;
1586     memcpy(sp, cp+1, (unsigned)(m->m_len - cnt - 1));
1587     m->m_len--;
1588     return;
1589     }
1590     cnt -= m->m_len;
1591     m = m->m_next; /* XXX WRONG! Fix it! */
1592     if (m == 0)
1593     break;
1594     }
1595     panic("tcp_pulloutofband");
1596     }
1597    
1598     #endif /* notdef */
1599    
1600     /*
1601     * Collect new round-trip time estimate
1602     * and update averages and current timeout.
1603     */
1604    
1605     void
1606     tcp_xmit_timer(tp, rtt)
1607     register struct tcpcb *tp;
1608     int rtt;
1609     {
1610     register short delta;
1611    
1612     DEBUG_CALL("tcp_xmit_timer");
1613     DEBUG_ARG("tp = %lx", (long)tp);
1614     DEBUG_ARG("rtt = %d", rtt);
1615    
1616     tcpstat.tcps_rttupdated++;
1617     if (tp->t_srtt != 0) {
1618     /*
1619     * srtt is stored as fixed point with 3 bits after the
1620     * binary point (i.e., scaled by 8). The following magic
1621     * is equivalent to the smoothing algorithm in rfc793 with
1622     * an alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed
1623     * point). Adjust rtt to origin 0.
1624     */
1625     delta = rtt - 1 - (tp->t_srtt >> TCP_RTT_SHIFT);
1626     if ((tp->t_srtt += delta) <= 0)
1627     tp->t_srtt = 1;
1628     /*
1629     * We accumulate a smoothed rtt variance (actually, a
1630     * smoothed mean difference), then set the retransmit
1631     * timer to smoothed rtt + 4 times the smoothed variance.
1632     * rttvar is stored as fixed point with 2 bits after the
1633     * binary point (scaled by 4). The following is
1634     * equivalent to rfc793 smoothing with an alpha of .75
1635     * (rttvar = rttvar*3/4 + |delta| / 4). This replaces
1636     * rfc793's wired-in beta.
1637     */
1638     if (delta < 0)
1639     delta = -delta;
1640     delta -= (tp->t_rttvar >> TCP_RTTVAR_SHIFT);
1641     if ((tp->t_rttvar += delta) <= 0)
1642     tp->t_rttvar = 1;
1643     } else {
1644     /*
1645     * No rtt measurement yet - use the unsmoothed rtt.
1646     * Set the variance to half the rtt (so our first
1647     * retransmit happens at 3*rtt).
1648     */
1649     tp->t_srtt = rtt << TCP_RTT_SHIFT;
1650     tp->t_rttvar = rtt << (TCP_RTTVAR_SHIFT - 1);
1651     }
1652     tp->t_rtt = 0;
1653     tp->t_rxtshift = 0;
1654    
1655     /*
1656     * the retransmit should happen at rtt + 4 * rttvar.
1657     * Because of the way we do the smoothing, srtt and rttvar
1658     * will each average +1/2 tick of bias. When we compute
1659     * the retransmit timer, we want 1/2 tick of rounding and
1660     * 1 extra tick because of +-1/2 tick uncertainty in the
1661     * firing of the timer. The bias will give us exactly the
1662     * 1.5 tick we need. But, because the bias is
1663     * statistical, we have to test that we don't drop below
1664     * the minimum feasible timer (which is 2 ticks).
1665     */
1666     TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
1667     (short)tp->t_rttmin, TCPTV_REXMTMAX); /* XXX */
1668    
1669     /*
1670     * We received an ack for a packet that wasn't retransmitted;
1671     * it is probably safe to discard any error indications we've
1672     * received recently. This isn't quite right, but close enough
1673     * for now (a route might have failed after we sent a segment,
1674     * and the return path might not be symmetrical).
1675     */
1676     tp->t_softerror = 0;
1677     }
1678    
1679     /*
1680     * Determine a reasonable value for maxseg size.
1681     * If the route is known, check route for mtu.
1682     * If none, use an mss that can be handled on the outgoing
1683     * interface without forcing IP to fragment; if bigger than
1684     * an mbuf cluster (MCLBYTES), round down to nearest multiple of MCLBYTES
1685     * to utilize large mbufs. If no route is found, route has no mtu,
1686     * or the destination isn't local, use a default, hopefully conservative
1687     * size (usually 512 or the default IP max size, but no more than the mtu
1688     * of the interface), as we can't discover anything about intervening
1689     * gateways or networks. We also initialize the congestion/slow start
1690     * window to be a single segment if the destination isn't local.
1691     * While looking at the routing entry, we also initialize other path-dependent
1692     * parameters from pre-set or cached values in the routing entry.
1693     */
1694    
1695     int
1696     tcp_mss(tp, offer)
1697     register struct tcpcb *tp;
1698     u_int offer;
1699     {
1700     struct socket *so = tp->t_socket;
1701     int mss;
1702    
1703     DEBUG_CALL("tcp_mss");
1704     DEBUG_ARG("tp = %lx", (long)tp);
1705     DEBUG_ARG("offer = %d", offer);
1706    
1707     mss = min(if_mtu, if_mru) - sizeof(struct tcpiphdr);
1708     if (offer)
1709     mss = min(mss, offer);
1710     mss = max(mss, 32);
1711     if (mss < tp->t_maxseg || offer != 0)
1712     tp->t_maxseg = mss;
1713    
1714     tp->snd_cwnd = mss;
1715    
1716     sbreserve(&so->so_snd, tcp_sndspace+((tcp_sndspace%mss)?(mss-(tcp_sndspace%mss)):0));
1717     sbreserve(&so->so_rcv, tcp_rcvspace+((tcp_rcvspace%mss)?(mss-(tcp_rcvspace%mss)):0));
1718    
1719     DEBUG_MISC((dfd, " returning mss = %d\n", mss));
1720    
1721     return mss;
1722     }