sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/servers/inet/generic/tcp_send.c
Lionel Sambuc 744378194d Alignement on netbsd types, part 1 
The following types are modified (old -> new):
 * _BSD_USECONDS_T_ int       -> unsigned int
 * __socklen_t      __int32_t -> __uint32_t
 * blksize_t        uint32_t  -> int32_t
 * rlim_t           uint32_t  -> uint64_t
On ARM:
 * _BSD_CLOCK_T_    int       -> unsigned int
On Intel:
 * _BSD_CLOCK_T_    int       -> unsigned long

bin/cat is also updated in order to fix warnings.

_BSD_TIMER_T_ has still to be aligned.

Change-Id: I2b4fda024125a19901120546c4e22e443ba5e9d7
2014-02-18 11:25:01 +01:00

1449 lines
33 KiB
C
Raw Blame History

/*
tcp_send.c
Copyright 1995 Philip Homburg
*/
#include "inet.h"
#include "buf.h"
#include "clock.h"
#include "event.h"
#include "type.h"
#include "sr.h"
#include "assert.h"
#include "io.h"
#include "ip.h"
#include "tcp.h"
#include "tcp_int.h"
THIS_FILE
static acc_t *make_pack ARGS(( tcp_conn_t *tcp_conn ));
static void tcp_send_timeout ARGS(( int conn, struct timer *timer ));
static void do_snd_event ARGS(( event_t *ev, ev_arg_t arg ));
void tcp_conn_write (tcp_conn, enq)
tcp_conn_t *tcp_conn;
int enq; /* Writes need to be enqueued. */
{
tcp_port_t *tcp_port;
ev_arg_t snd_arg;
assert (tcp_conn->tc_flags & TCF_INUSE);
tcp_port= tcp_conn->tc_port;
if (tcp_conn->tc_flags & TCF_MORE2WRITE)
return;
/* Do we really have something to send here? */
if (tcp_conn->tc_SND_UNA == tcp_conn->tc_SND_NXT &&
!(tcp_conn->tc_flags & TCF_SEND_ACK) &&
!tcp_conn->tc_frag2send)
{
return;
}
tcp_conn->tc_flags |= TCF_MORE2WRITE;
tcp_conn->tc_send_link= NULL;
if (!tcp_port->tp_snd_head)
{
tcp_port->tp_snd_head= tcp_conn;
tcp_port->tp_snd_tail= tcp_conn;
if (enq)
{
snd_arg.ev_ptr= tcp_port;
if (!ev_in_queue(&tcp_port->tp_snd_event))
{
ev_enqueue(&tcp_port->tp_snd_event,
do_snd_event, snd_arg);
}
}
else
tcp_port_write(tcp_port);
}
else
{
tcp_port->tp_snd_tail->tc_send_link= tcp_conn;
tcp_port->tp_snd_tail= tcp_conn;
}
}
static void do_snd_event(ev, arg)
event_t *ev;
ev_arg_t arg;
{
tcp_port_t *tcp_port;
tcp_port= arg.ev_ptr;
assert(ev == &tcp_port->tp_snd_event);
tcp_port_write(tcp_port);
}
void tcp_port_write(tcp_port)
tcp_port_t *tcp_port;
{
tcp_conn_t *tcp_conn;
acc_t *pack2write;
int r;
assert (!(tcp_port->tp_flags & TPF_WRITE_IP));
while(tcp_port->tp_snd_head)
{
tcp_conn= tcp_port->tp_snd_head;
assert(tcp_conn->tc_flags & TCF_MORE2WRITE);
for(;;)
{
if (tcp_conn->tc_frag2send)
{
pack2write= tcp_conn->tc_frag2send;
tcp_conn->tc_frag2send= 0;
}
else
{
tcp_conn->tc_busy++;
pack2write= make_pack(tcp_conn);
tcp_conn->tc_busy--;
if (!pack2write)
break;
}
r= ip_send(tcp_port->tp_ipfd, pack2write,
bf_bufsize(pack2write));
if (r != NW_OK)
{
if (r == NW_WOULDBLOCK)
break;
if (r == EPACKSIZE)
{
tcp_mtu_exceeded(tcp_conn);
continue;
}
if (r == EHOSTUNREACH || r == ENETUNREACH ||
r == ENETDOWN)
{
tcp_notreach(tcp_conn, r);
continue;
}
if (r == EAFNOSUPPORT)
continue;
}
assert(r == NW_OK ||
(printf("ip_send failed, error %d\n", r),0));
}
if (pack2write)
{
tcp_port->tp_flags |= TPF_WRITE_IP;
tcp_port->tp_pack= pack2write;
r= ip_write (tcp_port->tp_ipfd,
bf_bufsize(pack2write));
if (r == NW_SUSPEND)
{
tcp_port->tp_flags |= TPF_WRITE_SP;
return;
}
assert(r == NW_OK);
tcp_port->tp_flags &= ~TPF_WRITE_IP;
assert(!(tcp_port->tp_flags &
(TPF_WRITE_IP|TPF_WRITE_SP)));
continue;
}
tcp_conn->tc_flags &= ~TCF_MORE2WRITE;
tcp_port->tp_snd_head= tcp_conn->tc_send_link;
}
}
static acc_t *make_pack(tcp_conn)
tcp_conn_t *tcp_conn;
{
acc_t *pack2write, *tmp_pack, *tcp_pack;
tcp_hdr_t *tcp_hdr = NULL;
ip_hdr_t *ip_hdr = NULL;
int tot_hdr_size, ip_hdr_len, no_push, head, more2write;
u32_t seg_seq, seg_lo_data, queue_lo_data, seg_hi, seg_hi_data;
u16_t seg_up, mss;
u8_t seg_flags;
size_t pack_size;
clock_t curr_time, new_dis;
u8_t *optptr;
mss= tcp_conn->tc_mtu-IP_TCP_MIN_HDR_SIZE;
assert(tcp_conn->tc_busy);
curr_time= get_time();
switch (tcp_conn->tc_state)
{
case TCS_CLOSED:
case TCS_LISTEN:
return NULL;
case TCS_SYN_RECEIVED:
case TCS_SYN_SENT:
if (tcp_conn->tc_SND_TRM == tcp_conn->tc_SND_NXT &&
!(tcp_conn->tc_flags & TCF_SEND_ACK))
{
return 0;
}
tcp_conn->tc_flags &= ~TCF_SEND_ACK;
/* Advertise a mss based on the port mtu. The current mtu may
* be lower if the other side sends a smaller mss.
*/
mss= tcp_conn->tc_port->tp_mtu-IP_TCP_MIN_HDR_SIZE;
/* Include a max segment size option. */
assert(tcp_conn->tc_tcpopt == NULL);
tcp_conn->tc_tcpopt= bf_memreq(4);
optptr= (u8_t *)ptr2acc_data(tcp_conn->tc_tcpopt);
optptr[0]= TCP_OPT_MSS;
optptr[1]= 4;
optptr[2]= mss >> 8;
optptr[3]= mss & 0xFF;
pack2write= tcp_make_header(tcp_conn, &ip_hdr, &tcp_hdr,
(acc_t *)0);
bf_afree(tcp_conn->tc_tcpopt);
tcp_conn->tc_tcpopt= NULL;
if (!pack2write)
{
DBLOCK(1, printf("connection closed while inuse\n"));
return 0;
}
tot_hdr_size= bf_bufsize(pack2write);
seg_seq= tcp_conn->tc_SND_TRM;
if (tcp_conn->tc_state == TCS_SYN_SENT)
seg_flags= 0;
else
seg_flags= THF_ACK; /* except for TCS_SYN_SENT
* ack is always present */
if (seg_seq == tcp_conn->tc_ISS)
{
assert(tcp_conn->tc_transmit_timer.tim_active ||
(tcp_print_conn(tcp_conn), printf("\n"), 0));
seg_flags |= THF_SYN;
tcp_conn->tc_SND_TRM++;
}
tcp_hdr->th_seq_nr= htonl(seg_seq);
tcp_hdr->th_ack_nr= htonl(tcp_conn->tc_RCV_NXT);
tcp_hdr->th_flags= seg_flags;
tcp_hdr->th_window= htons(mss);
/* Initially we allow one segment */
ip_hdr->ih_length= htons(tot_hdr_size);
pack2write->acc_linkC++;
ip_hdr_len= (ip_hdr->ih_vers_ihl & IH_IHL_MASK) << 2;
tcp_pack= bf_delhead(pack2write, ip_hdr_len);
tcp_hdr->th_chksum= ~tcp_pack_oneCsum(ip_hdr, tcp_pack);
bf_afree(tcp_pack);
new_dis= curr_time + 2*HZ*tcp_conn->tc_ttl;
if (new_dis > tcp_conn->tc_senddis)
tcp_conn->tc_senddis= new_dis;
return pack2write;
case TCS_ESTABLISHED:
case TCS_CLOSING:
seg_seq= tcp_conn->tc_SND_TRM;
seg_flags= 0;
pack2write= 0;
seg_up= 0;
if (tcp_conn->tc_flags & TCF_SEND_ACK)
{
seg_flags= THF_ACK;
tcp_conn->tc_flags &= ~TCF_SEND_ACK;
pack2write= tcp_make_header (tcp_conn, &ip_hdr,
&tcp_hdr, (acc_t *)0);
if (!pack2write)
{
return NULL;
}
}
if (tcp_conn->tc_SND_UNA != tcp_conn->tc_SND_NXT)
{
assert(tcp_LEmod4G(seg_seq, tcp_conn->tc_SND_NXT));
if (seg_seq == tcp_conn->tc_snd_cwnd)
{
DBLOCK(2,
printf("no data: window is closed\n"));
goto after_data;
}
/* Assert that our SYN has been ACKed. */
assert(tcp_conn->tc_SND_UNA != tcp_conn->tc_ISS);
seg_lo_data= seg_seq;
queue_lo_data= tcp_conn->tc_SND_UNA;
seg_hi= tcp_conn->tc_SND_NXT;
seg_hi_data= seg_hi;
if (tcp_conn->tc_flags & TCF_FIN_SENT)
{
if (seg_seq != seg_hi)
seg_flags |= THF_FIN;
if (queue_lo_data == seg_hi_data)
queue_lo_data--;
if (seg_lo_data == seg_hi_data)
seg_lo_data--;
seg_hi_data--;
}
if (!pack2write)
{
pack2write= tcp_make_header (tcp_conn,
&ip_hdr, &tcp_hdr, (acc_t *)0);
if (!pack2write)
{
return NULL;
}
}
tot_hdr_size= bf_bufsize(pack2write);
no_push= (tcp_LEmod4G(tcp_conn->tc_SND_PSH, seg_seq));
head= (seg_seq == tcp_conn->tc_SND_UNA);
if (no_push)
{
/* Shutdown sets SND_PSH */
seg_flags &= ~THF_FIN;
if (seg_hi_data-seg_lo_data <= 1)
{
/* Allways keep at least one byte
* for a future push.
*/
DBLOCK(0x20,
printf("no data: no push\n"));
if (head)
{
DBLOCK(0x1, printf(
"no data: setting TCF_NO_PUSH\n"));
tcp_conn->tc_flags |=
TCF_NO_PUSH;
}
goto after_data;
}
seg_hi_data--;
}
if (tot_hdr_size != IP_TCP_MIN_HDR_SIZE)
{
printf(
"tcp_write`make_pack: tot_hdr_size = %d\n",
tot_hdr_size);
mss= tcp_conn->tc_mtu-tot_hdr_size;
}
if (seg_hi_data - seg_lo_data > mss)
{
/* Truncate to at most one segment */
seg_hi_data= seg_lo_data + mss;
seg_hi= seg_hi_data;
seg_flags &= ~THF_FIN;
}
if (no_push &&
seg_hi_data-seg_lo_data != mss)
{
DBLOCK(0x20, printf(
"no data: no push for partial segment\n"));
more2write= (tcp_conn->tc_fd &&
(tcp_conn->tc_fd->tf_flags &
TFF_WRITE_IP));
DIFBLOCK(2, more2write,
printf(
"tcp_send`make_pack: more2write -> !TCF_NO_PUSH\n");
);
if (head && !more2write)
{
DBLOCK(0x1, printf(
"partial segment: setting TCF_NO_PUSH\n"));
tcp_conn->tc_flags |= TCF_NO_PUSH;
}
goto after_data;
}
if (tcp_Gmod4G(seg_hi, tcp_conn->tc_snd_cwnd))
{
seg_hi_data= tcp_conn->tc_snd_cwnd;
seg_hi= seg_hi_data;
seg_flags &= ~THF_FIN;
}
if (!head &&
seg_hi_data-seg_lo_data < mss)
{
if (tcp_conn->tc_flags & TCF_PUSH_NOW)
{
DBLOCK(0x20,
printf("push: no Nagle\n"));
}
else
{
DBLOCK(0x20,
printf("no data: partial packet\n"));
seg_flags &= ~THF_FIN;
goto after_data;
}
}
if (seg_hi-seg_seq == 0)
{
DBLOCK(0x20,
printf("no data: no data available\n"));
goto after_data;
}
if (tcp_GEmod4G(tcp_conn->tc_SND_UP, seg_lo_data))
{
extern int killer_inet;
if (tcp_GEmod4G(tcp_conn->tc_SND_UP,
seg_hi_data))
{
seg_up= seg_hi_data-seg_seq;
}
else
{
seg_up= tcp_conn->tc_SND_UP-seg_seq;
}
seg_flags |= THF_URG;
if (!killer_inet &&
(tcp_conn->tc_flags & TCF_BSD_URG) &&
seg_up == 0)
{
/* A zero urgent pointer doesn't mean
* anything when BSD semantics are
* used (urgent pointer points to the
* first no urgent byte). The use of
* a zero urgent pointer also crashes
* a Solaris 2.3 kernel. If urgent
* pointer doesn't have BSD semantics
* then an urgent pointer of zero
* simply indicates that there is one
* urgent byte.
*/
seg_flags &= ~THF_URG;
}
}
else
seg_up= 0;
if (tcp_Gmod4G(tcp_conn->tc_SND_PSH, seg_lo_data) &&
tcp_LEmod4G(tcp_conn->tc_SND_PSH, seg_hi_data))
{
seg_flags |= THF_PSH;
}
tcp_conn->tc_SND_TRM= seg_hi;
assert(tcp_conn->tc_transmit_timer.tim_active ||
(tcp_print_conn(tcp_conn), printf("\n"), 0));
if (tcp_conn->tc_rt_seq == 0 &&
tcp_Gmod4G(seg_seq, tcp_conn->tc_rt_threshold))
{
tcp_conn->tc_rt_time= curr_time;
tcp_conn->tc_rt_seq=
tcp_conn->tc_rt_threshold= seg_seq;
}
if (seg_hi_data-seg_lo_data)
{
#if DEBUG & 0
assert(tcp_check_conn(tcp_conn));
assert((seg_hi_data-queue_lo_data <=
bf_bufsize(tcp_conn->tc_send_data) &&
seg_lo_data-queue_lo_data <=
bf_bufsize(tcp_conn->tc_send_data) &&
seg_hi_data>seg_lo_data)||
(tcp_print_conn(tcp_conn),
printf(
" seg_hi_data= 0x%x, seg_lo_data= 0x%x, queue_lo_data= 0x%x\n",
seg_hi_data, seg_lo_data,
queue_lo_data), 0));
#endif
tmp_pack= pack2write;
while (tmp_pack->acc_next)
tmp_pack= tmp_pack->acc_next;
tmp_pack->acc_next=
bf_cut(tcp_conn->tc_send_data,
(unsigned)(seg_lo_data-queue_lo_data),
(unsigned) (seg_hi_data-seg_lo_data));
}
seg_flags |= THF_ACK;
}
after_data:
if (!(seg_flags & THF_ACK))
{
if (pack2write)
bf_afree(pack2write);
return NULL;
}
assert( tcp_hdr != NULL );
assert( ip_hdr != NULL );
tcp_hdr->th_seq_nr= htonl(seg_seq);
tcp_hdr->th_ack_nr= htonl(tcp_conn->tc_RCV_NXT);
tcp_hdr->th_flags= seg_flags;
tcp_hdr->th_window= htons(tcp_conn->tc_RCV_HI -
tcp_conn->tc_RCV_NXT);
tcp_hdr->th_urgptr= htons(seg_up);
pack_size= bf_bufsize(pack2write);
ip_hdr->ih_length= htons(pack_size);
pack2write->acc_linkC++;
ip_hdr_len= (ip_hdr->ih_vers_ihl & IH_IHL_MASK) << 2;
tcp_pack= bf_delhead(pack2write, ip_hdr_len);
tcp_hdr->th_chksum= ~tcp_pack_oneCsum(ip_hdr, tcp_pack);
bf_afree(tcp_pack);
new_dis= curr_time + 2*HZ*tcp_conn->tc_ttl;
if (new_dis > tcp_conn->tc_senddis)
tcp_conn->tc_senddis= new_dis;
return pack2write;
default:
DBLOCK(1, tcp_print_conn(tcp_conn); printf("\n"));
ip_panic(( "Illegal state" ));
}
assert(0);
return NULL;
}
/*
tcp_release_retrans
*/
void tcp_release_retrans(
tcp_conn_t *tcp_conn,
u32_t seg_ack,
u16_t new_win
)
{
tcp_fd_t *tcp_fd;
size_t size, offset;
acc_t *pack;
clock_t retrans_time, curr_time, rtt, artt, drtt, srtt;
u32_t queue_lo, queue_hi;
u16_t mss, cthresh, new_cthresh;
unsigned window;
DBLOCK(0x10, printf("tcp_release_retrans, conn[%d]: ack %lu, win %u\n",
tcp_conn-tcp_conn_table, (unsigned long)seg_ack, new_win););
assert(tcp_conn->tc_busy);
assert (tcp_GEmod4G(seg_ack, tcp_conn->tc_SND_UNA));
assert (tcp_LEmod4G(seg_ack, tcp_conn->tc_SND_NXT));
tcp_conn->tc_snd_dack= 0;
mss= tcp_conn->tc_mtu-IP_TCP_MIN_HDR_SIZE;
curr_time= get_time();
if (tcp_conn->tc_rt_seq != 0 &&
tcp_Gmod4G(seg_ack, tcp_conn->tc_rt_seq))
{
assert(curr_time >= tcp_conn->tc_rt_time);
retrans_time= curr_time-tcp_conn->tc_rt_time;
rtt= tcp_conn->tc_rtt;
tcp_conn->tc_rt_seq= 0;
if (rtt == TCP_RTT_GRAN*CLOCK_GRAN &&
retrans_time <= TCP_RTT_GRAN*CLOCK_GRAN)
{
/* Common in fast networks. Nothing to do. */
}
else
{
srtt= retrans_time * TCP_RTT_SCALE;
artt= tcp_conn->tc_artt;
artt= ((TCP_RTT_SMOOTH-1)*artt+srtt)/TCP_RTT_SMOOTH;
if (srtt < artt)
srtt = artt - srtt;
else
srtt -= artt;
drtt= tcp_conn->tc_drtt;
drtt= ((TCP_RTT_SMOOTH-1)*drtt+srtt)/TCP_RTT_SMOOTH;
rtt= (artt+TCP_DRTT_MULT*drtt-1)/TCP_RTT_SCALE+1;
if (rtt < TCP_RTT_GRAN*CLOCK_GRAN)
{
rtt= TCP_RTT_GRAN*CLOCK_GRAN;
}
else if (rtt > TCP_RTT_MAX)
{
#if DEBUG
static int warned /* = 0 */;
if (!warned)
{
printf(
"tcp_release_retrans: warning retransmission time is limited to %d ms\n",
TCP_RTT_MAX*1000/HZ);
warned= 1;
}
#endif
rtt= TCP_RTT_MAX;
}
DBLOCK(0x10, printf(
"tcp_release_retrans, conn[%i]: retrans_time= %lu ms, rtt = %lu ms\n",
tcp_conn-tcp_conn_table,
retrans_time*1000/HZ,
rtt*1000/HZ));
DBLOCK(0x10, printf(
"tcp_release_retrans: artt= %lu -> %lu, drtt= %lu -> %lu\n",
tcp_conn->tc_artt, artt,
tcp_conn->tc_drtt, drtt));
tcp_conn->tc_artt= artt;
tcp_conn->tc_drtt= drtt;
tcp_conn->tc_rtt= rtt;
}
if (tcp_conn->tc_mtu != tcp_conn->tc_max_mtu &&
curr_time > tcp_conn->tc_mtutim+TCP_PMTU_INCR_IV)
{
tcp_mtu_incr(tcp_conn);
}
}
/* Update the current window. */
window= tcp_conn->tc_snd_cwnd-tcp_conn->tc_SND_UNA;
assert(seg_ack != tcp_conn->tc_SND_UNA);
/* For every real ACK we try to increase the current window
* with 1 mss.
*/
window += mss;
/* If the window becomes larger than the current threshold,
* increment the threshold by a small amount and set the
* window to the threshold.
*/
cthresh= tcp_conn->tc_snd_cthresh;
if (window > cthresh)
{
new_cthresh= cthresh + tcp_conn->tc_snd_cinc;
if (new_cthresh < cthresh)
new_cthresh= cthresh; /* overflow */
tcp_conn->tc_snd_cthresh= new_cthresh;
window= new_cthresh;
}
/* If the window is larger than the window advertised by the
* receiver, set the window size to the advertisement.
*/
if (window > new_win)
window= new_win;
tcp_conn->tc_snd_cwnd= seg_ack+window;
/* Release data queued for retransmissions. */
queue_lo= tcp_conn->tc_SND_UNA;
queue_hi= tcp_conn->tc_SND_NXT;
tcp_conn->tc_SND_UNA= seg_ack;
if (tcp_Lmod4G(tcp_conn->tc_SND_TRM, seg_ack))
{
tcp_conn->tc_SND_TRM= seg_ack;
}
assert(tcp_GEmod4G(tcp_conn->tc_snd_cwnd, seg_ack));
/* Advance ISS every 0.5GB to avoid problem with wrap around */
if (tcp_conn->tc_SND_UNA - tcp_conn->tc_ISS > 0x40000000)
{
tcp_conn->tc_ISS += 0x20000000;
DBLOCK(1, printf(
"tcp_release_retrans: updating ISS to 0x%lx\n",
(unsigned long)tcp_conn->tc_ISS););
if (tcp_Lmod4G(tcp_conn->tc_SND_UP, tcp_conn->tc_ISS))
{
tcp_conn->tc_SND_UP= tcp_conn->tc_ISS;
DBLOCK(1, printf(
"tcp_release_retrans: updating SND_UP to 0x%lx\n",
(unsigned long)tcp_conn->tc_SND_UP););
}
}
if (queue_lo == tcp_conn->tc_ISS)
queue_lo++;
if (tcp_conn->tc_flags & TCF_FIN_SENT)
{
if (seg_ack == queue_hi)
seg_ack--;
if (queue_lo == queue_hi)
queue_lo--;
queue_hi--;
}
offset= seg_ack - queue_lo;
size= queue_hi - seg_ack;
pack= tcp_conn->tc_send_data;
tcp_conn->tc_send_data= 0;
if (!size)
{
bf_afree(pack);
}
else
{
pack= bf_delhead(pack, offset);
tcp_conn->tc_send_data= pack;
}
if (tcp_Gmod4G(tcp_conn->tc_SND_TRM, tcp_conn->tc_snd_cwnd))
tcp_conn->tc_SND_TRM= tcp_conn->tc_snd_cwnd;
/* Copy in new data if an ioctl is pending or if a write request is
* pending and either the write can be completed or at least one
* mss buffer space is available.
*/
tcp_fd= tcp_conn->tc_fd;
if (tcp_fd)
{
if (tcp_fd->tf_flags & TFF_IOCTL_IP)
{
tcp_fd_write(tcp_conn);
}
if ((tcp_fd->tf_flags & TFF_WRITE_IP) &&
(size+tcp_fd->tf_write_count <= TCP_MAX_SND_WND_SIZE ||
size <= TCP_MAX_SND_WND_SIZE-mss))
{
tcp_fd_write(tcp_conn);
}
if (tcp_fd->tf_flags & TFF_SEL_WRITE)
tcp_rsel_write(tcp_conn);
}
else
{
if (tcp_conn->tc_SND_UNA == tcp_conn->tc_SND_NXT)
{
assert(tcp_conn->tc_state == TCS_CLOSING);
DBLOCK(0x10,
printf("all data sent in abondoned connection\n"));
tcp_close_connection(tcp_conn, ENOTCONN);
return;
}
}
if (!size && !tcp_conn->tc_send_data)
{
/* Reset window if a write is completed */
tcp_conn->tc_snd_cwnd= tcp_conn->tc_SND_UNA + mss;
}
DIFBLOCK(2, (tcp_conn->tc_snd_cwnd == tcp_conn->tc_SND_TRM),
printf("not sending: zero window\n"));
if (tcp_conn->tc_snd_cwnd != tcp_conn->tc_SND_TRM &&
tcp_conn->tc_SND_NXT != tcp_conn->tc_SND_TRM)
{
tcp_conn_write(tcp_conn, 1);
}
}
/*
tcp_fast_retrans
*/
void tcp_fast_retrans(tcp_conn)
tcp_conn_t *tcp_conn;
{
u16_t mss, mss2;
/* Update threshold sequence number for retransmission calculation. */
if (tcp_Gmod4G(tcp_conn->tc_SND_TRM, tcp_conn->tc_rt_threshold))
tcp_conn->tc_rt_threshold= tcp_conn->tc_SND_TRM;
tcp_conn->tc_SND_TRM= tcp_conn->tc_SND_UNA;
mss= tcp_conn->tc_mtu-IP_TCP_MIN_HDR_SIZE;
mss2= 2*mss;
if (tcp_conn->tc_snd_cwnd == tcp_conn->tc_SND_UNA)
tcp_conn->tc_snd_cwnd++;
if (tcp_Gmod4G(tcp_conn->tc_snd_cwnd, tcp_conn->tc_SND_UNA + mss2))
{
tcp_conn->tc_snd_cwnd= tcp_conn->tc_SND_UNA + mss2;
if (tcp_Gmod4G(tcp_conn->tc_SND_TRM, tcp_conn->tc_snd_cwnd))
tcp_conn->tc_SND_TRM= tcp_conn->tc_snd_cwnd;
tcp_conn->tc_snd_cthresh /= 2;
if (tcp_conn->tc_snd_cthresh < mss2)
tcp_conn->tc_snd_cthresh= mss2;
}
tcp_conn_write(tcp_conn, 1);
}
#if 0
void do_tcp_timeout(tcp_conn)
tcp_conn_t *tcp_conn;
{
tcp_send_timeout(tcp_conn-tcp_conn_table,
&tcp_conn->tc_transmit_timer);
}
#endif
/*
tcp_send_timeout
*/
static void tcp_send_timeout(conn, timer)
int conn;
struct timer *timer;
{
tcp_conn_t *tcp_conn;
u16_t mss, mss2;
u32_t snd_una, snd_nxt;
clock_t curr_time, rtt, stt, timeout;
acc_t *pkt;
int new_ttl, no_push;
DBLOCK(0x20, printf("tcp_send_timeout: conn[%d]\n", conn));
curr_time= get_time();
tcp_conn= &tcp_conn_table[conn];
assert(tcp_conn->tc_flags & TCF_INUSE);
assert(tcp_conn->tc_state != TCS_CLOSED);
assert(tcp_conn->tc_state != TCS_LISTEN);
snd_una= tcp_conn->tc_SND_UNA;
snd_nxt= tcp_conn->tc_SND_NXT;
no_push= (tcp_conn->tc_flags & TCF_NO_PUSH);
if (snd_nxt == snd_una || no_push)
{
/* Nothing more to send */
assert(tcp_conn->tc_SND_TRM == snd_una || no_push);
/* A new write sets the timer if tc_transmit_seq == SND_UNA */
tcp_conn->tc_transmit_seq= tcp_conn->tc_SND_UNA;
tcp_conn->tc_stt= 0;
tcp_conn->tc_0wnd_to= 0;
assert(!tcp_conn->tc_fd ||
!(tcp_conn->tc_fd->tf_flags & TFF_WRITE_IP) ||
(tcp_print_conn(tcp_conn), printf("\n"), 0));
if (snd_nxt != snd_una)
{
assert(no_push);
DBLOCK(1, printf("not setting keepalive timer\n"););
/* No point in setting the keepalive timer if we
* still have to send more data.
*/
return;
}
assert(tcp_conn->tc_send_data == NULL);
DBLOCK(0x20, printf("keep alive timer\n"));
if (tcp_conn->tc_ka_snd != tcp_conn->tc_SND_NXT ||
tcp_conn->tc_ka_rcv != tcp_conn->tc_RCV_NXT)
{
tcp_conn->tc_ka_snd= tcp_conn->tc_SND_NXT;
tcp_conn->tc_ka_rcv= tcp_conn->tc_RCV_NXT;
DBLOCK(0x20, printf(
"tcp_send_timeout: conn[%i] setting keepalive timer (+%lu ms)\n",
tcp_conn-tcp_conn_table,
tcp_conn->tc_ka_time*1000/HZ));
clck_timer(&tcp_conn->tc_transmit_timer,
curr_time+tcp_conn->tc_ka_time,
tcp_send_timeout,
tcp_conn-tcp_conn_table);
return;
}
DBLOCK(0x10, printf(
"tcp_send_timeout, conn[%d]: triggering keep alive probe\n",
tcp_conn-tcp_conn_table));
tcp_conn->tc_ka_snd--;
if (!(tcp_conn->tc_flags & TCF_FIN_SENT))
{
pkt= bf_memreq(1);
*ptr2acc_data(pkt)= '\xff'; /* a random char */
tcp_conn->tc_send_data= pkt; pkt= NULL;
}
tcp_conn->tc_SND_UNA--;
if (tcp_conn->tc_SND_UNA == tcp_conn->tc_ISS)
{
/* We didn't send anything so far. Retrying the
* SYN is too hard. Decrement ISS and hope
* that the other side doesn't care.
*/
tcp_conn->tc_ISS--;
}
/* Set tc_transmit_seq and tc_stt to trigger packet */
tcp_conn->tc_transmit_seq= tcp_conn->tc_SND_UNA;
tcp_conn->tc_stt= curr_time;
/* Set tc_rt_seq for round trip measurements */
tcp_conn->tc_rt_time= curr_time;
tcp_conn->tc_rt_seq= tcp_conn->tc_SND_UNA;
/* Set PSH to make sure that data gets sent */
tcp_conn->tc_SND_PSH= tcp_conn->tc_SND_NXT;
assert(tcp_check_conn(tcp_conn));
/* Fall through */
}
rtt= tcp_conn->tc_rtt;
if (tcp_conn->tc_transmit_seq != tcp_conn->tc_SND_UNA)
{
/* Some data has been acknowledged since the last time the
* timer was set, set the timer again. */
tcp_conn->tc_transmit_seq= tcp_conn->tc_SND_UNA;
tcp_conn->tc_stt= 0;
tcp_conn->tc_0wnd_to= 0;
DBLOCK(0x20, printf(
"tcp_send_timeout: conn[%i] setting timer to %lu ms (+%lu ms)\n",
tcp_conn-tcp_conn_table,
(curr_time+rtt)*1000/HZ, rtt*1000/HZ));
clck_timer(&tcp_conn->tc_transmit_timer,
curr_time+rtt, tcp_send_timeout,
tcp_conn-tcp_conn_table);
return;
}
stt= tcp_conn->tc_stt;
if (stt == 0)
{
/* Some packet arrived but did not acknowledge any data.
* Apparently, the other side is still alive and has a
* reason to transmit. We can asume a zero window.
*/
DBLOCK(0x10, printf("conn[%d] setting zero window timer\n",
tcp_conn-tcp_conn_table));
if (tcp_conn->tc_0wnd_to < TCP_0WND_MIN)
tcp_conn->tc_0wnd_to= TCP_0WND_MIN;
else if (tcp_conn->tc_0wnd_to < rtt)
tcp_conn->tc_0wnd_to= rtt;
else
{
tcp_conn->tc_0wnd_to *= 2;
if (tcp_conn->tc_0wnd_to > TCP_0WND_MAX)
tcp_conn->tc_0wnd_to= TCP_0WND_MAX;
}
tcp_conn->tc_stt= curr_time;
tcp_conn->tc_rt_seq= 0;
DBLOCK(0x10, printf(
"tcp_send_timeout: conn[%i] setting timer to %lu ms (+%lu ms)\n",
tcp_conn-tcp_conn_table,
(curr_time+tcp_conn->tc_0wnd_to)*1000/HZ,
tcp_conn->tc_0wnd_to*1000/HZ));
clck_timer(&tcp_conn->tc_transmit_timer,
curr_time+tcp_conn->tc_0wnd_to,
tcp_send_timeout, tcp_conn-tcp_conn_table);
return;
}
assert(stt <= curr_time);
DIFBLOCK(0x10, (tcp_conn->tc_fd == 0),
printf("conn[%d] timeout in abondoned connection\n",
tcp_conn-tcp_conn_table));
/* At this point, we have do a retransmission, or send a zero window
* probe, which is almost the same.
*/
DBLOCK(0x20, printf("tcp_send_timeout: conn[%i] una= %lu, rtt= %lu ms\n",
tcp_conn-tcp_conn_table,
(unsigned long)tcp_conn->tc_SND_UNA, rtt*1000/HZ));
/* Update threshold sequence number for retransmission calculation. */
if (tcp_Gmod4G(tcp_conn->tc_SND_TRM, tcp_conn->tc_rt_threshold))
tcp_conn->tc_rt_threshold= tcp_conn->tc_SND_TRM;
tcp_conn->tc_SND_TRM= tcp_conn->tc_SND_UNA;
if (tcp_conn->tc_flags & TCF_PMTU &&
curr_time > stt+TCP_PMTU_BLACKHOLE)
{
/* We can't tell the difference between a PMTU blackhole
* and a broken link. Assume a PMTU blackhole, and switch
* off PMTU discovery.
*/
DBLOCK(1, printf(
"tcp[%d]: PMTU blackhole (or broken link) on route to ",
tcp_conn-tcp_conn_table);
writeIpAddr(tcp_conn->tc_remaddr);
printf(", max mtu = %u\n", tcp_conn->tc_max_mtu););
tcp_conn->tc_flags &= ~TCF_PMTU;
tcp_conn->tc_mtutim= curr_time;
if (tcp_conn->tc_max_mtu > IP_DEF_MTU)
tcp_conn->tc_mtu= IP_DEF_MTU;
}
mss= tcp_conn->tc_mtu-IP_TCP_MIN_HDR_SIZE;
mss2= 2*mss;
if (tcp_conn->tc_snd_cwnd == tcp_conn->tc_SND_UNA)
tcp_conn->tc_snd_cwnd++;
if (tcp_Gmod4G(tcp_conn->tc_snd_cwnd, tcp_conn->tc_SND_UNA + mss2))
{
tcp_conn->tc_snd_cwnd= tcp_conn->tc_SND_UNA + mss2;
if (tcp_Gmod4G(tcp_conn->tc_SND_TRM, tcp_conn->tc_snd_cwnd))
tcp_conn->tc_SND_TRM= tcp_conn->tc_snd_cwnd;
tcp_conn->tc_snd_cthresh /= 2;
if (tcp_conn->tc_snd_cthresh < mss2)
tcp_conn->tc_snd_cthresh= mss2;
}
if (curr_time-stt > tcp_conn->tc_rt_dead)
{
tcp_close_connection(tcp_conn, ETIMEDOUT);
return;
}
timeout= (curr_time-stt) >> 3;
if (timeout < rtt)
timeout= rtt;
timeout += curr_time;
DBLOCK(0x20, printf(
"tcp_send_timeout: conn[%i] setting timer to %lu ms (+%lu ms)\n",
tcp_conn-tcp_conn_table, timeout*1000/HZ,
(timeout-curr_time)*1000/HZ));
clck_timer(&tcp_conn->tc_transmit_timer, timeout,
tcp_send_timeout, tcp_conn-tcp_conn_table);
#if 0
if (tcp_conn->tc_rt_seq == 0)
{
printf("tcp_send_timeout: conn[%d]: setting tc_rt_time\n",
tcp_conn-tcp_conn_table);
tcp_conn->tc_rt_time= curr_time-rtt;
tcp_conn->tc_rt_seq= tcp_conn->tc_SND_UNA;
}
#endif
if (tcp_conn->tc_state == TCS_SYN_SENT ||
(curr_time-stt >= tcp_conn->tc_ttl*HZ))
{
new_ttl= tcp_conn->tc_ttl+1;
if (new_ttl> IP_MAX_TTL)
new_ttl= IP_MAX_TTL;
tcp_conn->tc_ttl= new_ttl;
}
tcp_conn_write(tcp_conn, 0);
}
void tcp_fd_write(tcp_conn)
tcp_conn_t *tcp_conn;
{
tcp_fd_t *tcp_fd;
int urg, nourg, push;
u32_t max_seq;
size_t max_trans, write_count;
acc_t *data, *send_data;
assert(tcp_conn->tc_busy);
tcp_fd= tcp_conn->tc_fd;
if ((tcp_fd->tf_flags & TFF_IOCTL_IP) &&
!(tcp_fd->tf_flags & TFF_WRITE_IP))
{
if (tcp_fd->tf_ioreq != NWIOTCPSHUTDOWN)
return;
DBLOCK(0x10, printf("NWIOTCPSHUTDOWN\n"));
if (tcp_conn->tc_state == TCS_CLOSED)
{
tcp_reply_ioctl (tcp_fd, tcp_conn->tc_error);
return;
}
if (!(tcp_conn->tc_flags & TCF_FIN_SENT))
{
DBLOCK(0x10, printf("calling tcp_shutdown\n"));
tcp_shutdown (tcp_conn);
}
else
{
if (tcp_conn->tc_SND_UNA == tcp_conn->tc_SND_NXT)
{
tcp_reply_ioctl (tcp_fd, NW_OK);
DBLOCK(0x10, printf("shutdown completed\n"));
}
else
{
DBLOCK(0x10,
printf("shutdown still inprogress\n"));
}
}
return;
}
assert (tcp_fd->tf_flags & TFF_WRITE_IP);
if (tcp_conn->tc_state == TCS_CLOSED)
{
if (tcp_fd->tf_write_offset)
{
tcp_reply_write(tcp_fd,
tcp_fd->tf_write_offset);
}
else
tcp_reply_write(tcp_fd, tcp_conn->tc_error);
return;
}
urg= (tcp_fd->tf_flags & TFF_WR_URG);
push= (tcp_fd->tf_flags & TFF_PUSH_DATA);
max_seq= tcp_conn->tc_SND_UNA + TCP_MAX_SND_WND_SIZE;
max_trans= max_seq - tcp_conn->tc_SND_NXT;
if (tcp_fd->tf_write_count <= max_trans)
write_count= tcp_fd->tf_write_count;
else
write_count= max_trans;
if (write_count)
{
if (tcp_conn->tc_flags & TCF_BSD_URG)
{
if (tcp_Gmod4G(tcp_conn->tc_SND_NXT,
tcp_conn->tc_SND_UNA))
{
nourg= tcp_LEmod4G(tcp_conn->tc_SND_UP,
tcp_conn->tc_SND_UNA);
if ((urg && nourg) || (!urg && !nourg))
{
DBLOCK(0x20,
printf("not sending\n"));
return;
}
}
}
data= (*tcp_fd->tf_get_userdata)
(tcp_fd->tf_srfd, tcp_fd->tf_write_offset,
write_count, FALSE);
if (!data)
{
if (tcp_fd->tf_write_offset)
{
tcp_reply_write(tcp_fd,
tcp_fd->tf_write_offset);
}
else
tcp_reply_write(tcp_fd, EFAULT);
return;
}
tcp_fd->tf_write_offset += write_count;
tcp_fd->tf_write_count -= write_count;
send_data= tcp_conn->tc_send_data;
tcp_conn->tc_send_data= 0;
send_data= bf_append(send_data, data);
tcp_conn->tc_send_data= send_data;
tcp_conn->tc_SND_NXT += write_count;
if (urg)
{
if (tcp_conn->tc_flags & TCF_BSD_URG)
tcp_conn->tc_SND_UP= tcp_conn->tc_SND_NXT;
else
tcp_conn->tc_SND_UP= tcp_conn->tc_SND_NXT-1;
}
if (push && !tcp_fd->tf_write_count)
tcp_conn->tc_SND_PSH= tcp_conn->tc_SND_NXT;
}
if (!tcp_fd->tf_write_count)
{
tcp_reply_write(tcp_fd, tcp_fd->tf_write_offset);
}
}
unsigned tcp_sel_write(tcp_conn)
tcp_conn_t *tcp_conn;
{
tcp_fd_t *tcp_fd;
int urg, nourg;
u32_t max_seq;
size_t max_trans;
tcp_fd= tcp_conn->tc_fd;
if (tcp_conn->tc_state == TCS_CLOSED)
return 1;
urg= (tcp_fd->tf_flags & TFF_WR_URG);
max_seq= tcp_conn->tc_SND_UNA + TCP_MAX_SND_WND_SIZE;
max_trans= max_seq - tcp_conn->tc_SND_NXT;
if (max_trans)
{
if (tcp_conn->tc_flags & TCF_BSD_URG)
{
if (tcp_Gmod4G(tcp_conn->tc_SND_NXT,
tcp_conn->tc_SND_UNA))
{
nourg= tcp_LEmod4G(tcp_conn->tc_SND_UP,
tcp_conn->tc_SND_UNA);
if ((urg && nourg) || (!urg && !nourg))
{
DBLOCK(0x20,
printf("not sending\n"));
return 0;
}
}
}
return 1;
}
return 0;
}
void
tcp_rsel_write(tcp_conn)
tcp_conn_t *tcp_conn;
{
tcp_fd_t *tcp_fd;
if (tcp_sel_write(tcp_conn) == 0)
return;
tcp_fd= tcp_conn->tc_fd;
tcp_fd->tf_flags &= ~TFF_SEL_WRITE;
if (tcp_fd->tf_select_res)
tcp_fd->tf_select_res(tcp_fd->tf_srfd, SR_SELECT_WRITE);
else
printf("tcp_rsel_write: no select_res\n");
}
/*
tcp_shutdown
*/
void tcp_shutdown(tcp_conn)
tcp_conn_t *tcp_conn;
{
switch (tcp_conn->tc_state)
{
case TCS_CLOSED:
case TCS_LISTEN:
case TCS_SYN_SENT:
case TCS_SYN_RECEIVED:
tcp_close_connection(tcp_conn, ENOTCONN);
return;
}
if (tcp_conn->tc_flags & TCF_FIN_SENT)
return;
tcp_conn->tc_flags |= TCF_FIN_SENT;
tcp_conn->tc_flags &= ~TCF_NO_PUSH;
tcp_conn->tc_SND_NXT++;
tcp_conn->tc_SND_PSH= tcp_conn->tc_SND_NXT;
assert (tcp_check_conn(tcp_conn) ||
(tcp_print_conn(tcp_conn), printf("\n"), 0));
tcp_conn_write(tcp_conn, 1);
/* Start the timer */
tcp_set_send_timer(tcp_conn);
}
void tcp_set_send_timer(tcp_conn)
tcp_conn_t *tcp_conn;
{
clock_t curr_time;
clock_t rtt;
assert(tcp_conn->tc_state != TCS_CLOSED);
assert(tcp_conn->tc_state != TCS_LISTEN);
curr_time= get_time();
rtt= tcp_conn->tc_rtt;
DBLOCK(0x20, printf(
"tcp_set_send_timer: conn[%i] setting timer to %lu ms (+%lu ms)\n",
tcp_conn-tcp_conn_table,
(curr_time+rtt)*1000/HZ, rtt*1000/HZ));
/* Start the timer */
clck_timer(&tcp_conn->tc_transmit_timer,
curr_time+rtt, tcp_send_timeout, tcp_conn-tcp_conn_table);
tcp_conn->tc_stt= curr_time;
}
/*
tcp_close_connection
*/
void tcp_close_connection(tcp_conn, error)
tcp_conn_t *tcp_conn;
int error;
{
int i;
tcp_port_t *tcp_port;
tcp_fd_t *tcp_fd;
tcp_conn_t *tc;
assert (tcp_check_conn(tcp_conn) ||
(tcp_print_conn(tcp_conn), printf("\n"), 0));
assert (tcp_conn->tc_flags & TCF_INUSE);
tcp_conn->tc_error= error;
tcp_port= tcp_conn->tc_port;
tcp_fd= tcp_conn->tc_fd;
if (tcp_conn->tc_state == TCS_CLOSED)
return;
tcp_conn->tc_state= TCS_CLOSED;
DBLOCK(0x10, tcp_print_state(tcp_conn); printf("\n"));
if (tcp_fd && (tcp_fd->tf_flags & TFF_LISTENQ))
{
for (i= 0; i<TFL_LISTEN_MAX; i++)
{
if (tcp_fd->tf_listenq[i] == tcp_conn)
break;
}
assert(i < TFL_LISTEN_MAX);
tcp_fd->tf_listenq[i]= NULL;
tcp_conn->tc_connInprogress= 0;
tcp_conn->tc_fd= NULL;
tcp_fd= NULL;
}
else if (tcp_fd)
{
tcp_conn->tc_busy++;
assert(tcp_fd->tf_conn == tcp_conn);
if (tcp_fd->tf_flags & TFF_READ_IP)
tcp_fd_read (tcp_conn, 1);
assert (!(tcp_fd->tf_flags & TFF_READ_IP));
if (tcp_fd->tf_flags & TFF_SEL_READ)
tcp_rsel_read (tcp_conn);
if (tcp_fd->tf_flags & TFF_WRITE_IP)
{
tcp_fd_write(tcp_conn);
tcp_conn_write(tcp_conn, 1);
}
assert (!(tcp_fd->tf_flags & TFF_WRITE_IP));
if (tcp_fd->tf_flags & TFF_IOCTL_IP)
{
tcp_fd_write(tcp_conn);
tcp_conn_write(tcp_conn, 1);
}
if (tcp_fd->tf_flags & TFF_IOCTL_IP)
assert(tcp_fd->tf_ioreq != NWIOTCPSHUTDOWN);
if (tcp_fd->tf_flags & TFF_SEL_WRITE)
tcp_rsel_write(tcp_conn);
if (tcp_conn->tc_connInprogress)
tcp_restart_connect(tcp_conn);
assert(!tcp_conn->tc_connInprogress);
assert (!(tcp_fd->tf_flags & TFF_IOCTL_IP) ||
(printf("req= 0x%lx\n",
(unsigned long)tcp_fd->tf_ioreq), 0));
tcp_conn->tc_busy--;
}
if (tcp_conn->tc_rcvd_data)
{
bf_afree(tcp_conn->tc_rcvd_data);
tcp_conn->tc_rcvd_data= NULL;
}
tcp_conn->tc_flags &= ~TCF_FIN_RECV;
tcp_conn->tc_RCV_LO= tcp_conn->tc_RCV_NXT;
if (tcp_conn->tc_adv_data)
{
bf_afree(tcp_conn->tc_adv_data);
tcp_conn->tc_adv_data= NULL;
}
if (tcp_conn->tc_send_data)
{
bf_afree(tcp_conn->tc_send_data);
tcp_conn->tc_send_data= NULL;
tcp_conn->tc_SND_TRM=
tcp_conn->tc_SND_NXT= tcp_conn->tc_SND_UNA;
}
tcp_conn->tc_SND_TRM= tcp_conn->tc_SND_NXT= tcp_conn->tc_SND_UNA;
if (tcp_conn->tc_remipopt)
{
bf_afree(tcp_conn->tc_remipopt);
tcp_conn->tc_remipopt= NULL;
}
if (tcp_conn->tc_tcpopt)
{
bf_afree(tcp_conn->tc_tcpopt);
tcp_conn->tc_tcpopt= NULL;
}
if (tcp_conn->tc_frag2send)
{
bf_afree(tcp_conn->tc_frag2send);
tcp_conn->tc_frag2send= NULL;
}
if (tcp_conn->tc_flags & TCF_MORE2WRITE)
{
for (tc= tcp_port->tp_snd_head; tc; tc= tc->tc_send_link)
{
if (tc->tc_send_link == tcp_conn)
break;
}
if (tc == NULL)
{
assert(tcp_port->tp_snd_head == tcp_conn);
tcp_port->tp_snd_head= tcp_conn->tc_send_link;
}
else
{
tc->tc_send_link= tcp_conn->tc_send_link;
if (tc->tc_send_link == NULL)
tcp_port->tp_snd_tail= tc;
}
tcp_conn->tc_flags &= ~TCF_MORE2WRITE;
}
clck_untimer (&tcp_conn->tc_transmit_timer);
tcp_conn->tc_transmit_seq= 0;
/* clear all flags but TCF_INUSE */
tcp_conn->tc_flags &= TCF_INUSE;
assert (tcp_check_conn(tcp_conn));
}
/*
* $PchId: tcp_send.c,v 1.32 2005/06/28 14:21:52 philip Exp $
*/
Reference in a new issue View git blame Copy permalink