lib/space/netid.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/string.h>

#include <lib/rcstring/accumulator.h>
#include <lib/space/netid.h>


space_netid::~space_netid()
{
}


space_netid::space_netid(const rcstring &a_filename) :
    space(a_filename),
    last_uid(-1)
{
    // discard_comments(); can't, because of netid of the form "a.b#c"
    discard_blank_lines();
}


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


space_netid::record::pointer
space_netid::get(void)
{
    for (;;)
    {
        source_location line_locn;
        line_t line;
        if (!read_one_line(line_locn, line))
        {
            last_uid = -1;
            return record::pointer();
        }

        //
        // Check that the record is in one of two valid formats.
        //
        //   unix.<uid>@<domain> <uid>:<gid>,<gid>...
        //   unix.<host>#<domain> 0:<host>
        //              ^
        //              `-- conflicts with comments?!?
        //
        // In the first format, it isn't essential for the two <uid>
        // fields to be the same.  This is becase in the case where we
        // are mapping a foreign ID into a local user, they probably
        // won't match.
        //
        // In the second format, it's hard to figure out what mapping a
        // foreign host's permissions to a local host's permissions means.
        // It certainly doesn't sound especially desirable.
        //
        if (line.size() < 2)
        {
            error
            (
                line_locn,
                "too few fields (expeced 2, given %d)",
                (int)line.size()
            );
            continue;
        }
        if (line.size() > 2)
        {
            error
            (
                line_locn,
                "too many fields (expected 2, given %ld)",
                (long)line.size()
            );
        }

        //
        // Pull apart the first word.
        //
        // unix.{rec_id}@{rec_domain}
        //
        rcstring rec_uid1;
        rcstring rec_domain;
        bool host_rec = false;
        {
            rcstring first = line[0];
            if (!first.starts_with("unix."))
            {
                error
                (
                    line_locn,
                    "netid name %s not valid, must start with \"unix.\"",
                    line[0].quote_c().c_str()
                );
                continue;
            }
            first = first.substr(5, first.size() - 5);

            const char *at = strchr(first.c_str(), '@');
            if (at)
            {
                rcstring first1(first.c_str(), at - first.c_str());
                ++at;
                rcstring first2(at);
                long first1_bin = -1;
                if (!first1.to_long(first1_bin) || first1_bin < 0)
                {
                    error
                    (
                        line_locn,
                        "netid name %s not valid, uid %s not valid",
                        line[0].quote_c().c_str(),
                        first1.quote_c().c_str()
                    );
                    continue;
                }
                // normalise
                first1 = rcstring::format("%ld", first1_bin);

                if (first1_bin < last_uid)
                {
                    error(line_locn, "user id %ld out of order", first1_bin);
                    explain_sequence_errors();
                }
                last_uid = first1_bin;

                rec_uid1 = first1;
                rec_domain = first2;
            }
            else
            {
                const char *hash = strchr(first.c_str(), '#');
                if (!hash)
                {
                    error
                    (
                        line_locn,
                        "netid name %s not valid",
                        line[0].quote_c().c_str()
                    );
                    continue;
                }
                host_rec = true;
                rcstring first1(first.c_str(), hash - first.c_str());
                ++hash;
                rcstring first2(hash);

                long first1_bin = -1;
                if (first1.to_long(first1_bin))
                {
                    error
                    (
                        line_locn,
                        "netid name %s not valid, host name %s not valid",
                        line[0].quote_c().c_str(),
                        first1.quote_c().c_str()
                    );
                }
                rec_uid1 = first1;
                rec_domain = first2;
            }
        }

        //
        // Pull apart the second word.
        //
        // {uid}:{gid},{gid}...
        // 0:{host},{host},...
        //
        rcstring rec_uid2;
        record::gids_t rec_gids;
        {
            rcstring second = line[1];
            const char *colon = strchr(second.c_str(), ':');
            if (!colon)
            {
                error
                (
                    line_locn,
                    "netid value %s not valid, no '@' or '#' separator",
                    line[1].quote_c().c_str()
                );
                continue;
            }
            rcstring second1(second.c_str(), colon - second.c_str());
            long second1_bin = -1;
            if (!second1.to_long(second1_bin) || second1_bin < 0)
            {
                error
                (
                    line_locn,
                    "netid value %s not valid, "
                        "user id %s not a positive number",
                    line[1].quote_c().c_str(),
                    second1.quote_c().c_str()
                );
                continue;
            }
            if (host_rec && second1_bin != 0)
            {
                error
                (
                    line_locn,
                    "netid value %s not valid, user id must be \"0\", not %s",
                    second.quote_c().c_str(),
                    second1.quote_c().c_str()
                );
            }
            second1 = rcstring::format("%ld", second1_bin); // normalise
            ++colon;
            rcstring second2(colon, second.c_str() + second.size() - colon);

            rec_uid2 = second1;
            rec_gids = second2.break_up(",", false);
            bool gids_ok = true;
            for
            (
                record::gids_t::iterator git = rec_gids.begin();
                git != rec_gids.end();
                ++git
            )
            {
                long value = -1;
                if (!git->to_long(value) || value < 0)
                {
                    if (!host_rec)
                    {
                        error
                        (
                            line_locn,
                            "netid value %s not valid, "
                                "group id %s not a positive number",
                            second.quote_c().c_str(),
                            git->quote_c().c_str()
                        );
                        gids_ok = false;
                    }
                }
                else
                {
                    if (host_rec)
                    {
                        error
                        (
                            line_locn,
                            "netid value %s not valid, host name %s not valid",
                            second.quote_c().c_str(),
                            git->quote_c().c_str()
                        );
                        gids_ok = false;
                    }
                    else
                    {
                        // normalise
                        *git = rcstring::format("%ld", value);
                    }
                }
            }
            if (!gids_ok)
                continue;
        }

        //
        // Got a record.
        //
        record::pointer rp =
            space_netid::record::create
            (
                line_locn,
                rec_uid1,
                rec_domain,
                rec_uid2,
                rec_gids
            );

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

        //
        // report success
        //
        return rp;
    }
}


space_netid::record::~record()
{
}


space_netid::record::record(
    const source_location &a_locn,
    const rcstring &a_uid1,
    const rcstring &a_domain,
    const rcstring &a_uid2,
    const gids_t &a_gids
) :
    locn(a_locn),
    uid1(a_uid1),
    domain(a_domain),
    uid2(a_uid2),
    gids(a_gids)
{
}


space_netid::record::pointer
space_netid::record::create(const source_location &a_locn,
    const rcstring &a_uid1, const rcstring &a_domain, const rcstring &a_uid2,
    const gids_t &a_gids)
{
    return pointer(new record(a_locn, a_uid1, a_domain, a_uid2, a_gids));
}


rcstring
space_netid::record::name(void)
    const
{
    long dummy;
    if (uid2 == "0" && !uid1.to_long(dummy))
        return ("unix." + uid1 + "#" + domain);
    return ("unix." + uid1 + "@" + domain);
}


rcstring
space_netid::record::representation(void)
    const
{
    rcstring_accumulator acc;
    acc.push_back("unix.");
    acc.push_back(uid1);
    acc.push_back(is_host_kind() ? '#' : '@');
    acc.push_back(domain);
    acc.push_back(' ');
    acc.push_back(uid2);
    acc.push_back(':');
    for (gids_t::const_iterator it = gids.begin(); it != gids.end(); ++it)
    {
        if (it != gids.begin())
            acc.push_back(',');
        acc.push_back(*it);
    }
    return acc.mkstr();
}


bool
space_netid::record::is_host_kind(void)
    const
{
    long dummy;
    return !uid1.to_long(dummy);
}


void
space_netid::record::append(const rcstring &arg)
{
    for (gids_t::const_iterator it = gids.begin(); it != gids.end(); ++it)
    {
        if (*it == arg)
            return;
    }
    gids.push_back(arg);
}


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