Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/tcpdump/print-pfsync.c	Lines:	0	111	0.0 %
Date:	2017-11-07	Branches:	0	51	0.0 %


/*	$OpenBSD: print-pfsync.c,v 1.43 2017/01/20 09:36:42 claudio Exp $	*/

/*
 * Copyright (c) 2002 Michael Shalayeff
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/time.h>
#include <sys/socket.h>
#include <sys/file.h>
#include <sys/ioctl.h>

#ifdef __STDC__
struct rtentry;
#endif
#include <net/if.h>

#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/ip_ipsp.h>

#include <net/pfvar.h>
#include <net/if_pfsync.h>

#include <ctype.h>
#include <netdb.h>
#include <pcap.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <vis.h>

#include "interface.h"
#include "addrtoname.h"
#include "pfctl_parser.h"
#include "pfctl.h"

void	pfsync_print(struct pfsync_header *, const u_char *, int);

void
pfsync_if_print(u_char *user, const struct pcap_pkthdr *h,
     const u_char *p)
{
	u_int caplen = h->caplen;

	ts_print(&h->ts);

	if (caplen < PFSYNC_HDRLEN) {
		printf("[|pfsync]");
		goto out;
	}

	pfsync_print((struct pfsync_header *)p,
	    p + sizeof(struct pfsync_header),
	    caplen - sizeof(struct pfsync_header));
out:
	if (xflag) {
		default_print((const u_char *)p, caplen);
	}
	putchar('\n');
}

void
pfsync_ip_print(const u_char *bp, u_int len, const u_char *bp2)
{
	struct pfsync_header *hdr = (struct pfsync_header *)bp;
	struct ip *ip = (struct ip *)bp2;

	if (vflag)
		printf("%s > %s: ", ipaddr_string(&ip->ip_src),
		    ipaddr_string(&ip->ip_dst));
	else
		printf("%s: ", ipaddr_string(&ip->ip_src));

	if (len < PFSYNC_HDRLEN)
		printf("[|pfsync]");
	else
		pfsync_print(hdr, bp + sizeof(struct pfsync_header),
		    len - sizeof(struct pfsync_header));
	putchar('\n');
}

const char *actnames[] = { PFSYNC_ACTIONS };

struct pfsync_actions {
	size_t len;
	int (*print)(int, const void *);
};

int	pfsync_print_clr(int, const void *);
int	pfsync_print_state(int, const void *);
int	pfsync_print_ins_ack(int, const void *);
int	pfsync_print_upd_c(int, const void *);
int	pfsync_print_upd_req(int, const void *);
int	pfsync_print_del_c(int, const void *);
int	pfsync_print_bus(int, const void *);
int	pfsync_print_tdb(int, const void *);
int	pfsync_print_eof(int, const void *);

struct pfsync_actions actions[] = {
	{ sizeof(struct pfsync_clr),		pfsync_print_clr },
	{ 0,					NULL },
	{ sizeof(struct pfsync_ins_ack),	pfsync_print_ins_ack },
	{ 0,					NULL },
	{ sizeof(struct pfsync_upd_c),		pfsync_print_upd_c },
	{ sizeof(struct pfsync_upd_req),	pfsync_print_upd_req },
	{ sizeof(struct pfsync_state),		pfsync_print_state },
	{ sizeof(struct pfsync_del_c),		pfsync_print_del_c },
	{ 0,					NULL },
	{ 0,					NULL },
	{ sizeof(struct pfsync_bus),		pfsync_print_bus },
	{ 0,					NULL },
	{ 0,					pfsync_print_eof },
	{ sizeof(struct pfsync_state),		pfsync_print_state },
	{ sizeof(struct pfsync_state),		pfsync_print_state },
	{ sizeof(struct pfsync_tdb),		pfsync_print_tdb },
};

void
pfsync_print(struct pfsync_header *hdr, const u_char *bp, int len)
{
	struct pfsync_subheader *subh;
	int count, plen, alen, flags = 0;
	int i;

	plen = ntohs(hdr->len);

	printf("PFSYNCv%d len %d", hdr->version, plen);

	if (hdr->version != PFSYNC_VERSION)
		return;

	plen -= sizeof(*hdr);

	if (vflag)
		flags |= PF_OPT_VERBOSE;
	if (vflag > 1)
		flags |= PF_OPT_VERBOSE2;
	if (!nflag)
		flags |= PF_OPT_USEDNS;

	while (plen > 0) {
		if (len < sizeof(*subh))
			break;

		subh = (struct pfsync_subheader *)bp;
		bp += sizeof(*subh);
		len -= sizeof(*subh);
		plen -= sizeof(*subh);

		if (subh->action >= PFSYNC_ACT_MAX) {
			printf("\n    act UNKNOWN id %d", subh->action);
			return;
		}

		count = ntohs(subh->count);
		printf("\n    act %s count %d", actnames[subh->action], count);
		alen = actions[subh->action].len;

		if (actions[subh->action].print == NULL) {
			printf("\n    unimplemented action");
			return;
		}

		for (i = 0; i < count; i++) {
			if (len < alen) {
				len = 0;
				break;
			}

			if (actions[subh->action].print(flags, bp) != 0)
				return;

			bp += alen;
			len -= alen;
			plen -= alen;
		}
	}

	if (plen > 0) {
		printf("\n    ...");
		return;
	}
	if (plen < 0) {
		printf("\n    invalid header length");
		return;
	}
	if (len > 0)
		printf("\n    invalid packet length");
}

int
pfsync_print_clr(int flags, const void *bp)
{
	const struct pfsync_clr *clr = bp;
	char ifname[IFNAMSIZ * 4 + 1];
	char *cp = ifname;
	int i;

	printf("\n\tcreatorid: %08x", htonl(clr->creatorid));
	if (clr->ifname[0] != '\0') {
		/* Treat clr->ifname as untrusted input. */
		for (i = 0; i < IFNAMSIZ && clr->ifname[i] != '\0'; i++)
			cp = vis(cp, clr->ifname[i], VIS_WHITE, 0);
		printf(" interface: %s", ifname);
	}

	return (0);
}

int
pfsync_print_state(int flags, const void *bp)
{
	struct pfsync_state *st = (struct pfsync_state *)bp;
	putchar('\n');
	print_state(st, flags);
	return (0);
}

int
pfsync_print_ins_ack(int flags, const void *bp)
{
	const struct pfsync_ins_ack *iack = bp;

	printf("\n\tid: %016llx creatorid: %08x", betoh64(iack->id),
	    ntohl(iack->creatorid));

	return (0);
}

int
pfsync_print_upd_c(int flags, const void *bp)
{
	const struct pfsync_upd_c *u = bp;

	printf("\n\tid: %016llx creatorid: %08x", betoh64(u->id),
	    ntohl(u->creatorid));

	return (0);
}

int
pfsync_print_upd_req(int flags, const void *bp)
{
	const struct pfsync_upd_req *ur = bp;

	printf("\n\tid: %016llx creatorid: %08x", betoh64(ur->id),
	    ntohl(ur->creatorid));

	return (0);
}

int
pfsync_print_del_c(int flags, const void *bp)
{
	const struct pfsync_del_c *d = bp;

	printf("\n\tid: %016llx creatorid: %08x", betoh64(d->id),
	    ntohl(d->creatorid));

	return (0);
}

int
pfsync_print_bus(int flags, const void *bp)
{
	const struct pfsync_bus *b = bp;
	u_int32_t endtime;
	int min, sec;
	const char *status;

	endtime = ntohl(b->endtime);
	sec = endtime % 60;
	endtime /= 60;
	min = endtime % 60;
	endtime /= 60;

	switch (b->status) {
	case PFSYNC_BUS_START:
		status = "start";
		break;
	case PFSYNC_BUS_END:
		status = "end";
		break;
	default:
		status = "UNKNOWN";
		break;
	}

	printf("\n\tcreatorid: %08x age: %.2u:%.2u:%.2u status: %s",
	    htonl(b->creatorid), endtime, min, sec, status);

	return (0);
}

int
pfsync_print_tdb(int flags, const void *bp)
{
	const struct pfsync_tdb *t = bp;

	printf("\n\tspi: 0x%08x rpl: %llu cur_bytes: %llu",
	    ntohl(t->spi), betoh64(t->rpl), betoh64(t->cur_bytes));

	return (0);
}

int
pfsync_print_eof(int flags, const void *bp)
{
	return (1);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: print-pfsync.c,v 1.43 2017/01/20 09:36:42 claudio Exp $ */
2
3			/*
4			* Copyright (c) 2002 Michael Shalayeff
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			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			*
16			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17			* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19			* IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,
20			* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21			* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22			* SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
24			* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
25			* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26			* THE POSSIBILITY OF SUCH DAMAGE.
27			*/
28
29			#include <sys/time.h>
30			#include <sys/socket.h>
31			#include <sys/file.h>
32			#include <sys/ioctl.h>
33
34			#ifdef __STDC__
35			struct rtentry;
36			#endif
37			#include <net/if.h>
38
39			#include <netinet/in.h>
40			#include <netinet/ip.h>
41			#include <netinet/ip_ipsp.h>
42
43			#include <net/pfvar.h>
44			#include <net/if_pfsync.h>
45
46			#include <ctype.h>
47			#include <netdb.h>
48			#include <pcap.h>
49			#include <signal.h>
50			#include <stdio.h>
51			#include <string.h>
52			#include <vis.h>
53
54			#include "interface.h"
55			#include "addrtoname.h"
56			#include "pfctl_parser.h"
57			#include "pfctl.h"
58
59			void pfsync_print(struct pfsync_header , const u_char , int);
60
61			void
62			pfsync_if_print(u_char user, const struct pcap_pkthdr h,
63			const u_char *p)
64			{
65			u_int caplen = h->caplen;
66
67			ts_print(&h->ts);
68
69			if (caplen < PFSYNC_HDRLEN) {
70			printf("[\|pfsync]");
71			goto out;
72			}
73
74			pfsync_print((struct pfsync_header *)p,
75			p + sizeof(struct pfsync_header),
76			caplen - sizeof(struct pfsync_header));
77			out:
78			if (xflag) {
79			default_print((const u_char *)p, caplen);
80			}
81			putchar('\n');
82			}
83
84			void
85			pfsync_ip_print(const u_char bp, u_int len, const u_char bp2)
86			{
87			struct pfsync_header hdr = (struct pfsync_header )bp;
88			struct ip ip = (struct ip )bp2;
89
90			if (vflag)
91			printf("%s > %s: ", ipaddr_string(&ip->ip_src),
92			ipaddr_string(&ip->ip_dst));
93			else
94			printf("%s: ", ipaddr_string(&ip->ip_src));
95
96			if (len < PFSYNC_HDRLEN)
97			printf("[\|pfsync]");
98			else
99			pfsync_print(hdr, bp + sizeof(struct pfsync_header),
100			len - sizeof(struct pfsync_header));
101			putchar('\n');
102			}
103
104			const char *actnames[] = { PFSYNC_ACTIONS };
105
106			struct pfsync_actions {
107			size_t len;
108			int (print)(int, const void );
109			};
110
111			int pfsync_print_clr(int, const void *);
112			int pfsync_print_state(int, const void *);
113			int pfsync_print_ins_ack(int, const void *);
114			int pfsync_print_upd_c(int, const void *);
115			int pfsync_print_upd_req(int, const void *);
116			int pfsync_print_del_c(int, const void *);
117			int pfsync_print_bus(int, const void *);
118			int pfsync_print_tdb(int, const void *);
119			int pfsync_print_eof(int, const void *);
120
121			struct pfsync_actions actions[] = {
122			{ sizeof(struct pfsync_clr), pfsync_print_clr },
123			{ 0, NULL },
124			{ sizeof(struct pfsync_ins_ack), pfsync_print_ins_ack },
125			{ 0, NULL },
126			{ sizeof(struct pfsync_upd_c), pfsync_print_upd_c },
127			{ sizeof(struct pfsync_upd_req), pfsync_print_upd_req },
128			{ sizeof(struct pfsync_state), pfsync_print_state },
129			{ sizeof(struct pfsync_del_c), pfsync_print_del_c },
130			{ 0, NULL },
131			{ 0, NULL },
132			{ sizeof(struct pfsync_bus), pfsync_print_bus },
133			{ 0, NULL },
134			{ 0, pfsync_print_eof },
135			{ sizeof(struct pfsync_state), pfsync_print_state },
136			{ sizeof(struct pfsync_state), pfsync_print_state },
137			{ sizeof(struct pfsync_tdb), pfsync_print_tdb },
138			};
139
140			void
141			pfsync_print(struct pfsync_header hdr, const u_char bp, int len)
142			{
143			struct pfsync_subheader *subh;
144			int count, plen, alen, flags = 0;
145			int i;
146
147			plen = ntohs(hdr->len);
148
149			printf("PFSYNCv%d len %d", hdr->version, plen);
150
151			if (hdr->version != PFSYNC_VERSION)
152			return;
153
154			plen -= sizeof(*hdr);
155
156			if (vflag)
157			flags \|= PF_OPT_VERBOSE;
158			if (vflag > 1)
159			flags \|= PF_OPT_VERBOSE2;
160			if (!nflag)
161			flags \|= PF_OPT_USEDNS;
162
163			while (plen > 0) {
164			if (len < sizeof(*subh))
165			break;
166
167			subh = (struct pfsync_subheader *)bp;
168			bp += sizeof(*subh);
169			len -= sizeof(*subh);
170			plen -= sizeof(*subh);
171
172			if (subh->action >= PFSYNC_ACT_MAX) {
173			printf("\n act UNKNOWN id %d", subh->action);
174			return;
175			}
176
177			count = ntohs(subh->count);
178			printf("\n act %s count %d", actnames[subh->action], count);
179			alen = actions[subh->action].len;
180
181			if (actions[subh->action].print == NULL) {
182			printf("\n unimplemented action");
183			return;
184			}
185
186			for (i = 0; i < count; i++) {
187			if (len < alen) {
188			len = 0;
189			break;
190			}
191
192			if (actions[subh->action].print(flags, bp) != 0)
193			return;
194
195			bp += alen;
196			len -= alen;
197			plen -= alen;
198			}
199			}
200
201			if (plen > 0) {
202			printf("\n ...");
203			return;
204			}
205			if (plen < 0) {
206			printf("\n invalid header length");
207			return;
208			}
209			if (len > 0)
210			printf("\n invalid packet length");
211			}
212
213			int
214			pfsync_print_clr(int flags, const void *bp)
215			{
216			const struct pfsync_clr *clr = bp;
217			char ifname[IFNAMSIZ * 4 + 1];
218			char *cp = ifname;
219			int i;
220
221			printf("\n\tcreatorid: %08x", htonl(clr->creatorid));
222			if (clr->ifname[0] != '\0') {
223			/* Treat clr->ifname as untrusted input. */
224			for (i = 0; i < IFNAMSIZ && clr->ifname[i] != '\0'; i++)
225			cp = vis(cp, clr->ifname[i], VIS_WHITE, 0);
226			printf(" interface: %s", ifname);
227			}
228
229			return (0);
230			}
231
232			int
233			pfsync_print_state(int flags, const void *bp)
234			{
235			struct pfsync_state st = (struct pfsync_state )bp;
236			putchar('\n');
237			print_state(st, flags);
238			return (0);
239			}
240
241			int
242			pfsync_print_ins_ack(int flags, const void *bp)
243			{
244			const struct pfsync_ins_ack *iack = bp;
245
246			printf("\n\tid: %016llx creatorid: %08x", betoh64(iack->id),
247			ntohl(iack->creatorid));
248
249			return (0);
250			}
251
252			int
253			pfsync_print_upd_c(int flags, const void *bp)
254			{
255			const struct pfsync_upd_c *u = bp;
256
257			printf("\n\tid: %016llx creatorid: %08x", betoh64(u->id),
258			ntohl(u->creatorid));
259
260			return (0);
261			}
262
263			int
264			pfsync_print_upd_req(int flags, const void *bp)
265			{
266			const struct pfsync_upd_req *ur = bp;
267
268			printf("\n\tid: %016llx creatorid: %08x", betoh64(ur->id),
269			ntohl(ur->creatorid));
270
271			return (0);
272			}
273
274			int
275			pfsync_print_del_c(int flags, const void *bp)
276			{
277			const struct pfsync_del_c *d = bp;
278
279			printf("\n\tid: %016llx creatorid: %08x", betoh64(d->id),
280			ntohl(d->creatorid));
281
282			return (0);
283			}
284
285			int
286			pfsync_print_bus(int flags, const void *bp)
287			{
288			const struct pfsync_bus *b = bp;
289			u_int32_t endtime;
290			int min, sec;
291			const char *status;
292
293			endtime = ntohl(b->endtime);
294			sec = endtime % 60;
295			endtime /= 60;
296			min = endtime % 60;
297			endtime /= 60;
298
299			switch (b->status) {
300			case PFSYNC_BUS_START:
301			status = "start";
302			break;
303			case PFSYNC_BUS_END:
304			status = "end";
305			break;
306			default:
307			status = "UNKNOWN";
308			break;
309			}
310
311			printf("\n\tcreatorid: %08x age: %.2u:%.2u:%.2u status: %s",
312			htonl(b->creatorid), endtime, min, sec, status);
313
314			return (0);
315			}
316
317			int
318			pfsync_print_tdb(int flags, const void *bp)
319			{
320			const struct pfsync_tdb *t = bp;
321
322			printf("\n\tspi: 0x%08x rpl: %llu cur_bytes: %llu",
323			ntohl(t->spi), betoh64(t->rpl), betoh64(t->cur_bytes));
324
325			return (0);
326			}
327
328			int
329			pfsync_print_eof(int flags, const void *bp)
330			{
331			return (1);
332			}