The R13B03 release.OTP_R13B03

7 files changed, 2538 insertions, 0 deletions

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);
+}