tcp sock kernel server and client

/*client.c*/  
#include<linux/in.h>  
#include<linux/inet.h>  
#include<linux/socket.h>  
#include<net/sock.h>  
#include<linux/module.h>  
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_irq.h>
#include <linux/delay.h>
#include <linux/tcp.h>
struct timer_test{
    unsigned char t;
    int len;
    struct timer_list     timer;    
    char *sendbuf;
    struct kvec vec;  
    struct msghdr msg;  
    struct socket *sock;
    
};
struct timer_test my_data;

static struct timeval tv = {0,2 * 100000};
int cnt ;
unsigned char *sendbuf[10]= {"mausb","retry","immediate","req","test","while","every","time-10","voer","~~~~~"};
static void mausb_retry_immediate_req(unsigned long _my_data)
{            
    int ret;
    int i;
    i = cnt % 10;
    struct timer_test *my_data = (struct timer_test *)_my_data;
    
     my_data->vec.iov_base=sendbuf[i];  
        my_data->vec.iov_len=strlen(sendbuf[i]);  
    kernel_setsockopt(my_data->sock, SOL_SOCKET, SO_SNDTIMEO,
            (char *)&tv, sizeof(tv));
    
    printk(KERN_ERR "seemood:my_data->sock->state=%d\n",my_data->sock->state);
        ret=kernel_sendmsg(my_data->sock,&my_data->msg,&my_data->vec,1,my_data->vec.iov_len);     
    printk(KERN_ERR "seemood:sendmsg ret =%d cnt=%d len=%d sendbuf[%d]=%s \n",ret,cnt,strlen(sendbuf[i]),i,sendbuf[i]);
        if(ret<0){  
               printk(KERN_ERR "client: kernel_sendmsg error!\n");  
              // return ret;  
        }
    cnt ++;
    
    mod_timer(&my_data->timer, jiffies + HZ/10);

}


static void init_msg(struct msghdr *msg)
{
    msg->msg_name = NULL;
    msg->msg_namelen = 0;
    msg->msg_control = NULL;
    msg->msg_controllen = 0;
    msg->msg_flags =0;
}

static void socket_keep_alive(struct socket *sockfd)
{
    int keep_alive = 1;
    int keep_idle = 5;
    int keep_interval = 2;
    int keep_count = 3;
    if(kernel_setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, (char *)&keep_alive,sizeof(keep_alive))!=0) {
        printk(KERN_ERR "Set SO_KEEPALIVE WRONG fail\n");
        return;
    }
    if(kernel_setsockopt(sockfd, SOL_TCP, TCP_KEEPIDLE, (char *)&keep_idle,sizeof(keep_idle))!=0) {
        printk(KERN_ERR "Set TCP_KEEPIDLE fail\n");
        return;
    }
    if(kernel_setsockopt(sockfd, SOL_TCP, TCP_KEEPINTVL, (char *)&keep_interval,sizeof(keep_interval))!=0){
        printk(KERN_ERR "Set TCP_KEEPIDLE fail\n");
        return;
    }
    if(kernel_setsockopt(sockfd, SOL_TCP, TCP_KEEPCNT, (char *)&keep_count,sizeof(keep_count))!=0) {
        printk(KERN_ERR "Set TCP_KEEPCNT fail\n");
        return;
    }
}

int myclient(void){  
        struct socket *sock;  
        struct sockaddr_in s_addr;  
        unsigned short portnum=0x8888;  
        int ret=0;  
      cnt = 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=in_aton("192.168.1.101"); /*server ip is 192.168.209.134*/  
        sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
      
        /*create a socket*/  
        ret=sock_create_kern(AF_INET, SOCK_STREAM,0,&sock);  
        if(ret<0){  
                printk("client:socket create error!\n");  
                return ret;  
        }  
        printk("client: socket create ok!\n");  
      
      int keep_alive = 1;
      int keep_idle = 5;
      int keep_interval = 2;
      int keep_count = 3;
      unsigned int timeout = 10000;
      
      kernel_setsockopt(sock,IPPROTO_TCP,TCP_USER_TIMEOUT,(char *)&timeout,sizeof(timeout));
      kernel_setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (char *)&keep_alive,sizeof(keep_alive));
      kernel_setsockopt(sock, SOL_TCP, TCP_KEEPIDLE, (char *)&keep_idle,sizeof(keep_idle));
      kernel_setsockopt(sock, SOL_TCP, TCP_KEEPINTVL, (char *)&keep_interval,sizeof(keep_interval));
      kernel_setsockopt(sock, SOL_TCP, TCP_KEEPCNT, (char *)&keep_count,sizeof(keep_count));
        /*connect server*/  
        ret=sock->ops->connect(sock,(struct sockaddr *)&s_addr, sizeof(s_addr),0);  
        if(ret !=0){  
                printk("client:connect error!\n");  
                return ret;  
        }  
        printk("client:connect ok!\n");  
 
        /*kmalloc sendbuf*/  
    init_msg(&my_data.msg);
      my_data. sock = sock;
      my_data.t = 0;
    my_data.timer.data = (unsigned long)&my_data;
    my_data.timer.function = &mausb_retry_immediate_req;
    my_data.timer.expires = jiffies + 5*HZ;
    init_timer(&my_data.timer);
    add_timer(&my_data.timer);
    char recvbuf[512] = {0};
#if 1
while(1){
    struct kvec vec;  
    struct msghdr msg;
    memset(&vec,0,sizeof(vec));
    memset(&msg,0,sizeof(msg));
    memset(recvbuf, 0,512);  


    vec.iov_base = recvbuf;  
    vec.iov_len=512;  
    //printk(KERN_ERR "seemood:===recv msg begin...\n");
    ret=kernel_recvmsg(sock,&msg,&vec,1,512, 0); /*receive message*/  
    printk(KERN_ERR "client:receive message:ret = %d recv=%s\n",ret,recvbuf);    

}

#endif
            return 0;  
    }  
      
    static int client_init(void){  
         //   printk("client:init\n");  
            return (myclient());  
    }  
      
    static void client_exit(void){  
            printk("client exit!\n");  
    }  
      
    module_init(client_init);  
    module_exit(client_exit);  
    MODULE_LICENSE("GPL");  


/*server.c*/  
#include<linux/in.h>  
#include<linux/inet.h>    
#include<linux/socket.h>  
#include<net/sock.h>  
 
#include<linux/init.h>    
#include<linux/module.h>  
unsigned char *sendbuf[10]= {"0000000000","1111111111","2222222222","3333333333","4444444444","5555555555","6666666666",
                "7777777777","8888888888","9999999999"};
 static void mausb_tcp_init_msg(struct msghdr *msg)
{
    msg->msg_name = NULL;
    msg->msg_namelen = 0;
    msg->msg_control = NULL;
    msg->msg_controllen = 0;
    msg->msg_flags = 0;
}
int myserver(void)
{  
      int ret=0;    
    struct socket *sock,*client_sock;  
    struct sockaddr_in s_addr;    
    unsigned short portnum=0x8888;    
    
    
    /*kmalloc a receive buffer*/  
    char *recvbuf=NULL;  
    recvbuf=kmalloc(512,GFP_KERNEL);  
    if(recvbuf==NULL){    
            printk("server: recvbuf kmalloc error!\n");  
            return -1;    
    }  

    /*receive message from client*/  
    
    struct msghdr msg;    
    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);  


    sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    client_sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  

    /*create a socket*/  
    //ret=sock_create_kern(AF_INET, SOCK_STREAM,0,&sock);  
    //if(ret){  
    //    printk("server:socket_create error!\n");  
    //}  
    ret = sock_create(PF_INET, SOCK_STREAM, IPPROTO_TCP,&sock);
    printk("server:socket_create ok!\n");  

    /*bind the socket*/  
    ret=kernel_bind(sock,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));  
    if(ret<0){    
            printk("server: bind error\n");  
            return ret;  
    }  
    ret = kernel_listen(sock,1);
    printk(KERN_ERR "seemood:kernel_listen ret =%d\n",ret);

    ret = kernel_accept(sock,&client_sock,0);
    printk(KERN_ERR "seemood:kernel_accept ret =%d\n",ret);

    mausb_tcp_init_msg(&msg);
while(1){
    static int cnt;
    int i;
    struct kvec vec;  
    memset(&vec,0,sizeof(vec));
    memset(recvbuf, 0,512);  

      
    vec.iov_base = recvbuf;  
    vec.iov_len=512;  
    //printk(KERN_ERR "seemood:===recv msg begin...\n");
    ret=kernel_recvmsg(client_sock,&msg,&vec,1,512, 0); /*receive message*/  
    printk(KERN_ERR "receive message:ret = %d recv=%s\n",ret,recvbuf);
    i = cnt % 10;
    vec.iov_base = sendbuf[i];
    vec.iov_len=strlen(sendbuf[i]);
    ret = kernel_sendmsg(client_sock,&msg,&vec,1,vec.iov_len);    
    printk(KERN_ERR "seemood server:send msg ret=%d,i=%d,sendbuf=%s\n",ret,i,sendbuf[i]);
    cnt ++;
}
  /*release socket*/    
        sock_release(sock);  
        sock_release(client_sock);
        return 0;  
}  
 
static int server_init(void){  
        printk("server init:\n");  
        return (myserver());  
}  
 
static void server_exit(void){    
        printk("good bye\n");  
}  
 
module_init(server_init);  
module_exit(server_exit);  
 
MODULE_LICENSE("GPL");