Line data Source code
1 : /**
2 : * Copyright (c) 2025 Huawei Technologies Co., Ltd.
3 : * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 : * CANN Open Software License Agreement Version 2.0 (the "License").
5 : * Please refer to the License for details. You may not use this file except in compliance with the License.
6 : * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
7 : * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
8 : * See LICENSE in the root of the software repository for the full text of the License.
9 : */
10 :
11 : #include "securec.h"
12 : #include "user_log.h"
13 : #include "ra.h"
14 : #include "ra_comm.h"
15 : #include "ra_async.h"
16 : #include "ra_rs_comm.h"
17 : #include "ra_rs_err.h"
18 : #include "ra_hdc.h"
19 : #include "ra_hdc_socket.h"
20 : #include "ra_hdc_async.h"
21 : #include "ra_hdc_async_socket.h"
22 :
23 1 : int RaHdcSocketSendAsync(const struct SocketHdcInfo *fdHandle, const void *data, unsigned long long size,
24 : unsigned long long *sentSize, void **reqHandle)
25 : {
26 1 : unsigned long long sendSize = (size > SOCKET_SEND_MAXLEN) ? SOCKET_SEND_MAXLEN : size;
27 1 : struct RaRequestHandle *reqHandleTmp = NULL;
28 1 : union OpSocketSendData *asyncData = NULL;
29 1 : unsigned int phyId = fdHandle->phyId;
30 1 : int ret = 0;
31 :
32 1 : asyncData = (union OpSocketSendData *)calloc(sizeof(union OpSocketSendData), sizeof(char));
33 1 : CHK_PRT_RETURN(asyncData == NULL, hccp_err("[send][ra_hdc_socket]calloc async_data failed, phyId(%u)", phyId),
34 : -ENOMEM);
35 :
36 1 : asyncData->txData.fd = (unsigned int)fdHandle->fd;
37 1 : asyncData->txData.sendSize = sendSize;
38 1 : ret = memcpy_s(asyncData->txData.dataSend, SOCKET_SEND_MAXLEN, data, sendSize);
39 1 : if (ret != 0) {
40 0 : hccp_err("[send][ra_hdc_socket]memcpy_s data failed, ret(%d) sendSize(%llu) phyId(%u)",
41 : ret, sendSize, phyId);
42 0 : ret = -ESAFEFUNC;
43 0 : goto out;
44 : }
45 :
46 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
47 1 : if (reqHandleTmp == NULL) {
48 0 : hccp_err("[send][ra_hdc_socket]calloc req_handle_tmp failed, phyId[%u]", phyId);
49 0 : ret = -ENOMEM;
50 0 : goto out;
51 : }
52 1 : *sentSize = 0;
53 1 : reqHandleTmp->privData = (void *)sentSize;
54 :
55 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_SEND, phyId, (char *)asyncData, sizeof(union OpSocketSendData),
56 : reqHandleTmp);
57 1 : if (ret != 0) {
58 0 : hccp_err("[send][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
59 0 : free(reqHandleTmp);
60 0 : reqHandleTmp = NULL;
61 0 : goto out;
62 : }
63 :
64 1 : *reqHandle = (void *)reqHandleTmp;
65 :
66 1 : out:
67 1 : free(asyncData);
68 1 : asyncData = NULL;
69 1 : return ret;
70 : }
71 :
72 0 : void RaHdcAsyncHandleSocketSend(struct RaRequestHandle *reqHandle)
73 : {
74 0 : union OpSocketSendData *asyncData = NULL;
75 :
76 0 : if (reqHandle->opRet > 0) {
77 0 : asyncData = (union OpSocketSendData *)reqHandle->recvBuf;
78 0 : *(unsigned long long *)reqHandle->privData = asyncData->rxData.realSendSize;
79 0 : reqHandle->opRet = 0;
80 0 : } else if (reqHandle->opRet == 0) {
81 0 : hccp_warn("[send][ra_hdc_socket]socket has been closed. sent_size is 0");
82 0 : *(unsigned long long *)reqHandle->privData = 0;
83 0 : reqHandle->opRet = -ESOCKCLOSED;
84 : } else {
85 0 : if (reqHandle->opRet != -EAGAIN) {
86 0 : hccp_warn("[send][ra_hdc_socket]socket send unsuccessful ret(%d) phyId(%u)", reqHandle->opRet,
87 : reqHandle->phyId);
88 : }
89 0 : *(unsigned long long *)reqHandle->privData = 0;
90 : }
91 :
92 0 : return;
93 : }
94 :
95 1 : STATIC void RaHdcSocketPrepareRecvRsp(struct RaResponseSocketRecv *recvRsp, void *data,
96 : unsigned long long size, unsigned long long *receivedSize)
97 : {
98 1 : recvRsp->data = data;
99 1 : recvRsp->size = size;
100 1 : *receivedSize = 0;
101 1 : recvRsp->receivedSize = receivedSize;
102 1 : }
103 :
104 1 : int RaHdcSocketRecvAsync(const struct SocketHdcInfo *fdHandle, void *data, unsigned long long size,
105 : unsigned long long *receivedSize, void **reqHandle)
106 : {
107 1 : unsigned long long recvSize = (size > SOCKET_SEND_MAXLEN) ? SOCKET_SEND_MAXLEN : size;
108 1 : struct RaResponseSocketRecv *recvRsp = NULL;
109 1 : struct RaRequestHandle *reqHandleTmp = NULL;
110 1 : union OpSocketRecvData *asyncData = NULL;
111 1 : unsigned int phyId = fdHandle->phyId;
112 1 : int ret = 0;
113 :
114 1 : recvRsp = (struct RaResponseSocketRecv *)calloc(1, sizeof(struct RaResponseSocketRecv));
115 1 : CHK_PRT_RETURN(recvRsp == NULL, hccp_err("[recv][ra_hdc_socket]calloc recv_rsp failed, phyId(%u)", phyId),
116 : -ENOMEM);
117 1 : RaHdcSocketPrepareRecvRsp(recvRsp, data, recvSize, receivedSize);
118 :
119 1 : asyncData = (union OpSocketRecvData *)calloc(sizeof(union OpSocketRecvData) + recvSize, sizeof(char));
120 1 : if (asyncData == NULL) {
121 0 : hccp_err("[recv][ra_hdc_socket]calloc async_data failed, phyId(%u)", phyId);
122 0 : ret = -ENOMEM;
123 0 : goto free_recv_rsp;
124 : }
125 :
126 1 : asyncData->txData.fd = (unsigned int)fdHandle->fd;
127 1 : asyncData->txData.recvSize = recvSize;
128 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
129 1 : if (reqHandleTmp == NULL) {
130 0 : hccp_err("[recv][ra_hdc_socket]calloc req_handle_tmp failed, phyId[%u]", phyId);
131 0 : ret = -ENOMEM;
132 0 : goto out;
133 : }
134 1 : reqHandleTmp->privData = (void *)recvRsp;
135 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_RECV, phyId, (char *)asyncData,
136 : (unsigned int)(sizeof(union OpSocketRecvData) + recvSize), reqHandleTmp);
137 1 : if (ret != 0) {
138 0 : hccp_err("[recv][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
139 0 : free(reqHandleTmp);
140 0 : reqHandleTmp = NULL;
141 0 : goto out;
142 : }
143 :
144 1 : free(asyncData);
145 1 : asyncData = NULL;
146 1 : *reqHandle = (void *)reqHandleTmp;
147 1 : return 0;
148 :
149 0 : out:
150 0 : free(asyncData);
151 0 : asyncData = NULL;
152 0 : free_recv_rsp:
153 0 : free(recvRsp);
154 0 : recvRsp = NULL;
155 0 : return ret;
156 : }
157 :
158 0 : void RaHdcAsyncHandleSocketRecv(struct RaRequestHandle *reqHandle)
159 : {
160 0 : struct RaResponseSocketRecv *recvRsp = NULL;
161 0 : union OpSocketRecvData *asyncData = NULL;
162 0 : unsigned long long realRecvSize = 0;
163 0 : unsigned int phyId = 0;
164 0 : int ret = 0;
165 :
166 0 : phyId = reqHandle->phyId;
167 0 : if (reqHandle->opRet == 0) {
168 0 : hccp_warn("[recv][ra_hdc_socket]socket has been closed. received_size is 0");
169 0 : reqHandle->opRet = -ESOCKCLOSED;
170 0 : goto out;
171 0 : } else if (reqHandle->opRet < 0) {
172 0 : if (reqHandle->opRet != -EAGAIN) {
173 0 : hccp_warn("[recv][ra_hdc_socket]socket recv ret(%d) phyId(%u)", reqHandle->opRet, phyId);
174 : }
175 0 : goto out;
176 : }
177 :
178 0 : asyncData = (union OpSocketRecvData *)reqHandle->recvBuf;
179 0 : realRecvSize = asyncData->rxData.realRecvSize;
180 0 : if (realRecvSize > SOCKET_SEND_MAXLEN) {
181 0 : hccp_err("[recv][ra_hdc_socket]real_recv_size:%llu invalid, phyId(%u)", realRecvSize, phyId);
182 0 : reqHandle->opRet = -EINVAL;
183 0 : goto out;
184 : }
185 :
186 0 : recvRsp = (struct RaResponseSocketRecv *)reqHandle->privData;
187 0 : ret = memcpy_s(recvRsp->data, recvRsp->size, (char *)asyncData + sizeof(union OpSocketRecvData),
188 : realRecvSize);
189 0 : if (ret != 0) {
190 0 : hccp_err("[recv][ra_hdc_socket]memcpy_s failed, ret(%d) phyId(%u) size(%llu) realRecvSize(%llu)",
191 : ret, phyId, recvRsp->size, realRecvSize);
192 0 : reqHandle->opRet = -ESAFEFUNC;
193 0 : goto out;
194 : }
195 :
196 0 : reqHandle->opRet = 0;
197 0 : *recvRsp->receivedSize = realRecvSize;
198 :
199 0 : out:
200 0 : free(reqHandle->privData);
201 0 : reqHandle->privData = NULL;
202 0 : return;
203 : }
204 :
205 1 : int RaHdcSocketListenStartAsync(unsigned int phyId, struct SocketListenInfoT conn[], unsigned int num,
206 : void **reqHandle)
207 : {
208 1 : struct RaResponseSocketListen *asyncRsp = NULL;
209 1 : struct RaRequestHandle *reqHandleTmp = NULL;
210 1 : union OpSocketListenData asyncData = {0};
211 1 : int ret = 0;
212 :
213 1 : ret = RaGetSocketListenInfo(conn, num, asyncData.txData.conn, MAX_SOCKET_NUM);
214 1 : CHK_PRT_RETURN(ret != 0, hccp_err("[listen_start][ra_hdc_socket]get_socket_listen_info failed, ret(%d) phyId(%u)",
215 : ret, phyId), -EINVAL);
216 1 : asyncData.txData.num = num | (1U << SOCKET_USE_PORT_BIT);
217 :
218 1 : asyncRsp = (struct RaResponseSocketListen *)calloc(1, sizeof(struct RaResponseSocketListen));
219 1 : CHK_PRT_RETURN(asyncRsp == NULL, hccp_err("[listen_start][ra_hdc_socket]calloc async_rsp failed, phyId(%u)",
220 : phyId), -ENOMEM);
221 1 : asyncRsp->conn = conn;
222 1 : asyncRsp->num = num;
223 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
224 1 : if (reqHandleTmp == NULL) {
225 0 : hccp_err("[listen_start][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId);
226 0 : ret = -ENOMEM;
227 0 : goto out;
228 : }
229 1 : reqHandleTmp->privData = (void *)asyncRsp;
230 :
231 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_LISTEN_START, phyId, (char *)&asyncData,
232 : sizeof(union OpSocketListenData), reqHandleTmp);
233 1 : if (ret != 0) {
234 0 : hccp_err("[listen_start][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
235 0 : free(reqHandleTmp);
236 0 : reqHandleTmp = NULL;
237 0 : goto out;
238 : }
239 1 : *reqHandle = (void *)reqHandleTmp;
240 1 : return 0;
241 :
242 0 : out:
243 0 : free(asyncRsp);
244 0 : asyncRsp = NULL;
245 0 : return ret;
246 : }
247 :
248 1 : void RaHdcAsyncHandleSocketListenStart(struct RaRequestHandle *reqHandle)
249 : {
250 1 : struct RaResponseSocketListen *asyncRsp = NULL;
251 1 : union OpSocketListenData *asyncData = NULL;
252 1 : unsigned int phyId = reqHandle->phyId;
253 1 : int ret = 0;
254 :
255 1 : asyncData = (union OpSocketListenData *)reqHandle->recvBuf;
256 1 : asyncRsp = (struct RaResponseSocketListen *)reqHandle->privData;
257 1 : ret = RaGetSocketListenResult(asyncData->rxData.conn, asyncRsp->num, asyncRsp->conn, MAX_SOCKET_NUM);
258 1 : if (ret != 0) {
259 1 : hccp_err("[listen_start][ra_hdc_socket]ra_get_socket_listen_result failed, ret(%d) phyId(%u)", ret, phyId);
260 1 : reqHandle->opRet = -EINVAL;
261 1 : goto out;
262 : }
263 0 : return;
264 :
265 1 : out:
266 1 : free(reqHandle->privData);
267 1 : reqHandle->privData = NULL;
268 1 : return;
269 : }
270 :
271 1 : int RaHdcSocketListenStopAsync(unsigned int phyId, struct SocketListenInfoT conn[], unsigned int num,
272 : void **reqHandle)
273 : {
274 1 : struct RaRequestHandle *reqHandleTmp = NULL;
275 1 : union OpSocketListenData asyncData = {0};
276 1 : int ret = 0;
277 :
278 1 : ret = RaGetSocketListenInfo(conn, num, asyncData.txData.conn, MAX_SOCKET_NUM);
279 1 : CHK_PRT_RETURN(ret != 0, hccp_err("[listen_stop][ra_hdc_socket]get_socket_listen_info failed, ret(%d) phyId(%u)",
280 : ret, phyId), -EINVAL);
281 1 : asyncData.txData.num = num | (1U << SOCKET_USE_PORT_BIT);
282 :
283 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
284 1 : CHK_PRT_RETURN(reqHandleTmp == NULL,
285 : hccp_err("[listen_stop][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId), -ENOMEM);
286 :
287 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_LISTEN_STOP, phyId, (char *)&asyncData,
288 : sizeof(union OpSocketListenData), reqHandleTmp);
289 1 : if (ret != 0) {
290 0 : hccp_err("[listen_stop][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
291 0 : free(reqHandleTmp);
292 0 : reqHandleTmp = NULL;
293 0 : return ret;
294 : }
295 :
296 1 : *reqHandle = (void *)reqHandleTmp;
297 1 : return 0;
298 : }
299 :
300 1 : int RaHdcSocketBatchConnectAsync(unsigned int phyId, struct SocketConnectInfoT conn[], unsigned int num,
301 : void **reqHandle)
302 : {
303 1 : struct RaRequestHandle *reqHandleTmp = NULL;
304 1 : union OpSocketConnectData *asyncData = NULL;
305 1 : int ret = 0;
306 :
307 1 : asyncData = (union OpSocketConnectData *)calloc(sizeof(union OpSocketConnectData), sizeof(char));
308 1 : CHK_PRT_RETURN(asyncData == NULL, hccp_err("[batch_connect][ra_hdc_socket]calloc async_data failed, phyId(%u)",
309 : phyId), -ENOMEM);
310 :
311 1 : asyncData->txData.num = num | (1U << SOCKET_USE_PORT_BIT);
312 1 : ret = RaGetSocketConnectInfo(conn, num, asyncData->txData.conn, MAX_SOCKET_NUM);
313 1 : if (ret != 0) {
314 0 : hccp_err("[batch_connect][ra_hdc_socket]ra_get_socket_connect_info failed, ret(%d) phyId(%u)", ret, phyId);
315 0 : goto out;
316 : }
317 :
318 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
319 1 : if (reqHandleTmp == NULL) {
320 0 : hccp_err("[batch_connect][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId);
321 0 : ret = -ENOMEM;
322 0 : goto out;
323 : }
324 :
325 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_CONN, phyId, (char *)asyncData, sizeof(union OpSocketConnectData),
326 : reqHandleTmp);
327 1 : if (ret != 0) {
328 0 : hccp_err("[batch_connect][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
329 0 : free(reqHandleTmp);
330 0 : reqHandleTmp = NULL;
331 0 : goto out;
332 : }
333 :
334 1 : *reqHandle = (void *)reqHandleTmp;
335 :
336 1 : out:
337 1 : free(asyncData);
338 1 : asyncData = NULL;
339 1 : return ret;
340 : }
341 :
342 1 : int RaHdcSocketBatchCloseAsync(unsigned int phyId, struct SocketCloseInfoT conn[], unsigned int num,
343 : void **reqHandle)
344 : {
345 1 : struct RaResponseSocketBatchClose *asyncRsp = NULL;
346 1 : struct RaRequestHandle *reqHandleTmp = NULL;
347 1 : union OpSocketCloseData asyncData = {0};
348 : unsigned int i;
349 1 : int ret = 0;
350 :
351 2 : for (i = 0; i < num; i++) {
352 1 : if (conn[i].fdHandle == NULL) {
353 0 : hccp_err("[batch_close][ra_hdc_socket]i(%u), conn fdHandle is NULL", i);
354 0 : ret = -EINVAL;
355 0 : goto out;
356 : }
357 1 : asyncData.txData.conn[i].phyId = phyId;
358 1 : asyncData.txData.conn[i].closeFd = ((struct SocketHdcInfo *)conn[i].fdHandle)->fd;
359 : }
360 : // use attr disuse_linger of the fist conn as the common attr for all(0 by default)
361 1 : asyncData.txData.num = (conn[0].disuseLinger != 0) ? (num | (1U << SOCKET_DISUSE_LINGER_BIT)) : num;
362 :
363 1 : asyncRsp = (struct RaResponseSocketBatchClose *)calloc(1, sizeof(struct RaResponseSocketBatchClose));
364 1 : CHK_PRT_RETURN(asyncRsp == NULL, hccp_err("[batch_close][ra_hdc_socket]calloc async_rsp failed, phyId(%u)",
365 : phyId), -ENOMEM);
366 1 : asyncRsp->conn = conn;
367 1 : asyncRsp->num = num;
368 :
369 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
370 1 : if (reqHandleTmp == NULL) {
371 0 : hccp_err("[batch_close][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId);
372 0 : ret = -ENOMEM;
373 0 : goto out;
374 : }
375 :
376 1 : reqHandleTmp->privData = (void *)asyncRsp;
377 :
378 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_CLOSE, phyId, (char *)&asyncData,
379 : sizeof(union OpSocketCloseData), reqHandleTmp);
380 1 : if (ret != 0) {
381 0 : hccp_err("[batch_close][ra_hdc_socket]hdc async send message process failed, ret(%d) phyId(%u)",
382 : ret, phyId);
383 0 : free(reqHandleTmp);
384 0 : reqHandleTmp = NULL;
385 0 : goto out;
386 : }
387 :
388 1 : *reqHandle = (void *)reqHandleTmp;
389 1 : return 0;
390 :
391 0 : out:
392 0 : free(asyncRsp);
393 0 : asyncRsp = NULL;
394 0 : return ret;
395 : }
396 :
397 0 : void RaHdcAsyncHandleSocketBatchClose(struct RaRequestHandle *reqHandle)
398 : {
399 0 : struct RaResponseSocketBatchClose *asyncRsp = NULL;
400 : unsigned int i;
401 :
402 : // should free fd_handle when op_ret is not EAGAIN, otherwise caller will retry
403 0 : if (reqHandle->opRet == -EAGAIN) {
404 0 : return;
405 : }
406 :
407 0 : asyncRsp = (struct RaResponseSocketBatchClose *)reqHandle->privData;
408 0 : for (i = 0; i < asyncRsp->num; i++) {
409 0 : if (asyncRsp->conn[i].fdHandle != NULL) {
410 0 : free(asyncRsp->conn[i].fdHandle);
411 0 : asyncRsp->conn[i].fdHandle = NULL;
412 : }
413 : }
414 0 : return;
415 : }
|
