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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22
23 /*
24 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
27 */
28
29 #include <sys/types.h>
30 #include <sys/cmn_err.h>
31 #include <sys/systm.h>
32 #include <sys/socket.h>
33 #include <sys/sunddi.h>
34 #include <netinet/in.h>
35 #include <inet/led.h>
36
37 static void convert2ascii(char *, const in6_addr_t *);
38 static char *strchr_w(const char *, int);
39 static int str2inet_addr(char *, ipaddr_t *);
40
41 /*
42 * inet_ntop -- Convert an IPv4 or IPv6 address in binary form into
43 * printable form, and return a pointer to that string. Caller should
44 * provide a buffer of correct length to store string into.
45 * Note: this routine is kernel version of inet_ntop. It has similar
46 * format as inet_ntop() defined in rfc2553. But it does not do
47 * error handling operations exactly as rfc2553 defines. This function
48 * is used by kernel inet directory routines only for debugging.
49 * This inet_ntop() function, does not return NULL if third argument
50 * is NULL. The reason is simple that we don't want kernel to panic
51 * as the output of this function is directly fed to ip<n>dbg macro.
52 * Instead it uses a local buffer for destination address for
53 * those calls which purposely pass NULL ptr for the destination
54 * buffer. This function is thread-safe when the caller passes a non-
55 * null buffer with the third argument.
56 */
57 /* ARGSUSED */
58 char *
inet_ntop(int af,const void * addr,char * buf,int addrlen)59 inet_ntop(int af, const void *addr, char *buf, int addrlen)
60 {
61 static char local_buf[INET6_ADDRSTRLEN];
62 static char *err_buf1 = "<badaddr>";
63 static char *err_buf2 = "<badfamily>";
64 in6_addr_t *v6addr;
65 uchar_t *v4addr;
66 char *caddr;
67
68 /*
69 * We don't allow thread unsafe inet_ntop calls, they
70 * must pass a non-null buffer pointer. For DEBUG mode
71 * we use the ASSERT() and for non-debug kernel it will
72 * silently allow it for now. Someday we should remove
73 * the static buffer from this function.
74 */
75
76 ASSERT(buf != NULL);
77 if (buf == NULL)
78 buf = local_buf;
79 buf[0] = '\0';
80
81 /* Let user know politely not to send NULL or unaligned addr */
82 if (addr == NULL || !(OK_32PTR(addr))) {
83 #ifdef DEBUG
84 cmn_err(CE_WARN, "inet_ntop: addr is <null> or unaligned");
85 #endif
86 return (err_buf1);
87 }
88
89
90 #define UC(b) (((int)b) & 0xff)
91 switch (af) {
92 case AF_INET:
93 ASSERT(addrlen >= INET_ADDRSTRLEN);
94 v4addr = (uchar_t *)addr;
95 (void) sprintf(buf, "%03d.%03d.%03d.%03d",
96 UC(v4addr[0]), UC(v4addr[1]), UC(v4addr[2]), UC(v4addr[3]));
97 return (buf);
98
99 case AF_INET6:
100 ASSERT(addrlen >= INET6_ADDRSTRLEN);
101 v6addr = (in6_addr_t *)addr;
102 if (IN6_IS_ADDR_V4MAPPED(v6addr)) {
103 caddr = (char *)addr;
104 (void) sprintf(buf, "::ffff:%d.%d.%d.%d",
105 UC(caddr[12]), UC(caddr[13]),
106 UC(caddr[14]), UC(caddr[15]));
107 } else if (IN6_IS_ADDR_V4COMPAT(v6addr)) {
108 caddr = (char *)addr;
109 (void) sprintf(buf, "::%d.%d.%d.%d",
110 UC(caddr[12]), UC(caddr[13]), UC(caddr[14]),
111 UC(caddr[15]));
112 } else if (IN6_IS_ADDR_UNSPECIFIED(v6addr)) {
113 (void) sprintf(buf, "::");
114 } else {
115 convert2ascii(buf, v6addr);
116 }
117 return (buf);
118
119 default:
120 return (err_buf2);
121 }
122 #undef UC
123 }
124
125 /*
126 *
127 * v6 formats supported
128 * General format xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx
129 * The short hand notation :: is used for COMPAT addr
130 * Other forms : fe80::xxxx:xxxx:xxxx:xxxx
131 */
132 static void
convert2ascii(char * buf,const in6_addr_t * addr)133 convert2ascii(char *buf, const in6_addr_t *addr)
134 {
135 int hexdigits;
136 int head_zero = 0;
137 int tail_zero = 0;
138 /* tempbuf must be big enough to hold ffff:\0 */
139 char tempbuf[6];
140 char *ptr;
141 uint16_t *addr_component;
142 size_t len;
143 boolean_t first = B_FALSE;
144 boolean_t med_zero = B_FALSE;
145 boolean_t end_zero = B_FALSE;
146
147 addr_component = (uint16_t *)addr;
148 ptr = buf;
149
150 /* First count if trailing zeroes higher in number */
151 for (hexdigits = 0; hexdigits < 8; hexdigits++) {
152 if (*addr_component == 0) {
153 if (hexdigits < 4)
154 head_zero++;
155 else
156 tail_zero++;
157 }
158 addr_component++;
159 }
160 addr_component = (uint16_t *)addr;
161 if (tail_zero > head_zero && (head_zero + tail_zero) != 7)
162 end_zero = B_TRUE;
163
164 for (hexdigits = 0; hexdigits < 8; hexdigits++) {
165
166 /* if entry is a 0 */
167
168 if (*addr_component == 0) {
169 if (!first && *(addr_component + 1) == 0) {
170 if (end_zero && (hexdigits < 4)) {
171 *ptr++ = '0';
172 *ptr++ = ':';
173 } else {
174 /*
175 * address starts with 0s ..
176 * stick in leading ':' of pair
177 */
178 if (hexdigits == 0)
179 *ptr++ = ':';
180 /* add another */
181 *ptr++ = ':';
182 first = B_TRUE;
183 med_zero = B_TRUE;
184 }
185 } else if (first && med_zero) {
186 if (hexdigits == 7)
187 *ptr++ = ':';
188 addr_component++;
189 continue;
190 } else {
191 *ptr++ = '0';
192 *ptr++ = ':';
193 }
194 addr_component++;
195 continue;
196 }
197 if (med_zero)
198 med_zero = B_FALSE;
199
200 tempbuf[0] = '\0';
201 (void) sprintf(tempbuf, "%x:", ntohs(*addr_component) & 0xffff);
202 len = strlen(tempbuf);
203 bcopy(tempbuf, ptr, len);
204 ptr = ptr + len;
205 addr_component++;
206 }
207 *--ptr = '\0';
208 }
209
210 /*
211 * search for char c, terminate on trailing white space
212 */
213 static char *
strchr_w(const char * sp,int c)214 strchr_w(const char *sp, int c)
215 {
216 /* skip leading white space */
217 while (*sp && (*sp == ' ' || *sp == '\t')) {
218 sp++;
219 }
220
221 do {
222 if (*sp == (char)c)
223 return ((char *)sp);
224 if (*sp == ' ' || *sp == '\t')
225 return (NULL);
226 } while (*sp++);
227 return (NULL);
228 }
229
230 static int
str2inet_addr(char * cp,ipaddr_t * addrp)231 str2inet_addr(char *cp, ipaddr_t *addrp)
232 {
233 char *end;
234 long byte;
235 int i;
236 ipaddr_t addr = 0;
237
238 for (i = 0; i < 4; i++) {
239 if (ddi_strtol(cp, &end, 10, &byte) != 0 || byte < 0 ||
240 byte > 255) {
241 return (0);
242 }
243 addr = (addr << 8) | (uint8_t)byte;
244 if (i < 3) {
245 if (*end != '.') {
246 return (0);
247 } else {
248 cp = end + 1;
249 }
250 } else {
251 cp = end;
252 }
253 }
254 *addrp = addr;
255 return (1);
256 }
257
258 /*
259 * inet_pton: This function takes string format IPv4 or IPv6 address and
260 * converts it to binary form. The format of this function corresponds to
261 * inet_pton() in the socket library.
262 *
263 * Return values:
264 * 0 invalid IPv4 or IPv6 address
265 * 1 successful conversion
266 * -1 af is not AF_INET or AF_INET6
267 */
268 int
__inet_pton(int af,char * inp,void * outp,int compat)269 __inet_pton(int af, char *inp, void *outp, int compat)
270 {
271 int i;
272 long byte;
273 char *end;
274
275 switch (af) {
276 case AF_INET:
277 if (str2inet_addr(inp, (ipaddr_t *)outp) != 0) {
278 if (!compat)
279 *(uint32_t *)outp = htonl(*(uint32_t *)outp);
280 return (1);
281 } else {
282 return (0);
283 }
284 case AF_INET6: {
285 union v6buf_u {
286 uint16_t v6words_u[8];
287 in6_addr_t v6addr_u;
288 } v6buf, *v6outp;
289 uint16_t *dbl_col = NULL;
290 char lastbyte = NULL;
291
292 v6outp = (union v6buf_u *)outp;
293
294 if (strchr_w(inp, '.') != NULL) {
295 int ret = 0;
296
297 /* v4 mapped or v4 compatable */
298 if (strncmp(inp, "::ffff:", 7) == 0) {
299 ipaddr_t ipv4_all_zeroes = 0;
300 /* mapped - first init prefix and then fill */
301 IN6_IPADDR_TO_V4MAPPED(ipv4_all_zeroes,
302 &v6outp->v6addr_u);
303 ret = str2inet_addr(inp + 7,
304 &(v6outp->v6addr_u.s6_addr32[3]));
305 } else if (strncmp(inp, "::", 2) == 0) {
306 /* v4 compatable - prefix all zeroes */
307 bzero(&v6outp->v6addr_u, sizeof (in6_addr_t));
308 ret = str2inet_addr(inp + 2,
309 &(v6outp->v6addr_u.s6_addr32[3]));
310 }
311 if (ret > 0 && !compat) {
312 v6outp->v6addr_u.s6_addr32[3] =
313 htonl(v6outp->v6addr_u.s6_addr32[3]);
314 }
315 return (ret);
316 }
317 for (i = 0; i < 8; i++) {
318 int error;
319 /*
320 * if ddi_strtol() fails it could be because
321 * the string is "::". That is valid and
322 * checked for below so just set the value to
323 * 0 and continue.
324 */
325 if ((error = ddi_strtol(inp, &end, 16, &byte)) != 0) {
326 if (error == ERANGE)
327 return (0);
328 byte = 0;
329 }
330 if (byte < 0 || byte > 0x0ffff) {
331 return (0);
332 }
333 if (compat) {
334 v6buf.v6words_u[i] = (uint16_t)byte;
335 } else {
336 v6buf.v6words_u[i] = htons((uint16_t)byte);
337 }
338 if (*end == NULL || i == 7) {
339 inp = end;
340 break;
341 }
342 if (inp == end) { /* not a number must be */
343 if (*inp == ':' &&
344 ((i == 0 && *(inp + 1) == ':') ||
345 lastbyte == ':')) {
346 if (dbl_col) {
347 return (0);
348 }
349 if (byte != 0)
350 i++;
351 dbl_col = &v6buf.v6words_u[i];
352 if (i == 0)
353 inp++;
354 } else if (*inp == NULL || *inp == ' ' ||
355 *inp == '\t') {
356 break;
357 } else {
358 return (0);
359 }
360 } else {
361 inp = end;
362 }
363 if (*inp != ':') {
364 return (0);
365 }
366 inp++;
367 if (*inp == NULL || *inp == ' ' || *inp == '\t') {
368 break;
369 }
370 lastbyte = *inp;
371 }
372 if (*inp != NULL && *inp != ' ' && *inp != '\t') {
373 return (0);
374 }
375 /*
376 * v6words now contains the bytes we could translate
377 * dbl_col points to the word (should be 0) where
378 * a double colon was found
379 */
380 if (i == 7) {
381 v6outp->v6addr_u = v6buf.v6addr_u;
382 } else {
383 int rem;
384 int word;
385 int next;
386 if (dbl_col == NULL) {
387 return (0);
388 }
389 bzero(&v6outp->v6addr_u, sizeof (in6_addr_t));
390 rem = dbl_col - &v6buf.v6words_u[0];
391 for (next = 0; next < rem; next++) {
392 v6outp->v6words_u[next] = v6buf.v6words_u[next];
393 }
394 next++; /* skip dbl_col 0 */
395 rem = i - rem;
396 word = 8 - rem;
397 while (rem > 0) {
398 v6outp->v6words_u[word] = v6buf.v6words_u[next];
399 word++;
400 rem--;
401 next++;
402 }
403 }
404 return (1); /* Success */
405 }
406 } /* switch */
407 return (-1); /* return -1 for default case */
408 }
409
410 /*
411 * Provide fixed inet_pton() implementation.
412 */
413 int
_inet_pton(int af,char * inp,void * outp)414 _inet_pton(int af, char *inp, void *outp)
415 {
416 return (__inet_pton(af, inp, outp, 0));
417 }
418
419 /*
420 * Provide broken inet_pton() implementation by default for binary
421 * compatibility.
422 */
423 int
inet_pton(int af,char * inp,void * outp)424 inet_pton(int af, char *inp, void *outp)
425 {
426 return (__inet_pton(af, inp, outp, 1));
427 }
428