libasyncio: (tomj) fix uninitialized vars, added little safety against zombie filters

[libasyncio] / asyncio / async_socket.cpp

/** @file
 *
 * (c) Copyright 2008 by Intra2net AG
 * 
 * info@intra2net.com
 *
 * @todo unlink unix server socket on close.
 */

#include "async_socket.hpp"
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <errno.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <limits.h>
#include <filefunc.hxx>


namespace AsyncIo
{


namespace
{

struct sockaddr_un dummy_un;

union MegaAddr {
   struct sockaddr         m_addr;
   struct sockaddr_in      m_addr_in;
   struct sockaddr_un      m_addr_un; // NOTE (historically) too small...
   // storage is large enough to hold all sockaddr_* variants with the (historical) exception of _un !
   struct sockaddr_storage m_addr_store;
   // a char array large enough to hold _un (with an path up to the maximum allowed size!)
   // (the +1 is added for a later 0-termination of the path)
   char m_buffer[ sizeof(dummy_un) - sizeof(dummy_un.sun_path) + PATH_MAX + 1 ];
};


} // eo namespace <anonymous>



/*
** implementation of ServerSocketBaseImplementation
*/


ServerSocketBaseImplementation::ServerSocketBaseImplementation()
: IOImplementation()
{
} // eo ServerSocketBaseImplementation::ServerSocketBaseImplementation()


/**
 * @brief handled incoming connections on the server port.
 *
 * accepts the new connection, stores the peer address in an internal buffer
 * and calls a (derived) acceptNewConnection method to create an apropriate
 * IO class instance.
 * If no io instance is created the connection is closed.
 */
void ServerSocketBaseImplementation::doRead()
{
   MegaAddr addr;
   socklen_t addrlen = sizeof(addr);

   // reset errno:
   m_errno= 0;

   // reset the mark:
   resetReadMark();

   int fd = ::accept( readFd(), &addr.m_addr, &addrlen);
   if (fd < 0)
   {
      // handle errors.
      m_errno= errno;
      switch (m_errno)
      {
         case EBADF:
         case EINVAL:
         case ENOTSOCK:
            // should not happen...
            close();
            break;
         default:;
      }
      return;
   }

   if (addrlen < sizeof(addr))
   {
      // in case of unix domain socket: terminate the path!
      // NOTE we are doing this here since we don't pass the length info.
      addr.m_buffer[addrlen]= 0;
   }
   else
   {
      //something went terribly wrong!!
      // the resulting address structure is larger than it ever could be...
      ::close(fd);
      return;
   }

   IOImplementationPtr connection= acceptNewConnection(fd, &addr.m_addr);
   if(!connection)
   {
      ::close(fd);
      return;
   }
   if (m_new_connection_base_callback)
   {
      m_new_connection_base_callback(connection);
   }
} // eo ServerSocketBaseImplementation::doRead()


/**
 * @brief handles write events.
 *
 * since server sockets never ever get a write mark, something must
 * be wrong and the connection is closed!
 */
void ServerSocketBaseImplementation::doWrite()
{
   // if this method is called, something went wrong...
   close();
   //TODO throw something?!
} // eo ServerSocketBaseImplementation::doWrite()



/**
 * @brief sets a function which is called when a new connection was established.
 *
 * The function gets a (shared) pointer to the new connetion as parameter and is
 * expected to store it when it accepts the connection.
 * (Else the conenction gets deleted after the function was called.)
 *
 * @param func the function which hsould be called on new conenctions.
 */
void ServerSocketBaseImplementation::setNewConnectionBaseCallback(
   const NewConnectionBaseCallbackFunc& func)
{
   m_new_connection_base_callback= func;
} // eo ServerSocketBaseImplementation::setNewConnectionBaseCallback(NewConnectionBaseCallbackFunc&)



/**
 * @brief callback for new connections.
 *
 * The base method always returns an empty pointer.
 *
 * Derived classes must override this method and do something useful with
 * the passed file descriptor.
 *
 * @param fd the file descriptor of the new connection.
 * @param addr pointer to the address structure filled from ::accept()
 * @return shared pointer to the new IO class instance (; empty if not accepted)
 */
IOImplementationPtr ServerSocketBaseImplementation::acceptNewConnection(
   int fd, boost::any addr)
{
   // needs to be defined in derived class!
   return IOImplementationPtr();
} // eo ServerSocketBaseImplementation::acceptNewConnection(int,boost::any)



/*
** implementation of UnixIOSocket
*/


UnixIOSocket::UnixIOSocket()
: m_peer_pid(0)
, m_peer_uid(0)
, m_peer_gid(0)
{
} // eo UnixIOSocket::UnixIOSocket()



UnixIOSocket::UnixIOSocket(const std::string& path)
: m_peer_pid(0)
, m_peer_uid(0)
, m_peer_gid(0)
{
   open(path);
} // eo UnixIOSocket::UnixIOSocket(const std::string&)


UnixIOSocket::UnixIOSocket(
   int fd, const std::string& path,
   unsigned int peer_pid, unsigned int peer_uid, unsigned int peer_gid)
: IOImplementation(fd,fd)
, m_path(path)
, m_peer_pid(peer_pid)
, m_peer_uid(peer_uid)
, m_peer_gid(peer_gid)
{
} // eo UnixIOSocket::UnixIOSocket(int,const std::string&,unsigned,unsigned,unsigned)


/**
 * @brief opens a (client) connection to an unix domain socket.
 *
 * @param path the path the server is listening on.
 * @return @a true iff the connection was successfully opened.
 */
bool UnixIOSocket::open(const std::string& path)
{
   if (opened()) close();

   m_errno= 0;
   m_path.clear();

   if (path.empty() || path.size() >= PATH_MAX)
   {
      return false;
   }

   int fd= ::socket(PF_UNIX, SOCK_STREAM, 0);
   if (fd<0)
   {
      m_errno= errno;
      return false;
   }

   {
      MegaAddr addr;
      addr.m_addr_un.sun_family= AF_UNIX;
      strncpy(addr.m_addr_un.sun_path, path.c_str(), PATH_MAX);
      if (::connect(fd,(sockaddr*)&addr.m_addr_un, SUN_LEN(&addr.m_addr_un)) < 0)
      {
         m_errno= errno;
         ::close(fd);
         return false;
      }
   }
   m_path= path;
   setReadFd(fd);
   setWriteFd(fd);
   return true;
} // eo UnixIOSocket::open(const std::string&,int)


/*
** implementation of UnixServerSocketBase
*/


UnixServerSocketBase::UnixServerSocketBase()
{
} // eo UnixServerSocketBase::UnixServerSocketBase


UnixServerSocketBase::UnixServerSocketBase(const std::string& path, int mode)
{
   open(path,mode);
} // eo UnixServerSocketBase::UnixServerSocketBase(const std::string&,int)


/**
 * @brief opens the server part of an unix domain socket.
 *
 * @param path the path the new port should listen on.
 * @param mode the mode for the path.
 * @return @a true iff the port was successfully opened.
 */
bool UnixServerSocketBase::open(const std::string& path, int mode)
{
   if (opened()) close();
   m_errno= 0;
   if (path.empty() || path.size() >= PATH_MAX)
   {
      return false;
   }

   int fd= ::socket(PF_UNIX, SOCK_STREAM, 0);
   if (fd<0)
   {
      m_errno= errno;
      return false;
   }

   {
      MegaAddr addr;
      addr.m_addr_un.sun_family= AF_UNIX;
      strncpy(addr.m_addr_un.sun_path, path.c_str(), PATH_MAX);
      ::I2n::unlink(path); // just in case...
      mode_t old_mask= ::umask( (mode & 0777) ^ 0777);
      if (::bind(fd,(sockaddr*)&addr.m_addr_un, SUN_LEN(&addr.m_addr_un)) < 0)
      {
         m_errno= errno;
         ::umask(old_mask);
         ::close(fd);
         return false;
      }
      ::umask(old_mask);
   }
   m_path= path;

   {
      int res= ::listen(fd,8);
      if (res < 0)
      {
         m_errno= errno;
         ::close(fd);
         return false;
      }
   }
   setReadFd(fd);
   return true;
} // eo UnixServerSocketBase::open(const std::string&,int)


/**
 * @brief called from base class to create a new connection instance.
 *
 * This method accepts only connections to unix domain sockets.
 * It also tries to determine the peer pid, uid and gid.
 *
 * @param fd the file descriptor of a freshly accepted connection.
 * @param addr conatins "pointer to struct sockaddr"
 * @return @a a (shared) pointer to the new connection isntance; empty if none was
 * created.
 */
IOImplementationPtr UnixServerSocketBase::acceptNewConnection(int fd, boost::any addr)
{
   struct sockaddr *addr_ptr= NULL;
   try {
      addr_ptr = boost::any_cast<struct sockaddr*>(addr);
   }
   catch (boost::bad_any_cast&)
   {
      return IOImplementationPtr();
   }
   // check for the right family:
   if (addr_ptr->sa_family != AF_UNIX)
   {
      return IOImplementationPtr();
   }
   struct sockaddr_un *un_ptr = reinterpret_cast<struct sockaddr_un*>(addr_ptr);
   std::string peer_path( un_ptr->sun_path );
   unsigned peer_pid=0;
   unsigned peer_gid=0;
   unsigned peer_uid=0;
#ifdef __linux__
   { // the linux way to get peer info (pid,gid,uid):
      struct ucred cred;
      socklen_t cred_len = sizeof(cred);
      if (getsockopt(fd,SOL_SOCKET,SO_PEERCRED,&cred,&cred_len) == 0)
      {
         peer_pid= cred.pid;
         peer_uid= cred.uid;
         peer_gid= cred.gid;
      }
   }
#else
#error dont know how to determine peer info.
#endif

   UnixIOSocketPtr ptr( createIOSocket(fd, peer_path, peer_pid, peer_uid, peer_gid) );
   return ptr;
} // eo UnixServerSocketBase::acceptNewConnection(int,boost::any);


/**
 * @brief "real" creator of the connection instance.
 *
 * called by UnixServerSocketBase::acceptNewConnection to create the new io instance.
 *
 * @param fd file descriptor for the socket
 * @param path path as delivered by peer.
 * @param peer_pid peer pid.
 * @param peer_uid peer uid.
 * @param peer_gid peer gid.
 * @return (shared) pointer to the new io instance.
 */
UnixIOSocketPtr UnixServerSocketBase::createIOSocket(
   int fd, const std::string& path,
   unsigned int peer_pid,
   unsigned int peer_uid, unsigned int peer_gid)
{
   return UnixIOSocketPtr(
      new UnixIOSocket(fd, path, peer_pid, peer_uid, peer_gid)
   );
} // eo UnixServerSocketBase::createIOSocket(int,const std::string&,unsigned,unsigned,unsigned)



}// eo namespace AsyncIo