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; }