libxdas_net.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 * Copyright (c) 2006, Novell, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are 
 * met:
 * 
 *     * Redistributions of source code must retain the above copyright 
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright 
 *       notice, this list of conditions and the following disclaimer in the 
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Novell nor the names of its contributors 
 *       may be used to endorse or promote products derived from this 
 *       software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *--------------------------------------------------------------------------*/

#include <xdas.h>
#include <xdasd.h>
#include <xdas_buf.h>
#include <xdas_wire.h>
#include <xdas_debug.h>

#include "libxdas_impl.h"

#include <errno.h>
#include <stdio.h>

#ifdef _WIN32
/* map WSA error codes to unix names */
# define EWOULDBLOCK        WSAEWOULDBLOCK
# define EINPROGRESS        WSAEINPROGRESS
# define EALREADY           WSAEALREADY
# define ENOTSOCK           WSAENOTSOCK
# define EDESTADDRREQ       WSAEDESTADDRREQ
# define EMSGSIZE           WSAEMSGSIZE
# define EPROTOTYPE         WSAEPROTOTYPE
# define ENOPROTOOPT        WSAENOPROTOOPT
# define EPROTONOSUPPORT    WSAEPROTONOSUPPORT
# define ESOCKTNOSUPPORT    WSAESOCKTNOSUPPORT
# define EOPNOTSUPP         WSAEOPNOTSUPP
# define EPFNOSUPPORT       WSAEPFNOSUPPORT
# define EAFNOSUPPORT       WSAEAFNOSUPPORT
# define EADDRINUSE         WSAEADDRINUSE
# define EADDRNOTAVAIL      WSAEADDRNOTAVAIL
# define ENETDOWN           WSAENETDOWN
# define ENETUNREACH        WSAENETUNREACH
# define ENETRESET          WSAENETRESET
# define ECONNABORTED       WSAECONNABORTED
# define ECONNRESET         WSAECONNRESET
# define ENOBUFS            WSAENOBUFS
# define EISCONN            WSAEISCONN
# define ENOTCONN           WSAENOTCONN
# define ESHUTDOWN          WSAESHUTDOWN
# define ETOOMANYREFS       WSAETOOMANYREFS
# define ETIMEDOUT          WSAETIMEDOUT
# define ECONNREFUSED       WSAECONNREFUSED
# define ELOOP              WSAELOOP
# define EHOSTDOWN          WSAEHOSTDOWN
# define EHOSTUNREACH       WSAEHOSTUNREACH
# define EREMOTE            WSAEREMOTE
#else
# include <sys/un.h>
#endif

#ifndef _WIN32

static void xdas_get_ipcpath(char * ipcpath, size_t ipcpathsz)
{
#define UNIT_TEST_RUN_PATH_ENVAR "XDAS_UNIT_TEST_RUN_PATH"

   char * runpath = getenv(UNIT_TEST_RUN_PATH_ENVAR);
   if (runpath == 0)
      snprintf(ipcpath, ipcpathsz, XDASD_RUNPATH "/xdasd.ipc");
   else
   {
      snprintf(ipcpath, ipcpathsz, "%s/xdasd.ipc", runpath);
      printf("LIBXDAS: Using dynamic ipc path: %s.\n", ipcpath);
   }
}
#endif

static int xdas_map_network_error_to_minor(void)
{
#ifdef _WIN32
   int err = WSAGetLastError();
#else
   int err = errno;
#endif
   switch(err)
   {
      case 0:                 return 0;

      case ENOTSOCK:          return OXDAS_MS_NET_BAD_SOCKET;
      case ECONNABORTED:      return OXDAS_MS_NET_CONN_ABORTED;
      case ECONNRESET:        return OXDAS_MS_NET_CONN_RESET;
      case ENOTCONN:          return OXDAS_MS_NET_NOT_CONNECTED;
      case ESHUTDOWN:         return OXDAS_MS_NET_SHUTDOWN;
      case ETIMEDOUT:         return OXDAS_MS_NET_TIMEDOUT;
      case ECONNREFUSED:      return OXDAS_MS_NET_CONN_REFUSED;

      case EWOULDBLOCK:
      case EINPROGRESS:
      case EALREADY:
      case EDESTADDRREQ:
      case EMSGSIZE:
      case EPROTOTYPE:
      case ENOPROTOOPT:
      case EPROTONOSUPPORT:   
      case ESOCKTNOSUPPORT:
      case EOPNOTSUPP:
      case EPFNOSUPPORT:
      case EAFNOSUPPORT:
      case EADDRINUSE:
      case EADDRNOTAVAIL:
      case ENETDOWN:
      case ENETUNREACH:
      case ENETRESET:
      case ENOBUFS:
      case EISCONN:
      case ETOOMANYREFS:
      case ELOOP:
      case EHOSTDOWN:
      case EHOSTUNREACH:
      case EREMOTE:
         break;
   }
   return OXDAS_MS_NET_GENERAL_ERROR;
}

void xdas_service_disconnect(xdas_session * xs)
{
   if (xs->s != BAD_SOCKET)
   {
      closesocket(xs->s);
      xs->s = BAD_SOCKET;
   }
}

int xdas_service_connect(int * minor, xdas_session * xs)
{
   struct sockaddr_storage ss;
   int addrsz;

   memset(&ss, 0, sizeof(ss));

#ifdef _WIN32
   {
      struct sockaddr_in * v4 = (struct sockaddr_in *)&ss;
      v4->sin_family = AF_INET;
      v4->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
      v4->sin_port = htons(XDASD_RESERVED_PORT);
      addrsz = sizeof(*v4);
   }
#else
   {
      struct sockaddr_un * ud = (struct sockaddr_un *)&ss;

      static char ipcpath[FILENAME_MAX] = "";
      if (*ipcpath == 0) 
         xdas_get_ipcpath(ipcpath, sizeof(ipcpath));

      ud->sun_family = AF_LOCAL;
      strncpy(ud->sun_path, ipcpath, sizeof(ud->sun_path));
      addrsz = sizeof(*ud);
   }
#endif

   /* close existing connection if open */
   xdas_service_disconnect(xs);

   /* connect to xdasd */
   xs->s = socket(ss.ss_family, SOCK_STREAM, 0);
   if (connect(xs->s, (struct sockaddr *)&ss, addrsz) < 0)
   {
      *minor = xdas_map_network_error_to_minor();
      return XDAS_S_FAILURE;
   }
   return 0;
}

int xdas_req_rsp(int * minorp, xdas_session * xs)
{
   char peek[4];
   int scode, rspsz, bytes;
   xdas_buffer rsp;

   /* basic sanity check on parameters */
   xdas_assert(minorp && xs && xs->req);
   if (!minorp || !xs || !xs->req)
      return -1;

   /* establish connection if it was previously closed */
   if (xs->s == BAD_SOCKET 
         && (scode = xdas_service_connect(minorp, xs)) != 0)
      return scode;

   /* send pre-configured request buffer */
   if ((bytes = send(xs->s, xs->req->start, 
         (int)(xs->req->curpos - xs->req->start), 0)) < 0)
      return (*minorp = xdas_map_network_error_to_minor()), XDAS_S_FAILURE;

   /* Peek at return buffer header for buffer size. */
   bytes = recv(xs->s, peek, sizeof(peek), MSG_PEEK);
   xdas_assert(bytes < 0 || bytes == sizeof(peek));
   if (bytes < 0)
      return (*minorp = xdas_map_network_error_to_minor()), XDAS_S_FAILURE;

   rspsz = (int)AS_UINT32(peek);

   /* no xdasd response should be greater than 4k, and all xdasd responses 
      should have at least 12 bytes - size, scode, and minor status */
   xdas_assert(rspsz >= 12 && rspsz < 4096);

   if ((rsp = xdas_buffer_realloc(xs->rsp, rspsz)) == 0)
      return (*minorp = OXDAS_MS_OUT_OF_MEMORY), XDAS_S_FAILURE;
   rsp->curpos = rsp->start;
   xs->rsp = rsp;

   /* read till we have it all, or an error occurs */
   while (rspsz && (bytes = recv(xs->s, rsp->curpos, rspsz, 0)) > 0)
   {
      rsp->curpos += bytes;
      rspsz -= bytes;
   }

   /* check for error condition (or socket closed) from loop */
   if (bytes <= 0)
      return (*minorp = xdas_map_network_error_to_minor()), XDAS_S_FAILURE;

   /* parse response buffer for error codes */
   rsp->curpos = rsp->start + 4; /* skip rspsz this time */
   scode = (int)xdas_buffer_get_uint32(rsp);
   *minorp = (int)xdas_buffer_get_uint32(rsp);

   return scode;
}