嵌入式

嵌入式Linux网络编程

2019-07-12 17:59发布

站内文章 / 嵌入式Linux
16642 0 1584

嵌入式Linux网络编程

分类： 嵌入式学习 2013-01-10 15:20 95人阅读 评论(2) 收藏 举报
             TCP：Transmission Control Protocol 传输控制协议TCP是一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议。 OSI 协议参考模型，它是基于国际标准化组织（ISO）的建议发展起来的，从上到下共分为7 层：应用层、表示层、会话层、传输层、网络层、数据链路层及物理层 TCP/IP 参考模型  ：从上到下共分为4 层  :应用层、传输层、网络层、网络接口层 TCP：为应用程序提供可靠的通信连接。适合于一次传输大批数据的情况。并适用于要求得到响应的应用程序。
UDP：提供了无连接通信，且不对传送包进行可靠的保证。适合于一次传输少量数据，可靠性则由应用层来负责。 TCP 三次握手协议
TCP对话通过三次握手来初始化的。三次握手的目的是使数据段的发送和接收同步，告诉其他主机其一次可接收的数据量，并建立虚连接。 三次握手的简单过程。
· 初始化主机通过一个同步标志置位的数据段发出会话请求。
· 接收主机通过发回具有以下项目的数据段表示回复：同步标志置位、即将发送的数据段的起始字节的顺序号、应答并带有将收到的下一个数据段的字节顺序号。
· 请求主机再回送一个数据段，并带有确认顺序号和确认号。 UDP UDP 即用户数据报协议，它是一种无连接协议，因此不需要像TCP 那样通过三次握手来建立一个连接。同时，一个UDP应用可同时作为应用的客户或服务器方。由于UDP协议
并不需要建立一个明确的连接，因此建立UDP应用要比建立TCP应用简单得多。 socket socket接口是一种特殊的I/O，它也是一种文件描述符。每一个socket都用一个半相关描述{协议，本地地址、本地端口}来表示；一个完整的套接字则用一个相关描述{协议，本地地址、本地端口、远程地址、远程端口} socket有3 种类型
（1）流式socket（SOCK_STREAM）
流式套接字提供可靠的、面向连接的通信流；它使用TCP协议，从而保证了数据传输的正确性和顺序性。
（2）数据报socket（SOCK_DGRAM）
数据报套接字定义了一种无连接的服务，数据通过相互独立的报文进行传输，是无序的，并且不保证是可靠、无差错的。它使用数据报协议UDP。
（3）原始socket
原始套接字允许对底层协议如IP或ICMP进行直接访问，它功能强大但使用较为不便，主要用于一些协议的开发。 地址结构相关处理    1 . 下面首先介绍两个重要的数据类型：sockaddr 和sockaddr_in，这两个结构类型都是用来保存socket信息的，如下所示：
[cpp] view plaincopyprint?
  1. struct sockaddr {  
  2. unsigned short sa_family; /*地址族*/  
  3. char sa_data[14]; /*14字节的协议地址，包含该socket的IP地址和端口号。*/  
  4. };  
  5. struct sockaddr_in {  
  6. short int sa_family; /*地址族*/  
  7. unsigned short int sin_port; /*端口号*/  
  8. struct in_addr sin_addr; /*IP地址*/  
  9. unsigned char sin_zero[8]; /*填充0 以保持与struct sockaddr同样大小*/  
  10. };  
struct sockaddr { unsigned short sa_family; /*地址族*/ char sa_data[14]; /*14字节的协议地址，包含该socket的IP地址和端口号。*/ }; struct sockaddr_in { short int sa_family; /*地址族*/ unsigned short int sin_port; /*端口号*/ struct in_addr sin_addr; /*IP地址*/ unsigned char sin_zero[8]; /*填充0 以保持与struct sockaddr同样大小*/ };
    这两个数据类型是等效的，可以相互转化，通常sockaddr_in数据类型使用更为方便。在建立socketadd或sockaddr_in后，就可以对该socket 进行适当的操作了。
  2.结构字段      下面列出了该结构sa_family字段可选的常见值。 结构定义头文件#include
AF_INET：IPv4协议
AF_INET6：IPv6协议
AF_LOCAL：UNIX域协议
AF_LINK：链路地址协议
Sa_family
AF_KEY：密钥套接字（socket） htons、ntohs、htonl、ntohl。这四个地址分别实现网络字节序和主机字节序的转化，这里的h 代表host，n 代表network，s 代表short，l 代表long
3．地址格式转化函数           在IPv4 中用到的函数有inet_aton、inet_addr 和inet_ntoa，而IPv4 和IPv6 兼容的函数有inet_pton 和inet_ntop。在IPv4 中用到的函数有inet_aton、inet_addr 和inet_ntoa，而IPv4 和IPv6 兼容的函数有inet_pton 和inet_ntop。
      inet_pton 函数是将点分十进制地址映射为二进制地址，而inet_ntop 是将二进制地址映射为点分十进制地址。
     函数原型如下：          int inet_pton(int family,const char *strptr, void *addrptr)  strptr：要转化的值   addrptr：转化后的地址          int inet_ntop(int family, void *addrptr, char *strptr, size_t len)     addrptr：转化后的地址  strptr：要转化的值  4．名字地址转化                一些函数可以实现主机名和地址的转化，最为常见的有gethostbyname、gethostbyaddr、getaddrinfo等               gethostbyname 是将主机名转化为IP 地址，gethostbyaddr 则是逆操作，是将IP地址转化为主机名，另外getaddrinfo还能实现自动识别IPv4地址和IPv6地址。             gethostbyname和gethostbyaddr 都涉及到一个hostent 的结构体 [cpp] view plaincopyprint?
  1. Struct hostent{  
  2. char *h_name;/*正式主机名*/  
  3. char **h_aliases;/*主机别名*/  
  4. int h_addrtype;/*地址类型*/  
  5. int h_length;/*地址长度*/  
  6. char **h_addr_list;/*指向IPv4或IPv6的地址指针数组*/  
  7. }  
Struct hostent{ char *h_name;/*正式主机名*/ char **h_aliases;/*主机别名*/ int h_addrtype;/*地址类型*/ int h_length;/*地址长度*/ char **h_addr_list;/*指向IPv4或IPv6的地址指针数组*/ }       调用该函数后就能返回hostent 结构体的相关信息。
      [cpp] view plaincopyprint?
  1. struct addrinfo{  
  2. int ai_flags;/*AI_PASSIVE,AI_CANONNAME;*/  
  3. int ai_family;/*地址族*/  
  4. int ai_socktype;/*socket类型*/  
  5. int ai_protocol;/*协议类型*/  
  6. size_t ai_addrlen;/*地址长度*/  
  7. char *ai_canoname;/*主机名*/  
  8. struct sockaddr *ai_addr;/*socket结构体*/  
  9. struct addrinfo *ai_next;/*下一个指针链表*/  
  10. }  
struct addrinfo{ int ai_flags;/*AI_PASSIVE,AI_CANONNAME;*/ int ai_family;/*地址族*/ int ai_socktype;/*socket类型*/ int ai_protocol;/*协议类型*/ size_t ai_addrlen;/*地址长度*/ char *ai_canoname;/*主机名*/ struct sockaddr *ai_addr;/*socket结构体*/ struct addrinfo *ai_next;/*下一个指针链表*/ }
    getaddrinfo函数涉及到一个addrinfo的结构体 头文件：           #include
函数原型            Struct hostent *gethostbyname(const char *hostname)      Hostname：主机名             Int getaddrinfo(const char *hostname,const char *service,const struct addrinfo*hints,struct addrinfo **result)    service：服务名或十进制的串口号字符串   hints：服务线索   result：返回结果  -----------    socket基础编程 socket编程的基本函数有socket、bind、listen、accept、send、sendto、recv、recvfrom这几个 · socket：该函数用于建立一个socket连接，可指定socket类型等信息。在建立了socket连接之后，可对socketadd或sockaddr_in进行初始化，以保存所建立的socket信息。
· bind：该函数是用于将本地IP 地址绑定端口号的，若绑定其他地址则不能成功。另外，它主要用于TCP的连接，而在UDP的连接中则无必要。
· connect：该函数在TCP中是用于bind的之后的client 端，用于与服务器端建立连接，而在UDP中由于没有了bind函数，因此用connect有点类似bind函数的作用。
· send和recv：这两个函数用于接收和发送数据，可以用在TCP中，也可以用在UDP中。当用在UDP时，可以在connect函数建立连接之后再用。
· sendto和recvfrom：这两个函数的作用与send和recv函数类型，也可以用在TCP和UDP中。当用在TCP时，后面的几个与地址有关参数不起作用，函数作用等同于send和recv；当用在UDP时，可以用在之前没有使用connect的情况时，这两个函数可以自动寻找制定地址并进行连接。 用TCP协议socket编程流程图 用UDP协议socket编程流程图 函数格式 所需头文件#include
函数原型int socket(int family, int type, int protocol)               family：协议族  type：套接字类型：SOCK_STREAM：字节流套接字socket   SOCK_DGRAM：数据报套接字socket  SOCK_RAW：原始套接字socket 函数原型int bind(int sockfd,struct sockaddr *my_addr, int addrlen)    socktd：套接字描述符 my_addr：本地地址  addrlen：地址长度 函数原型int listen(int sockfd， int backlog)    Backlog：请求队列中允许的最大请求数，大多数系统缺省值为20 函数原型int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)    addr：客户端地址  addrlen：地址长度 函数原型int connect(int sockfd, struct sockaddr *serv_addr, int addrlen)  serv_addr：服务器端地址  addrlen：地址长度 函数原型int send(int sockfd, const void *msg, int len, int flags)  msg：指向要发送数据的指针  len：数据长度   flags：一般为0 函数原型int recv(int sockfd,void *buf,int len,unsigned int flags) 函数原型int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr*to, int tolen) 函数原型int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int*fromlen)  from：源机的IP地址和端口号信息  tolen：地址长度   一个简单的C/S例子 server.c [cpp] view plaincopyprint?
  1. #include    
  2. #include    
  3. #include    
  4. #include    
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #define SERVPORT 3333   
  10. #define BACKLOG 10   
  11. #define MAX_CONNECTED_NO 10   
  12. #define MAXDATASIZE 5   
  13. int main()  
  14. {  
  15. struct sockaddr_in server_sockaddr,client_sockaddr;  
  16. int sin_size,recvbytes;  
  17. int sockfd,client_fd;  
  18. char buf[MAXDATASIZE];  
  19. /*建立socket连接*/  
  20. if((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1){  
  21. perror("socket");  
  22. exit(1);  
  23. }  
  24. printf("socket success!,sockfd=%d ",sockfd);  
  25. /*设置sockaddr_in 结构体中相关参数*/  
  26. server_sockaddr.sin_family=AF_INET;  
  27. server_sockaddr.sin_port=htons(SERVPORT);  
  28. server_sockaddr.sin_addr.s_addr=INADDR_ANY;  
  29. bzero(&(server_sockaddr.sin_zero),8);  
  30. /*绑定函数bind*/  
  31. if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct  
  32. sockaddr))== -1){  
  33. perror("bind");  
  34. exit(1);  
  35. }  
  36. printf("bind success! ");  
  37. /*调用listen函数*/  
  38. if(listen(sockfd,BACKLOG)== -1){  
  39. perror("listen");  
  40. exit(1);  
  41. }  
  42. printf("listening.... ");  
  43. /*调用accept函数，等待客户端的连接*/  
  44. if((client_fd=accept(sockfd,(struct sockaddr *)&client_sockaddr,&sin_  
  45. size))== -1){  
  46. perror("accept");  
  47. exit(1);  
  48. }  
  49. /*调用recv函数接收客户端的请求*/  
  50. if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))== -1){  
  51. perror("recv");  
  52. exit(1);  
  53. }  
  54. printf("received a connection :%s ",buf);  
  55. close(sockfd);  
  56. }  
#include #include #include #include #include #include #include #include #define SERVPORT 3333 #define BACKLOG 10 #define MAX_CONNECTED_NO 10 #define MAXDATASIZE 5 int main() { struct sockaddr_in server_sockaddr,client_sockaddr; int sin_size,recvbytes; int sockfd,client_fd; char buf[MAXDATASIZE]; /*建立socket连接*/ if((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1){ perror("socket"); exit(1); } printf("socket success!,sockfd=%d ",sockfd); /*设置sockaddr_in 结构体中相关参数*/ server_sockaddr.sin_family=AF_INET; server_sockaddr.sin_port=htons(SERVPORT); server_sockaddr.sin_addr.s_addr=INADDR_ANY; bzero(&(server_sockaddr.sin_zero),8); /*绑定函数bind*/ if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct sockaddr))== -1){ perror("bind"); exit(1); } printf("bind success! "); /*调用listen函数*/ if(listen(sockfd,BACKLOG)== -1){ perror("listen"); exit(1); } printf("listening.... "); /*调用accept函数，等待客户端的连接*/ if((client_fd=accept(sockfd,(struct sockaddr *)&client_sockaddr,&sin_ size))== -1){ perror("accept"); exit(1); } /*调用recv函数接收客户端的请求*/ if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))== -1){ perror("recv"); exit(1); } printf("received a connection :%s ",buf); close(sockfd); } client.c [cpp] view plaincopyprint?
  1. #include    
  2. #include    
  3. #include    
  4. #include    
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #define SERVPORT 3333   
  10. #define MAXDATASIZE 100   
  11. main(int argc,char *argv[]){  
  12. int sockfd,sendbytes;  
  13. char buf[MAXDATASIZE];  
  14. struct hostent *host;  
  15. struct sockaddr_in serv_addr;  
  16. if(argc < 2){  
  17. fprintf(stderr,"Please enter the server's hostname! ");  
  18. exit(1);  
  19. }  
  20. /*地址解析函数*/  
  21. if((host=gethostbyname(argv[1]))==NULL){  
  22. perror("gethostbyname");  
  23. exit(1);  
  24. }  
  25. /*创建socket*/  
  26. if((sockfd=socket(AF_INET,SOCK_STREAM,0))== -1){  
  27. perror("socket");  
  28. exit(1);  
  29. }  
  30. /*设置sockaddr_in 结构体中相关参数*/  
  31. serv_addr.sin_family=AF_INET;  
  32. serv_addr.sin_port=htons(SERVPORT);  
  33. serv_addr.sin_addr=*((struct in_addr *)host->h_addr);  
  34. bzero(&(serv_addr.sin_zero),8);  
  35. /*调用connect函数主动发起对服务器端的连接*/  
  36. if(connect(sockfd,(struct sockaddr *)&serv_addr,  
  37. sizeof(struct sockaddr))== -1){  
  38. perror("connect");  
  39. exit(1);  
  40. }  
  41. /*发送消息给服务器端*/  
  42. if((sendbytes=send(sockfd,"hello",5,0))== -1){  
  43. perror("send");  
  44. exit(1);  
  45. }  
  46. close(sockfd);  
  47. }  
#include #include #include #include #include #include #include #include #define SERVPORT 3333 #define MAXDATASIZE 100 main(int argc,char *argv[]){ int sockfd,sendbytes; char buf[MAXDATASIZE]; struct hostent *host; struct sockaddr_in serv_addr; if(argc < 2){ fprintf(stderr,"Please enter the server's hostname! "); exit(1); } /*地址解析函数*/ if((host=gethostbyname(argv[1]))==NULL){ perror("gethostbyname"); exit(1); } /*创建socket*/ if((sockfd=socket(AF_INET,SOCK_STREAM,0))== -1){ perror("socket"); exit(1); } /*设置sockaddr_in 结构体中相关参数*/ serv_addr.sin_family=AF_INET; serv_addr.sin_port=htons(SERVPORT); serv_addr.sin_addr=*((struct in_addr *)host->h_addr); bzero(&(serv_addr.sin_zero),8); /*调用connect函数主动发起对服务器端的连接*/ if(connect(sockfd,(struct sockaddr *)&serv_addr, sizeof(struct sockaddr))== -1){ perror("connect"); exit(1); } /*发送消息给服务器端*/ if((sendbytes=send(sockfd,"hello",5,0))== -1){ perror("send"); exit(1); } close(sockfd); }


网络高级编程网络高级编程所需头文件   #include
函数原型int socket(int family, int type, int protocol)所需头文件#include
函数原型int socket(int family, int type, int protocol)所需头文件#include
函数原型int socket(int family, int type, int protocol)调用该函数后就能返回hostent 结构体的相关信息。
getaddrinfo函数涉及到一个addrinfo的结构体调用该函数后就能返回hostent 结构体的相关信息。
getaddrinfo函数涉及到一个addrinfo的结构体 5.网络高级编程     之前介绍的如connet、recv、send都是阻塞性函数，若资源没有准备好，则调用该函数的进程将进入睡眠状态，这样就无法处理I/O 多路复用的情况了，fcntl和select是了两种解决I/O 多路复用的解决方法 1．fcntl
函数fcntl针对socket编程提供了如下的编程特性。
· 非阻塞I/O：可将cmd设置为F_SETFL，将lock设置为O_NONBLOCK。
· 信号驱动I/O：可将cmd设置为F_SETFL，将lock设置为O_ASYNC。 简单的例子fcntl.c [cpp] view plaincopyprint?
  1. #include    
  2. #include    
  3. #include    
  4. #include    
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #include    
  10. #include    
  11. #include    
  12. #include    
  13. #include    
  14. #define SERVPORT 3333   
  15. #define BACKLOG 10   
  16. #define MAX_CONNECTED_NO 10   
  17. #define MAXDATASIZE 100   
  18. int main()  
  19. {  
  20. struct sockaddr_in server_sockaddr,client_sockaddr;  
  21. int sin_size,recvbytes,flags;  
  22. int sockfd,client_fd;  
  23. char buf[MAXDATASIZE];  
  24. if((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1){  
  25. perror("socket");  
  26. exit(1);  
  27. }  
  28. printf("socket success!,sockfd=%d ",sockfd);  
  29. server_sockaddr.sin_family=AF_INET;  
  30. server_sockaddr.sin_port=htons(SERVPORT);  
  31. server_sockaddr.sin_addr.s_addr=INADDR_ANY;  
  32. bzero(&(server_sockaddr.sin_zero),8);  
  33. if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct  
  34. sockaddr))== -1){  
  35. perror("bind");  
  36. exit(1);  
  37. }  
  38. printf("bind success! ");  
  39. if(listen(sockfd,BACKLOG)== -1){  
  40. perror("listen");  
  41. exit(1);  
  42. }  
  43. printf("listening.... ");  
  44. /*调用fcntl函数设置非阻塞参数*/  
  45. if((flags=fcntl( sockfd, F_SETFL, 0))<0)  
  46. perror("fcntl F_SETFL");  
  47. flag |= O_NONBLOCK;  
  48. if(fcntl(fd,F_SETEL,flags)<0)  
  49. perror("fcntl");  
  50. while(1){  
  51. sin_size=sizeof(struct sockaddr_in);  
  52. if((client_fd=accept(sockfd,(structsockaddr*)&client_sockaddr,  
  53. &sin_size))== -1){  
  54. perror("accept");  
  55. exit(1);  
  56. }  
  57. if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))== -1){  
  58. perror("recv");  
  59. exit(1);  
  60. }  
  61. if(read(client_fd,buf,MAXDATASIZE)<0){  
  62. perror("read");  
  63. exit(1);  
  64. }  
  65. printf("received a connection :%s",buf);  
  66. close(client_fd);  
  67. exit(1);  
  68. }/*while*/  
  69. }  
#include #include #include #include #include #include #include #include #include #include #include #include #include #define SERVPORT 3333 #define BACKLOG 10 #define MAX_CONNECTED_NO 10 #define MAXDATASIZE 100 int main() { struct sockaddr_in server_sockaddr,client_sockaddr; int sin_size,recvbytes,flags; int sockfd,client_fd; char buf[MAXDATASIZE]; if((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1){ perror("socket"); exit(1); } printf("socket success!,sockfd=%d ",sockfd); server_sockaddr.sin_family=AF_INET; server_sockaddr.sin_port=htons(SERVPORT); server_sockaddr.sin_addr.s_addr=INADDR_ANY; bzero(&(server_sockaddr.sin_zero),8); if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct sockaddr))== -1){ perror("bind"); exit(1); } printf("bind success! "); if(listen(sockfd,BACKLOG)== -1){ perror("listen"); exit(1); } printf("listening.... "); /*调用fcntl函数设置非阻塞参数*/ if((flags=fcntl( sockfd, F_SETFL, 0))<0) perror("fcntl F_SETFL"); flag |= O_NONBLOCK; if(fcntl(fd,F_SETEL,flags)<0) perror("fcntl"); while(1){ sin_size=sizeof(struct sockaddr_in); if((client_fd=accept(sockfd,(structsockaddr*)&client_sockaddr, &sin_size))== -1){ perror("accept"); exit(1); } if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))== -1){ perror("recv"); exit(1); } if(read(client_fd,buf,MAXDATASIZE)<0){ perror("read"); exit(1); } printf("received a connection :%s",buf); close(client_fd); exit(1); }/*while*/ } 2．select
使用fcntl 函数虽然可以实现非阻塞I/O 或信号驱动I/O，但在实际使用时往往会对资源是否准备完毕进行循环测试，这样就大大增加了不必要的CPU 资源。select函数还可以设置等待的时 select_socket.c   [cpp] view plaincopyprint?
  1. #include    
  2. #include    
  3. #include    
  4. #include    
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #include    
  10. #include    
  11. #include    
  12. #include    
  13. #define SERVPORT 3333   
  14. #define BACKLOG 10   
  15. #define MAX_CONNECTED_NO 10   
  16. #define MAXDATASIZE 100   
  17. int main()  
  18. {  
  19. struct sockaddr_in server_sockaddr,client_sockaddr;  
  20. int sin_size,recvbytes;  
  21. fd_set readfd;  
  22. fd_set writefd;  
  23. int sockfd,client_fd;  
  24. char buf[MAXDATASIZE];  
  25. if((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1){  
  26. perror("socket");  
  27. exit(1);  
  28. }  
  29. printf("socket success!,sockfd=%d ",sockfd);  
  30. server_sockaddr.sin_family=AF_INET;  
  31. server_sockaddr.sin_port=htons(SERVPORT);  
  32. server_sockaddr.sin_addr.s_addr=INADDR_ANY;  
  33. bzero(&(server_sockaddr.sin_zero),8);  
  34. if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct  
  35. sockaddr))== -1){  
  36. perror("bind");  
  37. exit(1);  
  38. }  
  39. printf("bind success! ");  
  40. if(listen(sockfd,BACKLOG)== -1){  
  41. perror("listen");  
  42. exit(1);  
  43. }  
  44. printf("listening.... ");  
  45. /*将调用socket函数的描述符作为文件描述符*/  
  46. FD_ZERO(&readfd);  
  47. FD_SET(sockfd,&readfd);  
  48. while(1){  
  49. sin_size=sizeof(struct sockaddr_in);  
  50. /*调用select函数*/  
  51. if(select(MAX_CONNECTED_NO,&readfd,NULL,NULL,(struct timeval *)0)>0){  
  52. if(FD_ISSET(sockfd,&readfd)>0){  
  53. if((client_fd=accept(sockfd,(struct sockaddr *)&client_  
  54. sockaddr,&sin_size))== -1){  
  55. perror("accept");  
  56. exit(1);  
  57. }  
  58. if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))== -1){  
  59. perror("recv");  
  60. exit(1);  
  61. }  
  62. if(read(client_fd,buf,MAXDATASIZE)<0){  
  63. perror("read");  
  64. exit(1);  
  65. }  
  66. printf("received a connection :%s",buf);  
  67. }/*if*/  
  68. close(client_fd);  
  69. }/*select*/  
  70. }/*while*/  
  71. }  
#include #include #include #include #include #include #include #include #include #include #include #include #define SERVPORT 3333 #define BACKLOG 10 #define MAX_CONNECTED_NO 10 #define MAXDATASIZE 100 int main() { struct sockaddr_in server_sockaddr,client_sockaddr; int sin_size,recvbytes; fd_set readfd; fd_set writefd; int sockfd,client_fd; char buf[MAXDATASIZE]; if((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1){ perror("socket"); exit(1); } printf("socket success!,sockfd=%d ",sockfd); server_sockaddr.sin_family=AF_INET; server_sockaddr.sin_port=htons(SERVPORT); server_sockaddr.sin_addr.s_addr=INADDR_ANY; bzero(&(server_sockaddr.sin_zero),8); if(bind(sockfd,(struct sockaddr *)&server_sockaddr,sizeof(struct sockaddr))== -1){ perror("bind"); exit(1); } printf("bind success! "); if(listen(sockfd,BACKLOG)== -1){ perror("listen"); exit(1); } printf("listening.... "); /*将调用socket函数的描述符作为文件描述符*/ FD_ZERO(&readfd); FD_SET(sockfd,&readfd); while(1){ sin_size=sizeof(struct sockaddr_in); /*调用select函数*/ if(select(MAX_CONNECTED_NO,&readfd,NULL,NULL,(struct timeval *)0)>0){ if(FD_ISSET(sockfd,&readfd)>0){ if((client_fd=accept(sockfd,(struct sockaddr *)&client_ sockaddr,&sin_size))== -1){ perror("accept"); exit(1); } if((recvbytes=recv(client_fd,buf,MAXDATASIZE,0))== -1){ perror("recv"); exit(1); } if(read(client_fd,buf,MAXDATASIZE)<0){ perror("read"); exit(1); } printf("received a connection :%s",buf); }/*if*/ close(client_fd); }/*select*/ }/*while*/ }
  下面是实现简单的linux 下的TCP通讯程序 服务器端的代码如下： server.c [cpp] view plaincopyprint?

  1. #include  

  2. #include   
  3. #include   
  4. #include   
  5. #include   
  6. #include   
  7. #include   
  8. #include   
  9. #include

    #define MYPORT 3490   

  10. #define BACKLOG 10    
  11. #define MAXDATASIZE 1024

    int sockfd,new_fd;   

  12. pthread_t  accthread,recthread;

    void recmessage(void){  

  13.     while(1){  
  14.       int numbytes;  
  15.       char buf[MAXDATASIZE];  
  16.       if((numbytes = recv(new_fd,buf,MAXDATASIZE,0)) == -1){  
  17. perror("recv");  
  18.    exit(1);  
  19.      }  
  20.       buf[numbytes] = '

热门文章