Files
STM32F4-Base/IEC60870-Slave/104/IEC104_SendManager.c
T
STF bdcc8b6500
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s
添加遥控、参数装载、文件传输等业务
2026-11-16 22:19:17 -08:00

1878 lines
106 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 子站串行发送管理:发送流程、子站启停封装和初始化入口集中在本文件。
* 本模块由Connection内部调用;业务通过TcpServer提交ASDU并读取事件副本,不直接操作Manager。
* 完成分派按原帧类型直接调用公共或子站Link接口,不经过角色回调。
* S/TESTFR与子站启停构帧入口复用控制槽预留、取消和提交,状态机仍由Link维护。
* Init只绑定CONTROLLED链路;启停流程接收ACT并发送CON。
*/
#include "IEC104_SendManager.h"
#include "IEC104_Link_Slave_StartStop.h"
#include <stddef.h>
#include <string.h>
/* ==================== 公共管理:调度、进度、确认与回收 ==================== */
/**
* 功能:计算15位序号沿发送方向的循环距离。
* 输入参数:from——起始序号,范围0..32767。
* to——目标序号,范围0..32767。
* 输出参数:无。
* 返回值:0..32767范围内的模32768距离。
* 说明:调用方须先保证区间受窗口或容量约束;不能直接用序号大小判断先后。
*/
static uint16_t Sequence_Distance(uint16_t from, uint16_t to)
{
return (uint16_t)(((uint32_t)to + 32768U - from) & IEC104_SEQUENCE_MASK);
}
/**
* 功能:将业务记录相对队首的逻辑偏移换算为数组下标。
* 输入参数:manager——存储边界已验证且record_capacity非零的发送管理器。
* offset——相对记录队首的槽数偏移,不是字节数,可定位现有记录或下一个空槽。
* 输出参数:无。
* 返回值:0..record_capacity-1范围内的物理下标。
* 说明:用32位加法避免索引相加溢出;本函数不验证该槽是否已有有效记录。
*/
static uint16_t Record_Index_From_Offset(const IEC104_SendManager_t *manager, uint16_t offset)
{
return (uint16_t)(((uint32_t)manager->record_head_index + offset) % manager->record_capacity);
}
/**
* 功能:检查发送管理器自身的存储边界、绑定指针和配置。
* 输入参数:manager——待检查的发送管理器,允许NULL。
* 输出参数:无。
* 返回值:控制结构合法返回1,否则返回0。
* 说明:不要求Link及两个队列仍可运行,也不扫描业务记录。
* 故障回收仍须读取帧身份、NORMAL来源编号和ACK事实,不能被故障后的会话状态阻断。
*/
static int Manager_Storage_Valid(const IEC104_SendManager_t *manager)
{
return manager != NULL && manager->is_initialized == 1U && manager->asdu_queue != NULL &&
manager->send_buffer != NULL && manager->link_state != NULL && manager->records != NULL &&
manager->record_capacity != 0U && manager->record_capacity <= IEC104_SEQUENCE_MASK &&
manager->record_head_index < manager->record_capacity &&
manager->record_count <= manager->record_capacity && manager->connection_generation != 0U &&
(uint32_t)manager->high_unacked_count + manager->idle_unacked_count <= manager->record_count &&
manager->send_window_k != 0U && manager->send_window_k <= IEC104_SEQUENCE_MASK &&
manager->next_record_ns <= IEC104_SEQUENCE_MASK &&
manager->high_priority_burst_count <= manager->high_priority_burst_limit;
}
/**
* 功能:检查业务记录的身份、序号快照、完成标志及有效发送时刻。
* 输入参数:manager——已通过Manager_Storage_Valid检查的发送管理器。
* record——指向已登记记录的非NULL指针。
* offset——该记录相对队首的偏移,调用方保证小于record_count。
* 输出参数:无。
* 返回值:记录符合当前位置的约束返回1,否则返回0。
* 说明:队列发送及直接应答共用Prepare_I_Asdu连续登记,记录只从队首释放,因此首条N(S)=next_record_ns-record_count。
* 记录容量小于序号环,可按offset推导唯一N(S)。
* 本地完成和对端ACK分别记录;已确认的业务记录必须已经提交本地完成。
*/
static int I_Frame_Record_Valid(const IEC104_SendManager_t *manager,
const IEC104_IFrameSendRecordStorage_t *record, uint16_t offset)
{
uint16_t expected = (uint16_t)(((uint32_t)manager->next_record_ns + 32768U -
manager->record_count + offset) & IEC104_SEQUENCE_MASK);
return record->frame_serial != 0U &&
(((record->asdu_priority == IEC104_ASDU_PRIORITY_HIGH ||
record->asdu_priority == IEC104_ASDU_PRIORITY_IDLE) && record->asdu_entry_serial == 0U) ||
(record->asdu_priority == IEC104_ASDU_PRIORITY_NORMAL && record->asdu_entry_serial != 0U)) &&
record->i_frame_snapshot.send_number == expected && record->i_frame_snapshot.receive_number <= IEC104_SEQUENCE_MASK &&
record->i_frame_snapshot.frame_length >= IEC104_APCI_LEN + IEC104_ASDU_HEADER_LEN &&
record->i_frame_snapshot.frame_length <= IEC104_MAX_APDU_LEN &&
record->local_send_completed <= 1U && record->peer_acknowledged <= 1U &&
(record->peer_acknowledged == 0U || record->local_send_completed != 0U) &&
(record->local_send_completed == 0U || record->written_at_ms >= record->queued_at_ms);
}
/**
* 功能:检查当前连接的Link序号、当前I帧、保留ASDU和记录数量是否一致。
* 输入参数:manager——待检查对象,允许NULL;connection_generation——本次事件的代次。
* 输出参数:无,通过公开查询读取各模块数值,不修改它们的控制字段。
* 返回值:运行状态自洽返回1,否则0;不证明TCP仍然可用。
* 说明:Link独占协议边界;Buffer报告至多一个当前I帧;HIGH/IDLE未确认数量由Manager维护。
* 本模块只服务CONTROLLED角色,绑定后的角色变化属于本地状态非法。
* HIGH/IDLE未确认记录数加NORMAL保留及覆盖待确认条目数,等于Link已编号未ACK的I帧数。
* 未消费的已ACK回执仍占记录,所以record_count可以大于未ACK帧数。
* 公开入口不允许遗留预留;整个跨模块事务完成后才检查,不能检查提交中间态。
*/
static int Manager_Session_Valid(const IEC104_SendManager_t *manager, uint64_t connection_generation)
{
IEC104_IFrameSendProgress_t link_progress;
IEC104_LinkStatus_t link_status;
IEC104_AsduQueueStatus_t asdu_status;
IEC104_SendBufferStatus_t buffer_status;
uint16_t pending, outstanding;
if (!Manager_Storage_Valid(manager) || connection_generation != manager->connection_generation ||
IEC104_Link_Get_Status(manager->link_state, &link_status) != 1 ||
link_status.role != IEC104_ROLE_CONTROLLED ||
IEC104_Link_Get_Send_Progress(manager->link_state, &link_progress) != 1 ||
IEC104_AsduQueue_Get_Status(manager->asdu_queue, &asdu_status) != IEC104_ASDU_QUEUE_OK ||
IEC104_SendBuffer_Get_Status(manager->send_buffer, &buffer_status) != IEC104_SEND_BUFFER_OK ||
asdu_status.connection_generation != connection_generation ||
buffer_status.connection_generation != connection_generation) {
return 0;
}
/* pending只统计唯一当前I帧;outstanding还包含已经写完但尚未ACK的I帧。 */
pending = Sequence_Distance(link_progress.next_completion_ns, link_progress.next_frame_ns);
outstanding = Sequence_Distance(link_progress.peer_ack_nr, link_progress.next_frame_ns);
return manager->next_record_ns == link_progress.next_frame_ns &&
pending <= 1U && buffer_status.has_i_frame == pending &&
(pending == 0U || buffer_status.i_frame_ns == link_progress.next_completion_ns) &&
buffer_status.has_reservation == 0U && outstanding <= manager->send_window_k &&
manager->record_count >= outstanding &&
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_HIGH] == 0U &&
(uint64_t)manager->high_unacked_count + manager->idle_unacked_count +
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL] +
asdu_status.overwritten_unacked_count == outstanding;
}
/**
* 功能:已校验会话;START受理即允许接手应答,STOP受理即拒绝。
* 输入参数:manager——发送管理器。
* 输出参数:无。
* 返回值:1表示已启动且启停过程空闲,允许接手应答,否则0。
* 说明:这里只判生命周期准入;实际选帧由兼容模式的FIFO/配额或严格模式的业务等级决定。
*/
static int Response_Submit_Allowed(const IEC104_SendManager_t *manager)
{
const IEC104_LinkState_t *state = manager->link_state;
return state->dt_state == IEC104_DT_STARTED && state->dt_procedure == IEC104_DT_PROC_IDLE;
}
/**
* 功能:只在已验证的会话上调用;本层检查链路阶段、发送缓冲、两级业务队列和编号资源。
* 输入参数:manager——发送管理器。
* reserve——须保留的窗口及记录槽数量。
* priority——优先级。
* 输出参数:无。
* 返回值:合法reserve暂时不能保留足额余量才返回WAIT。
* 说明:当前帧和控制帧先于新的IDLE;兼容模式另让出全部排队业务,严格模式仅让出同级及更高级可选条目。
* 上层另查未读通知、待交付请求及协议期限,不能用此处的队列空闲代替完整业务就绪判定。
* 启动暂停必须单独检查:IDLE不经过NORMAL选帧,即使队列为空也不能绕过启动顺序。
* reserve本身占满任一种资源属于配置错误;合法reserve暂时不能保留足额余量才返回WAIT。
*/
static IEC104_SendManagerResult_t Idle_Admission(const IEC104_SendManager_t *manager, uint16_t reserve,
IEC104_BusinessPriority_t priority)
{
IEC104_SendBufferHeadInfo_t head;
IEC104_AsduHeadInfo_t queued;
IEC104_AsduQueueResult_t result;
unsigned lane;
IEC104_IFrameSendProgress_t progress;
IEC104_SendBufferResult_t buffer;
uint16_t outstanding;
int link;
if (reserve >= manager->send_window_k || reserve >= manager->record_capacity) {
return IEC104_SEND_MANAGER_ERROR;
}
if (!Response_Submit_Allowed(manager) || manager->asdu_queue->startup_pending != 0U) {
return IEC104_SEND_MANAGER_WAIT;
}
buffer = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head);
if (buffer == IEC104_SEND_BUFFER_OK) { return IEC104_SEND_MANAGER_WAIT; }
if (buffer != IEC104_SEND_BUFFER_EMPTY) { return IEC104_SEND_MANAGER_ERROR; }
if (priority < IEC104_BUSINESS_PRIORITY_NONE || priority >= IEC104_BUSINESS_PRIORITY_COUNT) {
return IEC104_SEND_MANAGER_ERROR;
}
if (manager->asdu_queue->strict_business_priority != 0U) {
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_MEASUREMENT; }
/* pending是尚未组帧的立即就绪候选,direct是应用本轮授予的取值/直交阶段。
* 两者都要检查:只看已编码队列会漏掉目录扫描等本轮尚未完成准备的高级业务。 */
if ((manager->pending_business_priority != IEC104_BUSINESS_PRIORITY_NONE &&
priority > manager->pending_business_priority) ||
(manager->business_cycle_active != 0U &&
(manager->direct_business_priority != priority || manager->business_frame_used != 0U))) {
return IEC104_SEND_MANAGER_WAIT;
}
for (lane = 0U; lane < IEC104_ASDU_PRIORITY_COUNT; ++lane) {
result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, (IEC104_AsduPriority_t)lane, &queued);
if (result == IEC104_ASDU_QUEUE_ERROR) { return IEC104_SEND_MANAGER_ERROR; }
/* IDLE此刻才提交;同级已入队条目更早接手,必须先发,保证跨生命周期的同级FIFO。 */
if (result == IEC104_ASDU_QUEUE_OK && queued.business_priority <= priority) {
return IEC104_SEND_MANAGER_WAIT;
}
}
} else {
IEC104_AsduQueueStatus_t queued_status;
/* 保留兼容模式“全部未交接原文先于IDLE”的准入规则,并计入独立SOE及补报占位。 */
if (IEC104_AsduQueue_Get_Status(manager->asdu_queue, &queued_status) != IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_ERROR;
}
if (queued_status.entry_count[IEC104_ASDU_PRIORITY_HIGH] != 0U ||
queued_status.entry_count[IEC104_ASDU_PRIORITY_NORMAL] >
queued_status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL]) {
return IEC104_SEND_MANAGER_WAIT;
}
}
link = IEC104_Link_Can_Prepare_I_Frame(manager->link_state, manager->send_window_k);
if (link < 0 || IEC104_Link_Get_Send_Progress(manager->link_state, &progress) != 1) {
return IEC104_SEND_MANAGER_ERROR;
}
/* 已ACK未消费的记录仍占槽,所以窗口余量与记录余量分别扣除本帧及reserve。 */
outstanding = Sequence_Distance(progress.peer_ack_nr, progress.next_frame_ns);
if (link == 0 || (uint32_t)outstanding + 1U + reserve > manager->send_window_k ||
(uint32_t)manager->record_count + 1U + reserve > manager->record_capacity) {
return IEC104_SEND_MANAGER_WAIT;
}
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:纯查询,不编号、不占槽;
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* reserve——须保留的窗口及记录槽数量。
* priority——优先级。
* 输出参数:无。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、Idle_Admission(manager, reserve, priority)。
* 说明:取值期间状态可能变化,Submit必须再执行同一准入判定。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Can_Submit_Idle_Priority(
const IEC104_SendManager_t *manager, uint64_t connection_generation, uint16_t reserve,
IEC104_BusinessPriority_t priority)
{
if (!Manager_Session_Valid(manager, connection_generation)) { return IEC104_SEND_MANAGER_ERROR; }
return Idle_Admission(manager, reserve, priority);
}
/**
* 功能:使用默认业务等级查询IDLE业务的发送准入条件。
* 输入参数:manager/connection_generation——发送管理器及代次;reserve——提交后须保留的资源数量。
* 输出参数:无。
* 返回值:OK当前可提交;WAIT暂受链路、队列或资源限制;ERROR为参数或会话非法。
* 说明:只查询,不分配N(S)或预留槽位;实际提交仍须重新检查。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Can_Submit_Idle(
const IEC104_SendManager_t *manager, uint64_t connection_generation, uint16_t reserve)
{
return IEC104_SendManager_Can_Submit_Idle_Priority(manager, connection_generation, reserve, IEC104_BUSINESS_PRIORITY_NONE);
}
/**
* 功能:返回发送记录存储概况,使连接层无需读取Manager内部字段。
* 输入参数:manager——尚未Abort的管理器;status——不重叠的输出存储。
* 输出参数:status——状态快照的更新结果。
* 返回值:OK写数值副本,ERROR参数/存储非法且不改输出。
* 说明:不依赖故障后的Link运行状态,可在连接冻结期间用于记录回收和状态展示。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Get_Status(
const IEC104_SendManager_t *manager, IEC104_SendManagerStatus_t *status)
{
IEC104_SendManagerStatus_t prepared;
if (status == NULL || !Manager_Storage_Valid(manager)) {
return IEC104_SEND_MANAGER_ERROR;
}
prepared.connection_generation = manager->connection_generation;
prepared.record_capacity = manager->record_capacity;
prepared.record_count = manager->record_count;
prepared.high_unacked_count = manager->high_unacked_count;
*status = prepared;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:校验当前发送会话后,将业务ASDU交给绑定队列复制保存。
* 输入参数:manager/connection_generation——有效会话及代次;priority/asdu/asdu_length——待入队业务。
* 输出参数:manager——发送管理器的更新结果。
* 返回值:OK成功,WAIT容量/条目编号窗口不足,ERROR参数、会话或HIGH准入阶段非法。
* 说明:调用关系:Connection推迟应答及Submit_Response回退时使用,向上隐藏队列指针及专用返回值。
* HIGH与Submit_Response共用准入检查,先于队列容量判断;NORMAL不受此检查限制。
* 内部条目编号由队列管理,协议N(S)在实际准备I帧时分配;不推进发送进度。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Enqueue(
IEC104_SendManager_t *manager, uint64_t connection_generation,
IEC104_AsduPriority_t priority, const uint8_t *asdu, uint16_t asdu_length)
{
IEC104_AsduQueueResult_t result;
if (!Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
if (priority == IEC104_ASDU_PRIORITY_HIGH && !Response_Submit_Allowed(manager)) {
return IEC104_SEND_MANAGER_ERROR;
}
/* 队列同步复制原文;这里不创建APDU,后续Prepare_Next_Send才选择业务并分配协议序号。 */
result = IEC104_AsduQueue_Enqueue(manager->asdu_queue, connection_generation, priority, asdu, asdu_length);
if (result == IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_OK;
}
/* FULL是可等待的背压;其他非法输入或状态统一返回ERROR,不作为容量不足反复重试。 */
return result == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
}
/**
* 功能:应答始终属于当前HIGH会话;
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* asdu——ASDU报文。
* asdu_length——ASDU字节长度。
* ticket——应答交接票据。
* priority——优先级。
* 输出参数:manager——发送管理器的更新结果。
* ticket——应答交接票据的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK、result == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR。
* 说明:成功才输出交接凭证,不在此处分配N(S)。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Enqueue_Response_Priority(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint64_t *ticket,
IEC104_BusinessPriority_t priority)
{
IEC104_AsduQueueResult_t result;
if (!Manager_Session_Valid(manager, connection_generation) || !Response_Submit_Allowed(manager)) {
return IEC104_SEND_MANAGER_ERROR;
}
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_INTERROGATION; }
result = IEC104_AsduQueue_Enqueue_Response_Priority(manager->asdu_queue, connection_generation,
asdu, asdu_length, ticket, priority);
if (result == IEC104_ASDU_QUEUE_OK) { return IEC104_SEND_MANAGER_OK; }
return result == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
}
/**
* 功能:使用默认业务等级将应答复制到HIGH队列。
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
* 输出参数:ticket——成功时的交接票据,可为NULL。
* 返回值:OK已接手;WAIT暂无入队空间;ERROR为参数、链路阶段或队列状态非法。
* 说明:严格模式默认总召等级;本入口只排队,不分配N(S)或准备I帧。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Enqueue_Response(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint64_t *ticket)
{
return IEC104_SendManager_Enqueue_Response_Priority(manager, connection_generation, asdu, asdu_length, ticket, IEC104_BUSINESS_PRIORITY_NONE);
}
/**
* 功能:为发送队首定位尚未提交本地完成的I帧业务记录。
* 输入参数:manager——会话及存储边界已验证的发送管理器。
* head_info——当前发送队首的有效I帧信息,代次已由调用入口验证。
* 输出参数:无,不修改记录。
* 返回值:成功返回内部记录指针;找不到或身份、快照不匹配时返回NULL。
* 说明:先按N(S)计算偏移,再核对frame_id的frame_serial、原始N(R)、长度和入队时刻。
* 不能只用可能回绕的N(S)识别完成事件;返回指针只供当前串行操作使用。
*/
static IEC104_IFrameSendRecordStorage_t *Find_Pending_Send_Record(IEC104_SendManager_t *manager,
const IEC104_SendBufferHeadInfo_t *head_info)
{
uint16_t first = (uint16_t)(((uint32_t)manager->next_record_ns + 32768U -
manager->record_count) & IEC104_SEQUENCE_MASK);
uint16_t offset = Sequence_Distance(first, head_info->i_frame_snapshot.send_number);
IEC104_IFrameSendRecordStorage_t *record;
if (offset >= manager->record_count) {
return NULL;
}
record = &manager->records[Record_Index_From_Offset(manager, offset)];
if (!I_Frame_Record_Valid(manager, record, offset) || record->local_send_completed != 0U ||
record->frame_serial != head_info->frame_id.frame_serial ||
record->i_frame_snapshot.receive_number != head_info->i_frame_snapshot.receive_number ||
record->i_frame_snapshot.frame_length != head_info->apdu_length || record->queued_at_ms != head_info->queued_at_ms) {
return NULL;
}
return record;
}
/**
* 功能:按保存的帧类型将完整发送或发送失败结果交给对应链路完成接口。
* 输入参数:manager——已校验的子站管理器,绑定本连接CONTROLLED链路。
* head_info——有效队首信息,保存原始帧类型及I帧快照。
* sent_len——实际整帧发送长度;发送失败时传-1。
* 输出参数:manager->link_state——由匹配的链路完成接口按其约定提交或清理状态。
* 返回值:返回对应接口的OK、IGNORED或FATAL;本端不支持的帧类型返回FATAL。
* 说明:不按当前dt_procedure猜测报文身份,不执行I/O或发送队列出队。
* STARTDT_CON/STOPDT_CON直接提交子站完成接口;帧类型在缓冲提交时已完成校验。
* TESTFR_CON为无状态应答,没有Link完成接口;长度为6返回OK,否则返回FATAL。
*/
static IEC104_LinkResult_t Dispatch_Link_Send_Completion(const IEC104_SendManager_t *manager,
const IEC104_SendBufferHeadInfo_t *head_info, int sent_len)
{
IEC104_LinkState_t *link_state = manager->link_state;
switch (head_info->frame_type) {
case IEC104_SEND_BUFFER_FRAME_I:
return IEC104_Link_Complete_I_Send(link_state, &head_info->i_frame_snapshot, sent_len);
case IEC104_SEND_BUFFER_FRAME_S_ACK:
return IEC104_Link_Complete_S_Ack_Send(link_state, sent_len);
case IEC104_SEND_BUFFER_FRAME_STARTDT_CON:
return IEC104_Link_Complete_Startdt_Con_Send(link_state, sent_len);
case IEC104_SEND_BUFFER_FRAME_STOPDT_CON:
return IEC104_Link_Complete_Stopdt_Con_Send(link_state, sent_len);
case IEC104_SEND_BUFFER_FRAME_TESTFR_ACT:
return IEC104_Link_Complete_Testfr_Act_Send(link_state, sent_len);
case IEC104_SEND_BUFFER_FRAME_TESTFR_CON:
return sent_len == IEC104_APCI_LEN ? IEC104_LINK_RESULT_OK : IEC104_LINK_RESULT_FATAL;
default:
return IEC104_LINK_RESULT_FATAL;
}
}
/**
* 功能:校验同连接各模块的状态,并为一帧S/U取得控制槽。
* 输入参数:manager——待校验的管理器;connection_generation——本次调用所属连接代次。
* 输出参数:reservation——非NULL,仅OK时写入帧身份、可写APDU地址及容量。
* 返回值:OK表示预留成功;缓冲报告FULL/BUSY时返回WAIT;会话或缓冲非法返回ERROR。
* 调用关系:公共S/TESTFR及子站应答入口在调用Link构帧前使用,成功后须提交或取消预留。
* 说明:本函数不调用Link构帧或接收处理,不改变链路过程;WAIT表示尚未取得应答槽。
* TESTFR接收入口在本函数之前登记主站ACT事实,WAIT不撤回该事实。
* 预留只占用控制槽,不进入发送FIFO,也不占用Manager的I帧业务记录槽。
* 会话入口要求无外部遗留预留,因此外部未结束的预留会先被判为ERROR。
*/
static IEC104_SendManagerResult_t Reserve_Control_Frame(
IEC104_SendManager_t *manager, uint64_t connection_generation,
IEC104_SendBufferReservation_t *reservation)
{
IEC104_SendBufferResult_t result;
if (!Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
result = IEC104_SendBuffer_Reserve_S_U_Frame(manager->send_buffer, reservation);
if (result == IEC104_SEND_BUFFER_FULL || result == IEC104_SEND_BUFFER_BUSY) {
return IEC104_SEND_MANAGER_WAIT;
}
return result == IEC104_SEND_BUFFER_OK ? IEC104_SEND_MANAGER_OK : IEC104_SEND_MANAGER_ERROR;
}
/**
* 功能:归还本次未生成S/U报文的预留控制槽,并传回调用方选定的处理结果。
* 输入参数:manager——已校验的管理器;reservation——本次有效预留;result——取消成功后的返回值。
* 输出参数:无独立输出对象;成功时由SendBuffer释放预留,已使用的frame_serial不复用。
* 返回值:取消成功原样返回result,取消失败返回FATAL,要求结束连接。
* 前置条件:指针有效,Link尚未为本次预留生成报文;不可用于撤回已经构帧成功的发送义务。
* 说明:只归还尚未提交的控制槽,不回滚Link状态。
*/
static IEC104_SendManagerResult_t Cancel_Control_Reservation(
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
IEC104_SendManagerResult_t result)
{
return IEC104_SendBuffer_Cancel_Reservation(manager->send_buffer, reservation->frame_id) ==
IEC104_SEND_BUFFER_OK ? result : IEC104_SEND_MANAGER_FATAL;
}
/**
* 功能:将预留控制槽内已生成的固定6字节S/U报文追加到发送FIFO。
* 输入参数:manager——已校验的管理器;reservation——本次有效预留,APDU已由Link写入;
* frame_type——与APDU一致的S/U完成分派类型;now_ms——本次入队单调时刻,允许0。
* 输出参数:无独立输出对象;SendBuffer保存帧类型、长度及入队时间,不登记I帧业务记录。
* 返回值:QUEUED表示提交成功;FATAL表示提交失败,须结束连接,不能按容量不足重试。
* 前置条件:指针有效且Link已生成报文;S/U不传I帧快照,容量已由Reserve_Control_Frame保障。
* 说明:失败时不取消预留、不回滚Link;成功后实际I/O及Handle_Send_Progress另由接入方驱动。
*/
static IEC104_SendManagerResult_t Commit_Control_Frame(
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
IEC104_SendBufferFrameType_t frame_type, uint64_t now_ms)
{
return IEC104_SendBuffer_Commit_Frame(manager->send_buffer, reservation->frame_id,
frame_type, IEC104_APCI_LEN, NULL, now_ms) == IEC104_SEND_BUFFER_OK ?
IEC104_SEND_MANAGER_QUEUED : IEC104_SEND_MANAGER_FATAL;
}
/**
* 功能:将公共S/TESTFR准备接口返回的长度转换为提交或取消操作。
* 输入参数:manager/reservation——已校验的管理器及本次有效预留;frame_type——预期帧类型;
* length——Link.Prepare的原始返回值;now_ms——生成报文时使用的入队时刻。
* 输出参数:无独立输出对象;按length提交FIFO或归还预留,不执行网络发送。
* 返回值:length为6时提交并返回QUEUED;为0时取消并返回WAIT;为负时取消并返回ERROR;
* 提交/取消失败或其他正长度返回FATAL。
* 说明:0/负值表示Link未生成报文,才允许取消;异常正长度可能已有发送义务,保留现场并断连。
*/
static IEC104_SendManagerResult_t Finish_Control_Prepare(
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
IEC104_SendBufferFrameType_t frame_type, int length, uint64_t now_ms)
{
if (length <= 0) {
return Cancel_Control_Reservation(manager, reservation,
length == 0 ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR);
}
if (length != IEC104_APCI_LEN) {
return IEC104_SEND_MANAGER_FATAL;
}
return Commit_Control_Frame(manager, reservation, frame_type, now_ms);
}
/**
* 功能:按接收门限、立即确认或子站停止排空规则生成S确认并入队。
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;w——1..32767的门限;
* immediate——非0表示立即确认;now_ms——入队单调时刻,允许0。
* 输出参数:无独立输出对象;生成成功时Link保存本帧N(R)及S在途状态,SendBuffer持有报文。
* 返回值:QUEUED表示S入队;WAIT表示控制容量不足,或Link判断当前无需、不能生成;
* ERROR表示参数、会话或准备结果非法;提交/取消异常返回FATAL。
* 调用时机:接收I帧后、启动CON完成后或确认条件变化时,由连接调度代码驱动。
* 说明:immediate只跳过数量门限,不跳过启停门控、已有S在途及无待确认数据检查。
* 构帧只冻结N(R),完整发送后由Handle_Send_Progress提交确认;WAIT不等于已确认。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Queue_S_Ack(
IEC104_SendManager_t *manager, uint64_t connection_generation,
uint16_t w, int immediate, uint64_t now_ms)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendManagerResult_t result;
int length;
if (w == 0U || w > IEC104_SEQUENCE_MASK) {
return IEC104_SEND_MANAGER_ERROR;
}
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
if (result != IEC104_SEND_MANAGER_OK) {
return result;
}
length = IEC104_Link_Prepare_S_Ack(manager->link_state, w, immediate,
reservation.apdu, reservation.apdu_capacity);
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_S_ACK, length, now_ms);
}
/**
* 功能:待确认数据的t2到期后,按公共S确认规则构帧并入队。
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;
* elapsed_ms——从原待确认数据起点计算的经过毫秒数;t2_ms——非0的t2配置;
* now_ms——本次入队单调时刻,与elapsed_ms的相对时间含义不同。
* 输出参数:无独立输出对象;成功时Link记录S在途状态,报文进入SendBuffer。
* 返回值:QUEUED表示S入队;WAIT表示控制容量不足、未到期或Link当前不生成S;
* ERROR表示参数、会话或准备结果非法;提交/取消异常返回FATAL。
* 调用时机:接入方的定时唤醒或连接调度;elapsed_ms等于t2_ms即满足到期条件。
* 说明:到期仍受启停及已有S在途约束;函数不读取时钟、不重置起点,重试须沿用原计时。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Queue_T2_Ack(
IEC104_SendManager_t *manager, uint64_t connection_generation,
uint32_t elapsed_ms, uint32_t t2_ms, uint64_t now_ms)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendManagerResult_t result;
int length;
if (t2_ms == 0U) {
return IEC104_SEND_MANAGER_ERROR;
}
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
if (result != IEC104_SEND_MANAGER_OK) {
return result;
}
length = IEC104_Link_Prepare_T2_Ack(manager->link_state, elapsed_ms, t2_ms,
reservation.apdu, reservation.apdu_capacity);
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_S_ACK, length, now_ms);
}
/**
* 功能:子站主动生成并排队一帧TESTFR_ACT。
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;now_ms——入队单调时刻。
* 输出参数:无独立输出对象;生成后Link进入ACT_SEND_PENDING,SendBuffer持有ACT报文。
* 返回值:QUEUED表示ACT入队;WAIT表示容量不足、已有探测或已收到主站ACT;ERROR表示会话或准备非法;
* 提交/取消异常返回FATAL。
* 调用时机:连接调度代码决定主动探测时;按空闲时间触发可使用Queue_T3_Testfr。
* 说明:本入口不检查空闲时长。ACT完整发送后才由Handle_Send_Progress提交CON_PENDING,
* 接入方以实际written_at_ms作为等待CON的t1起点;不能在入队时提前提交发送完成。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Queue_Testfr_Act(
IEC104_SendManager_t *manager, uint64_t connection_generation, uint64_t now_ms)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendManagerResult_t result = Reserve_Control_Frame(manager, connection_generation, &reservation);
int length;
if (result != IEC104_SEND_MANAGER_OK) {
return result;
}
length = IEC104_Link_Prepare_Testfr_Act(manager->link_state, reservation.apdu, reservation.apdu_capacity);
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_TESTFR_ACT, length, now_ms);
}
/**
* 功能:链路空闲达到t3后,复用Link的主动探测流程生成TESTFR_ACT并入队。
* 输入参数:manager——当前连接管理器;connection_generation——连接代次;
* idle_elapsed_ms——接入方计算的空闲毫秒数;t3_ms——非0的t3配置;now_ms——入队单调时刻。
* 输出参数:无独立输出对象;生成成功后记录ACT待发送状态,并发布到同一FIFO。
* 返回值:QUEUED表示ACT入队;WAIT表示容量不足、未到期、已有探测或已收到主站ACT;
* ERROR表示参数、会话或准备结果非法;提交/取消异常返回FATAL。
* 调用时机:接入方定时唤醒后,以当前有效活动起点计算时间差;等于t3_ms即满足到期条件。
* 说明:不创建定时器、不更新活动起点;已有探测的t1不能因活动、重复调用或WAIT而续期。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Queue_T3_Testfr(
IEC104_SendManager_t *manager, uint64_t connection_generation,
uint32_t idle_elapsed_ms, uint32_t t3_ms, uint64_t now_ms)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendManagerResult_t result;
int length;
if (t3_ms == 0U) {
return IEC104_SEND_MANAGER_ERROR;
}
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
if (result != IEC104_SEND_MANAGER_OK) {
return result;
}
length = IEC104_Link_Prepare_T3_Testfr(manager->link_state, idle_elapsed_ms, t3_ms,
reservation.apdu, reservation.apdu_capacity);
return Finish_Control_Prepare(manager, &reservation, IEC104_SEND_BUFFER_FRAME_TESTFR_ACT, length, now_ms);
}
/**
* 功能:子站接收TESTFR_ACT,为其生成并排队一帧TESTFR_CON。
* 输入参数:manager——当前连接管理器;connection_generation——接收所属连接代次;
* apci——已通过Parse_APCI且功能码为TESTFR_ACT的U帧;now_ms——应答入队单调时刻。
* 输出参数:合法接收立即禁止本连接的新主动ACT;QUEUED时SendBuffer另持有CON,已有探测进度不变。
* 返回值:QUEUED表示应答入队;WAIT表示已登记接收事实,但尚未取得CON应答槽;
* ERROR表示前置输入或会话非法,未登记接收事实;登记后的预留、编码或提交异常返回FATAL。
* 调用链:会话校验 -> Link.Handle_Testfr_Act -> Reserve_Control_Frame -> Build_Uframe -> Commit。
* 说明:先记录主站ACT,避免应答背压期间新生主动ACT;幂等登记不等于可以丢弃应答。
* WAIT须按序保留请求后重试,无法保留则断连;收到多个ACT时分别调用并逐个应答。
* TESTFR_CON没有Link完成接口,但实际发送仍交给Handle_Send_Progress/Failure统一处理。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Testfr_Act(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const IEC104_ApciInfo_t *apci, uint64_t now_ms)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendManagerResult_t result;
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_TESTFR_ACT ||
!Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
if (IEC104_Link_Handle_Testfr_Act(manager->link_state, apci) != IEC104_LINK_RESULT_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
if (result != IEC104_SEND_MANAGER_OK) {
return result == IEC104_SEND_MANAGER_WAIT ? result : IEC104_SEND_MANAGER_FATAL;
}
if (reservation.apdu_capacity < IEC104_APCI_LEN ||
IEC104_Build_Uframe(reservation.apdu, IEC104_U_TESTFR_CON) != IEC104_APCI_LEN) {
return Cancel_Control_Reservation(manager, &reservation, IEC104_SEND_MANAGER_FATAL);
}
return Commit_Control_Frame(manager, &reservation, IEC104_SEND_BUFFER_FRAME_TESTFR_CON, now_ms);
}
/**
* 功能:TESTFR的接收确认与发送完成使用同一个Manager入口边界。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* apci——APCI控制头。
* 输出参数:manager——发送管理器的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK、result == IEC104_LINK_RESULT_IGNORED ? IEC104_SEND_MANAGER_IGNORED : IEC104_SEND_MANAGER_FATAL。
* 说明:不预留控制槽,槽满不影响接受确认;只有CON_PENDING才结束本端探测。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Testfr_Con(
IEC104_SendManager_t *manager, uint64_t connection_generation, const IEC104_ApciInfo_t *apci)
{
IEC104_LinkResult_t result;
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_TESTFR_CON ||
!Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
result = IEC104_Link_Handle_Testfr_Con(manager->link_state, apci);
if (result == IEC104_LINK_RESULT_OK) {
return IEC104_SEND_MANAGER_OK;
}
return result == IEC104_LINK_RESULT_IGNORED ? IEC104_SEND_MANAGER_IGNORED : IEC104_SEND_MANAGER_FATAL;
}
/**
* 功能:HIGH快速路径也遵守事件公平配额,不能通过反复调用应答接口绕过已配置的调度规则。
* 输入参数:manager——发送管理器。
* normal_waiting——int值。
* 输出参数:无。
* 返回值:1表示无NORMAL候选、未限制HIGH连发或HIGH连发尚未达到限额,否则0。
* 说明:直接处理传入的manager、normal_waiting,不经过其他函数调用。
*/
static int High_Has_Priority(const IEC104_SendManager_t *manager, int normal_waiting)
{
return !normal_waiting || manager->high_priority_burst_limit == 0U ||
manager->high_priority_burst_count < manager->high_priority_burst_limit;
}
/**
* 功能:仅用于Connection/TcpServer内部关联,安装本身不观察或重放历史发送记录。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* observer——ACK观察回调。
* 输出参数:manager——发送管理器的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK。
* 说明:内部调用:Manager_Session_Valid、memset。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Set_Ack_Observer(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const IEC104_SendManagerAckObserver_t *observer)
{
if (!Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
if (observer != NULL) { manager->ack_observer = *observer; }
else { memset(&manager->ack_observer, 0, sizeof(manager->ack_observer)); }
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:仅有序业务阶段允许队满旁路;同级前驱、已有帧和链路容量仍必须满足。
* 输入参数:manager——发送管理器。
* priority——优先级。
* 输出参数:无。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_WAIT、IEC104_SEND_MANAGER_ERROR、checked == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR、link == 0 || manager->record_count == manager->record_capacity ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_OK。
* 说明:应用已依次给更高等级生产者准备机会,才可把本级候选交给现有单帧缓冲;不能任意直发抢占。
* 这里不删除低级原文,也不额外分配报文缓存;只是避免低级占满HIGH后阻塞高级候选。
* 不复制ASDU、不编号,可用于动作执行前的保守容量预检;实际提交必须重新校验。
*/
static IEC104_SendManagerResult_t Direct_Response_Admission(const IEC104_SendManager_t *manager,
IEC104_BusinessPriority_t priority)
{
IEC104_AsduHeadInfo_t queued;
IEC104_SendBufferHeadInfo_t frame;
IEC104_AsduQueueResult_t checked;
IEC104_SendBufferResult_t buffered;
unsigned lane;
int link;
if (manager->asdu_queue->strict_business_priority == 0U ||
manager->business_cycle_active == 0U || manager->business_frame_used != 0U ||
manager->direct_business_priority != priority ||
(manager->pending_business_priority != IEC104_BUSINESS_PRIORITY_NONE &&
priority > manager->pending_business_priority)) { return IEC104_SEND_MANAGER_WAIT; }
buffered = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &frame);
if (buffered == IEC104_SEND_BUFFER_OK) { return IEC104_SEND_MANAGER_WAIT; }
if (buffered != IEC104_SEND_BUFFER_EMPTY) { return IEC104_SEND_MANAGER_ERROR; }
for (lane = 0U; lane < IEC104_ASDU_PRIORITY_COUNT; ++lane) {
checked = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, (IEC104_AsduPriority_t)lane, &queued);
if (checked == IEC104_ASDU_QUEUE_ERROR) { return IEC104_SEND_MANAGER_ERROR; }
if (checked == IEC104_ASDU_QUEUE_OK && queued.business_priority <= priority) {
return IEC104_SEND_MANAGER_WAIT;
}
}
/* 同级没有待发前驱才可直接登记HANDED;票据耗尽或队列状态非法须在分配N(S)之前发现。 */
checked = IEC104_AsduQueue_Can_Record_Direct_Response(manager->asdu_queue,
manager->connection_generation, priority);
if (checked != IEC104_ASDU_QUEUE_OK) {
return checked == IEC104_ASDU_QUEUE_FULL ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
}
link = IEC104_Link_Can_Prepare_I_Frame(manager->link_state, manager->send_window_k);
if (link < 0) { return IEC104_SEND_MANAGER_ERROR; }
return link == 0 || manager->record_count == manager->record_capacity ?
IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_OK;
}
/**
* 功能:容量提示同时承认“可入队”和“本阶段可旁路”两种接手方式;OK不表示当前就能上网发送。
* 输入参数:manager——发送管理器。
* generation——连接代次。
* asdu_length——ASDU字节长度。
* priority——优先级。
* 输出参数:无。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK、Direct_Response_Admission(manager, priority)。
* 说明:使用当前模式的真实管理头长度,不能用兼容模式2字节头估算严格应答的余量。
* 查询不占空间、不取得票据,也不执行协议推进;业务决定和后续Submit之间仍须保持串行。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Can_Submit_Response_Priority(
const IEC104_SendManager_t *manager, uint64_t generation, uint16_t asdu_length,
IEC104_BusinessPriority_t priority)
{
uint32_t free_bytes, header;
if (asdu_length < IEC104_ASDU_HEADER_LEN || asdu_length > IEC104_MAX_ASDU_LEN ||
priority < IEC104_BUSINESS_PRIORITY_NONE || priority >= IEC104_BUSINESS_PRIORITY_COUNT ||
!Manager_Session_Valid(manager, generation) || !Response_Submit_Allowed(manager)) {
return IEC104_SEND_MANAGER_ERROR;
}
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_INTERROGATION; }
header = manager->asdu_queue->strict_business_priority != 0U ?
IEC104_ASDU_STRICT_HIGH_ENTRY_HEADER_LEN : IEC104_ASDU_HIGH_ENTRY_HEADER_LEN;
if (IEC104_AsduQueue_Get_Free_Bytes(manager->asdu_queue, IEC104_ASDU_PRIORITY_HIGH,
&free_bytes) != IEC104_ASDU_QUEUE_OK) { return IEC104_SEND_MANAGER_ERROR; }
if (free_bytes >= header + asdu_length) { return IEC104_SEND_MANAGER_OK; }
return Direct_Response_Admission(manager, priority);
}
/**
* 功能:统一交接一帧I报文:预留、Link编号、提交APDU、建立记录、更新来源及调度额度。
* 输入参数:manager——发送管理器。
* asdu——ASDU报文。
* asdu_length——ASDU字节长度。
* priority——优先级。
* queue_entry——const IEC104_AsduEntryId_t *所指数据。
* normal_waiting——int值。
* response_ticket——uint64_t值。
* now_ms——当前单调毫秒时刻。
* head_info——队首信息。
* 输出参数:manager——发送管理器的更新结果。
* head_info——队首信息的更新结果。
* 返回值:严格旁路票据在成功返回后单独登记。
* 说明:queue_entry非NULL表示来自队列,response_ticket是已选中HIGH条目的真实票据,不能换成物理队首票据。
* 直接HIGH应答和IDLE传NULL,不虚构队列条目或执行Mark;严格旁路票据在成功返回后单独登记。
* 调用方已验证会话、ASDU及发送顺序;WAIT尚未接手原文,Link编号后的失败必须FATAL收尾。
*/
static IEC104_SendManagerResult_t Prepare_I_Asdu(
IEC104_SendManager_t *manager, const uint8_t *asdu, uint16_t asdu_length,
IEC104_AsduPriority_t priority, const IEC104_AsduEntryId_t *queue_entry,
int normal_waiting, uint64_t response_ticket, uint64_t now_ms, IEC104_SendBufferHeadInfo_t *head_info)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendBufferResult_t tx_result;
IEC104_SendBufferHeadInfo_t prepared_head;
IEC104_IFrameSendRecordStorage_t prepared;
int apdu_length;
/* 已ACK但未消费的记录仍占槽;没有记录容量时不得分配协议序号。 */
if (manager->record_count == manager->record_capacity) {
return IEC104_SEND_MANAGER_WAIT;
}
tx_result = IEC104_SendBuffer_Reserve_I_Frame(manager->send_buffer, &reservation);
if (tx_result == IEC104_SEND_BUFFER_FULL || tx_result == IEC104_SEND_BUFFER_BUSY) {
return IEC104_SEND_MANAGER_WAIT;
}
if (tx_result != IEC104_SEND_BUFFER_OK) {
return IEC104_SEND_MANAGER_ERROR;
}
memset(&prepared, 0, sizeof(prepared));
apdu_length = IEC104_Link_Prepare_I_Frame(manager->link_state, manager->send_window_k,
asdu, asdu_length,
reservation.apdu, reservation.apdu_capacity, &prepared.i_frame_snapshot);
if (apdu_length <= 0) {
if (IEC104_SendBuffer_Cancel_Reservation(manager->send_buffer, reservation.frame_id) != IEC104_SEND_BUFFER_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
return apdu_length == 0 ? IEC104_SEND_MANAGER_WAIT : IEC104_SEND_MANAGER_ERROR;
}
/* 从Prepare成功起N(S)不可撤回,后续异常必须结束连接;此时原始ASDU尚未释放。 */
if (prepared.i_frame_snapshot.send_number != manager->next_record_ns ||
IEC104_SendBuffer_Commit_Frame(manager->send_buffer, reservation.frame_id, IEC104_SEND_BUFFER_FRAME_I,
(uint16_t)apdu_length, &prepared.i_frame_snapshot, now_ms) != IEC104_SEND_BUFFER_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
/* 队列提交与直接提交共用发送记录及ACK记账。队列来源随后Mark;直接HIGH及IDLE的serial为0。
* SendBuffer已复制完整APDU,成功后不再借用业务输入;本步骤尚未执行socket发送。 */
prepared.frame_serial = reservation.frame_id.frame_serial;
prepared.asdu_entry_serial = queue_entry != NULL ? queue_entry->entry_serial : 0U;
prepared.asdu_priority = priority;
prepared.queued_at_ms = now_ms;
manager->records[Record_Index_From_Offset(manager, manager->record_count)] = prepared;
manager->record_count++;
if (priority == IEC104_ASDU_PRIORITY_HIGH) {
manager->high_unacked_count++;
} else if (priority == IEC104_ASDU_PRIORITY_IDLE) {
manager->idle_unacked_count++;
}
manager->next_record_ns = (uint16_t)((manager->next_record_ns + 1U) & IEC104_SEQUENCE_MASK);
manager->network_frame_used = 1U;
/* 在出HIGH之前固定关联;即使之后Mark失败,SendBuffer接手的事实也不撤回。
* 直接构帧的queue_entry为空;严格旁路由Submit_Response在本函数返回OK后登记非零票据并通知handed。
* IDLE不调用handed、不建立观察槽,也不参与队列Mark;仍保留真实帧身份供累计ACK及收尾回执使用。 */
if (priority == IEC104_ASDU_PRIORITY_HIGH && queue_entry != NULL &&
manager->ack_observer.handed != NULL) {
manager->ack_observer.handed(manager->ack_observer.context,
response_ticket, reservation.frame_id);
}
if (queue_entry != NULL && IEC104_AsduQueue_Mark_Submitted(manager->asdu_queue, priority,
*queue_entry) != IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
/* 只计本次成功选择;normal_waiting表示当前可选的NORMAL,已缓存但暂停的数据不计。
* 无可选NORMAL时清零,避免HIGH为尚不能发送的数据累积欠额;严格选帧不读取此公平配额。 */
if (priority == IEC104_ASDU_PRIORITY_HIGH &&
normal_waiting && manager->high_priority_burst_limit != 0U) {
/* 饱和计数;兼容模式达到配额后,下一次两级都可发时轮到NORMAL。 */
if (manager->high_priority_burst_count < manager->high_priority_burst_limit) {
manager->high_priority_burst_count++;
}
} else {
manager->high_priority_burst_count = 0U;
}
if (IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &prepared_head) != IEC104_SEND_BUFFER_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
if (manager->asdu_queue->strict_business_priority != 0U && manager->business_cycle_active != 0U) {
manager->business_frame_used = 1U;
}
*head_info = prepared_head;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:紧邻实际写socket前取得待写字节;没有已准备帧时选择ASDU并分配一个N(S)。
* 输入参数:manager/connection_generation——当前管理器及匹配代次;
* now_ms——单调毫秒,仅准备新I帧时成为本地发送期限起点。
* 输出参数:head_info——非NULL,仅OK时写入当前帧身份、描述和剩余字节借用指针。
* 返回值:OK返回当前帧剩余字节;EMPTY表示既无已准备帧,也无当前允许选择的ASDU;WAIT表示门控、窗口或记录容量阻塞;
* ERROR表示输入、会话或准备非法;Link准备成功后的提交异常返回FATAL。
* 调用链:续传当前I/控制帧;无当前帧时Peek_Unsubmitted -> Reserve_I_Frame -> Link.Prepare
* -> Buffer.Commit_Frame接手报文 -> 登记记录 -> Queue.Mark_Submitted完成队列交接记账 -> 返回待写字节。
* 说明:APDU提交且发送记录建立后,HIGH原文立即出队,NORMAL标记已提交并保留原文至ACK或覆盖。
* 控制帧先于尚未分配协议N(S)的ASDU,已准备的I帧即使EAGAIN零进度也必须先完成。
* 重复取得当前帧不编号、不改变配额或期限;函数不执行实际I/O。
* 只有启动/EOF暂停的NORMAL积压时EMPTY是正常空闲;调用方等待网络、期限或显式放行,不按缓存条数忙轮询。
* 跨尾部原文用249字节局部缓冲拼接后调用Link;连续原文直接借用,不增加动态分配。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Prepare_Next_Send(
IEC104_SendManager_t *manager, uint64_t connection_generation, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info)
{
IEC104_AsduHeadInfo_t high_head_info, normal_head_info, selected_head_info;
IEC104_AsduQueueResult_t high_result, normal_result;
IEC104_SendBufferResult_t tx_result;
IEC104_SendBufferHeadInfo_t prepared_head;
uint8_t wrapped_asdu[IEC104_MAX_ASDU_LEN];
const uint8_t *selected_asdu;
int high_eligible, normal_eligible, normal_waiting;
if (head_info == NULL || !Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
/* 续传已准备帧,不为后续业务预建APDU;控制FIFO在选择新I帧之前排空。 */
tx_result = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &prepared_head);
if (tx_result == IEC104_SEND_BUFFER_OK) {
*head_info = prepared_head;
return IEC104_SEND_MANAGER_OK;
}
if (tx_result != IEC104_SEND_BUFFER_EMPTY) {
return IEC104_SEND_MANAGER_ERROR;
}
/* 已有帧及S/U继续;未分派业务通知先让应用形成完整候选集合。 */
if (manager->new_i_frame_blocked != 0U) { return IEC104_SEND_MANAGER_WAIT; }
high_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_HIGH, &high_head_info);
normal_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_NORMAL, &normal_head_info);
if (high_result == IEC104_ASDU_QUEUE_ERROR || normal_result == IEC104_ASDU_QUEUE_ERROR) {
return IEC104_SEND_MANAGER_ERROR;
}
if (high_result == IEC104_ASDU_QUEUE_EMPTY && normal_result == IEC104_ASDU_QUEUE_EMPTY) {
return IEC104_SEND_MANAGER_EMPTY;
}
high_eligible = high_result == IEC104_ASDU_QUEUE_OK;
normal_eligible = normal_result == IEC104_ASDU_QUEUE_OK;
/* 暂停的NORMAL不参与公平配额;即使此前HIGH已达配额,也必须允许本轮初始化/总召应答继续。
* 这里依据Peek的可选结果,不直接读取物理积压数,避免错误地选中尚未开放的NORMAL。 */
normal_waiting = normal_eligible;
/* Peek在严格模式分别给出两种生命周期中最优的可选条目,再比较业务等级。
* 同级比较两份存储共享的admission_order,不能固定偏向HIGH,也不能比较分级票据或N(S)。
* 兼容模式仍按HIGH配额选择,不要求NORMAL排空。 */
if (high_eligible && (manager->asdu_queue->strict_business_priority != 0U ?
(!normal_eligible || high_head_info.business_priority < normal_head_info.business_priority ||
(high_head_info.business_priority == normal_head_info.business_priority &&
high_head_info.admission_order < normal_head_info.admission_order)) :
High_Has_Priority(manager, normal_eligible))) {
selected_head_info = high_head_info;
} else {
selected_head_info = normal_head_info;
}
/* 已编码集合的最优条目仍可能低于待准备候选;暂停新编号,给下一业务轮继续准备的机会。
* 这个上限只限制等级更低者,同级已接手条目仍可推进;已编号帧在本函数开头已先行返回。 */
if (manager->asdu_queue->strict_business_priority != 0U &&
manager->pending_business_priority != IEC104_BUSINESS_PRIORITY_NONE &&
selected_head_info.business_priority > manager->pending_business_priority) {
return IEC104_SEND_MANAGER_WAIT;
}
/* 连续原文直接借用;跨尾部的两段仅在此拼成连续ASDU,原队列数据不移动。 */
selected_asdu = selected_head_info.asdu_first;
if (selected_head_info.asdu_second != NULL) {
if (IEC104_AsduQueue_Copy_Asdu(&selected_head_info, wrapped_asdu, sizeof(wrapped_asdu)) != IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_ERROR;
}
selected_asdu = wrapped_asdu;
}
return Prepare_I_Asdu(manager, selected_asdu, selected_head_info.asdu_length,
selected_head_info.priority, &selected_head_info.entry_id,
normal_waiting, selected_head_info.response_ticket, now_ms, head_info);
}
/**
* 功能:按启停阶段接手当前连接应答;兼容模式先试直发,严格模式先入队并仅在允许的阶段尝试队满旁路。
* 输入参数:asdu/asdu_length——业务原文;now_ms——准备帧时的单调时刻。
* 输出参数:仅OK写head_info,返回直接准备好的应答帧;成功后不再借用业务原文。
* 返回值:OK已准备、尚未实际写;QUEUED已缓存HIGH;WAIT未接手、由调用方保留重试;
* ERROR非法参数/状态或HIGH总容量装不下;FATAL表示编号后的交接失败,必须结束连接。
* 说明:仅STARTED/IDLE时接手;否则ERROR且不入HIGH。
* 准入先于容量及窗口判断;兼容模式的帧/配额/窗口阻塞转入HIGH,严格模式仅容量背压可尝试有序直交。
* 新STOP受理时取消HIGH待发应答;已经交给SendBuffer的I帧继续原发送及确认流程。
* 直接路径与队列路径共用Prepare_I_Asdu,不另建序号、帧缓冲或ACK逻辑。
* HIGH直发也通过Peek_Unsubmitted取得NORMAL资格;不能因旧缓存或旧配额而阻断启动所需的应答。
*/
static IEC104_SendManagerResult_t Submit_Response(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info, uint64_t *ticket,
IEC104_BusinessPriority_t priority)
{
IEC104_AsduHeadInfo_t high_head, normal_head;
IEC104_SendBufferHeadInfo_t current_head;
IEC104_AsduQueueResult_t high_result, normal_result;
IEC104_SendBufferResult_t current_result;
IEC104_SendManagerResult_t result;
if (head_info == NULL || asdu == NULL || asdu_length < IEC104_ASDU_HEADER_LEN ||
asdu_length > IEC104_MAX_ASDU_LEN || !Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
if (priority < IEC104_BUSINESS_PRIORITY_NONE || priority >= IEC104_BUSINESS_PRIORITY_COUNT ||
!Response_Submit_Allowed(manager)) {
return IEC104_SEND_MANAGER_ERROR;
}
if (manager->asdu_queue->strict_business_priority != 0U) {
uint64_t direct_ticket;
if (priority == IEC104_BUSINESS_PRIORITY_NONE) { priority = IEC104_BUSINESS_PRIORITY_INTERROGATION; }
/* 统一入队;低级原文占满时,只允许当前有序阶段借用已有单帧缓冲,
* 既不撤回已接受的低级响应,也不让它们阻塞更高级的就绪候选。 */
result = IEC104_SendManager_Enqueue_Response_Priority(manager, connection_generation,
asdu, asdu_length, ticket, priority);
/* 只有容量背压才有旁路资格;非法输入/身份/队列状态不能用直发掩盖。
* QUEUED同样已复制接手,调用方必须推进游标,不能因尚未HANDED而重复提交。 */
if (result != IEC104_SEND_MANAGER_WAIT) {
return result == IEC104_SEND_MANAGER_OK ? IEC104_SEND_MANAGER_QUEUED : result;
}
result = Direct_Response_Admission(manager, priority);
if (result != IEC104_SEND_MANAGER_OK) { return result; }
result = Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_HIGH, NULL,
0, 0U, now_ms, head_info);
if (result != IEC104_SEND_MANAGER_OK) { return result; }
/* 此时帧已编号且SendBuffer已接手,票据登记失败只能FATAL收尾,不能按未发送重试。
* 成功票据立即HANDED,但ACK仍须由该frame_id对应的真实累计确认来证明。 */
if (IEC104_AsduQueue_Record_Direct_Response(manager->asdu_queue, connection_generation,
priority, &direct_ticket) != IEC104_ASDU_QUEUE_OK) { return IEC104_SEND_MANAGER_FATAL; }
if (manager->ack_observer.handed != NULL) {
manager->ack_observer.handed(manager->ack_observer.context, direct_ticket, head_info->frame_id);
}
if (ticket != NULL) { *ticket = direct_ticket; }
return IEC104_SEND_MANAGER_OK;
}
current_result = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &current_head);
high_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_HIGH, &high_head);
normal_result = IEC104_AsduQueue_Peek_Unsubmitted(manager->asdu_queue, IEC104_ASDU_PRIORITY_NORMAL, &normal_head);
if ((current_result != IEC104_SEND_BUFFER_OK && current_result != IEC104_SEND_BUFFER_EMPTY) ||
high_result == IEC104_ASDU_QUEUE_ERROR || normal_result == IEC104_ASDU_QUEUE_ERROR) {
return IEC104_SEND_MANAGER_ERROR;
}
if (current_result == IEC104_SEND_BUFFER_EMPTY && high_result == IEC104_ASDU_QUEUE_EMPTY &&
High_Has_Priority(manager, normal_result == IEC104_ASDU_QUEUE_OK)) {
result = Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_HIGH, NULL,
normal_result == IEC104_ASDU_QUEUE_OK,
0U, now_ms, head_info);
if (result != IEC104_SEND_MANAGER_WAIT) {
if (result == IEC104_SEND_MANAGER_OK && ticket != NULL) { *ticket = 0U; }
return result;
}
}
/* 当前帧、窗口或配额暂不允许直发时,复制进HIGH,NORMAL非空不妨碍接手。 */
result = IEC104_SendManager_Enqueue_Response(manager, connection_generation, asdu, asdu_length, ticket);
return result == IEC104_SEND_MANAGER_OK ? IEC104_SEND_MANAGER_QUEUED : result;
}
/**
* 功能:准入后直接交给唯一SendBuffer;WAIT不转存HIGH/NORMAL,调用方下次重新取得快照。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* asdu——ASDU报文。
* asdu_length——ASDU字节长度。
* reserve——须保留的窗口及记录槽数量。
* now_ms——当前单调毫秒时刻。
* head_info——队首信息。
* priority——优先级。
* 输出参数:manager——发送管理器的更新结果。
* head_info——队首信息的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、ready、Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_IDLE, NULL, 0, 0U, now_ms, head_info)。
* 说明:兼容模式要求队列无待发;严格模式可越过更低等级条目,但不能越过同级前驱。
* normal_waiting=0用于维持既有配额记账,严格模式并不据此决定业务先后。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Idle_Priority(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint16_t reserve, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info,
IEC104_BusinessPriority_t priority)
{
IEC104_SendManagerResult_t ready;
if (head_info == NULL || asdu == NULL || asdu_length < IEC104_ASDU_HEADER_LEN ||
asdu_length > IEC104_MAX_ASDU_LEN || !Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
ready = Idle_Admission(manager, reserve, priority);
if (ready != IEC104_SEND_MANAGER_OK) { return ready; }
return Prepare_I_Asdu(manager, asdu, asdu_length, IEC104_ASDU_PRIORITY_IDLE, NULL, 0, 0U, now_ms, head_info);
}
/**
* 功能:使用默认业务等级尝试直接准备一帧IDLE业务ASDU。
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
* reserve——须保留的窗口和记录槽数量;now_ms——本次单调时刻。
* 输出参数:head_info——OK时取得已准备的发送帧信息。
* 返回值:OK已准备;WAIT未接手;ERROR非法;FATAL表示编号后的交接失败。
* 说明:WAIT不复制到HIGH/NORMAL队列;准备成功后仍须由上层完成实际发送和进度回报。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Idle(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint16_t reserve, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info)
{
return IEC104_SendManager_Submit_Idle_Priority(manager, connection_generation, asdu, asdu_length, reserve, now_ms, head_info, IEC104_BUSINESS_PRIORITY_NONE);
}
/**
* 功能:按指定业务等级提交应答,选择HIGH排队或满足条件的直接交接路径。
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
* now_ms——本次单调时刻;priority——业务等级,NONE表示使用默认等级。
* 输出参数:head_info——OK时的已准备帧信息。
* 返回值:OK已准备;QUEUED已排队;WAIT未接手;ERROR非法;FATAL为交接故障。
* 说明:本入口不返回票据;OK和QUEUED都已复制接手,调用方不可重复提交。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response_Priority(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info,
IEC104_BusinessPriority_t priority)
{
return Submit_Response(manager, connection_generation, asdu, asdu_length, now_ms, head_info, NULL, priority);
}
/**
* 功能:使用默认业务等级提交应答,沿用带等级入口的交接和HIGH排队规则。
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
* now_ms——本次单调时刻。
* 输出参数:head_info——OK时的已准备帧信息。
* 返回值:OK或QUEUED表示已接手;WAIT未接手;ERROR非法;FATAL为交接故障。
* 说明:准备或排队均不表示TCP已写完;本入口不返回交接票据。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info)
{
return IEC104_SendManager_Submit_Response_Priority(manager, connection_generation, asdu, asdu_length, now_ms, head_info, IEC104_BUSINESS_PRIORITY_NONE);
}
/**
* 功能:与普通应答共用发送路径;OK和QUEUED均已接手,调用方不能重复提交同一原文。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* asdu——ASDU报文。
* asdu_length——ASDU字节长度。
* now_ms——当前单调毫秒时刻。
* head_info——队首信息。
* ticket——应答交接票据。
* priority——优先级。
* 输出参数:manager——发送管理器的更新结果。
* head_info——队首信息的更新结果。
* ticket——应答交接票据的更新结果。
* 返回值:严格模式排队或直交均返回非零票据,HANDED仍不等于写完或收到ACK。
* 说明:兼容模式直交票据为0;严格模式排队或直交均返回非零票据,HANDED仍不等于写完或收到ACK。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response_Tracked_Priority(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info, uint64_t *ticket,
IEC104_BusinessPriority_t priority)
{
return Submit_Response(manager, connection_generation, asdu, asdu_length, now_ms, head_info, ticket, priority);
}
/**
* 功能:使用默认业务等级提交应答,并按需返回交接票据。
* 输入参数:manager/connection_generation——发送管理器及代次;asdu/asdu_length——原文及长度。
* now_ms——本次单调时刻。
* 输出参数:head_info——OK时的已准备帧信息;ticket——接手成功时的票据,可为NULL。
* 返回值:OK或QUEUED已接手;WAIT未接手;ERROR非法;FATAL为交接故障。
* 说明:兼容模式直交票据为0;严格模式直交和排队均分配非零票据,票据交接不等于ACK。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Submit_Response_Tracked(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const uint8_t *asdu, uint16_t asdu_length, uint64_t now_ms,
IEC104_SendBufferHeadInfo_t *head_info, uint64_t *ticket)
{
return IEC104_SendManager_Submit_Response_Tracked_Priority(manager, connection_generation, asdu, asdu_length, now_ms, head_info, ticket, IEC104_BUSINESS_PRIORITY_NONE);
}
/**
* 功能:提交队首实际写入增量,整帧写完后提交适用的链路完成结果并释放发送缓冲槽。
* 输入参数:manager——有效的本连接发送管理器。
* frame_id——此前Prepare_Next_Send或Submit_Response返回的当前帧身份。
* bytes_written_now——本次实际成功写入的增量,不能超过剩余长度;0不推进进度。
* now_ms——本次完成时刻;最后一段须传实际整帧写完的单调时刻。
* 输出参数:completion——仅FRAME_WRITTEN时写入数值副本;其他结果保持原值。
* 发送队列、链路及I帧记录——按实际发送进度提交状态。
* 返回值:OK表示尚未写完;FRAME_WRITTEN表示本地完成处理及缓冲释放成功;ERROR表示输入或匹配非法;
* FATAL表示整帧写完后的状态提交失败,必须结束当前连接。
* 调用方:Connection接收TcpServer的实际写入结果后,用准备帧时取得的frame_id提交本次增量。
* 调用链:SendBuffer.Record_Written_Bytes;仅整帧写完时继续分派适用的Link.Complete
* -> Manager登记I帧本地完成 -> SendBuffer.Commit_Send_Completion。
* 说明:本函数不写socket;调用方先执行实际I/O,再恰好提交一次对应进度。
* TESTFR_CON没有Link完成接口;完整写入后直接进入缓冲完成处理。
* 整帧完成时刻不能早于入队时刻;部分写入不更新计时起点。
* 同一增量不能重复提交,也不能另行调用Buffer.Record_Written_Bytes、Link.Complete或Buffer完成接口。
* 完成本函数后再分派依赖本地TESTFR_ACT完成的TESTFR_CON;不自动创建t1定时器。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Send_Progress(
IEC104_SendManager_t *manager, IEC104_SendFrameId_t frame_id,
uint16_t bytes_written_now, uint64_t now_ms, IEC104_LocalSendCompletion_t *completion)
{
IEC104_SendBufferHeadInfo_t head_info;
IEC104_SendBufferResult_t tx_result;
IEC104_LinkResult_t link_completion_result;
IEC104_IFrameSendRecordStorage_t *record = NULL;
IEC104_LocalSendCompletion_t prepared;
if (completion == NULL || !Manager_Session_Valid(manager, frame_id.connection_generation) ||
IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head_info) != IEC104_SEND_BUFFER_OK ||
head_info.frame_id.frame_serial != frame_id.frame_serial || head_info.remaining_bytes == 0U) {
return IEC104_SEND_MANAGER_ERROR;
}
/* 在推进写入进度之前核对业务记录,避免错误frame_id或关联造成部分状态更新。 */
if (head_info.frame_type == IEC104_SEND_BUFFER_FRAME_I) {
record = Find_Pending_Send_Record(manager, &head_info);
if (record == NULL) {
return IEC104_SEND_MANAGER_ERROR;
}
}
tx_result = IEC104_SendBuffer_Record_Written_Bytes(manager->send_buffer, frame_id, bytes_written_now, now_ms);
if (tx_result == IEC104_SEND_BUFFER_OK) {
return IEC104_SEND_MANAGER_OK;
}
if (tx_result != IEC104_SEND_BUFFER_FRAME_WRITTEN) {
return IEC104_SEND_MANAGER_ERROR;
}
/*
* 整帧完成第1步:按原始类型分派适用的Link完成接口;TESTFR_CON无需调用,I帧推进sent_vs及捎带确认。
* head_info保留构帧时的类型和I帧快照,实际完整发送时刻取本次now_ms。
*/
link_completion_result = Dispatch_Link_Send_Completion(manager, &head_info, head_info.apdu_length);
if (link_completion_result != IEC104_LINK_RESULT_OK && link_completion_result != IEC104_LINK_RESULT_IGNORED) {
return IEC104_SEND_MANAGER_FATAL;
}
if (record != NULL) {
if (link_completion_result != IEC104_LINK_RESULT_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
/* 第2步:登记Manager业务记录的本地完成;后续接收路径才允许ACK覆盖该帧。 */
record->local_send_completed = 1U;
record->written_at_ms = now_ms;
}
/*
* 第3步:释放当前I槽或控制FIFO队首;独立业务记录继续等待ACK,即使NORMAL原文已覆盖。
* 这里只处理报文存储,就绪记录由TcpServer转为事件后再移除。Complete已提交,缓冲提交失败不能重做Complete。
*/
if (IEC104_SendBuffer_Commit_Send_Completion(manager->send_buffer, frame_id) != IEC104_SEND_BUFFER_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
/* 输出只复制数值,避免把已释放帧的借用指针交给后续定时器或业务。 */
prepared.frame_id = frame_id;
prepared.frame_type = head_info.frame_type;
prepared.link_completion_result = link_completion_result;
prepared.i_frame_snapshot = head_info.i_frame_snapshot;
prepared.queued_at_ms = head_info.queued_at_ms;
prepared.written_at_ms = now_ms;
*completion = prepared;
return IEC104_SEND_MANAGER_FRAME_WRITTEN;
}
/**
* 功能:将匹配队首的发送失败或本地发送超时交给链路完成接口。
* 输入参数:manager——有效的本连接发送管理器。
* frame_id——尚未整帧完成的发送队首身份。
* 输出参数:link_state——匹配时按Complete(-1)约定清理;队列及业务记录保留供故障回收。
* 返回值:ERROR表示参数、会话、队首或身份非法;匹配并提交失败后始终返回FATAL。
* 说明:即使底层Complete返回IGNORED,实际发送失败仍要求连接层断连。
* 不自动Abort;调用方须回收业务、关闭TCP并结束或隔离旧I/O。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Handle_Send_Failure(
IEC104_SendManager_t *manager, IEC104_SendFrameId_t frame_id)
{
IEC104_SendBufferHeadInfo_t head_info;
if (!Manager_Session_Valid(manager, frame_id.connection_generation) ||
IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head_info) != IEC104_SEND_BUFFER_OK ||
head_info.frame_id.frame_serial != frame_id.frame_serial || head_info.remaining_bytes == 0U ||
(head_info.frame_type == IEC104_SEND_BUFFER_FRAME_I && Find_Pending_Send_Record(manager, &head_info) == NULL)) {
return IEC104_SEND_MANAGER_ERROR;
}
/* 网络失败已决定必须断连,不因底层完成接口返回IGNORED而继续发送。 */
(void)Dispatch_Link_Send_Completion(manager, &head_info, -1);
return IEC104_SEND_MANAGER_FATAL;
}
/**
* 功能:处理已解析I/S帧,验证累计ACK并登记确认事实;仅NORMAL继续确认原文队列。
* 输入参数:manager/connection_generation——当前管理器及匹配代次;
* apci——成功Parse_APCI得到的完整I/S帧描述;now_ms——本次协议推进的单调时刻。
* 输出参数:Link——提交有效ACK及I帧接收位置;records——标记新确认事实;
* Manager——分别核减HIGH及IDLE未确认记录数;AsduQueue——释放NORMAL原文或核减覆盖待确认数;不消费业务回执。
* 返回值:OK处理成功;ERROR表示参数、会话或新确认区间的记录非法;
* PROTOCOL_ERROR表示合法本地会话下Link拒绝报文;FATAL表示受理后的确认同步或原文释放失败。
* 调用链:读取旧位置 -> 预检新ACK记录 -> Link.Handle -> 登记全部新ACK事实 -> NORMAL逐条Confirm_Next_Normal_Entry。
* 说明:ACK只能覆盖已提交本地完成的I帧;异步接入须先提交真实发送结果。
* 重复ACK的新确认数量为0,不重复释放、不重置期限或首次ACK时刻;I帧接收仍由Link处理。
* 确认处理只访问新确认区间,复杂度O(新确认数)。释放中途失败仍保留整个已接受ACK区间供恢复。
* NORMAL原文覆盖不撤销帧;记录仍严格匹配序号和本地完成,已覆盖原文由Queue跳过释放。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Handle_I_S_Frame(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const IEC104_ApciInfo_t *apci, uint64_t now_ms)
{
IEC104_IFrameSendProgress_t before_progress, after_progress;
uint16_t acknowledged, first_offset, i, high_acknowledged = 0U, idle_acknowledged = 0U;
int ack_in_range;
IEC104_LinkResult_t result;
if (!Manager_Session_Valid(manager, connection_generation) || apci == NULL ||
(apci->frame_type != IEC104_FRAME_TYPE_I && apci->frame_type != IEC104_FRAME_TYPE_S) ||
IEC104_Link_Get_Send_Progress(manager->link_state, &before_progress) != 1) {
return IEC104_SEND_MANAGER_ERROR;
}
acknowledged = Sequence_Distance(before_progress.peer_ack_nr, apci->receive_number);
ack_in_range = apci->receive_number <= IEC104_SEQUENCE_MASK &&
acknowledged <= Sequence_Distance(before_progress.peer_ack_nr, before_progress.next_completion_ns);
/* 记录前缀是已ACK未消费回执,后缀是未ACK帧;相减直接定位旧V(A)对应记录。 */
first_offset = (uint16_t)(manager->record_count -
Sequence_Distance(before_progress.peer_ack_nr, before_progress.next_frame_ns));
/* 非法网络N(R)不用于访问记录,仍由Link处理并拒绝。 */
if (ack_in_range) {
for (i = 0U; i < acknowledged; ++i) {
uint16_t offset = (uint16_t)(first_offset + i);
const IEC104_IFrameSendRecordStorage_t *record = &manager->records[Record_Index_From_Offset(manager, offset)];
if (!I_Frame_Record_Valid(manager, record, offset) ||
record->local_send_completed != 1U || record->peer_acknowledged != 0U) {
return IEC104_SEND_MANAGER_ERROR;
}
if (record->asdu_priority == IEC104_ASDU_PRIORITY_HIGH) {
high_acknowledged++;
} else if (record->asdu_priority == IEC104_ASDU_PRIORITY_IDLE) {
idle_acknowledged++;
}
}
if (high_acknowledged > manager->high_unacked_count || idle_acknowledged > manager->idle_unacked_count) {
return IEC104_SEND_MANAGER_ERROR;
}
}
result = apci->frame_type == IEC104_FRAME_TYPE_I ?
IEC104_Link_Handle_I_Frame(manager->link_state, apci) :
IEC104_Link_Handle_S_Frame(manager->link_state, apci);
/* 本地会话及记录已预检;Link仍检查接收阶段、序号范围及N(R),不检查接收N(S)连续性。 */
if (result == IEC104_LINK_RESULT_FATAL) {
return IEC104_SEND_MANAGER_PROTOCOL_ERROR;
}
if (result != IEC104_LINK_RESULT_OK || !ack_in_range ||
IEC104_Link_Get_Send_Progress(manager->link_state, &after_progress) != 1 ||
after_progress.peer_ack_nr != apci->receive_number) {
return IEC104_SEND_MANAGER_FATAL;
}
/* 即使之后释放原文失败,也不能丢失Link已经接受的累计确认事实。
* 必须先遍历完整的新ACK区间:较早的NORMAL释放失败时,后面的HIGH及IDLE仍已被同一N(R)确认。
* 所有来源都通知acknowledged;观察器按帧身份匹配,未建立观察槽的IDLE不会命中HIGH票据。
* 观察器就在事实生效处登记时刻,不依赖上层收到OK,也不等待记录转成RECORD事件。 */
for (i = 0U; i < acknowledged; ++i) {
IEC104_IFrameSendRecordStorage_t *record =
&manager->records[Record_Index_From_Offset(manager, (uint16_t)(first_offset + i))];
record->peer_acknowledged = 1U;
if (manager->ack_observer.acknowledged != NULL) {
IEC104_SendFrameId_t frame_id;
frame_id.connection_generation = connection_generation;
frame_id.frame_serial = record->frame_serial;
manager->ack_observer.acknowledged(manager->ack_observer.context, frame_id, now_ms);
}
}
manager->high_unacked_count = (uint16_t)(manager->high_unacked_count - high_acknowledged);
manager->idle_unacked_count = (uint16_t)(manager->idle_unacked_count - idle_acknowledged);
/* HIGH原文已出队,IDLE没有队列原文;仅NORMAL按真实身份释放原文或核减覆盖计数。 */
for (i = 0U; i < acknowledged; ++i) {
const IEC104_IFrameSendRecordStorage_t *record =
&manager->records[Record_Index_From_Offset(manager, (uint16_t)(first_offset + i))];
IEC104_AsduEntryId_t entry_id;
if (record->asdu_priority != IEC104_ASDU_PRIORITY_NORMAL) {
continue;
}
entry_id.connection_generation = connection_generation;
entry_id.entry_serial = record->asdu_entry_serial;
if (IEC104_AsduQueue_Confirm_Next_Normal_Entry(manager->asdu_queue, record->asdu_priority, entry_id) != IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
}
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:按交接顺序复制指定偏移处的业务记录,供观察或故障回收。
* 输入参数:manager——存储结构有效的发送管理器,不要求故障后的Link仍合法。
* offset——相对当前记录队首的记录数偏移,0表示最早记录,单位不是字节。
* 输出参数:record——仅OK时写入带完整frame_id的数值副本;EMPTY和ERROR时保持原值。
* 返回值:OK表示取得记录;EMPTY表示偏移处无记录;ERROR表示参数、存储或记录非法。
* 说明:frame_id由Manager共享代次和记录frame_serial组合,不依赖Link或原文借用。
* 不删除记录、不修改完成标志;已关闭TCP不妨碍读取保存的ACK事实。
* 已确认与未确认事实须供业务回收策略使用;未确认不等于对端未收到。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Get_Record_By_Offset(
const IEC104_SendManager_t *manager, uint16_t offset, IEC104_IFrameSendRecord_t *record)
{
const IEC104_IFrameSendRecordStorage_t *stored;
IEC104_IFrameSendRecord_t prepared;
if (!Manager_Storage_Valid(manager) || record == NULL) {
return IEC104_SEND_MANAGER_ERROR;
}
if (offset >= manager->record_count) {
return IEC104_SEND_MANAGER_EMPTY;
}
stored = &manager->records[Record_Index_From_Offset(manager, offset)];
if (!I_Frame_Record_Valid(manager, stored, offset)) {
return IEC104_SEND_MANAGER_ERROR;
}
memset(&prepared, 0, sizeof(prepared));
prepared.frame_id.connection_generation = manager->connection_generation;
prepared.frame_id.frame_serial = stored->frame_serial;
prepared.asdu_entry_serial = stored->asdu_entry_serial;
prepared.queued_at_ms = stored->queued_at_ms;
prepared.written_at_ms = stored->written_at_ms;
prepared.i_frame_snapshot = stored->i_frame_snapshot;
prepared.asdu_priority = stored->asdu_priority;
prepared.local_send_completed = stored->local_send_completed;
prepared.peer_acknowledged = stored->peer_acknowledged;
*record = prepared;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:读取最早已完成本地发送、尚未被对端确认的I帧记录。
* 输入参数:manager——当前会话有效的子站管理器;record——非NULL输出。
* 输出参数:仅OK时复制记录,不返回APDU指针,不改变队列。
* 返回值:OK、EMPTY(包括只有待发送I帧)或ERROR。
* 说明:记录环形数组中,已确认未消费的前缀后就是V(A)对应的记录,可直接定位。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Peek_Oldest_Sent_Unacked_Record(
const IEC104_SendManager_t *manager, IEC104_IFrameSendRecord_t *record)
{
IEC104_IFrameSendProgress_t progress;
IEC104_IFrameSendRecord_t prepared;
uint16_t offset;
if (record == NULL || !Manager_Storage_Valid(manager) ||
!Manager_Session_Valid(manager, manager->connection_generation) ||
IEC104_Link_Get_Send_Progress(manager->link_state, &progress) != 1) {
return IEC104_SEND_MANAGER_ERROR;
}
if (progress.peer_ack_nr == progress.next_completion_ns) {
return IEC104_SEND_MANAGER_EMPTY;
}
offset = (uint16_t)(manager->record_count -
Sequence_Distance(progress.peer_ack_nr, progress.next_frame_ns));
if (IEC104_SendManager_Get_Record_By_Offset(manager, offset, &prepared) != IEC104_SEND_MANAGER_OK ||
prepared.i_frame_snapshot.send_number != progress.peer_ack_nr ||
prepared.local_send_completed != 1U || prepared.peer_acknowledged != 0U) {
return IEC104_SEND_MANAGER_ERROR;
}
*record = prepared;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:起点与期限已校验;
* 输入参数:now_ms——当前单调毫秒时刻。
* started_ms——毫秒计时值。
* timeout_ms——超时毫秒数。
* 输出参数:无。
* 返回值:返回elapsed >= timeout_ms ? 0U : timeout_ms - (uint32_t)elapsed的结果。
* 说明:先作64位差值再截断,避免绝对期限加法或长时间差溢出。
*/
static uint32_t Deadline_Remaining(uint64_t now_ms, uint64_t started_ms, uint32_t timeout_ms)
{
uint64_t elapsed = now_ms - started_ms;
return elapsed >= timeout_ms ? 0U : timeout_ms - (uint32_t)elapsed;
}
/**
* 功能:向Connection提供同一时刻的队首期限、帧身份、I帧t1和控制容量。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* now_ms——当前单调毫秒时刻。
* local_send_timeout_ms——毫秒计时值。
* t1_ms——确认超时毫秒数。
* deadlines——IEC104_SendManagerDeadlines_t *所指数据。
* 输出参数:deadlines——IEC104_SendManagerDeadlines_t *所指数据的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK。
* 说明:原始起点仍分别来自Buffer和发送记录;此快照只在当前串行调用中使用,不缓存到对象内。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Get_Deadlines(
const IEC104_SendManager_t *manager, uint64_t connection_generation,
uint64_t now_ms, uint32_t local_send_timeout_ms, uint32_t t1_ms,
IEC104_SendManagerDeadlines_t *deadlines)
{
IEC104_SendManagerDeadlines_t prepared;
IEC104_SendBufferStatus_t buffer_status;
IEC104_SendBufferHeadInfo_t head;
IEC104_IFrameSendRecord_t record;
IEC104_SendBufferResult_t buffered;
IEC104_SendManagerResult_t recorded;
if (deadlines == NULL || local_send_timeout_ms == 0U || t1_ms == 0U ||
!Manager_Session_Valid(manager, connection_generation) ||
IEC104_SendBuffer_Get_Status(manager->send_buffer, &buffer_status) != IEC104_SEND_BUFFER_OK) {
return IEC104_SEND_MANAGER_ERROR;
}
memset(&prepared, 0, sizeof(prepared));
prepared.control_has_room = buffer_status.control_has_room;
buffered = IEC104_SendBuffer_Peek_Send_Head(manager->send_buffer, &head);
if (buffered == IEC104_SEND_BUFFER_OK) {
if (now_ms < head.queued_at_ms) {
return IEC104_SEND_MANAGER_ERROR;
}
prepared.has_send_head = 1U;
prepared.head_frame_id = head.frame_id;
prepared.local_send_remaining_ms = Deadline_Remaining(now_ms, head.queued_at_ms, local_send_timeout_ms);
} else if (buffered != IEC104_SEND_BUFFER_EMPTY) {
return IEC104_SEND_MANAGER_ERROR;
}
recorded = IEC104_SendManager_Peek_Oldest_Sent_Unacked_Record(manager, &record);
if (recorded == IEC104_SEND_MANAGER_OK) {
if (now_ms < record.written_at_ms) {
return IEC104_SEND_MANAGER_ERROR;
}
prepared.has_i_ack_deadline = 1U;
prepared.i_ack_remaining_ms = Deadline_Remaining(now_ms, record.written_at_ms, t1_ms);
} else if (recorded != IEC104_SEND_MANAGER_EMPTY) {
return IEC104_SEND_MANAGER_ERROR;
}
*deadlines = prepared;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:检查最早已本地完成、尚未收到ACK的I帧是否达到t1。
* 输入参数:manager/connection_generation——当前管理器及匹配代次;
* now_ms——当前单调毫秒;t1_ms——非零确认等待期限。
* 输出参数:无,不更新记录、不启动定时器或关闭连接。
* 返回值:1到期;0未到期或没有已完成未确认I帧;-1参数、状态或时间非法。
* 说明:起点取最早未ACK记录的原written_at_ms,等于期限即到期。
* 部分ACK后选下一帧的原时间,重复ACK或后续帧发送不为前帧续期;
* 尚未整帧完成的当前I帧使用Buffer的本地发送期限。
*/
int IEC104_SendManager_T1_I_Ack_Expired(
const IEC104_SendManager_t *manager, uint64_t connection_generation,
uint64_t now_ms, uint32_t t1_ms)
{
IEC104_IFrameSendRecord_t record;
IEC104_SendManagerResult_t result;
if (!Manager_Storage_Valid(manager) || connection_generation != manager->connection_generation || t1_ms == 0U) {
return -1;
}
result = IEC104_SendManager_Peek_Oldest_Sent_Unacked_Record(manager, &record);
if (result == IEC104_SEND_MANAGER_EMPTY) {
return 0;
}
if (result != IEC104_SEND_MANAGER_OK || now_ms < record.written_at_ms) {
return -1;
}
return Deadline_Remaining(now_ms, record.written_at_ms, t1_ms) == 0U;
}
/**
* 功能:读取同时满足本地完成和对端确认的队首业务回执。
* 输入参数:manager——存储结构有效的发送管理器。
* 输出参数:record——仅OK时写入回执副本;其余结果保持原值。
* 返回值:OK表示队首回执就绪;EMPTY表示无记录;WAIT表示队首尚未同时满足两个条件;
* ERROR表示参数、存储或记录非法。
* 调用方:Connection代TcpServer查询;返回OK后,TcpServer复制RECORD事件,再经Connection调用Remove。
* 说明:只检查队首,不跳过尚未完成的旧记录;不依赖运行中的Link状态。
* 不自动释放记录;事件成功保存后才调用Remove_Confirmed_Record,尚未移除的回执仍占容量。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Peek_Confirmed_Record(
const IEC104_SendManager_t *manager, IEC104_IFrameSendRecord_t *record)
{
IEC104_IFrameSendRecord_t prepared;
IEC104_SendManagerResult_t result;
if (record == NULL) {
return IEC104_SEND_MANAGER_ERROR;
}
result = IEC104_SendManager_Get_Record_By_Offset(manager, 0U, &prepared);
if (result != IEC104_SEND_MANAGER_OK) {
return result;
}
if (prepared.local_send_completed == 0U || prepared.peer_acknowledged == 0U) {
return IEC104_SEND_MANAGER_WAIT;
}
*record = prepared;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:在TcpServer成功保存RECORD事件后,按frame_id释放已就绪的队首内部记录。
* 输入参数:manager——存储结构有效的发送管理器。
* frame_id——已读取并成功复制为事件的队首回执身份。
* 输出参数:manager——成功时推进record_head_index并减少record_count。
* 返回值:OK表示释放成功;ERROR表示参数、记录、frame_id非法,或队首尚未就绪/不存在。
* 调用方:Connection接到TcpServer的记录移除请求后,用Peek_Confirmed_Record返回的frame_id调用一次。
* 说明:失败不修改记录;成功只释放业务记录槽,不改变Link序号、ACK或原始ASDU存储。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Remove_Confirmed_Record(
IEC104_SendManager_t *manager, IEC104_SendFrameId_t frame_id)
{
IEC104_IFrameSendRecord_t record;
if (IEC104_SendManager_Peek_Confirmed_Record(manager, &record) != IEC104_SEND_MANAGER_OK ||
frame_id.connection_generation != record.frame_id.connection_generation || frame_id.frame_serial != record.frame_id.frame_serial) {
return IEC104_SEND_MANAGER_ERROR;
}
manager->record_head_index = Record_Index_From_Offset(manager, 1U);
manager->record_count--;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:终止Manager,并在自身存储结构有效时终止绑定的SendBuffer。
* 输入参数:manager——待终止对象,允许NULL。
* 输出参数:manager——非NULL时清零;AsduQueue及调用方记录数组保留。
* 返回值:无。
* 说明:先结束旧I/O并读取需要的业务记录;清零后不能再通过Manager取得这些回执。
* AsduQueue.Rebind清空HIGH并恢复NORMAL现存原文;明确全部丢弃须另调AsduQueue.Abort。
* 本函数不关闭socket、不回滚Link,不能代替旧异步操作的结束或隔离。
*/
void IEC104_SendManager_Abort(IEC104_SendManager_t *manager)
{
if (manager != NULL) {
if (Manager_Storage_Valid(manager)) {
IEC104_SendBuffer_Abort(manager->send_buffer);
}
memset(manager, 0, sizeof(*manager));
}
}
/* ==================== 子站:STARTDT_CON / STOPDT_CON ==================== */
/**
* 功能:Link已生成启动应答后提交;
* 输入参数:manager——发送管理器。
* reservation——const IEC104_SendBufferReservation_t *所指数据。
* now_ms——当前单调毫秒时刻。
* first_start——int值。
* 输出参数:manager——发送管理器的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_FATAL、Commit_Control_Frame(manager, reservation, IEC104_SEND_BUFFER_FRAME_STARTDT_CON, now_ms)。
* 说明:仅每轮首个CON清理HIGH,重复应答保留队列及公平配额。
*/
static IEC104_SendManagerResult_t Commit_Startdt_Con(
IEC104_SendManager_t *manager, const IEC104_SendBufferReservation_t *reservation,
uint64_t now_ms, int first_start)
{
if (first_start) {
if (IEC104_AsduQueue_Reset_High(manager->asdu_queue, manager->connection_generation) != IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
manager->high_priority_burst_count = 0U;
}
return Commit_Control_Frame(manager, reservation, IEC104_SEND_BUFFER_FRAME_STARTDT_CON, now_ms);
}
/**
* 功能:先取得控制槽再受理START;受理时立即激活并结束停止等待,CON按FIFO发送。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* apci——APCI控制头。
* now_ms——当前单调毫秒时刻。
* 输出参数:manager——发送管理器的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、result、Cancel_Control_Reservation(manager, &reservation, IEC104_SEND_MANAGER_FATAL)、Commit_Startdt_Con(manager, &reservation, now_ms, first_start)。
* 说明:WAIT保留原请求、状态和期限;相反方向ACT不暂存。
* 保留本项目的队列约定:从停用状态重新启动清理HIGH,已激活时重复START保留HIGH。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Slave_Handle_Startdt_Act(
IEC104_SendManager_t *manager, uint64_t connection_generation,
const IEC104_ApciInfo_t *apci, uint64_t now_ms)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendManagerResult_t result;
int first_start;
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_STARTDT_ACT) {
return IEC104_SEND_MANAGER_ERROR;
}
result = Reserve_Control_Frame(manager, connection_generation, &reservation);
if (result != IEC104_SEND_MANAGER_OK) {
return result;
}
first_start = manager->link_state->dt_state == IEC104_DT_STOPPED;
if (IEC104_Link_Handle_Startdt_Act(manager->link_state, apci,
reservation.apdu, reservation.apdu_capacity) != IEC104_LINK_RESULT_OK) {
return Cancel_Control_Reservation(manager, &reservation, IEC104_SEND_MANAGER_FATAL);
}
return Commit_Startdt_Con(manager, &reservation, now_ms, first_start);
}
/**
* 功能:STOP受理立即停用并清理HIGH;当前I帧和已有控制帧仍须按原顺序完成。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* apci——APCI控制头。
* 输出参数:manager——发送管理器的更新结果。
* 返回值: 排空中的重复STOP返回IGNORED;
* 说明:排空中的重复STOP返回IGNORED;控制队列满也可受理STOP,不暂存相反请求。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Slave_Handle_Stopdt_Act(
IEC104_SendManager_t *manager, uint64_t connection_generation, const IEC104_ApciInfo_t *apci)
{
IEC104_LinkResult_t result;
if (apci == NULL || apci->frame_type != IEC104_FRAME_TYPE_U || apci->u_function != IEC104_U_STOPDT_ACT ||
!Manager_Session_Valid(manager, connection_generation)) {
return IEC104_SEND_MANAGER_ERROR;
}
result = IEC104_Link_Handle_Stopdt_Act(manager->link_state, apci);
if (result == IEC104_LINK_RESULT_OK) {
if (IEC104_AsduQueue_Reset_High(manager->asdu_queue, connection_generation) != IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_FATAL;
}
return IEC104_SEND_MANAGER_OK;
}
return result == IEC104_LINK_RESULT_IGNORED ? IEC104_SEND_MANAGER_IGNORED : IEC104_SEND_MANAGER_FATAL;
}
/**
* 功能:为STOP排队S或CON;stop_con_id仅在STOP_CON成功入队时写出,S/等待/失败不修改。
* 输入参数:manager——发送管理器。
* connection_generation——连接代次。
* now_ms——当前单调毫秒时刻。
* stop_con_id——身份编号。
* 输出参数:manager——发送管理器的更新结果。
* stop_con_id——身份编号的更新结果。
* 返回值:按处理分支返回result、IEC104_SEND_MANAGER_FATAL、Cancel_Control_Reservation(manager, &reservation, result)。
* 说明:Connection用该帧身份结束本轮STOP总计时,旧CON完成不能结束后续STOP的期限。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Slave_Queue_Stopdt_Response(
IEC104_SendManager_t *manager, uint64_t connection_generation, uint64_t now_ms,
IEC104_SendFrameId_t *stop_con_id)
{
IEC104_SendBufferReservation_t reservation;
IEC104_SendManagerResult_t result = Reserve_Control_Frame(manager, connection_generation, &reservation);
IEC104_StopdtPrepareResult_t prepared;
IEC104_StopdtTx_t tx;
if (result != IEC104_SEND_MANAGER_OK) {
return result;
}
prepared = IEC104_Link_Prepare_Stopdt_Response(manager->link_state, reservation.apdu,
reservation.apdu_capacity, &tx);
switch (prepared) {
case IEC104_STOPDT_FRAME_READY:
if (tx.frame_length != IEC104_APCI_LEN ||
(tx.frame_type != IEC104_STOPDT_FRAME_S_ACK && tx.frame_type != IEC104_STOPDT_FRAME_CON)) {
return IEC104_SEND_MANAGER_FATAL;
}
result = Commit_Control_Frame(manager, &reservation,
tx.frame_type == IEC104_STOPDT_FRAME_S_ACK ? IEC104_SEND_BUFFER_FRAME_S_ACK :
IEC104_SEND_BUFFER_FRAME_STOPDT_CON, now_ms);
if (result == IEC104_SEND_MANAGER_QUEUED && tx.frame_type == IEC104_STOPDT_FRAME_CON &&
stop_con_id != NULL) {
*stop_con_id = reservation.frame_id;
}
return result;
case IEC104_STOPDT_NOT_ACTIVE:
result = IEC104_SEND_MANAGER_EMPTY;
break;
case IEC104_STOPDT_WAIT_SEND:
case IEC104_STOPDT_WAIT_PEER_ACK:
result = IEC104_SEND_MANAGER_WAIT;
break;
default:
result = IEC104_SEND_MANAGER_ERROR;
break;
}
return Cancel_Control_Reservation(manager, &reservation, result);
}
/* ==================== 子站初始化 ==================== */
/**
* 功能:绑定子站新连接的业务队列、发送队列、链路状态和业务记录数组。
* 输入参数:asdu_queue——已初始化或Rebind的业务队列;允许非空,但不能有保留或已覆盖的待确认条目。
* send_buffer——已初始化的发送缓冲,须与业务队列同代次且无当前I帧、控制帧或预留。
* link_state——已按CONTROLLED角色State_Init的初始链路,序号为0,各过程空闲。
* records——调用方持有的固定存储记录数组;帧身份只存frame_serial,共用Manager代次。
* record_capacity——记录容量,范围1..32767。
* send_window_k——未确认I帧窗口上限,范围1..32767。
* high_priority_burst_limit——0表示严格高优先;非0限制NORMAL有未提交条目时连续HIGH交接次数。
* 输出参数:manager——仅成功时整体写入绑定结果;asdu_queue——成功时清空HIGH未提交条目,保留NORMAL;ERROR均不修改。
* 返回值:OK表示初始化成功;ERROR表示参数或初始状态非法。
* 说明:所有对象不得重叠,须持续有效且按连接串行访问;不清零records数组。
* 绑定后I帧由Prepare_Next_Send或Submit_Response统一准备,I/S接收经Handle_I_S_Frame,发送进度经Handle_Send_Progress提交。
* S/TESTFR及子站启停由本模块封装构帧入队,完成结果直接提交对应Link接口。
* 不接管运行中的连接,不创建TCP、线程或定时器。
* 发送缓冲空闲及链路初始状态由各模块查询判断;查询成功后核对Link的固定角色配置。
* 非CONTROLLED链路返回ERROR;初始化后不得改写Link角色或绑定对象。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Init(
IEC104_SendManager_t *manager, IEC104_AsduQueue_t *asdu_queue,
IEC104_SendBuffer_t *send_buffer, IEC104_LinkState_t *link_state,
IEC104_IFrameSendRecordStorage_t *records, uint16_t record_capacity,
uint16_t send_window_k, uint16_t high_priority_burst_limit)
{
IEC104_SendManager_t prepared;
IEC104_LinkStatus_t link_status;
IEC104_AsduQueueStatus_t asdu_status;
IEC104_SendBufferStatus_t buffer_status;
if (manager == NULL || records == NULL || record_capacity == 0U ||
record_capacity > IEC104_SEQUENCE_MASK || send_window_k == 0U || send_window_k > IEC104_SEQUENCE_MASK ||
IEC104_Link_Is_Initial_State(link_state) != 1 || IEC104_Link_Get_Status(link_state, &link_status) != 1 ||
link_status.role != IEC104_ROLE_CONTROLLED ||
IEC104_AsduQueue_Get_Status(asdu_queue, &asdu_status) != IEC104_ASDU_QUEUE_OK ||
IEC104_SendBuffer_Get_Status(send_buffer, &buffer_status) != IEC104_SEND_BUFFER_OK ||
asdu_status.connection_generation != buffer_status.connection_generation ||
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_HIGH] != 0U ||
asdu_status.retained_unacked_count[IEC104_ASDU_PRIORITY_NORMAL] != 0U ||
asdu_status.overwritten_unacked_count != 0U || buffer_status.is_idle != 1U) {
return IEC104_SEND_MANAGER_ERROR;
}
memset(&prepared, 0, sizeof(prepared));
prepared.asdu_queue = asdu_queue;
prepared.send_buffer = send_buffer;
prepared.link_state = link_state;
prepared.records = records;
prepared.record_capacity = record_capacity;
prepared.send_window_k = send_window_k;
prepared.high_priority_burst_limit = high_priority_burst_limit;
prepared.connection_generation = buffer_status.connection_generation;
prepared.is_initialized = 1U;
if (IEC104_AsduQueue_Reset_High(asdu_queue, prepared.connection_generation) != IEC104_ASDU_QUEUE_OK) {
return IEC104_SEND_MANAGER_ERROR;
}
*manager = prepared;
return IEC104_SEND_MANAGER_OK;
}
/**
* 功能:先完成所有可失败的校验和HIGH清理,再向最终地址提交;不读取旧目标对象的未初始化内容。
* 输入参数:manager——发送管理器。
* asdu_queue——ASDU队列。
* send_buffer——发送缓冲。
* link_state——链路状态。
* control_frames——控制帧存储。
* control_capacity——控制帧容量。
* records——记录存储。
* record_capacity——发送记录容量。
* send_window_k——发送窗口K。
* high_priority_burst_limit——uint16_t值。
* connection_generation——连接代次。
* 输出参数:manager——发送管理器的更新结果。
* asdu_queue——ASDU队列的更新结果。
* send_buffer——发送缓冲的更新结果。
* link_state——链路状态的更新结果。
* 返回值:按处理分支返回IEC104_SEND_MANAGER_ERROR、IEC104_SEND_MANAGER_OK。
* 说明:绑定关系只在Manager内部建立,不提供对运行会话重新绑定指针的入口。
*/
IEC104_SendManagerResult_t IEC104_SendManager_Init_Connection(
IEC104_SendManager_t *manager, IEC104_AsduQueue_t *asdu_queue,
IEC104_SendBuffer_t *send_buffer, IEC104_LinkState_t *link_state,
IEC104_SendBufferControlFrame_t *control_frames, uint16_t control_capacity,
IEC104_IFrameSendRecordStorage_t *records, uint16_t record_capacity,
uint16_t send_window_k, uint16_t high_priority_burst_limit, uint64_t connection_generation)
{
IEC104_SendManager_t prepared;
IEC104_LinkState_t prepared_link;
IEC104_SendBuffer_t prepared_buffer;
if (manager == NULL || send_buffer == NULL || link_state == NULL ||
IEC104_Link_State_Init(&prepared_link, IEC104_ROLE_CONTROLLED) != 1 ||
IEC104_SendBuffer_Init(&prepared_buffer, control_frames, control_capacity, connection_generation) !=
IEC104_SEND_BUFFER_OK ||
IEC104_SendManager_Init(&prepared, asdu_queue, &prepared_buffer, &prepared_link, records, record_capacity,
send_window_k, high_priority_burst_limit) != IEC104_SEND_MANAGER_OK) {
return IEC104_SEND_MANAGER_ERROR;
}
*link_state = prepared_link;
*send_buffer = prepared_buffer;
prepared.link_state = link_state;
prepared.send_buffer = send_buffer;
*manager = prepared;
return IEC104_SEND_MANAGER_OK;
}