#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

#include "header.h"

#include <assert.h>

void send_packet(int transmit, struct packet * const foo);
int read_packet(int recieve, struct packet* const foo);
void box_RX(int transmit, int recieve);
void box_TX(int transmit, int recieve);

unsigned char *buffer;
FILE* test;

struct packet foo;

int main()
{
	pid_t child;
	int TX[2];
	int RX[2];
	ssize_t rw_return;
	int pipe_return;


	foo.pack_id = 1;
	foo.payload = NULL;

	assert((pipe_return = pipe(TX)) == 0);
	assert((pipe_return = pipe(RX)) == 0);

	if((child = fork()) == -1)
	{
		return -1;
	} else if(child == 0)
	{
		unsigned char md5sum[16];
		/* child RX side*/
		assert(read_packet(RX[0], &foo) == 0);
		/*confirm MD5 */
		send_packet(TX[1], &foo);
		
		box_RX(TX[1], RX[0]);
	} else
	{
	buffer = malloc(128);
	foo.payload = buffer;
		fgets(buffer, 128, stdin);

		foo.pack_size = strlen(foo.payload)+20;
		MD5(foo.payload, foo.pack_size - 20, foo.md5sum);
		send_packet(RX[1], &foo);
		assert(read_packet(TX[0], &foo) == 0);
		printf("got %s\n", foo.payload);
		box_TX(RX[1], TX[0]);
		wait(NULL);
		/* parent TX side*/
	}
	return 0;
}


void box_RX(int transmit, int recieve)
{
}
void box_TX(int transmit, int recieve)
{
	unsigned char* buffer;
	struct packet go;
	unsigned short packet_count = 65534;

	buffer = malloc(128);
	go.payload = buffer;

	while(fgets(buffer, 128, stdin))
	{
		go.pack_size = strlen(go.payload)+20;
		send_packet(transmit, &go);
	}
}

void send_packet(int transmit, struct packet * const foo)
{
	unsigned char* buffer = NULL;
	static unsigned char md[16];
	int rw;

	/* Send id and size */
	rw = write(transmit, foo, 4);
	assert(rw == 4);
	printf("Sent id %d\n", foo->pack_id);
	printf("Send size %d\n", foo->pack_size);

	/* Send payload */
	rw = write(transmit, foo->payload, foo->pack_size- 20);
	assert(rw == foo->pack_size-20);
	printf("Sent String %s\n", foo->payload);

	/* Generate MD5 */
	buffer = malloc(foo->pack_size - 16);
	memcpy(buffer, &foo->pack_id, sizeof(foo->pack_id));
	memcpy(buffer+sizeof(foo->pack_id), &foo->pack_size, sizeof(foo->pack_size));
	memcpy(buffer+sizeof(foo->pack_id)+sizeof(foo->pack_size), foo->payload, foo->pack_size-20);
	MD5(buffer, foo->pack_size-16, foo->md5sum);
	free(buffer);
	
	/* Send MD5 */
	printf("Sent      MD5 ");
	for(rw = 0; rw<16; rw++)
		printf("%X", foo->md5sum[rw]);
	printf("\n");


	rw = write(transmit, foo->md5sum, 16);
	assert(rw == 16);
}
int read_packet(int recieve, struct packet* const foo)
{
	static unsigned char md[16];
	unsigned char* buffer = NULL;
	int rw;

	if(foo->payload)
		free(foo->payload);

	rw = read(recieve, foo, 4);
	assert(rw == 4);
	printf("Read id %d\n", foo->pack_id);
	printf("Read size %d\n", foo->pack_size);

	foo->payload = malloc(foo->pack_size - 20);
	rw = read(recieve, foo->payload, foo->pack_size-20);
	assert(rw == foo->pack_size-20);
	printf("got %s\n", foo->payload);

	rw = read(recieve, foo->md5sum, 16);
	assert(rw == 16);
	printf("Read      MD5 ");
	for(rw = 0; rw<16; rw++)
		printf("%X", foo->md5sum[rw]);
	printf("\n");
	

	buffer = malloc(foo->pack_size - 16);
	memcpy(buffer, &foo->pack_id, sizeof(foo->pack_id));
	memcpy(buffer+sizeof(foo->pack_id), &foo->pack_size, sizeof(foo->pack_size));
	memcpy(buffer+sizeof(foo->pack_id)+sizeof(foo->pack_size), foo->payload, foo->pack_size-20);
	MD5(buffer, foo->pack_size-16, md);
	free(buffer);

	/* Print Generated MD5 */
	printf("Generated MD5 ");
	for(rw = 0; rw<16; rw++)
		printf("%X", md[rw]);
	printf("\n");



	return memcmp(md, foo->md5sum, 16);
}