target

/.idea

**/*.rs.bk

Cargo.lock

main

examples/*/*.exe

examples/*.dll

examples/reowolf*

examples/*.txt

logs/*

logs/*/*

[package]

name = "reowolf_rs"

version = "0.1.4"

authors = [

	"Christopher Esterhuyse <esterhuy@cwi.nl, christopher.esterhuyse@gmail.com>",

	"Hans-Dieter Hiep <hdh@cwi.nl>"

]

edition = "2018"

[dependencies]

# convenience macros

maplit = "1.0.2"

derive_more = "0.99.2"

# runtime

bincode = "1.3.1"

serde = { version = "1.0.114", features = ["derive"] }

getrandom = "0.1.14" # tiny crate. used to guess controller-id

# network

mio = { version = "0.7.0", package = "mio", features = ["udp", "tcp", "os-poll"] }

socket2 = { version = "0.3.12", optional = true }

# protocol

backtrace = "0.3"

lazy_static = "1.4.0"

# ffi

# socket ffi

libc = { version = "^0.2", optional = true }

os_socketaddr = { version = "0.1.0", optional = true }

[dev-dependencies]

# test-generator = "0.3.0"

crossbeam-utils = "0.7.2"

lazy_static = "1.4.0"

[lib]

# compile target: dynamically linked library using C ABI

crate-type = ["cdylib"]

[features]

ffi = [] # see src/ffi/mod.rs

ffi_pseudo_socket_api = ["ffi", "libc", "os_socketaddr"]# see src/ffi/pseudo_socket_api.rs

endpoint_logging = [] # see src/macros.rs

session_optimization = [] # see src/runtime/setup.rs

#include <stdio.h>

#include <string.h>

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

#include "../utility.c"

int main(int argc, char** argv) {

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

	size_t pdl_len = strlen(pdl_ptr);

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl_ptr, pdl_len);

	Connector * c = connector_new(pd);

	PortId putter, getter;

	connector_add_port_pair(c, &putter, &getter);

	connector_connect(c, -1);

	connector_print_debug(c);

	connector_put_bytes(c, putter, "hello", 5);

	connector_get(c, getter);

	connector_sync(c, -1);

	size_t msg_len;

	const char * msg_ptr = connector_gotten_bytes(c, getter, &msg_len);

	protocol_description_destroy(pd);

	connector_destroy(c);

	free(pdl_ptr);

	return 0;

#include <stdio.h>

#include <string.h>

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

#include "../utility.c"

int main(int argc, char** argv) {

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

	size_t pdl_len = strlen(pdl_ptr);

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl_ptr, pdl_len);

	char logpath[] = "./7_amy_log.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	printf("Err %s\n", reowolf_error_peek(NULL));

	PortId putter, getter;

	connector_add_port_pair(c, &putter, &getter);

	connector_connect(c, -1);

	connector_print_debug(c);

	printf("Let's try to put without get\n");

	connector_put_bytes(c, putter, "hello", 5);

	// connector_get(c, getter);

	int err = connector_sync(c, 5000);

	printf("Error code %d with string `%s`\n", err, reowolf_error_peek(NULL));

	printf("\nLet's try again, doing both\n");

	connector_put_bytes(c, putter, "hello", 5);

	connector_get(c, getter);

	err = connector_sync(c, 5000);

	printf("Error code %d with string `%s`\n", err, reowolf_error_peek(NULL));

	size_t msg_len;

	const char * msg_ptr = connector_gotten_bytes(c, getter, &msg_len);

	protocol_description_destroy(pd);

	connector_destroy(c);

	free(pdl_ptr);

	return 0;

#include <stdio.h>

#include <string.h>

int main(int argc, char** argv) {

  // --- setup ---

  Arc_ProtocolDescription * pd = protocol_description_parse("", 0);

  Connector * c = connector_new(pd);

  PortId putter_a, putter_b;

  FfiSocketAddr addresses[4];

  /* (address structure initializations omitted) */

  // putter_a to UDP mediator (getter id discarded)

  // with local addresses[0] and peer addresses[1] 

  connector_add_udp_mediator_component(c, &putter_a, NULL, addresses[0], addresses[1]);

  connector_add_udp_mediator_component(c, &putter_b, NULL, addresses[2], addresses[3]);

  connector_connect(c, -1);

  // --- communication --- 

  connector_put_bytes(c, putter_a, "hello, socket!", 14);

  connector_put_bytes(c, putter_b, "hello, pseudo-socket!", 21);

  connector_sync(c, -1);

  // --- cleanup ---

  protocol_description_destroy(pd);

  connector_destroy(c);

  return 0;

#include <stdio.h>

#define BUFSIZE 512

int main() {

  // --- setup ---

  /* (address structure initializations omitted) */

  int fd = rw_socket(AF_INET, SOCK_DGRAM, 0); 

  // --- communication ---

  size_t msglen, i;

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

    printf("%02X", buffer[i]);

  }

  // --- cleanup ---

  rw_close(fd);

  free(buffer);

  return 0;

#define BUFSIZE 512

int main() {

    // --- setup ---

    /* (address structure initializations omitted) */

    int fd = socket(AF_INET, SOCK_DGRAM, 0); 

    // --- communication ---

    size_t msglen, i;

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

        printf("%02X", buffer[i]);

    }

    // --- cleanup ---

    close(fd);

    free(buffer);

    return 0;

import os, glob, subprocess, time

script_path = os.path.dirname(os.path.realpath(__file__));

for c_file in glob.glob(script_path + "/*/*.c", recursive=False):

  print("compiling", c_file)

  args = [

    "gcc",          # compiler

    "-std=c11",     # C11 mode

    "-Wl,-R./",     # pass -R flag to linker: produce relocatable object

    c_file,         # input source file

    "-o",           # output flag

  ];

  subprocess.run(args)

input("Blocking until newline...");

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

#include "../utility.c"

int main(int argc, char** argv) {

	// Create a connector, configured with our (trivial) protocol.

	Arc_ProtocolDescription * pd = protocol_description_parse("", 0);

	char logpath[] = "./pres_1_bob.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	rw_err_peek(c);

	// ... with 1 outgoing network connection

	PortId p0;

	FfiSocketAddr addr = {{127,0,0,1}, 8000};

	connector_add_net_port(c, &p0, addr, Polarity_Getter, EndpointPolarity_Active);

	rw_err_peek(c);

	// Connect with peers (5000ms timeout).

	connector_connect(c, 5000);

	rw_err_peek(c);

	// Prepare to receive a message.

	connector_get(c, p0);

	rw_err_peek(c);

	// ... reach new consistent state within 1000ms deadline.

	connector_sync(c, 1000);

	rw_err_peek(c);

	// Read our received message

	size_t msg_len;

	const char * msg_ptr = connector_gotten_bytes(c, p0, &msg_len);

	printf("Exiting\n");

	protocol_description_destroy(pd);

	connector_destroy(c);

	sleep(1.0);

	return 0;

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

#include "../utility.c"

int main(int argc, char** argv) {

	// Create a connector, configured with a protocol defined in a file

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

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl, strlen(pdl));

	char logpath[] = "./pres_2_bob.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	rw_err_peek(c);

	// ... with 1 outgoing network connection

	PortId ports[3];

	FfiSocketAddr addr = {{127,0,0,1}, 8000};

	connector_add_net_port(c, &ports[0], addr, Polarity_Getter, EndpointPolarity_Active);

	connector_add_port_pair(c, &ports[1], &ports[2]);

	connector_add_component(c, "pres_2", 6, ports, 2);

	rw_err_peek(c);

	// Connect with peers (5000ms timeout).

	connector_connect(c, 5000);

	rw_err_peek(c);

	// Prepare to receive a message.

	connector_get(c, ports[2]);

	rw_err_peek(c);

	// ... reach new consistent state within 1000ms deadline.

	connector_sync(c, 1000);

	rw_err_peek(c);

	// Read our received message

	size_t msg_len;

	const char * msg_ptr = connector_gotten_bytes(c, ports[2], &msg_len);

	printf("Exiting\n");

	protocol_description_destroy(pd);

	connector_destroy(c);

	free(pdl);

	sleep(1.0);

	return 0;

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

#include "../utility.c"

int main(int argc, char** argv) {

	// Create a connector, configured with a protocol defined in a file

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

	Arc_ProtocolDescription * pd = protocol_description_parse(pdl, strlen(pdl));

	char logpath[] = "./pres_3_bob.txt";

	Connector * c = connector_new_logging(pd, logpath, sizeof(logpath)-1);

	rw_err_peek(c);

	// ... with 2 outgoing network connections

	PortId ports[4];

	FfiSocketAddr addr = {{127,0,0,1}, 8000};

	connector_add_net_port(c, &ports[0], addr, Polarity_Getter, EndpointPolarity_Active);

	rw_err_peek(c);

	addr.port = 8001;

	connector_add_net_port(c, &ports[1], addr, Polarity_Getter, EndpointPolarity_Active);

	connector_add_port_pair(c, &ports[2], &ports[3]);

	connector_add_component(c, "alt_round_merger", 16, ports, 3);

	rw_err_peek(c);

	// Connect with peers (5000ms timeout).

	connector_connect(c, 5000);

	rw_err_peek(c);

	for(int round=0; round<3; round++) {

		printf("----------Round %d\n", round);

		connector_get(c, ports[3]);

		rw_err_peek(c);

		connector_sync(c, 1000);

		rw_err_peek(c);

		size_t msg_len = 0;

		const char * msg_ptr = connector_gotten_bytes(c, ports[3], &msg_len);

	}

	printf("Exiting\n");

	protocol_description_destroy(pd);

	connector_destroy(c);

	free(pdl);

	sleep(1.0);

	return 0;

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <string.h>

#include <unistd.h>

#include "../reowolf.h"

size_t get_user_msg(char * buf, size_t cap) {

	memset(buf, 0, cap);

	fgets(buf, cap, stdin);

	for(size_t len = 0; len<cap; len++)

		if(buf[len]==0 || buf[len]=='\n')

			return len;

	return cap;

}

void rw_err_peek(Connector * c) {

	printf("Error str `%s`\n", reowolf_error_peek(NULL));

}

// allocates a buffer!

char * buffer_pdl(char * filename) {

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

	if (f == NULL) {

		printf("Opening pdl file returned errno %d!\n", errno);

		exit(1);

	}

	fseek(f, 0, SEEK_END);

	long fsize = ftell(f);

	fseek(f, 0, SEEK_SET);

	char *pdl = malloc(fsize + 1);

	fread(pdl, 1, fsize, f);

	fclose(f);

	pdl[fsize] = 0;

	return pdl;

}

use super::*;

use core::ops::DerefMut;

use libc::{sockaddr, socklen_t};

use std::{

    collections::HashMap,

    ffi::c_void,

    net::SocketAddr,

    os::raw::c_int,

    sync::{Mutex, RwLock},

};

///////////////////////////////////////////////////////////////////

struct FdAllocator {

    next: Option<c_int>,

    freed: Vec<c_int>,

}

enum ConnectorComplexPhased {

    Setup { local: Option<SocketAddr>, peer: Option<SocketAddr> },

    Communication { putter: PortId, getter: PortId },

}

struct ConnectorComplex {

    // invariant: .connector.phased and .phased are variants Setup/Communication in lockstep.

    connector: Connector,

    phased: ConnectorComplexPhased,

}

#[derive(Default)]

struct CcMap {

    fd_to_cc: HashMap<c_int, Mutex<ConnectorComplex>>,

    fd_allocator: FdAllocator,

}

///////////////////////////////////////////////////////////////////

unsafe fn payload_from_raw(bytes_ptr: *const c_void, bytes_len: usize) -> Payload {

    let bytes_ptr = std::mem::transmute(bytes_ptr);

    let bytes = &*slice_from_raw_parts(bytes_ptr, bytes_len);

    Payload::from(bytes)

}

unsafe fn libc_to_std_sockaddr(addr: *const sockaddr, addr_len: socklen_t) -> Option<SocketAddr> {

    os_socketaddr::OsSocketAddr::from_raw_parts(addr as _, addr_len as usize).into_addr()

}

impl Default for FdAllocator {

    fn default() -> Self {

        // negative FDs aren't used s.t. they are available for error signalling

        Self { next: Some(0), freed: vec![] }

    }

}

impl FdAllocator {

    fn alloc(&mut self) -> c_int {

        if let Some(fd) = self.freed.pop() {

            return fd;

        }

        if let Some(fd) = self.next {