Colony

 *       and sends it to the appropriate client

 */

#include <ctype.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "includes/Command.h"

#include "includes/ConnectionPool.h"

}

 * @brief checks a list of tokens to see if it's valid

 *

 * @param tokens The tokens to check

    /* Not enough tokens */

    return -1;

  }

  if (tokens[1] != COLONET_REQUEST && tokens[1] != COLONET_COMMAND) {

    /* Invalid message type */

    return -1;

  memset(arguments, 1, PACKET_DATA_LEN);

  for (i = ROBOT_COMMAND_OFFSET; i < number_int_tokens; i++) {

    int_tokens[i-ROBOT_COMMAND_OFFSET] = atoi(tokens[i]);

  }

  for (i = ROBOT_COMMAND_LEN; i < number_int_tokens-ROBOT_COMMAND_OFFSET; i++) {

    arguments[i-ROBOT_COMMAND_LEN] = int_tokens[i];

  }

  if (check_tokens(int_tokens, number_int_tokens) < 0) {

    fprintf(stderr, "%s: Error - Invalid robot command/request.\n", __FUNCTION__);

    return -1;

  }

  fprintf(stderr, "Calling colonet_wl_send(%d, %d, %d, arguments)\n", int_tokens[0], int_tokens[1], int_tokens[2]);

  colonet_wl_send(pool_index, int_tokens[0], (ColonetMessageType)int_tokens[1], int_tokens[2], arguments);

    printf("There was an error converting second token into a number.\n");

    return -1;

  }

  if (second_token == REQUEST_BOM_MATRIX) {

    if (parse_request_bom_matrix(pool_index)) {

      return -1;

int Command::parse_request_bom_matrix(int pool_index) {

  char response_bom_matrix_buffer[MAX_RESPONSE_LEN];

  char temp_bom_matrix_buffer[MAX_RESPONSE_LEN];

  if (!connection_pool) {

    return -1;

  }

      bom_matrix[ii][j] = ((ii*3+j)%17)-1;

    }

  }

  printf("number of robots is %d\n", number_robots);

  //TODO: make this better

  char xbee_id_buffer[MAX_RESPONSE_LEN];

  char temp_xbee_id_buffer[MAX_RESPONSE_LEN];

  if (!connection_pool) {

    return -1;

  }

  snprintf(xbee_id_buffer, MAX_RESPONSE_LEN, "%d %d %d", RESPONSE_TO_CLIENT_REQUEST, REQUEST_XBEE_IDS, number_robots);

  printf("number of robots is %d\n", number_robots);

  for (int ii = 0; ii < number_robots; ii++) {

 * @file Log.cpp

 *

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

 * @author Jason Knichel

 *

 */

struct tm Log::get_current_time() {

  struct tm current_time;

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

  time_t t = time(NULL);

  localtime_r(&t, &current_time);

}

/**

    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";

  }

  struct tm current_time = get_current_time();

  char buffer[LOG_MAX_TIME_LENGTH];

  asctime_r(&current_time, buffer);

  int len = strlen(buffer);

 * @brief An easier way to log a normal message

 *

 * @param message The message to log as a normal message

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

 */

int Log::log_message(char *  message) {

#include "includes/ConnectionPool.h"

#include "includes/Command.h"

#include "../lib/colonet_defs.h"

#include <colonet_wireless.h>

/**

    while ((newline_position = strstr(read_buffer[pool_index], "\n"))) {

      //toss out the command

      // because either the command being given is too long or someone is trying

      // to do something bad to the server

  int sent = write(client_file_descriptor, write_buffer[pool_index], write_buffer_size[pool_index]);

  memmove(write_buffer[pool_index], write_buffer[pool_index]+sent, WRITE_BUFFER_SIZE - sent);

  return 0;

}

 * @file ColonetServer.cpp

 *

 * @brief colonet_server - primary server application for Colonet

      }

      char log_buffer[LOG_BUFFER_LENGTH];

	       inet_ntoa(client_addr.sin_addr));

      logger.log_string(LOG_TYPE_CONNECT, log_buffer);

	continue;

      }

	       inet_ntoa(client_addr.sin_addr));

      logger.log_string(LOG_TYPE_CONNECT, log_buffer);

    }

    printf("response\n");

    char buffer[WRITE_BUFFER_SIZE];

    int value = (int)(data[0]);

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

    int buflen = strlen(buffer);

    if (connection_pool.write_to_client(dest, buffer, buflen)

        == ERROR_INVALID_CLIENT_ID) {

    log_filename = optionsG.log_filename;

  }

    fprintf(stderr, "%s: colonet_wl_run_listener_thread failed.\n",

    return -1;

  return 0;

}

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

 */

int ColonetServer::initialize_connection(int port) {

         "clients...\n");

  int options = 1;

  struct sockaddr_in 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

    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;

}

  if (colonet_server.start_listening() < 0) {

    return -1;

  }

  colonet_server.run_server();

  return 0;

	@echo "---finish compilation---"

clean: