OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

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

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

powered by: WebSVN 2.1.0

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