lib/colon/passwd.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/ctype.h>
#include <lib/ac/string.h>

#include <lib/colon/passwd.h>
#include <lib/configuration.h>
#include <lib/path_join.h>
#include <lib/rcstring/accumulator.h>


colon_passwd::~colon_passwd()
{
}


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

    discard_comments();
    discard_blank_lines();
}


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


colon_passwd::record::pointer
colon_passwd::get(void)
{
    source_location line_locn;
    line_t line;
    while (read_one_line(line_locn, line))
    {
        //
        // Check the number of fields
        //
        if (line.size() < 7)
        {
            error
            (
                line_locn,
                "too few fields (expected 7, given %d)",
                (int)line.size()
            );
            continue;
        }
        if (line.size() > 7)
        {
            error
            (
                line_locn,
                "user %s has too many fields (expected 7, given %ld)",
                line[0].quote_c().c_str(),
                (long)line.size()
            );
        }

        //
        // Transfer the fields to the structure.
        //
        record::pointer rp =
            record::create
            (
                line_locn,
                line[0],
                line[1],
                line[2],
                line[3],
                line[4],
                line[5],
                line[6]
            );

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


bool
colon_passwd::validate(const record::pointer &rp)
{
    //
    // Check the login name
    //
    if (rp->get_name().empty())
    {
        error
        (
            rp->get_source_location(),
            "may not have empty login name"
        );
        return false;
    }

    unsigned login_name_maximum_length =
        cfg.get_long("passwd", ITEM_NAME_LENGTH_MAXIMUM);
    assert(login_name_maximum_length >= 8);
    if (rp->get_name().size() > login_name_maximum_length)
    {
        rcstring suggest =
            rp->get_name().substr(0, login_name_maximum_length);
        error
        (
            rp->get_source_location(),
            "login name %s too long, by %ld, suggest %s instead",
            rp->get_name().quote_c().c_str(),
            (long)(rp->get_name().size() - login_name_maximum_length),
            suggest.quote_c().c_str()
        );
        return false;
    }

    {
        rcstring suggest = is_ok_user_name(rp->get_name());
        if (suggest != rp->get_name())
        {
            error
            (
                rp->get_source_location(),
                "login name %s unacceptable, suggest %s instead",
                rp->get_name().quote_c().c_str(),
                suggest.quote_c().c_str()
            );
            return false;
        }
    }

    //
    // Check the password
    //

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

        if (uid < last_uid)
        {
            error
            (
                rp->get_source_location(),
                "user %s: user id %s is out of order",
                rp->get_name().quote_c().c_str(),
                rp->get_uid().quote_c().c_str()
            );
            explain_sequence_errors();
            //return false;
        }
        last_uid = uid;

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

        rcstring s = rcstring::format("%ld", uid);
        if (s != rp->get_uid())
        {
            error
            (
                rp->get_source_location(),
                "user %s: user id %s not in canonical form, use %s instead",
                rp->get_name().quote_c().c_str(),
                rp->get_uid().quote_c().c_str(),
                s.quote_c().c_str()
            );
            return false;
        }
    }

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

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

        // FIXME: check range?
    }

    //
    // Check full name field.
    //
    if (rp->get_gecos().empty())
    {
        error
        (
            rp->get_source_location(),
            "user %s has an empty Full Name field",
            rp->get_name().quote_c().c_str()
        );
        return false;
    }

    //
    // Check home directory
    //
    if (rp->get_home().empty())
    {
        error
        (
            rp->get_source_location(),
            "user %s has an empty home directory field",
            rp->get_name().quote_c().c_str()
        );
        return false;
    }

    if (rp->get_home().front() != '/')
    {
        rcstring suggest = "/" + rp->get_home();
        if (suggest.size() > 1 && suggest.back() == '/')
            suggest = suggest.substr(0, suggest.size() - 1);
        error
        (
            rp->get_source_location(),
            "user %s: home directory %s must be an absolute path, suggest %s",
            rp->get_name().quote_c().c_str(),
            rp->get_home().quote_c().c_str(),
            suggest.quote_c().c_str()
        );
        return false;
    }
    if (rp->get_home().size() > 1 && rp->get_home().back() == '/')
    {
        rcstring suggest = rp->get_home();
        suggest = suggest.substr(0, suggest.size() - 1);
        error
        (
            rp->get_source_location(),
            "user %s: home directory %s may not end with slash, "
                "suggest %s instead",
            rp->get_name().quote_c().c_str(),
            rp->get_home().quote_c().c_str(),
            suggest.quote_c().c_str()
        );
        return false;
    }
    if (rp->get_home().basename() != rp->get_name())
    {
        rcstring suggest = path_join(rp->get_home(), rp->get_name());
        error
        (
            rp->get_source_location(),
            "user %s: home directory %s does not end with %s, "
                "did you mean %s instead?",
            rp->get_name().quote_c().c_str(),
            rp->get_home().quote_c().c_str(),
            rp->get_name().quote_c().c_str(),
            suggest.quote_c().c_str()
        );
        return false;
    }

    //
    // Check shell.
    //
    // FIXME: validate against /etc/shells
    // also take suggestion from /etc/shells
    //
    if (rp->get_shell().empty())
    {
        rcstring suggest = "/bin/bash";
        error
        (
            rp->get_source_location(),
            "user %s has an empty shell field, suggest %s",
            rp->get_name().quote_c().c_str(),
            suggest.quote_c().c_str()
        );
        return false;
    }
    if (rp->get_home().front() != '/')
    {
        rcstring suggest = "/" + rp->get_home();
        error
        (
            rp->get_source_location(),
            "user %s: shell %s must be an absolute path, "
                "suggest %s",
            rp->get_name().quote_c().c_str(),
            rp->get_shell().quote_c().c_str(),
            suggest.quote_c().c_str()
        );
        return false;
    }
    if (rp->get_shell().back() == '/')
    {
        rcstring suggest = rp->get_shell();
        suggest = suggest.substr(0, suggest.size() - 1);
        error
        (
            rp->get_source_location(),
            "user %s: shell %s may not end with slash, suggest %s",
            rp->get_name().quote_c().c_str(),
            rp->get_shell().quote_c().c_str(),
            suggest.quote_c().c_str()
        );
        return false;
    }

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

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


rcstring
colon_passwd::is_ok_user_name(const rcstring &s)
{
    //
    // Characters you can't have in a login name
    //  - you can't have upper case, because then the serial
    //    login programs think you have an upper-case-only terminal.
    //  - You can't have colon (:) because that's the password
    //    file field separator.
    //  - You cant have comma (,) because that's the separator
    //    in the groups file and the mail aliases file.
    //  - You can't have space or tab, because they are used as
    //    field separators in many files.
    //  - You can't have dot (.) because that's what chown uses
    //    to separate the user name and the group name.
    //  - You can't have '#' becuase that looks like a comment
    //    in too many 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("_");

    //
    // Make sure we have buffer space.
    //
    rcstring_accumulator acc;

    unsigned char c = s.front();
    if (islower(c))
        ;
    else if (isupper(c))
        c = tolower(c);
    else
        c = 'a';
    acc.push_back(c);
    for (const char *cp = s.c_str() + 1; *cp; ++cp)
    {
        c = *cp;
        if (isupper(c))
            c = tolower(c);
        else if (isalnum(c))
            ;
        else if (c != '-' && c != '_')
            c = '_';
        acc.push_back(c);
    }
    return acc.mkstr();
}


colon_passwd::record::~record()
{
}


colon_passwd::record::record(
    const source_location &a_locn,
    const rcstring &a_name,
    const rcstring &a_password,
    const rcstring &a_uid,
    const rcstring &a_gid,
    const rcstring &a_gecos,
    const rcstring &a_home,
    const rcstring &a_shell
) :
    locn(a_locn),
    name(a_name),
    password(a_password),
    uid(a_uid),
    gid(a_gid),
    gecos(a_gecos),
    home(a_home),
    shell(a_shell)
{
    groups.push_back(gid);
}


colon_passwd::record::pointer
colon_passwd::record::create(const source_location &a_locn,
    const rcstring &a_name, const rcstring &a_password, const rcstring &a_uid,
    const rcstring &a_gid, const rcstring &a_gecos, const rcstring &a_home,
    const rcstring &a_shell)
{
    return
        pointer
        (
            new record
            (
                a_locn,
                a_name,
                a_password,
                a_uid,
                a_gid,
                a_gecos,
                a_home,
                a_shell
            )
        );
}


long
colon_passwd::record::get_uid_binary(void)
    const
{
    long value = -1;
    if (!uid.to_long(value))
        return -1;
    return value;
}


long
colon_passwd::record::get_gid_binary(void)
    const
{
    long value = -1;
    if (!gid.to_long(value))
        return -1;
    return value;
}


rcstring
colon_passwd::record::representation(void)
    const
{
    return
        rcstring::format
        (
            "%s:%s:%s:%s:%s:%s:%s",
            name.c_str(),
            password.c_str(),
            uid.c_str(),
            gid.c_str(),
            gecos.c_str(),
            home.c_str(),
            shell.c_str()
        );
}


void
colon_passwd::record::append_group(const rcstring &group_name)
{
    groups_t::iterator it = std::find(groups.begin(), groups.end(), group_name);
    if (it == groups.end())
        groups.push_back(group_name);
}


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