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 <ConnectionPool.h>

#include <Command.h>

#include <colonet_defs.h>

#include <colonet_wireless.h>

/**

 * @brief The default constructor for ConnectionPool

 *

 * @param cs The colonet server instance to use with this class

 */

ConnectionPool::ConnectionPool(ColonetServer* cs) {

  colonet_server = cs;

  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;

  }

        //add the new file descriptor to the set of ready descriptors

  FD_SET(client_file_descriptor, &ready_set);

  int next_slot = next_available_slot;

        //put the new client into the connection pool

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

        //clear this client from all lists of file descriptors

  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 up the resources this client used

  free(read_buffer[pool_index]);

  free(write_buffer[pool_index]);

        //shift the other clients down

  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;

        //figure out the newest max file descriptor

  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("Client disconnected.\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.

 *

 * @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() {

  int i;

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

    int client_file_descriptor = client_file_descriptor_array[i];

                //check to see if this client is ready to be read from

    if (FD_ISSET(client_file_descriptor, &read_set)) {

      if (read_data(i, client_file_descriptor) == DECREMENT_INDEX_COUNTER) {

                                i--;

                                continue;

      }

    }

                //check to see if this client is ready to write to

    if (FD_ISSET(client_file_descriptor, &write_set)) {

      write_data(i, client_file_descriptor);

    }

  }

  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.  -1 for global.

 * @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 (!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;

  }

  if (pool_index == -1) {

    // Global message.

    for (int i = 0; i < number_clients_ready; i++) {

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

      write_buffer_size[i] += length;

    }

  } else {

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

      return ERROR_INVALID_CLIENT_ID;

    }

    //printf("Connection pool: attempting to write [%s], length %i to index %i.\n", message, length, pool_index);

    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::add_new_socket_to_pool(int new_socket) {

  if (new_socket < 0)

    return;

  FD_SET(new_socket, &ready_set);

  if (new_socket > max_file_descriptor) {

    max_file_descriptor = new_socket;

  }

}

/**

 * @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;

        //call select.  select sees if any file descriptor in the read set is ready to be read and modifies the read set.

        // It sees if any file descriptor in the write set is ready to be written to and modifies the write set.

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

  if (number_clients_ready < 0) {

    perror(__FUNCTION__);

  }

  return 0;

}

/**

 * @return 1 if the socket is ready to be read, 0 otherwise

 */

int ConnectionPool::is_socket_ready_to_read(int socket) {

  return FD_ISSET(socket, &read_set);

}

/**

 * @return the number of clients that are ready

 */

int ConnectionPool::get_number_clients_ready() {

  return number_clients_ready;

}

/**

 * @brief Reads data from a particular client and checks to see if it contains a command and parses that command

 *   or buffers the data assuming the rest of the command will be sent later

 *

 * @param pool_index The index in the connection pool of the client to read from

 * @param client_file_descriptor The file descriptor of the client to read from

 *

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

 */

int ConnectionPool::read_data(int pool_index, int client_file_descriptor) {

  char temporary_buffer[READ_BUFFER_SIZE];

  char temporary_command_buffer[READ_BUFFER_SIZE+1];

  int num_bytes_read;

  int length;

  int command_length;

        //read data that the client is trying to send us

  num_bytes_read = read(client_file_descriptor, temporary_buffer, READ_BUFFER_SIZE);

        //check to see if the client disconnected

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

    remove_client(pool_index);

    return DECREMENT_INDEX_COUNTER;

  }

  while (num_bytes_read > 0) {

    length = num_bytes_read;

                //make sure this new data won't overflow the read buffer

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

      length = READ_BUFFER_SIZE - read_buffer_size[pool_index];

    }

                //put the newly read data into the read buffer for this client

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

    read_buffer_size[pool_index] += length;

    num_bytes_read -= length;

    if (num_bytes_read > 0) {

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

    }

    char* newline_position;

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

      //if no newline is 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[pool_index] == READ_BUFFER_SIZE)) {

        read_buffer_size[pool_index] = 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[pool_index])+1;

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

      // of the read buffer

      if (command_length > read_buffer_size[pool_index]) {

        break;

      }

      memcpy(temporary_command_buffer, read_buffer[pool_index], 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[pool_index], read_buffer[pool_index]+command_length, read_buffer_size[pool_index] - command_length);

      read_buffer_size[pool_index] -= command_length;

      if (command_length > MAX_COMMAND_LEN) {

        fprintf(stderr, "Command was too long.  Tossing command out.\n");

        break;

      }

      Command command(this, colonet_server);

      if (command.parse_command(temporary_command_buffer, pool_index) != 0) {

        fprintf(stderr, "Error parsing command\n");

        break;

      }

    }

  }

  return 0;

}

/**

 * @brief This function takes data out of the write buffer for a client and tries to actually send it to the client

 *

 * @param pool_index The index in the connection pool of the client to write to

 * @param client_file_descriptor The file descriptor to write out on

 *

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

 */

int ConnectionPool::write_data(int pool_index, int client_file_descriptor) {

  if (write_buffer_size[pool_index] == 0) {

    return 0;

  }

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

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

  write_buffer_size[pool_index] -= sent;

  return 0;

}