Colony

/**

 * @file ConnectionPool.cpp

 *

 * @author Jason Knichel

 * @date 7/22/07

 */

#include <sys/select.h>

#include <ctype.h>

#include <errno.h>

#include <unistd.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include "includes/ConnectionPool.h"

#include "includes/client.h"

#include "../lib/colonet_defs.h"

/**

 * @brief The default constructor for ConnectionPool

 */

ConnectionPool::ConnectionPool() {

  max_file_descriptor = 0;

  next_available_slot = 0;

  number_clients_ready = 0;

  FD_ZERO(&ready_set);

  FD_ZERO(&read_set);

  FD_ZERO(&write_set);

  memset(&client_file_descriptor_array, 0, sizeof(int)*MAX_CONNECTIONS);

  memset(&read_buffer, 0, sizeof(char *)*MAX_CONNECTIONS);

  memset(&read_buffer_size, 0, sizeof(int)*MAX_CONNECTIONS);

  memset(&write_buffer, 0, sizeof(char *)*MAX_CONNECTIONS);

  memset(&write_buffer_size, 0, sizeof(int)*MAX_CONNECTIONS);

}

/**

 * @brief The destructor for ConnectionPool

 */

ConnectionPool::~ConnectionPool() {

}

/**

 * @brief Adds a client to the connection pool

 *

 * @param client_file_descriptor The file descriptor to add to the connection pool

 *

 * @return 0 on success, negative error code on failure

 */

int ConnectionPool::add_client(int client_file_descriptor) {

  if (client_file_descriptor < 0) {

    return ERROR_INVALID_CLIENT_DESCRIPTOR;

  }

  if (next_available_slot == MAX_CONNECTIONS) {

    return ERROR_TOO_MANY_CLIENTS;

  }

  if (client_file_descriptor > max_file_descriptor) {

    max_file_descriptor = client_file_descriptor;

  }

  FD_SET(client_file_descriptor, &ready_set);

  int next_slot = next_available_slot;

  client_file_descriptor_array[next_slot] = client_file_descriptor;

  read_buffer[next_slot] = (char*) malloc(sizeof(char) * READ_BUFFER_SIZE);

  if (!(read_buffer[next_slot])) {

    return ERROR_ALLOCATING_MEMORY;

  }

  read_buffer_size[next_slot] = 0;

  write_buffer[next_slot] = (char *)malloc(sizeof(char) * WRITE_BUFFER_SIZE);

  if (!(write_buffer[next_slot])) {

    free(read_buffer[next_slot]);

    return ERROR_ALLOCATING_MEMORY;

  }

  write_buffer_size[next_slot] = 0;

  next_available_slot++;

  return 0;

}

/**

 * @brief Removes a client from the connection pool

 *

 * @param The index in the pool of the client to remove

 *

 * @return 0 on success, negative error code on failure

 */

int ConnectionPool::remove_client(int pool_index) {

  if (pool_index < 0 || pool_index >= next_available_slot) {

    return ERROR_INVALID_CLIENT_DESCRIPTOR;

  }

  int client_file_descriptor = client_file_descriptor_array[pool_index];

  if (FD_ISSET(client_file_descriptor, &ready_set)) {

    FD_CLR(client_file_descriptor, &ready_set);

  }

  if (FD_ISSET(client_file_descriptor, &read_set)) {

    FD_CLR(client_file_descriptor, &read_set);

  }

  if (FD_ISSET(client_file_descriptor, &write_set)) {

    FD_CLR(client_file_descriptor, &write_set);

  }

  free(read_buffer[pool_index]);

  free(write_buffer[pool_index]);

  for (int j = pool_index; j < next_available_slot - 1; j++) {

    client_file_descriptor_array[pool_index] = client_file_descriptor_array[pool_index+1];

    read_buffer[pool_index] = read_buffer[pool_index+1];

    read_buffer_size[pool_index] = read_buffer_size[pool_index+1];

    write_buffer[pool_index] = write_buffer[pool_index+1];

    write_buffer_size[pool_index] = write_buffer_size[pool_index+1];

  }

  next_available_slot--;

  int temp_max_file_descriptor = 0;

  for (int j = 0; j < next_available_slot; j++) {

    if (client_file_descriptor_array[j] > temp_max_file_descriptor)

      temp_max_file_descriptor = client_file_descriptor_array[j];

  }

  max_file_descriptor = temp_max_file_descriptor;

  printf("Removing client.\n");

  return 0;

}

/**

 * @brief Checks the status of the clients

 *

 * Sees is any clients are ready to read from their file descriptor or are

 *  ready to write to their file descriptor.

 *

 * @param wireless A pointer to the wireless object

 *

 * @return 0 on success, negative error code on error

 */

//TODO: test that it drops commands properly if it gets sent too much data

//      do we want it to drop the data or drop the connection?

int ConnectionPool::check_clients(ColonetWireless * wireless) {

  char temporary_buffer[READ_BUFFER_SIZE];

  char temporary_command_buffer[READ_BUFFER_SIZE+1];

  int i;

  int client_file_descriptor;

  int num_bytes_read;

  int length;

  int sent;

  int command_length;

  for (i = 0; i < next_available_slot; i++) {

    client_file_descriptor = client_file_descriptor_array[i];

    if (FD_ISSET(client_file_descriptor, &read_set)) {

      num_bytes_read = read(client_file_descriptor, temporary_buffer, READ_BUFFER_SIZE);

      if (num_bytes_read == 0 || (num_bytes_read == -1 && errno == ECONNRESET)) {

        remove_client(i);

        i--;

        continue;

      }

      while (num_bytes_read > 0) {

        length = num_bytes_read;

        if (length + read_buffer_size[i] > READ_BUFFER_SIZE) {

          length = READ_BUFFER_SIZE - read_buffer_size[i];

        }

        memcpy(read_buffer[i]+read_buffer_size[i], temporary_buffer, length);

        read_buffer_size[i] += length;

        num_bytes_read -= length;

        if (num_bytes_read > 0) {

          memmove(temporary_buffer, temporary_buffer+length, READ_BUFFER_SIZE - length);

        }

        printf("Read buffer is %s\n", read_buffer[i]);

        char* newline_position;

        while ((newline_position = strstr(read_buffer[i], "\n"))) {

          //if no newline if found in the entire readbuffer (when its full), 

          //toss out the command

          // because either the command being given is too long or someone is trying

          // to do something bad to the server

          //TODO: this is from before all this code was put in the loop.  reconsider

          //      how to check this error condition and do it elsewhere

          if (!newline_position && (read_buffer_size[i] == READ_BUFFER_SIZE)) {

            read_buffer_size[i] = 0;

            break;

          }

          //if no newline is found then there is not a command in the buffer

          if (!newline_position) {

            break;

          }

          command_length = (newline_position - read_buffer[i])+1;

          //the newline was found in garbage in the currently not used portion

          // of the read buffer

          if (command_length > read_buffer_size[i]) {

            break;

          }

          memcpy(temporary_command_buffer, read_buffer[i], command_length);

          //do command_length-1 to get rid of the newline terminating the command

          temporary_command_buffer[command_length-1] = '\0';

          //did this because telnet was putting a \r\n on the end instead of just \n

          if (isspace(temporary_command_buffer[command_length-2])) {

            temporary_command_buffer[command_length-2] = '\0';

          }

          memmove(read_buffer[i], read_buffer[i]+command_length, read_buffer_size[i] - command_length);

          read_buffer_size[i] -= command_length;

          if (command_length > MAX_COMMAND_LEN) {

            printf("The command was too long.  Tossing command out.\n");

            break;

          }

          if (parse_command(temporary_command_buffer, i, wireless) < 0) {

            printf("There was an error parsing command\n");

            break;

          }

        }

      }

    }

    if (FD_ISSET(client_file_descriptor, &write_set)) {

      if (write_buffer_size[i] == 0) {

        continue;

      }

      sent = write(client_file_descriptor, write_buffer[i], write_buffer_size[i]);

      memmove(write_buffer[i], write_buffer[i]+sent, WRITE_BUFFER_SIZE - sent);

      write_buffer_size[i] -= sent;

    }

  }

  return 0;

}

/**

 * @brief Puts text into a write buffer that will be written to a client's file

 *  descriptor sometime when the client is ready to write.

 *

 * @param pool_index Index in the pool of the client to write to

 * @param message The message to be written

 * @param length The length of the message

 *

 * @return 0 on success, negative error code on failure

 */

int ConnectionPool::write_to_client(int pool_index, char * message, int length) {

  if (pool_index < 0 || pool_index >= next_available_slot) {

    return ERROR_INVALID_CLIENT_ID;

  }

  if (!message) {

    return ERROR_INVALID_MESSAGE;

  }

  if (length < 0) {

    return ERROR_INVALID_MESSAGE_LENGTH;

  }

  if (length > (WRITE_BUFFER_SIZE-write_buffer_size[pool_index])) {

    //TODO: make this a logging statement instead of a print statement

    printf("There is not enough room in the write buffer to send the data to the client.\n");

    return ERROR_NOT_ENOUGH_ROOM;

  }

  memcpy(write_buffer[pool_index], message, length);

  write_buffer_size[pool_index] += length;

  return 0;

}

/**

 * @brief Sets the socket to listen on

 *

 * @param listen_socket The socket to listen on

 *

 * @return void

 */

void ConnectionPool::set_listen_socket_in_ready_set(int listen_socket) {

  if (listen_socket < 0)

    return;

  FD_SET(listen_socket, &ready_set);

}

/**

 * @brief Find out what file descriptors are ready to write to and read from

 *

 * @param listen_socket The socket to listen on

 * @param select_timeout The timeout for the select statement

 *

 * @return 0

 */

int ConnectionPool::perform_select(int listen_socket) {

  read_set = ready_set;

  write_set = ready_set;

  struct timeval select_timeout;

  memset(&select_timeout, 0, sizeof(select_timeout));

  //TODO(Jason): think about why I put this there

  if (max_file_descriptor < listen_socket)

    max_file_descriptor = listen_socket;

  number_clients_ready = select(max_file_descriptor+1, &(read_set), &(write_set), NULL, &select_timeout);

  if (number_clients_ready < 0) {

    perror(__FUNCTION__);

  }

  return 0;

}

int ConnectionPool::is_socket_ready_to_read(int socket) {

  return FD_ISSET(socket, &read_set);

}

int ConnectionPool::is_socket_ready_to_write(int socket) {

  return FD_ISSET(socket, &write_set);

}

int ConnectionPool::get_max_file_descriptor() {

  return max_file_descriptor;

}

void ConnectionPool::set_max_file_descriptor(int new_max_file_descriptor) {

  max_file_descriptor = new_max_file_descriptor;

}

int ConnectionPool::get_next_available_slot() {

  return next_available_slot;

}

int ConnectionPool::get_number_clients_ready() {

  return number_clients_ready;

}

void ConnectionPool::set_number_clients_ready(int new_number_clients_ready) {

  number_clients_ready = new_number_clients_ready;

}

fd_set ConnectionPool::get_ready_set() {

  return ready_set;

}

fd_set ConnectionPool::get_read_set() {

  return read_set;

}

void ConnectionPool::set_read_set(fd_set new_set) {

  read_set = new_set;

}

fd_set ConnectionPool::get_write_set() {

  return write_set;

}

void ConnectionPool::set_write_set(fd_set new_set) {

  write_set = new_set;

}

//TODO: write a function to write data into the write buffers (jason: what was this referring to?)

int ConnectionPool::parse_command(char* command, int pool_index, ColonetWireless * wireless) {

  char tokens[MAX_TOKENS][MAX_TOKEN_SIZE];

  unsigned char int_tokens[MAX_TOKENS];

  int number_tokens = 0;

  char* end_pointer = NULL;

  int command_id;

  int i;

  unsigned char arguments[PACKET_DATA_LEN];

  memset(arguments, 1, PACKET_DATA_LEN);

  if (!command) {

    return -1;

  }

  if (pool_index < 0) {

    return -1;

  }

  if (pool_index >= next_available_slot) {

    return -1;

  }

  if ((number_tokens = tokenize_command(command, tokens)) < 0) {

    return -1;

  }

  //the 10 in the function call indicates number is base 10

  command_id = strtol(tokens[0], &end_pointer, 10);

  if (!end_pointer || *end_pointer != '\0') {

    printf("There was an error converting first token into a number.\n");

    return -1;

  }

  if (command_id == SEND_TO_ROBOT || REQUEST_FROM_ROBOT) {

    int number_int_tokens = number_tokens;

    /* Convert tokens to ints */

    for (i = ROBOT_COMMAND_OFFSET; i < number_int_tokens; i++) {

      int_tokens[i-ROBOT_COMMAND_OFFSET] = atoi(tokens[i]);

    }

    if (command_id == REQUEST_FROM_ROBOT) {

      if (i < MAX_TOKENS) {

        for (;i >= 4; i--) {

          int_tokens[i] = int_tokens[i-1];

        }

        int_tokens[3] = pool_index;

        number_int_tokens++;

      } else {

        //TODO: send an error back to client here also

        fprintf(stderr, "Client attempted to request data from the robot but there was not enough room to put in the client's id.\n");

        return -1;

      }

    }

    /* Fill arguments buffer with arguments */

    for (i = ROBOT_COMMAND_LEN; i < number_int_tokens-ROBOT_COMMAND_OFFSET; i++) {

      arguments[i-ROBOT_COMMAND_LEN] = int_tokens[i];

    }

    /* Check the tokens */

    if (check_tokens(int_tokens, number_int_tokens) < 0) {

      fprintf(stderr, "%s: Error - Invalid command/request.\n", __FUNCTION__);

      return 0;

    }

    /* Send packet to robot */

    fprintf(stderr, "Calling wireless->send(%d, %d, %d, arguments)\n", 

            int_tokens[0], int_tokens[1], int_tokens[2]);

    wireless->send(int_tokens[0], int_tokens[1], int_tokens[2], arguments);

  }

  return 0;

}

/**

 * @brief Breaks a command up into tokens

 *

 * @param command The command to tokenize

 * @param tokens A two dimensional character array to store the tokens in

 *

 * @return 0 on success, negative error code on failure

 */

int ConnectionPool::tokenize_command(char* command, char tokens[MAX_TOKENS][MAX_TOKEN_SIZE]) {

  char* next_token = command;

  char* end_token = NULL;

  int number_tokens = 0;

  if (!command) {

    return -1;

  }

  while ((end_token = strstr(next_token, " "))) {

    *end_token = '\0';

    if (strlen(next_token) > MAX_TOKEN_SIZE-1) {

      return -1;

    }

    strcpy(tokens[number_tokens], next_token);

    number_tokens++;

    next_token = end_token + 1;

    while (isspace(*next_token) && *next_token != '\0') {

      next_token++;

    }

  }

  if (end_token == NULL && *next_token != '\0') {

    if (strlen(next_token) > MAX_TOKEN_SIZE-1) {

      return -1;

    }

    strcpy(tokens[number_tokens], next_token);

    number_tokens++;

  }

  return number_tokens;

}

/** 

 * @brief checks a list of tokens to see if it's valid

 *

 * @param tokens The tokens to check

 * @param number_tokens The number of tokens contained in the tokens parameter

 *

 * @return 0 if tokens is valid

 */

int ConnectionPool::check_tokens(unsigned char* tokens, int number_tokens) {

  if (number_tokens > 3 + PACKET_DATA_LEN) {

    /* Too many tokens */

    return -1;

  }

  if (number_tokens < 3) {

    /* Not enough tokens */

    return -1;

  }

  if (tokens[1] != COLONET_REQUEST && tokens[1] != COLONET_COMMAND) {

    /* Invalid message type */

    return -1;

  }

  return 0;

}