/*

  Copyright 2009 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 <stdlib.h>

#include <stdio.h>

#include <string.h>

#ifndef WINDOWS

#include <sys/socket.h>

#include <sys/un.h>

#endif

/* local */

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 WINDOWS

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 WINDOWS

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

  static int haslisted_methods = 0;

  struct remoteio_server *aserver;

  opts->servers = malloc(sizeof(struct remoteio_server));

  if(!opts->servers)

    {

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

      abort();

    }

  aserver = opts->servers;

  numservers = cfg_size(cfg, "server"); 

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

    {

      cfg_t *cfg_aserver;

      char *method;

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

      if(!aserver) /*< if the malloc in the previous loop failed */

	abort();

      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(counter = 0; funcmap[counter].name; counter ++)

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

	  aserver->method = REMOTEIO_METHOD_SSH;

      if(aserver->method == REMOTEIO_METHOD_MAX)

	{

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

	  if(!haslisted_methods)

	    {

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

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

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

	      haslisted_methods ++;

	    }

	  abort();

	}

      if(counter < numservers - 1)

	{

	  aserver->next = malloc(sizeof(struct remoteio_server));

	  aserver = aserver->next;