lib/space/automap/row.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 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 <map>
#include <lib/rcstring/accumulator.h>

#include <lib/space/automap/row.h>
#include <lib/sizeof.h>
#include <lib/space/automap.h>


space_automap_row::~space_automap_row()
{
}


space_automap_row::space_automap_row(
    const mount_point &a_key,
    const rcstring &a_options
) :
    key(a_key),
    options(a_options)
{
}


static bool
is_a_number(const rcstring &s)
{
    // no leading zeros
    if (s.size() > 1 && s.c_str()[0] == '0')
        return false;
    for (const char *cp = s.c_str(); *cp; ++cp)
        if (!isdigit((unsigned char)*cp))
            return false;
    return true;
}


void
space_automap_row::option_verify(const rcstring &name, const rcstring &value,
    space *ctx)
{
    enum
    {
        otab_type_none,
        otab_type_integer,
        otab_type_string,
        otab_type_filename
    };

    struct otab_t
    {
        const char *name;
        int type;
    };

    static const otab_t otab[] =
    {
        { "acdirmax", otab_type_integer },
        { "acdirmin", otab_type_integer },
        { "acregmax", otab_type_integer },
        { "acregmin", otab_type_integer },
        { "actimeo", otab_type_integer },
        { "backfstype", otab_type_string },
        { "backpath", otab_type_filename },
        { "bg", otab_type_none },
        { "cachedir", otab_type_filename },
        { "cacheid", otab_type_string },
        { "fg", otab_type_none },
        { "grpid", otab_type_none },
        { "hard", otab_type_none },
        { "intr", otab_type_none },
        { "local-access", otab_type_none },
        { "noac", otab_type_none },
        { "noconst", otab_type_none },
        { "nocto", otab_type_none },
        { "non-shared", otab_type_none },
        { "noquota", otab_type_none },
        { "norrip", otab_type_none },
        { "nosuid", otab_type_none },
        { "port", otab_type_integer },
        { "posix", otab_type_none },
        { "purge", otab_type_none },
        { "quota", otab_type_none },
        { "retrans", otab_type_integer },
        { "retry", otab_type_integer },
        { "ro", otab_type_none },
        { "rsize", otab_type_integer },
        { "rw", otab_type_none },
        { "secure", otab_type_none },
        { "soft", otab_type_none },
        { "suid", otab_type_none },
        { "timeo", otab_type_integer },
        { "write-around", otab_type_none },
        { "wsize", otab_type_integer },
    };

    // typedef std::map<rcstring, otab_type_t> stp_t;
    typedef std::map<rcstring, int> stp_t;
    static stp_t stp;

    if (stp.empty())
    {
        for (const otab_t *otp = otab; otp < ENDOF(otab); ++otp)
        {
            stp.insert(stp_t::value_type(otp->name, otp->type));
        }
    }
    stp_t::const_iterator it = stp.find(name);
    if (it == stp.end())
    {
        ctx->error
        (
            ctx->yak_location(),
            "option %s unknown",
            name.quote_c().c_str()
        );
        return;
    }

    if (it->second != otab_type_none && value.empty())
    {
        ctx->error
        (
            ctx->yak_location(),
            "option %s requires an argument",
            name.quote_c().c_str()
        );
        return;
    }

    switch (it->second)
    {
    default:
        assert(!"should never reach here");

    case otab_type_none:
        if (!value.empty())
        {
            ctx->error
            (
                ctx->yak_location(),
                "option %s should have no argument",
                name.quote_c().c_str()
            );
        }
        break;

    case otab_type_integer:
        if (!is_a_number(value))
        {
            ctx->error
            (
                ctx->yak_location(),
                "option %s requires an integer argument",
                name.quote_c().c_str()
            );
        }
        break;

    case otab_type_string:
        // existence already checked
        break;

    case otab_type_filename:
        if (value.c_str()[0] != '/')
        {
            ctx->error
            (
                ctx->yak_location(),
                "option %s requires an absolute path argument",
                name.quote_c().c_str()
            );
        }
        break;
    }
}


void
space_automap_row::options_verify(const rcstring &text, space *ctx)
{
    // get rid of leading hyphen
    const char *cp = text.c_str();
    if (*cp == '-')
        ++cp;

    // break into comma separated things
    typedef std::list<std::pair<rcstring, rcstring> > wl_t;
    wl_t wl;
    for (;;)
    {
        if (!*cp)
            break;
        if (*cp == ',')
        {
            ++cp;
            continue;
        }
        const char *comma = strchr(cp, ',');
        const char *next = cp + 1;
        if (comma)
        {
            next = comma + 1;
        }
        else
        {
            comma = cp + strlen(cp);
            next = comma;
        }
        const char *eq = (const char *)memchr(cp, '=', comma - cp);
        rcstring name;
        rcstring value;
        if (eq)
        {
            name = rcstring(cp, eq - cp);
            ++eq;
            value = rcstring(eq, comma - eq);
        }
        else
        {
            name = rcstring(cp, comma - cp);
        }

        // make sure we like each of the options
        option_verify(name, value, ctx);

        cp = next;
    }
}


void
space_automap_row::space_automap_insert_sub(space_automap *)
    const
{
}


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