2 * Copyright (c) 1997-2005 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the Institute nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 #include "krb5_locl.h"
36 RCSID("$Id: addr_families.c,v 1.49 2005/06/16 20:16:12 lha Exp $");
38 struct addr_operations {
40 krb5_address_type atype;
41 size_t max_sockaddr_size;
42 krb5_error_code (*sockaddr2addr)(const struct sockaddr *, krb5_address *);
43 krb5_error_code (*sockaddr2port)(const struct sockaddr *, int16_t *);
44 void (*addr2sockaddr)(const krb5_address *, struct sockaddr *,
45 krb5_socklen_t *sa_size, int port);
46 void (*h_addr2sockaddr)(const char *, struct sockaddr *, krb5_socklen_t *, int);
47 krb5_error_code (*h_addr2addr)(const char *, krb5_address *);
48 krb5_boolean (*uninteresting)(const struct sockaddr *);
49 void (*anyaddr)(struct sockaddr *, krb5_socklen_t *, int);
50 int (*print_addr)(const krb5_address *, char *, size_t);
51 int (*parse_addr)(krb5_context, const char*, krb5_address *);
52 int (*order_addr)(krb5_context, const krb5_address*, const krb5_address*);
53 int (*free_addr)(krb5_context, krb5_address*);
54 int (*copy_addr)(krb5_context, const krb5_address*, krb5_address*);
55 int (*mask_boundary)(krb5_context, const krb5_address*, unsigned long,
56 krb5_address*, krb5_address*);
60 * AF_INET - aka IPv4 implementation
63 static krb5_error_code
64 ipv4_sockaddr2addr (const struct sockaddr *sa, krb5_address *a)
66 const struct sockaddr_in *sin4 = (const struct sockaddr_in *)sa;
69 a->addr_type = KRB5_ADDRESS_INET;
70 memcpy (buf, &sin4->sin_addr, 4);
71 return krb5_data_copy(&a->address, buf, 4);
74 static krb5_error_code
75 ipv4_sockaddr2port (const struct sockaddr *sa, int16_t *port)
77 const struct sockaddr_in *sin4 = (const struct sockaddr_in *)sa;
79 *port = sin4->sin_port;
84 ipv4_addr2sockaddr (const krb5_address *a,
86 krb5_socklen_t *sa_size,
89 struct sockaddr_in tmp;
91 memset (&tmp, 0, sizeof(tmp));
92 tmp.sin_family = AF_INET;
93 memcpy (&tmp.sin_addr, a->address.data, 4);
95 memcpy(sa, &tmp, min(sizeof(tmp), *sa_size));
96 *sa_size = sizeof(tmp);
100 ipv4_h_addr2sockaddr(const char *addr,
102 krb5_socklen_t *sa_size,
105 struct sockaddr_in tmp;
107 memset (&tmp, 0, sizeof(tmp));
108 tmp.sin_family = AF_INET;
110 tmp.sin_addr = *((const struct in_addr *)addr);
111 memcpy(sa, &tmp, min(sizeof(tmp), *sa_size));
112 *sa_size = sizeof(tmp);
115 static krb5_error_code
116 ipv4_h_addr2addr (const char *addr,
119 unsigned char buf[4];
121 a->addr_type = KRB5_ADDRESS_INET;
122 memcpy(buf, addr, 4);
123 return krb5_data_copy(&a->address, buf, 4);
127 * Are there any addresses that should be considered `uninteresting'?
131 ipv4_uninteresting (const struct sockaddr *sa)
133 const struct sockaddr_in *sin4 = (const struct sockaddr_in *)sa;
135 if (sin4->sin_addr.s_addr == INADDR_ANY)
142 ipv4_anyaddr (struct sockaddr *sa, krb5_socklen_t *sa_size, int port)
144 struct sockaddr_in tmp;
146 memset (&tmp, 0, sizeof(tmp));
147 tmp.sin_family = AF_INET;
149 tmp.sin_addr.s_addr = INADDR_ANY;
150 memcpy(sa, &tmp, min(sizeof(tmp), *sa_size));
151 *sa_size = sizeof(tmp);
155 ipv4_print_addr (const krb5_address *addr, char *str, size_t len)
159 memcpy (&ia, addr->address.data, 4);
161 return snprintf (str, len, "IPv4:%s", inet_ntoa(ia));
165 ipv4_parse_addr (krb5_context context, const char *address, krb5_address *addr)
170 p = strchr(address, ':');
173 if(strncasecmp(address, "ip:", p - address) != 0 &&
174 strncasecmp(address, "ip4:", p - address) != 0 &&
175 strncasecmp(address, "ipv4:", p - address) != 0 &&
176 strncasecmp(address, "inet:", p - address) != 0)
180 #ifdef HAVE_INET_ATON
181 if(inet_aton(p, &a) == 0)
183 #elif defined(HAVE_INET_ADDR)
184 a.s_addr = inet_addr(p);
185 if(a.s_addr == INADDR_NONE)
190 addr->addr_type = KRB5_ADDRESS_INET;
191 if(krb5_data_alloc(&addr->address, 4) != 0)
193 _krb5_put_int(addr->address.data, ntohl(a.s_addr), addr->address.length);
198 ipv4_mask_boundary(krb5_context context, const krb5_address *inaddr,
199 unsigned long len, krb5_address *low, krb5_address *high)
202 u_int32_t l, h, m = 0xffffffff;
205 krb5_set_error_string(context, "IPv4 prefix too large (%ld)", len);
206 return KRB5_PROG_ATYPE_NOSUPP;
210 _krb5_get_int(inaddr->address.data, &ia, inaddr->address.length);
215 low->addr_type = KRB5_ADDRESS_INET;
216 if(krb5_data_alloc(&low->address, 4) != 0)
218 _krb5_put_int(low->address.data, l, low->address.length);
220 high->addr_type = KRB5_ADDRESS_INET;
221 if(krb5_data_alloc(&high->address, 4) != 0) {
222 krb5_free_address(context, low);
225 _krb5_put_int(high->address.data, h, high->address.length);
232 * AF_INET6 - aka IPv6 implementation
237 static krb5_error_code
238 ipv6_sockaddr2addr (const struct sockaddr *sa, krb5_address *a)
240 const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
242 if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
243 unsigned char buf[4];
245 a->addr_type = KRB5_ADDRESS_INET;
246 #ifndef IN6_ADDR_V6_TO_V4
247 #ifdef IN6_EXTRACT_V4ADDR
248 #define IN6_ADDR_V6_TO_V4(x) (&IN6_EXTRACT_V4ADDR(x))
250 #define IN6_ADDR_V6_TO_V4(x) ((const struct in_addr *)&(x)->s6_addr[12])
253 memcpy (buf, IN6_ADDR_V6_TO_V4(&sin6->sin6_addr), 4);
254 return krb5_data_copy(&a->address, buf, 4);
256 a->addr_type = KRB5_ADDRESS_INET6;
257 return krb5_data_copy(&a->address,
259 sizeof(sin6->sin6_addr));
263 static krb5_error_code
264 ipv6_sockaddr2port (const struct sockaddr *sa, int16_t *port)
266 const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
268 *port = sin6->sin6_port;
273 ipv6_addr2sockaddr (const krb5_address *a,
275 krb5_socklen_t *sa_size,
278 struct sockaddr_in6 tmp;
280 memset (&tmp, 0, sizeof(tmp));
281 tmp.sin6_family = AF_INET6;
282 memcpy (&tmp.sin6_addr, a->address.data, sizeof(tmp.sin6_addr));
283 tmp.sin6_port = port;
284 memcpy(sa, &tmp, min(sizeof(tmp), *sa_size));
285 *sa_size = sizeof(tmp);
289 ipv6_h_addr2sockaddr(const char *addr,
291 krb5_socklen_t *sa_size,
294 struct sockaddr_in6 tmp;
296 memset (&tmp, 0, sizeof(tmp));
297 tmp.sin6_family = AF_INET6;
298 tmp.sin6_port = port;
299 tmp.sin6_addr = *((const struct in6_addr *)addr);
300 memcpy(sa, &tmp, min(sizeof(tmp), *sa_size));
301 *sa_size = sizeof(tmp);
304 static krb5_error_code
305 ipv6_h_addr2addr (const char *addr,
308 a->addr_type = KRB5_ADDRESS_INET6;
309 return krb5_data_copy(&a->address, addr, sizeof(struct in6_addr));
317 ipv6_uninteresting (const struct sockaddr *sa)
319 const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
320 const struct in6_addr *in6 = (const struct in6_addr *)&sin6->sin6_addr;
323 IN6_IS_ADDR_LINKLOCAL(in6)
324 || IN6_IS_ADDR_V4COMPAT(in6);
328 ipv6_anyaddr (struct sockaddr *sa, krb5_socklen_t *sa_size, int port)
330 struct sockaddr_in6 tmp;
332 memset (&tmp, 0, sizeof(tmp));
333 tmp.sin6_family = AF_INET6;
334 tmp.sin6_port = port;
335 tmp.sin6_addr = in6addr_any;
336 *sa_size = sizeof(tmp);
340 ipv6_print_addr (const krb5_address *addr, char *str, size_t len)
342 char buf[128], buf2[3];
343 #ifdef HAVE_INET_NTOP
344 if(inet_ntop(AF_INET6, addr->address.data, buf, sizeof(buf)) == NULL)
347 /* XXX this is pretty ugly, but better than abort() */
349 unsigned char *p = addr->address.data;
351 for(i = 0; i < addr->address.length; i++) {
352 snprintf(buf2, sizeof(buf2), "%02x", p[i]);
353 if(i > 0 && (i & 1) == 0)
354 strlcat(buf, ":", sizeof(buf));
355 strlcat(buf, buf2, sizeof(buf));
358 return snprintf(str, len, "IPv6:%s", buf);
362 ipv6_parse_addr (krb5_context context, const char *address, krb5_address *addr)
368 p = strchr(address, ':');
371 if(strncasecmp(address, "ip6:", p - address) == 0 ||
372 strncasecmp(address, "ipv6:", p - address) == 0 ||
373 strncasecmp(address, "inet6:", p - address) == 0)
377 ret = inet_pton(AF_INET6, address, &in6.s6_addr);
379 addr->addr_type = KRB5_ADDRESS_INET6;
380 ret = krb5_data_alloc(&addr->address, sizeof(in6.s6_addr));
383 memcpy(addr->address.data, in6.s6_addr, sizeof(in6.s6_addr));
390 ipv6_mask_boundary(krb5_context context, const krb5_address *inaddr,
391 unsigned long len, krb5_address *low, krb5_address *high)
393 struct in6_addr addr, laddr, haddr;
398 krb5_set_error_string(context, "IPv6 prefix too large (%ld)", len);
399 return KRB5_PROG_ATYPE_NOSUPP;
402 if (inaddr->address.length != sizeof(addr)) {
403 krb5_set_error_string(context, "IPv6 addr bad length");
404 return KRB5_PROG_ATYPE_NOSUPP;
407 memcpy(&addr, inaddr->address.data, inaddr->address.length);
409 for (i = 0; i < 16; i++) {
410 sub_len = min(8, len);
412 m = 0xff << (8 - sub_len);
414 laddr.s6_addr[i] = addr.s6_addr[i] & m;
415 haddr.s6_addr[i] = (addr.s6_addr[i] & m) | ~m;
423 low->addr_type = KRB5_ADDRESS_INET6;
424 if (krb5_data_alloc(&low->address, sizeof(laddr.s6_addr)) != 0)
426 memcpy(low->address.data, laddr.s6_addr, sizeof(laddr.s6_addr));
428 high->addr_type = KRB5_ADDRESS_INET6;
429 if (krb5_data_alloc(&high->address, sizeof(haddr.s6_addr)) != 0) {
430 krb5_free_address(context, low);
433 memcpy(high->address.data, haddr.s6_addr, sizeof(haddr.s6_addr));
444 #define KRB5_ADDRESS_ARANGE (-100)
452 arange_parse_addr (krb5_context context,
453 const char *address, krb5_address *addr)
456 krb5_address low0, high0;
460 if(strncasecmp(address, "RANGE:", 6) != 0)
465 p = strrchr(address, '/');
467 krb5_addresses addrmask;
471 if (strlcpy(buf, address, sizeof(buf)) > sizeof(buf))
473 buf[p - address] = '\0';
474 ret = krb5_parse_address(context, buf, &addrmask);
477 if(addrmask.len != 1) {
478 krb5_free_addresses(context, &addrmask);
482 address += p - address + 1;
484 num = strtol(address, &q, 10);
485 if (q == address || *q != '\0' || num < 0) {
486 krb5_free_addresses(context, &addrmask);
490 ret = krb5_address_prefixlen_boundary(context, &addrmask.val[0], num,
492 krb5_free_addresses(context, &addrmask);
497 krb5_addresses low, high;
499 strsep_copy(&address, "-", buf, sizeof(buf));
500 ret = krb5_parse_address(context, buf, &low);
504 krb5_free_addresses(context, &low);
508 strsep_copy(&address, "-", buf, sizeof(buf));
509 ret = krb5_parse_address(context, buf, &high);
511 krb5_free_addresses(context, &low);
515 if(high.len != 1 && high.val[0].addr_type != low.val[0].addr_type) {
516 krb5_free_addresses(context, &low);
517 krb5_free_addresses(context, &high);
521 ret = krb5_copy_address(context, &high.val[0], &high0);
523 ret = krb5_copy_address(context, &low.val[0], &low0);
525 krb5_free_address(context, &high0);
527 krb5_free_addresses(context, &low);
528 krb5_free_addresses(context, &high);
533 krb5_data_alloc(&addr->address, sizeof(*a));
534 addr->addr_type = KRB5_ADDRESS_ARANGE;
535 a = addr->address.data;
537 if(krb5_address_order(context, &low0, &high0) < 0) {
548 arange_free (krb5_context context, krb5_address *addr)
551 a = addr->address.data;
552 krb5_free_address(context, &a->low);
553 krb5_free_address(context, &a->high);
559 arange_copy (krb5_context context, const krb5_address *inaddr,
560 krb5_address *outaddr)
563 struct arange *i, *o;
565 outaddr->addr_type = KRB5_ADDRESS_ARANGE;
566 ret = krb5_data_alloc(&outaddr->address, sizeof(*o));
569 i = inaddr->address.data;
570 o = outaddr->address.data;
571 ret = krb5_copy_address(context, &i->low, &o->low);
573 krb5_data_free(&outaddr->address);
576 ret = krb5_copy_address(context, &i->high, &o->high);
578 krb5_free_address(context, &o->low);
579 krb5_data_free(&outaddr->address);
586 arange_print_addr (const krb5_address *addr, char *str, size_t len)
590 size_t l, size, ret_len;
592 a = addr->address.data;
594 l = strlcpy(str, "RANGE:", len);
600 ret = krb5_print_address (&a->low, str + size, len - size, &l);
609 l = strlcat(str + size, "-", len - size);
616 ret = krb5_print_address (&a->high, str + size, len - size, &l);
625 arange_order_addr(krb5_context context,
626 const krb5_address *addr1,
627 const krb5_address *addr2)
629 int tmp1, tmp2, sign;
631 const krb5_address *a2;
633 if(addr1->addr_type == KRB5_ADDRESS_ARANGE) {
634 a = addr1->address.data;
637 } else if(addr2->addr_type == KRB5_ADDRESS_ARANGE) {
638 a = addr2->address.data;
644 if(a2->addr_type == KRB5_ADDRESS_ARANGE) {
645 struct arange *b = a2->address.data;
646 tmp1 = krb5_address_order(context, &a->low, &b->low);
649 return sign * krb5_address_order(context, &a->high, &b->high);
650 } else if(a2->addr_type == a->low.addr_type) {
651 tmp1 = krb5_address_order(context, &a->low, a2);
654 tmp2 = krb5_address_order(context, &a->high, a2);
659 return sign * (addr1->addr_type - addr2->addr_type);
664 addrport_print_addr (const krb5_address *addr, char *str, size_t len)
667 krb5_address addr1, addr2;
669 size_t ret_len = 0, l, size = 0;
672 sp = krb5_storage_from_data((krb5_data*)rk_UNCONST(&addr->address));
673 /* for totally obscure reasons, these are not in network byteorder */
674 krb5_storage_set_byteorder(sp, KRB5_STORAGE_BYTEORDER_LE);
676 krb5_storage_seek(sp, 2, SEEK_CUR); /* skip first two bytes */
677 krb5_ret_address(sp, &addr1);
679 krb5_storage_seek(sp, 2, SEEK_CUR); /* skip two bytes */
680 krb5_ret_address(sp, &addr2);
681 krb5_storage_free(sp);
682 if(addr2.addr_type == KRB5_ADDRESS_IPPORT && addr2.address.length == 2) {
684 _krb5_get_int(addr2.address.data, &value, 2);
687 l = strlcpy(str, "ADDRPORT:", len);
694 ret = krb5_print_address(&addr1, str + size, len - size, &l);
703 ret = snprintf(str + size, len - size, ",PORT=%u", port);
710 static struct addr_operations at[] = {
711 {AF_INET, KRB5_ADDRESS_INET, sizeof(struct sockaddr_in),
715 ipv4_h_addr2sockaddr,
717 ipv4_uninteresting, ipv4_anyaddr, ipv4_print_addr, ipv4_parse_addr,
718 NULL, NULL, NULL, ipv4_mask_boundary },
720 {AF_INET6, KRB5_ADDRESS_INET6, sizeof(struct sockaddr_in6),
724 ipv6_h_addr2sockaddr,
726 ipv6_uninteresting, ipv6_anyaddr, ipv6_print_addr, ipv6_parse_addr,
727 NULL, NULL, NULL, ipv6_mask_boundary } ,
729 {KRB5_ADDRESS_ADDRPORT, KRB5_ADDRESS_ADDRPORT, 0,
730 NULL, NULL, NULL, NULL, NULL,
731 NULL, NULL, addrport_print_addr, NULL, NULL, NULL, NULL },
732 /* fake address type */
733 {KRB5_ADDRESS_ARANGE, KRB5_ADDRESS_ARANGE, sizeof(struct arange),
734 NULL, NULL, NULL, NULL, NULL, NULL, NULL,
735 arange_print_addr, arange_parse_addr,
736 arange_order_addr, arange_free, arange_copy }
739 static int num_addrs = sizeof(at) / sizeof(at[0]);
741 static size_t max_sockaddr_size = 0;
747 static struct addr_operations *
750 struct addr_operations *a;
752 for (a = at; a < at + num_addrs; ++a)
758 static struct addr_operations *
759 find_atype(int atype)
761 struct addr_operations *a;
763 for (a = at; a < at + num_addrs; ++a)
764 if (atype == a->atype)
769 krb5_error_code KRB5_LIB_FUNCTION
770 krb5_sockaddr2address (krb5_context context,
771 const struct sockaddr *sa, krb5_address *addr)
773 struct addr_operations *a = find_af(sa->sa_family);
775 krb5_set_error_string (context, "Address family %d not supported",
777 return KRB5_PROG_ATYPE_NOSUPP;
779 return (*a->sockaddr2addr)(sa, addr);
782 krb5_error_code KRB5_LIB_FUNCTION
783 krb5_sockaddr2port (krb5_context context,
784 const struct sockaddr *sa, int16_t *port)
786 struct addr_operations *a = find_af(sa->sa_family);
788 krb5_set_error_string (context, "Address family %d not supported",
790 return KRB5_PROG_ATYPE_NOSUPP;
792 return (*a->sockaddr2port)(sa, port);
795 krb5_error_code KRB5_LIB_FUNCTION
796 krb5_addr2sockaddr (krb5_context context,
797 const krb5_address *addr,
799 krb5_socklen_t *sa_size,
802 struct addr_operations *a = find_atype(addr->addr_type);
805 krb5_set_error_string (context, "Address type %d not supported",
807 return KRB5_PROG_ATYPE_NOSUPP;
809 if (a->addr2sockaddr == NULL) {
810 krb5_set_error_string (context, "Can't convert address type %d to sockaddr",
812 return KRB5_PROG_ATYPE_NOSUPP;
814 (*a->addr2sockaddr)(addr, sa, sa_size, port);
818 size_t KRB5_LIB_FUNCTION
819 krb5_max_sockaddr_size (void)
821 if (max_sockaddr_size == 0) {
822 struct addr_operations *a;
824 for(a = at; a < at + num_addrs; ++a)
825 max_sockaddr_size = max(max_sockaddr_size, a->max_sockaddr_size);
827 return max_sockaddr_size;
830 krb5_boolean KRB5_LIB_FUNCTION
831 krb5_sockaddr_uninteresting(const struct sockaddr *sa)
833 struct addr_operations *a = find_af(sa->sa_family);
834 if (a == NULL || a->uninteresting == NULL)
836 return (*a->uninteresting)(sa);
839 krb5_error_code KRB5_LIB_FUNCTION
840 krb5_h_addr2sockaddr (krb5_context context,
842 const char *addr, struct sockaddr *sa,
843 krb5_socklen_t *sa_size,
846 struct addr_operations *a = find_af(af);
848 krb5_set_error_string (context, "Address family %d not supported", af);
849 return KRB5_PROG_ATYPE_NOSUPP;
851 (*a->h_addr2sockaddr)(addr, sa, sa_size, port);
855 krb5_error_code KRB5_LIB_FUNCTION
856 krb5_h_addr2addr (krb5_context context,
858 const char *haddr, krb5_address *addr)
860 struct addr_operations *a = find_af(af);
862 krb5_set_error_string (context, "Address family %d not supported", af);
863 return KRB5_PROG_ATYPE_NOSUPP;
865 return (*a->h_addr2addr)(haddr, addr);
868 krb5_error_code KRB5_LIB_FUNCTION
869 krb5_anyaddr (krb5_context context,
872 krb5_socklen_t *sa_size,
875 struct addr_operations *a = find_af (af);
878 krb5_set_error_string (context, "Address family %d not supported", af);
879 return KRB5_PROG_ATYPE_NOSUPP;
882 (*a->anyaddr)(sa, sa_size, port);
886 krb5_error_code KRB5_LIB_FUNCTION
887 krb5_print_address (const krb5_address *addr,
888 char *str, size_t len, size_t *ret_len)
890 struct addr_operations *a = find_atype(addr->addr_type);
893 if (a == NULL || a->print_addr == NULL) {
899 l = snprintf(s, len, "TYPE_%d:", addr->addr_type);
900 if (l < 0 || l >= len)
904 for(i = 0; i < addr->address.length; i++) {
905 l = snprintf(s, len, "%02x", ((char*)addr->address.data)[i]);
906 if (l < 0 || l >= len)
915 ret = (*a->print_addr)(addr, str, len);
923 krb5_error_code KRB5_LIB_FUNCTION
924 krb5_parse_address(krb5_context context,
926 krb5_addresses *addresses)
929 struct addrinfo *ai, *a;
933 for(i = 0; i < num_addrs; i++) {
934 if(at[i].parse_addr) {
936 if((*at[i].parse_addr)(context, string, &addr) == 0) {
937 ALLOC_SEQ(addresses, 1);
938 addresses->val[0] = addr;
944 error = getaddrinfo (string, NULL, NULL, &ai);
947 krb5_set_error_string (context, "%s: %s", string, gai_strerror(error));
948 return krb5_eai_to_heim_errno(error, save_errno);
952 for (a = ai; a != NULL; a = a->ai_next)
955 ALLOC_SEQ(addresses, n);
956 if (addresses->val == NULL) {
957 krb5_set_error_string(context, "malloc: out of memory");
963 for (a = ai, i = 0; a != NULL; a = a->ai_next) {
964 if (krb5_sockaddr2address (context, ai->ai_addr, &addresses->val[i]))
966 if(krb5_address_search(context, &addresses->val[i], addresses))
975 int KRB5_LIB_FUNCTION
976 krb5_address_order(krb5_context context,
977 const krb5_address *addr1,
978 const krb5_address *addr2)
980 /* this sucks; what if both addresses have order functions, which
981 should we call? this works for now, though */
982 struct addr_operations *a;
983 a = find_atype(addr1->addr_type);
985 krb5_set_error_string (context, "Address family %d not supported",
987 return KRB5_PROG_ATYPE_NOSUPP;
989 if(a->order_addr != NULL)
990 return (*a->order_addr)(context, addr1, addr2);
991 a = find_atype(addr2->addr_type);
993 krb5_set_error_string (context, "Address family %d not supported",
995 return KRB5_PROG_ATYPE_NOSUPP;
997 if(a->order_addr != NULL)
998 return (*a->order_addr)(context, addr1, addr2);
1000 if(addr1->addr_type != addr2->addr_type)
1001 return addr1->addr_type - addr2->addr_type;
1002 if(addr1->address.length != addr2->address.length)
1003 return addr1->address.length - addr2->address.length;
1004 return memcmp (addr1->address.data,
1005 addr2->address.data,
1006 addr1->address.length);
1009 krb5_boolean KRB5_LIB_FUNCTION
1010 krb5_address_compare(krb5_context context,
1011 const krb5_address *addr1,
1012 const krb5_address *addr2)
1014 return krb5_address_order (context, addr1, addr2) == 0;
1017 krb5_boolean KRB5_LIB_FUNCTION
1018 krb5_address_search(krb5_context context,
1019 const krb5_address *addr,
1020 const krb5_addresses *addrlist)
1024 for (i = 0; i < addrlist->len; ++i)
1025 if (krb5_address_compare (context, addr, &addrlist->val[i]))
1030 krb5_error_code KRB5_LIB_FUNCTION
1031 krb5_free_address(krb5_context context,
1032 krb5_address *address)
1034 struct addr_operations *a = find_atype (address->addr_type);
1035 if(a != NULL && a->free_addr != NULL)
1036 return (*a->free_addr)(context, address);
1037 krb5_data_free (&address->address);
1038 memset(address, 0, sizeof(*address));
1042 krb5_error_code KRB5_LIB_FUNCTION
1043 krb5_free_addresses(krb5_context context,
1044 krb5_addresses *addresses)
1047 for(i = 0; i < addresses->len; i++)
1048 krb5_free_address(context, &addresses->val[i]);
1049 free(addresses->val);
1053 krb5_error_code KRB5_LIB_FUNCTION
1054 krb5_copy_address(krb5_context context,
1055 const krb5_address *inaddr,
1056 krb5_address *outaddr)
1058 struct addr_operations *a = find_af (inaddr->addr_type);
1059 if(a != NULL && a->copy_addr != NULL)
1060 return (*a->copy_addr)(context, inaddr, outaddr);
1061 return copy_HostAddress(inaddr, outaddr);
1064 krb5_error_code KRB5_LIB_FUNCTION
1065 krb5_copy_addresses(krb5_context context,
1066 const krb5_addresses *inaddr,
1067 krb5_addresses *outaddr)
1070 ALLOC_SEQ(outaddr, inaddr->len);
1071 if(inaddr->len > 0 && outaddr->val == NULL)
1073 for(i = 0; i < inaddr->len; i++)
1074 krb5_copy_address(context, &inaddr->val[i], &outaddr->val[i]);
1078 krb5_error_code KRB5_LIB_FUNCTION
1079 krb5_append_addresses(krb5_context context,
1080 krb5_addresses *dest,
1081 const krb5_addresses *source)
1084 krb5_error_code ret;
1086 if(source->len > 0) {
1087 tmp = realloc(dest->val, (dest->len + source->len) * sizeof(*tmp));
1089 krb5_set_error_string(context, "realloc: out of memory");
1093 for(i = 0; i < source->len; i++) {
1094 /* skip duplicates */
1095 if(krb5_address_search(context, &source->val[i], dest))
1097 ret = krb5_copy_address(context,
1099 &dest->val[dest->len]);
1109 * Create an address of type KRB5_ADDRESS_ADDRPORT from (addr, port)
1112 krb5_error_code KRB5_LIB_FUNCTION
1113 krb5_make_addrport (krb5_context context,
1114 krb5_address **res, const krb5_address *addr, int16_t port)
1116 krb5_error_code ret;
1117 size_t len = addr->address.length + 2 + 4 * 4;
1120 *res = malloc (sizeof(**res));
1122 krb5_set_error_string(context, "malloc: out of memory");
1125 (*res)->addr_type = KRB5_ADDRESS_ADDRPORT;
1126 ret = krb5_data_alloc (&(*res)->address, len);
1128 krb5_set_error_string(context, "malloc: out of memory");
1132 p = (*res)->address.data;
1135 *p++ = (addr->addr_type ) & 0xFF;
1136 *p++ = (addr->addr_type >> 8) & 0xFF;
1138 *p++ = (addr->address.length ) & 0xFF;
1139 *p++ = (addr->address.length >> 8) & 0xFF;
1140 *p++ = (addr->address.length >> 16) & 0xFF;
1141 *p++ = (addr->address.length >> 24) & 0xFF;
1143 memcpy (p, addr->address.data, addr->address.length);
1144 p += addr->address.length;
1148 *p++ = (KRB5_ADDRESS_IPPORT ) & 0xFF;
1149 *p++ = (KRB5_ADDRESS_IPPORT >> 8) & 0xFF;
1152 *p++ = (2 >> 8) & 0xFF;
1153 *p++ = (2 >> 16) & 0xFF;
1154 *p++ = (2 >> 24) & 0xFF;
1156 memcpy (p, &port, 2);
1163 * Calculate the boundary addresses of `inaddr'/`prefixlen' and store
1164 * them in `low' and `high'.
1167 krb5_error_code KRB5_LIB_FUNCTION
1168 krb5_address_prefixlen_boundary(krb5_context context,
1169 const krb5_address *inaddr,
1170 unsigned long prefixlen,
1174 struct addr_operations *a = find_atype (inaddr->addr_type);
1175 if(a != NULL && a->mask_boundary != NULL)
1176 return (*a->mask_boundary)(context, inaddr, prefixlen, low, high);
1177 krb5_set_error_string(context, "Address family %d doesn't support "
1178 "address mask operation", inaddr->addr_type);
1179 return KRB5_PROG_ATYPE_NOSUPP;