1 /**
2 * @file
3 * Management Information Base II (RFC1213) TCP objects and functions.
4 */
5
6 /*
7 * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands.
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without modification,
11 * are permitted provided that the following conditions are met:
12 *
13 * 1. Redistributions of source code must retain the above copyright notice,
14 * this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
18 * 3. The name of the author may not be used to endorse or promote products
19 * derived from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
24 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
26 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
29 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
30 * OF SUCH DAMAGE.
31 *
32 * Author: Dirk Ziegelmeier <dziegel@gmx.de>
33 * Christiaan Simons <christiaan.simons@axon.tv>
34 */
35
36 #include "lwip/snmp.h"
37 #include "lwip/apps/snmp.h"
38 #include "lwip/apps/snmp_core.h"
39 #include "lwip/apps/snmp_mib2.h"
40 #include "lwip/apps/snmp_table.h"
41 #include "lwip/apps/snmp_scalar.h"
42 #include "lwip/tcp.h"
43 #include "lwip/priv/tcp_priv.h"
44 #include "lwip/stats.h"
45
46 #include <string.h>
47
48 #if LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_TCP
49
50 #if SNMP_USE_NETCONN
51 #define SYNC_NODE_NAME(node_name) node_name ## _synced
52 #define CREATE_LWIP_SYNC_NODE(oid, node_name) \
53 static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks);
54 #else
55 #define SYNC_NODE_NAME(node_name) node_name
56 #define CREATE_LWIP_SYNC_NODE(oid, node_name)
57 #endif
58
59 /* --- tcp .1.3.6.1.2.1.6 ----------------------------------------------------- */
60
61 static s16_t
tcp_get_value(struct snmp_node_instance * instance,void * value)62 tcp_get_value(struct snmp_node_instance *instance, void *value)
63 {
64 u32_t *uint_ptr = (u32_t *)value;
65 s32_t *sint_ptr = (s32_t *)value;
66
67 switch (instance->node->oid) {
68 case 1: /* tcpRtoAlgorithm, vanj(4) */
69 *sint_ptr = 4;
70 return sizeof(*sint_ptr);
71 case 2: /* tcpRtoMin */
72 /* @todo not the actual value, a guess,
73 needs to be calculated */
74 *sint_ptr = 1000;
75 return sizeof(*sint_ptr);
76 case 3: /* tcpRtoMax */
77 /* @todo not the actual value, a guess,
78 needs to be calculated */
79 *sint_ptr = 60000;
80 return sizeof(*sint_ptr);
81 case 4: /* tcpMaxConn */
82 *sint_ptr = MEMP_NUM_TCP_PCB;
83 return sizeof(*sint_ptr);
84 case 5: /* tcpActiveOpens */
85 *uint_ptr = STATS_GET(mib2.tcpactiveopens);
86 return sizeof(*uint_ptr);
87 case 6: /* tcpPassiveOpens */
88 *uint_ptr = STATS_GET(mib2.tcppassiveopens);
89 return sizeof(*uint_ptr);
90 case 7: /* tcpAttemptFails */
91 *uint_ptr = STATS_GET(mib2.tcpattemptfails);
92 return sizeof(*uint_ptr);
93 case 8: /* tcpEstabResets */
94 *uint_ptr = STATS_GET(mib2.tcpestabresets);
95 return sizeof(*uint_ptr);
96 case 9: { /* tcpCurrEstab */
97 u16_t tcpcurrestab = 0;
98 struct tcp_pcb *pcb = tcp_active_pcbs;
99 while (pcb != NULL) {
100 if ((pcb->state == ESTABLISHED) ||
101 (pcb->state == CLOSE_WAIT)) {
102 tcpcurrestab++;
103 }
104 pcb = pcb->next;
105 }
106 *uint_ptr = tcpcurrestab;
107 }
108 return sizeof(*uint_ptr);
109 case 10: /* tcpInSegs */
110 *uint_ptr = STATS_GET(mib2.tcpinsegs);
111 return sizeof(*uint_ptr);
112 case 11: /* tcpOutSegs */
113 *uint_ptr = STATS_GET(mib2.tcpoutsegs);
114 return sizeof(*uint_ptr);
115 case 12: /* tcpRetransSegs */
116 *uint_ptr = STATS_GET(mib2.tcpretranssegs);
117 return sizeof(*uint_ptr);
118 case 14: /* tcpInErrs */
119 *uint_ptr = STATS_GET(mib2.tcpinerrs);
120 return sizeof(*uint_ptr);
121 case 15: /* tcpOutRsts */
122 *uint_ptr = STATS_GET(mib2.tcpoutrsts);
123 return sizeof(*uint_ptr);
124 #if LWIP_HAVE_INT64
125 case 17: { /* tcpHCInSegs */
126 /* use the 32 bit counter for now... */
127 u64_t val64 = STATS_GET(mib2.tcpinsegs);
128 *((u64_t *)value) = val64;
129 }
130 return sizeof(u64_t);
131 case 18: { /* tcpHCOutSegs */
132 /* use the 32 bit counter for now... */
133 u64_t val64 = STATS_GET(mib2.tcpoutsegs);
134 *((u64_t *)value) = val64;
135 }
136 return sizeof(u64_t);
137 #endif
138 default:
139 LWIP_DEBUGF(SNMP_MIB_DEBUG, ("tcp_get_value(): unknown id: %"S32_F"\n", instance->node->oid));
140 break;
141 }
142
143 return 0;
144 }
145
146 /* --- tcpConnTable --- */
147
148 #if LWIP_IPV4
149
150 /* list of allowed value ranges for incoming OID */
151 static const struct snmp_oid_range tcp_ConnTable_oid_ranges[] = {
152 { 0, 0xff }, /* IP A */
153 { 0, 0xff }, /* IP B */
154 { 0, 0xff }, /* IP C */
155 { 0, 0xff }, /* IP D */
156 { 0, 0xffff }, /* Port */
157 { 0, 0xff }, /* IP A */
158 { 0, 0xff }, /* IP B */
159 { 0, 0xff }, /* IP C */
160 { 0, 0xff }, /* IP D */
161 { 0, 0xffff } /* Port */
162 };
163
164 static snmp_err_t
tcp_ConnTable_get_cell_value_core(struct tcp_pcb * pcb,const u32_t * column,union snmp_variant_value * value,u32_t * value_len)165 tcp_ConnTable_get_cell_value_core(struct tcp_pcb *pcb, const u32_t *column, union snmp_variant_value *value, u32_t *value_len)
166 {
167 LWIP_UNUSED_ARG(value_len);
168
169 /* value */
170 switch (*column) {
171 case 1: /* tcpConnState */
172 value->u32 = pcb->state + 1;
173 break;
174 case 2: /* tcpConnLocalAddress */
175 value->u32 = ip_2_ip4(&pcb->local_ip)->addr;
176 break;
177 case 3: /* tcpConnLocalPort */
178 value->u32 = pcb->local_port;
179 break;
180 case 4: /* tcpConnRemAddress */
181 if (pcb->state == LISTEN) {
182 value->u32 = IP4_ADDR_ANY4->addr;
183 } else {
184 value->u32 = ip_2_ip4(&pcb->remote_ip)->addr;
185 }
186 break;
187 case 5: /* tcpConnRemPort */
188 if (pcb->state == LISTEN) {
189 value->u32 = 0;
190 } else {
191 value->u32 = pcb->remote_port;
192 }
193 break;
194 default:
195 LWIP_ASSERT("invalid id", 0);
196 return SNMP_ERR_NOSUCHINSTANCE;
197 }
198
199 return SNMP_ERR_NOERROR;
200 }
201
202 static snmp_err_t
tcp_ConnTable_get_cell_value(const u32_t * column,const u32_t * row_oid,u8_t row_oid_len,union snmp_variant_value * value,u32_t * value_len)203 tcp_ConnTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len)
204 {
205 u8_t i;
206 ip4_addr_t local_ip;
207 ip4_addr_t remote_ip;
208 u16_t local_port;
209 u16_t remote_port;
210 struct tcp_pcb *pcb;
211
212 /* check if incoming OID length and if values are in plausible range */
213 if (!snmp_oid_in_range(row_oid, row_oid_len, tcp_ConnTable_oid_ranges, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges))) {
214 return SNMP_ERR_NOSUCHINSTANCE;
215 }
216
217 /* get IPs and ports from incoming OID */
218 snmp_oid_to_ip4(&row_oid[0], &local_ip); /* we know it succeeds because of oid_in_range check above */
219 local_port = (u16_t)row_oid[4];
220 snmp_oid_to_ip4(&row_oid[5], &remote_ip); /* we know it succeeds because of oid_in_range check above */
221 remote_port = (u16_t)row_oid[9];
222
223 /* find tcp_pcb with requested ips and ports */
224 for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) {
225 pcb = *tcp_pcb_lists[i];
226
227 while (pcb != NULL) {
228 /* do local IP and local port match? */
229 if (IP_IS_V4_VAL(pcb->local_ip) &&
230 ip4_addr_cmp(&local_ip, ip_2_ip4(&pcb->local_ip)) && (local_port == pcb->local_port)) {
231
232 /* PCBs in state LISTEN are not connected and have no remote_ip or remote_port */
233 if (pcb->state == LISTEN) {
234 if (ip4_addr_cmp(&remote_ip, IP4_ADDR_ANY4) && (remote_port == 0)) {
235 /* fill in object properties */
236 return tcp_ConnTable_get_cell_value_core(pcb, column, value, value_len);
237 }
238 } else {
239 if (IP_IS_V4_VAL(pcb->remote_ip) &&
240 ip4_addr_cmp(&remote_ip, ip_2_ip4(&pcb->remote_ip)) && (remote_port == pcb->remote_port)) {
241 /* fill in object properties */
242 return tcp_ConnTable_get_cell_value_core(pcb, column, value, value_len);
243 }
244 }
245 }
246
247 pcb = pcb->next;
248 }
249 }
250
251 /* not found */
252 return SNMP_ERR_NOSUCHINSTANCE;
253 }
254
255 static snmp_err_t
tcp_ConnTable_get_next_cell_instance_and_value(const u32_t * column,struct snmp_obj_id * row_oid,union snmp_variant_value * value,u32_t * value_len)256 tcp_ConnTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len)
257 {
258 u8_t i;
259 struct tcp_pcb *pcb;
260 struct snmp_next_oid_state state;
261 u32_t result_temp[LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)];
262
263 /* init struct to search next oid */
264 snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges));
265
266 /* iterate over all possible OIDs to find the next one */
267 for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) {
268 pcb = *tcp_pcb_lists[i];
269 while (pcb != NULL) {
270 u32_t test_oid[LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)];
271
272 if (IP_IS_V4_VAL(pcb->local_ip)) {
273 snmp_ip4_to_oid(ip_2_ip4(&pcb->local_ip), &test_oid[0]);
274 test_oid[4] = pcb->local_port;
275
276 /* PCBs in state LISTEN are not connected and have no remote_ip or remote_port */
277 if (pcb->state == LISTEN) {
278 snmp_ip4_to_oid(IP4_ADDR_ANY4, &test_oid[5]);
279 test_oid[9] = 0;
280 } else {
281 if (IP_IS_V6_VAL(pcb->remote_ip)) { /* should never happen */
282 continue;
283 }
284 snmp_ip4_to_oid(ip_2_ip4(&pcb->remote_ip), &test_oid[5]);
285 test_oid[9] = pcb->remote_port;
286 }
287
288 /* check generated OID: is it a candidate for the next one? */
289 snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges), pcb);
290 }
291
292 pcb = pcb->next;
293 }
294 }
295
296 /* did we find a next one? */
297 if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) {
298 snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
299 /* fill in object properties */
300 return tcp_ConnTable_get_cell_value_core((struct tcp_pcb *)state.reference, column, value, value_len);
301 }
302
303 /* not found */
304 return SNMP_ERR_NOSUCHINSTANCE;
305 }
306
307 #endif /* LWIP_IPV4 */
308
309 /* --- tcpConnectionTable --- */
310
311 static snmp_err_t
tcp_ConnectionTable_get_cell_value_core(const u32_t * column,struct tcp_pcb * pcb,union snmp_variant_value * value)312 tcp_ConnectionTable_get_cell_value_core(const u32_t *column, struct tcp_pcb *pcb, union snmp_variant_value *value)
313 {
314 /* all items except tcpConnectionState and tcpConnectionProcess are declared as not-accessible */
315 switch (*column) {
316 case 7: /* tcpConnectionState */
317 value->u32 = pcb->state + 1;
318 break;
319 case 8: /* tcpConnectionProcess */
320 value->u32 = 0; /* not supported */
321 break;
322 default:
323 return SNMP_ERR_NOSUCHINSTANCE;
324 }
325
326 return SNMP_ERR_NOERROR;
327 }
328
329 static snmp_err_t
tcp_ConnectionTable_get_cell_value(const u32_t * column,const u32_t * row_oid,u8_t row_oid_len,union snmp_variant_value * value,u32_t * value_len)330 tcp_ConnectionTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len)
331 {
332 ip_addr_t local_ip, remote_ip;
333 u16_t local_port, remote_port;
334 struct tcp_pcb *pcb;
335 u8_t idx = 0;
336 u8_t i;
337 struct tcp_pcb **const tcp_pcb_nonlisten_lists[] = {&tcp_bound_pcbs, &tcp_active_pcbs, &tcp_tw_pcbs};
338
339 LWIP_UNUSED_ARG(value_len);
340
341 /* tcpConnectionLocalAddressType + tcpConnectionLocalAddress + tcpConnectionLocalPort */
342 idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port);
343 if (idx == 0) {
344 return SNMP_ERR_NOSUCHINSTANCE;
345 }
346
347 /* tcpConnectionRemAddressType + tcpConnectionRemAddress + tcpConnectionRemPort */
348 idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &remote_ip, &remote_port);
349 if (idx == 0) {
350 return SNMP_ERR_NOSUCHINSTANCE;
351 }
352
353 /* find tcp_pcb with requested ip and port*/
354 for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_nonlisten_lists); i++) {
355 pcb = *tcp_pcb_nonlisten_lists[i];
356
357 while (pcb != NULL) {
358 if (ip_addr_cmp(&local_ip, &pcb->local_ip) &&
359 (local_port == pcb->local_port) &&
360 ip_addr_cmp(&remote_ip, &pcb->remote_ip) &&
361 (remote_port == pcb->remote_port)) {
362 /* fill in object properties */
363 return tcp_ConnectionTable_get_cell_value_core(column, pcb, value);
364 }
365 pcb = pcb->next;
366 }
367 }
368
369 /* not found */
370 return SNMP_ERR_NOSUCHINSTANCE;
371 }
372
373 static snmp_err_t
tcp_ConnectionTable_get_next_cell_instance_and_value(const u32_t * column,struct snmp_obj_id * row_oid,union snmp_variant_value * value,u32_t * value_len)374 tcp_ConnectionTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len)
375 {
376 struct tcp_pcb *pcb;
377 struct snmp_next_oid_state state;
378 /* 1x tcpConnectionLocalAddressType + 1x OID len + 16x tcpConnectionLocalAddress + 1x tcpConnectionLocalPort
379 * 1x tcpConnectionRemAddressType + 1x OID len + 16x tcpConnectionRemAddress + 1x tcpConnectionRemPort */
380 u32_t result_temp[38];
381 u8_t i;
382 struct tcp_pcb **const tcp_pcb_nonlisten_lists[] = {&tcp_bound_pcbs, &tcp_active_pcbs, &tcp_tw_pcbs};
383
384 LWIP_UNUSED_ARG(value_len);
385
386 /* init struct to search next oid */
387 snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp));
388
389 /* iterate over all possible OIDs to find the next one */
390 for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_nonlisten_lists); i++) {
391 pcb = *tcp_pcb_nonlisten_lists[i];
392
393 while (pcb != NULL) {
394 u8_t idx = 0;
395 u32_t test_oid[LWIP_ARRAYSIZE(result_temp)];
396
397 /* tcpConnectionLocalAddressType + tcpConnectionLocalAddress + tcpConnectionLocalPort */
398 idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]);
399
400 /* tcpConnectionRemAddressType + tcpConnectionRemAddress + tcpConnectionRemPort */
401 idx += snmp_ip_port_to_oid(&pcb->remote_ip, pcb->remote_port, &test_oid[idx]);
402
403 /* check generated OID: is it a candidate for the next one? */
404 snmp_next_oid_check(&state, test_oid, idx, pcb);
405
406 pcb = pcb->next;
407 }
408 }
409
410 /* did we find a next one? */
411 if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) {
412 snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
413 /* fill in object properties */
414 return tcp_ConnectionTable_get_cell_value_core(column, (struct tcp_pcb *)state.reference, value);
415 } else {
416 /* not found */
417 return SNMP_ERR_NOSUCHINSTANCE;
418 }
419 }
420
421 /* --- tcpListenerTable --- */
422
423 static snmp_err_t
tcp_ListenerTable_get_cell_value_core(const u32_t * column,union snmp_variant_value * value)424 tcp_ListenerTable_get_cell_value_core(const u32_t *column, union snmp_variant_value *value)
425 {
426 /* all items except tcpListenerProcess are declared as not-accessible */
427 switch (*column) {
428 case 4: /* tcpListenerProcess */
429 value->u32 = 0; /* not supported */
430 break;
431 default:
432 return SNMP_ERR_NOSUCHINSTANCE;
433 }
434
435 return SNMP_ERR_NOERROR;
436 }
437
438 static snmp_err_t
tcp_ListenerTable_get_cell_value(const u32_t * column,const u32_t * row_oid,u8_t row_oid_len,union snmp_variant_value * value,u32_t * value_len)439 tcp_ListenerTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len)
440 {
441 ip_addr_t local_ip;
442 u16_t local_port;
443 struct tcp_pcb_listen *pcb;
444 u8_t idx = 0;
445
446 LWIP_UNUSED_ARG(value_len);
447
448 /* tcpListenerLocalAddressType + tcpListenerLocalAddress + tcpListenerLocalPort */
449 idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port);
450 if (idx == 0) {
451 return SNMP_ERR_NOSUCHINSTANCE;
452 }
453
454 /* find tcp_pcb with requested ip and port*/
455 pcb = tcp_listen_pcbs.listen_pcbs;
456 while (pcb != NULL) {
457 if (ip_addr_cmp(&local_ip, &pcb->local_ip) &&
458 (local_port == pcb->local_port)) {
459 /* fill in object properties */
460 return tcp_ListenerTable_get_cell_value_core(column, value);
461 }
462 pcb = pcb->next;
463 }
464
465 /* not found */
466 return SNMP_ERR_NOSUCHINSTANCE;
467 }
468
469 static snmp_err_t
tcp_ListenerTable_get_next_cell_instance_and_value(const u32_t * column,struct snmp_obj_id * row_oid,union snmp_variant_value * value,u32_t * value_len)470 tcp_ListenerTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len)
471 {
472 struct tcp_pcb_listen *pcb;
473 struct snmp_next_oid_state state;
474 /* 1x tcpListenerLocalAddressType + 1x OID len + 16x tcpListenerLocalAddress + 1x tcpListenerLocalPort */
475 u32_t result_temp[19];
476
477 LWIP_UNUSED_ARG(value_len);
478
479 /* init struct to search next oid */
480 snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp));
481
482 /* iterate over all possible OIDs to find the next one */
483 pcb = tcp_listen_pcbs.listen_pcbs;
484 while (pcb != NULL) {
485 u8_t idx = 0;
486 u32_t test_oid[LWIP_ARRAYSIZE(result_temp)];
487
488 /* tcpListenerLocalAddressType + tcpListenerLocalAddress + tcpListenerLocalPort */
489 idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]);
490
491 /* check generated OID: is it a candidate for the next one? */
492 snmp_next_oid_check(&state, test_oid, idx, NULL);
493
494 pcb = pcb->next;
495 }
496
497 /* did we find a next one? */
498 if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) {
499 snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len);
500 /* fill in object properties */
501 return tcp_ListenerTable_get_cell_value_core(column, value);
502 } else {
503 /* not found */
504 return SNMP_ERR_NOSUCHINSTANCE;
505 }
506 }
507
508 static const struct snmp_scalar_node tcp_RtoAlgorithm = SNMP_SCALAR_CREATE_NODE_READONLY(1, SNMP_ASN1_TYPE_INTEGER, tcp_get_value);
509 static const struct snmp_scalar_node tcp_RtoMin = SNMP_SCALAR_CREATE_NODE_READONLY(2, SNMP_ASN1_TYPE_INTEGER, tcp_get_value);
510 static const struct snmp_scalar_node tcp_RtoMax = SNMP_SCALAR_CREATE_NODE_READONLY(3, SNMP_ASN1_TYPE_INTEGER, tcp_get_value);
511 static const struct snmp_scalar_node tcp_MaxConn = SNMP_SCALAR_CREATE_NODE_READONLY(4, SNMP_ASN1_TYPE_INTEGER, tcp_get_value);
512 static const struct snmp_scalar_node tcp_ActiveOpens = SNMP_SCALAR_CREATE_NODE_READONLY(5, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
513 static const struct snmp_scalar_node tcp_PassiveOpens = SNMP_SCALAR_CREATE_NODE_READONLY(6, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
514 static const struct snmp_scalar_node tcp_AttemptFails = SNMP_SCALAR_CREATE_NODE_READONLY(7, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
515 static const struct snmp_scalar_node tcp_EstabResets = SNMP_SCALAR_CREATE_NODE_READONLY(8, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
516 static const struct snmp_scalar_node tcp_CurrEstab = SNMP_SCALAR_CREATE_NODE_READONLY(9, SNMP_ASN1_TYPE_GAUGE, tcp_get_value);
517 static const struct snmp_scalar_node tcp_InSegs = SNMP_SCALAR_CREATE_NODE_READONLY(10, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
518 static const struct snmp_scalar_node tcp_OutSegs = SNMP_SCALAR_CREATE_NODE_READONLY(11, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
519 static const struct snmp_scalar_node tcp_RetransSegs = SNMP_SCALAR_CREATE_NODE_READONLY(12, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
520 static const struct snmp_scalar_node tcp_InErrs = SNMP_SCALAR_CREATE_NODE_READONLY(14, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
521 static const struct snmp_scalar_node tcp_OutRsts = SNMP_SCALAR_CREATE_NODE_READONLY(15, SNMP_ASN1_TYPE_COUNTER, tcp_get_value);
522 #if LWIP_HAVE_INT64
523 static const struct snmp_scalar_node tcp_HCInSegs = SNMP_SCALAR_CREATE_NODE_READONLY(17, SNMP_ASN1_TYPE_COUNTER64, tcp_get_value);
524 static const struct snmp_scalar_node tcp_HCOutSegs = SNMP_SCALAR_CREATE_NODE_READONLY(18, SNMP_ASN1_TYPE_COUNTER64, tcp_get_value);
525 #endif
526
527 #if LWIP_IPV4
528 static const struct snmp_table_simple_col_def tcp_ConnTable_columns[] = {
529 { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnState */
530 { 2, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnLocalAddress */
531 { 3, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnLocalPort */
532 { 4, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnRemAddress */
533 { 5, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpConnRemPort */
534 };
535
536 static const struct snmp_table_simple_node tcp_ConnTable = SNMP_TABLE_CREATE_SIMPLE(13, tcp_ConnTable_columns, tcp_ConnTable_get_cell_value, tcp_ConnTable_get_next_cell_instance_and_value);
537 #endif /* LWIP_IPV4 */
538
539 static const struct snmp_table_simple_col_def tcp_ConnectionTable_columns[] = {
540 /* all items except tcpConnectionState and tcpConnectionProcess are declared as not-accessible */
541 { 7, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnectionState */
542 { 8, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpConnectionProcess */
543 };
544
545 static const struct snmp_table_simple_node tcp_ConnectionTable = SNMP_TABLE_CREATE_SIMPLE(19, tcp_ConnectionTable_columns, tcp_ConnectionTable_get_cell_value, tcp_ConnectionTable_get_next_cell_instance_and_value);
546
547
548 static const struct snmp_table_simple_col_def tcp_ListenerTable_columns[] = {
549 /* all items except tcpListenerProcess are declared as not-accessible */
550 { 4, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpListenerProcess */
551 };
552
553 static const struct snmp_table_simple_node tcp_ListenerTable = SNMP_TABLE_CREATE_SIMPLE(20, tcp_ListenerTable_columns, tcp_ListenerTable_get_cell_value, tcp_ListenerTable_get_next_cell_instance_and_value);
554
555 /* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */
556 CREATE_LWIP_SYNC_NODE( 1, tcp_RtoAlgorithm)
557 CREATE_LWIP_SYNC_NODE( 2, tcp_RtoMin)
558 CREATE_LWIP_SYNC_NODE( 3, tcp_RtoMax)
559 CREATE_LWIP_SYNC_NODE( 4, tcp_MaxConn)
560 CREATE_LWIP_SYNC_NODE( 5, tcp_ActiveOpens)
561 CREATE_LWIP_SYNC_NODE( 6, tcp_PassiveOpens)
562 CREATE_LWIP_SYNC_NODE( 7, tcp_AttemptFails)
563 CREATE_LWIP_SYNC_NODE( 8, tcp_EstabResets)
564 CREATE_LWIP_SYNC_NODE( 9, tcp_CurrEstab)
565 CREATE_LWIP_SYNC_NODE(10, tcp_InSegs)
566 CREATE_LWIP_SYNC_NODE(11, tcp_OutSegs)
567 CREATE_LWIP_SYNC_NODE(12, tcp_RetransSegs)
568 #if LWIP_IPV4
569 CREATE_LWIP_SYNC_NODE(13, tcp_ConnTable)
570 #endif /* LWIP_IPV4 */
571 CREATE_LWIP_SYNC_NODE(14, tcp_InErrs)
572 CREATE_LWIP_SYNC_NODE(15, tcp_OutRsts)
573 #if LWIP_HAVE_INT64
574 CREATE_LWIP_SYNC_NODE(17, tcp_HCInSegs)
575 CREATE_LWIP_SYNC_NODE(18, tcp_HCOutSegs)
576 #endif
577 CREATE_LWIP_SYNC_NODE(19, tcp_ConnectionTable)
578 CREATE_LWIP_SYNC_NODE(20, tcp_ListenerTable)
579
580 static const struct snmp_node *const tcp_nodes[] = {
581 &SYNC_NODE_NAME(tcp_RtoAlgorithm).node.node,
582 &SYNC_NODE_NAME(tcp_RtoMin).node.node,
583 &SYNC_NODE_NAME(tcp_RtoMax).node.node,
584 &SYNC_NODE_NAME(tcp_MaxConn).node.node,
585 &SYNC_NODE_NAME(tcp_ActiveOpens).node.node,
586 &SYNC_NODE_NAME(tcp_PassiveOpens).node.node,
587 &SYNC_NODE_NAME(tcp_AttemptFails).node.node,
588 &SYNC_NODE_NAME(tcp_EstabResets).node.node,
589 &SYNC_NODE_NAME(tcp_CurrEstab).node.node,
590 &SYNC_NODE_NAME(tcp_InSegs).node.node,
591 &SYNC_NODE_NAME(tcp_OutSegs).node.node,
592 &SYNC_NODE_NAME(tcp_RetransSegs).node.node,
593 #if LWIP_IPV4
594 &SYNC_NODE_NAME(tcp_ConnTable).node.node,
595 #endif /* LWIP_IPV4 */
596 &SYNC_NODE_NAME(tcp_InErrs).node.node,
597 &SYNC_NODE_NAME(tcp_OutRsts).node.node,
598 &SYNC_NODE_NAME(tcp_HCInSegs).node.node,
599 #if LWIP_HAVE_INT64
600 &SYNC_NODE_NAME(tcp_HCOutSegs).node.node,
601 &SYNC_NODE_NAME(tcp_ConnectionTable).node.node,
602 #endif
603 &SYNC_NODE_NAME(tcp_ListenerTable).node.node
604 };
605
606 const struct snmp_tree_node snmp_mib2_tcp_root = SNMP_CREATE_TREE_NODE(6, tcp_nodes);
607 #endif /* LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_TCP */
608