Socket.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/>.
 */

#include <map>

#include "boost/filesystem.hpp"
#include "boost/bind.hpp"

#include "QRegExp"

#include "Confdump/System/FixedTable.hpp"
#include "Confdump/System/LinuxDumper.hpp"
#include "Confdump/System/Linux/Socket.hpp"

using boost::shared_ptr;
namespace fs = boost::filesystem;

namespace Confdump
{

namespace System
{

namespace Linux
{

namespace
{

// Converts strings as found in the system tables to something convenient (1.2.3.4:80)
QString fixIpv4String( QString ip )
{
    // The host and port are present (thus layer 4) and in network byte order
    QRegExp hexL4( "([0-9A-F]{8}):([0-9A-F]{4})" );
    if ( hexL4.exactMatch( ip ) )
    {
        QString hexAddress = hexL4.cap( 1 );
        QString hexPort = hexL4.cap( 2 );
        QString result( "%1.%2.%3.%4:%5" );

        for ( unsigned i = 0; i < 4; ++i )
        {
            quint8 byte = hexAddress.mid( ( 3 - i ) * 2, 2 ).toUInt( NULL, 16 );
            result = result.arg( byte );
        }

        quint16 port = hexPort.toUInt( NULL, 16 );
        result = result.arg( port );

        return result;
    }
    else // unknown format, leave as is
    {
        return ip;
    }
}

class SocketListFile
{
    SocketListFile();

public:
    SocketListFile( shared_ptr<LinuxDumper> driver, fs::path file )
     : file_( file ),
       list_( driver->systemContext().slurpConfigurationFile( file, "CD_Socket") ),
       ipv6_( file_.string().at( file_.string().size() - 1 ) == '6' )
    {
        fieldTranslations_["inode"]         = "inode";
        fieldTranslations_["local_address"] = "localAddressString";
        fieldTranslations_["rem_address"]   = "remoteAddressString";
        fieldTranslations_["st"]            = "stateString";
        fieldTranslations_["tm->when"]      = "tm_when";
    }

    void readAllInto( std::vector< shared_ptr< Socket > > &instances )
    {
        // Field reference: http://lkml.indiana.edu/hypermail/linux/kernel/0409.1/2166.html
        //   sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode
        //    0: 00000000:0016 00000000:0000 0A 00000000:00000000 00:00000000 00000000     0        0 6611 1 ffff88011a178000 300 0 0 2 -1
        FixedTable::Specification spec;
        spec.addColumnHead( "sl",            2,  2 );
        spec.addColumnHead( "local_address", 2, 13 );
        spec.addColumnHead( "rem_address",   1, 13 );
        spec.addColumnHead( "st",            1,  2 );
        spec.addColumnHead( "tx_queue",      1,  8 );
        spec.addColumnHead( "rx_queue",      1,  8 );
        spec.addColumnHead( "tr",            1,  2 );
        spec.addColumnHead( "tm->when",      1,  8 );
        spec.addColumnHead( "retrnsmt",      1,  8 );
        spec.addColumnHead( "uid",           1,  5 );
        spec.addColumnHead( "timeout",       1,  8 );
        spec.addColumnHead( "inode",         1, 58 ); // there are that many spaces in the input

        FixedTable table;
        table.setSpecification( spec );
        table.setFieldTranslations( fieldTranslations_ );

        table.readAllInto( list_, instances );
    }

private:
    fs::path file_;
    QByteArray list_;
    std::map<std::string, std::string> fieldTranslations_;
    bool ipv6_;
};

} // ns


Socket::Socket()
 : inode_( 0 )
{
}

Socket::~Socket()
{
}

QString Socket::protocolName() const
{
    return protocolName_;
}

QString Socket::localAddressString() const
{
    return localAddressString_;
}

QString Socket::remoteAddressString() const
{
    return remoteAddressString_;
}

QString Socket::stateString() const
{
    return stateString_;
}

void Socket::setProtocolName( QString protocolName )
{
    protocolName_ = protocolName;
}

void Socket::setLocalAddressString( QString localAddressString )
{
    localAddressString_ = fixIpv4String( localAddressString );
}

void Socket::setRemoteAddressString( QString remoteAddressString )
{
    remoteAddressString_ = fixIpv4String( remoteAddressString );
}

void Socket::setStateString( QString stateString )
{
    // According to Linux Kernel 2.6's include/net/tcp_states.h
    int state = stateString.toInt( NULL, 16 );
    switch ( state )
    {
    case  1: stateString_ = "ESTABLISHED"; break;
    case  2: stateString_ = "SYN_SENT";    break;
    case  3: stateString_ = "SYN_RECV";    break;
    case  4: stateString_ = "FIN_WAIT1";   break;
    case  5: stateString_ = "FIN_WAIT2";   break;
    case  6: stateString_ = "TIME_WAIT";   break;
    case  7: stateString_ = "CLOSE";       break;
    case  8: stateString_ = "CLOSE_WAIT";  break;
    case  9: stateString_ = "LAST_ACK";    break;
    case 10: stateString_ = "LISTEN";      break;
    case 11: stateString_ = "CLOSING";     break;
    }
}

std::vector< shared_ptr< Socket > > Socket::allSystemInstances( boost::shared_ptr<LinuxDumper> driver, QString protocolName )
{
    SocketListFile file( driver, fs::path( "/proc/net" ) / protocolName.toStdString() );
    std::vector< shared_ptr< Socket > > instances;
    file.readAllInto( instances );

    // FIXME: would be cleaner/faster with a factory
    for ( size_t i = 0; i < instances.size(); ++i )
        instances[i]->setProtocolName( protocolName );

    return instances;
}

}
}
}