include/iproutines.h

/* [<][>]
[^][v][top][bottom][index][help] */

FUNCTIONS

This source file includes following functions.
  1. IP_addr_e2b
  2. IP_pref_e2b
  3. IP_rang_e2b
  4. IP_revd_e2b
  5. IP_addr_a2b
  6. IP_pref_a2b
  7. IP_rang_a2b
  8. IP_revd_a2b
  9. IP_pref_b2v4_len
  10. IP_pref_b2v6_len
  11. IP_revd_b2v4
  12. IP_revd_b2v6

   1 /***************************************
   2   $Revision: 1.19 $
   3 
   4   IP handling (ip). iproutines.h  - header file for conversions routines.
   5                                     defines data structures for IP module.
   6 
   7   Status: NOT REVUED, TESTED
   8 
   9   Design and implementation by: Marek Bukowy
  10 
  11   ******************/ /******************
  12   Copyright (c) 1999                              RIPE NCC
  13  
  14   All Rights Reserved
  15   
  16   Permission to use, copy, modify, and distribute this software and its
  17   documentation for any purpose and without fee is hereby granted,
  18   provided that the above copyright notice appear in all copies and that
  19   both that copyright notice and this permission notice appear in
  20   supporting documentation, and that the name of the author not be
  21   used in advertising or publicity pertaining to distribution of the
  22   software without specific, written prior permission.
  23   
  24   THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  25   ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS; IN NO EVENT SHALL
  26   AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
  27   DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
  28   AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  29   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  30   ***************************************/
  31 
  32 
  33 #ifndef _IP_H
  34 #define _IP_H
  35 
  36 /* NOTE: some #include calls are further down in the file */ 
  37 
  38 #include <sys/types.h>
  39 #include <glib.h>
  40 
  41 #include <inet6def.h>
  42 
  43 /*+ the key type (for ascii keys - tells what it was before it was 
  44     converted into prefixes in smart_conv() +*/
  45 
  46 typedef enum {
  47   IPK_UNDEF = 0,
  48   IPK_RANGE,
  49   IPK_PREFIX,
  50   IPK_IP
  51 } ip_keytype_t;
  52 
  53 /*+ the space type +*/
  54 typedef enum {
  55   IP_V4 = 1,
  56   IP_V6
  57 } ip_space_t;  
  58 
  59 
  60 typedef unsigned int   ip_limb_t; /* the limb must be at least 32 bit wide */
  61 typedef uint64_t       ip_v6word_t;
  62 /* should use 64bit for ipv6:   
  63    u_int64_t (bsd,linux)
  64    uint64_t (solaris)
  65 */
  66 #define IPLIMBNUM (16/sizeof(ip_limb_t))
  67 
  68 /*+ address structure +*/
  69 typedef struct {
  70   ip_limb_t  words[IPLIMBNUM];    /*+ 32/128 bit ip addr. SUBJECT TO CHANGE +*/
  71                              
  72   ip_space_t space;       /*+ MUST NOT BE char ! prefixes are compared with 
  73                             memcmp, so there may be absolutely no unitialised 
  74                             bytes  +*/
  75 } ip_addr_internal_t;
  76 
  77 /*+ prefix structure +*/
  78 typedef struct {
  79   unsigned                bits;         /*+ length in bits. +*/
  80   ip_addr_internal_t      ip;           /*+ the IP of the prefix +*/        
  81 } ip_prefix_internal_t;
  82  
  83 /*+ range structure +*/
  84 typedef struct {
  85   ip_addr_internal_t         begin;        /*+ IP where the range begins. +*/
  86   ip_addr_internal_t         end;          /*+ IP where it ends +*/
  87 } ip_range_internal_t;
  88 
  89 #if 0/* #ifndef IP_IMPL  -- set this to see accesses to structure members */
  90 /* hide the internals */
  91 typedef struct {char a[sizeof(ip_addr_internal_t)];}    ip_addr_t;
  92 typedef struct {char a[sizeof(ip_range_internal_t)];}   ip_range_t;
  93 typedef struct {char a[sizeof(ip_prefix_internal_t)];}  ip_prefix_t;
  94 #else
  95 typedef ip_addr_internal_t   ip_addr_t;
  96 typedef ip_range_internal_t  ip_range_t;
  97 typedef ip_prefix_internal_t ip_prefix_t;
  98 #endif 
  99 
 100 
 101 /*+ 
 102   stores size/span of an allocation 
 103   SUBJECT TO CHANGE: will be bigger for IPv6 
 104   +*/
 105 typedef unsigned int  ip_rangesize_t; 
 106 
 107 /*+  the length of a string that should be able to hold a prefix / range
 108     when used with b2a functions.
 109 +*/
 110 #define IP_ADDRSTR_MAX 20 /* XXX watch out for IPv6 !! */
 111 #define IP_PREFSTR_MAX 24
 112 #define IP_RANGSTR_MAX 48
 113 
 114 /*+ 
 115   IP expansion mode - for use with t2b functions, they control
 116   whether the input is supposed to be fully expanded or contain shortcuts
 117   (eg. enabling saying 0/0 instead 0.0.0.0/0)
 118   +*/
 119 typedef enum {
 120   IP_PLAIN = 1,
 121   IP_EXPN
 122 } ip_exp_t;
 123 
 124 #include <erroutines.h>
 125 
 126 
 127 /* prototypes */
 128 /* text to binary */
 129 er_ret_t IP_addr_t2b(ip_addr_t *ipptr, char *addr, ip_exp_t expf);
 130 er_ret_t IP_pref_t2b(ip_prefix_t *prefptr, char *prefstr, ip_exp_t expf);
 131 er_ret_t IP_rang_t2b(ip_range_t *rangptr, char *rangstr, ip_exp_t expf);
 132 er_ret_t IP_revd_t2b(ip_prefix_t *prefptr, char *prefstr, ip_exp_t expf);
 133 /* convenience (or call it backward compatibility) macros */
 134 
 135 /*+ the e2b macros assume fully expanded text  +*/
 136 #define IP_addr_e2b(a,b) IP_addr_t2b(a,b,IP_PLAIN)
     /* [<][>][^][v][top][bottom][index][help] */
 137 #define IP_pref_e2b(a,b) IP_pref_t2b(a,b,IP_PLAIN)
     /* [<][>][^][v][top][bottom][index][help] */
 138 #define IP_rang_e2b(a,b) IP_rang_t2b(a,b,IP_PLAIN)
     /* [<][>][^][v][top][bottom][index][help] */
 139 #define IP_revd_e2b(a,b) IP_revd_t2b(a,b,IP_PLAIN)
     /* [<][>][^][v][top][bottom][index][help] */
 140 
 141 /*+ the a2b macros will fully expand an address. 
 142   The details depend on the individual functions. +*/
 143 #define IP_addr_a2b(a,b) IP_addr_t2b(a,b,IP_EXPN)
     /* [<][>][^][v][top][bottom][index][help] */
 144 #define IP_pref_a2b(a,b) IP_pref_t2b(a,b,IP_EXPN)
     /* [<][>][^][v][top][bottom][index][help] */
 145 #define IP_rang_a2b(a,b) IP_rang_t2b(a,b,IP_EXPN)
     /* [<][>][^][v][top][bottom][index][help] */
 146 #define IP_revd_a2b(a,b) IP_revd_t2b(a,b,IP_EXPN)
     /* [<][>][^][v][top][bottom][index][help] */
 147 
 148 /* text fragments to binary */
 149 er_ret_t IP_addr_f2b_v4(ip_addr_t *addrptr, char *adrstr);
 150 er_ret_t IP_rang_f2b_v4(ip_range_t *rangptr, char *beginstr,  char *endstr);
 151 er_ret_t IP_pref_f2b_v4(ip_prefix_t *prefptr, char *prefixstr, 
 152                         char *lengthstr);
 153 er_ret_t IP_addr_f2b_v6(ip_addr_t *addrptr, char *msbstr, char *lsbstr );
 154 er_ret_t IP_pref_f2b_v6(ip_prefix_t *prefptr, char *msbstr, char *lsbstr, 
 155                         char *lengthstr);
 156 
 157 er_ret_t IP_addr_b2a(ip_addr_t *binaddr, char *ascaddr, unsigned strmax );
 158 er_ret_t IP_pref_b2a(ip_prefix_t *prefptr, char *ascaddr, unsigned strmax);
 159 er_ret_t IP_rang_b2a(ip_range_t *rangptr, char *ascaddr, unsigned strmax);
 160 er_ret_t IP_rang_classful(ip_range_t *rangptr, ip_addr_t *addrptr);
 161 er_ret_t IP_pref_2_rang( ip_range_t *rangptr, ip_prefix_t *prefptr );
 162   
 163 /* utility functions: testers/converters */
 164 int  IP_addr_bit_get(ip_addr_t *binaddr, unsigned bitnum);
 165 void IP_addr_bit_set(ip_addr_t *binaddr, unsigned bitnum, unsigned bitval);
 166 int  IP_addr_cmp(ip_addr_t *ptra, ip_addr_t *ptrb, unsigned len);
 167 unsigned  IP_sizebits(ip_space_t spc_id);
 168 void IP_pref_bit_fix( ip_prefix_t *prefix );
 169 int IP_addr_in_pref(ip_addr_t *ptra, ip_prefix_t *prefix);
 170 int IP_addr_in_rang(ip_addr_t *ptra, ip_range_t *rangptr);
 171 er_ret_t IP_smart_conv(char *key, int justcheck, int encomp, 
 172                        GList **preflist, ip_exp_t expf, ip_keytype_t *keytype);
 173 er_ret_t IP_smart_range(char *key, ip_range_t *rangptr, ip_exp_t expf, 
 174                         ip_keytype_t *keytype);
 175 
 176 
 177 ip_rangesize_t IP_rang_span( ip_range_t *rangptr );
 178 er_ret_t IP_addr_s2b(ip_addr_t *addrptr, void *addr_in, int addr_len);
 179 
 180 /* accessor functions */
 181 unsigned IP_addr_b2_space(ip_addr_t *addrptr);
 182 unsigned IP_pref_b2_space(ip_prefix_t *prefix);
 183 unsigned IP_rang_b2_space(ip_range_t *myrang);
 184 
 185 unsigned IP_addr_b2v4_addr(ip_addr_t *addrptr);
 186 ip_v6word_t IP_addr_b2v6_hi(ip_addr_t *addrptr); 
 187 ip_v6word_t IP_addr_b2v6_lo(ip_addr_t *addrptr);
 188 
 189 unsigned IP_pref_b2_space(ip_prefix_t *prefix);
 190 unsigned IP_pref_b2_len(ip_prefix_t *prefix);
 191 #define IP_pref_b2v4_len(prefix) IP_pref_b2_len(prefix)
     /* [<][>][^][v][top][bottom][index][help] */
 192 #define IP_pref_b2v6_len(prefix) IP_pref_b2_len(prefix)
     /* [<][>][^][v][top][bottom][index][help] */
 193 
 194 unsigned IP_pref_b2v4_addr(ip_prefix_t *prefix);
 195 void IP_addr_b2v4(ip_addr_t *addrptr, unsigned *address);
 196 void IP_pref_b2v4(ip_prefix_t *prefptr, 
 197                    unsigned int *prefix, 
 198                    unsigned int *prefix_length);
 199 #define IP_revd_b2v4(a,b,c) IP_pref_b2v4(a,b,c)
     /* [<][>][^][v][top][bottom][index][help] */
 200 void IP_pref_b2v6(ip_prefix_t *prefptr, 
 201                   ip_v6word_t *high, 
 202                   ip_v6word_t *low, 
 203                   unsigned int *prefix_length);
 204 #define IP_revd_b2v6(a,b,c,d) IP_pref_b2v6(a,b,c,d)
     /* [<][>][^][v][top][bottom][index][help] */
 205 void IP_rang_b2v4(ip_range_t *myrang,
 206                   unsigned *begin, 
 207                   unsigned *end);
 208 
 209 /******** constructing from raw values **********/
 210 er_ret_t IP_addr_v4_mk(ip_addr_t *addrptr, unsigned addrval);
 211 er_ret_t IP_addr_v6_mk(ip_addr_t *addrptr,
 212                        ip_v6word_t high, ip_v6word_t low);
 213 er_ret_t IP_pref_v4_mk(ip_prefix_t *prefix,
 214                        unsigned prefval, unsigned preflen);
 215 er_ret_t IP_rang_v4_mk(ip_range_t *rangptr, 
 216                        unsigned addrbegin, unsigned addrend);
 217 /* a2v4 functions to convert the ascii to binary, and
 218   then set the raw values at the pointers provided. */
 219 er_ret_t IP_pref_a2v4(char *avalue, ip_prefix_t *pref,
 220                       unsigned *prefix, unsigned *prefix_length);
 221 er_ret_t IP_pref_a2v6(char *avalue, ip_prefix_t *pref,
 222                       ip_v6word_t *high, ip_v6word_t  *low,
 223                       unsigned *prefix_length);
 224 er_ret_t IP_revd_a2v4(char *avalue, ip_prefix_t *pref,
 225                       unsigned int *prefix, unsigned int *prefix_length);
 226 er_ret_t IP_addr_a2v4(char *avalue,ip_addr_t *ipaddr, unsigned int *address);
 227 er_ret_t IP_rang_a2v4(char *rangstr, ip_range_t *myrang,
 228                       unsigned int *begin_in, unsigned int *end_in);
 229 
 230 /* decompose/find encompasssing prefix */
 231 void IP_rang_encomp(ip_range_t *rangptr);
 232 unsigned IP_rang_decomp(ip_range_t *rangptr, GList **preflist);
 233 
 234 /*
 235   this is to define a constant struct for comparisons.
 236 */
 237 #ifdef IP_IMPL
 238 const ip_addr_t IP_ADDR_UNSPEC={{0,0,0,0},0}; /* unlikely to be real :-)
 239                                                as there is no space 0 
 240                                                bonus: it's a natural state after 
 241                                                initializing to 0 */
 242 #else
 243 extern ip_addr_t IP_ADDR_UNSPEC;
 244 #endif
 245 
 246 #endif /* _IP_H */

/* [<][>][^][v][top][bottom][index][help] */