1304 lines
62 KiB
C
1304 lines
62 KiB
C
/*
|
||
* 国网扩展 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;
|
||
}
|