TCP编程API

以下为一对 TCP 客户和服务器进程之间发生的一些典型事件的时间表。

 

 

 

服务器首先启动，稍后某个客户启动，它试图连接到服务器。我们假设客户给服务器发送一个请求，服务器处理该请求，并给客户发回一个响应。这个过程持续下去，直至客户关闭连接的客户端，从而给服务器发送一个 EOF (文件结束) 通知为止。服务器接着也关闭连接的服务器端，然后结束运行或等待新的客户连接。
（以上资链接：https://blog.csdn.net/YangLei253/article/details/90748313）

1、socket()函数

　　在进行网络I/O时，一个进程最先调用的就是socket()函数，指定期望的通信协议。

 #include <sys/types.h>          /* See NOTES */
 #include <sys/socket.h>

 int socket(int domain, int type, int protocol);

　　参数：

　　1）domain：协议族/协议域

　　AF_UNIX, AF_LOCAL   Local communication 　　　   unix(7)
　　AF_INET　　 　　　　 IPv4 Internet protocols　　      ip(7)
　　AF_INET6 　　　　      IPv6 Internet protocols　　      ipv6(7)

　　AF_NETLINK                Kernel user interface device     netlink(7)

　　AF_PACKET                 Low level packet interface        packet(7)

　　2) type：套接字类型

　　SOCK_STREAM：流式套接字，唯一对应TCP

　　SOCK_DGRAM：数据包套接字，唯一对应UDP

　　SOCK_RAW：原始套接字

　　3）protocol：一般填0，原始套接字编程时需填充

　　返回值：

　　成功返回非负整数，即套接字描述符，类似于文件描述符，出错返回-1

2、bind()函数

　　在套接口中，一个套接字只是用户程序与内核交互信息的枢纽，它自身没有太多的信息，也没有网络协议地址和端口号等信息，在进行网络通信的时候，必须把一个套接字与一个地址相关联，这个过程就是地址绑定的过程。许多时候内核会我们自动绑定一个地址，然而有时用户可能需要自己来完成这个绑定的过程，以满足实际应用的需要，最典型的情况是一个服务器进程需要绑定一个众所周知的地址或端口以等待客户来连接。这个事由bind的函数完成。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
 //bind将一个本地协议地址赋予一个套接字。对于网际网协议，协议地址是 32位 IPv4 地址或 128 位 IPv6 地址与 16 位的 TCP 或 UDP 端口号组合。
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数：

　　sockfd   ：待连接的sockfd，通过socket获得
　　addr      ：本地的通用套接字地址结构
　　addrlen ：地址长度

　　sockaddr 与 sockaddr_in（详见）

　1)sockaddr

　　struct sockaddr 是一个通用地址结构，这是为了统一地址结构的表示方法，统一接口函数，使不同的地址结构可以被bind() , connect() 等函数调用；但缺陷在于sa_data把目标地址和端口信息混在一起

struct sockaddr {  
     unsigned short sa_family;  //地址族
　　 char sa_data[14];  //14字节，包含套接字中的目标地址与端口信息                
　　 }; 

　　2）sockaddr_in

　　 struct sockaddr_in中的in 表示internet，即网络地址，为比较常用的地址结构，属于AF_INET地址族，
        sockaddr_in结构体解决了sockaddr的缺陷，把port和addr 分开储存在两个变量中

struct sockaddr_in { 
 　　 short int          sin_family;  //地址族 NBD
　　  unsigned short int sin_port;    //16位TCP/UDP端口号
     struct in_addr     sin_addr;     //32位IP地址
     unsigned char      sin_zero[8]; //8字节填充，不使用
 }       

struct in_addr {           
     unsigned long s_addr;   //32位IPV4地址
          }       
11      sin_zero 初始值应该使用函数 bzero() 来全部置零。

　　sin_port和sin_addr都必须是网络字节序（NBO），一般可视化的数字都是主机字节序（HBO）。

　　sockaddr_in结构体变量的基本配置

 

struct sockaddr_in ina;

bzero(&ina,sizeof(ina));

ina.sin_family=AF_INET;

ina.sin_port=htons(23);
ina.sin_addr.s_addr = inet_addr("132.241.5.10");  

　　3）两者相互关系

　sockaddr常用于bind、connect、recvfrom、sendto等函数的参数，指明地址信息，是一种通用的套接字地址。 
　sockaddr_in 是internet环境下套接字的地址形式。所以在网络编程中我们会对sockaddr_in结构体进行操作，使用sockaddr_in来建立所需的信息，最后使用类型转化就可以。     一般先把sockaddr_in变量赋值后，强制类型转换后传入用sockaddr做参数的函数：sockaddr_in用于socket定义和赋值；sockaddr用于函数参数。

 

3、listen()函数

　　设置监听模式与监听上限

　　listen 函数仅由 TCP 服务器调用，当 socket 函数创建一个套接字时，默认为一个主动套接字，也就是说它是一个将调用 connect 发起连接的客户套接字。

　　listen 函数把一个未连接的套接字转换为一个被动套接字，指示内核应该接收指向该套接字的连接请求，同时·设置accept监听数量的上限。

#include<sys/socket.h>
#include<sys/types.h>
int listen(int sockfd,int backlog);
//第二个参数规定内核应该为相应套接字排队的最大连接个数

　　参数：

　　sockfd：通过socket函数拿到的fd

　　backlog：同时允许几路客户端和服务器进行正在连接的过程（正在三次握手）

　          一般填5，测试可知，ARM最大为8

注：内核中服务器的套接字fd会维护2个链表：

　　1、正在三次握手的客户端链表（数量 = 2*backlog + 1）

　　2、已经建立好连接的客户端链表（已经完成三次握手，分配好了newfd）

　　eg：listen(fd, 5);  //表示系统允许11 = 2*5 + 1个客户端进行三次握手

　　返回值：

　　成功返回0，出错返回-1

 

4、accept()函数

　　阻塞等待客户端连接请求

#include <sys/types.h>          /* See NOTES */
2 #include <sys/socket.h>
//等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

　　参数：

　　sockfd：经过前面socket()创建并通过bind(),listen()设置的fd

　　addr和addrlen

　　返回值：

　　成功返回新建的newfd, 失败返回-1

 

5、客户端的连接函数 connect()

      客户端使用 connect 函数来建立与 TCP 服务器的连接。

#include <sys/socket。h>
#include <sys/types.h>

int connect(int sockfd,const struct sockaddr *servaddr,socklent_t addrlen);

　　connect()和服务端的bind()函数写法基本一致。

 

当服务器的监听地址是INADDR_ANY时，意思不是监听所有的客户端IP。而是服务器端的IP地址可以随意配置，这样使得该服务器端程序可以运行在任意计算机上，可使任意计算机作为服务器，便于程序移植。将INADDR_ANY换成127.0.0.1也可以达到同样的目的。这样，当作为服务器的计算机的IP有变动或者网卡数量有增减，服务器端程序都能够正常监听来自客户端的请求。

测试：基于TCP协议的简单客户端与服务器交互

基于TCP（面向连接）的socket编程，分为客户端和服务器端。

客户端的流程如下：

（1）创建套接字（socket）

（2）向服务器发出连接请求（connect）

（3）和服务器端进行通信（send/recv）

（4）关闭套接字

服务器端的流程如下：

（1）创建套接字（socket）

（2）将套接字绑定到一个本地地址和端口上（bind）

（3）将套接字设为监听模式，准备接收客户端请求（listen）

（4）等待客户请求到来；当请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字（accept）

（5）用返回的套接字和客户端进行通信（send/recv）

（6）返回，等待另一个客户请求。

（7）关闭套接字。

#include "net.h"

int main()
{
    int fd = -1;
    struct sockaddr_in sin; //Internet环境下套接字的地址形式，对其进行操作以建立信息
    
    /*1、创建套接字描述符ｆｄ */
    if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket");
        exit(1);
    }

    /*2、将套接字绑定到一个本地地址与端口上*/
    
    /*2.1 填充struct sockaddr_in结构体变量*/
    bzero(&sin, sizeof(sin)); //初始值置零
    //sin_port和sin_addr都必须是NBD,且可视化的数字一般都是HBD,如端口号２３
    sin.sin_family = AF_INET; //协议，ipv4
    sin.sin_port   = htons(SERV_PORT); //将端口号转化为NBD

    /*优化１:让服务器能绑定在任意ＩＰ上*/
    sin.sin_addr.s_addr = htonl(INADDR_ANY);

    /*2.2 绑定 */
    if(bind(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("bind");
        exit(1);
    }

    /*3. 把套接字设为监听模式，准备接收客户请求*/
    if(listen(fd, BACKLOG) < 0)
    {
        perror("listen");
        exit(1);
    }
    printf("Severing start...OK!\n");

    /*4.等待客户请求到来，当请求到来后，接收请求，返回一个基于此次的新的套接字 */
    int newfd = -1;

    /*优化２:通过程序获取刚建立连接的socket的客户端的IP地址与端口号 */
    struct sockaddr_in cin;
    socklen_t addrlen = sizeof(cin);
    //获取客户端信息
    if((newfd = accept(fd, (struct sockaddr *)&cin, &addrlen))<0)
    {
        perror("accept");
        exit(1);
    }
    //读出客户端信息，并将HBD转为NBD
    char ipv4_addr[16];
    if(!inet_ntop(AF_INET, (void *)&cin.sin_addr,ipv4_addr,sizeof(cin)))
    {
        perror("inet_ntop");
        exit(1);
    }
    //打印客户端的IP和端口号
    printf("Client(%s,%d) is connected!\n",ipv4_addr,ntohs(cin.sin_port));


    /*5.　读写数据*/
    int ret = -1;
    char buf[BUFSIZ];

    while(1)
    {
    bzero(buf, BUFSIZ);
        do{
            ret = read(newfd, buf, BUFSIZ-1);
        }while(ret < 0 && EINTR == errno);
        if(ret < 0)
        {
            perror("read");
            exit(1);
        }

        if(!ret) //对方已经关闭
        {
            break;
        }
        printf("Receive data: %s",buf);

        if(!strncasecmp(buf,QUIT_STR, strlen(QUIT_STR)))
        {
            printf("Client is exiting!\n");
            break;
        }
    }
    close(newfd);
    close(fd);
    return 0;

}

#include "net.h"

int main()
{
    int fd = -1;
    struct sockaddr_in sin;

    /*1.创建sock fd */
    if((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
    {
        perror("socket");
        exit(1);
    }

    /*2.连接服务器 */
    /*2.1 填充struct sockaddr_in结构体变量*/
    bzero(&sin, sizeof(sin)); //初始值置零
    sin.sin_family = AF_INET; //
    sin.sin_port = htons(SERV_PORT); //转化为ＮＢＤ
#if 0
    sin.sin_addr.s_addr = inet_addr(SERV_IP_ADDR);
#else
    if(inet_pton(AF_INET, SERV_IP_ADDR,(void *)&sin.sin_addr.s_addr) != 1)
    {
        perror("inet_pton");
        exit(1);
    }
#endif

    if(connect(fd,(struct sockaddr *)&sin, sizeof(sin)) < 0)
    {
        perror("connect");
        exit(1);
    }

    printf("Client starting ...\n");

    /*3.读写数据*/
    char buf[BUFSIZ];
    int ret = -1;
    while(1)
    {
        bzero(buf,BUFSIZ);
        if(fgets(buf, BUFSIZ-1, stdin) == NULL)
        {
            continue;
        }
        do{
            ret = write(fd, buf, strlen(buf));
        }while(ret < 0 && EINTR == errno);
        if(!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR)))
        {
            printf("Clinet is exiting!\n");
            break;
        }

    }

    /*4.关闭套接字 */
    close(fd);

        return 0;
}

#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <netinet/in.h>
#include <netinet/ip.h>

#define BACKLOG 5
#define QUIT_STR "quit"
#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.31.123"

#endif

测试结果：