int app_glue_v4_connect(struct socket *sock,unsigned int ipaddr,unsigned short port)
{
struct sockaddr_in sin;
if(!sock->sk)
return -1;
struct inet_sock *inet = inet_sk(sock->sk);
while(!inet->inet_num) {
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = /*my_ip_addr*/0;
sin.sin_port = htons(rand() & 0xffff);
if(kernel_bind(sock,(struct sockaddr *)&sin,sizeof(sin))) {
syslog(LOG_ERR,"cannot bind %s %d %d\n",__FILE__,__LINE__,sin.sin_port);
continue;
}
break;
}
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = ipaddr;
sin.sin_port = port;
if(sock->sk) {
sock->sk->sk_state_change = app_glue_sock_wakeup;
}
kernel_connect(sock, (struct sockaddr *)&sin,sizeof(sin), 0);
return 0;
}
int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg,
struct socket **sockp)
{
struct sockaddr_in6 udp6_addr;
int err;
struct socket *sock = NULL;
err = sock_create_kern(AF_INET6, SOCK_DGRAM, 0, &sock);
if (err < 0)
goto error;
sk_change_net(sock->sk, net);
udp6_addr.sin6_family = AF_INET6;
memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
sizeof(udp6_addr.sin6_addr));
udp6_addr.sin6_port = cfg->local_udp_port;
err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
sizeof(udp6_addr));
if (err < 0)
goto error;
if (cfg->peer_udp_port) {
udp6_addr.sin6_family = AF_INET6;
memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
sizeof(udp6_addr.sin6_addr));
udp6_addr.sin6_port = cfg->peer_udp_port;
err = kernel_connect(sock,
(struct sockaddr *)&udp6_addr,
sizeof(udp6_addr), 0);
}
if (err < 0)
goto error;
udp_set_no_check6_tx(sock->sk, !cfg->use_udp6_tx_checksums);
udp_set_no_check6_rx(sock->sk, !cfg->use_udp6_rx_checksums);
*sockp = sock;
return 0;
error:
if (sock) {
kernel_sock_shutdown(sock, SHUT_RDWR);
sk_release_kernel(sock->sk);
}
*sockp = NULL;
return err;
}
static int exchange_info (unsigned int addr)
{
struct socket *sock = NULL;
struct sockaddr_in sin;
int ret;
ret = sock_create (AF_INET, SOCK_STREAM, 0, &sock);
if (ret) {
printk (KERN_INFO "Sock create failed: %d\n", ret);
goto err;
}
sin.sin_family = AF_INET;
sin.sin_port = htons (PORT);
sin.sin_addr.s_addr = htonl (server_addr);
printk (KERN_INFO "Trying to connect to 0x%x\n", server_addr);
ret = kernel_connect (sock, (struct sockaddr*)&sin, sizeof (sin), 0);
if (ret) {
printk (KERN_INFO "Connect failed: %d\n", ret);
goto err;
}
ret = recv_remote_info (sock, &remote_info);
if (ret)
goto err;
ret = send_remote_info (sock, &local_info);
if (ret)
goto err;
have_remote_info = 1;
printk (KERN_INFO "Got information about remote side.\n");
printk (KERN_INFO "QPN: 0x%x, QKey: %u, LID: 0x%x, GID: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
remote_info.qp_num, remote_info.qkey, remote_info.lid,
remote_info.gid.raw[0], remote_info.gid.raw[1], remote_info.gid.raw[2], remote_info.gid.raw[3],
remote_info.gid.raw[4], remote_info.gid.raw[5], remote_info.gid.raw[6], remote_info.gid.raw[7],
remote_info.gid.raw[8], remote_info.gid.raw[9], remote_info.gid.raw[10], remote_info.gid.raw[10],
remote_info.gid.raw[12], remote_info.gid.raw[13], remote_info.gid.raw[14], remote_info.gid.raw[15]);
err:
if (sock)
sock_release (sock);
return ret;
}
int udp_sock_create4(struct net *net, struct udp_port_cfg *cfg,
struct socket **sockp)
{
int err;
struct socket *sock = NULL;
struct sockaddr_in udp_addr;
err = sock_create_kern(AF_INET, SOCK_DGRAM, 0, &sock);
if (err < 0)
goto error;
sk_change_net(sock->sk, net);
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->local_ip;
udp_addr.sin_port = cfg->local_udp_port;
err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
sizeof(udp_addr));
if (err < 0)
goto error;
if (cfg->peer_udp_port) {
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->peer_ip;
udp_addr.sin_port = cfg->peer_udp_port;
err = kernel_connect(sock, (struct sockaddr *)&udp_addr,
sizeof(udp_addr), 0);
if (err < 0)
goto error;
}
sock->sk->sk_no_check_tx = !cfg->use_udp_checksums;
*sockp = sock;
return 0;
error:
if (sock) {
kernel_sock_shutdown(sock, SHUT_RDWR);
sk_release_kernel(sock->sk);
}
*sockp = NULL;
return err;
}
/*
* We need to preserve the port number so the reply cache on the server can
* find our cached RPC replies when we get around to reconnecting.
*/
static void xs_abort_connection(struct rpc_xprt *xprt)
{
int result;
struct socket *sock = xprt->sock;
struct sockaddr any;
dprintk("RPC: disconnecting xprt %p to reuse port\n", xprt);
/*
* Disconnect the transport socket by doing a connect operation
* with AF_UNSPEC. This should return immediately...
*/
memset(&any, 0, sizeof(any));
any.sa_family = AF_UNSPEC;
result = kernel_connect(sock, &any, sizeof(any), 0);
if (result)
dprintk("RPC: AF_UNSPEC connect return code %d\n",
result);
}
int sclp_sock_create4(struct net *net, struct sclp_port_cfg *cfg, struct socket **sockp)
{
int err;
struct socket *sock = NULL;
struct sockaddr_in sclp_addr;
err = sock_create_kern(AF_INET, SOCK_SCLP, 0, &sock);
if (err < 0)
goto error;
sk_change_net(sock->sk, net);
sclp_addr.sin_family = AF_INET;
sclp_addr.sin_addr = cfg->local_ip;
sclp_addr.sin_port = cfg->local_sclp_port;
err = kernel_bind(sock, (struct sockaddr*)&sclp_addr, sizeof(sclp_addr));
if (err < 0)
goto error;
if (cfg->peer_sclp_port) {
sclp_addr.sin_family = AF_INET;
sclp_addr.sin_addr = cfg->peer_ip;
sclp_addr.sin_port = cfg->peer_sclp_port;
err = kernel_connect(sock, (struct sockaddr*)&sclp_addr, sizeof(sclp_addr), 0);
if (err < 0)
goto error;
}
*sockp = sock;
return 0;
error:
if (sock) {
kernel_sock_shutdown(sock, SHUT_RDWR);
sk_release_kernel(sock->sk);
}
*sockp = NULL;
return err;
}
int
lnet_sock_connect(struct socket **sockp, int *fatal, __u32 local_ip,
int local_port, __u32 peer_ip, int peer_port)
{
struct sockaddr_in srvaddr;
int rc;
rc = lnet_sock_create(sockp, fatal, local_ip, local_port);
if (rc)
return rc;
memset(&srvaddr, 0, sizeof(srvaddr));
srvaddr.sin_family = AF_INET;
srvaddr.sin_port = htons(peer_port);
srvaddr.sin_addr.s_addr = htonl(peer_ip);
rc = kernel_connect(*sockp, (struct sockaddr *)&srvaddr,
sizeof(srvaddr), 0);
if (!rc)
return 0;
/*
* EADDRNOTAVAIL probably means we're already connected to the same
* peer/port on the same local port on a differently typed
* connection. Let our caller retry with a different local
* port...
*/
*fatal = !(rc == -EADDRNOTAVAIL);
CDEBUG_LIMIT(*fatal ? D_NETERROR : D_NET,
"Error %d connecting %pI4h/%d -> %pI4h/%d\n", rc,
&local_ip, local_port, &peer_ip, peer_port);
sock_release(*sockp);
return rc;
}
static int syslog_connect(struct socket **socket)
{
int ret = 0;
int retry = 0;
int logtype = SOCK_DGRAM;
struct sockaddr_un syslog_server;
while (retry < 2)
{
ret = sock_create_kern(PF_UNIX, logtype, 0, socket);
if (ret < 0)
break;
syslog_server.sun_family = PF_UNIX;
strcpy(syslog_server.sun_path , "/dev/log");
ret = kernel_connect(*socket, (struct sockaddr *)&syslog_server, sizeof(struct sockaddr_un) - 1, 0);
if (ret < 0)
{
if (ret == -EPROTOTYPE)
{
logtype = (logtype == SOCK_DGRAM ? SOCK_STREAM : SOCK_DGRAM);
}
retry++;
goto cleanup_sock;
}
(*socket)->sk->sk_allocation = GFP_NOIO;
return ret;
cleanup_sock:
sock_release(*socket);
*socket = NULL;
}
return ret;
}
int rpl_udp_sock_create(struct net *net, struct udp_port_cfg *cfg,
struct socket **sockp)
{
int err;
struct socket *sock = NULL;
#if IS_ENABLED(CONFIG_IPV6)
if (cfg->family == AF_INET6) {
struct sockaddr_in6 udp6_addr;
err = sock_create_kern(net, AF_INET6, SOCK_DGRAM, 0, &sock);
if (err < 0)
goto error;
udp6_addr.sin6_family = AF_INET6;
memcpy(&udp6_addr.sin6_addr, &cfg->local_ip6,
sizeof(udp6_addr.sin6_addr));
udp6_addr.sin6_port = cfg->local_udp_port;
err = kernel_bind(sock, (struct sockaddr *)&udp6_addr,
sizeof(udp6_addr));
if (err < 0)
goto error;
if (cfg->peer_udp_port) {
udp6_addr.sin6_family = AF_INET6;
memcpy(&udp6_addr.sin6_addr, &cfg->peer_ip6,
sizeof(udp6_addr.sin6_addr));
udp6_addr.sin6_port = cfg->peer_udp_port;
err = kernel_connect(sock,
(struct sockaddr *)&udp6_addr,
sizeof(udp6_addr), 0);
}
if (err < 0)
goto error;
} else
#endif
if (cfg->family == AF_INET) {
struct sockaddr_in udp_addr;
err = sock_create_kern(net, AF_INET, SOCK_DGRAM, 0, &sock);
if (err < 0)
goto error;
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->local_ip;
udp_addr.sin_port = cfg->local_udp_port;
err = kernel_bind(sock, (struct sockaddr *)&udp_addr,
sizeof(udp_addr));
if (err < 0)
goto error;
if (cfg->peer_udp_port) {
udp_addr.sin_family = AF_INET;
udp_addr.sin_addr = cfg->peer_ip;
udp_addr.sin_port = cfg->peer_udp_port;
err = kernel_connect(sock,
(struct sockaddr *)&udp_addr,
sizeof(udp_addr), 0);
if (err < 0)
goto error;
}
} else {
return -EPFNOSUPPORT;
}
*sockp = sock;
return 0;
error:
if (sock) {
kernel_sock_shutdown(sock, SHUT_RDWR);
sock_release(sock);
}
*sockp = NULL;
return err;
}
/**
* xs_tcp_connect_worker - connect a TCP socket to a remote endpoint
* @args: RPC transport to connect
*
* Invoked by a work queue tasklet.
*/
static void xs_tcp_connect_worker(void *args)
{
struct rpc_xprt *xprt = (struct rpc_xprt *)args;
struct socket *sock = xprt->sock;
int err, status = -EIO;
if (xprt->shutdown || xprt->addr.sin_port == 0)
goto out;
dprintk("RPC: xs_tcp_connect_worker for xprt %p\n", xprt);
if (!xprt->sock) {
/* start from scratch */
if ((err = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock)) < 0) {
dprintk("RPC: can't create TCP transport socket (%d).\n", -err);
goto out;
}
xs_reclassify_socket(sock);
if (xs_bind(xprt, sock)) {
sock_release(sock);
goto out;
}
} else
/* "close" the socket, preserving the local port */
xs_tcp_reuse_connection(xprt);
if (!xprt->inet) {
struct sock *sk = sock->sk;
write_lock_bh(&sk->sk_callback_lock);
sk->sk_user_data = xprt;
xprt->old_data_ready = sk->sk_data_ready;
xprt->old_state_change = sk->sk_state_change;
xprt->old_write_space = sk->sk_write_space;
sk->sk_data_ready = xs_tcp_data_ready;
sk->sk_state_change = xs_tcp_state_change;
sk->sk_write_space = xs_tcp_write_space;
sk->sk_allocation = GFP_ATOMIC;
/* socket options */
sk->sk_userlocks |= SOCK_BINDPORT_LOCK;
sock_reset_flag(sk, SOCK_LINGER);
tcp_sk(sk)->linger2 = 0;
tcp_sk(sk)->nonagle |= TCP_NAGLE_OFF;
xprt_clear_connected(xprt);
/* Reset to new socket */
xprt->sock = sock;
xprt->inet = sk;
write_unlock_bh(&sk->sk_callback_lock);
}
/* Tell the socket layer to start connecting... */
xprt->stat.connect_count++;
xprt->stat.connect_start = jiffies;
status = kernel_connect(sock, (struct sockaddr *) &xprt->addr,
sizeof(xprt->addr), O_NONBLOCK);
dprintk("RPC: %p connect status %d connected %d sock state %d\n",
xprt, -status, xprt_connected(xprt), sock->sk->sk_state);
if (status < 0) {
switch (status) {
case -EINPROGRESS:
case -EALREADY:
goto out_clear;
case -ECONNREFUSED:
case -ECONNRESET:
/* retry with existing socket, after a delay */
break;
case -ENETUNREACH:
status = -ENOTCONN;
break;
default:
/* get rid of existing socket, and retry */
xs_close(xprt);
break;
}
}
out:
xprt_wake_pending_tasks(xprt, status);
out_clear:
xprt_clear_connecting(xprt);
}
/* Create a new IPv4 subflow.
*
* We are in user-context and meta-sock-lock is hold.
*/
int mptcp_init4_subsockets(struct sock *meta_sk, const struct mptcp_loc4 *loc,
struct mptcp_rem4 *rem)
{
struct tcp_sock *tp;
struct sock *sk;
struct sockaddr_in loc_in, rem_in;
struct socket_alloc sock_full;
struct socket *sock = (struct socket *)&sock_full;
int ret;
/** First, create and prepare the new socket */
memcpy(&sock_full, meta_sk->sk_socket, sizeof(sock_full));
sock->state = SS_UNCONNECTED;
sock->ops = NULL;
ret = inet_create(sock_net(meta_sk), sock, IPPROTO_TCP, 1);
if (unlikely(ret < 0)) {
net_err_ratelimited("%s inet_create failed ret: %d\n",
__func__, ret);
return ret;
}
sk = sock->sk;
tp = tcp_sk(sk);
/* All subsockets need the MPTCP-lock-class */
lockdep_set_class_and_name(&(sk)->sk_lock.slock, &meta_slock_key, meta_slock_key_name);
lockdep_init_map(&(sk)->sk_lock.dep_map, meta_key_name, &meta_key, 0);
ret = mptcp_add_sock(meta_sk, sk, loc->loc4_id, rem->rem4_id, GFP_KERNEL);
if (ret) {
net_err_ratelimited("%s mptcp_add_sock failed ret: %d\n",
__func__, ret);
goto error;
}
tp->mptcp->slave_sk = 1;
/* Initializing the timer for an MPTCP subflow */
timer_setup(&tp->mptcp->mptcp_ack_timer, mptcp_ack_handler, 0);
/** Then, connect the socket to the peer */
loc_in.sin_family = AF_INET;
rem_in.sin_family = AF_INET;
loc_in.sin_port = 0;
if (rem->port)
rem_in.sin_port = rem->port;
else
rem_in.sin_port = inet_sk(meta_sk)->inet_dport;
loc_in.sin_addr = loc->addr;
rem_in.sin_addr = rem->addr;
if (loc->if_idx)
sk->sk_bound_dev_if = loc->if_idx;
ret = kernel_bind(sock, (struct sockaddr *)&loc_in,
sizeof(struct sockaddr_in));
if (ret < 0) {
net_err_ratelimited("%s: token %#x bind() to %pI4 index %d failed, error %d\n",
__func__, tcp_sk(meta_sk)->mpcb->mptcp_loc_token,
&loc_in.sin_addr, loc->if_idx, ret);
goto error;
}
mptcp_debug("%s: token %#x pi %d src_addr:%pI4:%d dst_addr:%pI4:%d ifidx: %d\n",
__func__, tcp_sk(meta_sk)->mpcb->mptcp_loc_token,
tp->mptcp->path_index, &loc_in.sin_addr,
ntohs(loc_in.sin_port), &rem_in.sin_addr,
ntohs(rem_in.sin_port), loc->if_idx);
ret = kernel_connect(sock, (struct sockaddr *)&rem_in,
sizeof(struct sockaddr_in), O_NONBLOCK);
if (ret < 0 && ret != -EINPROGRESS) {
net_err_ratelimited("%s: MPTCP subsocket connect() failed, error %d\n",
__func__, ret);
goto error;
}
MPTCP_INC_STATS(sock_net(meta_sk), MPTCP_MIB_JOINSYNTX);
sk_set_socket(sk, meta_sk->sk_socket);
sk->sk_wq = meta_sk->sk_wq;
return 0;
error:
/* May happen if mptcp_add_sock fails first */
if (!mptcp(tp)) {
tcp_close(sk, 0);
} else {
local_bh_disable();
mptcp_sub_force_close(sk);
local_bh_enable();
}
return ret;
}
static struct socket *
udp_tx_sock_create (struct in_addr if_address,
uint16_t port,
struct in_addr dest_addr,
uint32_t bufsize)
{
struct socket *sk;
struct sockaddr_in saddr;
char loop = 0;
int err = 0;
do {
err = sock_create(PF_INET, SOCK_DGRAM, 0, &sk);
if (err < 0) {
break;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin_addr = if_address;
saddr.sin_family = AF_INET;
saddr.sin_port = 0;
err = kernel_bind(sk,
(struct sockaddr *) &saddr,
sizeof(saddr));
if (err < 0) {
break;
}
err = kernel_setsockopt(sk,
IPPROTO_IP,
IP_MULTICAST_LOOP,
&loop,
sizeof(loop));
if (err < 0) {
break;
}
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr = dest_addr;
saddr.sin_port = port;
err = kernel_connect(sk,
(struct sockaddr *)&saddr,
sizeof(saddr),
0);
if (err < 0) {
break;
}
if (bufsize) {
err = kernel_setsockopt(sk,
SOL_SOCKET,
SO_SNDBUF,
(char *)&bufsize,
sizeof(bufsize));
if (err < 0) {
break;
}
}
} while (0);
if (err < 0) {
kernel_sock_shutdown(sk, SHUT_RDWR);
sock_release(sk);
sk = NULL;
}
return (sk);
}
void
btv_send_msg_thru_eth(const unsigned char *buf, int size)
{
struct socket *sock[NUM_OF_SOCKS];
struct sockaddr ksockaddr[NUM_OF_SOCKS] = {0};
struct msghdr msg;
struct kvec iov;
printk("Send Message Thru Eth\n");
for (;;) {
/* To communicate TVSOC, we have to prepare two sockets for sync and async ports */
sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock[SOCK_FOR_SYNC]);
sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock[SOCK_FOR_ASYNC]);
/* initialize socket for sync command */
ksockaddr[SOCK_FOR_SYNC].sa_family = PF_INET;
/* sockaddr.sin_addr.s_addr = inet_addr((const char*)("198.18.186.199")); */
//*((unsigned short *)&(ksockaddr.sa_data[0])) = 0x409c; /* 0x9c40:40000 */
*((unsigned short *)&(ksockaddr[SOCK_FOR_SYNC].sa_data[0])) = htons(40000); /* 0x9c40:40000 */
//*((unsigned int *)&(ksockaddr.sa_data[2])) = 0x0b9c082b; /* 0x2b:43 0x08:08 0x9c:156 0x0b:11 */
*((unsigned int *)&(ksockaddr[SOCK_FOR_SYNC].sa_data[2])) = 0xc7ba12c6; /* 0xc6:198 0x12:18 0xba:186 0xc7:199 */
/* initialize socket for async command */
ksockaddr[SOCK_FOR_ASYNC].sa_family = PF_INET;
*((unsigned short *)&(ksockaddr[SOCK_FOR_ASYNC].sa_data[0])) = htons(40001); /* 0x9d40:40001 */
//*((unsigned int *)&(ksockaddr.sa_data[2])) = 0x0b9c082b; /* 0x2b:43 0x08:08 0x9c:156 0x0b:11 */
*((unsigned int *)&(ksockaddr[SOCK_FOR_ASYNC].sa_data[2])) = 0xc7ba12c6; /* 0xc6:198 0x12:18 0xba:186 0xc7:199 */
while(kernel_connect(sock[SOCK_FOR_SYNC], (struct sockaddr *)&ksockaddr[SOCK_FOR_SYNC], sizeof(struct sockaddr), 0) < 0) {
printk("Cannot connect server sync port, Retry \n");
mdelay(REBOOT_CMD_INTERVAL_MSEC);
}
while(kernel_connect(sock[SOCK_FOR_ASYNC], (struct sockaddr *)&ksockaddr[SOCK_FOR_ASYNC], sizeof(struct sockaddr), 0) < 0) {
printk("Cannot connect server async port, Retry \n");
mdelay(REBOOT_CMD_INTERVAL_MSEC);
}
iov.iov_base = (void *)buf;
iov.iov_len = ETH_CMD_SIZE;
msg.msg_name = (struct sockaddr *)&ksockaddr[SOCK_FOR_SYNC];
msg.msg_namelen = sizeof(struct sockaddr);
msg.msg_iov = (struct iovec *) &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
kernel_sendmsg(sock[SOCK_FOR_SYNC], &msg, &iov, 1, ETH_CMD_SIZE);
sock_release(sock[SOCK_FOR_SYNC]);
sock_release(sock[SOCK_FOR_ASYNC]);
mdelay(ETHER_CMD_INTERVAL);
}
/* NOREACHED */
}
