14f2f1721a49067e9b65f6da5966587a896553ba
[openafs.git] / src / util / netutils.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * Network utility functions
12  * Parsing NetRestrict file and filtering IP addresses
13  */
14
15 #include <afsconfig.h>
16 #ifdef KERNEL
17 #include "afs/param.h"
18 #else
19 #include <afs/param.h>
20 #endif
21
22
23 #include <stdlib.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <ctype.h>
27 #ifdef KERNEL
28 #include "afs/sysincludes.h"
29 #include "afsincludes.h"
30 #else
31 #ifdef AFS_NT40_ENV
32 #include <winsock2.h>
33 #else 
34 #ifdef __FreeBSD__
35 #include <sys/types.h>
36 #endif
37 #include <netinet/in.h>
38 #include <sys/errno.h>
39 #endif
40 #include <errno.h>
41 #endif
42
43 #include <rx/rx.h>
44
45 #include "assert.h"
46 #include "afsutil.h"
47 #include "dirpath.h"
48
49 #define AFS_IPINVALID        0xffffffff /* invalid IP address */
50 #define AFS_IPINVALIDIGNORE  0xfffffffe /* no input given to extractAddr */
51 #define MAX_NETFILE_LINE       2048     /* length of a line in the netrestrict file */
52 #define MAXIPADDRS             1024     /* from afsd.c */
53
54 int ParseNetInfoFile_int(afs_uint32 *, afs_uint32 *, afs_uint32 *,
55                          int, char reason[], const char *,
56                          int);
57 /* 
58  * The line parameter is a pointer to a buffer containing a string of 
59  * bytes of the form 
60 ** w.x.y.z      # machineName
61  * returns the network interface IP Address in NBO
62  */
63 afs_uint32
64 extract_Addr(char *line, int maxSize)
65 {
66     char bytes[4][32];
67     int i = 0, n = 0;
68     char *endPtr;
69     afs_uint32 val[4];
70     afs_uint32 retval = 0;
71
72     /* skip empty spaces */
73     while (isspace(*line) && maxSize) {
74         line++;
75         maxSize--;
76     }
77     /* skip empty lines */
78     if (!maxSize || !*line)
79         return AFS_IPINVALIDIGNORE;
80
81     for (n = 0; n < 4; n++) {
82         while ((*line != '.') && !isspace(*line) && maxSize) {  /* extract nth byte */
83             if (!isdigit(*line))
84                 return AFS_IPINVALID;
85             if (i > 31)
86                 return AFS_IPINVALID;   /* no space */
87             bytes[n][i++] = *line++;
88             maxSize--;
89         }                       /* while */
90         if (!maxSize)
91             return AFS_IPINVALID;
92         bytes[n][i] = 0;
93         i = 0, line++;
94         errno = 0;
95         val[n] = strtol(bytes[n], &endPtr, 10);
96         if ((val[n] == 0) && (errno != 0 || bytes[n] == endPtr))        /* no conversion */
97             return AFS_IPINVALID;
98     }                           /* for */
99
100     retval = (val[0] << 24) | (val[1] << 16) | (val[2] << 8) | val[3];
101     return htonl(retval);
102 }
103
104
105
106
107 /* parseNetRestrictFile()
108  * Get a list of IP addresses for this host removing any address found
109  * in the config file (fileName parameter): /usr/vice/etc/NetRestrict
110  * for clients and /usr/afs/local/NetRestrict for servers.  
111  *
112  * Returns the number of valid addresses in outAddrs[] and count in
113  * nAddrs.  Returns 0 on success; or 1 if the config file was not
114  * there or empty (we still return the host's IP addresses). Returns
115  * -1 on fatal failure with reason in the reason argument (so the
116  * caller can choose to ignore the entire file but should write
117  * something to a log file).
118  *
119  * All addresses should be in NBO (as returned by rx_getAllAddrMaskMtu() and
120  * parsed by extract_Addr().
121  */
122 /*
123   afs_uint32  outAddrs[];          * output address array *
124   afs_uint32  *mask, *mtu;         * optional mask and mtu *
125   afs_uint32 maxAddrs;             * max number of addresses *
126   afs_uint32 *nAddrs;              * number of Addresses in output array *
127   char       reason[];             * reason for failure *
128   const char *fileName;            * filename to parse *
129 */
130
131 int
132 parseNetRestrictFile_int(afs_uint32 outAddrs[], afs_uint32 * mask,
133                          afs_uint32 * mtu, afs_uint32 maxAddrs,
134                          afs_uint32 * nAddrs, char reason[], 
135                          const char *fileName, const char *fileName_ni)
136 {
137     FILE *fp;
138     char line[MAX_NETFILE_LINE];
139     int lineNo, usedfile = 0;
140     afs_uint32 i, neaddrs, nOutaddrs;
141     afs_uint32 addr, eAddrs[MAXIPADDRS], eMask[MAXIPADDRS], eMtu[MAXIPADDRS];
142
143     assert(outAddrs);
144     assert(reason);
145     assert(fileName);
146     assert(nAddrs);
147     if (mask)
148         assert(mtu);
149
150     /* Initialize */
151     *nAddrs = 0;
152     for (i = 0; i < maxAddrs; i++)
153         outAddrs[i] = 0;
154     strcpy(reason, "");
155
156     /* get all network interfaces from the kernel */
157     neaddrs = rx_getAllAddrMaskMtu(eAddrs, eMask, eMtu, MAXIPADDRS);
158     if (neaddrs <= 0) {
159         sprintf(reason, "No existing IP interfaces found");
160         return -1;
161     }
162     i = 0;
163     if ((neaddrs < MAXIPADDRS) && fileName_ni) 
164         i = ParseNetInfoFile_int(&(eAddrs[neaddrs]), &(eMask[neaddrs]), 
165                                  &(eMtu[neaddrs]), MAXIPADDRS-neaddrs, reason,
166                                  fileName_ni, 1);
167
168     if (i > 0)
169         neaddrs += i;
170
171     if ((fp = fopen(fileName, "r")) == 0) {
172         sprintf(reason, "Could not open file %s for reading:%s", fileName,
173                 strerror(errno));
174         goto done;
175     }
176
177     /* For each line in the NetRestrict file */
178     lineNo = 0;
179     usedfile = 0;
180     while (fgets(line, MAX_NETFILE_LINE, fp) != NULL) {
181         lineNo++;               /* input line number */
182         addr = extract_Addr(line, strlen(line));
183         if (addr == AFS_IPINVALID) {    /* syntactically invalid */
184             fprintf(stderr, "%s : line %d : parse error - invalid IP\n",
185                     fileName, lineNo);
186             continue;
187         }
188         if (addr == AFS_IPINVALIDIGNORE) {      /* ignore error */
189             fprintf(stderr, "%s : line %d : invalid address ... ignoring\n",
190                     fileName, lineNo);
191             continue;
192         }
193         usedfile = 1;
194
195         /* Check if we need to exclude this address */
196         for (i = 0; i < neaddrs; i++) {
197             if (eAddrs[i] && (eAddrs[i] == addr)) {
198                 eAddrs[i] = 0;  /* Yes - exclude it by zeroing it for now */
199             }
200         }
201     }                           /* while */
202
203     fclose(fp);
204
205     if (!usedfile) {
206         sprintf(reason, "No valid IP addresses in %s\n", fileName);
207         goto done;
208     }
209
210   done:
211     /* Collect the addresses we have left to return */
212     nOutaddrs = 0;
213     for (i = 0; i < neaddrs; i++) {
214         if (!eAddrs[i])
215             continue;
216         outAddrs[nOutaddrs] = eAddrs[i];
217         if (mask) {
218             mask[nOutaddrs] = eMask[i];
219             mtu[nOutaddrs] = eMtu[i];
220         }
221         if (++nOutaddrs >= maxAddrs)
222             break;
223     }
224     if (nOutaddrs == 0) {
225         sprintf(reason, "No addresses to use after parsing %s", fileName);
226         return -1;
227     }
228     *nAddrs = nOutaddrs;
229     return (usedfile ? 0 : 1);  /* 0=>used the file.  1=>didn't use file */
230 }
231
232 int
233 parseNetRestrictFile(afs_uint32 outAddrs[], afs_uint32 * mask,
234                          afs_uint32 * mtu, afs_uint32 maxAddrs,
235                          afs_uint32 * nAddrs, char reason[], 
236                          const char *fileName)
237 {
238     return parseNetRestrictFile_int(outAddrs, mask, mtu, maxAddrs, nAddrs, reason, fileName, NULL);
239 }
240
241 /*
242  * this function reads in stuff from InterfaceAddr file in
243  * /usr/vice/etc ( if it exists ) and verifies the addresses
244  * specified. 
245  * 'final' contains all those addresses that are found to 
246  * be valid. This function returns the number of valid
247  * interface addresses. Pulled out from afsd.c
248  */
249 int
250 ParseNetInfoFile_int(afs_uint32 * final, afs_uint32 * mask, afs_uint32 * mtu,
251                      int max, char reason[], const char *fileName, 
252                      int fakeonly)
253 {
254
255     afs_uint32 existingAddr[MAXIPADDRS], existingMask[MAXIPADDRS],
256         existingMtu[MAXIPADDRS];
257     char line[MAX_NETFILE_LINE];
258     FILE *fp;
259     int i, existNu, count = 0;
260     afs_uint32 addr;
261     int lineNo = 0;
262     int l;
263
264     assert(fileName);
265     assert(final);
266     assert(mask);
267     assert(mtu);
268     assert(reason);
269
270     /* get all network interfaces from the kernel */
271     existNu =
272         rx_getAllAddrMaskMtu(existingAddr, existingMask, existingMtu,
273                               MAXIPADDRS);
274     if (existNu < 0)
275         return existNu;
276
277     if ((fp = fopen(fileName, "r")) == 0) {
278         /* If file does not exist or is not readable, then
279          * use all interface addresses.
280          */
281         sprintf(reason,
282                 "Failed to open %s(%s)\nUsing all configured addresses\n",
283                 fileName, strerror(errno));
284         for (i = 0; i < existNu; i++) {
285             final[i] = existingAddr[i];
286             mask[i] = existingMask[i];
287             mtu[i] = existingMtu[i];
288         }
289         return existNu;
290     }
291
292     /* For each line in the NetInfo file */
293     while (fgets(line, MAX_NETFILE_LINE, fp) != NULL) {
294         int fake = 0;
295
296         /* See if first char is an 'F' for fake */
297         /* Added to allow the fileserver to advertise fake IPS for use with
298          * the translation tables for NAT-like firewalls - defect 12462 */
299         for (fake = 0; ((fake < strlen(line)) && isspace(line[fake]));
300              fake++);
301         if ((fake < strlen(line))
302             && ((line[fake] == 'f') || (line[fake] == 'F'))) {
303             fake++;
304         } else {
305             fake = 0;
306         }
307
308         lineNo++;               /* input line number */
309         addr = extract_Addr(&line[fake], strlen(&line[fake]));
310
311         if (addr == AFS_IPINVALID) {    /* syntactically invalid */
312             fprintf(stderr, "afs:%s : line %d : parse error\n", fileName,
313                     lineNo);
314             continue;
315         }
316         if (addr == AFS_IPINVALIDIGNORE) {      /* ignore error */
317             continue;
318         }
319
320         /* See if it is an address that really exists */
321         for (i = 0; i < existNu; i++) {
322             if (existingAddr[i] == addr)
323                 break;
324         }
325         if ((i >= existNu) && (!fake))
326             continue;           /* not found/fake - ignore */
327
328         /* Check if it is a duplicate address we alread have */
329         for (l = 0; l < count; l++) {
330             if (final[l] == addr)
331                 break;
332         }
333         if (l < count) {
334             fprintf(stderr, "afs:%x specified twice in NetInfo file\n",
335                     ntohl(addr));
336             continue;           /* duplicate addr - ignore */
337         }
338
339         if (count > max) {      /* no more space */
340             fprintf(stderr,
341                     "afs:Too many interfaces. The current kernel configuration supports a maximum of %d interfaces\n",
342                     max);
343         } else if (fake) {
344             if (!fake) 
345                 fprintf(stderr, "Client (2) also has address %s\n", line);
346             final[count] = addr;
347             mask[count] = 0xffffffff;
348             mtu[count] = htonl(1500);
349             count++;
350         } else if (!fakeonly) {
351             final[count] = existingAddr[i];
352             mask[count] = existingMask[i];
353             mtu[count] = existingMtu[i];
354             count++;
355         }
356     }                           /* while */
357
358     /* in case of any error, we use all the interfaces present */
359     if (count <= 0) {
360         sprintf(reason,
361                 "Error in reading/parsing Interface file\nUsing all configured interface addresses \n");
362         for (i = 0; i < existNu; i++) {
363             final[i] = existingAddr[i];
364             mask[i] = existingMask[i];
365             mtu[i] = existingMtu[i];
366         }
367         return existNu;
368     }
369     return count;
370 }
371
372 int
373 ParseNetInfoFile(afs_uint32 * final, afs_uint32 * mask, afs_uint32 * mtu,
374                  int max, char reason[], const char *fileName)
375 {
376     return ParseNetInfoFile_int(final, mask, mtu, max, reason, fileName, 0);
377 }
378
379 /*
380  * Given two arrays of addresses, masks and mtus find the common ones
381  * and return them in the first buffer. Return number of common
382  * entries.
383  */
384 int
385 filterAddrs(afs_uint32 addr1[], afs_uint32 addr2[], afs_uint32 mask1[],
386             afs_uint32 mask2[], afs_uint32 mtu1[], afs_uint32 mtu2[], int n1,
387             int n2)
388 {
389     afs_uint32 taddr[MAXIPADDRS];
390     afs_uint32 tmask[MAXIPADDRS];
391     afs_uint32 tmtu[MAXIPADDRS];
392     int count = 0, i = 0, j = 0, found = 0;
393
394     assert(addr1);
395     assert(addr2);
396     assert(mask1);
397     assert(mask2);
398     assert(mtu1);
399     assert(mtu2);
400
401     for (i = 0; i < n1; i++) {
402         found = 0;
403         for (j = 0; j < n2; j++) {
404             if (addr1[i] == addr2[j]) {
405                 found = 1;
406                 break;
407             }
408         }
409
410         /* Always mask loopback address */
411         if (found && rx_IsLoopbackAddr(addr1[i]))
412             found = 0;
413
414         if (found) {
415             taddr[count] = addr1[i];
416             tmask[count] = mask1[i];
417             tmtu[count] = mtu1[i];
418             count++;
419         }
420     }
421     /* copy everything into addr1, mask1 and mtu1 */
422     for (i = 0; i < count; i++) {
423         addr1[i] = taddr[i];
424         if (mask1) {
425             mask1[i] = tmask[i];
426             mtu1[i] = tmtu[i];
427         }
428     }
429     /* and zero out the rest */
430     for (i = count; i < n1; i++) {
431         addr1[i] = 0;
432         if (mask1) {
433             mask1[i] = 0;
434             mtu1[i] = 0;
435         }
436     }
437     return count;
438 }
439
440 /*
441  * parse both netinfo and netrerstrict files and return the final
442  * set of IP addresses to use
443  */
444 /* max - Entries in addrbuf, maskbuf and mtubuf */
445 int
446 parseNetFiles(afs_uint32 addrbuf[], afs_uint32 maskbuf[], afs_uint32 mtubuf[],
447               afs_uint32 max, char reason[], const char *niFileName,
448               const char *nrFileName)
449 {
450     afs_uint32 addrbuf1[MAXIPADDRS], maskbuf1[MAXIPADDRS],
451         mtubuf1[MAXIPADDRS];
452     afs_uint32 addrbuf2[MAXIPADDRS], maskbuf2[MAXIPADDRS],
453         mtubuf2[MAXIPADDRS];
454     int nAddrs1 = 0;
455     afs_uint32 nAddrs2 = 0;
456     int code, i;
457
458     nAddrs1 =
459         ParseNetInfoFile(addrbuf1, maskbuf1, mtubuf1, MAXIPADDRS, reason,
460                          niFileName);
461     code =
462         parseNetRestrictFile_int(addrbuf2, maskbuf2, mtubuf2, MAXIPADDRS,
463                              &nAddrs2, reason, nrFileName, niFileName);
464     if ((nAddrs1 < 0) && (code)) {
465         /* both failed */
466         return -1;
467     } else if ((nAddrs1 > 0) && (code)) {
468         /* netinfo succeeded and netrestrict failed */
469         for (i = 0; ((i < nAddrs1) && (i < max)); i++) {
470             addrbuf[i] = addrbuf1[i];
471             if (maskbuf) {
472                 maskbuf[i] = maskbuf1[i];
473                 mtubuf[i] = mtubuf1[i];
474             }
475         }
476         return i;
477     } else if ((!code) && (nAddrs1 < 0)) {
478         /* netrestrict succeeded and netinfo failed */
479         for (i = 0; ((i < nAddrs2) && (i < max)); i++) {
480             addrbuf[i] = addrbuf2[i];
481             if (maskbuf) {
482                 maskbuf[i] = maskbuf2[i];
483                 mtubuf[i] = mtubuf2[i];
484             }
485         }
486         return i;
487     } else if ((!code) && (nAddrs1 >= 0)) {
488         /* both succeeded */
489         /* take the intersection of addrbuf1 and addrbuf2 */
490         code =
491             filterAddrs(addrbuf1, addrbuf2, maskbuf1, maskbuf2, mtubuf1,
492                         mtubuf2, nAddrs1, nAddrs2);
493         for (i = 0; ((i < code) && (i < max)); i++) {
494             addrbuf[i] = addrbuf1[i];
495             if (maskbuf) {
496                 maskbuf[i] = maskbuf1[i];
497                 mtubuf[i] = mtubuf1[i];
498             }
499         }
500         return i;
501     }
502     return 0;
503 }