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