static void ci_udp_set_raddr(ci_udp_state* us, unsigned raddr_be32,
int rport_be16)
{
ci_ip_cache_invalidate(&us->s.pkt);
udp_raddr_be32(us) = raddr_be32;
udp_rport_be16(us) = (ci_uint16) rport_be16;
us->s.pkt.dport_be16 = (ci_uint16) rport_be16;
}
/* check that we can handle this destination */
static int ci_tcp_connect_check_dest(citp_socket* ep, ci_ip_addr_t dst_be32,
int dport_be16)
{
ci_ip_cached_hdrs* ipcache = &ep->s->pkt;
ipcache->ip.ip_daddr_be32 = dst_be32;
ipcache->dport_be16 = dport_be16;
cicp_user_retrieve(ep->netif, ipcache, &ep->s->cp);
if(CI_LIKELY( ipcache->status == retrrc_success ||
ipcache->status == retrrc_nomac ||
ipcache->status < 0 )) {
/* Onloadable. */
if( ipcache->encap.type & CICP_LLAP_TYPE_XMIT_HASH_LAYER4 )
/* We don't yet have a local port number, so the result of that
* lookup may be wrong.
*/
ci_ip_cache_invalidate(ipcache);
if( ipcache->ip.ip_saddr_be32 == 0 ) {
/* Control plane has selected a source address for us -- remember it. */
ipcache->ip.ip_saddr_be32 = ipcache->ip_saddr_be32;
ep->s->cp.ip_laddr_be32 = ipcache->ip_saddr_be32;
}
return 0;
}
else if( ipcache->status == retrrc_localroute ) {
ci_tcp_state* ts = SOCK_TO_TCP(ep->s);
if( NI_OPTS(ep->netif).tcp_client_loopback == CITP_TCP_LOOPBACK_OFF)
return CI_SOCKET_HANDOVER;
ep->s->s_flags |= CI_SOCK_FLAG_BOUND_ALIEN;
if( NI_OPTS(ep->netif).tcp_server_loopback != CITP_TCP_LOOPBACK_OFF )
ts->local_peer = ci_tcp_connect_find_local_peer(ep->netif, dst_be32,
dport_be16);
else
ts->local_peer = OO_SP_NULL;
if( OO_SP_NOT_NULL(ts->local_peer) ||
NI_OPTS(ep->netif).tcp_client_loopback !=
CITP_TCP_LOOPBACK_SAMESTACK ) {
ipcache->flags |= CI_IP_CACHE_IS_LOCALROUTE;
if( ipcache->ip.ip_saddr_be32 == 0 ) {
ipcache->ip.ip_saddr_be32 = dst_be32;
ep->s->cp.ip_laddr_be32 = dst_be32;
}
ipcache->ether_offset = 4; /* lo is non-VLAN */
ipcache->ip_saddr_be32 = dst_be32;
ipcache->dport_be16 = dport_be16;
return 0;
}
return CI_SOCKET_HANDOVER;
}
return CI_SOCKET_HANDOVER;
}
void ci_ip_send_tcp_slow(ci_netif* ni, ci_tcp_state* ts, ci_ip_pkt_fmt* pkt)
{
/* We're here because the ipcache is not valid. */
int rc, prev_mtu = ts->s.pkt.mtu;
cicp_user_retrieve(ni, &ts->s.pkt, &ts->s.cp);
if( ts->s.pkt.status == retrrc_success ) {
if( ts->s.pkt.mtu != prev_mtu )
CI_PMTU_TIMER_NOW(ni, &ts->pmtus);
ci_ip_set_mac_and_port(ni, &ts->s.pkt, pkt);
ci_netif_send(ni, pkt);
return;
}
else if( ts->s.pkt.status == retrrc_localroute &&
(ts->s.pkt.flags & CI_IP_CACHE_IS_LOCALROUTE) )
ci_ip_local_send(ni, pkt, &ts->s, OO_SP_NULL);
/* For TCP, we want the ipcache to only be valid when onloadable. */
ci_ip_cache_invalidate(&ts->s.pkt);
switch( ts->s.pkt.status ) {
case retrrc_nomac:
rc = 0;
/* If we resend SYN, and there is no MAC - it means ARP failed.
* Connect() should return with EHOSTUNREACH.
* We verify twice - on the first and the second retransmit.
* Very hackish.
*/
if( ts->s.b.state == CI_TCP_SYN_SENT ) {
if( ts->retransmits == 1 )
ts->tcpflags |= CI_TCPT_FLAG_NO_ARP;
else if( (ts->tcpflags & CI_TCPT_FLAG_NO_ARP) &&
ts->retransmits == 2 ) {
ci_tcp_drop(ni, ts, EHOSTUNREACH);
return;
}
}
cicp_user_defer_send(ni, retrrc_nomac, &rc, OO_PKT_P(pkt),
ts->s.pkt.ifindex);
++ts->stats.tx_nomac_defer;
return;
case retrrc_noroute:
rc = -EHOSTUNREACH;
break;
case retrrc_alienroute:
case retrrc_localroute:
/* ?? TODO: inc some stat */
return;
default:
ci_assert_lt(ts->s.pkt.status, 0);
if( ts->s.pkt.status < 0 )
rc = ts->s.pkt.status;
else
/* belt and braces... */
rc = 0;
}
ci_assert_le(rc, 0);
/* In most cases, we should ignore return code; the packet will be resend
* later, because of RTO. However, in SYN-SENT we should pass errors to
* user. At the same time, we should not pass ENOBUFS to user - it is
* pretty internal problem of cplane, so we should try again. Possibly,
* there may be other internal problems, such as ENOMEM.
*
* Also, do not break connection when the first SYN fails:
* - Linux does not do it;
* - cplane has some latency, so we have false positives here;
* - ci_tcp_connect() does not expect it.
*/
if( ts->s.b.state == CI_TCP_SYN_SENT && rc < 0 && ts->retransmits > 0 &&
(rc == -EHOSTUNREACH || rc == -ENETUNREACH || rc == -ENETDOWN) )
ci_tcp_drop(ni, ts, -rc);
}