网络基础（2）

- 1. 端口号
- 2. 套接字socket
- 3. 网络通信
- - 3.1 sockaddr与sockaddr_in
  - 3.2 接口
  - - 服务端
    - 3.2.1 创建套接字，打开网络文件
    - 3.2.2 给该服务器绑定端口和ip（特殊处理）
    - 3.2.3 初始化相关服务器
    - 3.2.4 提供服务
    - 客户端
    - 3.2.5 绑定
    - 3.2.6 使用服务
- 4. makefile实现：
- 5. 整体代码

1. 端口号

IP能够唯一地标识互联网中的一台主机；而端口号能够唯一地标识一台机器上的唯一一个进程。

那么这两个因素加起来，就构成了能够标识互联网上的唯一一个进程。这就是端口号与IP的联系。

2. 套接字socket

整个网络看作是一个大的OS，所有网络上网行为，都是在这里面实现进程间通信的。

IP地址+port端口号 = socket

端口号之于进程PID，就相当于身份证号之于学生学号。

为什么有了PID，在网络里还需要端口号来进行标识？

这就好比学校不用身份证来对学生信息进行管理、录入。因为学校内部会有更合适的管理系统，采用自己一套的管理方式能够使管理更加得心应手，也不惧怕外部环境的改变，实现与外部解耦。PID和端口号也是这个原理。

3. 网络通信

3.1 sockaddr与sockaddr_in

要实现网络通信，首先是要找到目标主机，其次是找到该主机上的目标进程。

而进程具有独立性，要实现网络通信需要让两个进程看到同一份资源，这份资源就是网络。

应用层的下一层就是传输层，传输层有TCP/UDP协议。

统一接口

对于将要介绍的sock接口，要先说明一个概念，就是sockarr结构：由于各种网络协议的实现方式不同，导致接口需要对应设计，所以干脆就设计出来了一个通用的接口，该参数统一为sockaddr。

socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4、IPv6,以及UNIX DomainSocket。然而, 各种网络协议的地址格式并不相同。

目前我们采用的是struct sockaddr，这是一个通用接口，也即是说，可以兼容后两个接口类型的参数。

通用接口与其他两个不同协议的接口：

在这里插入图片描述

虽然socket api的接口是sockaddr, 但是我们真正在基于IPv4编程时, 使用的数据结构是sockaddr_in; 这个结构里主要有三部分信息: 地址类型, 端口号, IP地址。

sockaddr与sockaddr_in其实都是结构体类型：

sockaddr

它把目标地址和端口信息实现在一起：

struct sockaddr{
	sa_family_t sin_family;//16位地址类型家族
	char sa_data[14];
	//14位长度地址数据,包含套接字中的目标地址和端口信息
}

sockaddr_in

sockaddr_in的头文件包含在：

#include <netinet/in.h>
#include <arpa/inet.h>

该结构体解决了sockaddr的缺陷，把port和addr 分开储存在两个变量中，如下

typedef uint16_t in_port_t;//十六位数字

struct sockaddr_in{
	sa_family_t   sin_family;//16位地址类型家族
	in_port_t sin_port;//16位端口号
	struct in_addr    sin_addr;//32位ip地址
	unsigned char sin_zero;//未使用
}

in_addr其实就是32位的IPv4地址：

typedef uint32_t in_addr_t;

struct in_addr{
	In_addr_t  s_addr;    //32位IPv4地址
};

sockaddr_un

struct sockaddr_un{
	//16位地址类型
	//108字节路径名
}

IPv4、IPv6地址类型分别定义为常数AF_INET、AF_INET6. 这样,只要取得某种sockaddr结构体的首地址,不需要知道具体是哪种类型的sockaddr结构体,就可以根据地址类型字段确定结构体中的内容。

socket API可以都用struct sockaddr * 类型表示, 在使用的时候需要强制转化成sockaddr_in; 这样的好处是程序的通用性, 可以接收IPv4, IPv6, 以及UNIX Domain Socket各种类型的sockaddr结构体指针做为参数。

3.2 接口

服务端

3.2.1 创建套接字，打开网络文件

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);

参数：

domain就是用来区分传入的是哪个协议种类。

type代表协议特性，是套接字类型。比如流式套结、原始套结等。

proyocol在tcp中只需要全部设置为0。

返回值：创建成功后，新的套接字会返回一个文件描述符。

#include <iostream>
#include <cerrno>
int main()
{
    int sock = socket(AF_INET,SOCK_DGRAM,0);
    if(sock < 0){
        std::cout<<"socket create error!"<<errno<<std::endl;
        return 1;
    }
    std::cout<<"sock:"<<sock<<std::endl;
    return 0;
}

运行结果：

在这里插入图片描述

3.2.2 给该服务器绑定端口和ip（特殊处理）

作为一个服务器，对应的服务器地址（IP+port）是必须要被客户（人、软件、浏览器）所知晓的，并且不能轻易地被改变。

首先要绑定端口号

// 绑定端口号 (TCP/UDP, 服务器)
int bind(int sockfd, const struct sockaddr *addr,
socklen_t address_len);

参数

sockfd代表创建好的套接字的文件描述符；addr代表需要用户指定服务器的相关socket信息，address_len代表传入的结构体大小。

返回值

绑定成功返回0，失败返回-1，也可以是错误码。

3.2.3 初始化相关服务器

这里的参数addr是相关服务器的信息，所以要bind，就要先初始化好addr的信息：

首先定义一个sockaddr_in类型的结构体，因为我们平时传的addr其实是sockaddr_in类型的，只需要在绑定的时候做一下强转即可。

那么接下来就是将它里面的对应字段全部初始化：

const uint16_t port = 8080;
struct sockaddr_in local;
local.sin_family = AF_INET; //IPV4
local.sin_port = htons(port); //该端口号是主机序列，要改成网络序列
local.sin_addr.s_addr = INADDR_ANY;

其中port是主机序列，需要转为网络序列，使用的是htons函数：

h是host代表主机，n代表network网络：

在这里插入图片描述

剩下最后一个字段初始化为INADDR_ANY的意思是：由该服务器发送的，到任意主机（IP）上的数据都能被你的网络进程接收。

如果不这样初始化，而是绑定了确定的IP，例如：

//inet_addr函数将地址从数点法转化为整数IP
//网络需要的是整数表示IP而不是数点法表示的地址
local.sin_addr.s_addr = inet_addr("xx.xxx.xx.xxx");

这样的话，只有发送到该IP的数据才能被你进程接收，所以一般不这么写。

并且云服务器不直接绑定公网IP。

然后就可以进行绑定：

if(bind(sock,(struct sockaddr*)&lockal,sizeof(local)) < 0){
    std::cout << "bind error : " << errno << std::endl;
    return 2;
}

3.2.4 提供服务

绑定完成以后，等待他人给自己的服务器发送信息，是接收的过程。

recvfrom

udp的数据读取不是用文件的接口，而是有专门的接口recvfrom：

在这里插入图片描述

参数：分别是自身套接字fd、读完的数据放到buf、读len大小、读的方式flag（默认0），剩下最后两个代表的是和你的服务器通信的客户端的信息，是一个输出型参数，作用是如需要返回数据给它，就可以拿到其地址返回。

sendto

给对端发信息，用的是sendto

其他参数都一样，最后两个参数代表的是要给谁发：

在这里插入图片描述

由此可以提供服务：

// 3. 提供服务
#define NUM 1024
char buffer[NUM];
bool quit = false;
while(!quit){
    struct sockaddr_in send;
    socklen_t len = sizeof(send);
    //开始读
    recvfrom(sock,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&send,&len);
    std::cout << "client" << buffer << std::endl;
    //收到以后回复hello
    std::string echo = "hello";
    sendto(sock,echo.c_str(),echo.size(),0,(struct sockaddr*)&send,len);
    }

客户端

3.2.5 绑定

客户端不需要显示绑定。

对于客户端来说，也必须要有套接字，但是它不需要显示绑定。因为一旦绑定了，它就要和某一个端口关联了，该端口不一定会存在，或者被占用，那么该客户端将无法使用。

对于服务端来说，端口必须要明确，并且不能变更；而对于客户端，只要有端口就行，因为是客户端访问他人。所以客户端一般都是由OS在发送数据的时候自动绑定，采用的是随机端口。

// 1. 创建
int sockfd = socket(AF_INET,SOCK_DGRAM,0);
if(sockfd < 0){
    std::cout<<"socket create error!"<<errno<<std::endl;
    return 1;
}
std::cout<<"sock:"<<sockfd<<std::endl;

3.2.6 使用服务

实现基本和服务端一样，但是由于自定义遵守./udp_client server_ip server_port的格式，所以要用到命令行参数来规范行为，不规范的话会打印使用手册。

void Usage(std::string proc)
{
    std::cout << "Usage: \n\t"<< proc << " server_ip server_port" << std::endl;
}
int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 0;
    }
    // 1. 创建
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd < 0){
        std::cout<<"socket create error!"<<errno<<std::endl;
        return 1;
    }
    std::cout<<"client:sock:"<<sockfd<<std::endl;
    //客户端也必须要有套接字
    //不需要显示bind
    // 2. 使用服务
    // ./udp_client server_ip server_port的格式
    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]);
    while(1){
        // 1. 数据来源 
        std::string s;
        std::cout<<"输入# ";
        std::cin>>s;
        // 2. 发给谁
        sendto(sockfd,s.c_str(),s.size(),0,(struct sockaddr*)&server,sizeof(server));
        //此处tmp就是一个”占位符“
        struct sockaddr_in tmp;
        socklen_t len = sizeof(tmp);
        char buffer[1024];
        recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&tmp, &len);
    std::cout << "server echo# " << buffer << std::endl;
    }
    return 0; 
}

由于云服务器需要手动在后台开通窗口才可通信，所以IP使用127.0.0.1来测试

下列运行结果：

客户端：
在这里插入图片描述

服务端：

在这里插入图片描述

4. makefile实现：

.PHONY:all
all:udp_server udp_client

udp_server:udp_server.cc
	g++ -o $@ $^ -std=c++11

udp_client:udp_client.cc
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -f udp_server udp_client

5. 整体代码

服务端：

#include <netinet/in.h>
#include <arpa/inet.h>
#include <iostream>
#include <cerrno>

const uint16_t port = 8080;
int main()
{
    // 1. 创建套接字，打开网络文件
    int sock = socket(AF_INET,SOCK_DGRAM,0);
    if(sock < 0){
        std::cout<<"socket create error!"<<errno<<std::endl;
        return 1;
    }
    std::cout<<"server:sock:"<<sock<<std::endl;
    
    // 2. 给该服务器绑定端口和ip
    struct sockaddr_in local;
    local.sin_family = AF_INET; //IPV4
    local.sin_port = htons(port); //该端口号是主机序列，要改成网络序列
    local.sin_addr.s_addr = INADDR_ANY;

    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0){
        std::cout << "bind error : " << errno << std::endl;
        return 2;
    }
    // 3. 提供服务
    #define NUM 1024
    char buffer[NUM];
    bool quit = false;
    while(!quit){
        struct sockaddr_in send;
        socklen_t len = sizeof(send);
        recvfrom(sock,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&send,&len);
        std::cout << "client say# " << buffer << std::endl;
        //收到以后回复hello
        std::string echo = "hello";
        sendto(sock,echo.c_str(),echo.size(),0,(struct sockaddr*)&send,len);
    }
    return 0;
}

客户端：

#include <iostream>
#include <string>
#include <cerrno>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>

//正确用法
// ./udp_client server_ip server_port的格式
void Usage(std::string proc)
{
    std::cout << "Usage: \n\t"<< proc << " server_ip server_port" << std::endl;
}
int main(int argc,char* argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        return 0;
    }
    // 1. 创建
    int sockfd = socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd < 0){
        std::cout<<"socket create error!"<<errno<<std::endl;
        return 1;
    }
    std::cout<<"client:sock:"<<sockfd<<std::endl;
    //客户端也必须要有套接字
    //不需要显示bind
    // 2. 使用服务
    // ./udp_client server_ip server_port的格式
    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]);
    while(1){
        // 1. 数据来源 
        std::string s;
        std::cout<<"输入# ";
        std::cin>>s;
        // 2. 发给谁
        sendto(sockfd,s.c_str(),s.size(),0,(struct sockaddr*)&server,sizeof(server));
        //此处tmp就是一个”占位符“
        struct sockaddr_in tmp;
        socklen_t len = sizeof(tmp);
        char buffer[1024];
        recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&tmp, &len);
    std::cout << "server echo# " << buffer << std::endl;
    }
    return 0; 
}