nis-util-netid/map.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 <algorithm>
#include <map>

#include <lib/colon/group.h>
#include <lib/colon/passwd.h>
#include <lib/output/file.h>
#include <lib/space/hosts.h>
#include <lib/space/netid.h>

#include <nis-util-netid/map.h>


void
map(const rcstring &etc_netid, const rcstring &etc_passwd,
    const rcstring &etc_group, const rcstring &etc_hosts,
    const rcstring &domain, const rcstring &ofn)
{
    typedef std::map<rcstring, space_netid::record::pointer> result_t;
    result_t result;

    typedef std::map<rcstring, space_netid::record::pointer> user_t;
    user_t user;

    //
    // Read the netid file.
    //
    space_netid::pointer netid = space_netid::create(etc_netid);
    for (;;)
    {
        space_netid::record::pointer rp = netid->get();
        if (!rp)
            break;
        result[rp->name()] = rp;
    }

    //
    // Read the passwd file.
    //
    colon_passwd::pointer passwd = colon_passwd::create(etc_passwd);
    for (;;)
    {
        colon_passwd::record::pointer rp = passwd->get();
        if (!rp)
            break;

        space_netid::record::gids_t gids;
        gids.push_back(rp->get_gid());
        space_netid::record::pointer tmp =
            space_netid::record::create
            (
                rp->get_source_location(),
                rp->get_uid(),
                domain,
                rp->get_uid(),
                gids
            );
        result_t::iterator rit = result.find(tmp->name());
        if (rit == result.end())
        {
            result.insert(result_t::value_type(tmp->name(), tmp));
            user.insert(user_t::value_type(rp->get_name(), tmp));
        }
        else
        {
            user.insert(user_t::value_type(rp->get_name(), rit->second));
        }
    }

    //
    // Read the group file.
    //
    colon_group::pointer group = colon_group::create(etc_group);
    for (;;)
    {
        colon_group::record::pointer rp = group->get();
        if (!rp)
            break;
        const colon_group::record::members_t &members = rp->get_members();
        for
        (
            colon_group::record::members_t::const_iterator it = members.begin();
            it != members.end();
            ++it
        )
        {
            user_t::iterator uit = user.find(*it);
            if (uit != user.end())
                uit->second->append(rp->get_gid());
        }
    }

    //
    // Read the hosts file.
    //
    space_hosts::pointer hosts = space_hosts::create(etc_hosts);
    for (;;)
    {
        space_hosts::record::pointer rp = hosts->get();
        if (!rp)
            break;

        const space_hosts::record::names_t &names = rp->get_names();
        for
        (
            space_hosts::record::names_t::const_iterator nit = names.begin();
            nit != names.end();
            ++nit
        )
        {
            // glue the domain onto all of the host records
            space_netid::record::gids_t gids;
            gids.push_back(*nit);
            space_netid::record::pointer tmp =
                space_netid::record::create
                (
                    rp->get_source_location(),
                    *nit,
                    domain,
                    "0",
                    gids
                );
            rcstring name = tmp->name();
            result_t::iterator rit = result.find(name);
            if (rit == result.end())
            {
                result.insert(result_t::value_type(name, tmp));
            }
            else
            {
                // This means there was a duplicate host name
                // in the hosts file.  Oops.
                rit->second->append(*nit);
            }
        }
    }

    //
    // Open the output file.
    //
    output::pointer ofp = output_file::create(ofn);

    //
    // Write out all the results.
    // (The sort is for predictable test results.)
    // (The std::map implementation gives us a sorted iteration order.)
    //
    for
    (
        result_t::const_iterator it = result.begin();
        it != result.end();
        ++it
    )
    {
        // FIXME: check for record length?
        ofp->put(it->second->representation());
        ofp->put('\n');
    }
}


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