1/*
2 * Copyright (c) 2001-2002
3 *	Fraunhofer Institute for Open Communication Systems (FhG Fokus).
4 *	All rights reserved.
5 *
6 * Author: Harti Brandt <harti@freebsd.org>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $Begemot: bsnmp/snmp_mibII/mibII_ipaddr.c,v 1.10 2005/10/04 11:21:35 brandt_h Exp $
30 *
31 * IP address table. This table is writeable!
32 *
33 * Writing to this table will add a new IP address to the interface.
34 * An address can be deleted with writing the interface index 0.
35 */
36#include "mibII.h"
37#include "mibII_oid.h"
38
39static const struct asn_oid
40	oid_ipAddrTable = OIDX_ipAddrTable;
41
42/*
43 * Be careful not to hold any pointers during the SET processing - the
44 * interface and address lists can be relocated at any time.
45 */
46struct update {
47	struct snmp_dependency dep;
48
49	uint32_t	set;
50	struct in_addr	addr;
51	struct in_addr	mask;
52	int		bcast;
53	u_int		ifindex;
54
55	uint32_t	rb;
56	struct in_addr	rb_mask;
57	struct in_addr	rb_bcast;
58};
59#define UPD_IFINDEX	0x0001
60#define UPD_MASK	0x0002
61#define UPD_BCAST	0x0004
62#define RB_CREATE	0x0001
63#define RB_DESTROY	0x0002
64#define RB_MODIFY	0x0004
65
66/*
67 * Create a new interface address
68 */
69static int
70create(struct update *upd)
71{
72	struct in_addr bcast;
73	struct mibifa *ifa;
74
75	if (!(upd->set & UPD_MASK)) {
76		if (IN_CLASSA(ntohl(upd->addr.s_addr)))
77			upd->mask.s_addr = htonl(IN_CLASSA_NET);
78		else if (IN_CLASSB(ntohl(upd->addr.s_addr)))
79			upd->mask.s_addr = htonl(IN_CLASSB_NET);
80		else if (IN_CLASSC(ntohl(upd->addr.s_addr)))
81			upd->mask.s_addr = htonl(IN_CLASSC_NET);
82		else
83			upd->mask.s_addr = 0xffffffff;
84	}
85
86	bcast.s_addr = upd->addr.s_addr & upd->mask.s_addr;
87	if (!(upd->set & UPD_BCAST) || upd->bcast) {
88		uint32_t tmp = ~ntohl(upd->mask.s_addr);
89		bcast.s_addr |= htonl(0xffffffff & ~tmp);
90	}
91
92	if ((ifa = mib_create_ifa(upd->ifindex, upd->addr, upd->mask, bcast))
93	    == NULL)
94		return (SNMP_ERR_GENERR);
95
96	upd->rb |= RB_CREATE;
97	return (SNMP_ERR_NOERROR);
98}
99
100/*
101 * Modify the netmask or broadcast address. The ifindex cannot be
102 * changed (obviously).
103 */
104static int
105modify(struct update *upd, struct mibifa *ifa)
106{
107	struct mibif *ifp;
108
109	if ((ifp = mib_find_if(ifa->ifindex)) == NULL)
110		return (SNMP_ERR_WRONG_VALUE);
111	if ((upd->set & UPD_IFINDEX) && upd->ifindex != ifa->ifindex)
112		return (SNMP_ERR_INCONS_VALUE);
113
114	upd->rb_mask = ifa->inmask;
115	upd->rb_bcast = ifa->inbcast;
116	if (((upd->set & UPD_MASK) && upd->mask.s_addr != ifa->inmask.s_addr) ||
117	    (upd->set & UPD_BCAST)) {
118		if (upd->set & UPD_MASK)
119			ifa->inmask = upd->mask;
120		if (upd->set & UPD_BCAST) {
121			ifa->inbcast.s_addr = ifa->inaddr.s_addr
122			    & ifa->inmask.s_addr;
123			if (upd->bcast)
124				ifa->inbcast.s_addr |= 0xffffffff
125				    & ~ifa->inmask.s_addr;
126		}
127		if (mib_modify_ifa(ifa)) {
128			syslog(LOG_ERR, "set netmask/bcast: %m");
129			ifa->inmask = upd->rb_mask;
130			ifa->inbcast = upd->rb_bcast;
131			mib_unmodify_ifa(ifa);
132			return (SNMP_ERR_GENERR);
133		}
134		upd->rb |= RB_MODIFY;
135	}
136	return (SNMP_ERR_NOERROR);
137}
138
139/*
140 * Destroy the given row in the table. We remove the address from the
141 * system, but keep the structure around for the COMMIT. It's deleted
142 * only in the FINISH operation.
143 */
144static int
145destroy(struct snmp_context *ctx __unused, struct update *upd,
146    struct mibifa *ifa)
147{
148	if (mib_destroy_ifa(ifa))
149		return (SNMP_ERR_GENERR);
150	upd->rb |= RB_DESTROY;
151	return (SNMP_ERR_NOERROR);
152}
153
154/*
155 * This function is called to commit/rollback a SET on an IpAddrEntry
156 */
157static int
158update_func(struct snmp_context *ctx, struct snmp_dependency *dep,
159    enum snmp_depop op)
160{
161	struct update *upd = (struct update *)dep;
162	struct mibifa *ifa;
163
164	switch (op) {
165
166	  case SNMP_DEPOP_COMMIT:
167		if ((ifa = mib_find_ifa(upd->addr)) == NULL) {
168			/* non existing entry - must have ifindex */
169			if (!(upd->set & UPD_IFINDEX))
170				return (SNMP_ERR_INCONS_NAME);
171			return (create(upd));
172		}
173		/* existing entry */
174		if ((upd->set & UPD_IFINDEX) && upd->ifindex == 0) {
175			/* delete */
176			return (destroy(ctx, upd, ifa));
177		}
178		/* modify entry */
179		return (modify(upd, ifa));
180
181	  case SNMP_DEPOP_ROLLBACK:
182		if ((ifa = mib_find_ifa(upd->addr)) == NULL) {
183			/* ups */
184			mib_iflist_bad = 1;
185			return (SNMP_ERR_NOERROR);
186		}
187		if (upd->rb & RB_CREATE) {
188			mib_uncreate_ifa(ifa);
189			return (SNMP_ERR_NOERROR);
190		}
191		if (upd->rb & RB_DESTROY) {
192			mib_undestroy_ifa(ifa);
193			return (SNMP_ERR_NOERROR);
194		}
195		if (upd->rb & RB_MODIFY) {
196			ifa->inmask = upd->rb_mask;
197			ifa->inbcast = upd->rb_bcast;
198			mib_unmodify_ifa(ifa);
199			return (SNMP_ERR_NOERROR);
200		}
201		return (SNMP_ERR_NOERROR);
202
203	  case SNMP_DEPOP_FINISH:
204		if ((upd->rb & RB_DESTROY) &&
205		    (ifa = mib_find_ifa(upd->addr)) != NULL &&
206		    (ifa->flags & MIBIFA_DESTROYED)) {
207			TAILQ_REMOVE(&mibifa_list, ifa, link);
208			free(ifa);
209		}
210		return (SNMP_ERR_NOERROR);
211	}
212	abort();
213}
214
215/**********************************************************************/
216/*
217 * ACTION
218 */
219int
220op_ipaddr(struct snmp_context *ctx, struct snmp_value *value,
221    u_int sub, u_int iidx, enum snmp_op op)
222{
223	asn_subid_t which;
224	struct mibifa *ifa;
225	struct update *upd;
226	struct asn_oid idx;
227	u_char ipaddr[4];
228
229	which = value->var.subs[sub - 1];
230
231	ifa = NULL;
232
233	switch (op) {
234
235	  case SNMP_OP_GETNEXT:
236		if ((ifa = NEXT_OBJECT_OID(&mibifa_list, &value->var, sub)) == NULL)
237			return (SNMP_ERR_NOSUCHNAME);
238		index_append(&value->var, sub, &ifa->index);
239		break;
240
241	  case SNMP_OP_GET:
242		if ((ifa = FIND_OBJECT_OID(&mibifa_list, &value->var, sub)) == NULL)
243			return (SNMP_ERR_NOSUCHNAME);
244		break;
245
246	  case SNMP_OP_SET:
247		if (index_decode(&value->var, sub, iidx, ipaddr))
248			return (SNMP_ERR_NO_CREATION);
249		ifa = FIND_OBJECT_OID(&mibifa_list, &value->var, sub);
250		idx.len = 4;
251		idx.subs[0] = ipaddr[0];
252		idx.subs[1] = ipaddr[1];
253		idx.subs[2] = ipaddr[2];
254		idx.subs[3] = ipaddr[3];
255
256		if ((upd = (struct update *)snmp_dep_lookup(ctx,
257		    &oid_ipAddrTable, &idx, sizeof(*upd), update_func)) == NULL)
258			return (SNMP_ERR_RES_UNAVAIL);
259
260		upd->addr.s_addr = htonl((ipaddr[0] << 24) | (ipaddr[1] << 16) |
261		    (ipaddr[2] << 8) | (ipaddr[3] << 0));
262
263		switch (which) {
264
265		  case LEAF_ipAdEntIfIndex:
266			if (upd->set & UPD_IFINDEX)
267				return (SNMP_ERR_INCONS_VALUE);
268			if (value->v.integer < 0 ||
269			    value->v.integer > 0x07fffffff)
270				return (SNMP_ERR_WRONG_VALUE);
271			if (ifa != NULL) {
272				if (ifa->ifindex != (u_int)value->v.integer &&
273				    value->v.integer != 0)
274					return (SNMP_ERR_INCONS_VALUE);
275			}
276			upd->set |= UPD_IFINDEX;
277			upd->ifindex = (u_int)value->v.integer;
278			break;
279
280		  case LEAF_ipAdEntNetMask:
281			if (upd->set & UPD_MASK)
282				return (SNMP_ERR_INCONS_VALUE);
283			upd->mask.s_addr = htonl((value->v.ipaddress[0] << 24)
284			    | (value->v.ipaddress[1] << 16)
285			    | (value->v.ipaddress[2] << 8)
286			    | (value->v.ipaddress[3] << 0));
287			upd->set |= UPD_MASK;
288			break;
289
290		  case LEAF_ipAdEntBcastAddr:
291			if (upd->set & UPD_BCAST)
292				return (SNMP_ERR_INCONS_VALUE);
293			if (value->v.integer != 0 && value->v.integer != 1)
294				return (SNMP_ERR_WRONG_VALUE);
295			upd->bcast = value->v.integer;
296			upd->set |= UPD_BCAST;
297			break;
298
299		}
300		return (SNMP_ERR_NOERROR);
301
302	  case SNMP_OP_ROLLBACK:
303	  case SNMP_OP_COMMIT:
304		return (SNMP_ERR_NOERROR);
305	}
306
307	switch (which) {
308
309	  case LEAF_ipAdEntAddr:
310		value->v.ipaddress[0] = ifa->index.subs[0];
311		value->v.ipaddress[1] = ifa->index.subs[1];
312		value->v.ipaddress[2] = ifa->index.subs[2];
313		value->v.ipaddress[3] = ifa->index.subs[3];
314		break;
315
316	  case LEAF_ipAdEntIfIndex:
317		if (ifa->flags & MIBIFA_DESTROYED)
318			value->v.integer = 0;
319		else
320			value->v.integer = ifa->ifindex;
321		break;
322
323	  case LEAF_ipAdEntNetMask:
324		value->v.ipaddress[0] = (ntohl(ifa->inmask.s_addr) >> 24) & 0xff;
325		value->v.ipaddress[1] = (ntohl(ifa->inmask.s_addr) >> 16) & 0xff;
326		value->v.ipaddress[2] = (ntohl(ifa->inmask.s_addr) >>  8) & 0xff;
327		value->v.ipaddress[3] = (ntohl(ifa->inmask.s_addr) >>  0) & 0xff;
328		break;
329
330	  case LEAF_ipAdEntBcastAddr:
331		value->v.integer = ntohl(ifa->inbcast.s_addr) & 1;
332		break;
333
334
335	  case LEAF_ipAdEntReasmMaxSize:
336		value->v.integer = 65535;
337		break;
338	}
339	return (SNMP_ERR_NOERROR);
340}
341