tcpip_appender.cpp

Go to the documentation of this file.

/**************************************************************************

   begin                : Fri Sep 14 2007
   copyright            : (C) 2007 by Ewald Arnold
   email                : log4sendpp at ewald-arnold dot de

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser 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 Lesser General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 **/

#define LOG4SENDPP_NEED_EXPORTS
#include <log4sendpp/log4sendpp.h>  // always first header

#if defined(__WIN32__) || defined(_MSC_VER)
#include <winsock2.h>
//#include <windows.h>
typedef int socklen_t;
#endif

#ifdef __unix__
#include <unistd.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#endif

#include <csignal>
#include <cerrno>

#include <log4sendpp/tcpip_appender.h>
#include <log4sendpp/exception.h>
#include <log4sendpp/formatter.h>


LOG4SENDPP_NS_START


struct TcpIpAppender::Impl
{
   unsigned            timeout;    
   struct sockaddr_in  hostdata;   
   int                 fd_handle;  
   unsigned            port;       
   bool                net_error;  
};


#if defined(__WIN32__)  && !defined (LOG4SENDPP_NO_WSA_STARTUP)

bool TcpIpAppender::WSA_is_initialized = false; 

#endif



LOG4SENDPP_API_IMPL(int) TcpIpAppender::getLastError()
{
#ifdef __WIN32__
    return(::WSAGetLastError());
#else
    return(errno);
#endif
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string)
  TcpIpAppender::getErrorString(int err_number)
{
#ifdef __WIN32__
    LPSTR lpMsgBuf;
    int ok = FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
        NULL,
        err_number,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
        (LPSTR)&lpMsgBuf,
        0,
        NULL);

    if (ok != 0 && lpMsgBuf != 0)
      return lpMsgBuf;

    else
    {
      char s[40];
      LOG4SENDPP_STD_NS::string errn  = itoa(err_number, s, 10);
      return LOG4SENDPP_STD_NS::string("Unknown connection problem, Windows error code: #")+errn;
    }
#else
    return LOG4SENDPP_STD_NS::strerror(err_number);
#endif
}


LOG4SENDPP_API_IMPL(void)
  TcpIpAppender::asciiToInAddr(const char *address, struct in_addr &saddr)
{
  memset (&saddr, 0, sizeof(in_addr));
  struct hostent *host;

  /* First try it as aaa.bbb.ccc.ddd. */
  saddr.s_addr = inet_addr(address);
  if ((int)saddr.s_addr == -1)
  {
    LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("inet_addr() failed: ")
                                   + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    pimpl->net_error = true;
    return;
#endif
  }

  host = ::gethostbyname(address);
  if (host == 0)
  {
    LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("gethostbyname() failed: ")
                                   + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    pimpl->net_error = true;
    return;
#endif
  }

  memmove((void*)&saddr, host->h_addr_list, sizeof(in_addr));
}


LOG4SENDPP_API_IMPL(struct hostent *)
  TcpIpAppender::getHostAdress(const LOG4SENDPP_STD_NS::string &dom)
{
  return ::gethostbyname(dom.c_str() );
}


#if defined(__WIN32__)  && !defined (LOG4SENDPP_NO_WSA_STARTUP)


LOG4SENDPP_API_IMPL(void) TcpIpAppender::WSA_init()
{
  if (!WSA_is_initialized)
  {
    WSA_is_initialized = true;
    WORD wVersionRequested;
    WSADATA wsaData;
    wVersionRequested = MAKEWORD( 2, 0 );

    if (::WSAStartup( wVersionRequested, &wsaData) != 0)
    {
      LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("Initializing Windows sockets failed: ")
                                  + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
      pimpl->net_error = true;
      return;
#endif
    }
  }
}

#endif


LOG4SENDPP_API_IMPL0 TcpIpAppender::TcpIpAppender(Formatter *formatter, long adr, unsigned prt)
  : Appender(formatter)
{
  init(prt);
  pimpl->hostdata.sin_addr.s_addr = htonl(adr);

  LOG4SENDPP_TRY
  {
    open();
  }
  LOG4SENDPP_CATCH_ALL
  {
    pimpl->net_error = true;
  }
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) TcpIpAppender::gethostname()
{
#if defined(__WIN32__)  && !defined (LOG4SENDPP_NO_WSA_STARTUP)
  WSA_init();
#endif

  char buffer[1000];
  memset(buffer, 0, sizeof(buffer));

  int ret = ::gethostname ( buffer, sizeof(buffer)-1);
  if (ret != 0)
  {
    LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("gethostname() failed: ")
                                   + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    return "";
#endif
  }
  return LOG4SENDPP_STD_NS::string(buffer);
}


LOG4SENDPP_API_IMPL0 TcpIpAppender::TcpIpAppender(Formatter *formatter, const LOG4SENDPP_STD_NS::string &host, unsigned prt)
  : Appender(formatter)
{
  init(prt);

  struct hostent *hp = getHostAdress(host);
  if (hp == 0)
  {
//    LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("Host adress not found: ") + host));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    pimpl->net_error = true;
    return;
#endif
  }

  memcpy(&(pimpl->hostdata.sin_addr), hp->h_addr_list[0], hp->h_length);

  LOG4SENDPP_TRY
  {
    open();
  }

  LOG4SENDPP_CATCH_ALL
  {
    pimpl->net_error = true;
  }
}

LOG4SENDPP_API_IMPL(void) TcpIpAppender::init(unsigned prt)
{
#if !defined(__WIN32__) && !defined(_WIN32)
  signal (SIGPIPE, SIG_IGN);  // prevent SIGKILL while write()-ing in closing pipe
#endif

#if defined(__WIN32__)  && !defined (LOG4SENDPP_NO_WSA_STARTUP)
  WSA_init();
#endif

  pimpl = new Impl;
  pimpl->timeout = 10;
  pimpl->port = prt;
  memset(&pimpl->hostdata, 0, sizeof(pimpl->hostdata));
  pimpl->hostdata.sin_port = htons(prt);
  pimpl->hostdata.sin_family = AF_INET;
  pimpl->net_error = false;
  pimpl->fd_handle = -1;
}


LOG4SENDPP_API_IMPL0 TcpIpAppender::~TcpIpAppender()
{
  LOG4SENDPP_TRY
  {
    close();
  }

  LOG4SENDPP_CATCH_ALL
  {
    // forget it ?
  }

  delete pimpl;
  pimpl = 0;
}


LOG4SENDPP_API_IMPL(bool) TcpIpAppender::isWorking() const
{
   return pimpl->fd_handle > 0 && !pimpl->net_error;
}


LOG4SENDPP_API_IMPL(void) TcpIpAppender::open()
{
  if (pimpl->fd_handle >= 0)
     return;

  pimpl->fd_handle = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (pimpl->fd_handle < 0)
  {
    LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("socket() failed: ")
                                   + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    pimpl->net_error = true;
    return;
#endif
  }

  int iOptVal = pimpl->timeout * 1000;
  int iOptLen = sizeof(int);
  int ret;
  ret = ::setsockopt(pimpl->fd_handle, SOL_SOCKET, SO_RCVTIMEO, (char*)&iOptVal, iOptLen);
  ret = ::setsockopt(pimpl->fd_handle, SOL_SOCKET, SO_SNDTIMEO, (char*)&iOptVal, iOptLen);

  if(::connect(pimpl->fd_handle, (struct sockaddr *)&pimpl->hostdata, sizeof(pimpl->hostdata)) < 0)
  {
    LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("connect() failed: ")
                                   + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    pimpl->net_error = true;
    return;
#endif
  }

  pimpl->net_error = false;

  LOG4SENDPP_UNUSED(ret);
}


LOG4SENDPP_API_IMPL(signed long) TcpIpAppender::low_level_write(char const *buff, long len)
{
#ifndef __unix__
      return ::send(pimpl->fd_handle, buff, len, 0);
#else
      return ::write(pimpl->fd_handle, buff, len);
#endif

}


LOG4SENDPP_API_IMPL(void) TcpIpAppender::append (Logger::Level level,
                                                LOG4SENDPP_STD_NS::string msg,
                                                LOG4SENDPP_STD_NS::string category,
                                                LOG4SENDPP_INT64 stamp,
                                                const LocationInformation *info,
                                                const Logger::DiagnosticInformation *diaginfo )
{
  if (!isWorking())
    return;

  LOG4SENDPP_TRY
  {
    Formatter *formatter = getFormatter();
    if (formatter)
    {
      LOG4SENDPP_STD_NS::vector<LOG4SENDPP_STD_NS::string> msgs = formatter->format(level, msg, category, stamp, info, diaginfo);

      LOG4SENDPP_STD_NS::string s;
      for (unsigned i = 0; i < msgs.size(); ++i)
         s += msgs[i] + "\n";

      writeString(s);
    }
  }

  LOG4SENDPP_CATCH_ALL
  {
    pimpl->net_error = true;
    LOG4SENDPP_RETHROW;
  }
}


LOG4SENDPP_API_IMPL(void) TcpIpAppender::writeString(const LOG4SENDPP_STD_NS::string &data)
{
  long written;

  if (!isWorking() || data.length() == 0)
    return;

  fd_set wfd;

  timeval wait;
  wait.tv_sec = pimpl->timeout;
  wait.tv_usec = 0;

  unsigned len = data.length();
  char *buff = (char*) data.data();

  while (len > 0)
  {
    FD_ZERO(&wfd);
    FD_SET((unsigned) pimpl->fd_handle, &wfd);
    int ready;
    wait.tv_sec = pimpl->timeout;
    wait.tv_usec = 0;
    while((ready = select(pimpl->fd_handle+1, 0, &wfd, 0, &wait)) < 0)
    {
      if(errno == EINTR || errno == EAGAIN)
      {
        wait.tv_sec = pimpl->timeout;
        wait.tv_usec = 0;
        continue;
      }

      else
      {
        LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("select() failed: ")
                             + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
       pimpl->net_error = true;
       return;
#endif
      }
    }

    if(ready == 0)
    {
      LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, "timeout while attempting to write."));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
      pimpl->net_error = true;
      return;
#endif
    }

    if(FD_ISSET(pimpl->fd_handle, &wfd))
    {
      if ( (written = low_level_write(buff, len)) < 0)
      {
        switch(getLastError())
        {
          case EAGAIN:
          case EINTR:
#ifdef __unix__
            errno = 0;
#endif
          continue;

          case EPIPE:
            close();
            LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("attempt to write to a connection"
                                            " already closed by the peer")));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
            pimpl->net_error = true;
            return;
#endif
          /*break; */

          default:
            LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("low_level_write() failed: ")
                                           + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
            pimpl->net_error = true;
            return;
#endif

        }
      }

      else
      {
        buff += written;
        len -= written;
      }
    }
  }
}


LOG4SENDPP_API_IMPL(void) TcpIpAppender::close()
{
  pimpl->net_error = false;

  if (pimpl->fd_handle < 0)
     return;

  int ret;

#ifndef __unix__

  ret = closesocket(pimpl->fd_handle);

#else

  do
    ret = ::close(pimpl->fd_handle);
  while(ret < 0 && (errno == EINTR || errno == EAGAIN));

#endif

  pimpl->fd_handle = -1;

  if(ret < 0)
  {
    LOG4SENDPP_THROW(Exception(__LINE__, __FILE__, LOG4SENDPP_STD_NS::string("close() failed: ")
                               + getErrorString(getLastError())));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    pimpl->net_error = true;
    return;
#endif
  }
}


LOG4SENDPP_NS_END

---