462 lines
24 KiB
C
462 lines
24 KiB
C
/*
|
||
* ASDU层仅处理公共头、对象布局、容量和分派。
|
||
* 对象编码调用基类函数表；对象解码按Type ID调用独立类型解析器。
|
||
* 所有外部可见写入都在字段、布局和容量验证完成后提交，失败不留下半条报文。
|
||
*/
|
||
#include "IEC60870_Asdu.h"
|
||
#include "IEC60870_InformationObjects_Internal.h"
|
||
|
||
#include <string.h>
|
||
|
||
/**
|
||
* 功能：计算当前配置的ASDU公共头字节数。
|
||
* 输入参数：parameters——已通过IEC60870_AppLayerParameters_Valid检查的非空参数。
|
||
* 输出参数：无。
|
||
* 返回值：2+sizeOfCOT+sizeOfCA，即4、5或6字节。
|
||
* 说明：固定的2字节是Type ID和VSQ；OA已包含在2字节COT中，不能再次累加。
|
||
*/
|
||
static uint16_t Header_Size(const IEC60870_AppLayerParameters_t *parameters)
|
||
{
|
||
return (uint16_t)(2 + parameters->sizeOfCOT + parameters->sizeOfCA);
|
||
}
|
||
|
||
/**
|
||
* 功能：检查信息对象区的精确长度、数量、SQ约束及连续地址上限。
|
||
* 输入参数：info——非空公共头视图，参数和对象原文在使用期间必须有效且不变。
|
||
* type——与info->type_id匹配的非空只读类型描述。
|
||
* 输出参数：无。
|
||
* 返回值：1表示对象区布局合法；0表示参数、数量、长度或隐含地址范围非法。
|
||
* 说明：先检查长度，再读取首IOA；这里只验证布局，不检查值、品质或时标。
|
||
*/
|
||
static int Layout_Valid(const IEC60870_AsduInfo_t *info,
|
||
const IEC60870_InformationObjectVTable *type)
|
||
{
|
||
uint16_t expected;
|
||
if (!IEC60870_AppLayerParameters_Valid(info->parameters) ||
|
||
info->information_objects == NULL || info->object_count == 0U ||
|
||
info->object_count > IEC60870_ASDU_MAX_OBJECTS || info->is_sequence > 1U ||
|
||
(info->is_sequence && !type->supports_sequence) ||
|
||
(type->single_object && info->object_count != 1U)) {
|
||
return 0;
|
||
}
|
||
/* 设N为数量、D为值载荷长度、L为IOA宽度：SQ=0占N*(L+D)，SQ=1占L+N*D。
|
||
* 精确相等同时拒绝截短对象和额外尾字节；这里不计ASDU公共头。 */
|
||
expected = (uint16_t)(info->object_count * type->payload_size +
|
||
(info->is_sequence ? info->parameters->sizeOfIOA :
|
||
info->object_count * info->parameters->sizeOfIOA));
|
||
if (type->get_payload_size_from_buffer != NULL) {
|
||
uint16_t payload_size;
|
||
uint16_t address_size = (uint16_t)info->parameters->sizeOfIOA;
|
||
/* 当前变长类型是单对象文件段；先保护段头读取，再依据LOS计算实际长度。 */
|
||
if (info->object_count != 1U || info->is_sequence ||
|
||
info->information_objects_len < address_size) { return 0; }
|
||
payload_size = type->get_payload_size_from_buffer(info->information_objects + address_size,
|
||
(uint16_t)(info->information_objects_len - address_size));
|
||
if (payload_size == 0U) { return 0; }
|
||
expected = (uint16_t)(address_size + payload_size);
|
||
}
|
||
if (expected != info->information_objects_len ||
|
||
expected > info->parameters->maxSizeOfASDU - Header_Size(info->parameters)) {
|
||
return 0;
|
||
}
|
||
/* SQ首地址本身可表示，但末地址首IOA+N-1也必须能由同样的IOA宽度表示。 */
|
||
return !info->is_sequence ||
|
||
IEC60870_Object_Read_LE(info->information_objects, (unsigned int)info->parameters->sizeOfIOA) <=
|
||
IEC60870_Object_Max_IOA(info->parameters) - (info->object_count - 1U);
|
||
}
|
||
|
||
/**
|
||
* 功能：定位指定对象的值载荷，同时恢复其信息对象地址。
|
||
* 输入参数：info——已通过Layout_Valid校验的非空ASDU视图。
|
||
* type——与info->type_id匹配的非空只读类型描述。
|
||
* index——从0开始的索引，调用方必须保证小于object_count。
|
||
* 输出参数：ioa——非空地址输出；SQ=1时使用首地址加索引还原。
|
||
* payload_length——非空输出，返回固定或变长载荷的实际长度。
|
||
* 返回值：输入原文中的载荷借用指针，不含IOA，不复制字节。
|
||
* 说明：本内部函数不再验证长度/索引；返回指针的有效期与原ASDU一致。
|
||
*/
|
||
static const uint8_t *Element_Position(const IEC60870_AsduInfo_t *info,
|
||
const IEC60870_InformationObjectVTable *type, uint8_t index, uint32_t *ioa,
|
||
uint16_t *payload_length)
|
||
{
|
||
unsigned int address_size = (unsigned int)info->parameters->sizeOfIOA;
|
||
const uint8_t *data = info->information_objects;
|
||
*payload_length = type->payload_size;
|
||
if (type->get_payload_size_from_buffer != NULL) {
|
||
/* Layout_Valid已确认变长对象为SQ=0、数量1且载荷完整。 */
|
||
*payload_length = type->get_payload_size_from_buffer(data + address_size,
|
||
(uint16_t)(info->information_objects_len - address_size));
|
||
}
|
||
/* SQ=1的对象区为：首IOA、载荷0、载荷1……；后续地址不占报文字节。 */
|
||
if (info->is_sequence) {
|
||
*ioa = IEC60870_Object_Read_LE(data, address_size) + index;
|
||
return data + address_size + index * type->payload_size;
|
||
}
|
||
/* SQ=0每个对象都有独立IOA，故步长包含地址；取值前先跳过该地址。 */
|
||
data += index * (address_size + type->payload_size);
|
||
*ioa = IEC60870_Object_Read_LE(data, address_size);
|
||
return data + address_size;
|
||
}
|
||
|
||
/**
|
||
* 功能：核对容器控制字段与已构造ASDU布局是否一致。
|
||
* 输入参数：self——待检查容器或借用原文对象，可为NULL。
|
||
* 输出参数：无。
|
||
* 返回值：1表示结构状态一致；0表示参数、容量、类型、数量、长度或首地址非法。
|
||
* 说明：构造容器按类型重算精确长度；借用原文对象只检查公共头及最低长度。
|
||
* 不重新解码值，参数、控制字段及对象区须由调用方保持有效且不变。
|
||
*/
|
||
static int Container_Valid(const IEC60870_Asdu_t *self)
|
||
{
|
||
uint16_t expected;
|
||
const IEC60870_InformationObjectVTable *type;
|
||
if (self == NULL || self->buffer == NULL ||
|
||
!IEC60870_AppLayerParameters_Valid(self->parameters) ||
|
||
self->capacity < Header_Size(self->parameters) ||
|
||
self->capacity > self->parameters->maxSizeOfASDU ||
|
||
self->length < Header_Size(self->parameters) ||
|
||
self->length > self->capacity || self->is_sequence > 1U ||
|
||
self->object_count > IEC60870_ASDU_MAX_OBJECTS || self->is_from_buffer > 1U) {
|
||
return 0;
|
||
}
|
||
if (self->is_from_buffer) {
|
||
IEC60870_AsduInfo_t info;
|
||
/* 已有原文的容量固定为其长度，不将未知对象当作可追加的构造容器。
|
||
* 不读取未知类型的IOA；first_ioa仅供构造时的连续地址检查使用。 */
|
||
return self->capacity == self->length && self->first_ioa == 0U &&
|
||
IEC60870_Parse_ASDU_Header(self->parameters, self->buffer, self->length, &info) &&
|
||
self->type_id == info.type_id && self->object_count == info.object_count &&
|
||
self->is_sequence == info.is_sequence;
|
||
}
|
||
expected = Header_Size(self->parameters);
|
||
if (self->object_count == 0U) {
|
||
if (self->type_id != 0U) { return 0; }
|
||
} else {
|
||
type = IEC60870_InformationObject_Get_Descriptor(self->type_id);
|
||
if (type == NULL || (self->is_sequence && !type->supports_sequence) ||
|
||
(type->single_object && self->object_count != 1U)) {
|
||
return 0;
|
||
}
|
||
expected = (uint16_t)(expected + self->object_count * type->payload_size +
|
||
(self->is_sequence ? self->parameters->sizeOfIOA :
|
||
self->object_count * self->parameters->sizeOfIOA));
|
||
if (type->get_payload_size_from_buffer != NULL) {
|
||
IEC60870_AsduInfo_t info;
|
||
if (!IEC60870_Parse_ASDU_Header(self->parameters, self->buffer, self->length, &info) ||
|
||
!Layout_Valid(&info, type)) { return 0; }
|
||
expected = self->length;
|
||
}
|
||
}
|
||
if (self->length != expected || self->buffer[0] != self->type_id ||
|
||
self->buffer[1] != (uint8_t)(self->object_count | (self->is_sequence << 7))) {
|
||
return 0;
|
||
}
|
||
if (self->object_count != 0U &&
|
||
(self->first_ioa != IEC60870_Object_Read_LE(self->buffer + Header_Size(self->parameters),
|
||
(unsigned int)self->parameters->sizeOfIOA) ||
|
||
(self->is_sequence && self->first_ioa >
|
||
IEC60870_Object_Max_IOA(self->parameters) - (self->object_count - 1U)))) {
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
/**
|
||
* 功能：在调用方缓冲区中创建一个尚未加入对象的ASDU。
|
||
* 输入参数：parameters——非空合法参数；容器借用指针，使用期间必须有效且不变。
|
||
* capacity——buffer实际可用字节数；有效容量取此值与maxSizeOfASDU的较小值。
|
||
* header——非空公共头配置；COT为0..63，P/N和TEST为0/1，CA须适合所选宽度。
|
||
* is_sequence——0为逐对象IOA，1为连续地址；一条ASDU内不自动切换。
|
||
* 输出参数：self——非空容器存储，成功后记录缓冲区、参数及初始状态。
|
||
* buffer——非空可写ASDU缓冲区，初始只写公共头，不含APCI。
|
||
* 返回值：OK为成功，FULL为实际缓冲区不足头长，ERROR为参数或字段非法。
|
||
* 说明：全部检查通过后才写回；首对象尚未确定，Type ID和对象数均为0。
|
||
* 本函数不分配内存，也不发送；SQ适用性按具体类型检查，空容器不能Get_Data。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Create(IEC60870_Asdu_t *self,
|
||
const IEC60870_AppLayerParameters_t *parameters,
|
||
uint8_t *buffer, uint16_t capacity, const IEC60870_AsduHeader_t *header, int is_sequence)
|
||
{
|
||
IEC60870_Asdu_t result;
|
||
uint16_t header_length;
|
||
if (self == NULL || buffer == NULL || header == NULL ||
|
||
!IEC60870_AppLayerParameters_Valid(parameters) ||
|
||
(is_sequence != 0 && is_sequence != 1) ||
|
||
header->cause_of_transmission > 63U || header->is_negative_confirm > 1U ||
|
||
header->is_test > 1U || (parameters->sizeOfCA == 1 && header->common_address > 255U)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
header_length = Header_Size(parameters);
|
||
if (capacity < header_length) { return IEC60870_ASDU_FULL; }
|
||
memset(&result, 0, sizeof(result));
|
||
result.buffer = buffer;
|
||
/* 缓冲区较大也不能突破协议配置上限；仅保存参数指针，不复制配置。 */
|
||
result.capacity = capacity > parameters->maxSizeOfASDU ?
|
||
(uint16_t)parameters->maxSizeOfASDU : capacity;
|
||
result.length = header_length;
|
||
result.is_sequence = (uint8_t)is_sequence;
|
||
result.parameters = parameters;
|
||
/* 此后没有可能失败的校验；按所选宽度恰好写入header_length字节。 */
|
||
/* Type ID暂置0；VSQ bit7为SQ、低7位为数量，初始数量为0。 */
|
||
buffer[0] = 0;
|
||
buffer[1] = (uint8_t)(is_sequence << 7);
|
||
/* COT首字节：bit0..5为原因、bit6为P/N、bit7为TEST；2字节COT才写OA。 */
|
||
buffer[2] = (uint8_t)(header->cause_of_transmission |
|
||
(header->is_negative_confirm << 6) | (header->is_test << 7));
|
||
if (parameters->sizeOfCOT == 2) { buffer[3] = header->originator_address; }
|
||
IEC60870_Object_Write_LE(buffer + 2 + parameters->sizeOfCOT,
|
||
header->common_address, (unsigned int)parameters->sizeOfCA);
|
||
*self = result;
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：将已有可写ASDU原文包装成调用方持有的对象。
|
||
* 输入参数：parameters——非空应用层参数；buffer——可写原文；length——原文长度。
|
||
* 输出参数：self——全部检查成功后写入；buffer不变。
|
||
* 返回值：OK为成功，ERROR为参数或最低长度非法。
|
||
* 说明：借用参数和原文，不分配、不复制；本入口不替代业务使用的完整Parse。
|
||
* 容量固定为原文长度，后续只允许修改公共头，不能追加信息对象。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Create_From_Buffer(IEC60870_Asdu_t *self,
|
||
const IEC60870_AppLayerParameters_t *parameters, uint8_t *buffer, uint16_t length)
|
||
{
|
||
IEC60870_AsduInfo_t info;
|
||
IEC60870_Asdu_t result;
|
||
if (self == NULL || !IEC60870_Parse_ASDU_Header(parameters, buffer, length, &info)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
memset(&result, 0, sizeof(result));
|
||
result.buffer = buffer;
|
||
result.capacity = length;
|
||
result.length = length;
|
||
result.type_id = info.type_id;
|
||
result.object_count = info.object_count;
|
||
result.is_sequence = info.is_sequence;
|
||
result.is_from_buffer = 1U;
|
||
result.parameters = parameters;
|
||
*self = result;
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：修改ASDU传送原因，保留COT字节中的两个独立标志。
|
||
* 输入参数：self——合法ASDU对象；cause——0..63。
|
||
* 输出参数：self->buffer[2]——校验成功后更新低6位。
|
||
* 返回值：OK为成功，ERROR为参数或对象状态非法。
|
||
* 说明：所有字段宽度配置中COT首字节均位于偏移2；不改变OA或载荷。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Set_COT(IEC60870_Asdu_t *self, int cause)
|
||
{
|
||
if (cause < 0 || cause > 63 || !Container_Valid(self)) { return IEC60870_ASDU_ERROR; }
|
||
self->buffer[2] = (uint8_t)((self->buffer[2] & 0xC0U) | (uint8_t)cause);
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：修改ASDU的P/N标志，保留传送原因及TEST。
|
||
* 输入参数：self——合法ASDU对象；is_negative——0或1。
|
||
* 输出参数：self->buffer[2]——校验成功后仅更新bit6。
|
||
* 返回值：OK为成功，ERROR为参数或对象状态非法。
|
||
* 说明：不执行命令，不提交发送；失败保持字节原值。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Set_Negative(IEC60870_Asdu_t *self, int is_negative)
|
||
{
|
||
if ((is_negative != 0 && is_negative != 1) || !Container_Valid(self)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
self->buffer[2] = (uint8_t)((self->buffer[2] & 0xBFU) | (uint8_t)(is_negative << 6));
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：修改ASDU公共地址，保留其他公共头字段与对象区。
|
||
* 输入参数：self——合法ASDU对象；common_address——须适合sizeOfCA的无符号地址。
|
||
* 输出参数：self->buffer——在2+sizeOfCOT偏移按小端写入sizeOfCA字节。
|
||
* 返回值：OK为成功，ERROR为非法容器或1字节CA无法表示的地址；失败不写入。
|
||
* 说明：沿用Container_Valid检查构造及借用对象，不截断地址，不决定是否允许广播。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Set_CA(IEC60870_Asdu_t *self, uint16_t common_address)
|
||
{
|
||
if (!Container_Valid(self) || (self->parameters->sizeOfCA == 1 && common_address > 255U)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
IEC60870_Object_Write_LE(self->buffer + 2 + self->parameters->sizeOfCOT,
|
||
common_address, (unsigned int)self->parameters->sizeOfCA);
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：编码并追加一个同类型对象，成功后更新ASDU长度及VSQ。
|
||
* 输入参数：self——已成功Create且控制字段/参数/原文未被修改的容器。
|
||
* object——已由具体类型Create或解析器初始化的公共基类首成员。
|
||
* 输出参数：self——成功后更新容器及其字节缓冲区，失败保持原值。
|
||
* 返回值：OK为追加成功；FULL为字节空间或对象数已满；UNSUPPORTED为未知类型；
|
||
* ERROR为容器、身份、字段、地址或SQ约束非法。
|
||
* 说明：在有界临时区完成IOA和值编码（含变长文件段），确认容量后才写入。
|
||
* 首个成功对象固定Type ID；SQ=1首对象仍带IOA，其后只写载荷且地址必须递增1。
|
||
* FULL时由调用方提交已有非空ASDU，另起一条重试同一对象；不会自动拆包。
|
||
* 成功后仅保存对象的报文字节，不借用object，调用方可以立即复用其存储。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Add_InformationObject(IEC60870_Asdu_t *self,
|
||
const IEC60870_InformationObject_t *object)
|
||
{
|
||
const IEC60870_InformationObjectVTable *type;
|
||
uint8_t encoded[IEC60870_OBJECT_MAX_ENCODED];
|
||
uint16_t added;
|
||
IEC60870_AsduResult_t status;
|
||
if (!Container_Valid(self) || self->is_from_buffer || object == NULL) { return IEC60870_ASDU_ERROR; }
|
||
type = IEC60870_InformationObject_Get_Descriptor(object->type_id);
|
||
if (type == NULL) { return IEC60870_ASDU_UNSUPPORTED; }
|
||
if (object->virtual_function_table != type ||
|
||
(self->object_count != 0U && self->type_id != type->type_id) ||
|
||
(self->is_sequence && !type->supports_sequence) ||
|
||
object->ioa > IEC60870_Object_Max_IOA(self->parameters)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
/* 用减法先判断地址范围，再比较首IOA+已有数量，避免允许隐含地址越界。 */
|
||
if (self->is_sequence && self->object_count != 0U &&
|
||
(self->first_ioa > IEC60870_Object_Max_IOA(self->parameters) - self->object_count ||
|
||
object->ioa != self->first_ioa + self->object_count)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
/* 字段错误优先于容量已满，以免把非法对象误当作下一条ASDU的可重试输入。 */
|
||
status = IEC60870_InformationObject_Encode(object, self->parameters,
|
||
self->is_sequence && self->object_count != 0U, encoded, sizeof(encoded), &added);
|
||
if (status != IEC60870_ASDU_OK) { return status; }
|
||
if (self->object_count == IEC60870_ASDU_MAX_OBJECTS ||
|
||
(type->single_object && self->object_count != 0U) ||
|
||
added > self->capacity - self->length) {
|
||
return IEC60870_ASDU_FULL;
|
||
}
|
||
/* 从此处开始统一提交，没有后续失败分支，容量不足不会留下半个对象。 */
|
||
memcpy(self->buffer + self->length, encoded, added);
|
||
if (self->object_count == 0U) {
|
||
self->first_ioa = object->ioa;
|
||
self->type_id = type->type_id;
|
||
self->buffer[0] = type->type_id;
|
||
}
|
||
self->length = (uint16_t)(self->length + added);
|
||
++self->object_count;
|
||
self->buffer[1] = (uint8_t)(self->object_count | (self->is_sequence << 7));
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：导出构造完成或直接借用的ASDU原文。
|
||
* 输入参数：self——非空合法对象；Create创建的容器必须至少加入一个对象。
|
||
* 输出参数：asdu——非空输出指针，成功时指向调用方原有缓冲区。
|
||
* length——非空输出指针，成功时得到当前ASDU字节数，不含APCI。
|
||
* 返回值：OK为成功；ERROR为容器、输出参数非法或容器为空；失败不修改输出。
|
||
* 说明：返回借用视图，不复制或发送。借用原文对象不额外进行完整对象校验。
|
||
* 后续Add/Create/Set会影响原文，length只是本次快照。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Get_Data(const IEC60870_Asdu_t *self,
|
||
const uint8_t **asdu, uint16_t *length)
|
||
{
|
||
if (!Container_Valid(self) || (!self->is_from_buffer && self->object_count == 0U) ||
|
||
asdu == NULL || length == NULL) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
*asdu = self->buffer;
|
||
*length = self->length;
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：校验完整ASDU（含参数和文件类型），生成可用于逐对象提取的只读视图。
|
||
* 输入参数：parameters——显式非空应用层参数，字段宽度必须对应收到的报文。
|
||
* asdu——非空ASDU原文，不含APCI。
|
||
* length——完整ASDU字节数，不能超过配置上限，不能包含多余尾字节。
|
||
* 输出参数：info——非空视图输出，借用parameters和asdu，二者须在取对象期间有效且不变。
|
||
* 返回值：OK为成功；UNSUPPORTED为未支持类型；ERROR为公共头、布局或任一对象非法。
|
||
* 说明：先检查公共头和布局，再验证所有对象，全部成功后才发布info，失败保留旧输出。
|
||
* 不执行命令，也不判断COT/CA/IOA的业务适用性；具体对象通过Get_Element获取。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Parse(const IEC60870_AppLayerParameters_t *parameters,
|
||
const uint8_t *asdu, uint16_t length, IEC60870_AsduInfo_t *info)
|
||
{
|
||
IEC60870_AsduInfo_t result;
|
||
const IEC60870_InformationObjectVTable *type;
|
||
uint8_t i;
|
||
if (info == NULL || !IEC60870_Parse_ASDU_Header(parameters, asdu, length, &result)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
type = IEC60870_InformationObject_Get_Descriptor(result.type_id);
|
||
if (type == NULL) { return IEC60870_ASDU_UNSUPPORTED; }
|
||
if (!Layout_Valid(&result, type)) { return IEC60870_ASDU_ERROR; }
|
||
/* 输出传NULL使类型解析器仅校验，不分配对象数组；任一对象失败就丢弃整个临时视图。 */
|
||
for (i = 0; i < result.object_count; ++i) {
|
||
uint32_t ioa;
|
||
uint16_t payload_length;
|
||
const uint8_t *payload = Element_Position(&result, type, i, &ioa, &payload_length);
|
||
IEC60870_AsduResult_t status = IEC60870_InformationObject_Decode(result.type_id, ioa,
|
||
payload, payload_length, NULL, 0);
|
||
if (status != IEC60870_ASDU_OK) { return status; }
|
||
}
|
||
*info = result;
|
||
return IEC60870_ASDU_OK;
|
||
}
|
||
|
||
/**
|
||
* 功能：从已解析视图中按索引取得一个独立类型的对象副本。
|
||
* 输入参数：info——由Asdu_Parse生成且未修改的视图，其原文和参数仍须有效。
|
||
* index——从0开始的对象索引，必须小于object_count。
|
||
* object_size——object实际可用字节数，至少为对应具体结构的sizeof。
|
||
* 输出参数：object——非空具体对象存储，结构类型必须由info->type_id正确选择。
|
||
* 返回值：OK为成功；UNSUPPORTED为未知类型；ERROR为布局、索引、载荷或输出尺寸非法。
|
||
* 说明：输出无需预先Create，成功时按值保存且不借用原文，失败保持原输出不变。
|
||
* 只重新检查布局和选中对象；尺寸校验不能替代C语言类型匹配，公共头仍从info读取。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Get_Element(const IEC60870_AsduInfo_t *info,
|
||
uint8_t index, void *object, size_t object_size)
|
||
{
|
||
const IEC60870_InformationObjectVTable *type;
|
||
const uint8_t *payload;
|
||
uint32_t ioa;
|
||
uint16_t payload_length;
|
||
if (info == NULL || object == NULL) { return IEC60870_ASDU_ERROR; }
|
||
type = IEC60870_InformationObject_Get_Descriptor(info->type_id);
|
||
if (type == NULL) { return IEC60870_ASDU_UNSUPPORTED; }
|
||
if (!Layout_Valid(info, type) || index >= info->object_count) { return IEC60870_ASDU_ERROR; }
|
||
payload = Element_Position(info, type, index, &ioa, &payload_length);
|
||
return IEC60870_InformationObject_Decode(info->type_id, ioa, payload,
|
||
payload_length, object, object_size);
|
||
}
|
||
|
||
/**
|
||
* 功能：复制请求原文并改写COT/P/N，构造确认、终止或未知字段错误应答。
|
||
* 输入参数：parameters——与请求布局匹配的非空合法应用层参数。
|
||
* request——非空请求ASDU原文，不含APCI。
|
||
* length——请求ASDU的完整字节数。
|
||
* cause——接受7、9、10及44..47；分别用于确认、终止及未知类型/原因/地址。
|
||
* is_negative——P/N标志，0或1；否定激活确认使用cause=7、is_negative=1。
|
||
* capacity——out实际可写字节数，至少为length。
|
||
* 输出参数：out——非空应答缓冲区，可与request原地或部分重叠。
|
||
* out_length——非空长度输出，成功时等于length。
|
||
* 返回值：OK为成功，FULL为输出容量不足，ERROR为参数或请求基础格式非法。
|
||
* 说明：只依赖公共头和最低长度检查，不要求具体对象解析成功，因此可回显未知类型。
|
||
* 保留TEST、OA、CA、VSQ及所有对象字节；失败不修改out/out_length，不自动发送。
|
||
*/
|
||
IEC60870_AsduResult_t IEC60870_Asdu_Build_Response(const IEC60870_AppLayerParameters_t *parameters,
|
||
const uint8_t *request, uint16_t length,
|
||
int cause, int is_negative, uint8_t *out, uint16_t capacity, uint16_t *out_length)
|
||
{
|
||
IEC60870_AsduInfo_t info;
|
||
uint8_t cot;
|
||
if (out == NULL || out_length == NULL || (is_negative != 0 && is_negative != 1) ||
|
||
(cause != IEC60870_ASDU_COT_ACTIVATION_CON && cause != IEC60870_ASDU_COT_DEACTIVATION_CON &&
|
||
cause != IEC60870_ASDU_COT_ACTIVATION_TERMINATION &&
|
||
(cause < IEC60870_ASDU_COT_UNKNOWN_TYPE || cause > IEC60870_ASDU_COT_UNKNOWN_IOA)) ||
|
||
!IEC60870_Parse_ASDU_Header(parameters, request, length, &info)) {
|
||
return IEC60870_ASDU_ERROR;
|
||
}
|
||
if (capacity < length) { return IEC60870_ASDU_FULL; }
|
||
/* 先保存新COT，再memmove原文；即使输入输出重叠，也不会丢失请求的TEST。 */
|
||
cot = (uint8_t)(cause | (is_negative << 6) | (info.is_test << 7));
|
||
memmove(out, request, length);
|
||
out[2] = cot;
|
||
*out_length = length;
|
||
return IEC60870_ASDU_OK;
|
||
}
|