lib/space/protocols.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>


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


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


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


space_protocols::record::pointer
space_protocols::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 %d)",
                (int)line.size()
            );
            continue;
        }

        //
        // The first field is the name.
        //
        rcstring rec_name = line[0];
        rcstring name_suggestion;
        // NB: primary key is not allowed to contain upper case
        if (!is_ok_name(rec_name, false, name_suggestion))
        {
            error
            (
                line_locn,
                "protocol name %s not valid, suggest %s instead",
                rec_name.quote_c().c_str(),
                name_suggestion.quote_c().c_str()
            );
            rec_name = name_suggestion;
        }

        //
        // The second field is the number.
        //
        rcstring rec_number = line[1];
        long rec_number_binary = 0;
        if (!rec_number.to_long(rec_number_binary))
        {
            error
            (
                line_locn,
                "protocol number %s not valid",
                rec_number.quote_c().c_str()
            );
            continue;
        }
        if (rec_number_binary < 0 || rec_number_binary >= 256)
        {
            error
            (
                line_locn,
                "protocol number %ld out of range (0..255)",
                rec_number_binary
            );
            continue;
        }
        // normalise the number
        rec_number = rcstring::format("%ld", rec_number_binary);

        //
        // Check record sequencing.
        //
        if (rec_number_binary < last_num)
        {
            error
            (
                line_locn,
                "protocol number %ld out of order",
                rec_number_binary
            );
            explain_sequence_errors();
        }
        last_num = rec_number_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 alias_name = *it;
            // NB: aliases are permitted to contain upper case
            if (!is_ok_name(alias_name, true, name_suggestion))
            {
                error
                (
                    line_locn,
                    "protocol alias %s not valid, suggest %s instead",
                    alias_name.quote_c().c_str(),
                    name_suggestion.quote_c().c_str()
                );
                alias_name = name_suggestion;
            }
            rec_aliases.push_back(alias_name);
        }

        //
        // Create a new record.
        //
        record::pointer rp =
            record::create(line_locn, rec_name, rec_number, rec_aliases);

        //
        // Check line length.
        //
        if (rp->representation().size() >= 512)
        {
            error
            (
                rp->get_source_location(),
                "line too long (NIS limits records to 511 bytes)"
            );
        }

        //
        // Return the new record to the caller.
        //
        return rp;
    }
}


space_protocols::record::~record()
{
}


space_protocols::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_protocols::record::pointer
space_protocols::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));
}


int
space_protocols::record::get_number_binary(void)
    const
{
    long value = 0;
    if (!number.to_long(value))
        return -1;
    return value;
}


rcstring
space_protocols::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();
}


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

    //
    // See http://www.iana.org/assignments/protocol-numbers for assigned
    // numbers.
    //
    // According to http://www.iana.org/assignments/service-names
    // "A protocol 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."
    //
    enum { maxlen = 40 };

    //
    // However, IANA themselves don't follow the rules.
    // Examples are "3PC", "TP++", "AX.25" and "A/N"
    //
    // Traditionally unix protocol names have been lowercase, so we will
    // continue to allow lower case names.  The upper_case_ok argument
    // is to indicate that upper case is acceptable in aliases.
    //
    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':
            if (!upper_case_ok)
                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 "TP++", "A/N" and "AX.25" we allow some
        // additional characters.
        //
        case '/':
            all_numeric = false;
            break;

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

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

    //
    // To cope with the "3PC" case, we will allow leading digits.
    //
#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 "TP++' 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 last 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 :