commit 7ec0389a8af03e638a874d6d75ed5056fa38891f Author: cheney Date: Fri Jul 10 17:53:18 2026 +0800 init diff --git a/.vscode/launch.json b/.vscode/launch.json new file mode 100644 index 0000000..6d546c9 --- /dev/null +++ b/.vscode/launch.json @@ -0,0 +1,36 @@ +{ + // 使用 IntelliSense 了解相关属性。 + // 悬停以查看现有属性的描述。 + // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387 + "version": "0.2.0", + "configurations": [ + { + "name": "gcc - 生成和调试活动文件", + "type": "cppdbg", + "request": "launch", + //"program": "${fileDirname}/${fileBasenameNoExtension}", + "program": "/mnt/hgfs/D/work/信雅达科技有限公司/2025年/5、金交所存储加密改造/密码设备应用软件_C接口程序_黄金交易所版(存储加密)_bld_1.18/lib/demo", + "args": [], + "stopAtEntry": false, + //"cwd": "${fileDirname}", + "cwd": "/mnt/hgfs/D/work/信雅达科技有限公司/2025年/5、金交所存储加密改造/密码设备应用软件_C接口程序_黄金交易所版(存储加密)_bld_1.18/lib", + "environment": [], + "externalConsole": false, + "MIMode": "gdb", + "setupCommands": [ + { + "description": "为 gdb 启用整齐打印", + "text": "-enable-pretty-printing", + "ignoreFailures": true + }, + { + "description": "将反汇编风格设置为 Intel", + "text": "-gdb-set disassembly-flavor intel", + "ignoreFailures": true + } + ], + "preLaunchTask": "C/C++: gcc 生成活动文件", + "miDebuggerPath": "/usr/bin/gdb" + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..7d32025 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,10 @@ +{ + "files.associations": { + "threadpool.h": "c", + "typedef.h": "c", + "log.h": "c", + "in.h": "c", + "sunyard_d.h": "c", + "sunyard.h": "c" + } +} \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 0000000..f294200 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,48 @@ +{ + "tasks": [ + { + "type": "cppbuild", + "label": "C/C++: gcc build active file", + "command": "/usr/bin/gcc", + "args": [ + "-fdiagnostics-color=always", + "-g", + "${file}", + "-o", + "${fileDirname}/${fileBasenameNoExtension}" + ], + "options": { + "cwd": "${fileDirname}" + }, + "problemMatcher": [ + "$gcc" + ], + "group": "build", + "detail": "Task generated by Debugger." + }, + { + "type": "cppbuild", + "label": "C/C++: gcc 生成活动文件", + "command": "/usr/bin/gcc", + "args": [ + "-fdiagnostics-color=always", + "-g", + "${file}", + "-o", + "${fileDirname}/${fileBasenameNoExtension}" + ], + "options": { + "cwd": "${fileDirname}" + }, + "problemMatcher": [ + "$gcc" + ], + "group": { + "kind": "build", + "isDefault": true + }, + "detail": "调试器生成的任务。" + } + ], + "version": "2.0.0" +} \ No newline at end of file diff --git a/demo/Makefile b/demo/Makefile new file mode 100644 index 0000000..fa7f8a3 --- /dev/null +++ b/demo/Makefile @@ -0,0 +1,54 @@ +# SlickEdit generated file. Do not edit this file except in designated areas. + +# Make command to use for dependencies +MAKE=make +RM=rm +MKDIR=mkdir + +# -----Begin user-editable area----- + +# -----End user-editable area----- + +# If no configuration is specified, "Debug" will be used +ifndef CFG +CFG=Debug +endif + +# +# Configuration: Debug +# +ifeq "$(CFG)" "Debug" +OUTDIR=Debug +OUTFILE=../lib/demo +CFG_INC=-I../inc +CFG_LIB=-lsunyard -lpthread +CFG_OBJ= +COMMON_OBJ=$(OUTDIR)/demo.o $(OUTDIR)/demo_api.o +OBJ=$(COMMON_OBJ) $(CFG_OBJ) +ALL_OBJ=$(OUTDIR)/demo.o $(OUTDIR)/demo_api.o +COMPILE=gcc -c -g -o "$(OUTDIR)/$(*F).o" $(CFG_INC) $< +LINK=gcc -g -L ../lib -o "$(OUTFILE)" $(ALL_OBJ) $(CFG_LIB) -Wl,-rpath=../lib +# Pattern rules +$(OUTDIR)/%.o : %.c + $(COMPILE) + +# Build rules +all: $(OUTFILE) + +$(OUTFILE): $(OUTDIR) $(OBJ) + $(LINK) + +$(OUTDIR): + $(MKDIR) -p "$(OUTDIR)" + +# Rebuild this project +rebuild: cleanall all + +# Clean this project +clean: + $(RM) -f $(OUTFILE) + $(RM) -f $(OBJ) + +# Clean this project and all dependencies +cleanall: clean +endif diff --git a/demo/demo.c b/demo/demo.c new file mode 100644 index 0000000..593d76b --- /dev/null +++ b/demo/demo.c @@ -0,0 +1,579 @@ +#ifndef _DEMO_API_H_ +#include "demo_api.h" +#endif + +#include +#include +#include + +#include "demo_xn.c" + +static pthread_mutex_t g_mutex; +static float g_allflow[300] = {0}; +static unsigned long g_threadnum = 0; + +typedef struct { + int datalen; + int cmd; +}XN_INFO; + +int connect_test() +{ + int ret = 0, i = 0; + void *hHandle = NULL; + const char *iplist[5] = {0}; + int port[5] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + iplist[1] = DEV_IP; + port[1] = DEV_PORT; + for(i = 0; i < 10; i++) + { + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 0, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return -1; + } + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return -1; + } + LOG("短连接正常测试|线程数:0|单个连接|成功"); + } + + for(i = 0; i < 10; i++) + { + ret = SYD_Connect_Ex(iplist, port, 2, CON_TIMEOUT, DEAL_TIMEOUT, 0, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return -1; + } + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return -1; + } + LOG("短连接正常测试|线程数:0|2个连接|成功"); + } + + for(i = 0; i < 10; i++) + { + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 5, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return -1; + } + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return -1; + } + LOG("短连接正常测试|线程数:5|单个连接|成功"); + } + + for(i = 0; i < 10; i++) + { + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 5, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return -1; + } + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return -1; + } + LOG("短连接正常测试|线程数:5|2个连接|成功"); + } + return 0; +} + +int CMD(void *hHandle, int cmd) +{ + int ret = 0; + switch(cmd) + { + case 0: + ret = SM4_ShortData_Test(hHandle); + break; + case 1: + ret = SM4_BatchData_Test(hHandle); + break; + case 2: + ret = SM4_LongData_Test_Special(hHandle); + if(ret != 0) + { + return ret; + } + ret = SM4_LongData_Test(hHandle); + if(ret != 0) + { + return ret; + } + break; + case 3: + ret = SM3_ShortHash_Test(hHandle); + break; + case 4: + ret = SM3_LongHash_Test_Special(hHandle); + if(ret != 0) + { + return ret; + } + ret = SM3_LongHash_Test(hHandle); + if(ret != 0) + { + return ret; + } + break; + case 5: + ret = SM4Mac_ShortData(hHandle); + break; + case 6: + ret = SM4Mac_BatchData(hHandle); + break; + case 7: + ret = SM4Mac_LongData_Special(hHandle); + if(ret != 0) + { + return ret; + } + + ret = SM4Mac_LongData(hHandle); + if(ret != 0) + { + return ret; + } + break; + case 8: + ret = SM4_ShortData_CheckValue(hHandle); + break; + case 9: + ret = SM4_BatchData_CheckValue(hHandle); + break; + case 10: + ret = SM4_LongData_CheckValue(hHandle); + break; + default: + LOG("cmd not exit"); + ret = 1; + } + return ret; +} + +void short_connect_test() +{ + int ret = 0, cmd = 0, i = 0; + void *hHandle = NULL; + const char *iplist[2] = {0}; + int port[2] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + iplist[1] = DEV2_IP; + port[1] = DEV2_PORT; + for(i = 0; i < 10; i++) + { + ret = SYD_Connect_Ex(iplist, port, 2, CON_TIMEOUT, DEAL_TIMEOUT, 0, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return; + } + + for(cmd = 0; cmd <= 9; cmd++) + { + ret = CMD(hHandle, cmd); + if(ret != 0) goto END; + } + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return; + } + LOG("遍历所有指令|总循环次数:10|已执行次数:%d|成功", i+1); + } +END: + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return; + } +} + +void threadpool_connect_test() +{ + int ret = 0, i = 0, cmd = 0; + void *hHandle = NULL; + const char *iplist[2] = {0}; + int port[2] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + iplist[1] = DEV2_IP; + port[1] = DEV2_PORT; + + for(i = 0; i < 10; i++) + { + ret = SYD_Connect_Ex(iplist, port, 2, CON_TIMEOUT, DEAL_TIMEOUT, 5, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return; + } + + for(cmd = 0; cmd <= 9; cmd++) + { + ret = CMD(hHandle, cmd); + if(ret != 0) goto END; + } + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return; + } + LOG("遍历所有指令|总循环次数:10|已执行次数:%d|成功", i+1); + } +END: + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return; + } +} + +void choose_cmd_test() +{ + int ret = 0, i = 0; + int cmd = 0; + void *hHandle = NULL; + const char *iplist[2] = {0}; + int port[2] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + iplist[1] = DEV2_IP; + port[1] = DEV2_PORT; + + while (1) + { + LOG_MSG("/----功能正确性测试-----/"); + LOG_MSG("0:SM4短数据"); + LOG_MSG("1:SM4批量数据"); + LOG_MSG("2:SM4长数据"); + LOG_MSG("3:SM3短数据"); + LOG_MSG("4:SM3长数据"); + LOG_MSG("5:SM4-MAC短数据"); + LOG_MSG("6:SM4-MAC批量数据"); + LOG_MSG("7:SM4-MAC长数据"); + LOG_MSG("8:SM4短数据+密文校验"); + LOG_MSG("9:SM4批量数据+密文校验"); + LOG_MSG("10:SM4长数据+密文校验"); + LOG_MSG("100:退出"); + LOG_MSG("请选择测试指令:"); + scanf("%d", &cmd); + if(cmd == 100) return; + + ret = SYD_Connect_Ex(iplist, port, 2, CON_TIMEOUT, DEAL_TIMEOUT, 0, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return; + } + + ret = CMD(hHandle, cmd); + if(ret == 1) goto END; + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return; + } + } +END: + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return; + } +} + +void* CMD_XN(void *p) +{ + XN_INFO* arg = (XN_INFO *)p; + int ret = 0; + float flow = 0; + long difftime = 0; + struct timeval start_time; + struct timeval local_time; + const char *iplist[5] = {0}; + int port[5] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + void *hHandle = NULL; + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, 1000, 0, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return NULL; + } + + gettimeofday(&start_time, NULL); + switch(arg->cmd) + { + case 0: + ret = XN_SM4_Enc_LongData_Test(hHandle, arg->datalen); + break; + case 1: + ret = XN_SM4_Dec_LongData_Test(hHandle, arg->datalen); + break; + case 2: + ret = XN_SM4Mac_LongData_Test(hHandle, arg->datalen); + break; + case 3: + ret = XN_SM3_LongHash_Test(hHandle, arg->datalen); + break; + case 4: + ret = XN_SM4EncMac_LongData_Test(hHandle, arg->datalen); + break; + case 5: + ret = XN_SM4DecMac_LongData_Test(hHandle, arg->datalen); + break; + default: + LOG("cmd not exist"); + return NULL; + } + gettimeofday(&local_time, NULL); + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return NULL; + } + + pthread_mutex_lock(&g_mutex); + difftime = us_difftime(start_time, local_time); + flow = (arg->datalen / (difftime * 0.000001)) / (1024 * 1024); + g_allflow[g_threadnum] = flow; + LOG_MSG("线程:%ld|用时%ld(us)|数据长度:%d(bytes)|吞吐量:%f(MB/S)", g_threadnum, difftime, arg->datalen, flow); + g_threadnum++; + pthread_mutex_unlock(&g_mutex); + return NULL; +} + +void xn_throughput_test() +{ + int ret = 0, i = 0, cmd = 0; + long alldatalen = 0; + int run_conut = 0; + float all_flow = 0; + long thread_count = 0; + pthread_t pthid[1000]; + XN_INFO arg = {0}; + pthread_mutex_init(&g_mutex, NULL); + + while (1) + { + LOG_MSG("/------吞吐量测试------/"); + LOG_MSG("0:SM4加密长数据"); + LOG_MSG("1:SM4解密长数据"); + LOG_MSG("2:SM4-MAC长数据"); + LOG_MSG("3:SM3长数据"); + LOG_MSG("4:SM4加密+MAC长数据"); + LOG_MSG("5:SM4解密+MAC长数据"); + LOG_MSG("100:退出"); + LOG_MSG("请选择测试指令:"); + scanf("%d", &cmd); + if(cmd == 100) goto END; + LOG_MSG("请输出数据的总长度(MB):"); + scanf("%ld", &alldatalen); + alldatalen = alldatalen * 1024 * 1024; + LOG_MSG("请输入线程数:"); + scanf("%ld", &thread_count); + g_threadnum = 0; + memset(g_allflow, 0, sizeof(g_allflow)); + arg.cmd = cmd; + arg.datalen = alldatalen / thread_count; + for(i = 0; i < thread_count; i++) + { + ret = pthread_create(&pthid[i], NULL, CMD_XN, (void *)&arg); + if(ret) + { + printf("Fail to create thread %d\n", (int)pthid[i]); + goto END; + } + } + + for (i = 0; i < thread_count; i++) + { + ret = pthread_join(pthid[i],NULL); + if(ret) + { + printf("Thread %d join failed\n", (int)pthid[i]); + goto END; + } + } + + all_flow = 0; + for (i = 0; i < thread_count; i++) + { + all_flow += g_allflow[i]; + } + LOG_MSG("命令:%d|线程数:%ld|总吞吐量:%f(MB/S)", arg.cmd, thread_count, all_flow); + } +END: + pthread_mutex_destroy(&g_mutex); +} + +int stability_test() +{ + int ret = 0, cmd = 0; + long long i = 0, count = 0; + void *hHandle = NULL; + const char *iplist[2] = {0}; + int port[5] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, 5000, 0, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return 0; + } + + LOG_MSG("请输入循环次数:"); + scanf("%lld", &count); + for(i = 0; i < count; i++) + { + for(cmd = 0; cmd <= 10; cmd++) + { + ret = CMD(hHandle, cmd); + if(ret != 0) + { + LOG("命令:%d|当前循环次数:%lld|错误!", cmd, i); + goto END; + } + } + } + +END: + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return 0; + } +} + +int main() +{ + int ret = 0, mode = 0; + void *hHandle = NULL; + char version[256] = {0}; + int version_len = sizeof(version); + const char *iplist[5] = {0}; + int port[5] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + ret = SYD_SetLogConfig("./Log", 6, 2); + if(ret != 0) + { + LOG("SYD_SetLogConfig ret=%08x", ret); + return 0; + } + + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 0, &hHandle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return 0; + } + + ret = SYD_GetVersionInfo(hHandle, version, &version_len); + if(ret != 0) + { + LOG("SYD_GetVersionInfo ret=%08x", ret); + return 0; + } + printf("%s\n", version); + + ret = SYD_DisConnect_Ex(hHandle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return 0; + } + + /* + *注意：该测试需要提前手动合成密钥，密钥合成方式如下 + *机构号16字节0 类型:ZEK(00A) 索引:8字节0 方案:X 不变种 分量个数:2 + *这里用的密钥分量为 + 分量1:31313131313131313131313131313131 + 分量2:32323232323232323232323232323232 + 合成后的分量:03030303030303030303030303030303 + */ + + while (1) + { + LOG_MSG("/---功能测试---/"); + LOG_MSG("0:连接正确性测试"); + LOG_MSG("1:金交所业务场景1:循环多次(短连接-遍历所有功能-断开连接)"); + LOG_MSG("2:金交所业务场景2:循环多次(连接池-遍历所有功能-断开连接)"); + LOG_MSG("3:功能正确性测试"); + LOG_MSG("4:吞吐量测试"); + LOG_MSG("5:TPS性能测试"); + LOG_MSG("6:稳定性测试"); + LOG_MSG("100:退出"); + LOG_MSG("请选择测试类型:"); + scanf("%d", &mode); + switch (mode) + { + case 0: + connect_test(); + break; + case 1: + short_connect_test(); + break; + case 2: + threadpool_connect_test(); + break; + case 3: + choose_cmd_test(); + break; + case 4: + xn_throughput_test(); + break; + case 5: + xn_cmd_tps(); + break; + case 6: + stability_test(); + break; + case 100: + return 0; + default: + LOG("mode not exist!"); + break; + } + } + return 0; +} \ No newline at end of file diff --git a/demo/demo_api.c b/demo/demo_api.c new file mode 100644 index 0000000..89e62b4 --- /dev/null +++ b/demo/demo_api.c @@ -0,0 +1,1449 @@ +#ifndef _DEMO_API_H_ +#include "demo_api.h" +#endif + +#define SM4_BATCH_NUM 4 +#define SM4_MAC_BATCH_NUM 4 + +static const char g_cHexToAsc1[] = "0123456789ABCDEF"; + +static int g_iTable_ASC_HEX[] = +{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f +}; + /*乱序*/ +void IniOrgData(char *pcData, int iOrgDataLen, int k) +{ + int i = 0; + for (i = 0; i < iOrgDataLen; i++, k++) + { + memset(pcData + i, k, 1); + if (k == 9) + { + k = 0; + } + } +} + +void PrintHex(const char* Title, unsigned char* Data, int DataLen) +{ + int i; + printf("[%s][len=%d]:", Title, DataLen); + for (i = 0; i < DataLen; i++) + { + if (!(i % 16)) printf("\n "); + printf(" %02X", Data[i]); + } + printf("\n"); +} + +void HexToBin(int iLen, unsigned char* pucInBuf, unsigned char* pucOutBuf) +{ + for (; iLen > 0; iLen -= 2, pucInBuf += 2) + { + (*pucOutBuf++) = (g_iTable_ASC_HEX[(*pucInBuf)] << 4) | g_iTable_ASC_HEX[*(pucInBuf + 1)]; + } +} + +void BinToHex(int iLen, unsigned char* pucInBuf, unsigned char* pucOutBuf) +{ + for (; iLen > 0; iLen--) + { + (*pucOutBuf++) = g_cHexToAsc1[((*pucInBuf) >> 4) & 0xf]; + (*pucOutBuf++) = g_cHexToAsc1[(*pucInBuf++) & 0xf]; + } +} + +//精确到微秒 +int us_difftime(struct timeval start_time, struct timeval end_time) +{ + long start = start_time.tv_sec * 1000000 + start_time.tv_usec; + long end = end_time.tv_sec * 1000000 + end_time.tv_usec; + return end - start; +} + +//精确到微秒 +int ms_difftime(struct timeval start_time, struct timeval end_time) +{ + long start = start_time.tv_sec * 1000 + start_time.tv_usec * 0.001; + long end = end_time.tv_sec * 1000 + end_time.tv_usec * 0.001; + return end - start; +} + +int SM4_ShortData_Test(void *hHandle) +{ + int iRet = 0, i = 0; + char cEncData[4096 + 16] = {0}; + int iEncDataLen = 0; + char cDecData[4096 + 16] = {0}; + int iDecDataLen = 0; + char cOrgData[4096] = { 0 }; + IniOrgData(cOrgData, 2048, 1); + + for(i = 1; i <= 1024; i++) + { + iEncDataLen = i + 16; + iRet = SYD_SM4_ShortData(hHandle, KEYINDEX, cOrgData, i, SM4_ENCRYPT, cEncData, &iEncDataLen); + if(iRet != 0) + { + LOG("SYD_SM4_ShortData ret=%08x, i=%d", iRet, i); + return iRet; + } + + iDecDataLen = i; + iRet = SYD_SM4_ShortData(hHandle, KEYINDEX, cEncData, iEncDataLen, SM4_DECRYPT, cDecData, &iDecDataLen); + if(iRet != 0) + { + LOG("SYD_SM4_ShortData ret=%08x, i=%d", iRet, i); + return iRet; + } + + if(iDecDataLen != i) + { + LOG("iDecDataLen(%d) != (%d)", iDecDataLen, i); + return -1; + } + + if(memcmp(cDecData, cOrgData, i)) + { + LOG("memcmp err i=%d", i); + return -1; + } + printf("i=%d\r", i); + fflush(stdout); + } + return 0; +} + +int SM4_BatchData_Test(void *hHandle) +{ + int ret = 0, i = 0, j = 0, k = 0, iBatchNum = 0; + int iKeyIdex[SM4_BATCH_NUM] = {0}; + char cEncData[SM4_BATCH_NUM][2048 + 16] = {{0}}; + int iEncDataLen[SM4_BATCH_NUM] = {0}; + char cDecData[SM4_BATCH_NUM][4096 + 16] = {{0}}; + int iDecDataLen[SM4_BATCH_NUM] = {0}; + char cOrgData[SM4_BATCH_NUM][2048] = {{0}}; + int iOrgDataLen[SM4_BATCH_NUM] = {0}; + char *pTmpOrgData[SM4_BATCH_NUM] = {0}; + int iTmpOrgDataLen[SM4_BATCH_NUM] = {0}; + char *pTmpEncData[SM4_BATCH_NUM] = {0}; + char *pTmpDecData[SM4_BATCH_NUM] = {0}; + + for(i = 0; i < SM4_BATCH_NUM; i++) + { + IniOrgData(cOrgData[i], 2048, i); + iKeyIdex[i] = KEYINDEX; + pTmpOrgData[i] = cOrgData[i]; + pTmpEncData[i] = cEncData[i]; + pTmpDecData[i] = cDecData[i]; + } + + for(i = 1; i <= 1024; i++) + { + for(j = 0; j < SM4_BATCH_NUM; j++) + { + iTmpOrgDataLen[j] = i; + iEncDataLen[j] = i + 16; + iDecDataLen[j] = i; + } + + /* 特殊测试 pcData为NULL测试 */ + ret = SYD_SM4_BatchData(hHandle, iKeyIdex, NULL, iTmpOrgDataLen, SM4_BATCH_NUM, SM4_ENCRYPT, pTmpEncData, iEncDataLen); + if(ret != 0) + { + LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + /* 特殊测试 iSize为0测试 */ + ret = SYD_SM4_BatchData(hHandle, iKeyIdex, pTmpOrgData, iTmpOrgDataLen, 0, SM4_ENCRYPT, pTmpEncData, iEncDataLen); + if(ret != 0) + { + LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + ret = SYD_SM4_BatchData(hHandle, iKeyIdex, pTmpOrgData, iTmpOrgDataLen, SM4_BATCH_NUM, SM4_ENCRYPT, pTmpEncData, iEncDataLen); + if(ret != 0) + { + LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + ret = SYD_SM4_BatchData(hHandle, iKeyIdex, pTmpEncData, iEncDataLen, SM4_BATCH_NUM, SM4_DECRYPT, pTmpDecData, iDecDataLen); + if(ret != 0) + { + LOG("SYD_SM4_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + for(j = 0; j < SM4_BATCH_NUM; j++) + { + if(iDecDataLen[j] != i) + { + LOG("iDecDataLen[%d](%d) != (%d)", j, iDecDataLen[j], i); + return -1; + } + + if(memcmp(pTmpDecData[j], pTmpOrgData[j], i)) + { + LOG("memcmp err i=%d, j=%d", i, j); + return -1; + } + } + printf("i=%d\r", i); + fflush(stdout); + } + return 0; +} + +int SM4_LongData_Test_Special(void *hHandle) +{ + int ret = 0; + char bEncData[9000] = { 0 }; + int ulEncDataLen = 9000; + char bDecData[9000] = { 0 }; + int ulDecDataLen = 0; + int ulDecDataLen1 = 0; + void *hEncProchandle = NULL; + void *hDecProchandle = NULL; + /*1、0长度数据测试*/ + ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_ENCRYPT, &hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataInit, ret=%08x", ret); + return ret; + } + + ret = SYD_SM4_LongDataFinal(hHandle, bEncData, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataFinal ret=%08x", ret); + goto END; + } + + ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_DECRYPT, &hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataInit, ret=%08x", ret); + goto END; + } + + ret = SYD_SM4_LongDataUpdate(hHandle, bEncData, ulEncDataLen, bDecData, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataUpdate, ret=%08x", ret); + goto END; + } + + ret = SYD_SM4_LongDataFinal(hHandle, bDecData, &ulDecDataLen1, hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataFinal ret=%08x", ret); + goto END; + } + + if(ulDecDataLen != 0) + { + LOG("ulDecDataLen != 0"); + goto END; + } +END: + SYD_CloseHandle(hEncProchandle); + SYD_CloseHandle(hDecProchandle); + return 0; +} + +int SM4_LongData_Test(void *hHandle) +{ + int ret = 0; + int k = 0, iEncDecNum = 10240, iSymSingleBytes = 0; + int ulDataLen = 0; + char bEncData[10240 + 16] = { 0 }; + int ulEncDataLen = 0; + char* pbEncTemp = NULL; + int ulTempEncLen = 0; + char bDecData[10240] = { 0 }; + int ulDecDataLen = 0; + char* pbDecTemp = NULL; + int ulTempDecLen = 0; + void *hEncProchandle = NULL; + void *hDecProchandle = NULL; + + char cOrgData[10240] = {0}; + IniOrgData(cOrgData, 10240, 1); + + for (iSymSingleBytes = 1; iSymSingleBytes <= 6144; iSymSingleBytes++) + { + /*加密*/ + ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_ENCRYPT, &hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataInit, ret=%08x", ret); + goto END; + } + + pbEncTemp = bEncData; + for (k = 0; k < iEncDecNum / iSymSingleBytes; k++) + { + ulEncDataLen = 10240; + ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData + (k * iSymSingleBytes), iSymSingleBytes, pbEncTemp, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + ulTempEncLen += ulEncDataLen; + pbEncTemp += ulEncDataLen; + } + + if (iEncDecNum % iSymSingleBytes != 0) + { + ulEncDataLen = 10240; + ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData + (iEncDecNum - (iEncDecNum % iSymSingleBytes)), iEncDecNum % iSymSingleBytes, pbEncTemp, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataUpdate ret=%08x", ret); + goto END; + } + ulTempEncLen += ulEncDataLen; + pbEncTemp += ulEncDataLen; + } + + ulEncDataLen = 10240; + ret = SYD_SM4_LongDataFinal(hHandle, pbEncTemp, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataFinal ret=%08x", ret); + goto END; + } + ulTempEncLen += ulEncDataLen; + + /*解密*/ + ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_DECRYPT, &hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataInit, ulRet=%08x", ret); + goto END; + } + + pbDecTemp = bDecData; + for (k = 0; k < ulTempEncLen / iSymSingleBytes; k++) + { + ulDecDataLen = 10240; + ret = SYD_SM4_LongDataUpdate(hHandle, bEncData + (k * iSymSingleBytes), iSymSingleBytes, pbDecTemp, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + ulTempDecLen += ulDecDataLen; + pbDecTemp += ulDecDataLen; + } + + if (ulTempEncLen % iSymSingleBytes != 0) + { + ulDecDataLen = 10240; + ret = SYD_SM4_LongDataUpdate(hHandle, bEncData + (ulTempEncLen - (ulTempEncLen % iSymSingleBytes)), ulTempEncLen % iSymSingleBytes, pbDecTemp, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SKF_DecryptUpdate k=%d, ret=%08x", k, ret); + goto END; + } + ulTempDecLen += ulDecDataLen; + pbDecTemp += ulDecDataLen; + } + + ulDecDataLen = 10240; + ret = SYD_SM4_LongDataFinal(hHandle, pbDecTemp, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SKF_DecryptFinal ret=%08x", ret); + goto END; + } + ulTempDecLen += ulDecDataLen; + + SYD_CloseHandle(hEncProchandle); + SYD_CloseHandle(hDecProchandle); + + if (ulTempDecLen != iEncDecNum) + { + LOG("iSymSingleBytes=%d, ulTempDecLen=%d", iSymSingleBytes, ulTempDecLen); + return 0; + } + + if (memcmp(cOrgData, bDecData, ulTempDecLen)) + { + LOG("memcmp iSymSingleBytes=%d, ulTempDecLen=%d", iSymSingleBytes, ulTempDecLen); + return 0; + } + memset(bEncData, 0, sizeof(bEncData)); + memset(bDecData, 0, sizeof(bDecData)); + ulTempEncLen = 0; + ulTempDecLen = 0; + printf("count: %d\r", iSymSingleBytes); + fflush(stdout); + } +END: + if(ret != 0) + { + SYD_CloseHandle(hEncProchandle); + SYD_CloseHandle(hDecProchandle); + } + return 0; +} + +int SM3_ShortHash_Test(void *hHandle) +{ + int ret = 0; + char cOrgData[2048] = {0}; + int iOrgDataLen = 0; + char cHash[33] = {0}; + IniOrgData(cOrgData, 2048, 1); + for(iOrgDataLen = 0; iOrgDataLen <= 1024; iOrgDataLen++) + { + ret = SYD_SM3_Hash_ShortData(hHandle, cOrgData, iOrgDataLen, cHash); + if(ret != 0) + { + LOG("SYD_SM3_Hash_ShortData ret=%08x", ret); + return 0; + } + printf("iOrgDataLen=%d\r", iOrgDataLen); + fflush(stdout); + } + return 0; +} + +int SM3_LongHash_Test_Special(void *hHandle) +{ + int ret = 0; + void* hHash = NULL; + char cOrgData[256] = {0}; + char cHash[33] = {0}; + ret = SYD_SM3_Hash_Init(&hHash); + if (ret != 0) + { + LOG("SYD_SM3_Hash_Init ret=%08x", ret); + return ret; + } + + ret = SYD_SM3_Hash_Final(hHandle, cHash, hHash); + if (ret != 0) + { + LOG("SYD_SM3_Hash_Final ret=%08x", ret); + goto END; + } + PrintHex("cHash", cHash, 32); + SYD_CloseHandle(hHash); + + ret = SYD_SM3_Hash_Init(&hHash); + if (ret != 0) + { + LOG("SYD_SM3_Hash_Init ret=%08x", ret); + return ret; + } + + ret = SYD_SM3_Hash_Update(hHandle, cOrgData, 0, hHash); + if (ret != 0) + { + LOG("SYD_SM3_Hash_Update ret=%08x", ret); + return ret; + } + + ret = SYD_SM3_Hash_Final(hHandle, cHash, hHash); + if (ret != 0) + { + LOG("SYD_SM3_Hash_Final ret=%08x", ret); + goto END; + } + PrintHex("cHash", cHash, 32); + SYD_CloseHandle(hHash); +END: + if(ret != 0) + { + SYD_CloseHandle(hHash); + } + return 0; +} + +int SM3_LongHash_Test(void *hHandle) +{ + int ulRet = 0, i = 0, num = 0; + void* hHash = NULL; + char bHash[32] = { 0 }, bTmpHash[32] = { 0 }; + int ulHashLen = 0, ulTmpHashLen = 0; + int ulHashBytes = 0, ulMultBytes = 0; + char cOrgData[9000] = {0}; + IniOrgData(cOrgData, 9000, 1); + for (ulHashBytes = 1; ulHashBytes <= 64; ulHashBytes++) + { + for (ulMultBytes = 1; ulMultBytes < ulHashBytes + 1; ulMultBytes++) + { + /*带公钥的HASH*/ + ulRet = SYD_SM3_Hash_Init(&hHash); + if (ulRet != 0) + { + LOG("SYD_SM3_Hash_Init ulRet=%08x", ulRet); + return ulRet; + } + + for (i = 0; i < ulHashBytes / ulMultBytes; i++) + { + ulRet = SYD_SM3_Hash_Update(hHandle, cOrgData + (i * ulMultBytes), ulMultBytes, hHash); + if (ulRet != 0) + { + LOG("SYD_SM3_Hash_Update ulRet=%08x", ulRet); + goto END; + } + } + + if (ulHashBytes % ulMultBytes != 0) + { + ulRet = SYD_SM3_Hash_Update(hHandle, cOrgData + (ulHashBytes - (ulHashBytes % ulMultBytes)), ulHashBytes % ulMultBytes, hHash); + if (ulRet != 0) + { + LOG("SYD_SM3_Hash_Update ulRet=%08x", ulRet); + goto END; + } + } + + ulRet = SYD_SM3_Hash_Final(hHandle, bHash, hHash); + if (ulRet != 0) + { + LOG("SYD_SM3_Hash_Final ulRet=%08x", ulRet); + goto END; + } + SYD_CloseHandle(hHash); + + ulRet = SYD_SM3_Hash_ShortData(hHandle, cOrgData, ulHashBytes, bTmpHash); + if(ulRet != 0) + { + LOG("SYD_SM3_Hash_ShortData ulRet=%08x", ulRet); + return 0; + } + + if (memcmp(bTmpHash, bHash, 32)) + { + LOG("memcmp err"); + return 0; + } + } + printf("ulHashBytes=%d\r", ulHashBytes); + fflush(stdout); + } + +END: + if (ulRet != 0) + { + SYD_CloseHandle(hHash); + } + return 0; +} + +int SM4Mac_ShortData(void *hHandle) +{ + int ret = 0; + char cOrgData[2048] = {0}; + int iOrgDataLen = 0; + char cMac[33] = {0}; + IniOrgData(cOrgData, 2048, 1); + + /*1、未校验MAC*/ + for(iOrgDataLen = 0; iOrgDataLen <= 1024; iOrgDataLen++) + { + ret = SYD_SM4Mac_ShortData(hHandle, KEYINDEX, cOrgData, iOrgDataLen, cMac, NULL); + if(ret != 0) + { + LOG("SYD_SM4Mac_ShortData ret=%08x", ret); + return 0; + } + printf("iOrgDataLen=%d\r", iOrgDataLen); + fflush(stdout); + } + + /*2、校验MAC*/ + int iCheckRet = -1; + /* + *注意：手算校验值时不要忘记填充值也是原始数据的一部分 + *这里用的密钥分量为 + 分量1:31313131313131313131313131313131 + 分量2:32323232323232323232323232323232 + 合成后的分量:03030303030303030303030303030303 + */ + + char cCheckMac[] = "A3B596312F67832C4F8B74F8E68FD394"; + HexToBin(32, cCheckMac, cMac); + ret = SYD_SM4Mac_ShortData(hHandle, KEYINDEX, cOrgData, 32, cMac, &iCheckRet); + if(ret != 0) + { + LOG("SYD_SM4Mac_ShortData ret=%08x", ret); + return 0; + } + + if(iCheckRet != 0) + { + LOG("mac check err iCheckRet=%08x\n", iCheckRet); + } + return 0; +} + +int SM4Mac_BatchData(void *hHandle) +{ + int ret = 0, i = 0, j = 0; + int iKeyIdex[SM4_MAC_BATCH_NUM] = {0}; + int iCheckRet[SM4_MAC_BATCH_NUM] = {0}; + char cOrgData[SM4_MAC_BATCH_NUM][2048] = {{0}}; + int iOrgDataLen[SM4_MAC_BATCH_NUM] = {0}; + char cMac[SM4_MAC_BATCH_NUM][33] = {{0}}; + char *pTmpMac[SM4_MAC_BATCH_NUM] = {0}; + char *pTmpOrgData[SM4_MAC_BATCH_NUM] = {0}; + + for(i = 0; i < SM4_MAC_BATCH_NUM; i++) + { + IniOrgData(cOrgData[i], 2048, i); + iKeyIdex[i] = KEYINDEX; + pTmpOrgData[i] = cOrgData[i]; + pTmpMac[i] = cMac[i]; + } + + /*不校验MAC*/ + for(i = 1; i <= 1024; i++) + { + for(j = 0; j < SM4_MAC_BATCH_NUM; j++) + { + iOrgDataLen[j] = i; + } + + /* 特殊测试 pcData为NULL*/ + ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, NULL, iOrgDataLen, SM4_MAC_BATCH_NUM, pTmpMac, NULL); + if(ret != 0) + { + LOG("SYD_SM4Mac_BatchData ret=%08x", ret); + return 0; + } + + /* 特殊测试 iSize为0 */ + ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, pTmpOrgData, iOrgDataLen, 0, pTmpMac, NULL); + if(ret != 0) + { + LOG("SYD_SM4Mac_BatchData ret=%08x", ret); + return 0; + } + + ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, pTmpOrgData, iOrgDataLen, SM4_MAC_BATCH_NUM, pTmpMac, NULL); + if(ret != 0) + { + LOG("SYD_SM4Mac_BatchData ret=%08x", ret); + return 0; + } + printf("i=%d\r", i); + fflush(stdout); + } + + /*校验MAC*/ + char cCheckMac[10][33] = {0}; + char cCheckMac_Bin[10][17] = {0}; + strcpy(cCheckMac[0], "4A590763CFD67F045BE26A7570D8FDB1"); + strcpy(cCheckMac[1], "7CEDAE1E836889962F8C06C0501613F8"); + strcpy(cCheckMac[2], "60F34B352AB359A3109C3C7A343BA881"); + strcpy(cCheckMac[3], "2A6600B4397FA5331F7310DBECE475EE"); + + for(j = 0; j < SM4_MAC_BATCH_NUM; j++) + { + iOrgDataLen[j] = 1; + HexToBin(32, cCheckMac[j], cCheckMac_Bin[j]); + pTmpMac[j] = cCheckMac_Bin[j]; + } + + memset(iCheckRet, '1', sizeof(iCheckRet)); + ret = SYD_SM4Mac_BatchData(hHandle, iKeyIdex, pTmpOrgData, iOrgDataLen, SM4_MAC_BATCH_NUM, pTmpMac, iCheckRet); + if(ret != 0) + { + LOG("SYD_SM4Mac_BatchData ret=%08x", ret); + return 0; + } + + for(j = 0; j < SM4_MAC_BATCH_NUM; j++) + { + if(iCheckRet[j] != 0) + { + LOG("mac check err iCheckRet[%d]=%08x\n", j, iCheckRet[j]); + } + } + return 0; +} + +int SM4Mac_LongData_Special(void *hHandle) +{ + int ret = 0; + char cData[16] = {0}; + char cMac[64] = {0}; + void *hMacProchandle = NULL; + ret = SYD_SM4Mac_LongDataInit(KEYINDEX, &hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataInit, ret=%08x", ret); + goto END; + } + + ret = SYD_SM4Mac_LongDataUpdate(hHandle, cData, 0, hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataUpdate, ret=%08x", ret); + goto END; + } + + ret = SYD_SM4Mac_LongDataFinal(hHandle, cMac, NULL, hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataFinal ret=%08x", ret); + goto END; + } + SYD_CloseHandle(hMacProchandle); + PrintHex("cMac", cMac, 64); +END: + if(ret != 0) + { + SYD_CloseHandle(hMacProchandle); + } + return 0; +} + +int SM4Mac_LongData(void *hHandle) +{ + int ret = 0; + int k = 0, iEncDecNum = 10240, iSymSingleBytes = 0; + char cCheckMac[64] = {0}; + char cMac[64] = {0}; + void *hMacProchandle = NULL; + char cOrgData[10240] = {0}; + IniOrgData(cOrgData, 10240, 1); + char mac_hex[] = "9222B9CDFBCF1F75469A118762F415C9"; + char mac_bin[32] = {0}; + HexToBin(32, mac_hex, mac_bin); + for (iSymSingleBytes = 1; iSymSingleBytes <= 6144; iSymSingleBytes++) + { + ret = SYD_SM4Mac_LongDataInit(KEYINDEX, &hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataInit, ret=%08x", ret); + goto END; + } + + for (k = 0; k < iEncDecNum / iSymSingleBytes; k++) + { + ret = SYD_SM4Mac_LongDataUpdate(hHandle, cOrgData + (k * iSymSingleBytes), iSymSingleBytes, hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + } + + if (iEncDecNum % iSymSingleBytes != 0) + { + ret = SYD_SM4Mac_LongDataUpdate(hHandle, cOrgData + (iEncDecNum - (iEncDecNum % iSymSingleBytes)), iEncDecNum % iSymSingleBytes, hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataUpdate ret=%08x", ret); + goto END; + } + } + + ret = SYD_SM4Mac_LongDataFinal(hHandle, cMac, NULL, hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataFinal ret=%08x", ret); + goto END; + } + SYD_CloseHandle(hMacProchandle); + + if(memcmp(cMac, mac_bin, 16)) + { + LOG("memcmp err iSymSingleBytes=%d", iSymSingleBytes); + PrintHex("mac_bin", mac_bin, 32); + PrintHex("cMac", cMac, 32); + goto END; + } + printf("count: %d\r", iSymSingleBytes); + fflush(stdout); + } +END: + if(ret != 0) + { + SYD_CloseHandle(hMacProchandle); + } + return 0; +} + +int SM4_ShortData_CheckValue(void *hHandle) +{ + int ret = 0, i = 0; + char cMac[33] = {0}; + char cOrgData[2048] = { 0 }; + IniOrgData(cOrgData, 2048, 1); + char cEncryptData[2048] = {0}; + int iEncryptDataLen = 0; + char cCheckValue[17] = {0}; + char cDecryptData[2048] = {0}; + int iDecryptDataLen = 0; + char cErrMac[] = "1234567812345678"; + + for(i = 1; i <= 1024; i++) + { + iEncryptDataLen = i + 16; + ret = SYD_SM4_Encrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, cOrgData, i, \ + cEncryptData, &iEncryptDataLen, cCheckValue); + if (ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret); + return ret; + } + + iDecryptDataLen = sizeof(cDecryptData); + ret = SYD_SM4_Decrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, \ + cEncryptData, iEncryptDataLen, cCheckValue, cDecryptData, &iDecryptDataLen); + if (ret != 0) + { + LOG("SYD_SM4_Decrypt_Mac_ShortData ret=%08x", ret); + return ret; + } + + if(iDecryptDataLen != i) + { + LOG("iDecryptDataLen(%d) != (%d)", iDecryptDataLen, i); + return -1; + } + + if(memcmp(cDecryptData, cOrgData, iDecryptDataLen)) + { + LOG("memcmp err i=%d", i); + return -1; + } + + /* 错误场景,输入错误的MAC值 */ + iDecryptDataLen = sizeof(cDecryptData); + ret = SYD_SM4_Decrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, \ + cEncryptData, iEncryptDataLen, cErrMac, cDecryptData, &iDecryptDataLen); + if (ret != 0x01000010) + { + LOG("SYD_SM4_Decrypt_Mac_ShortData ret=%08x", ret); + return ret; + } + printf("iOrgDataLen=%d\r", i); + fflush(stdout); + } + return 0; +} + +int SM4_BatchData_CheckValue(void *hHandle) +{ + int ret = 0, i = 0, j = 0; + int iEncKeyIdex[SM4_BATCH_NUM] = {0}; + int iCheckKeyIdex[SM4_BATCH_NUM] = {0}; + char cOrgData[SM4_BATCH_NUM][2048] = {{0}}; + int iOrgDataLen[SM4_BATCH_NUM] = {0}; + char cEncData[SM4_BATCH_NUM][1024 + 16] = {{0}}; + int iEncDataLen[SM4_BATCH_NUM] = {0}; + char cDecData[SM4_BATCH_NUM][1024] = {{0}}; + int iDecDataLen[SM4_BATCH_NUM] = {0}; + char cCheckValue[SM4_BATCH_NUM][17] = {0}; + char *pTmpOrgData[SM4_BATCH_NUM] = {0}; + char *pTmpEncData[SM4_BATCH_NUM] = {0}; + char *pTmpDecData[SM4_BATCH_NUM] = {0}; + char *pTmpCheckValue[SM4_BATCH_NUM] = {0}; + char cErrMac[SM4_BATCH_NUM][17] = {0}; + char *pTmpErrMac[SM4_BATCH_NUM] = {0}; + int iCheckRet[SM4_MAC_BATCH_NUM] = {0}; + + for(i = 0; i < SM4_BATCH_NUM; i++) + { + IniOrgData(cOrgData[i], 2048, i); + iEncKeyIdex[i] = KEYINDEX; + iCheckKeyIdex[i] = CHECKINDEX; + pTmpOrgData[i] = cOrgData[i]; + pTmpEncData[i] = cEncData[i]; + pTmpDecData[i] = cDecData[i]; + pTmpCheckValue[i] = cCheckValue[i]; + memcpy(cErrMac[i], "1234567812345678", 16); + pTmpErrMac[i] = cErrMac[i]; + } + + for(i = 1; i <= 1024; i++) + { + for(j = 0; j < SM4_BATCH_NUM; j++) + { + iOrgDataLen[j] = i; + iEncDataLen[j] = i + 16; + iDecDataLen[j] = i; + iCheckRet[j] = 1; + } + + /* 特殊测试pcData为NULL */ + ret = SYD_SM4_Encrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, NULL, iOrgDataLen, \ + SM4_BATCH_NUM, pTmpEncData, iEncDataLen, pTmpCheckValue); + if(ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + /* 特殊测试iSize为0 */ + ret = SYD_SM4_Encrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpOrgData, iOrgDataLen, \ + 0, pTmpEncData, iEncDataLen, pTmpCheckValue); + if(ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + ret = SYD_SM4_Encrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpOrgData, iOrgDataLen, \ + SM4_BATCH_NUM, pTmpEncData, iEncDataLen, pTmpCheckValue); + if(ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + /* 特殊测试pcData为NULL */ + ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, NULL, iEncDataLen, \ + pTmpCheckValue, SM4_BATCH_NUM, pTmpDecData, iDecDataLen, iCheckRet); + if(ret != 0) + { + LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + /* 特殊测试iSize为0 */ + ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpEncData, iEncDataLen, \ + pTmpCheckValue, 0, pTmpDecData, iDecDataLen, iCheckRet); + if(ret != 0) + { + LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpEncData, iEncDataLen, \ + pTmpCheckValue, SM4_BATCH_NUM, pTmpDecData, iDecDataLen, iCheckRet); + if(ret != 0) + { + LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x, i=%d", ret, i); + return ret; + } + + for(j = 0; j < SM4_BATCH_NUM; j++) + { + if(iCheckRet[j] != 0) + { + LOG("mac check err iCheckRet[%d]=%08x\n", j, iCheckRet[j]); + } + + if(iDecDataLen[j] != i) + { + LOG("iDecDataLen[%d](%d) != (%d)", j, iDecDataLen[j], i); + return -1; + } + + if(memcmp(pTmpDecData[j], pTmpOrgData[j], i)) + { + LOG("memcmp err i=%d, j=%d", i, j); + return -1; + } + } + + /* 错误场景,输入错误的MAC值 */ + + for(j = 0; j < SM4_BATCH_NUM; j++) + { + iDecDataLen[j] = 0; + } + + ret = SYD_SM4_Decrypt_Mac_BatchData(hHandle, iEncKeyIdex, iCheckKeyIdex, pTmpEncData, iEncDataLen, \ + pTmpErrMac, SM4_BATCH_NUM, pTmpDecData, iDecDataLen, iCheckRet); + if(ret != 0) + { + LOG("SYD_SM4_Decrypt_Mac_BatchData ret=%08x", ret); + return ret; + } + + for(j = 0; j < SM4_MAC_BATCH_NUM; j++) + { + if(iDecDataLen[j] != 0) + { + LOG("decdatalen err\n"); + } + + if(iCheckRet[j] != 0x01000010) + { + LOG("mac check err iCheckRet[%d]=%08x\n", j, iCheckRet[j]); + } + } + printf("i=%d\r", i); + fflush(stdout); + } + return 0; +} + +int XN_SM4_Enc_LongData_Test(void *hHandle, int datasize) +{ + if(datasize < 1024 || datasize % 16 != 0) + { + LOG("datasize er"); + return -1; + } + int ret = 0, k = 0; + int singlebytes = 6144; + char bEncData[8192] = { 0 }; + int ulEncDataLen = 0; + void *hEncProchandle = NULL; + char cOrgData[8192] = {0}; + IniOrgData(cOrgData, 8192, 1); + + /*加密*/ + ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_ENCRYPT, &hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataInit, ret=%08x", ret); + goto END; + } + + for (k = 0; k < datasize / singlebytes; k++) + { + ulEncDataLen = 9000; + ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData, singlebytes, bEncData, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + } + + ulEncDataLen = 9000; + ret = SYD_SM4_LongDataFinal(hHandle, bEncData, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataFinal ret=%08x", ret); + goto END; + } + SYD_CloseHandle(hEncProchandle); +END: + if(ret != 0) + { + SYD_CloseHandle(hEncProchandle); + } + return 0; +} + +int XN_SM4_Dec_LongData_Test(void *hHandle, int datasize) +{ + if(datasize < 1024 || datasize % 16 != 0) + { + LOG("datasize er"); + return -1; + } + int ret = 0, k = 0; + int singlebytes = 6144; + char bDecData[8192] = { 0 }; + int ulDecDataLen = 0; + void *hDecProchandle = NULL; + char cOrgData[8192] = {0}; + IniOrgData(cOrgData, 8192, 1); + + /*解密-这里使用随机数据作为密文，而且final不判断返回值， 这里只做吞吐量的验证，不做正确性的验证*/ + ret = SYD_SM4_LongDataInit(KEYINDEX, SM4_DECRYPT, &hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataInit, ret=%08x", ret); + goto END; + } + + for (k = 0; k < datasize / singlebytes; k++) + { + ulDecDataLen = 9000; + ret = SYD_SM4_LongDataUpdate(hHandle, cOrgData, singlebytes, bDecData, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + } + ulDecDataLen = 9000; + SYD_SM4_LongDataFinal(hHandle, bDecData, &ulDecDataLen, hDecProchandle); + SYD_CloseHandle(hDecProchandle); +END: + if(ret != 0) + { + SYD_CloseHandle(hDecProchandle); + } + return 0; +} + +int XN_SM4Mac_LongData_Test(void *hHandle, int datasize) +{ + if(datasize < 1024 || datasize % 16 != 0) + { + LOG("datasize err"); + return -1; + } + int ret = 0, k = 0; + int singlebytes = 6144; + char cMac[64] = {0}; + void *hMacProchandle = NULL; + char cOrgData[9000] = {0}; + IniOrgData(cOrgData, 9000, 1); + + ret = SYD_SM4Mac_LongDataInit(KEYINDEX, &hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataInit, ret=%08x", ret); + goto END; + } + + for (k = 0; k < datasize / singlebytes; k++) + { + ret = SYD_SM4Mac_LongDataUpdate(hHandle, cOrgData, singlebytes, hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + } + + ret = SYD_SM4Mac_LongDataFinal(hHandle, cMac, NULL, hMacProchandle); + if (ret != 0) + { + LOG("SYD_SM4Mac_LongDataFinal ret=%08x", ret); + goto END; + } + SYD_CloseHandle(hMacProchandle); +END: + if(ret != 0) + { + SYD_CloseHandle(hMacProchandle); + } + return 0; +} + +int XN_SM3_LongHash_Test(void *hHandle, int datasize) +{ + if(datasize < 1024 || datasize % 16 != 0) + { + LOG("datasize err"); + return -1; + } + int ulRet = 0, i = 0; + int singlebytes = 6144; + void* hHash = NULL; + char bHash[32] = { 0 }; + char cOrgData[9000] = {0}; + IniOrgData(cOrgData, 9000, 1); + + /*带公钥的HASH*/ + ulRet = SYD_SM3_Hash_Init(&hHash); + if (ulRet != 0) + { + LOG("SYD_SM3_Hash_Init ulRet=%08x", ulRet); + return ulRet; + } + + for (i = 0; i < datasize / singlebytes; i++) + { + ulRet = SYD_SM3_Hash_Update(hHandle, cOrgData, singlebytes, hHash); + if (ulRet != 0) + { + LOG("SYD_SM3_Hash_Update ulRet=%08x", ulRet); + goto END; + } + } + + ulRet = SYD_SM3_Hash_Final(hHandle, bHash, hHash); + if (ulRet != 0) + { + LOG("SYD_SM3_Hash_Final ulRet=%08x", ulRet); + goto END; + } + SYD_CloseHandle(hHash); + +END: + if (ulRet != 0) + { + SYD_CloseHandle(hHash); + } + return 0; +} + +int XN_SM4EncMac_LongData_Test(void *hHandle, int datasize) +{ + if(datasize < 1024 || datasize % 16 != 0) + { + LOG("datasize er"); + return -1; + } + int ret = 0, k = 0; + int singlebytes = 6144; + char bEncData[8192] = { 0 }; + int ulEncDataLen = 0; + char cMac[64] = {0}; + void *hEncProchandle = NULL; + char cOrgData[8192] = {0}; + IniOrgData(cOrgData, 8192, 1); + + /*加密*/ + ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_ENCRYPT, &hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret); + goto END; + } + + for (k = 0; k < datasize / singlebytes; k++) + { + ulEncDataLen = 8192; + ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData, singlebytes, bEncData, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + } + + ulEncDataLen = 8192; + ret = SYD_SM4EncDecMac_LongDataFinal(hHandle, bEncData, &ulEncDataLen, cMac, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataFinal ret=%08x", ret); + goto END; + } + SYD_CloseHandle(hEncProchandle); +END: + if(ret != 0) + { + SYD_CloseHandle(hEncProchandle); + } + return 0; +} + +int XN_SM4DecMac_LongData_Test(void *hHandle, int datasize) +{ + if(datasize < 1024 || datasize % 16 != 0) + { + LOG("datasize er"); + return -1; + } + int ret = 0, k = 0; + int singlebytes = 6144; + char bDecData[8192] = { 0 }; + int ulDecDataLen = 0; + char cMac[64] = {0}; + void *hDecProchandle = NULL; + char cOrgData[8192] = {0}; + IniOrgData(cOrgData, 8192, 1); + + /*解密-这里使用随机数据作为密文，而且final不判断返回值， 这里只做吞吐量的验证，不做正确性的验证*/ + ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_DECRYPT, &hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret); + goto END; + } + + for (k = 0; k < datasize / singlebytes; k++) + { + ulDecDataLen = 8192; + ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData, singlebytes, bDecData, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + } + ulDecDataLen = 8192; + SYD_SM4EncDecMac_LongDataFinal(hHandle, bDecData, &ulDecDataLen, cMac, hDecProchandle); + SYD_CloseHandle(hDecProchandle); +END: + if(ret != 0) + { + SYD_CloseHandle(hDecProchandle); + } + return 0; +} + +int SM4_LongData_CheckValue(void *hHandle) +{ + int ret = 0; + int k = 0, iEncDecNum = 1024, iSingleBytes = 0; + char bEncData[10240 + 16] = { 0 }; + int ulEncDataLen = 0; + char* pbEncTemp = NULL; + int ulTempEncLen = 0; + char bDecData[10240] = { 0 }; + int ulDecDataLen = 0; + char* pbDecTemp = NULL; + int ulTempDecLen = 0; + void *hEncProchandle = NULL; + void *hDecProchandle = NULL; + char cOrgData[10240] = {0}; + char cMac[64] = {0}; + IniOrgData(cOrgData, 10240, 1); + + char cShortEncData[2048] = {0}; + int iShortEncDataLen = 0; + char cShortDecData[2048] = {0}; + int iShortDecDataLen = 0; + char cShortMac[64] = {0}; + + for (iSingleBytes = 1; iSingleBytes <= 6144; iSingleBytes++) + { + /* 长数据加密并mac */ + ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_ENCRYPT, &hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret); + goto END; + } + + pbEncTemp = bEncData; + for (k = 0; k < iEncDecNum / iSingleBytes; k++) + { + ulEncDataLen = 10240; + ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData + (k * iSingleBytes), iSingleBytes, \ + pbEncTemp, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + ulTempEncLen += ulEncDataLen; pbEncTemp += ulEncDataLen; + } + + if (iEncDecNum % iSingleBytes != 0) + { + ulEncDataLen = 10240; + ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, cOrgData + (iEncDecNum - (iEncDecNum % iSingleBytes)), \ + iEncDecNum % iSingleBytes, pbEncTemp, &ulEncDataLen, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataUpdate ret=%08x", ret); + goto END; + } + ulTempEncLen += ulEncDataLen; pbEncTemp += ulEncDataLen; + } + + ulEncDataLen = 10240; + ret = SYD_SM4EncDecMac_LongDataFinal(hHandle, pbEncTemp, &ulEncDataLen, cMac, hEncProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataFinal ret=%08x", ret); + goto END; + } + ulTempEncLen += ulEncDataLen; +#if 1 + /* 使用短数据加密并校验MAC接口来对比密文和MAC值是否一致 */ + iShortEncDataLen = sizeof(cShortEncData); + ret = SYD_SM4_Encrypt_Mac_ShortData(hHandle, KEYINDEX, CHECKINDEX, cOrgData, iEncDecNum, \ + cShortEncData, &iShortEncDataLen, cShortMac); + if (ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret); + return ret; + } + + if(iShortEncDataLen != ulTempEncLen) + { + LOG("iShortEncDataLen(%d) != ulTempEncLen(%d)", iShortEncDataLen, ulTempEncLen); + return 0; + } + + if(memcmp(cShortEncData, bEncData, ulTempEncLen)) + { + LOG("memcmp cShortEncData != bEncData"); + return 0; + } + + if(memcmp(cShortMac, cMac, 16)) + { + LOG("memcmp cShortMac != cMac"); + return 0; + } +#endif + /* 长数据解密并校验mac */ + ret = SYD_SM4EncDecMac_LongDataInit(KEYINDEX, CHECKINDEX, SM4_DECRYPT, &hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataInit, ret=%08x", ret); + goto END; + } + + pbDecTemp = bDecData; + for (k = 0; k < ulTempEncLen / iSingleBytes; k++) + { + ulDecDataLen = 10240; + ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, bEncData + (k * iSingleBytes), iSingleBytes, \ + pbDecTemp, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SYD_SM4EncDecMac_LongDataUpdate k=%d, ret=%08x", k, ret); + goto END; + } + ulTempDecLen += ulDecDataLen; pbDecTemp += ulDecDataLen; + } + + if (ulTempEncLen % iSingleBytes != 0) + { + ulDecDataLen = 10240; + ret = SYD_SM4EncDecMac_LongDataUpdate(hHandle, bEncData + (ulTempEncLen - (ulTempEncLen % iSingleBytes)), \ + ulTempEncLen % iSingleBytes, pbDecTemp, &ulDecDataLen, hDecProchandle); + if (ret != 0) + { + LOG("SKF_DecryptUpdate k=%d, ret=%08x", k, ret); + goto END; + } + ulTempDecLen += ulDecDataLen; pbDecTemp += ulDecDataLen; + } + + ulDecDataLen = 10240; + ret = SYD_SM4EncDecMac_LongDataFinal(hHandle, pbDecTemp, &ulDecDataLen, cMac, hDecProchandle); + if (ret != 0) + { + LOG("SKF_DecryptFinal ret=%08x", ret); + goto END; + } + ulTempDecLen += ulDecDataLen; + + SYD_CloseHandle(hEncProchandle); + SYD_CloseHandle(hDecProchandle); + + if (ulTempDecLen != iEncDecNum) + { + LOG("iSingleBytes=%d, ulTempDecLen=%d", iSingleBytes, ulTempDecLen); + return 0; + } + + if (memcmp(cOrgData, bDecData, ulTempDecLen)) + { + LOG("memcmp iSingleBytes=%d, ulTempDecLen=%d", iSingleBytes, ulTempDecLen); + return 0; + } + memset(bEncData, 0, sizeof(bEncData)); + memset(bDecData, 0, sizeof(bDecData)); + ulTempEncLen = 0; + ulTempDecLen = 0; + printf("count: %d\r", iSingleBytes); + fflush(stdout); + } + +END: + if(ret != 0) + { + SYD_CloseHandle(hEncProchandle); + SYD_CloseHandle(hDecProchandle); + } + return 0; +} \ No newline at end of file diff --git a/demo/demo_api.h b/demo/demo_api.h new file mode 100644 index 0000000..307498f --- /dev/null +++ b/demo/demo_api.h @@ -0,0 +1,53 @@ +#ifndef _DEMO_API_H_ +#define _DEMO_API_H_ + +#ifndef _DEMO_TYPEDEF_H_ +#include "demo_typedef.h" +#endif + +#ifndef _SUNYARD_H_ +#include "sunyard.h" +#endif + +#define DEV_IP "127.0.0.1" +#define DEV_PORT 8889 + +#define DEV2_IP "127.0.0.1" +#define DEV2_PORT 8889 + +#define CON_TIMEOUT 5000 +#define DEAL_TIMEOUT 5000 +#define KEYINDEX 0 +#define CHECKINDEX 0 + +void IniOrgData(char *pcData, int iOrgDataLen, int k); +void PrintHex(const char* Title, unsigned char* Data, int DataLen); +void HexToBin(int iLen, unsigned char* pucInBuf, unsigned char* pucOutBuf); +void BinToHex(int iLen, unsigned char* pucInBuf, unsigned char* pucOutBuf); +int us_difftime(struct timeval start_time, struct timeval end_time); +int ms_difftime(struct timeval start_time, struct timeval end_time); + +int SM4_ShortData_Test(void *hHandle); +int SM4_BatchData_Test(void *hHandle); +int SM4_LongData_Test(void *hHandle); +int SM4_LongData_Test_Special(void *hHandle); +int SM3_ShortHash_Test(void *hHandle); +int SM3_LongHash_Test(void *hHandle); +int SM3_LongHash_Test_Special(void *hHandle); +int SM4Mac_ShortData(void *hHandle); +int SM4Mac_BatchData(void *hHandle); +int SM4Mac_LongData(void *hHandle); +int SM4Mac_LongData_Special(void *hHandle); +int SM4_ShortData_CheckValue(void *hHandle); +int SM4_BatchData_CheckValue(void *hHandle); +int SM4_LongData_CheckValue(void *hHandle); + +int XN_SM4_Enc_LongData_Test(void *hHandle, int datasize); +int XN_SM4_Dec_LongData_Test(void *hHandle, int datasize); +int XN_SM4Mac_LongData_Test(void *hHandle, int singlebytes); +int XN_SM3_LongHash_Test(void *hHandle, int singlebytes); +int XN_SM4EncMac_LongData_Test(void *hHandle, int datasize); +int XN_SM4DecMac_LongData_Test(void *hHandle, int datasize); + + +#endif \ No newline at end of file diff --git a/demo/demo_typedef.h b/demo/demo_typedef.h new file mode 100644 index 0000000..71390e8 --- /dev/null +++ b/demo/demo_typedef.h @@ -0,0 +1,24 @@ +#ifndef _DEMO_TYPEDEF_H_ +#define _DEMO_TYPEDEF_H_ + +#include +#include +#include +#include +#include +#include + +#define API_DEBUG 1 +#define API_DEBUG_ERR 1 + +#define LOG(format, ...) \ +if (API_DEBUG) \ + printf("[DEBUG|%s@%s,%d] " format "\n", \ + __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__) + +#define LOG_MSG(format, ...) \ +if (API_DEBUG_ERR) \ + printf("[DEBUG|%s@%s,%d] " format "\n", \ + __FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__) + +#endif \ No newline at end of file diff --git a/demo/demo_xn.c b/demo/demo_xn.c new file mode 100644 index 0000000..67a8893 --- /dev/null +++ b/demo/demo_xn.c @@ -0,0 +1,462 @@ + +#define BATCH_MAX_SIZE 4 + +typedef struct +{ + int cycle_num; /*<单线程循环次数>*/ + int cmd; /*<命令码>*/ + int data_len; /*<数据长度>*/ +} trd_arg_t; + +typedef struct +{ + int keyidex[BATCH_MAX_SIZE]; + int checkidex[BATCH_MAX_SIZE]; + char sm4_short_encdata[1024 + 16]; + int sm4_short_encdata_len; + char sm4_short_decdata[1024]; + int sm4_short_decdata_len; + char sm4_short_checkvalue[33]; + int sm4_short_checkvalue_len; + char sm4_batch_encdata[BATCH_MAX_SIZE][1024 + 16]; + int sm4_batch_encdata_len[BATCH_MAX_SIZE]; + char *tmp_sm4_batch_encdata[BATCH_MAX_SIZE]; + char sm4_batch_decdata[BATCH_MAX_SIZE][1024]; + int sm4_batch_decdata_len[BATCH_MAX_SIZE]; + char *tmp_sm4_batch_decdata[BATCH_MAX_SIZE]; + char sm4_batch_checkvalue[BATCH_MAX_SIZE][33]; + int sm4_batch_checkvalue_len[BATCH_MAX_SIZE]; + char *tmp_sm4_batch_checkvalue[BATCH_MAX_SIZE]; + char sm4_batch_mac[BATCH_MAX_SIZE][33]; + int sm4_batch_mac_len[BATCH_MAX_SIZE]; + char *tmp_sm4_batch_mac[BATCH_MAX_SIZE]; + char batch_orgdata[BATCH_MAX_SIZE][2048]; + int batch_orgdata_len[BATCH_MAX_SIZE]; + char *tmp_batch_orgdata[BATCH_MAX_SIZE]; + char hash[33]; + char mac[33]; + int checkret[BATCH_MAX_SIZE]; +} xn_init_config_t; + +xn_init_config_t g_stc_xn_init_config; +static pthread_mutex_t g_time_mutex; +static int g_thread_count = 0; +static long g_all_time[300] = {0}; +static long g_all_average_time[300] = {0}; +static char g_org_data[9000] = {0}; + +long GetTime() +{ + struct timeval t_time; + gettimeofday(&t_time,NULL); + return ((long)t_time.tv_sec) * 1000000 + ((long)t_time.tv_usec); +} + +static int xn_tps_init_data(int data_len) +{ + if(data_len <= 0 || data_len > 1024) + { + LOG("输入数据长度错误, 范围为[1, 1024]"); + return -1; + } + + int ret = 0, i = 0; + int check_ret[BATCH_MAX_SIZE] = {0}; + void *handle = NULL; + const char *iplist[2] = {0}; + int port[2] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 0, &handle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return ret; + } + memset(&g_stc_xn_init_config, 0, sizeof(xn_init_config_t)); + + for(i = 0; i < BATCH_MAX_SIZE; i++) + { + g_stc_xn_init_config.keyidex[i] = KEYINDEX; + g_stc_xn_init_config.checkidex[i] = CHECKINDEX; + g_stc_xn_init_config.sm4_short_encdata_len = sizeof(g_stc_xn_init_config.sm4_short_encdata); + g_stc_xn_init_config.sm4_short_decdata_len = sizeof(g_stc_xn_init_config.sm4_short_decdata); + g_stc_xn_init_config.sm4_short_checkvalue_len = sizeof(g_stc_xn_init_config.sm4_short_checkvalue); + g_stc_xn_init_config.sm4_batch_encdata_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_encdata[i]); + g_stc_xn_init_config.tmp_sm4_batch_encdata[i] = g_stc_xn_init_config.sm4_batch_encdata[i]; + g_stc_xn_init_config.sm4_batch_decdata_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_decdata[i]); + g_stc_xn_init_config.tmp_sm4_batch_decdata[i] = g_stc_xn_init_config.sm4_batch_decdata[i]; + g_stc_xn_init_config.sm4_batch_checkvalue_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_checkvalue[i]); + g_stc_xn_init_config.tmp_sm4_batch_checkvalue[i] = g_stc_xn_init_config.sm4_batch_checkvalue[i]; + g_stc_xn_init_config.sm4_batch_mac_len[i] = sizeof(g_stc_xn_init_config.sm4_batch_mac[i]); + g_stc_xn_init_config.tmp_sm4_batch_mac[i] = g_stc_xn_init_config.sm4_batch_mac[i]; + IniOrgData(g_stc_xn_init_config.batch_orgdata[i], 2048, 1); + g_stc_xn_init_config.batch_orgdata_len[i] = data_len; + g_stc_xn_init_config.tmp_batch_orgdata[i] = g_stc_xn_init_config.batch_orgdata[i]; + } + + ret = SYD_SM4_Encrypt_Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.checkidex[0], \ + g_org_data, data_len, g_stc_xn_init_config.sm4_short_encdata, &g_stc_xn_init_config.sm4_short_encdata_len, \ + g_stc_xn_init_config.sm4_short_checkvalue); + if(ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret); + goto END; + } + g_stc_xn_init_config.sm4_short_checkvalue_len = 16; + + ret = SYD_SM4_Encrypt_Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.checkidex, \ + g_stc_xn_init_config.tmp_batch_orgdata, g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, \ + g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len, \ + g_stc_xn_init_config.tmp_sm4_batch_checkvalue); + if(ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_BatchData ret=%08x", ret); + goto END; + } + g_stc_xn_init_config.sm4_short_checkvalue_len = 16; +END: + SYD_DisConnect_Ex(handle); + return ret; +} + +static int xn_sm4_short_enc(void* handle, unsigned int data_len) +{ + int ret = 0; + unsigned int sm4_short_encdata_len = sizeof(g_stc_xn_init_config.sm4_short_encdata); + ret = SYD_SM4_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_org_data, data_len, \ + SM4_ENCRYPT, g_stc_xn_init_config.sm4_short_encdata, &sm4_short_encdata_len); + if (ret != 0) + { + LOG("SYD_SM4_ShortData err ret=%08x", ret); + return ret; + } + return 0; +} + +static int xn_sm4_short_dec(void* handle, unsigned int data_len) +{ + int ret = 0; + unsigned int sm4_short_decdata_len = sizeof(g_stc_xn_init_config.sm4_short_decdata); + ret = SYD_SM4_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.sm4_short_encdata, \ + g_stc_xn_init_config.sm4_short_encdata_len, SM4_DECRYPT, g_stc_xn_init_config.sm4_short_decdata, \ + &sm4_short_decdata_len); + if (ret != 0) + { + LOG("SYD_SM4_ShortData err ret=%08x", ret); + return ret; + } + return 0; +} + +static int xn_sm4_short_mac(void* handle, unsigned int data_len) +{ + int ret = 0; + ret = SYD_SM4Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_org_data, data_len, \ + g_stc_xn_init_config.mac, NULL); + if(ret != 0) + { + LOG("SYD_SM4Mac_ShortData ret=%08x", ret); + return 0; + } + return 0; +} + +static int xn_sm4_batch_mac(void* handle) +{ + int ret = 0; + ret = SYD_SM4Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.tmp_batch_orgdata, \ + g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, g_stc_xn_init_config.tmp_sm4_batch_mac, NULL); + if(ret != 0) + { + LOG("SYD_SM4Mac_BatchData ret=%08x", ret); + return 0; + } + return 0; +} + +static int xn_sm4_batch_enc(void* handle) +{ + int ret = 0; + ret = SYD_SM4_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.tmp_batch_orgdata, \ + g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, SM4_ENCRYPT, \ + g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len); + if(ret != 0) + { + LOG("SYD_SM4_BatchData ret=%08x", ret); + return ret; + } + return 0; +} + +static int xn_sm4_batch_dec(void* handle) +{ + int ret = 0; + ret = SYD_SM4_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.tmp_sm4_batch_encdata, \ + g_stc_xn_init_config.sm4_batch_encdata_len, BATCH_MAX_SIZE, SM4_DECRYPT, \ + g_stc_xn_init_config.tmp_sm4_batch_decdata, g_stc_xn_init_config.sm4_batch_decdata_len); + if(ret != 0) + { + LOG("SYD_SM4_BatchData ret=%08x", ret); + return ret; + } + return 0; +} + +static int xn_sm3_short_data(void* handle, unsigned int data_len) +{ + int ret = 0; + ret = SYD_SM3_Hash_ShortData(handle, g_org_data, data_len, g_stc_xn_init_config.hash); + if(ret != 0) + { + LOG("SYD_SM3_Hash_ShortData ret=%08x", ret); + return ret; + } + return 0; +} + +static int xn_sm4_enc_short_checkvalue(void* handle, unsigned int data_len) +{ + int ret = 0; + unsigned int sm4_short_encdata_len = sizeof(g_stc_xn_init_config.sm4_short_encdata); + ret = SYD_SM4_Encrypt_Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.checkidex[0], \ + g_org_data, data_len, g_stc_xn_init_config.sm4_short_encdata, &sm4_short_encdata_len, g_stc_xn_init_config.mac); + if(ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_ShortData ret=%08x", ret); + return 0; + } + return 0; +} + +static int xn_sm4_dec_short_checkvalue(void* handle) +{ + int ret = 0; + unsigned int sm4_short_decdata_len = sizeof(g_stc_xn_init_config.sm4_short_decdata); + ret = SYD_SM4_Decrypt_Mac_ShortData(handle, g_stc_xn_init_config.keyidex[0], g_stc_xn_init_config.checkidex[0], \ + g_stc_xn_init_config.sm4_short_encdata, g_stc_xn_init_config.sm4_short_encdata_len, g_stc_xn_init_config.sm4_short_checkvalue, \ + g_stc_xn_init_config.sm4_short_decdata, &sm4_short_decdata_len); + if (ret != 0) + { + LOG("SYD_SM4_Decrypt_Mac_ShortData err ret=%08x", ret); + return ret; + } + return 0; +} + +static int xn_sm4_batch_enc_checkvalue(void* handle) +{ + int ret = 0; + ret = SYD_SM4_Encrypt_Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.checkidex, \ + g_stc_xn_init_config.tmp_batch_orgdata, g_stc_xn_init_config.batch_orgdata_len, BATCH_MAX_SIZE, \ + g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len, \ + g_stc_xn_init_config.tmp_sm4_batch_checkvalue); + if (ret != 0) + { + LOG("SYD_SM4_Encrypt_Mac_BatchData err ret=%08x", ret); + return ret; + } + return 0; +} + +static int xn_sm4_batch_dec_checkvalue(void* handle) +{ + int ret = 0; + ret = SYD_SM4_Decrypt_Mac_BatchData(handle, g_stc_xn_init_config.keyidex, g_stc_xn_init_config.checkidex, \ + g_stc_xn_init_config.tmp_sm4_batch_encdata, g_stc_xn_init_config.sm4_batch_encdata_len, \ + g_stc_xn_init_config.tmp_sm4_batch_checkvalue, BATCH_MAX_SIZE, g_stc_xn_init_config.tmp_sm4_batch_decdata, \ + g_stc_xn_init_config.sm4_batch_decdata_len, g_stc_xn_init_config.checkret); + if (ret != 0) + { + LOG("SYD_SM4_Decrypt_Mac_BatchData err ret=%08x", ret); + return ret; + } + return 0; +} + +static int command_tps(void* handle, int cmd, int data_len) +{ + int ret = 0; + switch(cmd) + { + case 0: + ret = xn_sm4_short_enc(handle, data_len); + break; + case 1: + ret = xn_sm4_short_dec(handle, data_len); + break; + case 2: + ret = xn_sm4_batch_enc(handle); + break; + case 3: + ret = xn_sm4_batch_dec(handle); + break; + case 4: + ret = xn_sm4_short_mac(handle, data_len); + break; + case 5: + ret = xn_sm4_batch_mac(handle); + break; + case 6: + ret = xn_sm3_short_data(handle, data_len); + break; + case 7: + ret = xn_sm4_enc_short_checkvalue(handle, data_len); + break; + case 8: + ret = xn_sm4_dec_short_checkvalue(handle); + break; + case 9: + ret = xn_sm4_batch_enc_checkvalue(handle); + break; + case 10: + ret = xn_sm4_batch_dec_checkvalue(handle); + break; + default: + break; + } + return 0; +} + +void *xn_func_tps(void *arg) +{ + int ret = 0, i = 0; + long begin = 0, end = 0; + trd_arg_t *trd_arg = (trd_arg_t *)arg; + void *conn_handle = NULL; + const char *iplist[5] = {0}; + int port[5] = {0}; + iplist[0] = DEV_IP; + port[0] = DEV_PORT; + ret = SYD_Connect_Ex(iplist, port, 1, CON_TIMEOUT, DEAL_TIMEOUT, 0, &conn_handle); + if(ret != 0) + { + LOG("SYD_Connect_Ex ret=%08x", ret); + return NULL; + } + + begin = GetTime(); + for (i = 0; i < trd_arg->cycle_num; i++) + { + ret = command_tps(conn_handle, trd_arg->cmd, trd_arg->data_len); + if (ret != 0) goto END; + } + end = GetTime() - begin; + LOG_MSG("笔数=%d|总用时:%ld(us)|单笔用时:%ld(us)", trd_arg->cycle_num, end, (end/trd_arg->cycle_num)); + + pthread_mutex_lock(&g_time_mutex); + printf("g_thread_count=%d\n", g_thread_count); + g_all_time[g_thread_count] = end; + g_all_average_time[g_thread_count] = (end/trd_arg->cycle_num); + g_thread_count++; + pthread_mutex_unlock(&g_time_mutex); + +END: + if (ret == 0) + LOG_MSG("CMD:%d ok", trd_arg->cmd); + else + LOG_MSG("CMD:%d fail", trd_arg->cmd); + + ret = SYD_DisConnect_Ex(conn_handle); + if(ret != 0) + { + LOG("SYD_DisConnect_Ex ret=%08x", ret); + return NULL; + } + return NULL; +} + +int xn_cmd_tps() +{ + int ret = 0; + float all_time = 0, all_average_time = 0, tps = 0; + int i = 0, cmd = 0; + long thread_count = 0, run_count = 0; + pthread_t pthid[1000]; + trd_arg_t trd_arg; + memset(&trd_arg, 0, sizeof(trd_arg_t)); + IniOrgData(g_org_data, 9000, 1); + pthread_mutex_init(&g_time_mutex, NULL); + + while(1) + { + LOG_MSG("/-------性能测试TPS------/"); + LOG_MSG("0:SM4短数据加密"); + LOG_MSG("1:SM4短数据解密 "); + LOG_MSG("2:SM4批量加密 "); + LOG_MSG("3:SM4批量解密 "); + LOG_MSG("4:SM4-MAC短数据 "); + LOG_MSG("5:SM4-MAC批量数据 "); + LOG_MSG("6:SM3短数据"); + LOG_MSG("7:SM4短数据加密&校验值"); + LOG_MSG("8:SM4短数据解密&校验值"); + LOG_MSG("9:SM4批量数据加密&校验值"); + LOG_MSG("10:SM4批量数据解密&校验值"); + LOG_MSG("100:退出"); + LOG_MSG("请选择测试项:"); + scanf("%d", &trd_arg.cmd); + if(trd_arg.cmd == 100) goto END; + LOG_MSG("请输入线程数:"); + scanf("%ld", &thread_count); + LOG_MSG("请输入循环笔数:"); + scanf("%ld", &run_count); + LOG_MSG("请输入数据长度:"); + scanf("%d", &trd_arg.data_len); + trd_arg.cycle_num = run_count / thread_count; + g_thread_count = 0; + + ret = xn_tps_init_data(trd_arg.data_len); + if(ret != 0) + { + LOG("xn_tps_init_data err"); + goto END; + } + + for (i = 0; i < thread_count; i++) + { + ret = pthread_create(&pthid[i], NULL, xn_func_tps, (void *)&trd_arg); + if(ret) + { + LOG("Fail to create thread %d", (int)pthid[i]); + goto END; + } + } + + for (i = 0; i < thread_count; i++) + { + ret = pthread_join(pthid[i], NULL); + if(ret) + { + LOG("thread %d join failed\n", (int)pthid[i]); + goto END; + } + } + + /*计算总时间*/ + all_time = 0; + all_average_time = 0; + for(i = 0; i < g_thread_count; i++) + { + all_time += g_all_time[i]; + all_average_time += g_all_average_time[i]; + } + + if(all_time == 0) + { + all_time = 1; + } + + if(all_average_time == 0) + { + all_average_time = 1; + } + /*****平均时间*****/ + tps = (run_count * 1000000) / (all_time / thread_count); + LOG_MSG("[指令:%d] [笔数:%ld] [线程数:%ld] [总用时:%f(us)] [TPS:%f] [平均延时:%f(ms)]", \ + trd_arg.cmd, run_count, thread_count, (all_time / thread_count), tps, ((all_average_time / thread_count) / 1000)); + } + +END: + pthread_mutex_destroy(&g_time_mutex); + return 0; +} \ No newline at end of file diff --git a/doc/上金所存储加密C接口设计V1.02.docx b/doc/上金所存储加密C接口设计V1.02.docx new file mode 100644 index 0000000..5e055a9 Binary files /dev/null and b/doc/上金所存储加密C接口设计V1.02.docx differ diff --git a/doc/上金所存储加密C接口设计V1.02.pdf b/doc/上金所存储加密C接口设计V1.02.pdf new file mode 100644 index 0000000..85a342e Binary files /dev/null and b/doc/上金所存储加密C接口设计V1.02.pdf differ diff --git a/doc/上金所存储加密C接口设计V1.03.docx b/doc/上金所存储加密C接口设计V1.03.docx new file mode 100644 index 0000000..cf29a8c Binary files /dev/null and b/doc/上金所存储加密C接口设计V1.03.docx differ diff --git a/doc/上金所存储加密C接口设计V1.03.pdf b/doc/上金所存储加密C接口设计V1.03.pdf new file mode 100644 index 0000000..ceacb90 Binary files /dev/null and b/doc/上金所存储加密C接口设计V1.03.pdf differ diff --git a/doc/金交所存储加密C接口详细设计V1.00.doc b/doc/金交所存储加密C接口详细设计V1.00.doc new file mode 100644 index 0000000..7737d56 Binary files /dev/null and b/doc/金交所存储加密C接口详细设计V1.00.doc differ diff --git a/inc/error.h b/inc/error.h new file mode 100644 index 0000000..424e965 --- /dev/null +++ b/inc/error.h @@ -0,0 +1,41 @@ +#ifndef _ERROR_H_ +#define _ERROR_H_ + +#define SYD_OK 0 +#define SYD_FAIL 0x01000000 + +#define SYD_PARAM_ERR 0x01000001 //参数错误 +#define SYD_POINT_ERR 0x01000002 //指针错误 +#define SYD_MEMORY_ERR 0x01000003 //内存错误 +#define SYD_DEVICE_NUM_ERR 0x01000004 //设备连接数错误 +#define SYD_DEVICE_PORT_ERR 0x01000005 //设备端口错误 +#define SYD_DEVICE_TIMEOUT_ERR 0x01000006 //设备超时错误 +#define SYD_INVALIDHANDLE_ERR 0x01000007 //无效的句柄 +#define SYD_OUTDATA_LEN_ERR 0x01000008 //输出缓冲区大小不足 +#define SYD_QUEUE_HANDLE_ERR 0x01000009 //队列句柄未初始化 +#define SYD_QUEUE_ISFULL 0x0100000A //队列已满 +#define SYD_QUEUE_ISEMPTY 0x0100000B //队列为空 +#define SYD_THREAD_CREATE_ERR 0x0100000C //线程创建失败 +#define SYD_THREADPOOL_CLOSE 0x0100000D //线程池已关闭 +#define SYD_THREADPOOL_HANDLE_ERROR 0x0100000E //线程句柄无效 +#define SYD_THREAPOOL_DESTORY_OVERTIME 0x0100000F //线程销毁超时 +#define SYD_MAC_CHECK_ERROR 0x01000010 //MAC校验错误 +#define SYD_THREADPOOL_COUNT_ERROR 0x01000011 //线程数错误 +#define SYD_HANDLE_TYPE_ERROR 0x01000012 //句柄类型错误 +#define SYD_LONGDATA_HANDLE_UNINIT 0x01000013 //长数据的过程句柄没有执行初始化操作（init, update, final 必须先执行init操作） +#define SYD_DECRYPT_DATALEN_ERROR 0x01000014 //解密传入的数据长度错误（不能为0且必须满足16的倍数） +#define SYD_BATCH_DATA_SIZE_ERROR 0x01000015 //批量数据数组大小错误（短连接最多只能支持4个，长连接不限制） + +#define SYD_NET_CONNECT_ERR 0xFFFFFFFF //网络连接失败 +#define SYD_NET_SEND_ERR 0xFFFFFFFE //网络发送失败 +#define SYD_NET_RECV_ERR 0xFFFFFFFD //网络接收失败 +#define SYD_NET_PARAM_ERR 0xFFFFFFFC //网络参数错误 +#define SYD_NET_PKGLEN_ERR 0xFFFFFFFB //发送或接收的数据大小超过最大缓冲区大小 +#define SYD_NET_CMD_ERR 0xFFFFFFFA //网络返回包命令码错误 +#define SYD_NET_SN_ERR 0xFFFFFFF9 //网络返回包序列号错误 +#define SYD_NET_OVERTIME 0xFFFFFFF8 //数据处理超时（可以将处理超时调大） +#define SYD_NET_NOBLOCK_EINTR 0xFFFFFFF7 //被信号中断，需要重试(非阻塞模式) +#define SYD_NET_NOBLOCK_EWOUDBLOCK_EAGAIN 0xFFFFFFF6 //send:TCP 窗口太小，数据暂时发不出去 recv:当前内核缓冲区中无可读数据 (非阻塞模式) +#define SYD_NET_NOBLOCK_CLOSE 0xFFFFFFF5 //对端关闭连接(非阻塞模式) + +#endif \ No newline at end of file diff --git a/inc/log.h b/inc/log.h new file mode 100644 index 0000000..14a7e0f --- /dev/null +++ b/inc/log.h @@ -0,0 +1,36 @@ +#ifndef _LOG_H_ +#define _LOG_H_ + +#define LOG_MSG(A) Log_Two(__FILE__, __func__, __LINE__, A) +#define LOG_TWO(A, ...) Log_Two(__FILE__, __func__, __LINE__, A, __VA_ARGS__) +#define LOG(A, ...) Log_One(__FILE__, __func__, __LINE__, A, __VA_ARGS__) +#define LOG_NET(A, ...) Log_Net(__FILE__, __func__, __LINE__, A, __VA_ARGS__) + +#define LOG_MAX_LINE 1024 +#define LOG_MIN_LIN 256 + +#define LOG_CLOSE 0 +#define LOG_OPEN 1 +#define LOG_LEVEL_ONE 1 +#define LOG_LEVEL_TWO 2 +#define LOG_LEVEL_NET 3 + +typedef struct { + int iLogFlag; + int iLogLevel; +}STC_LOGINFO; + +extern STC_LOGINFO g_stcLogInfo; + +void Log_SetAttribute(int iLogFlag, int iLogLevel); +void Log_MutexInit(); +void Log_MutexDestory(); +void Log_Init(char *pcWorkPath); +void Log_One(const char* pcFile, const char* pcFunc, int iLine, char* pcLogBuf, ...); +void Log_Two(const char* pcFile, const char* pcFunc, int iLine, char* pcLogBuf, ...); +void Log_Net(const char* pcFile, const char* pcFunc, int iLine, char* pcLogBuf, ...); +void Log_Msg(char* pcLogBuf, ...); +void LOG_PrintHex(char* pcTitle, unsigned char* ucData, unsigned int uiDataLen); + + +#endif \ No newline at end of file diff --git a/inc/netapi.h b/inc/netapi.h new file mode 100644 index 0000000..d95d988 --- /dev/null +++ b/inc/netapi.h @@ -0,0 +1,55 @@ +#ifndef _NETAPI_H_ +#define _NETAPI_H_ + +#define IPMODE_IPV4 0 +#define IPMODE_IPV6 1 + +int socket_connect( + const char *ip, + const int port, + const int timeout, + const int ipmode, + int *pSockfd); + +int socket_send( + int fd, + char *buf, + int len); + +int socket_recv( + int fd, + char *buf, + int len); + +void socket_close( + int fd); + +int socket_connect_noblock( + const char* ip, + const int port, + const int timeout, + const int ipmode, + int* pSockfd); + +int socket_send_noblock( + int fd, + char *buf, + int len, + struct timeval start_time, + int deal_time); + +int socket_recv_noblock( + int fd, + char *buf, + int len, + struct timeval start_time, + int deal_time); + +void socket_close_noblock( + int fd); + +int ms_difftime( + struct timeval start_time, + struct timeval end_time); + +#endif \ No newline at end of file diff --git a/inc/public.h b/inc/public.h new file mode 100644 index 0000000..3f37042 --- /dev/null +++ b/inc/public.h @@ -0,0 +1,53 @@ +#ifndef _PUBLIC_H_ +#define _PUBLIC_H_ + +#define MIN_LIN 256 +#define MAX_LIN 1024 + +/*动态库加载状态*/ +#define P_DLL_INIT_OK 1 +#define P_DLL_INIT_FAIL 0 + +/*连接池*/ +#define P_THREADPOOL_MAX_COUNT 16 +#define P_THREADPOOL_QUERY_MAX_COUNT 1000 +#define P_THREADAPOOL_PKG_FLAG_OK 0x10001 +#define P_THREADAPOOL_PKG_FLAG_FAIL 0x00000 + +/*句柄类型*/ +#define P_HANDLE_DEV 0 +#define P_HANDLE_SM4_ENCDEC 1 +#define P_HANDLE_SM4_MAC 2 +#define P_HANDLE_SM3_HASH 3 +#define P_HANDLE_SM4_ENCDECMAC 4 +#define P_HANDLE_NOTIFY 5 + +/*句柄有效性*/ +#define P_HANDLE_OK 1 +#define P_HANDLE_FAIL 0 + +/*错误码字节长度*/ +#define P_ERR_LEN 2 + +/*主备机最大设备数*/ +#define P_DEVICE_MAX_COUNT 16 + +/*批量调用流程*/ +#define P_BATCH_ONLY_ONE 0 +#define P_BATCH_ALL_PKG 1 + +/*批量分组个数*/ +#define P_BATCH_GROUP 4 + +/*长数据分组初始化标志*/ +#define P_DATA_INIT 1 +#define P_DATA_FINAL 0 + +#define P_USEFLAG_THREADPOOL 1 +#define P_USEFLAG_ORDINARY 0 + +void P_BinToHex(char* pcInBuf, int iInBufLen,char* pcOutBuf); +void P_HexToBin(char* pcInBuf, int iInBufLen,char* pcOutBuf); +int P_GetWorkPath(char *pcWorkPath); + +#endif \ No newline at end of file diff --git a/inc/queue.h b/inc/queue.h new file mode 100644 index 0000000..160b483 --- /dev/null +++ b/inc/queue.h @@ -0,0 +1,39 @@ +#ifndef _QUEUE_H_ +#define _QUEUE_H_ + +typedef struct +{ + int* (*function)(void*, void*); + void *arg; + void *device; +}task_t; + +typedef struct +{ + task_t* task; //任务 + int head; //队列头 + int tail; //队列尾 + int length; //队列长度 + int capacity; //队列总容量 + int status; //句柄状态 +}queue_t; + +/*初始化队列*/ +queue_t* queue_init(int capacity); + +/*销毁队列*/ +void queue_destory(queue_t* queue); + +/*清空队列*/ +void queue_clear(queue_t* queue); + +/*获取队列长度*/ +int queue_getlength(queue_t* queue); + +/*入队*/ +int queue_enqueue(queue_t* queue, int* (*function)(void* arg, void *device), void *arg, void *device); + +/*出队*/ +int queue_dequeue(queue_t* queue, int* (*function)(void* arg, void *device), void *arg, void *device); + +#endif diff --git a/inc/sunyard.h b/inc/sunyard.h new file mode 100644 index 0000000..beadee0 --- /dev/null +++ b/inc/sunyard.h @@ -0,0 +1,225 @@ +#ifndef _SUNYARD_H_ +#define _SUNYARD_H_ + +#ifdef __cplusplus +extern "C"{ +#endif + +#if (defined(_WIN32) || defined(_WIN64)) && !defined(__WIN__) +#define __WIN__ +#endif + +#define DLL_EXPORT + +#ifdef __WIN__ +#ifdef DLL_EXPORT +#define DLL_DECLARE __declspec(dllexport) +#else +#define DLL_DECLARE __declspec(dllimport) +#endif +#define DEVAPI __stdcall +#else +#define DEVAPI +#define DLL_DECLARE __attribute__((visibility("default"))) +#endif + +/*log level*/ +#define LOG_LEVEL_0 0 +#define LOG_LEVEL_1 1 +#define LOG_LEVEL_2 2 +#define LOG_LEVEL_3 3 + +/*sm4 operate*/ +#define SM4_ENCRYPT 1 +#define SM4_DECRYPT 0 + +/*batch data package serial number*/ +#define PKG_ONLY_ONE 0 +#define PKG_FIRST 1 +#define PKG_MIDDLE 2 +#define PKG_LAST 3 + +DLL_DECLARE int DEVAPI SYD_SetLogConfig( + const char *pcLogPath, + int iLogPathLen, + int iLogLevel); + +DLL_DECLARE int DEVAPI SYD_Connect_Ex( + const char *pcIpList[], + int iPortList[], + int iSize, + int iConnectTimeout, + int iDealTimeOut, + int iThreadCount, + void** phHandle); + +DLL_DECLARE int DEVAPI SYD_DisConnect_Ex( + void* phHandle); + +DLL_DECLARE int DEVAPI SYD_GetVersionInfo( + void* phHandle, + char* pcVersion, + int* piVersionLen); + +DLL_DECLARE int DEVAPI SYD_SM4_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iFlag, + char* pcOutData, + int* piOutDataLen); + +DLL_DECLARE int DEVAPI SYD_SM4_BatchData( + void* phHandle, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + int iFlag, + char* pcOutData[], + int iOutDataLen[]); + +DLL_DECLARE int DEVAPI SYD_SM4_LongDataInit( + int iKeyIndex, + int iFlag, + void** phProcHandle); + +DLL_DECLARE int DEVAPI SYD_SM4_LongDataUpdate( + void* phHandle, + char* pcData, + int iDataLen, + char* pcOutData, + int* piOutDataLen, + void* phProcHandle); + +DLL_DECLARE int DEVAPI SYD_SM4_LongDataFinal( + void* phHandle, + char* pcOutData, + int* piOutDataLen, + void* phProcHandle); + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_ShortData( + void* phHandle, + char* pcData, + int iDataLen, + char* pcHash); + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_Init( + void** phHash); + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_Update( + void* phHandle, + char* pcData, + int iDataLen, + void* phHash); + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_Final( + void* phHandle, + char* pcHash, + void* phHash); + +DLL_DECLARE int DEVAPI SYD_SM4Mac_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + char* pcMac, + int* piCheckRet); + +DLL_DECLARE int DEVAPI SYD_SM4Mac_BatchData( + void* phHandle, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcMac[], + int piCheckRet[]); + +DLL_DECLARE int DEVAPI SYD_SM4Mac_LongDataInit( + int iKeyIndex, + void** phMac); + +DLL_DECLARE int DEVAPI SYD_SM4Mac_LongDataUpdate( + void* phHandle, + char* pcData, + int iDataLen, + void* phMac); + +DLL_DECLARE int DEVAPI SYD_SM4Mac_LongDataFinal( + void* phHandle, + char* pcMac, + int* piCheckRet, + void* phMac); + +DLL_DECLARE int DEVAPI SYD_CloseHandle( + void *hHandle); + +DLL_DECLARE int DEVAPI SYD_SM4_Encrypt_Mac_ShortData( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcData, + int iDataLen, + char* pcEncData, + int* piEncDataLen, + char* pcMac); + +DLL_DECLARE int DEVAPI SYD_SM4_Decrypt_Mac_ShortData( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcEncData, + int iEncDataLen, + char* pcMac, + char* pcOutData, + int* piOutDataLen); + +DLL_DECLARE int DEVAPI SYD_SM4_Encrypt_Mac_BatchData( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcEncData[], + int iEncDataLen[], + char* pcMac[]); + +DLL_DECLARE int DEVAPI SYD_SM4_Decrypt_Mac_BatchData( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcEncData[], + int iEncDataLen[], + char* pcMac[], + int iSize, + char* pcOutData[], + int iOutDataLen[], + int iCheckRet[]); + +DLL_DECLARE int DEVAPI SYD_SM4EncDecMac_LongDataInit( + int iEncKeyIndex, + int iCheckKeyIndex, + int iFlag, + void** phProcHandle); + +DLL_DECLARE int DEVAPI SYD_SM4EncDecMac_LongDataUpdate( + void* phHandle, + char* pcData, + int iDataLen, + char* pcOutData, + int* piOutDataLen, + void* phProcHandle); + +DLL_DECLARE int DEVAPI SYD_SM4EncDecMac_LongDataFinal( + void* phHandle, + char* pcOutData, + int* piOutDataLen, + char* pcMac, + void* phProcHandle); + +#ifdef __cplusplus +} +#endif +#endif \ No newline at end of file diff --git a/inc/sunyard_d.h b/inc/sunyard_d.h new file mode 100644 index 0000000..2f56fab --- /dev/null +++ b/inc/sunyard_d.h @@ -0,0 +1,215 @@ +#ifndef _SUNYARD_D_H_ +#define _SUNYARD_D_H_ + +#ifndef _SUNYARD_H_ +#include "sunyard.h" +#endif + +#ifndef _PUBLIC_H_ +#include "public.h" +#endif + +#ifndef _THREAD_POOL_H_ +#include "threadpool.h" +#endif + +typedef struct { + int socket_fd; + char ip[40]; + int port; + int con_timeout; + int deal_timeout; + int status; +} STC_CONNECT_INFO; + +typedef struct { + threadpool_t *threadpool; /*连接池*/ + pthread_mutex_t threadpool_mutex; /*连接池锁*/ + int threadpool_deal_time; /*连接池处理时间*/ + STC_CONNECT_INFO connect_info[P_DEVICE_MAX_COUNT]; /*普通连接信息*/ + int connect_idex; /*当前使用机器序号*/ + int connect_count; /*机器连接个数*/ + int deal_time; /*普通连接处理时间*/ + int connect_timeout; /*设备连接时间*/ + int use_flag; /*使用标志：0：使用普通连接 1：使用线程池*/ + int status; /*句柄有效性*/ +}STC_DEVICE_INFO; + +typedef struct { + int keyidex; /*密钥索引*/ + int flag; /*加解密标识*/ + char procdata[64]; /*加密过渡数据*/ + int procdatalen; /*加密过渡数据长度*/ + int initflag; /*初始化标志*/ + int status; /*句柄有效性*/ +}STC_SM4_ENCDEC_INFO; + +typedef struct { + int keyidex; /*密钥索引*/ + char iv[64]; /*过程IV*/ + int ivlen; /*过程IV长度*/ + char procdata[64]; /*过渡数据*/ + int procdatalen; /*过渡数据长度*/ + int initflag; /*初始化标志*/ + int status; /*句柄有效性*/ +}STC_SM4_MAC_INFO; + +typedef struct { + char procdata[MAX_LIN]; /*过渡数据*/ + int procdatalen; /*过渡数据长度*/ + int firstflag; /*第一包标志*/ + int initflag; /*初始化标志*/ + int status; /*句柄有效性*/ +}STC_SM3_HASH_INFO; + +typedef struct { + STC_SM4_ENCDEC_INFO sm4_encdec_info; + STC_SM4_MAC_INFO sm4_mac_info; + int initflag; /*初始化标志*/ + int status; /*句柄有效性*/ +}STC_SM4_ENCDECMAC_INFO; + +typedef struct { + STC_DEVICE_INFO *device_info; + STC_SM4_ENCDEC_INFO *sm4_encdec_info; + STC_SM4_MAC_INFO *sm4_mac_info; + STC_SM3_HASH_INFO *sm3_hash_info; + STC_SM4_ENCDECMAC_INFO *sm4_encdecmac_info; + int iHandleType; + int iStatus; +}STC_D_HANDLE; + +int SYD_D_AnalysisDevHandle( + void* handle, + int handletype, + void** outhandle); + +int SYD_D_Connect_Ex( + const char *pcIpList[], + int iPortList[], + int iSize, + int iConnectTimeout, + int iDealTimeOut, + int iThreadCount, + void** phHandle); + +int SYD_D_DisConnect_Ex( + void* phHandle); + +int SYD_D_GetServerVersion( + void* phHandle, + char* pcServerVersion, + int* piServerVersionLen); + +int SYD_D_SM4_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iFlag, + char* pcOutData, + int* piOutDataLen); + +int SYD_D_SM4_LongData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iPkgNum, + int iFlag, + char* pcOutData, + int* piOutDataLen); + +int SYD_D_SM4_Data( + void* phHandle, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[]); + +int SYD_D_SM4_BatchData( + void* phHandle, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[], + int iCheckRet[]); + +int SYD_D_SM3_Hash_ShortData( + void* phHandle, + char* pcData, + int iDataLen, + char* pcHash); + +int SYD_D_SM3_Hash_LongData( + void* phHandle, + char* pcData, + int iDataLen, + int iPkgNum, + char* pcProcData, + int* piProcDataLen, + char* pcHash); + +int SYD_D_SM4Mac_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + char* pcMac, + int* piCheckRet); + +int SYD_D_SM4Mac_BatchData( + void* phHandle, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcMac[], + int piCheckRet[]); + +int SYD_D_SM4Mac_LongData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iPkgNum, + char* pcProcData, + int* piProcDataLen, + char* pcMac, + int* piCheckRet); + +int SYD_D_CloseHandle( + void *handle); + +int SYD_D_SM4_ShortData_CheckValue( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcData, + int iDataLen, + char* pcMac, + int iFlag, + char* pcOutData, + int* piOutDataLen, + char* pcOutMac); + +int SYD_D_SM4_BatchData_CheckValue( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcData[], + int iDataLen[], + char* pcMac[], + int iSize, + int iFlag, + char* pcOutData[], + int iOutDataLen[], + char* pcOutMac[]); + +#endif \ No newline at end of file diff --git a/inc/threadpool.h b/inc/threadpool.h new file mode 100644 index 0000000..81a2e31 --- /dev/null +++ b/inc/threadpool.h @@ -0,0 +1,103 @@ +#ifndef _THREAD_POOL_H_ +#define _THREAD_POOL_H_ + +#ifndef _TYPEDEF_H_ +#include "typedef.h" +#endif + +#ifndef _PUBLIC_H_ +#include "public.h" +#endif + +#ifndef _QUEUE_H_ +#include "queue.h" +#endif + + +typedef struct { + int socket_fd; + char ip[40]; + int port; + int con_timeout; + int deal_timeout; + int status; +} threadpool_connect_info_t; + +typedef struct { + pthread_t thread_id; + queue_t* work_queue; + threadpool_connect_info_t connect_info[P_DEVICE_MAX_COUNT]; + int connect_count; + int connect_idex; +} threadpool_task_t; + +typedef struct { + threadpool_task_t* work_threads; /* 工作线程 */ + + /*管理线程*/ + threadpool_task_t* admin_threads; /* 管理线程 */ + pthread_t admin_thread_id; /* 管理线程ID */ + + /*线程池信息*/ + int total_thr_num; /* 线程总数 */ + int live_thr_num; /* 线程池中存活的线程数 */ + int busy_thr_num; /* 忙线程，正在工作的线程 */ + unsigned long long task_num; /* 已执行的所有任务量统计值（不包含正在执行中的任务） */ + + /*任务队列信息*/ + queue_t* queue[64]; + int queue_max_size; /* 队列能容纳的最大任务数 */ + pthread_mutex_t queue_mutex; /* 多个工作线程创建队列时加锁 */ + int free_queue; + + /*线程池状态*/ + int shutdown; /* 线程池开关： FALSE: 开启 TRUE: 关闭 */ +} threadpool_t; + + +/* +功能：创建线程池-多队列* +注意：这里的queue_max_size是一个工作线程的队列容量 +*/ +threadpool_t* threadpool_create(int thread_num, int queue_max_size); + +/* +功能：添加任务-多队列 +注意：该功能使用时必须加锁（必须与销毁线程（threadpool_destroy）使用相同的锁） +*/ +int threadpool_add_task(threadpool_t *threadpool, int* (*function)(void* arg, void* device), void* arg, void* device); + +/* +功能：销毁线程 +注意：该功能使用时必须加锁（必须与添加任务（threadpool_add_task）使用相同的锁） +*/ +int threadpool_destroy(threadpool_t *threadpool); + +/*创建线程池中设备连接*/ +int threadpool_create_connect( + threadpool_t *threadpool, + const char *pcIpList[], + int iPortList[], + int dev_num, + int iConnectTimeout); + +/*断开线程池中的所有设备连接*/ +int threadpool_disconnect(threadpool_t *threadpool); + +/*设置线程池中的连接信息*/ +int threadpool_set_connect_info( + threadpool_t *threadpool, + const char *pcIpList[], + int iPortList[], + int dev_num, + int iConnectTimeout, + int iDealTimeOut); + +/*清除线程池中的连接信息*/ +int threadpool_clear_connect_info(threadpool_t *threadpool); + +/*主备机监控恢复线程*/ +int threadpool_device_admin(threadpool_t *threadpool); + + +#endif \ No newline at end of file diff --git a/inc/trans.h b/inc/trans.h new file mode 100644 index 0000000..e54ef33 --- /dev/null +++ b/inc/trans.h @@ -0,0 +1,48 @@ +#ifndef _TRANS_H_ +#define _TRANS_H_ + +#ifndef _THREADPOOL_H_ +#include "threadpool.h" +#endif + +typedef struct +{ + unsigned char LENGTH[2]; + unsigned char HEADER[8]; + unsigned char COMMAND[2]; + unsigned char data[8192]; +} TRD_PKG_ST; + +typedef struct +{ + TRD_PKG_ST send_pkg_st; + TRD_PKG_ST recv_pkg_st; + char cmd[3]; + int deal_time; + int task_ret; + int task_flag; + int connect_idex; +} TRD_PKG_THREADPOOL_ST; + +int Get_retcode(TRD_PKG_ST *pkg); +unsigned int Get_sn(TRD_PKG_ST *pkg); +char *Get_cmd(TRD_PKG_ST *pkg); +int Get_length(TRD_PKG_ST *pkg); +void Set_sn(TRD_PKG_ST *pkg, unsigned int sn); +void Set_cmd(TRD_PKG_ST *pkg, char *cmd); +void Set_length(TRD_PKG_ST *pkg, int length); +int Packet_Recv(int fd, TRD_PKG_ST *pkg, int pkgsize); +int Packet_Send(int fd, TRD_PKG_ST *pkg, int pkgsize); +void SetDataLength(int iInData, unsigned char* pcOutData); +int GetDataLength(unsigned char* pcInData); + + +/*非阻塞-线程回调-主备模式*/ +int TP_Process_NoBlock_Standby(char *cmd, TRD_PKG_ST *send_pkg, TRD_PKG_ST *recv_pkg, void *device, int deal_time); + +/*非阻塞-非线程回调-主备模式*/ +int TP_Process_NoBlock_Ordinary(char *cmd, TRD_PKG_ST *send_pkg, TRD_PKG_ST *recv_pkg, STC_CONNECT_INFO *connect_info, int *connect_idex, int device_count, int deal_time); + +int TP_Process_NoBlock(threadpool_t *threadpool, pthread_mutex_t *threadpool_mutex, TRD_PKG_THREADPOOL_ST *pkg_threadpool_st, int pkg_number); + +#endif \ No newline at end of file diff --git a/inc/typedef.h b/inc/typedef.h new file mode 100644 index 0000000..00e5ed1 --- /dev/null +++ b/inc/typedef.h @@ -0,0 +1,51 @@ +#ifndef _TYPEDEF_H_ +#define _TYPEDEF_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#ifndef _ERROR_H_ +#include "error.h" +#endif + +/* 内存访问栅 */ + #define barrier() (__sync_synchronize()) + +/*原子设置，如果原值和新值不一样则设置*/ +#define AO_SET(ptr, value) ((void)__sync_lock_test_and_set((ptr), (value))) + +/*原子获取*/ +#define AO_GET(ptr) ({ __typeof__(*(ptr)) volatile *_val = (ptr); barrier(); (*_val); }) + +/*原子加*/ +#define AO_F_ADD(ptr, value) ((__typeof__(*(ptr)))__sync_fetch_and_add((ptr), (value))) + +/*原子减*/ +#define AO_F_SUB(ptr, value) ((__typeof__(*(ptr)))__sync_fetch_and_sub((ptr), (value))) + +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef FALSE +#define FALSE 0 +#endif + +#endif \ No newline at end of file diff --git a/run.sh b/run.sh new file mode 100644 index 0000000..10e8dd9 --- /dev/null +++ b/run.sh @@ -0,0 +1,7 @@ + +cd src/ +make clean all +cd ../demo +make clean all +cd .. +export LD_LRBRARY_PATH=./lib diff --git a/src/Makefile b/src/Makefile new file mode 100644 index 0000000..fe16cd2 --- /dev/null +++ b/src/Makefile @@ -0,0 +1,65 @@ +# SlickEdit generated file. Do not edit this file except in designated areas. + +# Make command to use for dependencies +MAKE=make +RM=rm +MKDIR=mkdir + +# SlickEdit generated file. Do not edit this file except in designated areas. + +# Make command to use for dependencies +MAKE=make +RM=rm +MKDIR=mkdir + +# -----Begin user-editable area----- + +# -----End user-editable area----- + +# If no configuration is specified, "Debug" will be used +ifndef CFG +CFG=Debug +endif + +# +# Configuration: Debug +# +ifeq "$(CFG)" "Debug" +OUTDIR=Debug +OUTFILE=../lib/libsunyard.so +CFG_INC=-I../inc +CFG_LIB=-lpthread +CFG_OBJ= +COMMON_OBJ=$(OUTDIR)/netapi.o $(OUTDIR)/trans.o $(OUTDIR)/log.o $(OUTDIR)/public.o $(OUTDIR)/sunyard.o $(OUTDIR)/sunyard_d.o \ + $(OUTDIR)/queue.o $(OUTDIR)/threadpool.o +OBJ=$(COMMON_OBJ) $(CFG_OBJ) +ALL_OBJ=$(OUTDIR)/netapi.o $(OUTDIR)/trans.o $(OUTDIR)/log.o $(OUTDIR)/public.o $(OUTDIR)/sunyard.o $(OUTDIR)/sunyard_d.o \ + $(OUTDIR)/queue.o $(OUTDIR)/threadpool.o +COMPILE=gcc -c "-D_REENTRANT" -g -fPIC -fvisibility=hidden -o "$(OUTDIR)/$(*F).o" $(CFG_INC) $< +LINK=gcc -g -shared -fPIC -fvisibility=hidden -L../lib -o "$(OUTFILE)" $(ALL_OBJ) $(CFG_LIB) + +# Pattern rules +$(OUTDIR)/%.o : %.c + $(COMPILE) + +# Build rules +all: $(OUTFILE) + +$(OUTFILE): $(OUTDIR) $(OBJ) + $(LINK) + +$(OUTDIR): + $(MKDIR) -p "$(OUTDIR)" + +# Rebuild this project +rebuild: cleanall all + +# Clean this project +clean: + $(RM) -f $(OUTFILE) + $(RM) -f $(OBJ) + +# Clean this project and all dependencies +cleanall: clean +endif + diff --git a/src/log.c b/src/log.c new file mode 100644 index 0000000..39788e3 --- /dev/null +++ b/src/log.c @@ -0,0 +1,298 @@ +#ifndef _TYPEDEF_H_ +#include "typedef.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +static pthread_mutex_t g_apilogmutex; + +static unsigned char g_stcApiLogPath[LOG_MAX_LINE] = { 0 }; + +STC_LOGINFO g_stcLogInfo; + +static void GetDateTime(unsigned char *pucDate, unsigned char *pucDateTime) +{ + long ts; + struct tm *ptm; + ts = time(NULL); + ptm = localtime(&ts); + if(pucDate != NULL) + { + sprintf((char *)pucDate, "%04d-%02d-%02d", \ + ptm->tm_year + 1900, ptm-> tm_mon + 1, ptm->tm_mday); + } + if(pucDateTime != NULL) + { + sprintf((char *)pucDateTime, "%04d-%02d-%02d %02d:%02d:%02d", \ + ptm->tm_year + 1900, ptm-> tm_mon + 1, ptm->tm_mday, ptm-> tm_hour, ptm-> tm_min, ptm-> tm_sec); + } +} + +static int CheckFileExit(char *pcFilePath) +{ + if(access(pcFilePath, F_OK) != 0) + { + return SYD_FAIL; + } + return SYD_OK; +} + +void Log_SetAttribute(int iLogFlag, int iLogLevel) +{ + g_stcLogInfo.iLogFlag = iLogFlag; + g_stcLogInfo.iLogLevel = iLogLevel; +} + +void Log_MutexInit() +{ + pthread_mutex_init(&g_apilogmutex, NULL); +} + +void Log_MutexDestory() +{ + pthread_mutex_destroy(&g_apilogmutex); +} + +static void Mkdir(char *pcDir) +{ + int iIndex = 1; + char *tmp = (char *)pcDir; + while(iIndex < strlen(pcDir) + 1) + { + if(*(pcDir + iIndex) == '/' || *(pcDir + iIndex) == '\0') + { + char cParent[LOG_MIN_LIN] = {0}; + strncpy(cParent, pcDir, iIndex); + if(0 != access(cParent, 6)) + { + mkdir(cParent, 0755); + } + } + iIndex++; + } +} + +static unsigned int Touch(char *pcFile) +{ + FILE* fp = NULL; + fp = fopen(pcFile, "w+"); + if (fp == NULL) + { + return SYD_FAIL; + } + fclose(fp); + return SYD_OK; +} + +void Log_Init(char *pcWorkPath) +{ + int iRet = 0; + char cCmd[LOG_MAX_LINE] = {0}; + memset(g_stcApiLogPath, 0, sizeof(g_stcApiLogPath)); + sprintf(g_stcApiLogPath, "%s/SydLog", pcWorkPath); + iRet = CheckFileExit(g_stcApiLogPath); + if(iRet != SYD_OK) + { + Mkdir(g_stcApiLogPath); + } +} + +void Log_Net(const char* pcFile, const char* pcFunc, int iLine, char* pcLogBuf, ...) +{ + if (g_stcLogInfo.iLogFlag != LOG_OPEN) + { + return; + } + + int iRet = 0; + unsigned char bDateTime[LOG_MAX_LINE] = {0}; + unsigned char bDate[LOG_MAX_LINE] = {0}; + char cLogBuf[8192] = {0}; + char cLogPath[LOG_MAX_LINE] = {0}; + char cCmd[LOG_MAX_LINE] = {0}; + GetDateTime(bDate, bDateTime); + + pthread_mutex_lock(&g_apilogmutex); + sprintf(cLogPath, "%s/%s[%d].txt", g_stcApiLogPath, bDate, getpid()); + iRet = CheckFileExit(cLogPath); + if(iRet != 0) + { + Touch(cLogPath); + } + + va_list ap; + va_start(ap, pcLogBuf); + vsnprintf(cLogBuf, 8192, pcLogBuf, ap); + va_end(ap); + + FILE *fp = NULL; + fp = fopen((char *)cLogPath, "a"); + if (fp == NULL) + { + pthread_mutex_unlock(&g_apilogmutex); + return; + } + fprintf(fp, "[thread_id:%ld][%s][%s][%s]:%d %s\n", pthread_self(), bDateTime, pcFile, pcFunc, iLine, cLogBuf); + fflush(fp); + fclose(fp); + pthread_mutex_unlock(&g_apilogmutex); +} + +void Log_One(const char* pcFile, const char* pcFunc, int iLine, char* pcLogBuf, ...) +{ + if (g_stcLogInfo.iLogFlag != LOG_OPEN) + { + return; + } + + int iRet = 0; + unsigned char bDateTime[LOG_MAX_LINE] = {0}; + unsigned char bDate[LOG_MAX_LINE] = {0}; + char cLogBuf[8192] = {0}; + char cLogPath[LOG_MAX_LINE] = {0}; + char cCmd[LOG_MAX_LINE] = {0}; + GetDateTime(bDate, bDateTime); + + pthread_mutex_lock(&g_apilogmutex); + sprintf(cLogPath, "%s/%s[%d].txt", g_stcApiLogPath, bDate, getpid()); + iRet = CheckFileExit(cLogPath); + if(iRet != 0) + { + Touch(cLogPath); + } + + va_list ap; + va_start(ap, pcLogBuf); + vsnprintf(cLogBuf, 8192, pcLogBuf, ap); + va_end(ap); + + FILE *fp = NULL; + fp = fopen((char *)cLogPath, "a"); + if (fp == NULL) + { + pthread_mutex_unlock(&g_apilogmutex); + return; + } + fprintf(fp, "[thread_id:%ld][%s][%s][%s]:%d %s\n", pthread_self(), bDateTime, pcFile, pcFunc, iLine, cLogBuf); + fflush(fp); + fclose(fp); + pthread_mutex_unlock(&g_apilogmutex); +} + +void Log_Two(const char* pcFile, const char* pcFunc, int iLine, char* pcLogBuf, ...) +{ + if (g_stcLogInfo.iLogFlag != LOG_OPEN || g_stcLogInfo.iLogLevel != LOG_LEVEL_TWO) + { + return; + } + + int iRet = 0; + unsigned char bDateTime[LOG_MAX_LINE] = {0}; + unsigned char bDate[LOG_MAX_LINE] = {0}; + char cLogBuf[8192] = {0}; + char cLogPath[LOG_MAX_LINE] = {0}; + char cCmd[LOG_MAX_LINE] = {0}; + GetDateTime(bDate, bDateTime); + + pthread_mutex_lock(&g_apilogmutex); + sprintf(cLogPath, "%s/%s[%d].txt", g_stcApiLogPath, bDate, getpid()); + iRet = CheckFileExit(cLogPath); + if(iRet != 0) + { + Touch(cLogPath); + } + + va_list ap; + va_start(ap, pcLogBuf); + vsnprintf(cLogBuf, 8192, pcLogBuf, ap); + va_end(ap); + + FILE *fp = NULL; + fp = fopen((char *)cLogPath, "a"); + if (fp == NULL) + { + pthread_mutex_unlock(&g_apilogmutex); + return; + } + fprintf(fp, "[thread_id:%ld][%s][%s][%s]:%d %s\n", pthread_self(), bDateTime, pcFile, pcFunc, iLine, cLogBuf); + fflush(fp); + fclose(fp); + pthread_mutex_unlock(&g_apilogmutex); +} + +void Log_Msg(char* pcLogBuf, ...) +{ + if (g_stcLogInfo.iLogFlag != LOG_OPEN || g_stcLogInfo.iLogLevel != LOG_LEVEL_TWO) + { + return; + } + + int iRet = 0; + unsigned char bDateTime[LOG_MAX_LINE] = {0}; + unsigned char bDate[LOG_MAX_LINE] = {0}; + char cLogBuf[8192] = {0}; + char cLogPath[LOG_MAX_LINE] = {0}; + char cCmd[LOG_MAX_LINE] = {0}; + GetDateTime(bDate, bDateTime); + + pthread_mutex_lock(&g_apilogmutex); + sprintf(cLogPath, "%s/%s[%d].txt", g_stcApiLogPath, bDate, getpid()); + iRet = CheckFileExit(cLogPath); + if(iRet != 0) + { + Touch(cLogPath); + } + + va_list ap; + va_start(ap, pcLogBuf); + vsnprintf(cLogBuf, 8192, pcLogBuf, ap); + va_end(ap); + + FILE *fp = NULL; + fp = fopen((char *)cLogPath, "a"); + if (fp == NULL) + { + pthread_mutex_unlock(&g_apilogmutex); + return; + } + fprintf(fp, "%s\n", cLogBuf); + fflush(fp); + fclose(fp); + pthread_mutex_unlock(&g_apilogmutex); +} + +void LOG_PrintHex(char* pcTitle, unsigned char* ucData, unsigned int uiDataLen) +{ + if (g_stcLogInfo.iLogFlag != LOG_OPEN || g_stcLogInfo.iLogLevel != LOG_LEVEL_TWO) + { + return; + } + + if (ucData == NULL || uiDataLen == 0) + { + return; + } + + unsigned int i = 0; + char cTmp[8000] = { 0 }; + char cBuf[10] = { 0 }; + LOG_TWO("\n[%s][len=%d]:", pcTitle, uiDataLen); + for (i = 0; i < uiDataLen; i++) + { + if (!(i % 16)) + { + strcat(cTmp, "\n"); + } + sprintf(cBuf, " %02X", ucData[i]); + strcat(cTmp, cBuf); + + if ((i % 256 == 0) && (i / 256 > 0)) + { + Log_Msg("%s", cTmp); + memset(cTmp, 0, sizeof(cTmp)); + } + } + Log_Msg("%s\n", cTmp); +} \ No newline at end of file diff --git a/src/netapi.c b/src/netapi.c new file mode 100644 index 0000000..3b59c81 --- /dev/null +++ b/src/netapi.c @@ -0,0 +1,431 @@ +#ifndef _TYPEDEF_H_ +#include "typedef.h" +#endif + +#ifndef _NETAPI_H_ +#include "netapi.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +void socket_set_timeout(int sockfd, int second) +{ + struct timeval tv; + tv.tv_sec = second / 1000; + tv.tv_usec = (second % 1000) * 1000; + setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, (char*)&tv, sizeof(struct timeval)); + setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(struct timeval)); +} + +int socket_connect_ipv4(const char* ip, const int port, const int timeout, int* pSockfd) +{ + if (ip == NULL || port > 65535 || port < 1024 || pSockfd == NULL) + { + return -1; + } + int fd = 0, ret = -1; + struct sockaddr_in servaddr; + int iSockLen = sizeof(servaddr); + fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) + { + return -1; + } + memset(&servaddr, 0, iSockLen); + servaddr.sin_family = AF_INET; + servaddr.sin_addr.s_addr = inet_addr(ip); + servaddr.sin_port = htons(port); + socket_set_timeout(fd, timeout); + + ret = connect(fd, (struct sockaddr *)&servaddr, iSockLen); + if (ret < 0) + { + if(errno==ETIMEDOUT) + { + return -3; + } + return -1; + } + *pSockfd = fd; + return 0; +} + +int socket_connect_ipv6(const char* ip, const int port, const int timeout, int* pSockfd) +{ + if (ip == NULL || port > 65535 || port < 1024 || pSockfd == NULL) + { + return -1; + } + + int fd = 0, ret = -1; + struct sockaddr_in6 servaddr; + int iSockLen = sizeof(servaddr); + fd = socket(AF_INET6, SOCK_STREAM, 0); + if (fd < 0) + { + return -1; + } + memset(&servaddr, 0, iSockLen); + servaddr.sin6_family = AF_INET6; + inet_pton(AF_INET6, ip, &servaddr.sin6_addr); + servaddr.sin6_port = htons(port); + socket_set_timeout(fd, timeout); + ret = connect(fd, (struct sockaddr *)&servaddr, iSockLen); + if (ret<0) + { + if(errno==ETIMEDOUT) + { + return -3; + } + return -1; + } + *pSockfd = fd; + return 0; +} + +int socket_connect(const char* ip, const int port, const int timeout, const int ipmode, int* pSockfd) +{ + int ret = 0; + switch (ipmode) + { + case IPMODE_IPV4: + ret = socket_connect_ipv4(ip, port, timeout, pSockfd); + break; + case IPMODE_IPV6: + ret = socket_connect_ipv6(ip, port, timeout, pSockfd); + break; + default: + return SYD_NET_CONNECT_ERR; + } + return ret; +} + +int socket_send(int fd, char* buf, int len) +{ + if (NULL == buf || len < 0) + { + return SYD_NET_PARAM_ERR; + } + + int ret = 0, total = 0; + while (total < len) + { + ret = send(fd, buf + total, len - total, MSG_NOSIGNAL); + if (ret <= 0) + { + return SYD_NET_SEND_ERR; + } + total += ret; + } + return 0; +} + +int socket_recv(int fd, char* buf, int len) +{ + if (NULL == buf || len < 0) + { + return SYD_NET_PARAM_ERR; + } + + int ret = 0, total = 0; + while (total < len) + { + ret = recv(fd, buf + total, len - total, MSG_NOSIGNAL); + if (ret <= 0) + { + return SYD_NET_RECV_ERR; + } + total += ret; + } + return 0; +} + +void socket_close(int fd) +{ + close(fd); +} + +int socket_connect_ipv4_noblock(const char* ip, const int port, const int timeout, int* pSockfd) +{ + if (ip == NULL || port > 65535 || port < 1024 || pSockfd == NULL) + { + return -1; + } + int fd = 0, ret = -1, flags = 0; + int len = 0, error = 0; + struct sockaddr_in servaddr; + int iSockLen = sizeof(servaddr); + fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) + { + return -1; + } + memset(&servaddr, 0, iSockLen); + servaddr.sin_family = AF_INET; + servaddr.sin_addr.s_addr = inet_addr(ip); + servaddr.sin_port = htons(port); + + flags = fcntl(fd, F_GETFL, 0); + if (flags == -1) + { + close(fd); + return -1; + } + + flags |= O_NONBLOCK; + if (fcntl(fd, F_SETFL, flags) == -1) + { + close(fd); + return -1; + } + + ret = connect(fd, (struct sockaddr *)&servaddr, iSockLen); + if (ret < 0) + { + if(errno != EINPROGRESS) + { + close(fd); + return -1; + } + + struct timeval tv; + fd_set wset; + tv.tv_sec = timeout/1000; + tv.tv_usec = (timeout % 1000) * 1000; + FD_ZERO(&wset); + FD_SET(fd, &wset); + int n = select(fd + 1, NULL, &wset, NULL, &tv); + if (n <= 0) + { + close(fd); + return -1; + } + len = sizeof(error); + getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len); + if(error) + { + close(fd); + return -1; + } + } + *pSockfd = fd; + return 0; +} + +int socket_connect_ipv6_noblock(const char* ip, const int port, const int timeout, int* pSockfd) +{ + if (ip == NULL || port > 65535 || port < 1024 || pSockfd == NULL) + { + return -1; + } + + int fd = 0, ret = -1, flags = 0; + int len = 0, error = 0; + struct sockaddr_in6 servaddr; + int iSockLen = sizeof(servaddr); + fd = socket(AF_INET6, SOCK_STREAM, 0); + if (fd < 0) + { + return -1; + } + memset(&servaddr, 0, iSockLen); + servaddr.sin6_family = AF_INET6; + inet_pton(AF_INET6, ip, &servaddr.sin6_addr); + servaddr.sin6_port = htons(port); + + flags = fcntl(fd, F_GETFL, 0); + if (flags == -1) + { + close(fd); + return -1; + } + + flags |= O_NONBLOCK; + if (fcntl(fd, F_SETFL, flags) == -1) + { + close(fd); + return -1; + } + + ret = connect(fd, (struct sockaddr *)&servaddr, iSockLen); + if (ret < 0) + { + if (errno != EINPROGRESS) + { + close(fd); + return -1; + } + + struct timeval tv; + fd_set wset; + tv.tv_sec = timeout / 1000; + tv.tv_usec = (timeout % 1000) * 1000; + FD_ZERO(&wset); + FD_SET(fd, &wset); + int n = select(fd + 1, NULL, &wset, NULL, &tv); + if (n <= 0) + { + close(fd); + return -1; + } + len = sizeof(error); + getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len); + if (error) + { + close(fd); + return -1; + } + } + *pSockfd = fd; + return 0; +} + +int socket_connect_noblock(const char* ip, const int port, const int timeout, const int ipmode, int* pSockfd) +{ + int ret = 0; + switch (ipmode) + { + case IPMODE_IPV4: + ret = socket_connect_ipv4_noblock(ip, port, timeout, pSockfd); + break; + case IPMODE_IPV6: + ret = socket_connect_ipv6_noblock(ip, port, timeout, pSockfd); + break; + default: + return -1; + } + return ret; +} + +//精确到毫秒 +int ms_difftime(struct timeval start_time, struct timeval end_time) +{ + long start = start_time.tv_sec * 1000 + start_time.tv_usec * 0.001; + long end = end_time.tv_sec * 1000 + end_time.tv_usec * 0.001; + return end - start; +} + +int socket_send_noblock(int fd, char* buf, int len, struct timeval start_time, int deal_time) +{ + if (NULL == buf || len < 0) + { + return SYD_NET_PARAM_ERR; + } + + struct timeval local_time; + int ret = 0, send_bytes = 0; //已发送的字节数 + while(send_bytes < len) + { + gettimeofday(&local_time, NULL); + if(deal_time < ms_difftime(start_time, local_time)) + { + LOG_NET("socket_send_noblock overtime ret=%08x", SYD_NET_OVERTIME); + return SYD_NET_OVERTIME; + } + ret = send(fd, buf + send_bytes, len - send_bytes, MSG_NOSIGNAL|MSG_DONTWAIT); + if(ret < 0) + { + if(errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) + { + continue; + } + LOG_NET("send err ret=%08x", SYD_NET_SEND_ERR); + return SYD_NET_SEND_ERR; + } + else if(ret == 0) + { + LOG_NET("send err ret=%08x", SYD_NET_NOBLOCK_CLOSE); + return SYD_NET_NOBLOCK_CLOSE; + } + send_bytes += ret; + } + return SYD_OK; +} + +int socket_recv_noblock(int fd, char* buf, int len, struct timeval start_time, int deal_time) +{ + if (NULL == buf || len < 0) + { + return SYD_NET_PARAM_ERR; + } + + struct timeval local_time; + int ret = 0, recv_bytes = 0; //已接受的字节数 + while (recv_bytes < len) + { + gettimeofday(&local_time, NULL); + if(deal_time < ms_difftime(start_time, local_time)) + { + LOG_NET("socket_recv_noblock overtime ret=%08x", SYD_NET_OVERTIME); + return SYD_NET_OVERTIME; + } + + ret = recv(fd, buf + recv_bytes, len - recv_bytes, MSG_NOSIGNAL|MSG_DONTWAIT); + if(ret < 0) + { + if(errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) + { + continue; + } + LOG_NET("recv err ret=%08x", SYD_NET_RECV_ERR); + return SYD_NET_RECV_ERR; + } + else if(ret == 0) + { + LOG_NET("recv err ret=%08x", SYD_NET_NOBLOCK_CLOSE); + return SYD_NET_NOBLOCK_CLOSE; + } + recv_bytes += ret; + } + return SYD_OK; +} + +#if 0 +int socket_recv_noblock(int fd, char* buf, int len, struct timeval start_time, int deal_time) +{ + if (NULL == buf || len < 0) + { + return SYD_NET_PARAM_ERR; + } + + struct timeval local_time; + int ret = 0, recv_bytes = 0; //已接受的字节数 + while (recv_bytes < len) + { + gettimeofday(&local_time, NULL); + if(deal_time < ms_difftime(start_time, local_time)) + { + LOG_NET("socket_recv_noblock overtime ret=%08x", SYD_NET_OVERTIME); + return SYD_NET_OVERTIME; + } + + ret = recv(fd, buf + recv_bytes, 1, MSG_NOSIGNAL|MSG_DONTWAIT); + if(ret < 0) + { + if(errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) + { + continue; + } + LOG_NET("recv err ret=%08x", SYD_NET_RECV_ERR); + return SYD_NET_RECV_ERR; + } + else if(ret == 0) + { + LOG_NET("recv err ret=%08x", SYD_NET_NOBLOCK_CLOSE); + return SYD_NET_NOBLOCK_CLOSE; + } + recv_bytes += ret; + } + return SYD_OK; +} +#endif + +void socket_close_noblock(int fd) +{ + if(fd != -1) + { + close(fd); + } +} \ No newline at end of file diff --git a/src/public.c b/src/public.c new file mode 100644 index 0000000..cb3ccdd --- /dev/null +++ b/src/public.c @@ -0,0 +1,71 @@ +#ifndef _TYPEDEF_H_ +#include "typedef.h" +#endif + +#ifndef _PUBLIC_H_ +#include "public.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +static const char g_cHexToAsc1[] = "0123456789ABCDEF"; + +static int g_iTable_ASC_HEX[] = +{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f +}; + +void P_BinToHex( + char* pcInBuf, + int iInBufLen, + char* pcOutBuf) +{ + for (; iInBufLen > 0; iInBufLen--) + { + (*pcOutBuf++) = g_cHexToAsc1[((*pcInBuf) >> 4) & 0xf]; + (*pcOutBuf++) = g_cHexToAsc1[(*pcInBuf++) & 0xf]; + } +} + +void P_HexToBin( + char* pcInBuf, + int iInBufLen, + char* pcOutBuf) +{ + for (; iInBufLen > 0; iInBufLen -= 2, pcInBuf += 2) + { + (*pcOutBuf++) = (g_iTable_ASC_HEX[(*pcInBuf)] << 4) | g_iTable_ASC_HEX[*(pcInBuf + 1)]; + } +} + +int P_GetWorkPath(char *pcWorkPath) +{ + int iCount = -1, i = 0; + char cWorkPath[1024] = {0}; + iCount = readlink("/proc/self/exe", cWorkPath, 1024); + if (iCount < 0 || iCount >= 1024) + { + LOG("iCount=%d ret=%08x", iCount, -1); + return SYD_FAIL; + } + cWorkPath[iCount] = '\0'; + + for (i = iCount; i >= 0; --i) + { + if (cWorkPath[i] == '/') + { + cWorkPath[i] = 0; + break; + } + } + memcpy(pcWorkPath, cWorkPath, strlen(cWorkPath)); + return SYD_OK; +} diff --git a/src/queue.c b/src/queue.c new file mode 100644 index 0000000..179940f --- /dev/null +++ b/src/queue.c @@ -0,0 +1,141 @@ +#ifndef _QUEUE_H_ +#include "queue.h" +#endif + +#ifndef _TYPEDEF_H_ +#include "typedef.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +#define QUEUE_HANDLE_FAIL 0 +#define QUEUE_HANDLE_OK 1 + +queue_t* queue_init(int capacity) +{ + queue_t* queue = (queue_t*)malloc(sizeof(queue_t)); + if (queue == NULL) + { + LOG("malloc queue err ret=%08x", SYD_MEMORY_ERR); + return NULL; + } + memset(queue, 0, sizeof(queue_t)); + + queue->task = (task_t*)malloc(sizeof(task_t) * capacity); + if (queue->task == NULL) + { + LOG("malloc task err ret=%08x", SYD_MEMORY_ERR); + return NULL; + } + memset(queue->task, 0, sizeof(task_t) * capacity); + + queue->head = 0; + queue->tail = 0; + queue->length = 0; + queue->capacity = capacity; + queue->status = QUEUE_HANDLE_OK; + return queue; +} + +void queue_destory(queue_t* queue) +{ + if (queue == NULL) + { + return; + } + + if (queue->task != NULL) + { + free(queue->task); + queue->task = NULL; + } + queue->status = QUEUE_HANDLE_FAIL; + free(queue); + queue = NULL; +} + +void queue_clear(queue_t* queue) +{ + queue->head = 0; + queue->tail = 0; + queue->length = 0; +} + +int queue_getlength(queue_t* queue) +{ + if (queue == NULL) + { + LOG("queue == NULL ret=%04x", SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if (queue->status != QUEUE_HANDLE_OK) + { + LOG("queue->status != QUEUE_HANDLE_OK ret=%08x", SYD_QUEUE_HANDLE_ERR); + return SYD_QUEUE_HANDLE_ERR; + } + return AO_GET(&queue->length); +} + +int queue_enqueue(queue_t* queue, int* (*function)(void* arg, void *device), void *arg, void *device) +{ + if (queue == NULL) + { + LOG("queue == NULL ret=%04x", SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if (queue->status != QUEUE_HANDLE_OK) + { + LOG("queue->status != QUEUE_HANDLE_OK ret=%08x", SYD_QUEUE_HANDLE_ERR); + return SYD_QUEUE_HANDLE_ERR; + } + + /*队列是否已满*/ + if (AO_GET(&queue->length) == queue->capacity) + { + //LOG("queue is full ret=%04x", SYD_QUEUE_ISFULL); + return SYD_QUEUE_ISFULL; + } + + queue->task[queue->tail].function = function; + queue->task[queue->tail].arg = arg; + queue->task[queue->tail].device = device; + queue->tail = (queue->tail + 1) % queue->capacity; + AO_F_ADD(&queue->length, 1); + return SYD_OK; +} + +int queue_dequeue(queue_t* queue, int* (*function)(void* arg, void *device), void *arg, void *device) +{ + if (queue == NULL) + { + LOG("queue == NULL ret=%04x", SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if (queue->status != QUEUE_HANDLE_OK) + { + LOG("queue->status != QUEUE_HANDLE_OK ret=%08x", SYD_QUEUE_HANDLE_ERR); + return SYD_QUEUE_HANDLE_ERR; + } + + /*队列是否为空*/ + if (AO_GET(&queue->length) == 0) + { + //LOG("queue is empty ret=%04x", SYD_QUEUE_ISEMPTY); + return SYD_QUEUE_ISEMPTY; + } + + function = queue->task[queue->head].function; + arg = queue->task[queue->head].arg; + device = queue->task[queue->head].device; + queue->head = (queue->head + 1) % queue->capacity; + AO_F_SUB(&queue->length, 1); + return SYD_OK; +} + + + diff --git a/src/sunyard.c b/src/sunyard.c new file mode 100644 index 0000000..43c6e49 --- /dev/null +++ b/src/sunyard.c @@ -0,0 +1,2076 @@ +#ifndef _SUNYARD_H_ +#include "sunyard.h" +#endif + +#ifndef _SUNYARD_D_H_ +#include "sunyard_d.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +static int g_iDllInitFlag = P_DLL_INIT_OK; +static __attribute__ ((constructor))void _init(void); +static __attribute__ ((destructor)) void _fini(void); + +static const char g_cHexToAsc1[] = "0123456789ABCDEF"; +static int g_iTable_ASC_HEX[] = +{ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f +}; + +void _init(void) +{ + /*初始化日志锁*/ + Log_MutexInit(); + + /*初始化日志登记（默认开启一级网络层日志）*/ + Log_SetAttribute(LOG_OPEN, LOG_LEVEL_ONE); + + /*动态库初始化成功标志*/ + g_iDllInitFlag = P_DLL_INIT_OK; +} + +void _fini(void) +{ + if(g_iDllInitFlag == P_DLL_INIT_OK) + { + /*销毁日志锁*/ + Log_MutexDestory(); + } + g_iDllInitFlag = P_DLL_INIT_FAIL; +} + +void ModifyPathSpecChar(char* pcFilePath, int iFilePathLen, char *pcFileDealPath, int *piFileDealPathLen) +{ + char cFilePath[2048] = { 0 }; + memcpy(cFilePath, pcFilePath, iFilePathLen); + int iSpecChar = 0; + iSpecChar = iFilePathLen - 1; + if (cFilePath[iSpecChar] == '/') + { + memcpy(pcFileDealPath, cFilePath, iSpecChar); + *piFileDealPathLen = iSpecChar; + } + else + { + memcpy(pcFileDealPath, pcFilePath, iFilePathLen); + *piFileDealPathLen = iFilePathLen; + } +} + +DLL_DECLARE int DEVAPI SYD_SetLogConfig( + const char *pcLogPath, + int iLogPathLen, + int iLogLevel) +{ + if(pcLogPath == NULL) + { + printf("pcLogPath == NULL ret=%08x\n", SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iLogPathLen == 0) + { + printf("iLogPathLen = 0 ret=%08x\n", SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + char cDealLogPath[2048] = {0}; + int iDealLogPath = 0; + ModifyPathSpecChar((char *)pcLogPath, iLogPathLen, cDealLogPath, &iDealLogPath); + Log_Init(cDealLogPath); + + switch(iLogLevel) + { + case 0: //关闭日志 + Log_SetAttribute(LOG_CLOSE, LOG_LEVEL_ONE); + break; + case 1: //记录网络错误日志 + Log_SetAttribute(LOG_OPEN, LOG_LEVEL_NET); + break; + case 2: //记录错误日志 + Log_SetAttribute(LOG_OPEN, LOG_LEVEL_ONE); + break; + case 3: //记录所有日志 + Log_SetAttribute(LOG_OPEN, LOG_LEVEL_TWO); + break; + default: + printf("iLogLevel=%d ret=%08x\n", iLogLevel, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_Connect_Ex( + const char *pcIpList[], + int iPortList[], + int iSize, + int iConnectTimeout, + int iDealTimeOut, + int iThreadCount, + void** phHandle) +{ + if(iSize > P_DEVICE_MAX_COUNT || iSize <= 0) + { + LOG("iSize=%d ret=%08x", iSize, SYD_DEVICE_NUM_ERR); + return SYD_DEVICE_NUM_ERR; + } + + if(pcIpList == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0, i = 0; + for(i = 0; i < iSize; i++) + { + if(pcIpList[i] == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + LOG_TWO("pcIpList[%d]=%s", i, pcIpList[i]); + LOG_TWO("iPortList[%d]=%d", i, iPortList[i]); + } + LOG_TWO("iSize=%d", iSize); + LOG_TWO("iConnectTimeout=%d", iConnectTimeout); + LOG_TWO("iDealTimeOut=%d", iDealTimeOut); + LOG_TWO("iThreadCount=%d", iThreadCount); + + for(i = 0; i < iSize; i++) + { + if(iPortList[i] <= 1024 || iPortList[i] > 65535) + { + LOG("iPortList[%d]=%d ret=%08x", i, iPortList[i], SYD_DEVICE_PORT_ERR); + return SYD_DEVICE_PORT_ERR; + } + } + + if(iConnectTimeout <= 0 || iDealTimeOut <= 0) + { + LOG("iConnectTimeout=%d iDealTimeOut=%d ret=%08x", iConnectTimeout, iDealTimeOut, SYD_DEVICE_TIMEOUT_ERR); + return SYD_DEVICE_TIMEOUT_ERR; + } + + if(iThreadCount < 0 || iThreadCount > P_THREADPOOL_MAX_COUNT) + { + LOG("iThreadCount=%d ret=%08x", iThreadCount, SYD_THREADPOOL_COUNT_ERROR); + return SYD_THREADPOOL_COUNT_ERROR; + } + + ret = SYD_D_Connect_Ex(pcIpList, iPortList, iSize, iConnectTimeout, iDealTimeOut, iThreadCount, phHandle); + if(ret != SYD_OK) + { + LOG("SYD_D_Connect_Ex ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_Connect_Ex Success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_DisConnect_Ex( + void* phHandle) +{ + int ret = 0; + ret = SYD_D_DisConnect_Ex(phHandle); + if(ret != SYD_OK) + { + LOG("SYD_D_DisConnect_Ex ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_DisConnect_Ex Success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_GetVersionInfo( + void* phHandle, + char* pcVersion, + int* piVersionLen) +{ + if(pcVersion == NULL || piVersionLen == NULL) + { + LOG("point is null", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0; + char tmp_version[MIN_LIN] = {0}; + char client_version[] = {"1.00.11"}; + char server_version[16] = {0}; + int server_version_len = 0; + ret = SYD_D_GetServerVersion(phHandle, server_version, &server_version_len); + if(ret != SYD_OK) + { + LOG("SYD_D_GetServerVersion ret=%08x", ret); + return ret; + } + + sprintf(tmp_version, "server:%s\nlibsunyard.so:%s\n", server_version, client_version); + if(*piVersionLen < strlen(tmp_version)) + { + LOG("piVersionLen err", SYD_OUTDATA_LEN_ERR); + return SYD_OUTDATA_LEN_ERR; + } + strcpy(pcVersion, tmp_version); + *piVersionLen = strlen(tmp_version); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iFlag, + char* pcOutData, + int* piOutDataLen) +{ + if(iKeyIndex < 0) + { + LOG("iKeyIndex=%d ret=%08x", iKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData == NULL || piOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iFlag != SM4_ENCRYPT && iFlag != SM4_DECRYPT) + { + LOG("iFlag=%d ret=%08x", iFlag, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iFlag == SM4_ENCRYPT) + { + if(iDataLen <= 0 || iDataLen > 1024) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + else + { + if(iDataLen <= 0 || iDataLen > 1024 + 16) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iDataLen % 16 != 0) + { + LOG("iDataLen err ret=%08x", SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + + int ret = 0; + ret = SYD_D_SM4_ShortData(phHandle, iKeyIndex, pcData, iDataLen, iFlag, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_ShortData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_ShortData Success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_LongDataInit( + int iKeyIndex, + int iFlag, + void** phProcHandle) +{ + if(iKeyIndex < 0) + { + LOG("iKeyIndex=%d ret=%08x", iKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iFlag != SM4_ENCRYPT && iFlag != SM4_DECRYPT) + { + LOG("iFlag=%d ret=%08x", iFlag, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + STC_D_HANDLE *m_handle = (STC_D_HANDLE *)malloc(sizeof(STC_D_HANDLE)); + if (m_handle == NULL) + { + LOG("m_handle null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle, 0, sizeof(STC_D_HANDLE)); + + m_handle->sm4_encdec_info = (STC_SM4_ENCDEC_INFO *)malloc(sizeof(STC_SM4_ENCDEC_INFO)); + if(m_handle->sm4_encdec_info == NULL) + { + LOG("m_handle->sm4_encdec_info null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle->sm4_encdec_info, 0, sizeof(STC_SM4_ENCDEC_INFO)); + + m_handle->sm4_encdec_info->keyidex = iKeyIndex; + m_handle->sm4_encdec_info->flag = iFlag; + m_handle->sm4_encdec_info->initflag = P_DATA_INIT; + m_handle->sm4_encdec_info->status = P_HANDLE_OK; + m_handle->iHandleType = P_HANDLE_SM4_ENCDEC; + m_handle->iStatus = P_HANDLE_OK; + *phProcHandle = (void *)m_handle; + LOG_MSG("SYD_SM4_LongDataInit success"); + return SYD_OK; +} + +static int SYD_SM4_EncryptUpdate( + void* phHandle, + char* pcData, + int iDataLen, + char* pcOutData, + int* piOutDataLen, + STC_SM4_ENCDEC_INFO *sm4_enc_info) +{ + int ret = 0; + char *p_enc = NULL; + int alldatalen = 0; + int tmpencdatalen = MAX_LIN * 8; + + /*上一包无多余字节*/ + if(sm4_enc_info->procdatalen == 0) + { + if (iDataLen < 16) // < 16 + { + memcpy(sm4_enc_info->procdata, pcData, iDataLen); + sm4_enc_info->procdatalen = iDataLen; + *piOutDataLen = 0; + } + else if(iDataLen / 16 > 0 && iDataLen % 16 == 0) // >= 16且满足16的倍数 + { + ret = SYD_D_SM4_LongData(phHandle, sm4_enc_info->keyidex, pcData, iDataLen, PKG_MIDDLE, sm4_enc_info->flag, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + memset(sm4_enc_info->procdata, 0, sizeof(sm4_enc_info->procdata)); + sm4_enc_info->procdatalen = 0; + } + else // > 16且不满足16的倍数 + { + ret = SYD_D_SM4_LongData(phHandle, sm4_enc_info->keyidex, pcData, iDataLen - (iDataLen % 16), PKG_MIDDLE, sm4_enc_info->flag, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + sm4_enc_info->procdatalen = iDataLen % 16; + memcpy(sm4_enc_info->procdata, pcData + (iDataLen - sm4_enc_info->procdatalen), sm4_enc_info->procdatalen); + } + } + /*上一包有多余字节*/ + else + { + alldatalen = iDataLen + sm4_enc_info->procdatalen; + if(alldatalen < 16) // < 16 + { + memcpy(sm4_enc_info->procdata + sm4_enc_info->procdatalen, pcData, iDataLen); + sm4_enc_info->procdatalen = alldatalen; + *piOutDataLen = 0; + } + else if(alldatalen / 16 > 0 && alldatalen % 16 == 0) // >= 16且满足16的倍数 + { + p_enc = pcOutData; + memcpy(sm4_enc_info->procdata + sm4_enc_info->procdatalen, pcData, 16 - sm4_enc_info->procdatalen); + ret = SYD_D_SM4_LongData(phHandle, sm4_enc_info->keyidex, sm4_enc_info->procdata, 16, PKG_MIDDLE, sm4_enc_info->flag, p_enc, &tmpencdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + p_enc += tmpencdatalen; + + if(alldatalen != 16) + { + tmpencdatalen = MAX_LIN * 8; + ret = SYD_D_SM4_LongData(phHandle, sm4_enc_info->keyidex, pcData + (16 - sm4_enc_info->procdatalen), iDataLen - (16 - sm4_enc_info->procdatalen), PKG_MIDDLE, sm4_enc_info->flag, p_enc, &tmpencdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + } + *piOutDataLen = alldatalen; + memset(sm4_enc_info->procdata, 0, sizeof(sm4_enc_info->procdata)); + sm4_enc_info->procdatalen = 0; + } + else // > 16且不满足16的倍数 + { + p_enc = pcOutData; + memcpy(sm4_enc_info->procdata + sm4_enc_info->procdatalen, pcData, 16 - sm4_enc_info->procdatalen); + ret = SYD_D_SM4_LongData(phHandle, sm4_enc_info->keyidex, sm4_enc_info->procdata, 16, PKG_MIDDLE, sm4_enc_info->flag, p_enc, &tmpencdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + p_enc += tmpencdatalen; + + if ((alldatalen - 16) > 16) + { + tmpencdatalen = MAX_LIN * 8; + ret = SYD_D_SM4_LongData(phHandle, sm4_enc_info->keyidex, pcData + (16 - sm4_enc_info->procdatalen), alldatalen - 16 - (alldatalen % 16), PKG_MIDDLE, sm4_enc_info->flag, p_enc, &tmpencdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + } + *piOutDataLen = alldatalen - (alldatalen % 16); + memcpy(sm4_enc_info->procdata, pcData + (iDataLen - (alldatalen % 16)), alldatalen % 16); + sm4_enc_info->procdatalen = alldatalen % 16; + } + } + return SYD_OK; +} + +static int SYD_SM4_DecryptUpdate( + void* phHandle, + char* pcData, + int iDataLen, + char* pcOutData, + int* piOutDataLen, + STC_SM4_ENCDEC_INFO *sm4_dec_info) +{ + int ret = 0, i = 0; + int decloopnum = 0; + int tmpdatalen = MAX_LIN * 8; + int alltmpdatalen = 0; + + /*上一包无多余数据*/ + if(sm4_dec_info->procdatalen <= 0) + { + // 1)解密字节小于等于16，保存在缓冲区中 + if (iDataLen <= 16) + { + memcpy(sm4_dec_info->procdata, pcData, iDataLen); + sm4_dec_info->procdatalen = iDataLen; + *piOutDataLen = 0; + return SYD_OK; + } + // 2)解密字节大于16, 若加密字节满足16的倍数，输出拼接后的密文。 不满足则输出拼接的密文后，保存多余字节 + else + { + if (iDataLen % 16 == 0) + { + decloopnum = iDataLen / 16 - 1; //保存最后16字节 + } + else + { + decloopnum = iDataLen / 16; + } + + if(decloopnum != 0) + { + ret = SYD_D_SM4_LongData(phHandle, sm4_dec_info->keyidex, pcData, decloopnum * 16, PKG_MIDDLE, sm4_dec_info->flag, pcOutData, &tmpdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + } + *piOutDataLen = 16 * decloopnum; + memset(sm4_dec_info->procdata, 0, sizeof(sm4_dec_info->procdata)); + + //满足16的倍数，保存最后16字节 + if(iDataLen % 16 == 0) + { + memcpy(sm4_dec_info->procdata, pcData + (decloopnum * 16), 16); + sm4_dec_info->procdatalen = 16; + } + //不满足16的倍数，保存多余部分 + else + { + memcpy(sm4_dec_info->procdata, pcData + (decloopnum * 16), iDataLen % 16); + sm4_dec_info->procdatalen = iDataLen % 16; + } + } + } + /*上一包有多余数据*/ + else + { + if (sm4_dec_info->procdatalen == 16) + { + //解密缓冲区数据 + ret = SYD_D_SM4_LongData(phHandle, sm4_dec_info->keyidex, sm4_dec_info->procdata, sm4_dec_info->procdatalen, PKG_MIDDLE, sm4_dec_info->flag, pcOutData, &tmpdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + //清空缓冲区 + memset(sm4_dec_info->procdata, 0, sizeof(sm4_dec_info->procdata)); + sm4_dec_info->procdatalen = 0; + + //保存在缓冲区中 + if (iDataLen <= 16) + { + memcpy(sm4_dec_info->procdata, pcData, iDataLen); + sm4_dec_info->procdatalen = iDataLen; + *piOutDataLen = 16; + return SYD_OK; + } + //解密前16倍数，保存多余字节 + else + { + if (iDataLen % 16 == 0) + { + decloopnum = iDataLen / 16 - 1; + } + else + { + decloopnum = iDataLen / 16; + } + + if(decloopnum != 0) + { + tmpdatalen = MAX_LIN * 8; + ret = SYD_D_SM4_LongData(phHandle, sm4_dec_info->keyidex, pcData, decloopnum * 16, PKG_MIDDLE, sm4_dec_info->flag, pcOutData + 16, &tmpdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + } + *piOutDataLen = 16 + (decloopnum * 16); + + if (iDataLen % 16 == 0) + { + memcpy(sm4_dec_info->procdata, pcData + (decloopnum * 16), 16); + sm4_dec_info->procdatalen = 16; + } + else + { + memcpy(sm4_dec_info->procdata, pcData + (decloopnum * 16), iDataLen % 16); + sm4_dec_info->procdatalen = iDataLen % 16; + } + return SYD_OK; + } + } + else if(sm4_dec_info->procdatalen < 16) + { + if(iDataLen < 16) + { + //总字节数 + alltmpdatalen = iDataLen + sm4_dec_info->procdatalen; + //解密16字节 + if(alltmpdatalen > 16) + { + memcpy(sm4_dec_info->procdata + sm4_dec_info->procdatalen, pcData, 16 - sm4_dec_info->procdatalen); + ret = SYD_D_SM4_LongData(phHandle, sm4_dec_info->keyidex, sm4_dec_info->procdata, 16, PKG_MIDDLE, sm4_dec_info->flag, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + memset(sm4_dec_info->procdata, 0, sizeof(sm4_dec_info->procdatalen)); + memcpy(sm4_dec_info->procdata, pcData + (16 - sm4_dec_info->procdatalen), iDataLen - (16 - sm4_dec_info->procdatalen)); + sm4_dec_info->procdatalen = iDataLen - (16 - sm4_dec_info->procdatalen); + return SYD_OK; + } + else + { + memcpy(sm4_dec_info->procdata + sm4_dec_info->procdatalen, pcData, iDataLen); + sm4_dec_info->procdatalen = sm4_dec_info->procdatalen + iDataLen; + *piOutDataLen = 0; + return SYD_OK; + } + } + else + { + //先解密16字节 + memcpy(sm4_dec_info->procdata + sm4_dec_info->procdatalen, pcData, 16 - sm4_dec_info->procdatalen); + ret = SYD_D_SM4_LongData(phHandle, sm4_dec_info->keyidex, sm4_dec_info->procdata, 16, PKG_MIDDLE, sm4_dec_info->flag, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + //清空缓冲区 + memset(sm4_dec_info->procdata, 0, sizeof(sm4_dec_info->procdata)); + + //剩余字节数 + alltmpdatalen = iDataLen - (16 - sm4_dec_info->procdatalen); + if(alltmpdatalen % 16 == 0) + { + decloopnum = alltmpdatalen / 16 - 1; + } + else + { + decloopnum = alltmpdatalen / 16; + } + + if(decloopnum != 0) + { + tmpdatalen = MAX_LIN * 8; + //解密16的整数倍 + ret = SYD_D_SM4_LongData(phHandle, sm4_dec_info->keyidex, pcData + (16 - sm4_dec_info->procdatalen), decloopnum * 16, PKG_MIDDLE, sm4_dec_info->flag, pcOutData + 16, &tmpdatalen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + } + *piOutDataLen = 16 + decloopnum * 16; + + //保存剩余字节 + if(alltmpdatalen % 16 == 0) + { + memcpy(sm4_dec_info->procdata, pcData + ((16 - sm4_dec_info->procdatalen) + (decloopnum * 16)), 16); + sm4_dec_info->procdatalen = 16; + } + else + { + memcpy(sm4_dec_info->procdata, pcData + ((16 - sm4_dec_info->procdatalen) + (decloopnum * 16)), alltmpdatalen % 16); + sm4_dec_info->procdatalen = alltmpdatalen % 16; + } + } + } + } + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_LongDataUpdate( + void* phHandle, + char* pcData, + int iDataLen, + char* pcOutData, + int* piOutDataLen, + void* phProcHandle) +{ + if(pcData == NULL || pcOutData == NULL || piOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0; + STC_SM4_ENCDEC_INFO *sm4_info = NULL; + ret = SYD_D_AnalysisDevHandle(phProcHandle, P_HANDLE_SM4_ENCDEC, (void **)&sm4_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm4_info->initflag != P_DATA_INIT) + { + LOG("sm4_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + if(sm4_info->flag == SM4_ENCRYPT) + { + if(iDataLen < 0 || iDataLen > 6144) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + ret = SYD_SM4_EncryptUpdate(phHandle, pcData, iDataLen, pcOutData, piOutDataLen, sm4_info); + if(ret != SYD_OK) + { + LOG("SYD_SM4_EncryptUpdate Error ret=%08x", ret); + return ret; + } + } + else + { + if(iDataLen < 0 || iDataLen > 6144 + 16) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + ret = SYD_SM4_DecryptUpdate(phHandle, pcData, iDataLen, pcOutData, piOutDataLen, sm4_info); + if(ret != SYD_OK) + { + LOG("SYD_SM4_DecryptUpdate Error ret=%08x", ret); + return ret; + } + } + LOG_MSG("SYD_SM4_LongDataUpdate success"); + return SYD_OK; +} + +static int SYD_SM4_EncryptFinal( + void* phHandle, + char* pcOutData, + int* piOutDataLen, + STC_SM4_ENCDEC_INFO* sm4_enc_info) +{ + int ret = 0; + ret = SYD_D_SM4_LongData(phHandle, sm4_enc_info->keyidex, sm4_enc_info->procdata, sm4_enc_info->procdatalen, PKG_LAST, sm4_enc_info->flag, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + return SYD_OK; +} + +static int SYD_SM4_DecryptFinal( + void* phHandle, + char* pcOutData, + int* piOutDataLen, + STC_SM4_ENCDEC_INFO* sm4_dec_info) +{ + int ret = 0; + if(sm4_dec_info->procdatalen == 0 || sm4_dec_info->procdatalen % 16 != 0) + { + LOG("sm4_dec_info->procdatalen=%d ret=%08x", sm4_dec_info->procdatalen, SYD_DECRYPT_DATALEN_ERROR); + return SYD_DECRYPT_DATALEN_ERROR; + } + + ret = SYD_D_SM4_LongData(phHandle, sm4_dec_info->keyidex, sm4_dec_info->procdata, sm4_dec_info->procdatalen, PKG_LAST, sm4_dec_info->flag, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_LongData ret=%08x", ret); + return ret; + } + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_LongDataFinal( + void* phHandle, + char* pcOutData, + int* piOutDataLen, + void* phProcHandle) +{ + if(pcOutData == NULL || piOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0; + STC_SM4_ENCDEC_INFO *sm4_info = NULL; + ret = SYD_D_AnalysisDevHandle(phProcHandle, P_HANDLE_SM4_ENCDEC, (void **)&sm4_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm4_info->initflag != P_DATA_INIT) + { + LOG("sm4_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + if(sm4_info->flag == SM4_ENCRYPT) + { + ret = SYD_SM4_EncryptFinal(phHandle, pcOutData, piOutDataLen, sm4_info); + if(ret != SYD_OK) + { + LOG("SYD_SM4_EncryptFinal Error ret=%08x", ret); + return ret; + } + } + else + { + ret = SYD_SM4_DecryptFinal(phHandle, pcOutData, piOutDataLen, sm4_info); + if(ret != SYD_OK) + { + LOG("SYD_SM4_DecryptFinal Error ret=%08x", ret); + return ret; + } + } + sm4_info->initflag = P_DATA_FINAL; + LOG_MSG("SYD_SM4_LongDataFinal success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_CloseHandle( + void *hHandle) +{ + int ret = 0; + if(hHandle == NULL) + { + LOG("handle == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + + STC_D_HANDLE* pHandle = (STC_D_HANDLE*)hHandle; + if (pHandle->iStatus != P_HANDLE_OK) + { + LOG("pHandle->uiStatus != SYD_P_HADNLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + + /*不允许在这里销毁连接句柄，断开连接的时候会自动销毁的*/ + if(pHandle->iHandleType == P_HANDLE_DEV) + { + LOG("pHandle->iHandleType == P_HANDLE_DEV ret=%08x", SYD_HANDLE_TYPE_ERROR); + return SYD_HANDLE_TYPE_ERROR; + } + + ret = SYD_D_CloseHandle(hHandle); + if(ret != SYD_OK) + { + LOG("SYD_D_CloseHandle ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_CloseHandle success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_BatchData( + void* phHandle, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + int iFlag, + char* pcOutData[], + int iOutDataLen[]) +{ + int ret = 0, i = 0; + + /* 客户要求如果pcData为NULL不报错，返回正确 */ + if(pcData == NULL || iSize == 0) + { + /* 不做处理直接返回正确 */ + return SYD_OK; + } + + if(iKeyIndex == NULL || iDataLen == NULL || pcOutData == NULL || iOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iFlag != SM4_ENCRYPT && iFlag != SM4_DECRYPT) + { + LOG("iFlag=%d ret=%08x", iFlag, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + for(i = 0; i < iSize; i++) + { + if(iKeyIndex[i] < 0) + { + LOG("iKeyIndex[%d]=%d ret=%08x", i, iKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData[i] == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iFlag == SM4_ENCRYPT) + { + if(iDataLen[i] <= 0 || iDataLen[i] > 1024) + { + LOG("iDataLen[%d]=%d ret=%08x", i, iDataLen[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + else + { + if(iDataLen[i] <= 0 || iDataLen[i] > 1024 + 16) + { + LOG("iDataLen[%d]=%d ret=%08x", i, iDataLen[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + } + + ret = SYD_D_SM4_Data(phHandle, iKeyIndex, pcData, iDataLen, iSize, iFlag, pcOutData, iOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_Data ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_BatchData Success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_ShortData( + void* phHandle, + char* pcData, + int iDataLen, + char* pcHash) +{ + if(pcData == NULL || pcHash == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen < 0 || iDataLen > 1024) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + ret = SYD_D_SM3_Hash_LongData(phHandle, pcData, iDataLen, PKG_ONLY_ONE, NULL, NULL, pcHash); + if(ret != SYD_OK) + { + LOG("SYD_D_SM3_Hash_ShortData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM3_Hash_ShortData Success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_Init( + void** phHash) +{ + STC_D_HANDLE *m_handle = (STC_D_HANDLE *)malloc(sizeof(STC_D_HANDLE)); + if (m_handle == NULL) + { + LOG("m_handle null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle, 0, sizeof(STC_D_HANDLE)); + + m_handle->sm3_hash_info = (STC_SM3_HASH_INFO *)malloc(sizeof(STC_SM3_HASH_INFO)); + if(m_handle->sm3_hash_info == NULL) + { + LOG("m_handle->sm3_hash_info null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle->sm3_hash_info, 0, sizeof(STC_SM3_HASH_INFO)); + + m_handle->sm3_hash_info->status = P_HANDLE_OK; + m_handle->sm3_hash_info->firstflag = TRUE; + m_handle->sm3_hash_info->initflag = P_DATA_INIT; + m_handle->iHandleType = P_HANDLE_SM3_HASH; + m_handle->iStatus = P_HANDLE_OK; + *phHash = (void *)m_handle; + LOG_MSG("SYD_SM3_Hash_Init success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_Update( + void* phHandle, + char* pcData, + int iDataLen, + void* phHash) +{ + if(pcData == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen < 0 || iDataLen > 6144) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + STC_SM3_HASH_INFO *sm3_hash_info = NULL; + ret = SYD_D_AnalysisDevHandle(phHash, P_HANDLE_SM3_HASH, (void **)&sm3_hash_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm3_hash_info->initflag != P_DATA_INIT) + { + LOG("sm3_hash_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + if(sm3_hash_info->firstflag == TRUE) + { + ret = SYD_D_SM3_Hash_LongData(phHandle, pcData, iDataLen, PKG_FIRST, sm3_hash_info->procdata, &sm3_hash_info->procdatalen, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM3_Hash_LongData ret=%08x", ret); + return ret; + } + sm3_hash_info->firstflag = FALSE; + } + else + { + ret = SYD_D_SM3_Hash_LongData(phHandle, pcData, iDataLen, PKG_MIDDLE, sm3_hash_info->procdata, &sm3_hash_info->procdatalen, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM3_Hash_LongData ret=%08x", ret); + return ret; + } + } + LOG_MSG("SYD_SM3_Hash_Update success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM3_Hash_Final( + void* phHandle, + char* pcHash, + void* phHash) +{ + if(pcHash == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0; + STC_SM3_HASH_INFO *sm3_hash_info = NULL; + ret = SYD_D_AnalysisDevHandle(phHash, P_HANDLE_SM3_HASH, (void **)&sm3_hash_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm3_hash_info->initflag != P_DATA_INIT) + { + LOG("sm3_hash_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + char tmpData[MIN_LIN] = {0}; + if(sm3_hash_info->firstflag == TRUE) + { + ret = SYD_D_SM3_Hash_LongData(phHandle, tmpData, 0, PKG_ONLY_ONE, NULL, NULL, pcHash); + if(ret != SYD_OK) + { + LOG("SYD_D_SM3_Hash_LongData ret=%08x", ret); + return ret; + } + } + else + { + ret = SYD_D_SM3_Hash_LongData(phHandle, tmpData, 0, PKG_LAST, sm3_hash_info->procdata, &sm3_hash_info->procdatalen, pcHash); + if(ret != SYD_OK) + { + LOG("SYD_D_SM3_Hash_LongData ret=%08x", ret); + return ret; + } + } + sm3_hash_info->initflag = P_DATA_FINAL; + LOG_MSG("SYD_SM3_Hash_Final success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4Mac_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + char* pcMac, + int* piCheckRet) +{ + if(iKeyIndex < 0) + { + LOG("iKeyIndex=%d ret=%08x", iKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData == NULL || pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen < 0 || iDataLen > 1024) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + ret = SYD_D_SM4Mac_ShortData(phHandle, iKeyIndex, pcData, iDataLen, pcMac, piCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_ShortData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_D_SM4Mac_ShortData Success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4Mac_BatchData( + void* phHandle, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcMac[], + int piCheckRet[]) +{ + int ret = 0, i = 0; + + /* 客户要求如果pcMac为NULL不报错，返回正确 */ + if(pcData == NULL || iSize == 0) + { + /* 不做处理直接返回正确 */ + return SYD_OK; + } + + if(iKeyIndex == NULL || iDataLen == NULL || pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + for(i = 0; i < iSize; i++) + { + if(iKeyIndex[i] < 0) + { + LOG("iKeyIndex[%d]=%d ret=%08x", i, iKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData[i] == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen[i] < 0 || iDataLen[i] > 1024) + { + LOG("iDataLen[%d]=%d ret=%08x", i, iDataLen[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + + ret = SYD_D_SM4Mac_BatchData(phHandle, iKeyIndex, pcData, iDataLen, iSize, pcMac, piCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_BatchData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4Mac_BatchData Success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4Mac_LongDataInit( + int iKeyIndex, + void** phMac) +{ + if(iKeyIndex < 0) + { + LOG("iKeyIndex=%d ret=%08x", iKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + STC_D_HANDLE *m_handle = (STC_D_HANDLE *)malloc(sizeof(STC_D_HANDLE)); + if (m_handle == NULL) + { + LOG("m_handle null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle, 0, sizeof(STC_D_HANDLE)); + + m_handle->sm4_mac_info = (STC_SM4_MAC_INFO *)malloc(sizeof(STC_SM4_MAC_INFO)); + if (m_handle->sm4_mac_info == NULL) + { + LOG("m_handle->sm4_mac_info null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle->sm4_mac_info, 0, sizeof(STC_SM4_MAC_INFO)); + + m_handle->sm4_mac_info->keyidex = iKeyIndex; + memset(m_handle->sm4_mac_info->iv, '0', sizeof(m_handle->sm4_mac_info->iv)); + m_handle->sm4_mac_info->ivlen = 32; + m_handle->sm4_mac_info->initflag = P_DATA_INIT; + m_handle->sm4_mac_info->status = P_HANDLE_OK; + m_handle->iHandleType = P_HANDLE_SM4_MAC; + m_handle->iStatus = P_HANDLE_OK; + *phMac = (void *)m_handle; + LOG_MSG("SYD_SM4Mac_LongDataInit success"); + return SYD_OK; +} + +static int SYD_SM4MAC_Update( + void* phHandle, + char* pcData, + int iDataLen, + STC_SM4_MAC_INFO *sm4_mac_info) +{ + int ret = 0; + int alldatalen = 0; + + /*上一包无多余字节*/ + if(sm4_mac_info->procdatalen == 0) + { + if (iDataLen < 16) // < 16 + { + memcpy(sm4_mac_info->procdata, pcData, iDataLen); + sm4_mac_info->procdatalen = iDataLen; + } + else if(iDataLen / 16 > 0 && iDataLen % 16 == 0) // >= 16且满足16的倍数 + { + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_mac_info->keyidex, pcData, iDataLen, PKG_MIDDLE, sm4_mac_info->iv, &sm4_mac_info->ivlen, NULL, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + memset(sm4_mac_info->procdata, 0, sizeof(sm4_mac_info->procdata)); + sm4_mac_info->procdatalen = 0; + } + else // > 16且不满足16的倍数 + { + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_mac_info->keyidex, pcData, iDataLen - (iDataLen % 16), PKG_MIDDLE, sm4_mac_info->iv, &sm4_mac_info->ivlen, NULL, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + sm4_mac_info->procdatalen = iDataLen % 16; + memcpy(sm4_mac_info->procdata, pcData + (iDataLen - sm4_mac_info->procdatalen), sm4_mac_info->procdatalen); + } + } + /*上一包有多余字节*/ + else + { + alldatalen = iDataLen + sm4_mac_info->procdatalen; + if(alldatalen < 16) // < 16 + { + memcpy(sm4_mac_info->procdata + sm4_mac_info->procdatalen, pcData, iDataLen); + sm4_mac_info->procdatalen = alldatalen; + } + else if(alldatalen / 16 > 0 && alldatalen % 16 == 0) // >= 16且满足16的倍数 + { + memcpy(sm4_mac_info->procdata + sm4_mac_info->procdatalen, pcData, 16 - sm4_mac_info->procdatalen); + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_mac_info->keyidex, sm4_mac_info->procdata, 16, PKG_MIDDLE, sm4_mac_info->iv, &sm4_mac_info->ivlen, NULL, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + + if(alldatalen != 16) + { + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_mac_info->keyidex, pcData + (16 - sm4_mac_info->procdatalen), iDataLen - (16 - sm4_mac_info->procdatalen), PKG_MIDDLE, sm4_mac_info->iv, &sm4_mac_info->ivlen, NULL, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + } + memset(sm4_mac_info->procdata, 0, sizeof(sm4_mac_info->procdata)); + sm4_mac_info->procdatalen = 0; + } + else // > 16且不满足16的倍数 + { + memcpy(sm4_mac_info->procdata + sm4_mac_info->procdatalen, pcData, 16 - sm4_mac_info->procdatalen); + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_mac_info->keyidex, sm4_mac_info->procdata, 16, PKG_MIDDLE, sm4_mac_info->iv, &sm4_mac_info->ivlen, NULL, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + + if ((alldatalen - 16) > 16) + { + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_mac_info->keyidex, pcData + (16 - sm4_mac_info->procdatalen), alldatalen - 16 - (alldatalen % 16), PKG_MIDDLE, sm4_mac_info->iv, &sm4_mac_info->ivlen, NULL, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + } + memcpy(sm4_mac_info->procdata, pcData + (iDataLen - (alldatalen % 16)), alldatalen % 16); + sm4_mac_info->procdatalen = alldatalen % 16; + } + } + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4Mac_LongDataUpdate( + void* phHandle, + char* pcData, + int iDataLen, + void* phMac) +{ + if(pcData == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen < 0 || iDataLen > 6144) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + STC_SM4_MAC_INFO *sm4_mac_info = NULL; + ret = SYD_D_AnalysisDevHandle(phMac, P_HANDLE_SM4_MAC, (void **)&sm4_mac_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm4_mac_info->initflag != P_DATA_INIT) + { + LOG("sm4_mac_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + ret = SYD_SM4MAC_Update(phHandle, pcData, iDataLen, sm4_mac_info); + if(ret != SYD_OK) + { + LOG("SYD_SM4MAC_Update Error ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4Mac_LongDataUpdate success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4Mac_LongDataFinal( + void* phHandle, + char* pcMac, + int* piCheckRet, + void* phMac) +{ + if(pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0; + STC_SM4_MAC_INFO *sm4_mac_info = NULL; + ret = SYD_D_AnalysisDevHandle(phMac, P_HANDLE_SM4_MAC, (void **)&sm4_mac_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm4_mac_info->initflag != P_DATA_INIT) + { + LOG("sm4_mac_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_mac_info->keyidex, sm4_mac_info->procdata, sm4_mac_info->procdatalen, PKG_LAST, sm4_mac_info->iv, &sm4_mac_info->ivlen, pcMac, piCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + sm4_mac_info->initflag = P_DATA_FINAL; + LOG_MSG("SYD_SM4Mac_LongDataFinal success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_Encrypt_Mac_ShortData( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcData, + int iDataLen, + char* pcEncData, + int* piEncDataLen, + char* pcMac) +{ + if(iEncKeyIndex < 0) + { + LOG("iEncKeyIndex=%d ret=%08x", iEncKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex < 0) + { + LOG("iCheckKeyIndex=%d ret=%08x", iCheckKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData == NULL || pcEncData == NULL || piEncDataLen == NULL || pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen <= 0 || iDataLen > 1024) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + ret = SYD_D_SM4_ShortData(phHandle, iEncKeyIndex, pcData, iDataLen, SM4_ENCRYPT, pcEncData, piEncDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_ShortData ret=%08x", ret); + return ret; + } + + ret = SYD_D_SM4Mac_ShortData(phHandle, iCheckKeyIndex, pcEncData, *piEncDataLen, pcMac, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_ShortData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Encrypt_Mac_ShortData success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_Decrypt_Mac_ShortData( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcEncData, + int iEncDataLen, + char* pcMac, + char* pcOutData, + int* piOutDataLen) +{ + if(iEncKeyIndex < 0) + { + LOG("iEncKeyIndex=%d ret=%08x", iEncKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex < 0) + { + LOG("iCheckKeyIndex=%d ret=%08x", iCheckKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcEncData == NULL || pcMac == NULL || piOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iEncDataLen <= 0 || iEncDataLen > 1024 + 16 || (iEncDataLen % 16) != 0) + { + LOG("iEncDataLen=%d ret=%08x", iEncDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + int check_ret = -1; + ret = SYD_D_SM4Mac_ShortData(phHandle, iCheckKeyIndex, pcEncData, iEncDataLen, pcMac, &check_ret); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_ShortData ret=%08x", ret); + return ret; + } + + if(check_ret != 0) + { + LOG("SYD_D_SM4Mac_ShortData ret=%08x", SYD_MAC_CHECK_ERROR); + return SYD_MAC_CHECK_ERROR; + } + + ret = SYD_D_SM4_ShortData(phHandle, iEncKeyIndex, pcEncData, iEncDataLen, SM4_DECRYPT, pcOutData, piOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_ShortData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Decrypt_Mac_ShortData success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_Encrypt_Mac_BatchData( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcEncData[], + int iEncDataLen[], + char* pcMac[]) +{ + int ret = 0, i = 0; + /* 客户要求如果pcData为NULL不报错，返回正确 */ + if(pcData == NULL || iSize == 0) + { + /* 不做处理直接返回正确 */ + return SYD_OK; + } + + if(iEncKeyIndex == NULL || iCheckKeyIndex == NULL || iDataLen == NULL \ + || pcEncData == NULL || iEncDataLen == NULL || pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + for(i = 0; i < iSize; i++) + { + if(iEncKeyIndex[i] < 0) + { + LOG("iEncKeyIndex[%d]=%d ret=%08x", i, iEncKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex[i] < 0) + { + LOG("iCheckKeyIndex[%d]=%d ret=%08x", i, iCheckKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData[i] == NULL || pcEncData[i] == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen[i] <= 0 || iDataLen[i] > 1024) + { + LOG("iDataLen[%d]=%d ret=%08x", i, iDataLen[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + + ret = SYD_D_SM4_BatchData(phHandle, iEncKeyIndex, pcData, iDataLen, iSize, SM4_ENCRYPT, pcEncData, iEncDataLen, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData ret=%08x", ret); + return ret; + } + + ret = SYD_D_SM4Mac_BatchData(phHandle, iCheckKeyIndex, pcEncData, iEncDataLen, iSize, pcMac, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_BatchData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Encrypt_Mac_BatchData success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_Decrypt_Mac_BatchData( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcEncData[], + int iEncDataLen[], + char* pcMac[], + int iSize, + char* pcOutData[], + int iOutDataLen[], + int iCheckRet[]) +{ + int ret = 0, i = 0; + /* 客户要求如果pcData为NULL不报错，返回正确 */ + if(pcEncData == NULL || iSize == 0) + { + /* 不做处理直接返回正确 */ + return SYD_OK; + } + + if(iEncKeyIndex == NULL || iCheckKeyIndex == NULL || iEncDataLen == NULL \ + || pcMac == NULL || pcOutData == NULL || iOutDataLen == NULL || iCheckRet == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + for(i = 0; i < iSize; i++) + { + if(iEncKeyIndex[i] < 0) + { + LOG("iEncKeyIndex[%d]=%d ret=%08x", i, iEncKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex[i] < 0) + { + LOG("iCheckKeyIndex[%d]=%d ret=%08x", i, iCheckKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcEncData[i] == NULL || pcMac[i] == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iEncDataLen[i] <= 0 || iEncDataLen[i] > (1024 + 16)) + { + LOG("iEncDataLen[%d]=%d ret=%08x", i, iEncDataLen[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + + ret = SYD_D_SM4Mac_BatchData(phHandle, iCheckKeyIndex, pcEncData, iEncDataLen, iSize, pcMac, iCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_BatchData ret=%08x", ret); + return ret; + } + + ret = SYD_D_SM4_BatchData(phHandle, iEncKeyIndex, pcEncData, iEncDataLen, iSize, SM4_DECRYPT, \ + pcOutData, iOutDataLen, iCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Decrypt_Mac_BatchData success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4EncDecMac_LongDataInit( + int iEncKeyIndex, + int iCheckKeyIndex, + int iFlag, + void** phProcHandle) +{ + if(iEncKeyIndex < 0) + { + LOG("iEncKeyIndex=%d ret=%08x", iEncKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex < 0) + { + LOG("iCheckKeyIndex=%d ret=%08x", iCheckKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iFlag != SM4_ENCRYPT && iFlag != SM4_DECRYPT) + { + LOG("iFlag=%d ret=%08x", iFlag, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + STC_D_HANDLE *m_handle = (STC_D_HANDLE *)malloc(sizeof(STC_D_HANDLE)); + if (m_handle == NULL) + { + LOG("m_handle null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle, 0, sizeof(STC_D_HANDLE)); + + m_handle->sm4_encdecmac_info = (STC_SM4_ENCDECMAC_INFO *)malloc(sizeof(STC_SM4_ENCDECMAC_INFO)); + if(m_handle->sm4_encdecmac_info == NULL) + { + LOG("m_handle->sm4_encdecmac_info null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle->sm4_encdecmac_info, 0, sizeof(STC_SM4_ENCDECMAC_INFO)); + + /* 加解密初始化信息 */ + m_handle->sm4_encdecmac_info->sm4_encdec_info.keyidex = iEncKeyIndex; + m_handle->sm4_encdecmac_info->sm4_encdec_info.flag = iFlag; + m_handle->sm4_encdecmac_info->sm4_encdec_info.initflag = P_DATA_INIT; + m_handle->sm4_encdecmac_info->sm4_encdec_info.status = P_HANDLE_OK; + + /* MAC初始化信息 */ + m_handle->sm4_encdecmac_info->sm4_mac_info.keyidex = iCheckKeyIndex; + memset(m_handle->sm4_encdecmac_info->sm4_mac_info.iv, '0', sizeof(m_handle->sm4_encdecmac_info->sm4_mac_info.iv)); + m_handle->sm4_encdecmac_info->sm4_mac_info.ivlen = 32; + m_handle->sm4_encdecmac_info->sm4_mac_info.initflag = P_DATA_INIT; + m_handle->sm4_encdecmac_info->sm4_mac_info.status = P_HANDLE_OK; + + m_handle->sm4_encdecmac_info->initflag = P_DATA_INIT; + m_handle->sm4_encdecmac_info->status = P_HANDLE_OK; + + /* 句柄初始化标志 */ + m_handle->iHandleType = P_HANDLE_SM4_ENCDECMAC; + m_handle->iStatus = P_HANDLE_OK; + *phProcHandle = (void *)m_handle; + LOG_MSG("SYD_SM4EncDecMac_LongDataInit success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4EncDecMac_LongDataUpdate( + void* phHandle, + char* pcData, + int iDataLen, + char* pcOutData, + int* piOutDataLen, + void* phProcHandle) +{ + if(pcData == NULL || pcOutData == NULL || piOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0; + STC_SM4_ENCDECMAC_INFO *sm4_encdecmac_info = NULL; + ret = SYD_D_AnalysisDevHandle(phProcHandle, P_HANDLE_SM4_ENCDECMAC, (void **)&sm4_encdecmac_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm4_encdecmac_info->initflag != P_DATA_INIT) + { + LOG("sm4_encdecmac_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + if(sm4_encdecmac_info->sm4_encdec_info.flag == SM4_ENCRYPT) + { + if(iDataLen < 0 || iDataLen > 6144) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + ret = SYD_SM4_EncryptUpdate(phHandle, pcData, iDataLen, pcOutData, piOutDataLen, &(sm4_encdecmac_info->sm4_encdec_info)); + if(ret != SYD_OK) + { + LOG("SYD_SM4_EncryptUpdate Error ret=%08x", ret); + return ret; + } + + ret = SYD_SM4MAC_Update(phHandle, pcOutData, *piOutDataLen, &(sm4_encdecmac_info->sm4_mac_info)); + if(ret != SYD_OK) + { + LOG("SYD_SM4MAC_Update Error ret=%08x", ret); + return ret; + } + } + else + { + if(iDataLen < 0 || iDataLen > 6144 + 16) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + ret = SYD_SM4MAC_Update(phHandle, pcData, iDataLen, &(sm4_encdecmac_info->sm4_mac_info)); + if(ret != SYD_OK) + { + LOG("SYD_SM4MAC_Update Error ret=%08x", ret); + return ret; + } + + ret = SYD_SM4_DecryptUpdate(phHandle, pcData, iDataLen, pcOutData, piOutDataLen, &(sm4_encdecmac_info->sm4_encdec_info)); + if(ret != SYD_OK) + { + LOG("SYD_SM4_DecryptUpdate Error ret=%08x", ret); + return ret; + } + } + LOG_MSG("SYD_SM4EncDecMac_LongDataUpdate success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4EncDecMac_LongDataFinal( + void* phHandle, + char* pcOutData, + int* piOutDataLen, + char* pcMac, + void* phProcHandle) +{ + if(pcOutData == NULL || piOutDataLen == NULL || pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + int ret = 0, check_ret = -1; + STC_SM4_ENCDECMAC_INFO *sm4_encdecmac_info = NULL; + ret = SYD_D_AnalysisDevHandle(phProcHandle, P_HANDLE_SM4_ENCDECMAC, (void **)&sm4_encdecmac_info); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(sm4_encdecmac_info->initflag != P_DATA_INIT) + { + LOG("sm4_encdecmac_info->initflag != P_DATA_INIT ret=%08x", SYD_LONGDATA_HANDLE_UNINIT); + return SYD_LONGDATA_HANDLE_UNINIT; + } + + if(sm4_encdecmac_info->sm4_encdec_info.flag == SM4_ENCRYPT) + { + ret = SYD_SM4_EncryptFinal(phHandle, pcOutData, piOutDataLen, &(sm4_encdecmac_info->sm4_encdec_info)); + if(ret != SYD_OK) + { + LOG("SYD_SM4_EncryptFinal Error ret=%08x", ret); + return ret; + } + + ret = SYD_SM4MAC_Update(phHandle, pcOutData, *piOutDataLen, &(sm4_encdecmac_info->sm4_mac_info)); + if(ret != SYD_OK) + { + LOG("SYD_SM4MAC_Update Error ret=%08x", ret); + return ret; + } + + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_encdecmac_info->sm4_mac_info.keyidex, \ + sm4_encdecmac_info->sm4_mac_info.procdata, sm4_encdecmac_info->sm4_mac_info.procdatalen, \ + PKG_LAST, sm4_encdecmac_info->sm4_mac_info.iv, &sm4_encdecmac_info->sm4_mac_info.ivlen, pcMac, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + } + else + { + ret = SYD_D_SM4Mac_LongData(phHandle, sm4_encdecmac_info->sm4_mac_info.keyidex, \ + sm4_encdecmac_info->sm4_mac_info.procdata, sm4_encdecmac_info->sm4_mac_info.procdatalen, \ + PKG_LAST, sm4_encdecmac_info->sm4_mac_info.iv, &sm4_encdecmac_info->sm4_mac_info.ivlen, pcMac, &check_ret); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", ret); + return ret; + } + + if(check_ret != 0) + { + LOG("SYD_D_SM4Mac_LongData ret=%08x", SYD_MAC_CHECK_ERROR); + return SYD_MAC_CHECK_ERROR; + } + + ret = SYD_SM4_DecryptFinal(phHandle, pcOutData, piOutDataLen, &(sm4_encdecmac_info->sm4_encdec_info)); + if(ret != SYD_OK) + { + LOG("SYD_SM4_DecryptFinal Error ret=%08x", ret); + return ret; + } + } + sm4_encdecmac_info->initflag = P_DATA_FINAL; + LOG_MSG("SYD_SM4_LongDataFinal success"); + return SYD_OK; +} + +#if 0 /* E1的指令暂时未使用，未测试，接口需要重新核对 */ +DLL_DECLARE int DEVAPI SYD_SM4_Encrypt_Mac_ShortData( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcData, + int iDataLen, + char* pcEncData, + int* piEncDataLen, + char* pcMac) +{ + if(iEncKeyIndex < 0) + { + LOG("iEncKeyIndex=%d ret=%08x", iEncKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex < 0) + { + LOG("iCheckKeyIndex=%d ret=%08x", iCheckKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData == NULL || pcEncData == NULL || piEncDataLen == NULL || pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen <= 0 || iDataLen > 1024) + { + LOG("iDataLen=%d ret=%08x", iDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + ret = SYD_D_SM4_ShortData_CheckValue(phHandle, iEncKeyIndex, iCheckKeyIndex, \ + pcData, iDataLen, NULL, SM4_ENCRYPT, pcEncData, piEncDataLen, pcMac); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_ShortData_CheckValue ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Encrypt_Mac_ShortData success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_Decrypt_Mac_ShortData( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcEncData, + int iEncDataLen, + char* pcMac, + char* pcOutData, + int* piOutDataLen) +{ + if(iEncKeyIndex < 0) + { + LOG("iEncKeyIndex=%d ret=%08x", iEncKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex < 0) + { + LOG("iCheckKeyIndex=%d ret=%08x", iCheckKeyIndex, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcEncData == NULL || pcMac == NULL || piOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iEncDataLen <= 0 || iEncDataLen > 1024 + 16 || (iEncDataLen % 16) != 0) + { + LOG("iEncDataLen=%d ret=%08x", iEncDataLen, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + int ret = 0; + ret = SYD_D_SM4_ShortData_CheckValue(phHandle, iEncKeyIndex, iCheckKeyIndex, \ + pcEncData, iEncDataLen, pcMac, SM4_DECRYPT, pcOutData, piOutDataLen, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_ShortData_CheckValue ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Decrypt_Mac_ShortData success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_Encrypt_Mac_BatchData( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcEncData[], + int iEncDataLen[], + char* pcMac[]) +{ + int ret = 0, i = 0; + /* 客户要求如果pcData为NULL不报错，返回正确 */ + if(pcData == NULL || iSize == 0) + { + /* 不做处理直接返回正确 */ + return SYD_OK; + } + + if(iEncKeyIndex == NULL || iCheckKeyIndex == NULL || iDataLen == NULL \ + || pcEncData == NULL || iEncDataLen == NULL || pcMac == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + for(i = 0; i < iSize; i++) + { + if(iEncKeyIndex[i] < 0) + { + LOG("iEncKeyIndex[%d]=%d ret=%08x", i, iEncKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex[i] < 0) + { + LOG("iCheckKeyIndex[%d]=%d ret=%08x", i, iCheckKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcData[i] == NULL || pcEncData[i] == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iDataLen[i] <= 0 || iDataLen[i] > 1024) + { + LOG("iDataLen[%d]=%d ret=%08x", i, iDataLen[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + + ret = SYD_D_SM4_BatchData_CheckValue(phHandle, iEncKeyIndex, iCheckKeyIndex, pcData, iDataLen, \ + NULL, iSize, SM4_ENCRYPT, pcEncData, iEncDataLen, pcMac); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData_CheckValue ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Encrypt_Mac_BatchData success"); + return SYD_OK; +} + +DLL_DECLARE int DEVAPI SYD_SM4_Decrypt_Mac_BatchData( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcEncData[], + int iEncDataLen[], + char* pcMac[], + int iSize, + char* pcOutData[], + int iOutDataLen[]) +{ + int ret = 0, i = 0; + /* 客户要求如果pcData为NULL不报错，返回正确 */ + if(pcEncData == NULL || iSize == 0) + { + /* 不做处理直接返回正确 */ + return SYD_OK; + } + + if(iEncKeyIndex == NULL || iCheckKeyIndex == NULL || iEncDataLen == NULL \ + || pcMac == NULL || pcOutData == NULL || iOutDataLen == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + for(i = 0; i < iSize; i++) + { + if(iEncKeyIndex[i] < 0) + { + LOG("iEncKeyIndex[%d]=%d ret=%08x", i, iEncKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(iCheckKeyIndex[i] < 0) + { + LOG("iCheckKeyIndex[%d]=%d ret=%08x", i, iCheckKeyIndex[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + + if(pcEncData[i] == NULL || pcMac[i] == NULL) + { + LOG("point is null ret=%08x", SYD_POINT_ERR); + return SYD_POINT_ERR; + } + + if(iEncDataLen[i] <= 0 || iEncDataLen[i] > (1024 + 16)) + { + LOG("iEncDataLen[%d]=%d ret=%08x", i, iEncDataLen[i], SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + } + + ret = SYD_D_SM4_BatchData_CheckValue(phHandle, iEncKeyIndex, iCheckKeyIndex, pcEncData, iEncDataLen, \ + pcMac, iSize, SM4_DECRYPT, pcOutData, iOutDataLen, NULL); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData_CheckValue ret=%08x", ret); + return ret; + } + LOG_MSG("SYD_SM4_Decrypt_Mac_BatchData success"); + return SYD_OK; +} +#endif \ No newline at end of file diff --git a/src/sunyard_d.c b/src/sunyard_d.c new file mode 100644 index 0000000..deb83da --- /dev/null +++ b/src/sunyard_d.c @@ -0,0 +1,3180 @@ +#ifndef _SUNYARD_D_H_ +#include "sunyard_d.h" +#endif + +#ifndef _NETAPI_H_ +#include "netapi.h" +#endif + +#ifndef _TRANS_H_ +#include "trans.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +static void PrintHex(const char* Title, unsigned char* Data, int DataLen) +{ + int i; + printf("[%s][len=%d]:", Title, DataLen); + for (i = 0; i < DataLen; i++) + { + if (!(i % 16)) printf("\n "); + printf(" %02X", Data[i]); + } + printf("\n"); +} + +int SYD_D_AnalysisDevHandle(void* handle, int handletype, void** outhandle) +{ + if(handle == NULL) + { + LOG("handle == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + + STC_D_HANDLE* m_handle = (STC_D_HANDLE*)handle; + if(m_handle->iStatus != P_HANDLE_OK) + { + LOG("m_handle->iStatus != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + + if(m_handle->iHandleType != handletype) + { + LOG("m_handle->iHandleType(%ld) != handletype(%ld) ret=%08x", m_handle->iHandleType, handletype, SYD_HANDLE_TYPE_ERROR); + return SYD_HANDLE_TYPE_ERROR; + } + + switch (handletype) + { + case P_HANDLE_DEV: + { + if (m_handle->device_info == NULL) + { + LOG("m_handle->device_info == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + else if(m_handle->device_info->status != P_HANDLE_OK) + { + LOG("m_handle->device_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + *outhandle = m_handle->device_info; + } + break; + case P_HANDLE_SM4_ENCDEC: + { + if (m_handle->sm4_encdec_info == NULL) + { + LOG("m_handle->sm4_encdec_info == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + else if(m_handle->sm4_encdec_info->status != P_HANDLE_OK) + { + LOG("m_handle->sm4_encdec_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + *outhandle = m_handle->sm4_encdec_info; + } + break; + case P_HANDLE_SM4_MAC: + { + if (m_handle->sm4_mac_info == NULL) + { + LOG("m_handle->sm4_mac_info == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + else if(m_handle->sm4_mac_info->status != P_HANDLE_OK) + { + LOG("m_handle->sm4_mac_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + *outhandle = m_handle->sm4_mac_info; + } + break; + case P_HANDLE_SM3_HASH: + { + if(m_handle->sm3_hash_info == NULL) + { + LOG("m_handle->sm3_hash_info == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + else if(m_handle->sm3_hash_info->status != P_HANDLE_OK) + { + LOG("m_handle->sm3_hash_info->status == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + *outhandle = m_handle->sm3_hash_info; + } + break; + case P_HANDLE_SM4_ENCDECMAC: + { + if(m_handle->sm4_encdecmac_info == NULL) + { + LOG("m_handle->sm4_encdecmac_info == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + else if(m_handle->sm4_encdecmac_info->status != P_HANDLE_OK) + { + LOG("m_handle->sm4_encdecmac_info->status == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + *outhandle = m_handle->sm4_encdecmac_info; + } + break; + default: + LOG("handletype=%d ret=%08x", handletype, SYD_HANDLE_TYPE_ERROR); + return SYD_HANDLE_TYPE_ERROR; + } + return SYD_OK; +} + +int SYD_D_CloseHandle(void *handle) +{ + if(handle == NULL) + { + LOG("handle == NULL ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + + STC_D_HANDLE* pHandle = (STC_D_HANDLE*)handle; + if (pHandle->iStatus != P_HANDLE_OK) + { + LOG("pSymKey->uiStatus != SYD_P_HADNLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + + switch (pHandle->iHandleType) + { + case P_HANDLE_DEV: + { + if (pHandle->device_info == NULL || pHandle->device_info->status != P_HANDLE_OK) + { + LOG("pHandle->device_info == NULL || pHandle->device_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + pHandle->device_info->status = P_HANDLE_FAIL; + free(pHandle->device_info); + pHandle->device_info = NULL; + } + break; + case P_HANDLE_SM4_ENCDEC: + { + if (pHandle->sm4_encdec_info == NULL || pHandle->sm4_encdec_info->status != P_HANDLE_OK) + { + LOG("pHandle->sm4_encdec_info == NULL || pHandle->sm4_encdec_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + pHandle->sm4_encdec_info->status = P_HANDLE_FAIL; + free(pHandle->sm4_encdec_info); + pHandle->sm4_encdec_info = NULL; + } + break; + case P_HANDLE_SM4_MAC: + { + if (pHandle->sm4_mac_info == NULL || pHandle->sm4_mac_info->status != P_HANDLE_OK) + { + LOG("pHandle->sm4_mac_info == NULL || pHandle->sm4_mac_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + pHandle->sm4_mac_info->status = P_HANDLE_FAIL; + free(pHandle->sm4_mac_info); + pHandle->sm4_mac_info = NULL; + } + break; + case P_HANDLE_SM3_HASH: + { + if (pHandle->sm3_hash_info == NULL || pHandle->sm3_hash_info->status != P_HANDLE_OK) + { + LOG("pHandle->sm3_hash_info == NULL || pHandle->sm3_hash_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + pHandle->sm3_hash_info->status = P_HANDLE_FAIL; + free(pHandle->sm3_hash_info); + pHandle->sm3_hash_info = NULL; + } + break; + case P_HANDLE_SM4_ENCDECMAC: + { + if (pHandle->sm4_encdecmac_info == NULL || pHandle->sm4_encdecmac_info->status != P_HANDLE_OK) + { + LOG("pHandle->sm4_encdecmac_info == NULL || pHandle->sm4_encdecmac_info->status != P_HANDLE_OK ret=%08x", SYD_INVALIDHANDLE_ERR); + return SYD_INVALIDHANDLE_ERR; + } + pHandle->sm4_encdecmac_info->status = P_HANDLE_FAIL; + free(pHandle->sm4_encdecmac_info); + pHandle->sm4_encdecmac_info = NULL; + } + break; + default: + LOG("pHandle->iHandleType=%d ret=%08x", pHandle->iHandleType, SYD_HANDLE_TYPE_ERROR); + return SYD_HANDLE_TYPE_ERROR; + } + pHandle->iStatus = P_HANDLE_FAIL; + pHandle->iHandleType = P_HANDLE_NOTIFY; + free(pHandle); + pHandle = NULL; + return SYD_OK; +} + +static int create_connect( + STC_DEVICE_INFO *device_info, + const char *pcIpList[], + int iPortList[], + int dev_num, + int iConnectTimeout) +{ + int ret = 0; + int tmp_fd = -1, tmp_flag = TRUE; + int i = 0, j = 0, k = 0; + int err_device[P_DEVICE_MAX_COUNT] = {0}; + int err_device_count = 0; + + /*1、尝试连接*/ + for(i = 0; i < dev_num; i++) + { + ret = socket_connect_noblock(pcIpList[i], iPortList[i], iConnectTimeout, IPMODE_IPV4, &tmp_fd); + if(ret != 0) + { + err_device[k] = i; //记录有问题的机器 + err_device_count++; + k++; + continue; + } + socket_close_noblock(tmp_fd); + tmp_fd = -1; + } + + /*所有设备失败直接报错返回*/ + if(err_device_count == dev_num) + { + for(i = 0; i < err_device_count; i++) + { + LOG("connect err ip=%s, port=%d, iConnectTimeout=%d\n ret=%08x", pcIpList[i], iPortList[i], iConnectTimeout, SYD_NET_CONNECT_ERR); + } + return SYD_NET_CONNECT_ERR; + } + + /*2、对每个主备机进行连接*/ + for (k = 0; k < dev_num; k++) + { + tmp_flag = TRUE; + for(j = 0; j < err_device_count; j++) + { + if(err_device[j] == k) + { + device_info->connect_info[k].socket_fd = -1; + device_info->connect_info[k].status = FALSE; + tmp_flag = FALSE; + break; //如果连接到错误的机器直接跳过 + } + } + + if(tmp_flag == FALSE) + { + continue; + } + + /*有连接失败不退出，只记录日志*/ + ret = socket_connect_noblock( + device_info->connect_info[k].ip, + device_info->connect_info[k].port, + device_info->connect_info[k].con_timeout, + IPMODE_IPV4, + &device_info->connect_info[k].socket_fd); + if (ret != SYD_OK) + { + LOG("socket_connect_noblock err ip=%s, port=%d, timeout=%d ret=%08x", + device_info->connect_info[k].ip, + device_info->connect_info[k].port, + device_info->connect_info[k].con_timeout, + ret); + device_info->connect_info[k].status = FALSE; + } + else + { + device_info->connect_info[k].status = TRUE; + } + } + return SYD_OK; +} + +static void set_connect_info( + STC_DEVICE_INFO *device_info, + const char *pcIpList[], + int iPortList[], + int dev_num, + int iConnectTimeout, + int iDealTimeOut) +{ + int i = 0; + for (i = 0; i < dev_num; i++) + { + strcpy(device_info->connect_info[i].ip, pcIpList[i]); + device_info->connect_info[i].port = iPortList[i]; + device_info->connect_info[i].con_timeout = iConnectTimeout; + device_info->connect_info[i].deal_timeout = iDealTimeOut; + device_info->connect_info[i].status = TRUE; + } +} + +static void disconnect(STC_DEVICE_INFO *device_info) +{ + int i = 0; + for (i = 0; i < device_info->connect_count; i++) + { + if(device_info->connect_info[i].socket_fd != -1) + { + socket_close_noblock(device_info->connect_info[i].socket_fd); + device_info->connect_info[i].socket_fd = -1; + } + } +} + +static void clear_connect_info(STC_DEVICE_INFO *device_info) +{ + int i = 0; + for (i = 0; i < device_info->connect_count; i++) + { + memset(&device_info->connect_info[i], 0, sizeof(STC_CONNECT_INFO)); + } +} + +int SYD_D_Connect_Ex( + const char *pcIpList[], + int iPortList[], + int iSize, + int iConnectTimeout, + int iDealTimeOut, + int iThreadCount, + void** phHandle) +{ + int i = 0, ret = 0; + threadpool_t *threadpool = NULL; + if(iThreadCount > 0) + { + /*创建线程池*/ + threadpool = threadpool_create(iThreadCount, P_THREADPOOL_QUERY_MAX_COUNT); + if (threadpool == NULL) + { + LOG("threadpool_create err ret=%08x", SYD_THREAD_CREATE_ERR); + return SYD_THREAD_CREATE_ERR; + } + + /*主备机连接监控恢复线程*/ + ret = threadpool_device_admin(threadpool); + if(ret != SYD_OK) + { + LOG("admin threadpool create err ret=%08x", SYD_THREAD_CREATE_ERR); + return SYD_THREAD_CREATE_ERR; + } + + ret = threadpool_set_connect_info(threadpool, pcIpList, iPortList, iSize, iConnectTimeout, iDealTimeOut); + if (ret != 0) + { + LOG("threadpool_set_devconnect_info err ret=%08x", ret); + threadpool_destroy(threadpool); + return ret; + } + + /*只要有一个连接成功就算成功*/ + ret = threadpool_create_connect(threadpool, pcIpList, iPortList, iSize, iConnectTimeout); + if (ret != 0) + { + LOG("threadpool_create_devconnect err ret=%08x", ret); + threadpool_destroy(threadpool); + return ret; + } + } + + STC_D_HANDLE *m_handle = (STC_D_HANDLE *)malloc(sizeof(STC_D_HANDLE)); + if (m_handle == NULL) + { + LOG("m_handle null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle, 0, sizeof(STC_D_HANDLE)); + + m_handle->device_info = (STC_DEVICE_INFO *)malloc(sizeof(STC_DEVICE_INFO)); + if (m_handle->device_info == NULL) + { + LOG("m_handle->device_info null ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(m_handle->device_info, 0, sizeof(STC_DEVICE_INFO)); + + if(iThreadCount > 0) + { + m_handle->device_info->threadpool = threadpool; + pthread_mutex_init(&m_handle->device_info->threadpool_mutex, NULL); + m_handle->device_info->threadpool_deal_time = iDealTimeOut; + m_handle->device_info->use_flag = P_USEFLAG_THREADPOOL; + } + else + { + set_connect_info(m_handle->device_info, pcIpList, iPortList, iSize, iConnectTimeout, iDealTimeOut); + ret = create_connect(m_handle->device_info, pcIpList, iPortList, iSize, iConnectTimeout); + if(ret != SYD_OK) + { + LOG("create_connect err ret=%08x", ret); + free(m_handle->device_info); + free(m_handle); + return ret; + } + + m_handle->device_info->connect_count = iSize; + m_handle->device_info->connect_idex = 0; //主机作为首选 + m_handle->device_info->deal_time = iDealTimeOut; + m_handle->device_info->use_flag = P_USEFLAG_ORDINARY; + } + m_handle->device_info->connect_timeout = iConnectTimeout; + m_handle->device_info->status = P_HANDLE_OK; + m_handle->iHandleType = P_HANDLE_DEV; + m_handle->iStatus = P_HANDLE_OK; + *phHandle = (void *)m_handle; + return SYD_OK; +} + +int SYD_D_DisConnect_Ex( + void* phHandle) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = threadpool_disconnect(deviceInfo->threadpool); + if(ret != SYD_OK) + { + LOG("threadpool_disconnect Error ret=%08x", ret); + return ret; + } + + ret = threadpool_clear_connect_info(deviceInfo->threadpool); + if(ret != SYD_OK) + { + LOG("threadpool_clear_connect_info Error ret=%08x", ret); + return ret; + } + + pthread_mutex_lock(&deviceInfo->threadpool_mutex); + threadpool_destroy(deviceInfo->threadpool); + pthread_mutex_unlock(&deviceInfo->threadpool_mutex); + + /*销毁线程锁*/ + pthread_mutex_destroy(&deviceInfo->threadpool_mutex); + } + else + { + disconnect(deviceInfo); + clear_connect_info(deviceInfo); + deviceInfo->connect_count = 0; //恢复主机首选 + } + + ret = SYD_D_CloseHandle(phHandle); + if(ret != SYD_OK) + { + LOG("SYD_D_CloseHandle Error ret=%08x", ret); + return ret; + } + return SYD_OK; +} + +int SYD_D_GetServerVersion( + void* phHandle, + char* pcServerVersion, + int* piServerVersionLen) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if (ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + int length = 0; + char cmd[3] = {"HV"}; + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char *send_p = NULL; + unsigned char *recv_p = NULL; + send_p = send_pkg->data; + Set_length(send_pkg, length); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + 2 + 40 + 16 + 16; + memcpy(pcServerVersion, recv_p, 10); + *piServerVersionLen = 10; + return SYD_OK; +} + +int SYD_D_SM4_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iFlag, + char* pcOutData, + int* piOutDataLen) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + int length = 0; + char cmd[3] = { "E0" }; + char len[5] = {0}; + int loop = 0, i = 0; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + unsigned char packtype; + unsigned char tmpalg; + int packlen = 2048; + int outlen = 0, tmplen = 0; + loop = iDataLen / packlen; + if (iDataLen % packlen) + { + loop++; + } + + switch (iFlag) + { + case SM4_DECRYPT: //解密 + tmpalg = '9'; + break; + case SM4_ENCRYPT: //加密 + tmpalg = '8'; + break; + } + + while (i < loop) + { + memset(&threadpool_st.send_pkg_st, 0, sizeof(TRD_PKG_ST)); + send_p = send_pkg->data; + length = 0; + if (i == 0) + { + if (loop == 1) + { + packtype = '0'; + } + else + { + packtype = '1'; + } + } + else + { + if (i == (loop - 1)) + { + packtype = '3'; + } + else + { + packtype = '2'; + } + } + + *send_p++ = packtype; length += 1; + *send_p++ = tmpalg; length += 1; + *send_p++ = '1'; length += 1; //ECB + *send_p++ = '0'; length += 1; + /* K0+19位机构号+8位密钥索引 */ + memcpy(send_p, "K0", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char *)send_p, "%08d", iKeyIndex); + send_p += 8; length += 8; + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + if (packtype == '0' || packtype == '3') + { + //PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + } + tmplen = ((iDataLen % packlen) && i == (loop - 1)) ? (iDataLen % packlen) : packlen; + sprintf((char *)send_p, "%03X", tmplen); + send_p += 3; length += 3; + memcpy(send_p, pcData + i * packlen, tmplen); + send_p += tmplen; length += tmplen; + Set_length(send_pkg, length); + strcpy(cmd, "E0"); + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + 2; + memset(len, 0, sizeof(len)); + if (*recv_p == '0') + { + recv_p++; + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + outlen += length; + if(*piOutDataLen < outlen) + { + return SYD_OUTDATA_LEN_ERR; + } + else + { + if(pcOutData != NULL) + { + memcpy(pcOutData + i * packlen, recv_p, length); + } + } + } + else + { + recv_p++; + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + outlen += length; + if(*piOutDataLen < outlen) + { + return SYD_OUTDATA_LEN_ERR; + } + else + { + if(pcOutData != NULL) + { + P_HexToBin((char *)recv_p, length * 2, pcOutData + i * packlen); + } + } + } + i++; + } + *piOutDataLen = outlen; + return SYD_OK; +} + +int SYD_D_SM4_LongData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iPkgNum, + int iFlag, + char* pcOutData, + int* piOutDataLen) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + char cmd[3] = { "E0" }; + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + TRD_PKG_ST* send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST* recv_pkg = &threadpool_st.recv_pkg_st; + int length = 0; + char len[5] = { 0 }; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + unsigned char packtype; + unsigned char tmpalg; + switch (iFlag) + { + case SM4_DECRYPT: //解密 + tmpalg = '9'; + break; + case SM4_ENCRYPT: //加密 + tmpalg = '8'; + break; + } + send_p = send_pkg->data; + switch (iPkgNum) + { + case 0: + packtype = '0'; + break; + case 1: + packtype = '1'; + break; + case 2: + packtype = '2'; + break; + case 3: + packtype = '3'; + break; + } + *send_p++ = packtype; length += 1; + *send_p++ = tmpalg; length += 1; + *send_p++ = '1'; length += 1; //ECB + *send_p++ = '0'; length += 1; + /* K0+19位机构号+8位密钥索引 */ + memcpy(send_p, "K0", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char*)send_p, "%08d", iKeyIndex); + send_p += 8; length += 8; + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + if (packtype == '0' || packtype == '3') + { + //PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + } +#if 0 + sprintf((char*)send_p, "%03X", iDataLen); + send_p += 3; length += 3; + memcpy(send_p, pcData, iDataLen); + send_p += iDataLen; length += iDataLen; +#else + *send_p++ = 'P'; length += 1; + sprintf((char*)send_p, "%04X", iDataLen); + send_p += 4; length += 4; + memcpy(send_p, pcData, iDataLen); + send_p += iDataLen; length += iDataLen; +#endif + Set_length(send_pkg, length); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + 2; + length = 0; + if (*recv_p == '0') + { + recv_p++; + if(iDataLen > 4095) + { + memcpy(len, recv_p, 4); + sscanf(len, "%04X", &length); + recv_p += 4; + } + else + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + } + + if(*piOutDataLen < length) + { + return SYD_OUTDATA_LEN_ERR; + } + else + { + if(pcOutData != NULL) + { + memcpy(pcOutData, recv_p, length); + } + } + } + else + { + recv_p++; + if(iFlag == SM4_ENCRYPT) + { + if(iDataLen >= 4080) + { + memcpy(len, recv_p, 4); + sscanf(len, "%04X", &length); + recv_p += 4; + } + else + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + } + } + else + { + if(iDataLen > 4096) + { + memcpy(len, recv_p, 4); + sscanf(len, "%04X", &length); + recv_p += 4; + } + else + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + } + } + + if(*piOutDataLen < length) + { + return SYD_OUTDATA_LEN_ERR; + } + else + { + if(pcOutData != NULL) + { + P_HexToBin((char*)recv_p, length * 2, pcOutData); + } + } + } + *piOutDataLen = length; + return SYD_OK; +} + +static int SYD_D_SM4_Data_ShortConnect( + STC_DEVICE_INFO *deviceInfo, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[]) +{ + if(iSize <= 0 || iSize > P_BATCH_GROUP) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + int ret = 0; + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + unsigned char packtype = '4'; + int length = 0, k = 0; + char len[5] = {0}; + unsigned char tmpalg; + + switch (iFlag) + { + case SM4_DECRYPT: //解密 + tmpalg = '9'; + break; + case SM4_ENCRYPT: //加密 + tmpalg = '8'; + break; + } + sprintf(threadpool_st.cmd, "E0"); + send_p = send_pkg->data; + length = 0; + *send_p++ = packtype; + length += 1; + *send_p++= iSize; + length += 1; + *send_p++ = tmpalg; + length += 1; + *send_p++ = '1'; + length += 1; // ECB + *send_p++ = '0'; + length += 1; // ZEK + + /* K0+19位机构号+8位密钥索引 */ + for (k = 0; k < iSize; k++) + { + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char *)send_p, "%08d", iKeyIndex[k]); + send_p += 8; length += 8; + } + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + + // PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + + for (k = 0; k < iSize; k++) + { + sprintf((char *)send_p, "%03X", iDataLen[k]); + send_p += 3; length += 3; + } + + for (k = 0; k < iSize; k++) + { + memcpy(send_p, pcData[k], iDataLen[k]); + send_p += iDataLen[k]; + length += iDataLen[k]; + } + Set_length(send_pkg, length); + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + recv_p = recv_pkg->data + P_ERR_LEN + 1; + for (k = 0; k < iSize; k++) + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + if (length > iOutDataLen[k]) + { + return SYD_OUTDATA_LEN_ERR; + } + iOutDataLen[k] = length; + recv_p += 3; + } + + for (k = 0; k < iSize; k++) + { + if (pcOutData[k] != NULL) + { + memcpy(pcOutData[k], recv_p, iOutDataLen[k]); + } + recv_p += iOutDataLen[k]; + } + return SYD_OK; +} + +static int SYD_D_SM4_Data_Threadpool( + STC_DEVICE_INFO *deviceInfo, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[]) +{ + if(iSize <= 0) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + int ret = 0; + int allret_flag = 0; + int mult_type = 0, group = 0; //批量数据4个为一组 + int k = 0, i = 0; + int count = 0, offset = 0; + unsigned char tmpalg; + switch (iFlag) + { + case SM4_DECRYPT: //解密 + tmpalg = '9'; + break; + case SM4_ENCRYPT: //加密 + tmpalg = '8'; + break; + } + if(iSize % P_BATCH_GROUP) + { + count = (iSize / P_BATCH_GROUP) + 1; + mult_type = 1; //未被4整除 + } + else + { + count = (iSize / P_BATCH_GROUP); + mult_type = 0; //被4整除 + } + + TRD_PKG_THREADPOOL_ST *threadpool_st = (TRD_PKG_THREADPOOL_ST *)malloc(sizeof(TRD_PKG_THREADPOOL_ST) * count); + if(threadpool_st == NULL) + { + LOG("threadpool_st malloc err ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(threadpool_st, 0, sizeof(TRD_PKG_THREADPOOL_ST) * count); + + TRD_PKG_ST *send_pkg = NULL; + TRD_PKG_ST *recv_pkg = NULL; + unsigned char *send_p = NULL; + unsigned char *recv_p = NULL; + unsigned char packtype = '4'; + int length = 0; + char len[5] = {0}; + + for(i = 0; i < count; i++) + { + if(mult_type == 1) //未被4整除 + { + if(i == count - 1) //最后一次循环是余数 + { + group = iSize % P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; + } + else + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + } + else //被4整除 + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + sprintf(threadpool_st[i].cmd, "E0"); + threadpool_st[i].deal_time = deviceInfo->threadpool_deal_time; + send_pkg = &threadpool_st[i].send_pkg_st; + send_p = send_pkg->data; + length = 0; + *send_p++ = packtype; + length += 1; + *send_p++= group; + length += 1; + *send_p++ = tmpalg; + length += 1; + *send_p++ = '1'; + length += 1; // ECB + *send_p++ = '0'; + length += 1; // ZEK + + /* K0+19位机构号+8位密钥索引 */ + for (k = 0; k < group; k++) + { + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char *)send_p, "%08d", iKeyIndex[k + offset]); + send_p += 8; length += 8; + } + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + + // PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + + for (k = 0; k < group; k++) + { + sprintf((char *)send_p, "%03X", iDataLen[k + offset]); + send_p += 3; length += 3; + } + + for (k = 0; k < group; k++) + { + memcpy(send_p, pcData[k + offset], iDataLen[k + offset]); + send_p += iDataLen[k + offset]; + length += iDataLen[k + offset]; + } + + Set_length(send_pkg, length); + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st[i], + P_BATCH_ALL_PKG); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + goto END; + } + } + + while(1) + { + allret_flag = TRUE; + for(i = 0; i < count; i++) + { + if(threadpool_st[i].task_flag != P_THREADAPOOL_PKG_FLAG_OK) + { + allret_flag = FALSE; + } + } + + if(allret_flag == TRUE) + { + /*有一个任务报错直接退出*/ + for(i = 0; i < count; i++) + { + if(threadpool_st[i].task_ret != SYD_OK) + { + LOG("threadpool_st[%d].task_ret=%d", i, threadpool_st[i].task_ret); + ret = threadpool_st[i].task_ret; + goto END; + } + } + break; + } + } + for(i = 0; i < count; i++) + { + if(mult_type == 1) //未被4整除 + { + if(i == count - 1) //最后一次循环是余数 + { + group = iSize % P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; + } + else + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + } + else //被4整除 + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + length = 0; + recv_pkg = &threadpool_st[i].recv_pkg_st; + recv_p = recv_pkg->data + P_ERR_LEN + 1; + for (k = 0; k < group; k++) + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + if (length > iOutDataLen[k + offset]) + { + ret = SYD_OUTDATA_LEN_ERR; + goto END; + } + iOutDataLen[k + offset] = length; + recv_p += 3; + } + + for (k = 0; k < group; k++) + { + if (pcOutData[k + offset] != NULL) + { + memcpy(pcOutData[k + offset], recv_p, iOutDataLen[k + offset]); + } + recv_p += iOutDataLen[k + offset]; + } + } + +END: + if(threadpool_st != NULL) + { + free(threadpool_st); + threadpool_st = NULL; + } + return ret; +} + +static int SYD_D_SM4_BatchData_ShortConnect( + STC_DEVICE_INFO *deviceInfo, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[], + int iCheckRet[]) +{ + if(iSize <= 0 || iSize > P_BATCH_GROUP) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + int ret = 0; + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + unsigned char packtype = '4'; + int length = 0, k = 0; + char len[5] = {0}; + unsigned char tmpalg; + + switch (iFlag) + { + case SM4_DECRYPT: //解密 + tmpalg = '9'; + break; + case SM4_ENCRYPT: //加密 + tmpalg = '8'; + break; + } + sprintf(threadpool_st.cmd, "E0"); + send_p = send_pkg->data; + length = 0; + *send_p++ = packtype; + length += 1; + *send_p++= iSize; + length += 1; + *send_p++ = tmpalg; + length += 1; + *send_p++ = '1'; + length += 1; // ECB + *send_p++ = '0'; + length += 1; // ZEK + + /* K0+19位机构号+8位密钥索引 */ + for (k = 0; k < iSize; k++) + { + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char *)send_p, "%08d", iKeyIndex[k]); + send_p += 8; length += 8; + } + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + + // PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + + for (k = 0; k < iSize; k++) + { + sprintf((char *)send_p, "%03X", iDataLen[k]); + send_p += 3; length += 3; + } + + for (k = 0; k < iSize; k++) + { + memcpy(send_p, pcData[k], iDataLen[k]); + send_p += iDataLen[k]; + length += iDataLen[k]; + } + Set_length(send_pkg, length); + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + recv_p = recv_pkg->data + P_ERR_LEN + 1; + for (k = 0; k < iSize; k++) + { + if(iFlag == SM4_DECRYPT && (iCheckRet == NULL || iCheckRet[k] != 0)) + { + + } + else + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + if (length > iOutDataLen[k]) + { + return SYD_OUTDATA_LEN_ERR; + } + iOutDataLen[k] = length; + } + recv_p += 3; + } + + for (k = 0; k < iSize; k++) + { + if (pcOutData[k] != NULL) + { + if(iFlag == SM4_DECRYPT && (iCheckRet == NULL || iCheckRet[k] != 0)) + { + + } + else + { + memcpy(pcOutData[k], recv_p, iOutDataLen[k]); + } + } + recv_p += iOutDataLen[k]; + } + return SYD_OK; +} + +static int SYD_D_SM4_BatchData_Threadpool( + STC_DEVICE_INFO *deviceInfo, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[], + int iCheckRet[]) +{ + if(iSize <= 0) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + int ret = 0; + int allret_flag = 0; + int mult_type = 0, group = 0; //批量数据4个为一组 + int k = 0, i = 0; + int count = 0, offset = 0; + unsigned char tmpalg; + switch (iFlag) + { + case SM4_DECRYPT: //解密 + tmpalg = '9'; + break; + case SM4_ENCRYPT: //加密 + tmpalg = '8'; + break; + } + if(iSize % P_BATCH_GROUP) + { + count = (iSize / P_BATCH_GROUP) + 1; + mult_type = 1; //未被4整除 + } + else + { + count = (iSize / P_BATCH_GROUP); + mult_type = 0; //被4整除 + } + + TRD_PKG_THREADPOOL_ST *threadpool_st = (TRD_PKG_THREADPOOL_ST *)malloc(sizeof(TRD_PKG_THREADPOOL_ST) * count); + if(threadpool_st == NULL) + { + LOG("threadpool_st malloc err ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(threadpool_st, 0, sizeof(TRD_PKG_THREADPOOL_ST) * count); + + TRD_PKG_ST *send_pkg = NULL; + TRD_PKG_ST *recv_pkg = NULL; + unsigned char *send_p = NULL; + unsigned char *recv_p = NULL; + unsigned char packtype = '4'; + int length = 0; + char len[5] = {0}; + + for(i = 0; i < count; i++) + { + if(mult_type == 1) //未被4整除 + { + if(i == count - 1) //最后一次循环是余数 + { + group = iSize % P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; + } + else + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + } + else //被4整除 + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + sprintf(threadpool_st[i].cmd, "E0"); + threadpool_st[i].deal_time = deviceInfo->threadpool_deal_time; + send_pkg = &threadpool_st[i].send_pkg_st; + send_p = send_pkg->data; + length = 0; + *send_p++ = packtype; + length += 1; + *send_p++= group; + length += 1; + *send_p++ = tmpalg; + length += 1; + *send_p++ = '1'; + length += 1; // ECB + *send_p++ = '0'; + length += 1; // ZEK + + /* K0+19位机构号+8位密钥索引 */ + for (k = 0; k < group; k++) + { + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char *)send_p, "%08d", iKeyIndex[k + offset]); + send_p += 8; length += 8; + } + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + + // PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + + for (k = 0; k < group; k++) + { + sprintf((char *)send_p, "%03X", iDataLen[k + offset]); + send_p += 3; length += 3; + } + + for (k = 0; k < group; k++) + { + memcpy(send_p, pcData[k + offset], iDataLen[k + offset]); + send_p += iDataLen[k + offset]; + length += iDataLen[k + offset]; + } + + Set_length(send_pkg, length); + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st[i], + P_BATCH_ALL_PKG); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + goto END; + } + } + + while(1) + { + allret_flag = TRUE; + for(i = 0; i < count; i++) + { + if(threadpool_st[i].task_flag != P_THREADAPOOL_PKG_FLAG_OK) + { + allret_flag = FALSE; + } + } + + if(allret_flag == TRUE) + { + /*有一个任务报错直接退出*/ + for(i = 0; i < count; i++) + { + if(threadpool_st[i].task_ret != SYD_OK) + { + LOG("threadpool_st[%d].task_ret=%d", i, threadpool_st[i].task_ret); + ret = threadpool_st[i].task_ret; + goto END; + } + } + break; + } + } + for(i = 0; i < count; i++) + { + if(mult_type == 1) //未被4整除 + { + if(i == count - 1) //最后一次循环是余数 + { + group = iSize % P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; + } + else + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + } + else //被4整除 + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + length = 0; + recv_pkg = &threadpool_st[i].recv_pkg_st; + recv_p = recv_pkg->data + P_ERR_LEN + 1; + for (k = 0; k < group; k++) + { + if(iFlag == SM4_DECRYPT && (iCheckRet == NULL || iCheckRet[k + offset] != 0)) + { + + } + else + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + if (length > iOutDataLen[k + offset]) + { + ret = SYD_OUTDATA_LEN_ERR; + goto END; + } + iOutDataLen[k + offset] = length; + } + recv_p += 3; + } + + for (k = 0; k < group; k++) + { + if (pcOutData[k + offset] != NULL) + { + if(iFlag == SM4_DECRYPT && (iCheckRet == NULL || iCheckRet[k + offset] != 0)) + { + + } + else + { + memcpy(pcOutData[k + offset], recv_p, iOutDataLen[k + offset]); + } + } + recv_p += iOutDataLen[k + offset]; + } + } + +END: + if(threadpool_st != NULL) + { + free(threadpool_st); + threadpool_st = NULL; + } + return ret; +} + +int SYD_D_SM4_Data( + void* phHandle, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[]) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = SYD_D_SM4_Data_Threadpool(deviceInfo, iKeyIndex, pcData, iDataLen, \ + iSize, iFlag, pcOutData, iOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_Data_Threadpool ret=%08x", ret); + return ret; + } + } + else + { + ret = SYD_D_SM4_Data_ShortConnect(deviceInfo, iKeyIndex, pcData, iDataLen, \ + iSize, iFlag, pcOutData, iOutDataLen); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_Data_ShortConnect ret=%08x", ret); + return ret; + } + } + return SYD_OK; +} + +int SYD_D_SM4_BatchData( + void* phHandle, + int iKeyIndex[], + char *pcData[], + int iDataLen[], + int iSize, + int iFlag, + char *pcOutData[], + int iOutDataLen[], + int iCheckRet[]) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = SYD_D_SM4_BatchData_Threadpool(deviceInfo, iKeyIndex, pcData, iDataLen, \ + iSize, iFlag, pcOutData, iOutDataLen, iCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData_Threadpool ret=%08x", ret); + return ret; + } + } + else + { + ret = SYD_D_SM4_BatchData_ShortConnect(deviceInfo, iKeyIndex, pcData, iDataLen, \ + iSize, iFlag, pcOutData, iOutDataLen, iCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData_Threadpool ret=%08x", ret); + return ret; + } + } + return SYD_OK; +} + +int SYD_D_SM3_Hash_ShortData( + void* phHandle, + char* pcData, + int iDataLen, + char* pcHash) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + + int length = 0; + int loop = 0, i = 0; + int packlen = 2048, tmplen = 0; + char ctx[2048] = { 0 }; + int ctxlen = 0; + char cmd[3] = { "76" }; + char len[5] = { 0 }; + unsigned char packtype; + loop = iDataLen / packlen; + if (iDataLen % packlen) loop++; + while (i < loop) + { + memset(&threadpool_st.send_pkg_st, 0, sizeof(TRD_PKG_ST)); + send_p = send_pkg->data; + length = 0; + if (i == 0) + { + if (loop == 1) + { + packtype = '0'; + } + else + { + packtype = '1'; + } + } + else + { + if (i == (loop - 1)) + { + packtype = '3'; + } + else + { + packtype = '2'; + } + } + *send_p++ = packtype; + length += 1; + tmplen = (i < loop - 1 || !(iDataLen % packlen)) ? packlen : (iDataLen % packlen); + sprintf((char*)send_p, "%04d", tmplen); + send_p += 4; length += 4; + memcpy(send_p, pcData + i * packlen, tmplen); + send_p += tmplen; length += tmplen; + if (packtype == '0' || packtype == '1') + { + sprintf((char*)send_p, "%02d", 16); + send_p += 2; length += 2; + strcpy((char*)send_p, "1234567812345678"); + send_p += 16; length += 16; + sprintf((char*)send_p, "%04d", 0); + send_p += 4; length += 4; + } + if (packtype == '2' || packtype == '3') + { + sprintf((char*)send_p, "%04d", ctxlen); + send_p += 4; length += 4; + memcpy(send_p, ctx, ctxlen); + send_p += ctxlen; length += ctxlen; + } + strcpy(cmd, "76"); + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + Set_length(send_pkg, length); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + P_ERR_LEN; + if (packtype == '0' || packtype == '3') + { + memcpy(pcHash, recv_p, 32); + break; + } + if (packtype == '1' || packtype == '2') + { + memset(len, 0, sizeof(len)); + memcpy(len, recv_p, 4); + recv_p += 4; + ctxlen = atoi(len); + memcpy(ctx, recv_p, ctxlen); + } + i++; + } + return SYD_OK; +} + +int SYD_D_SM3_Hash_LongData( + void* phHandle, + char* pcData, + int iDataLen, + int iPkgNum, + char* pcProcData, + int* piProcDataLen, + char* pcHash) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + int length = 0; + char len[5] = { 0 }; + char cmd[3] = { "76" }; + unsigned char packtype; + send_p = send_pkg->data; + switch (iPkgNum) + { + case 0: + packtype = '0'; + break; + case 1: + packtype = '1'; + break; + case 2: + packtype = '2'; + break; + case 3: + packtype = '3'; + break; + } + *send_p++ = packtype; length += 1; + sprintf((char*)send_p, "%04d", iDataLen); + send_p += 4; length += 4; + memcpy(send_p, pcData, iDataLen); + send_p += iDataLen; length += iDataLen; + if (packtype == '0' || packtype == '1') + { + sprintf((char*)send_p, "%02d", 16); + send_p += 2; length += 2; + strcpy((char*)send_p, "1234567812345678"); + send_p += 16; length += 16; + sprintf((char*)send_p, "%04d", 0); + send_p += 4; length += 4; + } + if (packtype == '2' || packtype == '3') + { + sprintf((char*)send_p, "%04d", *piProcDataLen); + send_p += 4; length += 4; + memcpy(send_p, pcProcData, *piProcDataLen); + send_p += *piProcDataLen; length += *piProcDataLen; + } + Set_length(send_pkg, length); + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + P_ERR_LEN; + if (packtype == '0' || packtype == '3') + { + memcpy(pcHash, recv_p, 32); + } + else if (packtype == '1' || packtype == '2') + { + memset(len, 0, sizeof(len)); + memcpy(len, recv_p, 4); + recv_p += 4; + length = atoi(len); + *piProcDataLen = atoi(len); + memcpy(pcProcData, recv_p, *piProcDataLen); + } + return SYD_OK; +} + +int SYD_D_SM4Mac_ShortData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + char* pcMac, + int* piCheckRet) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + + int length = 0; + int i = 0, loop = 0, tmplen = 0; + char cmd[3] = { "E0" }; + char len[5] = { 0 }; + unsigned char iv[64] = {0}; + memset(iv, '0', sizeof(iv)); + unsigned char mac[64] = {0}; + int packlen = 2048; + unsigned char packtype; + unsigned char tmpalg = '8'; //SM4 + loop = iDataLen / packlen; + + if(iDataLen != 0) + { + if (iDataLen % packlen) + { + loop++; + } + } + else + { + loop = 1; + } + + + while (i < loop) + { + send_p = send_pkg->data; + length = 0; + if (i == 0) + { + if (loop == 1) + { + packtype = '0'; + } + else + { + packtype = '1'; + } + } + else + { + if (i == (loop - 1)) + { + packtype = '3'; + } + else + { + packtype = '2'; + } + } + *send_p++ = packtype; length += 1; + *send_p++ = tmpalg; length += 1; + *send_p++ = '2'; length += 1; //CBC + *send_p++ = '0'; length += 1; + /* XK+19位机构号+8位密钥索引 */ + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char*)send_p, "%08d", iKeyIndex); + send_p += 8; length += 8; + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + if (packtype == '0' || packtype == '3') + { + //PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + } + memcpy(send_p, iv, 32); + send_p += 32; length += 32; + if(iDataLen != 0) + { + tmplen = ((iDataLen % packlen) && i == (loop - 1)) ? (iDataLen % packlen) : packlen; + sprintf((char *)send_p, "%03X", tmplen); + send_p += 3; length += 3; + memcpy(send_p, pcData + i * packlen, tmplen); + send_p += tmplen; length += tmplen; + } + else + { + sprintf((char *)send_p, "%03X", 0); + send_p += 3; length += 3; + } + Set_length(send_pkg, length); + strcpy(cmd, "E0"); + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + 2; + memset(len, 0, sizeof(len)); + recv_p++; + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + + if (packtype == '0' || packtype == '3') + { + memcpy(mac, recv_p + length - 16, 16); + } + + recv_p += length; + if (packtype == '1' || packtype == '2') + { + memcpy(iv, recv_p, 32); + } + i++; + } + + if(piCheckRet != NULL) + { + if(memcmp(pcMac, mac, 16) != 0) + { + *piCheckRet = SYD_MAC_CHECK_ERROR; + } + else + { + *piCheckRet = 0; + } + } + else + { + memcpy(pcMac, mac, 16); + } + return SYD_OK; +} + +static int SYD_D_SM4Mac_BatchData_ThreadPool( + STC_DEVICE_INFO *deviceInfo, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcMac[], + int piCheckRet[]) +{ + if(iSize <= 0) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + int ret = 0; + int allret_flag = 0; + int i = 0, length = 0; + char len[5] = { 0 }; + unsigned char iv[64] = {0}; + memset(iv, '0', sizeof(iv)); + unsigned char mac[64] = {0}; + + TRD_PKG_THREADPOOL_ST *threadpool_st = (TRD_PKG_THREADPOOL_ST *)malloc(sizeof(TRD_PKG_THREADPOOL_ST) * iSize); + if(threadpool_st == NULL) + { + LOG("threadpool_st malloc err ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(threadpool_st, 0, sizeof(TRD_PKG_THREADPOOL_ST) * iSize); + + TRD_PKG_ST *send_pkg = NULL; + TRD_PKG_ST *recv_pkg = NULL; + unsigned char *send_p = NULL; + unsigned char *recv_p = NULL; + + for(i = 0; i < iSize; i++) + { + sprintf(threadpool_st[i].cmd, "E0"); + threadpool_st[i].deal_time = deviceInfo->threadpool_deal_time; + send_pkg = &threadpool_st[i].send_pkg_st; + send_p = send_pkg->data; + length = 0; + *send_p++ = '0'; length += 1; + *send_p++ = '8'; length += 1; + *send_p++ = '2'; length += 1; //CBC + *send_p++ = '0'; length += 1; + /* XK+19位机构号+8位密钥索引 */ + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char*)send_p, "%08d", iKeyIndex[i]); + send_p += 8; length += 8; + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + /*PKCS7*/ + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + memcpy(send_p, iv, 32); + send_p += 32; length += 32; + /*data*/ + sprintf((char *)send_p, "%03X", iDataLen[i]); + send_p += 3; length += 3; + memcpy(send_p, pcData[i], iDataLen[i]); + send_p += iDataLen[i]; length += iDataLen[i]; + Set_length(send_pkg, length); + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st[i], + P_BATCH_ALL_PKG); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + goto END; + } + } + + while(1) + { + allret_flag = TRUE; + for(i = 0; i < iSize; i++) + { + if(threadpool_st[i].task_flag != P_THREADAPOOL_PKG_FLAG_OK) + { + allret_flag = FALSE; + } + } + + if(allret_flag == TRUE) + { + /*有一个任务报错直接退出*/ + for(i = 0; i < iSize; i++) + { + if(threadpool_st[i].task_ret != SYD_OK) + { + LOG("threadpool_st[%d].task_ret=%d", i, threadpool_st[i].task_ret); + ret = threadpool_st[i].task_ret; + goto END; + } + } + break; + } + } + + for(i = 0; i < iSize; i++) + { + length = 0; + recv_pkg = &threadpool_st[i].recv_pkg_st; + recv_p = recv_pkg->data + 2; + memset(len, 0, sizeof(len)); + recv_p++; + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + memcpy(mac, recv_p + length - 16, 16); + recv_p += length; + + if(piCheckRet != NULL) + { + if(memcmp(pcMac[i], mac, 16) != 0) + { + piCheckRet[i] = SYD_MAC_CHECK_ERROR; + } + else + { + piCheckRet[i] = 0; + } + } + else + { + memcpy(pcMac[i], mac, 16); + } + } + +END: + if(threadpool_st != NULL) + { + free(threadpool_st); + threadpool_st = NULL; + } + return ret; +} + +static int SYD_D_SM4Mac_BatchData_ShortConnect( + STC_DEVICE_INFO *deviceInfo, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcMac[], + int piCheckRet[]) +{ + if(iSize <= 0 || iSize > P_BATCH_GROUP) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + int ret = 0; + int allret_flag = 0; + int i = 0, length = 0; + char len[5] = { 0 }; + unsigned char iv[64] = {0}; + memset(iv, '0', sizeof(iv)); + unsigned char mac[64] = {0}; + + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + + for(i = 0; i < iSize; i++) + { + sprintf(threadpool_st.cmd, "E0"); + send_p = send_pkg->data; + length = 0; + *send_p++ = '0'; length += 1; + *send_p++ = '8'; length += 1; + *send_p++ = '2'; length += 1; //CBC + *send_p++ = '0'; length += 1; + /* XK+19位机构号+8位密钥索引 */ + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char*)send_p, "%08d", iKeyIndex[i]); + send_p += 8; length += 8; + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + /*PKCS7*/ + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + memcpy(send_p, iv, 32); + send_p += 32; length += 32; + /*data*/ + sprintf((char *)send_p, "%03X", iDataLen[i]); + send_p += 3; length += 3; + memcpy(send_p, pcData[i], iDataLen[i]); + send_p += iDataLen[i]; length += iDataLen[i]; + Set_length(send_pkg, length); + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + recv_p = recv_pkg->data + P_ERR_LEN; + length = 0; + memset(len, 0, sizeof(len)); + recv_p++; + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + memcpy(mac, recv_p + length - 16, 16); + recv_p += length; + + if(piCheckRet != NULL) + { + if(memcmp(pcMac[i], mac, 16) != 0) + { + piCheckRet[i] = SYD_MAC_CHECK_ERROR; + } + else + { + piCheckRet[i] = 0; + } + } + else + { + memcpy(pcMac[i], mac, 16); + } + } + return SYD_OK; +} + +int SYD_D_SM4Mac_BatchData( + void* phHandle, + int iKeyIndex[], + char* pcData[], + int iDataLen[], + int iSize, + char* pcMac[], + int piCheckRet[]) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = SYD_D_SM4Mac_BatchData_ThreadPool(deviceInfo, iKeyIndex, pcData, iDataLen, iSize, pcMac, piCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_BatchData_ThreadPool ret=%08x", ret); + return ret; + } + } + else + { + ret = SYD_D_SM4Mac_BatchData_ShortConnect(deviceInfo, iKeyIndex, pcData, iDataLen, iSize, pcMac, piCheckRet); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4Mac_BatchData_ShortConnect ret=%08x", ret); + return ret; + } + } + return SYD_OK; +} + +int SYD_D_SM4Mac_LongData( + void* phHandle, + int iKeyIndex, + char* pcData, + int iDataLen, + int iPkgNum, + char* pcProcData, + int* piProcDataLen, + char* pcMac, + int* piCheckRet) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + int length = 0; + char cmd[3] = { "E0" }; + char len[5] = { 0 }; + unsigned char mac[64] = {0}; + unsigned char packtype; + unsigned char iv[64] = {0}; + memset(iv, '0', sizeof(iv)); + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + + switch (iPkgNum) + { + case 0: + packtype = '0'; + break; + case 1: + packtype = '1'; + break; + case 2: + packtype = '2'; + break; + case 3: + packtype = '3'; + break; + } + + send_p = send_pkg->data; + *send_p++ = packtype; length += 1; + *send_p++ = '8'; length += 1; + *send_p++ = '2'; length += 1; //CBC + *send_p++ = '0'; length += 1; + /* XK+19位机构号+8位密钥索引 */ + memcpy(send_p, "XK", 2); + send_p += 2; length += 2; + memcpy(send_p, "000000000000000000A", 19); + send_p += 19; length += 19; + sprintf((char*)send_p, "%08d", iKeyIndex); + send_p += 8; length += 8; + *send_p++ = '0'; length += 1; + *send_p++ = '0'; length += 1; + if (packtype == '0' || packtype == '3') + { + //PKCS7 + *send_p++ = '1'; length += 1; + memcpy(send_p, "0000", 4); + send_p += 4; length += 4; + *send_p++ = '2'; length += 1; + } + + if(packtype == '1' || packtype == '0') + { + memcpy(send_p, iv, 32); + send_p += 32; length += 32; + } + else + { + memcpy(send_p, pcProcData, *piProcDataLen); + send_p += *piProcDataLen; length += *piProcDataLen; + } +#if 0 + sprintf((char*)send_p, "%03X", iDataLen); + send_p += 3; length += 3; + memcpy(send_p, pcData, iDataLen); + send_p += iDataLen; length += iDataLen; +#else + *send_p++ = 'P'; length += 1; + sprintf((char*)send_p, "%04X", iDataLen); + send_p += 4; length += 4; + memcpy(send_p, pcData, iDataLen); + send_p += iDataLen; length += iDataLen; +#endif + Set_length(send_pkg, length); + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + P_ERR_LEN; + memset(len, 0, sizeof(len)); + recv_p++; + + if(iDataLen > 4095) + { + memcpy(len, recv_p, 4); + sscanf(len, "%04X", &length); + recv_p += 4; + } + else + { + memcpy(len, recv_p, 3); + sscanf(len, "%03X", &length); + recv_p += 3; + } + + if (packtype == '0' || packtype == '3') + { + memcpy(mac, recv_p + length - 16, 16); + if(piCheckRet != NULL) + { + if(memcmp(pcMac, mac, 16) != 0) + { + *piCheckRet = SYD_MAC_CHECK_ERROR; + } + else + { + *piCheckRet = 0; + } + } + else + { + memcpy(pcMac, mac, 16); + } + } + + recv_p += length; + if (packtype == '1' || packtype == '2') + { + memcpy(pcProcData, recv_p, 32); + *piProcDataLen = 32; + } + return SYD_OK; +} + +int SYD_D_SM4_ShortData_CheckValue( + void* phHandle, + int iEncKeyIndex, + int iCheckKeyIndex, + char* pcData, + int iDataLen, + char* pcMac, + int iFlag, + char* pcOutData, + int* piOutDataLen, + char* pcOutMac) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + int length = 0; + char len[5] = { 0 }; + char cmd[3] = { "E1" }; + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + send_p = send_pkg->data; + /* 批量个数 */ + sprintf(send_p, "%02d", 1); + send_p += 2; length += 2; + /* 密钥模式 */ + switch (iFlag) + { + case SM4_ENCRYPT: + sprintf(send_p, "%d", 8); + send_p += 1; length += 1; + break; + case SM4_DECRYPT: + sprintf(send_p, "%d", 9); + send_p += 1; length += 1; + break; + default: + LOG("iFlag=%d ret=%08x", iFlag, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + /* 加密密钥索引 */ + sprintf(send_p, "XK000000000000000000A%08d", iEncKeyIndex); + send_p += 29; length += 29; + /* 校验密钥索引 */ + sprintf(send_p, "XK000000000000000000A%08d", iCheckKeyIndex); + send_p += 29; length += 29; + /* 数据长度 */ + sprintf(send_p, "%04d", iDataLen); + send_p += 4; length += 4; + /* 数据 */ + memcpy(send_p, pcData, iDataLen); + send_p += iDataLen; length += iDataLen; + + if(iFlag == SM4_DECRYPT) + { + /* 校验值长度 */ + sprintf(send_p, "%04d", 16); + send_p += 4; length += 4; + /* 校验值 */ + memcpy(send_p, pcMac, 16); + send_p += 16; length += 16; + } + Set_length(send_pkg, length); + memcpy(threadpool_st.cmd, cmd, sizeof(cmd)); + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st, + P_BATCH_ONLY_ONE); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + else + { + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + } + recv_p = recv_pkg->data + P_ERR_LEN; + + /* 返回数据长度 */ + memcpy(len, recv_p, 4); + sscanf(len, "%04d", &length); + if(length > *piOutDataLen) + { + return SYD_OUTDATA_LEN_ERR; + } + *piOutDataLen = length; + recv_p += 4; + + /* 返回数据 */ + if(pcOutData != NULL) + { + memcpy(pcOutData, recv_p, *piOutDataLen); + } + recv_p += *piOutDataLen; + + if(iFlag == SM4_ENCRYPT) + { + /* 返回校验值长度 */ + recv_p += 4; + + /* 返回校验值 */ + memcpy(pcOutMac, recv_p, 16); + } + return SYD_OK; +} + +static int SYD_D_SM4_BatchData_CheckValue_ShortData( + STC_DEVICE_INFO *deviceInfo, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcData[], + int iDataLen[], + char* pcMac[], + int iSize, + int iFlag, + char* pcOutData[], + int iOutDataLen[], + char* pcOutMac[]) +{ + if(iSize <= 0 || iSize > P_BATCH_GROUP) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + char len[5] = {0}; + int ret = 0, i = 0, length = 0; + TRD_PKG_THREADPOOL_ST threadpool_st = {0}; + threadpool_st.deal_time = deviceInfo->threadpool_deal_time; + TRD_PKG_ST *send_pkg = &threadpool_st.send_pkg_st; + TRD_PKG_ST *recv_pkg = &threadpool_st.recv_pkg_st; + unsigned char* send_p = NULL; + unsigned char* recv_p = NULL; + sprintf(threadpool_st.cmd, "E1"); + send_p = send_pkg->data; + /* 批量个数 */ + sprintf(send_p, "%02d", iSize); + send_p += 2; length += 2; + /* 密钥模式 */ + switch (iFlag) + { + case SM4_ENCRYPT: + sprintf(send_p, "%d", 8); + send_p += 1; length += 1; + break; + case SM4_DECRYPT: + sprintf(send_p, "%d", 9); + send_p += 1; length += 1; + break; + default: + LOG("iFlag=%d ret=%08x", iFlag, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + /* 加密密钥索引 */ + for(i = 0; i < iSize; i++) + { + sprintf(send_p, "XK000000000000000000A%08d", iEncKeyIndex[i]); + send_p += 29; length += 29; + } + + /* 校验密钥索引 */ + for(i = 0; i < iSize; i++) + { + sprintf(send_p, "XK000000000000000000A%08d", iCheckKeyIndex[i]); + send_p += 29; length += 29; + } + + /* 数据长度 */ + for(i = 0; i < iSize; i++) + { + sprintf(send_p, "%04d", iDataLen[i]); + send_p += 4; length += 4; + } + + /* 数据 */ + for(i = 0; i < iSize; i++) + { + memcpy(send_p, pcData[i], iDataLen[i]); + send_p += iDataLen[i]; length += iDataLen[i]; + } + + if(iFlag == SM4_DECRYPT) + { + /* 校验值长度 */ + for(i = 0; i < iSize; i++) + { + sprintf(send_p, "%04d", 16); + send_p += 4; length += 4; + } + + /* 校验值 */ + for(i = 0; i < iSize; i++) + { + memcpy(send_p, pcMac[i], 16); + send_p += 16; length += 16; + } + } + + Set_length(send_pkg, length); + ret = TP_Process_NoBlock_Ordinary( + threadpool_st.cmd, + send_pkg, + recv_pkg, + deviceInfo->connect_info, + &deviceInfo->connect_idex, + deviceInfo->connect_count, + deviceInfo->deal_time); + if (ret) + { + LOG("TP_Process_NoBlock_Ordinary ret=%08x(dec:%d)", ret, ret); + return ret; + } + recv_p = recv_pkg->data + P_ERR_LEN; + + /* 返回数据长度 */ + for(i = 0; i < iSize; i++) + { + memcpy(len, recv_p, 4); + sscanf(len, "%04d", &length); + if(length > iOutDataLen[i]) + { + return SYD_OUTDATA_LEN_ERR; + } + iOutDataLen[i] = length; + recv_p += 4; + } + + /* 返回数据 */ + for(i = 0; i < iSize; i++) + { + if(pcOutData[i] != NULL) + { + memcpy(pcOutData[i], recv_p, iOutDataLen[i]); + } + recv_p += iOutDataLen[i]; + } + + if(iFlag == SM4_ENCRYPT) + { + /* 返回校验值长度 */ + for(i = 0; i < iSize; i++) + { + recv_p += 4; + } + + /* 返回校验值 */ + for(i = 0; i < iSize; i++) + { + memcpy(pcOutMac[i], recv_p, 16); + recv_p += 16; + } + } + return SYD_OK; +} + +static int SYD_D_SM4_BatchData_CheckValue_Threadpool( + STC_DEVICE_INFO *deviceInfo, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcData[], + int iDataLen[], + char* pcMac[], + int iSize, + int iFlag, + char* pcOutData[], + int iOutDataLen[], + char* pcOutMac[]) +{ + if(iSize <= 0) + { + LOG("iSize=%d, ret=%08x", iSize, SYD_BATCH_DATA_SIZE_ERROR); + return SYD_BATCH_DATA_SIZE_ERROR; + } + + int ret = 0; + int allret_flag = 0; + int mult_type = 0, group = 0; //批量数据4个为一组 + int k = 0, i = 0; + int count = 0, offset = 0; + if(iSize % P_BATCH_GROUP) + { + count = (iSize / P_BATCH_GROUP) + 1; + mult_type = 1; //未被4整除 + } + else + { + count = (iSize / P_BATCH_GROUP); + mult_type = 0; //被4整除 + } + TRD_PKG_THREADPOOL_ST *threadpool_st = (TRD_PKG_THREADPOOL_ST *)malloc(sizeof(TRD_PKG_THREADPOOL_ST) * count); + if(threadpool_st == NULL) + { + LOG("threadpool_st malloc err ret=%08x", SYD_MEMORY_ERR); + return SYD_MEMORY_ERR; + } + memset(threadpool_st, 0, sizeof(TRD_PKG_THREADPOOL_ST) * count); + + TRD_PKG_ST *send_pkg = NULL; + TRD_PKG_ST *recv_pkg = NULL; + unsigned char *send_p = NULL; + unsigned char *recv_p = NULL; + int length = 0; + char len[5] = {0}; + for(i = 0; i < count; i++) + { + if(mult_type == 1) //未被4整除 + { + if(i == count - 1) //最后一次循环是余数 + { + group = iSize % P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; + } + else + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + } + else //被4整除 + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + + sprintf(threadpool_st[i].cmd, "E1"); + threadpool_st[i].deal_time = deviceInfo->threadpool_deal_time; + send_pkg = &threadpool_st[i].send_pkg_st; + send_p = send_pkg->data; + length = 0; + + /* 批量个数 */ + sprintf(send_p, "%02d", group); + send_p += 2; length += 2; + /* 密钥模式 */ + switch (iFlag) + { + case SM4_ENCRYPT: + sprintf(send_p, "%d", 8); + send_p += 1; length += 1; + break; + case SM4_DECRYPT: + sprintf(send_p, "%d", 9); + send_p += 1; length += 1; + break; + default: + LOG("iFlag=%d ret=%08x", iFlag, SYD_PARAM_ERR); + return SYD_PARAM_ERR; + } + /* 加密密钥索引 */ + for(k = 0; k < group; k++) + { + sprintf(send_p, "XK000000000000000000A%08d", iEncKeyIndex[k + offset]); + send_p += 29; length += 29; + } + + /* 校验密钥索引 */ + for(k = 0; k < group; k++) + { + sprintf(send_p, "XK000000000000000000A%08d", iCheckKeyIndex[k + offset]); + send_p += 29; length += 29; + } + + /* 数据长度 */ + for(k = 0; k < group; k++) + { + sprintf(send_p, "%04d", iDataLen[k + offset]); + send_p += 4; length += 4; + } + + /* 数据 */ + for(k = 0; k < group; k++) + { + memcpy(send_p, pcData[k], iDataLen[k + offset]); + send_p += iDataLen[k + offset]; length += iDataLen[k + offset]; + } + + if(iFlag == SM4_DECRYPT) + { + /* 校验值长度 */ + for(k = 0; k < group; k++) + { + sprintf(send_p, "%04d", 16); + send_p += 4; length += 4; + } + + /* 校验值 */ + for(k = 0; k < group; k++) + { + memcpy(send_p, pcMac[k + offset], 16); + send_p += 16; length += 16; + } + } + + Set_length(send_pkg, length); + ret = TP_Process_NoBlock( + deviceInfo->threadpool, + &deviceInfo->threadpool_mutex, + &threadpool_st[i], + P_BATCH_ALL_PKG); + if (ret) + { + LOG("TP_Process_NoBlock ret=%08x(dec:%d)", ret, ret); + goto END; + } + } + + while(1) + { + allret_flag = TRUE; + for(i = 0; i < count; i++) + { + if(threadpool_st[i].task_flag != P_THREADAPOOL_PKG_FLAG_OK) + { + allret_flag = FALSE; + } + } + + if(allret_flag == TRUE) + { + /*有一个任务报错直接退出*/ + for(i = 0; i < count; i++) + { + if(threadpool_st[i].task_ret != SYD_OK) + { + LOG("threadpool_st[%d].task_ret=%d", i, threadpool_st[i].task_ret); + ret = threadpool_st[i].task_ret; + goto END; + } + } + break; + } + } + + for(i = 0; i < count; i++) + { + if(mult_type == 1) //未被4整除 + { + if(i == count - 1) //最后一次循环是余数 + { + group = iSize % P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; + } + else + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + } + else //被4整除 + { + group = P_BATCH_GROUP; + offset = i * P_BATCH_GROUP; //所有循环均为4的倍数 + } + length = 0; + recv_pkg = &threadpool_st[i].recv_pkg_st; + recv_p = recv_pkg->data + P_ERR_LEN; + + /* 返回数据长度 */ + for (k = 0; k < group; k++) + { + memcpy(len, recv_p, 4); + sscanf(len, "%04d", &length); + iOutDataLen[k + offset] = length; + recv_p += 4; + } + + /* 返回数据 */ + for (k = 0; k < group; k++) + { + memcpy(pcOutData[k + offset], recv_p, iOutDataLen[k + offset]); + recv_p += iOutDataLen[k + offset]; + } + + if(iFlag == SM4_ENCRYPT) + { + /* 返回校验值长度 */ + for (k = 0; k < group; k++) + { + recv_p += 4; + } + + /* 返回校验值 */ + for (k = 0; k < group; k++) + { + memcpy(pcOutMac[k + offset], recv_p, 16); + recv_p += 16; + } + } + } +END: + if(threadpool_st != NULL) + { + free(threadpool_st); + threadpool_st = NULL; + } + return ret; +} + +int SYD_D_SM4_BatchData_CheckValue( + void* phHandle, + int iEncKeyIndex[], + int iCheckKeyIndex[], + char* pcData[], + int iDataLen[], + char* pcMac[], + int iSize, + int iFlag, + char* pcOutData[], + int iOutDataLen[], + char* pcOutMac[]) +{ + int ret = 0; + STC_DEVICE_INFO *deviceInfo = NULL; + ret = SYD_D_AnalysisDevHandle(phHandle, P_HANDLE_DEV, (void **)&deviceInfo); + if(ret != SYD_OK) + { + LOG("SYD_D_AnalysisDevHandle Error ret=%08x", ret); + return ret; + } + + if(deviceInfo->use_flag == P_USEFLAG_THREADPOOL) + { + ret = SYD_D_SM4_BatchData_CheckValue_Threadpool(deviceInfo, iEncKeyIndex, iCheckKeyIndex, \ + pcData, iDataLen, pcMac, iSize, iFlag, pcOutData, iOutDataLen, pcOutMac); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData_CheckValue_Threadpool ret=%08x", ret); + return ret; + } + } + else + { + ret = SYD_D_SM4_BatchData_CheckValue_ShortData(deviceInfo, iEncKeyIndex, iCheckKeyIndex, \ + pcData, iDataLen, pcMac, iSize, iFlag, pcOutData, iOutDataLen, pcOutMac); + if(ret != SYD_OK) + { + LOG("SYD_D_SM4_BatchData_CheckValue_ShortData ret=%08x", ret); + return ret; + } + } + return SYD_OK; +} \ No newline at end of file diff --git a/src/threadpool.c b/src/threadpool.c new file mode 100644 index 0000000..7f4b273 --- /dev/null +++ b/src/threadpool.c @@ -0,0 +1,517 @@ +#ifndef _THREAD_POOL_H_ +#include "threadpool.h" +#endif + +#ifndef _NETAPI_H_ +#include "netapi.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +static void threadpool_free_ex(threadpool_t *pool) +{ + if (pool == NULL) + { + return; + } + + int i = 0; + for(i = 0; i < pool->total_thr_num; i++) + { + queue_destory(pool->queue[i]); + } + + if (pool->work_threads) + { + free(pool->work_threads); + pool->work_threads = NULL; + } + + if (pool) + { + free(pool); + pool = NULL; + } +} + +int threadpool_create_connect( + threadpool_t *threadpool, + const char *pcIpList[], + int iPortList[], + int dev_num, + int iConnectTimeout) +{ + int ret = 0; + int tmp_fd = -1, tmp_flag = TRUE; + int i = 0, j = 0, k = 0; + int err_device[P_DEVICE_MAX_COUNT] = {0}; + int err_device_count = 0; + + /*1、尝试连接*/ + for(i = 0; i < dev_num; i++) + { + ret = socket_connect_noblock(pcIpList[i], iPortList[i], iConnectTimeout, IPMODE_IPV4, &tmp_fd); + if(ret != 0) + { + err_device[k] = i; //记录有问题的机器 + err_device_count++; + k++; + continue; + } + socket_close_noblock(tmp_fd); + tmp_fd = -1; + } + + /*所有设备失败直接报错返回*/ + if(err_device_count == dev_num) + { + for(i = 0; i < err_device_count; i++) + { + LOG("connect err ip=%s, port=%d, iConnectTimeout=%d\n ret=%08x", pcIpList[i], iPortList[i], iConnectTimeout, SYD_NET_CONNECT_ERR); + } + return SYD_NET_CONNECT_ERR; + } + + /*2、对所有线程的中的每个主备机进行连接*/ + for (i = 0; i < threadpool->live_thr_num; i++) + { + for (k = 0; k < dev_num; k++) + { + tmp_flag = TRUE; + for(j = 0; j < err_device_count; j++) + { + if(err_device[j] == k) + { + threadpool->work_threads[i].connect_info[k].socket_fd = -1; + threadpool->work_threads[i].connect_info[k].status = FALSE; + tmp_flag = FALSE; + break; //如果连接到错误的机器直接跳过 + } + } + + if(tmp_flag == FALSE) + { + continue; + } + + /*有连接失败不退出，只记录日志*/ + ret = socket_connect_noblock( + threadpool->work_threads[i].connect_info[k].ip, + threadpool->work_threads[i].connect_info[k].port, + threadpool->work_threads[i].connect_info[k].con_timeout, + IPMODE_IPV4, + &threadpool->work_threads[i].connect_info[k].socket_fd); + if (ret != SYD_OK) + { + LOG("socket_connect_noblock err ip=%s, port=%d, timeout=%d ret=%08x", + threadpool->work_threads[i].connect_info[k].ip, + threadpool->work_threads[i].connect_info[k].port, + threadpool->work_threads[i].connect_info[k].con_timeout, + ret); + threadpool->work_threads[i].connect_info[k].status = FALSE; + } + else + { + threadpool->work_threads[i].connect_info[k].status = TRUE; + } + } + } + return SYD_OK; +} + +int threadpool_set_connect_info( + threadpool_t *threadpool, + const char *pcIpList[], + int iPortList[], + int dev_num, + int iConnectTimeout, + int iDealTimeOut) +{ + if(threadpool->shutdown != FALSE) + { + LOG("threadpool->shutdown != FALSE ret=%08x", SYD_THREADPOOL_CLOSE); + return SYD_THREADPOOL_CLOSE; + } + + int i = 0, k = 0; + /*对所有线程的中的每个主备机进行连接*/ + for (i = 0; i < threadpool->live_thr_num; i++) + { + for (k = 0; k < dev_num; k++) + { + strcpy(threadpool->work_threads[i].connect_info[k].ip, pcIpList[k]); + threadpool->work_threads[i].connect_info[k].port = iPortList[k]; + threadpool->work_threads[i].connect_info[k].con_timeout = iConnectTimeout; + threadpool->work_threads[i].connect_info[k].deal_timeout = iDealTimeOut; + threadpool->work_threads[i].connect_info[k].status = TRUE; + } + threadpool->work_threads[i].connect_count = dev_num; + threadpool->work_threads[i].connect_idex = 0; //设置主机为首选 + } + return SYD_OK; +} + +int threadpool_disconnect(threadpool_t *threadpool) +{ + if(threadpool->shutdown != FALSE) + { + LOG("threadpool->shutdown != FALSE ret=%08x", SYD_THREADPOOL_CLOSE); + return SYD_THREADPOOL_CLOSE; + } + + int i = 0, k = 0; + for (i = 0; i < threadpool->live_thr_num; i++) + { + for (k = 0; k < threadpool->work_threads[i].connect_count; k++) + { + if(threadpool->work_threads[i].connect_info[k].socket_fd != -1) + { + socket_close_noblock(threadpool->work_threads[i].connect_info[k].socket_fd); + threadpool->work_threads[i].connect_info[k].socket_fd = -1; + } + } + } + return SYD_OK; +} + +int threadpool_clear_connect_info(threadpool_t *threadpool) +{ + if(threadpool->shutdown != FALSE) + { + LOG("threadpool->shutdown != FALSE ret=%08x", SYD_THREADPOOL_CLOSE); + return SYD_THREADPOOL_CLOSE; + } + + int i = 0; + for (i = 0; i < threadpool->live_thr_num; i++) + { + memset(threadpool->work_threads[i].connect_info, 0, sizeof(threadpool_connect_info_t)); + threadpool->work_threads[i].connect_idex = 0; //恢复主机首选 + } + return SYD_OK; +} + +static threadpool_task_t *GetTaskWorkThreadInfo(threadpool_t* threadpool, pthread_t thread_id) +{ + int i = 0; + for(i = 0; i < threadpool->total_thr_num; i++) + { + if(threadpool->work_threads[i].thread_id == thread_id) + { + return &threadpool->work_threads[i]; + } + } + return NULL; +} + +void *threadpool_workthread(void *threadpool) +{ + threadpool_t *pool = (threadpool_t *)threadpool; + + /*查找本线程ID对应的信息*/ + pthread_mutex_lock(&pool->queue_mutex); + threadpool_task_t *workthread_info = GetTaskWorkThreadInfo(pool, pthread_self()); + if(workthread_info == NULL) + { + LOG("workthread_info == NULL pthread_tid=%ld", pthread_self()); + AO_F_SUB(&pool->live_thr_num, 1); + pthread_mutex_unlock(&pool->queue_mutex); + pthread_exit(NULL); + } + LOG_TWO("threadself_id=%ld, workthread_info->thread_id=%ld\n", pthread_self(), workthread_info->thread_id); + pthread_mutex_unlock(&pool->queue_mutex); + + int ret = 0, sig = 0; + sigset_t mask; + sigemptyset(&mask); + sigaddset(&mask, SIGUSR1); + ret = pthread_sigmask(SIG_BLOCK, &mask, NULL); + if (ret != 0) + { + LOG("pthread_sigmask err ret=%04x", SYD_FAIL); + AO_F_SUB(&pool->live_thr_num, 1); + pthread_exit(NULL); + } + + do + { + while (queue_getlength(workthread_info->work_queue) <= 0 && pool->shutdown == FALSE) + { + ret = sigwait(&mask, &sig); + if (ret != 0) + { + LOG("sigwait err ret=%04x", SYD_FAIL); + break; + } + } + + if (pool->shutdown == TRUE) + { + LOG_TWO("thread %lu is exiting \n", pthread_self()); + AO_F_SUB(&pool->live_thr_num, 1); + pthread_exit(NULL); + return NULL; + } + + if (workthread_info->work_queue == NULL) + { + LOG("queue == NULL ret=%04x", SYD_PARAM_ERR); + break; + } + + if (workthread_info->work_queue->status != 1) + { + LOG("queue->status != QUEUE_HANDLE_OK ret=%04x", SYD_QUEUE_HANDLE_ERR); + break; + } + + /*队列是否为空*/ + if (queue_getlength(workthread_info->work_queue) <= 0) + { + continue; + } + + AO_F_ADD(&pool->task_num, 1); + AO_F_ADD(&pool->busy_thr_num, 1); + (*(workthread_info->work_queue->task[workthread_info->work_queue->head].function))( + workthread_info->work_queue->task[workthread_info->work_queue->head].arg, + workthread_info); + workthread_info->work_queue->head = (workthread_info->work_queue->head + 1) % workthread_info->work_queue->capacity; + AO_F_SUB(&workthread_info->work_queue->length, 1); + AO_F_SUB(&pool->busy_thr_num, 1); + } while (1); + + AO_F_SUB(&pool->live_thr_num, 1); + return 0; +} + +threadpool_t* threadpool_create(int thread_num, int queue_max_size) +{ + int ret = 0, i = 0; + threadpool_t *pool = NULL; + do + { + sigset_t mask; + sigemptyset(&mask); + sigaddset(&mask, SIGUSR1); + ret = pthread_sigmask(SIG_BLOCK, &mask, NULL); + if (ret != 0) + { + LOG("pthread_sigmask err ret=%04x", SYD_FAIL); + pthread_exit(NULL); + } + + /*线程池空间开辟*/ + if ((pool = (threadpool_t *)malloc(sizeof(threadpool_t))) == NULL) + { + LOG("malloc pool err ret=%08x", SYD_MEMORY_ERR); + return NULL; + } + memset(pool, 0, sizeof(threadpool_t)); + + pool->total_thr_num = thread_num; + pool->busy_thr_num = 0; + pool->live_thr_num = thread_num; + pool->task_num = 0; + pool->queue_max_size = queue_max_size; + + pool->work_threads = (threadpool_task_t *)malloc(sizeof(threadpool_task_t) * thread_num); + if (pool->work_threads == NULL) + { + LOG("malloc pool->work_threads err ret=%08x", SYD_MEMORY_ERR); + break; + } + memset(pool->work_threads, 0, sizeof(threadpool_task_t) * thread_num); + + /*创建所有工作队列*/ + for (i = 0; i < thread_num; i++) + { + pool->queue[i] = queue_init(queue_max_size); + if(pool->queue[i] == NULL) + { + LOG("pool->queue[i] err ret=%04x", i, SYD_MEMORY_ERR); + threadpool_free_ex(pool); + return NULL; + } + pool->work_threads[i].work_queue = pool->queue[i]; + } + + /*创建所有工作线程*/ + for (i = 0; i < thread_num; i++) + { + ret = pthread_create(&(pool->work_threads[i].thread_id), NULL, threadpool_workthread, (void *)pool); + if (ret != 0) + { + LOG("work pthread_create[%d] err ret=%08x", i, SYD_THREAD_CREATE_ERR); + threadpool_free_ex(pool); + return NULL; + } + pthread_detach(pool->work_threads[i].thread_id); + LOG_TWO("work thread %ld\n", (unsigned long)(pool->work_threads[i].thread_id)); + } + + /*初始化队列锁*/ + pthread_mutex_init(&pool->queue_mutex, NULL); + + pool->shutdown = FALSE; + usleep(5000); //线程创建后不能立即响应功能，所以在这里强行等待半秒 + LOG_MSG("threadpool_create_ex ok"); + return pool; + } while (0); + + /* 释放pool的空间 */ + threadpool_free_ex(pool); + return NULL; +} + +void *threadpool_adminthread(void *threadpool) +{ + threadpool_t *pool = (threadpool_t *)threadpool; + + int ret = 0; + int i = 0, k = 0; + while(1) + { + for(k = 0; k < pool->live_thr_num; k++) + { + for(i = 0; i < pool->work_threads[k].connect_count; i++) + { + if (pool->shutdown != FALSE) + { + LOG("pool->shutdown == TRUE ret=%08x", SYD_THREADPOOL_CLOSE); + pthread_exit(NULL); + return NULL; + } + + if(pool->work_threads[k].connect_info[i].status == FALSE) + { + ret = socket_connect_noblock( + pool->work_threads[k].connect_info[i].ip, + pool->work_threads[k].connect_info[i].port, + pool->work_threads[k].connect_info[i].con_timeout, + IPMODE_IPV4, + &pool->work_threads[k].connect_info[i].socket_fd); + if(ret != SYD_OK) + { + /*当前连接失败，放弃次连接尝试下一个连接*/ + continue; + } + } + pool->work_threads[k].connect_info[i].status = TRUE; + } + } + usleep(5000); + } +} + +int threadpool_device_admin(threadpool_t *threadpool) +{ + threadpool_t *pool = (threadpool_t *)threadpool; + if (pool->shutdown != FALSE) + { + LOG("pool->shutdown == TRUE ret=%08x", SYD_THREADPOOL_CLOSE); + return SYD_THREADPOOL_CLOSE; + } + + int ret = 0; + ret = pthread_create(&pool->admin_thread_id, NULL, threadpool_adminthread, (void *)pool); + if (ret != 0) + { + LOG("admin pthread_create err ret=%08x", SYD_THREAD_CREATE_ERR); + return SYD_THREAD_CREATE_ERR; + } + pthread_detach(pool->admin_thread_id); + return SYD_OK; +} + +int threadpool_add_task(threadpool_t *threadpool, int* (*function)(void* arg, void* device), void* arg, void* device) +{ + threadpool_t *pool = (threadpool_t *)threadpool; + if (pool->shutdown != FALSE) + { + LOG("pool->shutdown == TRUE ret=%08x", SYD_THREADPOOL_CLOSE); + return SYD_THREADPOOL_CLOSE; + } + + int ret = 0; + int queue_pend_size = 0; + while (1) + { + pool->free_queue = pool->free_queue % AO_GET(&pool->live_thr_num); + queue_pend_size = queue_getlength(pool->work_threads[pool->free_queue].work_queue); + if(queue_pend_size >= pool->queue_max_size) + { + pool->free_queue++; + continue; + } + + ret = queue_enqueue(pool->work_threads[pool->free_queue].work_queue, function, arg, device); + if(ret != SYD_OK) + { + LOG("queue_enqueue err ret=%04x", ret); + break; + } + pthread_kill(pool->work_threads[pool->free_queue].thread_id, SIGUSR1); + pool->free_queue++; + break; + } + return SYD_OK; +} + +/*精确到s*/ +static int threadpool_destory_difftime(struct timeval start_time, struct timeval end_time) +{ + int start = start_time.tv_sec; + int end = end_time.tv_sec; + return end - start; +} + +int threadpool_destroy(threadpool_t *threadpool) +{ + if (threadpool == NULL || threadpool->shutdown != FALSE) + { + LOG("threadpool == NULL ret=%04x", SYD_THREADPOOL_HANDLE_ERROR); + return SYD_THREADPOOL_HANDLE_ERROR; + } + + int ret = 0, i = 0; + int thread_live_num = 0; + thread_live_num = AO_GET(&threadpool->live_thr_num); + for (i = 0; i < thread_live_num; i++) + { + ret = pthread_cancel(threadpool->work_threads[i].thread_id); + if (ret == 0) + { + AO_F_SUB(&threadpool->live_thr_num, 1); + } + } + pthread_cancel(threadpool->admin_thread_id); + threadpool->shutdown = TRUE; + + struct timeval start_time, local_time; + gettimeofday(&start_time, NULL); + while (1) + { + if (0 >= AO_GET(&threadpool->live_thr_num)) + { + pthread_mutex_destroy(&threadpool->queue_mutex); + threadpool_free_ex(threadpool); + break; + } + else + { + usleep(5000); + gettimeofday(&local_time, NULL); + if(5 < threadpool_destory_difftime(start_time, local_time)) //大于5s直接退出 + { + LOG("threadpool_destroy_ex overtime ret=%08x", SYD_THREAPOOL_DESTORY_OVERTIME); + return SYD_THREAPOOL_DESTORY_OVERTIME; + } + continue; + } + } + LOG_MSG("threadpool_destroy_ex ok"); + return SYD_OK; +} \ No newline at end of file diff --git a/src/trans.c b/src/trans.c new file mode 100644 index 0000000..1a234a3 --- /dev/null +++ b/src/trans.c @@ -0,0 +1,456 @@ +#ifndef _TYPEDEF_H_ +#include "typedef.h" +#endif + +#ifndef _SUNYARD_D_H_ +#include "sunyard_d.h" +#endif + +#ifndef _NETAPI_H_ +#include "netapi.h" +#endif + +#ifndef _TRANS_H_ +#include "trans.h" +#endif + +#ifndef _LOG_H_ +#include "log.h" +#endif + +int Get_retcode(TRD_PKG_ST *pkg) +{ + unsigned char cmd[3] = {0}; + memcpy(cmd, Get_cmd(pkg), 2); + if ((memcmp(cmd, "\x80\x00" ,2) > 0 && memcmp(cmd, "\x80\x21", 2) < 0) || + (memcmp(cmd, "\x3E\x80", 2) >= 0 && memcmp(cmd, "\x3E\x90", 2) < 0)) + { + return (pkg->data[0]*256 + pkg->data[1]); + } + else + { + return (pkg->data[0] - 0x30)*16 + (pkg->data[1] - 0x30); + } +} + +unsigned int Get_sn(TRD_PKG_ST *pkg) +{ + return pkg->HEADER[6]*256 + pkg->HEADER[7]; +} + +char *Get_cmd(TRD_PKG_ST *pkg) +{ + return (char *)pkg->COMMAND; +} + +int Get_length(TRD_PKG_ST *pkg) +{ + return pkg->LENGTH[0]*256 + pkg->LENGTH[1]; +} + +void Set_sn(TRD_PKG_ST *pkg, unsigned int sn) +{ + pkg->HEADER[6] = sn/256; + pkg->HEADER[7] = sn%256; +} + +void Set_cmd(TRD_PKG_ST *pkg, char *cmd) +{ + if (strlen(cmd) < 2) + { + return; + } + pkg->COMMAND[0] = cmd[0]; + pkg->COMMAND[1] = cmd[1]; +} + +void Set_length(TRD_PKG_ST *pkg, int length) +{ + length += 8+2; + pkg->LENGTH[0] = length/256; + pkg->LENGTH[1] = length%256; +} + +int Packet_Recv(int fd, TRD_PKG_ST *pkg, int pkgsize) +{ + int len = 0,ret = 0; + char *p = NULL; + p = (char *)pkg; + ret = socket_recv(fd, p, 2); + if (ret < 0) + { + return ret; + } + len = Get_length(pkg); + if (len + 2 > pkgsize) + { + return SYD_NET_PKGLEN_ERR; + } + ret=socket_recv(fd, p+2, len); + if (ret < 0) + { + return ret; + } + len += 2; + return len; +} + +int Packet_Send(int fd, TRD_PKG_ST *pkg, int pkgsize) +{ + int len = 0, ret = 0; + char *p = NULL; + p = (char *)pkg; + len = Get_length(pkg); + len += 2; + if (len + 2 > pkgsize) + { + return SYD_NET_PKGLEN_ERR; + } + ret = socket_send(fd,p,len); + if (ret < 0) + { + return ret; + } + return len; +} + +void SetDataLength(int iInData, unsigned char* pcOutData) +{ + pcOutData[0] = iInData / 256; + pcOutData[1] = iInData % 256; +} + +int GetDataLength(unsigned char* pcInData) +{ + return pcInData[0] * 256 + pcInData[1]; +} + +int Packet_Recv_Noblock(int fd, TRD_PKG_ST *pkg, int pkgsize, struct timeval start_time, int deal_time) +{ + int len = 0, ret = 0; + char *p = NULL; + p = (char *)pkg; + ret = socket_recv_noblock(fd, p, 2, start_time, deal_time); + if (ret < 0) + { + return ret; + } + + len = Get_length(pkg); + if (len + 2 > pkgsize) + { + return SYD_NET_PKGLEN_ERR; + } + + ret = socket_recv_noblock(fd, p + 2, len, start_time, deal_time); + if (ret < 0) + { + return ret; + } + len += 2; + return len; +} + +int Packet_Send_Noblock(int fd, TRD_PKG_ST *pkg, int pkgsize, struct timeval start_time, int deal_time) +{ + int len = 0, ret = 0; + char *p = NULL; + p = (char *)pkg; + len = Get_length(pkg); + len += 2; + if (len + 2 > pkgsize) + { + return SYD_NET_PKGLEN_ERR; + } + ret = socket_send_noblock(fd, p, len, start_time, deal_time); + if (ret < 0) + { + return ret; + } + return len; +} + +int TP_Process_NoBlock_Ordinary( + char *cmd, + TRD_PKG_ST *send_pkg, + TRD_PKG_ST *recv_pkg, + STC_CONNECT_INFO *connect_info, + int *connect_idex, + int device_count, + int deal_time) +{ + if(device_count <= 0) + { + LOG("device_count=%d, ret=%08x", device_count, SYD_DEVICE_NUM_ERR); + return SYD_DEVICE_NUM_ERR; + } + + struct timeval start_time; + struct timeval local_time; + struct timeval start_switch_time; + struct timeval local_switch_time; + int tmp_dealtime = deal_time / device_count; + int ret = 0, length = 0; + static unsigned short global_sn = 0; + unsigned short local_sn; + local_sn = global_sn; + if(global_sn == 65535) + { + global_sn = 0; + } + else + { + global_sn++; + } + Set_sn(send_pkg,local_sn); + Set_cmd(send_pkg,cmd); + + gettimeofday(&start_switch_time, NULL); + /*切换时间开始计时*/ + while(1) + { + if(ret < 0) + { + gettimeofday(&local_switch_time, NULL); + if(deal_time < ms_difftime(start_switch_time, local_switch_time)) + { + LOG_NET("device switch overtime ret=%08x", SYD_NET_OVERTIME); + return SYD_NET_OVERTIME; + } + } + + /*交易起始时间*/ + LOG_PrintHex("Send", (unsigned char *)send_pkg, Get_length(send_pkg) + 2); + gettimeofday(&start_time, NULL); + ret = Packet_Send_Noblock(connect_info[*connect_idex].socket_fd, send_pkg, sizeof(TRD_PKG_ST), start_time, tmp_dealtime); + if (ret < 0) + { + if(connect_info[*connect_idex].socket_fd != -1) + { + socket_close_noblock(connect_info[*connect_idex].socket_fd); + connect_info[*connect_idex].socket_fd = -1; + } + + /*设置当前连接状态为错误状态*/ + connect_info[*connect_idex].status = FALSE; + + if(*connect_idex + 1 >= device_count) + { + *connect_idex = 0; + } + else + { + *connect_idex += 1; + } + continue; + } + gettimeofday(&local_time, NULL); + + ret = Packet_Recv_Noblock(connect_info[*connect_idex].socket_fd, recv_pkg, sizeof(TRD_PKG_ST), start_time, tmp_dealtime - ms_difftime(start_time, local_time)); + if (ret < 0) + { + if(connect_info[*connect_idex].socket_fd != -1) + { + socket_close_noblock(connect_info[*connect_idex].socket_fd); + connect_info[*connect_idex].socket_fd = -1; + } + + /*设置当前连接状态为错误状态*/ + connect_info[*connect_idex].status = FALSE; + + if(*connect_idex + 1 >= device_count) + { + *connect_idex = 0; + } + else + { + *connect_idex += 1; + } + continue; + } + LOG_PrintHex("Recv", (unsigned char *)recv_pkg, Get_length(recv_pkg) + 2); + break; + } + + if (Get_sn(recv_pkg) != local_sn) + { + LOG("Get_sn err ret=%08x", SYD_NET_SN_ERR); + return SYD_NET_SN_ERR; + } + cmd[1]++; + if (memcmp(Get_cmd(recv_pkg), cmd, 2)) + { + LOG("Get_cmd err ret=%08x", SYD_NET_CMD_ERR); + return SYD_NET_CMD_ERR; + } + + ret = Get_retcode(recv_pkg); + if(ret == 0x49) + return SYD_MAC_CHECK_ERROR; + else + return ret; + return 0; +} + +int TP_Process_NoBlock_Standby(char *cmd, TRD_PKG_ST *send_pkg, TRD_PKG_ST *recv_pkg, void *device, int deal_time) +{ + threadpool_task_t *task_t = (threadpool_task_t *)device; + if(task_t->connect_count <= 0) + { + LOG("task_t->connect_count=%d, ret=%08x", task_t->connect_count, SYD_DEVICE_NUM_ERR); + return SYD_DEVICE_NUM_ERR; + } + + struct timeval start_time; + struct timeval local_time; + struct timeval start_switch_time; + struct timeval local_switch_time; + int ret = 0, length = 0; + int tmp_dealtime = deal_time / task_t->connect_count; + static unsigned short global_sn = 0; + unsigned short local_sn; + local_sn = global_sn; + if(global_sn == 65535) + { + global_sn = 0; + } + else + { + global_sn++; + } + Set_sn(send_pkg,local_sn); + Set_cmd(send_pkg,cmd); + + /*切换时间开始计时*/ + gettimeofday(&start_switch_time, NULL); + while(1) + { + if(ret < 0) + { + gettimeofday(&local_switch_time, NULL); + if(deal_time < ms_difftime(start_switch_time, local_switch_time)) + { + LOG_NET("device switch overtime ret=%08x", SYD_NET_OVERTIME); + return SYD_NET_OVERTIME; + } + } + + /*交易起始时间*/ + gettimeofday(&start_time, NULL); + LOG_PrintHex("Send", (unsigned char *)send_pkg, Get_length(send_pkg) + 2); + ret = Packet_Send_Noblock(task_t->connect_info[task_t->connect_idex].socket_fd, send_pkg, sizeof(TRD_PKG_ST), start_time, tmp_dealtime); + if (ret < 0) + { + if(task_t->connect_info[task_t->connect_idex].socket_fd != -1) + { + socket_close_noblock(task_t->connect_info[task_t->connect_idex].socket_fd); + task_t->connect_info[task_t->connect_idex].socket_fd = -1; + } + + /*设置当前连接状态为错误状态*/ + task_t->connect_info[task_t->connect_idex].status = FALSE; + + if(task_t->connect_idex + 1 >= task_t->connect_count) + { + task_t->connect_idex = 0; + } + else + { + task_t->connect_idex += 1; + } + continue; + } + gettimeofday(&local_time, NULL); + + ret = Packet_Recv_Noblock(task_t->connect_info[task_t->connect_idex].socket_fd, recv_pkg, sizeof(TRD_PKG_ST), start_time, tmp_dealtime - ms_difftime(start_time, local_time)); + if (ret < 0) + { + if(task_t->connect_info[task_t->connect_idex].socket_fd != -1) + { + socket_close_noblock(task_t->connect_info[task_t->connect_idex].socket_fd); + task_t->connect_info[task_t->connect_idex].socket_fd = -1; + } + + /*设置当前连接状态为错误状态*/ + task_t->connect_info[task_t->connect_idex].status = FALSE; + + if(task_t->connect_idex + 1 >= task_t->connect_count) + { + task_t->connect_idex = 0; + } + else + { + task_t->connect_idex += 1; + } + continue; + } + LOG_PrintHex("Recv", (unsigned char *)recv_pkg, Get_length(recv_pkg) + 2); + break; + } + + if (Get_sn(recv_pkg) != local_sn) + { + LOG("Get_sn err ret=%08x", SYD_NET_SN_ERR); + return SYD_NET_SN_ERR; + } + cmd[1]++; + if (memcmp(Get_cmd(recv_pkg), cmd, 2)) + { + LOG("Get_cmd err ret=%08x", SYD_NET_CMD_ERR); + return SYD_NET_CMD_ERR; + } + + ret = Get_retcode(recv_pkg); + if(ret == 0x49) + return SYD_MAC_CHECK_ERROR; + else + return ret; + return 0; +} + +static int *T_Threadpool_PkgDeal(void* arg, void *device) +{ + TRD_PKG_THREADPOOL_ST *pkg_threadpool_st = (TRD_PKG_THREADPOOL_ST *)arg; + pkg_threadpool_st->task_ret = TP_Process_NoBlock_Standby( + pkg_threadpool_st->cmd, + &pkg_threadpool_st->send_pkg_st, + &pkg_threadpool_st->recv_pkg_st, + device, + pkg_threadpool_st->deal_time); + pkg_threadpool_st->task_flag = P_THREADAPOOL_PKG_FLAG_OK; + return SYD_OK; +} + +int TP_Process_NoBlock( + threadpool_t *threadpool, + pthread_mutex_t *threadpool_mutex, + TRD_PKG_THREADPOOL_ST *pkg_threadpool_st, + int pkg_number) +{ + int ret = 0; + struct timeval local_time; + pkg_threadpool_st->task_ret = 0; + pkg_threadpool_st->task_flag = P_THREADAPOOL_PKG_FLAG_FAIL; + + pthread_mutex_lock(threadpool_mutex); + ret = threadpool_add_task(threadpool, T_Threadpool_PkgDeal, (void *)pkg_threadpool_st, NULL); + pthread_mutex_unlock(threadpool_mutex); + if(ret != SYD_OK) + { + LOG("threadpool_add_task err ret=%08x", ret); + return ret; + } + + if(pkg_number == P_BATCH_ONLY_ONE) + { + while(1) + { + if(pkg_threadpool_st->task_flag == P_THREADAPOOL_PKG_FLAG_OK) + { + return pkg_threadpool_st->task_ret; + } + } + } + return SYD_OK; +} + diff --git a/测试说明.txt b/测试说明.txt new file mode 100644 index 0000000..25180cf --- /dev/null +++ b/测试说明.txt @@ -0,0 +1,13 @@ +1、该测试需要提前手动合成密钥，密钥合成方式如下 + 机构号16字节0 类型:ZEK(00A) 索引:8字节0 方案:S 不变种 分量个数:2 (金交所使用的是方案S) + 这里用的密钥分量为 + 分量1:31313131313131313131313131313131 + 分量2:32323232323232323232323232323232 + 合成后的分量:03030303030303030303030303030303 + 校验值:9602336689EBE514 + + 分量1:32323232323232323232323232323232 + 分量2:33333333333333333333333333333333 + 校验值:82F1B998DEBBB05E + +2、在demo.c的宏定义中架构IP改为测试的IP \ No newline at end of file