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
_nss_initf_ethers(nss_db_params_t * p)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
ether_hostton(const char * host,struct ether_addr * e)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
ether_ntohost(char * host,const struct ether_addr * e)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
ether_line(const char * s,struct ether_addr * e,char * hostname)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
str2ether(const char * instr,int lenstr,void * ent,char * buffer,int buflen)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 *
ea_buf(void)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 *
ether_ntoa_r(const struct ether_addr * e,char * buf)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 *
ether_ntoa(const struct ether_addr * e)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 *
ether_aton_r(const char * s,struct ether_addr * e)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 *
ether_aton(const char * s)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