The R13B03 release.OTP_R13B03

14 files changed, 3558 insertions, 0 deletions

diff --git a/erts/epmd/Makefile b/erts/epmd/Makefile
new file mode 100644
index 0000000000..4c1af393ac
--- /dev/null
+++ b/erts/epmd/Makefile
@@ -0,0 +1,32 @@
+# 
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1998-2009. All Rights Reserved.
+# 
+# The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved online at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# %CopyrightEnd%
+# 
+include $(ERL_TOP)/make/target.mk
+include $(ERL_TOP)/make/$(TARGET)/otp.mk
+
+# ----------------------------------------------------
+# Common Macros
+# ----------------------------------------------------
+SUB_DIRECTORIES = src 
+
+SPECIAL_TARGETS = 
+
+# ----------------------------------------------------
+# Default Subdir Targets
+# ----------------------------------------------------
+include $(ERL_TOP)/make/otp_subdir.mk
diff --git a/erts/epmd/doc/.gitignore b/erts/epmd/doc/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/erts/epmd/doc/.gitignore
diff --git a/erts/epmd/epmd.mk b/erts/epmd/epmd.mk
new file mode 100644
index 0000000000..a73f4bc077
--- /dev/null
+++ b/erts/epmd/epmd.mk
@@ -0,0 +1,70 @@
+# 
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1998-2009. All Rights Reserved.
+# 
+# The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved online at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# %CopyrightEnd%
+# 
+# ------------------------------------------------
+# Server defines
+#
+
+# EPMD port number
+#   4365 - Version 4.2                 TCP
+#   4366 - Version 4.3                 TCP
+#   4368 - Version 4.4.0 - 4.6.2       TCP
+#   4369 - Version 4.6.3 - 4.7.4       TCP/UDP
+EPMD_PORT_NO=4369
+
+
+# ------------------------------------------------
+# Client defines
+#
+
+# Node type:
+#    72 = R3 hidden node
+#    77 = R3 erlang node
+#   104 = R4 hidden node
+#   109 = R4 erlang node
+#   (110 = R6 nodes (explicit flags for differences between nodes))
+#
+# What epmd has been told, differs very much between versions, both
+# 111 and 110 seems to have been used to tell epmd, while 
+# the actual nodetypes has still been 104 and 109. 
+# EPMD does not care about this, why we move back to using
+# the correct tag (an 'n') for all nodes.
+#
+EPMD_NODE_TYPE=110
+
+# Lowest/Highest supported version of the distribution protocol:
+#   0 = R3
+#   1 = R4
+#   2 = R5      ?????
+#   3 = R5C
+#   4 = R6 (development)
+#   5 = R6
+# There was no protocol change in release R5, so we didn't need to raise
+# the version number. But now that R5A is released, it's best to keep it
+# this way.
+# The number was inadvertently raised for R5C, so we increase it again
+# for R6.
+# Distribution version 4 means a) distributed monitor and b) larger references
+# in the distribution format. 
+# In format 5, nodes can explicitly tell each other which of the above
+# mentioned capabilities they can handle.
+# Distribution format 5 contains the new md5 based handshake.
+
+EPMD_DIST_LOW=5
+EPMD_DIST_HIGH=5
+
diff --git a/erts/epmd/src/Makefile b/erts/epmd/src/Makefile
new file mode 100644
index 0000000000..7d586c7438
--- /dev/null
+++ b/erts/epmd/src/Makefile
@@ -0,0 +1,22 @@
+# 
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1998-2009. All Rights Reserved.
+# 
+# The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved online at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# %CopyrightEnd%
+#
+# Invoke with GNU make or clearmake -C gnu.
+#
+
+include $(ERL_TOP)/make/run_make.mk
diff --git a/erts/epmd/src/Makefile.in b/erts/epmd/src/Makefile.in
new file mode 100644
index 0000000000..498756b468
--- /dev/null
+++ b/erts/epmd/src/Makefile.in
@@ -0,0 +1,123 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1998-2009. All Rights Reserved.
+# 
+# The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved online at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# %CopyrightEnd%
+#
+include $(ERL_TOP)/make/target.mk
+
+
+ifeq ($(TYPE),debug)
+PURIFY     =
+TYPEMARKER = .debug
+TYPE_FLAGS = -DDEBUG @DEBUG_FLAGS@
+else
+ifeq ($(TYPE),purify)
+PURIFY     = purify
+TYPEMARKER =
+ifeq ($(findstring ose,$(TARGET)),ose)
+  TYPE_FLAGS = -DPURIFY
+else
+  TYPE_FLAGS = -O2 -DPURIFY
+endif
+else
+PURIFY     =
+TYPEMARKER =
+ifeq ($(findstring ose,$(TARGET)),ose)
+  TYPE_FLAGS =
+else
+  TYPE_FLAGS = -O2
+endif
+endif
+endif
+
+include $(ERL_TOP)/make/$(TARGET)/otp.mk
+include ../../vsn.mk
+include ../epmd.mk
+
+BINDIR  = $(ERL_TOP)/bin/$(TARGET)
+OBJDIR  = $(ERL_TOP)/erts/obj$(TYPEMARKER)/$(TARGET)
+
+CC      = @CC@
+WFLAGS  = @WFLAGS@
+CFLAGS  = @CFLAGS@ @DEFS@ $(TYPE_FLAGS) $(WFLAGS)
+LD      = @LD@
+LIBS    = @LIBS@
+LDFLAGS = @LDFLAGS@
+
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+
+# The targets
+ifeq ($(findstring win32,$(TARGET)),win32)
+EPMD = epmd.exe
+else
+EPMD = epmd
+endif
+
+INSTALL_PROGS = $(BINDIR)/$(EPMD)
+
+#---------------------------------
+# Options
+#---------------------------------
+ 
+EPMD_FLAGS = -DEPMD_PORT_NO=$(EPMD_PORT_NO)
+
+#---------------------------------
+# source and object file information
+#---------------------------------
+
+EPMD_OBJS = $(OBJDIR)/epmd.o       \
+               $(OBJDIR)/epmd_cli.o   \
+               $(OBJDIR)/epmd_srv.o 
+
+#---------------------------------
+# Build targets
+#---------------------------------
+
+
+all: $(BINDIR)/$(EPMD)
+
+docs:
+
+clean:
+	rm -f $(BINDIR)/$(EPMD) 
+	rm -f $(ERL_TOP)/erts/obj/$(TARGET)/epmd.o
+	rm -f $(ERL_TOP)/erts/obj/$(TARGET)/epmd_cli.o
+	rm -f $(ERL_TOP)/erts/obj/$(TARGET)/epmd_srv.o 
+	rm -f *.o
+	rm -f *~ core
+
+#
+# Objects & executables
+#
+
+$(BINDIR)/$(EPMD): $(EPMD_OBJS)
+	$(PURIFY) $(LD) $(LDFLAGS) -o $@ $(EPMD_OBJS) $(LIBS)
+
+$(OBJDIR)/%.o: %.c
+	$(CC) $(CFLAGS) $(EPMD_FLAGS) -o $@ -c $<
+
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec: all
+	$(INSTALL_DIR)     $(RELEASE_PATH)/erts-$(VSN)/bin
+	$(INSTALL_PROGRAM) $(INSTALL_PROGS) $(RELEASE_PATH)/erts-$(VSN)/bin
+
+
+release_docs_spec:
+
diff --git a/erts/epmd/src/epmd.c b/erts/epmd/src/epmd.c
new file mode 100644
index 0000000000..23ac421446
--- /dev/null
+++ b/erts/epmd/src/epmd.c
@@ -0,0 +1,629 @@
+/* -*- c-indent-level: 2; c-continued-statement-offset: 2 -*- */ 
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#include "epmd.h"     /* Renamed from 'epmd_r4.h' */
+#include "epmd_int.h"
+
+#ifdef _OSE_
+#  include "ose.h"
+#  include "efs.h"
+#endif
+
+#ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+#endif
+
+/* forward declarations */
+
+static void usage(EpmdVars *);
+static void run_daemon(EpmdVars*);
+static int get_port_no(void);
+#ifdef __WIN32__
+static int has_console(void);
+#endif
+
+#ifdef DONT_USE_MAIN
+
+static int epmd_main(int, char **, int);
+
+/* VxWorks fill 10 stack words with zero when a function is called
+   from the shell. So it is safe to have argv and argc as parameters
+   even if they are not given in the call. */
+
+#define MAX_DEBUG 10
+
+int epmd_dbg(int level,int port) /* Utility to debug epmd... */
+{
+  char* argv[MAX_DEBUG+2];
+  char  ibuff[100];
+  int   argc = 0;
+  
+  argv[argc++] = "epmd";
+  if(level > MAX_DEBUG)
+    level = MAX_DEBUG;
+  for(;level;--level)
+    argv[argc++] = "-d";
+  if(port)
+    {
+      argv[argc++] = "-port";
+      sprintf(ibuff,"%d",port);
+      argv[argc++] = ibuff;
+    }
+  argv[argc] = NULL;
+
+  return epmd(argc,argv);
+
+}
+
+static char *mystrdup(char *s)
+{
+    char *r = malloc(strlen(s)+1);
+    strcpy(r,s);
+    return r;
+}
+
+#ifdef _OSE_
+
+struct args_sig {
+  SIGSELECT sig_no;
+  int argc ;
+  char argv[20][20];
+};
+
+union SIGNAL {
+  SIGSELECT sig_no;
+  struct args_sig args;
+};
+
+/* Start function. It may be called from the start script as well as from
+   the OSE shell directly (using late start hooks). It spawns epmd as an
+   OSE process which calls the epmd main function. */
+int start_ose_epmd(int argc, char **argv) {
+  union SIGNAL *sig;
+  PROCESS epmd_;
+  OSENTRYPOINT ose_epmd;
+  int i;
+
+  if(hunt("epmd", 0, &epmd_, NULL)) {
+    fprintf(stderr, "Warning! EPMD already exists (%u).\n", epmd_);
+    return 0;
+  }
+  else {
+    /* copy start args to signal */
+    sig = alloc(sizeof(struct args_sig), 0);
+    sig->args.argc = argc;
+    for(i=0; i<argc; i++) {
+      strcpy((sig->args.argv)[i], argv[i]);
+    }    
+    /* start epmd and send signal */
+    epmd_ = create_process(OS_BG_PROC, /* processtype */
+			   "epmd",      /* name        */
+			   ose_epmd,    /* entrypoint  */
+			   16383,	/* stacksize   */
+			   20,	        /* priority    */
+			   0,	        /* timeslice   */
+			   0,	        /* block       */
+			   NULL,0,0);   /* not used    */
+    efs_clone(epmd_);
+    start(epmd_);
+    send(&sig, epmd_);	
+#ifdef DEBUG
+    printf("EPMD ID: %li\n", epmd_);
+#endif
+  }
+  return 0;
+}
+
+OS_PROCESS(ose_epmd) {
+  union SIGNAL *sig;
+  static const SIGSELECT rec_any_sig[] = { 0 };
+  int i, argc;
+  char **argv;
+
+  sig = receive((SIGSELECT*)rec_any_sig);
+
+  argc = sig->args.argc;
+  argv = (char **)malloc((argc+1)*sizeof(char *));
+  for(i=0; i<argc; i++) {
+    argv[i] = (char *)malloc(strlen((sig->args.argv)[i])+1);
+    strcpy(argv[i], (sig->args.argv)[i]);
+  }
+  argv[argc] = NULL;
+  free_buf(&sig);
+
+  epmd(argc, argv);
+
+  for(i=0; i<argc; i++) {
+    free(argv[i]);
+  }
+  free(argv);
+}
+
+#else  /* ifdef _OSE_ */
+
+/* VxWorks start function */
+int start_epmd(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
+char *a0, *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8, *a9;     
+{
+  char*  argarr[] = {a0,a1,a2,a3,a4,a5,a6,a7,a8,a9};
+  int    i;
+  char** argv = malloc(sizeof(char *)*10);
+  int    argvsiz = 10;
+  int    argc = 1;
+  char*  tmp = malloc(100);
+  int    tmpsiz = 100;
+  char*  pplast;
+  char*  token;
+  
+  argv[0] = mystrdup("epmd");
+  argv[1] = NULL;
+  
+  for(i=0;i<10;++i)
+    {
+      if(argarr[i] == NULL || *argarr[i] == '\0')
+	continue;
+      if(strlen(argarr[i]) >= tmpsiz)
+	tmp = realloc(tmp, tmpsiz = (strlen(argarr[i])+1));
+      strcpy(tmp,argarr[i]);
+      for(token = strtok_r(tmp," ",&pplast);
+	  token != NULL;
+	  token = strtok_r(NULL," ",&pplast))
+	{
+	  if(argc >= argvsiz - 1)
+	    argv = realloc(argv,sizeof(char *) * (argvsiz += 10));
+	  argv[argc++] = mystrdup(token);
+	  argv[argc] = NULL;
+	}
+    }
+  free(tmp);
+  return taskSpawn("epmd",100,VX_FP_TASK,20000,epmd_main,
+		   argc,(int) argv,1,
+		   0,0,0,0,0,0,0);
+}
+    
+#endif    /* _OSE_ */
+    
+    
+
+
+int epmd(int argc, char **argv)
+{
+  return epmd_main(argc,argv,0);
+}
+
+static int epmd_main(int argc, char** argv, int free_argv)
+#else
+int main(int argc, char** argv)
+#endif /* DONT_USE_MAIN */
+{
+    EpmdVars g_empd_vars;
+    EpmdVars *g = &g_empd_vars;
+#ifdef __WIN32__
+    WORD wVersionRequested;
+    WSADATA wsaData;
+    int err;
+
+    wVersionRequested = MAKEWORD(1, 1);
+
+    err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0)
+        epmd_cleanup_exit(g,1);
+
+    if (LOBYTE(wsaData.wVersion) != 1 || HIBYTE(wsaData.wVersion ) != 1) {
+        WSACleanup();
+    	epmd_cleanup_exit(g,1);
+    }
+#endif
+#ifdef DONT_USE_MAIN
+    if(free_argv)
+	g->argv = argv;
+    else 
+	g->argv = NULL;
+#else
+    g->argv = NULL;
+#endif
+
+    g->port  = get_port_no();
+    g->debug = 0;
+
+    g->silent         = 0; 
+    g->is_daemon      = 0;
+    g->packet_timeout = CLOSE_TIMEOUT; /* Default timeout */
+    g->delay_accept   = 0;
+    g->delay_write    = 0;
+    g->progname       = argv[0];
+    g->listenfd       = -1;
+    g->conn           = NULL;
+    g->nodes.reg = g->nodes.unreg = g->nodes.unreg_tail = NULL;
+    g->nodes.unreg_count = 0;
+    g->active_conn    = 0;
+
+    argc--;
+    argv++;
+    while (argc > 0) {
+	if ((strcmp(argv[0], "-debug")==0) ||
+	    (strcmp(argv[0], "-d")==0)) {
+	    g->debug += 1;
+	    argv++; argc--;
+	} else if (strcmp(argv[0], "-packet_timeout") == 0) {
+	    if ((argc == 1) ||
+		((g->packet_timeout = atoi(argv[1])) == 0))
+		usage(g);
+	    argv += 2; argc -= 2;
+	} else if (strcmp(argv[0], "-delay_accept") == 0) {
+	    if ((argc == 1) ||
+		((g->delay_accept = atoi(argv[1])) == 0))
+		usage(g);
+	    argv += 2; argc -= 2;
+	} else if (strcmp(argv[0], "-delay_write") == 0) {
+	    if ((argc == 1) ||
+		((g->delay_write = atoi(argv[1])) == 0))
+		usage(g);
+	    argv += 2; argc -= 2;
+	} else if (strcmp(argv[0], "-daemon") == 0) {
+	    g->is_daemon = 1;
+	    argv++; argc--;
+	} else if (strcmp(argv[0], "-kill") == 0) {
+	    if (argc == 1)
+		kill_epmd(g);
+	    else
+		usage(g);
+	    epmd_cleanup_exit(g,0);
+	} else if (strcmp(argv[0], "-port") == 0) {
+	    if ((argc == 1) ||
+		((g->port = atoi(argv[1])) == 0))
+	      usage(g);
+	    argv += 2; argc -= 2;
+	} else if (strcmp(argv[0], "-names") == 0) {
+	    if (argc == 1)
+		epmd_call(g, EPMD_NAMES_REQ);
+	    else
+		usage(g);
+	    epmd_cleanup_exit(g,0);
+	} else if (strcmp(argv[0], "-started") == 0) {
+	    g->silent = 1;
+	    if (argc == 1)
+		epmd_call(g, EPMD_NAMES_REQ);
+	    else
+		usage(g);
+	    epmd_cleanup_exit(g,0);
+	} else if (strcmp(argv[0], "-dump") == 0) {
+	    if (argc == 1)
+		epmd_call(g, EPMD_DUMP_REQ);
+	    else
+		usage(g);
+	    epmd_cleanup_exit(g,0);
+	}
+	else
+	    usage(g);
+    }
+    dbg_printf(g,0,"epmd running - daemon = %d",g->is_daemon);
+
+#ifndef NO_SYSCONF
+    if ((g->max_conn = sysconf(_SC_OPEN_MAX)) <= 0)
+#endif
+      g->max_conn = MAX_FILES;
+  
+    /*
+     * max_conn must not be greater than FD_SETSIZE.
+     * (at least QNX crashes)
+     *
+     * More correctly, it must be FD_SETSIZE - 1, beacuse the
+     * listen FD is stored outside the connection array.
+     */
+  
+    if (g->max_conn > FD_SETSIZE) {
+      g->max_conn = FD_SETSIZE - 1;
+    }
+
+    if (g->is_daemon)  {
+	run_daemon(g);
+    } else {
+	run(g);
+    }
+    return 0;
+}
+
+#ifndef NO_DAEMON
+static void run_daemon(EpmdVars *g)
+{
+    register int child_pid, fd;
+    
+    dbg_tty_printf(g,2,"fork a daemon");
+
+    /* fork to make sure first child is not a process group leader */
+    if (( child_pid = fork()) < 0)
+      {
+#ifndef NO_SYSLOG
+	syslog(LOG_ERR,"erlang mapper daemon cant fork %m");
+#endif
+	epmd_cleanup_exit(g,1);
+      }
+    else if (child_pid > 0)
+      {
+	dbg_tty_printf(g,2,"daemon child is %d",child_pid);
+	epmd_cleanup_exit(g,0);  /*parent */
+      }
+    
+    if (setsid() < 0)
+      {
+	dbg_perror(g,"epmd: Cant setsid()");
+	epmd_cleanup_exit(g,1);
+      }
+
+    /* ???? */
+
+
+    signal(SIGHUP, SIG_IGN);
+
+    /* We don't want to be session leader so we fork again */
+
+    if ((child_pid = fork()) < 0)
+      {
+#ifndef NO_SYSLOG
+	syslog(LOG_ERR,"erlang mapper daemon cant fork 2'nd time %m");
+#endif
+	epmd_cleanup_exit(g,1);
+      }
+    else if (child_pid > 0)
+      {
+	dbg_tty_printf(g,2,"daemon 2'nd child is %d",child_pid);
+	epmd_cleanup_exit(g,0);  /*parent */
+      }
+
+    /* move cwd to root to make sure we are not on a mounted filesystem  */
+    chdir("/");
+    
+    umask(0);
+
+    for (fd = 0; fd < g->max_conn ; fd++) /* close all files ... */
+        close(fd);
+    /* Syslog on linux will try to write to whatever if we dont
+       inform it of that the log is closed. */
+    closelog();
+
+    /* These chouldn't be needed but for safety... */
+
+    open("/dev/null", O_RDONLY); /* Order is important! */
+    open("/dev/null", O_WRONLY);
+    open("/dev/null", O_WRONLY);
+
+    errno = 0;  /* if set by open */
+
+    run(g);
+}
+
+#endif /* NO_DAEMON */    
+
+#ifdef __WIN32__
+static int has_console(void)
+{
+    HANDLE handle = CreateFile("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE,
+			       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+    if (handle == INVALID_HANDLE_VALUE) {
+	return 0;
+    } else {
+        CloseHandle(handle);
+	return 1;
+    }
+}
+
+static void run_daemon(EpmdVars *g)
+{
+    if (has_console()) {
+	if (spawnvp(_P_DETACH, __argv[0], __argv) == -1) {
+	    fprintf(stderr, "Failed to spawn detached epmd\n");
+	    exit(1);
+	}
+	exit(0);
+    }
+
+    close(0);
+    close(1);
+    close(2);
+
+    /* These chouldn't be needed but for safety... */
+
+    open("nul", O_RDONLY);
+    open("nul", O_WRONLY);
+    open("nul", O_WRONLY);
+
+    run(g);
+}
+#endif
+
+#if (defined(VXWORKS) || defined(_OSE_))
+static void run_daemon(EpmdVars *g)
+{
+    run(g);
+}
+#endif
+
+
+/***************************************************************************
+ *  Misc support routines
+ *
+ */
+
+static void usage(EpmdVars *g)
+{
+    fprintf(stderr, "usage: epmd [-d|-debug] [DbgExtra...] [-port No] [-daemon]\n");
+    fprintf(stderr, "            [-d|-debug] [-port No] [-names|-kill]\n\n");
+    fprintf(stderr, "See the Erlang epmd manual page for info about the usage.\n");
+    fprintf(stderr, "The -port and DbgExtra options are\n\n");
+    fprintf(stderr, "    -port No\n");
+    fprintf(stderr, "        Let epmd listen to another port than default %d\n",
+	    EPMD_PORT_NO);
+    fprintf(stderr, "    -d\n");
+    fprintf(stderr, "    -debug\n");
+    fprintf(stderr, "        Enable debugging. This will give a log to\n");
+    fprintf(stderr, "        the standard error stream. It will shorten\n");
+    fprintf(stderr, "        the number of saved used node names to 5.\n\n");
+    fprintf(stderr, "        If you give more than one debug flag you may\n");
+    fprintf(stderr, "        get more debugging information.\n\n");
+    fprintf(stderr, "    -packet_timout Seconds\n");
+    fprintf(stderr, "        Set the number of seconds a connection can be\n");
+    fprintf(stderr, "        inactive before epmd times out and closes the\n");
+    fprintf(stderr, "        connection (default 60).\n\n");
+    fprintf(stderr, "    -delay_accept Seconds\n");
+    fprintf(stderr, "        To simulate a busy server you can insert a\n");
+    fprintf(stderr, "        delay between epmd gets notified about that\n");
+    fprintf(stderr, "        a new connection is requested and when the\n");
+    fprintf(stderr, "        connections gets accepted.\n\n");
+    fprintf(stderr, "    -delay_write Seconds\n");
+    fprintf(stderr, "        Also a simulation of a busy server. Inserts\n");
+    fprintf(stderr, "        a delay before a reply is sent.\n");
+    epmd_cleanup_exit(g,1);
+}
+
+/***************************************************************************
+ *  Error reporting - dbg_printf() & dbg_tty_printf & dbg_perror()
+ *
+ *  The first form will print out on tty or syslog depending on
+ *  if it runs as deamon or not. The second form will never print
+ *  out on syslog.
+ *
+ *  The arguments are
+ *
+ *      g            Epmd variables
+ *      from_level   From what debug level we print. 0 means always.
+ *                   (This argument is missing from dbg_perror() )
+ *      format       Format string
+ *      args...      Arguments to print out according to the format
+ *      
+ */
+
+static void dbg_gen_printf(int onsyslog,int perr,int from_level,
+			   EpmdVars *g,const char *format, va_list args)
+{
+  time_t now;
+  char *timestr;
+  char buf[2048];
+
+  if (g->is_daemon)
+    {
+#ifndef NO_SYSLOG
+      if (onsyslog)
+	{
+	  vsprintf(buf, format, args);
+	  syslog(LOG_ERR,"epmd: %s",buf);
+	}
+#endif
+    }
+  else
+    {
+      int len;
+
+      time(&now);
+      timestr = (char *)ctime(&now);
+      sprintf(buf, "epmd: %.*s: ", (int) strlen(timestr)-1, timestr);
+      len = strlen(buf);
+      vsprintf(buf + len, format, args);
+      if (perr == 1)
+	perror(buf);
+      else
+	fprintf(stderr,"%s\r\n",buf);
+    }
+}
+
+
+void dbg_perror(EpmdVars *g,const char *format,...)
+{
+  va_list args;
+  va_start(args, format);
+  dbg_gen_printf(1,1,0,g,format,args);
+  va_end(args);
+}
+
+
+void dbg_tty_printf(EpmdVars *g,int from_level,const char *format,...)
+{
+  if (g->debug >= from_level) {
+    va_list args;
+    va_start(args, format);
+    dbg_gen_printf(0,0,from_level,g,format,args);
+    va_end(args);
+  }
+}
+
+void dbg_printf(EpmdVars *g,int from_level,const char *format,...)
+{
+  if (g->debug >= from_level) {
+    va_list args;
+    va_start(args, format);
+    dbg_gen_printf(1,0,from_level,g,format,args);
+    va_end(args);
+  }
+}
+
+
+/***************************************************************************
+ *
+ * This function is to clean up all filedescriptors and free up memory on 
+ * VxWorks.
+ * This function exits, there is nothing else to do when all here is run.
+ *
+ */
+
+static void free_all_nodes(EpmdVars *g)
+{
+    Node *tmp;
+    for(tmp=g->nodes.reg; tmp != NULL; tmp = g->nodes.reg){
+	g->nodes.reg = tmp->next;
+	free(tmp);
+    }
+    for(tmp=g->nodes.unreg; tmp != NULL; tmp = g->nodes.unreg){
+	g->nodes.unreg = tmp->next;
+	free(tmp);
+    }
+}
+void epmd_cleanup_exit(EpmdVars *g, int exitval)
+{
+  int i;
+
+  if(g->conn){
+      for (i = 0; i < g->max_conn; i++)
+	  if (g->conn[i].open == EPMD_TRUE)
+	      epmd_conn_close(g,&g->conn[i]);
+      free(g->conn);
+  }
+  if(g->listenfd >= 0)
+      close(g->listenfd);
+  free_all_nodes(g);
+  if(g->argv){
+      for(i=0; g->argv[i] != NULL; ++i)
+	  free(g->argv[i]);
+      free(g->argv);
+  }      
+      
+
+  exit(exitval);
+}
+
+static int get_port_no(void)
+{
+    char* port_str = getenv("ERL_EPMD_PORT");
+    return (port_str != NULL) ? atoi(port_str) : EPMD_PORT_NO;
+}
+
diff --git a/erts/epmd/src/epmd.h b/erts/epmd/src/epmd.h
new file mode 100644
index 0000000000..9e939ee38e
--- /dev/null
+++ b/erts/epmd/src/epmd.h
@@ -0,0 +1,37 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+/* The port number is now defined in a makefile */
+
+/* Definitions of message codes */
+
+#define EPMD_ALIVE_REQ 'a'
+#define EPMD_ALIVE_OK_RESP 'Y'
+#define EPMD_PORT_REQ 'p'
+#define EPMD_NAMES_REQ 'n'
+#define EPMD_DUMP_REQ 'd'
+#define EPMD_KILL_REQ 'k'
+#define EPMD_STOP_REQ 's'
+
+/* New epmd messages */
+
+#define EPMD_ALIVE2_REQ 'x' /* 120 */
+#define EPMD_PORT2_REQ 'z' /* 122 */
+#define EPMD_ALIVE2_RESP 'y' /* 121 */
+#define EPMD_PORT2_RESP 'w' /* 119 */
diff --git a/erts/epmd/src/epmd_cli.c b/erts/epmd/src/epmd_cli.c
new file mode 100644
index 0000000000..c12f711bc5
--- /dev/null
+++ b/erts/epmd/src/epmd_cli.c
@@ -0,0 +1,127 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#include "epmd.h"     /* Renamed from 'epmd_r4.h' */
+#include "epmd_int.h"
+
+/* forward declarations */
+
+static int conn_to_epmd(EpmdVars*);
+static int read_fill(int,char*,int);
+
+
+void kill_epmd(EpmdVars *g)
+{
+    char buf[5];
+    int fd, rval;
+
+    fd = conn_to_epmd(g);
+    put_int16(1,buf);
+    buf[2] = EPMD_KILL_REQ;
+    if (write(fd, buf, 3) != 3) {
+	printf("epmd: Can't write to epmd\n");
+	epmd_cleanup_exit(g,1);
+    }
+    if ((rval = read_fill(fd,buf,2)) == 2) {
+	printf("Killed\n");
+	epmd_cleanup_exit(g,0);
+    } else if (rval < 0) {
+	printf("epmd: failed to read answer from local epmd\n");
+	epmd_cleanup_exit(g,1);
+    } else { 			/* rval is now 0 or 1 */
+	buf[rval] = '\0';
+	printf("epmd: local epmd responded with <%s>\n", buf);
+	epmd_cleanup_exit(g,1);
+    }
+}
+
+/* what == EPMD_NAMES_REQ || EPMD_DUMP_REQ */
+
+void epmd_call(EpmdVars *g,int what)
+{
+    char buf[OUTBUF_SIZE];
+    int rval,fd,i,j;
+    
+    fd = conn_to_epmd(g);
+    put_int16(1,buf);
+    buf[2] = what;
+    write(fd,buf,3);
+    if (read(fd,(char *)&i,4) != 4) {
+	if (!g->silent)
+	    printf("epmd: no response from local epmd\n");
+	epmd_cleanup_exit(g,1);
+    }
+    j = ntohl(i);
+    if (!g->silent)
+	printf("epmd: up and running on port %d with data:\n", j);
+    while(1) {
+	if ((rval = read(fd,buf,1)) <= 0)  {
+	    close(fd);
+	    epmd_cleanup_exit(g,0);
+	}
+	buf[rval] = '\0';
+	if (!g->silent)
+	    printf("%s",buf);
+    }
+}
+
+
+
+static int conn_to_epmd(EpmdVars *g)
+{
+    struct EPMD_SOCKADDR_IN address;
+    int connect_sock;
+    
+    connect_sock = socket(FAMILY, SOCK_STREAM, 0);
+    if (connect_sock<0)
+	goto error;
+
+    { /* store port number in unsigned short */
+      unsigned short sport = g->port;
+      SET_ADDR_LOOPBACK(address, FAMILY, sport);
+    }
+
+    if (connect(connect_sock, (struct sockaddr*)&address, sizeof address) < 0) 
+	goto error;
+    return connect_sock;
+
+ error:
+    if (!g->silent) {
+	fprintf(stderr, "epmd: Cannot connect to local epmd\n");
+    }
+    epmd_cleanup_exit(g,1);
+    return -1;
+}
+
+/* Fill buffer, return buffer length, 0 for EOF, < 0 for error. */
+static int read_fill(int fd,char *buf,int len)
+{
+    int i;
+    int got = 0;
+    
+    do {
+	if ((i = read(fd, buf+got, len-got)) <= 0) 
+	    return (i);
+	got += i;
+    } while (got < len);
+    return (len);
+}
diff --git a/erts/epmd/src/epmd_int.h b/erts/epmd/src/epmd_int.h
new file mode 100644
index 0000000000..b120b44579
--- /dev/null
+++ b/erts/epmd/src/epmd_int.h
@@ -0,0 +1,346 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+/* 
+ * This file is for internal use within epmd.
+ */
+
+/* This file don't depend on "sys.h" so we have to do some target
+   definitions ourselves */
+
+#ifdef __WIN32__
+#define NO_SYSLOG
+#define NO_SYSCONF
+#define NO_DAEMON
+#endif
+
+#ifdef VXWORKS
+#define NO_SYSLOG
+#define NO_SYSCONF
+#define NO_DAEMON
+#define NO_FCNTL
+#define DONT_USE_MAIN
+#endif
+
+#ifdef _OSE_
+#define NO_SYSLOG
+#define NO_SYSCONF
+#define NO_DAEMON
+#define DONT_USE_MAIN
+#ifndef HAVE_SYS_TIME_H
+#define HAVE_SYS_TIME_H
+#endif
+#ifndef HAVE_UNISTD_H
+#define HAVE_UNISTD_H
+#endif
+#endif
+
+/* ************************************************************************ */
+/* Standard includes                                                        */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef __WIN32__
+#  ifndef WINDOWS_H_INCLUDES_WINSOCK2_H
+#    include <winsock2.h>
+#  endif
+#  include <windows.h>
+#  include <process.h>
+#endif
+
+#include <sys/types.h>
+#include <fcntl.h>
+
+#ifdef VXWORKS
+#  include <sys/times.h>
+#  include <time.h>
+#  include <selectLib.h>
+#  include <sysLib.h>
+#  include <sockLib.h>
+#  include <ioLib.h>
+#  include <taskLib.h>
+#  include <rpc/rpc.h>
+#else /* ! VXWORKS */
+#ifndef __WIN32__
+#  ifdef TIME_WITH_SYS_TIME
+#    include <sys/time.h>
+#    include <time.h>
+#  else
+#    ifdef HAVE_SYS_TIME_H
+#       include <sys/time.h>
+#    else
+#       include <time.h>
+#    endif
+#  endif
+#endif
+#endif /* ! VXWORKS */
+
+#if (!defined(__WIN32__) && !defined(_OSE_))
+#  include <netinet/in.h>
+#  include <sys/socket.h>
+#  include <sys/stat.h>
+
+#  ifdef DEF_INADDR_LOOPBACK_IN_RPC_TYPES_H
+#    include <rpc/types.h>
+#  endif
+
+#  include <arpa/inet.h>
+#  include <netinet/tcp.h>
+#endif /* ! WIN32 */
+
+#ifndef _OSE_
+#include <ctype.h>
+#include <signal.h>
+#endif
+
+#include <errno.h>
+
+#ifndef NO_SYSLOG
+#  include <syslog.h>
+#endif
+
+#ifdef SYS_SELECT_H
+#  include <sys/select.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#  include <unistd.h>
+#endif
+
+#include <stdarg.h>
+
+#ifdef _OSE_
+#  include "ose.h"
+#  include "inet.h"
+#  include "sys/stat.h"
+#endif
+
+
+/* ************************************************************************ */
+/* Replace some functions by others by making the function name a macro */
+
+#ifdef __WIN32__
+#  define close(s) closesocket((s))
+#  define write(a,b,c) send((a),(b),(c),0)
+#  define read(a,b,c) recv((a),(char *)(b),(c),0)
+#  define sleep(s) Sleep((s) * 1000)
+#  define ioctl(s,r,o) ioctlsocket((s),(r),(o))
+#endif /* WIN32 */
+
+#ifdef VXWORKS
+#define sleep(n) taskDelay((n) * sysClkRateGet())
+#endif /* VXWORKS */
+
+#ifdef _OSE_
+#define sleep(n) delay((n))
+#endif
+
+#ifdef USE_BCOPY
+#  define memcpy(a, b, c) bcopy((b), (a), (c))
+#  define memcmp(a, b, c) bcmp((a), (b), (c))
+#  define memzero(buf, len) bzero((buf), (len))
+#else
+#  define memzero(buf, len) memset((buf), '\0', (len))
+#endif
+
+/* ************************************************************************ */
+/* Try to find replacement values for undefined system parameters           */
+
+#if defined(__WIN32__) && !defined(EADDRINUSE)
+#  define EADDRINUSE WSAEADDRINUSE
+#endif
+
+#ifndef SOMAXCONN
+#  define SOMAXCONN 128
+#endif
+
+/*
+ * How to get max no of file descriptors? We used to use NOFILE from
+ * <sys/param.h>, but that tends to have little relation to reality.
+ * Best is to use sysconf() (POSIX), but we'll just punt if that isn't
+ * available. Start out with a high value because it will also be
+ * used as the number of file descriptors given to select() (it's is
+ * a terrible bug not to have all file descriptors included in the select()).
+ * The value will be adjusted down if FD_SETSIZE is smaller.
+ */
+
+#define MAX_FILES 2048		/* if sysconf() isn't available, or fails */
+
+/* ************************************************************************ */
+/* Macros that let us use IPv6                                              */
+
+#if defined(HAVE_IN6) && defined(AF_INET6) && defined(EPMD6)
+
+#define EPMD_SOCKADDR_IN sockaddr_in6
+#define FAMILY      AF_INET6
+
+#define SET_ADDR_LOOPBACK(addr, af, port) do { \
+    static u_int32_t __addr[4] = IN6ADDR_LOOPBACK_INIT; \
+    memset((char*)&(addr), 0, sizeof(addr)); \
+    (addr).sin6_family = (af); \
+    (addr).sin6_flowinfo = 0; \
+    (addr).sin6_addr.s6_addr32[0] = __addr[0]; \
+    (addr).sin6_addr.s6_addr32[1] = __addr[1]; \
+    (addr).sin6_addr.s6_addr32[2] = __addr[2]; \
+    (addr).sin6_addr.s6_addr32[3] = __addr[3]; \
+    (addr).sin6_port = htons(port); \
+ } while(0)
+
+#define SET_ADDR_ANY(addr, af, port) do { \
+    static u_int32_t __addr[4] = IN6ADDR_ANY_INIT; \
+    memset((char*)&(addr), 0, sizeof(addr)); \
+    (addr).sin6_family = (af); \
+    (addr).sin6_flowinfo = 0; \
+    (addr).sin6_addr.s6_addr32[0] = __addr[0]; \
+    (addr).sin6_addr.s6_addr32[1] = __addr[1]; \
+    (addr).sin6_addr.s6_addr32[2] = __addr[2]; \
+    (addr).sin6_addr.s6_addr32[3] = __addr[3]; \
+    (addr).sin6_port = htons(port); \
+ } while(0)
+
+#else /* Not IP v6 */
+
+#define EPMD_SOCKADDR_IN sockaddr_in
+#define FAMILY      AF_INET
+
+#define SET_ADDR_LOOPBACK(addr, af, port) do { \
+    memset((char*)&(addr), 0, sizeof(addr)); \
+    (addr).sin_family = (af); \
+    (addr).sin_addr.s_addr = htonl(INADDR_LOOPBACK); \
+    (addr).sin_port = htons(port); \
+ } while(0)
+
+#define SET_ADDR_ANY(addr, af, port) do { \
+    memset((char*)&(addr), 0, sizeof(addr)); \
+    (addr).sin_family = (af); \
+    (addr).sin_addr.s_addr = htonl(INADDR_ANY); \
+    (addr).sin_port = htons(port); \
+ } while(0)
+
+#endif /* Not IP v6 */
+
+/* ************************************************************************ */
+/* Our own definitions                                                      */
+
+#define EPMD_FALSE 0
+#define EPMD_TRUE 1
+
+/* If no activity we let select() return every IDLE_TIMEOUT second
+   A file descriptor that are idle for CLOSE_TIMEOUT seconds and
+   isn't a ALIVE socket is probably hanging and we close it */
+
+#define IDLE_TIMEOUT 5
+#define CLOSE_TIMEOUT 60
+
+/* We save the name of nodes that are unregistered. If a new
+   node register the name we want to increment the "creation",
+   a constant 1..3. But we put an limit to this saving to keep
+   the lookup fast and not to leak memory. */
+
+#define MAX_UNREG_COUNT 1000
+#define DEBUG_MAX_UNREG_COUNT 5
+
+/* Maximum length of a node name == atom name */
+#define MAXSYMLEN 255
+
+#define INBUF_SIZE 1024
+#define OUTBUF_SIZE 1024
+
+#define get_int16(s) ((((unsigned char*)  (s))[0] << 8) | \
+                      (((unsigned char*)  (s))[1]))
+
+#define put_int16(i, s) {((unsigned char*)(s))[0] = ((i) >> 8) & 0xff; \
+                        ((unsigned char*)(s))[1] = (i)         & 0xff;}
+
+/* ************************************************************************ */
+
+/* Stuctures used by server */
+
+typedef struct {
+  int fd;			/* File descriptor */
+  unsigned open:1;		/* TRUE if open */
+  unsigned keep:1;		/* Don't close when sent reply */
+  unsigned got;			/* # of bytes we have got */
+  unsigned want;		/* Number of bytes we want */
+  char *buf;			/* The remaining buffer */
+
+  time_t mod_time;		/* Last activity on this socket */
+} Connection;
+
+struct enode {
+  struct enode *next;
+  int fd;			/* The socket in use */
+  unsigned short port;		/* Port number of Erlang node */
+  char symname[MAXSYMLEN+1];	/* Name of the Erlang node */
+  short creation;		/* Started as a random number 1..3 */
+  char nodetype;                /* 77 = normal erlang node 72 = hidden (c-node */
+  char protocol;                /* 0 = tcp/ipv4 */
+  unsigned short highvsn;       /* 0 = OTP-R3 erts-4.6.x, 1 = OTP-R4 erts-4.7.x*/
+  unsigned short lowvsn;
+  char extra[MAXSYMLEN+1];
+};
+
+typedef struct enode Node;
+
+typedef struct {
+  Node *reg;
+  Node *unreg;
+  Node *unreg_tail;
+  int unreg_count;
+} Nodes;
+
+
+/* This is the structure with all variables needed to pass on
+   to all functions. This makes this program reentrant */
+
+typedef struct {
+  int port;
+  int debug;
+  int silent; 
+  int is_daemon;
+  unsigned packet_timeout;
+  unsigned delay_accept;
+  unsigned delay_write;
+  int max_conn;
+  int active_conn;
+  char *progname;
+  Connection *conn;
+  Nodes nodes;
+  fd_set orig_read_mask;
+  int listenfd;
+  char **argv;
+} EpmdVars;
+
+void dbg_printf(EpmdVars*,int,const char*,...);
+void dbg_tty_printf(EpmdVars*,int,const char*,...);
+void dbg_perror(EpmdVars*,const char*,...);
+void kill_epmd(EpmdVars*);
+void epmd_call(EpmdVars*,int);
+void run(EpmdVars*);
+void epmd_cleanup_exit(EpmdVars*, int);
+int epmd_conn_close(EpmdVars*,Connection*);
+
+#ifdef DONT_USE_MAIN
+int  start_epmd(char *,char *,char *,char *,char *,char *,char *,char *,char *,char *);
+int  epmd(int,char **);
+int  epmd_dbg(int,int);
+#endif
+
+
diff --git a/erts/epmd/src/epmd_srv.c b/erts/epmd/src/epmd_srv.c
new file mode 100644
index 0000000000..b71e27cffd
--- /dev/null
+++ b/erts/epmd/src/epmd_srv.c
@@ -0,0 +1,1254 @@
+/* -*- c-indent-level: 2; c-continued-statement-offset: 2 -*- */ 
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#include "epmd.h"     /* Renamed from 'epmd_r4.h' */
+#include "epmd_int.h"
+
+/*
+ *  
+ *  This server is a local name server for Erlang nodes. Erlang nodes can
+ *  ask this server for the listening port of other Erlang nodes on the
+ *  machine EPMD is running on. New distributed nodes that are started
+ *  register their names with this server.
+ *
+ *  To be accessible to all Erlang nodes this server listens to a well
+ *  known port EPMD_PORT_NO (curently port 4369) where requests
+ *  for connections can be sent.
+ *
+ *  To keep track of when registered Erlang nodes are terminated this
+ *  server keeps the socket open where the request for registration was
+ *  made.
+ *
+ *  The protocol is briefly documented in "erl_ext_dist.txt". All requests
+ *  to this server are done with a packet
+ *
+ *      2        n
+ *  +--------+---------+
+ *  | Length | Request |
+ *  +--------+---------+
+ *
+ *  In all but one case there is only one request for each connection made
+ *  to this server so we can safely close the socket after sending the
+ *  reply.  The exception is ALIVE_REQ where we keep the connection
+ *  open without sending any data. When we receive a "close" this is
+ *  an indication that the Erlang node was terminated. The termination
+ *  may have been "normal" or caused by a crash. The operating system
+ *  ensure that the connection is closed either way.
+ *  
+ *  Reading is done non-blocking, i.e. we call a "read" only if we are
+ *  told by the "select" function that there are data to read.
+ *  
+ *  Two databases are used: One node database where the registered names
+ *  of the nodes are stored, and one connection database where the state
+ *  of sockets and the data buffers is stored.
+ *  
+ *  Incomplete packets are thrown away after a timout. The Erlang node
+ *  doing the request is responsible for completing in it in a reasonable time.
+ *
+ *  Note that if the server gets busy it may not have time to
+ *  process all requests for connection. The "accept()" function
+ *  will on most operating systems silently refuse to accept more
+ *  than 5 outstanding requests. It is the client's responsibility
+ *  to retry the request a number of times with random time interval.
+ *  The "-debug" flag will insert a delay so you can test this 
+ *  behaviour.
+ *
+ *  FIXME: In this code we assume that the packets we send on each
+ *  socket is so small that a "write()" never block
+ *
+ *  FIXME: We never restarts a read or write that was terminated
+ *  by an interrupt. Do we need to?
+ *
+ */
+
+/* We use separate data structures for node names and connections
+   so that a request will not use a slot with a name that we
+   want to resuse later incrementing the "creation" */
+
+
+/* forward declarations */
+
+static void do_request(EpmdVars*,int,Connection*,char*,int);
+static int do_accept(EpmdVars*,int);
+static void do_read(EpmdVars*,Connection*);
+static time_t current_time(EpmdVars*);
+
+static Connection *conn_init(EpmdVars*);
+static int conn_open(EpmdVars*,int);
+static int conn_close_fd(EpmdVars*,int);
+
+static void node_init(EpmdVars*);
+static Node *node_reg(EpmdVars*,char*,int,int);
+static Node *node_reg2(EpmdVars*,char*, int, int, unsigned char, unsigned char, int, int, char*);
+static int node_unreg(EpmdVars*,char*);
+static int node_unreg_sock(EpmdVars*,int);
+
+static int reply(EpmdVars*,int,char *,int);
+static void dbg_print_buf(EpmdVars*,char *,int);
+static void print_names(EpmdVars*);
+
+
+void run(EpmdVars *g)
+{
+  int listensock;
+  int i;
+  int opt;
+  struct EPMD_SOCKADDR_IN iserv_addr;
+
+  node_init(g);
+  g->conn = conn_init(g);
+
+  dbg_printf(g,2,"try to initiate listening port %d", g->port);
+  
+  if ((listensock = socket(FAMILY,SOCK_STREAM,0)) < 0) {
+    dbg_perror(g,"error opening stream socket");
+    epmd_cleanup_exit(g,1);
+  }
+  g->listenfd = listensock;
+
+  /*
+   * Initialize number of active file descriptors.
+   * Stdin, stdout, and stderr are still open.
+   * One for the listen socket.
+   */
+  g->active_conn = 3+1;
+  
+  /*
+   * Note that we must not enable the SO_REUSEADDR on Windows,
+   * because addresses will be reused even if they are still in use.
+   */
+  
+#if (!defined(__WIN32__) && !defined(_OSE_))
+  /* We ignore the SIGPIPE signal that is raised when we call write
+     twice on a socket closed by the other end. */
+  signal(SIGPIPE, SIG_IGN);
+
+  opt = 1;			/* Set this option */
+  if (setsockopt(listensock,SOL_SOCKET,SO_REUSEADDR,(char* ) &opt,
+		 sizeof(opt)) <0) {
+    dbg_perror(g,"can't set sockopt");
+    epmd_cleanup_exit(g,1);
+  }
+#endif
+  
+  /* In rare cases select returns because there is someone
+     to accept but the request is withdrawn before the
+     accept function is called. We set the listen socket
+     to be non blocking to prevent us from being hanging
+     in accept() waiting for the next request. */
+#ifdef _OSE_  
+  opt = 1;
+  if (ioctl(listensock, FIONBIO, (char*)&opt) != 0)
+#else
+#if (defined(__WIN32__) || defined(NO_FCNTL))
+  opt = 1;
+  if (ioctl(listensock, FIONBIO, &opt) != 0) /* Gives warning in VxWorks */
+#else
+  opt = fcntl(listensock, F_GETFL, 0);
+  if (fcntl(listensock, F_SETFL, opt | O_NONBLOCK) == -1)
+#endif /* __WIN32__ || VXWORKS */
+#endif /* _OSE_ */
+    dbg_perror(g,"failed to set non-blocking mode of listening socket %d",
+	       listensock);
+
+  { /* store port number in unsigned short */
+    unsigned short sport = g->port;
+    SET_ADDR_ANY(iserv_addr, FAMILY, sport);
+  }
+  
+#ifdef _OSE_
+  {
+    int optlen = sizeof(opt);
+    opt = 1;
+    if(getsockopt(listensock, SOL_SOCKET, SO_REUSEADDR,
+		  (void*)&opt, &optlen) < 0)
+      fprintf(stderr, "\n\nGETSOCKOPT FAILS! %d\n\n", errno);
+    else if(opt == 1)
+      fprintf(stderr, "SO_REUSEADDR is set!\n");
+  }
+#endif
+
+  if(bind(listensock,(struct sockaddr*) &iserv_addr, sizeof(iserv_addr)) < 0 )
+    {
+      if (errno == EADDRINUSE)
+	{
+	  dbg_tty_printf(g,1,"there is already a epmd running at port %d",
+			 g->port);
+	  epmd_cleanup_exit(g,0);
+	}
+      else
+	{
+	  dbg_perror(g,"failed to bind socket");
+	  epmd_cleanup_exit(g,1);
+	}
+    }
+
+  dbg_printf(g,2,"starting");
+
+  listen(listensock, SOMAXCONN);
+
+
+  FD_ZERO(&g->orig_read_mask);
+  FD_SET(listensock,&g->orig_read_mask);
+
+  dbg_tty_printf(g,2,"entering the main select() loop");
+
+ select_again:
+  while(1)
+    {	
+      fd_set read_mask = g->orig_read_mask;
+      struct timeval timeout;
+      int ret;
+
+      /* If we are idle we time out now and then to enable the code
+	 below to close connections that are old and probably
+	 hanging. Make sure that select will return often enough. */
+
+      timeout.tv_sec = (g->packet_timeout < IDLE_TIMEOUT) ? 1 : IDLE_TIMEOUT;
+      timeout.tv_usec = 0;
+
+      if ((ret = select(g->max_conn,&read_mask,(fd_set *)0,(fd_set *)0,&timeout)) < 0)
+	dbg_perror(g,"error in select ");
+      else {
+	time_t now;
+	if (ret == 0) {
+	  FD_ZERO(&read_mask);
+	}
+	if (g->delay_accept) {		/* Test of busy server */
+	  sleep(g->delay_accept);
+	}
+
+	if (FD_ISSET(listensock,&read_mask)) {
+	  if (do_accept(g, listensock) && g->active_conn < g->max_conn) {
+	    /*
+	     * The accept() succeeded, and we have at least one file
+	     * descriptor still free, which means that another accept()
+	     * could succeed. Go do do another select(), in case there
+	     * are more incoming connections waiting to be accepted.
+	     */
+	    goto select_again;
+	  }
+	}
+	  
+	/* Check all open streams marked by select for data or a
+	   close.  We also close all open sockets except ALIVE
+	   with no activity for a long period */
+
+	now = current_time(g);
+	for (i = 0; i < g->max_conn; i++) {
+	  if (g->conn[i].open == EPMD_TRUE) {
+	    if (FD_ISSET(g->conn[i].fd,&read_mask))
+	      do_read(g,&g->conn[i]);
+	    else if ((g->conn[i].keep == EPMD_FALSE) &&
+		     ((g->conn[i].mod_time + g->packet_timeout) < now)) {
+	      dbg_tty_printf(g,1,"closing because timed out on receive");
+	      epmd_conn_close(g,&g->conn[i]);
+	    }
+	  }
+	}
+      }
+    }
+}
+
+/*
+ *  This routine read as much of the packet as possible and
+ *  if completed calls "do_request()" to fullfill the request.
+ *
+ */
+
+static void do_read(EpmdVars *g,Connection *s)
+{
+  int val, pack_size;
+
+  if (s->open == EPMD_FALSE)
+    {
+      dbg_printf(g,0,"read on unknown socket");
+      return;
+    }
+
+  /* Check if we already got the whole packet but we keep the
+     connection alive to find out when a node is terminated. We then
+     want to check for a close */
+
+  if (s->keep == EPMD_TRUE)
+    {
+      val = read(s->fd, s->buf, INBUF_SIZE);
+
+      if (val == 0)
+	{
+	  node_unreg_sock(g,s->fd);
+	  epmd_conn_close(g,s);
+	}
+      else if (val < 0)
+	{
+	    dbg_tty_printf(g,1,"error on ALIVE socket %d (%d; errno=0x%x)",
+			   s->fd, val, errno);
+	  node_unreg_sock(g,s->fd);
+	  epmd_conn_close(g,s);
+	}
+      else
+	{
+	  dbg_tty_printf(g,1,"got more than expected on ALIVE socket %d (%d)",
+		 s->fd,val);
+	  dbg_print_buf(g,s->buf,val);
+
+	  /* FIXME: Shouldn't be needed to close down.... */
+	  node_unreg_sock(g,s->fd);
+	  epmd_conn_close(g,s);
+	}
+      /* FIXME: We always close, probably the right thing to do */
+      return;
+    }
+
+  /* If unknown size we request the whole buffer - what we got - 1
+     We subtract 1 because we will add a "\0" in "do_request()".
+     This is not needed for R3A or higher versions of Erlang,
+     because the '\0' is included in the request,
+     but is kept for backwards compatibility to allow R2D to use
+     this epmd. */
+
+  pack_size = s->want ? s->want : INBUF_SIZE - 1;
+  val = read(s->fd, s->buf + s->got, pack_size - s->got);
+
+  if (val == 0)
+    {
+      /* A close when we haven't got all data */
+      dbg_printf(g,0,"got partial packet only on file descriptor %d (%d)",
+		 s->fd,s->got);
+      epmd_conn_close(g,s);
+      return;
+    }
+
+  if (val < 0)
+    {
+      dbg_perror(g,"error in read");
+      epmd_conn_close(g,s);
+      return;
+    }
+
+  dbg_print_buf(g,s->buf,val);
+
+  s->got += val;
+
+  if ((s->want == 0) && (s->got >= 2))
+    {
+      /* The two byte header that specify the length of the packet
+	 doesn't count the header as part of the packet so we add 2
+	 to "s->want" to make us talk about all bytes we get. */
+
+      s->want = get_int16(s->buf) + 2;
+
+      if ((s->want < 3) || (s->want >= INBUF_SIZE))
+	{
+	  dbg_printf(g,0,"invalid packet size (%d)",s->want - 2);
+	  epmd_conn_close(g,s);
+	  return;
+	}
+
+      if (s->got > s->want)
+	{
+	  dbg_printf(g,0,"got %d bytes in packet, expected %d",
+		     s->got - 2, s->want - 2);
+	  epmd_conn_close(g,s);
+	  return;
+	}
+    }
+  
+  s->mod_time = current_time(g); /* Note activity */
+  
+  if (s->want == s->got)
+    {
+      /* Do action and close up */
+      /* Skip header bytes */
+
+      do_request(g, s->fd, s, s->buf + 2, s->got - 2);
+
+      if (!s->keep)
+	epmd_conn_close(g,s);		/* Normal close */
+    }
+}
+
+static int do_accept(EpmdVars *g,int listensock)
+{
+    int msgsock;
+    struct EPMD_SOCKADDR_IN icli_addr; /* workaround for QNX bug - cannot */
+    int icli_addr_len;            /* handle NULL pointers to accept.  */
+
+    icli_addr_len = sizeof(icli_addr);
+
+    msgsock = accept(listensock,(struct sockaddr*) &icli_addr,
+		     (unsigned int*) &icli_addr_len);
+
+    if (msgsock < 0) {
+        dbg_perror(g,"error in accept");
+	return EPMD_FALSE;
+    }
+
+    return conn_open(g,msgsock);
+}
+
+static void do_request(g, fd, s, buf, bsize)
+     EpmdVars *g;
+     int fd;
+     Connection *s;
+     char *buf;
+     int bsize;
+{
+  char wbuf[OUTBUF_SIZE];	/* Buffer for writing */
+  int i;
+
+  /*
+   * Terminate packet as a C string.  Needed for requests received from Erlang
+   * nodes with lower version than R3A.
+   */
+
+  buf[bsize] = '\0';
+
+  switch (*buf)
+    {
+    case EPMD_ALIVE_REQ:
+      dbg_printf(g,1,"** got ALIVE_REQ");
+
+      /* The packet has the format "axxyyyyyy" where xx is port, given
+	 in network byte order, and yyyyyy is symname, possibly null
+	 terminated. */
+
+      if (buf[bsize - 1] == '\000') /* Skip null termination */
+	bsize--;
+	
+      if (bsize <= 3)
+	{
+	  dbg_printf(g,0,"packet to small for request ALIVE_REQ (%d)", bsize);
+	  return;
+	}
+
+      for (i = 3; i < bsize; i++)
+	if (buf[i] == '\000')
+	  {
+	    dbg_printf(g,0,"node name contains ascii 0 in ALIVE_REQ");
+	    return;
+	  }
+
+      {
+	Node *node;
+	int eport;
+	char *name  = &buf[3];	/* points to node name */
+
+	eport = get_int16(&buf[1]);
+
+	if ((node = node_reg(g, name, fd, eport)) == NULL)
+	  return;
+
+	wbuf[0] = EPMD_ALIVE_OK_RESP;
+	put_int16(node->creation, wbuf+1);
+  
+	if (g->delay_write)		/* Test of busy server */
+	  sleep(g->delay_write);
+
+	if (reply(g, fd, wbuf, 3) != 3)
+	  {
+	    dbg_tty_printf(g,1,"failed to send ALIVE_OK_RESP for \"%s\"",name);
+	    return;
+	  }
+
+	dbg_tty_printf(g,1,"** sent ALIVE_OK_RESP for \"%s\"",name);
+	s->keep = EPMD_TRUE;		/* Don't close on inactivity */
+      }
+      break;
+
+    case EPMD_PORT_REQ:
+      dbg_printf(g,1,"** got PORT_REQ");
+
+      if (buf[bsize - 1] == '\000') /* Skip null termination */
+	bsize--;
+	
+      if (bsize <= 1)
+	{
+	  dbg_printf(g,0,"packet to small for request PORT_REQ (%d)", bsize);
+	  return;
+	}
+
+      for (i = 1; i < bsize; i++)
+	if (buf[i] == '\000')
+	  {
+	    dbg_printf(g,0,"node name contains ascii 0 in PORT_REQ");
+	    return;
+	  }
+
+      {
+	char *name = &buf[1]; /* Points to node name */
+	Node *node;
+
+	for (node = g->nodes.reg; node; node = node->next)
+	  {
+	    if (strcmp(node->symname, name) == 0)
+	      {
+		put_int16(node->port,wbuf);
+		if (reply(g, fd, wbuf, 2) != 2)
+		  {
+		    dbg_tty_printf(g,1,"failed to send PORT_RESP for %s: %d",
+				   name,node->port);
+		    return;
+		  }
+		dbg_tty_printf(g,1,"** sent PORT_RESP for %s: %d",
+			       name,node->port);
+		return;
+	      }
+	  }
+	dbg_tty_printf(g,1,"Closed on PORT_REQ for %s",name);
+      }
+      /* FIXME: How about an answer if no port? Is a close enough? */
+      break;
+
+    case EPMD_ALIVE2_REQ:
+      dbg_printf(g,1,"** got ALIVE2_REQ");
+
+      /* The packet has the format "axxyyyyyy" where xx is port, given
+	 in network byte order, and yyyyyy is symname, possibly null
+	 terminated. */
+
+      if (bsize <= 13)
+	{
+	  dbg_printf(g,0,"packet to small for request ALIVE2_REQ (%d)",bsize);
+	  return;
+	}
+
+      {
+	Node *node;
+	int eport;
+	unsigned char nodetype;
+	unsigned char protocol;
+	unsigned short highvsn;
+	unsigned short lowvsn;
+	int namelen;
+	int extralen;
+	char *name; 
+	char *extra;
+	eport = get_int16(&buf[1]);
+	nodetype = buf[3];
+	protocol = buf[4];
+	highvsn = get_int16(&buf[5]);
+	lowvsn = get_int16(&buf[7]);
+	namelen = get_int16(&buf[9]);
+	extralen = get_int16(&buf[11+namelen]);
+	for (i = 11 ; i < 11 + namelen; i ++)
+	    if (buf[i] == '\000')  {
+		dbg_printf(g,0,"node name contains ascii 0 in ALIVE2_REQ");
+		return;
+	    }
+	name = &buf[11];
+	name[namelen]='\000';
+	extra = &buf[11+namelen+1];
+	extra[extralen]='\000';
+	wbuf[0] = EPMD_ALIVE2_RESP;
+	if ((node = node_reg2(g, name, fd, eport, nodetype, protocol,
+			      highvsn, lowvsn, extra)) == NULL) {
+	    wbuf[1] = 1; /* error */
+	    put_int16(99, wbuf+2);
+	} else {
+	    wbuf[1] = 0; /* ok */
+	    put_int16(node->creation, wbuf+2);
+	}
+  
+	if (g->delay_write)		/* Test of busy server */
+	  sleep(g->delay_write);
+
+	if (reply(g, fd, wbuf, 4) != 4)
+	  {
+	    dbg_tty_printf(g,1,"** failed to send ALIVE2_RESP for \"%s\"",
+			   name);
+	    return;
+	  }
+
+	dbg_tty_printf(g,1,"** sent ALIVE2_RESP for \"%s\"",name);
+	s->keep = EPMD_TRUE;		/* Don't close on inactivity */
+      }
+      break;
+
+    case EPMD_PORT2_REQ:
+      dbg_printf(g,1,"** got PORT2_REQ");
+
+      if (buf[bsize - 1] == '\000') /* Skip null termination */
+	bsize--;
+	
+      if (bsize <= 1)
+	{
+	  dbg_printf(g,0,"packet to small for request PORT2_REQ (%d)", bsize);
+	  return;
+	}
+
+      for (i = 1; i < bsize; i++)
+	if (buf[i] == '\000')
+	  {
+	    dbg_printf(g,0,"node name contains ascii 0 in PORT2_REQ");
+	    return;
+	  }
+
+      {
+	char *name = &buf[1]; /* Points to node name */
+	Node *node;
+	
+	wbuf[0] = EPMD_PORT2_RESP;
+	for (node = g->nodes.reg; node; node = node->next) {
+	    int offset;
+	    if (strcmp(node->symname, name) == 0) {
+		wbuf[1] = 0; /* ok */
+		put_int16(node->port,wbuf+2);
+		wbuf[4] = node->nodetype;
+		wbuf[5] = node->protocol;
+		put_int16(node->highvsn,wbuf+6);
+		put_int16(node->lowvsn,wbuf+8);
+		put_int16(strlen(node->symname),wbuf+10);
+		offset = 12;
+		strcpy(wbuf + offset,node->symname);
+		offset += strlen(node->symname);
+		put_int16(strlen(node->extra),wbuf + offset);
+		offset += 2;
+		strcpy(wbuf + offset,node->extra);
+		offset += (strlen(node->extra)-1);
+		if (reply(g, fd, wbuf, offset) != offset)
+		  {
+		    dbg_tty_printf(g,1,"** failed to send PORT2_RESP (ok) for \"%s\"",name);
+		    return;
+		  }
+		dbg_tty_printf(g,1,"** sent PORT2_RESP (ok) for \"%s\"",name);
+		return;
+	    }
+	}
+	wbuf[1] = 1; /* error */
+	if (reply(g, fd, wbuf, 2) != 2)
+	  {
+	    dbg_tty_printf(g,1,"** failed to send PORT2_RESP (error) for \"%s\"",name);
+	    return;
+	  }
+	dbg_tty_printf(g,1,"** sent PORT2_RESP (error) for \"%s\"",name);
+	return;
+      }
+      break;
+
+    case EPMD_NAMES_REQ:
+      dbg_printf(g,1,"** got NAMES_REQ");
+      {
+	Node *node;
+
+	i = htonl(g->port);
+	memcpy(wbuf,&i,4);
+
+	if (reply(g, fd,wbuf,4) != 4)
+	  {
+	    dbg_tty_printf(g,1,"failed to send NAMES_RESP");
+	    return;
+	  }
+
+	for (node = g->nodes.reg; node; node = node->next)
+	  {
+	    int len;
+
+	    /* CAREFUL!!! These are parsed by "erl_epmd.erl" so a slight
+	       change in syntax will break < OTP R3A */
+
+	    sprintf(wbuf,"name %s at port %d\n",node->symname, node->port);
+	    len = strlen(wbuf);
+	    if (reply(g, fd, wbuf, len) != len)
+	      {
+		dbg_tty_printf(g,1,"failed to send NAMES_RESP");
+		return;
+	      }
+	  }
+      }
+      dbg_tty_printf(g,1,"** sent NAMES_RESP");
+      break;
+
+    case EPMD_DUMP_REQ:
+      dbg_printf(g,1,"** got DUMP_REQ");
+      {
+	Node *node;
+
+	i = htonl(g->port);
+	memcpy(wbuf,&i,4);
+	if (reply(g, fd,wbuf,4) != 4)
+	  {
+	    dbg_tty_printf(g,1,"failed to send DUMP_RESP");
+	    return;
+	  }
+
+	for (node = g->nodes.reg; node; node = node->next)
+	  {
+	    int len;
+
+	    /* CAREFUL!!! These are parsed by "erl_epmd.erl" so a slight
+	       change in syntax will break < OTP R3A */
+
+	    sprintf(wbuf,"active name     <%s> at port %d, fd = %d\n",
+		    node->symname, node->port, node->fd);
+	    len = strlen(wbuf) + 1;
+	    if (reply(g, fd,wbuf,len) != len)
+	      {
+		dbg_tty_printf(g,1,"failed to send DUMP_RESP");
+		return;
+	      }
+	  }
+
+	for (node = g->nodes.unreg; node; node = node->next)
+	  {
+	    int len;
+
+	    /* CAREFUL!!! These are parsed by "erl_epmd.erl" so a slight
+	       change in syntax will break < OTP R3A */
+
+	    sprintf(wbuf,"old/unused name <%s>, port = %d, fd = %d \n",
+		    node->symname,node->port, node->fd);
+	    len = strlen(wbuf) + 1;
+	    if (reply(g, fd,wbuf,len) != len)
+	      {
+		dbg_tty_printf(g,1,"failed to send DUMP_RESP");
+		return;
+	      }
+	  }
+      }
+      dbg_tty_printf(g,1,"** sent DUMP_RESP");
+      break;
+
+    case EPMD_KILL_REQ:
+      dbg_printf(g,1,"** got KILL_REQ");
+      if (reply(g, fd,"OK",2) != 2)
+	dbg_printf(g,0,"failed to send reply to KILL_REQ");
+      dbg_tty_printf(g,1,"epmd killed");
+      conn_close_fd(g,fd);	/* We never return to caller so close here */
+      dbg_printf(g,0,"got KILL_REQ - terminates normal");
+      epmd_cleanup_exit(g,0);			/* Normal exit */
+
+    case EPMD_STOP_REQ:
+      dbg_printf(g,1,"** got STOP_REQ");
+      if (bsize <= 1 )
+	{
+	  dbg_printf(g,0,"packet to small for request STOP_REQ (%d)",bsize);
+	  return;
+	}
+
+      {
+	char *name = &buf[1]; /* Points to node name */
+	int node_fd;
+
+	if ((node_fd = node_unreg(g,name)) < 0)
+	  {
+	    if (reply(g, fd,"NOEXIST",7) != 7)
+	      {
+		dbg_tty_printf(g,1,"failed to send STOP_RESP NOEXIST");
+		return;
+	      }
+	    dbg_tty_printf(g,1,"** sent STOP_RESP NOEXIST");
+	  }
+
+	conn_close_fd(g,node_fd);
+	dbg_tty_printf(g,1,"epmd connection stopped");
+
+	if (reply(g, fd,"STOPPED",7) != 7)
+	  {
+	    dbg_tty_printf(g,1,"failed to send STOP_RESP STOPPED");
+	    return;
+	  }
+	dbg_tty_printf(g,1,"** sent STOP_RESP STOPPED");
+      }
+      break;
+
+    default:
+      dbg_printf(g,0,"got garbage ");
+    }
+}
+
+
+/****************************************************************************
+ *
+ *  Handle database with data for each socket to read
+ *
+ ****************************************************************************/
+
+static Connection *conn_init(EpmdVars *g)
+{
+  int nbytes = g->max_conn * sizeof(Connection);
+  Connection *connections = (Connection *)malloc(nbytes);
+
+  if (connections == NULL)
+    {
+      dbg_printf(g,0,"epmd: Insufficient memory");
+#ifdef DONT_USE_MAIN
+      free(g->argv);
+#endif
+      exit(1);
+    }
+
+  memzero(connections, nbytes);
+
+  return connections;
+}
+
+static int conn_open(EpmdVars *g,int fd)
+{
+  int i;
+  Connection *s;
+
+#ifdef VXWORKS
+  /*
+   * Since file descriptors are global on VxWorks, we might get an fd that
+   * does not fit in the FD_SET.
+   *
+   * Note: This test would be harmless on Unix, but would fail on Windows
+   * because socket are numbered differently and FD_SETs are implemented
+   * differently.
+   */
+  if (fd >= FD_SETSIZE) {
+      dbg_tty_printf(g,0,"file descriptor %d: too high for FD_SETSIZE=%d",
+		     fd,FD_SETSIZE);
+      close(fd);
+      return EPMD_FALSE;
+  }
+#endif
+
+  for (i = 0; i < g->max_conn; i++) {
+    if (g->conn[i].open == EPMD_FALSE) {
+      g->active_conn++;
+      s = &g->conn[i];
+     
+      /* From now on we want to know if there are data to be read */
+      FD_SET(fd, &g->orig_read_mask);
+
+      s->fd   = fd;
+      s->open = EPMD_TRUE;
+      s->keep = EPMD_FALSE;
+      s->want = 0;		/* Currently unknown */
+      s->got  = 0;
+      s->mod_time = current_time(g); /* Note activity */
+
+      s->buf = (char *)malloc(INBUF_SIZE);
+
+      if (s->buf == NULL) {
+	dbg_printf(g,0,"epmd: Insufficient memory");
+	close(fd);
+	return EPMD_FALSE;
+      }
+
+      dbg_tty_printf(g,2,"opening connection on file descriptor %d",fd);
+      return EPMD_TRUE;
+    }
+  }
+
+  dbg_tty_printf(g,0,"failed opening connection on file descriptor %d",fd);
+  close(fd);
+  return EPMD_FALSE;
+}
+
+static int conn_close_fd(EpmdVars *g,int fd)
+{
+  int i;
+
+  for (i = 0; i < g->max_conn; i++)
+    if (g->conn[i].fd == fd)
+      {
+	epmd_conn_close(g,&g->conn[i]);
+	return EPMD_TRUE;
+      }
+  
+  return EPMD_FALSE;
+}
+
+
+int epmd_conn_close(EpmdVars *g,Connection *s)
+{
+  dbg_tty_printf(g,2,"closing connection on file descriptor %d",s->fd);
+
+  FD_CLR(s->fd,&g->orig_read_mask);
+  close(s->fd);			/* Sometimes already closed but close anyway */
+  s->open = EPMD_FALSE;
+  if (s->buf != NULL) {		/* Should never be NULL but test anyway */
+    free(s->buf);
+  }
+  g->active_conn--;
+  return EPMD_TRUE;
+}
+
+/****************************************************************************
+ *
+ *  Handle database with data for each registered node
+ *
+ ****************************************************************************/
+
+
+static void node_init(EpmdVars *g)
+{
+  g->nodes.reg         = NULL;
+  g->nodes.unreg       = NULL;
+  g->nodes.unreg_tail  = NULL;
+  g->nodes.unreg_count = 0;
+}
+
+
+/* We have got a close on a connection and it may be a
+   EPMD_ALIVE_CLOSE_REQ. Note that this call shouild be called
+   *before* calling conn_close() */
+
+static int node_unreg(EpmdVars *g,char *name)
+{
+  Node **prev = &g->nodes.reg;	/* Point to cell pointing to... */
+  Node *node  = g->nodes.reg;	/* Point to first node */
+
+  for (; node; prev = &node->next, node = node->next)
+    if (strcmp(node->symname, name) == 0)
+      {
+	dbg_tty_printf(g,1,"unregistering '%s:%d', port %d",
+		       node->symname, node->creation, node->port);
+
+	*prev = node->next;	/* Link out from "reg" list */
+
+	if (g->nodes.unreg == NULL) /* Link into "unreg" list */
+	  g->nodes.unreg = g->nodes.unreg_tail = node;
+	else
+	  {
+	    g->nodes.unreg_tail->next = node;
+	    g->nodes.unreg_tail = node;
+	  }
+
+	g->nodes.unreg_count++;
+
+	node->next = NULL;	/* Last in list == first in FIFO queue */
+
+	print_names(g);
+
+	return node->fd;
+      }
+
+  dbg_tty_printf(g,1,"trying to unregister node with unknown name %s", name);
+  return -1;
+}
+
+
+static int node_unreg_sock(EpmdVars *g,int fd)
+{
+  Node **prev = &g->nodes.reg;	/* Point to cell pointing to... */
+  Node *node  = g->nodes.reg;	/* Point to first node */
+
+  for (; node; prev = &node->next, node = node->next)
+    if (node->fd == fd)
+      {
+	dbg_tty_printf(g,1,"unregistering '%s:%d', port %d",
+		       node->symname, node->creation, node->port);
+
+	*prev = node->next;	/* Link out from "reg" list */
+
+	if (g->nodes.unreg == NULL) /* Link into "unreg" list */
+	  g->nodes.unreg = g->nodes.unreg_tail = node;
+	else
+	  {
+	    g->nodes.unreg_tail->next = node;
+	    g->nodes.unreg_tail = node;
+	  }
+
+	g->nodes.unreg_count++;
+
+	node->next = NULL;	/* Last in list == first in FIFO queue */
+
+	print_names(g);
+
+	return node->fd;
+      }
+
+  dbg_tty_printf(g,1,
+		 "trying to unregister node with unknown file descriptor %d",
+		 fd);
+  return -1;
+}
+
+/*
+ *  Finding a node slot and a (name,creation) name is a bit tricky.
+ *  We try in order
+ *
+ *  1. If the name was used before and we can reuse that slot but use
+ *     a new "creation" digit in the range 1..3.
+ *
+ *  2. We try to find a new unused slot.
+ *
+ *  3. We try to use an used slot this isn't used any longer.
+ *     FIXME: The criteria for *what* slot to steal should be improved.
+ *     Perhaps use the oldest or something.
+ */
+
+static Node *node_reg(EpmdVars *g,char *name,int fd, int port)
+{
+    return node_reg2(g, name, fd, port, 0, 0, 0, 0, NULL);
+}
+
+static Node *node_reg2(EpmdVars *g,
+		       char* name,
+		       int fd,
+		       int port,
+		       unsigned char nodetype,
+		       unsigned char protocol,
+		       int highvsn,
+		       int lowvsn,
+		       char* extra)
+{
+  Node *prev;			/* Point to previous node or NULL */
+  Node *node;			/* Point to first node */
+
+  /* Can be NULL; means old style */
+  if (extra == NULL)
+     extra = "";
+
+  /* Fail if node name is too long */
+
+  if (strlen(name) > MAXSYMLEN)
+    {
+      dbg_printf(g,0,"node name is too long (%d) %s", strlen(name), name);
+      return NULL;
+    }
+
+  /* Fail if it is already registered */
+
+  for (node = g->nodes.reg; node; node = node->next)
+    if (strcmp(node->symname, name) == 0)
+      {
+	dbg_printf(g,0,"node name already occupied %s", name);
+	return NULL;
+      }
+
+  /* Try to find the name in the used queue so that we
+     can change "creation" number 1..3 */
+
+  prev = NULL;
+
+  for (node = g->nodes.unreg; node; prev = node, node = node->next)
+    if (strcmp(node->symname, name) == 0)
+      {
+	dbg_tty_printf(g,1,"reusing slot with same name '%s'", node->symname);
+
+	if (prev == NULL)	/* First in list matched */
+	  {
+	    if (node->next == NULL) /* Only one element */
+	      g->nodes.unreg = g->nodes.unreg_tail = NULL;
+	    else
+	      g->nodes.unreg = node->next;
+	  }
+	else
+	  {
+	    if (node->next == NULL) /* Last in list */
+	      {
+		g->nodes.unreg_tail = prev; /* Point to new last */
+		prev->next = NULL; /* New last has no next */
+	      }
+	    else
+	      prev->next = node->next; /* Simple link out from list */
+	  }
+
+	g->nodes.unreg_count--;
+
+	/* When reusing we change the "creation" number 1..3 */
+
+	node->creation = node->creation % 3 + 1;
+
+	break;
+      }
+
+  if (node == NULL)
+    {
+      /* A new name. If the "unreg" list is too long we steal the
+	 oldest node structure and use it for the new node, else
+	 we allocate a new node structure */
+
+      if ((g->nodes.unreg_count > MAX_UNREG_COUNT) ||
+	  (g->debug && (g->nodes.unreg_count > DEBUG_MAX_UNREG_COUNT)))
+	{
+	  /* MAX_UNREG_COUNT > 1 so no need to check unreg_tail */
+	  node = g->nodes.unreg;	/* Take first == oldest */
+	  g->nodes.unreg = node->next; /* Link out */
+	  g->nodes.unreg_count--;
+	}
+      else
+	{
+	  if ((node = (Node *)malloc(sizeof(Node))) == NULL)
+	    {
+	      dbg_printf(g,0,"epmd: Insufficient memory");
+	      exit(1);
+	    }
+
+	  node->creation = (current_time(g) % 3) + 1; /* "random" 1-3 */
+	}
+    }
+
+  node->next = g->nodes.reg; /* Link into "reg" queue */
+  g->nodes.reg  = node;
+
+  node->fd       = fd;
+  node->port     = port;
+  node->nodetype = nodetype;
+  node->protocol = protocol;
+  node->highvsn  = highvsn;
+  node->lowvsn   = lowvsn;
+  strcpy(node->extra,extra);
+  strcpy(node->symname,name);
+  FD_SET(fd,&g->orig_read_mask);
+
+  if (highvsn == 0) {
+    dbg_tty_printf(g,1,"registering '%s:%d', port %d",
+		   node->symname, node->creation, node->port);
+  } else {
+    dbg_tty_printf(g,1,"registering '%s:%d', port %d",
+		   node->symname, node->creation, node->port);
+    dbg_tty_printf(g,1,"type %d proto %d highvsn %d lowvsn %d",
+		   nodetype, protocol, highvsn, lowvsn);
+  }      
+
+  print_names(g);
+
+  return node;
+}
+  
+
+static time_t current_time(EpmdVars *g)
+{
+  time_t t = time((time_t *)0);
+  dbg_printf(g,3,"time in seconds: %d",t);
+  return t;
+}
+
+
+static int reply(EpmdVars *g,int fd,char *buf,int len)
+{
+  int val;
+
+  if (len < 0)
+    {
+      dbg_printf(g,0,"Invalid length in write %d",len);
+      return -1;
+    }
+
+  if (g->delay_write)		/* Test of busy server */
+    sleep(g->delay_write);
+
+  val = write(fd,buf,len);
+  if (val < 0)
+    dbg_perror(g,"error in write");
+  else if (val != len)
+    dbg_printf(g,0,"could only send %d bytes out of %d to fd %d",val,len,fd);
+
+  dbg_print_buf(g,buf,len);
+
+  return val;
+}
+      
+
+#define LINEBYTECOUNT 16
+
+static void print_buf_hex(unsigned char *buf,int len,char *prefix)
+{
+  int rows, row;
+
+  rows = len / LINEBYTECOUNT; /* Number of rows */
+  if (len % LINEBYTECOUNT)
+    rows++;			/* If leftovers, add a line for them */
+
+  for (row = 0; row < rows; row++)
+    {
+      int rowstart = row * LINEBYTECOUNT;
+      int rowend   = rowstart + LINEBYTECOUNT;
+      int i;
+
+      fprintf(stderr,"%s%.8x",prefix,rowstart);
+
+      for (i = rowstart; i < rowend; i++)
+	{
+	  if ((i % (LINEBYTECOUNT/2)) == 0)
+	    fprintf(stderr," ");
+
+	  if (i < len)
+	    fprintf(stderr," %.2x",buf[i]);
+	  else
+	    fprintf(stderr,"   ");
+	}
+
+      fprintf(stderr,"  |");
+
+      for (i = rowstart; (i < rowend) && (i < len); i++)
+	{
+	  int c = buf[i];
+
+	  /* Used to be isprint(c) but we want ascii only */
+
+	  if ((c >= 32) && (c <= 126))
+	    fprintf(stderr,"%c",c);
+	  else
+	    fprintf(stderr,".");
+	}
+
+      fprintf(stderr,"|\r\n");
+    }
+}
+
+static void dbg_print_buf(EpmdVars *g,char *buf,int len)
+{
+  int plen;
+
+  if ((g->is_daemon) ||		/* Don't want to write to stderr if daemon */
+      (g->debug < 2))		/* or debug level too low */
+    return;
+
+  dbg_tty_printf(g,1,"got %d bytes",len);
+
+  plen = len > 1024 ? 1024 : len; /* Limit the number of chars to print */
+
+  print_buf_hex((unsigned char*)buf,plen,"***** ");
+
+  if (len != plen)
+    fprintf(stderr,"***** ......and more\r\n");
+}
+
+static void print_names(EpmdVars *g)
+{
+  int count = 0;
+  Node *node;
+
+  if ((g->is_daemon) ||		/* Don't want to write to stderr if daemon */
+      (g->debug < 3))		/* or debug level too low */
+    return;
+
+  for (node = g->nodes.reg; node; node = node->next)
+    {
+      fprintf(stderr,"*****     active name     \"%s#%d\" at port %d, fd = %d\r\n",
+	      node->symname, node->creation, node->port, node->fd);
+      count ++;
+    }
+
+  fprintf(stderr, "*****     reg calculated count  : %d\r\n", count);
+
+  count = 0;
+
+  for (node = g->nodes.unreg; node; node = node->next)
+    {
+      fprintf(stderr,"*****     old/unused name \"%s#%d\"\r\n",
+	      node->symname, node->creation);
+      count ++;
+    }
+
+  fprintf(stderr, "*****     unreg counter         : %d\r\n",
+	  g->nodes.unreg_count);
+  fprintf(stderr, "*****     unreg calculated count: %d\r\n", count);
+}
diff --git a/erts/epmd/test/Makefile b/erts/epmd/test/Makefile
new file mode 100644
index 0000000000..c1d62f0f93
--- /dev/null
+++ b/erts/epmd/test/Makefile
@@ -0,0 +1,80 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1998-2009. All Rights Reserved.
+# 
+# The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved online at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# %CopyrightEnd%
+#
+include $(ERL_TOP)/make/target.mk
+
+include $(ERL_TOP)/make/$(TARGET)/otp.mk
+
+include ../epmd.mk
+
+EBIN = .
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+
+MODULES= epmd_SUITE
+
+ERL_FILES= $(MODULES:%=%.erl)
+
+TARGET_FILES = $(MODULES:%=$(EBIN)/%.$(EMULATOR))
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELEPMDDIR   = $(RELEASE_PATH)/epmd_test
+
+# ----------------------------------------------------
+# FLAGS
+# ----------------------------------------------------
+
+ERL_COMPILE_FLAGS += -I$(ERL_TOP)/lib/test_server/include \
+                     -I$(ERL_TOP)/lib/kernel/src/         \
+                     $(EPMD_FLAGS)
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+
+tests debug opt: $(TARGET_FILES)
+
+clean:
+	rm -f $(TARGET_FILES)
+	rm -f core *~
+
+docs:
+
+# ----------------------------------------------------
+# Release Target
+# ---------------------------------------------------- 
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec:
+
+release_tests_spec: opt
+	$(INSTALL_DIR) $(RELEPMDDIR)
+	$(INSTALL_DATA) epmd.spec epmd.spec.vxworks $(ERL_FILES) \
+		$(TARGET_FILES) $(RELEPMDDIR)
+	chmod -f -R u+w $(RELEPMDDIR)
+
+release_docs_spec:
+
+
+
+
+
diff --git a/erts/epmd/test/epmd.spec b/erts/epmd/test/epmd.spec
new file mode 100644
index 0000000000..0e2496bc72
--- /dev/null
+++ b/erts/epmd/test/epmd.spec
@@ -0,0 +1 @@
+{topcase, {dir, "../epmd_test"}}.
diff --git a/erts/epmd/test/epmd.spec.vxworks b/erts/epmd/test/epmd.spec.vxworks
new file mode 100644
index 0000000000..476308b481
--- /dev/null
+++ b/erts/epmd/test/epmd.spec.vxworks
@@ -0,0 +1,2 @@
+{topcase, {dir, "../epmd_test"}}.
+{skip,{epmd_rx_SUITE,"EPMD RX does simply not work on VxWorks"}}.
diff --git a/erts/epmd/test/epmd_SUITE.erl b/erts/epmd/test/epmd_SUITE.erl
new file mode 100644
index 0000000000..513c87a13e
--- /dev/null
+++ b/erts/epmd/test/epmd_SUITE.erl
@@ -0,0 +1,835 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1998-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(epmd_SUITE).
+-include("test_server.hrl").
+-include_lib("kernel/include/file.hrl").
+
+
+% Timeout for test cases (rather long to work on slow machines)
+-define(SHORT_TEST_TIMEOUT, ?t:seconds(30)).	% Default
+-define(MEDIUM_TEST_TIMEOUT, ?t:minutes(3)).
+-define(LONG_TEST_TIMEOUT, ?t:minutes(10)).
+
+% Delay inserted into code
+-define(SHORT_PAUSE, 100).
+-define(MEDIUM_PAUSE, ?t:seconds(1)).
+-define(LONG_PAUSE, ?t:seconds(5)).
+
+% Test server specific exports
+-export([all/1, init_per_testcase/2, fin_per_testcase/2]).
+
+-export(
+   [
+    register_name/1,
+    register_names_1/1,
+    register_names_2/1,
+    register_duplicate_name/1,
+    get_port_nr/1,
+    slow_get_port_nr/1,
+    unregister_others_name_1/1,
+    unregister_others_name_2/1,
+    register_overflow/1,
+    name_with_null_inside/1,
+    name_null_terminated/1,
+    stupid_names_req/1,
+
+    no_data/1,
+    one_byte/1,
+    two_bytes/1,
+    partial_packet/1,
+    zero_length/1,
+    too_large/1,
+    alive_req_too_small_1/1,
+    alive_req_too_small_2/1,
+    alive_req_too_large/1
+   ]).
+
+
+% Port we use for testing
+-define(PORT,2243).
+-define(EPMDARGS,"-packet_timeout 1").
+
+-define(DUMMY_PORT, 1000).			% Port number to register
+						% not in real use.
+
+% Timeouts etc inside test cases. Time is in milliseconds.
+-define(CONN_RETRY, 4).				% Times to retry connecting
+-define(CONN_SLEEP, 500).
+-define(CONN_TIMEOUT, 100).
+-define(RECV_TIMEOUT, 2000).
+-define(REG_REPEAT_LIM,1000).
+
+% Message codes in epmd protocol
+-define(EPMD_ALIVE_REQ,	$a).
+-define(EPMD_ALIVE_OK_RESP, $Y).
+-define(EPMD_PORT_REQ,	$p).
+-define(EPMD_NAMES_REQ,	$n).
+-define(EPMD_DUMP_REQ,	$d).
+-define(EPMD_KILL_REQ,	$k).
+-define(EPMD_STOP_REQ,	$s).
+
+%%
+%% all/1
+%%
+
+all(suite) ->
+    [
+     register_name,
+     register_names_1,
+     register_names_2,
+     register_duplicate_name,
+     get_port_nr,
+     slow_get_port_nr,
+     unregister_others_name_1,
+     unregister_others_name_2,
+     register_overflow,
+     name_with_null_inside,
+     name_null_terminated,
+     stupid_names_req,
+
+     no_data,
+     one_byte,
+     two_bytes,
+     partial_packet,
+     zero_length,
+     too_large,
+     alive_req_too_small_1,
+     alive_req_too_small_2,
+     alive_req_too_large
+    ].
+
+%%
+%% Run before and after each test case
+%%
+
+init_per_testcase(_Func, Config) ->
+    Dog = test_server:timetrap(?SHORT_TEST_TIMEOUT),
+    cleanup(),
+    [{watchdog, Dog} | Config].
+
+fin_per_testcase(_Func, Config) ->
+    cleanup(),
+    Dog = ?config(watchdog, Config),
+    catch test_server:timetrap_cancel(Dog),	% We may have canceled already
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+register_name(doc) ->
+    ["Register a name"];
+register_name(suite) ->
+    [];
+register_name(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = register_node("foobar"),
+    ?line ok = close(Sock),			% Unregister
+    ok.
+
+register_names_1(doc) ->
+    ["Register and unregister two nodes"];
+register_names_1(suite) ->
+    [];
+register_names_1(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock1} = register_node("foobar"),
+    ?line {ok,Sock2} = register_node("foozap"),
+    ?line ok = close(Sock1),			% Unregister
+    ?line ok = close(Sock2),			% Unregister
+    ok.
+
+register_names_2(doc) ->
+    ["Register and unregister two nodes"];
+register_names_2(suite) ->
+    [];
+register_names_2(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock1} = register_node("foobar"),
+    ?line {ok,Sock2} = register_node("foozap"),
+    ?line ok = close(Sock2),			% Unregister
+    ?line ok = close(Sock1),			% Unregister
+    ok.
+
+register_duplicate_name(doc) ->
+    ["Two nodes with the same name"];
+register_duplicate_name(suite) ->
+    [];
+register_duplicate_name(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = register_node("foobar"),
+    ?line error = register_node("foobar"),
+    ?line ok = close(Sock),			% Unregister
+    ok.
+
+% Internal function to register a node name, no close, i.e. unregister
+
+register_node(Name) ->
+    register_node(Name,?DUMMY_PORT).
+
+register_node(Name, Port) ->
+    case connect() of
+	{ok,Sock} ->
+	    M = [?EPMD_ALIVE_REQ, put16(Port), Name],
+	    case send(Sock, [size16(M), M]) of
+		ok ->
+		    case recv(Sock,3) of
+			{ok, [?EPMD_ALIVE_OK_RESP,_D1,_D0]} ->
+			    {ok,Sock};
+			Other ->
+			    test_server:format("recv on sock ~w: ~p~n",
+					       [Sock,Other]),
+			    error
+		    end;
+		Other ->
+		    test_server:format("send on sock ~w: ~w~n",[Sock,Other]),
+		    error
+	    end;
+	Other ->
+	    test_server:format("Connect on port ~w: ~p~n",[Port,Other]),
+	    error
+    end.
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+name_with_null_inside(doc) ->
+    ["Register a name with a null char in it"];
+name_with_null_inside(suite) ->
+    [];
+name_with_null_inside(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line error = register_node("foo\000bar"),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+name_null_terminated(doc) ->
+    ["Register a name with terminating null byte"];
+name_null_terminated(suite) ->
+    [];
+name_null_terminated(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = register_node("foobar\000"),
+    ?line error = register_node("foobar"),
+    ?line ok = close(Sock),			% Unregister
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+stupid_names_req(doc) ->
+    ["Read names from epmd in a stupid way"];
+stupid_names_req(suite) ->
+    [];
+stupid_names_req(Config) when list(Config) ->
+    Dog = ?config(watchdog, Config),
+    test_server:timetrap_cancel(Dog),
+    LongDog = test_server:timetrap(?MEDIUM_TEST_TIMEOUT),
+    ?line ok = epmdrun(),
+    ?line [FirstConn | Conn] = register_many(1, ?REG_REPEAT_LIM, "foo"),
+    ?line unregister_many([FirstConn]),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = check_names(Conn),
+    ?line ok = unregister_many(Conn),
+    test_server:timetrap_cancel(LongDog),
+    ok.
+
+check_names(Conn) ->
+    ?line {ok,Sock} = connect_active(),
+    ?line {ok,Reply} = do_get_names(Sock),
+    ?line SortConn  = lists:sort(Conn),
+    ?line SortReply = lists:sort(Reply),
+    ?line ok = check_names_cmp(SortConn, SortReply),
+    ok.
+    
+
+% Compare if the result was the same as was registered
+
+check_names_cmp([], []) ->
+    ok;
+check_names_cmp([{Name,Port,_Sock} | Conn], [{Name,Port} | Reply]) ->
+    check_names_cmp(Conn, Reply).
+
+
+% This code is taken directly from "erl_epmd.erl" in R3A01
+
+-define(int16(X), [(X bsr 8) band 16#ff, X band 16#ff]).
+-define(u32(X1,X2,X3,X4), 
+	(((X1) bsl 24) bor ((X2) bsl 16) bor ((X3) bsl 8) bor X4)).
+
+do_get_names(Socket) ->
+    inet_tcp:send(Socket, [?int16(1),?EPMD_NAMES_REQ]),
+    receive
+	{tcp, Socket, [P0,P1,P2,P3 | T]} ->
+	    EpmdPort = ?u32(P0,P1,P2,P3),
+	    if EpmdPort == ?PORT ->
+		    names_loop(Socket, T, []);
+	       true ->
+		    close(Socket),
+		    {error, address}
+	    end;
+	{tcp_closed, Socket} ->
+	    {ok, []}
+    end.
+
+names_loop(Socket, Acc, Ps) ->
+    receive
+	{tcp, Socket, Bytes} ->
+	    {NAcc, NPs} = scan_names(Acc ++ Bytes, Ps),
+	    names_loop(Socket, NAcc, NPs);
+	{tcp_closed, Socket} ->
+	    {_, NPs} = scan_names(Acc, Ps),	% Really needed?
+	    {ok, NPs}
+    end.
+
+scan_names(Buf, Ps) ->
+    case scan_line(Buf, []) of
+	{Line, NBuf} ->
+	    case parse_line(Line) of
+		{ok, Entry} -> 
+		    scan_names(NBuf, [Entry | Ps]);
+		error ->
+		    scan_names(NBuf, Ps)
+	    end;
+	[] -> {Buf, Ps}
+    end.
+
+scan_line([$\n | Buf], Line) -> {lists:reverse(Line), Buf};
+scan_line([C | Buf], Line) -> scan_line(Buf, [C|Line]);
+scan_line([], _) -> [].
+
+parse_line([$n,$a,$m,$e,$ | Buf0]) ->
+    case parse_name(Buf0, []) of
+	{Name, Buf1}  ->
+	    case Buf1 of
+		[$a,$t,$ ,$p,$o,$r,$t,$ | Buf2] ->
+		    case catch list_to_integer(Buf2) of
+			{'EXIT', _} -> error;
+			Port -> {ok, {Name, Port}}
+		    end;
+		_ -> error
+	    end;
+	error -> error
+    end;
+parse_line(_) -> error.
+
+
+parse_name([$  | Buf], Name) -> {lists:reverse(Name), Buf};
+parse_name([C | Buf], Name) -> parse_name(Buf, [C|Name]);
+parse_name([], _Name) -> error.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+get_port_nr(doc) ->
+    ["Register a name on a port and ask about port nr"];
+get_port_nr(suite) ->
+    [];
+get_port_nr(Config) when list(Config) ->
+    port_request([?EPMD_PORT_REQ,"foo"]).
+
+slow_get_port_nr(doc) ->
+    ["Register with slow write and ask about port nr"];
+slow_get_port_nr(suite) ->
+    [];
+slow_get_port_nr(Config) when list(Config) ->
+    port_request([?EPMD_PORT_REQ,d,$f,d,$o,d,$o]).
+
+
+% Internal function used above
+
+port_request(M) ->
+    ?line ok = epmdrun(),
+    Port = 1042,
+    ?line {ok,RSock} = register_node("foo", Port),
+    ?line {ok,Sock} = connect(),
+    ?line ok = send(Sock,[size16(M),M]),
+    R = put16(Port),
+    ?line {ok,R} = recv(Sock, length(R)),
+    ?line ok = close(RSock),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+unregister_others_name_1(doc) ->
+    ["Unregister name of other node"];
+unregister_others_name_1(suite) ->
+    [];
+unregister_others_name_1(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,RSock} = register_node("foo"),
+    ?line {ok,Sock} = connect(),
+    M = [?EPMD_STOP_REQ,"foo"],
+    ?line ok = send(Sock,[size16(M),M]),
+    R = "STOPPED",
+    ?line {ok,R} = recv(Sock,length(R)),
+    ?line ok = close(RSock),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+unregister_others_name_2(doc) ->
+    ["Unregister name of other node"];
+unregister_others_name_2(suite) ->
+    [];
+unregister_others_name_2(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    M = [?EPMD_STOP_REQ,"xxx42"],
+    ?line ok = send(Sock,[size16(M),M]),
+    R = "NOEXIST",
+    ?line {ok,R} = recv(Sock,length(R)),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+register_overflow(doc) ->
+    ["Register too many, clean and redo 10 times"];
+register_overflow(suite) ->
+    [];
+register_overflow(Config) when list(Config) ->
+    Dog = ?config(watchdog, Config),
+    test_server:timetrap_cancel(Dog),
+    LongDog = test_server:timetrap(?LONG_TEST_TIMEOUT),
+    ?line ok = epmdrun(),
+    ?line Conn = register_many(1, ?REG_REPEAT_LIM, "foo"),
+    Count = length(Conn),
+    ?line ok = unregister_many(Conn),
+    sleep(?MEDIUM_PAUSE),
+    test_server:format("Limit was ~w names, now reg/unreg all 10 times~n",
+		       [Count]),
+    ?line ok = register_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = rregister_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = register_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = rregister_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = register_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = rregister_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = register_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = rregister_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = register_repeat(Count),
+    sleep(?MEDIUM_PAUSE),
+    ?line ok = rregister_repeat(Count),
+    test_server:timetrap_cancel(LongDog),
+    ok.
+
+register_repeat(Count) ->
+    Conn = register_many(1, ?REG_REPEAT_LIM, "foo"),
+    ok = unregister_many(Conn),
+    if
+	length(Conn) == Count ->
+	    ok;
+	true ->
+	    error
+    end.
+
+rregister_repeat(Count) ->
+    Conn = register_many(1, ?REG_REPEAT_LIM, "foo"),
+    ok = unregister_many(lists:reverse(Conn)),
+    if
+	length(Conn) == Count ->
+	    ok;
+	true ->
+	    error
+    end.
+
+% Return count of successful registrations
+
+register_many(I, N, _Prefix) when I > N ->
+    test_server:format("Done with all ~n", []),
+    [];
+register_many(I, N, Prefix) ->
+    Name = gen_name(Prefix, I),
+    Port = ?DUMMY_PORT + I,				% Just make it up
+    case register_node(Name, Port) of
+	{ok,Sock} ->
+	    [{Name,Port,Sock} | register_many(I + 1, N, Prefix)];
+	Any ->
+	    test_server:format("Can't register: ~w of 1..~w ~w~n", 
+			       [Name,N,Any]),
+	    []
+    end.
+
+unregister_many([]) ->
+    ok;
+unregister_many([{Name,_Port,Sock} | Socks]) ->
+    case close(Sock) of
+	ok ->
+	    unregister_many(Socks);
+	Any ->
+	    test_server:format("Can't unregister: ~w reason ~w~n", [Name,Any]),
+	    error
+    end.
+
+gen_name(Str,Int) ->
+    Str ++ integer_to_list(Int).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+no_data(doc) ->
+    ["Open but send no data"];
+no_data(suite) ->
+    [];
+no_data(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    sleep(?LONG_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+one_byte(doc) ->
+    ["Send one byte only"];
+one_byte(suite) ->
+    [];
+one_byte(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    ?line ok = send(Sock,[0]),
+    sleep(?LONG_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+two_bytes(doc) ->
+    ["Send packet size only"];
+two_bytes(suite) ->
+    [];
+two_bytes(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    ?line ok = send(Sock,[put16(3)]),
+    sleep(?LONG_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+partial_packet(doc) ->
+    ["Got only part of a packet"];
+partial_packet(suite) ->
+    [];
+partial_packet(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    ?line ok = send(Sock,[put16(100),"only a few bytes"]),
+    sleep(?LONG_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+zero_length(doc) ->
+    ["Invalid zero packet size"];
+zero_length(suite) ->
+    [];
+zero_length(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    ?line ok = send(Sock,[0,0,0,0,0,0,0,0,0,0]),
+    sleep(?MEDIUM_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+too_large(doc) ->
+    ["Invalid large packet"];
+too_large(suite) ->
+    [];
+too_large(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    Size = 63000,
+    M = lists:duplicate(Size, $z),
+    ?line ok = send(Sock,[put16(Size),M]),
+    sleep(?MEDIUM_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+alive_req_too_small_1(doc) ->
+    ["Try to register but not enough data"];
+alive_req_too_small_1(suite) ->
+    [];
+alive_req_too_small_1(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    M = [?EPMD_ALIVE_REQ, 42],
+    ?line ok = send(Sock, [size16(M), M]),
+    sleep(?MEDIUM_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+alive_req_too_small_2(doc) ->
+    ["Try to register but not enough data"];
+alive_req_too_small_2(suite) ->
+    [];
+alive_req_too_small_2(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    M = [?EPMD_ALIVE_REQ, put16(?DUMMY_PORT)],
+    ?line ok = send(Sock, [size16(M), M]),
+    sleep(?MEDIUM_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+alive_req_too_large(doc) ->
+    ["Try to register but node name too large"];
+alive_req_too_large(suite) ->
+    [];
+alive_req_too_large(Config) when list(Config) ->
+    ?line ok = epmdrun(),
+    ?line {ok,Sock} = connect(),
+    L = [
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+	 ],
+    M = [?EPMD_ALIVE_REQ, put16(?DUMMY_PORT), L],
+    ?line ok = send(Sock, [size16(M), M]),
+    sleep(?MEDIUM_PAUSE),
+    ?line closed = recv(Sock,1),
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Terminate all tests with killing epmd.
+
+cleanup() ->
+    sleep(?MEDIUM_PAUSE),
+    case connect() of
+	{ok,Sock} ->
+	    M = [?EPMD_KILL_REQ],
+	    send(Sock, [size16(M), M]),
+	    recv(Sock,length("OK")),
+	    close(Sock),
+	    sleep(?MEDIUM_PAUSE);
+	_ ->
+	    true
+    end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Normal debug start of epmd
+
+epmdrun() ->
+    case os:find_executable(epmd) of
+	false ->
+	    {error, {could_not_find_epmd_in_path}};
+	Path ->
+	    epmdrun(Path)
+    end.
+
+epmdrun(Epmd) ->
+  %% test_server:format("epmdrun() => Epmd = ~p",[Epmd]),
+  osrun(Epmd ++ " " ?EPMDARGS " -port " ++ integer_to_list(?PORT)).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Start an external process
+
+osrun(Cmd) ->
+    _ = open_port({spawn, Cmd}, []),
+    ok.
+    
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Wrappers of TCP functions
+
+% These two functions is the interface for connect.
+% Passive mode is the default
+
+connect() ->
+    connect(?PORT, passive).
+
+connect_active() ->
+    connect(?PORT, active).
+
+
+% Try a few times before giving up
+
+connect(Port, Mode) ->
+    case connect_repeat(?CONN_RETRY, Port, Mode) of
+	{ok,Sock} ->
+	    {ok,Sock};
+	{error,timeout} ->
+	    timeout;
+	{error,Reason} ->
+	    test_server:format("connect: error: ~w~n",[Reason]),
+	    error;
+	Any ->
+	    test_server:format("connect: unknown message: ~w~n",[Any]),
+	    exit(1)
+    end.
+
+
+% Try a few times before giving up. Pause a small time between
+% each try.
+
+connect_repeat(1, Port, Mode) ->
+    connect_mode(Port, Mode);
+connect_repeat(Retry, Port, Mode) ->
+    case connect_mode(Port, Mode) of
+	{ok,Sock} ->
+	    {ok,Sock};
+	{error,Reason} ->
+	    test_server:format("connect: error: ~w~n",[Reason]),
+	    timer:sleep(?CONN_SLEEP),
+	    connect_repeat(Retry - 1, Port, Mode);
+	Any ->
+	    test_server:format("connect: unknown message: ~w~n",[Any]),
+	    exit(1)
+    end.
+
+connect_mode(Port, active) ->
+    gen_tcp:connect("localhost", Port, [{packet, 0}], ?CONN_TIMEOUT);
+connect_mode(Port, passive) ->
+    gen_tcp:connect("localhost", Port, [{packet, 0}, {active, false}],
+		    ?CONN_TIMEOUT).
+
+
+close(Sock) ->
+    case gen_tcp:close(Sock) of
+	{error,_} ->
+	    error;
+	ok ->
+	    ok;
+	Any ->
+	    test_server:format("unknown message: ~w~n",[Any]),
+	    exit(1)
+    end.
+
+recv(Sock, Len) ->
+    recv(Sock, Len, ?RECV_TIMEOUT).
+
+recv(Sock, Len, Timeout) ->
+    case gen_tcp:recv(Sock, Len, Timeout) of
+	{ok,[]} ->				% Should not be the case
+	    recv(Sock, 1, 1);			% any longer
+	{ok,Data} ->
+	    {ok,Data};
+	{error,timeout} ->
+	    timeout;
+	{error,closed} ->
+	    closed;
+	{error,_}=Error ->
+	    Error;
+	Any ->
+	    test_server:format("unknown message: ~w~n",[Any]),
+	    exit(1)
+    end.
+
+%% Send data to socket. The list can be non flat and contain
+%% the atom 'd' or tuple {d,Seconds} where this is delay
+%% put in between the sent characters.
+
+send(Sock, SendSpec) ->
+    case send(SendSpec, [], Sock) of
+	{ok,[]} ->
+	    ok;
+	{ok,RevBytes} ->
+	    send_direct(Sock, lists:reverse(RevBytes));
+	Any ->
+	    Any
+    end.
+
+
+% If an error, return immediately
+% Collect real characters in the first argument to form
+% a string to send. Only perform "actions", like a delay,
+% when this argument is empty.
+
+send([], RevBytes, _Sock) ->
+    {ok,RevBytes};
+send([Byte | Spec], RevBytes, Sock) when integer(Byte) ->
+    send(Spec, [Byte | RevBytes], Sock);
+send([List | Spec], RevBytes, Sock) when list(List) ->
+    case send(List, RevBytes, Sock) of
+	{ok,Left} ->
+	    send(Spec, Left, Sock);
+	Other ->
+	    Other
+    end;
+send([d | Spec], RevBytes, Sock) ->
+    send([{d,1000} | Spec], RevBytes, Sock);
+send([{d,S} | Spec], RevBytes, Sock) ->
+    case send_direct(Sock, lists:reverse(RevBytes)) of
+	ok ->
+	    timer:sleep(S),
+	    send(Spec, [], Sock);
+	Any ->
+	    Any
+    end.
+
+%%%%
+
+send_direct(Sock, Bytes) ->
+    case gen_tcp:send(Sock, Bytes) of
+	ok ->
+	    ok;
+	{error, closed} ->
+	    closed;
+	{error, _Reason} ->
+	    error;
+	Any ->
+	    test_server:format("unknown message: ~w~n",[Any]),
+	    Any
+    end.
+
+sleep(MilliSeconds) ->
+    timer:sleep(MilliSeconds).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+put16(N) ->
+    [N bsr 8, N band 16#ff].
+
+size16(List) ->
+    N = flat_count(List, 0),
+    [N bsr 8, N  band 16#ff].
+
+flat_count([H|T], N) when is_integer(H) ->
+    flat_count(T, N+1);
+flat_count([H|T], N) when is_list(H) ->
+    flat_count(T, flat_count(H, N));
+flat_count([_|T], N) ->
+    flat_count(T, N);
+flat_count([], N) -> N.
+