Source File include/iproutines.h

    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)
    137  | #define IP_pref_e2b(a,b) IP_pref_t2b(a,b,IP_PLAIN)
    138  | #define IP_rang_e2b(a,b) IP_rang_t2b(a,b,IP_PLAIN)
    139  | #define IP_revd_e2b(a,b) IP_revd_t2b(a,b,IP_PLAIN)
    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)
    144  | #define IP_pref_a2b(a,b) IP_pref_t2b(a,b,IP_EXPN)
    145  | #define IP_rang_a2b(a,b) IP_rang_t2b(a,b,IP_EXPN)
    146  | #define IP_revd_a2b(a,b) IP_revd_t2b(a,b,IP_EXPN)
    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)
    192  | #define IP_pref_b2v6_len(prefix) IP_pref_b2_len(prefix)
    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)
    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)
    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 */