lib/space/netgroup/slurp.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/ac/assert.h>
#include <algorithm>
#include <lib/space/netgroup/slurp.h>
#include <lib/colon/passwd/slurp.h>


space_netgroup_slurp::~space_netgroup_slurp()
{
}


space_netgroup_slurp::space_netgroup_slurp(
    const rcstring &a_filename,
    const space_hosts_slurp::pointer &a_hosts,
    const colon_passwd_slurp::pointer &a_passwd
) :
    space_netgroup(a_filename),
    hosts(a_hosts),
    passwd(a_passwd)
{
}


space_netgroup_slurp::pointer
space_netgroup_slurp::create(const rcstring &a_filename,
    const space_hosts_slurp::pointer &a_hosts,
    const colon_passwd_slurp::pointer &a_passwd)
{
    return pointer(new space_netgroup_slurp(a_filename, a_hosts, a_passwd));
}


space_netgroup_slurp::pointer
space_netgroup_slurp::create(const rcstring &a_filename)
{
    space_hosts_slurp::pointer a_hosts;
    colon_passwd_slurp::pointer a_passwd;
    return create(a_filename, a_hosts, a_passwd);
}


void
space_netgroup_slurp::process(const record::pointer &rp)
{
    //
    // Stash the record.
    //
    by_name_t::iterator it1 = by_name.find(rp->get_name());
    if (it1 != by_name.end())
    {
        error
        (
            rp->get_source_location(),
            "duplicate %s netgroup...",
        rp->get_name().quote_c().c_str()
        );
        error
        (
            it1->second->get_source_location(),
            "...here is the first definition of the %s netgroup",
            it1->second->get_name().quote_c().c_str()
        );
    }
    else
    {
        by_name.insert(by_name_t::value_type(rp->get_name(), rp));
    }

    //
    // Check the members.
    //
    const record::members_t &members = rp->get_members();
    for
    (
        record::members_t::const_iterator it = members.begin();
        it != members.end();
        ++it
    )
    {
        //
        // Can't check references until all the groups have been
        // read in.
        //
        if (!it->reference_to_netgroup.empty())
            continue;

        //
        // Check the user name.
        //
        if
        (
            passwd
        &&
            !it->user_any()
        &&
            !it->user_ignore()
        &&
            !passwd->query_by_name(it->user)
        )
        {
            error
            (
                rp->get_source_location(),
                "user %s unknown",
                it->user.quote_c().c_str()
            );
        }

        //
        // Check the host name.
        //
        if
        (
            hosts
        &&
            !it->host_any()
        &&
            !it->host_ignore()
        &&
            !hosts->query_by_name(it->host)
        )
        {
            error
            (
                rp->get_source_location(),
                "host %s unknown",
                it->host.quote_c().c_str()
            );
        }
    }

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


static bool
append_unique(space_netgroup::record::members_t &elp,
    const space_netgroup::entry_t &e)
{
    for
    (
        space_netgroup::record::members_t::const_iterator it = elp.begin();
        it != elp.end();
        ++it
    )
    {
        if (*it == e)
        {
            return false;
        }
    }
    elp.push_back(e);
    return true;
}


static bool
append_unique(space_netgroup::record::members_t &elp,
    const space_netgroup::record::members_t &elp2)
{
    bool result = false;
    for
    (
        space_netgroup::record::members_t::const_iterator it2 = elp2.begin();
        it2 != elp2.end();
        ++it2
    )
    {
        if (append_unique(elp, *it2))
            result = true;
    }
    return result;
}


void
space_netgroup_slurp::read_and_process(void)
{
    //
    // Read the file contents.
    //
    for (;;)
    {
        record::pointer rp = get();
        if (!rp)
        {
            break;
        }
        process(rp);
    }

    //
    // Check that cross references are OK.
    // (Sorting the keys gives more consistent output, which reduces
    // the false negatives when testing.  Also, std::map does it for free.)
    //
    name_list_t keys = keys_by_name();
    // std::sort(keys.begin(), keys.end());
    for (name_list_t::iterator it = keys.begin(); it != keys.end(); ++it)
    {
        rcstring key = *it;
        record::pointer rp = query_by_name(key);
        assert(rp);
        if (!rp)
            continue;
        const record::members_t &members = rp->get_members();
        for
        (
            record::members_t::const_iterator mit = members.begin();
            mit != members.end();
            ++mit
        )
        {
            //
            // Ignore group members which are not references to other groups.
            //
            rcstring name2 = mit->reference_to_netgroup;
            if (name2.empty())
                continue;

            //
            // Make sure referenced groups exist.
            //
            record::pointer rp2 = query_by_name(name2);
            if (!rp2)
            {
                error
                (
                    rp->get_source_location(),
                    "netgroup %s references netgroup %s that does not exist",
                    rp->get_name().quote_c().c_str(),
                    name2.quote_c().c_str()
                );
            }
        }
    }

    //
    // Compute the closure of by_name.
    // (Sorting the keys gives more consistent output, which reduces the false
    // negatives when testing.  By using std::map, we get that sort for free.)
    //
    // FIXME: Unfortunately, this has O(n**3) behaviour.  Sites with
    // many large netgroups may need for this to use the algorithm in
    // Knuth to speed things up.
    //
    typedef std::map<rcstring, record::members_t> closure_t;
    closure_t closure;
    for
    (
        by_name_t::const_iterator bnit = by_name.begin();
        bnit != by_name.end();
        ++bnit
    )
    {
        closure.insert
        (
            closure_t::value_type(bnit->first, bnit->second->get_members())
        );
    }
    for (;;)
    {
        //
        // We keep iterating until there are no more changes.
        //
        bool changed = false;

        //
        // For each netgroup, make sure we have everything covered.
        //
        for
        (
            name_list_t::const_iterator kit1 = keys.begin();
            kit1 != keys.end();
            ++kit1
        )
        {
            //
            // Look at each netgroup entry, and if it references another
            // netgroup, add all its entries to this one.
            //
            rcstring key1 = *kit1;
            closure_t::iterator elp1 = closure.find(key1);
            if (elp1 == closure.end())
                continue;
            const record::members_t &members = elp1->second;
            record::members_t new_members = members;
            for
            (
                record::members_t::const_iterator eit = members.begin();
                eit != members.end();
                ++eit
            )
            {
                rcstring key2 = eit->reference_to_netgroup;
                if (key2.empty())
                    continue;

                // short circuit reference to self
                if (key2 == key1)
                    continue;
                closure_t::const_iterator elp2 = closure.find(key2);

                //
                // Ignore netgroups that don't exist.
                //
                if (elp2 == closure.end())
                    continue;

                //
                // If there is stuff in *elp2 that isn't in *elp1,
                // then something changed, and we need to iterate.
                //
                if (append_unique(new_members, elp2->second))
                {
                    changed = true;
                }
            }
            elp1->second = new_members;
        }

        //
        // If this iteration found nothing different, we are done.
        //
        if (!changed)
            break;
    }

    //
    // Iterate over the closure, checking for self references, and also
    // filling in the by_user and by_host instance variables.
    //
    for
    (
        closure_t::const_iterator cit = closure.begin();
        cit != closure.end();
        ++cit
    )
    {
        for
        (
            record::members_t::const_iterator mit = cit->second.begin();
            mit != cit->second.end();
            ++mit
        )
        {
            //
            // Check for self recursion.  We do this once, rather than
            // risk the same error being issued multiple times by the
            // loop that computes the closure of by_name.
            //
            if (cit->first == mit->reference_to_netgroup)
            {
                record::pointer rp = query_by_name(cit->first);
                assert(rp);
                if (rp)
                {
                    error
                    (
                        rp->get_source_location(),
                        "netgroup %s contains a recursive reference to itself",
                        rp->get_name().quote_c().c_str()
                    );
                    break;
                }
            }

            //
            // Ignore cross references, we have resolved them all, now.
            //
            if (!mit->reference_to_netgroup.empty())
                continue;

            //
            // Stash the by_host information.
            //
            if (mit->host_indexing())
            {
                rcstring hostname(mit->host_any() ? "*" : mit->host);
                by_host_t::iterator nlp = by_host.find(hostname);
                if (nlp == by_host.end())
                {
                    name_list_t names;
                    names.push_back(cit->first);
                    by_host.insert(by_host_t::value_type(hostname, names));
                }
                else
                    nlp->second.push_back(cit->first);
            }

            //
            // Stash the by_user information.
            //
            if (mit->user_indexing())
            {
                rcstring username(mit->user_any() ? "*" : mit->user);
                by_user_t::iterator nlp = by_user.find(username);
                if (nlp == by_user.end())
                {
                    name_list_t names;
                    names.push_back(cit->first);
                    by_user.insert(by_user_t::value_type(username, names));
                }
                else
                    nlp->second.push_back(cit->first);
            }
        }
    }

    //
    // Close the file.
    //
    close();
}


space_netgroup_slurp::name_list_t
space_netgroup_slurp::keys_by_name(void)
    const
{
    name_list_t result;
    for
    (
        by_name_t::const_iterator it = by_name.begin();
        it != by_name.end();
        ++it
    )
        result.push_back(it->first);
    return result;
}


space_netgroup::record::pointer
space_netgroup_slurp::query_by_name(const rcstring &key)
    const
{
    by_name_t::const_iterator it = by_name.find(key);
    if (it == by_name.end())
        return record::pointer();
    return it->second;
}


space_netgroup_slurp::name_list_t
space_netgroup_slurp::keys_by_host(void)
    const
{
    name_list_t result;
    for
    (
        by_host_t::const_iterator it = by_host.begin();
        it != by_host.end();
        ++it
    )
        result.push_back(it->first);
    return result;
}


space_netgroup_slurp::name_list_t
space_netgroup_slurp::query_by_host(const rcstring &key)
    const
{
    by_host_t::const_iterator it = by_host.find(key);
    if (it == by_host.end())
        return name_list_t();
    return it->second;
}


space_netgroup_slurp::name_list_t
space_netgroup_slurp::keys_by_user(void)
    const
{
    name_list_t result;
    for
    (
        by_user_t::const_iterator it = by_user.begin();
        it != by_user.end();
        ++it
    )
        result.push_back(it->first);
    return result;
}


space_netgroup_slurp::name_list_t
space_netgroup_slurp::query_by_user(const rcstring &key)
    const
{
    by_user_t::const_iterator it = by_user.find(key);
    if (it == by_user.end())
        return name_list_t();
    return it->second;
}


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