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)", ret, sendSize, phyId);
41 0 : ret = -ESAFEFUNC;
42 0 : goto out;
43 : }
44 :
45 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
46 1 : if (reqHandleTmp == NULL) {
47 0 : hccp_err("[send][ra_hdc_socket]calloc req_handle_tmp failed, phyId[%u]", phyId);
48 0 : ret = -ENOMEM;
49 0 : goto out;
50 : }
51 1 : *sentSize = 0;
52 1 : reqHandleTmp->privData = (void *)sentSize;
53 :
54 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_SEND, phyId, (char *)asyncData, sizeof(union OpSocketSendData), reqHandleTmp);
55 1 : if (ret != 0) {
56 0 : hccp_err("[send][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
57 0 : free(reqHandleTmp);
58 0 : reqHandleTmp = NULL;
59 0 : goto out;
60 : }
61 :
62 1 : *reqHandle = (void *)reqHandleTmp;
63 :
64 1 : out:
65 1 : free(asyncData);
66 1 : asyncData = NULL;
67 1 : return ret;
68 : }
69 :
70 0 : void RaHdcAsyncHandleSocketSend(struct RaRequestHandle *reqHandle)
71 : {
72 0 : union OpSocketSendData *asyncData = NULL;
73 :
74 0 : if (reqHandle->opRet > 0) {
75 0 : asyncData = (union OpSocketSendData *)reqHandle->recvBuf;
76 0 : *(unsigned long long *)reqHandle->privData = asyncData->rxData.realSendSize;
77 0 : reqHandle->opRet = 0;
78 0 : } else if (reqHandle->opRet == 0) {
79 0 : hccp_warn("[send][ra_hdc_socket]socket has been closed. sent_size is 0");
80 0 : *(unsigned long long *)reqHandle->privData = 0;
81 0 : reqHandle->opRet = -ESOCKCLOSED;
82 : } else {
83 0 : if (reqHandle->opRet != -EAGAIN) {
84 0 : hccp_warn("[send][ra_hdc_socket]socket send unsuccessful ret(%d) phyId(%u)", reqHandle->opRet,
85 : reqHandle->phyId);
86 : }
87 0 : *(unsigned long long *)reqHandle->privData = 0;
88 : }
89 :
90 0 : return;
91 : }
92 :
93 1 : STATIC void RaHdcSocketPrepareRecvRsp(struct RaResponseSocketRecv *recvRsp, void *data, unsigned long long size,
94 : unsigned long long *receivedSize)
95 : {
96 1 : recvRsp->data = data;
97 1 : recvRsp->size = size;
98 1 : *receivedSize = 0;
99 1 : recvRsp->receivedSize = receivedSize;
100 1 : }
101 :
102 1 : int RaHdcSocketRecvAsync(const struct SocketHdcInfo *fdHandle, void *data, unsigned long long size,
103 : unsigned long long *receivedSize, void **reqHandle)
104 : {
105 1 : unsigned long long recvSize = (size > SOCKET_SEND_MAXLEN) ? SOCKET_SEND_MAXLEN : size;
106 1 : struct RaResponseSocketRecv *recvRsp = NULL;
107 1 : struct RaRequestHandle *reqHandleTmp = NULL;
108 1 : union OpSocketRecvData *asyncData = NULL;
109 1 : unsigned int phyId = fdHandle->phyId;
110 1 : int ret = 0;
111 :
112 1 : recvRsp = (struct RaResponseSocketRecv *)calloc(1, sizeof(struct RaResponseSocketRecv));
113 1 : CHK_PRT_RETURN(recvRsp == NULL, hccp_err("[recv][ra_hdc_socket]calloc recv_rsp failed, phyId(%u)", phyId), -ENOMEM);
114 1 : RaHdcSocketPrepareRecvRsp(recvRsp, data, recvSize, receivedSize);
115 :
116 1 : asyncData = (union OpSocketRecvData *)calloc(sizeof(union OpSocketRecvData) + recvSize, sizeof(char));
117 1 : if (asyncData == NULL) {
118 0 : hccp_err("[recv][ra_hdc_socket]calloc async_data failed, phyId(%u)", phyId);
119 0 : ret = -ENOMEM;
120 0 : goto free_recv_rsp;
121 : }
122 :
123 1 : asyncData->txData.fd = (unsigned int)fdHandle->fd;
124 1 : asyncData->txData.recvSize = recvSize;
125 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
126 1 : if (reqHandleTmp == NULL) {
127 0 : hccp_err("[recv][ra_hdc_socket]calloc req_handle_tmp failed, phyId[%u]", phyId);
128 0 : ret = -ENOMEM;
129 0 : goto out;
130 : }
131 1 : reqHandleTmp->privData = (void *)recvRsp;
132 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_RECV, phyId, (char *)asyncData,
133 : (unsigned int)(sizeof(union OpSocketRecvData) + recvSize), reqHandleTmp);
134 1 : if (ret != 0) {
135 0 : hccp_err("[recv][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
136 0 : free(reqHandleTmp);
137 0 : reqHandleTmp = NULL;
138 0 : goto out;
139 : }
140 :
141 1 : free(asyncData);
142 1 : asyncData = NULL;
143 1 : *reqHandle = (void *)reqHandleTmp;
144 1 : return 0;
145 :
146 0 : out:
147 0 : free(asyncData);
148 0 : asyncData = NULL;
149 0 : free_recv_rsp:
150 0 : free(recvRsp);
151 0 : recvRsp = NULL;
152 0 : return ret;
153 : }
154 :
155 0 : void RaHdcAsyncHandleSocketRecv(struct RaRequestHandle *reqHandle)
156 : {
157 0 : struct RaResponseSocketRecv *recvRsp = NULL;
158 0 : union OpSocketRecvData *asyncData = NULL;
159 0 : unsigned long long realRecvSize = 0;
160 0 : unsigned int phyId = 0;
161 0 : int ret = 0;
162 :
163 0 : phyId = reqHandle->phyId;
164 0 : if (reqHandle->opRet == 0) {
165 0 : hccp_warn("[recv][ra_hdc_socket]socket has been closed. received_size is 0");
166 0 : reqHandle->opRet = -ESOCKCLOSED;
167 0 : goto out;
168 0 : } else if (reqHandle->opRet < 0) {
169 0 : if (reqHandle->opRet != -EAGAIN) {
170 0 : hccp_warn("[recv][ra_hdc_socket]socket recv ret(%d) phyId(%u)", reqHandle->opRet, phyId);
171 : }
172 0 : goto out;
173 : }
174 :
175 0 : asyncData = (union OpSocketRecvData *)reqHandle->recvBuf;
176 0 : realRecvSize = asyncData->rxData.realRecvSize;
177 0 : if (realRecvSize > SOCKET_SEND_MAXLEN) {
178 0 : hccp_err("[recv][ra_hdc_socket]real_recv_size:%llu invalid, phyId(%u)", realRecvSize, phyId);
179 0 : reqHandle->opRet = -EINVAL;
180 0 : goto out;
181 : }
182 :
183 0 : recvRsp = (struct RaResponseSocketRecv *)reqHandle->privData;
184 0 : ret = memcpy_s(recvRsp->data, recvRsp->size, (char *)asyncData + sizeof(union OpSocketRecvData), realRecvSize);
185 0 : if (ret != 0) {
186 0 : hccp_err("[recv][ra_hdc_socket]memcpy_s failed, ret(%d) phyId(%u) size(%llu) realRecvSize(%llu)", ret, phyId,
187 : recvRsp->size, realRecvSize);
188 0 : reqHandle->opRet = -ESAFEFUNC;
189 0 : goto out;
190 : }
191 :
192 0 : reqHandle->opRet = 0;
193 0 : *recvRsp->receivedSize = realRecvSize;
194 :
195 0 : out:
196 0 : free(reqHandle->privData);
197 0 : reqHandle->privData = NULL;
198 0 : return;
199 : }
200 :
201 1 : int RaHdcSocketListenStartAsync(unsigned int phyId, struct SocketListenInfoT conn[], unsigned int num, void **reqHandle)
202 : {
203 1 : struct RaResponseSocketListen *asyncRsp = NULL;
204 1 : struct RaRequestHandle *reqHandleTmp = NULL;
205 1 : union OpSocketListenData asyncData = {0};
206 1 : int ret = 0;
207 :
208 1 : ret = RaGetSocketListenInfo(conn, num, asyncData.txData.conn, MAX_SOCKET_NUM);
209 1 : CHK_PRT_RETURN(ret != 0,
210 : hccp_err("[listen_start][ra_hdc_socket]get_socket_listen_info failed, ret(%d) phyId(%u)", ret, phyId), -EINVAL);
211 1 : asyncData.txData.num = num | (1U << SOCKET_USE_PORT_BIT);
212 :
213 1 : asyncRsp = (struct RaResponseSocketListen *)calloc(1, sizeof(struct RaResponseSocketListen));
214 1 : CHK_PRT_RETURN(asyncRsp == NULL, hccp_err("[listen_start][ra_hdc_socket]calloc async_rsp failed, phyId(%u)", phyId),
215 : -ENOMEM);
216 1 : asyncRsp->conn = conn;
217 1 : asyncRsp->num = num;
218 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
219 1 : if (reqHandleTmp == NULL) {
220 0 : hccp_err("[listen_start][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId);
221 0 : ret = -ENOMEM;
222 0 : goto out;
223 : }
224 1 : reqHandleTmp->privData = (void *)asyncRsp;
225 :
226 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_LISTEN_START, phyId, (char *)&asyncData, sizeof(union OpSocketListenData),
227 : reqHandleTmp);
228 1 : if (ret != 0) {
229 0 : hccp_err("[listen_start][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
230 0 : free(reqHandleTmp);
231 0 : reqHandleTmp = NULL;
232 0 : goto out;
233 : }
234 1 : *reqHandle = (void *)reqHandleTmp;
235 1 : return 0;
236 :
237 0 : out:
238 0 : free(asyncRsp);
239 0 : asyncRsp = NULL;
240 0 : return ret;
241 : }
242 :
243 1 : void RaHdcAsyncHandleSocketListenStart(struct RaRequestHandle *reqHandle)
244 : {
245 1 : struct RaResponseSocketListen *asyncRsp = NULL;
246 1 : union OpSocketListenData *asyncData = NULL;
247 1 : unsigned int phyId = reqHandle->phyId;
248 1 : int ret = 0;
249 :
250 1 : asyncData = (union OpSocketListenData *)reqHandle->recvBuf;
251 1 : asyncRsp = (struct RaResponseSocketListen *)reqHandle->privData;
252 1 : ret = RaGetSocketListenResult(asyncData->rxData.conn, asyncRsp->num, asyncRsp->conn, MAX_SOCKET_NUM);
253 1 : if (ret != 0) {
254 1 : hccp_err("[listen_start][ra_hdc_socket]ra_get_socket_listen_result failed, ret(%d) phyId(%u)", ret, phyId);
255 1 : reqHandle->opRet = -EINVAL;
256 1 : goto out;
257 : }
258 0 : return;
259 :
260 1 : out:
261 1 : free(reqHandle->privData);
262 1 : reqHandle->privData = NULL;
263 1 : return;
264 : }
265 :
266 1 : int RaHdcSocketListenStopAsync(unsigned int phyId, struct SocketListenInfoT conn[], unsigned int num, void **reqHandle)
267 : {
268 1 : struct RaRequestHandle *reqHandleTmp = NULL;
269 1 : union OpSocketListenData asyncData = {0};
270 1 : int ret = 0;
271 :
272 1 : ret = RaGetSocketListenInfo(conn, num, asyncData.txData.conn, MAX_SOCKET_NUM);
273 1 : CHK_PRT_RETURN(ret != 0,
274 : hccp_err("[listen_stop][ra_hdc_socket]get_socket_listen_info failed, ret(%d) phyId(%u)", ret, phyId), -EINVAL);
275 1 : asyncData.txData.num = num | (1U << SOCKET_USE_PORT_BIT);
276 :
277 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
278 1 : CHK_PRT_RETURN(reqHandleTmp == NULL,
279 : hccp_err("[listen_stop][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId), -ENOMEM);
280 :
281 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_LISTEN_STOP, phyId, (char *)&asyncData, sizeof(union OpSocketListenData),
282 : reqHandleTmp);
283 1 : if (ret != 0) {
284 0 : hccp_err("[listen_stop][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
285 0 : free(reqHandleTmp);
286 0 : reqHandleTmp = NULL;
287 0 : return ret;
288 : }
289 :
290 1 : *reqHandle = (void *)reqHandleTmp;
291 1 : return 0;
292 : }
293 :
294 1 : int RaHdcSocketBatchConnectAsync(unsigned int phyId, struct SocketConnectInfoT conn[], unsigned int num,
295 : void **reqHandle)
296 : {
297 1 : struct RaRequestHandle *reqHandleTmp = NULL;
298 1 : union OpSocketConnectData *asyncData = NULL;
299 1 : int ret = 0;
300 :
301 1 : asyncData = (union OpSocketConnectData *)calloc(sizeof(union OpSocketConnectData), sizeof(char));
302 1 : CHK_PRT_RETURN(asyncData == NULL,
303 : hccp_err("[batch_connect][ra_hdc_socket]calloc async_data failed, phyId(%u)", phyId), -ENOMEM);
304 :
305 1 : asyncData->txData.num = num | (1U << SOCKET_USE_PORT_BIT);
306 1 : ret = RaGetSocketConnectInfo(conn, num, asyncData->txData.conn, MAX_SOCKET_NUM);
307 1 : if (ret != 0) {
308 0 : hccp_err("[batch_connect][ra_hdc_socket]ra_get_socket_connect_info failed, ret(%d) phyId(%u)", ret, phyId);
309 0 : goto out;
310 : }
311 :
312 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
313 1 : if (reqHandleTmp == NULL) {
314 0 : hccp_err("[batch_connect][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId);
315 0 : ret = -ENOMEM;
316 0 : goto out;
317 : }
318 :
319 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_CONN, phyId, (char *)asyncData, sizeof(union OpSocketConnectData),
320 : reqHandleTmp);
321 1 : if (ret != 0) {
322 0 : hccp_err("[batch_connect][ra_hdc_socket]hdc async send message process failed ret(%d) phyId(%u)", ret, phyId);
323 0 : free(reqHandleTmp);
324 0 : reqHandleTmp = NULL;
325 0 : goto out;
326 : }
327 :
328 1 : *reqHandle = (void *)reqHandleTmp;
329 :
330 1 : out:
331 1 : free(asyncData);
332 1 : asyncData = NULL;
333 1 : return ret;
334 : }
335 :
336 1 : int RaHdcSocketBatchCloseAsync(unsigned int phyId, struct SocketCloseInfoT conn[], unsigned int num, void **reqHandle)
337 : {
338 1 : struct RaResponseSocketBatchClose *asyncRsp = NULL;
339 1 : struct RaRequestHandle *reqHandleTmp = NULL;
340 1 : union OpSocketCloseData asyncData = {0};
341 : unsigned int i;
342 1 : int ret = 0;
343 :
344 2 : for (i = 0; i < num; i++) {
345 1 : if (conn[i].fdHandle == NULL) {
346 0 : hccp_err("[batch_close][ra_hdc_socket]i(%u), conn fdHandle is NULL", i);
347 0 : ret = -EINVAL;
348 0 : goto out;
349 : }
350 1 : asyncData.txData.conn[i].phyId = phyId;
351 1 : asyncData.txData.conn[i].closeFd = ((struct SocketHdcInfo *)conn[i].fdHandle)->fd;
352 : }
353 : // use attr disuse_linger of the fist conn as the common attr for all(0 by default)
354 1 : asyncData.txData.num = (conn[0].disuseLinger != 0) ? (num | (1U << SOCKET_DISUSE_LINGER_BIT)) : num;
355 :
356 1 : asyncRsp = (struct RaResponseSocketBatchClose *)calloc(1, sizeof(struct RaResponseSocketBatchClose));
357 1 : CHK_PRT_RETURN(asyncRsp == NULL, hccp_err("[batch_close][ra_hdc_socket]calloc async_rsp failed, phyId(%u)", phyId),
358 : -ENOMEM);
359 1 : asyncRsp->conn = conn;
360 1 : asyncRsp->num = num;
361 :
362 1 : reqHandleTmp = (struct RaRequestHandle *)calloc(1, sizeof(struct RaRequestHandle));
363 1 : if (reqHandleTmp == NULL) {
364 0 : hccp_err("[batch_close][ra_hdc_socket]calloc RaRequestHandle failed, phyId[%u]", phyId);
365 0 : ret = -ENOMEM;
366 0 : goto out;
367 : }
368 :
369 1 : reqHandleTmp->privData = (void *)asyncRsp;
370 :
371 1 : ret = RaHdcSendMsgAsync(RA_RS_SOCKET_CLOSE, phyId, (char *)&asyncData, sizeof(union OpSocketCloseData),
372 : reqHandleTmp);
373 1 : if (ret != 0) {
374 0 : hccp_err("[batch_close][ra_hdc_socket]hdc async send message process failed, ret(%d) phyId(%u)", ret, phyId);
375 0 : free(reqHandleTmp);
376 0 : reqHandleTmp = NULL;
377 0 : goto out;
378 : }
379 :
380 1 : *reqHandle = (void *)reqHandleTmp;
381 1 : return 0;
382 :
383 0 : out:
384 0 : free(asyncRsp);
385 0 : asyncRsp = NULL;
386 0 : return ret;
387 : }
388 :
389 0 : void RaHdcAsyncHandleSocketBatchClose(struct RaRequestHandle *reqHandle)
390 : {
391 0 : struct RaResponseSocketBatchClose *asyncRsp = NULL;
392 : unsigned int i;
393 :
394 : // should free fd_handle when op_ret is not EAGAIN, otherwise caller will retry
395 0 : if (reqHandle->opRet == -EAGAIN) {
396 0 : return;
397 : }
398 :
399 0 : asyncRsp = (struct RaResponseSocketBatchClose *)reqHandle->privData;
400 0 : for (i = 0; i < asyncRsp->num; i++) {
401 0 : if (asyncRsp->conn[i].fdHandle != NULL) {
402 0 : free(asyncRsp->conn[i].fdHandle);
403 0 : asyncRsp->conn[i].fdHandle = NULL;
404 : }
405 : }
406 0 : return;
407 : }
|
