triplet.cpp

//
// C++ Implementation: triplet
//
// Description: 
//
//
// Author: Michael Moritz <mimo@restoel.net>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <iostream>
#include <string>
#include <sstream>
#include <stdexcept>
#include <netdb.h>
#include "cfg.h"
#include "read.h"
#include "defs.h"
#include "triplet.h"

#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif

Triplet::Triplet(const Reader& reader)
        : _client_address(reader.getValue(ATTR_CLIENT)), 
          _sender(reader.getValue(ATTR_SENDER)), 
          _recipient(reader.getValue(ATTR_RECIPIENT)),
          _resolved(reader.getValue(ATTR_RCLNAME,"")),
          _client_address_numeric(),
          _not_resolved(),
          _weakclient()
{
        _init();
}
Triplet::Triplet(const std::string& client,const std::string& sender,const std::string& recipient,
                const std::string& client_numeric) 
        :       _client_address(client), 
                _sender(sender), 
                _recipient(recipient),
                _resolved(),
                _client_address_numeric(client_numeric),
                _not_resolved(),
                _weakclient()
                
{
        _init();
}

// - set up _resolved (if reverse)
// - set up _client_address_numeric (always?)
// - set up _weakclient (if in weak mode)
void Triplet::_init() {
        bool weak = g_getCfg().isModeWeak();
        bool reverse = g_getCfg().isModeReverse();
        bool verbose = g_getCfg().isVerbose();

        
        const std::string& tStr = _client_address;
//      std::cout << "tStr" << tStr << std::endl;
        std::string::size_type i = tStr.find('.');
        std::string::size_type j = 1; //skip '
        if(tStr[0] != '\'') //unquoted
                j = 0;
        if(i != std::string::npos) {
                do {
                        //std::cout << "substr " << tStr.substr(j,i-j) << std::endl;
                        _client_address_numeric += atoi((tStr.substr(j,i-j)).c_str());
                        j = i+1;
                        i = tStr.find('.',j);
                        if(i == std::string::npos) {
                                i = tStr.find('\'',j);
                                if((i == std::string::npos) && (tStr[0] != '\'')) { //unquoted
                                        //std::cout << "substr " << tStr.substr(j,i) << std::endl;
                                        _client_address_numeric += atoi((tStr.substr(j,i)).c_str());
                                        break;
                                }
                        }
                }while( i != std::string::npos);
        }


        if(reverse) {

                const std::string& clientAddressNumeric = _client_address_numeric;
                //would like to use getnameinfo but documentation sucks big time
                hostent* hp = ::gethostbyaddr(clientAddressNumeric.c_str(),
                        clientAddressNumeric.size(),
                        AF_INET);
                if(hp) {
                        _resolved = hp->h_name;
                } else {
                        std::string err;
                        switch(h_errno) {
                                case HOST_NOT_FOUND:
                                        err = "HOST_NOT_FOUND";
                                        break;
                                case NO_ADDRESS:
                                        err = "NO_ADDRESS|NO_DATA";
                                        break;
                                case NO_RECOVERY:
                                        err = "NO_RECOVERY";
                                        break;
                                case TRY_AGAIN:
                                        err = "TRY_AGAIN";
                                        break;
                                default:
                                        err = "Unexpected";
                                        break;
                        }
                        _not_resolved = err;
                }
        }


        _weakclient = "'" + getClientAddressNumericStr('.',3)+"." + "'";

}
/* const std::string& getClientAddressNumeric() const { 
                if(_client_address_numeric.size())
                        return _client_address_numeric;
                else {
                        if( !_client_address.size() )
                                return _client_address_numeric;
                        const std::string& tStr = _client_address;
//                      std::cout << "tStr" << tStr << std::endl;
                        std::string::size_type i = tStr.find('.');
                        std::string::size_type j = 1; //skip '
                        if(tStr[0] != '\'') //unquoted
                                j = 0;
                        if(i != std::string::npos) {
                                do {
                                        //std::cout << "substr " << tStr.substr(j,i-j) << std::endl;
                                        _client_address_numeric += atoi((tStr.substr(j,i-j)).c_str());
                                        j = i+1;
                                        i = tStr.find('.',j);
                                        if(i == std::string::npos) {
                                                i = tStr.find('\'',j);
                                                if((i == std::string::npos) && (tStr[0] != '\'')) { //unquoted
                                                        //std::cout << "substr " << tStr.substr(j,i) << std::endl;
                                                        _client_address_numeric += atoi((tStr.substr(j,i)).c_str());
                                                        break;
                                                }
                                        }
                                }while( i != std::string::npos);
                        }
                        return _client_address_numeric;
                }
        };*/

const std::string Triplet::getClientAddressNumericStr(const char sep,unsigned size) const { 
        std::stringstream stm;
        if(size == 0)
                size = getClientAddressNumeric().size();
        if(size == 0)
                return std::string("(zero size)");
        //TODO check if this way of conversion is portable
        const unsigned char* pu = reinterpret_cast<const unsigned char*>(_client_address_numeric.c_str());
        for(unsigned i=0;i < size-1;i++) 
                stm << static_cast<unsigned>(pu[i]) << sep;
        if(size >= 1)
                stm << static_cast<unsigned>(pu[size-1]);
        return stm.str();
}
const std::string Triplet::getClientAddressNumericStrSQL(const std::string& sep,const std::string& base,
        unsigned start,const std::string& afterstart,unsigned mult,unsigned size) const { 
        std::stringstream stm;
//      unsigned size = bytes;
        if(size == 0)
                size = getClientAddressNumeric().size();
        //TODO check if this way of conversion is portable
        const unsigned char* pu = reinterpret_cast<const unsigned char*>(getClientAddressNumeric().c_str());
        for(unsigned i=0;i < size-1;i++) {
                stm << base << start << afterstart << static_cast<unsigned>(pu[i]) << sep;
                start /= mult;
        }
        if(size >= 1)
                stm << base << start << afterstart << static_cast<unsigned>(pu[size-1]);
        return stm.str();
}
// const std::string Triplet::getResolved() const {
//      if(_resolved.size() > 0)
//                      return _resolved;
//      if(_not_resolved.size() > 0)
//              return _resolved; //empty string
//      const std::string& clientAddressNumeric = this->getClientAddressNumeric();
//      //would like to use getnameinfo but documentation sucks big time
//      hostent* hp = ::gethostbyaddr(clientAddressNumeric.c_str(),
//                    clientAddressNumeric.size(),
//                    AF_INET);
//      if(hp) {
//              _resolved = hp->h_name;
//      } else {
//              std::string err;
//              switch(h_errno) {
//                      case HOST_NOT_FOUND:
//                              err = "HOST_NOT_FOUND";
//                              break;
//                      case NO_ADDRESS:
//                              err = "NO_ADDRESS|NO_DATA";
//                              break;
//                      case NO_RECOVERY:
//                              err = "NO_RECOVERY";
//                              break;
//                      case TRY_AGAIN:
//                              err = "TRY_AGAIN";
//                              break;
//                      default:
//                              err = "Unexpected";
//                              break;
//              }
//              _not_resolved = err;
//      }
//      return _resolved;
// }

---