lib/space/auto_master/functor/check.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 <lib/sizeof.h>
#include <lib/space/auto_master/functor/check.h>
#include <lib/space/auto_master/row/adapter.h>
#include <lib/space/auto_master/row/direct.h>
#include <lib/space/auto_master/row/hosts.h>


space_auto_master_functor_check::~space_auto_master_functor_check()
{
}


space_auto_master_functor_check::space_auto_master_functor_check(
    const space_auto_master::pointer &a_context,
    const space_hosts_slurp::pointer &a_hosts
) :
    context(a_context),
    hosts(a_hosts)
{
    assert(context);
}


static bool
dumb(const rcstring &dir)
{
    static const char *const table[] =
    {
        "/",
        "/dev",
        "/etc",
        "/media",
        "/opt",
        "/proc",
        "/sys",
        "/tmp"
        "/usr",
        "/var",
    };

    for (const char *const *cpp = table; cpp < ENDOF(table); ++cpp)
    {
        if (dir == *cpp)
            return true;
    }
    return false;
}


void
space_auto_master_functor_check::check_for_dumb_place(
    const space_auto_master_row::pointer &rp)
{
    const mount_point &mp = rp->get_mount_point();
    rcstring dir = mp.get_mount_point();
    if (dumb(dir))
    {
        context->error
        (
            mp.get_source_location(),
            "directory %s is not a suitable mount point",
            dir.quote_c().c_str()
        );
    }
}


static bool
below_dir(const rcstring &s1, const rcstring &s2)
{
    return
        (
            s1.size() < s2.size()
        &&
            0 == memcmp(s1.c_str(), s2.c_str(), s1.size())
        &&
            s2[s1.size()] == '/'
        );
}


void
space_auto_master_functor_check::check_for_overlap(
    const space_auto_master_row::pointer &rp)
{
    rcstring dir = rp->get_mount_point().get_mount_point();
    for
    (
        overlap_t::const_iterator it = overlap.begin();
        it != overlap.end();
        ++it
    )
    {
        space_auto_master_row::pointer rp2 = *it;
        rcstring dir2 = rp2->get_mount_point().get_mount_point();

        if (dir == dir2)
        {
            context->error
            (
                rp->get_mount_point().get_source_location(),
                "duplicate %s mount point...",
                dir.quote_c().c_str()
            );
            context->error
            (
                rp2->get_mount_point().get_source_location(),
                "... here is the location of the first %s mount point",
                rp2->get_mount_point().get_mount_point().quote_c().c_str()
            );
            return;
        }

        if (below_dir(dir2, dir))
        {
            context->error
            (
                rp->get_mount_point().get_source_location(),
                "mount point %s is beneath...",
                dir.quote_c().c_str()
            );
            context->error
            (
                rp2->get_mount_point().get_source_location(),
                "...existing %s mount point",
                dir2.quote_c().c_str()
            );
            return;
        }
        if (below_dir(dir, dir2))
        {
            context->error
            (
                rp->get_mount_point().get_source_location(),
                "mount point %s is above...",
                dir.quote_c().c_str()
            );
            context->error
            (
                rp2->get_mount_point().get_source_location(),
                "...existing %s mount point",
                dir2.quote_c().c_str()
            );
            return;
        }
    }
    overlap.push_back(rp);
}


//
// Many applications (including Arc/Info) require that path names be
// entirely uppercase or entirely lower case.  They have a variety of
// heart-attacks if there is mixed case.  Because most of the existing
// pathnames are lower case, enforce the requirement that they all be
// lower case.
//

void
space_auto_master_functor_check::check_case(
    const space_auto_master_row::pointer &rp)
{
    rcstring dir = rp->get_mount_point().get_mount_point();
    if (!dir.is_lower_case())
    {
        rcstring suggest = dir.downcase();
        context->error
        (
            rp->get_mount_point().get_source_location(),
            "mount point %s must be lower case, suggest %s instead; "
            "some overly stupid applications make this unavoidable",
            dir.quote_c().c_str(),
            suggest.quote_c().c_str()
        );
    }
}


void
space_auto_master_functor_check::walk(const space_auto_master_row::pointer &rp)
{
    check_case(rp);
    check_for_dumb_place(rp);
    check_for_overlap(rp);

    if (rp->has_associated_file())
    {
        // load map and check it
        rp->load_map(find_file(rp->get_filename()), hosts);
    }

    // check that there is only ever one direct map
    {
        space_auto_master_row_direct::pointer rp2 =
            boost::dynamic_pointer_cast<space_auto_master_row_direct>(rp);
        if (rp2)
        {
            if (direct_rp)
            {
                context->error
                (
                    rp2->get_mount_point().get_source_location(),
                    "duplicate direct mount map specified..."
                );
                context->error
                (
                    direct_rp->get_mount_point().get_source_location(),
                    "...here is the first direct mount map"
                );
            }
            else
            {
                direct_rp = rp2;

                // Add each of the diretc mount points to the known
                // mount points, so that we can validate against
                // everything we know about.
                space_auto_master_row::keys_t keys = rp2->get_keys();
                for
                (
                    space_auto_master_row::keys_t::const_iterator it =
                        keys.begin();
                    it != keys.end();
                    ++it
                )
                {
                    const mount_point &key = *it;
                    space_auto_master_row::pointer rp3 =
                        space_auto_master_row_adapter::create(key);
                    check_case(rp3);
                    check_for_dumb_place(rp3);
                    check_for_overlap(rp3);
                }
            }
        }
    }

    // check that there is only ever one hosts map
    {
        space_auto_master_row_hosts::pointer rp2 =
            boost::dynamic_pointer_cast<space_auto_master_row_hosts>(rp);
        if (rp2)
        {
            if (hosts_rp)
            {
                context->error
                (
                    rp2->get_mount_point().get_source_location(),
                    "duplicate -hosts mount point specified..."
                );
                context->error
                (
                    hosts_rp->get_mount_point().get_source_location(),
                    "...here is the first -hosts mount point"
                );
            }
            else
            {
                hosts_rp = rp2;
            }
        }
    }
}


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