tcp_socket_t *tcp_accept_until (tcp_socket_t *s
, scheduless_condition waitfor, void* waitarg)
{
tcp_socket_t *ns;
buf_t *p;
ip_hdr_t *iph;
tcp_hdr_t *h;
unsigned long optdata;
int ok = tcp_lock_avail(s, (1<<LISTEN)
, waitfor, waitarg);
if (ok != 0){
if (s->state != LISTEN){
tcp_debug ("tcp_accept: called in invalid state\n");
return (tcp_socket_t *)SEINVAL;
}
if (ok == -1)
return 0;
return (tcp_socket_t *)ok;
}
/* Create a new PCB, and respond with a SYN|ACK.
* If a new PCB could not be created (probably due to lack of memory),
* we don't do anything, but rely on the sender will retransmit
* the SYN at a time when we have more memory available. */
mutex_lock (&s->ip->lock);
ns = tcp_alloc (s->ip);
if (ns == 0) {
mutex_unlock (&s->lock);
++(s->ip->tcp_in_discards);
mutex_unlock (&s->ip->lock);
tcp_debug ("tcp_accept: could not allocate PCB\n");
return (tcp_socket_t *)SENOMEM;
}
p = tcp_queue_get (s);
h = (tcp_hdr_t*) p->payload;
iph = ((ip_hdr_t*) p->payload) - 1;
/* Set up the new PCB. */
ns->local_ip = iph->dest.var;
ns->local_port = s->local_port;
ns->remote_ip = iph->src;
ns->remote_port = h->src;
ns->state = SYN_RCVD;
ns->rcv_nxt = s->ip->tcp_input_seqno + 1;
ns->snd_wnd = h->wnd;
ns->ssthresh = ns->snd_wnd;
ns->snd_wl1 = s->ip->tcp_input_seqno;
ns->ip = s->ip;
mutex_unlock (&s->lock);
/* Register the new PCB so that we can begin receiving
* segments for it. */
tcp_list_add (&s->ip->tcp_sockets, ns);
/* Parse any options in the SYN. */
tcp_parseopt (ns, h);
/* Build an MSS option. */
optdata = HTONL (((unsigned long)2 << 24) | ((unsigned long)4 << 16) |
(((unsigned long)ns->mss / 256) << 8) | (ns->mss & 255));
buf_free (p);
/* Send a SYN|ACK together with the MSS option.
* there is impossible fail of tcp_enqueue_option4
* */
tcp_enqueue_option4 (ns, TCP_SYN | TCP_ACK, optdata);
#if TCP_LOCK_STYLE <= TCP_LOCK_SURE
tcp_output (ns);
mutex_unlock (&ns->ip->lock);
#elif TCP_LOCK_STYLE >= TCP_LOCK_RELAXED
mutex_unlock (&ns->ip->lock);
tcp_output (ns);
#endif
mutex_unlock (&ns->lock);
return ns;
}
/**
* Called by tcp_input() when a segment arrives for a listening
* connection (from tcp_input()).
*
* @param pcb the tcp_pcb_listen for which a segment arrived
* @return ERR_OK if the segment was processed
* another err_t on error
*
* @note the return value is not (yet?) used in tcp_input()
* @note the segment which arrived is saved in global variables, therefore only the pcb
* involved is passed as a parameter to this function
*/
static err_t
tcp_listen_input(struct tcp_pcb_listen *pcb)
{
struct tcp_pcb *npcb;
u32_t optdata;
/* In the LISTEN state, we check for incoming SYN segments,
creates a new PCB, and responds with a SYN|ACK. */
if (flags & TCP_ACK) {
/* For incoming segments with the ACK flag set, respond with a
RST. */
LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_listen_input: ACK in LISTEN, sending reset\n"));
tcp_rst(ackno + 1, seqno + tcplen,
&(iphdr->dest), &(iphdr->src),
tcphdr->dest, tcphdr->src);
} else if (flags & TCP_SYN) {
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection request %"U16_F" -> %"U16_F".\n", tcphdr->src, tcphdr->dest));
#if TCP_LISTEN_BACKLOG
if (pcb->accepts_pending >= pcb->backlog) {
return ERR_ABRT;
}
#endif /* TCP_LISTEN_BACKLOG */
npcb = tcp_alloc(pcb->prio);
/* If a new PCB could not be created (probably due to lack of memory),
we don't do anything, but rely on the sender will retransmit the
SYN at a time when we have more memory available. */
if (npcb == NULL) {
LWIP_DEBUGF(TCP_DEBUG, ("tcp_listen_input: could not allocate PCB\n"));
TCP_STATS_INC(tcp.memerr);
return ERR_MEM;
}
#if TCP_LISTEN_BACKLOG
pcb->accepts_pending++;
#endif /* TCP_LISTEN_BACKLOG */
/* Set up the new PCB. */
ip_addr_set(&(npcb->local_ip), &(iphdr->dest));
npcb->local_port = pcb->local_port;
ip_addr_set(&(npcb->remote_ip), &(iphdr->src));
npcb->remote_port = tcphdr->src;
npcb->state = SYN_RCVD;
npcb->rcv_nxt = seqno + 1;
npcb->snd_wnd = tcphdr->wnd;
npcb->ssthresh = npcb->snd_wnd;
npcb->snd_wl1 = seqno - 1;/* initialise to seqno-1 to force window update */
npcb->callback_arg = pcb->callback_arg;
#if LWIP_CALLBACK_API
npcb->accept = pcb->accept;
#endif /* LWIP_CALLBACK_API */
/* inherit socket options */
npcb->so_options = pcb->so_options & (SOF_DEBUG|SOF_DONTROUTE|SOF_KEEPALIVE|SOF_OOBINLINE|SOF_LINGER);
/* Register the new PCB so that we can begin receiving segments
for it. */
TCP_REG(&tcp_active_pcbs, npcb);
/* Parse any options in the SYN. */
tcp_parseopt(npcb);
#if TCP_CALCULATE_EFF_SEND_MSS
npcb->mss = tcp_eff_send_mss(npcb->mss, &(npcb->remote_ip));
#endif /* TCP_CALCULATE_EFF_SEND_MSS */
snmp_inc_tcppassiveopens();
/* Build an MSS option. */
optdata = TCP_BUILD_MSS_OPTION();
/* Send a SYN|ACK together with the MSS option. */
tcp_enqueue(npcb, NULL, 0, TCP_SYN | TCP_ACK, 0, (u8_t *)&optdata, 4);
return tcp_output(npcb);
}
return ERR_OK;
}
/**
* Implements the TCP state machine. Called by tcp_input. In some
* states tcp_receive() is called to receive data. The tcp_seg
* argument will be freed by the caller (tcp_input()) unless the
* recv_data pointer in the pcb is set.
*
* @param pcb the tcp_pcb for which a segment arrived
*
* @note the segment which arrived is saved in global variables, therefore only the pcb
* involved is passed as a parameter to this function
*/
static err_t
tcp_process(struct tcp_pcb *pcb)
{
struct tcp_seg *rseg;
u8_t acceptable = 0;
err_t err;
u8_t accepted_inseq;
err = ERR_OK;
/* Process incoming RST segments. */
if (flags & TCP_RST) {
/* First, determine if the reset is acceptable. */
if (pcb->state == SYN_SENT) {
if (ackno == pcb->snd_nxt) {
acceptable = 1;
}
} else {
if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt,
pcb->rcv_nxt+pcb->rcv_ann_wnd)) {
acceptable = 1;
}
}
if (acceptable) {
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: Connection RESET\n"));
LWIP_ASSERT("tcp_input: pcb->state != CLOSED", pcb->state != CLOSED);
recv_flags = TF_RESET;
pcb->flags &= ~TF_ACK_DELAY;
return ERR_RST;
} else {
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n",
seqno, pcb->rcv_nxt));
LWIP_DEBUGF(TCP_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n",
seqno, pcb->rcv_nxt));
return ERR_OK;
}
}
/* Update the PCB (in)activity timer. */
pcb->tmr = tcp_ticks;
pcb->keep_cnt_sent = 0;
/* Do different things depending on the TCP state. */
switch (pcb->state) {
case SYN_SENT:
LWIP_DEBUGF(TCP_INPUT_DEBUG, ("SYN-SENT: ackno %"U32_F" pcb->snd_nxt %"U32_F" unacked %"U32_F"\n", ackno,
pcb->snd_nxt, ntohl(pcb->unacked->tcphdr->seqno)));
/* received SYN ACK with expected sequence number? */
if ((flags & TCP_ACK) && (flags & TCP_SYN)
&& ackno == ntohl(pcb->unacked->tcphdr->seqno) + 1) {
pcb->snd_buf++;
pcb->rcv_nxt = seqno + 1;
pcb->lastack = ackno;
pcb->snd_wnd = tcphdr->wnd;
pcb->snd_wl1 = seqno - 1; /* initialise to seqno - 1 to force window update */
pcb->state = ESTABLISHED;
/* Parse any options in the SYNACK before using pcb->mss since that
* can be changed by the received options! */
tcp_parseopt(pcb);
#if TCP_CALCULATE_EFF_SEND_MSS
pcb->mss = tcp_eff_send_mss(pcb->mss, &(pcb->remote_ip));
#endif /* TCP_CALCULATE_EFF_SEND_MSS */
/* Set ssthresh again after changing pcb->mss (already set in tcp_connect
* but for the default value of pcb->mss) */
pcb->ssthresh = pcb->mss * 10;
pcb->cwnd = ((pcb->cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
LWIP_ASSERT("pcb->snd_queuelen > 0", (pcb->snd_queuelen > 0));
--pcb->snd_queuelen;
LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_process: SYN-SENT --queuelen %"U16_F"\n", (u16_t)pcb->snd_queuelen));
rseg = pcb->unacked;
pcb->unacked = rseg->next;
/* If there's nothing left to acknowledge, stop the retransmit
timer, otherwise reset it to start again */
if(pcb->unacked == NULL)
pcb->rtime = -1;
else {
pcb->rtime = 0;
pcb->nrtx = 0;
}
tcp_seg_free(rseg);
/* Call the user specified function to call when sucessfully
* connected. */
TCP_EVENT_CONNECTED(pcb, ERR_OK, err);
tcp_ack_now(pcb);
}
/* received ACK? possibly a half-open connection */
else if (flags & TCP_ACK) {
/* send a RST to bring the other side in a non-synchronized state. */
tcp_rst(ackno, seqno + tcplen, &(iphdr->dest), &(iphdr->src),
tcphdr->dest, tcphdr->src);
}
break;
case SYN_RCVD:
if (flags & TCP_ACK &&
!(flags & TCP_RST)) {
/* expected ACK number? */
if (TCP_SEQ_BETWEEN(ackno, pcb->lastack+1, pcb->snd_nxt)) {
u16_t old_cwnd;
pcb->state = ESTABLISHED;
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection established %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
#if LWIP_CALLBACK_API
LWIP_ASSERT("pcb->accept != NULL", pcb->accept != NULL);
#endif
/* Call the accept function. */
TCP_EVENT_ACCEPT(pcb, ERR_OK, err);
if (err != ERR_OK) {
/* If the accept function returns with an error, we abort
* the connection. */
tcp_abort(pcb);
return ERR_ABRT;
}
old_cwnd = pcb->cwnd;
/* If there was any data contained within this ACK,
* we'd better pass it on to the application as well. */
accepted_inseq = tcp_receive(pcb);
pcb->cwnd = ((old_cwnd == 1) ? (pcb->mss * 2) : pcb->mss);
if ((flags & TCP_FIN) && accepted_inseq) {
tcp_ack_now(pcb);
pcb->state = CLOSE_WAIT;
}
}
/* incorrect ACK number */
else {
/* send RST */
tcp_rst(ackno, seqno + tcplen, &(iphdr->dest), &(iphdr->src),
tcphdr->dest, tcphdr->src);
}
}
break;
case CLOSE_WAIT:
/* FALLTHROUGH */
case ESTABLISHED:
accepted_inseq = tcp_receive(pcb);
if ((flags & TCP_FIN) && accepted_inseq) { /* passive close */
tcp_ack_now(pcb);
pcb->state = CLOSE_WAIT;
}
break;
case FIN_WAIT_1:
tcp_receive(pcb);
if (flags & TCP_FIN) {
if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
LWIP_DEBUGF(TCP_DEBUG,
("TCP connection closed %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
tcp_ack_now(pcb);
tcp_pcb_purge(pcb);
TCP_RMV(&tcp_active_pcbs, pcb);
pcb->state = TIME_WAIT;
TCP_REG(&tcp_tw_pcbs, pcb);
} else {
tcp_ack_now(pcb);
pcb->state = CLOSING;
}
} else if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
pcb->state = FIN_WAIT_2;
}
break;
case FIN_WAIT_2:
tcp_receive(pcb);
if (flags & TCP_FIN) {
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
tcp_ack_now(pcb);
tcp_pcb_purge(pcb);
TCP_RMV(&tcp_active_pcbs, pcb);
pcb->state = TIME_WAIT;
TCP_REG(&tcp_tw_pcbs, pcb);
}
break;
case CLOSING:
tcp_receive(pcb);
if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
tcp_ack_now(pcb);
tcp_pcb_purge(pcb);
TCP_RMV(&tcp_active_pcbs, pcb);
pcb->state = TIME_WAIT;
TCP_REG(&tcp_tw_pcbs, pcb);
}
break;
case LAST_ACK:
tcp_receive(pcb);
if (flags & TCP_ACK && ackno == pcb->snd_nxt) {
LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest));
/* bugfix #21699: don't set pcb->state to CLOSED here or we risk leaking segments */
recv_flags = TF_CLOSED;
}
break;
default:
break;
}
return ERR_OK;
}
tcp_socket_t *
tcp_accept (tcp_socket_t *s)
{
tcp_socket_t *ns;
buf_t *p;
ip_hdr_t *iph;
tcp_hdr_t *h;
unsigned long optdata;
again:
mutex_lock (&s->lock);
for (;;) {
if (s->state != LISTEN) {
mutex_unlock (&s->lock);
tcp_debug ("tcp_accept: called in invalid state\n");
return 0;
}
if (! tcp_queue_is_empty (s)) {
p = tcp_queue_get (s);
break;
}
mutex_wait (&s->lock);
}
mutex_unlock (&s->lock);
/* Create a new PCB, and respond with a SYN|ACK.
* If a new PCB could not be created (probably due to lack of memory),
* we don't do anything, but rely on the sender will retransmit
* the SYN at a time when we have more memory available. */
mutex_lock (&s->ip->lock);
ns = tcp_alloc (s->ip);
if (ns == 0) {
tcp_debug ("tcp_accept: could not allocate PCB\n");
++s->ip->tcp_in_discards;
mutex_unlock (&s->ip->lock);
buf_free (p);
goto again;
}
h = (tcp_hdr_t*) p->payload;
iph = ((ip_hdr_t*) p->payload) - 1;
/* Set up the new PCB. */
memcpy (ns->local_ip, iph->dest, 4);
ns->local_port = s->local_port;
memcpy (ns->remote_ip, iph->src, 4);
ns->remote_port = h->src;
ns->state = SYN_RCVD;
ns->rcv_nxt = s->ip->tcp_input_seqno + 1;
ns->snd_wnd = h->wnd;
ns->ssthresh = ns->snd_wnd;
ns->snd_wl1 = s->ip->tcp_input_seqno;
ns->ip = s->ip;
/* Register the new PCB so that we can begin receiving
* segments for it. */
tcp_list_add (&s->ip->tcp_sockets, ns);
/* Parse any options in the SYN. */
tcp_parseopt (ns, h);
/* Build an MSS option. */
optdata = HTONL (((unsigned long)2 << 24) | ((unsigned long)4 << 16) |
(((unsigned long)ns->mss / 256) << 8) | (ns->mss & 255));
buf_free (p);
/* Send a SYN|ACK together with the MSS option. */
tcp_enqueue (ns, 0, 0, TCP_SYN | TCP_ACK, (unsigned char*) &optdata, 4);
tcp_output (ns);
mutex_unlock (&s->ip->lock);
return ns;
}
