Colony

/* Colonet Server

   Eugene Marinelli and Gregory Tress

*/

#include <sys/types.h>

#include <sys/socket.h>

#include <stdio.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <string.h>

#include <netdb.h>

#include "wireless.h"

#define SERIAL_PORT "/dev/ttyS0"  

//#define SERIAL_PORT "/dev/ttyUSB0"

#define SERVER_ID 213

#define FORWARD 0xF0

#define BACK 0xF1

#define RIGHT 0xF2

#define LEFT 0xF3

#define STOP 0xF4

#define message_length 3

void send_command(char cmd, char dest);

int mysocket;   //the socket that gets new connections

int io_socket;  //the socket we use to communicate when a connection is initiated.

int main (int argc, char **argv) {

  unsigned int clientlen;

  struct sockaddr_in clientaddr;

  struct hostent *hp;

  char *haddrp;

  char newdata[100];

  int newdatasize;

  if (argc != 2) {

    fprintf(stderr, "Usage: %s <port>\n", argv[0]);

    return 0;

  }

  //start server

  printf("Starting server on port %i\n", atoi(argv[1]));

  mysocket = open_listenfd(atoi(argv[1]));

  if (mysocket < 0) {

    fprintf(stderr, "Error listening on port.\n");

    return -1;

  } else {

    printf("Server running, waiting for connection\n");

  }

  //accept connections

  while (1) {

    clientlen = sizeof(clientaddr);

    io_socket = accept(mysocket, (struct sockaddr *) &clientaddr, &clientlen);

    //get client info

    hp = gethostbyaddr((const char *) &clientaddr.sin_addr.s_addr, 

                       sizeof(clientaddr.sin_addr.s_addr), AF_INET);

    haddrp = inet_ntoa(clientaddr.sin_addr);

    printf("Client connected: %s %s\n", hp->h_name, haddrp);

    if (!fork()) { // this is the child process

      close(mysocket); // child doesn't need the listener

      newdata[0] = ' ';

      while (newdata[0] != 'q') {

        memset(newdata, '\0', strlen(newdata));

        newdatasize = recv(io_socket, newdata, 99, 0);

        //receive commands from clients and give them to robots

        printf("Received: [%s]\n", newdata);

        send_command(newdata[0], GLOBAL_DEST);

      }

      printf("\nClient has disconnected.\n");

      close(io_socket);

      return 0;

    }

    close(io_socket);

  }

  close(mysocket);

  return 0;

}

//listen on port, as specified by 15-213 book.

int open_listenfd(int port) {

  int listenfd, optval=1;

  struct sockaddr_in serveraddr;

  //create socket descriptor

  if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)

    return -1;

  //prevent "address already in use" error

  if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const void *) &optval, 

                 sizeof(int)) < 0)

    return -1;

  bzero((char *) &serveraddr, sizeof(serveraddr));

  serveraddr.sin_family = AF_INET;

  serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);

  serveraddr.sin_port = htons((unsigned short)port);

  if (bind(listenfd, (struct sockaddr *) &serveraddr, sizeof(serveraddr)) < 0)

    return -1;

  //start listening

  if (listen(listenfd, 128) < 0)

    return -1;

  return listenfd;

}

void send_command(char cmd, char dest){

  FILE* serial;

  WL_Packet pkt;

  int i;

  char robot_cmd[message_length];

  if(cmd != 'w' && cmd != 'a' && cmd != 's' && cmd != 'd' && cmd != ' '){

    fprintf(stderr, "Invalid command\n");

    return;

  }

  robot_cmd[0] = 0;

  robot_cmd[1] = '\0';

  switch(cmd){

  case 'w':

    robot_cmd[0] = FORWARD;

    break;

  case 'a':

    robot_cmd[0] = LEFT;

    break;

  case 's':

    robot_cmd[0] = BACK;

    break;

  case 'd':

    robot_cmd[0] = RIGHT;

    break;

  case ' ':

    robot_cmd[0] = STOP;

    break;

  }

  wl_create_packet(robot_cmd, SERVER_ID, dest, &pkt);

  serial = fopen(SERIAL_PORT, "w");

  fprintf(stderr, "%i %i %i %i ", pkt.prefix[0], pkt.prefix[1], pkt.src, 

          pkt.dest);

  fprintf(serial, "%c%c%c%c", pkt.prefix[0], pkt.prefix[1], pkt.src,  

          pkt.dest);

  for(i = 0; i < message_length; i++){

    fprintf(stderr, "%i ", pkt.msg[i]);

    fprintf(serial, "%c", pkt.msg[i]);

  }

  fprintf(stderr, "%i", pkt.checksum);

  fprintf(serial, "%c", pkt.checksum);

  fclose(serial);

}

char wl_get_checksum(WL_Packet* packet){

  char checksum = 0;

  int i;

  checksum += packet->src;

  checksum += packet->dest;

  for(i = 0; i < message_length; i++) {

    checksum += packet->msg[i];

  }

  return checksum;

}

int wl_create_packet(char* msg, char src, char dest, WL_Packet* packet){

  packet->prefix[0] = 'R';

  packet->prefix[1] = 'C';

  packet->src = src;

  packet->dest = dest;

  memset(packet->msg, 0, message_length);

  strcpy(packet->msg, msg);

  packet->checksum = wl_get_checksum(packet);

  return 0;

}