Colony

# ColonetServer makefile

CC = g++

CFLAGS = -Wall -Wshadow -Wextra -g

COLONETCPPFILES = ColonetServer.cpp client.cpp ConnectionPool.cpp

COLONETCPPOBJECTS = $(COLONETCPPFILES:.cpp=.o)

COLONETFILES = options.c

COLONETOBJECTS = $(COLONETFILES:.c=.o)

LOGGINGFILES = Log.cpp

LOGGINGOBJECTS = $(LOGGINGFILES:.cpp=.o)

VPATH = ../lib:../lib/colonet_wireless

INCLUDE_DIRS = ../lib/colonet_wireless ../lib

LIBRARY_DIRS = ../lib

#this takes the include directory and puts a -I in front of each directory name before being used in a gcc statement

INCLUDE_DIRS_FOR_GCC = $(patsubst %, -I %, $(INCLUDE_DIRS))

#this takes the library directory and puts a -L in front of each directory name so it can be used in a gcc statement

LIBRARY_DIRS_FOR_GCC = $(patsubst %,-L%, $(LIBRARY_DIRS))

.PHONY : all clean

all: ColonetServer

#TODO: make a variable that handles the multiple -I blah stuff so it doesn't have to be written on every line

#TODO: make use of VPATH or vpath directive to point at lib directory and then use -lcolonet_wireless

ColonetServer: $(COLONETCPPFILES) $(COLONETFILES) $(LOGGINGFILES) -lcolonet_wireless

	$(CC) $(CFLAGS) -c $(COLONETFILES) $(INCLUDE_DIRS_FOR_GCC)

	$(CC) $(CFLAGS) -c $(COLONETCPPFILES) $(INCLUDE_DIRS_FOR_GCC)

	$(CC) $(CFLAGS) -c $(LOGGINGFILES) $(INCLUDE_DIRS_FOR_GCC)

	$(CC) $(CFLAGS) $(COLONETOBJECTS) $(COLONETCPPOBJECTS) $(LOGGINGOBJECTS) $(LIBRARY_DIRS_FOR_GCC) -lpthread -lcolonet_wireless $(INCLUDE_DIRS_FOR_GCC) -o $@

clean: 

	rm -rf *.o ColonetServer

/**

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

}

/** 

 * @file ColonetServer.cpp

 *

 * @brief colonet_server - primary server application for Colonet

 *

 * @author Jason Knichel

 * @author Eugene Marinelli

 * @date 10/31/06

 */

#include <colonet_wireless.h>

#include <sys/select.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <errno.h>

#include <arpa/inet.h>

#include <fcntl.h>

#include <colonet_wireless.h>

#include "includes/ColonetServer.h"

#include "includes/ConnectionPool.h"

#include "includes/client.h"

#include "includes/options.h"

#include "includes/Log.h"

#define LISTEN_BACKLOG 5

#define LOG_BUFFER_LENGTH 128

ConnectionPool * connection_pool;

/**

 * @brief Default constructor for ColonetServer

 */

ColonetServer::ColonetServer(): logger("logFile.txt") {

  listen_socket = 0;

}

/**

 * @brief Destructor for ColonetServer

 */

ColonetServer::~ColonetServer() {

}

/**

 * @brief Initializes the various elements needed for the server to run

 *

 * @param argc The number of command line arguments passed to the program

 * @param argv The command line arguments passed to the program

 *

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

 */

int ColonetServer::initialize_server(int argc, char * argv[]) {

  printf("Initializing Server...\n");

  parseCmdLine(argc, argv);

  if (initialize_connection(optionsG.listen_port) < 0) {

    return -1;

  }

  if (initialize_wireless() < 0) {

    fprintf(stderr, "%s: initWireless failed\n", __FUNCTION__);

    return -1;

  }

  return 0;

}

/**

 * @brief Starts the server listening on the socket that was opened for listening

 *

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

 */

int ColonetServer::start_listening() {

  if (listen(listen_socket, LISTEN_BACKLOG) < 0) {

    log_error("\t\nThere was an error telling the socket to "

              "listen for connections from clients.  Terminating Server...\n");

    return -1;

  }

  return 0;

}

/**

 * @brief Logs an error message to the log file

 */

int ColonetServer::log_error(char * error_message) {

  return logger.logMessage(LOG_TYPE_ERROR, error_message);

}

/**

 * @brief Logs a message to the log file

 */

int ColonetServer::log_message(char * message) {

  return logger.logMessage(LOG_TYPE_MESSAGE, message);

}

/**

 * @brief Starts the server running (starts an infinite loop)

 */

int ColonetServer::run_server() {

  connection_pool.set_listen_socket_in_ready_set(listen_socket);

  //TODO: why is all of this in that if statement and not just conn_pool.maxfd = listen_socket ?

  if (listen_socket > connection_pool.get_max_file_descriptor()) {

    connection_pool.set_max_file_descriptor(listen_socket);

    int accept_socket = 0;

    struct sockaddr_in client_addr;

    socklen_t client_addr_size = sizeof(client_addr);

    log_message("Server initialized.  About to start listening for connections");

    while(1) {

      connection_pool.perform_select(listen_socket);

      //either no descriptors are ready or there was an error

      if (connection_pool.get_number_clients_ready() <= 0) {

        continue;

      }

      if (connection_pool.is_socket_ready_to_read(listen_socket)) {

        printf("Something is trying to connect...\n");

        if ((accept_socket = accept(listen_socket, (struct sockaddr*) &client_addr, &client_addr_size)) < 0) {

          if (errno == EMFILE) {

            printf("\tWhen attempting to accept a connection, "

                   "reached the per process limit of file descriptors."

                   "  Dropping the new connection.\n");

            continue;

          } else {

            printf("\tThere was an error when attempting to accept a connection");

          }

          continue;

        }

        char log_buffer[LOG_BUFFER_LENGTH];

        snprintf(log_buffer, LOG_BUFFER_LENGTH, "Client at address %s attempting to connect.", 

                 inet_ntoa(client_addr.sin_addr));

        logger.logMessage(LOG_TYPE_CONNECT, log_buffer);

        if (connection_pool.add_client(accept_socket) < 0) {

          printf("\tThere was an error when trying to add a client to the connection pool.");

          continue;

        }

        snprintf(log_buffer, LOG_BUFFER_LENGTH, "Client at address %s successfully added to connection pool.", 

                 inet_ntoa(client_addr.sin_addr));

        logger.logMessage(LOG_TYPE_CONNECT, log_buffer);

      }

      if (connection_pool.check_clients(wireless) < 0) {

        printf("\tThere was an error trying to update the clients.");

        continue;

      }

    }

  }

  return 0;

}

/**

 * @todo This method is here because the wireless message handler has a dependency on the connection_pool

 *  This should be removed when that dependency is broken

 *

 * @return A pointer to the connection pool

 */

ConnectionPool * ColonetServer::get_connection_pool_pointer() {

  return &connection_pool;

}

/**

 * @brief Initializes the wireless

 *

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

 */

int ColonetServer::initialize_wireless() {

  char* log_filename = NULL;

  if (optionsG.logging_enabled) {

    log_filename = optionsG.log_filename;

  }

  wireless = new ColonetWireless(optionsG.wireless_port, 

                                 wirelessMessageHandler, log_filename, 

                                 /*!optionsG.listener_mode*/false, true);

  //Note: last arg set to true ignores token ring;  in general, this should

  //probably be false (changed for demo purposes)

  if (!wireless->run_listener_thread()) {

    return -1;

  }

  return 0;

}

/**

 * @brief Initialize a connection to listen on

 *

 * @port The port to try to open to listen on

 *

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

 */

int ColonetServer::initialize_connection(int port) {

  printf("Initializing connection that will be used to listen for " 

         "clients...\n");

  int options = 1;

  struct sockaddr_in my_address;

  //get a socket fd

  if ((listen_socket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

    printf("\tThere was an error creating a socket\n");

    return -1;

  }

  //set up the address struct

  memset(&my_address,'\0',sizeof(my_address));

  my_address.sin_family = AF_INET;

  my_address.sin_addr.s_addr = htonl(INADDR_ANY);

  my_address.sin_port = htons(port);

  setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, &options, sizeof(options));

  //get the current socket options

  if ((options = fcntl(listen_socket, F_GETFL)) < 0) {

    printf("\tThere was an error getting the socket options.\n");

    return -1;

  }

  //set the socket to non blocking

  options = (options | O_NONBLOCK);

  if (fcntl(listen_socket, F_SETFL, options) < 0) {

    printf("\tThere was an error setting the socket to be non blocking.\n");

    return -1;

  }

  //bind the socket to listen on the specified port

  if (bind(listen_socket, (struct sockaddr *) &my_address, sizeof(my_address)) < 0) {

    printf("\tThere was an error binding the socket\n");

    return -1;

  }

  return 0;

}

/**

 * @brief The main function of the server

 *

 * @param argc The number of command line arguments passed to the program

 * @param argv The command line arguments passed to the program

 *

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

 */

int main(int argc, char** argv) {

  ColonetServer colonet_server;

  connection_pool = colonet_server.get_connection_pool_pointer();

  if (colonet_server.initialize_server(argc, argv) < 0) {

    colonet_server.log_error("\t\nThere was an error initializing the server. "

                             "Terminating server...\n");

    return -1;

  }

  if (colonet_server.start_listening() < 0) {

    return -1;

  }

  colonet_server.run_server();

  return 0;

}

//this is old code that was commented out that I didn't want to delete yet

/*

int parseCommandLine(int argc, char * argv[], commandParams_t * params)

{

  printf("Parsing Command Line...\n");

  if (!params)

    return -1;

  //if no command line parameters were specified, set to defaults

  if (argc == 1) {

    printf("No port was specified for listening for client connections."

           "  Defaulting to %d\n", DEFAULTPORT);

    params->listenPort = DEFAULTPORT;

  }

  if (!argv)

    return -1;

  int i;

  for (i = 1; i < argc; i++) {

    char * temp = argv[i];

    if (temp[0] != '-')

      {

        printUsage(argv[0]);

        return -1;

      }

    switch(temp[1])

      {

      case 'h': printUsage(argv[0]);

        break;

      case 'p': 

        {

          if (i >= argc-1)

            {

              printUsage(argv[0]);

              return -1;

            }

          i++;

          char * portString = argv[i];

          char * endptr = NULL;

          int port = strtol(portString, &endptr, 10);

          if (*endptr != '\0')

            {

              printf("Invalid port specified...%s, %d\n", endptr, port);

              return -1;

            }

          if (port < SMALLEST_POSS_LISTEN_PORT)

            {

              printf("You cannot listen on a port less than %d.\n",

                     SMALLEST_POSS_LISTEN_PORT);

              return -1;

            }

          params->listenPort = port;

          printf("Setting port to listen on to %d.\n", params->listenPort);

        }

        break;

      default: printUsage(argv[0]);

        return -1;

        break;

      }

  }

  return 0;

}

*/

/**

 * @author Jason Knichel

 * @date 7/22/07

 */

#ifndef CONNECTION_POOL_H

#define CONNECTION_POOL_H

#include <sys/select.h>

#include <colonet_wireless.h>

#define MAX_TOKENS 15

#define MAX_TOKEN_SIZE 30

#define ROBOT_COMMAND_OFFSET 1

#define ROBOT_COMMAND_LEN    3

#define ERROR_INVALID_CLIENT_DESCRIPTOR -1

#define ERROR_TOO_MANY_CLIENTS          -2

#define ERROR_ALLOCATING_MEMORY         -3

#define ERROR_NOT_ENOUGH_ROOM           -4

#define ERROR_INVALID_COMMAND           -5

#define ERROR_INVALID_CLIENT_ID         -6

#define ERROR_INVALID_MESSAGE           -7

#define ERROR_INVALID_MESSAGE_LENGTH    -8

#define MAX_CONNECTIONS 250

#define READ_BUFFER_SIZE 1024

#define WRITE_BUFFER_SIZE 1024

class ConnectionPool {

public:

  ConnectionPool();

  ~ConnectionPool();

  int add_client(int client_file_descriptor);

  int remove_client(int pool_index);

  int check_clients(ColonetWireless * wireless);

  int write_to_client(int pool_index, char * message, int length);

  void set_listen_socket_in_ready_set(int listen_socket);

  int perform_select(int listen_socket);

  int is_socket_ready_to_read(int socket);

  int is_socket_ready_to_write(int socket);

  int get_max_file_descriptor();

  void set_max_file_descriptor(int new_max_file_descriptor);

  int get_next_available_slot();

  int get_number_clients_ready();

  void set_number_clients_ready(int new_number_clients_ready);

  fd_set get_ready_set();

  fd_set get_read_set();

  void set_read_set(fd_set new_set);

  fd_set get_write_set();

  void set_write_set(fd_set new_set);

private:

  int max_file_descriptor;

  int next_available_slot;

  int number_clients_ready;

  fd_set ready_set;

  fd_set read_set;

  fd_set write_set;

  int client_file_descriptor_array[MAX_CONNECTIONS];

  char * read_buffer[MAX_CONNECTIONS];

  int read_buffer_size[MAX_CONNECTIONS];

  char * write_buffer[MAX_CONNECTIONS];

  int write_buffer_size[MAX_CONNECTIONS];

  int parse_command(char* command, int pool_index, ColonetWireless * wireless);

  int tokenize_command(char* command, char tokens[MAX_TOKENS][MAX_TOKEN_SIZE]);

  int check_tokens(unsigned char* tokens, int number_tokens);

};

#endif

/**

 *

 *  @author Jason Knichel

 *

 */

#ifndef LOGGING_H

#define LOGGING_H

#include <time.h>

#include <stdio.h>

#define LOG_TYPE_START_LOG  0

#define LOG_TYPE_CONNECT    1

#define LOG_TYPE_DISCONNECT 2

#define LOG_TYPE_ERROR      3

#define LOG_TYPE_MESSAGE    4

#define LOG_MAX_TYPE_LENGTH 25

#define LOG_MAX_TIME_LENGTH 64

class Log {

public:

  Log(char * fileName);

  ~Log();

  int logMessage(int type, char * message);

private:

  struct tm getCurrentTime();

  FILE * logFile;

};

#endif

/**

 * @author Jason Knichel

 * @date 9/10/07

 */

#ifndef COLONETSERVER_H

#define COLONETSERVER_H

#include <colonet_wireless.h>

#include "ConnectionPool.h"

#include "Log.h"

class ColonetServer {

public:

  ColonetServer();

  ~ColonetServer();

  int initialize_server(int argc, char * argv[]);

  int start_listening();

  int log_error(char * error_message);

  int log_message(char * message);

  int run_server();

  ConnectionPool * get_connection_pool_pointer();

private:

  ConnectionPool connection_pool;

  Log logger;

  ColonetWireless* wireless;

  int listen_socket;

  int initialize_wireless();

  int initialize_connection(int port);

};

#endif

/**

 * @file options.h

 * @brief Options for ColonetServer

 * @author Eugene Marinelli

 * @date 2/13/07

 */

#ifndef OPTIONS_H

#define OPTIONS_H

#define DEFAULTPORT 10123

#define SMALLEST_POSS_LISTEN_PORT 2000

typedef struct {

  int listen_port;

  char wireless_port[80];

  char log_filename[80];

  bool logging_enabled;

  bool listener_mode;

} ColonetServerOptionsT;

extern ColonetServerOptionsT optionsG;

void parseCmdLine(int argc, char** argv);

#endif

/**

 *

 *  @author Jason Knichel

 *

 */

#ifndef CLIENT_H

#define CLIENT_H

#include <colonet_wireless.h>

int wirelessMessageHandler(ColonetPacket* pkt);

int initWireless(void);

void send_wireless_message(unsigned char msg_dest, unsigned char msg_type, 

                           unsigned char msg_code, unsigned char* data);

#endif

/**

 * @file Logging.cpp

 *

 * @brief This file contains the code to do logging for Colonet

 * 

 * @author Jason Knichel

 *

 */

#include <time.h>

#include <string.h>

#include <stdio.h>

#include "includes/Log.h"

/**

 * @brief Constructor for the Log class

 *

 * @param filename The name of the file to output log statements to

 */

Log::Log(char * filename) {

  printf("Creating log object\n");

  if (!filename) {

    fprintf(stderr, "Provided a null filename when trying to create a log.\n");

    return;

  }

  logFile = fopen(filename, "a"); //open file for appending

  if (!logFile) {

    fprintf(stderr, "Error opening %s as log file.\n", filename);

    return;

  }

  printf("About to log start message.\n");

  logMessage(LOG_TYPE_START_LOG, "Starting server");

}

/**

 * @brief Destructor for the Log class

 */

Log::~Log() {

  if (!logFile)

    fclose(logFile);

}

/**

 * @brief A function to get the current time

 *

 * @return A struct tm that represents the current time

 */

struct tm Log::getCurrentTime() {

  struct tm currTime;

  memset(&currTime, 0, sizeof(struct tm));

  time_t t = time(NULL);

  localtime_r(&t, &currTime);

  return currTime;  

}

/**

 * @brief This method logs a message with the specified type

 *

 * @param type The type of the message to log

 * @param message The message to log

 *

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

 */

int Log::logMessage(int type, char * message) {

  if (!logFile) {

    fprintf(stderr, "Tried to log a message but the file pointer was null.\n");

    return -1;

  }

  if (!message) {

    fprintf(stderr, "Tried to log a null message.\n");

    return -1;

  }

  static char * start_log = "Starting Log";

  static char * connect = "Client Connecting";

  static char * disconnect = "Client Disconnecting";

  static char * error = "Error";

  static char * logGenMessage = "Generic Message";

  char * messageType;

  switch(type) {

  case LOG_TYPE_START_LOG:

    messageType = start_log;

    break;

  case LOG_TYPE_CONNECT:

    messageType = connect;

    break;

  case LOG_TYPE_DISCONNECT:

    messageType = disconnect;

    break;

  case LOG_TYPE_ERROR:

    messageType = error;

    break;

  case LOG_TYPE_MESSAGE:

    messageType = logGenMessage;

    break;

  default:

    fprintf(stderr, "Tried to log a message with an invalid type.\n");

    return -1;

  }

  struct tm currTime = getCurrentTime();

  char buffer[LOG_MAX_TIME_LENGTH];

  asctime_r(&currTime, buffer);

  int len = strlen(buffer);

  buffer[len-1] = '\0'; //remove the newline that is put at the end by asctime_r

  fprintf(logFile, "%s %*s   %s\n", buffer, LOG_MAX_TYPE_LENGTH, messageType, message);

  fflush(logFile);

  return 0;

}

/** @file client.c

 *

 *  @author Jason Knichel

 *  @author Eugene Marinelli

 *

 * @TODO remove dependency on connection_pool

 * @bug Weird segfault when processing tokens

 */

#include <string.h>

#include <stdio.h>

#include <unistd.h>

#include <ctype.h>

#include <errno.h>

#include <colonet_wireless.h>

#include "includes/client.h"

#include "includes/options.h"

#include "includes/ConnectionPool.h"

/* Globals */

extern ConnectionPool * connection_pool;

/* Public functions */

int wirelessMessageHandler(ColonetPacket* pkt)

{

  printf("Received wireless message!!!\n");

  if (!pkt) {

    printf("The packet pointer was null.\n");

    return -1;

  }

  if ((int)pkt->msg_type == COLONET_RESPONSE) {

    printf("response\n");

    int dest = (int)(pkt->msg_dest);

    char buffer[WRITE_BUFFER_SIZE];

    int value = (int)(pkt->data[0]);

    snprintf(buffer, WRITE_BUFFER_SIZE, "%d\n", value);

    int len = strlen(buffer);

    if (connection_pool->write_to_client(dest, buffer, len) == ERROR_INVALID_CLIENT_ID) {

      printf("The robot wanted to pass the data to a client not in the pool.\n");

      return -1;

    }

    printf("Put data in write buffer for client.\n");

  } else {

    printf("not a response\n");

  }

  pkt = 0;

  return 0;

}

/**

 * @file options.c

 *

 * @brief Options for ColonetServer

 *

 * @author Eugene Marinelli

 *

 * @date 2/13/07

 *

 * @bug Usage not written

 */

#include <stdio.h>

#include <getopt.h>

#include <string.h>

#include <stdlib.h>

#include <colonet_defs.h>

#include "includes/options.h"

ColonetServerOptionsT optionsG;

/**

 * @brief Prints the usage of the program

 */

static void printUsage() {

  printf("USAGE:\n");

}

/**

 * @brief Parses the command line arguments

 *

 * @param argc The number of arguments passed to the program

 * @param argv The arguments passed to the program

 *

 * @return Void

 */

void parseCmdLine(int argc, char** argv) {

  int c;

  memset(&optionsG, 0, sizeof(ColonetServerOptionsT));

  if (argc < 2) {

    printf("No port was specified for listening for client connections."

           "  Defaulting to %d\n", DEFAULTPORT);

  }

  /* Defaults */

  optionsG.listen_port = DEFAULTPORT;

  strcpy(optionsG.wireless_port, USB_PORT);

  optionsG.logging_enabled = false;

  optionsG.listener_mode = false;

  /* Parse args */

  while (1) {

    c = getopt(argc, argv, "p:l:w:su");

    if (c == -1) {

      break;

    }

    switch (c) {

    case 'p':

      /* Listen port */

      optionsG.listen_port = atoi(optarg);

      if (optionsG.listen_port < SMALLEST_POSS_LISTEN_PORT) {

        printf("You cannot listen on a port less than %d.\n", 

               SMALLEST_POSS_LISTEN_PORT);

        printf("Setting listener port to %d\n", DEFAULTPORT);

        optionsG.listen_port = DEFAULTPORT;

      }

      break;

    case 'w':

      /* Set wireless port */

      strcpy(optionsG.wireless_port, optarg);

      break;

    case 'l':

      /* Set log filename (and enable logging) */

      strcpy(optionsG.log_filename, optarg);

      optionsG.logging_enabled = true;

      break;

    case 's':

      /* Enable listener mode */

      optionsG.listener_mode = true;

      break;

    case 'u':

      printUsage();

    }

  }

}

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">

<plist version="1.0">

<dict>

	<key>ActivePerspectiveName</key>

	<string>Project</string>

	<key>AllowedModules</key>

	<array>

		<dict>

			<key>BundleLoadPath</key>

			<string></string>

			<key>MaxInstances</key>

			<string>n</string>

			<key>Module</key>

			<string>PBXSmartGroupTreeModule</string>

			<key>Name</key>

			<string>Groups and Files Outline View</string>

		</dict>

		<dict>

			<key>BundleLoadPath</key>

			<string></string>

			<key>MaxInstances</key>

			<string>n</string>

			<key>Module</key>

			<string>PBXNavigatorGroup</string>

			<key>Name</key>

			<string>Editor</string>

		</dict>

		<dict>

			<key>BundleLoadPath</key>

			<string></string>

			<key>MaxInstances</key>

			<string>n</string>

			<key>Module</key>

			<string>XCTaskListModule</string>

			<key>Name</key>

			<string>Task List</string>

		</dict>

		<dict>

			<key>BundleLoadPath</key>

			<string></string>

			<key>MaxInstances</key>

			<string>n</string>

			<key>Module</key>

			<string>XCDetailModule</string>

			<key>Name</key>

			<string>File and Smart Group Detail Viewer</string>

		</dict>

		<dict>

			<key>BundleLoadPath</key>

			<string></string>

			<key>MaxInstances</key>

			<string>1</string>

			<key>Module</key>

			<string>PBXBuildResultsModule</string>

			<key>Name</key>

			<string>Detailed Build Results Viewer</string>

		</dict>

		<dict>

			<key>BundleLoadPath</key>

			<string></string>

			<key>MaxInstances</key>

			<string>1</string>

			<key>Module</key>

			<string>PBXProjectFindModule</string>

			<key>Name</key>

			<string>Project Batch Find Tool</string>

		</dict>

		<dict>

			<key>BundleLoadPath</key>

			<string></string>