int ci_udp_shutdown(citp_socket* ep, ci_fd_t fd, int how)
{
ci_fd_t os_sock;
int rc;
CHECK_UEP(ep);
LOG_UV(log(LPF "shutdown("SF_FMT", %d)", SF_PRI_ARGS(ep,fd), how));
os_sock = ci_get_os_sock_fd(fd);
if( CI_IS_VALID_SOCKET( os_sock ) ) {
rc = ci_sys_shutdown(os_sock, how);
ci_rel_os_sock_fd( os_sock );
if( rc < 0 )
return CI_SOCKET_ERROR;
}
rc = __ci_udp_shutdown(ep->netif, SOCK_TO_UDP(ep->s), how);
if( rc < 0 ) {
CI_SET_ERROR(rc, -rc);
return rc;
}
return 0;
}
ci_fd_t ci_udp_ep_ctor(citp_socket* ep, ci_netif* netif, int domain, int type)
{
ci_udp_state* us;
ci_fd_t fd;
VERB( log(LPFIN "ctor( )" ) );
ci_assert(ep);
ci_assert(netif);
ci_netif_lock(netif);
us = ci_udp_get_state_buf(netif);
if (!us) {
ci_netif_unlock(netif);
LOG_E(ci_log("%s: [%d] out of socket buffers", __FUNCTION__,NI_ID(netif)));
return -ENOMEM;
}
/* It's required to set protocol before ci_tcp_helper_sock_attach()
* since it's used to determine if TCP or UDP file operations should be
* attached to the file descriptor in kernel. */
sock_protocol(&us->s) = IPPROTO_UDP;
/* NB: this attach will close the os_sock_fd */
fd = ci_tcp_helper_sock_attach(ci_netif_get_driver_handle(netif),
SC_SP(&us->s), domain, type);
if( fd < 0 ) {
if( fd == -EAFNOSUPPORT )
LOG_U(ci_log("%s: ci_tcp_helper_sock_attach (domain=%d, type=%d) "
"failed %d", __FUNCTION__, domain, type, fd));
else
LOG_E(ci_log("%s: ci_tcp_helper_sock_attach (domain=%d, type=%d) "
"failed %d", __FUNCTION__, domain, type, fd));
ci_netif_unlock(netif);
return fd;
}
ci_assert(~us->s.b.sb_aflags & CI_SB_AFLAG_ORPHAN);
us->s.rx_errno = 0;
us->s.tx_errno = 0;
us->s.so_error = 0;
us->s.cp.sock_cp_flags |= OO_SCP_UDP_WILD;
ep->s = &us->s;
ep->netif = netif;
CHECK_UEP(ep);
ci_netif_unlock(netif);
return fd;
}
/* Conclude the EP's binding. This function is abstracted from the
* main bind code to allow implicit binds that occur when sendto() is
* called on an OS socket. [lport] and CI_SIN(addr)->sin_port do not
* have to be the same value. */
static int ci_udp_bind_conclude(citp_socket* ep, const struct sockaddr* addr,
ci_uint16 lport )
{
ci_udp_state* us;
ci_uint32 addr_be32;
int rc;
CHECK_UEP(ep);
ci_assert(addr != NULL);
if( ci_udp_should_handover(ep, addr, lport) )
goto handover;
addr_be32 = ci_get_ip4_addr(ep->s->domain, addr);
ci_udp_set_laddr(ep, addr_be32, lport);
us = SOCK_TO_UDP(ep->s);
if( addr_be32 != 0 )
us->s.cp.sock_cp_flags |= OO_SCP_LADDR_BOUND;
/* reset any rx/tx that have taken place already */
UDP_CLR_FLAG(us, CI_UDPF_EF_SEND);
#ifdef ONLOAD_OFE
if( ep->netif->ofe != NULL )
us->s.ofe_code_start = ofe_socktbl_find(
ep->netif->ofe, OFE_SOCKTYPE_UDP,
udp_laddr_be32(us), udp_raddr_be32(us),
udp_lport_be16(us), udp_rport_be16(us));
#endif
/* OS source addrs have already been handed-over, so this must be one of
* our src addresses.
*/
rc = ci_udp_set_filters( ep, us);
ci_assert( !UDP_GET_FLAG(us, CI_UDPF_EF_BIND) );
/*! \todo FIXME isn't the port the thing to be testing here? */
if( udp_laddr_be32(us) != INADDR_ANY_BE32 )
UDP_SET_FLAG(us, CI_UDPF_EF_BIND);
CI_UDPSTATE_SHOW_EP( ep );
if( rc == CI_SOCKET_ERROR && CITP_OPTS.no_fail) {
CITP_STATS_NETIF(++ep->netif->state->stats.udp_bind_no_filter);
goto handover;
}
return rc;
handover:
LOG_UV(log("%s: "SK_FMT" HANDOVER", __FUNCTION__, SK_PRI_ARGS(ep)));
return CI_SOCKET_HANDOVER;
}
/*! \todo we can simplify this a lot by letting the kernel have it! */
int ci_udp_getpeername(citp_socket*ep, struct sockaddr* name, socklen_t* namelen)
{
ci_udp_state* us;
CHECK_UEP(ep);
us = SOCK_TO_UDP(ep->s);
/*
* At first, it's necessary to check whether socket is connected or
* not, since we can return ENOTCONN even if name and/or namelen are
* not valid.
*/
if( udp_raddr_be32(us) == 0 ) {
RET_WITH_ERRNO(ENOTCONN);
} else if( name == NULL || namelen == NULL ) {
RET_WITH_ERRNO(EFAULT);
} else {
ci_addr_to_user(name, namelen, ep->s->domain,
udp_rport_be16(us), udp_raddr_be32(us));
return 0;
}
}
/* To handle bind we just let the underlying OS socket make all
* of the decisions for us. If The bind leaves things such that
* the source address is not one of ours then we hand it over to the
* OS (by returning CI_SOCKET_HANDOVER) - in which case the OS socket
* will be bound as expected. */
int ci_udp_bind(citp_socket* ep, ci_fd_t fd, const struct sockaddr* addr,
socklen_t addrlen)
{
int rc;
ci_uint16 local_port;
CHECK_UEP(ep);
LOG_UC(log("%s("SF_FMT", addrlen=%d)", __FUNCTION__,
SF_PRI_ARGS(ep,fd), addrlen));
/* Make sure we have no filters.
*
* ?? TODO: Under what circumstances could we possibly have filters here?
* _WIN32 only perhaps?
*/
ci_udp_clr_filters(ep);
rc = ci_tcp_helper_bind_os_sock(fd, addr, addrlen, &local_port);
if( rc == CI_SOCKET_ERROR )
return rc;
return ci_udp_bind_conclude(ep, addr, local_port );
}
/* create a pt->pt association with a server
* This uses the OS to do all the work so that we don't have to emulate
* some of the more unpleasant "tricks" of Linux.
*
* When we're either handing-over OS-dest connects or when we're "no
* failing" connects we may return -2 (unhandled). In this case the
* OS socket _has_ been connected & we therefore are handing-over to
* a socket in the right state.
*
* NOTE: WINDOWS the WSPConnect() API is quite a lot more complex than
* the BSD one. Therefore, to stop polluting the core code with masses
* of Windows frippery, the backing socket connection is successfully
* established _before_ this function is called. This function will use
* the state of the backing socket to configure the Efab socket - so the
* end result is the same (right down to the race between the OS socket
* connection being established and our filters being inserted).
*/
int ci_udp_connect(citp_socket* ep, ci_fd_t fd,
const struct sockaddr* serv_addr, socklen_t addrlen )
{
int rc;
ci_fd_t os_sock;
CHECK_UEP(ep);
LOG_UC(log("%s("SF_FMT", addrlen=%d)", __FUNCTION__,
SF_PRI_ARGS(ep,fd), addrlen));
os_sock = ci_get_os_sock_fd(fd);
if( !CI_IS_VALID_SOCKET( os_sock ) ) {
LOG_U(ci_log("%s: no backing socket", __FUNCTION__));
return -1;
}
/* Because we have not handed over the fd to the OS all calls to bind()
* and connect() will have been seen by us - therefore our copies of
* the local/remote address & port will be accurate. */
/* Let the OS do the connection - it'll also do the data validation
* for free. On failure the OS changes nothing - therefore we
* need to leave the filters in place (if such they were).
* Because the OS socket and our socket are socket-options-synchronized,
* the following call will also check the supplied address according to
* the SO_BROADCAST socket option settings. */
rc = ci_sys_connect(os_sock, serv_addr, addrlen);
if( rc != 0 ) {
LOG_U(log("%s: sys_connect failed errno:%d", __FUNCTION__, errno));
ci_rel_os_sock_fd(os_sock);
return -1;
}
rc = ci_udp_connect_conclude( ep, fd, serv_addr, addrlen, os_sock);
ci_rel_os_sock_fd(os_sock);
return rc;
}
/* Complete a UDP U/L connect. The sys connect() call must have been made
* (and succeeded) before calling this function. So if anything goes wrong
* in here, then it can be consider an internal error or failing of onload.
*/
int ci_udp_connect_conclude(citp_socket* ep, ci_fd_t fd,
const struct sockaddr* serv_addr,
socklen_t addrlen, ci_fd_t os_sock)
{
const struct sockaddr_in* serv_sin = (const struct sockaddr_in*) serv_addr;
ci_uint32 dst_be32;
ci_udp_state* us = SOCK_TO_UDP(ep->s);
int onloadable;
int rc = 0;
CHECK_UEP(ep);
UDP_CLR_FLAG(us, CI_UDPF_EF_SEND);
us->s.rx_errno = 0;
us->s.tx_errno = 0;
if( IS_DISCONNECTING(serv_sin) ) {
rc = ci_udp_disconnect(ep, us, os_sock);
goto out;
}
#if CI_CFG_FAKE_IPV6
if( us->s.domain == PF_INET6 && !ci_tcp_ipv6_is_ipv4(serv_addr) ) {
LOG_UC(log(FNT_FMT "HANDOVER not IPv4", FNT_PRI_ARGS(ep->netif, us)));
goto handover;
}
#endif
dst_be32 = ci_get_ip4_addr(serv_sin->sin_family, serv_addr);
if( (rc = ci_udp_sys_getsockname(os_sock, ep)) != 0 ) {
LOG_E(log(FNT_FMT "ERROR: (%s:%d) sys_getsockname failed (%d)",
FNT_PRI_ARGS(ep->netif, us), ip_addr_str(dst_be32),
CI_BSWAP_BE16(serv_sin->sin_port), errno));
goto out;
}
us->s.cp.sock_cp_flags |= OO_SCP_CONNECTED;
ci_udp_set_raddr(us, dst_be32, serv_sin->sin_port);
cicp_user_retrieve(ep->netif, &us->s.pkt, &us->s.cp);
switch( us->s.pkt.status ) {
case retrrc_success:
case retrrc_nomac:
onloadable = 1;
break;
default:
onloadable = 0;
if( NI_OPTS(ep->netif).udp_connect_handover ) {
LOG_UC(log(FNT_FMT "HANDOVER %s:%d", FNT_PRI_ARGS(ep->netif, us),
ip_addr_str(dst_be32), CI_BSWAP_BE16(serv_sin->sin_port)));
goto handover;
}
break;
}
if( dst_be32 == INADDR_ANY_BE32 || serv_sin->sin_port == 0 ) {
LOG_UC(log(FNT_FMT "%s:%d - route via OS socket",
FNT_PRI_ARGS(ep->netif, us), ip_addr_str(dst_be32),
CI_BSWAP_BE16(serv_sin->sin_port)));
ci_udp_clr_filters(ep);
return 0;
}
if( CI_IP_IS_LOOPBACK(dst_be32) ) {
/* After connecting via loopback it is not possible to connect anywhere
* else.
*/
LOG_UC(log(FNT_FMT "HANDOVER %s:%d", FNT_PRI_ARGS(ep->netif, us),
ip_addr_str(dst_be32), CI_BSWAP_BE16(serv_sin->sin_port)));
goto handover;
}
if( onloadable ) {
#ifdef ONLOAD_OFE
if( ep->netif->ofe != NULL )
us->s.ofe_code_start = ofe_socktbl_find(
ep->netif->ofe, OFE_SOCKTYPE_UDP,
udp_laddr_be32(us), udp_raddr_be32(us),
udp_lport_be16(us), udp_rport_be16(us));
#endif
if( (rc = ci_udp_set_filters(ep, us)) != 0 ) {
/* Failed to set filters. Most likely we've run out of h/w filters.
* Handover to O/S to avoid breaking the app.
*
* TODO: Actually we probably won't break the app if we don't
* handover, as packets will still get delivered via the kernel
* stack. Might be worth having a runtime option to choose whether
* or not to handover in such cases.
*/
LOG_U(log(FNT_FMT "ERROR: (%s:%d) ci_udp_set_filters failed (%d)",
FNT_PRI_ARGS(ep->netif, us), ip_addr_str(dst_be32),
CI_BSWAP_BE16(serv_sin->sin_port), rc));
CITP_STATS_NETIF(++ep->netif->state->stats.udp_connect_no_filter);
goto out;
}
}
else {
ci_udp_clr_filters(ep);
}
LOG_UC(log(LPF "connect: "SF_FMT" %sCONNECTED L:%s:%u R:%s:%u (err:%d)",
SF_PRI_ARGS(ep,fd), udp_raddr_be32(us) ? "" : "DIS",
ip_addr_str(udp_laddr_be32(us)),
(unsigned) CI_BSWAP_BE16(udp_lport_be16(us)),
ip_addr_str(udp_raddr_be32(us)),
(unsigned) CI_BSWAP_BE16(udp_rport_be16(us)), errno));
return 0;
out:
if( rc < 0 && CITP_OPTS.no_fail )
goto handover;
return rc;
handover:
ci_udp_clr_filters(ep);
return CI_SOCKET_HANDOVER;
}