/ - Diff - Colony - Robotics Club

Revision 58

Added by Jason knichel over 16 years ago

got rid of some TODO's

       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);
       int perform_select(int listen_socket);
       int is_socket_ready_to_read(int socket);
       int is_socket_ready_to_write(int socket);
-...
       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);
       int check_tokens(unsigned char* tokens, int number_tokens);
     };
     #endif

     //TODO: rename either the file or the class so they match
     /**
+     *
      *  @author Jason Knichel
-...
       struct tm getCurrentTime();
       FILE * logFile;
     };
     #endif

+     *
      * @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);
       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 char int_tokens[MAX_TOKENS];
       int numTokens = 0;
       char* endptr = NULL;
       int commandID;
       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 || REQUEST_FROM_ROBOT) {
         int number_int_tokens = number_tokens;
         /* Convert tokens to ints */
         for (i = ROBOT_COMMAND_OFFSET; i < numIntTokens; i++) {
         for (i = ROBOT_COMMAND_OFFSET; i < number_int_tokens; i++) {
           int_tokens[i-ROBOT_COMMAND_OFFSET] = atoi(tokens[i]);
+        }
         if (commandID == REQUEST_FROM_ROBOT) {
         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");
-...
+          }
+        }
         /* 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) {
         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",
         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);
+      }
       return 0;
-...
      * @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
+     *
      * @param tokens The tokens to check
      * @param numTokens The number of tokens contained in the tokens parameter
      * @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;
+      }

         int accept_socket = 0;
         struct sockaddr_in client_addr;
         socklen_t client_addr_size = sizeof(client_addr);
         struct timeval select_timeout;
         memset(&select_timeout, 0, sizeof(select_timeout));
         log_message("Server initialized.  About to start listening for connections");
         while(1) {
           connection_pool.perform_select(listen_socket, &select_timeout);
           connection_pool.perform_select(listen_socket);
           //either no descriptors are ready or there was an error
           //TODO: check for specific errors

Also available in: Unified diff

Project

General

Profile

Colony

Revision 58