0x00 背景介绍

由于最近要完成自己的项目作业，其中需要使用socket进行网络通信。所以简单了解了一些这方面的知识，希望可以抛砖引玉。

0x01 socket介绍

socket 的原意是“插座”，在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。我们把插头插到插座上就能从电网获得电力供应，同样，为了与远程计算机进行数据传输，需要连接到因特网，而 socket 就是用来连接到因特网的工具。
套接字（socket）是一个抽象层，网络套接字是IP地址与端口的组合。学习 socket，也就是学习计算机之间如何通信，并编写出实用健壮的程序。
套接字有很多种类，而最具代表性的就是 Internet 套接字，我们常说的套接字，如果没有其他说明，都是指 Internet 套接字。

0x02 socket类型

根据数据的传输方式，可以将套接字分成两种类型。流格式套接字（SOCK_STREAM）和数据报格式套接字（SOCK_DGRAM）。通过 socket() 函数创建连接时，必须告诉它使用哪种数据传输方式。
流格式套接字是基于TCP协议，TCP 协议会控制你的数据按照顺序到达并且没有错误。所以说流格式套接字是一种可靠的、双向的通信数据流。
流格式套接字有以下特征：

数据在传输过程中不会消失；
数据是按照顺序传输的；
数据的发送和接收不是同步的

数据报格式套接字也是 IP 协议作路由，但是是依托UDP协议。数据报套接字是一种不可靠的、不按顺序传递的、以追求速度为目的的套接字。当数据传输发生错误时，也不会重传。
数据报格式套接字有以下特征：

强调快速传输而非传输顺序；
传输的数据可能丢失也可能损毁；
限制每次传输的数据大小；
数据的发送和接收是同步的。

0x03 网络通信协议

socket是站在传输层的基础上，所以可以使用 TCP/UDP 协议，为了更好的了解socket，我们需要网络通信协议知识的储备，我把附件已经放在下面了，大家可以自取。至少要了解TCP/IP协议，关于TCP的三次握手（这也是面试常问的问题），

0x04 linux与windows系统下socket程序演示

linux系统下比较简单，我们实现一个简单的客户端从服务器读取“Hello World”并打印出来
服务器：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>

int main(){
    //创建套接字
    int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

    //将套接字和IP、端口绑定
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
    serv_addr.sin_family = AF_INET;  //使用IPv4地址
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    serv_addr.sin_port = htons(1234);  //端口
    bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

    //进入监听状态，等待用户发起请求
    listen(serv_sock, 20);

    //接收客户端请求
    struct sockaddr_in clnt_addr;
    socklen_t clnt_addr_size = sizeof(clnt_addr);
    int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);

    //向客户端发送数据
    char str[] = "Hello World";
    write(clnt_sock, str, sizeof(str));
   
    //关闭套接字
    close(clnt_sock);
    close(serv_sock);

    return 0;
}

客户端：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

int main(){
    //创建套接字
    int sock = socket(AF_INET, SOCK_STREAM, 0);

    //向服务器（特定的IP和端口）发起请求
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
    serv_addr.sin_family = AF_INET;  //使用IPv4地址
    serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    serv_addr.sin_port = htons(1234);  //端口
    connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
   
    //读取服务器传回的数据
    char buffer[40];
    read(sock, buffer, sizeof(buffer)-1);
   
    printf("Message form server: %s\n", buffer);
   
    //关闭套接字
    close(sock);

    return 0;
}

windows系统下就比较麻烦了，需要预先加载Winsock.dll 或 ws2_32.dll文件，而且windows跟linux所用的一些函数功能虽然相同，但是名称却是不同的，这个要注意一下。
服务器：

#include <stdio.h>
#include <winsock2.h>
#pragma comment (lib, "ws2_32.lib")  //加载 ws2_32.dll

int main(){
    //初始化 DLL
    WSADATA wsaData;
    WSAStartup( MAKEWORD(2, 2), &wsaData);

    //创建套接字
    SOCKET servSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

    //绑定套接字
    sockaddr_in sockAddr;
    memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
    sockAddr.sin_family = PF_INET;  //使用IPv4地址
    sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
    sockAddr.sin_port = htons(1234);  //端口
    bind(servSock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));

    //进入监听状态
    listen(servSock, 20);

    //接收客户端请求
    SOCKADDR clntAddr;
    int nSize = sizeof(SOCKADDR);
    SOCKET clntSock = accept(servSock, (SOCKADDR*)&clntAddr, &nSize);

    //向客户端发送数据
    char *str = "Hello World!";
    send(clntSock, str, strlen(str)+sizeof(char), NULL);

    //关闭套接字
    closesocket(clntSock);
    closesocket(servSock);

    //终止 DLL 的使用
    WSACleanup();

    return 0;
}

客户端：

#include <stdio.h>
#include <stdlib.h>
#include <WinSock2.h>
#pragma comment(lib, "ws2_32.lib")  //加载 ws2_32.dll

int main(){
    //初始化DLL
    WSADATA wsaData;
    WSAStartup(MAKEWORD(2, 2), &wsaData);

    //创建套接字
    SOCKET sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

    //向服务器发起请求
    sockaddr_in sockAddr;
    memset(&sockAddr, 0, sizeof(sockAddr));  //每个字节都用0填充
    sockAddr.sin_family = PF_INET;
    sockAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    sockAddr.sin_port = htons(1234);
    connect(sock, (SOCKADDR*)&sockAddr, sizeof(SOCKADDR));

    //接收服务器传回的数据
    char szBuffer[MAXBYTE] = {0};
    recv(sock, szBuffer, MAXBYTE, NULL);

    //输出接收到的数据
    printf("Message form server: %s\n", szBuffer);

    //关闭套接字
    closesocket(sock);

    //终止使用 DLL
    WSACleanup();

    system("pause");
    return 0;
}

0x05 socket（）函数解析

socket（）函数在两个平台下参数是相同的，不同的是返回值，大家可以参考上面的代码。
先说一下linux系统下的socket（）函数。在 Linux系统下使用 <sys/socket.h> 头文件中 socket() 函数来创建套接字，原型为：

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

af指的是地址族（Address Family），也就是ip地址类型。当然有时候也会使用pf，到时候见到就不用惊讶了。type指的是数据传输方式/套接字类型，我们在上面已经讲了，根据数据传输方式的不同，我们可以将socket划分为两种常用类型，这里指的就是这个。protocol 表示传输协议，常用的有 IPPROTO_TCP 和 IPPTOTO_UDP，分别表示 TCP 传输协议和 UDP 传输协议。
一般情况下有了 af 和 type 两个参数就可以创建套接字了，操作系统会自动推演出协议类型，但是有时候有两种不同的协议支持同一种地址类型和数据传输类型，这个时候我们就需要指定传输协议了。
参数 af 的值为 PF_INET。如果使用 SOCK_STREAM 传输数据，那么满足这两个条件的协议只有 TCP，因此可以这样来调用 socket() 函数：

int tcp_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

这种套接字称为 TCP 套接字。

如果使用 SOCK_DGRAM 传输方式，那么满足这两个条件的协议只有 UDP，因此可以这样来调用 socket() 函数：

int udp_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

这种套接字称为 UDP 套接字。

上面两种情况都只有一种协议满足条件，可以将 protocol 的值设为 0，系统会自动推演出应该使用什么协议，如下所示：

int tcp_socket = socket(AF_INET, SOCK_STREAM, 0);
int udp_socket = socket(AF_INET, SOCK_DGRAM, 0);

windows平台下也是如此

SOCKET socket(int af, int type, int protocol);

本文参考的是《Socket通信原理》https://www.cnblogs.com/wangcq/p/3520400.html

一、TCP/IP UDP是什么？

TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，是一个工业标准的协议集，它是为广域网（WANs）设计的。UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是属于TCP/IP协议族中的一种。下面是他们三者的关系：

可以看出TCP/IP协议族包括运输层、网络层、链路层。socket是一个接口，在用户进程与TCP/IP协议之间充当中间人，完成TCP/IP协议的书写，用户只需理解接口即可。

二、socket与TCP/IP的对应关系

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

原作者将socket通信类比为打电话这一生活场景。这里我把TCP服务器比作政府某一服务部门能，TCP客户端比作企业中某一部门电话，描述这一过程，恰好就像是socket通信，服务部门提供服务，企业部门申请服务。
要实现通信，首先政府部门都必须申请一个电话（socket_fd），并向有关部门注册（我们的系统），提供地址（sockadrr）以及属于哪个部门的（port），录入系统后，就算是合约生效了（bind），于是乎，政府广而告之，这个服务热线就算开通了，在部门里面的人员所需要做的事情，就是等待企业家拨打热线（listen）。
企业家拨打电话对地点和部门没有这么多的要求了，他并不需要绑定地址和部门，在任何一个可以拨打电话的地方(可能是同个部门，也可以同公司不同部门，甚至可能是竞争对手)，他只需要拿起一个已经注册的电话（socket_fd），拨打电话（connect）
政府部门接通电话（accept）后，桥梁就打通了（服务者client_fd、顾客server_fd），可以进行听说了（read write）。企业家咨询完成（close）,政府到点下班关闭服务（close）

三、socket API 简单介绍

3.1 socket() 创建socket描述符

int socket(int domain, int type, int protocol); 
//成功返回非负描述符，失败返回-1

domain：即协议域，又称为协议族（family）。
常用的地址族有：

• AF_INET
• AF_INET6
• AF_LOCAL（AF_UNIX，本地通信用）
• AF_ROUTE

协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。

type：信息传送方式。

• SOCK_STREAM
• SOCK_DGRAM
• SOCK_RAW
• SOCK_PACKET
• SOCK_SEQPACKET

protocol：对应协议。

• IPPROTO_TCP TCP传输协议
• IPPROTO_UDP UDP传输协议
• IPPROTO_SCTP STCP传输协议
• IPPROTO_TIPCTIPC传输协议
  通常设置为0,让其自动匹配。

我的理解就是：
domain 网络层相关协议 type 信息传送方式 protocol 运输层相关协议，如果前两个都确定了，系统就可以自动选择协议了。

3.2 bind()绑定实际地址

int bind(int sockfd, const struct sockaddr *addr, socklen_t
addrlen); 
//返回值：成功则为0，失败为-1

sockfd 一般服务端才需要绑定，客户端由系统内核解决
addr 所有协议都有一个公共的结构叫做const struct sockaddr,不同协议对应不同的具体结构，结构如下：

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

可以看出，我们端口和目标地址放在同一数组中，不太容易使用。对于不同的协议，我们会通过另一种特定的结构体的来完成初始化，再通过强制类型转换，来使用bind函数。

强制转换第二个地址参数为const sockaddr *

(const sockaddr *)sockaddr_in;
(const sockaddr *)sockaddr_in6;
(const sockaddr *)sockaddr_un;

• ipv4结构体

struct sockaddr_in {
    sa_family_t    sin_family; 
    in_port_t      sin_port;   //typedef	__uint16_t		in_port_t;
    struct in_addr sin_addr;   
};

struct in_addr {
    uint32_t       s_addr;     
};

• ipv6结构体

struct sockaddr_in6 { 
    sa_family_t     sin6_family;    
    in_port_t       sin6_port;      
    uint32_t        sin6_flowinfo;  
    struct in6_addr sin6_addr;      
    uint32_t        sin6_scope_id;  
};

struct in6_addr { 
    unsigned char   s6_addr[16];    
};

• Unix域结构体

#define UNIX_PATH_MAX    108

struct sockaddr_un { 
    sa_family_t sun_family;                
    char        sun_path[UNIX_PATH_MAX];   
};

• addrlen：协议结构体大小
  通常使用sizeof运算符计算

sizeof(sockaddr_in);//IPv4 in:internet
sizeof(sockaddr_in6);//IPv6
sizeof(sockaddr_un);//本地 un:unix

3.3 listen()、connect() 主机监听、从机链接

int listen(int sockfd, int backlog);
//返回值：成功则为0，失败为-1 

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
//返回值：成功则为0，失败为-1 

listen决定需要开启的部门热线，connect拨打电话。

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

3.4 accept 建立链接

只要服务端建立链接，我们就可以进行操作了

int accept(int sockfd, struct sockaddr *addr, socklen_t  *addrlen);
//返回值：成功则为0，失败为-1 

第一个参数为服务器的socket描述字，
第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址
第三个参数为协议地址的长度。

如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。后面的读写操作都是根据这个返回值来完成的。

3.5 read和write函数，读写

这不是属于socket的API，但是socket总是伴随着以下函数：

ssize_t read(int fd, void *buf, size_t count);
       ssize_t write(int fd, const void *buf, size_t count);

ssize_t send(int sockfd, const void *buf, size_t len, int flags);
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
              const struct sockaddr *dest_addr, socklen_t addrlen);
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                struct sockaddr *src_addr, socklen_t *addrlen);

ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。

write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节 数。失败时返回-1，并设置errno变量。在网络程序中，当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0，表示写了部分或者是 全部的数据。2)返回的值小于0，此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示 网络连接出现了问题(对方已经关闭了连接)。

3.6 close关闭服务

int close(int fd);
//返回值：成功则为0，失败为-1 

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

一、理解socket

1. socket即为套接字，在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一的标识网络通讯中的一个进程，“IP地址+TCP或UDP端口号”就为socket。
2. 在TCP协议中，建立连接的两个进程（客户端和服务器）各自有一个socket来标识，则这两个socket组成的socket pair就唯一标识一个连接。
3. socket本身就有“插座”的意思，因此用来形容网络连接的一对一关系，为TCP/IP协议设计的应用层编程接口称为socket API。

二、网络字节序

内存中的多字节数据都有大小端之分，磁盘文件中的多字节数据相对于文件中的偏移地址也有大小端之分，同样，网络数据流也有大小端之分。

网络数据流的地址规定：先发出的数据时低地址，后发出的数据是高地址。发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出，为了不使数据流乱序，接收主机也会把从网络上接收的数据按内存地址从低到高的顺序保存在接收缓冲区中。

TCP/IP协议规定：网络数据流应采用大端字节序，即低地址高字节。

由于两端的两个主机的大小端不一定相同，因此为了使这些网络数据具有更强的可移植性，使相同的代码在大端和小端主机上都能正常运行，我们可以调用以下库函数进行网络字节序和主机字节序的相关转换：

#include<arpa/inet.h>

//将主机字节序转换为网络字节序
uint32_t htonl(uint32_t hostlong);//将32长整数从主机字节序转换为网络字节序，
                                  //如果主机字节序是小端，则函数会做相应大小
                                  //端转换后返回；如果主机字节序是大端，则函
                                  //数不做转换，将参数原封不动返回。。。下同
uint16_t htons(uint16_t hostshort);

//将网络字节序转换为主机字节序
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);

// h表示主机（host），n表示网络（net），l表示32位长整数，s表示16短整数。

三、TCP协议通讯的实现

我们先介绍几个函数：
1、创建套接字

int socket(int domain,int type,int protocol);
//domain:该参数一般被设置为AF_INET，表示使用的是IPv4地址。还有更多选项可以利用man查看该函数
//type:该参数也有很多选项，例如SOCK_STREAM表示面向流的传输协议，SOCK_DGRAM表示数据报，我们这里实现的是TCP，因此选用SOCK_STREAM，如果实现UDP可选SOCK_DGRAM
//protocol:协议类型，一般使用默认，设置为0

该函数用于打开一个网络通讯接口，出错则返回-1，成功返回一个socket(文件描述符)，应用进程就可以像读写文件一样调用read/write在网络上收发数据。

2、绑定

int bind(int sockfd,const struct sockaddr*addr,socklen_t addrlen);
//sockfd：服务器打开的sock
//后两个参数可以参考第四部分的介绍

服务器所监听的网络地址和端口号一般是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind来绑定一个固定的网络地址和端口号。bind成功返回0，出错返回-1。
bind()的作用：将参数sockfd和addr绑定在一起，是sockfd这个用于网络通讯的文件描述符监听addr所描述的地址和端口号。

3、监听

int listen(int sockfd,int backlog);
//sockfd的含义与bind中的相同。
//backlog参数解释为内核为次套接口排队的最大数量，这个大小一般为5~10，不宜太大（是为了防止SYN攻击）

该函数仅被服务器端使用，listen()声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接等待状态，如果收到更多的连接请求就忽略。listen()成功返回0，失败返回-1。

4、接收连接

int accept(int sockfd,struct sockaddr* addr,socklen_t* addrlen);
//addrlen是一个传入传出型参数，传入的是调用者的缓冲区cliaddr的长度，以避免缓冲区溢出问题；传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。如果给cliaddr参数传NULL，表示不关心客户端的地址。

典型的服务器程序是可以同时服务多个客户端的，当有客户端发起连接时，服务器就调用accept()返回并接收这个连接，如果有大量客户端发起请求，服务器来不及处理，还没有accept的客户端就处于连接等待状态。
三次握手完成后，服务器调用accept()接收连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。

5、请求连接

int connect(int sockfd,const struct sockaddr* addr,socklen_t addrlen);

这个函数只需要有客户端程序来调用，调用该函数后表明连接服务器，这里的参数都是对方的地址。connect()成功返回0，出错返回-1。

了解这些函数后，我们来捋一捋客户端程序和服务器程序建立连接的过程：

• 服务器：首先调用socket()创建一个套接字用来通讯，其次调用bind()进行绑定这个文件描述符，并调用listen()用来监听端口是否有客户端请求来，如果有，就调用accept()进行连接，否则就继续阻塞式等待直到有客户端连接上来。连接建立后就可以进行通信了。

• 客户端：调用socket()分配一个用来通讯的端口，接着就调用connect()发出SYN请求并处于阻塞等待服务器应答状态，服务器应答一个SYN-ACK分段，客户端收到后从connect()返回，同时应答一个ACK分段，服务器收到后从accept()返回，连接建立成功。客户端一般不调用bind()来绑定一个端口号，并不是不允许bind()，服务器也不是必须要bind()。

为什么不建议客户端进行bind()？
答：当客户端没有自己进行bind时，系统随机分配给客户端一个端口号，并且在分配的时候，操作系统会做到不与现有的端口号发生冲突。但如果自己进行bind，客户端程序就很容易出现问题，假设在一个PC机上开启多个客户端进程，如果是用户自己绑定了端口号，必然会造成端口冲突，影响通信。

进行一番理论知识后我们就可以写代码了：
“server.c”

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int startup(int _port,const char* _ip)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        exit(1);
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons( _port);
    local.sin_addr.s_addr = inet_addr(_ip);
    socklen_t len = sizeof(local);

    if(bind(sock,(struct sockaddr*)&local , len) < 0)
    {
        perror("bind");
        exit(2);
    }

    if(listen(sock, 5) < 0) //允许连接的最大数量为5
    {
        perror("listen");
        exit(3);
    }

    return sock;
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        printf("Usage:%s [loacl_ip] [loacl_port]\n",argv[0]);
        return 1;
    }

    int listen_sock = startup(atoi(argv[2]),argv[1]);//初始化

    //用来接收客户端的socket地址结构体
    struct sockaddr_in remote;
    socklen_t len = sizeof(struct sockaddr_in);

    while(1)
    {
        int sock = accept(listen_sock, (struct sockaddr*)&remote, &len);
        if(sock < 0)
        {
            perror("accept");
            continue;
        }
        printf("get a client, ip:%s, port:%d\n",inet_ntoa(remote.sin_addr),ntohs(remote.sin_port));
        char buf[1024];
        while(1)
        {
            ssize_t _s = read(sock, buf, sizeof(buf)-1);
            if(_s > 0)
            {
                buf[_s] = 0;
                printf("client:%s",buf);
            }
            else
            {
                printf("client is quit!\n");
                break;
            }
        }
    }
    return 0;
}

”client.c“

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<arpa/inet.h>
int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        printf("Usage:%s [ip] [port]\n",argv[0]);
        return 0;
    }

    //创建一个用来通讯的socket
    int sock = socket(AF_INET,SOCK_STREAM, 0);
    if(sock < 0)
    {
        perror("socket");
        return 1;
    }

    //需要connect的是对端的地址，因此这里定义服务器端的地址结构体
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t len = sizeof(struct sockaddr_in);
    if(connect(sock, (struct sockaddr*)&server, len) < 0 )
    {
        perror("connect");
        return 2;
    }
    //连接成功进行收数据
    char buf[1024];
    while(1)
    {
        printf("send###");
        fflush(stdout);
        ssize_t _s = read(0, buf, sizeof(buf)-1);
        buf[_s] = 0;
        write(sock, buf, _s);
    }
    close(sock);
    return 0;
}

但是这样实现只能进行单进程通信，也就是说每次只能使一个客户端连接上进行数据通讯，这显然不符合服务器的基本要求。我们可以想办法修改服务器端的代码，每次accept成功之后就创建一个子进程，让子进程去处理读写数据，父进程继续监听并accept。
具体代码：https://github.com/lybb/Linux/tree/master/TCP_pro

修改的代码在服务器程序的socket()和bind()之间加入了如下的代码：

int opt=1;
setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
//设置sockfd的选项为SO_REUSEADDR为1，表示允许创建端口号相同但IP不同的多个
//socket描述符

但是如果是用创建子进程的方法比较浪费资源，我们可以修改为创建线程的方法

四、sockaddr数据结构

IPv4 和 IPv6 的地址格式定义在“netinet/in.h”中，IPv4用sockaddr_in结构体表示，包括16位端口号和32位IP地址；IPv6用sockaddr_in6结构体表示，包括16位端口号、128位IP地址和一些控制字段。

UNIX Domain Socket的地址格式定义在sys/un.h中，用sockaddr_un结构体表示。

各种socket地址结构体的开头都是相同的，前16位表⽰示整个结构体的长度(并不是所有UNIX的实现都有长度字段，如Linux就没有)，后16位表示地址类型。IPv4、IPv6和UNIX Domain Socket的地 址类型分别定义为常数AF_INET、AF_INET6、AF_UNIX。

这样，只要取得某种sockaddr结构体的首地址，不需要知道具体是哪种类型的sockaddr结构体，就可以根据地址类型字段确定结构体中的内容。

因此socket API可以接受各种类型的sockaddr结构体指针做参数，例 如bind、accept、connect等函数，这些函数的参数应该设计成void 类型以便接受各种类型的指针，但是sock API的实现早于ANSI C标准化，那时还没有void 类型,因此这写函数的参数都用struct sockaddr*类型表示，在传参之前需要强制类型转换（在bind函数中就有用到）。