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