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

#ifndef _DISTREN_LIBREMOTEIO_H
#define _DISTREN_LIBREMOTEIO_H

#include "common/multiio.h"
#include "common/remoteio.h"

#include <confuse.h>
#include <list.h>
#include <queue.h>

/**
  private declarations for remoteio, to be included by options.c and remoteio.c
 */

enum remoteio_method
  {
    REMOTEIO_METHOD_SSH = 0,
#ifndef WINDOWS
    REMOTEIO_METHOD_UNIX = 1,
#endif
    REMOTEIO_METHOD_TCP = 2,
    /*    REMOETIO_METHOD_XMLRPC */ /*< maybe someday */
    /** method for the remoteio_open_socket() function, where we don't call open() ourselves: */
    REMOTEIO_METHOD_SOCKET = 3,
    REMOTEIO_METHOD_MAX = 4 /*< This is a number used to check the consitency of remoteio_server structs */
  };

struct remoteio_server
{
  char *name; /*< The friendly named passed to remoteio_open() */
  char *hostname;
  char *username;
  enum remoteio_method method;
  unsigned int types; /*< See ``Server types'' in protocol.h */
};

struct remoteio_opts
{
  char *ssh_command;
  list_t servers;  /* type: (struct remoteio_server *) */
  /* store the multiio context for general use */
  multiio_context_t multiio;
  /* store remoteio's socket_type */
  multiio_socket_type_t socket_type;

  /* an argument for the remoteio_read_handle_func_t */
  void *generic_handler_data;
};

/**
 * Used to describe the nature of the data stored in the
 * outbound and message queues that power remoteio_write()
 * and remoteio_read() (?).
 */
struct remoteio_packet
{
  size_t len;
  char *data;
};


struct remoteio
{
  enum remoteio_method method;
  struct remoteio_opts *opts;
  struct execio *execio;
#ifndef WINDOWS
  int sock;
#endif

  remoteio_read_handle_func_t read_handler;
  /* for the read_handler */
  void *read_handler_data;
  /* so that read_handler_data can be cleaned up */
  remoteio_close_handle_func_t close_handler;

  /**
   * Store a buffer of data waiting to be processed.
   */
  struct remoteio_packet inbuf;

  /**
   * Provide the asynchronosity abstraction by queuing outgoing messages.
   */
  queue_t outmsgs;

  /**
   * This is disappointingly hacky. If this variable is 0, then
   * remoteio_close() will act normal. If set to 1, then
   * remoteio_close() will not actually free this struct but instead
   * increment this variable to 2. This is so that read_handler can
   * call remoteio_close() without segfaulting us.
   */
  short careful_free;
};


/* lookup table */
typedef int remoteio_open_func_t(struct remoteio *rem, struct remoteio_server *server);
typedef int remoteio_read_func_t(struct remoteio *rem, void *buf, size_t len, size_t *bytesread);
typedef int remoteio_write_func_t(struct remoteio *rem, const void *buf, size_t len, size_t *bytesread);
typedef int remoteio_close_func_t(struct remoteio *rem);

struct remoteio_method_funcmap
{
  enum remoteio_method method;

  remoteio_open_func_t *open_func;
  remoteio_read_func_t *read_func;
  remoteio_write_func_t *write_func;
  remoteio_close_func_t *close_func;

  char *name; /*< used for error messages */
};

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

#endif