Annotation of embedaddon/bird2/lib/ip.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD Library -- IP address functions
3: *
4: * (c) 1998--2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: /**
10: * DOC: IP addresses
11: *
12: * BIRD uses its own abstraction of IP address in order to share the same
13: * code for both IPv4 and IPv6. IP addresses are represented as entities
14: * of type &ip_addr which are never to be treated as numbers and instead
15: * they must be manipulated using the following functions and macros.
16: */
17:
18: #include <stdlib.h>
19:
20: #include "nest/bird.h"
21: #include "lib/ip.h"
22:
23:
24: int
25: ip6_compare(ip6_addr a, ip6_addr b)
26: {
27: int i;
28: for (i=0; i<4; i++)
29: if (a.addr[i] > b.addr[i])
30: return 1;
31: else if (a.addr[i] < b.addr[i])
32: return -1;
33: return 0;
34: }
35:
36: ip6_addr
37: ip6_mkmask(uint n)
38: {
39: ip6_addr a;
40: int i;
41:
42: for (i=0; i<4; i++)
43: {
44: if (!n)
45: a.addr[i] = 0;
46: else if (n >= 32)
47: {
48: a.addr[i] = ~0;
49: n -= 32;
50: }
51: else
52: {
53: a.addr[i] = u32_mkmask(n);
54: n = 0;
55: }
56: }
57:
58: return a;
59: }
60:
61: uint
62: ip6_masklen(ip6_addr *a)
63: {
64: int i, j, n;
65:
66: for (i=0, n=0; i<4; i++, n+=32)
67: if (a->addr[i] != ~0U)
68: {
69: j = u32_masklen(a->addr[i]);
70: if (j == 255)
71: return j;
72: n += j;
73: while (++i < 4)
74: if (a->addr[i])
75: return 255;
76: break;
77: }
78:
79: return n;
80: }
81:
82: int
83: ip4_classify(ip4_addr ad)
84: {
85: u32 a = _I(ad);
86: u32 b = a >> 24U;
87:
88: if (b && b <= 0xdf)
89: {
90: if (b == 0x7f)
91: return IADDR_HOST | SCOPE_HOST;
92: else if ((b == 0x0a) ||
93: ((a & 0xffff0000) == 0xc0a80000) ||
94: ((a & 0xfff00000) == 0xac100000))
95: return IADDR_HOST | SCOPE_SITE;
96: else
97: return IADDR_HOST | SCOPE_UNIVERSE;
98: }
99:
100: if (b >= 0xe0 && b <= 0xef)
101: return IADDR_MULTICAST | SCOPE_UNIVERSE;
102:
103: if (a == 0xffffffff)
104: return IADDR_BROADCAST | SCOPE_LINK;
105:
106: return IADDR_INVALID;
107: }
108:
109: int
110: ip6_classify(ip6_addr *a)
111: {
112: u32 x = a->addr[0];
113:
114: if ((x & 0xe0000000) == 0x20000000) /* 2000::/3 Aggregatable Global Unicast Address */
115: return IADDR_HOST | SCOPE_UNIVERSE;
116: if ((x & 0xffc00000) == 0xfe800000) /* fe80::/10 Link-Local Address */
117: return IADDR_HOST | SCOPE_LINK;
118: if ((x & 0xffc00000) == 0xfec00000) /* fec0::/10 Site-Local Address */
119: return IADDR_HOST | SCOPE_SITE;
120: if ((x & 0xfe000000) == 0xfc000000) /* fc00::/7 Unique Local Unicast Address (RFC 4193) */
121: return IADDR_HOST | SCOPE_SITE;
122: if ((x & 0xff000000) == 0xff000000) /* ff00::/8 Multicast Address */
123: {
124: uint scope = (x >> 16) & 0x0f;
125: switch (scope)
126: {
127: case 1: return IADDR_MULTICAST | SCOPE_HOST;
128: case 2: return IADDR_MULTICAST | SCOPE_LINK;
129: case 5: return IADDR_MULTICAST | SCOPE_SITE;
130: case 8: return IADDR_MULTICAST | SCOPE_ORGANIZATION;
131: case 14: return IADDR_MULTICAST | SCOPE_UNIVERSE;
132: default: return IADDR_MULTICAST | SCOPE_UNDEFINED;
133: }
134: }
135:
136: if (!x && !a->addr[1])
137: {
138: u32 a2 = a->addr[2];
139: u32 a3 = a->addr[3];
140:
141: if (a2 == 0 && a3 == 1)
142: return IADDR_HOST | SCOPE_HOST; /* Loopback address */
143: if (a2 == 0)
144: return ip4_classify(_MI4(a3)); /* IPv4 compatible addresses */
145: if (a2 == 0xffff)
146: return ip4_classify(_MI4(a3)); /* IPv4 mapped addresses */
147:
148: return IADDR_INVALID;
149: }
150:
151: return IADDR_HOST | SCOPE_UNDEFINED;
152: }
153:
154:
155:
156: /*
157: * Conversion of IPv6 address to presentation format and vice versa.
158: * Heavily inspired by routines written by Paul Vixie for the BIND project
159: * and of course by RFC 2373.
160: */
161:
162:
163: char *
164: ip4_ntop(ip4_addr a, char *b)
165: {
166: u32 x = _I(a);
167: return b + bsprintf(b, "%d.%d.%d.%d", (x >> 24) & 0xff, (x >> 16) & 0xff, (x >> 8) & 0xff, x & 0xff);
168: }
169:
170:
171: char *
172: ip6_ntop(ip6_addr a, char *b)
173: {
174: u16 words[8];
175: int bestpos, bestlen, curpos, curlen, i;
176:
177: /* First of all, preprocess the address and find the longest run of zeros */
178: bestlen = bestpos = curpos = curlen = 0;
179: for (i=0; i<8; i++)
180: {
181: u32 x = a.addr[i/2];
182: words[i] = ((i%2) ? x : (x >> 16)) & 0xffff;
183: if (words[i])
184: curlen = 0;
185: else
186: {
187: if (!curlen)
188: curpos = i;
189: curlen++;
190: if (curlen > bestlen)
191: {
192: bestpos = curpos;
193: bestlen = curlen;
194: }
195: }
196: }
197:
198: if (bestlen < 2)
199: bestpos = -1;
200:
201: /* Is it an encapsulated IPv4 address? */
202: if (!bestpos && ((bestlen == 5 && a.addr[2] == 0xffff) || (bestlen == 6)))
203: {
204: u32 x = a.addr[3];
205: b += bsprintf(b, "::%s%d.%d.%d.%d",
206: a.addr[2] ? "ffff:" : "",
207: (x >> 24) & 0xff,
208: (x >> 16) & 0xff,
209: (x >> 8) & 0xff,
210: x & 0xff);
211: return b;
212: }
213:
214: /* Normal IPv6 formatting, compress the largest sequence of zeros */
215: for (i=0; i<8; i++)
216: {
217: if (i == bestpos)
218: {
219: i += bestlen - 1;
220: *b++ = ':';
221: if (i == 7)
222: *b++ = ':';
223: }
224: else
225: {
226: if (i)
227: *b++ = ':';
228: b += bsprintf(b, "%x", words[i]);
229: }
230: }
231: *b = 0;
232: return b;
233: }
234:
235: int
236: ip4_pton(const char *a, ip4_addr *o)
237: {
238: int i;
239: unsigned long int l;
240: u32 ia = 0;
241:
242: i=4;
243: while (i--)
244: {
245: char *d, *c = strchr(a, '.');
246: if (!c != !i)
247: return 0;
248: l = bstrtoul10(a, &d);
249: if (((d != c) && *d) || (l > 255))
250: return 0;
251: ia = (ia << 8) | l;
252: if (c)
253: c++;
254: a = c;
255: }
256: *o = ip4_from_u32(ia);
257: return 1;
258: }
259:
260: int
261: ip6_pton(const char *a, ip6_addr *o)
262: {
263: u16 words[8];
264: int i, j, k, l, hfil;
265: const char *start;
266:
267: if (a[0] == ':') /* Leading :: */
268: {
269: if (a[1] != ':')
270: return 0;
271: a++;
272: }
273:
274: hfil = -1;
275: i = 0;
276: while (*a)
277: {
278: if (*a == ':') /* :: */
279: {
280: if (hfil >= 0)
281: return 0;
282:
283: hfil = i;
284: a++;
285: continue;
286: }
287:
288: j = 0;
289: l = 0;
290: start = a;
291: for (;;)
292: {
293: if (*a >= '0' && *a <= '9')
294: k = *a++ - '0';
295: else if (*a >= 'A' && *a <= 'F')
296: k = *a++ - 'A' + 10;
297: else if (*a >= 'a' && *a <= 'f')
298: k = *a++ - 'a' + 10;
299: else
300: break;
301:
302: j = (j << 4) + k;
303: if (j >= 0x10000 || ++l > 4)
304: return 0;
305: }
306:
307: if (*a == ':' && a[1])
308: a++;
309: else if (*a == '.' && (i == 6 || (i < 6 && hfil >= 0)))
310: { /* Embedded IPv4 address */
311: ip4_addr x;
312: if (!ip4_pton(start, &x))
313: return 0;
314: words[i++] = _I(x) >> 16;
315: words[i++] = _I(x);
316: break;
317: }
318: else if (*a)
319: return 0;
320:
321: if (i >= 8)
322: return 0;
323:
324: words[i++] = j;
325: }
326:
327: /* Replace :: with an appropriate number of zeros */
328: if (hfil >= 0)
329: {
330: j = 8 - i;
331: for (i=7; i-j >= hfil; i--)
332: words[i] = words[i-j];
333: for (; i>=hfil; i--)
334: words[i] = 0;
335: }
336:
337: /* Convert the address to ip6_addr format */
338: for (i=0; i<4; i++)
339: o->addr[i] = (words[2*i] << 16) | words[2*i+1];
340:
341: return 1;
342: }
343:
344:
345: /**
346: * ip_scope_text - get textual representation of address scope
347: * @scope: scope (%SCOPE_xxx)
348: *
349: * Returns a pointer to a textual name of the scope given.
350: */
351: char *
352: ip_scope_text(uint scope)
353: {
354: static char *scope_table[] = { "host", "link", "site", "org", "univ", "undef" };
355:
356: if (scope > SCOPE_UNDEFINED)
357: return "?";
358: else
359: return scope_table[scope];
360: }
361:
362: ip4_addr
363: ip4_class_mask(ip4_addr ad)
364: {
365: u32 m, a = _I(ad);
366:
367: if (a == 0x00000000)
368: m = 0x00000000;
369: else if (a < 0x80000000)
370: m = 0xff000000;
371: else if (a < 0xc0000000)
372: m = 0xffff0000;
373: else
374: m = 0xffffff00;
375: if (a & ~m)
376: m = 0xffffffff;
377:
378: return _MI4(m);
379: }
380:
381: #if 0
382: /**
383: * ipa_equal - compare two IP addresses for equality
384: * @x: IP address
385: * @y: IP address
386: *
387: * ipa_equal() returns 1 if @x and @y represent the same IP address, else 0.
388: */
389: int ipa_equal(ip_addr x, ip_addr y) { DUMMY }
390:
391: /**
392: * ipa_nonzero - test if an IP address is defined
393: * @x: IP address
394: *
395: * ipa_nonzero returns 1 if @x is a defined IP address (not all bits are zero),
396: * else 0.
397: *
398: * The undefined all-zero address is reachable as a |IPA_NONE| macro.
399: */
400: int ipa_nonzero(ip_addr x) { DUMMY }
401:
402: /**
403: * ipa_and - compute bitwise and of two IP addresses
404: * @x: IP address
405: * @y: IP address
406: *
407: * This function returns a bitwise and of @x and @y. It's primarily
408: * used for network masking.
409: */
410: ip_addr ipa_and(ip_addr x, ip_addr y) { DUMMY }
411:
412: /**
413: * ipa_or - compute bitwise or of two IP addresses
414: * @x: IP address
415: * @y: IP address
416: *
417: * This function returns a bitwise or of @x and @y.
418: */
419: ip_addr ipa_or(ip_addr x, ip_addr y) { DUMMY }
420:
421: /**
422: * ipa_xor - compute bitwise xor of two IP addresses
423: * @x: IP address
424: * @y: IP address
425: *
426: * This function returns a bitwise xor of @x and @y.
427: */
428: ip_addr ipa_xor(ip_addr x, ip_addr y) { DUMMY }
429:
430: /**
431: * ipa_not - compute bitwise negation of two IP addresses
432: * @x: IP address
433: *
434: * This function returns a bitwise negation of @x.
435: */
436: ip_addr ipa_not(ip_addr x) { DUMMY }
437:
438: /**
439: * ipa_mkmask - create a netmask
440: * @x: prefix length
441: *
442: * This function returns an &ip_addr corresponding of a netmask
443: * of an address prefix of size @x.
444: */
445: ip_addr ipa_mkmask(int x) { DUMMY }
446:
447: /**
448: * ipa_masklen - calculate netmask length
449: * @x: IP address
450: *
451: * This function checks whether @x represents a valid netmask and
452: * returns the size of the associate network prefix or -1 for invalid
453: * mask.
454: */
455: int ipa_masklen(ip_addr x) { DUMMY }
456:
457: /**
458: * ipa_hash - hash IP addresses
459: * @x: IP address
460: *
461: * ipa_hash() returns a 16-bit hash value of the IP address @x.
462: */
463: int ipa_hash(ip_addr x) { DUMMY }
464:
465: /**
466: * ipa_hton - convert IP address to network order
467: * @x: IP address
468: *
469: * Converts the IP address @x to the network byte order.
470: *
471: * Beware, this is a macro and it alters the argument!
472: */
473: void ipa_hton(ip_addr x) { DUMMY }
474:
475: /**
476: * ipa_ntoh - convert IP address to host order
477: * @x: IP address
478: *
479: * Converts the IP address @x from the network byte order.
480: *
481: * Beware, this is a macro and it alters the argument!
482: */
483: void ipa_ntoh(ip_addr x) { DUMMY }
484:
485: /**
486: * ipa_classify - classify an IP address
487: * @x: IP address
488: *
489: * ipa_classify() returns an address class of @x, that is a bitwise or
490: * of address type (%IADDR_INVALID, %IADDR_HOST, %IADDR_BROADCAST, %IADDR_MULTICAST)
491: * with address scope (%SCOPE_HOST to %SCOPE_UNIVERSE) or -1 (%IADDR_INVALID)
492: * for an invalid address.
493: */
494: int ipa_classify(ip_addr x) { DUMMY }
495:
496: /**
497: * ip4_class_mask - guess netmask according to address class
498: * @x: IPv4 address
499: *
500: * This function (available in IPv4 version only) returns a
501: * network mask according to the address class of @x. Although
502: * classful addressing is nowadays obsolete, there still live
503: * routing protocols transferring no prefix lengths nor netmasks
504: * and this function could be useful to them.
505: */
506: ip4_addr ip4_class_mask(ip4_addr x) { DUMMY }
507:
508: /**
509: * ipa_from_u32 - convert IPv4 address to an integer
510: * @x: IP address
511: *
512: * This function takes an IPv4 address and returns its numeric
513: * representation.
514: */
515: u32 ipa_from_u32(ip_addr x) { DUMMY }
516:
517: /**
518: * ipa_to_u32 - convert integer to IPv4 address
519: * @x: a 32-bit integer
520: *
521: * ipa_to_u32() takes a numeric representation of an IPv4 address
522: * and converts it to the corresponding &ip_addr.
523: */
524: ip_addr ipa_to_u32(u32 x) { DUMMY }
525:
526: /**
527: * ipa_compare - compare two IP addresses for order
528: * @x: IP address
529: * @y: IP address
530: *
531: * The ipa_compare() function takes two IP addresses and returns
532: * -1 if @x is less than @y in canonical ordering (lexicographical
533: * order of the bit strings), 1 if @x is greater than @y and 0
534: * if they are the same.
535: */
536: int ipa_compare(ip_addr x, ip_addr y) { DUMMY }
537:
538: /**
539: * ipa_build6 - build an IPv6 address from parts
540: * @a1: part #1
541: * @a2: part #2
542: * @a3: part #3
543: * @a4: part #4
544: *
545: * ipa_build() takes @a1 to @a4 and assembles them to a single IPv6
546: * address. It's used for example when a protocol wants to bind its
547: * socket to a hard-wired multicast address.
548: */
549: ip_addr ipa_build6(u32 a1, u32 a2, u32 a3, u32 a4) { DUMMY }
550:
551: /**
552: * ip_ntop - convert IP address to textual representation
553: * @a: IP address
554: * @buf: buffer of size at least %STD_ADDRESS_P_LENGTH
555: *
556: * This function takes an IP address and creates its textual
557: * representation for presenting to the user.
558: */
559: char *ip_ntop(ip_addr a, char *buf) { DUMMY }
560:
561: /**
562: * ip_ntox - convert IP address to hexadecimal representation
563: * @a: IP address
564: * @buf: buffer of size at least %STD_ADDRESS_P_LENGTH
565: *
566: * This function takes an IP address and creates its hexadecimal
567: * textual representation. Primary use: debugging dumps.
568: */
569: char *ip_ntox(ip_addr a, char *buf) { DUMMY }
570:
571: /**
572: * ip_pton - parse textual representation of IP address
573: * @a: textual representation
574: * @o: where to put the resulting address
575: *
576: * This function parses a textual IP address representation and
577: * stores the decoded address to a variable pointed to by @o.
578: * Returns 0 if a parse error has occurred, else 0.
579: */
580: int ip_pton(char *a, ip_addr *o) { DUMMY }
581:
582: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ip.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / lib