1 | /**
|
---|
2 | * @file
|
---|
3 | * SNMP table support implementation.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
|
---|
8 | * All rights reserved.
|
---|
9 | *
|
---|
10 | * Redistribution and use in source and binary forms, with or without modification,
|
---|
11 | * are permitted provided that the following conditions are met:
|
---|
12 | *
|
---|
13 | * 1. Redistributions of source code must retain the above copyright notice,
|
---|
14 | * this list of conditions and the following disclaimer.
|
---|
15 | * 2. Redistributions in binary form must reproduce the above copyright notice,
|
---|
16 | * this list of conditions and the following disclaimer in the documentation
|
---|
17 | * and/or other materials provided with the distribution.
|
---|
18 | * 3. The name of the author may not be used to endorse or promote products
|
---|
19 | * derived from this software without specific prior written permission.
|
---|
20 | *
|
---|
21 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
---|
22 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
---|
23 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
---|
24 | * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
---|
25 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
---|
26 | * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
---|
27 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
---|
28 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
---|
29 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
---|
30 | * OF SUCH DAMAGE.
|
---|
31 | *
|
---|
32 | * This file is part of the lwIP TCP/IP stack.
|
---|
33 | *
|
---|
34 | * Author: Martin Hentschel <info@cl-soft.de>
|
---|
35 | *
|
---|
36 | */
|
---|
37 |
|
---|
38 | #include "lwip/apps/snmp_opts.h"
|
---|
39 |
|
---|
40 | #if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */
|
---|
41 |
|
---|
42 | #include "lwip/apps/snmp_core.h"
|
---|
43 | #include "lwip/apps/snmp_table.h"
|
---|
44 | #include <string.h>
|
---|
45 |
|
---|
46 | snmp_err_t snmp_table_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance)
|
---|
47 | {
|
---|
48 | snmp_err_t ret = SNMP_ERR_NOSUCHINSTANCE;
|
---|
49 | const struct snmp_table_node *table_node = (const struct snmp_table_node *)(const void *)instance->node;
|
---|
50 |
|
---|
51 | LWIP_UNUSED_ARG(root_oid);
|
---|
52 | LWIP_UNUSED_ARG(root_oid_len);
|
---|
53 |
|
---|
54 | /* check min. length (fixed row entry definition, column, row instance oid with at least one entry */
|
---|
55 | /* fixed row entry always has oid 1 */
|
---|
56 | if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) {
|
---|
57 | /* search column */
|
---|
58 | const struct snmp_table_col_def *col_def = table_node->columns;
|
---|
59 | u16_t i = table_node->column_count;
|
---|
60 | while (i > 0) {
|
---|
61 | if (col_def->index == instance->instance_oid.id[1]) {
|
---|
62 | break;
|
---|
63 | }
|
---|
64 |
|
---|
65 | col_def++;
|
---|
66 | i--;
|
---|
67 | }
|
---|
68 |
|
---|
69 | if (i > 0) {
|
---|
70 | /* everything may be overwritten by get_cell_instance_method() in order to implement special handling for single columns/cells */
|
---|
71 | instance->asn1_type = col_def->asn1_type;
|
---|
72 | instance->access = col_def->access;
|
---|
73 | instance->get_value = table_node->get_value;
|
---|
74 | instance->set_test = table_node->set_test;
|
---|
75 | instance->set_value = table_node->set_value;
|
---|
76 |
|
---|
77 | ret = table_node->get_cell_instance(
|
---|
78 | &(instance->instance_oid.id[1]),
|
---|
79 | &(instance->instance_oid.id[2]),
|
---|
80 | instance->instance_oid.len - 2,
|
---|
81 | instance);
|
---|
82 | }
|
---|
83 | }
|
---|
84 |
|
---|
85 | return ret;
|
---|
86 | }
|
---|
87 |
|
---|
88 | snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance)
|
---|
89 | {
|
---|
90 | const struct snmp_table_node *table_node = (const struct snmp_table_node *)(const void *)instance->node;
|
---|
91 | const struct snmp_table_col_def *col_def;
|
---|
92 | struct snmp_obj_id row_oid;
|
---|
93 | u32_t column = 0;
|
---|
94 | snmp_err_t result;
|
---|
95 |
|
---|
96 | LWIP_UNUSED_ARG(root_oid);
|
---|
97 | LWIP_UNUSED_ARG(root_oid_len);
|
---|
98 |
|
---|
99 | /* check that first part of id is 0 or 1, referencing fixed row entry */
|
---|
100 | if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) {
|
---|
101 | return SNMP_ERR_NOSUCHINSTANCE;
|
---|
102 | }
|
---|
103 | if (instance->instance_oid.len > 1) {
|
---|
104 | column = instance->instance_oid.id[1];
|
---|
105 | }
|
---|
106 | if (instance->instance_oid.len > 2) {
|
---|
107 | snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2);
|
---|
108 | } else {
|
---|
109 | row_oid.len = 0;
|
---|
110 | }
|
---|
111 |
|
---|
112 | instance->get_value = table_node->get_value;
|
---|
113 | instance->set_test = table_node->set_test;
|
---|
114 | instance->set_value = table_node->set_value;
|
---|
115 |
|
---|
116 | /* resolve column and value */
|
---|
117 | do {
|
---|
118 | u16_t i;
|
---|
119 | const struct snmp_table_col_def *next_col_def = NULL;
|
---|
120 | col_def = table_node->columns;
|
---|
121 |
|
---|
122 | for (i = 0; i < table_node->column_count; i++) {
|
---|
123 | if (col_def->index == column) {
|
---|
124 | next_col_def = col_def;
|
---|
125 | break;
|
---|
126 | } else if ((col_def->index > column) && ((next_col_def == NULL) || (col_def->index < next_col_def->index))) {
|
---|
127 | next_col_def = col_def;
|
---|
128 | }
|
---|
129 | col_def++;
|
---|
130 | }
|
---|
131 |
|
---|
132 | if (next_col_def == NULL) {
|
---|
133 | /* no further column found */
|
---|
134 | return SNMP_ERR_NOSUCHINSTANCE;
|
---|
135 | }
|
---|
136 |
|
---|
137 | instance->asn1_type = next_col_def->asn1_type;
|
---|
138 | instance->access = next_col_def->access;
|
---|
139 |
|
---|
140 | result = table_node->get_next_cell_instance(
|
---|
141 | &next_col_def->index,
|
---|
142 | &row_oid,
|
---|
143 | instance);
|
---|
144 |
|
---|
145 | if (result == SNMP_ERR_NOERROR) {
|
---|
146 | col_def = next_col_def;
|
---|
147 | break;
|
---|
148 | }
|
---|
149 |
|
---|
150 | row_oid.len = 0; /* reset row_oid because we switch to next column and start with the first entry there */
|
---|
151 | column = next_col_def->index + 1;
|
---|
152 | } while (1);
|
---|
153 |
|
---|
154 | /* build resulting oid */
|
---|
155 | instance->instance_oid.len = 2;
|
---|
156 | instance->instance_oid.id[0] = 1;
|
---|
157 | instance->instance_oid.id[1] = col_def->index;
|
---|
158 | snmp_oid_append(&instance->instance_oid, row_oid.id, row_oid.len);
|
---|
159 |
|
---|
160 | return SNMP_ERR_NOERROR;
|
---|
161 | }
|
---|
162 |
|
---|
163 |
|
---|
164 | snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance)
|
---|
165 | {
|
---|
166 | snmp_err_t ret = SNMP_ERR_NOSUCHINSTANCE;
|
---|
167 | const struct snmp_table_simple_node *table_node = (const struct snmp_table_simple_node *)(const void *)instance->node;
|
---|
168 |
|
---|
169 | LWIP_UNUSED_ARG(root_oid);
|
---|
170 | LWIP_UNUSED_ARG(root_oid_len);
|
---|
171 |
|
---|
172 | /* check min. length (fixed row entry definition, column, row instance oid with at least one entry */
|
---|
173 | /* fixed row entry always has oid 1 */
|
---|
174 | if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) {
|
---|
175 | ret = table_node->get_cell_value(
|
---|
176 | &(instance->instance_oid.id[1]),
|
---|
177 | &(instance->instance_oid.id[2]),
|
---|
178 | instance->instance_oid.len - 2,
|
---|
179 | &instance->reference,
|
---|
180 | &instance->reference_len);
|
---|
181 |
|
---|
182 | if (ret == SNMP_ERR_NOERROR) {
|
---|
183 | /* search column */
|
---|
184 | const struct snmp_table_simple_col_def *col_def = table_node->columns;
|
---|
185 | u32_t i = table_node->column_count;
|
---|
186 | while (i > 0) {
|
---|
187 | if (col_def->index == instance->instance_oid.id[1]) {
|
---|
188 | break;
|
---|
189 | }
|
---|
190 |
|
---|
191 | col_def++;
|
---|
192 | i--;
|
---|
193 | }
|
---|
194 |
|
---|
195 | if (i > 0) {
|
---|
196 | instance->asn1_type = col_def->asn1_type;
|
---|
197 | instance->access = SNMP_NODE_INSTANCE_READ_ONLY;
|
---|
198 | instance->set_test = NULL;
|
---|
199 | instance->set_value = NULL;
|
---|
200 |
|
---|
201 | switch (col_def->data_type) {
|
---|
202 | case SNMP_VARIANT_VALUE_TYPE_U32:
|
---|
203 | instance->get_value = snmp_table_extract_value_from_u32ref;
|
---|
204 | break;
|
---|
205 | case SNMP_VARIANT_VALUE_TYPE_S32:
|
---|
206 | instance->get_value = snmp_table_extract_value_from_s32ref;
|
---|
207 | break;
|
---|
208 | case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */
|
---|
209 | case SNMP_VARIANT_VALUE_TYPE_CONST_PTR:
|
---|
210 | instance->get_value = snmp_table_extract_value_from_refconstptr;
|
---|
211 | break;
|
---|
212 | default:
|
---|
213 | LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type));
|
---|
214 | return SNMP_ERR_GENERROR;
|
---|
215 | }
|
---|
216 |
|
---|
217 | ret = SNMP_ERR_NOERROR;
|
---|
218 | } else {
|
---|
219 | ret = SNMP_ERR_NOSUCHINSTANCE;
|
---|
220 | }
|
---|
221 | }
|
---|
222 | }
|
---|
223 |
|
---|
224 | return ret;
|
---|
225 | }
|
---|
226 |
|
---|
227 | snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance)
|
---|
228 | {
|
---|
229 | const struct snmp_table_simple_node *table_node = (const struct snmp_table_simple_node *)(const void *)instance->node;
|
---|
230 | const struct snmp_table_simple_col_def *col_def;
|
---|
231 | struct snmp_obj_id row_oid;
|
---|
232 | u32_t column = 0;
|
---|
233 | snmp_err_t result;
|
---|
234 |
|
---|
235 | LWIP_UNUSED_ARG(root_oid);
|
---|
236 | LWIP_UNUSED_ARG(root_oid_len);
|
---|
237 |
|
---|
238 | /* check that first part of id is 0 or 1, referencing fixed row entry */
|
---|
239 | if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) {
|
---|
240 | return SNMP_ERR_NOSUCHINSTANCE;
|
---|
241 | }
|
---|
242 | if (instance->instance_oid.len > 1) {
|
---|
243 | column = instance->instance_oid.id[1];
|
---|
244 | }
|
---|
245 | if (instance->instance_oid.len > 2) {
|
---|
246 | snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2);
|
---|
247 | } else {
|
---|
248 | row_oid.len = 0;
|
---|
249 | }
|
---|
250 |
|
---|
251 | /* resolve column and value */
|
---|
252 | do {
|
---|
253 | u32_t i;
|
---|
254 | const struct snmp_table_simple_col_def *next_col_def = NULL;
|
---|
255 | col_def = table_node->columns;
|
---|
256 |
|
---|
257 | for (i = 0; i < table_node->column_count; i++) {
|
---|
258 | if (col_def->index == column) {
|
---|
259 | next_col_def = col_def;
|
---|
260 | break;
|
---|
261 | } else if ((col_def->index > column) && ((next_col_def == NULL) ||
|
---|
262 | (col_def->index < next_col_def->index))) {
|
---|
263 | next_col_def = col_def;
|
---|
264 | }
|
---|
265 | col_def++;
|
---|
266 | }
|
---|
267 |
|
---|
268 | if (next_col_def == NULL) {
|
---|
269 | /* no further column found */
|
---|
270 | return SNMP_ERR_NOSUCHINSTANCE;
|
---|
271 | }
|
---|
272 |
|
---|
273 | result = table_node->get_next_cell_instance_and_value(
|
---|
274 | &next_col_def->index,
|
---|
275 | &row_oid,
|
---|
276 | &instance->reference,
|
---|
277 | &instance->reference_len);
|
---|
278 |
|
---|
279 | if (result == SNMP_ERR_NOERROR) {
|
---|
280 | col_def = next_col_def;
|
---|
281 | break;
|
---|
282 | }
|
---|
283 |
|
---|
284 | row_oid.len = 0; /* reset row_oid because we switch to next column and start with the first entry there */
|
---|
285 | column = next_col_def->index + 1;
|
---|
286 | } while (1);
|
---|
287 |
|
---|
288 | instance->asn1_type = col_def->asn1_type;
|
---|
289 | instance->access = SNMP_NODE_INSTANCE_READ_ONLY;
|
---|
290 | instance->set_test = NULL;
|
---|
291 | instance->set_value = NULL;
|
---|
292 |
|
---|
293 | switch (col_def->data_type) {
|
---|
294 | case SNMP_VARIANT_VALUE_TYPE_U32:
|
---|
295 | instance->get_value = snmp_table_extract_value_from_u32ref;
|
---|
296 | break;
|
---|
297 | case SNMP_VARIANT_VALUE_TYPE_S32:
|
---|
298 | instance->get_value = snmp_table_extract_value_from_s32ref;
|
---|
299 | break;
|
---|
300 | case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */
|
---|
301 | case SNMP_VARIANT_VALUE_TYPE_CONST_PTR:
|
---|
302 | instance->get_value = snmp_table_extract_value_from_refconstptr;
|
---|
303 | break;
|
---|
304 | default:
|
---|
305 | LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type));
|
---|
306 | return SNMP_ERR_GENERROR;
|
---|
307 | }
|
---|
308 |
|
---|
309 | /* build resulting oid */
|
---|
310 | instance->instance_oid.len = 2;
|
---|
311 | instance->instance_oid.id[0] = 1;
|
---|
312 | instance->instance_oid.id[1] = col_def->index;
|
---|
313 | snmp_oid_append(&instance->instance_oid, row_oid.id, row_oid.len);
|
---|
314 |
|
---|
315 | return SNMP_ERR_NOERROR;
|
---|
316 | }
|
---|
317 |
|
---|
318 |
|
---|
319 | s16_t
|
---|
320 | snmp_table_extract_value_from_s32ref(struct snmp_node_instance *instance, void *value)
|
---|
321 | {
|
---|
322 | s32_t *dst = (s32_t *)value;
|
---|
323 | *dst = instance->reference.s32;
|
---|
324 | return sizeof(*dst);
|
---|
325 | }
|
---|
326 |
|
---|
327 | s16_t
|
---|
328 | snmp_table_extract_value_from_u32ref(struct snmp_node_instance *instance, void *value)
|
---|
329 | {
|
---|
330 | u32_t *dst = (u32_t *)value;
|
---|
331 | *dst = instance->reference.u32;
|
---|
332 | return sizeof(*dst);
|
---|
333 | }
|
---|
334 |
|
---|
335 | s16_t
|
---|
336 | snmp_table_extract_value_from_refconstptr(struct snmp_node_instance *instance, void *value)
|
---|
337 | {
|
---|
338 | MEMCPY(value, instance->reference.const_ptr, instance->reference_len);
|
---|
339 | return (u16_t)instance->reference_len;
|
---|
340 | }
|
---|
341 |
|
---|
342 | #endif /* LWIP_SNMP */
|
---|