Colony

/**

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

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

}

ConnectionPool::~ConnectionPool() {

}

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;

}

int ConnectionPool::remove_client(int client_file_descriptor) {

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

    return ERROR_INVALID_CLIENT_DESCRIPTOR;

  }

  int clientfd = client_file_descriptor_array[client_file_descriptor];

  if (FD_ISSET(clientfd, &ready_set)) {

    FD_CLR(clientfd, &ready_set);

  }

  if (FD_ISSET(clientfd, &read_set)) {

    FD_CLR(clientfd, &read_set);

  }

  if (FD_ISSET(clientfd, &write_set)) {

    FD_CLR(clientfd, &write_set);

  }

  free(read_buffer[client_file_descriptor]);

  free(write_buffer[client_file_descriptor]);

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

    client_file_descriptor_array[client_file_descriptor] = client_file_descriptor_array[client_file_descriptor+1];

    read_buffer[client_file_descriptor] = read_buffer[client_file_descriptor+1];

    read_buffer_size[client_file_descriptor] = read_buffer_size[client_file_descriptor+1];

    write_buffer[client_file_descriptor] = write_buffer[client_file_descriptor+1];

    write_buffer_size[client_file_descriptor] = write_buffer_size[client_file_descriptor+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;

}

//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?

//TODO: give variables a better name

int ConnectionPool::check_clients(ColonetWireless * wireless) {

  char temp[READ_BUFFER_SIZE];

  char tempCommand[READ_BUFFER_SIZE+1];

  int i;

  int client_file_descriptor;

  int n;

  int len;

  int sent;

  int commandLen;

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

    client_file_descriptor = client_file_descriptor_array[i];

    if (FD_ISSET(client_file_descriptor, &read_set)) {

      n = read(client_file_descriptor, temp, READ_BUFFER_SIZE);

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

        remove_client(i);

        i--;

        continue;

      }

      while (n > 0) {

        len = n;

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

          len = READ_BUFFER_SIZE - read_buffer_size[i];

        }

        memcpy(read_buffer[i]+read_buffer_size[i], temp, len);

        read_buffer_size[i] += len;

        n -= len;

        if (n > 0) {

          memmove(temp, temp+len, READ_BUFFER_SIZE - len);

        }

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

        char* newLine;

        while ((newLine = 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 && (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) {

            break;

          }

          commandLen = (newLine - read_buffer[i])+1;

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

          // of the read buffer

          if (commandLen > read_buffer_size[i]) {

            break;

          }

          memcpy(tempCommand, read_buffer[i], commandLen);

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

          tempCommand[commandLen-1] = '\0';

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

          if (isspace(tempCommand[commandLen-2])) {

            tempCommand[commandLen-2] = '\0';

          }

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

          read_buffer_size[i] -= commandLen;

          if (commandLen > MAX_COMMAND_LEN) {

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

            break;

          }

          if (parse_command(tempCommand, 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;

}

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;

}

//TODO: put error checking on listen_socket to make sure its a valid socket

void ConnectionPool::set_listen_socket_in_ready_set(int listen_socket) {

  FD_SET(listen_socket, &ready_set);

}

int ConnectionPool::perform_select(int listen_socket, struct timeval * select_timeout) {

  read_set = ready_set;

  write_set = ready_set;

  //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);

  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

//TODO: fix names of variables to obey new style

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 numTokens = 0;

  char* endptr = NULL;

  int commandID;

  int i;

  unsigned char args[PACKET_DATA_LEN];

  memset(args, 1, PACKET_DATA_LEN);

  if (!command) {

    return -1;

  }

  if (pool_index < 0) {

    return -1;

  }

  if (pool_index >= next_available_slot) {

    return -1;

  }

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

    return -1;

  }

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

  commandID = strtol(tokens[0], &endptr, 10);

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

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

    return -1;

  }

  if (commandID == SEND_TO_ROBOT || REQUEST_FROM_ROBOT) {

    int numIntTokens = numTokens;

    /* Convert tokens to ints */

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

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

    }

    if (commandID == REQUEST_FROM_ROBOT) {

      if (i < MAX_TOKENS) {

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

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

        }

        int_tokens[3] = pool_index;

        numIntTokens++;

      } 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 args buffer with args */

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

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

    }

    /* Check the tokens */

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

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

      return 0;

    }

    /* Send packet to robot */

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

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

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

  }

  return 0;

}

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

  char* nextToken = command;

  char* endToken = NULL;

  int numTokens = 0;

  if (!command) {

    return -1;

  }

  while ((endToken = strstr(nextToken, " "))) {

    *endToken = '\0';

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

      return -1;

    }

    strcpy(tokens[numTokens], nextToken);

    numTokens++;

    nextToken = endToken + 1;

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

      nextToken++;

    }

  }

  if (endToken == NULL && *nextToken != '\0') {

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

      return -1;

    }

    strcpy(tokens[numTokens], nextToken);

    numTokens++;

  }

  return numTokens;

}

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

 *

 * @return 0 if tokens is valid

 */

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

  if (numTokens > 3 + PACKET_DATA_LEN) {

    /* Too many tokens */

    return -1;

  }

  if (numTokens < 3) {

    /* Not enough tokens */

    return -1;

  }

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

    /* Invalid message type */

    return -1;

  }

  return 0;

}