759 lines
37 KiB
C
759 lines
37 KiB
C
/*
|
||
* IEC104 Type102读命令:固定槽FIFO、会话隔离及受理到提交前的期限。
|
||
*
|
||
* 入口分工:Handle_Event只校验/保存请求;Process只清理与发送错误回复;
|
||
* Execute_Next才调用应用lookup,Get_Status只导出调度快照。全部与Slave串行调用。
|
||
*
|
||
* 任务不变量:order[0..count)唯一列出所有occupied槽;稳定状态的READ_VALUE持有原站引用,
|
||
* READ_REPLY只需请求副本。发送/取值只能操作队首,超时扫描可以移除任意到期槽。
|
||
* 数据应答仅存在于Execute_Next栈上,提交WAIT丢弃值但保留READ_VALUE;
|
||
* UNKNOWN在原槽转READ_REPLY并立即释放引用,后续仅重发47,不再取值。
|
||
*
|
||
* 本模块完成点是发送层接手;不等待ACK,也不向应用提供“成功上报后清标志”回调。
|
||
* 公共契约见IEC104_Read.h;流程及验证见docs/104/IEC104_Read_设计架构.md。
|
||
*/
|
||
#include "IEC104_Read.h"
|
||
#include "IEC104_TcpServer_Config.h"
|
||
#include "IEC104_Net.h"
|
||
#include "IEC104_AsduQueue.h"
|
||
#include <string.h>
|
||
|
||
#ifndef IEC104_READ_CAPACITY
|
||
#define IEC104_READ_CAPACITY IEC104_TCP_SERVER_CAPACITY
|
||
#endif
|
||
#ifndef IEC104_READ_TASK_CAPACITY
|
||
#define IEC104_READ_TASK_CAPACITY 4U
|
||
#endif
|
||
_Static_assert(IEC104_READ_CAPACITY > 0U, "Read needs instance storage");
|
||
_Static_assert(IEC104_READ_TASK_CAPACITY > 0U && IEC104_READ_TASK_CAPACITY <= UINT32_MAX / 2U,
|
||
"Read needs bounded task storage");
|
||
|
||
/**
|
||
* 功能:专项测试只替换“余量快照”和“提交”两个边界;会话检查仍使用真实Slave。
|
||
* 输入参数:self——有效句柄;status——非NULL输出存储;error——可选诊断。
|
||
* 输出参数:status——状态快照的更新结果。
|
||
* error——错误诊断的更新结果。
|
||
* 返回值:OK写入status,失败保持输出;Create后、Init失败后和Close后均可查询。
|
||
* 说明:生产编译不定义此宏,也不保留钩子函数指针或测试符号。
|
||
*/
|
||
#ifdef IEC104_READ_TEST_HOOKS
|
||
extern IEC104_TcpResult_t IEC104_Read_Test_Get_Status(const IEC104_Slave_t *slave,
|
||
IEC104_TcpServerStatus_t *status, IEC104_TcpError_t *error);
|
||
/**
|
||
* 功能:使用默认业务等级向请求所属连接提交应答。
|
||
* 输入参数:self/identity——从站服务及请求身份;asdu——待提交的应答ASDU。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:OK已复制接手;WAIT未接手;ERROR为身份或ASDU非法;FATAL为连接故障。
|
||
* 说明:可直接交接或进入HIGH队列;本入口不返回票据,成功不表示对端已确认。
|
||
*/
|
||
extern IEC104_TcpSubmitResult_t IEC104_Read_Test_Send_Response(IEC104_Slave_t *slave,
|
||
const IEC104_SlaveEventIdentity_t *identity, const IEC60870_Asdu_t *response);
|
||
#define READ_ROOM_STATUS IEC104_Read_Test_Get_Status
|
||
#define READ_SEND_RESPONSE IEC104_Read_Test_Send_Response
|
||
#else
|
||
#define READ_ROOM_STATUS IEC104_Slave_Get_Status
|
||
/* 读命令在12级业务优先级中扩展与非初始化召唤同级,不据返回数据Type改变应答等级。 */
|
||
#define READ_SEND_RESPONSE(s, i, a) IEC104_Slave_Send_Response_Priority(s, i, a, IEC104_BUSINESS_PRIORITY_INTERROGATION)
|
||
#endif
|
||
|
||
/* 0保留给清零后的空槽;occupied决定槽是否有效,不借phase代替占用判断。 */
|
||
enum { READ_VALUE = 1, READ_REPLY = 2 };
|
||
typedef struct {
|
||
IEC104_SlaveEventIdentity_t identity; /* 原Slave实例及TCP代次,提交时不改绑当前连接。 */
|
||
IEC104_Station_t *station; /* READ_VALUE持有一个引用;释放或转REPLY后置NULL。 */
|
||
uint64_t receive_serial, accepted_ms; /* 诊断流水号;固定期限起点,重试不刷新。 */
|
||
uint8_t bytes[9]; /* 规范Type102副本;仅REPLY构造时允许改其中COT/P-N。 */
|
||
uint8_t phase, cause; /* READ_VALUE/READ_REPLY;REPLY的45/46/47原因。 */
|
||
bool occupied, send_waiting; /* 后者只表示该队首上次受发送容量阻塞。 */
|
||
} ReadTask;
|
||
|
||
struct IEC104_Read {
|
||
IEC104_Slave_t *slave; /* 借用,必须晚于Read销毁。 */
|
||
IEC104_SlaveEventIdentity_t session; /* 由已分派通知建立,不能只读传输最终状态猜测。 */
|
||
IEC104_ReadConfig_t config;
|
||
IEC104_ReadStatus_t status; /* 持久计数/激活标志;队列与期限字段由Get_Status合成。 */
|
||
ReadTask tasks[IEC104_READ_TASK_CAPACITY];
|
||
unsigned order[IEC104_READ_TASK_CAPACITY], count; /* FIFO下标/占槽数,任务本体地址稳定。 */
|
||
bool in_use, in_lookup; /* 池占用;仅保护本实例的修改入口,不是线程锁或Slave全局锁。 */
|
||
};
|
||
static IEC104_Read_t read_pool[IEC104_READ_CAPACITY];
|
||
|
||
/**
|
||
* 功能:先用地址匹配池槽再解引用,NULL/池外指针安全返回false;
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:无。
|
||
* 返回值:true表示句柄属于当前占用的静态实例槽;NULL、池外地址或未占用槽返回false。
|
||
* 说明:销毁后的旧句柄不得复用。
|
||
*/
|
||
static bool Owned(const IEC104_Read_t *self)
|
||
{
|
||
unsigned i;
|
||
for (i = 0U; i < IEC104_READ_CAPACITY; ++i) {
|
||
if (self == &read_pool[i]) { return self->in_use; }
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 功能:归还本任务Acquire的那一个引用并清指针,随后Remove_Task不会重复Release。
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* 输出参数:task——业务任务的更新结果。
|
||
* 返回值:无。
|
||
* 说明:Release可能使已删除节点立即可复用;本任务之后不能再依赖此前借用的原站/context。
|
||
*/
|
||
static void Release_Station(IEC104_Read_t *self, ReadTask *task)
|
||
{
|
||
if (task->station != NULL) {
|
||
(void)IEC104_Slave_Release_Station(self->slave, task->station);
|
||
task->station = NULL;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:task必须是本实例的占用槽。释放站点、删除顺序下标并清空槽,不搬移其他任务。
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* task——业务任务的更新结果。
|
||
* 返回值:无。
|
||
* 说明:计数由结束原因所在分支增加;这里不把超时、取消和应用失败混记。
|
||
* 队首变化即清除新队首的send_waiting,旧任务的背压不能抑制新任务首次尝试。
|
||
*/
|
||
static void Remove_Task(IEC104_Read_t *self, ReadTask *task)
|
||
{
|
||
unsigned i, slot = (unsigned)(task - self->tasks);
|
||
bool was_head = self->count != 0U && self->order[0] == slot;
|
||
Release_Station(self, task);
|
||
for (i = 0U; i < self->count; ++i) {
|
||
if (self->order[i] == slot) {
|
||
memmove(self->order + i, self->order + i + 1U,
|
||
(self->count - i - 1U) * sizeof(self->order[0]));
|
||
--self->count;
|
||
break;
|
||
}
|
||
}
|
||
memset(task, 0, sizeof(*task));
|
||
if (was_head && self->count != 0U) { self->tasks[self->order[0]].send_waiting = false; }
|
||
}
|
||
|
||
/**
|
||
* 功能:内部统一收尾:每个仍占槽的READ/REPLY计一次cancelled,不改变激活状态或已提交帧。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:调用方按原因决定是否active=false;公共Cancel允许本会话继续接纳新请求。
|
||
*/
|
||
static void Cancel(IEC104_Read_t *self)
|
||
{
|
||
while (self->count != 0U) {
|
||
++self->status.cancelled;
|
||
Remove_Task(self, &self->tasks[self->order[0]]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:查询并归一化会话状态,同时处理ERROR/STALE的整队列取消。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值: 返回READY才可继续取值或提交;
|
||
* ERROR/STALE返回前可能已清空全部槽。
|
||
* 说明:WAIT_EVENTS优先于最终连接状态:不能越过同代次内尚未分派的STOP/START执行旧请求。
|
||
* 返回READY才可继续取值或提交;ERROR/STALE返回前可能已清空全部槽。
|
||
*/
|
||
static IEC104_SlaveRequestState_t Check_Session(IEC104_Read_t *self)
|
||
{
|
||
IEC104_SlaveRequestState_t state = IEC104_Slave_Check_Request(self->slave, &self->session);
|
||
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR ||
|
||
(state != IEC104_SLAVE_REQUEST_WAIT_EVENTS && (!self->status.active || state != IEC104_SLAVE_REQUEST_READY))) {
|
||
Cancel(self);
|
||
self->status.active = false;
|
||
return state == IEC104_SLAVE_REQUEST_ERROR ? state : IEC104_SLAVE_REQUEST_STALE;
|
||
}
|
||
return state;
|
||
}
|
||
|
||
/**
|
||
* 功能:调用前须确认期限非0。先检查64位倒退/到期,再将已证明小于期限的差值收窄到32位。
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* now——当前时刻。
|
||
* 输出参数:无。
|
||
* 返回值:按处理分支返回0U、self->config.request_timeout_ms - (uint32_t)(now - task->accepted_ms)。
|
||
* 说明:接受时刻固定,重试不得重置期限;now与accepted_ms相等时仍有完整预算。
|
||
*/
|
||
static uint32_t Remaining(const IEC104_Read_t *self, const ReadTask *task, uint64_t now)
|
||
{
|
||
if (now < task->accepted_ms || now - task->accepted_ms >= self->config.request_timeout_ms) { return 0U; }
|
||
return self->config.request_timeout_ms - (uint32_t)(now - task->accepted_ms);
|
||
}
|
||
|
||
/**
|
||
* 功能:用同一采样扫描全部占槽任务,保证Get_Status报告的最小期限都能被处理。
|
||
* 输入参数:self——本模块实例。
|
||
* now——当前时刻。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:移除后下标i处已换成下一项,不能自增跳过它;结束后调用方必须重新检查空队列/队首。
|
||
*/
|
||
static void Expire(IEC104_Read_t *self, uint64_t now)
|
||
{
|
||
unsigned i = 0U;
|
||
if (self->config.request_timeout_ms == 0U) { return; }
|
||
while (i < self->count) {
|
||
ReadTask *task = &self->tasks[self->order[i]];
|
||
if (Remaining(self, task, now) == 0U) {
|
||
++self->status.timeouts;
|
||
Remove_Task(self, task);
|
||
} else { ++i; }
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:Send_Response可能先处理已缓存的STOP;只有ERROR且原连接仍健康、已停止传输、
|
||
* 输入参数:self——本模块实例。
|
||
* identity——原会话身份。
|
||
* submitted——IEC104_TcpSubmitResult_t值。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:仅原会话仍健康、传输已停止且存在待消费通知时返回true;其他情况返回false。
|
||
* 说明:还有未读通知时让出,由DEACTIVATED按FIFO取消任务。普通ERROR和FATAL不能重试。
|
||
* 这里只读状态并设置提示;不消费通知,不替调用者推进Slave。
|
||
*/
|
||
static bool Defer_For_Stop(IEC104_Read_t *self, const IEC104_SlaveEventIdentity_t *identity,
|
||
IEC104_TcpSubmitResult_t submitted)
|
||
{
|
||
IEC104_TcpServerStatus_t status;
|
||
if (submitted != IEC104_TCP_SUBMIT_ERROR || identity->slave != self->slave ||
|
||
identity->instance_id != self->session.instance_id || identity->generation != self->session.generation ||
|
||
IEC104_Slave_Get_Status(self->slave, &status, NULL) != IEC104_TCP_OK ||
|
||
status.generation != identity->generation || !status.connected || !status.connection_status_valid ||
|
||
!status.asdu_queue_status_valid || status.connection.phase != IEC104_TCP_SESSION_ACTIVE ||
|
||
status.connection.fault != IEC104_TCP_FAULT_NONE || status.connection.data_transfer_started ||
|
||
status.pending_event_count == 0U) { return false; }
|
||
self->status.events_pending = true;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:前置:任务为队首,已完成会话及最后一次期限检查;response只在调用内借用。
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* response——应答。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* task——业务任务的更新结果。
|
||
* 返回值: true表示原任务已移除(提交成功或发送故障取消),不等同发送成功;
|
||
* false表示WAIT或正常STOP待通知,任务保持占槽。
|
||
* 调用者不得在true后继续解引用task。
|
||
* 说明:true表示原任务已移除(提交成功或发送故障取消),不等同发送成功;
|
||
* false表示WAIT或正常STOP待通知,任务保持占槽。调用者不得在true后继续解引用task。
|
||
* 提交OK后原文已由发送层接手,直接累计并释放,不再按新的时钟值追认超时。
|
||
*/
|
||
static bool Submit(IEC104_Read_t *self, ReadTask *task, const IEC60870_Asdu_t *response)
|
||
{
|
||
IEC104_TcpSubmitResult_t submitted = READ_SEND_RESPONSE(self->slave, &task->identity, response);
|
||
if (submitted == IEC104_TCP_SUBMIT_OK) {
|
||
++self->status.submitted;
|
||
if (task->phase == READ_REPLY) { ++self->status.negative_submitted; }
|
||
else { ++self->status.answered; }
|
||
Remove_Task(self, task);
|
||
return true;
|
||
}
|
||
if (submitted == IEC104_TCP_SUBMIT_WAIT) {
|
||
++self->status.waits;
|
||
task->send_waiting = true;
|
||
return false;
|
||
}
|
||
if (Defer_For_Stop(self, &task->identity, submitted)) { return false; }
|
||
Cancel(self);
|
||
self->status.active = false;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:前置:队首READ_REPLY且station=NULL,会话/期限已检查。
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* task——业务任务的更新结果。
|
||
* 返回值: 返回1:任务已移除;
|
||
* 说明:错误回复只借用槽内9字节副本,经Set_COT/Set_Negative原位改头;重试重复设置幂等,
|
||
* 不需要额外数据缓存,不改变TEST/OA/CA/IOA。原Slave事件从未被修改。
|
||
* 返回1:任务已移除;0:保留等待;-1:内部组包失败且已取消、停用实例。
|
||
*/
|
||
static int Submit_Reply(IEC104_Read_t *self, ReadTask *task)
|
||
{
|
||
IEC60870_Asdu_t reply;
|
||
if (IEC60870_Asdu_Create_From_Buffer(&reply, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
|
||
task->bytes, sizeof(task->bytes)) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Set_COT(&reply, task->cause) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Set_Negative(&reply, 1) != IEC60870_ASDU_OK) {
|
||
Cancel(self);
|
||
self->status.active = false;
|
||
return -1;
|
||
}
|
||
return Submit(self, task, &reply) ? 1 : 0;
|
||
}
|
||
|
||
/**
|
||
* 功能:选一个空槽并把下标追加到FIFO;调用方随后填身份和阶段,申请站点失败须Remove_Task回滚。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值: 满槽返回NULL且不改队列;
|
||
* 说明:满槽返回NULL且不改队列;正常入口已先检查count,用于防御内部状态不一致。
|
||
*/
|
||
static ReadTask *Allocate_Task(IEC104_Read_t *self)
|
||
{
|
||
unsigned i;
|
||
for (i = 0U; i < IEC104_READ_TASK_CAPACITY; ++i) {
|
||
if (!self->tasks[i].occupied) {
|
||
ReadTask *task = &self->tasks[i];
|
||
memset(task, 0, sizeof(*task));
|
||
task->occupied = true;
|
||
self->order[self->count++] = i;
|
||
return task;
|
||
}
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
/**
|
||
* 功能:Slave固定使用标准104参数,IOA为3字节小端;
|
||
* 输入参数:data——数据存储。
|
||
* 输出参数:无。
|
||
* 返回值:返回(uint32_t)data[0] | ((uint32_t)data[1] << 8) | ((uint32_t)data[2] << 16)的结果。
|
||
* 说明:只读Parse已证明完整的对象区。
|
||
*/
|
||
static uint32_t Read_IOA(const uint8_t *data)
|
||
{
|
||
return (uint32_t)data[0] | ((uint32_t)data[1] << 8) | ((uint32_t)data[2] << 16);
|
||
}
|
||
|
||
/**
|
||
* 功能:仅由Handle_Event在核对I帧归属/当前代次后调用,不执行应用lookup。
|
||
* 输入参数:self——本模块实例。
|
||
* event——事件。
|
||
* identity——原会话身份。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:按处理分支返回IEC104_READ_EVENT_IGNORED、IEC104_READ_EVENT_HANDLED、IEC104_READ_EVENT_ERROR。
|
||
* 说明:畸形请求不占槽;语义错误和合法READ共用FIFO。rejected先于满槽判断,
|
||
* 所以错误请求遇满槽会同时计rejected、overloads和dropped_requests。
|
||
*/
|
||
static IEC104_ReadEventResult_t Request(IEC104_Read_t *self, const IEC104_SlaveEvent_t *event,
|
||
const IEC104_SlaveEventIdentity_t *identity)
|
||
{
|
||
IEC60870_AsduInfo_t info;
|
||
const uint8_t *data;
|
||
uint16_t length;
|
||
IEC104_Station_t *station;
|
||
ReadTask *task;
|
||
uint8_t cause = 0U;
|
||
if (!self->status.active || event->asdu_result != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Get_Data(&event->asdu, &data, &length) != IEC60870_ASDU_OK ||
|
||
length == 0U || data[0] != 102U) { return IEC104_READ_EVENT_IGNORED; }
|
||
/* 畸形请求优先静默丢弃,不能被COT/CA/IOA错误变成可应答请求。 */
|
||
if (IEC60870_Asdu_Parse(event->asdu.parameters, data, length, &info) != IEC60870_ASDU_OK ||
|
||
info.is_negative_confirm) {
|
||
++self->status.rejected;
|
||
return IEC104_READ_EVENT_HANDLED;
|
||
}
|
||
station = IEC104_Slave_Get_Station(self->slave, info.common_address);
|
||
if (info.cause_of_transmission != IEC60870_ASDU_COT_REQUEST) { cause = IEC60870_ASDU_COT_UNKNOWN_CAUSE; }
|
||
else if (station == NULL || info.common_address == IEC104_CA_BROADCAST) {
|
||
cause = IEC60870_ASDU_COT_UNKNOWN_COMMON_ADDRESS;
|
||
} else if (Read_IOA(info.information_objects) == 0U) { cause = IEC60870_ASDU_COT_UNKNOWN_IOA; }
|
||
if (cause != 0U) { ++self->status.rejected; }
|
||
if (self->count == IEC104_READ_TASK_CAPACITY) {
|
||
++self->status.overloads;
|
||
++self->status.dropped_requests;
|
||
return IEC104_READ_EVENT_HANDLED;
|
||
}
|
||
task = Allocate_Task(self);
|
||
if (task == NULL) { return IEC104_READ_EVENT_ERROR; }
|
||
task->identity = *identity;
|
||
memcpy(task->bytes, data, sizeof(task->bytes));
|
||
task->receive_serial = event->transport.data.i_frame.receive_serial;
|
||
task->accepted_ms = IEC104_Net_Now_Ms(); /* 从入槽受理开始计时,不含此前Slave通知排队。 */
|
||
task->cause = cause;
|
||
task->phase = cause == 0U ? READ_VALUE : READ_REPLY;
|
||
/* READ先持有原站;唯一错误回复可立即尝试,已有队首时则留队,绝不越过READ。 */
|
||
if (cause == 0U) {
|
||
if (IEC104_Slave_Acquire_Station(self->slave, station) != IEC104_STATION_OK) {
|
||
Remove_Task(self, task);
|
||
return IEC104_READ_EVENT_ERROR;
|
||
}
|
||
task->station = station;
|
||
++self->status.accepted;
|
||
} else if (self->count == 1U && !IEC104_Read_Process(self)) { return IEC104_READ_EVENT_ERROR; }
|
||
return IEC104_READ_EVENT_HANDLED;
|
||
}
|
||
|
||
/**
|
||
* 功能:写项目默认受理期限;
|
||
* 输入参数:config——配置。
|
||
* 输出参数:config——配置的更新结果。
|
||
* 返回值:无。
|
||
* 说明:NULL兼容无操作,不创建定时器。
|
||
*/
|
||
void IEC104_Read_Config_Default(IEC104_ReadConfig_t *config)
|
||
{
|
||
if (config != NULL) { config->request_timeout_ms = 15000U; }
|
||
}
|
||
|
||
/**
|
||
* 功能:绑定有效Slave并占用静态实例槽,复制配置;
|
||
* 输入参数:slave——所属从站服务。
|
||
* config——配置。
|
||
* 输出参数:无。
|
||
* 返回值:成功句柄;非法参数、同Slave重复绑定或池满为NULL,失败不改变已有实例。
|
||
* 生命周期起点由后续通知建立,不能用本接口把新模块热挂到已消费通知的会话。
|
||
* 说明:不监听网络或保存应用回调。
|
||
*/
|
||
IEC104_Read_t *IEC104_Read_Create(IEC104_Slave_t *slave, const IEC104_ReadConfig_t *config)
|
||
{
|
||
IEC104_Read_t *free_slot = NULL;
|
||
unsigned i;
|
||
if (config == NULL || IEC104_Slave_Get_Application_Layer_Parameters(slave) == NULL) { return NULL; }
|
||
for (i = 0U; i < IEC104_READ_CAPACITY; ++i) {
|
||
if (read_pool[i].in_use && read_pool[i].slave == slave) { return NULL; }
|
||
if (!read_pool[i].in_use && free_slot == NULL) { free_slot = &read_pool[i]; }
|
||
}
|
||
if (free_slot == NULL) { return NULL; }
|
||
memset(free_slot, 0, sizeof(*free_slot));
|
||
free_slot->slave = slave;
|
||
free_slot->config = *config;
|
||
free_slot->in_use = true;
|
||
return free_slot;
|
||
}
|
||
|
||
/**
|
||
* 功能:仅归还空闲模块的池槽,不隐式Cancel或销毁Slave;
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:!Owned(self) || self->in_lookup || self->count != 0U时返回false;其余分支返回false、true。
|
||
* 说明:失败时句柄仍有效。
|
||
*/
|
||
bool IEC104_Read_Destroy(IEC104_Read_t *self)
|
||
{
|
||
if (!Owned(self) || self->in_lookup || self->count != 0U) { return false; }
|
||
memset(self, 0, sizeof(*self));
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:主动取消本模块尚持有的请求;
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:无。
|
||
* 说明:无效/回调重入无操作,不影响已接手的HIGH原帧。
|
||
*/
|
||
void IEC104_Read_Cancel(IEC104_Read_t *self)
|
||
{
|
||
if (Owned(self) && !self->in_lookup) { Cancel(self); }
|
||
}
|
||
|
||
/**
|
||
* 功能:按应用分派顺序维护生命周期或接收Type102;事件只借用,不修改或保存其指针。
|
||
* ERROR表示归属/重入等失败,不能继续当未知类型兜底;HANDLED包含主动丢弃。
|
||
* CONNECTED先换代再比较generation;其他旧代次通知均忽略。
|
||
* 输入参数:self——本模块实例。
|
||
* event——事件。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:按处理分支返回IEC104_READ_EVENT_ERROR、IEC104_READ_EVENT_HANDLED、IEC104_READ_EVENT_IGNORED、Request(self, event, &identity)。
|
||
* 说明:内部调用:Owned、IEC104_Slave_Get_Event_Identity、Cancel、Request。
|
||
*/
|
||
IEC104_ReadEventResult_t IEC104_Read_Handle_Event(IEC104_Read_t *self, const IEC104_SlaveEvent_t *event)
|
||
{
|
||
IEC104_SlaveEventIdentity_t identity;
|
||
if (!Owned(self) || self->in_lookup ||
|
||
!IEC104_Slave_Get_Event_Identity(self->slave, event, &identity) ||
|
||
(self->session.instance_id != 0U && self->session.instance_id != identity.instance_id)) {
|
||
return IEC104_READ_EVENT_ERROR;
|
||
}
|
||
self->session.slave = identity.slave;
|
||
self->session.instance_id = identity.instance_id;
|
||
if (event->transport.type == IEC104_TCP_EVENT_CONNECTED) {
|
||
Cancel(self);
|
||
self->session.generation = identity.generation;
|
||
self->status.active = false;
|
||
return IEC104_READ_EVENT_HANDLED;
|
||
}
|
||
if (identity.generation != self->session.generation) { return IEC104_READ_EVENT_IGNORED; }
|
||
switch (event->transport.type) {
|
||
case IEC104_TCP_EVENT_ACTIVATED:
|
||
self->status.active = true;
|
||
return IEC104_READ_EVENT_HANDLED;
|
||
case IEC104_TCP_EVENT_DEACTIVATED:
|
||
case IEC104_TCP_EVENT_DISCONNECTED:
|
||
Cancel(self);
|
||
self->status.active = false;
|
||
if (event->transport.type == IEC104_TCP_EVENT_DISCONNECTED) { self->session.generation = 0U; }
|
||
return IEC104_READ_EVENT_HANDLED;
|
||
case IEC104_TCP_EVENT_I_FRAME: return Request(self, event, &identity);
|
||
default: return IEC104_READ_EVENT_IGNORED;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:有界清理失效/到期任务并提交队首错误回复,遇READ或WAIT就返回,不执行lookup。
|
||
* 返回true包含“等待通知/网络”和“发送故障已清理”,不表示所有请求已经应答。
|
||
* 即使Get_Status没有need_process,每轮网络推进后也必须调用,以重试REPLY的WAIT。
|
||
* 输入参数:self——本模块实例。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值:功能:有界清理失效/到期任务并提交队首错误回复,遇READ或WAIT就返回,不执行lookup。
|
||
* 返回true包含“等待通知/网络”和“发送故障已清理”,不表示所有请求已经应答。
|
||
* 说明:内部调用:Owned、Check_Session、Expire、IEC104_Net_Now_Ms、Submit_Reply。
|
||
*/
|
||
bool IEC104_Read_Process(IEC104_Read_t *self)
|
||
{
|
||
unsigned step;
|
||
if (!Owned(self) || self->in_lookup) { return false; }
|
||
for (step = 0U; step < 2U * IEC104_READ_TASK_CAPACITY; ++step) {
|
||
IEC104_SlaveRequestState_t state = Check_Session(self);
|
||
int submitted;
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
|
||
if (state != IEC104_SLAVE_REQUEST_READY || self->count == 0U) { return true; }
|
||
Expire(self, IEC104_Net_Now_Ms());
|
||
if (self->count == 0U || self->tasks[self->order[0]].phase == READ_VALUE) { return true; }
|
||
submitted = Submit_Reply(self, &self->tasks[self->order[0]]);
|
||
if (submitted <= 0) { return submitted == 0; }
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 功能:保守检查最大应答容量,不预留空间;即使实际点只有10字节也按最大21字节预检。
|
||
* 输入参数:self——本模块实例。
|
||
* task——业务任务。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* task——业务任务的更新结果。
|
||
* 返回值: 返回1:空间够并清send_waiting;
|
||
* 说明:返回1:空间够并清send_waiting;0:不足、记room_waits;-1:查询/快照错误并整队列取消。
|
||
* 不替代Check_Session。lookup禁止推进Slave是预检与提交间容量保持的调用前提。
|
||
*/
|
||
static int Check_Room(IEC104_Read_t *self, ReadTask *task)
|
||
{
|
||
IEC104_TcpServerStatus_t status;
|
||
if (IEC104_Slave_Strict_Priority_Enabled(self->slave)) {
|
||
/* 低等级原文占满HIGH时,本轮获准的较高等级仍可能直接交接;不能只按字节环余量拒绝取值。
|
||
* Query只是容量/阶段预检,不预约资源;预检WAIT时保留队首、不调用lookup。
|
||
* 后续真实提交仍可能WAIT,此时按原契约丢弃临时结果,下轮重新取值。 */
|
||
IEC104_TcpSubmitResult_t room = IEC104_Slave_Query_Response_Priority(self->slave, &task->identity,
|
||
IEC104_READ_RESPONSE_MAX_LEN, IEC104_BUSINESS_PRIORITY_INTERROGATION);
|
||
if (room == IEC104_TCP_SUBMIT_WAIT) {
|
||
++self->status.room_waits; task->send_waiting = true; return 0;
|
||
}
|
||
if (room != IEC104_TCP_SUBMIT_OK) {
|
||
Cancel(self); self->status.active = false; return -1;
|
||
}
|
||
task->send_waiting = false; return 1;
|
||
}
|
||
if (READ_ROOM_STATUS(self->slave, &status, NULL) != IEC104_TCP_OK || !status.asdu_queue_status_valid) {
|
||
Cancel(self);
|
||
self->status.active = false;
|
||
return -1;
|
||
}
|
||
if (status.high_queue.free_bytes < IEC104_ASDU_HIGH_ENTRY_HEADER_LEN + IEC104_READ_RESPONSE_MAX_LEN) {
|
||
++self->status.room_waits;
|
||
task->send_waiting = true;
|
||
return 0;
|
||
}
|
||
task->send_waiting = false;
|
||
return 1;
|
||
}
|
||
|
||
/**
|
||
* 功能:读业务类型白名单,不等于对象编解码器支持的全部类型。
|
||
* 输入参数:type——类型。
|
||
* 输出参数:无。
|
||
* 返回值:类型1/3/5/7/9/11/13/20/21及30..36返回true,其余类型返回false。
|
||
* 说明:新增项须重算最大应答长度。
|
||
*/
|
||
static bool Allowed_Type(uint8_t type)
|
||
{
|
||
switch (type) {
|
||
case 1: case 3: case 5: case 7: case 9: case 11: case 13: case 20: case 21:
|
||
case 30: case 31: case 32: case 33: case 34: case 35: case 36: return true;
|
||
default: return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 功能:仅FOUND需要此检查,所有判断无副作用;先查容器归属,避免使用被替换的缓冲/参数。
|
||
* 输入参数:response——应答。
|
||
* buffer——缓冲区。
|
||
* capacity——存储容量。
|
||
* parameters——应用层参数。
|
||
* task——业务任务。
|
||
* 输出参数:无。
|
||
* 返回值:容器归属、对象类型/数量、COT、标志及CA/OA/IOA均符合原读请求返回true,否则false。
|
||
* 说明:Get_Data校验容器内部一致性;Parse逐对象解码,不再Get_Element重复解码。
|
||
* 公共头与IOA使用槽内原请求比较,不相信回调借用的request结构仍未被违规改写。
|
||
* 这些检查不能防止回调先修改capacity并越界写,调用方必须遵守容器契约。
|
||
*/
|
||
static bool Response_Valid(const IEC60870_Asdu_t *response, uint8_t *buffer, uint16_t capacity,
|
||
const IEC60870_AppLayerParameters_t *parameters, const ReadTask *task)
|
||
{
|
||
IEC60870_AsduInfo_t info;
|
||
const uint8_t *data;
|
||
uint16_t length;
|
||
if (response->buffer != buffer || response->capacity != capacity ||
|
||
response->parameters != parameters || response->is_from_buffer != 0U ||
|
||
IEC60870_Asdu_Get_Data(response, &data, &length) != IEC60870_ASDU_OK ||
|
||
IEC60870_Asdu_Parse(parameters, data, length, &info) != IEC60870_ASDU_OK) { return false; }
|
||
return Allowed_Type(info.type_id) && info.object_count == 1U && !info.is_sequence &&
|
||
info.cause_of_transmission == IEC60870_ASDU_COT_REQUEST && !info.is_negative_confirm &&
|
||
info.is_test == ((task->bytes[2] >> 7) & 1U) && info.originator_address == task->bytes[3] &&
|
||
info.common_address == ((uint16_t)task->bytes[4] | ((uint16_t)task->bytes[5] << 8)) &&
|
||
Read_IOA(info.information_objects) == Read_IOA(task->bytes + 6U);
|
||
}
|
||
|
||
/**
|
||
* 功能:对清理后的队首READ至多取值一次,合法值在本次调用内立即尝试提交。
|
||
* 返回值区分“调用过lookup且READ已结束/转回复”(OK)与“保留READ等待”(WAIT),
|
||
* 让应用可按OK有界续跑;到期清理本身不算一次lookup,可能清空队列并返回EMPTY。
|
||
* lookup与借用容器只在本栈帧存活,模块不缓存正数据或回调。完整契约见头文件。
|
||
* 输入参数:self——本模块实例。
|
||
* lookup——取值回调。
|
||
* context——调用方上下文。
|
||
* 输出参数:self——本模块实例的更新结果。
|
||
* 返回值: 返回值区分“调用过lookup且READ已结束/转回复”(OK)与“保留READ等待”(WAIT), 让应用可按OK有界续跑;
|
||
* 到期清理本身不算一次lookup,可能清空队列并返回EMPTY。
|
||
* 说明:内部调用:Owned、Check_Session、IEC104_Net_Now_Ms、Expire、Check_Room、memset等。
|
||
*/
|
||
IEC104_ReadExecuteResult_t IEC104_Read_Execute_Next(IEC104_Read_t *self,
|
||
IEC104_ReadLookup_t lookup, void *context)
|
||
{
|
||
IEC104_SlaveRequestState_t state;
|
||
IEC104_ReadLookupResult_t result;
|
||
IEC104_ReadRequest_t request;
|
||
IEC60870_AsduHeader_t header;
|
||
IEC60870_Asdu_t response;
|
||
const IEC60870_AppLayerParameters_t *parameters;
|
||
uint8_t bytes[IEC104_READ_RESPONSE_MAX_LEN];
|
||
uint16_t capacity;
|
||
ReadTask *task;
|
||
uint64_t now;
|
||
int room;
|
||
if (!Owned(self) || self->in_lookup || lookup == NULL) { return IEC104_READ_EXECUTE_ERROR; }
|
||
/* EMPTY不查询会话:WAIT始终对应真实存在且未离开READ状态的队首。 */
|
||
if (self->count == 0U || self->tasks[self->order[0]].phase != READ_VALUE) { return IEC104_READ_EXECUTE_EMPTY; }
|
||
state = Check_Session(self);
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_READ_EXECUTE_ERROR; }
|
||
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_READ_EXECUTE_WAIT; }
|
||
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_READ_EXECUTE_EMPTY; }
|
||
now = IEC104_Net_Now_Ms();
|
||
Expire(self, now);
|
||
if (self->count == 0U || self->tasks[self->order[0]].phase != READ_VALUE) { return IEC104_READ_EXECUTE_EMPTY; }
|
||
task = &self->tasks[self->order[0]];
|
||
room = Check_Room(self, task);
|
||
if (room < 0) { return IEC104_READ_EXECUTE_ERROR; }
|
||
if (room == 0) { return IEC104_READ_EXECUTE_WAIT; }
|
||
memset(&request, 0, sizeof(request));
|
||
request.generation = task->identity.generation;
|
||
request.receive_serial = task->receive_serial;
|
||
request.station_id = IEC104_Station_Get_Id(task->station);
|
||
request.common_address = (uint16_t)((uint16_t)task->bytes[4] | ((uint16_t)task->bytes[5] << 8));
|
||
request.originator_address = task->bytes[3];
|
||
request.is_test = (task->bytes[2] & 0x80U) != 0U;
|
||
request.ioa = Read_IOA(task->bytes + 6U);
|
||
request.accepted_ms = task->accepted_ms;
|
||
request.base_ms = now;
|
||
memset(&header, 0, sizeof(header));
|
||
header.cause_of_transmission = IEC60870_ASDU_COT_REQUEST;
|
||
header.common_address = request.common_address;
|
||
header.originator_address = request.originator_address;
|
||
header.is_test = request.is_test;
|
||
parameters = IEC104_Slave_Get_Application_Layer_Parameters(self->slave);
|
||
if (IEC60870_Asdu_Create(&response, parameters, bytes, sizeof(bytes), &header, 0) != IEC60870_ASDU_OK) {
|
||
Cancel(self);
|
||
self->status.active = false;
|
||
return IEC104_READ_EXECUTE_ERROR;
|
||
}
|
||
capacity = response.capacity;
|
||
++self->status.lookups;
|
||
self->in_lookup = true;
|
||
result = lookup(context, &request, &response);
|
||
self->in_lookup = false;
|
||
/* 无可发送结果时先按应用失败归因并结束;只有FOUND/UNKNOWN通过检查后才再查会话和期限。
|
||
* 因而返回ERROR或非法FOUND的同次回调,即使耗时跨期限,也不重复计timeouts。 */
|
||
if (result == IEC104_READ_LOOKUP_ERROR) {
|
||
++self->status.lookup_errors;
|
||
Remove_Task(self, task);
|
||
return IEC104_READ_EXECUTE_OK;
|
||
}
|
||
if ((result != IEC104_READ_LOOKUP_FOUND && result != IEC104_READ_LOOKUP_UNKNOWN) ||
|
||
(result == IEC104_READ_LOOKUP_FOUND && !Response_Valid(&response, bytes, capacity, parameters, task))) {
|
||
++self->status.invalid_responses;
|
||
Remove_Task(self, task);
|
||
return IEC104_READ_EXECUTE_OK;
|
||
}
|
||
/* 合法结果也要重新检查会话与期限;不能把取值耗时当作有效期之外的时间。 */
|
||
state = Check_Session(self);
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_READ_EXECUTE_ERROR; }
|
||
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_READ_EXECUTE_WAIT; }
|
||
if (state != IEC104_SLAVE_REQUEST_READY) { return IEC104_READ_EXECUTE_OK; }
|
||
if (self->config.request_timeout_ms != 0U && Remaining(self, task, IEC104_Net_Now_Ms()) == 0U) {
|
||
++self->status.timeouts;
|
||
Remove_Task(self, task);
|
||
return IEC104_READ_EXECUTE_OK;
|
||
}
|
||
if (result == IEC104_READ_LOOKUP_UNKNOWN) {
|
||
++self->status.unknown_ioa;
|
||
Release_Station(self, task);
|
||
task->phase = READ_REPLY;
|
||
task->cause = IEC60870_ASDU_COT_UNKNOWN_IOA;
|
||
task->send_waiting = false;
|
||
/* READ已经结束;WAIT只重试47,不再调用lookup。 */
|
||
if (Submit_Reply(self, task) < 0) { return IEC104_READ_EXECUTE_ERROR; }
|
||
return IEC104_READ_EXECUTE_OK;
|
||
}
|
||
/* OK后绝不追认超时;提交可能已经写出字节。WAIT丢弃本次栈上数据,下轮重新取值。 */
|
||
return Submit(self, task, &response) ? IEC104_READ_EXECUTE_OK : IEC104_READ_EXECUTE_WAIT;
|
||
}
|
||
|
||
/**
|
||
* 功能:只读生成调度快照;先查服务,成功后才写输出,查询失败保持调用方原内容。
|
||
* 不调用有清理副作用的Check_Session,也不Expire;应用仍须显式Process/Execute_Next。
|
||
* 回调内允许查询,need_process在in_lookup时抑制;这不授权回调递归推进模块。
|
||
* 输入参数:self——本模块实例。
|
||
* status——状态快照。
|
||
* 输出参数:status——状态快照的更新结果。
|
||
* 返回值:!Owned(self) || status == NULL时返回false;state == IEC104_SLAVE_REQUEST_ERROR时返回false;其余分支返回false、true。
|
||
* 说明:内部调用:Owned、IEC104_Slave_Check_Request、IEC104_Net_Now_Ms、Remaining。
|
||
*/
|
||
bool IEC104_Read_Get_Status(const IEC104_Read_t *self, IEC104_ReadStatus_t *status)
|
||
{
|
||
IEC104_SlaveRequestState_t state;
|
||
unsigned i;
|
||
uint64_t now;
|
||
if (!Owned(self) || status == NULL) { return false; }
|
||
state = IEC104_Slave_Check_Request(self->slave, &self->session);
|
||
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
|
||
*status = self->status;
|
||
status->generation = self->session.generation;
|
||
status->pending_requests = self->count;
|
||
status->events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
|
||
status->execute_pending = self->count != 0U && self->tasks[self->order[0]].phase == READ_VALUE;
|
||
status->send_waiting = self->count != 0U && self->tasks[self->order[0]].send_waiting;
|
||
status->timer_active = false;
|
||
status->timeout_remaining_ms = 0U;
|
||
status->need_process = false;
|
||
now = IEC104_Net_Now_Ms();
|
||
if (self->config.request_timeout_ms != 0U) {
|
||
for (i = 0U; i < self->count; ++i) {
|
||
uint32_t remaining = Remaining(self, &self->tasks[self->order[i]], now);
|
||
if (!status->timer_active || remaining < status->timeout_remaining_ms) {
|
||
status->timer_active = true;
|
||
status->timeout_remaining_ms = remaining;
|
||
}
|
||
}
|
||
}
|
||
if (self->count != 0U && !self->in_lookup && !status->events_pending) {
|
||
status->need_process = state != IEC104_SLAVE_REQUEST_READY || !status->active ||
|
||
(status->timer_active && status->timeout_remaining_ms == 0U) ||
|
||
(!status->execute_pending && !status->send_waiting);
|
||
}
|
||
return true;
|
||
}
|