Return to ippool.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / coova-chilli / src

coova-chilli

    1: /* 
    2:  *
    3:  * IP address pool functions.
    4:  * Copyright (C) 2003, 2004 Mondru AB.
    5:  * Copyright (c) 2006-2007 David Bird <david@coova.com>
    6:  * 
    7:  * The contents of this file may be used under the terms of the GNU
    8:  * General Public License Version 2, provided that the above copyright
    9:  * notice and this permission notice is included in all copies or
   10:  * substantial portions of the software.
   11:  * 
   12:  */
   13: 
   14: #ifndef _IPPOOL_H
   15: #define _IPPOOL_H
   16: 
   17: /* Assuming that the address space is fragmented we need a hash table
   18:    in order to return the addresses.
   19: 
   20:    The list pool should provide for both IPv4 and IPv6 addresses.
   21: 
   22:    When initialising a new address pool it should be possible to pass
   23:    a string of CIDR format networks: "10.0.0.0/24 10.15.0.0/20" would
   24:    translate to 256 addresses starting at 10.0.0.0 and 1024 addresses
   25:    starting at 10.15.0.0. 
   26: 
   27:    The above also applies to IPv6 which can be specified as described
   28:    in RFC2373.
   29: */
   30: 
   31: #define IPPOOL_NOIP6
   32: 
   33: #include "system.h"
   34: 
   35: struct ippoolm_t;                /* Forward declaration */
   36: 
   37: struct ippool_t {
   38:   int listsize;                  /* Total number of addresses */
   39:   int allowdyn;                  /* Allow dynamic IP address allocation */
   40:   int allowstat;                 /* Allow static IP address allocation */
   41:   struct in_addr stataddr;       /* Static address range network address */
   42:   struct in_addr statmask;       /* Static address range network mask */
   43:   struct ippoolm_t *member;      /* Listsize array of members */
   44:   int hashsize;                  /* Size of hash table */
   45:   int hashlog;                   /* Log2 size of hash table */
   46:   int hashmask;                  /* Bitmask for calculating hash */
   47:   struct ippoolm_t **hash;       /* Hashsize array of pointer to member */
   48:   struct ippoolm_t *firstdyn;    /* Pointer to first free dynamic member */
   49:   struct ippoolm_t *lastdyn;     /* Pointer to last free dynamic member */
   50:   struct ippoolm_t *firststat;   /* Pointer to first free static member */
   51:   struct ippoolm_t *laststat;    /* Pointer to last free static member */
   52: };
   53: 
   54: struct ippoolm_t {
   55: #ifndef IPPOOL_NOIP6
   56:   struct in6_addr addr;          /* IP address of this member */
   57: #else
   58:   struct in_addr addr;           /* IP address of this member */
   59: #endif
   60:   int inuse;                     /* 0=available; 1= dynamic; 2 = static */
   61:   struct ippoolm_t *nexthash;    /* Linked list part of hash table */
   62:   struct ippoolm_t *prev, *next; /* Linked list of free dynamic or static */
   63:   void *peer;                    /* Pointer to peer protocol handler */
   64: };
   65: 
   66: /* The above structures require approximately 20+4 = 24 bytes for
   67:    each address (IPv4). For IPv6 the corresponding value is 32+4 = 36
   68:    bytes for each address. */
   69: 
   70: /* Hash an IP address using code based on Bob Jenkins lookupa */
   71: extern uint32_t ippool_hash4(struct in_addr *addr);
   72: 
   73: /* Create new address pool */
   74: extern int ippool_new(struct ippool_t **this, 
   75: 		      char *dyn, int start, int end, 
   76: 		      char *stat, int allowdyn, int allowstat);
   77: 
   78: /* Delete existing address pool */
   79: extern int ippool_free(struct ippool_t *this);
   80: 
   81: /* Find an IP address in the pool */
   82: extern int ippool_getip(struct ippool_t *this, struct ippoolm_t **member,
   83: 		 struct in_addr *addr);
   84: 
   85: /* Get an IP address. If addr = 0.0.0.0 get a dynamic IP address. Otherwise
   86:    check to see if the given address is available */
   87: extern int ippool_newip(struct ippool_t *this, struct ippoolm_t **member,
   88: 			struct in_addr *addr, int statip);
   89: 
   90: /* Return a previously allocated IP address */
   91: extern int ippool_freeip(struct ippool_t *this, struct ippoolm_t *member);
   92: 
   93: /* Get net and mask based on ascii string */
   94: extern int ippool_aton(struct in_addr *addr, struct in_addr *mask,
   95: 		       char *pool, int number);
   96: 
   97: int ippool_hashadd(struct ippool_t *this, struct ippoolm_t *member);
   98: 
   99: #ifndef IPPOOL_NOIP6
  100: extern uint32_t ippool_hash6(struct in6_addr *addr);
  101: extern int ippool_getip6(struct ippool_t *this, struct in6_addr *addr);
  102: extern int ippool_returnip6(struct ippool_t *this, struct in6_addr *addr);
  103: #endif
  104: 
  105: #endif	/* !_IPPOOL_H */