}

       list_mvnext(listens->clients);

   *//* provide for termination of this loop *//*

       if(newclient == list_curr(listens->clients))

	 newclient = NULL;

       else

	 newclient = list_curr(listens->clients);

     }

					       */

   return 0;

 }

 /**

  * Handle read events from remoteio, remoteio_read_handle_func_t.

  *

  * This func requires that someone called remoteio_generic_data_set(remoteio_opts, listens);

  *

  * @param client the client associated with this remoteio instance.

  */

size_t distrend_listen_read_handle(struct remoteio *rem, struct distrend_listens *listens, void *buf, size_t len, struct distrend_client *client)

 {

   struct distren_request *req;

   void *reqdata;

   size_t used_len;

   used_len = 0;

   /**

    * Manage input, etc.

    */

   if(client->expectlen == 0)

     {

       /* search out header from input so far */

       if(len > sizeof(struct distren_request))

	 {

	   if(distren_request_new_fromdata(&req, buf, len))

	     {

	       fprintf(stderr, "Error handling data from client (magic likely did not match), closing connection\n");

	       /*

		* yes, this is safe and legal... because of hackishness

		* in remoteio_close() ;-)

		*/

	      remoteio_close(rem);

	      return 1;

	    }

	  client->expectlen = req->len + sizeof(struct distren_request);

	  distren_request_free(req);

	}

    }

  if(client->expectlen

     && len >= client->expectlen)

    {

      if(distren_request_new_fromdata(&req, buf, len))

	{

	  if(client->state == DISTREND_CLIENT_PREAUTH)

	    remoteio_close(rem);

	  else

	    distrend_send_disconnect(client, "Protocol error.");

	  return 1;

	}

      /*

       * this really shouldn't happen... reparsing the same data with

       * distren_request_new_fromdata() a second time shouldn't yeild

       * a different req->len than it did before.

       */

      if(len - sizeof(struct distren_request) < req->len)

	{

	  fprintf(stderr, "Unexpected error handling some data from client\n");

	  distren_request_free(req);

	  /* but we should pay homage to W3C if the impossible happens */

	  distrend_send_disconnect(client, "HTTP/1.1 503 Internal Server Error");

	  return 1;

	}

      reqdata = malloc(req->len);

      if(!reqdata)

	{

	  fprintf(stderr, "OOM\n");

	  distren_request_free(req);

	  return 1;

	}

      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 used_len;

}

/**

 * Handle cleaning up after remoteio_close() has been called. This includes cleaning up the struct distrend_client and stuffs

 */

void distrend_listen_remoteio_handle_close(struct distrend_listens *listens, struct distrend_client *client)

{

  /*

   * remoteio handles removing itself from multiio for us. We just

   * have to clean up tabletennis and the struct itself.

   */

  tabletennis_del_client(listens->tabletennis, client);

  free(client);

}

int distrend_listen_free(struct distrend_listens *listens)

{

  tabletennis_free(listens->tabletennis);

  fprintf(stderr, "%s:%d: I am a stub that needn't be implemented 'til later\n", __FILE__, __LINE__);

  return 1;

}

/**

   This is probably just NOT a placeholder for remotio

*/

void remotio_send_to_client(struct distrend_client *client, const char *msg, size_t len)

{

    fprintf(stderr, "%s:%d: STUB I should queue data for writing to a client.... or should I? :-p\n", __FILE__, __LINE__);

}

/**

 * Allocates and initializes a struct distrend_client.

 *

 *

 */

struct distrend_client *distrend_client_new(struct distrend_listens *listens, enum distrend_client_state state, struct remoteio *rem)

{

  struct distrend_client *client;

  client = malloc(sizeof(struct distrend_client));

  if(!client)

    {

      fprintf(stderr, "OOM\n");

      return NULL;

    }

  client->state = state;

  client->cleanup_time = time(NULL) + DISTREND_LISTEN_AUTHTIME;

  client->inlen = 0;

  client->expectlen = 0;

  client->rem = rem;

  return client;

}

int distrend_client_write_request(struct distrend_client *client, const struct distren_request *req, const void *data)

{

  char *towrite;

  int ret;

  size_t msglen;

  msglen = sizeof(struct distren_request) + req->len;

  towrite = malloc(msglen);

  if(!towrite)

    {

      fprintf(stderr, "OOM\n");

      return 1;

    }

  memcpy(towrite, req, sizeof(struct distren_request));

  memcpy(towrite + sizeof(struct distren_request), data, req->len);

  ret = remoteio_write(client->rem, towrite, msglen);

  free(towrite);

  return ret;

}

/*

int distrend_client_read(struct distrend_client *client, char **toread, size_t *lenread)

{

  struct distrend_packet *packet;

  *lenread = 0;

  *toread = NULL;

  if(q_empty(client->inmsgs))

    return 1;

  packet = q_dequeue(client->inmsgs);