void TCPClientPort::OnConnect(const boost::system::error_code &ec) { if (ec == boost::asio::error::operation_aborted) /* this object has already been deleted; bail out quickly without touching anything */ return; if (ec) { socket.close(); state = PortState::FAILED; StateChanged(); Error(ec.message().c_str()); return; } SendTimeoutS send_timeout(1); socket.set_option(send_timeout); state = PortState::READY; StateChanged(); socket.async_receive(boost::asio::buffer(input, sizeof(input)), std::bind(&TCPClientPort::OnRead, this, std::placeholders::_1, std::placeholders::_2)); }
// Function responsible of accepting a connection on the socket. inline Socket* TCPSocket::accept() { Socket* return_value = NULL; lock_ref().enter(); if ( socket_ref() != NULL && listen() ) { sockaddr_storage target; SOCKET new_socket; int target_size = sizeof(target); memset(&target,'\0',target_size); new_socket = WSAAccept(socket_ref(),reinterpret_cast<sockaddr*>(&target),&target_size,NULL,NULL); if ( new_socket != INVALID_SOCKET ) { TCPSocket* accepted_socket = new (std::nothrow) TCPSocket( ( protocol() == SOCKET_TCP_V4 ? false : true ) , new_socket,target); if ( accepted_socket != NULL ) { accepted_socket->queue_size(queue_size()); accepted_socket->blocking(blocking()); accepted_socket->send_timeout(send_timeout()); accepted_socket->receive_timeout(receive_timeout()); accepted_socket->keep_alive(keep_alive()); accepted_socket->keep_alive_timeout(keep_alive_timeout()); accepted_socket->keep_alive_interval(keep_alive_interval()); accepted_socket->overlapped(overlapped()); accepted_socket->send_overlapped_function(send_overlapped_function()); accepted_socket->receive_overlapped_function(receive_overlapped_function()); _accepted_sockets.push_back(accepted_socket); return_value = accepted_socket; } else closesocket(new_socket); } } lock_ref().leave(); return return_value; };
static uint16_t sendto_interrupt(struct uip_driver_s *dev, void *conn, void *pvpriv, uint16_t flags) { FAR struct sendto_s *pstate = (FAR struct sendto_s *)pvpriv; nllvdbg("flags: %04x\n", flags); if (pstate) { /* Check if the outgoing packet is available. It may have been claimed * by a sendto interrupt serving a different thread -OR- if the output * buffer currently contains unprocessed incoming data. In these cases * we will just have to wait for the next polling cycle. */ if (dev->d_sndlen > 0 || (flags & UIP_NEWDATA) != 0) { /* Another thread has beat us sending data or the buffer is busy, * Check for a timeout. If not timed out, wait for the next * polling cycle and check again. */ #ifdef CONFIG_NET_SENDTO_TIMEOUT if (send_timeout(pstate)) { /* Yes.. report the timeout */ nlldbg("SEND timeout\n"); pstate->st_sndlen = -ETIMEDOUT; } else #endif /* CONFIG_NET_SENDTO_TIMEOUT */ { /* No timeout. Just wait for the next polling cycle */ return flags; } } /* It looks like we are good to send the data */ else { /* Copy the user data into d_snddata and send it */ uip_send(dev, pstate->st_buffer, pstate->st_buflen); pstate->st_sndlen = pstate->st_buflen; } /* Don't allow any further call backs. */ pstate->st_cb->flags = 0; pstate->st_cb->priv = NULL; pstate->st_cb->event = NULL; /* Wake up the waiting thread */ sem_post(&pstate->st_sem); } return flags; }
static uint16_t tcpsend_interrupt(FAR struct net_driver_s *dev, FAR void *pvconn, FAR void *pvpriv, uint16_t flags) { FAR struct tcp_conn_s *conn = (FAR struct tcp_conn_s *)pvconn; FAR struct send_s *pstate = (FAR struct send_s *)pvpriv; #ifdef CONFIG_NETDEV_MULTINIC /* The TCP socket is connected and, hence, should be bound to a device. * Make sure that the polling device is the one that we are bound to. */ DEBUGASSERT(conn->dev != NULL); if (dev != conn->dev) { return flags; } #endif nllvdbg("flags: %04x acked: %d sent: %d\n", flags, pstate->snd_acked, pstate->snd_sent); /* If this packet contains an acknowledgement, then update the count of * acknowledged bytes. */ if ((flags & TCP_ACKDATA) != 0) { FAR struct tcp_hdr_s *tcp; /* Update the timeout */ #ifdef CONFIG_NET_SOCKOPTS pstate->snd_time = clock_systimer(); #endif /* Get the offset address of the TCP header */ #ifdef CONFIG_NET_IPv4 #ifdef CONFIG_NET_IPv6 if (conn->domain == PF_INET) #endif { DEBUGASSERT(IFF_IS_IPv4(dev->d_flags)); tcp = TCPIPv4BUF; } #endif /* CONFIG_NET_IPv4 */ #ifdef CONFIG_NET_IPv6 #ifdef CONFIG_NET_IPv4 else #endif { DEBUGASSERT(IFF_IS_IPv6(dev->d_flags)); tcp = TCPIPv6BUF; } #endif /* CONFIG_NET_IPv6 */ /* The current acknowledgement number number is the (relative) offset * of the of the next byte needed by the receiver. The snd_isn is the * offset of the first byte to send to the receiver. The difference * is the number of bytes to be acknowledged. */ pstate->snd_acked = tcp_getsequence(tcp->ackno) - pstate->snd_isn; nllvdbg("ACK: acked=%d sent=%d buflen=%d\n", pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen); /* Have all of the bytes in the buffer been sent and acknowledged? */ if (pstate->snd_acked >= pstate->snd_buflen) { /* Yes. Then pstate->snd_buflen should hold the number of bytes * actually sent. */ goto end_wait; } /* No.. fall through to send more data if necessary */ } /* Check if we are being asked to retransmit data */ else if ((flags & TCP_REXMIT) != 0) { /* Yes.. in this case, reset the number of bytes that have been sent * to the number of bytes that have been ACKed. */ pstate->snd_sent = pstate->snd_acked; #if defined(CONFIG_NET_TCP_SPLIT) /* Reset the even/odd indicator to even since we need to * retransmit. */ pstate->snd_odd = false; #endif /* Fall through to re-send data from the last that was ACKed */ } /* Check for a loss of connection */ else if ((flags & TCP_DISCONN_EVENTS) != 0) { /* Report not connected */ nllvdbg("Lost connection\n"); net_lostconnection(pstate->snd_sock, flags); pstate->snd_sent = -ENOTCONN; goto end_wait; } /* Check if the outgoing packet is available (it may have been claimed * by a sendto interrupt serving a different thread). */ #if 0 /* We can't really support multiple senders on the same TCP socket */ else if (dev->d_sndlen > 0) { /* Another thread has beat us sending data, wait for the next poll */ return flags; } #endif /* We get here if (1) not all of the data has been ACKed, (2) we have been * asked to retransmit data, (3) the connection is still healthy, and (4) * the outgoing packet is available for our use. In this case, we are * now free to send more data to receiver -- UNLESS the buffer contains * unprocessed incoming data. In that event, we will have to wait for the * next polling cycle. */ if ((flags & TCP_NEWDATA) == 0 && pstate->snd_sent < pstate->snd_buflen) { uint32_t seqno; /* Get the amount of data that we can send in the next packet */ uint32_t sndlen = pstate->snd_buflen - pstate->snd_sent; #if defined(CONFIG_NET_TCP_SPLIT) /* RFC 1122 states that a host may delay ACKing for up to 500ms but * must respond to every second segment). This logic here will trick * the RFC 1122 recipient into responding sooner. This logic will be * activated if: * * 1. An even number of packets has been send (where zero is an even * number), * 2. There is more data be sent (more than or equal to * CONFIG_NET_TCP_SPLIT_SIZE), but * 3. Not enough data for two packets. * * Then we will split the remaining, single packet into two partial * packets. This will stimulate the RFC 1122 peer to ACK sooner. * * Don't try to split very small packets (less than CONFIG_NET_TCP_SPLIT_SIZE). * Only the first even packet and the last odd packets could have * sndlen less than CONFIG_NET_TCP_SPLIT_SIZE. The value of sndlen on * the last even packet is guaranteed to be at least MSS/2 by the * logic below. */ if (sndlen >= CONFIG_NET_TCP_SPLIT_SIZE) { /* sndlen is the number of bytes remaining to be sent. * conn->mss will provide the number of bytes that can sent * in one packet. The difference, then, is the number of bytes * that would be sent in the next packet after this one. */ int32_t next_sndlen = sndlen - conn->mss; /* Is this the even packet in the packet pair transaction? */ if (!pstate->snd_odd) { /* next_sndlen <= 0 means that the entire remaining data * could fit into this single packet. This is condition * in which we must do the split. */ if (next_sndlen <= 0) { /* Split so that there will be an odd packet. Here * we know that 0 < sndlen <= MSS */ sndlen = (sndlen / 2) + 1; } } /* No... this is the odd packet in the packet pair transaction */ else { /* Will there be another (even) packet afer this one? * (next_sndlen > 0) Will the split condition occur on that * next, even packet? ((next_sndlen - conn->mss) < 0) If * so, then perform the split now to avoid the case where the * byte count is less than CONFIG_NET_TCP_SPLIT_SIZE on the * next pair. */ if (next_sndlen > 0 && (next_sndlen - conn->mss) < 0) { /* Here, we know that sndlen must be MSS < sndlen <= 2*MSS * and so (sndlen / 2) is <= MSS. */ sndlen /= 2; } } } /* Toggle the even/odd indicator */ pstate->snd_odd ^= true; #endif /* CONFIG_NET_TCP_SPLIT */ if (sndlen > conn->mss) { sndlen = conn->mss; } /* Check if we have "space" in the window */ if ((pstate->snd_sent - pstate->snd_acked + sndlen) < conn->winsize) { /* Set the sequence number for this packet. NOTE: The network updates * sndseq on receipt of ACK *before* this function is called. In that * case sndseq will point to the next unacknowledged byte (which might * have already been sent). We will overwrite the value of sndseq * here before the packet is sent. */ seqno = pstate->snd_sent + pstate->snd_isn; nllvdbg("SEND: sndseq %08x->%08x\n", conn->sndseq, seqno); tcp_setsequence(conn->sndseq, seqno); #ifdef NEED_IPDOMAIN_SUPPORT /* If both IPv4 and IPv6 support are enabled, then we will need to * select which one to use when generating the outgoing packet. * If only one domain is selected, then the setup is already in * place and we need do nothing. */ tcpsend_ipselect(dev, pstate); #endif /* Then set-up to send that amount of data. (this won't actually * happen until the polling cycle completes). */ devif_send(dev, &pstate->snd_buffer[pstate->snd_sent], sndlen); /* Check if the destination IP address is in the ARP or Neighbor * table. If not, then the send won't actually make it out... it * will be replaced with an ARP request or Neighbor Solicitation. */ if (pstate->snd_sent != 0 || psock_send_addrchck(conn)) { /* Update the amount of data sent (but not necessarily ACKed) */ pstate->snd_sent += sndlen; nllvdbg("SEND: acked=%d sent=%d buflen=%d\n", pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen); } } } #ifdef CONFIG_NET_SOCKOPTS /* All data has been sent and we are just waiting for ACK or re-transmit * indications to complete the send. Check for a timeout. */ if (send_timeout(pstate)) { /* Yes.. report the timeout */ nlldbg("SEND timeout\n"); pstate->snd_sent = -ETIMEDOUT; goto end_wait; } #endif /* CONFIG_NET_SOCKOPTS */ /* Continue waiting */ return flags; end_wait: /* Do not allow any further callbacks */ pstate->snd_cb->flags = 0; pstate->snd_cb->priv = NULL; pstate->snd_cb->event = NULL; /* There are no outstanding, unacknowledged bytes */ conn->unacked = 0; /* Wake up the waiting thread */ sem_post(&pstate->snd_sem); return flags; }
static uint16_t send_interrupt(struct uip_driver_s *dev, void *pvconn, void *pvpriv, uint16_t flags) { struct uip_conn *conn = (struct uip_conn*)pvconn; struct send_s *pstate = (struct send_s *)pvpriv; nllvdbg("flags: %04x acked: %d sent: %d\n", flags, pstate->snd_acked, pstate->snd_sent); /* If this packet contains an acknowledgement, then update the count of * acknowldged bytes. */ if ((flags & UIP_ACKDATA) != 0) { /* The current acknowledgement number number is the (relative) offset * of the of the next byte needed by the receiver. The snd_isn is the * offset of the first byte to send to the receiver. The difference * is the number of bytes to be acknowledged. */ pstate->snd_acked = uip_tcpgetsequence(TCPBUF->ackno) - pstate->snd_isn; nllvdbg("ACK: acked=%d sent=%d buflen=%d\n", pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen); /* Have all of the bytes in the buffer been sent and acknowledged? */ if (pstate->snd_acked >= pstate->snd_buflen) { /* Yes. Then pstate->snd_buflen should hold the number of bytes * actually sent. */ goto end_wait; } /* No.. fall through to send more data if necessary */ } /* Check if we are being asked to retransmit data */ else if ((flags & UIP_REXMIT) != 0) { /* Yes.. in this case, reset the number of bytes that have been sent * to the number of bytes that have been ACKed. */ pstate->snd_sent = pstate->snd_acked; /* Fall through to re-send data from the last that was ACKed */ } /* Check for a loss of connection */ else if ((flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0) { /* Report not connected */ nllvdbg("Lost connection\n"); pstate->snd_sent = -ENOTCONN; goto end_wait; } /* Check if the outgoing packet is available (it may have been claimed * by a sendto interrupt serving a different thread). */ #if 0 /* We can't really support multiple senders on the same TCP socket */ else if (dev->d_sndlen > 0) { /* Another thread has beat us sending data, wait for the next poll */ return flags; } #endif /* We get here if (1) not all of the data has been ACKed, (2) we have been * asked to retransmit data, (3) the connection is still healthy, and (4) * the outgoing packet is available for our use. In this case, we are * now free to send more data to receiver -- UNLESS the buffer contains * unprocessing incoming data. In that event, we will have to wait for the * next polling cycle. */ if ((flags & UIP_NEWDATA) == 0 && pstate->snd_sent < pstate->snd_buflen) { uint32_t seqno; /* Get the amount of data that we can send in the next packet */ uint32_t sndlen = pstate->snd_buflen - pstate->snd_sent; if (sndlen > uip_mss(conn)) { sndlen = uip_mss(conn); } /* Set the sequence number for this packet. NOTE: uIP updates * sndseq on recept of ACK *before* this function is called. In that * case sndseq will point to the next unacknowledge byte (which might * have already been sent). We will overwrite the value of sndseq * here before the packet is sent. */ seqno = pstate->snd_sent + pstate->snd_isn; nllvdbg("SEND: sndseq %08x->%08x\n", conn->sndseq, seqno); uip_tcpsetsequence(conn->sndseq, seqno); /* Then set-up to send that amount of data. (this won't actually * happen until the polling cycle completes). */ uip_send(dev, &pstate->snd_buffer[pstate->snd_sent], sndlen); /* Check if the destination IP address is in the ARP table. If not, * then the send won't actually make it out... it will be replaced with * an ARP request. * * NOTE 1: This could an expensive check if there are a lot of entries * in the ARP table. Hence, we only check on the first packet -- when * snd_sent is zero. * * NOTE 2: If we are actually harvesting IP addresses on incomming IP * packets, then this check should not be necessary; the MAC mapping * should already be in the ARP table. */ #if defined(CONFIG_NET_ETHERNET) && defined (CONFIG_NET_ARP_IPIN) if (pstate->snd_sent != 0 || uip_arp_find(conn->ripaddr) != NULL) #endif { /* Update the amount of data sent (but not necessarily ACKed) */ pstate->snd_sent += sndlen; nllvdbg("SEND: acked=%d sent=%d buflen=%d\n", pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen); /* Update the send time */ #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) pstate->snd_time = clock_systimer(); #endif } } /* All data has been send and we are just waiting for ACK or re-transmit * indications to complete the send. Check for a timeout. */ #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) else if (send_timeout(pstate)) { /* Yes.. report the timeout */ nlldbg("SEND timeout\n"); pstate->snd_sent = -ETIMEDOUT; goto end_wait; } #endif /* CONFIG_NET_SOCKOPTS && !CONFIG_DISABLE_CLOCK */ /* Continue waiting */ return flags; end_wait: /* Do not allow any further callbacks */ pstate->snd_cb->flags = 0; pstate->snd_cb->priv = NULL; pstate->snd_cb->event = NULL; /* There are no outstanding, unacknowledged bytes */ conn->unacked = 0; /* Wake up the waiting thread */ sem_post(&pstate->snd_sem); return flags; }
void Chatpad::send_command() { //log_tmp("send_command: " << m_init_state); // default init code for m_bcdDevice == 0x0110 uint8_t code[2] = { 0x01, 0x02 }; if (m_bcdDevice == 0x0114) { code[0] = 0x09; code[1] = 0x00; } switch(m_init_state) { case kStateInit1: send_ctrl(0x40, 0xa9, 0xa30c, 0x4423, NULL, 0, &Chatpad::on_control_wrap, this); break; case kStateInit2: send_ctrl(0x40, 0xa9, 0x2344, 0x7f03, NULL, 0, &Chatpad::on_control_wrap, this); break; case kStateInit3: send_ctrl(0x40, 0xa9, 0x5839, 0x6832, NULL, 0, &Chatpad::on_control_wrap, this); break; case kStateInit4: send_ctrl(0xc0, 0xa1, 0x0000, 0xe416, code, 2, &Chatpad::on_control_wrap, this); break; case kStateInit5: send_ctrl(0x40, 0xa1, 0x0000, 0xe416, code, 2, &Chatpad::on_control_wrap, this); break; case kStateInit6: send_ctrl(0xc0, 0xa1, 0x0000, 0xe416, code, 2, &Chatpad::on_control_wrap, this); break; case kStateInit_1e: send_timeout(1000); break; case kStateInit_1f: send_timeout(1000); break; case kStateInit_1b: send_ctrl(0x41, 0x0, 0x1b, 0x02, NULL, 0, &Chatpad::on_control_wrap, this); break; case kStateKeepAlive_1e: send_timeout(1000); break; case kStateKeepAlive_1f: send_timeout(1000); break; default: assert(!"unknown state"); break; } }
static uint16_t sendto_interrupt(FAR struct net_driver_s *dev, FAR void *conn, FAR void *pvpriv, uint16_t flags) { FAR struct sendto_s *pstate = (FAR struct sendto_s *)pvpriv; nllvdbg("flags: %04x\n", flags); if (pstate) { /* If the network device has gone down, then we will have terminate * the wait now with an error. */ if ((flags & NETDEV_DOWN) != 0) { /* Terminate the transfer with an error. */ nlldbg("ERROR: Network is down\n"); pstate->st_sndlen = -ENETUNREACH; } /* Check if the outgoing packet is available. It may have been claimed * by a sendto interrupt serving a different thread -OR- if the output * buffer currently contains unprocessed incoming data. In these cases * we will just have to wait for the next polling cycle. */ else if (dev->d_sndlen > 0 || (flags & UDP_NEWDATA) != 0) { /* Another thread has beat us sending data or the buffer is busy, * Check for a timeout. If not timed out, wait for the next * polling cycle and check again. */ #ifdef CONFIG_NET_SENDTO_TIMEOUT if (send_timeout(pstate)) { /* Yes.. report the timeout */ nlldbg("ERROR: SEND timeout\n"); pstate->st_sndlen = -ETIMEDOUT; } else #endif /* CONFIG_NET_SENDTO_TIMEOUT */ { /* No timeout. Just wait for the next polling cycle */ return flags; } } /* It looks like we are good to send the data */ else { #ifdef NEED_IPDOMAIN_SUPPORT /* If both IPv4 and IPv6 support are enabled, then we will need to * select which one to use when generating the outgoing packet. * If only one domain is selected, then the setup is already in * place and we need do nothing. */ sendto_ipselect(dev, pstate); #endif /* Copy the user data into d_appdata and send it */ devif_send(dev, pstate->st_buffer, pstate->st_buflen); pstate->st_sndlen = pstate->st_buflen; } /* Don't allow any further call backs. */ pstate->st_cb->flags = 0; pstate->st_cb->priv = NULL; pstate->st_cb->event = NULL; /* Wake up the waiting thread */ sem_post(&pstate->st_sem); } return flags; }
static uint16_t send_interrupt(FAR struct uip_driver_s *dev, FAR void *pvconn, FAR void *pvpriv, uint16_t flags) { FAR struct uip_conn *conn = (FAR struct uip_conn*)pvconn; FAR struct send_s *pstate = (FAR struct send_s *)pvpriv; nllvdbg("flags: %04x acked: %d sent: %d\n", flags, pstate->snd_acked, pstate->snd_sent); /* If this packet contains an acknowledgement, then update the count of * acknowledged bytes. */ if ((flags & UIP_ACKDATA) != 0) { /* Update the timeout */ #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) pstate->snd_time = clock_systimer(); #endif /* The current acknowledgement number number is the (relative) offset * of the of the next byte needed by the receiver. The snd_isn is the * offset of the first byte to send to the receiver. The difference * is the number of bytes to be acknowledged. */ pstate->snd_acked = uip_tcpgetsequence(TCPBUF->ackno) - pstate->snd_isn; nllvdbg("ACK: acked=%d sent=%d buflen=%d\n", pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen); /* Have all of the bytes in the buffer been sent and acknowledged? */ if (pstate->snd_acked >= pstate->snd_buflen) { /* Yes. Then pstate->snd_buflen should hold the number of bytes * actually sent. */ goto end_wait; } /* No.. fall through to send more data if necessary */ } /* Check if we are being asked to retransmit data */ else if ((flags & UIP_REXMIT) != 0) { /* Yes.. in this case, reset the number of bytes that have been sent * to the number of bytes that have been ACKed. */ pstate->snd_sent = pstate->snd_acked; #if defined(CONFIG_NET_TCP_SPLIT) /* Reset the even/odd indicator to even since we need to * retransmit. */ pstate->snd_odd = false; #endif /* Fall through to re-send data from the last that was ACKed */ } /* Check for a loss of connection */ else if ((flags & (UIP_CLOSE|UIP_ABORT|UIP_TIMEDOUT)) != 0) { /* Report not connected */ nllvdbg("Lost connection\n"); net_lostconnection(pstate->snd_sock, flags); pstate->snd_sent = -ENOTCONN; goto end_wait; } /* Check if the outgoing packet is available (it may have been claimed * by a sendto interrupt serving a different thread). */ #if 0 /* We can't really support multiple senders on the same TCP socket */ else if (dev->d_sndlen > 0) { /* Another thread has beat us sending data, wait for the next poll */ return flags; } #endif /* We get here if (1) not all of the data has been ACKed, (2) we have been * asked to retransmit data, (3) the connection is still healthy, and (4) * the outgoing packet is available for our use. In this case, we are * now free to send more data to receiver -- UNLESS the buffer contains * unprocessed incoming data. In that event, we will have to wait for the * next polling cycle. */ if ((flags & UIP_NEWDATA) == 0 && pstate->snd_sent < pstate->snd_buflen) { uint32_t seqno; /* Get the amount of data that we can send in the next packet */ uint32_t sndlen = pstate->snd_buflen - pstate->snd_sent; #if defined(CONFIG_NET_TCP_SPLIT) /* RFC 1122 states that a host may delay ACKing for up to 500ms but * must respond to every second segment). This logic here will trick * the RFC 1122 recipient into responding sooner. This logic will be * activated if: * * 1. An even number of packets has been send (where zero is an even * number), * 2. There is more data be sent (more than or equal to * CONFIG_NET_TCP_SPLIT_SIZE), but * 3. Not enough data for two packets. * * Then we will split the remaining, single packet into two partial * packets. This will stimulate the RFC 1122 peer to ACK sooner. * * Don't try to split very small packets (less than CONFIG_NET_TCP_SPLIT_SIZE). * Only the first even packet and the last odd packets could have * sndlen less than CONFIG_NET_TCP_SPLIT_SIZE. The value of sndlen on * the last even packet is guaranteed to be at least MSS/2 by the * logic below. */ if (sndlen >= CONFIG_NET_TCP_SPLIT_SIZE) { /* sndlen is the number of bytes remaining to be sent. * uip_mss(conn) will return the number of bytes that can sent * in one packet. The difference, then, is the number of bytes * that would be sent in the next packet after this one. */ int32_t next_sndlen = sndlen - uip_mss(conn); /* Is this the even packet in the packet pair transaction? */ if (!pstate->snd_odd) { /* next_sndlen <= 0 means that the entire remaining data * could fit into this single packet. This is condition * in which we must do the split. */ if (next_sndlen <= 0) { /* Split so that there will be an odd packet. Here * we know that 0 < sndlen <= MSS */ sndlen = (sndlen / 2) + 1; } } /* No... this is the odd packet in the packet pair transaction */ else { /* Will there be another (even) packet afer this one? * (next_sndlen > 0) Will the split condition occur on that * next, even packet? ((next_sndlen - uip_mss(conn)) < 0) If * so, then perform the split now to avoid the case where the * byte count is less than CONFIG_NET_TCP_SPLIT_SIZE on the * next pair. */ if (next_sndlen > 0 && (next_sndlen - uip_mss(conn)) < 0) { /* Here, we know that sndlen must be MSS < sndlen <= 2*MSS * and so (sndlen / 2) is <= MSS. */ sndlen /= 2; } } } /* Toggle the even/odd indicator */ pstate->snd_odd ^= true; #endif /* CONFIG_NET_TCP_SPLIT */ if (sndlen > uip_mss(conn)) { sndlen = uip_mss(conn); } /* Check if we have "space" in the window */ if ((pstate->snd_sent - pstate->snd_acked + sndlen) < conn->winsize) { /* Set the sequence number for this packet. NOTE: uIP updates * sndseq on recept of ACK *before* this function is called. In that * case sndseq will point to the next unacknowledged byte (which might * have already been sent). We will overwrite the value of sndseq * here before the packet is sent. */ seqno = pstate->snd_sent + pstate->snd_isn; nllvdbg("SEND: sndseq %08x->%08x\n", conn->sndseq, seqno); uip_tcpsetsequence(conn->sndseq, seqno); /* Then set-up to send that amount of data. (this won't actually * happen until the polling cycle completes). */ uip_send(dev, &pstate->snd_buffer[pstate->snd_sent], sndlen); /* Check if the destination IP address is in the ARP table. If not, * then the send won't actually make it out... it will be replaced with * an ARP request. * * NOTE 1: This could be an expensive check if there are a lot of entries * in the ARP table. Hence, we only check on the first packet -- when * snd_sent is zero. * * NOTE 2: If we are actually harvesting IP addresses on incoming IP * packets, then this check should not be necessary; the MAC mapping * should already be in the ARP table. */ #if defined(CONFIG_NET_ETHERNET) && !defined(CONFIG_NET_ARP_IPIN) if (pstate->snd_sent != 0 || uip_arp_find(conn->ripaddr) != NULL) #endif { /* Update the amount of data sent (but not necessarily ACKed) */ pstate->snd_sent += sndlen; nllvdbg("SEND: acked=%d sent=%d buflen=%d\n", pstate->snd_acked, pstate->snd_sent, pstate->snd_buflen); } } } /* All data has been sent and we are just waiting for ACK or re-transmit * indications to complete the send. Check for a timeout. */ #if defined(CONFIG_NET_SOCKOPTS) && !defined(CONFIG_DISABLE_CLOCK) if (send_timeout(pstate)) { /* Yes.. report the timeout */ nlldbg("SEND timeout\n"); pstate->snd_sent = -ETIMEDOUT; goto end_wait; } #endif /* CONFIG_NET_SOCKOPTS && !CONFIG_DISABLE_CLOCK */ /* Continue waiting */ return flags; end_wait: /* Do not allow any further callbacks */ pstate->snd_cb->flags = 0; pstate->snd_cb->priv = NULL; pstate->snd_cb->event = NULL; /* There are no outstanding, unacknowledged bytes */ conn->unacked = 0; /* Wake up the waiting thread */ sem_post(&pstate->snd_sem); return flags; }