xref: /titanic_51/usr/src/lib/libsocket/inet/ether_addr.c (revision 7f11fd00fc23e2af7ae21cc8837a2b86380dcfa7)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
26  */
27 
28 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
29 /*	  All Rights Reserved  	*/
30 
31 /*
32  * University Copyright- Copyright (c) 1982, 1986, 1988
33  * The Regents of the University of California
34  * All Rights Reserved
35  *
36  * University Acknowledgment- Portions of this document are derived from
37  * software developed by the University of California, Berkeley, and its
38  * contributors.
39  */
40 
41 /*
42  * All routines necessary to deal the "ethers" database.  The sources
43  * contain mappings between 48 bit ethernet addresses and corresponding
44  * hosts names.  The addresses have an ascii representation of the form
45  * "x:x:x:x:x:x" where x is a hex number between 0x00 and 0xff;  the
46  * bytes are always in network order.
47  */
48 
49 #include <stdio.h>
50 #include <ctype.h>
51 #include <string.h>
52 #include <stdlib.h>
53 #include <sys/types.h>
54 #include <thread.h>
55 #include <pthread.h>
56 #include <sys/socket.h>
57 #include <net/if.h>
58 #include <netinet/in.h>
59 #include <netinet/if_ether.h>
60 #include <nss_dbdefs.h>
61 
62 int str2ether(const char *, int, void *, char *, int);
63 
64 static DEFINE_NSS_DB_ROOT(db_root);
65 
66 void
67 _nss_initf_ethers(nss_db_params_t *p)
68 {
69 	p->name = NSS_DBNAM_ETHERS;
70 	p->default_config = NSS_DEFCONF_ETHERS;
71 }
72 
73 /*
74  * Given a host's name, this routine finds the corresponding 48 bit
75  * ethernet address based on the "ethers" policy in /etc/nsswitch.conf.
76  * Returns zero if successful, non-zero otherwise.
77  */
78 int
79 ether_hostton(
80 	const char *host,		/* function input */
81 	struct ether_addr *e		/* function output */
82 )
83 {
84 	nss_XbyY_args_t arg;
85 	nss_status_t	res;
86 
87 	/*
88 	 * let the backend do the allocation to store stuff for parsing.
89 	 */
90 	NSS_XbyY_INIT(&arg, e, NULL, 0, str2ether);
91 	arg.key.name = host;
92 	res = nss_search(&db_root, _nss_initf_ethers,
93 	    NSS_DBOP_ETHERS_HOSTTON, &arg);
94 	(void) NSS_XbyY_FINI(&arg);
95 	return (arg.status = res);
96 }
97 
98 /*
99  * Given a 48 bit ethernet address, it finds the corresponding hostname
100  * ethernet address based on the "ethers" policy in /etc/nsswitch.conf.
101  * Returns zero if successful, non-zero otherwise.
102  */
103 int
104 ether_ntohost(
105 	char *host,			/* function output */
106 	const struct ether_addr *e	/* function input */
107 )
108 {
109 	nss_XbyY_args_t arg;
110 	nss_status_t	res;
111 
112 	/*
113 	 * let the backend do the allocation to store stuff for parsing.
114 	 */
115 	NSS_XbyY_INIT(&arg, NULL, host, 0, str2ether);
116 	arg.key.ether = (void *)e;
117 	res = nss_search(&db_root, _nss_initf_ethers,
118 	    NSS_DBOP_ETHERS_NTOHOST, &arg);
119 	/* memcpy(host, ether_res.host, strlen(ether_res.host)); */
120 	(void) NSS_XbyY_FINI(&arg);
121 	return (arg.status = res);
122 }
123 
124 /*
125  * Parses a line from "ethers" database into its components.  The line has
126  * the form 8:0:20:1:17:c8	krypton
127  * where the first part is a 48 bit ethernet address and the second is
128  * the corresponding hosts name.
129  * Returns zero if successful, non-zero otherwise.
130  */
131 int
132 ether_line(
133 	const char *s,		/* the string to be parsed */
134 	struct ether_addr *e,	/* ethernet address struct to be filled in */
135 	char *hostname		/* hosts name to be set */
136 )
137 {
138 	int i;
139 	uint_t t[6];
140 
141 	i = sscanf(s, " %x:%x:%x:%x:%x:%x %s",
142 	    &t[0], &t[1], &t[2], &t[3], &t[4], &t[5], hostname);
143 	if (i != 7) {
144 		return (7 - i);
145 	}
146 	for (i = 0; i < 6; i++)
147 		e->ether_addr_octet[i] = (uchar_t)t[i];
148 	return (0);
149 }
150 
151 /*
152  * Parses a line from "ethers" database into its components.
153  * Useful for the vile purposes of the backends that
154  * expect a str2ether() format.
155  *
156  * This function, after parsing the instr line, will
157  * place the resulting struct ether_addr in b->buf.result only if
158  * b->buf.result is initialized (not NULL). I.e. it always happens
159  * for "files" backend (that needs to parse input line and
160  * then do a match for the ether key) and happens for "nis"
161  * backend only if the call was ether_hostton.
162  *
163  * Also, it will place the resulting hostname into b->buf.buffer
164  * only if b->buf.buffer is initialized. I.e. it always happens
165  * for "files" backend (that needs to parse input line and
166  * then do a match for the host key) and happens for "nis"
167  * backend only if the call was ether_ntohost.
168  *
169  * Cannot use the sscanf() technique for parsing because instr
170  * is a read-only, not necessarily null-terminated, buffer.
171  *
172  * Return values: 0 = success, 1 = parse error, 2 = erange ...
173  * The structure pointer passed in is a structure in the caller's space
174  * wherein the field pointers would be set to areas in the buffer if
175  * need be. instring and buffer should be separate areas.
176  */
177 #define	DIGIT(x)	(isdigit(x) ? (x) - '0' : \
178 		islower(x) ? (x) + 10 - 'a' : (x) + 10 - 'A')
179 #define	lisalnum(x)	(isdigit(x) || \
180 		((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z'))
181 /* ARGSUSED */
182 int
183 str2ether(const char *instr, int lenstr, void *ent, char *buffer, int buflen)
184 {
185 	uchar_t	*ether =  (uchar_t *)ent;
186 	char	*host = buffer;
187 	const char	*p, *limit, *start;
188 	ptrdiff_t i;
189 
190 	p = instr;
191 	limit = p + lenstr;
192 
193 	/* skip beginning whitespace, if any */
194 	while (p < limit && isspace(*p))
195 		p++;
196 
197 	if (ether) {	/* parse ether */
198 		for (i = 0; i < 6; i++) {
199 			int	j = 0, n = 0;
200 
201 			start = p;
202 			while (p < limit && lisalnum(start[j])) {
203 				/* don't worry about overflow here */
204 				n = 16 * n + DIGIT(start[j]);
205 				j++;
206 				p++;
207 			}
208 			if (*p != ':' && i < 5) {
209 				return (NSS_STR_PARSE_PARSE);
210 			} else {
211 				p++;
212 				*(ether + i) = (uchar_t)n;
213 			}
214 		}
215 	} else {	/* skip ether */
216 		while (p < limit && !isspace(*p))
217 			p++;
218 	}
219 	if (host) {	/* parse host */
220 		while (p < limit && isspace(*p))	/* skip whitespace */
221 			p++;
222 		start = p;
223 		while (p < limit && !isspace(*p))	/* skip hostname */
224 			p++;
225 		if ((i = (p - start)) < MAXHOSTNAMELEN) {
226 			(void) memcpy(host, start, i);
227 			host[i] = '\0';
228 		} else
229 			return (NSS_STR_PARSE_ERANGE); /* failure */
230 	}
231 	return (NSS_STR_PARSE_SUCCESS);
232 }
233 
234 typedef struct {
235 	char			ea_string[18];
236 	struct ether_addr	ea_addr;
237 } eabuf_t;
238 
239 static eabuf_t *
240 ea_buf(void)
241 {
242 	static thread_key_t key = THR_ONCE_KEY;
243 	static eabuf_t ea_main;
244 	eabuf_t *eabuf;
245 
246 	if (thr_main())
247 		return (&ea_main);
248 
249 	if (thr_keycreate_once(&key, free) != 0)
250 		return (NULL);
251 	eabuf = pthread_getspecific(key);
252 	if (eabuf == NULL) {
253 		eabuf = malloc(sizeof (eabuf_t));
254 		(void) thr_setspecific(key, eabuf);
255 	}
256 	return (eabuf);
257 }
258 
259 /*
260  * Converts a 48 bit ethernet number to its string representation using a user
261  * defined buffer.
262  */
263 char *
264 ether_ntoa_r(const struct ether_addr *e, char *buf)
265 {
266 	(void) sprintf(buf, "%x:%x:%x:%x:%x:%x",
267 	    e->ether_addr_octet[0], e->ether_addr_octet[1],
268 	    e->ether_addr_octet[2], e->ether_addr_octet[3],
269 	    e->ether_addr_octet[4], e->ether_addr_octet[5]);
270 	return (buf);
271 }
272 
273 /*
274  * Converts a 48 bit ethernet number to its string representation using a
275  * per-thread buffer.
276  */
277 char *
278 ether_ntoa(const struct ether_addr *e)
279 {
280 	eabuf_t *eabuf;
281 
282 	if ((eabuf = ea_buf()) == NULL)
283 		return (NULL);
284 	return (ether_ntoa_r(e, eabuf->ea_string));
285 }
286 
287 /*
288  * Converts an ethernet address representation back into its 48 bits using a
289  * user defined buffer.
290  */
291 struct ether_addr *
292 ether_aton_r(const char *s, struct ether_addr *e)
293 {
294 	int i;
295 	uint_t t[6];
296 	i = sscanf(s, " %x:%x:%x:%x:%x:%x",
297 	    &t[0], &t[1], &t[2], &t[3], &t[4], &t[5]);
298 	if (i != 6)
299 		return (NULL);
300 	for (i = 0; i < 6; i++)
301 		e->ether_addr_octet[i] = (uchar_t)t[i];
302 	return (e);
303 }
304 
305 /*
306  * Converts an ethernet address representation back into its 48 bits using a
307  * per-thread buffer.
308  */
309 struct ether_addr *
310 ether_aton(const char *s)
311 {
312 	eabuf_t *eabuf;
313 
314 	if ((eabuf = ea_buf()) == NULL)
315 		return (NULL);
316 	return (ether_aton_r(s, &eabuf->ea_addr));
317 }
318