Files
STM32F4-Base/IEC60870-Slave/test/iec60870_asdu_test.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

1042 lines
67 KiB
C

/* 独立字节向量、边界和失败原子性测试,不操作网络或系统时钟。
* 这里只用联合体为多种具体类型复用测试存储;生产API均采用独立类型。 */
/*
* 文件内导航(搜索方括号标记;Suite:Common):
* 公共ASDU与信息对象编解码;Header、Vector、Sample_Object等由iec60870_asdu_fixture.h共享。
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
* [ASDU/FIXTURE] 本套件辅助:参数、具体对象解析与失败原子性断言
* [ASDU/LAYOUT] 编解码用例:字段宽度矩阵与具体对象入口
* [ASDU/VALIDATION] 边界用例:容量、地址、非法载荷、构造失败与Add原子性
* [ASDU/NUMERIC] 数值与参数用例:位模式、NULL和应用层参数
* [ASDU/RESPONSE] 应答容器用例:原文回显及CA修改
* [ENTRY/MAIN] 测试入口:按主题登记公共ASDU用例
* 公共辅助、业务专属辅助和用例按分区阅读;RUN/CASE标记用于细分执行组。
*/
/* ============================================================================
* [COMMON/BASE] 公共基础:依赖、编译选项与断言入口
* ============================================================================ */
#include "iec60870_asdu_fixture.h"
/* ============================================================================
* [ASDU/FIXTURE] 本套件辅助:参数、具体对象解析与失败原子性断言
* ============================================================================ */
/* 显式采用2/2/3、249布局作为一组测试参数;公共模块不依赖104默认宏。 */
static const IEC60870_AppLayerParameters_t parameters104 = {1, 1, 2, 0, 2, 3, 249};
/**
* 功能:直接测试各类型的载荷解析入口,独立于ASDU布局。
* 输入参数:type——协议类型或期望事件类型;ioa——信息对象地址;payload——原始对象载荷(只读);length——字节长度;object——测试信息对象联合体。
* 输出参数:object——构造、解析或追加完成的对象/ASDU。
* 返回值:对象构造、解析或追加的 ASDU 结果,保留无效输入、不支持类型及容量不足。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
static IEC60870_AsduResult_t Parse_Object(uint8_t type, uint32_t ioa,
const uint8_t *payload, uint16_t length, TestObject *object)
{
switch (type) {
case 1: return IEC60870_SinglePointInformation_Get_From_Buffer(object == NULL ? NULL : &object->v1, ioa, payload, length);
case 3: return IEC60870_DoublePointInformation_Get_From_Buffer(object == NULL ? NULL : &object->v3, ioa, payload, length);
case 9: return IEC60870_MeasuredValueNormalized_Get_From_Buffer(object == NULL ? NULL : &object->v9, ioa, payload, length);
case 11: return IEC60870_MeasuredValueScaled_Get_From_Buffer(object == NULL ? NULL : &object->v11, ioa, payload, length);
case 13: return IEC60870_MeasuredValueShort_Get_From_Buffer(object == NULL ? NULL : &object->v13, ioa, payload, length);
case 15: return IEC60870_IntegratedTotals_Get_From_Buffer(object == NULL ? NULL : &object->v15, ioa, payload, length);
case 30: return IEC60870_SinglePointWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v30, ioa, payload, length);
case 31: return IEC60870_DoublePointWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v31, ioa, payload, length);
case 34: return IEC60870_MeasuredValueNormalizedWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v34, ioa, payload, length);
case 35: return IEC60870_MeasuredValueScaledWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v35, ioa, payload, length);
case 36: return IEC60870_MeasuredValueShortWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v36, ioa, payload, length);
case 37: return IEC60870_IntegratedTotalsWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v37, ioa, payload, length);
case 45: return IEC60870_SingleCommand_Get_From_Buffer(object == NULL ? NULL : &object->v45, ioa, payload, length);
case 46: return IEC60870_DoubleCommand_Get_From_Buffer(object == NULL ? NULL : &object->v46, ioa, payload, length);
case 47: return IEC60870_StepCommand_Get_From_Buffer(object == NULL ? NULL : &object->v47, ioa, payload, length);
case 48: return IEC60870_SetpointCommandNormalized_Get_From_Buffer(object == NULL ? NULL : &object->v48, ioa, payload, length);
case 49: return IEC60870_SetpointCommandScaled_Get_From_Buffer(object == NULL ? NULL : &object->v49, ioa, payload, length);
case 50: return IEC60870_SetpointCommandShort_Get_From_Buffer(object == NULL ? NULL : &object->v50, ioa, payload, length);
case 58: return IEC60870_SingleCommandWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v58, ioa, payload, length);
case 59: return IEC60870_DoubleCommandWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v59, ioa, payload, length);
case 60: return IEC60870_StepCommandWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v60, ioa, payload, length);
case 61: return IEC60870_SetpointCommandNormalizedWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v61, ioa, payload, length);
case 62: return IEC60870_SetpointCommandScaledWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v62, ioa, payload, length);
case 63: return IEC60870_SetpointCommandShortWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v63, ioa, payload, length);
case 100: return IEC60870_InterrogationCommand_Get_From_Buffer(object == NULL ? NULL : &object->v100, ioa, payload, length);
case 101: return IEC60870_CounterInterrogationCommand_Get_From_Buffer(object == NULL ? NULL : &object->v101, ioa, payload, length);
case 102: return IEC60870_ReadCommand_Get_From_Buffer(object == NULL ? NULL : &object->v102, ioa, payload, length);
case 103: return IEC60870_ClockSynchronizationCommand_Get_From_Buffer(object == NULL ? NULL : &object->v103, ioa, payload, length);
case 105: return IEC60870_ResetProcessCommand_Get_From_Buffer(object == NULL ? NULL : &object->v105, ioa, payload, length);
case 107: return IEC60870_TestCommandWithCP56Time2a_Get_From_Buffer(object == NULL ? NULL : &object->v107, ioa, payload, length);
default: return IEC60870_ASDU_UNSUPPORTED;
}
}
/**
* 功能:失败不仅要返回指定错误,还必须保留调用方原有的解析结果。
* 输入参数:p——应用层字段宽度配置(只读);frame——读取结果帧或报文缓冲区(只读);length——字节长度;expected——期望的结果或数量。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:哨兵覆盖结构体全部字节。
*/
static int Reject_Frame(const IEC60870_AppLayerParameters_t *p,
const uint8_t *frame, uint16_t length, IEC60870_AsduResult_t expected)
{
IEC60870_AsduInfo_t info;
unsigned char saved[sizeof(info)];
memset(&info, 0xA5, sizeof(info));
memcpy(saved, &info, sizeof(info));
CHECK(IEC60870_Asdu_Parse(p, frame, length, &info) == expected);
CHECK(memcmp(saved, &info, sizeof(info)) == 0);
return 1;
}
/* ============================================================================
* [ASDU/LAYOUT] 编解码用例:字段宽度矩阵与具体对象入口
* ============================================================================ */
/**
* 功能:验证以下场景与约束:12种配置 x(12监视类型 x 两种SQ + 18命令类型)=504种完整布局。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:对命令新增编码测试;监视使用两个对象,验证连续/独立地址和所有字段。
*/
static int test_wire_matrix(void)
{
static const uint8_t addresses[2][3] = {{0x56,0x34,0x12}, {0x57,0x34,0x12}};
IEC60870_AppLayerParameters_t p = parameters104;
size_t v;
for (p.sizeOfCOT = 1; p.sizeOfCOT <= 2; ++p.sizeOfCOT) {
for (p.sizeOfCA = 1; p.sizeOfCA <= 2; ++p.sizeOfCA) {
for (p.sizeOfIOA = 1; p.sizeOfIOA <= 3; ++p.sizeOfIOA) {
uint32_t base = p.sizeOfIOA == 1 ? 0x56U : p.sizeOfIOA == 2 ? 0x3456U : 0x123456U;
for (v = 0; v < COUNT(vectors); ++v) {
const Vector *vector = &vectors[v];
int sq;
for (sq = 0; sq <= (vector->command ? 0 : 1); ++sq) {
uint8_t frame[64], expected[64], saved[64];
IEC60870_Asdu_t asdu, saved_asdu;
IEC60870_AsduInfo_t info;
IEC60870_AsduHeader_t header = Header();
TestObject input, output;
const uint8_t *data = NULL;
uint16_t length = 77, h, n;
int i, count = vector->command ? 1 : 2;
header.common_address = p.sizeOfCA == 1 ? 0x67 : 0x4567;
header.cause_of_transmission = vector->command ? 6 : 3;
header.is_negative_confirm = vector->command;
memset(frame, 0xA5, sizeof(frame));
/* 前后各留哨兵,容量和偏移故意不等于整个数组,检查编码器遵守借用区间。 */
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame + 1, 62, &header, sq) == IEC60870_ASDU_OK);
CHECK(asdu.type_id == 0 && frame[1] == 0 && asdu.object_count == 0);
CHECK(IEC60870_Asdu_Get_Data(&asdu, &data, &length) == IEC60870_ASDU_ERROR);
CHECK(data == NULL && length == 77);
h = Wire_Header(&p, vector->type, (uint8_t)(count | (sq << 7)),
vector->command ? 0xC6 : 0x83, expected);
n = h;
for (i = 0; i < count; ++i) {
CHECK(Sample_Object(vector->type, base + (uint32_t)i, &input) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, Object_Base(&input, vector->type)) == IEC60870_ASDU_OK);
/* SQ=1只发送首IOA,后续对象地址由位置推导;SQ=0每个对象都带地址。 */
if (!sq || i == 0) {
memcpy(expected + n, addresses[i], (size_t)p.sizeOfIOA);
n += (uint16_t)p.sizeOfIOA;
}
memcpy(expected + n, vector->payload, vector->size); n += vector->size;
}
CHECK(IEC60870_Asdu_Get_Data(&asdu, &data, &length) == IEC60870_ASDU_OK);
CHECK(length == n && data == frame + 1 && memcmp(data, expected, n) == 0);
CHECK(frame[0] == 0xA5 && frame[n + 1] == 0xA5 && asdu.parameters == &p);
CHECK(IEC60870_Asdu_Parse(&p, expected, n, &info) == IEC60870_ASDU_OK);
CHECK(info.type_id == vector->type && info.object_count == count && info.is_sequence == sq);
CHECK(info.parameters == &p && info.information_objects == expected + h);
CHECK(info.common_address == header.common_address && info.is_test == 1);
CHECK(info.originator_address == (p.sizeOfCOT == 2 ? 0x21 : 0));
CHECK(info.cause_of_transmission == (vector->command ? 6 : 3));
CHECK(info.is_negative_confirm == vector->command);
for (i = 0; i < count; ++i) {
unsigned char snapshot[sizeof(output)];
memset(&output, 0xA5, sizeof(output)); memcpy(snapshot, &output, sizeof(output));
CHECK(IEC60870_Asdu_Get_Element(&info, (uint8_t)i, &output, Object_Size(vector->type) - 1) == IEC60870_ASDU_ERROR);
CHECK(memcmp(snapshot, &output, sizeof(output)) == 0);
CHECK(IEC60870_Asdu_Get_Element(&info, (uint8_t)i, &output, Object_Size(vector->type)) == IEC60870_ASDU_OK);
CHECK(Object_Base(&output, vector->type)->ioa == base + (uint32_t)i);
CHECK(IEC60870_InformationObject_Get_Type(Object_Base(&output, vector->type)) == vector->type);
CHECK(Check_Object(vector, &output));
CHECK(memcmp((unsigned char *)&output + Object_Size(vector->type),
snapshot + Object_Size(vector->type), sizeof(output) - Object_Size(vector->type)) == 0);
}
/* 遍历所有截断位置,并再多传一个尾字节,防止解析器只检查最短长度。 */
for (i = 0; i < n; ++i) { CHECK(Reject_Frame(&p, expected, (uint16_t)i, IEC60870_ASDU_ERROR)); }
expected[n] = 0;
CHECK(Reject_Frame(&p, expected, (uint16_t)(n + 1), IEC60870_ASDU_ERROR));
/* 命令数量上限;第二个对象不改变容器或原文。 */
if (vector->command) {
memcpy(saved, frame, sizeof(frame)); memcpy(&saved_asdu, &asdu, sizeof(asdu));
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, Object_Base(&input, vector->type)) == IEC60870_ASDU_FULL);
CHECK(memcmp(saved, frame, sizeof(frame)) == 0 && memcmp(&saved_asdu, &asdu, sizeof(asdu)) == 0);
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 1) == IEC60870_ASDU_OK);
memcpy(saved, frame, sizeof(frame)); memcpy(&saved_asdu, &asdu, sizeof(asdu));
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, Object_Base(&input, vector->type)) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, frame, sizeof(frame)) == 0 && memcmp(&saved_asdu, &asdu, sizeof(asdu)) == 0);
}
}
}
}
}
}
return 1;
}
/**
* 功能:逐类型核对对象级Encode/Get_From_Buffer及独立载荷向量。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:同时覆盖未对齐输入、解析结果不借用源数据,以及容量/参数错误时输出不变。
*/
static int test_object_entrypoints(void)
{
size_t v;
for (v = 0; v < COUNT(vectors); ++v) {
const Vector *vector = &vectors[v];
TestObject input, output;
unsigned char snapshot[sizeof(output)];
uint8_t encoded[20], saved[20], payload[13];
uint16_t length = 99, n;
CHECK(Sample_Object(vector->type, 0x123456, &input) == IEC60870_ASDU_OK);
memset(encoded, 0xA5, sizeof(encoded));
CHECK(IEC60870_InformationObject_Encode(Object_Base(&input, vector->type), &parameters104, 0,
encoded, sizeof(encoded), &length) == IEC60870_ASDU_OK);
CHECK(length == vector->size + 3U && encoded[0] == 0x56 && encoded[1] == 0x34 && encoded[2] == 0x12);
CHECK(memcmp(encoded + 3, vector->payload, vector->size) == 0 && encoded[length] == 0xA5);
memcpy(saved, encoded, sizeof(saved)); length = 99;
CHECK(IEC60870_InformationObject_Encode(Object_Base(&input, vector->type), &parameters104, 0,
encoded, (uint16_t)(vector->size + 2), &length) == IEC60870_ASDU_FULL);
CHECK(length == 99 && memcmp(encoded, saved, sizeof(saved)) == 0);
if (!vector->command) {
CHECK(IEC60870_InformationObject_Encode(Object_Base(&input, vector->type), &parameters104, 1,
encoded, sizeof(encoded), &length) == IEC60870_ASDU_OK);
CHECK(length == vector->size && memcmp(encoded, vector->payload, length) == 0);
} else {
CHECK(IEC60870_InformationObject_Encode(Object_Base(&input, vector->type), &parameters104, 1,
encoded, sizeof(encoded), &length) == IEC60870_ASDU_ERROR);
}
memcpy(payload, vector->payload, vector->size);
CHECK(Parse_Object(vector->type, 0x123456, payload, vector->size, &output) == IEC60870_ASDU_OK);
memcpy(payload + 1, vector->payload, vector->size);
CHECK(Parse_Object(vector->type, 0x123456, payload + 1, vector->size, &output) == IEC60870_ASDU_OK);
memset(payload, 0, sizeof(payload)); /* 按值对象不借用载荷。 */
CHECK(Check_Object(vector, &output));
CHECK(Object_Base(&output, vector->type)->ioa == 0x123456);
memset(&output, 0xA5, sizeof(output)); memcpy(snapshot, &output, sizeof(output));
for (n = 0; n < vector->size; ++n) {
CHECK(Parse_Object(vector->type, 0, vector->payload, n, &output) == IEC60870_ASDU_ERROR);
CHECK(memcmp(snapshot, &output, sizeof(output)) == 0);
}
CHECK(Parse_Object(vector->type, 0, vector->payload, (uint16_t)(vector->size + 1), &output) == IEC60870_ASDU_ERROR);
CHECK(Parse_Object(vector->type, 0x1000000, vector->payload, vector->size, &output) == IEC60870_ASDU_ERROR);
CHECK(Parse_Object(vector->type, 0, vector->payload, vector->size, NULL) == IEC60870_ASDU_ERROR);
if (vector->size != 0U) {
CHECK(Parse_Object(vector->type, 0, NULL, vector->size, &output) == IEC60870_ASDU_ERROR);
}
CHECK(memcmp(snapshot, &output, sizeof(output)) == 0);
Object_Base(&input, vector->type)->virtual_function_table = NULL;
CHECK(IEC60870_InformationObject_Get_Type(Object_Base(&input, vector->type)) == 0);
CHECK(IEC60870_InformationObject_Encode(Object_Base(&input, vector->type), &parameters104, 0,
encoded, sizeof(encoded), &length) == IEC60870_ASDU_ERROR);
}
{
IEC60870_ReadCommand_t read;
CHECK(IEC60870_ReadCommand_Get_From_Buffer(&read, 7, NULL, 0) == IEC60870_ASDU_OK && read.object.ioa == 7);
}
return 1;
}
/* ============================================================================
* [ASDU/VALIDATION] 边界用例:容量、地址、非法载荷、构造失败与Add原子性
* ============================================================================ */
/**
* 功能:验证 ASDU 最大对象容量和地址宽度。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:追加满后原对象与缓冲不变,重建后可重试同一对象。
*/
static int test_capacity_and_addresses(void)
{
IEC60870_AppLayerParameters_t p = parameters104;
IEC60870_Asdu_t asdu, saved_asdu;
IEC60870_AsduInfo_t info;
IEC60870_AsduHeader_t header = Header();
IEC60870_MeasuredValueNormalized_t value;
IEC60870_SinglePointInformation_t point, decoded;
uint8_t frame[300], before[300];
const uint8_t *data = NULL;
uint16_t length = 0;
unsigned int i;
memset(frame, 0xA5, sizeof(frame));
CHECK(IEC60870_MeasuredValueNormalized_Create(&value, 0, -1, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 1) == IEC60870_ASDU_OK);
for (i = 0; i < 80; ++i) {
value.object.ioa = i;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_OK);
}
CHECK(IEC60870_Asdu_Get_Data(&asdu, &data, &length) == IEC60870_ASDU_OK && length == 249);
CHECK(asdu.capacity == 249 && frame[1] == 0xD0 && frame[249] == 0xA5);
memcpy(before, frame, sizeof(frame)); memcpy(&saved_asdu, &asdu, sizeof(asdu));
value.object.ioa = 80;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_FULL);
CHECK(memcmp(before, frame, sizeof(frame)) == 0 && memcmp(&saved_asdu, &asdu, sizeof(asdu)) == 0);
/* FULL后开启下一条并重试原对象。 */
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 1) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_OK && asdu.object_count == 1);
p.sizeOfCOT = 1; p.sizeOfCA = 1; p.sizeOfIOA = 2; p.maxSizeOfASDU = 254;
header.common_address = 0x67;
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_OK);
for (i = 0; i < 50; ++i) {
value.object.ioa = i;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_OK);
}
CHECK(asdu.length == 254 && asdu.capacity == 254 && frame[254] == 0xA5);
memcpy(before, frame, sizeof(frame)); memcpy(&saved_asdu, &asdu, sizeof(asdu));
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_FULL);
CHECK(memcmp(before, frame, sizeof(frame)) == 0 && memcmp(&saved_asdu, &asdu, sizeof(asdu)) == 0);
CHECK(IEC60870_Asdu_Parse(&p, frame, 254, &info) == IEC60870_ASDU_OK);
CHECK(!IEC60870_Parse_ASDU_Header(&parameters104, frame, 254, &info));
/* 首对象装不下:类型和VSQ保持空状态;参数上限与实际容量都要生效。 */
for (i = 0; i < 3; ++i) {
p.maxSizeOfASDU = i == 0 ? 4 : i == 1 ? 8 : 254;
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, i == 2 ? 8 : sizeof(frame), &header, 0) == IEC60870_ASDU_OK);
memcpy(before, frame, sizeof(frame)); memcpy(&saved_asdu, &asdu, sizeof(asdu));
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_FULL);
CHECK(asdu.type_id == 0 && asdu.object_count == 0 && asdu.length == 4);
CHECK(memcmp(before, frame, sizeof(frame)) == 0 && memcmp(&saved_asdu, &asdu, sizeof(asdu)) == 0);
}
p.maxSizeOfASDU = 9;
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_OK && asdu.length == 9);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &value.object) == IEC60870_ASDU_FULL);
p.maxSizeOfASDU = 254;
CHECK(IEC60870_SinglePointInformation_Create(&point, 0, 1, 0) == IEC60870_ASDU_OK);
for (p.sizeOfIOA = 1; p.sizeOfIOA <= 3; ++p.sizeOfIOA) {
uint32_t max_ioa = p.sizeOfIOA == 1 ? 0xFFU : p.sizeOfIOA == 2 ? 0xFFFFU : 0xFFFFFFU;
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 1) == IEC60870_ASDU_OK);
point.object.ioa = max_ioa - 1U;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
++point.object.ioa;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Parse(&p, frame, asdu.length, &info) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Element(&info, 1, &decoded, sizeof(decoded)) == IEC60870_ASDU_OK && decoded.object.ioa == max_ioa);
memcpy(before, frame, sizeof(frame)); memcpy(&saved_asdu, &asdu, sizeof(asdu));
++point.object.ioa;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_ERROR);
point.object.ioa = 0;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_ERROR);
CHECK(memcmp(before, frame, sizeof(frame)) == 0 && memcmp(&saved_asdu, &asdu, sizeof(asdu)) == 0);
frame[4] = 0xFF; /* SQ首地址改为上限,隐含的第二个地址溢出。 */
CHECK(Reject_Frame(&p, frame, asdu.length, IEC60870_ASDU_ERROR));
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 1) == IEC60870_ASDU_OK);
for (i = 0; i < 127; ++i) {
point.object.ioa = i;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
}
point.object.ioa = 127;
memcpy(before, frame, sizeof(frame)); memcpy(&saved_asdu, &asdu, sizeof(asdu));
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_FULL);
CHECK(frame[1] == 0xFF && memcmp(before, frame, sizeof(frame)) == 0);
CHECK(memcmp(&saved_asdu, &asdu, sizeof(asdu)) == 0);
}
/* SQ=0允许不连续的独立地址。 */
p.sizeOfIOA = 3;
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_OK);
point.object.ioa = 7;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
point.object.ioa = 0x123456;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Parse(&p, frame, asdu.length, &info) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Element(&info, 1, &decoded, sizeof(decoded)) == IEC60870_ASDU_OK && decoded.object.ioa == 0x123456);
return 1;
}
/**
* 功能:验证以下场景与约束:在独立合法报文上修改SQ、对象数、品质或时标保留位,检查ASDU和对象解析同时拒绝。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:错误位于后部对象时也须拒绝整帧,不能只校验第一个对象。
*/
static int test_malformed_payloads(void)
{
size_t v;
for (v = 0; v < COUNT(vectors); ++v) {
const Vector *vector = &vectors[v];
uint8_t frame[64];
uint16_t n = Wire_Header(&parameters104, vector->type, 1, 3, frame);
uint16_t h = n;
TestObject output;
unsigned char saved[sizeof(output)];
frame[n++] = 0; frame[n++] = 0; frame[n++] = 0;
memcpy(frame + n, vector->payload, vector->size); n += vector->size;
if (vector->command) {
frame[1] = 0x81;
CHECK(Reject_Frame(&parameters104, frame, n, IEC60870_ASDU_ERROR));
frame[1] = 2;
memcpy(frame + n, frame + h, n - h);
CHECK(Reject_Frame(&parameters104, frame, (uint16_t)(n + n - h), IEC60870_ASDU_ERROR));
frame[1] = 1;
}
if (vector->timed) {
frame[n - 4] |= 0x20; /* CP56小时RES2;分钟bit6是可接收的GEN,不是非法编码。 */
} else if (vector->type == 1 || vector->type == 45) {
frame[h + 3] |= 2;
} else if (vector->type == 3) {
frame[h + 3] |= 4;
} else if (vector->type == 9 || vector->type == 11 || vector->type == 13) {
frame[n - 1] |= 2;
} else if (vector->type == 46 || vector->type == 47) {
frame[h + 3] |= 3; /* 双命令/步调节状态3非法。 */
} else { continue; }
CHECK(Reject_Frame(&parameters104, frame, n, IEC60870_ASDU_ERROR));
memset(&output, 0xA5, sizeof(output)); memcpy(saved, &output, sizeof(output));
CHECK(Parse_Object(vector->type, 0, frame + h + 3, vector->size, &output) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &output, sizeof(output)) == 0);
}
{
uint8_t frame[] = {1,0x82,3,0,1,0,0,0,0,1,2};
CHECK(Reject_Frame(&parameters104, frame, sizeof(frame), IEC60870_ASDU_ERROR)); /* 后部对象错误 */
frame[1] = 0;
CHECK(Reject_Frame(&parameters104, frame, 6, IEC60870_ASDU_ERROR));
frame[0] = 250;
CHECK(Reject_Frame(&parameters104, frame, 6, IEC60870_ASDU_UNSUPPORTED));
}
return 1;
}
/**
* 功能:验证以下场景与约束:CP56接收按合法日期解释时刻,星期为可选信息,GEN与IV独立。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:穷举星期0..7、GEN/IV/SU,验证归一化编码、失败原子性及转换仍拒绝IV。
* 本测试直接给定闰日和非法位,避免仅以编解码互逆代替协议边界断言。
*/
static int test_cp56_reception(void)
{
static const uint8_t source[7] = {0xd5U,0xddU,34U,12U,29U,2U,24U}; /* 2024-02-29 Thu 12:34:56.789 */
static const struct { uint8_t offset, mask; } reserved[] = {
{3U,0x20U},{3U,0x40U},{5U,0x10U},{5U,0x20U},
{5U,0x40U},{5U,0x80U},{6U,0x80U}
};
static const struct { uint8_t offset, value; } invalid[] = {
{2U,60U},{3U,24U},{4U,0U},{4U,30U},{5U,0U},{5U,13U},{6U,100U}
};
IEC60870_CP56Time2a_t decoded, saved;
uint8_t bytes[7], encoded[7];
unsigned weekday, flags;
size_t i;
for (weekday = 0U; weekday < 8U; ++weekday) {
for (flags = 0U; flags < 8U; ++flags) {
uint32_t seconds = 123U;
memcpy(bytes, source, sizeof(bytes));
bytes[2] |= (uint8_t)(((flags & 1U) << 6) | ((flags & 2U) << 6));
bytes[3] |= (uint8_t)((flags & 4U) << 5);
bytes[4] |= (uint8_t)(weekday << 5);
CHECK(IEC60870_Time_From_CP56(bytes, sizeof(bytes), &decoded));
CHECK(decoded.time.year == 2024U && decoded.time.month == 2U && decoded.time.day == 29U);
CHECK(decoded.time.hour == 12U && decoded.time.minute == 34U && decoded.time.second == 56U);
CHECK(decoded.time.ms == 789U && decoded.time.weekday == 4U);
CHECK(decoded.has_weekday == (weekday != 0U));
CHECK(decoded.is_invalid == ((flags >> 1) & 1U));
CHECK(decoded.is_summer_time == ((flags >> 2) & 1U));
if (decoded.is_invalid) {
CHECK(!IEC60870_Time_CP56_To_Seconds(&decoded, 0, &seconds));
CHECK(seconds == 123U);
} else {
CHECK(IEC60870_Time_CP56_To_Seconds(&decoded, 0, &seconds));
CHECK(seconds == UINT32_C(1709210096) - (uint32_t)decoded.is_summer_time * 3600U);
}
CHECK(IEC60870_Time_To_CP56(&decoded, encoded, sizeof(encoded)));
/* 这是日历规范化编码;业务原文确认须另行保留GEN及对端填写的星期。 */
bytes[2] &= (uint8_t)~0x40U;
bytes[4] = (uint8_t)(29U | (weekday != 0U ? 0x80U : 0U));
CHECK(memcmp(bytes, encoded, sizeof(bytes)) == 0);
}
}
memset(&decoded, 0xa5, sizeof(decoded));
memcpy(&saved, &decoded, sizeof(saved));
for (i = 0U; i < COUNT(reserved); ++i) {
memcpy(bytes, source, sizeof(bytes));
bytes[2] |= 0x40U;
bytes[4] |= 0x20U; /* 即使星期/GEN可接收,RES2/3/4仍必须为0。 */
bytes[reserved[i].offset] |= reserved[i].mask;
CHECK(!IEC60870_Time_From_CP56(bytes, sizeof(bytes), &decoded));
CHECK(memcmp(&decoded, &saved, sizeof(decoded)) == 0);
}
for (i = 0U; i < COUNT(invalid); ++i) {
memcpy(bytes, source, sizeof(bytes));
bytes[invalid[i].offset] = invalid[i].value;
CHECK(!IEC60870_Time_From_CP56(bytes, sizeof(bytes), &decoded));
CHECK(memcmp(&decoded, &saved, sizeof(decoded)) == 0);
}
memcpy(bytes, source, sizeof(bytes));
bytes[0] = 0x60U; bytes[1] = 0xeaU; /* 60000ms不能表示分钟内毫秒。 */
CHECK(!IEC60870_Time_From_CP56(bytes, sizeof(bytes), &decoded));
CHECK(memcmp(&decoded, &saved, sizeof(decoded)) == 0);
CHECK(!IEC60870_Time_From_CP56(source, sizeof(source) - 1U, &decoded));
CHECK(memcmp(&decoded, &saved, sizeof(decoded)) == 0);
/* 具体对象和整条ASDU都必须应用相同规则,应答容器仍逐字节保留收到的时标。 */
for (i = 0U; i < COUNT(vectors); ++i) {
const Vector *vector = &vectors[i];
uint8_t frame[64], reply[64];
uint16_t n, length;
IEC60870_AsduInfo_t info;
TestObject object;
if (!vector->timed) { continue; }
n = Wire_Header(&parameters104, vector->type, 1U, vector->command ? 6U : 3U, frame);
frame[n++] = 1U; frame[n++] = 0U; frame[n++] = 0U;
memcpy(frame + n, vector->payload, vector->size);
n += vector->size;
frame[n - 5U] |= 0x40U;
frame[n - 3U] = (uint8_t)((frame[n - 3U] & 0x1fU) | 0x20U);
CHECK(Parse_Object(vector->type, 1U, frame + 9U, vector->size, &object) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Parse(&parameters104, frame, n, &info) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Element(&info, 0U, &object, Object_Size(vector->type)) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Build_Response(&parameters104, frame, n, 7U, 0, reply, sizeof(reply), &length) == IEC60870_ASDU_OK);
CHECK(length == n && memcmp(frame + 3U, reply + 3U, n - 3U) == 0);
}
return 1;
}
/**
* 功能:验证以下场景与约束:对各构造函数分别提供空指针、越界IOA、非法值/品质/时标,检查失败不改写目标对象。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int test_constructor_failures(void)
{
TestObject object;
unsigned char saved[sizeof(object)];
IEC60870_CP56Time2a_t time = Sample_Time();
IEC60870_CP56Time2a_t bad_time = time;
IEC60870_BinaryCounterReading_t counter = {INT32_MIN, 21, 1, 1, 1};
IEC60870_BinaryCounterReading_t bad_counter = counter;
bad_time.time.day = 30; /* 不存在的2024-02-30。 */
bad_counter.sequence_number = 32;
memset(&object, 0xA5, sizeof(object)); memcpy(saved, &object, sizeof(object));
CHECK(IEC60870_SinglePointInformation_Create(NULL, 0, 1, 0xF0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SinglePointInformation_Create(&object.v1, 0x1000000, 1, 0xF0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SinglePointInformation_Create(&object.v1, 0, 1, 2) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_DoublePointInformation_Create(NULL, 0, 3, 0x90) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoublePointInformation_Create(&object.v3, 0x1000000, 3, 0x90) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoublePointInformation_Create(&object.v3, 0, 3, 2) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_MeasuredValueNormalized_Create(NULL, 0, INT16_MIN, 0x81) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueNormalized_Create(&object.v9, 0x1000000, INT16_MIN, 0x81) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueNormalized_Create(&object.v9, 0, 0, 2) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_MeasuredValueScaled_Create(NULL, 0, -2, 0x10) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueScaled_Create(&object.v11, 0x1000000, -2, 0x10) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueScaled_Create(&object.v11, 0, 0, 2) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_MeasuredValueShort_Create(NULL, 0, 1.5f, 0x41) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueShort_Create(&object.v13, 0x1000000, 1.5f, 0x41) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueShort_Create(&object.v13, 0, 0, 2) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_IntegratedTotals_Create(NULL, 0, &counter) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_IntegratedTotals_Create(&object.v15, 0x1000000, &counter) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_IntegratedTotals_Create(&object.v15, 0, &bad_counter) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SinglePointWithCP56Time2a_Create(NULL, 0, 1, 0xF0, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SinglePointWithCP56Time2a_Create(&object.v30, 0x1000000, 1, 0xF0, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SinglePointWithCP56Time2a_Create(&object.v30, 0, 1, 0xF0, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_DoublePointWithCP56Time2a_Create(NULL, 0, 3, 0x90, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoublePointWithCP56Time2a_Create(&object.v31, 0x1000000, 3, 0x90, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoublePointWithCP56Time2a_Create(&object.v31, 0, 3, 0x90, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_MeasuredValueNormalizedWithCP56Time2a_Create(NULL, 0, INT16_MIN, 0x81, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueNormalizedWithCP56Time2a_Create(&object.v34, 0x1000000, INT16_MIN, 0x81, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueNormalizedWithCP56Time2a_Create(&object.v34, 0, INT16_MIN, 0x81, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_MeasuredValueScaledWithCP56Time2a_Create(NULL, 0, -2, 0x10, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueScaledWithCP56Time2a_Create(&object.v35, 0x1000000, -2, 0x10, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueScaledWithCP56Time2a_Create(&object.v35, 0, -2, 0x10, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_MeasuredValueShortWithCP56Time2a_Create(NULL, 0, 1.5f, 0x41, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueShortWithCP56Time2a_Create(&object.v36, 0x1000000, 1.5f, 0x41, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_MeasuredValueShortWithCP56Time2a_Create(&object.v36, 0, 1.5f, 0x41, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_IntegratedTotalsWithCP56Time2a_Create(NULL, 0, &counter, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_IntegratedTotalsWithCP56Time2a_Create(&object.v37, 0x1000000, &counter, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_IntegratedTotalsWithCP56Time2a_Create(&object.v37, 0, &counter, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SingleCommand_Create(NULL, 0, 1, 1, 3) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SingleCommand_Create(&object.v45, 0x1000000, 1, 1, 3) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SingleCommand_Create(&object.v45, 0, 2, 1, 3) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_DoubleCommand_Create(NULL, 0, 2, 1, 1) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoubleCommand_Create(&object.v46, 0x1000000, 2, 1, 1) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoubleCommand_Create(&object.v46, 0, 0, 1, 1) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_StepCommand_Create(NULL, 0, 1, 0, 2) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_StepCommand_Create(&object.v47, 0x1000000, 1, 0, 2) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_StepCommand_Create(&object.v47, 0, 3, 0, 2) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SetpointCommandNormalized_Create(NULL, 0, INT16_MIN, 1, 65) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandNormalized_Create(&object.v48, 0x1000000, INT16_MIN, 1, 65) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandNormalized_Create(&object.v48, 0, 0, 1, 128) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SetpointCommandScaled_Create(NULL, 0, -2, 0, 127) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandScaled_Create(&object.v49, 0x1000000, -2, 0, 127) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandScaled_Create(&object.v49, 0, 0, 2, 0) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SetpointCommandShort_Create(NULL, 0, 1.5f, 1, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandShort_Create(&object.v50, 0x1000000, 1.5f, 1, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandShort_Create(&object.v50, 0, 0, -1, 0) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SingleCommandWithCP56Time2a_Create(NULL, 0, 1, 1, 3, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SingleCommandWithCP56Time2a_Create(&object.v58, 0x1000000, 1, 1, 3, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SingleCommandWithCP56Time2a_Create(&object.v58, 0, 1, 1, 3, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_DoubleCommandWithCP56Time2a_Create(NULL, 0, 2, 1, 1, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoubleCommandWithCP56Time2a_Create(&object.v59, 0x1000000, 2, 1, 1, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoubleCommandWithCP56Time2a_Create(&object.v59, 0, 2, 1, 1, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_StepCommandWithCP56Time2a_Create(NULL, 0, 1, 0, 2, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_StepCommandWithCP56Time2a_Create(&object.v60, 0x1000000, 1, 0, 2, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_StepCommandWithCP56Time2a_Create(&object.v60, 0, 1, 0, 2, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SetpointCommandNormalizedWithCP56Time2a_Create(NULL, 0, INT16_MIN, 1, 65, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandNormalizedWithCP56Time2a_Create(&object.v61, 0x1000000, INT16_MIN, 1, 65, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandNormalizedWithCP56Time2a_Create(&object.v61, 0, INT16_MIN, 1, 65, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SetpointCommandScaledWithCP56Time2a_Create(NULL, 0, -2, 0, 127, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandScaledWithCP56Time2a_Create(&object.v62, 0x1000000, -2, 0, 127, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandScaledWithCP56Time2a_Create(&object.v62, 0, -2, 0, 127, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SetpointCommandShortWithCP56Time2a_Create(NULL, 0, 1.5f, 1, 0, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandShortWithCP56Time2a_Create(&object.v63, 0x1000000, 1.5f, 1, 0, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SetpointCommandShortWithCP56Time2a_Create(&object.v63, 0, 1.5f, 1, 0, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_InterrogationCommand_Create(NULL, 0, 20) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_InterrogationCommand_Create(&object.v100, 0x1000000, 20) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_InterrogationCommand_Create(&object.v100, 0, 256) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_CounterInterrogationCommand_Create(NULL, 0, 5, 3) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_CounterInterrogationCommand_Create(&object.v101, 0x1000000, 5, 3) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_CounterInterrogationCommand_Create(&object.v101, 0, 64, 0) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_ReadCommand_Create(NULL, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_ReadCommand_Create(&object.v102, 0x1000000) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_ClockSynchronizationCommand_Create(NULL, 0, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_ClockSynchronizationCommand_Create(&object.v103, 0x1000000, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_ClockSynchronizationCommand_Create(&object.v103, 0, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_ResetProcessCommand_Create(NULL, 0, 2) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_ResetProcessCommand_Create(&object.v105, 0x1000000, 2) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_ResetProcessCommand_Create(&object.v105, 0, -1) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_TestCommandWithCP56Time2a_Create(NULL, 0, 0x1234, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_TestCommandWithCP56Time2a_Create(&object.v107, 0x1000000, 0x1234, &time) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_TestCommandWithCP56Time2a_Create(&object.v107, 0, 0, &bad_time) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
CHECK(IEC60870_SinglePointInformation_Create(&object.v1, 0, -1, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_DoublePointInformation_Create(&object.v3, 0, 4, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SingleCommand_Create(&object.v45, 0, 1, 0, 32) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_CounterInterrogationCommand_Create(&object.v101, 0, 1, 4) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_IntegratedTotals_Create(&object.v15, 0, NULL) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_SinglePointWithCP56Time2a_Create(&object.v30, 0, 1, 0, NULL) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_ClockSynchronizationCommand_Create(&object.v103, 0, NULL) == IEC60870_ASDU_ERROR);
CHECK(memcmp(saved, &object, sizeof(object)) == 0);
return 1;
}
/**
* 功能:验证以下场景与约束:编码时重新检查对象,不依赖Create曾经检查过字段。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int test_add_atomicity(void)
{
uint8_t frame[64], before[64];
IEC60870_Asdu_t asdu, saved;
IEC60870_AsduHeader_t header = Header();
IEC60870_SinglePointInformation_t point;
IEC60870_DoublePointInformation_t double_point;
IEC60870_SinglePointWithCP56Time2a_t timed;
IEC60870_CP56Time2a_t time = Sample_Time();
IEC60870_AsduInfo_t info;
unsigned char object_before[sizeof(point)];
CHECK(IEC60870_SinglePointInformation_Create(&point, 5, 1, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_DoublePointInformation_Create(&double_point, 6, 2, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, sizeof(frame), &header, 1) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
memcpy(before, frame, sizeof(frame)); memcpy(&saved, &asdu, sizeof(asdu));
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &double_point.object) == IEC60870_ASDU_ERROR);
point.object.ioa = 7;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_ERROR);
point.object.ioa = 6; point.quality = 2;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_ERROR);
point.quality = 0; point.value = 2;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_ERROR);
point.value = 1; point.object.virtual_function_table = double_point.object.virtual_function_table;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_ERROR);
point.object.type_id = 250;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_UNSUPPORTED);
CHECK(memcmp(before, frame, sizeof(frame)) == 0 && memcmp(&saved, &asdu, sizeof(asdu)) == 0);
CHECK(IEC60870_Asdu_Parse(&parameters104, frame, asdu.length, &info) == IEC60870_ASDU_OK);
memset(&point, 0xA5, sizeof(point)); memcpy(object_before, &point, sizeof(point));
CHECK(IEC60870_Asdu_Get_Element(&info, 1, &point, sizeof(point)) == IEC60870_ASDU_ERROR);
frame[9] |= 2; /* 视图建立后修改原文,取对象仍验证选中载荷。 */
CHECK(IEC60870_Asdu_Get_Element(&info, 0, &point, sizeof(point)) == IEC60870_ASDU_ERROR);
CHECK(memcmp(object_before, &point, sizeof(point)) == 0);
CHECK(IEC60870_SinglePointWithCP56Time2a_Create(&timed, 0, 1, 0, &time) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_OK);
memcpy(before, frame, sizeof(frame)); memcpy(&saved, &asdu, sizeof(asdu));
timed.time.time.day = 30;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &timed.base.object) == IEC60870_ASDU_ERROR);
CHECK(memcmp(before, frame, sizeof(frame)) == 0 && memcmp(&saved, &asdu, sizeof(asdu)) == 0);
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, 5, &header, 0) == IEC60870_ASDU_FULL);
header.is_test = 2;
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_ERROR);
header = Header(); header.cause_of_transmission = 64;
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_ERROR);
header = Header(); header.is_negative_confirm = 2;
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_ERROR);
header = Header();
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, sizeof(frame), &header, 2) == IEC60870_ASDU_ERROR);
CHECK(memcmp(before, frame, sizeof(frame)) == 0 && memcmp(&saved, &asdu, sizeof(asdu)) == 0);
return 1;
}
/* ============================================================================
* [ASDU/NUMERIC] 数值与参数用例:位模式、NULL和应用层参数
* ============================================================================ */
/**
* 功能:验证以下场景与约束:浮点按原始位模式比较,覆盖负零、非正规数、无穷和NaN载荷。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:数值相等无法证明字节未变。
*/
static int test_numeric_bits(void)
{
static const uint32_t bits[] = {0,0x80000000U,0x00000001U,0x7F7FFFFFU,0x7F800000U,0xFF800000U,0x7FC12345U};
static const uint8_t float_types[] = {13,36,50,63};
static const uint8_t time_bytes[] = {TIME_BYTES};
size_t i, t;
for (t = 0; t < COUNT(float_types); ++t) {
for (i = 0; i < COUNT(bits); ++i) {
uint8_t payload[12] = {0}, encoded[16];
TestObject object;
uint16_t length, size = (float_types[t] == 36 || float_types[t] == 63) ? 12 : 5;
unsigned int b;
for (b = 0; b < 4; ++b) { payload[b] = (uint8_t)(bits[i] >> (b * 8)); }
if (size == 12) { memcpy(payload + 5, time_bytes, 7); }
CHECK(Parse_Object(float_types[t], 0, payload, size, &object) == IEC60870_ASDU_OK);
CHECK(IEC60870_InformationObject_Encode(Object_Base(&object, float_types[t]), &parameters104,
0, encoded, sizeof(encoded), &length) == IEC60870_ASDU_OK);
CHECK(length == size + 3U && memcmp(encoded + 3, payload, size) == 0);
}
}
{
static const int16_t values[] = {INT16_MIN,-1,0,INT16_MAX};
static const uint8_t expected[][2] = {{0,0x80},{0xFF,0xFF},{0,0},{0xFF,0x7F}};
IEC60870_MeasuredValueNormalized_t object, decoded;
uint8_t encoded[6];
uint16_t length;
for (i = 0; i < COUNT(values); ++i) {
CHECK(IEC60870_MeasuredValueNormalized_Create(&object, 0, values[i], 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_InformationObject_Encode(&object.object, &parameters104, 0, encoded, sizeof(encoded), &length) == IEC60870_ASDU_OK);
CHECK(length == 6 && memcmp(encoded + 3, expected[i], 2) == 0);
CHECK(IEC60870_MeasuredValueNormalized_Get_From_Buffer(&decoded, 0, encoded + 3, 3) == IEC60870_ASDU_OK && decoded.value == values[i]);
}
}
{
static const int32_t values[] = {INT32_MIN,-1,0,INT32_MAX};
static const uint8_t expected[][4] = {
{0,0,0,0x80}, {0xFF,0xFF,0xFF,0xFF}, {0,0,0,0}, {0xFF,0xFF,0xFF,0x7F}
};
IEC60870_IntegratedTotals_t object, decoded;
IEC60870_BinaryCounterReading_t counter = {0,31,1,1,1};
uint8_t encoded[8];
uint16_t length;
for (i = 0; i < COUNT(values); ++i) {
counter.value = values[i];
CHECK(IEC60870_IntegratedTotals_Create(&object, 0, &counter) == IEC60870_ASDU_OK);
CHECK(IEC60870_InformationObject_Encode(&object.object, &parameters104, 0, encoded, sizeof(encoded), &length) == IEC60870_ASDU_OK);
CHECK(length == 8 && memcmp(encoded + 3, expected[i], 4) == 0 && encoded[7] == 0xFF);
CHECK(IEC60870_IntegratedTotals_Get_From_Buffer(&decoded, 0, encoded + 3, 5) == IEC60870_ASDU_OK);
CHECK(decoded.value.value == values[i] && decoded.value.sequence_number == 31);
CHECK(decoded.value.has_carry == 1 && decoded.value.is_adjusted == 1 && decoded.value.is_invalid == 1);
}
}
return 1;
}
/**
* 功能:遍历非法应用层参数和空参数,并验证可配置头宽度、容量不足及篡改容器的拒绝路径。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:输出指针、长度哨兵和原缓冲用于检查失败原子性。
*/
static int test_parameters_and_nulls(void)
{
static const IEC60870_AppLayerParameters_t invalid[] = {
{0,1,2,0,2,3,249}, {2,1,2,0,2,3,249}, {1,0,2,0,2,3,249},
{1,2,2,0,2,3,249}, {1,1,0,0,2,3,249}, {1,1,3,0,2,3,249},
{1,1,2,0,0,3,249}, {1,1,2,0,3,3,249}, {1,1,2,0,2,0,249},
{1,1,2,0,2,4,249}, {1,1,2,-1,2,3,249}, {1,1,2,256,2,3,249},
{1,1,2,0,2,3,5}, {1,1,2,0,2,3,255}, {1,1,2,0,2,3,INT_MAX},
{1,1,INT_MIN,0,2,3,249}, {1,1,2,0,INT_MAX,3,249}, {1,1,2,0,2,-1,249}
};
IEC60870_Asdu_t asdu, second, saved;
IEC60870_AsduInfo_t info;
IEC60870_AsduHeader_t header = Header();
IEC60870_SinglePointInformation_t point;
IEC60870_AppLayerParameters_t p = {1,1,1,0,1,1,249};
uint8_t frame[32], other[32], before[32];
const uint8_t request[] = {1,1,3,0,1,0,1,0,0,1};
const uint8_t *data = frame;
uint16_t length = 77;
size_t i;
CHECK(IEC60870_SinglePointInformation_Create(&point, 0, 1, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_AppLayerParameters_Valid(&parameters104));
for (i = 0; i <= COUNT(invalid); ++i) {
const IEC60870_AppLayerParameters_t *bad = i == COUNT(invalid) ? NULL : &invalid[i];
CHECK(!IEC60870_AppLayerParameters_Valid(bad));
memset(frame, 0xA5, sizeof(frame)); memcpy(before, frame, sizeof(frame));
memset(&asdu, 0xA5, sizeof(asdu)); memcpy(&saved, &asdu, sizeof(asdu));
CHECK(IEC60870_Asdu_Create(&asdu, bad, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&saved, &asdu, sizeof(asdu)) == 0);
CHECK(Reject_Frame(bad, request, sizeof(request), IEC60870_ASDU_ERROR));
CHECK(IEC60870_InformationObject_Encode(&point.object, bad, 0, frame, sizeof(frame), &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Build_Response(bad, request, sizeof(request), 7, 0, frame, sizeof(frame), &length) == IEC60870_ASDU_ERROR);
CHECK(length == 77 && memcmp(before, frame, sizeof(frame)) == 0);
}
header.common_address = 256;
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_ERROR);
CHECK(memcmp(&saved, &asdu, sizeof(asdu)) == 0 && memcmp(before, frame, sizeof(frame)) == 0);
header.common_address = 255;
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, 3, &header, 0) == IEC60870_ASDU_FULL);
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_OK);
CHECK(frame[3] == 255 && frame[4] == 0xA5);
CHECK(IEC60870_Asdu_Create(NULL, &p, frame, sizeof(frame), &header, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Create(&asdu, &p, NULL, sizeof(frame), &header, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Create(&asdu, &p, frame, sizeof(frame), NULL, 0) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Add_InformationObject(NULL, &point.object) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, NULL) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Get_Data(NULL, &data, &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Parse(&p, NULL, 8, &info) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Parse(&parameters104, request, sizeof(request), NULL) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Get_Element(NULL, 0, &point, sizeof(point)) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Parse(&parameters104, request, sizeof(request), &info) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Element(&info, 0, NULL, sizeof(point)) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_InformationObject_Get_Type(NULL) == 0);
CHECK(IEC60870_InformationObject_Encode(NULL, &p, 0, frame, sizeof(frame), &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_InformationObject_Encode(&point.object, &p, 2, frame, sizeof(frame), &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_InformationObject_Encode(&point.object, &p, 0, NULL, sizeof(frame), &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_InformationObject_Encode(&point.object, &p, 0, frame, sizeof(frame), NULL) == IEC60870_ASDU_ERROR);
CHECK(length == 77 && data == frame);
point.object.ioa = 256;
CHECK(IEC60870_InformationObject_Encode(&point.object, &p, 0, frame, sizeof(frame), &length) == IEC60870_ASDU_ERROR);
point.object.ioa = 0;
CHECK(IEC60870_Asdu_Create(&asdu, &parameters104, frame, sizeof(frame), &header, 1) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Create(&second, &p, other, sizeof(other), &header, 0) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&second, &point.object) == IEC60870_ASDU_OK);
++point.object.ioa;
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
point.object.ioa = 5;
CHECK(IEC60870_Asdu_Add_InformationObject(&second, &point.object) == IEC60870_ASDU_OK);
CHECK(asdu.length == 11 && second.length == 8 && frame[1] == 0x82 && other[1] == 2);
CHECK(IEC60870_Asdu_Get_Data(&asdu, NULL, &length) == IEC60870_ASDU_ERROR && length == 77);
CHECK(IEC60870_Asdu_Get_Data(&asdu, &data, NULL) == IEC60870_ASDU_ERROR && data == frame);
/* 容器/视图被篡改时,布局检查拒绝,不越界读载荷。 */
++asdu.length;
CHECK(IEC60870_Asdu_Get_Data(&asdu, &data, &length) == IEC60870_ASDU_ERROR);
info.parameters = NULL;
CHECK(IEC60870_Asdu_Get_Element(&info, 0, &point, sizeof(point)) == IEC60870_ASDU_ERROR);
return 1;
}
/* ============================================================================
* [ASDU/RESPONSE] 应答容器用例:原文回显及CA修改
* ============================================================================ */
/**
* 功能:遍历字段宽度、传送原因与 P/N 位,核对应答镜像和公共地址修改的完整字节及失败边界。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int test_responses(void)
{
static const int causes[] = {7,9,10,44,45,46,47,
IEC60870_ASDU_COT_COMMAND_INTERLOCK_ERROR, IEC60870_ASDU_COT_COMMAND_TIME_ERROR};
IEC60870_AppLayerParameters_t p = parameters104;
size_t v, ci;
int pn;
for (p.sizeOfCOT = 1; p.sizeOfCOT <= 2; ++p.sizeOfCOT) {
for (p.sizeOfCA = 1; p.sizeOfCA <= 2; ++p.sizeOfCA) {
for (p.sizeOfIOA = 1; p.sizeOfIOA <= 3; ++p.sizeOfIOA) {
for (v = 0; v < COUNT(vectors); ++v) {
uint8_t frame[32], reply[32], expected[32];
uint16_t n = Wire_Header(&p, vectors[v].type, 1, 0x86, frame), length;
int b;
for (b = 0; b < p.sizeOfIOA; ++b) { frame[n++] = (uint8_t)(0x56 - b); }
memcpy(frame + n, vectors[v].payload, vectors[v].size); n += vectors[v].size;
for (ci = 0; ci < COUNT(causes); ++ci) {
for (pn = 0; pn <= 1; ++pn) {
memcpy(expected, frame, n); expected[2] = (uint8_t)(0x80 | (pn << 6) | causes[ci]);
CHECK(IEC60870_Asdu_Build_Response(&p, frame, n, causes[ci], pn, reply, sizeof(reply), &length) == IEC60870_ASDU_OK);
CHECK(length == n && memcmp(expected, reply, n) == 0);
}
}
}
}
}
}
{
uint8_t frame[40], saved[40];
static const uint8_t unknown[] = {250,0,0x83,0x67};
static const int invalid_causes[] = {-1,0,6,8,11,43,50,63,64,256};
const IEC60870_AppLayerParameters_t short_p = {1,1,1,0,1,1,249};
IEC60870_AsduInfo_t info;
IEC60870_ReadCommand_t read;
uint16_t length = 77;
memcpy(frame, unknown, sizeof(unknown));
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 4, 44, 1, frame + 1, 39, &length) == IEC60870_ASDU_OK);
CHECK(length == 4 && frame[1] == 250 && frame[3] == 0xEC && frame[4] == 0x67);
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame + 1, 4, 47, 0, frame, 40, &length) == IEC60870_ASDU_OK);
CHECK(frame[0] == 250 && frame[2] == 0xAF && frame[3] == 0x67);
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 4, 10, 0, frame, 40, &length) == IEC60870_ASDU_OK && frame[2] == 0x8A);
memcpy(saved, frame, sizeof(frame)); length = 77;
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 4, 7, 0, frame, 3, &length) == IEC60870_ASDU_FULL);
for (ci = 0; ci < COUNT(invalid_causes); ++ci) {
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 4, invalid_causes[ci], 1,
frame, 40, &length) == IEC60870_ASDU_ERROR);
CHECK(length == 77 && memcmp(saved, frame, sizeof(frame)) == 0);
}
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 4, 7, 2, frame, 40, &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 3, 7, 0, frame, 40, &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Build_Response(&short_p, NULL, 4, 7, 0, frame, 40, &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 4, 7, 0, NULL, 40, &length) == IEC60870_ASDU_ERROR);
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 4, 7, 0, frame, 40, NULL) == IEC60870_ASDU_ERROR);
CHECK(length == 77 && memcmp(saved, frame, sizeof(frame)) == 0);
memcpy(frame, unknown, sizeof(unknown)); frame[0] = 102; frame[1] = 1; frame[4] = 0x56;
CHECK(IEC60870_Asdu_Parse(&short_p, frame, 5, &info) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Get_Element(&info, 0, &read, sizeof(read)) == IEC60870_ASDU_OK && read.object.ioa == 0x56);
CHECK(IEC60870_Asdu_Build_Response(&short_p, frame, 5, 7, 0, frame, 40, &length) == IEC60870_ASDU_OK && length == 5);
}
return 1;
}
/**
* 功能:验证以下场景与约束:CA宽度、COT决定的偏移、借用/构造对象及失败原子性使用独立字节期望。
* 输入参数:无。
* 输出参数:无。
* 返回值:非零表示本次操作或检查通过;0 表示失败。
* 说明:检查不满足时由 CHECK 立即返回失败,不继续后续断言。
*/
static int test_set_ca(void)
{
static const uint16_t addresses[] = {0, 1, 255, 256, 0x1234, UINT16_MAX};
IEC60870_AppLayerParameters_t p = parameters104;
unsigned form;
size_t i;
CHECK(IEC60870_Asdu_Set_CA(NULL, 1) == IEC60870_ASDU_ERROR);
for (p.sizeOfCOT = 1; p.sizeOfCOT <= 2; ++p.sizeOfCOT) {
for (p.sizeOfCA = 1; p.sizeOfCA <= 2; ++p.sizeOfCA) {
for (form = 0; form < 3; ++form) {
IEC60870_Asdu_t asdu, saved;
IEC60870_AsduHeader_t header = {6, 1, 1, 0x78, 0x34};
IEC60870_SinglePointInformation_t point;
uint8_t bytes[32], expected[32];
unsigned offset = 2U + (unsigned)p.sizeOfCOT;
memset(bytes, 0xa5, sizeof(bytes));
CHECK(IEC60870_Asdu_Create(&asdu, &p, bytes, sizeof(bytes), &header, 0) == IEC60870_ASDU_OK);
if (form != 0) {
CHECK(IEC60870_SinglePointInformation_Create(&point, 0x1234, 1, 0x80) == IEC60870_ASDU_OK);
CHECK(IEC60870_Asdu_Add_InformationObject(&asdu, &point.object) == IEC60870_ASDU_OK);
}
if (form == 2) {
CHECK(IEC60870_Asdu_Create_From_Buffer(&asdu, &p, bytes, asdu.length) == IEC60870_ASDU_OK);
}
saved = asdu;
for (i = 0; i < COUNT(addresses); ++i) {
memcpy(expected, bytes, sizeof(bytes));
if (p.sizeOfCA == 1 && addresses[i] > 255) {
CHECK(IEC60870_Asdu_Set_CA(&asdu, addresses[i]) == IEC60870_ASDU_ERROR);
} else {
expected[offset] = (uint8_t)addresses[i];
if (p.sizeOfCA == 2) { expected[offset + 1U] = (uint8_t)(addresses[i] >> 8); }
CHECK(IEC60870_Asdu_Set_CA(&asdu, addresses[i]) == IEC60870_ASDU_OK);
}
CHECK(memcmp(bytes, expected, sizeof(bytes)) == 0 && memcmp(&asdu, &saved, sizeof(asdu)) == 0);
}
memcpy(expected, bytes, sizeof(bytes));
asdu.parameters = NULL;
CHECK(IEC60870_Asdu_Set_CA(&asdu, 1) == IEC60870_ASDU_ERROR); asdu = saved;
asdu.length = (uint16_t)(offset + (unsigned)p.sizeOfCA - 1U);
CHECK(IEC60870_Asdu_Set_CA(&asdu, 1) == IEC60870_ASDU_ERROR); asdu = saved;
asdu.buffer = NULL;
CHECK(IEC60870_Asdu_Set_CA(&asdu, 1) == IEC60870_ASDU_ERROR); asdu = saved;
asdu.type_id ^= 1U;
CHECK(IEC60870_Asdu_Set_CA(&asdu, 1) == IEC60870_ASDU_ERROR); asdu = saved;
{
int width = p.sizeOfCA;
p.sizeOfCA = 3;
CHECK(IEC60870_Asdu_Set_CA(&asdu, 1) == IEC60870_ASDU_ERROR);
p.sizeOfCA = width;
}
CHECK(memcmp(bytes, expected, sizeof(bytes)) == 0);
}
}
}
return 1;
}
/* ============================================================================
* [ENTRY/MAIN] 测试入口:按主题登记公共ASDU用例
* ============================================================================ */
/**
* 功能:测试入口:按主题登记公共ASDU用例
* 输入参数:无。
* 输出参数:无。
* 返回值:正常完成返回 0;参数、运行或断言失败以非零状态结束进程。
* 说明:本辅助入口用于构造或核对上述测试场景,相关状态保存在当前测试夹具中。
*/
int main(void)
{
int passed = 0;
#define RUN(test) do { if (!(test)()) { return 1; } ++passed; } while (0)
/* [RUN/LAYOUT] 报文布局与对象API */
RUN(test_wire_matrix);
RUN(test_object_entrypoints);
/* [RUN/VALIDATION] 容量、非法值与失败原子性 */
RUN(test_capacity_and_addresses);
RUN(test_malformed_payloads);
RUN(test_cp56_reception);
RUN(test_constructor_failures);
RUN(test_add_atomicity);
/* [RUN/NUMERIC] 数值位模式和参数 */
RUN(test_numeric_bits);
RUN(test_parameters_and_nulls);
/* [RUN/RESPONSE] 应答回显与公共地址修改 */
RUN(test_responses);
RUN(test_set_ca);
#undef RUN
printf("ASDU: %d groups passed (30 concrete types, 504 wire layouts, 12 parameter configurations)\n", passed);
return 0;
}