Colony

#include "netserv.h"

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h> 

#include <sys/socket.h>

#include <netinet/in.h>

int make_sock(int portno)

{

  int sockfd, newsockfd, clilen;

  struct sockaddr_in serv_addr, cli_addr;

  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if (sockfd < 0)

    error("ERROR opening socket");

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

  serv_addr.sin_family = AF_INET;

  serv_addr.sin_addr.s_addr = INADDR_ANY;

  serv_addr.sin_port = htons(portno);

  if (bind(sockfd, (struct sockaddr *) &serv_addr,

	   sizeof(serv_addr)) < 0) 

    error("ERROR on binding");

  listen(sockfd,5);

  clilen = sizeof(cli_addr);

  newsockfd = accept(sockfd, 

		     (struct sockaddr *) &cli_addr, 

		     (socklen_t *) &clilen);

  if (newsockfd < 0) 

    error("ERROR on accept");

  return newsockfd;

}

/* A simple server in the internet domain using TCP

   The port number is passed as an argument */

#include <stdio.h>

#include <stdlib.h>

#include <strings.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h> 

#include <sys/socket.h>

#include <netinet/in.h>

#include "netserv.h"

#include "robots.h"

#include "wireless.h"

void donothin()

{

     return;

}

int main(int argc, char *argv[])

{

     char buffer[256];

     char outbuf[256];

     int n, newsockfd, len;

     Packet *received;

     if (argc < 2) {

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

	  exit(1);

     }

     newsockfd = make_sock(atoi(argv[1]));

     make_listener();

     printf("Robot listener created.\n");

     bzero(buffer,256);

     while (1)

     {

	  wl_do();

	  /* this is a completely useless queue, since wl_do only reads one packet at a time */

	  received = dequeue();

	  /* oh well */

	  if (received)

	  {

	       fprintf(stdout, "len: %d\n", buffer[1]);

	       buffer[0] = (char) received->source;

	       buffer[1] = (char) received->length-2;

	       buffer[2] = (char) received->type;

	       memcpy(buffer+3, received->packet, received->length);

	       n = write(newsockfd, buffer, 200);

	       free(received);

	       bzero(buffer, 256);

	  }

     }

     return 0; 

}

void error(char *msg)

{

     printf(msg);

     exit(1);

}

#include <stdlib.h>

#include <wireless.h>

#include <string.h>

#include <stdio.h>

#include "robots.h"

typedef struct Node {

     Packet *info;

     struct Node *next;

     struct Node *prev;

} Node;

Node *thead = NULL;

void enqueue(char typ, int src, unsigned char *wrds,int len);

void make_listener()

{ 

     PacketGroupHandler *receiver;

     printf("wl_init() returned %d\n", wl_init());

     wl_set_channel(0xE);

     receiver = malloc(sizeof(PacketGroupHandler));

     receiver->groupCode = GROUP;

     receiver->handle_response = NULL;

     receiver->timeout_handler = NULL;

     receiver->handle_receive = enqueue;

     wl_register_packet_group(receiver);

}

void enqueue(char typ, int src, unsigned char *wrds,int len)

{

     Node *new = malloc(sizeof(Node));

     new->info = malloc(sizeof(Packet));

     new->info->source = src;

     new->info->length = len;

     new->info->type = typ;

     new->info->packet = malloc((strlen(wrds)+1)*sizeof(char));

     strcpy(new->info->packet, wrds);

     if (!thead)

	  thead = new;

     else

     {

	  new->next = thead;

	  thead->prev = new;

	  thead = new;

     }

}

Packet * dequeue()

{

     Node *iter;

     Packet *ret;

     if (!thead)

	  return NULL;

     for (iter = thead; iter->next != NULL; iter = iter->next)

	  ;

     ret = iter->info;

     if (iter->prev)

	  (iter->prev)->next = NULL;

     else

	  thead = NULL;

     free (iter);

     return ret;

}

#!/usr/bin/env python3.0

import sys, time

from socket import *

hostname='localhost'

def inp(str):

    return input(str).encode('ascii')

def main():

    funcs = {31 : 'print_range_info'}

    buf = []

    sock = socket()

    sock.connect((hostname, int(sys.argv[1])))

    while (True):

        buf = sock.recv(100)

        if (buf):

            type = buf[2]

            if type in funcs.keys():

                globals()[funcs[type]](buf)

def print_range_info(packet):

    print ('Info from %d' % packet[0])

    src = packet[0]

    len = packet[1]

    print(len)

    data = packet[3:]

    for i in range(len // 2):

        bot_id = data[i*2]

        max_range_id = data[i*2+1]

        print ('Max to bot %d is %d' % (bot_id, max_range_id))

if __name__=='__main__':

    if len(sys.argv) < 2 or not str.isdecimal(sys.argv[1]):

        print("Usage: %s <portno>" % sys.argv[0])

        sys.exit()

    main()

#ifndef NETSERV

#define NETSERV

int make_sock(int portno);

void error(char *);

#endif

CC=gcc

CFLAGS=-W -Wall -lpthread -g

INCS=-I../../libwireless/lib

COMPS=../../libwireless/lib

server : clean

	$(CC) $(CFLAGS) $(INCS) ../../libwireless/lib/*.c server.c netserv.c robots.c -o server

clean :

	rm -f server

cd src/

gcc -c *.c -I/usr/include/python2.5/ -I../../colony-wireless/code/lib/include/libwireless/ *.c

gcc -shared  *.o -o wireless.so

#ifndef ROBOTS

#define ROBOTS

typedef struct Packet

{

  int source;

  int length;

  char type;

  char *packet;

} Packet;

#define GROUP 1

void make_listener();

Packet *dequeue();

#endif