1 /* 2 * Copyright (c) 2001-2003 3 * Fraunhofer Institute for Open Communication Systems (FhG Fokus). 4 * All rights reserved. 5 * 6 * Author: Harti Brandt <harti@freebsd.org> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $Begemot: bsnmp/snmp_mibII/mibII_tcp.c,v 1.7 2005/05/23 09:03:42 brandt_h Exp $ 30 * 31 * tcp 32 */ 33 #include "mibII.h" 34 #include "mibII_oid.h" 35 #include <sys/socketvar.h> 36 #include <netinet/in_pcb.h> 37 #include <netinet/tcp.h> 38 #include <netinet/tcp_var.h> 39 #include <netinet/tcp_timer.h> 40 #include <netinet/tcp_fsm.h> 41 42 struct tcp_index { 43 struct asn_oid index; 44 struct xtcpcb *tp; 45 }; 46 47 static uint64_t tcp_tick; 48 static uint64_t tcp_stats_tick; 49 static struct tcpstat tcpstat; 50 static uint64_t tcps_states[TCP_NSTATES]; 51 static struct xinpgen *xinpgen; 52 static size_t xinpgen_len; 53 static u_int tcp_total; 54 55 static u_int oidnum; 56 static struct tcp_index *tcpoids; 57 58 static int 59 tcp_compare(const void *p1, const void *p2) 60 { 61 const struct tcp_index *t1 = p1; 62 const struct tcp_index *t2 = p2; 63 64 return (asn_compare_oid(&t1->index, &t2->index)); 65 } 66 67 static int 68 fetch_tcp_stats(void) 69 { 70 size_t len; 71 72 len = sizeof(tcpstat); 73 if (sysctlbyname("net.inet.tcp.stats", &tcpstat, &len, NULL, 0) == -1) { 74 syslog(LOG_ERR, "net.inet.tcp.stats: %m"); 75 return (-1); 76 } 77 if (len != sizeof(tcpstat)) { 78 syslog(LOG_ERR, "net.inet.tcp.stats: wrong size"); 79 return (-1); 80 } 81 82 len = sizeof(tcps_states); 83 if (sysctlbyname("net.inet.tcp.states", &tcps_states, &len, NULL, 84 0) == -1) { 85 syslog(LOG_ERR, "net.inet.tcp.states: %m"); 86 return (-1); 87 } 88 if (len != sizeof(tcps_states)) { 89 syslog(LOG_ERR, "net.inet.tcp.states: wrong size"); 90 return (-1); 91 } 92 93 tcp_stats_tick = get_ticks(); 94 95 return (0); 96 } 97 98 static int 99 fetch_tcp(void) 100 { 101 size_t len; 102 struct xinpgen *ptr; 103 struct xtcpcb *tp; 104 struct tcp_index *oid; 105 in_addr_t inaddr; 106 107 len = 0; 108 if (sysctlbyname("net.inet.tcp.pcblist", NULL, &len, NULL, 0) == -1) { 109 syslog(LOG_ERR, "net.inet.tcp.pcblist: %m"); 110 return (-1); 111 } 112 if (len > xinpgen_len) { 113 if ((ptr = realloc(xinpgen, len)) == NULL) { 114 syslog(LOG_ERR, "%zu: %m", len); 115 return (-1); 116 } 117 xinpgen = ptr; 118 xinpgen_len = len; 119 } 120 if (sysctlbyname("net.inet.tcp.pcblist", xinpgen, &len, NULL, 0) == -1) { 121 syslog(LOG_ERR, "net.inet.tcp.pcblist: %m"); 122 return (-1); 123 } 124 125 tcp_tick = get_ticks(); 126 127 tcp_total = 0; 128 for (ptr = (struct xinpgen *)(void *)((char *)xinpgen + xinpgen->xig_len); 129 ptr->xig_len > sizeof(struct xinpgen); 130 ptr = (struct xinpgen *)(void *)((char *)ptr + ptr->xig_len)) { 131 tp = (struct xtcpcb *)ptr; 132 if (tp->xt_inp.inp_gencnt > xinpgen->xig_gen || 133 (tp->xt_inp.inp_vflag & (INP_IPV4|INP_IPV6)) == 0) 134 continue; 135 136 if (tp->xt_inp.inp_vflag & INP_IPV4) 137 tcp_total++; 138 } 139 140 if (oidnum < tcp_total) { 141 oid = realloc(tcpoids, tcp_total * sizeof(tcpoids[0])); 142 if (oid == NULL) { 143 free(tcpoids); 144 oidnum = 0; 145 return (0); 146 } 147 tcpoids = oid; 148 oidnum = tcp_total; 149 } 150 151 oid = tcpoids; 152 for (ptr = (struct xinpgen *)(void *)((char *)xinpgen + xinpgen->xig_len); 153 ptr->xig_len > sizeof(struct xinpgen); 154 ptr = (struct xinpgen *)(void *)((char *)ptr + ptr->xig_len)) { 155 tp = (struct xtcpcb *)ptr; 156 if (tp->xt_inp.inp_gencnt > xinpgen->xig_gen || 157 (tp->xt_inp.inp_vflag & INP_IPV4) == 0) 158 continue; 159 oid->tp = tp; 160 oid->index.len = 10; 161 inaddr = ntohl(tp->xt_inp.inp_laddr.s_addr); 162 oid->index.subs[0] = (inaddr >> 24) & 0xff; 163 oid->index.subs[1] = (inaddr >> 16) & 0xff; 164 oid->index.subs[2] = (inaddr >> 8) & 0xff; 165 oid->index.subs[3] = (inaddr >> 0) & 0xff; 166 oid->index.subs[4] = ntohs(tp->xt_inp.inp_lport); 167 inaddr = ntohl(tp->xt_inp.inp_faddr.s_addr); 168 oid->index.subs[5] = (inaddr >> 24) & 0xff; 169 oid->index.subs[6] = (inaddr >> 16) & 0xff; 170 oid->index.subs[7] = (inaddr >> 8) & 0xff; 171 oid->index.subs[8] = (inaddr >> 0) & 0xff; 172 oid->index.subs[9] = ntohs(tp->xt_inp.inp_fport); 173 oid++; 174 } 175 176 qsort(tcpoids, tcp_total, sizeof(tcpoids[0]), tcp_compare); 177 178 return (0); 179 } 180 181 /* 182 * Scalars 183 */ 184 int 185 op_tcp(struct snmp_context *ctx __unused, struct snmp_value *value, 186 u_int sub, u_int iidx __unused, enum snmp_op op) 187 { 188 switch (op) { 189 190 case SNMP_OP_GETNEXT: 191 abort(); 192 193 case SNMP_OP_GET: 194 break; 195 196 case SNMP_OP_SET: 197 return (SNMP_ERR_NOT_WRITEABLE); 198 199 case SNMP_OP_ROLLBACK: 200 case SNMP_OP_COMMIT: 201 abort(); 202 } 203 204 if (tcp_stats_tick < this_tick) 205 if (fetch_tcp_stats() == -1) 206 return (SNMP_ERR_GENERR); 207 208 switch (value->var.subs[sub - 1]) { 209 210 case LEAF_tcpRtoAlgorithm: 211 value->v.integer = 4; /* Van Jacobson */ 212 break; 213 214 #define hz clockinfo.hz 215 216 case LEAF_tcpRtoMin: 217 value->v.integer = 1000 * TCPTV_MIN / hz; 218 break; 219 220 case LEAF_tcpRtoMax: 221 value->v.integer = 1000 * TCPTV_REXMTMAX / hz; 222 break; 223 #undef hz 224 225 case LEAF_tcpMaxConn: 226 value->v.integer = -1; 227 break; 228 229 case LEAF_tcpActiveOpens: 230 value->v.uint32 = tcpstat.tcps_connattempt; 231 break; 232 233 case LEAF_tcpPassiveOpens: 234 value->v.uint32 = tcpstat.tcps_accepts; 235 break; 236 237 case LEAF_tcpAttemptFails: 238 value->v.uint32 = tcpstat.tcps_conndrops; 239 break; 240 241 case LEAF_tcpEstabResets: 242 value->v.uint32 = tcpstat.tcps_drops; 243 break; 244 245 case LEAF_tcpCurrEstab: 246 value->v.uint32 = tcps_states[TCPS_ESTABLISHED] + 247 tcps_states[TCPS_CLOSE_WAIT]; 248 break; 249 250 case LEAF_tcpInSegs: 251 value->v.uint32 = tcpstat.tcps_rcvtotal; 252 break; 253 254 case LEAF_tcpOutSegs: 255 value->v.uint32 = tcpstat.tcps_sndtotal - 256 tcpstat.tcps_sndrexmitpack; 257 break; 258 259 case LEAF_tcpRetransSegs: 260 value->v.uint32 = tcpstat.tcps_sndrexmitpack; 261 break; 262 263 case LEAF_tcpInErrs: 264 value->v.uint32 = tcpstat.tcps_rcvbadsum + 265 tcpstat.tcps_rcvbadoff + 266 tcpstat.tcps_rcvshort; 267 break; 268 } 269 return (SNMP_ERR_NOERROR); 270 } 271 272 int 273 op_tcpconn(struct snmp_context *ctx __unused, struct snmp_value *value, 274 u_int sub, u_int iidx __unused, enum snmp_op op) 275 { 276 u_int i; 277 278 if (tcp_tick < this_tick) 279 if (fetch_tcp() == -1) 280 return (SNMP_ERR_GENERR); 281 282 switch (op) { 283 284 case SNMP_OP_GETNEXT: 285 for (i = 0; i < tcp_total; i++) 286 if (index_compare(&value->var, sub, &tcpoids[i].index) < 0) 287 break; 288 if (i == tcp_total) 289 return (SNMP_ERR_NOSUCHNAME); 290 index_append(&value->var, sub, &tcpoids[i].index); 291 break; 292 293 case SNMP_OP_GET: 294 for (i = 0; i < tcp_total; i++) 295 if (index_compare(&value->var, sub, &tcpoids[i].index) == 0) 296 break; 297 if (i == tcp_total) 298 return (SNMP_ERR_NOSUCHNAME); 299 break; 300 301 case SNMP_OP_SET: 302 return (SNMP_ERR_NOT_WRITEABLE); 303 304 case SNMP_OP_ROLLBACK: 305 case SNMP_OP_COMMIT: 306 default: 307 abort(); 308 } 309 310 switch (value->var.subs[sub - 1]) { 311 312 case LEAF_tcpConnState: 313 switch (tcpoids[i].tp->t_state) { 314 315 case TCPS_CLOSED: 316 value->v.integer = 1; 317 break; 318 case TCPS_LISTEN: 319 value->v.integer = 2; 320 break; 321 case TCPS_SYN_SENT: 322 value->v.integer = 3; 323 break; 324 case TCPS_SYN_RECEIVED: 325 value->v.integer = 4; 326 break; 327 case TCPS_ESTABLISHED: 328 value->v.integer = 5; 329 break; 330 case TCPS_CLOSE_WAIT: 331 value->v.integer = 8; 332 break; 333 case TCPS_FIN_WAIT_1: 334 value->v.integer = 6; 335 break; 336 case TCPS_CLOSING: 337 value->v.integer = 10; 338 break; 339 case TCPS_LAST_ACK: 340 value->v.integer = 9; 341 break; 342 case TCPS_FIN_WAIT_2: 343 value->v.integer = 7; 344 break; 345 case TCPS_TIME_WAIT: 346 value->v.integer = 11; 347 break; 348 default: 349 value->v.integer = 0; 350 break; 351 } 352 break; 353 354 case LEAF_tcpConnLocalAddress: 355 value->v.ipaddress[0] = tcpoids[i].index.subs[0]; 356 value->v.ipaddress[1] = tcpoids[i].index.subs[1]; 357 value->v.ipaddress[2] = tcpoids[i].index.subs[2]; 358 value->v.ipaddress[3] = tcpoids[i].index.subs[3]; 359 break; 360 361 case LEAF_tcpConnLocalPort: 362 value->v.integer = tcpoids[i].index.subs[4]; 363 break; 364 365 case LEAF_tcpConnRemAddress: 366 value->v.ipaddress[0] = tcpoids[i].index.subs[5]; 367 value->v.ipaddress[1] = tcpoids[i].index.subs[6]; 368 value->v.ipaddress[2] = tcpoids[i].index.subs[7]; 369 value->v.ipaddress[3] = tcpoids[i].index.subs[8]; 370 break; 371 372 case LEAF_tcpConnRemPort: 373 value->v.integer = tcpoids[i].index.subs[9]; 374 break; 375 } 376 return (SNMP_ERR_NOERROR); 377 } 378