int sim_sock_accept (struct SimSocket *socket, struct SimSocket **new_socket, int flags)
{
struct socket *sock, *newsock;
int err;
sock = (struct socket *)socket;
// the fields do not matter here. If we could,
// we would call sock_alloc but it's not exported.
err = sock_create_lite (0, 0, 0, &newsock);
if (err < 0)
{
return err;
}
newsock->type = sock->type;
newsock->ops = sock->ops;
err = sock->ops->accept(sock, newsock, flags);
if (err < 0)
{
sock_release (newsock);
return err;
}
*new_socket = (struct SimSocket *)newsock;
return 0;
}
struct sock *
netlink_kernel_create(int unit, void (*input)(struct sock *sk, int len))
{
struct socket *sock;
struct sock *sk;
if (!nl_table)
return NULL;
if (unit<0 || unit>=MAX_LINKS)
return NULL;
if (sock_create_lite(PF_NETLINK, SOCK_DGRAM, unit, &sock))
return NULL;
if (netlink_create(sock, unit) < 0) {
sock_release(sock);
return NULL;
}
sk = sock->sk;
sk->sk_data_ready = netlink_data_ready;
if (input)
nlk_sk(sk)->data_ready = input;
if (netlink_insert(sk, 0)) {
sock_release(sock);
return NULL;
}
return sk;
}
static int rds_tcp_accept_one(struct socket *sock)
{
struct socket *new_sock = NULL;
struct rds_connection *conn;
int ret;
struct inet_sock *inet;
ret = sock_create_lite(sock->sk->sk_family, sock->sk->sk_type,
sock->sk->sk_protocol, &new_sock);
if (ret)
goto out;
new_sock->type = sock->type;
new_sock->ops = sock->ops;
ret = sock->ops->accept(sock, new_sock, O_NONBLOCK);
if (ret < 0)
goto out;
rds_tcp_tune(new_sock);
inet = inet_sk(new_sock->sk);
rdsdebug("accepted tcp %pI4:%u -> %pI4:%u\n",
&inet->inet_saddr, ntohs(inet->inet_sport),
&inet->inet_daddr, ntohs(inet->inet_dport));
conn = rds_conn_create(inet->inet_saddr, inet->inet_daddr,
&rds_tcp_transport, GFP_KERNEL);
if (IS_ERR(conn)) {
ret = PTR_ERR(conn);
goto out;
}
/*
* see the comment above rds_queue_delayed_reconnect()
*/
if (!rds_conn_transition(conn, RDS_CONN_DOWN, RDS_CONN_CONNECTING)) {
if (rds_conn_state(conn) == RDS_CONN_UP)
rds_tcp_stats_inc(s_tcp_listen_closed_stale);
else
rds_tcp_stats_inc(s_tcp_connect_raced);
rds_conn_drop(conn);
ret = 0;
goto out;
}
rds_tcp_set_callbacks(new_sock, conn);
rds_connect_complete(conn);
new_sock = NULL;
ret = 0;
out:
if (new_sock)
sock_release(new_sock);
return ret;
}
int
lnet_sock_accept(struct socket **newsockp, struct socket *sock)
{
wait_queue_entry_t wait;
struct socket *newsock;
int rc;
/*
* XXX this should add a ref to sock->ops->owner, if
* TCP could be a module
*/
rc = sock_create_lite(PF_PACKET, sock->type, IPPROTO_TCP, &newsock);
if (rc) {
CERROR("Can't allocate socket\n");
return rc;
}
newsock->ops = sock->ops;
rc = sock->ops->accept(sock, newsock, O_NONBLOCK, false);
if (rc == -EAGAIN) {
/* Nothing ready, so wait for activity */
init_waitqueue_entry(&wait, current);
add_wait_queue(sk_sleep(sock->sk), &wait);
set_current_state(TASK_INTERRUPTIBLE);
schedule();
remove_wait_queue(sk_sleep(sock->sk), &wait);
rc = sock->ops->accept(sock, newsock, O_NONBLOCK, false);
}
if (rc)
goto failed;
*newsockp = newsock;
return 0;
failed:
sock_release(newsock);
return rc;
}
int sock_tcpsrv_waitfor_cli(struct socket *server_sock, struct socket **client_sock, int flags)
{
struct sock *sk = server_sock->sk;
int err;
err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, client_sock);
if (err < 0)
goto done;
err = server_sock->ops->accept(server_sock, *client_sock, flags);
if (err < 0)
{
sock_release(*client_sock);
*client_sock= NULL;
goto done;
}
(*client_sock)->ops = server_sock->ops;
__module_get((*client_sock)->ops->owner);
done:
return err;
}
/*
* Create a raw connection on a network device
*/
static void *privCreateRaw(char *pDevLabel)
{
raw_socket *pRaw = NULL;
int rvalue;
struct net_device *pDev = NULL;
if (NULL != pDevLabel) {
pRaw = kmalloc(sizeof(raw_socket), GFP_ATOMIC);
if (NULL != pRaw) {
pRaw->pSocket = NULL;
pRaw->bConnected = false;
/* Create our socket */
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4,2,0))
rvalue = sock_create_kern(PF_PACKET,
SOCK_RAW,
htons(ETH_P_ALL),
&pRaw->pSocket);
#else
rvalue = sock_create_lite(PF_PACKET,
SOCK_RAW,
htons(ETH_P_ALL),
&pRaw->pSocket);
#endif
if ((rvalue >= 0) && (NULL != pRaw->pSocket)) {
/* Need to reference our data structure */
pRaw->pSocket->sk->sk_user_data = (void *)pRaw;
/* Set 4 second timeout. Easy calculation. */
pRaw->pSocket->sk->sk_sndtimeo = HZ << 2;
pRaw->pSocket->sk->sk_rcvtimeo = HZ << 2;
/* Yea, we can reuse this socket. Needed? */
pRaw->pSocket->sk->sk_reuse = 1;
/* atomic allocation */
pRaw->pSocket->sk->sk_allocation = GFP_ATOMIC;
/* Create recv queue, before setting callbacks */
init_waitqueue_head(&pRaw->recvQueue);
/* We need a semaphore. */
sema_init(&pRaw->sendWait, 1);
/* Halt any callback */
write_lock_bh(&pRaw->pSocket->sk->sk_callback_lock);
/* Perhaps not needed, but remember our orignal data ready function. */
pRaw->recvReady = pRaw->pSocket->sk->sk_data_ready;
/* Our callback recv function. */
pRaw->pSocket->sk->sk_data_ready = privRecvReady;
/* Copy the header information */
strncpy(pRaw->hdr.str, KLEM_NAME, 4);
/* Set the protocol type */
pRaw->uProtocol = KLEM_PROTOCOL;
/* Set the protcol version */
pRaw->uVersion = KLEM_INT_VERSION;
/* Resume any callbacks */
write_unlock_bh(&pRaw->pSocket->sk->sk_callback_lock);
/* Find the device were will transmit the raw packet. */
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4,2,0))
pDev = __dev_get_by_name(pRaw->pSocket->sk->__sk_common.skc_net,
pDevLabel);
#else
pDev = __dev_get_by_name(pRaw->pSocket->sk->__sk_common.skc_net.net,
pDevLabel);
#endif
if (NULL != pDev) {
memcpy(pRaw->pDevMac, (char *)pDev->perm_addr, ETH_ALEN);
} else {
/* We failed, broadcasting it might work, lets try that. */
KLEM_MSG("Didn't find network device, we will broadcast it");
memset(pRaw->pDevMac, 0xff, ETH_ALEN);
}
/* Default the lemu to broadcast. */
memset(pRaw->pLemuMac, 0xff, ETH_ALEN);
/* Set the send/recv threads to null */
pRaw->pRecvThread = NULL;
/* Lets say we have a conenction now. */
pRaw->bConnected = true;
} else {
KLEM_LOG("Error creating socket %s %d\n", pDevLabel, rvalue);
kfree(pRaw);
pRaw = NULL;
}
}
}
return pRaw;
}
static int
kni_vhost_backend_init(struct kni_dev *kni)
{
struct kni_vhost_queue *q;
struct net *net = current->nsproxy->net_ns;
int err, i, sockfd;
struct rte_kni_fifo *fifo;
struct sk_buff *elem;
if (kni->vhost_queue != NULL)
return -1;
if (!(q = (struct kni_vhost_queue *)sk_alloc(
net, AF_UNSPEC, GFP_KERNEL, &kni_raw_proto)))
return -ENOMEM;
err = sock_create_lite(AF_UNSPEC, SOCK_RAW, IPPROTO_RAW, &q->sock);
if (err)
goto free_sk;
sockfd = kni_sock_map_fd(q->sock);
if (sockfd < 0) {
err = sockfd;
goto free_sock;
}
/* cache init */
q->cache = (struct sk_buff*)
kzalloc(RTE_KNI_VHOST_MAX_CACHE_SIZE * sizeof(struct sk_buff),
GFP_KERNEL);
if (!q->cache)
goto free_fd;
fifo = (struct rte_kni_fifo*)
kzalloc(RTE_KNI_VHOST_MAX_CACHE_SIZE * sizeof(void *)
+ sizeof(struct rte_kni_fifo), GFP_KERNEL);
if (!fifo)
goto free_cache;
kni_fifo_init(fifo, RTE_KNI_VHOST_MAX_CACHE_SIZE);
for (i = 0; i < RTE_KNI_VHOST_MAX_CACHE_SIZE; i++) {
elem = &q->cache[i];
kni_fifo_put(fifo, (void**)&elem, 1);
}
q->fifo = fifo;
/* store sockfd in vhost_queue */
q->sockfd = sockfd;
/* init socket */
q->sock->type = SOCK_RAW;
q->sock->state = SS_CONNECTED;
q->sock->ops = &kni_socket_ops;
sock_init_data(q->sock, &q->sk);
/* init sock data */
q->sk.sk_write_space = kni_sk_write_space;
q->sk.sk_destruct = kni_sk_destruct;
q->flags = IFF_NO_PI | IFF_TAP;
q->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
#ifdef RTE_KNI_VHOST_VNET_HDR_EN
q->flags |= IFF_VNET_HDR;
#endif
/* bind kni_dev with vhost_queue */
q->kni = kni;
kni->vhost_queue = q;
wmb();
kni->vq_status = BE_START;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)
KNI_DBG("backend init sockfd=%d, sock->wq=0x%16llx,"
"sk->sk_wq=0x%16llx",
q->sockfd, (uint64_t)q->sock->wq,
(uint64_t)q->sk.sk_wq);
#else
KNI_DBG("backend init sockfd=%d, sock->wait at 0x%16llx,"
"sk->sk_sleep=0x%16llx",
q->sockfd, (uint64_t)&q->sock->wait,
(uint64_t)q->sk.sk_sleep);
#endif
return 0;
free_cache:
kfree(q->cache);
q->cache = NULL;
free_fd:
put_unused_fd(sockfd);
free_sock:
q->kni = NULL;
kni->vhost_queue = NULL;
kni->vq_status |= BE_FINISH;
sock_release(q->sock);
q->sock->ops = NULL;
q->sock = NULL;
free_sk:
sk_free((struct sock*)q);
return err;
}
static int the_socket(void)
{
struct socket *socketnumber1;
struct socket *socketnumber2;
struct sockaddr_in *server_address;
//struct sockaddr_in *client_addres;
struct msghdr *sock_msg;
struct iovec iov;
int accepting1;
int size;
int readvalue;
char *buffer;
int a,b;
//mm_segment_t oldms;
printk(KERN_INFO "We are infact loading");
a = sock_create_kern(PF_INET, SOCK_STREAM,IPPROTO_TCP, &socketnumber1);
b = sock_create_lite(AF_INET, SOCK_STREAM, 0, &socketnumber2);
server_address=(struct sockaddr_in*) kmalloc(sizeof(struct sockaddr_in),GFP_KERNEL);
// client_address=(struct sockaddr_in*) kmalloc(sizeof(struct sockaddr_in),GFP_KERNEL);
//iov = (struct iovec) kmalloc(sizeof(iov),GFP_KERNEL);
sock_msg = (struct msghdr*) kmalloc(sizeof(struct msghdr),GFP_KERNEL);
buffer=(char *)kmalloc((sizeof(char)*1024),GFP_KERNEL);
printk(KERN_INFO "PHASE 1");
if(a<0)
{
printk(KERN_ERR "CREATE SOCKET ERROR");
return -1;
}
memset(server_address,0, sizeof(struct sockaddr_in));
//memset(newsocketfd,0, sizeof(struct socket));
//memset(socketinfo,0, sizeof(struct socket));
server_address->sin_family = AF_INET;
server_address->sin_port = htons(PORT);
server_address->sin_addr.s_addr =htonl(INADDR_ANY);
//bind
a = socketnumber1->ops->bind(socketnumber1,(struct sockaddr*)server_address,sizeof(struct sockaddr_in));
//listen
a = socketnumber1->ops->listen(socketnumber1,5);
//accept
iov.iov_base=buffer;
size=SNDBUF;
iov.iov_len=size;
//sock_msg->msg_name= client_address;
sock_msg->msg_namelen=sizeof(struct sockaddr_in);
sock_msg->msg_iov=&iov;
sock_msg->msg_iovlen=1;
sock_msg->msg_control=NULL;
sock_msg->msg_controllen=0;
sock_msg->msg_flags=0;
// size = SNDBUF;
accepting1 = socketnumber1->ops->accept(socketnumber1,socketnumber2, 0);
memset(&iov,0,sizeof(iov));
memset(sock_msg,0,sizeof(struct msghdr));
memset(buffer,0,SNDBUF);
if(accepting1 == -1)
{
printk(KERN_ERR "Error, accepting failed");
sock_release((struct socket *)socketnumber2);
return -1;
}
if(accepting1 == 0 || accepting1 > 0)
{
//oldms = get_fs(); set_fs(KERNEL_DS);
readvalue=sock_recvmsg(socketnumber2,sock_msg,size,0);
//set_fs(oldms);
if(readvalue < 0 )
{
printk(KERN_ERR "Reading stream message error");
sock_release((struct socket *)socketnumber2);
}
else if (readvalue == 0)
{
printk(KERN_INFO"Reading connection\n");
}
else
{
printk(KERN_INFO "MESSSAGE: %s",buffer);
}
sock_release((struct socket *)socketnumber2);
}
return 0;
}
