dnxTcp.c

Go to the documentation of this file.

/*--------------------------------------------------------------------------

   Copyright (c) 2006-2007, Intellectual Reserve, Inc. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  --------------------------------------------------------------------------*/

#include "dnxTcp.h"     // temporary
#include "dnxTSPI.h"

#include "dnxTransport.h"
#include "dnxError.h"
#include "dnxDebug.h"
#include "dnxLogging.h"

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
#include <pthread.h>
#include <limits.h>

#ifndef HOST_NAME_MAX
# define HOST_NAME_MAX 256
#endif

#define DNX_TCP_LISTEN  5

typedef struct iDnxTcpChannel_
{
   char * host;         
   int port;            
   int socket;          
   iDnxChannel ichan;   
} iDnxTcpChannel;

static pthread_mutex_t tcpMutex;

/*--------------------------------------------------------------------------
                  TRANSPORT SERVICE PROVIDER INTERFACE
  --------------------------------------------------------------------------*/

static int dnxTcpOpen(iDnxChannel * icp, int mode)
{
   iDnxTcpChannel * itcp = (iDnxTcpChannel *)
         ((char *)icp - offsetof(iDnxTcpChannel, ichan));
   struct hostent * he;
   struct sockaddr_in inaddr;
   int sd;

   assert(icp && itcp->port > 0);

   inaddr.sin_family = AF_INET;
   inaddr.sin_port = (in_port_t)itcp->port;
   inaddr.sin_port = htons(inaddr.sin_port);

   // see if we are listening on any address
   if (!strcmp(itcp->host, "INADDR_ANY")
         || !strcmp(itcp->host, "0.0.0.0")
         || !strcmp(itcp->host, "0"))
   {
      // make sure that the request is passive
      if (mode == DNX_MODE_ACTIVE) return DNX_ERR_ADDRESS;
      inaddr.sin_addr.s_addr = INADDR_ANY;
   }
   else  // resolve destination address
   {
      DNX_PT_MUTEX_LOCK(&tcpMutex);
      if ((he = gethostbyname(itcp->host)) != 0)
         memcpy(&inaddr.sin_addr.s_addr, he->h_addr_list[0], he->h_length);
      DNX_PT_MUTEX_UNLOCK(&tcpMutex);

      if (!he) return DNX_ERR_ADDRESS;
   }

   if ((sd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
   {
      dnxLog("dnxUdpOpen: socket failed: %s.", strerror(errno));
      return DNX_ERR_OPEN;
   }

   // determine how to handle socket connectivity based upon open mode
   if (mode == DNX_MODE_ACTIVE)
   {
      if (connect(sd, (struct sockaddr *)&inaddr, sizeof inaddr) != 0)
      {
         close(sd);
         dnxLog("dnxTcpOpen: connect(%lx) failed: %s.",
               (unsigned long)inaddr.sin_addr.s_addr, strerror(errno));
         return DNX_ERR_OPEN;
      }
   }
   else
   {
      // bind the socket to a local address and port and listen
      if (bind(sd, (struct sockaddr *)&inaddr, sizeof inaddr) != 0)
      {
         close(sd);
         dnxLog("dnxTcpOpen: bind(%lx) failed: %s.",
               (unsigned long)inaddr.sin_addr.s_addr, strerror(errno));
         return DNX_ERR_OPEN;
      }
      listen(sd, DNX_TCP_LISTEN);
   }

   itcp->socket = sd;

   return DNX_OK;
}

//----------------------------------------------------------------------------

static int dnxTcpClose(iDnxChannel * icp)
{
   iDnxTcpChannel * itcp = (iDnxTcpChannel *)
         ((char *)icp - offsetof(iDnxTcpChannel, ichan));

   assert(icp && itcp->socket);

   shutdown(itcp->socket, SHUT_RDWR);
   close(itcp->socket);
   itcp->socket = 0;

   return DNX_OK;
}

//----------------------------------------------------------------------------

static int dnxTcpRead(iDnxChannel * icp, char * buf, int * size,
      int timeout, char * src)
{
   iDnxTcpChannel * itcp = (iDnxTcpChannel *)
         ((char *)icp - offsetof(iDnxTcpChannel, ichan));
   char mbuf[DNX_MAX_MSG];
   unsigned short mlen;

   assert(icp && itcp->socket && buf && size && *size > 0);

   // implement timeout logic, if timeout value is greater than zero
   if (timeout > 0)
   {
      struct timeval tv;
      fd_set fd_rds;
      int nsd;

      FD_ZERO(&fd_rds);
      FD_SET(itcp->socket, &fd_rds);

      tv.tv_usec = 0L;
      tv.tv_sec = timeout;

      if ((nsd = select(itcp->socket + 1, &fd_rds, 0, 0, &tv)) == 0)
         return DNX_ERR_TIMEOUT;

      if (nsd < 0)
      {
         if (errno != EINTR)
         {
            dnxLog("dnxTcpRead: select failed: %s.", strerror(errno));
            return DNX_ERR_RECEIVE;
         }
         return DNX_ERR_TIMEOUT;
      }
   }

   // read the incoming message length
   if (read(itcp->socket, &mlen, sizeof mlen) != sizeof mlen)
      return DNX_ERR_RECEIVE;
   mlen = ntohs(mlen);

   // validate the message length
   if (mlen < 1 || mlen > DNX_MAX_MSG)
      return DNX_ERR_RECEIVE;

   // check to see if the message fits within the user buffer
   if (*size >= mlen)
   {
      if (read(itcp->socket, buf, (int)mlen) != (int)mlen)
         return DNX_ERR_RECEIVE;
      *size = (int)mlen;
   }
   else  // user buffer too small, read what we can, throw the rest away
   {
      if (read(itcp->socket, mbuf, (int)mlen) != (int)mlen)
         return DNX_ERR_RECEIVE;
      memcpy(buf, mbuf, *size);
   }

   // set source addr/port information, if desired
   if (src)
   {
      socklen_t slen;
      *src = 0;   // clear first byte in case getpeeraddr fails
      getpeername(itcp->socket, (struct sockaddr *)src, &slen);
   }
   return DNX_OK;
}

//----------------------------------------------------------------------------

static int dnxTcpWrite(iDnxChannel * icp, char * buf, int size,
      int timeout, char * dst)
{
   iDnxTcpChannel * itcp = (iDnxTcpChannel *)
         ((char *)icp - offsetof(iDnxTcpChannel, ichan));
   unsigned short mlen;

   assert(icp && itcp->socket && buf && size);

   // implement timeout logic, if timeout value is greater than zero
   if (timeout > 0)
   {
      struct timeval tv;
      fd_set fd_wrs;
      int nsd;

      FD_ZERO(&fd_wrs);
      FD_SET(itcp->socket, &fd_wrs);

      tv.tv_usec = 0L;
      tv.tv_sec = timeout;

      if ((nsd = select(itcp->socket + 1, 0, &fd_wrs, 0, &tv)) == 0)
         return DNX_ERR_TIMEOUT;

      if (nsd < 0)
      {
         if (errno != EINTR)
         {
            dnxLog("dnxTcpWrite: select failed: %s.", strerror(errno));
            return DNX_ERR_SEND;
         }
         return DNX_ERR_TIMEOUT;
      }
   }

   // convert the size into a network ushort
   mlen = (unsigned short)size;
   mlen = htons(mlen);

   // send the length of the message as a header
   if (write(itcp->socket, &mlen, sizeof mlen) != sizeof mlen)
      return DNX_ERR_SEND;

   // send the message
   if (write(itcp->socket, buf, size) != size)
      return DNX_ERR_SEND;

   return DNX_OK;
}

//----------------------------------------------------------------------------

static void dnxTcpDelete(iDnxChannel * icp)
{
   iDnxTcpChannel * itcp = (iDnxTcpChannel *)
         ((char *)icp - offsetof(iDnxTcpChannel, ichan));

   assert(icp && itcp->socket == 0);

   xfree(itcp->host);
   xfree(itcp);
}

//----------------------------------------------------------------------------

static int dnxTcpNew(char * url, iDnxChannel ** icpp)
{
   char * cp, * ep, * lastchar;
   iDnxTcpChannel * itcp;
   long port;

   assert(icpp && url && *url);

   // search for host:port in URL
   if ((cp = strstr(url, "://")) == 0)
      return DNX_ERR_BADURL;
   cp += 3;

   // find host/port separator ':' - copy host name
   if ((ep = strchr(cp, ':')) == 0 || ep == cp || ep - cp > HOST_NAME_MAX)
      return DNX_ERR_BADURL;

   // extract port number
   if ((port = strtol(ep + 1, &lastchar, 0)) < 1 || port > 65535
         || (*lastchar && *lastchar != '/'))
      return DNX_ERR_BADURL;

   // allocate a new iDnxTcpChannel object
   if ((itcp = (iDnxTcpChannel *)xmalloc(sizeof *itcp)) == 0)
      return DNX_ERR_MEMORY;
   memset(itcp, 0, sizeof *itcp);

   // save host name and port
   if ((itcp->host = (char *)xmalloc(ep - cp + 1)) == 0)
   {
      xfree(itcp);
      return DNX_ERR_MEMORY;
   }
   memcpy(itcp->host, cp, ep - cp);
   itcp->host[ep - cp] = 0;
   itcp->port = (int)port;

   // set I/O methods
   itcp->ichan.txOpen   = dnxTcpOpen;
   itcp->ichan.txClose  = dnxTcpClose;
   itcp->ichan.txRead   = dnxTcpRead;
   itcp->ichan.txWrite  = dnxTcpWrite;
   itcp->ichan.txDelete = dnxTcpDelete;

   *icpp = &itcp->ichan;

   return DNX_OK;
}

/*--------------------------------------------------------------------------
                           EXPORTED INTERFACE
  --------------------------------------------------------------------------*/

int dnxTcpInit(int (**ptxAlloc)(char * url, iDnxChannel ** icpp))
{
   DNX_PT_MUTEX_INIT(&tcpMutex);

   *ptxAlloc = dnxTcpNew;

   return DNX_OK;
}

//----------------------------------------------------------------------------

void dnxTcpDeInit(void)
{
   DNX_PT_MUTEX_DESTROY(&tcpMutex);
}

/*--------------------------------------------------------------------------*/