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