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

2316 lines
129 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.
/*
* 事件式召唤共用状态机。Slave负责通信,应用通过BEGIN/NEED_DATA/FINISHED交互。
* 请求任务仅保存原身份及10字节应答副本;业务事件为纯值,可以移动和复制。
* 单目标预留FINISHED槽,多目标使用每站终结记录,断线/STOP/取消/撤销/超时不丢清理通知。
* 确认、数据与终止沿原身份统一走HIGH FIFO,避免跨连接重放和本业务帧序颠倒。
*
* 正常阶段:START生成BEGIN并等待应用接受 -> CONFIRM提交激活确认 -> DATA反复索取并提交批次
* -> TERMINATE提交激活终止 -> 交付FINISHED。多目标按全部确认、逐站数据、全部终止推进。
* 只执行动作的种类在CONFIRM成功后直接FINISHED;种类差异仅由创建时的只读规则表决定。
* FINISHING保留多目标状态区至终结事件读完,不阻塞网络或其他短应答。
* REPLY表示当前站只需提交确认或错误应答;广播继续下一站,否则释放任务。
* Handle_Event更新会话和接收请求,条件允许时立即提交短应答;Process推进保存的任务。
* NextEvent把业务事件交给应用;一个实例至多一个未终结召唤,同种类忙时否定新激活。
* Reply_Begin/Complete_Data接收决定;Submit_Batch进入HIGH,接手后位置固定,WAIT后应用重新组包。
* 总召可重取当前值,计数量读取须保持本轮冻结快照;引擎不保存业务点值。
* 事件来源和会话可用性统一由Slave接口校验,本模块维护各实例自己的阶段和业务期限。
* 单帧应答与召唤任务分开选择,双方可推进时轮转;等待应用只阻塞同关联对象的后到ACT_CON。
* 请求解析后按CA选站,合法多目标广播持有节点集合;错误广播仍用共享快照遍历。
* 总召广播撤销针对整轮原目标;某站已拒绝并不意味着后续PENDING目标也已经结束。
* 撤销确认另存每站标志,与原否定ACT_CON、应用FINISHED分别收尾,三者不能相互替代。
*/
#include "IEC104_Interrogation_Internal.h"
#include "IEC104_BusinessConfig_Internal.h"
#include "IEC104_TcpServer_Config.h"
#include "IEC104_Net.h"
#include <string.h>
/* 库内三类存储均为静态有界容量:实例池、每实例协议任务池、每实例业务事件FIFO。
* 多目标广播另外借用调用方提供的轻量状态数组,不分配数据快照或每站发送队列。
* 单目标路径需同时容纳BEGIN及预留的FINISHED,因此业务事件容量至少为两个。 */
#ifndef IEC104_INTERROGATION_CAPACITY
#define IEC104_INTERROGATION_CAPACITY (2U * IEC104_TCP_SERVER_CAPACITY)
#endif
#ifndef IEC104_INTERROGATION_TASK_CAPACITY
#define IEC104_INTERROGATION_TASK_CAPACITY 4U
#endif
#ifndef IEC104_INTERROGATION_EVENT_CAPACITY
#define IEC104_INTERROGATION_EVENT_CAPACITY 4U
#endif
_Static_assert(IEC104_INTERROGATION_CAPACITY > 0U, "Interrogation needs instance storage");
_Static_assert(IEC104_INTERROGATION_TASK_CAPACITY > 0U, "Interrogation needs request storage");
_Static_assert(IEC104_INTERROGATION_EVENT_CAPACITY >= 2U, "BEGIN needs a reserved FINISHED slot");
/* 支持的104召唤命令固定为6字节公共头、3字节IOA和1字节限定词;入口完整校验后才保存。
* 独立保存原身份和必要原文,不借用SlaveEvent、ASDU视图或发送接口中的自引用。
* 不保存接收APCI;发送序号、确认号及链路期限由底层连接管理。 */
typedef struct {
IEC104_SlaveEventIdentity_t identity;
uint8_t bytes[IEC104_ASDU_HEADER_LEN + 3U + 1U];
uint8_t priority; /* 受理时固定整事务等级,利用原10字节原文后的对齐空隙。 */
} InterrogationResponse;
/* 任务使用固定槽及顺序索引;压缩存储不改变任务数量、调度顺序和背压策略。 */
typedef struct {
InterrogationResponse request; /* 原服务/代次和独立10字节请求,保存时已设置应答CA。 */
IEC104_InterrogationRequest_t info; /* 唯一业务元数据;供事件交付及批次校验,终结时仍描述原激活。 */
IEC104_Station_t *station; /* 当前站额外引用,独立于广播数组持有的引用和CA路由资格。 */
IEC104_StationSnapshot_t stations; /* 单目标广播/错误广播的遍历快照;正常多目标广播使用每站状态数组。 */
uint64_t request_id; /* 激活任务编号;未建立总召事务的单帧应答为0。 */
uint64_t completion_ticket; /* 只保存当前站成功最终应答的交接凭证,不以提交代替HANDED。 */
uint64_t started_ms, application_since_ms; /* 单调毫秒:BEGIN生成、当前工作事件入队。 */
size_t batch_index, objects_submitted; /* 已被发送层接手的批次数、对象总数。 */
IEC104_InterrogationPhase_t phase; /* 当前站下一步动作;整轮广播阶段另由broadcast.stage管理。 */
uint8_t reply_cause; /* 非零为单帧确认/错误应答,肯定撤销确认也使用此路径。 */
bool reply_negative; /* REPLY阶段发送的P/N标志;肯定撤销确认为false。 */
bool data_send_waiting; /* 本批已及时提供有效数据但发送WAIT;不缓存原文,不再计本批取数期限。 */
bool send_waiting; /* 当前帧提交曾返回WAIT;无新的本地工作时等网络推进后再重试。 */
bool event_outstanding, event_delivered; /* 当前交互待应答、该工作事件已被应用取出。 */
bool begin_delivered, finish_reserved; /* 应用已取过当前BEGIN;finish_reserved仅用于单目标终结预留。 */
bool occupied; /* 固定任务槽正在使用;任务可非队首完成,释放后立即复用此槽。 */
} InterrogationTask;
/* 整轮依次完成全部站确认、逐站取数、全部站终止;FINISH只等待终结事件交付和资源回收。 */
enum { BROADCAST_ACCEPT, BROADCAST_DATA, BROADCAST_TERMINATE, BROADCAST_FINISH };
/* ACCEPTED仅表示应用接受;CONFIRMED表示肯定ACT_CON已被发送层接手,尚不代表主站ACK。
* DATA_DONE等其他站取数完成后再发ACT_TERM;ENDED保留终结原因,不能立即回收状态项。 */
enum { STATION_PENDING, STATION_ACCEPTED, STATION_CONFIRMED, STATION_DATA_DONE, STATION_ENDED };
/* BEGIN_READ决定是否欠应用一次FINISHED;QUEUED防止重复入队,READ才表示已经交付。
* DEACTIVATE单独记录待发送COT=9,站点ENDED或FINISHED已读均不能代替撤销确认提交。
* DEACTIVATE_NEGATIVE仅在DEACTIVATE置位时有意义,保存撤销受理时的P/N结果;
* End_Broadcast_Station会把未结束站也改为ENDED,故不能在发送时再按ENDED推断P/N。
* 发送层接手对应COT=9或Cancel丢弃整轮回复时,两位一起清除。 */
enum { STATION_BEGIN_READ = 1U, STATION_FINISH_QUEUED = 2U, STATION_FINISH_READ = 4U,
STATION_DEACTIVATE = 8U, STATION_DEACTIVATE_NEGATIVE = 16U };
/* 一个实例至多一轮广播,三阶段共用同一协议任务,应用可逐站复用取数游标。 */
typedef struct {
InterrogationTask *task; /* 三阶段复用同一固定槽,FINISHING期间仍占用。 */
size_t count, index; /* 已捕获目标数、当前站在调用方状态数组中的位置。 */
uint8_t stage; /* 整轮阶段;当前站的等待/发送动作保存在task->phase。 */
bool cancelling, cancel_all; /* cancelling保留原回复/撤销确认的收尾义务,并阻止回收快照;
* cancel_all区分确认后结束整轮,还是恢复未被定向撤销的站。 */
} InterrogationBroadcast;
struct IEC104_Interrogation {
IEC104_Slave_t *slave; /* NULL为空闲槽;有效期间Slave必须存活。 */
const IEC104_InterrogationRules_t *rules; /* 创建时借用的只读种类规则,寿命覆盖实例。 */
IEC104_InterrogationConfig_t config; /* 配置对象按值复制,broadcast_states指向的数组仍借用调用方存储。 */
IEC104_InterrogationStatus_t status; /* 会话状态和累计统计;即时进度由Get_Status补齐。 */
IEC104_SlaveEventIdentity_t session; /* Slave校验后交付的服务身份和已处理的连接代次。 */
uint64_t instance_id, next_request_id;
InterrogationBroadcast broadcast;
/* instance_id区分总召静态槽的历次使用;next_request_id在本实例内递增,
* 两者共同标识一次总召,独立于Slave的服务实例和连接身份。 */
unsigned count, event_count, reserved_finishes;
/* count包含等待清理的广播任务;event_count仅统计已入FIFO的事件。
* reserved_finishes仅为单目标预留,二者之和不超过FIFO容量;广播延迟FINISHED另存每站状态。 */
unsigned order[IEC104_INTERROGATION_TASK_CAPACITY]; /* 有效任务槽下标,保持应答形成的先后顺序。 */
bool prefer_interrogation; /* 单帧提交后给可推进总召一次机会,跨Process返回保留。 */
InterrogationTask tasks[IEC104_INTERROGATION_TASK_CAPACITY]; /* 固定地址的协议任务池。 */
IEC104_InterrogationEvent_t events[IEC104_INTERROGATION_EVENT_CAPACITY]; /* 可移动的纯值事件FIFO。 */
};
static IEC104_Interrogation_t interrogation_pool[IEC104_INTERROGATION_CAPACITY];
/* 不随槽释放清零,避免旧事件误命中新实例;达到上限拒绝创建,不回绕。 */
static uint64_t instance_serial;
/**
* 功能:Process或Submit_Batch确认发送层已接手ASDU后推进所选任务;发送WAIT/失败时不得调用。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:!Bind_Station(self, task, next) || (task->request_id != 0U && self->next_request_id == UINT64_MAX)时返回false;其余分支返回true、Complete_Broadcast_Deactivation(self)、Next_Broadcast_Station(self)、false。
* 说明:单目标CONFIRM转入DATA;多目标依次遍历确认、数据、终止三阶段。
* DATA由Submit_Batch累计进度;TERMINATE生成FINISHED(COMPLETED),REPLY结束当前站。
* 释放时只移动顺序索引,保持其他任务的槽位和调度顺序;此处不等待主站ACK。
*/
static bool Advance(IEC104_Interrogation_t *self, InterrogationTask *task);
/**
* 功能:先完成当前阶段的余下站点,再从数组首项进入下一阶段,保证全部确认先于数据、全部数据先于终止。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回Select_Broadcast_Station(self, index)、true。
* 说明:仅跳过尚未选中便被删除的未来站;已确认站即使退役,也按原引用继续完成或显式终结。
* 最后一遍完成后进入FINISHING;若没有待交付终结事件,本次调用即可回收任务。
*/
static bool Next_Broadcast_Station(IEC104_Interrogation_t *self);
/**
* 功能:终结记录留在每站状态区,FIFO有空位才入队;2槽FIFO也可交付全部已配置目标的终结通知。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:仅为应用已读BEGIN的站点生成一次FINISHED,未入队的记录保留到后续调用继续交付。
* 共享任务此时可能已切到其他站,故公共请求字段沿用task,身份/CA/进度/票据须从原站状态覆盖。
* 不重新查询或猜测交接结果;交付的是提交时保存的纯值凭证,应用之后才能区分HANDED与CANCELLED。
*/
static void Flush_Broadcast_Finishes(IEC104_Interrogation_t *self);
/**
* 功能:仅识别使用状态数组的正常多目标广播,单目标广播和错误广播不走此分支。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:无。
* 返回值:返回task != NULL && self->broadcast.task == task的结果。
* 说明:直接处理传入的self、task,不经过其他函数调用。
*/
static bool Is_Broadcast(const IEC104_Interrogation_t *self, const InterrogationTask *task)
{
return task != NULL && self->broadcast.task == task;
}
/**
* 功能:返回调用方状态数组中当前广播站的借用条目;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:返回调用方状态数组中当前广播站的借用条目;
* 说明:仅在广播快照有效且index未越界时调用。
*/
static IEC104_InterrogationStationState_t *Broadcast_Current(IEC104_Interrogation_t *self)
{
return &self->config.broadcast_states[self->broadcast.index];
}
/**
* 功能:切站或终结前保存共享任务的当前进度及成功终止凭证;不保存应用游标或点值快照。
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:无。
* 说明:最终应答提交OK后,Finish先保存本站票据再切换共享任务;事件FIFO满也不能丢掉本站交接身份。
*/
static void Save_Broadcast_Progress(IEC104_Interrogation_t *self)
{
IEC104_InterrogationStationState_t *entry = Broadcast_Current(self);
entry->_batch_index = self->broadcast.task->batch_index;
entry->_objects_submitted = self->broadcast.task->objects_submitted;
entry->_completion_ticket = self->broadcast.task->completion_ticket;
}
/**
* 功能:检查句柄是否指向仍被占用的实例槽;先比较地址再解引用,NULL和池外指针返回false。
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:true表示句柄属于当前占用的静态实例槽;NULL、池外地址或未占用槽返回false。
* 说明:这里只验证实例占用,Slave的寿命仍由调用方保证。
*/
static bool Owned(const IEC104_Interrogation_t *self)
{
size_t i;
for (i = 0U; i < IEC104_INTERROGATION_CAPACITY; ++i) {
if (self == &interrogation_pool[i]) { return self->slave != NULL; }
}
return false;
}
/**
* 功能:取得固定任务槽并追加顺序索引;调用方完成请求复制,失败时须立即Remove_Task。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回NULL、task。
* 说明:不移动已有任务,保持快照的_self校验及broadcast.task指针有效。
*/
static InterrogationTask *Allocate_Task(IEC104_Interrogation_t *self)
{
unsigned slot;
if (self->count == IEC104_INTERROGATION_TASK_CAPACITY) { return NULL; }
for (slot = 0U; slot < IEC104_INTERROGATION_TASK_CAPACITY; ++slot) {
InterrogationTask *task = &self->tasks[slot];
if (!task->occupied) {
memset(task, 0, sizeof(*task));
task->occupied = true;
self->order[self->count++] = slot;
return task;
}
}
return NULL;
}
/**
* 功能:分别归还当前站引用、遍历快照及每个广播状态项的引用,随后清空本轮状态。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:当前站与对应状态项各持有一次引用,因此两次Release均须保留。
*/
static void Release_Stations(IEC104_Interrogation_t *self, InterrogationTask *task)
{
size_t i;
if (task->station != NULL) {
(void)IEC104_Slave_Release_Station(self->slave, task->station);
task->station = NULL;
}
if (task->stations._owner != NULL) { (void)IEC104_Slave_StationSnapshot_End(&task->stations); }
if (Is_Broadcast(self, task)) {
for (i = 0U; i < self->broadcast.count; ++i) {
IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[i];
(void)IEC104_Slave_Release_Station(self->slave, entry->_station);
memset(entry, 0, sizeof(*entry));
}
memset(&self->broadcast, 0, sizeof(self->broadcast));
}
}
/**
* 功能:仅压紧顺序索引,不移动其他任务;调用前须完成终结通知安排。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:多目标广播须经Reap_Broadcast确认FINISHED已读完,才能释放任务及借用状态项。
*/
static void Remove_Task(IEC104_Interrogation_t *self, InterrogationTask *task)
{
unsigned i;
for (i = 0U; i < self->count; ++i) {
if (&self->tasks[self->order[i]] == task) {
Release_Stations(self, task);
memset(task, 0, sizeof(*task));
memmove(self->order + i, self->order + i + 1U,
(self->count - i - 1U) * sizeof(self->order[0]));
self->order[--self->count] = 0U;
return;
}
}
}
/**
* 功能:原总召转为拒绝/撤销确认时,复用原槽并按应答形成时刻放到顺序末尾。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:满池也能转换;不让这条新应答越过已经等待的其他单帧应答。
*/
static void Move_Reply_To_Tail(IEC104_Interrogation_t *self, const InterrogationTask *task)
{
unsigned i;
for (i = 0U; i < self->count; ++i) {
unsigned slot = self->order[i];
if (&self->tasks[slot] == task) {
memmove(self->order + i, self->order + i + 1U,
(self->count - i - 1U) * sizeof(self->order[0]));
self->order[self->count - 1U] = slot;
self->prefer_interrogation = false;
return;
}
}
}
/**
* 功能:返回唯一未终结总召的固定槽下标;request_id为0查当前总召,非0核对指定请求。
* 输入参数:self——本模块实例。
* request_id——请求编号。
* 输出参数:无。
* 返回值:返回唯一未终结总召的固定槽下标;
* 无匹配返回TASK_CAPACITY;
* 说明:无匹配返回TASK_CAPACITY;广播在当前站否定确认等待期间仍占总召资格。
* FINISHING不参与业务推进,接纳新请求时另检查broadcast.task,防止复用未清理的状态区。
*/
static unsigned Find_Interrogation(const IEC104_Interrogation_t *self, uint64_t request_id)
{
unsigned i;
for (i = 0U; i < self->count; ++i) {
unsigned slot = self->order[i];
const InterrogationTask *task = &self->tasks[slot];
if (task->request_id != 0U && task->phase != IEC104_INTERROGATION_FINISHING &&
(task->phase != IEC104_INTERROGATION_REPLY || task->stations._owner != NULL || Is_Broadcast(self, task)) &&
(request_id == 0U || task->request_id == request_id)) { return slot; }
}
return IEC104_INTERROGATION_TASK_CAPACITY;
}
/**
* 功能:相同关联字段的ACT_CON按原请求接收顺序交接,避免后到忙否定被主站关联到首条激活。
* 输入参数:self——本模块实例。
* request——请求。
* cause——传送原因。
* receive_serial——接收事件序号。
* 输出参数:无。
* 返回值:存在应先交接、关联字段相同的更早确认时返回true,否则false。
* 说明:receive_serial仅用于本地排先后,不写入ASDU,也不等待主站ACK。比较完整对象含QCC的FRZ,
* 不能把同RQT的不同冻结动作视作同一关联对象;T位、OA、类型和服务/代次同样独立。
* 广播请求副本只保存当前CA,因此须从原目标快照查每站是否仍欠确认。ENDED不一定已回复:
* 当前站应用拒绝时先终结业务,否定ACT_CON仍可能等待发送。其他ENDED站没有待发确认。
* 本函数只读,入口直发、排队调度及Get_Status共用;不新增任务、期限或每站状态。
*/
static bool Confirmation_Blocked(const IEC104_Interrogation_t *self,
const InterrogationResponse *request, uint8_t cause, uint64_t receive_serial)
{
unsigned i;
uint16_t ca;
if (cause != IEC60870_ASDU_COT_ACTIVATION_CON) { return false; }
ca = (uint16_t)((uint16_t)request->bytes[4] | ((uint16_t)request->bytes[5] << 8));
for (i = 0U; i < self->count; ++i) {
const InterrogationTask *older = &self->tasks[self->order[i]];
bool current_pending;
if (older->info.receive_serial >= receive_serial ||
older->request.identity.slave != request->identity.slave ||
older->request.identity.instance_id != request->identity.instance_id ||
older->request.identity.generation != request->identity.generation ||
older->request.bytes[0] != request->bytes[0] ||
((older->request.bytes[2] ^ request->bytes[2]) & 0x80U) != 0U ||
older->request.bytes[3] != request->bytes[3] ||
memcmp(older->request.bytes + 6U, request->bytes + 6U, 4U) != 0) { continue; }
current_pending = older->phase == IEC104_INTERROGATION_START ||
older->phase == IEC104_INTERROGATION_CONFIRM ||
(older->phase == IEC104_INTERROGATION_REPLY &&
older->reply_cause == IEC60870_ASDU_COT_ACTIVATION_CON);
if (current_pending && older->info.common_address == ca) { return true; }
if (Is_Broadcast(self, older)) {
size_t n;
for (n = 0U; n < self->broadcast.count; ++n) {
const IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[n];
if ((entry->_state == STATION_ACCEPTED ||
(entry->_state == STATION_PENDING && IEC104_Station_Is_Registered(entry->_station))) &&
IEC104_Station_Get_Common_Address(entry->_station) == ca) { return true; }
}
} else if (current_pending && older->stations._owner != NULL && older->stations._next != NULL) {
/* 错误/忙广播使用注册顺序快照逐站回否定,没有broadcast_states。后续仍注册的目标
* 必须落在未走过的位置和原上界之间;删除或同CA重建的未来节点不会被旧快照应答。 */
const IEC104_Station_t *station = IEC104_Slave_Get_Station(self->slave, ca);
uint64_t id = IEC104_Station_Get_Id(station);
if (id >= IEC104_Station_Get_Id(older->stations._next) && id <= older->stations._last_id) {
return true;
}
}
}
return false;
}
/**
* 功能:最早可发送的单帧应答;同关联对象尚欠较早ACT_CON时暂让出,其他可发REPLY保持FIFO。
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:按处理分支返回slot、IEC104_INTERROGATION_TASK_CAPACITY。
* 说明:原激活拒绝后会移到队尾;必须允许跳过依赖它的后到否定,才能先发原确认并解除依赖。
* 广播撤销借用原任务发送一组确认,即使当前站phase未转REPLY,也按短应答参与排序。
*/
static unsigned Find_Reply(const IEC104_Interrogation_t *self)
{
unsigned i;
for (i = 0U; i < self->count; ++i) {
unsigned slot = self->order[i];
const InterrogationTask *task = &self->tasks[slot];
if ((task->phase == IEC104_INTERROGATION_REPLY ||
(Is_Broadcast(self, task) && self->broadcast.cancelling)) &&
!Confirmation_Blocked(self, &task->request, task->reply_cause, task->info.receive_serial)) {
return slot;
}
}
return IEC104_INTERROGATION_TASK_CAPACITY;
}
/**
* 功能:业务推进无需等待应用或事件空位时为true;
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:无。
* 返回值:业务推进无需等待应用或事件空位时为true;
* 说明:发送容量仍由实际提交结果决定。
*/
static bool Interrogation_Can_Progress(const IEC104_Interrogation_t *self, const InterrogationTask *task)
{
if (task->phase == IEC104_INTERROGATION_CONFIRM &&
Confirmation_Blocked(self, &task->request, IEC60870_ASDU_COT_ACTIVATION_CON,
task->info.receive_serial)) { return false; }
if (task->phase == IEC104_INTERROGATION_START || task->phase == IEC104_INTERROGATION_DATA) {
unsigned needed = task->phase == IEC104_INTERROGATION_DATA || Is_Broadcast(self, task) ? 1U : 2U;
return !task->event_outstanding &&
self->event_count + self->reserved_finishes + needed <= IEC104_INTERROGATION_EVENT_CAPACITY;
}
return task->phase != IEC104_INTERROGATION_FINISHING;
}
/**
* 功能:可发单帧保持FIFO;双方可推进时先单帧再总召,轮转位置跨调用保存。
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:均不能推进时返回容量哨兵。
* 说明:总召等应用或业务FIFO空位时只选无确认依赖的单帧;均不能推进时返回容量哨兵。
* Process与状态查询共用选择规则;send_waiting不阻止网络推进后的显式重试。
*/
static unsigned Select_Task(const IEC104_Interrogation_t *self)
{
unsigned slot = Find_Interrogation(self, 0U), reply_slot = Find_Reply(self);
if (slot != IEC104_INTERROGATION_TASK_CAPACITY &&
(self->tasks[slot].phase == IEC104_INTERROGATION_REPLY ||
(Is_Broadcast(self, &self->tasks[slot]) && self->broadcast.cancelling) ||
!Interrogation_Can_Progress(self, &self->tasks[slot]))) { slot = IEC104_INTERROGATION_TASK_CAPACITY; }
if (reply_slot != IEC104_INTERROGATION_TASK_CAPACITY &&
(!self->prefer_interrogation || slot == IEC104_INTERROGATION_TASK_CAPACITY)) { return reply_slot; }
return slot != IEC104_INTERROGATION_TASK_CAPACITY ? slot : reply_slot;
}
/**
* 功能:将任务身份、请求元数据和当前进度复制成一条业务事件;本函数不执行应用代码。
* 输入参数:self——本模块实例。
* task——业务任务。
* type——类型。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:type决定应用需要接受、交付数据还是清理;reason仅在FINISHED时有业务意义。
* 调用方须已检查容量,或已将本任务的终结预留释放为可写位置。
* 先清零再仅为成功FINISHED复制票据,避免复用FIFO槽时把旧成功凭证带入BEGIN或失败事件。
*/
static void Push_Event(IEC104_Interrogation_t *self, const InterrogationTask *task,
IEC104_InterrogationEventType_t type, IEC104_InterrogationFinishReason_t reason)
{
IEC104_InterrogationEvent_t *event = &self->events[self->event_count++];
memset(event, 0, sizeof(*event));
event->type = type;
event->instance_id = self->instance_id;
event->request_id = task->request_id;
event->request = task->info;
event->batch_index = task->batch_index;
event->objects_submitted = task->objects_submitted;
event->reason = reason;
if (type == IEC104_INTERROGATION_FINISHED && reason == IEC104_INTERROGATION_FINISH_COMPLETED) {
event->completion_ticket = task->completion_ticket;
}
}
/**
* 功能:终结记录留在每站状态区,FIFO有空位才入队;2槽FIFO也可交付全部已配置目标的终结通知。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:仅为应用已读BEGIN的站点生成一次FINISHED,未入队的记录保留到后续调用继续交付。
* 共享任务此时可能已切到其他站,故公共请求字段沿用task,身份/CA/进度/票据须从原站状态覆盖。
* 不重新查询或猜测交接结果;交付的是提交时保存的纯值凭证,应用之后才能区分HANDED与CANCELLED。
*/
static void Flush_Broadcast_Finishes(IEC104_Interrogation_t *self)
{
size_t i;
InterrogationTask *task = self->broadcast.task;
if (task == NULL) { return; }
for (i = 0U; i < self->broadcast.count &&
self->event_count + self->reserved_finishes < IEC104_INTERROGATION_EVENT_CAPACITY; ++i) {
IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[i];
IEC104_InterrogationEvent_t *event;
if (entry->_reason == IEC104_INTERROGATION_FINISH_NONE ||
(entry->_flags & (STATION_BEGIN_READ | STATION_FINISH_QUEUED)) != STATION_BEGIN_READ) { continue; }
Push_Event(self, task, IEC104_INTERROGATION_FINISHED, (IEC104_InterrogationFinishReason_t)entry->_reason);
event = &self->events[self->event_count - 1U];
event->request_id = entry->_request_id;
event->request.station_id = IEC104_Station_Get_Id(entry->_station);
event->request.common_address = IEC104_Station_Get_Common_Address(entry->_station);
event->batch_index = entry->_batch_index;
event->objects_submitted = entry->_objects_submitted;
/* 共享任务可能已完成别的站;成功凭证必须与本条FINISHED的原站身份一起恢复。 */
event->completion_ticket = entry->_reason == IEC104_INTERROGATION_FINISH_COMPLETED ?
entry->_completion_ticket : 0U;
entry->_flags |= STATION_FINISH_QUEUED;
}
}
/**
* 功能:只计尚未入FIFO的终结记录;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:按处理分支返回0U、pending。
* 说明:状态查询再加event_count,避免重复统计已排队的FINISHED。
*/
static unsigned Pending_Broadcast_Finishes(const IEC104_Interrogation_t *self)
{
size_t i;
unsigned pending = 0U;
if (self->broadcast.task == NULL) { return 0U; }
for (i = 0U; i < self->broadcast.count; ++i) {
const IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[i];
if (entry->_reason != IEC104_INTERROGATION_FINISH_NONE &&
(entry->_flags & (STATION_BEGIN_READ | STATION_FINISH_QUEUED)) == STATION_BEGIN_READ) { ++pending; }
}
return pending;
}
/**
* 功能:整轮结束、撤销确认提交完且每个已读BEGIN的FINISHED也已读出后,才归还状态区和引用。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:应用可能先读完FINISHED而网络仍WAIT,cancelling须继续保护逐站回复所需的原节点引用。
* 入FIFO不等于交付;此函数可能清空broadcast.task,调用方不能假定原任务仍有效。
*/
static void Reap_Broadcast(IEC104_Interrogation_t *self)
{
size_t i;
if (self->broadcast.task == NULL || self->broadcast.stage != BROADCAST_FINISH || self->broadcast.cancelling) { return; }
for (i = 0U; i < self->broadcast.count; ++i) {
uint8_t flags = self->config.broadcast_states[i]._flags;
if ((flags & (STATION_BEGIN_READ | STATION_FINISH_READ)) == STATION_BEGIN_READ) { return; }
}
Remove_Task(self, self->broadcast.task);
}
/**
* 功能:取消当前请求尚未消费的工作事件,保留所有FINISHED;
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:已交给应用的旧应答由身份/状态拒绝。
*/
static void Remove_Work_Events(IEC104_Interrogation_t *self, InterrogationTask *task)
{
unsigned read, write = 0U;
for (read = 0U; read < self->event_count; ++read) {
const IEC104_InterrogationEvent_t *event = &self->events[read];
if (event->request_id == task->request_id && event->type != IEC104_INTERROGATION_FINISHED) { continue; }
self->events[write++] = *event;
}
self->event_count = write;
task->event_outstanding = task->event_delivered = false;
}
/**
* 功能:可终结任一未结束原目标,包括尚未BEGIN的PENDING站;仅当前站需要保存共享进度、
* 输入参数:self——本模块实例。
* index——索引。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:撤销未完成的工作交互。尚未交付BEGIN的PENDING站不会凭此生成FINISHED。
* 每站首次终结原因不被后续整轮取消覆盖;实例last_finish_reason仍记录最近一次新终结。
* 节点引用及待发撤销标志留到各自清理边界,不随业务状态变为ENDED就立即清除。
* 非成功终结的票据归零;已经COMPLETED的站保留原原因和票据,之后帧是否取消须另查交接状态。
*/
static void End_Broadcast_Station(IEC104_Interrogation_t *self, size_t index,
IEC104_InterrogationFinishReason_t reason)
{
IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[index];
if (entry->_state == STATION_ENDED) { return; }
if (index == self->broadcast.index) {
Save_Broadcast_Progress(self);
Remove_Work_Events(self, self->broadcast.task);
}
entry->_reason = (uint8_t)reason;
if (reason != IEC104_INTERROGATION_FINISH_COMPLETED) { entry->_completion_ticket = 0U; }
entry->_state = STATION_ENDED;
self->status.last_finish_reason = reason;
}
/**
* 功能:结束一个总召的应用交互,reason保存为该请求的终结原因;不自行释放协议任务。
* 输入参数:self——本模块实例。
* task——业务任务。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:多目标广播把终结记录写入调用方状态区,FIFO有空位时才交付。
* 移除本请求尚未取出的BEGIN/NEED_DATA,保留其他事件和所有历史FINISHED。
* 单目标BEGIN已取出时,用预留位置交付一次FINISHED;BEGIN未取出时只撤销事件和预留,
* 因为应用尚未获得请求,无需通知它清理资源。finish_reserved同时防止重复终结。
*/
static void Finish(IEC104_Interrogation_t *self, InterrogationTask *task,
IEC104_InterrogationFinishReason_t reason)
{
if (Is_Broadcast(self, task)) {
End_Broadcast_Station(self, self->broadcast.index, reason);
Flush_Broadcast_Finishes(self);
return;
}
if (task->request_id != 0U && task->phase != IEC104_INTERROGATION_REPLY) {
self->status.last_finish_reason = reason;
}
if (!task->finish_reserved) { return; }
Remove_Work_Events(self, task);
--self->reserved_finishes;
task->finish_reserved = false;
task->event_outstanding = task->event_delivered = false;
if (task->begin_delivered) {
Push_Event(self, task, IEC104_INTERROGATION_FINISHED, reason);
task->begin_delivered = false;
}
}
/**
* 功能:肯定ACT_CON尚未被发送层接手时,结束本次业务并复用原槽保存否定确认。
* 输入参数:self——本模块实例。
* task——业务任务。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:应用主动拒绝、BEGIN失败以及START/CONFIRM超时共用此路径,保留各自终结原因。
* Finish清除未读工作事件并兑现终结预留;不取消其他任务、不额外占槽、不关闭连接。
* 新形成的否定确认移到REPLY队尾;调度仍先于依赖它的后到确认,WAIT时保留重试。
*/
static void Reject_Request(IEC104_Interrogation_t *self, InterrogationTask *task,
IEC104_InterrogationFinishReason_t reason)
{
++self->status.rejected;
Finish(self, task, reason);
task->reply_cause = IEC60870_ASDU_COT_ACTIVATION_CON;
task->reply_negative = true;
task->phase = IEC104_INTERROGATION_REPLY;
task->send_waiting = false;
self->status.waiting = false;
Move_Reply_To_Tail(self, task);
}
/**
* 功能:按reason结束本实例全部任务,不关闭Slave或连接;Slave已接手的帧不撤销。
* 输入参数:self——本模块实例。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:单目标任务可立即释放,多目标留在FINISHING,待各站FINISHED读完再归还状态区。
* cancelled按取消的协议任务数累计,包含单帧应答;整轮广播只计一个,不按站点或事件计数。
*/
static void Cancel(IEC104_Interrogation_t *self, IEC104_InterrogationFinishReason_t reason)
{
unsigned i = 0U;
while (i < self->count) {
InterrogationTask *task = &self->tasks[self->order[i]];
if (Is_Broadcast(self, task)) {
size_t station;
if (task->phase != IEC104_INTERROGATION_FINISHING) { ++self->status.cancelled; }
for (station = 0U; station < self->broadcast.count; ++station) {
End_Broadcast_Station(self, station, reason);
/* STOP、断线或本地取消丢弃尚未交接的撤销确认,不跨会话继续发送;
* FINISHED标志独立保留,应用已取BEGIN的清理义务仍须兑现。 */
self->config.broadcast_states[station]._flags &=
(uint8_t)~(STATION_DEACTIVATE | STATION_DEACTIVATE_NEGATIVE);
}
self->broadcast.stage = BROADCAST_FINISH;
self->broadcast.cancelling = false;
task->phase = IEC104_INTERROGATION_FINISHING;
task->send_waiting = task->data_send_waiting = false;
++i;
} else {
Finish(self, task, reason);
Remove_Task(self, task);
++self->status.cancelled;
}
}
Flush_Broadcast_Finishes(self);
Reap_Broadcast(self);
self->prefer_interrogation = false;
self->status.waiting = false;
}
/**
* 功能:内部服务故障或肯定确认提交后的执行失败,关闭identity所属连接并按reason取消全部任务。
* 输入参数:self——本模块实例。
* identity——原会话身份。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值: true包括成功关闭、原连接已断开和代次已过期;
* false表示底层关闭失败,任务仍已取消。
* 说明:identity可能位于任务中,必须先关闭原连接再清任务;旧代次不会关闭新连接。
* true包括成功关闭、原连接已断开和代次已过期;false表示底层关闭失败,任务仍已取消。
*/
static bool Reject_Connection(IEC104_Interrogation_t *self, const IEC104_SlaveEventIdentity_t *identity,
IEC104_InterrogationFinishReason_t reason)
{
IEC104_TcpResult_t result = IEC104_Slave_Close_Connection_By_Identity(self->slave, identity, NULL);
Cancel(self, reason);
self->status.active = false;
return result == IEC104_TCP_OK || result == IEC104_TCP_NOT_CONNECTED ||
result == IEC104_TCP_STALE_GENERATION;
}
/**
* 功能:按肯定确认的提交边界处理业务失败:START/CONFIRM仍可否定激活并保留连接;
* 输入参数:self——本模块实例。
* task——业务任务。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:true表示失败已处理,并不表示否定确认已经提交。
* 说明:肯定ACT_CON被发送层接手即越过边界:单目标转DATA,多目标标记CONFIRMED并继续确认其他站。
* DATA/TERMINATE失败沿用关闭原连接的策略,不补发成功ACT_TERM。
* 调用方已校验会话与任务;true表示失败已处理,并不表示否定确认已经提交。
*/
static bool Fail_Interrogation(IEC104_Interrogation_t *self, InterrogationTask *task,
IEC104_InterrogationFinishReason_t reason)
{
if (task->phase == IEC104_INTERROGATION_START || task->phase == IEC104_INTERROGATION_CONFIRM) {
Reject_Request(self, task, reason);
return true;
}
return Reject_Connection(self, &task->request.identity, reason);
}
/* DEFER表示暂不能尝试提交,WAIT表示已尝试但发送层未接手;均保存原请求,或在满槽时丢弃并计数。
* 只使用现有HIGH接口,不越过Slave通知、较早关联确认或可发送的旧REPLY。 */
typedef enum { REPLY_DEFER, REPLY_WAIT, REPLY_SENT, REPLY_FAILED } ImmediateReplyResult;
/**
* 功能:为请求校验选择首个实际CA;
* 输入参数:self——本模块实例。
* address——uint16_t值。
* 输出参数:无。
* 返回值:按处理分支返回station != NULL ? IEC104_Station_Get_Common_Address(station) : address、address == IEC104_CA_BROADCAST ? self->config.common_address : address。
* 说明:广播任务随后建立快照逐站推进,未知CA保留原值。
*/
static uint16_t Resolve_Common_Address(const IEC104_Interrogation_t *self, uint16_t address)
{
if (self->config.use_station_registry) {
IEC104_Station_t *station = address == IEC104_CA_BROADCAST ?
IEC104_Slave_Next_Station(self->slave, NULL) : IEC104_Slave_Get_Station(self->slave, address);
return station != NULL ? IEC104_Station_Get_Common_Address(station) : address;
}
return address == IEC104_CA_BROADCAST ? self->config.common_address : address;
}
/**
* 功能:保存可明确识别的单对象Type100及原身份;IOA/QOI必须完整,零对象/多对象不在此构造应答。
* 输入参数:self——本模块实例。
* destination——目标存储。
* identity——原会话身份。
* data——数据存储。
* length——字节长度。
* response_ca——uint16_t值。
* 输出参数:destination——复制的请求身份和规范应答原文;仅完整可识别请求进入复制路径,后续构造失败时不得使用该候选。
* 返回值:完整复制单对象请求并成功设置应答CA返回true;长度、类型、对象数或ASDU构造失败返回false。
* 说明:应答固定为10字节、VSQ=1,保留唯一对象、OA和TEST;CA按原规则处理广播。
* 调用方须记住原SQ/尾字节错误并仅作否定应答,不能把规范化副本当作合法激活或撤销执行。
*/
static bool Copy_Response_Request(IEC104_Interrogation_t *self, InterrogationResponse *destination,
const IEC104_SlaveEventIdentity_t *identity, const uint8_t *data, uint16_t length, uint16_t response_ca)
{
IEC60870_Asdu_t asdu;
if (length < sizeof(destination->bytes) || data[0] != self->rules->type_id ||
(data[1] & 0x7fU) != 1U) { return false; } /* VSQ低7位为对象数。 */
destination->identity = *identity;
destination->priority = (uint8_t)(self->rules->type_id == IEC60870_ASDU_C_CI_NA_1 ?
IEC104_BUSINESS_PRIORITY_COUNTER_INTERROGATION : IEC104_BUSINESS_PRIORITY_INTERROGATION);
memcpy(destination->bytes, data, sizeof(destination->bytes));
destination->bytes[1] = 1U;
return IEC60870_Asdu_Create_From_Buffer(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
destination->bytes, sizeof(destination->bytes)) == IEC60870_ASDU_OK &&
IEC60870_Asdu_Set_CA(&asdu, response_ca) == IEC60870_ASDU_OK;
}
/**
* 功能:整轮确认、数据、终止使用同一等级;不能在终止时重新看启动门禁而把尾帧提到数据之前。
* 输入参数:self——本模块实例。
* response——应答。
* initialization——bool值。
* 输出参数:response——应答的更新结果。
* 返回值:无。
* 说明:新请求默认总召5/计数量12;调用方仅把有效的真实全站初始化总召判为2,分组和TEST不提级。
* 同关联后到请求继承仍保留的原任务等级,包括将被拒绝的忙请求,不能按此刻门禁另分等级。
* 配合Confirmation_Blocked及发送层同级FIFO保持确认顺序;继承等级不代表接受重复请求。
* 原请求可能是多CA广播,CA匹配须覆盖其原目标,不能只检查共享任务当前站。
*/
static void Classify_Response(IEC104_Interrogation_t *self, InterrogationResponse *response,
bool initialization)
{
unsigned i;
uint16_t ca = (uint16_t)((uint16_t)response->bytes[4] | ((uint16_t)response->bytes[5] << 8));
if (initialization) { response->priority = (uint8_t)IEC104_BUSINESS_PRIORITY_INITIAL_INTERROGATION; }
for (i = 0U; i < self->count; ++i) {
const InterrogationTask *older = &self->tasks[self->order[i]];
bool matches = older->info.common_address == ca;
if (older->request.identity.generation != response->identity.generation ||
older->request.identity.instance_id != response->identity.instance_id ||
older->request.bytes[0] != response->bytes[0] ||
((older->request.bytes[2] ^ response->bytes[2]) & 0x80U) != 0U ||
older->request.bytes[3] != response->bytes[3] ||
memcmp(older->request.bytes + 6U, response->bytes + 6U, 4U) != 0) { continue; }
if (!matches && Is_Broadcast(self, older)) {
size_t n;
for (n = 0U; n < self->broadcast.count; ++n) {
if (IEC104_Station_Get_Common_Address(self->config.broadcast_states[n]._station) == ca) {
matches = true; break;
}
}
}
if (matches) { response->priority = older->request.priority; return; }
}
}
/* 选中节点后持有引用;删除只退出路由,当前事务仍使用这个注册编号及context。 */
/**
* 功能:当前任务持有原节点,并把请求副本CA改为实际目标站;
* 输入参数:self——本模块实例。
* task——业务任务。
* station——逻辑站点。
* 输出参数:task——业务任务的更新结果。
* 返回值:持有目标站点引用并成功更新请求副本CA返回true;站点无效、引用取得失败或ASDU处理失败返回false。
* 说明:连接身份、OA、QOI等保持原请求语义。
*/
static bool Bind_Station(IEC104_Interrogation_t *self, InterrogationTask *task, IEC104_Station_t *station)
{
IEC60870_Asdu_t asdu;
if (station == NULL || IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) { return false; }
task->station = station;
task->info.common_address = IEC104_Station_Get_Common_Address(station);
task->info.station_id = IEC104_Station_Get_Id(station);
return IEC60870_Asdu_Create_From_Buffer(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
task->request.bytes, sizeof(task->request.bytes)) == IEC60870_ASDU_OK &&
IEC60870_Asdu_Set_CA(&asdu, task->info.common_address) == IEC60870_ASDU_OK;
}
/**
* 功能:在同一任务槽内切站:归还当前额外引用,再从状态项恢复本站身份、起始时间和提交进度。
* 输入参数:self——本模块实例。
* index——索引。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!Bind_Station(self, task, entry->_station)时返回false;其余分支返回false、true。
* 说明:状态项本身仍持有原节点,故删除或同CA替换不会使切换误绑定新站;此处不重新按CA查找。
* 每站只恢复协议状态,BEGIN/NEED_DATA的交互标志重新开始,应用取数游标由应用另行维护。
*/
static bool Select_Broadcast_Station(IEC104_Interrogation_t *self, size_t index)
{
InterrogationTask *task = self->broadcast.task;
IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[index];
if (task->station != NULL) {
(void)IEC104_Slave_Release_Station(self->slave, task->station);
task->station = NULL;
}
self->broadcast.index = index;
if (!Bind_Station(self, task, entry->_station)) { return false; }
task->request_id = entry->_request_id;
task->started_ms = entry->_started_ms;
task->application_since_ms = 0U;
task->batch_index = entry->_batch_index;
task->objects_submitted = entry->_objects_submitted;
task->completion_ticket = entry->_completion_ticket;
task->phase = self->broadcast.stage == BROADCAST_ACCEPT ? IEC104_INTERROGATION_START :
self->broadcast.stage == BROADCAST_DATA ? IEC104_INTERROGATION_DATA : IEC104_INTERROGATION_TERMINATE;
task->reply_cause = 0U;
task->reply_negative = task->send_waiting = task->data_send_waiting = false;
task->event_outstanding = task->event_delivered = task->finish_reserved = false;
task->begin_delivered = (entry->_flags & STATION_BEGIN_READ) != 0U;
return true;
}
/**
* 功能:接收时一次取得所有节点引用;后续确认、数据、终止使用同一集合,不混入新增/替代节点。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* 返回值:全部目标站点均成功取得引用并完成状态快照返回true;捕获中任一步失败返回false。
* 说明:入口已检查整轮容量和请求编号余量;本段串行执行且不调用应用,捕获期间注册集合不变。
* 每成功持有一项便计入count,部分失败时由整轮取消/回收路径归还已取得的引用。
*/
static bool Capture_Broadcast(IEC104_Interrogation_t *self, InterrogationTask *task)
{
IEC104_Station_t *station = NULL;
self->broadcast.task = task;
while ((station = IEC104_Slave_Next_Station(self->slave, station)) != NULL) {
IEC104_InterrogationStationState_t *entry;
if (self->broadcast.count == self->config.broadcast_capacity ||
IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) { return false; }
entry = &self->config.broadcast_states[self->broadcast.count];
memset(entry, 0, sizeof(*entry));
entry->_station = station;
entry->_request_id = self->broadcast.count == 0U ? task->request_id : ++self->next_request_id;
++self->broadcast.count;
}
return self->broadcast.count != 0U && Select_Broadcast_Station(self, 0U);
}
/**
* 功能:先完成当前阶段的余下站点,再从数组首项进入下一阶段,保证全部确认先于数据、全部数据先于终止。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回Select_Broadcast_Station(self, index)、true。
* 说明:仅跳过尚未选中便被删除的未来站;已确认站即使退役,也按原引用继续完成或显式终结。
* 最后一遍完成后进入FINISHING;若没有待交付终结事件,本次调用即可回收任务。
*/
static bool Next_Broadcast_Station(IEC104_Interrogation_t *self)
{
size_t index = self->broadcast.index + 1U;
while (self->broadcast.stage < BROADCAST_FINISH) {
for (; index < self->broadcast.count; ++index) {
IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[index];
if (self->broadcast.stage == BROADCAST_ACCEPT && entry->_state == STATION_PENDING &&
!IEC104_Station_Is_Registered(entry->_station)) {
entry->_state = STATION_ENDED; /* 未选择/未确认的退役站不启动,不发成功终止。 */
}
if ((self->broadcast.stage == BROADCAST_ACCEPT && entry->_state == STATION_PENDING) ||
(self->broadcast.stage == BROADCAST_DATA && entry->_state == STATION_CONFIRMED) ||
(self->broadcast.stage == BROADCAST_TERMINATE && entry->_state == STATION_DATA_DONE)) {
return Select_Broadcast_Station(self, index);
}
}
++self->broadcast.stage;
index = 0U;
}
self->broadcast.task->phase = IEC104_INTERROGATION_FINISHING;
self->broadcast.task->send_waiting = false;
Flush_Broadcast_Finishes(self);
Reap_Broadcast(self); /* 无待读终结记录时立即回收,不依赖下一轮网络唤醒。 */
return true;
}
/**
* 功能:定向撤销的活动范围:已确认但尚未取数、或等最后终止的站也包括在内。
* 输入参数:self——本模块实例。
* index——索引。
* 输出参数:无。
* 返回值:返回entry->_state != STATION_ENDED && (entry->_state != STATION_PENDING || index == self->broadcast.index)的结果。
* 说明:尚未选中的PENDING站不属于定向活动事务,但仍属于可整轮撤销的广播工作。
*/
static bool Broadcast_Station_Active(const IEC104_Interrogation_t *self, size_t index)
{
const IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[index];
return entry->_state != STATION_ENDED &&
(entry->_state != STATION_PENDING || index == self->broadcast.index);
}
/**
* 功能:广播地址匹配任一未结束原目标,包括尚未生成BEGIN的PENDING站;本地调度不代表未收到ACT。
* 输入参数:self——本模块实例。
* common_address——ASDU公共地址。
* 输出参数:无。
* 返回值: 返回值仅证明整轮/定向事务存在,不是广播确认的起始位置;
* 说明:例如首站已拒绝、后站尚未BEGIN时,当前task虽处于否定REPLY,整轮仍可被广播撤销。
* 定向地址仍只匹配活动站,可找到已退役但仍活动的原目标;不重新查询当前站点注册表。
* 返回值仅证明整轮/定向事务存在,不是广播确认的起始位置;count表示无匹配。
*/
static size_t Find_Broadcast_Activation(const IEC104_Interrogation_t *self, uint16_t common_address)
{
size_t i;
for (i = 0U; i < self->broadcast.count; ++i) {
const IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[i];
if (common_address == IEC104_CA_BROADCAST) {
if (entry->_state != STATION_ENDED) { return i; }
} else if (Broadcast_Station_Active(self, i) &&
IEC104_Station_Get_Common_Address(entry->_station) == common_address) { return i; }
}
return self->broadcast.count;
}
/**
* 功能:按原快照顺序寻找尚未交接的确认,包含已结束但仍欠否定COT=9的站。
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值: 返回count表示没有待交接的COT=9,尚须由统一收尾函数检查原回复及FINISHED义务。
* 说明:WAIT不清标志,因此下次仍选同一目标;不得用当前业务index或当前注册表替代此遍历。
* 返回count表示没有待交接的COT=9,尚须由统一收尾函数检查原回复及FINISHED义务。
*/
static size_t Pending_Broadcast_Deactivation(const IEC104_Interrogation_t *self)
{
size_t i;
for (i = 0U; i < self->broadcast.count; ++i) {
if ((self->config.broadcast_states[i]._flags & STATION_DEACTIVATE) != 0U) { return i; }
}
return self->broadcast.count;
}
/**
* 功能:在原任务内保存撤销应答,不要求额外队列槽;第二条重叠撤销在此应答完成前按未匹配拒绝。
* 输入参数:self——本模块实例。
* common_address——ASDU公共地址。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:全局撤销逐站确认:未结束目标(包括未来PENDING)肯定COT=9,已结束目标否定COT=9。
* 原否定ACT_CON仍由共享任务保存并先交接;撤销结果另存标志,不覆盖原回复或终结原因。
* 定向撤销保留其他站进度,待这组撤销确认提交后继续原阶段;不覆盖其他站已有终结原因。
* 调用前须由Find_Activation完成身份、限定词与活动范围匹配;这里不再接受新目标。
*/
static void Deactivate_Broadcast(IEC104_Interrogation_t *self, uint16_t common_address)
{
size_t i;
self->broadcast.cancel_all = common_address == IEC104_CA_BROADCAST;
for (i = 0U; i < self->broadcast.count; ++i) {
IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[i];
bool active = Broadcast_Station_Active(self, i);
if (self->broadcast.cancel_all ||
(active && IEC104_Station_Get_Common_Address(entry->_station) == common_address)) {
/* 必须先保存撤销前的状态对应的肯否定结果,再终结业务。
* 原站已结束时仍欠一条否定确认,但End内部会保留它原来的FINISHED原因。 */
entry->_flags |= STATION_DEACTIVATE;
if (entry->_state == STATION_ENDED) { entry->_flags |= STATION_DEACTIVATE_NEGATIVE; }
else { entry->_flags &= (uint8_t)~STATION_DEACTIVATE_NEGATIVE; }
End_Broadcast_Station(self, i, IEC104_INTERROGATION_FINISH_DEACTIVATED);
}
}
self->broadcast.cancelling = true;
self->broadcast.task->send_waiting = false;
Move_Reply_To_Tail(self, self->broadcast.task);
Flush_Broadcast_Finishes(self);
/* 按成功匹配的一条撤销请求计数,不按目标数或逐站肯否定确认数累计。 */
++self->status.deactivated;
++self->status.cancelled;
}
/**
* 功能:原否定ACT_CON和全部COT=9均交接后才结束撤销;不等待ACK,但保留FINISHED交付义务。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:true也可表示仍欠回复,并非必然已回收。
* Reap或推进下一站均可能释放共享任务, 返回后调用方不能假定原task指针仍有效,须重新选择任务。
* 说明:仅在broadcast.task有效且cancelling为真时调用;true也可表示仍欠回复,并非必然已回收。
* 整轮撤销进入FINISHING,定向撤销则继续其余站;Reap或推进下一站均可能释放共享任务,
* 返回后调用方不能假定原task指针仍有效,须重新选择任务。
*/
static bool Complete_Broadcast_Deactivation(IEC104_Interrogation_t *self)
{
if (self->broadcast.task->phase == IEC104_INTERROGATION_REPLY &&
self->broadcast.task->reply_cause != 0U) { return true; }
if (Pending_Broadcast_Deactivation(self) != self->broadcast.count) { return true; }
self->broadcast.cancelling = false;
if (self->broadcast.cancel_all) {
self->broadcast.stage = BROADCAST_FINISH;
self->broadcast.task->phase = IEC104_INTERROGATION_FINISHING;
Reap_Broadcast(self);
return true;
}
return Broadcast_Current(self)->_state == STATION_ENDED ? Next_Broadcast_Station(self) : true;
}
/**
* 功能:只在Process提交对应COT=9返回OK后调用;WAIT不推进目标,也不清除P/N快照。
* 输入参数:self——本模块实例。
* index——索引。
* 输出参数:self——本模块实例的更新结果。
* 返回值:只在Process提交对应COT=9返回OK后调用;
* 说明:发送层接手不代表已写完或已ACK;此处只完成本模块的交接义务,最后一条后统一收尾。
*/
static bool Advance_Broadcast_Deactivation(IEC104_Interrogation_t *self, size_t index)
{
self->config.broadcast_states[index]._flags &=
(uint8_t)~(STATION_DEACTIVATE | STATION_DEACTIVATE_NEGATIVE);
self->broadcast.task->send_waiting = false;
return Complete_Broadcast_Deactivation(self);
}
/**
* 功能:每次发送只建立临时ASDU视图;
* 输入参数:self——本模块实例。
* request——请求。
* cause——传送原因。
* negative——否定确认标志。
* asdu——ASDU报文。
* 输出参数:asdu——建立借用request原文的ASDU视图;request——原文字段随COT/P/N设置更新。
* 任一步返回false时,不能把本次候选当作完整应答提交。
* 返回值:从任务原文成功建立ASDU视图并设置COT、P/N返回true,任一步失败返回false。
* 说明:WAIT保留紧凑原文和身份,输入Slave事件始终不变。
*/
static bool Prepare_Response(IEC104_Interrogation_t *self, InterrogationResponse *request,
uint8_t cause, bool negative, IEC60870_Asdu_t *asdu)
{
return IEC60870_Asdu_Create_From_Buffer(asdu, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
request->bytes, sizeof(request->bytes)) == IEC60870_ASDU_OK &&
IEC60870_Asdu_Set_COT(asdu, cause) == IEC60870_ASDU_OK &&
IEC60870_Asdu_Set_Negative(asdu, negative) == IEC60870_ASDU_OK;
}
/**
* 功能:仅对ERROR复核正常STOP拒绝,避免在消费DEACTIVATED前误记SEND_ERROR。
* 输入参数:self——本模块实例。
* identity——原会话身份。
* submitted——IEC104_TcpSubmitResult_t值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:仅原会话仍健康、传输已停止且存在待消费通知时返回true;其他情况返回false。
* 说明:须同时确认原代次仍连接、会话/队列无故障、传输已停用且有未读通知;普通新通知不足以放行。
* OK/WAIT沿原路径处理,FATAL可能已发送字节,绝不降级为等待;本函数不消费通知或重置期限。
*/
static bool Defer_For_Stop(IEC104_Interrogation_t *self,
const IEC104_SlaveEventIdentity_t *identity, IEC104_TcpSubmitResult_t submitted)
{
IEC104_TcpServerStatus_t status;
if (submitted != IEC104_TCP_SUBMIT_ERROR) { return false; }
if (identity->slave != self->slave || identity->instance_id != self->session.instance_id ||
identity->generation != self->session.generation ||
IEC104_Slave_Get_Status(self->slave, &status, NULL) != IEC104_TCP_OK ||
status.generation != identity->generation || !status.connected || !status.connection_status_valid ||
!status.asdu_queue_status_valid || status.connection.phase != IEC104_TCP_SESSION_ACTIVE ||
status.connection.fault != IEC104_TCP_FAULT_NONE || status.connection.data_transfer_started ||
status.pending_event_count == 0U) { return false; }
self->status.events_pending = true;
return true;
}
/**
* 功能:尝试接手当前确认,queued用于标识它是否已是本模块最早待答任务;不越过事务屏障或更早回复。
* 输入参数:self——本模块实例。
* request——请求。
* cause——传送原因。
* negative——否定确认标志。
* receive_serial——接收事件序号。
* queued——const InterrogationTask *所指数据。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回REPLY_DEFER、REPLY_FAILED、REPLY_SENT、REPLY_WAIT。
* 说明:SENT只表示发送层接手;DEFER表示通知/次序尚未就绪,WAIT表示本次提交背压,两者均不得视为已回复。
* 会话或发送错误可取消任务,调用方收到FAILED后不能继续借用原任务;业务等级沿受理时的request保存值传递。
*/
static ImmediateReplyResult Try_Immediate_Reply(IEC104_Interrogation_t *self,
InterrogationResponse *request,
uint8_t cause, bool negative, uint64_t receive_serial, const InterrogationTask *queued)
{
IEC60870_Asdu_t asdu;
IEC104_TcpSubmitResult_t submitted;
IEC104_SlaveRequestState_t state;
unsigned first = Find_Reply(self);
if (Confirmation_Blocked(self, request, cause, receive_serial)) { return REPLY_DEFER; }
if (first != IEC104_INTERROGATION_TASK_CAPACITY && &self->tasks[first] != queued) { return REPLY_DEFER; }
state = IEC104_Slave_Check_Request(self->slave, &self->session);
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
if (self->status.events_pending) { return REPLY_DEFER; }
if (state == IEC104_SLAVE_REQUEST_ERROR || !self->status.active || state != IEC104_SLAVE_REQUEST_READY) {
Cancel(self, state == IEC104_SLAVE_REQUEST_ERROR ? IEC104_INTERROGATION_FINISH_SERVICE_ERROR :
IEC104_INTERROGATION_FINISH_CONNECTION_CHANGED);
self->status.active = false;
return REPLY_FAILED;
}
if (!Prepare_Response(self, request, cause, negative, &asdu)) { return REPLY_FAILED; }
submitted = IEC104_Slave_Send_Response_Priority(self->slave, &request->identity, &asdu,
(IEC104_BusinessPriority_t)request->priority);
if (submitted == IEC104_TCP_SUBMIT_OK) {
++self->status.submitted;
if (negative) { ++self->status.negative_submitted; }
self->prefer_interrogation = true;
return REPLY_SENT;
}
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
++self->status.waits;
self->status.waiting = true;
return REPLY_WAIT;
}
if (Defer_For_Stop(self, &request->identity, submitted)) { return REPLY_DEFER; }
Cancel(self, IEC104_INTERROGATION_FINISH_SEND_ERROR);
self->status.active = false;
return REPLY_FAILED;
}
/* 单次只读期限计算的结果,不缓存到任务;已确认广播站总超时决定整轮必须断连。 */
typedef struct {
IEC104_InterrogationFinishReason_t reason;
uint32_t remaining_ms;
bool confirmed_total_expired;
} InterrogationTimeout;
/**
* 功能:将一项期限并入当前最近期限:now/since为单调毫秒,duration为允许时长。
* 输入参数:now——当前时刻。
* since——uint64_t值。
* duration——uint32_t值。
* candidate——IEC104_InterrogationFinishReason_t值。
* timeout——超时状态。
* 输出参数:timeout——超时状态的更新结果。
* 返回值:无。
* 说明:timeout是累积输入输出;reason为NONE表示此前还没有有效候选。
* 用经过时间比较,避免绝对期限相加溢出;0时长禁用,到期剩余值为0。
* 相同剩余时间保留先检查的原因,因此Task_Timeout先检查总期限以确定并发超时的归因。
*/
static void Limit_Timeout(uint64_t now, uint64_t since, uint32_t duration,
IEC104_InterrogationFinishReason_t candidate, InterrogationTimeout *timeout)
{
uint64_t elapsed;
uint32_t left;
if (duration == 0U) { return; }
elapsed = now - since;
left = elapsed >= duration ? 0U : duration - (uint32_t)elapsed;
if (timeout->reason == IEC104_INTERROGATION_FINISH_NONE || left < timeout->remaining_ms) {
timeout->remaining_ms = left;
timeout->reason = candidate;
}
}
/**
* 功能:只读计算task在同一now时刻的最近期限及已确认站超时标志;reason为NONE表示没有启用的期限。
* 输入参数:self——本模块实例。
* task——业务任务。
* now——当前时刻。
* 输出参数:无。
* 返回值:返回timeout的结果。
* 说明:只有尚未终结的激活业务受定时器约束,单帧应答不参加业务超时计算。
* START尚未生成BEGIN时不计业务期限;读取任务的总期限从BEGIN生成起覆盖取数及发送等待。
* 动作命令接受后已执行副作用,CONFIRM不再计业务期限;发送层仍处理连接期限。
* BEGIN/NEED_DATA期限从工作事件入队起计算;首次有效批次发送WAIT后不再计本批取数期限。
* 本函数不触发超时动作,供Expire执行处理和Get_Status计算唤醒时间共用。
*/
static InterrogationTimeout Task_Timeout(const IEC104_Interrogation_t *self,
const InterrogationTask *task, uint64_t now)
{
InterrogationTimeout timeout = {IEC104_INTERROGATION_FINISH_NONE, 0U, false};
if (Is_Broadcast(self, task)) {
size_t i;
/* 当前任务可能已切到后续站的BEGIN,先前已确认站的总期限仍独立有效,不能只查当前站。 */
for (i = 0U; i < self->broadcast.count; ++i) {
const IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[i];
if (entry->_state == STATION_CONFIRMED || entry->_state == STATION_DATA_DONE) {
Limit_Timeout(now, entry->_started_ms, self->config.total_timeout_ms,
IEC104_INTERROGATION_FINISH_TOTAL_TIMEOUT, &timeout);
}
}
/* 此时只汇入了已确认站的总期限;先保存到期事实,再合入当前站的期限。 */
timeout.confirmed_total_expired = timeout.reason == IEC104_INTERROGATION_FINISH_TOTAL_TIMEOUT &&
timeout.remaining_ms == 0U;
if (self->config.broadcast_states[self->broadcast.index]._state == STATION_ENDED) { return timeout; }
}
if (task->request_id == 0U || task->phase == IEC104_INTERROGATION_REPLY ||
task->phase == IEC104_INTERROGATION_FINISHING) { return timeout; }
if (task->phase == IEC104_INTERROGATION_START && !task->event_outstanding) { return timeout; }
/* 已接受的动作可能已经改变计数器,不能因确认排队超时再改发否定确认。
* 这里只停止当前动作站的业务期限;传输期限、STOP和断线仍有效。 */
if (task->phase == IEC104_INTERROGATION_CONFIRM && !self->rules->has_data(task->info.freeze)) { return timeout; }
Limit_Timeout(now, task->started_ms, self->config.total_timeout_ms,
IEC104_INTERROGATION_FINISH_TOTAL_TIMEOUT, &timeout);
if (task->event_outstanding && !task->data_send_waiting) {
bool begin = task->phase == IEC104_INTERROGATION_START;
Limit_Timeout(now, task->application_since_ms,
begin ? self->config.begin_timeout_ms : self->config.data_timeout_ms,
begin ? IEC104_INTERROGATION_FINISH_BEGIN_TIMEOUT : IEC104_INTERROGATION_FINISH_DATA_TIMEOUT,
&timeout);
}
return timeout;
}
/**
* 功能:只检查唯一未终结总召;确认前超时转为否定REPLY,确认后超时关闭原连接并取消。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 返回0为未超时,1为已处理超时,-1为任务已取消但底层关闭失败。
* 说明:已交付BEGIN的FINISHED有预留槽或每站记录,迟到应答随即失效;已终结站不再计算期限。
* 调用方须先确认Slave通知已读空,使先到的STOP/断线/撤销先于超时处理。
* 返回0为未超时,1为已处理超时,-1为任务已取消但底层关闭失败。
*/
static int Expire(IEC104_Interrogation_t *self)
{
unsigned slot = Find_Interrogation(self, 0U);
InterrogationTask *task;
InterrogationTimeout timeout;
if (slot == IEC104_INTERROGATION_TASK_CAPACITY) { return 0; }
task = &self->tasks[slot];
timeout = Task_Timeout(self, task, IEC104_Net_Now_Ms());
if (timeout.reason != IEC104_INTERROGATION_FINISH_NONE && timeout.remaining_ms == 0U) {
++self->status.timeouts;
if (timeout.confirmed_total_expired) {
/* 若超时的是先前已确认站,即使当前站尚在START,也必须按确认后失败结束原连接。 */
return Reject_Connection(self, &task->request.identity, timeout.reason) ? 1 : -1;
}
return Fail_Interrogation(self, task, timeout.reason) ? 1 : -1;
}
return 0;
}
/**
* 功能:查找唯一未终结总召;它可能等待BEGIN或排在错误应答后面,不能只看任务队首。
* 输入参数:self——本模块实例。
* event——事件。
* info——查询信息。
* response_ca——uint16_t值。
* qualifier——限定词。
* 输出参数:无。
* 返回值: 返回原任务供Request复用:单目标可改为撤销确认,多目标须保留已有否定回复并另设每站标志。
* 说明:event/info/qualifier来自已校验的撤销请求,response_ca已解析为实际站CA;
* 原连接代次、OA、TEST和QOI须全部相同,CA按单目标或广播原快照匹配。
* 允许广播激活后定向撤销,也允许广播撤销本站任务;多目标当前站的REPLY不代表整轮已结束。
* 返回原任务供Request复用:单目标可改为撤销确认,多目标须保留已有否定回复并另设每站标志。
* NULL表示没有匹配的未终结激活任务;重叠撤销不能覆盖尚未交接的上一组确认。
*/
static InterrogationTask *Find_Activation(IEC104_Interrogation_t *self,
const IEC104_SlaveEvent_t *event, const IEC60870_AsduInfo_t *info,
uint16_t response_ca, uint8_t qualifier)
{
unsigned i;
for (i = 0U; i < self->count; ++i) {
InterrogationTask *task = &self->tasks[self->order[i]];
if (Is_Broadcast(self, task)) {
if (!self->broadcast.cancelling && task->phase != IEC104_INTERROGATION_FINISHING &&
task->info.generation == event->transport.generation &&
task->info.originator_address == info->originator_address &&
task->info.is_test == (info->is_test != 0U) && task->info.qualifier == qualifier &&
Find_Broadcast_Activation(self, info->common_address) != self->broadcast.count) { return task; }
continue;
}
/* 单目标广播结束后,快照可仍为待发回复保留;它不代表业务仍可撤销。
* 只匹配活动阶段,避免后来的广播撤销覆盖既有否定ACT_CON或撤销确认。 */
if (task->request_id != 0U &&
(task->phase == IEC104_INTERROGATION_START || task->phase == IEC104_INTERROGATION_CONFIRM ||
task->phase == IEC104_INTERROGATION_DATA || task->phase == IEC104_INTERROGATION_TERMINATE) &&
task->info.generation == event->transport.generation &&
(task->info.common_address == response_ca || info->common_address == IEC104_CA_BROADCAST) &&
task->info.originator_address == info->originator_address &&
task->info.is_test == (info->is_test != 0U) && task->info.qualifier == qualifier) { return task; }
}
return NULL;
}
/**
* 功能:解析一个I帧通知中的总召请求,完成布局、地址、QOI和事务状态校验。
* 输入参数:self——本模块实例。
* event——事件。
* identity——原会话身份。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 未启用时或有效的其他Type返回IGNORED;
* 接手、拒绝或满槽丢弃请求均返回HANDLED。
* 说明:未启用时或有效的其他Type返回IGNORED;接手、拒绝或满槽丢弃请求均返回HANDLED。
* 公共头不可用交公共入口处理;总召对象不明确则丢弃,单对象完整但布局非法则仅否定。
* 请求错误和容量耗尽均不取消已有任务;只有原会话或内部服务故障沿用原失败策略。
* 单帧应答先尝试安全提交,未接手才保存;匹配的撤销复用原任务槽。
* 只有空闲时才建立START任务;此时已占用总召资格,Process有事件空位后生成BEGIN。
*/
static IEC104_InterrogationEventResult_t Request(IEC104_Interrogation_t *self,
const IEC104_SlaveEvent_t *event, const IEC104_SlaveEventIdentity_t *identity)
{
IEC60870_AsduInfo_t info;
uint32_t ioa;
uint8_t qualifier, freeze;
InterrogationResponse response;
const uint8_t *data;
uint16_t length;
uint16_t response_ca;
uint8_t reply_cause = 0U;
bool deactivation;
bool overload_counted = false;
bool send_waiting = false;
bool broadcast;
bool known_address;
bool invalid_layout;
size_t station_count;
InterrogationTask *activation;
InterrogationTask *task;
if (!self->status.active) { return IEC104_INTERROGATION_EVENT_IGNORED; }
/* 来源/身份已由Handle_Event验证;先保护长度再读取类型,不替其他业务处理ASDU错误。 */
if (event->transport.data.i_frame.apdu_length <= IEC104_APCI_LEN ||
event->transport.data.i_frame.apdu_length > sizeof(event->transport.data.i_frame.apdu) ||
event->transport.data.i_frame.apdu[IEC104_APCI_LEN] != self->rules->type_id) {
return IEC104_INTERROGATION_EVENT_IGNORED;
}
if (event->asdu_result != IEC60870_ASDU_OK ||
IEC60870_Asdu_Get_Data(&event->asdu, &data, &length) != IEC60870_ASDU_OK ||
!IEC60870_Parse_ASDU_Header(event->asdu.parameters, data, length, &info)) {
return IEC104_INTERROGATION_EVENT_IGNORED;
}
if (info.object_count != 1U || info.information_objects_len < 3U + 1U) {
/* 无唯一完整IOA/QOI,不能猜测或选取多个对象之一应答;HANDLED防止进入未知类型兜底。 */
++self->status.rejected;
return IEC104_INTERROGATION_EVENT_HANDLED;
}
invalid_layout = info.is_sequence != 0U || length != sizeof(response.bytes);
if (invalid_layout) {
/* 只为拒绝应答读取唯一对象;不修改原文。原布局错误必须在匹配撤销/建立激活前拦截。 */
info.is_sequence = 0U;
info.information_objects_len = 3U + 1U;
}
if ((!invalid_layout && IEC60870_Asdu_Parse(event->asdu.parameters, data, length, &info) != IEC60870_ASDU_OK) ||
!self->rules->decode(&info, &ioa, &qualifier, &freeze)) {
++self->status.rejected;
return IEC104_INTERROGATION_EVENT_HANDLED;
}
/* 只决定应答地址,不改变原请求;后续仍按COT优先级决定是否接受及如何否定。 */
response_ca = Resolve_Common_Address(self, info.common_address);
deactivation = self->rules->has_deactivation && info.cause_of_transmission == IEC60870_ASDU_COT_DEACTIVATION;
activation = deactivation && !invalid_layout ? Find_Activation(self, event, &info, response_ca, qualifier) : NULL;
if (activation != NULL) {
response_ca = Is_Broadcast(self, activation) && info.common_address != IEC104_CA_BROADCAST ?
info.common_address : activation->info.common_address;
}
station_count = IEC104_Slave_Get_Station_Count(self->slave);
broadcast = self->config.use_station_registry && info.common_address == IEC104_CA_BROADCAST &&
station_count != 0U;
known_address = activation != NULL || (self->config.use_station_registry ?
IEC104_Slave_Get_Station(self->slave, response_ca) != NULL :
response_ca == self->config.common_address &&
(self->config.station == NULL || IEC104_Station_Is_Registered(self->config.station)));
if (!Copy_Response_Request(self, &response, identity, data, length, response_ca)) {
return IEC104_INTERROGATION_EVENT_ERROR;
}
Classify_Response(self, &response,
self->rules->type_id == IEC60870_ASDU_C_IC_NA_1 && !invalid_layout && known_address &&
info.cause_of_transmission == IEC60870_ASDU_COT_ACTIVATION && ioa == 0U && qualifier == 20U &&
info.is_test == 0U && info.is_negative_confirm == 0U &&
IEC104_Slave_Startup_Is_Pending(self->slave, identity));
if (activation != NULL) { response.priority = activation->request.priority; }
/* 无歧义对象才可回应;错误原因优先级COT -> CA -> IOA -> 布局/QOI/P/N/事务状态。 */
if (info.cause_of_transmission != IEC60870_ASDU_COT_ACTIVATION && !deactivation) {
reply_cause = IEC60870_ASDU_COT_UNKNOWN_CAUSE;
} else if (!known_address) {
reply_cause = IEC60870_ASDU_COT_UNKNOWN_COMMON_ADDRESS;
} else if (ioa != 0U) {
reply_cause = IEC60870_ASDU_COT_UNKNOWN_IOA;
} else if (invalid_layout || !self->rules->qualifier_valid(qualifier) || info.is_negative_confirm != 0U) {
reply_cause = deactivation ? IEC60870_ASDU_COT_DEACTIVATION_CON : IEC60870_ASDU_COT_ACTIVATION_CON;
} else if (deactivation) {
task = activation;
if (task != NULL) {
ImmediateReplyResult sent;
if (Is_Broadcast(self, task)) {
Deactivate_Broadcast(self, info.common_address);
return IEC104_INTERROGATION_EVENT_HANDLED;
}
/* 原位替换为撤销确认,不要求额外任务槽。
* 先保存撤销请求,Finish仍使用原激活的info/id/进度通知应用清理。
* 已提交HIGH的帧按原顺序在确认前发出;本地未提交批次就此丢弃。 */
task->request = response;
Finish(self, task, IEC104_INTERROGATION_FINISH_DEACTIVATED);
task->phase = IEC104_INTERROGATION_REPLY;
task->reply_cause = IEC60870_ASDU_COT_DEACTIVATION_CON;
task->reply_negative = false;
task->data_send_waiting = false;
task->send_waiting = false;
/* 广播撤销终结余下遍历;定向撤销只终结当前站,确认后继续下一站。 */
if (info.common_address == IEC104_CA_BROADCAST && task->stations._owner != NULL) {
(void)IEC104_Slave_StationSnapshot_End(&task->stations);
}
if (task->stations._owner == NULL) { task->request_id = 0U; }
Move_Reply_To_Tail(self, task);
self->status.waiting = false;
++self->status.deactivated;
++self->status.cancelled;
sent = Try_Immediate_Reply(self, &task->request, task->reply_cause, false,
event->transport.data.i_frame.receive_serial, task);
if (sent == REPLY_SENT && !Advance(self, task)) { return IEC104_INTERROGATION_EVENT_ERROR; }
if (sent == REPLY_FAILED) { return IEC104_INTERROGATION_EVENT_ERROR; }
if (sent == REPLY_WAIT) { task->send_waiting = true; }
return IEC104_INTERROGATION_EVENT_HANDLED;
}
reply_cause = IEC60870_ASDU_COT_DEACTIVATION_CON;
} else if (Find_Interrogation(self, 0U) != IEC104_INTERROGATION_TASK_CAPACITY || self->broadcast.task != NULL) {
/* 从保存激活到终结全程占用总召资格;相同/不同QOI都否定,不替换原请求。
* FINISHING虽不再有取数任务,广播状态区仍被未读FINISHED占用,必须继续拒绝新激活。
* 此判断仅作用于Type100激活,其他业务及匹配的COT=8撤销不受忙状态拦截。 */
reply_cause = IEC60870_ASDU_COT_ACTIVATION_CON;
}
/* 发出任何肯定确认前检查整轮状态容量;不足时整轮拒绝,不启动只能覆盖部分站点的广播。 */
if (reply_cause == 0U && broadcast && station_count > 1U &&
station_count > self->config.broadcast_capacity) {
++self->status.overloads;
overload_counted = true;
reply_cause = IEC60870_ASDU_COT_ACTIVATION_CON;
}
/* 合法的新总召没有空槽时改为否定ACT_CON,仍可尝试提交,不影响当前任务。 */
if (reply_cause == 0U && self->count == IEC104_INTERROGATION_TASK_CAPACITY) {
++self->status.overloads;
overload_counted = true;
reply_cause = IEC60870_ASDU_COT_ACTIVATION_CON;
}
if (reply_cause != 0U) {
ImmediateReplyResult sent;
++self->status.rejected;
/* 多站应答先占一个遍历任务,不能发出部分站应答后才发现无处保存余下游标。 */
sent = broadcast ? REPLY_DEFER : Try_Immediate_Reply(self, &response, reply_cause, true,
event->transport.data.i_frame.receive_serial, NULL);
if (sent == REPLY_SENT) { return IEC104_INTERROGATION_EVENT_HANDLED; }
if (sent == REPLY_FAILED) { return IEC104_INTERROGATION_EVENT_ERROR; }
send_waiting = sent == REPLY_WAIT;
if (self->count == IEC104_INTERROGATION_TASK_CAPACITY) {
if (!overload_counted) { ++self->status.overloads; }
++self->status.dropped_requests;
return IEC104_INTERROGATION_EVENT_HANDLED; /* 无法保存/提交的新请求已丢弃;不能重投或断链。 */
}
}
if (reply_cause == 0U && (self->next_request_id == UINT64_MAX ||
(broadcast && station_count > UINT64_MAX - self->next_request_id))) {
return Reject_Connection(self, identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR) ?
IEC104_INTERROGATION_EVENT_HANDLED : IEC104_INTERROGATION_EVENT_ERROR;
}
task = Allocate_Task(self);
if (task == NULL) {
(void)Reject_Connection(self, identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return IEC104_INTERROGATION_EVENT_ERROR;
}
task->request = response;
task->reply_cause = reply_cause;
task->reply_negative = reply_cause != 0U;
task->phase = reply_cause != 0U ? IEC104_INTERROGATION_REPLY : IEC104_INTERROGATION_START;
task->send_waiting = send_waiting;
task->info.generation = event->transport.generation;
task->info.receive_serial = event->transport.data.i_frame.receive_serial;
task->info.common_address = response_ca; /* 合法总召均为本站CA;错误应答保留原错误CA且不交付BEGIN。 */
task->info.originator_address = info.originator_address;
task->info.qualifier = qualifier;
task->info.freeze = freeze;
task->info.data_cause = self->rules->data_cause(qualifier);
task->info.is_test = info.is_test != 0U;
task->info.max_objects_per_asdu = self->config.max_objects_per_asdu;
if (reply_cause == 0U) {
task->request_id = ++self->next_request_id;
}
if (broadcast && reply_cause == 0U && station_count > 1U) {
if (!Capture_Broadcast(self, task)) {
(void)Reject_Connection(self, identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return IEC104_INTERROGATION_EVENT_ERROR;
}
} else if (broadcast) {
/* 单目标无须三阶段状态数组;错误广播仅逐站应答,使用共用快照保存范围和游标即可。 */
if (IEC104_Slave_StationSnapshot_Begin(self->slave, &task->stations) != IEC104_STATION_OK ||
!Bind_Station(self, task, IEC104_Slave_StationSnapshot_Next(&task->stations))) {
(void)Reject_Connection(self, identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return IEC104_INTERROGATION_EVENT_ERROR;
}
} else if (reply_cause == 0U && (self->config.use_station_registry || self->config.station != NULL)) {
IEC104_Station_t *station = self->config.use_station_registry ?
IEC104_Slave_Get_Station(self->slave, response_ca) : self->config.station;
if (!Bind_Station(self, task, station)) {
(void)Reject_Connection(self, identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return IEC104_INTERROGATION_EVENT_ERROR;
}
}
return IEC104_INTERROGATION_EVENT_HANDLED;
}
/**
* 功能:为总召任务生成一次BEGIN或NEED_DATA,并标记等待应用应答;task须处于START或DATA。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:event_outstanding为true时复用现有交互,不重复入队或重置等待起点。
* 单目标BEGIN需要自身和未来FINISHED两个位置;多目标终结另存状态项,BEGIN仅占一个位置。
* 优先将已有终结记录入队;新工作事件不能占用单目标预留位置或挤掉尚未交付的清理通知。
* BEGIN前等FIFO空位不计业务期限,但已占用总召资格;已启用的整体期限从BEGIN生成起算。
* NEED_DATA等FIFO空位仍受已启用的整体期限约束;每次工作事件入队才启动本次应用应答期限。
*/
static void Request_Application(IEC104_Interrogation_t *self, InterrogationTask *task)
{
self->status.waiting = true;
if (task->event_outstanding) { return; }
Flush_Broadcast_Finishes(self);
if (task->phase == IEC104_INTERROGATION_START) {
unsigned needed = Is_Broadcast(self, task) ? 1U : 2U;
if (self->event_count + self->reserved_finishes + needed > IEC104_INTERROGATION_EVENT_CAPACITY) { return; }
if (!Is_Broadcast(self, task)) {
task->finish_reserved = true;
++self->reserved_finishes;
}
Push_Event(self, task, IEC104_INTERROGATION_BEGIN, IEC104_INTERROGATION_FINISH_NONE);
} else {
if (self->event_count + self->reserved_finishes >= IEC104_INTERROGATION_EVENT_CAPACITY) { return; }
Push_Event(self, task, IEC104_INTERROGATION_NEED_DATA, IEC104_INTERROGATION_FINISH_NONE);
}
task->event_outstanding = true;
task->event_delivered = false;
task->data_send_waiting = false;
task->application_since_ms = IEC104_Net_Now_Ms();
if (task->phase == IEC104_INTERROGATION_START) {
task->started_ms = task->application_since_ms;
if (Is_Broadcast(self, task)) { Broadcast_Current(self)->_started_ms = task->started_ms; }
}
}
/**
* 功能:应用应答的共同入口检查;expected指定应答BEGIN还是NEED_DATA,不在这里消费交互。
* 输入参数:self——本模块实例。
* event——事件。
* expected——IEC104_InterrogationEventType_t值。
* matched_task——匹配任务。
* 输出参数:self——本模块实例的更新结果。
* matched_task——匹配任务的更新结果。
* 返回值: 核对实例、请求、批次、类型、阶段和已取出标记,旧事件或重复应答返回STALE。
* Slave仍有通知时返回WAIT,调用方先按FIFO处理它们,防止跳过STOP/撤销/断线。
* 业务超时按确认边界终结,两者均返回STALE;
* 参数/状态查询失败返回ERROR。
* 说明:核对实例、请求、批次、类型、阶段和已取出标记,旧事件或重复应答返回STALE。
* Slave仍有通知时返回WAIT,调用方先按FIFO处理它们,防止跳过STOP/撤销/断线。
* 当前会话失效时取消;业务超时按确认边界终结,两者均返回STALE;参数/状态查询失败返回ERROR。
* OK只表示本次可以继续校验和应用应答;实际请求元数据始终取内部副本,不信任回传字段。
*/
static IEC104_InterrogationReplyResult_t Check_Reply(IEC104_Interrogation_t *self,
const IEC104_InterrogationEvent_t *event, IEC104_InterrogationEventType_t expected,
InterrogationTask **matched_task)
{
InterrogationTask *task;
IEC104_SlaveRequestState_t state;
unsigned slot;
if (!Owned(self) || event == NULL) { return IEC104_INTERROGATION_REPLY_ERROR; }
slot = Find_Interrogation(self, event->request_id);
if (slot == IEC104_INTERROGATION_TASK_CAPACITY) { return IEC104_INTERROGATION_REPLY_STALE; }
task = &self->tasks[slot];
if (event->instance_id != self->instance_id || event->request_id != task->request_id ||
event->type != expected || event->batch_index != task->batch_index ||
!task->event_outstanding || !task->event_delivered ||
(expected == IEC104_INTERROGATION_BEGIN && task->phase != IEC104_INTERROGATION_START) ||
(expected == IEC104_INTERROGATION_NEED_DATA && task->phase != IEC104_INTERROGATION_DATA)) {
return IEC104_INTERROGATION_REPLY_STALE;
}
state = IEC104_Slave_Check_Request(self->slave, &self->session);
if (state == IEC104_SLAVE_REQUEST_ERROR) {
return IEC104_INTERROGATION_REPLY_ERROR;
}
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
if (self->status.events_pending) { return IEC104_INTERROGATION_REPLY_WAIT; }
if (!self->status.active || state != IEC104_SLAVE_REQUEST_READY) {
Cancel(self, IEC104_INTERROGATION_FINISH_CONNECTION_CHANGED);
self->status.active = false;
return IEC104_INTERROGATION_REPLY_STALE;
}
if (Expire(self) != 0) { return IEC104_INTERROGATION_REPLY_STALE; }
*matched_task = task; /* 仅OK交付内部任务地址,调用方不再假定它位于队首。 */
return IEC104_INTERROGATION_REPLY_OK;
}
/**
* 功能:标记当前工作事件已经应答,解除应用等待;只在应答内容校验并接手后调用。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:关闭event_outstanding也停止本次BEGIN/NEED_DATA期限,后续事件会设置新的计时起点。
*/
static void Consume_Reply(IEC104_Interrogation_t *self, InterrogationTask *task)
{
task->event_outstanding = task->event_delivered = false;
task->data_send_waiting = false;
task->send_waiting = false;
self->status.waiting = false;
}
/**
* 功能:Process或Submit_Batch确认发送层已接手ASDU后推进所选任务;发送WAIT/失败时不得调用。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:!Bind_Station(self, task, next) || (task->request_id != 0U && self->next_request_id == UINT64_MAX)时返回false;其余分支返回true、Complete_Broadcast_Deactivation(self)、Next_Broadcast_Station(self)、false。
* 说明:单目标CONFIRM转入DATA;多目标依次遍历确认、数据、终止三阶段。
* DATA由Submit_Batch累计进度;TERMINATE生成FINISHED(COMPLETED),REPLY结束当前站。
* 释放时只移动顺序索引,保持其他任务的槽位和调度顺序;此处不等待主站ACK。
*/
static bool Advance(IEC104_Interrogation_t *self, InterrogationTask *task)
{
bool action_complete = task->phase == IEC104_INTERROGATION_CONFIRM && !self->rules->has_data(task->info.freeze);
task->send_waiting = false;
if (Is_Broadcast(self, task)) {
if (task->phase == IEC104_INTERROGATION_DATA) {
++task->batch_index;
Save_Broadcast_Progress(self);
return true;
}
if (task->phase == IEC104_INTERROGATION_REPLY && self->broadcast.cancelling) {
/* 这里只完成原回复,尚欠逐站COT=9;结束整轮还是恢复其他站由统一收尾函数决定。
* reply_cause清零后,Process才转入逐站COT=9分支;原ACT元数据仍供FINISHED使用。 */
task->reply_cause = 0U; /* 原否定ACT_CON已接手,接着兑现各目标的独立撤销确认。 */
return Complete_Broadcast_Deactivation(self);
}
if (task->phase == IEC104_INTERROGATION_CONFIRM && !action_complete) {
Broadcast_Current(self)->_state = STATION_CONFIRMED;
} else if (task->phase == IEC104_INTERROGATION_TERMINATE || action_complete) {
++self->status.gi_submitted;
Finish(self, task, IEC104_INTERROGATION_FINISH_COMPLETED);
}
return Next_Broadcast_Station(self);
}
if (task->phase == IEC104_INTERROGATION_CONFIRM && !action_complete) {
task->phase = IEC104_INTERROGATION_DATA;
} else if (task->phase == IEC104_INTERROGATION_DATA) {
++task->batch_index;
} else {
if (task->phase == IEC104_INTERROGATION_TERMINATE || action_complete) {
++self->status.gi_submitted;
Finish(self, task, IEC104_INTERROGATION_FINISH_COMPLETED);
}
if (task->stations._owner != NULL) {
IEC104_Station_t *next;
if (task->station != NULL) {
(void)IEC104_Slave_Release_Station(self->slave, task->station);
task->station = NULL;
}
next = IEC104_Slave_StationSnapshot_Next(&task->stations);
if (next != NULL) {
if (!Bind_Station(self, task, next) ||
(task->request_id != 0U && self->next_request_id == UINT64_MAX)) {
return false;
}
if (task->request_id != 0U) {
task->request_id = ++self->next_request_id;
task->phase = IEC104_INTERROGATION_START;
task->reply_cause = 0U;
task->reply_negative = false;
}
task->started_ms = task->application_since_ms = 0U;
task->completion_ticket = 0U;
task->batch_index = task->objects_submitted = 0U;
task->data_send_waiting = false;
return true;
}
}
Remove_Task(self, task);
}
return true;
}
/**
* 功能:库内初始化GI/CI共用配置基础值,设置站地址、批次及应用应答和执行期限。
* 输入参数:config为可写配置对象;NULL时不执行任何操作。
* 输出参数:config——配置的更新结果。
* 返回值:无。
* 说明:不创建实例或占用资源;上层统一入口分别填GI/CI配置,再启用各自的站表策略。
*/
void IEC104_Interrogation_Config_Init_Base(IEC104_InterrogationConfig_t *config)
{
if (config == NULL) { return; }
memset(config, 0, sizeof(*config));
config->common_address = 1U;
config->max_objects_per_asdu = 127U;
config->begin_timeout_ms = 15000U;
config->data_timeout_ms = 15000U;
config->total_timeout_ms = 0U;
}
/**
* 功能:从静态池创建总召实例,复制配置并借用一个有效Slave。
* 输入参数:slave须在本实例整个寿命内保持有效;config可在成功返回后复用。
* 输出参数:无。
* 返回值:新实例句柄;配置非法、Slave无效、重复绑定、池满或编号耗尽时返回NULL。
* 说明:扫描完整静态池拒绝重复绑定,失败不占槽;实例编号在整个进程内不重复。
* 创建时尚无活动会话,后续依靠Handle_Event接收CONNECTED/ACTIVATED建立状态。
*/
IEC104_Interrogation_t *IEC104_Interrogation_Create_With_Rules(IEC104_Slave_t *slave,
const IEC104_InterrogationConfig_t *config, const IEC104_InterrogationRules_t *rules)
{
size_t i;
uintptr_t storage_begin, storage_end;
IEC104_Interrogation_t *free_slot = NULL;
if (rules == NULL || rules->decode == NULL || rules->qualifier_valid == NULL ||
rules->data_cause == NULL || rules->data_allowed == NULL || rules->has_data == NULL ||
config == NULL || (config->use_station_registry && config->station != NULL) ||
(!config->use_station_registry && config->station == NULL &&
(config->common_address == 0U || config->common_address == IEC104_CA_BROADCAST)) ||
config->max_objects_per_asdu == 0U || config->max_objects_per_asdu > 127U ||
IEC104_Slave_Get_Application_Layer_Parameters(slave) == NULL || instance_serial == UINT64_MAX) { return NULL; }
if ((config->broadcast_states == NULL) != (config->broadcast_capacity == 0U) ||
config->broadcast_capacity > SIZE_MAX / sizeof(*config->broadcast_states)) { return NULL; }
storage_begin = (uintptr_t)config->broadcast_states;
if (storage_begin > UINTPTR_MAX - config->broadcast_capacity * sizeof(*config->broadcast_states)) { return NULL; }
storage_end = storage_begin + config->broadcast_capacity * sizeof(*config->broadcast_states);
for (i = 0U; i < IEC104_INTERROGATION_CAPACITY; ++i) {
if (interrogation_pool[i].slave == slave && interrogation_pool[i].rules == rules) { return NULL; }
if (config->broadcast_states != NULL && interrogation_pool[i].slave != NULL) {
const IEC104_InterrogationConfig_t *other = &interrogation_pool[i].config;
uintptr_t other_begin = (uintptr_t)other->broadcast_states;
uintptr_t other_end = other_begin + other->broadcast_capacity * sizeof(*other->broadcast_states);
if (storage_begin < other_end && other_begin < storage_end) { return NULL; }
}
if (free_slot == NULL && interrogation_pool[i].slave == NULL) { free_slot = &interrogation_pool[i]; }
}
if (free_slot != NULL) {
if (config->station != NULL && !IEC104_Station_Is_Registered(config->station)) { return NULL; }
if (config->station != NULL &&
IEC104_Slave_Acquire_Station(slave, config->station) != IEC104_STATION_OK) { return NULL; }
memset(free_slot, 0, sizeof(*free_slot));
free_slot->slave = slave;
free_slot->rules = rules;
free_slot->config = *config;
if (config->station != NULL) {
free_slot->config.common_address = IEC104_Station_Get_Common_Address(config->station);
}
free_slot->instance_id = ++instance_serial;
}
return free_slot;
}
/**
* 功能:释放已经没有协议任务和业务事件的实例槽,不销毁借用的Slave。
* 输入参数:self为Create返回的有效实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:true已释放,句柄失效;false为非法句柄或仍有任务/事件,原状态不变。
* 说明:不会隐式Cancel或丢弃通知;调用方须先取消任务、读完FINISHED并清理应用资源。
*/
bool IEC104_Interrogation_Destroy(IEC104_Interrogation_t *self)
{
if (!Owned(self) || self->count != 0U || self->event_count != 0U) { return false; }
if (self->config.station != NULL &&
IEC104_Slave_Release_Station(self->slave, self->config.station) != IEC104_STATION_OK) { return false; }
memset(self, 0, sizeof(*self));
return true;
}
/**
* 功能:以CANCELLED原因放弃本实例尚未提交的工作,保留终结事件供应用清理。
* 输入参数:self为总召实例;非法句柄无操作。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:不关闭连接、不发送确认或终止,也不撤回发送层已经接手的ASDU。
* 该入口是应用本地取消;主站撤销请求由Handle_Event执行匹配和确认流程。
*/
void IEC104_Interrogation_Cancel(IEC104_Interrogation_t *self)
{
if (Owned(self)) { Cancel(self, IEC104_INTERROGATION_FINISH_CANCELLED); }
}
/**
* 功能:处理应用转交的一个Slave历史通知,更新会话状态或保存总召请求。
* 输入参数:self为有效实例;event须为同一Slave按FIFO取出的原事件或Copy_Event副本。
* 输出参数:self——本模块实例的更新结果。
* 返回值:HANDLED已处理请求(含拒绝/满槽丢弃)或会话变化;IGNORED可交给其他业务;ERROR为参数/处理失败。
* 说明:校验事件所属服务及代次,不自行读取Slave FIFO,不保存调用方事件指针。
* 不调用应用代码;短应答在通知已读空、会话有效、无较早关联确认/可发REPLY时尝试直交。
* 布局错误或满槽只拒绝/丢弃新请求;取消时保留FINISHED,内部服务故障沿用失败策略。
*/
IEC104_InterrogationEventResult_t IEC104_Interrogation_Handle_Event(
IEC104_Interrogation_t *self, const IEC104_SlaveEvent_t *event)
{
IEC104_SlaveEventIdentity_t identity;
/* Slave负责来源和视图校验;本模块额外保持首次绑定的服务实例,不接管复用后的另一服务。 */
if (!Owned(self) || !IEC104_Slave_Get_Event_Identity(self->slave, event, &identity) ||
(self->session.instance_id != 0U && self->session.instance_id != identity.instance_id)) {
return IEC104_INTERROGATION_EVENT_ERROR;
}
self->session.slave = identity.slave;
self->session.instance_id = identity.instance_id;
if (event->transport.type == IEC104_TCP_EVENT_CONNECTED) {
/* TCP连通仅建立新代次;必须再收到ACTIVATED,才能接受本代次总召。 */
Cancel(self, IEC104_INTERROGATION_FINISH_CONNECTION_CHANGED);
self->session.generation = identity.generation;
self->status.active = false;
return IEC104_INTERROGATION_EVENT_HANDLED;
}
if (identity.generation != self->session.generation) {
/* 旧连接遗留的断开、回执或I帧不能改变新连接的业务状态。 */
return IEC104_INTERROGATION_EVENT_IGNORED;
}
switch (event->transport.type) {
case IEC104_TCP_EVENT_ACTIVATED:
self->status.active = true;
return IEC104_INTERROGATION_EVENT_HANDLED;
case IEC104_TCP_EVENT_DEACTIVATED:
case IEC104_TCP_EVENT_DISCONNECTED:
Cancel(self, event->transport.type == IEC104_TCP_EVENT_DEACTIVATED ?
IEC104_INTERROGATION_FINISH_STOPPED : IEC104_INTERROGATION_FINISH_DISCONNECTED);
self->status.active = false;
if (event->transport.type == IEC104_TCP_EVENT_DISCONNECTED) { self->session.generation = 0U; }
return IEC104_INTERROGATION_EVENT_HANDLED;
case IEC104_TCP_EVENT_I_FRAME: return Request(self, event, &identity);
default: return IEC104_INTERROGATION_EVENT_IGNORED; /* ACK回执不触发业务重发。 */
}
}
/**
* 功能:自动推进当前可处理的单帧应答和总召任务,直到空闲或需要等待。
* 输入参数:self为有效实例;调用方不需要提供处理步数。
* 输出参数:self——本模块实例的更新结果。
* 返回值:true为本轮正常结束,包括等待、取消或成功处理超时;false为参数、状态查询、组包或关闭失败。
* 说明:Slave通知未读空时仅设置events_pending,应用先转交网络通知再继续调用。
* START有事件空位时生成BEGIN并开始执行计时;DATA生成NEED_DATA,应用直接提交批次。
* 双方可推进时轮转;总召等应用或业务FIFO空位时仍处理没有确认依赖的单帧应答。
* 每步重查Slave通知,发送过程中新交付的通知也须先处理;只有接手ASDU后才Advance。
* ERROR若确认为原连接正常STOP拒绝,则先让出交付通知;其他ERROR/FATAL仍为SEND_ERROR。
* 发送WAIT保留任务并返回,下轮优先检查单帧应答。
* 本函数不接收新请求、不执行应用代码;广播逐站复用任务,每轮至多2倍任务容量步。
* 网络推进并读空Slave通知后须调用本函数重试;本地变化后按need_process及业务期限安排唤醒。
*/
bool IEC104_Interrogation_Process(IEC104_Interrogation_t *self)
{
IEC104_SlaveRequestState_t state;
unsigned steps;
if (!Owned(self)) { return false; }
for (steps = 0U; steps < 2U * IEC104_INTERROGATION_TASK_CAPACITY; ++steps) {
InterrogationTask *task;
IEC60870_Asdu_t asdu;
InterrogationResponse cancellation;
InterrogationResponse *response;
IEC104_TcpSubmitResult_t submitted;
uint64_t completion_ticket = 0U;
uint8_t cause;
bool negative = false;
unsigned slot;
size_t cancel_index = 0U;
bool cancelling, completing;
int expired;
Flush_Broadcast_Finishes(self);
Reap_Broadcast(self);
state = IEC104_Slave_Check_Request(self->slave, &self->session);
if (state == IEC104_SLAVE_REQUEST_ERROR) {
Cancel(self, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
self->status.active = false;
return false;
}
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
if (self->status.events_pending) { return true; }
self->status.waiting = false;
if (self->count == 0U) { return true; }
if (!self->status.active || state != IEC104_SLAVE_REQUEST_READY) {
Cancel(self, IEC104_INTERROGATION_FINISH_CONNECTION_CHANGED);
self->status.active = false;
return true;
}
expired = Expire(self);
if (expired != 0) {
if (expired < 0 || !self->status.active) { return expired > 0; }
continue; /* 确认前超时仅转为REPLY;重查通知后,本轮即可尝试提交否定确认。 */
}
slot = Select_Task(self);
if (slot == IEC104_INTERROGATION_TASK_CAPACITY) { self->status.waiting = true; return true; }
task = &self->tasks[slot];
/* 共享任务可能同时欠原否定ACT_CON和逐站COT=9;先提交原回复,Advance清掉reply_cause
* 后才选择撤销确认。此门控避免把原否定改写掉,也避免恢复未来站的BEGIN/数据流程。 */
cancelling = Is_Broadcast(self, task) && self->broadcast.cancelling &&
!(task->phase == IEC104_INTERROGATION_REPLY && task->reply_cause != 0U);
response = &task->request;
if (!cancelling && (task->phase == IEC104_INTERROGATION_START || task->phase == IEC104_INTERROGATION_DATA)) {
Request_Application(self, task);
self->prefer_interrogation = false;
continue; /* 应用稍后取事件;继续处理当前已有的单帧应答。 */
}
/* 撤销匹配与入口校验已保证OA/TEST/IOA/QOI等保留字段一致,无需另存新DEACT原文。
* 从原ACT可信副本构造临时应答,仅改目标CA及COT/P/N;不改供FINISHED使用的原业务身份。
* WAIT丢弃临时视图,原任务及每站标志仍在,下次按同一目标和P/N重新构帧。 */
if (cancelling) {
cancel_index = Pending_Broadcast_Deactivation(self);
if (cancel_index == self->broadcast.count) {
if (!Complete_Broadcast_Deactivation(self)) {
Cancel(self, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return false;
}
continue; /* 空确认集正常收尾;原任务可能已释放,重新选任务。 */
}
if (!Copy_Response_Request(self, &cancellation, &task->request.identity, task->request.bytes,
sizeof(task->request.bytes),
IEC104_Station_Get_Common_Address(self->config.broadcast_states[cancel_index]._station))) {
Cancel(self, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return false;
}
response = &cancellation;
cause = IEC60870_ASDU_COT_DEACTIVATION_CON;
negative = (self->config.broadcast_states[cancel_index]._flags & STATION_DEACTIVATE_NEGATIVE) != 0U;
} else if (task->phase == IEC104_INTERROGATION_CONFIRM) {
cause = IEC60870_ASDU_COT_ACTIVATION_CON;
} else if (task->phase == IEC104_INTERROGATION_TERMINATE) {
cause = IEC60870_ASDU_COT_ACTIVATION_TERMINATION;
} else if (task->phase == IEC104_INTERROGATION_REPLY) {
cause = task->reply_cause;
negative = task->reply_negative;
} else {
Cancel(self, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return false;
}
if (!Prepare_Response(self, response, cause, negative, &asdu)) {
(void)Reject_Connection(self, &task->request.identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return false;
}
completing = !cancelling && !negative &&
(task->phase == IEC104_INTERROGATION_TERMINATE ||
(task->phase == IEC104_INTERROGATION_CONFIRM && !self->rules->has_data(task->info.freeze)));
/* 只有成功结束本次业务的应答需要交接凭证;普通确认/否定/撤销不产生成功凭据。
* 读取以ACT_TERM为尾帧,计数量仅冻结/复位动作则以肯定ACT_CON为尾帧。
* 保持FINISHED(COMPLETED)在提交OK时产生,不等待HIGH出队、socket写完或主站ACK;
* 严格优先级只改变排队次序,不把该业务完成点改成交接完成,也不要求跨等级比较票据大小。
* 应用收到该事件后仍可能查到PENDING或CANCELLED,启动放行必须另行确认HANDED。
* WAIT/FATAL不读取输出;局部凭证成功后才保存到原站,随后Advance可能切站或回收任务。 */
submitted = completing ? IEC104_Slave_Send_Response_Tracked_Priority(self->slave, &task->request.identity,
&asdu, &completion_ticket, (IEC104_BusinessPriority_t)task->request.priority) :
IEC104_Slave_Send_Response_Priority(self->slave, &task->request.identity, &asdu,
(IEC104_BusinessPriority_t)task->request.priority);
if (submitted != IEC104_TCP_SUBMIT_OK) {
if (Defer_For_Stop(self, &task->request.identity, submitted)) { return true; }
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
/* 确认/终止/短应答保留原文重试;总召数据仅由Submit_Batch直接提交。 */
++self->status.waits;
self->status.waiting = true;
task->send_waiting = true;
self->prefer_interrogation = false;
} else {
Cancel(self, IEC104_INTERROGATION_FINISH_SEND_ERROR);
self->status.active = false;
}
return true;
}
if (completing) { task->completion_ticket = completion_ticket; }
self->prefer_interrogation = cancelling || task->phase == IEC104_INTERROGATION_REPLY;
++self->status.submitted;
if (negative) { ++self->status.negative_submitted; }
if (!(cancelling ? Advance_Broadcast_Deactivation(self, cancel_index) : Advance(self, task))) {
(void)Reject_Connection(self, &task->request.identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return false;
}
}
return true;
}
/**
* 功能:将最早一条业务事件复制到调用方并从FIFO移除,不执行网络操作。
* 输入参数:self为有效实例;event为非NULL输出对象,接收可独立保存的纯值副本。
* 输出参数:self——本模块实例的更新结果。
* event——事件的更新结果。
* 返回值:READY写出事件;EMPTY表示暂时无事件;ERROR表示参数非法,后两者不改输出。
* 说明:工作事件出队后才允许应答;BEGIN出队同时标记应用已持有本请求,后续须配对FINISHED。
* 业务事件不含自引用指针,因此可以memmove压紧FIFO;协议任务仍通过order维护槽位顺序。
* 每次先补入延迟FINISHED,因此仅反复NextEvent也能读完全部终结通知,无须靠Process补齐。
* 读出最后一条时可能释放广播持有的站点引用;应用若仍需节点/context,须事先独立Acquire。
*/
IEC104_InterrogationNextResult_t IEC104_Interrogation_NextEvent(
IEC104_Interrogation_t *self, IEC104_InterrogationEvent_t *event)
{
InterrogationTask *task = NULL;
if (!Owned(self) || event == NULL) { return IEC104_INTERROGATION_NEXT_ERROR; }
Flush_Broadcast_Finishes(self);
Reap_Broadcast(self);
if (self->event_count == 0U) { return IEC104_INTERROGATION_NEXT_EMPTY; }
if (self->events[0].type != IEC104_INTERROGATION_FINISHED) {
unsigned slot = Find_Interrogation(self, self->events[0].request_id);
if (slot == IEC104_INTERROGATION_TASK_CAPACITY) { return IEC104_INTERROGATION_NEXT_ERROR; }
task = &self->tasks[slot];
}
*event = self->events[0];
--self->event_count;
memmove(self->events, self->events + 1, self->event_count * sizeof(self->events[0]));
if (task != NULL) {
task->event_delivered = true;
if (event->type == IEC104_INTERROGATION_BEGIN) { task->begin_delivered = true; }
if (event->type == IEC104_INTERROGATION_BEGIN && Is_Broadcast(self, task)) {
Broadcast_Current(self)->_flags |= STATION_BEGIN_READ;
}
} else if (self->broadcast.task != NULL && event->type == IEC104_INTERROGATION_FINISHED) {
size_t i;
for (i = 0U; i < self->broadcast.count; ++i) {
IEC104_InterrogationStationState_t *entry = &self->config.broadcast_states[i];
if (entry->_request_id == event->request_id) { entry->_flags |= STATION_FINISH_READ; break; }
}
Reap_Broadcast(self);
}
return IEC104_INTERROGATION_NEXT_READY;
}
/**
* 功能:接收应用对已取出BEGIN事件的接受或拒绝决定。
* 输入参数:event为本实例当前BEGIN的原样副本;accept为true接受、false拒绝。
* 输出参数:self——本模块实例的更新结果。
* 返回值:沿用Check_Reply的WAIT/STALE/ERROR;OK表示决定已消费,不可用同一事件重复应答。
* 说明:接受后转为CONFIRM,等待Process提交肯定ACT_CON;拒绝先生成FINISHED(REJECTED),
* 再将任务转为否定ACT_CON应答。资源由应用读取FINISHED后释放,本函数不执行清理回调。
*/
IEC104_InterrogationReplyResult_t IEC104_Interrogation_Reply_Begin(
IEC104_Interrogation_t *self, const IEC104_InterrogationEvent_t *event, bool accept)
{
InterrogationTask *task;
IEC104_InterrogationReplyResult_t result = Check_Reply(self, event, IEC104_INTERROGATION_BEGIN, &task);
if (result != IEC104_INTERROGATION_REPLY_OK) { return result; }
Consume_Reply(self, task);
if (accept) {
task->phase = IEC104_INTERROGATION_CONFIRM;
if (Is_Broadcast(self, task)) { Broadcast_Current(self)->_state = STATION_ACCEPTED; }
}
else { Reject_Request(self, task, IEC104_INTERROGATION_FINISH_REJECTED); }
return IEC104_INTERROGATION_REPLY_OK;
}
/**
* 功能:校验种类、事件、会话及期限后,先消费BEGIN再执行同步动作,重试同一事件不会再次执行。
* 输入参数:self——本模块实例。
* event——事件。
* rules——规则。
* action——动作回调。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回IEC104_INTERROGATION_REPLY_ERROR、result、IEC104_INTERROGATION_REPLY_OK。
* 说明:action只接收引擎保存的请求元数据,不信任调用方可改写的event.request;禁止回调重入。
* TEST只完成协议过程,不调用真实冻结/复位动作;action失败须保证业务数据未变。
* 接受后保持肯定确认,不在回调之后重新判超时;协议确认不证明测试修改了真实计数器。
*/
IEC104_InterrogationReplyResult_t IEC104_Interrogation_Execute_Action(
IEC104_Interrogation_t *self, const IEC104_InterrogationEvent_t *event,
const IEC104_InterrogationRules_t *rules,
bool (*action)(void *context, const IEC104_InterrogationRequest_t *request), void *context)
{
InterrogationTask *task;
IEC104_InterrogationReplyResult_t result;
bool accepted;
if (!Owned(self) || self->rules != rules || action == NULL) { return IEC104_INTERROGATION_REPLY_ERROR; }
result = Check_Reply(self, event, IEC104_INTERROGATION_BEGIN, &task);
if (result != IEC104_INTERROGATION_REPLY_OK) { return result; }
if (self->rules->has_data(task->info.freeze)) { return IEC104_INTERROGATION_REPLY_ERROR; }
Consume_Reply(self, task);
accepted = task->info.is_test || action(context, &task->info);
if (accepted) {
task->phase = IEC104_INTERROGATION_CONFIRM;
if (Is_Broadcast(self, task)) { Broadcast_Current(self)->_state = STATION_ACCEPTED; }
} else { Reject_Request(self, task, IEC104_INTERROGATION_FINISH_REJECTED); }
return IEC104_INTERROGATION_REPLY_OK;
}
/**
* 功能:验证一次NEED_DATA对应的非空批次,提交到原连接的HIGH应答队列。
* 输入参数:event为当前已取出的NEED_DATA;asdu为应用构造的完整监视信息ASDU。
* 输出参数:self——本模块实例的更新结果。
* 返回值:OK发送层已接手;WAIT通知未读空或发送背压;STALE交互失效/发送失败已取消;ERROR批次非法。
* 说明:按当前目标站验证CA,按原请求验证COT、OA、TEST,按配置检查对象数及计数溢出。
* 发送OK才消费事件并累计进度。发送WAIT不缓存、不推进游标,应用下次重新组包;
* 总召可重取当前值,计数量仍须使用本轮冻结快照。
* 首次有效批次发生发送WAIT后结束本批取数计时;同一交互的重试由应用在网络推进后驱动。
* 非法批次不结束取数计时。成功后原文由发送层持有,不借用应用缓冲;空数据调用Complete_Data。
*/
IEC104_InterrogationReplyResult_t IEC104_Interrogation_Submit_Batch(
IEC104_Interrogation_t *self, const IEC104_InterrogationEvent_t *event,
const IEC60870_Asdu_t *asdu)
{
InterrogationTask *task;
IEC60870_AsduInfo_t info;
const uint8_t *data;
uint16_t length;
IEC104_TcpSubmitResult_t submitted;
const IEC60870_AppLayerParameters_t *parameters;
IEC104_InterrogationReplyResult_t result = Check_Reply(self, event, IEC104_INTERROGATION_NEED_DATA, &task);
if (result != IEC104_INTERROGATION_REPLY_OK) { return result; }
parameters = IEC104_Slave_Get_Application_Layer_Parameters(self->slave);
if (asdu == NULL || asdu->parameters == NULL ||
asdu->parameters->sizeOfCOT != 2 || asdu->parameters->sizeOfCA != 2 ||
asdu->parameters->sizeOfIOA != 3 ||
IEC60870_Asdu_Get_Data(asdu, &data, &length) != IEC60870_ASDU_OK ||
length > IEC104_MAX_ASDU_LEN ||
IEC60870_Asdu_Parse(parameters, data, length, &info) != IEC60870_ASDU_OK ||
!self->rules->data_allowed(&info, task->info.freeze) || info.object_count == 0U ||
info.object_count > self->config.max_objects_per_asdu ||
info.cause_of_transmission != task->info.data_cause ||
info.common_address != task->info.common_address ||
info.originator_address != task->info.originator_address ||
info.is_test != (uint8_t)task->info.is_test || info.is_negative_confirm != 0U ||
task->batch_index == SIZE_MAX || task->objects_submitted > SIZE_MAX - info.object_count) {
return IEC104_INTERROGATION_REPLY_ERROR;
}
/* HIGH可在NORMAL非空时接手;WAIT不缓存本批旧值,应用重读实时值后再试。
* 严格模式按冻结业务等级选帧,兼容模式按配额;两者均不保证不同业务采样值的时间先后。 */
submitted = IEC104_Slave_Send_Response_Priority(self->slave, &task->request.identity, asdu,
(IEC104_BusinessPriority_t)task->request.priority);
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
task->data_send_waiting = true;
task->send_waiting = true;
self->status.waiting = true;
++self->status.waits;
return IEC104_INTERROGATION_REPLY_WAIT;
}
if (submitted != IEC104_TCP_SUBMIT_OK) {
if (Defer_For_Stop(self, &task->request.identity, submitted)) {
return IEC104_INTERROGATION_REPLY_WAIT; /* 仅等待STOP通知,不算发送背压,不停止取数计时。 */
}
Cancel(self, IEC104_INTERROGATION_FINISH_SEND_ERROR);
self->status.active = false;
return IEC104_INTERROGATION_REPLY_STALE;
}
task->objects_submitted += info.object_count;
++self->status.submitted;
Consume_Reply(self, task);
(void)Advance(self, task); /* DATA仅递增批次,不切换站点或释放资源。 */
self->prefer_interrogation = false;
return IEC104_INTERROGATION_REPLY_OK;
}
/**
* 功能:应答当前NEED_DATA,声明当前站已没有更多总召数据。
* 输入参数:event须为当前已取出的NEED_DATA,不能使用BEGIN或已经交付过批次的旧事件。
* 输出参数:self——本模块实例的更新结果。
* 返回值:OK已消费交互;单目标转TERMINATE,多目标继续下一站数据或进入终止遍历。
* 说明:此处不发送ACT_TERM;后续Process提交成功才产生FINISHED(COMPLETED),发送等待时保留任务。
* 应用可在OK后释放本站取数游标供下一站使用;迟到的FINISHED须按请求身份清理,避免误清新站。
*/
IEC104_InterrogationReplyResult_t IEC104_Interrogation_Complete_Data(
IEC104_Interrogation_t *self, const IEC104_InterrogationEvent_t *event)
{
InterrogationTask *task;
IEC104_InterrogationReplyResult_t result = Check_Reply(self, event, IEC104_INTERROGATION_NEED_DATA, &task);
if (result != IEC104_INTERROGATION_REPLY_OK) { return result; }
Consume_Reply(self, task);
if (Is_Broadcast(self, task)) {
Save_Broadcast_Progress(self);
Broadcast_Current(self)->_state = STATION_DATA_DONE;
if (!Next_Broadcast_Station(self)) {
(void)Reject_Connection(self, &task->request.identity, IEC104_INTERROGATION_FINISH_SERVICE_ERROR);
return IEC104_INTERROGATION_REPLY_ERROR;
}
return IEC104_INTERROGATION_REPLY_OK;
}
task->phase = IEC104_INTERROGATION_TERMINATE;
return IEC104_INTERROGATION_REPLY_OK;
}
/**
* 功能:应用在准备数据源或取得数据失败时,按肯定确认的提交边界终结本次总召。
* 输入参数:event为当前已取出且尚未应答的BEGIN或NEED_DATA。
* 输出参数:self——本模块实例的更新结果。
* 返回值:WAIT要求先处理Slave通知;STALE表示交互已失效;ERROR为检查或关闭失败。
* 通过检查后,BEGIN失败转为否定REPLY并保留连接;NEED_DATA失败关闭原连接。
* OK表示失败已处理,否定确认由Process提交;若关闭失败返回ERROR,任务仍已取消,不能重试。
* 说明:两种路径均保留SOURCE_ERROR并交付FINISHED供应用清理,不发送成功ACT_TERM。
*/
IEC104_InterrogationReplyResult_t IEC104_Interrogation_Fail_Request(
IEC104_Interrogation_t *self, const IEC104_InterrogationEvent_t *event)
{
IEC104_InterrogationReplyResult_t result;
InterrogationTask *task;
if (event == NULL) { return IEC104_INTERROGATION_REPLY_ERROR; }
if (event->type != IEC104_INTERROGATION_BEGIN && event->type != IEC104_INTERROGATION_NEED_DATA) {
return Owned(self) ? IEC104_INTERROGATION_REPLY_STALE : IEC104_INTERROGATION_REPLY_ERROR;
}
result = Check_Reply(self, event, event->type, &task);
if (result != IEC104_INTERROGATION_REPLY_OK) { return result; }
return Fail_Interrogation(self, task, IEC104_INTERROGATION_FINISH_SOURCE_ERROR) ?
IEC104_INTERROGATION_REPLY_OK : IEC104_INTERROGATION_REPLY_ERROR;
}
/**
* 功能:只读保留在任务中的等级;应用自行判断本地准备是否仍可立即推进,不借本查询执行业务。
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:返回priority的结果。
* 说明:本查询不排除BEGIN/NEED_DATA等应用等待或发送WAIT,也不触发Process;结果不能直接充当就绪位。
* 纯FINISHING只欠清理通知,不应凭其原等级阻挡低级业务;仍有协议工作的等待项则保留原等级。
*/
IEC104_BusinessPriority_t IEC104_Interrogation_Get_Pending_Priority(const IEC104_Interrogation_t *self)
{
IEC104_BusinessPriority_t priority = IEC104_BUSINESS_PRIORITY_NONE;
unsigned i;
if (!Owned(self)) { return priority; }
for (i = 0U; i < self->count; ++i) {
const InterrogationTask *task = &self->tasks[self->order[i]];
if (task->phase != IEC104_INTERROGATION_FINISHING &&
(priority == IEC104_BUSINESS_PRIORITY_NONE || task->request.priority < priority)) {
priority = (IEC104_BusinessPriority_t)task->request.priority;
}
}
return priority;
}
/**
* 功能:组合会话状态、累计统计、活动总召进度及最近业务期限,生成独立状态副本。
* 输入参数:self为有效实例;status为非NULL输出对象。
* 输出参数:status——状态快照的更新结果。
* 返回值:true已写出快照;false为非法句柄/NULL,输出保持不变。
* 说明:phase和进度优先描述当前站;收尾为FINISHING,仅有应答时REPLY,无任务时IDLE。
* 尚未生成BEGIN不计业务期限;timer_active为false时剩余值无意义。
* 实时查询Slave通知和本地可推进任务;need_process不等于!waiting,不保证发送接手。
* 只读取当前单调时钟及服务状态,不触发超时、发送或事件入队。
*/
bool IEC104_Interrogation_Get_Status(const IEC104_Interrogation_t *self,
IEC104_InterrogationStatus_t *status)
{
const InterrogationTask *task;
IEC104_SlaveRequestState_t state;
unsigned slot;
InterrogationTimeout timeout;
if (!Owned(self) || status == NULL) { return false; }
slot = Find_Interrogation(self, 0U);
task = slot != IEC104_INTERROGATION_TASK_CAPACITY ? &self->tasks[slot] :
(self->count != 0U ? &self->tasks[self->order[0]] : NULL);
*status = self->status;
status->gi_pending = slot != IEC104_INTERROGATION_TASK_CAPACITY;
status->generation = self->session.generation;
status->pending_requests = self->count;
status->pending_events = self->event_count + Pending_Broadcast_Finishes(self);
status->phase = task != NULL ? task->phase : IEC104_INTERROGATION_IDLE;
status->batch_index = task != NULL ? task->batch_index : 0U;
status->objects_submitted = task != NULL ? task->objects_submitted : 0U;
status->data_send_waiting = task != NULL && task->data_send_waiting;
status->application_waiting = task != NULL && task->event_outstanding && !task->data_send_waiting;
if (task != NULL && task->phase != IEC104_INTERROGATION_REPLY &&
!Interrogation_Can_Progress(self, task)) { status->waiting = true; }
status->timer_active = false;
status->timeout_remaining_ms = 0U;
if (task != NULL) {
timeout = Task_Timeout(self, task, IEC104_Net_Now_Ms());
if (timeout.reason != IEC104_INTERROGATION_FINISH_NONE) {
status->timer_active = true;
status->timeout_remaining_ms = timeout.remaining_ms;
}
}
/* 只查询Slave通知,不消费或发送;不能跨过未读STOP/撤销推进旧业务。
* 选择规则与Process一致,避免把等应用的总召误当成阻塞所有短应答的队首。
* WAIT只抑制本地空转;网络推进后调用方仍须显式Process重试,不以本标志跳过。 */
state = IEC104_Slave_Check_Request(self->slave, &self->session);
status->events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
slot = Select_Task(self);
status->need_process = self->count != 0U && !status->events_pending &&
(state != IEC104_SLAVE_REQUEST_READY || !status->active ||
(status->timer_active && status->timeout_remaining_ms == 0U) ||
(slot != IEC104_INTERROGATION_TASK_CAPACITY && !self->tasks[slot].send_waiting));
/* 仅剩终结事件交付时由NextEvent推进;pending_events负责唤醒,重复Process不能代替应用读取。 */
if (self->broadcast.task != NULL && self->broadcast.stage == BROADCAST_FINISH &&
!self->broadcast.cancelling && self->count == 1U) { status->need_process = false; }
return true;
}