学习笔记七之网络编程(TCP)

深藏阁楼爱情的钟 2022-08-10 06:30 141阅读 0赞

# 一.Linux下TCP编程框架  ![0_1315996134ERSS.gif][]  TCP网络编程的流程包含服务器和客户端两种模式。服务器模式创建一个服务程序，等待客户端用户的连接，接收到用户的连接请求后，根据用户的请求进行处理；客户端模式则根据目的服务器的地址和端口进行连接，向服务器发送请求并对服务器的响应进行数据处理。  1.服务器端程序包括  Ø  建立套接字（ socket()）  Ø  套接字与端口的绑定(bind())  Ø  设置服务器的侦听连接（listen()）  Ø  接收客户端连接（accept()）  Ø  接收和发送数据（send(),recv()）  Ø  关闭套接字(close())  2.说明  1>套接字初始化过程中，根据用户对套接字的需求来确定套接字的选项。按照用户定义的网络类型，协议类型和具体的协议标号等参数来定以socket()函数。系统根据用户的需求生成一个套接字文件描述符供用户使用。  2>套接字与端口的绑定过程中，将套接字与一个地址结构进行绑定。绑定之后，套接字所代表IP地址和端口地址及协议类型等参数按照绑定值进行操作。  3>由于一个服务器需要满足多个客户端的连接请求，而服务器在某个时间仅能处理有限个数的客户端连接请求，所以服务器需要设置服务器端排队队列的长度。  4>在客户端发送连接请求之后，服务器需要接收客户端的连接，然后才能进行其他的处理。  5>在服务器接收客户端请求之后，可以从套接字文件描述符中读取数据或者向文件描述符发送数据。接收数据后服务器按照定义的规则对数据进行处理，并将结果发送给客户端。  6>当服务器处理完数据，要结束与客户端的通信过程的时候，需要关闭套接字连接  2.客户端程序包括  Ø  建立套接字(socket())  Ø  连接服务器(connect())  Ø  读写网络数据(send(),recv())  Ø  关闭套接字(close())  3.服务器端和客户端程序的区别  客户端程序和服务器端程序不同之处是客户端在建立套接字之后可以不进行地址绑定，而是直接连接服务器端。  服务器端有listen()和accept()两个函数，而客户端不需要这两个函数。  二.基于Linux的TCP套接字函数  1. socket  1> 函数原型:  int socket(int domain,int type,int protocol)  2> 函数功能：  函数socket()用于创建一个套接字描述符。  3> 形参：  Ø  domain:用于指定创建套接字所使用的协议族，在头文件  <linux/socket.h>中定义。有时候程序中会使用PF\_INET，在头文件中AF\_INET和PF\_INET的数值是一致的。  常见的协议族如下：  AF\_UNIX:创建只在本机内进行通信的套接字。  AF\_INET:使用IPv4TCP/IP协议  AF\_INET6:使用IPv6 TCP/IP协议  说明：  AF\_UNIX只能用于单一的UNIX系统进程间通信，而AF\_INET是针对Interne的，因而可以允许在远程主机之间通信。一般把它赋为AF\_INET。  Ø  type:指明套接子通信的类型，对应的参数如下  SOCK\_STREAM:创建TCP流套接字  SOCK\_DGRAM:创建UDP数据报套接字  SOCK\_RAW:创建原始套接字  Ø  protocol:指定某个协议的特定类型  参数protocol通常设置为0，表示通过参数domain指定的协议族和参数type指定的套接字类型来确定使用的协议。当为原始套接字时，系统无法唯一的确定协议，此时就需要使用使用该参数指定所使用的协议。  4> 返回值：执行成功后返回一个新创建的套接字；若有错误发生则返回一个-1，错误代码存入errno中。  5> 举例：调用socket函数创建一个UDP套接字  int sock\_fd;  sock\_fd = socket(AF\_INET,SOCK\_DGRAM,0);  if(sock\_fd< 0)\{          perror(“socket”);         exit(1);  \}  2. bind  1> 函数原型：  int bind(int sockfd,struct sockaddr \*my\_addr,socklen\_t addrlen)  2> 函数功能  函数bind()的作用是将一个套接字文件描述符与地址和端口绑定。  3> 形参：  Ø  sockfd:sockfd是调用socket函数返回的文件描述符；  Ø  addrlen是sockaddr结构的长度。  Ø  my\_addr: 是一个指向sockaddr结构的指针，它保存着本地套接字的地址（即端口和IP地址）信息。不过由于系统兼容性的问题，一般不使用这个结构，而使用另外一个结构(structsockaddr\_in)来代替  4> 套接字地址结构：  (1)struct sockaddr:  结构struct  sockaddr定义了一种通用的套接字地址，它在  sys/socket.h 中定义。  struct sockaddr\{          unsigned short  sa\_family;/\*地址类型，AF\_XXX\*/         char          sa\_data\[14\];/\*14字节的协议地址\*/  \}  a. sin\_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF\_INET.  b. sa\_data：存储具体的协议地址。  (2)sockaddr\_in  每种协议族都有自己的协议地址格式，TCP/IP协议组的地址格式为结构体struct sockaddr\_in,它在netinet/in.h头文件中定义。  structsockaddr\_in\{      unsigned short  sin\_family;/\*地址类型\*/     unsigned short  sin\_port;/\*端口号\*/     struct in\_addr   sin\_addr;/\*IP地址\*/     unsigned char  sin\_zero\[8\];/\*填充字节，一般赋值为0\*/  \}  a. sin\_family：表示地址类型，对于使用TCP/IP协议进行的网络编程，该值只能是AF\_INET.  b. sin\_port:是端口号  c. sin\_addr:用来存储32位的IP地址。  d. 数组sin\_zero为填充字段，一般赋值为0.  e. struct in\_addr的定义如下：  structin\_addr\{                        unsigned long s\_addr;  \}  结构体sockaddr的长度为16字节，结构体sockaddr\_in的长度为16字节。可以将参数my\_addr的sin\_addr设置为INADDR\_ANY而不是某个确定的IP地址就可以绑定到任何网络接口。对于只有一IP地址的计算机，INADDR\_ANY对应的就是它的IP地址；对于多宿主主机(拥有多个网卡)，INADDR\_ANY表示本服务器程序将处理来自所有网络接口上相应端口的连接请求  5> 返回值：  函数成功后返回0，当有错误发生时则返回-1，错误代码存入errno中。  6>举例：调用socket函数创建一个UDP套接字  struct sockaddr\_in addr\_serv,addr\_client;/\*本地的地址信息\*/  memset(&serv\_addr,0,sizeof(structsockaddr\_in));  addr\_serv.sin\_family= AF\_INET;/\*协议族\*/  addr\_serv.sin\_port= htons(SERV\_PORT);/\*本地端口号\*/  addr\_serv.sin\_addr.s\_addr= htonl(INADDR\_ANY); /\*任意本地地址\*/   /\*套接字绑定\*/  if(bind(sock\_fd,(structsockaddr \*)&addr\_serv),sizeof(struct sockaddr\_in)) <0)  \{          perror(“bind”);         exit(1);  \}  3. 监听本地端口listen()  1>函数功能：函数listen()用来初始化服务器可连接队列，服务器处理客户端连接请求的时候是顺序处理的，同一时间仅能处理一个客户端连接。当多个客户端的连接请求同时到来的时候，服务器并不是同时处理，而是将不能处理的客户端连接请求放到等待队列中，这个队列的长度由listen()函数来定义。  2>函数原型：  \#includ<sys/socket.h>  int listen(int sockfd,int backlog);  3>形参  Ø  sockfd: sockfd是调用socket函数返回的文件描述符  Ø  backlog:指定该连接队列的最大长度。如果连接队列已经达到最大，之后的连接请求被服务器拒绝。大多数系统的设置为20，可以将其设置修改为5或者10，根据系统可承受负载或者应用程序的需求来确定。  4>返回值：当listen()函数成功运行时，返回值为0；当运行失败时，它的返回值为-1，错误代码存入errno中。  5>.listen()函数的例子：  \#define SERV\_PORT 3000  int main(int argc,char \*argv\[\])  \{   int sock\_fd;  struct sockaddr\_in addr\_serv,addr\_client;/\*本地的地址信息\*/  sock\_fd = socket(AF\_INET,SOCK\_DGRAM,0);  if(sock\_fd< 0)\{          perror(“socket”);         exit(1);  \}  memset(&serv\_addr,0,sizeof(structsockaddr\_in));  addr\_serv.sin\_family= AF\_INET;/\*协议族\*/  addr\_serv.sin\_port= htons(SERV\_PORT);/\*本地端口号\*/  addr\_serv.sin\_addr.s\_addr= htonl(INADDR\_ANY); /\*任意本地地址\*/   /\*套接字绑定\*/  if(bind(sock\_fd,(structsockaddr \*)&addr\_serv),sizeof(struct sockaddr\_in)) <0)  \{          perror(“bind”);         exit(1);  \}  //设置服务器侦听队列的长度  if(listen(sock\_fd,5) <0)\{          perror(“listen”);         exit(1);  \}  4. accept(接收一个网络请求)  1>函数功能：  当一个客户端的连接请求到达服务器主机侦听的端口时，此时客户端的连接会在队列中等待，知道使用服务器处理接收请求。  函数accept()成功执行后，会返回一个新的套接口文件描述符来表示客户端的连接，客户端连接的信息可以通过这个新描述符来获得。因此当服务器成功处理客户端的请求连接后，会有两个文件描述符，老的文件描述符表示客户端的连接，函数send()和recv()通过新的文件描述符进行数据收发。  2>函数原型：  \#include<sys/types.h>  \#include<sys/socket.h>  int accept(int sock\_fd,struct sockaddr\*addr,socklen\_t \*addrlen);  3>形参  Ø  sock\_fd:是由函数socket创建，经函数bind绑定到本地某一端口上，然后通过函数listen转化而来的监听套接字。  Ø  addr:用来保存发起连接请求的主机的地址和端口。  Ø  addrlen是addr 所指向的结构体的大小。  4>返回值：accept()函数的返回值是新连接的客户端套接字文件描述符，与客户端之间的通信是通过accept()返回的新套接字文件描述符来进行的，而不是通过建立套接字时的文件描述符。如果accept()函数发生错误，accept()会返回-1，通过errno可以得到错误值。  5>如果参数sock\_fd所指定的套接字被设置为阻塞方式（Linux下的默认方式），且连接请求队列为空，则accept()将被阻塞直到有连接请求到此为止；如果参数s所指定的套接字被设置为非阻塞方式，如果队列为空，accept将立即返回-1，errno被设置为EAGAIN.  6>实例：  int client\_fd;  int client\_len;  struct sockaddr\_in  client\_addr;  client\_len = sizeof(struct sockaddr\_in);  client\_fd = accept(sock\_fd,(struct sockaddr \*)&client\_addr,&client\_len);  if(conn\_fd< 0)\{          perror(“accept”);  exit(1);  \}  5. connect(连接目标网络服务器)  1>函数功能：  客户端在建立套接字之后，不需要进行地址绑定，就可以直接连接服务器。连接服务器的函数为connect(),此函数连接指定参数的服务器，例如IP地址，端口号。  如果是TCP编程，则connect()函数用于服务器发出连接请求，服务器的IP地址和端口号由 参数serv\_addr指定。  如果是UDP编程，则connect函数并不建立真正的连接，它只是告诉内核与该套接字进行通信的目的地址（由第二个参数指定），只有该目的地址发来的数据才会被该socket接收。调用connect函数的好处是不必在每次发送和接收数据时都指定目的地址。  2>函数原型：  \#include<sys/types.h>  \#include<sys/socket.h>  int connect(int sock\_fd,struct sockaddr  \*serv\_addr,socklen\_taddrlen);  3>形参：  Ø  sock\_fd:建立套接字时返回的套接字文件描述符，调用socket()返回的。  Ø  serv\_addr:是一个指向数据结构sockaddr的指针，其中包括客户端需要连接的服务器的目的IP地址和端口号。  Ø  addrlen:表示了第二了参数的大小，可以使用sizeof(struct sockaddr)  4>执行成功后返回0，有错误发生则返回-1，错误代码存入errno中。  5>实例：  int sock\_fd;  struct sockaddr\_in serv\_addr;   if(-1 == (sock\_fd == socket(AF\_INET,SOCK\_STREAM,0)))\{                 printf(“Error: Unable to createsocket(%i)…\\n”,errno);                perror(“sockets”);                exit(1);  \}  memset(&serv\_addr,0,sizeof(structsockaddr\_in));  serv\_addr.sin\_family= AF\_INET;  serv\_addr.sin\_port= htons(DEST\_PORT);  serv\_addr.sin\_addr.s\_addr= inet(DEST\_IP\_ADDRESS);  if(-1== connect(sock\_fd,(struct sockaddr \*)&serv\_add,sizeof(struct sockaddr)))\{          printf(“Error:unable to the establishconnection to socket(%i)…\\n”,errno);         perror(“socks”);         close(sock\_fd);         exit(1);  \}  6. send(发送数据)  1>函数功能：函数send用来在TCP套接字上发送数据,send只能对处于连接状态的套接字使用。  2>函数原型  \#include<sys/types.h>  \#include<sys/socket.h>  ssize\_t send(int conn\_fd,const void \*msg,size\_t len, int flags);  3>函数形参：  Ø  conn\_fd:为已建立好连接的套接字描述符，即调用accept()函数后返回的套接字描述符。  Ø  msg:存放发送数据的缓冲区。  Ø  len:发送缓冲区的长度  Ø  flags:为控制选项，一般设置为0，或取以下值：  ²  MSG\_OOB:在指定的套接字上发送带外数据（out-of-band data）,该类型的套接字必须支持带外数据（如：SOCK\_STREAM）.  ²  MSG\_DONTROUTE:通过最直接的路径发送数据，而忽略下层协议的路由设置。  4>返回值：  执行成功返回实际发送数据的字节数，出错则返回-1，错误代码存入errno中。  执行成功只是说明数据写入套接字的缓冲区中，并不表示数据已经成功地通过网络发送到目的地。  5>实例：  \#define  BUFFERSIZE  1500  char  send\_buf\[BUFFERSIZE\];  ……  if(send(conn\_fd,send\_buf,len,0)< 0)\{          perror(“send”);  exit(1);  \}   7. recv(接收数据)  1>函数功能：recv()用来TCP套接字上接收数据。函数recv从指定的套接字描述符上接收数据并保存到指定buf中。  2>函数原型  \#include<sys/types.h>  \#include<sys/socket.h>  ssize\_t recv(int conn\_fd,void \*buf,size\_t len,int flags);  3>函数形参：  Ø  conn\_fd: 为已建立好连接的套接字描述符，即调用accept()函数后返回的套接字描述符  Ø  buf:接收缓冲区  Ø  len:接收缓冲区的大小  Ø  flags:为控制选项，一般设置为0或取以下数值  ²  MSG\_OOB:请求接收带外数据  ²  MSG\_PEEK:只查看数据而不读出  ²  MSG\_WAITALL:只在接收缓冲区满时才返回。  4>函数返回值  函数执行成功返回接收到的数据字节数，出错返回-1，错误代码存入errno中。  5>实例：  \#define  BUFFERSIZE  1500  char recv\_buf\[BUFFERSIZE\];  ……  if(recv(conn\_fd,recv\_buf,sizeof(recv\_buf),0)< 0)\{          perror(“recv”);  exit(1);  \}   8. close  1>函数原型：  int  close(int fd);  2>函数功能：  函数close用来关闭一个套接字描述符。  3>函数形参：  Ø  参数fd为一个套接字描述符。  4>返回值：  执行成功返回0，出错则返回-1.错误代码存入errno中。  说明：close()函数的头文件是\#include<unistd.h>.  三.基于Linux的TCP套接字编程实例  1.实例程序分为服务器端和客户端，客户端把Hello tigerjibo发送给服务器端；服务器端接收到字符串后，发送接收到的总字符串个数给客户端；  ![0_13159977429EKy.gif][]  2.服务器端程序：     ![0_1316056497lv1J.gif][]     ![0_13160565695x55.gif][]            **\[cpp\]**  [view plain][] [copy][view plain]  \#include<stdio.h>    \#include<stdlib.h>    \#include<string.h>    \#include<errno.h>    \#include<sys/types.h>    \#include<sys/socket.h>    \#include<unistd.h>//close()    \#include<netinet/in.h>//struct sockaddr\_in    \#include<arpa/inet.h>//inet\_ntoa    \#define  QUEUE\_LINE  12    \#define  SOURCE\_PORT 8000        \#define  SOURCE\_IP\_ADDRESS "192.168.1.6"        void process\_info(int s)    \{            int recv\_num;            int send\_num;            char recv\_buf\[50\];            char send\_buf\[50\];            while(1)\{                    printf("begin recv:\\n");                    recv\_num = recv(s,recv\_buf,sizeof(recv\_buf),0);                    if(recv\_num <0)\{                            perror("recv");                            exit(1);                    \} else \{                            recv\_buf\[recv\_num\] = '\\0';                            printf("recv sucessful:%s\\n",recv\_buf);                    \}                    sprintf(send\_buf,"recv %d numbers bytes\\n",recv\_num);                    printf("begin send\\n");                    send\_num = send(s,send\_buf,sizeof(send\_buf),0);                    if (send\_num < 0)\{                            perror("sned");                            exit(1);                    \} else \{                            printf("send sucess\\n");                    \}            \}    \}    int main()    \{            int sock\_fd,conn\_fd;            int client\_len;            pid\_t pid;            struct sockaddr\_in addr\_serv,addr\_client;            sock\_fd = socket(AF\_INET,SOCK\_STREAM,0);            if(sock\_fd < 0)\{                    perror("socket");                    exit(1);            \} else \{                    printf("sock sucessful\\n");            \}            //初始化服务器端地址            memset(&addr\_serv,0,sizeof(addr\_serv));            addr\_serv.sin\_family = AF\_INET;            addr\_serv.sin\_port = htons(SOURCE\_PORT);            addr\_serv.sin\_addr.s\_addr =inet\_addr(SOURCE\_IP\_ADDRESS);            client\_len = sizeof(struct sockaddr\_in);            if(bind(sock\_fd,(struct sockaddr \*)&addr\_serv,sizeof(struct sockaddr\_in))<0)\{                    perror("bind");                    exit(1);            \} else \{                    printf("bind sucess\\n");            \}            if (listen(sock\_fd,QUEUE\_LINE) < 0)\{                    perror("listen");                    exit(1);            \} else \{                    printf("listen sucessful\\n");            \}            while(1)\{                     printf("begin accept:\\n");                     conn\_fd = accept(sock\_fd,(struct sockaddr \*)&addr\_client,&client\_len);                     if(conn\_fd < 0)\{                            perror("accept");                            exit(1);                     \}                     printf("accept a new client,ip:%s\\n",inet\_ntoa(addr\_client.sin\_addr));                     pid = fork();                     if(0 == pid)\{         //子进程                            close(sock\_fd);//在子进程中关闭服务器的侦听                            process\_info(conn\_fd);//处理信息                     \} else \{                            close(conn\_fd);//在父进程中关闭客户端的连接                     \}            \}        \}                  3.客户端程序：     ![0_1316056688RM8M.gif][]     ![0_1316056706ZMXH.gif][]       **\[cpp\]**  [view plain][] [copy][view plain]  \#include<stdio.h>    \#include<string.h>    \#include<stdlib.h>    \#include<errno.h>    \#include<sys/types.h>    \#include<sys/socket.h>    \#include<unistd.h>//close()    \#include<netinet/in.h>//struct sockaddr\_in    \#include<arpa/inet.h>//inet\_ntoa        \#define DEST\_PORT 8000    \#define DEST\_IP\_ADDRESS "192.168.1.6"        /\*客户端的处理过程\*/    void process\_info(int s)    \{            int send\_num;            int recv\_num;            char send\_buf\[\]="tigerjibo";            char recv\_buf\[50\];            while(1)\{                    printf("begin send\\n");                    send\_num = send(s,send\_buf,sizeof(send\_buf),0);                    if (send\_num < 0)\{                            perror("send");                            exit(1);                    \} else \{                            printf("send sucess:%s\\n",send\_buf);                    \}                    printf("begin recv:\\n");                    recv\_num = recv(s,recv\_buf,sizeof(recv\_buf),0);                    if(recv\_num < 0)\{                            perror("recv");                            exit(1);                    \} else \{                            recv\_buf\[recv\_num\]='\\0';                            printf("recv sucess:%s\\n",recv\_buf);                    \}            \}    \}    int main(int argc,char \*argv\[\])    \{            int sock\_fd;            struct sockaddr\_in addr\_serv;//服务器端地址                sock\_fd = socket(AF\_INET,SOCK\_STREAM,0);            if(sock\_fd < 0)\{                    perror("sock");                    exit(1);            \} else \{                    printf("sock sucessful:\\n");            \}            memset(&addr\_serv,0,sizeof(addr\_serv));            addr\_serv.sin\_family = AF\_INET;            addr\_serv.sin\_port =  htons(DEST\_PORT);            addr\_serv.sin\_addr.s\_addr = inet\_addr(DEST\_IP\_ADDRESS);           if( connect(sock\_fd,(struct sockaddr \*)&addr\_serv,sizeof(struct sockaddr)) < 0)\{                    perror("connect");                    printf("connect (%d)\\n",errno);                    exit(1);           \} else \{                    printf("connect sucessful\\n");           \}            process\_info(sock\_fd);            close(sock\_fd);    \}   #

[0_1315996134ERSS.gif]: http://hi.csdn.net/attachment/201109/14/0_1315996134ERSS.gif
[0_13159977429EKy.gif]: http://hi.csdn.net/attachment/201109/14/0_13159977429EKy.gif
[0_1316056497lv1J.gif]: http://hi.csdn.net/attachment/201109/15/0_1316056497lv1J.gif
[0_13160565695x55.gif]: http://hi.csdn.net/attachment/201109/15/0_13160565695x55.gif
[view plain]: http://blog.csdn.net/cqkxboy168/article/details/8897426#
[0_1316056688RM8M.gif]: http://hi.csdn.net/attachment/201109/15/0_1316056688RM8M.gif
[0_1316056706ZMXH.gif]: /images/20220731/ef3ee780da4b41eebbfe52f0882e668e.png