文章目录
1. 网络通信的理解
主机A将自己的数据交给主机B，就需要给主机B发送消息，主机B未来要给主机A回消息
但实际上 主机A将自己的数据交给主机B 并不是最终目的
如：你在淘宝上买了一件衣服，卖家发货后，从广东省发货 到 你所在的地区 ，最终包裹成功到达你的手上，你还需要决定这个快递该怎么用
数据的传送不是目的，让两台主机通过数据进行通信来协同完成任务才是目的
如：唐僧说要去西天去取经，唐僧所对应的寺庙是A主机，西天的大雷音寺是B主机，唐僧并不是到大类饮食就完了，这只是他的手段，
他还需要面见如来，如来会提供给他经书的服务
数据发起时，从主机A的传输层开始，交给主机B的传输层
而数据是从主机A的应用层中的某种客户端传来的
而将数据交给主机B的传输层不是直接目的，要把数据再交给应用层 中的某种服务器
主机A对应的客户端一定要启动起来，所以其本质是 进程
因为主机B的某种服务器在以进程的方式运行，所以可以随时随地能够访问某种服务
网络通信的本质是 进程间的通信
通信的第一个阶段：先将数据通过操作系统，将数据发送到目标主机(手段)
通信的第二个阶段：在本主机将收到的数据，推送给自己上层的指定进程
第一个阶段 可以通过TCP/IP协议完成，因为IP可以表示互联网上唯一的一台主机
当主机B的传输层把数据交给应用层，应用层对应的进程非常多
所以为了标识自己主机上网络进程的唯一性，提出了 端口号 的概念
端口号是传输层协议的字段，是一个2个字节16位的整数，用来标识系统层面上进程的唯一性
所以 IP地址 + 端口号 可以表示 互联网中唯一的一个进程
通信时，是有两个进程进行通信，所以就有源IP 和源 端口号 以及 目标IP 和目标 端口号
源IP 和源 端口号表示 互联网中唯一的一个进程
目标IP 和目标 端口号也表示 互联网中唯一的一个进程
所以 网络通信的本质 是通过IP+PORT号 构建唯一性，来进行网络进程间通信， 简称 套接字通信
2.进程PID可以取代端口号吗？
进程PID在系统层面上每个进程也是唯一的，也能表示该系统上进程的唯一性，所以用进程PID可以代替端口号的
但会存在一些问题
1.不是所有的进程都要进行网络通信，只有部分进程可能会网络通信，若用进程PID来作为网络标识该进程，就很难区分清楚那些是进行网络通信的，那些不是进行网络通信的
2. PID是操作系统进程管理的概念，网络模块也要包含进程管理的部分，要不然无法认识PID
就增加了系统当中进程管理和网络管理的耦合度
3. 认识TCP协议
TCP协议(Transmission Control Protocol) 传输控制协议
特点：
传输层协议
面向连接
在通信过程中，会自带可靠性
面向字节流
在进行发和收数据时，在TCP层没有报文的概念，收到一堆的数据，把这一堆的东西一次将给上层的应用层，也可一个字节一个字节交
字节数据如何解释TCP不关心，只关心要都多少，给你多少，最终解释信息由应用层自己解释，这种从称之为字节流
4. 认识 UDP协议
UDP协议(User Datagram Protocol)用户数据报协议
特点：
传输层协议
无连接
不可靠传输
面向数据报
如：收快递，收一个就是一个完整的快递，具体的快递不可能收半个或者一个半，若对方发了三次，你就必须收三次
5. socket编程接口
实验室做出来一套进程间通信的标准，既可在本地通信，又可以在网络跨主机通信的标准 即 socket标准 隶属于 posix标准
最常见的为 基于网络通信的套接字 sockaddr_in
预间套接字 (使用在两个进程间使用本地进程通信的) sockaddr_un
套接字的设计者为了能够让所有人以 一套接口的方式 既能本地通信 又能网络通信，
所以设计出一个公共的数据结构 叫做 struct sockaddr
若想进行网络通信 (struct sockaddr_in) 或者 进行 本地通信 (struct sockaddr_un) ，使用 sockaddr 进行强制转换即可
在结构最开始时，都要有16位的地址类型
AF_INET 与AF_UNIX 实际上都是宏，用整数来表示的
将地址进行比较判断，
若等于 AF_INET，就为网络通信，把 sockaddr强转为 sockaddr_in
若等于 AF_UNIX，就为本地通信，把 sockaddr强转为 sockaddr_un
udp_server.hpp的代码解析
通过网络协议栈的通信功能 ，来把数据交付给对方的应用层，来完成双方进程的通信
将客户端的数据交给 服务端 ，就需要给服务端发送消息，服务端再给客户端回消息
在 udp_server.hpp 中 使用namspace 将命名空间 命名为 ns_server
其中再定义一个类 udpserver
socket——创建 socket 文件描述符
输入 man socket，创建套接字
第一个参数 domain ，用于区分 进行网络通信还是 本地通信
若想为网络通信，则使用 AF_INET
若想为本地通信，则使用 AF_UNIX
第二个参数 type， 套接字对应的服务类型
SOCK_STREAM 流式套接
SOCK_DGRAM 无连接不可靠的通信(用户数据报)
第三个参数 protocol ，表示想用那种协议，协议默认为0
若为 流式套接，则系统会认为是TCP协议 ，若为用户数据报，则系统会认为是UDP协议
套接字的返回值：若成功则返回文件描述符，若失败则返回 -1
Initserver——初始化
1.创建套接字接口，打开网络文件
使用socket套接字，创建出 网络通信、UDP协议
若套接字返回-1表示失败，则初始化也就失败，程序就没有必要在继续运行了，所以使用exit终止程序
若套接字创建成功，则返回文件描述符
文件描述符的前三个分别被 标准输入 标准输出 标准错误占用，所以此时的文件描述符应该打印出3
bind——绑定的使用
输入 man 2 bind ，查看绑定
给一个套接字绑定一个名字
第一个参数 sockfd 为 文件描述符
第二个参数 addr 为 通用结构体类型
第三个参数 addrlen 为 第二个参数的实际长度大小
bind返回值：若成功，则返回0，若失败，返回 -1
2.给服务器指明IP地址和端口号
想要使用struct sockaddr_in类型 需添加头文件
定义一个 struct sockaddr_in(网络通信) 类型的 变量 local
struct sockaddr_in的理解
将 struct sockaddr_in 转到定义
16位地址类型：将 sa_prefix替换成 sin_ ，sin## family 实际上为 sin_family
此时的 sin_port 对应 当前绑定的端口号
sin_addr对应的是IP地址
再次将 in_addr转到定义，IP地址就是一个32位的整数
bzero 清空
sin_zero 作为 该结构体的填充字段
结构体可能很大，用不完，则使用填充字段将其填充上即可
输入 man bzero
将有n个字节的缓冲区，全部写为0
代码实现
将local对应的family(16位地址类型) 设置为 网络通信
设置一个私有的端口号port_
在类外设置一个端口号，用于构造时，若没有端口号传入，则8082充当缺省值
若我给你发消息，未来也需要将消息发回来，所以就必须知道我的IP地址和端口号
即端口号 以报文的形式发送到网络中
类内定义的port_，被称为本地主机序列， 需要把这个port_从主机序列 转成网络序列
输入 man htons ，表示短整数的主机转网络序列
定义一个私有的变量 ip_ 由于我们设置的IP地址是字符串风格的，而系统中的IP地址是4字节风格的 所以就需要将字符串风格的转化为 4字节风格的
inet_addr ——字符串风格转化为4字节风格
输入 man inet_addr
作用为：将字符串风格的IP地址 转化为 4字节风格的IP地址，并 默认会把主机序列 转换为 网络序列
由于local实际上定义在用户层的栈上，并没有在内核
所以借助bind，将填充好的套接字字段和文件字段，进行绑定关联，这样的文件才是网络文件
由于local 是 struct sock_addr_in 类型 ，需要强转为 struct sockaddr 公共类型
服务器自己指定IP地址
此时运行 udp_server可执行程序，会发现套接字创建成功，但绑定会失败
云服务器 不需要bind IP地址，需要让服务器自己指定IP地址
所以在main函数中添加命令行参数
命令行参数
main函数的两个参数，char* argv[] 为指针数组 ，argv为一张表，包含一个个指针，指针指向字符串
int argc，argc为数组的元素个数
设计一个usage函数，用以表示出 出现问题的可执行程序的名字 proc
再次创建一个err.hpp，使用enum枚举，将USAGE_ERR设置成1 ，默认将SOCKET_ERR(套接字报错)设置为2，
将 BIND_ERR(绑定错误)设置为3
通过argv数组的第二个下标指明字符串风格的端口号，再通过atoi将字符串转化为整数
最终只传入 端口号即可
3. 云服务器，或者一款服务器，一般不要指明某一个确定的IP
使用 INADDDR_ANY ， 让udpserver在启动的时候，bind本主机上的任意IP
将 INADDDR_ANY 转到定义，实际上为缺省的0值
start ——启动
服务器本质是一个死循环，永远不退出
如：半夜打开王者荣耀，依旧可以玩
1. 收到客户端发来的消息
recvfrom——获取用户数据报
输入 man recvfrom， 获取用户数据报
第一个参数 sockfd 为 套接字
第二个参数 buf 为 自己定义的缓冲区
第三个参数 len 为 缓冲区的长度
第四个参数 flags 为读取方式，默认设为0，以阻塞方式读取
剩余两个参数 src_addr 和 addrlen 为 输入 输出型 参数
使用recvfrom收到数据，最终还要把数据还回去，想要还回去就必须知道别人是谁
src_addr 为 作为一个结构体，内部记录客户端的IP地址和端口号
addrlen 为 输出时结构体的大小
返回值：若大于0，则读取成功
定义一个 struct sockaddr_in(网络通信) 类型的 变量 peer
使用 len 来表示 未来的结构体大小
若n大于0，则读取成功，将最后一个位置的下一个位置设为\0
若读取失败，则继续读取
peer下的IP地址为 4字节整数，需要将其转为字符串风格
inet_addr ——将4字节风格转为字符串风格
输入 man inet_addr，将4字节IP转为字符串风格的IP
peer下的端口号为网络序列，想要获取客户端的端口号 clientport，需要使用 ntohs 将网络序列转为主机序列
2.将消息发给别人
sendto
输入 man sendto
第一个参数 sockfd 为 套接字
第二个参数 buf 为 自己定义的缓冲区
第三个参数 len 为 缓冲区的长度
第四个参数 flags 为读取方式，默认设为0，以阻塞方式读取
剩余两个参数 src_addr 和 addrlen 为 输入 输出型 参数
使用recvfrom收到数据，最终还要把数据还回去，想要还回去就必须知道别人是谁
src_addr 为 将以前收到的消息转会给客户端
addrlen 为 输出时结构体的大小
返回值：若大于0，则读取成功
udp_client.cc的代码解析
第一个参数 使用 AF_INET，表示网络通信
第二个参数 使用SOCK_DRAM，表示数据报
第三个参数 默认设为0，由于上述为数据报，所以为UDP协议
客户端如何绑定？
客户端是需要绑定的
socket通信的本质 是 客户端的IP与端口号 与 服务器的IP与端口号 进行网络版本的进程间通信
但客户端是不需要自己绑定的，由操作系统自动进行绑定
如：电脑和手机充满大量客户端，这些客户端来自于不同的企业，每个客户端的端口号不可以是固定的
必须让操作系统随机去选择，本质是为了防止确定的客户端被别人去占用，减少客户端层面的冲突
所以客户端的端口号要让操作系统随机分配，防止客户端出现启动冲突
服务器为什么要自己绑定？
1.服务器的端口 是 众所周知并不能随意改变的
如：110是报警电话，不可能报警电话每天都变，否则会导致当真正想打电话时都不知道打那个
2.服务器都是一家公司的，所以端口号需要统一规范化
如：淘宝不会把自己的服务部署到知乎上
代码实现
进行while循环，向服务器发送消息
目前没有消息，所以让用户输入充当消息源
使用 sendto，将消息发送给服务端
作为客户端将消息发送给 服务器主机
想要运行 客户端 ，就需要服务器的IP 和端口号
借助命令行参数，通过用户的输入的第二个参数 作为服务器的IP
用户输入的第三个作为 服务器的端口号
虽然此时服务器的IP和端口号知道了，但是想要借助sendto，后两个参数是需要套接字结构体
新建一个结构体server，内部包含服务器的IP和端口号
使用 htons ，将主机序列转为网络序列
使用inet_addr，将字符串转化为 4字节
此时 sendto的后两个参数 添加 创建的结构体 sever ，来完成发送服务器的任务
由于server 的类型 是 struct sockaddr_in ，而参数的类型为 公共结构体类型 struct sockaddr ，所以需要强转
使用 revfrom ，获取用户数据报
收到来自服务器转回来的消息 ，所以 定义一个 temp结构体，用于接收
在首次系统调用发送数据的时候，操作系统在底层随机选择客户端的端口号 加上自己的IP
先构建bind，再构建发送的数据报文
完整代码
err.hpp (枚举错误码)
#pragma once
enum
{
USAGE_ERR=1,
SOCKET_ERR,
BIND_ERR
};
makefile
.PHONY:all
all: udp_client udp_server
udp_client:udp_client.cc
g++ -o $@ $^ -std=c++11
udp_server:udp_server.cc
g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
rm -f udp_clinet udp_server
udp_client.cc(客户端的实现，无封装)
#include"udp_client.hpp"
#include"err.hpp"
#include<cstring>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
static void usage(std::string proc)
{
std::cout<<"usage:\n\t"<<proc<<"serverip serverport\n"<< std::endl;
}
// ./udp_client serverip sevrerport
int main(int argc ,char* argv[])//命令行参数 传入的是 客户端的运行 服务器的IP和端口号
{
if(argc!=3)
{
std::cout<<" "<<std::endl;
exit( USAGE_ERR);//终止程序
}
std::string serverip = argv[1];//服务器的IP
uint16_t serverport =atoi(argv[2]);//服务器的端口号
int sock=socket(AF_INET,SOCK_DGRAM,0);
if(sock<0)//创建套接字失败
{
std::cout<<"create socket error"<<std::endl;
exit( SOCKET_ERR);
}
//明确server是谁
struct sockaddr_in server;//设置网络通信的结构体
memset(&server,0,sizeof(server)); //将结构体清空
server.sin_family=AF_INET;
server.sin_port=htons(serverport);//端口号
server.sin_addr.s_addr=inet_addr(serverip.c_str());//IP地址
while(true)
{
//用户输入
std::string message;
std::cout<< "please enter# ";
std::cin>> message;
//发送消息
sendto(sock,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));
//接收消息
char buffer[1024];
struct sockaddr_in temp;
socklen_t len=sizeof(temp);
int n=recvfrom(sock,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&temp,&len);
if(n>0)
{
buffer[n]=0;
//收到回显消息
std::cout<<"server echo"<<buffer<<std::endl;
}
}
return 0;
}
udp_clinet.hpp
#pragma once
#include<iostream>
using namespace std;
udp_server.cc (有封装)
#include"udp_server.hpp"
#include"err.hpp"
#include<memory>
#include<string>
using namespace ns_server;
using namespace std;
static void usage(string proc)
{
std::cout<<"usage:\n\t"<<proc<<"prot\n"<< std::endl;
}
//udp_server port
int main(int argc,char*argv[])//命令行参数
{
if(argc!=2)//若命令行参数个数不为2,则当前会报错
{
usage(argv[0]);
exit(USAGE_ERR);//终止程序
}
//端口号
uint16_t port=atoi(argv[1]);//atoi可将字符串转化为整数
//只需传入由用户指明的端口号
unique_ptr<UdpServer> usvr(new UdpServer (port));
usvr->Initserver();//服务器的初始化
usvr->Start();//启动服务器
return 0;
}
udp_server.hpp(服务器的实现)
#pragma once
#include<iostream>
#include<cerrno>
#include<cstring>
#include<cstdlib>
#include<strings.h>
#include<functional>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include"err.hpp"
namespace ns_server
{
const static uint16_t default_port=8082;//设置端口号为8082
class UdpServer
{
public:
UdpServer(uint16_t port=default_port)//构造
:port_(port)
{
}
void Initserver()//初始化
{
//1.创建套接字接口，打开网络文件
sock_=socket(AF_INET,SOCK_DGRAM,0);
if(sock_<0)//创建失败
{
//打印错误信息
std::cout<<" create socket error: "<<strerror(errno)<<std::endl;
exit(SOCKET_ERR);//终止程序
}
std::cout<<"create socket success:"<<sock_<<std::endl;//3
//2.给服务器指明IP地址和端口号
struct sockaddr_in local;
bzero(&local,sizeof(local));//全部置为0
local.sin_family=AF_INET;//将16位地址类型 置为 网络通信
local.sin_port= htons(port_); //主机转网络的端口号
//1.需要将字符串风格转化为 4字节
//2.需要 将主机序列转换为 网络序列
local.sin_addr.s_addr= INADDR_ANY ; //bind本机上的任意IP
//bind 绑定
int n=bind(sock_,(struct sockaddr*)&local,sizeof(local));
if(n<0)//绑定失败
{
std::cout<<" bind socket error: "<<strerror(errno)<<std::endl;
exit(BIND_ERR);
}
std::cout<<"bind socket success:"<<sock_<<std::endl;//3
}
void Start()//启动
{
char buffer[1024];//用于保护用户数据
//设置一个死循环
while(true)
{
//1.收到客户端发来的消息
struct sockaddr_in peer;
socklen_t len=sizeof(peer);//传入的缓冲区大小
int n=recvfrom(sock_,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
if(n>0)
{
buffer[n]='\0';
}
else
{
//读取失败，则继续读取
continue;
}
//提取客户端信息
//4字节IP转为 字符串IP
std::string clientip =inet_ntoa(peer.sin_addr);//客户端IP
//将网络序列转换为主机序列
uint16_t clientport =ntohs(peer.sin_port);//客户端 端口号
std::cout<<clientip<<"-"<<clientport<<"-"<<"get message# "<<buffer<<std::endl;
//2.将消息发给别人
sendto(sock_,buffer,strlen(buffer),0,(struct sockaddr*)&peer,sizeof(peer));
}
}
~UdpServer()//析构
{
}
private:
int sock_; //文件描述符
uint16_t port_;//端口号
};
}