Merge branch 'maint'

Conflicts:
	erts/etc/common/heart.c

11 files changed, 318 insertions, 104 deletions

diff --git a/erts/doc/src/erl.xml b/erts/doc/src/erl.xml
index 93d1289e8d..7cdb3a4dfe 100644
--- a/erts/doc/src/erl.xml
+++ b/erts/doc/src/erl.xml
@@ -1042,6 +1042,37 @@
           the emulator will be allowed to spend writing a crash dump. When
           the given number of seconds have elapsed, the emulator will be
           terminated by a SIGALRM signal.</p>
+
+	  <p> If the environment variable is <em>not</em> set or it is set to zero seconds, <c><![CDATA[ERL_CRASH_DUMP_SECONDS=0]]></c>,
+		  the runtime system will not even attempt to write the crash dump file. It will just terminate.
+	  </p>
+	  <p> If the environment variable is set to negative valie, e.g. <c><![CDATA[ERL_CRASH_DUMP_SECONDS=-1]]></c>,
+		  the runtime system will wait indefinitely for the crash dump file to be written.
+	  </p>
+	  <p> This environment variable is used in conjuction with
+		  <seealso marker="kernel:heart"><c>heart</c></seealso> if <c>heart</c> is running:
+	  </p>
+	  <taglist>
+		  <tag><c><![CDATA[ERL_CRASH_DUMP_SECONDS=0]]></c></tag>
+		  <item><p>
+				  Suppresses the writing a crash dump file entirely,
+				  thus rebooting the runtime system immediately.
+				  This is the same as not setting the environment variable.
+			  </p>
+		  </item>
+		  <tag><c><![CDATA[ERL_CRASH_DUMP_SECONDS=-1]]></c></tag>
+		  <item><p>Setting the environment variable to a negative value will cause the
+				  termination of the runtime system to wait until the crash dump file
+				  has been completly written.
+			  </p>
+		  </item>
+		  <tag><c><![CDATA[ERL_CRASH_DUMP_SECONDS=S]]></c></tag>
+		  <item><p>
+				  Will wait for <c>S</c> seconds to complete the crash dump file and
+				  then terminate the runtime system.
+			  </p>
+		  </item>
+	  </taglist>
       </item>
       <tag><c><![CDATA[ERL_AFLAGS]]></c></tag>
       <item>
diff --git a/erts/emulator/beam/atom.names b/erts/emulator/beam/atom.names
index 106fad030b..afcbd732df 100644
--- a/erts/emulator/beam/atom.names
+++ b/erts/emulator/beam/atom.names
@@ -252,6 +252,7 @@ atom heap_block_size
 atom heap_size
 atom heap_sizes
 atom heap_type
+atom heart_port
 atom heir
 atom hidden
 atom hide
diff --git a/erts/emulator/beam/break.c b/erts/emulator/beam/break.c
index 376201c309..63136d86c9 100644
--- a/erts/emulator/beam/break.c
+++ b/erts/emulator/beam/break.c
@@ -663,10 +663,13 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
     ErtsThrPrgrData tpd_buf; /* in case we aren't a managed thread... */
 #endif
     int fd;
+    size_t envsz;
     time_t now;
+    char env[21]; /* enough to hold any 64-bit integer */
     size_t dumpnamebufsize = MAXPATHLEN;
     char dumpnamebuf[MAXPATHLEN];
     char* dumpname;
+    int secs;
 
     if (ERTS_SOMEONE_IS_CRASH_DUMPING)
 	return;
@@ -689,9 +692,41 @@ erl_crash_dump_v(char *file, int line, char* fmt, va_list args)
     erts_writing_erl_crash_dump = 1;
 #endif
 
-    erts_sys_prepare_crash_dump();
+    envsz = sizeof(env);
+    /* ERL_CRASH_DUMP_SECONDS not set
+     * same as ERL_CRASH_DUMP_SECONDS = 0
+     * - do not write dump
+     * - do not set an alarm
+     * - break immediately
+     *
+     * ERL_CRASH_DUMP_SECONDS = 0
+     * - do not write dump
+     * - do not set an alarm
+     * - break immediately
+     *
+     * ERL_CRASH_DUMP_SECONDS < 0
+     * - do not set alarm
+     * - write dump until done
+     *
+     * ERL_CRASH_DUMP_SECONDS = S (and S positive)
+     * - Don't dump file forever
+     * - set alarm (set in sys)
+     * - write dump until alarm or file is written completely
+     */
+	
+    if (erts_sys_getenv__("ERL_CRASH_DUMP_SECONDS", env, &envsz) != 0) {
+	return; /* break immediately */
+    } else {
+	secs = atoi(env);
+    }
+
+    if (secs == 0) {
+	return;
+    }
+
+    erts_sys_prepare_crash_dump(secs);
 
-    if (erts_sys_getenv_raw("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
+    if (erts_sys_getenv__("ERL_CRASH_DUMP",&dumpnamebuf[0],&dumpnamebufsize) != 0)
 	dumpname = "erl_crash.dump";
     else
 	dumpname = &dumpnamebuf[0];
diff --git a/erts/emulator/beam/erl_process_lock.c b/erts/emulator/beam/erl_process_lock.c
index 7777ba1d3d..84a8270d06 100644
--- a/erts/emulator/beam/erl_process_lock.c
+++ b/erts/emulator/beam/erl_process_lock.c
@@ -1587,7 +1587,7 @@ erts_proc_lc_chk_no_proc_locks(char *file, int line)
 		  lc_id.proc_lock_msgq,
 		  lc_id.proc_lock_status};
     erts_lc_have_lock_ids(resv, ids, 4);
-    if (resv[0] || resv[1] || resv[2] || resv[3]) {
+    if (!ERTS_IS_CRASH_DUMPING && (resv[0] || resv[1] || resv[2] || resv[3])) {
 	erts_lc_fail("%s:%d: Thread has process locks locked when expected "
 		     "not to have any process locks locked",
 		     file, line);
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 1503d793ab..4c0d3421c8 100755
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -999,6 +999,9 @@ Uint erts_port_ioq_size(Port *pp);
 void erts_stale_drv_select(Eterm, ErlDrvEvent, int, int);
 void erts_port_cleanup(Port *);
 void erts_fire_port_monitor(Port *prt, Eterm ref);
+
+Port *erts_get_heart_port(void);
+
 #ifdef ERTS_SMP
 void erts_smp_xports_unlock(Port *);
 #endif
diff --git a/erts/emulator/beam/index.c b/erts/emulator/beam/index.c
index 25d5cce0f3..c981a0a55e 100644
--- a/erts/emulator/beam/index.c
+++ b/erts/emulator/beam/index.c
@@ -82,7 +82,8 @@ index_put_entry(IndexTable* t, void* tmpl)
     if (ix >= t->size) {
 	Uint sz;
 	if (ix >= t->limit) {
-	    erl_exit(1, "no more index entries in %s (max=%d)\n",
+	    /* A core dump is unnecessary */
+	    erl_exit(ERTS_DUMP_EXIT, "no more index entries in %s (max=%d)\n",
 		     t->htable.name, t->limit);
 	}
 	sz = INDEX_PAGE_SIZE*sizeof(IndexSlot*);
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index dec51f3be5..60b9238d38 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -1128,7 +1128,7 @@ int erts_write_to_port(Eterm caller_id, Port *p, Eterm list)
     Uint size;
     int fpe_was_unmasked;
     
-    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
+    ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p) || ERTS_IS_CRASH_DUMPING);
     ERTS_SMP_CHK_NO_PROC_LOCKS;
 
     p->caller = caller_id;
@@ -5258,3 +5258,27 @@ erl_drv_getenv(char *key, char *value, size_t *value_size)
 {
     return erts_sys_getenv_raw(key, value, value_size);
 }
+
+/* get heart_port
+ * used by erl_crash_dump
+ * - uses the fact that heart_port is registered when starting heart
+ */
+
+Port *erts_get_heart_port() {
+
+    Port* port;
+    Uint  ix;
+
+    for(ix = 0; ix < erts_max_ports; ix++) {
+	port = &erts_port[ix];
+	/* only examine undead or alive ports */
+	if (port->status & ERTS_PORT_SFLGS_DEAD)
+	    continue;
+	/* immediate atom compare */
+	if (port->reg && port->reg->name == am_heart_port) {
+	    return port;
+	}
+    }
+
+    return NULL;
+}
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index 0e6bec352e..8957bb5bde 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -644,7 +644,7 @@ void erts_sys_schedule_interrupt_timed(int set, erts_short_time_t msec);
 void erts_sys_main_thread(void);
 #endif
 
-extern void erts_sys_prepare_crash_dump(void);
+extern void erts_sys_prepare_crash_dump(int secs);
 extern void erts_sys_pre_init(void);
 extern void erl_sys_init(void);
 extern void erl_sys_args(int *argc, char **argv);
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 97756e8434..b485dbf784 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -58,7 +58,6 @@
 #define __DARWIN__ 1
 #endif
 
-
 #ifdef USE_THREADS
 #include "erl_threads.h"
 #endif
@@ -71,7 +70,6 @@ static erts_smp_rwmtx_t environ_rwmtx;
 #define MAX_VSIZE 16		/* Max number of entries allowed in an I/O
 				 * vector sock_sendv().
 				 */
-
 /*
  * Don't need global.h, but bif_table.h (included by bif.h),
  * won't compile otherwise
@@ -123,6 +121,15 @@ struct ErtsSysReportExit_ {
 #endif
 };
 
+/* This data is shared by these drivers - initialized by spawn_init() */
+static struct driver_data {
+    int port_num, ofd, packet_bytes;
+    ErtsSysReportExit *report_exit;
+    int pid;
+    int alive;
+    int status;
+} *driver_data;			/* indexed by fd */
+
 static ErtsSysReportExit *report_exit_list;
 #if CHLDWTHR && !defined(ERTS_SMP)
 static ErtsSysReportExit *report_exit_transit_list;
@@ -680,17 +687,40 @@ static RETSIGTYPE break_handler(int sig)
 #endif /* 0 */
 
 static ERTS_INLINE void
-prepare_crash_dump(void)
+prepare_crash_dump(int secs)
 {
+#define NUFBUF (3)
     int i, max;
     char env[21]; /* enough to hold any 64-bit integer */
     size_t envsz;
+    DeclareTmpHeapNoproc(heap,NUFBUF);
+    Port *heart_port;
+    Eterm *hp = heap;
+    Eterm list = NIL;
+    int heart_fd[2] = {-1,-1};
+
+    UseTmpHeapNoproc(NUFBUF);
 
     if (ERTS_PREPARED_CRASH_DUMP)
 	return; /* We have already been called */
 
+    heart_port = erts_get_heart_port();
+    if (heart_port) {
+	/* hearts input fd
+	 * We "know" drv_data is the in_fd since the port is started with read|write
+	 */
+	heart_fd[0] = (int)heart_port->drv_data;
+	heart_fd[1] = (int)driver_data[heart_fd[0]].ofd;
+
+	list = CONS(hp, make_small(8), list); hp += 2;
+
+	/* send to heart port, CMD = 8, i.e. prepare crash dump =o */
+	erts_write_to_port(ERTS_INVALID_PID, heart_port, list);
+    }
+
     /* Make sure we unregister at epmd (unknown fd) and get at least
        one free filedescriptor (for erl_crash.dump) */
+
     max = max_files;
     if (max < 1024)
 	max = 1024;
@@ -704,11 +734,15 @@ prepare_crash_dump(void)
 	if (i == async_fd[0] || i == async_fd[1])
 	    continue;
 #endif
+	/* We don't want to close our heart yet ... */
+	if (i == heart_fd[0] || i == heart_fd[1])
+	    continue;
+
 	close(i);
     }
 
     envsz = sizeof(env);
-    i = erts_sys_getenv_raw("ERL_CRASH_DUMP_NICE", env, &envsz);
+    i = erts_sys_getenv__("ERL_CRASH_DUMP_NICE", env, &envsz);
     if (i >= 0) {
 	int nice_val;
 	nice_val = i != 0 ? 0 : atoi(env);
@@ -717,21 +751,21 @@ prepare_crash_dump(void)
 	}
 	erts_silence_warn_unused_result(nice(nice_val));
     }
-    
-    envsz = sizeof(env);
-    i = erts_sys_getenv_raw("ERL_CRASH_DUMP_SECONDS", env, &envsz);
-    if (i >= 0) {
-	unsigned sec;
-	sec = (unsigned) i != 0 ? 0 : atoi(env);
-	alarm(sec);
-    }
 
+    /* Positive secs means an alarm must be set
+     * 0 or negative means no alarm
+     */
+    if (secs > 0) {
+	alarm((unsigned int)secs);
+    }
+    UnUseTmpHeapNoproc(NUFBUF);
+#undef NUFBUF
 }
 
 void
-erts_sys_prepare_crash_dump(void)
+erts_sys_prepare_crash_dump(int secs)
 {
-    prepare_crash_dump();
+    prepare_crash_dump(secs);
 }
 
 static ERTS_INLINE void
@@ -773,7 +807,7 @@ sigusr1_exit(void)
       is hung somewhere, so it won't be able to poll any flag we set here.
       */
     ERTS_SET_GOT_SIGUSR1;
-    prepare_crash_dump();
+    prepare_crash_dump((int)0);
     erl_exit(1, "Received SIGUSR1\n");
 }
 
@@ -1021,15 +1055,6 @@ void fini_getenv_state(GETENV_STATE *state)
 
 #define ERTS_SYS_READ_BUF_SZ (64*1024)
 
-/* This data is shared by these drivers - initialized by spawn_init() */
-static struct driver_data {
-    int port_num, ofd, packet_bytes;
-    ErtsSysReportExit *report_exit;
-    int pid;
-    int alive;
-    int status;
-} *driver_data;			/* indexed by fd */
-
 /* Driver interfaces */
 static ErlDrvData spawn_start(ErlDrvPort, char*, SysDriverOpts*);
 static ErlDrvData fd_start(ErlDrvPort, char*, SysDriverOpts*);
@@ -2419,6 +2444,15 @@ erts_sys_getenv_raw(char *key, char *value, size_t *size) {
     return erts_sys_getenv(key, value, size);
 }
 
+/*
+ * erts_sys_getenv
+ * returns:
+ *  -1, if environment key is not set with a value
+ *   0, if environment key is set and value fits into buffer size
+ *   1, if environment key is set but does not fit into buffer size
+ *      size is set with the needed buffer size value
+ */
+
 int
 erts_sys_getenv(char *key, char *value, size_t *size)
 {
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index 6c69fecbf3..47d12ed5fe 100755
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -256,10 +256,25 @@ void erl_sys_args(int* argc, char** argv)
 }
 
 void
-erts_sys_prepare_crash_dump(void)
+erts_sys_prepare_crash_dump(int secs)
 {
+    Port *heart_port;
+    Eterm heap[3];
+    Eterm *hp = heap;
+    Eterm list = NIL;
+
+    heart_port = erts_get_heart_port();
+
+    if (heart_port) {
+
+	list = CONS(hp, make_small(8), list); hp += 2;
+
+	/* send to heart port, CMD = 8, i.e. prepare crash dump =o */
+	erts_write_to_port(NIL, heart_port, list);
+    }
+
     /* Windows - free file descriptors are hopefully available */
-    return;
+    /* Alarm not used on windows */
 }
 
 static void
diff --git a/erts/etc/common/heart.c b/erts/etc/common/heart.c
index 7b78cc489d..81d797dc7e 100644
--- a/erts/etc/common/heart.c
+++ b/erts/etc/common/heart.c
@@ -115,7 +115,8 @@
 #  endif
 #endif
 
-#define HEART_COMMAND_ENV    "HEART_COMMAND"
+#define HEART_COMMAND_ENV          "HEART_COMMAND"
+#define ERL_CRASH_DUMP_SECONDS_ENV "ERL_CRASH_DUMP_SECONDS"
 
 #define MSG_HDR_SIZE        2
 #define MSG_HDR_PLUS_OP_SIZE 3
@@ -131,13 +132,14 @@ struct msg {
 };
 
 /* operations */
-#define  HEART_ACK    1
-#define  HEART_BEAT   2
-#define  SHUT_DOWN    3
-#define  SET_CMD      4
-#define  CLEAR_CMD    5
-#define  GET_CMD      6
-#define  HEART_CMD    7
+#define  HEART_ACK       (1)
+#define  HEART_BEAT      (2)
+#define  SHUT_DOWN       (3)
+#define  SET_CMD         (4)
+#define  CLEAR_CMD       (5)
+#define  GET_CMD         (6)
+#define  HEART_CMD       (7)
+#define  PREPARING_CRASH (8)
 
 
 /*  Maybe interesting to change */
@@ -165,10 +167,11 @@ unsigned long heart_beat_kill_pid = 0;
 #define SOL_WD_TIMEOUT (heart_beat_timeout+heart_beat_boot_delay)
 
 /* reasons for reboot */
-#define  R_TIMEOUT          1
-#define  R_CLOSED           2
-#define  R_ERROR            3
-#define  R_SHUT_DOWN        4
+#define  R_TIMEOUT          (1)
+#define  R_CLOSED           (2)
+#define  R_ERROR            (3)
+#define  R_SHUT_DOWN        (4)
+#define  R_CRASHING         (5) /* Doing a crash dump and we will wait for it */
 
 
 /*  macros */
@@ -178,8 +181,8 @@ unsigned long heart_beat_kill_pid = 0;
 
 /*  prototypes */
 
-static int message_loop(int,int);
-static void do_terminate(int);
+static int message_loop(int, int);
+static void do_terminate(int, int);
 static int notify_ack(int);
 static int heart_cmd_reply(int, char *);
 static int write_message(int, struct msg *);
@@ -190,6 +193,7 @@ static void print_error(const char *,...);
 static void debugf(const char *,...);
 static void init_timestamp(void);
 static time_t timestamp(time_t *);
+static int  wait_until_close_write_or_env_tmo(int);
 
 #ifdef __WIN32__
 static BOOL enable_privilege(void);
@@ -328,12 +332,14 @@ static void get_arguments(int argc, char** argv) {
     debugf("arguments -ht %d -wt %d -pid %lu\n",h,w,p);
 }
 
-int
-main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
+
+    if (is_env_set("HEART_DEBUG")) {
+	fprintf(stderr, "heart: debug is ON!\r\n");
+	debug_on = 1;
+    }
+
     get_arguments(argc,argv);
-    if (is_env_set("HEART_DEBUG"))
-	debug_on=1;
 #ifdef __WIN32__
     if (debug_on) {
 	if(!is_env_set("ERLSRV_SERVICE_NAME")) {
@@ -354,7 +360,7 @@ main(int argc, char **argv)
     program_name[sizeof(program_name)-1] = '\0';
     notify_ack(erlout_fd);
     cmd[0] = '\0';
-    do_terminate(message_loop(erlin_fd,erlout_fd));
+    do_terminate(erlin_fd,message_loop(erlin_fd,erlout_fd));
     return 0;
 }
 
@@ -388,6 +394,7 @@ message_loop(erlin_fd, erlout_fd)
 #endif
 
   while (1) {
+      /* REFACTOR: below to select/tmo function */
 #ifdef __WIN32__
 	wresult = WaitForSingleObject(hevent_dataready,SELECT_TIMEOUT*1000+ 2);
 	if (wresult == WAIT_FAILED) {
@@ -482,6 +489,10 @@ message_loop(erlin_fd, erlout_fd)
 				    free_env_val(env);
 				}
 			        break;
+			case PREPARING_CRASH:
+				/* Erlang has reached a crushdump point (is crashing for sure) */
+				print_error("Erlang is crashing .. (waiting for crash dump file)");
+				return R_CRASHING;
 			default:
 				/* ignore all other messages */
 				break;
@@ -612,72 +623,130 @@ void win_system(char *command)
  * do_terminate
  */
 static void 
-do_terminate(reason)
-  int reason;
-{
+do_terminate(int erlin_fd, int reason) {
   /*
     When we get here, we have HEART_BEAT_BOOT_DELAY secs to finish
     (plus heart_beat_report_delay if under VxWorks), so we don't need
     to call wd_reset().
     */
-  
+  int ret = 0, tmo=0;
+  char *tmo_env;
+
   switch (reason) {
   case R_SHUT_DOWN:
     break;
+  case R_CRASHING:
+    if (is_env_set(ERL_CRASH_DUMP_SECONDS_ENV)) {
+	tmo_env = get_env(ERL_CRASH_DUMP_SECONDS_ENV);
+	tmo = atoi(tmo_env);
+	print_error("Waiting for dump - timeout set to %d seconds.", tmo);
+	wait_until_close_write_or_env_tmo(tmo);
+	free_env_val(tmo_env);
+    }
+    /* fall through */
   case R_TIMEOUT:
-  case R_ERROR:
   case R_CLOSED:
+  case R_ERROR:
   default:
-#if defined(__WIN32__)
     {
-      if(!cmd[0]) {
-	char *command = get_env(HEART_COMMAND_ENV);
-	if(!command)
-	  print_error("Would reboot. Terminating.");
-	else {
-	  kill_old_erlang();
-	  /* High prio combined with system() works badly indeed... */
-	  SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
-	  win_system(command);
-	  print_error("Executed \"%s\". Terminating.",command);
+#if defined(__WIN32__) /* Not VxWorks */
+	if(!cmd[0]) {
+	    char *command = get_env(HEART_COMMAND_ENV);
+	    if(!command)
+		print_error("Would reboot. Terminating.");
+	    else {
+		kill_old_erlang();
+		/* High prio combined with system() works badly indeed... */
+		SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
+		win_system(command);
+		print_error("Executed \"%s\". Terminating.",command);
+	    }
+	    free_env_val(command);
+	} else {
+	    kill_old_erlang();
+	    /* High prio combined with system() works badly indeed... */
+	    SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
+	    win_system(&cmd[0]);
+	    print_error("Executed \"%s\". Terminating.",cmd);
 	}
-	free_env_val(command);
-      }
-      else {
-	kill_old_erlang();
-	/* High prio combined with system() works badly indeed... */
-	SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
-	win_system(&cmd[0]);
-	print_error("Executed \"%s\". Terminating.",cmd);
-      }
-    }
-
 #else
-    {
-      if(!cmd[0]) {
-	char *command = get_env(HEART_COMMAND_ENV);
-	if(!command)
-	  print_error("Would reboot. Terminating.");
-	else {
-	  kill_old_erlang();
-	  /* suppress gcc warning with 'if' */
-	  if(system(command));
-	  print_error("Executed \"%s\". Terminating.",command);
+	if(!cmd[0]) {
+	    char *command = get_env(HEART_COMMAND_ENV);
+	    if(!command)
+		print_error("Would reboot. Terminating.");
+	    else {
+		kill_old_erlang();
+		/* suppress gcc warning with 'if' */
+		ret = system(command);
+		print_error("Executed \"%s\" -> %d. Terminating.",command, ret);
+	    }
+	    free_env_val(command);
+	} else {
+	    kill_old_erlang();
+	    /* suppress gcc warning with 'if' */
+	    ret = system((char*)&cmd[0]);
+	    print_error("Executed \"%s\" -> %d. Terminating.",cmd, ret);
 	}
-	free_env_val(command);
-      }
-      else {
-	kill_old_erlang();
-	/* suppress gcc warning with 'if' */
-	if(system((char*)&cmd[0]));
-	print_error("Executed \"%s\". Terminating.",cmd);
-      }
+#endif
     }
     break;
-#endif
   } /* switch(reason) */
 }
 
+
+/* Waits until something happens on socket or handle
+ *
+ * Uses global variables erlin_fd or hevent_dataready
+ */
+int wait_until_close_write_or_env_tmo(int tmo) {
+    int i = 0;
+
+#ifdef __WIN32__
+    DWORD wresult;
+    DWORD wtmo = INFINITE;
+
+    if (tmo >= 0) {
+	wtmo = tmo*1000 + 2;
+    }
+
+    wresult = WaitForSingleObject(hevent_dataready, wtmo);
+    if (wresult == WAIT_FAILED) {
+	print_last_error();
+	return -1;
+    }
+
+    if (wresult == WAIT_TIMEOUT) {
+	debugf("wait timed out\n");
+	i = 0;
+    } else {
+	debugf("wait ok\n");
+	i = 1;
+    }
+#else
+    fd_set read_fds;
+    int   max_fd;
+    struct timeval timeout;
+    struct timeval *tptr = NULL;
+
+    max_fd = erlin_fd; /* global */
+
+    if (tmo >= 0) {
+	timeout.tv_sec  = tmo;  /* On Linux timeout is modified by select */
+	timeout.tv_usec = 0;
+	tptr = &timeout;
+    }
+
+    FD_ZERO(&read_fds);
+    FD_SET(erlin_fd, &read_fds);
+    if ((i = select(max_fd + 1, &read_fds, NULLFDS, NULLFDS, tptr)) < 0) {
+	print_error("error in select.");
+	return -1;
+    }
+#endif
+    return i;
+}
+
+
 /*
  * notify_ack
  *
@@ -868,12 +937,13 @@ debugf(const char *format,...)
 {
   va_list args;
 
-  if (!debug_on) return;
-  va_start(args, format);
-  fprintf(stderr, "Heart: ");
-  vfprintf(stderr, format, args);
-  va_end(args);
-  fprintf(stderr, "\r\n");
+  if (debug_on) {
+      va_start(args, format);
+      fprintf(stderr, "Heart: ");
+      vfprintf(stderr, format, args);
+      va_end(args);
+      fprintf(stderr, "\r\n");
+  }
 }
 
 #ifdef __WIN32__