#include <tcp_socket.hpp>

类 neforce::tcp_socket 继承关系图:

Public 成员函数
	tcp_socket ()=default
	默认构造函数
	tcp_socket (tcp_socket &&)=default
	移动构造函数
tcp_socket &	operator= (tcp_socket &&)=default
	移动赋值运算符
	tcp_socket (native_handle_type fd)
	从原生句柄构造
	~tcp_socket () override=default
	析构函数
void	open (family f=family::INET4)
	打开TCP socket
bool	connect (const ip_address &endpoint, milliseconds timeout, bool was_blocking=true)
	连接到远程服务器
virtual ssize_t	send (memory_view< const char > data, int flags=0)
	发送数据
ssize_t	send (memory_view< const char > data, milliseconds timeout, int flags=0)
	带超时的发送数据
void	send_all (memory_view< const char > data)
	发送所有数据
virtual ssize_t	receive (memory_view< char > buffer, int flags=0)
	接收数据
vector< char >	receive_all (size_t expected_size)
	接收指定大小的所有数据
virtual bool	is_ssl () const noexcept
	检查是否为SSL/TLS socket
void	async_connect (io_context &ctx, const ip_address &endpoint, function< void(error_code)> handler)
	异步连接到远程端点
void	async_connect (io_context &ctx, const ip_address &endpoint, cancellation_slot &slot, function< void(error_code)> handler)
	异步连接（带取消槽）
void	async_read (io_context &ctx, memory_view< char > buffer, function< void(error_code, size_t)> handler) override
	异步读取数据
void	async_read (io_context &ctx, memory_view< char > buffer, cancellation_slot &slot, function< void(error_code, size_t)> handler) override
	异步读取（带取消槽）
void	async_write (io_context &ctx, memory_view< const char > buffer, function< void(error_code, size_t)> handler) override
	异步写入数据
void	async_write (io_context &ctx, memory_view< const char > buffer, cancellation_slot &slot, function< void(error_code, size_t)> handler) override
	异步写入（带取消槽）
void	async_receive (io_context &ctx, memory_view< char > buffer, function< void(error_code, size_t)> handler)
	异步接收（转发到 async_read）
void	async_receive (io_context &ctx, memory_view< char > buffer, cancellation_slot &slot, function< void(error_code, size_t)> handler)
	异步接收（带取消槽，转发到 async_read）
void	async_send (io_context &ctx, memory_view< const char > buffer, function< void(error_code, size_t)> handler)
	异步发送（转发到 async_write）
void	async_send (io_context &ctx, memory_view< const char > buffer, cancellation_slot &slot, function< void(error_code, size_t)> handler)
	异步发送（带取消槽，转发到 async_write）
template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code, size_t)> >, int > = 0>
decltype(auto)	async_receive (io_context &ctx, memory_view< char > buffer, Token &&token)
	异步接收—模板令牌版本（转发到 async_read）
template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code, size_t)> >, int > = 0>
decltype(auto)	async_send (io_context &ctx, memory_view< const char > buffer, Token &&token)
	异步发送—模板令牌版本（转发到 async_write）
template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code)> >, int > = 0>
void	async_connect (io_context &ctx, const ip_address &endpoint, Token &&token)
	异步连接—任意可调用对象版本
auto	async_connect (io_context &ctx, const ip_address &endpoint, use_future_t)
	异步连接—use_future
void	async_connect (io_context &ctx, const ip_address &endpoint, detached_t)
	异步连接—detached（即发即忘）
auto	async_connect (io_context &ctx, const ip_address &endpoint, use_awaitable_t)
	异步连接—use_awaitable
Public 成员函数继承自 neforce::ip_socket
	ip_socket ()=default
	默认构造函数
	ip_socket (const native_handle_type fd) noexcept
	从原生句柄构造
	~ip_socket () override=default
	析构函数
family	address_family () const noexcept
	获取地址族
bool	is_ipv4 () const noexcept
	检查是否为IPv4 socket
bool	is_ipv6 () const noexcept
	检查是否为IPv6 socket
virtual void	connect (const ip_address &endpoint)
	连接到远程端点（TCP客户端）
bool	close () noexcept override
	关闭socket
Public 成员函数继承自 neforce::socket_base
	socket_base ()
	默认构造函数
	socket_base (const native_handle_type fd) noexcept
	从原生句柄构造
	socket_base (socket_base &&other) noexcept
	移动构造函数
socket_base &	operator= (socket_base &&other) noexcept
	移动赋值运算符
virtual	~socket_base ()
	析构函数
native_handle_type	native_handle () const noexcept
	获取原生句柄
bool	is_open () const noexcept
	检查socket是否已打开
	operator bool () const noexcept
	布尔转换运算符
void	open (family f, type t=type::STREAM, protocol p=protocol::AUTO)
	打开socket
bool	try_open (family f, type t=type::STREAM, protocol p=protocol::AUTO) noexcept
	尝试打开socket
bool	is_nonblocking () const noexcept
	查询是否为非阻塞模式
bool	set_nonblocking (bool enable) noexcept
	设置非阻塞模式
bool	shutdown_send () noexcept
	关闭发送方向
bool	shutdown_receive () noexcept
	关闭接收方向
bool	shutdown_both () noexcept
	关闭双向通信
bool	set_option (int level, int optname, const void *value, ::socklen_t len) noexcept
	设置socket选项
bool	get_option (int level, int optname, void optval, ::socklen_t optlen) const noexcept
	获取socket选项
bool	get_reuse_address () const noexcept
	查询地址重用
bool	set_reuse_address (bool enable=true) noexcept
	设置地址重用
bool	get_reuse_port () const noexcept
	查询端口重用
bool	set_reuse_port (bool enable=true) noexcept
	设置端口重用
bool	get_keep_alive () const noexcept
	查询TCP KeepAlive
bool	set_keep_alive (bool enable=true) noexcept
	设置TCP KeepAlive
bool	get_tcp_nodelay () const noexcept
	查询Nagle算法
bool	set_tcp_nodelay (bool enable=true) noexcept
	设置禁用Nagle算法
int	get_receive_buffer_size () const noexcept
	查询接收缓冲区大小
bool	set_receive_buffer_size (int size) noexcept
	设置接收缓冲区大小
int	get_send_buffer_size () const noexcept
	查询发送缓冲区大小
bool	set_send_buffer_size (int size) noexcept
	设置发送缓冲区大小
optional< milliseconds >	get_send_timeout () const noexcept
	获取发送超时时间
bool	set_send_timeout (milliseconds timeout) noexcept
	设置发送超时时间
optional< milliseconds >	get_receive_timeout () const noexcept
	获取接收超时时间
bool	set_receive_timeout (milliseconds timeout) noexcept
	设置接收超时时间
optional< ip_address >	local_endpoint () const
	获取本地端点地址
optional< ip_address >	remote_endpoint () const
	获取远程端点地址
void	bind (const ip_address &endpoint)
	绑定socket到本地地址
void	listen (int backlog)
	开始监听连接（TCP）
native_handle_type	release () noexcept
	释放socket所有权
Public 成员函数继承自 neforce::async_stream
virtual	~async_stream ()=default
	析构函数
template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code, size_t)> >, int > = 0>
void	async_read (io_context &ctx, memory_view< char > buffer, Token &&token)
	异步读取—任意可调用对象
auto	async_read (io_context &ctx, memory_view< char > buffer, use_future_t)
	异步读取—use_future
void	async_read (io_context &ctx, memory_view< char > buffer, detached_t)
	异步读取—detached（即发即忘）
auto	async_read (io_context &ctx, memory_view< char > buffer, use_awaitable_t)
	异步读取—use_awaitable
template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code, size_t)> >, int > = 0>
void	async_write (io_context &ctx, memory_view< const char > buffer, Token &&token)
	异步写入—任意可调用对象
auto	async_write (io_context &ctx, memory_view< const char > buffer, use_future_t)
	异步写入—use_future
void	async_write (io_context &ctx, memory_view< const char > buffer, detached_t)
	异步写入—detached（即发即忘）
auto	async_write (io_context &ctx, memory_view< const char > buffer, use_awaitable_t)
	异步写入—use_awaitable
void	async_read (io_context &ctx, mutable_buffers &bufs, function< void(error_code, size_t)> handler)
	异步读取—scatter-gather
void	async_write (io_context &ctx, const_buffers &bufs, function< void(error_code, size_t)> handler)
	异步写入—scatter-gather
void	async_read (io_context &ctx, dynamic_buffer &buf, size_t n, function< void(error_code, size_t)> handler)
	异步读取到 dynamic_buffer

额外继承的成员函数
Public 类型继承自 neforce::socket_base
enum class	type : int32_t { STREAM = SOCK_STREAM , DGRAM = SOCK_DGRAM , RAW = SOCK_RAW , RDM = SOCK_RDM , SEQPACKET = SOCK_SEQPACKET , CLOEXEC = SOCK_CLOEXEC , NONBLOCK = SOCK_NONBLOCK , DCCP = SOCK_DCCP }
	socket 类型枚举更多...
enum class	protocol : int32_t { AUTO = 0 , ICMP = IPPROTO_ICMP , TCP = IPPROTO_TCP , UDP = IPPROTO_UDP , SCTP = IPPROTO_SCTP , RAW = IPPROTO_RAW , ESP = IPPROTO_ESP , AH = IPPROTO_AH , DCCP = IPPROTO_DCCP , IP = ETH_P_IP , ARP = ETH_P_ARP , IPV6 = ETH_P_IPV6 , LAT = ETH_P_LAT , VLAN = ETH_P_8021Q , LLDP = ETH_P_LLDP , MPLS = ETH_P_MPLS_UC }
	socket 协议枚举更多...
using	native_handle_type
	平台原生句柄类型
using	family = ip_address::family
	网络地址族类型
静态 Public 属性继承自 neforce::socket_base
static constexpr native_handle_type	invalid_handle
	无效句柄常量
Protected 属性继承自 neforce::ip_socket
family	family_ = family::UNDEF
	地址族
Protected 属性继承自 neforce::socket_base
native_handle_type	fd_ = invalid_handle
	Socket句柄
bool	nonblocking_ {false}
	非阻塞模式状态跟踪

详细描述

TCP Socket类

实现TCP协议的流式socket， TCP是面向连接的协议，提供可靠的数据传输、流量控制和拥塞控制。

主要功能：

TCP socket创建和打开
连接建立（支持超时）
数据发送（普通、带超时、全部发送）
数据接收（普通、全部接收）
SSL/TLS支持接口

使用示例：

// TCP客户端示例
tcp_socket client;
client.open(AF_INET);
 
auto server = ip_address::parse("192.168.1.100", ports(8080));
if (client.connect(*server, milliseconds(3000))) {
    string request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n";
    client.send_all(request.view());
 
    char buffer[4096];
    ssize_t received = client.receive({buffer, sizeof(buffer)});
    if (received > 0) {
        println(string_view(buffer, received));
    }
}
 
// TCP服务器示例
tcp_socket server;
server.open(AF_INET);
auto local = ip_address::any(ports(8080));
server.bind(local);
server.listen(128);
 
auto client_sock = server.accept();  // 接受连接
// 与客户端通信...

在文件 tcp_socket.hpp 第 69 行定义.

构造及析构函数说明

◆ tcp_socket()

neforce::tcp_socket::tcp_socket ( native_handle_type fd )

inlineexplicit

从原生句柄构造

参数

fd	原生socket句柄

在文件 tcp_socket.hpp 第 90 行定义.

引用了 neforce::ip_socket::ip_socket().

成员函数说明

◆ async_connect() [1/6]

void neforce::tcp_socket::async_connect	(	io_context &	ctx,
		const ip_address &	endpoint,
		cancellation_slot &	slot,
		function< void(error_code)>	handler )

异步连接（带取消槽）

参数

ctx	异步 I/O 执行上下文
endpoint	远程端点地址
slot	取消槽
handler	完成回调 void(error_code)

◆ async_connect() [2/6]

void neforce::tcp_socket::async_connect	(	io_context &	ctx,
		const ip_address &	endpoint,
		detached_t	)

inline

异步连接—detached（即发即忘）

参数

ctx	异步 I/O 执行上下文
endpoint	远程端点地址

在文件 tcp_socket.hpp 第 343 行定义.

引用了 async_connect().

◆ async_connect() [3/6]

void neforce::tcp_socket::async_connect	(	io_context &	ctx,
		const ip_address &	endpoint,
		function< void(error_code)>	handler )

异步连接到远程端点

参数

ctx	异步 I/O 执行上下文
endpoint	远程端点地址
handler	完成回调 void(error_code)

发起异步TCP连接。socket 会被设为非阻塞模式。 handler 在 io_context::run() 线程中执行。

被这些函数引用 async_connect(), async_connect(), async_connect() , 以及 async_connect().

◆ async_connect() [4/6]

template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code)> >, int > = 0>

void neforce::tcp_socket::async_connect	(	io_context &	ctx,
		const ip_address &	endpoint,
		Token &&	token )

inline

异步连接—任意可调用对象版本

模板参数

Token 可调用对象类型，需满足 void(error_code) 签名

参数

ctx	异步 I/O 执行上下文
endpoint	远程端点地址
token	完成令牌

handler 可以是任意满足 void(error_code) 的可调用对象。

在文件 tcp_socket.hpp 第 322 行定义.

引用了 async_connect() , 以及 neforce::forward().

◆ async_connect() [5/6]

auto neforce::tcp_socket::async_connect	(	io_context &	ctx,
		const ip_address &	endpoint,
		use_awaitable_t	)

inline

异步连接—use_awaitable

参数

ctx	异步 I/O 执行上下文
endpoint	远程端点地址

返回: awaitable<void> 可协程等待的结果

在文件 tcp_socket.hpp 第 354 行定义.

引用了 async_connect() , 以及 neforce::use_awaitable.

◆ async_connect() [6/6]

auto neforce::tcp_socket::async_connect	(	io_context &	ctx,
		const ip_address &	endpoint,
		use_future_t	)

inline

异步连接—use_future

参数

ctx	异步 I/O 执行上下文
endpoint	远程端点地址

返回: future<void> 异步操作结果

在文件 tcp_socket.hpp 第 332 行定义.

引用了 async_connect() , 以及 neforce::use_future.

◆ async_read() [1/2]

void neforce::tcp_socket::async_read	(	io_context &	ctx,
		memory_view< char >	buffer,
		cancellation_slot &	slot,
		function< void(error_code, size_t)>	handler )

overridevirtual

异步读取（带取消槽）

参数

ctx	异步 I/O 执行上下文
buffer	接收缓冲区
slot	取消槽
handler	完成回调 void(error_code, size_t bytes_transferred)

实现了 neforce::async_stream.

◆ async_read() [2/2]

void neforce::tcp_socket::async_read	(	io_context &	ctx,
		memory_view< char >	buffer,
		function< void(error_code, size_t)>	handler )

overridevirtual

异步读取数据

参数

ctx	异步 I/O 执行上下文
buffer	接收缓冲区
handler	完成回调 void(error_code, size_t bytes_transferred)

实现了 neforce::async_stream.

◆ async_receive() [1/3]

void neforce::tcp_socket::async_receive	(	io_context &	ctx,
		memory_view< char >	buffer,
		cancellation_slot &	slot,
		function< void(error_code, size_t)>	handler )

inline

异步接收（带取消槽，转发到 async_read）

参数

ctx	异步 I/O 执行上下文
buffer	接收缓冲区
slot	取消槽
handler	完成回调 void(error_code, size_t bytes_transferred)

在文件 tcp_socket.hpp 第 261 行定义.

引用了 neforce::async_read() , 以及 neforce::move().

◆ async_receive() [2/3]

void neforce::tcp_socket::async_receive	(	io_context &	ctx,
		memory_view< char >	buffer,
		function< void(error_code, size_t)>	handler )

inline

异步接收（转发到 async_read）

参数

ctx	异步 I/O 执行上下文
buffer	接收缓冲区
handler	完成回调 void(error_code, size_t bytes_transferred)

在文件 tcp_socket.hpp 第 250 行定义.

引用了 neforce::async_read() , 以及 neforce::move().

◆ async_receive() [3/3]

template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code, size_t)> >, int > = 0>

decltype(auto) neforce::tcp_socket::async_receive	(	io_context &	ctx,
		memory_view< char >	buffer,
		Token &&	token )

inline

异步接收—模板令牌版本（转发到 async_read）

模板参数

Token 完成令牌类型

参数

ctx	异步 I/O 执行上下文
buffer	接收缓冲区
token	完成令牌

在文件 tcp_socket.hpp 第 296 行定义.

引用了 neforce::async_stream::async_read() , 以及 neforce::forward().

◆ async_send() [1/3]

void neforce::tcp_socket::async_send	(	io_context &	ctx,
		memory_view< const char >	buffer,
		cancellation_slot &	slot,
		function< void(error_code, size_t)>	handler )

inline

异步发送（带取消槽，转发到 async_write）

参数

ctx	异步 I/O 执行上下文
buffer	发送缓冲区
slot	取消槽
handler	完成回调 void(error_code, size_t bytes_transferred)

在文件 tcp_socket.hpp 第 283 行定义.

引用了 neforce::async_write() , 以及 neforce::move().

◆ async_send() [2/3]

void neforce::tcp_socket::async_send	(	io_context &	ctx,
		memory_view< const char >	buffer,
		function< void(error_code, size_t)>	handler )

inline

异步发送（转发到 async_write）

参数

ctx	异步 I/O 执行上下文
buffer	发送缓冲区
handler	完成回调 void(error_code, size_t bytes_transferred)

在文件 tcp_socket.hpp 第 272 行定义.

引用了 neforce::async_write() , 以及 neforce::move().

◆ async_send() [3/3]

template<typename Token, enable_if_t<!is_same_v< decay_t< Token >, function< void(error_code, size_t)> >, int > = 0>

decltype(auto) neforce::tcp_socket::async_send	(	io_context &	ctx,
		memory_view< const char >	buffer,
		Token &&	token )

inline

异步发送—模板令牌版本（转发到 async_write）

模板参数

Token 完成令牌类型

参数

ctx	异步 I/O 执行上下文
buffer	发送缓冲区
token	完成令牌

在文件 tcp_socket.hpp 第 308 行定义.

引用了 neforce::async_stream::async_write() , 以及 neforce::forward().

◆ async_write() [1/2]

void neforce::tcp_socket::async_write	(	io_context &	ctx,
		memory_view< const char >	buffer,
		cancellation_slot &	slot,
		function< void(error_code, size_t)>	handler )

overridevirtual

异步写入（带取消槽）

参数

ctx	异步 I/O 执行上下文
buffer	发送缓冲区
slot	取消槽
handler	完成回调 void(error_code, size_t bytes_transferred)

实现了 neforce::async_stream.

◆ async_write() [2/2]

void neforce::tcp_socket::async_write	(	io_context &	ctx,
		memory_view< const char >	buffer,
		function< void(error_code, size_t)>	handler )

overridevirtual

异步写入数据

参数

ctx	异步 I/O 执行上下文
buffer	发送缓冲区
handler	完成回调 void(error_code, size_t bytes_transferred)

实现了 neforce::async_stream.

◆ connect()

bool neforce::tcp_socket::connect	(	const ip_address &	endpoint,
		milliseconds	timeout,
		bool	was_blocking = true )

连接到远程服务器

参数

endpoint	远程端点地址
timeout	连接超时时间
was_blocking	连接前是否处于阻塞模式

返回: 连接成功返回true，超时返回false

异常

socket_exception	连接失败时抛出
value_exception	socket未打开或端点无效时抛出

发起TCP连接到指定的远程服务器，支持超时控制。非阻塞模式下，此函数会等待连接完成或超时。

◆ is_ssl()

virtual bool neforce::tcp_socket::is_ssl ( ) const

inlinenodiscardvirtualnoexcept

检查是否为SSL/TLS socket

返回: 始终返回false（基类实现）

被 neforce::ssl_socket 重载.

在文件 tcp_socket.hpp 第 184 行定义.

◆ open()

void neforce::tcp_socket::open ( family f = family::INET4 )

打开TCP socket

参数

f	地址族，默认IPv4

异常

socket_exception 创建失败时抛出

创建TCP协议的socket，使用SOCK_STREAM类型和IPPROTO_TCP协议。

◆ receive()

virtual ssize_t neforce::tcp_socket::receive	(	memory_view< char >	buffer,
		int	flags = 0 )

virtual

接收数据

参数

buffer	接收缓冲区
flags	接收标志（通常为0）

返回: 实际接收的字节数（0表示连接关闭）

异常

socket_exception	接收失败时抛出
value_exception	socket未打开时抛出

从已连接的远程端点接收数据。返回0表示对端已关闭连接。

被 neforce::ssl_socket 重载.

◆ receive_all()

vector< char > neforce::tcp_socket::receive_all ( size_t expected_size )

接收指定大小的所有数据

参数

expected_size 期望接收的字节数

返回: 实际接收的数据（可能小于expected_size）

异常

socket_exception 接收失败时抛出

循环接收直到达到期望大小或连接关闭。适用于需要完整接收特定大小数据的场景。

◆ send() [1/2]

virtual ssize_t neforce::tcp_socket::send	(	memory_view< const char >	data,
		int	flags = 0 )

virtual

发送数据

参数

data	要发送的数据
flags	发送标志（通常为0）

返回: 实际发送的字节数

异常

socket_exception	发送失败时抛出
value_exception	socket未打开时抛出

发送数据到已连接的远程端点。可能只发送部分数据，需要循环调用直到全部发送完成。

被 neforce::ssl_socket 重载.

引用了 neforce::data().

◆ send() [2/2]

ssize_t neforce::tcp_socket::send	(	memory_view< const char >	data,
		milliseconds	timeout,
		int	flags = 0 )

带超时的发送数据

参数

data	要发送的数据
timeout	发送超时时间
flags	发送标志（通常为0）

返回: 实际发送的字节数

异常

socket_exception 发送失败或超时时抛出

在指定超时时间内等待socket可写，然后发送数据。

引用了 neforce::data().

◆ send_all()

void neforce::tcp_socket::send_all ( memory_view< const char > data )

发送所有数据

参数

data 要发送的数据

异常

socket_exception 发送失败时抛出

循环发送直到所有数据发送完毕。适用于阻塞模式下的完整数据发送。

引用了 neforce::data().

该类的文档由以下文件生成:

tcp_socket.hpp

Public 成员函数

额外继承的成员函数

详细描述

构造及析构函数说明

◆ tcp_socket()

成员函数说明

◆ async_connect() [1/6]

◆ async_connect() [2/6]

◆ async_connect() [3/6]

◆ async_connect() [4/6]

◆ async_connect() [5/6]

◆ async_connect() [6/6]

◆ async_read() [1/2]

◆ async_read() [2/2]

◆ async_receive() [1/3]

◆ async_receive() [2/3]

◆ async_receive() [3/3]

◆ async_send() [1/3]

◆ async_send() [2/3]

◆ async_send() [3/3]

◆ async_write() [1/2]

◆ async_write() [2/2]

◆ connect()

◆ is_ssl()

◆ open()

◆ receive()

◆ receive_all()

◆ send() [1/2]

◆ send() [2/2]

◆ send_all()