Changes in uspace/lib/c/generic/inet/addr.c [83781a22:26de91a] in mainline
- File:
-
- 1 edited
-
uspace/lib/c/generic/inet/addr.c (modified) (30 diffs)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/c/generic/inet/addr.c
r83781a22 r26de91a 33 33 */ 34 34 35 #include <assert.h> 35 36 #include <errno.h> 36 37 #include <unistd.h> … … 48 49 #endif 49 50 51 const addr32_t addr32_broadcast_all_hosts = 0xffffffff; 52 50 53 const addr48_t addr48_broadcast = { 51 54 0xff, 0xff, 0xff, 0xff, 0xff, 0xff … … 57 60 58 61 static const inet_addr_t inet_addr_any_addr = { 59 . family = AF_INET,62 .version = ip_v4, 60 63 .addr = 0 61 64 }; 62 65 63 66 static const inet_addr_t inet_addr_any_addr6 = { 64 . family = AF_INET6,67 .version = ip_v6, 65 68 .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} 66 69 }; … … 76 79 } 77 80 81 /** Compare addr48. 82 * 83 * @return Non-zero if equal, zero if not equal. 84 */ 78 85 int addr48_compare(const addr48_t a, const addr48_t b) 79 86 { 80 return memcmp(a, b, 6); 81 } 82 87 return memcmp(a, b, 6) == 0; 88 } 89 90 /** Compare addr128. 91 * 92 * @return Non-zero if equal, zero if not equal. 93 */ 83 94 int addr128_compare(const addr128_t a, const addr128_t b) 84 95 { 85 return memcmp(a, b, 16) ;96 return memcmp(a, b, 16) == 0; 86 97 } 87 98 … … 100 111 void host2addr128_t_be(const addr128_t host, addr128_t be) 101 112 { 102 #ifdef __BE__103 113 memcpy(be, host, 16); 104 #else105 be[0] = host[15];106 be[1] = host[14];107 be[2] = host[13];108 be[3] = host[12];109 be[4] = host[11];110 be[5] = host[10];111 be[6] = host[9];112 be[7] = host[8];113 be[8] = host[7];114 be[9] = host[6];115 be[10] = host[5];116 be[11] = host[4];117 be[12] = host[3];118 be[13] = host[2];119 be[14] = host[1];120 be[15] = host[0];121 #endif122 114 } 123 115 124 116 void addr128_t_be2host(const addr128_t be, addr128_t host) 125 117 { 126 #ifdef __BE__127 118 memcpy(host, be, 16); 128 #else129 host[0] = be[15];130 host[1] = be[14];131 host[2] = be[13];132 host[3] = be[12];133 host[4] = be[11];134 host[5] = be[10];135 host[6] = be[9];136 host[7] = be[8];137 host[8] = be[7];138 host[9] = be[6];139 host[10] = be[5];140 host[11] = be[4];141 host[12] = be[3];142 host[13] = be[2];143 host[14] = be[1];144 host[15] = be[0];145 #endif146 119 } 147 120 148 121 void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d) 149 122 { 150 addr-> family = AF_INET;123 addr->version = ip_v4; 151 124 addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) | 152 125 ((addr32_t) c << 8) | ((addr32_t) d); … … 156 129 uint8_t prefix) 157 130 { 158 naddr-> family = AF_INET;131 naddr->version = ip_v4; 159 132 naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) | 160 133 ((addr32_t) c << 8) | ((addr32_t) d); … … 165 138 uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h) 166 139 { 167 addr-> family = AF_INET6;140 addr->version = ip_v6; 168 141 addr->addr6[0] = (a >> 8) & 0xff; 169 142 addr->addr6[1] = a & 0xff; … … 187 160 uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix) 188 161 { 189 naddr-> family = AF_INET6;162 naddr->version = ip_v6; 190 163 naddr->addr6[0] = (a >> 8) & 0xff; 191 164 naddr->addr6[1] = a & 0xff; … … 207 180 } 208 181 209 /** Parse network address family.210 * 211 * @param text Network address in common notation.212 * @param af Place to store network address family.182 /** Determine address version. 183 * 184 * @param text Address in common notation. 185 * @param af Place to store address version. 213 186 * 214 187 * @return EOK on success, EINVAL if input is not in valid format. 215 188 * 216 189 */ 217 int inet_addr_family(const char *text, uint16_t *af)190 static int inet_addr_version(const char *text, ip_ver_t *ver) 218 191 { 219 192 char *dot = str_chr(text, '.'); 220 193 if (dot != NULL) { 221 * af = AF_INET;194 *ver = ip_v4; 222 195 return EOK; 223 196 } 224 197 225 198 char *collon = str_chr(text, ':'); 226 199 if (collon != NULL) { 227 * af = AF_INET6;200 *ver = ip_v6; 228 201 return EOK; 229 202 } 230 203 231 204 return EINVAL; 232 205 } 233 206 207 static int ipver_af(ip_ver_t ver) 208 { 209 switch (ver) { 210 case ip_any: 211 return AF_NONE; 212 case ip_v4: 213 return AF_INET; 214 case ip_v6: 215 return AF_INET6; 216 default: 217 assert(false); 218 return EINVAL; 219 } 220 } 221 222 ip_ver_t ipver_from_af(int af) 223 { 224 switch (af) { 225 case AF_NONE: 226 return ip_any; 227 case AF_INET: 228 return ip_v4; 229 case AF_INET6: 230 return ip_v6; 231 default: 232 assert(false); 233 return EINVAL; 234 } 235 } 236 234 237 void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr) 235 238 { 236 addr-> family = naddr->family;239 addr->version = naddr->version; 237 240 memcpy(addr->addr6, naddr->addr6, 16); 238 241 } … … 241 244 inet_naddr_t *naddr) 242 245 { 243 naddr-> family = addr->family;246 naddr->version = addr->version; 244 247 memcpy(naddr->addr6, addr->addr6, 16); 245 248 naddr->prefix = prefix; … … 248 251 void inet_addr_any(inet_addr_t *addr) 249 252 { 250 addr-> family = AF_NONE;253 addr->version = ip_any; 251 254 memset(addr->addr6, 0, 16); 252 255 } … … 254 257 void inet_naddr_any(inet_naddr_t *naddr) 255 258 { 256 naddr-> family = AF_NONE;259 naddr->version = ip_any; 257 260 memset(naddr->addr6, 0, 16); 258 261 naddr->prefix = 0; … … 261 264 int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b) 262 265 { 263 if (a-> family != b->family)266 if (a->version != b->version) 264 267 return 0; 265 266 switch (a-> family) {267 case AF_INET:268 269 switch (a->version) { 270 case ip_v4: 268 271 return (a->addr == b->addr); 269 case AF_INET6:272 case ip_v6: 270 273 return addr128_compare(a->addr6, b->addr6); 271 274 default: … … 276 279 int inet_addr_is_any(const inet_addr_t *addr) 277 280 { 278 return ((addr-> family == 0) ||281 return ((addr->version == ip_any) || 279 282 (inet_addr_compare(addr, &inet_addr_any_addr)) || 280 283 (inet_addr_compare(addr, &inet_addr_any_addr6))); … … 283 286 int inet_naddr_compare(const inet_naddr_t *naddr, const inet_addr_t *addr) 284 287 { 285 if (naddr-> family != addr->family)288 if (naddr->version != addr->version) 286 289 return 0; 287 290 288 switch (naddr-> family) {289 case AF_INET:291 switch (naddr->version) { 292 case ip_v4: 290 293 return (naddr->addr == addr->addr); 291 case AF_INET6:294 case ip_v6: 292 295 return addr128_compare(naddr->addr6, addr->addr6); 293 296 default: … … 298 301 int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr) 299 302 { 300 if (naddr-> family != addr->family)303 if (naddr->version != addr->version) 301 304 return 0; 302 303 switch (naddr-> family) {304 case AF_INET:305 306 switch (naddr->version) { 307 case ip_v4: 305 308 if (naddr->prefix > 32) 306 309 return 0; 307 310 308 311 addr32_t mask = 309 312 BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1)); 310 313 return ((naddr->addr & mask) == (addr->addr & mask)); 311 case AF_INET6:314 case ip_v6: 312 315 if (naddr->prefix > 128) 313 316 return 0; … … 350 353 int inet_addr_parse(const char *text, inet_addr_t *addr) 351 354 { 352 int rc = inet_addr_ family(text, &addr->family);355 int rc = inet_addr_version(text, &addr->version); 353 356 if (rc != EOK) 354 357 return rc; 355 358 356 359 uint8_t buf[16]; 357 rc = inet_pton( addr->family, text, buf);360 rc = inet_pton(ipver_af(addr->version), text, buf); 358 361 if (rc != EOK) 359 362 return rc; 360 363 361 switch (addr-> family) {362 case AF_INET:364 switch (addr->version) { 365 case ip_v4: 363 366 addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | 364 367 buf[3]; 365 368 break; 366 case AF_INET6:369 case ip_v6: 367 370 memcpy(addr->addr6, buf, 16); 368 371 break; … … 390 393 *slash = 0; 391 394 392 int rc = inet_addr_ family(text, &naddr->family);395 int rc = inet_addr_version(text, &naddr->version); 393 396 if (rc != EOK) 394 397 return rc; 395 398 396 399 uint8_t buf[16]; 397 rc = inet_pton( naddr->family, text, buf);400 rc = inet_pton(ipver_af(naddr->version), text, buf); 398 401 *slash = '/'; 399 402 … … 404 407 uint8_t prefix; 405 408 406 switch (naddr-> family) {407 case AF_INET:409 switch (naddr->version) { 410 case ip_v4: 408 411 prefix = strtoul(slash, &slash, 10); 409 412 if (prefix > 32) … … 415 418 416 419 break; 417 case AF_INET6:420 case ip_v6: 418 421 prefix = strtoul(slash, &slash, 10); 419 422 if (prefix > 128) … … 445 448 int rc = 0; 446 449 447 switch (addr-> family) {448 case AF_NONE:450 switch (addr->version) { 451 case ip_any: 449 452 rc = asprintf(bufp, "none"); 450 453 break; 451 case AF_INET:454 case ip_v4: 452 455 rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff, 453 456 (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff, 454 457 addr->addr & 0xff); 455 458 break; 456 case AF_INET6:459 case ip_v6: 457 460 *bufp = (char *) malloc(INET6_ADDRSTRLEN); 458 461 if (*bufp == NULL) … … 485 488 char prefix[INET_PREFIXSTRSIZE]; 486 489 487 switch (naddr-> family) {488 case AF_NONE:490 switch (naddr->version) { 491 case ip_any: 489 492 rc = asprintf(bufp, "none"); 490 493 break; 491 case AF_INET:494 case ip_v4: 492 495 rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8 493 496 "/%" PRIu8, (naddr->addr >> 24) & 0xff, … … 495 498 naddr->addr & 0xff, naddr->prefix); 496 499 break; 497 case AF_INET6:500 case ip_v6: 498 501 *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE); 499 502 if (*bufp == NULL) … … 527 530 } 528 531 529 uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)530 { 531 switch (addr-> family) {532 case AF_INET:532 ip_ver_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6) 533 { 534 switch (addr->version) { 535 case ip_v4: 533 536 if (v4 != NULL) 534 537 *v4 = addr->addr; 535 536 break; 537 case AF_INET6: 538 break; 539 case ip_v6: 538 540 if (v6 != NULL) 539 541 memcpy(*v6, addr->addr6, 16); 540 541 break; 542 } 543 544 return addr->family; 545 } 546 547 uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6, 542 break; 543 default: 544 assert(false); 545 break; 546 } 547 548 return addr->version; 549 } 550 551 ip_ver_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6, 548 552 uint8_t *prefix) 549 553 { 550 switch (naddr-> family) {551 case AF_INET:554 switch (naddr->version) { 555 case ip_v4: 552 556 if (v4 != NULL) 553 557 *v4 = naddr->addr; 554 555 558 if (prefix != NULL) 556 559 *prefix = naddr->prefix; 557 558 break; 559 case AF_INET6: 560 break; 561 case ip_v6: 560 562 if (v6 != NULL) 561 563 memcpy(*v6, naddr->addr6, 16); 562 563 564 if (prefix != NULL) 564 565 *prefix = naddr->prefix; 565 566 break; 567 } 568 569 return naddr->family; 566 break; 567 default: 568 assert(false); 569 break; 570 } 571 572 return naddr->version; 570 573 } 571 574 572 575 void inet_addr_set(addr32_t v4, inet_addr_t *addr) 573 576 { 574 addr-> family = AF_INET;577 addr->version = ip_v4; 575 578 addr->addr = v4; 576 579 } … … 578 581 void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr) 579 582 { 580 naddr-> family = AF_INET;583 naddr->version = ip_v4; 581 584 naddr->addr = v4; 582 585 naddr->prefix = prefix; … … 585 588 void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr) 586 589 { 587 addr-> family = AF_INET;590 addr->version = ip_v4; 588 591 addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr); 589 592 } … … 591 594 void inet_addr_set6(addr128_t v6, inet_addr_t *addr) 592 595 { 593 addr-> family = AF_INET6;596 addr->version = ip_v6; 594 597 memcpy(addr->addr6, v6, 16); 595 598 } … … 597 600 void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr) 598 601 { 599 naddr-> family = AF_INET6;602 naddr->version = ip_v6; 600 603 memcpy(naddr->addr6, v6, 16); 601 604 naddr->prefix = prefix; … … 605 608 inet_addr_t *addr) 606 609 { 607 addr-> family = AF_INET6;610 addr->version = ip_v6; 608 611 addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6); 609 612 } … … 612 615 sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6) 613 616 { 614 switch (addr-> family) {615 case AF_INET:617 switch (addr->version) { 618 case ip_v4: 616 619 if (sockaddr_in != NULL) { 617 620 sockaddr_in->sin_family = AF_INET; 618 621 sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr); 619 622 } 620 621 break; 622 case AF_INET6: 623 break; 624 case ip_v6: 623 625 if (sockaddr_in6 != NULL) { 624 626 sockaddr_in6->sin6_family = AF_INET6; 625 627 host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr); 626 628 } 627 628 break; 629 } 630 631 return addr->family; 629 break; 630 default: 631 assert(false); 632 break; 633 } 634 635 return ipver_af(addr->version); 636 } 637 638 int inet_addr_sockaddr(const inet_addr_t *addr, uint16_t port, 639 sockaddr_t **nsockaddr, socklen_t *naddrlen) 640 { 641 sockaddr_in_t *sa4; 642 sockaddr_in6_t *sa6; 643 644 switch (addr->version) { 645 case ip_v4: 646 sa4 = calloc(1, sizeof(sockaddr_in_t)); 647 if (sa4 == NULL) 648 return ENOMEM; 649 650 sa4->sin_family = AF_INET; 651 sa4->sin_port = host2uint16_t_be(port); 652 sa4->sin_addr.s_addr = host2uint32_t_be(addr->addr); 653 if (nsockaddr != NULL) 654 *nsockaddr = (sockaddr_t *)sa4; 655 if (naddrlen != NULL) 656 *naddrlen = sizeof(*sa4); 657 break; 658 case ip_v6: 659 sa6 = calloc(1, sizeof(sockaddr_in6_t)); 660 if (sa6 == NULL) 661 return ENOMEM; 662 663 sa6->sin6_family = AF_INET6; 664 sa6->sin6_port = host2uint16_t_be(port); 665 host2addr128_t_be(addr->addr6, sa6->sin6_addr.s6_addr); 666 if (nsockaddr != NULL) 667 *nsockaddr = (sockaddr_t *)sa6; 668 if (naddrlen != NULL) 669 *naddrlen = sizeof(*sa6); 670 break; 671 default: 672 assert(false); 673 break; 674 } 675 676 return EOK; 632 677 } 633 678
Note:
See TracChangeset
for help on using the changeset viewer.
