源IP地址(Source IP Address):
源IP地址是数据包发送方(或数据流出发点)的唯一标识符。它用于在互联网或本地网络中定位发送数据包的设备或主机。源IP地址是数据包的出发点,即数据从这个地址开始传送,向目的IP地址指示的设备发送。
在TCP/IP协议中,源IP地址通常由发送方的操作系统或网络栈分配,并在数据包的IP首部中进行标记。
目的IP地址(Destination IP Address):
目的IP地址是数据包的接收方(或数据流的目标点)的唯一标识符。它用于在互联网或本地网络中定位接收数据包的设备或主机。目的IP地址是数据包的终点,即数据传输的目标地址,数据包应该传输到这个地址。
在TCP/IP协议中,目的IP地址通常由应用程序或网络栈设置,并在数据包的IP首部中进行标记。
这两个地址在数据包传输过程中起着非常重要的作用,确保数据从源设备正确地传递到目标设备,实现网络通信。IP地址是一个32位的二进制数,通常用点分十进制表示(例如,192.168.0.1),其中前24位表示网络地址,后8位表示主机地址。
端口号(port)是传输层协议的内容.
端口号是一个2字节16位的整数;
端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;
IP地址 + 端口号能够标识网络上的某一台主机的某一个进程;
一个端口号只能被一个进程占用.
端口号:
端口号是在计算机网络中用于标识特定进程或服务的数字。 它是一个16位的无符号整数,取值范围是0到65535。
在TCP/IP网络中,每个传输控制协议(TCP)和用户数据报协议(UDP)的通信端点都与一个端口号相关联。 这样,计算机上的不同进程或服务可以通过不同的端口号进行通信,从而实现多个应用程序的并发运行。
例如,HTTP服务通常使用端口号80,HTTPS使用端口号443,SMTP使用端口号25等。
进程ID:
进程ID是操作系统中用于标识运行中进程(或线程)的唯一标识符。 它是一个非负整数,通常由操作系统在进程创建时分配。
在多任务操作系统中,每个运行中的进程都有一个唯一的进程ID,操作系统通过进程ID来跟踪和管理不同的进程。
进程ID的范围通常由操作系统定义,可以是一个较小的数值范围,也可以是一个较大的范围。
区别:
端口号是在计算机网络中用于标识不同进程或服务的通信端点,用于实现多个应用程序的并发运行。 进程ID是操作系统中用于标识运行中进程的唯一标识符,用于跟踪和管理不同的进程。
端口号是在网络通信中使用的,而进程ID是在操作系统层级使用的。
端口号是一个16位的数字,进程ID是一个非负整数。
传输层协议
有连接
可靠传输
面向字节流
传输层协议
无连接
不可靠传输
面向数据报
网络字节序是一种在计算机网络中使用的固定字节顺序,用于在不同计算机体系结构和操作系统之间传递数据。 在计算机内部,不同的体系结构(例如x86、ARM、SPARC等)和操作系统(例如Windows、Linux、iOS等)可能使用不同的字节顺序,这可能导致在网络通信中出现问题。
为了解决这个问题,网络通信中使用了统一的字节顺序,即网络字节序。 网络字节序采用大端字节序(Big-Endian)表示法,其中较高的字节位于较低的内存地址上,较低的字节位于较高的内存地址上。
举例说明:
假设一个16位整数0x1234(十进制为4660)在内存中存储为两个字节:0x12和0x34。
在大端字节序中,较高的字节(0x12)存储在较低的内存地址,较低的字节(0x34)存储在较高的内存地址。 即内存地址由高到低,数据依次为0x12 0x34。
在小端字节序中,较低的字节(0x34)存储在较低的内存地址,较高的字节(0x12)存储在较高的内存地址。 即内存地址由高到低,数据依次为0x34 0x12。
在网络通信中,发送方将数据转换为网络字节序后发送,接收方收到数据后将其转换为本地字节序进行处理,以保证在不同计算机体系结构和操作系统之间正确地传递数据。 常用的网络编程库(例如Socket编程)通常会自动处理字节序的转换。
Socket(套接字)是一种用于网络通信的编程接口,它允许计算机之间通过网络传输数据。 在Socket编程中,我们可以使用一组API函数来创建、绑定、连接、发送和接收数据等操作。
使用Socket API时,通常的流程是创建一个套接字、绑定到一个地址和端口(可选)、监听连接请求(可选)、接受连接请求、发送和接收数据,最后关闭套接字。 服务器端和客户端使用不同的套接字操作,服务器端用于监听连接请求和处理客户端请求,而客户端用于建立连接和发送请求给服务器端。
sockaddr 是一个通用的套接字地址结构,在Socket编程中经常用于存储网络地址信息。由于不同的协议族(IPv4、IPv6等)具有不同的地址结构,因此 sockaddr 用作地址结构的基类,而实际使用时通常会使用具体的子结构 sockaddr_in(IPv4)或 sockaddr_in6(IPv6)。
struct sockaddr {
sa_family_t sa_family; // 地址族,通常为 AF_INET 或 AF_INET6
char sa_data[14]; // 存放地址信息的缓冲区,不同协议族具有不同的结构
};
在实际使用时,通常会将 sockaddr 结构转换为适合当前协议族的具体地址结构。例如,在IPv4协议中,使用 sockaddr_in 结构,其定义如下:
struct sockaddr_in {
sa_family_t sin_family; // 地址族,固定为 AF_INET
in_port_t sin_port; // 16位端口号,使用网络字节序
struct in_addr sin_addr; // 32位IPv4地址,使用网络字节序
char sin_zero[8]; // 不使用,填充字段
};
在IPv6协议中,使用 sockaddr_in6 结构,其定义如下:
struct sockaddr_in6 {
sa_family_t sin6_family; // 地址族,固定为 AF_INET6
in_port_t sin6_port; // 16位端口号,使用网络字节序
uint32_t sin6_flowinfo; // 流标识,通常为0
struct in6_addr sin6_addr; // 128位IPv6地址,使用网络字节序
uint32_t sin6_scope_id; // 接口范围标识
};
在使用 结构时,通常需要进行类型转换,将其转换为适用于当前协议族的地址结构,并根据需要填充具体的地址信息,然后传递给套接字相关的函数使用。
sockaddr_in 是用于存储IPv4地址的套接字地址结构,是在网络编程中非常常用的结构。它用于在IPv4协议族中表示网络地址和端口号。下面是 sockaddr_in 结构的定义:
struct sockaddr_in {
sa_family_t sin_family; // 地址族,固定为 AF_INET
in_port_t sin_port; // 16位端口号,使用网络字节序
struct in_addr sin_addr; // 32位IPv4地址,使用网络字节序
char sin_zero[8]; // 不使用,填充字段
};
其中,各字段的含义如下:
sin_family:地址族,固定为 AF_INET,表示IPv4地址族。
sin_port:16位端口号,使用网络字节序,需要使用 htons 函数进行字节序转换。
sin_addr:32位IPv4地址,使用网络字节序,需要使用 inet_pton 函数将点分十进制形式的IPv4地址转换为网络字节序。
sin_zero:不使用,填充字段,通常设置为0。
使用 结构时,通常先将IPv4地址和端口号填充到该结构中,然后将其转换为通用的 sockaddr_insockaddr 结构,在套接字相关的函数中使用。
例如,在服务器端绑定一个IPv4地址和端口号,可以这样做:
#include
#include
#include
int main() {
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket");
return -1;
}
struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8080); // 将端口号转换为网络字节序
inet_pton(AF_INET, "127.0.0.1", &server_addr.sin_addr); // 将IPv4地址转换为网络字节序
memset(server_addr.sin_zero, 0, sizeof(server_addr.sin_zero));
if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("bind");
close(sockfd);
return -1;
}
// 其他操作...
close(sockfd);
return 0;
}
注意,在使用 sockaddr_in 结构时,需要包含
#pragma once
#include
#include
#include
#include
#include
#include
#include
#define DEBUG 0
#define NOTICE 1
#define WARINING 2
#define FATAL 3
const char *log_level[]={"DEBUG", "NOTICE", "WARINING", "FATAL"};
// logMessage(DEBUG, "%d", 10);
void logMessage(int level, const char *format, ...)
{
assert(level >= DEBUG);
assert(level <= FATAL);
char *name = getenv("USER");
char logInfo[1024];
va_list ap; // ap -> char*
va_start(ap, format);
vsnprintf(logInfo, sizeof(logInfo)-1, format, ap);
va_end(ap); // ap = NULL
FILE *out = (level == FATAL) ? stderr:stdout;
fprintf(out, "%s | %u | %s | %s\n", \
log_level[level], \
(unsigned int)time(nullptr),\
name == nullptr ? "unknow":name,\
logInfo);
// char *s = format;
// while(s){
// case '%':
// if(*(s+1) == 'd') int x = va_arg(ap, int);
// break;
// }
}
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
struct sockaddr_in server;
static void Usage(std::string name)
{
std::cout << "Usage:\n\t" << name << " server_ip server_port" << std::endl;
}
void *recverAndPrint(void *args)
{
while (true)
{
int sockfd = *(int *)args;
char buffer[1024];
struct sockaddr_in temp;
socklen_t len = sizeof(temp);
ssize_t s = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&temp, &len);
if (s > 0)
{
buffer[s] = 0;
std::cout << "server echo# " << buffer << std::endl;
}
}
}
// ./udpClient server_ip server_port
// 如果一个客户端要连接server必须知道server对应的ip和port
int main(int argc, char *argv[])
{
if (argc != 3)
{
Usage(argv[0]);
exit(1);
}
// 1. 根据命令行,设置要访问的服务器IP
std::string server_ip = argv[1];
uint16_t server_port = atoi(argv[2]);
// 2. 创建客户端
// 2.1 创建socket
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
assert(sockfd > 0);
// 2.2 client 需不需要bind??? 需要bind,但是不需要用户自己bind,而是os自动给你bind
// 所谓的"不需要",指的是: 不需要用户自己bind端口信息!因为OS会自动给你绑定,你也最好这么做!
// 如果我非要自己bind呢?可以!严重不推荐!
// 所有的客户端软件 <-> 服务器 通信的时候,必须得有 client[ip:port] <-> server[ip:port]
// 为什么呢??client很多,不能给客户端bind指定的port,port可能被别的client使用了,你的client就无法启动了
// 那么server凭什么要bind呢??server提供的服务,必须被所有人知道!server不能随便改变!
// 2.2 填写服务器对应的信息
bzero(&server, sizeof server);
server.sin_family = AF_INET;
server.sin_port = htons(server_port);
server.sin_addr.s_addr = inet_addr(server_ip.c_str());
pthread_t t;
pthread_create(&t, nullptr, recverAndPrint, (void *)&sockfd);
// 3. 通讯过程
std::string buffer;
while (true)
{
std::cerr << "Please Enter# ";
std::getline(std::cin, buffer);
// 发送消息给server
sendto(sockfd, buffer.c_str(), buffer.size(), 0,
(const struct sockaddr *)&server, sizeof(server)); // 首次调用sendto函数的时候,我们的client会自动bind自己的ip和port
}
close(sockfd);
return 0;
}
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "log.hpp"
static void Usage(const std::string porc)
{
std::cout << "Usage:\n\t" << porc << " port [ip]" << std::endl;
}
class udpServer
{
public:
udpServer(int port, std::string ip = "") : port_((uint16_t)port), ip_(ip), sockfd_(-1)
{
}
~udpServer()
{
}
void init()//初始化函数
{
//1.创建套接字
sockfd_=socket(AF_INET,SOCK_DGRAM,0);
// 参数1:套接字的协议族 `AF_INET`: IPv4协议族,用于Internet地址。
//参数2:套接字类型 `SOCK_DGRAM`: 面向消息的套接字,用于不可靠的、固定长度的数据传输(如UDP)。
//参数3:套接字的协议 0,让系统自动选择合适的协议。
if(sockfd_<0) //创建失败 打印日志信息
{
logMessage(FATAL, "socket:%s:%d", strerror(errno), sockfd_);
exit(1);
}
//到这说明 创建成功
logMessage(DEBUG, "socket create success: %d", sockfd_);
struct sockaddr_in local; // local在哪里开辟的空间? 用户栈 -> 临时变量 -> 写入内核中
bzero(&local, sizeof(local)); // memset
// 填充协议家族,域
local.sin_family = AF_INET;
// 填充服务器对应的端口号信息,一定是会发给对方的,port_一定会到网络中
local.sin_port = htons(port_);
// 服务器都必须具有IP地址,"xx.yy.zz.aaa",字符串风格点分十进制 -> 4字节IP -> uint32_t ip
// INADDR_ANY(0): 程序员不关心会bind到哪一个ip, 任意地址bind,强烈推荐的做法,所有服务器一般的做法
// inet_addr: 指定填充确定的IP,特殊用途,或者测试时使用,除了做转化,还会自动给我们进行 h—>n
local.sin_addr.s_addr = ip_.empty() ? htonl(INADDR_ANY) : inet_addr(ip_.c_str());
// 2.2 bind 网络信息
if (bind(sockfd_, (const struct sockaddr *)&local, sizeof(local)) == -1)
{
logMessage(FATAL, "bind: %s:%d", strerror(errno), sockfd_);
exit(2);
}
logMessage(DEBUG, "socket bind success: %d", sockfd_);
// done
}
void start()
{
// 服务器设计的时候,服务器都是死循环
char inbuffer[1024]; //将来读取到的数据,都放在这里
char outbuffer[1024]; //将来发送的数据,都放在这里
while (true)
{
struct sockaddr_in peer; //输出型参数
socklen_t len = sizeof(peer); //输入输出型参数
// demo2
// UDP无连接的
// 对方给你发了消息,你想不想给对方回消息?要的!后面的两个参数是输出型参数
ssize_t s = recvfrom(sockfd_, inbuffer, sizeof(inbuffer) - 1, 0,
(struct sockaddr *)&peer, &len);
if (s > 0)
{
inbuffer[s] = 0; //当做字符串
}
else if (s == -1)
{
logMessage(WARINING, "recvfrom: %s:%d", strerror(errno), sockfd_);
continue;
}
// 读取成功的,除了读取到对方的数据,你还要读取到对方的网络地址[ip:port]
std::string peerIp = inet_ntoa(peer.sin_addr); //拿到了对方的IP
uint32_t peerPort = ntohs(peer.sin_port); // 拿到了对方的port
checkOnlineUser(peerIp, peerPort, peer); //如果存在,什么都不做,如果不存在,就添加
// 打印出来客户端给服务器发送过来的消息
logMessage(NOTICE, "[%s:%d]# %s", peerIp.c_str(), peerPort, inbuffer);
// for(int i = 0; i < strlen(inbuffer); i++)
// {
// if(isalpha(inbuffer[i]) && islower(inbuffer[i])) outbuffer[i] = toupper(inbuffer[i]);
// else outbuffer[i] = toupper(inbuffer[i]);
// }
messageRoute(peerIp, peerPort,inbuffer); //消息路由
// 线程池!
// sendto(sockfd_, outbuffer, strlen(outbuffer), 0, (struct sockaddr*)&peer, len);
// demo1
// logMessage(NOTICE, "server 提供 service 中....");
// sleep(1);
}
}
void checkOnlineUser(std::string &ip, uint32_t port, struct sockaddr_in &peer)
{
std::string key = ip;
key += ":";
key += std::to_string(port);
auto iter = users.find(key);
if(iter == users.end())
{
users.insert({key, peer});
}
else
{
// iter->first, iter->second->
// do nothing
}
}
void messageRoute(std::string ip, uint32_t port, std::string info)
{
std::string message = "[";
message += ip;
message += ":";
message += std::to_string(port);
message += "]# ";
message += info;
for(auto &user : users)
{
sendto(sockfd_, message.c_str(), message.size(), 0, (struct sockaddr*)&(user.second), sizeof(user.second));
}
}
private:
// 服务器必须得有端口号信息
uint16_t port_;
// 服务器必须得有ip地址
std::string ip_;
// 服务器的socket fd信息
int sockfd_;
// onlineuser
std::unordered_map<std::string, struct sockaddr_in> users;
};
int main(int argc, char *argv[])
{
if (argc != 2 && argc != 3) //反面:argc == 2 || argc == 3
{
Usage(argv[0]);
exit(3);
}
uint16_t port = atoi(argv[1]);
std::string ip;
if (argc == 3)
{
ip = argv[2];
}
udpServer svr(port, ip);
svr.init();
svr.start();
return 0;
}
.PHONY:all
all:udpClient udpServer
udpClient: UCPClient.cc
g++ -o $@ $^ -std=c++11 -lpthread
udpServer:UDPServer.cc
g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
rm -f udpClient udpServer
设置对对应的端口号就行