#include<stdio.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<linux/if_packet.h>
#include<linux/if_ether.h>
#include<errno.h>
#include<sys/ioctl.h>
#include<net/if.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>


/* Raw socket creation/read/write code */

int CreateRawSocket(int protocol)
{
	int rawsock;

	if((rawsock = socket(PF_PACKET, SOCK_RAW, htons(protocol)))== -1)
	{
		perror("Error creating raw socket: ");
		exit(-1);
	}

	return rawsock;
}

int BindRawSocketToInterface(char *device, int rawsock, int protocol)
{
	
	struct sockaddr_ll sll;
	struct ifreq ifr;

	bzero(&sll, sizeof(sll));
	bzero(&ifr, sizeof(ifr));
	
	/* First Get the Interface Index  */


	strncpy((char *)ifr.ifr_name, device, IFNAMSIZ);
	if((ioctl(rawsock, SIOCGIFINDEX, &ifr)) == -1)
	{
		printf("Error getting Interface index !\n");
		exit(-1);
	}

	/* Bind our raw socket to this interface */

	sll.sll_family = AF_PACKET;
	sll.sll_ifindex = ifr.ifr_ifindex;
	sll.sll_protocol = htons(protocol); 


	if((bind(rawsock, (struct sockaddr *)&sll, sizeof(sll)))== -1)
	{
		perror("Error binding raw socket to interface\n");
		exit(-1);
	}

	return 1;
}


int SendRawPacket(int rawsock, unsigned char *pkt, int pkt_len)
{
	int sent= 0;

	/* A simple write on the socket ..thats all it takes ! */

	if((sent = write(rawsock, pkt, pkt_len)) != pkt_len)
	{
		/* Error */
		printf("Could only send %d bytes of packet of length %d\n", sent, pkt_len);
		return 0;
	}

	return 1;
}




/* IPC Mechanism code */

#define PATHNAME_FTOK	"/etc/services"
#define PROJ_ID_FTOK	1	
#define PERMISSION	0644

typedef struct Message{

	long mtype;
	int data; // The real data 

}Message;

int CreateMessageQueue(void)
{
	int messageQ;
	key_t key;

	if((key = ftok(PATHNAME_FTOK, PROJ_ID_FTOK)) == -1)
	{
		perror("FTOK() failed ! - exiting \n");
		exit(-1);
	}

	if((messageQ = msgget(key, PERMISSION | IPC_CREAT)) == -1)
	{
		perror("msgget() failed - Exiting\n");
		exit(-1);
	}

	return messageQ;

}

SendMessage(int messageQ, Message buf)
{
	if((msgsnd(messageQ, &buf, sizeof(Message), 0)) == -1)
	{
		perror("Message send failed\n");
	}
}

Message *ReceiveMessage(int messageQ)
{
	Message *buf = (Message *)malloc(sizeof(Message));
	
	if((msgrcv(messageQ, buf, sizeof(Message), 0, 0)) == -1)
	{
		perror("Receive failed");
		free(buf);
		buf = NULL;
	}

	return buf;
}

DestroyMessageQueue(int messageQ)
{

	if((msgctl(messageQ, IPC_RMID, NULL)) == -1)
	{
		perror("Could not destroy Message Queue\n");
	}

}



/* Sniffer Thread */

void *sniffer_thread(void *arg)
{

}


/* Injector Thread */

void *injector_thread(void *arg)
{
	

}


/* The main dude ..... */

main(int argc, char **argv)
{
	/* The Thread Ids */

	pthread_t sniffer;
	pthread_t injector;

	/* The mode of communication between the threads will be IPC*/
	/* We choose Message Queues in this example */

	int messageQueue;

	/* Initialize the IPC mechanism */

	messageQueue = CreateMessageQueue();
		

	/* Start the threads - Pass them the message queue id as argument */

	if((pthread_create(&sniffer, NULL, sniffer_thread, &messageQueue)) != 0)
	{
		printf("Error creating Sniffer thread - Exiting\n");
		exit(-1);
	}

	if((pthread_create(&injector, NULL, injector_thread, &messageQueue)) != 0)
	{
		printf("Error creating Injector thread - Exiting\n");
		exit(-1);
	}

	/* Wait for the threads to exit */

	pthread_join(sniffer);
	pthread_join(injector);

	/* Cleanup code */

	DestroyMessageQueue(messageQueue);

	return 0;

}