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
FtAppValidateFlowConfig(IN FILLP_CONST FillpAppGlobalConfigsSt * globalResource)18 static FILLP_INT32 FtAppValidateFlowConfig(IN FILLP_CONST FillpAppGlobalConfigsSt *globalResource)
19 {
20 #ifdef FILLP_SERVER_SUPPORT
21 if ((globalResource->flowControl.oppositeSetRate > FILLP_MAX_STACK_OPPOSITE_SET_RATE) ||
22 (globalResource->flowControl.oppositeSetRate > g_resource.flowControl.maxRate)) {
23 FILLP_LOGERR("oppositeSetRate is invalid parameter oppositeSetRate = %u maxRate = %u !!!",
24 globalResource->flowControl.oppositeSetRate, g_resource.flowControl.maxRate);
25 return ERR_FAILURE;
26 }
27 #endif
28
29 if ((globalResource->flowControl.maxRate == 0) || (globalResource->flowControl.maxRate > FILLP_MAX_STACK_RATE)) {
30 FILLP_LOGERR("maxRate: %u Kbps is invalid parameter!!!", globalResource->flowControl.maxRate);
31 return ERR_FAILURE;
32 }
33
34 if ((globalResource->flowControl.maxRecvRate == 0) ||
35 (globalResource->flowControl.maxRecvRate > FILLP_MAX_STACK_RECV_RATE)) {
36 FILLP_LOGERR("maxRecvRate: %u Kbps is invalid parameter!!!", globalResource->flowControl.maxRecvRate);
37 return ERR_FAILURE;
38 }
39
40 if ((globalResource->flowControl.pktSize == 0) ||
41 (globalResource->flowControl.pktSize > (FILLP_FRAME_MTU - (FILLP_HLEN + UDP_HLEN + IP_HLEN)))) {
42 FILLP_LOGERR("pktSize %u is invalid parameter!!!", globalResource->flowControl.pktSize);
43 return ERR_FAILURE;
44 }
45
46 if ((globalResource->flowControl.slowStart != FILLP_TRUE) &&
47 (globalResource->flowControl.slowStart != FILLP_FALSE)) {
48 FILLP_LOGERR("slowStart %u is invalid parameter!!!", globalResource->flowControl.slowStart);
49 return ERR_FAILURE;
50 }
51
52 if ((globalResource->flowControl.constRateEnbale != FILLP_TRUE) &&
53 (globalResource->flowControl.constRateEnbale != FILLP_FALSE)) {
54 FILLP_LOGERR("constRateEnbale %u is invalid parameter!!!", globalResource->flowControl.constRateEnbale);
55 return ERR_FAILURE;
56 }
57
58 return ERR_OK;
59 }
60
FtAppValidateUdpParams(IN FILLP_CONST FillpAppGlobalConfigsSt * globalResource)61 static FILLP_INT32 FtAppValidateUdpParams(IN FILLP_CONST FillpAppGlobalConfigsSt *globalResource)
62 {
63 if ((globalResource->udp.txBurst == 0) || (globalResource->udp.txBurst > FILLP_MAX_TX_RX_BURST)) {
64 FILLP_LOGERR(" txBurst is invalid parameter txBurst = %u", globalResource->udp.txBurst);
65 return ERR_FAILURE;
66 }
67
68 return ERR_OK;
69 }
70
FtAppValidateCommParams(IN FILLP_CONST FillpAppGlobalConfigsSt * globalResource)71 static FILLP_INT32 FtAppValidateCommParams(IN FILLP_CONST FillpAppGlobalConfigsSt *globalResource)
72 {
73 #ifdef FILLP_SERVER_SUPPORT
74
75 if ((globalResource->common.maxServerAllowSendCache == 0) ||
76 (globalResource->common.maxServerAllowSendCache > FILLP_MAX_SERVER_ALLOW_SEND_RECV_CACHE)) {
77 FILLP_LOGERR("maxServerAllowSendCache %u is invalid parameter!!!",
78 globalResource->common.maxServerAllowSendCache);
79 return ERR_FAILURE;
80 }
81
82 if ((globalResource->common.maxServerAllowRecvCache == 0) ||
83 (globalResource->common.maxServerAllowRecvCache > FILLP_MAX_SERVER_ALLOW_SEND_RECV_CACHE)) {
84 FILLP_LOGERR("maxServerAllowRecvCache %u is invalid parameter!!!",
85 globalResource->common.maxServerAllowRecvCache);
86 return ERR_FAILURE;
87 }
88
89 #endif
90
91 if (globalResource->common.udpSendBufSize < FILLP_FRAME_MTU) {
92 FILLP_LOGERR("send_bufSize %u is invalid parameter!!!", globalResource->common.udpSendBufSize);
93 return ERR_FAILURE;
94 }
95
96 if (globalResource->common.recvBufSize < FILLP_FRAME_MTU) {
97 FILLP_LOGERR("recvBufSize %u is invalid parameter!!!", globalResource->common.recvBufSize);
98 return ERR_FAILURE;
99 }
100
101 if ((globalResource->common.sendCache == FILLP_NULL) ||
102 (globalResource->common.sendCache > FILLP_MAX_ALLOW_SEND_RECV_CACHE)) {
103 FILLP_LOGERR("sendCache %u is invalid parameter!!!", globalResource->common.sendCache);
104 return ERR_FAILURE;
105 }
106
107 if ((globalResource->common.recvCache == FILLP_NULL) ||
108 (globalResource->common.recvCache > FILLP_MAX_ALLOW_SEND_RECV_CACHE)) {
109 FILLP_LOGERR("recvCache %u is invalid parameter!!!", globalResource->common.recvCache);
110 return ERR_FAILURE;
111 }
112
113 if ((globalResource->common.nackDelayTimeout < (FILLP_MAX_SEND_INTERVAL >> 3)) ||
114 (globalResource->common.nackDelayTimeout > FILLP_MAX_INT_VALUE)) {
115 FILLP_LOGERR("nackDelayTimeout %lld is invalid parameter!!! \r\n", globalResource->common.nackDelayTimeout);
116 return ERR_FAILURE;
117 }
118
119 if ((globalResource->common.enableNackDelay != FILLP_TRUE) &&
120 (globalResource->common.enableNackDelay != FILLP_FALSE)) {
121 FILLP_LOGERR("enableNackDelay %u is invalid parameter!!!", globalResource->common.enableNackDelay);
122 return ERR_FAILURE;
123 }
124
125 return ERR_OK;
126 }
127
FtAppValidateTimerParams(IN FILLP_CONST FillpAppGlobalConfigsSt * globalResource)128 static FILLP_INT32 FtAppValidateTimerParams(IN FILLP_CONST FillpAppGlobalConfigsSt *globalResource)
129 {
130 /* connectTimeout is in seconds. */
131 if ((globalResource->timers.connectTimeout == FILLP_NULL) ||
132 (globalResource->timers.connectTimeout > FILLP_MAX_CONNECT_TIMEOUT)) {
133 FILLP_LOGERR("connectTimeout %u is invalid parameter", globalResource->timers.connectTimeout);
134 return ERR_FAILURE;
135 }
136
137 if ((globalResource->timers.keepAliveTime < FILLP_MIN_KEEP_ALIVE_TIMER) ||
138 (globalResource->timers.keepAliveTime > FILLP_MAX_KEEP_ALIVE_TIME)) {
139 FILLP_LOGERR("keepAliveTime %u is invalid parameter", globalResource->timers.keepAliveTime);
140 return ERR_FAILURE;
141 }
142
143 /* connRetryTimeout is in milliseconds */
144 if ((globalResource->timers.connRetrytimeout == FILLP_NULL) ||
145 (globalResource->timers.connRetrytimeout > FILLP_MAX_CONNECT_RETRY_TIMER_INTERVAL)) {
146 FILLP_LOGERR("connRetryTimeout %u is invalid parameter", globalResource->timers.connRetrytimeout);
147 return (ERR_FAILURE);
148 }
149
150 /* disconnectRetrytimeout is in milliseconds */
151 if ((globalResource->timers.disconnectRetrytimeout == FILLP_NULL) ||
152 (globalResource->timers.disconnectRetrytimeout > FILLP_MAX_DISCONNECT_TIMER_INTERVAL)) {
153 FILLP_LOGERR("disconnectRetrytimeout %u is invalid parameter", globalResource->timers.disconnectRetrytimeout);
154 return (ERR_FAILURE);
155 }
156
157 return ERR_OK;
158 }
159
160 /**********************************************************************************
161 Function : FtAppValidateConfigParams
162 Description : This API is used to validate application. This is refer as a validation function.
163 Input : resource This is the pointer to FillpAppGlobalConfigsSt structure.
164 Return : On success - FillP_SUCCESS
165 On Failure - ERROR CODES
166 ******************************************************************************************/
FtAppValidateConfigParams(IN FILLP_CONST FillpAppGlobalConfigsSt * globalResource)167 FILLP_INT32 FtAppValidateConfigParams(IN FILLP_CONST FillpAppGlobalConfigsSt *globalResource)
168 {
169 FILLP_INT32 ret;
170
171 ret = FtAppValidateUdpParams(globalResource);
172 if (ret != ERR_OK) {
173 return ret;
174 }
175
176 ret = FtAppValidateCommParams(globalResource);
177 if (ret != ERR_OK) {
178 return ret;
179 }
180
181 ret = FtAppValidateTimerParams(globalResource);
182 if (ret != ERR_OK) {
183 return ret;
184 }
185
186 return FtAppValidateFlowConfig(globalResource);
187 }
188
189 /*******************************************************************
190 Function : FtAppTimerConfigSet
191 Description : Api is used to Set individual FILLP stack Timer lengths
192 Currently 5 timers are handled.
193 1. Connect timeout timer
194 2. Disconnect timeout
195 3. Keep Alive timer
196 4. pack timer
197 5. close pending
198 Input : FILLP_UINT32 name: Timer name which user wants to change the timeout value (FILLP_TIMER_LIST).
199 FILLP_UINT32 *value : Will specify the timeout value in milliseconds
200 Output : NA
201 Return : FILLP_UINT32 SUCCESS/FAILURE
202 ********************************************************************/
FtAppTimerConfigSet(IN FILLP_CONST void * value,struct GlobalAppResource * resource,IN FILLP_INT sockIndex)203 static FILLP_INT32 FtAppTimerConfigSet(
204 IN FILLP_CONST void *value,
205 struct GlobalAppResource *resource,
206 IN FILLP_INT sockIndex)
207 {
208 FILLP_UINT32 timerValue;
209
210 timerValue = *(FILLP_UINT32 *)value;
211 if ((timerValue == 0) || (timerValue > FILLP_MAX_CONNECT_TIMEOUT)) {
212 FILLP_LOGERR("fillp_sock_id:%d connectTimeout timer is invalid", sockIndex);
213 return ERR_FAILURE;
214 }
215
216 resource->common.connectTimeout = timerValue;
217
218 FILLP_LOGINF("set connect timeout fillp_sock_id:%d, value:%u", sockIndex, timerValue);
219
220 FILLP_UNUSED_PARA(sockIndex);
221 return FILLP_SUCCESS;
222 }
223
FtAppSetKeepAliveTime(IN FILLP_CONST void * value,struct GlobalAppResource * resource,IN FILLP_INT sockIndex)224 static FILLP_INT32 FtAppSetKeepAliveTime(
225 IN FILLP_CONST void *value,
226 struct GlobalAppResource *resource,
227 IN FILLP_INT sockIndex)
228 {
229 FILLP_UINT32 timerValue;
230
231 timerValue = *(FILLP_UINT32 *)value;
232 if ((timerValue < FILLP_MIN_KEEP_ALIVE_TIMER) || (timerValue > FILLP_MAX_KEEP_ALIVE_TIME)) {
233 FILLP_LOGERR("fillp_sock_id:%d keepAliveTime timer is invalid!!!", sockIndex);
234 return ERR_FAILURE;
235 }
236
237 struct FtSocket *sock = FILLP_NULL_PTR;
238 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
239 sock = SockGetSocket(sockIndex);
240 if (sock == FILLP_NULL_PTR) {
241 FILLP_LOGERR("invalid sock: %d", sockIndex);
242 return ERR_FAILURE;
243 }
244
245 resource->common.keepAliveTime = timerValue;
246 if ((sock->netconn != FILLP_NULL_PTR) && (sock->netconn->state == CONN_STATE_CONNECTED)) {
247 FillpErrorType ret = SpungePostMsg(sock->inst, (void *)sock, MSG_TYPE_SET_KEEP_ALIVE, FILLP_TRUE);
248 if (ret != ERR_OK) {
249 FILLP_LOGERR("fillp_sock_id:%d Failed to set the keep alive time for system socket", sockIndex);
250
251 return ret;
252 }
253
254 if (sock->coreErrType[MSG_TYPE_SET_KEEP_ALIVE] != ERR_OK) {
255 FILLP_LOGERR("fillp_sock_id:%d Failed to set the keep alive time for system socket", sockIndex);
256 return sock->coreErrType[MSG_TYPE_SET_KEEP_ALIVE];
257 }
258 }
259 } else {
260 resource->common.keepAliveTime = timerValue;
261 }
262
263 FILLP_LOGBUTT("fillp_sock_id: %d, set keepalive time to %u", sockIndex, timerValue);
264 return FILLP_SUCCESS;
265 }
266
FtAppSetConnRetryTimeout(IN FILLP_CONST void * value,struct GlobalAppResource * resource,IN FILLP_INT sockIndex)267 static FILLP_INT32 FtAppSetConnRetryTimeout(
268 IN FILLP_CONST void *value,
269 struct GlobalAppResource *resource,
270 IN FILLP_INT sockIndex)
271 {
272 FILLP_UINT16 usTempTimerValue;
273
274 usTempTimerValue = *(FILLP_UINT16 *)value;
275 if ((usTempTimerValue == FILLP_NULL) || (usTempTimerValue > FILLP_MAX_CONNECT_RETRY_TIMER_INTERVAL)) {
276 FILLP_LOGERR("fillp_sock_id:%d connRetryTimeout timer is invalid!!!", sockIndex);
277 return ERR_FAILURE;
278 }
279
280 resource->common.connRetryTimeout = usTempTimerValue;
281 FILLP_UNUSED_PARA(sockIndex);
282 return FILLP_SUCCESS;
283 }
284
FtAppSetDisconnectRetryTimeout(IN FILLP_CONST void * value,struct GlobalAppResource * resource,IN FILLP_INT sockIndex)285 static FILLP_INT32 FtAppSetDisconnectRetryTimeout(
286 IN FILLP_CONST void *value,
287 struct GlobalAppResource *resource,
288 IN FILLP_INT sockIndex)
289 {
290 FILLP_UINT32 timerValue;
291
292 timerValue = *(FILLP_UINT32 *)value;
293 if ((timerValue == FILLP_NULL) || (timerValue > FILLP_MAX_DISCONNECT_TIMER_INTERVAL)) {
294 FILLP_LOGERR("fillp_sock_id:%d disconnectRetrytimeout timer is invalid!!!", sockIndex);
295 return ERR_FAILURE;
296 }
297
298 resource->common.disconnectRetryTimeout = timerValue;
299 FILLP_UNUSED_PARA(sockIndex);
300 return FILLP_SUCCESS;
301 }
302
303 /**********************************************************************************
304 Function : FtSetConfigStack
305 Description : Api is used to set Individual FILLP stack configuration item.
306 Input : FILLP_UINT32 name : Name of the config item to configure
307 (FILLP_CONFIG_LIST_ENUM)
308 void *value : This will contain the value for the config item.
309 void *param : this is optional. only required for config items
310 which requires additional information to configure.
311 for ex:
312 For SOCKET option this will store the Socket index.
313 Output : NA
314 Return : FILLP_UINT32 SUCCESS/FAILURE
315 ******************************************************************************************/
FtAppConfigSetTxBurst(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)316 static FILLP_INT32 FtAppConfigSetTxBurst(
317 IN FILLP_CONST void *value,
318 struct GlobalAppResource *resource,
319 FILLP_INT sockIndex)
320 {
321 FILLP_UINT16 configValue;
322
323 configValue = *(FILLP_UINT16 *)value;
324 if ((configValue == 0) || (configValue > FILLP_MAX_TX_RX_BURST)) {
325 FILLP_LOGERR("fillp_sock_id:%d txBurst is invalid parameter!!!", sockIndex);
326
327 return ERR_FAILURE;
328 }
329
330 resource->udp.txBurst = (FILLP_UINT32)(configValue);
331 FILLP_UNUSED_PARA(sockIndex);
332 return FILLP_SUCCESS;
333 }
334
FtAppConfigSetSendCache(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)335 static FILLP_INT32 FtAppConfigSetSendCache(
336 IN FILLP_CONST void *value,
337 struct GlobalAppResource *resource,
338 FILLP_INT sockIndex)
339 {
340 FILLP_UINT32 configValue;
341 struct FtSocket *sock = FILLP_NULL_PTR;
342
343 configValue = *(FILLP_UINT32 *)value;
344 if ((configValue == FILLP_NULL) || (configValue > FILLP_MAX_ALLOW_SEND_RECV_CACHE)) {
345 FILLP_LOGERR("fillp_sock_id:%d sendCache invalid parameter!!!", sockIndex);
346 return ERR_FAILURE;
347 }
348 resource->common.sendCache = configValue;
349 if (sockIndex != FILLP_CONFIG_ALL_SOCKET) {
350 sock = SockGetSocket(sockIndex);
351 if ((sock != FILLP_NULL_PTR) && (sock->netconn != FILLP_NULL_PTR) &&
352 (sock->netconn->pcb != FILLP_NULL_PTR) && (sock->netconn->state == CONN_STATE_IDLE)) {
353 NetconnSetSendCacheSize(sock->netconn, configValue);
354 } else {
355 return ERR_FAILURE;
356 }
357 }
358
359 return FILLP_SUCCESS;
360 }
361
FtAppConfigSetRecvCache(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)362 static FILLP_INT32 FtAppConfigSetRecvCache(
363 IN FILLP_CONST void *value,
364 struct GlobalAppResource *resource,
365 FILLP_INT sockIndex)
366 {
367 FILLP_UINT32 configValue;
368 struct FtSocket *sock = FILLP_NULL_PTR;
369 configValue = *(FILLP_UINT32 *)value;
370 if ((configValue == FILLP_NULL) || (configValue > FILLP_MAX_ALLOW_SEND_RECV_CACHE)) {
371 FILLP_LOGERR("fillp_sock_id:%d recvCache invalid parameter!!!", sockIndex);
372 return ERR_FAILURE;
373 }
374
375 resource->common.recvCache = configValue;
376 if (sockIndex != FILLP_CONFIG_ALL_SOCKET) {
377 sock = SockGetSocket(sockIndex);
378 if ((sock != FILLP_NULL_PTR) && (sock->netconn != FILLP_NULL_PTR) &&
379 (sock->netconn->pcb != FILLP_NULL_PTR) && (sock->netconn->state == CONN_STATE_IDLE)) {
380 NetconnSetRecvCacheSize(sock->netconn, configValue);
381 } else {
382 return ERR_FAILURE;
383 }
384 }
385
386 return FILLP_SUCCESS;
387 }
388
FtAppSetMaxServerSendCache(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)389 static FILLP_INT32 FtAppSetMaxServerSendCache(
390 IN FILLP_CONST void *value,
391 struct GlobalAppResource *resource,
392 FILLP_INT sockIndex)
393 {
394 FILLP_UINT32 configValue;
395
396 configValue = *(FILLP_UINT32 *)value;
397 if ((configValue == FILLP_NULL) || (configValue > FILLP_MAX_SERVER_ALLOW_SEND_RECV_CACHE)) {
398 FILLP_LOGERR("fillp_sock_id:%d maxServerAllowSendCache is invalid parameter!!!", sockIndex);
399 return ERR_FAILURE;
400 }
401
402 resource->common.maxServerAllowSendCache = configValue;
403 FILLP_UNUSED_PARA(sockIndex);
404 return FILLP_SUCCESS;
405 }
406
FtAppSetMaxServeRecvCache(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)407 static FILLP_INT32 FtAppSetMaxServeRecvCache(
408 IN FILLP_CONST void *value,
409 struct GlobalAppResource *resource,
410 FILLP_INT sockIndex)
411 {
412 FILLP_UINT32 configValue;
413
414 configValue = *(FILLP_UINT32 *)value;
415
416 if ((configValue == FILLP_NULL) || (configValue > FILLP_MAX_SERVER_ALLOW_SEND_RECV_CACHE)) {
417 FILLP_LOGERR("fillp_sock_id:%d maxServerAllowRecvCache is invalid parameter!!!", sockIndex);
418 return ERR_FAILURE;
419 }
420
421 resource->common.maxServerAllowRecvCache = configValue;
422 FILLP_UNUSED_PARA(sockIndex);
423 return FILLP_SUCCESS;
424 }
425
FtAppConfigSetOppositeSetRate(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)426 static FILLP_INT32 FtAppConfigSetOppositeSetRate(
427 IN FILLP_CONST void *value,
428 struct GlobalAppResource *resource,
429 FILLP_INT sockIndex)
430 {
431 FILLP_UINT32 configValue;
432 struct FtSocket *sock = FILLP_NULL_PTR;
433
434 configValue = *(FILLP_UINT32 *)value;
435 if ((configValue > FILLP_NULL) && (configValue <= FILLP_MAX_STACK_OPPOSITE_SET_RATE) &&
436 (configValue <= g_resource.flowControl.maxRate)
437 /* if fairness is set, then we should not allow user to set opposite set rate */
438 && (g_resource.flowControl.supportFairness == FILLP_FAIRNESS_TYPE_NONE)) {
439 resource->flowControl.oppositeSetRate = configValue;
440 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
441 sock = SockGetSocket(sockIndex);
442 if ((sock != FILLP_NULL_PTR) && (sock->netconn != FILLP_NULL_PTR) &&
443 (sock->netconn->pcb != FILLP_NULL_PTR)) {
444 NetconnSetOpersiteRate(sock->netconn, configValue);
445 }
446 }
447 } else {
448 FILLP_LOGERR("fillp_sock_id:%d oppositeSetRate is invalid parameter %u, maxRate = %u, "
449 "supportFairness = %u!!!",
450 sockIndex, configValue, g_resource.flowControl.maxRate, g_resource.flowControl.supportFairness);
451 return ERR_FAILURE;
452 }
453
454 return FILLP_SUCCESS;
455 }
456
FtAppConfigSetPktSize(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)457 static FILLP_INT32 FtAppConfigSetPktSize(
458 IN FILLP_CONST void *value,
459 struct GlobalAppResource *resource,
460 FILLP_INT sockIndex)
461 {
462 FILLP_UINT16 configValue;
463 struct FtSocket *sock = FILLP_NULL_PTR;
464
465 configValue = *(FILLP_UINT16 *)value;
466 if ((configValue > 0) && (configValue <= (FILLP_FRAME_MTU - FILLP_HLEN - UDP_HLEN - IP_HLEN))) {
467 if (sockIndex != FILLP_CONFIG_ALL_SOCKET) {
468 FILLP_UINT16 dataOptionAreaSize = 0;
469 sock = SockGetSocket(sockIndex);
470 if ((sock != FILLP_NULL_PTR) && (sock->dataOptionFlag != FILLP_NULL)) {
471 dataOptionAreaSize = (FILLP_UINT16)(sock->dataOptionSize + FILLP_DATA_OFFSET_LEN);
472 }
473 if ((sock != FILLP_NULL_PTR) && (dataOptionAreaSize >= configValue)) {
474 FILLP_LOGERR("fillp_sock_id:%d pktSize is invalid parameter!!!", sockIndex);
475 return ERR_FAILURE;
476 }
477
478 if ((sock != FILLP_NULL_PTR) && (sock->netconn != FILLP_NULL_PTR) &&
479 (sock->netconn->pcb != FILLP_NULL_PTR) && (sock->netconn->state <= CONN_STATE_LISTENING)) {
480 resource->flowControl.pktSize = configValue;
481 NetconnSetPktSize(sock->netconn, configValue);
482 } else {
483 FILLP_LOGERR("fillp_sock_id:%d pktSize cannot be set if state is not listening or idle", sockIndex);
484 return ERR_FAILURE;
485 }
486 } else {
487 resource->flowControl.pktSize = configValue;
488 }
489 } else {
490 FILLP_LOGERR("fillp_sock_id:%d pktSize is invalid parameter!!!", sockIndex);
491 return ERR_FAILURE;
492 }
493
494 return FILLP_SUCCESS;
495 }
496
FtAppConfigSetSendBufSize(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex,struct FtSocket * sock)497 static FILLP_INT32 FtAppConfigSetSendBufSize(
498 IN FILLP_CONST void *value,
499 struct GlobalAppResource *resource,
500 FILLP_INT sockIndex,
501 struct FtSocket *sock)
502 {
503 FILLP_UINT32 configValue;
504 FillpErrorType ret;
505
506 configValue = *(FILLP_UINT32 *)value;
507 if (configValue < FILLP_FRAME_MTU) {
508 FILLP_LOGERR("fillp_sock_id:%d send_bufSize is invalid parameter!!!", sockIndex);
509 return ERR_FAILURE;
510 }
511
512 resource->common.udpSendBufSize = configValue;
513 if (sock != FILLP_NULL_PTR) {
514 ret = SpungePostMsg(sock->inst, (void *)sock, MSG_TYPE_SET_SEND_BUF, FILLP_TRUE);
515 if (ret != ERR_OK) {
516 FILLP_LOGERR("fillp_sock_id:%d Failed to set the send Buffer size for system socket", sockIndex);
517
518 return ret;
519 }
520
521 if (sock->coreErrType[MSG_TYPE_SET_SEND_BUF] != ERR_OK) {
522 FILLP_LOGERR("fillp_sock_id:%d Failed to set the send Buffer size for system socket", sockIndex);
523 }
524
525 return sock->coreErrType[MSG_TYPE_SET_SEND_BUF];
526 }
527
528 FILLP_UNUSED_PARA(sockIndex);
529 return FILLP_SUCCESS;
530 }
531
FtAppConfigSetRecvBufSize(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex,struct FtSocket * sock)532 static FILLP_INT32 FtAppConfigSetRecvBufSize(
533 IN FILLP_CONST void *value,
534 struct GlobalAppResource *resource,
535 FILLP_INT sockIndex,
536 struct FtSocket *sock)
537 {
538 FILLP_UINT32 configValue;
539 FillpErrorType ret;
540
541 configValue = *(FILLP_UINT32 *)value;
542 if (configValue < FILLP_FRAME_MTU) {
543 FILLP_LOGERR("fillp_sock_id:%d recvBufSize is invalid parameter!!!", sockIndex);
544 return ERR_FAILURE;
545 }
546
547 resource->common.recvBufSize = configValue;
548 if (sock != FILLP_NULL_PTR) {
549 ret = SpungePostMsg(sock->inst, (void *)sock, MSG_TYPE_SET_RECV_BUF, FILLP_TRUE);
550 if (ret != ERR_OK) {
551 FILLP_LOGERR("fillp_sock_id:%d Failed to set the receive Buffer size for system socket", sockIndex);
552
553 return ret;
554 }
555
556 if (sock->coreErrType[MSG_TYPE_SET_RECV_BUF] != ERR_OK) {
557 FILLP_LOGERR("fillp_sock_id:%d Failed to set the receive Buffer size for system socket", sockIndex);
558 }
559
560 return sock->coreErrType[MSG_TYPE_SET_RECV_BUF];
561 }
562
563 FILLP_UNUSED_PARA(sockIndex);
564 return FILLP_SUCCESS;
565 }
566
FtAppConfigSetSlowStart(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)567 static FILLP_INT32 FtAppConfigSetSlowStart(
568 IN FILLP_CONST void *value,
569 struct GlobalAppResource *resource,
570 FILLP_INT sockIndex)
571 {
572 FILLP_BOOL val;
573 struct FtSocket *sock = FILLP_NULL_PTR;
574 val = *(FILLP_BOOL *)value;
575 if ((val == FILLP_FALSE) || (val == FILLP_TRUE)) {
576 resource->flowControl.slowStart = val;
577 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
578 sock = SockGetSocket(sockIndex);
579 if ((sock != FILLP_NULL_PTR) && (sock->netconn != FILLP_NULL_PTR) &&
580 (sock->netconn->pcb != FILLP_NULL_PTR)) {
581 NetconnSetSlowStart(sock->netconn, val);
582 }
583 }
584 } else {
585 FILLP_LOGERR("fillp_sock_id:%d slowStart is invalid parameter!!!", sockIndex);
586 return ERR_FAILURE;
587 }
588
589 return FILLP_SUCCESS;
590 }
591
FtAppConfigSetMaxRate(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)592 static FILLP_INT32 FtAppConfigSetMaxRate(
593 IN FILLP_CONST void *value,
594 struct GlobalAppResource *resource,
595 FILLP_INT sockIndex)
596 {
597 FILLP_UINT32 configValue;
598
599 configValue = *(FILLP_UINT32 *)value;
600 if ((configValue >= FILLP_DEFAULT_MIN_RATE) && (configValue <= FILLP_MAX_STACK_RATE)) {
601 resource->flowControl.maxRate = configValue;
602 if (sockIndex != FILLP_CONFIG_ALL_SOCKET) {
603 struct FtSocket *sock = SockGetSocket(sockIndex);
604 if (FILLP_INVALID_PTR(sock) || FILLP_INVALID_PTR(sock->netconn)) {
605 FILLP_LOGERR("Invalid fillp_sock_id:%d", sockIndex);
606 return ERR_FAILURE;
607 }
608 }
609 } else {
610 FILLP_LOGERR("fillp_sock_id:%d max_rat(%u) Kbps is invalid parameter!!!", sockIndex, configValue);
611 return ERR_FAILURE;
612 }
613
614 return FILLP_SUCCESS;
615 }
616
FtAppConfigSetConstRate(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)617 static FILLP_INT32 FtAppConfigSetConstRate(
618 IN FILLP_CONST void *value,
619 struct GlobalAppResource *resource,
620 FILLP_INT sockIndex)
621 {
622 FILLP_BOOL val;
623
624 val = *(FILLP_BOOL *)value;
625 if ((val != FILLP_FALSE) && (val != FILLP_TRUE)) {
626 FILLP_LOGERR("fillp_sock_id:%d constRateEnbale is invalid parameter!!!", sockIndex);
627 return ERR_FAILURE;
628 }
629
630 resource->flowControl.constRateEnbale = val;
631 FILLP_UNUSED_PARA(sockIndex);
632 return FILLP_SUCCESS;
633 }
634
FtAppConfigSetMaxRecvRate(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)635 static FILLP_INT32 FtAppConfigSetMaxRecvRate(
636 IN FILLP_CONST void *value,
637 struct GlobalAppResource *resource,
638 FILLP_INT sockIndex)
639 {
640 FILLP_UINT32 configValue;
641
642 configValue = *(FILLP_UINT32 *)value;
643 if ((configValue != FILLP_NULL) && (configValue <= FILLP_MAX_STACK_RECV_RATE)) {
644 resource->flowControl.maxRecvRate = configValue;
645 } else {
646 FILLP_LOGERR("fillp_sock_id:%d maxRecvRate(%u) Kbps is invalid parameter!!!", sockIndex, configValue);
647 return ERR_FAILURE;
648 }
649
650 FILLP_UNUSED_PARA(sockIndex);
651 return FILLP_SUCCESS;
652 }
653
FtAppEnlargePackInterval(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex,struct FtSocket * sock)654 static FILLP_INT32 FtAppEnlargePackInterval(
655 IN FILLP_CONST void *value,
656 struct GlobalAppResource *resource,
657 FILLP_INT sockIndex,
658 struct FtSocket *sock)
659 {
660 FILLP_BOOL configValue;
661
662 FILLP_UNUSED_PARA(sock);
663
664 configValue = *(FILLP_BOOL *)value;
665 if ((configValue != FILLP_TRUE) && (configValue != FILLP_FALSE)) {
666 FILLP_LOGERR("fillp_sock_id:%d enlargePackIntervalFlag %u passed is invalid parameter!!!", sockIndex,
667 configValue);
668 return ERR_FAILURE;
669 }
670 resource->common.enlargePackIntervalFlag = configValue;
671 FILLP_UNUSED_PARA(sockIndex);
672 return FILLP_SUCCESS;
673 }
674
FtAppConfigInitNackDelayCfg(FILLP_INT sockIndex,struct GlobalAppResource * resource)675 FILLP_INT FtAppConfigInitNackDelayCfg(
676 FILLP_INT sockIndex,
677 struct GlobalAppResource *resource)
678 {
679 FILLP_INT ret;
680
681 if ((sockIndex == FILLP_MAX_UNSHORT_VAL) && (g_spunge != FILLP_NULL_PTR) && (g_spunge->hasInited == FILLP_TRUE)) {
682 struct NackDelayCfg *cfg =
683 (struct NackDelayCfg *)SpungeAlloc(1, sizeof(struct NackDelayCfg), SPUNGE_ALLOC_TYPE_MALLOC);
684 if (cfg == FILLP_NULL_PTR) {
685 FILLP_LOGERR("fillp_sock_id:%d unable to set the parameter due to system error", sockIndex);
686 return ERR_FAILURE;
687 }
688
689 cfg->nackCfgVal = resource->common.enableNackDelay;
690 cfg->nackDelayTimeout = resource->common.nackDelayTimeout;
691 cfg->sockIndex = sockIndex;
692
693 ret = SpungePostMsg(SPUNGE_GET_CUR_INSTANCE(), (void *)cfg, MSG_TYPE_SET_NACK_DELAY, FILLP_TRUE);
694 if (ret != ERR_OK) {
695 FILLP_LOGERR("fillp_sock_id:%d Failed to set the nack delay for affected connections", sockIndex);
696 SpungeFree(cfg, SPUNGE_ALLOC_TYPE_MALLOC);
697 return ret;
698 }
699 }
700
701 return ERR_OK;
702 }
703
FtAppConfigSetEnableNackDelay(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)704 static FILLP_INT32 FtAppConfigSetEnableNackDelay(
705 IN FILLP_CONST void *value,
706 struct GlobalAppResource *resource,
707 FILLP_INT sockIndex)
708 {
709 FILLP_BOOL configValue;
710 FillpErrorType ret;
711
712 configValue = *(FILLP_BOOL *)value;
713 if ((configValue != FILLP_TRUE) && (configValue != FILLP_FALSE)) {
714 FILLP_LOGERR("fillp_sock_id:%d enableNackDelay %u passed is invalid parameter!!!", sockIndex,
715 configValue);
716 return ERR_FAILURE;
717 }
718
719 resource->common.enableNackDelay = configValue;
720
721 /* need to post in 2 cases:
722 a) if the config is being set for a particular socket
723 b) if set for global after stack init, since it needs to be updated on all
724 the existing socket.
725 So, if the stack is not init and it is being set globally, then no need
726 to post it, since there are no sockets for which it needs to be set */
727 ret = FtAppConfigInitNackDelayCfg(sockIndex, resource);
728 if (ret != ERR_OK) {
729 return ret;
730 }
731
732 return FILLP_SUCCESS;
733 }
734
FtAppConfigSetNackDelayTimeout(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)735 static FILLP_INT32 FtAppConfigSetNackDelayTimeout(
736 IN FILLP_CONST void *value,
737 struct GlobalAppResource *resource,
738 FILLP_INT sockIndex)
739 {
740 FILLP_LLONG configValue;
741 FillpErrorType ret;
742
743 configValue = *(FILLP_LLONG *)value;
744
745 if ((configValue < (FILLP_MAX_SEND_INTERVAL >> FILLP_RARE_3)) || (configValue > FILLP_MAX_INT_VALUE)) {
746 FILLP_LOGERR("fillp_sock_id:%d nackDelayTimeout %lld is invalid parameter!!!", sockIndex, configValue);
747 return ERR_FAILURE;
748 }
749 resource->common.nackDelayTimeout = configValue;
750
751 /* need to post in 2 cases:
752 a) if the config is being set for a particular socket
753 b) if set for global after stack init, since it needs to be updated on all
754 the existing socket.
755 So, if the stack is not init and it is being set globally, then no need
756 to post it, since there are no sockets for which it needs to be set */
757 ret = FtAppConfigInitNackDelayCfg(sockIndex, resource);
758 if (ret != ERR_OK) {
759 return ret;
760 }
761
762 return FILLP_SUCCESS;
763 }
764
FtAppSetFcStatInterval(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)765 static FILLP_INT32 FtAppSetFcStatInterval(
766 IN FILLP_CONST void *value,
767 struct GlobalAppResource *resource,
768 FILLP_INT sockIndex)
769 {
770 FILLP_UINT32 configValue;
771
772 configValue = *(FILLP_UINT32 *)value;
773 if ((configValue < resource->flowControl.packInterval) ||
774 (configValue > FILLP_APP_FC_STASTICS_MAX_INTERVAL)) {
775 FILLP_LOGERR("fillp_sock_id:%d maxServerAllowSendCache is invalid parameter!!!", sockIndex);
776 return ERR_FAILURE;
777 }
778
779 resource->common.fcStasticsInterval = configValue;
780 FILLP_UNUSED_PARA(sockIndex);
781 return FILLP_SUCCESS;
782 }
783
FtAppConfigSetPackInterval(IN FILLP_CONST void * value,struct GlobalAppResource * resource,FILLP_INT sockIndex)784 static FILLP_INT32 FtAppConfigSetPackInterval(IN FILLP_CONST void *value, struct GlobalAppResource *resource,
785 FILLP_INT sockIndex)
786 {
787 FILLP_UINT32 val = *(FILLP_UINT32 *)value;
788 struct FtSocket *sock = FILLP_NULL_PTR;
789
790 if (val < FILLP_MIN_APP_PACK_INTERVAL || val > FILLP_MAX_APP_PACK_INTERVAL) {
791 FILLP_LOGERR("fillp_sock_id:%d pack interval(%u) is invalid parameter!!!", sockIndex, val);
792 return ERR_FAILURE;
793 }
794
795 if (sockIndex != FILLP_MAX_UNSHORT_VAL) {
796 sock = SockGetSocket(sockIndex);
797 if ((sock != FILLP_NULL_PTR) && (sock->netconn != FILLP_NULL_PTR) && (sock->netconn->pcb != FILLP_NULL_PTR) &&
798 (sock->netconn->state <= CONN_STATE_LISTENING)) {
799 FILLP_LOGBUTT("set the pack interval of the socket %d to %u us", sockIndex, val);
800 resource->flowControl.packInterval = val;
801 NetconnSetPackInterval(sock->netconn, val);
802 } else {
803 FILLP_LOGERR("cannot set the pack interval when the sock is not in idle or listen state");
804 return ERR_FAILURE;
805 }
806 } else {
807 FILLP_LOGBUTT("set the pack interval of all the sockets to %u us", val);
808 resource->flowControl.packInterval = val;
809 }
810
811 return FILLP_SUCCESS;
812 }
813
FtInnerAppConfigSetHelper(IN FILLP_UINT32 name,IN FILLP_CONST void * value,IN struct GlobalAppResource * resource,IN FILLP_INT sockIndex,IN struct FtSocket * sock)814 static FILLP_INT32 FtInnerAppConfigSetHelper(
815 IN FILLP_UINT32 name,
816 IN FILLP_CONST void *value,
817 IN struct GlobalAppResource *resource,
818 IN FILLP_INT sockIndex,
819 IN struct FtSocket *sock)
820 {
821 switch (name) {
822 case FT_CONF_MAX_RATE:
823 return FtAppConfigSetMaxRate(value, resource, sockIndex);
824
825 case FT_CONF_MAX_RECV_RATE:
826 return FtAppConfigSetMaxRecvRate(value, resource, sockIndex);
827
828 case FT_CONF_ENABLE_NACK_DELAY:
829 return FtAppConfigSetEnableNackDelay(value, resource, sockIndex);
830
831 case FT_CONF_NACK_DELAY_TIMEOUT:
832 return FtAppConfigSetNackDelayTimeout(value, resource, sockIndex);
833
834 case FT_CONF_ENLARGE_PACK_INTERVAL:
835 return FtAppEnlargePackInterval(value, resource, sockIndex, sock);
836
837 case FT_CONF_TIMER_CONNECT:
838 return FtAppTimerConfigSet(value, resource, sockIndex);
839
840 case FT_CONF_TIMER_KEEP_ALIVE:
841 return FtAppSetKeepAliveTime(value, resource, sockIndex);
842
843 /* This timer value is in milliseconds */
844 case FT_CONF_TIMER_CONNECTION_RETRY:
845 return FtAppSetConnRetryTimeout(value, resource, sockIndex);
846
847 /* This timer value is in milliseconds */
848 case FT_CONF_TIMER_DISCONNECT_RETRY_TIMEOUT:
849 return FtAppSetDisconnectRetryTimeout(value, resource, sockIndex);
850
851 case FT_CONF_CONST_RATE:
852 return FtAppConfigSetConstRate(value, resource, sockIndex);
853
854 case FT_CONF_APP_FC_STASTICS_INTERVAL:
855 return FtAppSetFcStatInterval(value, resource, sockIndex);
856
857 case FT_CONF_APP_PACK_INTERVAL:
858 return FtAppConfigSetPackInterval(value, resource, sockIndex);
859
860 default:
861 FILLP_LOGERR("invalid name %u!!!", name);
862 return ERR_FAILURE;
863 }
864 return ERR_OK;
865 }
866
FtInnerAppConfigSet(IN FILLP_UINT32 name,IN FILLP_CONST void * value,IN struct GlobalAppResource * resource,IN FILLP_INT sockIndex,IN struct FtSocket * sock)867 FILLP_INT32 FtInnerAppConfigSet(
868 IN FILLP_UINT32 name,
869 IN FILLP_CONST void *value,
870 IN struct GlobalAppResource *resource,
871 IN FILLP_INT sockIndex,
872 IN struct FtSocket *sock)
873 {
874 switch (name) {
875 case FT_CONF_TX_BURST:
876 return FtAppConfigSetTxBurst(value, resource, sockIndex);
877
878 case FT_CONF_MAX_SERVER_ALLOW_SEND_CACHE:
879 #ifdef FILLP_SERVER_SUPPORT
880 return FtAppSetMaxServerSendCache(value, resource, sockIndex);
881 #else
882 FILLP_LOGERR("Server feature Not enabled : FT_CONF_MAX_SERVER_ALLOW_SEND_CACHE is server only option !!!");
883 return ERR_FEATURE_MACRO_NOT_ENABLED;
884 #endif
885
886 case FT_CONF_MAX_SERVER_ALLOW_RECV_CACHE:
887 #ifdef FILLP_SERVER_SUPPORT
888 return FtAppSetMaxServeRecvCache(value, resource, sockIndex);
889 #else
890 FILLP_LOGERR("Server feature Not enabled : FT_CONF_MAX_SERVER_ALLOW_RECV_CACHE is server only option !!!");
891 return ERR_FEATURE_MACRO_NOT_ENABLED;
892 #endif
893
894 case FT_CONF_SEND_CACHE:
895 return FtAppConfigSetSendCache(value, resource, sockIndex);
896
897 case FT_CONF_RECV_CACHE:
898 return FtAppConfigSetRecvCache(value, resource, sockIndex);
899
900 case FT_CONF_SEND_BUFFER_SIZE:
901 return FtAppConfigSetSendBufSize(value, resource, sockIndex, sock);
902
903 case FT_CONF_RECV_BUFFER_SIZE:
904 return FtAppConfigSetRecvBufSize(value, resource, sockIndex, sock);
905
906 case FT_CONF_OPPOSITE_SET_RATE:
907 #ifdef FILLP_SERVER_SUPPORT
908 return FtAppConfigSetOppositeSetRate(value, resource, sockIndex);
909 #else
910 FILLP_LOGERR("Server feature Not enabled : FT_CONF_OPPOSITE_SET_RATE is server only option !!!");
911 return ERR_FEATURE_MACRO_NOT_ENABLED;
912 #endif
913
914 case FT_CONF_PACKET_SIZE:
915 return FtAppConfigSetPktSize(value, resource, sockIndex);
916
917 case FT_CONF_SLOW_START:
918 return FtAppConfigSetSlowStart(value, resource, sockIndex);
919
920 default: /* name bigger than FT_CONF_SLOW_START handle in FtInnerAppConfigSetHelper */
921 return FtInnerAppConfigSetHelper(name, value, resource, sockIndex, sock);
922 }
923 return ERR_OK;
924 }
925
FtInnerAppConfigGetHelper(FILLP_UINT32 name,void * value,FILLP_CONST struct GlobalAppResource * resource)926 static FILLP_INT32 FtInnerAppConfigGetHelper(FILLP_UINT32 name, void *value,
927 FILLP_CONST struct GlobalAppResource *resource)
928 {
929 switch (name) {
930 case FT_CONF_SLOW_START:
931 *(FILLP_BOOL *)value = resource->flowControl.slowStart;
932 break;
933
934 case FT_CONF_MAX_RATE:
935 *(FILLP_UINT32 *)value = resource->flowControl.maxRate;
936 break;
937
938 case FT_CONF_MAX_RECV_RATE:
939 *(FILLP_UINT32 *)value = resource->flowControl.maxRecvRate;
940 break;
941
942 case FT_CONF_ENABLE_NACK_DELAY:
943 *(FILLP_BOOL *)value = resource->common.enableNackDelay;
944 break;
945
946 case FT_CONF_NACK_DELAY_TIMEOUT:
947 *(FILLP_LLONG *)value = resource->common.nackDelayTimeout;
948 break;
949
950 case FT_CONF_ENLARGE_PACK_INTERVAL:
951 *(FILLP_BOOL *)value = resource->common.enlargePackIntervalFlag;
952 break;
953
954 case FT_CONF_TIMER_CONNECT:
955 *(FILLP_UINT32 *)value = resource->common.connectTimeout;
956 break;
957
958 case FT_CONF_TIMER_CONNECTION_RETRY:
959 *(FILLP_UINT16 *)value = resource->common.connRetryTimeout;
960 break;
961
962 case FT_CONF_TIMER_DISCONNECT_RETRY_TIMEOUT:
963 *(FILLP_UINT32 *)value = resource->common.disconnectRetryTimeout;
964 break;
965
966 case FT_CONF_TIMER_KEEP_ALIVE:
967 *(FILLP_UINT32 *)value = resource->common.keepAliveTime;
968 break;
969
970 case FT_CONF_CONST_RATE:
971 *(FILLP_BOOL *)value = resource->flowControl.constRateEnbale;
972 break;
973
974 case FT_CONF_APP_FC_STASTICS_INTERVAL:
975 *(FILLP_UINT32 *)value = resource->common.fcStasticsInterval;
976 break;
977
978 default:
979 FILLP_LOGERR("invalid name %u!!!", name);
980 return ERR_PARAM;
981 }
982 return ERR_OK;
983 }
984
FtAppGetMaxServerSendCache(void * value,FILLP_CONST struct GlobalAppResource * resource)985 static inline FILLP_INT32 FtAppGetMaxServerSendCache(void *value, FILLP_CONST struct GlobalAppResource *resource)
986 {
987 #ifdef FILLP_SERVER_SUPPORT
988 *(FILLP_UINT32 *)value = resource->common.maxServerAllowSendCache;
989 return ERR_OK;
990 #else
991 FILLP_UNUSED_PARA(value);
992 FILLP_UNUSED_PARA(resource);
993 FILLP_LOGERR("Server feature Not enabled : FT_CONF_MAX_SERVER_ALLOW_SEND_CACHE is "
994 "server only option so cannot GET !!!");
995 return ERR_FEATURE_MACRO_NOT_ENABLED;
996 #endif
997 }
998
FtAppGetMaxServeRecvCache(void * value,FILLP_CONST struct GlobalAppResource * resource)999 static inline FILLP_INT32 FtAppGetMaxServeRecvCache(void *value, FILLP_CONST struct GlobalAppResource *resource)
1000 {
1001 #ifdef FILLP_SERVER_SUPPORT
1002 *(FILLP_UINT32 *)value = resource->common.maxServerAllowRecvCache;
1003 return ERR_OK;
1004 #else
1005 FILLP_UNUSED_PARA(value);
1006 FILLP_UNUSED_PARA(resource);
1007 FILLP_LOGERR("Server feature Not enabled : FT_CONF_MAX_SERVER_ALLOW_RECV_CACHE is "
1008 "server only option so cannot GET !!!");
1009 return ERR_FEATURE_MACRO_NOT_ENABLED;
1010 #endif
1011 }
1012
FtAppConfigGetOppositeSetRate(void * value,FILLP_CONST struct GlobalAppResource * resource)1013 static inline FILLP_INT32 FtAppConfigGetOppositeSetRate(void *value, FILLP_CONST struct GlobalAppResource *resource)
1014 {
1015 #ifdef FILLP_SERVER_SUPPORT
1016 *(FILLP_UINT32 *)value = resource->flowControl.oppositeSetRate;
1017 return ERR_OK;
1018 #else
1019 FILLP_UNUSED_PARA(value);
1020 FILLP_UNUSED_PARA(resource);
1021 FILLP_LOGERR("Server feature Not enabled : FT_CONF_OPPOSITE_SET_RATE is "
1022 "server only option so cannot GET !!!");
1023 return ERR_FEATURE_MACRO_NOT_ENABLED;
1024 #endif
1025 }
1026
1027 /*******************************************************************
1028 Function : FtInnerAppConfigGet
1029 Description : Api is used to get Individual FILLP stack configuration item.
1030 Input : FILLP_UINT32 name : Name of the config item to querry
1031 (FILLP_CONFIG_LISTENUM)
1032 void *value : FILLP will store the current value for the config item.
1033 void *param : this is optional. only required for config items
1034 which requires additional information to get the configuration value.
1035 for ex:
1036 For SOCKET option this will store the Socket index.
1037 Output : NA
1038 Return : FILLP_UINT32 SUCCESS/FAILURE
1039 ********************************************************************/
FtInnerAppConfigGet(IN FILLP_UINT32 name,IO void * value,IN FILLP_CONST struct GlobalAppResource * resource)1040 FILLP_INT32 FtInnerAppConfigGet(IN FILLP_UINT32 name, IO void *value,
1041 IN FILLP_CONST struct GlobalAppResource *resource)
1042 {
1043 switch (name) {
1044 case FT_CONF_TX_BURST:
1045 *(FILLP_UINT16 *)value = (FILLP_UINT16)resource->udp.txBurst;
1046 break;
1047
1048 case FT_CONF_SEND_CACHE:
1049 *(FILLP_UINT32 *)value = resource->common.sendCache;
1050 break;
1051
1052 case FT_CONF_RECV_CACHE:
1053 *(FILLP_UINT32 *)value = resource->common.recvCache;
1054 break;
1055
1056 case FT_CONF_MAX_SERVER_ALLOW_SEND_CACHE:
1057 return FtAppGetMaxServerSendCache(value, resource);
1058
1059 case FT_CONF_MAX_SERVER_ALLOW_RECV_CACHE:
1060 return FtAppGetMaxServeRecvCache(value, resource);
1061
1062 case FT_CONF_SEND_BUFFER_SIZE:
1063 *(FILLP_UINT32 *)value = resource->common.udpSendBufSize;
1064 break;
1065
1066 case FT_CONF_RECV_BUFFER_SIZE:
1067 *(FILLP_UINT32 *)value = resource->common.recvBufSize;
1068 break;
1069
1070 case FT_CONF_OPPOSITE_SET_RATE:
1071 return FtAppConfigGetOppositeSetRate(value, resource);
1072
1073 case FT_CONF_PACKET_SIZE:
1074 *(FILLP_UINT16 *)value = resource->flowControl.pktSize;
1075 break;
1076
1077 default: /* name bigger than FT_CONF_OPPOSITE_SET_RATE handle in FtInnerAppConfigGetHelper */
1078 return FtInnerAppConfigGetHelper(name, value, resource);
1079 }
1080 return ERR_OK;
1081 }
1082