/branches/lib_additions/code/projects/colonet/ColonetServer/ConnectionPool.cpp - Diff - Colony - Robotics Club

Revision 79

tried to merge lib_additions again...

+     *
      * @return void
      */
     //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) {
       if (listen_socket < 0)
         return;
       FD_SET(listen_socket, &ready_set);
+    }
     /**
      * @todo Since the listen socket is now a member of the class, the first parameter can be removed
      * @todo Does the select timeout need to be passed in?  or can it be specified in the method?
+     *
      * @brief Find out what file descriptors are ready to write to and read from
+     *
      * @param listen_socket The socket to listen on
-...
+     *
      * @return 0
      */
     int ConnectionPool::perform_select(int listen_socket, struct timeval * select_timeout) {
     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);
       number_clients_ready = select(max_file_descriptor+1, &(read_set), &(write_set), NULL, &select_timeout);
       if (number_clients_ready < 0) {
         perror(__FUNCTION__);
+      }
       return 0;
+    }
-...
       write_set = new_set;
+    }
     //TODO: write a function to write data into the write buffers
     //TODO: fix names of variables to obey new style
     //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 cnhar int_tokens[MAX_TOKENS];
       int numTokens = 0;
       char* endptr = NULL;
       int commandID;
       unsigned char int_tokens[MAX_TOKENS];
       int number_tokens = 0;
       char* end_pointer = NULL;
       int command_id;
       int i;
       unsigned char args[PACKET_DATA_LEN];
       unsigned char arguments[PACKET_DATA_LEN];
       memset(args, 1, PACKET_DATA_LEN);
       memset(arguments, 1, PACKET_DATA_LEN);
       if (!command) {
         return -1;
-...
         return -1;
+      }
       if ((numTokens = tokenize_command(command, tokens)) < 0) {
       if ((number_tokens = tokenize_command(command, tokens)) < 0) {
         return -1;
+      }
       //the 10 in the function call indicates number is base 10
       commandID = strtol(tokens[0], &endptr, 10);
       command_id = strtol(tokens[0], &end_pointer, 10);
       if (!endptr || *endptr != '\0') {
       if (!end_pointer || *end_pointer != '\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;
       if (command_id == SEND_TO_ROBOT) {
         int number_int_tokens = number_tokens;
         /* Convert tokens to ints */
         for (i = ROBOT_COMMAND_OFFSET; i < numIntTokens; i++) {
         // Convert tokens to ints
         for (i = ROBOT_COMMAND_OFFSET; i < number_int_tokens; i++) {
           int_tokens[i-ROBOT_COMMAND_OFFSET] = atoi(tokens[i]);
+        }
         if (commandID == REQUEST_FROM_ROBOT) {
         /* we removed the request from robot constant
         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;
             numIntTokens++;
             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 args buffer with args */
         for (i = ROBOT_COMMAND_LEN; i < numIntTokens-ROBOT_COMMAND_OFFSET; i++) {
           args[i-ROBOT_COMMAND_LEN] = int_tokens[i];
         // 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, numIntTokens) < 0) {
         // 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, args)\n",
         // 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], args);
         wireless->send(int_tokens[0], int_tokens[1], int_tokens[2], arguments);
       } else if (command_id == REQUEST_FROM_SERVER) {
         if (number_tokens < 2)
           return -1;
         end_pointer=NULL;
         int second_token = strtol(tokens[1], &end_pointer, 10);
         if (!end_pointer || *end_pointer != '\0') {
           printf("There was an error converting second token into a number.\n");
           return -1;
+        }
         if (second_token == REQUEST_BOM_MATRIX) {
           //TODO: rename to indicate its actually the response message
           char bom_matrix_buffer[MAX_RESPONSE_LEN];
           char temp_bom_matrix_buffer[MAX_RESPONSE_LEN];
           //TODO: change after we start keeping track of bom matrix
           int number_robots = rand()%10;
           int bom_matrix[number_robots][number_robots];
           for (int ii = 0; ii < number_robots; ii++) {
             for (int j = 0; j < number_robots; j++) {
               //do this to generate some -1 values which mean they can't see each other
               int matrix_value = rand()%(number_robots+1)-1;
               bom_matrix[ii][j] = matrix_value;
+            }
+          }
           printf("number of robots is %d\n", number_robots);
           //TODO: separate parameters with spaces
           //TODO: make this better
           //TODO: make sure I don't need to do MAX_RESPONSE_LENGTH-1
           snprintf(bom_matrix_buffer,MAX_RESPONSE_LEN, "%d %d %d", RESPONSE_TO_CLIENT_REQUEST, REQUEST_BOM_MATRIX, number_robots);
           for (int ii = 0; ii < number_robots; ii++) {
             for (int j = 0; j < number_robots; j++) {
               //TODO: don't use strcpy
               strcpy(temp_bom_matrix_buffer, bom_matrix_buffer);
               //TODO: put length checking in here so array doesn't go out of bounds
               //TODO: maybe use strncat?
               printf("Buffer is %s\n", bom_matrix_buffer);
               strcat(temp_bom_matrix_buffer," %d");
               snprintf(bom_matrix_buffer, MAX_RESPONSE_LEN, temp_bom_matrix_buffer, bom_matrix[ii][j]);
+            }
+          }
           strcat(bom_matrix_buffer,"\n");
           write_to_client(pool_index, bom_matrix_buffer, strlen(bom_matrix_buffer));
           printf("Sending %s", bom_matrix_buffer);
         } else {
           char * my_current_message = "Hi, how are you?\n";
           printf("Sending %s\n", my_current_message);
           write_to_client(pool_index, my_current_message, strlen(my_current_message));
+        }
+      }
       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* nextToken = command;
       char* endToken = NULL;
       int numTokens = 0;
       char* next_token = command;
       char* end_token = NULL;
       int number_tokens = 0;
       if (!command) {
         return -1;
+      }
       while ((endToken = strstr(nextToken, " "))) {
         *endToken = '\0';
       while ((end_token = strstr(next_token, " "))) {
         *end_token = '\0';
         if (strlen(nextToken) > MAX_TOKEN_SIZE-1) {
         if (strlen(next_token) > MAX_TOKEN_SIZE-1) {
           return -1;
+        }
         strcpy(tokens[numTokens], nextToken);
         strcpy(tokens[number_tokens], next_token);
         numTokens++;
         nextToken = endToken + 1;
         number_tokens++;
         next_token = end_token + 1;
         while (isspace(*nextToken) && *nextToken != '\0') {
           nextToken++;
         while (isspace(*next_token) && *next_token != '\0') {
           next_token++;
+        }
+      }
       if (endToken == NULL && *nextToken != '\0') {
         if (strlen(nextToken) > MAX_TOKEN_SIZE-1) {
       if (end_token == NULL && *next_token != '\0') {
         if (strlen(next_token) > MAX_TOKEN_SIZE-1) {
           return -1;
+        }
         strcpy(tokens[numTokens], nextToken);
         strcpy(tokens[number_tokens], next_token);
         numTokens++;
         number_tokens++;
+      }
       return numTokens;
       return number_tokens;
+    }
     /** @brief checks a list of tokens to see if it's valid
     /**
      * @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 numTokens) {
       if (numTokens > 3 + PACKET_DATA_LEN) {
     int ConnectionPool::check_tokens(unsigned char* tokens, int number_tokens) {
       if (number_tokens > 3 + PACKET_DATA_LEN) {
         /* Too many tokens */
         return -1;
+      }
       if (numTokens < 3) {
       if (number_tokens < 3) {
         /* Not enough tokens */
         return -1;
+      }

Also available in: Unified diff

Project

General

Profile

Colony

Revision 79