lib/space/netgroup.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2001, 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/ctype.h>

#include <lib/colon/passwd.h>
#include <lib/rcstring/accumulator.h>
#include <lib/space/hosts.h>
#include <lib/space/netgroup.h>
#include <lib/rcstring/accumulator.h>


space_netgroup::~space_netgroup()
{
}


space_netgroup::space_netgroup(const rcstring &a_filename) :
    space(a_filename)
{
    discard_comments();
    discard_blank_lines();
    discard_backslash_newline();
}


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


rcstring
space_netgroup::is_ok_netgroup_name(const rcstring &s)
{
    //
    // Characters you can't have in a netgroup name
    //  - You cant have comma "," or "(" parens ")" because they
    //    are separators in the netgroups file.
    //  - You can't have space or tab, because they are used as
    //    field separators in many files.
    //  - You can't have '#' because that looks like a comment
    //    in may files.
    //  - The name must start with a letter, so that it looks
    //    like a word and not a number or a symbol (many parsers
    //    need this).  In general, the more like a C identifier it
    //    looks, the more programs will be able to cope with it.
    //
    // The rest of the characters rejected here are just to make
    // sure it looks reasonable (as well as making sure the characters
    // are printable).
    //
    if (s.empty())
        return rcstring("_");

    rcstring_accumulator acc;
    unsigned char c = s.c_str()[0];
    if (!isalpha(c))
        c = '_';
    acc.push_back(c);
    for (const char *cp = s.c_str() + 1; *cp; ++cp)
    {
        c = *cp;
        if (!isdigit(c) && !isalpha(c) && c != '-' && c != '_')
            c = '_';
        acc.push_back(c);
    }
    return acc.mkstr();
}


bool
space_netgroup::parse_group(const rcstring &s, entry_t &result,
    const source_location &glocn)
{
    const char *cp = s.c_str();
    if (*cp != '(')
        return false;
    ++cp;

    const char *host_begin = cp;
    while (*cp != ',')
    {
        if (!*cp)
            return false;
        ++cp;
    }
    const char *host_end = cp;
    ++cp;

    const char *user_begin = cp;
    while (*cp != ',')
    {
        if (!*cp)
            return false;
        ++cp;
    }
    const char *user_end = cp;
    ++cp;

    const char *domain_begin = cp;
    while (*cp != ')')
    {
        if (!*cp)
            return false;
        ++cp;
    }
    const char *domain_end = cp;
    ++cp;

    if (*cp)
        return false;

    rcstring ss = rcstring(user_begin, user_end - user_begin);
    if (ss == rcstring("-") || ss.empty())
        result.user = ss;
    else
    {
        result.user = colon_passwd::is_ok_user_name(ss);
        if (result.user != ss)
        {
            error
            (
                glocn,
                "user name %s is not valid, suggest %s instead",
                ss.quote_c().c_str(),
                result.user.quote_c().c_str()
            );
        }
    }

    ss = rcstring(host_begin, host_end - host_begin);
    if (ss == "-" || ss.empty())
        result.host = ss;
    else
    {
        rcstring other;
        if (!space_hosts::valid_host_name(ss, other))
        {
            error
            (
                glocn,
                "host name %s is not valid, suggest %s instead",
                ss.quote_c().c_str(),
                other.quote_c().c_str()
            );
            ss = other;
        }
        result.host = ss;
    }

    ss = rcstring(domain_begin, domain_end - domain_begin);
    if (ss == "-" || ss.empty())
        result.domain = ss;
    else
        error(glocn, "don't use the domain field, it is meaningless");

    return true;
}


space_netgroup::record::pointer
space_netgroup::get(void)
{
    source_location line_locn;
    line_t line;
    if (!read_one_line(line_locn, line))
        return record::pointer();

    rcstring name = is_ok_netgroup_name(line[0]);
    if (name != line[0])
    {
        error
        (
            line_locn,
            "the string %s is not a valid netgroup name, suggest %s instead",
            line[1].quote_c().c_str(),
            name.quote_c().c_str()
        );
    }

    record::members_t members;
    for (line_t::iterator it = line.begin() + 1; it != line.end(); ++it)
    {
        entry_t entry;
        if (!parse_group(*it, entry, line_locn))
        {
            entry.reference_to_netgroup = is_ok_netgroup_name(*it);
            if (entry.reference_to_netgroup != *it)
            {
                error
                (
                    line_locn,
                    "the string %s is not a valid netgroup name, "
                        "suggest %s instead",
                    it->quote_c().c_str(),
                    entry.reference_to_netgroup.quote_c().c_str()
                );
            }
        }
        members.push_back(entry);
    }
    return record::create(line_locn, name, members);
}


bool
space_netgroup::entry_t::user_any(void)
    const
{
    return (user.empty());
}


bool
space_netgroup::entry_t::user_ignore(void)
    const
{
    return (user == "-");
}


bool
space_netgroup::entry_t::user_indexing(void)
    const
{
    if (!reference_to_netgroup.empty())
        return false;
    return !user_ignore();
}


bool
space_netgroup::entry_t::host_any(void)
    const
{
    return (host.empty());
}


bool
space_netgroup::entry_t::host_ignore(void)
    const
{
    return (host == "-");
}


bool
space_netgroup::entry_t::host_indexing(void)
    const
{
    if (!reference_to_netgroup.empty())
        return false;
    return !host_ignore();
}


rcstring
space_netgroup::entry_t::representation(void)
const
{
    if (!reference_to_netgroup.empty())
        return reference_to_netgroup;
    rcstring_accumulator acc;
    acc.push_back('(');
    acc.push_back(host);
    acc.push_back(',');
    acc.push_back(user);
    acc.push_back(',');
    acc.push_back(domain);
    acc.push_back(')');
    return acc.mkstr();
}


space_netgroup::record::~record()
{
}


space_netgroup::record::record(
    const source_location &a_locn,
    const rcstring &a_name,
    const members_t &a_members
) :
    locn(a_locn),
    name(a_name),
    members(a_members)
{
}


space_netgroup::record::pointer
space_netgroup::record::create(const source_location &a_locn,
    const rcstring &a_name, const members_t &a_members)
{
    return pointer(new record(a_locn, a_name, a_members));
}


rcstring
space_netgroup::record::representation(void)
    const
{
    // Note: the name is NOT part of the representation.
    rcstring_accumulator acc;
    for
    (
        members_t::const_iterator it = members.begin();
        it != members.end();
        ++it
    )
    {
        if (!acc.empty())
            acc.push_back(' ');
        acc.push_back(it->representation());
    }
    return acc.mkstr();
}


bool
space_netgroup::entry_t::operator==(const entry_t &arg)
    const
{
    return
        (
            reference_to_netgroup == arg.reference_to_netgroup
        &&
            host == arg.host
        &&
            user == arg.user
        &&
            domain == arg.domain
        );
}


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