dnxUdp.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 "dnxUdp.h"
#include "dnxTSPI.h"

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

#include "dnxProtocol.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

typedef struct iDnxUdpChannel_
{
   char * host;         
   int port;            
   int socket;          
   DnxTransStats stats; 
   iDnxChannel ichan;   
} iDnxUdpChannel;

static pthread_mutex_t udpMutex;

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

static int dnxUdpOpen(iDnxChannel * icp, int mode)
{
   iDnxUdpChannel * iucp = (iDnxUdpChannel *)
         ((char *)icp - offsetof(iDnxUdpChannel, ichan));
   struct hostent * he;
   struct sockaddr_in inaddr;
   int sd;

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

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

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

      if (!he) return DNX_ERR_ADDRESS;
   }

   if ((sd = socket(AF_INET, SOCK_DGRAM, 0)) < 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)
   {
      struct sockaddr_in inaddr_any;

      // want to sometimes listen for incoming packets on this 
      // active channel also, so bind socket to any local address
      // (if not done, would happen anyway on first packet sent)
      memset(&inaddr_any, 0, sizeof inaddr_any);
      inaddr_any.sin_family = AF_INET;
      inaddr_any.sin_addr.s_addr = htonl(INADDR_ANY);
      if (bind(sd, (struct sockaddr *)&inaddr_any, sizeof inaddr_any) != 0)
      {
         close(sd);
         dnxLog("dnxUdpOpen: bind(any) failed: %s.", strerror(errno));
         return DNX_ERR_OPEN;
      }

      // for UDP, this sets the default destination address, so we can
      // now use send() and write() in addition to sendto() and sendmsg()
      // (also makes it impossible to specify sendto address or retrieve
      // sender address in recvfrom, but there's only one in either case)
      if (connect(sd, (struct sockaddr *)&inaddr, sizeof inaddr) != 0)
      {
         dnxLog("dnxUdpOpen: connect(%lx) failed: %s.",
               (unsigned long)inaddr.sin_addr.s_addr, strerror(errno));
         close(sd);
         return DNX_ERR_OPEN;
      }
   }
   else
   {
      struct linger lopt;
      int reuse = 1;

      lopt.l_onoff = 0;
      lopt.l_linger = 0;

      // reuse addr and clear linger to avoid tcp time_wait state issues
      setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof reuse);
      setsockopt(sd, SOL_SOCKET, SO_LINGER, &lopt, sizeof lopt);

      // want to listen for incoming packets, so bind to the
      // specified local address and port
      if (bind(sd, (struct sockaddr *)&inaddr, sizeof inaddr) != 0)
      {
         close(sd);
         dnxLog("dnxUdpOpen: bind(%lx) failed: %s.",
               (unsigned long)inaddr.sin_addr.s_addr, strerror(errno));
         return DNX_ERR_OPEN;
      }
   }

   iucp->socket = sd;

   return DNX_OK;
}

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

static int dnxUdpClose(iDnxChannel * icp)
{
   iDnxUdpChannel * iucp = (iDnxUdpChannel *)
         ((char *)icp - offsetof(iDnxUdpChannel, ichan));

   assert(icp && iucp->socket);

   close(iucp->socket);
   iucp->socket = 0;

   return DNX_OK;
}

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

static int dnxUdpRead(iDnxChannel * icp, char * buf, int * size, int timeout, char * src)
{
   iDnxUdpChannel * iucp = (iDnxUdpChannel *)((char *)icp - offsetof(iDnxUdpChannel, ichan));
   socklen_t slen = sizeof(struct sockaddr_storage);
   ssize_t mlen;

   assert(icp && iucp->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(iucp->socket, &fd_rds);

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

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

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

   // read the incoming message, use recvfrom only if address was requested
   if (src)
      mlen = recvfrom(iucp->socket, buf, *size, 0, (struct sockaddr *)src, &slen);
   else 
      mlen = read(iucp->socket, buf, *size);

   if (mlen < 0)
   {
      iucp->stats.rderrs++;

      // on "connected" UDP sockets, if the server can't be reached -
      // ICMP returned ICMP_UNREACH - we could get notified here.
      if (errno == ECONNREFUSED) return DNX_ERR_ADDRESS;

      dnxDebug(2, "UDP receive - %s socket failed: %s.", 
            src? "recvfrom unconnected": "read connected", strerror(errno));

      return DNX_ERR_RECEIVE;
   }

   iucp->stats.reads++;
   *size = (int)mlen;

   return DNX_OK;
}

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

static int dnxUdpWrite(iDnxChannel * icp, char * buf, int size, int timeout, char * dst)
{
   iDnxUdpChannel * iucp = (iDnxUdpChannel *) ((char *)icp - offsetof(iDnxUdpChannel, ichan));
   ssize_t mlen;

   assert(icp && iucp->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(iucp->socket, &fd_wrs);

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

      if ((nsd = select(iucp->socket + 1, 0, &fd_wrs, 0, &tv)) == 0)
         return DNX_ERR_TIMEOUT;
      if (nsd < 0)
      {
         if (errno != EINTR)
         {
            dnxLog("UDP send - select failed: %s.", strerror(errno));
            return DNX_ERR_SEND;
         }
         return DNX_ERR_TIMEOUT;
      }
   }

   // specify destination address for passive, server-side sockets only
   if (dst)
   {
      struct sockaddr * sa = (struct sockaddr *)dst;
      mlen = sendto(iucp->socket, buf, size, 0, sa, sa->sa_family == AF_INET?
            sizeof(struct sockaddr_in): sizeof(struct sockaddr_in6));
   }
   else
      mlen = write(iucp->socket, buf, size);

   if (mlen < 0)
   {
      iucp->stats.wrerrs++;
      dnxDebug(2, "UDP send - %s socket failed: %s.", 
            dst? "sendto unconnected": "write connected", strerror(errno));
      return DNX_ERR_SEND;
   }

   iucp->stats.writes++;

   return DNX_OK;
}

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

static void dnxUdpDelete(iDnxChannel * icp)
{
   iDnxUdpChannel * iucp = (iDnxUdpChannel *)
         ((char *)icp - offsetof(iDnxUdpChannel, ichan));

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

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

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

static void dnxUdpGetStats(iDnxChannel * icp, DnxTransStats * tsp)
{
   iDnxUdpChannel * iucp = (iDnxUdpChannel *)
         ((char *)icp - offsetof(iDnxUdpChannel, ichan));

   assert(icp && tsp);

   *tsp = iucp->stats;
}

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

static void dnxUdpResetStats(iDnxChannel * icp)
{
   iDnxUdpChannel * iucp = (iDnxUdpChannel *)
         ((char *)icp - offsetof(iDnxUdpChannel, ichan));

   assert(icp);

   memset(&iucp->stats, 0, sizeof iucp->stats);
}

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

static int dnxUdpNew(char * url, iDnxChannel ** icpp)
{
   char * cp, * ep, * lastchar;
   iDnxUdpChannel * iucp = NULL;
   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;

    if(iucp)
        xfree(iucp);

   // allocate a new iDnxUdpChannel object
    if ((iucp = (iDnxUdpChannel *)xcalloc(1,sizeof *iucp)) == 0)
    {
        return DNX_ERR_MEMORY;
    }


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

   // set I/O methods
   iucp->ichan.txOpen         = dnxUdpOpen;
   iucp->ichan.txClose        = dnxUdpClose;
   iucp->ichan.txRead         = dnxUdpRead;
   iucp->ichan.txWrite        = dnxUdpWrite;
   iucp->ichan.txDelete       = dnxUdpDelete;
   iucp->ichan.txGetStats     = dnxUdpGetStats;
   iucp->ichan.txResetStats   = dnxUdpResetStats;
   *icpp = &iucp->ichan;

   return DNX_OK;
}

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

int dnxUdpInit(int (**ptxAlloc)(char * url, iDnxChannel ** icpp))
{
   DNX_PT_MUTEX_INIT(&udpMutex);

   *ptxAlloc = dnxUdpNew;

   return DNX_OK;
}

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

void dnxUdpDeInit(void)
{
   DNX_PT_MUTEX_DESTROY(&udpMutex);
}

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