719 lines
17 KiB
C++
719 lines
17 KiB
C++
|
||
/**
|
||
* Tencent is pleased to support the open source community by making MSEC available.
|
||
*
|
||
* Copyright (C) 2016 THL A29 Limited, a Tencent company. All rights reserved.
|
||
*
|
||
* Licensed under the GNU General Public License, Version 2.0 (the "License");
|
||
* you may not use this file except in compliance with the License. You may
|
||
* obtain a copy of the License at
|
||
*
|
||
* https://opensource.org/licenses/GPL-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software distributed under the
|
||
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
|
||
* either express or implied. See the License for the specific language governing permissions
|
||
* and limitations under the License.
|
||
*/
|
||
|
||
|
||
/**
|
||
* @file mt_net.h
|
||
* @info 微线程封装的网络接口类
|
||
**/
|
||
|
||
#ifndef __MT_NET_H__
|
||
#define __MT_NET_H__
|
||
|
||
#include "micro_thread.h"
|
||
#include "hash_list.h"
|
||
#include "mt_api.h"
|
||
#include "mt_cache.h"
|
||
#include "mt_net_api.h"
|
||
|
||
namespace NS_MICRO_THREAD {
|
||
|
||
/**
|
||
* @brief 连接类型定义
|
||
*/
|
||
enum MT_CONN_TYPE
|
||
{
|
||
TYPE_CONN_UNKNOWN = 0,
|
||
TYPE_CONN_SHORT = 0x1, ///< 短连接, 一次交互后关闭
|
||
TYPE_CONN_POOL = 0x2, ///< 长连接，每次使用后, 可回收重复使用
|
||
TYPE_CONN_SESSION = 0x4, ///< 长连接，按session id 复用, 防串包
|
||
TYPE_CONN_SENDONLY = 0x8, ///< 只发不收
|
||
};
|
||
|
||
|
||
/******************************************************************************/
|
||
/* 内部实现部分 */
|
||
/******************************************************************************/
|
||
class CSockLink;
|
||
|
||
/**
|
||
* @brief 定时回收的对象池模板实现
|
||
* @info List必须是tailq, Type 需要有reset函数, releasetime, linkentry字段
|
||
*/
|
||
template <typename List, typename Type>
|
||
class CRecyclePool
|
||
{
|
||
public:
|
||
|
||
// 构造函数, 默认60s超时
|
||
CRecyclePool() {
|
||
_expired = 60 * 1000;
|
||
_count = 0;
|
||
TAILQ_INIT(&_free_list);
|
||
};
|
||
|
||
// 析构函数, 删除池中元素
|
||
~CRecyclePool() {
|
||
Type* item = NULL;
|
||
Type* tmp = NULL;
|
||
TAILQ_FOREACH_SAFE(item, &_free_list, _link_entry, tmp)
|
||
{
|
||
TAILQ_REMOVE(&_free_list, item, _link_entry);
|
||
delete item;
|
||
}
|
||
_count = 0;
|
||
};
|
||
|
||
// 复用或新创建对象
|
||
Type* AllocItem() {
|
||
Type* item = TAILQ_FIRST(&_free_list);
|
||
if (item != NULL)
|
||
{
|
||
TAILQ_REMOVE(&_free_list, item, _link_entry);
|
||
_count--;
|
||
return item;
|
||
}
|
||
|
||
item = new Type();
|
||
if (NULL == item)
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
return item;
|
||
};
|
||
|
||
// 释放管理对象
|
||
void FreeItem(Type* obj) {
|
||
//obj->Reset();
|
||
TAILQ_INSERT_TAIL(&_free_list, obj, _link_entry);
|
||
obj->_release_time = mt_time_ms();
|
||
_count++;
|
||
};
|
||
|
||
|
||
// 回收句柄
|
||
void RecycleItem(uint64_t now) {
|
||
Type* item = NULL;
|
||
Type* tmp = NULL;
|
||
TAILQ_FOREACH_SAFE(item, &_free_list, _link_entry, tmp)
|
||
{
|
||
if ((now - item->_release_time) < _expired) {
|
||
break;
|
||
}
|
||
|
||
TAILQ_REMOVE(&_free_list, item, _link_entry);
|
||
delete item;
|
||
_count--;
|
||
}
|
||
};
|
||
|
||
// 设置自定义的超时时间
|
||
void SetExpiredTime(uint64_t expired) {
|
||
_expired = expired;
|
||
};
|
||
|
||
private:
|
||
|
||
List _free_list; ///< 空闲链表
|
||
uint64_t _expired; ///< 超时时间
|
||
uint32_t _count; ///< 元素计数
|
||
};
|
||
|
||
|
||
|
||
/**
|
||
* @brief 每次IO关联一个句柄对象
|
||
*/
|
||
class CNetHandler : public HashKey
|
||
{
|
||
public:
|
||
|
||
// 句柄状态描述
|
||
enum {
|
||
STATE_IN_SESSION = 0x1,
|
||
STATE_IN_CONNECT = 0x2,
|
||
STATE_IN_SEND = 0x4,
|
||
STATE_IN_RECV = 0x8,
|
||
STATE_IN_IDLE = 0x10,
|
||
};
|
||
|
||
/**
|
||
* @brief 节点元素的hash算法, 获取key的hash值
|
||
* @return 节点元素的hash值
|
||
*/
|
||
virtual uint32_t HashValue();
|
||
|
||
/**
|
||
* @brief 节点元素的cmp方法, 同一桶ID下, 按key比较
|
||
* @return 节点元素的hash值
|
||
*/
|
||
virtual int HashCmp(HashKey* rhs);
|
||
|
||
// 同步收发接口
|
||
int32_t SendRecv(void* data, uint32_t len, uint32_t timeout);
|
||
|
||
// 获取返回buff信息, 有效期直到helper析构
|
||
void* GetRspBuff() {
|
||
if (_rsp_buff != NULL) {
|
||
return _rsp_buff->data;
|
||
} else {
|
||
return NULL;
|
||
}
|
||
};
|
||
|
||
// 获取返回buff信息, 有效期直到helper析构
|
||
uint32_t GetRspLen() {
|
||
if (_rsp_buff != NULL) {
|
||
return _rsp_buff->data_len;
|
||
} else {
|
||
return 0;
|
||
}
|
||
};
|
||
|
||
// 设置rsp信息
|
||
void SetRespBuff(TSkBuffer* buff) {
|
||
if (_rsp_buff != NULL) {
|
||
delete_sk_buffer(_rsp_buff);
|
||
_rsp_buff = NULL;
|
||
}
|
||
|
||
_rsp_buff = buff;
|
||
};
|
||
|
||
// 设置协议的类型, 默认UDP
|
||
void SetProtoType(MT_PROTO_TYPE type) {
|
||
_proto_type = type;
|
||
};
|
||
|
||
// 设置连接类型, 默认长连接
|
||
void SetConnType(MT_CONN_TYPE type) {
|
||
_conn_type = type;
|
||
};
|
||
|
||
// 设置目的IP地址
|
||
void SetDestAddress(struct sockaddr_in* dst) {
|
||
if (dst != NULL) {
|
||
memcpy(&_dest_ipv4, dst, sizeof(*dst));
|
||
}
|
||
};
|
||
|
||
// 设置session本次session id信息, 必须非0
|
||
void SetSessionId(uint64_t sid) {
|
||
_session_id = sid;
|
||
};
|
||
|
||
// 设置session解析回调函数
|
||
void SetSessionCallback(CHECK_SESSION_CALLBACK function) {
|
||
_callback = function;
|
||
};
|
||
|
||
// 获取回调函数信息
|
||
CHECK_SESSION_CALLBACK GetSessionCallback() {
|
||
return _callback;
|
||
};
|
||
|
||
|
||
public:
|
||
|
||
// 关联连接对象
|
||
void Link(CSockLink* conn);
|
||
|
||
// 解耦连接对象
|
||
void Unlink();
|
||
|
||
// 检查必要的参数信息
|
||
int32_t CheckParams();
|
||
|
||
// 获取链接, 同时关联到等待连接的队列中
|
||
int32_t GetConnLink();
|
||
|
||
// 检查必要的参数信息
|
||
int32_t WaitConnect(uint64_t timeout);
|
||
|
||
// 检查必要的参数信息
|
||
int32_t WaitSend(uint64_t timeout);
|
||
|
||
// 检查必要的参数信息
|
||
int32_t WaitRecv(uint64_t timeout);
|
||
|
||
// 关联在等待连接队列
|
||
void SwitchToConn();
|
||
|
||
// 切换到发送队列
|
||
void SwitchToSend();
|
||
|
||
// 切换到接收队列
|
||
void SwitchToRecv();
|
||
|
||
// 切换到空闲状态
|
||
void SwitchToIdle();
|
||
|
||
// 解耦连接对象
|
||
void DetachConn();
|
||
|
||
// 注册session管理
|
||
bool RegistSession();
|
||
|
||
// 取消注册session
|
||
void UnRegistSession();
|
||
|
||
// 跳过发送的请求长度
|
||
uint32_t SkipSendPos(uint32_t len);
|
||
|
||
// 设置返回码
|
||
void SetErrNo(int32_t err) {
|
||
_err_no = err;
|
||
};
|
||
|
||
// 获取关联的线程信息
|
||
MicroThread* GetThread() {
|
||
return _thread;
|
||
};
|
||
|
||
// 获取待发送的指针与数据长度
|
||
void GetSendData(void*& data, uint32_t& len) {
|
||
data = _req_data;
|
||
len = _req_len;
|
||
};
|
||
|
||
// 复用接口
|
||
void Reset();
|
||
|
||
// 构造与析构
|
||
CNetHandler();
|
||
~CNetHandler();
|
||
|
||
// 队列快捷访问的宏定义
|
||
TAILQ_ENTRY(CNetHandler) _link_entry;
|
||
uint64_t _release_time;
|
||
|
||
protected:
|
||
|
||
MicroThread* _thread; ///< 关联线程指针对象
|
||
MT_PROTO_TYPE _proto_type; ///< 协议类型
|
||
MT_CONN_TYPE _conn_type; ///< 连接类型
|
||
struct sockaddr_in _dest_ipv4; ///< ipv4目的地址
|
||
uint64_t _session_id; ///< 会话ID
|
||
CHECK_SESSION_CALLBACK _callback; ///< 会话提取回调函数
|
||
uint32_t _state_flags; ///< 内部状态字段
|
||
int32_t _err_no; ///< 返回码信息
|
||
void* _conn_ptr; ///< socket 链路指针
|
||
uint32_t _send_pos; ///< 已发送的pos位置
|
||
uint32_t _req_len; ///< 请求包长度
|
||
void* _req_data; ///< 请求包指针
|
||
TSkBuffer* _rsp_buff; ///< 应答buff信息
|
||
|
||
};
|
||
typedef TAILQ_HEAD(__NetHandlerList, CNetHandler) TNetItemList; ///< 高效的双链管理
|
||
typedef CRecyclePool<TNetItemList, CNetHandler> TNetItemPool; ///< 定时回收的对象池
|
||
|
||
|
||
/**
|
||
* @brief 长连接链路对象
|
||
*/
|
||
class CSockLink : public KqueuerObj
|
||
{
|
||
public:
|
||
|
||
// 句柄状态描述
|
||
enum {
|
||
LINK_CONNECTING = 0x1,
|
||
LINK_CONNECTED = 0x2,
|
||
};
|
||
|
||
// 状态队列定义
|
||
enum {
|
||
LINK_IDLE_LIST = 1,
|
||
LINK_CONN_LIST = 2,
|
||
LINK_SEND_LIST = 3,
|
||
LINK_RECV_LIST = 4,
|
||
};
|
||
|
||
// 检查或创建socket句柄
|
||
int32_t CreateSock();
|
||
|
||
// 关闭链路的句柄
|
||
void Close();
|
||
|
||
// 发起连接过程
|
||
bool Connect();
|
||
bool Connected() {
|
||
return (_state & LINK_CONNECTED);
|
||
}
|
||
|
||
// 异常终止的处理函数
|
||
void Destroy();
|
||
|
||
// 获取管理链表
|
||
TNetItemList* GetItemList(int32_t type);
|
||
|
||
// 管理句柄信息
|
||
void AppendToList(int32_t type, CNetHandler* item);
|
||
|
||
// 管理句柄信息
|
||
void RemoveFromList(int32_t type, CNetHandler* item);
|
||
|
||
// 获取目标ip信息
|
||
struct sockaddr_in* GetDestAddr(struct sockaddr_in* addr);
|
||
|
||
// 发起连接过程
|
||
int32_t SendData(void* data, uint32_t len);
|
||
|
||
// udp发送数据
|
||
int32_t SendCacheUdp(void* data, uint32_t len);
|
||
|
||
// tcp发送数据
|
||
int32_t SendCacheTcp(void* data, uint32_t len);
|
||
|
||
// 尝试接收更多的数据到临时buff
|
||
void ExtendRecvRsp();
|
||
|
||
// 数据分发处理过程
|
||
int32_t RecvDispath();
|
||
|
||
// 或者回调函数, 优先从排队等待中获取, 备份从父节点获取
|
||
CHECK_SESSION_CALLBACK GetSessionCallback();
|
||
|
||
// TCP接收数据流处理与分发
|
||
int32_t DispathTcp();
|
||
|
||
// UDP接收数据流处理与分发
|
||
int32_t DispathUdp();
|
||
|
||
// 查询本地sessionid关联的session信息
|
||
CNetHandler* FindSession(uint64_t sid);
|
||
|
||
/**
|
||
* @brief 可读事件通知接口, 考虑通知处理可能会破坏环境, 可用返回值区分
|
||
* @return 0 该fd可继续处理其它事件; !=0 该fd需跳出回调处理
|
||
*/
|
||
virtual int InputNotify();
|
||
|
||
/**
|
||
* @brief 可写事件通知接口, 考虑通知处理可能会破坏环境, 可用返回值区分
|
||
* @return 0 该fd可继续处理其它事件; !=0 该fd需跳出回调处理
|
||
*/
|
||
virtual int OutputNotify();
|
||
|
||
/**
|
||
* @brief 异常通知接口
|
||
* @return 忽略返回值, 跳过其它事件处理
|
||
*/
|
||
virtual int HangupNotify();
|
||
|
||
|
||
// 构造与析构函数
|
||
CSockLink();
|
||
~CSockLink();
|
||
|
||
// 清理置初始化逻辑
|
||
void Reset();
|
||
|
||
// 通知唤醒线程
|
||
void NotifyThread(CNetHandler* item, int32_t result);
|
||
|
||
// 通知唤醒线程
|
||
void NotifyAll(int32_t result);
|
||
|
||
// 设置协议类型, 决定buff池的指针
|
||
void SetProtoType(MT_PROTO_TYPE type);
|
||
|
||
// 设置上级指针信息
|
||
void SetParentsPtr(void* ptr) {
|
||
_parents = ptr;
|
||
};
|
||
|
||
// 获取上级节点指针
|
||
void* GetParentsPtr() {
|
||
return _parents;
|
||
};
|
||
|
||
// 获取上次的访问时间
|
||
uint64_t GetLastAccess() {
|
||
return _last_access;
|
||
};
|
||
|
||
|
||
|
||
public:
|
||
|
||
// 队列快捷访问的宏定义
|
||
TAILQ_ENTRY(CSockLink) _link_entry;
|
||
uint64_t _release_time;
|
||
|
||
private:
|
||
|
||
TNetItemList _wait_connect;
|
||
TNetItemList _wait_send;
|
||
TNetItemList _wait_recv;
|
||
TNetItemList _idle_list;
|
||
MT_PROTO_TYPE _proto_type;
|
||
int32_t _errno;
|
||
uint32_t _state;
|
||
uint64_t _last_access;
|
||
TRWCache _recv_cache;
|
||
TSkBuffer* _rsp_buff;
|
||
void* _parents;
|
||
};
|
||
typedef TAILQ_HEAD(__SocklinkList, CSockLink) TLinkList; ///< 高效的双链管理
|
||
typedef CRecyclePool<TLinkList, CSockLink> TLinkPool; ///< 定时回收的对象池
|
||
|
||
|
||
class CDestLinks : public CTimerNotify, public HashKey
|
||
{
|
||
public:
|
||
|
||
// 构造函数
|
||
CDestLinks();
|
||
|
||
// 析构函数
|
||
~CDestLinks();
|
||
|
||
// 重置复用的接口函数
|
||
void Reset();
|
||
|
||
// 启动定时器
|
||
void StartTimer();
|
||
|
||
// 获取一个连接link, 暂时按轮询
|
||
CSockLink* GetSockLink();
|
||
|
||
// 释放一个连接link
|
||
void FreeSockLink(CSockLink* sock);
|
||
|
||
// 获取协议类型
|
||
MT_PROTO_TYPE GetProtoType() {
|
||
return _proto_type;
|
||
};
|
||
|
||
// 获取连接类型
|
||
MT_CONN_TYPE GetConnType() {
|
||
return _conn_type;
|
||
};
|
||
|
||
|
||
// 设置关键信息
|
||
void SetKeyInfo(uint32_t ipv4, uint16_t port, MT_PROTO_TYPE proto, MT_CONN_TYPE conn) {
|
||
_addr_ipv4 = ipv4;
|
||
_net_port = port;
|
||
_proto_type = proto;
|
||
_conn_type = conn;
|
||
};
|
||
|
||
// 拷贝KEY信息
|
||
void CopyKeyInfo(CDestLinks* key) {
|
||
_addr_ipv4 = key->_addr_ipv4;
|
||
_net_port = key->_net_port;
|
||
_proto_type = key->_proto_type;
|
||
_conn_type = key->_conn_type;
|
||
};
|
||
|
||
// 获取IP port信息
|
||
void GetDestIP(uint32_t& ip, uint16_t& port) {
|
||
ip = _addr_ipv4;
|
||
port = _net_port;
|
||
};
|
||
|
||
/**
|
||
* @brief 超时通知函数, 检查空闲链路, 检查配置链路个数
|
||
*/
|
||
virtual void timer_notify();
|
||
|
||
/**
|
||
* @brief 节点元素的hash算法, 获取key的hash值
|
||
* @return 节点元素的hash值
|
||
*/
|
||
virtual uint32_t HashValue() {
|
||
return _addr_ipv4 ^ (((uint32_t)_net_port << 16) | (_proto_type << 8) | _conn_type);
|
||
};
|
||
|
||
/**
|
||
* @brief 节点元素的cmp方法, 同一桶ID下, 按key比较
|
||
* @return 节点元素的hash值
|
||
*/
|
||
virtual int HashCmp(HashKey* rhs) {
|
||
CDestLinks* data = (CDestLinks*)(rhs);
|
||
if (!data) {
|
||
return -1;
|
||
}
|
||
if (this->_addr_ipv4 != data->_addr_ipv4) {
|
||
return (this->_addr_ipv4 > data->_addr_ipv4) ? 1 : -1;
|
||
}
|
||
if (this->_net_port != data->_net_port) {
|
||
return (this->_net_port > data->_net_port) ? 1 : -1;
|
||
}
|
||
if (this->_proto_type != data->_proto_type) {
|
||
return (this->_proto_type > data->_proto_type) ? 1 : -1;
|
||
}
|
||
if (this->_conn_type != data->_conn_type) {
|
||
return (this->_conn_type > data->_conn_type) ? 1 : -1;
|
||
}
|
||
|
||
return 0;
|
||
};
|
||
|
||
// 设置session解析回调函数
|
||
void SetDefaultCallback(CHECK_SESSION_CALLBACK function) {
|
||
_dflt_callback = function;
|
||
};
|
||
|
||
// 获取回调函数信息
|
||
CHECK_SESSION_CALLBACK GetDefaultCallback() {
|
||
return _dflt_callback;
|
||
};
|
||
|
||
// 队列快捷访问的宏定义
|
||
TAILQ_ENTRY(CDestLinks) _link_entry;
|
||
uint64_t _release_time;
|
||
|
||
private:
|
||
|
||
uint32_t _timeout; ///< idle的超时时间
|
||
uint32_t _addr_ipv4; ///< ip地址
|
||
uint16_t _net_port; ///< port 网络序列
|
||
MT_PROTO_TYPE _proto_type; ///< 协议类型
|
||
MT_CONN_TYPE _conn_type; ///< 连接类型
|
||
|
||
uint32_t _max_links; ///< 最大连接数
|
||
uint32_t _curr_link; ///< 当前连接数
|
||
TLinkList _sock_list; ///< 连接链表
|
||
CHECK_SESSION_CALLBACK _dflt_callback; ///< 默认的check函数
|
||
|
||
};
|
||
typedef TAILQ_HEAD(__DestlinkList, CDestLinks) TDestList; ///< 高效的双链管理
|
||
typedef CRecyclePool<TDestList, CDestLinks> TDestPool; ///< 定时回收的对象池
|
||
|
||
/**
|
||
* @brief 连接管理工厂模型
|
||
*/
|
||
class CNetMgr
|
||
{
|
||
public:
|
||
|
||
/**
|
||
* @brief 消息buff的全局管理句柄接口
|
||
* @return 全局句柄指针
|
||
*/
|
||
static CNetMgr* Instance (void);
|
||
|
||
/**
|
||
* @brief 消息清理接口
|
||
*/
|
||
static void Destroy(void);
|
||
|
||
// 查询是否已经存在同一个sid的对象
|
||
CNetHandler* FindNetItem(CNetHandler* key);
|
||
|
||
// 注册一个item, 先查询后插入, 保证无冲突
|
||
void InsertNetItem(CNetHandler* item);
|
||
|
||
// 移除一个item对象
|
||
void RemoveNetItem(CNetHandler* item);
|
||
|
||
// 查询或创建一个目标ip的links节点
|
||
CDestLinks* FindCreateDest(CDestLinks* key);
|
||
|
||
// 删除掉已有的目标链路信息
|
||
void DeleteDestLink(CDestLinks* dst);
|
||
|
||
// 查询是否已经存在同一个sid的对象
|
||
CDestLinks* FindDestLink(CDestLinks* key);
|
||
|
||
// 注册一个item, 先查询后插入, 保证无冲突
|
||
void InsertDestLink(CDestLinks* item);
|
||
|
||
// 移除一个item对象
|
||
void RemoveDestLink(CDestLinks* item);
|
||
|
||
/**
|
||
* @brief 消息buff的析构函数
|
||
*/
|
||
~CNetMgr();
|
||
|
||
/**
|
||
* @brief 回收资源信息
|
||
*/
|
||
void RecycleObjs(uint64_t now);
|
||
|
||
// 分配一个网络管理句柄
|
||
CNetHandler* AllocNetItem() {
|
||
return _net_item_pool.AllocItem();
|
||
};
|
||
|
||
// 释放一个网络管理句柄
|
||
void FreeNetItem(CNetHandler* item) {
|
||
return _net_item_pool.FreeItem(item);
|
||
};
|
||
|
||
// 分配一个SOCK连接链路
|
||
CSockLink* AllocSockLink() {
|
||
return _sock_link_pool.AllocItem();
|
||
};
|
||
|
||
// 释放一个SOCK连接链路
|
||
void FreeSockLink(CSockLink* item) {
|
||
return _sock_link_pool.FreeItem(item);
|
||
};
|
||
|
||
// 分配一个SOCK连接链路
|
||
CDestLinks* AllocDestLink() {
|
||
return _dest_ip_pool.AllocItem();
|
||
};
|
||
|
||
// 释放一个SOCK连接链路
|
||
void FreeDestLink(CDestLinks* item) {
|
||
return _dest_ip_pool.FreeItem(item);
|
||
};
|
||
|
||
// 获取udp的buff池信息
|
||
TSkBuffMng* GetSkBuffMng(MT_PROTO_TYPE type) {
|
||
if (type == NET_PROTO_TCP) {
|
||
return &_tcp_pool;
|
||
} else {
|
||
return &_udp_pool;
|
||
}
|
||
};
|
||
|
||
|
||
private:
|
||
/**
|
||
* @brief 消息buff的构造函数
|
||
*/
|
||
CNetMgr();
|
||
|
||
static CNetMgr * _instance; ///< 单例类句柄
|
||
HashList* _ip_hash; ///< 目的地址hash
|
||
HashList* _session_hash; ///< session id的hash
|
||
TSkBuffMng _udp_pool; ///< udp pool, 64K
|
||
TSkBuffMng _tcp_pool; ///< tcp pool, 4K
|
||
TDestPool _dest_ip_pool; ///< 目的ip对象池
|
||
TLinkPool _sock_link_pool; ///< socket pool
|
||
TNetItemPool _net_item_pool; ///< net handle pool
|
||
};
|
||
|
||
|
||
|
||
|
||
|
||
}
|
||
|
||
#endif
|
||
|
||
|