Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/tcpdump/print-radius.c	Lines:	0	69	0.0 %
Date:	2017-11-07	Branches:	0	44	0.0 %


/*	$OpenBSD: print-radius.c,v 1.11 2015/11/16 00:16:39 mmcc Exp $	*/

/*
 * Copyright (c) 1997 Thomas H. Ptacek. 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 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 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/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <stdio.h>
#include <string.h>

/* RADIUS support for tcpdump, Thomas Ptacek <tqbf@enteract.com> */

#include "interface.h"
#include "radius.h"

static void r_print_att(int code, int len, const u_char *val);
static void r_print_int(int code, int len, const u_char *val);
static void r_print_address(int code, int len, const u_char *val);
static void r_print_string(int code, int len, const u_char *val);
static void r_print_hex(int code, int len, const u_char *val);

/* --------------------------------------------------------------- */

struct radius_ctable {
	int code;
	char *name;
};

/* map opcodes to strings */

#define DEFINED_OPCODES		11

static struct radius_ctable radius_codes[] = {
	{ -1, 					NULL	},
	{ RADIUS_CODE_ACCESS_REQUEST,		"Axs?"	},
	{ RADIUS_CODE_ACCESS_ACCEPT,		"Axs+"	},
	{ RADIUS_CODE_ACCESS_REJECT,		"Axs-"	},
	{ RADIUS_CODE_ACCOUNT_REQUEST,		"Act?"	},
	{ RADIUS_CODE_ACCOUNT_RESPONSE,		"Act+"	},
	{ RADIUS_CODE_ACCOUNT_STATUS,		"ActSt"	},
	{ RADIUS_CODE_PASSCHG_REQUEST,		"Pchg?"	},
	{ RADIUS_CODE_PASSCHG_ACCEPT,		"Pchg+"	},
	{ RADIUS_CODE_PASSCHG_REJECT,		"Pchg-"	},
	{ RADIUS_CODE_ACCOUNT_MESSAGE,		"ActMg"	},
	{ RADIUS_CODE_ACCESS_CHALLENGE,		"Axs!"	},
	{ -1,					NULL	}
};

/* --------------------------------------------------------------- */

#define MAX_VALUES 20

struct radius_atable {
	int code;
	int encoding;
	char *name;
	char *values[MAX_VALUES];
};

/* map attributes to strings */

/* the right way to do this is probably to read these values out
 * of the actual RADIUS dictionary; this would require the machine
 * running tcpdump to have that file installed, and it's not my
 * program, so I'm not going to introduce new dependencies. Oh well.
 */

static struct radius_atable radius_atts[] = {

{ RADIUS_ATT_USER_NAME, 	RD_STRING, 	"Name", 	{ NULL } },
{ RADIUS_ATT_PASSWORD, 		RD_HEX, 	"Pass", 	{ NULL } },
{ RADIUS_ATT_CHAP_PASS, 	RD_HEX, 	"CPass",	{ NULL } },
{ RADIUS_ATT_NAS_IP, 		RD_ADDRESS, 	"NAS-IP", 	{ NULL } },
{ RADIUS_ATT_NAS_PORT, 		RD_INT, 	"NAS-Pt", 	{ NULL } },

{ RADIUS_ATT_USER_SERVICE, 	RD_INT, 	"USvc",
{ "", "Login", "Framed", "DB-Lgn", "DB-Frm", "Out", "Shell", NULL } },

{ RADIUS_ATT_PROTOCOL, 		RD_INT, 	"FProt",
{ "", "PPP", "SLIP", NULL } },

{ RADIUS_ATT_FRAMED_ADDRESS, 	RD_ADDRESS, 	"F-IP", 	{ NULL } },
{ RADIUS_ATT_NETMASK, 		RD_ADDRESS, 	"F-Msk", 	{ NULL } },
{ RADIUS_ATT_ROUTING, 		RD_INT, 	"F-Rtg", 	{ NULL } },
{ RADIUS_ATT_FILTER, 		RD_STRING, 	"FltID", 	{ NULL } },
{ RADIUS_ATT_MTU, 		RD_INT, 	"F-MTU", 	{ NULL } },
{ RADIUS_ATT_COMPRESSION, 	RD_INT, 	"F-Comp", 	{ NULL } },
{ RADIUS_ATT_LOGIN_HOST, 	RD_ADDRESS, 	"L-Hst", 	{ NULL } },

{ RADIUS_ATT_LOGIN_SERVICE, 	RD_INT, 	"L-Svc",
{ "", "Telnt", "Rlog", "Clear", "PortM", NULL }				},

{ RADIUS_ATT_LOGIN_TCP_PORT, 	RD_INT, 	"L-Pt", 	{ NULL } },
{ RADIUS_ATT_OLD_PASSWORD, 	RD_HEX, 	"OPass", 	{ NULL } },
{ RADIUS_ATT_PORT_MESSAGE, 	RD_STRING, 	"PMsg", 	{ NULL } },
{ RADIUS_ATT_DIALBACK_NO, 	RD_STRING, 	"DB#", 		{ NULL } },
{ RADIUS_ATT_DIALBACK_NAME, 	RD_STRING, 	"DBNm", 	{ NULL } },
{ RADIUS_ATT_EXPIRATION, 	RD_DATE, 	"PExp", 	{ NULL } },
{ RADIUS_ATT_FRAMED_ROUTE, 	RD_STRING, 	"F-Rt", 	{ NULL } },
{ RADIUS_ATT_FRAMED_IPX, 	RD_ADDRESS, 	"F-IPX", 	{ NULL } },
{ RADIUS_ATT_CHALLENGE_STATE, 	RD_STRING, 	"CState", 	{ NULL } },
{ RADIUS_ATT_CLASS, 		RD_STRING, 	"Class", 	{ NULL } },
{ RADIUS_ATT_VENDOR_SPECIFIC, 	RD_HEX, 	"Vendor", 	{ NULL } },
{ RADIUS_ATT_SESSION_TIMEOUT, 	RD_INT, 	"S-TO", 	{ NULL } },
{ RADIUS_ATT_IDLE_TIMEOUT, 	RD_INT, 	"I-TO", 	{ NULL } },
{ RADIUS_ATT_TERMINATE_ACTION, 	RD_INT, 	"TermAct", 	{ NULL } },
{ RADIUS_ATT_CALLED_ID, 	RD_STRING, 	"Callee", 	{ NULL } },
{ RADIUS_ATT_CALLER_ID, 	RD_STRING, 	"Caller", 	{ NULL } },

{ RADIUS_ATT_STATUS_TYPE, 	RD_INT, 	"Stat",
{ "", "Start", "Stop", NULL }					},

{ -1,				-1,		NULL, 		{ NULL } }

};

typedef void (*aselector)(int code, int len, const u_char *data);
aselector atselector[] = {
	r_print_hex,
	r_print_int,
	r_print_int,
	r_print_address,
	r_print_string,
	r_print_hex
};

static void r_print_att(int code, int len, const u_char *data) {
	struct radius_atable *atp;
	int i;

	for(atp = radius_atts; atp->code != -1; atp++)
		if(atp->code == code)
			break;

	if(atp->code == -1) {
		if(vflag > 1) {
			fprintf(stdout, " %d =", code);
			atselector[RD_HEX](code, len, data);
		} else
			fprintf(stdout, " %d", code);

		return;
	}

	fprintf(stdout, " %s =", atp->name);

	if(atp->encoding == RD_INT && *atp->values) {
		u_int32_t k = ntohl((*(int *)data));

		for(i = 0; atp->values[i] != NULL; i++)
			/* SHOOT ME */ ;

		if(k < i) {
			fprintf(stdout, " %s",
				atp->values[k]);
			return;
		}
	}

	atselector[atp->encoding](code, len, data);
}

static void r_print_int(int code, int len, const u_char *data) {
	if(len < 4) {
		fputs(" ?", stdout);
		return;
	}

	fprintf(stdout, " %d", ntohl((*(int *)data)));
}

static void r_print_address(int code, int len, const u_char *data) {
	if(len < 4) {
		fputs(" ?", stdout);
		return;
	}

	fprintf(stdout, " %s", inet_ntoa((*(struct in_addr *)data)));
}

static void r_print_string(int code, int len, const u_char *data) {
	char string[128];

	if(!len) {
		fputs(" ?", stdout);
		return;
	}

	if(len > 127)
		len = 127;

	memset(string, 0, 128);
	memcpy(string, data, len);

	fprintf(stdout, " ");
	safeputs(string);
}

static void r_print_hex(int code, int len, const u_char *data) {
	int i;

	/* excuse me */

	fputs(" [", stdout);

	for(i = 0; i < len; i++)
		fprintf(stdout, "%02x", data[i]);

	fputc(']', stdout);
}

void radius_print(const u_char *data, u_int len) {
	const struct radius_header *rhp;
	const u_char *pp;
	int first, l, ac, al;

	if(len < sizeof(struct radius_header)) {
		fputs(" [|radius]", stdout);
		return;
	}

	rhp = (struct radius_header *) data;

	if(rhp->code > DEFINED_OPCODES ||
	   rhp->code < 1)
		fprintf(stdout, " Code:%d id:%x [%d]",
		rhp->code, rhp->id, ntohs(rhp->len));
	else
		fprintf(stdout, " %s id:%x [%d]",
			radius_codes[rhp->code].name,
			rhp->id, ntohs(rhp->len));

	if(ntohs(rhp->len) > len) {
		fputs(" [|radius]", stdout);
		return;
	}

	l = len - RADFIXEDSZ;
	if(!l)
		return;
	else
		pp = data + RADFIXEDSZ;

	first = 1;
	while(l) {
		if(!first)
			fputc(',', stdout);
		else
			first = 0;

		ac = *pp++;
		al = *pp++;

		if(al > l || al < 2) {
			fputs(" [|radius]", stdout);
			return;
		}

		al -= 2;

		r_print_att(ac, al, pp);

		pp += al; l -= al + 2;
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: print-radius.c,v 1.11 2015/11/16 00:16:39 mmcc Exp $ */
2
3			/*
4			* Copyright (c) 1997 Thomas H. Ptacek. All rights reserved.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions
8			* are met:
9			*
10			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			*
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 THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18			* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20			* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22			* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23			* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24			* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26			* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27			*
28			*/
29
30			#include <sys/types.h>
31			#include <netinet/in.h>
32			#include <arpa/inet.h>
33
34			#include <stdio.h>
35			#include <string.h>
36
37			/* RADIUS support for tcpdump, Thomas Ptacek <tqbf@enteract.com> */
38
39			#include "interface.h"
40			#include "radius.h"
41
42			static void r_print_att(int code, int len, const u_char *val);
43			static void r_print_int(int code, int len, const u_char *val);
44			static void r_print_address(int code, int len, const u_char *val);
45			static void r_print_string(int code, int len, const u_char *val);
46			static void r_print_hex(int code, int len, const u_char *val);
47
48			/* --------------------------------------------------------------- */
49
50			struct radius_ctable {
51			int code;
52			char *name;
53			};
54
55			/* map opcodes to strings */
56
57			#define DEFINED_OPCODES 11
58
59			static struct radius_ctable radius_codes[] = {
60			{ -1, NULL },
61			{ RADIUS_CODE_ACCESS_REQUEST, "Axs?" },
62			{ RADIUS_CODE_ACCESS_ACCEPT, "Axs+" },
63			{ RADIUS_CODE_ACCESS_REJECT, "Axs-" },
64			{ RADIUS_CODE_ACCOUNT_REQUEST, "Act?" },
65			{ RADIUS_CODE_ACCOUNT_RESPONSE, "Act+" },
66			{ RADIUS_CODE_ACCOUNT_STATUS, "ActSt" },
67			{ RADIUS_CODE_PASSCHG_REQUEST, "Pchg?" },
68			{ RADIUS_CODE_PASSCHG_ACCEPT, "Pchg+" },
69			{ RADIUS_CODE_PASSCHG_REJECT, "Pchg-" },
70			{ RADIUS_CODE_ACCOUNT_MESSAGE, "ActMg" },
71			{ RADIUS_CODE_ACCESS_CHALLENGE, "Axs!" },
72			{ -1, NULL }
73			};
74
75			/* --------------------------------------------------------------- */
76
77			#define MAX_VALUES 20
78
79			struct radius_atable {
80			int code;
81			int encoding;
82			char *name;
83			char *values[MAX_VALUES];
84			};
85
86			/* map attributes to strings */
87
88			/* the right way to do this is probably to read these values out
89			* of the actual RADIUS dictionary; this would require the machine
90			* running tcpdump to have that file installed, and it's not my
91			* program, so I'm not going to introduce new dependencies. Oh well.
92			*/
93
94			static struct radius_atable radius_atts[] = {
95
96			{ RADIUS_ATT_USER_NAME, RD_STRING, "Name", { NULL } },
97			{ RADIUS_ATT_PASSWORD, RD_HEX, "Pass", { NULL } },
98			{ RADIUS_ATT_CHAP_PASS, RD_HEX, "CPass", { NULL } },
99			{ RADIUS_ATT_NAS_IP, RD_ADDRESS, "NAS-IP", { NULL } },
100			{ RADIUS_ATT_NAS_PORT, RD_INT, "NAS-Pt", { NULL } },
101
102			{ RADIUS_ATT_USER_SERVICE, RD_INT, "USvc",
103			{ "", "Login", "Framed", "DB-Lgn", "DB-Frm", "Out", "Shell", NULL } },
104
105			{ RADIUS_ATT_PROTOCOL, RD_INT, "FProt",
106			{ "", "PPP", "SLIP", NULL } },
107
108			{ RADIUS_ATT_FRAMED_ADDRESS, RD_ADDRESS, "F-IP", { NULL } },
109			{ RADIUS_ATT_NETMASK, RD_ADDRESS, "F-Msk", { NULL } },
110			{ RADIUS_ATT_ROUTING, RD_INT, "F-Rtg", { NULL } },
111			{ RADIUS_ATT_FILTER, RD_STRING, "FltID", { NULL } },
112			{ RADIUS_ATT_MTU, RD_INT, "F-MTU", { NULL } },
113			{ RADIUS_ATT_COMPRESSION, RD_INT, "F-Comp", { NULL } },
114			{ RADIUS_ATT_LOGIN_HOST, RD_ADDRESS, "L-Hst", { NULL } },
115
116			{ RADIUS_ATT_LOGIN_SERVICE, RD_INT, "L-Svc",
117			{ "", "Telnt", "Rlog", "Clear", "PortM", NULL } },
118
119			{ RADIUS_ATT_LOGIN_TCP_PORT, RD_INT, "L-Pt", { NULL } },
120			{ RADIUS_ATT_OLD_PASSWORD, RD_HEX, "OPass", { NULL } },
121			{ RADIUS_ATT_PORT_MESSAGE, RD_STRING, "PMsg", { NULL } },
122			{ RADIUS_ATT_DIALBACK_NO, RD_STRING, "DB#", { NULL } },
123			{ RADIUS_ATT_DIALBACK_NAME, RD_STRING, "DBNm", { NULL } },
124			{ RADIUS_ATT_EXPIRATION, RD_DATE, "PExp", { NULL } },
125			{ RADIUS_ATT_FRAMED_ROUTE, RD_STRING, "F-Rt", { NULL } },
126			{ RADIUS_ATT_FRAMED_IPX, RD_ADDRESS, "F-IPX", { NULL } },
127			{ RADIUS_ATT_CHALLENGE_STATE, RD_STRING, "CState", { NULL } },
128			{ RADIUS_ATT_CLASS, RD_STRING, "Class", { NULL } },
129			{ RADIUS_ATT_VENDOR_SPECIFIC, RD_HEX, "Vendor", { NULL } },
130			{ RADIUS_ATT_SESSION_TIMEOUT, RD_INT, "S-TO", { NULL } },
131			{ RADIUS_ATT_IDLE_TIMEOUT, RD_INT, "I-TO", { NULL } },
132			{ RADIUS_ATT_TERMINATE_ACTION, RD_INT, "TermAct", { NULL } },
133			{ RADIUS_ATT_CALLED_ID, RD_STRING, "Callee", { NULL } },
134			{ RADIUS_ATT_CALLER_ID, RD_STRING, "Caller", { NULL } },
135
136			{ RADIUS_ATT_STATUS_TYPE, RD_INT, "Stat",
137			{ "", "Start", "Stop", NULL } },
138
139			{ -1, -1, NULL, { NULL } }
140
141			};
142
143			typedef void (aselector)(int code, int len, const u_char data);
144			aselector atselector[] = {
145			r_print_hex,
146			r_print_int,
147			r_print_int,
148			r_print_address,
149			r_print_string,
150			r_print_hex
151			};
152
153			static void r_print_att(int code, int len, const u_char *data) {
154			struct radius_atable *atp;
155			int i;
156
157			for(atp = radius_atts; atp->code != -1; atp++)
158			if(atp->code == code)
159			break;
160
161			if(atp->code == -1) {
162			if(vflag > 1) {
163			fprintf(stdout, " %d =", code);
164			atselector[RD_HEX](code, len, data);
165			} else
166			fprintf(stdout, " %d", code);
167
168			return;
169			}
170
171			fprintf(stdout, " %s =", atp->name);
172
173			if(atp->encoding == RD_INT && *atp->values) {
174			u_int32_t k = ntohl(((int )data));
175
176			for(i = 0; atp->values[i] != NULL; i++)
177			/* SHOOT ME */ ;
178
179			if(k < i) {
180			fprintf(stdout, " %s",
181			atp->values[k]);
182			return;
183			}
184			}
185
186			atselector[atp->encoding](code, len, data);
187			}
188
189			static void r_print_int(int code, int len, const u_char *data) {
190			if(len < 4) {
191			fputs(" ?", stdout);
192			return;
193			}
194
195			fprintf(stdout, " %d", ntohl(((int )data)));
196			}
197
198			static void r_print_address(int code, int len, const u_char *data) {
199			if(len < 4) {
200			fputs(" ?", stdout);
201			return;
202			}
203
204			fprintf(stdout, " %s", inet_ntoa(((struct in_addr )data)));
205			}
206
207			static void r_print_string(int code, int len, const u_char *data) {
208			char string[128];
209
210			if(!len) {
211			fputs(" ?", stdout);
212			return;
213			}
214
215			if(len > 127)
216			len = 127;
217
218			memset(string, 0, 128);
219			memcpy(string, data, len);
220
221			fprintf(stdout, " ");
222			safeputs(string);
223			}
224
225			static void r_print_hex(int code, int len, const u_char *data) {
226			int i;
227
228			/* excuse me */
229
230			fputs(" [", stdout);
231
232			for(i = 0; i < len; i++)
233			fprintf(stdout, "%02x", data[i]);
234
235			fputc(']', stdout);
236			}
237
238			void radius_print(const u_char *data, u_int len) {
239			const struct radius_header *rhp;
240			const u_char *pp;
241			int first, l, ac, al;
242
243			if(len < sizeof(struct radius_header)) {
244			fputs(" [\|radius]", stdout);
245			return;
246			}
247
248			rhp = (struct radius_header *) data;
249
250			if(rhp->code > DEFINED_OPCODES \|\|
251			rhp->code < 1)
252			fprintf(stdout, " Code:%d id:%x [%d]",
253			rhp->code, rhp->id, ntohs(rhp->len));
254			else
255			fprintf(stdout, " %s id:%x [%d]",
256			radius_codes[rhp->code].name,
257			rhp->id, ntohs(rhp->len));
258
259			if(ntohs(rhp->len) > len) {
260			fputs(" [\|radius]", stdout);
261			return;
262			}
263
264			l = len - RADFIXEDSZ;
265			if(!l)
266			return;
267			else
268			pp = data + RADFIXEDSZ;
269
270			first = 1;
271			while(l) {
272			if(!first)
273			fputc(',', stdout);
274			else
275			first = 0;
276
277			ac = *pp++;
278			al = *pp++;
279
280			if(al > l \|\| al < 2) {
281			fputs(" [\|radius]", stdout);
282			return;
283			}
284
285			al -= 2;
286
287			r_print_att(ac, al, pp);
288
289			pp += al; l -= al + 2;
290			}
291			}