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;

}

#!/bin/sh

LIB_PATH="../"

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

primitive forward(in i, out o) {

	while(true) synchronous {

		put(o, get(i));

	}

}

primitive sync(in i, out o) {

	while(true) synchronous {

		if(fires(i)) {

			put(o, get(i));

		}

	}

}

primitive sync_two(in ia, in ib, out oa, out ob) {

	while(true) synchronous {

		if (fires(ia)) {

			put(oa, get(ia));

			put(ob, get(ib));

		}

	}

}

composite recovery_bob(in i, out o) {

	new sync(i, o);

}

primitive xor_three(in ai, out ao, in bi, out bo, in ci, out co) {

	synchronous {

		if      (fires(ai)) put(ao, get(ai));

		else if (fires(bi)) put(bo, get(bi));

		else                put(co, get(ci)); 

	}

}

	FILE *f = fopen(filename, "rb");

/**

 * # Safety

 * TODO

 */

int connector_dump_log(Connector *connector);

        Ok(connected.sync_batches.len() - 2)

pub unsafe extern "C" fn connector_get(

    connector: *mut Connector,

    proto_port_index: c_uint,

) -> c_int {

pub unsafe extern "C" fn connector_dump_log(connector: *mut Connector) -> c_int {

    let mut b = Box::from_raw(connector); // unsafe!

    let result = match b.get_mut_logger() {

        Some(s) => {

            println!("{}", s);

            0

        }

        None => 1,

    };

    result

        Err(SyncErr::Timeout) => -1, // timeout!

            -2