lib/space/hosts.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2001-2003, 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 <netinet/in.h>
#include <libexplain/realloc.h>

#include <lib/configuration.h>
#include <lib/space/hosts.h>


space_hosts::~space_hosts()
{
}


space_hosts::space_hosts(const rcstring &a_filename) :
    space(a_filename)
{
    // This host's sysconf(HOST_NAME_MAX)-1 may be too generous for
    // all NIS clients.  Be conservative.
    cfg.set_builtin_long("hosts", ITEM_NAME_LENGTH_MAXIMUM, 63);

    discard_comments();
    discard_blank_lines();
}


space_hosts::pointer
space_hosts::create(const rcstring &filename)
{
    return pointer(new space_hosts(filename));
}


bool
space_hosts::valid_ip_address(const rcstring &input, rcstring &output)
{
    in_addr ipa;
    if (!inet_aton(input.c_str(), &ipa))
        return false;
    output = rcstring(inet_ntoa(ipa));
    return true;
}


bool
space_hosts::valid_host_name(const rcstring &input, rcstring &output)
{
    if (input.empty())
    {
        output = rcstring("_");
        return false;
    }

    enum { max_distance_between_dots = 63 };

    //
    // Temporary buffer to hold sanitised name.
    //
    static size_t bufmax;
    static char *buffer;
    while (bufmax < input.size())
    {
        bufmax = bufmax * 2 + 16;
        buffer = (char *)explain_realloc_or_die((void *)buffer, bufmax);
    }
    char *bp = buffer;

    //
    // Sanitize the name.
    //
    // FIXME: what is the BIND RFC (1035?),
    // and what does it say about names?
    //
    bool ok = true;
    const char *start = input.c_str();
    const char *ip = start;
    for (; *ip; ++ip)
    {
        int c = (unsigned char)*ip;
        if (c == '.')
        {
            if (!ip[1] || ip == start)
            {
                c = '_';
                ok = false;
            }
            else
            {
                if (ip - start > max_distance_between_dots)
                {
                    // move the output pointer back
                    bp += max_distance_between_dots + (start - ip);
                    ok = false;
                }

                // Can't have two dots in a row
                start = ip + 1;
            }
        }
        else if (isupper(c))
            c = tolower(c);
        else if (isalnum(c))
            ;
        else if (c != '-' && c != '_')
        {
            c = '_';
            ok = false;
        }
        *bp++ = c;
    }
    if (ip - start > max_distance_between_dots)
    {
        // move the output pointer back
        bp += max_distance_between_dots + (start - ip);
        ok = false;
    }
    output = rcstring(buffer, bp - buffer);
    return ok;
}


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

        //
        // Check IP Address.
        //
        in_addr tmp_addr;
        if (!inet_aton(line[0].c_str(), &tmp_addr))
        {
            error(glocn, "IP address %s not valid", line[0].quote_c().c_str());
            continue;
        }
        rcstring temp(inet_ntoa(tmp_addr));
        if (temp != line[0])
        {
            error
            (
                glocn,
                "IP address %s not in correct format, use %s instead",
                line[0].quote_c().c_str(),
                temp.quote_c().c_str()
            );
            line[0] = temp;
        }

        //
        // Check names
        //
        record::names_t names;
        for
        (
            line_t::iterator it = line.begin() + 1;
            it != line.end();
            ++it
        )
        {
            rcstring canonical_name;
            if (!valid_host_name(*it, canonical_name))
            {
                error
                (
                    glocn,
                    "host name %s is not valid, suggest %s instead",
                    it->quote_c().c_str(),
                    canonical_name.quote_c().c_str()
                );
            }
            else if (*it != canonical_name)
            {
                error
                (
                    glocn,
                    "host name %s not in correct format, use %s instead",
                    it->quote_c().c_str(),
                    canonical_name.quote_c().c_str()
                );
            }
            names.push_back(canonical_name);
        }

        record::pointer rp = record::create(glocn, line[0], names);

        //
        // Check record ordering
        // (this finds common typographical errors)
        //
        if (last_rp && *rp < *last_rp)
        {
            error
            (
                rp->get_source_location(),
                "address %s out of order",
                rp->get_ip_address().quote_c().c_str()
            );
            explain_sequence_errors();
        }
        last_rp = rp;

        //
        // return the record
        //
        return rp;
    }
}


space_hosts::record::~record()
{
}


space_hosts::record::record(
    const source_location &a_locn,
    const rcstring &a_ip_address,
    const names_t &a_names
) :
    locn(a_locn),
    ip_address(a_ip_address),
    names(a_names),
    ip_address_binary(0)
{
    in_addr tmp_addr;
    if (inet_aton(ip_address.c_str(), &tmp_addr))
        ip_address_binary = ntohl(tmp_addr.s_addr);
}


space_hosts::record::pointer
space_hosts::record::create(const source_location &a_locn,
    const rcstring &a_ip_address, const names_t &a_names)
{
    return pointer(new record(a_locn, a_ip_address, a_names));
}


rcstring
space_hosts::record::representation(void)
    const
{
    rcstring result = ip_address;
    for
    (
        std::vector<rcstring>::const_iterator it = names.begin();
        it != names.end();
        ++it
    )
    {
        result += " " + *it;
    }
    return result;
}


bool
space_hosts::record::operator<(const record &rhs)
    const
{
    return (ip_address_binary < rhs.ip_address_binary);
}


bool
space_hosts::record::operator<=(const record &rhs)
    const
{
    return (ip_address_binary <= rhs.ip_address_binary);
}


bool
space_hosts::record::operator>(const record &rhs)
    const
{
    return (ip_address_binary > rhs.ip_address_binary);
}


bool
space_hosts::record::operator>=(const record &rhs)
    const
{
    return (ip_address_binary >= rhs.ip_address_binary);
}


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