lib/space/netmasks.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2002, 2008, 2009, 2011, 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/string.h>
#include <arpa/inet.h>
#include <lib/ac/ctype.h>
#include <netinet/in.h>

#include <lib/net_utils.h>
#include <lib/space/netmasks.h>


space_netmasks::~space_netmasks()
{
}


space_netmasks::space_netmasks(const rcstring &a_filename) :
    space(a_filename),
    last_number(0)
{
    discard_comments();
    discard_blank_lines();
}


space_netmasks::pointer
space_netmasks::create(const rcstring &a_filename)
{
    return pointer(new space_netmasks(a_filename));
}


space_netmasks::record::pointer
space_netmasks::get(void)
{
    for (;;)
    {
        source_location line_locn;
        line_t line;
        if (!read_one_line(line_locn, line))
        {
            last_number = 0;
            return record::pointer();
        }
        if (line.size() < 2)
        {
            error
            (
                line_locn,
                "too few fields (expected 2, given %ld)",
                (long)line.size()
            );
            continue;
        }
        if (line.size() > 2)
        {
            error
            (
                line_locn,
                "too many fields (expected 2, given %ld)",
                (long)line.size()
            );
        }

        //
        // Check the network number.
        //
        in_addr tmp_addr;
        if (!inet_aton(line[0].c_str(), &tmp_addr))
        {
            error
            (
                line_locn,
                "network number %s not valid",
                line[0].quote_c().c_str()
            );
            continue;
        }
        rcstring temp(inet_ntoa(tmp_addr));
        if (temp != line[0])
        {
            error
            (
                line_locn,
                "network number %s not in correct format, use %s instead",
                line[0].quote_c().c_str(),
                temp.quote_c().c_str()
            );
        }
        rcstring rec_number = temp;
        unsigned long rec_number_binary = ntohl(tmp_addr.s_addr);

        //
        // Check record ordering
        //
        if (last_number > rec_number_binary)
        {
            error
            (
                line_locn,
                "network %s out of order",
                rec_number.quote_c().c_str()
            );
            explain_sequence_errors();
        }
        last_number = rec_number_binary;

        //
        // Check that it is class A, B or C.
        // Any other class is invalid.
        //
        int net_class = network_class_from_number(rec_number_binary);
        if (net_class > 'C')
        {
            error(line_locn, "networks of class %c are reserved", net_class);
        }

        //
        // Check the network mask.
        //
        rcstring rec_mask = line[1];
        if (!inet_aton(rec_mask.c_str(), &tmp_addr))
        {
            error
            (
                line_locn,
                "network mask %s not valid",
                rec_mask.quote_c().c_str()
            );
            continue;
        }
        temp = rcstring(inet_ntoa(tmp_addr));
        if (temp != rec_mask)
        {
            error
            (
                line_locn,
                "network mask %s not in correct format, use %s instead",
                rec_mask.quote_c().c_str(),
                temp.quote_c().c_str()
            );
            rec_mask = temp;
        }
        unsigned long rec_mask_binary = ntohl(tmp_addr.s_addr);

        //
        // Make sure the network mask has the correct pattern of ones
        // and zeros.  Otherwise it's stuffed.
        //
        {
            unsigned long tmp_mask = rec_mask_binary;
            unsigned long vfy_mask = 0xFFFFFFFFuL ^ (LSB(tmp_mask) - 1);
            vfy_mask &= ~3; // smallest possible subnet
            if (vfy_mask != tmp_mask)
            {
                rcstring s = string_from_network_number(vfy_mask);
                error
                (
                    line_locn,
                    "network mask %s not valid, "
                        "suggest network mask %s instead",
                    rec_mask.quote_c().c_str(),
                    s.quote_c().c_str()
                );

                // to avoid cascading errors, re-write the rule
                rec_mask_binary = vfy_mask;
                rec_mask = s;
            }
        }

        //
        // Make sure there are at least 2 bits at the bottom, otherwise
        // there are insufficient bits for hosts.
        //
        if (rec_number_binary & 3)
        {
            unsigned long tmp_number = rec_number_binary & ~3;
            rcstring tmp_number_str = string_from_network_number(tmp_number);
            error
            (
                line_locn,
                "network number %s has no room for any hosts, "
                    "suggest network number %s instead",
                rec_number.quote_c().c_str(),
                tmp_number_str.quote_c().c_str()
            );

            // to avoid cascading errors, re-write the rule
            rec_number_binary = tmp_number;
            rec_number = tmp_number_str;
        }
        if (rec_mask_binary & 3)
        {
            unsigned long tmp_mask = rec_mask_binary & ~3;
            rcstring s = string_from_network_number(tmp_mask);
            error
            (
                line_locn,
                "network mask %s has no room for any hosts, "
                    "suggest network mask %s instead",
                rec_mask.quote_c().c_str(),
                s.quote_c().c_str()
            );

            // to avoid cascading errors, re-write the rule
            rec_mask_binary = tmp_mask;
            rec_mask = s;
        }

        //
        // Sanity check the network number against the inverse
        // of the network mask.  We know the mask is valid at this point.
        //
        if (rec_number_binary & ~rec_mask_binary)
        {
            unsigned long vfy_num = rec_number_binary & rec_mask_binary;
            rcstring vfy_num_str = string_from_network_number(vfy_num);
            unsigned long vfy_mask =
                0xFFFFFFFFuL ^ (LSB(rec_number_binary) - 1);
            rcstring vfy_mask_str = string_from_network_number(vfy_mask);

            if (vfy_num != rec_number_binary)
            {
                if (vfy_mask != rec_mask_binary)
                {
                    error
                    (
                        line_locn,
                        "network number %s and network mask %s "
                            "inconsistent, suggest network number %s "
                            "or network mask %s instead",
                        rec_number.quote_c().c_str(),
                        rec_mask.quote_c().c_str(),
                        vfy_num_str.quote_c().c_str(),
                        vfy_mask_str.quote_c().c_str()
                    );
                    // to avoid cascading errors, re-write the rule
                    rec_mask_binary = vfy_mask;
                    rec_mask = vfy_mask_str;
                }
                else
                {
                    error
                    (
                        line_locn,
                        "network number %s and network mask %s inconsistent, "
                            "suggest network number %s instead",
                        rec_number.quote_c().c_str(),
                        rec_mask.quote_c().c_str(),
                        vfy_num_str.quote_c().c_str()
                    );
                    // to avoid cascading errors, re-write the rule
                    rec_number_binary = vfy_num;
                    rec_number = vfy_num_str;
                }
            }
            else
            {
                error
                (
                    line_locn,
                    "network number %s and network mask %s inconsistent, "
                        "suggest network mask %s instead",
                    rec_number.quote_c().c_str(),
                    rec_mask.quote_c().c_str(),
                    vfy_mask_str.quote_c().c_str()
                );
                // to avoid cascading errors, re-write the rule
                rec_mask_binary = vfy_mask;
                rec_mask = vfy_mask_str;
            }
        }

        //
        // build the new record and pass it to the caller.
        //
        return record::create(line_locn, rec_number, rec_mask);
    }
}


space_netmasks::record::~record()
{
}


space_netmasks::record::record(
    const source_location &a_locn,
    const rcstring &a_number,
    const rcstring &a_mask
) :
    locn(a_locn),
    number(a_number),
    mask(a_mask)
{
}


space_netmasks::record::pointer
space_netmasks::record::create(const source_location &a_locn,
    const rcstring &a_number, const rcstring &a_mask)
{
    return pointer(new record(a_locn, a_number, a_mask));
}


unsigned long
space_netmasks::record::get_number_binary(void)
    const
{
    return network_number_from_string(number);
}


unsigned long
space_netmasks::record::get_mask_binary(void)
    const
{
    return network_number_from_string(mask);
}


rcstring
space_netmasks::record::representation(void)
    const
{
    return (number + " " + mask);
}


// vim: set ts=8 sw=4 et :