# HG changeset patch
# User Nathan Phillip Brink <ohnobinki@ohnopublishing.net>
# Date 2010-07-21 23:03:26
# Node ID 27eb6c6418f666fe243df1e40aace06a4801d06e
# Parent  eb391af42d628fd2ce153040004af0bd6fdac205

Handle resolving hostnames gracefully.
Fix support for hostname:port in remoteio.
Added timeout parameter to multiio_poll().
Fix stupid mistakes in distrenslave's read handler.
The server and client may not sit and play table tennis at last :-D.

diff --git a/src/common/multiio.c b/src/common/multiio.c
--- a/src/common/multiio.c
+++ b/src/common/multiio.c
@@ -174,14 +174,14 @@ int multiio_poll_invoke_handlers(struct 
   return TRUE;
 }
 
-int multiio_poll(multiio_context_t context)
+int multiio_poll(multiio_context_t context, int timeout)
 {
   size_t counter;
   struct multiio_poll_travinfo travinfo;
 
   int ret;
 
-  ret = poll(context->pollfds, context->nfds, -1);
+  ret = poll(context->pollfds, context->nfds, timeout);
   if(ret == -1)
     {
       perror("poll");
diff --git a/src/common/multiio.h b/src/common/multiio.h
--- a/src/common/multiio.h
+++ b/src/common/multiio.h
@@ -67,11 +67,15 @@ multiio_context_t multiio_context_new();
 int multiio_context_free(multiio_context_t context);
 
 /**
-   Call poll() on the registered sockets and react to events accordingly.
-
-   @param context the context which sockets and handlers were registered with
+ * Call poll() on the registered sockets and react to events accordingly.
+ *
+ * @param context the context which sockets and handlers were registered with
+ *
+ * @param timeout see poll(3p). The number of milliseconds to wait for
+ * a request before returning. 0 for immediate return if no activity
+ * and -1 for waiting until some activity happens before returning.
  */
-int multiio_poll(multiio_context_t context);
+int multiio_poll(multiio_context_t context, int timeout);
 
 /**
    Registers a new socket type/classification for use with this multiio_context.
diff --git a/src/common/protocol.c b/src/common/protocol.c
--- a/src/common/protocol.c
+++ b/src/common/protocol.c
@@ -76,12 +76,27 @@ int distren_request_new_fromdata(struct 
 {
   struct distren_request *newreq;
 
+#if 0
+  size_t counter;
+  uint32_t debugtmp;
+#endif
+
   if(len < sizeof(struct distren_request))
     return 1;
 
   if( ((struct distren_request *)data)->magic != DISTREN_REQUEST_MAGIC )
     {
-      fprintf(stderr, "packet doesn't match magic stuffs\n");
+      fprintf(stderr, "packet doesn't match magic stuffs");
+#if 0
+      fputs("\n\tmagic=`", stderr);
+      debugtmp = DISTREN_REQUEST_MAGIC;
+      for(counter = 0; counter < sizeof(uint32_t); counter ++)
+	putc(((char *)&debugtmp)[counter], stderr);
+      fputs("'\n\t`", stderr);
+      for(counter = 0; counter < sizeof(struct distren_request); counter ++)
+	putc(((char *)data)[counter], stderr);
+      fputs("'\n", stderr);
+#endif
       return 1;
     }
 
diff --git a/src/common/remoteio.c b/src/common/remoteio.c
--- a/src/common/remoteio.c
+++ b/src/common/remoteio.c
@@ -739,6 +739,8 @@ int _remoteio_tcp_open(struct remoteio *
   struct addrinfo addrinfo_hints;
   struct addrinfo *addrinfo_res;
 
+  static char *default_port = REMOTEIO_DEFAULT_PORT;
+
   /**
      only hostname should be free()-ed, not port,
      because both are from the same block of malloc()-ed
@@ -755,7 +757,7 @@ int _remoteio_tcp_open(struct remoteio *
       port ++;
     }
   else
-    port = REMOTEIO_DEFAULT_PORT;
+    port = default_port;
 
   memset(&addrinfo_hints, '\0', sizeof(struct addrinfo));
   addrinfo_hints.ai_family = AF_UNSPEC;
@@ -767,9 +769,13 @@ int _remoteio_tcp_open(struct remoteio *
 #endif
   addrinfo_hints.ai_socktype = SOCK_STREAM;
 
-  tmp = getaddrinfo(server->hostname, port, &addrinfo_hints, &addrinfo_res);
+  tmp = getaddrinfo(hostname, port, &addrinfo_hints, &addrinfo_res);
   if(tmp)
-    fprintf(stderr, "error resolving %s:%s: %s\n", server->hostname, port, gai_strerror(tmp));
+    {
+      fprintf(stderr, "error resolving %s:%s: %s\n", server->hostname, port, gai_strerror(tmp));
+      free(hostname);
+      return 1;
+    }
   fprintf(stderr, "connecting to %s[%s]:%s\n", server->hostname, addrinfo_res->ai_canonname, port);
 
   free(hostname);
diff --git a/src/common/request.c b/src/common/request.c
--- a/src/common/request.c
+++ b/src/common/request.c
@@ -28,7 +28,7 @@ int distren_request_free_with_data(struc
   return distren_request_free(req);
 }
 
-uint32_t distren_request_poing(struct distren_request **req, void **data, short is_ping, const void *poing_cookie, size_t poing_data_len)
+int distren_request_poing(struct distren_request **req, void **data, short is_ping, const void *poing_cookie, size_t poing_data_len)
 {
   enum distren_request_type type;
 
@@ -40,5 +40,5 @@ uint32_t distren_request_poing(struct di
   (*data) = malloc(poing_data_len);
   memcpy(*data, poing_cookie, poing_data_len);
 
-  return (uint32_t)poing_data_len;
+  return 0;
 }
diff --git a/src/server/distrend.c b/src/server/distrend.c
--- a/src/server/distrend.c
+++ b/src/server/distrend.c
@@ -187,7 +187,7 @@ int main(int argc, char *argv[])
     {
       int clientrequest = 0; /*< temporary example variable, will be replaced when we can handle messages */
 
-      multiio_poll(multiio);
+      multiio_poll(multiio, 15000);
 
       tabletennis_serve(general_info.config->listens->tabletennis);
 
@@ -579,7 +579,7 @@ int interactiveTest(int test, multiio_co
      case 5:
        while(1)
 	 {
-	   multiio_poll(multiio);
+	   multiio_poll(multiio, 15000);
 	   tabletennis_serve(geninfo->config->listens->tabletennis);
 	 }
        break;
diff --git a/src/server/listen.c b/src/server/listen.c
--- a/src/server/listen.c
+++ b/src/server/listen.c
@@ -61,11 +61,6 @@ int listen_handle_error(multiio_context_
 			int *port);
 
 /*** TO BE MOVED TO REMOTEIO */
-int listen_handle_read(multiio_context_t multiio,
-		       int fd,
-		       short revent,
-		       struct distrend_listens *listens,
-		       struct distrend_client *client);
 int listen_handle_existence(multiio_context_t multiio,
 			    int fd,
 			    short revent,
@@ -195,9 +190,6 @@ int listen_handle_error(multiio_context_
 }
 
 
-//int listen_handle_read(struct distrend_listens *listens,
-//			struct distrend_client *client)
-
 /**
  * an important thing to handle
  *
@@ -349,6 +341,9 @@ size_t distrend_listen_read_handle(struc
    struct distren_request *req;
    void *reqdata;
 
+   size_t used_len;
+
+   used_len = 0;
    /**
     * Manage input, etc.
     */
@@ -411,16 +406,17 @@ size_t distrend_listen_read_handle(struc
       memcpy(reqdata, ((void *)buf) + sizeof(struct distren_request), req->len);
 
       client->expectlen = 0;
+      used_len = sizeof(struct distren_request) + req->len;
 
       distrend_dispatch_request(listens, rem, client, req, reqdata);
       free(reqdata);
       distren_request_free(req);
 
       /* I actually just used recursion in non-LISP code! :-D */
-      return req->len + distrend_listen_read_handle(rem, listens, buf + req->len, len - req->len, client);
+      return used_len + distrend_listen_read_handle(rem, listens, buf + req->len, len - req->len, client);
     }
 
-  return 0;
+  return used_len;
 }
 
 /**
@@ -572,10 +568,10 @@ int _distrend_dispatch_request_trav(stru
 }
 
 /**
-   helper for listen_handle_read() which looks up the correct
+   helper for distrend_listen_read_handle() which looks up the correct
    request handler and handles handing the the request to the
    handler. :-p
- */
+*/
 int distrend_dispatch_request(struct distrend_listens *listens, struct remoteio *rem, struct distrend_client *client, struct distren_request *req, void *reqdata)
 {
   struct distrend_dispatch_request_data data;
@@ -589,4 +585,3 @@ int distrend_dispatch_request(struct dis
 
   return 0;
 }
-
diff --git a/src/server/slave.c b/src/server/slave.c
--- a/src/server/slave.c
+++ b/src/server/slave.c
@@ -230,7 +230,7 @@ int main(int argc, char *argv[])
   // Main loop
   while(!slave_state.quit)
     {
-      multiio_poll(multiio);
+      multiio_poll(multiio, 15000);
 
       if(slave_state.quit)
 	break;
@@ -393,6 +393,7 @@ static size_t distren_slave_remoteio_rea
   size_t to_return;
 
   size_t counter;
+  fprintf(stderr, "expected to eat %d bytes\n", len);
 
   /* to_return shall record how much of buf we've eaten already */
   to_return = 0;
@@ -433,14 +434,14 @@ static size_t distren_slave_remoteio_rea
       if(!slave_state->expectlen)
 	{
 	  if(len < sizeof(struct distren_request))
-	    return 0;
+	    return to_return;
 
 	  /* figure out how much we need to read in before we can get anywhere */
 	  if(distren_request_new_fromdata(&req, buf, len))
 	    {
 	      fprintf(stderr, "Failing to interpret data from server, exiting\n");
 	      slave_state->quit = 1;
-	      return 0;
+	      return to_return;
 	    }
 	  slave_state->expectlen = sizeof(struct distren_request) + req->len;
 	  distren_request_free(req);
@@ -465,8 +466,8 @@ static size_t distren_slave_remoteio_rea
 	      fprintf(stderr, "PONG ! :-D\n");
 
 	      distren_request_poing(&my_req, &my_req_data, 0, req_data, req->len);
-	      remoteio_write(slave_state->rem, &my_req, sizeof(struct distren_request));
-	      remoteio_write(slave_state->rem, &my_req_data, req->len);
+	      remoteio_write(slave_state->rem, my_req, sizeof(struct distren_request));
+	      remoteio_write(slave_state->rem, my_req_data, req->len);
 	      distren_request_free_with_data(my_req, my_req_data);
 	      break;
 
@@ -484,16 +485,17 @@ static size_t distren_slave_remoteio_rea
 	      break;
 	    }
 
+	  counter = req->len + sizeof(struct distren_request);
+
 	  distren_request_free(req);
 	  slave_state->expectlen = 0;
 
-	  counter = req->len + sizeof(struct distren_request);
-
 	  len -= counter;
 	  buf += counter;
 	  to_return += counter;
 	}
     }
 
+  fprintf(stderr, "ate %d bytes\n", to_return);
   return to_return;
 }
diff --git a/src/server/tabletennis.c b/src/server/tabletennis.c
--- a/src/server/tabletennis.c
+++ b/src/server/tabletennis.c
@@ -83,7 +83,6 @@ int tabletennis_serve(tabletennis_t tabl
 
   struct distren_request *req;
   void *req_data;
-  size_t req_len;
 
   clock_gettime(CLOCK_MONOTONIC, &time_now);
 
@@ -95,7 +94,7 @@ int tabletennis_serve(tabletennis_t tabl
       q_dequeue(tabletennis->clients_to_ping);
 
       /* use time_next_check as the ping data */
-      req_len = distren_request_poing(&req, &req_data, 1, &time_next_check, sizeof(time_next_check));
+      distren_request_poing(&req, &req_data, 1, &time_next_check, sizeof(time_next_check));
       distrend_client_write_request(client, req, req_data);
       distren_request_free_with_data(req, req_data);