source: mainline/uspace/lib/inet/src/addr.c@ edeee9f

serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since edeee9f was edeee9f, checked in by Jiri Svoboda <jiri@…>, 4 years ago

Fix header guards and doxy groups of stuff moved out of libc
  • Property mode set to 100644
File size: 15.2 KB
Line 
1/*
2 * Copyright (c) 2021 Jiri Svoboda
3 * Copyright (c) 2013 Martin Decky
4 * 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 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup libinet
31 * @{
32 */
33/** @file Internet address parsing and formatting.
34 */
35
36#include <assert.h>
37#include <errno.h>
38#include <inet/addr.h>
39#include <inet/eth_addr.h>
40#include <stdio.h>
41#include <stddef.h>
42#include <stdlib.h>
43#include <bitops.h>
44#include <inttypes.h>
45#include <str.h>
46
47#define INET_PREFIXSTRSIZE 5
48
49#define INET6_ADDRSTRLEN (8 * 4 + 7 + 1)
50
51#if !(defined(__BE__) ^ defined(__LE__))
52#error The architecture must be either big-endian or little-endian.
53#endif
54
55const addr32_t addr32_broadcast_all_hosts = 0xffffffff;
56
57static eth_addr_t inet_eth_addr_solicited_node =
58 ETH_ADDR_INITIALIZER(0x33, 0x33, 0xff, 0, 0, 0);
59
60static const inet_addr_t inet_addr_any_addr = {
61 .version = ip_v4,
62 .addr = 0
63};
64
65static const inet_addr_t inet_addr_any_addr6 = {
66 .version = ip_v6,
67 .addr6 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
68};
69
70void addr128(const addr128_t src, addr128_t dst)
71{
72 memcpy(dst, src, 16);
73}
74
75/** Compare addr128.
76 *
77 * @return Non-zero if equal, zero if not equal.
78 */
79int addr128_compare(const addr128_t a, const addr128_t b)
80{
81 return memcmp(a, b, 16) == 0;
82}
83
84/** Compute solicited node MAC multicast address from target IPv6 address
85 *
86 * @param ip Target IPv6 address
87 * @param mac Solicited MAC address to be assigned
88 *
89 */
90void eth_addr_solicited_node(const addr128_t ip, eth_addr_t *mac)
91{
92 uint8_t b[6];
93 mac->a = inet_eth_addr_solicited_node.a;
94
95 eth_addr_encode(&inet_eth_addr_solicited_node, b);
96 memcpy(&b[3], ip + 13, 3);
97 eth_addr_decode(b, mac);
98}
99
100void host2addr128_t_be(const addr128_t host, addr128_t be)
101{
102 memcpy(be, host, 16);
103}
104
105void addr128_t_be2host(const addr128_t be, addr128_t host)
106{
107 memcpy(host, be, 16);
108}
109
110void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
111{
112 addr->version = ip_v4;
113 addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
114 ((addr32_t) c << 8) | ((addr32_t) d);
115}
116
117void inet_naddr(inet_naddr_t *naddr, uint8_t a, uint8_t b, uint8_t c, uint8_t d,
118 uint8_t prefix)
119{
120 naddr->version = ip_v4;
121 naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
122 ((addr32_t) c << 8) | ((addr32_t) d);
123 naddr->prefix = prefix;
124}
125
126void inet_addr6(inet_addr_t *addr, uint16_t a, uint16_t b, uint16_t c,
127 uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
128{
129 addr->version = ip_v6;
130 addr->addr6[0] = (a >> 8) & 0xff;
131 addr->addr6[1] = a & 0xff;
132 addr->addr6[2] = (b >> 8) & 0xff;
133 addr->addr6[3] = b & 0xff;
134 addr->addr6[4] = (c >> 8) & 0xff;
135 addr->addr6[5] = c & 0xff;
136 addr->addr6[6] = (d >> 8) & 0xff;
137 addr->addr6[7] = d & 0xff;
138 addr->addr6[8] = (e >> 8) & 0xff;
139 addr->addr6[9] = e & 0xff;
140 addr->addr6[10] = (f >> 8) & 0xff;
141 addr->addr6[11] = f & 0xff;
142 addr->addr6[12] = (g >> 8) & 0xff;
143 addr->addr6[13] = g & 0xff;
144 addr->addr6[14] = (h >> 8) & 0xff;
145 addr->addr6[15] = h & 0xff;
146}
147
148void inet_naddr6(inet_naddr_t *naddr, uint16_t a, uint16_t b, uint16_t c,
149 uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
150{
151 naddr->version = ip_v6;
152 naddr->addr6[0] = (a >> 8) & 0xff;
153 naddr->addr6[1] = a & 0xff;
154 naddr->addr6[2] = (b >> 8) & 0xff;
155 naddr->addr6[3] = b & 0xff;
156 naddr->addr6[4] = (c >> 8) & 0xff;
157 naddr->addr6[5] = c & 0xff;
158 naddr->addr6[6] = (d >> 8) & 0xff;
159 naddr->addr6[7] = d & 0xff;
160 naddr->addr6[8] = (e >> 8) & 0xff;
161 naddr->addr6[9] = e & 0xff;
162 naddr->addr6[10] = (f >> 8) & 0xff;
163 naddr->addr6[11] = f & 0xff;
164 naddr->addr6[12] = (g >> 8) & 0xff;
165 naddr->addr6[13] = g & 0xff;
166 naddr->addr6[14] = (h >> 8) & 0xff;
167 naddr->addr6[15] = h & 0xff;
168 naddr->prefix = prefix;
169}
170
171void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
172{
173 addr->version = naddr->version;
174 memcpy(addr->addr6, naddr->addr6, 16);
175}
176
177void inet_addr_naddr(const inet_addr_t *addr, uint8_t prefix,
178 inet_naddr_t *naddr)
179{
180 naddr->version = addr->version;
181 memcpy(naddr->addr6, addr->addr6, 16);
182 naddr->prefix = prefix;
183}
184
185void inet_addr_any(inet_addr_t *addr)
186{
187 addr->version = ip_any;
188 memset(addr->addr6, 0, 16);
189}
190
191void inet_naddr_any(inet_naddr_t *naddr)
192{
193 naddr->version = ip_any;
194 memset(naddr->addr6, 0, 16);
195 naddr->prefix = 0;
196}
197
198int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
199{
200 if (a->version != b->version)
201 return 0;
202
203 switch (a->version) {
204 case ip_v4:
205 return (a->addr == b->addr);
206 case ip_v6:
207 return addr128_compare(a->addr6, b->addr6);
208 default:
209 return 0;
210 }
211}
212
213int inet_addr_is_any(const inet_addr_t *addr)
214{
215 return ((addr->version == ip_any) ||
216 (inet_addr_compare(addr, &inet_addr_any_addr)) ||
217 (inet_addr_compare(addr, &inet_addr_any_addr6)));
218}
219
220int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr)
221{
222 if (naddr->version != addr->version)
223 return 0;
224
225 switch (naddr->version) {
226 case ip_v4:
227 return (naddr->addr == addr->addr);
228 case ip_v6:
229 return addr128_compare(naddr->addr6, addr->addr6);
230 default:
231 return 0;
232 }
233}
234
235int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
236{
237 if (naddr->version != addr->version)
238 return 0;
239
240 switch (naddr->version) {
241 case ip_v4:
242 if (naddr->prefix > 32)
243 return 0;
244
245 addr32_t mask =
246 BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
247 return ((naddr->addr & mask) == (addr->addr & mask));
248 case ip_v6:
249 if (naddr->prefix > 128)
250 return 0;
251
252 size_t pos = 0;
253 for (size_t i = 0; i < 16; i++) {
254 /* Further bits do not matter */
255 if (naddr->prefix < pos)
256 break;
257
258 if (naddr->prefix - pos > 8) {
259 /* Comparison without masking */
260 if (naddr->addr6[i] != addr->addr6[i])
261 return 0;
262 } else {
263 /* Comparison with masking */
264 uint8_t mask =
265 BIT_RANGE(uint8_t, 8, 8 - (naddr->prefix - pos - 1));
266 if ((naddr->addr6[i] & mask) != (addr->addr6[i] & mask))
267 return 0;
268 }
269
270 pos += 8;
271 }
272
273 return 1;
274 default:
275 return 0;
276 }
277}
278
279static errno_t inet_addr_parse_v4(const char *str, inet_addr_t *raddr,
280 int *prefix, char **endptr)
281{
282 uint32_t a = 0;
283 uint8_t b;
284 char *cur = (char *)str;
285 size_t i = 0;
286
287 while (i < 4) {
288 errno_t rc = str_uint8_t(cur, (const char **)&cur, 10, false, &b);
289 if (rc != EOK)
290 return rc;
291
292 a = (a << 8) + b;
293
294 i++;
295
296 if (*cur != '.')
297 break;
298
299 if (i < 4)
300 cur++;
301 }
302
303 if (prefix != NULL) {
304 if (*cur != '/')
305 return EINVAL;
306 cur++;
307
308 *prefix = strtoul(cur, &cur, 10);
309 if (*prefix > 32)
310 return EINVAL;
311 }
312
313 if (i != 4)
314 return EINVAL;
315
316 if (endptr == NULL && *cur != '\0')
317 return EINVAL;
318
319 raddr->version = ip_v4;
320 raddr->addr = a;
321
322 if (endptr != NULL)
323 *endptr = cur;
324
325 return EOK;
326}
327
328static errno_t inet_addr_parse_v6(const char *str, inet_addr_t *raddr, int *prefix,
329 char **endptr)
330{
331 uint8_t data[16];
332 int explicit_groups;
333
334 memset(data, 0, 16);
335
336 const char *cur = str;
337 size_t i = 0;
338 size_t wildcard_pos = (size_t) -1;
339 size_t wildcard_size = 0;
340
341 /* Handle initial wildcard */
342 if ((str[0] == ':') && (str[1] == ':')) {
343 cur = str + 2;
344 wildcard_pos = 0;
345 wildcard_size = 16;
346 }
347
348 while (i < 16) {
349 uint16_t bioctet;
350 const char *gend;
351 errno_t rc = str_uint16_t(cur, &gend, 16, false, &bioctet);
352 if (rc != EOK)
353 break;
354
355 data[i] = (bioctet >> 8) & 0xff;
356 data[i + 1] = bioctet & 0xff;
357
358 if (wildcard_pos != (size_t) -1) {
359 if (wildcard_size < 2)
360 return EINVAL;
361
362 wildcard_size -= 2;
363 }
364
365 i += 2;
366
367 if (*gend != ':') {
368 cur = gend;
369 break;
370 }
371
372 if (i < 16) {
373 /* Handle wildcard */
374 if (gend[1] == ':') {
375 if (wildcard_pos != (size_t) -1)
376 return EINVAL;
377
378 wildcard_pos = i;
379 wildcard_size = 16 - i;
380 cur = gend + 2;
381 }
382 }
383 }
384
385 /* Number of explicitly specified groups */
386 explicit_groups = i;
387
388 if (prefix != NULL) {
389 if (*cur != '/')
390 return EINVAL;
391 cur++;
392
393 *prefix = strtoul(cur, (char **)&cur, 10);
394 if (*prefix > 128)
395 return EINVAL;
396 }
397
398 if (endptr == NULL && *cur != '\0')
399 return EINVAL;
400
401 /* Create wildcard positions */
402 if ((wildcard_pos != (size_t) -1) && (wildcard_size > 0)) {
403 size_t wildcard_shift = 16 - wildcard_size;
404
405 for (i = wildcard_pos + wildcard_shift; i > wildcard_pos; i--) {
406 size_t j = i - 1;
407 data[j + wildcard_size] = data[j];
408 data[j] = 0;
409 }
410 } else {
411 /* Verify that all groups have been specified */
412 if (explicit_groups != 16)
413 return EINVAL;
414 }
415
416 raddr->version = ip_v6;
417 memcpy(raddr->addr6, data, 16);
418 if (endptr != NULL)
419 *endptr = (char *)cur;
420 return EOK;
421}
422
423/** Parse node address.
424 *
425 * Will fail if @a text contains extra characters at the and and @a endptr
426 * is @c NULL.
427 *
428 * @param text Network address in common notation.
429 * @param addr Place to store node address.
430 * @param endptr Place to store pointer to next character oc @c NULL
431 *
432 * @return EOK on success, EINVAL if input is not in valid format.
433 *
434 */
435errno_t inet_addr_parse(const char *text, inet_addr_t *addr, char **endptr)
436{
437 errno_t rc;
438
439 rc = inet_addr_parse_v4(text, addr, NULL, endptr);
440 if (rc == EOK)
441 return EOK;
442
443 rc = inet_addr_parse_v6(text, addr, NULL, endptr);
444 if (rc == EOK)
445 return EOK;
446
447 return EINVAL;
448}
449
450/** Parse network address.
451 *
452 * Will fail if @a text contains extra characters at the and and @a endptr
453 * is @c NULL.
454 *
455 * @param text Network address in common notation.
456 * @param naddr Place to store network address.
457 * @param endptr Place to store pointer to next character oc @c NULL
458 *
459 * @return EOK on success, EINVAL if input is not in valid format.
460 *
461 */
462errno_t inet_naddr_parse(const char *text, inet_naddr_t *naddr, char **endptr)
463{
464 errno_t rc;
465 inet_addr_t addr;
466 int prefix;
467
468 rc = inet_addr_parse_v4(text, &addr, &prefix, endptr);
469 if (rc == EOK) {
470 inet_addr_naddr(&addr, prefix, naddr);
471 return EOK;
472 }
473
474 rc = inet_addr_parse_v6(text, &addr, &prefix, endptr);
475 if (rc == EOK) {
476 inet_addr_naddr(&addr, prefix, naddr);
477 return EOK;
478 }
479
480 return EINVAL;
481}
482
483static errno_t inet_addr_format_v4(addr32_t addr, char **bufp)
484{
485 int rc;
486
487 rc = asprintf(bufp, "%u.%u.%u.%u", (addr >> 24) & 0xff,
488 (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff);
489 if (rc < 0)
490 return ENOMEM;
491
492 return EOK;
493}
494
495static errno_t inet_addr_format_v6(const addr128_t addr, char **bufp)
496{
497 *bufp = (char *) malloc(INET6_ADDRSTRLEN);
498 if (*bufp == NULL)
499 return ENOMEM;
500
501 /* Find the longest zero subsequence */
502
503 uint16_t zeroes[8];
504 uint16_t bioctets[8];
505
506 for (size_t i = 8; i > 0; i--) {
507 size_t j = i - 1;
508
509 bioctets[j] = (addr[j << 1] << 8) | addr[(j << 1) + 1];
510
511 if (bioctets[j] == 0) {
512 zeroes[j] = 1;
513 if (j < 7)
514 zeroes[j] += zeroes[j + 1];
515 } else
516 zeroes[j] = 0;
517 }
518
519 size_t wildcard_pos = (size_t) -1;
520 size_t wildcard_size = 0;
521
522 for (size_t i = 0; i < 8; i++) {
523 if (zeroes[i] > wildcard_size) {
524 wildcard_pos = i;
525 wildcard_size = zeroes[i];
526 }
527 }
528
529 char *cur = *bufp;
530 size_t rest = INET6_ADDRSTRLEN;
531 bool tail_zero = false;
532 int ret;
533
534 for (size_t i = 0; i < 8; i++) {
535 if ((i == wildcard_pos) && (wildcard_size > 1)) {
536 ret = snprintf(cur, rest, ":");
537 i += wildcard_size - 1;
538 tail_zero = true;
539 } else if (i == 0) {
540 ret = snprintf(cur, rest, "%" PRIx16, bioctets[i]);
541 tail_zero = false;
542 } else {
543 ret = snprintf(cur, rest, ":%" PRIx16, bioctets[i]);
544 tail_zero = false;
545 }
546
547 if (ret < 0)
548 return EINVAL;
549
550 cur += ret;
551 rest -= ret;
552 }
553
554 if (tail_zero)
555 (void) snprintf(cur, rest, ":");
556
557 return EOK;
558}
559
560/** Format node address.
561 *
562 * @param addr Node address.
563 * @param bufp Place to store pointer to formatted string.
564 *
565 * @return EOK on success.
566 * @return ENOMEM if out of memory.
567 * @return ENOTSUP on unsupported address family.
568 *
569 */
570errno_t inet_addr_format(const inet_addr_t *addr, char **bufp)
571{
572 errno_t rc;
573 int ret;
574
575 rc = ENOTSUP;
576
577 switch (addr->version) {
578 case ip_any:
579 ret = asprintf(bufp, "none");
580 if (ret < 0)
581 return ENOMEM;
582 rc = EOK;
583 break;
584 case ip_v4:
585 rc = inet_addr_format_v4(addr->addr, bufp);
586 break;
587 case ip_v6:
588 rc = inet_addr_format_v6(addr->addr6, bufp);
589 break;
590 }
591
592 return rc;
593}
594
595/** Format network address.
596 *
597 * @param naddr Network address.
598 * @param bufp Place to store pointer to formatted string.
599 *
600 * @return EOK on success.
601 * @return ENOMEM if out of memory.
602 * @return ENOTSUP on unsupported address family.
603 *
604 */
605errno_t inet_naddr_format(const inet_naddr_t *naddr, char **bufp)
606{
607 errno_t rc;
608 int ret;
609 char *astr;
610
611 rc = ENOTSUP;
612
613 switch (naddr->version) {
614 case ip_any:
615 ret = asprintf(bufp, "none");
616 if (ret < 0)
617 return ENOMEM;
618 rc = EOK;
619 break;
620 case ip_v4:
621 rc = inet_addr_format_v4(naddr->addr, &astr);
622 if (rc != EOK)
623 return ENOMEM;
624
625 ret = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
626 if (ret < 0) {
627 free(astr);
628 return ENOMEM;
629 }
630
631 rc = EOK;
632 break;
633 case ip_v6:
634 rc = inet_addr_format_v6(naddr->addr6, &astr);
635 if (rc != EOK)
636 return ENOMEM;
637
638 ret = asprintf(bufp, "%s/%" PRIu8, astr, naddr->prefix);
639 if (ret < 0) {
640 free(astr);
641 return ENOMEM;
642 }
643
644 rc = EOK;
645 break;
646 }
647
648 return rc;
649}
650
651ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
652{
653 switch (addr->version) {
654 case ip_v4:
655 if (v4 != NULL)
656 *v4 = addr->addr;
657 break;
658 case ip_v6:
659 if (v6 != NULL)
660 memcpy(*v6, addr->addr6, 16);
661 break;
662 default:
663 assert(false);
664 break;
665 }
666
667 return addr->version;
668}
669
670ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
671 uint8_t *prefix)
672{
673 switch (naddr->version) {
674 case ip_v4:
675 if (v4 != NULL)
676 *v4 = naddr->addr;
677 if (prefix != NULL)
678 *prefix = naddr->prefix;
679 break;
680 case ip_v6:
681 if (v6 != NULL)
682 memcpy(*v6, naddr->addr6, 16);
683 if (prefix != NULL)
684 *prefix = naddr->prefix;
685 break;
686 default:
687 assert(false);
688 break;
689 }
690
691 return naddr->version;
692}
693
694void inet_addr_set(addr32_t v4, inet_addr_t *addr)
695{
696 addr->version = ip_v4;
697 addr->addr = v4;
698}
699
700void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
701{
702 naddr->version = ip_v4;
703 naddr->addr = v4;
704 naddr->prefix = prefix;
705}
706
707void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
708{
709 addr->version = ip_v6;
710 memcpy(addr->addr6, v6, 16);
711}
712
713void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
714{
715 naddr->version = ip_v6;
716 memcpy(naddr->addr6, v6, 16);
717 naddr->prefix = prefix;
718}
719
720/** @}
721 */
Note: See TracBrowser for help on using the repository browser.