annotate src/ctrl_telnet.c @ 125:e413158cae13

Add ushare project files.

/* ctrltelnet.c - Telnet controler
 * Copyright (C) 2005-2007 Sven Almgren <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Library General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#define STR(x) _STR(x)
#define _STR(x) __STR(x)
#define __STR(x) #x

#include "config.h"
#include "ctrl_telnet.h"
#include "minmax.h"
#include "trace.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/select.h> /* For select */
#include <sys/time.h>
#include <unistd.h> /* For pipe */
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include <stdarg.h>

#if (defined(____DISABLE_MUTEX) || 0)
#define pthread_mutex_lock(x)   printf(">>>> Locking   " __FILE__ ":" STR(__LINE__) " \t" #x "\n");
#define pthread_mutex_unlock(x) printf("<<<< Unlocking " __FILE__ ":" STR(__LINE__) " \t" #x "\n");
#endif

/**
 * @brief Structure holding data between the staring rutine and the thread
 */
typedef struct telnet_thread_data_t
{
  pthread_t thread;

  /* Litening socket */
  int listener;

  /* Socket used to terminate loop:
     0 is reading and 1 is sending, kill by sending to 1 */
  int killer[2];

  /* Our socket address */
  struct sockaddr_in local_address;

  /* Shared data buffer that can be used by others... */
  char shared_buffer[CTRL_TELNET_SHARED_BUFFER_SIZE];

  ctrl_telnet_client *clients;
} telnet_thread_data;

/**
 * @brief Struct for registerd commands
 */
typedef struct telnet_function_list_t
{
  /* Function name, or keyword, if you like */
  char *name;
  char *description;
  ctrl_telnet_command_ptr function;

  struct telnet_function_list_t *next;
} telnet_function_list;

/* Static yes used to set socketoptions */
static int yes = 1;
static telnet_thread_data ttd;
static telnet_function_list* functions = NULL;
static pthread_mutex_t functions_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t startstop_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t shared_lock = PTHREAD_MUTEX_INITIALIZER;
static int started = 0;

/* Threadfunction, core in telnet controler */
/**
 * @brief Thread function
 *
 * @param data Not used, leave as NULL
 */
static void *ctrl_telnet_thread (void *data);

/**
 * @brief Adds a new client to our list of new ones
 *
 * @param client to add
 */
static void ctrl_telnet_client_add (ctrl_telnet_client *client);

/**
 * @brief Removes "client" from our list of clients
 */
static void ctrl_telnet_client_remove (ctrl_telnet_client *client);

/**
 * @brief Updates an fd_set to contain the current set of clients
 *
 * @return max fd found in list
 */
static int ctrl_telnet_fix_fdset (fd_set* readable);

static void ctrl_telnet_tokenize (char *raw, int *argc, char ***argv);

static int ctrl_telnet_client_recv (ctrl_telnet_client *client);
static int ctrl_telnet_client_execute (ctrl_telnet_client *client);
static int ctrl_telnet_client_execute_line (ctrl_telnet_client *client,
                                            char *line);
static int ctrl_telnet_client_execute_line_safe (ctrl_telnet_client *client,
                                                 char *line);
static void ctrl_telnet_register_internals();

/**
 * @brief Starts a Telnet bound control interface
 *
 * @return 0 on success, -1 on error
 */
int
ctrl_telnet_start (int port)
{
  /* Start by making us threadsafe... */
  pthread_mutex_lock (&startstop_lock);

  /* Create listener socket */
  ttd.listener = socket (PF_INET, SOCK_STREAM, 0);
  if (ttd.listener == -1)
  {
    perror ("socket");
    pthread_mutex_unlock (&startstop_lock);
    return -1;
  }

  /* Clears us from "address already in use" errors */
  if (setsockopt (ttd.listener, SOL_SOCKET, SO_REUSEADDR,
                  &yes, sizeof (int)) == -1)
    perror ("setsockopt");

  ttd.local_address.sin_family = AF_INET;
  ttd.local_address.sin_addr.s_addr = INADDR_ANY;
  ttd.local_address.sin_port = htons (port);
  memset (&ttd.local_address.sin_zero, '\0',
          sizeof (ttd.local_address.sin_zero));

  if (bind (ttd.listener, (struct sockaddr *) &ttd.local_address,
            sizeof (ttd.local_address)) == -1)
  {
    perror ("bind");
    pthread_mutex_unlock (&startstop_lock);
    return -1;
  }

  if (listen (ttd.listener, CTRL_TELNET_BACKLOG) == -1)
  {
    perror ("listen");
    pthread_mutex_unlock (&startstop_lock);
    return -1;
  }

  print_log (ULOG_NORMAL, "Listening on telnet port %u\n", port);

  /* Create killer pipes */
  if (pipe (ttd.killer))
  {
    perror ("Failed to create killer pipe");
    pthread_mutex_unlock (&startstop_lock);
    return -1; /* FIXME. Kill all sockets... not critical,, but still */
  }

  if (pthread_create (&ttd.thread, NULL, ctrl_telnet_thread, NULL))
  {
    /* FIXME: Killall sockets... */
    perror ("Failed to create thread");
    pthread_mutex_unlock (&startstop_lock);
    return -1;
  }

  started = 1;
  ctrl_telnet_register_internals ();
  pthread_mutex_unlock (&startstop_lock);

  return 0;
}

/**
 * @brief Stops all telnet bound control interfaces
 */
void
ctrl_telnet_stop (void)
{
  pthread_mutex_lock (&startstop_lock);

  if (!started)
  {
    pthread_mutex_unlock (&startstop_lock);
    return;
  }

  /* yes is int, which is bigger then char, so this should be safe */
  write (ttd.killer[1], &yes, sizeof (char));

  pthread_mutex_unlock (&startstop_lock);
  pthread_join (ttd.thread, NULL);
}

/**
 * @brief Telnet thread function
 */
static void *
ctrl_telnet_thread (void *a __attribute__ ((unused)))
{
  /* fd_set with readable clients */
  fd_set fd_readable;

  /* Pointer to a client object */
  ctrl_telnet_client *client;

  int fd_max;

  while (1)
  {
    /* Get fds */
    fd_max = ctrl_telnet_fix_fdset (&fd_readable);

    if (select (fd_max + 1, &fd_readable, NULL, NULL, NULL) == -1)
    {
      perror ("select");
      /* FIXME: Close sockets */
      return NULL;
    }

    /* Check killer */
    if (FD_ISSET (ttd.killer[0], &fd_readable))
    {
      /* FIXME: TODO: Shut down sockets...  */

      /* Close listener and killer */
      close (ttd.listener);
      close (ttd.killer[0]);
      close (ttd.killer[1]);

      /* Check which fds that had anyhting to say... */
      client = ttd.clients;

      /* Say goodby to clients */
      while (client)
      {
        ctrl_telnet_client *current = client;
        ctrl_telnet_client_send (current,
                                 "\nServer is going down, Bye bye\n");
        client = client->next;
        ctrl_telnet_client_remove (current);
      }

      pthread_mutex_lock (&functions_lock);

      while (functions)
      {
        telnet_function_list *head = functions;
        functions = functions->next;

        free (head->name);
        if (head->description)
          free (head->description);

        free (head);
      }

      pthread_mutex_unlock (&functions_lock);

      return NULL;
    }

    /* Check for new connection */
    if (FD_ISSET (ttd.listener, &fd_readable))
    {
      socklen_t sl_addr;

      /* Create client object */
      client = malloc (sizeof (ctrl_telnet_client));

      if (!client)
      {
        perror ("Failed to create new client");
        return NULL;
      }

      memset (client, '\0', sizeof (ctrl_telnet_client));
      sl_addr = sizeof (client->remote_address);

      client->socket = accept (ttd.listener,
                               (struct sockaddr *) &client->remote_address,
                               &sl_addr);
      if (client->socket == -1)
      {
        perror ("accept");
        free (client);
      }
      else
      {
        ctrl_telnet_client_add (client);
        ctrl_telnet_client_execute_line_safe (client, "banner");
        ctrl_telnet_client_sendf (client, "For a list of registered commands type \"help\"\n");
        ctrl_telnet_client_send (client, "\n> ");
      }
    }

    /* Check which fds that had anyhting to say... */
    client = ttd.clients;

    /* Run through all clients and check if there's data avalible
       with FD_ISSET(current->socket) */
    while (client)
    {
      ctrl_telnet_client *current = client;
      client = client->next;

      if (FD_ISSET (current->socket, &fd_readable))
      {
        if (ctrl_telnet_client_recv (current) <= 0)
        {
          ctrl_telnet_client_remove (current);
          continue;
        }

        if (current->ready)
        {
          ctrl_telnet_client_execute (current);

          if (!current->exiting)
            ctrl_telnet_client_send (current, "\n> ");
          else
            ctrl_telnet_client_remove (current);
        }
      }
    }
  }
}

/**
 * @brief Adds a new client to our list of new ones
 *
 * @note This funtion is only called from a single thread,
 *       as such it won't need to be threadsafe
 * @param client to add
 */
static void
ctrl_telnet_client_add (ctrl_telnet_client *client)
{
  client->next = ttd.clients;
  ttd.clients = client;
}

/**
 * @brief Removes "client" from our list of clients
 *
 * @note This funtion is only called from a single thread,
 *       as such it won't need to be threadsafe
 * @param client to remove
 */
static void
ctrl_telnet_client_remove (ctrl_telnet_client *client)
{
  ctrl_telnet_client *tmp;

  /* Start by dealing with our head */
  if (client == ttd.clients)
    ttd.clients = client->next;
  else
  {
    for (tmp = ttd.clients; tmp->next; tmp = tmp->next)
    {
      if (tmp->next == client)
      {
        tmp->next = tmp->next->next;
        break;
      }
    }
  }

  close (client->socket);

  free (client);
}

/**
 * @brief Clears readable fd_set and adds every client to it,
 *        returns max fd found
 *
 * @param readable fd_set to update
 * @return Biggest fd
 */
static int
ctrl_telnet_fix_fdset (fd_set *readable)
{
  int maxfd;
  ctrl_telnet_client *client;

  maxfd = MAX (ttd.killer[0], ttd.listener);

  FD_ZERO (readable);
  FD_SET (ttd.listener, readable);
  FD_SET (ttd.killer[0], readable);

  client = ttd.clients;

  while (client)
  {
    if (client->socket > maxfd)
      maxfd = client->socket;

    FD_SET (client->socket, readable);

    client = client->next;
  }

  return maxfd;
}

static int
ctrl_telnet_client_recv (ctrl_telnet_client *client)
{
  int i;
  int nbytes;
  int buffer_free = CTRL_CLIENT_RECV_BUFFER_SIZE - client->buffer_recv_current - 1;

  nbytes = recv (client->socket,
                 client->buffer_recv + client->buffer_recv_current,
                 buffer_free, 0);
  if (nbytes <= 0)
  {
    close (client->socket);
    return nbytes;
  }

  client->buffer_recv_current += nbytes;
  client->buffer_recv[client->buffer_recv_current] = '\0';

  for (i = 0; i < client->buffer_recv_current; i++)
    if (client->buffer_recv[i] == '\n')
      client->ready = 1;

  return nbytes;
}

int
ctrl_telnet_client_send (const ctrl_telnet_client *client, const char *string)
{
  const char* cc = string;
  int len = strlen (cc);
  int sent = 0;
  int senttotal = 0;

  while ((cc - string) < len)
  {
    /* Use nonblocking just as a precation...
       and a failed write won't _really_ kill us */
    sent = send (client->socket, string, len - (cc - string), MSG_DONTWAIT);
    
    /* This will mark the socket as dead... just to be safe..
       and its only a telnet interface... reconnect and do it again */
    if (sent == -1)
      return -1;

    senttotal += sent;
    cc += sent;
  }

  return senttotal;
}

int
ctrl_telnet_client_sendf (const ctrl_telnet_client *client,
                          const char *format, ...)
{
  int retval;
  va_list ap;
  int len;

  pthread_mutex_lock (&shared_lock);

  va_start (ap, format);
  len = vsnprintf (ttd.shared_buffer,
                   CTRL_TELNET_SHARED_BUFFER_SIZE, format, ap);
  va_end (ap);

  /* Check if the message fitted inside the buffer, if not,
     either exit or adjust len to be buffersize, I choose exit for now */
  if (len >= CTRL_TELNET_SHARED_BUFFER_SIZE)
  {
    pthread_mutex_unlock (&shared_lock);
    /* FIXME: Return error or send what we've got? */
    return -1; /* Buffer was to small */
  }
  
  /* TODO: Might be good to have the option to specify str length so
     send doesn't have to recompute it... */
  retval = ctrl_telnet_client_send (client, ttd.shared_buffer);

  pthread_mutex_unlock (&shared_lock);

  return retval;
}

int
ctrl_telnet_client_sendsf (const ctrl_telnet_client *client,
                           char *buffer, int buffersize,
                           const char *format, ...)
{
  va_list ap;
  int len;

  va_start (ap, format);
  len = vsnprintf (buffer, buffersize, format, ap);
  va_end (ap);

  /* Check if the message fitted inside the buffer, if not,
     either exit or adjust len to be buffersize, I choose exit for now */
  if (len >= buffersize)
    return -1; /* Buffer was to small */

  /* TODO: Might be good to have the option to specify str length
     so send doesn't have to recompute it... */
  return ctrl_telnet_client_send (client, buffer);
}

/* FIXME: Ulgy non optimised version */
static int
ctrl_telnet_client_execute (ctrl_telnet_client *client)
{
  int i = 0;

  /* Check buffer for complete lines and execute them,,, */
  for (i = 0; i < client->buffer_recv_current; i++)
  {
    if (client->buffer_recv[i] == '\n' || client->buffer_recv[i] == '\r')
    {
      /* Replace newline with null (or \r) */
      client->buffer_recv[i] = '\0';

      /* Send line to execution */
      ctrl_telnet_client_execute_line_safe (client, client->buffer_recv);

      /* Check if next is either newline or CR, strip that too, if needed */
      if ((i + 1 < CTRL_CLIENT_RECV_BUFFER_SIZE) &&
          (client->buffer_recv[i+1]=='\n' || client->buffer_recv[i+1]=='\r'))
        client->buffer_recv[++i] = '\0';

      /* Remove processed line */
      memmove (client->buffer_recv, client->buffer_recv + i,
               client->buffer_recv_current - 1);
      client->buffer_recv_current -= (i + 1);
      i = -1;
    }
  }

  return 0; /* No syntax error checking yet */
}

static int
ctrl_telnet_client_execute_line_safe (ctrl_telnet_client *client, char *line)
{
  int retval;

  pthread_mutex_lock (&functions_lock);
  retval = ctrl_telnet_client_execute_line (client, line);
  pthread_mutex_unlock (&functions_lock);

  return retval;
}

static int
ctrl_telnet_client_execute_line (ctrl_telnet_client *client, char *line)
{
  int argc = 0;
  char **argv = NULL;
  telnet_function_list *node;
  char *line2 = strdup (line); /* To make it safer */
  ctrl_telnet_tokenize (line2, &argc, &argv);

  node = functions;

  if (*argv[0] == '\0')
  {
    free (argv);
    free (line2);
    return 0;
  }

  while (node)
  {
    if (!strcmp (node->name, argv[0]))
    {
      node->function (client, argc, argv);
      break;
    }

    node = node->next;
  }

  if (!node)
    ctrl_telnet_client_sendf (client, "%s: Command not found\n", argv[0]);

  free (argv);
  free (line2);

  return strlen (line);
}

void
ctrl_telnet_register (const char *funcname,
                      ctrl_telnet_command_ptr funcptr,
                      const char *description)
{
  telnet_function_list *function;

  function = malloc (sizeof (telnet_function_list));
  function->name = strdup (funcname); /* Mayby use strndup...? */
  function->description = description ? strdup (description) : NULL;
  function->function = funcptr;

  pthread_mutex_lock (&functions_lock);
  function->next = functions;
  functions = function;
  pthread_mutex_unlock (&functions_lock);
}

/* Warning: This WILL edit the input string... use strdup or something
   if needed, also remember to free() argv as the first array is dynamic */
/* If *argv != NULL it'll first be free()ed... or realloc,
   make sure to clear *argv to null on initialization */
static void
ctrl_telnet_tokenize (char *raw, int *argc, char ***argv)
{
  int i;
  int has_backslash = 0;
  int has_quote = 0;
  char *pc = raw;

  if (!raw || !argc || !argv)
  {
    perror ("NULL in " __FILE__ " at line " STR (__LINE__));
    return;
  }

  /* (1/3) First run is just to count our arguments... */
  *argc = (raw[0] == '\0') ? 0 : 1;

  pc = raw;
  while (*pc)
  {
    switch (*pc)
    {
    case '\\':
      if (!has_backslash)
        has_backslash = 2; /* FULHACK */
      break;
    case ' ':
      if (!has_backslash && !has_quote)
        (*argc)++;
      break;
    case '"':
      if (!has_backslash)
        has_quote = !has_quote;
      
      break;
    }

    /* When we get a BS we set it to two, this makes it one,
       next run it will still be 1, then one after that is zero... FULHACK */
    if (has_backslash)
      has_backslash--;

    pc++;
  }

  /* Create argv */
  *argv = malloc (sizeof (char **) * ((*argc) + 1));

  /* (2/3) Parse throu one more time, this time filling argv (Pass 2 / 3) */
  i = 0;
  pc = raw;
  has_backslash = 0;
  has_quote = 0;
  (*argv)[0] = raw;

  while (*pc)
  {
    switch (*pc)
    {
    case '\\':
      if (!has_backslash)
        has_backslash = 2; /* FULHACK */
      break;
    case ' ':
      if (!has_backslash && !has_quote)
      {
        *pc = '\0';
        (*argv)[++i] = pc+1;
        pc++;
        continue;
      }
      break;
    case '"':
      if (!has_backslash)
        has_quote = !has_quote;
      break;
    }

    /* When we get a BS we set it to two, this makes it one,
       next run it will still be 1, then one after that is zero... FULHACK */
    if (has_backslash)
      has_backslash--;

    pc++;
  }

  /* Make last element (argc) point to null... */
  (*argv)[++i] = NULL;

  /* (3/3) Parse arguments to remove escapings and such */
  for (i = 0; (*argv)[i]; i++)
  {
    /* Set up environment */
    pc = (*argv)[i];
    has_backslash = 0;
    has_quote = 0;

    /* Remove leading and ending quotes, if existing */
    if (*pc == '"')
    {
      int len = strlen (pc);

      if (len > 0 && pc[len - 1] == '"')
        pc[len - 1] = '\0';
      memmove (pc, pc + 1, len);
    }

    /* Remove any special characters */
    while (*pc)
    {
      switch (*pc)
      {
      case '\\':
        if (!has_backslash)
        {
          has_backslash = 2; /* FULHACK */
          break;
        }
        /* Else: fall through */
      case ' ':
      case '"':
        if (has_backslash)
        {
          pc--;
          memmove (pc, pc + 1, strlen (pc)); /* FIXME: Not cheap */
        }
        break;
      }

      /* When we get a BS we set it to two, this makes it one,
         next run it will still be 1, then one after that is zero... */
      if (has_backslash)
        has_backslash--;
      
      pc++;
    }
  }
}

static void
help (ctrl_telnet_client *client, int argc, char **argv)
{
  int hidden = 0;
  ctrl_telnet_client_execute_line (client, "banner");
  
  if (argc < 2)
  {
    ctrl_telnet_client_send (client, "\n");
    ctrl_telnet_client_send (client, "Usage: help TOPIC\n");
    ctrl_telnet_client_send (client, "Valid topics are\n");
    ctrl_telnet_client_send
      (client, "  commands - For a list of registed commands\n");
    ctrl_telnet_client_send
      (client, "  syntax - For a description of the interface syntax\n");
    return;
  }
  else
  {
    if (!strcmp ("commands", argv[1]))
    {
      telnet_function_list *node;

      node = functions;
      ctrl_telnet_client_send
        (client, "Registered command (command - description)\n");
      ctrl_telnet_client_send
        (client, "=======================================================\n");

      while (node)
      {
        /* Make functions without descriptions invisible */
        if (node->description)
          ctrl_telnet_client_sendf (client, "  %s - %s\n",
                                    node->name, node->description);
        else
          hidden++;

        node = node->next;
      }

      if (hidden)
        ctrl_telnet_client_sendf
          (client, "There's also %i hidden functions\n", hidden);
    } /* commands */
    else if (!strcmp ("syntax", argv[1]))
    {
      ctrl_telnet_client_send
        (client, "Syntax is easy: command parameters\n");
      ctrl_telnet_client_send
        (client, "  Each new word is a new argument, unless the space is precided\n");
      ctrl_telnet_client_send
        (client, "  a backslash (\\), or if a set of words are surrounded by quotes\n");
      ctrl_telnet_client_send
        (client, "  (\"). To get a litteral quote you can escape it as \\\".\n");
      ctrl_telnet_client_send (client, "\n");
      ctrl_telnet_client_send (client, "STUB\n");
    }
    else
      ctrl_telnet_client_send (client, "Unknown topic\n");
  }
}

static void
banner (ctrl_telnet_client *client,
        int argc __attribute__ ((unused)),
        char **argv __attribute__ ((unused)))
{
  ctrl_telnet_client_sendf (client, "%s (%s) (Built %s)\n",
                            PACKAGE_NAME, VERSION, __DATE__);
}

static void
echo (ctrl_telnet_client *client, int argc, char **argv)
{
  int i;
  
  for (i = 1; i < argc; i++)
    ctrl_telnet_client_sendf (client, "%s%s", (i > 1 ? " " : ""), argv[i]);
  ctrl_telnet_client_send (client, "\n");
}

static void
echod (ctrl_telnet_client *client, int argc, char **argv)
{
  int i;

  ctrl_telnet_client_sendf (client, "Argc: %i\n", argc);

  for (i = 0; i < argc; i++)
    ctrl_telnet_client_sendf (client, "%i: '%s'\n", i, argv[i]);
}

static void
ctrl_telnet_exit (ctrl_telnet_client *client,
                  int argc __attribute__ ((unused)),
                  char **argv __attribute__ ((unused)))
{
  client->exiting = 1;
  ctrl_telnet_client_send (client, "Bye bye\n");
}

static void
ctrl_telnet_register_internals (void)
{
  ctrl_telnet_register ("echo", echo, "Echos all arguments");
  ctrl_telnet_register ("echod", echod, "Echos all arguments but with each argument on a new line... DEBUG");
  ctrl_telnet_register ("help", help, "Display help");
  ctrl_telnet_register ("banner", banner, NULL);
  ctrl_telnet_register ("exit", ctrl_telnet_exit, "Exits this interface (Or CTRL+D then Enter)");
  /* CTRL+D... But it has to be fallowd by a new line */
  ctrl_telnet_register ("\4", ctrl_telnet_exit, NULL);
}