精华内容
下载资源
问答
  • Linux 内核Socket 编程

    千次阅读 2015-04-01 16:18:49
    Linux 内核态 Socket 编程 ...内核socket编程的过程和用户态下的socket编程流程一样,但是接口不同。Kernel提供了一组内核态的socket API,基本上在用户态的sockt API在内核中都有对应的API。 在net/
     

    Linux 内核态 Socket 编程

    分类: Socket 909人阅读 评论(0) 收藏 举报

    1.内核态 socket API

    内核态socket编程的过程和用户态下的socket编程流程一样,但是接口不同。Kernel提供了一组内核态的socket API,基本上在用户态的sockt API在内核中都有对应的API。 在net/socket.c中可以看到如下导出符号:

    1. EXPORT_SYMBOL(kernel_sendmsg);    
    2. EXPORT_SYMBOL(kernel_recvmsg);    
    3. EXPORT_SYMBOL(sock_create_kern);    
    4. EXPORT_SYMBOL(sock_release);    
    5. EXPORT_SYMBOL(kernel_bind);    
    6. EXPORT_SYMBOL(kernel_listen);    
    7. EXPORT_SYMBOL(kernel_accept);    
    8. EXPORT_SYMBOL(kernel_connect);    
    9. EXPORT_SYMBOL(kernel_getsockname);    
    10. EXPORT_SYMBOL(kernel_getpeername);    
    11. EXPORT_SYMBOL(kernel_getsockopt);    
    12. EXPORT_SYMBOL(kernel_setsockopt);    
    13. EXPORT_SYMBOL(kernel_sendpage);    
    14. EXPORT_SYMBOL(kernel_sock_ioctl);    
    15. EXPORT_SYMBOL(kernel_sock_shutdown);   

    下面以两个内核模块间利用socket进行通信为例来讲述内核态下socket编程。

    server内核模块功能是:建立套接字,绑定端口,监听端口,等待client的连接,并接收client发来的数据。

    client内核模块功能是:建立套接字,和server建立连接,并向server发送数据。

    2. server模块

    1. /*server.c*/  
    2. #include<linux/in.h>  
    3. #include<linux/inet.h>  
    4. #include<linux/socket.h>  
    5. #include<net/sock.h>  
    6.   
    7. #include<linux/init.h>  
    8. #include<linux/module.h>  
    9.   
    10. int myserver(void){  
    11.   
    12.         struct socket *sock,*client_sock;  
    13.         struct sockaddr_in s_addr;  
    14.         unsigned short portnum=0x8888;  
    15.         int ret=0;  
    16.   
    17.         memset(&s_addr,0,sizeof(s_addr));  
    18.         s_addr.sin_family=AF_INET;  
    19.         s_addr.sin_port=htons(portnum);  
    20.         s_addr.sin_addr.s_addr=htonl(INADDR_ANY);  
    21.   
    22.   
    23.         sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    24.         client_sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    25.   
    26.         /*create a socket*/  
    27.         ret=sock_create_kern(AF_INET, SOCK_STREAM,0,&sock);  
    28.         if(ret){  
    29.                 printk("server:socket_create error!\n");  
    30.         }  
    31.         printk("server:socket_create ok!\n");  
    32.   
    33.         /*bind the socket*/  
    34.         ret=sock->ops->bind(sock,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));  
    35.         if(ret<0){  
    36.                 printk("server: bind error\n");  
    37.                 return ret;  
    38.         }  
    39.         printk("server:bind ok!\n");  
    40.   
    41.         /*listen*/  
    42.         ret=sock->ops->listen(sock,10);  
    43.         if(ret<0){  
    44.                 printk("server: listen error\n");  
    45.                 return ret;  
    46.         }  
    47.         printk("server:listen ok!\n");  
    48.   
    49.         ret=sock->ops->accept(sock,client_sock,10);if(ret<0){  
    50.                 printk("server:accept error!\n");  
    51.                 return ret;  
    52.         }  
    53.   
    54.         printk("server: accept ok, Connection Established\n");  
    55.   
    56.         /*kmalloc a receive buffer*/  
    57.         char *recvbuf=NULL;  
    58.         recvbuf=kmalloc(1024,GFP_KERNEL);  
    59.         if(recvbuf==NULL){  
    60.                 printk("server: recvbuf kmalloc error!\n");  
    61.                 return -1;  
    62.         }  
    63.         memset(recvbuf, 0, sizeof(recvbuf));  
    64.   
    65.         /*receive message from client*/  
    66.         struct kvec vec;  
    67.         struct msghdr msg;  
    68.         memset(&vec,0,sizeof(vec));  
    69.         memset(&msg,0,sizeof(msg));  
    70.         vec.iov_base=recvbuf;  
    71.         vec.iov_len=1024;  
    72.         ret=kernel_recvmsg(client_sock,&msg,&vec,1,1024,0); /*receive message*/  
    73.         printk("receive message:\n %s\n",recvbuf);  
    74.           
    75.     /*release socket*/  
    76.     sock_release(sock);  
    77.         sock_release(client_sock);  
    78.         return ret;  
    79. }  
    80.   
    81. static int server_init(void){  
    82.         printk("server init:\n");  
    83.         return (myserver());  
    84. }  
    85.   
    86. static void server_exit(void){  
    87.         printk("good bye\n");  
    88. }  
    89.   
    90. module_init(server_init);  
    91. module_exit(server_exit);  
    92.   
    93. MODULE_LICENSE("GPL");  

    3.client模块

    1. /*client.c*/  
    2. #include<linux/in.h>  
    3. #include<linux/inet.h>  
    4. #include<linux/socket.h>  
    5. #include<net/sock.h>  
    6.   
    7. #include<linux/init.h>  
    8. #include<linux/module.h>  
    9.   
    10. int myclient(void){  
    11.         struct socket *sock;  
    12.         struct sockaddr_in s_addr;  
    13.         unsigned short portnum=0x8888;  
    14.         int ret=0;  
    15.   
    16.         memset(&s_addr,0,sizeof(s_addr));  
    17.         s_addr.sin_family=AF_INET;  
    18.         s_addr.sin_port=htons(portnum);  
    19.        
    20.         s_addr.sin_addr.s_addr=in_aton("192.168.209.134"); /*server ip is 192.168.209.134*/  
    21.         sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    22.   
    23.         /*create a socket*/  
    24.         ret=sock_create_kern(AF_INET, SOCK_STREAM,0,&sock);  
    25.         if(ret<0){  
    26.                 printk("client:socket create error!\n");  
    27.                 return ret;  
    28.         }  
    29.         printk("client: socket create ok!\n");  
    30.   
    31.         /*connect server*/  
    32.         ret=sock->ops->connect(sock,(struct sockaddr *)&s_addr, sizeof(s_addr),0);  
    33.         if(ret!=0){  
    34.                 printk("client:connect error!\n");  
    35.                 return ret;  
    36.         }  
    37.         printk("client:connect ok!\n");  
    38.   
    39.         /*kmalloc sendbuf*/  
    40.         char *sendbuf=NULL;  
    41.         sendbuf=kmalloc(1024,GFP_KERNEL);  
    42.         if(sendbuf==NULL){  
    43.                 printk("client: sendbuf kmalloc error!\n");  
    44.                 return -1;  
    45.         }  
    46.         memset(sendbuf,1,1024);          
    47.           
    48.     struct kvec vec;  
    49.         struct msghdr msg;  
    50.   
    51.         vec.iov_base=sendbuf;  
    52.         vec.iov_len=1024;  
    53.   
    54.         memset(&msg,0,sizeof(msg));  
    55.   
    56.         ret=kernel_sendmsg(sock,&msg,&vec,1,1024); /*send message */  
    57.         if(ret<0){  
    58.                 printk("client: kernel_sendmsg error!\n");  
    59.                 return ret;  
    60.         }else if(ret!=1024){  
    61.                 printk("client: ret!=1024");  
    62.         }  
    63.         printk("client:send ok!\n");  
    64.   
    65.         return ret;  
    66. }  
    67.   
    68. static int client_init(void){  
    69.         printk("client:init\n");  
    70.         return (myclient());  
    71. }  
    72.   
    73. static void client_exit(void){  
    74.         printk("client exit!\n");  
    75. }  
    76.   
    77. module_init(client_init);  
    78. module_exit(client_exit);  
    79. MODULE_LICENSE("GPL"); 
    展开全文
  • Linux 内核Socket TCP 编程

    千次阅读 2016-04-22 10:57:12
    c++ socket编程 c++ sock linux下socket c++  转自: http://blog.csdn.net/miaohongyu1/article/details/16986053 1.内核态 socket API 内核socket编程的过程和用户态下的socket编程流程一样,...


    1.内核态 socket API

    内核态socket编程的过程和用户态下的socket编程流程一样,但是接口不同。Kernel提供了一组内核态的socket API,基本上在用户态的sockt API在内核中都有对应的API。 在net/socket.c中可以看到如下导出符号:

    1. EXPORT_SYMBOL(kernel_sendmsg);    
    2. EXPORT_SYMBOL(kernel_recvmsg);    
    3. EXPORT_SYMBOL(sock_create_kern);    
    4. EXPORT_SYMBOL(sock_release);    
    5. EXPORT_SYMBOL(kernel_bind);    
    6. EXPORT_SYMBOL(kernel_listen);    
    7. EXPORT_SYMBOL(kernel_accept);    
    8. EXPORT_SYMBOL(kernel_connect);    
    9. EXPORT_SYMBOL(kernel_getsockname);    
    10. EXPORT_SYMBOL(kernel_getpeername);    
    11. EXPORT_SYMBOL(kernel_getsockopt);    
    12. EXPORT_SYMBOL(kernel_setsockopt);    
    13. EXPORT_SYMBOL(kernel_sendpage);    
    14. EXPORT_SYMBOL(kernel_sock_ioctl);    
    15. EXPORT_SYMBOL(kernel_sock_shutdown);   

    下面以两个内核模块间利用socket进行通信为例来讲述内核态下socket编程。

    server内核模块功能是:建立套接字,绑定端口,监听端口,等待client的连接,并接收client发来的数据。

    client内核模块功能是:建立套接字,和server建立连接,并向server发送数据。

    2. server模块

    1. /*server.c*/  
    2. #include<linux/in.h>  
    3. #include<linux/inet.h>  
    4. #include<linux/socket.h>  
    5. #include<net/sock.h>  
    6.   
    7. #include<linux/init.h>  
    8. #include<linux/module.h>  
    9.   
    10. int myserver(void){  
    11.   
    12.         struct socket *sock,*client_sock;  
    13.         struct sockaddr_in s_addr;  
    14.         unsigned short portnum=0x8888;  
    15.         int ret=0;  
    16.   
    17.         memset(&s_addr,0,sizeof(s_addr));  
    18.         s_addr.sin_family=AF_INET;  
    19.         s_addr.sin_port=htons(portnum);  
    20.         s_addr.sin_addr.s_addr=htonl(INADDR_ANY);  
    21.   
    22.   
    23.         sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    24.         client_sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    25.   
    26.         /*create a socket*/  
    27.         ret=sock_create_kern(AF_INET, SOCK_STREAM,0,&sock);  
    28.         if(ret){  
    29.                 printk("server:socket_create error!\n");  
    30.         }  
    31.         printk("server:socket_create ok!\n");  
    32.   
    33.         /*bind the socket*/  
    34.         ret=sock->ops->bind(sock,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));  
    35.         if(ret<0){  
    36.                 printk("server: bind error\n");  
    37.                 return ret;  
    38.         }  
    39.         printk("server:bind ok!\n");  
    40.   
    41.         /*listen*/  
    42.         ret=sock->ops->listen(sock,10);  
    43.         if(ret<0){  
    44.                 printk("server: listen error\n");  
    45.                 return ret;  
    46.         }  
    47.         printk("server:listen ok!\n");  
    48.   
    49.         ret=sock->ops->accept(sock,client_sock,10);if(ret<0){  
    50.                 printk("server:accept error!\n");  
    51.                 return ret;  
    52.         }  
    53.   
    54.         printk("server: accept ok, Connection Established\n");  
    55.   
    56.         /*kmalloc a receive buffer*/  
    57.         char *recvbuf=NULL;  
    58.         recvbuf=kmalloc(1024,GFP_KERNEL);  
    59.         if(recvbuf==NULL){  
    60.                 printk("server: recvbuf kmalloc error!\n");  
    61.                 return -1;  
    62.         }  
    63.         memset(recvbuf, 0, sizeof(recvbuf));  
    64.   
    65.         /*receive message from client*/  
    66.         struct kvec vec;  
    67.         struct msghdr msg;  
    68.         memset(&vec,0,sizeof(vec));  
    69.         memset(&msg,0,sizeof(msg));  
    70.         vec.iov_base=recvbuf;  
    71.         vec.iov_len=1024;  
    72.         ret=kernel_recvmsg(client_sock,&msg,&vec,1,1024,0); /*receive message*/  
    73.         printk("receive message:\n %s\n",recvbuf);  
    74.           
    75.     /*release socket*/  
    76.     sock_release(sock);  
    77.         sock_release(client_sock);  
    78.         return ret;  
    79. }  
    80.   
    81. static int server_init(void){  
    82.         printk("server init:\n");  
    83.         return (myserver());  
    84. }  
    85.   
    86. static void server_exit(void){  
    87.         printk("good bye\n");  
    88. }  
    89.   
    90. module_init(server_init);  
    91. module_exit(server_exit);  
    92.   
    93. MODULE_LICENSE("GPL");  

    3.client模块 

    1. /*client.c*/  
    2. #include<linux/in.h>  
    3. #include<linux/inet.h>  
    4. #include<linux/socket.h>  
    5. #include<net/sock.h>  
    6.   
    7. #include<linux/init.h>  
    8. #include<linux/module.h>  
    9.   
    10. int myclient(void){  
    11.         struct socket *sock;  
    12.         struct sockaddr_in s_addr;  
    13.         unsigned short portnum=0x8888;  
    14.         int ret=0;  
    15.   
    16.         memset(&s_addr,0,sizeof(s_addr));  
    17.         s_addr.sin_family=AF_INET;  
    18.         s_addr.sin_port=htons(portnum);  
    19.        
    20.         s_addr.sin_addr.s_addr=in_aton("192.168.209.134"); /*server ip is 192.168.209.134*/  
    21.         sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    22.   
    23.         /*create a socket*/  
    24.         ret=sock_create_kern(AF_INET, SOCK_STREAM,0,&sock);  
    25.         if(ret<0){  
    26.                 printk("client:socket create error!\n");  
    27.                 return ret;  
    28.         }  
    29.         printk("client: socket create ok!\n");  
    30.   
    31.         /*connect server*/  
    32.         ret=sock->ops->connect(sock,(struct sockaddr *)&s_addr, sizeof(s_addr),0);  
    33.         if(ret!=0){  
    34.                 printk("client:connect error!\n");  
    35.                 return ret;  
    36.         }  
    37.         printk("client:connect ok!\n");  
    38.   
    39.         /*kmalloc sendbuf*/  
    40.         char *sendbuf=NULL;  
    41.         sendbuf=kmalloc(1024,GFP_KERNEL);  
    42.         if(sendbuf==NULL){  
    43.                 printk("client: sendbuf kmalloc error!\n");  
    44.                 return -1;  
    45.         }  
    46.         memset(sendbuf,1,1024);          
    47.           
    48.     struct kvec vec;  
    49.         struct msghdr msg;  
    50.   
    51.         vec.iov_base=sendbuf;  
    52.         vec.iov_len=1024;  
    53.   
    54.         memset(&msg,0,sizeof(msg));  
    55.   
    56.         ret=kernel_sendmsg(sock,&msg,&vec,1,1024); /*send message */  
    57.         if(ret<0){  
    58.                 printk("client: kernel_sendmsg error!\n");  
    59.                 return ret;  
    60.         }else if(ret!=1024){  
    61.                 printk("client: ret!=1024");  
    62.         }  
    63.         printk("client:send ok!\n");  
    64.   
    65.         return ret;  
    66. }  
    67.   
    68. static int client_init(void){  
    69.         printk("client:init\n");  
    70.         return (myclient());  
    71. }  
    72.   
    73. static void client_exit(void){  
    74.         printk("client exit!\n");  
    75. }  
    76.   
    77. module_init(client_init);  
    78. module_exit(client_exit);  
    79. MODULE_LICENSE("GPL");  
    展开全文
  • Linux kernel下的内核socket编程

    千次阅读 2018-04-11 17:02:44
    内核4版本下测试通过,引用了高手的代码,做了修改,避免崩溃:...lt;linux/in.h&gt; #...

    内核4版本下测试通过,引用了高手的代码,做了修改,避免崩溃:

    https://www.linuxquestions.org/questions/blog/915086731-521769/implementation-of-server-client-socket-under-kernel-environment-37716/

    server:

    #include<linux/in.h>  
    #include<linux/inet.h>  
    #include<linux/socket.h>  
    #include<net/sock.h>  
      
    #include<linux/init.h>  
    #include<linux/module.h>  
    
    #define BUFFSIZE 1024
    
    void jiang_debug( void )
    {
        printk("just debug");
    }
    
    int myserver(void)
    {  
      
        struct socket *sock,*client_sock;  
        struct sockaddr_in s_addr;  
        unsigned short portnum=8888;  
        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=in_aton("192.168.0.70");  
    
    
        sock=(struct socket *)kmalloc(sizeof(struct socket),GFP_KERNEL);  
    
        /*create a socket*/  
        ret=sock_create_kern(&init_net, AF_INET,SOCK_STREAM, IPPROTO_TCP,&sock);  
        if(ret){  
                printk("server:socket_create error!\n");  
        }  
        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;  
        }  
        printk("server:bind ok!\n");  
    
        /*listen*/  
        ret=kernel_listen(sock,10);  
        if(ret<0){  
                printk("server: listen error\n");  
                return ret;  
        }  
        printk("server:listen ok!\n");  
    
        ret=kernel_accept(sock,&client_sock,10);
        if(ret<0){  
                printk("server:accept error!\n");  
                return ret;  
        }  
    
        printk("server: accept ok, Connection Established\n");  
    
        /*kmalloc a receive buffer*/  
        char *recvbuf=NULL;  
        recvbuf=kmalloc(1024,GFP_KERNEL);  
        if(recvbuf==NULL){  
                printk("server: recvbuf kmalloc error!\n");  
                return -1;  
        }  
        memset(recvbuf, 0, 1024);  
    
        /*receive message from client*/  
        struct kvec vec;  
        struct msghdr msg;  
        memset(&vec,0,sizeof(vec));  
        memset(&msg,0,sizeof(msg));  
        vec.iov_base=recvbuf;  
        vec.iov_len=1024;  
        msg.msg_flags=MSG_NOSIGNAL;
        msleep(1000);
        jiang_debug();
        ret=kernel_recvmsg(client_sock,&msg,&vec,1,1024, msg.msg_flags); /*receive message*/  
        recvbuf[1023] = 0;
        printk("receive message:\n %s\n",recvbuf);  
              
        /*release socket*/  
        printk("release socket now\n");
        sock_release(client_sock);  
        sock_release(sock);  
        return ret;  
    }  
      
    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");

    client:

    #include<linux/in.h>
    #include<linux/inet.h>
    #include<linux/socket.h>
    #include<net/sock.h>
    #include<linux/init.h>
    #include<linux/module.h>
    #define BUFFER_SIZE 1024
    int connect_send_recv(void){
        struct socket *sock;
        struct sockaddr_in s_addr;
        unsigned short port_num = 8888;
        int ret = 0;
        char *send_buf = NULL;
        char *recv_buf = NULL;
        struct kvec send_vec, recv_vec;
        struct msghdr send_msg, recv_msg;
        /* kmalloc a send buffer*/
        send_buf = kmalloc(BUFFER_SIZE, GFP_KERNEL);
        if (send_buf == NULL) {
            printk("client: send_buf kmalloc error!\n");
            return -1;
        }
        /* kmalloc a receive buffer*/
        recv_buf = kmalloc(BUFFER_SIZE, GFP_KERNEL);
        if(recv_buf == NULL){
            printk("client: recv_buf kmalloc error!\n");
            return -1;
        }
        memset(&s_addr, 0, sizeof(s_addr));
        s_addr.sin_family = AF_INET;
        s_addr.sin_port = htons(port_num);
        s_addr.sin_addr.s_addr = in_aton("192.168.0.71");
        sock = (struct socket *)kmalloc(sizeof(struct socket), GFP_KERNEL);
        // 创建一个sock, &init_net是默认网络命名空间
        ret = sock_create_kern(&init_net, AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
        if (ret < 0) {
            printk("client:socket create error!\n");
            return ret;
        }
        printk("client: socket create ok!\n");
        //连接
        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");
        memset(send_buf, 'a', BUFFER_SIZE);
        memset(&send_msg, 0, sizeof(send_msg));
        memset(&send_vec, 0, sizeof(send_vec));
        send_vec.iov_base = send_buf;
        send_vec.iov_len = BUFFER_SIZE;
        // 发送数据
        ret = kernel_sendmsg(sock, &send_msg, &send_vec, 1, BUFFER_SIZE);
        if (ret < 0) {
            printk("client: kernel_sendmsg error!\n");
            return ret;
        } else if(ret != BUFFER_SIZE){
            printk("client: ret!=BUFFER_SIZE");
        }
        printk("client: send ok!\n");
        memset(recv_buf, 0, BUFFER_SIZE);
        memset(&recv_vec, 0, sizeof(recv_vec));
        memset(&recv_msg, 0, sizeof(recv_msg));
        recv_vec.iov_base = recv_buf;
        recv_vec.iov_len = BUFFER_SIZE;
        // 接收数据
        ret = kernel_recvmsg(sock, &recv_msg, &recv_vec, 1, BUFFER_SIZE, 0);
        printk("client: received message:\n %s\n", recv_buf);
        // 关闭连接
        kernel_sock_shutdown(sock, SHUT_RDWR);
        sock_release(sock);
        return 0;
    }
    static int client_example_init(void){
        printk("client: init\n");
        return connect_send_recv();
    }
    static void client_example_exit(void){
        printk("client: exit!\n");
    }
    module_init(client_example_init);
    module_exit(client_example_exit);
    MODULE_LICENSE("GPL");


    Please pay attentation, you must call kernel_accept instead of sock->ops->accept. Or you will get into kernel panic.


    展开全文
  • Linux 内核Socket 编程--更正

    千次阅读 2014-02-20 17:02:31
    Server端代码: #include #include #include #include #include #include ... struct socket *sock,*client_sock; struct sockaddr_in s_addr; unsigned short portnum=0x8870; int ret=0; m

    Server端代码:

    #include<linux/in.h>
    #include<linux/inet.h>
    #include<linux/socket.h>
    #include<net/sock.h>
    
    #include<linux/init.h>
    #include<linux/module.h>
    
    int myserver(void){
    	
    	struct socket *sock,*client_sock;
    	struct sockaddr_in s_addr;
    	unsigned short portnum=0x8870;
    	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);
    
    
    	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");
    	}
    	printk("server:socket_create ok!\n");
    
        /*set the socket can be reused*/
        int val=1;
        ret= kernel_setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val));
        if(ret){
            printk("kernel_setsockopt error!!!!!!!!!!!\n");
        }
    
    	/*bind the socket*/
    	ret=sock->ops->bind(sock,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));
    	if(ret<0){
    		printk("server: bind error\n");
    		return ret;
    	}
    	printk("server:bind ok!\n");
    
    	/*listen*/
    	ret=sock->ops->listen(sock,10);
    	if(ret<0){
    		printk("server: listen error\n");
    		return ret;
    	}
    	printk("server:listen ok!\n");
    
    	//ret=sock->ops->accept(sock,client_sock,10);
        ret = kernel_accept(sock,&client_sock,10);
    	if(ret<0){
    		printk("server:accept error!\n");
    		return ret;
    	}
    	
    	printk("server: accept ok, Connection Established\n");
    	
    	/*kmalloc a receive buffer*/
     	char *recvbuf=NULL;
    	recvbuf=kmalloc(1024,GFP_KERNEL);
    	if(recvbuf==NULL){
    		printk("server: recvbuf kmalloc error!\n");
    		return -1;
    	}
    	memset(recvbuf, 0, sizeof(recvbuf));
    	
    	/*receive message from client*/
    	struct kvec vec;
    	struct msghdr msg;
    	memset(&vec,0,sizeof(vec));
    	memset(&msg,0,sizeof(msg));
    	vec.iov_base=recvbuf;
    	vec.iov_len=1024;
    	ret=kernel_recvmsg(client_sock,&msg,&vec,1,1024,0);
    	printk("receive message:\n %s\n",recvbuf);
        printk("receive size=%d\n",ret);
    
        sock_release(sock);
        sock_release(client_sock);
    	return ret;
    }
    
    static int server_init(void){
    	printk("server init:\n");
        myserver();
        return 0;
    }		
    
    static void server_exit(void){
    	printk("good bye\n");
    }
    
    module_init(server_init);
    module_exit(server_exit);
    
    MODULE_LICENSE("GPL");
    

    client端代码:

    #include<linux/in.h>
    #include<linux/inet.h>
    #include<linux/socket.h>
    #include<net/sock.h>
    
    #include<linux/init.h>
    #include<linux/module.h>
    
    int myclient(void){
    	struct socket *sock;
    	struct sockaddr_in s_addr;
        unsigned short portnum=0x8870;
    	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=inet_addr("127.0.0.1"); /*I am not sure whether the ined_addr is right, may should be htonl*/
    	s_addr.sin_addr.s_addr=in_aton("127.0.0.1");
    	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");
    
    	/*conncet 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*/
    	char *sendbuf="client messsage!";
        int len=sizeof("client message!");
    	
        /*send message */
    	struct kvec vec;
    	struct msghdr msg;
    	
    	vec.iov_base=sendbuf;
    	vec.iov_len=len;
    	memset(&msg,0,sizeof(msg));
        
    	ret= kernel_sendmsg(sock,&msg,&vec,1,len);
        if(ret<0){
    		printk("client: kernel_sendmsg error!\n");
    		return ret;	
    	}else if(ret!=len){
    		printk("client: ret!=len\n");
    	}
        printk("client send size=%d\n",ret);
    	printk("client:send ok!\n");
    
        sock_release(sock);
        return ret;
    }
    
    static int client_init(void){
    	printk("client:init\n");
    	myclient();
        return 0;
    }
    
    static void client_exit(void){
    	printk("client exit!\n");
    }
    
    module_init(client_init);
    module_exit(client_exit);
    MODULE_LICENSE("GPL");
    


    展开全文
  • linuxsocket编程

    2021-02-01 03:03:09
    文章目录1. socket是什么?2. socket怎么用? 1. socket是什么?   我们知道计算机网络通信需要用到TCP/IP协议...再说明白一点,在程序中调用socket函数的时候,Linux内核会根据你的选用参数自动帮你封装你将要发送的
  • linuxsocket编程

    2017-09-06 00:42:32
    socket就是linux中提供的用于网络通信的文件接口, 两台机器之间可以读写消息 在使用socket真正的通信之前, 需要先建立连接, 连接的建立根据协议的不同, 建立的过程也不一样, 目前支持tcp, udp 协议, 通过raw socket,...
  • 嵌入式linux TCP socket编程

    千次阅读 2017-03-08 17:19:05
    一、利用内核编程的API sendto 和 recvfrom sendto()_Linux C函数 sendto(经socket传送数据) 相关函数  send , sendmsg,recv , recvfrom , socket 表头文件  #include  #include 定义函数  int ...
  • linuxsocket编程和epoll的使用

    千次阅读 2017-02-19 23:32:27
    首先介绍socket,socket编程我之前也接触过,不过是在windows下接触的。和windows不同的是,windows下关于socket编程,是直接给你一个socket的类,在上面建立自己的实例。而在linux中,你在建立socket时,它会给你...
  • LinuxSocket编程基础

    2017-10-09 17:02:00
    Linux作为一个完全开放其原代码的免费的自由软件,兼容了各种UNIX标准(如POSIX、UNIXSystemV和BSDUNIX等)的多用户、多任务的具有复杂内核的操作系统。在中国,随着Internet的普及,一批主要以高等院校的学生和ISP...
  • Linux socket编程

    2019-07-11 18:23:27
    socket套接字(口) 套接口可以说是网络编程中一个非常重要的概念,linux以...换句话说,对每一个新创建的socket套接口,linux内核都将在sockfs特殊文件系统中创建一个新的inode。描述套接口的数据结构是socket。 ...
  • Linuxsocket编程:网络基础中有讲解socket的用法。这里就不重复了。TCP/IP中,层与层之间是相互独立的,在Linux中可以直接通过设置不同的socket参数来实现各个层的数据读取以及操作。 数据链路层访问 在Linux下...
  • 现在大多数计算机网络都是根据TCP/IP协议栈搭建起来的,为了具体实现TCP/IP协议栈,Linux操作系统就对外提供了一套可供程序员做网络开发所用的操作接口,这就是Socket编程接口,这就是用来进行Linux网络编程项目开发...
  • Socket编程基础知识 套接字概念 Socket本身有“插座”的意思,在Linux环境下,用于表示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。 既然是文件,那么理所当然的,我们可以使用文件描述符引用...
  • 1、概述 timerfd是Linux为用户程序提供的一个...timerfd是linux内核2.6.25版本中加入的借口。 timerfd、eventfd、signalfd配合epoll使用,可以构造出一个零轮询的程序,但程序没有处理的事件时,程序是被阻塞的...
  • Linux作为一个完全开放其原代码的免费的自由软件,兼容了各种UNIX标准(如POSIX、UNIX System V 和 BSD UNIX 等)的多用户、多任务的具有复杂内核的操作系统。在中国,随着Internet的普及,一批主要以高等院校...
  • linux socket编程

    2017-03-09 09:30:19
    Linux作为一个完全开放其原代码的免费的自由软件,兼容了各种UNIX标准(如POSIX、UNIX System V 和 BSD UNIX 等)的多用户、多任务的具有复杂内核的操作系统。在中国,随着Internet的普及,一批主要以高等院校...
  • LInuxSocket网络编程

    2020-11-27 17:11:52
    都是基于linux内核,在一个linux服务器中的通信, 缺陷:无法多机通信,多机—linux和安卓、ios手机的通信 多机通信要用到地址:IP地址、端口号 一台机器要找到另外一台机器,需要的就是IP地址 在一台机器上可能有很...
  • linux内核socket编程如何实现:(以tcp服务端举例) 1、sock_create_kern() 2、kernel_setsockopt()这一步为可去掉的,但是如果想socket进行配置,则需要此步骤,例如配置成非阻塞模式: struct tim...
  • 经过这段时间,我的感悟是:数据结构,数据结构,数据结构——重要的事情要强调三次。...Linux虽然是C写的,而C不是面向对象的语言,但是内核却是用C和面向对象的思想写出来的——感觉矛盾?没关系,先有个印象
  • 1.socket 是用户进程与内核网络协议栈的编程接口;可用于本机进程间通信也可以用于网络上不同主机进程间通信。 软硬件平台均可不同。  也可在不同的体系结构中,即异构。例如,手机QQ(ARM)与PC端QQ(Intel x86)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 768
精华内容 307
关键字:

linux内核socket编程

linux 订阅