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

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

    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 编程

    千次阅读 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
    标签: linux c++ socket编程 c++ sock linux下socket c++  转自: ... ...内核态socket编程的过程和用户态下的socket编程流程一样,但是接口不同。Kernel提供了一组


    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");  
    展开全文
  • 关于4.x内核的内核态socket编程问题(sock_create_kern) tags : linux socket linux内核态socket编程如何实现:(以tcp服务端举例) 1、sock_create_kern() 2、kernel_setsockopt()这一步为可去掉的,...

    关于4.x内核的内核态socket编程问题(sock_create_kern)

    tags : linux socket


    linux内核态socket编程如何实现:(以tcp服务端举例)

    1、sock_create_kern()
    2、kernel_setsockopt()这一步为可去掉的,但是如果想socket进行配置,则需要此步骤,例如配置成非阻塞模式:

    struct timeval tv;
    
    tv.tv_sec = 0;
    tv.tv_usec = 1000 * RECV_WATI_TIME_MS;
    kernel_setsockopt(sock_srv, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));

    3、kernel_bind()
    4、kernel_listen()
    5、kernel_accept()
    6、kernel_sendmsg()/kernel_recvmsg()
    7、sock_release()

    其他的也都类似,这里不记录了。

    关于不同版本的linux对于sock_create_kern函数的定义

    linux2.x的版本

    int sock_create_kern(int family, int type, int protocol, struct socket **res)
    {
        return __sock_create(family, type, protocol, res, 1);
    }

    linux3.x的版本:

    int sock_create_kern(int family, int type, int protocol, struct socket **res)
    {
        return __sock_create(&init_net, family, type, protocol, res, 1);
    }

    linux4.x的版本

    int sock_create_kern(struct net *net, int family, int type, int protocol, struct socket **res)
    {
        return __sock_create(net, family, type, protocol, res, 1);
    }

    所以,这里在4.x版本里面创建socket的话,最简单的方式是这样调用:

    sock_create_kern(&init_net, family, type, protocol, res);

    还有一个create socket的函数不要用!!!

    int sock_create(int family, int type, int protocol, struct socket **res)
    {
        return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
    }

    如果用这个函数创建socket,可以成功的bind、listen、accept,但是一到sendmesg、recvmesg就会出现permission denied。

    先在这里插个眼,今后有空的时候再来研究下struct net *net相关的内容,把原因补上。

    展开全文
  • 内核态socket编程

    千次阅读 2015-04-01 17:12:10
    内核态socket编程 分类: 嵌入式开发2013-06-17 15:32 794人阅读 评论(0) 收藏 举报 记不清从哪个kernel版本开始,内核态就不能直接使用系统调用了。当然,socket的系统调用也不能用了。不过好在kernel...
  • 内核态 Socket UDP编程

    千次阅读 2017-04-18 17:24:56
    不过好在kernel提供了一组内核态socket API。在net/socket.c文件中,可以看到这么几个导出符号: [cpp] view plaincopyprint? EXPORT_SYMBOL(kernel_sendmsg);  EXP
  • 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
  • 内核态socket编程

    千次阅读 2013-06-17 15:32:58
    记不清从哪个kernel...不过好在kernel提供了一组内核态socket API。在net/socket.c文件中,可以看到这么几个导出符号: EXPORT_SYMBOL(kernel_sendmsg); EXPORT_SYMBOL(kernel_recvmsg); EXPORT_SYMBOL(sock_crea
  • linux socket实现内核态和用户态通信

    千次阅读 2017-03-05 23:51:37
    linux sockey实现内核态和用户态通信
  • netlink socket 用户态和内核态的通信

    万次阅读 2012-06-26 17:04:05
    原文地址:... Why and How to Use Netlink Socket 作者:Kevin He,2005-01-05 原文地址:http://www.linuxjournal.com/article/7356   译者:Love. Katherine,2007-
  • socket函数是任何套接口网络编程中第一个使用的函数,它向用户提供一个套接字,即套接口描述文件字,它是一个整数,如同文件描述符一样,是内核标识一个IO结构的索引。通过socket函数,我们指定一个套接口的协议相关...
  • vold进程: 1.管理和控制Android平台外部存储设备...Netlink是一种在内核与用户应用间进行双向数据传输的非常好的方式,用户态应用使用标准的socketAPI就可以使用netlink提供的强大功能,内核态需要使用专门的内核A...
  • 1、系统调用 -- 最常用的方式,一般是用户态通过系统调用函数访问内核态空间 2、netlink -- 本质上是socket,可以用于内核与多种用户进程之间的消息传递系统 3、procfs(/proc/)-- 在该目录下,有各种内核和进程...
  • 0、前言 由于开发需要,用户态要时刻监视内核态状态,以便检测上层应用知道磁盘...比如系统调用,ioctl接口,proc文件系统以及netlink socket来获取内核态状态信息。本文主要是netlink socket有关知识。 1、net...
  • 内核态filter支持

    2021-01-03 17:05:50
    所有包都要从内核态传到用户态,影响性能。可以考虑加上bpf filter.这个我测试过,openwrt和桌面linux都是支持的。 代码如下: <pre><code> struct sock_filter code_tcp[] = { { 0x5, 0, 0, ...
  • 三天的努力,终于搞定了自己需要的这种通信机制:由内核态向用户态反馈信息;先看代码,内核的:#include #include #include #include #include #include #include //it include linux/netlink.h#define NETLINK_...
  • 如题,内核态程序能并行执行吗?比如同时写多个io或者socket? 它是怎样工作的 相关的博文推荐下呗? 谢谢!!!
  • Linux用户态和内核态通信方法--netlink

    千次阅读 2019-06-18 10:38:00
    netlink 是 Linux 用户态与内核态通信最常用的一种方式。 netlink:netlink socekt是一种用于在内核态和用户态进程之间进行数据传输的特殊的IPC。它通过为内核模块提供一组特殊的API,并为用户程序提供了一组标准的...
  • 通讯方式:procfs/socket/syscall/IOCTL常用的是socket/syscall/ioctl.ioctl机制,ioctl机制可以在驱动中扩展特定的ioctl消息,用于将一些状态从内核反应到用户。Ioctl有很好的数据同步保护机制,不要担心内核和...
  • 内核态编程指南 https://blog.csdn.net/yeshennet/article/details/82315604 内核态程序开发 内核态开发和用户态开发有很多相似之处,也有些不同之处。 相同之处 都要进行设计、开发、调试和优化的过程。 业务的开发...
  • Linux用户态和内核态之间的交互

    千次阅读 2012-05-18 16:43:14
    Linux用户态和内核态之间的交互: 读书笔记:  原文:《在 Linux 下用户空间与内核空间数据交换的方式》  链接:http://www.ibm.com/developerworks/cn/linux/l-kerns-usrs/  Netlink 是一种在内核与用户应用...
  • 使用Netlink通过自定义一种新的协议并加入协议族即可通过socket API使用Netlink协议完成数据交换,而ioctl和proc文件系统均需要通过程序加入相应的设备或文件。 Netlink使用socket缓存队列,是一种异步通信机制,而...

空空如也

空空如也

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

内核态socket