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

2471 lines
131 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.
/*
* 国网配电自动化文件服务(Type 210)。
* 模块管理报文、目录快照寿命和读写会话,不接触文件系统或硬件。
* 请求FIFO、写激活槽、写数据环各自有界;所有确认按形成序号交接。
* 写路径在BUSY期间仅操作应用暂存;COMMIT必须等Slave通知读空。
* 应用回调仅由Execute_Next同步交付,Handle_Event/Process不调用应用。
*
* 操作对:1/2目录,3/4读激活,5/6读数据及确认,7/8写激活,9/10写数据及确认。
* 三个入口分工:Handle_Event按通知顺序保存请求,Process检查期限并提交固定回复,
* Execute_Next交付一个应用步骤或组一帧数据。发送层接手不代表主站已收到。
*/
#include "IEC104_FileService.h"
#include "IEC104_Net.h"
#include "IEC104_TcpServer_Config.h"
#include <limits.h>
#include <string.h>
#ifndef IEC104_FILE_SERVICE_CAPACITY
#define IEC104_FILE_SERVICE_CAPACITY IEC104_TCP_SERVER_CAPACITY
#endif
#ifndef IEC104_FILE_SERVICE_TASK_CAPACITY
#define IEC104_FILE_SERVICE_TASK_CAPACITY 2U
#endif
#ifndef IEC104_FILE_SERVICE_SEGMENT_CAPACITY
#define IEC104_FILE_SERVICE_SEGMENT_CAPACITY 2U
#endif
#ifndef IEC104_FILE_SERVICE_CONFIRM_CAPACITY
#define IEC104_FILE_SERVICE_CONFIRM_CAPACITY 2U
#endif
typedef char FileService_Capacity_Check[(IEC104_FILE_SERVICE_CAPACITY > 0U &&
IEC104_FILE_SERVICE_CAPACITY <= UINT_MAX && IEC104_FILE_SERVICE_TASK_CAPACITY > 0U &&
IEC104_FILE_SERVICE_TASK_CAPACITY <= (UINT_MAX - 16U) / 4U &&
IEC104_FILE_SERVICE_SEGMENT_CAPACITY > 0U && IEC104_FILE_SERVICE_SEGMENT_CAPACITY <= UINT_MAX / 4U &&
IEC104_FILE_SERVICE_CONFIRM_CAPACITY >= 2U && IEC104_FILE_SERVICE_CONFIRM_CAPACITY <= UINT_MAX / 4U) ? 1 : -1];
/**
* 功能:外部边界替身只在专项构建中存在,生产对象不引用测试符号。
* 输入参数:self/identity——从站服务及请求身份;asdu——待提交的应答ASDU。
* 输出参数:self——本模块实例的更新结果。
* 返回值:OK已复制接手;WAIT未接手;ERROR为身份或ASDU非法;FATAL为连接故障。
* 说明:可直接交接或进入HIGH队列;本入口不返回票据,成功不表示对端已确认。
*/
#ifdef IEC104_FILE_SERVICE_TEST_HOOKS
extern IEC104_TcpSubmitResult_t IEC104_FileService_Test_Send_Response(IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *, const IEC60870_Asdu_t *, uint64_t *);
/**
* 功能:使用默认业务等级查询该事件身份是否允许一次空闲业务发送。
* 输入参数:self/identity——从站服务及事件身份;reserve——提交后须保留的窗口和记录槽数量。
* 输出参数:无。
* 返回值:OK当前可发送;WAIT暂受通知、协议或资源限制;ERROR为身份、参数或状态非法。
* 说明:查询不接手ASDU或预留资源,实际Send_Idle仍重新核对通知和连接状态。
*/
extern IEC104_TcpSubmitResult_t IEC104_FileService_Test_Query_Idle_Send(const IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *, uint16_t);
/**
* 功能:使用默认业务等级尝试直接发送一帧空闲业务ASDU。
* 输入参数:self/identity——从站服务及事件身份;asdu——待提交原文。
* reserve——提交后须保留的窗口和记录槽数量。
* 输出参数:self——本模块实例的更新结果。
* 返回值:OK已接手;WAIT尚未接手;ERROR非法;FATAL为连接故障。
* 说明:WAIT不把原文转入队列;待分派通知优先,实际发送仍遵循底层部分写入流程。
*/
extern IEC104_TcpSubmitResult_t IEC104_FileService_Test_Send_Idle(IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *, const IEC60870_Asdu_t *, uint16_t);
/**
* 功能:统一判断业务是否应先处理通知、放弃失效请求,或继续当前会话的工作。
* 输入参数:identity为Get_Event_Identity的只读结果,允许零初始化表示尚未绑定会话。
* 输出参数:无。
* 返回值:ERROR为参数/查询失败;WAIT_EVENTS优先于会话判断;STALE为原身份不再可用;READY可继续。
* 说明:检查通知FIFO、服务实例、TCP代次和传输激活状态,不执行I/O或保留发送窗口。
* 先读空通知可避免同一代次STOP后又START时,仅凭最终激活状态误续旧业务。
*/
extern IEC104_SlaveRequestState_t IEC104_FileService_Test_Check_Request(const IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *);
/**
* 功能:取得内部TCP服务、队列和最近会话的状态副本,不推进协议或消费队列。
* 输入参数:self——有效句柄;status——非NULL输出存储;error——可选诊断。
* 输出参数:status——状态快照的更新结果。
* error——错误诊断的更新结果。
* 返回值:OK写入status,失败保持输出;Create后、Init失败后和Close后均可查询。
* 说明:会话和队列各自有有效标志,connected与data_transfer_started含义不同。
*/
extern IEC104_TcpResult_t IEC104_FileService_Test_Get_Status(const IEC104_Slave_t *,
IEC104_TcpServerStatus_t *, IEC104_TcpError_t *);
/**
* 功能:能力属于已Init的服务,不依赖活动连接;
* 输入参数:self——本模块实例。
* capacity——存储容量。
* error——错误诊断。
* 输出参数:capacity——存储容量的更新结果。
* error——错误诊断的更新结果。
* 返回值:按处理分支返回Slave_Error(IEC104_TCP_INVALID_HANDLE, error)、IEC104_TcpServer_Get_Send_Capacity(self->server, capacity, error)。
* 说明:Close后历史ACTIVATED仍可能待分派,须保留INVALID_STATE。
*/
extern IEC104_TcpResult_t IEC104_FileService_Test_Get_Send_Capacity(const IEC104_Slave_t *,
IEC104_TcpSendCapacity_t *, IEC104_TcpError_t *);
/**
* 功能:按事件捕获的原连接身份主动断开主站,保留监听和服务级NORMAL。
* 输入参数:self——所属Slave;event——本服务事件或Copy_Event副本;error——可选诊断。
* 输出参数:self——本模块实例的更新结果。
* error——错误诊断的更新结果。
* 返回值:OK已断开;其他服务/已复用Slave的事件为INVALID_ARGUMENT;当前无连接为NOT_CONNECTED;
* 仍有连接但代次不同为STALE_GENERATION;底层服务异常通过原结果和error返回。
* 说明:来源serial先由本层检查,原generation再由TcpServer核对;不用当前代次代替旧身份。
* 不等待STOPDT或ACK,成功后继续读取收尾事件,再Prepare更新监听条件。
*/
extern IEC104_TcpResult_t IEC104_FileService_Test_Close_Connection(IEC104_Slave_t *,
const IEC104_SlaveEventIdentity_t *, IEC104_TcpError_t *);
/**
* 功能:读取系统启动以来的64位毫秒计数;供相对期限计算,不受用户修改日历时间影响。
* 输入参数:无。
* 输出参数:无。
* 返回值:64位单调毫秒计数,不是UTC时间戳,也不用于显示日期;0及连续读取相等值有效。
* 说明:不在此处换算为UTC或本地时间,避免将协议超时与日历时钟混用。
*/
extern uint64_t IEC104_FileService_Test_Now_Ms(void);
#define FS_SEND IEC104_FileService_Test_Send_Response
#define FS_IDLE_QUERY IEC104_FileService_Test_Query_Idle_Send
#define FS_IDLE_SEND IEC104_FileService_Test_Send_Idle
#define FS_CHECK IEC104_FileService_Test_Check_Request
#define FS_STATUS IEC104_FileService_Test_Get_Status
#define FS_CAPACITY IEC104_FileService_Test_Get_Send_Capacity
#define FS_CLOSE IEC104_FileService_Test_Close_Connection
#define FS_NOW IEC104_FileService_Test_Now_Ms
#else
/* 文件召唤/目录/固定确认归10,文件读取数据归11;控制提交并不等于已交接。 */
#define FS_SEND(s, i, a, t) IEC104_Slave_Send_Response_Tracked_Priority(s, i, a, t, IEC104_BUSINESS_PRIORITY_FILE_CALL)
#define FS_IDLE_QUERY(s, i, r) IEC104_Slave_Query_Idle_Send_Priority(s, i, r, IEC104_BUSINESS_PRIORITY_FILE_TRANSFER)
#define FS_IDLE_SEND(s, i, a, r) IEC104_Slave_Send_Idle_Priority(s, i, a, r, IEC104_BUSINESS_PRIORITY_FILE_TRANSFER)
#define FS_CHECK IEC104_Slave_Check_Request
#define FS_STATUS IEC104_Slave_Get_Status
#define FS_CAPACITY IEC104_Slave_Get_Send_Capacity
#define FS_CLOSE IEC104_Slave_Close_Connection_By_Identity
#define FS_NOW IEC104_Net_Now_Ms
#endif
/* 目录正常末帧交出后仍以DONE占住队首,等CLOSE_DIRECTORY交付才归还槽。
* FS_REPLY中的bytes已变成冻结回复,不能再按原请求偏移读取名称或时标。 */
enum { FS_EXECUTE = 1, FS_DIRECTORY = 2, FS_REPLY = 3, FS_DIRECTORY_DONE = 4 };
enum { FS_READ_OPEN = 1, FS_READ_DATA = 2 };
/* 持久记录的station非NULL表示拥有一个Acquire引用,转交时原记录必须置NULL。
* Source_Event构造的栈上来源暂借注册站,只有Queue_Task成功后才获得引用。
* 其他来源字段均按值保存,同CA重注册不会改写旧资源的station_id;
* 回复/近期记录只复制身份值,不因保留诊断字段而额外占有应用资源。 */
typedef struct {
IEC104_SlaveEventIdentity_t identity;
IEC104_Station_t *station;
uint64_t station_id, receive_serial, accepted_ms;
uint16_t ca;
uint8_t oa;
bool test;
} FileSource;
/* 目录扫描与固定回复/写激活不会同时使用这些字段,故复用阶段存储,不增加目录页缓冲。
* phase为0扫描、1前瞻、2重建待发页;task->cursor在页被接收前保持页首。
* page_end为候选页的尾后下标,next为前瞻位置;more记录是否发现下一匹配项。 */
typedef union {
struct { uint64_t sequence, formed_ms, write_serial; } reply;
struct { size_t page_end, next; uint8_t phase; bool more; } directory;
} FileTaskWork;
/* 请求槽同时用于FIFO和独立写激活:phase决定bytes是原文还是固定回复。
* cursor只在目录扫描时有效;work的两种解释由phase/operation区分。 */
typedef struct {
FileSource source;
FileTaskWork work;
size_t cursor;
uint8_t bytes[249];
uint16_t length;
uint8_t operation, phase;
bool occupied, waiting, failed;
} FileTask;
/* 数据段仅记录注册编号,不持站点引用;归属由执行时的打开会话证明。 */
typedef struct {
uint64_t write_serial, station_id, generation, receive_serial, accepted_ms;
uint32_t file_id, segment;
uint16_t ca, length;
uint8_t oa, data[IEC104_FILE_SERVICE_MAX_SEGMENT];
bool test, more, malformed, bad_sum;
} FileSegment;
/* reserved表示COMMIT尚未返回结果,仍实际占槽、参加排序和回复期限计算。
* terminal为最终结果,满队列时不能与非末段确认一起淘汰。 */
typedef struct {
FileSource source; /* 不拥有引用,资源引用由会话/收尾持有。 */
uint64_t sequence, formed_ms, write_serial;
uint8_t bytes[20];
bool occupied, reserved, terminal, waiting;
} FileConfirm;
/* 成功OPEN的资源只沿“打开 -> 收尾待交付 -> 释放”单向移动。
* COMMIT即最终收尾,不论结果如何都不会再补ABORT_WRITE。 */
typedef struct {
FileSource source;
uint64_t sequence, write_serial;
uintptr_t handle;
uint32_t size, transferred, file_id;
unsigned confirm_index;
IEC104_FileServiceCall_t call;
IEC104_FileServiceEndReason_t reason;
bool occupied;
} FileFinish;
/* task_alive和closed独立:先发末帧或先关快照都合法,两个条件完成才Release。
* task_index仅在task_alive时使用,避免任务取消/复用后误取另一目录原文。 */
typedef struct {
FileSource source;
uintptr_t handle;
uint64_t opened_ms, finish_sequence;
unsigned task_index;
IEC104_FileServiceEndReason_t reason;
bool occupied, task_alive, closing, closed;
} FileDirectory;
/* OPEN阶段只等待op4提交;DATA阶段启用段间隔期限,实际read还须通过op4票据的HANDED检查。
* aborting锁存读取失败:空中止末帧遇WAIT也不能重新调用read恢复传输。 */
typedef struct {
FileSource source;
uintptr_t handle;
uint32_t size, offset;
uint64_t progress_ms, confirmation_ticket; /* op4真实凭据;数据不得先于激活确认交给SendBuffer。 */
uint8_t phase;
bool occupied, waiting, aborting;
} FileRead;
/* serial是本实例每次受理写激活分配的序号,与线上file_id及Slave身份无关。
* op8_sent之前仅受激活回复期限约束;progress_ms只由成功的非空写入更新。 */
typedef struct {
FileSource source;
uintptr_t handle;
uint32_t size, received, file_id, segment;
uint64_t serial, op8_ms, progress_ms;
bool occupied, op8_sent, progress_valid;
} FileWrite;
/* 三种近期记录都只保存值,不保留站点指针或应用handle。
* recent_read用于末段后op6统计,silent_write用于健康Cancel后一次失败反馈;
* empty_write的ready表示COMMIT已有结果,pending表示对应终结确认尚未交出。 */
typedef struct {
FileSource source;
uint64_t serial;
uint32_t file_id;
uint8_t result;
bool valid, ready, pending;
} FileRecent;
struct IEC104_FileService {
IEC104_Slave_t *slave;
IEC104_FileServiceConfig_t config;
IEC104_FileServiceStatus_t status;
IEC104_SlaveEventIdentity_t session, fault_identity;
uint64_t instance_id, next_reply, next_write, next_finish; /* 实例身份、回复排序、写归属、收尾排序各自独立。 */
FileTask tasks[IEC104_FILE_SERVICE_TASK_CAPACITY], activation;
unsigned order[IEC104_FILE_SERVICE_TASK_CAPACITY], task_count; /* FIFO只移动槽下标,不搬动持有资源的记录。 */
FileSegment segments[IEC104_FILE_SERVICE_SEGMENT_CAPACITY];
unsigned segment_head, segment_count;
FileConfirm confirms[IEC104_FILE_SERVICE_CONFIRM_CAPACITY];
FileDirectory directory;
FileRead reader;
FileWrite writer;
FileFinish read_finish, write_finish[2]; /* 前次COMMIT暂缓时允许后一次写打开,故写收尾上界为2。 */
FileRecent recent_read, silent_write, empty_write;
uint8_t buffer[249]; /* 本次组帧/包装共用,正常目录和读帧WAIT后不保留其数据。 */
bool in_use, in_callback, close_attempted, fault_ended;
};
typedef char FileService_Storage_Check[(IEC104_FILE_SERVICE_CAPACITY <= SIZE_MAX / sizeof(IEC104_FileService_t) &&
IEC104_FILE_SERVICE_TASK_CAPACITY <= SIZE_MAX / sizeof(FileTask) &&
IEC104_FILE_SERVICE_SEGMENT_CAPACITY <= SIZE_MAX / sizeof(FileSegment) &&
IEC104_FILE_SERVICE_CONFIRM_CAPACITY <= SIZE_MAX / sizeof(FileConfirm)) ? 1 : -1];
static IEC104_FileService_t file_pool[IEC104_FILE_SERVICE_CAPACITY];
static uint64_t next_instance_id;
/**
* 功能:boundary=true表示已知传输边界改变,不再给旧会话保留一次性失败反馈。
* 输入参数:self——本模块实例。
* boundary——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:否则从打开/待COMMIT会话选最高写序号记录无声结束;已COMMIT或已欠ABORT
* 不参与。这里只登记收尾,绝不调用应用,也不回滚已经提交的文件。
*/
static void Cancel_All(IEC104_FileService_t *self, bool boundary);
/**
* 功能:先复制原身份:Cancel_All可能清掉identity所在任务。故障关闭至多一次,
* 输入参数:self——本模块实例。
* identity——原会话身份。
* attempted——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:attempted为回复超时已尝试关闭的情况;失败后保留清理责任而不自动重试。
*/
static void Fault(IEC104_FileService_t *self, const IEC104_SlaveEventIdentity_t *identity, bool attempted);
/**
* 功能:先按地址定位静态池,再读取in_use;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:true表示句柄属于当前占用的静态实例槽;NULL、池外地址或未占用槽返回false。
* 说明:不解引用NULL或外来句柄。
*/
static bool Owned(const IEC104_FileService_t *self)
{
unsigned i;
for (i = 0U; i < IEC104_FILE_SERVICE_CAPACITY; ++i) {
if (self == &file_pool[i]) { return self->in_use; }
}
return false;
}
/**
* 功能:线格式一律小端;
* 输入参数:p——const uint8_t *所指数据。
* 输出参数:无。
* 返回值:返回(uint16_t)((uint16_t)p[0] | ((uint16_t)p[1] << 8))的结果。
* 说明:这些辅助函数不检查长度,调用者须先证明字段完整可读。
*/
static uint16_t Read16(const uint8_t *p)
{
return (uint16_t)((uint16_t)p[0] | ((uint16_t)p[1] << 8));
}
/**
* 功能:从已确认可读的4字节字段解析小端值,不要求地址对齐,也不自行检查报文剩余长度。
* 输入参数:p——const uint8_t *所指数据。
* 输出参数:无。
* 返回值:返回(uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24)的结果。
* 说明:直接处理传入的p,不经过其他函数调用。
*/
static uint32_t Read32(const uint8_t *p)
{
return (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
}
/**
* 功能:将32位值写为4字节小端字段;
* 输入参数:p——uint8_t *所指数据。
* value——业务值。
* 输出参数:p——uint8_t *所指数据的更新结果。
* 返回值:无。
* 说明:目标容量由组帧调用方保证。
*/
static void Write32(uint8_t *p, uint32_t value)
{
p[0] = (uint8_t)value; p[1] = (uint8_t)(value >> 8);
p[2] = (uint8_t)(value >> 16); p[3] = (uint8_t)(value >> 24);
}
/**
* 功能:比较Slave指针、实例编号及连接代次三项身份;
* 输入参数:a——const IEC104_SlaveEventIdentity_t *所指数据。
* b——const IEC104_SlaveEventIdentity_t *所指数据。
* 输出参数:无。
* 返回值:服务指针、实例编号和连接代次三者相同返回true,否则false。
* 说明:同一CA或重连后的同一指针不足以匹配。
*/
static bool Same_Identity(const IEC104_SlaveEventIdentity_t *a, const IEC104_SlaveEventIdentity_t *b)
{
return a->slave == b->slave && a->instance_id == b->instance_id && a->generation == b->generation;
}
/**
* 功能:OA仅用于回显/诊断,不作为授权凭证;
* 输入参数:a——const FileSource *所指数据。
* b——const FileSource *所指数据。
* 输出参数:无。
* 返回值:返回Same_Identity(&a->identity, &b->identity) && a->station_id == b->station_id && a->ca == b->ca && a->test == b->test的结果。
* 说明:station_id阻止同CA重注册继承旧会话。
*/
static bool Same_Source(const FileSource *a, const FileSource *b)
{
return Same_Identity(&a->identity, &b->identity) && a->station_id == b->station_id &&
a->ca == b->ca && a->test == b->test;
}
/**
* 功能:单调时钟回退与恰好到达期限均按到期处理;0禁用由Expired/Add_Timer过滤。
* 输入参数:now——当前时刻。
* start——uint64_t值。
* timeout——超时状态。
* 输出参数:无。
* 返回值:按处理分支返回0U、timeout - (uint32_t)(now - start)。
* 说明:先以64位判断差值,再转32位,避免长时间等待时截断成尚未到期。
*/
static uint32_t Remaining(uint64_t now, uint64_t start, uint32_t timeout)
{
if (now < start || now - start >= timeout) { return 0U; }
return timeout - (uint32_t)(now - start);
}
/**
* 功能:timeout=0禁用期限;
* 输入参数:now——当前时刻。
* start——uint64_t值。
* timeout——超时状态。
* 输出参数:无。
* 返回值:启用期限且已经到期或单调时钟回退时返回true;期限禁用或尚未到期时返回false。
* 说明:启用时恰到边界或单调时钟回退均返回到期。
*/
static bool Expired(uint64_t now, uint64_t start, uint32_t timeout)
{
return timeout != 0U && Remaining(now, start, timeout) == 0U;
}
/**
* 功能:归还source仍持有的站点引用并清指针,允许重复清理;
* 输入参数:self——本模块实例。
* source——源数据。
* 输出参数:source——源数据的更新结果。
* 返回值:无。
* 说明:不负责关闭应用文件句柄。
*/
static void Release_Source(IEC104_FileService_t *self, FileSource *source)
{
if (source->station != NULL) { (void)IEC104_Slave_Release_Station(self->slave, source->station); source->station = NULL; }
}
/**
* 功能:序号0留作未分配;
* 输入参数:self——本模块实例。
* counter——uint64_t *所指数据。
* value——业务值。
* identity——原会话身份。
* 输出参数:self——本模块实例的更新结果。
* counter、value——成功时递增并写回同一非零序号;耗尽时二者均不改。
* 返回值:成功递增计数器并写回新序号返回true;序号耗尽时登记故障并返回false,不回绕。
* 说明:耗尽不回绕,也不能为了拒绝再申请一个回复序号。
*/
static bool Next_Serial(IEC104_FileService_t *self, uint64_t *counter, uint64_t *value,
const IEC104_SlaveEventIdentity_t *identity)
{
if (*counter == UINT64_MAX) {
++self->status.serial_exhausted;
Fault(self, identity, false);
return false;
}
*value = ++*counter;
return true;
}
/**
* 功能:每次回调从零构造借用请求,操作专用字段随后填写;不能遗留上次name/handle。
* 输入参数:self——本模块实例。
* source——源数据。
* call——IEC104_FileServiceCall_t值。
* request——请求。
* 输出参数:request——请求的更新结果。
* 返回值:无。
* 说明:identity保持原Slave身份,instance_id则标识本模块实例,两者不得互换。
*/
static void Request_From(const IEC104_FileService_t *self, const FileSource *source,
IEC104_FileServiceCall_t call, IEC104_FileServiceRequest_t *request)
{
memset(request, 0, sizeof(*request));
request->identity = source->identity;
request->instance_id = self->instance_id;
request->receive_serial = source->receive_serial;
request->station_id = source->station_id;
request->common_address = source->ca;
request->originator_address = source->oa;
request->accepted_ms = source->accepted_ms;
request->test = source->test;
request->call = call;
}
/**
* 功能:新组帧采用固定104头,VSQ=1、IOA=0。只有COT7的失败结果置P/N;
* 输入参数:bytes——字节存储。
* source——源数据。
* operation——操作类型。
* cause——传送原因。
* result——处理结果。
* 输出参数:bytes——字节存储的更新结果。
* 返回值:无。
* 说明:COT5的数据/兼容确认保持P/N=0。镜像报文错误由Mirror_Error单独处理。
*/
static void Prefix(uint8_t *bytes, const FileSource *source, uint8_t operation, uint8_t cause, uint8_t result)
{
memset(bytes, 0, 11U);
bytes[0] = IEC104_FILE_SERVICE_TYPE_ID; bytes[1] = 1U;
bytes[2] = (uint8_t)(cause | (source->test ? 0x80U : 0U) | (cause == 7U && result != 0U ? 0x40U : 0U));
bytes[3] = source->oa; bytes[4] = (uint8_t)source->ca; bytes[5] = (uint8_t)(source->ca >> 8);
bytes[9] = IEC104_FILE_SERVICE_PACKAGE_FILE; bytes[10] = operation;
}
/**
* 功能:按配置决定回复文件ID:兼容回显模式保留请求值,默认模式统一输出0。
* 输入参数:self——本模块实例。
* requested——uint32_t值。
* 输出参数:无。
* 返回值:返回self->config.id_mode == IEC104_FILE_SERVICE_ID_ECHO ? requested : 0U的结果。
* 说明:直接处理传入的self、requested,不经过其他函数调用。
*/
static uint32_t Output_Id(const IEC104_FileService_t *self, uint32_t requested)
{
return self->config.id_mode == IEC104_FILE_SERVICE_ID_ECHO ? requested : 0U;
}
/**
* 功能:目录原站引用同时保护回复寿命与应用快照寿命,任一责任未完成都不能释放。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:内部调用:Release_Source、memset。
*/
static void Release_Directory(IEC104_FileService_t *self)
{
if (self->directory.occupied && !self->directory.task_alive && self->directory.closed) {
Release_Source(self, &self->directory.source);
memset(&self->directory, 0, sizeof(self->directory));
}
}
/**
* 功能:删除协议任务不等于关闭应用资源;已转给会话/目录的station在此为NULL。
* 输入参数:self——本模块实例。
* task——业务任务。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:目录任务取消后独立清理记录继续保有handle,直到Execute交付关闭。
*/
static void Remove_Task(IEC104_FileService_t *self, FileTask *task)
{
unsigned i;
if (task == &self->activation) {
Release_Source(self, &task->source);
memset(task, 0, sizeof(*task));
return;
}
for (i = 0U; i < self->task_count; ++i) {
unsigned index = self->order[i];
if (task == &self->tasks[index]) {
if (self->directory.occupied && self->directory.task_alive && self->directory.task_index == index) {
self->directory.task_alive = false;
}
Release_Source(self, &task->source);
memset(task, 0, sizeof(*task));
--self->task_count;
memmove(self->order + i, self->order + i + 1U, (self->task_count - i) * sizeof(self->order[0]));
Release_Directory(self);
return;
}
}
}
/**
* 功能:消费非空分段环的队首并清槽;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:调用方先处理其内容,本函数不发送确认或执行写回调。
*/
static void Pop_Segment(IEC104_FileService_t *self)
{
memset(&self->segments[self->segment_head], 0, sizeof(self->segments[0]));
self->segment_head = (self->segment_head + 1U) % IEC104_FILE_SERVICE_SEGMENT_CAPACITY;
--self->segment_count;
}
/**
* 功能:固定回复形成后直接冻结其完整字节,后续WAIT只重试同一份原文,不再借用回调输出。
* 输入参数:self——本模块实例。
* task——业务任务。
* length——字节长度。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:!Next_Serial(self, &self->next_reply, &sequence, &task->source.identity)时返回false;其余分支返回false、true。
* 说明:本槽执行阶段已结束,原请求名等仅在构造回复前使用。
*/
static bool Freeze_Task(IEC104_FileService_t *self, FileTask *task, uint16_t length)
{
uint64_t sequence;
if (!Next_Serial(self, &self->next_reply, &sequence, &task->source.identity)) { return false; }
memcpy(task->bytes, self->buffer, length);
task->length = length; task->phase = FS_REPLY; task->work.reply.sequence = sequence;
task->work.reply.formed_ms = FS_NOW(); task->waiting = false;
return true;
}
/**
* 功能:镜像完整请求形成否定回复,仅保留原T位并改写P/N及COT;
* 输入参数:self——本模块实例。
* task——业务任务。
* cause——传送原因。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:返回Freeze_Task(self, task, task->length)的结果。
* 说明:冻结失败由Freeze_Task报告。
*/
static bool Mirror_Error(IEC104_FileService_t *self, FileTask *task, uint8_t cause)
{
memcpy(self->buffer, task->bytes, task->length);
self->buffer[2] = (uint8_t)((self->buffer[2] & 0x80U) | 0x40U | cause);
return Freeze_Task(self, task, task->length);
}
/**
* 功能:格式错误仍只能回显完整可读的名称和字段;
* 输入参数:self——本模块实例。
* task——业务任务。
* result——处理结果。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:按处理分支返回Freeze_Task(self, task, 18U)、Freeze_Task(self, task, (uint16_t)(21U + name_length))。
* 说明:不能从截短原文臆造指针。
*/
static bool Operation_Error(IEC104_FileService_t *self, FileTask *task, uint8_t result)
{
uint8_t name_length = 0U, encoded_length = 0U;
uint32_t id = 0U, size = 0U;
unsigned position;
if (task->operation == 1U) {
uint8_t cause = (task->bytes[2] & 0x3FU) == 5U ? 5U : 7U;
if (task->length >= 15U) { id = Read32(task->bytes + 11U); }
Prefix(self->buffer, &task->source, 2U, cause, result);
self->buffer[11] = result; Write32(self->buffer + 12U, Output_Id(self, id));
self->buffer[16] = 0U; self->buffer[17] = 0U;
if (!task->failed) { ++self->status.directory_failures; task->failed = true; }
return Freeze_Task(self, task, 18U);
}
if (task->length >= 12U) {
encoded_length = task->bytes[11];
if (encoded_length > 0U && encoded_length <= IEC104_FILE_SERVICE_MAX_FILE_NAME &&
task->length >= 12U + encoded_length) { name_length = encoded_length; }
}
if (task->operation == 7U) {
position = 12U + encoded_length;
if (task->length >= position + 4U) { id = Read32(task->bytes + position); }
if (task->length >= position + 8U) { size = Read32(task->bytes + position + 4U); }
}
Prefix(self->buffer, &task->source, task->operation == 7U ? 8U : 4U, 7U, result);
self->buffer[11] = result; self->buffer[12] = name_length;
if (name_length != 0U) { memcpy(self->buffer + 13U, task->bytes + 12U, name_length); }
Write32(self->buffer + 13U + name_length, Output_Id(self, id));
Write32(self->buffer + 17U + name_length, size);
return Freeze_Task(self, task, (uint16_t)(21U + name_length));
}
/**
* 功能:登记目录关闭责任及先后序号,不在协议推进路径调用应用CLOSE_DIRECTORY。
* 输入参数:self——本模块实例。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:即使序号耗尽返回false,快照仍保留给后续Execute清理。
* 说明:重复关闭不改变第一次原因;即使序号耗尽返回false,快照仍保留给后续Execute清理。
*/
static bool Close_Directory(IEC104_FileService_t *self, IEC104_FileServiceEndReason_t reason)
{
FileDirectory *directory = &self->directory;
if (!directory->occupied || directory->closing || directory->closed) { return true; }
/* 先固定清理责任,编号耗尽触发的Fault也不能丢失成功OPEN的资源。 */
directory->closing = true; directory->reason = reason;
if (!Next_Serial(self, &self->next_finish, &directory->finish_sequence, &directory->source.identity)) {
directory->finish_sequence = UINT64_MAX;
return false;
}
return true;
}
/**
* 功能:把活动读的句柄、站点引用和已接手字节进度转交收尾槽,实际CLOSE_READ由Execute交付。
* 输入参数:self——本模块实例。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!reader->occupied时返回true;其余分支返回true、false。
* 说明:清空活动读后仍保留不持有站点引用的最近来源,仅用于识别迟到op6,不允许它重新开启发送。
*/
static bool End_Read(IEC104_FileService_t *self, IEC104_FileServiceEndReason_t reason)
{
FileRead *reader = &self->reader;
FileFinish *finish = &self->read_finish;
if (!reader->occupied) { return true; }
if (finish->occupied) { Fault(self, &reader->source.identity, false); return false; }
memset(finish, 0, sizeof(*finish));
finish->occupied = true; finish->source = reader->source; reader->source.station = NULL;
finish->call = IEC104_FILE_SERVICE_CALL_CLOSE_READ; finish->reason = reason;
finish->handle = reader->handle; finish->size = reader->size; finish->transferred = reader->offset;
self->recent_read.source = finish->source; self->recent_read.source.station = NULL;
self->recent_read.valid = true;
if (reason != IEC104_FILE_SERVICE_END_COMPLETE) { ++self->status.reads_aborted; }
memset(reader, 0, sizeof(*reader));
if (!Next_Serial(self, &self->next_finish, &finish->sequence, &finish->source.identity)) {
finish->sequence = UINT64_MAX;
return false;
}
return true;
}
/**
* 功能:EACH可丢最旧非末段READY确认,COMMIT预留和终结结果始终受保护。
* 输入参数:self——本模块实例。
* source——源数据。
* serial——流水号。
* file_id——身份编号。
* segment——uint32_t值。
* result——处理结果。
* terminal——bool值。
* reserved——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 此处即固定形成序号/时刻,COMMIT返回只填结果,不重新申请或延长期限。
* 说明:终结槽仍无法取得意味着容量不变量被破坏,必须faulted,不能丢最终结果。
* 此处即固定形成序号/时刻,COMMIT返回只填结果,不重新申请或延长期限。
*/
static FileConfirm *Reserve_Confirm(IEC104_FileService_t *self, const FileSource *source,
uint64_t serial, uint32_t file_id, uint32_t segment, uint8_t result, bool terminal, bool reserved)
{
FileConfirm *slot = NULL, *oldest = NULL;
unsigned i;
uint64_t sequence;
for (i = 0U; i < IEC104_FILE_SERVICE_CONFIRM_CAPACITY; ++i) {
FileConfirm *item = &self->confirms[i];
if (!item->occupied && slot == NULL) { slot = item; }
if (item->occupied && !item->terminal && !item->reserved &&
(oldest == NULL || item->sequence < oldest->sequence)) { oldest = item; }
}
if (slot == NULL) {
if (oldest != NULL) { slot = oldest; ++self->status.dropped_replies; }
else if (!terminal) { ++self->status.dropped_replies; return NULL; }
else { Fault(self, &source->identity, false); return NULL; }
}
if (!Next_Serial(self, &self->next_reply, &sequence, &source->identity)) { return NULL; }
memset(slot, 0, sizeof(*slot));
slot->occupied = true; slot->terminal = terminal; slot->reserved = reserved;
slot->source = *source; slot->source.station = NULL;
slot->write_serial = serial; slot->sequence = sequence; slot->formed_ms = FS_NOW();
Prefix(slot->bytes, source, 10U, self->config.write_confirm_cause, result);
Write32(slot->bytes + 11U, Output_Id(self, file_id));
Write32(slot->bytes + 15U, segment); slot->bytes[19] = result;
return slot;
}
/**
* 功能:转移引用和handle后立即清空writer,后续段不能再写已终结会话。
* 输入参数:self——本模块实例。
* call——IEC104_FileServiceCall_t值。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回NULL、finish。
* 说明:先保留清理责任再分配排序号,序号耗尽也必须能交付ABORT。
*/
static FileFinish *Move_Write_To_Finish(IEC104_FileService_t *self,
IEC104_FileServiceCall_t call, IEC104_FileServiceEndReason_t reason)
{
FileWrite *writer = &self->writer;
FileFinish *finish = NULL;
unsigned i;
for (i = 0U; i < 2U; ++i) { if (!self->write_finish[i].occupied) { finish = &self->write_finish[i]; break; } }
if (finish == NULL) { Fault(self, &writer->source.identity, false); return NULL; }
memset(finish, 0, sizeof(*finish));
finish->occupied = true; finish->source = writer->source; writer->source.station = NULL;
finish->call = call; finish->reason = reason; finish->handle = writer->handle;
finish->size = writer->size; finish->transferred = writer->received;
finish->file_id = writer->file_id; finish->write_serial = writer->serial;
memset(writer, 0, sizeof(*writer));
if (!Next_Serial(self, &self->next_finish, &finish->sequence, &finish->source.identity)) {
finish->sequence = UINT64_MAX;
return NULL;
}
return finish;
}
/**
* 功能:错误/超时先冻结终结确认,随后只欠一次ABORT。
* 输入参数:self——本模块实例。
* result——处理结果。
* segment——uint32_t值。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!writer->occupied时返回true;Reserve_Confirm(self, &writer->source, writer->serial, writer->file_id, segment, result, true, false) == NULL时返回false;Move_Write_To_Finish(self, IEC104_FILE_SERVICE_CALL_ABORT_WRITE, reason) == NULL时返回false;其余分支返回true、false。
* 说明:TEST直接结束协议会话。
*/
static bool Fail_Write(IEC104_FileService_t *self, uint8_t result,
uint32_t segment, IEC104_FileServiceEndReason_t reason)
{
FileWrite *writer = &self->writer;
if (!writer->occupied) { return true; }
if (Reserve_Confirm(self, &writer->source, writer->serial, writer->file_id, segment, result, true, false) == NULL) { return false; }
++self->status.writes_failed;
if (writer->source.test) { Release_Source(self, &writer->source); memset(writer, 0, sizeof(*writer)); }
else if (Move_Write_To_Finish(self, IEC104_FILE_SERVICE_CALL_ABORT_WRITE, reason) == NULL) { return false; }
return true;
}
/**
* 功能:保存最高序号的未提交写归属;
* 输入参数:self——本模块实例。
* source——源数据。
* serial——流水号。
* id——标识。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:重复Cancel不能用较旧清理覆盖这个标记。
*/
static void Remember_Silent(IEC104_FileService_t *self, const FileSource *source, uint64_t serial, uint32_t id)
{
if (!self->silent_write.valid || serial > self->silent_write.serial) {
memset(&self->silent_write, 0, sizeof(self->silent_write));
self->silent_write.valid = true; self->silent_write.source = *source;
self->silent_write.source.station = NULL; self->silent_write.serial = serial; self->silent_write.file_id = id;
}
}
/**
* 功能:boundary=true表示已知传输边界改变,不再给旧会话保留一次性失败反馈。
* 输入参数:self——本模块实例。
* boundary——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:否则从打开/待COMMIT会话选最高写序号记录无声结束;已COMMIT或已欠ABORT
* 不参与。这里只登记收尾,绝不调用应用,也不回滚已经提交的文件。
*/
static void Cancel_All(IEC104_FileService_t *self, bool boundary)
{
unsigned i;
if (self->directory.occupied) { (void)Close_Directory(self, IEC104_FILE_SERVICE_END_CANCELLED); }
if (self->reader.occupied) { (void)End_Read(self, IEC104_FILE_SERVICE_END_CANCELLED); }
if (self->writer.occupied) {
if (!boundary) { Remember_Silent(self, &self->writer.source, self->writer.serial, self->writer.file_id); }
if (self->writer.source.test) { Release_Source(self, &self->writer.source); memset(&self->writer, 0, sizeof(self->writer)); }
else { (void)Move_Write_To_Finish(self, IEC104_FILE_SERVICE_CALL_ABORT_WRITE, IEC104_FILE_SERVICE_END_CANCELLED); }
}
for (i = 0U; i < 2U; ++i) {
FileFinish *finish = &self->write_finish[i];
if (finish->occupied && finish->call == IEC104_FILE_SERVICE_CALL_COMMIT) {
if (!boundary) { Remember_Silent(self, &finish->source, finish->write_serial, finish->file_id); }
finish->call = IEC104_FILE_SERVICE_CALL_ABORT_WRITE;
finish->reason = IEC104_FILE_SERVICE_END_CANCELLED; ++self->status.commits_cancelled;
}
}
while (self->task_count != 0U) { ++self->status.cancelled; Remove_Task(self, &self->tasks[self->order[0]]); }
if (self->activation.occupied) { ++self->status.cancelled; Remove_Task(self, &self->activation); }
while (self->segment_count != 0U) { ++self->status.cancelled; Pop_Segment(self); }
memset(self->confirms, 0, sizeof(self->confirms));
memset(&self->recent_read, 0, sizeof(self->recent_read));
memset(&self->empty_write, 0, sizeof(self->empty_write));
if (boundary) { memset(&self->silent_write, 0, sizeof(self->silent_write)); }
}
/**
* 功能:原连接已关闭、已断开或代次过期都表示关闭义务结束;
* 输入参数:result——处理结果。
* 输出参数:无。
* 返回值:返回result == IEC104_TCP_OK || result == IEC104_TCP_NOT_CONNECTED || result == IEC104_TCP_STALE_GENERATION的结果。
* 说明:其他结果仍按关闭错误处理。
*/
static bool Closed_Result(IEC104_TcpResult_t result)
{
return result == IEC104_TCP_OK || result == IEC104_TCP_NOT_CONNECTED || result == IEC104_TCP_STALE_GENERATION;
}
/**
* 功能:先复制原身份:Cancel_All可能清掉identity所在任务。故障关闭至多一次,
* 输入参数:self——本模块实例。
* identity——原会话身份。
* attempted——bool值。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:attempted为回复超时已尝试关闭的情况;失败后保留清理责任而不自动重试。
*/
static void Fault(IEC104_FileService_t *self, const IEC104_SlaveEventIdentity_t *identity, bool attempted)
{
IEC104_SlaveEventIdentity_t original = *identity;
/* 已置faulted时只保留最初故障,避免清理中的内部错误递归重进取消/关闭。 */
if (self->status.faulted) { return; }
self->status.faulted = true; self->fault_identity = original; self->close_attempted = attempted;
Cancel_All(self, false);
if (!self->close_attempted) {
IEC104_TcpResult_t result;
self->close_attempted = true;
result = FS_CLOSE(self->slave, &self->fault_identity, NULL);
if (Closed_Result(result)) { self->fault_ended = true; }
else { ++self->status.close_errors; }
}
}
/**
* 功能:查询原请求身份并同步通知等待状态;WAIT_EVENTS只暂停业务,不丢请求也不刷新期限。
* 输入参数:self——本模块实例。
* identity——原会话身份。
* 输出参数:self——本模块实例的更新结果。
* 返回值:两种路径都可能清空identity所在任务,返回后须先按状态分支。
* 说明:ERROR转故障收尾,STALE取消旧会话;两种路径都可能清空identity所在任务,返回后须先按状态分支。
*/
static IEC104_SlaveRequestState_t Check(IEC104_FileService_t *self, const IEC104_SlaveEventIdentity_t *identity)
{
IEC104_SlaveRequestState_t state = FS_CHECK(self->slave, identity);
self->status.events_pending = state == IEC104_SLAVE_REQUEST_WAIT_EVENTS;
if (state == IEC104_SLAVE_REQUEST_ERROR) { Fault(self, identity, false); }
else if (state == IEC104_SLAVE_REQUEST_STALE) { Cancel_All(self, true); self->status.active = false; }
return state;
}
/**
* 功能:只用于HIGH提交ERROR:完整原身份、健康连接及已停传输且有未读通知须同时成立。
* 输入参数:self——本模块实例。
* identity——原会话身份。
* 输出参数:无。
* 返回值:仅原会话仍健康、传输已停止且存在待消费通知时返回true;其他情况返回false。
* 说明:FATAL和IDLE故障不适用;仅有未读通知不能证明错误来自尚未分派的STOP。
*/
static bool Defer_For_Stop(IEC104_FileService_t *self, const IEC104_SlaveEventIdentity_t *identity)
{
IEC104_TcpServerStatus_t status;
return Same_Identity(identity, &self->session) && identity->slave == self->slave &&
FS_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;
}
/**
* 功能:1已接手,0等待,-1故障。
* 输入参数:self——本模块实例。
* source——源数据。
* bytes——字节存储。
* length——字节长度。
* negative——否定确认标志。
* idle——bool值。
* ticket——应答交接票据。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回-1、1、0。
* 说明:故障后可能清空调用者的任务,不能再解引用它。
*/
static int Send(IEC104_FileService_t *self, const FileSource *source, const uint8_t *bytes,
uint16_t length, bool negative, bool idle, uint64_t *ticket)
{
IEC60870_Asdu_t asdu;
IEC104_TcpSubmitResult_t result;
IEC104_SlaveEventIdentity_t identity = source->identity;
if (bytes != self->buffer) { memcpy(self->buffer, bytes, length); }
if (IEC60870_Asdu_Create_From_Buffer(&asdu, IEC104_Slave_Get_Application_Layer_Parameters(self->slave),
self->buffer, length) != IEC60870_ASDU_OK) { Fault(self, &identity, false); return -1; }
result = idle ? FS_IDLE_SEND(self->slave, &identity, &asdu, self->config.window_reserve) :
FS_SEND(self->slave, &identity, &asdu, ticket);
if (result == IEC104_TCP_SUBMIT_OK) {
++self->status.submitted; if (negative) { ++self->status.negative_submitted; }
return 1;
}
if (result == IEC104_TCP_SUBMIT_WAIT) {
if (idle) { ++self->status.idle_waits; } else { ++self->status.waits; }
return 0;
}
++self->status.send_errors;
if (!idle && result == IEC104_TCP_SUBMIT_ERROR && Defer_For_Stop(self, &identity)) {
self->status.events_pending = true; return 0;
}
Fault(self, &identity, false);
return -1;
}
/**
* 功能:固定回复跨三条存储路径按形成序号排序。RESERVED_COMMIT占实际槽,
* 输入参数:self——本模块实例。
* task——业务任务。
* confirm——const FileConfirm **所指数据。
* 输出参数:task、confirm——分别指向最早回复的任务或确认槽,另一项置NULL;无回复时均置NULL。
* 返回值:最早待交接回复的形成序号;没有已分配序号的回复时返回0。
* 说明:因而会挡住下一写激活确认;不能越过它提交任何较晚确认。
*/
static uint64_t Oldest_Reply(const IEC104_FileService_t *self, const FileTask **task, const FileConfirm **confirm)
{
uint64_t sequence = 0U;
unsigned i;
*task = NULL; *confirm = NULL;
for (i = 0U; i < self->task_count; ++i) {
const FileTask *item = &self->tasks[self->order[i]];
if (item->phase == FS_REPLY && (sequence == 0U || item->work.reply.sequence < sequence)) {
sequence = item->work.reply.sequence; *task = item;
}
}
if (self->activation.occupied && self->activation.phase == FS_REPLY &&
(sequence == 0U || self->activation.work.reply.sequence < sequence)) {
sequence = self->activation.work.reply.sequence; *task = &self->activation;
}
for (i = 0U; i < IEC104_FILE_SERVICE_CONFIRM_CAPACITY; ++i) {
const FileConfirm *item = &self->confirms[i];
if (item->occupied && (sequence == 0U || item->sequence < sequence)) {
sequence = item->sequence; *task = NULL; *confirm = item;
}
}
return sequence;
}
/**
* 功能:查询所有回复路径是否存在已分配序号,含预留COMMIT确认;
* 输入参数:self——本模块实例。
* 输出参数:无。
* 返回值:返回Oldest_Reply(self, &task, &confirm) != 0U的结果。
* 说明:有回复不代表立即可提交。
*/
static bool Has_Reply(const IEC104_FileService_t *self)
{
const FileTask *task;
const FileConfirm *confirm;
return Oldest_Reply(self, &task, &confirm) != 0U;
}
/**
* 功能:op4/op8提交OK(入HIGH或直接交接)才启动读间隔/写进度计时,不等待链路ACK。
* 输入参数:self——本模块实例。
* task——业务任务。
* ticket——应答交接票据。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:无。
* 说明:op4的PENDING等待计入该读期限;较低等级暂未获发送机会不能暂停计时或重置progress_ms。
* op8对应会话可能已经写完并转入COMMIT,此时无需再启动活动写计时器。
*/
static void Task_Sent(IEC104_FileService_t *self, FileTask *task, uint64_t ticket)
{
if (task == &self->activation) {
if (self->writer.occupied && self->writer.serial == task->work.reply.write_serial) {
self->writer.op8_sent = true; self->writer.op8_ms = FS_NOW();
}
} else if (task->operation == 3U && task->length >= 12U && task->bytes[11] == 0U &&
self->reader.occupied && self->reader.phase == FS_READ_OPEN &&
self->reader.source.receive_serial == task->source.receive_serial &&
Same_Source(&self->reader.source, &task->source)) {
self->reader.phase = FS_READ_DATA; self->reader.progress_ms = FS_NOW();
self->reader.confirmation_ticket = ticket;
}
if (self->directory.occupied && self->directory.task_alive &&
task == &self->tasks[self->directory.task_index]) {
++self->status.directory_frames; ++self->status.directories;
if (!self->directory.closed) { task->phase = FS_DIRECTORY_DONE; return; }
} else if (task->operation == 1U && task->length >= 18U && task->bytes[10] == 2U) {
++self->status.directory_frames; ++self->status.directories;
}
Remove_Task(self, task);
}
/**
* 功能:提交循环只发送固定字节,不执行应用;每次成功移除一条待发回复,
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回1、0、-1、self->status.faulted ? -1 : 1。
* 说明:但目录任务槽可能仍须等关闭回调。循环预算覆盖本轮全部固定回复位置。
* 请求FIFO中的应用动作仍严格只执行队首,错误回复则服从统一形成序号。
*/
static int Flush_Replies(IEC104_FileService_t *self)
{
unsigned budget = IEC104_FILE_SERVICE_TASK_CAPACITY + IEC104_FILE_SERVICE_CONFIRM_CAPACITY + 2U;
while (budget-- != 0U && !self->status.faulted) {
const FileTask *found_task;
const FileConfirm *found_confirm;
FileTask *task;
FileConfirm *confirm;
const FileSource *source;
IEC104_SlaveRequestState_t state;
uint64_t ticket = 0U;
int sent;
if (Oldest_Reply(self, &found_task, &found_confirm) == 0U) { return 1; }
if (found_confirm != NULL && found_confirm->reserved) { return 0; }
task = (FileTask *)found_task; confirm = (FileConfirm *)found_confirm;
source = task != NULL ? &task->source : &confirm->source;
state = Check(self, &source->identity);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return -1; }
if (state != IEC104_SLAVE_REQUEST_READY) { return 0; }
if (task != NULL) {
bool negative = (task->bytes[2] & 0x40U) != 0U ||
(task->length >= 12U && task->bytes[10] == 2U && task->bytes[11] != 0U);
sent = Send(self, &task->source, task->bytes, task->length, negative, false, &ticket);
if (sent < 0) { return -1; }
task->waiting = sent == 0;
if (sent == 0) { return 0; }
Task_Sent(self, task, ticket);
} else {
sent = Send(self, &confirm->source, confirm->bytes, 20U, confirm->bytes[19] != 0U, false, NULL);
if (sent < 0) { return -1; }
confirm->waiting = sent == 0;
if (sent == 0) { return 0; }
if (self->empty_write.valid && self->empty_write.serial == confirm->write_serial) { self->empty_write.pending = false; }
memset(confirm, 0, sizeof(*confirm));
}
}
return self->status.faulted ? -1 : 1;
}
/**
* 功能:从扫描转入固定错误末帧,同时登记关闭快照;之后只重试冻结回复,不再list。
* 输入参数:self——本模块实例。
* reason——原因。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!directory->occupied || !directory->task_alive时返回true;task->phase != FS_DIRECTORY时返回true;!Operation_Error(self, task, 1U)时返回false;其余分支返回true、false、Close_Directory(self, reason)。
* 说明:错误帧不含本轮尚未交出的条目,回复期限从冻结时重新独立起算。
*/
static bool Directory_Failed(IEC104_FileService_t *self, IEC104_FileServiceEndReason_t reason)
{
FileDirectory *directory = &self->directory;
FileTask *task;
if (!directory->occupied || !directory->task_alive) { return true; }
task = &self->tasks[directory->task_index];
if (task->phase != FS_DIRECTORY) { return true; }
if (!Operation_Error(self, task, 1U)) { return false; }
return Close_Directory(self, reason);
}
/**
* 功能:BUSY允许在op8交出前先写暂存,所以取确认接手与成功非空写入中较晚的时刻。
* 输入参数:writer——日志写入回调。
* 输出参数:无。
* 返回值:返回writer->progress_valid && writer->progress_ms > writer->op8_ms ? writer->progress_ms : writer->op8_ms的结果。
* 说明:新段入环、零长度段和不匹配归属均不能刷新这个起点。
*/
static uint64_t Write_Progress(const FileWrite *writer)
{
return writer->progress_valid && writer->progress_ms > writer->op8_ms ? writer->progress_ms : writer->op8_ms;
}
/**
* 功能:回复期限从形成时起算,包括未到队首及尚未执行COMMIT的预留槽。
* 输入参数:self——本模块实例。
* source——源数据。
* reserved_serial——顺序编号。
* 输出参数:self——本模块实例的更新结果。
* 返回值:原连接关闭义务已结束并完成取消返回true;关闭失败时登记故障并返回false。
* 说明:关闭前把预留COMMIT改为TIMEOUT收尾,随后取消不得改写这个首个原因。
*/
static bool Reply_Timeout(IEC104_FileService_t *self, const FileSource *source, uint64_t reserved_serial)
{
IEC104_SlaveEventIdentity_t identity = source->identity;
IEC104_TcpResult_t result;
unsigned i;
++self->status.reply_timeouts;
if (reserved_serial != 0U) {
for (i = 0U; i < 2U; ++i) {
FileFinish *finish = &self->write_finish[i];
if (finish->occupied && finish->write_serial == reserved_serial && finish->call == IEC104_FILE_SERVICE_CALL_COMMIT) {
finish->call = IEC104_FILE_SERVICE_CALL_ABORT_WRITE;
finish->reason = IEC104_FILE_SERVICE_END_TIMEOUT; ++self->status.commits_cancelled;
}
}
}
result = FS_CLOSE(self->slave, &identity, NULL);
if (!Closed_Result(result)) {
++self->status.close_errors; Fault(self, &identity, true); return false;
}
Cancel_All(self, true); self->status.active = false;
return true;
}
/**
* 功能:-1新故障,0无变化,1发生确定的本地推进。Execute不能把纯超时清理报成EMPTY,
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回0、Reply_Timeout(self, &task->source, 0U) ? 1 : -1、Reply_Timeout(self, &self->activation.source, 0U) ? 1 : -1、Reply_Timeout(self, &confirm->source, confirm->reserved ? confirm->write_serial : 0U) ? 1 : -1、-1、changed。
* 说明:否则保留事件的BUSY循环会把已腾出槽误认为没有进展。
*/
static int Expire(IEC104_FileService_t *self)
{
uint64_t now = FS_NOW();
unsigned i;
int changed = 0;
if (self->status.faulted) { return 0; }
/* 回复从形成就计时,检查全部固定回复及预留槽;不能仅检查最早一条。 */
for (i = 0U; i < self->task_count; ++i) {
FileTask *task = &self->tasks[self->order[i]];
if (task->phase == FS_REPLY && Expired(now, task->work.reply.formed_ms, self->config.reply_timeout_ms)) {
return Reply_Timeout(self, &task->source, 0U) ? 1 : -1;
}
}
if (self->activation.occupied && self->activation.phase == FS_REPLY &&
Expired(now, self->activation.work.reply.formed_ms, self->config.reply_timeout_ms)) {
return Reply_Timeout(self, &self->activation.source, 0U) ? 1 : -1;
}
for (i = 0U; i < IEC104_FILE_SERVICE_CONFIRM_CAPACITY; ++i) {
FileConfirm *confirm = &self->confirms[i];
if (confirm->occupied && Expired(now, confirm->formed_ms, self->config.reply_timeout_ms)) {
return Reply_Timeout(self, &confirm->source, confirm->reserved ? confirm->write_serial : 0U) ? 1 : -1;
}
}
if (self->directory.occupied && self->directory.task_alive && !self->directory.closing && !self->directory.closed &&
Expired(now, self->directory.opened_ms, self->config.directory_timeout_ms)) {
++self->status.directory_timeouts;
if (!Directory_Failed(self, IEC104_FILE_SERVICE_END_TIMEOUT)) { return -1; }
changed = 1;
}
if (self->reader.occupied && self->reader.phase == FS_READ_DATA &&
Expired(now, self->reader.progress_ms, self->config.read_idle_timeout_ms)) {
++self->status.read_timeouts;
if (!End_Read(self, IEC104_FILE_SERVICE_END_TIMEOUT)) { return -1; }
changed = 1;
}
if (self->writer.occupied && self->writer.op8_sent &&
Expired(now, Write_Progress(&self->writer), self->config.write_idle_timeout_ms)) {
++self->status.write_timeouts;
if (!Fail_Write(self, 1U, self->writer.segment, IEC104_FILE_SERVICE_END_TIMEOUT)) { return -1; }
changed = 1;
}
if (self->activation.occupied && self->activation.phase == FS_EXECUTE &&
Expired(now, self->activation.source.accepted_ms, self->config.execute_timeout_ms)) {
++self->status.timeouts;
if (!Operation_Error(self, &self->activation, 1U)) { return -1; }
changed = 1;
}
/* 读请求的执行期限只处理FIFO队首,后方超时不提前越序形成回复。 */
if (self->task_count != 0U) {
FileTask *task = &self->tasks[self->order[0]];
if (task->phase == FS_EXECUTE && Expired(now, task->source.accepted_ms, self->config.execute_timeout_ms)) {
++self->status.timeouts;
if (!Operation_Error(self, task, 1U)) { return -1; }
changed = 1;
}
}
return changed;
}
/**
* 功能:只按日历分量比较,忽略星期/SU;
* 输入参数:a——const IEC60870_CP56Time2a_t *所指数据。
* b——const IEC60870_CP56Time2a_t *所指数据。
* 输出参数:无。
* 返回值:按处理分支返回a->time.field < b->time.field ? -1 : 1、0。
* 说明:查询和条目的CP56合法性在调用前检查。
*/
static int Time_Compare(const IEC60870_CP56Time2a_t *a, const IEC60870_CP56Time2a_t *b)
{
#define FS_TIME_COMPARE(field) if (a->time.field != b->time.field) { return a->time.field < b->time.field ? -1 : 1; }
FS_TIME_COMPARE(year)
FS_TIME_COMPARE(month)
FS_TIME_COMPARE(day)
FS_TIME_COMPARE(hour)
FS_TIME_COMPARE(minute)
FS_TIME_COMPARE(second)
FS_TIME_COMPARE(ms)
#undef FS_TIME_COMPARE
return 0;
}
/**
* 功能:校验目录名称、过滤标志及两份CP56字段的长度/有效性,不比较起止顺序。
* 输入参数:self——本模块实例。
* data——数据存储。
* length——字节长度。
* 输出参数:无。
* 返回值:目录名、过滤标志和适用的时标字段符合本服务配置返回true,否则false。
* 说明:未启用过滤时忽略时标内容;仅显式兼容配置允许同时省略两份时标。
*/
static bool Directory_Request_Valid(const IEC104_FileService_t *self, const uint8_t *data, uint16_t length)
{
unsigned name_length, position;
IEC60870_CP56Time2a_t first, last;
if (length < 16U) { return false; }
name_length = data[15]; position = 16U + name_length;
if (name_length > IEC104_FILE_SERVICE_MAX_DIRECTORY_NAME || length <= position || data[position] > 1U) { return false; }
if (data[position] == 0U) {
/* 不过滤时仍默认要求完整14字节时标,但忽略内容;兼容项仅放行全部省略。 */
return length == position + 15U || (self->config.allow_short_directory_request && length == position + 1U);
}
return length == position + 15U &&
IEC60870_Time_From_CP56(data + position + 1U, 7U, &first) != 0 && first.is_invalid == 0U &&
IEC60870_Time_From_CP56(data + position + 8U, 7U, &last) != 0 && last.is_invalid == 0U;
}
/**
* 功能:仅返回结构错误对应的结果码;op9的模和、文件ID、偏移及剩余长度按环序执行。
* 输入参数:self——本模块实例。
* data——数据存储。
* length——字节长度。
* operation——操作类型。
* 输出参数:无。
* 返回值:仅返回结构错误对应的结果码;
* 说明:已确认前缀与操作合法后才进入这里,避免先读变长字段再补长度检查。
*/
static uint8_t Check_Structure(const IEC104_FileService_t *self, const uint8_t *data, uint16_t length, uint8_t operation)
{
unsigned size;
if (operation == 1U) { return Directory_Request_Valid(self, data, length) ? 0U : 1U; }
if (operation == 6U) { return length == 20U ? 0U : 1U; }
if (operation == 9U) { return length >= 21U && data[19] <= 1U ? 0U : 1U; }
if (length < 12U) { return 1U; }
size = data[11];
if (size == 0U || size > IEC104_FILE_SERVICE_MAX_FILE_NAME) { return operation == 7U ? 2U : 1U; }
return length == (operation == 7U ? 20U : 12U) + size ? 0U : 1U;
}
/**
* 功能:记录原I帧来源,不从当前连接重建身份。
* 输入参数:source——源数据。
* identity——原会话身份。
* event——事件。
* data——数据存储。
* station——逻辑站点。
* 输出参数:source——源数据的更新结果。
* 返回值:无。
* 说明:此处station仅借用,尚未Acquire。
*/
static void Source_Event(FileSource *source, const IEC104_SlaveEventIdentity_t *identity,
const IEC104_SlaveEvent_t *event, const uint8_t *data, IEC104_Station_t *station)
{
memset(source, 0, sizeof(*source));
source->identity = *identity; source->station = station;
source->station_id = IEC104_Station_Get_Id(station);
source->receive_serial = event->transport.data.i_frame.receive_serial;
source->accepted_ms = FS_NOW(); source->ca = Read16(data + 4U); source->oa = data[3];
source->test = (data[2] & 0x80U) != 0U;
}
/**
* 功能:先找空槽再Acquire,成功后才发布occupied/FIFO顺序;满槽丢新不取代旧会话。
* 输入参数:self——本模块实例。
* source——源数据。
* bytes——字节存储。
* length——字节长度。
* operation——操作类型。
* activation——活动轮次。
* 输出参数:self——本模块实例的更新结果。
* 返回值:按处理分支返回NULL、task。
* 说明:后续OPEN将此引用转给资源,失败请求则持有到确认交出或任务取消。
*/
static FileTask *Queue_Task(IEC104_FileService_t *self, const FileSource *source,
const uint8_t *bytes, uint16_t length, uint8_t operation, bool activation)
{
FileTask *task = NULL;
unsigned i;
if (activation) { if (!self->activation.occupied) { task = &self->activation; } }
else if (self->task_count < IEC104_FILE_SERVICE_TASK_CAPACITY) {
for (i = 0U; i < IEC104_FILE_SERVICE_TASK_CAPACITY; ++i) {
if (!self->tasks[i].occupied) { task = &self->tasks[i]; self->order[self->task_count] = i; break; }
}
}
if (task == NULL) { ++self->status.dropped_requests; return NULL; }
if (source->station != NULL && IEC104_Slave_Acquire_Station(self->slave, source->station) != IEC104_STATION_OK) { return NULL; }
memset(task, 0, sizeof(*task)); task->occupied = true; task->source = *source;
memcpy(task->bytes, bytes, length); task->length = length; task->operation = operation; task->phase = FS_EXECUTE;
if (!activation) { ++self->task_count; }
return task;
}
/**
* 功能:仅在新激活实际入槽后调用。旧待执行激活改否定,已打开读资源立即停发;
* 输入参数:self——本模块实例。
* new_task——const FileTask *所指数据。
* 输出参数:self——本模块实例的更新结果。
* 返回值:!Operation_Error(self, task, 1U)时返回false;!End_Read(self, IEC104_FILE_SERVICE_END_SUPERSEDED)时返回false;其余分支返回false、true。
* 说明:不区分CA/T,已安排的旧CLOSE由独立收尾记录保留,不会再安排第二次。
*/
static bool Supersede_Read(IEC104_FileService_t *self, const FileTask *new_task)
{
unsigned i;
for (i = 0U; i < self->task_count; ++i) {
FileTask *task = &self->tasks[self->order[i]];
if (task == new_task || task->operation != 3U) { continue; }
if (task->phase == FS_EXECUTE) { if (!Operation_Error(self, task, 1U)) { return false; } }
else if (task->phase == FS_REPLY && task->length >= 21U && task->bytes[10] == 4U && task->bytes[11] == 0U) {
/* 原回复已经有形成序号,取代只改结果/大小,不重启回复期限。 */
task->bytes[2] |= 0x40U; task->bytes[11] = 1U;
Write32(task->bytes + 17U + task->bytes[12], 0U);
}
}
if (!End_Read(self, IEC104_FILE_SERVICE_END_SUPERSEDED)) { return false; }
memset(&self->recent_read, 0, sizeof(self->recent_read));
return true;
}
/**
* 功能:只终结仍打开的writer,不改已经安排的COMMIT/ABORT;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:Move_Write_To_Finish(self, IEC104_FILE_SERVICE_CALL_ABORT_WRITE, IEC104_FILE_SERVICE_END_SUPERSEDED) == NULL时返回false;其余分支返回false、true。
* 说明:新激活是近期记录边界。
*/
static bool Supersede_Write(IEC104_FileService_t *self)
{
if (self->writer.occupied) {
if (self->writer.source.test) { Release_Source(self, &self->writer.source); memset(&self->writer, 0, sizeof(self->writer)); }
else if (Move_Write_To_Finish(self, IEC104_FILE_SERVICE_CALL_ABORT_WRITE, IEC104_FILE_SERVICE_END_SUPERSEDED) == NULL) { return false; }
}
memset(&self->silent_write, 0, sizeof(self->silent_write));
memset(&self->empty_write, 0, sizeof(self->empty_write));
return true;
}
/**
* 功能:op6不入队、不回复:最近结束的读归属仍可统计迟到确认,但只有DATA会话可停发。
* 输入参数:self——本模块实例。
* source——源数据。
* result——处理结果。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:非零结果仅作诊断;是否据此中止由显式模式决定,不推断规范的失败含义。
*/
static void Receive_Read_Confirm(IEC104_FileService_t *self, const FileSource *source, uint8_t result)
{
bool active = self->reader.occupied && self->reader.phase == FS_READ_DATA && Same_Source(source, &self->reader.source);
bool match = active || (self->read_finish.occupied && Same_Source(source, &self->read_finish.source)) ||
(self->recent_read.valid && Same_Source(source, &self->recent_read.source));
if (!match) { ++self->status.rejected; return; }
++self->status.read_confirms; if (result != 0U) { ++self->status.read_confirm_nonzero; }
if (active && (self->config.read_confirm_mode == IEC104_FILE_SERVICE_READ_CONFIRM_STOP_ANY ||
(self->config.read_confirm_mode == IEC104_FILE_SERVICE_READ_CONFIRM_STOP_NONZERO && result != 0U))) {
(void)End_Read(self, IEC104_FILE_SERVICE_END_MASTER);
}
}
/**
* 功能:填入全功能、偏移校验及末段确认等默认策略和期限;
* 输入参数:config——配置。
* 输出参数:config——配置的更新结果。
* 返回值:无。
* 说明:NULL无操作,不绑定Slave或打开文件。
*/
void IEC104_FileService_Config_Default(IEC104_FileServiceConfig_t *config)
{
if (config == NULL) { return; }
memset(config, 0, sizeof(*config));
config->features = IEC104_FILE_SERVICE_FEATURE_ALL;
config->segment_mode = IEC104_FILE_SERVICE_SEGMENT_OFFSET;
config->write_confirm_mode = IEC104_FILE_SERVICE_WRITE_CONFIRM_FINAL;
config->read_confirm_mode = IEC104_FILE_SERVICE_READ_CONFIRM_COUNT;
config->id_mode = IEC104_FILE_SERVICE_ID_ZERO; config->write_confirm_cause = 7U;
config->read_segment_bytes = IEC104_FILE_SERVICE_MAX_SEGMENT; config->window_reserve = 2U;
config->list_scan_budget = 64U; config->directory_timeout_ms = 60000U;
config->reply_timeout_ms = 15000U; config->execute_timeout_ms = 15000U;
config->read_idle_timeout_ms = 60000U; config->write_idle_timeout_ms = 60000U;
}
/**
* 功能:固定偏移依赖104的2/2/3字段宽度;全部配置/重复绑定检查通过后才占静态池槽。
* 输入参数:slave——所属从站服务。
* config——配置。
* 输出参数:无。
* 返回值:按处理分支返回NULL、slot。
* 说明:window_reserve与实际k/记录容量的关系推迟到ACTIVATED检查,允许Init前创建。
*/
IEC104_FileService_t *IEC104_FileService_Create(IEC104_Slave_t *slave, const IEC104_FileServiceConfig_t *config)
{
const IEC60870_AppLayerParameters_t *parameters = IEC104_Slave_Get_Application_Layer_Parameters(slave);
IEC104_FileService_t *slot = NULL;
unsigned i;
if (parameters == NULL || config == NULL || parameters->sizeOfCOT != 2 || parameters->sizeOfCA != 2 || parameters->sizeOfIOA != 3 ||
config->features == 0U || (config->features & ~IEC104_FILE_SERVICE_FEATURE_ALL) != 0U ||
(config->segment_mode != IEC104_FILE_SERVICE_SEGMENT_OFFSET && config->segment_mode != IEC104_FILE_SERVICE_SEGMENT_UNCHECKED) ||
(config->write_confirm_mode != IEC104_FILE_SERVICE_WRITE_CONFIRM_FINAL && config->write_confirm_mode != IEC104_FILE_SERVICE_WRITE_CONFIRM_EACH) ||
(config->read_confirm_mode != IEC104_FILE_SERVICE_READ_CONFIRM_COUNT && config->read_confirm_mode != IEC104_FILE_SERVICE_READ_CONFIRM_STOP_NONZERO &&
config->read_confirm_mode != IEC104_FILE_SERVICE_READ_CONFIRM_STOP_ANY) ||
(config->id_mode != IEC104_FILE_SERVICE_ID_ZERO && config->id_mode != IEC104_FILE_SERVICE_ID_ECHO) ||
(config->write_confirm_cause != 5U && config->write_confirm_cause != 7U) || config->read_segment_bytes == 0U ||
config->read_segment_bytes > IEC104_FILE_SERVICE_MAX_SEGMENT || config->window_reserve == 0U ||
config->list_scan_budget == 0U || config->reply_timeout_ms == 0U || next_instance_id == UINT64_MAX) { return NULL; }
for (i = 0U; i < IEC104_FILE_SERVICE_CAPACITY; ++i) {
if (file_pool[i].in_use && file_pool[i].slave == slave) { return NULL; }
if (!file_pool[i].in_use && slot == NULL) { slot = &file_pool[i]; }
}
if (slot == NULL) { return NULL; }
memset(slot, 0, sizeof(*slot)); slot->slave = slave; slot->config = *config;
slot->instance_id = ++next_instance_id; slot->in_use = true;
return slot;
}
/**
* 功能:Destroy不隐式Cancel,也不交付回调。faulted即使已无任务仍须证明原连接结束,
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:self->write_finish[i].occupied时返回false;self->confirms[i].occupied时返回false;!self->fault_ended时返回false;其余分支返回false、true。
* 说明:防止在同一健康TCP代次上通过Destroy/Create跳过故障隔离。
*/
bool IEC104_FileService_Destroy(IEC104_FileService_t *self)
{
IEC104_TcpServerStatus_t status;
unsigned i;
if (!Owned(self) || self->in_callback || self->task_count != 0U || self->activation.occupied ||
self->segment_count != 0U || self->directory.occupied || self->reader.occupied || self->writer.occupied || self->read_finish.occupied) { return false; }
for (i = 0U; i < 2U; ++i) { if (self->write_finish[i].occupied) { return false; } }
for (i = 0U; i < IEC104_FILE_SERVICE_CONFIRM_CAPACITY; ++i) { if (self->confirms[i].occupied) { return false; } }
if (self->status.faulted && !self->fault_ended) {
if (FS_STATUS(self->slave, &status, NULL) == IEC104_TCP_OK &&
(!status.connected || status.generation != self->fault_identity.generation)) { self->fault_ended = true; }
if (!self->fault_ended) { return false; }
}
memset(self, 0, sizeof(*self)); return true;
}
/**
* 功能:取消协议任务并保留外部资源的收尾责任;不在本入口执行应用回调。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:调用方仍须提供原handlers/context推进Execute,直至关闭/中止完成后才能Destroy。
*/
void IEC104_FileService_Cancel(IEC104_FileService_t *self)
{
if (!Owned(self) || self->in_callback) { return; }
Cancel_All(self, false);
}
/**
* 功能:生命周期先处理,再按无状态校验顺序分流I帧。本入口只登记/取代协议状态,
* 输入参数:self——本模块实例。
* event——事件。
* 输出参数:self——本模块实例的更新结果。
* 返回值:返回IEC104_FileServiceEventResult_t结果;本函数显式处理IEC104_FILE_SERVICE_EVENT_ERROR、IEC104_FILE_SERVICE_EVENT_IGNORED、IEC104_FILE_SERVICE_EVENT_HANDLED、IEC104_FILE_SERVICE_TASK_CAPACITY、IEC104_FILE_SERVICE_EVENT_BUSY,其余结果由下层调用传回。
* 说明:不执行存储回调;BUSY时未消费事件,应用必须保留原事件并在本地推进后重试。
*/
IEC104_FileServiceEventResult_t IEC104_FileService_Handle_Event(IEC104_FileService_t *self, const IEC104_SlaveEvent_t *event)
{
IEC104_SlaveEventIdentity_t identity;
IEC104_Station_t *station;
FileSource source;
FileTask *task;
const uint8_t *data;
uint16_t length;
uint8_t cause, operation = 0U, error = 0U, feature = 0U, mirror = 0U;
bool drop = false, rejected = false, malformed = false;
if (!Owned(self) || self->in_callback || !IEC104_Slave_Get_Event_Identity(self->slave, event, &identity) ||
(self->session.instance_id != 0U && self->session.instance_id != identity.instance_id)) { return IEC104_FILE_SERVICE_EVENT_ERROR; }
if (event->transport.type == IEC104_TCP_EVENT_CONNECTED) {
if (self->session.generation != 0U && identity.generation < self->session.generation) { return IEC104_FILE_SERVICE_EVENT_IGNORED; }
Cancel_All(self, true);
if (self->status.faulted && !Same_Identity(&identity, &self->fault_identity)) { self->fault_ended = true; }
self->session = identity; self->status.active = false; self->status.reserve_invalid = false;
return IEC104_FILE_SERVICE_EVENT_HANDLED;
}
if (event->transport.type == IEC104_TCP_EVENT_DISCONNECTED && self->status.faulted && Same_Identity(&identity, &self->fault_identity)) { self->fault_ended = true; }
if (!Same_Identity(&identity, &self->session)) { return IEC104_FILE_SERVICE_EVENT_IGNORED; }
switch (event->transport.type) {
case IEC104_TCP_EVENT_ACTIVATED:
if (!self->status.faulted) {
IEC104_TcpSendCapacity_t capacity;
IEC104_TcpResult_t result = FS_CAPACITY(self->slave, &capacity, NULL);
/* Close后读出的历史ACTIVATED只消费,不重新激活或误报reserve非法。 */
if (result == IEC104_TCP_INVALID_STATE) { return IEC104_FILE_SERVICE_EVENT_HANDLED; }
if (result != IEC104_TCP_OK) { return IEC104_FILE_SERVICE_EVENT_ERROR; }
self->status.reserve_invalid = self->config.window_reserve >= capacity.window_k || self->config.window_reserve >= capacity.record_capacity;
self->status.active = true;
}
return IEC104_FILE_SERVICE_EVENT_HANDLED;
case IEC104_TCP_EVENT_DEACTIVATED:
case IEC104_TCP_EVENT_DISCONNECTED:
Cancel_All(self, true); self->status.active = false;
if (event->transport.type == IEC104_TCP_EVENT_DISCONNECTED) { self->status.reserve_invalid = false; }
return IEC104_FILE_SERVICE_EVENT_HANDLED;
case IEC104_TCP_EVENT_I_FRAME: break;
default: return IEC104_FILE_SERVICE_EVENT_IGNORED;
}
if (event->asdu_result != IEC60870_ASDU_OK || IEC60870_Asdu_Get_Data(&event->asdu, &data, &length) != IEC60870_ASDU_OK ||
length < 6U || length > 249U || data[0] != IEC104_FILE_SERVICE_TYPE_ID) { return IEC104_FILE_SERVICE_EVENT_IGNORED; }
/* faulted只吞本模块Type210,防止应用继续44兜底;其他业务类型仍可分派。 */
if (self->status.faulted) { ++self->status.faulted_dropped; return IEC104_FILE_SERVICE_EVENT_HANDLED; }
if (!self->status.active) { return IEC104_FILE_SERVICE_EVENT_IGNORED; }
cause = data[2] & 0x3FU;
station = Read16(data + 4U) == 65535U ? NULL : IEC104_Slave_Get_Station(self->slave, Read16(data + 4U));
Source_Event(&source, &identity, event, data, station);
/* 优先级:COT -> CA -> 可读IOA -> 前缀 -> 操作COT -> 功能 -> 结构。 */
if (cause != 5U && cause != 6U) { mirror = 45U; }
else if (station == NULL) { mirror = 46U; }
else if (length >= 9U && (data[6] != 0U || data[7] != 0U || data[8] != 0U)) { mirror = 47U; }
else if (length < 11U || data[9] != IEC104_FILE_SERVICE_PACKAGE_FILE || (data[2] & 0x40U) != 0U ||
(data[10] != 1U && data[10] != 3U && data[10] != 6U && data[10] != 7U && data[10] != 9U)) {
if (cause == 6U) { mirror = 7U; } else { drop = true; rejected = true; }
} else {
operation = data[10];
if (((operation == 3U || operation == 7U) && cause != 6U) ||
((operation == 6U || operation == 9U) && cause != 5U)) { mirror = 45U; }
else {
feature = operation == 1U ? IEC104_FILE_SERVICE_FEATURE_DIRECTORY :
((operation == 3U || operation == 6U) ? IEC104_FILE_SERVICE_FEATURE_READ : IEC104_FILE_SERVICE_FEATURE_WRITE);
if ((self->config.features & feature) == 0U) {
if (operation == 9U) { ++self->status.stray_segments; drop = true; }
else if (operation == 6U) { drop = true; rejected = true; }
else { error = 1U; }
} else {
error = Check_Structure(self, data, length, operation);
if (operation == 9U) { malformed = error != 0U; error = 0U; }
else if (operation == 6U && error != 0U) { error = 0U; drop = true; rejected = true; }
}
}
}
if (mirror != 0U || error != 0U || rejected) { ++self->status.rejected; }
if (drop) { return IEC104_FILE_SERVICE_EVENT_HANDLED; }
if (mirror != 0U || error != 0U) {
unsigned before = self->task_count;
task = Queue_Task(self, &source, data, length, operation, false);
if (task == NULL) { return before == IEC104_FILE_SERVICE_TASK_CAPACITY ? IEC104_FILE_SERVICE_EVENT_HANDLED : IEC104_FILE_SERVICE_EVENT_ERROR; }
if (!(mirror != 0U ? Mirror_Error(self, task, mirror) : Operation_Error(self, task, error))) { return IEC104_FILE_SERVICE_EVENT_HANDLED; }
return IEC104_FILE_SERVICE_EVENT_HANDLED;
}
if (operation == 6U) { Receive_Read_Confirm(self, &source, data[19]); return IEC104_FILE_SERVICE_EVENT_HANDLED; }
if (operation == 9U) {
FileSegment *segment;
unsigned index, i;
uint8_t checksum = 0U;
/* 格式/模和错误也须按环序处理,不能越过前面的合法段提前终结会话。
* 满环时不复制、不Acquire、不增加accepted,重试仍使用同一原事件。 */
if (self->segment_count == IEC104_FILE_SERVICE_SEGMENT_CAPACITY) { ++self->status.busy_returns; return IEC104_FILE_SERVICE_EVENT_BUSY; }
index = (self->segment_head + self->segment_count) % IEC104_FILE_SERVICE_SEGMENT_CAPACITY;
segment = &self->segments[index]; memset(segment, 0, sizeof(*segment));
segment->write_serial = self->next_write; segment->station_id = source.station_id;
segment->generation = identity.generation; segment->ca = source.ca; segment->oa = source.oa; segment->test = source.test;
segment->receive_serial = source.receive_serial; segment->accepted_ms = source.accepted_ms; segment->malformed = malformed;
if (length >= 15U) { segment->file_id = Read32(data + 11U); }
if (length >= 19U) { segment->segment = Read32(data + 15U); }
if (length >= 20U) { segment->more = data[19] != 0U; }
if (length >= 21U) {
segment->length = (uint16_t)(length - 21U);
memcpy(segment->data, data + 20U, segment->length);
for (i = 0U; i < segment->length; ++i) { checksum = (uint8_t)(checksum + segment->data[i]); }
segment->bad_sum = checksum != data[length - 1U];
}
++self->segment_count; ++self->status.accepted;
return IEC104_FILE_SERVICE_EVENT_HANDLED;
}
/* TEST写不能抢占真实打开会话;拒绝走普通错误FIFO,不改变写序号。 */
if (operation == 7U && source.test && self->writer.occupied && !self->writer.source.test) {
unsigned before = self->task_count;
++self->status.rejected;
task = Queue_Task(self, &source, data, length, operation, false);
if (task == NULL) { return before == IEC104_FILE_SERVICE_TASK_CAPACITY ? IEC104_FILE_SERVICE_EVENT_HANDLED : IEC104_FILE_SERVICE_EVENT_ERROR; }
(void)Operation_Error(self, task, 1U); return IEC104_FILE_SERVICE_EVENT_HANDLED;
}
{
bool full = operation == 7U ? self->activation.occupied : self->task_count == IEC104_FILE_SERVICE_TASK_CAPACITY;
task = Queue_Task(self, &source, data, length, operation, operation == 7U);
if (task == NULL) { return full ? IEC104_FILE_SERVICE_EVENT_HANDLED : IEC104_FILE_SERVICE_EVENT_ERROR; }
}
++self->status.accepted;
/* 直到入槽成功才产生取代副作用;写序号把之后到达的数据段绑定到这次激活。 */
if (operation == 3U) { (void)Supersede_Read(self, task); }
else if (operation == 7U) {
if (!Next_Serial(self, &self->next_write, &task->work.reply.write_serial, &source.identity)) { return IEC104_FILE_SERVICE_EVENT_HANDLED; }
(void)Supersede_Write(self);
}
return IEC104_FILE_SERVICE_EVENT_HANDLED;
}
/**
* 功能:每轮即使need_process=false也可调用以重试WAIT。先检查期限,再验证会话并提交;
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:每轮即使need_process=false也可调用以重试WAIT。
* true表示本轮正常结束,不表示队列已空。
* 说明:true表示本轮正常结束,不表示队列已空。故障时清理仍由Execute_Next交付。
*/
bool IEC104_FileService_Process(IEC104_FileService_t *self)
{
IEC104_SlaveRequestState_t state;
if (!Owned(self) || self->in_callback) { return false; }
if (self->status.faulted) { return false; }
if (Expire(self) < 0) { return false; }
if (self->session.instance_id == 0U || !self->status.active) { return true; }
state = Check(self, &self->session);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return false; }
if (state != IEC104_SLAVE_REQUEST_READY) { return true; }
return Flush_Replies(self) >= 0;
}
/**
* 功能:检查是否为协议可表达的四种应用结果;
* 输入参数:result——处理结果。
* 输出参数:无。
* 返回值:其他枚举值返回false,交由调用方计数和归一化。
* 说明:其他枚举值返回false,交由调用方计数和归一化。
*/
static bool Valid_Result(IEC104_FileServiceResult_t result)
{
return result == IEC104_FILE_SERVICE_RESULT_OK || result == IEC104_FILE_SERVICE_RESULT_FAILED ||
result == IEC104_FILE_SERVICE_RESULT_NAME_UNSUPPORTED || result == IEC104_FILE_SERVICE_RESULT_SIZE_OUT_OF_RANGE;
}
/**
* 功能:同步借用期间阻止修改入口重入;
* 输入参数:self——本模块实例。
* handlers——回调集合。
* context——调用方上下文。
* request——请求。
* open——IEC104_FileServiceOpen_t *所指数据。
* 输出参数:self——本模块实例的更新结果。
* 返回值:返回result的结果。
* 说明:此保护不保存handlers/context,也不替代串行调用约束。
*/
static IEC104_FileServiceResult_t Action(IEC104_FileService_t *self,
const IEC104_FileServiceHandlers_t *handlers, void *context,
const IEC104_FileServiceRequest_t *request, IEC104_FileServiceOpen_t *open)
{
IEC104_FileServiceResult_t result;
self->in_callback = true;
result = handlers->action(context, request, open);
self->in_callback = false;
return result;
}
/**
* 功能:所有应用借用都现用现建;
* 输入参数:self——本模块实例。
* task——业务任务。
* call——IEC104_FileServiceCall_t值。
* request——请求。
* 输出参数:request——请求的更新结果。
* 返回值:无。
* 说明:目录名保留在尚未冻结回复的任务原文中。
*/
static void Directory_Request(const IEC104_FileService_t *self, const FileTask *task,
IEC104_FileServiceCall_t call, IEC104_FileServiceRequest_t *request)
{
unsigned position = 16U + task->bytes[15];
Request_From(self, &task->source, call, request);
request->name_length = task->bytes[15];
request->name = request->name_length != 0U ? task->bytes + 16U : NULL;
request->time_filter = task->bytes[position] != 0U;
if (request->time_filter) {
(void)IEC60870_Time_From_CP56(task->bytes + position + 1U, 7U, &request->start_time);
(void)IEC60870_Time_From_CP56(task->bytes + position + 8U, 7U, &request->stop_time);
}
if (call == IEC104_FILE_SERVICE_CALL_NONE) { request->handle = self->directory.handle; }
}
/**
* 功能:打开成功只建立快照和总期限,本次不继续list;原站引用从任务转入目录资源。
* 输入参数:self——本模块实例。
* task——业务任务。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:按处理分支返回IEC104_FILE_SERVICE_EXECUTE_EMPTY、IEC104_FILE_SERVICE_EXECUTE_OK。
* 说明:打开失败没有CLOSE,应用必须已自行释放临时资源。
*/
static IEC104_FileServiceExecuteResult_t Open_Directory(IEC104_FileService_t *self, FileTask *task,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
IEC104_FileServiceRequest_t request;
IEC104_FileServiceOpen_t open;
IEC104_FileServiceResult_t result;
if (self->directory.occupied) { return IEC104_FILE_SERVICE_EXECUTE_EMPTY; }
Directory_Request(self, task, IEC104_FILE_SERVICE_CALL_OPEN_DIRECTORY, &request);
memset(&open, 0, sizeof(open));
result = Action(self, handlers, context, &request, &open);
if (!Valid_Result(result)) { ++self->status.invalid_callbacks; }
if (result != IEC104_FILE_SERVICE_RESULT_OK) {
if (Operation_Error(self, task, 1U)) { (void)Flush_Replies(self); }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
memset(&self->directory, 0, sizeof(self->directory));
self->directory.occupied = true; self->directory.task_alive = true;
self->directory.source = task->source; task->source.station = NULL;
self->directory.task_index = (unsigned)(task - self->tasks);
self->directory.handle = open.handle; self->directory.opened_ms = FS_NOW();
memset(&task->work, 0, sizeof(task->work));
task->phase = FS_DIRECTORY; task->cursor = 0U; task->waiting = false;
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/**
* 功能:预算耗尽时暂不发送含条目的候选页,跨轮前瞻到下一匹配项或END再重建。
* 输入参数:self——本模块实例。
* task——业务任务。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:按处理分支返回IEC104_FILE_SERVICE_EXECUTE_EMPTY、IEC104_FILE_SERVICE_EXECUTE_OK、called ? IEC104_FILE_SERVICE_EXECUTE_OK : IEC104_FILE_SERVICE_EXECUTE_ERROR、IEC104_FILE_SERVICE_EXECUTE_WAIT、expired < 0 && !called ? IEC104_FILE_SERVICE_EXECUTE_ERROR : IEC104_FILE_SERVICE_EXECUTE_OK。
* 说明:非空结果的末页因此始终含真实条目;真空目录/错误仍使用规范的零项末帧。
* 这样避免非空目录额外以零项帧收尾,兼容不接受纯头部目录确认帧的接收端。
* 扫描、前瞻、重建各轮均受list_scan_budget限制;WAIT从固定页首重建。
* 原请求始终保留,重建只使用现有工作缓冲,目录快照必须保持不变。
*/
static IEC104_FileServiceExecuteResult_t Scan_Directory(IEC104_FileService_t *self, FileTask *task,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
IEC104_FileServiceRequest_t request;
IEC104_SlaveRequestState_t state;
bool lookahead = task->work.directory.phase == 1U;
bool rebuild = task->work.directory.phase == 2U;
size_t cursor = lookahead ? task->work.directory.next : task->cursor;
uint16_t length = 18U;
uint8_t count = 0U, cause = (task->bytes[2] & 0x3FU) == 5U ? 5U : 7U;
unsigned scanned = 0U;
bool last = false, called = false, more = false;
uint64_t sequence;
int sent, expired;
if (Has_Reply(self)) { return IEC104_FILE_SERVICE_EXECUTE_EMPTY; }
Directory_Request(self, task, IEC104_FILE_SERVICE_CALL_NONE, &request);
Prefix(self->buffer, &task->source, 2U, cause, 0U);
self->buffer[11] = 0U; Write32(self->buffer + 12U, Output_Id(self, Read32(task->bytes + 11U)));
if (request.time_filter && Time_Compare(&request.start_time, &request.stop_time) > 0) { last = true; }
while (!last && scanned < self->config.list_scan_budget &&
(!rebuild || cursor < task->work.directory.page_end)) {
IEC104_FileServiceEntry_t entry;
IEC104_FileServiceListResult_t result;
uint8_t time_bytes[7];
unsigned item_length;
bool selected;
memset(&entry, 0, sizeof(entry));
self->in_callback = true;
result = handlers->list(context, &request, cursor, &entry);
self->in_callback = false; called = true; ++scanned;
if (result == IEC104_FILE_SERVICE_LIST_END) { last = true; break; }
if (result == IEC104_FILE_SERVICE_LIST_NO_DIRECTORY && cursor == 0U) {
(void)Directory_Failed(self, IEC104_FILE_SERVICE_END_ERROR);
(void)Flush_Replies(self); return IEC104_FILE_SERVICE_EXECUTE_OK;
}
if (result != IEC104_FILE_SERVICE_LIST_ENTRY) {
if (result != IEC104_FILE_SERVICE_LIST_ERROR) { ++self->status.invalid_callbacks; }
(void)Directory_Failed(self, IEC104_FILE_SERVICE_END_ERROR);
(void)Flush_Replies(self); return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/* 即使条目稍后会被过滤,也须先检查输出;SIZE_MAX可END但不能再ENTRY递增。 */
if (entry.name == NULL || entry.name_length == 0U || entry.name_length > IEC104_FILE_SERVICE_MAX_DIRECTORY_NAME ||
IEC60870_Time_To_CP56(&entry.time, time_bytes, sizeof(time_bytes)) == 0 || cursor == SIZE_MAX) {
++self->status.invalid_callbacks;
(void)Directory_Failed(self, IEC104_FILE_SERVICE_END_ERROR);
(void)Flush_Replies(self); return IEC104_FILE_SERVICE_EXECUTE_OK;
}
selected = !request.time_filter || (entry.time.is_invalid == 0U &&
Time_Compare(&entry.time, &request.start_time) >= 0 && Time_Compare(&entry.time, &request.stop_time) <= 0);
if (!selected) { ++cursor; continue; }
if (lookahead) { more = true; break; }
item_length = 13U + entry.name_length;
if (item_length > 249U - length) {
if (count == 0U) {
++self->status.invalid_callbacks;
(void)Directory_Failed(self, IEC104_FILE_SERVICE_END_ERROR);
(void)Flush_Replies(self); return IEC104_FILE_SERVICE_EXECUTE_OK;
}
more = true; break;
}
self->buffer[length] = entry.name_length;
memcpy(self->buffer + length + 1U, entry.name, entry.name_length);
self->buffer[length + 1U + entry.name_length] = entry.attribute;
Write32(self->buffer + length + 2U + entry.name_length, entry.size);
memcpy(self->buffer + length + 6U + entry.name_length, time_bytes, sizeof(time_bytes));
length = (uint16_t)(length + item_length); ++count; ++cursor;
}
/* list已经调用过也不能直接发送:再次确认原会话和总期限,失败丢弃本轮条目。 */
state = Check(self, &task->source.identity);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return called ? IEC104_FILE_SERVICE_EXECUTE_OK : IEC104_FILE_SERVICE_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_STALE) { return IEC104_FILE_SERVICE_EXECUTE_OK; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_FILE_SERVICE_EXECUTE_WAIT; }
expired = Expire(self);
if (expired != 0) { return expired < 0 && !called ? IEC104_FILE_SERVICE_EXECUTE_ERROR : IEC104_FILE_SERVICE_EXECUTE_OK; }
if (lookahead) {
/* 找到的匹配项尚未消费,next仍指向它;重建并发出本页后,它将作为下一页首项。 */
task->work.directory.next = cursor;
if (last || more) { task->work.directory.phase = 2U; task->work.directory.more = more; }
task->waiting = false;
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
if (rebuild) { last = !task->work.directory.more; }
else if (count != 0U && !last && !more) {
/* 恰好耗尽本轮预算,尚不能确定CONT;仅保存边界,下一轮先找后续项。 */
task->work.directory.page_end = cursor; task->work.directory.next = cursor;
task->work.directory.phase = 1U; task->waiting = false;
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
if (count == 0U && !last) {
/* 只有已确定不匹配且无需发出的条目可独立提交游标,不发送空CONT=1。 */
task->cursor = cursor; task->waiting = false;
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
self->buffer[16] = last ? 0U : 1U; self->buffer[17] = count;
if (!Next_Serial(self, &self->next_reply, &sequence, &task->source.identity)) {
return called ? IEC104_FILE_SERVICE_EXECUTE_OK : IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
(void)sequence; /* 现组帧没有跨WAIT槽;下一次重取重新参加形成次序。 */
sent = Send(self, &task->source, self->buffer, length, false, false, NULL);
if (sent < 0) { return called ? IEC104_FILE_SERVICE_EXECUTE_OK : IEC104_FILE_SERVICE_EXECUTE_ERROR; }
task->waiting = sent == 0;
if (sent == 0) { return IEC104_FILE_SERVICE_EXECUTE_WAIT; }
/* 只有Send接收整页后才推进游标;WAIT期间保留页首及前瞻结论,便于原样重建。 */
task->cursor = rebuild ? task->work.directory.next : cursor;
task->work.directory.phase = 0U; ++self->status.directory_frames;
if (last) {
++self->status.directories; task->phase = FS_DIRECTORY_DONE;
(void)Close_Directory(self, IEC104_FILE_SERVICE_END_COMPLETE);
}
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/**
* 功能:先接管成功OPEN的handle,再复核回显名;输出非法仍须恰一次CLOSE,不能泄漏资源。
* 输入参数:self——本模块实例。
* task——业务任务。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* task——业务任务的更新结果。
* 返回值:按处理分支返回IEC104_FILE_SERVICE_EXECUTE_ERROR、IEC104_FILE_SERVICE_EXECUTE_OK。
* 说明:固定op4交给HIGH之前维持OPEN阶段,数据读取由Task_Sent切入DATA。
*/
static IEC104_FileServiceExecuteResult_t Open_Read(IEC104_FileService_t *self, FileTask *task,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
IEC104_FileServiceRequest_t request;
IEC104_FileServiceOpen_t open;
IEC104_FileServiceResult_t result;
const uint8_t *name;
uint8_t name_length;
if (self->status.reserve_invalid) {
if (!Operation_Error(self, task, 1U) || Flush_Replies(self) < 0) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
Request_From(self, &task->source, IEC104_FILE_SERVICE_CALL_OPEN_READ, &request);
request.name = task->bytes + 12U; request.name_length = task->bytes[11];
memset(&open, 0, sizeof(open)); result = Action(self, handlers, context, &request, &open);
if (!Valid_Result(result)) { ++self->status.invalid_callbacks; }
if (result != IEC104_FILE_SERVICE_RESULT_OK) {
if (Operation_Error(self, task, 1U)) { (void)Flush_Replies(self); }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
++self->status.reads_opened;
memset(&self->reader, 0, sizeof(self->reader)); self->reader.occupied = true;
self->reader.source = task->source; task->source.station = NULL;
self->reader.handle = open.handle; self->reader.size = open.size; self->reader.phase = FS_READ_OPEN;
name = open.name == NULL ? request.name : open.name;
name_length = open.name == NULL ? request.name_length : open.name_length;
if (name_length == 0U || name_length > IEC104_FILE_SERVICE_MAX_FILE_NAME) {
++self->status.invalid_callbacks;
if (Operation_Error(self, task, 1U)) { (void)End_Read(self, IEC104_FILE_SERVICE_END_ERROR); (void)Flush_Replies(self); }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
Prefix(self->buffer, &task->source, 4U, 7U, 0U);
self->buffer[11] = 0U; self->buffer[12] = name_length; memcpy(self->buffer + 13U, name, name_length);
Write32(self->buffer + 13U + name_length, 0U); Write32(self->buffer + 17U + name_length, open.size);
if (Freeze_Task(self, task, (uint16_t)(21U + name_length))) { (void)Flush_Replies(self); }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/**
* 功能:IDLE准入先于read,拥塞时不取数;提交WAIT后偏移不动,下轮重取同一快照内容。
* 输入参数:self——本模块实例。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值:返回IEC104_FileServiceExecuteResult_t结果;本函数显式处理IEC104_FILE_SERVICE_EXECUTE_EMPTY、IEC104_FILE_SERVICE_EXECUTE_ERROR、IEC104_FILE_SERVICE_EXECUTE_OK、IEC104_FILE_SERVICE_EXECUTE_WAIT,其余结果由下层调用传回。
* 说明:read失败锁存为空末段,不伪造P/N失败字段,主站须按激活大小发现截短。
*/
static IEC104_FileServiceExecuteResult_t Read_Data(IEC104_FileService_t *self,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
FileRead *reader = &self->reader;
IEC104_FileServiceRequest_t request;
IEC104_SlaveRequestState_t state;
IEC104_TcpSubmitResult_t query;
uint16_t length;
uint8_t checksum = 0U;
unsigned i;
bool last, called = false;
int sent, expired;
if (Has_Reply(self)) { return IEC104_FILE_SERVICE_EXECUTE_EMPTY; }
state = Check(self, &reader->source.identity);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_STALE) { return IEC104_FILE_SERVICE_EXECUTE_OK; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_FILE_SERVICE_EXECUTE_WAIT; }
/* 级10的op4虽已提交,仍可能排在统一队列中;级11的数据是nocache直交路径,
* 因此须以真实票据建立依赖,不能只依靠READ_DATA阶段或先前调用顺序。
* 0仅在op4提交OK后存入,代表直接交接;不等待主站ACK。
* PENDING在调用read之前返回WAIT,既不预读数据,也不刷新读期限;CANCELLED/ERROR不放行数据。 */
if (reader->confirmation_ticket != 0U) {
IEC104_ResponseState_t handed = IEC104_Slave_Get_Response_State(self->slave, reader->confirmation_ticket);
if (handed == IEC104_RESPONSE_PENDING) {
reader->waiting = true; ++self->status.idle_waits; return IEC104_FILE_SERVICE_EXECUTE_WAIT;
}
if (handed != IEC104_RESPONSE_HANDED) {
++self->status.send_errors; Fault(self, &reader->source.identity, false);
return IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
}
query = FS_IDLE_QUERY(self->slave, &reader->source.identity, self->config.window_reserve);
if (query == IEC104_TCP_SUBMIT_WAIT) { reader->waiting = true; ++self->status.idle_waits; return IEC104_FILE_SERVICE_EXECUTE_WAIT; }
if (query != IEC104_TCP_SUBMIT_OK) {
++self->status.send_errors; Fault(self, &reader->source.identity, false); return IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
if (reader->offset > reader->size) { Fault(self, &reader->source.identity, false); return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
length = (uint16_t)((reader->size - reader->offset) < self->config.read_segment_bytes ?
(reader->size - reader->offset) : self->config.read_segment_bytes);
if (!reader->aborting) {
bool success;
Request_From(self, &reader->source, IEC104_FILE_SERVICE_CALL_NONE, &request);
request.handle = reader->handle; request.file_size = reader->size;
self->in_callback = true;
success = handlers->read(context, &request, reader->offset, self->buffer + 20U, length);
self->in_callback = false; called = true;
if (!success) { reader->aborting = true; }
}
if (reader->aborting) { length = 0U; }
last = reader->aborting || length == reader->size - reader->offset;
Prefix(self->buffer, &reader->source, 5U, 5U, 0U);
Write32(self->buffer + 11U, 0U); Write32(self->buffer + 15U, reader->offset); self->buffer[19] = last ? 0U : 1U;
for (i = 0U; i < length; ++i) { checksum = (uint8_t)(checksum + self->buffer[20U + i]); }
self->buffer[20U + length] = checksum;
/* read返回后再次确认会话和期限;回调已发生的故障返回OK,避免调用方误重做。 */
state = Check(self, &reader->source.identity);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return called ? IEC104_FILE_SERVICE_EXECUTE_OK : IEC104_FILE_SERVICE_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_STALE) { return IEC104_FILE_SERVICE_EXECUTE_OK; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_FILE_SERVICE_EXECUTE_WAIT; }
expired = Expire(self);
if (expired != 0) { return expired < 0 && !called ? IEC104_FILE_SERVICE_EXECUTE_ERROR : IEC104_FILE_SERVICE_EXECUTE_OK; }
sent = Send(self, &reader->source, self->buffer, (uint16_t)(21U + length), false, true, NULL);
if (sent < 0) { return called ? IEC104_FILE_SERVICE_EXECUTE_OK : IEC104_FILE_SERVICE_EXECUTE_ERROR; }
reader->waiting = sent == 0;
if (sent == 0) { return IEC104_FILE_SERVICE_EXECUTE_WAIT; }
reader->offset += length; reader->progress_ms = FS_NOW(); ++self->status.read_frames;
if (last) {
if (!reader->aborting) { ++self->status.reads_completed; }
(void)End_Read(self, reader->aborting ? IEC104_FILE_SERVICE_END_ERROR : IEC104_FILE_SERVICE_END_COMPLETE);
}
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/**
* 功能:保存空文件的重复末段识别信息,不新增站点引用;资源归属仍由原写会话/COMMIT收尾槽负责。
* 输入参数:self——本模块实例。
* writer——日志写入回调。
* ready——就绪信息。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:ready为true才允许重复确认,真实写必须等COMMIT完成;不能因声明大小为0就提前报告持久化成功。
*/
static void Empty_Record(IEC104_FileService_t *self, const FileWrite *writer, bool ready)
{
memset(&self->empty_write, 0, sizeof(self->empty_write));
self->empty_write.valid = true; self->empty_write.ready = ready; self->empty_write.pending = true;
self->empty_write.source = writer->source; self->empty_write.source.station = NULL;
self->empty_write.serial = writer->serial; self->empty_write.file_id = writer->file_id;
}
/**
* 功能:末段完成时先实际占终结确认槽,再转为待COMMIT资源;预留挡住较晚op8。
* 输入参数:self——本模块实例。
* 输出参数:self——本模块实例的更新结果。
* 返回值:confirm == NULL时返回false;finish == NULL时返回false;其余分支返回false、true。
* 说明:TEST没有外部资源,确认立即就绪;真实空文件也必须等COMMIT结果才能重确认。
*/
static bool Schedule_Commit(IEC104_FileService_t *self)
{
FileWrite *writer = &self->writer;
FileConfirm *confirm;
FileFinish *finish;
bool test = writer->source.test;
confirm = Reserve_Confirm(self, &writer->source, writer->serial, writer->file_id, writer->segment, 0U, true, !test);
if (confirm == NULL) { return false; }
if (writer->size == 0U) { Empty_Record(self, writer, test); }
if (test) { Release_Source(self, &writer->source); memset(writer, 0, sizeof(*writer)); return true; }
finish = Move_Write_To_Finish(self, IEC104_FILE_SERVICE_CALL_COMMIT, IEC104_FILE_SERVICE_END_NONE);
if (finish == NULL) { return false; }
finish->confirm_index = (unsigned)(confirm - self->confirms);
return true;
}
/**
* 功能:本地暂存步骤不等通知读空:BUSY保留事件时仍能执行,应用不得在OPEN发布文件。
* 输入参数:self——本模块实例。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值:返回IEC104_FILE_SERVICE_EXECUTE_OK的结果。
* 说明:op8先形成,再为空文件预留op10,保证即使主站不等确认就发数据也不颠倒回复。
*/
static IEC104_FileServiceExecuteResult_t Open_Write(IEC104_FileService_t *self,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
FileTask *task = &self->activation;
IEC104_FileServiceRequest_t request;
IEC104_FileServiceOpen_t open;
IEC104_FileServiceResult_t result;
unsigned position = 12U + task->bytes[11];
Request_From(self, &task->source, IEC104_FILE_SERVICE_CALL_OPEN_WRITE, &request);
request.name = task->bytes + 12U; request.name_length = task->bytes[11];
request.file_id = Read32(task->bytes + position); request.file_size = Read32(task->bytes + position + 4U);
memset(&open, 0, sizeof(open));
result = request.test ? IEC104_FILE_SERVICE_RESULT_OK : Action(self, handlers, context, &request, &open);
if (!Valid_Result(result)) { ++self->status.invalid_callbacks; result = IEC104_FILE_SERVICE_RESULT_FAILED; }
if (result == IEC104_FILE_SERVICE_RESULT_OK) {
memset(&self->writer, 0, sizeof(self->writer)); self->writer.occupied = true;
self->writer.source = task->source; task->source.station = NULL;
self->writer.handle = open.handle; self->writer.file_id = request.file_id;
self->writer.size = request.file_size; self->writer.serial = task->work.reply.write_serial;
if (!request.test) { ++self->status.writes_opened; }
}
if (Operation_Error(self, task, (uint8_t)result)) {
if (result == IEC104_FILE_SERVICE_RESULT_OK && request.file_size == 0U) { (void)Schedule_Commit(self); }
(void)Flush_Replies(self);
}
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/**
* 功能:数据环只属于本实例,因此保存代次+写序号即可定位其传输批次;另核对原站和T。
* 输入参数:segment——const FileSegment *所指数据。
* source——源数据。
* serial——流水号。
* 输出参数:无。
* 返回值: file_id在归属成立后独立检查,以便正确返回结果4,而非误当游离段丢弃。
* 说明:file_id在归属成立后独立检查,以便正确返回结果4,而非误当游离段丢弃。
*/
static bool Segment_Matches(const FileSegment *segment, const FileSource *source, uint64_t serial)
{
return segment->write_serial == serial && segment->generation == source->identity.generation &&
segment->station_id == source->station_id && segment->ca == source->ca && segment->test == source->test;
}
/**
* 功能:正常处理无论写入、拒绝还是丢弃都会消费环头,保证BUSY能在有限步骤内解除。
* 输入参数:self——本模块实例。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值: 本地消费即使没有回调也返回OK;
* 说明:本地消费即使没有回调也返回OK;新查询/发送故障仍按本轮是否已调用应用区分。
*/
static IEC104_FileServiceExecuteResult_t Write_Segment(IEC104_FileService_t *self,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
FileSegment *segment = &self->segments[self->segment_head];
FileWrite *writer = &self->writer;
uint32_t number = segment->segment;
uint16_t length = segment->length;
uint8_t result = 0U;
bool last = !segment->more, called = false, success;
if (!writer->occupied || !Segment_Matches(segment, &writer->source, writer->serial)) {
FileRecent *empty = &self->empty_write, *silent = &self->silent_write;
/* 已终结空文件只复述既有结果;确认仍待交出时合并重复空末段,
* 不占第二槽、不重置原形成序号/期限,也不再次执行COMMIT。 */
if (empty->valid && Segment_Matches(segment, &empty->source, empty->serial) &&
!segment->malformed && !segment->bad_sum && segment->file_id == empty->file_id && length == 0U && last &&
(self->config.segment_mode == IEC104_FILE_SERVICE_SEGMENT_UNCHECKED || number == 0U)) {
Pop_Segment(self);
if (!empty->pending && empty->ready) {
if (Reserve_Confirm(self, &empty->source, empty->serial, empty->file_id, number, empty->result, true, false) == NULL) {
return IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
empty->pending = true;
}
} else if (silent->valid && Segment_Matches(segment, &silent->source, silent->serial)) {
/* 健康Cancel的反馈只消耗一次;faulted已在Execute入口阻止业务发送。 */
Pop_Segment(self);
if (Reserve_Confirm(self, &silent->source, silent->serial, silent->file_id, number, 1U, true, false) == NULL) {
return IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
memset(silent, 0, sizeof(*silent));
} else { ++self->status.stray_segments; Pop_Segment(self); }
if (Flush_Replies(self) < 0) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/* 先检查旧进度期限,再处理已入环的段;受理时间不能复活过期的暂存会话。 */
if (writer->op8_sent && Expired(FS_NOW(), Write_Progress(writer), self->config.write_idle_timeout_ms)) {
++self->status.write_timeouts;
Pop_Segment(self);
if (!Fail_Write(self, 1U, writer->segment, IEC104_FILE_SERVICE_END_TIMEOUT) || Flush_Replies(self) < 0) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/* 错误优先级固定:结构、模和、ID、偏移、剩余长度,最后才触及应用暂存。
* 长度使用size-received验证,避免uint32加法回绕;空非末段不能续命。 */
if (segment->malformed) { result = 1U; }
else if (segment->bad_sum) { result = 2U; }
else if (segment->file_id != writer->file_id) { result = 4U; }
else if (self->config.segment_mode == IEC104_FILE_SERVICE_SEGMENT_OFFSET && number != writer->received) { result = 3U; }
else if (writer->received > writer->size) { Fault(self, &writer->source.identity, false); return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
else if (length > writer->size - writer->received || (last && length != writer->size - writer->received) || (length == 0U && !last)) { result = 3U; }
if (result != 0U) {
Pop_Segment(self);
if (!Fail_Write(self, result, number, IEC104_FILE_SERVICE_END_ERROR) || Flush_Replies(self) < 0) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
success = true;
if (!writer->source.test) {
IEC104_FileServiceRequest_t request;
Request_From(self, &writer->source, IEC104_FILE_SERVICE_CALL_NONE, &request);
request.handle = writer->handle; request.file_id = writer->file_id; request.file_size = writer->size;
self->in_callback = true;
success = handlers->write(context, &request, writer->received, segment->data, length, last);
self->in_callback = false; called = true;
} else { called = true; /* TEST模拟本段同样属于确定的本地推进。 */ }
/* write/TEST只执行一次,先消费本段;后续确认WAIT不能重做外部写入。 */
Pop_Segment(self);
if (!success) {
(void)Fail_Write(self, 1U, number, IEC104_FILE_SERVICE_END_ERROR);
} else {
writer->received += length; writer->segment = number;
if (length != 0U) { writer->progress_ms = FS_NOW(); writer->progress_valid = true; }
if (!writer->source.test) { ++self->status.segments_written; }
if (last) { (void)Schedule_Commit(self); }
else if (self->config.write_confirm_mode == IEC104_FILE_SERVICE_WRITE_CONFIRM_EACH) {
(void)Reserve_Confirm(self, &writer->source, writer->serial, writer->file_id, number, 0U, false, false);
}
}
if (!self->status.faulted) { (void)Flush_Replies(self); }
return called ? IEC104_FILE_SERVICE_EXECUTE_OK : IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
/**
* 功能:不检查连接是否仍有效,清理必须在STOP/faulted后仍可交付。
* 输入参数:self——本模块实例。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值:无。
* 说明:关闭完成不一定立即释放目录:固定错误末帧可能仍在等待HIGH容量。
*/
static void Deliver_Directory(IEC104_FileService_t *self, const IEC104_FileServiceHandlers_t *handlers, void *context)
{
IEC104_FileServiceRequest_t request;
FileDirectory *directory = &self->directory;
Request_From(self, &directory->source, IEC104_FILE_SERVICE_CALL_CLOSE_DIRECTORY, &request);
request.reason = directory->reason; request.handle = directory->handle;
(void)Action(self, handlers, context, &request, NULL);
++self->status.finishes; directory->closing = false; directory->closed = true;
if (directory->task_alive && self->tasks[directory->task_index].phase == FS_DIRECTORY_DONE) {
Remove_Task(self, &self->tasks[directory->task_index]);
}
Release_Directory(self);
}
/**
* 功能:COMMIT仅由Execute在READY后选中;交付前核对其真实预留槽仍属于本写会话。
* 输入参数:self——本模块实例。
* finish——FileFinish *所指数据。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* finish——FileFinish *所指数据的更新结果。
* 返回值:按处理分支返回IEC104_FILE_SERVICE_EXECUTE_ERROR、IEC104_FILE_SERVICE_EXECUTE_OK。
* 说明:COMMIT不论成败均是最终资源回调,应用须自行释放handle;CLOSE/ABORT结果忽略。
*/
static IEC104_FileServiceExecuteResult_t Deliver_Finish(IEC104_FileService_t *self, FileFinish *finish,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
IEC104_FileServiceRequest_t request;
IEC104_FileServiceResult_t result;
FileConfirm *confirm = NULL;
bool commit = finish->call == IEC104_FILE_SERVICE_CALL_COMMIT;
uint64_t serial = finish->write_serial;
if (commit) {
if (finish->confirm_index >= IEC104_FILE_SERVICE_CONFIRM_CAPACITY) {
Fault(self, &finish->source.identity, false); return IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
confirm = &self->confirms[finish->confirm_index];
if (!confirm->occupied || !confirm->reserved || confirm->write_serial != serial) {
Fault(self, &finish->source.identity, false); return IEC104_FILE_SERVICE_EXECUTE_ERROR;
}
}
Request_From(self, &finish->source, finish->call, &request);
request.reason = finish->reason; request.handle = finish->handle; request.file_size = finish->size;
request.file_id = finish->file_id; request.transferred = finish->transferred;
result = Action(self, handlers, context, &request, NULL);
++self->status.finishes;
if (commit) {
uint8_t wire_result = result == IEC104_FILE_SERVICE_RESULT_OK ? 0U : 1U;
if (!Valid_Result(result)) { ++self->status.invalid_callbacks; }
if (wire_result == 0U) { ++self->status.writes_committed; } else { ++self->status.writes_failed; }
confirm->bytes[19] = wire_result;
confirm->bytes[2] = (uint8_t)(self->config.write_confirm_cause | (confirm->source.test ? 0x80U : 0U) |
(self->config.write_confirm_cause == 7U && wire_result != 0U ? 0x40U : 0U));
confirm->reserved = false; /* 原序号、预留时刻、槽位置都不变。 */
if (self->empty_write.valid && self->empty_write.serial == serial) {
self->empty_write.ready = true; self->empty_write.result = wire_result;
}
}
/* 已交付COMMIT不论成败都在查询/发送之前移出清理集合,不再补ABORT。
* 尤其成功提交的事实不能因随后STOP或回复丢失而反转成失败。 */
Release_Source(self, &finish->source); memset(finish, 0, sizeof(*finish));
if (commit) { (void)Flush_Replies(self); }
return IEC104_FILE_SERVICE_EXECUTE_OK;
}
/**
* 功能:每次只推进一个收尾/本地步骤/请求帧:清理优先,然后写激活、数据环、读FIFO、读数据。
* 输入参数:self——本模块实例。
* handlers——回调集合。
* context——调用方上下文。
* mode——处理模式。
* 输出参数:self——本模块实例的更新结果。
* 返回值:未调用回调的超时推进也返回OK。
* 说明:先检查旧期限再触及应用,避免迟到段复活会话;未调用回调的超时推进也返回OK。
* CONTROL/ALL中的清理不受faulted或未读通知阻挡,只有对外发布的COMMIT必须满足READY。
* CONTROL可先OPEN而尚无应答原文,应用须继续有界推进,不能把这次OK当作级10候选已收集完成。
*/
IEC104_FileServiceExecuteResult_t IEC104_FileService_Execute_Next_Mode(IEC104_FileService_t *self,
const IEC104_FileServiceHandlers_t *handlers, void *context, IEC104_FileServiceExecuteMode_t mode)
{
bool tried[4] = { false, false, false, false }; /* 目录、读、两个写收尾;暂缓项每轮只检查一次。 */
unsigned attempt;
int expired;
if (!Owned(self) || self->in_callback || handlers == NULL || handlers->action == NULL ||
(mode != IEC104_FILE_SERVICE_EXECUTE_ALL && mode != IEC104_FILE_SERVICE_EXECUTE_CONTROL &&
mode != IEC104_FILE_SERVICE_EXECUTE_DATA) ||
((self->config.features & IEC104_FILE_SERVICE_FEATURE_DIRECTORY) != 0U && handlers->list == NULL) ||
((self->config.features & IEC104_FILE_SERVICE_FEATURE_READ) != 0U && handlers->read == NULL) ||
((self->config.features & IEC104_FILE_SERVICE_FEATURE_WRITE) != 0U && handlers->write == NULL)) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
expired = Expire(self);
if (expired < 0) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
if (expired != 0) { return IEC104_FILE_SERVICE_EXECUTE_OK; }
/* DATA阶段不执行新控制动作;清理仍由CONTROL/ALL推进,不能为低级数据跳过高层资源收尾。
* 两种模式都已执行Expire;拆分只限定本轮动作类别,不给读会话另起期限或绕过确认依赖。 */
if (mode == IEC104_FILE_SERVICE_EXECUTE_DATA) {
return !self->status.faulted && self->reader.occupied && self->reader.phase == FS_READ_DATA ?
Read_Data(self, handlers, context) : IEC104_FILE_SERVICE_EXECUTE_EMPTY;
}
/* 排序只决定可交付收尾的次序。WAIT_EVENTS的COMMIT让出,后面的ABORT/本地写不能被它堵住。 */
for (attempt = 0U; attempt < 4U; ++attempt) {
uint64_t sequence = 0U;
int selected = -1;
FileFinish *finish = NULL;
unsigned i;
if (!tried[0] && self->directory.occupied && self->directory.closing) { selected = 0; sequence = self->directory.finish_sequence; }
if (!tried[1] && self->read_finish.occupied && (selected < 0 || self->read_finish.sequence < sequence)) { selected = 1; sequence = self->read_finish.sequence; }
for (i = 0U; i < 2U; ++i) {
if (!tried[i + 2U] && self->write_finish[i].occupied && (selected < 0 || self->write_finish[i].sequence < sequence)) {
selected = (int)i + 2; sequence = self->write_finish[i].sequence;
}
}
if (selected < 0) { break; }
tried[selected] = true;
if (selected == 0) { Deliver_Directory(self, handlers, context); return IEC104_FILE_SERVICE_EXECUTE_OK; }
finish = selected == 1 ? &self->read_finish : &self->write_finish[(unsigned)selected - 2U];
if (finish->call == IEC104_FILE_SERVICE_CALL_COMMIT) {
IEC104_SlaveRequestState_t state;
if (self->status.faulted) { finish->call = IEC104_FILE_SERVICE_CALL_ABORT_WRITE; finish->reason = IEC104_FILE_SERVICE_END_CANCELLED; ++self->status.commits_cancelled; }
else {
state = Check(self, &finish->source.identity);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_STALE) { return IEC104_FILE_SERVICE_EXECUTE_OK; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { continue; }
}
}
return Deliver_Finish(self, finish, handlers, context);
}
if (self->status.faulted) { return IEC104_FILE_SERVICE_EXECUTE_EMPTY; }
/* 以下两个本地步骤刻意不查WAIT_EVENTS,否则保留op9的BUSY循环会自锁。
* 仍只允许写暂存,真正发布已经移到上方COMMIT屏障。 */
if (self->activation.occupied && self->activation.phase == FS_EXECUTE) { return Open_Write(self, handlers, context); }
if (self->segment_count != 0U) { return Write_Segment(self, handlers, context); }
if (self->task_count != 0U) {
FileTask *task = &self->tasks[self->order[0]];
if (task->phase == FS_EXECUTE || task->phase == FS_DIRECTORY) {
IEC104_SlaveRequestState_t state = Check(self, &task->source.identity);
if (state == IEC104_SLAVE_REQUEST_ERROR) { return IEC104_FILE_SERVICE_EXECUTE_ERROR; }
if (state == IEC104_SLAVE_REQUEST_STALE) { return IEC104_FILE_SERVICE_EXECUTE_OK; }
if (state == IEC104_SLAVE_REQUEST_WAIT_EVENTS) { return IEC104_FILE_SERVICE_EXECUTE_WAIT; }
if (task->phase == FS_DIRECTORY) { return Scan_Directory(self, task, handlers, context); }
if (task->operation == 1U) { return Open_Directory(self, task, handlers, context); }
return Open_Read(self, task, handlers, context);
}
}
if (mode == IEC104_FILE_SERVICE_EXECUTE_ALL && self->reader.occupied && self->reader.phase == FS_READ_DATA) {
return Read_Data(self, handlers, context);
}
return IEC104_FILE_SERVICE_EXECUTE_EMPTY;
}
/**
* 功能:以ALL模式推进一次应用工作,包含清理、执行及读数据;
* 输入参数:self——本模块实例。
* handlers——回调集合。
* context——调用方上下文。
* 输出参数:self——本模块实例的更新结果。
* 返回值:回调借用及返回语义沿用模式入口。
* 说明:回调借用及返回语义沿用模式入口。
*/
IEC104_FileServiceExecuteResult_t IEC104_FileService_Execute_Next(IEC104_FileService_t *self,
const IEC104_FileServiceHandlers_t *handlers, void *context)
{
return IEC104_FileService_Execute_Next_Mode(self, handlers, context, IEC104_FILE_SERVICE_EXECUTE_ALL);
}
/**
* 功能:合并可处理期限:timer_active区分“没有定时器”和“已有定时器恰好到期为0”。
* 输入参数:status——状态快照。
* now——当前时刻。
* start——uint64_t值。
* timeout——超时状态。
* 输出参数:status——状态快照的更新结果。
* 返回值:无。
* 说明:内部调用:Remaining。
*/
static void Add_Timer(IEC104_FileServiceStatus_t *status, uint64_t now, uint64_t start, uint32_t timeout)
{
uint32_t remaining;
if (timeout == 0U) { return; }
remaining = Remaining(now, start, timeout);
if (!status->timer_active || remaining < status->timeout_remaining_ms) { status->timeout_remaining_ms = remaining; }
status->timer_active = true;
}
/**
* 功能:在局部副本合成快照,查询失败不改调用者输出,也不在只读接口里执行取消/关闭。
* 输入参数:self——本模块实例。
* status——状态快照。
* 输出参数:status——全部查询成功后写回快照,失败保持原值。
* 返回值:!Owned(self) || status == NULL || FS_STATUS(self->slave, &transport, NULL) != IEC104_TCP_OK时返回false;其余分支返回false、true。
* 说明:pending只说明工作存在;ready/need_process才决定零等待,背压不能导致空转。
*/
bool IEC104_FileService_Get_Status(const IEC104_FileService_t *self, IEC104_FileServiceStatus_t *status)
{
IEC104_FileServiceStatus_t value;
IEC104_TcpServerStatus_t transport;
const FileTask *oldest_task;
const FileConfirm *oldest_confirm;
bool reply, cleanup = false, commit = false, local = false;
uint64_t now;
unsigned i;
if (!Owned(self) || status == NULL || FS_STATUS(self->slave, &transport, NULL) != IEC104_TCP_OK) { return false; }
value = self->status; now = FS_NOW();
value.generation = self->session.generation; value.events_pending = transport.pending_event_count != 0U;
value.pending_requests = self->task_count + (self->activation.occupied ? 1U : 0U);
value.pending_segments = self->segment_count; value.pending_replies = 0U;
value.segments_full = self->segment_count == IEC104_FILE_SERVICE_SEGMENT_CAPACITY;
value.directory_active = self->directory.occupied && !self->directory.closed;
value.read_active = self->reader.occupied; value.write_active = self->writer.occupied;
value.write_test = self->writer.occupied && self->writer.source.test;
value.read_offset = self->reader.offset; value.read_size = self->reader.size;
value.write_received = self->writer.received; value.write_size = self->writer.size;
value.idle_waiting = self->reader.occupied && self->reader.waiting;
value.execute_pending = false; value.execute_ready = false; value.need_process = false;
value.timer_active = false; value.timeout_remaining_ms = 0U;
cleanup = (self->directory.occupied && self->directory.closing) || self->read_finish.occupied;
for (i = 0U; i < 2U; ++i) {
if (self->write_finish[i].occupied) {
if (self->write_finish[i].call == IEC104_FILE_SERVICE_CALL_COMMIT) { commit = true; }
else { cleanup = true; }
}
}
value.finish_pending = cleanup || commit; value.commit_waiting = commit && value.events_pending;
reply = Oldest_Reply(self, &oldest_task, &oldest_confirm) != 0U;
/* 固定回复无论是否队首都计期限,RESERVED_COMMIT同样计pending_replies。
* 未执行读请求则仅由下面的FIFO队首参加执行计时。 */
for (i = 0U; i < self->task_count; ++i) {
const FileTask *task = &self->tasks[self->order[i]];
if (task->phase == FS_REPLY) {
++value.pending_replies;
if (!value.faulted) { Add_Timer(&value, now, task->work.reply.formed_ms, self->config.reply_timeout_ms); }
} else if (task->phase == FS_EXECUTE || task->phase == FS_DIRECTORY) { value.execute_pending = true; }
}
if (self->activation.occupied) {
if (self->activation.phase == FS_REPLY) {
++value.pending_replies;
if (!value.faulted) { Add_Timer(&value, now, self->activation.work.reply.formed_ms, self->config.reply_timeout_ms); }
} else {
local = true;
if (!value.faulted) { Add_Timer(&value, now, self->activation.source.accepted_ms, self->config.execute_timeout_ms); }
}
}
for (i = 0U; i < IEC104_FILE_SERVICE_CONFIRM_CAPACITY; ++i) {
if (self->confirms[i].occupied) {
++value.pending_replies;
if (!value.faulted) { Add_Timer(&value, now, self->confirms[i].formed_ms, self->config.reply_timeout_ms); }
}
}
local = local || self->segment_count != 0U;
if (!value.faulted) {
if (self->task_count != 0U) {
const FileTask *head = &self->tasks[self->order[0]];
if (head->phase == FS_EXECUTE) { Add_Timer(&value, now, head->source.accepted_ms, self->config.execute_timeout_ms); }
if ((head->phase == FS_EXECUTE || head->phase == FS_DIRECTORY) && !value.events_pending && !head->waiting &&
(head->phase != FS_DIRECTORY || !reply)) { value.execute_ready = true; }
}
if (self->directory.occupied && self->directory.task_alive && !self->directory.closing && !self->directory.closed) {
Add_Timer(&value, now, self->directory.opened_ms, self->config.directory_timeout_ms);
}
if (self->reader.occupied && self->reader.phase == FS_READ_DATA) {
value.execute_pending = true;
Add_Timer(&value, now, self->reader.progress_ms, self->config.read_idle_timeout_ms);
if (!value.events_pending && !reply && !self->reader.waiting) { value.execute_ready = true; }
}
if (self->writer.occupied && self->writer.op8_sent) { Add_Timer(&value, now, Write_Progress(&self->writer), self->config.write_idle_timeout_ms); }
if (reply && !value.events_pending) {
value.need_process = oldest_task != NULL ? !oldest_task->waiting : (!oldest_confirm->reserved && !oldest_confirm->waiting);
}
if (value.timer_active && value.timeout_remaining_ms == 0U) { value.need_process = true; }
if ((self->reader.occupied || self->writer.occupied || self->directory.occupied || value.pending_requests != 0U || value.finish_pending) &&
(!transport.connected || transport.generation != self->session.generation)) { value.need_process = true; }
value.execute_pending = value.execute_pending || local || cleanup || commit;
value.execute_ready = value.execute_ready || local || cleanup || (commit && !value.events_pending);
} else { value.execute_pending = cleanup; value.execute_ready = cleanup; }
/* 回调内允许观察事实和计数,但压住递归推进提示;这不是重入许可。 */
if (self->in_callback) { value.execute_ready = false; value.need_process = false; value.timer_active = false; value.timeout_remaining_ms = 0U; }
*status = value; return true;
}