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

1304 lines
62 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.
/*
* 国网扩展 Type211:固定任务 FIFO、单升级会话、显式动作和历史 ACK 授权。
* 站点引用依次由任务、真实/TEST 会话或待交付 ABANDON 独占,不因指针复制重复释放。
* Handle_Event 受理,Execute_Next 调动作,Process 发确认/观察 ACK,Take_Restart 交出授权;
* 本模块不保存应用回调,不操作文件或重启设备。公开契约与部署边界见同名头文件。
*/
#include "IEC104_SoftwareUpgrade.h"
#include "IEC104_TcpServer_Config.h"
#include "IEC104_Net.h"
#include "IEC60870_Codec.h"
#include <string.h>
#ifndef IEC104_SOFTWARE_UPGRADE_CAPACITY
#define IEC104_SOFTWARE_UPGRADE_CAPACITY IEC104_TCP_SERVER_CAPACITY
#endif
#ifndef IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY
#define IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY 2U
#endif
/* 静态池和队列均须非空;任务数上限也保证索引/计数运算不会绕回。 */
typedef char Upgrade_Instance_Capacity_Check[(IEC104_SOFTWARE_UPGRADE_CAPACITY > 0U) ? 1 : -1];
typedef char Upgrade_Task_Capacity_Check[(IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY > 0U &&
IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY <= UINT32_MAX / 2U) ? 1 : -1];
#ifdef IEC104_SOFTWARE_UPGRADE_TEST_HOOKS
/**
* 功能:仅专项构建替换发送、查询和时钟,以到达拥塞/故障/历史时刻分支;生产不导出注入入口。
* 输入参数:self/identity——从站服务及请求身份;asdu——待提交的应答ASDU。
* 输出参数:self——本模块实例的更新结果。
* 返回值:OK已复制接手;WAIT未接手;ERROR为身份或ASDU非法;FATAL为连接故障。
* 说明:可直接交接或进入HIGH队列;本入口不返回票据,成功不表示对端已确认。
*/
extern IEC104_TcpSubmitResult_t IEC104_SoftwareUpgrade_Test_Send_Response(IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *, const IEC60870_Asdu_t *);
/**
* 功能:使用默认业务等级提交应答,同时申请可查询对端ACK的回执。
* 输入参数:self/identity——从站服务及请求身份;asdu——待提交应答。
* 输出参数:receipt——必填,仅最终OK时写入服务身份、连接代次和票据。
* 返回值:OK已接手并建立观察;WAIT未接手,含观察槽耗尽;ERROR非法;FATAL为连接故障。
* 说明:OK不表示已收到ACK;调用方使用完回执后须调用Release_Ack归还观察资源。
*/
extern IEC104_TcpSubmitResult_t IEC104_SoftwareUpgrade_Test_Send_Response_Acked(IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *, const IEC60870_Asdu_t *, IEC104_SlaveAckReceipt_t *);
/**
* 功能:查询是历史通信事实,不要求Check_Request为READY;
* 输入参数:self——本模块实例。
* receipt——ACK回执。
* acked_at_ms——ACK确认毫秒时刻。
* 输出参数:acked_at_ms——ACK确认毫秒时刻的更新结果。
* 返回值:按处理分支返回IEC104_SLAVE_ACK_ERROR、(IEC104_SlaveAckState_t)IEC104_TcpServer_Get_Ack_State(self->server, receipt->identity.generation, receipt->ticket, acked_at_ms)。
* 说明:动作提交条件由业务选择相应ACK契约。
*/
extern IEC104_SlaveAckState_t IEC104_SoftwareUpgrade_Test_Get_Ack_State(const IEC104_Slave_t *,
const IEC104_SlaveAckReceipt_t *, uint64_t *);
/**
* 功能:历史活动期结果不依赖当前通知是否读空;
* 输入参数:self——本模块实例。
* receipt——ACK回执。
* acked_at_ms——ACK确认毫秒时刻。
* 输出参数:acked_at_ms——ACK确认毫秒时刻的更新结果。
* 返回值:按处理分支返回IEC104_SLAVE_ACK_ERROR、(IEC104_SlaveAckState_t)IEC104_TcpServer_Get_Active_Ack_State(self->server, receipt->identity.generation, receipt->ticket, acked_at_ms)。
* 说明:实例身份仍须匹配,避免静态槽复用混淆回执。
*/
extern IEC104_SlaveAckState_t IEC104_SoftwareUpgrade_Test_Get_Active_Ack_State(const IEC104_Slave_t *,
const IEC104_SlaveAckReceipt_t *, uint64_t *);
/**
* 功能:统一判断业务是否应先处理通知、放弃失效请求,或继续当前会话的工作。
* 输入参数:identity为Get_Event_Identity的只读结果,允许零初始化表示尚未绑定会话。
* 输出参数:无。
* 返回值:ERROR为参数/查询失败;WAIT_EVENTS优先于会话判断;STALE为原身份不再可用;READY可继续。
* 说明:检查通知FIFO、服务实例、TCP代次和传输激活状态,不执行I/O或保留发送窗口。
* 先读空通知可避免同一代次STOP后又START时,仅凭最终激活状态误续旧业务。
*/
extern IEC104_SlaveRequestState_t IEC104_SoftwareUpgrade_Test_Check_Request(const IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *);
/**
* 功能:取得内部TCP服务、队列和最近会话的状态副本,不推进协议或消费队列。
* 输入参数:self——有效句柄;status——非NULL输出存储;error——可选诊断。
* 输出参数:status——状态快照的更新结果。
* error——错误诊断的更新结果。
* 返回值:OK写入status,失败保持输出;Create后、Init失败后和Close后均可查询。
* 说明:会话和队列各自有有效标志,connected与data_transfer_started含义不同。
*/
extern IEC104_TcpResult_t IEC104_SoftwareUpgrade_Test_Get_Status(const IEC104_Slave_t *,
IEC104_TcpServerStatus_t *, IEC104_TcpError_t *);
/**
* 功能:紧凑业务上下文只需保留来源身份即可关闭原会话;
* 输入参数:self——本模块实例。
* identity——原会话身份。
* error——错误诊断。
* 输出参数:self——本模块实例的更新结果。
* error——错误诊断的更新结果。
* 返回值:按处理分支返回Slave_Error(IEC104_TCP_INVALID_HANDLE, error)、Slave_Error(IEC104_TCP_INVALID_ARGUMENT, error)、IEC104_TcpServer_Close_Connection(self->server, identity->generation, error)。
* 说明:校验与完整事件关闭入口一致。
*/
extern IEC104_TcpResult_t IEC104_SoftwareUpgrade_Test_Close_Connection_By_Identity(IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *, IEC104_TcpError_t *);
/**
* 功能:读取系统启动以来的64位毫秒计数;供相对期限计算,不受用户修改日历时间影响。
* 输入参数:无。
* 输出参数:无。
* 返回值:64位单调毫秒计数,不是UTC时间戳,也不用于显示日期;0及连续读取相等值有效。
* 说明:不在此处换算为UTC或本地时间,避免将协议超时与日历时钟混用。
*/
extern uint64_t IEC104_SoftwareUpgrade_Test_Now_Ms(void);
#define UP_SEND IEC104_SoftwareUpgrade_Test_Send_Response
#define UP_SEND_ACK IEC104_SoftwareUpgrade_Test_Send_Response_Acked
#define UP_ACK IEC104_SoftwareUpgrade_Test_Get_Ack_State
#define UP_ACTIVE_ACK IEC104_SoftwareUpgrade_Test_Get_Active_Ack_State
#define UP_CHECK IEC104_SoftwareUpgrade_Test_Check_Request
#define UP_STATUS IEC104_SoftwareUpgrade_Test_Get_Status
#define UP_CLOSE IEC104_SoftwareUpgrade_Test_Close_Connection_By_Identity
#define UP_NOW IEC104_SoftwareUpgrade_Test_Now_Ms
#else
/* 升级控制在12级业务优先级中扩展归复位进程级,END仍须独立观察主站ACK再交重启授权。 */
#define UP_SEND(s, i, a) IEC104_Slave_Send_Response_Priority(s, i, a, IEC104_BUSINESS_PRIORITY_RESET)
#define UP_SEND_ACK(s, i, a, r) IEC104_Slave_Send_Response_Acked_Priority(s, i, a, r, IEC104_BUSINESS_PRIORITY_RESET)
#define UP_ACK IEC104_Slave_Get_Ack_State
#define UP_ACTIVE_ACK IEC104_Slave_Get_Active_Ack_State
#define UP_CHECK IEC104_Slave_Check_Request
#define UP_STATUS IEC104_Slave_Get_Status
#define UP_CLOSE IEC104_Slave_Close_Connection_By_Identity
#define UP_NOW IEC104_Net_Now_Ms
#endif
enum { UPGRADE_EXECUTE = 1, UPGRADE_REPLY = 2 };
/* 槽在动作执行后仍留在 FIFO,直到确认提交或任务取消;WAIT 不重复应用动作。 */
typedef struct {
IEC104_SoftwareUpgradeRequest_t request;
IEC104_Station_t *station; /* START 接受后转给真实/TEST 会话,并将本指针清零。 */
uint64_t reply_started_ms, start_session_serial; /* 普通回复期限;关联尚未提交的 START 肯定。 */
uint8_t bytes[10], length, phase, cause; /* 原文最多十字节;构造确认时仅改允许字段。 */
/* send_waiting 抑制零等待重试;ack_confirm 标明真实 END 肯定,使用独立 ACK 期限。 */
bool occupied, negative, test, reply_started, send_waiting, ack_confirm;
} UpgradeTask;
/* END 提交后离开任务 FIFO,但原 START、END 和站点引用一直保留到真实会话结局。 */
typedef struct {
IEC104_SoftwareUpgradeSessionState_t state;
IEC104_SoftwareUpgradeRequest_t start, end;
IEC104_Station_t *station;
IEC104_SlaveAckReceipt_t receipt;
uint64_t ack_started_ms; /* 在 END 动作前采样,把动作耗时计入 ACK 期限。 */
bool ack_submitted; /* 确认已交发送层,不能再发相反确认;不等于已获 ACK。 */
} UpgradeSession;
/* TEST 也持有站点引用,但不占 ACK 槽、不调用动作,结束时直接释放。 */
typedef struct {
IEC104_SlaveEventIdentity_t identity;
IEC104_Station_t *station;
uint64_t station_id;
uint16_t common_address;
bool active;
} UpgradeTestSession;
/* 只有一个真实会话;下一 START 执行前必须先交付此记录,因此只需一个收尾槽。 */
typedef struct {
IEC104_SoftwareUpgradeRequest_t request;
IEC104_Station_t *station;
bool pending;
} UpgradeAbandon;
struct IEC104_SoftwareUpgrade {
IEC104_Slave_t *slave;
IEC104_SlaveEventIdentity_t transport; /* 当前通知代次;既有授权保留其自身的原 END 身份。 */
IEC104_SoftwareUpgradeConfig_t config;
IEC104_SoftwareUpgradeStatus_t status;
UpgradeTask tasks[IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY];
unsigned order[IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY], count; /* FIFO 只移动槽索引,不移动任务内容。 */
UpgradeSession session;
UpgradeTestSession test;
UpgradeAbandon abandon;
uint64_t instance_id, last_session_serial; /* 实例编号跨池复用递增;会话序号仅在本实例内递增。 */
/* in_action 阻止回调重入修改;FATAL 关闭最多尝试一次,faulted 不自动恢复。 */
bool in_use, in_action, fatal_close_attempted;
};
static IEC104_SoftwareUpgrade_t software_upgrade_pool[IEC104_SOFTWARE_UPGRADE_CAPACITY];
static uint64_t software_upgrade_last_instance;
/**
* 功能:先在静态池中匹配地址,再解引用;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:true表示句柄属于当前占用的静态实例槽;NULL、池外地址或未占用槽返回false。
* 说明:可安全拒绝 NULL 或外部伪句柄。
*/
static bool Owned(const IEC104_SoftwareUpgrade_t *self)
{
unsigned i;
for (i = 0U; i < IEC104_SOFTWARE_UPGRADE_CAPACITY; ++i) {
if (self == &software_upgrade_pool[i]) { return self->in_use; }
}
return false;
}
/**
* 功能:句柄可能复用,连接也可能重建,因此三项必须同时相同。
* 输入参数:a——const IEC104_SlaveEventIdentity_t *所指数据。
* b——const IEC104_SlaveEventIdentity_t *所指数据。
* 输出参数:无。
* 返回值:服务指针、实例编号和连接代次三者相同返回true,否则false。
* 说明:直接处理传入的a、b,不经过其他函数调用。
*/
static bool Same_Identity(const IEC104_SlaveEventIdentity_t *a, const IEC104_SlaveEventIdentity_t *b)
{
return a->slave == b->slave && a->instance_id == b->instance_id && a->generation == b->generation;
}
/**
* 功能:调用者先排除禁用的零期限;
* 输入参数:limit——uint32_t值。
* start——uint64_t值。
* now——当前时刻。
* 输出参数:无。
* 返回值:按处理分支返回0U、limit - (uint32_t)(now - start)。
* 说明:时钟倒退和恰好到边界都按到期处理。
*/
static uint32_t Remaining(uint32_t limit, uint64_t start, uint64_t now)
{
if (now < start || now - start >= limit) { return 0U; }
return limit - (uint32_t)(now - start);
}
/**
* 功能:清空持有者指针,使同一清理路径重复经过时不会重复归还引用。
* 输入参数:self——本模块实例。
* station——逻辑站点。
* 输出参数:station——逻辑站点的更新结果。
* 返回值:无。
* 说明:内部调用:IEC104_Slave_Release_Station。
*/
static void Release_Station(IEC104_SoftwareUpgrade_t *self, IEC104_Station_t **station)
{
if (*station != NULL) {
(void)IEC104_Slave_Release_Station(self->slave, *station);
*station = NULL;
}
}
/**
* 功能:返回FIFO队首的借用任务槽,空队列返回NULL;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:返回FIFO队首的借用任务槽,空队列返回NULL;
* 说明:不移除任务或改变其回复期限。
*/
static UpgradeTask *Head(IEC104_SoftwareUpgrade_t *self)
{
return self->count != 0U ? &self->tasks[self->order[0]] : NULL;
}
/**
* 功能:普通回复第一次成为队首时起算,WAIT 重试不重置;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:无。
* 说明:真实 END 肯定用 ACK 期限。
*/
static void Arm_Head_Reply(IEC104_SoftwareUpgrade_t *self)
{
UpgradeTask *task = Head(self);
if (task != NULL && task->phase == UPGRADE_REPLY && !task->ack_confirm && !task->reply_started) {
task->reply_started_ms = UP_NOW();
task->reply_started = true;
}
}
/**
* 功能:仅归还任务仍持有的引用;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:已转交会话的 START 指针为空,不影响会话寿命。
*/
static void Remove_Head(IEC104_SoftwareUpgrade_t *self)
{
UpgradeTask *task = Head(self);
if (task == NULL) { return; }
Release_Station(self, &task->station);
memset(task, 0, sizeof(*task));
--self->count;
if (self->count != 0U) {
memmove(self->order, self->order + 1U, self->count * sizeof(self->order[0]));
Head(self)->send_waiting = false;
Arm_Head_Reply(self);
}
}
/**
* 功能:生命周期取消也包含已执行但尚未提交确认的任务,逐槽累计 cancelled。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:内部调用:Remove_Head。
*/
static void Clear_Tasks(IEC104_SoftwareUpgrade_t *self)
{
while (self->count != 0U) {
++self->status.cancelled;
Remove_Head(self);
}
}
/**
* 功能:TEST 没有 ABANDON 结局通知,模拟会话的站点引用在此闭合。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:内部调用:Release_Station、memset。
*/
static void End_Test(IEC104_SoftwareUpgrade_t *self)
{
Release_Station(self, &self->test.station);
memset(&self->test, 0, sizeof(self->test));
}
/**
* 功能:观察槽与授权寿命分离:进入 READY 就释放槽,已确定的授权仍由 session 保存。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:内部调用:IEC104_Slave_Release_Ack、memset。
*/
static void Release_Observation(IEC104_SoftwareUpgrade_t *self)
{
if (self->session.receipt.ticket != 0U) {
IEC104_Slave_Release_Ack(self->slave, &self->session.receipt);
}
memset(&self->session.receipt, 0, sizeof(self->session.receipt));
self->session.ack_submitted = false;
}
/**
* 功能:CANCEL 被接受或 Take_Restart 成功已构成会话结局,不再额外交付 ABANDON。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:内部调用:Release_Observation、Release_Station、memset。
*/
static void Finish_Session(IEC104_SoftwareUpgrade_t *self)
{
Release_Observation(self);
Release_Station(self, &self->session.station);
memset(&self->session, 0, sizeof(self->session));
}
/**
* 功能:动作决定固定为回复;
* 输入参数:self——本模块实例。
* task——业务任务。
* negative——否定确认标志。
* 输出参数:task——业务任务的更新结果。
* 返回值:无。
* 说明:不立即删除任务,以保持确认和后续请求的 FIFO 次序。
*/
static void Reply(IEC104_SoftwareUpgrade_t *self, UpgradeTask *task, bool negative)
{
task->phase = UPGRADE_REPLY;
task->cause = task->request.operation == IEC104_SOFTWARE_UPGRADE_OP_CANCEL ? 9U : 7U;
task->negative = negative;
task->send_waiting = false;
Arm_Head_Reply(self);
}
/**
* 功能:原 START 字段和引用转入收尾槽;session 虽已 NONE,应用资源尚未完成清理。
* 输入参数:self——本模块实例。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:仍未提交的 START 肯定改为否定,回复计时起点不变;已交出的确认无法撤回。
*/
static void Abandon(IEC104_SoftwareUpgrade_t *self, IEC104_SoftwareUpgradeAbandonReason_t reason)
{
unsigned i;
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_NONE) { return; }
for (i = 0U; i < self->count; ++i) {
UpgradeTask *task = &self->tasks[self->order[i]];
if (task->phase == UPGRADE_REPLY && !task->negative &&
task->start_session_serial != 0U &&
task->start_session_serial == self->session.start.session_serial) {
task->negative = true;
}
}
Release_Observation(self);
self->abandon.request = self->session.start;
self->abandon.request.operation = IEC104_SOFTWARE_UPGRADE_OP_ABANDON;
self->abandon.request.reason = reason;
self->abandon.station = self->session.station;
self->abandon.pending = true;
memset(&self->session, 0, sizeof(self->session));
}
/**
* 功能:两种策略共用同一回执,只切换观察边界;
* 输入参数:self——本模块实例。
* acked——uint64_t *所指数据。
* 输出参数:无。
* 返回值:按处理分支返回UP_ACK(self->slave, &self->session.receipt, acked)、UP_ACTIVE_ACK(self->slave, &self->session.receipt, acked)。
* 说明:有效累计 N(R) 才构成这里的 ACK。
*/
static IEC104_SlaveAckState_t Query_Ack(const IEC104_SoftwareUpgrade_t *self, uint64_t *acked)
{
if (self->config.restart_policy == IEC104_SOFTWARE_UPGRADE_RESTART_ACKED) {
return UP_ACK(self->slave, &self->session.receipt, acked);
}
return UP_ACTIVE_ACK(self->slave, &self->session.receipt, acked);
}
/**
* 功能:已提交时先取 ACK 事实,再用首次 ACK 时刻判期限,避免晚调度误杀按时确认。
* 输入参数:self——本模块实例。
* now——当前时刻。
* reply_on_timeout——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值: reply_on_timeout=false 用于已清 FIFO 的生命周期路径,不能再访问/生成原回复。
* 说明:提交前超时可将队首改为普通否定;提交后仅收尾,不发相反确认。
* reply_on_timeout=false 用于已清 FIFO 的生命周期路径,不能再访问/生成原回复。
*/
static bool Advance_Ack(IEC104_SoftwareUpgrade_t *self, uint64_t now, bool reply_on_timeout)
{
uint32_t limit = self->config.restart_ack_timeout_ms;
if (self->session.state != IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK) { return true; }
if (self->session.ack_submitted) {
uint64_t acked = 0U;
IEC104_SlaveAckState_t state = Query_Ack(self, &acked);
if (state == IEC104_SLAVE_ACK_ERROR) {
/* 查询故障不等于主站未确认,单独计错并粘滞停用。 */
++self->status.ack_errors;
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_CANCELLED);
self->status.faulted = true;
return false;
}
if (state == IEC104_SLAVE_ACK_LOST) {
++self->status.acks_lost;
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_ACK_LOST);
return true;
}
if (state == IEC104_SLAVE_ACK_ACKED) {
if (limit != 0U && Remaining(limit, self->session.ack_started_ms, acked) == 0U) {
++self->status.ack_timeouts;
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_ACK_TIMEOUT);
} else {
/* 授权一经确定不再受业务期限约束,观察槽可让给其他业务模块。 */
self->session.state = IEC104_SOFTWARE_UPGRADE_SESSION_RESTART_READY;
Release_Observation(self);
}
return true;
}
}
if (limit != 0U && Remaining(limit, self->session.ack_started_ms, now) == 0U) {
if (!self->session.ack_submitted && reply_on_timeout) {
UpgradeTask *task = Head(self);
if (task == NULL || !task->ack_confirm) {
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_CANCELLED);
self->status.faulted = true;
return false;
}
task->ack_confirm = false;
Reply(self, task, true);
}
++self->status.ack_timeouts;
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_ACK_TIMEOUT);
}
return true;
}
/**
* 功能:STOP/STALE 可以保留已提交的 ACKED 观察;其他连接边界先冻结可证明的 ACK 再收尾。
* 输入参数:self——本模块实例。
* keep_observing——bool值。
* explicit_cancel——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回true、valid。
* 说明:普通生命周期保留 READY;显式 Cancel 表示应用放弃,连未领取 READY 也转 ABANDON,
* 且不再查询 ACK 来制造调用者刚决定丢弃的授权。
*/
static bool Cancel_Work(IEC104_SoftwareUpgrade_t *self, bool keep_observing, bool explicit_cancel)
{
bool valid = true;
Clear_Tasks(self);
End_Test(self);
if (explicit_cancel) {
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_CANCELLED);
return true;
}
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK) {
if (self->session.ack_submitted) {
valid = Advance_Ack(self, UP_NOW(), false);
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK &&
!(keep_observing && self->config.restart_policy == IEC104_SOFTWARE_UPGRADE_RESTART_ACKED)) {
++self->status.acks_lost;
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_ACK_LOST);
}
} else {
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_CANCELLED);
}
} else if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN) {
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_CANCELLED);
}
return valid;
}
/**
* 功能:只关闭保存的原身份;
* 输入参数:self——本模块实例。
* identity——原会话身份。
* 输出参数:self——本模块实例的更新结果。
* 返回值:result == IEC104_TCP_OK || result == IEC104_TCP_NOT_CONNECTED || result == IEC104_TCP_STALE_GENERATION时返回true;其余分支返回true、false。
* 说明:已断开或代次已过均算本地收尾完成,不能误关新连接。
*/
static bool Close_Original(IEC104_SoftwareUpgrade_t *self, const IEC104_SlaveEventIdentity_t *identity)
{
IEC104_TcpResult_t result = UP_CLOSE(self->slave, identity, NULL);
if (result == IEC104_TCP_OK || result == IEC104_TCP_NOT_CONNECTED ||
result == IEC104_TCP_STALE_GENERATION) { return true; }
++self->status.close_errors;
self->status.faulted = true;
return false;
}
/**
* 功能:先收尾未授权工作并保留可验证的 READY;
* 输入参数:self——本模块实例。
* identity——原会话身份。
* close——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:FATAL 结果不确定,只尝试关闭一次,不重发。
*/
static void Fault(IEC104_SoftwareUpgrade_t *self, const IEC104_SlaveEventIdentity_t *identity, bool close)
{
(void)Cancel_Work(self, false, false);
self->status.faulted = true;
self->status.active = false;
if (close && !self->fatal_close_attempted) {
self->fatal_close_attempted = true;
(void)Close_Original(self, identity);
}
}
/**
* 功能:未读通知优先于业务;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:返回state的结果。
* 说明:STALE 清普通工作,但允许 ACKED 在 STOP 后继续观察。
*/
static IEC104_SlaveRequestState_t Check_Transport(IEC104_SoftwareUpgrade_t *self)
{
IEC104_SlaveRequestState_t state = UP_CHECK(self->slave, &self->transport);
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
if (state == IEC104_SLAVE_REQUEST_ERROR) {
Fault(self, &self->transport, false);
} else if (state != IEC104_SLAVE_REQUEST_WAIT_EVENTS &&
(state != IEC104_SLAVE_REQUEST_READY || !self->status.active)) {
bool valid = Cancel_Work(self, true, false);
self->status.active = false;
state = valid ? IEC104_SLAVE_REQUEST_STALE : IEC104_SLAVE_REQUEST_ERROR;
}
return state;
}
/**
* 功能:仅精确识别“传输刚 STOP、相应通知还未分派”的 ERROR;
* 输入参数:self——本模块实例。
* identity——原会话身份。
* submitted——IEC104_TcpSubmitResult_t值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:仅原会话仍健康、传输已停止且存在待消费通知时返回true;其他情况返回false。
* 说明:任何谓词缺失或 FATAL 都是真故障。
*/
static bool Defer_For_Stop(IEC104_SoftwareUpgrade_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 ||
!Same_Identity(identity, &self->transport) ||
UP_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;
}
/**
* 功能:会话期限只覆盖 OPEN;
* 输入参数:self——本模块实例。
* now——当前时刻。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:END 接受后改由独立 ACK 期限负责,TEST 不受此期限限制。
*/
static void Expire_Session(IEC104_SoftwareUpgrade_t *self, uint64_t now)
{
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN && self->config.session_timeout_ms != 0U &&
Remaining(self->config.session_timeout_ms, self->session.start.session_started_ms, now) == 0U) {
++self->status.session_timeouts;
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_SESSION_TIMEOUT);
}
}
/**
* 功能:普通回复不能无限占队首:超时清队列、按原身份关闭;
* 输入参数:self——本模块实例。
* now——当前时刻。
* 输出参数:self——本模块实例的更新结果。
* 返回值:普通回复本次达到期限并执行取消/关闭处理返回true;没有适用超时返回false。
* 说明:此前已确定的 READY 保留。
*/
static bool Expire_Reply(IEC104_SoftwareUpgrade_t *self, uint64_t now)
{
UpgradeTask *task = Head(self);
if (task != NULL && task->phase == UPGRADE_REPLY && !task->ack_confirm && task->reply_started &&
self->config.reply_timeout_ms != 0U &&
Remaining(self->config.reply_timeout_ms, task->reply_started_ms, now) == 0U) {
IEC104_SlaveEventIdentity_t identity = task->request.identity;
++self->status.reply_timeouts;
(void)Cancel_Work(self, false, false);
self->status.active = false;
(void)Close_Original(self, &identity);
return true;
}
return false;
}
/**
* 功能:返回 1 已提交、0 等待或无回复、-1 故障。清队列/移除队首后须重取指针,不能继续借用旧槽。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:返回 1 已提交、0 等待或无回复、-1 故障。
* 说明:本函数不执行动作;所有 WAIT 重试使用固定原文,只在提交前应用确认字段变换。
*/
static int Submit_Head(IEC104_SoftwareUpgrade_t *self)
{
UpgradeTask *task = Head(self);
IEC60870_Asdu_t asdu;
IEC104_TcpSubmitResult_t result;
IEC104_SlaveRequestState_t state;
uint8_t bytes[10];
if (task == NULL || task->phase != UPGRADE_REPLY || self->status.faulted) { return 0; }
state = Check_Transport(self);
if (state != IEC104_SLAVE_REQUEST_READY) { return state == IEC104_SLAVE_REQUEST_ERROR ? -1 : 0; }
if (!Advance_Ack(self, UP_NOW(), true)) {
Fault(self, &self->transport, false);
return -1;
}
Arm_Head_Reply(self);
if (Expire_Reply(self, UP_NOW())) { return self->status.faulted ? -1 : 0; }
task = Head(self);
if (task == NULL) { return 0; }
memcpy(bytes, task->bytes, task->length);
/* 保留 T/OA/CA/VSQ/IOA/CTYPE 原值;S/E 兼容只作用于可完整读取的 END 的 COT7 确认。 */
bytes[2] = (uint8_t)((bytes[2] & 0x80U) | task->cause | (task->negative ? 0x40U : 0U));
if (self->config.end_confirm_se_one && task->length >= 10U &&
(task->bytes[2] & 0x3fU) == 6U && !(task->bytes[9] & IEC104_SOFTWARE_UPGRADE_CTYPE_SE) &&
task->cause == 7U) { bytes[9] |= IEC104_SOFTWARE_UPGRADE_CTYPE_SE; }
if (IEC60870_Asdu_Create_From_Buffer(&asdu,
IEC104_Slave_Get_Application_Layer_Parameters(self->slave), bytes, task->length) != IEC60870_ASDU_OK) {
Fault(self, &task->request.identity, false);
return -1;
}
result = task->ack_confirm ? UP_SEND_ACK(self->slave, &task->request.identity, &asdu, &self->session.receipt) :
UP_SEND(self->slave, &task->request.identity, &asdu);
if (result == IEC104_TCP_SUBMIT_OK) {
++self->status.submitted;
if (task->negative) { ++self->status.negative_submitted; }
/* END 交出后从 FIFO 移除,后续 CANCEL 才能执行;ACK 观察由 session 继续持有。 */
if (task->ack_confirm) { self->session.ack_submitted = true; }
Remove_Head(self);
return 1;
}
if (result == IEC104_TCP_SUBMIT_WAIT) {
++self->status.waits;
task->send_waiting = true;
return 0;
}
if (Defer_For_Stop(self, &task->request.identity, result)) { return 0; }
{
IEC104_SlaveEventIdentity_t identity = task->request.identity;
++self->status.send_errors;
Fault(self, &identity, result == IEC104_TCP_SUBMIT_FATAL);
}
return -1;
}
/**
* 功能:空闲槽追加到 FIFO 尾部;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回NULL、task。
* 说明:合法请求与错误确认使用同一容量,满时丢新。
*/
static UpgradeTask *Allocate_Task(IEC104_SoftwareUpgrade_t *self)
{
unsigned i;
if (self->count == IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY) { return NULL; }
for (i = 0U; i < IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY; ++i) {
if (!self->tasks[i].occupied) {
UpgradeTask *task = &self->tasks[i];
memset(task, 0, sizeof(*task));
task->occupied = true;
self->order[self->count++] = i;
return task;
}
}
return NULL;
}
/**
* 功能:这里只校验报文并入槽;
* 输入参数:self——本模块实例。
* event——事件。
* identity——原会话身份。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回IEC104_SOFTWARE_UPGRADE_EVENT_IGNORED、IEC104_SOFTWARE_UPGRADE_EVENT_ERROR、IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED。
* 说明:会话规则依赖前序动作结果,必须留到 Execute_Next 按 FIFO 决定。
*/
static IEC104_SoftwareUpgradeEventResult_t Request(IEC104_SoftwareUpgrade_t *self,
const IEC104_SlaveEvent_t *event, const IEC104_SlaveEventIdentity_t *identity)
{
const uint8_t *data;
uint16_t length;
IEC60870_AsduInfo_t info;
IEC104_Station_t *station;
UpgradeTask *task;
uint32_t ioa = 0U;
uint8_t cause = 0U;
if (event->asdu_result != IEC60870_ASDU_OK) { return IEC104_SOFTWARE_UPGRADE_EVENT_IGNORED; }
if (IEC60870_Asdu_Get_Data(&event->asdu, &data, &length) != IEC60870_ASDU_OK || length < 6U ||
!IEC60870_Parse_ASDU_Header(IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
data, length, &info)) { return IEC104_SOFTWARE_UPGRADE_EVENT_ERROR; }
if (info.type_id != IEC104_SOFTWARE_UPGRADE_TYPE_ID) { return IEC104_SOFTWARE_UPGRADE_EVENT_IGNORED; }
/* 故障检查先于 active:停用的本类型仍由模块消费,不能误落应用的未知类型回 44。 */
if (self->status.faulted) {
++self->status.faulted_dropped;
return IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED;
}
if (!self->status.active) { return IEC104_SOFTWARE_UPGRADE_EVENT_IGNORED; }
station = IEC104_Slave_Get_Station(self->slave, info.common_address);
if (length >= 9U) { ioa = (uint32_t)data[6] | ((uint32_t)data[7] << 8) | ((uint32_t)data[8] << 16); }
/* 校验优先级为 COT、CA、可选 IOA、格式;先检查可读长度,再取 IOA/CTYPE。 */
if (info.cause_of_transmission != 6U && info.cause_of_transmission != 8U) { cause = 45U; }
else if (info.common_address == 65535U || station == NULL) { cause = 46U; }
else if (self->config.check_ioa && length >= 9U && ioa != 0U) { cause = 47U; }
else if (length != 10U || (data[1] != 0U && !(self->config.accept_vsq_one && data[1] == 1U)) ||
info.is_negative_confirm || (info.cause_of_transmission == 8U && length >= 10U &&
(data[9] & IEC104_SOFTWARE_UPGRADE_CTYPE_SE))) {
cause = info.cause_of_transmission == 8U ? 9U : 7U;
}
if (cause != 0U) { ++self->status.rejected; }
if (self->count == IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY) {
++self->status.dropped_requests;
return IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED;
}
if (cause == 0U && IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) {
return IEC104_SOFTWARE_UPGRADE_EVENT_ERROR;
}
task = Allocate_Task(self);
if (task == NULL) {
if (cause == 0U) { (void)IEC104_Slave_Release_Station(self->slave, station); }
return IEC104_SOFTWARE_UPGRADE_EVENT_ERROR;
}
task->request.identity = *identity;
task->request.receive_serial = event->transport.data.i_frame.receive_serial;
task->request.common_address = info.common_address;
task->request.originator_address = info.originator_address;
task->request.ioa = ioa;
task->request.ctype = length >= 10U ? data[9] : 0U;
task->request.accepted_ms = UP_NOW();
task->request.operation = info.cause_of_transmission == 8U ? IEC104_SOFTWARE_UPGRADE_OP_CANCEL :
((task->request.ctype & IEC104_SOFTWARE_UPGRADE_CTYPE_SE) ? IEC104_SOFTWARE_UPGRADE_OP_START :
IEC104_SOFTWARE_UPGRADE_OP_END);
task->length = (uint8_t)(length < 10U ? length : 10U);
/* 截短按原长度镜像,超长最多保留十字节;不借用事件缓冲区跨次调用。 */
memcpy(task->bytes, data, task->length);
task->test = info.is_test != 0U;
if (cause == 0U) {
task->station = station;
task->request.station_id = IEC104_Station_Get_Id(station);
task->phase = UPGRADE_EXECUTE;
++self->status.accepted;
} else {
task->phase = UPGRADE_REPLY;
task->cause = cause;
task->negative = true;
Arm_Head_Reply(self);
/* 错误确认也不能越过前序请求,仅自己是队首时可当场尝试提交。 */
if (self->count == 1U && Submit_Head(self) < 0) { return IEC104_SOFTWARE_UPGRADE_EVENT_ERROR; }
}
return IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED;
}
/**
* 功能:默认采用ACKED重启策略,执行/回复期限15秒、重启ACK期限30秒;
* 输入参数:config——配置。
* 输出参数:config——配置的更新结果。
* 返回值:无。
* 说明:NULL不操作。
*/
void IEC104_SoftwareUpgrade_Config_Default(IEC104_SoftwareUpgradeConfig_t *config)
{
if (config != NULL) {
memset(config, 0, sizeof(*config));
config->restart_policy = IEC104_SOFTWARE_UPGRADE_RESTART_ACKED;
config->execute_timeout_ms = 15000U;
config->reply_timeout_ms = 15000U;
config->restart_ack_timeout_ms = 30000U;
}
}
/**
* 功能:校验配置后从静态池绑定Slave并复制配置,每个Slave最多一个实例。
* 输入参数:slave——所属从站服务。
* config——配置。
* 输出参数:无。
* 返回值: 参数非法、池满或实例编号耗尽返回NULL;
* 说明:参数非法、池满或实例编号耗尽返回NULL;不创建传输会话或调用升级动作。
*/
IEC104_SoftwareUpgrade_t *IEC104_SoftwareUpgrade_Create(IEC104_Slave_t *slave,
const IEC104_SoftwareUpgradeConfig_t *config)
{
IEC104_SoftwareUpgrade_t *available = NULL;
unsigned i;
if (config == NULL || (config->restart_policy != IEC104_SOFTWARE_UPGRADE_RESTART_ACKED &&
config->restart_policy != IEC104_SOFTWARE_UPGRADE_RESTART_ACTIVE_ACKED) ||
IEC104_Slave_Get_Application_Layer_Parameters(slave) == NULL ||
software_upgrade_last_instance == UINT64_MAX) { return NULL; }
for (i = 0U; i < IEC104_SOFTWARE_UPGRADE_CAPACITY; ++i) {
if (software_upgrade_pool[i].in_use && software_upgrade_pool[i].slave == slave) { return NULL; }
if (!software_upgrade_pool[i].in_use && available == NULL) { available = &software_upgrade_pool[i]; }
}
if (available == NULL) { return NULL; }
memset(available, 0, sizeof(*available));
available->slave = slave;
available->config = *config;
available->instance_id = ++software_upgrade_last_instance;
available->in_use = true;
return available;
}
/**
* 功能:任务、TEST、真实会话、ACK回执及ABANDON责任全空才释放静态槽。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:回调内或仍有未完成责任时返回false。
* 说明:不隐式取消工作;回调内或仍有未完成责任时返回false。
*/
bool IEC104_SoftwareUpgrade_Destroy(IEC104_SoftwareUpgrade_t *self)
{
if (!Owned(self) || self->in_action || self->count != 0U || self->test.active || self->abandon.pending ||
self->session.state != IEC104_SOFTWARE_UPGRADE_SESSION_NONE || self->session.receipt.ticket != 0U) { return false; }
memset(self, 0, sizeof(*self));
return true;
}
/**
* 功能:应用显式放弃本实例工作,连未领取重启授权也转入ABANDON;清理回调留给Execute_Next。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:无效句柄或动作回调内调用忽略,不撤回发送层已接手的确认。
*/
void IEC104_SoftwareUpgrade_Cancel(IEC104_SoftwareUpgrade_t *self)
{
if (Owned(self) && !self->in_action) { (void)Cancel_Work(self, false, true); }
}
/**
* 功能:按通知FIFO更新连接/启停状态,或接收Type211请求;旧代次通知忽略,身份或重入错误返回ERROR。
* 输入参数:self——本模块实例。
* event——事件。
* 输出参数:self——本模块实例的更新结果。
* 返回值:旧代次通知忽略,身份或重入错误返回ERROR。
* 说明:CONNECTED先收尾旧会话,STOP按策略保留ACK观察;本入口不调用应用升级动作。
*/
IEC104_SoftwareUpgradeEventResult_t IEC104_SoftwareUpgrade_Handle_Event(IEC104_SoftwareUpgrade_t *self,
const IEC104_SlaveEvent_t *event)
{
IEC104_SlaveEventIdentity_t identity;
bool valid;
if (!Owned(self) || self->in_action || !IEC104_Slave_Get_Event_Identity(self->slave, event, &identity) ||
(self->transport.instance_id != 0U && self->transport.instance_id != identity.instance_id)) {
return IEC104_SOFTWARE_UPGRADE_EVENT_ERROR;
}
self->transport.slave = identity.slave;
self->transport.instance_id = identity.instance_id;
if (event->transport.type == IEC104_TCP_EVENT_CONNECTED) {
/* 先按旧会话观察记录收尾,再采用新连接代次;已确定授权保留原 END 身份。 */
valid = Cancel_Work(self, false, false);
self->transport.generation = identity.generation;
self->status.active = false;
return valid ? IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED : IEC104_SOFTWARE_UPGRADE_EVENT_ERROR;
}
if (identity.generation != self->transport.generation) { return IEC104_SOFTWARE_UPGRADE_EVENT_IGNORED; }
switch (event->transport.type) {
case IEC104_TCP_EVENT_ACTIVATED:
self->status.active = !self->status.faulted;
return IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED;
case IEC104_TCP_EVENT_DEACTIVATED:
case IEC104_TCP_EVENT_DISCONNECTED:
/* 只有 STOP 能给 ACKED 策略继续观察的机会,断线必须立即作出收尾结论。 */
valid = Cancel_Work(self, event->transport.type == IEC104_TCP_EVENT_DEACTIVATED, false);
self->status.active = false;
if (event->transport.type == IEC104_TCP_EVENT_DISCONNECTED) { self->transport.generation = 0U; }
return valid ? IEC104_SOFTWARE_UPGRADE_EVENT_HANDLED : IEC104_SOFTWARE_UPGRADE_EVENT_ERROR;
case IEC104_TCP_EVENT_I_FRAME: return Request(self, event, &identity);
default: return IEC104_SOFTWARE_UPGRADE_EVENT_IGNORED;
}
}
/**
* 功能:推进ACK观察、会话期限及有界队首回复,通知未读或发送WAIT时让出循环。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:false表示实例/查询/发送故障,true不承诺已有工作完成。
* 说明:不调用升级动作;false表示实例/查询/发送故障,true不承诺已有工作完成。
*/
bool IEC104_SoftwareUpgrade_Process(IEC104_SoftwareUpgrade_t *self)
{
IEC104_SlaveRequestState_t state;
unsigned i;
if (!Owned(self) || self->in_action || self->status.faulted) { return false; }
state = Check_Transport(self);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) {
/* Slave_Close 可能已归还回执,但生命周期通知尚在队列。
* 此处只提前识别查询错误,不抢在通知 FIFO 前裁决正常 ACK/CANCEL 竞争。 */
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK && self->session.ack_submitted &&
Query_Ack(self, NULL) == IEC104_SLAVE_ACK_ERROR) {
++self->status.ack_errors;
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_CANCELLED);
Fault(self, &self->transport, false);
return false;
}
return true;
}
if (!Advance_Ack(self, UP_NOW(), true)) { Fault(self, &self->transport, false); return false; }
if (state != IEC104_SLAVE_REQUEST_READY) { return !self->status.faulted; }
Expire_Session(self, UP_NOW());
/* 单轮最多推进固定槽数;一遇待动作或发送 WAIT 就让出事件循环。 */
for (i = 0U; i < IEC104_SOFTWARE_UPGRADE_TASK_CAPACITY; ++i) {
UpgradeTask *task = Head(self);
int result;
if (task == NULL || task->phase != UPGRADE_REPLY) { break; }
result = Submit_Head(self);
if (result < 0) { return false; }
if (result == 0) { break; }
}
return !self->status.faulted;
}
/**
* 功能:清理通知不依赖原连接仍有效;
* 输入参数:self——本模块实例。
* action——动作回调。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:回调期间保留引用,返回后才归还站点并释放收尾槽。
*/
static void Deliver_Abandon(IEC104_SoftwareUpgrade_t *self, IEC104_SoftwareUpgradeAction_t action, void *context)
{
self->in_action = true;
(void)action(context, &self->abandon.request);
self->in_action = false;
Release_Station(self, &self->abandon.station);
memset(&self->abandon, 0, sizeof(self->abandon));
++self->status.abandons;
}
/**
* 功能:模拟会话按完整身份及站点注册编号隔离,不调用动作、不产生 ACK 或重启授权。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:内部调用:Same_Identity、Reply、End_Test。
*/
static void Execute_Test(IEC104_SoftwareUpgrade_t *self, UpgradeTask *task)
{
bool accepted = false;
bool same_ca = self->test.active && task->request.common_address == self->test.common_address;
bool same_owner = same_ca && task->request.station_id == self->test.station_id &&
Same_Identity(&task->request.identity, &self->test.identity);
if (same_ca && !same_owner) { Reply(self, task, true); return; }
switch (task->request.operation) {
case IEC104_SOFTWARE_UPGRADE_OP_START:
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_NONE && (!self->test.active || same_owner)) {
End_Test(self);
self->test.active = true;
self->test.identity = task->request.identity;
self->test.station_id = task->request.station_id;
self->test.common_address = task->request.common_address;
/* TEST START 接管引用;END/CANCEL 的任务引用与会话引用仍须分别归还。 */
self->test.station = task->station;
task->station = NULL;
accepted = true;
}
break;
case IEC104_SOFTWARE_UPGRADE_OP_END:
if (same_owner) { End_Test(self); accepted = true; }
break;
case IEC104_SOFTWARE_UPGRADE_OP_CANCEL:
if (same_owner) { End_Test(self); }
accepted = true;
break;
default: break;
}
Reply(self, task, !accepted);
}
/**
* 功能:将任务转为否定回复,真实END同时计入拒绝数;
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:task——业务任务的更新结果。
* 返回值:无。
* 说明:不在这里提交回复或执行应用动作。
*/
static void Reject_Operation(IEC104_SoftwareUpgrade_t *self, UpgradeTask *task)
{
if (!task->test && task->request.operation == IEC104_SOFTWARE_UPGRADE_OP_END) { ++self->status.ends_rejected; }
Reply(self, task, true);
}
/**
* 功能:每次至多交付一次同步动作,欠应用的ABANDON优先于正常队首并可在故障/断线后执行。
* 输入参数:self——本模块实例。
* action——动作回调。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 通知阻塞有待执行队首时返回WAIT,无工作返回EMPTY;
* 动作完成后返回OK,即使随后的确认提交失败也不能据此重做动作;
* 说明:通知阻塞有待执行队首时返回WAIT,无工作返回EMPTY;TEST及预检拒绝不调用动作。
* 动作完成后返回OK,即使随后的确认提交失败也不能据此重做动作;重启须另取授权。
*/
IEC104_SoftwareUpgradeExecuteResult_t IEC104_SoftwareUpgrade_Execute_Next(IEC104_SoftwareUpgrade_t *self,
IEC104_SoftwareUpgradeAction_t action, void *context)
{
UpgradeTask *task;
IEC104_SlaveRequestState_t state;
IEC104_SoftwareUpgradeDecision_t decision;
IEC104_SoftwareUpgradeRequest_t request;
uint64_t before_action;
bool same_ca, same_owner;
if (!Owned(self) || self->in_action || action == NULL) { return IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR; }
/* 即使已断线或 faulted,欠应用的收尾也必须先交付,不能被通知等待阻塞。 */
if (self->abandon.pending) {
Deliver_Abandon(self, action, context);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
if (self->status.faulted) { return IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY; }
state = Check_Transport(self);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) {
/* WAIT 表示确有待执行队首因通知次序暂留;空队列/仅待回复时返回 EMPTY。
* 退出时可先 Cancel 再 Close,不因尚未读空通知而伪造一项待执行工作。 */
task = Head(self);
return task != NULL && task->phase == UPGRADE_EXECUTE ?
IEC104_SOFTWARE_UPGRADE_EXECUTE_WAIT : IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY;
}
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY; }
/* 先冻结已经到达的 ACK,再考虑队首 CANCEL;省略外部 Process 也保持同一竞争规则。 */
if (!Advance_Ack(self, UP_NOW(), true)) {
Fault(self, &self->transport, false);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_ERROR;
}
Expire_Session(self, UP_NOW());
if (self->abandon.pending) {
Deliver_Abandon(self, action, context);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
task = Head(self);
if (task == NULL || task->phase != UPGRADE_EXECUTE) { return IEC104_SOFTWARE_UPGRADE_EXECUTE_EMPTY; }
if (self->config.execute_timeout_ms != 0U &&
Remaining(self->config.execute_timeout_ms, task->request.accepted_ms, UP_NOW()) == 0U) {
++self->status.timeouts;
Reject_Operation(self, task);
(void)Submit_Head(self);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
if (task->test) {
Execute_Test(self, task);
(void)Submit_Head(self);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
/* 只有合法、未过期且确实到队首的真实请求才抢占 TEST,收包和错误回复不改变模拟会话。 */
End_Test(self);
same_ca = self->session.state != IEC104_SOFTWARE_UPGRADE_SESSION_NONE &&
task->request.common_address == self->session.start.common_address;
same_owner = same_ca && task->request.station_id == self->session.start.station_id &&
Same_Identity(&task->request.identity, &self->session.start.identity);
if (same_ca && !same_owner) {
/* 同 CA 注销后重注册不是原站点,不能结束、撤销或取代旧会话。 */
Reject_Operation(self, task);
(void)Submit_Head(self);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
if (task->request.operation == IEC104_SOFTWARE_UPGRADE_OP_CANCEL && !same_ca) {
/* 本 CA 本来没有会话,撤销幂等成立;不调用动作,也不影响其他 CA 的会话。 */
++self->status.cancels;
Reply(self, task, false);
(void)Submit_Head(self);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
if (task->request.operation == IEC104_SOFTWARE_UPGRADE_OP_START) {
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN && same_owner) {
/* 本轮只交付旧会话 ABANDON,保留新 START 到下轮,保证至多一次应用回调。 */
Abandon(self, IEC104_SOFTWARE_UPGRADE_ABANDON_SUPERSEDED);
Deliver_Abandon(self, action, context);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
if (self->session.state != IEC104_SOFTWARE_UPGRADE_SESSION_NONE || self->last_session_serial == UINT64_MAX) {
Reject_Operation(self, task);
(void)Submit_Head(self);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
} else if (!same_owner || (task->request.operation == IEC104_SOFTWARE_UPGRADE_OP_END &&
self->session.state != IEC104_SOFTWARE_UPGRADE_SESSION_OPEN) ||
(task->request.operation == IEC104_SOFTWARE_UPGRADE_OP_CANCEL &&
self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_RESTART_READY)) {
Reject_Operation(self, task);
(void)Submit_Head(self);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
request = task->request;
request.session_serial = request.operation == IEC104_SOFTWARE_UPGRADE_OP_START ? self->last_session_serial + 1U :
self->session.start.session_serial;
request.session_started_ms = request.operation == IEC104_SOFTWARE_UPGRADE_OP_START ? 0U :
self->session.start.session_started_ms;
before_action = UP_NOW();
self->in_action = true;
decision = action(context, &request);
self->in_action = false;
if (decision != IEC104_SOFTWARE_UPGRADE_DECISION_ACCEPT) {
Reject_Operation(self, task);
} else if (request.operation == IEC104_SOFTWARE_UPGRADE_OP_START) {
/* 只有接受才消耗序号、开始会话期限,并将任务的站点引用转给真实会话。 */
self->last_session_serial = request.session_serial;
request.session_started_ms = UP_NOW();
self->session.start = request;
self->session.state = IEC104_SOFTWARE_UPGRADE_SESSION_OPEN;
self->session.station = task->station;
task->station = NULL;
task->start_session_serial = request.session_serial;
++self->status.starts;
Reply(self, task, false);
} else if (request.operation == IEC104_SOFTWARE_UPGRADE_OP_END) {
/* END 肯定留在队首等提交;ACK 期限含回调耗时,不叠加普通回复期限。 */
self->session.end = request;
self->session.ack_started_ms = before_action;
self->session.state = IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK;
task->ack_confirm = true;
++self->status.ends_accepted;
Reply(self, task, false);
} else {
Finish_Session(self);
++self->status.cancels;
Reply(self, task, false);
}
/* 动作已完成,提交失败也不能改成“未执行”;故障由状态及后续 Process 报告。 */
(void)Submit_Head(self);
return IEC104_SOFTWARE_UPGRADE_EXECUTE_OK;
}
/**
* 功能:一次性领取已确定的原END重启授权并释放会话;成功才写request。
* 输入参数:self——本模块实例。
* request——请求。
* 输出参数:self——本模块实例的更新结果。
* request——请求的更新结果。
* 返回值:存在满足确认条件且可领取的重启授权时返回true并交付;身份、状态、通知或观察条件不满足时返回false。
* 说明:通知未读或查询错误保留授权,原连接STALE不推翻已确定授权;本函数不执行重启。
*/
bool IEC104_SoftwareUpgrade_Take_Restart(IEC104_SoftwareUpgrade_t *self,
IEC104_SoftwareUpgradeRequest_t *request)
{
IEC104_SlaveRequestState_t state;
if (!Owned(self) || self->in_action || request == NULL ||
self->session.state != IEC104_SOFTWARE_UPGRADE_SESSION_RESTART_READY) { return false; }
state = UP_CHECK(self->slave, &self->session.end.identity);
/* STALE 只说明原请求当前不可执行,不推翻历史授权;未读通知/查询错误则保留授权及输出。 */
if (state != IEC104_SLAVE_REQUEST_READY && state != IEC104_SLAVE_REQUEST_STALE) { return false; }
*request = self->session.end;
Finish_Session(self);
++self->status.restarts_released;
return true;
}
/**
* 功能:合并最早期限;
* 输入参数:status——状态快照。
* remaining——剩余量。
* 输出参数:status——状态快照的更新结果。
* 返回值:无。
* 说明:0 也参与比较,表示已到期而不是“未启用”。
*/
static void Add_Timer(IEC104_SoftwareUpgradeStatus_t *status, uint32_t remaining)
{
if (!status->timer_active || remaining < status->timeout_remaining_ms) { status->timeout_remaining_ms = remaining; }
status->timer_active = true;
}
/**
* 功能:只读合成会话、ACK、待执行工作及最近期限快照,全部查询成功才写status。
* 输入参数:self——本模块实例。
* status——状态快照。
* 输出参数:status——全部查询成功后写回快照,失败保持原值。
* 返回值:查询错误返回false且输出不变。
* 说明:不推进ACK裁决或调用清理,回调内压住推进提示;查询错误返回false且输出不变。
*/
bool IEC104_SoftwareUpgrade_Get_Status(const IEC104_SoftwareUpgrade_t *self,
IEC104_SoftwareUpgradeStatus_t *status)
{
IEC104_SoftwareUpgradeStatus_t result;
IEC104_SlaveRequestState_t state;
IEC104_SlaveAckState_t ack = IEC104_SLAVE_ACK_QUEUED;
const UpgradeTask *head;
uint64_t now;
unsigned i;
if (!Owned(self) || status == NULL) { return false; }
/* 先完成全部可能失败的只读查询,最后一次性写输出,不用旧快照掩盖查询故障。 */
state = UP_CHECK(self->slave, &self->transport);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK && self->session.ack_submitted) {
ack = Query_Ack(self, NULL);
if (ack == IEC104_SLAVE_ACK_ERROR) { return false; }
}
result = self->status;
result.generation = self->transport.generation;
result.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
result.session_state = self->session.state;
result.session_active = self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN ||
self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK;
result.session_test = self->test.active;
result.ack_pending = self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_WAIT_ACK;
result.restart_ready = self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_RESTART_READY;
result.abandon_pending = self->abandon.pending;
if (self->session.state != IEC104_SOFTWARE_UPGRADE_SESSION_NONE) {
result.session_identity = self->session.start.identity;
result.session_common_address = self->session.start.common_address;
result.session_station_id = self->session.start.station_id;
result.session_serial = self->session.start.session_serial;
} else {
memset(&result.session_identity, 0, sizeof(result.session_identity));
result.session_common_address = 0U;
result.session_station_id = 0U;
result.session_serial = 0U;
}
result.pending_requests = self->count;
result.execute_pending = self->abandon.pending;
result.execute_ready = self->abandon.pending && !self->in_action;
result.need_process = false;
result.timer_active = false;
result.timeout_remaining_ms = 0U;
/* 队尾动作只计 pending,不代表可越过队首的待发确认立即执行。 */
for (i = 0U; i < self->count; ++i) {
if (self->tasks[self->order[i]].phase == UPGRADE_EXECUTE) { result.execute_pending = true; }
}
head = self->count != 0U ? &self->tasks[self->order[0]] : NULL;
if (!self->status.faulted && !self->in_action) {
now = UP_NOW();
if (!result.events_pending) {
bool ready = state == IEC104_SLAVE_REQUEST_READY && self->status.active;
if (head != NULL) {
result.execute_ready = result.execute_ready || (ready && head->phase == UPGRADE_EXECUTE);
result.need_process = ready && head->phase == UPGRADE_REPLY && !head->send_waiting;
}
/* ACKED 策略的 STOP 后 WAIT_ACK 是允许保留的观察,不是需立即清理的旧任务。
* 同样,send_waiting 不置 need_process,避免等 HIGH/ACK 槽时零等待忙循环。 */
if (!ready && (self->count != 0U || self->test.active ||
self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN ||
(result.ack_pending && (!self->session.ack_submitted ||
self->config.restart_policy == IEC104_SOFTWARE_UPGRADE_RESTART_ACTIVE_ACKED)))) {
result.need_process = true;
}
if (result.ack_pending && (ack == IEC104_SLAVE_ACK_ACKED || ack == IEC104_SLAVE_ACK_LOST)) {
result.need_process = true;
}
}
if (head != NULL && head->phase == UPGRADE_EXECUTE && self->config.execute_timeout_ms != 0U) {
Add_Timer(&result, Remaining(self->config.execute_timeout_ms, head->request.accepted_ms, now));
}
if (head != NULL && head->phase == UPGRADE_REPLY && !head->ack_confirm && head->reply_started &&
self->config.reply_timeout_ms != 0U) {
Add_Timer(&result, Remaining(self->config.reply_timeout_ms, head->reply_started_ms, now));
}
if (self->session.state == IEC104_SOFTWARE_UPGRADE_SESSION_OPEN && self->config.session_timeout_ms != 0U) {
Add_Timer(&result, Remaining(self->config.session_timeout_ms, self->session.start.session_started_ms, now));
}
if (result.ack_pending && self->config.restart_ack_timeout_ms != 0U) {
Add_Timer(&result, Remaining(self->config.restart_ack_timeout_ms, self->session.ack_started_ms, now));
}
/* 期限到期也先让出未读通知;faulted 和回调中不启用普通业务调度及计时。 */
if (result.timer_active && result.timeout_remaining_ms == 0U && !result.events_pending) { result.need_process = true; }
}
*status = result;
return true;
}