Use standard heimdal function for finding interfaces - libreplace provides support...
[ira/wip.git] / source4 / heimdal / lib / krb5 / get_addrs.c
1 /*
2  * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
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  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
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.
16  *
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.
20  *
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
31  * SUCH DAMAGE.
32  */
33
34 #include "krb5_locl.h"
35
36 RCSID("$Id: get_addrs.c 23815 2008-09-13 09:21:03Z lha $");
37
38 #ifdef __osf__
39 /* hate */
40 struct rtentry;
41 struct mbuf;
42 #endif
43 #ifdef HAVE_NET_IF_H
44 #include <net/if.h>
45 #endif
46 #include <ifaddrs.h>
47
48 static krb5_error_code
49 gethostname_fallback (krb5_context context, krb5_addresses *res)
50 {
51     krb5_error_code ret;
52     char hostname[MAXHOSTNAMELEN];
53     struct hostent *hostent;
54
55     if (gethostname (hostname, sizeof(hostname))) {
56         ret = errno;
57         krb5_set_error_message(context, ret, "gethostname: %s", strerror(ret));
58         return ret;
59     }
60     hostent = roken_gethostbyname (hostname);
61     if (hostent == NULL) {
62         ret = errno;
63         krb5_set_error_message (context, ret, "gethostbyname %s: %s",
64                                 hostname, strerror(ret));
65         return ret;
66     }
67     res->len = 1;
68     res->val = malloc (sizeof(*res->val));
69     if (res->val == NULL) {
70         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
71         return ENOMEM;
72     }
73     res->val[0].addr_type = hostent->h_addrtype;
74     res->val[0].address.data = NULL;
75     res->val[0].address.length = 0;
76     ret = krb5_data_copy (&res->val[0].address,
77                           hostent->h_addr,
78                           hostent->h_length);
79     if (ret) {
80         free (res->val);
81         return ret;
82     }
83     return 0;
84 }
85
86 enum {
87     LOOP            = 1,        /* do include loopback interfaces */
88     LOOP_IF_NONE    = 2,        /* include loopback if no other if's */
89     EXTRA_ADDRESSES = 4,        /* include extra addresses */
90     SCAN_INTERFACES = 8         /* scan interfaces for addresses */
91 };
92
93 /*
94  * Try to figure out the addresses of all configured interfaces with a
95  * lot of magic ioctls.
96  */
97
98 static krb5_error_code
99 find_all_addresses (krb5_context context, krb5_addresses *res, int flags)
100 {
101     struct sockaddr sa_zero;
102     struct ifaddrs *ifa0, *ifa;
103     krb5_error_code ret = ENXIO;
104     unsigned int num, idx;
105     krb5_addresses ignore_addresses;
106
107     res->val = NULL;
108
109     if (getifaddrs(&ifa0) == -1) {
110         ret = errno;
111         krb5_set_error_message(context, ret, "getifaddrs: %s", strerror(ret));
112         return (ret);
113     }
114
115     memset(&sa_zero, 0, sizeof(sa_zero));
116
117     /* First, count all the ifaddrs. */
118     for (ifa = ifa0, num = 0; ifa != NULL; ifa = ifa->ifa_next, num++)
119         /* nothing */;
120
121     if (num == 0) {
122         freeifaddrs(ifa0);
123         krb5_set_error_message(context, ENXIO, N_("no addresses found", ""));
124         return (ENXIO);
125     }
126
127     if (flags & EXTRA_ADDRESSES) {
128         /* we'll remove the addresses we don't care about */
129         ret = krb5_get_ignore_addresses(context, &ignore_addresses);
130         if(ret)
131             return ret;
132     }
133
134     /* Allocate storage for them. */
135     res->val = calloc(num, sizeof(*res->val));
136     if (res->val == NULL) {
137         krb5_free_addresses(context, &ignore_addresses);
138         freeifaddrs(ifa0);
139         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
140         return ENOMEM;
141     }
142
143     /* Now traverse the list. */
144     for (ifa = ifa0, idx = 0; ifa != NULL; ifa = ifa->ifa_next) {
145         if ((ifa->ifa_flags & IFF_UP) == 0)
146             continue;
147         if (ifa->ifa_addr == NULL)
148             continue;
149         if (memcmp(ifa->ifa_addr, &sa_zero, sizeof(sa_zero)) == 0)
150             continue;
151         if (krb5_sockaddr_uninteresting(ifa->ifa_addr))
152             continue;
153         if ((ifa->ifa_flags & IFF_LOOPBACK) != 0) {
154             /* We'll deal with the LOOP_IF_NONE case later. */
155             if ((flags & LOOP) == 0)
156                 continue;
157         }
158
159         ret = krb5_sockaddr2address(context, ifa->ifa_addr, &res->val[idx]);
160         if (ret) {
161             /*
162              * The most likely error here is going to be "Program
163              * lacks support for address type".  This is no big
164              * deal -- just continue, and we'll listen on the
165              * addresses who's type we *do* support.
166              */
167             continue;
168         }
169         /* possibly skip this address? */
170         if((flags & EXTRA_ADDRESSES) &&
171            krb5_address_search(context, &res->val[idx], &ignore_addresses)) {
172             krb5_free_address(context, &res->val[idx]);
173             flags &= ~LOOP_IF_NONE; /* we actually found an address,
174                                        so don't add any loop-back
175                                        addresses */
176             continue;
177         }
178
179         idx++;
180     }
181
182     /*
183      * If no addresses were found, and LOOP_IF_NONE is set, then find
184      * the loopback addresses and add them to our list.
185      */
186     if ((flags & LOOP_IF_NONE) != 0 && idx == 0) {
187         for (ifa = ifa0; ifa != NULL; ifa = ifa->ifa_next) {
188             if ((ifa->ifa_flags & IFF_UP) == 0)
189                 continue;
190             if (ifa->ifa_addr == NULL)
191                 continue;
192             if (memcmp(ifa->ifa_addr, &sa_zero, sizeof(sa_zero)) == 0)
193                 continue;
194             if (krb5_sockaddr_uninteresting(ifa->ifa_addr))
195                 continue;
196
197             if ((ifa->ifa_flags & IFF_LOOPBACK) != 0) {
198                 ret = krb5_sockaddr2address(context,
199                                             ifa->ifa_addr, &res->val[idx]);
200                 if (ret) {
201                     /*
202                      * See comment above.
203                      */
204                     continue;
205                 }
206                 if((flags & EXTRA_ADDRESSES) &&
207                    krb5_address_search(context, &res->val[idx],
208                                        &ignore_addresses)) {
209                     krb5_free_address(context, &res->val[idx]);
210                     continue;
211                 }
212                 idx++;
213             }
214         }
215     }
216
217     if (flags & EXTRA_ADDRESSES)
218         krb5_free_addresses(context, &ignore_addresses);
219     freeifaddrs(ifa0);
220     if (ret) {
221         free(res->val);
222         res->val = NULL;
223     } else
224         res->len = idx;        /* Now a count. */
225     return (ret);
226 }
227
228 static krb5_error_code
229 get_addrs_int (krb5_context context, krb5_addresses *res, int flags)
230 {
231     krb5_error_code ret = -1;
232
233     if (flags & SCAN_INTERFACES) {
234         ret = find_all_addresses (context, res, flags);
235         if(ret || res->len == 0)
236             ret = gethostname_fallback (context, res);
237     } else {
238         res->len = 0;
239         res->val = NULL;
240         ret = 0;
241     }
242
243     if(ret == 0 && (flags & EXTRA_ADDRESSES)) {
244         krb5_addresses a;
245         /* append user specified addresses */
246         ret = krb5_get_extra_addresses(context, &a);
247         if(ret) {
248             krb5_free_addresses(context, res);
249             return ret;
250         }
251         ret = krb5_append_addresses(context, res, &a);
252         if(ret) {
253             krb5_free_addresses(context, res);
254             return ret;
255         }
256         krb5_free_addresses(context, &a);
257     }
258     if(res->len == 0) {
259         free(res->val);
260         res->val = NULL;
261     }
262     return ret;
263 }
264
265 /*
266  * Try to get all addresses, but return the one corresponding to
267  * `hostname' if we fail.
268  *
269  * Only include loopback address if there are no other.
270  */
271
272 krb5_error_code KRB5_LIB_FUNCTION
273 krb5_get_all_client_addrs (krb5_context context, krb5_addresses *res)
274 {
275     int flags = LOOP_IF_NONE | EXTRA_ADDRESSES;
276
277     if (context->scan_interfaces)
278         flags |= SCAN_INTERFACES;
279
280     return get_addrs_int (context, res, flags);
281 }
282
283 /*
284  * Try to get all local addresses that a server should listen to.
285  * If that fails, we return the address corresponding to `hostname'.
286  */
287
288 krb5_error_code KRB5_LIB_FUNCTION
289 krb5_get_all_server_addrs (krb5_context context, krb5_addresses *res)
290 {
291     return get_addrs_int (context, res, LOOP | SCAN_INTERFACES);
292 }