ipv4.c

   1 /* ipv4.c
   2  *
   3  * IPv4 address class. They understand how to take netmasks into consideration
   4  * during equivalence testing.
   5  *
   6  * Gilbert Ramirez <gram@xiexie.org>
   7  *
   8  * $Id: ipv4.c,v 1.5 2000/01/07 22:05:28 guy Exp $
   9  *
  10  * Ethereal - Network traffic analyzer
  11  * By Gerald Combs <gerald@zing.org>
  12  * Copyright 1998 Gerald Combs
  13  *
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <glib.h>
  35 #include <stdio.h>
  36
  37 #ifdef HAVE_SYS_TYPES_H
  38 # include <sys/types.h>
  39 #endif
  40
  41 #ifdef HAVE_NETINET_IN_H
  42 # include <netinet/in.h>
  43 #endif
  44
  45 #include "ipv4.h"
  46 #include "packet.h" /* for ip_to_str */
  47
  48 static guint32 create_nmask(gint net_bits);
  49
  50 ipv4_addr*
  51 ipv4_addr_new(void)
  52 {
  53         ipv4_addr       *ipv4;
  54
  55         ipv4 = g_new(ipv4_addr, 1);
  56         return ipv4;
  57 }
  58
  59 void
  60 ipv4_addr_free(ipv4_addr *ipv4)
  61 {
  62         if (ipv4)
  63                 g_free(ipv4);
  64 }
  65
  66 void
  67 ipv4_addr_set_host_order_addr(ipv4_addr *ipv4, guint32 new_addr)
  68 {
  69         ipv4->addr = new_addr;
  70 }
  71
  72 void
  73 ipv4_addr_set_net_order_addr(ipv4_addr *ipv4, guint32 new_addr)
  74 {
  75         ipv4->addr = ntohl(new_addr);
  76 }
  77
  78 void
  79 ipv4_addr_set_netmask_bits(ipv4_addr *ipv4, guint new_nmask_bits)
  80 {
  81 /*      ipv4->nmask_bits = new_nmask_bits;*/
  82         ipv4->nmask = create_nmask(new_nmask_bits);
  83 }
  84
  85 guint32
  86 ipv4_get_net_order_addr(ipv4_addr *ipv4)
  87 {
  88         return htonl(ipv4->addr);
  89 }
  90
  91 guint32
  92 ipv4_get_host_order_addr(ipv4_addr *ipv4)
  93 {
  94         return ipv4->addr;
  95 }
  96
  97 gchar*
  98 ipv4_addr_str(ipv4_addr *ipv4)
  99 {
 100         guint32 ipv4_host_order = htonl(ipv4->addr);
 101         return ip_to_str((gchar*)&ipv4_host_order);
 102 }
 103
 104 static guint32
 105 create_nmask(gint net_bits)
 106 {
 107         static guint32 bitmasks[33] = {
 108                 0x00000000,
 109                 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000,
 110                 0xf8000000, 0xfc000000, 0xfe000000, 0xff000000,
 111                 0xff800000, 0xffc00000, 0xffe00000, 0xfff00000,
 112                 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000,
 113                 0xffff8000, 0xffffc000, 0xffffe000, 0xfffff000,
 114                 0xfffff800, 0xfffffc00, 0xfffffe00, 0xffffff00,
 115                 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0,
 116                 0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff,
 117         };
 118
 119         g_assert(net_bits <= 32);
 120
 121         return bitmasks[net_bits];
 122 }
 123
 124
 125
 126 /*
 127  * w.x.y.z/32 eq w.x.y.0/24    TRUE
 128  */
 129
 130 /* Returns TRUE if equal, FALSE if not */
 131 gboolean
 132 ipv4_addr_eq(ipv4_addr *a, ipv4_addr *b)
 133 {
 134         guint32 val_a, val_b, nmask;
 135
 136         nmask = MIN(a->nmask, b->nmask);
 137         val_a = a->addr & nmask;
 138         val_b = b->addr & nmask;
 139         return (val_a == val_b);
 140 }
 141
 142 gboolean
 143 ipv4_addr_gt(ipv4_addr *a, ipv4_addr *b)
 144 {
 145         guint32 val_a, val_b, nmask;
 146
 147         nmask = MIN(a->nmask, b->nmask);
 148         val_a = a->addr & nmask;
 149         val_b = b->addr & nmask;
 150
 151         return (val_a > val_b);
 152 }
 153
 154 gboolean
 155 ipv4_addr_ge(ipv4_addr *a, ipv4_addr *b)
 156 {
 157         guint32 val_a, val_b, nmask;
 158
 159         nmask = MIN(a->nmask, b->nmask);
 160         val_a = a->addr & nmask;
 161         val_b = b->addr & nmask;
 162
 163         return (val_a >= val_b);
 164 }
 165
 166 gboolean
 167 ipv4_addr_lt(ipv4_addr *a, ipv4_addr *b)
 168 {
 169         guint32 val_a, val_b, nmask;
 170
 171         nmask = MIN(a->nmask, b->nmask);
 172         val_a = a->addr & nmask;
 173         val_b = b->addr & nmask;
 174
 175         return (val_a < val_b);
 176 }
 177
 178 gboolean
 179 ipv4_addr_le(ipv4_addr *a, ipv4_addr *b)
 180 {
 181         guint32 val_a, val_b, nmask;
 182
 183         nmask = MIN(a->nmask, b->nmask);
 184         val_a = a->addr & nmask;
 185         val_b = b->addr & nmask;
 186
 187         return (val_a <= val_b);
 188 }