/ - Diff - Colony - Robotics Club

     #include "includes/ConnectionPool.h"
     /* Globals */
     static ColonetWireless* wireless;
     extern ColonetWireless* wireless;
     extern ConnectionPool * connection_pool;
-...
         printf("response\n");
         int dest = (int)(pkt->msg_dest);
         if (dest < connection_pool->get_next_available_slot())
+        {
           char buffer[WRITE_BUFFER_SIZE];
         char buffer[WRITE_BUFFER_SIZE];
           int value = (int)(pkt->data[0]);
           snprintf(buffer, WRITE_BUFFER_SIZE, "%d\n", value);
         int value = (int)(pkt->data[0]);
         snprintf(buffer, WRITE_BUFFER_SIZE, "%d\n", value);
           int len = strlen(buffer);
           connection_pool->write_to_client(dest, buffer, len);
           printf("Put data in write buffer for client.\n");
+        }
         else
+        {
           printf("The robot wanted to pass the data to a client not in our pool.\n");
         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
+      {
-...
       return 0;
+    }
     int initWireless()
+    {
       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;
+    }
     void send_wireless_message(unsigned char msg_dest, unsigned char msg_type,
                               unsigned char msg_code, unsigned char* data) {
       wireless->send(msg_dest, msg_type, msg_code, data);
+    }

     #include <sys/select.h>
     #include <colonet_wireless.h>
     #define MAX_TOKENS 15
     #define MAX_TOKEN_SIZE 30
-...
     #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
-...
       int add_client(int client_file_descriptor);
       int remove_client(int client_file_descriptor);
       int check_clients();
       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, struct timeval * select_timeout);
-...
       char * write_buffer[MAX_CONNECTIONS];
       int write_buffer_size[MAX_CONNECTIONS];
       int parse_command(char* command, int pool_index);
       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 numTokens);
     };

     private:
       ConnectionPool connection_pool;
       Log logger;
       int initialize_wireless();
     };
     #endif

     //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() {
     int ConnectionPool::check_clients(ColonetWireless * wireless) {
       char temp[READ_BUFFER_SIZE];
       char tempCommand[READ_BUFFER_SIZE+1];
       int i;
-...
                 break;
+              }
               if (parse_command(tempCommand, i) < 0) {
               if (parse_command(tempCommand, i, wireless) < 0) {
                 printf("There was an error parsing command\n");
                 break;
+              }
-...
+    }
     int ConnectionPool::write_to_client(int pool_index, char * message, int length) {
       //TODO: put error checking on pool_index, message, 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 -1;
           return ERROR_NOT_ENOUGH_ROOM;
+        }
       memcpy(write_buffer[pool_index], message, length);
-...
     //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) {
     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;
-...
         /* Send packet to robot */
         fprintf(stderr, "Calling wireless->send(%d, %d, %d, args)\n",
                 int_tokens[0], int_tokens[1], int_tokens[2]);
         send_wireless_message(int_tokens[0], int_tokens[1], int_tokens[2], args);
         wireless->send(int_tokens[0], int_tokens[1], int_tokens[2], args);
+      }
       return 0;

     #define LOG_BUFFER_LENGTH 128
     ConnectionPool * connection_pool;
     ColonetWireless* wireless;
     ColonetServer::ColonetServer(): logger("logFile.txt") {
+    }
-...
       if (initConnection(optionsG.listen_port) < 0)
         return -1;
       if (initWireless() < 0) {
       if (initialize_wireless() < 0) {
         fprintf(stderr, "%s: initWireless failed\n", __FUNCTION__);
         return -1;
+      }
-...
       return 0;
+    }
     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;
+    }
     int ColonetServer::log_error(char * error_message) {
       return logger.logMessage(LOG_TYPE_ERROR, error_message);
+    }
-...
+          }
           if (connection_pool.check_clients() < 0) {
           if (connection_pool.check_clients(wireless) < 0) {
             printf("\tThere was an error trying to update the clients.");
             continue;
+          }
-...
     ConnectionPool * ColonetServer::get_connection_pool_pointer() {
       return &connection_pool;
+    }

Project

General

Profile

Colony

Revision 22