Colony

    int client_file_descriptor = client_file_descriptor_array[i];

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

	i--;

	continue;

      write_data(i, client_file_descriptor);

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;

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

    return DECREMENT_INDEX_COUNTER;

  }

  while (num_bytes_read > 0) {

    length = num_bytes_read;

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

      length = READ_BUFFER_SIZE - read_buffer_size[pool_index];

    }

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

    }

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

    char* newline_position;

    while ((newline_position = strstr(read_buffer[pool_index], "\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[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) {

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

	break;

      }

      Command command(this);

      if (command.parse_command(temporary_command_buffer, pool_index) < 0) {

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

	break;

      }

    }

  }

  return 0;

}

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;

}