Index: mtserve.scm
==================================================================
--- mtserve.scm
+++ mtserve.scm
@@ -264,12 +264,18 @@
 
 ;; ready? start the server
 ;;
 (if (args:get-arg "-server")
     (let ((mode (string->symbol (args:get-arg "-server"))))
-      (if (not (server:launch mode)) ;; opens the port, drops the pkt, contacts other servers and then waits for messages
-	  (exit 1))))
+      (print "Mode: " mode)
+      (case mode
+	((main)(print "Starting server in main mode."))
+	(else  (print "Starting server in hidden mode.")))
+       ;; opens the port, drops the pkt, contacts other servers and then waits for messages
+      (if (not (server:launch mode (lambda (pktrecvd)(print "Received: " pktrecvd))))
+	  (exit 1))
+      (set! *didsomething* #t)))
 
 (if (args:get-arg "-repl")
     (begin
       ;; user will have to start the server manually
       (print "Run: (server:start-nmsg 'main) to start the server")

Index: nmsg-transport.scm
==================================================================
--- nmsg-transport.scm
+++ nmsg-transport.scm
@@ -27,10 +27,11 @@
     nmsg-transport
     (
      nmsg:start-server
      nmsg:open-send-close
      nmsg:open-send-receive
+     nmsg:recv
      nmsg:close
      )
 
 (import scheme posix chicken data-structures ports)
 
@@ -83,34 +84,27 @@
        (thread-join! th1)
        res))))
 
 ;; default timeout is 3 seconds
 ;;
-(define (nmsg:open-send-receive host-port msg attrib #!key (timeout 3)(proc #f)) 
+(define (nmsg:open-send-receive host-port msg #!key (timeout 3)(proc #f)) 
   (let ((req  (nn-socket 'req))
         (uri  (conc "tcp://" host-port))
-        (res  #f)
-        (mode (alist-ref 'mode attrib))) 
+        (res  #f))
     (handle-exceptions
      exn
      (let ((emsg ((condition-property-accessor 'exn 'message) exn)))
-       ;; Send notification      
+       ;; take action on fail
        (if proc (proc exn emsg))
        #f)
      (nn-connect req uri)
-     (print "Connected to the server " )
      (nn-send req msg)
-     (print "Request Sent")  
-     ;; receive code here
-     ;;(print (nn-recv req))
      (let* ((th1  (make-thread (lambda ()
                                  (let ((resp (nn-recv req)))
                                    (nn-close req)
                                    (print resp)
-                                   (set! res (if (equal? resp "ok")
-                                                 #t
-                                                 #f))))
+                                   (set! res resp)))
                                "recv thread"))
             (th2 (make-thread (lambda ()
                                 (thread-sleep! timeout)
                                 (thread-terminate! th1))
                              "timer thread")))
@@ -117,9 +111,9 @@
        (thread-start! th1)
        (thread-start! th2)
        (thread-join! th1)
        res))))
 
-(define (nmsg:close conn)
-  (nn-close conn))
+(define nmsg:close nn-close)
+(define nmsg:recv  nn-recv)
 
 )

Index: server.scm
==================================================================
--- server.scm
+++ server.scm
@@ -75,19 +75,19 @@
   (mutex    (make-mutex))
   )
 
 ;; make it a global? Well, it is local to area module
 
-(define *area-conndat* (make-area))
+(define *area-info* (make-area))
 (define *pktspec*
   `((server (hostname . h)
 	    (port     . p)
 	    (pid      . i)
 	    )
     (data   (hostname . h)  ;; sender hostname
 	    (port     . p)  ;; sender port
-	    (ip       . i)  ;; sender ip
+	    (ip       . a)  ;; sender ip
 	    (hostkey  . k)  ;; sending host key - store info at server under this key
 	    (servkey  . s)  ;; server key - this needs to match at server end or reject the msg
 	    (format   . f)  ;; sb=serialized-base64, t=text, sx=sexpr, j=json
 	    (data     . d)  ;; base64 encoded slln data
 	    )))
@@ -105,18 +105,19 @@
 ;; there are two types of server
 ;;     main servers - dashboards, runners and dedicated servers - need pkt
 ;;     passive servers - test executers, step calls, list-runs - no pkt
 ;;
 (define (server:start-nmsg #!optional (force-server-type #f))
-  (mutex-lock! (area-mutex *area-conndat*))
+  (mutex-lock! (area-mutex *area-info*))
   (let* ((server-type  (or force-server-type
 			   (if (args:any? "-run" "-server")
 			       'main
 			       'passive)))
 	 (port-num     (portlogger:open-run-close portlogger:find-port))
+	 (best-ip      (server:get-my-best-address))
 	 (area-conn    (nmsg:start-server port-num))
-	 ;; (pktspec      (area-pktspec *area-conndat*))
+	 ;; (pktspec      (area-pktspec *area-info*))
 	 (mtdir        (or (server:get-mtrah)
 			   (begin
 			     (print "ERROR: megatest.config not found and MT_RUN_AREA_HOME is not set.")
 			     #f)))
 	 (pktdir       (conc mtdir
@@ -124,45 +125,48 @@
     (if (not mtdir)
 	#f
 	(begin
 	  (if  (not (directory? pktdir))(create-directory pktdir))
 	  ;; server is started, now create pkt if needed
+	  (print "Starting server in " server-type " mode")
 	  (if (eq? server-type 'main)
 	      (begin
-		(area-pktid-set! *area-conndat* 
+		(area-pktid-set! *area-info* 
 				 (write-alist->pkt
 				  pktdir 
 				  `((hostname . ,(get-host-name))
+				    (ip       . ,best-ip)
 				    (port     . ,port-num)
 				    (pid      . ,(current-process-id)))
 				  pktspec: *pktspec*
 				  ptype:   'server))
-		(area-pktfile-set! *area-conndat* (conc pktdir "/" (area-pktid *area-conndat*) ".pkt"))))
+		(area-pktfile-set! *area-info* (conc pktdir "/" (area-pktid *area-info*) ".pkt"))))
 	  ;; set all the area info in the 
-	  (area-pktsdir-set! *area-conndat* pktdir)
-	  (area-mtrah-set!   *area-conndat* mtdir)
-	  (area-conn-set!    *area-conndat* area-conn)
-	  (area-port-set!    *area-conndat* port-num)
-	  (mutex-unlock! (area-mutex *area-conndat*))
-	  #t))))
+	  (area-pktsdir-set! *area-info* pktdir)
+	  (area-mtrah-set!   *area-info* mtdir)
+	  (area-conn-set!    *area-info* area-conn)
+	  (area-port-set!    *area-info* port-num)
+	  (mutex-unlock! (area-mutex *area-info*))
+	  area-conn))))
 
 ;; Call this to start the actual server
 ;;
 ;; start_server
 ;;
 ;;   mode: '
 ;;   handler: proc which takes pktrecieved as argument
 ;;
-(define (server:launch mode handler)
+(define (server:launch mode proc)
   (let* ((start-time (current-seconds))
 	 (rep        (server:start-nmsg mode))
 	 (last-msg   (current-seconds))
 	 (th1        (make-thread
 		      (lambda ()
 			(let loop ()
-			  (let ((pktdat (nn-recv rep)))
+			  (let ((pktdat (nmsg:recv rep)))
 			    (set! last-msg (current-seconds))
+			    (print "received: " pktdat)
 			    (if (not (eof-object? pktdat))
 				(begin
 				  (proc pktdat)
 				  (loop))))))
 		      "message handler"))
@@ -175,16 +179,16 @@
 			       (print "Waited for 60 seconds and no messages, exiting now.")
 			       (exit))
 			     (loop)))))))
     (thread-start! th1)
     (thread-start! th2)
-    (thread-join th1)))
+    (thread-join! th1)))
 
 (define (server:shutdown)
-  (let ((conn (area-conn    *area-conndat*))
-	(pktf (area-pktfile *area-conndat*))
-	(port (area-port    *area-conndat*)))
+  (let ((conn (area-conn    *area-info*))
+	(pktf (area-pktfile *area-info*))
+	(port (area-port    *area-info*)))
     (if conn
 	(begin
 	  (if pktf (delete-file* pktf))
 	  (server:send-all "imshuttingdown")
 	  (nmsg:close conn)
@@ -211,44 +215,48 @@
 ;; srvpkt is the info for the server we wish to send the message to
 ;;
 (define (server:send servpkt data dtype)
   (let* ((port   (alist-ref 'port     servpkt))
 	 (host   (alist-ref 'hostname servpkt))
+	 (ip     (alist-ref 'ip       servpkt))
 	 (hkey   (alist-ref 'Z        servpkt))
-	 (addr   (conc host ":" port))
-	 (myport (area-port *area-conndat*))
-	 (myhost (area-myaddr *area-conndat*))
-	 (mykey  (area-pktid  *area-conndat*))
+	 (addr   (conc (or ip host) ":" port)) ;; fall back to host if ip not provided
+	 (myport (area-port *area-info*))
+	 (myhost (area-myaddr *area-info*))
+	 (mykey  (area-pktid  *area-info*))
 	 (msg    (alist->pkt `((hostname . ,myhost)
 			       (port     . ,myport)
 			       (servkey  . ,hkey)     ;; server looks at this to ensure message is for them
 			       (hostkey  . ,mykey)
 			       (format   . ,dtype)    ;; formating of the message
 			       (data     . ,data))
 			     *pktspec*)))
     (if (and port host)
-	(nmsg:open-send-receive addr msg)
+	(begin
+	  (print "sending " msg " to " addr)
+	  (nmsg:open-send-receive addr msg))
 	#f)))
 
 ;; is the server alive?
 ;;
 (define (server:ping servpkt)
   (let* ((start-time (current-milliseconds))
 	 (res        (server:send servpkt "ping" "t")))
-    (cons (- (current-milliseconds) 
-	     (equal? res "got ping")))))
+    (cons (- (current-milliseconds) start-time)
+	  (equal? res "got ping"))))
 
 ;; look up all pkts and get the server id (the hash), port, host/ip
-;; store this info in the global struct *area-conndat*
+;; store this info in the global struct *area-info*
 ;;
 (define (server:get-all)
   ;; readll all pkts
   ;; foreach pkt; if it isn't me ping the server; if alive, add to hosts hash, else rm the pkt
-  (let ((all-pkts (server:get-all-server-pkts *area-conn*)))
+  (let ((all-pkts (server:get-all-server-pkts *area-info*)))
     (for-each
      (lambda (servpkt)
-       (server:ping servpkt))
+       (let* ((res (server:ping servpkt)))
+	 (print "Got " res " from server " servpkt)))
      all-pkts)))
 
 ;; send out an "I'm about to exit notice to all known servers"
 ;;
 (define (server:imminent-death)