static int make_server_socket (void)
{
int ret;
struct sockaddr_in sin;
ret = sock_create (AF_INET, SOCK_STREAM, 0, &sock);
if (ret)
goto err;
sin.sin_family = AF_INET;
sin.sin_port = htons (PORT);
sin.sin_addr.s_addr = 0;
ret = kernel_bind (sock, (struct sockaddr*)&sin, sizeof (sin));
if (ret)
goto err;
ret = kernel_listen (sock, 1024);
if (ret)
goto err;
schedule_work (&sock_accept);
return 0;
err:
if (sock)
sock_release (sock);
return ret;
}
static int make_server_socket (void)
{
int res;
struct sockaddr_in sin;
res = sock_create (AF_INET, SOCK_STREAM, 0, &sock);
if (res < 0)
goto err;
sin.sin_family = AF_INET;
sin.sin_port = htons (PORT);
sin.sin_addr.s_addr = 0;
res = kernel_bind (sock, (struct sockaddr*)&sin, sizeof (sin));
if (res)
goto err;
res = kernel_listen (sock, 256);
if (res)
goto err;
return 0;
err:
if (sock)
sock_release (sock);
return res;
}
/*
* open an RxRPC socket and bind it to be a server for callback notifications
* - the socket is left in blocking mode and non-blocking ops use MSG_DONTWAIT
*/
int afs_open_socket(struct afs_net *net)
{
struct sockaddr_rxrpc srx;
struct socket *socket;
unsigned int min_level;
int ret;
_enter("");
ret = sock_create_kern(net->net, AF_RXRPC, SOCK_DGRAM, PF_INET6, &socket);
if (ret < 0)
goto error_1;
socket->sk->sk_allocation = GFP_NOFS;
/* bind the callback manager's address to make this a server socket */
memset(&srx, 0, sizeof(srx));
srx.srx_family = AF_RXRPC;
srx.srx_service = CM_SERVICE;
srx.transport_type = SOCK_DGRAM;
srx.transport_len = sizeof(srx.transport.sin6);
srx.transport.sin6.sin6_family = AF_INET6;
srx.transport.sin6.sin6_port = htons(AFS_CM_PORT);
min_level = RXRPC_SECURITY_ENCRYPT;
ret = kernel_setsockopt(socket, SOL_RXRPC, RXRPC_MIN_SECURITY_LEVEL,
(void *)&min_level, sizeof(min_level));
if (ret < 0)
goto error_2;
ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx));
if (ret == -EADDRINUSE) {
srx.transport.sin6.sin6_port = 0;
ret = kernel_bind(socket, (struct sockaddr *) &srx, sizeof(srx));
}
if (ret < 0)
goto error_2;
rxrpc_kernel_new_call_notification(socket, afs_rx_new_call,
afs_rx_discard_new_call);
ret = kernel_listen(socket, INT_MAX);
if (ret < 0)
goto error_2;
net->socket = socket;
afs_charge_preallocation(&net->charge_preallocation_work);
_leave(" = 0");
return 0;
error_2:
sock_release(socket);
error_1:
_leave(" = %d", ret);
return ret;
}
int listen(SOCKET socket_p, int backlog)
{
int rc;
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 10)
rc = kernel_listen(socket_p, backlog);
#else
rc = -1;
#endif
return rc;
}
int app_glue_v4_listen(struct socket *sock)
{
if(sock->sk) {
sock->sk->sk_state_change = app_glue_sock_wakeup;
}
else {
syslog(LOG_CRIT,"FATAL %s %d\n",__FILE__,__LINE__);exit(0);
}
if(kernel_listen(sock,32000)) {
syslog(LOG_ERR,"cannot listen %s %d\n",__FILE__,__LINE__);
return -1;
}
return 0;
}
int
lnet_sock_listen(struct socket **sockp, __u32 local_ip, int local_port,
int backlog)
{
int fatal;
int rc;
rc = lnet_sock_create(sockp, &fatal, local_ip, local_port);
if (rc) {
if (!fatal)
CERROR("Can't create socket: port %d already in use\n",
local_port);
return rc;
}
rc = kernel_listen(*sockp, backlog);
if (!rc)
return 0;
CERROR("Can't set listen backlog %d: %d\n", backlog, rc);
sock_release(*sockp);
return rc;
}
/*
* close the RxRPC socket AFS was using
*/
void afs_close_socket(struct afs_net *net)
{
_enter("");
kernel_listen(net->socket, 0);
flush_workqueue(afs_async_calls);
if (net->spare_incoming_call) {
afs_put_call(net->spare_incoming_call);
net->spare_incoming_call = NULL;
}
_debug("outstanding %u", atomic_read(&net->nr_outstanding_calls));
wait_var_event(&net->nr_outstanding_calls,
!atomic_read(&net->nr_outstanding_calls));
_debug("no outstanding calls");
kernel_sock_shutdown(net->socket, SHUT_RDWR);
flush_workqueue(afs_async_calls);
sock_release(net->socket);
_debug("dework");
_leave("");
}
int mempool_listen_thread(void *data)
{
int ret = KERERR_SUCCESS;
struct mempool_dev *dev = (struct mempool_dev *)data;
struct socket *cli_sock = NULL, *data_sock = NULL;
struct client_host *clihost = NULL;
int sockaddrlen = sizeof(struct sockaddr);
if(!dev) {
goto null_ptr_error;
}
//init mempool listen socket
ret = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &(dev->listen_sock));
if (ret < 0) {
KER_DEBUG(KERN_ALERT "mempool listen thread: TCP create listen sock err, err=%d\n", ret);
goto create_error;
}
dev->listen_sock->sk->sk_reuse = 1;
ret = sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &(dev->data_listen_sock));
if (ret < 0) {
KER_DEBUG(KERN_ALERT "mempool listen thread: TCP create listen sock err, err=%d\n", ret);
goto create_data_error;
}
dev->data_listen_sock->sk->sk_reuse = 1;
//bind to interwork interface
ret = bind_to_device(dev->listen_sock, MEMPOOL_IF_NAME, SERHOST_LISTEN_PORT);
if (ret < 0) {
KER_DEBUG(KERN_ALERT "mempool listen thread: Bind to %s err, err=%d\n", MEMPOOL_IF_NAME, ret);
goto bind_error;
}
ret = bind_to_device(dev->data_listen_sock, MEMPOOL_IF_NAME, DATA_PORT);
if (ret < 0) {
KER_DEBUG(KERN_ALERT "mempool listen thread: Bind to %s err, err=%d\n", MEMPOOL_IF_NAME, ret);
goto bind_data_error;
}
//begin listen
ret = kernel_listen(dev->listen_sock, LISTEM_MAX_QUEUE);
if (ret < 0) {
KER_DEBUG(KERN_ALERT "mempool thread: sock listen err, err=%d\n", ret);
goto listen_error;
}
ret = kernel_listen(dev->data_listen_sock, LISTEM_MAX_QUEUE);
if (ret < 0) {
KER_DEBUG(KERN_ALERT "mempool thread: sock listen err, err=%d\n", ret);
goto listen_data_error;
}
//accept loop
while(!kthread_should_stop()) {
schedule_timeout_interruptible(LISTEN_SCHEDULE_TIME * HZ);
if(!dev->listen_sock) {
continue;
}
clihost = NULL;
cli_sock = NULL;
data_sock = NULL;
ret = kernel_accept(dev->listen_sock, &cli_sock, O_NONBLOCK);
if (ret < 0) {
//KER_DEBUG(KERN_ALERT "mempool thread: sock accept err, err=%d\n", ret);
continue;
}
schedule_timeout_interruptible(LISTEN_SCHEDULE_TIME * HZ);
ret = kernel_accept(dev->data_listen_sock, &data_sock, O_NONBLOCK);
if (ret < 0) {
//KER_DEBUG(KERN_ALERT "mempool thread: sock accept err, err=%d\n", ret);
continue;
}
//create client host structure
clihost = (struct client_host *)kmem_cache_alloc(dev->slab_client_host, GFP_USER);
memset(clihost, 0, sizeof(struct client_host));
if(!clihost) {
KER_DEBUG(KERN_ALERT "mempool thread: create clihost err");
continue;
}
clihost->sock = cli_sock;
clihost->datasock = data_sock;
clihost->state = CLIHOST_STATE_CONNECTED;
kernel_getpeername(cli_sock, (struct sockaddr *)&clihost->host_addr, &sockaddrlen);
kernel_getpeername(data_sock, (struct sockaddr *)&clihost->host_data_addr, &sockaddrlen);
//init client host, slab, list_head
mutex_init(&clihost->ptr_mutex);
//add to list
mutex_lock(&dev->lshd_rent_client_mutex);
list_add_tail(&clihost->ls_rent, &dev->lshd_rent_client);
mutex_unlock(&dev->lshd_rent_client_mutex);
//create recive thread for client
clihost->CliHandleThread = kthread_run(CliRecvThread, clihost, "Client Recive thread");
if (IS_ERR(clihost->CliHandleThread)) {
KER_DEBUG(KERN_ALERT "create recvmsg thread err, err=%ld\n",
PTR_ERR(clihost->CliHandleThread));
continue;
}
}
while(!kthread_should_stop()) {
schedule_timeout_interruptible(SCHEDULE_TIME * HZ);
}
return 0;
listen_data_error:
listen_error:
bind_data_error:
bind_error:
if(dev->data_listen_sock) {
sock_release(dev->data_listen_sock);
}
create_data_error:
if(dev->listen_sock) {
sock_release(dev->listen_sock);
}
create_error:
null_ptr_error:
while(!kthread_should_stop()) {
schedule_timeout_interruptible(SCHEDULE_TIME * HZ);
}
return -1;
}
int init_server(void *conf)
{
int ret=0;
int flags=1;
sock_entry_t *se;
struct linger ling= {0,0};
//create workqueue
if(!wq) {
wq=create_singlethread_workqueue("kkvserver");
if(!wq) {
#ifdef DEBUG_KKV_NETWORK
printk("create_workqueue() failed in server_init()\n");
#endif
return -ENOMEM;
}
}
if(!svr) {
svr=kmalloc(sizeof(kkv_server),GFP_KERNEL);
INIT_WORK(&svr->work,server_work);
}
//create socket
se=(sock_entry_t *)conf;
ret=sock_create_kern(se->family,se->type,se->protocol,&svr->socket);
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("sock_create_kern() failed=%d, family=%d, type=%d, protocol=%d\n",
ret,se->family,se->type,se->protocol);
#endif
goto out0;
}
set_server_sock_callbacks(svr->socket,svr);
ret=kernel_setsockopt(svr->socket,SOL_SOCKET,SO_REUSEADDR,(char*)&flags,sizeof(flags));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,SOL_SOCKET,SO_REUSEADDR);
#endif
goto out1;
}
ret=kernel_setsockopt(svr->socket,SOL_SOCKET,SO_KEEPALIVE,(char*)&flags,sizeof(flags));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,SOL_SOCKET,SO_KEEPALIVE);
#endif
goto out1;
}
ret=kernel_setsockopt(svr->socket,SOL_SOCKET,SO_LINGER,(char*)&ling,sizeof(ling));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,SOL_SOCKET,SO_LINGER);
#endif
goto out1;
}
ret=kernel_setsockopt(svr->socket,SOL_TCP,TCP_NODELAY,(char*)&flags,sizeof(flags));
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_setsockopt() failed=%d, level=%d, name=%d\n",ret,IPPROTO_TCP,TCP_NODELAY);
#endif
goto out1;
}
ret=kernel_bind(svr->socket,(struct sockaddr*)se->addr,se->addrlen);
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_bind() failed=%d\n",ret);
#endif
goto out1;
}
ret=kernel_listen(svr->socket,1024);
if(ret<0) {
#ifdef DEBUG_KKV_NETWORK
printk("kernel_listen() failed=%d\n",ret);
#endif
goto out1;
}
return 0;
out1:
sock_release(svr->socket);
out0:
svr->socket=NULL;
return ret;
}
static int threadfn(void *data)
{
struct socket *sock;
struct sockaddr_in addr;
int size,i;
char buf[bufsize+1];
if (sock_create_kern(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock) < 0) {
err("sock_create_kern");
goto out;
}
sock->sk->sk_reuse = 1;
memset(&addr, '\0', sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons(9734);
if (kernel_bind(sock, &addr, sizeof(addr)) < 0) {
err("kernel_bind");
goto err;
}
if (kernel_listen(sock, 1024) < 0) {
err("kernel_listen");
goto err;
}
while (!kthread_should_stop()) {
struct socket *newsock;
struct inet_connection_sock *icsk = inet_csk(sock->sk);
struct socket_wq *wq;
rcu_read_lock();
wq = rcu_dereference(sock->sk->sk_wq);
wait_event_interruptible(wq->wait,!reqsk_queue_empty(&icsk->icsk_accept_queue) || kthread_should_stop());
if (!reqsk_queue_empty(&icsk->icsk_accept_queue)) {
if (kernel_accept(sock, &newsock, MSG_WAITALL) != 0) {
err("kernel_accept");
goto err;
}
printk(KERN_INFO "Server : accept a new connection request.\n");
// transfer_data(newsock);
memset(&buf, 0, bufsize+1);
size = receive(newsock, buf, bufsize/2);
printk(KERN_INFO "Server : received %d bytes\n", size);
//data processing
printk("Server : received data: %s\n", buf);
size = receive(newsock, buf, bufsize/2);
if (size < 0)
{
printk(KERN_INFO ": error getting datagram, sock_recvmsg error = %d\n", size);
break;
}
else
{
printk(KERN_INFO "Server : received %d bytes\n", size);
//data processing
printk("Server : received data: %s\n", buf);
for( i=0;i<bufsize/2;i++)
{
buf[i]+=1;
}
buf[i]=0 ;
// sending
//printk("buf=%s\n",buf);
size=send(newsock, buf, bufsize/2+1);
if(size<0)
printk("Server : error send\n");
}
//printk("ch =%c\n",ch);
sock_release(newsock);
}
}
err:
sock_release(sock);
out:
return 0;
}
int vdev_socket_task(void*data) {
struct sockaddr_in s_addr;
unsigned short portnum=8891;
int ret=0;
memset(&s_addr,0,sizeof(s_addr));
s_addr.sin_family=AF_INET;
s_addr.sin_port=htons(portnum);
s_addr.sin_addr.s_addr=htonl(INADDR_ANY);
/*create a socket*/
ret=sock_create_kern(AF_INET, SOCK_STREAM, 0, &server_sock);
if(ret) {
printk("vdev server:socket_create error = %d\n",ret);
return -1;
}
printk("vdev server: socket_create ok!\n");
/*bind the socket*/
ret=kernel_bind(server_sock, (struct sockaddr *)&s_addr, sizeof(s_addr));
if (ret < 0) {
printk("vdev server: bind error = %d\n",ret);
sock_release(server_sock);
return -1;
}
printk("vdev server: bind ok!\n");
/*listen*/
ret=kernel_listen(server_sock, 5);
if(ret < 0) {
printk("vdev server: listen error = %d\n",ret);
sock_release(server_sock);
return -1;
}
printk("vdev server: listen ok!\n");
/*accept*/
for(;;)
{
ret=kernel_accept(server_sock, &client_sock, 0);
if (ret<0) {
printk("vdev server: accept error = %d\n",ret);
sock_release(server_sock);
return -1;
}
printk("vdev server: accept ok!\n");
/*receive message from client*/
for(;;)
{
char cmd=-1;
ret = vdev_socket_recv(&cmd, 1);
if(ret < 0) {
printk("vdev socket recv error\n");
break;
}
ret = process_framework_event(cmd);
if(ret < 0) {
printk("vdev socket process error\n");
break;
}
}//for
}
}
