Annotation of embedaddon/quagga/lib/prefix.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Prefix related functions.
3: * Copyright (C) 1997, 98, 99 Kunihiro Ishiguro
4: *
5: * This file is part of GNU Zebra.
6: *
7: * GNU Zebra is free software; you can redistribute it and/or modify it
8: * under the terms of the GNU General Public License as published by the
9: * Free Software Foundation; either version 2, or (at your option) any
10: * later version.
11: *
12: * GNU Zebra is distributed in the hope that it will be useful, but
13: * WITHOUT ANY WARRANTY; without even the implied warranty of
14: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15: * General Public License for more details.
16: *
17: * You should have received a copy of the GNU General Public License
18: * along with GNU Zebra; see the file COPYING. If not, write to the Free
19: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20: * 02111-1307, USA.
21: */
22:
23: #include <zebra.h>
24:
25: #include "prefix.h"
26: #include "vty.h"
27: #include "sockunion.h"
28: #include "memory.h"
29: #include "log.h"
30:
31: /* Maskbit. */
32: static const u_char maskbit[] = {0x00, 0x80, 0xc0, 0xe0, 0xf0,
33: 0xf8, 0xfc, 0xfe, 0xff};
34:
35: /* Number of bits in prefix type. */
36: #ifndef PNBBY
37: #define PNBBY 8
38: #endif /* PNBBY */
39:
40: #define MASKBIT(offset) ((0xff << (PNBBY - (offset))) & 0xff)
41:
42: /* Address Famiy Identifier to Address Family converter. */
43: int
44: afi2family (afi_t afi)
45: {
46: if (afi == AFI_IP)
47: return AF_INET;
48: #ifdef HAVE_IPV6
49: else if (afi == AFI_IP6)
50: return AF_INET6;
51: #endif /* HAVE_IPV6 */
52: return 0;
53: }
54:
55: afi_t
56: family2afi (int family)
57: {
58: if (family == AF_INET)
59: return AFI_IP;
60: #ifdef HAVE_IPV6
61: else if (family == AF_INET6)
62: return AFI_IP6;
63: #endif /* HAVE_IPV6 */
64: return 0;
65: }
66:
67: /* If n includes p prefix then return 1 else return 0. */
68: int
69: prefix_match (const struct prefix *n, const struct prefix *p)
70: {
71: int offset;
72: int shift;
73: const u_char *np, *pp;
74:
75: /* If n's prefix is longer than p's one return 0. */
76: if (n->prefixlen > p->prefixlen)
77: return 0;
78:
79: /* Set both prefix's head pointer. */
80: np = (const u_char *)&n->u.prefix;
81: pp = (const u_char *)&p->u.prefix;
82:
83: offset = n->prefixlen / PNBBY;
84: shift = n->prefixlen % PNBBY;
85:
86: if (shift)
87: if (maskbit[shift] & (np[offset] ^ pp[offset]))
88: return 0;
89:
90: while (offset--)
91: if (np[offset] != pp[offset])
92: return 0;
93: return 1;
94: }
95:
96: /* Copy prefix from src to dest. */
97: void
98: prefix_copy (struct prefix *dest, const struct prefix *src)
99: {
100: dest->family = src->family;
101: dest->prefixlen = src->prefixlen;
102:
103: if (src->family == AF_INET)
104: dest->u.prefix4 = src->u.prefix4;
105: #ifdef HAVE_IPV6
106: else if (src->family == AF_INET6)
107: dest->u.prefix6 = src->u.prefix6;
108: #endif /* HAVE_IPV6 */
109: else if (src->family == AF_UNSPEC)
110: {
111: dest->u.lp.id = src->u.lp.id;
112: dest->u.lp.adv_router = src->u.lp.adv_router;
113: }
114: else
115: {
116: zlog (NULL, LOG_ERR, "prefix_copy(): Unknown address family %d",
117: src->family);
118: assert (0);
119: }
120: }
121:
122: /*
123: * Return 1 if the address/netmask contained in the prefix structure
124: * is the same, and else return 0. For this routine, 'same' requires
125: * that not only the prefix length and the network part be the same,
126: * but also the host part. Thus, 10.0.0.1/8 and 10.0.0.2/8 are not
127: * the same. Note that this routine has the same return value sense
128: * as '==' (which is different from prefix_cmp).
129: */
130: int
131: prefix_same (const struct prefix *p1, const struct prefix *p2)
132: {
133: if (p1->family == p2->family && p1->prefixlen == p2->prefixlen)
134: {
135: if (p1->family == AF_INET)
136: if (IPV4_ADDR_SAME (&p1->u.prefix, &p2->u.prefix))
137: return 1;
138: #ifdef HAVE_IPV6
139: if (p1->family == AF_INET6 )
140: if (IPV6_ADDR_SAME (&p1->u.prefix, &p2->u.prefix))
141: return 1;
142: #endif /* HAVE_IPV6 */
143: }
144: return 0;
145: }
146:
147: /*
148: * Return 0 if the network prefixes represented by the struct prefix
149: * arguments are the same prefix, and 1 otherwise. Network prefixes
150: * are considered the same if the prefix lengths are equal and the
151: * network parts are the same. Host bits (which are considered masked
152: * by the prefix length) are not significant. Thus, 10.0.0.1/8 and
153: * 10.0.0.2/8 are considered equivalent by this routine. Note that
154: * this routine has the same return sense as strcmp (which is different
155: * from prefix_same).
156: */
157: int
158: prefix_cmp (const struct prefix *p1, const struct prefix *p2)
159: {
160: int offset;
161: int shift;
162:
163: /* Set both prefix's head pointer. */
164: const u_char *pp1 = (const u_char *)&p1->u.prefix;
165: const u_char *pp2 = (const u_char *)&p2->u.prefix;
166:
167: if (p1->family != p2->family || p1->prefixlen != p2->prefixlen)
168: return 1;
169:
170: offset = p1->prefixlen / 8;
171: shift = p1->prefixlen % 8;
172:
173: if (shift)
174: if (maskbit[shift] & (pp1[offset] ^ pp2[offset]))
175: return 1;
176:
177: while (offset--)
178: if (pp1[offset] != pp2[offset])
179: return 1;
180:
181: return 0;
182: }
183:
184: /* Return prefix family type string. */
185: const char *
186: prefix_family_str (const struct prefix *p)
187: {
188: if (p->family == AF_INET)
189: return "inet";
190: #ifdef HAVE_IPV6
191: if (p->family == AF_INET6)
192: return "inet6";
193: #endif /* HAVE_IPV6 */
194: return "unspec";
195: }
196:
197: /* Allocate new prefix_ipv4 structure. */
198: struct prefix_ipv4 *
199: prefix_ipv4_new ()
200: {
201: struct prefix_ipv4 *p;
202:
203: /* Call prefix_new to allocate a full-size struct prefix to avoid problems
204: where the struct prefix_ipv4 is cast to struct prefix and unallocated
205: bytes were being referenced (e.g. in structure assignments). */
206: p = (struct prefix_ipv4 *)prefix_new();
207: p->family = AF_INET;
208: return p;
209: }
210:
211: /* Free prefix_ipv4 structure. */
212: void
213: prefix_ipv4_free (struct prefix_ipv4 *p)
214: {
215: prefix_free((struct prefix *)p);
216: }
217:
218: /* When string format is invalid return 0. */
219: int
220: str2prefix_ipv4 (const char *str, struct prefix_ipv4 *p)
221: {
222: int ret;
223: int plen;
224: char *pnt;
225: char *cp;
226:
227: /* Find slash inside string. */
228: pnt = strchr (str, '/');
229:
230: /* String doesn't contail slash. */
231: if (pnt == NULL)
232: {
233: /* Convert string to prefix. */
234: ret = inet_aton (str, &p->prefix);
235: if (ret == 0)
236: return 0;
237:
238: /* If address doesn't contain slash we assume it host address. */
239: p->family = AF_INET;
240: p->prefixlen = IPV4_MAX_BITLEN;
241:
242: return ret;
243: }
244: else
245: {
246: cp = XMALLOC (MTYPE_TMP, (pnt - str) + 1);
247: strncpy (cp, str, pnt - str);
248: *(cp + (pnt - str)) = '\0';
249: ret = inet_aton (cp, &p->prefix);
250: XFREE (MTYPE_TMP, cp);
251:
252: /* Get prefix length. */
253: plen = (u_char) atoi (++pnt);
254: if (plen > IPV4_MAX_PREFIXLEN)
255: return 0;
256:
257: p->family = AF_INET;
258: p->prefixlen = plen;
259: }
260:
261: return ret;
262: }
263:
264: /* Convert masklen into IP address's netmask. */
265: void
266: masklen2ip (int masklen, struct in_addr *netmask)
267: {
268: u_char *pnt;
269: int bit;
270: int offset;
271:
272: memset (netmask, 0, sizeof (struct in_addr));
273: pnt = (unsigned char *) netmask;
274:
275: offset = masklen / 8;
276: bit = masklen % 8;
277:
278: while (offset--)
279: *pnt++ = 0xff;
280:
281: if (bit)
282: *pnt = maskbit[bit];
283: }
284:
285: /* Convert IP address's netmask into integer. We assume netmask is
286: sequential one. Argument netmask should be network byte order. */
287: u_char
288: ip_masklen (struct in_addr netmask)
289: {
290: u_char len;
291: u_char *pnt;
292: u_char *end;
293: u_char val;
294:
295: len = 0;
296: pnt = (u_char *) &netmask;
297: end = pnt + 4;
298:
299: while ((pnt < end) && (*pnt == 0xff))
300: {
301: len+= 8;
302: pnt++;
303: }
304:
305: if (pnt < end)
306: {
307: val = *pnt;
308: while (val)
309: {
310: len++;
311: val <<= 1;
312: }
313: }
314: return len;
315: }
316:
317: /* Apply mask to IPv4 prefix. */
318: void
319: apply_mask_ipv4 (struct prefix_ipv4 *p)
320: {
321: u_char *pnt;
322: int index;
323: int offset;
324:
325: index = p->prefixlen / 8;
326:
327: if (index < 4)
328: {
329: pnt = (u_char *) &p->prefix;
330: offset = p->prefixlen % 8;
331:
332: pnt[index] &= maskbit[offset];
333: index++;
334:
335: while (index < 4)
336: pnt[index++] = 0;
337: }
338: }
339:
340: /* If prefix is 0.0.0.0/0 then return 1 else return 0. */
341: int
342: prefix_ipv4_any (const struct prefix_ipv4 *p)
343: {
344: return (p->prefix.s_addr == 0 && p->prefixlen == 0);
345: }
346:
347: #ifdef HAVE_IPV6
348:
349: /* Allocate a new ip version 6 route */
350: struct prefix_ipv6 *
351: prefix_ipv6_new (void)
352: {
353: struct prefix_ipv6 *p;
354:
355: /* Allocate a full-size struct prefix to avoid problems with structure
356: size mismatches. */
357: p = (struct prefix_ipv6 *)prefix_new();
358: p->family = AF_INET6;
359: return p;
360: }
361:
362: /* Free prefix for IPv6. */
363: void
364: prefix_ipv6_free (struct prefix_ipv6 *p)
365: {
366: prefix_free((struct prefix *)p);
367: }
368:
369: /* If given string is valid return pin6 else return NULL */
370: int
371: str2prefix_ipv6 (const char *str, struct prefix_ipv6 *p)
372: {
373: char *pnt;
374: char *cp;
375: int ret;
376:
377: pnt = strchr (str, '/');
378:
379: /* If string doesn't contain `/' treat it as host route. */
380: if (pnt == NULL)
381: {
382: ret = inet_pton (AF_INET6, str, &p->prefix);
383: if (ret == 0)
384: return 0;
385: p->prefixlen = IPV6_MAX_BITLEN;
386: }
387: else
388: {
389: int plen;
390:
391: cp = XMALLOC (0, (pnt - str) + 1);
392: strncpy (cp, str, pnt - str);
393: *(cp + (pnt - str)) = '\0';
394: ret = inet_pton (AF_INET6, cp, &p->prefix);
395: free (cp);
396: if (ret == 0)
397: return 0;
398: plen = (u_char) atoi (++pnt);
399: if (plen > 128)
400: return 0;
401: p->prefixlen = plen;
402: }
403: p->family = AF_INET6;
404:
405: return ret;
406: }
407:
408: /* Convert struct in6_addr netmask into integer.
409: * FIXME return u_char as ip_maskleni() does. */
410: int
411: ip6_masklen (struct in6_addr netmask)
412: {
413: int len = 0;
414: unsigned char val;
415: unsigned char *pnt;
416:
417: pnt = (unsigned char *) & netmask;
418:
419: while ((*pnt == 0xff) && len < 128)
420: {
421: len += 8;
422: pnt++;
423: }
424:
425: if (len < 128)
426: {
427: val = *pnt;
428: while (val)
429: {
430: len++;
431: val <<= 1;
432: }
433: }
434: return len;
435: }
436:
437: void
438: masklen2ip6 (int masklen, struct in6_addr *netmask)
439: {
440: unsigned char *pnt;
441: int bit;
442: int offset;
443:
444: memset (netmask, 0, sizeof (struct in6_addr));
445: pnt = (unsigned char *) netmask;
446:
447: offset = masklen / 8;
448: bit = masklen % 8;
449:
450: while (offset--)
451: *pnt++ = 0xff;
452:
453: if (bit)
454: *pnt = maskbit[bit];
455: }
456:
457: void
458: apply_mask_ipv6 (struct prefix_ipv6 *p)
459: {
460: u_char *pnt;
461: int index;
462: int offset;
463:
464: index = p->prefixlen / 8;
465:
466: if (index < 16)
467: {
468: pnt = (u_char *) &p->prefix;
469: offset = p->prefixlen % 8;
470:
471: pnt[index] &= maskbit[offset];
472: index++;
473:
474: while (index < 16)
475: pnt[index++] = 0;
476: }
477: }
478:
479: void
480: str2in6_addr (const char *str, struct in6_addr *addr)
481: {
482: int i;
483: unsigned int x;
484:
485: /* %x must point to unsinged int */
486: for (i = 0; i < 16; i++)
487: {
488: sscanf (str + (i * 2), "%02x", &x);
489: addr->s6_addr[i] = x & 0xff;
490: }
491: }
492: #endif /* HAVE_IPV6 */
493:
494: void
495: apply_mask (struct prefix *p)
496: {
497: switch (p->family)
498: {
499: case AF_INET:
500: apply_mask_ipv4 ((struct prefix_ipv4 *)p);
501: break;
502: #ifdef HAVE_IPV6
503: case AF_INET6:
504: apply_mask_ipv6 ((struct prefix_ipv6 *)p);
505: break;
506: #endif /* HAVE_IPV6 */
507: default:
508: break;
509: }
510: return;
511: }
512:
513: /* Utility function of convert between struct prefix <=> union sockunion.
514: * FIXME This function isn't used anywhere. */
515: struct prefix *
516: sockunion2prefix (const union sockunion *dest,
517: const union sockunion *mask)
518: {
519: if (dest->sa.sa_family == AF_INET)
520: {
521: struct prefix_ipv4 *p;
522:
523: p = prefix_ipv4_new ();
524: p->family = AF_INET;
525: p->prefix = dest->sin.sin_addr;
526: p->prefixlen = ip_masklen (mask->sin.sin_addr);
527: return (struct prefix *) p;
528: }
529: #ifdef HAVE_IPV6
530: if (dest->sa.sa_family == AF_INET6)
531: {
532: struct prefix_ipv6 *p;
533:
534: p = prefix_ipv6_new ();
535: p->family = AF_INET6;
536: p->prefixlen = ip6_masklen (mask->sin6.sin6_addr);
537: memcpy (&p->prefix, &dest->sin6.sin6_addr, sizeof (struct in6_addr));
538: return (struct prefix *) p;
539: }
540: #endif /* HAVE_IPV6 */
541: return NULL;
542: }
543:
544: /* Utility function of convert between struct prefix <=> union sockunion. */
545: struct prefix *
546: sockunion2hostprefix (const union sockunion *su)
547: {
548: if (su->sa.sa_family == AF_INET)
549: {
550: struct prefix_ipv4 *p;
551:
552: p = prefix_ipv4_new ();
553: p->family = AF_INET;
554: p->prefix = su->sin.sin_addr;
555: p->prefixlen = IPV4_MAX_BITLEN;
556: return (struct prefix *) p;
557: }
558: #ifdef HAVE_IPV6
559: if (su->sa.sa_family == AF_INET6)
560: {
561: struct prefix_ipv6 *p;
562:
563: p = prefix_ipv6_new ();
564: p->family = AF_INET6;
565: p->prefixlen = IPV6_MAX_BITLEN;
566: memcpy (&p->prefix, &su->sin6.sin6_addr, sizeof (struct in6_addr));
567: return (struct prefix *) p;
568: }
569: #endif /* HAVE_IPV6 */
570: return NULL;
571: }
572:
573: int
574: prefix_blen (const struct prefix *p)
575: {
576: switch (p->family)
577: {
578: case AF_INET:
579: return IPV4_MAX_BYTELEN;
580: break;
581: #ifdef HAVE_IPV6
582: case AF_INET6:
583: return IPV6_MAX_BYTELEN;
584: break;
585: #endif /* HAVE_IPV6 */
586: }
587: return 0;
588: }
589:
590: /* Generic function for conversion string to struct prefix. */
591: int
592: str2prefix (const char *str, struct prefix *p)
593: {
594: int ret;
595:
596: /* First we try to convert string to struct prefix_ipv4. */
597: ret = str2prefix_ipv4 (str, (struct prefix_ipv4 *) p);
598: if (ret)
599: return ret;
600:
601: #ifdef HAVE_IPV6
602: /* Next we try to convert string to struct prefix_ipv6. */
603: ret = str2prefix_ipv6 (str, (struct prefix_ipv6 *) p);
604: if (ret)
605: return ret;
606: #endif /* HAVE_IPV6 */
607:
608: return 0;
609: }
610:
611: int
612: prefix2str (const struct prefix *p, char *str, int size)
613: {
614: char buf[BUFSIZ];
615:
616: inet_ntop (p->family, &p->u.prefix, buf, BUFSIZ);
617: snprintf (str, size, "%s/%d", buf, p->prefixlen);
618: return 0;
619: }
620:
621: struct prefix *
622: prefix_new ()
623: {
624: struct prefix *p;
625:
626: p = XCALLOC (MTYPE_PREFIX, sizeof *p);
627: return p;
628: }
629:
630: /* Free prefix structure. */
631: void
632: prefix_free (struct prefix *p)
633: {
634: XFREE (MTYPE_PREFIX, p);
635: }
636:
637: /* Utility function. Check the string only contains digit
638: * character.
639: * FIXME str.[c|h] would be better place for this function. */
640: int
641: all_digit (const char *str)
642: {
643: for (; *str != '\0'; str++)
644: if (!isdigit ((int) *str))
645: return 0;
646: return 1;
647: }
648:
649: /* Utility function to convert ipv4 prefixes to Classful prefixes */
650: void apply_classful_mask_ipv4 (struct prefix_ipv4 *p)
651: {
652:
653: u_int32_t destination;
654:
655: destination = ntohl (p->prefix.s_addr);
656:
657: if (p->prefixlen == IPV4_MAX_PREFIXLEN);
658: /* do nothing for host routes */
659: else if (IN_CLASSC (destination))
660: {
661: p->prefixlen=24;
662: apply_mask_ipv4(p);
663: }
664: else if (IN_CLASSB(destination))
665: {
666: p->prefixlen=16;
667: apply_mask_ipv4(p);
668: }
669: else
670: {
671: p->prefixlen=8;
672: apply_mask_ipv4(p);
673: }
674: }
675:
676: in_addr_t
677: ipv4_network_addr (in_addr_t hostaddr, int masklen)
678: {
679: struct in_addr mask;
680:
681: masklen2ip (masklen, &mask);
682: return hostaddr & mask.s_addr;
683: }
684:
685: in_addr_t
686: ipv4_broadcast_addr (in_addr_t hostaddr, int masklen)
687: {
688: struct in_addr mask;
689:
690: masklen2ip (masklen, &mask);
691: return (masklen != IPV4_MAX_PREFIXLEN-1) ?
692: /* normal case */
693: (hostaddr | ~mask.s_addr) :
694: /* special case for /31 */
695: (hostaddr ^ ~mask.s_addr);
696: }
697:
698: /* Utility function to convert ipv4 netmask to prefixes
699: ex.) "1.1.0.0" "255.255.0.0" => "1.1.0.0/16"
700: ex.) "1.0.0.0" NULL => "1.0.0.0/8" */
701: int
702: netmask_str2prefix_str (const char *net_str, const char *mask_str,
703: char *prefix_str)
704: {
705: struct in_addr network;
706: struct in_addr mask;
707: u_char prefixlen;
708: u_int32_t destination;
709: int ret;
710:
711: ret = inet_aton (net_str, &network);
712: if (! ret)
713: return 0;
714:
715: if (mask_str)
716: {
717: ret = inet_aton (mask_str, &mask);
718: if (! ret)
719: return 0;
720:
721: prefixlen = ip_masklen (mask);
722: }
723: else
724: {
725: destination = ntohl (network.s_addr);
726:
727: if (network.s_addr == 0)
728: prefixlen = 0;
729: else if (IN_CLASSC (destination))
730: prefixlen = 24;
731: else if (IN_CLASSB (destination))
732: prefixlen = 16;
733: else if (IN_CLASSA (destination))
734: prefixlen = 8;
735: else
736: return 0;
737: }
738:
739: sprintf (prefix_str, "%s/%d", net_str, prefixlen);
740:
741: return 1;
742: }
743:
744: #ifdef HAVE_IPV6
745: /* Utility function for making IPv6 address string. */
746: const char *
747: inet6_ntoa (struct in6_addr addr)
748: {
749: static char buf[INET6_ADDRSTRLEN];
750:
751: inet_ntop (AF_INET6, &addr, buf, INET6_ADDRSTRLEN);
752: return buf;
753: }
754: #endif /* HAVE_IPV6 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to prefix.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib