dat-thang/libcess/include/cesspool.h

#ifndef LIBCESS_CESSPOOL_H
#define LIBCESS_CESSPOOL_H

#include <stddef.h>
#include <stdint.h>
#include "cess_net.h"

#define CESSPOOL_TOPIC_BYTES 32u
#define CESSPOOL_PEER_BYTES 32u
#define CESSPOOL_MAX_BOOTSTRAP 16u
#define CESSPOOL_MAX_PEERS 256u
#define CESSPOOL_MAX_TOPICS 64u
#define CESSPOOL_MAX_ANNOUNCEMENTS 1024u
#define CESSPOOL_MAX_TRANSACTIONS 64u

typedef struct cesspool_keypair {
	uint8_t pubkey[32];
	uint8_t seckey[64];
} cesspool_keypair_t;

enum cesspool_message_type {
	CESSPOOL_LOOKUP = 0, CESSPOOL_ANNOUNCE = 1, CESSPOOL_UNANNOUNCE = 2,
	CESSPOOL_REPLY = 3, CESSPOOL_PING = 4, CESSPOOL_PONG = 5,
	CESSPOOL_HOLEPUNCH = 6
};

typedef struct cesspool_message {
	uint8_t type, topic[CESSPOOL_TOPIC_BYTES], peer_id[CESSPOOL_PEER_BYTES];
	uint16_t port;
	uint8_t payload[2048];
	size_t payload_len;
} cesspool_message_t;
typedef struct cesspool_request {
	uint32_t type;
	uint16_t port;
	uint8_t local_address[6];
	size_t local_address_len;
} cesspool_request_t;
typedef struct cesspool_response {
	uint8_t peers[1024]; size_t peers_len;
	uint8_t local_peers[1024]; size_t local_peers_len;
	uint8_t peer_info[2048]; size_t peer_info_len;
} cesspool_response_t;
typedef struct cesspool_peer {
	cess_peer_t address;
	uint8_t public_key[32];
	uint8_t discovery_topic[CESSPOOL_TOPIC_BYTES];
	uint64_t last_seen;
	unsigned failures;
	int local, discovered;
} cesspool_peer_t;
typedef struct cesspool_topic {
	uint8_t key[32]; uint16_t port; int announcing, looking_up; uint64_t refresh_at;
} cesspool_topic_t;
typedef struct cesspool_transaction {
	uint16_t id; uint8_t target[32], type; uint64_t expires_at; int active;
} cesspool_transaction_t;
typedef struct cesspool_announcement {
	uint8_t topic[CESSPOOL_TOPIC_BYTES], peer_id[CESSPOOL_PEER_BYTES];
	cess_peer_t address;
	uint64_t last_seen;
} cesspool_announcement_t;
struct cesspool;
typedef void (*cesspool_transport_packet_fn)(struct cesspool *,
						     const cess_peer_t *,
						     const uint8_t *, size_t);
typedef struct cesspool {
	cessnet_t net;
	cess_peer_t bootstrap_nodes[CESSPOOL_MAX_BOOTSTRAP];
	size_t bootstrap_count;
	uint16_t port;
	int ready, bootstrap_server;
	cesspool_peer_t peers[CESSPOOL_MAX_PEERS]; size_t peer_count;
	cesspool_topic_t topics[CESSPOOL_MAX_TOPICS]; size_t topic_count;
	cesspool_announcement_t announcements[CESSPOOL_MAX_ANNOUNCEMENTS];
	size_t announcement_count;
	uint64_t bootstrap_last_seen, bootstrap_probe_at;
	int bootstrap_reachable;
	cesspool_transaction_t transactions[CESSPOOL_MAX_TRANSACTIONS];
	uint16_t next_transaction;
	void (*on_peer)(struct cesspool *, const cesspool_peer_t *);
	void (*on_holepunch)(struct cesspool *, const cess_peer_t *);
	cesspool_transport_packet_fn on_transport_packet;
	void *transport_context;
} cesspool_t;

int cesspool_identity_init(void);
int cesspool_identity_generate(cesspool_keypair_t *identity);
int cesspool_identity_save(const char *path, const cesspool_keypair_t *identity);
int cesspool_identity_load(const char *path, cesspool_keypair_t *identity);
int cesspool_discovery_key(const uint8_t public_key[32], uint8_t topic[32]);
int cesspool_encode(const cesspool_message_t *, uint8_t *, size_t, size_t *);
int cesspool_decode(cesspool_message_t *, const uint8_t *, size_t);
int cesspool_request_encode(const cesspool_request_t *, uint8_t *, size_t, size_t *);
int cesspool_request_decode(cesspool_request_t *, const uint8_t *, size_t);
int cesspool_response_encode(const cesspool_response_t *, uint8_t *, size_t, size_t *);
int cesspool_response_decode(cesspool_response_t *, const uint8_t *, size_t);
int cesspool_process_response(cesspool_t *, const cesspool_response_t *, const uint8_t[2]);
int cesspool_init(cesspool_t *, const uint8_t peer_id[32]);
int cesspool_add_bootstrap(cesspool_t *, const char *, uint16_t);
int cesspool_configure_bootstraps(cesspool_t *);
int cesspool_bootstrap_config_add(const char *);
int cesspool_bootstrap_config_set(const char *);
int cesspool_bootstrap_config_get(char *, size_t);
int cesspool_bootstrap_config_list(char *, size_t);
int cesspool_bootstrap(cesspool_t *);
int cesspool_listen(cesspool_t *, const char *, uint16_t);
int cesspool_set_bootstrap_server(cesspool_t *, int);
int cesspool_announce(cesspool_t *, const uint8_t[32], uint16_t);
int cesspool_lookup(cesspool_t *, const uint8_t[32]);
int cesspool_unannounce(cesspool_t *, const uint8_t[32], uint16_t);
int cesspool_ping(cesspool_t *, const cess_peer_t *);
int cesspool_holepunch(cesspool_t *, const cess_peer_t *);
int cesspool_poll(cesspool_t *, int);
int cesspool_add_peer(cesspool_t *, const cesspool_peer_t *);
int cesspool_remove_peer(cesspool_t *, const uint8_t[32]);
cesspool_peer_t *cesspool_find_peer(cesspool_t *, const uint8_t[32]);
int cesspool_join(cesspool_t *, const uint8_t[32], uint16_t, int, int);
int cesspool_leave(cesspool_t *, const uint8_t[32]);
int cesspool_tick(cesspool_t *, uint64_t);
size_t cesspool_closest(cesspool_t *, const uint8_t[32], cesspool_peer_t **, size_t);
size_t cesspool_topic_peers(cesspool_t *, const uint8_t[CESSPOOL_TOPIC_BYTES], cesspool_peer_t **, size_t);
size_t cesspool_announced_peer_count(const cesspool_t *);
size_t cesspool_announced_topic_count(const cesspool_t *);
int cesspool_transaction_begin(cesspool_t *, uint8_t, const uint8_t[32], uint64_t, uint16_t *);
int cesspool_transaction_finish(cesspool_t *, uint16_t);
int cesspool_destroy(cesspool_t *);

#endif