From 68ec926a8b67511879e09197f60a2bf8b1b06944 Mon Sep 17 00:00:00 2001
From: zolliker <zolliker>
Date: Fri, 18 Jan 2008 07:55:58 +0000
Subject: [PATCH] - introduce script context

---
 ascon.c         |  493 ++++++++++++++++
 ascon.h         |   81 +++
 ascon.i         |  143 +++++
 errormsg.c      |   63 ++
 errormsg.h      |   30 +
 make_gen        |    1 +
 mclist.c        |  116 ++++
 mclist.h        |  177 ++++++
 ofac.c          |    1 +
 scriptcontext.c | 1458 +++++++++++++++++++++++++++++++++++++++++++++++
 10 files changed, 2563 insertions(+)
 create mode 100644 ascon.c
 create mode 100644 ascon.h
 create mode 100644 ascon.i
 create mode 100644 errormsg.c
 create mode 100644 errormsg.h
 create mode 100644 mclist.c
 create mode 100644 mclist.h
 create mode 100644 scriptcontext.c

diff --git a/ascon.c b/ascon.c
new file mode 100644
index 00000000..4bc2eb2d
--- /dev/null
+++ b/ascon.c
@@ -0,0 +1,493 @@
+#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"
+
+/*
+     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;
+  
+  gettimeofday(&now, NULL);
+  return now.tv_sec + now.tv_usec / 1e6;
+}
+
+static void AsconError(AsconPtr a, char *msg, int errorno) {
+  static char *stateText[]={
+    "state 0", "kill", "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];
+  }
+  if (errorno != 0) {
+    ErrPutMsg(&a->errList, NULL, "%s %s (during %s)", msg, strerror(errorno), state);
+  } else {
+    ErrPutMsg(&a->errList, NULL, "%s (during %s)", msg, state);
+  }
+  a->state |= AsconFailed;
+}
+
+static void AsconConnect(AsconPtr a) {
+  /* input state: AsconConnectStart
+     output state: AsconFailed or AsconConnecting */
+  int ret;
+  struct sockaddr_in adr;
+  char *colon;
+  int port;
+  int oldopts;
+  
+  if (a->fd < 0) {
+    a->fd = socket(AF_INET,SOCK_STREAM,0);
+    if (a->fd < 0) {
+      AsconError(a, "socket failed:", 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;
+  }
+  /* should we insert the workaround for lantronix server ? see network.c */
+  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) {
+    if (errno != EINPROGRESS) {
+      AsconError(a, "connect failed:", errno);
+      return;
+    }
+  }
+  a->state = AsconConnecting;
+  return;
+}
+
+void AsconStdInit(AsconPtr a, char *hostport) {
+  a->fd = -1;
+  a->state = AsconConnectStart;
+  a->timeout = 2.0; /* sec */
+  a->hostport = strdup(hostport);
+}
+
+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 = select(fd + 1, &rmask, NULL, NULL, &tmo);
+    if (ret > 0) {
+      l = recv(fd, garbage, sizeof garbage, 0);
+      if (l > 0) {
+        /* swallow */
+        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 = select(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 = select(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 = select(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(AsconPtr 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 AsconKillMe: return 0;
+  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, "AsconConnectSuccess failed:", errno);
+    }
+    break;
+  case AsconWriteStart:
+    DynStringConcatChar(a->wrBuffer, '\r');
+    a->wrPos = 0;
+    a->state = AsconWriting;
+    break;
+  case AsconWriting:
+    AsconReadGarbage(a->fd);
+    l = GetDynStringLength(a->wrBuffer) - a->wrPos;
+    ret = AsconWriteChars(a->fd, GetCharArray(a->wrBuffer) + a->wrPos, l);
+    if (ret < 0) {
+      AsconError(a, "send failed:", errno);
+    } 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 (chr == '\n') {
+        if (a->readState) {
+          /* swallow LF after CR */
+          DynStringClear(a->rdBuffer);
+          a->readState = 0;
+        } else {
+          DynStringConcatChar(a->rdBuffer, '\0');
+          a->state = AsconReadDone;
+          break;
+        }
+      } else if (chr == '\r') {
+        a->readState = 1;
+        DynStringConcatChar(a->rdBuffer, '\0');
+        a->state = AsconReadDone;
+        break;
+      } else {
+        if (DynStringConcatChar(a->rdBuffer, chr) == 0) {
+          AsconError(a, "DynStringConcatChar failed:", ENOMEM);
+          break;
+        }
+        a->readState = 0;
+      }
+      ret = AsconReadChar(a->fd, &chr);
+    }
+    if (ret < 0) {
+      AsconError(a, "AsconReadChar failed:", errno);
+      return 1;
+    }
+    if (a->state == AsconReadDone) {
+      DynStringConcatChar(a->rdBuffer, '\0');
+    } else {
+      if (a->timeout > 0) {
+        if (DoubleTime() - a->start > a->timeout) {
+          AsconError(a, "read timeout", 0);
+        }
+      }
+    }
+    break;
+  default:
+    return 1;
+  }  
+  return 1;
+}
+
+/* define type AsconProtocolList and functions AsconProtocolAdd etc. */
+#define MC_NAME(T) AsconProtocol##T
+#include "mclist.c"
+
+static AsconProtocolList protocols={0};
+
+void AsconInsertProtocol(AsconProtocol *protocol) {
+  AsconProtocolAdd(&protocols, protocol);
+}
+
+AsconHandler AsconSetHandler(AsconPtr a, int argc, char *argv[]) {
+  AsconProtocol *p;
+  
+  if (argc < 1) return NULL;
+  if (strcasecmp(argv[0], "std") == 0) {
+    if (argc != 2) return NULL;
+    AsconStdInit(a, argv[1]);
+    return AsconStdHandler;
+  }
+  for (p = protocols.head; p!= NULL; p=p->next) {
+    if (strcasecmp(p->name, argv[0]) == 0) {
+      p->init(a, argc, argv);
+      return p->handler;
+    }
+  }
+  return NULL;
+}
+
+/* --- implementation of higher level interface ---- */
+
+char *ConcatArgs(int argc, char *argv[]) {
+  return Arg2Tcl(argc, argv, NULL, -1);
+}
+
+AsconPtr AsconMake(SConnection *con, int argc, char *argv[]) {
+  AsconPtr a;
+  char *args;
+  
+  a = calloc(1, sizeof(*a));
+  if (a == NULL) {
+    SCWrite(con, "ERROR: no memory", eError);
+    return NULL;
+  }
+  a->handler = AsconSetHandler(a, 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->errList.head = NULL;
+  a->responseValid = 0;
+  return a;
+}
+
+void AsconKill(AsconPtr a) {
+  a->state = AsconKillMe;
+  a->handler(a);
+  if (a->fd > 0) {
+    close(a->fd);
+  }
+  DeleteDynString(a->rdBuffer);
+  DeleteDynString(a->wrBuffer);
+  if (a->hostport) {
+    free(a->hostport);
+  }
+  free(a);
+}
+
+AsconState AsconTask(AsconPtr a) {  
+  a->handler(a);
+  while (1) {
+    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 <= AsconConnectFailed) {
+          return AsconUnconnected;
+        }
+        return AsconFailure;
+      case AsconFinished:
+        if (a->state < AsconConnectFailed) {
+          return AsconUnconnected;
+        }
+        return AsconReady;
+      }
+    }
+    a->handler(a);
+  }
+}
+
+int AsconWrite(AsconPtr 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(AsconPtr 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;
+}
+
+ErrMsgList *AsconGetErrList(AsconPtr a) {
+  return &a->errList;
+}
diff --git a/ascon.h b/ascon.h
new file mode 100644
index 00000000..55ae33ae
--- /dev/null
+++ b/ascon.h
@@ -0,0 +1,81 @@
+#ifndef ASCON_H
+#define ASCON_H
+
+#include "errormsg.h"
+
+/** \file
+ * \brief Asynchronous connection handling for devices controlled over tcp-ip
+ * connections. Interface for higher level modules.
+ */
+ 
+/** \brief the asynchronous connection
+ */
+typedef struct Ascon *AsconPtr;
+
+/** \brief the possible results of AsconTask
+ */
+typedef enum {
+  AsconOffline,
+  AsconUnconnected,
+  AsconPending,
+  AsconReady,
+  AsconFailure
+} AsconStatus;
+
+/** \brief make a new asynchronous connection
+ *  \param con the SICS connection
+ *  \param argc number of arguments
+ *  \param argv the arguments. argv[0] must be the protocol name, the other arguments
+ *     are protocol specific, but argv[1] is usually host::port
+ *  \return the created connection or NULL on failure
+ */
+AsconPtr AsconMake(SConnection *con, int argc, char *argv[]);
+
+/** \brief kill function
+ *  \param a the connection to be killed
+ */
+void AsconKill(AsconPtr a);
+
+/** \brief the task handler. To be called repeatedly.
+ *  \param a the connection
+ *  \return the state of the connection
+ */ 
+AsconStatus AsconTask(AsconPtr a);
+
+/** \brief write to the connection. allowed only when the state is ascon_ready
+ *  \param a the connection
+ *  \param command the command to be sent
+ *  \param noResponse 0 normally, 1 if no reponse is expected
+ *  \return 1 on success, 0 when not ready
+ */
+int AsconWrite(AsconPtr a, char *command, int noResponse);
+
+/** \brief read from the connection. allowed only when a response is available
+ *  \param a the connection
+ *  \return the response when a response is ready
+ *      NULL when the command has not completed and the response is not yet finished
+ *      "" when the command has completed, but no response was expected.
+ *      The result is only valid until the next call to other AsconXxx functions
+ *      and has to be duplicated if needed later.
+ */
+char *AsconRead(AsconPtr a);
+
+/** \brief get the connections error list
+ *  \return the error list
+ */
+ErrMsgList *AsconGetErrList(AsconPtr a);
+
+/** \brief a helper function
+ *  \param argc the number of args
+ *  \param argv the args to be concatenated
+ *  \result a allocated string containing the concatenated arguments
+ *     the args are properly quoted to be used as tcl proc arguments
+ */
+char *ConcatArgs(int argc, char *argv[]);
+
+/** \brief function for dealing with times with musec resolution
+ *  \return absolute time as double value
+ */
+double DoubleTime(void);
+
+#endif
diff --git a/ascon.i b/ascon.i
new file mode 100644
index 00000000..c941b184
--- /dev/null
+++ b/ascon.i
@@ -0,0 +1,143 @@
+#ifndef ASCON_I
+#define ASCON_I
+
+#include <sys/time.h>
+#include "ascon.h"
+#include "dynstring.h"
+
+/** \file
+ * \brief Asynchronous connection handling for devices controlled over tcp-ip
+ * connections. Interface for the implementation of custom protocols.
+ *
+ * For the implmentation of a custom protocol, hou have to implement
+ * the handler function and the init function, declare the protocol
+ * of type AsconProtocol and call AsconInsertProtocol on startup.
+ * The handler and init functions are normally be a wrapper around AsconStdHandler
+ * and AsconStdInit
+ *
+ * The functions with fd as the first argument are utility functions with
+ * may be used in handler wrapper functions.
+ * On error, the return value may be one of the defined macros ASCON_xxx,
+ * and errno will give more details about the error.
+ */
+ 
+/**
+ * A sub-state of the connection. Only states with sub-state AsconStart may
+ * be set by the caller, and only when the sub-state is not AsconOnTheWay
+ */
+typedef enum { AsconOnTheWay=0, AsconStart=1, AsconFinished=2, AsconFailed=3 } AsconMode; 
+
+/**
+ * The state of the connection. The sub-state is state % 4.
+ */
+typedef enum {
+  AsconNotConnected=0+AsconFinished,
+  AsconKillMe=0+AsconStart,
+  AsconConnecting=4+AsconOnTheWay,
+  AsconConnectStart=AsconConnecting+AsconStart,
+  AsconConnectDone=AsconConnecting+AsconFinished,
+  AsconConnectFailed=AsconConnecting+AsconFailed,
+  AsconWriting=8+AsconOnTheWay,
+  AsconWriteStart=AsconWriting+AsconStart,
+  AsconWriteDone=AsconWriting+AsconFinished,
+  AsconReading=12+AsconOnTheWay,
+  AsconReadStart=AsconReading+AsconStart,
+  AsconReadDone=AsconReading+AsconFinished,
+  AsconIdle=16+AsconFinished
+} AsconState;
+
+/** \brief the task handler function prototype
+ *
+ * custom handlers must have this prototype
+ */
+typedef int (* AsconHandler)(AsconPtr connection);
+
+/** Ascon struct
+ * all members are public, allowing access by handler wrappers
+ */
+typedef struct Ascon {
+  AsconState state;   /**< the current state */
+  int fd;             /**< socket */
+  int readState;      /**< default implementation: 'was cr' */
+  pDynString rdBuffer;/**< read buffer */
+  pDynString wrBuffer;/**< write buffer */
+  int wrPos;          /**< write buffer position */
+  float timeout;      /**< read timeout (sec) */
+  char *hostport;     /**< host:port to connect */
+  ErrMsgList errList; /**< error message list */
+  double start;       /**< unix time when read was started */
+  void *private;      /**< private data of protocol */
+  int noResponse;     /**< no response expected */
+  int responseValid;  /**< a valid response is ready */
+  AsconHandler handler; /**< handler function */
+} Ascon;
+
+#define ASCON_SELECT_ERROR -1
+#define ASCON_RECV_ERROR -2
+#define ASCON_SEND_ERROR -3
+#define ASCON_DISCONNECTED -4
+
+/** \brief the standard handler routine.
+ *  \param a the connection
+ *  \return 0 when task has finished (connection to be closed), 1 when active
+ *
+ * In most cases a custom handler may be a wrapper around AsconStdHandler
+ */
+int AsconStdHandler(AsconPtr a);
+
+/** \brief initialize a standard connection
+ *  \param a the connection
+ *  \param hostport the tcp/ip address (syntax: host:port)
+ *
+ * In most cases a custom init function may be a wrapper around AsconStdInit
+ */
+void AsconStdInit(AsconPtr a, char *hostport);
+
+/** The Ascon Protocol
+ */
+typedef struct AsconProtocol {
+  struct AsconProtocol *next;
+  char *name;
+  AsconHandler handler;
+  void (*init)(Ascon *s, int argc, char *argv[]);
+} AsconProtocol;
+
+/** \brief Insert a new protocol into the protocol list
+ * protocol the protocol (must be allocated by the caller, may be statically)
+ */
+void AsconInsertProtocol(AsconProtocol *protocol);
+
+/** \brief close the connection and free internal used memory
+ *  \param a the connection to be closed
+ *  remark: the connection struct itself has to be freed manually
+ */
+void AsconClose(AsconPtr a);
+
+/** \brief swallow garbage (utility function)
+ *  \param fd the socket
+ *  \return >=0: number of chars swallowed, else error
+ */
+int AsconReadGarbage(int fd);
+
+/** \brief check if a connection has succeded (utility function)
+ *  \param fd the socket
+ *  \return 1: connection succesful, 0: connection in progress, <0: error
+ */
+int AsconConnectSuccess(int fd);
+
+/** \brief read one character, if available (utility function)
+ *  \param fd the socket
+ *  \param chr the result
+ *  \return 1: succes, 0: no data available, <0: error
+ */
+int AsconReadChar(int fd, char *chr);
+
+/** \brief non blocking write (utility function)
+ *  \param fd the socket
+ *  \param data the data (not nul-terminated, may contain nul)
+ *  \param length the length of the data
+ *  \return  >0: number of written chars,0: write not yet possible, <0: error
+ */
+int AsconWriteChars(int fd, char *data, int length);
+
+#endif 
diff --git a/errormsg.c b/errormsg.c
new file mode 100644
index 00000000..488f26d8
--- /dev/null
+++ b/errormsg.c
@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include "errormsg.h"
+
+/* ErrMsgList implementation */
+#define MC_NAME(T) ErrMsg##T
+#define MC_IMPLEMENTATION
+#include "mclist.c"
+
+ErrMsg *ErrPutMsg(ErrMsgList *dump, char *data, char *fmt, ...) {
+  ErrMsg *m, *p;
+  va_list ap;
+  char buf[256];
+  char *text;
+  int l;
+  
+  va_start(ap, fmt);
+  l = vsnprintf(buf, sizeof buf, fmt, ap);
+  va_end(ap);
+  if (l < sizeof buf) {
+    text = buf;
+  } else {
+    /* assuming we have a C99 conforming snprintf and need a larger buffer */
+    text = calloc(l, 1);
+    va_start(ap, fmt);
+    vsnprintf(text, l, fmt, ap);
+    va_end(ap);
+  }
+  
+  m = NULL;
+  for (p = ErrMsgFirst(dump); p!= NULL; p = ErrMsgNext(dump)) {
+    if (strcmp(text, p->text) == 0) {
+      m = ErrMsgTake(dump);
+      break;
+    }
+  }
+  if (m == NULL) {
+    m = calloc(1, sizeof(*m));
+    if (text == buf) {
+      m->text = strdup(text);
+    } else {
+      m->text = text;
+    }
+    m->data = NULL;
+    m->cnt = 1;
+  } else {
+    if (text != buf) free(text);
+    m->cnt++;
+  }
+  if (m->data) {
+    free(m->data);
+    m->data = NULL;
+  }
+  if (data) {
+    m->data = strdup(data);
+  }
+  ErrMsgFirst(dump);
+  ErrMsgInsert(dump, m);
+  time(&m->last);
+  return m;
+}
diff --git a/errormsg.h b/errormsg.h
new file mode 100644
index 00000000..70efc753
--- /dev/null
+++ b/errormsg.h
@@ -0,0 +1,30 @@
+#ifndef ERRORMSG_H
+#define ERRORMSG_H
+
+#include <time.h>
+
+/** \file
+ * \brief Error message collection
+ */
+/** \brief Error message item
+ */
+typedef struct ErrMsg {
+  struct ErrMsg *next;
+  char *text;   /**< the message text */
+  char *data;   /**< additional text which may be different for the same message */
+  int cnt;      /**< count */
+  time_t last;  /**< time of last message */
+} ErrMsg;
+
+/* define type ErrMsgList and functions ErrMsgAdd etc. */
+#define MC_NAME(T) ErrMsg##T
+#include "mclist.h"
+
+/** \brief Put a formatted message to the error message list
+ *  \param dump the error message list
+ *  \param data some additional text (may be NULL)
+ *  \param fmt the format for the message
+ */
+ErrMsg *ErrPutMsg(ErrMsgList *dump, char *data, char *fmt, ...);
+
+#endif
diff --git a/make_gen b/make_gen
index 66180e68..9e87e018 100644
--- a/make_gen
+++ b/make_gen
@@ -31,6 +31,7 @@ SOBJ =  network.o ifile.o conman.o SCinter.o splitter.o passwd.o \
        hmdata.o  nxscript.o  tclintimpl.o sicsdata.o mcstascounter.o \
        mcstashm.o initializer.o remob.o tclmotdriv.o protocol.o \
        sinfox.o sicslist.o cone.o hipadaba.o sicshipadaba.o statistics.o \
+       ascon.o errormsg.o scriptcontext.o \
        moregress.o hdbcommand.o multicounter.o regresscter.o histregress.o \
        sicshdbadapter.o polldriv.o sicspoll.o statemon.o hmslave.o \
        nwatch.o asyncqueue.o asyncprotocol.o sicsobj.o hdbqueue.o\
diff --git a/mclist.c b/mclist.c
new file mode 100644
index 00000000..f67badf0
--- /dev/null
+++ b/mclist.c
@@ -0,0 +1,116 @@
+#ifndef MC_List_TYPE
+#define MC_List_TYPE MC_NAME(List)
+#define MC_First_FUN MC_NAME(First)
+#define MC_This_FUN MC_NAME(This)
+#define MC_Next_FUN MC_NAME(Next)
+#define MC_End_FUN MC_NAME(End)
+#define MC_Insert_FUN MC_NAME(Insert)
+#define MC_Add_FUN MC_NAME(Add)
+#define MC_Take_FUN MC_NAME(Take)
+#endif
+
+#ifdef MC_IMPLEMENTATION
+
+#undef MC_IMPLEMENTATION
+#ifndef MC_TYPE
+#define MC_TYPE MC_NAME()*
+#endif
+
+#else
+
+#define MC_DO_NOT_UNDEF
+#include "mclist.h"
+#undef MC_DO_NOT_UNDEF
+
+#endif
+
+#ifndef MC_NEXT
+#define MC_NEXT next
+#endif
+
+MC_TYPE MC_First_FUN(MC_List_TYPE *list) {
+  list->ptr = &list->head;
+  return list->head;
+}
+
+MC_TYPE MC_This_FUN(MC_List_TYPE *list) {
+  if (list->head == NULL) {
+    list->ptr = &list->head;
+    return NULL;
+  }
+  return *list->ptr;
+ }
+
+MC_TYPE MC_Next_FUN(MC_List_TYPE *list) {
+  MC_TYPE node;
+  if (list->head == NULL) {
+    list->ptr = &list->head;
+    return NULL;
+  }
+  node = *list->ptr;
+  if (node) {
+    list->ptr = &node->MC_NEXT;
+  }
+  return *list->ptr;
+}
+
+void MC_End_FUN(MC_List_TYPE *list) {
+  MC_TYPE node;
+  if (list->head == NULL) {
+    list->ptr = &list->head;
+  }
+  node = *list->ptr;
+  if (node) {
+    while (node->MC_NEXT != NULL) {
+      node = node->MC_NEXT;
+    }
+    list->ptr = &node->MC_NEXT;
+  }
+}
+
+void MC_Insert_FUN(MC_List_TYPE *list, MC_TYPE node) {
+  if (list->head == NULL) {
+    list->ptr = &list->head;
+  }
+  node->MC_NEXT = *list->ptr;
+  *list->ptr = node;
+}
+
+void MC_Add_FUN(MC_List_TYPE *list, MC_TYPE node) {
+  node->MC_NEXT = NULL;
+  if (list->head == NULL) {
+    list->head = node;
+    list->ptr = &list->head;
+  } else {
+    if (*list->ptr != NULL) {
+      MC_End_FUN(list);
+    }
+    *list->ptr = node;
+  }
+}
+
+MC_TYPE MC_Take_FUN(MC_List_TYPE *list) {
+  MC_TYPE node;
+  node = *list->ptr;
+  if (node != NULL) {
+    *list->ptr = node->MC_NEXT;
+  }
+  return node;
+}
+
+void MC_Delete_FUN(MC_List_TYPE *list, void (*deleteFunc)(MC_TYPE n)) {
+  MC_TYPE node;
+  MC_TYPE victim;
+  node = list->head;
+  while (node != NULL) {
+    victim = node;
+    node = node->next;
+    deleteFunc(victim);
+  }
+  list->head = NULL;
+  list->ptr = &list->head;
+}
+
+#undef MC_NAME
+#undef MC_TYPE
+#undef MC_NEXT
diff --git a/mclist.h b/mclist.h
new file mode 100644
index 00000000..889a6737
--- /dev/null
+++ b/mclist.h
@@ -0,0 +1,177 @@
+/** \file
+ * \brief Type safe list handling
+ *
+ * The definition and implementation make use of macros extensively to create
+ * a list type and related functions for any node type.
+ * <b>However, accessing the list does not use macros.</b>
+ * The list is implemented as a singly linked list. Sequential appending
+ * to the tail is fast, because the list structure contains
+ * a pointer to the anchor of the last accessed node.
+ *
+ * For a local list, mclist.c must be included after
+ * the declaration of the node type and after defining the macro MC_NAME
+ * and optionally MC_TYPE and MC_NEXT.
+ *
+ * For a public list, in the header file mclist.h must be included after
+ * the declaration of the node type and after defining the macro MC_NAME
+ * and optionally MC_TYPE. In the implementation mclist.c
+ * must be included after defining the macro MC_NAME and MC_IMPLEMENTATION
+ * and optionally MC_TYPE and MC_NEXT.
+ *
+ * MC_NAME has one parameter and describes how to combine the list name
+ * with the function names.
+ *
+ * MC_TYPE defines the node type. If undeclared it defaults to a pointer
+ * to the name.
+ *
+ * MC_NEXT indicates the name of the link. It defaults to 'next'.
+ *
+ * MC_IMPLEMENTATION has no value and must be defined when the list type
+ * was already declared. Typically this is done in a header file including mclist.h.
+ *
+ * The macros MC_NAME, MC_TYPE, MC_NEXT and MC_IMPLEMENTATION are undefined
+ * within mclist.c and mclist.h and must be redefined for every list.
+ * 
+ * \par Usage example
+ * \code
+ * // declare the Node type
+ * typedef struct Node {
+ *   struct Node *next;
+ *   char *name;
+ * } Node;
+ * 
+ * // this declaration leads to a list type 'NodeList' and fucntions names 'Node<fun>'
+ * #define MC_NAME(T) Node##T
+ * // the following line is not needed as 'next' is the default for the link
+ * #define MC_NEXT next
+ * // the following line is not needed as 'Node *' is the default for the type in this case
+ * #define MC_TYPE Node *
+ * // inside mclist.c, the list type is declared and the related functions are implemented
+ * #include "mclist.c"
+ *
+ * int main(void) {
+ *   // declare and init the list
+ *   NodeList list={NULL};
+ *
+ *   // create a node
+ *   Node *node;
+ *   node = malloc(sizeof(*node));
+ *   node->name = "First";
+ *   
+ *   // add node at the end of the list
+ *   NodeAdd(&list, node);
+ * 
+ *   // print the names of all list nodes
+ *   for (node = NodeFirst(&list); node != NULL; node = NodeNext(&list)) {
+ *     printf("%s\n", node->name);
+ *   }
+ *
+ *   // alternative form not touching the list position
+ *   // only for the case, where no insert or take function is used inside the loop
+ *   for (node = list.head; node != NULL; node = node->next) {
+ *     printf("%s\n", node->name);
+ *   }
+ *
+ *   // remove the node with the name "First"
+ *   for (node = NodeFirst(&list); node != NULL; node = NodeNext(&list)) {
+ *     if (strcmp(node->name, "First") == 0) {
+ *       free(NodeTake(&list));
+ *     }
+ *   }
+ * }
+ * \endcode
+ */
+#ifndef MC_TYPE
+/** \brief default node type
+ */
+#define MC_TYPE MC_NAME()*
+#endif
+
+#ifndef MC_List_TYPE
+#define MC_List_TYPE MC_NAME(List)
+#define MC_First_FUN MC_NAME(First)
+#define MC_This_FUN MC_NAME(This)
+#define MC_Next_FUN MC_NAME(Next)
+#define MC_End_FUN MC_NAME(End)
+#define MC_Insert_FUN MC_NAME(Insert)
+#define MC_Add_FUN MC_NAME(Add)
+#define MC_Take_FUN MC_NAME(Take)
+#define MC_Delete_FUN MC_NAME(Delete)
+#endif
+
+typedef struct MC_List_TYPE {
+  MC_TYPE head;
+  MC_TYPE *ptr;
+} MC_List_TYPE;
+
+/** \brief move to first node and get it
+ *  \param list the list
+ *  \return the node or NULL when the list is empty
+ *
+ *  Actual position on return: at the first node
+ */
+MC_TYPE MC_First_FUN(MC_List_TYPE *list);
+
+/** \brief get the node at the current position
+ *  \param list the list
+ *  \return the node or NULL when the list is empty or the position is at end
+ *
+ * Actual position on return: not changed (= at the returned node)
+ */
+MC_TYPE MC_This_FUN(MC_List_TYPE *list);
+
+/** \brief get the node after the current node
+ *  \param list the list
+ *  \return the node or NULL when the list is empty or the position is at end
+ *
+ * Actual position on return: incremented (= at the returned node or at end)
+ */
+MC_TYPE MC_Next_FUN(MC_List_TYPE *list);
+
+/** \brief move the position to the end
+ *  \param list the list
+ *
+ * Actual position on return: at end
+ */
+void MC_End_FUN(MC_List_TYPE *list);
+
+/** \brief insert at the current position, i.e. before the current node
+ *  \param list the list
+ *  \param node the node to be inserted
+ *
+ * Actual position on return: at the inserted node
+ */
+void MC_Insert_FUN(MC_List_TYPE *list, MC_TYPE node);
+
+/** \brief add at the end of the list
+ *  \param list the list
+ *  \param node the node to be added
+ *
+ * Actual position on return: at the inserted node (before the last node, not at end!)
+ */
+void MC_Add_FUN(MC_List_TYPE *list, MC_TYPE node);
+
+/** \brief remove the node at the current position
+ *  \param list the list
+ *  \return the removed node or NULL when the list is empty or the position is at end
+ *
+ * Actual position on return: after the taken node
+ *
+ * Note: it is the responsibility of the caller to free the node if it is not used
+ * anymore
+ */
+MC_TYPE MC_Take_FUN(MC_List_TYPE *list);
+
+/** \brief remove and delete all nodes
+ *  \param list the list
+ *  \param deleteFunc the kill function of the node
+ *
+ * Calls the kill function for every node. The list is
+ * empty on return.
+ */
+void MC_Delete_FUN(MC_List_TYPE *list, void (*deleteFunc)(MC_TYPE node));
+
+#ifndef MC_DO_NOT_UNDEF
+#undef MC_NAME
+#undef MC_TYPE
+#endif
diff --git a/ofac.c b/ofac.c
index 9c48f7d8..68ee73e7 100644
--- a/ofac.c
+++ b/ofac.c
@@ -437,6 +437,7 @@
 
     INIT(SiteInit); /* site specific initializations */
     INIT(StatisticsInit);
+    INIT(SctStartup);
 
   }
 /*--------------------------------------------------------------------------*/
diff --git a/scriptcontext.c b/scriptcontext.c
new file mode 100644
index 00000000..8f544afc
--- /dev/null
+++ b/scriptcontext.c
@@ -0,0 +1,1458 @@
+#include <strings.h>
+#include <tcl.h>
+#include <time.h>
+#include <math.h>
+#include "sics.h"
+#include "sicsobj.h"
+#include "initializer.h"
+#include "commandlog.h"
+#include "hipadaba.h"
+#include "sicshipadaba.h"
+#include "dynstring.h"
+#include "ascon.h"
+#include "errormsg.h"
+
+/** \file
+ *  \brief script context implementation (Sct)
+ */
+
+/** \brief the maximum hdb path length */
+#define MAX_HDB_PATH 1024
+
+typedef enum {
+  sct_send_keyword,
+  sct_result_keyword,
+  sct_command_keyword,
+  sct_path_keyword,
+  sct_update_keyword,
+  sct_take_keyword,
+  sct_complete_keyword,
+  sct_chain_keyword,
+  sct_next_keyword,
+  sct_steplist_keyword,
+  sct_no_keyword
+} SctKeyword;
+
+/* keywords must have the same order as SctKeyword */
+static char *sctKeywords[]={
+  "send",
+  "result",
+  "command",
+  "path",
+  "update",
+  "take",
+  "complete",
+  "chain",
+  "next",
+  "steplist",
+  NULL
+};
+
+static char *reset_type="";
+
+typedef struct SctList SctList;
+
+typedef struct SctChain {
+  struct SctChain *next;
+  char *command;
+  SctList *scriptList;
+  pHdb relatedNode;
+  ErrMsg *msg;
+  int doit;
+  char *dynamic;
+} SctChain;
+
+/* define SctChainList and their functions */
+#define MC_NAME(T) SctChain##T
+#include "mclist.c"
+
+typedef enum {set_type, timed_type, manual_type, no_type} SctScriptListType;
+static char *slTypes[]={"set", "timed", "manual", NULL};
+
+struct SctList {
+  struct SctList *next;
+  char *name;
+  SctChain *beginScript;
+  SctChain *endScript;
+  SctScriptListType type;
+  int dirty;
+  double interval;
+  double lastPeriod;
+  SctChain *lastScript;
+  SctChainList chains;
+};
+
+/* define SctListList and their functions */
+#define MC_NAME(T) SctList##T
+#include "mclist.c"
+
+typedef struct Sct Sct;
+
+typedef struct SctParData {
+  struct SctParData *next;
+  Sct *sct;
+  SctChain *scriptChain;
+  int pending, inprogress;
+  int refCnt;
+  hdbValue target;
+  SCStore conCtx;
+} SctParData;
+
+typedef struct SctObjectName {
+  struct SctObjectName *next;
+  char *name;
+} SctObjectName;
+
+/* define SctObjectNameList and their functions */
+#define MC_NAME(T) SctObjectName##T
+#include "mclist.c"
+
+struct Sct {
+  pObjectDescriptor desc;
+  char *name;
+  SctListList scriptLists;
+  SctObjectNameList names; /* created with the "object" command, needed for kill only */
+  AsconPtr ascon;
+  pHdb currentNode;
+  SctParData *foundData;
+  char *cmd;
+  char *result;
+  char *nextScript;
+  SctChain *runningChain;
+  SCStore debugConn;
+  char *debugCommand;
+  int sent;
+  SctKeyword operation;
+  int killTask;
+  int killObj;
+  int verbose;
+  int taskSteps;
+};
+
+static Sct *sct = NULL;
+
+static void SctFreeParData(void *d) {
+  SctParData *data=d;
+  data->refCnt--;
+  if (data->refCnt == 0) {
+    if (data->conCtx) SCStoreFree(data->conCtx);
+    free(data);
+  }
+}
+
+pHdb SctFindObjNode(char *name) {
+  CommandList *cmd;
+  pDummy obj;
+  
+  cmd = FindCommand(pServ->pSics, name);
+  if (cmd == NULL) return NULL;
+  obj = (void *)cmd->pData;
+  if (obj == NULL || obj->pDescriptor->parNode==NULL) return NULL;
+  return obj->pDescriptor->parNode;
+}
+
+/** \brief find the node with the relative path relpath
+ * \param node the root node (where to start)
+ * \param relpath an absolute or relative path
+ * \param parentPtr a pointer to the found parent (may be NULL if not used)
+ * \param nodePtr a pointer to the found node
+ * \return the name of the node
+ *
+ * An abolute path starts with a slash, a relative path equal to "."
+ * means that the input node is returned. A syntax like "..", "../down"
+ * is also allowed, but the double dots must appear at the start of the path.
+ *
+ * This routine may also be used in order to find the parent node of
+ * a node not yet existing. In this case the nodePtr will point
+ * to a NULL pointer on return, and a pointer to the last element
+ * in the path is returned.
+ *
+ * Nodes anchored in the sics object list are also found when
+ * the path starts with "/sics/"
+ */
+char *SctFindNode(pHdb node, char *relpath, pHdb *parentPtr, pHdb *nodePtr) {
+  char *path;
+  char buffer[MAX_HDB_PATH];
+  pHdb root = NULL;
+  char *name;
+  char *slash;
+  
+  if (strlen(relpath) >= sizeof(buffer)) {
+    *nodePtr = NULL;
+    return NULL; /* relpath too long */
+  }
+  strcpy(buffer, relpath);
+  path = buffer;
+  if (path[0] == '/') {
+    if (strncmp(path, "/sics/", 6) == 0) {
+      /* sics object case */
+      slash = strchr(path+6, '/');
+      if (slash != NULL) {
+        *slash = '\0';
+      }
+      node = SctFindObjNode(path);
+      if (node == NULL) goto notFound;
+      if (slash == NULL) goto nodeFound;
+      path = slash+1;
+      /* root node is sics object, path is relative to it */
+    } else {
+      /* absolute path */
+      node = GetHipadabaRoot();
+      /* strip off first slash, root node is sics root */
+      path++;
+    }
+  } else if (path[0] == '.') {
+    if (path[1] == '\0') {
+      /* this path */ 
+      goto nodeFound;
+    }
+    /* upper node */
+    while (strncmp(path, "..", 2) == 0 && node != NULL) {
+      node = node->mama;
+      if (path[2] == '\0') goto nodeFound;
+      path += 3;
+    }
+    if (node == NULL) goto notFound;
+  }
+  
+  /* now go down in path */
+  while (node != NULL) {
+    root = node;
+    slash = strchr(path, '/');
+    if (slash != NULL) *slash='\0';
+    for (node = root->child; node != NULL; node = node->next) {
+      if (strcasecmp(node->name, path) == 0) {
+        if (slash == NULL) goto nodeFound;
+        path = slash + 1;
+        break;
+      }
+    }
+  }
+
+  if (slash == NULL) {
+    if (parentPtr != NULL) {
+      *parentPtr = root;
+    }
+    *nodePtr = NULL;
+    /* the returned name must be taken from the end of relpath, as path is no longer valid */
+    name = relpath + (path - buffer);
+    goto finish;
+  }
+notFound:
+  node = NULL;
+nodeFound:
+  *nodePtr = node;
+  if (node) {
+    if (parentPtr != NULL) {
+      *parentPtr = node->mama;
+    }
+    name = node->name;
+  } else {
+    if (parentPtr != NULL) {
+      *parentPtr = NULL;
+    }
+    name = NULL;
+  }
+finish:
+  return name;
+}
+
+/** \brief get the absolute path of a node anchored in the
+ *     Hipadaba root or in a sics object
+ * \param nodeArg the input node
+ * \param path the result
+ * \param pathlen length of the result
+ * \return 1 on success, 0 on failure
+ */
+int SctGetPath(pHdb nodeArg, char *path, size_t pathlen) {
+  pHdb node, root;
+  int len, pos, l;
+  static char *sics="/sics";
+  
+  /* determine path length and root node */
+  root = nodeArg;
+  len = 0;
+  for (node = nodeArg; node != NULL; node = node->mama) {
+    len += strlen(node->name) + 1;
+    if (len >= pathlen) return 0; /* buffer overflow (may be recursize path?) */
+    root = node;
+  }
+  
+  /* check root and add prefix */
+  path[0]='\0';
+  if (root != GetHipadabaRoot()) { /* not anchored in root */
+    if (!FindCommand(pServ->pSics, root->name)) {
+      /* not a sicsobject, give up */
+      path[0]='\0';
+      return 0;
+    }
+    /* sics object case */
+    l = strlen(sics);
+    len += l;
+    if (len >= pathlen) return 0;
+    strncpy(path, sics, l);
+  }
+  
+  /* build the path backwards */
+  path[len]='\0';
+  pos = len;
+  for (node = nodeArg; node != NULL; node = node->mama) {
+    len = strlen(node->name);
+    pos -= len;
+    assert(pos>0);
+    strncpy(path+pos, node->name, len);
+    pos--;
+    path[pos]='/';
+  }
+  return 1;
+}
+
+static int UpdateNode(SConnection *con, ErrMsgList *e, pHdb node, int argc, char *argv[]) {
+  hdbValue newValue;
+  static char errtxt[512];
+  char *str;
+  int status;
+  
+  if (!cloneHdbValue(&node->value, &newValue)) {
+    ErrPutMsg(e, NULL, "no memory");
+    return 0;
+  }
+  str = ConcatArgs(argc, argv);
+  if (str == NULL) {
+    ErrPutMsg(e, NULL, "no memory");
+    return 0;
+  }
+  if (!readHdbValue(&newValue, str, errtxt, sizeof errtxt)) {
+    ErrPutMsg(e, errtxt, "conversion failure");
+    return 0;
+  }
+  free(str);
+  status = UpdateHipadabaPar(node, newValue, con);
+  ReleaseHdbValue(&newValue);
+  return status;
+}
+
+static int SctFindKeyword(char *name, char *keywords[]) {
+  int i;
+  for (i=0; keywords[i]!=NULL; i++) {
+    if (strcasecmp(name, keywords[i]) == 0) return i;
+  }
+  return i;
+}
+
+static SctChain *SctMakeChain(char *command) {
+  SctChain *sc;
+  
+  sc = calloc(1, sizeof(*sc));
+  if (sc == NULL) return NULL;
+  sc->doit = 0;
+  sc->dynamic = NULL;
+  sc->command = command;
+  sc->scriptList = NULL;
+  sc->msg = NULL;
+  return sc;
+}
+
+static void SctSetListDirty(SctList *sl) {
+  if (!sl->dirty) {
+    sl->dirty = 1;
+    if (sl->beginScript) {
+      sl->beginScript->doit = 1;
+    }
+  }
+}
+
+static void SctSetDirty(SctChain *sc) {
+  SctSetListDirty(sc->scriptList);
+  sc->doit = 1;
+}
+
+static int SctUpdateCallback(void *user, void *conn, pHdb node, hdbValue value) {
+  SctParData *data = user;
+  SConnection *con;
+  char path[MAX_HDB_PATH];
+  pDynString str;
+  
+  if (data->inprogress) {
+    if (data->sct->operation == sct_complete_keyword) {
+      data->inprogress = 0;
+      SctGetPath(node, path, sizeof path);
+      con = SCStorePush(data->conCtx);
+      str = formatValue(value, node);
+      SCPrintf(con, eStatus, "%s = %s", path,
+        GetCharArray(str));
+      DeleteDynString(str);
+      SCStorePop(data->conCtx);
+    }
+  }
+  return 1;
+}
+
+static int SctSetCallback(void *user, void *conn, pHdb node, hdbValue value) {
+  SctParData *data = user;
+  SConnection *oldCon;
+  char path[MAX_HDB_PATH];
+  pDynString str;
+  
+  if (data->scriptChain) {
+    if (data->pending) {
+      SctGetPath(node, path, sizeof path);
+      oldCon = SCStorePush(data->conCtx);
+      str = formatValue(value, node);
+      SCPrintf(oldCon, eStatus, "target of %s changed to %s", path,
+        GetCharArray(str));
+      DeleteDynString(str);
+      SCStorePop(data->conCtx);
+    }
+    data->conCtx = SCSave(conn, data->conCtx);
+    data->pending = 1;
+    SctSetDirty(data->scriptChain);
+    copyHdbValue(&value, &data->target);
+    return 0;
+  }
+  return 1;
+}
+
+static int SctReadCallback(void *user, void *conn, pHdb node, hdbValue value) {
+  SctParData *data = user;
+  
+  data->sct->foundData = data;
+  if (data->sct->operation == sct_take_keyword && data->pending) {
+    data->pending = 0;
+    data->inprogress = 1;
+    return 0;
+  }
+  return 1;
+}
+
+static int SctExec(SConnection *con, SicsInterp *sics, void *object, int argc, char *argv[]) {
+  SctKeyword keyword;
+  SctList *sl;
+  SctChain *sc;
+  pHdb node;
+  hdbValue newValue;
+  pDynString result;
+  char *args;
+  char path[MAX_HDB_PATH];
+  SConnection *dcon;
+  
+  if (sct == NULL) {
+    SCPrintf(con, eError, "ERROR: %s may be called only in proper context", argv[0]);
+    return 0;
+  };
+  if (argc < 2) {
+    SCPrintf(con, eInError, "ERROR: missing %s subcommand", argv[0]);
+    goto quit;
+  };
+  if (sct->verbose != 0) {
+    args = ConcatArgs(argc, argv);
+    dcon = SCStorePush(sct->debugConn);
+    SCPrintf(dcon, eWarning, "commnd: %s", args);
+    SCStorePop(sct->debugConn);
+    free(args);
+    args = NULL;
+  }
+  keyword = SctFindKeyword(argv[1], sctKeywords);
+  sct->operation = keyword;
+  switch (keyword) {
+  case sct_send_keyword:
+    if (argc < 4) {
+      SCPrintf(con, eInError, "ERROR: should be: %s send <cmd> <script ...>", argv[0]);
+      goto quit;
+    }
+    if (sct->cmd != NULL || sct->nextScript != NULL) {
+      SCPrintf(con, eInError, "ERROR: %s busy", argv[0]);
+      sct->taskSteps = 0;
+      goto quit;
+    }
+    if (sct->ascon == 0) {
+      SCPrintf(con, eInError, "ERROR: %s has no connection", argv[0]);
+      goto quit;
+    }
+    sct->cmd = strdup(argv[2]);
+    if (sct->verbose != 0) {
+      dcon = SCStorePush(sct->debugConn);
+      SCPrintf(dcon, eWarning, "send  : %s", sct->cmd);
+      SCStorePop(sct->debugConn);
+    }
+    AsconWrite(sct->ascon, sct->cmd, 0);
+    sct->nextScript = ConcatArgs(argc-3, argv+3);
+    if (sct->result) free(sct->result);
+    sct->result = NULL;
+    break;
+  case sct_result_keyword:
+    if (!sct->result) {
+      SCPrintf(con, eInError, "ERROR: no result available");
+      goto quit;
+    }
+    SCWrite(con, sct->result, eValue);
+    goto success;
+  case sct_command_keyword:
+    if (!sct->cmd) { 
+      SCPrintf(con, eInError, "ERROR: no command available");
+      goto quit;
+    }
+    SCWrite(con, sct->cmd, eValue);
+    goto success;
+  case sct_path_keyword:
+    if (SctGetPath(sct->currentNode, path, sizeof path)) {
+      SCWrite(con, path, eValue);
+    } else {
+      SCWrite(con, "ERROR: node not anchored or path name too long", eInError);
+    }
+    goto success;
+  case sct_complete_keyword:
+    /* fall through */
+  case sct_update_keyword:
+    if (argc < 4) {
+      SCPrintf(con, eInError, "ERROR: should be: %s %s <par> <value>", argv[0], argv[1]);
+      goto quit;
+    }
+    SctFindNode(sct->currentNode, argv[2], NULL, &node);
+    if (node == NULL) {
+      goto missingPar;
+    }
+    return UpdateNode(con, AsconGetErrList(sct->ascon), node, argc-3, argv+3);
+  case sct_take_keyword:
+    if (argc < 3) {
+      SCPrintf(con, eInError, "ERROR: should be: %s take <par>", argv[0]);
+      goto quit;
+    }
+    SctFindNode(sct->currentNode, argv[2], NULL, &node);
+    if (node == NULL) {
+      goto missingPar;
+    }
+    memset(&newValue,0,sizeof(hdbValue));
+    sct->foundData = NULL;
+    GetHipadabaPar(node, &newValue, con);
+    if (sct->foundData) {
+      cloneHdbValue(&sct->foundData->target, &newValue);
+    }
+    result = formatValue(newValue, node);
+    ReleaseHdbValue(&newValue);
+    if (result == NULL) goto noMemory;
+    if (sct->verbose != 0) {
+      dcon = SCStorePush(sct->debugConn);
+      SCPrintf(dcon, eWarning, "result: %s", GetCharArray(result));
+      SCStorePop(sct->debugConn);
+    }
+    SCWrite(con, GetCharArray(result), eValue);
+    DeleteDynString(result);
+    goto success;
+  case sct_steplist_keyword:
+    if (argc != 3) {
+      SCPrintf(con, eInError, "ERROR: should be:  %s stepList <list>", argv[0]);
+      goto quit;
+    }
+    for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
+      if (strcasecmp(sl->name, argv[2]) == 0) {
+        SctSetListDirty(sl);
+        goto success;
+      }
+      
+    }
+    goto missingScriptList;
+  case sct_chain_keyword:
+    if (argc < 4) {
+      SCPrintf(con, eInError, "ERROR: should be:  %s chain <name> <script>", argv[0]);
+      goto quit;
+    }
+    for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
+      for (sc = sl->chains.head; sc != NULL; sc = sc->next) { /* don't touch the list pos */
+        if (sc->dynamic && strcasecmp(argv[2], sc->dynamic) == 0) {
+          if (sc->command) free(sc->command);
+          sc->command = ConcatArgs(argc - 3, argv + 3);
+          goto success;
+        }
+      }
+    }
+    SCPrintf(con, eInError, "ERROR: dynamic script %s not found", argv[2]);
+    goto quit;
+  case sct_next_keyword:
+    if (argc < 3) {
+      SCPrintf(con, eInError, "ERROR: should be:  %s next <script>", argv[0]);
+      goto quit;
+    }
+    sc = sct->runningChain;
+    if (sc == NULL || sc->dynamic == NULL) goto notDynamic;
+    if (sc->command) free(sc->command);
+    sc->command = ConcatArgs(argc - 2, argv + 2);
+    sc->doit = 1;
+    break;
+  case sct_no_keyword:
+    SCPrintf(con, eInError, "ERROR: %s %s: unknown keyword", argv[0], argv[1]);
+    goto quit;
+  default:
+    SCPrintf(con, eInError, "ERROR: %s %s: untreated keyword", argv[0], argv[1]);
+    goto quit;
+  }
+  /* no OK message needed, as this command will never be called from a client */
+success:
+  sct->operation = sct_no_keyword;
+  return 1;
+noMemory:
+  SCWrite(con, "ERROR: no memory", eInError);
+  goto quit;
+missingPar:
+  SCPrintf(con, eInError, "ERROR: parameter %s not found", argv[2]);
+  goto quit;
+notDynamic:
+  SCPrintf(con, eInError, "ERROR: script is not dynamic");
+  goto quit;
+missingScriptList:
+  SCPrintf(con, eInError, "ERROR: script list %s not found", argv[2]);
+  goto quit;
+quit:
+  sct->operation = sct_no_keyword;
+  return 0;
+}
+
+static int SctWrapper(SConnection *con, SicsInterp *sics, void *object, int argc, char *argv[]) {
+  Sct *sct;
+  SctParData *data;
+  hdbValue val;
+  char *mode;
+  pDynString dyn;
+  pHdb node;
+  ErrMsg *msg;
+  
+  typedef enum {
+    target_keywd,
+    no_keywd
+  } Keyword;
+  /* keywds must have the same order as Keyword */
+  static char *keywds[]={
+    "-t", /* show state and target value */
+    NULL
+  };
+  Keyword keywd;
+  
+  if (argc < 2) {
+    return InvokeSICSOBJ(con, sics, object, argc, argv);
+  };
+  keywd = SctFindKeyword(argv[1], keywds);
+  sct = ((pSICSOBJ)object)->pPrivate;
+  switch (keywd) {
+  case no_keywd: return InvokeSICSOBJ(con, sics, object, argc, argv);
+  case target_keywd:
+    if (argc < 3) {
+      SCWrite(con, "ERROR: missing par", eInError);
+      return 0;
+    }
+    SctFindNode(sct->currentNode, argv[2], NULL, &node);
+    if (node == NULL) {
+      SCPrintf(con, eInError, "ERROR: %s %s not found", argv[0], argv[2]);
+      return 0;
+    }
+    sct->foundData = NULL;
+    GetHipadabaPar(node, &val, con);
+    data = sct->foundData;
+    if (data) {
+      if (data->pending) {
+        if (data->inprogress) {
+          mode = "inprogress pending";
+        } else {
+          mode = "pending";
+        }
+        cloneHdbValue(&data->target, &val);
+      } else {
+        if (data->inprogress) {
+          mode = "inprogress";
+          cloneHdbValue(&data->target, &val);
+        } else {
+          mode = "idle";
+        }
+      }
+      if (data->scriptChain && data->scriptChain->msg) {
+        msg = data->scriptChain->msg;
+        if (msg->data) {
+          SCPrintf(con, eInError, "ERROR:\n%s (%s)\n", msg->text, msg->data);
+        } else {
+          SCPrintf(con, eInError, "ERROR:\n%s\n", msg->text);
+        }
+      }
+    } else {
+      mode = "rdonly";
+    }
+    dyn = formatValue(val, node);
+    ReleaseHdbValue(&val);
+    SCPrintf(con, eValue, "%s %s", mode, GetCharArray(dyn));
+    DeleteDynString(dyn);
+    break;
+  default:
+    SCPrintf(con, eInError, "ERROR: %s %s: untreated keyword", argv[0], argv[1]);
+    return 0;
+  }
+  return 1;
+}
+
+static char *SctChainCmd(char *cmd) {
+  static char buf[512];
+  
+  if (sct->runningChain && strcmp(sct->runningChain->command, cmd) != 0) {
+    snprintf(buf, sizeof buf, "chain: %s\ncmd  : %s\n", sct->runningChain->command, cmd);
+  } else {
+    snprintf(buf, sizeof buf, "cmd  : %s\n", cmd);
+  }
+  return buf;
+}
+
+static char *SctCall(char *command) {
+  char *error;
+  Tcl_Interp *pTcl = InterpGetTcl(pServ->pSics);
+  int ret, l;
+  ErrMsg *msg;
+  SConnection *dcon;
+  
+  if (sct->verbose != 0) {
+    dcon = SCStorePush(sct->debugConn);
+    SCPrintf(dcon, eInError, "script: %s\n", command);
+    SCStorePop(sct->debugConn);
+  }
+  l = strlen(command);
+  ret = Tcl_EvalEx(pTcl, command, l, 0);
+  error = (char *)Tcl_GetStringResult(pTcl);
+  if (ret != TCL_OK && error[0]!='\0') {
+    msg = ErrPutMsg(AsconGetErrList(sct->ascon), NULL,
+      "%serror: %s", SctChainCmd(command), error);
+    if (sct->runningChain) {
+      sct->runningChain->msg = msg;
+    }
+    return error;
+  }
+  return NULL;
+}
+
+static char *SctCallChain(SctChain *sc) {
+  sct->runningChain = sc;
+  sct->currentNode = sc->relatedNode;
+  sc->msg = NULL;
+  return SctCall(sc->command);
+}
+
+static void SctCallNext(void) {
+  char *cmd = sct->nextScript;
+  
+  sct->nextScript = NULL;
+  if (SctCall(cmd) != NULL) {
+    if (sct->cmd) {
+      free(sct->cmd);
+      sct->cmd = NULL;
+    }
+  }
+  free(cmd);
+}
+
+static int SctTask(void *object) {
+  AsconStatus status;
+  char *response;
+  double period;
+  SctList *sl;
+  SctChain *sc;
+  SConnection *dcon = NULL;
+  
+  if (sct) {
+    WriteToCommandLog("SCT>", "forbidden command (like wait) called in script");
+    goto quit;
+  }
+  sct = object;
+  if (sct->killObj) {
+    sct->taskSteps = 0;
+    sct = NULL;
+    return 0;
+  }
+  if (!sct->ascon) { /* no connection */
+    goto quit;
+  }
+  if (sct->taskSteps == 0) {
+    goto quit;
+  }
+recycle:
+  status = AsconTask(sct->ascon);
+  if (status == AsconFailure) {
+    /* decide what to do on failure */
+  } else if (status != AsconReady) {
+    goto quit;
+  }
+  if (sct->taskSteps > 0) {
+    if (sct->taskSteps == 0) {
+      goto quit;
+    }
+    sct->taskSteps--;
+  }
+  response = AsconRead(sct->ascon);
+  if (response != NULL) {
+    if (sct->verbose != 0) {
+      if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
+      SCPrintf(dcon, eWarning, "answer: %s", response);
+    }
+    if (sct->cmd) free(sct->cmd);
+    sct->cmd = NULL;
+    if (sct->sent) {
+      sct->sent = 0;
+      if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
+      SCPrintf(dcon, eWarning, "response> %s", response);
+      free(sct->debugCommand);
+      sct->debugCommand = NULL;
+      goto recycle;
+    } else if (sct->nextScript) {
+      sct->result = strdup(response);
+    }
+  }
+  if (sct->debugCommand) {
+    if (sct->sent) {
+      if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
+      SCPrintf(dcon, eWarning, "state %d", status);
+      goto quit;
+    }
+    sct->sent = 1;
+    if (sct->verbose != 0) {
+      if (dcon == NULL) dcon = SCStorePush(sct->debugConn);
+      SCPrintf(dcon, eWarning, "sent  : %s", sct->debugCommand);
+    }
+    AsconWrite(sct->ascon, sct->debugCommand, 0);
+    goto recycle;
+  }
+  if (sct->nextScript) {
+    SctCallNext();
+    goto recycle;
+  }
+  for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
+    if (sl->type == set_type) {
+      if (sl->dirty) {
+        if (sl->beginScript && sl->beginScript->doit) {
+          sl->beginScript->doit = 0;
+          SctCallChain(sl->beginScript);
+          goto recycle;
+        }
+        sc = SctChainThis(&sl->chains);
+        if (sc != NULL) {
+          SctChainNext(&sl->chains);
+          SctCallChain(sc);
+          goto recycle;
+        }
+        /* look for pending scripts */
+        for (sc = SctChainFirst(&sl->chains); sc != NULL; sc = SctChainNext(&sl->chains)) {
+          if (sc->doit) break;
+        }
+        if (sc != NULL) {
+          SctChainNext(&sl->chains);
+          if (sl->type == set_type || sc->dynamic) sc->doit = 0;
+          SctCallChain(sc);
+          goto recycle; /* there are still pending scripts */
+        }
+        sl->dirty = 0;
+        SctChainFirst(&sl->chains);
+        if (sl->endScript) {
+          SctCallChain(sl->endScript);
+          goto recycle;
+        }
+        /* go to next scriptlist */
+      }
+    } else {
+      if (sl->type == timed_type) {
+        if (!sl->dirty) {
+          period = floor(DoubleTime() / sl->interval);
+          if (period != sl->lastPeriod) {
+            sl->lastPeriod = period;
+            SctSetListDirty(sl);
+          }
+        }
+      }
+      if (sl->dirty) {
+        if (sl->beginScript && sl->beginScript->doit) {
+          SctCallChain(sl->beginScript);
+          goto recycle;
+        }
+        sc = SctChainThis(&sl->chains);
+        if (sc != NULL) {
+          if (SctChainNext(&sl->chains) == NULL || sl->type == manual_type) {
+            sl->dirty = 0;
+          }
+          SctCallChain(sc);
+          goto recycle;
+        }
+        SctChainFirst(&sl->chains);
+      }
+      /* go to next scriptlist */
+    }
+  }
+quit:
+  if (sct->debugConn) {
+    SCStorePop(sct->debugConn);
+  }
+  sct = NULL;
+  return 1;
+}
+
+static void SctKillChain(SctChain *sc) {
+  if (sc->command) free(sc->command);
+  if (sc->dynamic) free(sc->dynamic);
+  free(sc);
+}
+
+static void SctKillSL(SctList *sl) {
+  if (sl->name) free(sl->name);
+  if (sl->beginScript) SctKillChain(sl->beginScript);
+  if (sl->endScript) SctKillChain(sl->endScript);
+  SctChainDelete(&sl->chains, SctKillChain);
+  free(sl);
+}
+
+static void SctObjectNameKill(SctObjectName *onam) {
+  RemoveCommand(pServ->pSics, onam->name);
+  free(onam->name);
+  free(onam);
+}
+
+static void SctKill(Sct *sct) {
+  SctObjectNameDelete(&sct->names, SctObjectNameKill);
+  SctListDelete(&sct->scriptLists, SctKillSL);
+  if (sct->ascon) AsconKill(sct->ascon);
+  if (sct->name) free(sct->name);
+  if (sct->cmd) free(sct->cmd);
+  if (sct->result) free(sct->result);
+  if (sct->nextScript) free(sct->nextScript);
+  if (sct->debugCommand) free(sct->debugCommand);
+  if (sct->debugConn) SCStoreFree(sct->debugConn);
+  if (sct->desc) DeleteDescriptor(sct->desc);
+  free(sct);
+}
+
+/* kill sct only after SctKillTask _and_ SctKillObj were invoked */
+
+static void SctKillTask(void *object) {
+  Sct *sct = object;
+  if (sct->killObj) {
+    SctKill(sct);
+  } else {
+    sct->killTask = 1;
+  }
+}
+
+static void SctKillObj(void *object) {
+  Sct *sct = object;
+  
+  if (sct->killTask) {
+    SctKill(sct);
+  } else {
+    sct->killObj = 1;
+  }
+}
+
+int SctAddNode2Script(Sct *sct, SctChain *sc, pHdb node, SConnection *con) {
+  hdbValue val;
+  char path[MAX_HDB_PATH];
+  
+  memset(&val,0,sizeof(hdbValue));
+  GetHipadabaPar(node, &val, con);
+  ReleaseHdbValue(&val);
+  if (!sct->foundData) {
+    SctGetPath(node, path, sizeof path);
+    SCPrintf(con, eError, "ERROR: %s has no script context data", path);
+    return 0;
+  }
+  if (sc->scriptList->type == set_type) {
+    sct->foundData->scriptChain = sc;
+  }
+  return 1;
+}
+
+static int SctAction(SConnection *con, SicsInterp *sics, void *object, int argc, char *argv[]) {
+  Sct *sct = object;
+  SctList *sl, *slItem;
+  SctChain *sc;
+  int type = 0, priv = -1;
+  SctParData *data;
+  pHdb node, parent;
+  pHdbCallback cb;
+  char *fmt;
+  char *name;
+  char path[MAX_HDB_PATH];
+  pSICSOBJ sicsobj;
+  int i;
+  ErrMsgList *list;
+  ErrMsg *msg;
+  time_t age;
+  char timetext[8];
+  double interval;
+  SctObjectName *objname;
+  hdbValue val;
+  
+  typedef enum {
+    connect_keyword,
+    object_keyword,
+    make_keyword,
+    path_keyword,
+    addscript_keyword,
+    addmultiscript_keyword,
+    addnode_keyword,
+    dynscript_keyword,
+    scriptlist_keyword,
+    beginscript_keyword,
+    endscript_keyword,
+    interval_keyword,
+    debug_keyword,
+    send_keyword,
+    error_keyword,
+    no_keyword
+  } Keyword;
+  /* keywords must have the same order as Keyword */
+  static char *keywords[]={
+    "connect",
+    "object",
+    "make",
+    "path",
+    "addscript",
+    "addmultiscript",
+    "addnode",
+    "dynscript",
+    "scriptlist",
+    "beginscript",
+    "endscript",
+    "interval",
+    "debug",
+    "send",
+    "error",
+    NULL
+  };
+  Keyword keyword;
+    
+  assert(sct);
+  if (argc < 2) {
+    SCPrintf(con, eError, "ERROR: missing %s subcommand", argv[0]);
+    goto quit;
+  };
+  keyword = SctFindKeyword(argv[1], keywords);
+  sct->operation = keyword;
+  switch (keyword) {
+  
+  case object_keyword:
+    if (argc < 5) {
+      SCPrintf(con, eError, "ERROR: should be  %s object <name> <priv> <type> [<fmt>]", argv[0]);
+      goto quit;
+    }     
+    sicsobj = MakeSICSOBJ(argv[2], "SctSicsObject");
+    if (!sicsobj) goto noMemory;
+    sicsobj->pPrivate = sct;
+    sct->currentNode = sicsobj->pDes->parNode;
+    sicsobj->KillPrivate = NULL;
+    /*
+    sicsobj->pDes->saveStatus = SctSave;
+    dynamic?
+    */
+    if (!AddCommand(pServ->pSics, argv[2], SctWrapper, KillSICSOBJ, sicsobj)) {
+      SCPrintf(con, eError, "%s already exists", argv[2]);
+      goto quit;
+    }
+    objname = calloc(1, sizeof(*objname));
+    objname->name = strdup(argv[2]);
+    SctObjectNameAdd(&sct->names, objname);
+    /* fall through */
+    
+  case make_keyword:
+    if (argc < 5) {
+      SCPrintf(con, eError, "ERROR: should be  %s make <par> <priv> <type> [<fmt>]", argv[0]);
+      goto quit;
+    }     
+    
+    fmt = NULL;
+    priv = decodeSICSPriv(argv[3]);
+    if (strcasecmp(argv[4], "int") == 0) {
+      type = HIPINT;
+    } else if (strcasecmp(argv[4], "float") == 0) {
+      type = HIPFLOAT;
+      if (argc == 6) {
+        fmt = argv[5];
+      } else {
+        fmt = "%.5g";
+      }
+    } else if (strcasecmp(argv[4], "text") == 0) {
+      type = HIPTEXT;
+    } else if (strcasecmp(argv[4], "none") == 0) {
+      type = HIPNONE;
+    } else {
+      SCWrite(con,
+        "ERROR: invalid type requested: none, int, float, text supported", eError);
+      goto quit;
+    }
+
+    if (keyword == make_keyword) { /* make parameter case */
+      name = SctFindNode(sct->currentNode, argv[2], &parent, &node);
+      if (node != NULL) goto nodeExists;
+      if (name == NULL) goto quit;
+      if (type != HIPNONE){
+        val = makeHdbValue(type,0);
+        node = MakeSICSHdbPar(name, priv, val);
+        ReleaseHdbValue(&val);
+      } else {
+        node = MakeHipadabaNode(name, type, 0);
+      }
+      if (node == NULL) goto noMemory;
+      AddHipadabaChild(parent, node, con);
+    } else { /* make object case */
+      name = argv[2];
+      node = sct->currentNode;
+    }
+    
+    data = calloc(1, sizeof(*data));
+    if (node == NULL || data == NULL) goto noMemory;
+    data->pending = 0;
+    data->inprogress = 0;
+    data->sct = sct;
+    data->scriptChain = NULL;
+    data->conCtx = NULL;
+    data->refCnt = 3; /* insert 3 times */
+    cloneHdbValue(&node->value, &data->target);
+    if (fmt) {
+      SetHdbProperty(node, "fmt", fmt);
+    }
+    
+    cb = MakeHipadabaCallback(SctUpdateCallback, data, SctFreeParData, -1, sct);
+    if (cb == NULL) goto noMemory;
+    AppendHipadabaCallback(node, HCBUPDATE, cb);
+
+    cb = MakeHipadabaCallback(SctSetCallback, data, SctFreeParData, -1, sct);
+    if (cb == NULL) goto noMemory;
+    AppendHipadabaCallback(node, HCBSET, cb);
+
+    cb = MakeHipadabaCallback(SctReadCallback, data, SctFreeParData, -1, sct);
+    if (cb == NULL) goto noMemory;
+    AppendHipadabaCallback(node, HCBREAD, cb);
+
+    break;
+    
+  case dynscript_keyword:
+    if (argc < 4) {
+      SCPrintf(con, eError, "ERROR: should be  %s %s <list> <name>", argv[0], argv[1]);
+      goto quit;
+    }
+    /* fall through */
+    
+  case addmultiscript_keyword:
+  
+  case addscript_keyword:
+    if (argc < 5) {
+      SCPrintf(con, eError, "ERROR: should be  %s %s <list> <par> <script ...>", argv[0], argv[1]);
+      goto quit;
+    }
+    if (keyword == dynscript_keyword) {
+      node = NULL;
+    } else {
+      SctFindNode(sct->currentNode, argv[3], &parent, &node);
+      if (node == NULL) {
+        name = argv[3];
+        goto nodeNotFound;
+      }
+    }
+    for (sl = SctListFirst(&sct->scriptLists); sl != NULL; sl = SctListNext(&sct->scriptLists)) {
+      if (strcasecmp(sl->name, argv[2]) == 0) {
+        if (keyword == dynscript_keyword) {
+          if (sl->type == set_type) {
+            SCPrintf(con, eError, "ERROR: dynscripts may not be added to a set type list");
+            goto quit;
+          }
+          node = sct->currentNode;
+        }
+        if (argc == 4) { /* take last script */
+          sc = SctChainThis(&sl->chains);
+          if (sc == NULL) {
+            SCPrintf(con, eError, "ERROR: script list is empty");
+            goto quit;
+          }
+        } else {
+          sc = SctMakeChain(ConcatArgs(argc-4, argv+4));
+          if (sc == NULL) goto noMemory;
+          if (node) {
+            sc->relatedNode = node;
+          } else {
+            sc->relatedNode = sct->currentNode;
+          }
+          sc->scriptList = sl;
+          if (keyword == dynscript_keyword) {
+            sc->dynamic = strdup(argv[3]);
+          }
+          SctChainAdd(&sl->chains, sc);
+        }
+        sct->foundData = NULL;
+        if (node && keyword == addscript_keyword) {
+          if (!SctAddNode2Script(sct, sc, node, con)) goto quit;
+        }
+        if (sl->type != set_type) {
+          sc->doit = 1;
+        }
+        /* the current script chain and script list is stored in the position of the Lists,
+           this is important for the addnode command */
+        goto success;
+      }
+    }
+    goto missingScriptList;
+    
+  case addnode_keyword:
+    if (argc != 3) {
+      SCPrintf(con, eError, "ERROR: should be  %s %s <par>", argv[0], argv[1]);
+      goto quit;
+    }
+    sl = SctListThis(&sct->scriptLists);
+    if (sl == NULL) {
+      sc = NULL;
+    } else {
+      sc = SctChainThis(&sl->chains);
+    }
+    if (sc == NULL) {
+      SCPrintf(con, eError, "ERROR: no script was specified");
+      goto quit;
+    }
+    SctFindNode(sct->currentNode, argv[2], &parent, &node);
+    if (node == NULL) {
+      name = argv[2];
+      goto nodeNotFound;
+    }
+    if (!SctAddNode2Script(sct, sc, node, con)) goto quit;
+    goto success;
+    
+  case scriptlist_keyword:
+    if (argc < 4) {
+      type == no_type;
+    } else {
+      type = SctFindKeyword(argv[2], slTypes);
+    }
+    if (type == no_type) {
+      SCPrintf(con, eError, "ERROR: should be  %s scriptList [set|timed|manual] <list>", argv[0]);
+      goto quit;
+    }
+    
+    for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
+      if (strcasecmp(sl->name, argv[2]) == 0) goto scriptListExists;
+    }
+    sl = calloc(1, sizeof(*sl));
+    if (sl == NULL) goto noMemory;
+    sl->name = strdup(argv[3]);
+    sl->type = type;
+    sl->beginScript = NULL;
+    sl->endScript = NULL;
+    sl->lastPeriod = 0.0;
+    sl->lastScript = NULL;
+    sl->chains.head = NULL;
+    sl->interval = 1e-6;
+    sl->dirty = (type == timed_type);
+    SctListAdd(&sct->scriptLists, sl);
+    break;
+    
+  case interval_keyword:
+    if (argc < 3) {
+      SCPrintf(con, eError, "ERROR: should be  %s interval <list> [<value>]", argv[0]);
+      goto quit;
+    }
+    for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
+      if (strcasecmp(sl->name, argv[2]) == 0) break;
+    }
+    if (sl == NULL) goto scriptListNotFound;
+    if (argc > 3) {
+      interval = atof(argv[3]);
+      if (interval < 1e-6) {
+        sl->interval = 1e-6;
+        interval = 0;
+      } else {
+        sl->interval = interval;
+      }
+    } else {
+      interval = sl->interval;
+      if (interval <= 1.001e-6) {
+        interval = 0;
+      }
+    }
+    SCPrintf(con, eValue, "%s %s = %.5g (sec)", argv[0], argv[1], sl->interval);
+    return 1;
+    
+  case beginscript_keyword:
+  
+  case endscript_keyword:
+    if (argc < 4) {
+      SCPrintf(con, eError, "ERROR: should be  %s %s <list> <script>", argv[0], argv[1]);
+      goto quit;
+    }
+    for (sl = sct->scriptLists.head; sl != NULL; sl = sl->next) {
+      if (strcasecmp(sl->name, argv[2]) == 0) break;
+    }
+    if (sl == NULL) goto scriptListNotFound;
+    sc = SctMakeChain(ConcatArgs(argc-3, argv+3));
+    sc->relatedNode = sct->currentNode;
+    sc->scriptList = sl;
+    if (keyword == beginscript_keyword) {
+      sl->beginScript = sc;
+    } else {
+      sl->endScript = sc;
+    }
+    break;
+    
+  case connect_keyword:
+    if (argc < 3) {
+      SCPrintf(con, eError, "ERROR: should be  %s connect <protocol> <host:port> ...", argv[0]);
+      goto quit;
+    }
+    if (sct->ascon) AsconKill(sct->ascon);
+    sct->ascon = AsconMake(con, argc - 2, argv + 2);
+    if (!sct->ascon) goto quit;
+    break;
+    
+  case path_keyword:
+    if (argc > 3) {
+      SCPrintf(con, eError, "ERROR: should be  %s path [<path>]", argv[0]);
+      goto quit;
+    }
+    if (argc == 3) {
+      SctFindNode(sct->currentNode, argv[2], &parent, &node);
+      if (node == NULL) {
+        name = argv[2];
+        goto nodeNotFound;
+      }
+    }
+    if (!SctGetPath(sct->currentNode, path, sizeof path)) {
+      SCWrite(con, "ERROR: node not anchored or path name too long", eError);
+      goto quit;
+    }
+    SCWrite(con, path, eValue);
+    goto success;
+    
+  case debug_keyword:
+    if (argc < 2) {
+      SCPrintf(con, eError, "ERROR: should be  %s debug [0 | <steps>]", argv[0]);
+      goto quit;
+    }
+    if (argc < 3) {
+      i = 1;
+    } else {
+      i = atoi(argv[2]);
+    }
+    if (i != 0) {
+      sct->taskSteps = i;
+      sct->debugConn = SCSave(con, sct->debugConn);
+      sct->verbose = 1;
+      while (sct->taskSteps > 0) {
+        SctTask(sct);
+      }
+      return 1;
+    } else {
+      sct->taskSteps = -1;
+      sct->verbose = 0;
+    }
+    break;
+    
+  case error_keyword:
+    list = AsconGetErrList(sct->ascon);
+    for (msg = ErrMsgFirst(list); msg != NULL; msg = msg->next) {
+      age = time(NULL) - msg->last;
+      if (age < 3600) {
+        snprintf(timetext, sizeof timetext, "%2ldm%2.2lds", age/60, age % 60);
+      } else if (age < 99*3600) {
+        age = age / 60;
+        snprintf(timetext, sizeof timetext, "%2ldh%2.2ldm", age/60, age % 60);
+      } else {
+        snprintf(timetext, sizeof timetext, "%5ldh", age/(24*3600));
+      }
+      if (msg->data) {
+        SCPrintf(con, eError, "--- %s ago, cnt %5d %s", timetext, msg->cnt, msg->data);
+      } else {
+        SCPrintf(con, eError, "--- %s ago, cnt %5d", timetext, msg->cnt, msg->data);
+      }
+      SCWrite(con, msg->text, eError);
+    }
+    return 1;
+    
+  case send_keyword:
+    if (argc < 3) {
+      SCPrintf(con, eError, "ERROR: should be  %s send <command>", argv[0]);
+      goto quit;
+    }
+    if (sct->debugCommand != NULL) {
+      SCPrintf(con, eError, "ERROR: busy");
+      goto quit;
+    }
+    sct->sent = 0;
+    sct->debugConn = SCSave(con, sct->debugConn);
+    sct->debugCommand = ConcatArgs(argc - 2, argv + 2);
+    goto success;
+    
+  case no_keyword:
+    SCPrintf(con, eError, "ERROR: %s %s: unknown keyword", argv[0], argv[1]);
+    goto quit;
+    
+  default:
+    SCPrintf(con, eError, "ERROR: %s %s: untreated keyword", argv[0], argv[1]);
+    goto quit;
+  }
+  SCSendOK(con);
+success:
+  sct->operation = sct_no_keyword;
+  return 1;
+noMemory:
+  SCWrite(con, "ERROR: no memory", eError);
+  goto quit;
+missingScriptList:
+  SCPrintf(con, eError, "ERROR: script list %s not found", argv[2]);
+  goto quit;
+scriptListExists:
+  SCWrite(con, "ERROR: script list exists", eError);
+  goto quit;
+nodeExists:
+  SCPrintf(con, eError, "ERROR: node %s exists", argv[2]);
+  goto quit;
+nodeNotFound:
+  SCPrintf(con, eError, "ERROR: node %s not found", name);
+  goto quit;
+scriptListNotFound:
+  SCPrintf(con, eError, "ERROR: script list %s not found", argv[2]);
+  goto quit;
+quit:
+  sct->operation = sct_no_keyword;
+  return 0;
+}
+
+static int SctInit(SConnection *con, int argc, char *argv[], int dynamic) {
+  /* syntax: makeobject <name> sct */
+  
+  if (sct) {
+    SCPrintf(con, eError, "ERROR: script context busy");
+    return 0;
+  }
+    
+  if (argc != 3) {
+    SCPrintf(con, eError, "ERROR: should be: makeobject <name> sct");
+    return 0;
+  }
+  
+  sct = calloc(1,sizeof(*sct));
+  assert(sct);
+  sct->desc = CreateDescriptor("sct");
+  assert(sct->desc);
+  sct->scriptLists.head = NULL;
+  sct->cmd = NULL;
+  sct->result = NULL;
+  sct->nextScript = NULL;
+  sct->runningChain = NULL;
+  sct->debugConn = NULL;
+  sct->debugCommand = NULL;
+  sct->verbose = 0;
+  sct->taskSteps = -1;
+  sct->name = strdup(argv[1]);
+  if (!AddCommand(pServ->pSics, argv[1], SctAction, SctKillObj, sct)) {
+    SCPrintf(con, eError, "%s already exists", argv[1]);
+    SctKill(sct);
+    goto quit;
+  }
+  TaskRegister(pServ->pTasker, SctTask, NULL, SctKillTask, sct, 0);
+  sct->killObj = 0;
+  sct->killTask = 0;
+  sct = NULL;
+  return 1;
+quit:
+  sct = NULL;
+  return 0;
+}
+
+/** \brief the startup routine */
+void SctStartup(void) {
+  MakeDriver("sct", SctInit, 0, "Script Context Driver");
+  AddCmd("sct", SctExec);
+}