LinuxDumper.cpp

Go to the documentation of this file.

/* 
 * Confdump-Agent - Dump static and runtime system configuration
 * Copyright (C) 2009-2012  Straton IT, SAS
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 * 
 * 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/>.
 */

extern "C"
{
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
}

#include <cstdlib> // atol
#include <algorithm>
#include <map>

#include <iostream>
#include "QString"
#include "boost/iostreams/stream.hpp"
#include "boost/iostreams/device/file_descriptor.hpp"
#include "boost/system/system_error.hpp"
#include "boost/algorithm/string/predicate.hpp"
#include "boost/algorithm/string/classification.hpp"
#include "boost/filesystem/operations.hpp"
#include "boost/function.hpp"
#include "boost/bind.hpp"
#include "boost/foreach.hpp"
#include "boost/iostreams/copy.hpp"
#include "Confdump/System/LinuxDumper.hpp"
#include "Confdump/Result.hpp"
#include "Confdump/System/Linux/MoreElements.hpp"
#include "Confdump/System/Linux/Process.hpp"
#include "Confdump/System/Linux/EnvironmentVariable.hpp"
#include "Confdump/System/Linux/OperatingSystem.hpp"
#include "Confdump/System/Linux/Socket.hpp"
#include "Confdump/System/Linux/NetworkInterface.hpp"
#include "Confdump/System/Linux/ConfigurationFile.hpp"
#include "Confdump/System/Linux/MountEntry.hpp"
#include "Confdump/System/Linux/InittabEntry.hpp"
#include "Confdump/System/Linux/Uptime.hpp"
#include "Confdump/System/Linux/InitScript.hpp"
#include "Confdump/System/Linux/RcdScript.hpp"

#include <QFile>

using boost::shared_ptr;
using std::streambuf;
using std::copy;
using std::back_inserter;
using namespace Confdump::System::Linux;
namespace fs = boost::filesystem;

namespace Confdump
{

namespace System
{


struct LinuxDumper::Impl
{
    shared_ptr<SystemContext> systemContext;
    //a tablehandler contain the table's name in a string and a pointer to the function to get data.
    typedef std::map< QString, boost::function< Result( shared_ptr<LinuxDumper> ) > > TableHandlers;
    TableHandlers tableHandler;
};

LinuxDumper::LinuxDumper()
 : impl_( new Impl )
{
    using boost::bind;
    impl_->tableHandler["CD_Process"]             = bind( &LinuxDumper::allProcesses, _1 );
    impl_->tableHandler["CD_EnvironmentVariable"] = bind( &LinuxDumper::allEnvironmentVariables, _1 );
    impl_->tableHandler["CD_CurrentKernel"]       = bind( &LinuxDumper::operatingSystem, _1 );
    impl_->tableHandler["CD_Socket"]              = bind( &LinuxDumper::allSockets, _1 );
    impl_->tableHandler["CD_NetworkInterface"]    = bind( &LinuxDumper::allNetworkInterfaces, _1 );
    impl_->tableHandler["CD_ConfigurationFile"]   = bind( &LinuxDumper::allConfigurationFiles, _1 );
    impl_->tableHandler["CD_FstabMountEntry"]     = bind( &LinuxDumper::allMountEntries, _1, "/etc/fstab" );
    impl_->tableHandler["CD_KernelMountEntry"]    = bind( &LinuxDumper::allMountEntries, _1, "/proc/mounts" );
    impl_->tableHandler["CD_InittabEntry"]        = bind( &LinuxDumper::allInittabEntries, _1 );
    impl_->tableHandler["CD_Uptime"]              = bind( &Linux::Uptime::uptime, _1 );
    impl_->tableHandler["CD_InitScript"]          = bind( &Linux::InitScript::allInitScripts, _1 );
    impl_->tableHandler["CD_RcdScript"]           = bind( &Linux::RcdScript::allRcdScripts, _1 );
    impl_->tableHandler["CD_BlockDevice"]         = bind( &Linux::allBlockDevices, _1 );
}

LinuxDumper::~LinuxDumper()
{
}

QString LinuxDumper::doComputerIdentifier()
{
    return Linux::NetworkInterface( "eth0" ).macAddress();
}

LinuxDumper::SystemContext& LinuxDumper::systemContext()
{
    if ( !impl_->systemContext )
        impl_->systemContext.reset( new SystemContext( shared_from_this() ) );

    return *impl_->systemContext;
}

LinuxDumper::SystemContext::SystemContext( boost::shared_ptr<LinuxDumper> driver) 
 : driver_( driver )
{
}

LinuxDumper::SystemContext::~SystemContext()
{
}

shared_ptr<std::streambuf> LinuxDumper::SystemContext::openRoFile( const boost::filesystem::path &path ) const
{
    int fd = ::open( path.string().c_str(), O_RDONLY );
    if (fd == -1)
    {
        using namespace boost::system;
        throw system_error( errno, system_category, "open " + path.string() );
    }
    else
    {
        using namespace boost::iostreams;
        return shared_ptr<std::streambuf>( new stream_buffer<file_descriptor_source>( fd, true ) );
    }
}


QByteArray LinuxDumper::SystemContext::slurpConfigurationFile( const boost::filesystem::path &path, QString refersToTable )
{
    shared_ptr<Linux::ConfigurationFile> configFile( new Linux::ConfigurationFile( driver_, path, refersToTable ) );
    configurationFiles_.push_back( configFile );
    return configFile->fileContents();
}

QByteArray LinuxDumper::SystemContext::slurpConfigurationFile( QString path, QString refersToTable )
{
    QByteArray path_bytes = path.toLocal8Bit();
    return slurpConfigurationFile( fs::path( path_bytes ), refersToTable );
}

Result LinuxDumper::SystemContext::allConfigurationFiles() const
{
    return configurationFiles_;
}


Result LinuxDumper::allProcesses()
{
    using namespace boost::algorithm;
    using namespace boost::filesystem;

    Result result;

    for ( directory_iterator iter( "/proc" ); iter != directory_iterator(); ++iter )
    {
        if ( is_directory( iter->status() ) && all( iter->filename(), is_digit() ) )
        {
            uint pid = atol( iter->filename().c_str() );
            shared_ptr<Linux::Process> proc( new Linux::Process( shared_from_this(), pid ) );
            result.push_back( proc );
        }
    }

    return result;
}

Result LinuxDumper::allEnvironmentVariables() const
{
    Result result;
    std::vector< shared_ptr< EnvironmentVariable > > rows( EnvironmentVariable::allSystemInstances( shared_from_this() ) );
    copy( rows.begin(), rows.end(), back_inserter( result ) );
    return result;
}

Result LinuxDumper::operatingSystem() const
{
    Result result;
    shared_ptr<OperatingSystem> current( new OperatingSystem( shared_from_this() ) );
    result.push_back( current );
    return result;
}

QStringList LinuxDumper::doListTables()
{
    QStringList tables;
    for ( Impl::TableHandlers::const_iterator handler = impl_->tableHandler.begin();
        handler != impl_->tableHandler.end(); ++handler )
    {
        tables.push_back( handler->first );
    }

    return tables;
}

Result LinuxDumper::allSockets()
{
    Result result;
    std::vector< shared_ptr< Socket > > rows( Socket::allSystemInstances( shared_from_this(), "tcp" ) );
    copy( rows.begin(), rows.end(), back_inserter( result ) );
    return result;
}

Result LinuxDumper::allNetworkInterfaces() const
{
    Result result;
    shared_ptr<Linux::NetworkInterface> proc( new Linux::NetworkInterface( "eth0" ) );
    result.push_back( proc );
    return result;
}
Result LinuxDumper::allConfigurationFiles()
{
    return systemContext().allConfigurationFiles();
}

Result LinuxDumper::allMountEntries( const boost::filesystem::path &fstab_path )
{
    Result result;
    std::vector< shared_ptr< MountEntry > > rows( MountEntry::allMountEntriesFrom( shared_from_this(), fstab_path ) );
    copy( rows.begin(), rows.end(), back_inserter( result ) );
    return result;
}

Result LinuxDumper::allInittabEntries()
{
    Result result;
    std::vector< shared_ptr< InittabEntry > > rows( InittabEntry::allInittabEntries( shared_from_this() ) );
    copy( rows.begin(), rows.end(), back_inserter( result ) );
    return result;
}

Result LinuxDumper::doQueryTable( QString table )
{
    Impl::TableHandlers::const_iterator handler = impl_->tableHandler.find( table );
    if ( handler == impl_->tableHandler.end() )
        throw NoSuchTable( QString( "No such table: %1" ).arg( table ), table );

    return handler->second( shared_from_this() );
}

}
}