ExternalVendorCode/serval-dna
1
0
Fork 0
mirror of https://github.com/servalproject/serval-dna.git synced 2025-02-22 18:12:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Simplify id peers command, hide mdp implementation details from node info

Browse Source
This commit is contained in:
Jeremy Lakeman 2012-10-03 16:21:06 +09:30
parent b72c01518b
commit 32cd46c165
4 changed files with 88 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
commandline.c
View File

@ -1400,8 +1400,6 @@ int app_id_self(int argc, const char *const *argv, struct command_line_option *o
else else
return WHYF("unsupported arg '%s'", argv[1]); return WHYF("unsupported arg '%s'", argv[1]);
a.addrlist.first_sid=0; a.addrlist.first_sid=0;
a.addrlist.last_sid=0x7fffffff;
a.addrlist.frame_sid_count=MDP_MAX_SID_REQUEST;
while(a.addrlist.frame_sid_count==MDP_MAX_SID_REQUEST) { while(a.addrlist.frame_sid_count==MDP_MAX_SID_REQUEST) {
result=overlay_mdp_send(&a,MDP_AWAITREPLY,5000); result=overlay_mdp_send(&a,MDP_AWAITREPLY,5000);

106
overlay_mdp.c
View File

@ -934,41 +934,63 @@ int overlay_mdp_dispatch(overlay_mdp_frame *mdp,int userGeneratedFrameP,
RETURN(0); RETURN(0);
} }
struct search_state{
overlay_mdp_frame *mdp;
overlay_mdp_frame *mdpreply;
int first;
int max;
int index;
int count;
};
static int search_subscribers(struct subscriber *subscriber, void *context){ static int search_subscribers(struct subscriber *subscriber, void *context){
struct search_state *state = context; overlay_mdp_addrlist *response = context;
if (state->mdp->addrlist.mode == MDP_ADDRLIST_MODE_SELF && subscriber->reachable != REACHABLE_SELF){ if (response->mode == MDP_ADDRLIST_MODE_SELF && subscriber->reachable != REACHABLE_SELF){
return 0; return 0;
} }
if (state->mdp->addrlist.mode == MDP_ADDRLIST_MODE_ROUTABLE_PEERS && if (response->mode == MDP_ADDRLIST_MODE_ROUTABLE_PEERS &&
(subscriber->reachable != REACHABLE_DIRECT && (subscriber->reachable != REACHABLE_DIRECT &&
subscriber->reachable != REACHABLE_INDIRECT && subscriber->reachable != REACHABLE_INDIRECT &&
subscriber->reachable != REACHABLE_UNICAST)){ subscriber->reachable != REACHABLE_UNICAST)){
return 0; return 0;
} }
if (state->mdp->addrlist.mode == MDP_ADDRLIST_MODE_ALL_PEERS && if (response->mode == MDP_ADDRLIST_MODE_ALL_PEERS &&
subscriber->reachable == REACHABLE_SELF){ subscriber->reachable == REACHABLE_SELF){
return 0; return 0;
} }
if (state->count++ >= state->first && state->index < state->max) { if (response->server_sid_count++ >= response->first_sid &&
memcpy(state->mdpreply->addrlist.sids[state->index++], subscriber->sid, SID_SIZE); response->first_sid + response->frame_sid_count < response->last_sid) {
memcpy(response->sids[response->frame_sid_count++], subscriber->sid, SID_SIZE);
} }
return 0; return 0;
} }
int overlay_mdp_address_list(overlay_mdp_addrlist *request, overlay_mdp_addrlist *response){
if (debug & DEBUG_MDPREQUESTS)
DEBUGF("MDP_GETADDRS first_sid=%u mode=%d",
request->first_sid,
request->mode
);
/* Prepare reply packet */
response->mode = request->mode;
response->first_sid = request->first_sid;
response->frame_sid_count = 0;
/* ... and constrain list for sanity */
if (response->first_sid<0) response->first_sid=0;
/* Populate with SIDs */
enum_subscribers(NULL, search_subscribers, response);
response->last_sid = response->first_sid + response->frame_sid_count - 1;
if (debug & DEBUG_MDPREQUESTS)
DEBUGF("reply MDP_ADDRLIST first_sid=%u last_sid=%u frame_sid_count=%u server_sid_count=%u",
response->first_sid,
response->last_sid,
response->frame_sid_count,
response->server_sid_count
);
return 0;
}
void overlay_mdp_poll(struct sched_ent *alarm) void overlay_mdp_poll(struct sched_ent *alarm)
{ {
if (alarm->poll.revents & POLLIN) { if (alarm->poll.revents & POLLIN) {
@ -995,63 +1017,25 @@ void overlay_mdp_poll(struct sched_ent *alarm)
if (debug & DEBUG_MDPREQUESTS) DEBUG("MDP_GOODBYE"); if (debug & DEBUG_MDPREQUESTS) DEBUG("MDP_GOODBYE");
overlay_mdp_releasebindings(recvaddr_un,recvaddrlen); overlay_mdp_releasebindings(recvaddr_un,recvaddrlen);
return; return;
/* Deprecated. We can replace with a more generic dump of the routing table */
case MDP_NODEINFO: case MDP_NODEINFO:
if (debug & DEBUG_MDPREQUESTS) DEBUG("MDP_NODEINFO"); if (debug & DEBUG_MDPREQUESTS) DEBUG("MDP_NODEINFO");
overlay_route_node_info(mdp,recvaddr_un,recvaddrlen);
if (!overlay_route_node_info(&mdp->nodeinfo))
overlay_mdp_reply(mdp_named.poll.fd,recvaddr_un,recvaddrlen,mdp);
return; return;
case MDP_GETADDRS: case MDP_GETADDRS:
if (debug & DEBUG_MDPREQUESTS)
DEBUGF("MDP_GETADDRS first_sid=%u last_sid=%u frame_sid_count=%u mode=%d",
mdp->addrlist.first_sid,
mdp->addrlist.last_sid,
mdp->addrlist.frame_sid_count,
mdp->addrlist.mode
);
{ {
overlay_mdp_frame mdpreply; overlay_mdp_frame mdpreply;
/* Work out which SIDs to get ... */
int sid_num=mdp->addrlist.first_sid;
int max_sid=mdp->addrlist.last_sid;
int max_sids=mdp->addrlist.frame_sid_count;
/* ... and constrain list for sanity */
if (sid_num<0) sid_num=0;
if (max_sids>MDP_MAX_SID_REQUEST) max_sids=MDP_MAX_SID_REQUEST;
if (max_sids<0) max_sids=0;
/* Prepare reply packet */
mdpreply.packetTypeAndFlags = MDP_ADDRLIST; mdpreply.packetTypeAndFlags = MDP_ADDRLIST;
mdpreply.addrlist.mode = mdp->addrlist.mode; if (!overlay_mdp_address_list(&mdp->addrlist, &mdpreply.addrlist))
mdpreply.addrlist.first_sid = sid_num;
mdpreply.addrlist.last_sid = max_sid;
mdpreply.addrlist.frame_sid_count = max_sids;
/* Populate with SIDs */
struct search_state state={
.mdp=mdp,
.mdpreply=&mdpreply,
.first=sid_num,
.max=max_sid,
};
enum_subscribers(NULL, search_subscribers, &state);
mdpreply.addrlist.frame_sid_count = state.index;
mdpreply.addrlist.last_sid = sid_num + state.index - 1;
mdpreply.addrlist.server_sid_count = state.count;
if (debug & DEBUG_MDPREQUESTS)
DEBUGF("reply MDP_ADDRLIST first_sid=%u last_sid=%u frame_sid_count=%u server_sid_count=%u",
mdpreply.addrlist.first_sid,
mdpreply.addrlist.last_sid,
mdpreply.addrlist.frame_sid_count,
mdpreply.addrlist.server_sid_count
);
/* Send back to caller */ /* Send back to caller */
overlay_mdp_reply(alarm->poll.fd, overlay_mdp_reply(alarm->poll.fd,
(struct sockaddr_un *)recvaddr,recvaddrlen, (struct sockaddr_un *)recvaddr,recvaddrlen,
&mdpreply); &mdpreply);
return; return;
} }
break; break;

79
overlay_route.c
View File

@ -925,18 +925,17 @@ void overlay_route_tick(struct sched_ent *alarm)
return; return;
} }
int overlay_route_node_info(overlay_mdp_frame *mdp, int overlay_route_node_info(overlay_mdp_nodeinfo *node_info)
struct sockaddr_un *addr,int addrlen)
{ {
time_ms_t now = gettime_ms(); time_ms_t now = gettime_ms();
if (0) if (0)
DEBUGF("Looking for node %s* (prefix len=0x%x)", DEBUGF("Looking for node %s* (prefix len=0x%x)",
alloca_tohex(mdp->nodeinfo.sid, mdp->nodeinfo.sid_prefix_length), alloca_tohex(node_info->sid, node_info->sid_prefix_length),
mdp->nodeinfo.sid_prefix_length node_info->sid_prefix_length
); );
mdp->nodeinfo.foundP=0; node_info->foundP=0;
/* check if it is a local identity */ /* check if it is a local identity */
int cn,in,kp; int cn,in,kp;
@ -946,24 +945,24 @@ int overlay_route_node_info(overlay_mdp_frame *mdp,
if (keyring->contexts[cn]->identities[in]->keypairs[kp]->type if (keyring->contexts[cn]->identities[in]->keypairs[kp]->type
==KEYTYPE_CRYPTOBOX) ==KEYTYPE_CRYPTOBOX)
{ {
if (!memcmp(&mdp->nodeinfo.sid[0], if (!memcmp(&node_info->sid[0],
&keyring->contexts[cn]->identities[in] &keyring->contexts[cn]->identities[in]
->keypairs[kp]->public_key[0], ->keypairs[kp]->public_key[0],
mdp->nodeinfo.sid_prefix_length/2)) node_info->sid_prefix_length/2))
{ {
mdp->nodeinfo.foundP=1; node_info->foundP=1;
mdp->nodeinfo.localP=1; node_info->localP=1;
mdp->nodeinfo.neighbourP=0; node_info->neighbourP=0;
mdp->nodeinfo.time_since_last_observation = 0; node_info->time_since_last_observation = 0;
mdp->nodeinfo.score=256; node_info->score=256;
mdp->nodeinfo.interface_number=-1; node_info->interface_number=-1;
bcopy(&keyring->contexts[cn]->identities[in] bcopy(&keyring->contexts[cn]->identities[in]
->keypairs[kp]->public_key[0], ->keypairs[kp]->public_key[0],
&mdp->nodeinfo.sid[0],SID_SIZE); &node_info->sid[0],SID_SIZE);
mdp->nodeinfo.did[0]=0; node_info->did[0]=0;
if (mdp->nodeinfo.resolve_did) { if (node_info->resolve_did) {
mdp->nodeinfo.resolve_did=0; node_info->resolve_did=0;
int k2; int k2;
for(k2=0;k2<keyring->contexts[cn]->identities[in] for(k2=0;k2<keyring->contexts[cn]->identities[in]
->keypair_count;k2++) ->keypair_count;k2++)
@ -973,64 +972,64 @@ int overlay_route_node_info(overlay_mdp_frame *mdp,
/* private key field has unpacked did */ /* private key field has unpacked did */
bcopy(&keyring->contexts[cn]->identities[in] bcopy(&keyring->contexts[cn]->identities[in]
->keypairs[k2]->private_key[0], ->keypairs[k2]->private_key[0],
&mdp->nodeinfo.did[0], &node_info->did[0],
keyring->contexts[cn]->identities[in] keyring->contexts[cn]->identities[in]
->keypairs[k2]->private_key_len); ->keypairs[k2]->private_key_len);
/* public key has name */ /* public key has name */
bcopy(&keyring->contexts[cn]->identities[in] bcopy(&keyring->contexts[cn]->identities[in]
->keypairs[k2]->public_key[0], ->keypairs[k2]->public_key[0],
&mdp->nodeinfo.name[0], &node_info->name[0],
keyring->contexts[cn]->identities[in] keyring->contexts[cn]->identities[in]
->keypairs[k2]->public_key_len); ->keypairs[k2]->public_key_len);
mdp->nodeinfo.resolve_did=1; node_info->resolve_did=1;
} }
} }
return overlay_mdp_reply(mdp_named.poll.fd,addr,addrlen,mdp); return 0;
} }
} }
struct subscriber *subscriber = find_subscriber(mdp->nodeinfo.sid, mdp->nodeinfo.sid_prefix_length/2, 0); struct subscriber *subscriber = find_subscriber(node_info->sid, node_info->sid_prefix_length/2, 0);
if (subscriber && subscriber->node){ if (subscriber && subscriber->node){
overlay_node *node = subscriber->node; overlay_node *node = subscriber->node;
mdp->nodeinfo.foundP=1; node_info->foundP=1;
mdp->nodeinfo.localP=0; node_info->localP=0;
mdp->nodeinfo.score=-1; node_info->score=-1;
mdp->nodeinfo.interface_number=-1; node_info->interface_number=-1;
mdp->nodeinfo.resolve_did=0; node_info->resolve_did=0;
bcopy(subscriber->sid, bcopy(subscriber->sid,
mdp->nodeinfo.sid,SID_SIZE); node_info->sid,SID_SIZE);
if (subscriber->node->neighbour_id){ if (subscriber->node->neighbour_id){
int n = subscriber->node->neighbour_id; int n = subscriber->node->neighbour_id;
mdp->nodeinfo.neighbourP=1; node_info->neighbourP=1;
mdp->nodeinfo.time_since_last_observation = now - overlay_neighbours[n].last_observation_time_ms; node_info->time_since_last_observation = now - overlay_neighbours[n].last_observation_time_ms;
int i; int i;
for(i=0;i<OVERLAY_MAX_INTERFACES;i++) for(i=0;i<OVERLAY_MAX_INTERFACES;i++)
if (overlay_neighbours[n].scores[i]>mdp->nodeinfo.score) if (overlay_neighbours[n].scores[i]>node_info->score)
{ {
mdp->nodeinfo.score=overlay_neighbours[n].scores[i]; node_info->score=overlay_neighbours[n].scores[i];
mdp->nodeinfo.interface_number=i; node_info->interface_number=i;
} }
}else{ }else{
mdp->nodeinfo.neighbourP=0; node_info->neighbourP=0;
mdp->nodeinfo.time_since_last_observation = -1; node_info->time_since_last_observation = -1;
int o; int o;
for(o=0;o<OVERLAY_MAX_OBSERVATIONS;o++) for(o=0;o<OVERLAY_MAX_OBSERVATIONS;o++)
if (node->observations[o].observed_score) if (node->observations[o].observed_score)
{ {
overlay_node_observation *ob overlay_node_observation *ob
=&node->observations[o]; =&node->observations[o];
if (ob->corrected_score>mdp->nodeinfo.score) { if (ob->corrected_score>node_info->score) {
mdp->nodeinfo.score=ob->corrected_score; node_info->score=ob->corrected_score;
} }
if (mdp->nodeinfo.time_since_last_observation == -1 || now - ob->rx_time < mdp->nodeinfo.time_since_last_observation) if (node_info->time_since_last_observation == -1 || now - ob->rx_time < node_info->time_since_last_observation)
mdp->nodeinfo.time_since_last_observation = now - ob->rx_time; node_info->time_since_last_observation = now - ob->rx_time;
} }
} }
} }
return overlay_mdp_reply(mdp_named.poll.fd,addr,addrlen,mdp); return 0;
} }

3
serval.h
View File

@ -815,8 +815,7 @@ int is_configvarname(const char *arg);
int overlay_mdp_getmyaddr(int index,unsigned char *sid); int overlay_mdp_getmyaddr(int index,unsigned char *sid);
int overlay_mdp_bind(unsigned char *localaddr,int port); int overlay_mdp_bind(unsigned char *localaddr,int port);
int overlay_route_node_info(overlay_mdp_frame *mdp, int overlay_route_node_info(overlay_mdp_nodeinfo *node_info);
struct sockaddr_un *addr,int addrlen);
int overlay_interface_register(char *name, int overlay_interface_register(char *name,
struct in_addr addr, struct in_addr addr,
struct in_addr mask); struct in_addr mask);