1 /*
2 * This file is part of the openHiTLS project.
3 *
4 * openHiTLS is licensed under the Mulan PSL v2.
5 * You can use this software according to the terms and conditions of the Mulan PSL v2.
6 * You may obtain a copy of Mulan PSL v2 at:
7 *
8 * http://license.coscl.org.cn/MulanPSL2
9 *
10 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
11 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
12 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
13 * See the Mulan PSL v2 for more details.
14 */
15
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <pthread.h>
19 #include "securec.h"
20 #include "hlt.h"
21 #include "handle_cmd.h"
22 #include "tls_res.h"
23 #include "logger.h"
24 #include "lock.h"
25 #include "hitls_error.h"
26 #include "hitls_type.h"
27 #include "tls.h"
28 #include "alert.h"
29 #include "hitls.h"
30 #include "common_func.h"
31 #include "sctp_channel.h"
32 #include "rpc_func.h"
33
34 #define HITLS_READBUF_MAXLEN (20 * 1024) /* 20K */
35 #define SUCCESS 0
36 #define ERROR (-1)
37
38 #define ASSERT_RETURN(condition) \
39 do { \
40 if (!(condition)) { \
41 LOG_ERROR("sprintf_s Error"); \
42 return ERROR; \
43 } \
44 } while (0)
45
46 RpcFunList g_rpcFuncList[] = {
47 #ifdef HITLS_TLS_FEATURE_PROVIDER
48 {"HLT_RpcProviderTlsNewCtx", RpcProviderTlsNewCtx},
49 #else
50 {"HLT_RpcTlsNewCtx", RpcTlsNewCtx},
51 #endif
52 {"HLT_RpcTlsSetCtx", RpcTlsSetCtx},
53 {"HLT_RpcTlsNewSsl", RpcTlsNewSsl},
54 {"HLT_RpcTlsSetSsl", RpcTlsSetSsl},
55 {"HLT_RpcTlsListen", RpcTlsListen},
56 {"HLT_RpcTlsAccept", RpcTlsAccept},
57 {"HLT_RpcTlsConnect", RpcTlsConnect},
58 {"HLT_RpcTlsRead", RpcTlsRead},
59 {"HLT_RpcTlsWrite", RpcTlsWrite},
60 {"HLT_RpcTlsRenegotiate", RpcTlsRenegotiate},
61 {"HLT_RpcDataChannelAccept", RpcDataChannelAccept},
62 {"HLT_RpcDataChannelConnect", RpcDataChannelConnect},
63 {"HLT_RpcProcessExit", RpcProcessExit},
64 {"HLT_RpcTlsRegCallback", RpcTlsRegCallback},
65 {"HLT_RpcTlsGetStatus", RpcTlsGetStatus},
66 {"HLT_RpcTlsGetAlertFlag", RpcTlsGetAlertFlag},
67 {"HLT_RpcTlsGetAlertLevel", RpcTlsGetAlertLevel},
68 {"HLT_RpcTlsGetAlertDescription", RpcTlsGetAlertDescription},
69 {"HLT_RpcTlsClose", RpcTlsClose},
70 {"HLT_RpcFreeResFormSsl", RpcFreeResFormSsl},
71 {"HLT_RpcCloseFd", RpcCloseFd},
72 {"HLT_RpcTlsSetMtu", RpcTlsSetMtu},
73 {"HLT_RpcTlsGetErrorCode", RpcTlsGetErrorCode},
74 {"HLT_RpcDataChannelBind", RpcDataChannelBind},
75 {"HLT_RpcTlsVerifyClientPostHandshake", RpcTlsVerifyClientPostHandshake},
76 };
77
GetRpcFuncList(void)78 RpcFunList *GetRpcFuncList(void)
79 {
80 return g_rpcFuncList;
81 }
82
GetRpcFuncNum(void)83 int GetRpcFuncNum(void)
84 {
85 return sizeof(g_rpcFuncList) / sizeof(g_rpcFuncList[0]);
86 }
87
88 #ifdef HITLS_TLS_FEATURE_PROVIDER
89 /**
90 * Parse the provider string in format "name1,fmt1:name2,fmt2:...:nameN,fmtN"
91 */
ParseProviderString(const char * providerStr,char (* providerNames)[MAX_PROVIDER_NAME_LEN],int32_t * providerLibFmts,int32_t * providerCnt)92 static int ParseProviderString(const char *providerStr, char (*providerNames)[MAX_PROVIDER_NAME_LEN],
93 int32_t *providerLibFmts, int32_t *providerCnt)
94 {
95 if (providerStr == NULL) {
96 LOG_DEBUG("Provider names is NULL");
97 return SUCCESS;
98 }
99
100 if (providerStr == NULL || providerLibFmts == NULL || providerCnt == NULL) {
101 LOG_ERROR("Invalid input parameters");
102 return ERROR;
103 }
104
105 int count = 1;
106 const char *ptr = providerStr;
107 while (*ptr) {
108 if (*ptr == ':') {
109 count++;
110 }
111 ptr++;
112 }
113 *providerCnt = count;
114 if (count == 0) {
115 LOG_ERROR("Provider string is empty");
116 return SUCCESS;
117 }
118
119 char *tempStr = strdup(providerStr);
120 if (tempStr == NULL) {
121 LOG_ERROR("Failed to duplicate provider string");
122 return ERROR;
123 }
124
125 char *saveptr1 = NULL;
126 char *saveptr2 = NULL;
127 char *token = strtok_r(tempStr, ":", &saveptr1);
128 int i = 0;
129
130 while (token != NULL && i < count) {
131 char *name = strtok_r(token, ",", &saveptr2);
132 char *fmt = strtok_r(NULL, ",", &saveptr2);
133
134 if (name == NULL || fmt == NULL) {
135 LOG_ERROR("Invalid provider format");
136 free(tempStr);
137 return ERROR;
138 }
139
140 if (strcpy_s(providerNames[i], MAX_PROVIDER_NAME_LEN, name) != EOK) {
141 LOG_ERROR("Failed to allocate memory for provider name");
142 free(tempStr);
143 return ERROR;
144 }
145
146 providerLibFmts[i] = atoi(fmt);
147
148 token = strtok_r(NULL, ":", &saveptr1);
149 i++;
150 }
151
152 free(tempStr);
153 return SUCCESS;
154 }
155
RpcProviderTlsNewCtx(CmdData * cmdData)156 int RpcProviderTlsNewCtx(CmdData *cmdData)
157 {
158 int id;
159 TLS_VERSION tlsVersion;
160 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
161
162 tlsVersion = atoi(cmdData->paras[0]);
163 char *providerNames = strlen(cmdData->paras[2]) > 0 ? cmdData->paras[2] : NULL;
164 char *attrName = strlen(cmdData->paras[3]) > 0 ? cmdData->paras[3] : NULL;
165 char *providerPath = strlen(cmdData->paras[4]) > 0 ? cmdData->paras[4] : NULL;
166 char parsedProviderNames[MAX_PROVIDER_COUNT][MAX_PROVIDER_NAME_LEN] = {0};
167 int32_t providerLibFmts[MAX_PROVIDER_COUNT] = {0};
168 int32_t providerCnt = 0;
169
170 if (ParseProviderString(providerNames, parsedProviderNames, providerLibFmts, &providerCnt) != SUCCESS) {
171 LOG_ERROR("Failed to parse provider string");
172 id = ERROR;
173 goto EXIT;
174 }
175
176 // Invoke the corresponding function.
177 void *ctx = HLT_TlsProviderNewCtx(providerPath, parsedProviderNames, providerLibFmts, providerCnt, attrName,
178 tlsVersion);
179 if (ctx == NULL) {
180 LOG_ERROR("HLT_TlsProviderNewCtx Return NULL");
181 id = ERROR;
182 goto EXIT;
183 }
184
185 // Insert to CTX linked list
186 id = InsertCtxToList(ctx);
187
188 EXIT:
189 // Return Result
190 if (sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id) <= 0) {
191 return ERROR;
192 }
193 return SUCCESS;
194 }
195 #endif
196
RpcTlsNewCtx(CmdData * cmdData)197 int RpcTlsNewCtx(CmdData *cmdData)
198 {
199 int id;
200 TLS_VERSION tlsVersion;
201 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
202
203 tlsVersion = atoi(cmdData->paras[0]);
204 // Invoke the corresponding function.
205 void* ctx = HLT_TlsNewCtx(tlsVersion);
206 if (ctx == NULL) {
207 LOG_ERROR("HLT_TlsNewCtx Return NULL");
208 id = ERROR;
209 goto EXIT;
210 }
211
212 // Insert to CTX linked list
213 id = InsertCtxToList(ctx);
214
215 EXIT:
216 // Return Result
217 if (sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id) <= 0) {
218 return ERROR;
219 }
220 return SUCCESS;
221 }
222
RpcTlsSetCtx(CmdData * cmdData)223 int RpcTlsSetCtx(CmdData *cmdData)
224 {
225 int ret;
226 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
227
228 // Find the corresponding CTX.
229 ResList *ctxList = GetCtxList();
230 int ctxId = atoi(cmdData->paras[0]);
231 void *ctx = GetTlsResFromId(ctxList, ctxId);
232 if (ctx == NULL) {
233 LOG_ERROR("GetResFromId Error");
234 ret = ERROR;
235 goto EXIT;
236 }
237
238 // Configurations related to parsing
239 HLT_Ctx_Config ctxConfig = {0};
240 ret = ParseCtxConfigFromString(cmdData->paras, &ctxConfig);
241 if (ret != SUCCESS) {
242 LOG_ERROR("ParseCtxConfigFromString Error");
243 ret = ERROR;
244 goto EXIT;
245 }
246
247 // Configure the data
248 ret = HLT_TlsSetCtx(ctx, &ctxConfig);
249
250 EXIT:
251 // Return the result
252 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
253 ASSERT_RETURN(ret > 0);
254 return SUCCESS;
255 }
256
RpcTlsNewSsl(CmdData * cmdData)257 int RpcTlsNewSsl(CmdData *cmdData)
258 {
259 int id, ret;
260 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
261
262 // Invoke the corresponding function.
263 ResList *ctxList = GetCtxList();
264 int ctxId = atoi(cmdData->paras[0]);
265 void *ctx = GetTlsResFromId(ctxList, ctxId);
266 if (ctx == NULL) {
267 LOG_ERROR("Not Find Ctx");
268 id = ERROR;
269 goto EXIT;
270 }
271
272 void *ssl = HLT_TlsNewSsl(ctx);
273 if (ssl == NULL) {
274 LOG_ERROR("HLT_TlsNewSsl Return NULL");
275 id = ERROR;
276 goto EXIT;
277 }
278
279 // Insert to the SSL linked list.
280 id = InsertSslToList(ctx, ssl);
281
282 EXIT:
283 // Return the result.
284 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, id);
285 ASSERT_RETURN(ret > 0);
286 return SUCCESS;
287 }
288
RpcTlsSetSsl(CmdData * cmdData)289 int RpcTlsSetSsl(CmdData *cmdData)
290 {
291 int ret;
292
293 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
294
295 ResList *sslList = GetSslList();
296 int sslId = atoi(cmdData->paras[0]);
297 void *ssl = GetTlsResFromId(sslList, sslId);
298 if (ssl == NULL) {
299 LOG_ERROR("Not Find Ssl");
300 ret = ERROR;
301 goto EXIT;
302 }
303
304 HLT_Ssl_Config sslConfig = {0};
305 sslConfig.sockFd = atoi(cmdData->paras[1]); // The first parameter indicates the FD value.
306 sslConfig.connType = atoi(cmdData->paras[2]); // The second parameter indicates the link type.
307 // The third parameter of indicates the Ctrl command that needs to register the hook.
308 sslConfig.connPort = atoi(cmdData->paras[3]);
309 ret = HLT_TlsSetSsl(ssl, &sslConfig);
310 EXIT:
311 // Return the result.
312 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
313 ASSERT_RETURN(ret > 0);
314 return SUCCESS;
315 }
316
RpcTlsListen(CmdData * cmdData)317 int RpcTlsListen(CmdData *cmdData)
318 {
319 int ret;
320 int sslId;
321 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
322 ResList *sslList = GetSslList();
323 sslId = strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
324 void *ssl = GetTlsResFromId(sslList, sslId);
325 if (ssl == NULL) {
326 LOG_ERROR("Not Find Ssl");
327 ret = ERROR;
328 goto EXIT;
329 }
330
331 ret = HLT_TlsListenBlock(ssl);
332
333 EXIT:
334 // Return the result
335 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
336 ASSERT_RETURN(ret > 0);
337 return SUCCESS;
338 }
339
RpcTlsAccept(CmdData * cmdData)340 int RpcTlsAccept(CmdData *cmdData)
341 {
342 int ret;
343
344 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
345 ResList *sslList = GetSslList();
346 int sslId = atoi(cmdData->paras[0]);
347 void *ssl = GetTlsResFromId(sslList, sslId);
348 if (ssl == NULL) {
349 LOG_ERROR("Not Find Ssl");
350 ret = ERROR;
351 goto EXIT;
352 }
353
354 // If there is a problem, the user must use non-blocking, and the remote call must use blocking
355 ret = HLT_TlsAcceptBlock(ssl);
356
357 EXIT:
358 // Return the result
359 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
360 ASSERT_RETURN(ret > 0);
361 return SUCCESS;
362 }
363
RpcTlsConnect(CmdData * cmdData)364 int RpcTlsConnect(CmdData *cmdData)
365 {
366 int ret;
367
368 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
369
370 ResList *sslList = GetSslList();
371 int sslId = atoi(cmdData->paras[0]);
372 void *ssl = GetTlsResFromId(sslList, sslId);
373 if (ssl == NULL) {
374 LOG_ERROR("Not Find Ssl");
375 ret = ERROR;
376 goto EXIT;
377 }
378
379 ret = HLT_TlsConnect(ssl);
380
381 EXIT:
382 // Return the result
383 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
384 ASSERT_RETURN(ret > 0);
385 return SUCCESS;
386 }
387
RpcTlsRead(CmdData * cmdData)388 int RpcTlsRead(CmdData *cmdData)
389 {
390 int ret = SUCCESS;
391
392 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
393 ResList *sslList = GetSslList();
394 int sslId = atoi(cmdData->paras[0]);
395 void *ssl = GetTlsResFromId(sslList, sslId);
396 if (ssl == NULL) {
397 LOG_ERROR("Not Find Ssl");
398 ret = ERROR;
399 goto ERR;
400 }
401
402 int dataLen = atoi(cmdData->paras[1]);
403 uint32_t readLen = 0;
404 if (dataLen == 0) {
405 LOG_ERROR("dataLen is 0");
406 ret = ERROR;
407 goto ERR;
408 }
409 uint8_t *data = (uint8_t *)calloc(1u, dataLen);
410 if (data == NULL) {
411 LOG_ERROR("Calloc Error");
412 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
413 ASSERT_RETURN(ret > 0);
414 }
415 (void)memset_s(data, dataLen, 0, dataLen);
416 ret = HLT_TlsRead(ssl, data, dataLen, &readLen);
417
418 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|%u|%s",
419 cmdData->id, cmdData->funcId, ret, readLen, data);
420 free(data);
421 return SUCCESS;
422 ERR:
423 // Return the result
424 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|", cmdData->id, cmdData->funcId, ret);
425 ASSERT_RETURN(ret > 0);
426 return SUCCESS;
427 }
428
RpcTlsWrite(CmdData * cmdData)429 int RpcTlsWrite(CmdData *cmdData)
430 {
431 int ret;
432 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
433
434 ResList *sslList = GetSslList();
435 int sslId = atoi(cmdData->paras[0]);
436 void *ssl = GetTlsResFromId(sslList, sslId);
437 if (ssl == NULL) {
438 LOG_ERROR("Not Find Ssl");
439 ret = ERROR;
440 goto ERR;
441 }
442
443 int dataLen = atoi(cmdData->paras[1]); // The first parameter indicates the data length.
444 if (dataLen == 0) {
445 LOG_ERROR("dataLen is 0");
446 ret = ERROR;
447 goto ERR;
448 }
449 uint8_t *data = (uint8_t *)calloc(1u, dataLen);
450 if (data == NULL) {
451 LOG_ERROR("Calloc Error");
452 ret = ERROR;
453 goto ERR;
454 }
455 if (dataLen >= CONTROL_CHANNEL_MAX_MSG_LEN) {
456 free(data);
457 goto ERR;
458 }
459 // The second parameter of indicates the content of the write data.
460 ret = memcpy_s(data, dataLen, cmdData->paras[2], dataLen);
461 if (ret != EOK) {
462 LOG_ERROR("memcpy_s Error");
463 free(data);
464 goto ERR;
465 }
466 ret = HLT_TlsWrite(ssl, data, dataLen);
467 free(data);
468 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
469 ASSERT_RETURN(ret > 0);
470 return SUCCESS;
471 ERR:
472 // Return the result
473 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
474 ASSERT_RETURN(ret > 0);
475 return SUCCESS;
476 }
477
RpcTlsRenegotiate(CmdData * cmdData)478 int RpcTlsRenegotiate(CmdData *cmdData)
479 {
480 int ret = ERROR;
481 ResList *sslList = GetSslList();
482 int sslId = (int)strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
483 void *ssl = GetTlsResFromId(sslList, sslId);
484 if (ssl == NULL) {
485 LOG_ERROR("Not Find Ssl");
486 goto EXIT;
487 }
488
489 ret = HLT_TlsRenegotiate(ssl);
490
491 EXIT:
492 // Return the result
493 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
494 ASSERT_RETURN(ret > 0);
495 return SUCCESS;
496 }
497
RpcTlsVerifyClientPostHandshake(CmdData * cmdData)498 int RpcTlsVerifyClientPostHandshake(CmdData *cmdData)
499 {
500 int ret = ERROR;
501 ResList *sslList = GetSslList();
502 int sslId = (int)strtol(cmdData->paras[0], NULL, 10); // Convert to a decimal number
503 void *ssl = GetTlsResFromId(sslList, sslId);
504 if (ssl == NULL) {
505 LOG_ERROR("Not Find Ssl");
506 goto EXIT;
507 }
508
509 ret = HLT_TlsVerifyClientPostHandshake(ssl);
510
511 EXIT:
512 // Return Result
513 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
514 ASSERT_RETURN(ret > 0);
515 return SUCCESS;
516 }
517
RpcProcessExit(CmdData * cmdData)518 int RpcProcessExit(CmdData *cmdData)
519 {
520 int ret;
521 // If 1 is returned, the process needs to exit
522 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
523 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, getpid());
524 ASSERT_RETURN(ret > 0);
525 return 1;
526 }
527
RpcDataChannelAccept(CmdData * cmdData)528 int RpcDataChannelAccept(CmdData *cmdData)
529 {
530 int sockFd, ret;
531 DataChannelParam channelParam;
532
533 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
534 (void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
535
536 channelParam.type = atoi(cmdData->paras[0]);
537 channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number
538 channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether to block
539 channelParam.bindFd = atoi(cmdData->paras[3]); // The third parameter of indicates whether the cis blocked.
540
541 // Invoke the blocking interface
542 sockFd = RunDataChannelAccept(&channelParam);
543
544 // Return the result.
545 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, sockFd);
546 ASSERT_RETURN(ret > 0);
547 return SUCCESS;
548 }
549
RpcDataChannelBind(CmdData * cmdData)550 int RpcDataChannelBind(CmdData *cmdData)
551 {
552 int sockFd, ret;
553 DataChannelParam channelParam;
554
555 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
556 (void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
557
558 channelParam.type = atoi(cmdData->paras[0]);
559 channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number
560 channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether to block
561 channelParam.bindFd = atoi(cmdData->paras[3]); // The third parameter of indicates whether the cis blocked.
562
563 // Invoke the blocking interface
564 sockFd = RunDataChannelBind(&channelParam);
565
566 // Return the result.
567 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d|%d", cmdData->id, cmdData->funcId,
568 sockFd, channelParam.port);
569 ASSERT_RETURN(ret > 0);
570 return SUCCESS;
571 }
572
573
RpcDataChannelConnect(CmdData * cmdData)574 int RpcDataChannelConnect(CmdData *cmdData)
575 {
576 int ret, sockFd;
577 DataChannelParam channelParam;
578
579 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
580 (void)memset_s(&channelParam, sizeof(DataChannelParam), 0, sizeof(DataChannelParam));
581
582 channelParam.type = atoi(cmdData->paras[0]);
583 channelParam.port = atoi(cmdData->paras[1]); // The first parameter of indicates the port number.
584 channelParam.isBlock = atoi(cmdData->paras[2]); // The second parameter of indicates whether the is blocked
585
586 sockFd = HLT_DataChannelConnect(&channelParam);
587
588 // Return the result.
589 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, sockFd);
590 ASSERT_RETURN(ret > 0);
591 return SUCCESS;
592 }
593
RpcTlsRegCallback(CmdData * cmdData)594 int RpcTlsRegCallback(CmdData *cmdData)
595 {
596 int ret;
597 TlsCallbackType type;
598 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
599
600 type = atoi(cmdData->paras[0]);
601 // Invoke the corresponding function
602 ret = HLT_TlsRegCallback(type);
603
604 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
605 ASSERT_RETURN(ret > 0);
606 return SUCCESS;
607 }
608
RpcTlsGetStatus(CmdData * cmdData)609 int RpcTlsGetStatus(CmdData *cmdData)
610 {
611 int ret, sslId;
612 uint32_t sslState = 0;
613 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
614
615 ResList *sslList = GetSslList();
616 sslId = atoi(cmdData->paras[0]);
617 void *ssl = GetTlsResFromId(sslList, sslId);
618 if (ssl != NULL) {
619 sslState = ((HITLS_Ctx *)ssl)->state;
620 }
621
622 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%u", cmdData->id, cmdData->funcId, sslState);
623 ASSERT_RETURN(ret > 0);
624 return SUCCESS;
625 }
626
RpcTlsGetAlertFlag(CmdData * cmdData)627 int RpcTlsGetAlertFlag(CmdData *cmdData)
628 {
629 int ret, sslId;
630 ALERT_Info alertInfo = {0};
631 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
632
633 ResList *sslList = GetSslList();
634 sslId = atoi(cmdData->paras[0]);
635 void *ssl = GetTlsResFromId(sslList, sslId);
636 if (ssl != NULL) {
637 ALERT_GetInfo(ssl, &alertInfo);
638 }
639
640 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
641 cmdData->id, cmdData->funcId, alertInfo.flag);
642 ASSERT_RETURN(ret > 0);
643 return SUCCESS;
644 }
645
RpcTlsGetAlertLevel(CmdData * cmdData)646 int RpcTlsGetAlertLevel(CmdData *cmdData)
647 {
648 int ret, sslId;
649 ALERT_Info alertInfo = {0};
650 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
651
652 ResList *sslList = GetSslList();
653 sslId = atoi(cmdData->paras[0]);
654 void *ssl = GetTlsResFromId(sslList, sslId);
655 if (ssl != NULL) {
656 ALERT_GetInfo(ssl, &alertInfo);
657 }
658
659 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
660 cmdData->id, cmdData->funcId, alertInfo.level);
661 ASSERT_RETURN(ret > 0);
662 return SUCCESS;
663 }
664
RpcTlsGetAlertDescription(CmdData * cmdData)665 int RpcTlsGetAlertDescription(CmdData *cmdData)
666 {
667 int ret, sslId;
668 ALERT_Info alertInfo = {0};
669 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
670
671 ResList *sslList = GetSslList();
672 sslId = atoi(cmdData->paras[0]);
673 void *ssl = GetTlsResFromId(sslList, sslId);
674 if (ssl != NULL) {
675 ALERT_GetInfo(ssl, &alertInfo);
676 }
677
678 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d",
679 cmdData->id, cmdData->funcId, alertInfo.description);
680 ASSERT_RETURN(ret > 0);
681 return SUCCESS;
682 }
683
RpcTlsClose(CmdData * cmdData)684 int RpcTlsClose(CmdData *cmdData)
685 {
686 int ret, sslId;
687 void *ssl = NULL;
688 char *endPtr = NULL;
689
690 ASSERT_RETURN(memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result)) == EOK);
691 ResList *sslList = GetSslList();
692 sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
693 ssl = GetTlsResFromId(sslList, sslId);
694 ASSERT_RETURN(ssl != NULL);
695
696 ret = HLT_TlsClose(ssl);
697
698 // Return the result
699 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
700 ASSERT_RETURN(ret > 0);
701 return SUCCESS;
702 }
703
RpcFreeResFormSsl(CmdData * cmdData)704 int RpcFreeResFormSsl(CmdData *cmdData)
705 {
706 int ret, sslId;
707 void *ssl = NULL;
708 char *endPtr = NULL;
709
710 ASSERT_RETURN(memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result)) == EOK);
711 ResList *sslList = GetSslList();
712 sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
713 ssl = GetTlsResFromId(sslList, sslId);
714 ASSERT_RETURN(ssl != NULL);
715
716 ret = HLT_FreeResFromSsl(ssl);
717
718 // Return the result
719 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
720 ASSERT_RETURN(ret > 0);
721 return SUCCESS;
722 }
723
RpcCloseFd(CmdData * cmdData)724 int RpcCloseFd(CmdData *cmdData)
725 {
726 int ret, fd, linkType;
727 char *endPtr = NULL;
728 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
729
730 fd = (int)strtol(cmdData->paras[0], &endPtr, 0);
731 linkType = (int)strtol(cmdData->paras[1], &endPtr, 0);
732
733 ret = SUCCESS;
734 HLT_CloseFd(fd, linkType);
735
736 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
737 ASSERT_RETURN(ret > 0);
738 return SUCCESS;
739 }
740
RpcTlsSetMtu(CmdData * cmdData)741 int RpcTlsSetMtu(CmdData *cmdData)
742 {
743 int ret, sslId;
744 uint16_t mtu;
745 void *ssl = NULL;
746 char *endPtr = NULL;
747 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
748
749 ResList *sslList = GetSslList();
750 sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
751 mtu = (int)strtol(cmdData->paras[1], &endPtr, 0);
752 ssl = GetTlsResFromId(sslList, sslId);
753 ASSERT_RETURN(ssl != NULL);
754
755 ret = HLT_TlsSetMtu(ssl, mtu);
756
757 ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, ret);
758 ASSERT_RETURN(ret > 0);
759 return SUCCESS;
760 }
761
RpcTlsGetErrorCode(CmdData * cmdData)762 int RpcTlsGetErrorCode(CmdData *cmdData)
763 {
764 int sslId;
765 int errorCode;
766 void *ssl = NULL;
767 char *endPtr = NULL;
768 (void)memset_s(cmdData->result, sizeof(cmdData->result), 0, sizeof(cmdData->result));
769
770 ResList *sslList = GetSslList();
771 sslId = (int)strtol(cmdData->paras[0], &endPtr, 0);
772 ssl = GetTlsResFromId(sslList, sslId);
773 ASSERT_RETURN(ssl != NULL);
774
775 errorCode = HLT_TlsGetErrorCode(ssl);
776
777 int ret = sprintf_s(cmdData->result, sizeof(cmdData->result), "%s|%s|%d", cmdData->id, cmdData->funcId, errorCode);
778 ASSERT_RETURN(ret > 0);
779 return SUCCESS;
780 }