![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to inet.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimdd|
Return to inet.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pimdd |
1.1 misho 1: /*
2: * The mrouted program is covered by the license in the accompanying file
3: * named "LICENSE.mrouted". Use of the mrouted program represents acceptance of
4: * the terms and conditions listed in that file.
5: *
6: * The mrouted program is COPYRIGHT 1989 by The Board of Trustees of
7: * Leland Stanford Junior University.
8: *
9: *
10: * inet.c,v 3.8.4.1 1997/01/29 19:49:33 fenner Exp
11: */
12: #define C(x) ((x) & 0xff)
13:
14: #include "defs.h"
15:
16:
17: /*
18: * Exported variables.
19: */
20: char s1[19]; /* buffers to hold the string representations */
21: char s2[19]; /* of IP addresses, to be passed to inet_fmt() */
22: char s3[19];
23: char s4[19];
24:
25:
26: /*
27: * Verify that a given IP address is credible as a host address.
28: * (Without a mask, cannot detect addresses of the form {subnet,0} or
29: * {subnet,-1}.)
30: */
31: int
32: inet_valid_host(naddr)
33: u_int32 naddr;
34: {
35: register u_int32 addr;
36:
37: addr = ntohl(naddr);
38:
39: return (!(IN_MULTICAST(addr) ||
40: IN_BADCLASS (addr) ||
41: (addr & 0xff000000) == 0));
42: }
43:
44: /*
45: * Verify that a given netmask is plausible;
46: * make sure that it is a series of 1's followed by
47: * a series of 0's with no discontiguous 1's.
48: */
49: int
50: inet_valid_mask(mask)
51: u_int32 mask;
52: {
53: if (~(((mask & -mask) - 1) | mask) != 0) {
54: /* Mask is not contiguous */
55: return (FALSE);
56: }
57:
58: return (TRUE);
59: }
60:
61: /*
62: * Verify that a given subnet number and mask pair are credible.
63: *
64: * With CIDR, almost any subnet and mask are credible. mrouted still
65: * can't handle aggregated class A's, so we still check that, but
66: * otherwise the only requirements are that the subnet address is
67: * within the [ABC] range and that the host bits of the subnet
68: * are all 0.
69: */
70: int
71: inet_valid_subnet(nsubnet, nmask)
72: u_int32 nsubnet, nmask;
73: {
74: register u_int32 subnet, mask;
75:
76: subnet = ntohl(nsubnet);
77: mask = ntohl(nmask);
78:
79: if ((subnet & mask) != subnet)
80: return (FALSE);
81:
82: if (subnet == 0)
83: return (mask == 0);
84:
85: if (IN_CLASSA(subnet)) {
86: if (mask < 0xff000000 ||
87: (subnet & 0xff000000) == 0x7f000000 ||
88: (subnet & 0xff000000) == 0x00000000) return (FALSE);
89: }
90: else if (IN_CLASSD(subnet) || IN_BADCLASS(subnet)) {
91: /* Above Class C address space */
92: return (FALSE);
93: }
94: if (subnet & ~mask) {
95: /* Host bits are set in the subnet */
96: return (FALSE);
97: }
98: if (!inet_valid_mask(mask)) {
99: /* Netmask is not contiguous */
100: return (FALSE);
101: }
102:
103: return (TRUE);
104: }
105:
106:
107: /*
108: * Convert an IP address in u_int32 (network) format into a printable string.
109: */
110: char *
111: inet_fmt(addr, s)
112: u_int32 addr;
113: char *s;
114: {
115: register u_char *a;
116:
117: a = (u_char *)&addr;
118: sprintf(s, "%u.%u.%u.%u", a[0], a[1], a[2], a[3]);
119: return (s);
120: }
121:
122:
123: /*
124: * Convert an IP subnet number in u_int32 (network) format into a printable
125: * string including the netmask as a number of bits.
126: */
127: #ifdef NOSUCHDEF /* replaced by netname() */
128: char *
129: inet_fmts(addr, mask, s)
130: u_int32 addr, mask;
131: char *s;
132: {
133: register u_char *a, *m;
134: int bits;
135:
136: if ((addr == 0) && (mask == 0)) {
137: sprintf(s, "default");
138: return (s);
139: }
140: a = (u_char *)&addr;
141: m = (u_char *)&mask;
142: bits = 33 - ffs(ntohl(mask));
143:
144: if (m[3] != 0) sprintf(s, "%u.%u.%u.%u/%d", a[0], a[1], a[2], a[3],
145: bits);
146: else if (m[2] != 0) sprintf(s, "%u.%u.%u/%d", a[0], a[1], a[2], bits);
147: else if (m[1] != 0) sprintf(s, "%u.%u/%d", a[0], a[1], bits);
148: else sprintf(s, "%u/%d", a[0], bits);
149:
150: return (s);
151: }
152: #endif /* NOSUCHDEF */
153:
154: /*
155: * Convert the printable string representation of an IP address into the
156: * u_int32 (network) format. Return 0xffffffff on error. (To detect the
157: * legal address with that value, you must explicitly compare the string
158: * with "255.255.255.255".)
159: * The return value is in network order.
160: */
161: u_int32
162: inet_parse(s, n)
163: char *s;
164: int n;
165: {
166: u_int32 a = 0;
167: u_int a0 = 0, a1 = 0, a2 = 0, a3 = 0;
168: int i;
169: char c;
170:
171: i = sscanf(s, "%u.%u.%u.%u%c", &a0, &a1, &a2, &a3, &c);
172: if (i < n || i > 4 || a0 > 255 || a1 > 255 || a2 > 255 || a3 > 255)
173: return (0xffffffff);
174:
175: ((u_char *)&a)[0] = a0;
176: ((u_char *)&a)[1] = a1;
177: ((u_char *)&a)[2] = a2;
178: ((u_char *)&a)[3] = a3;
179:
180: return (a);
181: }
182:
183:
184: /*
185: * inet_cksum extracted from:
186: * P I N G . C
187: *
188: * Author -
189: * Mike Muuss
190: * U. S. Army Ballistic Research Laboratory
191: * December, 1983
192: * Modified at Uc Berkeley
193: *
194: * (ping.c) Status -
195: * Public Domain. Distribution Unlimited.
196: *
197: * I N _ C K S U M
198: *
199: * Checksum routine for Internet Protocol family headers (C Version)
200: *
201: */
202: int
203: inet_cksum(addr, len)
204: u_int16 *addr;
205: u_int len;
206: {
207: register int nleft = (int)len;
208: register u_int16 *w = addr;
209: u_int16 answer = 0;
210: register int sum = 0;
211:
212: /*
213: * Our algorithm is simple, using a 32 bit accumulator (sum),
214: * we add sequential 16 bit words to it, and at the end, fold
215: * back all the carry bits from the top 16 bits into the lower
216: * 16 bits.
217: */
218: while (nleft > 1) {
219: sum += *w++;
220: nleft -= 2;
221: }
222:
223: /* mop up an odd byte, if necessary */
224: if (nleft == 1) {
225: *(u_char *) (&answer) = *(u_char *)w ;
226: sum += answer;
227: }
228:
229: /*
230: * add back carry outs from top 16 bits to low 16 bits
231: */
232: sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
233: sum += (sum >> 16); /* add carry */
234: answer = ~sum; /* truncate to 16 bits */
235: return (answer);
236: }
237:
238: /*
239: * Called by following netname() to create a mask specified network address.
240: */
241: void
242: trimdomain(cp)
243: char *cp;
244: {
245: static char domain[MAXHOSTNAMELEN + 1];
246: static int first = 1;
247: char *s;
248:
249: if (first) {
250: first = 0;
251: if (gethostname(domain, MAXHOSTNAMELEN) == 0 &&
252: (s = strchr(domain, '.')))
253: (void) strcpy(domain, s + 1);
254: else
255: domain[0] = 0;
256: }
257:
258: if (domain[0]) {
259: while ((cp = strchr(cp, '.'))) {
260: if (!strcasecmp(cp + 1, domain)) {
261: *cp = 0; /* hit it */
262: break;
263: } else {
264: cp++;
265: }
266: }
267: }
268: }
269:
270: static u_long
271: forgemask(a)
272: u_long a;
273: {
274: u_long m;
275:
276: if (IN_CLASSA(a))
277: m = IN_CLASSA_NET;
278: else if (IN_CLASSB(a))
279: m = IN_CLASSB_NET;
280: else
281: m = IN_CLASSC_NET;
282: return (m);
283: }
284:
285: static void
286: domask(dst, addr, mask)
287: char *dst;
288: u_long addr, mask;
289: {
290: int b, i;
291:
292: if (!mask || (forgemask(addr) == mask)) {
293: *dst = '\0';
294: return;
295: }
296: i = 0;
297: for (b = 0; b < 32; b++)
298: if (mask & (1 << b)) {
299: int bb;
300:
301: i = b;
302: for (bb = b+1; bb < 32; bb++)
303: if (!(mask & (1 << bb))) {
304: i = -1; /* noncontig */
305: break;
306: }
307: break;
308: }
309: if (i == -1)
310: sprintf(dst, "&0x%lx", mask);
311: else
312: sprintf(dst, "/%d", 32 - i);
313: }
314:
315: /*
316: * Return the name of the network whose address is given.
317: * The address is assumed to be that of a net or subnet, not a host.
318: */
319: char *
320: netname(addr, mask)
321: u_int32 addr, mask;
322: {
323: static char line[MAXHOSTNAMELEN + 4];
324: u_int32 omask;
325: u_int32 i;
326:
327: i = ntohl(addr);
328: omask = mask = ntohl(mask);
329: if ((i & 0xffffff) == 0)
330: sprintf(line, "%u", C(i >> 24));
331: else if ((i & 0xffff) == 0)
332: sprintf(line, "%u.%u", C(i >> 24) , C(i >> 16));
333: else if ((i & 0xff) == 0)
334: sprintf(line, "%u.%u.%u", C(i >> 24), C(i >> 16), C(i >> 8));
335: else
336: sprintf(line, "%u.%u.%u.%u", C(i >> 24),
337: C(i >> 16), C(i >> 8), C(i));
338: domask(line+strlen(line), i, omask);
339: return (line);
340: }