/* $OpenBSD: mib.c,v 1.34 2010/01/11 11:15:03 deraadt Exp $ */ /* * Copyright (c) 2007, 2008 Reyk Floeter * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "snmpd.h" #include "mib.h" extern struct snmpd *env; /* * Defined in SNMPv2-MIB.txt (RFC 3418) */ int mib_getsys(struct oid *, struct ber_oid *, struct ber_element **); int mib_getsnmp(struct oid *, struct ber_oid *, struct ber_element **); int mib_sysor(struct oid *, struct ber_oid *, struct ber_element **); int mib_setsnmp(struct oid *, struct ber_oid *, struct ber_element **); static struct oid mib_tree[] = MIB_TREE; static struct ber_oid zerodotzero = { { 0, 0 }, 2 }; #define sizeofa(_a) (sizeof(_a) / sizeof((_a)[0])) /* base MIB tree */ static struct oid base_mib[] = { { MIB(mib_2), OID_MIB }, { MIB(sysDescr), OID_RD, mib_getsys }, { MIB(sysOID), OID_RD, mib_getsys }, { MIB(sysUpTime), OID_RD, mib_getsys }, { MIB(sysContact), OID_RW, mib_getsys, mps_setstr }, { MIB(sysName), OID_RW, mib_getsys, mps_setstr }, { MIB(sysLocation), OID_RW, mib_getsys, mps_setstr }, { MIB(sysServices), OID_RS, mib_getsys }, { MIB(sysORLastChange), OID_RD, mps_getts }, { MIB(sysORIndex), OID_TRD, mib_sysor }, { MIB(sysORID), OID_TRD, mib_sysor }, { MIB(sysORDescr), OID_TRD, mib_sysor }, { MIB(sysORUpTime), OID_TRD, mib_sysor }, { MIB(snmp), OID_MIB }, { MIB(snmpInPkts), OID_RD, mib_getsnmp }, { MIB(snmpOutPkts), OID_RD, mib_getsnmp }, { MIB(snmpInBadVersions), OID_RD, mib_getsnmp }, { MIB(snmpInBadCommunityNames), OID_RD, mib_getsnmp }, { MIB(snmpInBadCommunityUses), OID_RD, mib_getsnmp }, { MIB(snmpInASNParseErrs), OID_RD, mib_getsnmp }, { MIB(snmpInTooBigs), OID_RD, mib_getsnmp }, { MIB(snmpInNoSuchNames), OID_RD, mib_getsnmp }, { MIB(snmpInBadValues), OID_RD, mib_getsnmp }, { MIB(snmpInReadOnlys), OID_RD, mib_getsnmp }, { MIB(snmpInGenErrs), OID_RD, mib_getsnmp }, { MIB(snmpInTotalReqVars), OID_RD, mib_getsnmp }, { MIB(snmpInTotalSetVars), OID_RD, mib_getsnmp }, { MIB(snmpInGetRequests), OID_RD, mib_getsnmp }, { MIB(snmpInGetNexts), OID_RD, mib_getsnmp }, { MIB(snmpInSetRequests), OID_RD, mib_getsnmp }, { MIB(snmpInGetResponses), OID_RD, mib_getsnmp }, { MIB(snmpInTraps), OID_RD, mib_getsnmp }, { MIB(snmpOutTooBigs), OID_RD, mib_getsnmp }, { MIB(snmpOutNoSuchNames), OID_RD, mib_getsnmp }, { MIB(snmpOutBadValues), OID_RD, mib_getsnmp }, { MIB(snmpOutGenErrs), OID_RD, mib_getsnmp }, { MIB(snmpOutGetRequests), OID_RD, mib_getsnmp }, { MIB(snmpOutGetNexts), OID_RD, mib_getsnmp }, { MIB(snmpOutSetRequests), OID_RD, mib_getsnmp }, { MIB(snmpOutGetResponses), OID_RD, mib_getsnmp }, { MIB(snmpOutTraps), OID_RD, mib_getsnmp }, { MIB(snmpEnableAuthenTraps), OID_RW, mib_getsnmp, mib_setsnmp }, { MIB(snmpSilentDrops), OID_RD, mib_getsnmp }, { MIB(snmpProxyDrops), OID_RD, mib_getsnmp }, { MIBEND } }; int mib_getsys(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_oid sysoid = OID(MIB_SYSOID_DEFAULT); char *s = oid->o_data; struct ber_oid *so = oid->o_data; struct utsname u; long long ticks; if (uname(&u) == -1) return (-1); switch (oid->o_oid[OIDIDX_system]) { case 1: if (s == NULL) { if (asprintf(&s, "%s %s %s %s %s", u.sysname, u.nodename, u.release, u.version, u.machine) == -1) return (-1); oid->o_data = s; oid->o_val = strlen(s); } *elm = ber_add_string(*elm, s); break; case 2: if (so == NULL) so = &sysoid; smi_oidlen(so); *elm = ber_add_oid(*elm, so); break; case 3: ticks = smi_getticks(); *elm = ber_add_integer(*elm, ticks); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_TIMETICKS); break; case 4: if (s == NULL) { if (asprintf(&s, "root@%s", u.nodename) == -1) return (-1); oid->o_data = s; oid->o_val = strlen(s); } *elm = ber_add_string(*elm, s); break; case 5: if (s == NULL) { if ((s = strdup(u.nodename)) == NULL) return (-1); oid->o_data = s; oid->o_val = strlen(s); } *elm = ber_add_string(*elm, s); break; case 6: if (s == NULL) s = ""; *elm = ber_add_string(*elm, s); break; case 7: *elm = ber_add_integer(*elm, oid->o_val); break; default: return (-1); } return (0); } int mib_sysor(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx = 1, nmib = 0; struct oid *next, *miboid; char buf[SNMPD_MAXSTRLEN]; /* Count MIB root OIDs in the tree */ for (next = NULL; (next = smi_foreach(next, OID_MIB)) != NULL; nmib++); /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_sysOREntry]; if (idx > nmib) return (1); /* Find the MIB root element for this Id */ for (next = miboid = NULL, nmib = 1; (next = smi_foreach(next, OID_MIB)) != NULL; nmib++) { if (nmib == idx) miboid = next; } if (miboid == NULL) return (-1); /* Tables need to prepend the OID on their own */ ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_sysOR]) { case 1: ber = ber_add_integer(ber, idx); break; case 2: ber = ber_add_oid(ber, &miboid->o_id); break; case 3: /* * This should be a description of the MIB. * But we use the symbolic OID string for now, it may * help to display names of internal OIDs. */ smi_oidstring(&miboid->o_id, buf, sizeof(buf)); ber = ber_add_string(ber, buf); break; case 4: /* * We do not support dynamic loading of MIB at runtime, * the sysORUpTime value of 0 will indicate "loaded at * startup". */ ber = ber_add_integer(ber, 0); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_TIMETICKS); break; default: return (-1); } return (0); } int mib_getsnmp(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct snmp_stats *stats = &env->sc_stats; long long i; struct statsmap { u_int8_t m_id; u_int32_t *m_ptr; } mapping[] = { { 1, &stats->snmp_inpkts }, { 2, &stats->snmp_outpkts }, { 3, &stats->snmp_inbadversions }, { 4, &stats->snmp_inbadcommunitynames }, { 5, &stats->snmp_inbadcommunityuses }, { 6, &stats->snmp_inasnparseerrs }, { 8, &stats->snmp_intoobigs }, { 9, &stats->snmp_innosuchnames }, { 10, &stats->snmp_inbadvalues }, { 11, &stats->snmp_inreadonlys }, { 12, &stats->snmp_ingenerrs }, { 13, &stats->snmp_intotalreqvars }, { 14, &stats->snmp_intotalsetvars }, { 15, &stats->snmp_ingetrequests }, { 16, &stats->snmp_ingetnexts }, { 17, &stats->snmp_insetrequests }, { 18, &stats->snmp_ingetresponses }, { 19, &stats->snmp_intraps }, { 20, &stats->snmp_outtoobigs }, { 21, &stats->snmp_outnosuchnames }, { 22, &stats->snmp_outbadvalues }, { 24, &stats->snmp_outgenerrs }, { 25, &stats->snmp_outgetrequests }, { 26, &stats->snmp_outgetnexts }, { 27, &stats->snmp_outsetrequests }, { 28, &stats->snmp_outgetresponses }, { 29, &stats->snmp_outtraps }, { 31, &stats->snmp_silentdrops }, { 32, &stats->snmp_proxydrops } }; switch (oid->o_oid[OIDIDX_snmp]) { case 30: i = stats->snmp_enableauthentraps == 1 ? 1 : 2; *elm = ber_add_integer(*elm, i); break; default: for (i = 0; (u_int)i < (sizeof(mapping) / sizeof(mapping[0])); i++) { if (oid->o_oid[OIDIDX_snmp] == mapping[i].m_id) { *elm = ber_add_integer(*elm, *mapping[i].m_ptr); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); return (0); } } return (-1); } return (0); } int mib_setsnmp(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct snmp_stats *stats = &env->sc_stats; long long i; if (ber_get_integer(*elm, &i) == -1) return (-1); stats->snmp_enableauthentraps = i == 1 ? 1 : 0; return (0); } /* * Defined in HOST-RESOURCES-MIB.txt (RFC 2790) */ int mib_hrmemory(struct oid *, struct ber_oid *, struct ber_element **); int mib_hrstorage(struct oid *, struct ber_oid *, struct ber_element **); int mib_hrdevice(struct oid *, struct ber_oid *, struct ber_element **); int mib_hrprocessor(struct oid *, struct ber_oid *, struct ber_element **); int mib_hrswrun(struct oid *, struct ber_oid *, struct ber_element **); int kinfo_proc_comp(const void *, const void *); int kinfo_proc(u_int32_t, struct kinfo_proc2 **); int kinfo_args(struct kinfo_proc2 *, char **); static struct oid hr_mib[] = { { MIB(host), OID_MIB }, { MIB(hrMemorySize), OID_RD, mib_hrmemory }, { MIB(hrStorageIndex), OID_TRD, mib_hrstorage }, { MIB(hrStorageType), OID_TRD, mib_hrstorage }, { MIB(hrStorageDescr), OID_TRD, mib_hrstorage }, { MIB(hrStorageAllocationUnits), OID_TRD, mib_hrstorage }, { MIB(hrStorageSize), OID_TRD, mib_hrstorage }, { MIB(hrStorageUsed), OID_TRD, mib_hrstorage }, { MIB(hrStorageAllocationFailures), OID_TRD, mib_hrstorage }, { MIB(hrDeviceIndex), OID_TRD, mib_hrdevice }, { MIB(hrDeviceType), OID_TRD, mib_hrdevice }, { MIB(hrDeviceDescr), OID_TRD, mib_hrdevice }, { MIB(hrDeviceID), OID_TRD, mib_hrdevice }, { MIB(hrDeviceStatus), OID_TRD, mib_hrdevice }, { MIB(hrDeviceErrors), OID_TRD, mib_hrdevice }, { MIB(hrProcessorFrwID), OID_TRD, mib_hrprocessor }, { MIB(hrProcessorLoad), OID_TRD, mib_hrprocessor }, { MIB(hrSWRunIndex), OID_TRD, mib_hrswrun }, { MIB(hrSWRunName), OID_TRD, mib_hrswrun }, { MIB(hrSWRunID), OID_TRD, mib_hrswrun }, { MIB(hrSWRunPath), OID_TRD, mib_hrswrun }, { MIB(hrSWRunParameters), OID_TRD, mib_hrswrun }, { MIB(hrSWRunType), OID_TRD, mib_hrswrun }, { MIB(hrSWRunStatus), OID_TRD, mib_hrswrun }, { MIBEND } }; int mib_hrmemory(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; int mib[] = { CTL_HW, HW_PHYSMEM64 }; u_int64_t physmem; size_t len = sizeof(physmem); if (sysctl(mib, sizeofa(mib), &physmem, &len, NULL, 0) == -1) return (-1); ber = ber_add_integer(ber, physmem / 1024); return (0); } int mib_hrstorage(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx; struct statfs *mntbuf, *mnt; int mntsize, maxsize; u_int32_t units, size, used, fail = 0; const char *descr = NULL; int mib[] = { CTL_HW, 0 }; u_int64_t physmem, realmem; struct uvmexp uvm; struct vmtotal vm; size_t len; static struct ber_oid *sop, so[] = { { { MIB_hrStorageOther } }, { { MIB_hrStorageRam } }, { { MIB_hrStorageVirtualMemory } }, { { MIB_hrStorageFixedDisk } } }; /* Physical memory, real memory, swap */ mib[1] = HW_PHYSMEM64; len = sizeof(physmem); if (sysctl(mib, sizeofa(mib), &physmem, &len, NULL, 0) == -1) return (-1); mib[1] = HW_USERMEM64; len = sizeof(realmem); if (sysctl(mib, sizeofa(mib), &realmem, &len, NULL, 0) == -1) return (-1); mib[0] = CTL_VM; mib[1] = VM_UVMEXP; len = sizeof(uvm); if (sysctl(mib, sizeofa(mib), &uvm, &len, NULL, 0) == -1) return (-1); mib[1] = VM_METER; len = sizeof(vm); if (sysctl(mib, sizeofa(mib), &vm, &len, NULL, 0) == -1) return (-1); maxsize = 10; /* Disks */ mntsize = getmntinfo(&mntbuf, MNT_NOWAIT); if (mntsize) maxsize = 30 + mntsize; /* * Get and verify the current row index. * * We use a special mapping here that is inspired by other SNMP * agents: index 1 + 2 for RAM, index 10 for swap, index 31 and * higher for disk storage. */ idx = o->bo_id[OIDIDX_hrStorageEntry]; if (idx > (u_int)maxsize) return (1); else if (idx > 2 && idx < 10) idx = 10; else if (idx > 10 && idx < 31) idx = 31; sop = &so[0]; switch (idx) { case 1: descr = "Physical memory"; units = uvm.pagesize; size = physmem / uvm.pagesize; used = size - vm.t_free; sop = &so[1]; break; case 2: descr = "Real memory"; units = uvm.pagesize; size = realmem / uvm.pagesize; used = size - uvm.free; sop = &so[1]; break; case 10: descr = "Swap space"; units = uvm.pagesize; size = uvm.swpages; used = uvm.swpginuse; sop = &so[2]; break; default: mnt = &mntbuf[idx - 31]; descr = mnt->f_mntonname; units = mnt->f_bsize; size = mnt->f_blocks; used = mnt->f_blocks - mnt->f_bfree; sop = &so[3]; break; } /* Tables need to prepend the OID on their own */ o->bo_id[OIDIDX_hrStorageEntry] = idx; ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_hrStorage]) { case 1: /* hrStorageIndex */ ber = ber_add_integer(ber, idx); break; case 2: /* hrStorageType */ smi_oidlen(sop); ber = ber_add_oid(ber, sop); break; case 3: /* hrStorageDescr */ ber = ber_add_string(ber, descr); break; case 4: /* hrStorageAllocationUnits */ ber = ber_add_integer(ber, units); break; case 5: /* hrStorageSize */ ber = ber_add_integer(ber, size); break; case 6: /* hrStorageUsed */ ber = ber_add_integer(ber, used); break; case 7: /* hrStorageAllocationFailures */ ber = ber_add_integer(ber, fail); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; default: return (-1); } return (0); } int mib_hrdevice(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx, fail = 0; int status; int mib[] = { CTL_HW, HW_MODEL }; size_t len; char descr[BUFSIZ]; static struct ber_oid *sop, so[] = { { { MIB_hrDeviceProcessor } }, }; /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_hrDeviceEntry]; if (idx > (u_int)env->sc_ncpu) return (1); /* Tables need to prepend the OID on their own */ o->bo_id[OIDIDX_hrDeviceEntry] = idx; ber = ber_add_oid(ber, o); len = sizeof(descr); if (sysctl(mib, sizeofa(mib), &descr, &len, NULL, 0) == -1) return (-1); /* unknown(1), running(2), warning(3), testing(4), down(5) */ status = 2; sop = &so[0]; switch (o->bo_id[OIDIDX_hrDevice]) { case 1: /* hrDeviceIndex */ ber = ber_add_integer(ber, idx); break; case 2: /* hrDeviceType */ smi_oidlen(sop); ber = ber_add_oid(ber, sop); break; case 3: /* hrDeviceDescr */ ber = ber_add_string(ber, descr); break; case 4: /* hrDeviceID */ ber = ber_add_oid(ber, &zerodotzero); break; case 5: /* hrDeviceStatus */ ber = ber_add_integer(ber, status); break; case 6: /* hrDeviceErrors */ ber = ber_add_integer(ber, fail); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; default: return (-1); } return (0); } int mib_hrprocessor(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx; int64_t *cptime2, val; /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_hrDeviceEntry]; if (idx > (u_int)env->sc_ncpu) return (1); else if (idx < 1) idx = 1; /* Tables need to prepend the OID on their own */ o->bo_id[OIDIDX_hrDeviceEntry] = idx; ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_hrDevice]) { case 1: /* hrProcessorFrwID */ ber = ber_add_oid(ber, &zerodotzero); break; case 2: /* hrProcessorLoad */ /* * The percentage of time that the system was not * idle during the last minute. */ if (env->sc_cpustates == NULL) return (-1); cptime2 = env->sc_cpustates + (CPUSTATES * (idx - 1)); val = 100 - (cptime2[CP_IDLE] > 1000 ? 1000 : (cptime2[CP_IDLE] / 10)); ber = ber_add_integer(ber, val); break; default: return (-1); } return (0); } int mib_hrswrun(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; struct kinfo_proc2 *kinfo; char *s; /* Get and verify the current row index */ if (kinfo_proc(o->bo_id[OIDIDX_hrSWRunEntry], &kinfo) == -1) return (-1); if (kinfo == NULL) return (1); /* Tables need to prepend the OID on their own */ o->bo_id[OIDIDX_hrSWRunEntry] = kinfo->p_pid; ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_hrSWRun]) { case 1: /* hrSWRunIndex */ ber = ber_add_integer(ber, kinfo->p_pid); break; case 2: /* hrSWRunName */ case 4: /* hrSWRunPath */ ber = ber_add_string(ber, kinfo->p_comm); break; case 3: /* hrSWRunID */ ber = ber_add_oid(ber, &zerodotzero); break; case 5: /* hrSWRunParameters */ if (kinfo_args(kinfo, &s) == -1) return (-1); ber = ber_add_string(ber, s); break; case 6: /* hrSWRunType */ if (kinfo->p_flag & P_SYSTEM) { /* operatingSystem(2) */ ber = ber_add_integer(ber, 2); } else { /* application(4) */ ber = ber_add_integer(ber, 4); } break; case 7: /* hrSWRunStatus */ switch (kinfo->p_stat) { case SONPROC: /* running(1) */ ber = ber_add_integer(ber, 1); break; case SIDL: case SRUN: case SSLEEP: /* runnable(2) */ ber = ber_add_integer(ber, 2); break; case SSTOP: /* notRunnable(3) */ ber = ber_add_integer(ber, 3); break; case SZOMB: case SDEAD: default: /* invalid(4) */ ber = ber_add_integer(ber, 4); break; } break; default: return (-1); } return (0); } int kinfo_proc_comp(const void *a, const void *b) { struct kinfo_proc2 * const *k1 = a; struct kinfo_proc2 * const *k2 = b; return (((*k1)->p_pid > (*k2)->p_pid) ? 1 : -1); } int kinfo_proc(u_int32_t idx, struct kinfo_proc2 **kinfo) { static struct kinfo_proc2 *kp = NULL; static size_t nkp = 0; int mib[] = { CTL_KERN, KERN_PROC2, KERN_PROC_ALL, 0, sizeof(*kp), 0 }; struct kinfo_proc2 **klist; size_t size, count, i; for (;;) { size = nkp * sizeof(*kp); mib[5] = nkp; if (sysctl(mib, sizeofa(mib), kp, &size, NULL, 0) == -1) { if (errno == ENOMEM) { free(kp); kp = NULL; nkp = 0; continue; } return (-1); } count = size / sizeof(*kp); if (count <= nkp) break; kp = malloc(size); if (kp == NULL) { nkp = 0; return (-1); } nkp = count; } klist = calloc(count, sizeof(*klist)); if (klist == NULL) return (-1); for (i = 0; i < count; i++) klist[i] = &kp[i]; qsort(klist, count, sizeof(*klist), kinfo_proc_comp); *kinfo = NULL; for (i = 0; i < count; i++) { if (klist[i]->p_pid >= (int32_t)idx) { *kinfo = klist[i]; break; } } free(klist); return (0); } int kinfo_args(struct kinfo_proc2 *kinfo, char **s) { static char str[128]; static char *buf = NULL; static size_t buflen = 128; int mib[] = { CTL_KERN, KERN_PROC_ARGS, kinfo->p_pid, KERN_PROC_ARGV }; char *nbuf, **argv; if (buf == NULL) { buf = malloc(buflen); if (buf == NULL) return (-1); } str[0] = '\0'; *s = str; while (sysctl(mib, sizeofa(mib), buf, &buflen, NULL, 0) == -1) { if (errno != ENOMEM) { /* some errors are expected, dont get too upset */ return (0); } nbuf = realloc(buf, buflen + 128); if (nbuf == NULL) return (-1); buf = nbuf; buflen += 128; } argv = (char **)buf; if (argv[0] == NULL) return (0); argv++; while (*argv != NULL) { strlcat(str, *argv, sizeof(str)); argv++; if (*argv != NULL) strlcat(str, " ", sizeof(str)); } return (0); } /* * Defined in IF-MIB.txt (RFCs 1229, 1573, 2233, 2863) */ int mib_ifnumber(struct oid *, struct ber_oid *, struct ber_element **); struct kif *mib_ifget(u_int); int mib_iftable(struct oid *, struct ber_oid *, struct ber_element **); int mib_ifxtable(struct oid *, struct ber_oid *, struct ber_element **); int mib_ifstacklast(struct oid *, struct ber_oid *, struct ber_element **); int mib_ifrcvtable(struct oid *, struct ber_oid *, struct ber_element **); static u_int8_t ether_zeroaddr[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; static struct oid if_mib[] = { { MIB(ifMIB), OID_MIB }, { MIB(ifName), OID_TRD, mib_ifxtable }, { MIB(ifInMulticastPkts), OID_TRD, mib_ifxtable }, { MIB(ifInBroadcastPkts), OID_TRD, mib_ifxtable }, { MIB(ifOutMulticastPkts), OID_TRD, mib_ifxtable }, { MIB(ifOutBroadcastPkts), OID_TRD, mib_ifxtable }, { MIB(ifHCInOctets), OID_TRD, mib_ifxtable }, { MIB(ifHCInUcastPkts), OID_TRD, mib_ifxtable }, { MIB(ifHCInMulticastPkts), OID_TRD, mib_ifxtable }, { MIB(ifHCInBroadcastPkts), OID_TRD, mib_ifxtable }, { MIB(ifHCOutOctets), OID_TRD, mib_ifxtable }, { MIB(ifHCOutUcastPkts), OID_TRD, mib_ifxtable }, { MIB(ifHCOutMulticastPkts), OID_TRD, mib_ifxtable }, { MIB(ifHCOutBroadcastPkts), OID_TRD, mib_ifxtable }, { MIB(ifLinkUpDownTrapEnable), OID_TRD, mib_ifxtable }, { MIB(ifHighSpeed), OID_TRD, mib_ifxtable }, { MIB(ifPromiscuousMode), OID_TRD, mib_ifxtable }, { MIB(ifConnectorPresent), OID_TRD, mib_ifxtable }, { MIB(ifAlias), OID_TRD, mib_ifxtable }, { MIB(ifCounterDiscontinuityTime), OID_TRD, mib_ifxtable }, { MIB(ifRcvAddressStatus), OID_TRD, mib_ifrcvtable }, { MIB(ifRcvAddressType), OID_TRD, mib_ifrcvtable }, { MIB(ifStackLastChange), OID_RD, mib_ifstacklast }, { MIB(ifNumber), OID_RD, mib_ifnumber }, { MIB(ifIndex), OID_TRD, mib_iftable }, { MIB(ifDescr), OID_TRD, mib_iftable }, { MIB(ifType), OID_TRD, mib_iftable }, { MIB(ifMtu), OID_TRD, mib_iftable }, { MIB(ifSpeed), OID_TRD, mib_iftable }, { MIB(ifPhysAddress), OID_TRD, mib_iftable }, { MIB(ifAdminStatus), OID_TRD, mib_iftable }, { MIB(ifOperStatus), OID_TRD, mib_iftable }, { MIB(ifLastChange), OID_TRD, mib_iftable }, { MIB(ifInOctets), OID_TRD, mib_iftable }, { MIB(ifInUcastPkts), OID_TRD, mib_iftable }, { MIB(ifInNUcastPkts), OID_TRD, mib_iftable }, { MIB(ifInDiscards), OID_TRD, mib_iftable }, { MIB(ifInErrors), OID_TRD, mib_iftable }, { MIB(ifInUnknownProtos), OID_TRD, mib_iftable }, { MIB(ifOutOctets), OID_TRD, mib_iftable }, { MIB(ifOutUcastPkts), OID_TRD, mib_iftable }, { MIB(ifOutNUcastPkts), OID_TRD, mib_iftable }, { MIB(ifOutDiscards), OID_TRD, mib_iftable }, { MIB(ifOutErrors), OID_TRD, mib_iftable }, { MIB(ifOutQLen), OID_TRD, mib_iftable }, { MIB(ifSpecific), OID_TRD, mib_iftable }, { MIBEND } }; int mib_ifnumber(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { *elm = ber_add_integer(*elm, kr_ifnumber()); return (0); } struct kif * mib_ifget(u_int idx) { struct kif *kif; if ((kif = kr_getif(idx)) == NULL) { /* * It may happen that a interface with a specific index * does not exist or has been removed. Jump to the next * available interface index. */ for (kif = kr_getif(0); kif != NULL; kif = kr_getnextif(kif->if_index)) if (kif->if_index > idx) break; if (kif == NULL) return (NULL); } idx = kif->if_index; /* Update interface information */ kr_updateif(idx); if ((kif = kr_getif(idx)) == NULL) { log_debug("mib_ifxtable: interface %d disappeared?", idx); return (NULL); } return (kif); } int mib_iftable(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx = 0; struct kif *kif; long long i; size_t len; int ifq; int mib[] = { CTL_NET, AF_INET, IPPROTO_IP, 0, 0 }; /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_ifEntry]; if ((kif = mib_ifget(idx)) == NULL) return (1); /* Tables need to prepend the OID on their own */ o->bo_id[OIDIDX_ifEntry] = kif->if_index; ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_if]) { case 1: ber = ber_add_integer(ber, kif->if_index); break; case 2: /* * The ifDescr should contain a vendor, product, etc. * but we just use the interface name (like ifName). * The interface name includes the driver name on OpenBSD. */ ber = ber_add_string(ber, kif->if_name); break; case 3: if (kif->if_type >= 0xf0) { /* * It does not make sense to announce the private * interface types for CARP, ENC, PFSYNC, etc. */ ber = ber_add_integer(ber, IFT_OTHER); } else ber = ber_add_integer(ber, kif->if_type); break; case 4: ber = ber_add_integer(ber, kif->if_mtu); break; case 5: ber = ber_add_integer(ber, kif->if_baudrate); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_GAUGE32); break; case 6: if (bcmp(kif->if_lladdr, ether_zeroaddr, sizeof(kif->if_lladdr)) == 0) { ber = ber_add_string(ber, ""); } else { ber = ber_add_nstring(ber, kif->if_lladdr, sizeof(kif->if_lladdr)); } break; case 7: /* ifAdminStatus up(1), down(2), testing(3) */ i = (kif->if_flags & IFF_UP) ? 1 : 2; ber = ber_add_integer(ber, i); break; case 8: /* ifOperStatus */ if ((kif->if_flags & IFF_UP) == 0) { i = 2; /* down(2) */ } else if (LINK_STATE_IS_UP(kif->if_link_state)) { i = 1; /* up(1) */ } else if (kif->if_link_state == LINK_STATE_DOWN) { i = 7; /* lowerLayerDown(7) or dormant(5)? */ } else i = 4; /* unknown(4) */ ber = ber_add_integer(ber, i); break; case 9: ber = ber_add_integer(ber, kif->if_ticks); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_TIMETICKS); break; case 10: ber = ber_add_integer(ber, (u_int32_t)kif->if_ibytes); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 11: ber = ber_add_integer(ber, (u_int32_t)kif->if_ipackets); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 12: ber = ber_add_integer(ber, (u_int32_t)kif->if_imcasts); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 13: ber = ber_add_integer(ber, (u_int32_t)kif->if_iqdrops); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 14: ber = ber_add_integer(ber, (u_int32_t)kif->if_ierrors); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 15: ber = ber_add_integer(ber, (u_int32_t)kif->if_noproto); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 16: ber = ber_add_integer(ber, (u_int32_t)kif->if_obytes); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 17: ber = ber_add_integer(ber, (u_int32_t)kif->if_opackets); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 18: ber = ber_add_integer(ber, (u_int32_t)kif->if_omcasts); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 19: mib[3] = IPCTL_IFQUEUE; mib[4] = IFQCTL_DROPS; len = sizeof(ifq); if (sysctl(mib, sizeofa(mib), &ifq, &len, 0, 0) == -1) { log_info("mib_iftable: %s: invalid ifq: %s", kif->if_name, strerror(errno)); return (-1); } ber = ber_add_integer(ber, ifq); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 20: ber = ber_add_integer(ber, (u_int32_t)kif->if_oerrors); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 21: mib[3] = IPCTL_IFQUEUE; mib[4] = IFQCTL_LEN; len = sizeof(ifq); if (sysctl(mib, sizeofa(mib), &ifq, &len, 0, 0) == -1) { log_info("mib_iftable: %s: invalid ifq: %s", kif->if_name, strerror(errno)); return (-1); } ber = ber_add_integer(ber, ifq); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_GAUGE32); break; case 22: ber = ber_add_oid(ber, &zerodotzero); break; default: return (-1); } return (0); } int mib_ifxtable(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx = 0; struct kif *kif; int i = 0; /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_ifXEntry]; if ((kif = mib_ifget(idx)) == NULL) return (1); /* Tables need to prepend the OID on their own */ o->bo_id[OIDIDX_ifXEntry] = kif->if_index; ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_ifX]) { case 1: ber = ber_add_string(ber, kif->if_name); break; case 2: ber = ber_add_integer(ber, (u_int32_t)kif->if_imcasts); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 3: ber = ber_add_integer(ber, 0); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 4: ber = ber_add_integer(ber, (u_int32_t)kif->if_omcasts); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 5: ber = ber_add_integer(ber, 0); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); break; case 6: ber = ber_add_integer(ber, (u_int64_t)kif->if_ibytes); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 7: ber = ber_add_integer(ber, (u_int64_t)kif->if_ipackets); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 8: ber = ber_add_integer(ber, (u_int64_t)kif->if_imcasts); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 9: ber = ber_add_integer(ber, 0); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 10: ber = ber_add_integer(ber, (u_int64_t)kif->if_obytes); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 11: ber = ber_add_integer(ber, (u_int64_t)kif->if_opackets); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 12: ber = ber_add_integer(ber, (u_int64_t)kif->if_omcasts); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 13: ber = ber_add_integer(ber, 0); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; case 14: ber = ber_add_integer(ber, 0); /* enabled(1), disabled(2) */ break; case 15: i = kif->if_baudrate >= 1000000 ? kif->if_baudrate / 1000000 : 0; ber = ber_add_integer(ber, i); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_GAUGE32); break; case 16: /* ifPromiscuousMode: true(1), false(2) */ i = kif->if_flags & IFF_PROMISC ? 1 : 2; ber = ber_add_integer(ber, i); break; case 17: /* ifConnectorPresent: false(2), true(1) */ i = kif->if_type == IFT_ETHER ? 1 : 2; ber = ber_add_integer(ber, i); break; case 18: ber = ber_add_string(ber, kif->if_descr); break; case 19: ber = ber_add_integer(ber, 0); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_TIMETICKS); break; default: return (-1); } return (0); } int mib_ifstacklast(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; ber = ber_add_integer(ber, kr_iflastchange()); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_TIMETICKS); return (0); } int mib_ifrcvtable(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx = 0; struct kif *kif; u_int i = 0; /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_ifRcvAddressEntry]; if ((kif = mib_ifget(idx)) == NULL) return (1); /* * The lladdr of the interface will be encoded in the returned OID * ifRcvAddressX.ifindex.6.x.x.x.x.x.x = val * Thanks to the virtual cloner interfaces, it is an easy 1:1 * mapping in OpenBSD; only one lladdr (MAC) address per interface. */ /* first set the base OID and caluculate the length */ idx = 0; o->bo_id[OIDIDX_ifRcvAddressEntry + idx++] = kif->if_index; o->bo_id[OIDIDX_ifRcvAddressEntry + idx] = 0; smi_oidlen(o); /* extend the OID with the lladdr length and octets */ o->bo_id[OIDIDX_ifRcvAddressEntry + idx++] = sizeof(kif->if_lladdr); o->bo_n++; for (i = 0; i < sizeof(kif->if_lladdr); i++, o->bo_n++) o->bo_id[OIDIDX_ifRcvAddressEntry + idx++] = kif->if_lladdr[i]; /* write OID */ ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_ifRcvAddress]) { case 2: /* ifRcvAddressStatus: RowStatus active(1), notInService(2) */ i = kif->if_flags & IFF_UP ? 1 : 2; ber = ber_add_integer(ber, i); break; case 3: /* ifRcvAddressType: other(1), volatile(2), nonVolatile(3) */ ber = ber_add_integer(ber, 1); break; default: return (-1); } return (0); } /* * Defined in OPENBSD-SENSORS-MIB.txt * (http://packetmischief.ca/openbsd/snmp/) */ int mib_sensornum(struct oid *, struct ber_oid *, struct ber_element **); int mib_sensors(struct oid *, struct ber_oid *, struct ber_element **); const char *mib_sensorunit(struct sensor *); char *mib_sensorvalue(struct sensor *); int mib_memiftable(struct oid *, struct ber_oid *, struct ber_element **); static struct oid openbsd_mib[] = { { MIB(sensorMIBObjects), OID_MIB }, { MIB(sensorNumber), OID_RD, mib_sensornum }, { MIB(sensorIndex), OID_TRD, mib_sensors }, { MIB(sensorDescr), OID_TRD, mib_sensors }, { MIB(sensorType), OID_TRD, mib_sensors }, { MIB(sensorDevice), OID_TRD, mib_sensors }, { MIB(sensorValue), OID_TRD, mib_sensors }, { MIB(sensorUnits), OID_TRD, mib_sensors }, { MIB(sensorStatus), OID_TRD, mib_sensors }, { MIB(memMIBObjects), OID_MIB }, { MIB(memMIBVersion), OID_RD, mps_getint, NULL, NULL, OIDVER_OPENBSD_MEM }, { MIB(memIfName), OID_TRD, mib_memiftable }, { MIB(memIfLiveLocks), OID_TRD, mib_memiftable }, { MIBEND } }; int mib_sensornum(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct sensordev sensordev; size_t len = sizeof(sensordev); int mib[] = { CTL_HW, HW_SENSORS, 0 }; int i, c; for (i = c = 0; i < MAXSENSORDEVICES; i++) { mib[2] = i; if (sysctl(mib, sizeofa(mib), &sensordev, &len, NULL, 0) == -1) { if (errno != ENOENT) return (-1); continue; } c += sensordev.sensors_count; } *elm = ber_add_integer(*elm, c); return (0); } int mib_sensors(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; struct sensordev sensordev; size_t len = sizeof(sensordev); struct sensor sensor; size_t slen = sizeof(sensor); int mib[] = { CTL_HW, HW_SENSORS, 0, 0, 0 }; int i, j, k; u_int32_t idx = 0, n; char *s; /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_sensorEntry]; for (i = 0, n = 1; i < MAXSENSORDEVICES; i++) { mib[2] = i; if (sysctl(mib, 3, &sensordev, &len, NULL, 0) == -1) { if (errno != ENOENT) return (-1); continue; } for (j = 0; j < SENSOR_MAX_TYPES; j++) { mib[3] = j; for (k = 0; k < sensordev.maxnumt[j]; k++, n++) { mib[4] = k; if (sysctl(mib, 5, &sensor, &slen, NULL, 0) == -1) { if (errno != ENOENT) return (-1); continue; } if (n == idx) goto found; } } } return (1); found: ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_sensor]) { case 1: ber = ber_add_integer(ber, (int32_t)n); break; case 2: ber = ber_add_string(ber, sensor.desc); break; case 3: ber = ber_add_integer(ber, sensor.type); break; case 4: ber = ber_add_string(ber, sensordev.xname); break; case 5: if ((s = mib_sensorvalue(&sensor)) == NULL) return (-1); ber = ber_add_string(ber, s); free(s); break; case 6: ber = ber_add_string(ber, mib_sensorunit(&sensor)); break; case 7: ber = ber_add_integer(ber, sensor.status); break; } return (0); } #define SENSOR_DRIVE_STATES (SENSOR_DRIVE_PFAIL + 1) static const char * const sensor_drive_s[SENSOR_DRIVE_STATES] = { NULL, "empty", "ready", "powerup", "online", "idle", "active", "rebuild", "powerdown", "fail", "pfail" }; static const char * const sensor_unit_s[SENSOR_MAX_TYPES + 1] = { "degC", "RPM", "V DC", "V AC", "Ohm", "W", "A", "Wh", "Ah", "", "", "%", "lx", "", "sec", "" }; const char * mib_sensorunit(struct sensor *s) { u_int idx; idx = s->type > SENSOR_MAX_TYPES ? SENSOR_MAX_TYPES : s->type; return (sensor_unit_s[idx]); } char * mib_sensorvalue(struct sensor *s) { char *v; int ret = -1; switch (s->type) { case SENSOR_TEMP: ret = asprintf(&v, "%.2f", (s->value - 273150000) / 1000000.0); break; case SENSOR_VOLTS_DC: case SENSOR_VOLTS_AC: case SENSOR_WATTS: case SENSOR_AMPS: case SENSOR_WATTHOUR: case SENSOR_AMPHOUR: case SENSOR_LUX: ret = asprintf(&v, "%.2f", s->value / 1000000.0); break; case SENSOR_INDICATOR: ret = asprintf(&v, "%s", s->value ? "on" : "off"); break; case SENSOR_PERCENT: ret = asprintf(&v, "%.2f%%", s->value / 1000.0); break; case SENSOR_TIMEDELTA: ret = asprintf(&v, "%.6f", s->value / 1000000000.0); break; case SENSOR_DRIVE: if (s->value > 0 && s->value < SENSOR_DRIVE_STATES) { ret = asprintf(&v, "%s", sensor_drive_s[s->value]); break; } /* FALLTHROUGH */ case SENSOR_FANRPM: case SENSOR_INTEGER: default: ret = asprintf(&v, "%lld", s->value); break; } if (ret == -1) return (NULL); return (v); } int mib_memiftable(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx = 0; struct kif *kif; idx = o->bo_id[OIDIDX_memIfEntry]; if ((kif = mib_ifget(idx)) == NULL) return (1); o->bo_id[OIDIDX_memIfEntry] = kif->if_index; ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_memIf]) { case 1: ber = ber_add_string(ber, kif->if_name); break; case 2: ber = ber_add_integer(ber, kif->if_data.ifi_livelocks); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_COUNTER64); break; default: return (-1); } return (0); } /* * Defined in IP-MIB.txt */ int mib_getipstat(struct ipstat *); int mib_ipstat(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipforwarding(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipdefaultttl(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipinhdrerrs(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipinaddrerrs(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipforwdgrams(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipindiscards(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipreasmfails(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipfragfails(struct oid *, struct ber_oid *, struct ber_element **); int mib_iproutingdiscards(struct oid *, struct ber_oid *, struct ber_element **); int mib_ipaddr(struct oid *, struct ber_oid *, struct ber_element **); struct ber_oid * mib_ipaddrtable(struct oid *, struct ber_oid *, struct ber_oid *); static struct oid ip_mib[] = { { MIB(ipMIB), OID_MIB }, { MIB(ipForwarding), OID_RD, mib_ipforwarding }, { MIB(ipDefaultTTL), OID_RD, mib_ipdefaultttl }, { MIB(ipInReceives), OID_RD, mib_ipstat }, { MIB(ipInHdrErrors), OID_RD, mib_ipinhdrerrs }, { MIB(ipInAddrErrors), OID_RD, mib_ipinaddrerrs }, { MIB(ipForwDatagrams), OID_RD, mib_ipforwdgrams }, { MIB(ipInUnknownProtos), OID_RD, mib_ipstat }, #ifdef notyet { MIB(ipInDiscards) }, #endif { MIB(ipInDelivers), OID_RD, mib_ipstat }, { MIB(ipOutRequests), OID_RD, mib_ipstat }, { MIB(ipOutDiscards), OID_RD, mib_ipstat }, { MIB(ipOutNoRoutes), OID_RD, mib_ipstat }, { MIB(ipReasmTimeout), OID_RD, mps_getint, NULL, NULL, IPFRAGTTL }, { MIB(ipReasmReqds), OID_RD, mib_ipstat }, { MIB(ipReasmOKs), OID_RD, mib_ipstat }, { MIB(ipReasmFails), OID_RD, mib_ipreasmfails }, { MIB(ipFragOKs), OID_RD, mib_ipstat }, { MIB(ipFragFails), OID_RD, mib_ipfragfails }, { MIB(ipFragCreates), OID_RD, mib_ipstat }, { MIB(ipAdEntAddr), OID_TRD, mib_ipaddr, NULL, mib_ipaddrtable }, { MIB(ipAdEntIfIndex), OID_TRD, mib_ipaddr, NULL, mib_ipaddrtable }, { MIB(ipAdEntNetMask), OID_TRD, mib_ipaddr, NULL, mib_ipaddrtable }, { MIB(ipAdEntBcastAddr), OID_TRD, mib_ipaddr, NULL, mib_ipaddrtable }, { MIB(ipAdEntReasmMaxSize), OID_TRD, mib_ipaddr, NULL, mib_ipaddrtable }, #ifdef notyet { MIB(ipNetToMediaIfIndex) }, { MIB(ipNetToMediaPhysAddress) }, { MIB(ipNetToMediaNetAddress) }, { MIB(ipNetToMediaType) }, { MIB(ipRoutingDiscards) }, #endif { MIBEND } }; int mib_ipforwarding(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { int mib[] = { CTL_NET, AF_INET, IPPROTO_IP, IPCTL_FORWARDING }; int v; size_t len = sizeof(v); if (sysctl(mib, sizeofa(mib), &v, &len, NULL, 0) == -1) return (-1); *elm = ber_add_integer(*elm, v); return (0); } int mib_ipdefaultttl(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { int mib[] = { CTL_NET, AF_INET, IPPROTO_IP, IPCTL_DEFTTL }; int v; size_t len = sizeof(v); if (sysctl(mib, sizeofa(mib), &v, &len, NULL, 0) == -1) return (-1); *elm = ber_add_integer(*elm, v); return (0); } int mib_getipstat(struct ipstat *ipstat) { int mib[] = { CTL_NET, AF_INET, IPPROTO_IP, IPCTL_STATS }; size_t len = sizeof(*ipstat); return (sysctl(mib, sizeofa(mib), ipstat, &len, NULL, 0)); } int mib_ipstat(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ipstat ipstat; long long i; struct statsmap { u_int8_t m_id; u_long *m_ptr; } mapping[] = { { 3, &ipstat.ips_total }, { 7, &ipstat.ips_noproto }, { 9, &ipstat.ips_delivered }, { 10, &ipstat.ips_localout }, { 11, &ipstat.ips_odropped }, { 12, &ipstat.ips_noroute }, { 14, &ipstat.ips_fragments }, { 15, &ipstat.ips_reassembled }, { 17, &ipstat.ips_fragmented }, { 19, &ipstat.ips_ofragments } }; if (mib_getipstat(&ipstat) == -1) return (-1); for (i = 0; (u_int)i < (sizeof(mapping) / sizeof(mapping[0])); i++) { if (oid->o_oid[OIDIDX_ip] == mapping[i].m_id) { *elm = ber_add_integer(*elm, *mapping[i].m_ptr); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); return (0); } } return (-1); } int mib_ipinhdrerrs(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { u_int32_t errors; struct ipstat ipstat; if (mib_getipstat(&ipstat) == -1) return (-1); errors = ipstat.ips_badsum + ipstat.ips_badvers + ipstat.ips_tooshort + ipstat.ips_toosmall + ipstat.ips_badhlen + ipstat.ips_badlen + ipstat.ips_badoptions + ipstat.ips_toolong + ipstat.ips_badaddr; *elm = ber_add_integer(*elm, errors); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); return (0); } int mib_ipinaddrerrs(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { u_int32_t errors; struct ipstat ipstat; if (mib_getipstat(&ipstat) == -1) return (-1); errors = ipstat.ips_cantforward + ipstat.ips_badaddr; *elm = ber_add_integer(*elm, errors); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); return (0); } int mib_ipforwdgrams(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { u_int32_t counter; struct ipstat ipstat; if (mib_getipstat(&ipstat) == -1) return (-1); counter = ipstat.ips_forward + ipstat.ips_redirectsent; *elm = ber_add_integer(*elm, counter); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); return (0); } int mib_ipindiscards(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { return (0); } int mib_ipreasmfails(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { u_int32_t counter; struct ipstat ipstat; if (mib_getipstat(&ipstat) == -1) return (-1); counter = ipstat.ips_fragdropped + ipstat.ips_fragtimeout; *elm = ber_add_integer(*elm, counter); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); return (0); } int mib_ipfragfails(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { u_int32_t counter; struct ipstat ipstat; if (mib_getipstat(&ipstat) == -1) return (-1); counter = ipstat.ips_badfrags + ipstat.ips_cantfrag; *elm = ber_add_integer(*elm, counter); ber_set_header(*elm, BER_CLASS_APPLICATION, SNMP_T_COUNTER32); return (0); } int mib_iproutingdiscards(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { return (0); } struct ber_oid * mib_ipaddrtable(struct oid *oid, struct ber_oid *o, struct ber_oid *no) { u_int32_t col, id; struct oid a, b; struct in_addr addr; struct kif_addr *ka; bcopy(&oid->o_id, no, sizeof(*no)); id = oid->o_oidlen - 1; if (o->bo_n >= oid->o_oidlen) { /* * Compare the requested and the matched OID to see * if we have to iterate to the next element. */ bzero(&a, sizeof(a)); bcopy(o, &a.o_id, sizeof(struct ber_oid)); bzero(&b, sizeof(b)); bcopy(&oid->o_id, &b.o_id, sizeof(struct ber_oid)); b.o_oidlen--; b.o_flags |= OID_TABLE; if (smi_oid_cmp(&a, &b) == 0) { col = oid->o_oid[id]; o->bo_id[id] = col; bcopy(o, no, sizeof(*no)); } } mps_decodeinaddr(no, &addr, OIDIDX_ipAddr + 1); if (addr.s_addr == INADDR_ANY) ka = kr_getaddr(NULL); else ka = kr_getnextaddr(&addr); addr.s_addr = ka == NULL ? 0 : ka->addr.s_addr; mps_encodeinaddr(no, &addr, OIDIDX_ipAddr + 1); smi_oidlen(o); return (no); } int mib_ipaddr(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; struct kif_addr *ka; struct in_addr addr; u_int32_t val; mps_decodeinaddr(o, &addr, OIDIDX_ipAddr + 1); ka = kr_getaddr(&addr); if (ka == NULL) return (1); /* write OID */ ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_ipAddr]) { case 1: val = addr.s_addr; ber = ber_add_nstring(ber, (char *)&val, sizeof(u_int32_t)); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_IPADDR); break; case 2: ber = ber_add_integer(ber, ka->if_index); break; case 3: val = ka->mask.s_addr; ber = ber_add_nstring(ber, (char *)&val, sizeof(u_int32_t)); ber_set_header(ber, BER_CLASS_APPLICATION, SNMP_T_IPADDR); break; case 4: ber = ber_add_integer(ber, ka->dstbrd.s_addr ? 1 : 0); break; case 5: ber = ber_add_integer(ber, IP_MAXPACKET); break; default: return (-1); } return (0); } /* * Defined in BRIDGE-MIB.txt (rfc1493) * * This MIB is required by some NMS to accept the device because * the RFC says that mostly any network device has to provide this MIB... :( */ int mib_dot1dtable(struct oid *, struct ber_oid *, struct ber_element **); static struct oid bridge_mib[] = { { MIB(dot1dBridge), OID_MIB }, { MIB(dot1dBaseBridgeAddress) }, { MIB(dot1dBaseNumPorts), OID_RD, mib_ifnumber }, { MIB(dot1dBaseType), OID_RD, mps_getint, NULL, NULL, 4 /* srt (sourceroute + transparent) */ }, { MIB(dot1dBasePort), OID_TRD, mib_dot1dtable }, { MIB(dot1dBasePortIfIndex), OID_TRD, mib_dot1dtable }, { MIB(dot1dBasePortCircuit), OID_TRD, mib_dot1dtable}, { MIB(dot1dBasePortDelayExceededDiscards), OID_TRD, mib_dot1dtable }, { MIB(dot1dBasePortMtuExceededDiscards), OID_TRD, mib_dot1dtable }, { MIBEND } }; int mib_dot1dtable(struct oid *oid, struct ber_oid *o, struct ber_element **elm) { struct ber_element *ber = *elm; u_int32_t idx = 0; struct kif *kif; /* Get and verify the current row index */ idx = o->bo_id[OIDIDX_dot1dEntry]; if ((kif = mib_ifget(idx)) == NULL) return (1); /* Tables need to prepend the OID on their own */ o->bo_id[OIDIDX_dot1dEntry] = kif->if_index; ber = ber_add_oid(ber, o); switch (o->bo_id[OIDIDX_dot1d]) { case 1: case 2: ber = ber_add_integer(ber, kif->if_index); break; case 3: ber = ber_add_oid(ber, &zerodotzero); break; case 4: case 5: ber = ber_add_integer(ber, 0); break; } return (0); } /* * Import all MIBs */ void mib_init(void) { /* * MIB declarations (to register the OID names) */ smi_mibtree(mib_tree); /* * MIB definitions (the implementation) */ /* SNMPv2-MIB */ smi_mibtree(base_mib); /* HOST-RESOURCES-MIB */ smi_mibtree(hr_mib); /* IF-MIB */ smi_mibtree(if_mib); /* IP-MIB */ smi_mibtree(ip_mib); /* BRIDGE-MIB */ smi_mibtree(bridge_mib); /* OPENBSD-MIB */ smi_mibtree(openbsd_mib); }