sics/ascon.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include "sics.h"
#include "splitter.h"
#include "ascon.i"
#include "uselect.h"

static double lastClose = 0; /* time of last close operation */

/*
     CreateSocketAdress stolen from Tcl. Thanks to John Ousterhout
*/

static int CreateSocketAdress(struct sockaddr_in *sockaddrPtr,  /* Socket address */
                              char *host,       /* Host.  NULL implies INADDR_ANY */
                              int port)
{                               /* Port number */
  struct hostent *hostent;      /* Host database entry */
  struct in_addr addr;          /* For 64/32 bit madness */

  (void) memset((char *) sockaddrPtr, '\0', sizeof(struct sockaddr_in));
  sockaddrPtr->sin_family = AF_INET;
  sockaddrPtr->sin_port = htons((unsigned short) (port & 0xFFFF));
  if (host == NULL) {
    addr.s_addr = INADDR_ANY;
  } else {
    hostent = gethostbyname(host);
    if (hostent != NULL) {
      memcpy((char *) &addr,
             (char *) hostent->h_addr_list[0], (size_t) hostent->h_length);
    } else {
      addr.s_addr = inet_addr(host);
      if (addr.s_addr == (unsigned long) -1) {
        return 0;               /* error */
      }
    }
  }
  /*
   * There is a rumor that this assignment may require care on
   * some 64 bit machines.
   */
  sockaddrPtr->sin_addr.s_addr = addr.s_addr;
  return 1;
}

double DoubleTime(void)
{
  struct timeval now;
  /* the resolution of this function is usec, if the machine supports this
     and the mantissa of a double is 51 bits or more (31 for sec and 20 for micro)
   */
  gettimeofday(&now, NULL);
  return now.tv_sec + now.tv_usec / 1e6;
}

void AsconError(Ascon *a, char *msg, int errorno)
{
  static char *stateText[]={
    "state 0", "state 1", "state 2", "notConnected",
    "connect", "start connect", "connect finished", "connect failed", 
    "write", "start write", "write finished", "write failed", 
    "read", "start read", "read finished", "read failed", 
    "state 16", "state 17", "state 18", "idle"
  };
  char *state;

  if (a->state < 0 || a->state > 19) {
    state = "bad state";
  } else {
    state = stateText[a->state];
  }
  DynStringCopy(a->errmsg, "ASCERR: ");
  if (errorno == 0) {
    DynStringConcat(a->errmsg, msg);
    DynStringConcat(a->errmsg, " (");
    DynStringConcat(a->errmsg, state);
    DynStringConcat(a->errmsg, " state)");
  } else {
    DynStringConcat(a->errmsg, strerror(errorno));
    DynStringConcat(a->errmsg, " (");
    DynStringConcat(a->errmsg, state);
    DynStringConcat(a->errmsg, " state, ");
    DynStringConcat(a->errmsg, msg);
    DynStringConcat(a->errmsg, ")");
  }
  a->state |= AsconFailed;
}

static void AsconConnect(Ascon * a)
{
  /* input state: AsconConnectStart
     output state: AsconFailed or AsconConnecting */
  int ret;
  struct sockaddr_in adr;
  char *colon;
  int port;
  int oldopts;
  
  /* wait 0.5 sec before connecting again after a close
     2 reasons for that:
     - it seems that connecting immediately to a closed port fails.
       We will avoid some "Connection refused" error messages.
     - a bug in the lantronix terminal: if a channel is closed and reopened
       within short time the connect may be succesful, but a message will be
       sent on the channel!
     In principle we need only to wait when connecting to the same address
     and port, but bookkeeping would be too complicated.
     */
  if (DoubleTime() < lastClose + 0.5) return;

  if (a->fd < 0) {
    a->fd = socket(AF_INET, SOCK_STREAM, 0);
    if (a->fd < 0) {
      AsconError(a, "ASC1", errno);
      return;
    }
  }
  colon = strchr(a->hostport, ':');
  if (colon == NULL)
    return;
  port = atoi(colon + 1);
  if (port <= 0) {
    AsconError(a, "bad port number", 0);
    return;
  }
  *colon = '\0';
  ret = CreateSocketAdress(&adr, a->hostport, port);
  *colon = ':';
  if (ret == 0) {
    AsconError(a, "bad host specification", 0);
    return;
  }
  oldopts = fcntl(a->fd, F_GETFL, 0);
  fcntl(a->fd, F_SETFL, oldopts | O_NONBLOCK);
  ret =
      connect(a->fd, (struct sockaddr *) &adr, sizeof(struct sockaddr_in));
  if (ret < 0) {
    switch(errno) {
    case EINPROGRESS:
    case EALREADY:
    case EISCONN:
      a->state = AsconConnecting;
      break;
    default:
      AsconError(a, "ASC2", errno);
      return;
    }
  }
  a->state = AsconConnecting;
  return;
}

int AsconStdInit(Ascon *a, SConnection *con, int argc, char *argv[])
{
  a->fd = -1;
  a->state = AsconConnectStart;
  a->hostport = strdup(argv[1]);
  if (argc > 2) {
    a->sendTerminator = strdup(argv[2]);
  } else {
    a->sendTerminator = strdup("\n");
  }
  if (argc > 3) {
    a->timeout = atof(argv[3]);
  } else {
    a->timeout = 2.0; /* sec */
  }
  a->replyTerminator == NULL;
  if (argc > 4 && argv[4][0] != '\0') {
    a->replyTerminator = strdup(argv[4]);
  }
  return 1;
}

int AsconReadGarbage(int fd)
{
  fd_set rmask;
  struct timeval tmo = { 0, 0 };
  int l, ret, result;
  char garbage[100];

  FD_ZERO(&rmask);
  result = 0;
  do {
    FD_SET(fd, &rmask);
    ret = uselect(fd + 1, &rmask, NULL, NULL, &tmo);
    if (ret > 0) {
      l = recv(fd, garbage, sizeof garbage - 1, 0);
      if (l > 0) {
        /* swallow */
        garbage[l] = '\0';
        printf("(((%s)))\n", garbage);
        result += l;
      } else if (l == 0) {
        errno = ECONNRESET;
        return -2;
      } else if (l < 0) {
        return -2;
      }
    }
  } while (ret > 0);
  return result;
}

void PrintChar(char chr)
{
  if (chr <= 32 || chr >= 127) {
    printf("%2.2x ", chr);
  } else {
    printf(" %c ", chr);
  }
}

int AsconConnectSuccess(int fd)
{
  fd_set wmask, rmask;
  struct timeval tmo = { 0, 0 };
  int oldopts;
  int ret;

  oldopts = fcntl(fd, F_GETFL, 0);
  assert(oldopts | O_NONBLOCK); /* fd must be in non-blocking mode */

  FD_ZERO(&wmask);
  FD_ZERO(&rmask);
  FD_SET(fd, &wmask);
  FD_SET(fd, &rmask);
  ret = uselect(fd + 1, &rmask, &wmask, NULL, &tmo);
  if (ret > 0) {
    assert(FD_ISSET(fd, &wmask));
    if (FD_ISSET(fd, &rmask)) { /* there may already be data for read */
      if (recv(fd, NULL, 0, 0) < 0) {   /* zero length, check only return value */
        ret = ASCON_RECV_ERROR; /* first recv failed */
      }
    } else {
      if (send(fd, NULL, 0, 0) < 0) {   /* zero length, check only return value */
        ret = ASCON_SEND_ERROR; /* first send failed */
      }
    }
  }
  fcntl(fd, F_SETFL, oldopts & ~O_NONBLOCK);    /* reset to blocking mode */
  return ret;
}

int AsconReadChar(int fd, char *chr)
{
  fd_set rmask;
  struct timeval tmo = { 0, 0 };
  int ret;

  FD_ZERO(&rmask);
  FD_SET(fd, &rmask);
  ret = uselect(fd + 1, &rmask, NULL, NULL, &tmo);
  if (ret <= 0)
    return ret;
  ret = recv(fd, chr, 1, 0);
  /* PrintChar(*chr); */
  fflush(stdout);
  if (ret > 0)
    return 1;
  if (ret == 0) {
    errno = ECONNRESET;
    return ASCON_DISCONNECTED;
  }
  return ASCON_RECV_ERROR;
}

int AsconWriteChars(int fd, char *data, int length)
{
  fd_set wmask;
  struct timeval tmo = { 0, 0 };
  int ret;

  if (length <= 0)
    return 0;
  /*
     { int i;
     for (i=0; i<length; i++) {
     PrintChar(data[i]);
     }
     }
     printf("<written\n");
   */
  FD_ZERO(&wmask);
  FD_SET(fd, &wmask);
  ret = uselect(fd + 1, NULL, &wmask, NULL, &tmo);
  if (ret <= 0)
    return ASCON_SELECT_ERROR;
  ret = send(fd, data, length, 0);
  if (ret > 0)
    return ret;
  if (ret == 0) {
    errno = ECONNRESET;
    return ASCON_DISCONNECTED;
  }
  return ASCON_SEND_ERROR;
}

static double lastCall = 0;

int AsconStdHandler(Ascon * a)
{
  int ret;
  int l;
  char chr;
  double now = DoubleTime();

  if (now > lastCall + 0.5) {   /* AsconStdHandler was not called since a long time (0.5 sec) */
    if (lastCall != 0) {        /* extend timeout time (for debugging purposes) */
      a->start += now - lastCall - 0.5;
    }
  }
  lastCall = now;
  switch (a->state) {
  case AsconConnectStart:
    AsconConnect(a);
    break;
  case AsconConnecting:
    ret = AsconConnectSuccess(a->fd);
    if (ret == 0) {
      /* in progress */
    } else if (ret > 0) {
      a->state = AsconConnectDone;      /* success */
    } else if (ret < 0) {
      AsconError(a, "ASC3", errno);
    }
    break;
  case AsconWriteStart:
    if (strstr(GetCharArray(a->wrBuffer), "@@NOSEND@@") != NULL) {
      a->state = AsconWriteDone;
    } else {
      DynStringConcat(a->wrBuffer, a->sendTerminator);
      a->wrPos = 0;
      a->state = AsconWriting;
    }
    break;
  case AsconWriting:
    if (a->readState) { /* last char was CR */
      ret = AsconReadChar(a->fd, &chr);
      if (ret > 0) {
        if (chr == '\n') {
          /* swallow LF after CR */
          a->readState = 0;
        } else {
          /* garbage character found */
        }
      }
    }
    AsconReadGarbage(a->fd);
    l = GetDynStringLength(a->wrBuffer) - a->wrPos;
    ret = AsconWriteChars(a->fd, GetCharArray(a->wrBuffer) + a->wrPos, l);
    if (ret < 0) {
      AsconError(a, "ASC4", errno);
      /*
       * Ooops: which state shall we go to after a write fail?
       * This seems to retry.
       */
    } else {
      a->wrPos += ret;
      if (a->wrPos >= GetDynStringLength(a->wrBuffer)) {
        a->state = AsconWriteDone;
      }
    }
    break;
  case AsconReadStart:
    DynStringClear(a->rdBuffer);
    a->start = DoubleTime();
    a->state = AsconReading;
    break;
  case AsconReading:
    ret = AsconReadChar(a->fd, &chr);
    while (ret > 0) {
      a->start = DoubleTime();
      
      if (a->replyTerminator != NULL) {
        if (strchr(a->replyTerminator, chr) != NULL) {
          DynStringConcatChar(a->rdBuffer, chr);
          DynStringConcatChar(a->rdBuffer, '\0');
          a->state = AsconReadDone;
          break;
        }
      } else {
        if (chr == '\n') {
          if (a->readState) { /* last char was CR */
            /* swallow LF after CR */
            a->readState = 0;
            chr = 0;
          } else {
            DynStringConcatChar(a->rdBuffer, '\0');
            a->state = AsconReadDone;
            break;
          }
        } else if (chr == '\r') {
          a->readState = 1; /* set 'last char was CR' */
          DynStringConcatChar(a->rdBuffer, '\0');
          a->state = AsconReadDone;
          break;
        }
      }
      if (chr != 0) {
        if (DynStringConcatChar(a->rdBuffer, chr) == 0) {
          AsconError(a, "DynStringConcatChar failed:", ENOMEM);
          break;
        }
        a->readState = 0;
      }
      ret = AsconReadChar(a->fd, &chr);
    }
    if (ret < 0) {
      /* EINTR means we shall retry */
      if (errno != EINTR && errno != EAGAIN) {
        AsconError(a, "ASC5", errno);
      }
      return 1;
    }
    if (a->state == AsconReadDone) {
      DynStringConcatChar(a->rdBuffer, '\0');
    } else {
      if (a->timeout > 0) {
        if (DoubleTime() - a->start > a->timeout) {
          AsconError(a, "no response", 0);
          a->state = AsconTimeout;
        }
      }
    }
    break;
  default:
    break;
  }  
  return 1;
}

static AsconProtocol *protocols = NULL;

void AsconInsertProtocol(AsconProtocol *protocol) {
  protocol->next = protocols;
  protocols = protocol;
}

AsconHandler AsconSetHandler(Ascon *a, SConnection *con,
                             int argc, char *argv[])
{
  AsconProtocol *p;

  if (argc < 1)
    return NULL;
  if (strcasecmp(argv[0], "std") == 0) {
    if (argc < 2)
      return NULL;
    AsconStdInit(a, con, argc, argv);
    return AsconStdHandler;
  }
  for (p = protocols; p!= NULL; p=p->next) {
    if (strcasecmp(p->name, argv[0]) == 0) {
      if (p->init(a, con, argc, argv)) {
        return p->handler;
      } else {
        return NULL;
      }
    }
  }
  return NULL;
}

/* --- implementation of higher level interface ---- */

char *ConcatArgs(int argc, char *argv[])
{
  return Arg2Tcl(argc, argv, NULL, -1);
}

Ascon *AsconMake(SConnection * con, int argc, char *argv[])
{
  Ascon *a;
  char *args;

  a = calloc(1, sizeof(*a));
  if (a == NULL) {
    SCWrite(con, "ERROR: no memory", eError);
    return NULL;
  }
  a->handler = AsconSetHandler(a, con, argc, argv);
  if (a->handler == NULL) {
    args = ConcatArgs(argc, argv);
    if (!args)
      return NULL;
    SCPrintf(con, eError, "ERROR: illegal protocol: %s", args);
    free(args);
    return NULL;
  }
  a->rdBuffer = CreateDynString(60, 63);
  a->wrBuffer = CreateDynString(60, 63);
  a->errmsg   = CreateDynString(60, 63);
  a->responseValid = 0;
  return a;
}

void AsconKill(Ascon * a)
{
  if (a->fd > 0) {
    close(a->fd);
    lastClose = DoubleTime();
  }
  DeleteDynString(a->rdBuffer);
  DeleteDynString(a->wrBuffer);
  DeleteDynString(a->errmsg);
  if (a->hostport) {
    free(a->hostport);
  }
  if(a->sendTerminator){
    free(a->sendTerminator);
  }
  if(a->replyTerminator){
    free(a->replyTerminator);
  }
  if (a->private != NULL && a->killPrivate != NULL) {
    a->killPrivate(a->private);
  }
  free(a);
}

void AsconDisconnect(Ascon * a)
{
  if (a->fd > 0) {
    close(a->fd);
  }
  a->fd = -1;
  a->state = AsconConnectStart;
}

AsconStatus AsconTask(Ascon * a)
{
  double now;

  while (a->handler(a)) {
    switch (a->state) {
    case AsconReading:
    case AsconWriting:
      return AsconPending;
    case AsconNotConnected:
      return AsconOffline;
      break;
    case AsconConnectDone:
      a->state = AsconIdle;
      return AsconReady;
    case AsconWriteDone:
      if (a->noResponse) {
        return AsconReady;
      }
      a->state = AsconReadStart;
      break;
    case AsconReadDone:
      a->state = AsconIdle;
      a->responseValid = 1;
      return AsconReady;
    case AsconConnecting:
      return AsconUnconnected;
    default:
      switch (a->state % 4) {
      case AsconOnTheWay:
      case AsconStart:
        return AsconPending;
      case AsconFailed:
        if (a->state == AsconTimeout) {
          a->state = AsconIdle;
        } else {
          close(a->fd);
          lastClose = DoubleTime();
          a->fd = -1;
          a->state = AsconConnectStart;
        }
        
        return AsconFailure;
      case AsconFinished:
        if (a->state < AsconConnectFailed) {
          return AsconUnconnected;
        }
        return AsconReady;
      }
    }
  }
  return AsconIdle;
}

int AsconWrite(Ascon * a, char *command, int noResponse)
{
  if (a->state <= AsconConnectFailed || a->state % 4 < AsconFinished)
    return 0;
  DynStringCopy(a->wrBuffer, command);
  a->noResponse = noResponse;
  a->state = AsconWriteStart;
  a->responseValid = 0;
  AsconTask(a);
  return 1;
}

char *AsconRead(Ascon * a)
{
  if (a->noResponse) {
    a->noResponse = 0;
    return "";
  }
  if (a->state % 4 == AsconFailed) {
    a->state = AsconIdle;
    return "";
  }
  if (a->responseValid) {
    a->responseValid = 0;
    return GetCharArray(a->rdBuffer);
  }
  return NULL;
}

char *AsconGetError(Ascon *a)
{
  return GetCharArray(a->errmsg);
}