lib/colon/group.cc

Go to the documentation of this file.

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

#include <lib/colon/group.h>
#include <lib/colon/passwd.h> // for static is_ok_user_name
#include <lib/configuration.h>
#include <lib/rcstring/accumulator.h>


colon_group::~colon_group()
{
}


colon_group::colon_group(const rcstring &a_filename) :
    colon(a_filename),
    last_gid(-1)
{
    // This host's sysconf(LOGIN_NAME_MAX)-1 may be too generous for
    // all NIS clients.  Be conservative.
    cfg.set_builtin_long(SECTION_GROUP, ITEM_NAME_LENGTH_MAXIMUM, 8);
    // there is no sysconf for this one...
    cfg.set_builtin_long(SECTION_GROUP, "group-id-maximum", 65534);

    discard_comments();
    discard_blank_lines();
}


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


colon_group::record::pointer
colon_group::get(void)
{
    source_location line_locn;
    line_t line;
    while (read_one_line(line_locn, line))
    {
        //
        // Check the number of fields
        //
        if (line.size() < 4)
        {
            error
            (
                line_locn,
                "too few fields (expected 4, given %d)",
                (int)line.size()
            );
            continue;
        }
        if (line.size() > 4)
        {
            error
            (
                line_locn,
                "too many fields (expected 4, given %ld)",
                (long)line.size()
            );
        }

        //
        // Transfer the fields to the structure.
        //
        record::members_t members = line[3].break_up(",", 1);
        record::pointer rp =
            record::create(line_locn, line[0], line[1], line[2], members);

        //
        // If it looks halfway sensable, use it.
        //
        if (validate(rp))
            return rp;
    }
    last_gid = -1;
    return record::pointer();
}


colon_group::record::~record()
{
}


colon_group::record::record(
    const source_location &a_locn,
    const rcstring &a_name,
    const rcstring &a_password,
    const rcstring &a_gid,
    const members_t &a_members
) :
    locn(a_locn),
    name(a_name),
    password(a_password),
    gid(a_gid),
    members(a_members),
    members_only(false)
{
    //
    // If the first member is "MEMBERS-ONLY", the group may only be the
    // default group of the user of the same name or group members.
    //
    if (members.size() >= 1 && members[0] == "MEMBERS-ONLY")
    {
        members.erase(members.begin());
        members_only = true;
    }

    //
    // If the first member starts with "USE-", it means that this
    // group should not be used as a default group, the preferred
    // default group name follows the hyphen.
    //
    if
    (
        members.size() >= 1
    &&
        members[0].size() >= 5
    &&
        0 == memcmp(members[0].c_str(), "USE-", 4)
    )
    {
        use_instead = members[0].substr(4, 9999);
        members.erase(members.begin());
    }
}


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


bool
colon_group::validate(const record::pointer &rp)
{
    //
    // Check the group name
    //
    if (rp->get_name().empty())
    {
        error
        (
            rp->get_source_location(),
            "may not have empty group name"
        );
        return false;
    }
    unsigned group_name_maximum_length =
        cfg.get_long("group", ITEM_NAME_LENGTH_MAXIMUM);
    if (rp->get_name().size() > group_name_maximum_length)
    {
        rcstring suggest = rp->get_name();
        suggest = suggest.substr(0, group_name_maximum_length);
        error
        (
            rp->get_source_location(),
            "group name %s too long, by %ld, suggest %s instead",
            rp->get_name().quote_c().c_str(),
            (long)(rp->get_name().size() - group_name_maximum_length),
            suggest.quote_c().c_str()
        );
        return false;
    }
    {
        rcstring suggest = colon_passwd::is_ok_user_name(rp->get_name());
        if (suggest != rp->get_name())
        {
            error
            (
                rp->get_source_location(),
                "group name %s unacceptable, suggest %s instead",
                rp->get_name().quote_c().c_str(),
                suggest.quote_c().c_str()
            );
            return false;
        }
    }

    //
    // Check the password
    //
    if (rp->get_password() != "x" && rp->get_password() != "*")
    {
        error(rp->get_source_location(), "must have \"*\" for password");
    }

    //
    // Check the UID
    //
    {
        long gid = -1;
        if (!rp->get_gid().to_long(gid) || gid < 0)
        {
                rp->get_source_location(),
            error
            (
                rp->get_source_location(),
                "group %s: group id %s is not a positive number",
                rp->get_name().quote_c().c_str(),
                rp->get_gid().quote_c().c_str()
            );
            return false;
        }

        if (gid < last_gid)
        {
            pedantic_error
            (
                rp->get_source_location(),
                "group %s: group id %s is out of order",
                rp->get_name().quote_c().c_str(),
                rp->get_gid().quote_c().c_str()
            );
            explain_sequence_errors();
        }
        last_gid = gid;

#if 0
        if (gid >= 32768L)
        {
            error
            (
                rp->get_source_location(),
                "group %s: group id %s is too large (0..32767)",
                rp->get_name().quote_c()->c_str(),
                rp->get_gid().quote_c()->c_str()
            );
            return false;
        }
#endif

        rcstring s = rcstring::format("%ld", gid);
        if (s != rp->get_gid())
        {
            error
            (
                rp->get_source_location(),
                "group %s: group id %s not simplest decimal number, "
                    "use %s instead",
                rp->get_name().quote_c().c_str(),
                rp->get_gid().quote_c().c_str(),
                s.quote_c().c_str()
            );
            return false;
        }
    }

    //
    // Make sure the group members are in alphabetical order.
    // This catches duplicates and some typographical errors.
    //
    const record::members_t &members = rp->get_members();
    for
    (
        record::members_t::const_iterator it = members.begin();
        it != members.end();
        ++it
    )
    {
        if (it->empty())
        {
            error
            (
                rp->get_source_location(),
                "group %s: member list contains empty member",
                rp->get_name().quote_c().c_str()
            );
            return false;
        }
        if (it != members.begin())
        {
            if (it[-1] == it[0])
            {
                error
                (
                    rp->get_source_location(),
                    "group %s: duplicate %s group member",
                    rp->get_name().quote_c().c_str(),
                    it->c_str()
                );
                return false;
            }
            if (it[-1] > it[0])
            {
                error
                (
                    rp->get_source_location(),
                    "group %s: member list not in alphabetical order",
                    rp->get_name().quote_c().c_str()
                );
                explain_sequence_errors();
                return false;
            }
        }
    }

    //
    // The overall length must be 511 characters.  This is a
    // limitation of some implementations of the NIS transport
    // mechanism.
    //
    if (rp->representation().size() >= 512)
    {
        error
        (
            rp->get_source_location(),
            "line too long (NIS limits records to 511 bytes)"
        );
    }

    //
    // Looks good so far.
    //
    return true;
}


bool
colon_group::record::is_member(const rcstring &member_name)
    const
{
    return (find(members.begin(), members.end(), member_name) != members.end());
}


rcstring
colon_group::record::representation(void)
    const
{
    rcstring_accumulator acc;
    acc.push_back(name);
    acc.push_back(':');
    acc.push_back(password);
    acc.push_back(':');
    acc.push_back(gid);
    acc.push_back(':');
    for
    (
        std::vector<rcstring>::const_iterator it = members.begin();
        it != members.end();
        ++it
    )
    {
        if (it != members.begin())
            acc.push_back(',');
        acc.push_back(*it);
    }
    return acc.mkstr();
}


void
colon_group::record::append_member(const rcstring &user_name)
{
    // append unique names
    if (std::find(members.begin(), members.end(), user_name) != members.end())
        return;
    // try to preseve sort order
    for
    (
        members_t::iterator it = members.begin();
        it != members.end();
        ++it
    )
    {
        if (user_name < *it)
        {
            members.insert(it, user_name);
            return;
        }
    }
    // it belongs on the end
    members.push_back(user_name);
}


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