Files
STM32F4-Base/IEC60870-Slave/104/business/IEC104_Command.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

2088 lines
114 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.
/*
* 模块职责:IEC104控制命令(45..51及58..64),处理校验、选择、执行、撤销、期限及协议应答。
* 数据来源:Slave交付连接/启停通知和I帧;应用通过纯值业务事件显式决定、启动和结束操作。
* 本模块借用只读点策略表、不直接控制硬件、不创建线程,也不保存应用回调或申请堆内存。
*
* 状态主线:SELECT_WAIT -> SELECTED -> EXECUTE_WAIT -> EXECUTING -> ENDED;
* 允许直接执行时从EXECUTE_WAIT开始,拒绝、撤销、超时及会话失效可提前进入ENDED。
* Accept先查旧回复、时标和确认容量,再消费事件并至多调用一次动作;
* Report_Result转入完成期限,Complete关闭返回阶段并转入交接期限。
* Complete按已报告结果安排肯定/否定ACT_TERM;等待执行结果超时则自动安排否定ACT_TERM,
* 同时立即产生EXECUTE_TIMEOUT,不改写未知结果、不关闭TCP,也不再次调用设备动作。
* ENDED只表示协议交互结束,不保证物理输出已停止,也不立即代表事务槽可以复用。
*
* 存储与所有权:一个事务槽保存工作请求、业务事件和必要回复,独立短应答使用固定池。
* 模块借用Slave;事务持有一个站点引用直到槽释放;独立短应答只保留会话身份和原文字节。
* 应用若跨循环持有站点上下文或异步设备资源,须提前取得自己的引用,并自行维护设备忙状态。
* FINISHED已消费(或无需交付)且模块持有的本事务回复全部被接手/取消,才归还事务槽及模块站点引用。
*
* 发送顺序:事务确认、终止、撤销/不匹配回复与独立短应答共用递增序号,只有最早者可提交。
* 返回信息不在模块缓存,先提交模块内更早的回复,再进入原连接HIGH FIFO。
* 事务尾凭证限制正常FINISHED;返回信息尾凭证单独决定补报,均不表示对端ACK。
* 发送OK只是发送层接手,不等于socket写完或主站ACK;WAIT未接手,只可重试发送,不能重做动作。
*
* 执行约束:全部接口与Slave在同一事件循环串行调用;修改入口在动作回调期间拒绝重入。
* Handle_Event按FIFO消费通知,不受后续未读通知的门禁阻挡;动作和发送先查会话,再判期限。
* FINISHED可在离线时继续读取;取消不回滚设备,实例/事务/事件身份阻止迟到调用操作新事务。
*/
#include "IEC104_Command.h"
#include "IEC104_AsduQueue.h" /* 确认容量准入只使用HIGH条目头长度,不操作内部队列。 */
#include "IEC104_TcpServer_Config.h"
#include "IEC104_Net.h"
#include <math.h>
#include <string.h>
/**
* 功能:仅专项测试替换只读查询,覆盖正常服务无法构造的损坏状态;生产构建直接调用Slave。
* 输入参数:self——从站服务;ticket——提交应答时取得的交接票据。
* 输出参数:无。
* 返回值:底层票据状态;实例无效时返回ERROR。
* 说明:只查询交接历史;HANDED不等于TCP写完或对端确认,需ACK结果时使用回执接口。
*/
#ifdef IEC104_COMMAND_TEST_HOOKS
extern IEC104_ResponseState_t IEC104_Command_Test_Response_State(const IEC104_Slave_t *slave, uint64_t ticket);
/**
* 功能:取得内部TCP服务、队列和最近会话的状态副本,不推进协议或消费队列。
* 输入参数:self——有效句柄;status——非NULL输出存储;error——可选诊断。
* 输出参数:status——状态快照的更新结果。
* error——错误诊断的更新结果。
* 返回值:OK写入status,失败保持输出;Create后、Init失败后和Close后均可查询。
* 说明:会话和队列各自有有效标志,connected与data_transfer_started含义不同。
*/
extern IEC104_TcpResult_t IEC104_Command_Test_Get_Status(const IEC104_Slave_t *slave,
IEC104_TcpServerStatus_t *status, IEC104_TcpError_t *error);
#define COMMAND_RESPONSE_STATE IEC104_Command_Test_Response_State
#define COMMAND_CONFIRM_STATUS IEC104_Command_Test_Get_Status
#else
#define COMMAND_RESPONSE_STATE IEC104_Slave_Get_Response_State
#define COMMAND_CONFIRM_STATUS IEC104_Slave_Get_Status
#endif
#ifndef IEC104_COMMAND_CAPACITY
/* 实例数默认与TCP服务池一致;每个Slave至多绑定一个遥控实例。 */
#define IEC104_COMMAND_CAPACITY IEC104_TCP_SERVER_CAPACITY
#endif
#ifndef IEC104_COMMAND_REPLY_CAPACITY
/* 独立短回复容量;事务自己的必要确认、终止及撤销回复不占用这些槽。 */
#define IEC104_COMMAND_REPLY_CAPACITY 4U
#endif
_Static_assert(IEC104_COMMAND_CAPACITY > 0U, "Command needs instance storage");
_Static_assert(IEC104_COMMAND_REPLY_CAPACITY > 0U &&
IEC104_COMMAND_REPLY_CAPACITY < UINT32_MAX / 2U, "Command needs bounded reply storage");
/* 标准104头和IOA之后是命令值。类型清单同时生成布局及静态缓冲容量,避免两处维护。 */
#define COMMAND_VALUE_OFFSET (IEC104_ASDU_HEADER_LEN + 3U)
#define COMMAND_LAYOUTS(X) \
X(45, 0, true, false) X(46, 0, true, false) X(47, 0, true, false) \
X(48, 2, true, false) X(49, 2, true, false) X(50, 4, true, false) X(51, 4, false, false) \
X(58, 0, true, true) X(59, 0, true, true) X(60, 0, true, true) \
X(61, 2, true, true) X(62, 2, true, true) X(63, 4, true, true) X(64, 4, false, true)
#define COMMAND_LAYOUT_LENGTH(value_length, has_se, has_time) \
(COMMAND_VALUE_OFFSET + (value_length) + ((has_se) ? 1U : 0U) + ((has_time) ? IEC60870_CP56_LEN : 0U))
typedef struct {
uint8_t type_id, value_length, length;
bool has_se, has_time;
} CommandLayout;
#define COMMAND_LAYOUT_ROW(type, value_length, has_se, has_time) \
{type, value_length, COMMAND_LAYOUT_LENGTH(value_length, has_se, has_time), has_se, has_time},
static const CommandLayout command_layouts[] = { COMMAND_LAYOUTS(COMMAND_LAYOUT_ROW) };
#define COMMAND_LENGTH_MEMBER(type, value_length, has_se, has_time) \
uint8_t length_##type[COMMAND_LAYOUT_LENGTH(value_length, has_se, has_time)];
typedef union { COMMAND_LAYOUTS(COMMAND_LENGTH_MEMBER) } CommandLengthProbe;
#define COMMAND_MAX_LENGTH sizeof(CommandLengthProbe)
#define COMMAND_LAYOUT_BIT(type, value_length, has_se, has_time) | IEC104_COMMAND_TYPE_BIT(type)
#define COMMAND_SUPPORTED_MASK (0U COMMAND_LAYOUTS(COMMAND_LAYOUT_BIT))
#define COMMAND_DIRECT_ONLY_MASK (IEC104_COMMAND_TYPE_BIT(51U) | IEC104_COMMAND_TYPE_BIT(64U))
#define COMMAND_MAX_UTC_MS ((uint64_t)IEC60870_TIME_MAX_SECONDS * UINT64_C(1000) + UINT64_C(999))
_Static_assert(COMMAND_MAX_LENGTH <= IEC104_MAX_ASDU_LEN, "Command layout must fit one 104 ASDU");
/* 私有解码快照不进入事务存储;每次从规范原文重建,公共解码器负责格式校验。 */
typedef struct {
uint8_t state, qualifier;
bool is_select, has_time;
union { int16_t normalized, scaled; float short_float; uint32_t bitstring; } value;
IEC60870_CP56Time2a_t time;
} CommandElement;
typedef enum {
COMMAND_ELEMENT_INVALID,
COMMAND_ELEMENT_TIME_INVALID,
COMMAND_ELEMENT_VALID
} CommandElementResult;
/**
* 功能:按类型查只读布局表,返回借用的静态条目;
* 输入参数:type_id——类型标识。
* 输出参数:无。
* 返回值:按类型查只读布局表,返回借用的静态条目;
* 不支持的类型返回NULL,不推测相邻类型布局。
* 说明:不支持的类型返回NULL,不推测相邻类型布局。
*/
static const CommandLayout *Find_Layout(uint8_t type_id)
{
unsigned i;
for (i = 0U; i < sizeof(command_layouts) / sizeof(command_layouts[0]); ++i) {
if (command_layouts[i].type_id == type_id) { return &command_layouts[i]; }
}
return NULL;
}
/**
* 功能:只允许has_se为真时求取并读取此位置;
* 输入参数:layout——命令布局。
* 输出参数:无。
* 返回值:返回COMMAND_VALUE_OFFSET + layout->value_length的结果。
* 说明:51/64在该位置没有限定词。
*/
static unsigned Se_Offset(const CommandLayout *layout)
{
return COMMAND_VALUE_OFFSET + layout->value_length;
}
/**
* 功能:原文长度须已按layout校验;
* 输入参数:layout——命令布局。
* bytes——字节存储。
* 输出参数:无。
* 返回值:存在S/E限定词且其选择位置1时返回true;51/64或执行命令返回false。
* 说明:仅含S/E限定词的类型读取选择位,51/64始终按直接执行处理。
*/
static bool Is_Select(const CommandLayout *layout, const uint8_t *bytes)
{
return layout->has_se && (bytes[Se_Offset(layout)] & 0x80U) != 0U;
}
/**
* 功能:先核对类型,保证两份原文布局相同;
* 输入参数:layout——命令布局。
* stored——const uint8_t *所指数据。
* data——数据存储。
* 输出参数:无。
* 返回值:类型、OA、命令值及屏蔽S/E后的限定词一致返回true,否则false;时标不参与比较。
* 说明:值逐字节比较,限定词屏蔽S/E,时标不参与。
*/
static bool Same_Command(const CommandLayout *layout, const uint8_t *stored, const uint8_t *data)
{
if (stored[0] != data[0] || stored[3] != data[3] ||
memcmp(stored + COMMAND_VALUE_OFFSET, data + COMMAND_VALUE_OFFSET, layout->value_length) != 0) {
return false;
}
if (layout->has_se) {
unsigned se = Se_Offset(layout);
return (stored[se] & 0x7FU) == (data[se] & 0x7FU);
}
return true;
}
/* 唯一事务槽。槽地址固定,当前工作事件、历史已交付事件身份和待发应答分别记账。 */
typedef struct {
IEC104_SlaveEventIdentity_t identity; /* 原服务实例和连接代次;不能替换为重连后的当前身份。 */
/* request_bytes:当前选择/执行请求,供动作、事件、ACT_CON及ACT_TERM使用。
* reply_bytes:撤销或不匹配执行请求,仅供对应短回复回显,不覆盖工作请求。 */
uint8_t request_bytes[COMMAND_MAX_LENGTH], reply_bytes[COMMAND_MAX_LENGTH];
uint8_t request_length, reply_length;
IEC104_Station_t *station; /* 本事务Acquire的原站点;删除注册后仍持有,Reap时Release。 */
/* transaction_id:实例内单调事务号;receive_serial:当前工作请求的原I帧接收号。
* accepted_ms:当前请求在Handle_Event受理的时刻;timer_start_ms:当前阶段的单调计时起点。 */
uint64_t transaction_id, receive_serial, accepted_ms, timer_start_ms;
/* event_serial:当前工作/终结事件号;accepted_event_serial:已消费工作事件号,0表示尚未消费。
* select_event_serial/execute_event_serial:本事务两个工作事件的历史身份,供只读查询验证。 */
uint64_t event_serial, accepted_event_serial, select_event_serial, execute_event_serial;
/* confirm_serial/term_serial/reply_serial:待交确认、终止及撤销/不匹配回复的全局FIFO号,0表示无。 */
uint64_t confirm_serial, term_serial, reply_serial;
uint64_t last_return_ticket, last_response_ticket; /* 已接手返回信息尾及事务应答尾;0也表示已直接交接。 */
/* phase:事务阶段;event_type:当前事件种类;finish_reason:首次终结原因,后续取消不得覆盖。
* result:设备执行结果,0表示尚未报告;执行超时后仍为0,不能用否定TERM反推FAILED。
* confirm_cot/reply_cot:两类待发回复各自的传送原因。 */
uint8_t phase, event_type, finish_reason, result, confirm_cot, reply_cot;
/* occupied:槽被占用;event_taken:当前事件已交付;ever_work_delivered:曾交付过任一工作事件。
* finish_pending:仍欠应用一个FINISHED;该义务不能因创建新的EXECUTE事件而丢失。 */
bool occupied, event_taken, ever_work_delivered, finish_pending;
/* select_delivered/execute_delivered:对应历史工作事件确实交付过,避免伪造查询身份。
* selected:当前执行经过了本事务的选择匹配,直接执行时为false。 */
bool select_delivered, execute_delivered, selected;
/* confirm_negative:当前确认P/N。
* send_waiting:事务回复上次提交遇到背压;return_waiting:应用返回信息上次提交遇到背压。 */
bool confirm_negative, send_waiting, return_waiting;
/* confirm_submitted:当前工作请求确认已被发送层接手;completed:Complete已关闭返回阶段。
* term_submitted:ACT_TERM已被发送层接手;select_effect/execute_effect:动作可能留有设备副作用。 */
bool confirm_submitted, completed, term_submitted, select_effect, execute_effect;
bool has_return, return_info_undelivered; /* 后者仅在首次Finish冻结,不在NextEvent重查。 */
} CommandTransaction;
/* 与事务槽分离的拒绝回复,不保存站点指针,也不产生应用业务事件。 */
typedef struct {
IEC104_SlaveEventIdentity_t identity; /* 请求原会话身份;断线/换代清理,不能跨连接重发。 */
uint8_t bytes[COMMAND_MAX_LENGTH]; /* 规范原文;提交时仅改COT及P/N。 */
uint8_t length; /* 有效长度,不能用缓冲容量代替。 */
uint64_t serial; /* 与事务内回复共用的生成序号,决定全局FIFO位置。 */
uint8_t cot; /* 错误原因或否定ACT_CON/DEACT_CON的COT;独立回复P/N固定为1。 */
bool occupied, send_waiting; /* 槽占用标志;上次发送WAIT标志,用于避免need_process空转。 */
} CommandReply;
struct IEC104_Command {
IEC104_Slave_t *slave; /* 借用的所属服务,寿命必须覆盖本实例。 */
IEC104_SlaveEventIdentity_t session; /* 已按FIFO消费的连接/启停通知所确定的会话身份。 */
IEC104_CommandConfig_t config; /* Create时按值复制;其中points数组借用至Destroy,期间不可变。 */
IEC104_CommandStatus_t status; /* 累计计数及模块活动状态;调度字段由Get_Status即时计算。 */
CommandTransaction transaction; /* 固定地址的唯一事务;占用期间所有站点的新遥控均忙拒绝。 */
CommandReply replies[IEC104_COMMAND_REPLY_CAPACITY]; /* 独立短回复池;满时丢新、不覆盖。 */
/* serial:进程内唯一实例号;next_transaction/next_event/next_reply:实例内身份计数器。
* last_generation:已接手CONNECTED的最高代次,断线后保留,用于拒绝旧连接通知。 */
uint64_t serial, next_transaction, next_event, next_reply, last_generation;
uint64_t time_base_utc_ms, time_base_ms; /* 应用交付的UTC/单调时间对应关系;有效位在status内。 */
bool in_use, in_action; /* 静态实例池占用标志;同步动作回调的修改入口重入保护。 */
};
/* 静态池不迁移对象、不进行堆分配;实例编号跨Destroy保留递增,旧事件不能匹配复用的池槽。 */
static IEC104_Command_t command_pool[IEC104_COMMAND_CAPACITY];
static uint64_t next_instance;
/**
* 功能:验证句柄是否指向本模块当前占用的静态池槽。
* 输入参数:self为待检查地址,可以是NULL或不属于池的地址。
* 输出参数:无。
* 返回值:归属合法且in_use为true时返回true;否则false,不修改状态。
* 说明:约束:先比较地址再解引用,所有公开入口据此拒绝无效句柄。
*/
static bool Owned(const IEC104_Command_t *self)
{
unsigned i;
for (i = 0U; i < IEC104_COMMAND_CAPACITY; ++i) {
if (self == &command_pool[i]) { return self->in_use; }
}
return false;
}
/**
* 功能:创建时一次校验只读表,禁止重复/乱序点,保证后续查找不遗漏或产生歧义。
* 输入参数:config——配置。
* 输出参数:无。
* 返回值:(config->points == NULL) != (config->point_count == 0U) || config->point_count > SIZE_MAX / sizeof(*config->points)时返回false;其余分支返回false、true。
* 说明:全局禁用的类型可以保留在共享点表中;未知类型及51/64的选择模式不能入表。
*/
static bool Valid_Points(const IEC104_CommandConfig_t *config)
{
size_t i;
if ((config->points == NULL) != (config->point_count == 0U) ||
config->point_count > SIZE_MAX / sizeof(*config->points)) { return false; }
for (i = 0U; i < config->point_count; ++i) {
const IEC104_CommandPoint_t *point = &config->points[i];
if (point->common_address == 0U || point->common_address == UINT16_MAX ||
point->ioa == 0U || point->ioa > UINT32_C(0xffffff) ||
point->type_mask == 0U || (point->type_mask & (uint16_t)~COMMAND_SUPPORTED_MASK) != 0U ||
(point->mode != IEC104_COMMAND_MODE_DIRECT && point->mode != IEC104_COMMAND_MODE_SELECT_EXECUTE) ||
(point->mode == IEC104_COMMAND_MODE_SELECT_EXECUTE &&
(point->type_mask & COMMAND_DIRECT_ONLY_MASK) != 0U)) { return false; }
if (i != 0U) {
const IEC104_CommandPoint_t *previous = &config->points[i - 1U];
if (previous->common_address > point->common_address ||
(previous->common_address == point->common_address && previous->ioa >= point->ioa)) { return false; }
}
}
return true;
}
/**
* 功能:点表按CA/IOA排序,借用期间不可修改。
* 输入参数:self——本模块实例。
* ca——ASDU公共地址。
* ioa——信息体地址。
* 输出参数:无。
* 返回值:二分查找不分配存储,空表自然返回NULL。
* 说明:二分查找不分配存储,空表自然返回NULL。
*/
static const IEC104_CommandPoint_t *Find_Point(const IEC104_Command_t *self, uint16_t ca, uint32_t ioa)
{
size_t first = 0U, last = self->config.point_count;
while (first < last) {
size_t middle = first + (last - first) / 2U;
const IEC104_CommandPoint_t *point = &self->config.points[middle];
if (point->common_address == ca && point->ioa == ioa) { return point; }
if (point->common_address < ca || (point->common_address == ca && point->ioa < ioa)) {
first = middle + 1U;
} else { last = middle; }
}
return NULL;
}
/**
* 功能:从固定104命令布局读取24位小端信息对象地址。
* 输入参数:bytes指向完整的标准104单对象ASDU;调用方已完成长度检查。
* 输出参数:无。
* 返回值:0..0xFFFFFF的IOA;不判断该地址是否存在或适用于遥控。
* 说明:直接处理传入的bytes,不经过其他函数调用。
*/
static uint32_t Read_IOA(const uint8_t *bytes)
{
return (uint32_t)bytes[6] | ((uint32_t)bytes[7] << 8) | ((uint32_t)bytes[8] << 16);
}
/**
* 功能:从固定104布局读取16位小端公共地址。
* 输入参数:bytes为具有完整6字节公共头的ASDU,COT/CA宽度均为2。
* 输出参数:无。
* 返回值:原CA数值;不查询站点注册表,不修改原文。
* 说明:直接处理传入的bytes,不经过其他函数调用。
*/
static uint16_t Read_CA(const uint8_t *bytes)
{
return (uint16_t)((uint16_t)bytes[4] | ((uint16_t)bytes[5] << 8));
}
/**
* 功能:完整对象校验后才可调用。失败不改输出;不执行时效判断或设备动作。
* 输入参数:layout——命令布局。
* bytes——字节存储。
* length——字节长度。
* element——CommandElement *所指数据。
* 输出参数:element——全部对象和可选时标解码成功时写入;失败保持原值。
* 返回值:VALID表示完整解码成功;INVALID表示命令格式或限定词错误;TIME_INVALID表示仅CP56编码错误。
* 说明:58..64共用Time_From_CP56接收契约:实际日历及RES2/3/4仍校验,星期归一化,GEN不导出。
* 先校验命令值和限定词,再单独解析CP56,避免将值错误误报为时间戳错误。
* IV与时差由Check_Time判断,应答仍另存请求原文。
*/
static CommandElementResult Decode_Element(const CommandLayout *layout, const uint8_t *bytes, uint16_t length,
CommandElement *element)
{
CommandElement result;
const uint8_t *payload;
uint16_t payload_length;
uint32_t ioa;
if (layout == NULL || bytes == NULL || element == NULL || length != layout->length ||
bytes[0] != layout->type_id) { return COMMAND_ELEMENT_INVALID; }
memset(&result, 0, sizeof(result));
payload = bytes + COMMAND_VALUE_OFFSET;
payload_length = (uint16_t)(length - COMMAND_VALUE_OFFSET - (layout->has_time ? IEC60870_CP56_LEN : 0U));
ioa = Read_IOA(bytes);
result.has_time = layout->has_time;
switch (layout->type_id) {
case 45U: case 58U: {
IEC60870_SingleCommand_t command;
if (IEC60870_SingleCommand_Get_From_Buffer(&command, ioa, payload, payload_length) !=
IEC60870_ASDU_OK) { return COMMAND_ELEMENT_INVALID; }
result.state = command.state;
result.qualifier = command.qualifier;
result.is_select = command.is_select != 0U;
break;
}
case 46U: case 59U: {
IEC60870_DoubleCommand_t command;
if (IEC60870_DoubleCommand_Get_From_Buffer(&command, ioa, payload, payload_length) !=
IEC60870_ASDU_OK) { return COMMAND_ELEMENT_INVALID; }
result.state = command.state;
result.qualifier = command.qualifier;
result.is_select = command.is_select != 0U;
break;
}
case 47U: case 60U: {
IEC60870_StepCommand_t command;
if (IEC60870_StepCommand_Get_From_Buffer(&command, ioa, payload, payload_length) !=
IEC60870_ASDU_OK) { return COMMAND_ELEMENT_INVALID; }
result.state = command.state;
result.qualifier = command.qualifier;
result.is_select = command.is_select != 0U;
break;
}
case 48U: case 61U: {
IEC60870_SetpointCommandNormalized_t command;
if (IEC60870_SetpointCommandNormalized_Get_From_Buffer(&command, ioa, payload, payload_length) !=
IEC60870_ASDU_OK) { return COMMAND_ELEMENT_INVALID; }
result.value.normalized = command.value;
result.qualifier = command.qualifier;
result.is_select = command.is_select != 0U;
break;
}
case 49U: case 62U: {
IEC60870_SetpointCommandScaled_t command;
if (IEC60870_SetpointCommandScaled_Get_From_Buffer(&command, ioa, payload, payload_length) !=
IEC60870_ASDU_OK) { return COMMAND_ELEMENT_INVALID; }
result.value.scaled = command.value;
result.qualifier = command.qualifier;
result.is_select = command.is_select != 0U;
break;
}
case 50U: case 63U: {
IEC60870_SetpointCommandShort_t command;
if (IEC60870_SetpointCommandShort_Get_From_Buffer(&command, ioa, payload, payload_length) !=
IEC60870_ASDU_OK) { return COMMAND_ELEMENT_INVALID; }
result.value.short_float = command.value;
result.qualifier = command.qualifier;
result.is_select = command.is_select != 0U;
break;
}
case 51U: case 64U: {
IEC60870_Bitstring32Command_t command;
if (IEC60870_Bitstring32Command_Get_From_Buffer(&command, ioa, payload, payload_length) !=
IEC60870_ASDU_OK) { return COMMAND_ELEMENT_INVALID; }
result.value.bitstring = command.value;
break;
}
default: return COMMAND_ELEMENT_INVALID;
}
if ((layout->type_id == 50U || layout->type_id == 63U) && !isfinite(result.value.short_float)) {
return COMMAND_ELEMENT_INVALID;
}
/* 51/64没有限定词,不能把比特串值当作QU/QL。 */
if (layout->has_se && (layout->value_length == 0U ? result.qualifier > 3U : result.qualifier != 0U)) {
return COMMAND_ELEMENT_INVALID;
}
if (layout->has_time &&
!IEC60870_Time_From_CP56(payload + payload_length, IEC60870_CP56_LEN, &result.time)) {
return COMMAND_ELEMENT_TIME_INVALID;
}
*element = result;
return COMMAND_ELEMENT_VALID;
}
/**
* 功能:从self的事务原文重建纯值请求,包含注册身份、受理时刻及UTC毫秒。
* 输入参数:self——本模块实例。
* request——请求。
* 输出参数:request——请求的更新结果。
* 返回值:成功true;
* 解码/UTC换算失败false, 输出仍保留事务身份以便故障收尾。
* 说明:self必须持有占用事务和站点引用;request非NULL。成功true;解码/UTC换算失败false,
* 输出仍保留事务身份以便故障收尾。无动态分配,不改变事务,也不重新判断时差。
* 动作不能使用应用修改的事件副本,必须以本函数从保存原文解出的参数为准。
*/
static bool Copy_Request(const IEC104_Command_t *self, IEC104_CommandRequest_t *request)
{
const CommandTransaction *task = &self->transaction;
const CommandLayout *layout = Find_Layout(task->request_bytes[0]);
CommandElement element;
memset(request, 0, sizeof(*request));
request->generation = task->identity.generation;
request->receive_serial = task->receive_serial;
request->station_id = IEC104_Station_Get_Id(task->station);
request->common_address = Read_CA(task->request_bytes);
request->originator_address = task->request_bytes[3];
request->type_id = task->request_bytes[0];
request->ioa = Read_IOA(task->request_bytes);
request->selected = task->selected;
request->accepted_ms = task->accepted_ms;
if (Decode_Element(layout, task->request_bytes, task->request_length, &element) != COMMAND_ELEMENT_VALID) { return false; }
request->is_select = element.is_select;
request->state = element.state;
request->qualifier = element.qualifier;
switch (request->type_id) {
case 48U: case 61U: request->value.normalized = element.value.normalized; break;
case 49U: case 62U: request->value.scaled = element.value.scaled; break;
case 50U: case 63U: request->value.short_float = element.value.short_float; break;
case 51U: case 64U: request->value.bitstring = element.value.bitstring; break;
default: break;
}
request->has_time = element.has_time;
if (element.has_time) {
uint32_t seconds;
request->time = element.time;
if (!IEC60870_Time_CP56_To_Seconds(&element.time, self->config.master_utc_offset_minutes, &seconds)) {
return false; /* 已受理激活必须能换算;失败是内部保存原文损坏,不能调用动作。 */
}
request->time_utc_ms = (uint64_t)seconds * UINT64_C(1000) + element.time.time.ms;
}
return true;
}
/**
* 功能:统计单个事务仍持有、尚未被发送层接手的回复数。
* 输入参数:task为有效事务存储,允许为空闲事务。
* 输出参数:无。
* 返回值:确认、结束、撤销/否定回复中仍持有序号的数量,不含独立短回复槽。
* 说明:约束:不包括已经进入HIGH/当前发送帧的回复,也不包括应用尚未交付的返回信息。
*/
static unsigned Pending_Transaction_Replies(const CommandTransaction *task)
{
return (task->confirm_serial != 0U ? 1U : 0U) +
(task->term_serial != 0U ? 1U : 0U) + (task->reply_serial != 0U ? 1U : 0U);
}
/**
* 功能:合并有效实例的事务回复与全部独立短回复,不修改状态;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:返回count的结果。
* 说明:已交给HIGH的原文不再计入本模块待答数。
*/
static unsigned Pending_Replies(const IEC104_Command_t *self)
{
const CommandTransaction *task = &self->transaction;
unsigned i, count = Pending_Transaction_Replies(task);
for (i = 0U; i < IEC104_COMMAND_REPLY_CAPACITY; ++i) {
if (self->replies[i].occupied) { ++count; }
}
return count;
}
/**
* 功能:在应用清理通知与本事务发送收尾均完成后释放事务槽。
* 输入参数:self为有效实例;允许事务尚未结束或已经空闲,此时无操作。
* 输出参数:满足条件时Release模块自己的站点引用,并清零事务全部状态。
* 返回值:无。
* 说明:约束:只有ENDED且FINISHED已读取(或无需生成)、模块持有的本事务回复已全部接手(或取消),
* 才能回收。正常结束已先等待尾帧HANDED;提前结束不再等已入HIGH的帧交接。
* 执行超时允许先读FINISHED,term_serial仍阻止回收;TERM交给HIGH后原文已复制,
* 该提前结束的事务即可按上述条件回收,不必再等TERM写完或收到ACK。
* 独立短应答不借用事务内存,不阻止本事务回收。
* 返回补充:无;不清理独立短应答、不关闭连接、不回滚设备动作。
*/
static void Reap(IEC104_Command_t *self)
{
CommandTransaction *task = &self->transaction;
if (!task->occupied || task->phase != IEC104_COMMAND_PHASE_ENDED || task->finish_pending ||
task->confirm_serial != 0U || task->term_serial != 0U || task->reply_serial != 0U) { return; }
(void)IEC104_Slave_Release_Station(self->slave, task->station);
memset(task, 0, sizeof(*task));
}
/**
* 功能:新增期限只丢弃本事务尚未接手的回复,按帧计数;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:独立回复和已进HIGH的原文保持不变。
*/
static void Drop_Transaction_Replies(IEC104_Command_t *self)
{
CommandTransaction *task = &self->transaction;
self->status.dropped_replies += Pending_Transaction_Replies(task);
task->confirm_serial = task->term_serial = task->reply_serial = 0U;
task->send_waiting = task->return_waiting = false;
}
/**
* 功能:结束当前应用交互,冻结首次原因并按交付历史生成一次FINISHED。
* 输入参数:self为有效实例;reason为本次终结原因。
* 输出参数:活动事务进入ENDED;未读工作事件被替换或移除,累计相应终结统计。
* 返回值:无。
* 说明:约束:是否欠FINISHED取决于ever_work_delivered,而非当前事件是否取走。
* 已经ENDED时保持原原因和通知,不因后续STOP/Cancel重复交付。
* 结束应用交互不等于释放槽,仍须由Reap同时核对FINISHED与本事务回复的收尾条件。
* 返回补充:无;不会自行丢弃待发回复,末尾仅尝试Reap。
*/
static void Finish(IEC104_Command_t *self, IEC104_CommandFinishReason_t reason)
{
CommandTransaction *task = &self->transaction;
if (!task->occupied || task->phase == IEC104_COMMAND_PHASE_ENDED) { Reap(self); return; }
task->return_info_undelivered = task->has_return &&
COMMAND_RESPONSE_STATE(self->slave, task->last_return_ticket) != IEC104_RESPONSE_HANDED;
if (task->return_info_undelivered) { ++self->status.return_info_undelivered; }
task->phase = IEC104_COMMAND_PHASE_ENDED;
task->timer_start_ms = IEC104_Net_Now_Ms(); /* 首次结束时启动残留回复清理,不随读取或重试刷新。 */
task->finish_reason = (uint8_t)reason;
task->event_type = IEC104_COMMAND_FINISHED;
task->event_taken = false;
task->finish_pending = task->ever_work_delivered;
task->return_waiting = false;
/* 创建事务时为最多两个工作事件和一个FINISHED检查了序号余量。 */
if (task->finish_pending) { task->event_serial = ++self->next_event; }
switch (reason) {
case IEC104_COMMAND_FINISH_COMPLETED: ++self->status.completed; break;
case IEC104_COMMAND_FINISH_EXECUTION_FAILED: ++self->status.execution_failed; break;
case IEC104_COMMAND_FINISH_ACTION_FAILED: ++self->status.action_failed; break;
case IEC104_COMMAND_FINISH_MISMATCH: ++self->status.mismatches; break;
case IEC104_COMMAND_FINISH_DEACTIVATED: ++self->status.deactivated; break;
case IEC104_COMMAND_FINISH_SELECT_TIMEOUT: ++self->status.select_timeouts; break;
case IEC104_COMMAND_FINISH_DECISION_TIMEOUT: ++self->status.decision_timeouts; break;
case IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT: ++self->status.execute_timeouts; break;
case IEC104_COMMAND_FINISH_COMPLETE_TIMEOUT: ++self->status.complete_timeouts; break;
case IEC104_COMMAND_FINISH_HANDOVER_TIMEOUT: ++self->status.handover_timeouts; break;
case IEC104_COMMAND_FINISH_TIME_EXPIRED: ++self->status.action_time_expired; break;
case IEC104_COMMAND_FINISH_TIME_REJECTED: ++self->status.action_time_rejected; break;
case IEC104_COMMAND_FINISH_CANCELLED:
case IEC104_COMMAND_FINISH_STOPPED:
case IEC104_COMMAND_FINISH_DISCONNECTED:
case IEC104_COMMAND_FINISH_CONNECTION_CHANGED:
case IEC104_COMMAND_FINISH_SEND_ERROR:
case IEC104_COMMAND_FINISH_SERVICE_ERROR: ++self->status.cancelled; break;
default: break;
}
Reap(self);
}
/**
* 功能:取消模块仍持有的全部回复,并终结尚未结束的事务。
* 输入参数:self为有效实例;reason交给Finish记录,仅首次终结生效。
* 输出参数:事务回复序号及独立回复池清空;欠应用的FINISHED仍保留。
* 返回值:无。
* 说明:返回补充:无;不修改发送层已经接手的帧,也不负责设置模块激活标志。
*/
static void Cancel_All(IEC104_Command_t *self, IEC104_CommandFinishReason_t reason)
{
CommandTransaction *task = &self->transaction;
task->confirm_serial = task->term_serial = task->reply_serial = 0U;
task->send_waiting = false;
memset(self->replies, 0, sizeof(self->replies));
Finish(self, reason);
}
/**
* 功能:动作或发送之前核对Slave会话,并按失效原因清理模块状态。
* 输入参数:self为有效实例,其session来自已经消费的连接通知。
* 输出参数:刷新events_pending;失效/错误时取消未提交回复、终结事务并清active。
* 返回值:READY可推进;WAIT_EVENTS须先读空通知;STALE表示旧事务不能继续;ERROR表示查询失败。
* 说明:约束:WAIT_EVENTS优先且不取消事务。Handle_Event消费通知时不能调用本门禁,
* 否则队列还有后续通知时,当前已经出队的通知会被阻挡或遗漏。
*/
static IEC104_SlaveRequestState_t Check_Session(IEC104_Command_t *self)
{
IEC104_SlaveRequestState_t state = IEC104_Slave_Check_Request(self->slave, &self->session);
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
if (state == IEC104_SLAVE_REQUEST_ERROR) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
self->status.active = false;
} else if (state != IEC104_SLAVE_REQUEST_WAIT_EVENTS &&
(!self->status.active || state != IEC104_SLAVE_REQUEST_READY)) {
Cancel_All(self, IEC104_COMMAND_FINISH_CONNECTION_CHANGED);
self->status.active = false;
state = IEC104_SLAVE_REQUEST_STALE;
}
return state;
}
/**
* 功能:根据当前事务阶段选择唯一生效的时长限制。
* 输入参数:self为有效实例。
* 输出参数:无。
* 返回值:当前决定/选择/执行/完成/交接或残留清理期限;无计时工作、回调中或配置禁用时为0。
* 说明:约束:只读,不判定到期;原决定/执行期限0仍保留回退检测,新收尾期限0同时关闭回退检测。
* select_timeout_ms只约束SELECTED的最长保持时间;DIRECT路径不进入该阶段。
*/
static uint32_t Timer_Limit(const IEC104_Command_t *self)
{
const CommandTransaction *task = &self->transaction;
if (!task->occupied || self->in_action) { return 0U; }
switch (task->phase) {
case IEC104_COMMAND_PHASE_SELECT_WAIT:
case IEC104_COMMAND_PHASE_EXECUTE_WAIT: return self->config.decision_timeout_ms;
case IEC104_COMMAND_PHASE_SELECTED: return self->config.select_timeout_ms;
case IEC104_COMMAND_PHASE_EXECUTING:
if (task->result == 0U) { return self->config.execute_timeout_ms; }
return task->completed ? self->config.handover_timeout_ms : self->config.complete_timeout_ms;
case IEC104_COMMAND_PHASE_ENDED:
return Pending_Transaction_Replies(task) != 0U ? self->config.handover_timeout_ms : 0U;
default: return 0U;
}
}
/**
* 功能:计算当前阶段距离启用的期限还剩多少毫秒。
* 输入参数:task提供timer_start_ms;limit为非零期限;now是本次统一采样的单调时间。
* 输出参数:无。
* 返回值:剩余毫秒;恰好到期、已经超期或时钟倒退均为0。
* 说明:约束:先比较64位差值再截窄,不使用可能溢出的起点加期限计算。
*/
static uint32_t Remaining(const CommandTransaction *task, uint32_t limit, uint64_t now)
{
if (now < task->timer_start_ms || now - task->timer_start_ms >= limit) { return 0U; }
return limit - (uint32_t)(now - task->timer_start_ms);
}
/**
* 功能:本地ENDED清理不需要会话准入。已冻结的FINISHED不变,读过FINISHED的槽也在这里及时回收。
* 输入参数:self——本模块实例。
* now——当前时刻。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:执行超时留下的否定TERM也受本期限约束;丢弃它只计dropped_replies,不覆盖EXECUTE_TIMEOUT。
* 期限0同时关闭清理回退检测;无残留回复时停表,不因未读FINISHED反复要求推进。
*/
static void Cleanup_Ended(IEC104_Command_t *self, uint64_t now)
{
CommandTransaction *task = &self->transaction;
uint32_t limit = self->config.handover_timeout_ms;
if (!task->occupied || task->phase != IEC104_COMMAND_PHASE_ENDED) { return; }
if (Pending_Transaction_Replies(task) != 0U && limit != 0U && Remaining(task, limit, now) == 0U) {
if (now < task->timer_start_ms) { ++self->status.clock_errors; }
Drop_Transaction_Replies(self);
}
Reap(self);
}
/**
* 功能:检查仍等待决定、执行命令或设备结果的阶段是否遇到单调时间倒退。
* 输入参数:self为有效实例;now为本次单调时钟采样。
* 输出参数:无。
* 返回值:计时阶段中now早于计时起点时为true;空闲或回调中为false。
* 说明:约束:原决定/选择/执行阶段即使禁用时长也检查回退;新增完成/交接/清理阶段只在期限非零时检查。
*/
static bool Clock_Reversed(const IEC104_Command_t *self, uint64_t now)
{
const CommandTransaction *task = &self->transaction;
return !self->in_action && task->occupied && now < task->timer_start_ms &&
(task->phase == IEC104_COMMAND_PHASE_SELECT_WAIT || task->phase == IEC104_COMMAND_PHASE_SELECTED ||
task->phase == IEC104_COMMAND_PHASE_EXECUTE_WAIT ||
(task->phase == IEC104_COMMAND_PHASE_EXECUTING && task->result == 0U) ||
Timer_Limit(self) != 0U);
}
/**
* 功能:分配模块内所有回复共用的递增FIFO序号。
* 输入参数:self为有效实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:成功为非零新序号;耗尽返回0,并以SERVICE_ERROR取消事务及回复、清active。
* 说明:约束:0是未排队哨兵;计数不回绕,避免新回复与历史排序身份重合。
*/
static uint64_t Reply_Serial(IEC104_Command_t *self)
{
if (self->next_reply == UINT64_MAX) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
self->status.active = false;
return 0U;
}
return ++self->next_reply;
}
/**
* 功能:使用事务自己的存储生成一条确认,分配全局FIFO位置。
* 输入参数:self持有当前事务;cause为确认/错误COT;negative为P/N。
* 输出参数:成功时写确认序号和策略,清confirm_submitted及send_waiting。
* 返回值:true已准备确认;false为序号耗尽,Reply_Serial已执行服务错误清理。
* 说明:约束:动作调用前必须准备必要确认资源,不能执行后再依赖独立回复池空位。
*/
static bool Set_Confirm(IEC104_Command_t *self, uint8_t cause, bool negative)
{
CommandTransaction *task = &self->transaction;
uint64_t serial = Reply_Serial(self);
if (serial == 0U) { return false; }
task->confirm_serial = serial;
task->confirm_cot = cause;
task->confirm_negative = negative;
task->confirm_submitted = false;
task->send_waiting = false;
return true;
}
/**
* 功能:在Complete关闭返回阶段后,检查协议收尾是否已经全部交接。
* 输入参数:self为有效实例。
* 输出参数:EXECUTING且completed、确认已接手、无确认/终止待发且事务尾已入SendBuffer时,按设备结果产生
* FINISHED(COMPLETED/EXECUTION_FAILED);其余状态只尝试Reap。
* 返回值:无。
* 说明:约束:正常收尾须等待ACT_TERM交接;发送交接不表示主站ACK或设备成功。
* 返回补充:无;既不发送报文也不回调应用。
*/
static void Complete_If_Sent(IEC104_Command_t *self);
/**
* 功能:等待执行结果超时,以否定TERM结束本次命令服务,保持TCP及其他业务继续运行。
* 输入参数:self为有效实例;仅由Expire在EXECUTING、result==0且期限到达/时钟回退时调用。
* 输出参数:TERM取得新的FIFO序号,保留原肯定ACT_CON和此前回复;随后冻结FINISHED(EXECUTE_TIMEOUT)。
* result保持未知,completed也不置位:本路径没有应用结果,不等价于Report_Result+Complete。
* 返回值:true已安排回复与终结通知,不表示TERM已交接;false为序号耗尽,保留SERVICE_ERROR收尾。
* 说明:约束:先占终止序号再Finish,防止应用先读FINISHED后事务被提前回收。
* 原队首若已WAIT,保留send_waiting,让它继续等待网络推进,不因新增TERM要求忙重试。
* 未提交TERM沿用ENDED残留清理;STOP/断线后不跨会话补发,也不再次调用设备动作。
* 否定TERM只表示服务未确认成功,不能证明物理动作未发生或已经停止。
*/
static bool Finish_Execute_Timeout(IEC104_Command_t *self)
{
uint64_t serial = Reply_Serial(self);
if (serial == 0U) { return false; }
self->transaction.term_serial = serial;
Finish(self, IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT);
return true;
}
/**
* 功能:按统一采样时刻执行当前阶段的到期转换,不调用应用动作。
* 输入参数:self为有效实例;now同时用于回退检测和期限比较。
* 输出参数:决定到期生成否定确认;选择到期丢弃本模块尚持有的选择确认;
* 执行到期保留原肯定确认并安排否定终止;完成/交接到期不撤回HIGH原文。
* 完整完成事实及ENDED本地清理先于期限判断,对应事务按需交付唯一FINISHED。
* 返回值:false表示执行超时的终止序号分配失败,已按服务错误收尾;其他情况true。
* 未到期且时钟未回退时不改变状态,时钟回退单独计clock_errors。
* 旧决定/执行期限0仍检查回退;新增收尾/清理期限0禁用该阶段的到期及回退处理。
* 说明:约束:动作/提交入口先通过会话门禁再调用;有效I帧按FIFO受理时也须在匹配前调用,
* 防止迟到执行先停掉选择计时、使已过期选择重新生效。
*/
static bool Expire(IEC104_Command_t *self, uint64_t now)
{
CommandTransaction *task = &self->transaction;
uint32_t limit;
bool reversed;
/* 完整完成条件先于期限,包括配置0;不能用旧确认的HANDED跳过尚在模块的ACT_TERM。 */
Complete_If_Sent(self);
Cleanup_Ended(self, now);
if (!task->occupied || task->phase == IEC104_COMMAND_PHASE_ENDED) { return true; }
limit = Timer_Limit(self);
reversed = Clock_Reversed(self, now);
if (!reversed && (limit == 0U || Remaining(task, limit, now) != 0U)) { return true; }
if (reversed) { ++self->status.clock_errors; }
switch (task->phase) {
case IEC104_COMMAND_PHASE_SELECT_WAIT:
case IEC104_COMMAND_PHASE_EXECUTE_WAIT:
if (Set_Confirm(self, IEC60870_ASDU_COT_ACTIVATION_CON, true)) {
Finish(self, IEC104_COMMAND_FINISH_DECISION_TIMEOUT);
}
break;
case IEC104_COMMAND_PHASE_SELECTED:
/* 到期只结束选择,不自动执行或重新选择;已被发送层接手的确认无法撤回。
* Finish后仍须交付FINISHED并完成回复收尾,Reap才释放唯一事务槽。 */
task->confirm_serial = 0U; /* 只能撤回模块尚持有的确认。 */
Finish(self, IEC104_COMMAND_FINISH_SELECT_TIMEOUT);
break;
case IEC104_COMMAND_PHASE_EXECUTING:
if (task->result == 0U) {
/* 动作已启动,不能因结果超时把原肯定确认改成否定。 */
return Finish_Execute_Timeout(self);
} else {
IEC104_CommandFinishReason_t reason = task->completed ?
IEC104_COMMAND_FINISH_HANDOVER_TIMEOUT : IEC104_COMMAND_FINISH_COMPLETE_TIMEOUT;
Drop_Transaction_Replies(self);
Finish(self, reason);
}
break;
default: break;
}
return true;
}
/**
* 功能:识别发送入口处理新网络输入后遇到的正常STOP,保留回复等待通知收尾。
* 输入参数:self为有效实例;identity是本次提交的原身份;submitted是发送入口返回值。
* 输出参数:匹配正常STOP时置events_pending,不计发送背压次数,不直接改变事务阶段。
* 返回值:仅ERROR且同一连接健康、已停用、仍有未读通知时为true;其他错误及FATAL均false。
* 说明:约束:FATAL可能已经写出字节,绝不能借此入口解释成可重试WAIT。
*/
static bool Defer_For_Stop(IEC104_Command_t *self, const IEC104_SlaveEventIdentity_t *identity,
IEC104_TcpSubmitResult_t submitted)
{
IEC104_TcpServerStatus_t status;
if (submitted != IEC104_TCP_SUBMIT_ERROR || identity->slave != self->slave ||
identity->instance_id != self->session.instance_id || identity->generation != self->session.generation ||
IEC104_Slave_Get_Status(self->slave, &status, NULL) != IEC104_TCP_OK ||
status.generation != identity->generation || !status.connected || !status.connection_status_valid ||
!status.asdu_queue_status_valid || status.connection.phase != IEC104_TCP_SESSION_ACTIVE ||
status.connection.fault != IEC104_TCP_FAULT_NONE || status.connection.data_transfer_started ||
status.pending_event_count == 0U) { return false; }
self->status.events_pending = true;
return true;
}
/* 队首种类:NONE无待发;CONFIRM/TERM/REPLY对应事务内三份排序记录;SHORT对应独立回复池。
* 三种事务内回复和独立回复共享一个序号域,不另建可溢出的指针FIFO。 */
enum { COMMAND_HEAD_NONE, COMMAND_HEAD_CONFIRM, COMMAND_HEAD_TERM, COMMAND_HEAD_REPLY, COMMAND_HEAD_SHORT };
/**
* 功能:只读查找所有待提交回复中生成序号最小的一项。
* 输入参数:self为有效实例;slot为非NULL输出,仅队首为SHORT时写入独立槽下标。
* 输出参数:slot——unsigned *所指数据的更新结果。
* 返回值:COMMAND_HEAD_*种类;没有待发回复时返回NONE。
* 说明:约束:不弹出、不预留发送资源;序号0表示无回复,不能参与排序。
*/
static unsigned Reply_Head(const IEC104_Command_t *self, unsigned *slot)
{
const CommandTransaction *task = &self->transaction;
uint64_t first = 0U;
unsigned head = COMMAND_HEAD_NONE, i;
if (task->confirm_serial != 0U) { first = task->confirm_serial; head = COMMAND_HEAD_CONFIRM; }
if (task->term_serial != 0U && (first == 0U || task->term_serial < first)) {
first = task->term_serial; head = COMMAND_HEAD_TERM;
}
if (task->reply_serial != 0U && (first == 0U || task->reply_serial < first)) {
first = task->reply_serial; head = COMMAND_HEAD_REPLY;
}
for (i = 0U; i < IEC104_COMMAND_REPLY_CAPACITY; ++i) {
if (self->replies[i].occupied && (first == 0U || self->replies[i].serial < first)) {
first = self->replies[i].serial; head = COMMAND_HEAD_SHORT; *slot = i;
}
}
return head;
}
/**
* 功能:在Complete关闭返回阶段后,检查协议收尾是否已经全部交接。
* 输入参数:self为有效实例。
* 输出参数:EXECUTING且completed、确认已接手、无确认/终止待发且事务尾已入SendBuffer时,按设备结果产生
* FINISHED(COMPLETED/EXECUTION_FAILED);其余状态只尝试Reap。
* 返回值:无。
* 说明:约束:正常收尾须等待ACT_TERM交接;发送交接不表示主站ACK或设备成功。
* 返回补充:无;既不发送报文也不回调应用。
*/
static void Complete_If_Sent(IEC104_Command_t *self)
{
CommandTransaction *task = &self->transaction;
if (task->occupied && task->phase == IEC104_COMMAND_PHASE_EXECUTING && task->completed &&
task->confirm_submitted && task->confirm_serial == 0U && task->term_serial == 0U) {
IEC104_ResponseState_t state = COMMAND_RESPONSE_STATE(self->slave, task->last_response_ticket);
if (state == IEC104_RESPONSE_HANDED) {
Finish(self, task->result == IEC104_COMMAND_RESULT_SUCCEEDED ?
IEC104_COMMAND_FINISH_COMPLETED : IEC104_COMMAND_FINISH_EXECUTION_FAILED);
} else if (state == IEC104_RESPONSE_ERROR) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
self->status.active = false;
}
/* PENDING等待网络推进;CANCELLED由既有STOP/断线/换代通知解释,不伪造成功。 */
}
Reap(self);
}
/**
* 功能:按全局FIFO向发送层交付至多一条回复。
* 输入参数:self为有效实例;内部先核对会话,再读取当前队首。
* 输出参数:OK后移除对应待交标记并计数,随后检查完成/释放;WAIT只保留原回复;
* 正常STOP先让出,其他发送错误终结事务并清回复池。
* 返回值:1表示有一条回复已被发送层接手;0表示无回复、等待或已处理发送失败;
* -1表示服务查询/组包错误,调用方应报告本轮推进失败。
* 说明:约束:局部副本只复制有效长度并改写COT/P/N,原工作请求和撤销回显来源不会被修改。
* CON/TERM、撤销及独立否定都沿用各自原文,保留接收的星期、GEN和TEST;
* 不从Copy_Request的归一化时间重编码,避免动作取值与应答回显混用。
*/
static int Submit_Head(IEC104_Command_t *self)
{
CommandTransaction *task = &self->transaction;
const IEC104_SlaveEventIdentity_t *identity;
const uint8_t *source;
uint8_t bytes[COMMAND_MAX_LENGTH], cause;
uint16_t length;
IEC60870_Asdu_t asdu;
IEC104_TcpSubmitResult_t submitted;
uint64_t ticket = 0U;
IEC104_SlaveRequestState_t state = Check_Session(self);
unsigned slot = 0U, head;
bool negative;
if (state == IEC104_SLAVE_REQUEST_ERROR) { return -1; }
if (state != IEC104_SLAVE_REQUEST_READY) { return 0; }
head = Reply_Head(self, &slot);
if (head == COMMAND_HEAD_NONE) { return 0; }
identity = &task->identity;
source = task->request_bytes;
length = task->request_length;
cause = IEC60870_ASDU_COT_ACTIVATION_TERMINATION;
negative = head == COMMAND_HEAD_TERM && (task->result == IEC104_COMMAND_RESULT_FAILED ||
task->finish_reason == IEC104_COMMAND_FINISH_EXECUTE_TIMEOUT);
/* 默认分支为ACT_TERM:成功P/N=0,明确失败或执行结果超时P/N=1。
* 超时的result仍为未知,P/N只报告本次命令服务未确认成功,不推断物理动作结果。
* 所有应答都进入HIGH,按FIFO保持模块提交顺序;不等待NORMAL排空。 */
if (head == COMMAND_HEAD_CONFIRM) {
cause = task->confirm_cot; negative = task->confirm_negative;
} else if (head == COMMAND_HEAD_REPLY) {
source = task->reply_bytes; length = task->reply_length; cause = task->reply_cot;
negative = cause != IEC60870_ASDU_COT_DEACTIVATION_CON;
} else if (head == COMMAND_HEAD_SHORT) {
identity = &self->replies[slot].identity;
source = self->replies[slot].bytes; length = self->replies[slot].length; cause = self->replies[slot].cot;
negative = true;
}
if (length < COMMAND_VALUE_OFFSET || length > sizeof(bytes)) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
return -1;
}
memcpy(bytes, source, length);
if (IEC60870_Asdu_Create_From_Buffer(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
bytes, length) != IEC60870_ASDU_OK ||
IEC60870_Asdu_Set_COT(&asdu, cause) != IEC60870_ASDU_OK ||
IEC60870_Asdu_Set_Negative(&asdu, negative) != IEC60870_ASDU_OK) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
return -1;
}
submitted = IEC104_Slave_Send_Response_Tracked_Priority(self->slave, identity, &asdu, &ticket,
IEC104_BUSINESS_PRIORITY_COMMAND);
if (submitted == IEC104_TCP_SUBMIT_OK) {
/* 发送层已复制/接手字节,立即撤销模块待发标记;不能等ACK再重复提交。 */
++self->status.submitted;
if (negative) { ++self->status.negative_submitted; }
if (head == COMMAND_HEAD_SHORT) { memset(&self->replies[slot], 0, sizeof(self->replies[slot])); }
else {
task->last_response_ticket = ticket;
task->send_waiting = false;
if (head == COMMAND_HEAD_CONFIRM) { task->confirm_serial = 0U; task->confirm_submitted = true; }
else if (head == COMMAND_HEAD_TERM) { task->term_serial = 0U; task->term_submitted = true; }
else { task->reply_serial = 0U; }
}
Complete_If_Sent(self);
return 1;
}
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
/* WAIT未接手,不改变FIFO号;仅标记等待,使状态查询不会要求无网络推进的忙轮询。 */
if (head == COMMAND_HEAD_SHORT) { self->replies[slot].send_waiting = true; }
else { task->send_waiting = true; }
++self->status.waits;
return 0;
}
if (Defer_For_Stop(self, identity, submitted)) { return 0; }
Cancel_All(self, IEC104_COMMAND_FINISH_SEND_ERROR);
self->status.active = false;
return 0;
}
/**
* 功能:为校验失败、实例忙或不允许撤销的请求保存一条独立否定回复。
* 输入参数:self为有效实例;identity为原会话身份;data至少含本类型规范长度;cause为回复COT。
* 输出参数:有空槽时复制原文、规范VSQ并分配FIFO号;池满计overloads/dropped_requests。
* 返回值:true表示已处理(含丢新或发送等待);false表示序号/服务/组包内部错误。
* 说明:约束:此前没有模块回复时才尝试当场提交;新短回复不能抢占事务必要确认存储,
* 也不能覆盖旧回复或因过载断开连接。
*/
static bool Short_Reply(IEC104_Command_t *self, const IEC104_SlaveEventIdentity_t *identity,
const uint8_t *data, uint8_t cause)
{
const CommandLayout *layout = Find_Layout(data[0]);
unsigned slot;
bool empty = Pending_Replies(self) == 0U;
uint64_t serial;
if (layout == NULL) { return false; }
for (slot = 0U; slot < IEC104_COMMAND_REPLY_CAPACITY; ++slot) {
if (!self->replies[slot].occupied) { break; }
}
if (slot == IEC104_COMMAND_REPLY_CAPACITY) {
++self->status.overloads;
++self->status.dropped_requests;
return true;
}
serial = Reply_Serial(self);
if (serial == 0U) { return false; }
self->replies[slot].identity = *identity;
memcpy(self->replies[slot].bytes, data, layout->length);
self->replies[slot].length = layout->length;
self->replies[slot].bytes[1] = 1U;
self->replies[slot].serial = serial;
self->replies[slot].cot = cause;
self->replies[slot].occupied = true;
self->replies[slot].send_waiting = false;
return !empty || Submit_Head(self) >= 0;
}
/**
* 功能:在已占用的事务槽中建立SELECT或EXECUTE工作事件。
* 输入参数:self已持有事务/站点;data为通过校验的命令原文;receive_serial为原I帧编号;
* now为受理时刻;selected说明本执行是否已经匹配本事务选择。
* 输出参数:替换工作原文,生成新事件号,重置当前交付/消费和确认标志,开始决定期限并计accepted。
* 返回值:无。
* 说明:约束:初始事务或匹配执行才可调用;保留事务身份、选择副作用和ever_work_delivered,
* 因此SELECT已交付而EXECUTE尚未交付时,取消仍须通知应用清理选择资源。
* 返回补充:无;不调用应用、不提交确认。
*/
static void Work_Event(IEC104_Command_t *self, const CommandLayout *layout, const uint8_t *data, uint64_t receive_serial,
uint64_t now, bool selected)
{
CommandTransaction *task = &self->transaction;
memcpy(task->request_bytes, data, layout->length);
task->request_length = layout->length;
task->request_bytes[1] = 1U;
task->receive_serial = receive_serial;
task->accepted_ms = task->timer_start_ms = now;
task->event_type = Is_Select(layout, data) ? IEC104_COMMAND_SELECT : IEC104_COMMAND_EXECUTE;
task->phase = task->event_type == IEC104_COMMAND_SELECT ?
IEC104_COMMAND_PHASE_SELECT_WAIT : IEC104_COMMAND_PHASE_EXECUTE_WAIT;
task->event_serial = ++self->next_event;
task->accepted_event_serial = 0U;
if (task->event_type == IEC104_COMMAND_SELECT) { task->select_event_serial = task->event_serial; }
else { task->execute_event_serial = task->event_serial; }
task->event_taken = false;
task->selected = selected;
task->confirm_submitted = false;
task->send_waiting = false;
++self->status.accepted;
}
/**
* 功能:TEST命令只演练协议状态机:复用唯一事务槽、选择期限及原文回复存储,不产生应用事件。
* 输入参数:self——本模块实例。
* layout——命令布局。
* data——数据存储。
* receive_serial——接收事件序号。
* now——当前时刻。
* selected——选中项。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 不调用Work_Event/Accept,不增加selected/executed动作计数,也不产生返回信息或FINISHED。
* 说明:调用方已完成格式/地址/点策略/限定词/时标以及SBO匹配检查,且已持有站点引用。
* 选择仅排肯定ACT_CON并保持模拟选择;执行排肯定ACT_CON及ACT_TERM,等待正常发送收尾。
* 不调用Work_Event/Accept,不增加selected/executed动作计数,也不产生返回信息或FINISHED。
* 原文T位贯穿全部确认;状态中的accepted/completed仍统计已经受理/完成的协议事务。
*/
static bool Test_Command(IEC104_Command_t *self, const CommandLayout *layout, const uint8_t *data,
uint64_t receive_serial, uint64_t now, bool selected)
{
CommandTransaction *task = &self->transaction;
bool selecting = Is_Select(layout, data);
memcpy(task->request_bytes, data, layout->length);
task->request_length = layout->length;
task->request_bytes[1] = 1U;
task->receive_serial = receive_serial;
task->accepted_ms = task->timer_start_ms = now;
task->selected = selected;
task->phase = selecting ? IEC104_COMMAND_PHASE_SELECTED : IEC104_COMMAND_PHASE_EXECUTING;
if (!Set_Confirm(self, IEC60870_ASDU_COT_ACTIVATION_CON, false)) { return false; }
if (!selecting) {
uint64_t serial = Reply_Serial(self);
if (serial == 0U) { return false; }
task->term_serial = serial;
task->result = IEC104_COMMAND_RESULT_SUCCEEDED;
task->completed = true;
}
++self->status.accepted;
return Submit_Head(self) >= 0;
}
/**
* 功能:使用事务自带回复存储处理撤销、重复选择或同点执行不匹配,然后结束应用交互。
* 输入参数:self持有待终结事务;data为本次终结旧事务的请求;cause为9或7;reason为终结原因。
* 输出参数:丢弃模块尚持有的旧确认/终止,保存本次请求回显及新的FIFO号,生成必要FINISHED。
* 返回值:true已处理(可仍等待发送);false为序号/服务/组包错误。
* 说明:约束:不依赖独立回复池空闲;原工作请求不覆盖,已提交给发送层的旧确认无法撤回。
*/
static bool End_With_Reply(IEC104_Command_t *self, const uint8_t *data, uint8_t cause,
IEC104_CommandFinishReason_t reason)
{
const CommandLayout *layout = Find_Layout(data[0]);
CommandTransaction *task = &self->transaction;
uint64_t serial;
if (layout == NULL) { return false; }
serial = Reply_Serial(self);
if (serial == 0U) { return false; }
task->confirm_serial = task->term_serial = 0U;
memcpy(task->reply_bytes, data, layout->length);
task->reply_length = layout->length;
task->reply_bytes[1] = 1U;
task->reply_cot = cause;
task->reply_serial = serial;
task->send_waiting = false;
/* 先使原事务和旧工作事件失效,再尝试交接本次回复;发送WAIT不恢复原选择。
* Finish只安排必要的FINISHED,实际返校资源仍由应用清理,不能直接清空事务绕过通知。 */
Finish(self, reason);
return Submit_Head(self) >= 0;
}
typedef enum {
COMMAND_TIME_ACCEPT,
COMMAND_TIME_INVALID,
COMMAND_TIME_NO_BASE,
COMMAND_TIME_CLOCK_REVERSED,
COMMAND_TIME_OVERFLOW,
COMMAND_TIME_EXPIRED,
COMMAND_TIME_FUTURE
} CommandTimeResult;
/**
* 功能:纯判断:受理和动作前共用,计数及否定/静默策略由各入口处理,不修改事务或读取Clock。
* 输入参数:self——本模块实例。
* has_time——bool值。
* time——时标。
* now——当前时刻。
* 输出参数:无。
* 返回值:按处理分支返回COMMAND_TIME_ACCEPT、COMMAND_TIME_INVALID、COMMAND_TIME_NO_BASE、COMMAND_TIME_CLOCK_REVERSED、COMMAND_TIME_OVERFLOW、COMMAND_TIME_EXPIRED、COMMAND_TIME_FUTURE。
* 说明:max=0只关闭时差限制,受理时仍校验CP56并拒绝IV;先比较再减,推算上限防止UTC加法溢出。
* 辅助星期/GEN的接收兼容不放宽时效:启用时标窗后,受理及Accept前都按实际UTC复查。
* 默认10s时标窗与15s决定期限各自独立,决定尚未超时也可能因时标过期而不能执行。
*/
static CommandTimeResult Check_Time(const IEC104_Command_t *self, bool has_time,
const IEC60870_CP56Time2a_t *time, uint64_t now)
{
uint32_t seconds;
uint64_t command_ms, station_ms, elapsed;
uint32_t limit = self->config.time_tag_max_delay_ms;
if (!has_time) { return COMMAND_TIME_ACCEPT; }
if (!IEC60870_Time_CP56_To_Seconds(time, self->config.master_utc_offset_minutes, &seconds)) {
return COMMAND_TIME_INVALID;
}
if (limit == 0U) { return COMMAND_TIME_ACCEPT; }
if (!self->status.time_base_valid) {
return COMMAND_TIME_NO_BASE;
}
if (now < self->time_base_ms) {
return COMMAND_TIME_CLOCK_REVERSED;
}
elapsed = now - self->time_base_ms;
if (elapsed > COMMAND_MAX_UTC_MS - self->time_base_utc_ms) {
return COMMAND_TIME_OVERFLOW;
}
station_ms = self->time_base_utc_ms + elapsed;
command_ms = (uint64_t)seconds * UINT64_C(1000) + time->time.ms;
if (command_ms <= station_ms) {
if (station_ms - command_ms >= limit) {
return COMMAND_TIME_EXPIRED;
}
} else if (command_ms - station_ms >= limit) {
return COMMAND_TIME_FUTURE;
}
return COMMAND_TIME_ACCEPT;
}
/**
* 功能:受理当前代次I帧,完成格式/时标校验、撤销、选择执行匹配和新事务建立。
* 输入参数:self为有效实例;event是Slave交付且归属已核验的事件;identity为原会话身份。
* 输出参数:有效命令生成工作事件;重复选择否定并复归;其他拒绝/静默激活按各分支处理。
* 返回值:IGNORED为未启用类型或不能接手;HANDLED包括保存、拒绝和丢弃;ERROR不得再走44兜底。
* 说明:约束:先确认完整单对象,再按COT、CA、IOA、对象格式、撤销、同点等待、时标顺序处理;
* 重复选择绕过同点等待分支,时标及点策略通过后才终结旧选择,不影响已开始的执行阶段。
* 撤销也先确认IOA存在;未知地址回47,已知地址无可撤销事务才回否定9。
* 完整单对象可按规范长度回显,截短或多对象不能截取/补零伪造单命令。
*/
static IEC104_CommandEventResult_t Request(IEC104_Command_t *self, const IEC104_SlaveEvent_t *event,
const IEC104_SlaveEventIdentity_t *identity)
{
CommandTransaction *task = &self->transaction;
IEC60870_AsduInfo_t info;
IEC104_Station_t *station;
const CommandLayout *layout;
const IEC104_CommandPoint_t *point;
CommandElement element;
CommandTimeResult time_result;
const uint8_t *data;
uint16_t length;
uint8_t cause = 0U;
uint32_t ioa;
uint64_t now;
bool same_point, is_select, duplicate_select;
if (!self->status.active || event->asdu_result != IEC60870_ASDU_OK ||
IEC60870_Asdu_Get_Data(&event->asdu, &data, &length) != IEC60870_ASDU_OK || length == 0U ||
(layout = Find_Layout(data[0])) == NULL ||
(self->config.type_mask & IEC104_COMMAND_TYPE_BIT(data[0])) == 0U ||
!IEC60870_Parse_ASDU_Header(event->asdu.parameters, data, length, &info)) {
return IEC104_COMMAND_EVENT_IGNORED;
}
now = IEC104_Net_Now_Ms();
/* 已经按FIFO消费到当前I帧;先转换期限,随后匹配不得重新激活已过期选择。 */
if (!Expire(self, now)) { return IEC104_COMMAND_EVENT_ERROR; }
if (!self->status.active) { return IEC104_COMMAND_EVENT_ERROR; }
if (info.object_count != 1U || length < layout->length) {
++self->status.rejected;
return IEC104_COMMAND_EVENT_HANDLED;
}
ioa = Read_IOA(data);
station = IEC104_Slave_Get_Station(self->slave, info.common_address);
is_select = Is_Select(layout, data);
if (info.cause_of_transmission != IEC60870_ASDU_COT_ACTIVATION &&
info.cause_of_transmission != IEC60870_ASDU_COT_DEACTIVATION) {
cause = IEC60870_ASDU_COT_UNKNOWN_CAUSE;
} else if (station == NULL) { cause = IEC60870_ASDU_COT_UNKNOWN_COMMON_ADDRESS; }
else if (ioa == 0U || (info.cause_of_transmission == IEC60870_ASDU_COT_DEACTIVATION &&
Find_Point(self, info.common_address, ioa) == NULL)) {
/* 撤销在后面直接完成,不经过新激活的点策略检查,故必须在这里识别未知地址。
* 地址错误不等同于“没有待撤销事务”:回47而非9,不能改写或终结其他点的事务。
* 已知点的类型/模式限制属于业务拒绝,不将其伪装成全局未知类型44。 */
cause = IEC60870_ASDU_COT_UNKNOWN_IOA;
}
else if (info.is_sequence || length != layout->length || info.is_negative_confirm) {
cause = info.cause_of_transmission == IEC60870_ASDU_COT_DEACTIVATION ?
IEC60870_ASDU_COT_DEACTIVATION_CON : IEC60870_ASDU_COT_ACTIVATION_CON;
} else {
CommandElementResult decoded = Decode_Element(layout, data, length, &element);
if (decoded == COMMAND_ELEMENT_TIME_INVALID) {
++self->status.time_rejected;
cause = IEC60870_ASDU_COT_COMMAND_TIME_ERROR;
} else if (decoded != COMMAND_ELEMENT_VALID) {
cause = info.cause_of_transmission == IEC60870_ASDU_COT_DEACTIVATION ?
IEC60870_ASDU_COT_DEACTIVATION_CON : IEC60870_ASDU_COT_ACTIVATION_CON;
}
}
if (cause != 0U) {
++self->status.rejected;
return Short_Reply(self, identity, data, cause) ? IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
same_point = task->occupied && task->identity.generation == identity->generation &&
IEC104_Station_Get_Id(task->station) == IEC104_Station_Get_Id(station) &&
Read_IOA(task->request_bytes) == ioa && ((task->request_bytes[2] ^ data[2]) & 0x80U) == 0U;
/* T位属于事务身份:模拟请求不能命中真实任务,真实请求也不能消费模拟选择。
* 站点注册编号参与匹配,同CA删除再注册不能接管旧选择;撤销不要求状态/QU相同。 */
if (info.cause_of_transmission == IEC60870_ASDU_COT_DEACTIVATION) {
/* TEST没有应用动作阶段;在此完成其时标校验,非法测试撤销不能清除模拟选择。 */
if (info.is_test) {
time_result = Check_Time(self, element.has_time, &element.time, now);
if (time_result != COMMAND_TIME_ACCEPT) {
if (time_result == COMMAND_TIME_EXPIRED) { ++self->status.time_expired; }
else { ++self->status.time_rejected; }
if (time_result == COMMAND_TIME_CLOCK_REVERSED) { ++self->status.clock_errors; }
++self->status.rejected;
return Short_Reply(self, identity, data, IEC60870_ASDU_COT_COMMAND_TIME_ERROR) ?
IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
}
if (same_point && task->request_bytes[0] == data[0] && task->request_bytes[3] == data[3] &&
(task->phase == IEC104_COMMAND_PHASE_SELECT_WAIT || task->phase == IEC104_COMMAND_PHASE_SELECTED ||
task->phase == IEC104_COMMAND_PHASE_EXECUTE_WAIT)) {
return End_With_Reply(self, data, IEC60870_ASDU_COT_DEACTIVATION_CON,
IEC104_COMMAND_FINISH_DEACTIVATED) ? IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
++self->status.rejected;
return Short_Reply(self, identity, data, IEC60870_ASDU_COT_DEACTIVATION_CON) ?
IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
/* 依据《配电自动化系统应用DL/T634.5104-2009实施细则(试行)》:
* 本目录20170804163032284877151.pdf第33页§8.1.4、第42页§8.2.7.1 c(从封面计页),
* 同点重复选择应恢复到未选择的初始状态,等待新的选择;返校状态收到选择应否定确认。
* 条文明确涉及45/46;本库对其他带S/E的类型统一处理,OA/合法值/QU/类型变化也复归。
* 这里只识别候选,仍须通过后面的时标和点策略校验,非法请求不能终结旧选择。
* SELECT_WAIT尚待应用决定也属于选择阶段;EXECUTE_WAIT已受理执行请求,即使设备
* 尚未实际动作,也与EXECUTING一样不再适用本分支,避免新选择取消已接纳的执行。 */
duplicate_select = same_point && is_select &&
(task->phase == IEC104_COMMAND_PHASE_SELECT_WAIT || task->phase == IEC104_COMMAND_PHASE_SELECTED);
if (!duplicate_select && same_point && (task->phase == IEC104_COMMAND_PHASE_SELECT_WAIT ||
task->phase == IEC104_COMMAND_PHASE_EXECUTE_WAIT)) {
/* 不同OA代表另一命令来源,须按新请求否定回显;不能当作原请求的重发吞掉。
* 独立短回复复用既有WAIT/满池丢新规则,不改原事务、工作事件或决定期限。
* 此处仍位于时差及点策略检查之前,只处理已通过前置报文校验的同点激活。 */
if (task->request_bytes[3] != data[3]) {
++self->status.rejected;
++self->status.busy_rejected;
return Short_Reply(self, identity, data, IEC60870_ASDU_COT_ACTIVATION_CON) ?
IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
/* 同OA原请求尚待应用决定,先回忙否定可能被主站误认为原请求的结果。
* 保留同会话/站点注册号/IOA/OA激活静默策略;不要求其余命令字段相同。
* 不占应答槽,不覆盖原请求/事件,不刷新决定期限;撤销已在前面独立处理。 */
++self->status.dropped_requests;
return IEC104_COMMAND_EVENT_HANDLED;
}
/* 撤销和非重复选择的决定期同点激活已处理;必须早于SELECTED匹配执行的提前返回。 */
time_result = Check_Time(self, element.has_time, &element.time, now);
if (time_result == COMMAND_TIME_EXPIRED) {
++self->status.time_expired;
if (!info.is_test && !self->config.negative_on_expired) { return IEC104_COMMAND_EVENT_HANDLED; }
} else if (time_result != COMMAND_TIME_ACCEPT) {
++self->status.time_rejected;
if (time_result == COMMAND_TIME_CLOCK_REVERSED) { ++self->status.clock_errors; }
}
if (time_result != COMMAND_TIME_ACCEPT) {
++self->status.rejected;
return Short_Reply(self, identity, data, IEC60870_ASDU_COT_COMMAND_TIME_ERROR) ?
IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
/* SELECTED阶段选择确认尚未被发送层接手时执行请求忙拒绝;接手后同点执行先匹配。
* 重复选择在点策略通过后单独终结旧事务,其他新激活不影响选择。
* Expire已先排除到期选择;匹配成功立即由Work_Event转入EXECUTE_WAIT并改计决定期限,
* 不等待select_timeout_ms耗尽。这里受理执行请求,实际动作仍须应用随后Accept。 */
if (same_point && !is_select && task->phase == IEC104_COMMAND_PHASE_SELECTED && task->confirm_submitted &&
(!info.is_test || task->request_bytes[3] == data[3])) {
if (!Same_Command(layout, task->request_bytes, data)) {
++self->status.rejected;
return End_With_Reply(self, data, IEC60870_ASDU_COT_ACTIVATION_CON,
IEC104_COMMAND_FINISH_MISMATCH) ? IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
if (info.is_test) {
return Test_Command(self, layout, data, event->transport.data.i_frame.receive_serial, now, true) ?
IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
Work_Event(self, layout, data, event->transport.data.i_frame.receive_serial, now, true);
return IEC104_COMMAND_EVENT_HANDLED;
}
/* 表在实例存活期间不可变;已匹配的执行沿用原选择许可,其他新激活须先通过点策略。
* 无点/类型/直接点选择的拒绝不占事务槽,不产生工作事件或FINISHED。 */
point = Find_Point(self, info.common_address, ioa);
if (point == NULL || (point->type_mask & IEC104_COMMAND_TYPE_BIT(data[0])) == 0U ||
(is_select && point->mode == IEC104_COMMAND_MODE_DIRECT)) {
++self->status.rejected;
return Short_Reply(self, identity, data, point == NULL ? IEC60870_ASDU_COT_UNKNOWN_IOA :
IEC60870_ASDU_COT_ACTIVATION_CON) ? IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
if (duplicate_select) {
/* 否定ACT_CON针对第二条选择,并使第一次选择事务失效;第二条不会成为新SELECT。
* 第一次的肯定确认若已被发送层接手(含HIGH中尚未上网的帧)不能撤回,也不为
* 第一次追加相反确认或ACT_TERM;模块仍持有的旧确认则由End_With_Reply清除。
* 旧Accept/Reject随即STALE,后续执行不能再沿用原选择,必须重新选择成功。
* 否定用事务自带回复,不依赖短回复池;原工作请求及副作用信息留给FINISHED。
* 仅旧工作事件曾交给应用时才欠一次FINISHED;未领取SELECT及TEST不产生该通知。
* 逻辑失效不等于槽已回收:必要FINISHED消费及否定交接/清理后,才能受理新选择。 */
++self->status.rejected;
return End_With_Reply(self, data, IEC60870_ASDU_COT_ACTIVATION_CON,
IEC104_COMMAND_FINISH_DUPLICATE_SELECT) ? IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
if (task->occupied || (!is_select && point->mode == IEC104_COMMAND_MODE_SELECT_EXECUTE)) {
/* 选择保持占唯一事务槽,通过前序校验的其他点(含DIRECT点)在此忙拒绝。
* 选择期限越长,未执行/未撤销的选择可能阻塞其他点越久;
* ENDED但尚欠FINISHED/事务回复也算忙,不能仅凭选择到期就认为槽已回收。 */
++self->status.rejected;
if (task->occupied) { ++self->status.busy_rejected; }
return Short_Reply(self, identity, data, IEC60870_ASDU_COT_ACTIVATION_CON) ?
IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
if (self->next_transaction == UINT64_MAX || (!info.is_test && self->next_event > UINT64_MAX - 3U)) {
/* 真实事务最多SELECT、EXECUTE、FINISHED三次生成;TEST不生成应用事件。 */
++self->status.overloads;
++self->status.dropped_requests;
return IEC104_COMMAND_EVENT_HANDLED;
}
if (IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) { return IEC104_COMMAND_EVENT_ERROR; }
/* Acquire成功后才占事务槽;独立短回复中的数值CA不借用这个引用。 */
memset(task, 0, sizeof(*task));
task->occupied = true;
task->identity = *identity;
task->station = station;
task->transaction_id = ++self->next_transaction;
if (info.is_test) {
return Test_Command(self, layout, data, event->transport.data.i_frame.receive_serial, now, false) ?
IEC104_COMMAND_EVENT_HANDLED : IEC104_COMMAND_EVENT_ERROR;
}
Work_Event(self, layout, data, event->transport.data.i_frame.receive_serial, now, false);
return IEC104_COMMAND_EVENT_HANDLED;
}
/**
* 功能:填写控制命令默认配置,不创建任何运行对象。
* 输入参数:config为输出结构;NULL时无操作。
* 输出参数:启用全部14种类型,点表为空;选择/决定/执行期限为30000/15000/60000毫秒,
* 完成/交接(及清理)期限为30000/60000毫秒,
* 收尾规则固定:成功肯定ACT_TERM,报告失败后Complete或执行结果超时否定ACT_TERM。
* 返回值:无。
* 说明:返回补充:无;调用方可在Create之前修改配置。
*/
void IEC104_Command_Config_Default(IEC104_CommandConfig_t *config)
{
if (config == NULL) { return; }
memset(config, 0, sizeof(*config));
config->type_mask = COMMAND_SUPPORTED_MASK;
/* 30s是本库的选择保持默认值。人工确认可从30s联调,自动紧接执行可考虑10s;
* 应用须按主站流程、确认发送等待及通信/调度余量,在Create之前调整此非零值。
* 它是等待匹配执行的上限,与下方10s命令时标时差检查分别生效。 */
config->select_timeout_ms = 30000U;
config->decision_timeout_ms = 15000U;
config->execute_timeout_ms = 60000U;
config->complete_timeout_ms = 30000U;
config->handover_timeout_ms = 60000U;
config->time_tag_max_delay_ms = 10000U;
/* 收到即过期或动作前复查过期,默认安排否定COT49,让主站结束本次请求。
* 须与主站约定迟到确认和重试的匹配方式;需静默丢弃时由应用显式设为false。 */
config->negative_on_expired = true;
config->master_utc_offset_minutes = IEC60870_LOCAL_UTC_OFFSET_MINUTES;
}
/**
* 功能:从静态池创建一个与Slave独占绑定的遥控实例。
* 输入参数:slave为有效服务句柄,寿命覆盖本实例;config按值复制,但其中点表借用至Destroy。
* 输出参数:成功时初始化空事务、空回复池和零统计,不建立网络监听,也不调用应用代码。
* 返回值:成功为池内不透明句柄;点表/类型位/期限配置非法、重复绑定、池满或实例号耗尽返回NULL。
* 说明:约束:必须早于消费Slave通知创建;点表有序、唯一且实例存活期间不可变,
* 当前允许45..51及58..64;51/64只允许直接执行,时区为-1439..1439。
*/
IEC104_Command_t *IEC104_Command_Create(IEC104_Slave_t *slave, const IEC104_CommandConfig_t *config)
{
const uint16_t supported = COMMAND_SUPPORTED_MASK;
IEC104_Command_t *free_slot = NULL;
unsigned i;
if (config == NULL || config->type_mask == 0U || (config->type_mask & (uint16_t)~supported) != 0U ||
config->select_timeout_ms == 0U ||
config->master_utc_offset_minutes < -1439 || config->master_utc_offset_minutes > 1439 ||
next_instance == UINT64_MAX || IEC104_Slave_Get_Application_Layer_Parameters(slave) == NULL ||
!Valid_Points(config)) { return NULL; }
for (i = 0U; i < IEC104_COMMAND_CAPACITY; ++i) {
if (command_pool[i].in_use && command_pool[i].slave == slave) { return NULL; }
if (!command_pool[i].in_use && free_slot == NULL) { free_slot = &command_pool[i]; }
}
if (free_slot == NULL) { return NULL; }
memset(free_slot, 0, sizeof(*free_slot));
free_slot->slave = slave;
free_slot->config = *config;
free_slot->serial = ++next_instance;
free_slot->in_use = true;
return free_slot;
}
/**
* 功能:只保存应用交付的时间对应关系;拒绝无效输入时不破坏先前基准。
* 输入参数:self——本模块实例。
* utc_ms——UTC毫秒时刻。
* base_ms——单调时间基准。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!Owned(self) || self->in_action || utc_ms > COMMAND_MAX_UTC_MS || base_ms > IEC104_Net_Now_Ms()时返回false;其余分支返回false、true。
* 说明:与其他修改入口一样禁止在Command动作回调中调用,允许离线和Slave尚未激活时调用。
*/
bool IEC104_Command_Set_Time_Base(IEC104_Command_t *self, uint64_t utc_ms, uint64_t base_ms)
{
if (!Owned(self) || self->in_action || utc_ms > COMMAND_MAX_UTC_MS || base_ms > IEC104_Net_Now_Ms()) {
return false;
}
self->time_base_utc_ms = utc_ms;
self->time_base_ms = base_ms;
self->status.time_base_valid = true;
return true;
}
/**
* 功能:清除基准不立即取消已受理事务,不修改已保存的命令时标;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:后续受理及Accept复查使用新状态。
*/
void IEC104_Command_Clear_Time_Base(IEC104_Command_t *self)
{
if (!Owned(self) || self->in_action) { return; }
self->status.time_base_valid = false;
self->time_base_utc_ms = self->time_base_ms = 0U;
}
/**
* 功能:归还空闲实例的静态池槽。
* 输入参数:self为待销毁句柄。
* 输出参数:成功清零实例;不隐式Cancel、不读取FINISHED、不关闭Slave。
* 返回值:true成功;无效句柄、动作回调中、事务仍占用或独立回复未清空时false。
* 说明:约束:先显式取消并完成事件/应答清理;成功后不得继续使用旧句柄。
*/
bool IEC104_Command_Destroy(IEC104_Command_t *self)
{
if (!Owned(self) || self->in_action || self->transaction.occupied || Pending_Replies(self) != 0U) { return false; }
memset(self, 0, sizeof(*self));
return true;
}
/**
* 功能:本地取消事务和模块尚未被发送层接手的回复,保留必要的应用清理通知。
* 输入参数:self为实例句柄;无效句柄或动作回调中调用时无操作。
* 输出参数:活动事务以CANCELLED结束,所有独立回复丢弃;会话激活状态保持,后续仍可接新请求。
* 返回值:无。
* 说明:返回补充:无;不撤回发送层已接手的字节,不回滚输出;已ENDED事务不改首次终结原因。
*/
void IEC104_Command_Cancel(IEC104_Command_t *self)
{
if (Owned(self) && !self->in_action) { Cancel_All(self, IEC104_COMMAND_FINISH_CANCELLED); }
}
/**
* 功能:按Slave FIFO顺序分派当前通知或I帧,不调用应用动作。
* 输入参数:self为实例;event须来自所属Slave的NextEvent或合法Copy_Event副本。
* 输出参数:连接/启停通知更新会话并按原因取消旧事务;I帧交Request处理。
* 返回值:HANDLED包括会话通知和已识别遥控请求;IGNORED为旧代次/未接手事件;
* ERROR为归属、实例、参数或重入错误,不可继续生成未知类型兜底回复。
* 说明:约束:状态通知先处理,不能统一套Check_Request;后续未出队通知不应阻挡当前通知消费。
*/
IEC104_CommandEventResult_t IEC104_Command_Handle_Event(IEC104_Command_t *self,
const IEC104_SlaveEvent_t *event)
{
IEC104_SlaveEventIdentity_t identity;
if (!Owned(self) || self->in_action ||
!IEC104_Slave_Get_Event_Identity(self->slave, event, &identity) ||
(self->session.instance_id != 0U && self->session.instance_id != identity.instance_id)) {
return IEC104_COMMAND_EVENT_ERROR;
}
self->session.slave = identity.slave;
self->session.instance_id = identity.instance_id;
if (event->transport.type == IEC104_TCP_EVENT_CONNECTED) {
/* 最高代次跨断线保留,历史CONNECTED副本不能重新绑定已经退役的连接。 */
if (identity.generation <= self->last_generation) { return IEC104_COMMAND_EVENT_IGNORED; }
Cancel_All(self, IEC104_COMMAND_FINISH_CONNECTION_CHANGED);
self->session.generation = self->last_generation = identity.generation;
self->status.active = false;
return IEC104_COMMAND_EVENT_HANDLED;
}
if (identity.generation != self->session.generation || identity.generation == 0U) {
return IEC104_COMMAND_EVENT_IGNORED;
}
switch (event->transport.type) {
case IEC104_TCP_EVENT_ACTIVATED:
self->status.active = true;
return IEC104_COMMAND_EVENT_HANDLED;
case IEC104_TCP_EVENT_DEACTIVATED:
Cancel_All(self, IEC104_COMMAND_FINISH_STOPPED);
self->status.active = false;
return IEC104_COMMAND_EVENT_HANDLED;
case IEC104_TCP_EVENT_DISCONNECTED:
Cancel_All(self, IEC104_COMMAND_FINISH_DISCONNECTED);
self->session.generation = 0U;
self->status.active = false;
return IEC104_COMMAND_EVENT_HANDLED;
case IEC104_TCP_EVENT_I_FRAME: return Request(self, event, &identity);
default: return IEC104_COMMAND_EVENT_IGNORED;
}
}
/**
* 功能:有界推进会话检查、期限转换及全局FIFO队首发送。
* 输入参数:self为实例句柄。
* 输出参数:每轮至多推进2*(1+独立回复容量)步;队首WAIT或有待消费通知时立即让出。
* 返回值:true表示本轮已处理,可仍等待发送/应用或刚刚取消;false为参数、重入、服务或组包错误。
* 说明:约束:不调用应用;每轮网络推进并分派通知后仍须调用,不能只在need_process为true时调用。
*/
bool IEC104_Command_Process(IEC104_Command_t *self)
{
unsigned step;
if (!Owned(self) || self->in_action) { return false; }
for (step = 0U; step < 2U * (1U + IEC104_COMMAND_REPLY_CAPACITY); ++step) {
IEC104_SlaveRequestState_t state = Check_Session(self);
int submitted;
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
if (state != IEC104_SLAVE_REQUEST_READY) { return true; }
if (!Expire(self, IEC104_Net_Now_Ms())) { return false; }
submitted = Submit_Head(self);
if (submitted <= 0) { return submitted == 0; }
}
return true;
}
/**
* 功能:交付当前最早且可读取的工作/终结事件。
* 输入参数:self为实例;event为非NULL输出结构,只有READY时改写。
* 输出参数:工作事件交付记录当前和历史交付标志;FINISHED交付清通知义务并尝试释放事务槽。
* 返回值:READY交付一个纯值事件;EMPTY为无事件或需先消费Slave通知;ERROR为参数/重入/服务错误。
* 说明:约束:入口独立清理ENDED残留回复;已有FINISHED不受离线/通知门禁阻挡。
* 工作事件先检查会话与期限,过期事件不会交给动作。
* 返回FINISHED时模块引用可能已释放,应用跨循环使用站点必须提前取得自己的引用。
*/
IEC104_CommandNextResult_t IEC104_Command_NextEvent(IEC104_Command_t *self, IEC104_CommandEvent_t *event)
{
CommandTransaction *task;
IEC104_CommandEvent_t result;
bool request_valid;
IEC104_SlaveRequestState_t state = IEC104_SLAVE_REQUEST_READY;
if (!Owned(self) || self->in_action || event == NULL) { return IEC104_COMMAND_NEXT_ERROR; }
Cleanup_Ended(self, IEC104_Net_Now_Ms());
task = &self->transaction;
/* 已存在的FINISHED不受离线或未读通知门禁阻挡;它只清理已结束的协议交互。 */
if (!task->finish_pending) {
state = Check_Session(self);
if (state == IEC104_SLAVE_REQUEST_READY && !Expire(self, IEC104_Net_Now_Ms())) {
return IEC104_COMMAND_NEXT_ERROR;
}
}
if (!task->finish_pending && state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_COMMAND_NEXT_ERROR; }
if (!task->occupied || (!task->finish_pending &&
(state != IEC104_SLAVE_REQUEST_READY || task->event_taken ||
(task->phase != IEC104_COMMAND_PHASE_SELECT_WAIT && task->phase != IEC104_COMMAND_PHASE_EXECUTE_WAIT)))) {
return IEC104_COMMAND_NEXT_EMPTY;
}
memset(&result, 0, sizeof(result));
result.type = (IEC104_CommandEventType_t)task->event_type;
result.instance_id = self->serial;
result.transaction_id = task->transaction_id;
result.event_serial = task->event_serial;
request_valid = Copy_Request(self, &result.request);
if (!request_valid && !task->finish_pending) {
/* 内部原文损坏不能继续执行;保留已交付事务的清理义务。 */
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
return IEC104_COMMAND_NEXT_ERROR;
}
if (task->finish_pending) {
/* 故障收尾只依赖事务身份,避免损坏原文令FINISHED永久不可读。值字段不可用于执行。 */
result.reason = request_valid ? (IEC104_CommandFinishReason_t)task->finish_reason :
IEC104_COMMAND_FINISH_SERVICE_ERROR;
result.select_effect = task->select_effect;
result.execute_effect = task->execute_effect;
result.return_info_undelivered = task->return_info_undelivered;
task->finish_pending = false;
} else {
/* 分开记录当前事件和事务历史:生成后续EXECUTE不能抹掉已交付SELECT的清理义务。 */
task->ever_work_delivered = true;
if (result.type == IEC104_COMMAND_SELECT) { task->select_delivered = true; }
else { task->execute_delivered = true; }
}
task->event_taken = true;
*event = result;
Reap(self);
return IEC104_COMMAND_NEXT_READY;
}
/**
* 功能:检查事件是否为当前事务当前阶段已经交付的那一个事件。
* 输入参数:self为有效实例;event可为NULL,其他情况下仅读取身份和类型。
* 输出参数:无。
* 返回值:实例号、事务号、当前事件号/种类和已交付标志全部匹配时true。
* 说明:约束:只读,不检查会话/期限;Slave身份不能代替这里的应用事务与工作事件身份。
*/
static bool Current_Event(const IEC104_Command_t *self, const IEC104_CommandEvent_t *event)
{
const CommandTransaction *task = &self->transaction;
return event != NULL && task->occupied && event->instance_id == self->serial &&
event->transaction_id == task->transaction_id && event->event_serial == task->event_serial &&
event->type == task->event_type && task->event_taken;
}
/**
* 功能:核对应用事件是否允许用于本类应答接口。
* 输入参数:self为有效实例;event为待应答事件;work=true要求已由NextEvent取走、
* 尚未由Accept/Reject消费的SELECT/EXECUTE,
* work=false要求已Accept且动作启动成功、仍处于EXECUTING的原EXECUTE令牌。
* 输出参数:无。
* 返回值:身份、交付/消费状态及阶段相符时true,否则false;不改变状态。
* 说明:约束:执行令牌可供报告结果、逐帧返回信息和Complete使用,各接口再检查自己的一次性条件。
*/
static bool Reply_Stage(const IEC104_Command_t *self, const IEC104_CommandEvent_t *event, bool work)
{
const CommandTransaction *task = &self->transaction;
if (!Current_Event(self, event)) { return false; }
if (work) {
return task->accepted_event_serial == 0U &&
((event->type == IEC104_COMMAND_SELECT && task->phase == IEC104_COMMAND_PHASE_SELECT_WAIT) ||
(event->type == IEC104_COMMAND_EXECUTE && task->phase == IEC104_COMMAND_PHASE_EXECUTE_WAIT));
}
return event->type == IEC104_COMMAND_EXECUTE && task->phase == IEC104_COMMAND_PHASE_EXECUTING &&
task->accepted_event_serial == event->event_serial && task->execute_effect;
}
/**
* 功能:统一执行应用应答入口的参数、事件、会话及期限检查。
* 输入参数:self/event为调用方传回的实例和纯值事件;work选择工作决定或已启动执行的校验模式。
* 输出参数:会话失效、期限到期或已Complete且尾帧交接时统一收尾;成功检查本身不消费事件、不调用动作。
* 返回值:OK可继续本次应答;WAIT须先消费Slave通知且本次未消费事件;STALE为身份/阶段失效;
* ERROR为参数、重入或服务查询错误。
* 说明:约束:先查会话再取一次now检查期限,之后再次校验阶段,避免到期转换后仍使用旧事件。
*/
static IEC104_CommandReplyResult_t Check_Reply(IEC104_Command_t *self,
const IEC104_CommandEvent_t *event, bool work)
{
IEC104_SlaveRequestState_t state;
if (!Owned(self) || self->in_action || event == NULL) { return IEC104_COMMAND_REPLY_ERROR; }
if (!Reply_Stage(self, event, work)) { return IEC104_COMMAND_REPLY_STALE; }
state = Check_Session(self);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_COMMAND_REPLY_ERROR; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_COMMAND_REPLY_WAIT; }
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_COMMAND_REPLY_STALE; }
if (!Expire(self, IEC104_Net_Now_Ms())) { return IEC104_COMMAND_REPLY_ERROR; }
if (!self->status.active) { return IEC104_COMMAND_REPLY_ERROR; }
return Reply_Stage(self, event, work) ? IEC104_COMMAND_REPLY_OK : IEC104_COMMAND_REPLY_STALE;
}
/**
* 功能:仅检查本次确认的保守接手机会;兼容模式检查入队容量,严格模式也考虑本轮获准的队满直交。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:WAIT在动作回调前返回,不标记该工作应答已受理。
* 说明:调用期间没有网络推进,也不保留跨调用额度;WAIT在动作回调前返回,不标记该工作应答已受理。
* 旧回复已由Accept门控挡住,回调不得修改Slave;状态失效不能伪装为容量WAIT。
*/
static IEC104_CommandReplyResult_t Check_Confirm_Room(IEC104_Command_t *self)
{
IEC104_TcpServerStatus_t status;
if (IEC104_Slave_Strict_Priority_Enabled(self->slave)) {
/* 动作前仍须有确认接手机会;不能让满环中的低等级原文提前挡住已获准的遥控级3。
* 此预检不预约容量,真实提交仍复核;也不授权越过同级前驱、未读通知或已编号帧。 */
IEC104_TcpSubmitResult_t room = IEC104_Slave_Query_Response_Priority(self->slave,
&self->transaction.identity, self->transaction.request_length, IEC104_BUSINESS_PRIORITY_COMMAND);
if (room == IEC104_TCP_SUBMIT_WAIT) {
++self->status.confirm_room_waits; return IEC104_COMMAND_REPLY_WAIT;
}
if (room != IEC104_TCP_SUBMIT_OK) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR); self->status.active = false;
return IEC104_COMMAND_REPLY_ERROR;
}
return IEC104_COMMAND_REPLY_OK;
}
if (COMMAND_CONFIRM_STATUS(self->slave, &status, NULL) != IEC104_TCP_OK ||
!status.asdu_queue_status_valid) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
self->status.active = false;
return IEC104_COMMAND_REPLY_ERROR;
}
if (status.high_queue.free_bytes < IEC104_ASDU_HIGH_ENTRY_HEADER_LEN + self->transaction.request_length) {
++self->status.confirm_room_waits;
return IEC104_COMMAND_REPLY_WAIT;
}
return IEC104_COMMAND_REPLY_OK;
}
/**
* 功能:接受已交付的SELECT/EXECUTE,在事件有效时最多调用一次同步应用动作。
* 输入参数:self/event为实例及原工作事件;action/context仅在本次调用借用,不保存。
* SELECT允许action=NULL,表示逻辑选择生效而无硬件副作用;EXECUTE必须提供action。
* 输出参数:先等模块旧回复、复查时标和HIGH容量,再准备确认、消费事件和调用动作。
* 按结果进入选择保持、执行等待结果或ENDED;动作后只提交本次确认。
* 返回值:OK仅表示工作交互已消费,动作可能NOT_STARTED/FAILED,确认也可能仍待发送;
* WAIT未调用动作、未消费事件;STALE不得执行;ERROR为参数/重入/服务或资源错误。
* 说明:约束:回调期间只允许只读查询;返回后重新采样阶段计时起点,不把回调耗时追认为决定超时。
*/
IEC104_CommandReplyResult_t IEC104_Command_Accept(IEC104_Command_t *self,
const IEC104_CommandEvent_t *event, IEC104_CommandAction_t action, void *context)
{
CommandTransaction *task;
IEC104_CommandRequest_t request;
IEC104_CommandActionResult_t action_result;
IEC104_CommandReplyResult_t checked;
bool selecting;
if (event != NULL && event->type == IEC104_COMMAND_EXECUTE && action == NULL) {
return IEC104_COMMAND_REPLY_ERROR;
}
checked = Check_Reply(self, event, true);
if (checked != IEC104_COMMAND_REPLY_OK) { return checked; }
/* 动作前不提交旧回复:交由Process推进,避免提交产生新通知后动作已执行而确认仍被门禁挡住。 */
if (Pending_Replies(self) != 0U) { return IEC104_COMMAND_REPLY_WAIT; }
task = &self->transaction;
selecting = task->event_type == IEC104_COMMAND_SELECT;
if (!Copy_Request(self, &request)) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
return IEC104_COMMAND_REPLY_ERROR;
}
if (request.has_time && self->config.time_tag_max_delay_ms != 0U) {
CommandTimeResult time_result = Check_Time(self, true, &request.time, IEC104_Net_Now_Ms());
if (time_result == COMMAND_TIME_INVALID) {
Cancel_All(self, IEC104_COMMAND_FINISH_SERVICE_ERROR);
self->status.active = false;
return IEC104_COMMAND_REPLY_ERROR;
}
if (time_result != COMMAND_TIME_ACCEPT) {
bool negative = time_result != COMMAND_TIME_EXPIRED || self->config.negative_on_expired;
task->accepted_event_serial = task->event_serial;
if (time_result == COMMAND_TIME_CLOCK_REVERSED) { ++self->status.clock_errors; }
if (negative && !Set_Confirm(self, IEC60870_ASDU_COT_COMMAND_TIME_ERROR, true)) {
return IEC104_COMMAND_REPLY_ERROR;
}
Finish(self, time_result == COMMAND_TIME_EXPIRED ?
IEC104_COMMAND_FINISH_TIME_EXPIRED : IEC104_COMMAND_FINISH_TIME_REJECTED);
if (negative) { (void)Submit_Head(self); }
return IEC104_COMMAND_REPLY_STALE;
}
}
checked = Check_Confirm_Room(self);
if (checked != IEC104_COMMAND_REPLY_OK) { return checked; }
/* 确认资源和序号在动作前准备。事务自己的回复不会被独立短回复洪泛挤占。 */
if (!Set_Confirm(self, IEC60870_ASDU_COT_ACTIVATION_CON, false)) {
return IEC104_COMMAND_REPLY_ERROR;
}
/* 先记录已消费的事件身份,回调即使经应用代码再次进入也不能重做同一动作。 */
task->accepted_event_serial = task->event_serial;
self->in_action = true;
action_result = action == NULL ? IEC104_COMMAND_ACTION_STARTED : action(context, &request);
self->in_action = false;
/* 非法动作返回值按可能有副作用的失败处理;已消费的动作绝不重试。 */
if (action_result != IEC104_COMMAND_ACTION_STARTED && action_result != IEC104_COMMAND_ACTION_NOT_STARTED) {
action_result = IEC104_COMMAND_ACTION_FAILED;
}
if (selecting) { task->select_effect = action != NULL && action_result != IEC104_COMMAND_ACTION_NOT_STARTED; }
else { task->execute_effect = action_result != IEC104_COMMAND_ACTION_NOT_STARTED; }
if (action_result == IEC104_COMMAND_ACTION_STARTED) {
task->phase = selecting ? IEC104_COMMAND_PHASE_SELECTED : IEC104_COMMAND_PHASE_EXECUTING;
/* 选择成功(含NULL动作)从动作返回后起计,不从主站收到确认时起计;
* 下方Submit_Head的发送等待已在选择保持期限内;执行动作返回STARTED则开始结果等待期限。 */
task->timer_start_ms = IEC104_Net_Now_Ms();
if (selecting) { ++self->status.selected; }
else { ++self->status.executed; }
} else {
task->confirm_negative = true;
if (action_result == IEC104_COMMAND_ACTION_NOT_STARTED) {
++self->status.app_rejected;
Finish(self, IEC104_COMMAND_FINISH_REJECTED);
} else { Finish(self, IEC104_COMMAND_FINISH_ACTION_FAILED); }
}
/* 提交可能接收STOP或产生故障;OK仍只描述动作交互已消费,应用继续读取FINISHED。 */
(void)Submit_Head(self);
return IEC104_COMMAND_REPLY_OK;
}
/**
* 功能:拒绝已交付且尚未消费的选择/执行工作事件。
* 输入参数:self/event为实例和原事件;cause为通用拒绝、未知IOA、软压板状态错误或时间戳错误。
* 输出参数:以当前工作请求否定回显7/47/48/49,计app_rejected并产生FINISHED(REJECTED)。
* 返回值:OK交互已消费、否定回复曾安排并尝试提交;WAIT未消费;STALE为旧事件;ERROR为非法参数或内部错误。
* 说明:约束:仅改变协议状态,不调用设备动作;回复使用事务自己的存储,不能因独立池满丢失。
* OK不保证回复仍在队列或已经发出:本次发送若失败,待交回复可能已被取消,须继续读取FINISHED。
* 软压板状态由应用确认;显式时间拒绝不受过期静默配置影响,也不冒充自动时标检查计数。
*/
IEC104_CommandReplyResult_t IEC104_Command_Reject(IEC104_Command_t *self,
const IEC104_CommandEvent_t *event, IEC104_CommandRejectCause_t cause)
{
IEC104_CommandReplyResult_t checked;
uint8_t cot;
switch (cause) {
case IEC104_COMMAND_REJECT_NEGATIVE: cot = IEC60870_ASDU_COT_ACTIVATION_CON; break;
case IEC104_COMMAND_REJECT_UNKNOWN_IOA: cot = IEC60870_ASDU_COT_UNKNOWN_IOA; break;
case IEC104_COMMAND_REJECT_INTERLOCK: cot = IEC60870_ASDU_COT_COMMAND_INTERLOCK_ERROR; break;
case IEC104_COMMAND_REJECT_TIME: cot = IEC60870_ASDU_COT_COMMAND_TIME_ERROR; break;
default: return IEC104_COMMAND_REPLY_ERROR;
}
checked = Check_Reply(self, event, true);
if (checked != IEC104_COMMAND_REPLY_OK) { return checked; }
if (!Set_Confirm(self, cot, true)) {
return IEC104_COMMAND_REPLY_ERROR;
}
self->transaction.accepted_event_serial = self->transaction.event_serial;
++self->status.app_rejected;
Finish(self, IEC104_COMMAND_FINISH_REJECTED);
(void)Submit_Head(self);
return IEC104_COMMAND_REPLY_OK;
}
/**
* 功能:一次性记录已启动设备动作的最终成功/失败结果,从执行期限转入完成期限。
* 输入参数:self/event为实例及启动成功的原EXECUTE事件;result为SUCCEEDED或FAILED。
* 输出参数:写入事务result并记录完成期限起点;不发送确认/终止、不关闭返回信息阶段、不调用应用。
* 返回值:OK已记录;WAIT结果未记录、先消费通知;STALE表示事务或事件已失效;
* ERROR为结果值非法、重复报告、已经Complete或参数/服务错误。
* 说明:约束:允许早于ACT_CON交接,设备执行时长和发送拥塞等待必须分开记账。
*/
IEC104_CommandReplyResult_t IEC104_Command_Report_Result(IEC104_Command_t *self,
const IEC104_CommandEvent_t *event, IEC104_CommandResult_t result)
{
IEC104_CommandReplyResult_t checked;
if (result != IEC104_COMMAND_RESULT_SUCCEEDED && result != IEC104_COMMAND_RESULT_FAILED) {
return IEC104_COMMAND_REPLY_ERROR;
}
checked = Check_Reply(self, event, false);
if (checked != IEC104_COMMAND_REPLY_OK) { return checked; }
if (self->transaction.result != 0U || self->transaction.completed) { return IEC104_COMMAND_REPLY_ERROR; }
self->transaction.result = (uint8_t)result;
self->transaction.timer_start_ms = IEC104_Net_Now_Ms();
return IEC104_COMMAND_REPLY_OK;
}
/**
* 功能:沿原事务连接向HIGH提交一帧命令返回信息,保持本事务确认、返回及终止的顺序。
* 输入参数:self/event为实例和启动成功的EXECUTE令牌;asdu为调用方持有的完整监视ASDU。
* 输出参数:完整验证104布局、对象、类型、COT、CA及标志;OK后累计发送和返回信息计数。
* 返回值:OK发送层已接手,不能重交;WAIT未接手且不缓存,应用保留或重建后重试;
* STALE为事务结束/发送故障已取消;ERROR为ASDU、阶段或参数错误。
* 正常STOP且通知尚未读取的发送ERROR先返回WAIT,保留由会话通知收尾的机会。
* 说明:约束:只能在肯定确认被发送层接手之后、Complete之前;模块内有任何更早回复时也必须WAIT。
* 返回信息不进入NORMAL、没有跨重连缓存;OK已占HIGH位置,WAIT未接手。
*/
IEC104_CommandReplyResult_t IEC104_Command_Submit_Return_Info(IEC104_Command_t *self,
const IEC104_CommandEvent_t *event, const IEC60870_Asdu_t *asdu)
{
CommandTransaction *task;
IEC60870_AsduInfo_t info;
const uint8_t *data;
uint16_t length;
IEC104_TcpSubmitResult_t submitted;
uint64_t ticket = 0U;
IEC104_CommandReplyResult_t checked = Check_Reply(self, event, false);
if (checked != IEC104_COMMAND_REPLY_OK) { return checked; }
task = &self->transaction;
if (task->completed || asdu == NULL || !IEC60870_AppLayerParameters_Valid(asdu->parameters) ||
asdu->parameters->sizeOfCOT != 2 || asdu->parameters->sizeOfCA != 2 || asdu->parameters->sizeOfIOA != 3 ||
asdu->parameters->maxSizeOfASDU > IEC104_MAX_ASDU_LEN ||
IEC60870_Asdu_Get_Data(asdu, &data, &length) != IEC60870_ASDU_OK || length > IEC104_MAX_ASDU_LEN ||
IEC60870_Asdu_Parse(IEC104_Slave_Get_Application_Layer_Parameters(self->slave), data, length, &info) !=
IEC60870_ASDU_OK ||
!((info.type_id >= 1U && info.type_id <= 21U) || (info.type_id >= 30U && info.type_id <= 40U)) ||
info.object_count == 0U ||
(info.cause_of_transmission != IEC60870_ASDU_COT_RETURN_INFO_REMOTE &&
info.cause_of_transmission != IEC60870_ASDU_COT_SPONTANEOUS) ||
info.is_negative_confirm || info.is_test != ((task->request_bytes[2] >> 7) & 1U) ||
info.common_address != Read_CA(task->request_bytes)) { return IEC104_COMMAND_REPLY_ERROR; }
/* 底层接口只知道传输队列;这里还必须检查模块内更早的独立/事务应答。 */
if (!task->confirm_submitted || Pending_Replies(self) != 0U) { return IEC104_COMMAND_REPLY_WAIT; }
/* 返回信息属于原遥控事务;即使COT=3,也不能按普通突发重新分类并越过确认或终止。 */
submitted = IEC104_Slave_Send_Response_Tracked_Priority(self->slave, &task->identity, asdu, &ticket,
IEC104_BUSINESS_PRIORITY_COMMAND);
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
task->return_waiting = true;
++self->status.waits;
return IEC104_COMMAND_REPLY_WAIT;
}
if (submitted == IEC104_TCP_SUBMIT_OK) {
task->return_waiting = false;
task->has_return = true;
task->last_return_ticket = task->last_response_ticket = ticket;
++self->status.submitted;
++self->status.return_info_submitted;
return IEC104_COMMAND_REPLY_OK;
}
if (Defer_For_Stop(self, &task->identity, submitted)) { return IEC104_COMMAND_REPLY_WAIT; }
Cancel_All(self, IEC104_COMMAND_FINISH_SEND_ERROR);
self->status.active = false;
return IEC104_COMMAND_REPLY_STALE;
}
/**
* 功能:声明本事务不再提交返回信息,并启动固定的协议终止收尾。
* 输入参数:self/event为实例及启动成功的原EXECUTE事件;设备结果必须已经Report_Result。
* 输出参数:分配终止FIFO序号,置completed并启动交接期限;成功肯定终止,失败否定终止。
* 两种已报告结果都占用终止序号,P/N在Submit_Head组包时确定;不会把失败改写成成功。
* 返回值:OK已关闭返回阶段,后续ACT_TERM由Process推进;WAIT未消费,先处理通知;
* STALE为事务失效;ERROR为未报告结果、重复调用或参数/内部错误。
* 说明:约束:OK不保证ACT_TERM已经发送;不能因等待终止而再次Complete或再提交返回信息。
*/
IEC104_CommandReplyResult_t IEC104_Command_Complete(IEC104_Command_t *self,
const IEC104_CommandEvent_t *event)
{
CommandTransaction *task;
uint64_t serial;
IEC104_CommandReplyResult_t checked = Check_Reply(self, event, false);
if (checked != IEC104_COMMAND_REPLY_OK) { return checked; }
task = &self->transaction;
if (task->result == 0U || task->completed) { return IEC104_COMMAND_REPLY_ERROR; }
serial = Reply_Serial(self);
if (serial == 0U) { return IEC104_COMMAND_REPLY_ERROR; }
task->term_serial = serial;
task->completed = true;
task->timer_start_ms = IEC104_Net_Now_Ms();
task->return_waiting = false;
/* Process只推进终止交接;应用不能重复Complete,也不能因等待终止而重做设备动作。 */
Complete_If_Sent(self);
return IEC104_COMMAND_REPLY_OK;
}
/**
* 功能:通过该事务任一已经交付的事件,只读查询仍保留的事务状态。
* 输入参数:self为实例;event为本事务历史SELECT/EXECUTE或已取FINISHED;info为非NULL输出。
* 输出参数:当前阶段、是否尚未ENDED、确认/结果/Complete/终止状态;不推进会话或期限。
* 返回值:true成功;句柄、身份、交付状态非法或槽已回收时false,失败保持info原值。
* 说明:约束:可在动作回调中查询;active只表示本地事务阶段,不保证当前连接仍允许操作。
* 不保存历史事务,槽回收后旧事件不能再查询,即使其字节副本仍由应用持有。
*/
bool IEC104_Command_Get_Transaction(const IEC104_Command_t *self,
const IEC104_CommandEvent_t *event, IEC104_CommandTransactionInfo_t *info)
{
const CommandTransaction *task;
IEC104_CommandTransactionInfo_t result;
bool delivered;
if (!Owned(self) || event == NULL || info == NULL) { return false; }
task = &self->transaction;
if (!task->occupied || event->instance_id != self->serial || event->transaction_id != task->transaction_id) {
return false;
}
delivered = (event->type == IEC104_COMMAND_SELECT && task->select_delivered &&
event->event_serial == task->select_event_serial) ||
(event->type == IEC104_COMMAND_EXECUTE && task->execute_delivered &&
event->event_serial == task->execute_event_serial) ||
(event->type == IEC104_COMMAND_FINISHED && task->event_type == IEC104_COMMAND_FINISHED &&
task->event_taken && event->event_serial == task->event_serial);
if (!delivered) { return false; }
memset(&result, 0, sizeof(result));
result.active = task->phase != IEC104_COMMAND_PHASE_ENDED;
result.phase = (IEC104_CommandPhase_t)task->phase;
result.confirm_submitted = task->confirm_submitted;
result.result_reported = task->result != 0U;
result.completed = task->completed;
result.term_submitted = task->term_submitted;
*info = result;
return true;
}
/**
* 功能:生成实例累计统计和当前调度条件的只读快照。
* 输入参数:self为实例;status为非NULL输出,可在动作回调内使用。
* 输出参数:在累计统计副本上即时计算会话通知、事务占用、待交回复/事件及期限剩余量。
* 返回值:true成功;无效参数或Slave查询失败时false,失败不改输出。
* 说明:约束:不触发到期转换、不取消事务、不预留发送容量;发送WAIT不要求持续空转,
* 但每轮网络推进后仍须调用Process重试。已有FINISHED由NextEvent读取,不靠Process清理。
*/
bool IEC104_Command_Get_Status(const IEC104_Command_t *self, IEC104_CommandStatus_t *status)
{
const CommandTransaction *task;
IEC104_CommandStatus_t result;
IEC104_SlaveRequestState_t state;
uint32_t limit;
uint64_t now;
unsigned slot = 0U, head;
bool waiting;
if (!Owned(self) || status == NULL) { return false; }
state = IEC104_Slave_Check_Request(self->slave, &self->session);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
task = &self->transaction;
result = self->status;
result.generation = self->session.generation;
result.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
result.busy = task->occupied;
result.pending_replies = Pending_Replies(self);
result.pending_events = task->occupied && (task->finish_pending ||
(!task->event_taken && (task->phase == IEC104_COMMAND_PHASE_SELECT_WAIT ||
task->phase == IEC104_COMMAND_PHASE_EXECUTE_WAIT))) ? 1U : 0U;
limit = Timer_Limit(self);
now = IEC104_Net_Now_Ms();
result.timer_active = limit != 0U;
result.timeout_remaining_ms = limit != 0U ? Remaining(task, limit, now) : 0U;
result.need_process = false;
head = Reply_Head(self, &slot);
waiting = head == COMMAND_HEAD_SHORT ? self->replies[slot].send_waiting : task->send_waiting;
if (!self->in_action && !result.events_pending) {
/* 有通知时先交回Slave;离线仅有FINISHED时无需反复推进,让应用直接读清理事件。 */
if (state != IEC104_SLAVE_REQUEST_READY || !result.active) {
result.need_process = result.pending_replies != 0U ||
(task->occupied && task->phase != IEC104_COMMAND_PHASE_ENDED);
} else {
/* 到期/回退或尚未尝试的队首需要立即推进;已WAIT的队首等待网络进展再重试。 */
result.need_process = Clock_Reversed(self, now) ||
(result.timer_active && result.timeout_remaining_ms == 0U) ||
(head != COMMAND_HEAD_NONE && !waiting);
if (task->occupied && task->phase == IEC104_COMMAND_PHASE_EXECUTING && task->completed &&
task->confirm_submitted && task->confirm_serial == 0U && task->term_serial == 0U) {
IEC104_ResponseState_t response =
COMMAND_RESPONSE_STATE(self->slave, task->last_response_ticket);
if (response == IEC104_RESPONSE_HANDED || response == IEC104_RESPONSE_ERROR) {
result.need_process = true;
}
}
}
}
*status = result;
return true;
}