1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "fillp_stack_app_config_in.h"
17
18 #ifdef __cplusplus
19 extern "C" {
20 #endif
21
FillpValidateSockAllocStateWithRdwaitAcquired(struct FtSocket * sock,FILLP_INT sockIndex)22 static FILLP_INT FillpValidateSockAllocStateWithRdwaitAcquired(struct FtSocket *sock, FILLP_INT sockIndex)
23 {
24 if ((sock)->allocState != SOCK_ALLOC_STATE_COMM) {
25 FILLP_LOGERR("Invalid socket Type. This function allowed only for communication socket = %d", sockIndex);
26 (void)SYS_ARCH_RWSEM_RDPOST(&((sock)->sockConnSem));
27 SET_ERRNO(FILLP_ENOTSOCK);
28 return -1;
29 }
30 return 0;
31 }
32
FtGetRightAppResourceByIndex(struct GlobalAppResource ** resource,FILLP_INT sockIndex)33 static FILLP_INT FtGetRightAppResourceByIndex(struct GlobalAppResource **resource, FILLP_INT sockIndex)
34 {
35 struct FtSocket *sock = FILLP_NULL_PTR;
36 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
37 sock = SockGetSocket(sockIndex);
38 if (sock == FILLP_NULL_PTR) {
39 FILLP_LOGERR("Invalid fillp_sock_id:%d", sockIndex);
40 return ERR_PARAM;
41 }
42
43 /* All configuration changes are not write protected, so other thread can read old value when this
44 function is getting executed. but this is ok as per fillp design. */
45 if (SYS_ARCH_RWSEM_TRYRDWAIT(&sock->sockConnSem) != ERR_OK) {
46 FILLP_LOGERR("Socket-%d state is changing,maybe closing", sockIndex);
47 return ERR_FAILURE;
48 }
49
50 if (FillpValidateSockAllocStateWithRdwaitAcquired(sock, sockIndex)) {
51 return -1;
52 }
53
54 *resource = &sock->resConf;
55 } else {
56 *resource = &g_appResource;
57 }
58
59 return ERR_OK;
60 }
61
FtCheckCofigPar(FILLP_CONST FillpAppGlobalConfigsSt * resource,FILLP_INT sockIndex)62 static FILLP_INT32 FtCheckCofigPar(FILLP_CONST FillpAppGlobalConfigsSt *resource, FILLP_INT sockIndex)
63 {
64 if ((sockIndex != FILLP_MAX_UNSHORT_VAL) && ((g_spunge == FILLP_NULL_PTR) ||
65 (g_spunge->hasInited == FILLP_FALSE))) {
66 FILLP_LOGERR("Cannot Set Socket level config value before stack initialization fillp_sock_id:%d !!!",
67 sockIndex);
68 return ERR_PARAM;
69 }
70 FILLP_INT32 ret = FtAppValidateConfigParams(resource);
71 if (ret == ERR_FAILURE) {
72 return ERR_PARAM;
73 }
74 return ERR_OK;
75 }
76
CopyGlobalConfig(FILLP_CONST FillpAppGlobalConfigsSt * globalConfig,struct GlobalAppResource * resource)77 static void CopyGlobalConfig(FILLP_CONST FillpAppGlobalConfigsSt *globalConfig, struct GlobalAppResource *resource)
78 {
79 if (globalConfig == FILLP_NULL_PTR || resource == FILLP_NULL_PTR) {
80 return;
81 }
82 resource->udp.txBurst = globalConfig->udp.txBurst;
83
84 #ifdef FILLP_SERVER_SUPPORT
85 resource->common.maxServerAllowSendCache = globalConfig->common.maxServerAllowSendCache;
86 resource->common.maxServerAllowRecvCache = globalConfig->common.maxServerAllowRecvCache;
87 #endif
88
89 resource->common.connectTimeout = globalConfig->timers.connectTimeout;
90 resource->common.keepAliveTime = globalConfig->timers.keepAliveTime;
91 resource->common.udpSendBufSize = globalConfig->common.udpSendBufSize;
92 resource->common.recvBufSize = globalConfig->common.recvBufSize;
93
94 resource->common.enlargePackIntervalFlag = globalConfig->common.enlargePackIntervalFlag;
95 resource->common.enableNackDelay = globalConfig->common.enableNackDelay;
96 resource->common.nackDelayTimeout = globalConfig->common.nackDelayTimeout;
97 resource->common.sendCache = globalConfig->common.sendCache;
98 resource->common.recvCache = globalConfig->common.recvCache;
99 resource->common.connRetryTimeout = globalConfig->timers.connRetrytimeout;
100 resource->common.disconnectRetryTimeout = globalConfig->timers.disconnectRetrytimeout;
101
102 resource->flowControl.constRateEnbale = globalConfig->flowControl.constRateEnbale;
103 resource->flowControl.maxRate = globalConfig->flowControl.maxRate;
104 resource->flowControl.maxRecvRate = globalConfig->flowControl.maxRecvRate;
105
106 /* Implementing Fair Bandwidth sharing among sockets */
107 #ifdef FILLP_SERVER_SUPPORT
108 resource->flowControl.oppositeSetRate = globalConfig->flowControl.oppositeSetRate;
109 #endif
110
111 resource->flowControl.pktSize = globalConfig->flowControl.pktSize;
112 resource->flowControl.slowStart = globalConfig->flowControl.slowStart;
113 }
114
115 /*******************************************************************
116 Function : FtInitConfigSet
117 Description : Api is used to set all the FILLP global stack configuration. please refer FillpGlobalConfigsSt
118 for parameter details.
119 Calls :
120 Called By :
121 Input : structure of type FILLP_GLOBAL_RESOURCE
122 Output :
123 Return : FILLP_UINT32 SUCCESS/FAILURE
124 Others :
125 ********************************************************************/
FtAppInitConfigSet(IN FILLP_CONST FillpAppGlobalConfigsSt * globalConfig,IN FILLP_INT sockIndex)126 FILLP_INT32 FtAppInitConfigSet(IN FILLP_CONST FillpAppGlobalConfigsSt *globalConfig, IN FILLP_INT sockIndex)
127 {
128 struct FtSocket *sock = FILLP_NULL_PTR;
129 struct GlobalAppResource *resource = FILLP_NULL_PTR;
130 FILLP_INT32 ret = FtCheckCofigPar(globalConfig, sockIndex);
131 if (ret != ERR_OK) {
132 return ret;
133 }
134
135 ret = FtGetRightAppResourceByIndex(&resource, sockIndex);
136 if (ret != ERR_OK) {
137 return ret;
138 }
139
140 CopyGlobalConfig(globalConfig, resource);
141
142 /* need to post in 2 cases:
143 a) if the config is being set for a particular socket
144 b) if set for global after stack init, since it needs to be updated on all
145 the existing socket.
146 So, if the stack is not init and it is being set globally, then no need
147 to post it, since there are no sockets for which it needs to be set */
148 ret = FtAppConfigInitNackDelayCfg(sockIndex, resource);
149 if (ret != ERR_OK) {
150 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
151 sock = SockGetSocket(sockIndex);
152 (void)SYS_ARCH_RWSEM_RDPOST(&sock->sockConnSem);
153 }
154
155 return ret;
156 }
157
158 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
159 sock = SockGetSocket(sockIndex);
160 (void)SYS_ARCH_RWSEM_RDPOST(&sock->sockConnSem);
161 }
162
163 return ERR_OK;
164 }
165
CopySockConfig(FillpAppGlobalConfigsSt * gresource,struct GlobalAppResource * resource)166 static void CopySockConfig(FillpAppGlobalConfigsSt *gresource, struct GlobalAppResource *resource)
167 {
168 if (gresource == FILLP_NULL_PTR || resource == FILLP_NULL_PTR) {
169 return;
170 }
171 gresource->udp.txBurst = (FILLP_UINT16)resource->udp.txBurst;
172
173 #ifdef FILLP_SERVER_SUPPORT
174 gresource->common.maxServerAllowSendCache = resource->common.maxServerAllowSendCache;
175 gresource->common.maxServerAllowRecvCache = resource->common.maxServerAllowRecvCache;
176 #endif
177
178 gresource->common.udpSendBufSize = resource->common.udpSendBufSize;
179 gresource->common.recvBufSize = resource->common.recvBufSize;
180 gresource->timers.connectTimeout = resource->common.connectTimeout;
181 gresource->timers.keepAliveTime = resource->common.keepAliveTime;
182
183 gresource->common.enlargePackIntervalFlag = resource->common.enlargePackIntervalFlag;
184 gresource->common.enableNackDelay = resource->common.enableNackDelay;
185 gresource->common.nackDelayTimeout = resource->common.nackDelayTimeout;
186 gresource->common.sendCache = resource->common.sendCache;
187 gresource->common.recvCache = resource->common.recvCache;
188 gresource->timers.connRetrytimeout = resource->common.connRetryTimeout;
189 gresource->timers.disconnectRetrytimeout = resource->common.disconnectRetryTimeout;
190
191 gresource->flowControl.constRateEnbale = resource->flowControl.constRateEnbale;
192 gresource->flowControl.maxRate = resource->flowControl.maxRate;
193 gresource->flowControl.maxRecvRate = resource->flowControl.maxRecvRate;
194
195 #ifdef FILLP_SERVER_SUPPORT
196 gresource->flowControl.oppositeSetRate = resource->flowControl.oppositeSetRate;
197 #endif
198 gresource->flowControl.pktSize = resource->flowControl.pktSize;
199 gresource->flowControl.slowStart = resource->flowControl.slowStart;
200 }
201
202 /*******************************************************************
203 Function : FtInitConfigGet
204 Description : Api is used to Querry the existing configuration values for all the
205 FILLP global stack configurations. please refer FillpGlobalConfigsSt
206 for parameter details.
207 Calls :
208 Called By :
209 Input : structure of type FILLP_GLOBAL_RESOURCE
210 Output : updated globalResource with current configuration values.
211 Return : FILLP_UINT32 SUCCESS/FAILURE
212 Others :
213 ********************************************************************/
FtAppInitConfigGet(IO FillpAppGlobalConfigsSt * globalResource,IN FILLP_INT sockIndex)214 FILLP_INT32 FtAppInitConfigGet(IO FillpAppGlobalConfigsSt *globalResource, IN FILLP_INT sockIndex)
215 {
216 struct FtSocket *sock = FILLP_NULL_PTR;
217 struct GlobalAppResource *resource = FILLP_NULL_PTR;
218 FILLP_INT ret;
219
220 if ((sockIndex != FILLP_MAX_UNSHORT_VAL) && ((g_spunge == FILLP_NULL_PTR) ||
221 (g_spunge->hasInited == FILLP_FALSE))) {
222 FILLP_LOGERR("Cannot Get Socket level config value before stack initialization fillp_sock_id:%d!!!",
223 sockIndex);
224 return ERR_PARAM;
225 }
226
227 ret = FtGetRightAppResourceByIndex(&resource, sockIndex);
228 if (ret != ERR_OK) {
229 return ret;
230 }
231 CopySockConfig(globalResource, resource);
232 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
233 sock = SockGetSocket(sockIndex);
234 if (sock == FILLP_NULL_PTR) {
235 FILLP_LOGERR("Invalid fillp_sock_id:%d", sockIndex);
236 return ERR_PARAM;
237 }
238
239 (void)SYS_ARCH_RWSEM_RDPOST(&sock->sockConnSem);
240 }
241
242 return ERR_OK;
243 }
244
FtInnerValidateAppConfigSet(FILLP_UINT32 name,struct FtSocket * sock,FILLP_INT sockIndex)245 static FILLP_INT32 FtInnerValidateAppConfigSet(FILLP_UINT32 name, struct FtSocket *sock, FILLP_INT sockIndex)
246 {
247 if ((name == FT_CONF_MAX_SERVER_ALLOW_SEND_CACHE) || (name == FT_CONF_MAX_SERVER_ALLOW_RECV_CACHE)) {
248 if (sock->isListenSock != FILLP_TRUE) {
249 FILLP_LOGERR("Cannot set option name = %u for non-server socket, isListenSock= %u. fillp_sock_id:%d",
250 name, sock->isListenSock, sockIndex);
251 return ERR_PARAM;
252 }
253 }
254
255 if ((name == FT_CONF_SEND_CACHE) || (name == FT_CONF_RECV_CACHE) || (name == FT_CONF_PACKET_SIZE)) {
256 if (sock->netconn != FILLP_NULL_PTR) {
257 if (sock->netconn->state == CONN_STATE_CONNECTING) {
258 FILLP_LOGERR("Cannot set option name = %u during connection, state= %u. fillp_sock_id:%d", name,
259 sock->netconn->state, sockIndex);
260
261 return ERR_PARAM;
262 }
263 }
264 }
265
266 if ((name == FT_CONF_ENABLE_NACK_DELAY) && (sockIndex != FILLP_MAX_UNSHORT_VAL)) {
267 FILLP_LOGERR("Cannot set option name = %u for individual sockets. fillp_sock_id:%d", name, sockIndex);
268 return ERR_PARAM;
269 }
270
271 return FILLP_SUCCESS;
272 }
273
FtSetConfigApp(IN FILLP_UINT32 name,IN FILLP_CONST void * value,IN FILLP_CONST void * param)274 FILLP_INT32 FtSetConfigApp(IN FILLP_UINT32 name, IN FILLP_CONST void *value, IN FILLP_CONST void *param)
275 {
276 struct FtSocket *sock = FILLP_NULL_PTR;
277 struct GlobalAppResource *resource = FILLP_NULL_PTR;
278 FILLP_INT sockIndex;
279 FILLP_INT32 ret;
280
281 FILLP_LOGINF("name:%u", name);
282
283 if (param == FILLP_NULL_PTR) {
284 FILLP_LOGERR("Parameter Error!");
285 return ERR_NULLPTR;
286 }
287
288 sockIndex = *(FILLP_INT *)param;
289 if (sockIndex != FILLP_CONFIG_ALL_SOCKET) {
290 if ((g_spunge == FILLP_NULL_PTR) || (g_spunge->hasInited == FILLP_FALSE)) {
291 FILLP_LOGERR("Cannot set Socket level config value before stack initialization fillp_sock_id:%d",
292 sockIndex);
293 return ERR_PARAM;
294 }
295
296 sock = SockGetSocket(sockIndex);
297 if (sock == FILLP_NULL_PTR) {
298 FILLP_LOGERR("Invalid fillp_sock_id:%d", sockIndex);
299 return ERR_PARAM;
300 }
301
302 /* All configuration changes are not write protected, so other thread can read old value when this
303 function is getting executed. but this is ok as per fillp design. */
304 if (SYS_ARCH_RWSEM_TRYRDWAIT(&sock->sockConnSem) != ERR_OK) {
305 FILLP_LOGERR("Socket-%d State is changing,maybe closing", sockIndex);
306 return ERR_FAILURE;
307 }
308
309 if (FillpValidateSockAllocStateWithRdwaitAcquired(sock, sockIndex)) {
310 return -1;
311 }
312
313 ret = FtInnerValidateAppConfigSet(name, sock, sockIndex);
314 if (ret != FILLP_SUCCESS) {
315 (void)SYS_ARCH_RWSEM_RDPOST(&sock->sockConnSem);
316 return ret; /* No need to log, already error is logged inside FtInnerValidateAppConfigSet */
317 }
318
319 resource = &sock->resConf;
320 ret = FtInnerAppConfigSet(name, value, resource, sockIndex, sock);
321 (void)SYS_ARCH_RWSEM_RDPOST(&sock->sockConnSem);
322 } else {
323 resource = &g_appResource;
324 ret = FtInnerAppConfigSet(name, value, resource, sockIndex, sock);
325 }
326 FILLP_LOGINF("name:%u,fillp_sock_id:%d,ret:%d", name, sockIndex, ret);
327 return ret;
328 }
329
FtCheckSockValid(struct FtSocket * sock)330 static FILLP_INT32 FtCheckSockValid(struct FtSocket *sock)
331 {
332 struct FtNetconn *netconn = FILLP_NULL_PTR;
333 if ((sock->netconn == FILLP_NULL_PTR) || (sock->allocState == SOCK_ALLOC_STATE_FREE)) {
334 FILLP_LOGERR("ERR_NULLPTR sock->netconn or sock->allocState is SOCK_ALLOC_STATE_FREE");
335 return ERR_NULLPTR;
336 }
337
338 netconn = (struct FtNetconn *)(sock->netconn);
339 if (netconn->pcb == FILLP_NULL_PTR) {
340 FILLP_LOGERR("ERR_NULLPTR netconn->pcb");
341 return ERR_NULLPTR;
342 }
343
344 return ERR_OK;
345 }
346
FtGetAppFcPeriodRecvRate(struct FtSocket * sock,FILLP_UINT32 * value)347 static FILLP_INT32 FtGetAppFcPeriodRecvRate(struct FtSocket *sock, FILLP_UINT32 *value)
348 {
349 struct FtNetconn *netconn = FILLP_NULL_PTR;
350 struct FillpStatisticsPcb *statisticsPcb = FILLP_NULL_PTR;
351 if (FtCheckSockValid(sock) != ERR_OK) {
352 return -1;
353 }
354 netconn = (struct FtNetconn *)(sock->netconn);
355 statisticsPcb = &(netconn->pcb->fpcb.statistics);
356 *value = statisticsPcb->appFcStastics.periodRecvRate;
357
358 return ERR_OK;
359 }
360
FtGetAppFcPeriodRecvRateBps(struct FtSocket * sock,FILLP_ULLONG * value)361 static FILLP_INT32 FtGetAppFcPeriodRecvRateBps(struct FtSocket *sock, FILLP_ULLONG *value)
362 {
363 struct FtNetconn *netconn = FILLP_NULL_PTR;
364 struct FillpStatisticsPcb *statisticsPcb = FILLP_NULL_PTR;
365 if (FtCheckSockValid(sock) != ERR_OK) {
366 return -1;
367 }
368 netconn = (struct FtNetconn *)(sock->netconn);
369 statisticsPcb = &(netconn->pcb->fpcb.statistics);
370 *value = statisticsPcb->appFcStastics.periodRecvRateBps;
371 return ERR_OK;
372 }
373
FtGetAppFcPeriodRecvPktLost(struct FtSocket * sock,FILLP_UINT32 * value)374 static FILLP_INT32 FtGetAppFcPeriodRecvPktLost(struct FtSocket *sock, FILLP_UINT32 *value)
375 {
376 struct FtNetconn *netconn = FILLP_NULL_PTR;
377 struct FillpStatisticsPcb *statisticsPcb = FILLP_NULL_PTR;
378 if (FtCheckSockValid(sock) != ERR_OK) {
379 return -1;
380 }
381 netconn = (struct FtNetconn *)(sock->netconn);
382 statisticsPcb = &(netconn->pcb->fpcb.statistics);
383 *value = statisticsPcb->appFcStastics.periodRecvPktLoss;
384
385 return ERR_OK;
386 }
387
FtGetAppFcPeriodStastics(struct FtSocket * sock,void * value)388 static FILLP_INT32 FtGetAppFcPeriodStastics(struct FtSocket *sock, void *value)
389 {
390 struct FtNetconn *netconn = FILLP_NULL_PTR;
391 struct FillAppFcStastics *appFcStastics = FILLP_NULL_PTR;
392 FillpAppFcStasticsSt *app_fc_stastics_out = (FillpAppFcStasticsSt *)value;
393
394 if (FtCheckSockValid(sock) != ERR_OK) {
395 return -1;
396 }
397
398 netconn = (struct FtNetconn *)(sock->netconn);
399 appFcStastics = &(netconn->pcb->fpcb.statistics.appFcStastics);
400
401 app_fc_stastics_out->periodRtt = appFcStastics->periodRtt;
402 app_fc_stastics_out->periodRecvPktLoss = appFcStastics->periodRecvPktLoss;
403 app_fc_stastics_out->periodRecvRate = appFcStastics->periodRecvRate;
404 app_fc_stastics_out->periodRecvPktLossHighPrecision = appFcStastics->periodRecvPktLossHighPrecision;
405 app_fc_stastics_out->periodSendPktLossHighPrecision = appFcStastics->periodSendPktLossHighPrecision;
406 app_fc_stastics_out->periodRecvRateBps = appFcStastics->periodRecvRateBps;
407 app_fc_stastics_out->periodSendRateBps = appFcStastics->periodSendRateBps;
408 app_fc_stastics_out->jitter = FILLP_UTILS_US2MS(sock->jitter);
409
410 return ERR_OK;
411 }
412
FtGetSockValue(void * value,struct FtSocket * sock,FILLP_UINT32 name)413 static FILLP_INT32 FtGetSockValue(void *value, struct FtSocket *sock, FILLP_UINT32 name)
414 {
415 struct GlobalAppResource *resource = FILLP_NULL_PTR;
416 FILLP_INT32 ret;
417 switch (name) {
418 case FT_CONF_RECV_JITTER:
419 *(FILLP_LLONG *)value = sock->jitter;
420 ret = ERR_OK;
421 break;
422 case FT_CONF_APP_FC_RECV_RATE:
423 ret = FtGetAppFcPeriodRecvRate(sock, value);
424 break;
425 case FT_CONF_APP_FC_RECV_RATE_BPS:
426 ret = FtGetAppFcPeriodRecvRateBps(sock, value);
427 break;
428 case FT_CONF_APP_FC_RECV_PKT_LOSS:
429 ret = FtGetAppFcPeriodRecvPktLost(sock, value);
430 break;
431 case FT_CONF_APP_FC_STATISTICS:
432 ret = FtGetAppFcPeriodStastics(sock, value);
433 break;
434 default:
435 resource = &sock->resConf;
436 ret = FtInnerAppConfigGet(name, value, resource);
437 break;
438 }
439 return ret;
440 }
441
442 /*******************************************************************
443 Function : FtGetConfigStack
444 Description : Api is used to get Individual FILLP stack configuration
445 item.
446 Calls :
447 Called By :
448 Input : FILLP_UINT32 name : Name of the config item to querry
449 (FILLP_CONFIG_LISTENUM)
450 void *value : FILLP will store the current value for the config item.
451
452 void *param : this is optional. only required for config items
453 which requires additional information to get the configuration value.
454 for ex:
455 For SOCKET option this will store the Socket index.
456 Output :
457 Return : FILLP_UINT32 SUCCESS/FAILURE
458 Others :
459 ********************************************************************/
FtGetConfigApp(IN FILLP_UINT32 name,IO void * value,IN FILLP_CONST void * param)460 FILLP_INT32 FtGetConfigApp(IN FILLP_UINT32 name, IO void *value, IN FILLP_CONST void *param)
461 {
462 struct FtSocket *sock = FILLP_NULL_PTR;
463 FILLP_INT sockIndex;
464 FILLP_INT32 ret;
465
466 if (param == FILLP_NULL_PTR) {
467 FILLP_LOGERR("Invalid parameter");
468 return ERR_NULLPTR;
469 }
470
471 sockIndex = *(FILLP_INT *)param;
472 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
473 if ((g_spunge == FILLP_NULL_PTR) || (g_spunge->hasInited == FILLP_FALSE)) {
474 FILLP_LOGERR("Cannot set Socket level config value before stack initialization fillp_sock_id:%d",
475 sockIndex);
476 return ERR_PARAM;
477 }
478
479 sock = SockGetSocket(sockIndex);
480 if (sock == FILLP_NULL_PTR) {
481 FILLP_LOGERR("Invalid fillp_sock_id:%d", sockIndex);
482 return ERR_PARAM;
483 }
484
485 /* All configuration changes are not write protected, so other thread can read old value when this
486 function is getting executed. but this is ok as per fillp design. */
487 if (SYS_ARCH_RWSEM_TRYRDWAIT(&sock->sockConnSem) != ERR_OK) {
488 FILLP_LOGERR("Socket-%d state is changing,maybe closing", sockIndex);
489 return ERR_FAILURE;
490 }
491
492 if (FillpValidateSockAllocStateWithRdwaitAcquired(sock, sockIndex)) {
493 return -1;
494 }
495 ret = FtGetSockValue(value, sock, name);
496 (void)SYS_ARCH_RWSEM_RDPOST(&sock->sockConnSem);
497 } else {
498 struct GlobalAppResource *resource = &g_appResource;
499 ret = FtInnerAppConfigGet(name, value, resource);
500 }
501
502 FILLP_LOGINF("name:%u,fillp_sock_id:%d,ret:%d", name, sockIndex, ret);
503 return ret;
504 }
505
506 #ifdef __cplusplus
507 }
508 #endif
509