/usr/src/libexec/snmpd/snmpd

Bug Summary

File:	src/libexec/snmpd/snmpd_metrics/mib.c
Warning:	line 3360, column 7 Although the value stored to 'hrSystemUptime' is used in the enclosing expression, the value is never actually read from 'hrSystemUptime'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name mib.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/libexec/snmpd/snmpd_metrics/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/libexec/snmpd/snmpd_metrics -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/libexec/snmpd/snmpd_metrics/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/libexec/snmpd/snmpd_metrics/mib.c

1	/* $OpenBSD: mib.c,v 1.7 2023/11/21 08:49:08 martijn Exp $ */
2
3	/*
4	* Copyright (c) 2022 Martijn van Duren <martijn@openbsd.org>
5	* Copyright (c) 2012 Joel Knight <joel@openbsd.org>
6	* Copyright (c) 2007, 2008, 2012 Reyk Floeter <reyk@openbsd.org>
7	*
8	* Permission to use, copy, modify, and distribute this software for any
9	* purpose with or without fee is hereby granted, provided that the above
10	* copyright notice and this permission notice appear in all copies.
11	*
12	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19	*/
20
21	#include <sys/types.h>
22	#include <sys/signal.h>
23	#include <sys/queue.h>
24	#include <sys/proc.h>
25	#include <sys/stat.h>
26	#include <sys/socket.h>
27	#include <sys/un.h>
28	#include <sys/time.h>
29	#include <sys/tree.h>
30	#include <sys/utsname.h>
31	#include <sys/sysctl.h>
32	#include <sys/sensors.h>
33	#include <sys/sched.h>
34	#include <sys/mount.h>
35	#include <sys/ioctl.h>
36	#include <sys/disk.h>
37
38	#include <netinet/in.h>
39	#include <netinet/ip.h>
40	#include <netinet/ip_carp.h>
41	#include <netinet/ip_var.h>
42	#include <arpa/inet.h>
43	#include <net/if.h>
44	#include <net/if_types.h>
45	#include <net/pfvar.h>
46	#include <netinet/ip_ipsp.h>
47	#include <net/if_pfsync.h>
48
49	#include <stdlib.h>
50	#include <stdio.h>
51	#include <errno(*__errno()).h>
52	#include <event.h>
53	#include <fcntl.h>
54	#include <grp.h>
55	#include <pwd.h>
56	#include <string.h>
57	#include <syslog.h>
58	#include <time.h>
59	#include <unistd.h>
60	#include <libgen.h>
61	#include <limits.h>
62	#include <kvm.h>
63
64	#include "log.h"
65	#include "snmpd.h"
66	#include "mib.h"
67
68	struct event connev;
69	const char agentxsocket = NULL((void )0);
70	int agentxfd = -1;
71
72	int pageshift;
73	#define pagetok(size)((size) << pageshift) ((size) << pageshift)
74
75	void pageshift_init(void);
76	void snmp_connect(struct agentx , void , int);
77	void snmp_tryconnect(int, short, void *);
78	void snmp_read(int, short, void *);
79
80	struct agentx_context *sac;
81	struct snmpd *snmpd_env;
82
83	/* HOST-RESOURCES-MIB */
84	struct agentx_object hrSystemProcesses, hrSystemMaxProcesses;
85	struct agentx_index *hrStorageIdx;
86	struct agentx_object hrStorageIndex, hrStorageType, *hrStorageDescr;
87	struct agentx_object hrStorageAllocationUnits, hrStorageSize, *hrStorageUsed;
88	struct agentx_object *hrStorageAllocationFailures;
89	struct agentx_index *hrDeviceIdx;
90	struct agentx_object hrDeviceIndex, hrDeviceType, hrDeviceDescr, hrDeviceID;
91	struct agentx_object hrDeviceStatus, hrDeviceErrors, *hrProcessorFrwID;
92	struct agentx_object *hrProcessorLoad;
93	struct agentx_index *hrSWRunIdx;
94	struct agentx_object hrSWRunIndex, hrSWRunName, hrSWRunID, hrSWRunPath;
95	struct agentx_object hrSWRunParameters, hrSWRunType, *hrSWRunStatus;
96	struct agentx_object hrSWRunPerfCPU, hrSWRunPerfMem;
97
98	void mib_hrsystemuptime(struct agentx_varbind *);
99	void mib_hrsystemdate(struct agentx_varbind *);
100	void mib_hrsystemprocs(struct agentx_varbind *);
101	void mib_hrmemory(struct agentx_varbind *);
102	void mib_hrstorage(struct agentx_varbind *);
103	void mib_hrdevice(struct agentx_varbind *);
104	void mib_hrprocessor(struct agentx_varbind *);
105	void mib_hrswrun(struct agentx_varbind *);
106
107	int kinfo_proc_comp(const void , const void );
108	int kinfo_proc(u_int32_t, struct kinfo_proc **);
109	void kinfo_timer_cb(int, short, void *);
110	void kinfo_proc_free(void);
111	int kinfo_args(struct kinfo_proc , char **);
112	int kinfo_path(struct kinfo_proc , char *);
113	int kinfo_parameters(struct kinfo_proc , char *);
114
115	/* IF-MIB */
116	struct agentx_index *ifIdx;
117	struct agentx_object ifName, ifInMulticastPkts, *ifInBroadcastPkts;
118	struct agentx_object ifOutMulticastPkts, ifOutBroadcastPkts;
119	struct agentx_object ifOutBroadcastPkts, ifHCInOctets, *ifHCInUcastPkts;
120	struct agentx_object ifHCInMulticastPkts, ifHCInBroadcastPkts, *ifHCOutOctets;
121	struct agentx_object ifHCOutUcastPkts, ifHCOutMulticastPkts;
122	struct agentx_object ifHCOutBroadcastPkts, ifLinkUpDownTrapEnable;
123	struct agentx_object ifHighSpeed, ifPromiscuousMode, *ifConnectorPresent;
124	struct agentx_object ifAlias, ifCounterDiscontinuityTime;
125	struct agentx_index *ifRcvAddressAddress;
126	struct agentx_object ifRcvAddressStatus, ifRcvAddressType;
127	struct agentx_object ifStackLastChange, ifNumber, ifIndex, ifDescr, *ifType;
128	struct agentx_object ifMtu, ifSpeed, ifPhysAddress, ifAdminStatus;
129	struct agentx_object ifOperStatus, ifLastChange, ifInOctets, ifInUcastPkts;
130	struct agentx_object ifInNUcastPkts, ifInDiscards, *ifInErrors;
131	struct agentx_object ifInUnknownProtos, ifOutOctets, *ifOutUcastPkts;
132	struct agentx_object ifOutNUcastPkts, ifOutDiscards, ifOutErrors, ifOutQLen;
133	struct agentx_object *ifSpecific;
134
135	/* OPENBSD-PF-MIB */
136	struct agentx_object pfRunning, pfRuntime, pfDebug, pfHostid;
137	struct agentx_object pfCntMatch, pfCntBadOffset, pfCntFragment, pfCntShort;
138	struct agentx_object pfCntNormalize, pfCntMemory, *pfCntTimestamp;
139	struct agentx_object pfCntCongestion, pfCntIpOption, *pfCntProtoCksum;
140	struct agentx_object pfCntStateMismatch, pfCntStateInsert, *pfCntStateLimit;
141	struct agentx_object pfCntSrcLimit, pfCntSynproxy, *pfCntTranslate;
142	struct agentx_object *pfCntNoRoute;
143	struct agentx_object pfStateCount, pfStateSearches, *pfStateInserts;
144	struct agentx_object *pfStateRemovals;
145	struct agentx_object pfLogIfName, pfLogIfIpBytesIn, *pfLogIfIpBytesOut;
146	struct agentx_object pfLogIfIpPktsInPass, pfLogIfIpPktsInDrop;
147	struct agentx_object pfLogIfIpPktsOutPass, pfLogIfIpPktsOutDrop;
148	struct agentx_object pfLogIfIp6BytesIn, pfLogIfIp6BytesOut;
149	struct agentx_object pfLogIfIp6PktsInPass, pfLogIfIp6PktsInDrop;
150	struct agentx_object pfLogIfIp6PktsOutPass, pfLogIfIp6PktsOutDrop;
151	struct agentx_object pfSrcTrackCount, pfSrcTrackSearches, *pfSrcTrackInserts;
152	struct agentx_object *pfSrcTrackRemovals;
153	struct agentx_object pfLimitStates, pfLimitSourceNodes, *pfLimitFragments;
154	struct agentx_object pfLimitMaxTables, pfLimitMaxTableEntries;
155	struct agentx_object pfTimeoutTcpFirst, pfTimeoutTcpOpening;
156	struct agentx_object pfTimeoutTcpEstablished, pfTimeoutTcpClosing;
157	struct agentx_object pfTimeoutTcpFinWait, pfTimeoutTcpClosed;
158	struct agentx_object pfTimeoutUdpFirst, pfTimeoutUdpSingle;
159	struct agentx_object pfTimeoutUdpMultiple, pfTimeoutIcmpFirst;
160	struct agentx_object pfTimeoutIcmpError, pfTimeoutOtherFirst;
161	struct agentx_object pfTimeoutOtherSingle, pfTimeoutOtherMultiple;
162	struct agentx_object pfTimeoutFragment, pfTimeoutInterval, *pfTimeoutInterval;
163	struct agentx_object pfTimeoutAdaptiveStart, pfTimeoutAdaptiveEnd;
164	struct agentx_object *pfTimeoutSrcTrack;
165	struct agentx_index *pfIfIdx;
166	struct agentx_object pfIfNumber, pfIfIndex, pfIfDescr, pfIfType, *pfIfRefs;
167	struct agentx_object pfIfRules, pfIfIn4PassPkts, *pfIfIn4PassBytes;
168	struct agentx_object pfIfIn4BlockPkts, pfIfIn4BlockBytes, *pfIfOut4PassPkts;
169	struct agentx_object pfIfOut4PassBytes, pfIfOut4BlockPkts;
170	struct agentx_object pfIfOut4BlockBytes, pfIfIn6PassPkts, *pfIfIn6PassBytes;
171	struct agentx_object pfIfIn6BlockPkts, pfIfIn6BlockBytes, *pfIfOut6PassPkts;
172	struct agentx_object pfIfOut6PassBytes, pfIfOut6BlockPkts;
173	struct agentx_object *pfIfOut6BlockBytes;
174	struct agentx_index *pfTblIdx;
175	struct agentx_object pfTblNumber, pfTblIndex, pfTblName, pfTblAddresses;
176	struct agentx_object pfTblAnchorRefs, pfTblRuleRefs, *pfTblEvalsMatch;
177	struct agentx_object pfTblEvalsNoMatch, pfTblInPassPkts, *pfTblInPassBytes;
178	struct agentx_object pfTblInBlockPkts, pfTblInBlockBytes, *pfTblInXPassPkts;
179	struct agentx_object pfTblInXPassBytes, pfTblOutPassPkts, *pfTblOutPassBytes;
180	struct agentx_object pfTblOutBlockPkts, pfTblOutBlockBytes;
181	struct agentx_object pfTblOutXPassPkts, pfTblOutXPassBytes;
182	struct agentx_object pfTblStatsCleared, pfTblInMatchPkts, *pfTblInMatchBytes;
183	struct agentx_object pfTblOutMatchPkts, pfTblOutMatchBytes;
184	struct agentx_index pfTblAddrTblIdx, pfTblAddrNetIdx, *pfTblAddrMaskIdx;
185	struct agentx_object pfTblAddrTblIndex, pfTblAddrNet, *pfTblAddrMask;
186	struct agentx_object pfTblAddrCleared, pfTblAddrInBlockPkts;
187	struct agentx_object pfTblAddrInBlockBytes, pfTblAddrInPassPkts;
188	struct agentx_object pfTblAddrInPassBytes, pfTblAddrOutBlockPkts;
189	struct agentx_object pfTblAddrOutBlockBytes, pfTblAddrOutPassPkts;
190	struct agentx_object pfTblAddrOutPassBytes, pfTblAddrInMatchPkts;
191	struct agentx_object pfTblAddrInMatchBytes, pfTblAddrOutMatchPkts;
192	struct agentx_object *pfTblAddrOutMatchBytes;
193	struct agentx_index *pfLabelIdx;
194	struct agentx_object pfLabelNumber, pfLabelIndex, pfLabelName, pfLabelEvals;
195	struct agentx_object pfLabelPkts, pfLabelBytes, *pfLabelInPkts;
196	struct agentx_object pfLabelInBytes, pfLabelOutPkts, *pfLabelOutBytes;
197	struct agentx_object *pfLabelTotalStates;
198	struct agentx_object pfsyncIpPktsRecv, pfsyncIp6PktsRecv;
199	struct agentx_object *pfsyncPktDiscardsForBadInterface;
200	struct agentx_object pfsyncPktDiscardsForBadTtl, pfsyncPktShorterThanHeader;
201	struct agentx_object *pfsyncPktDiscardsForBadVersion;
202	struct agentx_object *pfsyncPktDiscardsForBadAction;
203	struct agentx_object *pfsyncPktDiscardsForBadLength;
204	struct agentx_object *pfsyncPktDiscardsForBadAuth;
205	struct agentx_object *pfsyncPktDiscardsForStaleState;
206	struct agentx_object *pfsyncPktDiscardsForBadValues;
207	struct agentx_object *pfsyncPktDiscardsForBadState;
208	struct agentx_object pfsyncIpPktsSent, pfsyncIp6PktsSent, *pfsyncNoMemory;
209	struct agentx_object *pfsyncOutputErrors;
210
211	/* OPENBSD-SENSORS-MIB */
212	struct agentx_index *sensorIdx;
213	struct agentx_object sensorNumber, sensorIndex, sensorDescr, sensorType;
214	struct agentx_object sensorDevice, sensorValue, sensorUnits, sensorStatus;
215
216	/* OPENBSD-CARP-MIB */
217	struct agentx_object carpAllow, carpPreempt, *carpLog;
218	struct agentx_index *carpIfIdx;
219	struct agentx_object carpIfNumber, carpIfIndex, carpIfDescr, carpIfVhid;
220	struct agentx_object carpIfDev, carpIfAdvbase, carpIfAdvskew, carpIfState;
221	struct agentx_index *carpGroupIdx;
222	struct agentx_object carpGroupIndex, carpGroupName, *carpGroupDemote;
223	struct agentx_object carpIpPktsRecv, carpIp6PktsRecv;
224	struct agentx_object *carpPktDiscardsForBadInterface;
225	struct agentx_object carpPktDiscardsForWrongTtl, carpPktShorterThanHeader;
226	struct agentx_object *carpPktDiscardsForBadChecksum;
227	struct agentx_object carpPktDiscardsForBadVersion, carpPktDiscardsForTooShort;
228	struct agentx_object carpPktDiscardsForBadAuth, carpPktDiscardsForBadVhid;
229	struct agentx_object carpPktDiscardsForBadAddressList, carpIpPktsSent;
230	struct agentx_object carpIp6PktsSent, carpNoMemory, *carpTransitionsToMaster;
231
232	/* OPENBSD-MEM-MIB */
233	struct agentx_object memMIBVersion, memIfName, *memIfLiveLocks;
234
235	/* IP-MIB */
236	struct agentx_object ipForwarding, ipDefaultTTL, *ipInReceives;
237	struct agentx_object ipInHdrErrors, ipInAddrErrors, *ipForwDatagrams;
238	struct agentx_object ipInUnknownProtos, ipInDelivers, *ipOutRequests;
239	struct agentx_object ipOutDiscards, ipOutNoRoutes, *ipReasmTimeout;
240	struct agentx_object ipReasmReqds, ipReasmOKs, ipReasmFails, ipFragOKs;
241	struct agentx_object ipFragFails, ipFragCreates, *ipAdEntAddr;
242	struct agentx_index *ipAdEntAddrIdx;
243	struct agentx_object ipAdEntAddr, ipAdEntIfIndex, *ipAdEntNetMask;
244	struct agentx_object ipAdEntBcastAddr, ipAdEntReasmMaxSize;
245	struct agentx_index ipNetToMediaIfIdx, ipNetToMediaNetAddressIdx;
246	struct agentx_object ipNetToMediaIfIndex, ipNetToMediaPhysAddress;
247	struct agentx_object ipNetToMediaNetAddress, ipNetToMediaType;
248
249	/* IP-FORWARD-MIB */
250	struct agentx_object *inetCidrRouteNumber;
251	struct agentx_index inetCidrRouteDestTypeIdx, inetCidrRouteDestIdx;
252	struct agentx_index inetCidrRoutePfxLenIdx, inetCidrRoutePolicyIdx;
253	struct agentx_index inetCidrRouteNextHopTypeIdx, inetCidrRouteNextHopIdx;
254	struct agentx_object inetCidrRouteIfIndex, inetCidrRouteType;
255	struct agentx_object inetCidrRouteProto, inetCidrRouteAge;
256	struct agentx_object inetCidrRouteNextHopAS, inetCidrRouteMetric1;
257	struct agentx_object inetCidrRouteMetric2, inetCidrRouteMetric3;
258	struct agentx_object inetCidrRouteMetric4, inetCidrRouteMetric5;
259	struct agentx_object *inetCidrRouteStatus;
260
261	/* UCD-DISKIO-MIB */
262	struct agentx_index *diskIOIdx;
263	struct agentx_object diskIOIndex, diskIODevice, diskIONRead, diskIONWritten;
264	struct agentx_object diskIOReads, diskIOWrites, *diskIONReadX;
265	struct agentx_object *diskIONWrittenX;
266
267	/* BRIDGE-MIB */
268	struct agentx_object dot1dBaseNumPorts, dot1dBaseType;
269	struct agentx_index *dot1dBasePortIdx;
270	struct agentx_object dot1dBasePort, dot1dBasePortIfIndex;
271	struct agentx_object dot1dBasePortCircuit, dot1dBasePortDelayExceededDiscards;
272	struct agentx_object *dot1dBasePortMtuExceededDiscards;
273
274	/* HOST-RESOURCES-MIB */
275	void
276	mib_hrsystemuptime(struct agentx_varbind *vb)
277	{
278	struct timespec uptime;
279	long long ticks;
280
281	if (clock_gettime(CLOCK_BOOTTIME6, &uptime) == -1) {
282	log_warn("clock_gettime");
283	agentx_varbind_error(vb);
284	return;
285	}
286	ticks = uptime.tv_sec * 100 + uptime.tv_nsec / 10000000;
287	agentx_varbind_timeticks(vb, ticks);
288	}
289
290	void
291	mib_hrsystemdate(struct agentx_varbind *vb)
292	{
293	struct tm *ptm;
294	u_char s[11];
295	time_t now;
296	int tzoffset;
297	unsigned short year;
298
299	(void)time(&now);
300	ptm = localtime(&now);
301
302	year = htons(ptm->tm_year + 1900)(__uint16_t)(__builtin_constant_p(ptm->tm_year + 1900) ? ( __uint16_t)(((__uint16_t)(ptm->tm_year + 1900) & 0xffU ) << 8 \| ((__uint16_t)(ptm->tm_year + 1900) & 0xff00U ) >> 8) : __swap16md(ptm->tm_year + 1900));
303	memcpy(s, &year, 2);
304	s[2] = ptm->tm_mon + 1;
305	s[3] = ptm->tm_mday;
306	s[4] = ptm->tm_hour;
307	s[5] = ptm->tm_min;
308	s[6] = ptm->tm_sec;
309	s[7] = 0;
310
311	tzoffset = ptm->tm_gmtoff;
312	if (tzoffset < 0)
313	s[8] = '-';
314	else
315	s[8] = '+';
316
317	s[9] = abs(tzoffset) / 3600;
318	s[10] = (abs(tzoffset) - (s[9] * 3600)) / 60;
319
320	agentx_varbind_nstring(vb, s, sizeof(s));
321	}
322
323	void
324	mib_hrsystemprocs(struct agentx_varbind *vb)
325	{
326	struct agentx_object *obj;
327	char errbuf[_POSIX2_LINE_MAX2048];
328	int val;
329	int mib[] = { CTL_KERN1, KERN_MAXPROC6 };
330	kvm_t *kd;
331	size_t len;
332
333	obj = agentx_varbind_get_object(vb);
334	if (obj == hrSystemProcesses) {
335	if ((kd = kvm_openfiles(NULL((void )0), NULL((void )0), NULL((void *)0),
336	KVM_NO_FILES0x80000000, errbuf)) == NULL((void *)0)) {
337	log_warn("kvm_openfiles");
338	agentx_varbind_error(vb);
339	return;
340	}
341
342	if (kvm_getprocs(kd, KERN_PROC_ALL0, 0,
343	sizeof(struct kinfo_proc), &val) == NULL((void *)0)) {
344	log_warn("kvm_getprocs");
345	kvm_close(kd);
346	agentx_varbind_error(vb);
347	return;
348	}
349
350	agentx_varbind_gauge32(vb, val);
351
352	kvm_close(kd);
353	} else if (obj == hrSystemMaxProcesses) {
354	len = sizeof(val);
355	if (sysctl(mib, 2, &val, &len, NULL((void *)0), 0) == -1) {
356	log_warn("sysctl");
357	agentx_varbind_error(vb);
358	return;
359	}
360
361	agentx_varbind_integer(vb, val);
362	} else
363	fatal("%s: Unexpected object", __func__);
364	}
365
366	void
367	mib_hrmemory(struct agentx_varbind *vb)
368	{
369	int mib[] = { CTL_HW6, HW_PHYSMEM6419 };
370	u_int64_t physmem;
371	size_t len = sizeof(physmem);
372
373	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &physmem, &len, NULL((void *)0), 0) == -1) {
374	log_warn("sysctl");
375	agentx_varbind_error(vb);
376	return;
377	}
378
379	agentx_varbind_integer(vb, physmem / 1024);
380	}
381
382	void
383	mib_hrstorage(struct agentx_varbind *vb)
384	{
385	struct agentx_object *obj;
386	enum agentx_request_type req;
387	int32_t idx;
388	struct statfs mntbuf, mnt;
389	int mntsize, maxsize;
390	uint64_t units, size, used, fail = 0;
391	const char descr = NULL((void )0);
392	int mib[] = { CTL_HW6, 0 };
393	u_int64_t physmem, realmem;
394	struct uvmexp uvm;
395	size_t len;
396	uint32_t sop[] = { HRSTORAGEOTHER1, 3, 6, 1, 2, 1, 25, 2, 1, 1 };
397
398	/* Physical memory, real memory, swap */
399	mib[1] = HW_PHYSMEM6419;
400	len = sizeof(physmem);
401	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &physmem, &len, NULL((void *)0), 0) == -1) {
402	log_warn("sysctl");
403	agentx_varbind_error(vb);
404	return;
405	}
406	mib[1] = HW_USERMEM6420;
407	len = sizeof(realmem);
408	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &realmem, &len, NULL((void *)0), 0) == -1) {
409	log_warn("sysctl");
410	agentx_varbind_error(vb);
411	return;
412	}
413	mib[0] = CTL_VM2;
414	mib[1] = VM_UVMEXP4;
415	len = sizeof(uvm);
416	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &uvm, &len, NULL((void *)0), 0) == -1) {
417	log_warn("sysctl");
418	agentx_varbind_error(vb);
419	return;
420	}
421	maxsize = 10;
422
423	/* Disks */
424	if ((mntsize = getmntinfo(&mntbuf, MNT_NOWAIT2)) == 0) {
425	log_warn("getmntinfo");
426	agentx_varbind_error(vb);
427	return;
428	}
429	maxsize = 30 + mntsize;
430
431	/*
432	* Get and verify the current row index.
433	*
434	* We use a special mapping here that is inspired by other SNMP
435	* agents: index 1 + 2 for RAM, index 10 for swap, index 31 and
436	* higher for disk storage.
437	*/
438	obj = agentx_varbind_get_object(vb);
439	req = agentx_varbind_request(vb);
440	idx = agentx_varbind_get_index_integer(vb, hrStorageIdx);
441	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
442	if (idx == INT32_MAX0x7fffffff) {
443	agentx_varbind_notfound(vb);
444	return;
445	}
446	idx++;
447	}
448	if (idx > maxsize) {
449	agentx_varbind_notfound(vb);
450	return;
451	}
452	if (req == AGENTX_REQUEST_TYPE_GET) {
453	if (idx < 1 \|\| (idx > 2 && idx < 10) \|\|
454	(idx > 10 && idx < 31)) {
455	agentx_varbind_notfound(vb);
456	return;
457	}
458	} else {
459	if (idx < 1)
460	idx = 1;
461	else if (idx > 2 && idx < 10)
462	idx = 10;
463	else if (idx > 10 && idx < 31)
464	idx = 31;
465	}
466
467	switch (idx) {
468	case 1:
469	descr = "Physical memory";
470	units = uvm.pagesize;
471	size = physmem / uvm.pagesize;
472	used = size - uvm.free;
473	memcpy(sop, (uint32_t[]){ HRSTORAGERAM1, 3, 6, 1, 2, 1, 25, 2, 1, 2 }, sizeof(sop));
474	break;
475	case 2:
476	descr = "Real memory";
477	units = uvm.pagesize;
478	size = realmem / uvm.pagesize;
479	used = size - uvm.free;
480	memcpy(sop, (uint32_t[]){ HRSTORAGERAM1, 3, 6, 1, 2, 1, 25, 2, 1, 2 }, sizeof(sop));
481	break;
482	case 10:
483	descr = "Swap space";
484	units = uvm.pagesize;
485	size = uvm.swpages;
486	used = uvm.swpginuse;
487	memcpy(sop, (uint32_t[]){ HRSTORAGEVIRTUALMEMORY1, 3, 6, 1, 2, 1, 25, 2, 1, 3 },
488	sizeof(sop));
489	break;
490	default:
491	mnt = &mntbuf[idx - 31];
492	descr = mnt->f_mntonname;
493	units = mnt->f_bsize;
494	size = mnt->f_blocks;
495	used = mnt->f_blocks - mnt->f_bfree;
496	memcpy(sop, (uint32_t[]){ HRSTORAGEFIXEDDISK1, 3, 6, 1, 2, 1, 25, 2, 1, 4 }, sizeof(sop));
497	break;
498	}
499
500	while (size > INT32_MAX0x7fffffff) {
501	units *= 2;
502	size /= 2;
503	used /= 2;
504	}
505
506	agentx_varbind_set_index_integer(vb, hrStorageIdx, idx);
507
508	if (obj == hrStorageIndex)
509	agentx_varbind_integer(vb, idx);
510	else if (obj == hrStorageType)
511	agentx_varbind_oid(vb, sop, nitems(sop)(sizeof((sop)) / sizeof((sop)[0])));
512	else if (obj == hrStorageDescr)
513	agentx_varbind_string(vb, descr);
514	else if (obj == hrStorageAllocationUnits)
515	agentx_varbind_integer(vb, units);
516	else if (obj == hrStorageSize)
517	agentx_varbind_integer(vb, size);
518	else if (obj == hrStorageUsed)
519	agentx_varbind_integer(vb, used);
520	else if (obj == hrStorageAllocationFailures)
521	agentx_varbind_counter32(vb, fail);
522	else
523	fatal("%s: Unexpected object", __func__);
524	}
525
526	void
527	mib_hrdevice(struct agentx_varbind *vb)
528	{
529	struct agentx_object *obj;
530	enum agentx_request_type req;
531	int32_t idx;
532	uint32_t fail = 0;
533	int status;
534	int mib[] = { CTL_HW6, HW_MODEL2 };
535	size_t len;
536	char descr[BUFSIZ1024];
537	uint32_t sop[] = { HRDEVICEPROCESSOR1, 3, 6, 1, 2, 1, 25, 3, 1, 3 };
538
539	/* Get and verify the current row index */
540	obj = agentx_varbind_get_object(vb);
541	idx = agentx_varbind_get_index_integer(vb, hrDeviceIdx);
542	req = agentx_varbind_request(vb);
543	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
544	if (idx == INT32_MAX0x7fffffff) {
545	agentx_varbind_notfound(vb);
546	return;
547	}
548	idx++;
549	if (idx < 1)
550	idx = 1;
551	} else if (req == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
552	if (idx < 1)
553	idx = 1;
554	}
555	if (idx < 1 \|\| idx > snmpd_env->sc_ncpu) {
556	agentx_varbind_notfound(vb);
557	return;
558	}
559
560	agentx_varbind_set_index_integer(vb, hrDeviceIdx, idx);
561
562	len = sizeof(descr);
563	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &descr, &len, NULL((void *)0), 0) == -1) {
564	log_warn("sysctl");
565	agentx_varbind_error(vb);
566	return;
567	}
568	/* unknown(1), running(2), warning(3), testing(4), down(5) */
569	status = 2;
570
571	if (obj == hrDeviceIndex)
572	agentx_varbind_integer(vb, idx);
573	else if (obj == hrDeviceType)
574	agentx_varbind_oid(vb, sop, nitems(sop)(sizeof((sop)) / sizeof((sop)[0])));
575	else if (obj == hrDeviceDescr)
576	agentx_varbind_string(vb, descr);
577	else if (obj == hrDeviceID)
578	agentx_varbind_oid(vb, AGENTX_OID(0, 0)(uint32_t []) { 0, 0 }, (sizeof((uint32_t []) { 0, 0 }) / sizeof (uint32_t)));
579	else if (obj == hrDeviceStatus)
580	agentx_varbind_integer(vb, status);
581	else if (obj == hrDeviceErrors)
582	agentx_varbind_counter32(vb, fail);
583	else
584	fatal("%s: Unexpected object", __func__);
585	}
586
587	void
588	mib_hrprocessor(struct agentx_varbind *vb)
589	{
590	struct agentx_object *obj;
591	enum agentx_request_type req;
592	int32_t idx;
593	int64_t *cptime2, val;
594
595	obj = agentx_varbind_get_object(vb);
596	idx = agentx_varbind_get_index_integer(vb, hrDeviceIdx);
597	req = agentx_varbind_request(vb);
598	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
599	if (idx == INT32_MAX0x7fffffff) {
600	agentx_varbind_notfound(vb);
601	return;
602	}
603	idx++;
604	if (idx < 1)
605	idx = 1;
606	}
607	else if (req == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
608	if (idx < 1)
609	idx = 1;
610	}
611	if (idx < 1 \|\| idx > snmpd_env->sc_ncpu) {
612	agentx_varbind_notfound(vb);
613	return;
614	}
615
616	agentx_varbind_set_index_integer(vb, hrDeviceIdx, idx);
617
618	if (obj == hrProcessorFrwID)
619	agentx_varbind_oid(vb, AGENTX_OID(0, 0)(uint32_t []) { 0, 0 }, (sizeof((uint32_t []) { 0, 0 }) / sizeof (uint32_t)));
620	else if (obj == hrProcessorLoad) {
621	/*
622	* The percentage of time that the system was not
623	* idle during the last minute.
624	*/
625	if (snmpd_env->sc_cpustates == NULL((void *)0)) {
626	log_warnx("cpustates not initialized");
627	agentx_varbind_error(vb);
628	return;
629	}
630	cptime2 = snmpd_env->sc_cpustates + (CPUSTATES6 * (idx - 1));
631	val = 100 -
632	(cptime2[CP_IDLE5] > 1000 ? 1000 : (cptime2[CP_IDLE5] / 10));
633	agentx_varbind_integer(vb, val);
634	} else
635	fatal("%s: Unexpected object", __func__);
636	}
637
638	void
639	mib_hrswrun(struct agentx_varbind *vb)
640	{
641	struct agentx_object *obj;
642	enum agentx_request_type req;
643	int32_t idx;
644	int32_t time;
645	struct kinfo_proc *kinfo;
646	char *s;
647
648	obj = agentx_varbind_get_object(vb);
649	idx = agentx_varbind_get_index_integer(vb, hrSWRunIdx);
650	req = agentx_varbind_request(vb);
651
652	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
653	if (idx == INT32_MAX0x7fffffff) {
654	agentx_varbind_notfound(vb);
655	return;
656	}
657	idx++;
658	}
659	/* Get and verify the current row index */
660	if (kinfo_proc(idx, &kinfo) == -1) {
661	log_warn("kinfo_proc");
662	agentx_varbind_error(vb);
663	return;
664	}
665
666	if (kinfo == NULL((void *)0)) {
667	agentx_varbind_notfound(vb);
668	return;
669	}
670	if (req == AGENTX_REQUEST_TYPE_GET) {
671	if (kinfo->p_pid != idx) {
672	agentx_varbind_notfound(vb);
673	return;
674	}
675	}
676	agentx_varbind_set_index_integer(vb, hrSWRunIdx, kinfo->p_pid);
677
678	if (obj == hrSWRunIndex)
679	agentx_varbind_integer(vb, kinfo->p_pid);
680	else if (obj == hrSWRunName)
681	agentx_varbind_string(vb, kinfo->p_comm);
682	else if (obj == hrSWRunPath) {
683	if (kinfo_path(kinfo, &s) == -1) {
684	log_warn("kinfo_path");
685	agentx_varbind_error(vb);
686	return;
687	}
688
689	agentx_varbind_string(vb, s);
690	} else if (obj == hrSWRunID)
691	agentx_varbind_oid(vb, AGENTX_OID(0, 0)(uint32_t []) { 0, 0 }, (sizeof((uint32_t []) { 0, 0 }) / sizeof (uint32_t)));
692	else if (obj == hrSWRunParameters) {
693	if (kinfo_parameters(kinfo, &s) == -1) {
694	log_warn("kinfo_parameters");
695	agentx_varbind_error(vb);
696	return;
697	}
698
699	agentx_varbind_string(vb, s);
700	} else if (obj == hrSWRunType) {
701	if (kinfo->p_flag & P_SYSTEM0x00000200) {
702	/* operatingSystem(2) */
703	agentx_varbind_integer(vb, 2);
704	} else {
705	/* application(4) */
706	agentx_varbind_integer(vb, 4);
707	}
708	} else if (obj == hrSWRunStatus) {
709	switch (kinfo->p_stat) {
710	case SONPROC7:
711	/* running(1) */
712	agentx_varbind_integer(vb, 1);
713	break;
714	case SIDL1:
715	case SRUN2:
716	case SSLEEP3:
717	/* runnable(2) */
718	agentx_varbind_integer(vb, 2);
719	break;
720	case SSTOP4:
721	/* notRunnable(3) */
722	agentx_varbind_integer(vb, 3);
723	break;
724	case SDEAD6:
725	default:
726	/* invalid(4) */
727	agentx_varbind_integer(vb, 4);
728	break;
729	}
730	} else if (obj == hrSWRunPerfCPU) {
731	time = kinfo->p_rtime_sec * 100;
732	time += (kinfo->p_rtime_usec + 5000) / 10000;
733	agentx_varbind_integer(vb, time);
734	} else if (obj == hrSWRunPerfMem) {
735	agentx_varbind_integer(vb, pagetok(kinfo->p_vm_tsize +((kinfo->p_vm_tsize + kinfo->p_vm_dsize + kinfo->p_vm_ssize ) << pageshift)
736	kinfo->p_vm_dsize + kinfo->p_vm_ssize)((kinfo->p_vm_tsize + kinfo->p_vm_dsize + kinfo->p_vm_ssize ) << pageshift));
737	} else
738	fatal("%s: Unexpected object", __func__);
739	}
740
741	int
742	kinfo_proc_comp(const void a, const void b)
743	{
744	struct kinfo_proc * const *k1 = a;
745	struct kinfo_proc * const *k2 = b;
746
747	return (((k1)->p_pid > (k2)->p_pid) ? 1 : -1);
748	}
749
750	static struct event kinfo_timer;
751	static struct kinfo_proc kp = NULL((void )0);
752	static struct kinfo_proc *klist = NULL((void )0);
753	static size_t nkp = 0, nklist = 0;
754
755	int
756	kinfo_proc(u_int32_t idx, struct kinfo_proc **kinfo)
757	{
758	int mib[] = { CTL_KERN1, KERN_PROC66,
759	KERN_PROC_ALL0, 0, sizeof(*kp), 0 };
760	size_t size, count, i;
761	struct timeval timer;
762
763	if (kp != NULL((void )0) && klist != NULL((void )0))
764	goto cached;
765
766	kinfo_proc_free();
767	for (;;) {
768	size = nkp * sizeof(*kp);
769	mib[5] = nkp;
770	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), kp, &size, NULL((void *)0), 0) == -1) {
771	if (errno(*__errno()) == ENOMEM12) {
772	kinfo_proc_free();
773	continue;
774	}
775
776	return (-1);
777	}
778
779	count = size / sizeof(*kp);
780	if (count <= nkp)
781	break;
782
783	kp = malloc(size);
784	if (kp == NULL((void *)0)) {
785	kinfo_proc_free();
786	return (-1);
787	}
788	nkp = count;
789	}
790
791	klist = calloc(count, sizeof(*klist));
792	if (klist == NULL((void *)0)) {
793	kinfo_proc_free();
794	return (-1);
795	}
796	nklist = count;
797
798	for (i = 0; i < nklist; i++)
799	klist[i] = &kp[i];
800	qsort(klist, nklist, sizeof(*klist), kinfo_proc_comp);
801
802	evtimer_set(&kinfo_timer, kinfo_timer_cb, NULL)event_set(&kinfo_timer, -1, 0, kinfo_timer_cb, ((void *)0 ));
803	timer.tv_sec = 5;
804	timer.tv_usec = 0;
805	evtimer_add(&kinfo_timer, &timer)event_add(&kinfo_timer, &timer);
806
807	cached:
808	kinfo = NULL((void )0);
809	for (i = 0; i < nklist; i++) {
810	if (klist[i]->p_pid >= (int32_t)idx) {
811	*kinfo = klist[i];
812	break;
813	}
814	}
815
816	return (0);
817	}
818
819	void
820	kinfo_timer_cb(int fd, short event, void *arg)
821	{
822	kinfo_proc_free();
823	}
824
825	void
826	kinfo_proc_free(void)
827	{
828	free(kp);
829	kp = NULL((void *)0);
830	nkp = 0;
831	free(klist);
832	klist = NULL((void *)0);
833	nklist = 0;
834	}
835
836	int
837	kinfo_args(struct kinfo_proc kinfo, char **s)
838	{
839	static char buf = NULL((void )0);
840	static size_t buflen = 128;
841
842	int mib[] = { CTL_KERN1, KERN_PROC_ARGS55,
843	kinfo->p_pid, KERN_PROC_ARGV1 };
844	char *nbuf;
845
846	s = NULL((void )0);
847	if (buf == NULL((void *)0)) {
848	buf = malloc(buflen);
849	if (buf == NULL((void *)0))
850	return (-1);
851	}
852
853	while (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), buf, &buflen, NULL((void *)0), 0) == -1) {
854	if (errno(*__errno()) != ENOMEM12) {
855	/* some errors are expected, dont get too upset */
856	return (0);
857	}
858
859	nbuf = realloc(buf, buflen + 128);
860	if (nbuf == NULL((void *)0))
861	return (-1);
862
863	buf = nbuf;
864	buflen += 128;
865	}
866
867	s = (char *)buf;
868	return (0);
869	}
870
871	int
872	kinfo_path(struct kinfo_proc kinfo, char *s)
873	{
874	static char str[129];
875	char **argv;
876
877	if (kinfo_args(kinfo, &argv) == -1)
878	return (-1);
879
880	str[0] = '\0';
881	*s = str;
882	if (argv != NULL((void )0) && argv[0] != NULL((void )0))
883	strlcpy(str, argv[0], sizeof(str));
884	return (0);
885	}
886
887	int
888	kinfo_parameters(struct kinfo_proc kinfo, char *s)
889	{
890	static char str[129];
891	char **argv;
892
893	if (kinfo_args(kinfo, &argv) == -1)
894	return (-1);
895
896	str[0] = '\0';
897	*s = str;
898	if (argv == NULL((void )0) \|\| argv[0] == NULL((void )0))
899	return (0);
900	argv++;
901
902	while (argv != NULL((void )0)) {
903	strlcat(str, *argv, sizeof(str));
904	argv++;
905	if (argv != NULL((void )0))
906	strlcat(str, " ", sizeof(str));
907	}
908
909	return (0);
910	}
911
912	/*
913	* Defined in IF-MIB.txt (RFCs 1229, 1573, 2233, 2863)
914	*/
915
916	void mib_ifnumber(struct agentx_varbind *);
917	struct kif
918	*mib_ifget(u_int);
919	void mib_iftable(struct agentx_varbind *);
920	void mib_ifxtable(struct agentx_varbind *);
921	void mib_ifstacklast(struct agentx_varbind *);
922	void mib_ifrcvtable(struct agentx_varbind *);
923
924	static uint8_t ether_zeroaddr[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
925
926	void
927	mib_ifnumber(struct agentx_varbind *vb)
928	{
929	agentx_varbind_integer(vb, kr_ifnumber());
930	}
931
932	struct kif *
933	mib_ifget(u_int idx)
934	{
935	struct kif *kif;
936
937	if ((kif = kr_getif(idx)) == NULL((void *)0)) {
938	/*
939	* It may happen that an interface with a specific index
940	* does not exist or has been removed. Jump to the next
941	* available interface index.
942	*/
943	for (kif = kr_getif(0); kif != NULL((void *)0);
944	kif = kr_getnextif(kif->if_index))
945	if (kif->if_index > idx)
946	break;
947	if (kif == NULL((void *)0))
948	return (NULL((void *)0));
949	}
950	idx = kif->if_index;
951
952	/* Update interface information */
953	kr_updateif(idx);
954	if ((kif = kr_getif(idx)) == NULL((void *)0)) {
955	log_debug("mib_ifxtable: interface %d disappeared?", idx);
956	return (NULL((void *)0));
957	}
958
959	return (kif);
960	}
961
962	void
963	mib_iftable(struct agentx_varbind *vb)
964	{
965	struct agentx_object *obj;
966	enum agentx_request_type req;
967	int32_t idx = 0;
968	struct kif *kif;
969	long long i;
970
971	obj = agentx_varbind_get_object(vb);
972	idx = agentx_varbind_get_index_integer(vb, ifIdx);
973	req = agentx_varbind_request(vb);
974	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
975	if (idx == INT32_MAX0x7fffffff) {
976	agentx_varbind_notfound(vb);
977	return;
978	}
979	idx++;
980	}
981	if ((kif = mib_ifget(idx)) == NULL((void *)0)) {
982	agentx_varbind_notfound(vb);
983	return;
984	}
985	if (req == AGENTX_REQUEST_TYPE_GET) {
986	if (idx != kif->if_index) {
987	agentx_varbind_notfound(vb);
988	return;
989	}
990	}
991	agentx_varbind_set_index_integer(vb, ifIdx, kif->if_index);
992
993	if (obj == ifIndex)
994	agentx_varbind_integer(vb, kif->if_index);
995	else if (obj == ifDescr) {
996	/*
997	* The ifDescr should contain a vendor, product, etc.
998	* but we just use the interface name (like ifName).
999	* The interface name includes the driver name on OpenBSD.
1000	*/
1001	agentx_varbind_string(vb, kif->if_name);
1002	} else if (obj == ifType) {
1003	if (kif->if_typeif_data.ifi_type >= 0xf0) {
1004	/*
1005	* It does not make sense to announce the private
1006	* interface types for CARP, ENC, PFSYNC, etc.
1007	*/
1008	agentx_varbind_integer(vb, IFT_OTHER0x01);
1009	} else
1010	agentx_varbind_integer(vb, kif->if_typeif_data.ifi_type);
1011	} else if (obj == ifMtu)
1012	agentx_varbind_integer(vb, kif->if_mtuif_data.ifi_mtu);
1013	else if (obj == ifSpeed) {
1014	if (kif->if_baudrateif_data.ifi_baudrate > UINT32_MAX0xffffffffU) {
1015	/* speed should be obtained from ifHighSpeed instead */
1016	agentx_varbind_gauge32(vb, UINT32_MAX0xffffffffU);
1017	} else
1018	agentx_varbind_gauge32(vb, kif->if_baudrateif_data.ifi_baudrate);
1019	} else if (obj == ifPhysAddress) {
1020	if (bcmp(kif->if_lladdr, ether_zeroaddr,
1021	sizeof(kif->if_lladdr)) == 0) {
1022	agentx_varbind_string(vb, "");
1023	} else {
1024	agentx_varbind_nstring(vb, kif->if_lladdr,
1025	sizeof(kif->if_lladdr));
1026	}
1027	} else if (obj == ifAdminStatus) {
1028	/* ifAdminStatus up(1), down(2), testing(3) */
1029	i = (kif->if_flags & IFF_UP0x1) ? 1 : 2;
1030	agentx_varbind_integer(vb, i);
1031	} else if (obj == ifOperStatus) {
1032	if ((kif->if_flags & IFF_UP0x1) == 0)
1033	i = 2; /* down(2) */
1034	else if (kif->if_link_stateif_data.ifi_link_state == LINK_STATE_UNKNOWN0)
1035	i = 4; /* unknown(4) */
1036	else if (LINK_STATE_IS_UP(kif->if_link_state)((kif->if_data.ifi_link_state) >= 4 \|\| (kif->if_data .ifi_link_state) == 0))
1037	i = 1; /* up(1) */
1038	else
1039	i = 7; /* lowerLayerDown(7) or dormant(5)? */
1040	agentx_varbind_integer(vb, i);
1041	} else if (obj == ifLastChange)
1042	agentx_varbind_timeticks(vb, kif->if_ticks);
1043	else if (obj == ifInOctets)
1044	agentx_varbind_counter32(vb, (uint32_t)kif->if_ibytesif_data.ifi_ibytes);
1045	else if (obj == ifInUcastPkts)
1046	agentx_varbind_counter32(vb, (uint32_t)kif->if_ipacketsif_data.ifi_ipackets);
1047	else if (obj == ifInNUcastPkts)
1048	agentx_varbind_counter32(vb, (uint32_t)kif->if_imcastsif_data.ifi_imcasts);
1049	else if (obj == ifInDiscards)
1050	agentx_varbind_counter32(vb, (uint32_t)kif->if_iqdropsif_data.ifi_iqdrops);
1051	else if (obj == ifInErrors)
1052	agentx_varbind_counter32(vb, (uint32_t)kif->if_ierrorsif_data.ifi_ierrors);
1053	else if (obj == ifInUnknownProtos)
1054	agentx_varbind_counter32(vb, (uint32_t)kif->if_noprotoif_data.ifi_noproto);
1055	else if (obj == ifOutOctets)
1056	agentx_varbind_counter32(vb, (uint32_t)kif->if_obytesif_data.ifi_obytes);
1057	else if (obj == ifOutUcastPkts)
1058	agentx_varbind_counter32(vb, (uint32_t)kif->if_opacketsif_data.ifi_opackets);
1059	else if (obj == ifOutNUcastPkts)
1060	agentx_varbind_counter32(vb, (uint32_t)kif->if_omcastsif_data.ifi_omcasts);
1061	else if (obj == ifOutDiscards)
1062	agentx_varbind_counter32(vb, (uint32_t)kif->if_oqdropsif_data.ifi_oqdrops);
1063	else if (obj == ifOutErrors)
1064	agentx_varbind_counter32(vb, (uint32_t)kif->if_oerrorsif_data.ifi_oerrors);
1065	else if (obj == ifOutQLen)
1066	agentx_varbind_gauge32(vb, 0);
1067	else if (obj == ifSpecific)
1068	agentx_varbind_oid(vb, AGENTX_OID(0, 0)(uint32_t []) { 0, 0 }, (sizeof((uint32_t []) { 0, 0 }) / sizeof (uint32_t)));
1069	else
1070	fatal("%s: Unexpected object", __func__);
1071	}
1072
1073	void
1074	mib_ifxtable(struct agentx_varbind *vb)
1075	{
1076	struct agentx_object *obj;
1077	enum agentx_request_type req;
1078	int32_t idx = 0;
1079	struct kif *kif;
1080	int i = 0;
1081
1082	obj = agentx_varbind_get_object(vb);
1083	idx = agentx_varbind_get_index_integer(vb, ifIdx);
1084	req = agentx_varbind_request(vb);
1085	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
1086	if (idx == INT32_MAX0x7fffffff) {
1087	agentx_varbind_notfound(vb);
1088	return;
1089	}
1090	idx++;
1091	}
1092	if ((kif = mib_ifget(idx)) == NULL((void *)0)) {
1093	agentx_varbind_notfound(vb);
1094	return;
1095	}
1096	if (req == AGENTX_REQUEST_TYPE_GET) {
1097	if (idx != kif->if_index) {
1098	agentx_varbind_notfound(vb);
1099	return;
1100	}
1101	}
1102	agentx_varbind_set_index_integer(vb, ifIdx, kif->if_index);
1103
1104	if (obj == ifName)
1105	agentx_varbind_string(vb, kif->if_name);
1106	else if (obj == ifInMulticastPkts)
1107	agentx_varbind_counter32(vb, (uint32_t)kif->if_imcastsif_data.ifi_imcasts);
1108	else if (obj == ifInBroadcastPkts)
1109	agentx_varbind_counter32(vb, 0);
1110	else if (obj == ifOutMulticastPkts)
1111	agentx_varbind_counter32(vb, (uint32_t)kif->if_omcastsif_data.ifi_omcasts);
1112	else if (obj == ifOutBroadcastPkts)
1113	agentx_varbind_counter32(vb, 0);
1114	else if (obj == ifHCInOctets)
1115	agentx_varbind_counter64(vb, (uint64_t)kif->if_ibytesif_data.ifi_ibytes);
1116	else if (obj == ifHCInUcastPkts)
1117	agentx_varbind_counter64(vb, (uint64_t)kif->if_ipacketsif_data.ifi_ipackets);
1118	else if (obj == ifHCInMulticastPkts)
1119	agentx_varbind_counter64(vb, (uint64_t)kif->if_imcastsif_data.ifi_imcasts);
1120	else if (obj == ifHCInBroadcastPkts)
1121	agentx_varbind_counter64(vb, 0);
1122	else if (obj == ifHCOutOctets)
1123	agentx_varbind_counter64(vb, (uint64_t)kif->if_obytesif_data.ifi_obytes);
1124	else if (obj == ifHCOutUcastPkts)
1125	agentx_varbind_counter64(vb, (uint64_t)kif->if_opacketsif_data.ifi_opackets);
1126	else if (obj == ifHCOutMulticastPkts)
1127	agentx_varbind_counter64(vb, (uint64_t)kif->if_omcastsif_data.ifi_omcasts);
1128	else if (obj == ifHCOutBroadcastPkts)
1129	agentx_varbind_counter64(vb, 0);
1130	else if (obj == ifLinkUpDownTrapEnable)
1131	agentx_varbind_integer(vb, 0); /* enabled(1), disabled(2) */
1132	else if (obj == ifHighSpeed) {
1133	i = kif->if_baudrateif_data.ifi_baudrate >= 1000000 ?
1134	kif->if_baudrateif_data.ifi_baudrate / 1000000 : 0;
1135	agentx_varbind_gauge32(vb, i);
1136	} else if (obj == ifPromiscuousMode) {
1137	/* ifPromiscuousMode: true(1), false(2) */
1138	i = kif->if_flags & IFF_PROMISC0x100 ? 1 : 2;
1139	agentx_varbind_integer(vb, i);
1140	} else if (obj == ifConnectorPresent) {
1141	/* ifConnectorPresent: false(2), true(1) */
1142	i = kif->if_typeif_data.ifi_type == IFT_ETHER0x06 ? 1 : 2;
1143	agentx_varbind_integer(vb, i);
1144	} else if (obj == ifAlias)
1145	agentx_varbind_string(vb, kif->if_descr);
1146	else if (obj == ifCounterDiscontinuityTime)
1147	agentx_varbind_timeticks(vb, 0);
1148	else
1149	fatal("%s: Unexpected object", __func__);
1150	}
1151
1152	void
1153	mib_ifstacklast(struct agentx_varbind *vb)
1154	{
1155	agentx_varbind_timeticks(vb, kr_iflastchange());
1156	}
1157
1158	void
1159	mib_ifrcvtable(struct agentx_varbind *vb)
1160	{
1161	struct agentx_object *obj;
1162	enum agentx_request_type req;
1163	int32_t idx = 0;
1164	const uint8_t *lladdr;
1165	struct kif *kif;
1166	int i = 0, llcmp, impl;
1167	size_t slen;
1168
1169	obj = agentx_varbind_get_object(vb);
1170	idx = agentx_varbind_get_index_integer(vb, ifIdx);
1171	lladdr = (const uint8_t *)agentx_varbind_get_index_string(vb,
1172	ifRcvAddressAddress, &slen, &impl);
1173	if (lladdr == NULL((void *)0))
1174	lladdr = ether_zeroaddr;
1175	req = agentx_varbind_request(vb);
1176
1177	if ((kif = mib_ifget(idx)) == NULL((void *)0)) {
1178	agentx_varbind_notfound(vb);
1179	return;
1180	}
1181	/*
1182	* The lladdr of the interface will be encoded in the returned OID
1183	* ifRcvAddressX.ifindex.6.x.x.x.x.x.x = val
1184	* Thanks to the virtual cloner interfaces, it is an easy 1:1
1185	* mapping in OpenBSD; only one lladdr (MAC) address per interface.
1186	*/
1187	if (slen == 6)
1188	llcmp = bcmp(lladdr, kif->if_lladdr, sizeof(kif->if_lladdr));
1189	if (req == AGENTX_REQUEST_TYPE_GET) {
1190	if (idx != kif->if_index \|\| slen != 6 \|\| llcmp != 0) {
1191	agentx_varbind_notfound(vb);
1192	return;
1193	}
1194	} else if (idx == kif->if_index) {
1195	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
1196	if (slen > 6 \|\| llcmp >= 0)
1197	kif = kr_getnextif(kif->if_index);
1198	} else {
1199	if (slen > 6 \|\| llcmp > 0)
1200	kif = kr_getnextif(kif->if_index);
1201	}
1202	if (kif == NULL((void *)0)) {
1203	agentx_varbind_notfound(vb);
1204	return;
1205	}
1206	}
1207	agentx_varbind_set_index_integer(vb, ifIdx, kif->if_index);
1208	agentx_varbind_set_index_nstring(vb, ifRcvAddressAddress,
1209	kif->if_lladdr, sizeof(kif->if_lladdr));
1210
1211	if (obj == ifRcvAddressStatus) {
1212	/* ifRcvAddressStatus: RowStatus active(1), notInService(2) */
1213	i = kif->if_flags & IFF_UP0x1 ? 1 : 2;
1214	agentx_varbind_integer(vb, i);
1215	} else if (obj == ifRcvAddressType) {
1216	/* ifRcvAddressType: other(1), volatile(2), nonVolatile(3) */
1217	agentx_varbind_integer(vb, 1);
1218	} else
1219	fatal("%s: Unexpected object", __func__);
1220	}
1221
1222	/*
1223	* Defined in
1224	* - OPENBSD-PF-MIB.txt
1225	* - OPENBSD-SENSORS-MIB.txt
1226	* - OPENBSD-CARP-MIB.txt
1227	* (http://www.packetmischief.ca/openbsd-snmp-mibs/)
1228	*/
1229	#define OIDVER_OPENBSD_MEM1 1
1230
1231	struct carpif {
1232	struct carpreq carpr;
1233	struct kif kif;
1234	};
1235
1236	void mib_close_pftrans(struct agentx_varbind *, u_int32_t);
1237
1238	void mib_pfinfo(struct agentx_varbind *);
1239	void mib_pfcounters(struct agentx_varbind *);
1240	void mib_pfscounters(struct agentx_varbind *);
1241	void mib_pflogif(struct agentx_varbind *);
1242	void mib_pfsrctrack(struct agentx_varbind *);
1243	void mib_pflimits(struct agentx_varbind *);
1244	void mib_pftimeouts(struct agentx_varbind *);
1245	void mib_pfifnum(struct agentx_varbind *);
1246	void mib_pfiftable(struct agentx_varbind *);
1247	void mib_pftablenum(struct agentx_varbind *);
1248	void mib_pftables(struct agentx_varbind *);
1249	void mib_pftableaddrs(struct agentx_varbind *);
1250	void mib_pflabelnum(struct agentx_varbind *);
1251	void mib_pflabels(struct agentx_varbind *);
1252	void mib_pfsyncstats(struct agentx_varbind *);
1253
1254	void mib_sensornum(struct agentx_varbind *);
1255	void mib_sensors(struct agentx_varbind *);
1256	const char mib_sensorunit(struct sensor );
1257	char mib_sensorvalue(struct sensor );
1258
1259	void mib_carpsysctl(struct agentx_varbind *);
1260	void mib_carpstats(struct agentx_varbind *);
1261	void mib_carpiftable(struct agentx_varbind *);
1262	void mib_carpgrouptable(struct agentx_varbind *);
1263	void mib_carpifnum(struct agentx_varbind *);
1264	struct carpif
1265	*mib_carpifget(u_int);
1266	void mib_memversion(struct agentx_varbind *);
1267	void mib_memiftable(struct agentx_varbind *);
1268
1269	void
1270	mib_pfinfo(struct agentx_varbind *vb)
1271	{
1272	struct agentx_object *obj;
1273	struct pf_status s;
1274	time_t runtime = 0;
1275	struct timespec uptime;
1276
1277	if (pf_get_stats(&s)) {
1278	agentx_varbind_error(vb);
1279	return;
1280	}
1281
1282	obj = agentx_varbind_get_object(vb);
1283	if (obj == pfRunning)
1284	agentx_varbind_integer(vb, s.running);
1285	else if (obj == pfRuntime) {
1286	if (!clock_gettime(CLOCK_BOOTTIME6, &uptime))
1287	runtime = uptime.tv_sec - s.since;
1288	runtime *= 100;
1289	agentx_varbind_timeticks(vb, runtime);
1290	} else if (obj == pfDebug)
1291	agentx_varbind_integer(vb, s.debug);
1292	else if (obj == pfHostid)
1293	agentx_varbind_printf(vb, "0x%08x", ntohl(s.hostid)(__uint32_t)(__builtin_constant_p(s.hostid) ? (__uint32_t)((( __uint32_t)(s.hostid) & 0xff) << 24 \| ((__uint32_t) (s.hostid) & 0xff00) << 8 \| ((__uint32_t)(s.hostid) & 0xff0000) >> 8 \| ((__uint32_t)(s.hostid) & 0xff000000 ) >> 24) : __swap32md(s.hostid)));
1294	else
1295	fatal("%s: Unexpected object", __func__);
1296	}
1297
1298	void
1299	mib_pfcounters(struct agentx_varbind *vb)
1300	{
1301	struct agentx_object *obj;
1302	struct pf_status s;
1303
1304	if (pf_get_stats(&s)) {
1305	agentx_varbind_error(vb);
1306	return;
1307	}
1308
1309	obj = agentx_varbind_get_object(vb);
1310	if (obj == pfCntMatch)
1311	agentx_varbind_counter64(vb, s.counters[PFRES_MATCH0]);
1312	else if (obj == pfCntBadOffset)
1313	agentx_varbind_counter64(vb, s.counters[PFRES_BADOFF1]);
1314	else if (obj == pfCntFragment)
1315	agentx_varbind_counter64(vb, s.counters[PFRES_FRAG2]);
1316	else if (obj == pfCntShort)
1317	agentx_varbind_counter64(vb, s.counters[PFRES_SHORT3]);
1318	else if (obj == pfCntNormalize)
1319	agentx_varbind_counter64(vb, s.counters[PFRES_NORM4]);
1320	else if (obj == pfCntMemory)
1321	agentx_varbind_counter64(vb, s.counters[PFRES_MEMORY5]);
1322	else if (obj == pfCntTimestamp)
1323	agentx_varbind_counter64(vb, s.counters[PFRES_TS6]);
1324	else if (obj == pfCntCongestion)
1325	agentx_varbind_counter64(vb, s.counters[PFRES_CONGEST7]);
1326	else if (obj == pfCntIpOption)
1327	agentx_varbind_counter64(vb, s.counters[PFRES_IPOPTIONS8]);
1328	else if (obj == pfCntProtoCksum)
1329	agentx_varbind_counter64(vb, s.counters[PFRES_PROTCKSUM9]);
1330	else if (obj == pfCntStateMismatch)
1331	agentx_varbind_counter64(vb, s.counters[PFRES_BADSTATE10]);
1332	else if (obj == pfCntStateInsert)
1333	agentx_varbind_counter64(vb, s.counters[PFRES_STATEINS11]);
1334	else if (obj == pfCntStateLimit)
1335	agentx_varbind_counter64(vb, s.counters[PFRES_MAXSTATES12]);
1336	else if (obj == pfCntSrcLimit)
1337	agentx_varbind_counter64(vb, s.counters[PFRES_SRCLIMIT13]);
1338	else if (obj == pfCntSynproxy)
1339	agentx_varbind_counter64(vb, s.counters[PFRES_SYNPROXY14]);
1340	else if (obj == pfCntTranslate)
1341	agentx_varbind_counter64(vb, s.counters[PFRES_TRANSLATE15]);
1342	else if (obj == pfCntNoRoute)
1343	agentx_varbind_counter64(vb, s.counters[PFRES_NOROUTE16]);
1344	else
1345	fatal("%s: Unexpected object", __func__);
1346	}
1347
1348	void
1349	mib_pfscounters(struct agentx_varbind *vb)
1350	{
1351	struct agentx_object *obj;
1352	struct pf_status s;
1353
1354	if (pf_get_stats(&s)) {
1355	agentx_varbind_error(vb);
1356	return;
1357	}
1358
1359	obj = agentx_varbind_get_object(vb);
1360	if (obj == pfStateCount)
1361	agentx_varbind_unsigned32(vb, s.states);
1362	else if (obj == pfStateSearches)
1363	agentx_varbind_counter64(vb, s.fcounters[FCNT_STATE_SEARCH0]);
1364	else if (obj == pfStateInserts)
1365	agentx_varbind_counter64(vb, s.fcounters[FCNT_STATE_INSERT1]);
1366	else if (obj == pfStateRemovals)
1367	agentx_varbind_counter64(vb, s.fcounters[FCNT_STATE_REMOVALS2]);
1368	else
1369	fatal("%s: Unexpected object", __func__);
1370	}
1371
1372	void
1373	mib_pflogif(struct agentx_varbind *vb)
1374	{
1375	struct agentx_object *obj;
1376	struct pf_status s;
1377
1378	if (pf_get_stats(&s)) {
1379	agentx_varbind_error(vb);
1380	return;
1381	}
1382
1383	obj = agentx_varbind_get_object(vb);
1384	if (obj == pfLogIfName)
1385	agentx_varbind_string(vb, s.ifname);
1386	else if (obj == pfLogIfIpBytesIn)
1387	agentx_varbind_counter64(vb, s.bcounters[IPV4][IN]);
1388	else if (obj == pfLogIfIpBytesOut)
1389	agentx_varbind_counter64(vb, s.bcounters[IPV4][OUT]);
1390	else if (obj == pfLogIfIpPktsInPass)
1391	agentx_varbind_counter64(vb, s.pcounters[IPV4][IN][PF_PASS]);
1392	else if (obj == pfLogIfIpPktsInDrop)
1393	agentx_varbind_counter64(vb, s.pcounters[IPV4][IN][PF_DROP]);
1394	else if (obj == pfLogIfIpPktsOutPass)
1395	agentx_varbind_counter64(vb, s.pcounters[IPV4][OUT][PF_PASS]);
1396	else if (obj == pfLogIfIpPktsOutDrop)
1397	agentx_varbind_counter64(vb, s.pcounters[IPV4][OUT][PF_DROP]);
1398	else if (obj == pfLogIfIp6BytesIn)
1399	agentx_varbind_counter64(vb, s.bcounters[IPV6][IN]);
1400	else if (obj == pfLogIfIp6BytesOut)
1401	agentx_varbind_counter64(vb, s.bcounters[IPV6][OUT]);
1402	else if (obj == pfLogIfIp6PktsInPass)
1403	agentx_varbind_counter64(vb, s.pcounters[IPV6][IN][PF_PASS]);
1404	else if (obj == pfLogIfIp6PktsInDrop)
1405	agentx_varbind_counter64(vb, s.pcounters[IPV6][IN][PF_DROP]);
1406	else if (obj == pfLogIfIp6PktsOutPass)
1407	agentx_varbind_counter64(vb, s.pcounters[IPV6][OUT][PF_PASS]);
1408	else if (obj == pfLogIfIp6PktsOutDrop)
1409	agentx_varbind_counter64(vb, s.pcounters[IPV6][OUT][PF_DROP]);
1410	else
1411	fatal("%s: Unexpected object", __func__);
1412	}
1413
1414	void
1415	mib_pfsrctrack(struct agentx_varbind *vb)
1416	{
1417	struct agentx_object *obj;
1418	struct pf_status s;
1419
1420	if (pf_get_stats(&s)) {
1421	agentx_varbind_error(vb);
1422	return;
1423	}
1424
1425	obj = agentx_varbind_get_object(vb);
1426	if (obj == pfSrcTrackCount)
1427	agentx_varbind_unsigned32(vb, s.src_nodes);
1428	else if (obj == pfSrcTrackSearches)
1429	agentx_varbind_counter64(vb, s.scounters[SCNT_SRC_NODE_SEARCH0]);
1430	else if (obj == pfSrcTrackInserts)
1431	agentx_varbind_counter64(vb, s.scounters[SCNT_SRC_NODE_INSERT1]);
1432	else if (obj == pfSrcTrackRemovals)
1433	agentx_varbind_counter64(vb,
1434	s.scounters[SCNT_SRC_NODE_REMOVALS2]);
1435	else
1436	fatal("%s: Unexpected object", __func__);
1437	}
1438
1439	void
1440	mib_pflimits(struct agentx_varbind *vb)
1441	{
1442	struct agentx_object *obj;
1443	struct pfioc_limit pl;
1444	extern int devpf;
1445
1446	obj = agentx_varbind_get_object(vb);
1447	memset(&pl, 0, sizeof(pl));
1448	if (obj == pfLimitStates)
1449	pl.index = PF_LIMIT_STATES;
1450	else if (obj == pfLimitSourceNodes)
1451	pl.index = PF_LIMIT_SRC_NODES;
1452	else if (obj == pfLimitFragments)
1453	pl.index = PF_LIMIT_FRAGS;
1454	else if (obj == pfLimitMaxTables)
1455	pl.index = PF_LIMIT_TABLES;
1456	else if (obj == pfLimitMaxTableEntries)
1457	pl.index = PF_LIMIT_TABLE_ENTRIES;
1458	else
1459	fatal("%s: Unexpected object", __func__);
1460
1461	if (ioctl(devpf, DIOCGETLIMIT(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct pfioc_limit) & 0x1fff) << 16) \| ((('D')) << 8) \| ((39))), &pl) == -1) {
1462	log_warn("DIOCGETLIMIT");
1463	agentx_varbind_error(vb);
1464	return;
1465	}
1466
1467	agentx_varbind_unsigned32(vb, pl.limit);
1468	}
1469
1470	void
1471	mib_pftimeouts(struct agentx_varbind *vb)
1472	{
1473	struct agentx_object *obj;
1474	struct pfioc_tm pt;
1475	extern int devpf;
1476
1477	obj = agentx_varbind_get_object(vb);
1478	memset(&pt, 0, sizeof(pt));
1479	if (obj == pfTimeoutTcpFirst)
1480	pt.timeout = PFTM_TCP_FIRST_PACKET;
1481	else if (obj == pfTimeoutTcpOpening)
1482	pt.timeout = PFTM_TCP_OPENING;
1483	else if (obj == pfTimeoutTcpEstablished)
1484	pt.timeout = PFTM_TCP_ESTABLISHED;
1485	else if (obj == pfTimeoutTcpClosing)
1486	pt.timeout = PFTM_TCP_CLOSING;
1487	else if (obj == pfTimeoutTcpFinWait)
1488	pt.timeout = PFTM_TCP_FIN_WAIT;
1489	else if (obj == pfTimeoutTcpClosed)
1490	pt.timeout = PFTM_TCP_CLOSED;
1491	else if (obj == pfTimeoutUdpFirst)
1492	pt.timeout = PFTM_UDP_FIRST_PACKET;
1493	else if (obj == pfTimeoutUdpSingle)
1494	pt.timeout = PFTM_UDP_SINGLE;
1495	else if (obj == pfTimeoutUdpMultiple)
1496	pt.timeout = PFTM_UDP_MULTIPLE;
1497	else if (obj == pfTimeoutIcmpFirst)
1498	pt.timeout = PFTM_ICMP_FIRST_PACKET;
1499	else if (obj == pfTimeoutIcmpError)
1500	pt.timeout = PFTM_ICMP_ERROR_REPLY;
1501	else if (obj == pfTimeoutOtherFirst)
1502	pt.timeout = PFTM_OTHER_FIRST_PACKET;
1503	else if (obj == pfTimeoutOtherSingle)
1504	pt.timeout = PFTM_OTHER_SINGLE;
1505	else if (obj == pfTimeoutOtherMultiple)
1506	pt.timeout = PFTM_OTHER_MULTIPLE;
1507	else if (obj == pfTimeoutFragment)
1508	pt.timeout = PFTM_FRAG;
1509	else if (obj == pfTimeoutInterval)
1510	pt.timeout = PFTM_INTERVAL;
1511	else if (obj == pfTimeoutAdaptiveStart)
1512	pt.timeout = PFTM_ADAPTIVE_START;
1513	else if (obj == pfTimeoutAdaptiveEnd)
1514	pt.timeout = PFTM_ADAPTIVE_END;
1515	else if (obj == pfTimeoutSrcTrack)
1516	pt.timeout = PFTM_SRC_NODE;
1517	else
1518	fatal("%s: Unexpected object", __func__);
1519
1520	if (ioctl(devpf, DIOCGETTIMEOUT(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct pfioc_tm) & 0x1fff) << 16) \| ((('D')) << 8) \| ((30))), &pt) == -1) {
1521	log_warn("DIOCGETTIMEOUT");
1522	agentx_varbind_error(vb);
1523	return;
1524	}
1525
1526	agentx_varbind_integer(vb, pt.seconds);
1527	}
1528
1529	void
1530	mib_pfifnum(struct agentx_varbind *vb)
1531	{
1532	int c;
1533
1534	if ((c = pfi_count()) == -1)
1535	agentx_varbind_error(vb);
1536	else
1537	agentx_varbind_integer(vb, c);
1538	}
1539
1540	void
1541	mib_pfiftable(struct agentx_varbind *vb)
1542	{
1543	struct agentx_object *obj;
1544	enum agentx_request_type req;
1545	struct pfi_kif pif;
1546	int idx, iftype;
1547
1548	obj = agentx_varbind_get_object(vb);
1549	idx = agentx_varbind_get_index_integer(vb, pfIfIdx);
1550	req = agentx_varbind_request(vb);
1551
1552	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
1553	if (idx < 1)
1554	idx = 1;
1555	else if (idx == INT32_MAX0x7fffffff) {
1556	agentx_varbind_notfound(vb);
1557	return;
1558	} else
1559	idx++;
1560	} else if (req == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
1561	if (idx < 1)
1562	idx = 1;
1563	}
1564	if (pfi_get_if(&pif, idx)) {
1565	agentx_varbind_notfound(vb);
1566	return;
1567	}
1568	agentx_varbind_set_index_integer(vb, pfIfIdx, idx);
1569
1570	if (obj == pfIfIndex)
1571	agentx_varbind_integer(vb, idx);
1572	else if (obj == pfIfDescr)
1573	agentx_varbind_string(vb, pif.pfik_name);
1574	else if (obj == pfIfType) {
1575	iftype = (pif.pfik_ifp == NULL((void *)0) ? PFI_IFTYPE_GROUP
1576	: PFI_IFTYPE_INSTANCE);
1577	agentx_varbind_integer(vb, iftype);
1578	} else if (obj == pfIfRefs)
1579	agentx_varbind_unsigned32(vb, pif.pfik_states);
1580	else if (obj == pfIfRules)
1581	agentx_varbind_unsigned32(vb, pif.pfik_rules);
1582	else if (obj == pfIfIn4PassPkts)
1583	agentx_varbind_counter64(vb, pif.pfik_packets[IPV4][IN][PASS]);
1584	else if (obj == pfIfIn4PassBytes)
1585	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV4][IN][PASS]);
1586	else if (obj == pfIfIn4BlockPkts)
1587	agentx_varbind_counter64(vb, pif.pfik_packets[IPV4][IN][BLOCK]);
1588	else if (obj == pfIfIn4BlockBytes)
1589	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV4][IN][BLOCK]);
1590	else if (obj == pfIfOut4PassPkts)
1591	agentx_varbind_counter64(vb, pif.pfik_packets[IPV4][OUT][PASS]);
1592	else if (obj == pfIfOut4PassBytes)
1593	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV4][OUT][PASS]);
1594	else if (obj == pfIfOut4BlockPkts)
1595	agentx_varbind_counter64(vb, pif.pfik_packets[IPV4][OUT][BLOCK]);
1596	else if (obj == pfIfOut4BlockBytes)
1597	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV4][OUT][BLOCK]);
1598	else if (obj == pfIfIn6PassPkts)
1599	agentx_varbind_counter64(vb, pif.pfik_packets[IPV6][IN][PASS]);
1600	else if (obj == pfIfIn6PassBytes)
1601	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV6][IN][PASS]);
1602	else if (obj == pfIfIn6BlockPkts)
1603	agentx_varbind_counter64(vb, pif.pfik_packets[IPV6][IN][BLOCK]);
1604	else if (obj == pfIfIn6BlockBytes)
1605	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV6][IN][BLOCK]);
1606	else if (obj == pfIfOut6PassPkts)
1607	agentx_varbind_counter64(vb, pif.pfik_packets[IPV6][OUT][PASS]);
1608	else if (obj == pfIfOut6PassBytes)
1609	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV6][OUT][PASS]);
1610	else if (obj == pfIfOut6BlockPkts)
1611	agentx_varbind_counter64(vb, pif.pfik_packets[IPV6][OUT][BLOCK]);
1612	else if (obj == pfIfOut6BlockBytes)
1613	agentx_varbind_counter64(vb, pif.pfik_bytes[IPV6][OUT][BLOCK]);
1614	else
1615	fatal("%s: Unexpected object", __func__);
1616	}
1617
1618	void
1619	mib_pftablenum(struct agentx_varbind *vb)
1620	{
1621	int c;
1622
1623	if ((c = pft_count()) == -1)
1624	agentx_varbind_error(vb);
1625	else
1626	agentx_varbind_integer(vb, c);
1627	}
1628
1629	void
1630	mib_pftables(struct agentx_varbind *vb)
1631	{
1632	struct agentx_object *obj;
1633	enum agentx_request_type req;
1634	struct pfr_tstats ts;
1635	time_t tzero;
1636	int idx;
1637
1638	obj = agentx_varbind_get_object(vb);
1639	idx = agentx_varbind_get_index_integer(vb, pfTblIdx);
1640	req = agentx_varbind_request(vb);
1641
1642	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
1643	if (idx < 1)
1644	idx = 1;
1645	else if (idx == INT32_MAX0x7fffffff) {
1646	agentx_varbind_notfound(vb);
1647	return;
1648	} else
1649	idx++;
1650	} else if (req == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
1651	if (idx < 1)
1652	idx = 1;
1653	}
1654	if (pft_get_table(&ts, idx)) {
1655	agentx_varbind_notfound(vb);
1656	return;
1657	}
1658	agentx_varbind_set_index_integer(vb, pfTblIdx, idx);
1659
1660	if (obj == pfTblIndex)
1661	agentx_varbind_integer(vb, idx);
1662	else if (obj == pfTblName)
1663	agentx_varbind_string(vb, ts.pfrts_namepfrts_t.pfrt_name);
1664	else if (obj == pfTblAddresses)
1665	agentx_varbind_integer(vb, ts.pfrts_cnt);
1666	else if (obj == pfTblAnchorRefs)
1667	agentx_varbind_integer(vb, ts.pfrts_refcnt[PFR_REFCNT_ANCHOR]);
1668	else if (obj == pfTblRuleRefs)
1669	agentx_varbind_integer(vb, ts.pfrts_refcnt[PFR_REFCNT_RULE]);
1670	else if (obj == pfTblEvalsMatch)
1671	agentx_varbind_counter64(vb, ts.pfrts_match);
1672	else if (obj == pfTblEvalsNoMatch)
1673	agentx_varbind_counter64(vb, ts.pfrts_nomatch);
1674	else if (obj == pfTblInPassPkts)
1675	agentx_varbind_counter64(vb, ts.pfrts_packets[IN][PFR_OP_PASS]);
1676	else if (obj == pfTblInPassBytes)
1677	agentx_varbind_counter64(vb, ts.pfrts_bytes[IN][PFR_OP_PASS]);
1678	else if (obj == pfTblInBlockPkts)
1679	agentx_varbind_counter64(vb, ts.pfrts_packets[IN][PFR_OP_BLOCK]);
1680	else if (obj == pfTblInBlockBytes)
1681	agentx_varbind_counter64(vb, ts.pfrts_bytes[IN][PFR_OP_BLOCK]);
1682	else if (obj == pfTblInXPassPkts)
1683	agentx_varbind_counter64(vb, ts.pfrts_packets[IN][PFR_OP_XPASSPFR_OP_ADDR_MAX]);
1684	else if (obj == pfTblInXPassBytes)
1685	agentx_varbind_counter64(vb, ts.pfrts_bytes[IN][PFR_OP_XPASSPFR_OP_ADDR_MAX]);
1686	else if (obj == pfTblOutPassPkts)
1687	agentx_varbind_counter64(vb, ts.pfrts_packets[OUT][PFR_OP_PASS]);
1688	else if (obj == pfTblOutPassBytes)
1689	agentx_varbind_counter64(vb, ts.pfrts_bytes[OUT][PFR_OP_PASS]);
1690	else if (obj == pfTblOutBlockPkts)
1691	agentx_varbind_counter64(vb, ts.pfrts_packets[OUT][PFR_OP_BLOCK]);
1692	else if (obj == pfTblOutBlockBytes)
1693	agentx_varbind_counter64(vb, ts.pfrts_bytes[OUT][PFR_OP_BLOCK]);
1694	else if (obj == pfTblOutXPassPkts)
1695	agentx_varbind_counter64(vb, ts.pfrts_packets[OUT][PFR_OP_XPASSPFR_OP_ADDR_MAX]);
1696	else if (obj == pfTblOutXPassBytes)
1697	agentx_varbind_counter64(vb, ts.pfrts_bytes[OUT][PFR_OP_XPASSPFR_OP_ADDR_MAX]);
1698	else if (obj == pfTblStatsCleared) {
1699	tzero = (time(NULL((void )0)) - ts.pfrts_tzero) 100;
1700	agentx_varbind_timeticks(vb, tzero);
1701	} else if (obj == pfTblInMatchPkts)
1702	agentx_varbind_counter64(vb, ts.pfrts_packets[IN][PFR_OP_MATCH]);
1703	else if (obj == pfTblInMatchBytes)
1704	agentx_varbind_counter64(vb, ts.pfrts_bytes[IN][PFR_OP_MATCH]);
1705	else if (obj == pfTblOutMatchPkts)
1706	agentx_varbind_counter64(vb, ts.pfrts_packets[OUT][PFR_OP_MATCH]);
1707	else if (obj == pfTblOutMatchBytes)
1708	agentx_varbind_counter64(vb, ts.pfrts_bytes[OUT][PFR_OP_MATCH]);
1709	else
1710	fatal("%s: Unexpected object", __func__);
1711	}
1712
1713	void
1714	mib_pftableaddrs(struct agentx_varbind *vb)
1715	{
1716	struct agentx_object *obj;
1717	enum agentx_request_type req;
1718	struct pfr_astats as;
1719	int tblidx;
1720
1721	obj = agentx_varbind_get_object(vb);
1722	tblidx = agentx_varbind_get_index_integer(vb, pfTblAddrTblIdx);
1723	req = agentx_varbind_request(vb);
1724
1725	/*
1726	* XXX No consistent way to differentiate between not found and error
1727	* Treat everything as not found.
1728	*/
1729	if (req == AGENTX_REQUEST_TYPE_GET \|\|
1730	req == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
1731	as.pfras_a.pfra_ip4addrpfra_u._pfra_ip4addr = *agentx_varbind_get_index_ipaddress(
1732	vb, pfTblAddrNetIdx);
1733	as.pfras_a.pfra_net = agentx_varbind_get_index_integer(vb,
1734	pfTblAddrMaskIdx);
1735
1736	if (pfta_get_addr(&as, tblidx)) {
1737	if (req == AGENTX_REQUEST_TYPE_GET) {
1738	agentx_varbind_notfound(vb);
1739	return;
1740	}
1741	req = AGENTX_REQUEST_TYPE_GETNEXT;
1742	}
1743	}
1744	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
1745	if (tblidx < 1)
1746	tblidx = 1;
1747	as.pfras_a.pfra_ip4addrpfra_u._pfra_ip4addr = *agentx_varbind_get_index_ipaddress(
1748	vb, pfTblAddrNetIdx);
1749	as.pfras_a.pfra_net = agentx_varbind_get_index_integer(vb,
1750	pfTblAddrMaskIdx);
1751
1752	if (pfta_get_nextaddr(&as, &tblidx)){
1753	agentx_varbind_notfound(vb);
1754	return;
1755	}
1756	}
1757	agentx_varbind_set_index_integer(vb, pfTblAddrTblIdx, tblidx);
1758	agentx_varbind_set_index_ipaddress(vb, pfTblAddrNetIdx,
1759	&as.pfras_a.pfra_ip4addrpfra_u._pfra_ip4addr);
1760	agentx_varbind_set_index_integer(vb, pfTblAddrMaskIdx,
1761	as.pfras_a.pfra_net);
1762
1763	if (obj == pfTblAddrTblIndex)
1764	agentx_varbind_integer(vb, tblidx);
1765	else if (obj == pfTblAddrNet)
1766	agentx_varbind_ipaddress(vb, &as.pfras_a.pfra_ip4addrpfra_u._pfra_ip4addr);
1767	else if (obj == pfTblAddrMask)
1768	agentx_varbind_integer(vb, as.pfras_a.pfra_net);
1769	else if (obj == pfTblAddrCleared)
1770	agentx_varbind_timeticks(vb, (time(NULL((void )0)) - as.pfras_tzero) 100);
1771	else if (obj == pfTblAddrInBlockPkts)
1772	agentx_varbind_counter64(vb, as.pfras_packets[IN][PFR_OP_BLOCK]);
1773	else if (obj == pfTblAddrInBlockBytes)
1774	agentx_varbind_counter64(vb, as.pfras_bytes[IN][PFR_OP_BLOCK]);
1775	else if (obj == pfTblAddrInPassPkts)
1776	agentx_varbind_counter64(vb, as.pfras_packets[IN][PFR_OP_PASS]);
1777	else if (obj == pfTblAddrInPassBytes)
1778	agentx_varbind_counter64(vb, as.pfras_bytes[IN][PFR_OP_PASS]);
1779	else if (obj == pfTblAddrOutBlockPkts)
1780	agentx_varbind_counter64(vb, as.pfras_packets[OUT][PFR_OP_BLOCK]);
1781	else if (obj == pfTblAddrOutBlockBytes)
1782	agentx_varbind_counter64(vb, as.pfras_bytes[OUT][PFR_OP_BLOCK]);
1783	else if (obj == pfTblAddrOutPassPkts)
1784	agentx_varbind_counter64(vb, as.pfras_packets[OUT][PFR_OP_PASS]);
1785	else if (obj == pfTblAddrOutPassBytes)
1786	agentx_varbind_counter64(vb, as.pfras_bytes[OUT][PFR_OP_PASS]);
1787	else if (obj == pfTblAddrInMatchPkts)
1788	agentx_varbind_counter64(vb, as.pfras_packets[IN][PFR_OP_MATCH]);
1789	else if (obj == pfTblAddrInMatchBytes)
1790	agentx_varbind_counter64(vb, as.pfras_bytes[IN][PFR_OP_MATCH]);
1791	else if (obj == pfTblAddrOutMatchPkts)
1792	agentx_varbind_counter64(vb, as.pfras_packets[OUT][PFR_OP_MATCH]);
1793	else if (obj == pfTblAddrOutMatchBytes)
1794	agentx_varbind_counter64(vb, as.pfras_bytes[OUT][PFR_OP_MATCH]);
1795	else
1796	fatal("%s: Unexpected object", __func__);
1797	}
1798
1799	void
1800	mib_close_pftrans(struct agentx_varbind *vb, u_int32_t ticket)
1801	{
1802	extern int devpf;
1803
1804	if (ioctl(devpf, DIOCXEND(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (u_int32_t) & 0x1fff) << 16) \| ((('D')) << 8) \| ((100))), &ticket) == -1) {
1805	log_warn("DIOCXEND");
1806	agentx_varbind_error(vb);
1807	}
1808	}
1809
1810	void
1811	mib_pflabelnum(struct agentx_varbind *vb)
1812	{
1813	struct pfioc_rule pr;
1814	u_int32_t nr, mnr, lnr;
1815	extern int devpf;
1816
1817	memset(&pr, 0, sizeof(pr));
1818	if (ioctl(devpf, DIOCGETRULES(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct pfioc_rule) & 0x1fff) << 16) \| ((('D')) << 8) \| ((6))), &pr) == -1) {
1819	log_warn("DIOCGETRULES");
1820	agentx_varbind_error(vb);
1821	return;
1822	}
1823
1824	mnr = pr.nr;
1825	lnr = 0;
1826	for (nr = 0; nr < mnr; ++nr) {
1827	pr.nr = nr;
1828	if (ioctl(devpf, DIOCGETRULE(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct pfioc_rule) & 0x1fff) << 16) \| ((('D')) << 8) \| ((7))), &pr) == -1) {
1829	log_warn("DIOCGETRULE");
1830	agentx_varbind_error(vb);
1831	mib_close_pftrans(vb, pr.ticket);
1832	return;
1833	}
1834
1835	if (pr.rule.label[0])
1836	lnr++;
1837	}
1838
1839	agentx_varbind_integer(vb, lnr);
1840
1841	mib_close_pftrans(vb, pr.ticket);
1842	}
1843
1844	void
1845	mib_pflabels(struct agentx_varbind *vb)
1846	{
1847	struct agentx_object *obj;
1848	enum agentx_request_type req;
1849	struct pfioc_rule pr;
1850	struct pf_rule r = NULL((void )0);
1851	u_int32_t nr, mnr, lnr;
1852	u_int32_t idx;
1853	extern int devpf;
1854
1855	memset(&pr, 0, sizeof(pr));
1856	if (ioctl(devpf, DIOCGETRULES(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct pfioc_rule) & 0x1fff) << 16) \| ((('D')) << 8) \| ((6))), &pr) == -1) {
1857	log_warn("DIOCGETRULES");
1858	agentx_varbind_error(vb);
1859	return;
1860	}
1861
1862	obj = agentx_varbind_get_object(vb);
1863	idx = agentx_varbind_get_index_integer(vb, pfLabelIdx);
1864	req = agentx_varbind_request(vb);
1865
1866	if (idx < 1) {
1867	if (req == AGENTX_REQUEST_TYPE_GET) {
1868	agentx_varbind_notfound(vb);
1869	return;
1870	}
1871	idx = 1;
1872	} else if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
1873	if (idx == INT32_MAX0x7fffffff) {
1874	agentx_varbind_notfound(vb);
1875	return;
1876	}
1877	idx++;
1878	}
1879
1880	mnr = pr.nr;
1881	lnr = 0;
1882	for (nr = 0; nr < mnr; ++nr) {
1883	pr.nr = nr;
1884	if (ioctl(devpf, DIOCGETRULE(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct pfioc_rule) & 0x1fff) << 16) \| ((('D')) << 8) \| ((7))), &pr) == -1) {
1885	log_warn("DIOCGETRULE");
1886	agentx_varbind_error(vb);
1887	mib_close_pftrans(vb, pr.ticket);
1888	return;
1889	}
1890
1891	if (pr.rule.label[0] && ++lnr == idx) {
1892	r = &pr.rule;
1893	break;
1894	}
1895	}
1896
1897	mib_close_pftrans(vb, pr.ticket);
1898
1899	if (r == NULL((void *)0)) {
1900	agentx_varbind_notfound(vb);
1901	return;
1902	}
1903	agentx_varbind_set_index_integer(vb, pfLabelIdx, idx);
1904
1905	if (obj == pfLabelIndex)
1906	agentx_varbind_integer(vb, lnr);
1907	else if (obj == pfLabelName)
1908	agentx_varbind_string(vb, r->label);
1909	else if (obj == pfLabelEvals)
1910	agentx_varbind_counter64(vb, r->evaluations);
1911	else if (obj == pfLabelPkts)
1912	agentx_varbind_counter64(vb, r->packets[IN] + r->packets[OUT]);
1913	else if (obj == pfLabelBytes)
1914	agentx_varbind_counter64(vb, r->bytes[IN] + r->bytes[OUT]);
1915	else if (obj == pfLabelInPkts)
1916	agentx_varbind_counter64(vb, r->packets[IN]);
1917	else if (obj == pfLabelInBytes)
1918	agentx_varbind_counter64(vb, r->bytes[IN]);
1919	else if (obj == pfLabelOutPkts)
1920	agentx_varbind_counter64(vb, r->packets[OUT]);
1921	else if (obj == pfLabelOutBytes)
1922	agentx_varbind_counter64(vb, r->bytes[OUT]);
1923	else if (obj == pfLabelTotalStates)
1924	agentx_varbind_counter32(vb, r->states_tot);
1925	else
1926	fatal("%s: Unexpected object", __func__);
1927	}
1928
1929	void
1930	mib_pfsyncstats(struct agentx_varbind *vb)
1931	{
1932	struct agentx_object *obj;
1933	int mib[] = { CTL_NET4, PF_INET2, IPPROTO_PFSYNC240,
1934	PFSYNCCTL_STATS1 };
1935	size_t len = sizeof(struct pfsyncstats);
1936	struct pfsyncstats s;
1937
1938	if (sysctl(mib, 4, &s, &len, NULL((void *)0), 0) == -1) {
1939	log_warn("sysctl");
1940	agentx_varbind_error(vb);
1941	return;
1942	}
1943
1944	obj = agentx_varbind_get_object(vb);
1945	if (obj == pfsyncIpPktsRecv)
1946	agentx_varbind_counter64(vb, s.pfsyncs_ipackets);
1947	else if (obj == pfsyncIp6PktsRecv)
1948	agentx_varbind_counter64(vb, s.pfsyncs_ipackets6);
1949	else if (obj == pfsyncPktDiscardsForBadInterface)
1950	agentx_varbind_counter64(vb, s.pfsyncs_badif);
1951	else if (obj == pfsyncPktDiscardsForBadTtl)
1952	agentx_varbind_counter64(vb, s.pfsyncs_badttl);
1953	else if (obj == pfsyncPktShorterThanHeader)
1954	agentx_varbind_counter64(vb, s.pfsyncs_hdrops);
1955	else if (obj == pfsyncPktDiscardsForBadVersion)
1956	agentx_varbind_counter64(vb, s.pfsyncs_badver);
1957	else if (obj == pfsyncPktDiscardsForBadAction)
1958	agentx_varbind_counter64(vb, s.pfsyncs_badact);
1959	else if (obj == pfsyncPktDiscardsForBadLength)
1960	agentx_varbind_counter64(vb, s.pfsyncs_badlen);
1961	else if (obj == pfsyncPktDiscardsForBadAuth)
1962	agentx_varbind_counter64(vb, s.pfsyncs_badauth);
1963	else if (obj == pfsyncPktDiscardsForStaleState)
1964	agentx_varbind_counter64(vb, s.pfsyncs_stale);
1965	else if (obj == pfsyncPktDiscardsForBadValues)
1966	agentx_varbind_counter64(vb, s.pfsyncs_badval);
1967	else if (obj == pfsyncPktDiscardsForBadState)
1968	agentx_varbind_counter64(vb, s.pfsyncs_badstate);
1969	else if (obj == pfsyncIpPktsSent)
1970	agentx_varbind_counter64(vb, s.pfsyncs_opackets);
1971	else if (obj == pfsyncIp6PktsSent)
1972	agentx_varbind_counter64(vb, s.pfsyncs_opackets6);
1973	else if (obj == pfsyncNoMemory)
1974	agentx_varbind_counter64(vb, s.pfsyncs_onomem);
1975	else if (obj == pfsyncOutputErrors)
1976	agentx_varbind_counter64(vb, s.pfsyncs_oerrors);
1977	else
1978	fatal("%s: Unexpected object", __func__);
1979	}
1980
1981	/* OPENBSD-SENSORS-MIB */
1982	void
1983	mib_sensornum(struct agentx_varbind *vb)
1984	{
1985	struct sensordev sensordev;
1986	size_t len = sizeof(sensordev);
1987	int mib[] = { CTL_HW6, HW_SENSORS11, 0 };
1988	int i, c;
1989
1990	for (i = c = 0; ; i++) {
1991	mib[2] = i;
1992	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])),
1993	&sensordev, &len, NULL((void *)0), 0) == -1) {
1994	if (errno(*__errno()) == ENXIO6)
1995	continue;
1996	if (errno(*__errno()) == ENOENT2)
1997	break;
1998	log_warn("sysctl");
1999	agentx_varbind_error(vb);
2000	return;
2001	}
2002	c += sensordev.sensors_count;
2003	}
2004
2005	agentx_varbind_integer(vb, c);
2006	}
2007
2008	void
2009	mib_sensors(struct agentx_varbind *vb)
2010	{
2011	struct agentx_object *obj;
2012	enum agentx_request_type req;
2013	struct sensordev sensordev;
2014	size_t len = sizeof(sensordev);
2015	struct sensor sensor;
2016	size_t slen = sizeof(sensor);
2017	char desc[32];
2018	int mib[] =
2019	{ CTL_HW6, HW_SENSORS11, 0, 0, 0 };
2020	int i, j, k;
2021	u_int32_t idx = 0, n;
2022	char *s;
2023
2024	obj = agentx_varbind_get_object(vb);
2025	idx = agentx_varbind_get_index_integer(vb, sensorIdx);
2026	req = agentx_varbind_request(vb);
2027
2028	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
2029	if (idx == INT32_MAX0x7fffffff) {
2030	agentx_varbind_notfound(vb);
2031	return;
2032	}
2033	idx++;
2034	}
2035	if (idx < 1 &&
2036	(req == AGENTX_REQUEST_TYPE_GETNEXT \|\|
2037	req == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE))
2038	idx = 1;
2039
2040	for (i = 0, n = 1; ; i++) {
2041	mib[2] = i;
2042	if (sysctl(mib, 3, &sensordev, &len, NULL((void *)0), 0) == -1) {
2043	if (errno(*__errno()) == ENXIO6)
2044	continue;
2045	if (errno(*__errno()) == ENOENT2)
2046	break;
2047	log_warn("sysctl");
2048	agentx_varbind_error(vb);
2049	return;
2050	}
2051	for (j = 0; j < SENSOR_MAX_TYPES; j++) {
2052	mib[3] = j;
2053	for (k = 0; k < sensordev.maxnumt[j]; k++) {
2054	mib[4] = k;
2055	if (sysctl(mib, 5,
2056	&sensor, &slen, NULL((void *)0), 0) == -1) {
2057	if (errno(*__errno()) == ENXIO6)
2058	continue;
2059	if (errno(*__errno()) == ENOENT2)
2060	break;
2061	log_warn("sysctl");
2062	agentx_varbind_error(vb);
2063	return;
2064	}
2065	if (sensor.flags & SENSOR_FINVALID0x0001)
2066	continue;
2067	if (n == idx)
2068	goto found;
2069	n++;
2070	}
2071	}
2072	}
2073	agentx_varbind_notfound(vb);
2074	return;
2075
2076	found:
2077	agentx_varbind_set_index_integer(vb, sensorIdx, idx);
2078	if (obj == sensorIndex)
2079	agentx_varbind_integer(vb, (int32_t)n);
2080	else if (obj == sensorDescr) {
2081	if (sensor.desc[0] == '\0') {
2082	snprintf(desc, sizeof(desc), "%s%d",
2083	sensor_type_s[sensor.type],
2084	sensor.numt);
2085	agentx_varbind_string(vb, desc);
2086	} else
2087	agentx_varbind_string(vb, sensor.desc);
2088	} else if (obj == sensorType)
2089	agentx_varbind_integer(vb, sensor.type);
2090	else if (obj == sensorDevice)
2091	agentx_varbind_string(vb, sensordev.xname);
2092	else if (obj == sensorValue) {
2093	if ((s = mib_sensorvalue(&sensor)) == NULL((void *)0)) {
2094	log_warn("asprintf");
2095	agentx_varbind_error(vb);
2096	return;
2097	}
2098	agentx_varbind_string(vb, s);
2099	free(s);
2100	} else if (obj == sensorUnits)
2101	agentx_varbind_string(vb, mib_sensorunit(&sensor));
2102	else if (obj == sensorStatus)
2103	agentx_varbind_integer(vb, sensor.status);
2104	else
2105	fatal("%s: Unexpected object", __func__);
2106	}
2107
2108	#define SENSOR_DRIVE_STATES(10 + 1) (SENSOR_DRIVE_PFAIL10 + 1)
2109	static const char * const sensor_drive_s[SENSOR_DRIVE_STATES(10 + 1)] = {
2110	NULL((void *)0), "empty", "ready", "powerup", "online", "idle", "active",
2111	"rebuild", "powerdown", "fail", "pfail"
2112	};
2113
2114	static const char * const sensor_unit_s[SENSOR_MAX_TYPES + 1] = {
2115	"degC", "RPM", "V DC", "V AC", "Ohm", "W", "A", "Wh", "Ah",
2116	"", "", "%", "lx", "", "sec", "%RH", "Hz", "degree",
2117	"m", "Pa", "m/s^2", "m/s", ""
2118	};
2119
2120	const char *
2121	mib_sensorunit(struct sensor *s)
2122	{
2123	u_int idx;
2124	idx = s->type > SENSOR_MAX_TYPES ?
2125	SENSOR_MAX_TYPES : s->type;
2126	return (sensor_unit_s[idx]);
2127	}
2128
2129	char *
2130	mib_sensorvalue(struct sensor *s)
2131	{
2132	char *v;
2133	int ret = -1;
2134
2135	switch (s->type) {
2136	case SENSOR_TEMP:
2137	ret = asprintf(&v, "%.2f",
2138	(s->value - 273150000) / 1000000.0);
2139	break;
2140	case SENSOR_VOLTS_DC:
2141	case SENSOR_VOLTS_AC:
2142	case SENSOR_WATTS:
2143	case SENSOR_AMPS:
2144	case SENSOR_WATTHOUR:
2145	case SENSOR_AMPHOUR:
2146	case SENSOR_LUX:
2147	case SENSOR_FREQ:
2148	case SENSOR_ACCEL:
2149	case SENSOR_VELOCITY:
2150	case SENSOR_DISTANCE:
2151	ret = asprintf(&v, "%.2f", s->value / 1000000.0);
2152	break;
2153	case SENSOR_INDICATOR:
2154	ret = asprintf(&v, "%s", s->value ? "on" : "off");
2155	break;
2156	case SENSOR_PERCENT:
2157	case SENSOR_HUMIDITY:
2158	ret = asprintf(&v, "%.2f", s->value / 1000.0);
2159	break;
2160	case SENSOR_PRESSURE:
2161	ret = asprintf(&v, "%.2f", s->value / 1000.0);
2162	break;
2163	case SENSOR_TIMEDELTA:
2164	ret = asprintf(&v, "%.6f", s->value / 1000000000.0);
2165	break;
2166	case SENSOR_DRIVE:
2167	if (s->value > 0 && s->value < SENSOR_DRIVE_STATES(10 + 1)) {
2168	ret = asprintf(&v, "%s", sensor_drive_s[s->value]);
2169	break;
2170	}
2171	/* FALLTHROUGH */
2172	case SENSOR_FANRPM:
2173	case SENSOR_OHMS:
2174	case SENSOR_INTEGER:
2175	default:
2176	ret = asprintf(&v, "%lld", s->value);
2177	break;
2178	}
2179
2180	if (ret == -1)
2181	return (NULL((void *)0));
2182	return (v);
2183	}
2184
2185	void
2186	mib_carpsysctl(struct agentx_varbind *vb)
2187	{
2188	struct agentx_object *obj;
2189	size_t len;
2190	int mib[] = { CTL_NET4, PF_INET2, IPPROTO_CARP112, 0 };
2191	int v;
2192
2193	obj = agentx_varbind_get_object(vb);
2194	if (obj == carpAllow)
2195	mib[3] = CARPCTL_ALLOW1;
2196	else if (obj == carpPreempt)
2197	mib[3] = CARPCTL_PREEMPT2;
2198	else if (obj == carpLog)
2199	mib[3] = CARPCTL_LOG3;
2200	else
2201	fatal("%s: Unexpected object", __func__);
2202	len = sizeof(v);
2203
2204	if (sysctl(mib, 4, &v, &len, NULL((void *)0), 0) == -1) {
2205	log_warn("sysctl");
2206	agentx_varbind_error(vb);
2207	return;
2208	}
2209
2210	agentx_varbind_integer(vb, v);
2211	}
2212
2213	void
2214	mib_carpstats(struct agentx_varbind *vb)
2215	{
2216	struct agentx_object *obj;
2217	int mib[] = { CTL_NET4, PF_INET2, IPPROTO_CARP112,
2218	CARPCTL_STATS4 };
2219	size_t len;
2220	struct carpstats stats;
2221
2222	len = sizeof(stats);
2223
2224	if (sysctl(mib, 4, &stats, &len, NULL((void *)0), 0) == -1) {
2225	log_warn("sysctl");
2226	agentx_varbind_error(vb);
2227	return;
2228	}
2229
2230	obj = agentx_varbind_get_object(vb);
2231	if (obj == carpIpPktsRecv)
2232	agentx_varbind_counter64(vb, stats.carps_ipackets);
2233	else if (obj == carpIp6PktsRecv)
2234	agentx_varbind_counter64(vb, stats.carps_ipackets6);
2235	else if (obj == carpPktDiscardsForBadInterface)
2236	agentx_varbind_counter64(vb, stats.carps_badif);
2237	else if (obj == carpPktDiscardsForWrongTtl)
2238	agentx_varbind_counter64(vb, stats.carps_badttl);
2239	else if (obj == carpPktShorterThanHeader)
2240	agentx_varbind_counter64(vb, stats.carps_hdrops);
2241	else if (obj == carpPktDiscardsForBadChecksum)
2242	agentx_varbind_counter64(vb, stats.carps_badsum);
2243	else if (obj == carpPktDiscardsForBadVersion)
2244	agentx_varbind_counter64(vb, stats.carps_badver);
2245	else if (obj == carpPktDiscardsForTooShort)
2246	agentx_varbind_counter64(vb, stats.carps_badlen);
2247	else if (obj == carpPktDiscardsForBadAuth)
2248	agentx_varbind_counter64(vb, stats.carps_badauth);
2249	else if (obj == carpPktDiscardsForBadVhid)
2250	agentx_varbind_counter64(vb, stats.carps_badvhid);
2251	else if (obj == carpPktDiscardsForBadAddressList)
2252	agentx_varbind_counter64(vb, stats.carps_badaddrs);
2253	else if (obj == carpIpPktsSent)
2254	agentx_varbind_counter64(vb, stats.carps_opackets);
2255	else if (obj == carpIp6PktsSent)
2256	agentx_varbind_counter64(vb, stats.carps_opackets6);
2257	else if (obj == carpNoMemory)
2258	agentx_varbind_counter64(vb, stats.carps_onomem);
2259	else if (obj == carpTransitionsToMaster)
2260	agentx_varbind_counter64(vb, stats.carps_preempt);
2261	else
2262	fatal("%s: Unexpected object", __func__);
2263	}
2264
2265	void
2266	mib_carpifnum(struct agentx_varbind *vb)
2267	{
2268	struct kif *kif;
2269	int c = 0;
2270
2271	for (kif = kr_getif(0); kif != NULL((void *)0);
2272	kif = kr_getnextif(kif->if_index))
2273	if (kif->if_typeif_data.ifi_type == IFT_CARP0xf7)
2274	c++;
2275
2276	agentx_varbind_integer(vb, c);
2277	}
2278
2279	struct carpif *
2280	mib_carpifget(u_int idx)
2281	{
2282	struct kif *kif;
2283	struct carpif *cif;
2284	int s;
2285	struct ifreq ifr;
2286	struct carpreq carpr;
2287
2288	if ((kif = kr_getif(idx)) == NULL((void *)0) \|\| kif->if_typeif_data.ifi_type != IFT_CARP0xf7) {
2289	/*
2290	* It may happen that an interface with a specific index
2291	* does not exist, has been removed, or is not a carp(4)
2292	* interface. Jump to the next available carp(4) interface
2293	* index.
2294	*/
2295	for (kif = kr_getif(0); kif != NULL((void *)0);
2296	kif = kr_getnextif(kif->if_index)) {
2297	if (kif->if_typeif_data.ifi_type != IFT_CARP0xf7)
2298	continue;
2299	if (kif->if_index > idx)
2300	break;
2301
2302	}
2303	if (kif == NULL((void *)0))
2304	return (NULL((void *)0));
2305	}
2306	idx = kif->if_index;
2307
2308	/* Update interface information */
2309	kr_updateif(idx);
2310	if ((kif = kr_getif(idx)) == NULL((void *)0)) {
2311	log_debug("mib_carpifget: interface %d disappeared?", idx);
2312	return (NULL((void *)0));
2313	}
2314
2315	if ((s = socket(AF_INET2, SOCK_DGRAM2, 0)) == -1)
2316	return (NULL((void *)0));
2317
2318	memset(&ifr, 0, sizeof(ifr));
2319	strlcpy(ifr.ifr_name, kif->if_name, sizeof(ifr.ifr_name));
2320	memset((char *)&carpr, 0, sizeof(carpr));
2321	ifr.ifr_dataifr_ifru.ifru_data = (caddr_t)&carpr;
2322
2323	if (ioctl(s, SIOCGVH(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct ifreq) & 0x1fff) << 16) \| ((('i')) << 8) \| ((246))), (caddr_t)&ifr) == -1) {
2324	close(s);
2325	return (NULL((void *)0));
2326	}
2327
2328	cif = calloc(1, sizeof(struct carpif));
2329	if (cif != NULL((void *)0)) {
2330	memcpy(&cif->carpr, &carpr, sizeof(struct carpreq));
2331	memcpy(&cif->kif, kif, sizeof(struct kif));
2332	}
2333
2334	close(s);
2335
2336	return (cif);
2337	}
2338
2339	void
2340	mib_carpiftable(struct agentx_varbind *vb)
2341	{
2342	struct agentx_object *obj;
2343	enum agentx_request_type req;
2344	u_int32_t idx;
2345	struct carpif *cif;
2346
2347	obj = agentx_varbind_get_object(vb);
2348	idx = agentx_varbind_get_index_integer(vb, carpIfIdx);
2349	req = agentx_varbind_request(vb);
2350
2351	if (idx < 1) {
2352	if (req == AGENTX_REQUEST_TYPE_GET) {
2353	agentx_varbind_notfound(vb);
2354	return;
2355	}
2356	idx = 1;
2357	} else if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
2358	if (idx == INT32_MAX0x7fffffff) {
2359	agentx_varbind_notfound(vb);
2360	return;
2361	}
2362	idx++;
2363	}
2364
2365	/*
2366	* XXX No consistent way to differentiate between not found and error
2367	* Treat everything as not found.
2368	*/
2369	if ((cif = mib_carpifget(idx)) == NULL((void *)0)) {
2370	agentx_varbind_notfound(vb);
2371	return;
2372	}
2373
2374	if (req == AGENTX_REQUEST_TYPE_GET && cif->kif.if_index != idx) {
2375	agentx_varbind_notfound(vb);
2376	return;
2377	}
2378	agentx_varbind_set_index_integer(vb, carpIfIdx, cif->kif.if_index);
2379
2380	if (obj == carpIfIndex)
2381	agentx_varbind_integer(vb, cif->kif.if_index);
2382	else if (obj == carpIfDescr)
2383	agentx_varbind_string(vb, cif->kif.if_name);
2384	else if (obj == carpIfVhid)
2385	agentx_varbind_integer(vb, cif->carpr.carpr_vhids[0]);
2386	else if (obj == carpIfDev)
2387	agentx_varbind_string(vb, cif->carpr.carpr_carpdev);
2388	else if (obj == carpIfAdvbase)
2389	agentx_varbind_integer(vb, cif->carpr.carpr_advbase);
2390	else if (obj == carpIfAdvskew)
2391	agentx_varbind_integer(vb, cif->carpr.carpr_advskews[0]);
2392	else if (obj == carpIfState)
2393	agentx_varbind_integer(vb, cif->carpr.carpr_states[0]);
2394	else
2395	fatal("%s: Unexpected object", __func__);
2396	free(cif);
2397	}
2398
2399	static struct ifg_req *
2400	mib_carpgroupget(u_int idx)
2401	{
2402	struct ifgroupreq ifgr;
2403	struct ifg_req ifg = NULL((void )0);
2404	u_int len;
2405	int s = -1;
2406
2407	bzero(&ifgr, sizeof(ifgr));
2408
2409	if ((s = socket(AF_INET2, SOCK_DGRAM2, 0)) == -1) {
2410	log_warn("socket");
2411	return (NULL((void *)0));
2412	}
2413
2414	if (ioctl(s, SIOCGIFGLIST(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct ifgroupreq) & 0x1fff) << 16) \| ((('i')) << 8) \| ((141))), (caddr_t)&ifgr) == -1) {
2415	log_warn("SIOCGIFGLIST");
2416	goto err;
2417	}
2418	len = ifgr.ifgr_len;
2419
2420	if (len / sizeof(*ifgr.ifgr_groupsifgr_ifgru.ifgru_groups) <= idx-1)
2421	goto err;
2422
2423	if ((ifgr.ifgr_groupsifgr_ifgru.ifgru_groups = calloc(1, len)) == NULL((void *)0)) {
2424	log_warn("alloc");
2425	goto err;
2426	}
2427	if (ioctl(s, SIOCGIFGLIST(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct ifgroupreq) & 0x1fff) << 16) \| ((('i')) << 8) \| ((141))), (caddr_t)&ifgr) == -1) {
2428	log_warn("SIOCGIFGLIST");
2429	goto err;
2430	}
2431	close(s);
2432
2433	if ((ifg = calloc(1, sizeof ifg)) == NULL((void )0)) {
2434	log_warn("alloc");
2435	goto err;
2436	}
2437
2438	memcpy(ifg, &ifgr.ifgr_groupsifgr_ifgru.ifgru_groups[idx-1], sizeof *ifg);
2439	free(ifgr.ifgr_groupsifgr_ifgru.ifgru_groups);
2440	return ifg;
2441	err:
2442	free(ifgr.ifgr_groupsifgr_ifgru.ifgru_groups);
2443	close(s);
2444	return (NULL((void *)0));
2445	}
2446
2447	void
2448	mib_carpgrouptable(struct agentx_varbind *vb)
2449	{
2450	struct agentx_object *obj;
2451	enum agentx_request_type req;
2452	struct ifgroupreq ifgr;
2453	struct ifg_req *ifg;
2454	uint32_t idx;
2455	int s;
2456
2457	obj = agentx_varbind_get_object(vb);
2458	idx = agentx_varbind_get_index_integer(vb, carpGroupIdx);
2459	req = agentx_varbind_request(vb);
2460
2461	if (idx < 1) {
2462	if (req == AGENTX_REQUEST_TYPE_GET) {
2463	agentx_varbind_notfound(vb);
2464	return;
2465	}
2466	idx = 1;
2467	} else if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
2468	if (idx == INT32_MAX0x7fffffff) {
2469	agentx_varbind_notfound(vb);
2470	return;
2471	}
2472	idx++;
2473	}
2474
2475	/*
2476	* XXX No consistent way to differentiate between not found and error
2477	* Treat everything as not found.
2478	*/
2479	if ((ifg = mib_carpgroupget(idx)) == NULL((void *)0)) {
2480	agentx_varbind_notfound(vb);
2481	return;
2482	}
2483	agentx_varbind_set_index_integer(vb, carpGroupIdx, idx);
2484
2485	if (obj == carpGroupName)
2486	agentx_varbind_string(vb, ifg->ifgrq_groupifgrq_ifgrqu.ifgrqu_group);
2487	else if (obj == carpGroupDemote) {
2488	if ((s = socket(AF_INET2, SOCK_DGRAM2, 0)) == -1) {
2489	log_warn("socket");
2490	free(ifg);
2491	agentx_varbind_error(vb);
2492	return;
2493	}
2494
2495	bzero(&ifgr, sizeof(ifgr));
2496	strlcpy(ifgr.ifgr_name, ifg->ifgrq_groupifgrq_ifgrqu.ifgrqu_group, sizeof(ifgr.ifgr_name));
2497	if (ioctl(s, SIOCGIFGATTR(((unsigned long)0x80000000\|(unsigned long)0x40000000) \| ((sizeof (struct ifgroupreq) & 0x1fff) << 16) \| ((('i')) << 8) \| ((139))), (caddr_t)&ifgr) == -1) {
2498	log_warn("SIOCGIFGATTR");
2499	close(s);
2500	free(ifg);
2501	agentx_varbind_error(vb);
2502	return;
2503	}
2504
2505	close(s);
2506	agentx_varbind_integer(vb, ifgr.ifgr_attribifgr_ifgru.ifgru_attrib.ifg_carp_demoted);
2507	} else
2508	fatal("%s: Unexpected object", __func__);
2509
2510	free(ifg);
2511	}
2512
2513	void
2514	mib_memversion(struct agentx_varbind *vb)
2515	{
2516	agentx_varbind_integer(vb, 1);
2517	}
2518
2519	void
2520	mib_memiftable(struct agentx_varbind *vb)
2521	{
2522	struct agentx_object *obj;
2523	enum agentx_request_type req;
2524	u_int32_t idx = 0;
2525	struct kif *kif;
2526
2527	obj = agentx_varbind_get_object(vb);
2528	idx = agentx_varbind_get_index_integer(vb, ifIdx);
2529	req = agentx_varbind_request(vb);
2530	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
2531	if (idx == INT32_MAX0x7fffffff) {
2532	agentx_varbind_notfound(vb);
2533	return;
2534	}
2535	idx++;
2536	}
2537	if ((kif = mib_ifget(idx)) == NULL((void *)0)) {
2538	agentx_varbind_notfound(vb);
2539	return;
2540	}
2541	if (req == AGENTX_REQUEST_TYPE_GET) {
2542	if (idx != kif->if_index) {
2543	agentx_varbind_notfound(vb);
2544	return;
2545	}
2546	}
2547	agentx_varbind_set_index_integer(vb, ifIdx, kif->if_index);
2548
2549	if (obj == memIfName)
2550	agentx_varbind_string(vb, kif->if_name);
2551	else if (obj == memIfLiveLocks)
2552	agentx_varbind_counter64(vb, 0);
2553	else
2554	fatal("%s: Unexpected object", __func__);
2555	}
2556
2557	/*
2558	* Defined in IP-MIB.txt
2559	*/
2560	int mib_getipstat(struct ipstat *);
2561	void mib_ipstat(struct agentx_varbind *);
2562	void mib_ipforwarding(struct agentx_varbind *);
2563	void mib_ipdefaultttl(struct agentx_varbind *);
2564	void mib_ipinhdrerrs(struct agentx_varbind *);
2565	void mib_ipinaddrerrs(struct agentx_varbind *);
2566	void mib_ipforwdgrams(struct agentx_varbind *);
2567	void mib_ipreasmtimeout(struct agentx_varbind *);
2568	void mib_ipreasmfails(struct agentx_varbind *);
2569	void mib_ipfragfails(struct agentx_varbind *);
2570	void mib_ipaddr(struct agentx_varbind *);
2571	void mib_physaddr(struct agentx_varbind *);
2572
2573	void
2574	mib_ipforwarding(struct agentx_varbind *vb)
2575	{
2576	int mib[] = { CTL_NET4, PF_INET2, IPPROTO_IP0, IPCTL_FORWARDING1 };
2577	int v;
2578	size_t len = sizeof(v);
2579
2580	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &v, &len, NULL((void *)0), 0) == -1) {
2581	log_warn("sysctl");
2582	agentx_varbind_error(vb);
2583	return;
2584	}
2585
2586	/* ipForwarding: forwarding(1), notForwarding(2) */
2587	agentx_varbind_integer(vb, (v == 0) ? 2 : 1);
2588	}
2589
2590	void
2591	mib_ipdefaultttl(struct agentx_varbind *vb)
2592	{
2593	int mib[] = { CTL_NET4, PF_INET2, IPPROTO_IP0, IPCTL_DEFTTL3 };
2594	int v;
2595	size_t len = sizeof(v);
2596
2597	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &v, &len, NULL((void *)0), 0) == -1) {
2598	log_warn("sysctl");
2599	agentx_varbind_error(vb);
2600	return;
2601	}
2602
2603	agentx_varbind_integer(vb, v);
2604	}
2605
2606	int
2607	mib_getipstat(struct ipstat *ipstat)
2608	{
2609	int mib[] = { CTL_NET4, PF_INET2, IPPROTO_IP0, IPCTL_STATS33 };
2610	size_t len = sizeof(*ipstat);
2611
2612	return (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), ipstat, &len, NULL((void *)0), 0));
2613	}
2614
2615	void
2616	mib_ipstat(struct agentx_varbind *vb)
2617	{
2618	struct agentx_object *obj;
2619	struct ipstat ipstat;
2620
2621	if (mib_getipstat(&ipstat) == -1) {
2622	log_warn("sysctl");
2623	agentx_varbind_error(vb);
2624	return;
2625	}
2626
2627	obj = agentx_varbind_get_object(vb);
2628	if (obj == ipInReceives)
2629	agentx_varbind_counter32(vb, ipstat.ips_total);
2630	else if (obj == ipInUnknownProtos)
2631	agentx_varbind_counter32(vb, ipstat.ips_noproto);
2632	else if (obj == ipInDelivers)
2633	agentx_varbind_counter32(vb, ipstat.ips_delivered);
2634	else if (obj == ipOutRequests)
2635	agentx_varbind_counter32(vb, ipstat.ips_localout);
2636	else if (obj == ipOutDiscards)
2637	agentx_varbind_counter32(vb, ipstat.ips_odropped);
2638	else if (obj == ipOutNoRoutes)
2639	agentx_varbind_counter32(vb, ipstat.ips_noroute);
2640	else if (obj == ipReasmReqds)
2641	agentx_varbind_counter32(vb, ipstat.ips_fragments);
2642	else if (obj == ipReasmOKs)
2643	agentx_varbind_counter32(vb, ipstat.ips_reassembled);
2644	else if (obj == ipFragOKs)
2645	agentx_varbind_counter32(vb, ipstat.ips_fragmented);
2646	else if (obj == ipFragCreates)
2647	agentx_varbind_counter32(vb, ipstat.ips_ofragments);
2648	else
2649	fatal("%s: Unexpected object", __func__);
2650	}
2651
2652	void
2653	mib_ipinhdrerrs(struct agentx_varbind *vb)
2654	{
2655	u_int32_t errors;
2656	struct ipstat ipstat;
2657
2658	if (mib_getipstat(&ipstat) == -1) {
2659	log_warn("sysctl");
2660	agentx_varbind_error(vb);
2661	return;
2662	}
2663
2664	errors = ipstat.ips_badsum + ipstat.ips_badvers +
2665	ipstat.ips_tooshort + ipstat.ips_toosmall +
2666	ipstat.ips_badhlen + ipstat.ips_badlen +
2667	ipstat.ips_badoptions + ipstat.ips_toolong +
2668	ipstat.ips_badaddr;
2669
2670	agentx_varbind_counter32(vb, errors);
2671	}
2672
2673	void
2674	mib_ipinaddrerrs(struct agentx_varbind *vb)
2675	{
2676	u_int32_t errors;
2677	struct ipstat ipstat;
2678
2679	if (mib_getipstat(&ipstat) == -1) {
2680	log_warn("sysctl");
2681	agentx_varbind_error(vb);
2682	return;
2683	}
2684
2685	errors = ipstat.ips_cantforward + ipstat.ips_badaddr;
2686
2687	agentx_varbind_counter32(vb, errors);
2688	}
2689
2690	void
2691	mib_ipforwdgrams(struct agentx_varbind *vb)
2692	{
2693	u_int32_t counter;
2694	struct ipstat ipstat;
2695
2696	if (mib_getipstat(&ipstat) == -1) {
2697	log_warn("sysctl");
2698	agentx_varbind_error(vb);
2699	return;
2700	}
2701
2702	counter = ipstat.ips_forward + ipstat.ips_redirectsent;
2703
2704	agentx_varbind_counter32(vb, counter);
2705	}
2706
2707	void
2708	mib_ipreasmtimeout(struct agentx_varbind *vb)
2709	{
2710	agentx_varbind_integer(vb, IPFRAGTTL60);
2711	}
2712
2713	void
2714	mib_ipreasmfails(struct agentx_varbind *vb)
2715	{
2716	u_int32_t counter;
2717	struct ipstat ipstat;
2718
2719	if (mib_getipstat(&ipstat) == -1) {
2720	log_warn("sysctl");
2721	agentx_varbind_error(vb);
2722	return;
2723	}
2724
2725	counter = ipstat.ips_fragdropped + ipstat.ips_fragtimeout;
2726
2727	agentx_varbind_counter32(vb, counter);
2728	}
2729
2730	void
2731	mib_ipfragfails(struct agentx_varbind *vb)
2732	{
2733	u_int32_t counter;
2734	struct ipstat ipstat;
2735
2736	if (mib_getipstat(&ipstat) == -1) {
2737	log_warn("sysctl");
2738	agentx_varbind_error(vb);
2739	return;
2740	}
2741
2742	counter = ipstat.ips_badfrags + ipstat.ips_cantfrag;
2743	agentx_varbind_counter32(vb, counter);
2744	}
2745
2746	void
2747	mib_ipaddr(struct agentx_varbind *vb)
2748	{
2749	struct agentx_object *obj;
2750	enum agentx_request_type req;
2751	struct sockaddr_in addr;
2752	struct kif_addr *ka;
2753
2754	obj = agentx_varbind_get_object(vb);
2755	req = agentx_varbind_request(vb);
2756	bzero(&addr, sizeof(addr));
2757	addr.sin_family = AF_INET2;
2758	addr.sin_len = sizeof(addr);
2759	addr.sin_addr = *agentx_varbind_get_index_ipaddress(vb, ipAdEntAddrIdx);
2760
2761	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
2762	if (addr.sin_addr.s_addr == UINT32_MAX0xffffffffU) {
2763	agentx_varbind_notfound(vb);
2764	return;
2765	}
2766	addr.sin_addr.s_addr = htonl(ntohl(addr.sin_addr.s_addr) + 1)(__uint32_t)(__builtin_constant_p((__uint32_t)(__builtin_constant_p (addr.sin_addr.s_addr) ? (__uint32_t)(((__uint32_t)(addr.sin_addr .s_addr) & 0xff) << 24 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff00) << 8 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff000000) >> 24) : __swap32md(addr.sin_addr .s_addr)) + 1) ? (__uint32_t)(((__uint32_t)((__uint32_t)(__builtin_constant_p (addr.sin_addr.s_addr) ? (__uint32_t)(((__uint32_t)(addr.sin_addr .s_addr) & 0xff) << 24 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff00) << 8 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff000000) >> 24) : __swap32md(addr.sin_addr .s_addr)) + 1) & 0xff) << 24 \| ((__uint32_t)((__uint32_t )(__builtin_constant_p(addr.sin_addr.s_addr) ? (__uint32_t)(( (__uint32_t)(addr.sin_addr.s_addr) & 0xff) << 24 \| ( (__uint32_t)(addr.sin_addr.s_addr) & 0xff00) << 8 \| ((__uint32_t)(addr.sin_addr.s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(addr.sin_addr.s_addr) & 0xff000000) >> 24) : __swap32md(addr.sin_addr.s_addr)) + 1) & 0xff00) << 8 \| ((__uint32_t)((__uint32_t)(__builtin_constant_p(addr.sin_addr .s_addr) ? (__uint32_t)(((__uint32_t)(addr.sin_addr.s_addr) & 0xff) << 24 \| ((__uint32_t)(addr.sin_addr.s_addr) & 0xff00) << 8 \| ((__uint32_t)(addr.sin_addr.s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(addr.sin_addr.s_addr) & 0xff000000) >> 24) : __swap32md(addr.sin_addr.s_addr)) + 1) & 0xff0000) >> 8 \| ((__uint32_t)((__uint32_t) (__builtin_constant_p(addr.sin_addr.s_addr) ? (__uint32_t)((( __uint32_t)(addr.sin_addr.s_addr) & 0xff) << 24 \| ( (__uint32_t)(addr.sin_addr.s_addr) & 0xff00) << 8 \| ((__uint32_t)(addr.sin_addr.s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(addr.sin_addr.s_addr) & 0xff000000) >> 24) : __swap32md(addr.sin_addr.s_addr)) + 1) & 0xff000000 ) >> 24) : __swap32md((__uint32_t)(__builtin_constant_p (addr.sin_addr.s_addr) ? (__uint32_t)(((__uint32_t)(addr.sin_addr .s_addr) & 0xff) << 24 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff00) << 8 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(addr.sin_addr .s_addr) & 0xff000000) >> 24) : __swap32md(addr.sin_addr .s_addr)) + 1));
2767	}
2768	/*
2769	* XXX No consistent way to differentiate between not found and error
2770	* Treat everything as not found.
2771	*/
2772	ka = kr_getnextaddr((struct sockaddr *)&addr);
2773	if (ka == NULL((void *)0) \|\| ka->addr.sa.sa_family != AF_INET2) {
2774	agentx_varbind_notfound(vb);
2775	return;
2776	}
2777	if (req == AGENTX_REQUEST_TYPE_GET) {
2778	if (addr.sin_addr.s_addr !=
2779	((struct sockaddr_in *)&ka->addr.sa)->sin_addr.s_addr) {
2780	agentx_varbind_notfound(vb);
2781	return;
2782	}
2783	}
2784	agentx_varbind_set_index_ipaddress(vb, ipAdEntAddrIdx,
2785	&((struct sockaddr_in *)&ka->addr.sa)->sin_addr);
2786
2787	if (obj == ipAdEntAddr)
2788	agentx_varbind_ipaddress(vb,
2789	&((struct sockaddr_in *)&ka->addr.sa)->sin_addr);
2790	else if (obj == ipAdEntIfIndex)
2791	agentx_varbind_integer(vb, ka->if_index);
2792	else if (obj == ipAdEntNetMask)
2793	agentx_varbind_ipaddress(vb, &ka->mask.sin.sin_addr);
2794	else if (obj == ipAdEntBcastAddr)
2795	agentx_varbind_integer(vb, ka->dstbrd.sa.sa_len ? 1 : 0);
2796	else if (obj == ipAdEntReasmMaxSize)
2797	agentx_varbind_integer(vb, IP_MAXPACKET65535);
2798	else
2799	fatal("%s: Unexpected object", __func__);
2800	}
2801
2802	void
2803	mib_physaddr(struct agentx_varbind *vb)
2804	{
2805	struct agentx_object *obj;
2806	enum agentx_request_type req;
2807	struct sockaddr_in addr;
2808	struct kif *kif;
2809	struct kif_arp *ka;
2810	u_int32_t idx = 0;
2811
2812	obj = agentx_varbind_get_object(vb);
2813	idx = agentx_varbind_get_index_integer(vb, ipNetToMediaIfIdx);
2814	req = agentx_varbind_request(vb);
2815
2816	/* Get the IP address */
2817	bzero(&addr, sizeof(addr));
2818	addr.sin_family = AF_INET2;
2819	addr.sin_len = sizeof(addr);
2820	addr.sin_addr = *agentx_varbind_get_index_ipaddress(vb,
2821	ipNetToMediaNetAddressIdx);
2822
2823	if (req == AGENTX_REQUEST_TYPE_GET \|\|
2824	req == AGENTX_REQUEST_TYPE_GETNEXTINCLUSIVE) {
2825	if ((ka = karp_getaddr((struct sockaddr )&addr, idx, 0)) == NULL((void )0)) {
2826	if (req == AGENTX_REQUEST_TYPE_GET) {
2827	agentx_varbind_notfound(vb);
2828	return;
2829	}
2830	req = AGENTX_REQUEST_TYPE_GETNEXT;
2831	} else {
2832	if (req == AGENTX_REQUEST_TYPE_GET &&
2833	(idx != ka->if_index \|\|
2834	addr.sin_addr.s_addr !=
2835	ka->addr.sin.sin_addr.s_addr)) {
2836	agentx_varbind_notfound(vb);
2837	return;
2838	}
2839	}
2840	}
2841	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
2842	if ((kif = kr_getif(idx)) == NULL((void *)0)) {
2843	/* No configured interfaces */
2844	if (idx == 0) {
2845	agentx_varbind_notfound(vb);
2846	return;
2847	}
2848	/*
2849	* It may happen that an interface with a specific index
2850	* does not exist or has been removed. Jump to the next
2851	* available interface.
2852	*/
2853	kif = kr_getif(0);
2854	nextif:
2855	for (; kif != NULL((void *)0); kif = kr_getnextif(kif->if_index))
2856	if (kif->if_index > idx &&
2857	(ka = karp_first(kif->if_index)) != NULL((void *)0))
2858	break;
2859	if (kif == NULL((void *)0)) {
2860	/* No more interfaces with addresses on them */
2861	agentx_varbind_notfound(vb);
2862	return;
2863	}
2864	} else {
2865	if (idx == 0 \|\| addr.sin_addr.s_addr == 0)
2866	ka = karp_first(kif->if_index);
2867	else {
2868	/* XXX This only works on a walk. */
2869	ka = karp_getaddr((struct sockaddr *)&addr, idx, 1);
2870	}
2871	if (ka == NULL((void *)0)) {
2872	/* Try next interface */
2873	goto nextif;
2874	}
2875	}
2876	}
2877	agentx_varbind_set_index_integer(vb, ipNetToMediaIfIdx, ka->if_index);
2878	agentx_varbind_set_index_ipaddress(vb, ipNetToMediaNetAddressIdx,
2879	&ka->addr.sin.sin_addr);
2880
2881	if (obj == ipNetToMediaIfIndex)
2882	agentx_varbind_integer(vb, ka->if_index);
2883	else if (obj == ipNetToMediaPhysAddress) {
2884	if (bcmp(LLADDR(&ka->target.sdl)((caddr_t)((&ka->target.sdl)->sdl_data + (&ka-> target.sdl)->sdl_nlen)), ether_zeroaddr,
2885	sizeof(ether_zeroaddr)) == 0)
2886	agentx_varbind_nstring(vb, ether_zeroaddr,
2887	sizeof(ether_zeroaddr));
2888	else
2889	agentx_varbind_nstring(vb, LLADDR(&ka->target.sdl)((caddr_t)((&ka->target.sdl)->sdl_data + (&ka-> target.sdl)->sdl_nlen)),
2890	ka->target.sdl.sdl_alen);
2891	} else if (obj == ipNetToMediaNetAddress)
2892	agentx_varbind_ipaddress(vb, &ka->addr.sin.sin_addr);
2893	else if (obj == ipNetToMediaType) {
2894	if (ka->flags & F_STATIC0x0002)
2895	agentx_varbind_integer(vb, 4); /* static */
2896	else
2897	agentx_varbind_integer(vb, 3); /* dynamic */
2898	} else
2899	fatal("%s: Unexpected object", __func__);
2900	}
2901
2902	/*
2903	* Defined in IP-FORWARD-MIB.txt (rfc4292)
2904	*/
2905
2906	void mib_ipfnroutes(struct agentx_varbind *);
2907	//struct ber_oid *
2908	//mib_ipfroutetable(struct oid oid, struct ber_oid o, struct ber_oid *no);
2909	void mib_ipfroute(struct agentx_varbind *);
2910
2911	void
2912	mib_ipfnroutes(struct agentx_varbind *vb)
2913	{
2914	agentx_varbind_gauge32(vb, kr_routenumber());
2915	}
2916
2917	#define INETADDRESSTYPE_IPV41 1
2918	void
2919	mib_ipfroute(struct agentx_varbind *vb)
2920	{
2921	struct agentx_object *obj;
2922	enum agentx_request_type req;
2923	struct kroute *kr;
2924	const in_addr_t addr, nhaddr;
2925	const uint32_t *policy;
2926	size_t alen, plen, nlen;
2927	int af;
2928	int implied;
2929	u_int8_t prefixlen, prio, type, proto;
2930
2931
2932	obj = agentx_varbind_get_object(vb);
2933	req = agentx_varbind_request(vb);
2934	af = agentx_varbind_get_index_integer(vb, inetCidrRouteDestTypeIdx);
2935	addr = (const in_addr_t *)agentx_varbind_get_index_string(vb,
2936	inetCidrRouteDestIdx, &alen, &implied);
2937	prefixlen = agentx_varbind_get_index_integer(vb,
2938	inetCidrRoutePfxLenIdx);
2939	policy = agentx_varbind_get_index_oid(vb, inetCidrRoutePolicyIdx,
2940	&plen, &implied);
2941	nhaddr = ((const in_addr_t *)agentx_varbind_get_index_string(vb,
2942	inetCidrRouteNextHopIdx, &nlen, &implied));
2943
2944	if (plen >= 2)
2945	prio = policy[1];
2946	/* Initial 2 sub-identifiers should always be the same for us */
2947	if (af < INETADDRESSTYPE_IPV41 \|\|
2948	(af == INETADDRESSTYPE_IPV41 && alen < 4)) {
2949	if (req == AGENTX_REQUEST_TYPE_GET) {
2950	agentx_varbind_notfound(vb);
2951	return;
2952	}
2953	kr = kroute_first();
2954	} else if (af > INETADDRESSTYPE_IPV41 \|\|
2955	(af == INETADDRESSTYPE_IPV41 && alen > 4)) {
2956	agentx_varbind_notfound(vb);
2957	return;
2958	} else {
2959	/* XXX This only works when requesting known values. */
2960	kr = kroute_getaddr(*addr, prefixlen, prio,
2961	req == AGENTX_REQUEST_TYPE_GETNEXT);
2962	if (kr == NULL((void *)0)) {
2963	agentx_varbind_notfound(vb);
2964	return;
2965	}
2966	if (req == AGENTX_REQUEST_TYPE_GETNEXT)
2967	goto done;
2968	if (nlen < 4) {
2969	if (req == AGENTX_REQUEST_TYPE_GET) {
2970	agentx_varbind_notfound(vb);
2971	return;
2972	}
2973	} else if (nlen > 4) {
2974	kr = kroute_getaddr(*addr, prefixlen, prio, 1);
2975	if (req == AGENTX_REQUEST_TYPE_GET \|\| kr == NULL((void *)0)) {
2976	agentx_varbind_notfound(vb);
2977	return;
2978	}
2979	} else {
2980	if (ntohl(kr->nexthop.s_addr)(__uint32_t)(__builtin_constant_p(kr->nexthop.s_addr) ? (__uint32_t )(((__uint32_t)(kr->nexthop.s_addr) & 0xff) << 24 \| ((__uint32_t)(kr->nexthop.s_addr) & 0xff00) << 8 \| ((__uint32_t)(kr->nexthop.s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(kr->nexthop.s_addr) & 0xff000000) >> 24) : __swap32md(kr->nexthop.s_addr)) < ntohl(nhaddr)(__uint32_t)(__builtin_constant_p(nhaddr) ? (__uint32_t)(((__uint32_t )(nhaddr) & 0xff) << 24 \| ((__uint32_t)(nhaddr) & 0xff00) << 8 \| ((__uint32_t)(nhaddr) & 0xff0000) >> 8 \| ((__uint32_t)(nhaddr) & 0xff000000) >> 24) : __swap32md (*nhaddr))) {
2981	if (req == AGENTX_REQUEST_TYPE_GET) {
2982	agentx_varbind_notfound(vb);
2983	return;
2984	}
2985	} else if (ntohl(kr->nexthop.s_addr)(__uint32_t)(__builtin_constant_p(kr->nexthop.s_addr) ? (__uint32_t )(((__uint32_t)(kr->nexthop.s_addr) & 0xff) << 24 \| ((__uint32_t)(kr->nexthop.s_addr) & 0xff00) << 8 \| ((__uint32_t)(kr->nexthop.s_addr) & 0xff0000) >> 8 \| ((__uint32_t)(kr->nexthop.s_addr) & 0xff000000) >> 24) : __swap32md(kr->nexthop.s_addr)) > ntohl(nhaddr)(__uint32_t)(__builtin_constant_p(nhaddr) ? (__uint32_t)(((__uint32_t )(nhaddr) & 0xff) << 24 \| ((__uint32_t)(nhaddr) & 0xff00) << 8 \| ((__uint32_t)(nhaddr) & 0xff0000) >> 8 \| ((__uint32_t)(nhaddr) & 0xff000000) >> 24) : __swap32md (*nhaddr))) {
2986	kr = kroute_getaddr(*addr, prefixlen, prio, 1);
2987	if (req == AGENTX_REQUEST_TYPE_GET \|\|
2988	kr == NULL((void *)0)) {
2989	agentx_varbind_notfound(vb);
2990	return;
2991	}
2992	}
2993
2994	}
2995	}
2996	done:
2997	agentx_varbind_set_index_integer(vb, inetCidrRouteDestTypeIdx,
2998	INETADDRESSTYPE_IPV41);
2999	agentx_varbind_set_index_nstring(vb, inetCidrRouteDestIdx,
3000	(unsigned char *)&kr->prefix.s_addr, 4);
3001	agentx_varbind_set_index_integer(vb, inetCidrRoutePfxLenIdx,
3002	kr->prefixlen);
3003	agentx_varbind_set_index_oid(vb, inetCidrRoutePolicyIdx,
3004	AGENTX_OID(0, kr->priority)(uint32_t []) { 0, kr->priority }, (sizeof((uint32_t []) { 0, kr->priority }) / sizeof(uint32_t)));
3005	agentx_varbind_set_index_integer(vb, inetCidrRouteNextHopTypeIdx,
3006	INETADDRESSTYPE_IPV41);
3007	agentx_varbind_set_index_nstring(vb, inetCidrRouteNextHopIdx,
3008	(unsigned char *)&kr->nexthop.s_addr, 4);
3009
3010	if (obj == inetCidrRouteIfIndex)
3011	agentx_varbind_integer(vb, kr->if_index);
3012	else if (obj == inetCidrRouteType) {
3013	if (kr->flags & F_REJECT0x0008)
3014	type = 2;
3015	else if (kr->flags & F_BLACKHOLE0x0004)
3016	type = 5;
3017	else if (kr->flags & F_CONNECTED0x0001)
3018	type = 3;
3019	else
3020	type = 4;
3021	agentx_varbind_integer(vb, type);
3022	} else if (obj == inetCidrRouteProto) {
3023	switch (kr->priority) {
3024	case RTP_CONNECTED4:
3025	proto = 2;
3026	break;
3027	case RTP_STATIC8:
3028	proto = 3;
3029	break;
3030	case RTP_OSPF32:
3031	proto = 13;
3032	break;
3033	case RTP_ISIS36:
3034	proto = 9;
3035	break;
3036	case RTP_RIP40:
3037	proto = 8;
3038	break;
3039	case RTP_BGP48:
3040	proto = 14;
3041	break;
3042	default:
3043	if (kr->flags & F_DYNAMIC0x0010)
3044	proto = 4;
3045	else
3046	proto = 1; /* not specified */
3047	break;
3048	}
3049	agentx_varbind_integer(vb, proto);
3050	} else if (obj == inetCidrRouteAge)
3051	agentx_varbind_gauge32(vb, 0);
3052	else if (obj == inetCidrRouteNextHopAS)
3053	agentx_varbind_unsigned32(vb, 0); /* unknown */
3054	else if (obj == inetCidrRouteMetric1)
3055	agentx_varbind_integer(vb, -1);
3056	else if (obj == inetCidrRouteMetric2)
3057	agentx_varbind_integer(vb, -1);
3058	else if (obj == inetCidrRouteMetric3)
3059	agentx_varbind_integer(vb, -1);
3060	else if (obj == inetCidrRouteMetric4)
3061	agentx_varbind_integer(vb, -1);
3062	else if (obj == inetCidrRouteMetric5)
3063	agentx_varbind_integer(vb, -1);
3064	else if (obj == inetCidrRouteStatus)
3065	agentx_varbind_integer(vb, 1); /* XXX */
3066	else
3067	fatal("%s: Unexpected object", __func__);
3068	}
3069
3070	/*
3071	* Defined in UCD-DISKIO-MIB.txt.
3072	*/
3073
3074	void mib_diskio(struct agentx_varbind *vb);
3075
3076	void
3077	mib_diskio(struct agentx_varbind *vb)
3078	{
3079	struct agentx_object *obj;
3080	enum agentx_request_type req;
3081	u_int32_t idx;
3082	int mib[] = { CTL_HW6, 0 };
3083	unsigned int diskcount;
3084	struct diskstats *stats;
3085	size_t len;
3086
3087	len = sizeof(diskcount);
3088	mib[1] = HW_DISKCOUNT10;
3089	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), &diskcount, &len, NULL((void *)0), 0) == -1) {
3090	log_warn("sysctl");
3091	agentx_varbind_error(vb);
3092	return;
3093	}
3094
3095	obj = agentx_varbind_get_object(vb);
3096	req = agentx_varbind_request(vb);
3097	idx = agentx_varbind_get_index_integer(vb, diskIOIdx);
3098
3099	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
3100	if (idx == INT32_MAX0x7fffffff) {
3101	agentx_varbind_notfound(vb);
3102	return;
3103	}
3104	idx++;
3105	}
3106	if(idx < 1) {
3107	if (req == AGENTX_REQUEST_TYPE_GET) {
3108	agentx_varbind_notfound(vb);
3109	return;
3110	}
3111	idx = 1;
3112	} else if (idx > diskcount) {
3113	agentx_varbind_notfound(vb);
3114	return;
3115	}
3116	agentx_varbind_set_index_integer(vb, diskIOIdx, idx);
3117
3118	stats = calloc(diskcount, sizeof(*stats));
3119	if (stats == NULL((void *)0)) {
3120	log_warn("malloc");
3121	agentx_varbind_error(vb);
3122	return;
3123	}
3124	/* We know len won't overflow, otherwise calloc() would have failed. */
3125	len = diskcount * sizeof(*stats);
3126	mib[1] = HW_DISKSTATS9;
3127	if (sysctl(mib, nitems(mib)(sizeof((mib)) / sizeof((mib)[0])), stats, &len, NULL((void *)0), 0) == -1) {
3128	log_warn("sysctl");
3129	free(stats);
3130	agentx_varbind_error(vb);
3131	return;
3132	}
3133
3134	if (obj == diskIOIndex)
3135	agentx_varbind_integer(vb, idx);
3136	else if (obj == diskIODevice)
3137	agentx_varbind_string(vb, stats[idx - 1].ds_name);
3138	else if (obj == diskIONRead)
3139	agentx_varbind_counter32(vb,
3140	(u_int32_t)stats[idx - 1].ds_rbytes);
3141	else if (obj == diskIONWritten)
3142	agentx_varbind_counter32(vb,
3143	(u_int32_t)stats[idx - 1].ds_wbytes);
3144	else if (obj == diskIOReads)
3145	agentx_varbind_counter32(vb,
3146	(u_int32_t)stats[idx - 1].ds_rxfer);
3147	else if (obj == diskIOWrites)
3148	agentx_varbind_counter32(vb,
3149	(u_int32_t)stats[idx - 1].ds_wxfer);
3150	else if (obj == diskIONReadX)
3151	agentx_varbind_counter64(vb, stats[idx - 1].ds_rbytes);
3152	else if (obj == diskIONWrittenX)
3153	agentx_varbind_counter64(vb, stats[idx - 1].ds_wbytes);
3154	else
3155	fatal("%s: Unexpected object", __func__);
3156	free(stats);
3157	}
3158
3159	/*
3160	* Defined in BRIDGE-MIB.txt (rfc1493)
3161	*
3162	* This MIB is required by some NMS to accept the device because
3163	* the RFC says that mostly any network device has to provide this MIB... :(
3164	*/
3165
3166	void mib_dot1basetype(struct agentx_varbind *);
3167	void mib_dot1dtable(struct agentx_varbind *);
3168
3169	void
3170	mib_dot1basetype(struct agentx_varbind *vb)
3171	{
3172	/* srt (sourceroute + transparent) */
3173	agentx_varbind_integer(vb, 4);
3174	}
3175
3176	void
3177	mib_dot1dtable(struct agentx_varbind *vb)
3178	{
3179	struct agentx_object *obj;
3180	enum agentx_request_type req;
3181	u_int32_t idx = 0;
3182	struct kif *kif;
3183
3184	obj = agentx_varbind_get_object(vb);
3185	req = agentx_varbind_request(vb);
3186	idx = agentx_varbind_get_index_integer(vb, dot1dBasePortIdx);
3187
3188	if (req == AGENTX_REQUEST_TYPE_GETNEXT) {
3189	if (idx == INT32_MAX0x7fffffff) {
3190	agentx_varbind_notfound(vb);
3191	return;
3192	}
3193	idx++;
3194	}
3195	if ((kif = mib_ifget(idx)) == NULL((void *)0)) {
3196	agentx_varbind_notfound(vb);
3197	return;
3198	}
3199	if (req == AGENTX_REQUEST_TYPE_GET) {
3200	if (idx != kif->if_index) {
3201	agentx_varbind_notfound(vb);
3202	return;
3203	}
3204	}
3205	agentx_varbind_set_index_integer(vb, dot1dBasePortIdx, kif->if_index);
3206
3207	if (obj == dot1dBasePort)
3208	agentx_varbind_integer(vb, kif->if_index);
3209	else if (obj == dot1dBasePortIfIndex)
3210	agentx_varbind_integer(vb, kif->if_index);
3211	else if (obj == dot1dBasePortCircuit)
3212	agentx_varbind_oid(vb, AGENTX_OID(0, 0)(uint32_t []) { 0, 0 }, (sizeof((uint32_t []) { 0, 0 }) / sizeof (uint32_t)));
3213	else if (obj == dot1dBasePortDelayExceededDiscards)
3214	agentx_varbind_counter32(vb, 0);
3215	else if (obj == dot1dBasePortMtuExceededDiscards)
3216	agentx_varbind_counter32(vb, 0);
3217	else
3218	fatal("%s: Unexpected object", __func__);
3219	}
3220
3221	/*
3222	* Import all MIBs
3223	*/
3224
3225	int
3226	main(int argc, char *argv[])
3227	{
3228	static struct snmpd conf;
3229	struct agentx *sa;
3230	struct agentx_session *sas;
3231	struct agentx_index *indices[6];
3232	struct passwd *pw;
3233	struct group *gr;
3234	char agentxsocketdir[PATH_MAX1024];
3235	int ch;
3236	int verbose = 0, daemonize = 1, debug = 0;
3237	char context = NULL((void )0);
3238	const char *errstr;
3239	/* HOST-RESOURCES-MIB */
3240	struct agentx_region *host;
3241	struct agentx_object hrSystemUptime, hrSystemDate, *hrMemorySize;
3242	/* IF-MIB */
3243	struct agentx_region ifMIB, interfaces;
3244	/* OPENBSD-PF-MIB */
3245	struct agentx_region *pfMIBObjects;
3246	/* OPENBSD-SENSOR-MIB */
3247	struct agentx_region *sensorsMIBObjects;
3248	/* OPENBSD-CARP-MIB */
3249	struct agentx_region *carpMIBObjects;
3250	/* OPENBSD-MEM-MIB */
3251	struct agentx_region *memMIBObjects;
3252	/* IP-MIB */
3253	struct agentx_region *ip;
3254	/* IP-FORWARD-MIB */
3255	struct agentx_region *ipForward;
3256	/* UCD-DISKIO-MIB */
3257	struct agentx_region *ucdDiskIOMIB;
3258	/* BRIDGE-MIB */
3259	struct agentx_region *dot1dBridge;
3260
3261	snmpd_env = &conf;
3262	log_init(2, LOG_DAEMON(3<<3));
3263
3264	agentx_log_fatal = fatalx;
3265	agentx_log_warn = log_warnx;
3266	agentx_log_info = log_info;
3267	agentx_log_debug = log_debug;
3268
3269	while ((ch = getopt(argc, argv, "C:c:ds:vx:")) != -1) {
3270	switch (ch) {
3271	case 'C':
3272	if (strcmp(optarg, "filter-routes") == 0) {
3273	conf.sc_rtfilter = ROUTE_FILTER(RTM_NEWADDR)(1 << (0xc)) \|
3274	ROUTE_FILTER(RTM_DELADDR)(1 << (0xd)) \|
3275	ROUTE_FILTER(RTM_IFINFO)(1 << (0xe)) \|
3276	ROUTE_FILTER(RTM_IFANNOUNCE)(1 << (0xf));
3277
3278	}
3279	break;
3280	case 'c':
3281	context = optarg;
3282	break;
3283	case 'd':
3284	daemonize = 0;
3285	debug = 1;
3286	break;
3287	case 's':
3288	if (optarg[0] != '/')
3289	fatalx("agentx socket path must be absolute");
3290	agentxsocket = optarg;
3291	break;
3292	case 'v':
3293	verbose++;
3294	break;
3295	case 'x':
3296	/* Undocumented flag for snmpd(8) spawning */
3297	agentxfd = strtonum(optarg, 0, INT_MAX0x7fffffff, &errstr);
3298	if (errstr != NULL((void *)0))
3299	fatalx("invalid agentx fd: %s", errstr);
3300	daemonize = 0;
3301	break;
3302	default:
3303	fatalx("usage: snmpd_metrics [-dv] [-C option] "
3304	"[-c context] [-s master]\n");
3305	}
3306	}
3307
3308	if (agentxfd != -1 && !debug)
3309	/* Initialize syslog logging asap for snmpd */
3310	log_init(0, LOG_DAEMON(3<<3));
3311
3312	if ((pw = getpwnam("_snmpd")) == NULL((void *)0))
3313	fatal("can't find _snmpd user");
3314	if ((gr = getgrnam("_agentx")) == NULL((void *)0))
3315	fatal("can't find _agentx group");
3316
3317	if (agentxfd != -1 && agentxsocket != NULL((void *)0))
3318	fatalx("-s and -x are mutually exclusive");
3319	if (agentxfd == -1 && agentxsocket == NULL((void *)0))
3320	agentxsocket = AGENTX_MASTER_PATH"/var/agentx/master";
3321
3322	event_init();
3323
3324	if ((sa = agentx(snmp_connect, NULL((void )0))) == NULL((void )0))
3325	fatal("agentx");
3326	if ((sas = agentx_session(sa, NULL((void )0), 0, "OpenSNMPd metrics", 0)) == NULL((void )0))
3327	fatal("agentx_session");
3328	if ((sac = agentx_context(sas, context)) == NULL((void *)0))
3329	fatal("agentx_context");
3330
3331	/* kr_init requires sac */
3332	kr_init();
3333	pf_init();
3334	timer_init();
3335	pageshift_init();
3336
3337	if (agentxsocket != NULL((void *)0)) {
3338	if (strlcpy(agentxsocketdir, agentxsocket,
3339	sizeof(agentxsocketdir)) >= sizeof(agentxsocketdir)) {
3340	errno(*__errno()) = ENAMETOOLONG63;
3341	fatal("-s");
3342	}
3343	if (unveil(dirname(agentxsocketdir), "r") == -1)
3344	fatal("unveil");
3345	}
3346
3347	/* Can't pledge: kvm_getfiles */
3348	if (unveil(NULL((void )0), NULL((void )0)) == -1)
3349	fatal("unveil");
3350
3351	if (setgid(gr->gr_gid) == -1)
3352	fatal("setgid");
3353	if (setuid(pw->pw_uid) == -1)
3354	fatal("setuid");
3355
3356	/* HOST-RESOURCES-MIB */
3357	if ((host = agentx_region(sac, AGENTX_OID(HOST)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 25 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
3358	fatal("agentx_region");
3359
3360	if ((hrSystemUptime = agentx_object(host, AGENTX_OID(HRSYSTEMUPTIME)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 1 }) / sizeof(uint32_t)),
	Although the value stored to 'hrSystemUptime' is used in the enclosing expression, the value is never actually read from 'hrSystemUptime'
3361	NULL((void )0), 0, 0, mib_hrsystemuptime)) == NULL((void )0) \|\|
3362	(hrSystemDate = agentx_object(host, AGENTX_OID(HRSYSTEMDATE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 2 }) / sizeof(uint32_t)),
3363	NULL((void )0), 0, 0, mib_hrsystemdate)) == NULL((void )0) \|\|
3364	(hrSystemProcesses = agentx_object(host,
3365	AGENTX_OID(HRSYSTEMPROCESSES)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 6 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 6 }) / sizeof(uint32_t)), NULL((void *)0), 0, 0,
3366	mib_hrsystemprocs)) == NULL((void *)0) \|\|
3367	(hrSystemMaxProcesses = agentx_object(host,
3368	AGENTX_OID(HRSYSTEMMAXPROCESSES)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 7 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 1, 7 }) / sizeof(uint32_t)), NULL((void *)0), 0, 0,
3369	mib_hrsystemprocs)) == NULL((void *)0) \|\|
3370	(hrMemorySize = agentx_object(host, AGENTX_OID(HRMEMORYSIZE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 2 }) / sizeof(uint32_t)),
3371	NULL((void )0), 0, 0, mib_hrmemory)) == NULL((void )0))
3372	fatal("agentx_object");
3373
3374	if ((hrStorageIdx = agentx_index_integer_dynamic(host,
3375	AGENTX_OID(HRSTORAGEINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 1 }) / sizeof(uint32_t )))) == NULL((void *)0))
3376	fatal("agentx_index_integer_dynamic");
3377	if ((hrStorageIndex = agentx_object(host, AGENTX_OID(HRSTORAGEINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 1 }) / sizeof(uint32_t )),
3378	&hrStorageIdx, 1, 0, mib_hrstorage)) == NULL((void *)0) \|\|
3379	(hrStorageType = agentx_object(host, AGENTX_OID(HRSTORAGETYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 2 }) / sizeof(uint32_t )),
3380	&hrStorageIdx, 1, 0, mib_hrstorage)) == NULL((void *)0) \|\|
3381	(hrStorageDescr = agentx_object(host, AGENTX_OID(HRSTORAGEDESCR)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 3 }) / sizeof(uint32_t )),
3382	&hrStorageIdx, 1, 0, mib_hrstorage)) == NULL((void *)0) \|\|
3383	(hrStorageAllocationUnits = agentx_object(host,
3384	AGENTX_OID(HRSTORAGEALLOCATIONUNITS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 4 }) / sizeof(uint32_t )), &hrStorageIdx, 1, 0,
3385	mib_hrstorage)) == NULL((void *)0) \|\|
3386	(hrStorageSize = agentx_object(host, AGENTX_OID(HRSTORAGESIZE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 5 }) / sizeof(uint32_t )),
3387	&hrStorageIdx, 1, 0, mib_hrstorage)) == NULL((void *)0) \|\|
3388	(hrStorageUsed = agentx_object(host, AGENTX_OID(HRSTORAGEUSED)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 6 }) / sizeof(uint32_t )),
3389	&hrStorageIdx, 1, 0, mib_hrstorage)) == NULL((void *)0) \|\|
3390	(hrStorageAllocationFailures = agentx_object(host,
3391	AGENTX_OID(HRSTORAGEALLOCATIONFAILURES)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 2, 3, 1, 7 }) / sizeof(uint32_t )), &hrStorageIdx, 1, 0,
3392	mib_hrstorage)) == NULL((void *)0))
3393	fatal("agentx_object");
3394
3395	if ((hrDeviceIdx = agentx_index_integer_dynamic(host,
3396	AGENTX_OID(HRDEVICEINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 1 }) / sizeof(uint32_t )))) == NULL((void *)0))
3397	fatal("agentx_index_integer_dynamic");
3398	if ((hrDeviceIndex = agentx_object(host, AGENTX_OID(HRDEVICEINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 1 }) / sizeof(uint32_t )),
3399	&hrDeviceIdx, 1, 0, mib_hrdevice)) == NULL((void *)0) \|\|
3400	(hrDeviceType = agentx_object(host, AGENTX_OID(HRDEVICETYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 2 }) / sizeof(uint32_t )),
3401	&hrDeviceIdx, 1, 0, mib_hrdevice)) == NULL((void *)0) \|\|
3402	(hrDeviceDescr = agentx_object(host, AGENTX_OID(HRDEVICEDESCR)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 3 }) / sizeof(uint32_t )),
3403	&hrDeviceIdx, 1, 0, mib_hrdevice)) == NULL((void *)0) \|\|
3404	(hrDeviceID = agentx_object(host, AGENTX_OID(HRDEVICEID)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 4 }) / sizeof(uint32_t )),
3405	&hrDeviceIdx, 1, 0, mib_hrdevice)) == NULL((void *)0) \|\|
3406	(hrDeviceStatus = agentx_object(host, AGENTX_OID(HRDEVICESTATUS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 5 }) / sizeof(uint32_t )),
3407	&hrDeviceIdx, 1, 0, mib_hrdevice)) == NULL((void *)0) \|\|
3408	(hrDeviceErrors = agentx_object(host, AGENTX_OID(HRDEVICEERRORS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 2, 1, 6 }) / sizeof(uint32_t )),
3409	&hrDeviceIdx, 1, 0, mib_hrdevice)) == NULL((void *)0))
3410	fatal("agentx_object");
3411	if ((hrProcessorFrwID = agentx_object(host, AGENTX_OID(HRPROCESSORFRWID)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 3, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 3, 1, 1 }) / sizeof(uint32_t )),
3412	&hrDeviceIdx, 1, 0, mib_hrprocessor)) == NULL((void *)0) \|\|
3413	(hrProcessorLoad = agentx_object(host, AGENTX_OID(HRPROCESSORLOAD)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 3, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 3, 3, 1, 2 }) / sizeof(uint32_t )),
3414	&hrDeviceIdx, 1, 0, mib_hrprocessor)) == NULL((void *)0))
3415	fatal("agentx_object");
3416	if ((hrSWRunIdx = agentx_index_integer_dynamic(host,
3417	AGENTX_OID(HRSWRUNINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 1 }) / sizeof(uint32_t )))) == NULL((void *)0))
3418	fatal("agentx_index_integer_dynamic");
3419	if ((hrSWRunIndex = agentx_object(host, AGENTX_OID(HRSWRUNINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 1 }) / sizeof(uint32_t )),
3420	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0) \|\|
3421	(hrSWRunName = agentx_object(host, AGENTX_OID(HRSWRUNNAME)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 2 }) / sizeof(uint32_t )),
3422	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0) \|\|
3423	(hrSWRunID = agentx_object(host, AGENTX_OID(HRSWRUNID)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 3 }) / sizeof(uint32_t )),
3424	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0) \|\|
3425	(hrSWRunPath = agentx_object(host, AGENTX_OID(HRSWRUNPATH)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 4 }) / sizeof(uint32_t )),
3426	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0) \|\|
3427	(hrSWRunParameters = agentx_object(host,
3428	AGENTX_OID(HRSWRUNPARAMETERS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 5 }) / sizeof(uint32_t )), &hrSWRunIdx, 1, 0,
3429	mib_hrswrun)) == NULL((void *)0) \|\|
3430	(hrSWRunType = agentx_object(host, AGENTX_OID(HRSWRUNTYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 6 }) / sizeof(uint32_t )),
3431	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0) \|\|
3432	(hrSWRunStatus = agentx_object(host, AGENTX_OID(HRSWRUNSTATUS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 4, 2, 1, 7 }) / sizeof(uint32_t )),
3433	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0) \|\|
3434	(hrSWRunPerfCPU = agentx_object(host, AGENTX_OID(HRSWRUNPERFCPU)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 5, 1, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 5, 1, 1, 1 }) / sizeof(uint32_t )),
3435	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0) \|\|
3436	(hrSWRunPerfMem = agentx_object(host, AGENTX_OID(HRSWRUNPERFMEM)(uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 5, 1, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 25, 5, 1, 1, 2 }) / sizeof(uint32_t )),
3437	&hrSWRunIdx, 1, 0, mib_hrswrun)) == NULL((void *)0))
3438	fatal("agentx_object");
3439
3440	/* IF-MIB */
3441	if ((ifMIB = agentx_region(sac, AGENTX_OID(IFMIB)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 31 }) / sizeof(uint32_t)), 0)) == NULL((void *)0) \|\|
3442	(interfaces = agentx_region(sac,
3443	AGENTX_OID(INTERFACES)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
3444	fatal("agentx_region");
3445
3446	if ((ifIdx = agentx_index_integer_dynamic(interfaces,
3447	AGENTX_OID(IFINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 1 }) / sizeof(uint32_t)))) == NULL((void *)0))
3448	fatal("agentx_index_integer_dynamic");
3449	if ((ifName = agentx_object(ifMIB, AGENTX_OID(IFNAME)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 1 }) / sizeof(uint32_t )),
3450	&ifIdx, 1, 0, mib_ifxtable)) == NULL((void *)0) \|\|
3451	(ifInMulticastPkts = agentx_object(ifMIB,
3452	AGENTX_OID(IFINMULTICASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 2 }) / sizeof(uint32_t )), &ifIdx, 1, 0,
3453	mib_ifxtable)) == NULL((void *)0) \|\|
3454	(ifInBroadcastPkts = agentx_object(ifMIB,
3455	AGENTX_OID(IFINBROADCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 3 }) / sizeof(uint32_t )), &ifIdx, 1, 0,
3456	mib_ifxtable)) == NULL((void *)0) \|\|
3457	(ifOutMulticastPkts = agentx_object(ifMIB,
3458	AGENTX_OID(IFOUTMULTICASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 4 }) / sizeof(uint32_t )), &ifIdx, 1, 0,
3459	mib_ifxtable)) == NULL((void *)0) \|\|
3460	(ifOutBroadcastPkts = agentx_object(ifMIB,
3461	AGENTX_OID(IFOUTBROADCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 5 }) / sizeof(uint32_t )), &ifIdx, 1, 0,
3462	mib_ifxtable)) == NULL((void *)0) \|\|
3463	(ifHCInOctets = agentx_object(ifMIB, AGENTX_OID(IFHCINOCTETS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 6 }) / sizeof(uint32_t )),
3464	&ifIdx, 1, 0, mib_ifxtable)) == NULL((void *)0) \|\|
3465	(ifHCInUcastPkts = agentx_object(ifMIB, AGENTX_OID(IFHCINUCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 7 }) / sizeof(uint32_t )),
3466	&ifIdx, 1, 0, mib_ifxtable)) == NULL((void *)0) \|\|
3467	(ifHCInMulticastPkts = agentx_object(ifMIB,
3468	AGENTX_OID(IFHCINMULTICASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 8 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 8 }) / sizeof(uint32_t )), &ifIdx, 1, 0,
3469	mib_ifxtable)) == NULL((void *)0) \|\|
3470	(ifHCInBroadcastPkts = agentx_object(ifMIB,
3471	AGENTX_OID(IFHCINBROADCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 9 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 9 }) / sizeof(uint32_t )), &ifIdx, 1, 0,
3472	mib_ifxtable)) == NULL((void *)0) \|\|
3473	(ifHCOutOctets = agentx_object(ifMIB, AGENTX_OID(IFHCOUTOCTETS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 10 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 10 }) / sizeof (uint32_t)),
3474	&ifIdx, 1, 0, mib_ifxtable)) == NULL((void *)0) \|\|
3475	(ifHCOutUcastPkts = agentx_object(ifMIB,
3476	AGENTX_OID(IFHCOUTUCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 11 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 11 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
3477	mib_ifxtable)) == NULL((void *)0) \|\|
3478	(ifHCOutMulticastPkts = agentx_object(ifMIB,
3479	AGENTX_OID(IFHCOUTMULTICASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 12 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 12 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
3480	mib_ifxtable)) == NULL((void *)0) \|\|
3481	(ifHCOutBroadcastPkts = agentx_object(ifMIB,
3482	AGENTX_OID(IFHCOUTBROADCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 13 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 13 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
3483	mib_ifxtable)) == NULL((void *)0) \|\|
3484	(ifLinkUpDownTrapEnable = agentx_object(ifMIB,
3485	AGENTX_OID(IFLINKUPDOWNTRAPENABLE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 14 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 14 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
3486	mib_ifxtable)) == NULL((void *)0) \|\|
3487	(ifHighSpeed = agentx_object(ifMIB, AGENTX_OID(IFHIGHSPEED)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 15 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 15 }) / sizeof (uint32_t)),
3488	&ifIdx, 1, 0, mib_ifxtable)) == NULL((void *)0) \|\|
3489	(ifPromiscuousMode = agentx_object(ifMIB,
3490	AGENTX_OID(IFPROMISCUOUSMODE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 16 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 16 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
3491	mib_ifxtable)) == NULL((void *)0) \|\|
3492	(ifConnectorPresent = agentx_object(ifMIB,
3493	AGENTX_OID(IFCONNECTORPRESENT)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 17 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 17 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
3494	mib_ifxtable)) == NULL((void *)0) \|\|
3495	(ifAlias = agentx_object(ifMIB, AGENTX_OID(IFALIAS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 18 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 18 }) / sizeof (uint32_t)),
3496	&ifIdx, 1, 0, mib_ifxtable)) == NULL((void *)0) \|\|
3497	(ifCounterDiscontinuityTime = agentx_object(ifMIB,
3498	AGENTX_OID(IFCOUNTERDISCONTINUITYTIME)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 19 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 1, 1, 19 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
3499	mib_ifxtable)) == NULL((void *)0))
3500	fatal("agentx_object");
3501
3502	if ((ifRcvAddressAddress = agentx_index_string_dynamic(ifMIB,
3503	AGENTX_OID(IFRCVADDRESSADDRESS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 4, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 4, 1, 1 }) / sizeof(uint32_t )))) == NULL((void *)0))
3504	fatal("agentx_index_string_dynamic");
3505	indices[0] = ifIdx;
3506	indices[1] = ifRcvAddressAddress;
3507	if ((ifRcvAddressStatus = agentx_object(ifMIB,
3508	AGENTX_OID(IFRCVADDRESSSTATUS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 4, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 4, 1, 2 }) / sizeof(uint32_t )), indices, 2, 0,
3509	mib_ifrcvtable)) == NULL((void *)0) \|\|
3510	(ifRcvAddressType = agentx_object(ifMIB,
3511	AGENTX_OID(IFRCVADDRESSTYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 4, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 4, 1, 3 }) / sizeof(uint32_t )), indices, 2, 0,
3512	mib_ifrcvtable)) == NULL((void *)0))
3513	fatal("agentx_object");
3514
3515	if ((ifStackLastChange = agentx_object(ifMIB,
3516	AGENTX_OID(IFSTACKLASTCHANGE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 6 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 31, 1, 6 }) / sizeof(uint32_t)), NULL((void *)0), 0, 0,
3517	mib_ifstacklast)) == NULL((void *)0))
3518	fatal("agentx_object");
3519
3520	if ((ifNumber = agentx_object(interfaces, AGENTX_OID(IFNUMBER)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 1 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 2, 1 }) / sizeof(uint32_t)),
3521	NULL((void )0), 0, 0, mib_ifnumber)) == NULL((void )0))
3522	fatal("agentx_object");
3523
3524	if ((ifIndex = agentx_object(interfaces, AGENTX_OID(IFINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 1 }) / sizeof(uint32_t)),
3525	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3526	(ifDescr = agentx_object(interfaces, AGENTX_OID(IFDESCR)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 2 }) / sizeof(uint32_t)),
3527	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3528	(ifType = agentx_object(interfaces, AGENTX_OID(IFTYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 3 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 3 }) / sizeof(uint32_t)),
3529	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3530	(ifMtu = agentx_object(interfaces, AGENTX_OID(IFMTU)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 4 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 4 }) / sizeof(uint32_t)),
3531	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3532	(ifSpeed = agentx_object(interfaces, AGENTX_OID(IFSPEED)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 5 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 5 }) / sizeof(uint32_t)),
3533	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3534	(ifPhysAddress = agentx_object(interfaces,
3535	AGENTX_OID(IFPHYSADDRESS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 6 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 6 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3536	(ifAdminStatus = agentx_object(interfaces,
3537	AGENTX_OID(IFADMINSTATUS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 7 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 7 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3538	(ifOperStatus = agentx_object(interfaces,
3539	AGENTX_OID(IFOPERSTATUS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 8 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 8 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3540	(ifLastChange = agentx_object(interfaces,
3541	AGENTX_OID(IFLASTCHANGE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 9 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 9 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3542	(ifInOctets = agentx_object(interfaces, AGENTX_OID(IFINOCTETS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 10 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 10 }) / sizeof(uint32_t)),
3543	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3544	(ifInUcastPkts = agentx_object(interfaces,
3545	AGENTX_OID(IFINUCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 11 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 11 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3546	(ifInNUcastPkts = agentx_object(interfaces,
3547	AGENTX_OID(IFINNUCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 12 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 12 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3548	(ifInDiscards = agentx_object(interfaces,
3549	AGENTX_OID(IFINDISCARDS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 13 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 13 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3550	(ifInErrors = agentx_object(interfaces, AGENTX_OID(IFINERRORS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 14 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 14 }) / sizeof(uint32_t)),
3551	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3552	(ifInUnknownProtos = agentx_object(interfaces,
3553	AGENTX_OID(IFINUNKNOWNPROTOS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 15 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 15 }) / sizeof(uint32_t)), &ifIdx, 1, 0,
3554	mib_iftable)) == NULL((void *)0) \|\|
3555	(ifOutOctets = agentx_object(interfaces, AGENTX_OID(IFOUTOCTETS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 16 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 16 }) / sizeof(uint32_t)),
3556	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3557	(ifOutUcastPkts = agentx_object(interfaces,
3558	AGENTX_OID(IFOUTUCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 17 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 17 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3559	(ifOutNUcastPkts = agentx_object(interfaces,
3560	AGENTX_OID(IFOUTNUCASTPKTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 18 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 18 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3561	(ifOutDiscards = agentx_object(interfaces,
3562	AGENTX_OID(IFOUTDISCARDS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 19 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 19 }) / sizeof(uint32_t)), &ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3563	(ifOutErrors = agentx_object(interfaces, AGENTX_OID(IFOUTERRORS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 20 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 20 }) / sizeof(uint32_t)),
3564	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3565	(ifOutQLen = agentx_object(interfaces, AGENTX_OID(IFOUTQLEN)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 21 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 21 }) / sizeof(uint32_t)),
3566	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0) \|\|
3567	(ifSpecific = agentx_object(interfaces, AGENTX_OID(IFSPECIFIC)(uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 22 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 2, 2, 1, 22 }) / sizeof(uint32_t)),
3568	&ifIdx, 1, 0, mib_iftable)) == NULL((void *)0))
3569	fatal("agentx_object");
3570
3571	/* OPENBSD-PF-MIB */
3572	if ((pfMIBObjects = agentx_region(sac,
3573	AGENTX_OID(PFMIBOBJECTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
3574	fatal("agentx_region");
3575	if ((pfRunning = agentx_object(pfMIBObjects, AGENTX_OID(PFRUNNING)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 1 }) / sizeof(uint32_t )),
3576	NULL((void )0), 0, 0, mib_pfinfo)) == NULL((void )0) \|\|
3577	(pfRuntime = agentx_object(pfMIBObjects, AGENTX_OID(PFRUNTIME)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 2 }) / sizeof(uint32_t )),
3578	NULL((void )0), 0, 0, mib_pfinfo)) == NULL((void )0) \|\|
3579	(pfDebug = agentx_object(pfMIBObjects, AGENTX_OID(PFDEBUG)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 3 }) / sizeof(uint32_t )),
3580	NULL((void )0), 0, 0, mib_pfinfo)) == NULL((void )0) \|\|
3581	(pfHostid = agentx_object(pfMIBObjects, AGENTX_OID(PFHOSTID)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 1, 4 }) / sizeof(uint32_t )),
3582	NULL((void )0), 0, 0, mib_pfinfo)) == NULL((void )0))
3583	fatal("agentx_object");
3584
3585	if ((pfCntMatch = agentx_object(pfMIBObjects, AGENTX_OID(PFCNTMATCH)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 1 }) / sizeof(uint32_t )),
3586	NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3587	(pfCntBadOffset = agentx_object(pfMIBObjects,
3588	AGENTX_OID(PFCNTBADOFFSET)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 2 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3589	(pfCntFragment = agentx_object(pfMIBObjects,
3590	AGENTX_OID(PFCNTFRAGMENT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 3 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3591	(pfCntShort = agentx_object(pfMIBObjects, AGENTX_OID(PFCNTSHORT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 4 }) / sizeof(uint32_t )),
3592	NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3593	(pfCntNormalize = agentx_object(pfMIBObjects,
3594	AGENTX_OID(PFCNTNORMALIZE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 5 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3595	(pfCntMemory = agentx_object(pfMIBObjects, AGENTX_OID(PFCNTMEMORY)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 6 }) / sizeof(uint32_t )),
3596	NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3597	(pfCntTimestamp = agentx_object(pfMIBObjects,
3598	AGENTX_OID(PFCNTTIMESTAMP)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 7 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3599	(pfCntCongestion = agentx_object(pfMIBObjects,
3600	AGENTX_OID(PFCNTCONGESTION)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 8 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 8 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3601	(pfCntIpOption = agentx_object(pfMIBObjects,
3602	AGENTX_OID(PFCNTIPOPTION)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 9 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 9 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3603	(pfCntProtoCksum = agentx_object(pfMIBObjects,
3604	AGENTX_OID(PFCNTPROTOCKSUM)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 10 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 10 }) / sizeof (uint32_t)), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3605	(pfCntStateMismatch = agentx_object(pfMIBObjects,
3606	AGENTX_OID(PFCNTSTATEMISMATCH)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 11 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 11 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3607	mib_pfcounters)) == NULL((void *)0) \|\|
3608	(pfCntStateInsert = agentx_object(pfMIBObjects,
3609	AGENTX_OID(PFCNTSTATEINSERT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 12 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 12 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3610	mib_pfcounters)) == NULL((void *)0) \|\|
3611	(pfCntStateLimit = agentx_object(pfMIBObjects,
3612	AGENTX_OID(PFCNTSTATELIMIT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 13 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 13 }) / sizeof (uint32_t)), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3613	(pfCntSrcLimit = agentx_object(pfMIBObjects,
3614	AGENTX_OID(PFCNTSRCLIMIT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 14 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 14 }) / sizeof (uint32_t)), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3615	(pfCntSynproxy = agentx_object(pfMIBObjects,
3616	AGENTX_OID(PFCNTSYNPROXY)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 15 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 15 }) / sizeof (uint32_t)), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3617	(pfCntTranslate = agentx_object(pfMIBObjects,
3618	AGENTX_OID(PFCNTTRANSLATE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 16 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 16 }) / sizeof (uint32_t)), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0) \|\|
3619	(pfCntNoRoute = agentx_object(pfMIBObjects,
3620	AGENTX_OID(PFCNTNOROUTE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 17 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 2, 17 }) / sizeof (uint32_t)), NULL((void )0), 0, 0, mib_pfcounters)) == NULL((void )0))
3621	fatal("agentx_object");
3622
3623	if ((pfStateCount = agentx_object(pfMIBObjects,
3624	AGENTX_OID(PFSTATECOUNT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 1 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfscounters)) == NULL((void )0) \|\|
3625	(pfStateSearches = agentx_object(pfMIBObjects,
3626	AGENTX_OID(PFSTATESEARCHES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 2 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3627	mib_pfscounters)) == NULL((void *)0) \|\|
3628	(pfStateInserts = agentx_object(pfMIBObjects,
3629	AGENTX_OID(PFSTATEINSERTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 3 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfscounters)) == NULL((void )0) \|\|
3630	(pfStateRemovals = agentx_object(pfMIBObjects,
3631	AGENTX_OID(PFSTATEREMOVALS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 3, 4 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfscounters)) == NULL((void )0))
3632	fatal("agentx_object");
3633
3634	if ((pfLogIfName = agentx_object(pfMIBObjects, AGENTX_OID(PFLOGIFNAME)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 1 }) / sizeof(uint32_t )),
3635	NULL((void )0), 0, 0, mib_pflogif)) == NULL((void )0) \|\|
3636	(pfLogIfIpBytesIn = agentx_object(pfMIBObjects,
3637	AGENTX_OID(PFLOGIFIPBYTESIN)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 2 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pflogif)) == NULL((void )0) \|\|
3638	(pfLogIfIpBytesOut = agentx_object(pfMIBObjects,
3639	AGENTX_OID(PFLOGIFIPBYTESOUT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 3 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pflogif)) == NULL((void )0) \|\|
3640	(pfLogIfIpPktsInPass = agentx_object(pfMIBObjects,
3641	AGENTX_OID(PFLOGIFIPPKTSINPASS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 4 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3642	mib_pflogif)) == NULL((void *)0) \|\|
3643	(pfLogIfIpPktsInDrop = agentx_object(pfMIBObjects,
3644	AGENTX_OID(PFLOGIFIPPKTSINDROP)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 5 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3645	mib_pflogif)) == NULL((void *)0) \|\|
3646	(pfLogIfIpPktsOutPass = agentx_object(pfMIBObjects,
3647	AGENTX_OID(PFLOGIFIPPKTSOUTPASS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 6 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3648	mib_pflogif)) == NULL((void *)0) \|\|
3649	(pfLogIfIpPktsOutDrop = agentx_object(pfMIBObjects,
3650	AGENTX_OID(PFLOGIFIPPKTSOUTDROP)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 7 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3651	mib_pflogif)) == NULL((void *)0) \|\|
3652	(pfLogIfIp6BytesIn = agentx_object(pfMIBObjects,
3653	AGENTX_OID(PFLOGIFIP6BYTESIN)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 8 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 8 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pflogif)) == NULL((void )0) \|\|
3654	(pfLogIfIp6BytesOut = agentx_object(pfMIBObjects,
3655	AGENTX_OID(PFLOGIFIP6BYTESOUT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 9 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 9 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pflogif)) == NULL((void )0) \|\|
3656	(pfLogIfIp6PktsInPass = agentx_object(pfMIBObjects,
3657	AGENTX_OID(PFLOGIFIP6PKTSINPASS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 10 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 10 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3658	mib_pflogif)) == NULL((void *)0) \|\|
3659	(pfLogIfIp6PktsInDrop = agentx_object(pfMIBObjects,
3660	AGENTX_OID(PFLOGIFIP6PKTSINDROP)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 11 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 11 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3661	mib_pflogif)) == NULL((void *)0) \|\|
3662	(pfLogIfIp6PktsOutPass = agentx_object(pfMIBObjects,
3663	AGENTX_OID(PFLOGIFIP6PKTSOUTPASS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 12 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 12 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3664	mib_pflogif)) == NULL((void *)0) \|\|
3665	(pfLogIfIp6PktsOutDrop = agentx_object(pfMIBObjects,
3666	AGENTX_OID(PFLOGIFIP6PKTSOUTDROP)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 13 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 4, 13 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3667	mib_pflogif)) == NULL((void *)0))
3668	fatal("agentx_object");
3669
3670	if ((pfSrcTrackCount = agentx_object(pfMIBObjects,
3671	AGENTX_OID(PFSRCTRACKCOUNT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 1 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pfsrctrack)) == NULL((void )0) \|\|
3672	(pfSrcTrackSearches = agentx_object(pfMIBObjects,
3673	AGENTX_OID(PFSRCTRACKSEARCHES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 2 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3674	mib_pfsrctrack)) == NULL((void *)0) \|\|
3675	(pfSrcTrackInserts = agentx_object(pfMIBObjects,
3676	AGENTX_OID(PFSRCTRACKINSERTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 3 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3677	mib_pfsrctrack)) == NULL((void *)0) \|\|
3678	(pfSrcTrackRemovals = agentx_object(pfMIBObjects,
3679	AGENTX_OID(PFSRCTRACKREMOVALS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 5, 4 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3680	mib_pfsrctrack)) == NULL((void *)0))
3681	fatal("agentx_object");
3682
3683	if ((pfLimitStates = agentx_object(pfMIBObjects,
3684	AGENTX_OID(PFLIMITSTATES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 1 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pflimits)) == NULL((void )0) \|\|
3685	(pfLimitSourceNodes = agentx_object(pfMIBObjects,
3686	AGENTX_OID(PFLIMITSOURCENODES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 2 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3687	mib_pflimits)) == NULL((void *)0) \|\|
3688	(pfLimitFragments = agentx_object(pfMIBObjects,
3689	AGENTX_OID(PFLIMITFRAGMENTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 3 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pflimits)) == NULL((void )0) \|\|
3690	(pfLimitMaxTables = agentx_object(pfMIBObjects,
3691	AGENTX_OID(PFLIMITMAXTABLES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 4 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_pflimits)) == NULL((void )0) \|\|
3692	(pfLimitMaxTableEntries = agentx_object(pfMIBObjects,
3693	AGENTX_OID(PFLIMITMAXTABLEENTRIES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 6, 5 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3694	mib_pflimits)) == NULL((void *)0))
3695	fatal("agentx_object");
3696
3697	if ((pfTimeoutTcpFirst = agentx_object(pfMIBObjects,
3698	AGENTX_OID(PFTIMEOUTTCPFIRST)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 1 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3699	mib_pftimeouts)) == NULL((void *)0) \|\|
3700	(pfTimeoutTcpOpening = agentx_object(pfMIBObjects,
3701	AGENTX_OID(PFTIMEOUTTCPOPENING)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 2 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3702	mib_pftimeouts)) == NULL((void *)0) \|\|
3703	(pfTimeoutTcpEstablished = agentx_object(pfMIBObjects,
3704	AGENTX_OID(PFTIMEOUTTCPESTABLISHED)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 3 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3705	mib_pftimeouts)) == NULL((void *)0) \|\|
3706	(pfTimeoutTcpClosing = agentx_object(pfMIBObjects,
3707	AGENTX_OID(PFTIMEOUTTCPCLOSING)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 4 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3708	mib_pftimeouts)) == NULL((void *)0) \|\|
3709	(pfTimeoutTcpFinWait = agentx_object(pfMIBObjects,
3710	AGENTX_OID(PFTIMEOUTTCPFINWAIT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 5 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3711	mib_pftimeouts)) == NULL((void *)0) \|\|
3712	(pfTimeoutTcpClosed = agentx_object(pfMIBObjects,
3713	AGENTX_OID(PFTIMEOUTTCPCLOSED)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 6 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3714	mib_pftimeouts)) == NULL((void *)0) \|\|
3715	(pfTimeoutUdpFirst = agentx_object(pfMIBObjects,
3716	AGENTX_OID(PFTIMEOUTUDPFIRST)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 7 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3717	mib_pftimeouts)) == NULL((void *)0) \|\|
3718	(pfTimeoutUdpSingle = agentx_object(pfMIBObjects,
3719	AGENTX_OID(PFTIMEOUTUDPSINGLE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 8 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 8 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3720	mib_pftimeouts)) == NULL((void *)0) \|\|
3721	(pfTimeoutUdpMultiple = agentx_object(pfMIBObjects,
3722	AGENTX_OID(PFTIMEOUTUDPMULTIPLE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 9 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 9 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
3723	mib_pftimeouts)) == NULL((void *)0) \|\|
3724	(pfTimeoutIcmpFirst = agentx_object(pfMIBObjects,
3725	AGENTX_OID(PFTIMEOUTICMPFIRST)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 10 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 10 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3726	mib_pftimeouts)) == NULL((void *)0) \|\|
3727	(pfTimeoutIcmpError = agentx_object(pfMIBObjects,
3728	AGENTX_OID(PFTIMEOUTICMPERROR)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 11 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 11 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3729	mib_pftimeouts)) == NULL((void *)0) \|\|
3730	(pfTimeoutOtherFirst = agentx_object(pfMIBObjects,
3731	AGENTX_OID(PFTIMEOUTOTHERFIRST)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 12 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 12 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3732	mib_pftimeouts)) == NULL((void *)0) \|\|
3733	(pfTimeoutOtherSingle = agentx_object(pfMIBObjects,
3734	AGENTX_OID(PFTIMEOUTOTHERSINGLE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 13 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 13 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3735	mib_pftimeouts)) == NULL((void *)0) \|\|
3736	(pfTimeoutOtherMultiple = agentx_object(pfMIBObjects,
3737	AGENTX_OID(PFTIMEOUTOTHERMULTIPLE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 14 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 14 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3738	mib_pftimeouts)) == NULL((void *)0) \|\|
3739	(pfTimeoutFragment = agentx_object(pfMIBObjects,
3740	AGENTX_OID(PFTIMEOUTFRAGMENT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 15 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 15 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3741	mib_pftimeouts)) == NULL((void *)0) \|\|
3742	(pfTimeoutInterval = agentx_object(pfMIBObjects,
3743	AGENTX_OID(PFTIMEOUTINTERVAL)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 16 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 16 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3744	mib_pftimeouts)) == NULL((void *)0) \|\|
3745	(pfTimeoutAdaptiveStart = agentx_object(pfMIBObjects,
3746	AGENTX_OID(PFTIMEOUTADAPTIVESTART)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 17 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 17 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3747	mib_pftimeouts)) == NULL((void *)0) \|\|
3748	(pfTimeoutAdaptiveEnd = agentx_object(pfMIBObjects,
3749	AGENTX_OID(PFTIMEOUTADAPTIVEEND)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 18 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 18 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3750	mib_pftimeouts)) == NULL((void *)0) \|\|
3751	(pfTimeoutSrcTrack = agentx_object(pfMIBObjects,
3752	AGENTX_OID(PFTIMEOUTSRCTRACK)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 19 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 7, 19 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3753	mib_pftimeouts)) == NULL((void *)0))
3754	fatal("agentx_object");
3755
3756	if ((pfIfNumber = agentx_object(pfMIBObjects, AGENTX_OID(PFIFNUMBER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 1 }) / sizeof(uint32_t )),
3757	NULL((void )0), 0, 0, mib_pfifnum)) == NULL((void )0))
3758	fatal("agentx_object");
3759	if ((pfIfIdx = agentx_index_integer_dynamic(pfMIBObjects,
3760	AGENTX_OID(PFIFINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 1 }) / sizeof(uint32_t)))) == NULL((void *)0))
3761	fatal("agentx_index_integer_dynamic");
3762	if ((pfIfIndex = agentx_object(pfMIBObjects, AGENTX_OID(PFIFINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 1 }) / sizeof(uint32_t)),
3763	&pfIfIdx, 1, 0, mib_pfiftable)) == NULL((void *)0) \|\|
3764	(pfIfDescr = agentx_object(pfMIBObjects, AGENTX_OID(PFIFDESCR)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 2 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 2 }) / sizeof(uint32_t)),
3765	&pfIfIdx, 1, 0, mib_pfiftable)) == NULL((void *)0) \|\|
3766	(pfIfType = agentx_object(pfMIBObjects, AGENTX_OID(PFIFTYPE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 3 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 3 }) / sizeof(uint32_t)),
3767	&pfIfIdx, 1, 0, mib_pfiftable)) == NULL((void *)0) \|\|
3768	(pfIfRefs = agentx_object(pfMIBObjects, AGENTX_OID(PFIFREFS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 4 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 4 }) / sizeof(uint32_t)),
3769	&pfIfIdx, 1, 0, mib_pfiftable)) == NULL((void *)0) \|\|
3770	(pfIfRules = agentx_object(pfMIBObjects, AGENTX_OID(PFIFRULES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 5 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 5 }) / sizeof(uint32_t)),
3771	&pfIfIdx, 1, 0, mib_pfiftable)) == NULL((void *)0) \|\|
3772	(pfIfIn4PassPkts = agentx_object(pfMIBObjects,
3773	AGENTX_OID(PFIFIN4PASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 6 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 6 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3774	mib_pfiftable)) == NULL((void *)0) \|\|
3775	(pfIfIn4PassBytes = agentx_object(pfMIBObjects,
3776	AGENTX_OID(PFIFIN4PASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 7 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 7 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3777	mib_pfiftable)) == NULL((void *)0) \|\|
3778	(pfIfIn4BlockPkts = agentx_object(pfMIBObjects,
3779	AGENTX_OID(PFIFIN4BLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 8 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 8 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3780	mib_pfiftable)) == NULL((void *)0) \|\|
3781	(pfIfIn4BlockBytes = agentx_object(pfMIBObjects,
3782	AGENTX_OID(PFIFIN4BLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 9 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 9 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3783	mib_pfiftable)) == NULL((void *)0) \|\|
3784	(pfIfOut4PassPkts = agentx_object(pfMIBObjects,
3785	AGENTX_OID(PFIFOUT4PASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 10 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 10 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3786	mib_pfiftable)) == NULL((void *)0) \|\|
3787	(pfIfOut4PassBytes = agentx_object(pfMIBObjects,
3788	AGENTX_OID(PFIFOUT4PASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 11 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 11 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3789	mib_pfiftable)) == NULL((void *)0) \|\|
3790	(pfIfOut4BlockPkts = agentx_object(pfMIBObjects,
3791	AGENTX_OID(PFIFOUT4BLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 12 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 12 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3792	mib_pfiftable)) == NULL((void *)0) \|\|
3793	(pfIfOut4BlockBytes = agentx_object(pfMIBObjects,
3794	AGENTX_OID(PFIFOUT4BLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 13 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 13 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3795	mib_pfiftable)) == NULL((void *)0) \|\|
3796	(pfIfIn6PassPkts = agentx_object(pfMIBObjects,
3797	AGENTX_OID(PFIFIN6PASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 14 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 14 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3798	mib_pfiftable)) == NULL((void *)0) \|\|
3799	(pfIfIn6PassBytes = agentx_object(pfMIBObjects,
3800	AGENTX_OID(PFIFIN6PASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 15 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 15 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3801	mib_pfiftable)) == NULL((void *)0) \|\|
3802	(pfIfIn6BlockPkts = agentx_object(pfMIBObjects,
3803	AGENTX_OID(PFIFIN6BLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 16 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 16 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3804	mib_pfiftable)) == NULL((void *)0) \|\|
3805	(pfIfIn6BlockBytes = agentx_object(pfMIBObjects,
3806	AGENTX_OID(PFIFIN6BLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 17 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 17 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3807	mib_pfiftable)) == NULL((void *)0) \|\|
3808	(pfIfOut6PassPkts = agentx_object(pfMIBObjects,
3809	AGENTX_OID(PFIFOUT6PASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 18 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 18 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3810	mib_pfiftable)) == NULL((void *)0) \|\|
3811	(pfIfOut6PassBytes = agentx_object(pfMIBObjects,
3812	AGENTX_OID(PFIFOUT6PASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 19 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 19 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3813	mib_pfiftable)) == NULL((void *)0) \|\|
3814	(pfIfOut6BlockPkts = agentx_object(pfMIBObjects,
3815	AGENTX_OID(PFIFOUT6BLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 20 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 20 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3816	mib_pfiftable)) == NULL((void *)0) \|\|
3817	(pfIfOut6BlockBytes = agentx_object(pfMIBObjects,
3818	AGENTX_OID(PFIFOUT6BLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 21 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 8, 128, 1, 21 }) / sizeof(uint32_t)), &pfIfIdx, 1, 0,
3819	mib_pfiftable)) == NULL((void *)0))
3820	fatal("agentx_object");
3821
3822	if ((pfTblNumber = agentx_object(pfMIBObjects, AGENTX_OID(PFTBLNUMBER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 1 }) / sizeof(uint32_t )),
3823	NULL((void )0), 0, 0, mib_pftablenum)) == NULL((void )0))
3824	fatal("agentx_object");
3825	if ((pfTblIdx = agentx_index_integer_dynamic(pfMIBObjects,
3826	AGENTX_OID(PFTBLINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 1 }) / sizeof(uint32_t)))) == NULL((void *)0))
3827	fatal("agentx_index_integer_dynamic");
3828	if ((pfTblIndex = agentx_object(pfMIBObjects, AGENTX_OID(PFTBLINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 1 }) / sizeof(uint32_t)),
3829	&pfTblIdx, 1, 0, mib_pftables)) == NULL((void *)0) \|\|
3830	(pfTblName = agentx_object(pfMIBObjects, AGENTX_OID(PFTBLNAME)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 2 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 2 }) / sizeof(uint32_t)),
3831	&pfTblIdx, 1, 0, mib_pftables)) == NULL((void *)0) \|\|
3832	(pfTblAddresses = agentx_object(pfMIBObjects,
3833	AGENTX_OID(PFTBLADDRESSES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 3 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 3 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3834	mib_pftables)) == NULL((void *)0) \|\|
3835	(pfTblAnchorRefs = agentx_object(pfMIBObjects,
3836	AGENTX_OID(PFTBLANCHORREFS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 4 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 4 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3837	mib_pftables)) == NULL((void *)0) \|\|
3838	(pfTblRuleRefs = agentx_object(pfMIBObjects,
3839	AGENTX_OID(PFTBLRULEREFS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 5 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 5 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3840	mib_pftables)) == NULL((void *)0) \|\|
3841	(pfTblEvalsMatch = agentx_object(pfMIBObjects,
3842	AGENTX_OID(PFTBLEVALSMATCH)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 6 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 6 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3843	mib_pftables)) == NULL((void *)0) \|\|
3844	(pfTblEvalsNoMatch = agentx_object(pfMIBObjects,
3845	AGENTX_OID(PFTBLEVALSNOMATCH)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 7 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 7 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3846	mib_pftables)) == NULL((void *)0) \|\|
3847	(pfTblInPassPkts = agentx_object(pfMIBObjects,
3848	AGENTX_OID(PFTBLINPASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 8 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 8 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3849	mib_pftables)) == NULL((void *)0) \|\|
3850	(pfTblInPassBytes = agentx_object(pfMIBObjects,
3851	AGENTX_OID(PFTBLINPASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 9 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 9 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3852	mib_pftables)) == NULL((void *)0) \|\|
3853	(pfTblInBlockPkts = agentx_object(pfMIBObjects,
3854	AGENTX_OID(PFTBLINBLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 10 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 10 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3855	mib_pftables)) == NULL((void *)0) \|\|
3856	(pfTblInBlockBytes = agentx_object(pfMIBObjects,
3857	AGENTX_OID(PFTBLINBLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 11 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 11 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3858	mib_pftables)) == NULL((void *)0) \|\|
3859	(pfTblInXPassPkts = agentx_object(pfMIBObjects,
3860	AGENTX_OID(PFTBLINXPASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 12 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 12 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3861	mib_pftables)) == NULL((void *)0) \|\|
3862	(pfTblInXPassBytes = agentx_object(pfMIBObjects,
3863	AGENTX_OID(PFTBLINXPASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 13 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 13 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3864	mib_pftables)) == NULL((void *)0) \|\|
3865	(pfTblOutPassPkts = agentx_object(pfMIBObjects,
3866	AGENTX_OID(PFTBLOUTPASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 14 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 14 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3867	mib_pftables)) == NULL((void *)0) \|\|
3868	(pfTblOutPassBytes = agentx_object(pfMIBObjects,
3869	AGENTX_OID(PFTBLOUTPASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 15 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 15 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3870	mib_pftables)) == NULL((void *)0) \|\|
3871	(pfTblOutBlockPkts = agentx_object(pfMIBObjects,
3872	AGENTX_OID(PFTBLOUTBLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 16 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 16 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3873	mib_pftables)) == NULL((void *)0) \|\|
3874	(pfTblOutBlockBytes = agentx_object(pfMIBObjects,
3875	AGENTX_OID(PFTBLOUTBLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 17 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 17 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3876	mib_pftables)) == NULL((void *)0) \|\|
3877	(pfTblOutXPassPkts = agentx_object(pfMIBObjects,
3878	AGENTX_OID(PFTBLOUTXPASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 18 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 18 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3879	mib_pftables)) == NULL((void *)0) \|\|
3880	(pfTblOutXPassBytes = agentx_object(pfMIBObjects,
3881	AGENTX_OID(PFTBLOUTXPASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 19 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 19 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3882	mib_pftables)) == NULL((void *)0) \|\|
3883	(pfTblStatsCleared = agentx_object(pfMIBObjects,
3884	AGENTX_OID(PFTBLSTATSCLEARED)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 20 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 20 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3885	mib_pftables)) == NULL((void *)0) \|\|
3886	(pfTblInMatchPkts = agentx_object(pfMIBObjects,
3887	AGENTX_OID(PFTBLINMATCHPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 21 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 21 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3888	mib_pftables)) == NULL((void *)0) \|\|
3889	(pfTblInMatchBytes = agentx_object(pfMIBObjects,
3890	AGENTX_OID(PFTBLINMATCHBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 22 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 22 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3891	mib_pftables)) == NULL((void *)0) \|\|
3892	(pfTblOutMatchPkts = agentx_object(pfMIBObjects,
3893	AGENTX_OID(PFTBLOUTMATCHPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 23 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 23 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3894	mib_pftables)) == NULL((void *)0) \|\|
3895	(pfTblOutMatchBytes = agentx_object(pfMIBObjects,
3896	AGENTX_OID(PFTBLOUTMATCHBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 24 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 128, 1, 24 }) / sizeof(uint32_t)), &pfTblIdx, 1, 0,
3897	mib_pftables)) == NULL((void *)0))
3898	fatal("agentx_object");
3899
3900	if ((pfTblAddrTblIdx = agentx_index_integer_dynamic(pfMIBObjects,
3901	AGENTX_OID(PFTBLADDRTBLINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 1 }) / sizeof(uint32_t)))) == NULL((void *)0) \|\|
3902	(pfTblAddrNetIdx = agentx_index_ipaddress_dynamic(pfMIBObjects,
3903	AGENTX_OID(PFTBLADDRNET)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 2 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 2 }) / sizeof(uint32_t)))) == NULL((void *)0) \|\|
3904	(pfTblAddrMaskIdx = agentx_index_integer_dynamic(pfMIBObjects,
3905	AGENTX_OID(PFTBLADDRMASK)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 3 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 3 }) / sizeof(uint32_t)))) == NULL((void *)0))
3906	fatal("agentx_index_integer_dynamic");
3907	indices[0] = pfTblAddrTblIdx;
3908	indices[1] = pfTblAddrNetIdx;
3909	indices[2] = pfTblAddrMaskIdx;
3910	if ((pfTblAddrTblIndex = agentx_object(pfMIBObjects,
3911	AGENTX_OID(PFTBLADDRTBLINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 1 }) / sizeof(uint32_t)), indices, 3, 0,
3912	mib_pftableaddrs)) == NULL((void *)0) \|\|
3913	(pfTblAddrNet = agentx_object(pfMIBObjects,
3914	AGENTX_OID(PFTBLADDRNET)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 2 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 2 }) / sizeof(uint32_t)), indices, 3, 0,
3915	mib_pftableaddrs)) == NULL((void *)0) \|\|
3916	(pfTblAddrMask = agentx_object(pfMIBObjects,
3917	AGENTX_OID(PFTBLADDRMASK)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 3 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 3 }) / sizeof(uint32_t)), indices, 3, 0,
3918	mib_pftableaddrs)) == NULL((void *)0) \|\|
3919	(pfTblAddrCleared = agentx_object(pfMIBObjects,
3920	AGENTX_OID(PFTBLADDRCLEARED)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 4 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 4 }) / sizeof(uint32_t)), indices, 3, 0,
3921	mib_pftableaddrs)) == NULL((void *)0) \|\|
3922	(pfTblAddrInBlockPkts = agentx_object(pfMIBObjects,
3923	AGENTX_OID(PFTBLADDRINBLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 5 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 5 }) / sizeof(uint32_t)), indices, 3, 0,
3924	mib_pftableaddrs)) == NULL((void *)0) \|\|
3925	(pfTblAddrInBlockBytes = agentx_object(pfMIBObjects,
3926	AGENTX_OID(PFTBLADDRINBLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 6 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 6 }) / sizeof(uint32_t)), indices, 3, 0,
3927	mib_pftableaddrs)) == NULL((void *)0) \|\|
3928	(pfTblAddrInPassPkts = agentx_object(pfMIBObjects,
3929	AGENTX_OID(PFTBLADDRINPASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 7 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 7 }) / sizeof(uint32_t)), indices, 3, 0,
3930	mib_pftableaddrs)) == NULL((void *)0) \|\|
3931	(pfTblAddrInPassBytes = agentx_object(pfMIBObjects,
3932	AGENTX_OID(PFTBLADDRINPASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 8 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 8 }) / sizeof(uint32_t)), indices, 3, 0,
3933	mib_pftableaddrs)) == NULL((void *)0) \|\|
3934	(pfTblAddrOutBlockPkts = agentx_object(pfMIBObjects,
3935	AGENTX_OID(PFTBLADDROUTBLOCKPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 9 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 9 }) / sizeof(uint32_t)), indices, 3, 0,
3936	mib_pftableaddrs)) == NULL((void *)0) \|\|
3937	(pfTblAddrOutBlockBytes = agentx_object(pfMIBObjects,
3938	AGENTX_OID(PFTBLADDROUTBLOCKBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 10 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 10 }) / sizeof(uint32_t)), indices, 3, 0,
3939	mib_pftableaddrs)) == NULL((void *)0) \|\|
3940	(pfTblAddrOutPassPkts = agentx_object(pfMIBObjects,
3941	AGENTX_OID(PFTBLADDROUTPASSPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 11 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 11 }) / sizeof(uint32_t)), indices, 3, 0,
3942	mib_pftableaddrs)) == NULL((void *)0) \|\|
3943	(pfTblAddrOutPassBytes = agentx_object(pfMIBObjects,
3944	AGENTX_OID(PFTBLADDROUTPASSBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 12 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 12 }) / sizeof(uint32_t)), indices, 3, 0,
3945	mib_pftableaddrs)) == NULL((void *)0) \|\|
3946	(pfTblAddrInMatchPkts = agentx_object(pfMIBObjects,
3947	AGENTX_OID(PFTBLADDRINMATCHPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 13 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 13 }) / sizeof(uint32_t)), indices, 3, 0,
3948	mib_pftableaddrs)) == NULL((void *)0) \|\|
3949	(pfTblAddrInMatchBytes = agentx_object(pfMIBObjects,
3950	AGENTX_OID(PFTBLADDRINMATCHBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 14 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 14 }) / sizeof(uint32_t)), indices, 3, 0,
3951	mib_pftableaddrs)) == NULL((void *)0) \|\|
3952	(pfTblAddrOutMatchPkts = agentx_object(pfMIBObjects,
3953	AGENTX_OID(PFTBLADDROUTMATCHPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 15 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 15 }) / sizeof(uint32_t)), indices, 3, 0,
3954	mib_pftableaddrs)) == NULL((void *)0) \|\|
3955	(pfTblAddrOutMatchBytes = agentx_object(pfMIBObjects,
3956	AGENTX_OID(PFTBLADDROUTMATCHBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 16 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 9, 129, 1, 16 }) / sizeof(uint32_t)), indices, 3, 0,
3957	mib_pftableaddrs)) == NULL((void *)0))
3958	fatal("agentx_object");
3959
3960	if ((pfLabelNumber = agentx_object(pfMIBObjects,
3961	AGENTX_OID(PFLABELNUMBER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 1 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 1 }) / sizeof (uint32_t)), NULL((void )0), 0, 0, mib_pflabelnum)) == NULL((void )0))
3962	fatal("agentx_object");
3963	if ((pfLabelIdx = agentx_index_integer_dynamic(pfMIBObjects,
3964	AGENTX_OID(PFLABELINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 1 }) / sizeof(uint32_t)))) == NULL((void *)0))
3965	fatal("agentx_index_integer_dynamic");
3966	if ((pfLabelIndex = agentx_object(pfMIBObjects,
3967	AGENTX_OID(PFLABELINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 1 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 1 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3968	mib_pflabels)) == NULL((void *)0) \|\|
3969	(pfLabelName = agentx_object(pfMIBObjects, AGENTX_OID(PFLABELNAME)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 2 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 2 }) / sizeof(uint32_t)),
3970	&pfLabelIdx, 1, 0, mib_pflabels)) == NULL((void *)0) \|\|
3971	(pfLabelEvals = agentx_object(pfMIBObjects,
3972	AGENTX_OID(PFLABELEVALS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 3 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 3 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3973	mib_pflabels)) == NULL((void *)0) \|\|
3974	(pfLabelPkts = agentx_object(pfMIBObjects, AGENTX_OID(PFLABELPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 4 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 4 }) / sizeof(uint32_t)),
3975	&pfLabelIdx, 1, 0, mib_pflabels)) == NULL((void *)0) \|\|
3976	(pfLabelBytes = agentx_object(pfMIBObjects,
3977	AGENTX_OID(PFLABELBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 5 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 5 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3978	mib_pflabels)) == NULL((void *)0) \|\|
3979	(pfLabelInPkts = agentx_object(pfMIBObjects,
3980	AGENTX_OID(PFLABELINPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 6 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 6 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3981	mib_pflabels)) == NULL((void *)0) \|\|
3982	(pfLabelInBytes = agentx_object(pfMIBObjects,
3983	AGENTX_OID(PFLABELINBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 7 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 7 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3984	mib_pflabels)) == NULL((void *)0) \|\|
3985	(pfLabelOutPkts = agentx_object(pfMIBObjects,
3986	AGENTX_OID(PFLABELOUTPKTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 8 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 8 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3987	mib_pflabels)) == NULL((void *)0) \|\|
3988	(pfLabelOutBytes = agentx_object(pfMIBObjects,
3989	AGENTX_OID(PFLABELOUTBYTES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 9 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1 , 9 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3990	mib_pflabels)) == NULL((void *)0) \|\|
3991	(pfLabelTotalStates = agentx_object(pfMIBObjects,
3992	AGENTX_OID(PFLABELTOTALSTATES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 10 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 10, 128, 1, 10 }) / sizeof(uint32_t)), &pfLabelIdx, 1, 0,
3993	mib_pflabels)) == NULL((void *)0))
3994	fatal("agentx_object");
3995
3996	if ((pfsyncIpPktsRecv = agentx_object(pfMIBObjects,
3997	AGENTX_OID(PFSYNCIPPKTSRECV)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 1 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 1 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
3998	mib_pfsyncstats)) == NULL((void *)0) \|\|
3999	(pfsyncIp6PktsRecv = agentx_object(pfMIBObjects,
4000	AGENTX_OID(PFSYNCIP6PKTSRECV)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 2 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 2 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4001	mib_pfsyncstats)) == NULL((void *)0) \|\|
4002	(pfsyncPktDiscardsForBadInterface = agentx_object(pfMIBObjects,
4003	AGENTX_OID(PFSYNCPKTDISCARDSFORBADINTERFACE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 3 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 3 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4004	mib_pfsyncstats)) == NULL((void *)0) \|\|
4005	(pfsyncPktDiscardsForBadTtl = agentx_object(pfMIBObjects,
4006	AGENTX_OID(PFSYNCPKTDISCARDSFORBADTTL)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 4 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 4 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4007	mib_pfsyncstats)) == NULL((void *)0) \|\|
4008	(pfsyncPktShorterThanHeader = agentx_object(pfMIBObjects,
4009	AGENTX_OID(PFSYNCPKTSHORTERTHANHEADER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 5 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 5 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4010	mib_pfsyncstats)) == NULL((void *)0) \|\|
4011	(pfsyncPktDiscardsForBadVersion = agentx_object(pfMIBObjects,
4012	AGENTX_OID(PFSYNCPKTDISCARDSFORBADVERSION)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 6 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 6 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4013	mib_pfsyncstats)) == NULL((void *)0) \|\|
4014	(pfsyncPktDiscardsForBadAction = agentx_object(pfMIBObjects,
4015	AGENTX_OID(PFSYNCPKTDISCARDSFORBADACTION)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 7 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 7 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4016	mib_pfsyncstats)) == NULL((void *)0) \|\|
4017	(pfsyncPktDiscardsForBadLength = agentx_object(pfMIBObjects,
4018	AGENTX_OID(PFSYNCPKTDISCARDSFORBADLENGTH)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 8 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 8 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4019	mib_pfsyncstats)) == NULL((void *)0) \|\|
4020	(pfsyncPktDiscardsForBadAuth = agentx_object(pfMIBObjects,
4021	AGENTX_OID(PFSYNCPKTDISCARDSFORBADAUTH)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 9 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 9 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4022	mib_pfsyncstats)) == NULL((void *)0) \|\|
4023	(pfsyncPktDiscardsForStaleState = agentx_object(pfMIBObjects,
4024	AGENTX_OID(PFSYNCPKTDISCARDSFORSTALESTATE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 10 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 10 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4025	mib_pfsyncstats)) == NULL((void *)0) \|\|
4026	(pfsyncPktDiscardsForBadValues = agentx_object(pfMIBObjects,
4027	AGENTX_OID(PFSYNCPKTDISCARDSFORBADVALUES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 11 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 11 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4028	mib_pfsyncstats)) == NULL((void *)0) \|\|
4029	(pfsyncPktDiscardsForBadState = agentx_object(pfMIBObjects,
4030	AGENTX_OID(PFSYNCPKTDISCARDSFORBADSTATE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 12 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 12 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4031	mib_pfsyncstats)) == NULL((void *)0) \|\|
4032	(pfsyncIpPktsSent = agentx_object(pfMIBObjects,
4033	AGENTX_OID(PFSYNCIPPKTSSENT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 13 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 13 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4034	mib_pfsyncstats)) == NULL((void *)0) \|\|
4035	(pfsyncIp6PktsSent = agentx_object(pfMIBObjects,
4036	AGENTX_OID(PFSYNCIP6PKTSSENT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 14 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 14 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4037	mib_pfsyncstats)) == NULL((void *)0) \|\|
4038	(pfsyncNoMemory = agentx_object(pfMIBObjects,
4039	AGENTX_OID(PFSYNCNOMEMORY)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 15 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 15 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4040	mib_pfsyncstats)) == NULL((void *)0) \|\|
4041	(pfsyncOutputErrors = agentx_object(pfMIBObjects,
4042	AGENTX_OID(PFSYNCOUTPUTERRORS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 16 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 1, 11, 16 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4043	mib_pfsyncstats)) == NULL((void *)0))
4044	fatal("agentx_object");
4045
4046	if ((sensorsMIBObjects = agentx_region(sac,
4047	AGENTX_OID(SENSORSMIBOBJECTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
4048	fatal("agentx_region");
4049	if ((sensorNumber = agentx_object(sensorsMIBObjects,
4050	AGENTX_OID(SENSORNUMBER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 1 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_sensornum)) == NULL((void )0))
4051	fatal("agentx_object");
4052	if ((sensorIdx = agentx_index_integer_dynamic(sensorsMIBObjects,
4053	AGENTX_OID(SENSORINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 1 }) / sizeof (uint32_t)))) == NULL((void *)0))
4054	fatal("agentx_index_integer_dynamic");
4055	if ((sensorIndex = agentx_object(sensorsMIBObjects,
4056	AGENTX_OID(SENSORINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 1 }) / sizeof (uint32_t)), &sensorIdx, 1, 0, mib_sensors)) == NULL((void *)0) \|\|
4057	(sensorDescr = agentx_object(sensorsMIBObjects,
4058	AGENTX_OID(SENSORDESCR)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 2 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 2 }) / sizeof (uint32_t)), &sensorIdx, 1, 0, mib_sensors)) == NULL((void *)0) \|\|
4059	(sensorType = agentx_object(sensorsMIBObjects,
4060	AGENTX_OID(SENSORTYPE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 3 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 3 }) / sizeof (uint32_t)), &sensorIdx, 1, 0, mib_sensors)) == NULL((void *)0) \|\|
4061	(sensorDevice = agentx_object(sensorsMIBObjects,
4062	AGENTX_OID(SENSORDEVICE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 4 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 4 }) / sizeof (uint32_t)), &sensorIdx, 1, 0, mib_sensors)) == NULL((void *)0) \|\|
4063	(sensorValue = agentx_object(sensorsMIBObjects,
4064	AGENTX_OID(SENSORVALUE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 5 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 5 }) / sizeof (uint32_t)), &sensorIdx, 1, 0, mib_sensors)) == NULL((void *)0) \|\|
4065	(sensorUnits = agentx_object(sensorsMIBObjects,
4066	AGENTX_OID(SENSORUNITS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 6 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 6 }) / sizeof (uint32_t)), &sensorIdx, 1, 0, mib_sensors)) == NULL((void *)0) \|\|
4067	(sensorStatus = agentx_object(sensorsMIBObjects,
4068	AGENTX_OID(SENSORSTATUS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 7 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 2, 1, 2, 1, 7 }) / sizeof (uint32_t)), &sensorIdx, 1, 0, mib_sensors)) == NULL((void *)0))
4069	fatal("agentx_object");
4070
4071	if ((carpMIBObjects = agentx_region(sac,
4072	AGENTX_OID(CARPMIBOBJECTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
4073	fatal("agentx_region");
4074	if ((carpAllow = agentx_object(carpMIBObjects, AGENTX_OID(CARPALLOW)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 1, 1 }) / sizeof(uint32_t )),
4075	NULL((void )0), 0, 0, mib_carpsysctl)) == NULL((void )0) \|\|
4076	(carpPreempt = agentx_object(carpMIBObjects,
4077	AGENTX_OID(CARPPREEMPT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 1, 2 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_carpsysctl)) == NULL((void )0) \|\|
4078	(carpLog = agentx_object(carpMIBObjects, AGENTX_OID(CARPLOG)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 1, 3 }) / sizeof(uint32_t )),
4079	NULL((void )0), 0, 0, mib_carpsysctl)) == NULL((void )0))
4080	fatal("agentx_object");
4081
4082	if ((carpIfNumber = agentx_object(carpMIBObjects,
4083	AGENTX_OID(CARPIFNUMBER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 1 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_carpifnum)) == NULL((void )0))
4084	fatal("agentx_object");
4085	if ((carpIfIdx = agentx_index_integer_dynamic(carpMIBObjects,
4086	AGENTX_OID(CARPIFINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 1 }) / sizeof (uint32_t)))) == NULL((void *)0))
4087	fatal("agentx_index_integer_dynamic");
4088	if ((carpIfIndex = agentx_object(carpMIBObjects,
4089	AGENTX_OID(CARPIFINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 1 }) / sizeof (uint32_t)), &carpIfIdx, 1, 0,
4090	mib_carpiftable)) == NULL((void *)0) \|\|
4091	(carpIfDescr = agentx_object(carpMIBObjects,
4092	AGENTX_OID(CARPIFDESCR)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 2 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 2 }) / sizeof (uint32_t)), &carpIfIdx, 1, 0,
4093	mib_carpiftable)) == NULL((void *)0) \|\|
4094	(carpIfVhid = agentx_object(carpMIBObjects, AGENTX_OID(CARPIFVHID)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 3 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 3 }) / sizeof (uint32_t)),
4095	&carpIfIdx, 1, 0, mib_carpiftable)) == NULL((void *)0) \|\|
4096	(carpIfDev = agentx_object(carpMIBObjects, AGENTX_OID(CARPIFDEV)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 4 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 4 }) / sizeof (uint32_t)),
4097	&carpIfIdx, 1, 0, mib_carpiftable)) == NULL((void *)0) \|\|
4098	(carpIfAdvbase = agentx_object(carpMIBObjects,
4099	AGENTX_OID(CARPIFADVBASE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 5 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 5 }) / sizeof (uint32_t)), &carpIfIdx, 1, 0,
4100	mib_carpiftable)) == NULL((void *)0) \|\|
4101	(carpIfAdvskew = agentx_object(carpMIBObjects,
4102	AGENTX_OID(CARPIFADVSKEW)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 6 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 6 }) / sizeof (uint32_t)), &carpIfIdx, 1, 0,
4103	mib_carpiftable)) == NULL((void *)0) \|\|
4104	(carpIfState = agentx_object(carpMIBObjects,
4105	AGENTX_OID(CARPIFSTATE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 7 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 2, 2, 1, 7 }) / sizeof (uint32_t)), &carpIfIdx, 1, 0,
4106	mib_carpiftable)) == NULL((void *)0))
4107	fatal("agentx_object");
4108
4109	if ((carpGroupIdx = agentx_index_integer_dynamic(carpMIBObjects,
4110	AGENTX_OID(CARPGROUPINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 4, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 4, 1, 1 }) / sizeof (uint32_t)))) == NULL((void *)0))
4111	fatal("agentx_index_integer_dynamic");
4112	if ((carpGroupName = agentx_object(carpMIBObjects,
4113	AGENTX_OID(CARPGROUPNAME)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 4, 1, 2 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 4, 1, 2 }) / sizeof (uint32_t)), &carpGroupIdx, 1, 0,
4114	mib_carpgrouptable)) == NULL((void *)0) \|\|
4115	(carpGroupDemote = agentx_object(carpMIBObjects,
4116	AGENTX_OID(CARPGROUPDEMOTE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 4, 1, 3 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 4, 1, 3 }) / sizeof (uint32_t)), &carpGroupIdx, 1, 0,
4117	mib_carpgrouptable)) == NULL((void *)0))
4118	fatal("agentx_object");
4119
4120	if ((carpIpPktsRecv = agentx_object(carpMIBObjects,
4121	AGENTX_OID(CARPIPPKTSRECV)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 1 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_carpstats)) == NULL((void )0) \|\|
4122	(carpIp6PktsRecv = agentx_object(carpMIBObjects,
4123	AGENTX_OID(CARPIP6PKTSRECV)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 2 }) / sizeof(uint32_t )), NULL((void )0), 0, 0, mib_carpstats)) == NULL((void )0) \|\|
4124	(carpPktDiscardsForBadInterface = agentx_object(carpMIBObjects,
4125	AGENTX_OID(CARPPKTDISCARDSFORBADINTERFACE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 3 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
4126	mib_carpstats)) == NULL((void *)0) \|\|
4127	(carpPktDiscardsForWrongTtl = agentx_object(carpMIBObjects,
4128	AGENTX_OID(CARPPKTDISCARDSFORWRONGTTL)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 4 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
4129	mib_carpstats)) == NULL((void *)0) \|\|
4130	(carpPktShorterThanHeader = agentx_object(carpMIBObjects,
4131	AGENTX_OID(CARPPKTSHORTERTHANHEADER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 5 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
4132	mib_carpstats)) == NULL((void *)0) \|\|
4133	(carpPktDiscardsForBadChecksum = agentx_object(carpMIBObjects,
4134	AGENTX_OID(CARPPKTDISCARDSFORBADCHECKSUM)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 6 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
4135	mib_carpstats)) == NULL((void *)0) \|\|
4136	(carpPktDiscardsForBadVersion = agentx_object(carpMIBObjects,
4137	AGENTX_OID(CARPPKTDISCARDSFORBADVERSION)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 7 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
4138	mib_carpstats)) == NULL((void *)0) \|\|
4139	(carpPktDiscardsForTooShort = agentx_object(carpMIBObjects,
4140	AGENTX_OID(CARPPKTDISCARDSFORTOOSHORT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 8 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 8 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
4141	mib_carpstats)) == NULL((void *)0) \|\|
4142	(carpPktDiscardsForBadAuth = agentx_object(carpMIBObjects,
4143	AGENTX_OID(CARPPKTDISCARDSFORBADAUTH)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 9 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 9 }) / sizeof(uint32_t )), NULL((void *)0), 0, 0,
4144	mib_carpstats)) == NULL((void *)0) \|\|
4145	(carpPktDiscardsForBadVhid = agentx_object(carpMIBObjects,
4146	AGENTX_OID(CARPPKTDISCARDSFORBADVHID)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 10 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 10 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4147	mib_carpstats)) == NULL((void *)0) \|\|
4148	(carpPktDiscardsForBadAddressList = agentx_object(carpMIBObjects,
4149	AGENTX_OID(CARPPKTDISCARDSFORBADADDRESSLIST)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 11 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 11 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4150	mib_carpstats)) == NULL((void *)0) \|\|
4151	(carpIpPktsSent = agentx_object(carpMIBObjects,
4152	AGENTX_OID(CARPIPPKTSSENT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 12 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 12 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4153	mib_carpstats)) == NULL((void *)0) \|\|
4154	(carpIp6PktsSent = agentx_object(carpMIBObjects,
4155	AGENTX_OID(CARPIP6PKTSSENT)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 13 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 13 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4156	mib_carpstats)) == NULL((void *)0) \|\|
4157	(carpNoMemory = agentx_object(carpMIBObjects,
4158	AGENTX_OID(CARPNOMEMORY)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 14 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 14 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4159	mib_carpstats)) == NULL((void *)0) \|\|
4160	(carpTransitionsToMaster = agentx_object(carpMIBObjects,
4161	AGENTX_OID(CARPTRANSITIONSTOMASTER)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 15 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 6, 3, 15 }) / sizeof (uint32_t)), NULL((void *)0), 0, 0,
4162	mib_carpstats)) == NULL((void *)0))
4163	fatal("agentx_object");
4164
4165	/* OPENBSD-MEM-MIB */
4166	if ((memMIBObjects = agentx_region(sac,
4167	AGENTX_OID(MEMMIBOBJECTS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
4168	fatal("agentx_region");
4169	if ((memMIBVersion = agentx_object(memMIBObjects,
4170	AGENTX_OID(MEMMIBVERSION)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5, 1 }) / sizeof(uint32_t)), NULL((void )0), 0, 0, mib_memversion)) == NULL((void )0))
4171	fatal("agentx_object");
4172	if ((memIfName = agentx_object(memMIBObjects, AGENTX_OID(MEMIFNAME)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5, 2, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5, 2, 1, 1 }) / sizeof (uint32_t)),
4173	&ifIdx, 1, 0, mib_memiftable)) == NULL((void *)0) \|\|
4174	(memIfLiveLocks = agentx_object(memMIBObjects,
4175	AGENTX_OID(MEMIFLIVELOCKS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5, 2, 1, 2 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 30155, 5, 2, 1, 2 }) / sizeof (uint32_t)), &ifIdx, 1, 0,
4176	mib_memiftable)) == NULL((void *)0))
4177	fatal("agentx_object");
4178
4179	/* IP-MIB */
4180	if ((ip = agentx_region(sac, AGENTX_OID(IP)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
4181	fatal("agentx_region");
4182	if ((ipForwarding = agentx_object(ip, AGENTX_OID(IPFORWARDING)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 1 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 1 }) / sizeof(uint32_t)),
4183	NULL((void )0), 0, 0, mib_ipforwarding)) == NULL((void )0) \|\|
4184	(ipDefaultTTL = agentx_object(ip, AGENTX_OID(IPDEFAULTTTL)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 2 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 2 }) / sizeof(uint32_t)),
4185	NULL((void )0), 0, 0, mib_ipdefaultttl)) == NULL((void )0) \|\|
4186	(ipInReceives = agentx_object(ip, AGENTX_OID(IPINRECEIVES)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 3 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 3 }) / sizeof(uint32_t)),
4187	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4188	(ipInHdrErrors = agentx_object(ip, AGENTX_OID(IPINHDRERRORS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 4 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 4 }) / sizeof(uint32_t)),
4189	NULL((void )0), 0, 0, mib_ipinhdrerrs)) == NULL((void )0) \|\|
4190	(ipInAddrErrors = agentx_object(ip, AGENTX_OID(IPINADDRERRORS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 5 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 5 }) / sizeof(uint32_t)),
4191	NULL((void )0), 0, 0, mib_ipinaddrerrs)) == NULL((void )0) \|\|
4192	(ipForwDatagrams = agentx_object(ip, AGENTX_OID(IPFORWDATAGRAMS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 6 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 6 }) / sizeof(uint32_t)),
4193	NULL((void )0), 0, 0, mib_ipforwdgrams)) == NULL((void )0) \|\|
4194	(ipInUnknownProtos = agentx_object(ip,
4195	AGENTX_OID(IPINUNKNOWNPROTOS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 7 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 7 }) / sizeof(uint32_t)), NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4196	(ipInDelivers = agentx_object(ip, AGENTX_OID(IPINDELIVERS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 9 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 9 }) / sizeof(uint32_t)),
4197	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4198	(ipOutRequests = agentx_object(ip, AGENTX_OID(IPOUTREQUESTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 10 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 10 }) / sizeof(uint32_t)),
4199	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4200	(ipOutDiscards = agentx_object(ip, AGENTX_OID(IPOUTDISCARDS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 11 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 11 }) / sizeof(uint32_t)),
4201	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4202	(ipOutNoRoutes = agentx_object(ip, AGENTX_OID(IPOUTNOROUTES)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 12 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 12 }) / sizeof(uint32_t)),
4203	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4204	(ipReasmTimeout = agentx_object(ip, AGENTX_OID(IPREASMTIMEOUT)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 13 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 13 }) / sizeof(uint32_t)),
4205	NULL((void )0), 0, 0, mib_ipreasmtimeout)) == NULL((void )0) \|\|
4206	(ipReasmReqds = agentx_object(ip, AGENTX_OID(IPREASMREQDS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 14 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 14 }) / sizeof(uint32_t)),
4207	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4208	(ipReasmOKs = agentx_object(ip, AGENTX_OID(IPREASMOKS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 15 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 15 }) / sizeof(uint32_t)),
4209	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4210	(ipReasmFails = agentx_object(ip, AGENTX_OID(IPREASMFAILS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 16 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 16 }) / sizeof(uint32_t)),
4211	NULL((void )0), 0, 0, mib_ipreasmfails)) == NULL((void )0) \|\|
4212	(ipFragOKs = agentx_object(ip, AGENTX_OID(IPFRAGOKS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 17 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 17 }) / sizeof(uint32_t)),
4213	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0) \|\|
4214	(ipFragFails = agentx_object(ip, AGENTX_OID(IPFRAGFAILS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 18 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 18 }) / sizeof(uint32_t)),
4215	NULL((void )0), 0, 0, mib_ipfragfails)) == NULL((void )0) \|\|
4216	(ipFragCreates = agentx_object(ip, AGENTX_OID(IPFRAGCREATES)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 19 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 19 }) / sizeof(uint32_t)),
4217	NULL((void )0), 0, 0, mib_ipstat)) == NULL((void )0))
4218	fatal("agentx_object");
4219
4220	if ((ipAdEntAddrIdx = agentx_index_ipaddress_dynamic(ip,
4221	AGENTX_OID(IPADENTADDR)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 1 }) / sizeof(uint32_t)))) == NULL((void *)0))
4222	fatal("agentx_index_integer_dynamic");
4223	if ((ipAdEntAddr = agentx_object(ip, AGENTX_OID(IPADENTADDR)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 1 }) / sizeof(uint32_t)),
4224	&ipAdEntAddrIdx, 1, 0, mib_ipaddr)) == NULL((void *)0) \|\|
4225	(ipAdEntIfIndex = agentx_object(ip, AGENTX_OID(IPADENTIFINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 2 }) / sizeof(uint32_t)),
4226	&ipAdEntAddrIdx, 1, 0, mib_ipaddr)) == NULL((void *)0) \|\|
4227	(ipAdEntNetMask = agentx_object(ip, AGENTX_OID(IPADENTNETMASK)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 3 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 3 }) / sizeof(uint32_t)),
4228	&ipAdEntAddrIdx, 1, 0, mib_ipaddr)) == NULL((void *)0) \|\|
4229	(ipAdEntBcastAddr = agentx_object(ip, AGENTX_OID(IPADENTBCASTADDR)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 4 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 4 }) / sizeof(uint32_t)),
4230	&ipAdEntAddrIdx, 1, 0, mib_ipaddr)) == NULL((void *)0) \|\|
4231	(ipAdEntReasmMaxSize = agentx_object(ip,
4232	AGENTX_OID(IPADENTREASMMAXSIZE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 5 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 20, 1, 5 }) / sizeof(uint32_t)), &ipAdEntAddrIdx, 1, 0,
4233	mib_ipaddr)) == NULL((void *)0))
4234	fatal("agentx_object");
4235
4236	if ((ipNetToMediaIfIdx = agentx_index_integer_dynamic(ip,
4237	AGENTX_OID(IPNETTOMEDIAIFINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 1 }) / sizeof(uint32_t)))) == NULL((void *)0))
4238	fatal("agentx_index_integer_dynamic");
4239	if ((ipNetToMediaNetAddressIdx = agentx_index_ipaddress_dynamic(ip,
4240	AGENTX_OID(IPNETTOMEDIANETADDRESS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 3 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 3 }) / sizeof(uint32_t)))) == NULL((void *)0))
4241	fatal("agentx_index_string_dynamic");
4242	indices[0] = ipNetToMediaIfIdx;
4243	indices[1] = ipNetToMediaNetAddressIdx;
4244	if ((ipNetToMediaIfIndex = agentx_object(ip,
4245	AGENTX_OID(IPNETTOMEDIAIFINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 1 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 1 }) / sizeof(uint32_t)), indices, 2, 0,
4246	mib_physaddr)) == NULL((void *)0) \|\|
4247	(ipNetToMediaPhysAddress = agentx_object(ip,
4248	AGENTX_OID(IPNETTOMEDIAPHYSADDRESS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 2 }) / sizeof(uint32_t)), indices, 2, 0,
4249	mib_physaddr)) == NULL((void *)0) \|\|
4250	(ipNetToMediaNetAddress = agentx_object(ip,
4251	AGENTX_OID(IPNETTOMEDIANETADDRESS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 3 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 3 }) / sizeof(uint32_t)), indices, 2, 0,
4252	mib_physaddr)) == NULL((void *)0) \|\|
4253	(ipNetToMediaType = agentx_object(ip, AGENTX_OID(IPNETTOMEDIATYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 4 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 22, 1, 4 }) / sizeof(uint32_t)),
4254	indices, 2, 0, mib_physaddr)) == NULL((void *)0))
4255	fatal("agentx_object");
4256
4257	if ((ipForward = agentx_region(sac, AGENTX_OID(IPFORWARD)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24 }, (sizeof((uint32_t [ ]) { 1, 3, 6, 1, 2, 1, 4, 24 }) / sizeof(uint32_t)), 0)) == NULL((void *)0))
4258	fatal("agentx_region");
4259	if ((inetCidrRouteNumber = agentx_object(ipForward,
4260	AGENTX_OID(INETCIDRROUTENUMBER)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 6 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 6 }) / sizeof(uint32_t)), NULL((void *)0), 0, 0,
4261	mib_ipfnroutes)) == NULL((void *)0))
4262	fatal("agentx_object");
4263	if ((inetCidrRouteDestTypeIdx = agentx_index_integer_dynamic(ipForward,
4264	AGENTX_OID(INETCIDRROUTEDESTTYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 1 }) / sizeof(uint32_t )))) == NULL((void *)0) \|\|
4265	(inetCidrRouteDestIdx = agentx_index_string_dynamic(ipForward,
4266	AGENTX_OID(INETCIDRROUTEDEST)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 2 }) / sizeof(uint32_t )))) == NULL((void *)0) \|\|
4267	(inetCidrRoutePfxLenIdx = agentx_index_integer_dynamic(ipForward,
4268	AGENTX_OID(INETCIDRROUTEPFXLEN)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 3 }) / sizeof(uint32_t )))) == NULL((void *)0) \|\|
4269	(inetCidrRoutePolicyIdx = agentx_index_oid_dynamic(ipForward,
4270	AGENTX_OID(INETCIDRROUTEPOLICY)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 4 }) / sizeof(uint32_t )))) == NULL((void *)0) \|\|
4271	(inetCidrRouteNextHopTypeIdx = agentx_index_integer_dynamic(
4272	ipForward, AGENTX_OID(INETCIDRROUTENEXTHOPTYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 5 }) / sizeof(uint32_t )))) == NULL((void *)0) \|\|
4273	(inetCidrRouteNextHopIdx = agentx_index_string_dynamic(ipForward,
4274	AGENTX_OID(INETCIDRROUTENEXTHOP)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 6 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 6 }) / sizeof(uint32_t )))) == NULL((void *)0))
4275	fatal("agentx_index_*_dynamic");
4276	indices[0] = inetCidrRouteDestTypeIdx;
4277	indices[1] = inetCidrRouteDestIdx;
4278	indices[2] = inetCidrRoutePfxLenIdx;
4279	indices[3] = inetCidrRoutePolicyIdx;
4280	indices[4] = inetCidrRouteNextHopTypeIdx;
4281	indices[5] = inetCidrRouteNextHopIdx;
4282	if ((inetCidrRouteIfIndex = agentx_object(ipForward,
4283	AGENTX_OID(INETCIDRROUTEIFINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 7 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 7 }) / sizeof(uint32_t )), indices, 6, 0,
4284	mib_ipfroute)) == NULL((void *)0) \|\|
4285	(inetCidrRouteType = agentx_object(ipForward,
4286	AGENTX_OID(INETCIDRROUTETYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 8 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 8 }) / sizeof(uint32_t )), indices, 6, 0,
4287	mib_ipfroute)) == NULL((void *)0) \|\|
4288	(inetCidrRouteProto = agentx_object(ipForward,
4289	AGENTX_OID(INETCIDRROUTEPROTO)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 9 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 9 }) / sizeof(uint32_t )), indices, 6, 0,
4290	mib_ipfroute)) == NULL((void *)0) \|\|
4291	(inetCidrRouteAge = agentx_object(ipForward,
4292	AGENTX_OID(INETCIDRROUTEAGE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 10 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 10 }) / sizeof (uint32_t)), indices, 6, 0,
4293	mib_ipfroute)) == NULL((void *)0) \|\|
4294	(inetCidrRouteNextHopAS = agentx_object(ipForward,
4295	AGENTX_OID(INETCIDRROUTENEXTHOPAS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 11 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 11 }) / sizeof (uint32_t)), indices, 6, 0,
4296	mib_ipfroute)) == NULL((void *)0) \|\|
4297	(inetCidrRouteMetric1 = agentx_object(ipForward,
4298	AGENTX_OID(INETCIDRROUTEMETRIC1)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 12 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 12 }) / sizeof (uint32_t)), indices, 6, 0,
4299	mib_ipfroute)) == NULL((void *)0) \|\|
4300	(inetCidrRouteMetric2 = agentx_object(ipForward,
4301	AGENTX_OID(INETCIDRROUTEMETRIC2)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 13 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 13 }) / sizeof (uint32_t)), indices, 6, 0,
4302	mib_ipfroute)) == NULL((void *)0) \|\|
4303	(inetCidrRouteMetric3 = agentx_object(ipForward,
4304	AGENTX_OID(INETCIDRROUTEMETRIC3)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 14 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 14 }) / sizeof (uint32_t)), indices, 6, 0,
4305	mib_ipfroute)) == NULL((void *)0) \|\|
4306	(inetCidrRouteMetric4 = agentx_object(ipForward,
4307	AGENTX_OID(INETCIDRROUTEMETRIC4)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 15 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 15 }) / sizeof (uint32_t)), indices, 6, 0,
4308	mib_ipfroute)) == NULL((void *)0) \|\|
4309	(inetCidrRouteMetric5 = agentx_object(ipForward,
4310	AGENTX_OID(INETCIDRROUTEMETRIC5)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 16 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 16 }) / sizeof (uint32_t)), indices, 6, 0,
4311	mib_ipfroute)) == NULL((void *)0) \|\|
4312	(inetCidrRouteStatus = agentx_object(ipForward,
4313	AGENTX_OID(INETCIDRROUTESTATUS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 17 }, (sizeof( (uint32_t []) { 1, 3, 6, 1, 2, 1, 4, 24, 7, 1, 17 }) / sizeof (uint32_t)), indices, 6, 0,
4314	mib_ipfroute)) == NULL((void *)0))
4315	fatal("agentx_object");
4316
4317	/* UCD-DISKIO-MIB */
4318	if ((ucdDiskIOMIB = agentx_region(sac, AGENTX_OID(UCDDISKIOMIB)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15 }) / sizeof(uint32_t)),
4319	0)) == NULL((void *)0))
4320	fatal("agentx_region");
4321	if ((diskIOIdx = agentx_index_integer_dynamic(ucdDiskIOMIB,
4322	AGENTX_OID(DISKIOINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 1 }) / sizeof(uint32_t)))) == NULL((void *)0))
4323	fatal("agentx_index_integer_dynamic");
4324	if ((diskIOIndex = agentx_object(ucdDiskIOMIB, AGENTX_OID(DISKIOINDEX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 1 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 1 }) / sizeof(uint32_t)),
4325	&diskIOIdx, 1, 0, mib_diskio)) == NULL((void *)0) \|\|
4326	(diskIODevice = agentx_object(ucdDiskIOMIB,
4327	AGENTX_OID(DISKIODEVICE)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 2 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 2 }) / sizeof(uint32_t)), &diskIOIdx, 1, 0, mib_diskio)) == NULL((void *)0) \|\|
4328	(diskIONRead = agentx_object(ucdDiskIOMIB, AGENTX_OID(DISKIONREAD)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 3 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 3 }) / sizeof(uint32_t)),
4329	&diskIOIdx, 1, 0, mib_diskio)) == NULL((void *)0) \|\|
4330	(diskIONWritten = agentx_object(ucdDiskIOMIB,
4331	AGENTX_OID(DISKIONWRITTEN)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 4 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 4 }) / sizeof(uint32_t)), &diskIOIdx, 1, 0,
4332	mib_diskio)) == NULL((void *)0) \|\|
4333	(diskIOReads = agentx_object(ucdDiskIOMIB,
4334	AGENTX_OID(DISKIOREADS)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 5 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 5 }) / sizeof(uint32_t)), &diskIOIdx, 1, 0, mib_diskio)) == NULL((void *)0) \|\|
4335	(diskIOWrites = agentx_object(ucdDiskIOMIB,
4336	AGENTX_OID(DISKIOWRITES)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 6 }, (sizeof ((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 6 }) / sizeof(uint32_t)), &diskIOIdx, 1, 0, mib_diskio)) == NULL((void *)0) \|\|
4337	(diskIONReadX = agentx_object(ucdDiskIOMIB,
4338	AGENTX_OID(DISKIONREADX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 12 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 12 }) / sizeof(uint32_t)), &diskIOIdx, 1, 0, mib_diskio)) == NULL((void *)0) \|\|
4339	(diskIONWrittenX = agentx_object(ucdDiskIOMIB,
4340	AGENTX_OID(DISKIONWRITTENX)(uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 13 }, ( sizeof((uint32_t []) { 1, 3, 6, 1, 4, 1, 2021, 13, 15, 1, 1, 13 }) / sizeof(uint32_t)), &diskIOIdx, 1, 0,
4341	mib_diskio)) == NULL((void *)0))
4342	fatal("agentx_object");
4343
4344	if ((dot1dBridge = agentx_region(sac, AGENTX_OID(DOT1DBRIDGE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 17 }) / sizeof(uint32_t)),
4345	0)) == NULL((void *)0))
4346	fatal("agentx_region");
4347	if ((dot1dBaseNumPorts = agentx_object(dot1dBridge,
4348	AGENTX_OID(DOT1DBASENUMPORTS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 2 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 2 }) / sizeof(uint32_t)), NULL((void )0), 0, 0, mib_ifnumber)) == NULL((void )0) \|\|
4349	(dot1dBaseType = agentx_object(dot1dBridge,
4350	AGENTX_OID(DOT1DBASETYPE)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 3 }, (sizeof((uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 3 }) / sizeof(uint32_t)), NULL((void )0), 0, 0, mib_dot1basetype)) == NULL((void )0))
4351	fatal("agentx_object");
4352
4353	if ((dot1dBasePortIdx = agentx_index_integer_dynamic(dot1dBridge,
4354	AGENTX_OID(DOT1DBASEPORT)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 1 }) / sizeof(uint32_t )))) == NULL((void *)0))
4355	fatal("agentx_index_integer_dynamic");
4356	if ((dot1dBasePort = agentx_object(dot1dBridge,
4357	AGENTX_OID(DOT1DBASEPORT)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 1 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 1 }) / sizeof(uint32_t )), &dot1dBasePortIdx, 1, 0,
4358	mib_dot1dtable)) == NULL((void *)0) \|\|
4359	(dot1dBasePortIfIndex = agentx_object(dot1dBridge,
4360	AGENTX_OID(DOT1DBASEPORTIFINDEX)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 2 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 2 }) / sizeof(uint32_t )), &dot1dBasePortIdx, 1, 0,
4361	mib_dot1dtable)) == NULL((void *)0) \|\|
4362	(dot1dBasePortCircuit = agentx_object(dot1dBridge,
4363	AGENTX_OID(DOT1DBASEPORTCIRCUIT)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 3 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 3 }) / sizeof(uint32_t )), &dot1dBasePortIdx, 1, 0,
4364	mib_dot1dtable)) == NULL((void *)0) \|\|
4365	(dot1dBasePortDelayExceededDiscards = agentx_object(dot1dBridge,
4366	AGENTX_OID(DOT1DBASEPORTDELAYEXCEEDEDDISCARDS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 4 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 4 }) / sizeof(uint32_t )), &dot1dBasePortIdx,
4367	1, 0, mib_dot1dtable)) == NULL((void *)0) \|\|
4368	(dot1dBasePortMtuExceededDiscards = agentx_object(dot1dBridge,
4369	AGENTX_OID(DOT1DBASEPORTMTUEXCEEDEDDISCARDS)(uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 5 }, (sizeof(( uint32_t []) { 1, 3, 6, 1, 2, 1, 17, 1, 4, 1, 5 }) / sizeof(uint32_t )), &dot1dBasePortIdx,
4370	1, 0, mib_dot1dtable)) == NULL((void *)0))
4371	fatal("agentx_object");
4372
4373	if (daemonize) {
4374	log_init(0, LOG_DAEMON(3<<3));
4375	daemon(0, 0);
4376	}
4377	log_setverbose(verbose);
4378
4379	event_dispatch();
4380	}
4381
4382	#define LOG102410 10
4383	void
4384	pageshift_init(void)
4385	{
4386	long pagesize;
4387
4388	if ((pagesize = sysconf(_SC_PAGESIZE28)) == -1)
4389	fatal("sysconf(_SC_PAGESIZE)");
4390	while (pagesize > 1) {
4391	pageshift++;
4392	pagesize >>= 1;
4393	}
4394	/* we only need the amount of log(2)1024 for our conversion */
4395	pageshift -= LOG102410;
4396	}
4397
4398	void
4399	snmp_connect(struct agentx sa, void cookie, int close)
4400	{
4401	static int init = 0;
4402
4403	if (close) {
4404	event_del(&connev);
4405	return;
4406	}
4407
4408	if (agentxfd != -1) {
4409	/* Exit if snmpd(8) leaves */
4410	if (init)
4411	exit(0);
4412	agentx_connect(sa, agentxfd);
4413	event_set(&connev, agentxfd, EV_READ0x02 \| EV_PERSIST0x10,
4414	snmp_read, sa);
4415	event_add(&connev, NULL((void *)0));
4416	init = 1;
4417	} else
4418	snmp_tryconnect(-1, 0, sa);
4419	}
4420
4421	void
4422	snmp_tryconnect(int fd, short event, void *cookie)
4423	{
4424	struct timeval timeout = {3, 0};
4425	struct agentx *sa = cookie;
4426	struct sockaddr_un sun;
4427
4428	sun.sun_len = sizeof(sun);
4429	sun.sun_family = AF_UNIX1;
4430	strlcpy(sun.sun_path, AGENTX_MASTER_PATH"/var/agentx/master", sizeof(sun.sun_path));
4431
4432	if ((fd = socket(AF_UNIX1, SOCK_STREAM1, 0)) == -1 \|\|
4433	connect(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) {
4434	if (fd != -1)
4435	close(fd);
4436	log_warn("Failed to connect to snmpd");
4437	evtimer_set(&connev, snmp_tryconnect, sa)event_set(&connev, -1, 0, snmp_tryconnect, sa);
4438	evtimer_add(&connev, &timeout)event_add(&connev, &timeout);
4439	return;
4440	}
4441
4442	event_set(&connev, fd, EV_READ0x02 \| EV_PERSIST0x10, snmp_read, sa);
4443	event_add(&connev, NULL((void *)0));
4444
4445	agentx_connect(sa, fd);
4446	}
4447
4448	void
4449	snmp_read(int fd, short event, void *cookie)
4450	{
4451	struct agentx *sa = cookie;
4452
4453	agentx_read(sa);
4454	}
4455
4456	u_long
4457	smi_getticks(void)
4458	{
4459	return agentx_context_uptime(sac);
4460	}