[GNUnet-SVN] r28438 - msh/src

[gnunet]

Author: harsha
Date: 2013-08-07 15:56:40 +0200 (Wed, 07 Aug 2013)
New Revision: 28438

Modified:
   msh/src/addressmap.c
   msh/src/addressmap.h
   msh/src/msh.c
   msh/src/mshd-server.c
   msh/src/mshd.c
   msh/src/mtypes.h
Log:
- altered protocol design; msh now connects to remote mshd directly.  For
    address lookup and authentication it relies on its parent mshd.


Modified: msh/src/addressmap.c
===================================================================
--- msh/src/addressmap.c        2013-08-07 12:10:06 UTC (rev 28437)
+++ msh/src/addressmap.c        2013-08-07 13:56:40 UTC (rev 28438)
@@ -77,13 +77,19 @@
 #define instance_address_ip(iaddr) \
   (NULL == iaddr ? 0 : ((uint32_t) iaddr->ip))
 
+
 /**
- * Get the port number from an instance address
+ * Function to return the port number of an instance address
+ *
+ * @param iaddr the instance address
+ * @return the port number
  */
-#define instance_address_port(iaddr) \
-  (iaddr->port)
+uint16_t
+instance_address_port (struct InstanceAddr *iaddr)
+{
+  return iaddr->port;
+}
 
-
 /**
  * Create an instance address structure from its port number and ip address
  *
@@ -606,7 +612,7 @@
   for (iaddr = iainfo->addr_head; NULL != iaddr; iaddr = iaddr->next)
   {
     if (GNUNET_SYSERR == 
-        GNUNET_CONTAINER_multihashmap32_put (rmap->map, (uint32_t) iaddr->ip, 
iainfo,
+        GNUNET_CONTAINER_multihashmap32_put (rmap->map, (uint32_t) iaddr->ip, 
iaddr,
                                              
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
     {
       GNUNET_break (0);
@@ -692,3 +698,19 @@
 {
   return GNUNET_CONTAINER_multihashmap32_contains (rmap->map, (uint32_t) ip);
 }
+
+
+/**
+ * Find the address through reverse IP mapping
+ *
+ * @param map the map
+ * @param ip the IP
+ * @return NULL if no value was found; note that this is indistinguishable from
+ *   values that just happen to be NULL; use "contains" to test for key-value
+ *   pairs with value NULL
+ */
+struct InstanceAddr *
+reversemap_lookup (struct ReverseAddressMap *rmap, in_addr_t ip)
+{
+  return GNUNET_CONTAINER_multihashmap32_get (rmap->map, (uint32_t) ip);
+}

Modified: msh/src/addressmap.h
===================================================================
--- msh/src/addressmap.h        2013-08-07 12:10:06 UTC (rev 28437)
+++ msh/src/addressmap.h        2013-08-07 13:56:40 UTC (rev 28438)
@@ -34,6 +34,16 @@
 
 
 /**
+ * Function to return the port number of an instance address
+ *
+ * @param iaddr the instance address
+ * @return the port number
+ */
+uint16_t
+instance_address_port (struct InstanceAddr *iaddr);
+
+
+/**
  * Create an instance address information object
  *
  * @param rank the MPI rank of the instance
@@ -278,6 +288,31 @@
 reverse_map_destroy (struct ReverseAddressMap *rmap);
 
 
+/**
+ * Check if the reverse address map contains a given IP addresses
+ *
+ * @param rmap the map
+ * @param ip the IP addresses
+ * @return GNUNET_YES if the given IP exists,
+ *         GNUNET_NO if not
+ */
+int
+reversemap_check (struct ReverseAddressMap *rmap, in_addr_t ip);
+
+
+/**
+ * Find the address through reverse IP mapping
+ *
+ * @param map the map
+ * @param ip the IP
+ * @return NULL if no value was found; note that this is indistinguishable from
+ *   values that just happen to be NULL; use "contains" to test for key-value
+ *   pairs with value NULL
+ */
+struct InstanceAddr *
+reversemap_lookup (struct ReverseAddressMap *rmap, in_addr_t ip);
+
+
 #endif  /* ADDRESSMAP_H_ */
 
 /* End of addressmap.h */

Modified: msh/src/msh.c
===================================================================
--- msh/src/msh.c       2013-08-07 12:10:06 UTC (rev 28437)
+++ msh/src/msh.c       2013-08-07 13:56:40 UTC (rev 28438)
@@ -8,7 +8,6 @@
 
 #include "common.h"
 #include <gnunet/gnunet_util_lib.h>
-#include "util.h"
 #include "mtypes.h"
 
 #define LOG(kind,...)                           \
@@ -19,6 +18,16 @@
 #define LOG_ERROR(...) LOG(GNUNET_ERROR_TYPE_ERROR, __VA_ARGS__)
 
 /**
+ * Configuration section for connection to local MSHD
+ */
+#define MSHD_LOCAL "MSHD-LOCAL"
+
+/**
+ * Configuration section for connection to remote MSHD
+ */
+#define MSHD_REMOTE "MSHD-REMOTE"
+
+/**
  * The message queue for sending messages to the controller service
  */
 struct MessageQueue
@@ -54,7 +63,13 @@
  */
 static struct GNUNET_CLIENT_Connection *client;
 
+
 /**
+ * Our connection to the parent MSHD
+ */
+static struct GNUNET_CLIENT_Connection *client_remote;
+
+/**
  * Handle for transmissions on conn
  */
 static struct GNUNET_CLIENT_TransmitHandle *th;
@@ -92,11 +107,16 @@
 struct GNUNET_CLIENT_TestHandle *test;
 
 /**
- * our configuration for accessing GNUnet's client API functions
+ * configuration for connecting to local MSHD through client API
  */
 struct GNUNET_CONFIGURATION_Handle *cfg;
 
 /**
+ * configuration for connecting to remote MSHD through client API
+ */
+struct GNUNET_CONFIGURATION_Handle *remote_cfg;
+
+/**
  * length of the cmdstr
  */
 static size_t cmdstr_len;
@@ -147,8 +167,33 @@
  */
 static in_addr_t target;
 
+/**
+ * The port number where the MSHD is listening on target host
+ */
+static uint16_t target_port;
 
+
 /**
+ * Function to convert an 32-bit IP address into numbers-and-dots notation
+ *
+ * @param ip the IP address
+ * @return the string represeting the IP address.  The string is statically 
allocated.
+ */
+char *
+ip2str (const in_addr_t ip)
+{
+  static char hostip[NI_MAXHOST];
+  
+  GNUNET_break (0 < snprintf (hostip, NI_MAXHOST, "%u.%u.%u.%u",
+                           ip >> 24, 
+                           (ip >> 16) % 256,
+                           (ip >> 8) % 256,
+                           ip % 256));
+  return hostip;
+}
+
+
+/**
  * Function to cleanup the message queue
  *
  * @param 
@@ -320,7 +365,6 @@
 forward_output (void *cls, const struct GNUNET_MessageHeader *msg_)
 {
   const struct MSH_MSG_CmdIO *msg;
-  int fd_stdout;
   uint16_t size;
 
   msg = (const struct MSH_MSG_CmdIO *) msg_;
@@ -331,11 +375,10 @@
     return;
   }
   size = ntohs (msg->header.size);  
-  fd_stdout = fileno (stdout);
-  GNUNET_assert (-1 < fd_stdout);
-  GNUNET_break (size == write (fd_stdout, msg->data,
-                               size - sizeof (struct MSH_MSG_CmdIO)));
-  GNUNET_CLIENT_receive (client, &forward_output, NULL,
+  GNUNET_break (size == 
+                GNUNET_DISK_file_write (fh_stdout, msg->data,
+                                        size - sizeof (struct MSH_MSG_CmdIO)));
+  GNUNET_CLIENT_receive (client_remote, &forward_output, NULL,
                          GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
@@ -348,26 +391,144 @@
  * @param msg message received, NULL on timeout or fatal error
  */
 static void
-delivery_status (void *cls, const struct GNUNET_MessageHeader *msg)
+challenge_status (void *cls, const struct GNUNET_MessageHeader *msg_)
 {
-  if (MSH_MTYPE_SERVER_RUNCMDSTATUS != ntohs (msg->type))
-  {
-    GNUNET_break (0);
-    GNUNET_SCHEDULER_shutdown ();
-    return;
-  }
+  LOG (GNUNET_ERROR_TYPE_INFO, "Executing remote command\n");
   fh_stdin = GNUNET_DISK_get_handle_from_native (stdin);
   fh_stdout = GNUNET_DISK_get_handle_from_native (stdout);
+  GNUNET_assert (NULL != fh_stdin);
+  GNUNET_assert (NULL != fh_stdout);
   state = STATE_FORWARD_STREAMS;
-  GNUNET_CLIENT_receive (client, &forward_output, NULL,
+  GNUNET_CLIENT_receive (client_remote, &forward_output, NULL,
                          GNUNET_TIME_UNIT_FOREVER_REL);
   task_fwd_stdin = 
       GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      fh_stdin, &fwd_stdin, NULL);
+                                      fh_stdin, &fwd_stdin, NULL);  
 }
 
 
 /**
+ * Type of a function to call when we receive a message
+ * from the service.
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+auth_challenge_response (void *cls, const struct GNUNET_MessageHeader *msg_)
+{
+  const struct MSH_MSG_ChallengeResponse *msg;
+
+  //msg = (const struct MSH_MSG_ChallengeResponse *) msg_;
+  GNUNET_CLIENT_transmit_and_get_response (client_remote,
+                                           msg_,
+                                           GNUNET_TIME_UNIT_MINUTES,
+                                           GNUNET_NO,
+                                           &challenge_status,
+                                           NULL);
+}
+
+
+/**
+ * Type of a function to call when we receive a message
+ * from the service.
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+auth_challenge (void *cls, const struct GNUNET_MessageHeader *msg_)
+{
+  if (MSH_MTYPE_CHALLENGE != ntohs (msg_->type))
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  if (sizeof (struct MSH_MSG_Challenge) >= ntohs (msg_->size))
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CLIENT_transmit_and_get_response (client,
+                                                          msg_,
+                                                          
GNUNET_TIME_UNIT_SECONDS,
+                                                          GNUNET_NO,
+                                                          
&auth_challenge_response,
+                                                          NULL));
+}
+
+
+static void
+target_connect ()
+{
+  struct MSH_MSG_RunCmd *msg;
+  uint16_t size;
+
+  remote_cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_CONFIGURATION_set_value_string (remote_cfg, MSHD_REMOTE, "LISTEN",
+                                         ip2str (target));
+  GNUNET_CONFIGURATION_set_value_number (remote_cfg, MSHD_REMOTE, "PORT",
+                                         target_port);
+  client_remote = GNUNET_CLIENT_connect (MSHD_REMOTE, remote_cfg);
+  if (NULL == client_remote)
+    return;
+  size = sizeof (struct MSH_MSG_RunCmd) + cmdstr_len;
+  msg = GNUNET_malloc (size);
+  msg->header.size = htons (size);
+  msg->header.type = htons (MSH_MTYPE_RUNCMD);
+  (void) memcpy (msg->cmd, cmdstr, cmdstr_len);
+  GNUNET_assert (GNUNET_OK == 
+                 GNUNET_CLIENT_transmit_and_get_response (client_remote,
+                                                          &msg->header,
+                                                          
GNUNET_TIME_UNIT_SECONDS,
+                                                          GNUNET_NO,
+                                                          &auth_challenge,
+                                                          NULL));
+  GNUNET_free (msg);
+}
+
+
+/**
+ * Type of a function to call when we receive a message
+ * from the service.
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+lookup_status (void *cls, const struct GNUNET_MessageHeader *msg_)
+{
+  const struct MSH_MSG_AddressLookupReply *msg;
+  uint16_t size;
+  if (MSH_MTYPE_ADDRESS_LOOKUP_REPLY != ntohs (msg_->type))
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  size = ntohs (msg_->size);
+  msg = (const struct MSH_MSG_AddressLookupReply *) msg_;
+  if (0 == (target_port = ntohs (msg->port)))
+  {
+    if ('\0' != msg->emsg[(size - sizeof (struct MSH_MSG_AddressLookup)) - 1])
+    {
+      GNUNET_break (0);
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    LOG_ERROR ("Address lookup for IP:%s failed with error: %s\n",
+               ip2str (target), msg->emsg);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  target_connect ();
+}
+
+
+/**
  * Function called with the result on the service test.
  *
  * @param cls closure
@@ -378,7 +539,7 @@
 static void
 result_cb (void *cls, int result)
 {
-  struct MSH_MSG_RunCmd *msg;
+  struct MSH_MSG_AddressLookup *msg;
   uint16_t size;
 
   test = NULL;
@@ -387,22 +548,21 @@
     LOG_ERROR ("Service not running\n");
     return;
   }
-  client = GNUNET_CLIENT_connect ("mshd", cfg);
+  client = GNUNET_CLIENT_connect (MSHD_LOCAL, cfg);
   GNUNET_assert (NULL != client);
   GNUNET_assert (0 != cmdstr_len);
-  size = sizeof (struct MSH_MSG_RunCmd) + cmdstr_len;
+  size = sizeof (struct MSH_MSG_AddressLookup);
   msg = GNUNET_malloc (size);
   msg->header.size = htons (size);
-  msg->header.type = htons (MSH_MTYPE_CLIENT_RUNCMD);
+  msg->header.type = htons (MSH_MTYPE_ADDRESS_LOOKUP);
   msg->ip = htonl ((uint32_t) target);
-  (void) memcpy (msg->cmd, cmdstr, cmdstr_len);
   GNUNET_assert (GNUNET_OK == 
                  GNUNET_CLIENT_transmit_and_get_response (client, &msg->header,
                                                           
GNUNET_TIME_UNIT_SECONDS,
                                                           GNUNET_NO,
-                                                          &delivery_status,
+                                                          &lookup_status,
                                                           NULL));
-
+  GNUNET_free (msg);
 }
 
 
@@ -455,13 +615,13 @@
     return;
   }
   cfg = GNUNET_CONFIGURATION_dup (cfg_);
-  GNUNET_CONFIGURATION_set_value_string (cfg, "MSHD", "UNIXPATH", psock_path);
+  GNUNET_CONFIGURATION_set_value_string (cfg, MSHD_LOCAL, "UNIXPATH", 
psock_path);
   if (NULL == client)
   {
     LOG_ERROR ("Cannot open connection to MSHD\n");
     return;
   }
-  test = GNUNET_CLIENT_service_test ("mshd", cfg, GNUNET_TIME_UNIT_SECONDS,
+  test = GNUNET_CLIENT_service_test (MSHD_LOCAL, cfg, GNUNET_TIME_UNIT_SECONDS,
                                      &result_cb, NULL);
 }
 

Modified: msh/src/mshd-server.c
===================================================================
--- msh/src/mshd-server.c       2013-08-07 12:10:06 UTC (rev 28437)
+++ msh/src/mshd-server.c       2013-08-07 13:56:40 UTC (rev 28438)
@@ -11,6 +11,9 @@
 #include "mshd.h"
 #include "addressmap.h"
 
+#define MESSAGE_SEND_TIMEOUT(s) \
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, s)
+
 /**
  * server handle for accepting requests from local MSH instances
  */
@@ -33,6 +36,161 @@
 
 
 /**
+ * Tranmission context
+ */
+struct TransmitCtx
+{
+  struct GNUNET_SERVER_Client *client;
+  
+  struct GNUNET_MessageHeader *msg;
+  
+};
+
+/**
+ * Context for connections requiring to execute commands
+ */
+struct ExecConnCtx
+{
+  /**
+   * the client handle
+   */
+  struct GNUNET_SERVER_Client *client;
+
+  /**
+   * The command strings to execute
+   */
+  char **args;
+
+  /**
+   * salt hash used for authentication
+   */
+  struct GNUNET_HashCode salt;
+
+  /**
+   * timeout task
+   */
+  GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+  /**
+   * the file descriptor associated with the client connection
+   */
+  int conn_fd;
+};
+
+
+/**
+ * Function called to notify a client about the connection
+ * begin ready to queue more data.  "buf" will be
+ * NULL and "size" zero if the connection was closed for
+ * writing in the meantime.
+ *
+ * @param cls closure
+ * @param size number of bytes available in buf
+ * @param buf where the callee should write the message
+ * @return number of bytes written to buf
+ */
+static size_t 
+transmit_ready_cb (void *cls, size_t size, void *buf)
+{
+  struct TransmitCtx *ctx = cls;
+  struct GNUNET_SERVER_Client *client = ctx->client;
+  struct GNUNET_MessageHeader *msg = ctx->msg;
+  size_t wrote;
+
+  wrote = 0;
+  if ((0 == size) || (NULL == buf))
+    goto cleanup;
+  wrote = ntohs (msg->size);
+  GNUNET_assert (size >= wrote);
+  (void) memcpy (buf, msg, wrote);
+  
+ cleanup:
+  GNUNET_free (msg);
+  GNUNET_SERVER_client_drop (client);
+  GNUNET_SERVER_receive_done (client, GNUNET_YES);
+  return wrote;
+}
+
+
+static void
+send_message (struct GNUNET_SERVER_Client *client,
+              struct GNUNET_MessageHeader *msg)
+{
+  struct TransmitCtx *ctx;
+
+  GNUNET_SERVER_client_keep (client);
+  ctx = GNUNET_malloc (sizeof (struct TransmitCtx));
+  ctx->client = client;
+  ctx->msg = msg;
+  (void) GNUNET_SERVER_notify_transmit_ready (client, ntohs (msg->size),
+                                              MESSAGE_SEND_TIMEOUT (30),
+                                              &transmit_ready_cb, ctx);
+
+}
+
+
+static int
+parse_strings (const char *buf, size_t size, char ***s)
+{
+  size_t off;
+  unsigned int cnt;
+  const char *p;
+
+  cnt = 0;
+  p = NULL;
+  for (off = 0; off < size; off++)
+  {
+    if ('\0' == buf[off])
+    {
+      if (NULL == p)
+        continue;
+      GNUNET_array_append (*s, cnt, GNUNET_strdup (p));
+      p = NULL;
+      continue;
+    }
+    p = &buf[off];      
+  }
+  if (0 < cnt)
+    GNUNET_array_append (*s, cnt, NULL);
+  return cnt;
+}
+
+static struct GNUNET_MessageHeader *
+create_challenge_message (struct ExecConnCtx *ctx)
+{
+  struct MSH_MSG_Challenge *msg;
+  uint16_t size;
+
+  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_NONCE, &ctx->salt);
+  size = sizeof (struct MSH_MSG_Challenge);
+  msg = GNUNET_malloc (size);
+  msg->header.type = htons (MSH_MTYPE_CHALLENGE);
+  msg->header.size = htons (size);
+  GNUNET_CRYPTO_hash_to_enc (&ctx->salt, &msg->salt);
+  return &msg->header;
+}
+
+
+static void
+destroy_ctx (struct ExecConnCtx *ctx)
+{
+  unsigned int cnt;
+
+  if (NULL != ctx->client)
+    GNUNET_SERVER_client_drop (ctx->client);
+  if (NULL != ctx->args)
+  {
+    for (cnt = 0; NULL != ctx->args[cnt]; cnt++)
+      GNUNET_free (ctx->args[cnt]);
+    GNUNET_free (ctx->args);
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != ctx->timeout_task)
+    GNUNET_SCHEDULER_cancel (ctx->timeout_task);
+  GNUNET_free (ctx);
+}
+
+
+/**
  * Functions with this signature are called whenever a message is
  * received.
  *
@@ -41,38 +199,80 @@
  * @param message the actual message
  */
 static void
-handle_client_runcmd (void *cls,
-                      struct GNUNET_SERVER_Client *client,
-                      const struct GNUNET_MessageHeader* message)
+handle_runcmd (void *cls,
+               struct GNUNET_SERVER_Client *client,
+               const struct GNUNET_MessageHeader* message)
 {
-  struct MSH_MSG_RunCmdStatus *reply;
+  struct ExecConnCtx *ctx;
   const struct MSH_MSG_RunCmd *msg;
-  const struct MSH_MSG_RunCmd *forward;
-  const char *emsg;
-  in_addr_t ip;
+  struct GNUNET_MessageHeader *reply;
   uint16_t size;
-  uint16_t emsg_len;
   
+  ctx = GNUNET_SERVER_client_get_user_context (client, struct ExecConnCtx);
+  size = ntohs (message->size);
+  if ( size <= sizeof (struct MSH_MSG_RunCmd))
+    goto close_conn;
+  msg = (const struct MSH_MSG_RunCmd *) message;
+  if (0 == parse_strings (msg->cmd,
+                          size - sizeof (struct MSH_MSG_RunCmd),
+                          &ctx->args))
+    goto close_conn;
+  reply = create_challenge_message (ctx);
+  send_message (client, reply);
+  return;
+
+ close_conn:
+  GNUNET_break_op (0);
+  destroy_ctx (ctx);
+  GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+}
+
+
+/**
+ * Functions with this signature are called whenever a message is
+ * received.
+ *
+ * @param cls closure
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_addresslookup (void *cls, struct GNUNET_SERVER_Client *client,
+                      const struct GNUNET_MessageHeader* message)
+{
+  const struct MSH_MSG_AddressLookup *msg;
+  struct MSH_MSG_AddressLookupReply *reply;
+  struct TransmitCtx *ctx;
+  struct InstanceAddr *iaddr;
+  char *emsg;
+  in_addr_t ip;
+  uint16_t port;
+  uint16_t reply_size;
+
   emsg = NULL;
-  msg = (const struct MSH_MSG_RunCmd *) message;
-  ip = (in_addr_t) ntohl (msg->ip);
+  port = 0;
+  msg = (const struct MSH_MSG_AddressLookup *) message;
+  ip = ntohl (msg->ip);
   if (GNUNET_NO == reversemap_check (rmap, ip))
   {
     emsg = "Given IP address not present in the current mapping\n";
     goto respond;
   }
-  forward = (struct MSH_MSG_RunCmd *) GNUNET_copy_message (message);
-  /* FIXME: forward message to the responsible MSHD */
-  
-  
+  iaddr = reversemap_lookup (rmap, ip);
+  GNUNET_assert (NULL != iaddr);
+  port = instance_address_port (iaddr);
+
  respond:
-  emsg_len = (NULL == emsg) ? 0 : strlen (emsg);
-  size = sizeof (struct MSH_MSG_RunCmdStatus) + emsg_len;
-  reply = GNUNET_malloc (size);
-  reply->header.type = htons (MSH_MTYPE_SERVER_RUNCMDSTATUS);
-  reply->header.size = htons (size);
+  reply_size = sizeof (struct MSH_MSG_AddressLookupReply);
   if (NULL != emsg)
-    (void) memcpy (reply->emsg, emsg, emsg_len);
+    reply_size += strlen (emsg) + 1;
+  reply = GNUNET_malloc (reply_size);
+  reply->header.size = htons (reply_size);
+  reply->header.type = htons (MSH_MTYPE_ADDRESS_LOOKUP_REPLY);
+  reply->port = htons (port);
+  if (NULL != emsg)
+    (void) strcpy (reply->emsg, emsg);
+  send_message (client, &reply->header);
 }
 
 
@@ -85,15 +285,26 @@
  * @param message the actual message
  */
 static void
-handle_client_cmd_stream_stdin (void *cls,
-                                struct GNUNET_SERVER_Client *client,
-                                const struct GNUNET_MessageHeader* message)
+handle_auth_challenge (void *cls, struct GNUNET_SERVER_Client *client,
+                       const struct GNUNET_MessageHeader* message)
 {
-  const struct MSH_MSG_CmdIO *msg;
+  const struct MSH_MSG_Challenge *msg;
+  struct MSH_MSG_ChallengeResponse *reply;
+  struct GNUNET_HashCode salt;
+  struct GNUNET_HashCode xor;
 
-  msg = (const struct MSH_MSG_CmdIO *) message;
-  /* FIXME: forward message to the responsible MSHD */
-  GNUNET_break (0);
+  msg = (const struct MSH_MSG_Challenge *) message;
+  GNUNET_assert (GNUNET_OK == 
+                 GNUNET_CRYPTO_hash_from_string2 (msg->salt.encoding,
+                                                  sizeof (msg->salt),
+                                                  &salt));
+  GNUNET_CRYPTO_hash_xor (&salt, &shash, &xor);
+  GNUNET_CRYPTO_hash (&xor, sizeof (struct GNUNET_HashCode), &salt);
+  reply = GNUNET_malloc (sizeof (struct MSH_MSG_ChallengeResponse));
+  reply->header.size = htons (sizeof (struct MSH_MSG_ChallengeResponse));
+  reply->header.type = htons (MSH_MTYPE_CHALLENGE_RESPONSE);
+  GNUNET_CRYPTO_hash_to_enc (&salt, &reply->auth);
+  send_message (client, &reply->header);
 }
 
 
@@ -123,8 +334,9 @@
 {
   struct sockaddr_un saddr;
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
-    {&handle_client_runcmd, NULL, MSH_MTYPE_CLIENT_RUNCMD, 0},
-    {&handle_client_cmd_stream_stdin, NULL, MSH_MTYPE_CMD_STREAM_STDIN, 0},
+    {&handle_addresslookup, NULL, MSH_MTYPE_ADDRESS_LOOKUP, sizeof (struct
+    MSH_MSG_AddressLookup)},
+    {&handle_auth_challenge, NULL, MSH_MTYPE_CHALLENGE, sizeof (struct 
MSH_MSG_Challenge)},
     {NULL, NULL, 0, 0}
   };
   struct sockaddr *saddrs[] = {
@@ -187,24 +399,51 @@
  * @param h the network handle of the socket to listen for incoming connections
  */
 int
-init_daemon_server (struct GNUNET_NETWORK_Handle *h)
+init_daemon_server ()
 {
-  static struct GNUNET_NETWORK_Handle *lsocks[] = {
-    NULL,
-    NULL
+  static const struct GNUNET_SERVER_MessageHandler handlers[] = {
+    {&handle_runcmd, NULL, MSH_MTYPE_RUNCMD, 0},
+    {NULL, NULL, 0, 0}
   };
   
-  lsocks[0] = h;
-  daemon_serv = GNUNET_SERVER_create_with_sockets (&check_remote_access,
+  daemon_serv = GNUNET_SERVER_create_with_sockets (NULL,
                                                    NULL,
-                                                   lsocks,
+                                                   NULL,
                                                    
GNUNET_TIME_UNIT_FOREVER_REL,
                                                    GNUNET_YES);
-  return (NULL == daemon_serv) ? GNUNET_SYSERR: GNUNET_OK;
+  if (NULL == daemon_serv) 
+    return GNUNET_SYSERR;
+  GNUNET_SERVER_add_handlers (daemon_serv, handlers);
+  return GNUNET_OK;
 }
 
 
+static void
+timeout_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct ExecConnCtx *ctx = cls;
+
+  ctx->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  destroy_ctx (ctx);
+}
+
+
 void
+daemon_server_add_connection (struct GNUNET_CONNECTION_Handle *conn, 
+                              int conn_fd)
+{
+  struct ExecConnCtx *ctx;
+
+  ctx = GNUNET_malloc (sizeof (struct ExecConnCtx));
+  ctx->conn_fd = conn_fd;
+  ctx->client = GNUNET_SERVER_connect_socket (daemon_serv, conn);
+  GNUNET_SERVER_client_set_user_context (ctx->client, ctx);
+  ctx->timeout_task = 
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &timeout_cb, 
ctx);
+}
+
+
+void
 shutdown_daemon_server ()
 {
   GNUNET_SERVER_destroy (daemon_serv);

Modified: msh/src/mshd.c
===================================================================
--- msh/src/mshd.c      2013-08-07 12:10:06 UTC (rev 28437)
+++ msh/src/mshd.c      2013-08-07 13:56:40 UTC (rev 28438)
@@ -123,7 +123,7 @@
    * In this mode the listen socket accepts requests for starting remote 
processes
    */
   LISTEN_MODE_SERV
-};
+} listen_mode;;
 
 
 /**
@@ -339,22 +339,43 @@
     GNUNET_break (0);
     goto clo_ret;
   }
-  LOG_DEBUG ("%d: Got a connect\n", rank);
-  conn = GNUNET_CONNECTION_create_from_accept (NULL, NULL, listen_socket);
-  if (NULL == conn)
+  switch (listen_mode)
   {
-    GNUNET_break (0);
-    goto clo_ret;
+  case LISTEN_MODE_PROBE:
+    LOG_DEBUG ("%d: Got a probe connect\n", rank);
+    conn = GNUNET_CONNECTION_create_from_accept (NULL, NULL, listen_socket);
+    if (NULL == conn)
+    {
+      GNUNET_break (0);
+      goto clo_ret;
+    }
+    rctx = GNUNET_malloc (sizeof (struct ReadContext));
+    rctx->conn = conn;
+    rctx->in_receive = GNUNET_YES;
+    GNUNET_CONNECTION_receive (rctx->conn, sizeof (unsigned int),
+                               GNUNET_TIME_UNIT_FOREVER_REL, conn_reader, 
rctx);
+    GNUNET_CONTAINER_DLL_insert_tail (rhead, rtail, rctx);
+    /* resume accepting connections on the listen sock */
+    atask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                           listen_socket, &accept_task, NULL);
+    break;
+  case LISTEN_MODE_SERV:
+    {
+      struct GNUNET_NETWORK_Handle *client_sock;
+      struct GNUNET_CONNECTION_Handle *client_conn;
+      int client_sock_fd;
+      
+      LOG_DEBUG ("Got a command execution connection\n");
+      client_sock = GNUNET_NETWORK_socket_accept (listen_socket, NULL, NULL);
+      client_sock_fd = GNUNET_NETWORK_get_fd (client_sock);
+      client_conn = GNUNET_CONNECTION_create_from_existing (client_sock);
+      daemon_server_add_connection (client_conn);
+      GNUNET_break (0);
+    }
+    break;
+  default:
+    GNUNET_assert (0);
   }
-  rctx = GNUNET_malloc (sizeof (struct ReadContext));
-  rctx->conn = conn;
-  rctx->in_receive = GNUNET_YES;
-  GNUNET_CONNECTION_receive (rctx->conn, sizeof (unsigned int),
-                             GNUNET_TIME_UNIT_FOREVER_REL, conn_reader, rctx);
-  GNUNET_CONTAINER_DLL_insert_tail (rhead, rtail, rctx);
-  /* resume accepting connections on the listen sock */
-  atask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                         listen_socket, &accept_task, NULL);
   return;
 
  clo_ret:
@@ -393,7 +414,11 @@
   LOG_DEBUG ("Verification phase complete; commencing reduction phase\n");
   GNUNET_break (GNUNET_OK == reduce_ntree ());
   addressmap_print (addrmap);
+  listen_mode = LISTEN_MODE_SERV;
   rmap = addressmap_create_reverse_mapping (addrmap);
+  init_local_server ();
+  init_daemon_server (listen_socket);
+  listen_socket = NULL;
   if (0 == rank)
   {
     const char *unixpath = "/tmp/mshd.sock";

Modified: msh/src/mtypes.h
===================================================================
--- msh/src/mtypes.h    2013-08-07 12:10:06 UTC (rev 28437)
+++ msh/src/mtypes.h    2013-08-07 13:56:40 UTC (rev 28438)
@@ -106,31 +106,33 @@
 /* MSH Daemon and MSH command line tool communication messsages */
 /****************************************************************/
 
-#define MSH_MTYPE_CLIENT_RUNCMD 200
+#define MSH_MTYPE_RUNCMD 200
 
-#define MSH_MTYPE_SERVER_RUNCMDSTATUS 201
+#define MSH_MTYPE_RUNCMDSTATUS 201
 
 #define MSH_MTYPE_CMD_STREAM_STDIN 202
 
 #define MSH_MTYPE_CMD_STREAM_STDOUT 203
 
+#define MSH_MTYPE_ADDRESS_LOOKUP 204
 
+#define MSH_MTYPE_ADDRESS_LOOKUP_REPLY 205
+
+#define MSH_MTYPE_CHALLENGE 206
+
+#define MSH_MTYPE_CHALLENGE_RESPONSE 207
+
 /**
  * Message for sending a remote command and its arguments to MSHD
  */
 struct MSH_MSG_RunCmd
 {
   /**
-   * header
+   * header; set type to MSH_MTYPE_RUNCMD
    */
   struct GNUNET_MessageHeader header;
 
   /**
-   * The IP of the remote host
-   */
-  uint32_t ip;
-
-  /**
    * The command and all its arguments to be followed.  Each string is to be
    * NULL-terminated.
    */
@@ -144,7 +146,7 @@
 struct MSH_MSG_RunCmdStatus
 {
   /**
-   * header
+   * header; set type to MSH_MTYPE_RUNCMDSTATUS
    */
   struct GNUNET_MessageHeader header;
   
@@ -174,4 +176,67 @@
 };
 
 
+struct MSH_MSG_AddressLookup
+{
+  /**
+   * header; set type to MSH_MTYPE_ADDRESS_LOOKUP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * The IP address to lookup
+   */
+  uint32_t ip;
+
+};
+
+
+struct MSH_MSG_AddressLookupReply
+{
+  /**
+   * header; set type to MSH_MTYPE_ADDRESS_LOOKUP_REPLY
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * the port number.  Will be set to 0 upon lookup failure
+   */
+  uint16_t port;
+
+  /**
+   * If the lookup failed, it will contain the related NULL-terminated error
+   * message
+   */
+  char emsg[0];  
+};
+
+
+struct MSH_MSG_Challenge
+{
+  /**
+   * header; set type to MSH_MTYPE_CHALLENGE
+   */
+  struct GNUNET_MessageHeader header;
+  
+  /**
+   * ascii encoded salt value to follow (0-terminated)
+   */
+  struct GNUNET_CRYPTO_HashAsciiEncoded salt;
+};
+
+
+struct MSH_MSG_ChallengeResponse
+{
+  /**
+   * header; set type to MSH_MTYPE_CHALLENGE_RESPONSE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * ascii encoded auth hash
+   */
+  struct GNUNET_CRYPTO_HashAsciiEncoded auth;
+};
+
+
 #endif  /* MTYPES_H_ */