Socket套接字类实现(模块二)
目录
类功能
类设计
类实现
测试
测试服务器
测试客户端
测试结果
类功能
这一节相当于整合了之前的一些东西，重新过了一遍，这个就显得相对之前的版本更加完善一点
类设计
// 套接字类
#define MAX_LISTEN 1024
class Socket
{
private:
int _sockfd;
public:
Socket();
Socket(int fd);
~Socket();
// 创建套接字
bool Create();
// 绑定地址信息
bool Bind(const std::string &ip, uint64_t port);
// 开始监听
bool Listen(int backlog = MAX_LISTEN);
// 向服务器发起连接
bool Connect(const std::string &ip, uint64_t port);
// 获取新连接
int Accept();
// 接收数据
ssize_t Recv(void* buf, size_t len, int flag = 0); // 0 阻塞
// 发送数据
ssize_t Send(void* buf, size_t len, int flag = 0);
// 关闭套接字
void Close();
// 创建一个服务器连接
bool CreateServer(uint64_t port, const std::string &ip = "0.0.0.0"); // 接收全部
// 创建一个客户端连接
bool CreateClient(uint64_t port, const std::string &ip);
// 设置套接字选项 -- 开启地址端口重用
void ReuseAddress();
// 设置套接字阻塞属性 -- 设置为非阻塞
void NonBlock();
}; 类实现
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG
#define LOG(level, format, ...) \
do \
{ \
if (level < LOG_LEVEL) \
break; \
time_t t = time(nullptr); \
struct tm *ltm = localtime(&t); \
char tmp[32] = {0}; \
strftime(tmp, 31, "%H:%M:%S", ltm); \
fprintf(stdout, "[%s %s:%d] " format "\n", tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
} while (0)
#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)
// 缓冲区类
#define BUFFER_DEFAULT_SIZE 1024 // Buffer 默认起始大小
class Buffer
{
private:
std::vector _buffer; // 使用vector进行内存空间管理
uint64_t _reader_idx; // 读偏移
uint64_t _writer_idx; // 写偏移
public:
Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
char *Begin() { return &*_buffer.begin(); }
// 获取当前写入起始地址
char *WirtePosition() { return Begin() + _writer_idx; }
// 获取当前读取起始地址
char *ReadPosition() { return Begin() + _reader_idx; }
// 获取缓冲区末尾空闲空间大小--写偏移之后的空闲空间, 总体空间大小减去写偏移
uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
// 获取缓冲区起始空闲空间大小--读偏移之前的空闲空间
uint64_t HeadIdleSize() { return _reader_idx; }
// 获取可读数据大小 = 写偏移 - 读偏移
uint16_t ReadAbleSize() { return _writer_idx - _reader_idx; };
// 将读偏移向后移动
void MoveReadOffset(uint64_t len)
{
// 向后移动的大小, 必须小于可读数据大小
assert(len <= ReadAbleSize());
_reader_idx += len;
}
// 将写偏移向后移动
void MoveWriteOffset(uint64_t len)
{
// 向后移动的大小,必须小于当前后边的空闲空间大小
assert(len <= TailIdleSize());
_writer_idx += len;
}
// 确保可写空间足够(整体空闲空间够了就移动数据,否则就扩容)
void EnsureWriteSpace(uint64_t len)
{
// 如果末尾空闲空间大小足够,直接返回
if (len <= TailIdleSize())
{
return;
}
// 末尾空闲空间不够,则判断加上起始位置的空闲空间大小是否足够,够了就将数据移动到起始位置
if (len <= TailIdleSize() + HeadIdleSize())
{
// 将数据移动到起始位置
uint64_t rsz = ReadAbleSize(); // 把当前数据大小先保存起来
std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
_reader_idx = 0; // 将读偏移归0
_writer_idx = rsz; // 将写位置置为可读数据大小, 因为当前的可读数据大小就是写偏移量
}
else
{
// 总体空间不够,则需要扩容,不移动数据,直接给写偏移之后扩容足够空间即可
_buffer.resize(_writer_idx + len);
}
}
// 写入数据
void Write(const void *data, uint64_t len)
{
// 1.保证有足够空间， 2.拷贝数据进去
EnsureWriteSpace(len);
const char *d = (const char *)data;
std::copy(d, d + len, WirtePosition());
}
void WirteAndPush(const void *data, uint64_t len)
{
Write(data, len);
MoveWriteOffset(len);
}
void WriteString(const std::string &data)
{
return Write(data.c_str(), data.size());
}
void WriteStringAndPush(const std::string &data)
{
WriteString(data);
MoveWriteOffset(data.size());
}
void WriteBuffer(Buffer &data)
{
return Write(data.ReadPosition(), data.ReadAbleSize());
}
void WirteBufferAndPush(Buffer &data)
{
WriteBuffer(data);
MoveWriteOffset(data.ReadAbleSize());
}
// 读取数据
void Read(void *buf, uint64_t len)
{
// 要求获取的数据大小必须小于可读数据大小
assert(len <= ReadAbleSize());
std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
}
void ReadAndPop(void *buf, uint64_t len)
{
Read(buf, len);
MoveReadOffset(len);
}
std::string ReadAsString(uint64_t len)
{
// 要求获取的数据大小必须小于可读数据大小
assert(len <= ReadAbleSize());
std::string str;
str.resize(len);
Read(&str[0], len); // 这里不直接用str.c_str()的原因是，这个的返回值是const类型
return str;
}
std::string ReadAsStringAndPop(uint64_t len)
{
assert(len <= ReadAbleSize());
std::string str = ReadAsString(len);
MoveReadOffset(len);
return str;
}
char *FindCRLF()
{
char *res = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
return res;
}
// 这种情况针对的是,通常获取一行数据
std::string GetLine()
{
char *pos = FindCRLF();
if (pos == nullptr)
return "";
// +1 是为了把换行字符也取出来
return ReadAsString(pos - ReadPosition() + 1);
}
std::string GetLineAndPop()
{
std::string str = GetLine();
MoveReadOffset(str.size());
return str;
}
// 清空缓冲区
void Clear()
{
// 只需要将偏移量归0即可
_reader_idx = 0;
_writer_idx = 0;
}
};
// 套接字类
#define MAX_LISTEN 1024
class Socket
{
private:
int _sockfd;
public:
Socket() : _sockfd(-1) {}
Socket(int fd) : _sockfd(fd) {}
~Socket() { Close(); };
// 创建套接字
bool Create()
{
// int socket(int domain, int type, int protocol)
_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (_sockfd < 0)
{
ERR_LOG("CREATE SOCKET FAILED!");
return false;
}
return true;
}
// 绑定地址信息
bool Bind(const std::string &ip, uint64_t port)
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());
socklen_t len = sizeof(struct sockaddr_in);
// int bind(int sockfd, struct sockaddr* addr, socklen_t len)
int ret = bind(_sockfd, (struct sockaddr *)&addr, len);
if (ret < 0)
{
ERR_LOG("BIND ADDRESS FAILED!");
return false;
}
return true;
}
// 开始监听
bool Listen(int backlog = MAX_LISTEN)
{
// int listen(int backlog)
int ret = listen(_sockfd, backlog);
if (ret < 0)
{
ERR_LOG("SOCKET LISTEN FAILED!");
return false;
}
return true;
}
// 向服务器发起连接
bool Connect(const std::string &ip, uint64_t port)
{
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip.c_str());
socklen_t len = sizeof(struct sockaddr_in);
// int connect(int sockfd, struct sockaddr* addr, socklen_t len)
int ret = connect(_sockfd, (struct sockaddr *)&addr, len);
if (ret < 0)
{
ERR_LOG("CONNECT SERVER FAILED!");
return false;
}
return true;
}
// 获取新连接
int Accept()
{
// int accept(int sockfd, struct sockaddr *addr, socklen_t *len);
int newfd = accept(_sockfd, nullptr, nullptr);
if (newfd < 0)
{
ERR_LOG("SOCKET ACCEPT FAILED!");
return -1;
}
return newfd;
}
// 接收数据
ssize_t Recv(void *buf, size_t len, int flag = 0) // 0 阻塞
{
// ssize_t recv(int sockfd, void *buf, size_t len, int flag)
ssize_t ret = recv(_sockfd, buf, len, flag);
if (ret <= 0)
{
// EAGAIN 当前的接收缓冲区中没用数据了,在非阻塞的情况下才有这个错误
// EINTR 表示当前socket的阻塞等待,被信号打断了
if (errno == EAGAIN || errno == EINTR)
{
return 0; // 表示这次没用接收到数据
}
ERR_LOG("SOCKET RECV FAILED!");
return -1;
}
return ret; // 实际接收的数据长度
}
ssize_t NonBlockRecv(void *buf, size_t len)
{
return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞
}
// 发送数据
ssize_t Send(const void *buf, size_t len, int flag = 0)
{
// ssize_t send(int sockfd, void *data, size_t len, int flag)
ssize_t ret = send(_sockfd, buf, len, flag);
if (ret < 0)
{
ERR_LOG("SOCKET SEND FAILED!");
return -1;
}
return ret; // 实际发送的数据长度
}
ssize_t NonBlockSend(void *buf, size_t len)
{
return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞
}
// 关闭套接字
void Close()
{
if (_sockfd != -1)
{
close(_sockfd);
_sockfd = -1;
}
}
// 创建一个服务器连接
bool CreateServer(uint64_t port, const std::string &ip = "0.0.0.0", bool block_flag = false) // 接收全部
{
// 1.创建套接字 2.绑定地址 3.开始监听 4.设置非阻塞 5.启动地址重用
if (Create() == false)
return false;
if (block_flag) // 默认阻塞
NonBlock();
if (Bind(ip, port) == false)
return false;
if (Listen() == false)
return false;
ReuseAddress();
return true;
}
// 创建一个客户端连接
bool CreateClient(uint64_t port, const std::string &ip)
{
// 1.创建套接字 2.指向连接服务器
if (Create() == false)
return false;
if (Connect(ip, port) == false)
return false;
return true;
}
// 设置套接字选项 -- 开启地址端口重用
void ReuseAddress()
{
// int setsockopt(int fd, int level, int optname, void *val, int vallen)
int val = 1;
setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, (void *)&val, sizeof(int)); // 地址
val = 1;
setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, (void *)&val, sizeof(int)); // 端口号
}
// 设置套接字阻塞属性 -- 设置为非阻塞
void NonBlock()
{
// int fcntl(int fd, int cmd, .../*arg*/)
int flag = fcntl(_sockfd, F_GETFD, 0);
fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
}
}; 测试
注意头文件的包含，我这里是直接使用相对位置，所以这里的头文件包含是这个样子的
测试服务器
#include "../source/server.hpp"
int main()
{
Socket lst_sock;
bool ret = lst_sock.CreateServer(8500);
while (1)
{
int newfd = lst_sock.Accept();
if(newfd < 0)
{
continue;
}
Socket cli_sock(newfd);
char buf[1024] = {0};
int ret = cli_sock.Recv(buf, 1024);
if(ret < 0)
{
cli_sock.Close();
continue;
}
cli_sock.Send(buf, ret);
cli_sock.Close();
}
lst_sock.Close();
return 0;
}测试客户端
#include "../source/server.hpp"
int main()
{
Socket cli_sock;
cli_sock.CreateClient(8500, "127.0.0.1");
std::string str = "hello qingfengyuge!";
cli_sock.Send(str.c_str(), str.size());
char buf[1024] = {0};
cli_sock.Recv(buf, 1023);
DBG_LOG("%s", buf);
return 0;
}测试结果
符合预期