OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [freertos-6.1.1/] [Demo/] [Common/] [ethernet/] [lwIP/] [core/] [snmp/] [mib2.c] - Blame information for rev 622

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 606 jeremybenn 
/**
2 
 * @file
3 
 * Management Information Base II (RFC1213) objects and functions.
4 
 *
5 
 * @note the object identifiers for this MIB-2 and private MIB tree
6 
 * must be kept in sorted ascending order. This to ensure correct getnext operation.
7 
 */
8 
 
9 
/*
10 
 * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands.
11 
 * All rights reserved.
12 
 *
13 
 * Redistribution and use in source and binary forms, with or without modification,
14 
 * are permitted provided that the following conditions are met:
15 
 *
16 
 * 1. Redistributions of source code must retain the above copyright notice,
17 
 *    this list of conditions and the following disclaimer.
18 
 * 2. Redistributions in binary form must reproduce the above copyright notice,
19 
 *    this list of conditions and the following disclaimer in the documentation
20 
 *    and/or other materials provided with the distribution.
21 
 * 3. The name of the author may not be used to endorse or promote products
22 
 *    derived from this software without specific prior written permission.
23 
 *
24 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
25 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26 
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
27 
 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
28 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
29 
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
32 
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
33 
 * OF SUCH DAMAGE.
34 
 *
35 
 * Author: Christiaan Simons <christiaan.simons@axon.tv>
36 
 */
37 
 
38 
#include "arch/cc.h"
39 
#include "lwip/opt.h"
40 
 
41 
#if LWIP_SNMP
42 
#include "lwip/snmp.h"
43 
#include "lwip/netif.h"
44 
#include "netif/etharp.h"
45 
#include "lwip/ip.h"
46 
#include "lwip/ip_frag.h"
47 
#include "lwip/tcp.h"
48 
#include "lwip/udp.h"
49 
#include "lwip/snmp_asn1.h"
50 
#include "lwip/snmp_structs.h"
51 
 
52 
/**
53 
 * IANA assigned enterprise ID for lwIP is 26381
54 
 * @see http://www.iana.org/assignments/enterprise-numbers
55 
 *
56 
 * @note this enterprise ID is assigned to the lwIP project,
57 
 * all object identifiers living under this ID are assigned
58 
 * by the lwIP maintainers (contact Christiaan Simons)!
59 
 * @note don't change this define, use snmp_set_sysobjid()
60 
 *
61 
 * If you need to create your own private MIB you'll need
62 
 * to apply for your own enterprise ID with IANA:
63 
 * http://www.iana.org/numbers.html
64 
 */
65 
#define SNMP_ENTERPRISE_ID 26381
66 
#define SNMP_SYSOBJID_LEN 7
67 
#define SNMP_SYSOBJID {1, 3, 6, 1, 4, 1, SNMP_ENTERPRISE_ID}
68 
 
69 
#ifndef SNMP_SYSSERVICES
70 
#define SNMP_SYSSERVICES ((1 << 6) | (1 << 3) | ((IP_FORWARD) << 2))
71 
#endif
72 
 
73 
static void system_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
74 
static void system_get_value(struct obj_def *od, u16_t len, void *value);
75 
static u8_t system_set_test(struct obj_def *od, u16_t len, void *value);
76 
static void system_set_value(struct obj_def *od, u16_t len, void *value);
77 
static void interfaces_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
78 
static void interfaces_get_value(struct obj_def *od, u16_t len, void *value);
79 
static void ifentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
80 
static void ifentry_get_value(struct obj_def *od, u16_t len, void *value);
81 
static void atentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
82 
static void atentry_get_value(struct obj_def *od, u16_t len, void *value);
83 
static void ip_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
84 
static void ip_get_value(struct obj_def *od, u16_t len, void *value);
85 
static u8_t ip_set_test(struct obj_def *od, u16_t len, void *value);
86 
static void ip_addrentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
87 
static void ip_addrentry_get_value(struct obj_def *od, u16_t len, void *value);
88 
static void ip_rteentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
89 
static void ip_rteentry_get_value(struct obj_def *od, u16_t len, void *value);
90 
static void ip_ntomentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
91 
static void ip_ntomentry_get_value(struct obj_def *od, u16_t len, void *value);
92 
static void icmp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
93 
static void icmp_get_value(struct obj_def *od, u16_t len, void *value);
94 
#if LWIP_TCP
95 
static void tcp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
96 
static void tcp_get_value(struct obj_def *od, u16_t len, void *value);
97 
static void tcpconnentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
98 
static void tcpconnentry_get_value(struct obj_def *od, u16_t len, void *value);
99 
#endif
100 
static void udp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
101 
static void udp_get_value(struct obj_def *od, u16_t len, void *value);
102 
static void udpentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
103 
static void udpentry_get_value(struct obj_def *od, u16_t len, void *value);
104 
static void snmp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od);
105 
static void snmp_get_value(struct obj_def *od, u16_t len, void *value);
106 
static u8_t snmp_set_test(struct obj_def *od, u16_t len, void *value);
107 
static void snmp_set_value(struct obj_def *od, u16_t len, void *value);
108 
 
109 
 
110 
/* snmp .1.3.6.1.2.1.11 */
111 
const mib_scalar_node snmp_scalar = {
112 
  &snmp_get_object_def,
113 
  &snmp_get_value,
114 
  &snmp_set_test,
115 
  &snmp_set_value,
116 
  MIB_NODE_SC,
117 
 
118 
};
119 
const s32_t snmp_ids[28] = {
120 
  1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16,
121 
  17, 18, 19, 20, 21, 22, 24, 25, 26, 27, 28, 29, 30
122 
};
123 
struct mib_node* const snmp_nodes[28] = {
124 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
125 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
126 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
127 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
128 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
129 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
130 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
131 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
132 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
133 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
134 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
135 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
136 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar,
137 
  (struct mib_node* const)&snmp_scalar, (struct mib_node* const)&snmp_scalar
138 
};
139 
const struct mib_array_node snmp = {
140 
  &noleafs_get_object_def,
141 
  &noleafs_get_value,
142 
  &noleafs_set_test,
143 
  &noleafs_set_value,
144 
  MIB_NODE_AR,
145 
  28,
146 
  snmp_ids,
147 
  snmp_nodes
148 
};
149 
 
150 
/* dot3 and EtherLike MIB not planned. (transmission .1.3.6.1.2.1.10) */
151 
/* historical (some say hysterical). (cmot .1.3.6.1.2.1.9) */
152 
/* lwIP has no EGP, thus may not implement it. (egp .1.3.6.1.2.1.8) */
153 
 
154 
/* udp .1.3.6.1.2.1.7 */
155 
/** index root node for udpTable */
156 
struct mib_list_rootnode udp_root = {
157 
  &noleafs_get_object_def,
158 
  &noleafs_get_value,
159 
  &noleafs_set_test,
160 
  &noleafs_set_value,
161 
  MIB_NODE_LR,
162 
  0,
163 
  NULL,
164 
  NULL,
165 
 
166 
};
167 
const s32_t udpentry_ids[2] = { 1, 2 };
168 
struct mib_node* const udpentry_nodes[2] = {
169 
  (struct mib_node* const)&udp_root, (struct mib_node* const)&udp_root,
170 
};
171 
const struct mib_array_node udpentry = {
172 
  &noleafs_get_object_def,
173 
  &noleafs_get_value,
174 
  &noleafs_set_test,
175 
  &noleafs_set_value,
176 
  MIB_NODE_AR,
177 
  2,
178 
  udpentry_ids,
179 
  udpentry_nodes
180 
};
181 
 
182 
s32_t udptable_id = 1;
183 
struct mib_node* udptable_node = (struct mib_node* const)&udpentry;
184 
struct mib_ram_array_node udptable = {
185 
  &noleafs_get_object_def,
186 
  &noleafs_get_value,
187 
  &noleafs_set_test,
188 
  &noleafs_set_value,
189 
  MIB_NODE_RA,
190 
  0,
191 
  &udptable_id,
192 
  &udptable_node
193 
};
194 
 
195 
const mib_scalar_node udp_scalar = {
196 
  &udp_get_object_def,
197 
  &udp_get_value,
198 
  &noleafs_set_test,
199 
  &noleafs_set_value,
200 
  MIB_NODE_SC,
201 
 
202 
};
203 
const s32_t udp_ids[5] = { 1, 2, 3, 4, 5 };
204 
struct mib_node* const udp_nodes[5] = {
205 
  (struct mib_node* const)&udp_scalar, (struct mib_node* const)&udp_scalar,
206 
  (struct mib_node* const)&udp_scalar, (struct mib_node* const)&udp_scalar,
207 
  (struct mib_node* const)&udptable
208 
};
209 
const struct mib_array_node udp = {
210 
  &noleafs_get_object_def,
211 
  &noleafs_get_value,
212 
  &noleafs_set_test,
213 
  &noleafs_set_value,
214 
  MIB_NODE_AR,
215 
  5,
216 
  udp_ids,
217 
  udp_nodes
218 
};
219 
 
220 
/* tcp .1.3.6.1.2.1.6 */
221 
#if LWIP_TCP
222 
/* only if the TCP protocol is available may implement this group */
223 
/** index root node for tcpConnTable */
224 
struct mib_list_rootnode tcpconntree_root = {
225 
  &noleafs_get_object_def,
226 
  &noleafs_get_value,
227 
  &noleafs_set_test,
228 
  &noleafs_set_value,
229 
  MIB_NODE_LR,
230 
  0,
231 
  NULL,
232 
  NULL,
233 
 
234 
};
235 
const s32_t tcpconnentry_ids[5] = { 1, 2, 3, 4, 5 };
236 
struct mib_node* const tcpconnentry_nodes[5] = {
237 
  (struct mib_node* const)&tcpconntree_root, (struct mib_node* const)&tcpconntree_root,
238 
  (struct mib_node* const)&tcpconntree_root, (struct mib_node* const)&tcpconntree_root,
239 
  (struct mib_node* const)&tcpconntree_root
240 
};
241 
const struct mib_array_node tcpconnentry = {
242 
  &noleafs_get_object_def,
243 
  &noleafs_get_value,
244 
  &noleafs_set_test,
245 
  &noleafs_set_value,
246 
  MIB_NODE_AR,
247 
  5,
248 
  tcpconnentry_ids,
249 
  tcpconnentry_nodes
250 
};
251 
 
252 
s32_t tcpconntable_id = 1;
253 
struct mib_node* tcpconntable_node = (struct mib_node* const)&tcpconnentry;
254 
struct mib_ram_array_node tcpconntable = {
255 
  &noleafs_get_object_def,
256 
  &noleafs_get_value,
257 
  &noleafs_set_test,
258 
  &noleafs_set_value,
259 
  MIB_NODE_RA,
260 
/** @todo update maxlength when inserting / deleting from table
261 
 
262 
  0,
263 
  &tcpconntable_id,
264 
  &tcpconntable_node
265 
};
266 
 
267 
const mib_scalar_node tcp_scalar = {
268 
  &tcp_get_object_def,
269 
  &tcp_get_value,
270 
  &noleafs_set_test,
271 
  &noleafs_set_value,
272 
  MIB_NODE_SC,
273 
 
274 
};
275 
const s32_t tcp_ids[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
276 
struct mib_node* const tcp_nodes[15] = {
277 
  (struct mib_node* const)&tcp_scalar, (struct mib_node* const)&tcp_scalar,
278 
  (struct mib_node* const)&tcp_scalar, (struct mib_node* const)&tcp_scalar,
279 
  (struct mib_node* const)&tcp_scalar, (struct mib_node* const)&tcp_scalar,
280 
  (struct mib_node* const)&tcp_scalar, (struct mib_node* const)&tcp_scalar,
281 
  (struct mib_node* const)&tcp_scalar, (struct mib_node* const)&tcp_scalar,
282 
  (struct mib_node* const)&tcp_scalar, (struct mib_node* const)&tcp_scalar,
283 
  (struct mib_node* const)&tcpconntable, (struct mib_node* const)&tcp_scalar,
284 
  (struct mib_node* const)&tcp_scalar
285 
};
286 
const struct mib_array_node tcp = {
287 
  &noleafs_get_object_def,
288 
  &noleafs_get_value,
289 
  &noleafs_set_test,
290 
  &noleafs_set_value,
291 
  MIB_NODE_AR,
292 
  15,
293 
  tcp_ids,
294 
  tcp_nodes
295 
};
296 
#endif
297 
 
298 
/* icmp .1.3.6.1.2.1.5 */
299 
const mib_scalar_node icmp_scalar = {
300 
  &icmp_get_object_def,
301 
  &icmp_get_value,
302 
  &noleafs_set_test,
303 
  &noleafs_set_value,
304 
  MIB_NODE_SC,
305 
 
306 
};
307 
const s32_t icmp_ids[26] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 };
308 
struct mib_node* const icmp_nodes[26] = {
309 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
310 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
311 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
312 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
313 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
314 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
315 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
316 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
317 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
318 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
319 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
320 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar,
321 
  (struct mib_node* const)&icmp_scalar, (struct mib_node* const)&icmp_scalar
322 
};
323 
const struct mib_array_node icmp = {
324 
  &noleafs_get_object_def,
325 
  &noleafs_get_value,
326 
  &noleafs_set_test,
327 
  &noleafs_set_value,
328 
  MIB_NODE_AR,
329 
  26,
330 
  icmp_ids,
331 
  icmp_nodes
332 
};
333 
 
334 
/** index root node for ipNetToMediaTable */
335 
struct mib_list_rootnode ipntomtree_root = {
336 
  &noleafs_get_object_def,
337 
  &noleafs_get_value,
338 
  &noleafs_set_test,
339 
  &noleafs_set_value,
340 
  MIB_NODE_LR,
341 
  0,
342 
  NULL,
343 
  NULL,
344 
 
345 
};
346 
const s32_t ipntomentry_ids[4] = { 1, 2, 3, 4 };
347 
struct mib_node* const ipntomentry_nodes[4] = {
348 
  (struct mib_node* const)&ipntomtree_root, (struct mib_node* const)&ipntomtree_root,
349 
  (struct mib_node* const)&ipntomtree_root, (struct mib_node* const)&ipntomtree_root
350 
};
351 
const struct mib_array_node ipntomentry = {
352 
  &noleafs_get_object_def,
353 
  &noleafs_get_value,
354 
  &noleafs_set_test,
355 
  &noleafs_set_value,
356 
  MIB_NODE_AR,
357 
  4,
358 
  ipntomentry_ids,
359 
  ipntomentry_nodes
360 
};
361 
 
362 
s32_t ipntomtable_id = 1;
363 
struct mib_node* ipntomtable_node = (struct mib_node* const)&ipntomentry;
364 
struct mib_ram_array_node ipntomtable = {
365 
  &noleafs_get_object_def,
366 
  &noleafs_get_value,
367 
  &noleafs_set_test,
368 
  &noleafs_set_value,
369 
  MIB_NODE_RA,
370 
  0,
371 
  &ipntomtable_id,
372 
  &ipntomtable_node
373 
};
374 
 
375 
/** index root node for ipRouteTable */
376 
struct mib_list_rootnode iprtetree_root = {
377 
  &noleafs_get_object_def,
378 
  &noleafs_get_value,
379 
  &noleafs_set_test,
380 
  &noleafs_set_value,
381 
  MIB_NODE_LR,
382 
  0,
383 
  NULL,
384 
  NULL,
385 
 
386 
};
387 
const s32_t iprteentry_ids[13] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
388 
struct mib_node* const iprteentry_nodes[13] = {
389 
  (struct mib_node* const)&iprtetree_root, (struct mib_node* const)&iprtetree_root,
390 
  (struct mib_node* const)&iprtetree_root, (struct mib_node* const)&iprtetree_root,
391 
  (struct mib_node* const)&iprtetree_root, (struct mib_node* const)&iprtetree_root,
392 
  (struct mib_node* const)&iprtetree_root, (struct mib_node* const)&iprtetree_root,
393 
  (struct mib_node* const)&iprtetree_root, (struct mib_node* const)&iprtetree_root,
394 
  (struct mib_node* const)&iprtetree_root, (struct mib_node* const)&iprtetree_root,
395 
  (struct mib_node* const)&iprtetree_root
396 
};
397 
const struct mib_array_node iprteentry = {
398 
  &noleafs_get_object_def,
399 
  &noleafs_get_value,
400 
  &noleafs_set_test,
401 
  &noleafs_set_value,
402 
  MIB_NODE_AR,
403 
  13,
404 
  iprteentry_ids,
405 
  iprteentry_nodes
406 
};
407 
 
408 
s32_t iprtetable_id = 1;
409 
struct mib_node* iprtetable_node = (struct mib_node* const)&iprteentry;
410 
struct mib_ram_array_node iprtetable = {
411 
  &noleafs_get_object_def,
412 
  &noleafs_get_value,
413 
  &noleafs_set_test,
414 
  &noleafs_set_value,
415 
  MIB_NODE_RA,
416 
  0,
417 
  &iprtetable_id,
418 
  &iprtetable_node
419 
};
420 
 
421 
/** index root node for ipAddrTable */
422 
struct mib_list_rootnode ipaddrtree_root = {
423 
  &noleafs_get_object_def,
424 
  &noleafs_get_value,
425 
  &noleafs_set_test,
426 
  &noleafs_set_value,
427 
  MIB_NODE_LR,
428 
  0,
429 
  NULL,
430 
  NULL,
431 
 
432 
};
433 
const s32_t ipaddrentry_ids[5] = { 1, 2, 3, 4, 5 };
434 
struct mib_node* const ipaddrentry_nodes[5] = {
435 
  (struct mib_node* const)&ipaddrtree_root,
436 
  (struct mib_node* const)&ipaddrtree_root,
437 
  (struct mib_node* const)&ipaddrtree_root,
438 
  (struct mib_node* const)&ipaddrtree_root,
439 
  (struct mib_node* const)&ipaddrtree_root
440 
};
441 
const struct mib_array_node ipaddrentry = {
442 
  &noleafs_get_object_def,
443 
  &noleafs_get_value,
444 
  &noleafs_set_test,
445 
  &noleafs_set_value,
446 
  MIB_NODE_AR,
447 
  5,
448 
  ipaddrentry_ids,
449 
  ipaddrentry_nodes
450 
};
451 
 
452 
s32_t ipaddrtable_id = 1;
453 
struct mib_node* ipaddrtable_node = (struct mib_node* const)&ipaddrentry;
454 
struct mib_ram_array_node ipaddrtable = {
455 
  &noleafs_get_object_def,
456 
  &noleafs_get_value,
457 
  &noleafs_set_test,
458 
  &noleafs_set_value,
459 
  MIB_NODE_RA,
460 
  0,
461 
  &ipaddrtable_id,
462 
  &ipaddrtable_node
463 
};
464 
 
465 
/* ip .1.3.6.1.2.1.4 */
466 
const mib_scalar_node ip_scalar = {
467 
  &ip_get_object_def,
468 
  &ip_get_value,
469 
  &ip_set_test,
470 
  &noleafs_set_value,
471 
  MIB_NODE_SC,
472 
 
473 
};
474 
const s32_t ip_ids[23] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 };
475 
struct mib_node* const ip_nodes[23] = {
476 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
477 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
478 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
479 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
480 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
481 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
482 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
483 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
484 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ip_scalar,
485 
  (struct mib_node* const)&ip_scalar, (struct mib_node* const)&ipaddrtable,
486 
  (struct mib_node* const)&iprtetable, (struct mib_node* const)&ipntomtable,
487 
  (struct mib_node* const)&ip_scalar
488 
};
489 
const struct mib_array_node ip = {
490 
  &noleafs_get_object_def,
491 
  &noleafs_get_value,
492 
  &noleafs_set_test,
493 
  &noleafs_set_value,
494 
  MIB_NODE_AR,
495 
  23,
496 
  ip_ids,
497 
  ip_nodes
498 
};
499 
 
500 
/** index root node for atTable */
501 
struct mib_list_rootnode arptree_root = {
502 
  &noleafs_get_object_def,
503 
  &noleafs_get_value,
504 
  &noleafs_set_test,
505 
  &noleafs_set_value,
506 
  MIB_NODE_LR,
507 
  0,
508 
  NULL,
509 
  NULL,
510 
 
511 
};
512 
const s32_t atentry_ids[3] = { 1, 2, 3 };
513 
struct mib_node* const atentry_nodes[3] = {
514 
  (struct mib_node* const)&arptree_root,
515 
  (struct mib_node* const)&arptree_root,
516 
  (struct mib_node* const)&arptree_root
517 
};
518 
const struct mib_array_node atentry = {
519 
  &noleafs_get_object_def,
520 
  &noleafs_get_value,
521 
  &noleafs_set_test,
522 
  &noleafs_set_value,
523 
  MIB_NODE_AR,
524 
  3,
525 
  atentry_ids,
526 
  atentry_nodes
527 
};
528 
 
529 
const s32_t attable_id = 1;
530 
struct mib_node* const attable_node = (struct mib_node* const)&atentry;
531 
const struct mib_array_node attable = {
532 
  &noleafs_get_object_def,
533 
  &noleafs_get_value,
534 
  &noleafs_set_test,
535 
  &noleafs_set_value,
536 
  MIB_NODE_AR,
537 
  1,
538 
  &attable_id,
539 
  &attable_node
540 
};
541 
 
542 
/* at .1.3.6.1.2.1.3 */
543 
s32_t at_id = 1;
544 
struct mib_node* at_node = (struct mib_node* const)&attable;
545 
struct mib_ram_array_node at = {
546 
  &noleafs_get_object_def,
547 
  &noleafs_get_value,
548 
  &noleafs_set_test,
549 
  &noleafs_set_value,
550 
  MIB_NODE_RA,
551 
  0,
552 
  &at_id,
553 
  &at_node
554 
};
555 
 
556 
/** index root node for ifTable */
557 
struct mib_list_rootnode iflist_root = {
558 
  &ifentry_get_object_def,
559 
  &ifentry_get_value,
560 
  &noleafs_set_test,
561 
  &noleafs_set_value,
562 
  MIB_NODE_LR,
563 
  0,
564 
  NULL,
565 
  NULL,
566 
 
567 
};
568 
const s32_t ifentry_ids[22] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 };
569 
struct mib_node* const ifentry_nodes[22] = {
570 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
571 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
572 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
573 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
574 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
575 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
576 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
577 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
578 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
579 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root,
580 
  (struct mib_node* const)&iflist_root, (struct mib_node* const)&iflist_root
581 
};
582 
const struct mib_array_node ifentry = {
583 
  &noleafs_get_object_def,
584 
  &noleafs_get_value,
585 
  &noleafs_set_test,
586 
  &noleafs_set_value,
587 
  MIB_NODE_AR,
588 
  22,
589 
  ifentry_ids,
590 
  ifentry_nodes
591 
};
592 
 
593 
s32_t iftable_id = 1;
594 
struct mib_node* iftable_node = (struct mib_node* const)&ifentry;
595 
struct mib_ram_array_node iftable = {
596 
  &noleafs_get_object_def,
597 
  &noleafs_get_value,
598 
  &noleafs_set_test,
599 
  &noleafs_set_value,
600 
  MIB_NODE_RA,
601 
  0,
602 
  &iftable_id,
603 
  &iftable_node
604 
};
605 
 
606 
/* interfaces .1.3.6.1.2.1.2 */
607 
const mib_scalar_node interfaces_scalar = {
608 
  &interfaces_get_object_def,
609 
  &interfaces_get_value,
610 
  &noleafs_set_test,
611 
  &noleafs_set_value,
612 
  MIB_NODE_SC,
613 
 
614 
};
615 
const s32_t interfaces_ids[2] = { 1, 2 };
616 
struct mib_node* const interfaces_nodes[2] = {
617 
  (struct mib_node* const)&interfaces_scalar, (struct mib_node* const)&iftable
618 
};
619 
const struct mib_array_node interfaces = {
620 
  &noleafs_get_object_def,
621 
  &noleafs_get_value,
622 
  &noleafs_set_test,
623 
  &noleafs_set_value,
624 
  MIB_NODE_AR,
625 
  2,
626 
  interfaces_ids,
627 
  interfaces_nodes
628 
};
629 
 
630 
 
631 
/*             0 1 2 3 4 5 6 */
632 
/* system .1.3.6.1.2.1.1 */
633 
const mib_scalar_node sys_tem_scalar = {
634 
  &system_get_object_def,
635 
  &system_get_value,
636 
  &system_set_test,
637 
  &system_set_value,
638 
  MIB_NODE_SC,
639 
 
640 
};
641 
const s32_t sys_tem_ids[7] = { 1, 2, 3, 4, 5, 6, 7 };
642 
struct mib_node* const sys_tem_nodes[7] = {
643 
  (struct mib_node* const)&sys_tem_scalar, (struct mib_node* const)&sys_tem_scalar,
644 
  (struct mib_node* const)&sys_tem_scalar, (struct mib_node* const)&sys_tem_scalar,
645 
  (struct mib_node* const)&sys_tem_scalar, (struct mib_node* const)&sys_tem_scalar,
646 
  (struct mib_node* const)&sys_tem_scalar
647 
};
648 
/* work around name issue with 'sys_tem', some compiler(s?) seem to reserve 'system' */
649 
const struct mib_array_node sys_tem = {
650 
  &noleafs_get_object_def,
651 
  &noleafs_get_value,
652 
  &noleafs_set_test,
653 
  &noleafs_set_value,
654 
  MIB_NODE_AR,
655 
  7,
656 
  sys_tem_ids,
657 
  sys_tem_nodes
658 
};
659 
 
660 
/* mib-2 .1.3.6.1.2.1 */
661 
#if LWIP_TCP
662 
#define MIB2_GROUPS 8
663 
#else
664 
#define MIB2_GROUPS 7
665 
#endif
666 
const s32_t mib2_ids[MIB2_GROUPS] =
667 
{
668 
  1,
669 
  2,
670 
  3,
671 
  4,
672 
  5,
673 
#if LWIP_TCP
674 
  6,
675 
#endif
676 
  7,
677 
  11
678 
};
679 
struct mib_node* const mib2_nodes[MIB2_GROUPS] = {
680 
  (struct mib_node* const)&sys_tem,
681 
  (struct mib_node* const)&interfaces,
682 
  (struct mib_node* const)&at,
683 
  (struct mib_node* const)&ip,
684 
  (struct mib_node* const)&icmp,
685 
#if LWIP_TCP
686 
  (struct mib_node* const)&tcp,
687 
#endif
688 
  (struct mib_node* const)&udp,
689 
  (struct mib_node* const)&snmp
690 
};
691 
 
692 
const struct mib_array_node mib2 = {
693 
  &noleafs_get_object_def,
694 
  &noleafs_get_value,
695 
  &noleafs_set_test,
696 
  &noleafs_set_value,
697 
  MIB_NODE_AR,
698 
  MIB2_GROUPS,
699 
  mib2_ids,
700 
  mib2_nodes
701 
};
702 
 
703 
/* mgmt .1.3.6.1.2 */
704 
const s32_t mgmt_ids[1] = { 1 };
705 
struct mib_node* const mgmt_nodes[1] = { (struct mib_node* const)&mib2 };
706 
const struct mib_array_node mgmt = {
707 
  &noleafs_get_object_def,
708 
  &noleafs_get_value,
709 
  &noleafs_set_test,
710 
  &noleafs_set_value,
711 
  MIB_NODE_AR,
712 
  1,
713 
  mgmt_ids,
714 
  mgmt_nodes
715 
};
716 
 
717 
/* internet .1.3.6.1 */
718 
#if SNMP_PRIVATE_MIB
719 
s32_t internet_ids[2] = { 2, 4 };
720 
struct mib_node* const internet_nodes[2] = { (struct mib_node* const)&mgmt, (struct mib_node* const)&private };
721 
const struct mib_array_node internet = {
722 
  &noleafs_get_object_def,
723 
  &noleafs_get_value,
724 
  &noleafs_set_test,
725 
  &noleafs_set_value,
726 
  MIB_NODE_AR,
727 
  2,
728 
  internet_ids,
729 
  internet_nodes
730 
};
731 
#else
732 
const s32_t internet_ids[1] = { 2 };
733 
struct mib_node* const internet_nodes[1] = { (struct mib_node* const)&mgmt };
734 
const struct mib_array_node internet = {
735 
  &noleafs_get_object_def,
736 
  &noleafs_get_value,
737 
  &noleafs_set_test,
738 
  &noleafs_set_value,
739 
  MIB_NODE_AR,
740 
  1,
741 
  internet_ids,
742 
  internet_nodes
743 
};
744 
#endif
745 
 
746 
/** mib-2.system.sysObjectID  */
747 
static struct snmp_obj_id sysobjid = {SNMP_SYSOBJID_LEN, SNMP_SYSOBJID};
748 
/** enterprise ID for generic TRAPs, .iso.org.dod.internet.mgmt.mib-2.snmp */
749 
static struct snmp_obj_id snmpgrp_id = {7,{1,3,6,1,2,1,11}};
750 
/** mib-2.system.sysServices */
751 
static const s32_t sysservices = SNMP_SYSSERVICES;
752 
 
753 
/** mib-2.system.sysDescr */
754 
static const u8_t sysdescr_len_default = 4;
755 
static const u8_t sysdescr_default[] = "lwIP";
756 
static u8_t* sysdescr_len_ptr = (u8_t*)&sysdescr_len_default;
757 
static u8_t* sysdescr_ptr = (u8_t*)&sysdescr_default[0];
758 
/** mib-2.system.sysContact */
759 
static const u8_t syscontact_len_default = 0;
760 
static const u8_t syscontact_default[] = "";
761 
static u8_t* syscontact_len_ptr = (u8_t*)&syscontact_len_default;
762 
static u8_t* syscontact_ptr = (u8_t*)&syscontact_default[0];
763 
/** mib-2.system.sysName */
764 
static const u8_t sysname_len_default = 8;
765 
static const u8_t sysname_default[] = "FQDN-unk";
766 
static u8_t* sysname_len_ptr = (u8_t*)&sysname_len_default;
767 
static u8_t* sysname_ptr = (u8_t*)&sysname_default[0];
768 
/** mib-2.system.sysLocation */
769 
static const u8_t syslocation_len_default = 0;
770 
static const u8_t syslocation_default[] = "";
771 
static u8_t* syslocation_len_ptr = (u8_t*)&syslocation_len_default;
772 
static u8_t* syslocation_ptr = (u8_t*)&syslocation_default[0];
773 
/** mib-2.snmp.snmpEnableAuthenTraps */
774 
static const u8_t snmpenableauthentraps_default = 2; /* disabled */
775 
static u8_t* snmpenableauthentraps_ptr = (u8_t*)&snmpenableauthentraps_default;
776 
 
777 
/** mib-2.interfaces.ifTable.ifEntry.ifSpecific (zeroDotZero) */
778 
static const struct snmp_obj_id ifspecific = {2, {0, 0}};
779 
/** mib-2.ip.ipRouteTable.ipRouteEntry.ipRouteInfo (zeroDotZero) */
780 
static const struct snmp_obj_id iprouteinfo = {2, {0, 0}};
781 
 
782 
 
783 
 
784 
/* mib-2.system counter(s) */
785 
static u32_t sysuptime = 0;
786 
 
787 
/* mib-2.ip counter(s) */
788 
static u32_t ipinreceives = 0,
789 
             ipinhdrerrors = 0,
790 
             ipinaddrerrors = 0,
791 
             ipforwdatagrams = 0,
792 
             ipinunknownprotos = 0,
793 
             ipindiscards = 0,
794 
             ipindelivers = 0,
795 
             ipoutrequests = 0,
796 
             ipoutdiscards = 0,
797 
             ipoutnoroutes = 0,
798 
             ipreasmreqds = 0,
799 
             ipreasmoks = 0,
800 
             ipreasmfails = 0,
801 
             ipfragoks = 0,
802 
             ipfragfails = 0,
803 
             ipfragcreates = 0,
804 
             iproutingdiscards = 0;
805 
/* mib-2.icmp counter(s) */
806 
static u32_t icmpinmsgs = 0,
807 
             icmpinerrors = 0,
808 
             icmpindestunreachs = 0,
809 
             icmpintimeexcds = 0,
810 
             icmpinparmprobs = 0,
811 
             icmpinsrcquenchs = 0,
812 
             icmpinredirects = 0,
813 
             icmpinechos = 0,
814 
             icmpinechoreps = 0,
815 
             icmpintimestamps = 0,
816 
             icmpintimestampreps = 0,
817 
             icmpinaddrmasks = 0,
818 
             icmpinaddrmaskreps = 0,
819 
             icmpoutmsgs = 0,
820 
             icmpouterrors = 0,
821 
             icmpoutdestunreachs = 0,
822 
             icmpouttimeexcds = 0,
823 
             icmpoutparmprobs = 0,
824 
             icmpoutsrcquenchs = 0,
825 
             icmpoutredirects = 0,
826 
             icmpoutechos = 0,
827 
             icmpoutechoreps = 0,
828 
             icmpouttimestamps = 0,
829 
             icmpouttimestampreps = 0,
830 
             icmpoutaddrmasks = 0,
831 
             icmpoutaddrmaskreps = 0;
832 
/* mib-2.tcp counter(s) */
833 
static u32_t tcpactiveopens = 0,
834 
             tcppassiveopens = 0,
835 
             tcpattemptfails = 0,
836 
             tcpestabresets = 0,
837 
             tcpinsegs = 0,
838 
             tcpoutsegs = 0,
839 
             tcpretranssegs = 0,
840 
             tcpinerrs = 0,
841 
             tcpoutrsts = 0;
842 
/* mib-2.udp counter(s) */
843 
static u32_t udpindatagrams = 0,
844 
             udpnoports = 0,
845 
             udpinerrors = 0,
846 
             udpoutdatagrams = 0;
847 
/* mib-2.snmp counter(s) */
848 
static u32_t snmpinpkts = 0,
849 
             snmpoutpkts = 0,
850 
             snmpinbadversions = 0,
851 
             snmpinbadcommunitynames = 0,
852 
             snmpinbadcommunityuses = 0,
853 
             snmpinasnparseerrs = 0,
854 
             snmpintoobigs = 0,
855 
             snmpinnosuchnames = 0,
856 
             snmpinbadvalues = 0,
857 
             snmpinreadonlys = 0,
858 
             snmpingenerrs = 0,
859 
             snmpintotalreqvars = 0,
860 
             snmpintotalsetvars = 0,
861 
             snmpingetrequests = 0,
862 
             snmpingetnexts = 0,
863 
             snmpinsetrequests = 0,
864 
             snmpingetresponses = 0,
865 
             snmpintraps = 0,
866 
             snmpouttoobigs = 0,
867 
             snmpoutnosuchnames = 0,
868 
             snmpoutbadvalues = 0,
869 
             snmpoutgenerrs = 0,
870 
             snmpoutgetrequests = 0,
871 
             snmpoutgetnexts = 0,
872 
             snmpoutsetrequests = 0,
873 
             snmpoutgetresponses = 0,
874 
             snmpouttraps = 0;
875 
 
876 
 
877 
 
878 
/* prototypes of the following functions are in lwip/src/include/lwip/snmp.h */
879 
/**
880 
 * Copy octet string.
881 
 *
882 
 * @param dst points to destination
883 
 * @param src points to source
884 
 * @param n number of octets to copy.
885 
 */
886 
void ocstrncpy(u8_t *dst, u8_t *src, u8_t n)
887 
{
888 
  while (n > 0)
889 
  {
890 
    n--;
891 
    *dst++ = *src++;
892 
  }
893 
}
894 
 
895 
/**
896 
 * Copy object identifier (s32_t) array.
897 
 *
898 
 * @param dst points to destination
899 
 * @param src points to source
900 
 * @param n number of sub identifiers to copy.
901 
 */
902 
void objectidncpy(s32_t *dst, s32_t *src, u8_t n)
903 
{
904 
  while(n > 0)
905 
  {
906 
    n--;
907 
    *dst++ = *src++;
908 
  }
909 
}
910 
 
911 
/**
912 
 * Initializes sysDescr pointers.
913 
 *
914 
 * @param str if non-NULL then copy str pointer
915 
 * @param strlen points to string length, excluding zero terminator
916 
 */
917 
void snmp_set_sysdesr(u8_t *str, u8_t *strlen)
918 
{
919 
  if (str != NULL)
920 
  {
921 
    sysdescr_ptr = str;
922 
    sysdescr_len_ptr = strlen;
923 
  }
924 
}
925 
 
926 
void snmp_get_sysobjid_ptr(struct snmp_obj_id **oid)
927 
{
928 
  *oid = &sysobjid;
929 
}
930 
 
931 
/**
932 
 * Initializes sysObjectID value.
933 
 *
934 
 * @param oid points to stuct snmp_obj_id to copy
935 
 */
936 
void snmp_set_sysobjid(struct snmp_obj_id *oid)
937 
{
938 
  sysobjid = *oid;
939 
}
940 
 
941 
/**
942 
 * Must be called at regular 10 msec interval from a timer interrupt
943 
 * or signal handler depending on your runtime environment.
944 
 */
945 
void snmp_inc_sysuptime(void)
946 
{
947 
  sysuptime++;
948 
}
949 
 
950 
void snmp_get_sysuptime(u32_t *value)
951 
{
952 
  *value = sysuptime;
953 
}
954 
 
955 
/**
956 
 * Initializes sysContact pointers,
957 
 * e.g. ptrs to non-volatile memory external to lwIP.
958 
 *
959 
 * @param str if non-NULL then copy str pointer
960 
 * @param strlen points to string length, excluding zero terminator
961 
 */
962 
void snmp_set_syscontact(u8_t *ocstr, u8_t *ocstrlen)
963 
{
964 
  if (ocstr != NULL)
965 
  {
966 
    syscontact_ptr = ocstr;
967 
    syscontact_len_ptr = ocstrlen;
968 
  }
969 
}
970 
 
971 
/**
972 
 * Initializes sysName pointers,
973 
 * e.g. ptrs to non-volatile memory external to lwIP.
974 
 *
975 
 * @param str if non-NULL then copy str pointer
976 
 * @param strlen points to string length, excluding zero terminator
977 
 */
978 
void snmp_set_sysname(u8_t *ocstr, u8_t *ocstrlen)
979 
{
980 
  if (ocstr != NULL)
981 
  {
982 
    sysname_ptr = ocstr;
983 
    sysname_len_ptr = ocstrlen;
984 
  }
985 
}
986 
 
987 
/**
988 
 * Initializes sysLocation pointers,
989 
 * e.g. ptrs to non-volatile memory external to lwIP.
990 
 *
991 
 * @param str if non-NULL then copy str pointer
992 
 * @param strlen points to string length, excluding zero terminator
993 
 */
994 
void snmp_set_syslocation(u8_t *ocstr, u8_t *ocstrlen)
995 
{
996 
  if (ocstr != NULL)
997 
  {
998 
    syslocation_ptr = ocstr;
999 
    syslocation_len_ptr = ocstrlen;
1000 
  }
1001 
}
1002 
 
1003 
 
1004 
void snmp_add_ifinoctets(struct netif *ni, u32_t value)
1005 
{
1006 
  ni->ifinoctets += value;
1007 
}
1008 
 
1009 
void snmp_inc_ifinucastpkts(struct netif *ni)
1010 
{
1011 
  (ni->ifinucastpkts)++;
1012 
}
1013 
 
1014 
void snmp_inc_ifinnucastpkts(struct netif *ni)
1015 
{
1016 
  (ni->ifinnucastpkts)++;
1017 
}
1018 
 
1019 
void snmp_inc_ifindiscards(struct netif *ni)
1020 
{
1021 
  (ni->ifindiscards)++;
1022 
}
1023 
 
1024 
void snmp_add_ifoutoctets(struct netif *ni, u32_t value)
1025 
{
1026 
  ni->ifoutoctets += value;
1027 
}
1028 
 
1029 
void snmp_inc_ifoutucastpkts(struct netif *ni)
1030 
{
1031 
  (ni->ifoutucastpkts)++;
1032 
}
1033 
 
1034 
void snmp_inc_ifoutnucastpkts(struct netif *ni)
1035 
{
1036 
  (ni->ifoutnucastpkts)++;
1037 
}
1038 
 
1039 
void snmp_inc_ifoutdiscards(struct netif *ni)
1040 
{
1041 
  (ni->ifoutdiscards)++;
1042 
}
1043 
 
1044 
void snmp_inc_iflist(void)
1045 
{
1046 
  struct mib_list_node *if_node = NULL;
1047 
 
1048 
  snmp_mib_node_insert(&iflist_root, iflist_root.count + 1, &if_node);
1049 
  /* enable getnext traversal on filled table */
1050 
  iftable.maxlength = 1;
1051 
}
1052 
 
1053 
void snmp_dec_iflist(void)
1054 
{
1055 
  snmp_mib_node_delete(&iflist_root, iflist_root.tail);
1056 
  /* disable getnext traversal on empty table */
1057 
  if(iflist_root.count == 0) iftable.maxlength = 0;
1058 
}
1059 
 
1060 
/**
1061 
 * Inserts ARP table indexes (.xIfIndex.xNetAddress)
1062 
 * into arp table index trees (both atTable and ipNetToMediaTable).
1063 
 */
1064 
void snmp_insert_arpidx_tree(struct netif *ni, struct ip_addr *ip)
1065 
{
1066 
  struct mib_list_rootnode *at_rn;
1067 
  struct mib_list_node *at_node;
1068 
  struct ip_addr hip;
1069 
  s32_t arpidx[5];
1070 
  u8_t level, tree;
1071 
 
1072 
  LWIP_ASSERT("ni != NULL", ni != NULL);
1073 
  snmp_netiftoifindex(ni, &arpidx[0]);
1074 
  hip.addr = ntohl(ip->addr);
1075 
  snmp_iptooid(&hip, &arpidx[1]);
1076 
 
1077 
  for (tree = 0; tree < 2; tree++)
1078 
  {
1079 
    if (tree == 0)
1080 
    {
1081 
      at_rn = &arptree_root;
1082 
    }
1083 
    else
1084 
    {
1085 
      at_rn = &ipntomtree_root;
1086 
    }
1087 
    for (level = 0; level < 5; level++)
1088 
    {
1089 
      at_node = NULL;
1090 
      snmp_mib_node_insert(at_rn, arpidx[level], &at_node);
1091 
      if ((level != 4) && (at_node != NULL))
1092 
      {
1093 
        if (at_node->nptr == NULL)
1094 
        {
1095 
          at_rn = snmp_mib_lrn_alloc();
1096 
          at_node->nptr = (struct mib_node*)at_rn;
1097 
          if (at_rn != NULL)
1098 
          {
1099 
            if (level == 3)
1100 
            {
1101 
              if (tree == 0)
1102 
              {
1103 
                at_rn->get_object_def = atentry_get_object_def;
1104 
                at_rn->get_value = atentry_get_value;
1105 
              }
1106 
              else
1107 
              {
1108 
                at_rn->get_object_def = ip_ntomentry_get_object_def;
1109 
                at_rn->get_value = ip_ntomentry_get_value;
1110 
              }
1111 
              at_rn->set_test = noleafs_set_test;
1112 
              at_rn->set_value = noleafs_set_value;
1113 
            }
1114 
          }
1115 
          else
1116 
          {
1117 
            /* at_rn == NULL, malloc failure */
1118 
            LWIP_DEBUGF(SNMP_MIB_DEBUG,("snmp_insert_arpidx_tree() insert failed, mem full"));
1119 
            break;
1120 
          }
1121 
        }
1122 
        else
1123 
        {
1124 
          at_rn = (struct mib_list_rootnode*)at_node->nptr;
1125 
        }
1126 
      }
1127 
    }
1128 
  }
1129 
  /* enable getnext traversal on filled tables */
1130 
  at.maxlength = 1;
1131 
  ipntomtable.maxlength = 1;
1132 
}
1133 
 
1134 
/**
1135 
 * Removes ARP table indexes (.xIfIndex.xNetAddress)
1136 
 * from arp table index trees.
1137 
 */
1138 
void snmp_delete_arpidx_tree(struct netif *ni, struct ip_addr *ip)
1139 
{
1140 
  struct mib_list_rootnode *at_rn, *next, *del_rn[5];
1141 
  struct mib_list_node *at_n, *del_n[5];
1142 
  struct ip_addr hip;
1143 
  s32_t arpidx[5];
1144 
  u8_t fc, tree, level, del_cnt;
1145 
 
1146 
  snmp_netiftoifindex(ni, &arpidx[0]);
1147 
  hip.addr = ntohl(ip->addr);
1148 
  snmp_iptooid(&hip, &arpidx[1]);
1149 
 
1150 
  for (tree = 0; tree < 2; tree++)
1151 
  {
1152 
    /* mark nodes for deletion */
1153 
    if (tree == 0)
1154 
    {
1155 
      at_rn = &arptree_root;
1156 
    }
1157 
    else
1158 
    {
1159 
      at_rn = &ipntomtree_root;
1160 
    }
1161 
    level = 0;
1162 
    del_cnt = 0;
1163 
    while ((level < 5) && (at_rn != NULL))
1164 
    {
1165 
      fc = snmp_mib_node_find(at_rn, arpidx[level], &at_n);
1166 
      if (fc == 0)
1167 
      {
1168 
        /* arpidx[level] does not exist */
1169 
        del_cnt = 0;
1170 
        at_rn = NULL;
1171 
      }
1172 
      else if (fc == 1)
1173 
      {
1174 
        del_rn[del_cnt] = at_rn;
1175 
        del_n[del_cnt] = at_n;
1176 
        del_cnt++;
1177 
        at_rn = (struct mib_list_rootnode*)(at_n->nptr);
1178 
      }
1179 
      else if (fc == 2)
1180 
      {
1181 
        /* reset delete (2 or more childs) */
1182 
        del_cnt = 0;
1183 
        at_rn = (struct mib_list_rootnode*)(at_n->nptr);
1184 
      }
1185 
      level++;
1186 
    }
1187 
    /* delete marked index nodes */
1188 
    while (del_cnt > 0)
1189 
    {
1190 
      del_cnt--;
1191 
 
1192 
      at_rn = del_rn[del_cnt];
1193 
      at_n = del_n[del_cnt];
1194 
 
1195 
      next = snmp_mib_node_delete(at_rn, at_n);
1196 
      if (next != NULL)
1197 
      {
1198 
        LWIP_ASSERT("next_count == 0",next->count == 0);
1199 
        snmp_mib_lrn_free(next);
1200 
      }
1201 
    }
1202 
  }
1203 
  /* disable getnext traversal on empty tables */
1204 
  if(arptree_root.count == 0) at.maxlength = 0;
1205 
  if(ipntomtree_root.count == 0) ipntomtable.maxlength = 0;
1206 
}
1207 
 
1208 
void snmp_inc_ipinreceives(void)
1209 
{
1210 
  ipinreceives++;
1211 
}
1212 
 
1213 
void snmp_inc_ipinhdrerrors(void)
1214 
{
1215 
  ipinhdrerrors++;
1216 
}
1217 
 
1218 
void snmp_inc_ipinaddrerrors(void)
1219 
{
1220 
  ipinaddrerrors++;
1221 
}
1222 
 
1223 
void snmp_inc_ipforwdatagrams(void)
1224 
{
1225 
  ipforwdatagrams++;
1226 
}
1227 
 
1228 
void snmp_inc_ipinunknownprotos(void)
1229 
{
1230 
  ipinunknownprotos++;
1231 
}
1232 
 
1233 
void snmp_inc_ipindiscards(void)
1234 
{
1235 
  ipindiscards++;
1236 
}
1237 
 
1238 
void snmp_inc_ipindelivers(void)
1239 
{
1240 
  ipindelivers++;
1241 
}
1242 
 
1243 
void snmp_inc_ipoutrequests(void)
1244 
{
1245 
  ipoutrequests++;
1246 
}
1247 
 
1248 
void snmp_inc_ipoutdiscards(void)
1249 
{
1250 
  ipoutdiscards++;
1251 
}
1252 
 
1253 
void snmp_inc_ipoutnoroutes(void)
1254 
{
1255 
  ipoutnoroutes++;
1256 
}
1257 
 
1258 
void snmp_inc_ipreasmreqds(void)
1259 
{
1260 
  ipreasmreqds++;
1261 
}
1262 
 
1263 
void snmp_inc_ipreasmoks(void)
1264 
{
1265 
  ipreasmoks++;
1266 
}
1267 
 
1268 
void snmp_inc_ipreasmfails(void)
1269 
{
1270 
  ipreasmfails++;
1271 
}
1272 
 
1273 
void snmp_inc_ipfragoks(void)
1274 
{
1275 
  ipfragoks++;
1276 
}
1277 
 
1278 
void snmp_inc_ipfragfails(void)
1279 
{
1280 
  ipfragfails++;
1281 
}
1282 
 
1283 
void snmp_inc_ipfragcreates(void)
1284 
{
1285 
  ipfragcreates++;
1286 
}
1287 
 
1288 
void snmp_inc_iproutingdiscards(void)
1289 
{
1290 
  iproutingdiscards++;
1291 
}
1292 
 
1293 
/**
1294 
 * Inserts ipAddrTable indexes (.ipAdEntAddr)
1295 
 * into index tree.
1296 
 */
1297 
void snmp_insert_ipaddridx_tree(struct netif *ni)
1298 
{
1299 
  struct mib_list_rootnode *ipa_rn;
1300 
  struct mib_list_node *ipa_node;
1301 
  struct ip_addr ip;
1302 
  s32_t ipaddridx[4];
1303 
  u8_t level;
1304 
 
1305 
  LWIP_ASSERT("ni != NULL", ni != NULL);
1306 
  ip.addr = ntohl(ni->ip_addr.addr);
1307 
  snmp_iptooid(&ip, &ipaddridx[0]);
1308 
 
1309 
  level = 0;
1310 
  ipa_rn = &ipaddrtree_root;
1311 
  while (level < 4)
1312 
  {
1313 
    ipa_node = NULL;
1314 
    snmp_mib_node_insert(ipa_rn, ipaddridx[level], &ipa_node);
1315 
    if ((level != 3) && (ipa_node != NULL))
1316 
    {
1317 
      if (ipa_node->nptr == NULL)
1318 
      {
1319 
        ipa_rn = snmp_mib_lrn_alloc();
1320 
        ipa_node->nptr = (struct mib_node*)ipa_rn;
1321 
        if (ipa_rn != NULL)
1322 
        {
1323 
          if (level == 2)
1324 
          {
1325 
            ipa_rn->get_object_def = ip_addrentry_get_object_def;
1326 
            ipa_rn->get_value = ip_addrentry_get_value;
1327 
            ipa_rn->set_test = noleafs_set_test;
1328 
            ipa_rn->set_value = noleafs_set_value;
1329 
          }
1330 
        }
1331 
        else
1332 
        {
1333 
          /* ipa_rn == NULL, malloc failure */
1334 
          LWIP_DEBUGF(SNMP_MIB_DEBUG,("snmp_insert_ipaddridx_tree() insert failed, mem full"));
1335 
          break;
1336 
        }
1337 
      }
1338 
      else
1339 
      {
1340 
        ipa_rn = (struct mib_list_rootnode*)ipa_node->nptr;
1341 
      }
1342 
    }
1343 
    level++;
1344 
  }
1345 
  /* enable getnext traversal on filled table */
1346 
  ipaddrtable.maxlength = 1;
1347 
}
1348 
 
1349 
/**
1350 
 * Removes ipAddrTable indexes (.ipAdEntAddr)
1351 
 * from index tree.
1352 
 */
1353 
void snmp_delete_ipaddridx_tree(struct netif *ni)
1354 
{
1355 
  struct mib_list_rootnode *ipa_rn, *next, *del_rn[4];
1356 
  struct mib_list_node *ipa_n, *del_n[4];
1357 
  struct ip_addr ip;
1358 
  s32_t ipaddridx[4];
1359 
  u8_t fc, level, del_cnt;
1360 
 
1361 
  LWIP_ASSERT("ni != NULL", ni != NULL);
1362 
  ip.addr = ntohl(ni->ip_addr.addr);
1363 
  snmp_iptooid(&ip, &ipaddridx[0]);
1364 
 
1365 
  /* mark nodes for deletion */
1366 
  level = 0;
1367 
  del_cnt = 0;
1368 
  ipa_rn = &ipaddrtree_root;
1369 
  while ((level < 4) && (ipa_rn != NULL))
1370 
  {
1371 
    fc = snmp_mib_node_find(ipa_rn, ipaddridx[level], &ipa_n);
1372 
    if (fc == 0)
1373 
    {
1374 
      /* ipaddridx[level] does not exist */
1375 
      del_cnt = 0;
1376 
      ipa_rn = NULL;
1377 
    }
1378 
    else if (fc == 1)
1379 
    {
1380 
      del_rn[del_cnt] = ipa_rn;
1381 
      del_n[del_cnt] = ipa_n;
1382 
      del_cnt++;
1383 
      ipa_rn = (struct mib_list_rootnode*)(ipa_n->nptr);
1384 
    }
1385 
    else if (fc == 2)
1386 
    {
1387 
      /* reset delete (2 or more childs) */
1388 
      del_cnt = 0;
1389 
      ipa_rn = (struct mib_list_rootnode*)(ipa_n->nptr);
1390 
    }
1391 
    level++;
1392 
  }
1393 
  /* delete marked index nodes */
1394 
  while (del_cnt > 0)
1395 
  {
1396 
    del_cnt--;
1397 
 
1398 
    ipa_rn = del_rn[del_cnt];
1399 
    ipa_n = del_n[del_cnt];
1400 
 
1401 
    next = snmp_mib_node_delete(ipa_rn, ipa_n);
1402 
    if (next != NULL)
1403 
    {
1404 
      LWIP_ASSERT("next_count == 0",next->count == 0);
1405 
      snmp_mib_lrn_free(next);
1406 
    }
1407 
  }
1408 
  /* disable getnext traversal on empty table */
1409 
  if (ipaddrtree_root.count == 0) ipaddrtable.maxlength = 0;
1410 
}
1411 
 
1412 
/**
1413 
 * Inserts ipRouteTable indexes (.ipRouteDest)
1414 
 * into index tree.
1415 
 *
1416 
 * @param dflt non-zero for the default rte, zero for network rte
1417 
 * @param netif points to network interface for this rte
1418 
 *
1419 
 * @todo record sysuptime for _this_ route when it is installed
1420 
 *   (needed for ipRouteAge) in the netif.
1421 
 */
1422 
void snmp_insert_iprteidx_tree(u8_t dflt, struct netif *ni)
1423 
{
1424 
  u8_t insert = 0;
1425 
  struct ip_addr dst;
1426 
 
1427 
  if (dflt != 0)
1428 
  {
1429 
    /* the default route 0.0.0.0 */
1430 
    dst.addr = 0;
1431 
    insert = 1;
1432 
  }
1433 
  else
1434 
  {
1435 
    /* route to the network address */
1436 
    dst.addr = ntohl(ni->ip_addr.addr & ni->netmask.addr);
1437 
    /* exclude 0.0.0.0 network (reserved for default rte) */
1438 
    if (dst.addr != 0) insert = 1;
1439 
  }
1440 
  if (insert)
1441 
  {
1442 
    struct mib_list_rootnode *iprte_rn;
1443 
    struct mib_list_node *iprte_node;
1444 
    s32_t iprteidx[4];
1445 
    u8_t level;
1446 
 
1447 
    snmp_iptooid(&dst, &iprteidx[0]);
1448 
    level = 0;
1449 
    iprte_rn = &iprtetree_root;
1450 
    while (level < 4)
1451 
    {
1452 
      iprte_node = NULL;
1453 
      snmp_mib_node_insert(iprte_rn, iprteidx[level], &iprte_node);
1454 
      if ((level != 3) && (iprte_node != NULL))
1455 
      {
1456 
        if (iprte_node->nptr == NULL)
1457 
        {
1458 
          iprte_rn = snmp_mib_lrn_alloc();
1459 
          iprte_node->nptr = (struct mib_node*)iprte_rn;
1460 
          if (iprte_rn != NULL)
1461 
          {
1462 
            if (level == 2)
1463 
            {
1464 
              iprte_rn->get_object_def = ip_rteentry_get_object_def;
1465 
              iprte_rn->get_value = ip_rteentry_get_value;
1466 
              iprte_rn->set_test = noleafs_set_test;
1467 
              iprte_rn->set_value = noleafs_set_value;
1468 
            }
1469 
          }
1470 
          else
1471 
          {
1472 
            /* iprte_rn == NULL, malloc failure */
1473 
            LWIP_DEBUGF(SNMP_MIB_DEBUG,("snmp_insert_iprteidx_tree() insert failed, mem full"));
1474 
            break;
1475 
          }
1476 
        }
1477 
        else
1478 
        {
1479 
          iprte_rn = (struct mib_list_rootnode*)iprte_node->nptr;
1480 
        }
1481 
      }
1482 
      level++;
1483 
    }
1484 
  }
1485 
  /* enable getnext traversal on filled table */
1486 
  iprtetable.maxlength = 1;
1487 
}
1488 
 
1489 
/**
1490 
 * Removes ipRouteTable indexes (.ipRouteDest)
1491 
 * from index tree.
1492 
 *
1493 
 * @param dflt non-zero for the default rte, zero for network rte
1494 
 * @param netif points to network interface for this rte or NULL
1495 
 *   for default route to be removed.
1496 
 */
1497 
void snmp_delete_iprteidx_tree(u8_t dflt, struct netif *ni)
1498 
{
1499 
  u8_t delete = 0;
1500 
  struct ip_addr dst;
1501 
 
1502 
  if (dflt != 0)
1503 
  {
1504 
    /* the default route 0.0.0.0 */
1505 
    dst.addr = 0;
1506 
    delete = 1;
1507 
  }
1508 
  else
1509 
  {
1510 
    /* route to the network address */
1511 
    dst.addr = ntohl(ni->ip_addr.addr & ni->netmask.addr);
1512 
    /* exclude 0.0.0.0 network (reserved for default rte) */
1513 
    if (dst.addr != 0) delete = 1;
1514 
  }
1515 
  if (delete)
1516 
  {
1517 
    struct mib_list_rootnode *iprte_rn, *next, *del_rn[4];
1518 
    struct mib_list_node *iprte_n, *del_n[4];
1519 
    s32_t iprteidx[4];
1520 
    u8_t fc, level, del_cnt;
1521 
 
1522 
    snmp_iptooid(&dst, &iprteidx[0]);
1523 
    /* mark nodes for deletion */
1524 
    level = 0;
1525 
    del_cnt = 0;
1526 
    iprte_rn = &iprtetree_root;
1527 
    while ((level < 4) && (iprte_rn != NULL))
1528 
    {
1529 
      fc = snmp_mib_node_find(iprte_rn, iprteidx[level], &iprte_n);
1530 
      if (fc == 0)
1531 
      {
1532 
        /* iprteidx[level] does not exist */
1533 
        del_cnt = 0;
1534 
        iprte_rn = NULL;
1535 
      }
1536 
      else if (fc == 1)
1537 
      {
1538 
        del_rn[del_cnt] = iprte_rn;
1539 
        del_n[del_cnt] = iprte_n;
1540 
        del_cnt++;
1541 
        iprte_rn = (struct mib_list_rootnode*)(iprte_n->nptr);
1542 
      }
1543 
      else if (fc == 2)
1544 
      {
1545 
        /* reset delete (2 or more childs) */
1546 
        del_cnt = 0;
1547 
        iprte_rn = (struct mib_list_rootnode*)(iprte_n->nptr);
1548 
      }
1549 
      level++;
1550 
    }
1551 
    /* delete marked index nodes */
1552 
    while (del_cnt > 0)
1553 
    {
1554 
      del_cnt--;
1555 
 
1556 
      iprte_rn = del_rn[del_cnt];
1557 
      iprte_n = del_n[del_cnt];
1558 
 
1559 
      next = snmp_mib_node_delete(iprte_rn, iprte_n);
1560 
      if (next != NULL)
1561 
      {
1562 
        LWIP_ASSERT("next_count == 0",next->count == 0);
1563 
        snmp_mib_lrn_free(next);
1564 
      }
1565 
    }
1566 
  }
1567 
  /* disable getnext traversal on empty table */
1568 
  if (iprtetree_root.count == 0) iprtetable.maxlength = 0;
1569 
}
1570 
 
1571 
 
1572 
void snmp_inc_icmpinmsgs(void)
1573 
{
1574 
  icmpinmsgs++;
1575 
}
1576 
 
1577 
void snmp_inc_icmpinerrors(void)
1578 
{
1579 
  icmpinerrors++;
1580 
}
1581 
 
1582 
void snmp_inc_icmpindestunreachs(void)
1583 
{
1584 
  icmpindestunreachs++;
1585 
}
1586 
 
1587 
void snmp_inc_icmpintimeexcds(void)
1588 
{
1589 
  icmpintimeexcds++;
1590 
}
1591 
 
1592 
void snmp_inc_icmpinparmprobs(void)
1593 
{
1594 
  icmpinparmprobs++;
1595 
}
1596 
 
1597 
void snmp_inc_icmpinsrcquenchs(void)
1598 
{
1599 
  icmpinsrcquenchs++;
1600 
}
1601 
 
1602 
void snmp_inc_icmpinredirects(void)
1603 
{
1604 
  icmpinredirects++;
1605 
}
1606 
 
1607 
void snmp_inc_icmpinechos(void)
1608 
{
1609 
  icmpinechos++;
1610 
}
1611 
 
1612 
void snmp_inc_icmpinechoreps(void)
1613 
{
1614 
  icmpinechoreps++;
1615 
}
1616 
 
1617 
void snmp_inc_icmpintimestamps(void)
1618 
{
1619 
  icmpintimestamps++;
1620 
}
1621 
 
1622 
void snmp_inc_icmpintimestampreps(void)
1623 
{
1624 
  icmpintimestampreps++;
1625 
}
1626 
 
1627 
void snmp_inc_icmpinaddrmasks(void)
1628 
{
1629 
  icmpinaddrmasks++;
1630 
}
1631 
 
1632 
void snmp_inc_icmpinaddrmaskreps(void)
1633 
{
1634 
  icmpinaddrmaskreps++;
1635 
}
1636 
 
1637 
void snmp_inc_icmpoutmsgs(void)
1638 
{
1639 
  icmpoutmsgs++;
1640 
}
1641 
 
1642 
void snmp_inc_icmpouterrors(void)
1643 
{
1644 
  icmpouterrors++;
1645 
}
1646 
 
1647 
void snmp_inc_icmpoutdestunreachs(void)
1648 
{
1649 
  icmpoutdestunreachs++;
1650 
}
1651 
 
1652 
void snmp_inc_icmpouttimeexcds(void)
1653 
{
1654 
  icmpouttimeexcds++;
1655 
}
1656 
 
1657 
void snmp_inc_icmpoutparmprobs(void)
1658 
{
1659 
  icmpoutparmprobs++;
1660 
}
1661 
 
1662 
void snmp_inc_icmpoutsrcquenchs(void)
1663 
{
1664 
  icmpoutsrcquenchs++;
1665 
}
1666 
 
1667 
void snmp_inc_icmpoutredirects(void)
1668 
{
1669 
  icmpoutredirects++;
1670 
}
1671 
 
1672 
void snmp_inc_icmpoutechos(void)
1673 
{
1674 
  icmpoutechos++;
1675 
}
1676 
 
1677 
void snmp_inc_icmpoutechoreps(void)
1678 
{
1679 
  icmpoutechoreps++;
1680 
}
1681 
 
1682 
void snmp_inc_icmpouttimestamps(void)
1683 
{
1684 
  icmpouttimestamps++;
1685 
}
1686 
 
1687 
void snmp_inc_icmpouttimestampreps(void)
1688 
{
1689 
  icmpouttimestampreps++;
1690 
}
1691 
 
1692 
void snmp_inc_icmpoutaddrmasks(void)
1693 
{
1694 
  icmpoutaddrmasks++;
1695 
}
1696 
 
1697 
void snmp_inc_icmpoutaddrmaskreps(void)
1698 
{
1699 
  icmpoutaddrmaskreps++;
1700 
}
1701 
 
1702 
void snmp_inc_tcpactiveopens(void)
1703 
{
1704 
  tcpactiveopens++;
1705 
}
1706 
 
1707 
void snmp_inc_tcppassiveopens(void)
1708 
{
1709 
  tcppassiveopens++;
1710 
}
1711 
 
1712 
void snmp_inc_tcpattemptfails(void)
1713 
{
1714 
  tcpattemptfails++;
1715 
}
1716 
 
1717 
void snmp_inc_tcpestabresets(void)
1718 
{
1719 
  tcpestabresets++;
1720 
}
1721 
 
1722 
void snmp_inc_tcpinsegs(void)
1723 
{
1724 
  tcpinsegs++;
1725 
}
1726 
 
1727 
void snmp_inc_tcpoutsegs(void)
1728 
{
1729 
  tcpoutsegs++;
1730 
}
1731 
 
1732 
void snmp_inc_tcpretranssegs(void)
1733 
{
1734 
  tcpretranssegs++;
1735 
}
1736 
 
1737 
void snmp_inc_tcpinerrs(void)
1738 
{
1739 
  tcpinerrs++;
1740 
}
1741 
 
1742 
void snmp_inc_tcpoutrsts(void)
1743 
{
1744 
  tcpoutrsts++;
1745 
}
1746 
 
1747 
void snmp_inc_udpindatagrams(void)
1748 
{
1749 
  udpindatagrams++;
1750 
}
1751 
 
1752 
void snmp_inc_udpnoports(void)
1753 
{
1754 
  udpnoports++;
1755 
}
1756 
 
1757 
void snmp_inc_udpinerrors(void)
1758 
{
1759 
  udpinerrors++;
1760 
}
1761 
 
1762 
void snmp_inc_udpoutdatagrams(void)
1763 
{
1764 
  udpoutdatagrams++;
1765 
}
1766 
 
1767 
/**
1768 
 * Inserts udpTable indexes (.udpLocalAddress.udpLocalPort)
1769 
 * into index tree.
1770 
 */
1771 
void snmp_insert_udpidx_tree(struct udp_pcb *pcb)
1772 
{
1773 
  struct mib_list_rootnode *udp_rn;
1774 
  struct mib_list_node *udp_node;
1775 
  struct ip_addr ip;
1776 
  s32_t udpidx[5];
1777 
  u8_t level;
1778 
 
1779 
  LWIP_ASSERT("pcb != NULL", pcb != NULL);
1780 
  ip.addr = ntohl(pcb->local_ip.addr);
1781 
  snmp_iptooid(&ip, &udpidx[0]);
1782 
  udpidx[4] = pcb->local_port;
1783 
 
1784 
  udp_rn = &udp_root;
1785 
  for (level = 0; level < 5; level++)
1786 
  {
1787 
    udp_node = NULL;
1788 
    snmp_mib_node_insert(udp_rn, udpidx[level], &udp_node);
1789 
    if ((level != 4) && (udp_node != NULL))
1790 
    {
1791 
      if (udp_node->nptr == NULL)
1792 
      {
1793 
        udp_rn = snmp_mib_lrn_alloc();
1794 
        udp_node->nptr = (struct mib_node*)udp_rn;
1795 
        if (udp_rn != NULL)
1796 
        {
1797 
          if (level == 3)
1798 
          {
1799 
            udp_rn->get_object_def = udpentry_get_object_def;
1800 
            udp_rn->get_value = udpentry_get_value;
1801 
            udp_rn->set_test = noleafs_set_test;
1802 
            udp_rn->set_value = noleafs_set_value;
1803 
          }
1804 
        }
1805 
        else
1806 
        {
1807 
          /* udp_rn == NULL, malloc failure */
1808 
          LWIP_DEBUGF(SNMP_MIB_DEBUG,("snmp_insert_udpidx_tree() insert failed, mem full"));
1809 
          break;
1810 
        }
1811 
      }
1812 
      else
1813 
      {
1814 
        udp_rn = (struct mib_list_rootnode*)udp_node->nptr;
1815 
      }
1816 
    }
1817 
  }
1818 
  udptable.maxlength = 1;
1819 
}
1820 
 
1821 
/**
1822 
 * Removes udpTable indexes (.udpLocalAddress.udpLocalPort)
1823 
 * from index tree.
1824 
 */
1825 
void snmp_delete_udpidx_tree(struct udp_pcb *pcb)
1826 
{
1827 
  struct mib_list_rootnode *udp_rn, *next, *del_rn[5];
1828 
  struct mib_list_node *udp_n, *del_n[5];
1829 
  struct ip_addr ip;
1830 
  s32_t udpidx[5];
1831 
  u8_t bindings, fc, level, del_cnt;
1832 
 
1833 
  LWIP_ASSERT("pcb != NULL", pcb != NULL);
1834 
  ip.addr = ntohl(pcb->local_ip.addr);
1835 
  snmp_iptooid(&ip, &udpidx[0]);
1836 
  udpidx[4] = pcb->local_port;
1837 
 
1838 
  /* count PCBs for a given binding
1839 
     (e.g. when reusing ports or for temp output PCBs) */
1840 
  bindings = 0;
1841 
  pcb = udp_pcbs;
1842 
  while ((pcb != NULL))
1843 
  {
1844 
    if ((pcb->local_ip.addr == ip.addr) &&
1845 
        (pcb->local_port == udpidx[4]))
1846 
    {
1847 
      bindings++;
1848 
    }
1849 
    pcb = pcb->next;
1850 
  }
1851 
  if (bindings == 1)
1852 
  {
1853 
    /* selectively remove */
1854 
    /* mark nodes for deletion */
1855 
    level = 0;
1856 
    del_cnt = 0;
1857 
    udp_rn = &udp_root;
1858 
    while ((level < 5) && (udp_rn != NULL))
1859 
    {
1860 
      fc = snmp_mib_node_find(udp_rn, udpidx[level], &udp_n);
1861 
      if (fc == 0)
1862 
      {
1863 
        /* udpidx[level] does not exist */
1864 
        del_cnt = 0;
1865 
        udp_rn = NULL;
1866 
      }
1867 
      else if (fc == 1)
1868 
      {
1869 
        del_rn[del_cnt] = udp_rn;
1870 
        del_n[del_cnt] = udp_n;
1871 
        del_cnt++;
1872 
        udp_rn = (struct mib_list_rootnode*)(udp_n->nptr);
1873 
      }
1874 
      else if (fc == 2)
1875 
      {
1876 
        /* reset delete (2 or more childs) */
1877 
        del_cnt = 0;
1878 
        udp_rn = (struct mib_list_rootnode*)(udp_n->nptr);
1879 
      }
1880 
      level++;
1881 
    }
1882 
    /* delete marked index nodes */
1883 
    while (del_cnt > 0)
1884 
    {
1885 
      del_cnt--;
1886 
 
1887 
      udp_rn = del_rn[del_cnt];
1888 
      udp_n = del_n[del_cnt];
1889 
 
1890 
      next = snmp_mib_node_delete(udp_rn, udp_n);
1891 
      if (next != NULL)
1892 
      {
1893 
        LWIP_ASSERT("next_count == 0",next->count == 0);
1894 
        snmp_mib_lrn_free(next);
1895 
      }
1896 
    }
1897 
  }
1898 
  /* disable getnext traversal on empty table */
1899 
  if (udp_root.count == 0) udptable.maxlength = 0;
1900 
}
1901 
 
1902 
 
1903 
void snmp_inc_snmpinpkts(void)
1904 
{
1905 
  snmpinpkts++;
1906 
}
1907 
 
1908 
void snmp_inc_snmpoutpkts(void)
1909 
{
1910 
  snmpoutpkts++;
1911 
}
1912 
 
1913 
void snmp_inc_snmpinbadversions(void)
1914 
{
1915 
  snmpinbadversions++;
1916 
}
1917 
 
1918 
void snmp_inc_snmpinbadcommunitynames(void)
1919 
{
1920 
  snmpinbadcommunitynames++;
1921 
}
1922 
 
1923 
void snmp_inc_snmpinbadcommunityuses(void)
1924 
{
1925 
  snmpinbadcommunityuses++;
1926 
}
1927 
 
1928 
void snmp_inc_snmpinasnparseerrs(void)
1929 
{
1930 
  snmpinasnparseerrs++;
1931 
}
1932 
 
1933 
void snmp_inc_snmpintoobigs(void)
1934 
{
1935 
  snmpintoobigs++;
1936 
}
1937 
 
1938 
void snmp_inc_snmpinnosuchnames(void)
1939 
{
1940 
  snmpinnosuchnames++;
1941 
}
1942 
 
1943 
void snmp_inc_snmpinbadvalues(void)
1944 
{
1945 
  snmpinbadvalues++;
1946 
}
1947 
 
1948 
void snmp_inc_snmpinreadonlys(void)
1949 
{
1950 
  snmpinreadonlys++;
1951 
}
1952 
 
1953 
void snmp_inc_snmpingenerrs(void)
1954 
{
1955 
  snmpingenerrs++;
1956 
}
1957 
 
1958 
void snmp_add_snmpintotalreqvars(u8_t value)
1959 
{
1960 
  snmpintotalreqvars += value;
1961 
}
1962 
 
1963 
void snmp_add_snmpintotalsetvars(u8_t value)
1964 
{
1965 
  snmpintotalsetvars += value;
1966 
}
1967 
 
1968 
void snmp_inc_snmpingetrequests(void)
1969 
{
1970 
  snmpingetrequests++;
1971 
}
1972 
 
1973 
void snmp_inc_snmpingetnexts(void)
1974 
{
1975 
  snmpingetnexts++;
1976 
}
1977 
 
1978 
void snmp_inc_snmpinsetrequests(void)
1979 
{
1980 
  snmpinsetrequests++;
1981 
}
1982 
 
1983 
void snmp_inc_snmpingetresponses(void)
1984 
{
1985 
  snmpingetresponses++;
1986 
}
1987 
 
1988 
void snmp_inc_snmpintraps(void)
1989 
{
1990 
  snmpintraps++;
1991 
}
1992 
 
1993 
void snmp_inc_snmpouttoobigs(void)
1994 
{
1995 
  snmpouttoobigs++;
1996 
}
1997 
 
1998 
void snmp_inc_snmpoutnosuchnames(void)
1999 
{
2000 
  snmpoutnosuchnames++;
2001 
}
2002 
 
2003 
void snmp_inc_snmpoutbadvalues(void)
2004 
{
2005 
  snmpoutbadvalues++;
2006 
}
2007 
 
2008 
void snmp_inc_snmpoutgenerrs(void)
2009 
{
2010 
  snmpoutgenerrs++;
2011 
}
2012 
 
2013 
void snmp_inc_snmpoutgetrequests(void)
2014 
{
2015 
  snmpoutgetrequests++;
2016 
}
2017 
 
2018 
void snmp_inc_snmpoutgetnexts(void)
2019 
{
2020 
  snmpoutgetnexts++;
2021 
}
2022 
 
2023 
void snmp_inc_snmpoutsetrequests(void)
2024 
{
2025 
  snmpoutsetrequests++;
2026 
}
2027 
 
2028 
void snmp_inc_snmpoutgetresponses(void)
2029 
{
2030 
  snmpoutgetresponses++;
2031 
}
2032 
 
2033 
void snmp_inc_snmpouttraps(void)
2034 
{
2035 
  snmpouttraps++;
2036 
}
2037 
 
2038 
void snmp_get_snmpgrpid_ptr(struct snmp_obj_id **oid)
2039 
{
2040 
  *oid = &snmpgrp_id;
2041 
}
2042 
 
2043 
void snmp_set_snmpenableauthentraps(u8_t *value)
2044 
{
2045 
  if (value != NULL)
2046 
  {
2047 
    snmpenableauthentraps_ptr = value;
2048 
  }
2049 
}
2050 
 
2051 
void snmp_get_snmpenableauthentraps(u8_t *value)
2052 
{
2053 
  *value = *snmpenableauthentraps_ptr;
2054 
}
2055 
 
2056 
void
2057 
noleafs_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
2058 
{
2059 
  if (ident_len){}
2060 
  if (ident){}
2061 
  od->instance = MIB_OBJECT_NONE;
2062 
}
2063 
 
2064 
void
2065 
noleafs_get_value(struct obj_def *od, u16_t len, void *value)
2066 
{
2067 
  if (od){}
2068 
  if (len){}
2069 
  if (value){}
2070 
}
2071 
 
2072 
u8_t
2073 
noleafs_set_test(struct obj_def *od, u16_t len, void *value)
2074 
{
2075 
  if (od){}
2076 
  if (len){}
2077 
  if (value){}
2078 
  /* can't set */
2079 
  return 0;
2080 
}
2081 
 
2082 
void
2083 
noleafs_set_value(struct obj_def *od, u16_t len, void *value)
2084 
{
2085 
  if (od){}
2086 
  if (len){}
2087 
  if (value){}
2088 
}
2089 
 
2090 
 
2091 
/**
2092 
 * Returns systems object definitions.
2093 
 *
2094 
 * @param ident_len the address length (2)
2095 
 * @param ident points to objectname.0 (object id trailer)
2096 
 * @param od points to object definition.
2097 
 */
2098 
static void
2099 
system_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
2100 
{
2101 
  u8_t id;
2102 
 
2103 
  /* return to object name, adding index depth (1) */
2104 
  ident_len += 1;
2105 
  ident -= 1;
2106 
  if (ident_len == 2)
2107 
  {
2108 
    od->id_inst_len = ident_len;
2109 
    od->id_inst_ptr = ident;
2110 
 
2111 
    id = ident[0];
2112 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("get_object_def system.%"U16_F".0\n",(u16_t)id));
2113 
    switch (id)
2114 
    {
2115 
      case 1: /* sysDescr */
2116 
        od->instance = MIB_OBJECT_SCALAR;
2117 
        od->access = MIB_OBJECT_READ_ONLY;
2118 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
2119 
        od->v_len = *sysdescr_len_ptr;
2120 
        break;
2121 
      case 2: /* sysObjectID */
2122 
        od->instance = MIB_OBJECT_SCALAR;
2123 
        od->access = MIB_OBJECT_READ_ONLY;
2124 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID);
2125 
        od->v_len = sysobjid.len * sizeof(s32_t);
2126 
        break;
2127 
      case 3: /* sysUpTime */
2128 
        od->instance = MIB_OBJECT_SCALAR;
2129 
        od->access = MIB_OBJECT_READ_ONLY;
2130 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_TIMETICKS);
2131 
        od->v_len = sizeof(u32_t);
2132 
        break;
2133 
      case 4: /* sysContact */
2134 
        od->instance = MIB_OBJECT_SCALAR;
2135 
        od->access = MIB_OBJECT_READ_WRITE;
2136 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
2137 
        od->v_len = *syscontact_len_ptr;
2138 
        break;
2139 
      case 5: /* sysName */
2140 
        od->instance = MIB_OBJECT_SCALAR;
2141 
        od->access = MIB_OBJECT_READ_WRITE;
2142 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
2143 
        od->v_len = *sysname_len_ptr;
2144 
        break;
2145 
      case 6: /* sysLocation */
2146 
        od->instance = MIB_OBJECT_SCALAR;
2147 
        od->access = MIB_OBJECT_READ_WRITE;
2148 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
2149 
        od->v_len = *syslocation_len_ptr;
2150 
        break;
2151 
      case 7: /* sysServices */
2152 
        od->instance = MIB_OBJECT_SCALAR;
2153 
        od->access = MIB_OBJECT_READ_ONLY;
2154 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2155 
        od->v_len = sizeof(s32_t);
2156 
        break;
2157 
      default:
2158 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("system_get_object_def: no such object\n"));
2159 
        od->instance = MIB_OBJECT_NONE;
2160 
        break;
2161 
    };
2162 
  }
2163 
  else
2164 
  {
2165 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("system_get_object_def: no scalar\n"));
2166 
    od->instance = MIB_OBJECT_NONE;
2167 
  }
2168 
}
2169 
 
2170 
/**
2171 
 * Returns system object value.
2172 
 *
2173 
 * @param ident_len the address length (2)
2174 
 * @param ident points to objectname.0 (object id trailer)
2175 
 * @param len return value space (in bytes)
2176 
 * @param value points to (varbind) space to copy value into.
2177 
 */
2178 
static void
2179 
system_get_value(struct obj_def *od, u16_t len, void *value)
2180 
{
2181 
  u8_t id;
2182 
 
2183 
  id = od->id_inst_ptr[0];
2184 
  switch (id)
2185 
  {
2186 
    case 1: /* sysDescr */
2187 
      ocstrncpy(value,sysdescr_ptr,len);
2188 
      break;
2189 
    case 2: /* sysObjectID */
2190 
      objectidncpy((s32_t*)value,(s32_t*)sysobjid.id,len / sizeof(s32_t));
2191 
      break;
2192 
    case 3: /* sysUpTime */
2193 
      {
2194 
        u32_t *uint_ptr = value;
2195 
        *uint_ptr = sysuptime;
2196 
      }
2197 
      break;
2198 
    case 4: /* sysContact */
2199 
      ocstrncpy(value,syscontact_ptr,len);
2200 
      break;
2201 
    case 5: /* sysName */
2202 
      ocstrncpy(value,sysname_ptr,len);
2203 
      break;
2204 
    case 6: /* sysLocation */
2205 
      ocstrncpy(value,syslocation_ptr,len);
2206 
      break;
2207 
    case 7: /* sysServices */
2208 
      {
2209 
        s32_t *sint_ptr = value;
2210 
        *sint_ptr = sysservices;
2211 
      }
2212 
      break;
2213 
  };
2214 
}
2215 
 
2216 
static u8_t
2217 
system_set_test(struct obj_def *od, u16_t len, void *value)
2218 
{
2219 
  u8_t id, set_ok;
2220 
 
2221 
  if (value) {}
2222 
  set_ok = 0;
2223 
  id = od->id_inst_ptr[0];
2224 
  switch (id)
2225 
  {
2226 
    case 4: /* sysContact */
2227 
      if ((syscontact_ptr != syscontact_default) &&
2228 
          (len <= 255))
2229 
      {
2230 
        set_ok = 1;
2231 
      }
2232 
      break;
2233 
    case 5: /* sysName */
2234 
      if ((sysname_ptr != sysname_default) &&
2235 
          (len <= 255))
2236 
      {
2237 
        set_ok = 1;
2238 
      }
2239 
      break;
2240 
    case 6: /* sysLocation */
2241 
      if ((syslocation_ptr != syslocation_default) &&
2242 
          (len <= 255))
2243 
      {
2244 
        set_ok = 1;
2245 
      }
2246 
      break;
2247 
  };
2248 
  return set_ok;
2249 
}
2250 
 
2251 
static void
2252 
system_set_value(struct obj_def *od, u16_t len, void *value)
2253 
{
2254 
  u8_t id;
2255 
 
2256 
  id = od->id_inst_ptr[0];
2257 
  switch (id)
2258 
  {
2259 
    case 4: /* sysContact */
2260 
      ocstrncpy(syscontact_ptr,value,len);
2261 
      *syscontact_len_ptr = len;
2262 
      break;
2263 
    case 5: /* sysName */
2264 
      ocstrncpy(sysname_ptr,value,len);
2265 
      *sysname_len_ptr = len;
2266 
      break;
2267 
    case 6: /* sysLocation */
2268 
      ocstrncpy(syslocation_ptr,value,len);
2269 
      *syslocation_len_ptr = len;
2270 
      break;
2271 
  };
2272 
}
2273 
 
2274 
/**
2275 
 * Returns interfaces.ifnumber object definition.
2276 
 *
2277 
 * @param ident_len the address length (2)
2278 
 * @param ident points to objectname.index
2279 
 * @param od points to object definition.
2280 
 */
2281 
static void
2282 
interfaces_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
2283 
{
2284 
  /* return to object name, adding index depth (1) */
2285 
  ident_len += 1;
2286 
  ident -= 1;
2287 
  if (ident_len == 2)
2288 
  {
2289 
    od->id_inst_len = ident_len;
2290 
    od->id_inst_ptr = ident;
2291 
 
2292 
    od->instance = MIB_OBJECT_SCALAR;
2293 
    od->access = MIB_OBJECT_READ_ONLY;
2294 
    od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2295 
    od->v_len = sizeof(s32_t);
2296 
  }
2297 
  else
2298 
  {
2299 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("interfaces_get_object_def: no scalar\n"));
2300 
    od->instance = MIB_OBJECT_NONE;
2301 
  }
2302 
}
2303 
 
2304 
/**
2305 
 * Returns interfaces.ifnumber object value.
2306 
 *
2307 
 * @param ident_len the address length (2)
2308 
 * @param ident points to objectname.0 (object id trailer)
2309 
 * @param len return value space (in bytes)
2310 
 * @param value points to (varbind) space to copy value into.
2311 
 */
2312 
static void
2313 
interfaces_get_value(struct obj_def *od, u16_t len, void *value)
2314 
{
2315 
  if (len){}
2316 
  if (od->id_inst_ptr[0] == 1)
2317 
  {
2318 
    s32_t *sint_ptr = value;
2319 
    *sint_ptr = iflist_root.count;
2320 
  }
2321 
}
2322 
 
2323 
/**
2324 
 * Returns ifentry object definitions.
2325 
 *
2326 
 * @param ident_len the address length (2)
2327 
 * @param ident points to objectname.index
2328 
 * @param od points to object definition.
2329 
 */
2330 
static void
2331 
ifentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
2332 
{
2333 
  u8_t id;
2334 
 
2335 
  /* return to object name, adding index depth (1) */
2336 
  ident_len += 1;
2337 
  ident -= 1;
2338 
  if (ident_len == 2)
2339 
  {
2340 
    od->id_inst_len = ident_len;
2341 
    od->id_inst_ptr = ident;
2342 
 
2343 
    id = ident[0];
2344 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("get_object_def ifentry.%"U16_F"\n",(u16_t)id));
2345 
    switch (id)
2346 
    {
2347 
      case 1: /* ifIndex */
2348 
      case 3: /* ifType */
2349 
      case 4: /* ifMtu */
2350 
      case 8: /* ifOperStatus */
2351 
        od->instance = MIB_OBJECT_TAB;
2352 
        od->access = MIB_OBJECT_READ_ONLY;
2353 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2354 
        od->v_len = sizeof(s32_t);
2355 
        break;
2356 
      case 2: /* ifDescr */
2357 
        od->instance = MIB_OBJECT_TAB;
2358 
        od->access = MIB_OBJECT_READ_ONLY;
2359 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
2360 
        /** @todo this should be some sort of sizeof(struct netif.name) */
2361 
        od->v_len = 2;
2362 
        break;
2363 
      case 5: /* ifSpeed */
2364 
      case 21: /* ifOutQLen */
2365 
        od->instance = MIB_OBJECT_TAB;
2366 
        od->access = MIB_OBJECT_READ_ONLY;
2367 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_GAUGE);
2368 
        od->v_len = sizeof(u32_t);
2369 
        break;
2370 
      case 6: /* ifPhysAddress */
2371 
        {
2372 
          struct netif *netif;
2373 
 
2374 
          snmp_ifindextonetif(ident[1], &netif);
2375 
          od->instance = MIB_OBJECT_TAB;
2376 
          od->access = MIB_OBJECT_READ_ONLY;
2377 
          od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
2378 
          od->v_len = netif->hwaddr_len;
2379 
        }
2380 
        break;
2381 
      case 7: /* ifAdminStatus */
2382 
        od->instance = MIB_OBJECT_TAB;
2383 
        od->access = MIB_OBJECT_READ_WRITE;
2384 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2385 
        od->v_len = sizeof(s32_t);
2386 
        break;
2387 
      case 9: /* ifLastChange */
2388 
        od->instance = MIB_OBJECT_TAB;
2389 
        od->access = MIB_OBJECT_READ_ONLY;
2390 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_TIMETICKS);
2391 
        od->v_len = sizeof(u32_t);
2392 
        break;
2393 
      case 10: /* ifInOctets */
2394 
      case 11: /* ifInUcastPkts */
2395 
      case 12: /* ifInNUcastPkts */
2396 
      case 13: /* ifInDiscarts */
2397 
      case 14: /* ifInErrors */
2398 
      case 15: /* ifInUnkownProtos */
2399 
      case 16: /* ifOutOctets */
2400 
      case 17: /* ifOutUcastPkts */
2401 
      case 18: /* ifOutNUcastPkts */
2402 
      case 19: /* ifOutDiscarts */
2403 
      case 20: /* ifOutErrors */
2404 
        od->instance = MIB_OBJECT_TAB;
2405 
        od->access = MIB_OBJECT_READ_ONLY;
2406 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER);
2407 
        od->v_len = sizeof(u32_t);
2408 
        break;
2409 
      case 22: /* ifSpecific */
2410 
        /** @note returning zeroDotZero (0.0) no media specific MIB support */
2411 
        od->instance = MIB_OBJECT_TAB;
2412 
        od->access = MIB_OBJECT_READ_ONLY;
2413 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID);
2414 
        od->v_len = ifspecific.len * sizeof(s32_t);
2415 
        break;
2416 
      default:
2417 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("ifentry_get_object_def: no such object\n"));
2418 
        od->instance = MIB_OBJECT_NONE;
2419 
        break;
2420 
    };
2421 
  }
2422 
  else
2423 
  {
2424 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("ifentry_get_object_def: no scalar\n"));
2425 
    od->instance = MIB_OBJECT_NONE;
2426 
  }
2427 
}
2428 
 
2429 
/**
2430 
 * Returns ifentry object value.
2431 
 *
2432 
 * @param ident_len the address length (2)
2433 
 * @param ident points to objectname.0 (object id trailer)
2434 
 * @param len return value space (in bytes)
2435 
 * @param value points to (varbind) space to copy value into.
2436 
 */
2437 
static void
2438 
ifentry_get_value(struct obj_def *od, u16_t len, void *value)
2439 
{
2440 
  struct netif *netif;
2441 
  u8_t id;
2442 
 
2443 
  snmp_ifindextonetif(od->id_inst_ptr[1], &netif);
2444 
  id = od->id_inst_ptr[0];
2445 
  switch (id)
2446 
  {
2447 
    case 1: /* ifIndex */
2448 
      {
2449 
        s32_t *sint_ptr = value;
2450 
        *sint_ptr = od->id_inst_ptr[1];
2451 
      }
2452 
      break;
2453 
    case 2: /* ifDescr */
2454 
      ocstrncpy(value,(u8_t*)netif->name,len);
2455 
      break;
2456 
    case 3: /* ifType */
2457 
      {
2458 
        s32_t *sint_ptr = value;
2459 
        *sint_ptr = netif->link_type;
2460 
      }
2461 
      break;
2462 
    case 4: /* ifMtu */
2463 
      {
2464 
        s32_t *sint_ptr = value;
2465 
        *sint_ptr = netif->mtu;
2466 
      }
2467 
      break;
2468 
    case 5: /* ifSpeed */
2469 
      {
2470 
        u32_t *uint_ptr = value;
2471 
        *uint_ptr = netif->link_speed;
2472 
      }
2473 
      break;
2474 
    case 6: /* ifPhysAddress */
2475 
      ocstrncpy(value,netif->hwaddr,len);
2476 
      break;
2477 
    case 7: /* ifAdminStatus */
2478 
    case 8: /* ifOperStatus */
2479 
      {
2480 
        s32_t *sint_ptr = value;
2481 
        if (netif_is_up(netif))
2482 
        {
2483 
          *sint_ptr = 1;
2484 
        }
2485 
        else
2486 
        {
2487 
          *sint_ptr = 2;
2488 
        }
2489 
      }
2490 
      break;
2491 
    case 9: /* ifLastChange */
2492 
      {
2493 
        u32_t *uint_ptr = value;
2494 
        *uint_ptr = netif->ts;
2495 
      }
2496 
      break;
2497 
    case 10: /* ifInOctets */
2498 
      {
2499 
        u32_t *uint_ptr = value;
2500 
        *uint_ptr = netif->ifinoctets;
2501 
      }
2502 
      break;
2503 
    case 11: /* ifInUcastPkts */
2504 
      {
2505 
        u32_t *uint_ptr = value;
2506 
        *uint_ptr = netif->ifinucastpkts;
2507 
      }
2508 
      break;
2509 
    case 12: /* ifInNUcastPkts */
2510 
      {
2511 
        u32_t *uint_ptr = value;
2512 
        *uint_ptr = netif->ifinnucastpkts;
2513 
      }
2514 
      break;
2515 
    case 13: /* ifInDiscarts */
2516 
      {
2517 
        u32_t *uint_ptr = value;
2518 
        *uint_ptr = netif->ifindiscards;
2519 
      }
2520 
      break;
2521 
    case 14: /* ifInErrors */
2522 
    case 15: /* ifInUnkownProtos */
2523 
      /** @todo add these counters! */
2524 
      {
2525 
        u32_t *uint_ptr = value;
2526 
        *uint_ptr = 0;
2527 
      }
2528 
      break;
2529 
    case 16: /* ifOutOctets */
2530 
      {
2531 
        u32_t *uint_ptr = value;
2532 
        *uint_ptr = netif->ifoutoctets;
2533 
      }
2534 
      break;
2535 
    case 17: /* ifOutUcastPkts */
2536 
      {
2537 
        u32_t *uint_ptr = value;
2538 
        *uint_ptr = netif->ifoutucastpkts;
2539 
      }
2540 
      break;
2541 
    case 18: /* ifOutNUcastPkts */
2542 
      {
2543 
        u32_t *uint_ptr = value;
2544 
        *uint_ptr = netif->ifoutnucastpkts;
2545 
      }
2546 
      break;
2547 
    case 19: /* ifOutDiscarts */
2548 
      {
2549 
        u32_t *uint_ptr = value;
2550 
        *uint_ptr = netif->ifoutdiscards;
2551 
      }
2552 
      break;
2553 
    case 20: /* ifOutErrors */
2554 
       /** @todo add this counter! */
2555 
      {
2556 
        u32_t *uint_ptr = value;
2557 
        *uint_ptr = 0;
2558 
      }
2559 
      break;
2560 
    case 21: /* ifOutQLen */
2561 
      /** @todo figure out if this must be 0 (no queue) or 1? */
2562 
      {
2563 
        u32_t *uint_ptr = value;
2564 
        *uint_ptr = 0;
2565 
      }
2566 
      break;
2567 
    case 22: /* ifSpecific */
2568 
      objectidncpy((s32_t*)value,(s32_t*)ifspecific.id,len / sizeof(s32_t));
2569 
      break;
2570 
  };
2571 
}
2572 
 
2573 
/**
2574 
 * Returns atentry object definitions.
2575 
 *
2576 
 * @param ident_len the address length (6)
2577 
 * @param ident points to objectname.atifindex.atnetaddress
2578 
 * @param od points to object definition.
2579 
 */
2580 
static void
2581 
atentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
2582 
{
2583 
  /* return to object name, adding index depth (5) */
2584 
  ident_len += 5;
2585 
  ident -= 5;
2586 
 
2587 
  if (ident_len == 6)
2588 
  {
2589 
    od->id_inst_len = ident_len;
2590 
    od->id_inst_ptr = ident;
2591 
 
2592 
    switch (ident[0])
2593 
    {
2594 
      case 1: /* atIfIndex */
2595 
        od->instance = MIB_OBJECT_TAB;
2596 
        od->access = MIB_OBJECT_READ_WRITE;
2597 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2598 
        od->v_len = sizeof(s32_t);
2599 
        break;
2600 
      case 2: /* atPhysAddress */
2601 
        od->instance = MIB_OBJECT_TAB;
2602 
        od->access = MIB_OBJECT_READ_WRITE;
2603 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
2604 
        od->v_len = sizeof(struct eth_addr);
2605 
        break;
2606 
      case 3: /* atNetAddress */
2607 
        od->instance = MIB_OBJECT_TAB;
2608 
        od->access = MIB_OBJECT_READ_WRITE;
2609 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR);
2610 
        od->v_len = 4;
2611 
        break;
2612 
      default:
2613 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("atentry_get_object_def: no such object\n"));
2614 
        od->instance = MIB_OBJECT_NONE;
2615 
        break;
2616 
    }
2617 
  }
2618 
  else
2619 
  {
2620 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("atentry_get_object_def: no scalar\n"));
2621 
    od->instance = MIB_OBJECT_NONE;
2622 
  }
2623 
}
2624 
 
2625 
static void
2626 
atentry_get_value(struct obj_def *od, u16_t len, void *value)
2627 
{
2628 
  u8_t id;
2629 
  struct eth_addr* ethaddr_ret;
2630 
  struct ip_addr* ipaddr_ret;
2631 
  struct ip_addr ip;
2632 
  struct netif *netif;
2633 
 
2634 
  if (len) {}
2635 
 
2636 
  snmp_ifindextonetif(od->id_inst_ptr[1], &netif);
2637 
  snmp_oidtoip(&od->id_inst_ptr[2], &ip);
2638 
  ip.addr = htonl(ip.addr);
2639 
 
2640 
  if (etharp_find_addr(netif, &ip, &ethaddr_ret, &ipaddr_ret) > -1)
2641 
  {
2642 
    id = od->id_inst_ptr[0];
2643 
    switch (id)
2644 
    {
2645 
      case 1: /* atIfIndex */
2646 
        {
2647 
          s32_t *sint_ptr = value;
2648 
          *sint_ptr = od->id_inst_ptr[1];
2649 
        }
2650 
        break;
2651 
      case 2: /* atPhysAddress */
2652 
        {
2653 
          struct eth_addr *dst = value;
2654 
 
2655 
          *dst = *ethaddr_ret;
2656 
        }
2657 
        break;
2658 
      case 3: /* atNetAddress */
2659 
        {
2660 
          struct ip_addr *dst = value;
2661 
 
2662 
          *dst = *ipaddr_ret;
2663 
        }
2664 
        break;
2665 
    }
2666 
  }
2667 
}
2668 
 
2669 
static void
2670 
ip_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
2671 
{
2672 
  u8_t id;
2673 
 
2674 
  /* return to object name, adding index depth (1) */
2675 
  ident_len += 1;
2676 
  ident -= 1;
2677 
  if (ident_len == 2)
2678 
  {
2679 
    od->id_inst_len = ident_len;
2680 
    od->id_inst_ptr = ident;
2681 
 
2682 
    id = ident[0];
2683 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("get_object_def ip.%"U16_F".0\n",(u16_t)id));
2684 
    switch (id)
2685 
    {
2686 
      case 1: /* ipForwarding */
2687 
      case 2: /* ipDefaultTTL */
2688 
        od->instance = MIB_OBJECT_SCALAR;
2689 
        od->access = MIB_OBJECT_READ_WRITE;
2690 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2691 
        od->v_len = sizeof(s32_t);
2692 
        break;
2693 
      case 3: /* ipInReceives */
2694 
      case 4: /* ipInHdrErrors */
2695 
      case 5: /* ipInAddrErrors */
2696 
      case 6: /* ipForwDatagrams */
2697 
      case 7: /* ipInUnknownProtos */
2698 
      case 8: /* ipInDiscards */
2699 
      case 9: /* ipInDelivers */
2700 
      case 10: /* ipOutRequests */
2701 
      case 11: /* ipOutDiscards */
2702 
      case 12: /* ipOutNoRoutes */
2703 
      case 14: /* ipReasmReqds */
2704 
      case 15: /* ipReasmOKs */
2705 
      case 16: /* ipReasmFails */
2706 
      case 17: /* ipFragOKs */
2707 
      case 18: /* ipFragFails */
2708 
      case 19: /* ipFragCreates */
2709 
      case 23: /* ipRoutingDiscards */
2710 
        od->instance = MIB_OBJECT_SCALAR;
2711 
        od->access = MIB_OBJECT_READ_ONLY;
2712 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER);
2713 
        od->v_len = sizeof(u32_t);
2714 
        break;
2715 
      case 13: /* ipReasmTimeout */
2716 
        od->instance = MIB_OBJECT_SCALAR;
2717 
        od->access = MIB_OBJECT_READ_ONLY;
2718 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2719 
        od->v_len = sizeof(s32_t);
2720 
        break;
2721 
      default:
2722 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_get_object_def: no such object\n"));
2723 
        od->instance = MIB_OBJECT_NONE;
2724 
        break;
2725 
    };
2726 
  }
2727 
  else
2728 
  {
2729 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_get_object_def: no scalar\n"));
2730 
    od->instance = MIB_OBJECT_NONE;
2731 
  }
2732 
}
2733 
 
2734 
static void
2735 
ip_get_value(struct obj_def *od, u16_t len, void *value)
2736 
{
2737 
  u8_t id;
2738 
 
2739 
  if (len) {}
2740 
  id = od->id_inst_ptr[0];
2741 
  switch (id)
2742 
  {
2743 
    case 1: /* ipForwarding */
2744 
      {
2745 
        s32_t *sint_ptr = value;
2746 
#if IP_FORWARD
2747 
        /* forwarding */
2748 
        *sint_ptr = 1;
2749 
#else
2750 
        /* not-forwarding */
2751 
        *sint_ptr = 2;
2752 
#endif
2753 
      }
2754 
      break;
2755 
    case 2: /* ipDefaultTTL */
2756 
      {
2757 
        s32_t *sint_ptr = value;
2758 
        *sint_ptr = IP_DEFAULT_TTL;
2759 
      }
2760 
      break;
2761 
    case 3: /* ipInReceives */
2762 
      {
2763 
        u32_t *uint_ptr = value;
2764 
        *uint_ptr = ipinreceives;
2765 
      }
2766 
      break;
2767 
    case 4: /* ipInHdrErrors */
2768 
      {
2769 
        u32_t *uint_ptr = value;
2770 
        *uint_ptr = ipinhdrerrors;
2771 
      }
2772 
      break;
2773 
    case 5: /* ipInAddrErrors */
2774 
      {
2775 
        u32_t *uint_ptr = value;
2776 
        *uint_ptr = ipinaddrerrors;
2777 
      }
2778 
      break;
2779 
    case 6: /* ipForwDatagrams */
2780 
      {
2781 
        u32_t *uint_ptr = value;
2782 
        *uint_ptr = ipforwdatagrams;
2783 
      }
2784 
      break;
2785 
    case 7: /* ipInUnknownProtos */
2786 
      {
2787 
        u32_t *uint_ptr = value;
2788 
        *uint_ptr = ipinunknownprotos;
2789 
      }
2790 
      break;
2791 
    case 8: /* ipInDiscards */
2792 
      {
2793 
        u32_t *uint_ptr = value;
2794 
        *uint_ptr = ipindiscards;
2795 
      }
2796 
      break;
2797 
    case 9: /* ipInDelivers */
2798 
      {
2799 
        u32_t *uint_ptr = value;
2800 
        *uint_ptr = ipindelivers;
2801 
      }
2802 
      break;
2803 
    case 10: /* ipOutRequests */
2804 
      {
2805 
        u32_t *uint_ptr = value;
2806 
        *uint_ptr = ipoutrequests;
2807 
      }
2808 
      break;
2809 
    case 11: /* ipOutDiscards */
2810 
      {
2811 
        u32_t *uint_ptr = value;
2812 
        *uint_ptr = ipoutdiscards;
2813 
      }
2814 
      break;
2815 
    case 12: /* ipOutNoRoutes */
2816 
      {
2817 
        u32_t *uint_ptr = value;
2818 
        *uint_ptr = ipoutnoroutes;
2819 
      }
2820 
      break;
2821 
    case 13: /* ipReasmTimeout */
2822 
      {
2823 
        s32_t *sint_ptr = value;
2824 
#if IP_REASSEMBLY
2825 
        *sint_ptr = IP_REASS_MAXAGE;
2826 
#else
2827 
        *sint_ptr = 0;
2828 
#endif
2829 
      }
2830 
      break;
2831 
    case 14: /* ipReasmReqds */
2832 
      {
2833 
        u32_t *uint_ptr = value;
2834 
        *uint_ptr = ipreasmreqds;
2835 
      }
2836 
      break;
2837 
    case 15: /* ipReasmOKs */
2838 
      {
2839 
        u32_t *uint_ptr = value;
2840 
        *uint_ptr = ipreasmoks;
2841 
      }
2842 
      break;
2843 
    case 16: /* ipReasmFails */
2844 
      {
2845 
        u32_t *uint_ptr = value;
2846 
        *uint_ptr = ipreasmfails;
2847 
      }
2848 
      break;
2849 
    case 17: /* ipFragOKs */
2850 
      {
2851 
        u32_t *uint_ptr = value;
2852 
        *uint_ptr = ipfragoks;
2853 
      }
2854 
      break;
2855 
    case 18: /* ipFragFails */
2856 
      {
2857 
        u32_t *uint_ptr = value;
2858 
        *uint_ptr = ipfragfails;
2859 
      }
2860 
      break;
2861 
    case 19: /* ipFragCreates */
2862 
      {
2863 
        u32_t *uint_ptr = value;
2864 
        *uint_ptr = ipfragcreates;
2865 
      }
2866 
      break;
2867 
    case 23: /* ipRoutingDiscards */
2868 
      /** @todo can lwIP discard routes at all?? hardwire this to 0?? */
2869 
      {
2870 
        u32_t *uint_ptr = value;
2871 
        *uint_ptr = iproutingdiscards;
2872 
      }
2873 
      break;
2874 
  };
2875 
}
2876 
 
2877 
/**
2878 
 * Test ip object value before setting.
2879 
 *
2880 
 * @param od is the object definition
2881 
 * @param len return value space (in bytes)
2882 
 * @param value points to (varbind) space to copy value from.
2883 
 *
2884 
 * @note we allow set if the value matches the hardwired value,
2885 
 *   otherwise return badvalue.
2886 
 */
2887 
static u8_t
2888 
ip_set_test(struct obj_def *od, u16_t len, void *value)
2889 
{
2890 
  u8_t id, set_ok;
2891 
  s32_t *sint_ptr = value;
2892 
 
2893 
  if (len) {}
2894 
  set_ok = 0;
2895 
  id = od->id_inst_ptr[0];
2896 
  switch (id)
2897 
  {
2898 
    case 1: /* ipForwarding */
2899 
#if IP_FORWARD
2900 
      /* forwarding */
2901 
      if (*sint_ptr == 1)
2902 
#else
2903 
      /* not-forwarding */
2904 
      if (*sint_ptr == 2)
2905 
#endif
2906 
      {
2907 
        set_ok = 1;
2908 
      }
2909 
      break;
2910 
    case 2: /* ipDefaultTTL */
2911 
      if (*sint_ptr == IP_DEFAULT_TTL)
2912 
      {
2913 
        set_ok = 1;
2914 
      }
2915 
      break;
2916 
  };
2917 
  return set_ok;
2918 
}
2919 
 
2920 
static void
2921 
ip_addrentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
2922 
{
2923 
  /* return to object name, adding index depth (4) */
2924 
  ident_len += 4;
2925 
  ident -= 4;
2926 
 
2927 
  if (ident_len == 5)
2928 
  {
2929 
    u8_t id;
2930 
 
2931 
    od->id_inst_len = ident_len;
2932 
    od->id_inst_ptr = ident;
2933 
 
2934 
    id = ident[0];
2935 
    switch (id)
2936 
    {
2937 
      case 1: /* ipAdEntAddr */
2938 
      case 3: /* ipAdEntNetMask */
2939 
        od->instance = MIB_OBJECT_TAB;
2940 
        od->access = MIB_OBJECT_READ_ONLY;
2941 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR);
2942 
        od->v_len = 4;
2943 
        break;
2944 
      case 2: /* ipAdEntIfIndex */
2945 
      case 4: /* ipAdEntBcastAddr */
2946 
      case 5: /* ipAdEntReasmMaxSize */
2947 
        od->instance = MIB_OBJECT_TAB;
2948 
        od->access = MIB_OBJECT_READ_ONLY;
2949 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
2950 
        od->v_len = sizeof(s32_t);
2951 
        break;
2952 
      default:
2953 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_addrentry_get_object_def: no such object\n"));
2954 
        od->instance = MIB_OBJECT_NONE;
2955 
        break;
2956 
    }
2957 
  }
2958 
  else
2959 
  {
2960 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_addrentry_get_object_def: no scalar\n"));
2961 
    od->instance = MIB_OBJECT_NONE;
2962 
  }
2963 
}
2964 
 
2965 
static void
2966 
ip_addrentry_get_value(struct obj_def *od, u16_t len, void *value)
2967 
{
2968 
  u8_t id;
2969 
  u16_t ifidx;
2970 
  struct ip_addr ip;
2971 
  struct netif *netif = netif_list;
2972 
 
2973 
  if (len) {}
2974 
  snmp_oidtoip(&od->id_inst_ptr[1], &ip);
2975 
  ip.addr = htonl(ip.addr);
2976 
  ifidx = 0;
2977 
  while ((netif != NULL) && !ip_addr_cmp(&ip, &netif->ip_addr))
2978 
  {
2979 
    netif = netif->next;
2980 
    ifidx++;
2981 
  }
2982 
 
2983 
  if (netif != NULL)
2984 
  {
2985 
    id = od->id_inst_ptr[0];
2986 
    switch (id)
2987 
    {
2988 
      case 1: /* ipAdEntAddr */
2989 
        {
2990 
          struct ip_addr *dst = value;
2991 
          *dst = netif->ip_addr;
2992 
        }
2993 
        break;
2994 
      case 2: /* ipAdEntIfIndex */
2995 
        {
2996 
          s32_t *sint_ptr = value;
2997 
          *sint_ptr = ifidx + 1;
2998 
        }
2999 
        break;
3000 
      case 3: /* ipAdEntNetMask */
3001 
        {
3002 
          struct ip_addr *dst = value;
3003 
          *dst = netif->netmask;
3004 
        }
3005 
        break;
3006 
      case 4: /* ipAdEntBcastAddr */
3007 
        {
3008 
          s32_t *sint_ptr = value;
3009 
 
3010 
          /* lwIP oddity, there's no broadcast
3011 
            address in the netif we can rely on */
3012 
          *sint_ptr = ip_addr_broadcast.addr & 1;
3013 
        }
3014 
        break;
3015 
      case 5: /* ipAdEntReasmMaxSize */
3016 
        {
3017 
          s32_t *sint_ptr = value;
3018 
#if IP_REASSEMBLY
3019 
          *sint_ptr = (IP_HLEN + IP_REASS_BUFSIZE);
3020 
#else
3021 
          /** @todo returning MTU would be a bad thing and
3022 
             returning a wild guess like '576' isn't good either */
3023 
          *sint_ptr = 0;
3024 
#endif
3025 
        }
3026 
        break;
3027 
    }
3028 
  }
3029 
}
3030 
 
3031 
/**
3032 
 * @note
3033 
 * lwIP IP routing is currently using the network addresses in netif_list.
3034 
 * if no suitable network IP is found in netif_list, the default_netif is used.
3035 
 */
3036 
static void
3037 
ip_rteentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3038 
{
3039 
  u8_t id;
3040 
 
3041 
  /* return to object name, adding index depth (4) */
3042 
  ident_len += 4;
3043 
  ident -= 4;
3044 
 
3045 
  if (ident_len == 5)
3046 
  {
3047 
    od->id_inst_len = ident_len;
3048 
    od->id_inst_ptr = ident;
3049 
 
3050 
    id = ident[0];
3051 
    switch (id)
3052 
    {
3053 
      case 1: /* ipRouteDest */
3054 
      case 7: /* ipRouteNextHop */
3055 
      case 11: /* ipRouteMask */
3056 
        od->instance = MIB_OBJECT_TAB;
3057 
        od->access = MIB_OBJECT_READ_WRITE;
3058 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR);
3059 
        od->v_len = 4;
3060 
        break;
3061 
      case 2: /* ipRouteIfIndex */
3062 
      case 3: /* ipRouteMetric1 */
3063 
      case 4: /* ipRouteMetric2 */
3064 
      case 5: /* ipRouteMetric3 */
3065 
      case 6: /* ipRouteMetric4 */
3066 
      case 8: /* ipRouteType */
3067 
      case 10: /* ipRouteAge */
3068 
      case 12: /* ipRouteMetric5 */
3069 
        od->instance = MIB_OBJECT_TAB;
3070 
        od->access = MIB_OBJECT_READ_WRITE;
3071 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3072 
        od->v_len = sizeof(s32_t);
3073 
        break;
3074 
      case 9: /* ipRouteProto */
3075 
        od->instance = MIB_OBJECT_TAB;
3076 
        od->access = MIB_OBJECT_READ_ONLY;
3077 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3078 
        od->v_len = sizeof(s32_t);
3079 
        break;
3080 
      case 13: /* ipRouteInfo */
3081 
        /** @note returning zeroDotZero (0.0) no routing protocol specific MIB */
3082 
        od->instance = MIB_OBJECT_TAB;
3083 
        od->access = MIB_OBJECT_READ_ONLY;
3084 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OBJ_ID);
3085 
        od->v_len = iprouteinfo.len * sizeof(s32_t);
3086 
        break;
3087 
      default:
3088 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_rteentry_get_object_def: no such object\n"));
3089 
        od->instance = MIB_OBJECT_NONE;
3090 
        break;
3091 
    }
3092 
  }
3093 
  else
3094 
  {
3095 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_rteentry_get_object_def: no scalar\n"));
3096 
    od->instance = MIB_OBJECT_NONE;
3097 
  }
3098 
}
3099 
 
3100 
static void
3101 
ip_rteentry_get_value(struct obj_def *od, u16_t len, void *value)
3102 
{
3103 
  struct netif *netif;
3104 
  struct ip_addr dest;
3105 
  s32_t *ident;
3106 
  u8_t id;
3107 
 
3108 
  ident = od->id_inst_ptr;
3109 
  snmp_oidtoip(&ident[1], &dest);
3110 
  dest.addr = htonl(dest.addr);
3111 
 
3112 
  if (dest.addr == 0)
3113 
  {
3114 
    /* ip_route() uses default netif for default route */
3115 
    netif = netif_default;
3116 
  }
3117 
  else
3118 
  {
3119 
    /* not using ip_route(), need exact match! */
3120 
    netif = netif_list;
3121 
    while ((netif != NULL) &&
3122 
            !ip_addr_netcmp(&dest, &(netif->ip_addr), &(netif->netmask)) )
3123 
    {
3124 
      netif = netif->next;
3125 
    }
3126 
  }
3127 
  if (netif != NULL)
3128 
  {
3129 
    id = ident[0];
3130 
    switch (id)
3131 
    {
3132 
      case 1: /* ipRouteDest */
3133 
        {
3134 
          struct ip_addr *dst = value;
3135 
 
3136 
          if (dest.addr == 0)
3137 
          {
3138 
            /* default rte has 0.0.0.0 dest */
3139 
            dst->addr = 0;
3140 
          }
3141 
          else
3142 
          {
3143 
            /* netifs have netaddress dest */
3144 
            dst->addr = netif->ip_addr.addr & netif->netmask.addr;
3145 
          }
3146 
        }
3147 
        break;
3148 
      case 2: /* ipRouteIfIndex */
3149 
        {
3150 
          s32_t *sint_ptr = value;
3151 
 
3152 
          snmp_netiftoifindex(netif, sint_ptr);
3153 
        }
3154 
        break;
3155 
      case 3: /* ipRouteMetric1 */
3156 
        {
3157 
          s32_t *sint_ptr = value;
3158 
 
3159 
          if (dest.addr == 0)
3160 
          {
3161 
            /* default rte has metric 1 */
3162 
            *sint_ptr = 1;
3163 
          }
3164 
          else
3165 
          {
3166 
            /* other rtes have metric 0 */
3167 
            *sint_ptr = 0;
3168 
          }
3169 
        }
3170 
        break;
3171 
      case 4: /* ipRouteMetric2 */
3172 
      case 5: /* ipRouteMetric3 */
3173 
      case 6: /* ipRouteMetric4 */
3174 
      case 12: /* ipRouteMetric5 */
3175 
        {
3176 
          s32_t *sint_ptr = value;
3177 
          /* not used */
3178 
          *sint_ptr = -1;
3179 
        }
3180 
        break;
3181 
      case 7: /* ipRouteNextHop */
3182 
        {
3183 
          struct ip_addr *dst = value;
3184 
 
3185 
          if (dest.addr == 0)
3186 
          {
3187 
            /* default rte: gateway */
3188 
            *dst = netif->gw;
3189 
          }
3190 
          else
3191 
          {
3192 
            /* other rtes: netif ip_addr  */
3193 
            *dst = netif->ip_addr;
3194 
          }
3195 
        }
3196 
        break;
3197 
      case 8: /* ipRouteType */
3198 
        {
3199 
          s32_t *sint_ptr = value;
3200 
 
3201 
          if (dest.addr == 0)
3202 
          {
3203 
            /* default rte is indirect */
3204 
            *sint_ptr = 4;
3205 
          }
3206 
          else
3207 
          {
3208 
            /* other rtes are direct */
3209 
            *sint_ptr = 3;
3210 
          }
3211 
        }
3212 
        break;
3213 
      case 9: /* ipRouteProto */
3214 
        {
3215 
          s32_t *sint_ptr = value;
3216 
          /* locally defined routes */
3217 
          *sint_ptr = 2;
3218 
        }
3219 
        break;
3220 
      case 10: /* ipRouteAge */
3221 
        {
3222 
          s32_t *sint_ptr = value;
3223 
          /** @todo (sysuptime - timestamp last change) / 100
3224 
              @see snmp_insert_iprteidx_tree() */
3225 
          *sint_ptr = 0;
3226 
        }
3227 
        break;
3228 
      case 11: /* ipRouteMask */
3229 
        {
3230 
          struct ip_addr *dst = value;
3231 
 
3232 
          if (dest.addr == 0)
3233 
          {
3234 
            /* default rte use 0.0.0.0 mask */
3235 
            dst->addr = 0;
3236 
          }
3237 
          else
3238 
          {
3239 
            /* other rtes use netmask */
3240 
            *dst = netif->netmask;
3241 
          }
3242 
        }
3243 
        break;
3244 
      case 13: /* ipRouteInfo */
3245 
        objectidncpy((s32_t*)value,(s32_t*)iprouteinfo.id,len / sizeof(s32_t));
3246 
        break;
3247 
    }
3248 
  }
3249 
}
3250 
 
3251 
static void
3252 
ip_ntomentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3253 
{
3254 
  /* return to object name, adding index depth (5) */
3255 
  ident_len += 5;
3256 
  ident -= 5;
3257 
 
3258 
  if (ident_len == 6)
3259 
  {
3260 
    u8_t id;
3261 
 
3262 
    od->id_inst_len = ident_len;
3263 
    od->id_inst_ptr = ident;
3264 
 
3265 
    id = ident[0];
3266 
    switch (id)
3267 
    {
3268 
      case 1: /* ipNetToMediaIfIndex */
3269 
      case 4: /* ipNetToMediaType */
3270 
        od->instance = MIB_OBJECT_TAB;
3271 
        od->access = MIB_OBJECT_READ_WRITE;
3272 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3273 
        od->v_len = sizeof(s32_t);
3274 
        break;
3275 
      case 2: /* ipNetToMediaPhysAddress */
3276 
        od->instance = MIB_OBJECT_TAB;
3277 
        od->access = MIB_OBJECT_READ_WRITE;
3278 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
3279 
        od->v_len = sizeof(struct eth_addr);
3280 
        break;
3281 
      case 3: /* ipNetToMediaNetAddress */
3282 
        od->instance = MIB_OBJECT_TAB;
3283 
        od->access = MIB_OBJECT_READ_WRITE;
3284 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR);
3285 
        od->v_len = 4;
3286 
        break;
3287 
      default:
3288 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_ntomentry_get_object_def: no such object\n"));
3289 
        od->instance = MIB_OBJECT_NONE;
3290 
        break;
3291 
    }
3292 
  }
3293 
  else
3294 
  {
3295 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("ip_ntomentry_get_object_def: no scalar\n"));
3296 
    od->instance = MIB_OBJECT_NONE;
3297 
  }
3298 
}
3299 
 
3300 
static void
3301 
ip_ntomentry_get_value(struct obj_def *od, u16_t len, void *value)
3302 
{
3303 
  u8_t id;
3304 
  struct eth_addr* ethaddr_ret;
3305 
  struct ip_addr* ipaddr_ret;
3306 
  struct ip_addr ip;
3307 
  struct netif *netif;
3308 
 
3309 
  if (len) {}
3310 
 
3311 
  snmp_ifindextonetif(od->id_inst_ptr[1], &netif);
3312 
  snmp_oidtoip(&od->id_inst_ptr[2], &ip);
3313 
  ip.addr = htonl(ip.addr);
3314 
 
3315 
  if (etharp_find_addr(netif, &ip, &ethaddr_ret, &ipaddr_ret) > -1)
3316 
  {
3317 
    id = od->id_inst_ptr[0];
3318 
    switch (id)
3319 
    {
3320 
      case 1: /* ipNetToMediaIfIndex */
3321 
        {
3322 
          s32_t *sint_ptr = value;
3323 
          *sint_ptr = od->id_inst_ptr[1];
3324 
        }
3325 
        break;
3326 
      case 2: /* ipNetToMediaPhysAddress */
3327 
        {
3328 
          struct eth_addr *dst = value;
3329 
 
3330 
          *dst = *ethaddr_ret;
3331 
        }
3332 
        break;
3333 
      case 3: /* ipNetToMediaNetAddress */
3334 
        {
3335 
          struct ip_addr *dst = value;
3336 
 
3337 
          *dst = *ipaddr_ret;
3338 
        }
3339 
        break;
3340 
      case 4: /* ipNetToMediaType */
3341 
        {
3342 
          s32_t *sint_ptr = value;
3343 
          /* dynamic (?) */
3344 
          *sint_ptr = 3;
3345 
        }
3346 
        break;
3347 
    }
3348 
  }
3349 
}
3350 
 
3351 
static void
3352 
icmp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3353 
{
3354 
  /* return to object name, adding index depth (1) */
3355 
  ident_len += 1;
3356 
  ident -= 1;
3357 
  if ((ident_len == 2) &&
3358 
      (ident[0] > 0) && (ident[0] < 27))
3359 
  {
3360 
    od->id_inst_len = ident_len;
3361 
    od->id_inst_ptr = ident;
3362 
 
3363 
    od->instance = MIB_OBJECT_SCALAR;
3364 
    od->access = MIB_OBJECT_READ_ONLY;
3365 
    od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER);
3366 
    od->v_len = sizeof(u32_t);
3367 
  }
3368 
  else
3369 
  {
3370 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("icmp_get_object_def: no scalar\n"));
3371 
    od->instance = MIB_OBJECT_NONE;
3372 
  }
3373 
}
3374 
 
3375 
static void
3376 
icmp_get_value(struct obj_def *od, u16_t len, void *value)
3377 
{
3378 
  u32_t *uint_ptr = value;
3379 
  u8_t id;
3380 
 
3381 
  if (len){}
3382 
  id = od->id_inst_ptr[0];
3383 
  switch (id)
3384 
  {
3385 
    case 1: /* icmpInMsgs */
3386 
      *uint_ptr = icmpinmsgs;
3387 
      break;
3388 
    case 2: /* icmpInErrors */
3389 
      *uint_ptr = icmpinerrors;
3390 
      break;
3391 
    case 3: /* icmpInDestUnreachs */
3392 
      *uint_ptr = icmpindestunreachs;
3393 
      break;
3394 
    case 4: /* icmpInTimeExcds */
3395 
      *uint_ptr = icmpintimeexcds;
3396 
      break;
3397 
    case 5: /* icmpInParmProbs */
3398 
      *uint_ptr = icmpinparmprobs;
3399 
      break;
3400 
    case 6: /* icmpInSrcQuenchs */
3401 
      *uint_ptr = icmpinsrcquenchs;
3402 
      break;
3403 
    case 7: /* icmpInRedirects */
3404 
      *uint_ptr = icmpinredirects;
3405 
      break;
3406 
    case 8: /* icmpInEchos */
3407 
      *uint_ptr = icmpinechos;
3408 
      break;
3409 
    case 9: /* icmpInEchoReps */
3410 
      *uint_ptr = icmpinechoreps;
3411 
      break;
3412 
    case 10: /* icmpInTimestamps */
3413 
      *uint_ptr = icmpintimestamps;
3414 
      break;
3415 
    case 11: /* icmpInTimestampReps */
3416 
      *uint_ptr = icmpintimestampreps;
3417 
      break;
3418 
    case 12: /* icmpInAddrMasks */
3419 
      *uint_ptr = icmpinaddrmasks;
3420 
      break;
3421 
    case 13: /* icmpInAddrMaskReps */
3422 
      *uint_ptr = icmpinaddrmaskreps;
3423 
      break;
3424 
    case 14: /* icmpOutMsgs */
3425 
      *uint_ptr = icmpoutmsgs;
3426 
      break;
3427 
    case 15: /* icmpOutErrors */
3428 
      *uint_ptr = icmpouterrors;
3429 
      break;
3430 
    case 16: /* icmpOutDestUnreachs */
3431 
      *uint_ptr = icmpoutdestunreachs;
3432 
      break;
3433 
    case 17: /* icmpOutTimeExcds */
3434 
      *uint_ptr = icmpouttimeexcds;
3435 
      break;
3436 
    case 18: /* icmpOutParmProbs */
3437 
      *uint_ptr = icmpoutparmprobs;
3438 
      break;
3439 
    case 19: /* icmpOutSrcQuenchs */
3440 
      *uint_ptr = icmpoutsrcquenchs;
3441 
      break;
3442 
    case 20: /* icmpOutRedirects */
3443 
      *uint_ptr = icmpoutredirects;
3444 
      break;
3445 
    case 21: /* icmpOutEchos */
3446 
      *uint_ptr = icmpoutechos;
3447 
      break;
3448 
    case 22: /* icmpOutEchoReps */
3449 
      *uint_ptr = icmpoutechoreps;
3450 
      break;
3451 
    case 23: /* icmpOutTimestamps */
3452 
      *uint_ptr = icmpouttimestamps;
3453 
      break;
3454 
    case 24: /* icmpOutTimestampReps */
3455 
      *uint_ptr = icmpouttimestampreps;
3456 
      break;
3457 
    case 25: /* icmpOutAddrMasks */
3458 
      *uint_ptr = icmpoutaddrmasks;
3459 
      break;
3460 
    case 26: /* icmpOutAddrMaskReps */
3461 
      *uint_ptr = icmpoutaddrmaskreps;
3462 
      break;
3463 
  }
3464 
}
3465 
 
3466 
#if LWIP_TCP
3467 
/** @todo tcp grp */
3468 
static void
3469 
tcp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3470 
{
3471 
  u8_t id;
3472 
 
3473 
  /* return to object name, adding index depth (1) */
3474 
  ident_len += 1;
3475 
  ident -= 1;
3476 
  if (ident_len == 2)
3477 
  {
3478 
    od->id_inst_len = ident_len;
3479 
    od->id_inst_ptr = ident;
3480 
 
3481 
    id = ident[0];
3482 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("get_object_def tcp.%"U16_F".0\n",(u16_t)id));
3483 
 
3484 
    switch (id)
3485 
    {
3486 
      case 1: /* tcpRtoAlgorithm */
3487 
      case 2: /* tcpRtoMin */
3488 
      case 3: /* tcpRtoMax */
3489 
      case 4: /* tcpMaxConn */
3490 
        od->instance = MIB_OBJECT_SCALAR;
3491 
        od->access = MIB_OBJECT_READ_ONLY;
3492 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3493 
        od->v_len = sizeof(s32_t);
3494 
        break;
3495 
      case 5: /* tcpActiveOpens */
3496 
      case 6: /* tcpPassiveOpens */
3497 
      case 7: /* tcpAttemptFails */
3498 
      case 8: /* tcpEstabResets */
3499 
      case 10: /* tcpInSegs */
3500 
      case 11: /* tcpOutSegs */
3501 
      case 12: /* tcpRetransSegs */
3502 
      case 14: /* tcpInErrs */
3503 
      case 15: /* tcpOutRsts */
3504 
        od->instance = MIB_OBJECT_SCALAR;
3505 
        od->access = MIB_OBJECT_READ_ONLY;
3506 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER);
3507 
        od->v_len = sizeof(u32_t);
3508 
        break;
3509 
      case 9: /* tcpCurrEstab */
3510 
        od->instance = MIB_OBJECT_TAB;
3511 
        od->access = MIB_OBJECT_READ_ONLY;
3512 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_GAUGE);
3513 
        od->v_len = sizeof(u32_t);
3514 
        break;
3515 
      default:
3516 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("tcp_get_object_def: no such object\n"));
3517 
        od->instance = MIB_OBJECT_NONE;
3518 
        break;
3519 
    };
3520 
  }
3521 
  else
3522 
  {
3523 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("tcp_get_object_def: no scalar\n"));
3524 
    od->instance = MIB_OBJECT_NONE;
3525 
  }
3526 
}
3527 
 
3528 
static void
3529 
tcp_get_value(struct obj_def *od, u16_t len, void *value)
3530 
{
3531 
  u32_t *uint_ptr = value;
3532 
  s32_t *sint_ptr = value;
3533 
  u8_t id;
3534 
 
3535 
  if (len){}
3536 
  id = od->id_inst_ptr[0];
3537 
  switch (id)
3538 
  {
3539 
    case 1: /* tcpRtoAlgorithm, vanj(4) */
3540 
      *sint_ptr = 4;
3541 
      break;
3542 
    case 2: /* tcpRtoMin */
3543 
      /* @todo not the actual value, a guess,
3544 
          needs to be calculated */
3545 
      *sint_ptr = 1000;
3546 
      break;
3547 
    case 3: /* tcpRtoMax */
3548 
      /* @todo not the actual value, a guess,
3549 
         needs to be calculated */
3550 
      *sint_ptr = 60000;
3551 
      break;
3552 
    case 4: /* tcpMaxConn */
3553 
      *sint_ptr = MEMP_NUM_TCP_PCB;
3554 
      break;
3555 
    case 5: /* tcpActiveOpens */
3556 
      *uint_ptr = tcpactiveopens;
3557 
      break;
3558 
    case 6: /* tcpPassiveOpens */
3559 
      *uint_ptr = tcppassiveopens;
3560 
      break;
3561 
    case 7: /* tcpAttemptFails */
3562 
      *uint_ptr = tcpattemptfails;
3563 
      break;
3564 
    case 8: /* tcpEstabResets */
3565 
      *uint_ptr = tcpestabresets;
3566 
      break;
3567 
    case 9: /* tcpCurrEstab */
3568 
      {
3569 
        u16_t tcpcurrestab = 0;
3570 
        struct tcp_pcb *pcb = tcp_active_pcbs;
3571 
        while (pcb != NULL)
3572 
        {
3573 
          if ((pcb->state == ESTABLISHED) ||
3574 
              (pcb->state == CLOSE_WAIT))
3575 
          {
3576 
            tcpcurrestab++;
3577 
          }
3578 
          pcb = pcb->next;
3579 
        }
3580 
        *uint_ptr = tcpcurrestab;
3581 
      }
3582 
      break;
3583 
    case 10: /* tcpInSegs */
3584 
      *uint_ptr = tcpinsegs;
3585 
      break;
3586 
    case 11: /* tcpOutSegs */
3587 
      *uint_ptr = tcpoutsegs;
3588 
      break;
3589 
    case 12: /* tcpRetransSegs */
3590 
      *uint_ptr = tcpretranssegs;
3591 
      break;
3592 
    case 14: /* tcpInErrs */
3593 
      *uint_ptr = tcpinerrs;
3594 
      break;
3595 
    case 15: /* tcpOutRsts */
3596 
      *uint_ptr = tcpoutrsts;
3597 
      break;
3598 
  }
3599 
}
3600 
 
3601 
static void
3602 
tcpconnentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3603 
{
3604 
  /* return to object name, adding index depth (10) */
3605 
  ident_len += 10;
3606 
  ident -= 10;
3607 
 
3608 
  if (ident_len == 11)
3609 
  {
3610 
    u8_t id;
3611 
 
3612 
    od->id_inst_len = ident_len;
3613 
    od->id_inst_ptr = ident;
3614 
 
3615 
    id = ident[0];
3616 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("get_object_def tcp.%"U16_F".0\n",(u16_t)id));
3617 
 
3618 
    switch (id)
3619 
    {
3620 
      case 1: /* tcpConnState */
3621 
        od->instance = MIB_OBJECT_TAB;
3622 
        od->access = MIB_OBJECT_READ_WRITE;
3623 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3624 
        od->v_len = sizeof(s32_t);
3625 
        break;
3626 
      case 2: /* tcpConnLocalAddress */
3627 
      case 4: /* tcpConnRemAddress */
3628 
        od->instance = MIB_OBJECT_TAB;
3629 
        od->access = MIB_OBJECT_READ_ONLY;
3630 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR);
3631 
        od->v_len = 4;
3632 
        break;
3633 
      case 3: /* tcpConnLocalPort */
3634 
      case 5: /* tcpConnRemPort */
3635 
        od->instance = MIB_OBJECT_TAB;
3636 
        od->access = MIB_OBJECT_READ_ONLY;
3637 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3638 
        od->v_len = sizeof(s32_t);
3639 
        break;
3640 
      default:
3641 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("tcpconnentry_get_object_def: no such object\n"));
3642 
        od->instance = MIB_OBJECT_NONE;
3643 
        break;
3644 
    };
3645 
  }
3646 
  else
3647 
  {
3648 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("tcpconnentry_get_object_def: no such object\n"));
3649 
    od->instance = MIB_OBJECT_NONE;
3650 
  }
3651 
}
3652 
 
3653 
static void
3654 
tcpconnentry_get_value(struct obj_def *od, u16_t len, void *value)
3655 
{
3656 
  struct ip_addr lip, rip;
3657 
  u16_t lport, rport;
3658 
  s32_t *ident;
3659 
 
3660 
  ident = od->id_inst_ptr;
3661 
  snmp_oidtoip(&ident[1], &lip);
3662 
  lip.addr = htonl(lip.addr);
3663 
  lport = ident[5];
3664 
  snmp_oidtoip(&ident[6], &rip);
3665 
  rip.addr = htonl(rip.addr);
3666 
  rport = ident[10];
3667 
 
3668 
  /** @todo find matching PCB */
3669 
}
3670 
#endif
3671 
 
3672 
static void
3673 
udp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3674 
{
3675 
  /* return to object name, adding index depth (1) */
3676 
  ident_len += 1;
3677 
  ident -= 1;
3678 
  if ((ident_len == 2) &&
3679 
      (ident[0] > 0) && (ident[0] < 6))
3680 
  {
3681 
    od->id_inst_len = ident_len;
3682 
    od->id_inst_ptr = ident;
3683 
 
3684 
    od->instance = MIB_OBJECT_SCALAR;
3685 
    od->access = MIB_OBJECT_READ_ONLY;
3686 
    od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER);
3687 
    od->v_len = sizeof(u32_t);
3688 
  }
3689 
  else
3690 
  {
3691 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("udp_get_object_def: no scalar\n"));
3692 
    od->instance = MIB_OBJECT_NONE;
3693 
  }
3694 
}
3695 
 
3696 
static void
3697 
udp_get_value(struct obj_def *od, u16_t len, void *value)
3698 
{
3699 
  u32_t *uint_ptr = value;
3700 
  u8_t id;
3701 
 
3702 
  if (len){}
3703 
  id = od->id_inst_ptr[0];
3704 
  switch (id)
3705 
  {
3706 
    case 1: /* udpInDatagrams */
3707 
      *uint_ptr = udpindatagrams;
3708 
      break;
3709 
    case 2: /* udpNoPorts */
3710 
      *uint_ptr = udpnoports;
3711 
      break;
3712 
    case 3: /* udpInErrors */
3713 
      *uint_ptr = udpinerrors;
3714 
      break;
3715 
    case 4: /* udpOutDatagrams */
3716 
      *uint_ptr = udpoutdatagrams;
3717 
      break;
3718 
  }
3719 
}
3720 
 
3721 
static void
3722 
udpentry_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3723 
{
3724 
  /* return to object name, adding index depth (5) */
3725 
  ident_len += 5;
3726 
  ident -= 5;
3727 
 
3728 
  if (ident_len == 6)
3729 
  {
3730 
    od->id_inst_len = ident_len;
3731 
    od->id_inst_ptr = ident;
3732 
 
3733 
    switch (ident[0])
3734 
    {
3735 
      case 1: /* udpLocalAddress */
3736 
        od->instance = MIB_OBJECT_TAB;
3737 
        od->access = MIB_OBJECT_READ_ONLY;
3738 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_IPADDR);
3739 
        od->v_len = 4;
3740 
        break;
3741 
      case 2: /* udpLocalPort */
3742 
        od->instance = MIB_OBJECT_TAB;
3743 
        od->access = MIB_OBJECT_READ_ONLY;
3744 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3745 
        od->v_len = sizeof(s32_t);
3746 
        break;
3747 
      default:
3748 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("udpentry_get_object_def: no such object\n"));
3749 
        od->instance = MIB_OBJECT_NONE;
3750 
        break;
3751 
    }
3752 
  }
3753 
  else
3754 
  {
3755 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("udpentry_get_object_def: no scalar\n"));
3756 
    od->instance = MIB_OBJECT_NONE;
3757 
  }
3758 
}
3759 
 
3760 
static void
3761 
udpentry_get_value(struct obj_def *od, u16_t len, void *value)
3762 
{
3763 
  u8_t id;
3764 
  struct udp_pcb *pcb;
3765 
  struct ip_addr ip;
3766 
  u16_t port;
3767 
 
3768 
  if (len){}
3769 
  snmp_oidtoip(&od->id_inst_ptr[1], &ip);
3770 
  ip.addr = htonl(ip.addr);
3771 
  port = od->id_inst_ptr[5];
3772 
 
3773 
  pcb = udp_pcbs;
3774 
  while ((pcb != NULL) &&
3775 
         !((pcb->local_ip.addr == ip.addr) &&
3776 
           (pcb->local_port == port)))
3777 
  {
3778 
    pcb = pcb->next;
3779 
  }
3780 
 
3781 
  if (pcb != NULL)
3782 
  {
3783 
    id = od->id_inst_ptr[0];
3784 
    switch (id)
3785 
    {
3786 
      case 1: /* udpLocalAddress */
3787 
        {
3788 
          struct ip_addr *dst = value;
3789 
          *dst = pcb->local_ip;
3790 
        }
3791 
        break;
3792 
      case 2: /* udpLocalPort */
3793 
        {
3794 
          s32_t *sint_ptr = value;
3795 
          *sint_ptr = pcb->local_port;
3796 
        }
3797 
        break;
3798 
    }
3799 
  }
3800 
}
3801 
 
3802 
static void
3803 
snmp_get_object_def(u8_t ident_len, s32_t *ident, struct obj_def *od)
3804 
{
3805 
  /* return to object name, adding index depth (1) */
3806 
  ident_len += 1;
3807 
  ident -= 1;
3808 
  if (ident_len == 2)
3809 
  {
3810 
    u8_t id;
3811 
 
3812 
    od->id_inst_len = ident_len;
3813 
    od->id_inst_ptr = ident;
3814 
 
3815 
    id = ident[0];
3816 
    switch (id)
3817 
    {
3818 
      case 1: /* snmpInPkts */
3819 
      case 2: /* snmpOutPkts */
3820 
      case 3: /* snmpInBadVersions */
3821 
      case 4: /* snmpInBadCommunityNames */
3822 
      case 5: /* snmpInBadCommunityUses */
3823 
      case 6: /* snmpInASNParseErrs */
3824 
      case 8: /* snmpInTooBigs */
3825 
      case 9: /* snmpInNoSuchNames */
3826 
      case 10: /* snmpInBadValues */
3827 
      case 11: /* snmpInReadOnlys */
3828 
      case 12: /* snmpInGenErrs */
3829 
      case 13: /* snmpInTotalReqVars */
3830 
      case 14: /* snmpInTotalSetVars */
3831 
      case 15: /* snmpInGetRequests */
3832 
      case 16: /* snmpInGetNexts */
3833 
      case 17: /* snmpInSetRequests */
3834 
      case 18: /* snmpInGetResponses */
3835 
      case 19: /* snmpInTraps */
3836 
      case 20: /* snmpOutTooBigs */
3837 
      case 21: /* snmpOutNoSuchNames */
3838 
      case 22: /* snmpOutBadValues */
3839 
      case 24: /* snmpOutGenErrs */
3840 
      case 25: /* snmpOutGetRequests */
3841 
      case 26: /* snmpOutGetNexts */
3842 
      case 27: /* snmpOutSetRequests */
3843 
      case 28: /* snmpOutGetResponses */
3844 
      case 29: /* snmpOutTraps */
3845 
        od->instance = MIB_OBJECT_SCALAR;
3846 
        od->access = MIB_OBJECT_READ_ONLY;
3847 
        od->asn_type = (SNMP_ASN1_APPLIC | SNMP_ASN1_PRIMIT | SNMP_ASN1_COUNTER);
3848 
        od->v_len = sizeof(u32_t);
3849 
        break;
3850 
      case 30: /* snmpEnableAuthenTraps */
3851 
        od->instance = MIB_OBJECT_SCALAR;
3852 
        od->access = MIB_OBJECT_READ_WRITE;
3853 
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_INTEG);
3854 
        od->v_len = sizeof(s32_t);
3855 
        break;
3856 
      default:
3857 
        LWIP_DEBUGF(SNMP_MIB_DEBUG,("snmp_get_object_def: no such object\n"));
3858 
        od->instance = MIB_OBJECT_NONE;
3859 
        break;
3860 
    };
3861 
  }
3862 
  else
3863 
  {
3864 
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("snmp_get_object_def: no scalar\n"));
3865 
    od->instance = MIB_OBJECT_NONE;
3866 
  }
3867 
}
3868 
 
3869 
static void
3870 
snmp_get_value(struct obj_def *od, u16_t len, void *value)
3871 
{
3872 
  u32_t *uint_ptr = value;
3873 
  u8_t id;
3874 
 
3875 
  if (len){}
3876 
  id = od->id_inst_ptr[0];
3877 
  switch (id)
3878 
  {
3879 
      case 1: /* snmpInPkts */
3880 
        *uint_ptr = snmpinpkts;
3881 
        break;
3882 
      case 2: /* snmpOutPkts */
3883 
        *uint_ptr = snmpoutpkts;
3884 
        break;
3885 
      case 3: /* snmpInBadVersions */
3886 
        *uint_ptr = snmpinbadversions;
3887 
        break;
3888 
      case 4: /* snmpInBadCommunityNames */
3889 
        *uint_ptr = snmpinbadcommunitynames;
3890 
        break;
3891 
      case 5: /* snmpInBadCommunityUses */
3892 
        *uint_ptr = snmpinbadcommunityuses;
3893 
        break;
3894 
      case 6: /* snmpInASNParseErrs */
3895 
        *uint_ptr = snmpinasnparseerrs;
3896 
        break;
3897 
      case 8: /* snmpInTooBigs */
3898 
        *uint_ptr = snmpintoobigs;
3899 
        break;
3900 
      case 9: /* snmpInNoSuchNames */
3901 
        *uint_ptr = snmpinnosuchnames;
3902 
        break;
3903 
      case 10: /* snmpInBadValues */
3904 
        *uint_ptr = snmpinbadvalues;
3905 
        break;
3906 
      case 11: /* snmpInReadOnlys */
3907 
        *uint_ptr = snmpinreadonlys;
3908 
        break;
3909 
      case 12: /* snmpInGenErrs */
3910 
        *uint_ptr = snmpingenerrs;
3911 
        break;
3912 
      case 13: /* snmpInTotalReqVars */
3913 
        *uint_ptr = snmpintotalreqvars;
3914 
        break;
3915 
      case 14: /* snmpInTotalSetVars */
3916 
        *uint_ptr = snmpintotalsetvars;
3917 
        break;
3918 
      case 15: /* snmpInGetRequests */
3919 
        *uint_ptr = snmpingetrequests;
3920 
        break;
3921 
      case 16: /* snmpInGetNexts */
3922 
        *uint_ptr = snmpingetnexts;
3923 
        break;
3924 
      case 17: /* snmpInSetRequests */
3925 
        *uint_ptr = snmpinsetrequests;
3926 
        break;
3927 
      case 18: /* snmpInGetResponses */
3928 
        *uint_ptr = snmpingetresponses;
3929 
        break;
3930 
      case 19: /* snmpInTraps */
3931 
        *uint_ptr = snmpintraps;
3932 
        break;
3933 
      case 20: /* snmpOutTooBigs */
3934 
        *uint_ptr = snmpouttoobigs;
3935 
        break;
3936 
      case 21: /* snmpOutNoSuchNames */
3937 
        *uint_ptr = snmpoutnosuchnames;
3938 
        break;
3939 
      case 22: /* snmpOutBadValues */
3940 
        *uint_ptr = snmpoutbadvalues;
3941 
        break;
3942 
      case 24: /* snmpOutGenErrs */
3943 
        *uint_ptr = snmpoutgenerrs;
3944 
        break;
3945 
      case 25: /* snmpOutGetRequests */
3946 
        *uint_ptr = snmpoutgetrequests;
3947 
        break;
3948 
      case 26: /* snmpOutGetNexts */
3949 
        *uint_ptr = snmpoutgetnexts;
3950 
        break;
3951 
      case 27: /* snmpOutSetRequests */
3952 
        *uint_ptr = snmpoutsetrequests;
3953 
        break;
3954 
      case 28: /* snmpOutGetResponses */
3955 
        *uint_ptr = snmpoutgetresponses;
3956 
        break;
3957 
      case 29: /* snmpOutTraps */
3958 
        *uint_ptr = snmpouttraps;
3959 
        break;
3960 
      case 30: /* snmpEnableAuthenTraps */
3961 
        *uint_ptr = *snmpenableauthentraps_ptr;
3962 
        break;
3963 
  };
3964 
}
3965 
 
3966 
/**
3967 
 * Test snmp object value before setting.
3968 
 *
3969 
 * @param od is the object definition
3970 
 * @param len return value space (in bytes)
3971 
 * @param value points to (varbind) space to copy value from.
3972 
 */
3973 
static u8_t
3974 
snmp_set_test(struct obj_def *od, u16_t len, void *value)
3975 
{
3976 
  u8_t id, set_ok;
3977 
 
3978 
  if (len) {}
3979 
  set_ok = 0;
3980 
  id = od->id_inst_ptr[0];
3981 
  if (id == 30)
3982 
  {
3983 
    /* snmpEnableAuthenTraps */
3984 
    s32_t *sint_ptr = value;
3985 
 
3986 
    if (snmpenableauthentraps_ptr != &snmpenableauthentraps_default)
3987 
    {
3988 
      /* we should have writable non-volatile mem here */
3989 
      if ((*sint_ptr == 1) || (*sint_ptr == 2))
3990 
      {
3991 
        set_ok = 1;
3992 
      }
3993 
    }
3994 
    else
3995 
    {
3996 
      /* const or hardwired value */
3997 
      if (*sint_ptr == snmpenableauthentraps_default)
3998 
      {
3999 
        set_ok = 1;
4000 
      }
4001 
    }
4002 
  }
4003 
  return set_ok;
4004 
}
4005 
 
4006 
static void
4007 
snmp_set_value(struct obj_def *od, u16_t len, void *value)
4008 
{
4009 
  u8_t id;
4010 
 
4011 
  if (len) {}
4012 
  id = od->id_inst_ptr[0];
4013 
  if (id == 30)
4014 
  {
4015 
    /* snmpEnableAuthenTraps */
4016 
    s32_t *sint_ptr = value;
4017 
    *snmpenableauthentraps_ptr = *sint_ptr;
4018 
  }
4019 
}
4020 
 
4021 
#endif /* LWIP_SNMP */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.