mirror/lwip
1
0
Fork 0
mirror of https://github.com/lwip-tcpip/lwip.git synced 2025-01-27 03:35:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

minor: coding style cleanup in snmp code

Browse Source
This commit is contained in:
goldsimon 2016-06-09 14:28:04 +02:00
parent 010b0e2972
commit 076f1ee89e
7 changed files with 146 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/apps/snmp/snmp_asn1.c
View File

@ -100,8 +100,7 @@ snmp_ans1_enc_tlv(struct snmp_pbuf_stream* pbuf_stream, struct snmp_asn1_tlv* tl
PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, data));
while (length_bytes_required > 1)
{
while (length_bytes_required > 1) {
if (length_bytes_required == 2) {
/* append high byte */
data = (u8_t)(tlv->value_len >> 8);
@ -344,8 +343,7 @@ void
snmp_asn1_enc_u64t_cnt(const u32_t *value, u16_t *octets_needed)
{
/* check if high u32 is 0 */
if (*value == 0x00)
{
if (*value == 0x00) {
/* only low u32 is important */
value++;
snmp_asn1_enc_u32t_cnt(*value, octets_needed);
@ -496,8 +494,7 @@ snmp_asn1_dec_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *value
*value = data;
len--;
while (len > 0)
{
while (len > 0) {
PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data));
len--;
@ -544,8 +541,7 @@ snmp_asn1_dec_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *value
*value = data;
len--;
while (len > 0)
{
while (len > 0) {
PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data));
if (len == 4) {

173
src/apps/snmp/snmp_core.c
View File

@ -382,12 +382,10 @@ snmp_oid_prefix(struct snmp_obj_id* target, const u32_t *oid, u8_t oid_len)
{
LWIP_ASSERT("target->len + oid_len <= LWIP_SNMP_OBJ_ID_LEN", (target->len + oid_len) <= SNMP_MAX_OBJ_ID_LEN);
if (oid_len > 0)
{
if (oid_len > 0) {
/* move existing OID to make room at the beginning for OID to insert */
int i;
for (i = target->len-1; i>=0; i--)
{
for (i = target->len-1; i>=0; i--) {
target->id[i + oid_len] = target->id[i];
}
@ -421,14 +419,11 @@ snmp_oid_compare(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_
LWIP_ASSERT("'oid1' param must not be NULL or 'oid1_len' param be 0!", (oid1 != NULL) || (oid1_len == 0));
LWIP_ASSERT("'oid2' param must not be NULL or 'oid2_len' param be 0!", (oid2 != NULL) || (oid2_len == 0));
while ((level < oid1_len) && (level < oid2_len))
{
if (*oid1 < *oid2)
{
while ((level < oid1_len) && (level < oid2_len)) {
if (*oid1 < *oid2) {
return -1;
}
if (*oid1 > *oid2)
{
if (*oid1 > *oid2) {
return 1;
}
@ -438,12 +433,10 @@ snmp_oid_compare(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_
}
/* common part of both OID's is equal, compare length */
if (oid1_len < oid2_len)
{
if (oid1_len < oid2_len) {
return -1;
}
if (oid1_len > oid2_len)
{
if (oid1_len > oid2_len) {
return 1;
}
@ -493,21 +486,17 @@ snmp_get_mib_from_oid(const u32_t *oid, u8_t oid_len)
return NULL;
}
for (i=0; i<snmp_num_mibs; i++)
{
for (i = 0; i < snmp_num_mibs; i++) {
LWIP_ASSERT("MIB array not initialized correctly", (snmp_mibs[i] != NULL));
LWIP_ASSERT("MIB array not initialized correctly - base OID is NULL", (snmp_mibs[i]->base_oid != NULL));
if (oid_len >= snmp_mibs[i]->base_oid_len)
{
if (oid_len >= snmp_mibs[i]->base_oid_len) {
l = snmp_mibs[i]->base_oid_len;
list_oid = snmp_mibs[i]->base_oid;
searched_oid = oid;
while (l > 0)
{
if (*list_oid != *searched_oid)
{
while (l > 0) {
if (*list_oid != *searched_oid) {
break;
}
@ -516,8 +505,7 @@ snmp_get_mib_from_oid(const u32_t *oid, u8_t oid_len)
searched_oid++;
}
if ((l == 0) && (snmp_mibs[i]->base_oid_len > max_match_len))
{
if ((l == 0) && (snmp_mibs[i]->base_oid_len > max_match_len)) {
max_match_len = snmp_mibs[i]->base_oid_len;
matched_mib = snmp_mibs[i];
}
@ -539,15 +527,13 @@ snmp_get_next_mib(const u32_t *oid, u8_t oid_len)
return NULL;
}
for (i=0; i<snmp_num_mibs; i++)
{
if (snmp_mibs[i]->base_oid != NULL)
{
for (i = 0; i < snmp_num_mibs; i++) {
if (snmp_mibs[i]->base_oid != NULL) {
/* check if mib is located behind starting point */
if (snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len, oid, oid_len) > 0)
{
if ((next_mib == NULL) || (snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len, next_mib->base_oid, next_mib->base_oid_len) < 0))
{
if (snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len, oid, oid_len) > 0) {
if ((next_mib == NULL) ||
(snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len,
next_mib->base_oid, next_mib->base_oid_len) < 0)) {
next_mib = snmp_mibs[i];
}
}
@ -565,10 +551,8 @@ snmp_get_mib_between(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t o
LWIP_ASSERT("'oid2' param must not be NULL!", (oid2 != NULL));
LWIP_ASSERT("'oid2_len' param must be greater than 0!", (oid2_len > 0));
if (next_mib != NULL)
{
if (snmp_oid_compare(next_mib->base_oid, next_mib->base_oid_len, oid2, oid2_len) < 0)
{
if (next_mib != NULL) {
if (snmp_oid_compare(next_mib->base_oid, next_mib->base_oid_len, oid2, oid2_len) < 0) {
return next_mib;
}
}
@ -656,8 +640,7 @@ snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_valida
/* validate the node; if the node has no further instance or the returned instance is invalid, search for the next in MIB and validate again */
node_instance->node = mn;
while (mn != NULL)
{
while (mn != NULL) {
u8_t result;
/* clear fields which may have values from previous loops */
@ -675,8 +658,7 @@ snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_valida
node_oid->len,
node_instance);
if (result == SNMP_ERR_NOERROR)
{
if (result == SNMP_ERR_NOERROR) {
#ifdef LWIP_DEBUG
if(((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_READ) != 0) && (node_instance->get_value == NULL)) {
LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is readable but no get_value function is specified\n"));
@ -687,8 +669,8 @@ snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_valida
#endif
/* validate node because the node may be not accessible for example (but let the caller decide what is valid */
if ((validate_node_instance_method == NULL) || (validate_node_instance_method(node_instance, validate_node_instance_arg) == SNMP_ERR_NOERROR))
{
if ((validate_node_instance_method == NULL) ||
(validate_node_instance_method(node_instance, validate_node_instance_arg) == SNMP_ERR_NOERROR)) {
/* node_oid "returns" the full result OID (including the instance part) */
snmp_oid_append(node_oid, node_instance->instance_oid.id, node_instance->instance_oid.len);
break;
@ -702,17 +684,14 @@ snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_valida
we don't have to change any variables because node_instance->instance_oid is used as input (starting point)
as well as output (resulting next OID), so we have to simply call get_next_instance method again
*/
}
else
{
} else {
if (node_instance->release_instance != NULL) {
node_instance->release_instance(node_instance);
}
/* the node has no further instance, skip to next node */
mn = snmp_mib_tree_resolve_next(mib, node_oid->id, node_oid->len, &node_instance->instance_oid); /* misuse node_instance->instance_oid as tmp buffer */
if (mn != NULL)
{
if (mn != NULL) {
/* prepare for next loop */
snmp_oid_assign(node_oid, node_instance->instance_oid.id, node_instance->instance_oid.len);
node_instance->instance_oid.len = 0;
@ -781,8 +760,7 @@ snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_valida
}
}
if (mib == NULL)
{
if (mib == NULL) {
/* loop is only left when mib == null (error) or mib_node != NULL (success) */
return SNMP_ERR_ENDOFMIBVIEW;
}
@ -800,21 +778,18 @@ snmp_mib_tree_resolve_exact(const struct snmp_mib *mib, const u32_t *oid, u8_t o
const struct snmp_node* const* node = &mib->root_node;
u8_t oid_offset = mib->base_oid_len;
while ((oid_offset < oid_len) && ((*node)->node_type == SNMP_NODE_TREE))
{
while ((oid_offset < oid_len) && ((*node)->node_type == SNMP_NODE_TREE)) {
/* search for matching sub node */
u32_t subnode_oid = *(oid + oid_offset);
u32_t i = (*(const struct snmp_tree_node* const*)node)->subnode_count;
node = (*(const struct snmp_tree_node* const*)node)->subnodes;
while ((i > 0) && ((*node)->oid != subnode_oid))
{
while ((i > 0) && ((*node)->oid != subnode_oid)) {
node++;
i--;
}
if (i == 0)
{
if (i == 0) {
/* no matching subnode found */
return NULL;
}
@ -822,8 +797,7 @@ snmp_mib_tree_resolve_exact(const struct snmp_mib *mib, const u32_t *oid, u8_t o
oid_offset++;
}
if ((*node)->node_type != SNMP_NODE_TREE)
{
if ((*node)->node_type != SNMP_NODE_TREE) {
/* we found a leaf node */
*oid_instance_len = oid_len - oid_offset;
return (*node);
@ -841,30 +815,26 @@ snmp_mib_tree_resolve_next(const struct snmp_mib *mib, const u32_t *oid, u8_t oi
s32_t nsi = 0; /* NodeStackIndex */
u32_t subnode_oid;
if (mib->root_node->node_type != SNMP_NODE_TREE)
{
if (mib->root_node->node_type != SNMP_NODE_TREE) {
/* a next operation on a mib with only a leaf node will always return NULL because there is no other node */
return NULL;
}
/* first build node stack related to passed oid (as far as possible), then go backwards to determine the next node */
node_stack[nsi] = (const struct snmp_tree_node*)mib->root_node;
while (oid_offset < oid_len)
{
while (oid_offset < oid_len) {
/* search for matching sub node */
u32_t i = node_stack[nsi]->subnode_count;
node = node_stack[nsi]->subnodes;
subnode_oid = *(oid + oid_offset);
while ((i > 0) && ((*node)->oid != subnode_oid))
{
while ((i > 0) && ((*node)->oid != subnode_oid)) {
node++;
i--;
}
if ((i == 0) || ((*node)->node_type != SNMP_NODE_TREE))
{
if ((i == 0) || ((*node)->node_type != SNMP_NODE_TREE)) {
/* no (matching) tree-subnode found */
break;
}
@ -875,32 +845,24 @@ snmp_mib_tree_resolve_next(const struct snmp_mib *mib, const u32_t *oid, u8_t oi
}
if (oid_offset >= oid_len)
{
if (oid_offset >= oid_len) {
/* passed oid references a tree node -> return first useable sub node of it */
subnode_oid = 0;
}
else
{
} else {
subnode_oid = *(oid + oid_offset) + 1;
}
while (nsi >= 0)
{
while (nsi >= 0) {
const struct snmp_node* subnode = NULL;
/* find next node on current level */
s32_t i = node_stack[nsi]->subnode_count;
node = node_stack[nsi]->subnodes;
while (i > 0)
{
if ((*node)->oid == subnode_oid)
{
while (i > 0) {
if ((*node)->oid == subnode_oid) {
subnode = *node;
break;
}
else if (((*node)->oid > subnode_oid) && ((subnode == NULL) || ((*node)->oid < subnode->oid)))
{
} else if (((*node)->oid > subnode_oid) && ((subnode == NULL) || ((*node)->oid < subnode->oid))) {
subnode = *node;
}
@ -908,28 +870,21 @@ snmp_mib_tree_resolve_next(const struct snmp_mib *mib, const u32_t *oid, u8_t oi
i--;
}
if (subnode == NULL)
{
if (subnode == NULL) {
/* no further node found on this level, go one level up and start searching with index of current node*/
subnode_oid = node_stack[nsi]->node.oid + 1;
nsi--;
}
else
{
if (subnode->node_type == SNMP_NODE_TREE)
{
} else {
if (subnode->node_type == SNMP_NODE_TREE) {
/* next is a tree node, go into it and start searching */
nsi++;
node_stack[nsi] = (const struct snmp_tree_node*)subnode;
subnode_oid = 0;
}
else
{
} else {
/* we found a leaf node -> fill oidret and return it */
snmp_oid_assign(oidret, mib->base_oid, mib->base_oid_len);
i = 1;
while (i <= nsi)
{
while (i <= nsi) {
oidret->id[oidret->len] = node_stack[i]->node.oid;
oidret->len++;
i++;
@ -962,17 +917,14 @@ snmp_next_oid_init(struct snmp_next_oid_state *state,
u8_t
snmp_next_oid_precheck(struct snmp_next_oid_state *state, const u32_t *oid, const u8_t oid_len)
{
if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL)
{
if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL) {
u8_t start_oid_len = (oid_len < state->start_oid_len) ? oid_len : state->start_oid_len;
/* check passed OID is located behind start offset */
if (snmp_oid_compare(oid, oid_len, state->start_oid, start_oid_len) >= 0)
{
if (snmp_oid_compare(oid, oid_len, state->start_oid, start_oid_len) >= 0) {
/* check if new oid is located closer to start oid than current closest oid */
if ((state->status == SNMP_NEXT_OID_STATUS_NO_MATCH) ||
(snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0))
{
(snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0)) {
return 1;
}
}
@ -985,25 +937,19 @@ u8_t
snmp_next_oid_check(struct snmp_next_oid_state *state, const u32_t *oid, const u8_t oid_len, void* reference)
{
/* do not overwrite a fail result */
if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL)
{
if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL) {
/* check passed OID is located behind start offset */
if (snmp_oid_compare(oid, oid_len, state->start_oid, state->start_oid_len) > 0)
{
if (snmp_oid_compare(oid, oid_len, state->start_oid, state->start_oid_len) > 0) {
/* check if new oid is located closer to start oid than current closest oid */
if ((state->status == SNMP_NEXT_OID_STATUS_NO_MATCH) ||
(snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0))
{
if (oid_len <= state->next_oid_max_len)
{
(snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0)) {
if (oid_len <= state->next_oid_max_len) {
MEMCPY(state->next_oid, oid, oid_len * sizeof(u32_t));
state->next_oid_len = oid_len;
state->status = SNMP_NEXT_OID_STATUS_SUCCESS;
state->reference = reference;
return 1;
}
else
{
} else {
state->status = SNMP_NEXT_OID_STATUS_BUF_TO_SMALL;
}
}
@ -1022,9 +968,8 @@ snmp_oid_in_range(const u32_t *oid_in, u8_t oid_len, const struct snmp_oid_range
return 0;
}
for(i=0; i<oid_ranges_len; i++)
{
if((oid_in[i] < oid_ranges[i].min) || (oid_in[i] > oid_ranges[i].max)) {
for(i = 0; i < oid_ranges_len; i++) {
if ((oid_in[i] < oid_ranges[i].min) || (oid_in[i] > oid_ranges[i].max)) {
return 0;
}
}
@ -1155,13 +1100,11 @@ snmp_encode_bits(u8_t *buf, u32_t buf_len, u32_t bit_value, u8_t bit_count)
len++;
}
if (len < min_bytes)
{
if (len < min_bytes) {
buf += len;
buf_len -= len;
while ((len < min_bytes) && (buf_len > 0))
{
while ((len < min_bytes) && (buf_len > 0)) {
*buf = 0x00;
buf++;
buf_len--;

12
src/apps/snmp/snmp_msg.c
View File

@ -1308,25 +1308,29 @@ snmp_complete_outbound_frame(struct snmp_request *request)
case SNMP_ERR_NOSUCHINSTANCE:
case SNMP_ERR_NOSUCHOBJECT:
case SNMP_ERR_ENDOFMIBVIEW:
request->error_status = SNMP_ERR_NOSUCHNAME; break;
request->error_status = SNMP_ERR_NOSUCHNAME;
break;
/* mapping according to RFC */
case SNMP_ERR_WRONGVALUE:
case SNMP_ERR_WRONGENCODING:
case SNMP_ERR_WRONGTYPE:
case SNMP_ERR_WRONGLENGTH:
case SNMP_ERR_INCONSISTENTVALUE:
request->error_status = SNMP_ERR_BADVALUE; break;
request->error_status = SNMP_ERR_BADVALUE;
break;
case SNMP_ERR_NOACCESS:
case SNMP_ERR_NOTWRITABLE:
case SNMP_ERR_NOCREATION:
case SNMP_ERR_INCONSISTENTNAME:
case SNMP_ERR_AUTHORIZATIONERROR:
request->error_status = SNMP_ERR_NOSUCHNAME; break;
request->error_status = SNMP_ERR_NOSUCHNAME;
break;
case SNMP_ERR_RESOURCEUNAVAILABLE:
case SNMP_ERR_COMMITFAILED:
case SNMP_ERR_UNDOFAILED:
default:
request->error_status = SNMP_ERR_GENERROR; break;
request->error_status = SNMP_ERR_GENERROR;
break;
}
}
} else {

53
src/apps/snmp/snmp_scalar.c
View File

@ -55,8 +55,7 @@ snmp_scalar_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_n
LWIP_UNUSED_ARG(root_oid_len);
/* scalar only has one dedicated instance: .0 */
if ((instance->instance_oid.len != 1) || (instance->instance_oid.id[0] != 0))
{
if ((instance->instance_oid.len != 1) || (instance->instance_oid.id[0] != 0)) {
return SNMP_ERR_NOSUCHINSTANCE;
}
@ -72,8 +71,7 @@ snmp_err_t
snmp_scalar_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance)
{
/* because our only instance is .0 we can only return a next instance if no instance oid is passed */
if (instance->instance_oid.len == 0)
{
if (instance->instance_oid.len == 0) {
instance->instance_oid.len = 1;
instance->instance_oid.id[0] = 0;
@ -90,16 +88,13 @@ snmp_scalar_array_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct
LWIP_UNUSED_ARG(root_oid);
LWIP_UNUSED_ARG(root_oid_len);
if ((instance->instance_oid.len == 2) && (instance->instance_oid.id[1] == 0))
{
if ((instance->instance_oid.len == 2) && (instance->instance_oid.id[1] == 0)) {
const struct snmp_scalar_array_node* array_node = (const struct snmp_scalar_array_node*)instance->node;
const struct snmp_scalar_array_node_def* array_node_def = array_node->array_nodes;
u32_t i = 0;
while (i < array_node->array_node_count)
{
if (array_node_def->oid == instance->instance_oid.id[0])
{
while (i < array_node->array_node_count) {
if (array_node_def->oid == instance->instance_oid.id[0]) {
break;
}
@ -107,8 +102,7 @@ snmp_scalar_array_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct
i++;
}
if (i < array_node->array_node_count)
{
if (i < array_node->array_node_count) {
instance->access = array_node_def->access;
instance->asn1_type = array_node_def->asn1_type;
instance->get_value = snmp_scalar_array_get_value;
@ -133,33 +127,25 @@ snmp_scalar_array_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, st
LWIP_UNUSED_ARG(root_oid);
LWIP_UNUSED_ARG(root_oid_len);
if ((instance->instance_oid.len == 0) && (array_node->array_node_count > 0))
{
if ((instance->instance_oid.len == 0) && (array_node->array_node_count > 0)) {
/* return node with lowest OID */
u16_t i = 0;
result = array_node_def;
array_node_def++;
for (i = 1; i < array_node->array_node_count; i++)
{
if (array_node_def->oid < result->oid)
{
for (i = 1; i < array_node->array_node_count; i++) {
if (array_node_def->oid < result->oid) {
result = array_node_def;
}
array_node_def++;
}
}
else if (instance->instance_oid.len >= 1)
{
if (instance->instance_oid.len == 1)
{
} else if (instance->instance_oid.len >= 1) {
if (instance->instance_oid.len == 1) {
/* if we have the requested OID we return its instance, otherwise we search for the next available */
u16_t i = 0;
while (i < array_node->array_node_count)
{
if (array_node_def->oid == instance->instance_oid.id[0])
{
while (i < array_node->array_node_count) {
if (array_node_def->oid == instance->instance_oid.id[0]) {
result = array_node_def;
break;
}
@ -168,15 +154,13 @@ snmp_scalar_array_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, st
i++;
}
}
if (result == NULL)
{
if (result == NULL) {
u32_t oid_dist = 0xFFFFFFFFUL;
u16_t i = 0;
array_node_def = array_node->array_nodes; /* may be already at the end when if case before was executed without result -> reinitialize to start */
while (i < array_node->array_node_count)
{
if ((array_node_def->oid > instance->instance_oid.id[0]) && ((u32_t)(array_node_def->oid - instance->instance_oid.id[0]) < oid_dist))
{
while (i < array_node->array_node_count) {
if ((array_node_def->oid > instance->instance_oid.id[0]) &&
((u32_t)(array_node_def->oid - instance->instance_oid.id[0]) < oid_dist)) {
result = array_node_def;
oid_dist = array_node_def->oid - instance->instance_oid.id[0];
}
@ -187,8 +171,7 @@ snmp_scalar_array_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, st
}
}
if (result == NULL)
{
if (result == NULL) {
/* nothing to return */
return SNMP_ERR_NOSUCHINSTANCE;
}

129
src/apps/snmp/snmp_table.c
View File

@ -53,15 +53,12 @@ snmp_err_t snmp_table_get_instance(const u32_t *root_oid, u8_t root_oid_len, str
/* check min. length (fixed row entry definition, column, row instance oid with at least one entry */
/* fixed row entry always has oid 1 */
if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1))
{
if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) {
/* search column */
const struct snmp_table_col_def* col_def = table_node->columns;
u16_t i = table_node->column_count;
while (i > 0)
{
if (col_def->index == instance->instance_oid.id[1])
{
while (i > 0) {
if (col_def->index == instance->instance_oid.id[1]) {
break;
}
@ -69,8 +66,7 @@ snmp_err_t snmp_table_get_instance(const u32_t *root_oid, u8_t root_oid_len, str
i--;
}
if (i > 0)
{
if (i > 0) {
/* everything may be overwritten by get_cell_instance_method() in order to implement special handling for single columns/cells */
instance->asn1_type = col_def->asn1_type;
instance->access = col_def->access;
@ -101,20 +97,15 @@ snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len
LWIP_UNUSED_ARG(root_oid_len);
/* check that first part of id is 0 or 1, referencing fixed row entry */
if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1))
{
if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) {
return SNMP_ERR_NOSUCHINSTANCE;
}
if (instance->instance_oid.len > 1)
{
if (instance->instance_oid.len > 1) {
column = instance->instance_oid.id[1];
}
if (instance->instance_oid.len > 2)
{
if (instance->instance_oid.len > 2) {
snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2);
}
else
{
} else {
row_oid.len = 0;
}
@ -123,28 +114,22 @@ snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len
instance->set_value = table_node->set_value;
/* resolve column and value */
do
{
do {
u16_t i;
const struct snmp_table_col_def* next_col_def = NULL;
col_def = table_node->columns;
for (i=0; i<table_node->column_count; i++)
{
if (col_def->index == column)
{
for (i = 0; i < table_node->column_count; i++) {
if (col_def->index == column) {
next_col_def = col_def;
break;
}
else if ((col_def->index > column) && ((next_col_def == NULL) || (col_def->index < next_col_def->index)))
{
} else if ((col_def->index > column) && ((next_col_def == NULL) || (col_def->index < next_col_def->index))) {
next_col_def = col_def;
}
col_def++;
}
if (next_col_def == NULL)
{
if (next_col_def == NULL) {
/* no further column found */
return SNMP_ERR_NOSUCHINSTANCE;
}
@ -157,16 +142,14 @@ snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len
&row_oid,
instance);
if (result == SNMP_ERR_NOERROR)
{
if (result == SNMP_ERR_NOERROR) {
col_def = next_col_def;
break;
}
row_oid.len = 0; /* reset row_oid because we switch to next column and start with the first entry there */
column = next_col_def->index + 1;
}
while (1);
} while (1);
/* build resulting oid */
instance->instance_oid.len = 2;
@ -188,8 +171,7 @@ snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_l
/* check min. length (fixed row entry definition, column, row instance oid with at least one entry */
/* fixed row entry always has oid 1 */
if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1))
{
if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) {
ret = table_node->get_cell_value(
&(instance->instance_oid.id[1]),
&(instance->instance_oid.id[2]),
@ -197,15 +179,12 @@ snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_l
&instance->reference,
&instance->reference_len);
if (ret == SNMP_ERR_NOERROR)
{
if (ret == SNMP_ERR_NOERROR) {
/* search column */
const struct snmp_table_simple_col_def* col_def = table_node->columns;
u32_t i = table_node->column_count;
while (i > 0)
{
if (col_def->index == instance->instance_oid.id[1])
{
while (i > 0) {
if (col_def->index == instance->instance_oid.id[1]) {
break;
}
@ -213,28 +192,30 @@ snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_l
i--;
}
if (i > 0)
{
if (i > 0) {
instance->asn1_type = col_def->asn1_type;
instance->access = SNMP_NODE_INSTANCE_READ_ONLY;
instance->set_test = NULL;
instance->set_value = NULL;
switch (col_def->data_type)
{
case SNMP_VARIANT_VALUE_TYPE_U32: instance->get_value = snmp_table_extract_value_from_u32ref; break;
case SNMP_VARIANT_VALUE_TYPE_S32: instance->get_value = snmp_table_extract_value_from_s32ref; break;
switch (col_def->data_type) {
case SNMP_VARIANT_VALUE_TYPE_U32:
instance->get_value = snmp_table_extract_value_from_u32ref;
break;
case SNMP_VARIANT_VALUE_TYPE_S32:
instance->get_value = snmp_table_extract_value_from_s32ref;
break;
case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */
case SNMP_VARIANT_VALUE_TYPE_CONST_PTR: instance->get_value = snmp_table_extract_value_from_refconstptr; break;
case SNMP_VARIANT_VALUE_TYPE_CONST_PTR:
instance->get_value = snmp_table_extract_value_from_refconstptr;
break;
default:
LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type));
return SNMP_ERR_GENERROR;
}
ret = SNMP_ERR_NOERROR;
}
else
{
} else {
ret = SNMP_ERR_NOSUCHINSTANCE;
}
}
@ -255,46 +236,36 @@ snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_
LWIP_UNUSED_ARG(root_oid_len);
/* check that first part of id is 0 or 1, referencing fixed row entry */
if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1))
{
if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) {
return SNMP_ERR_NOSUCHINSTANCE;
}
if (instance->instance_oid.len > 1)
{
if (instance->instance_oid.len > 1) {
column = instance->instance_oid.id[1];
}
if (instance->instance_oid.len > 2)
{
if (instance->instance_oid.len > 2) {
snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2);
}
else
{
} else {
row_oid.len = 0;
}
/* resolve column and value */
do
{
do {
u32_t i;
const struct snmp_table_simple_col_def* next_col_def = NULL;
col_def = table_node->columns;
for (i=0; i<table_node->column_count; i++)
{
if (col_def->index == column)
{
for (i = 0; i < table_node->column_count; i++) {
if (col_def->index == column) {
next_col_def = col_def;
break;
}
else if ((col_def->index > column) && ((next_col_def == NULL) || (col_def->index < next_col_def->index)))
{
} else if ((col_def->index > column) && ((next_col_def == NULL) ||
(col_def->index < next_col_def->index))) {
next_col_def = col_def;
}
col_def++;
}
if (next_col_def == NULL)
{
if (next_col_def == NULL) {
/* no further column found */
return SNMP_ERR_NOSUCHINSTANCE;
}
@ -305,8 +276,7 @@ snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_
&instance->reference,
&instance->reference_len);
if (result == SNMP_ERR_NOERROR)
{
if (result == SNMP_ERR_NOERROR) {
col_def = next_col_def;
break;
}
@ -321,12 +291,17 @@ snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_
instance->set_test = NULL;
instance->set_value = NULL;
switch (col_def->data_type)
{
case SNMP_VARIANT_VALUE_TYPE_U32: instance->get_value = snmp_table_extract_value_from_u32ref; break;
case SNMP_VARIANT_VALUE_TYPE_S32: instance->get_value = snmp_table_extract_value_from_s32ref; break;
switch (col_def->data_type) {
case SNMP_VARIANT_VALUE_TYPE_U32:
instance->get_value = snmp_table_extract_value_from_u32ref;
break;
case SNMP_VARIANT_VALUE_TYPE_S32:
instance->get_value = snmp_table_extract_value_from_s32ref;
break;
case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */
case SNMP_VARIANT_VALUE_TYPE_CONST_PTR: instance->get_value = snmp_table_extract_value_from_refconstptr; break;
case SNMP_VARIANT_VALUE_TYPE_CONST_PTR:
instance->get_value = snmp_table_extract_value_from_refconstptr;
break;
default:
LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type));
return SNMP_ERR_GENERROR;

4
src/apps/snmp/snmp_threadsync.c
View File

@ -59,6 +59,7 @@ threadsync_get_value_synced(void *ctx)
sys_sem_signal(&call_data->threadsync_node->instance->sem);
}
static u16_t
threadsync_get_value(struct snmp_node_instance* instance, void* value)
{
@ -79,6 +80,7 @@ threadsync_set_test_synced(void *ctx)
sys_sem_signal(&call_data->threadsync_node->instance->sem);
}
static snmp_err_t
threadsync_set_test(struct snmp_node_instance* instance, u16_t len, void *value)
{
@ -100,6 +102,7 @@ threadsync_set_value_synced(void *ctx)
sys_sem_signal(&call_data->threadsync_node->instance->sem);
}
static snmp_err_t
threadsync_set_value(struct snmp_node_instance* instance, u16_t len, void *value)
{
@ -121,6 +124,7 @@ threadsync_release_instance_synced(void* ctx)
sys_sem_signal(&call_data->threadsync_node->instance->sem);
}
static void
threadsync_release_instance(struct snmp_node_instance *instance)
{

3
src/apps/snmp/snmpv3.c
View File

@ -119,8 +119,9 @@ snmpv3_build_priv_param(u8_t* priv_param)
/* Emulate 64bit increment */
priv1++;
if (!priv1) /* Overflow */
if (!priv1) { /* Overflow */
priv2++;
}
#else /* Based on RFC3414 */
static u32_t ctr;
u32_t boots = LWIP_SNMPV3_GET_ENGINE_BOOTS();