* Each queue shall be eaten as time passes and continue forever

	 * in circularity.

	 *

	 * data structures.

	 * fun.

	 * impossible to explain in text.

	 * easy to think up.

	 * impossible to determine the workings of existing ones.

	 * and... when you need them, screenshot utilities just aren't available :-/.

	 */

	distrend_send_disconnect(client, "Ping timeout :-p");

	break;

      case DISTREND_CLIENT_BAD:

	fprintf(stderr, __FILE__ ":%d: aaarrrrgh!\n :-D\n", __LINE__);

	break;

      default:

	break;

      }

  return 0;

}

struct distrend_accept_client_proc_data

{

  struct distrend_listens *listens;

  time_t current_time;

};

/**

 * Handle new connections.

 */

int listen_handle_accept(multiio_context_t multiio,

			 int fd,

			 short revent,

			 struct distrend_listens *listens,

			 int *port)

   //int distrend_accept(struct distrend_listens *listens)//, struct distrend_clientset *clients, distrend_handle_request_t handlereq, void *handlereqdata)

 {

   struct distrend_client *newclient;

   int newclientsock;

   struct remoteio *rem;

   struct distren_request *req;

   void *data;

   newclientsock = accept(fd, (struct sockaddr *)NULL, (socklen_t *)NULL);

   /* used to call int distrend_client_add(struct distrend_listens *listens, int sock, DISTREND_CLIENT_PREVERSION)*/

   newclient = distrend_client_new(listens, DISTREND_CLIENT_PREVERSION, NULL);

   if(remoteio_open_socket(&rem, listens->options->remoteio, (remoteio_read_handle_func_t)&distrend_listen_read_handle, newclient, (remoteio_close_handle_func_t)&distrend_listen_remoteio_handle_close, newclientsock))

     {

       fprintf(stderr, "error allocating/adding client struct\n");

       return 1;

     }

   newclient->rem = rem;

   fprintf(stderr, "accepted new connection; fd=%d\n", newclientsock);

   /* tabletennis */

   tabletennis_add_client(listens->tabletennis, newclient);

   /**

    * For those using netcat/telnet to debug their internets.

    */

 #ifndef PACKAGE_URL

 #define PACKAGE_URL "http://ohnopub.net/distren/"

 #endif

 #define DISTREN_GREETING PACKAGE_STRING " " PACKAGE_URL " : Nathan Phillip Brink && Ethan Michael Zonca\n"

   /* using sizeof() - 1 because the sizeof() includes a NULL byte we want to ignore. */

   remoteio_write(newclient->rem, DISTREN_GREETING, sizeof(DISTREN_GREETING) - 1);

   /* send a DISTREN_REQUEST_VERSION immediately as per protocol */

   distren_request_version(&req, &data,

			   DISTREN_SERVERTYPE_SUBMIT

			   | DISTREN_SERVERTYPE_DISTRIBUTE

			   | DISTREN_SERVERTYPE_RENDER,

			   PACKAGE_STRING);

   distren_request_send(rem, req, data);

   distren_request_free_with_data(req, data);

   /*

   list_mvfront(listens->clients);

   newclient = list_curr(listens->clients);

   while(newclient)

     {

       if(newclient->state == DISTREND_CLIENT_DEAD)

	 {

	   distrend_listen_poll_deletefd(listens, &newclient->sock);

	   distrend_client_free(newclient);

	   list_remove_curr(listens->clients);

	   fprintf(stderr, "removed dead connection\n");

	 }

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

  *lenread = packet->len;

  *toread = packet->data;

  free(packet);

  return 0;

}

*/

int distrend_send_disconnect(struct distrend_client *client, const char *quit_msg)

{

  struct distren_request *req;

  distren_request_new(&req, strlen(quit_msg), DISTREN_REQUEST_DISCONNECT);

  distrend_client_write_request(client, req, quit_msg);

  distren_request_free(req);

  client->state = DISTREND_CLIENT_BAD;

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

  return 0;

}

int distrend_listen_handler_add(struct distrend_listens *listens, enum distren_request_type type, distrend_handle_request_func_t handler)

{

  struct distrend_request_handler_info *handler_info;

  handler_info = malloc(sizeof(struct distrend_request_handler_info));

  if(!handler_info)

    return 1;

  handler_info->request_type = type;

  handler_info->handler = handler;

  list_insert_after(listens->request_handlers, handler_info, 0);

  return 0;

}

struct distrend_dispatch_request_data

{

  struct general_info *geninfo;

  struct distrend_client *client;

  struct distren_request *req;

  void *req_data;

};

/**

   traversal function for distrend_dispatch_request().

 */

int _distrend_dispatch_request_trav(struct distrend_dispatch_request_data *data, struct distrend_request_handler_info *handler_info)

{

  if(handler_info->request_type == data->req->type)

    (*handler_info->handler)(data->geninfo, data->client, data->req, data->req_data);

  return TRUE;

}

/**

   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;

  data.geninfo = listens->geninfo;

  data.client = client;

  data.req = req;

  data.req_data = reqdata;

  list_traverse(listens->request_handlers, &data, (list_traverse_func_t)&_distrend_dispatch_request_trav, LIST_FRNT | LIST_SAVE);

  return 0;

}