syslib.c

Go to the documentation of this file.

#ifndef NO_DOXYGEN
#include "prolog.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <stdarg.h>
#ifdef UNIX
# include <dirent.h>
#endif
#ifdef MSDOS
# include <signal.h>
# include <dos.h>
# include "doscmd.h"
# include "watchdog.h"
#endif
#ifdef WINNT
# include "io.h"
# include "ntcmd.h"
#endif
#ifdef NIOS
# include "nioscmd.h"
#endif
#include "servdef.h"
#include "database.h"
#include "errors.h"
#include "brdcast.h"
#include "history.h"
#include "srvip.h"
#include "toolkit.h"

int initRPC(void);
int initSAPWatchDog(void);
void FecSynchronize(void);
void initWatchDog(void);
void watchDog(void);
void netWatchDog(void);
int rdate(char *tsHost);
char *whoami(char *user);
extern FunHead FunList[];
time_t *tnull = NULL;
char tagNameFilter[64];
char  dbgbuf[256];
int StartupDebug = 1;
extern int gDelayInitRPCServices;
#ifndef NODAL
EXPORT int NGdebug=0;
#endif
#if !defined(IPXNW) && !defined(IPXBSD)
BYTE reg_socket[2] = { 0, 0 };
IPXAddress IncomingIPXfec;
#endif

char gUserName[20] = "";
FILE *dbgfp = NULL;
WORD watchdogBaseAddress = 0x0000;
int MaxNumGlobals = MAXGLOBALS;
#ifndef GLOBAL_SYNCHRONIZATION
# define GLOBAL_SYNCHRONIZATION TRUE
#endif

#ifndef STD_TIME_STR
# define STD_TIME_STR "CET"
#endif
#ifndef DST_TIME_STR
# define DST_TIME_STR "CDT"
#endif
#ifndef STD_TIMEZONE_STR
# define STD_TIMEZONE_STR "TZ=GMT-1GDT"
#endif
#ifndef DLT_TIMEZONE_STR
# define DLT_TIMEZONE_STR "TZ=GMT-1GDT"
#endif
#ifndef STD_TIME_UTC_OFFSET
# define STD_TIME_UTC_OFFSET 0
#endif
#ifndef NLINES
# define NLINES 1000
#endif

char *ltzname[2] = { STD_TIME_STR, DST_TIME_STR };
char FecDBpath[80];
char *vFeclogBuffer = NULL;
int vFeclogBufferPos = 0;
int leftFeclogTime = FALSE;
char *getTimeServerHost(void);
int METFindDaylight(time_t t);
int NoDstFindDaylight(time_t t);
int (*findDaylightHook)(time_t) = METFindDaylight;

EXPORT void (*cdiSystemInitHook)(void) = NULL;
EXPORT int (*cdiCloseLinkHook)(int) = NULL;
EXPORT char *(*getCdiLinkNameHook)(char *,char *) = NULL;
EXPORT int (*cdiExecLinkHook)(char *,char *,DTYPE *,DTYPE *,short,UINT16) = NULL;
EXPORT int (*cdiAttachLinkHook)(char *,char *,DTYPE *,DTYPE *,short,int,void (*)(int,int),int,UINT32) = NULL;
EXPORT void (*cdiSystemFreeHook)(void) = NULL;

void fixLocalTimeSettings(void)
{
  char *ptr=NULL;
  if ((ptr=getenv("STD_TIME_STR")) != NULL)
  {
    ltzname[0] = ptr;
  }
  if ((ptr=getenv("DST_TIME_STR")) != NULL)
  {
    ltzname[1] = ptr;
  }
  if (!strcmp(ltzname[0],ltzname[1])) /* no dst ! */
  {
    findDaylightHook = NoDstFindDaylight;
  }
}
EXPORT UINT32 ElfHash(const unsigned char *key)
{
  UINT32 g, h = 0;
  while (*key)
  {
    h = (h << 4) + *key++;
    g = h & 0xF0000000L;
    if (g) h ^= g >> 24;
    h &= ~g;
  }
  return h;
}
EXPORT int getFormatSize(int fmt)
{
  switch (fmt)
  {
    case CF_DOUBLE  : return 8;
    case CF_SHORT   : return 2;
    case CF_BYTE    : return 1;
    case CF_LONG    : return 4;
    case CF_FLOAT   : return 4;
    case CF_STRUCT  : return 1;
    case CF_POCALBLK: return 1;
    case CF_CHAR8   : return 8;
    case CF_CHAR16  : return 16;
    case CF_CHAR32  : return 32;
    case CF_CHAR48  : return 48;
    case CF_CHAR64  : return 64;
    case CF_CHAR16FI: return 24;
    case CF_SI      : return 6;
    case CF_FI      : return 8;
    case CF_II      : return 8;
    case CF_DI      : return 12;
    case CF_TDS     : return 12;
    case CF_HITTS   : return 6;
    case CF_CHAR8I  : return 12;
    case CF_CHAR16I : return 20;
    case CF_CHAR32I : return 36;
    case CF_CHAR48I : return 52;
    case CF_CHAR64I : return 68;
    case CF_USTRING : return 96;
    case CF_FFI     : return 12;
    case CF_FII     : return 12;
    case CF_IFFF    : return 16;
    case CF_IIII    : return 16;
    case CF_TTII    : return 16;
    case CF_IIFF    : return 16;
    case CF_FIFI    : return 16;
    case CF_XY      : return  8;
    case CF_TDSI    : return 12;
    case CF_SPECTRUM: return  4;
    case CF_TEXT    : return  1;
    case CF_XML     : return  1;
    case CF_BOOLEAN : return  4;
    case CF_BIT     : return  4;
    case CF_LNGDBL  : return  12;
    case CF_FLTDBL  : return  12;
    case CF_DBLDBL  : return  16;
    case CF_NAMEDBLDBL : return  32;
    case CF_NAME16II : return  24;
    case CF_III     : return  12;
    case CF_NAME32DBLDBL : return  48;
    case CF_NAME64DBLDBL : return  80;
    case CF_IFFFNAME : return  32;
    case CF_DEFAULT : return  1;
    default : break;
  }
  return 0;
}
short ftoi(char *fmt)
{
  char *c,fmtstr[64];
  short ifmt;
  strncpy(fmtstr,fmt,64);
  if ((c=strchr(fmtstr,'.')) != NULL) *c = 0;
  strupr(fmtstr);
  if ((ifmt=getSimpleFormatType(fmtstr)) != CF_NULL) return ifmt;
  return getCompoundFormatType(fmtstr);
}
char *itof(int fmt)
{
  static char s[64];
  switch(LFMT(fmt))  
  {                 
    case CF_BYTE: return "BYTE";
    case CF_SHORT: return "short";
    case CF_LONG: return "UINT32";
    case CF_FLOAT: return "float";
    case CF_DOUBLE: return "double";
    case CF_TEXT: return "char";
    case CF_NAME8: return "NAME8";
    case CF_NAME16: return "NAME16";
    case CF_NAME32: return "NAME32";
    case CF_NAME48: return "NAME48";
    case CF_NAME64: return "NAME64";
    case CF_LNGINT: return "LNGINT";
    case CF_FLTINT: return "FLTINT";
    case CF_DBLDBL: return "DBLDBL";
    case CF_NAME8I: return "NAME8I";
    case CF_NAME16I: return "NAME16I";
    case CF_NAME32I: return "NAME32I";
    case CF_NAME48I: return "NAME48I";
    case CF_NAME64I: return "NAME64I";
    case CF_NAME16FI: return "NAME16FLTINT";
    case CF_NAME16II: return "NAME16INTINT";
    case CF_INTFLTINT: return "INTFLTINT";
    case CF_FLTINTINT: return "FLTINTINT";
    case CF_FLTFLTINT: return "FLTFLTINT";
    case CF_FILTER: return "FILTER";
    case CF_ADDRESS: return "ADDRESS";
    case CF_USTRING: return "USTRING";
    case CF_SPECTRUM: return "SPECTRUM";
    case CF_POINT: return "POINT";
    case CF_WINDOW: return "WINDOW";
    case CF_BOOLEAN: return "BOOLEAN";
    case CF_IIFF: return "IIFF";
    case CF_FIFI: return "FIFI";
    default: break;
  }
  sprintf(s,"%d",LFMT(fmt));
  return s;
}
short getArrayType(char *fmt)
{
  char *c,typstr[64];
  short itype = AT_UNKNOWN;
  if ((c=strchr(fmt,'.')) == NULL) return itype;
  c++; strncpy(typstr,c,64); strupr(typstr);
  if (strstr(typstr,"BOOLEAN") != NULL) itype = AT_BOOLEAN;
  if (strstr(typstr,"DOUBLE") != NULL) itype = AT_DOUBLE;
  if (strstr(typstr,"CHANNEL") != NULL) itype |= AT_CHANNEL;
  else if (strstr(typstr,"SPECTRUM") != NULL) itype |= AT_SPECTRUM;
  else if (strstr(typstr,"TRACE") != NULL) itype |= AT_SPECTRUM;
  else if (strstr(typstr,"WAVEFORM") != NULL) itype |= AT_SPECTRUM;
  else if (strstr(typstr,"UNSTRUCTURED") != NULL) itype |= AT_UNSTRUCTURED;
  else if (strstr(typstr,"BLOB") != NULL) itype |= AT_UNSTRUCTURED;
  else if (strstr(typstr,"IMAGE") != NULL) itype |= AT_UNSTRUCTURED;
  else if (strstr(typstr,"STRUCTURED") != NULL) itype |= AT_STRUCTURED;
  return itype;
}
short getArrayRowLength(char *fmt)
{
  char *c,typstr[64];
  if ((c=strstr(fmt,"DOUBLE.")) == NULL) return 0;
  c++; strncpy(typstr,c,64); strupr(typstr);
  if ((c=strchr(typstr,'X')) != NULL) c++; else c = typstr;
  return atoi(c);
}
short mtoi(char *mod)
{
  short accessMode = CA_NULL;

  if (strstr(strupr(mod),"READ")) accessMode |= CA_READ;
  if (strstr(mod,"WRITE"))        accessMode |= CA_WRITE;
  if (strstr(mod,"ASYNC"))        accessMode |= CA_ASYNC;

  return accessMode;
}

char *itom(short accessMode)
{
  static char accessModeStr[32];

  accessModeStr[0] = 0;
  if (accessMode & 0x01) strcat(accessModeStr,strlen(accessModeStr)?"|READ":"READ");
  if (accessMode & 0x02) strcat(accessModeStr,strlen(accessModeStr)?"|WRITE":"WRITE");
  if (accessMode & 0x04) strcat(accessModeStr,strlen(accessModeStr)?"|ASYNC":"ASYNC");
  if (strlen(accessModeStr) == 0) strcat(accessModeStr,"NO");

  strcat(accessModeStr," ACCESS");
  return accessModeStr;
}
time_t startuptime;
double gDataTimeStamp;                                      /* System Timestamp  */
double gServerDataTimeStamp;                                /* System Timestamp for server thread */
double gDataTimeStampOffset = 0.0;                          /* for external synchronization */
void hardDelay(int msec)
{
  struct timeval tv0,tv;
  gettimeofday(&tv0,(struct timezone *)NULL);
  tv = tv0;
  while (MSECS(tv,tv0) < msec) gettimeofday(&tv,(struct timezone *)NULL);
}
short SychronizeFecClock = 1;
#ifdef MSDOS
void GetCommand(void);
#else
int readvFecLog(char *textbuf,int sizeInBytes);
int vfeclog(char *text);
#endif
#ifdef MSDOS
#pragma warn -wccc
#pragma warn -rch
#endif
void DataDump(char *txt,char *data,int siz,short fmt,short dir)
{
  int i,j,l,fsiz,msiz;
  float  fdat;
  UINT32 ldat,tdat;
  short  sdat;
  double ddat,ddat2;
  time_t timdat;

  dbglog("%s %d entries %s\n",txt,siz,dir == RTOL ? "received" : "returned");
  dbgbuf[0] = 0;
  switch (fmt)
  {
   case CF_SHORT:
       for (i=0;i<siz;i++)
       {
          memcpy(&sdat,(short *)&data[i*2],2);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%d ",sdat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_LONG:
       for (i=0;i<siz;i++)
       {
          memcpy(&ldat,(UINT32 *)&data[i*4],4);
#         ifdef MSDOS
          sprintf(&dbgbuf[strlen(dbgbuf)],"%ld ",ldat);
#         else
          sprintf(&dbgbuf[strlen(dbgbuf)],"%d ",ldat);
#         endif
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_FLOAT:
       for (i=0;i<siz;i++)
       {
          memcpy(&fdat,(float *)&data[i*4],4);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%g ",fdat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_BYTE:
       for (i=0;i<siz;i++)
       {
          sprintf(&dbgbuf[strlen(dbgbuf)],"%d ",((unsigned char *)data)[i]);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
    case CF_DOUBLE:
       for (i=0;i<siz;i++)
       {
          memcpy(&ddat,(double *)&data[i*8],8);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%g ",ddat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_TEXT:
       for (i=0,j=0; i<siz; i++)
       {
          dbgbuf[j++] = data[i];
          if (j > 254) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = j = 0; }
       }
       break;
   case CF_NAME8:
   case CF_NAME16:
   case CF_NAME32:
   case CF_NAME48:
   case CF_NAME64:
       fsiz = fmtsizeof(fmt); msiz = 64/fsiz;
       for (i=0,j=0;i<siz;i++)
       {
          for (l=0; l<fsiz; l++) dbgbuf[j++] = data[i*fsiz+l];
          if ((i+1)%msiz == 0)  { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = j = 0; }
          else dbgbuf[j++] = ' ';
       }
       break;
#  ifndef SMALL_TINE_LIB /* for MSDOS, etc. ... */
   case CF_II:
       for (i=0;i<siz;i++)
       {
          memcpy(&ldat,(UINT32 *)&data[i*8],4);
          memcpy(&tdat,(UINT32 *)&data[i*8+4],4);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%d %d  ",ldat,tdat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_FI:
       for (i=0;i<siz;i++)
       {
          memcpy(&fdat,(float *)&data[i*8],4);
          memcpy(&tdat,(UINT32 *)&data[i*8+4],4);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%g %d  ",fdat,tdat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_DI:
       for (i=0;i<siz;i++)
       {
          memcpy(&ddat,(double *)&data[i*12],8);
          memcpy(&tdat,(UINT32 *)&data[i*12+8],4);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%g %d  ",ddat,tdat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_DBLDBL:
       for (i=0;i<siz;i++)
       {
          memcpy(&ddat2,(double *)&data[i*16],8);
          memcpy(&ddat,(double *)&data[i*16+8],8);
          sprintf(dbgbuf,"%g %g (%10.4f)\n",ddat2,ddat,ddat);
          dbglog(dbgbuf);
       }
       break;
   case CF_NAMEDBLDBL:
       for (i=0,j=0;i<siz;i++)
       {
          for (l=0; l<16; l++) dbgbuf[j++] = data[i*32+l];
          memcpy(&ddat2,&data[i*32+16],8);
          memcpy(&ddat,&data[i*32+24],8);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %g %g\n",ddat2,ddat);
          dbglog(dbgbuf); dbgbuf[0] = j = 0;
       }
       break;
   case CF_TDS:
       for (i=0;i<siz;i++)
       {
          memcpy(&tdat,(UINT32 *)&data[i*12],4);
          memcpy(&fdat,(float *)&data[i*12+4],4);
          memcpy(&ldat,(UINT32 *)&data[i*12+8],4);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%d %g %d  ",tdat,fdat,ldat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_NAME16I:
       for (i=0,j=0;i<siz;i++)
       {
          for (l=0; l<16; l++) dbgbuf[j++] = data[i*20+l];
          memcpy(&ldat,&data[i*20+16],4);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %d\n",ldat);
          dbglog(dbgbuf); dbgbuf[0] = j = 0;
       }
       break;
   case CF_NAME8I:
       for (i=0,j=0;i<siz;i++)
       {
          for (l=0; l<8; l++) dbgbuf[j++] = data[i*12+l];
          memcpy(&ldat,&data[i*12+8],4);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %d\n",ldat);
          dbglog(dbgbuf); dbgbuf[0] = j = 0;
       }
       break;
   case CF_NAME32I:
       for (i=0,j=0;i<siz;i++)
       {
          for (l=0; l<32; l++) dbgbuf[j++] = data[i*36+l];
          memcpy(&ldat,&data[i*36+32],4);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %d\n",ldat);
          dbglog(dbgbuf); dbgbuf[0] = j = 0;
       }
       break;
   case CF_NAME48I:
       for (i=0,j=0;i<siz;i++)
       {
          for (l=0; l<52; l++) dbgbuf[j++] = data[i*52+l];
          memcpy(&ldat,&data[i*52+48],4);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %d\n",ldat);
          dbglog(dbgbuf); dbgbuf[0] = j = 0;
       }
       break;
   case CF_NAME16FI:
       for (i=0,j=0;i<siz;i++)
       {
          for (l=0; l<16; l++) dbgbuf[j++] = data[i*24+l];
          memcpy(&fdat,&data[i*24+16],4);
          memcpy(&ldat,&data[i*24+20],4);
#         ifdef MSDOS
          sprintf(&dbgbuf[strlen(dbgbuf)]," %f %ld\n",fdat,ldat);
#         else
          sprintf(&dbgbuf[strlen(dbgbuf)]," %f %d\n",fdat,ldat);
#         endif
          dbglog(dbgbuf); dbgbuf[0] = j = 0;
       }
       break;
   case CF_FFI:
       for (i=0;i<siz;i++)
       {
          memcpy(&fdat,(float *)&data[i*12],4);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%g",fdat);
          memcpy(&fdat,(float *)&data[i*12+4],4);
          memcpy(&tdat,(UINT32 *)&data[i*12+8],4);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %g %d  ",fdat,tdat);
          if ((i+1)%3 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_IFFF:
       for (i=0;i<siz;i++)
       {
          memcpy(&tdat,(UINT32 *)&data[i*16],4);
          memcpy(&fdat,(float *)&data[i*16+4],4);
#         ifdef MSDOS
          sprintf(&dbgbuf[strlen(dbgbuf)],"%ld %g",tdat,fdat);
#         else
          sprintf(&dbgbuf[strlen(dbgbuf)],"%d %g",tdat,fdat);
#         endif
          memcpy(&fdat,(float *)&data[i*16+8],4);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %g",fdat);
          memcpy(&fdat,(float *)&data[i*16+12],4);
          sprintf(&dbgbuf[strlen(dbgbuf)]," %g  ",fdat);
          if ((i+1)%2 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
   case CF_USTRING:
       for (i=0;i<siz;i++)
       {
          memcpy(&tdat,(UINT32 *)&data[i*96],4);
          memcpy(&fdat,(float *)&data[i*96+4],4);
#         ifdef MSDOS
          sprintf(&dbgbuf[strlen(dbgbuf)],"%ld %g",tdat,fdat);
#         else
          sprintf(&dbgbuf[strlen(dbgbuf)],"%d %g",tdat,fdat);
#         endif
          memcpy(&fdat,(float *)&data[i*96+8],4);
          memcpy(&tdat,(UINT32 *)&data[i*96+12],4);
#         ifdef MSDOS
          sprintf(&dbgbuf[strlen(dbgbuf)]," %g %ld %s\n",fdat,tdat,&data[i*96+16]);
#         else
          sprintf(&dbgbuf[strlen(dbgbuf)]," %g %d %s\n",fdat,tdat,&data[i*96+16]);
#         endif
          dbglog(dbgbuf); dbgbuf[0] = 0;
       }
       break;
   case CF_SPECTRUM:
       timdat = (time_t)(*((UINT32 *)&data[80]));
#      ifdef MSDOS
       sprintf(&dbgbuf[strlen(dbgbuf)],"%s\n>%s>start: %g\n>inc: %g\n>status: %lu\n",
#      else
       sprintf(&dbgbuf[strlen(dbgbuf)],"%s\n>%s>start: %g\n>inc: %g\n>status: %u\n",
#      endif
               (char *)&data[0],ctime(&timdat),*((float *)&data[84]),
               *((float *)&data[88]),*((UINT32 *)&data[92]));
       dbglog(dbgbuf); dbgbuf[0] = 0;
       for (i=0;i<siz;i++)
       {
          memcpy(&fdat,&data[96+i*4],4);
          sprintf(&dbgbuf[strlen(dbgbuf)],"%g ",fdat);
          if ((i+1)%8 == 0) { strcat(dbgbuf,"\n"); dbglog(dbgbuf); dbgbuf[0] = 0; }
       }
       break;
#  endif /* SMALL_TINE_LIB */
   default:
       dbgbuf[0] = 0;
       break;
  }
  strcat(dbgbuf,"\n"); 
  dbglog(dbgbuf);
}

int datacmp(BYTE *d1,BYTE *d2,int siz,int fmt,double t)
/* compares array d1[siz] against d2[siz] with given format
   and tolerance */
{
  int fmtsize,i;

  fmtsize = fmtsizeof(fmt);
  if (!memcmp(d1,d2,siz*fmtsize)) return 0;
  if ((short)t == 0) return 1;

  /* data have changed, but by how much? */
  switch (fmt)
  {
   case CF_DOUBLE:
       for (i=0; i<siz; i++)
        if ( ((double *)d1)[i] < ((double *)d2)[i] - t ||
             ((double *)d1)[i] > ((double *)d2)[i] + t ) return 1;
       return 0;
   case CF_SHORT:
       for (i=0; i<siz; i++)
        if ( ((short *)d1)[i] < ((short *)d2)[i] - (short)t ||
             ((short *)d1)[i] > ((short *)d2)[i] + (short)t ) return 1;
       return 0;
   case CF_LONG:
       for (i=0; i<siz; i++)
        if ( ((UINT32 *)d1)[i] < ((UINT32 *)d2)[i] - (UINT32)t ||
             ((UINT32 *)d1)[i] > ((UINT32 *)d2)[i] + (UINT32)t ) return 1;
       return 0;
   case CF_FLOAT:
       for (i=0; i<siz; i++)
        if ( ((float *)d1)[i] < ((float *)d2)[i] - (float)t ||
             ((float *)d1)[i] > ((float *)d2)[i] + (float)t ) return 1;
       return 0;
   case CF_BYTE:
       for (i=0; i<siz; i++)
        if ( ((BYTE *)d1)[i] < ((BYTE *)d2)[i] - (BYTE)t ||
             ((BYTE *)d1)[i] > ((BYTE *)d2)[i] + (BYTE)t ) return 1;
       return 0;
  }
  return -1;
}
EXPORT int reformat(BYTE *dstData,int dstFmt,BYTE *srcData,int srcFmt,int num)
{
  DTYPE d;
  UINT32 n = (UINT32)num;

  if (dstFmt == srcFmt) return  0;

  d.dArrayLength = num;
  d.dFormat = srcFmt;
  d.data.bptr = srcData;

  switch (dstFmt)
  {
    case CF_SHORT: return getValuesAsShort(&d,(short *)dstData,(short)num);
    case CF_LONG: return getValuesAsLong(&d,(UINT32 *)dstData,(short)num);
    case CF_FLOAT: return getValuesAsFloat(&d,(float *)dstData,(short)num);
    case CF_DOUBLE: return getValuesAsDouble(&d,(double *)dstData,(short)num);
    case CF_TEXT: return getValuesAsString(&d,(char *)dstData,&n);
    case CF_NAME8: return getValuesAsString(&d,((NAME8 *)dstData)->name,&n);
    case CF_NAME16: return getValuesAsString(&d,((NAME16 *)dstData)->name,&n);
    case CF_NAME32: return getValuesAsString(&d,((NAME32 *)dstData)->name,&n);
    case CF_NAME48: return getValuesAsString(&d,((NAME48 *)dstData)->name,&n);
    case CF_NAME64: return getValuesAsString(&d,((NAME64 *)dstData)->name,&n);
  }
  return illegal_format;
}

#if defined(MSDOS)|defined(VAX_VMS)|defined(WINNT)
EXPORT struct timeval *gettimeofday(struct timeval *t,struct timezone *tz)
{
  struct timeb tb;
  ftime(&tb);
  t->tv_sec  = (long)tb.time;
  t->tv_usec = ((UINT32)tb.millitm)*1000L;
  return t;
}
#elif defined(VXWORKS)
struct timeval *gettimeofday(struct timeval *t,struct timezone *tz)
{
  struct timespec ts;
  clock_gettime(CLOCK_REALTIME,&ts);
  t->tv_sec  = ts.tv_sec;
  t->tv_usec = ts.tv_nsec/1000;
  return t;
}
int millisleep(int msecs)
{
# ifdef USE_TASKDELAY
  static int tps = 0;
  if (tps == 0) tps = sysClkRateGet();
  return taskDelay((tps * msecs)/1000);
# else
  struct timespec ts;
  ts.tv_sec = msecs/1000;
  ts.tv_nsec = (msecs%1000) * 1000000;
  return nanosleep(&ts,NULL);
# endif
}
#endif

int findDaylight(time_t t)
{
  return (findDaylightHook != NULL) ? findDaylightHook(t) : 0;
}
int NoDstFindDaylight(time_t t) 
{
  t = t;
  return 0;
}
int METFindDaylight(time_t t)
{
  int dl;
  struct tm *tm = localtime(&t);
# if defined(UNIX) || defined(WINNT)
  if (tm->tm_isdst > 0) return 1;
  if (tm->tm_isdst == 0) return 0;
# endif
  if      (tm->tm_mon<2 || tm->tm_mon>9)       dl = 0;  /* winter */
  else if (tm->tm_mon>2 && tm->tm_mon<9)       dl = 1;  /* summer */
  else if (tm->tm_mon==2)                               /* March */
  { if      (tm->tm_mday < 25)                  dl = 0;
    else if (tm->tm_wday > tm->tm_mday-25)      dl = 0;
    else if (tm->tm_wday == 0 && tm->tm_hour<2) dl = 0; /* Sunday */
    else dl = 1;
  }
  else                                                  /* October */
  { if      (tm->tm_mday < 25)                  dl = 1;
    else if (tm->tm_wday > tm->tm_mday-25)      dl = 1;
    else if (tm->tm_wday == 0 && tm->tm_hour<2) dl = 1; /* Sunday */
    else dl = 0;
  }
  return dl;
}
int search_function(char name[6], FunHead **header, int *type)
{
  int i;
  FunHead *p;

  for (i=0; i<NumNodalFunctions; i++)
  {
    if (!strncmp(name,(p = &FunList[i])->F_name,6))
    {
      *type = p->F_type;
      *header = p;
      return 0;
    }
  }
  return non_existent;
}
char *whoami(char *user)
{
  char *up;
  static char usrnam[16];
# ifdef UNIX
  FILE *upipe = NULL;
# endif

  if (strlen(gUserName)) { strncpy(usrnam,gUserName,16); goto out; }
  strcpy(usrnam,"UNKNOWN");
  if ((up=getenv("LOGINAME"))  == NULL &&  /* Novell env. */
      (up=getenv("LOGINNAME")) == NULL &&  /*      "      */
      (up=getenv("USERNAME"))  == NULL &&  /*      NT     */
      (up=getenv("USER"))  == NULL)        /*     UNIX    */
       up = getenv("LOGNAME");             /*     UNIX    */
  if (up) strncpy(usrnam,up,15);
# if defined(VAX_VMS)
  else strncpy(usrnam,"VAX_USER",15);
# elif defined(VXWORKS)
  else strncpy(usrnam,"VXW_USER",15);
# elif defined(NIOS)
  else strncpy(usrnam,"NIOS_USER",15);
# elif defined(UNIX)
  else
  {
    if ((upipe=popen("whoami","r")) && fgets(usrnam,sizeof(usrnam),upipe))
      usrnam[strcspn(usrnam,"\n")] = 0; /* strip CR from whoami return */
    if (upipe != NULL) pclose(upipe);
  }
# endif
  strupr(usrnam);
out:
  if (NGdebug) dbglog("Recognizing user: %s",usrnam);
  if (user != NULL) strcpy(user,usrnam);
  return usrnam;
}
int isAbsolutePath(char *fname)
{
  if (fname == NULL || strlen(fname) < 2) return FALSE;
  if (fname[1] == ':') return TRUE;
  if (fname[0] == '\\') return TRUE;
  if (fname[0] == '/') return TRUE;
  return FALSE;
}
#define NotALogFile(f) (\
  strstr(f,".log") == NULL &&\
  strstr(f,".txt") == NULL &&\
  strstr(f,".ini") == NULL &&\
  strstr(f,".dat") == NULL &&\
  strstr(f,".cfg") == NULL &&\
  strstr(f,".csv") == NULL)
char gFeclogPath[80];
void applyFecLogPath(char *path,int pathlen)
{
  char root[256];
  int len = (int)strlen(gFeclogPath);
  if (path == NULL) return;
  if (isAbsolutePath(path)) return; /* nothing to apply */
  if (len + (int)strlen(path) > pathlen) 
  {
    dbglog("%s + %s too long!",gFeclogPath,path);
    return;
  }
  strncpy(root,gFeclogPath,80);
# if defined(UNIX) || defined(VXWORKS)
  if (len == 0) strcpy(root,"./");
# else
  if (len == 0) return; /* nothing to apply */
# endif
  strncat(root,path,128);
  strncpy(path,root,256); /* copy it back */
  return;
}
#define MAX_FILE_SCAN_LIMIT 100
int scanFecLogFiles(char *path,char *subpath,NAME64 *namebuf,int *numfiles,int numoffset)
{
  int n = numoffset;
  static int scancounter = 0;
# ifdef UNIX
  char fn[128],tfn[32];
# ifdef FECLOG_SCANDIR
  char spath[64];
# endif
  DIR *dp;
  struct dirent *dirp;
# ifdef FECLOG_SCANDIR
  int nread = 0;
# endif
# endif
# ifdef WINNT
  char fn[128],fnp[128],tfn[32],spath[64];
  struct _finddata_t fp;
  SINT32 hfp;
  int nread = 0;
# endif
# ifdef MSDOS
  char fn[128],fnp[128],tfn[32],spath[64];
  struct find_t fb;
  int nread = 0;
# endif

  if (namebuf == NULL || numfiles == NULL || *numfiles == 0) return argument_list_error;
  if (subpath != NULL) scancounter = 0;
# if defined(UNIX)
  if (path != NULL && strlen(path) > 0) strncpy(fn,path,128);
  if ((dp=opendir(fn)) == NULL) return no_such_file;
  while ((dirp=readdir(dp)) != NULL)
  {
    if (scancounter++ > MAX_FILE_SCAN_LIMIT) break;
    if (!strcmp(dirp->d_name,".") || !strcmp(dirp->d_name,"..")) continue;
#   ifdef FECLOG_SCANDIR
    if (dirp->d_type == DT_DIR)
    {
      if (strlen(path) + strlen(dirp->d_name) > 128) continue;
      if (subpath != NULL) strncpy(spath,subpath,60); else spath[0] = 0;
      strcat(path,dirp->d_name);
      strncpy(fn,path,128);
      strcat(spath,dirp->d_name); strcat(spath,"/");
      nread = *numfiles;
      scanFecLogFiles(fn,spath,namebuf,&nread,n);
      n = nread;
    }
#   endif
    strncpy(tfn,dirp->d_name,32); strlwr(tfn);
    if (NotALogFile(tfn)) continue;
    if (n >= *numfiles) break;
    if (subpath != NULL && strlen(subpath) + strlen(dirp->d_name) < 64)
    {
      sprintf(namebuf[n++].name,"%s%s",subpath,dirp->d_name);
    }
    else
    {
      strncpy(namebuf[n++].name,dirp->d_name,32);
    }
  }
  closedir(dp);
# elif defined(WINNT)
  if (strlen(path) > 0 && path[strlen(path)-1] != '\\') strcat(path,"\\");
  if (subpath != NULL) strncpy(spath,subpath,48);
  sprintf(fn,"%s*.*",path);
  if ((hfp=(SINT32)_findfirst(fn, &fp)) == -1) return no_such_file;
  do
  {
    if (scancounter++ > MAX_FILE_SCAN_LIMIT) break;
    if (!strcmp(fp.name,".") || !strcmp(fp.name,"..")) continue;
    if (fp.attrib & _A_SUBDIR)
    {
      if (subpath != NULL) strncpy(spath,subpath,60); else spath[0] = 0;
      strncpy(fnp,path,128);
      if (strlen(fnp) + strlen(fp.name) > 128) continue;
      if (strlen(spath) + strlen(fp.name) > 60) continue;
      strcat(fnp,fp.name); strcat(fnp,"\\");
      strcat(spath,fp.name); strcat(spath,"\\");
      nread = *numfiles;
      scanFecLogFiles(fnp,spath,namebuf,&nread,n);
      n = nread;
    }
    strncpy(tfn,fp.name,32); strlwr(tfn);
    if (NotALogFile(tfn)) continue;
    if (n >= *numfiles) break;
    if (subpath != NULL && strlen(subpath) + strlen(fp.name) < 64)
    {
      sprintf(namebuf[n++].name,"%s%s",subpath,fp.name);
    }
    else
    {
      strncpy(namebuf[n++].name,fp.name,32);
    }
  } while (_findnext(hfp,&fp) != -1);
# elif defined(MSDOS)
  if (strlen(path) > 0 && path[strlen(path)-1] != '\\') strcat(path,"\\");
  sprintf(fn,"%s*.*",path);
  if (_dos_findfirst(fn,_A_NORMAL,&fb) != 0) return no_such_file;
  do
  {
    if (scancounter++ > MAX_FILE_SCAN_LIMIT) break;
    if (!strcmp(fb.name,".") || !strcmp(fb.name,"..")) continue;
    if (fb.attrib & FA_DIREC)
    {
      if (subpath != NULL) strncpy(spath,subpath,60); else spath[0] = 0;
      strncpy(fnp,path,128);
      if (strlen(fnp) + strlen(fb.name) > 128) continue;
      if (strlen(spath) + strlen(fb.name) > 60) continue;
      strcat(fnp,fb.name); strcat(fnp,"\\");
      strcat(spath,fb.name); strcat(spath,"\\");
      nread = *numfiles;
      scanFecLogFiles(fnp,spath,namebuf,&nread,n);
      n = nread;
    }
    strncpy(tfn,fb.name,32); strlwr(tfn);
    if (NotALogFile(tfn)) continue;
    if (n >= *numfiles) break;
    if (subpath != NULL && strlen(subpath) + strlen(fb.name) < 64)
    {
      sprintf(namebuf[n++].name,"%s%s",subpath,fb.name);
    }
    else
    {
      strncpy(namebuf[n++].name,fb.name,13);
    }
  } while (_dos_findnext(&fb) == 0);
# endif
  *numfiles = n;
  return 0;
}
int readFecLog(char *textbuf,int sizeInBytes)
{
# ifndef MSDOS
  if (vFeclogBuffer != NULL) return readvFecLog(textbuf,sizeInBytes);
# endif
  return readFecLogFile("fec.log",textbuf,sizeInBytes);
}
int readFecLogFile(char *fname,char *textbuf,int sizeInBytes)
{
  int cc=0,useAbsolutePath=0;
  FILE *fp = NULL, *fpb = NULL;
  char fn[128],bakname[96], *c;
  int sz=0,szb=0,szt=0,pos=0;
# ifdef MSDOS
  static char *fmod = "r+t";
# else
  static char *fmod = "r";
# endif

  if (nofeclog) return 0;
  if (fname == NULL) return no_such_file;
  useAbsolutePath = isAbsolutePath(fname);
  if (useAbsolutePath) strncpy(fn,fname,128); else sprintf(fn,"%s%s",gFeclogPath,fname);
  if ((fp=fopen(fn,fmod)) == NULL) goto checkbak;
  fseek(fp,0,SEEK_END); sz = ftell(fp);
checkbak:
  if (sz < sizeInBytes)  /* look for back file */
  {
    szt = 0;
    strncpy(bakname,fname,95); bakname[95] = 0;
    if ((c=strstr(bakname,".log")) != NULL) *c = 0;
    strcat(bakname,".bak");
    if (useAbsolutePath) strncpy(fn,bakname,128); else sprintf(fn,"%s%s",gFeclogPath,bakname);
    if ((fpb=fopen(fn,fmod)) == NULL) goto filesread;
    szt = sizeInBytes - sz;
    fseek(fpb,0,SEEK_END); szb = ftell(fpb);
    if (szb > szt) pos = szb - szt;
    fseek(fpb,pos,SEEK_SET);
    szt = (int)fread(textbuf,1,szt,fpb);
    pos = 0;
    fclose(fpb);
  }
filesread:
  if (fp)
  {
    if (sz > sizeInBytes) pos = sz - sizeInBytes;
    fseek(fp,pos,SEEK_SET);
    szb = (int)fread(&textbuf[szt],1,sizeInBytes-szt,fp);
    fclose(fp);
    textbuf[szt+szb] = 0;
  }
  if (sz == 0 && szb == 0) cc = no_such_file;
  if (cc) dbglog("%s : %s",fn,erlst[cc]);
  return cc;
}
int writeFecLogFile(char *fname,char *textbuf,int sizeInBytes)
{
  int cc=0,useAbsolutePath=0;
# ifndef FS_RDONLY
  FILE *fp = NULL;
  char fn[128],fb[128], *c;
# ifdef MSDOS
  static char *fmod = "w+t";
# else
  static char *fmod = "w";
# endif

  if (fname == NULL) return no_such_file;
  if (sizeInBytes <= 0) return dimension_error;
  useAbsolutePath = isAbsolutePath(fname);
  if (useAbsolutePath) strncpy(fn,fname,128); else sprintf(fn,"%s%s",gFeclogPath,fname);
  strncpy(fb,fn,123); fb[123] = 0;
  if ((c=strchr(fb,'.')) != NULL) *c = 0;
  strcat(fb,".bak");
  remove(fb);
  rename(fn,fb);
  if ((fp=fopen(fn,fmod)) == NULL) ccerr(file_error);
  fwrite(textbuf,1,sizeInBytes,fp);
  fclose(fp);
# else 
  useAbsolutePath = 0;
  ccerr(not_implemented); /* no way to write a log file */
# endif
err:
  if (cc) dbglog("%s : %s",fn,erlst[cc]);
  return cc;
}
extern char TimeServerHost[64];
char *TimeServerHostPtr=NULL;
char *getTimeServerHost(void)
{
  char *ptr=NULL;
  if ((ptr=getenv("RDATE")) != NULL)
  {
    if (!strcmp(ptr,"NONE")) return NULL;
    strncpy(TimeServerHost,ptr,64);
  }
  else
  {
    if (TIME_SERVER_HOST != NULL) strncpy(TimeServerHost,TIME_SERVER_HOST,64);
    else return NULL;
  }
  return TimeServerHost;
}
int readSelfTest(char *eqm,char *textbuf,int sizeInBytes)
{
  int cnt=0,cc=0,sz=0;
  FILE *fp = NULL;
  char fn[96],lcl[16];
# ifdef MSDOS
  char *stext = "-t";
  static char *fmod = "r+t";
# else
  char *stext = "-selftest";
  static char *fmod = "r";
# endif
  strncpy(lcl,eqm,EQP_NAME_SIZE);
openSelfTestFile:
  textbuf[0] = 0;
  sprintf(fn,"%s%s%s.csv",FecDBpath,lcl,stext);
  if ((fp=fopen(fn,fmod)) == NULL) 
  {
    if (cnt++ == 0)
    {
      strlwr(lcl);                    /* try lower case local eqm name */
      goto openSelfTestFile;
    }
    ccerr(no_such_file);
  }
  sz = (int)fread(textbuf,1,sizeInBytes,fp);
  fclose(fp);
err:
  return sz;
}

#ifdef NIOS
int nr_setclock(SINT32 tgtTime);
extern time_t getUnixTime(char *tsHost);
int rdate(char *tsHost)
{
  int isdst;                         /* daylight saving time flag   */
  time_t utime=time(NULL);
  SINT32dt;

  isdst = findDaylight(utime);
  putenv(isdst ? DLT_TIMEZONE_STR : STD_TIMEZONE_STR);
  tzset();

  if ((utime=getUnixTime(tsHost)) == 0) return -1;
  if ((dt=nr_setclock(utime)) != 0) 
  {
    feclog("adjust system clock by %d seconds",dt);
  }
  return 0;
}
void FecShowtime(void)
{
  char tstr[32], s[80];
  time_t t = time(NULL);

  memset(tstr,0,32);
  strncpy(tstr,ctime(&t),19);
  sprintf(s,"current FEC time: %s (UNIX: %d)\n>",&tstr[4],t);
  ttyoutput(s);
}
int FecSettime(void)
{
  static time_t lastlogged = 0;
  time_t t;
  int delt,log = 0;

  t = time(NULL);
  rdate(TimeServerHostPtr);
  delt = (int)(time(NULL) - t);
  if (abs(delt) > 2) log = 1;
  if (t > lastlogged + (3600*24)) log = 1;
  if (NGdebug)
  {
    ttyoutput("time synchronized to server\n>");
    FecShowtime();
  }
  if (log)
  {
    feclog("synchronized (%d sec)",delt);
    lastlogged = t;
  }
  return 0;
}
void FecSynchronize(void)
{
  time_t t = time(NULL);

  if ((t % 3600) == 0)     /* sychronize once per hour */
  {
    FecSettime();
  }
}
#endif /* NIOS */

#ifdef MSDOS

int hConn,hControl;
WORD userConnNr;                     /* IPX connection number of PC */
extern time_t getUnixTime(char *tsHost);
int rdate(char *tsHost)
{
  struct dostime_t t, t0;
  struct dosdate_t d, d0;
  struct tm *lt;
  time_t utime = getUnixTime(tsHost);
  int isdst;                         /* daylight saving time flag   */

  isdst = findDaylight(utime);
  putenv(isdst ? DLT_TIMEZONE_STR : STD_TIMEZONE_STR);
  tzset();

  if (utime == 0) return -1;

  lt = localtime(&utime);

  _dos_gettime(&t); _dos_getdate(&d);
  memcpy(&d0,&d,sizeof(struct dosdate_t));
  memcpy(&t0,&t,sizeof(struct dostime_t));

  d.year  = 1900 + lt->tm_year;
  d.month = 1 + lt->tm_mon;
  d.day   = lt->tm_mday;
  t.hour  = lt->tm_hour;
  t.minute= lt->tm_min;
  t.second= lt->tm_sec;

  if (memcmp(&d,&d0,sizeof(struct dosdate_t)) ) _dos_setdate(&d);
  if (memcmp(&t,&t0,sizeof(struct dostime_t)) ) _dos_settime(&t);

  return 0;
}
int DiskErrorCount = 0;
#pragma argsused
int NetHandler(int errval,int ax,int bp,int si)
{
  if (ax > 0x04)hardretn(2);
  DiskErrorCount++;
  return 2;
}
UINT32 far *ColdBoot = (UINT32 far *)0x00400072L;
NodalError F_boot(void)
{
  feclog("Booting ...");
  *ColdBoot = 0x1234;
  asm DB 0EAh,0,0,0FFh,0FFh
  return 0;
}

#define WD_PFORTE 0
#define WD_BECKER 1
#ifndef WD_CARD
# define WD_CARD WD_PFORTE
#endif

#define WATCH_INTERVAL  5
#define WD_RESET(i)  ((i)+0x0003)
#define WD_POLL(i)   ((i)+0x0002)
#define WD_STATUS(i) ((i)+0x0001)

int watchdogEnabled = 0;
int watchdogType = WD_CARD;
void GetWatchDogBaseAddress(void)
{
  char *c,str[80];
  if ((c=getenv("WD_TYPE")) != NULL)
  {
    if (strstr(c,"BECKER") != NULL) watchdogType = WD_BECKER;
  }
  sprintf(str,"WD_TYPE : [%s]",c != NULL ? c : "");
  feclog(str);
  if ((c=getenv("WD_BASEADDR")) != NULL || (c=getenv("WATCHDOG")) != NULL)
  {
    watchdogBaseAddress = (WORD)strtol(c,NULL,0);
  }
  sprintf(str,"WD_BASEADDR : [%s]",c != NULL ? c : "");
  feclog(str);
}
void initWatchDog(void)
{
  char str[256];
  WORD baddr = watchdogBaseAddress;

  if (watchdogBaseAddress == 0) return;
  if (baddr < 0x240 || baddr > 0x400)
  {
    sprintf(str,"Illegal watchdog port : %x",baddr);
    watchdogBaseAddress = 0;
  }
  else
  {
    sprintf(str,"Initializing WATCHDOG at base address %x",baddr);
    if (watchdogType == WD_PFORTE)
    {
      outport(baddr,0x1111);           /* set pattern */
      outport(baddr+4,0x01);           /* enable watchdog */
      watchdogEnabled = 1;
    }
    else if (watchdogType == WD_BECKER)
    {
      outportb(WD_STATUS(baddr),0x01);    /* contact watchdog */
      outportb(watchdogBaseAddress,0x00); /* enable watchdog */
      watchdogEnabled = 1;
    }
  }
  feclog(str);
  return;
}
extern struct timeval thisCycleTime;
void watchDog(void)
{
  static unsigned int status, temp;
  static time_t t0 = 0;

  if (t0 == 0) initWatchDog();
  if (watchdogBaseAddress == 0) return;
  if (time(NULL) < t0 + WATCH_INTERVAL ||
      !watchdogBaseAddress ||
      !watchdogEnabled) return;
  t0 = time(NULL);

  if (watchdogType == WD_PFORTE)
  {
    outport(watchdogBaseAddress+2,0x1111);          /* feed watchdog */
    status = 1;
  }
  else if (watchdogType == WD_BECKER)
  {
    outportb(WD_POLL(watchdogBaseAddress),0x01);    /* feed watchdog */
    status = inportb(watchdogBaseAddress);
    temp = inportb(watchdogBaseAddress+1);
  }
  if (NGdebug>1)
  {
    dbglog("Watchdog %s (%x)",status == 1 ? "active" : "inactive",status);
    dbglog("Temperature %d (%x)",temp,temp);
  }
  return;
}
void enableWatchDog(void)
{
  if (!watchdogBaseAddress || watchdogEnabled) return;
  if (watchdogType == WD_PFORTE)
  {
    outport(watchdogBaseAddress,0x1111);           /* set pattern */
    outport(watchdogBaseAddress+4,0x01);           /* enable watchdog */
  }
  else if (watchdogType == WD_BECKER)
  {
    outportb(watchdogBaseAddress,0x00);           /* enable watchdog */
  }
  watchdogEnabled = 1;
  return;
}
void disableWatchDog(void)
{
  if (!watchdogBaseAddress || !watchdogEnabled) return;
  if (watchdogType == WD_PFORTE)
  {
    outport(watchdogBaseAddress+4,0x00);   /* disable watchdog */
  }
  else if (watchdogType == WD_BECKER)
  {
    outportb(watchdogBaseAddress,0x01);    /* disable watchdog */
  }
  watchdogEnabled = 0;
  return;
}
void FecShowtime(void)
{
  char tstr[32],strbuf[CMDSIZE];
  time_t t = time(NULL);

  memset(tstr,0,32);
  strncpy(tstr,ctime(&t),19);
  sprintf(strbuf,"current FEC time: %s (UNIX: %ld)\n>",&tstr[4],t);
  ttyoutput(strbuf);
}
int FecSettime(void)
{
  static time_t lastlogged = 0;
  time_t t;
  int delt,log = 0;
  char str[80];

  t = time(NULL);
  rdate(TimeServerHostPtr);
  delt = (int)(time(NULL) - t);
  if (abs(delt) > 2) log = 1;
  if (t > lastlogged + (3600*24)) log = 1;
  if (NGdebug)
  {
    ttyoutput("time synchronized to server\n>");
    FecShowtime();
  }
  if (log)
  {
    sprintf(str,"synchronized (%+d sec)",delt);
    feclog(str);
    lastlogged = t;
  }
  return 0;
}
void FecSynchronize(void)
{
  struct time t;
  static int next_hour = -1;

  gettime(&t);
  if (next_hour < 0) next_hour = t.ti_hour;
  if (t.ti_hour == next_hour)     /* sychronize once per hour */
  {
    FecSettime();
    gettime(&t);
    next_hour = (next_hour + 1) % 24;
  }
}

#else  /* MSDOS not defined */

int vfeclog(char *text)
{
  int i, len, maxlen = FeclogDepth*80;
  char str[255];
  if (vFeclogBuffer == NULL || text == NULL) return 0;
  strncpy(str,text,255);
  len = (int)strlen(str);
  for (i=0; i<len; i++) vFeclogBuffer[(vFeclogBufferPos+i)%maxlen] = str[i];
  vFeclogBufferPos = (vFeclogBufferPos + len) % maxlen;
  return 0;
}
int readvFecLog(char *textbuf,int sizeInBytes)
{
  int endptr = vFeclogBufferPos, startptr = 0;
  int i, maxlen = FeclogDepth*80;
  if (vFeclogBuffer[vFeclogBufferPos] != 0)
  {
    endptr = (vFeclogBufferPos + maxlen - 1)%maxlen;
    startptr = vFeclogBufferPos;
  }
  if (sizeInBytes < (endptr-startptr+maxlen)%maxlen)
    startptr = (endptr - sizeInBytes + maxlen) % maxlen;
  for (i=0; i<sizeInBytes; i++)
  {
    if (i >= maxlen) break;
    if ((textbuf[i]=vFeclogBuffer[(startptr+i)%maxlen]) == 0) break;
  }
  return 0;
}
#ifndef WINNT /* or MSDOS */
char *_strdate(char *buf)
{
  time_t t;
  struct tm *tm;
  time(&t);  
  t += (SINT32)gDataTimeStampOffset;
  tm=localtime(&t);
  sprintf(buf,"%02d/%02d/%02d",(tm->tm_mon)+1,tm->tm_mday,tm->tm_year%100);
  return buf;
}
char *_strtime(char *buf)
{
  time_t t;
  struct tm *tm;
  time(&t);  
  t += (SINT32)gDataTimeStampOffset;
  tm=localtime(&t);
  sprintf(buf,"%02d:%02d:%02d",tm->tm_hour,tm->tm_min,tm->tm_sec);
  return buf;
}
char *strupr(char *s)
{
  char *c;
  for (c=s; c && *c; c++) if (*c >= 'a' && *c <= 'z') *c -= 32;
  return s;
}
char *strlwr(char *s)
{
  char *c;
  for (c=s; c && *c; c++) if (*c >= 'A' && *c <= 'Z') *c += 32;
  return s;
}
char *strrev(char *s)
{
  char c;
  register int i,len = (int)strlen(s);
  for (i=0; i<len/2; i++) { c = s[i]; s[i] = s[len-1-i]; s[len-1-i] = c; }
  return s;
}
#ifndef NIOS /* or WINNT or MSDOS */
int stricmp(char *s1,char *s2)
{
  char *c1,*c2;
  for (c1=s1,c2=s2; *c1 != 0 && *c2 != 0; c1++,c2++)
    if (toupper(*c1) != toupper(*c2)) break;
  return toupper(*c2) - toupper(*c1);
}
int strnicmp(char *s1,char *s2,int n)
{
  char *c1,*c2;
  int i;
  for (c1=s1,c2=s2,i=0; *c1 != 0 && *c2 != 0; c1++,c2++,i++)
  {
    if (toupper(*c1) != toupper(*c2)) break;
    if (i >= n-1) break;
  }
  return toupper(*c2) - toupper(*c1);
}
#endif /* not defined NIOS, DOS, WINNT */
#endif /* not defined WINNT, DOS */

int D_dummy(double *v,short r,short n,short f,char *p) { return 0; }
FunHead FunList[] =
{
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0,"DUMMY","",D_dummy},
   { 0, "","", NULL },
};
int NumNodalFunctions = sizeof(FunList)/sizeof(FunHead) - 1;

#endif /* else MSDOS not defined */

#ifdef VXWORKS
void RPCConsumer(void)
{
  for(;;) doConsumer();
}
void VXWbkgtsk(void (*tsk)(void),int rate,int ref)
{
  int ticks = (sysClkRateGet() * rate) / 1000;
  void (*bkgtsk)(void) = tsk;
  int ready = FALSE;
  ExportListStruct *el = getExportListItemFromId(ref);

  if (ticks < 1) ticks = 1;
  if (StartupDebug)
  {
    dbglog("background task polling rate : %d msec (%d ticks)",rate,ticks);
  }
  if (el == NULL) ready = TRUE;
  while (!ServerExitCondition)
  {
    if (!ready) ready = el->inidone;
    if (ServerInitialized && ready) bkgtsk();
    taskDelay(ticks);
  }
}
#endif /* VXWORKS */

#ifdef MULTITHREADED
#include "threader.h"
int useMultiThreadedBackgroundTasks = TRUE;
int useMultiThreadedEquipmentFunctions = FALSE;
int hEqpFcnThread = 0;
#if defined(UNIX)
pthread_attr_t gBkgThreadAttr, *gPtrBkgThreadAttr = &gBkgThreadAttr;
pthread_attr_t gEqpThreadAttr, *gPtrEqpThreadAttr = &gEqpThreadAttr;
pthread_mutex_t EqpThreadMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t *hEqpThreadMutex = &EqpThreadMutex;
int bkgCreateThread(BkgThreadFcn *tsk)
{
  int cc;
  pthread_t tid;
  pthread_attr_init(gPtrBkgThreadAttr);
  cc = pthread_create(&tid,gPtrBkgThreadAttr,bkgTaskThread,(void *)tsk);
  return cc ? 0 : (int)tid;
}
int eqpCreateThread(void)
{
  int cc;
  pthread_t tid;

  if ((cc=pthread_mutex_init(hEqpThreadMutex,NULL)) != 0)
  {
    feclog("Cannot create Equipment Function Mutex: error %d",cc);
    return 0;
  }
  if ((cc=pthread_mutex_lock(hEqpThreadMutex)) != 0)
  {
    feclog("Cannot lock Equipment Function Mutex: error %d",cc);
    return 0;
  }
  pthread_attr_init(gPtrEqpThreadAttr);
# ifdef FORCE_PTHREAD_SCOPE_SYSTEM
  if ((cc=pthread_attr_setscope(gPtrEqpThreadAttr,PTHREAD_SCOPE_SYSTEM)) != 0) 
  {
    feclog("Cannot set thread scope !\n");
  }
# endif
  cc = pthread_create(&tid,gPtrEqpThreadAttr,eqpTaskThread,NULL);
  return cc ? 0 : (int)tid;
}
int WaitForMutex(pthread_mutex_t *mx,int to)
{
  struct timespec ts;
# ifdef NO_MUTEX_TIMEDLOCK
  int cc = -1;
  struct timeval tv0, tv1;
# endif
  ts.tv_sec = 0; ts.tv_nsec = 1000;
  nanosleep(&ts,NULL);
  if (to < 0) return pthread_mutex_lock(mx);
# ifndef NO_MUTEX_TIMEDLOCK
  ts.tv_sec = to/1000;
  ts.tv_nsec = (to%1000) * 1000000;
  return pthread_mutex_timedlock(mx,&ts);
# else
  gettimeofday(&tv0,(struct timezone *)NULL); tv1 = tv0;
  while ((UINT32)MSECS(tv1,tv0) < to)
  {
    if ((cc=pthread_mutex_trylock(mx)) == 0) return 0;
    gettimeofday(&tv1,(struct timezone *)NULL);
  }
  return cc;
# endif
}

#elif defined(WINNT)
DWORD dwBkgThreadId,dwEqpThreadId;
HANDLE hEqpThreadMutex;
int bkgCreateThread(BkgThreadFcn *tsk)
{
  return (int)CreateThread(NULL,0,bkgTaskThread,(LPVOID)tsk,0,&dwBkgThreadId);
}
int eqpCreateThread(void)
{
  if ((hEqpThreadMutex=CreateMutex(NULL,TRUE,EqpThreadMutexName)) == NULL)
  {
    feclog("Cannot create Equipment Function Mutex!");
    return 0;
  }
  return (int)CreateThread(NULL,0,eqpTaskThread,NULL,0,&dwEqpThreadId);
}
#endif /* UNIX or WINNT */

THREAD_TYPE eqpTaskThread(THREAD_PARAM lpvThreadParam)
{
  ExportListStruct *el;
  ContractListStruct *cl;
  struct timeval tv0, tv1;
  UINT32 delay = gSystemTick;
  int wasCalled = FALSE;
  while (!ServerExitCondition)
  {
    WaitForMutex(hEqpThreadMutex,-1);
    wasCalled = FALSE;
    if (NGdebug > 2) dbglog("[T2]: got mutex");
    if ((cl=ContractListItem) != NULL)
    {
      if (cl->compStatus == not_signalled) cl->compStatus = not_posted;
      if (cl->compStatus == not_posted && (el=cl->exp)->EqpFcn != NULL)
      {
        gettimeofday(&tv0,(struct timezone *)NULL);
        cl->compStatus = (*el->EqpFcn)(cl->lngDeviceName,cl->lngPropertyName,
                                       cl->dout,cl->din,cl->contract.EqpAccess);
        gettimeofday(&tv1,(struct timezone *)NULL);
        delay = ((UINT32)MSECS(tv1,tv0) < gSystemTick) ? 0 : gSystemTick;
        wasCalled = TRUE;
      }
      if (NGdebug > 2) 
        dbglog("[T2]: %s %s %s <%d> %s -> delay %d ms",
          cl->contract.EqpName,cl->contract.EqpDeviceName,
          cl->contract.EqpProperty,cl->compStatus,wasCalled ? "done" : "not called",delay);
    }
    else 
    {
      if (NGdebug > 2) dbglog("[T2]: Contract empty -> delay %d ms",delay);
    }
    ContractListItem = NULL;
    ReleaseMutex(hEqpThreadMutex); /* let the primary thread catch this */
    if (NGdebug > 2) dbglog("[T2]: Release mutex");
    millisleep(delay);           /* avoid spinning here if we can help it ! */
    delay += gSystemTick;
  }
  return 0;
}
THREAD_TYPE bkgTaskThread(THREAD_PARAM lpvThreadParam)
{
  int dly;
  struct timeval tv1,tv2;
  int ready = FALSE;

  BkgThreadFcn btf;

  btf = *(BkgThreadFcn *)lpvThreadParam;
  if (btf.ref == NULL) ready = TRUE;
  while (!ServerExitCondition)
  {
    if (!ready) ready = ((ExportListStruct *)btf.ref)->inidone;
    gettimeofday(&tv1,(struct timezone *)NULL);
    if (ServerInitialized && ready) btf.tsk();    /* do the registered background task */
    gettimeofday(&tv2,(struct timezone *)NULL);
    dly = btf.rate - MSECS(tv2,tv1);
    if (dly < 0) dly = 0;
    millisleep(dly);
  }
  return 0;
}
#endif /* MULTITHREADED */
void _SystemEngine(void)
{
  if (NrOfEqpTypes) dorpc();   /* check remote tasks  */
  if (nConnectionTableEntries) doConsumer();     /* Check our client list if any */
}
EXPORT int ServerInitialized = FALSE;
#if !defined(UNIX) && !defined(WINNT)
EXPORT int dbglog(char *text,...)
{
  int cc=0;
  char str[256];
  va_list args;

  if (strlen(text) > 80) ccerr(string_too_long);
  va_start(args,text);
  vsprintf(str,text,args);
  if (str[strlen(str)-1] == '\n') strcat(str,">");
  else sprintf(&str[strlen(str)]," @%s\n>",getDataTimeString((double)time(NULL),FALSE));
  va_end(args);
  if (strlen(tagNameFilter) && !strstr(str,tagNameFilter)) return 0;
  printf(str);
err:
  return cc;
}
int dbgoutput(char *str,time_t *ts)
{
  char strbuf[CMDSIZE];
  if (strlen(tagNameFilter) && !strstr(str,tagNameFilter)) return 0;
  if (ts != NULL)
  {
    if (strlen(str) > CMDSIZE-29) str[CMDSIZE-29] = 0; /* just in case */
    sprintf(strbuf,"%s @%ld\n>",str,*ts);
  }
  else sprintf(strbuf,"%s\n>",str);

  printf(strbuf);
  if (dbgfp != NULL) fprintf(dbgfp,strbuf);
  return 0;
}
#endif
#ifdef UNIX
int millisleep(int msec)
{
# ifdef USE_USLEEP
  return usleep(msec*1000);
# else
  struct timespec ts;
  if (msec <= 0) return 0;
  ts.tv_sec = msec/1000;
  ts.tv_nsec = (msec%1000) * 1000000;
  return nanosleep(&ts,NULL);
# endif
}
#endif
int dumpSemaphores(void)
{
  char s[256];
  sprintf(s,"Attach Link   : %d\n",AttachLinkSemaphore); ttyoutput(s);
  sprintf(s,"Exec Link     : %d\n",ExecLinkSemaphore); ttyoutput(s);
  sprintf(s,"Recv Global   : %d\n",recvNetGlobalSemaphore); ttyoutput(s);
  sprintf(s,"Consumer Loop : %d\n",doConsumerSemaphore); ttyoutput(s);
  sprintf(s,"EqpFcn busy   : %d\n",gEqpFcnBusySemaphore); ttyoutput(s);
  sprintf(s,"Exit Condition: %d\n",ServerExitCondition); ttyoutput(s);
  return 0;
}
void fixFecRepository(void)
{
  char *ptr;
  int len;
  memset(FecDBpath,0,80);
  if ((ptr=getenv("FEC_HOME")) != NULL || (ptr=getenv("FECDB")) != NULL)
  {
    strncpy(FecDBpath,ptr,80);
#   ifdef FS_DELIMITER
    len = (int)strlen(FecDBpath);
    if (FecDBpath[len-1] != FS_DELIMITER) FecDBpath[len] = FS_DELIMITER;
#   endif
  }
  memset(gFeclogPath,0,80);
  if ((ptr=getenv("FEC_LOG")) != NULL || (ptr=getenv("FECLOG")) != NULL) 
  {
    strncpy(gFeclogPath,ptr,64);
#   ifdef FS_DELIMITER
    len = (int)strlen(gFeclogPath);
    if (gFeclogPath[len-1] != FS_DELIMITER) gFeclogPath[len] = FS_DELIMITER;
#   endif
  }
  else
  {
    strncpy(gFeclogPath,FecDBpath,64);
  }
  if ((ptr=getenv("FECLOGDEPTH")) != NULL || (ptr=getenv("LOGDEPTH")) != NULL) 
    FeclogDepth = atoi(ptr);
  if ((ptr=getenv("FECPOLLRATE")) != NULL) 
  {
    MinPollingRate = atoi(ptr);
    if (MinPollingRate < 10) MinPollingRate = 10;
    if (MinPollingRate > 1000) MinPollingRate = 1000;
  }
  if ((ptr=getenv("FECWORKAREASIZE")) != NULL)
  {
    MaxRPCTransportSize = atoi(ptr);
    if (MaxRPCTransportSize < 4096) MaxRPCTransportSize = 4096;
  }
}
#endif /* NO_DOXYGEN */
#if defined(VXWORKS) || defined(NIOS)
EXPORT int nofeclog = TRUE;
#else
EXPORT int nofeclog = FALSE;
#endif
EXPORT int putCommandsInFeclog = TRUE;
EXPORT int FeclogDepth = NLINES;
EXPORT int useGlobalSynchronization = GLOBAL_SYNCHRONIZATION;
EXPORT int feclog(char *text,...)
{
  int len,cc=0;
  double ts = makeDataTimeStamp();
  static SINT32 flen = -1;
  char str[256],fn[96],fb[96];
  FILE *fp = NULL;
  va_list args;
# ifdef MSDOS
  static char *fmod = "a+t";
# else
  static char *fmod = "a+";
# endif
  fn[0] = 0;
  if (strlen(text) > 80) ccerr(string_too_long);
  va_start(args,text);
  sprintf(str,"%s[%s] ",getDataTimeString(ts,0),gFecName);
  vsprintf(&str[strlen(str)],text,args);
  if (str[strlen(str)-1] != '\n') strcat(str,"\n");
  va_end(args);
  if (NGdebug) dbglog(str);
# ifndef MSDOS
  if (vFeclogBuffer != NULL) return vfeclog(str);
# endif
  if (nofeclog) ccerr(0);
# ifndef FS_RDONLY
  sprintf(fn,"%s%s",gFeclogPath,"fec.log");
  if ((fp=fopen(fn,fmod)) == NULL) ccerr(file_error);
  fwrite(str,len=(int)strlen(str),1,fp);
  if (flen == -1) flen = ftell(fp);
  if ((flen += len) < FeclogDepth*2*80) ccerr(0);     /* finished */
  fclose(fp); fp = NULL; flen = 0;
  sprintf(fb,"%s%s",gFeclogPath,"fec.bak");
  remove(fb);
  rename(fn,fb);
# else 
  fb[0] = 0; len = 0; flen = flen; /* avoid warnings in this case */
  ccerr(not_implemented); /* no way to write a log file */
# endif
err:
  if (fp) fclose(fp);
  if (cc)
  {
    dbglog("%s : %s",fn,erlst[cc]);
  }
  return cc;
}
EXPORT char *getDataTimeString(double ts,int useLongStringFormat)
{
  static char tsstr[64];
  time_t t = (time_t)ts;
  UINT32 ms = (UINT32)((ts-(double)t) * 1000.0);
  int isdst = findDaylight(t);
  struct tm *tms;

  t += (isdst+1) * STD_TIME_UTC_OFFSET;

  if (useLongStringFormat)
  {
    strncpy(tsstr,ctime(&t),24);
    strncpy(&tsstr[28],&tsstr[20],4); tsstr[32] = 0;
#   ifdef MSDOS
    sprintf(&tsstr[19],".%03ld",ms);
#   else
    sprintf(&tsstr[19],".%03d",ms);
#   endif
    sprintf(&tsstr[23]," %s",ltzname[isdst]);
    tsstr[27] = ' ';
  }
  else
  {
    tms = localtime(&t);
    sprintf(tsstr,"%02d.%02d.%02d %02d:%02d:%02d.%03d %s",
      tms->tm_mday,tms->tm_mon+1,tms->tm_year%100,
      tms->tm_hour,tms->tm_min,tms->tm_sec,
      (int)ms,ltzname[isdst]);
  }
  return tsstr;
}
EXPORT struct timeval *getDataTimeStampAsTimeval(void)
{
  static struct timeval tv;
  tv.tv_sec = RPCtimestamp;
  tv.tv_usec = (RPCtimestampMSEC) * 1000;
  return &tv;
}
EXPORT double getDataTimeStamp(void)
{
  return gDataTimeStamp;
}
EXPORT double makeDataTimeStamp(void)
{
  struct timeval tv;
  double ts;
  gettimeofday(&tv,(struct timezone *)NULL);
  ts = (double)tv.tv_sec;
  ts += (double)(tv.tv_usec)/1000000.0;
  ts += gDataTimeStampOffset;
  return ts;
}
EXPORT double putDataTimeStamp(double toffset, time_t tsec, int tmsec)
{
  double ts;
  ts = (double)tsec;
  ts += (double)tmsec/1000.0;
  ts += toffset;
  return ts;
}
EXPORT void setDataTimeStamp(double ts)
{
  gServerDataTimeStamp = ts;                                /* this should be thread-safe */
  gDataTimeStamp = ts;                                      /* this isn't */
}
EXPORT int _SystemCycle(int chkcmd)
{
  if (NrOfEqpTypes || 
      FecNameRegistered || 
      gDelayInitRPCServices) 
    dorpc();                                             /* check remote tasks  */
  checkTasklist();                                 /* run through the task list */
  if (nConnectionTableEntries) doConsumer();    /* Check our client list if any */
  if (nHistoryRecords) historyCycle();
# ifdef RDATE
  if (SychronizeFecClock) FecSynchronize();                  /* Synchronize FEC */
# endif
# ifdef MSDOS
  if (watchdogBaseAddress) watchDog();                     /* hardware watchdog */
  netWatchDog();                                            /* network watchdog */
# endif
# if defined(MSDOS) || defined(WINNT) || defined(NIOS)
  if (chkcmd) GetCommand();    /* simple command line interpreter */
# endif
# ifdef UNIX
  foregroundTTY = foreground = chkcmd ? IsInForeground() : 0;
# endif
  return (ReturnToServerCycle | ReturnToClientCycle); /* need to return */
}
EXPORT void _SystemDelay(int msec)
{
  int forever;
  struct timeval tv0,tv;
  gettimeofday(&tv0,(struct timezone *)NULL);
  tv = tv0;
  forever = msec < 0 ? 1 : 0;
  while (forever || (MSECS(tv,tv0) < msec))
  {
    SystemCycle(TRUE);
    gettimeofday(&tv,(struct timezone *)NULL);
  }
}
EXPORT int _SystemInit(int netchk)
{
  int cc;

  fixLocalTimeSettings();
  fixFecRepository();
# ifndef MSDOS
  if (nofeclog && FeclogDepth > 0)
  {
    vFeclogBuffer = (char *)SystemCalloc(FeclogDepth,80);
  }
# else
  signal(SIGFPE,SIG_IGN);            /* catch Floating domain errors */
  harderr(NetHandler);               /* start error handler          */
  whoami(gUserName);                  /* find out who we are */
  GetWatchDogBaseAddress();          /* check environment for watchdog */
# endif
# if defined(RDATE)
  TimeServerHostPtr = getTimeServerHost();
  rdate(TimeServerHostPtr);          /* synchronize */
# elif !defined(VXWORKS)
  tzset();
# endif

  if ((cc=initRPC()) != 0) return cc;

# ifdef MULTITHREADED
  if (useMultiThreadedEquipmentFunctions) 
  {
    hEqpFcnThread = eqpCreateThread();
    feclog("FEC: Equipment Functions managed in separate thread");
  }
# endif

# ifdef MSDOS
  if (netchk)     /* network watchdog */
    feclog(initSAPWatchDog() ? "SAP Watchdog not active" : "SAP Watchdog active");
  feclog("started");
# endif

  ServerInitialized = TRUE;

  return cc;
}
EXPORT int _SystemReset(int level)
{
  level = level;                    /* keep level in mind for later use */
  ReturnToClientCycle = 0;          /* no immediate need */
  ReturnToServerCycle = 0;
  nConnectionTableEntries = NameServerLoaded ? 1 : 0; /* clear the connection table */
  doConsumerSemaphore = 0;          /* clear all semaphores */
  ExecLinkSemaphore = 0;
  AttachLinkSemaphore = 0;
  recvNetGlobalSemaphore = 0;
  isNameServerRequest = FALSE;
  return 0;
}
EXPORT BYTE *SystemVersion(void)
{
  static BYTE ver[4];
  ver[0] = MAJOR_VERSION; ver[1] = MINOR_VERSION;
  ver[2] = VERSION_REVISION/256; ver[3] = VERSION_REVISION%256;
  return ver;
}
EXPORT int _SystemScheduleProperty(char *eqm, char *prp)
{
  int i;
  ContractListStruct *cl;       /* improve readability by assignment */
  char *p=NULL,prpstr[512];

  if (eqm == NULL || prp == NULL) return argument_list_error;
  strncpy(prpstr,prp,512);
  for (p=strtok(prpstr,",|"); p != NULL; p=strtok(NULL,",|"))
  {
    if (GetPropertyId(eqm,p) < 0) continue;
    for (i=0; i<ncontract; i++)
    {
      if ((cl=ContractList[i])->expired) continue; 
      if (cl->nconsumer > 0 && !strncmp(cl->contract.EqpProperty,p,EQP_PROP_SIZE))
      {
        /* guarantee immediate execution of any contract using this property */
        cl->lasttime.tv_sec = cl->lasttime.tv_usec = PRP_SCHEDULE_SIGNAL;
      }
    }
  }
  ProduceData(&thisCycleTime);                  /* call the contract */
  while (StaleData) DeliverData(&thisCycleTime);/* send it out */

  return 0;
}
EXPORT UINT32 setWorkAreaSize(UINT32 size)
{
  if (!ServerInitialized &&  /* server already initialized => too late!*/
       size > MIN_WORK_SIZE) /* small setting not allowed */
    MaxRPCTransportSize = (UINT32)size;
  return (UINT32)MaxRPCTransportSize; /* return the working variable */
}
EXPORT int SetBurstLimit(int npackets)
{
  if (npackets < 1) npackets = 1;
  gBurstLimit = npackets;
  return gBurstLimit;
}
EXPORT int SetCycleDelay(int msecs)
{
  if (msecs < 0) msecs = 0;
  gCycleDelay = msecs;
  return gCycleDelay;
}
EXPORT char *GetFeclogPath(void)
{
  return gFeclogPath;
}
EXPORT char *GetFecHome(void)
{
  return FecDBpath;
}

---