From 2de7dbc43c5ec5931c8f5c057302f81ca80ae49a Mon Sep 17 00:00:00 2001 From: suvendhu Date: Thu, 9 Feb 2023 21:07:30 +0530 Subject: [PATCH] Added support of tr471 diagnostics --- CMakeLists.txt | 13 +- dmtree/tr143/diagnostics.c | 25 + dmtree/tr143/diagnostics.h | 5 + dmtree/tr181/ip.c | 4 +- dmtree/tr471/iplayercap.c | 1396 ++++++++++++++++++++++++++++++++++++ dmtree/tr471/iplayercap.h | 31 + libbbf_api/dmapi.h | 3 +- libbbf_api/dmcommon.c | 4 + libbbf_api/dmcommon.h | 4 + scripts/iplayercap | 435 +++++++++++ 10 files changed, 1916 insertions(+), 4 deletions(-) create mode 100644 dmtree/tr471/iplayercap.c create mode 100644 dmtree/tr471/iplayercap.h create mode 100644 scripts/iplayercap diff --git a/CMakeLists.txt b/CMakeLists.txt index b9480c6a..80c265ba 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -15,6 +15,7 @@ SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${PROJECT_SOURCE_DIR} -I${PROJECT_SOURCE_D OPTION(BBF_TR181 "build with tr181 datamodel" ON) OPTION(BBF_TR104 "build with tr104 datamodel" ON) OPTION(BBF_TR143 "build with tr143 datamodel" ON) +OPTION(BBF_TR471 "build with tr471 datamodel" ON) OPTION(BBF_DOTSO_PLUGIN "build with dotso plugin" ON) OPTION(BBF_JSON_PLUGIN "build with json plugin" ON) OPTION(BBF_VENDOR_EXTENSION "build with vendor extension enabled" ON) @@ -48,6 +49,16 @@ IF(BBF_TR143) add_compile_definitions(BBF_TR143) ENDIF(BBF_TR143) +IF(BBF_TR471) + IF(NOT BBF_TR143) + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${PROJECT_SOURCE_DIR}/dmtree/tr143") + FILE(GLOB BBF_TR143_SOURCES ${PROJECT_SOURCE_DIR}/dmtree/tr143/diagnostics.c) + ENDIF() + SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -I${PROJECT_SOURCE_DIR}/dmtree/tr471") + FILE(GLOB BBF_TR471_SOURCES ${PROJECT_SOURCE_DIR}/dmtree/tr471/*.c) + add_compile_definitions(BBF_TR471) +ENDIF(BBF_TR471) + IF(BBF_DOTSO_PLUGIN) SET(BBF_DOTSO_PLUGIN_SOURCES dmdynamiclibrary.c) add_compile_definitions(BBFDM_ENABLE_DOTSO_PLUGIN) @@ -92,7 +103,7 @@ IF(BBF_VENDOR_EXTENSION) ENDIF(BBF_VENDOR_EXTENSION) ADD_LIBRARY(bbfdm SHARED ${BBF_API_SOURCES} ${BBF_DM_SOURCES} - ${BBF_TR181_SOURCES} ${BBF_TR104_SOURCES} ${BBF_TR143_SOURCES} + ${BBF_TR181_SOURCES} ${BBF_TR104_SOURCES} ${BBF_TR143_SOURCES} ${BBF_TR471_SOURCES} ${BBF_DOTSO_PLUGIN_SOURCES} ${BBF_JSON_PLUGIN_SOURCES} ${BBF_VENDOR_EXTENSION_SOURCES}) diff --git a/dmtree/tr143/diagnostics.c b/dmtree/tr143/diagnostics.c index 15b5b35e..fad0782c 100644 --- a/dmtree/tr143/diagnostics.c +++ b/dmtree/tr143/diagnostics.c @@ -12,10 +12,15 @@ #include "dmdiagnostics.h" #include "dmbbfcommon.h" #include "diagnostics.h" +#ifdef BBF_TR471 +#include "iplayercap.h" +#endif +#ifdef BBF_TR143 #define TRACEROUTE_DIAGNOSTIC_PATH "/usr/share/bbfdm/traceroute" #define DOWNLOAD_DIAGNOSTIC_PATH "/usr/share/bbfdm/download" #define UPLOAD_DIAGNOSTIC_PATH "/usr/share/bbfdm/upload" +#endif /************************************************************* * COMMON FUNCTIONS @@ -29,6 +34,7 @@ static int get_diag_enable_true(char *refparam, struct dmctx *ctx, void *data, c /************************************************************* * GET & SET PARAM **************************************************************/ +#ifdef BBF_TR143 /* * *** Device.IP.Diagnostics.IPPing. *** */ @@ -2328,6 +2334,7 @@ static int operate_IPDiagnostics_ServerSelectionDiagnostics(char *refparam, stru return CMD_SUCCESS; } +#endif /********************************************************************************************************************************** * OBJ & LEAF DEFINITION @@ -2335,17 +2342,23 @@ static int operate_IPDiagnostics_ServerSelectionDiagnostics(char *refparam, stru /* *** Device.IP.Diagnostics. *** */ DMOBJ tIPDiagnosticsObj[] = { /* OBJ, permission, addobj, delobj, checkdep, browseinstobj, nextdynamicobj, dynamicleaf, nextobj, leaf, linker, bbfdm_type, uniqueKeys*/ +#ifdef BBF_TR143 {"IPPing", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, NULL, tIPDiagnosticsIPPingParams, NULL, BBFDM_CWMP}, {"TraceRoute", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, tIPDiagnosticsTraceRouteObj, tIPDiagnosticsTraceRouteParams, NULL, BBFDM_CWMP}, {"DownloadDiagnostics", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, tIPDiagnosticsDownloadDiagnosticsObj, tIPDiagnosticsDownloadDiagnosticsParams, NULL, BBFDM_CWMP}, {"UploadDiagnostics", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, tIPDiagnosticsUploadDiagnosticsObj, tIPDiagnosticsUploadDiagnosticsParams, NULL, BBFDM_CWMP}, {"UDPEchoDiagnostics", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, NULL, tIPDiagnosticsUDPEchoDiagnosticsParams, NULL, BBFDM_CWMP}, {"ServerSelectionDiagnostics", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, NULL, tIPDiagnosticsServerSelectionDiagnosticsParams, NULL, BBFDM_CWMP}, +#endif +#ifdef BBF_TR471 +{"IPLayerCapacityMetrics", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, tIPLayerCapacityObj, tIPLayerCapacityParams, NULL, BBFDM_CWMP}, +#endif {0} }; DMLEAF tIPDiagnosticsParams[] = { /* PARAM, permission, type, getvalue, setvalue, bbfdm_type*/ +#ifdef BBF_TR143 {"IPv4PingSupported", &DMREAD, DMT_BOOL, get_diag_enable_true, NULL, BBFDM_BOTH}, {"IPv6PingSupported", &DMREAD, DMT_BOOL, get_diag_enable_true, NULL, BBFDM_BOTH}, {"IPv4TraceRouteSupported", &DMREAD, DMT_BOOL, get_diag_enable_true, NULL, BBFDM_BOTH}, @@ -2364,9 +2377,20 @@ DMLEAF tIPDiagnosticsParams[] = { {"UploadDiagnostics()", &DMASYNC, DMT_COMMAND, get_operate_args_IPDiagnostics_UploadDiagnostics, operate_IPDiagnostics_UploadDiagnostics, BBFDM_USP}, {"UDPEchoDiagnostics()", &DMASYNC, DMT_COMMAND, get_operate_args_IPDiagnostics_UDPEchoDiagnostics, operate_IPDiagnostics_UDPEchoDiagnostics, BBFDM_USP}, {"ServerSelectionDiagnostics()", &DMASYNC, DMT_COMMAND, get_operate_args_IPDiagnostics_ServerSelectionDiagnostics, operate_IPDiagnostics_ServerSelectionDiagnostics, BBFDM_USP}, +#endif +#ifdef BBF_TR471 +{"IPLayerCapacitySupported", &DMREAD, DMT_BOOL, get_diag_enable_true, NULL, BBFDM_BOTH}, +{"IPLayerMaxConnections", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_MaxConnections, NULL, BBFDM_USP}, +{"IPLayerMaxIncrementalResult", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_MaxIncrementalResult, NULL, BBFDM_USP}, +{"IPLayerCapSupportedSoftwareVersion", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_SoftwareVersion, NULL, BBFDM_USP}, +{"IPLayerCapSupportedControlProtocolVersion", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_ControlProtocolVersion, NULL, BBFDM_USP}, +{"IPLayerCapSupportedMetrics", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_SupportedMetrics, NULL, BBFDM_USP}, +{"IPLayerCapacity()", &DMASYNC, DMT_COMMAND, get_operate_args_IPDiagnostics_IPLayerCapacity, operate_IPDiagnostics_IPLayerCapacity, BBFDM_USP}, +#endif {0} }; +#ifdef BBF_TR143 /* *** Device.IP.Diagnostics.IPPing. *** */ DMLEAF tIPDiagnosticsIPPingParams[] = { /* PARAM, permission, type, getvalue, setvalue, bbfdm_type*/ @@ -2563,3 +2587,4 @@ DMLEAF tIPDiagnosticsServerSelectionDiagnosticsParams[] = { {"IPAddressUsed", &DMREAD, DMT_STRING, get_IPDiagnosticsServerSelectionDiagnostics_IPAddressUsed, NULL, BBFDM_CWMP}, {0} }; +#endif diff --git a/dmtree/tr143/diagnostics.h b/dmtree/tr143/diagnostics.h index c8a7ce54..792a8c84 100644 --- a/dmtree/tr143/diagnostics.h +++ b/dmtree/tr143/diagnostics.h @@ -14,8 +14,12 @@ #include "libbbf_api/dmcommon.h" +#if defined(BBF_TR143) || defined(BBF_TR471) extern DMOBJ tIPDiagnosticsObj[]; extern DMLEAF tIPDiagnosticsParams[]; +#endif + +#ifdef BBF_TR143 extern DMLEAF tIPDiagnosticsIPPingParams[]; extern DMOBJ tIPDiagnosticsTraceRouteObj[]; extern DMLEAF tIPDiagnosticsTraceRouteParams[]; @@ -29,5 +33,6 @@ extern DMLEAF tIPDiagnosticsUploadDiagnosticsPerConnectionResultParams[]; extern DMLEAF tIPDiagnosticsUDPEchoConfigParams[]; extern DMLEAF tIPDiagnosticsUDPEchoDiagnosticsParams[]; extern DMLEAF tIPDiagnosticsServerSelectionDiagnosticsParams[]; +#endif #endif diff --git a/dmtree/tr181/ip.c b/dmtree/tr181/ip.c index 0ad30392..0d2643e6 100644 --- a/dmtree/tr181/ip.c +++ b/dmtree/tr181/ip.c @@ -13,7 +13,7 @@ #include "ppp.h" #include "firewall.h" #include "ip.h" -#ifdef BBF_TR143 +#if defined(BBF_TR143) || defined(BBF_TR471) #include "diagnostics.h" #endif @@ -2326,7 +2326,7 @@ static int operate_IPInterface_Reset(char *refparam, struct dmctx *ctx, void *da DMOBJ tIPObj[] = { /* OBJ, permission, addobj, delobj, checkdep, browseinstobj, nextdynamicobj, dynamicleaf, nextobj, leaf, linker, bbfdm_type, uniqueKeys, version*/ {"Interface", &DMWRITE, addObjIPInterface, delObjIPInterface, NULL, browseIPInterfaceInst, NULL, NULL, tIPInterfaceObj, tIPInterfaceParams, get_linker_ip_interface, BBFDM_BOTH, LIST_KEY{"Alias", "Name", NULL}, "2.0"}, -#ifdef BBF_TR143 +#if defined(BBF_TR143) || defined(BBF_TR471) {"Diagnostics", &DMREAD, NULL, NULL, NULL, NULL, NULL, NULL, tIPDiagnosticsObj, tIPDiagnosticsParams, NULL, BBFDM_BOTH, NULL, "2.0"}, #endif {0} diff --git a/dmtree/tr471/iplayercap.c b/dmtree/tr471/iplayercap.c new file mode 100644 index 00000000..7f2620e2 --- /dev/null +++ b/dmtree/tr471/iplayercap.c @@ -0,0 +1,1396 @@ +/* + * Copyright (C) 2023 iopsys Software Solutions AB + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 + * as published by the Free Software Foundation + * + * Author: Suvendhu Hansa + * + */ + +#include "dmdiagnostics.h" +#include "dmbbfcommon.h" +#include "iplayercap.h" + +#define IPLAYER_CAP_DIAGNOSTIC_PATH "/usr/share/bbfdm/iplayercap" + +/* + * *** Device.IP.Diagnostics.IPLayerCapacityMetrics. *** + */ +static int browseIPLayerCapacityModalResultInst(struct dmctx *dmctx, DMNODE *parent_node, void *prev_data, char *prev_instance) +{ + struct uci_section *s = NULL; + char *inst = NULL; + + uci_path_foreach_sections(bbfdm, DMMAP_DIAGNOSTIGS, "modalresult", s) { + inst = handle_instance(dmctx, parent_node, s, "modal_instance", "modal_alias"); + if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)s, inst) == DM_STOP) + break; + } + return 0; +} + +static int browseIPLayerCapacityIncrementalResultInst(struct dmctx *dmctx, DMNODE *parent_node, void *prev_data, char *prev_instance) +{ + struct uci_section *s = NULL; + char *inst = NULL; + + uci_path_foreach_sections(bbfdm, DMMAP_DIAGNOSTIGS, "incrementalresult", s) { + inst = handle_instance(dmctx, parent_node, s, "incremental_instance", "incremental_alias"); + if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)s, inst) == DM_STOP) + break; + } + return 0; +} + + +static int get_IPDiagnosticsIPLayerCapacity_DiagnosticsState(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option_fallback_def("iplayercapacity", "DiagnosticState", "None"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_DiagnosticsState(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, -1, DiagnosticsState, NULL)) + return FAULT_9007; + return 0; + case VALUESET: + if (DM_LSTRCMP(value, "Requested") == 0) { + set_diagnostics_option("iplayercapacity", "DiagnosticState", value); + bbf_set_end_session_flag(ctx, BBF_END_SESSION_IPLAYERCAPACITY_DIAGNOSTIC); + } + return 0; + } + return 0; +} + +int get_IPDiagnosticsIPLayerCapacity_SoftwareVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = "7.5.1"; + return 0; +} + +int get_IPDiagnosticsIPLayerCapacity_MaxConnections(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = "1"; + return 0; +} + +int get_IPDiagnosticsIPLayerCapacity_MaxIncrementalResult(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = "3600"; + return 0; +} + +int get_IPDiagnosticsIPLayerCapacity_ControlProtocolVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = "9"; + return 0; +} + +int get_IPDiagnosticsIPLayerCapacity_SupportedMetrics(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = "IPLR,Sampled_RTT,IPDV,IPRR,RIPR"; + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_Interface(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + char *linker = get_diagnostics_option("iplayercapacity", "interface"); + adm_entry_get_linker_param(ctx, "Device.IP.Interface.", linker, value); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_Interface(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + char *allowed_objects[] = {"Device.IP.Interface.", NULL}; + + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, 256, NULL, NULL)) + return FAULT_9007; + + if (dm_entry_validate_allowed_objects(ctx, value, allowed_objects)) + return FAULT_9007; + + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_interface_option(ctx, "iplayercapacity", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_Role(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "Role"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_Role(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, -1, IPLayerCapacityRole, NULL)) + return FAULT_9007; + + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "Role", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_Host(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "Host"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_Host(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, 256, NULL, NULL)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "Host", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_Port(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "Port"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_Port(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"1","65535"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "Port", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_JumboFramesPermitted(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "JumboFramesPermitted"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_JumboFramesPermitted(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + bool b; + + switch (action) { + case VALUECHECK: + if (dm_validate_boolean(value)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + string_to_bool(value, &b); + set_diagnostics_option("iplayercapacity", "JumboFramesPermitted", b ? "1" : "0"); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_DSCP(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "DSCP"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_DSCP(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"0","63"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "DSCP", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_ProtocolVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "ProtocolVersion"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_ProtocolVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, -1, ProtocolVersion, NULL)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "ProtocolVersion", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_UDPPayloadContent(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "UDPPayloadContent"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_UDPPayloadContent(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, -1, UDPPayloadContent, NULL)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "UDPPayloadContent", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_TestType(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "TestType"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_TestType(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, -1, IPLayerCapacityTestType, NULL)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "TestType", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_IPDVEnable(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "IPDVEnable"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_IPDVEnable(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + bool b; + + switch (action) { + case VALUECHECK: + if (dm_validate_boolean(value)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + string_to_bool(value, &b); + set_diagnostics_option("iplayercapacity", "IPDVEnable", b ? "1" : "0"); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_StartSendingRateIndex(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "StartSendingRateIndex"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_StartSendingRateIndex(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + /* As per TR max should be 11108 but udpst supports 1108 */ + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"0","1108"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "StartSendingRateIndex", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_NumberFirstModeTestSubIntervals(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "NumberFirstModeTestSubIntervals"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_NumberFirstModeTestSubIntervals(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"0","100"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "NumberFirstModeTestSubIntervals", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_NumberTestSubIntervals(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "NumberTestSubIntervals"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_NumberTestSubIntervals(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + /* As per TR max should be 100 and (NumberTestSubIntervals * TestSubInterval) <= 60 sec + * since supported min value of TestSubInterval by udpst is 1 sec, so can be supported + * upto 60 value + */ + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"1","60"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "NumberTestSubIntervals", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_TestSubInterval(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "TestSubInterval"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_TestSubInterval(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + /* As per DM min should be 100 but udpst supports min 1000 */ + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"1000","6000"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "TestSubInterval", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_StatusFeedbackInterval(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "StatusFeedbackInterval"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_StatusFeedbackInterval(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"5","250"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "StatusFeedbackInterval", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_SeqErrThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "SeqErrThresh"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_SeqErrThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"0","100"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "SeqErrThresh", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_ReordDupIgnoreEnable(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "ReordDupIgnoreEnable"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_ReordDupIgnoreEnable(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + bool b; + + switch (action) { + case VALUECHECK: + if (dm_validate_boolean(value)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + string_to_bool(value, &b); + set_diagnostics_option("iplayercapacity", "ReordDupIgnoreEnable", b ? "1" : "0"); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_LowerThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "LowerThresh"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_LowerThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"5","250"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "LowerThresh", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_UpperThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "UpperThresh"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_UpperThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"5","250"}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "UpperThresh", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_HighSpeedDelta(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "HighSpeedDelta"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_HighSpeedDelta(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"2", NULL}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "HighSpeedDelta", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_RateAdjAlgorithm(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "RateAdjAlgorithm"); + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_RateAdjAlgorithm(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_string(value, -1, -1, RateAdjAlgorithm, NULL)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "RateAdjAlgorithm", value); + return 0; + } + return 0; +} + +static int set_IPDiagnosticsIPLayerCapacity_SlowAdjThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + switch (action) { + case VALUECHECK: + if (dm_validate_unsignedInt(value, RANGE_ARGS{{"2",NULL}}, 1)) + return FAULT_9007; + return 0; + case VALUESET: + reset_diagnostic_state("iplayercapacity"); + set_diagnostics_option("iplayercapacity", "SlowAdjThresh", value); + return 0; + } + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_SlowAdjThresh(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "SlowAdjThresh"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_BOMTime(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option_fallback_def("iplayercapacity", "BOMTime", "0001-01-01T00:00:00.000000Z"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_EOMTime(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option_fallback_def("iplayercapacity", "EOMTime", "0001-01-01T00:00:00.000000Z"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_TmaxUsed(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "TmaxUsed"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_TestInterval(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "TestInterval"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_MaxIPLayerCapacity(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "MaxIPLayerCapacity"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_TimeOfMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option_fallback_def("iplayercapacity", "TimeOfMax", "0001-01-01T00:00:00.000000Z"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_MaxETHCapacityNoFCS(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "MaxETHCapacityNoFCS"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_MaxETHCapacityWithFCS(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "MaxETHCapacityWithFCS"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_MaxETHCapacityWithFCSVLAN(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "MaxETHCapacityWithFCSVLAN"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_LossRatioAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "LossRatioAtMax"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_RTTRangeAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "RTTRangeAtMax"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_PDVRangeAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "PDVRangeAtMax"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_MinOnewayDelayAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "MinOnewayDelayAtMax"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_ReorderedRatioAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "ReorderedRatioAtMax"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_ReplicatedRatioAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "ReplicatedRatioAtMax"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_InterfaceEthMbpsAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "InterfaceEthMbpsAtMax"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_IPLayerCapacitySummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "IPLayerCapacitySummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_LossRatioSummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "LossRatioSummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_RTTRangeSummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "RTTRangeSummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_PDVRangeSummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "PDVRangeSummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_MinOnewayDelaySummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "MinOnewayDelaySummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_MinRTTSummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "MinRTTSummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_ReorderedRatioSummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "ReorderedRatioSummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_ReplicatedRatioSummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "ReplicatedRatioSummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_InterfaceEthMbpsSummary(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "InterfaceEthMbpsSummary"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_TmaxRTTUsed(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "TmaxRTTUsed"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_TimestampResolutionUsed(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = get_diagnostics_option("iplayercapacity", "TimestampResolutionUsed"); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_IncrementalResultNumberOfEntries(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + int cnt = get_number_of_entries(ctx, data, instance, browseIPLayerCapacityIncrementalResultInst); + dmasprintf(value, "%d", cnt); + return 0; +} + +static int get_IPDiagnosticsIPLayerCapacity_ModalResultNumberOfEntries(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + int cnt = get_number_of_entries(ctx, data, instance, browseIPLayerCapacityModalResultInst); + dmasprintf(value, "%d", cnt); + return 0; +} + +static int get_IPLayerCapacityModal_MaxIPLayerCapacity(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "MaxIPLayerCapacity", value); + return 0; +} + +static int get_IPLayerCapacityModal_TimeOfMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = dmuci_get_value_by_section_fallback_def((struct uci_section *)data, "TimeOfMax", "0001-01-01T00:00:00.000000Z"); + return 0; +} + +static int get_IPLayerCapacityModal_MaxETHCapacityNoFCS(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "MaxETHCapacityNoFCS", value); + return 0; +} + +static int get_IPLayerCapacityModal_MaxETHCapacityWithFCS(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "MaxETHCapacityWithFCS", value); + return 0; +} + +static int get_IPLayerCapacityModal_MaxETHCapacityWithFCSVLAN(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "MaxETHCapacityWithFCSVLAN", value); + return 0; +} + +static int get_IPLayerCapacityModal_LossRatioAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "LossRatioAtMax", value); + return 0; +} + +static int get_IPLayerCapacityModal_RTTRangeAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "RTTRangeAtMax", value); + return 0; +} + +static int get_IPLayerCapacityModal_PDVRangeAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "PDVRangeAtMax", value); + return 0; +} + +static int get_IPLayerCapacityModal_MinOnewayDelayAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "MinOnewayDelayAtMax", value); + return 0; +} + +static int get_IPLayerCapacityModal_ReorderedRatioAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "ReorderedRatioAtMax", value); + return 0; +} + +static int get_IPLayerCapacityModal_ReplicatedRatioAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "ReplicatedRatioAtMax", value); + return 0; +} + +static int get_IPLayerCapacityModal_InterfaceEthMbpsAtMax(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "InterfaceEthMbpsAtMax", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_IPLayerCapacity(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "IPLayerCapacity", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_TimeOfSubInterval(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = dmuci_get_value_by_section_fallback_def((struct uci_section *)data, "TimeOfSubInterval", "0001-01-01T00:00:00.000000Z"); + return 0; +} + +static int get_IPLayerCapacityIncremental_LossRatio(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "LossRatio", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_RTTRange(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "RTTRange", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_PDVRange(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "PDVRange", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_MinOnewayDelay(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "MinOnewayDelay", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_ReorderedRatio(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "ReorderedRatio", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_ReplicatedRatio(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "ReplicatedRatio", value); + return 0; +} + +static int get_IPLayerCapacityIncremental_InterfaceEthMbps(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + dmuci_get_value_by_section_string((struct uci_section *)data, "InterfaceEthMbps", value); + return 0; +} + +static operation_args ip_diagnostics_iplayercapacity_args = { + .in = (const char *[]) { + "Interface", + "Role", + "Host", + "Port", + "JumboFramesPermitted", + "DSCP", + "ProtocolVersion", + "UDPPayloadContent", + "TestType", + "IPDVEnable", + "StartSendingRateIndex", + "NumberTestSubIntervals", + "NumberFirstModeTestSubIntervals", + "TestSubInterval", + "StatusFeedbackInterval", + "SeqErrThresh", + "ReordDupIgnoreEnable", + "LowerThresh", + "UpperThresh", + "HighSpeedDelta", + "SlowAdjThresh", + "RateAdjAlgorithm", + NULL + }, + .out = (const char *[]) { + "Status", + "BOMTime", + "EOMTime", + "TmaxUsed", + "TestInterval", + "MaxIPLayerCapacity", + "TimeOfMax", + "MaxETHCapacityNoFCS", + "MaxETHCapacityWithFCS", + "MaxETHCapacityWithFCSVLAN", + "LossRatioAtMax", + "RTTRangeAtMax", + "PDVRangeAtMax", + "MinOnewayDelayAtMax", + "ReorderedRatioAtMax", + "ReplicatedRatioAtMax", + "InterfaceEthMbpsAtMax", + "IPLayerCapacitySummary", + "LossRatioSummary", + "RTTRangeSummary", + "PDVRangeSummary", + "MinOnewayDelaySummary", + "MinRTTSummary", + "ReorderedRatioSummary", + "ReplicatedRatioSummary", + "InterfaceEthMbpsSummary", + "TmaxRTTUsed", + "TimestampResolutionUsed", + "ModalResult.{i}.MaxIPLayerCapacity", + "ModalResult.{i}.TimeOfMax", + "ModalResult.{i}.MaxETHCapacityNoFCS", + "ModalResult.{i}.MaxETHCapacityWithFCS", + "ModalResult.{i}.MaxETHCapacityWithFCSVLAN", + "ModalResult.{i}.LossRatioAtMax", + "ModalResult.{i}.RTTRangeAtMax", + "ModalResult.{i}.PDVRangeAtMax", + "ModalResult.{i}.MinOnewayDelayAtMax", + "ModalResult.{i}.ReorderedRatioAtMax", + "ModalResult.{i}.ReplicatedRatioAtMax", + "ModalResult.{i}.InterfaceEthMbpsAtMax", + "IncrementalResult.{i}.IPLayerCapacity", + "IncrementalResult.{i}.TimeOfSubInterval", + "IncrementalResult.{i}.LossRatio", + "IncrementalResult.{i}.RTTRange", + "IncrementalResult.{i}.PDVRange", + "IncrementalResult.{i}.MinOnewayDelay", + "IncrementalResult.{i}.ReorderedRatio", + "IncrementalResult.{i}.ReplicatedRatio", + "IncrementalResult.{i}.InterfaceEthMbps", + NULL + } +}; + +int get_operate_args_IPDiagnostics_IPLayerCapacity(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value) +{ + *value = (char *)&ip_diagnostics_iplayercapacity_args; + return 0; +} + +int operate_IPDiagnostics_IPLayerCapacity(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action) +{ + char input[4096] = {0}; + char output[40000] = {0}; + char cmd[5120] = {0}; + unsigned int idx = 0; + + char *host = dmjson_get_value((json_object *)value, 1, "Host"); + if (host[0] == '\0') + return CMD_INVALID_ARGUMENTS; + + char *ip_interface = dmjson_get_value((json_object *)value, 1, "Interface"); + char *interface = get_diagnostics_interface_option(ctx, ip_interface); + char *role = dmjson_get_value((json_object *)value, 1, "Role"); + if (role[0] != '\0' && dm_validate_string(role, -1, -1, IPLayerCapacityRole, NULL)) + return CMD_INVALID_ARGUMENTS; + + char *port = dmjson_get_value((json_object *)value, 1, "Port"); + if (port[0] != '\0' && dm_validate_unsignedInt(port, RANGE_ARGS{{"1","65535"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *jumbo = dmjson_get_value((json_object *)value, 1, "JumboFramesPermitted"); + bool jumbo_en = false; + string_to_bool(jumbo, &jumbo_en); + + char *dscp = dmjson_get_value((json_object *)value, 1, "DSCP"); + if (dscp[0] != '\0' && dm_validate_unsignedInt(dscp, RANGE_ARGS{{"0","63"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *ip_proto = dmjson_get_value((json_object *)value, 1, "ProtocolVersion"); + if (ip_proto[0] != '\0' && dm_validate_string(ip_proto, -1, -1, ProtocolVersion, NULL)) + return CMD_INVALID_ARGUMENTS; + + char *content = dmjson_get_value((json_object *)value, 1, "UDPPayloadContent"); + if (content[0] != '\0' && dm_validate_string(content, -1, -1, UDPPayloadContent, NULL)) + return CMD_INVALID_ARGUMENTS; + + char *test_type = dmjson_get_value((json_object *)value, 1, "TestType"); + if (test_type[0] != '\0' && dm_validate_string(test_type, -1, -1, IPLayerCapacityTestType, NULL)) + return CMD_INVALID_ARGUMENTS; + + char *ipdv = dmjson_get_value((json_object *)value, 1, "IPDVEnable"); + bool ipdv_en = false; + string_to_bool(ipdv, &ipdv_en); + + char *start_rate = dmjson_get_value((json_object *)value, 1, "StartSendingRateIndex"); + if (start_rate[0] != '\0' && dm_validate_unsignedInt(start_rate, RANGE_ARGS{{"0","1108"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *num_interval = dmjson_get_value((json_object *)value, 1, "NumberTestSubIntervals"); + if (num_interval[0] != '\0' && dm_validate_unsignedInt(num_interval, RANGE_ARGS{{"1","60"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *mode_test = dmjson_get_value((json_object *)value, 1, "NumberFirstModeTestSubIntervals"); + if (mode_test[0] != '\0' && dm_validate_unsignedInt(mode_test, RANGE_ARGS{{"0","100"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *sub_interval = dmjson_get_value((json_object *)value, 1, "TestSubInterval"); + if (sub_interval[0] != '\0' && dm_validate_unsignedInt(sub_interval, RANGE_ARGS{{"1000","6000"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *feed_interval = dmjson_get_value((json_object *)value, 1, "StatusFeedbackInterval"); + if (feed_interval[0] != '\0' && dm_validate_unsignedInt(feed_interval, RANGE_ARGS{{"5","250"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *seq_err = dmjson_get_value((json_object *)value, 1, "SeqErrThresh"); + if (seq_err[0] != '\0' && dm_validate_unsignedInt(seq_err, RANGE_ARGS{{"0","100"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *dup_ignore = dmjson_get_value((json_object *)value, 1, "ReordDupIgnoreEnable"); + bool dup_ignore_en = false; + string_to_bool(dup_ignore, &dup_ignore_en); + + char *low_thresh = dmjson_get_value((json_object *)value, 1, "LowerThresh"); + if (low_thresh[0] != '\0' && dm_validate_unsignedInt(low_thresh, RANGE_ARGS{{"5","250"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *up_thresh = dmjson_get_value((json_object *)value, 1, "UpperThresh"); + if (up_thresh[0] != '\0' && dm_validate_unsignedInt(up_thresh, RANGE_ARGS{{"5","250"}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *speed_delta = dmjson_get_value((json_object *)value, 1, "HighSpeedDelta"); + if (speed_delta[0] != '\0' && dm_validate_unsignedInt(speed_delta, RANGE_ARGS{{"2", NULL}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *slow_adj = dmjson_get_value((json_object *)value, 1, "SlowAdjThresh"); + if (slow_adj[0] != '\0' && dm_validate_unsignedInt(slow_adj, RANGE_ARGS{{"2", NULL}}, 1)) + return CMD_INVALID_ARGUMENTS; + + char *rate_adj = dmjson_get_value((json_object *)value, 1, "RateAdjAlgorithm"); + if (rate_adj[0] != '\0' && dm_validate_string(rate_adj, -1, -1, RateAdjAlgorithm, NULL)) + return CMD_INVALID_ARGUMENTS; + + snprintf(input, sizeof(input), "'{\"host\": \"%s\",\"interface\":\"%s\",\"role\":\"%s\",\"port\":\"%s\",\"jumbo_frames\":\"%s\",\"proto_ver\":\"%s\",\"udp_content\":\"%s\",\"test_type\":\"%s\",\"ipdv_enable\":\"%s\",\"DSCP\":\"%s\",\"rate_index\":\"%s\",\"mode_subintervals\":\"%s\",\"test_subinterval\":\"%s\",\"feedback_interval\":\"%s\",\"seq_err_thresh\":\"%s\",\"dup_ignore\":\"%s\",\"lower_thresh\":\"%s\",\"upper_thresh\":\"%s\",\"high_speed_delta\":\"%s\",\"algorithm\":\"%s\",\"slow_adj_thresh\":\"%s\",\"num_interval\":\"%s\",\"proto\":\"%s\"}'", + host, interface, role, port, DM_STRLEN(jumbo) > 0 ? (jumbo_en ? "1" : "0") : "\0", + ip_proto, content, test_type, DM_STRLEN(ipdv) > 0 ? (ipdv_en ? "1" : "0") : "\0", + dscp, start_rate, mode_test, sub_interval, feed_interval, seq_err, + DM_STRLEN(dup_ignore) > 0 ? (dup_ignore_en ? "1" : "0") : "\0", low_thresh, up_thresh, + speed_delta, rate_adj, slow_adj, num_interval, (bbfdatamodel_type == BBFDM_USP) ? "usp" : "both_proto"); + + snprintf(cmd, sizeof(cmd), "sh %s %s", IPLAYER_CAP_DIAGNOSTIC_PATH, input); + + FILE *pp = popen(cmd, "r"); + if (pp != NULL) { + fgets(output, sizeof(output), pp); + pclose(pp); + } else { + return CMD_FAIL; + } + + json_object *res = (DM_STRLEN(output)) ? json_tokener_parse(output) : NULL; + + if (res == NULL) { + return CMD_FAIL; + } + + char *status = NULL; + char *err = dmjson_get_value(res, 1, "ErrorStatus"); + if (DM_STRCMP(err, "0") != 0) + status = "Error_Internal"; + else + status = "Complete"; + + add_list_parameter(ctx, dmstrdup("Status"), dmstrdup(status), DMT_TYPE[DMT_STRING], NULL); + + json_object *jobj = dmjson_get_obj(res, 1, "Output"); + if (jobj) { + char *BOMTime = dmjson_get_value(jobj, 1, "BOMTime"); + char *EOMTime = dmjson_get_value(jobj, 1, "EOMTime"); + char *TmaxUsed = dmjson_get_value(jobj, 1, "TmaxUsed"); + char *TestInterval = dmjson_get_value(jobj, 1, "TestInterval"); + char *TmaxRTTUsed = dmjson_get_value(jobj, 1, "TmaxRTTUsed"); + char *TimestampResolutionUsed = dmjson_get_value(jobj, 1, "TimestampResolutionUsed"); + + add_list_parameter(ctx, dmstrdup("BOMTime"), dmstrdup(BOMTime), DMT_TYPE[DMT_TIME], NULL); + add_list_parameter(ctx, dmstrdup("EOMTime"), dmstrdup(EOMTime), DMT_TYPE[DMT_TIME], NULL); + add_list_parameter(ctx, dmstrdup("TmaxUsed"), dmstrdup(TmaxUsed), DMT_TYPE[DMT_UNINT], NULL); + add_list_parameter(ctx, dmstrdup("TestInterval"), dmstrdup(TestInterval), DMT_TYPE[DMT_UNINT], NULL); + add_list_parameter(ctx, dmstrdup("TmaxRTTUsed"), dmstrdup(TmaxRTTUsed), DMT_TYPE[DMT_UNINT], NULL); + add_list_parameter(ctx, dmstrdup("TimestampResolutionUsed"), dmstrdup(TimestampResolutionUsed), DMT_TYPE[DMT_UNINT], NULL); + + json_object *atmax = dmjson_get_obj(jobj, 1, "AtMax"); + if (atmax) { + char *MaxIPLayerCapacity = dmjson_get_value(atmax, 1, "MaxIPLayerCapacity"); + char *TimeOfMax = dmjson_get_value(atmax, 1, "TimeOfMax"); + char *MaxETHCapacityNoFCS = dmjson_get_value(atmax, 1, "MaxETHCapacityNoFCS"); + char *MaxETHCapacityWithFCS = dmjson_get_value(atmax, 1, "MaxETHCapacityWithFCS"); + char *MaxETHCapacityWithFCSVLAN = dmjson_get_value(atmax, 1, "MaxETHCapacityWithFCSVLAN"); + char *LossRatioAtMax = dmjson_get_value(atmax, 1, "LossRatioAtMax"); + char *RTTRangeAtMax = dmjson_get_value(atmax, 1, "RTTRangeAtMax"); + char *PDVRangeAtMax = dmjson_get_value(atmax, 1, "PDVRangeAtMax"); + char *MinOnewayDelayAtMax = dmjson_get_value(atmax, 1, "MinOnewayDelayAtMax"); + char *ReorderedRatioAtMax = dmjson_get_value(atmax, 1, "ReorderedRatioAtMax"); + char *ReplicatedRatioAtMax = dmjson_get_value(atmax, 1, "ReplicatedRatioAtMax"); + char *InterfaceEthMbpsAtMax = dmjson_get_value(atmax, 1, "InterfaceEthMbps"); + + add_list_parameter(ctx, dmstrdup("MaxIPLayerCapacity"), dmstrdup(MaxIPLayerCapacity), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("TimeOfMax"), dmstrdup(TimeOfMax), DMT_TYPE[DMT_TIME], NULL); + add_list_parameter(ctx, dmstrdup("MaxETHCapacityNoFCS"), dmstrdup(MaxETHCapacityNoFCS), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("MaxETHCapacityWithFCS"), dmstrdup(MaxETHCapacityWithFCS), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("MaxETHCapacityWithFCSVLAN"), dmstrdup(MaxETHCapacityWithFCSVLAN), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("LossRatioAtMax"), dmstrdup(LossRatioAtMax), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("RTTRangeAtMax"), dmstrdup(RTTRangeAtMax), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("PDVRangeAtMax"), dmstrdup(PDVRangeAtMax), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("MinOnewayDelayAtMax"), dmstrdup(MinOnewayDelayAtMax), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("ReorderedRatioAtMax"), dmstrdup(ReorderedRatioAtMax), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("ReplicatedRatioAtMax"), dmstrdup(ReplicatedRatioAtMax), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("InterfaceEthMbpsAtMax"), dmstrdup(InterfaceEthMbpsAtMax), DMT_TYPE[DMT_STRING], NULL); + } + + json_object *sum = dmjson_get_obj(jobj, 1, "Summary"); + if (sum) { + char *IPLayerCapacitySummary = dmjson_get_value(sum, 1, "IPLayerCapacitySummary"); + char *LossRatioSummary = dmjson_get_value(sum, 1, "LossRatioSummary"); + char *RTTRangeSummary = dmjson_get_value(sum, 1, "RTTRangeSummary"); + char *PDVRangeSummary = dmjson_get_value(sum, 1, "PDVRangeSummary"); + char *MinOnewayDelaySummary = dmjson_get_value(sum, 1, "MinOnewayDelaySummary"); + char *MinRTTSummary = dmjson_get_value(sum, 1, "MinRTTSummary"); + char *ReorderedRatioSummary = dmjson_get_value(sum, 1, "ReorderedRatioSummary"); + char *ReplicatedRatioSummary = dmjson_get_value(sum, 1, "ReplicatedRatioSummary"); + char *InterfaceEthMbpsSummary = dmjson_get_value(sum, 1, "InterfaceEthMbps"); + + add_list_parameter(ctx, dmstrdup("IPLayerCapacitySummary"), dmstrdup(IPLayerCapacitySummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("LossRatioSummary"), dmstrdup(LossRatioSummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("RTTRangeSummary"), dmstrdup(RTTRangeSummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("PDVRangeSummary"), dmstrdup(PDVRangeSummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("MinOnewayDelaySummary"), dmstrdup(MinOnewayDelaySummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("MinRTTSummary"), dmstrdup(MinRTTSummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("ReorderedRatioSummary"), dmstrdup(ReorderedRatioSummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("ReplicatedRatioSummary"), dmstrdup(ReplicatedRatioSummary), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, dmstrdup("InterfaceEthMbpsSummary"), dmstrdup(InterfaceEthMbpsSummary), DMT_TYPE[DMT_STRING], NULL); + } + + json_object *arrobj = NULL, *modal = NULL; + dmjson_foreach_obj_in_array(jobj, arrobj, modal, idx, 1, "ModalResult") { + unsigned int i = idx + 1; + char *MaxIPLayerCapacity[2] = {0}; + char *TimeOfMax[2] = {0}; + char *MaxETHCapacityNoFCS[2] = {0}; + char *MaxETHCapacityWithFCS[2] = {0}; + char *MaxETHCapacityWithFCSVLAN[2] = {0}; + char *LossRatioAtMax[2] = {0}; + char *RTTRangeAtMax[2] = {0}; + char *PDVRangeAtMax[2] = {0}; + char *MinOnewayDelayAtMax[2] = {0}; + char *ReorderedRatioAtMax[2] = {0}; + char *ReplicatedRatioAtMax[2] = {0}; + char *InterfaceEthMbpsAtMax[2] = {0}; + + MaxIPLayerCapacity[1] = dmjson_get_value(modal, 1, "MaxIPLayerCapacity"); + dmasprintf(&MaxIPLayerCapacity[0], "ModalResult.%u.MaxIPLayerCapacity", i); + + TimeOfMax[1] = dmjson_get_value(modal, 1, "TimeOfMax"); + dmasprintf(&TimeOfMax[0], "ModalResult.%u.TimeOfMax", i); + + MaxETHCapacityNoFCS[1] = dmjson_get_value(modal, 1, "MaxETHCapacityNoFCS"); + dmasprintf(&MaxETHCapacityNoFCS[0], "ModalResult.%u.MaxETHCapacityNoFCS", i); + + MaxETHCapacityWithFCS[1] = dmjson_get_value(modal, 1, "MaxETHCapacityWithFCS"); + dmasprintf(&MaxETHCapacityWithFCS[0], "ModalResult.%u.MaxETHCapacityWithFCS", i); + + MaxETHCapacityWithFCSVLAN[1] = dmjson_get_value(modal, 1, "MaxETHCapacityWithFCSVLAN"); + dmasprintf(&MaxETHCapacityWithFCSVLAN[0], "ModalResult.%u.MaxETHCapacityWithFCSVLAN", i); + + LossRatioAtMax[1] = dmjson_get_value(modal, 1, "LossRatioAtMax"); + dmasprintf(&LossRatioAtMax[0], "ModalResult.%u.LossRatioAtMax", i); + + RTTRangeAtMax[1] = dmjson_get_value(modal, 1, "RTTRangeAtMax"); + dmasprintf(&RTTRangeAtMax[0], "ModalResult.%u.RTTRangeAtMax", i); + + PDVRangeAtMax[1] = dmjson_get_value(modal, 1, "PDVRangeAtMax"); + dmasprintf(&PDVRangeAtMax[0], "ModalResult.%u.PDVRangeAtMax", i); + + MinOnewayDelayAtMax[1] = dmjson_get_value(modal, 1, "MinOnewayDelayAtMax"); + dmasprintf(&MinOnewayDelayAtMax[0], "ModalResult.%u.MinOnewayDelayAtMax", i); + + ReorderedRatioAtMax[1] = dmjson_get_value(modal, 1, "ReorderedRatioAtMax"); + dmasprintf(&ReorderedRatioAtMax[0], "ModalResult.%u.ReorderedRatioAtMax", i); + + ReplicatedRatioAtMax[1] = dmjson_get_value(modal, 1, "ReplicatedRatioAtMax"); + dmasprintf(&ReplicatedRatioAtMax[0], "ModalResult.%u.ReplicatedRatioAtMax", i); + + InterfaceEthMbpsAtMax[1] = dmjson_get_value(modal, 1, "InterfaceEthMbps"); + dmasprintf(&InterfaceEthMbpsAtMax[0], "ModalResult.%u.InterfaceEthMbpsAtMax", i); + + add_list_parameter(ctx, MaxIPLayerCapacity[0], dmstrdup(MaxIPLayerCapacity[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, TimeOfMax[0], dmstrdup(TimeOfMax[1]), DMT_TYPE[DMT_TIME], NULL); + add_list_parameter(ctx, MaxETHCapacityNoFCS[0], dmstrdup(MaxETHCapacityNoFCS[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, MaxETHCapacityWithFCS[0], dmstrdup(MaxETHCapacityWithFCS[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, MaxETHCapacityWithFCSVLAN[0], dmstrdup(MaxETHCapacityWithFCSVLAN[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, LossRatioAtMax[0], dmstrdup(LossRatioAtMax[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, RTTRangeAtMax[0], dmstrdup(RTTRangeAtMax[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, PDVRangeAtMax[0], dmstrdup(PDVRangeAtMax[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, MinOnewayDelayAtMax[0], dmstrdup(MinOnewayDelayAtMax[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, ReorderedRatioAtMax[0], dmstrdup(ReorderedRatioAtMax[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, ReplicatedRatioAtMax[0], dmstrdup(ReplicatedRatioAtMax[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, InterfaceEthMbpsAtMax[0], dmstrdup(InterfaceEthMbpsAtMax[1]), DMT_TYPE[DMT_STRING], NULL); + } + + idx = 0; + json_object *arrob = NULL, *incremental = NULL; + dmjson_foreach_obj_in_array(jobj, arrob, incremental, idx, 1, "IncrementalResult") { + unsigned int i = idx + 1; + char *IPLayerCapacity[2] = {0}; + char *TimeOfSubInterval[2] = {0}; + char *LossRatio[2] = {0}; + char *RTTRange[2] = {0}; + char *PDVRange[2] = {0}; + char *MinOnewayDelay[2] = {0}; + char *ReorderedRatio[2] = {0}; + char *ReplicatedRatio[2] = {0}; + char *InterfaceEthMbps[2] = {0}; + + IPLayerCapacity[1] = dmjson_get_value(incremental, 1, "IPLayerCapacity"); + dmasprintf(&IPLayerCapacity[0], "IncrementalResult.%u.IPLayerCapacity", i); + + TimeOfSubInterval[1] = dmjson_get_value(incremental, 1, "TimeOfSubInterval"); + dmasprintf(&TimeOfSubInterval[0], "IncrementalResult.%u.TimeOfSubInterval", i); + + LossRatio[1] = dmjson_get_value(incremental, 1, "LossRatio"); + dmasprintf(&LossRatio[0], "IncrementalResult.%u.LossRatio", i); + + RTTRange[1] = dmjson_get_value(incremental, 1, "RTTRange"); + dmasprintf(&RTTRange[0], "IncrementalResult.%u.RTTRange", i); + + PDVRange[1] = dmjson_get_value(incremental, 1, "PDVRange"); + dmasprintf(&PDVRange[0], "IncrementalResult.%u.PDVRange", i); + + MinOnewayDelay[1] = dmjson_get_value(incremental, 1, "MinOnewayDelay"); + dmasprintf(&MinOnewayDelay[0], "IncrementalResult.%u.MinOnewayDelay", i); + + ReorderedRatio[1] = dmjson_get_value(incremental, 1, "ReorderedRatio"); + dmasprintf(&ReorderedRatio[0], "IncrementalResult.%u.ReorderedRatio", i); + + ReplicatedRatio[1] = dmjson_get_value(incremental, 1, "ReplicatedRatio"); + dmasprintf(&ReplicatedRatio[0], "IncrementalResult.%u.ReplicatedRatio", i); + + InterfaceEthMbps[1] = dmjson_get_value(incremental, 1, "InterfaceEthMbps"); + dmasprintf(&InterfaceEthMbps[0], "IncrementalResult.%u.InterfaceEthMbps", i); + + add_list_parameter(ctx, IPLayerCapacity[0], dmstrdup(IPLayerCapacity[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, TimeOfSubInterval[0], dmstrdup(TimeOfSubInterval[1]), DMT_TYPE[DMT_TIME], NULL); + add_list_parameter(ctx, LossRatio[0], dmstrdup(LossRatio[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, RTTRange[0], dmstrdup(RTTRange[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, PDVRange[0], dmstrdup(PDVRange[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, MinOnewayDelay[0], dmstrdup(MinOnewayDelay[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, ReorderedRatio[0], dmstrdup(ReorderedRatio[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, ReplicatedRatio[0], dmstrdup(ReplicatedRatio[1]), DMT_TYPE[DMT_STRING], NULL); + add_list_parameter(ctx, InterfaceEthMbps[0], dmstrdup(InterfaceEthMbps[1]), DMT_TYPE[DMT_STRING], NULL); + } + } + + if (res != NULL) + json_object_put(res); + + return CMD_SUCCESS; +} + +/********************************************************************************************************************************** +* OBJ & LEAF DEFINITION +***********************************************************************************************************************************/ + +/* *** Device.IP.Diagnostics.IPLayerCapacityMetrics. *** */ +DMOBJ tIPLayerCapacityObj[] = { +/* OBJ, permission, addobj, delobj, checkdep, browseinstobj, nextdynamicobj, dynamicleaf, nextobj, leaf, linker, bbfdm_type, uniqueKeys*/ +{"ModalResult", &DMREAD, NULL, NULL, NULL, browseIPLayerCapacityModalResultInst, NULL, NULL, NULL, tIPLayerCapacityModalResultParams, NULL, BBFDM_CWMP}, +{"IncrementalResult", &DMREAD, NULL, NULL, NULL, browseIPLayerCapacityIncrementalResultInst, NULL, NULL, NULL, tIPLayerCapacityIncrementalResultParams, NULL, BBFDM_CWMP}, +{0} +}; + +DMLEAF tIPLayerCapacityParams[] = { +/* PARAM, permission, type, getvalue, setvalue, bbfdm_type*/ +{"DiagnosticsState", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_DiagnosticsState, set_IPDiagnosticsIPLayerCapacity_DiagnosticsState, BBFDM_CWMP}, +{"IPLayerMaxConnections", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_MaxConnections, NULL, BBFDM_CWMP}, +{"IPLayerMaxIncrementalResult", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_MaxIncrementalResult, NULL, BBFDM_CWMP}, +{"IPLayerCapSupportedSoftwareVersion", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_SoftwareVersion, NULL, BBFDM_CWMP}, +{"IPLayerCapSupportedControlProtocolVersion", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_ControlProtocolVersion, NULL, BBFDM_CWMP}, +{"IPLayerCapSupportedMetrics", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_SupportedMetrics, NULL, BBFDM_CWMP}, +{"Interface", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_Interface, set_IPDiagnosticsIPLayerCapacity_Interface, BBFDM_CWMP}, +{"Role", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_Role, set_IPDiagnosticsIPLayerCapacity_Role, BBFDM_CWMP}, +{"Host", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_Host, set_IPDiagnosticsIPLayerCapacity_Host, BBFDM_CWMP}, +{"Port", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_Port, set_IPDiagnosticsIPLayerCapacity_Port, BBFDM_CWMP}, +{"JumboFramesPermitted", &DMWRITE, DMT_BOOL, get_IPDiagnosticsIPLayerCapacity_JumboFramesPermitted, set_IPDiagnosticsIPLayerCapacity_JumboFramesPermitted, BBFDM_CWMP}, +{"DSCP", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_DSCP, set_IPDiagnosticsIPLayerCapacity_DSCP, BBFDM_CWMP}, +{"ProtocolVersion", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_ProtocolVersion, set_IPDiagnosticsIPLayerCapacity_ProtocolVersion, BBFDM_CWMP}, +{"UDPPayloadContent", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_UDPPayloadContent, set_IPDiagnosticsIPLayerCapacity_UDPPayloadContent, BBFDM_CWMP}, +{"TestType", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_TestType, set_IPDiagnosticsIPLayerCapacity_TestType, BBFDM_CWMP}, +{"IPDVEnable", &DMWRITE, DMT_BOOL, get_IPDiagnosticsIPLayerCapacity_IPDVEnable, set_IPDiagnosticsIPLayerCapacity_IPDVEnable, BBFDM_CWMP}, +{"StartSendingRateIndex", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_StartSendingRateIndex, set_IPDiagnosticsIPLayerCapacity_StartSendingRateIndex, BBFDM_CWMP}, +{"NumberTestSubIntervals", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_NumberTestSubIntervals, set_IPDiagnosticsIPLayerCapacity_NumberTestSubIntervals, BBFDM_CWMP}, +{"NumberFirstModeTestSubIntervals", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_NumberFirstModeTestSubIntervals, set_IPDiagnosticsIPLayerCapacity_NumberFirstModeTestSubIntervals, BBFDM_CWMP}, +{"TestSubInterval", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_TestSubInterval, set_IPDiagnosticsIPLayerCapacity_TestSubInterval, BBFDM_CWMP}, +{"StatusFeedbackInterval", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_StatusFeedbackInterval, set_IPDiagnosticsIPLayerCapacity_StatusFeedbackInterval, BBFDM_CWMP}, +{"SeqErrThresh", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_SeqErrThresh, set_IPDiagnosticsIPLayerCapacity_SeqErrThresh, BBFDM_CWMP}, +{"ReordDupIgnoreEnable", &DMWRITE, DMT_BOOL, get_IPDiagnosticsIPLayerCapacity_ReordDupIgnoreEnable, set_IPDiagnosticsIPLayerCapacity_ReordDupIgnoreEnable, BBFDM_CWMP}, +{"LowerThresh", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_LowerThresh, set_IPDiagnosticsIPLayerCapacity_LowerThresh, BBFDM_CWMP}, +{"UpperThresh", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_UpperThresh, set_IPDiagnosticsIPLayerCapacity_UpperThresh, BBFDM_CWMP}, +{"HighSpeedDelta", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_HighSpeedDelta, set_IPDiagnosticsIPLayerCapacity_HighSpeedDelta, BBFDM_CWMP}, +{"RateAdjAlgorithm", &DMWRITE, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_RateAdjAlgorithm, set_IPDiagnosticsIPLayerCapacity_RateAdjAlgorithm, BBFDM_CWMP}, +{"SlowAdjThresh", &DMWRITE, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_SlowAdjThresh, set_IPDiagnosticsIPLayerCapacity_SlowAdjThresh, BBFDM_CWMP}, +{"BOMTime", &DMREAD, DMT_TIME, get_IPDiagnosticsIPLayerCapacity_BOMTime, NULL, BBFDM_CWMP}, +{"EOMTime", &DMREAD, DMT_TIME, get_IPDiagnosticsIPLayerCapacity_EOMTime, NULL, BBFDM_CWMP}, +{"TmaxUsed", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_TmaxUsed, NULL, BBFDM_CWMP}, +{"TestInterval", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_TestInterval, NULL, BBFDM_CWMP}, +{"MaxIPLayerCapacity", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_MaxIPLayerCapacity, NULL, BBFDM_CWMP}, +{"TimeOfMax", &DMREAD, DMT_TIME, get_IPDiagnosticsIPLayerCapacity_TimeOfMax, NULL, BBFDM_CWMP}, +{"MaxETHCapacityNoFCS", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_MaxETHCapacityNoFCS, NULL, BBFDM_CWMP}, +{"MaxETHCapacityWithFCS", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_MaxETHCapacityWithFCS, NULL, BBFDM_CWMP}, +{"MaxETHCapacityWithFCSVLAN", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_MaxETHCapacityWithFCSVLAN, NULL, BBFDM_CWMP}, +{"LossRatioAtMax", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_LossRatioAtMax, NULL, BBFDM_CWMP}, +{"RTTRangeAtMax", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_RTTRangeAtMax, NULL, BBFDM_CWMP}, +{"PDVRangeAtMax", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_PDVRangeAtMax, NULL, BBFDM_CWMP}, +{"MinOnewayDelayAtMax", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_MinOnewayDelayAtMax, NULL, BBFDM_CWMP}, +{"ReorderedRatioAtMax", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_ReorderedRatioAtMax, NULL, BBFDM_CWMP}, +{"ReplicatedRatioAtMax", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_ReplicatedRatioAtMax, NULL, BBFDM_CWMP}, +{"InterfaceEthMbpsAtMax", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_InterfaceEthMbpsAtMax, NULL, BBFDM_CWMP}, +{"IPLayerCapacitySummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_IPLayerCapacitySummary, NULL, BBFDM_CWMP}, +{"LossRatioSummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_LossRatioSummary, NULL, BBFDM_CWMP}, +{"RTTRangeSummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_RTTRangeSummary, NULL, BBFDM_CWMP}, +{"PDVRangeSummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_PDVRangeSummary, NULL, BBFDM_CWMP}, +{"MinOnewayDelaySummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_MinOnewayDelaySummary, NULL, BBFDM_CWMP}, +{"MinRTTSummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_MinRTTSummary, NULL, BBFDM_CWMP}, +{"ReorderedRatioSummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_ReorderedRatioSummary, NULL, BBFDM_CWMP}, +{"ReplicatedRatioSummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_ReplicatedRatioSummary, NULL, BBFDM_CWMP}, +{"InterfaceEthMbpsSummary", &DMREAD, DMT_STRING, get_IPDiagnosticsIPLayerCapacity_InterfaceEthMbpsSummary, NULL, BBFDM_CWMP}, +{"IncrementalResultNumberOfEntries", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_IncrementalResultNumberOfEntries, NULL, BBFDM_CWMP}, +{"ModalResultNumberOfEntries", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_ModalResultNumberOfEntries, NULL, BBFDM_CWMP}, +{"TmaxRTTUsed", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_TmaxRTTUsed, NULL, BBFDM_CWMP}, +{"TimestampResolutionUsed", &DMREAD, DMT_UNINT, get_IPDiagnosticsIPLayerCapacity_TimestampResolutionUsed, NULL, BBFDM_CWMP}, +{0} +}; + +DMLEAF tIPLayerCapacityModalResultParams[] = { +/* PARAM, permission, type, getvalue, setvalue, bbfdm_type*/ +{"MaxIPLayerCapacity", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_MaxIPLayerCapacity, NULL, BBFDM_CWMP}, +{"TimeOfMax", &DMREAD, DMT_TIME, get_IPLayerCapacityModal_TimeOfMax, NULL, BBFDM_CWMP}, +{"MaxETHCapacityNoFCS", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_MaxETHCapacityNoFCS, NULL, BBFDM_CWMP}, +{"MaxETHCapacityWithFCS", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_MaxETHCapacityWithFCS, NULL, BBFDM_CWMP}, +{"MaxETHCapacityWithFCSVLAN", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_MaxETHCapacityWithFCSVLAN, NULL, BBFDM_CWMP}, +{"LossRatioAtMax", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_LossRatioAtMax, NULL, BBFDM_CWMP}, +{"RTTRangeAtMax", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_RTTRangeAtMax, NULL, BBFDM_CWMP}, +{"PDVRangeAtMax", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_PDVRangeAtMax, NULL, BBFDM_CWMP}, +{"MinOnewayDelayAtMax", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_MinOnewayDelayAtMax, NULL, BBFDM_CWMP}, +{"ReorderedRatioAtMax", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_ReorderedRatioAtMax, NULL, BBFDM_CWMP}, +{"ReplicatedRatioAtMax", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_ReplicatedRatioAtMax, NULL, BBFDM_CWMP}, +{"InterfaceEthMbpsAtMax", &DMREAD, DMT_STRING, get_IPLayerCapacityModal_InterfaceEthMbpsAtMax, NULL, BBFDM_CWMP}, +{0} +}; + +DMLEAF tIPLayerCapacityIncrementalResultParams[] = { +/* PARAM, permission, type, getvalue, setvalue, bbfdm_type*/ +{"IPLayerCapacity", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_IPLayerCapacity, NULL, BBFDM_CWMP}, +{"TimeOfSubInterval", &DMREAD, DMT_TIME, get_IPLayerCapacityIncremental_TimeOfSubInterval, NULL, BBFDM_CWMP}, +{"LossRatio", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_LossRatio, NULL, BBFDM_CWMP}, +{"RTTRange", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_RTTRange, NULL, BBFDM_CWMP}, +{"PDVRange", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_PDVRange, NULL, BBFDM_CWMP}, +{"MinOnewayDelay", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_MinOnewayDelay, NULL, BBFDM_CWMP}, +{"ReorderedRatio", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_ReorderedRatio, NULL, BBFDM_CWMP}, +{"ReplicatedRatio", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_ReplicatedRatio, NULL, BBFDM_CWMP}, +{"InterfaceEthMbps", &DMREAD, DMT_STRING, get_IPLayerCapacityIncremental_InterfaceEthMbps, NULL, BBFDM_CWMP}, +{0} +}; + diff --git a/dmtree/tr471/iplayercap.h b/dmtree/tr471/iplayercap.h new file mode 100644 index 00000000..238196f1 --- /dev/null +++ b/dmtree/tr471/iplayercap.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2023 iopsys Software Solutions AB + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 + * as published by the Free Software Foundation + * + * Author: Suvendhu Hansa + * + */ + +#ifndef __IPLAYERCAP_H +#define __IPLAYERCAP_H + +#include "libbbf_api/dmcommon.h" + +extern DMOBJ tIPLayerCapacityObj[]; +extern DMLEAF tIPLayerCapacityParams[]; +extern DMLEAF tIPLayerCapacityModalResultParams[]; +extern DMLEAF tIPLayerCapacityIncrementalResultParams[]; + +int operate_IPDiagnostics_IPLayerCapacity(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action); +int get_operate_args_IPDiagnostics_IPLayerCapacity(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value); +int get_IPDiagnosticsIPLayerCapacity_SoftwareVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value); +int get_IPDiagnosticsIPLayerCapacity_MaxConnections(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value); +int get_IPDiagnosticsIPLayerCapacity_MaxIncrementalResult(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value); +int get_IPDiagnosticsIPLayerCapacity_ControlProtocolVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value); +int get_IPDiagnosticsIPLayerCapacity_SupportedMetrics(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value); + +#endif + diff --git a/libbbf_api/dmapi.h b/libbbf_api/dmapi.h index 0b82ec11..f505ec44 100644 --- a/libbbf_api/dmapi.h +++ b/libbbf_api/dmapi.h @@ -407,7 +407,8 @@ enum bbf_end_session_enum { BBF_END_SESSION_TRACEROUTE_DIAGNOSTIC = 1<<9, BBF_END_SESSION_UDPECHO_DIAGNOSTIC = 1<<10, BBF_END_SESSION_SERVERSELECTION_DIAGNOSTIC = 1<<11, - BBF_END_SESSION_NEIGBORING_WIFI_DIAGNOSTIC = 1<<12 + BBF_END_SESSION_NEIGBORING_WIFI_DIAGNOSTIC = 1<<12, + BBF_END_SESSION_IPLAYERCAPACITY_DIAGNOSTIC = 1<<21 }; enum dm_browse_enum { diff --git a/libbbf_api/dmcommon.c b/libbbf_api/dmcommon.c index b0f7d922..32c563ab 100644 --- a/libbbf_api/dmcommon.c +++ b/libbbf_api/dmcommon.c @@ -53,6 +53,10 @@ char *PowerState[] = {"On", "Power_Save", "Off", "Unsupported", NULL}; char *FW_Mode[] = {"AnyTime", "Immediately", "WhenIdle", "ConfirmationNeeded", NULL}; char *AKMsAllowed[] = {"psk", "dpp", "sae", "psk+sae", "dpp+sae", "dpp+psk+sae", "SuiteSelector", NULL}; char *CellularDataPreference[] = {"Excluded", "Should not use", "Should use", NULL}; +char *IPLayerCapacityRole[] = {"Receiver", "Sender", NULL}; +char *UDPPayloadContent[] = {"zeroes", "random", NULL}; +char *IPLayerCapacityTestType[] = {"Search", "Fixed", NULL}; +char *RateAdjAlgorithm[] = {"B", "C", NULL}; char *PIN[] = {"^\\d{4}|\\d{8}$", NULL}; char *DestinationAddress[] = {"^\\d+/\\d+$", NULL}; diff --git a/libbbf_api/dmcommon.h b/libbbf_api/dmcommon.h index 7d8e0537..8a4d596d 100644 --- a/libbbf_api/dmcommon.h +++ b/libbbf_api/dmcommon.h @@ -116,6 +116,10 @@ extern char *PowerState[]; extern char *FW_Mode[]; extern char *AKMsAllowed[]; extern char *CellularDataPreference[]; +extern char *IPLayerCapacityRole[]; +extern char *UDPPayloadContent[]; +extern char *IPLayerCapacityTestType[]; +extern char *RateAdjAlgorithm[]; #define CRONTABS_ROOT "/etc/crontabs/root" #define ACTIVATE_HANDLER_FILE "/usr/share/bbfdm/bbf_activate_handler.sh" diff --git a/scripts/iplayercap b/scripts/iplayercap new file mode 100644 index 00000000..9e4dc8c4 --- /dev/null +++ b/scripts/iplayercap @@ -0,0 +1,435 @@ +#!/bin/sh +# Copyright (C) 2023 iopsys Software Solutions AB +# Author: Suvendhu Hansa + +. /usr/share/libubox/jshn.sh + +ROOT="$(dirname $0)" +. ${ROOT}/bbf_api + +iplayercap_error() { + json_init + json_add_string "Status" "$1" + json_dump + + # Store data in dmmap + [ "$2" == "both_proto" ] && { + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.DiagnosticState="${1}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.SoftwareVersion="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.BOMTime="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.EOMTime="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TmaxUsed="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TestInterval="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TmaxRTTUsed="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TimestampResolutionUsed="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxIPLayerCapacity="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TimeOfMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxETHCapacityNoFCS="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxETHCapacityWithFCS="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxETHCapacityWithFCSVLAN="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.LossRatioAtMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.RTTRangeAtMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.PDVRangeAtMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MinOnewayDelayAtMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReorderedRatioAtMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReplicatedRatioAtMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.InterfaceEthMbpsAtMax="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.IPLayerCapacitySummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.LossRatioSummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.RTTRangeSummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.PDVRangeSummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MinOnewayDelaySummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MinRTTSummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReorderedRatioSummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReplicatedRatioSummary="" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.InterfaceEthMbpsSummary="" + + # Clear all incremental & modal result instances + res=$($UCI_SHOW_BBF_DMMAP dmmap_diagnostics | grep -E "=modalresult$" | cut -d= -f 1) + for i in $res; do + $UCI_DELETE_BBF_DMMAP "${i}" + done + + res=$($UCI_SHOW_BBF_DMMAP dmmap_diagnostics | grep -E "=incrementalresult$" | cut -d= -f 1) + for i in $res; do + $UCI_DELETE_BBF_DMMAP "${i}" + done + + $UCI_COMMIT_BBF_DMMAP + } +} + +iplayercap_launch() { + input="$1" + options="" + + json_load "${input}" + + json_get_var interface interface + json_get_var role role + json_get_var host host + json_get_var port port + json_get_var jumbo_frames jumbo_frames + json_get_var DSCP DSCP + json_get_var proto_ver proto_ver + json_get_var udp_content udp_content + json_get_var test_type test_type + json_get_var ipdv_enable ipdv_enable + json_get_var rate_index rate_index + json_get_var num_interval num_interval + json_get_var mode_subintervals mode_subintervals + json_get_var test_subinterval test_subinterval + json_get_var feedback_interval feedback_interval + json_get_var seq_err_thresh seq_err_thresh + json_get_var dup_ignore dup_ignore + json_get_var lower_thresh lower_thresh + json_get_var upper_thresh upper_thresh + json_get_var high_speed_delta high_speed_delta + json_get_var algorithm algorithm + json_get_var slow_adj_thresh slow_adj_thresh + json_get_var proto proto + + # Fail if host is empty + [ -z "${host}" ] && { + iplayercap_error "Error_Internal" "${proto}" + return + } + + # Assign default value + [ -z "${test_type}" ] && test_type="Search" + [ -z "${test_subinterval}" ] && test_subinterval=1000 + [ -z "${feedback_interval}" ] && feedback_interval=50 + [ -z "${seq_err_thresh}" ] && seq_err_thresh=10 + [ -z "${dup_ignore}" ] && dup_ignore=1 + [ -z "${lower_thresh}" ] && lower_thresh=30 + [ -z "${upper_thresh}" ] && upper_thresh=90 + [ -z "${high_speed_delta}" ] && high_speed_delta=10 + [ -z "${slow_adj_thresh}" ] && slow_adj_thresh=3 + [ -z "${num_interval}" ] && num_interval=10 + + if [ -z "${role}" ] || [ "${role}" == "Sender" ]; then + options="$options -u" + else + options="$options -d" + fi + + if [ -n "${jumbo_frames}" ] && [ "${jumbo_frames}" -eq 0 ]; then + options="$options -j" + fi + + if [ -n "${DSCP}" ] && [ ${DSCP} -gt 0 ]; then + options="$options -m $DSCP" + fi + + if [ "${proto_ver}" == "IPv4" ]; then + options="$options -4" + elif [ "${proto_ver}" == "IPv6" ]; then + options="$options -6" + fi + + if [ "${udp_content}" == "random" ]; then + options="$options -X" + fi + + if [ -n "${ipdb_enable}" ] && [ "${ipdv_enable}" -eq 1 ]; then + options="$options -o" + fi + + if [ -n "${rate_index}" ]; then + options="$options -I @${rate_index}" + fi + + if [ -n "${algorithm}" ]; then + options="$options -A ${algorithm}" + fi + + if [ -n "${interface}" ]; then + options="$options -E ${interface}" + fi + + if [ -n "${port}" ]; then + options="$options -p ${port}" + fi + + test_subinterval=$(( test_subinterval/1000 )) + t_val=$(( test_subinterval*num_interval )) + if [ "${t_val}" -lt 5 ] || [ "${t_val}" -gt 60 ]; then + iplayercap_error "Error_Internal" "${proto}" + return + fi + + if [ -n "${mode_subintervals}" ] && [ ${mode_subintervals} -gt 0 ]; then + if [ ${mode_subintervals} -lt ${num_interval} ]; then + options="$options -i ${mode_subintervals}" + else + iplayercap_error "Error_Internal" "${proto}" + return + fi + fi + + options="$options -P ${test_subinterval} -t ${t_val} -F ${feedback_interval}" + + if [ "${test_type}" == "Search" ]; then + options="$options -q ${seq_err_thresh} -L ${lower_thresh} -U ${upper_thresh} -h ${high_speed_delta} -c ${slow_adj_thresh}" + if [ "${dup_ignore}" -eq 0 ]; then + options="$options -R" + fi + fi + + output=$(udpst $options -f jsonf $host 2>&1) + if [ "$?" -eq 127 ] || [ "$?" -eq 255 ]; then + iplayercap_error "Error_Internal" "${proto}" + return + fi + + json_init + json_load "$output" + + [ "${proto}" == "both_proto" ] && { + json_get_var err ErrorStatus + if [ "${err}" -ne 0 ]; then + iplayercap_error "Error_Internal" "${proto}" + return + fi + + json_select IPLayerCapSupported + if [ "$?" -ne 0 ]; then + iplayercap_error "Error_Internal" "${proto}" + return + fi + + json_get_var version SoftwareVersion + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.SoftwareVersion="${version}" + json_select .. + + json_select Output + if [ "$?" -ne 0 ]; then + iplayercap_error "Error_Internal" "${proto}" + return + fi + + json_get_var Status Status + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.DiagnosticState="${Status}" + + json_get_var BOMTime BOMTime + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.BOMTime="${BOMTime}" + + json_get_var EOMTime EOMTime + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.EOMTime="${EOMTime}" + + json_get_var TmaxUsed TmaxUsed + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TmaxUsed="${TmaxUsed}" + + json_get_var TestInterval TestInterval + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TestInterval="${TestInterval}" + + json_get_var TmaxRTTUsed TmaxRTTUsed + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TmaxRTTUsed="${TmaxRTTUsed}" + + json_get_var TimestampResolutionUsed TimestampResolutionUsed + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TimestampResolutionUsed="${TimestampResolutionUsed}" + + json_select AtMax + if [ "$?" -ne 0 ]; then + iplayercap_error "Error_Internal" "${proto}" + return + fi + + json_get_var MaxIPLayerCapacity MaxIPLayerCapacity + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxIPLayerCapacity="${MaxIPLayerCapacity}" + + json_get_var TimeOfMax TimeOfMax + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.TimeOfMax="${TimeOfMax}" + + json_get_var MaxETHCapacityNoFCS MaxETHCapacityNoFCS + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxETHCapacityNoFCS="${MaxETHCapacityNoFCS}" + + json_get_var MaxETHCapacityWithFCS MaxETHCapacityWithFCS + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxETHCapacityWithFCS="${MaxETHCapacityWithFCS}" + + json_get_var MaxETHCapacityWithFCSVLAN MaxETHCapacityWithFCSVLAN + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MaxETHCapacityWithFCSVLAN="${MaxETHCapacityWithFCSVLAN}" + + json_get_var LossRatioAtMax LossRatioAtMax + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.LossRatioAtMax="${LossRatioAtMax}" + + json_get_var RTTRangeAtMax RTTRangeAtMax + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.RTTRangeAtMax="${RTTRangeAtMax}" + + json_get_var PDVRangeAtMax PDVRangeAtMax + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.PDVRangeAtMax="${PDVRangeAtMax}" + + json_get_var MinOnewayDelayAtMax MinOnewayDelayAtMax + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MinOnewayDelayAtMax="${MinOnewayDelayAtMax}" + + json_get_var ReorderedRatioAtMax ReorderedRatioAtMax + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReorderedRatioAtMax="${ReorderedRatioAtMax}" + + json_get_var ReplicatedRatioAtMax ReplicatedRatioAtMax + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReplicatedRatioAtMax="${ReplicatedRatioAtMax}" + + json_get_var InterfaceEthMbps InterfaceEthMbps + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.InterfaceEthMbpsAtMax="${InterfaceEthMbps}" + json_select .. + + json_select Summary + if [ "$?" -ne 0 ]; then + iplayercap_error "Error_Internal" "${proto}" + return + fi + + json_get_var IPLayerCapacitySummary IPLayerCapacitySummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.IPLayerCapacitySummary="${IPLayerCapacitySummary}" + + json_get_var LossRatioSummary LossRatioSummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.LossRatioSummary="${LossRatioSummary}" + + json_get_var RTTRangeSummary RTTRangeSummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.RTTRangeSummary="${RTTRangeSummary}" + + json_get_var PDVRangeSummary PDVRangeSummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.PDVRangeSummary="${PDVRangeSummary}" + + json_get_var MinOnewayDelaySummary MinOnewayDelaySummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MinOnewayDelaySummary="${MinOnewayDelaySummary}" + + json_get_var MinRTTSummary MinRTTSummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.MinRTTSummary="${MinRTTSummary}" + + json_get_var ReorderedRatioSummary ReorderedRatioSummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReorderedRatioSummary="${ReorderedRatioSummary}" + + json_get_var ReplicatedRatioSummary ReplicatedRatioSummary + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.ReplicatedRatioSummary="${ReplicatedRatioSummary}" + + json_get_var InterfaceEthMbps InterfaceEthMbps + $UCI_SET_BBF_DMMAP dmmap_diagnostics.iplayercapacity.InterfaceEthMbpsSummary="${InterfaceEthMbps}" + json_select .. + + # Clear all existing incremental & modal result instances + res=$($UCI_SHOW_BBF_DMMAP dmmap_diagnostics | grep -E "=modalresult$" | cut -d= -f 1) + for i in $res; do + $UCI_DELETE_BBF_DMMAP "${i}" + done + + res=$($UCI_SHOW_BBF_DMMAP dmmap_diagnostics | grep -E "=incrementalresult$" | cut -d= -f 1) + for i in $res; do + $UCI_DELETE_BBF_DMMAP "${i}" + done + + failed=0 + if json_is_a ModalResult array; then + json_select ModalResult + if [ "$?" -eq 0 ]; then + local idx=1 + local inst=0 + while json_is_a ${idx} object + do + json_select ${idx} + if ["$?" -ne 0 ]; then + iplayercap_error "Error_Internal" "${proto}" + failed=1 + break + fi + + json_get_var TimeOfMax TimeOfMax + json_get_var MaxIPLayerCapacity MaxIPLayerCapacity + json_get_var MaxETHCapacityNoFCS MaxETHCapacityNoFCS + json_get_var MaxETHCapacityWithFCS MaxETHCapacityWithFCS + json_get_var MaxETHCapacityWithFCSVLAN MaxETHCapacityWithFCSVLAN + json_get_var LossRatioAtMax LossRatioAtMax + json_get_var RTTRangeAtMax RTTRangeAtMax + json_get_var PDVRangeAtMax PDVRangeAtMax + json_get_var MinOnewayDelayAtMax MinOnewayDelayAtMax + json_get_var ReorderedRatioAtMax ReorderedRatioAtMax + json_get_var ReplicatedRatioAtMax ReplicatedRatioAtMax + json_get_var InterfaceEthMbps InterfaceEthMbps + + sec=$($UCI_ADD_BBF_DMMAP dmmap_diagnostics modalresult) + $UCI_RENAME_BBF_DMMAP dmmap_diagnostics.@modalresult[${inst}]="modalresult_${inst}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.MaxIPLayerCapacity="${MaxIPLayerCapacity}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.TimeOfMax="${TimeOfMax}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.MaxETHCapacityNoFCS="${MaxETHCapacityNoFCS}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.MaxETHCapacityWithFCS="${MaxETHCapacityWithFCS}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.MaxETHCapacityWithFCSVLAN="${MaxETHCapacityWithFCSVLAN}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.LossRatioAtMax="${LossRatioAtMax}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.RTTRangeAtMax="${RTTRangeAtMax}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.PDVRangeAtMax="${PDVRangeAtMax}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.MinOnewayDelayAtMax="${MinOnewayDelayAtMax}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.ReorderedRatioAtMax="${ReorderedRatioAtMax}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.ReplicatedRatioAtMax="${ReplicatedRatioAtMax}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.modalresult_${inst}.InterfaceEthMbpsAtMax="${InterfaceEthMbps}" + + idx=$(( idx + 1 )) + inst=$(( inst + 1)) + json_select .. + done + json_select .. + fi + fi + + if [ "${failed}" -eq 1 ]; then + return + fi + + if json_is_a IncrementalResult array; then + json_select IncrementalResult + if [ "$?" -eq 0 ]; then + local idx=1 + local inst=0 + while json_is_a ${idx} object + do + json_select ${idx} + if [ "$?" -ne 0 ]; then + iplayercap_error "Error_Internal" "${proto}" + failed=1 + break + fi + + json_get_var TimeOfSubInterval TimeOfSubInterval + json_get_var IPLayerCapacity IPLayerCapacity + json_get_var LossRatio LossRatio + json_get_var RTTRange RTTRange + json_get_var PDVRange PDVRange + json_get_var MinOnewayDelay MinOnewayDelay + json_get_var ReorderedRatio ReorderedRatio + json_get_var ReplicatedRatio ReplicatedRatio + json_get_var InterfaceEthMbps InterfaceEthMbps + + sec=$($UCI_ADD_BBF_DMMAP dmmap_diagnostics incrementalresult) + $UCI_RENAME_BBF_DMMAP dmmap_diagnostics.@incrementalresult[${inst}]="incrementalresult_${inst}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.IPLayerCapacity="${IPLayerCapacity}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.TimeOfSubInterval="${TimeOfSubInterval}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.LossRatio="${LossRatio}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.RTTRange="${RTTRange}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.PDVRange="${PDVRange}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.MinOnewayDelay="${MinOnewayDelay}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.ReorderedRatio="${ReorderedRatio}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.ReplicatedRatio="${ReplicatedRatio}" + $UCI_SET_BBF_DMMAP dmmap_diagnostics.incrementalresult_${inst}.InterfaceEthMbps="${InterfaceEthMbps}" + + idx=$(( idx + 1 )) + inst=$(( inst + 1)) + json_select .. + done + json_select .. + fi + fi + + if [ "${failed}" -eq 1 ]; then + return + fi + + $UCI_COMMIT_BBF_DMMAP + } + + json_dump +} + + +[ ! -f /etc/bbfdm/dmmap/dmmap_diagnostics ] && touch /etc/bbfdm/dmmap/dmmap_diagnostics +if [ -n "$1" ]; then + iplayercap_launch "$1" +else + iplayercap_error "Error_Internal" "${proto}" +fi