/*

  Copyright 2010 Nathan Phillip Brink

  This file is a part of DistRen.

  DistRen is free software: you can redistribute it and/or modify

  it under the terms of the GNU Affero General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  DistRen is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License

  along with DistRen.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "libremoteio.h"

#include "execio.h"

#include "asprintf.h"

#include <list.h>

#include <errno.h>

#ifndef _WIN32

#include <netdb.h>

#endif

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/types.h>

#ifdef _WIN32

#include <winsock2.h>

#include <ws2tcpip.h>

#else

#include <sys/socket.h>

#endif

#include <unistd.h>

#ifndef _WIN32

#include <sys/un.h>

#endif

/* local */

#define REMOTEIO_DEFAULT_PORT "4050"

int _remoteio_ssh_open(struct remoteio *rem, struct remoteio_server *server);

int _remoteio_ssh_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);

int _remoteio_ssh_write(struct remoteio *rem, void *buf, size_t len, size_t *byteswritten);

int _remoteio_ssh_close(struct remoteio *rem);

#ifndef _WIN32

int _remoteio_sock_open(struct remoteio *rem, struct remoteio_server *server);

int _remoteio_sock_close(struct remoteio *rem);

#endif

int _remoteio_sock_read(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);

int _remoteio_sock_write(struct remoteio *rem, void *buf, size_t len, size_t *byteswritten);

int _remoteio_tcp_open(struct remoteio *rem, struct remoteio_server *server);

int _remoteio_tcp_close(struct remoteio *rem);

/**

  lookup table for different methods of remoteio:

  the enum remoteio_method is the index of the entry to use for that method. 

  Regardless, a NULL terminator is required because the configuration function

  searches through this table for the method specified in the config file.

*/

struct remoteio_method_funcmap funcmap[] = 

  {

    /* [REMOTEIO_METHOD_SSH] */

    {REMOTEIO_METHOD_SSH, &_remoteio_ssh_open, &_remoteio_ssh_read, &_remoteio_ssh_write, &_remoteio_ssh_close, "ssh"},

#ifndef _WIN32

    {REMOTEIO_METHOD_UNIX, &_remoteio_sock_open, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_sock_close, "unix"},

#endif

    {REMOTEIO_METHOD_TCP, &_remoteio_tcp_open, &_remoteio_sock_read, &_remoteio_sock_write, &_remoteio_tcp_close, "tcp"},

    {REMOTEIO_METHOD_MAX, NULL, NULL, NULL, NULL, NULL}

  };

struct remoteio_server *remoteio_getserver(const struct remoteio_opts *opts, const char *servername);

int remoteio_config(cfg_t *cfg, struct remoteio_opts *opts)

{

  size_t numservers;

  size_t counter, counter2;

  static int haslisted_methods = 0;

  struct remoteio_server aserver;

  opts->servers = list_init();

  if(!opts->servers)

    {

      fprintf(stderr, "@todo cleanup!\n");

      abort();

    }

  numservers = cfg_size(cfg, "server");

  for(counter = 0; counter < numservers; counter ++)

    {

      cfg_t *cfg_aserver;

      char *method;

      cfg_aserver = cfg_getnsec(cfg, "server", counter);

      aserver.name = strdup(cfg_title(cfg_aserver));

      aserver.hostname = strdup(cfg_getstr(cfg_aserver, "hostname"));

      aserver.username = strdup(cfg_getstr(cfg_aserver, "username"));

      aserver.method = REMOTEIO_METHOD_MAX;

      method = cfg_getstr(cfg_aserver, "method");

      for(counter2 = 0; funcmap[counter2].name; counter2 ++)

	if(strcmp(method, funcmap[counter2].name) == 0)

	  aserver.method = funcmap[counter2].method;

      if(aserver.method == REMOTEIO_METHOD_MAX)

	{

	  fprintf(stderr, "No such method as %s\n", method);

	  if(!haslisted_methods)

	    {

	      fprintf(stderr, "Available methods:\n");

	      for(counter2 = 0; funcmap[counter2].name; counter2 ++)

		fprintf(stderr, "\t%s\n", funcmap[counter2].name);

	      haslisted_methods ++;

	    }

	  abort();

	}

      list_insert_after(opts->servers, &aserver, sizeof(struct remoteio_server));

    }

  return 0;

}

int remoteio_open(struct remoteio **remoteio, struct remoteio_opts *opts, const char *servername)

{

  struct remoteio_server *theserver;

  struct remoteio *rem;

  int tmp;

  if(!opts)

    {

      fprintf(stderr, "%s:%d: no null opts!\n\tThis is a bug, please report it (after making sure it isn't already reported)\n", __FILE__, __LINE__);

      return 1;

    }

  theserver = remoteio_getserver(opts, servername);

  if(!theserver)

    {

      fprintf(stderr, "%s:%d: Could not find server named ``%s''\n", __FILE__, __LINE__, servername);

      return 1;

    }

  if(theserver->method >= REMOTEIO_METHOD_MAX

  struct distrend_packet *packet;

  ssize_t written_amount;

  short revents;

  if(client->state == DISTREND_CLIENT_DEAD)

    return TRUE;

  /**

     Manage timing-out clients.

   */

  if(data->current_time > client->cleanup_time)

    switch(client->state)

      {

      case DISTREND_CLIENT_PREVERSION:

	distrend_send_disconnect(data->listens, client, "You have failed to present version information in a timely manner. Cya :-p");

	break;

      case DISTREND_CLIENT_PREAUTH:

	distrend_send_disconnect(data->listens, client, "You have failed to present authentication information in a timely manner. Cya ;-)");

	break;

      case DISTREND_CLIENT_GOOD:

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

	break;

      case DISTREND_CLIENT_BAD:

	client->state = DISTREND_CLIENT_DEAD;

	return TRUE;

      default:

	break;

      }

  revents = data->listens->pollfds[client->sock.pollfd_offset].revents;

  if(revents & POLLRDNORM)

    /* handle reading */

    {

      fprintf(stderr, "%s:%d: My traversal says that sock %d is available for reading\n",

	      __FILE__, __LINE__, client->sock.sock);

      distrend_handleread(data->listens, client);

    }

  if(revents & POLLWRNORM)

    {

      fprintf(stderr, "%s:%d: My traversal says that sock %d is available for writing\n",

	      __FILE__, __LINE__, client->sock.sock);

      if(q_empty(client->outmsgs))

	{

	  data->listens->pollfds[client->sock.pollfd_offset].events &= ~POLLWRNORM;

	  return TRUE;

	}

      packet = q_front(client->outmsgs);

      written_amount = write(client->sock.sock, packet->data, packet->len);

      /**

	 Disconnect in case of write error.

       */

      if(written_amount == -1)

	{

	  perror("write");

	  /*

	    distrend_client_free();

	    Until liblist has the ability to delete nodes

	    during traversal, we'll have to free the client

	    during a client-list cleanup/pruning cycle.

	  */

	  client->state = DISTREND_CLIENT_DEAD;

	}

      if(packet->len == written_amount)

	{

	  q_dequeue(client->outmsgs);

	  distrend_packet_free(packet);

	  if(q_empty(client->outmsgs))

	    data->listens->pollfds[client->sock.pollfd_offset].events &= ~POLLWRNORM;

	}

      else

	{

	  /**

	     shifting seems the simplest solution.

	   */

	  packet->len -= written_amount;

	  memmove(packet->data, packet->data + written_amount, packet->len);

	}

    }

  /** continue iteration through the list */

  return TRUE;

}

int distrend_accept_newclient_proc(struct distrend_listens *listens, struct distrend_listen_sock *listen_sock)

{

  short revents;

  int newclientsock;

  revents = listens->pollfds[listen_sock->sock.pollfd_offset].revents;

  if(revents & POLLRDNORM)

    {

      newclientsock = accept(listen_sock->sock.sock, (struct sockaddr *)NULL, (socklen_t *)NULL);

      if(distrend_client_add(listens, newclientsock, DISTREND_CLIENT_PREVERSION))

	{

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

	  return 1;

	}

      fprintf(stderr, "accepted new connection\n");

    }

  /**

     Check other listen blocks too.

   */

  return TRUE;

}

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

{

  int tmp;

  struct distrend_accept_client_proc_data travinfo;

  struct distrend_client *newclient;

  fprintf(stderr, "poll(*, %d, -1)...\n", (int)listens->nfds);

  poll(listens->pollfds, listens->nfds, -1);

  if(tmp == -1)

    {

      perror("select");

      return 1;

    }

  /**

     Deal first with data waiting to be sent and then

     with input data.

   */

  travinfo.listens = listens;

  travinfo.current_time = time(NULL); /*< cache the time */

  list_traverse(listens->clients, &travinfo, (list_traverse_func_t)&distrend_accept_client_proc, LIST_FRNT | LIST_SAVE);

  /**

     Handle new connections.

   */

  list_traverse(listens->listen_socks, listens, (list_traverse_func_t)&distrend_accept_newclient_proc, LIST_FRNT | LIST_SAVE);

  /**

     Until liblist supports deleting nodes during a traversal,

     we clean dead clients here:

   */

  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;

}

int distrend_listen_free(struct distrend_listens *listens)

{

  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)

{

}

/**

   Adds a newly connected distrend_client to the listens->clients list

 */

int distrend_client_add(struct distrend_listens *listens, int sock, enum distrend_client_state state)

{

  int tmp;

  struct distrend_client *client;

  tmp = distrend_makesocknonblock(sock);

  if(tmp)

    {

      fprintf(stderr, "Not accepting this connection because I cannot make the sock non-blocking\n");

      close(sock);

      return 1;

    }

  client = malloc(sizeof(struct distrend_client));

  if(!client)

    {

      fprintf(stderr, "OOM\n");

      close(sock);

      return 1;

    }

  client->sock.sock = sock;

  distrend_listen_poll_newfd(listens, &client->sock, POLLRDNORM); /*< error checking? bah! */

  client->state = state;

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

  client->inlen = 0;

  client->expectlen = 0;

  client->inmsgs = q_init();

  client->outmsgs = q_init();

  list_insert_after(listens->clients, client, 0);

  /**

     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. */

  distrend_client_write(listens, client, DISTREN_GREETING, sizeof(DISTREN_GREETING) - 1);

  return 0;

}

/**

   This function shall only be called after the appropriate

   distrend_listen_poll_deletefd() has been called

 */

int distrend_client_free(struct distrend_client *client)

{

  q_free(client->inmsgs, (list_dealloc_func_t)distrend_packet_free);

  q_free(client->outmsgs, (list_dealloc_func_t)distrend_packet_free);

  close(client->sock.sock);

  return 0;

}

void distrend_packet_free(struct distrend_packet *packet)

{

  free(packet->data);

  free(packet); 

}

int distrend_makesocknonblock(int sock)

{

  int fdstatus;

  int tmp;

  fdstatus = fcntl(sock, F_GETFL);

  fdstatus |= O_NONBLOCK;

  tmp = fcntl(sock, F_SETFL, fdstatus);

  if(tmp == -1)

    {

      perror("fcntl");

      return 1;

    }

  return 0;

}

int distrend_client_write(struct distrend_listens *listens, struct distrend_client *client, char *towrite, size_t msglen)

{

  struct distrend_packet *packet;

  packet = malloc(sizeof(struct distrend_packet));

  if(!packet)

    {

      fprintf(stderr, "OOM\n");