link_t mesh_add(mesh_t mesh, lob_t json, pipe_t pipe)
{
link_t link;
lob_t keys, paths;
uint8_t csid;
if(!mesh || !json) return LOG("bad args");
LOG("mesh add %s",lob_json(json));
link = link_get(mesh, hashname_vchar(lob_get(json,"hashname")));
keys = lob_get_json(json,"keys");
paths = lob_get_array(json,"paths");
if(!link) link = link_keys(mesh, keys);
if(!link) LOG("no hashname");
LOG("loading keys/paths");
if(keys && (csid = hashname_id(mesh->keys,keys))) link_load(link, csid, keys);
// handle any pipe/paths
if(pipe) link_pipe(link, pipe);
lob_t path;
for(path=paths;path;path = lob_next(path)) link_path(link,path);
lob_free(keys);
lob_freeall(paths);
return link;
}
int main(int argc, char *argv[])
{
lob_t id, options, json;
mesh_t mesh;
net_udp4_t udp4;
net_tcp4_t tcp4;
int port = 0;
if(argc==2)
{
port = atoi(argv[1]);
}
id = util_fjson("id.json");
if(!id) return -1;
mesh = mesh_new(0);
mesh_load(mesh,lob_get_json(id,"secrets"),lob_get_json(id,"keys"));
mesh_on_discover(mesh,"auto",mesh_add); // auto-link anyone
mesh_on_open(mesh,"path",path_on_open); // add path support
options = lob_new();
lob_set_int(options,"port",port);
udp4 = net_udp4_new(mesh, options);
util_sock_timeout(udp4->server,100);
tcp4 = net_tcp4_new(mesh, options);
json = mesh_json(mesh);
printf("%s\n",lob_json(json));
printf("%s\n",mesh_uri(mesh, NULL));
while(net_udp4_receive(udp4) && net_tcp4_loop(tcp4));
/*
if(util_loadjson(s) != 0 || (sock = util_server(0,1000)) <= 0)
{
printf("failed to startup %s or %s\n", strerror(errno), crypt_err());
return -1;
}
printf("loaded hashname %s\n",s->id->hexname);
// create/send a ping packet
c = chan_new(s, bucket_get(s->seeds, 0), "link", 0);
p = chan_packet(c);
chan_send(c, p);
util_sendall(s,sock);
in = path_new("ipv4");
while(util_readone(s, sock, in) == 0)
{
switch_loop(s);
while((c = switch_pop(s)))
{
printf("channel active %d %s %s\n",c->ended,c->hexid,c->to->hexname);
if(util_cmp(c->type,"connect") == 0) ext_connect(c);
if(util_cmp(c->type,"link") == 0) ext_link(c);
if(util_cmp(c->type,"path") == 0) ext_path(c);
while((p = chan_pop(c)))
{
printf("unhandled channel packet %.*s\n", p->json_len, p->json);
lob_free(p);
}
}
util_sendall(s,sock);
}
*/
perror("exiting");
return 0;
}
// processes incoming packet, it will take ownership of p
link_t mesh_receive(mesh_t mesh, lob_t outer, pipe_t pipe)
{
lob_t inner;
link_t link;
char token[17];
hashname_t id;
if(!mesh || !outer || !pipe) return LOG("bad args");
LOG("mesh receiving %s to %s via pipe %s",outer->head_len?"handshake":"channel",hashname_short(mesh->id),pipe->id);
// process handshakes
if(outer->head_len == 1)
{
inner = e3x_self_decrypt(mesh->self, outer);
if(!inner)
{
LOG("%02x handshake failed %s",outer->head[0],e3x_err());
lob_free(outer);
return NULL;
}
// couple the two together, inner->outer
lob_link(inner,outer);
// set the unique id string based on some of the first 16 (routing token) bytes in the body
base32_encode(outer->body,10,token,17);
lob_set(inner,"id",token);
// process the handshake
return mesh_receive_handshake(mesh, inner, pipe);
}
// handle channel packets
if(outer->head_len == 0)
{
if(outer->body_len < 16)
{
LOG("packet too small %d",outer->body_len);
lob_free(outer);
return NULL;
}
route_t route;
for(route = mesh->routes;route;route = route->next) if(memcmp(route->token,outer->body,8) == 0) break;
link = route ? route->link : NULL;
if(!link)
{
LOG("dropping, no link for token %s",util_hex(outer->body,16,NULL));
lob_free(outer);
return NULL;
}
// forward packet
if(!route->flag)
{
LOG("forwarding route token %s via %s len %d",util_hex(route->token,8,NULL),hashname_short(link->id),lob_len(outer));
return link_send(link, outer);
}
inner = e3x_exchange_receive(link->x, outer);
lob_free(outer);
if(!inner) return LOG("channel decryption fail for link %s %s",hashname_short(link->id),e3x_err());
LOG("channel packet %d bytes from %s",lob_len(inner),hashname_short(link->id));
return link_receive(link,inner,pipe);
}
// transform incoming bare link json format into handshake for discovery
if((inner = lob_get_json(outer,"keys")))
{
if((id = hashname_vkeys(inner)))
{
lob_set(outer,"hashname",hashname_char(id));
lob_set_int(outer,"at",0);
lob_set(outer,"type","link");
LOG("bare incoming link json being discovered %s",lob_json(outer));
}
lob_free(inner);
}
// run everything else through discovery, usually plain handshakes
mesh_discover(mesh, outer, pipe);
link = mesh_linked(mesh, lob_get(outer,"hashname"), 0);
lob_free(outer);
return link;
}
// usually sets/updates event timer, ret if accepted/valid into receiving queue
uint8_t e3x_channel_receive(e3x_channel_t c, lob_t inner)
{
lob_t prev, miss;
uint32_t ack;
if(!c || !inner) return 1;
// TODO timer checks
if(inner == c->timer)
{
// uhoh or resend
return 1;
}
// no reliability, just append and done
if(!c->seq)
{
c->in = lob_push(c->in, inner);
return 0;
}
// reliability
inner->id = lob_get_uint(inner, "seq");
// if there's an id, it's content
if(inner->id)
{
if(inner->id <= c->acked)
{
LOG("dropping old seq %d",inner->id);
return 1;
}
// insert it sorted
prev = c->in;
while(prev && prev->id > inner->id) prev = prev->next;
if(prev && prev->id == inner->id)
{
LOG("dropping dup seq %d",inner->id);
lob_free(inner);
return 1;
}
c->in = lob_insert(c->in, prev, inner);
// LOG("inserted seq %d",c->in?c->in->id:-1);
}
// remove any from outgoing cache that have been ack'd
if((ack = lob_get_uint(inner, "ack")))
{
prev = c->out;
while(prev && prev->id <= ack)
{
c->out = lob_splice(c->out, prev);
lob_free(prev); // TODO, notify app this packet was ack'd
prev = c->out;
}
// process array, update list of packets that are missed or not
if((miss = lob_get_json(inner, "miss")))
{
// set resend flag timestamp on them
// update window
}
}
// TODO reset timer stuff
return 0;
}
int main(int argc, char **argv)
{
lob_t id;
mesh_t mesh;
lob_t opts = lob_new();
fail_unless(e3x_init(opts) == 0);
fail_unless(!e3x_err());
// need cs1a support to continue testing
e3x_cipher_t cs = e3x_cipher_set(0x1a,NULL);
if(!cs) return 0;
cs = e3x_cipher_set(0,"1a");
fail_unless(cs);
fail_unless(cs->id == CS_1a);
uint8_t buf[32];
fail_unless(e3x_rand(buf,32));
char hex[65];
util_hex(e3x_hash((uint8_t*)"foo",3,buf),32,hex);
fail_unless(strcmp(hex,"2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae") == 0);
id = util_fjson("/Users/chrigel/.id.json");
if(!id) return -1;
lob_t secrets = lob_get_json(id,"secrets");
fail_unless(secrets);
fail_unless(lob_get(secrets,"1a"));
lob_t keys = lob_get_json(id,"keys");
fail_unless(keys);
fail_unless(lob_get(keys,"1a"));
LOG("generated key %s secret %s",lob_get(keys,"1a"),lob_get(secrets,"1a"));
local_t localA = cs->local_new(keys,secrets);
fail_unless(localA);
remote_t remoteA = cs->remote_new(lob_get_base32(keys,"1a"), NULL);
fail_unless(remoteA);
// create another to start testing real packets
lob_t secretsB = e3x_generate();
fail_unless(lob_linked(secretsB));
printf("XX %s\n",lob_json(lob_linked(secretsB)));
local_t localB = cs->local_new(lob_linked(secretsB),secretsB);
fail_unless(localB);
remote_t remoteB = cs->remote_new(lob_get_base32(lob_linked(secretsB),"1a"), NULL);
fail_unless(remoteB);
// generate a message
lob_t messageAB = lob_new();
lob_set_int(messageAB,"a",42);
lob_t outerAB = cs->remote_encrypt(remoteB,localA,messageAB);
fail_unless(outerAB);
fail_unless(lob_len(outerAB) == 42);
// decrypt and verify it
lob_t innerAB = cs->local_decrypt(localB,outerAB);
fail_unless(innerAB);
fail_unless(lob_get_int(innerAB,"a") == 42);
fail_unless(cs->remote_verify(remoteA,localB,outerAB) == 0);
ephemeral_t ephemBA = cs->ephemeral_new(remoteA,outerAB);
fail_unless(ephemBA);
lob_t channelBA = lob_new();
lob_set(channelBA,"type","foo");
lob_t couterBA = cs->ephemeral_encrypt(ephemBA,channelBA);
fail_unless(couterBA);
fail_unless(lob_len(couterBA) == 42);
lob_t outerBA = cs->remote_encrypt(remoteA,localB,messageAB);
fail_unless(outerBA);
ephemeral_t ephemAB = cs->ephemeral_new(remoteB,outerBA);
fail_unless(ephemAB);
lob_t cinnerAB = cs->ephemeral_decrypt(ephemAB,couterBA);
fail_unless(cinnerAB);
fail_unless(util_cmp(lob_get(cinnerAB,"type"),"foo") == 0);
return 0;
}
