Provided by: libbobcat-dev_3.19.01-1ubuntu1_amd64 bug

NAME

       FBB::Cidr - Compares IP4 addresses to CIDR specifications

SYNOPSIS

       #include <bobcat/errno>
       Linking option: -lbobcat

DESCRIPTION

       Objects of the class Cidr can be used for testing whether IP4 Internet addresses belong to address ranges
       defined  by Classless Inter-Domain Routing (CIDR) address block specifications. CIDR blocks are specified
       as a.b.c.d/m where a.b.c.d are the four octets of a  dotted  decimal  IP4  address  specification  (e.g.,
       129.125.14.80)  and  m is a mask-size (ranging from 0 to 32) defining the number of most significant bits
       to remain as-is. The CIDR specification 129.125.14.80/16  defines  a  class  B  network,  with  addresses
       ranging from 129.125.0.0 to 129.125.255.255.

       The  mask  size  does not have to be a multiple of 8. E.g., when specifying 129.125.14.80/5 only the most
       significant 5 bits of the first octed are fixed, resulting in an address range ranging from 128.0.0.0  to
       135.255.255.255.

       CIDR  specifications passed to a Cidr object must be of the form a.b.c.d or a.b.c.d/m. If the mask is not
       specified a mask-size of 32 is used, effectively defining an address range  of  only  one  address.  Mask
       values of 0 are ignored.  Mask values of 0 are ignored by Cidr objects.

       When  specifying  CIDRs  on a stream, empty lines and comment lines (having a hash-character (#) as their
       first non-blank character) are ignored.  Non-empty lines must start with a CIDR  specification,  and  the
       Cidr object will ignore all information on a line trailing a CIDR specification.

NAMESPACE

       FBB
       All  constructors,  members,  operators  and manipulators, mentioned in this man-page, are defined in the
       namespace FBB.

INHERITS FROM

       -

CONSTRUCTORS

       o      Cidr(std::string const &cidrPattern):
              The Cidr object is initialized with a single CIDR specification.

       o      Cidr(std::istream &cidrStream):
              The Cidr object is initialized with CIDR specifications read  from  the  std::istream  cidrStream.
              The default, copy and move constructors are available.

OVERLOADED OPERATORS

       The copy and move assignment operators are available.

MEMBER FUNCTIONS

       The  return  valuess  of  the accessors (i.e., the const members) are only defined following a successful
       match (see below, the match members).

       o      std::string const &address() const:
              returns the address matching a CIDR.

       o      std::string cidr() const:
              returns the CIDR containing a specified address.

       o      std::string first() const:
              returns the first address of the range of addresses defined by the CIDR specification.

       o      std::string last() const:
              returns the last address of the range of addresses defined by the CIDR  specification.  Note  that
              first,  last  do  not  define an iterator range. The address returned by last still belongs to the
              CIDR-range.

       o      bool match(std::istream &in):
              The value true is returned when an IP4 address found in the lines of in belongs to  a  CIDR  range
              inspected  by  the  Cidr  object.  The  match function returns true at the first matching address.
              E.g., if a line contains the text

                  This is address 1.2.3.4 and this is 5.6.7.8

              and the CIDR specifications

                      5.1.1.1/8
                      1.2.1.1/16

              were provided to the Cidr object, then the object will report a match for 5.6.7.8.

              As soon as a match is found match returns true. If none of the addresses found in the lines of  in
              matches any of the object’s CIDR specifications, false is returned.

       o      std::string mask() const:
              returns the mask used by the CIDR specification.

       o      bool match(std::string const &line):
              The  value true is returned when an IP4 address found in line belongs to a CIDR range inspected by
              the Cidr object. The match function returns true at the first matching address.

              If none of the addresses found in line matches any of the object’s CIDR specifications,  false  is
              returned.

       o      void setCidr(std::istream &cidrStream):
              A  new  set  of CIDR specification is loaded into the Cidr object, reading the specifications from
              cidrStream.

       o      void setCidr(std::string const &cidrPattern):
              A new CIDR specification is loaded  into  the  Cidr  object,  using  the  specification  found  in
              cidrPattern.  The Cidr object is initialized with a single CIDR specification which must be of the
              form  a.b.c.d  or  a.b.c.d/m.  If the mask is not specified a mask-size of 32 is used, effectively
              defining an address range of only one address. Mask values of 0 are ignored.

STATIC MEMBERS

       o      size_t dotted2binary(std::string const &dotted):
              Converts "a.b.c.d" to a 32-bits value

       o      std::string binary2dotted(size_t binary):
              Converts a 32-bits value to a dotted decimal IP4 address

EXAMPLE

       #include <fstream>
       #include <iostream>

       #include <bobcat/errno>
       #ifdef BOBCAT
           #include <bobcat/cidr>
       #else
           #include "cidr"
       #endif

       using namespace std;
       using namespace FBB;

       int main(int argc, char **argv)
       {
           enum Spec
           {
               NONE,
               FILE,
               CIN
           };

           Spec spec = CIN;
           ifstream in;

           if (argc > 1)
           {
               Errno::open(in, argv[1]);       // file containing cidr-specs
               spec = FILE;
           }

           while (true)
           {
               string cidrSpec;
               if (spec == CIN)
               {
                   cout << "Specify cidr (empty to quit): ";
                   if (!getline(cin, cidrSpec) || cidrSpec.empty())
                       break;
               }
               try
               {
                   Cidr cidr;

                   switch (spec)
                   {
                       case NONE:
                       return 0;

                       case FILE:
                           cidr.setCidr(in);
                           spec = NONE;
                       break;

                       case CIN:
                           cidr.setCidr(cidrSpec);
                   }

                   while (true)
                   {
                       cout << "Specify address to test (empty to " <<
                           (spec == CIN ? "respec. CIDR" : "quit") << "): ";
                       string address;
                       if (!getline(cin, address) || address.empty())
                           break;

                       if (!cidr.match(address))
                       {
                           cout << "Address " << address << " not in ";
                           if (spec == CIN)
                               cout << cidrSpec << ’\n’;
                           else
                               cout << "specifications in " << argv[1] << ’\n’;
                       }
                       else
                           cout << "Address " << address << " in " << cidr.cidr() <<
                                                                               "\n"
                               "Lowest address: " << cidr.first() << "\n"
                               "Highest address: " << cidr.last() << "\n"
                               "CIDR mask: " << cidr.mask() << "\n"
                               "Address: " << cidr.address() << ’\n’;
                   }
               }
               catch (Errno const &err)
               {
                   cout << "Oops... " << err.why() << "\n"
                           "Try again...\n";
               }
           }
       }

FILES

       bobcat/cidr - defines the class interface

SEE ALSO

       bobcat(7)

BUGS

       Members of Cidr use static data. The current implementation of Cidr is therefore not thread-safe.

DISTRIBUTION FILES

       o      bobcat_3.19.01-x.dsc: detached signature;

       o      bobcat_3.19.01-x.tar.gz: source archive;

       o      bobcat_3.19.01-x_i386.changes: change log;

       o      libbobcat1_3.19.01-x_*.deb: debian package holding the libraries;

       o      libbobcat1-dev_3.19.01-x_*.deb: debian package holding the libraries, headers and manual pages;

       o      http://sourceforge.net/projects/bobcat: public archive location;

BOBCAT

       Bobcat is an acronym of `Brokken’s Own Base Classes And Templates’.

COPYRIGHT

       This is free software, distributed under the terms of the GNU General Public License (GPL).

AUTHOR

       Frank B. Brokken (f.b.brokken@rug.nl).

libbobcat-dev_3.19.01-x.tar.gz                      2005-2013                                 FBB::Cidr(3bobcat)