int main(int argc, char **argv)
{
mesh_t meshA = mesh_new();
fail_unless(meshA);
mesh_on_link(meshA, "test", link_check); // testing the event being triggered
lob_t secretsA = mesh_generate(meshA);
fail_unless(secretsA);
mesh_t meshB = mesh_new();
fail_unless(meshB);
lob_t secretsB = mesh_generate(meshB);
fail_unless(secretsB);
net_loopback_t pair = net_loopback_new(meshA,meshB);
fail_unless(pair);
link_t linkAB = link_get(meshA, meshB->id);
link_t linkBA = link_get(meshB, meshA->id);
fail_unless(linkAB);
fail_unless(linkBA);
fail_unless(link_resync(linkAB));
fail_unless(link_up(linkAB));
fail_unless(link_up(linkBA));
fail_unless(status);
fail_unless(mesh_process(meshA,1));
fail_unless(mesh_linked(meshA, hashname_char(meshB->id),0));
fail_unless(mesh_unlink(linkAB));
fail_unless(mesh_process(meshA,1));
fail_unless(!mesh_linked(meshA, hashname_char(meshB->id),0));
fail_unless(!status);
return 0;
}
// process an incoming handshake
link_t link_receive_handshake(link_t link, lob_t inner)
{
uint32_t out, at, err;
uint8_t csid = 0;
lob_t outer = lob_linked(inner);
if(!link || !inner || !outer) return LOG("bad args");
// inner/link must be validated by caller already, we just load if missing
if(!link->key)
{
util_unhex(lob_get(inner, "csid"), 2, &csid);
if(!link_load(link, csid, inner))
{
lob_free(inner);
return LOG("load key failed for %s %u %s",hashname_short(link->id),csid,util_hex(inner->body,inner->body_len,NULL));
}
}
if((err = e3x_exchange_verify(link->x,outer)))
{
lob_free(inner);
return LOG("handshake verification fail: %d",err);
}
out = e3x_exchange_out(link->x,0);
at = lob_get_uint(inner,"at");
link_t ready = link_up(link);
// if bad at, always send current handshake
if(e3x_exchange_in(link->x, at) < out)
{
LOG("old handshake: %s (%d,%d,%d)",lob_json(inner),at,out);
link_sync(link);
lob_free(inner);
return link;
}
// try to sync ephemeral key
if(!e3x_exchange_sync(link->x,outer))
{
lob_free(inner);
return LOG("sync failed");
}
// we may need to re-sync
if(out != e3x_exchange_out(link->x,0)) link_sync(link);
// notify of ready state change
if(!ready && link_up(link))
{
LOG("link ready");
mesh_link(link->mesh, link);
}
link->handshake = lob_free(link->handshake);
link->handshake = inner;
return link;
}
// process an incoming handshake
link_t link_receive_handshake(link_t link, lob_t inner, pipe_t pipe)
{
link_t ready;
uint32_t out, err;
seen_t seen;
uint8_t csid = 0;
char *hexid;
lob_t attached, outer = lob_linked(inner);
if(!link || !inner || !outer) return LOG("bad args");
hexid = lob_get(inner, "csid");
if(!lob_get(link->mesh->keys, hexid)) return LOG("unsupported csid %s",hexid);
util_unhex(hexid, 2, &csid);
attached = lob_parse(inner->body, inner->body_len);
if(!link->key && link_key(link->mesh, attached, csid) != link) return LOG("invalid/mismatch link handshake");
if((err = e3x_exchange_verify(link->x,outer))) return LOG("handshake verification fail: %d",err);
out = e3x_exchange_out(link->x,0);
ready = link_up(link);
// if bad at, always send current handshake
if(e3x_exchange_in(link->x, lob_get_uint(inner,"at")) < out)
{
LOG("old/bad at: %s (%d,%d,%d)",lob_json(inner),lob_get_int(inner,"at"),e3x_exchange_in(link->x,0),e3x_exchange_out(link->x,0));
// just reset pipe seen and call link_sync to resend handshake
for(seen = link->pipes;pipe && seen;seen = seen->next) if(seen->pipe == pipe) seen->at = 0;
lob_free(link_sync(link));
return NULL;
}
// trust/add this pipe
if(pipe) link_pipe(link,pipe);
// try to sync ephemeral key
if(!e3x_exchange_sync(link->x,outer)) return LOG("sync failed");
// we may need to re-sync
if(out != e3x_exchange_out(link->x,0)) lob_free(link_sync(link));
// notify of ready state change
if(!ready && link_up(link))
{
LOG("link ready");
mesh_link(link->mesh, link);
}
return link;
}
// force link down, end channels and generate all events
link_t link_down(link_t link)
{
if(!link) return NULL;
LOG("forcing link down for %s",hashname_short(link->id));
// generate down event if up
if(link_up(link))
{
e3x_exchange_down(link->x);
mesh_link(link->mesh, link);
}
// end all channels
chan_t c, cnext;
for(c = link->chans;c;c = cnext)
{
cnext = chan_next(c);
chan_err(c, "disconnected");
chan_process(c, 0);
}
// remove pipe
if(link->send_cb)
{
link->send_cb(link, NULL, link->send_arg); // notify jic
link->send_cb = NULL;
link->send_arg = NULL;
}
return NULL;
}
/*
* Tests if the link and port are both up.
*
* @return [Boolean] true if link is up otherwise false.
*/
static VALUE
port_and_link_up( VALUE self ) {
if ( port_up( self ) == Qtrue && link_up( self ) == Qtrue ) {
return Qtrue;
}
return Qfalse;
}
/**
* @brief linkstatd -- monitor interface status
*
* @param link_up [in] callback when link up
* @param link_down [in] callback when link down
*
* @return 0, if succ; -1, if failed
*/
int linkstatd(void (*link_up)(const char *ifname), void (*link_down)(const char *ifname))
{
int fd = -1;
char ifname[64] = {0};
char msg[1024] = {0};
struct sockaddr_nl sa = {0};
struct ifinfomsg *ifi = NLMSG_DATA(msg);
sa.nl_family = AF_NETLINK;
sa.nl_groups = RTMGRP_LINK;
if ((fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) < 0)
perror("linkstatd socket create");
socket_bind(fd, (struct sockaddr *)&sa);
while (read(fd, msg, sizeof(msg)))
{
if_indextoname(ifi->ifi_index, ifname);
if (ifi->ifi_flags & IFF_RUNNING)
{
if (link_up != NULL) link_up(ifname);
}
else
{
if (link_up != NULL) link_down(ifname);
}
}
return 0;
}
bool DwPcie::IsLinkUp() {
auto phyDebugR1 = PortLogic::DebugR1::Get().ReadFrom(&dbi_);
const bool isLinkUp = phyDebugR1.link_up();
const bool isLinkTraining = phyDebugR1.link_in_training();
return isLinkUp && !isLinkTraining;
}
void link_check(link_t link)
{
status = link_up(link) ? 1 : 0;
LOG("link state change to %s",status?"up":"down");
}
static int connect_pppoe_ses(void)
{
int err=-1;
int rcvbuf; //brcm
// cwu
#if 0
if( pppoe_server == 1 ){
srv_init_ses(ses,devnam);
}else{
client_init_ses(ses,devnam);
}
#endif
client_init_ses(ses,devnam);
#if 0
ses->np=1; /* jamal debug the discovery portion */
#endif
strlcpy(ppp_devnam, devnam, sizeof(ppp_devnam));
//brcm
if (disc_sock > 0) {
rcvbuf=5000;
setsockopt(disc_sock, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
}
err= session_connect ( ses );
/*
* brcm, after pppoe session is up, we don't read disc_sock,
* reduce socket rx buffer to avoid to exhaust all rx buffer
*/
if (disc_sock > 0) {
rcvbuf=256;
setsockopt(disc_sock, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));
}
if(err < 0){
if (!link_up(devnam))
return 0;
else if (!get_sock_intf(devnam))
return 0;
else
poe_fatal(ses,"Failed to negotiate PPPoE connection: %d %m",errno,errno);
}
// cwu
/*
poe_info(ses,"Connecting PPPoE socket: %E %04x %s %p",
ses->sp.sa_addr.pppoe.remote,
ses->sp.sa_addr.pppoe.sid,
ses->sp.sa_addr.pppoe.dev,ses);
*/
err = connect(ses->fd, (struct sockaddr*)&ses->sp,
sizeof(struct sockaddr_pppox));
if( err < 0 ){
poe_fatal(ses,"Failed to connect PPPoE socket: %d %m",errno,errno);
return err;
}
#if 0
if (ses->np)
fatal("discovery complete\n");
#endif
/* Once the logging is fixed, print a message here indicating
connection parameters */
return ses->fd;
}
/*
* Tests if the link is down.
*
* @return [Boolean] true if link is down otherwise false.
*/
static VALUE
link_down( VALUE self ) {
return link_up( self ) == Qfalse ? Qtrue : Qfalse;
}
void handle_input(char *input, char *itc_file , int node_id)
{
int quit_len;
char *inp_ptr;
pthread_t thread;
int srv_len = strlen("start_service");
int exit_len = strlen("exit");
int stop_srv_len = strlen("stop_service");
int connect_len = strlen("connect");
int download_len = strlen("download");
int dump_len = strlen("route_table");
int set_gar_len = strlen("set_garbler");
int link_up_len = strlen("link_up");
int link_down_len = strlen("link_down");
char file_name[NAME_MAX];
int max_connections;
char *app_buffer= (char *)malloc(APP_HEADER_SIZE);
int code;
int dest_node;
int window_size;
quit_len = strlen("quit");
inp_ptr = input;
srand(time(NULL));
if ( strncmp(input,"quit",quit_len) == 0 )
{
printf("\n Quiting ... \n");
exit(EXIT_SUCCESS);
}
if ( strncmp(input,"exit",exit_len) == 0 )
{
printf("\n Quiting ... \n");
exit(EXIT_SUCCESS);
}
if ( strncmp(input,"start_service",srv_len) == 0 )
{
printf("\n Starting Server Thread : SID = %d \n" , rand()% 10000 );
inp_ptr += srv_len ;
sscanf(inp_ptr,"%d", &max_connections);
printf("\n Max connections = %d \n" , max_connections );
init_state(&__max_connections);
set_state(&__max_connections,max_connections);
handle_start_server(itc_file , node_id , inp_ptr , &thread);
}
if ( strncmp(input,"stop_service",stop_srv_len) == 0 )
{
printf("\n stoping the serivce ... \n");
pthread_cancel(thread);
}
if ( strncmp(input,"connect",connect_len) == 0)
{
inp_ptr += connect_len;
sscanf(inp_ptr,"%d",&dest_node);
sscanf(inp_ptr,"%d",&window_size);
nfd_send_buffer_transport("Donkey!" ,8,2);
}
if ( strncmp(input,"route_table",dump_len) == 0)
{
dump_route_table();
printf("\n Route table dumped to file \n");
}
if ( strncmp(input,"link_up",link_up_len) == 0)
{
inp_ptr+=link_up_len;
sscanf(inp_ptr,"%d",&dest_node);
link_up(dest_node);
printf("\n Link upped :) \n");
}
if ( strncmp(input,"link_down",link_down_len) == 0)
{
inp_ptr += link_down_len;
sscanf(inp_ptr,"%d",&dest_node);
link_down(dest_node);
printf("\n Link downed!\n");
}
if ( strncmp(input,"download",download_len) == 0 )
{
inp_ptr += download_len;
sscanf(inp_ptr , "%d%s" , &dest_node , file_name);
code = CODE_GET ;
pack_into_packet(app_buffer, CODE_OFFSET , &code , CODE_SIZE);
pack_into_packet(app_buffer ,FILENAME_OFFSET , file_name , strlen(file_name) +1 );
printf("\n Currnet node = %d " , __current_node );
pack_into_packet(app_buffer , SRC_ID_OFFSET , &__current_node , SRC_ID_SIZE);
nfd_send_buffer_transport(app_buffer,APP_HEADER_SIZE,dest_node);
}
if ( strncmp(input,"set_garbler",set_gar_len) == 0)
{
inp_ptr += connect_len;
sscanf(inp_ptr,"%d%d",&__loss_frac , &__corr_fact);
fprintf(stderr ,"\n garbler charecteristics set ... \n");
}
}
