/trunk/code/projects/colonet/server/ConnectionPool.cpp - Diff - Colony - Robotics Club

Revision 642

Added by Jason knichel about 16 years ago

added more comments

     /**
      * @brief The default constructor for ConnectionPool
+     *
      * @param cs The colonet server instance to use with this class
      */
     ConnectionPool::ConnectionPool(ColonetServer* cs) {
       colonet_server = cs;
-...
         max_file_descriptor = client_file_descriptor;
+      }
     	//add the new file descriptor to the set of ready descriptors
       FD_SET(client_file_descriptor, &ready_set);
       int next_slot = next_available_slot;
     	//put the new client into the connection pool
       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++;
-...
       int client_file_descriptor = client_file_descriptor_array[pool_index];
     	//clear this client from all lists of file descriptors
       if (FD_ISSET(client_file_descriptor, &ready_set)) {
         FD_CLR(client_file_descriptor, &ready_set);
+      }
-...
         FD_CLR(client_file_descriptor, &write_set);
+      }
     	//free up the resources this client used
       free(read_buffer[pool_index]);
       free(write_buffer[pool_index]);
     	//shift the other clients down
       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];
-...
       next_available_slot--;
       int temp_max_file_descriptor = 0;
     	//figure out the newest max file descriptor
       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];
-...
       for (i = 0; i < next_available_slot; i++) {
         int client_file_descriptor = client_file_descriptor_array[i];
     		//check to see if this client is ready to be read from
         if (FD_ISSET(client_file_descriptor, &read_set)) {
           if (read_data(i, client_file_descriptor) == DECREMENT_INDEX_COUNTER) {
     	i--;
     	continue;
     				i--;
     				continue;
+          }
+        }
     		//check to see if this client is ready to write to
         if (FD_ISSET(client_file_descriptor, &write_set)) {
           write_data(i, client_file_descriptor);
+        }
-...
       if (max_file_descriptor < listen_socket)
         max_file_descriptor = listen_socket;
     	//call select.  select sees if any file descriptor in the read set is ready to be read and modifies the read set.
     	// It sees if any file descriptor in the write set is ready to be written to and modifies the write set.
       number_clients_ready = select(max_file_descriptor+1, &(read_set), &(write_set), NULL, &select_timeout);
       if (number_clients_ready < 0) {
-...
       return 0;
+    }
     /**
      * @return 1 if the socket is ready to be read, 0 otherwise
      */
     int ConnectionPool::is_socket_ready_to_read(int socket) {
       return FD_ISSET(socket, &read_set);
+    }
     /**
      * @return the number of clients that are ready
      */
     int ConnectionPool::get_number_clients_ready() {
       return number_clients_ready;
+    }
     /**
     */
      * @brief Reads data from a particular client and checks to see if it contains a command and parses that command
      *   or buffers the data assuming the rest of the command will be sent later
+     *
      * @param pool_index The index in the connection pool of the client to read from
      * @param client_file_descriptor The file descriptor of the client to read from
+     *
      * @return 0 on success, negative error code on error
      */
     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 length;
       int command_length;
     	//read data that the client is trying to send us
       num_bytes_read = read(client_file_descriptor, temporary_buffer, READ_BUFFER_SIZE);
     	//check to see if the client disconnected
       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;
     		//make sure this new data won't overflow the read buffer
         if (length + read_buffer_size[pool_index] > READ_BUFFER_SIZE) {
           length = READ_BUFFER_SIZE - read_buffer_size[pool_index];
+        }
     		//put the newly read data into the read buffer for this client
         memcpy(read_buffer[pool_index]+read_buffer_size[pool_index], temporary_buffer, length);
         read_buffer_size[pool_index] += length;
         num_bytes_read -= length;
-...
           memmove(temporary_buffer, temporary_buffer+length, READ_BUFFER_SIZE - length);
+        }
         //printf("read_data: 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
           //if no newline is 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
-...
       return 0;
+    }
     /**
      * @brief This function takes data out of the write buffer for a client and tries to actually send it to the client
+     *
      * @param pool_index The index in the connection pool of the client to write to
      * @param client_file_descriptor The file descriptor to write out on
+     *
      * @return 0 on success, negative error code on failure
      */
     int ConnectionPool::write_data(int pool_index, int client_file_descriptor) {
       if (write_buffer_size[pool_index] == 0) {
         return 0;

Also available in: Unified diff

Project

General

Profile

Colony

Revision 642