lib/space/networks.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 <arpa/inet.h>
#include <lib/ac/ctype.h>
#include <lib/ac/string.h>
#include <netinet/in.h>

#include <lib/net_utils.h>
#include <lib/space/networks.h>
#include <lib/rcstring/accumulator.h>


space_networks::~space_networks()
{
}


space_networks::space_networks(const rcstring &a_filename) :
    space(a_filename),
    last_addr(0)
{
    discard_comments();
    discard_blank_lines();
}


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


bool
space_networks::is_ok_name(const rcstring &input)
{
    rcstring dummy;
    return is_ok_name(input, dummy);
}


bool
space_networks::is_ok_name(const rcstring &input, rcstring &output)
{
    const char *cp = input.c_str();
    const char *end = cp + (input.size() < 40 ? input.size() : 40);
    rcstring_accumulator acc;
    while (cp < end)
    {
        unsigned char c = *cp++;
        assert(c != '\0');
        switch (c)
        {
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
        case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
        case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
        case 'v': case 'w': case 'x': case 'y': case 'z':
        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
        case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
        case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
        case 'V': case 'W': case 'X': case 'Y': case 'Z':
        case '_': case'-':
            acc.push_back(c);
            break;

        default:
            acc.push_back('_');
            break;
        }
    }
    output = acc.mkstr();
    return (input == output);
}


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

        //
        // Check the network name
        //
        rcstring rec_name = line[0];
        {
            rcstring suggest;
            if (!is_ok_name(rec_name, suggest))
            {
                error
                (
                    line_locn,
                    "network name %s not valid, suggest %s instead",
                    rec_name.quote_c().c_str(),
                    suggest.quote_c().c_str()
                );
                continue;
            }
        }

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

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

        //
        // 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 record ordering
        //
        if (last_addr > rec_number_binary)
        {
            error
            (
                line_locn,
                "address %s out of order",
                rec_number.quote_c().c_str()
            );
            explain_sequence_errors();
        }
        last_addr = rec_number_binary;

        //
        // Check the network aliases
        //
        record::aliases_t rec_aliases;
        for
        (
            line_t::const_iterator it = line.begin() + 2;
            it != line.end();
            ++it
        )
        {
            rcstring suggest;
            if (!is_ok_name(*it, suggest))
            {
                error
                (
                    line_locn,
                    "network alias %s not valid, suggest %s instead",
                    it->quote_c().c_str(),
                    suggest.quote_c().c_str()
                );
            }
            rec_aliases.push_back(*it);
        }

        //
        // build the record, and return it to the caller.
        //
        return record::create(line_locn, rec_name, rec_number, rec_aliases);
    }
}


space_networks::record::~record()
{
}


space_networks::record::record(
    const source_location &a_locn,
    const rcstring &a_name,
    const rcstring &a_number,
    const aliases_t &a_aliases
) :
    locn(a_locn),
    name(a_name),
    number(a_number),
    aliases(a_aliases)
{
}


space_networks::record::pointer
space_networks::record::create(const source_location &a_locn,
    const rcstring &a_name, const rcstring &a_number,
    const aliases_t &a_aliases)
{
    return pointer(new record(a_locn, a_name, a_number, a_aliases));
}


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


rcstring
space_networks::record::representation(void)
    const
{
    rcstring_accumulator acc;
    acc.push_back(name);
    acc.push_back(' ');
    acc.push_back(number);
    for
    (
        aliases_t::const_iterator it = aliases.begin();
        it != aliases.end();
        ++it
    )
    {
        acc.push_back(' ');
        acc.push_back(*it);
    }
    return acc.mkstr();
}


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