lib/space/services.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/rcstring/accumulator.h>
#include <lib/space/protocols.h>
#include <lib/space/services.h>


space_services::~space_services()
{
    discard_comments();
    discard_blank_lines();
}


space_services::space_services(const rcstring &a_filename) :
    space(a_filename),
    last_num(-1)
{
    discard_comments();
    discard_blank_lines();
}


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


space_services::record::pointer
space_services::get(void)
{
    for (;;)
    {
        source_location line_locn;
        line_t line;
        if (!read_one_line(line_locn, line))
        {
            last_num = -1;
            return record::pointer();
        }
        if (line.size() < 2)
        {
            error
            (
                line_locn,
                "too few fields (expected 2, given %d)",
                (int)line.size()
            );
            continue;
        }

        //
        // The first field is the name.
        //
        rcstring rec_name = line[0];
        rcstring rec_name_suggest;
        if (!is_ok_name(rec_name, rec_name_suggest))
        {
            error
            (
                line_locn,
                "service name %s not valid, suggest %s instead",
                rec_name.c_str(),
                rec_name_suggest.c_str()
            );
            rec_name = rec_name_suggest;
        }

        //
        // The second field is the port/protocol.
        //
        std::vector<rcstring> second = line[1].break_up("/", false);
        if (second.size() != 2)
        {
            error
            (
                line_locn,
                "the second field %s is required to be composed of 2 parts "
                "separated by a slash, not the %d part%s given",
                line[1].quote_c().c_str(),
                (int)second.size(),
                (second.size() == 1 ? "" : "s")
            );
            if (second.size() == 0)
                second[0] = "-1";
            if (second.size() == 1)
                second[1] = "dummy";
        }
        rcstring rec_port = second[0];
        long rec_port_binary = -1;
        if (!second[0].to_long(rec_port_binary))
        {
            error
            (
                line_locn,
                "port number %s is not valid",
                rec_port.quote_c().c_str()
            );
            continue;
        }
        if (rec_port_binary < 0 || rec_port_binary >= (1L << 16))
        {
            error
            (
                line_locn,
                "service number %ld out of range (1..65535)",
                rec_port_binary
            );
            continue;
        }
        // canonicalise
        rec_port = rcstring::format("%ld", rec_port_binary);

        rcstring rec_protocol = second[1];
        {
            rcstring suggest;
            if (!space_protocols::is_ok_name(rec_protocol, false, suggest))
            {
                error
                (
                    line_locn,
                    "protocol name %s not valid, suggest %s instead",
                    rec_protocol.quote_c().c_str(),
                    suggest.quote_c().c_str()
                );
                rec_protocol = suggest;
            }
        }

        //
        // Check record sequencing.
        //
        if (rec_port_binary < last_num)
        {
            error
            (
                line_locn,
                "service number %ld out of order",
                rec_port_binary
            );
            explain_sequence_errors();
        }
        last_num = rec_port_binary;

        //
        // The third and subsequent arguments are aliases.
        //
        record::aliases_t rec_aliases;
        for
        (
            line_t::const_iterator it = line.begin() + 2;
            it != line.end();
            ++it
        )
        {
            rcstring name = *it;
            rcstring suggest;
            if (!is_ok_name(name, suggest))
            {
                error
                (
                    line_locn,
                    "service alias %s not valid, suggest %s instead",
                    name.quote_c().c_str(),
                    suggest.quote_c().c_str()
                );
            }
            rec_aliases.push_back(name);
        }

        //
        // Create the record
        //
        record::pointer rp =
            record::create
            (
                line_locn,
                rec_name,
                rec_port,
                rec_protocol,
                rec_aliases
            );

        //
        // Make sure the representation fits within the size limit.
        //
        if (rp->representation().size() >= 512)
        {
            error
            (
                rp->get_source_location(),
                "line too long (NIS limits records to 511 bytes)"
            );
        }

        //
        // return the row to the caller
        //
        return rp;
    }
}


space_services::record::~record()
{
}


space_services::record::record(
    const source_location &a_locn,
    const rcstring &a_name,
    const rcstring &a_port,
    const rcstring &a_protocol,
    const aliases_t &a_aliases
) :
    locn(a_locn),
    name(a_name),
    port(a_port),
    protocol(a_protocol),
    aliases(a_aliases)
{
}


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


int
space_services::record::get_port_binary(void)
    const
{
    long value = -1;
    if (!port.to_long(value))
        return -1;
    return value;
}


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


bool
space_services::is_ok_name(const rcstring &text, rcstring &suggest)
{
    if (text.empty())
    {
        suggest = "a";
        return false;
    }

    //
    // According to http://www.iana.org/assignments/service-names
    // "A service name may be up to 40 characters taken from the set of
    // upper case letters, digits, and the punctuation character hyphen.
    // It must start with a letter, and end with a letter or digit."
    //
    // But there are problems: "whois++", "z39.50" and "krb5_pop"
    //
    // Traditionally unix service names have been mostly lowercase,
    // so we will continue to allow lower case names.
    //
    enum { maxlen = 40 };
    const char *cp = text.c_str();
    const char *end =
        cp + (text.size() < maxlen ? text.size() : (size_t)maxlen);
    rcstring_accumulator acc;
    bool all_numeric = true;
    while (cp < end)
    {
        unsigned char c = *cp++;
        switch (c)
        {
        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':
            all_numeric = false;
            break;

        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':
            c = tolower(c);
            all_numeric = false;
            break;

        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            break;

#ifndef STRICT_IANA_RULES
        //
        // To cope with IANA's own exceptions ("whois++", "z39.50" and
        // "krb5_pop") we permit a few more characters.
        //
        case '_':
            all_numeric = false;
            break;

        case '.':
        case '+':
#endif
        case '-':
            break;

        default:
            c = '-';
            break;
        }
        acc.push_back(c);
    }

    //
    // starts with a letter
    //
#ifdef STRICT_IANA_RULES
    if (!isalpha(acc.front()))
#else
    if (!isalnum(acc.front()))
#endif
    {
        if (acc.size() >= maxlen)
            acc.pop_back();
        acc.push_front('a');
        all_numeric = false;
    }

    //
    // To cope with the "whois++' case, we don't enforce the "ends in a
    // letter or digit" rule.
    //
#ifdef STRICT_IANA_RULES
    if (!isalnum(acc.back()))
    {
        if (acc.size() >= maxlen)
            acc.pop_back();
        acc.push_back('a');
        all_numeric = false;
    }
#endif

    // one final check
    if (all_numeric)
    {
        if (acc.size() >= maxlen)
            acc.pop_back();
        acc.push_front('a');
    }

    // build the suggestion
    suggest = acc.mkstr();

    // the name is ok if the suggestion is identical to the original text
    return (text == suggest);
}


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