char * pdl = buffer_pdl("eg_protocols.pdl");

	char * pdl = buffer_pdl("eg_protocols.pdl");

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "../../reowolf.h"

#include "../utility.c"

int main() { // AMY

	char * pdl = buffer_pdl("eg_protocols.pdl");

	Connector* c = connector_new();

	printf("configuring...\n");

	check("config ", connector_configure(c, pdl, "sync"));

	check("bind 0 ", connector_bind_native(c, 0));

	check("bind 1 ", connector_bind_passive(c, 1, "127.0.0.1:7000"));

	printf("connecting...\n");

	check("connect", connector_connect(c, 5000));

	int send_next = 0;

	char msg_buf[32];

	int code;

	int i;

	for (i = 0; 1; i++) {

		itoa(send_next, msg_buf, 10);

		printf("\nround %d. Will send msg `%s` next", i, msg_buf);

		// batch 0: no messages sent

		check("next_batch ", connector_next_batch(c));

		// batch 1: put 0

		check("put ", connector_put(c, 0, msg_buf, strlen(msg_buf) + 1));

		code = connector_sync(c, 3000);

		if (code == 0) printf("Sent no message!");

		else if (code == 1) {

			printf("Sent message `%s`!", msg_buf);

			send_next++;

		} else {

			printf(

				"Connector error! %d (%s)\nBreaking loop!\n",

				code, connector_error_peek()

			);

			break;

		}

	}

	printf("destroying...\n");

	connector_destroy(c);

	printf("exiting...\n");

	free(pdl);

	return 0;

}

#include <stdio.h>

#include <time.h>

#include "../../reowolf.h"

#include "../utility.c"

int main() { // BOB!

	char * pdl = buffer_pdl("eg_protocols.pdl");

	Connector* c = connector_new();

	printf("configuring...\n");

	check("config ", connector_configure(c, pdl, "sync"));

	check("bind 0 ", connector_bind_active(c, 0, "127.0.0.1:7000"));

	check("bind 1 ", connector_bind_native(c, 1));

	printf("connecting...\n");

	check("connect", connector_connect(c, 5000));

	int msg_len;

	const unsigned char * msg;

	int i;

	srand(time(NULL));

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

		printf("\nround %d...\n", i);

		int random = rand() % 2;

		if (random == 0) {

			printf("I don't want a message!\n");

			check("sync", connector_sync(c, 1000));

		} else {

			printf("I want a message!\n");

			check("get ", connector_get(c, 0));

			check("sync", connector_sync(c, 1000));

			check("read msg", connector_gotten(c, 0, &msg, &msg_len));

			printf("Got message: `%.*s`\n", msg_len, msg);

		}

	}

	printf("destroying...\n");

	connector_destroy(c);

	printf("exiting...\n");

	free(pdl);

	return 0;

}

	char * pdl = buffer_pdl("eg_protocols.pdl");

	check("config ", connector_configure(c, pdl, "sync_two"));

	int code;

	while (1) {

		// batch 0: no messages sent

		check("next_batch ", connector_next_batch(c));

		// batch 1: put 0 and put 1

		code = connector_sync(c, 3000);

		if (code == 0) printf("Sent neither message!");

		else if (code == 1) printf("Sent both messages!");

		else {

			printf(

				"Connector error! %d (%s)\nBreaking loop!\n",

				code, connector_error_peek()

			);

			break;

		}

#include <stdio.h>

#include "../../reowolf.h"

#include "../utility.c"

int main() { // BOB!

	char * pdl = buffer_pdl("eg_protocols.pdl");

	Connector* c = connector_new();

	printf("configuring...\n");

	check("config ", connector_configure(c, pdl, "sync_two"));

	check("bind 0 ", connector_bind_active(c, 0, "127.0.0.1:7000"));

	check("bind 1 ", connector_bind_active(c, 1, "127.0.0.1:7001"));

	check("bind 2 ", connector_bind_native(c, 2));

	check("bind 3 ", connector_bind_native(c, 3));

	printf("connecting...\n");

	check("connect", connector_connect(c, 5000));

	int msg_len;

	const unsigned char * msg;

	int i;

	// rounds 0..=2: get both messages

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

		printf("\nround %d\n", i);

		check("get ", connector_get(c, 0));

		check("get ", connector_get(c, 1));

		check("sync", connector_sync(c, 1000));

		check("read one", connector_gotten(c, 0, &msg, &msg_len));

		printf("Got message one: `%.*s`\n", msg_len, msg);

		check("read two", connector_gotten(c, 1, &msg, &msg_len));

		printf("Got message two: `%.*s`\n", msg_len, msg);

	}

	// rounds 3..=5: get neither message

	for (i = 3; i <= 5; i++) {

		printf("\nround %d\n", i);

		//check("get ", connector_get(c, 0));

		//check("get ", connector_get(c, 1));

		check("sync", connector_sync(c, 3000));

		//check("read one", connector_gotten(c, 0, &msg, &msg_len));

		//printf("Got message one: `%.*s`\n", msg_len, msg);

		//check("read two", connector_gotten(c, 1, &msg, &msg_len));

		//printf("Got message two: `%.*s`\n", msg_len, msg);

	}

	// round 6: attempt to get just one message

	for (i = 6; i <= 6; i++) {

		printf("\nround %d\n", i);

		check("get ", connector_get(c, 0));

		//check("get ", connector_get(c, 1));

		check("sync", connector_sync(c, 3000));

		//check("read one", connector_gotten(c, 0, &msg, &msg_len));

		//printf("Got message one: `%.*s`\n", msg_len, msg);

		check("read two", connector_gotten(c, 1, &msg, &msg_len));

		printf("Got message two: `%.*s`\n", msg_len, msg);

	}

	printf("destroying...\n");

	connector_destroy(c);

	printf("exiting...\n");

	free(pdl);

	return 0;

}

#!/bin/sh

LIB_PATH="../"

gcc -L $LIB_PATH -lreowolf_rs -Wl,-R$LIB_PATH amy.c -o amy

gcc -L $LIB_PATH -lreowolf_rs -Wl,-R$LIB_PATH bob.c -o bob

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "../../reowolf.h"

#include "../utility.c"

int main() { // AMY

	char * pdl = buffer_pdl("eg_protocols.pdl");

	Connector* c = connector_new();

	printf("configuring...\n");

	check("config ", connector_configure(c, pdl, "sync"));

	check("bind 0 ", connector_bind_native(c, 0));

	check("bind 1 ", connector_bind_passive(c, 1, "127.0.0.1:7000"));

	printf("connecting...\n");

	check("connect", connector_connect(c, 5000));

	int i;

	int code;

	while (1) {

		printf("\nround %d. I will offer the message \"hello\".\n", i);

		connector_next_batch(c);

		check("put ", connector_put(c, 0, "hello", 5));

		code = connector_sync(c, 3000);

		if (code == 0) printf("OK! No message was sent!");

		else if (code == 1) printf("OK! My message was received!");

		else if (code == -1) printf("!!! UH OH! The round rolled back! Let's try again");

		else {

			printf(

				"Something went wrong!\n",

				code, connector_error_peek()

			);

			break;

		}

	}

	printf("destroying...\n");

	connector_destroy(c);

	printf("exiting...\n");

	free(pdl);

	return 0;

}

#include <stdio.h>

#include "../../reowolf.h"

#include "../utility.c"

int main() { // BOB!

	char * pdl = buffer_pdl("eg_protocols.pdl");

	Connector* c = connector_new();

	printf("configuring...\n");

	check("config ", connector_configure(c, pdl, "recovery_bob"));

	check("bind 0 ", connector_bind_active(c, 0, "127.0.0.1:7000"));

	check("bind 1 ", connector_bind_native(c, 1));

	printf("connecting...\n");

	check("connect", connector_connect(c, 5000));

	int msg_len;

	const unsigned char * msg;

	int i;

	char msg_buf[1];

	int code;

	char answer;

	for (i = 0; true; i++) {

		printf("\nround %d...\n", i);

		printf("Should I receive a message? (y/n): ");

		scanf(" %c", &answer);

		if (answer == 'y') {

			printf("OK! Let's receive a message!\n");

			connector_get(c, 0);

		} else if (answer == 'n') {

			printf("OK! Let's NOT receive a message!\n");

		} else {

			printf("Expected (y/n) input!");

			continue;

		}

		code = connector_sync(c, 1000);

		// lets see how it went

		if (code == 0) {

			printf("Success!\n");

			if (answer == 'y') {

				check("read ", connector_gotten(c, 0, &msg, &msg_len));

				printf("Got message: `%.*s`\n", msg_len, msg);

			}

		} else if (code == -1) {

			printf("!!! UH OH! The round rolled back! Let's try again\n");

		} else {

			printf(

				"Something went wrong!\n",

				code, connector_error_peek()

			);

			break;

		}

	}

	printf("destroying...\n");

	connector_destroy(c);

	printf("exiting...\n");

	free(pdl);

	return 0;

}

#!/bin/sh

LIB_PATH="../"

gcc -L $LIB_PATH -lreowolf_rs -Wl,-R$LIB_PATH amy.c -o amy

gcc -L $LIB_PATH -lreowolf_rs -Wl,-R$LIB_PATH bob.c -o bob

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include "../../reowolf.h"

#include "../utility.c"

int main(int arg_c, char * argv[]) {

	int index;

	if (arg_c != 2) {

		printf("Expected one arg: which peer I am in 0..4");

		return 1;

	}

	index = atoi(argv[1]);

	printf("I am peer %d\n", index);

	const char* addrs[] = {

		"127.0.0.1:7000",

		"127.0.0.1:7001",

		"127.0.0.1:7002",

		"127.0.0.1:7003",

		"127.0.0.1:7004",

		"127.0.0.1:7005",

	};

	char * pdl = buffer_pdl("eg_protocols.pdl");

	Connector* c = connector_new();

	printf("configuring...\n");

	check("config ", connector_configure(c, pdl, "xor_three"));

	int i, j;

	int addr_index = 0;

	int port = 0;

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

		for (j = i+1; j < 4; j++) {

			if (i==index) {

				printf("ports %d and %d are for a passive channel to peer %d over addr %s\n", port, port+1, j, addrs[addr_index]);

				check("bind an ", connector_bind_native(c, port));

				port++;

				check("bind a  ", connector_bind_active(c, port, addrs[addr_index]));

				port++;

			} else if (j==index) {

				printf("ports %d and %d are for an active channel to peer %d over addr %s\n", port, port+1, i, addrs[addr_index]);

				check("bind p  ", connector_bind_passive(c, port, addrs[addr_index]));

				port++;

				check("bind pn ", connector_bind_native(c, port));

				port++;

			}

			addr_index++;

		}

	}

	check("connect", connector_connect(c, 5000));

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

		if (i == index) continue;

		// another batch

		for (j = 0; j < 4; j++) {

		}

	}

	connector_sync();

	printf("destroying...\n");

	connector_destroy(c);

	printf("exiting...\n");

	free(pdl);

	return 0;

}