source: branches/samba-3.0/source/lib/interface.c@ 161

Last change on this file since 161 was 158, checked in by Paul Smedley, 17 years ago

Update source to 3.0.32
File size: 10.1 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 multiple interface handling
4 Copyright (C) Andrew Tridgell 1992-1998
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
21#include "includes.h"
22
23static struct iface_struct *probed_ifaces;
24static int total_probed;
25
26struct in_addr allones_ip;
27struct in_addr loopback_ip;
28
29static struct interface *local_interfaces;
30
31#define ALLONES ((uint32)0xFFFFFFFF)
32#define MKBCADDR(_IP, _NM) ((_IP & _NM) | (_NM ^ ALLONES))
33#define MKNETADDR(_IP, _NM) (_IP & _NM)
34
35/****************************************************************************
36Try and find an interface that matches an ip. If we cannot, return NULL
37 **************************************************************************/
38static struct interface *iface_find(struct in_addr ip, BOOL CheckMask)
39{
40 struct interface *i;
41 if (is_zero_ip(ip)) return local_interfaces;
42
43 for (i=local_interfaces;i;i=i->next)
44 if (CheckMask) {
45 if (same_net(i->ip,ip,i->nmask)) return i;
46 } else if ((i->ip).s_addr == ip.s_addr) return i;
47
48 return NULL;
49}
50
51
52/****************************************************************************
53add an interface to the linked list of interfaces
54****************************************************************************/
55static void add_interface(struct in_addr ip, struct in_addr nmask)
56{
57 struct interface *iface;
58 if (iface_find(ip, False)) {
59 DEBUG(3,("not adding duplicate interface %s\n",inet_ntoa(ip)));
60 return;
61 }
62
63#if !defined(__s390__)
64 if (ip_equal(nmask, allones_ip)) {
65 DEBUG(3,("not adding non-broadcast interface %s\n",inet_ntoa(ip)));
66 return;
67 }
68#endif
69
70 iface = SMB_MALLOC_P(struct interface);
71 if (!iface) return;
72
73 ZERO_STRUCTPN(iface);
74
75 iface->ip = ip;
76 iface->nmask = nmask;
77 iface->bcast.s_addr = MKBCADDR(iface->ip.s_addr, iface->nmask.s_addr);
78
79 DLIST_ADD(local_interfaces, iface);
80
81 DEBUG(2,("added interface ip=%s ",inet_ntoa(iface->ip)));
82 DEBUG(2,("bcast=%s ",inet_ntoa(iface->bcast)));
83 DEBUG(2,("nmask=%s\n",inet_ntoa(iface->nmask)));
84}
85
86
87
88/****************************************************************************
89interpret a single element from a interfaces= config line
90
91This handles the following different forms:
92
931) wildcard interface name
942) DNS name
953) IP/masklen
964) ip/mask
975) bcast/mask
98****************************************************************************/
99static void interpret_interface(char *token)
100{
101 struct in_addr ip, nmask;
102 char *p;
103 int i, added=0;
104
105 zero_ip(&ip);
106 zero_ip(&nmask);
107
108 /* first check if it is an interface name */
109 for (i=0;i<total_probed;i++) {
110 if (gen_fnmatch(token, probed_ifaces[i].name) == 0) {
111 add_interface(probed_ifaces[i].ip,
112 probed_ifaces[i].netmask);
113 added = 1;
114 }
115 }
116 if (added) return;
117
118 /* maybe it is a DNS name */
119 p = strchr_m(token,'/');
120 if (!p) {
121 ip = *interpret_addr2(token);
122 for (i=0;i<total_probed;i++) {
123 if (ip.s_addr == probed_ifaces[i].ip.s_addr &&
124 !ip_equal(allones_ip, probed_ifaces[i].netmask)) {
125 add_interface(probed_ifaces[i].ip,
126 probed_ifaces[i].netmask);
127 return;
128 }
129 }
130 DEBUG(2,("can't determine netmask for %s\n", token));
131 return;
132 }
133
134 /* parse it into an IP address/netmasklength pair */
135 *p = 0;
136 ip = *interpret_addr2(token);
137 *p++ = '/';
138
139 if (strlen(p) > 2) {
140 nmask = *interpret_addr2(p);
141 } else {
142 nmask.s_addr = htonl(((ALLONES >> atoi(p)) ^ ALLONES));
143 }
144
145 /* maybe the first component was a broadcast address */
146 if (ip.s_addr == MKBCADDR(ip.s_addr, nmask.s_addr) ||
147 ip.s_addr == MKNETADDR(ip.s_addr, nmask.s_addr)) {
148 for (i=0;i<total_probed;i++) {
149 if (same_net(ip, probed_ifaces[i].ip, nmask)) {
150 add_interface(probed_ifaces[i].ip, nmask);
151 return;
152 }
153 }
154 DEBUG(2,("Can't determine ip for broadcast address %s\n", token));
155 return;
156 }
157
158 add_interface(ip, nmask);
159}
160
161
162/****************************************************************************
163load the list of network interfaces
164****************************************************************************/
165void load_interfaces(void)
166{
167 const char **ptr;
168 int i;
169 struct iface_struct ifaces[MAX_INTERFACES];
170
171 ptr = lp_interfaces();
172
173 allones_ip = *interpret_addr2("255.255.255.255");
174 loopback_ip = *interpret_addr2("127.0.0.1");
175
176 SAFE_FREE(probed_ifaces);
177
178 /* dump the current interfaces if any */
179 while (local_interfaces) {
180 struct interface *iface = local_interfaces;
181 DLIST_REMOVE(local_interfaces, local_interfaces);
182 ZERO_STRUCTPN(iface);
183 SAFE_FREE(iface);
184 }
185
186 /* probe the kernel for interfaces */
187 total_probed = get_interfaces(ifaces, MAX_INTERFACES);
188
189 if (total_probed > 0) {
190 probed_ifaces = (struct iface_struct *)memdup(ifaces, sizeof(ifaces[0])*total_probed);
191 if (!probed_ifaces) {
192 DEBUG(0,("ERROR: memdup failed\n"));
193 exit(1);
194 }
195 }
196
197 /* if we don't have a interfaces line then use all broadcast capable
198 interfaces except loopback */
199 if (!ptr || !*ptr || !**ptr) {
200 if (total_probed <= 0) {
201 DEBUG(0,("ERROR: Could not determine network interfaces, you must use a interfaces config line\n"));
202 exit(1);
203 }
204 for (i=0;i<total_probed;i++) {
205 if (
206#if !defined(__s390__)
207 probed_ifaces[i].netmask.s_addr != allones_ip.s_addr &&
208#endif
209 probed_ifaces[i].ip.s_addr != loopback_ip.s_addr) {
210 add_interface(probed_ifaces[i].ip,
211 probed_ifaces[i].netmask);
212 }
213 }
214 return;
215 }
216
217 if (ptr) {
218 while (*ptr) {
219 char *ptr_cpy = SMB_STRDUP(*ptr);
220 if (ptr_cpy) {
221 interpret_interface(ptr_cpy);
222 free(ptr_cpy);
223 }
224 ptr++;
225 }
226 }
227
228 if (!local_interfaces) {
229 DEBUG(0,("WARNING: no network interfaces found\n"));
230 }
231}
232
233
234void gfree_interfaces(void)
235{
236 while (local_interfaces) {
237 struct interface *iface = local_interfaces;
238 DLIST_REMOVE(local_interfaces, local_interfaces);
239 ZERO_STRUCTPN(iface);
240 SAFE_FREE(iface);
241 }
242
243 SAFE_FREE(probed_ifaces);
244}
245
246/****************************************************************************
247return True if the list of probed interfaces has changed
248****************************************************************************/
249BOOL interfaces_changed(void)
250{
251 int n;
252 struct iface_struct ifaces[MAX_INTERFACES];
253
254 n = get_interfaces(ifaces, MAX_INTERFACES);
255
256 if ((n > 0 )&& (n != total_probed ||
257 memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n))) {
258 return True;
259 }
260
261 return False;
262}
263
264
265/****************************************************************************
266 check if an IP is one of mine
267 **************************************************************************/
268BOOL ismyip(struct in_addr ip)
269{
270 struct interface *i;
271 for (i=local_interfaces;i;i=i->next)
272 if (ip_equal(i->ip,ip)) return True;
273 return False;
274}
275
276/****************************************************************************
277 check if a packet is from a local (known) net
278 **************************************************************************/
279BOOL is_local_net(struct in_addr from)
280{
281 struct interface *i;
282 for (i=local_interfaces;i;i=i->next) {
283 if((from.s_addr & i->nmask.s_addr) ==
284 (i->ip.s_addr & i->nmask.s_addr))
285 return True;
286 }
287 return False;
288}
289
290/****************************************************************************
291 how many interfaces do we have
292 **************************************************************************/
293int iface_count(void)
294{
295 int ret = 0;
296 struct interface *i;
297
298 for (i=local_interfaces;i;i=i->next)
299 ret++;
300 return ret;
301}
302
303/****************************************************************************
304 how many non-loopback interfaces do we have
305 **************************************************************************/
306int iface_count_nl(void)
307{
308 int ret = 0;
309 struct interface *i;
310
311 for (i=local_interfaces;i;i=i->next) {
312 if (ip_equal(i->ip, loopback_ip)) {
313 continue;
314 }
315 ret++;
316 }
317 return ret;
318}
319
320/****************************************************************************
321 return the Nth interface
322 **************************************************************************/
323struct interface *get_interface(int n)
324{
325 struct interface *i;
326
327 for (i=local_interfaces;i && n;i=i->next)
328 n--;
329
330 if (i) return i;
331 return NULL;
332}
333
334/****************************************************************************
335 return IP of the Nth interface
336 **************************************************************************/
337struct in_addr *iface_n_ip(int n)
338{
339 struct interface *i;
340
341 for (i=local_interfaces;i && n;i=i->next)
342 n--;
343
344 if (i) return &i->ip;
345 return NULL;
346}
347
348/****************************************************************************
349 return bcast of the Nth interface
350 **************************************************************************/
351struct in_addr *iface_n_bcast(int n)
352{
353 struct interface *i;
354
355 for (i=local_interfaces;i && n;i=i->next)
356 n--;
357
358 if (i) return &i->bcast;
359 return NULL;
360}
361
362
363/* these 3 functions return the ip/bcast/nmask for the interface
364 most appropriate for the given ip address. If they can't find
365 an appropriate interface they return the requested field of the
366 first known interface. */
367
368struct in_addr *iface_ip(struct in_addr ip)
369{
370 struct interface *i = iface_find(ip, True);
371 return(i ? &i->ip : &local_interfaces->ip);
372}
373
374/*
375 return True if a IP is directly reachable on one of our interfaces
376*/
377BOOL iface_local(struct in_addr ip)
378{
379 return iface_find(ip, True) ? True : False;
380}
Note: See TracBrowser for help on using the repository browser.