xref: /dragonfly/usr.sbin/pfctl/pfctl_radix.c (revision d4ef6694) 
1 /*	$OpenBSD: pfctl_radix.c,v 1.28 2007/12/05 12:01:47 chl Exp $ */
2 
3 /*
4  * Copyright (c) 2002 Cedric Berger
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  *    - Redistributions of source code must retain the above copyright
12  *      notice, this list of conditions and the following disclaimer.
13  *    - Redistributions in binary form must reproduce the above
14  *      copyright notice, this list of conditions and the following
15  *      disclaimer in the documentation and/or other materials provided
16  *      with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
26  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
28  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  * POSSIBILITY OF SUCH DAMAGE.
30  *
31  */
32 
33 #include <sys/types.h>
34 #include <sys/ioctl.h>
35 #include <sys/socket.h>
36 
37 #include <net/if.h>
38 #include <net/pf/pfvar.h>
39 
40 #include <errno.h>
41 #include <string.h>
42 #include <ctype.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <limits.h>
46 #include <err.h>
47 
48 #include "pfctl.h"
49 
50 #define BUF_SIZE 256
51 
52 extern int dev_fd;
53 
54 static int	 pfr_next_token(char buf[], FILE *);
55 
56 
57 int
58 pfr_clr_tables(struct pfr_table *filter, int *ndel, int flags)
59 {
60 	struct pfioc_table io;
61 
62 	bzero(&io, sizeof io);
63 	io.pfrio_flags = flags;
64 	if (filter != NULL)
65 		io.pfrio_table = *filter;
66 	if (ioctl(dev_fd, DIOCRCLRTABLES, &io))
67 		return (-1);
68 	if (ndel != NULL)
69 		*ndel = io.pfrio_ndel;
70 	return (0);
71 }
72 
73 int
74 pfr_add_tables(struct pfr_table *tbl, int size, int *nadd, int flags)
75 {
76 	struct pfioc_table io;
77 
78 	if (size < 0 || (size && tbl == NULL)) {
79 		errno = EINVAL;
80 		return (-1);
81 	}
82 	bzero(&io, sizeof io);
83 	io.pfrio_flags = flags;
84 	io.pfrio_buffer = tbl;
85 	io.pfrio_esize = sizeof(*tbl);
86 	io.pfrio_size = size;
87 	if (ioctl(dev_fd, DIOCRADDTABLES, &io))
88 		return (-1);
89 	if (nadd != NULL)
90 		*nadd = io.pfrio_nadd;
91 	return (0);
92 }
93 
94 int
95 pfr_del_tables(struct pfr_table *tbl, int size, int *ndel, int flags)
96 {
97 	struct pfioc_table io;
98 
99 	if (size < 0 || (size && tbl == NULL)) {
100 		errno = EINVAL;
101 		return (-1);
102 	}
103 	bzero(&io, sizeof io);
104 	io.pfrio_flags = flags;
105 	io.pfrio_buffer = tbl;
106 	io.pfrio_esize = sizeof(*tbl);
107 	io.pfrio_size = size;
108 	if (ioctl(dev_fd, DIOCRDELTABLES, &io))
109 		return (-1);
110 	if (ndel != NULL)
111 		*ndel = io.pfrio_ndel;
112 	return (0);
113 }
114 
115 int
116 pfr_get_tables(struct pfr_table *filter, struct pfr_table *tbl, int *size,
117 	int flags)
118 {
119 	struct pfioc_table io;
120 
121 	if (size == NULL || *size < 0 || (*size && tbl == NULL)) {
122 		errno = EINVAL;
123 		return (-1);
124 	}
125 	bzero(&io, sizeof io);
126 	io.pfrio_flags = flags;
127 	if (filter != NULL)
128 		io.pfrio_table = *filter;
129 	io.pfrio_buffer = tbl;
130 	io.pfrio_esize = sizeof(*tbl);
131 	io.pfrio_size = *size;
132 	if (ioctl(dev_fd, DIOCRGETTABLES, &io))
133 		return (-1);
134 	*size = io.pfrio_size;
135 	return (0);
136 }
137 
138 int
139 pfr_get_tstats(struct pfr_table *filter, struct pfr_tstats *tbl, int *size,
140 	int flags)
141 {
142 	struct pfioc_table io;
143 
144 	if (size == NULL || *size < 0 || (*size && tbl == NULL)) {
145 		errno = EINVAL;
146 		return (-1);
147 	}
148 	bzero(&io, sizeof io);
149 	io.pfrio_flags = flags;
150 	if (filter != NULL)
151 		io.pfrio_table = *filter;
152 	io.pfrio_buffer = tbl;
153 	io.pfrio_esize = sizeof(*tbl);
154 	io.pfrio_size = *size;
155 	if (ioctl(dev_fd, DIOCRGETTSTATS, &io))
156 		return (-1);
157 	*size = io.pfrio_size;
158 	return (0);
159 }
160 
161 int
162 pfr_clr_addrs(struct pfr_table *tbl, int *ndel, int flags)
163 {
164 	struct pfioc_table io;
165 
166 	if (tbl == NULL) {
167 		errno = EINVAL;
168 		return (-1);
169 	}
170 	bzero(&io, sizeof io);
171 	io.pfrio_flags = flags;
172 	io.pfrio_table = *tbl;
173 	if (ioctl(dev_fd, DIOCRCLRADDRS, &io))
174 		return (-1);
175 	if (ndel != NULL)
176 		*ndel = io.pfrio_ndel;
177 	return (0);
178 }
179 
180 int
181 pfr_add_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
182     int *nadd, int flags)
183 {
184 	struct pfioc_table io;
185 
186 	if (tbl == NULL || size < 0 || (size && addr == NULL)) {
187 		errno = EINVAL;
188 		return (-1);
189 	}
190 	bzero(&io, sizeof io);
191 	io.pfrio_flags = flags;
192 	io.pfrio_table = *tbl;
193 	io.pfrio_buffer = addr;
194 	io.pfrio_esize = sizeof(*addr);
195 	io.pfrio_size = size;
196 	if (ioctl(dev_fd, DIOCRADDADDRS, &io))
197 		return (-1);
198 	if (nadd != NULL)
199 		*nadd = io.pfrio_nadd;
200 	return (0);
201 }
202 
203 int
204 pfr_del_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
205     int *ndel, int flags)
206 {
207 	struct pfioc_table io;
208 
209 	if (tbl == NULL || size < 0 || (size && addr == NULL)) {
210 		errno = EINVAL;
211 		return (-1);
212 	}
213 	bzero(&io, sizeof io);
214 	io.pfrio_flags = flags;
215 	io.pfrio_table = *tbl;
216 	io.pfrio_buffer = addr;
217 	io.pfrio_esize = sizeof(*addr);
218 	io.pfrio_size = size;
219 	if (ioctl(dev_fd, DIOCRDELADDRS, &io))
220 		return (-1);
221 	if (ndel != NULL)
222 		*ndel = io.pfrio_ndel;
223 	return (0);
224 }
225 
226 int
227 pfr_set_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
228     int *size2, int *nadd, int *ndel, int *nchange, int flags)
229 {
230 	struct pfioc_table io;
231 
232 	if (tbl == NULL || size < 0 || (size && addr == NULL)) {
233 		errno = EINVAL;
234 		return (-1);
235 	}
236 	bzero(&io, sizeof io);
237 	io.pfrio_flags = flags;
238 	io.pfrio_table = *tbl;
239 	io.pfrio_buffer = addr;
240 	io.pfrio_esize = sizeof(*addr);
241 	io.pfrio_size = size;
242 	io.pfrio_size2 = (size2 != NULL) ? *size2 : 0;
243 	if (ioctl(dev_fd, DIOCRSETADDRS, &io))
244 		return (-1);
245 	if (nadd != NULL)
246 		*nadd = io.pfrio_nadd;
247 	if (ndel != NULL)
248 		*ndel = io.pfrio_ndel;
249 	if (nchange != NULL)
250 		*nchange = io.pfrio_nchange;
251 	if (size2 != NULL)
252 		*size2 = io.pfrio_size2;
253 	return (0);
254 }
255 
256 int
257 pfr_get_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int *size,
258     int flags)
259 {
260 	struct pfioc_table io;
261 
262 	if (tbl == NULL || size == NULL || *size < 0 ||
263 	    (*size && addr == NULL)) {
264 		errno = EINVAL;
265 		return (-1);
266 	}
267 	bzero(&io, sizeof io);
268 	io.pfrio_flags = flags;
269 	io.pfrio_table = *tbl;
270 	io.pfrio_buffer = addr;
271 	io.pfrio_esize = sizeof(*addr);
272 	io.pfrio_size = *size;
273 	if (ioctl(dev_fd, DIOCRGETADDRS, &io))
274 		return (-1);
275 	*size = io.pfrio_size;
276 	return (0);
277 }
278 
279 int
280 pfr_get_astats(struct pfr_table *tbl, struct pfr_astats *addr, int *size,
281     int flags)
282 {
283 	struct pfioc_table io;
284 
285 	if (tbl == NULL || size == NULL || *size < 0 ||
286 	    (*size && addr == NULL)) {
287 		errno = EINVAL;
288 		return (-1);
289 	}
290 	bzero(&io, sizeof io);
291 	io.pfrio_flags = flags;
292 	io.pfrio_table = *tbl;
293 	io.pfrio_buffer = addr;
294 	io.pfrio_esize = sizeof(*addr);
295 	io.pfrio_size = *size;
296 	if (ioctl(dev_fd, DIOCRGETASTATS, &io))
297 		return (-1);
298 	*size = io.pfrio_size;
299 	return (0);
300 }
301 
302 int
303 pfr_clr_tstats(struct pfr_table *tbl, int size, int *nzero, int flags)
304 {
305 	struct pfioc_table io;
306 
307 	if (size < 0 || (size && !tbl)) {
308 		errno = EINVAL;
309 		return (-1);
310 	}
311 	bzero(&io, sizeof io);
312 	io.pfrio_flags = flags;
313 	io.pfrio_buffer = tbl;
314 	io.pfrio_esize = sizeof(*tbl);
315 	io.pfrio_size = size;
316 	if (ioctl(dev_fd, DIOCRCLRTSTATS, &io))
317 		return (-1);
318 	if (nzero)
319 		*nzero = io.pfrio_nzero;
320 	return (0);
321 }
322 
323 int
324 pfr_tst_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
325     int *nmatch, int flags)
326 {
327 	struct pfioc_table io;
328 
329 	if (tbl == NULL || size < 0 || (size && addr == NULL)) {
330 		errno = EINVAL;
331 		return (-1);
332 	}
333 	bzero(&io, sizeof io);
334 	io.pfrio_flags = flags;
335 	io.pfrio_table = *tbl;
336 	io.pfrio_buffer = addr;
337 	io.pfrio_esize = sizeof(*addr);
338 	io.pfrio_size = size;
339 	if (ioctl(dev_fd, DIOCRTSTADDRS, &io))
340 		return (-1);
341 	if (nmatch)
342 		*nmatch = io.pfrio_nmatch;
343 	return (0);
344 }
345 
346 int
347 pfr_ina_define(struct pfr_table *tbl, struct pfr_addr *addr, int size,
348     int *nadd, int *naddr, int ticket, int flags)
349 {
350 	struct pfioc_table io;
351 
352 	if (tbl == NULL || size < 0 || (size && addr == NULL)) {
353 		errno = EINVAL;
354 		return (-1);
355 	}
356 	bzero(&io, sizeof io);
357 	io.pfrio_flags = flags;
358 	io.pfrio_table = *tbl;
359 	io.pfrio_buffer = addr;
360 	io.pfrio_esize = sizeof(*addr);
361 	io.pfrio_size = size;
362 	io.pfrio_ticket = ticket;
363 	if (ioctl(dev_fd, DIOCRINADEFINE, &io))
364 		return (-1);
365 	if (nadd != NULL)
366 		*nadd = io.pfrio_nadd;
367 	if (naddr != NULL)
368 		*naddr = io.pfrio_naddr;
369 	return (0);
370 }
371 
372 /* interface management code */
373 
374 int
375 pfi_get_ifaces(const char *filter, struct pfi_kif *buf, int *size)
376 {
377 	struct pfioc_iface io;
378 
379 	if (size == NULL || *size < 0 || (*size && buf == NULL)) {
380 		errno = EINVAL;
381 		return (-1);
382 	}
383 	bzero(&io, sizeof io);
384 	if (filter != NULL)
385 		if (strlcpy(io.pfiio_name, filter, sizeof(io.pfiio_name)) >=
386 		    sizeof(io.pfiio_name)) {
387 			errno = EINVAL;
388 			return (-1);
389 		}
390 	io.pfiio_buffer = buf;
391 	io.pfiio_esize = sizeof(*buf);
392 	io.pfiio_size = *size;
393 	if (ioctl(dev_fd, DIOCIGETIFACES, &io))
394 		return (-1);
395 	*size = io.pfiio_size;
396 	return (0);
397 }
398 
399 /* buffer management code */
400 
401 size_t buf_esize[PFRB_MAX] = { 0,
402 	sizeof(struct pfr_table), sizeof(struct pfr_tstats),
403 	sizeof(struct pfr_addr), sizeof(struct pfr_astats),
404 	sizeof(struct pfi_kif), sizeof(struct pfioc_trans_e)
405 };
406 
407 /*
408  * add one element to the buffer
409  */
410 int
411 pfr_buf_add(struct pfr_buffer *b, const void *e)
412 {
413 	size_t bs;
414 
415 	if (b == NULL || b->pfrb_type <= 0 || b->pfrb_type >= PFRB_MAX ||
416 	    e == NULL) {
417 		errno = EINVAL;
418 		return (-1);
419 	}
420 	bs = buf_esize[b->pfrb_type];
421 	if (b->pfrb_size == b->pfrb_msize)
422 		if (pfr_buf_grow(b, 0))
423 			return (-1);
424 	memcpy(((caddr_t)b->pfrb_caddr) + bs * b->pfrb_size, e, bs);
425 	b->pfrb_size++;
426 	return (0);
427 }
428 
429 /*
430  * return next element of the buffer (or first one if prev is NULL)
431  * see PFRB_FOREACH macro
432  */
433 const void *
434 pfr_buf_next(struct pfr_buffer *b, const void *prev)
435 {
436 	size_t bs;
437 
438 	if (b == NULL || b->pfrb_type <= 0 || b->pfrb_type >= PFRB_MAX)
439 		return (NULL);
440 	if (b->pfrb_size == 0)
441 		return (NULL);
442 	if (prev == NULL)
443 		return (b->pfrb_caddr);
444 	bs = buf_esize[b->pfrb_type];
445 	if ((((c_caddr_t)prev)-((c_caddr_t)b->pfrb_caddr)) / bs + 1 >=
446 	    (size_t)b->pfrb_size)
447 		return (NULL);
448 	return (((c_caddr_t)prev) + bs);
449 }
450 
451 /*
452  * minsize:
453  *    0: make the buffer somewhat bigger
454  *    n: make room for "n" entries in the buffer
455  */
456 int
457 pfr_buf_grow(struct pfr_buffer *b, int minsize)
458 {
459 	caddr_t p;
460 	size_t bs;
461 
462 	if (b == NULL || b->pfrb_type <= 0 || b->pfrb_type >= PFRB_MAX) {
463 		errno = EINVAL;
464 		return (-1);
465 	}
466 	if (minsize != 0 && minsize <= b->pfrb_msize)
467 		return (0);
468 	bs = buf_esize[b->pfrb_type];
469 	if (!b->pfrb_msize) {
470 		if (minsize < 64)
471 			minsize = 64;
472 		b->pfrb_caddr = calloc(bs, minsize);
473 		if (b->pfrb_caddr == NULL)
474 			return (-1);
475 		b->pfrb_msize = minsize;
476 	} else {
477 		if (minsize == 0)
478 			minsize = b->pfrb_msize * 2;
479 		if (minsize < 0 || (size_t)minsize >= SIZE_T_MAX / bs) {
480 			/* msize overflow */
481 			errno = ENOMEM;
482 			return (-1);
483 		}
484 		p = realloc(b->pfrb_caddr, minsize * bs);
485 		if (p == NULL)
486 			return (-1);
487 		bzero(p + b->pfrb_msize * bs, (minsize - b->pfrb_msize) * bs);
488 		b->pfrb_caddr = p;
489 		b->pfrb_msize = minsize;
490 	}
491 	return (0);
492 }
493 
494 /*
495  * reset buffer and free memory.
496  */
497 void
498 pfr_buf_clear(struct pfr_buffer *b)
499 {
500 	if (b == NULL)
501 		return;
502 	if (b->pfrb_caddr != NULL)
503 		free(b->pfrb_caddr);
504 	b->pfrb_caddr = NULL;
505 	b->pfrb_size = b->pfrb_msize = 0;
506 }
507 
508 int
509 pfr_buf_load(struct pfr_buffer *b, char *file, int nonetwork,
510     int (*append_addr)(struct pfr_buffer *, char *, int))
511 {
512 	FILE	*fp;
513 	char	 buf[BUF_SIZE];
514 	int	 rv;
515 
516 	if (file == NULL)
517 		return (0);
518 	if (!strcmp(file, "-"))
519 		fp = stdin;
520 	else {
521 		fp = pfctl_fopen(file, "r");
522 		if (fp == NULL)
523 			return (-1);
524 	}
525 	while ((rv = pfr_next_token(buf, fp)) == 1)
526 		if (append_addr(b, buf, nonetwork)) {
527 			rv = -1;
528 			break;
529 		}
530 	if (fp != stdin)
531 		fclose(fp);
532 	return (rv);
533 }
534 
535 int
536 pfr_next_token(char buf[BUF_SIZE], FILE *fp)
537 {
538 	static char	next_ch = ' ';
539 	int		i = 0;
540 
541 	for (;;) {
542 		/* skip spaces */
543 		while (isspace(next_ch) && !feof(fp))
544 			next_ch = fgetc(fp);
545 		/* remove from '#' until end of line */
546 		if (next_ch == '#')
547 			while (!feof(fp)) {
548 				next_ch = fgetc(fp);
549 				if (next_ch == '\n')
550 					break;
551 			}
552 		else
553 			break;
554 	}
555 	if (feof(fp)) {
556 		next_ch = ' ';
557 		return (0);
558 	}
559 	do {
560 		if (i < BUF_SIZE)
561 			buf[i++] = next_ch;
562 		next_ch = fgetc(fp);
563 	} while (!feof(fp) && !isspace(next_ch));
564 	if (i >= BUF_SIZE) {
565 		errno = EINVAL;
566 		return (-1);
567 	}
568 	buf[i] = '\0';
569 	return (1);
570 }
571 
572 const char *
573 pfr_strerror(int errnum)
574 {
575 	switch (errnum) {
576 	case ESRCH:
577 		return "Table does not exist";
578 	case ENOENT:
579 		return "Anchor or Ruleset does not exist";
580 	default:
581 		return strerror(errnum);
582 	}
583 }
584