int log_energymap(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); int i = get_node_count(); FILE *file = NULL; char file_map[100]; double time = get_time() * 0.000001; /* create file */ sprintf(file_map, "%s/%s.%.0lf.data", entitydata->directory, entitydata->map_prefix, time); if ((file = fopen(file_map, "w+")) == NULL) { fprintf(stderr, "My monitor: can not open file %s in monitor_event()\n", file_map); return -1; } /* log energy map */ while (i--) { call_t c0 = {-1, i, -1}; position_t *position = get_node_position(c0.node); fprintf(file, "%d %lf %lf %lf %lf\n", c0.node, position->x, position->y, position->z, battery_status(&c0)); } /* log virtual nodes for the 4 area corners */ fprintf(file, "%d %lf %lf %lf %lf\n", -1, 0.0, 0.0, 0.0, 1.0); fprintf(file, "%d %lf %lf %lf %lf\n", -1, get_topology_area()->x, 0.0, 0.0, 1.0); fprintf(file, "%d %lf %lf %lf %lf\n", -1, 0.0, get_topology_area()->y, 0.0, 1.0); fprintf(file, "%d %lf %lf %lf %lf\n", -1, get_topology_area()->x, get_topology_area()->y, 0.0, 1.0); fclose(file); return 0; }
double setRangeToFarestNeighbour(call_t *c, graphe* g, arbre* bipTree) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); // calcul de la distance entre ce noeud et son voisin 1-hop (dans l'arbre de BIP) le plus eloigne list *fils = 0; double distMax = 0, dist; position_t pos; arbre_get_fils(&fils, bipTree, c->node); while(fils != 0) { pos = listeNodes_getPos(nodedata->oneHopNeighbourhood, fils->val); dist = distance(get_node_position(c->node), &pos); if(dist > distMax) { distMax = dist; } fils = fils->suiv; } // set le range du module propagation a la valeur desiree set_range_Tr(c, distMax); //printf("rayon d'emission de %d fixe a %lf\n", c->node, macdata->range); return distMax; }
/* ************************************************** */ int setnode(call_t *c, void *params) { int id, found = 0; double x, y, z; struct entitydata *entitydata = get_entity_private_data(c); char str[128]; /* position at the beginning */ fseek(entitydata->file, 0L, SEEK_SET); while (fgets(str, 128, entitydata->file) != NULL) { sscanf(str, "%d %lf %lf %lf\n", &id, &x, &y, &z); if (id == c->node) { found = 1; get_node_position(c->node)->x = x; get_node_position(c->node)->y = y; get_node_position(c->node)->z = z; break; } } if (found == 0) { fprintf(stderr, "filestatic: node %d position not found (setnode())\n", c->node); return -1; } return 0; }
/* ************************************************** */ int event_callback(call_t *c, void *data) { struct _env_data *entitydata = get_entity_private_data(c); struct _collec_event *event = (struct _collec_event *) data; call_t c0; array_t *app_layer = NULL; int type, value; /* Execute the event using an IOCTL */ type = event->event_type; value = event->event_value; c0.node = event->node_id; app_layer = get_application_entities(&c0); c0.entity = app_layer->elts[0]; IOCTL(&c0, type, &value, 0); DBG("Time %"PRId64", IOCTL for node %d, type %d, value %d\n", event->time, event->node_id, type, value); /* Delete the event */ free(event); /* Schedule the next event */ event = (struct _collec_event *) sodas_pop(entitydata->events); if (event == NULL) { DBG("No more events in queue\n"); return 0; } scheduler_add_callback(event->time, c, event_callback, event); return 0; }
/* ************************************************** */ int setnode(call_t *c, void *params) { struct entitydata *entitydata = get_entity_private_data(c); struct nodedata *nodedata = malloc(sizeof(struct nodedata)); char str[128]; int id, dst, n_hop; /* extract routing table from file */ nodedata->routes = hadas_create(route_hash, route_equal); /* extract routing table from file */ fseek(entitydata->file, 0L, SEEK_SET); while (fgets(str, 128, entitydata->file) != NULL) { if (sscanf(str, "%d %d %d\n", &id, &dst, &n_hop) != 3) { fprintf(stderr, "filestatic: unable to read route in setnode()\n"); goto error; } if (id == c->node) { struct route *route = (struct route *) malloc(sizeof(struct route)); route->dst = dst; route->n_hop = n_hop; hadas_insert(nodedata->routes, (void *) ((unsigned long) (route->dst)), (void *) route); } } nodedata->overhead = -1; set_node_private_data(c, nodedata); return 0; error: free(entitydata); return -1; }
/* ************************************************** */ double interfere(call_t *c, int channel0, int channel1) { struct entitydata *entitydata = get_entity_private_data(c); if (channel0 == channel1) { return 1; } else { return entitydata->factor; } }
/* ************************************************** */ double modulate(call_t *c, double snr) { struct entitydata *entitydata = get_entity_private_data(c); if (snr >= entitydata->step) { return 0; } else { return 0.5; } }
/* *********************************************** */ int set_header( call_t *c , packet_t * packet , destination_t * dst ) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata =get_entity_private_data(c); packet_PROTOCOLE *data = (packet_PROTOCOLE *) (packet->data + nodedata->overhead); //augmenter le nbr d'evenement nodedata->nbr_evenement++; if(entitydata->debug) DBG("RBOP - %d SET HEADER \n",c->node); //Fixé le rayon if(nodedata->range<0) { listeNodes *tmp=nodedata->oneHopNeighbourhood; position_t pos1 = *get_node_position(c->node); double distMax = 0; while(tmp) { if(list_recherche(nodedata->RNG,tmp->values.node)) { position_t pos2= {tmp->values.x,tmp->values.y,tmp->values.z}; double dist=distance(&pos1,&pos2); if(distMax<dist) distMax=dist; } tmp=tmp->suiv; } set_range_Tr(c,distMax); nodedata->range=get_range_Tr(c); if(entitydata->debug) DBG("RBOP - %d FIXE RANGE TO %.2lf \n",c->node,get_range_Tr(c)); } //remplissage de data data->type=RBOP; data->src=c->node; data->src_pos=*get_node_position(c->node); data->seq=nodedata->nbr_evenement; data->redirected_by=c->node; data->destinations=Nullptr(list); list_copy(&data->destinations,nodedata->RNG); list_PACKET_insert_tout(&nodedata->paquets,data->src,data->seq,data->redirected_by); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; destination_t destination = {BROADCAST_ADDR, {-1, -1, -1}}; return SET_HEADER(&c0, packet, &destination); }
int destroy(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); if (entitydata->file != NULL) { fclose(entitydata->file); } free(entitydata); return 0; }
/* ************************************************** */ void register_callback(call_t *c, callback_t callback, void *arg) { struct entitydata *entitydata = get_entity_private_data(c); struct monitor_callback *call = malloc(sizeof(struct monitor_callback)); call->callback = callback; call->c.entity = c->from; call->c.node = c->node; call->c.from = -1; call->arg = arg; das_insert(entitydata->callbacks, (void *) call); return; }
/* ************************************************** */ void monitor_death(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); /* log node death */ entitydata->nbr_nodes--; /* log active nodes number */ log_activenodes(c); /* monitor */ monitor_event(c); }
void tx( call_t *c , packet_t * packet ) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); if(entitydata->debug) DBG("LBOP BROADCAST - ON %d WITH RANGE %.2lf At %lf \n",c->node,get_range_Tr(c), get_time_now_second()); entityid_t *down = get_entity_links_down(c); call_t c0 = {down[0], c->node}; TX(&c0,packet); }
/* ************************************************** */ double propagation(call_t *c, packet_t *packet, nodeid_t src, nodeid_t dst, double rxdBm) { struct entitydata *entitydata = get_entity_private_data(c); double rx_dBm = rxdBm; switch(entitydata->propagation){ case FREESPACE : rx_dBm = compute_freespace(entitydata, src, dst, rxdBm); break; case TWORAYGROUND : rx_dBm = compute_tworayground(entitydata, src, dst, rxdBm); break; case LOGDISTANCE : rx_dBm = compute_logdistance_pathloss(entitydata, src, dst, rxdBm); break; case LOGNORMAL : rx_dBm = compute_lognormal_shadowing(entitydata, src, dst, rxdBm); break; default : rx_dBm = rxdBm; /* should not happen */ } return rx_dBm + compute_fading(entitydata); }
/* ************************************************** */ void monitor_event(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); struct monitor_callback *callback; /* log energy map */ log_energymap(c); /* call callbacks */ das_init_traverse(entitydata->callbacks); while ((callback = (struct monitor_callback *) das_traverse(entitydata->callbacks)) != NULL) { callback->callback(&(callback->c), callback->arg); } }
/* ************************************************** */ double freespace(call_t *c, packet_t *packet, double dist, double rxmW) { struct entitydata *entitydata = get_entity_private_data(c); /* * Pt * Gt * Gr * lambda^2 * Pr(d) = ------------------------- * (4 * pi * d)^2 * L * * Note: rxmW = Pt * Gt * Gr, and L = 1 * * cf p71 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996. * */ return (rxmW * entitydata->factor*entitydata->factor / pow(dist, 2)); }
/* ************************************************** */ double propagation(call_t *c, packet_t *packet, nodeid_t src, nodeid_t dst, double rxdBm) { struct entitydata *entitydata = get_entity_private_data(c); double success = *(entitydata->success + (src * entitydata->node_cnt) + dst); if (success == 1) { return rxdBm; } else if (success == 0) { return MIN_DBM; } else if (get_random_double() <= success) { return rxdBm; } else { return MIN_DBM; } }
int destroy(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); long int total = entitydata->TX_hello + entitydata->TX_data + entitydata->TX_query + entitydata->TX_response + entitydata->TX_sensor_adv + entitydata->TX_sensor_data + entitydata->TX_home_adv; double total_virtual = entitydata->TX_hello*0.5 + entitydata->TX_data + entitydata->TX_query + entitydata->TX_response + entitydata->TX_sensor_adv*0.5 + entitydata->TX_sensor_data + entitydata->TX_home_adv*0.5; long int total_octets = entitydata->TX_hello*sizeof(struct xy_hello_p) + entitydata->TX_data*sizeof(struct xy_data_p) + entitydata->TX_query*sizeof(struct xy_request_p) + entitydata->TX_response*sizeof(struct xy_response_p) + entitydata->TX_sensor_adv*sizeof(struct sensor_adv_p) + entitydata->TX_sensor_data*sizeof(struct sensor_data_p) + entitydata->TX_home_adv*sizeof(struct home_adv_p); printf("[ENERGY] HELLO %d DATA %d QUERY %d RESPONSE %d SENSOR_ADV %d SENSOR_DATA %d HOME_ADV %d TOTAL %ld TOTAL_VIRTUAL %lf TOTAL_OCTETS %ld\n", entitydata->TX_hello, entitydata->TX_data, entitydata->TX_query, entitydata->TX_response, entitydata->TX_sensor_adv, entitydata->TX_sensor_data, entitydata->TX_home_adv, total, total_virtual, total_octets); free(entitydata); return 0; }
/* ************************************************** */ int bootstrap(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); /* log initial active nodes number */ log_activenodes(c); /* log initial energy map */ log_energymap(c); if (entitydata->map_period > 0) { scheduler_add_callback(entitydata->map_period, c, map_callback, NULL); } return 0; }
int destroy(call_t *c) { struct _env_data *entitydata = get_entity_private_data(c); struct _collec_event *event; /* Free the pending events */ while ((event = (struct _collec_event *) sodas_pop(entitydata->events)) != NULL) { free(event); } /* Free the event list */ sodas_destroy(entitydata->events); free(entitydata); return 0; }
int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* get mac header overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); broadcast_hello(c, NULL); uint64_t at=get_time_now()+time_seconds_to_nanos(3); scheduler_add_callback(at, c, init_rbop, NULL); return 0; }
/* ************************************************** */ int bootstrap(call_t *c) { struct _env_data *entitydata = get_entity_private_data(c); struct _collec_event *event = NULL; /* Get the first event */ event = (struct _collec_event *) sodas_pop(entitydata->events); if (event == NULL) { DBG("ERROR: no events in queue\n"); return 0; } /* Schedule the first event */ scheduler_add_callback(event->time, c, event_callback, event); return 0; }
int destroy(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); struct monitor_callback *callback; long time = (long) (get_time() * 0.000001); fprintf(entitydata->filenode, "%ld %d\n", time, entitydata->nbr_nodes); while ((callback = (struct monitor_callback *) das_pop(entitydata->callbacks)) != NULL) { free(callback); } das_destroy(entitydata->callbacks); if (entitydata->filenode) { fclose(entitydata->filenode); } free(entitydata); return 0; }
/* Periodic exchange of hello packets */ int hello_callback(call_t *c, void *args) { struct entitydata *entitydata = get_entity_private_data(c); struct nodedata *nodedata = get_node_private_data(c); entityid_t *down = get_entity_links_down(c); call_t c0 = {down[0], c->node, c->entity}; destination_t destination = {BROADCAST_ADDR, {-1, -1, -1}}; packet_t *packet = packet_create(c, nodedata->overhead + sizeof(struct xy_hello_p), -1); struct xy_hello_p *hello = (struct xy_hello_p *) (packet->data + nodedata->overhead); position_t *pos = get_node_position(c->node); /* set mac header */ if (SET_HEADER(&c0, packet, &destination) == -1) { packet_dealloc(packet); return -1; } /* set header */ hello->type = XY_HELLO_TYPE; hello->src = c->node; hello->position.x = pos->x; hello->position.y = pos->y; hello->position.z = pos->z; TX(&c0, packet); entitydata->TX_hello++; /* check neighbors timeout */ if (nodedata->h_timeout > 0) { das_selective_delete(nodedata->neighbors, neighbor_timeout, (void *) c); } /* schedules hello */ if (nodedata->h_nbr > 0) { nodedata->h_nbr --; } if (nodedata->h_nbr == -1 || nodedata->h_nbr > 0) { scheduler_add_callback(get_time() + nodedata->h_period, c, hello_callback, NULL); } return 0; }
/* ************************************************** */ double propagation(call_t *c, packet_t *packet, nodeid_t src, nodeid_t dst, double rxdBm) { struct entitydata *entitydata = get_entity_private_data(c); double dist = distance(get_node_position(src), get_node_position(dst)); /* * Pr_dBm(d) = Pr_dBm(d0) - 10 * beta * log10(d/d0) * * Note: rxdBm = [Pt + Gt + Gr]_dBm, and L = 1 * * cf p102-104 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996. * */ if (dist <= 1) { return entitydata->Pr0 + rxdBm; } else { return entitydata->Pr0 + rxdBm - 10.0 * entitydata->pathloss * log10(dist); } }
void forward(call_t* c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); array_t *down = get_entity_bindings_down(c); packet_PROTOCOLE *data = (packet_PROTOCOLE *) (packet->data + nodedata->overhead); //printf("%d doit relayer depuis %d\n", c->node, data->pred); // construire le bip tree pour relayer a partir des infos du paquet int indice = listeNodes_get_index(data->askedToRedirect, c->node); graphe* g = purgeGraphe(c, listeNodes_get(data->needsToBeCovered, indice), data->src, data->pred); arbre* bipTree = computeBIPtree(c, g, data->askedToRedirect, data->needsToBeCovered, 0); if(entitydata->debug) { printf("%d relai depuis %d :\n", c->node, data->pred); arbre_affiche(bipTree); } // relayer le paquet destination_t dst = {-1,{-1,-1,-1}}; double cout = setRangeToFarestNeighbour(c, g, bipTree); //listeNodes_detruire(&data->askedToRedirect); data->askedToRedirect = 0; //listeNodes_detruire(&data->needsToBeCovered); data->needsToBeCovered = 0; data->pred = c->node; //call_t c0 = {-1,c->node,-1}; //data->energyRem = battery_remaining(&c0) - cout; //nodedata->energiesRem[c->node] = data->energyRem; setRelayNodes(c, g, bipTree, &data->askedToRedirect, &data->needsToBeCovered, c->node); call_t c_down = {down->elts[0], c->node, c->entity}; SET_HEADER(&c_down, packet, &dst); tx(c, packet); arbre_detruire(&bipTree); deleteGraphe(g); free(g); }
int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* get mac header overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); int i; for(i = 0 ; i < get_node_count() ; i++) { nodedata->lastIDs[i] = -1; nodedata->energiesRem[i] = battery_remaining(c) - 2*getCoutFromDistance(getRange(c), entitydata->alpha, entitydata->c); } broadcast_hello(c, NULL); uint64_t at=get_time_now()+time_seconds_to_nanos(2); scheduler_add_callback(at, c, broadcast_hello2, NULL); return 0; }
/* ************************************************** */ double propagation(call_t *c, packet_t *packet, nodeid_t src, nodeid_t dst, double rxdBm) { struct entitydata *entitydata = get_entity_private_data(c); double dist, powerloss_dbm; /* * Pr_dBm(d) = Pr_dBm(d0) - 10 * beta * log10(d/d0) + X * * Note: rxdBm = [Pt + Gt + Gr]_dBm, L = 1, and X a normal distributed RV (in dBm) * * cf p104-105 ref "Wireless Communications: Principles and Practice", Theodore Rappaport, 1996. * */ if (rxdBm != entitydata->last_rxdBm) { entitydata->Pr0 = freespace(c, packet, entitydata->dist0, dBm2mW(rxdBm)); entitydata->last_rxdBm = rxdBm; } dist = distance(get_node_position(src), get_node_position(dst)); powerloss_dbm = -10.0 * entitydata->pathloss * log10(dist/entitydata->dist0) + normal(0.0, entitydata->deviation); return mW2dBm(entitydata->Pr0) + powerloss_dbm; }
/* ************************************************** */ void rx_source_adv(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct entitydata *entitydata = get_entity_private_data(c); struct source_adv_p *source = (struct source_adv_p *) (packet->data + nodedata->overhead); struct sensor_adv_p *sensor; packet_t *packet0; destination_t dst = {BROADCAST_ADDR, {-1, -1, -1}}; entityid_t *down = get_entity_links_down(c); call_t c0 = {down[0], c->node, c->entity}; /* check adv sequence */ if (source->s_seq <= nodedata->s_seq[source->source]) { /* old request */ packet_dealloc(packet); return; } nodedata->s_seq[source->source] = source->s_seq; /* reply */ packet0 = packet_create(c, nodedata->overhead + sizeof(struct sensor_adv_p), -1); sensor = (struct sensor_adv_p *) (packet0->data + nodedata->overhead); if (SET_HEADER(&c0, packet0, &dst) == -1) { packet_dealloc(packet); packet_dealloc(packet0); return; } sensor->type = SENSOR_ADV_TYPE; sensor->sensor = c->node; sensor->source = source->source; sensor->s_seq = source->s_seq; TX(&c0, packet0); entitydata->TX_sensor_adv++; packet_dealloc(packet); return; }
int destroy(call_t *c) { free(get_entity_private_data(c)); return 0; }
/* received a request from a sensor */ void rx_xy_request(call_t *c, packet_t *packet) { struct nodedata *nodedata = get_node_private_data(c); struct entitydata *entitydata = get_entity_private_data(c); struct xy_request_p *request = (struct xy_request_p *) (packet->data + nodedata->overhead); position_t rdv_position; struct xy_neighbor *n_hop; entityid_t *down = get_entity_links_down(c); call_t c0 = {down[0], c->node, c->entity}; /* are we the next hop */ if (request->n_hop != c->node) { packet_dealloc(packet); return; } /* do we have the requested data (or some more recent data) ? */ if (request->d_seq <= nodedata->d_seq[request->metadata]) { packet_t *packet0; destination_t dst = {BROADCAST_ADDR, {-1, -1, -1}}; n_hop = xy_next_hop(c, &(request->position)); if (n_hop == NULL) { struct sensor_data_p *data; packet0 = packet_create(c, nodedata->overhead + sizeof(struct sensor_data_p), -1); data = (struct sensor_data_p *) (packet0->data + nodedata->overhead); if (SET_HEADER(&c0, packet0, &dst) == -1) { packet_dealloc(packet); packet_dealloc(packet0); return; } data->type = SENSOR_DATA_TYPE; data->metadata = request->metadata; data->sink = request->sink; data->r_seq = request->r_seq; data->source = nodedata->d_source[request->metadata]; data->d_seq = nodedata->d_seq[request->metadata]; data->d_value = nodedata->d_value[request->metadata]; data->delay = nodedata->d_time[request->metadata]; data->hop = nodedata->d_hop[request->metadata]; #ifdef LOG_APPLICATION_REQUEST printf("[XY] Node %d (%lf,%lf) : broadcasting DATA REPLY (%d,%d,%d) to sink %d (%lf,%lf)\n", c->node, (get_node_position(c->node))->x, (get_node_position(c->node))->y, nodedata->d_source[request->metadata], request->metadata, nodedata->d_seq[request->metadata], request->sink, (get_node_position(request->sink))->x, (get_node_position(request->sink))->y); #endif TX(&c0, packet0); entitydata->TX_sensor_data++; packet_dealloc(packet); return; } else { struct xy_response_p *response; /* reply */ packet0 = packet_create(c, nodedata->overhead + sizeof(struct xy_response_p), -1); response = (struct xy_response_p *) (packet0->data + nodedata->overhead); if (SET_HEADER(&c0, packet0, &dst) == -1) { packet_dealloc(packet); packet_dealloc(packet0); return; } response->type = XY_RESPONSE_TYPE; response->n_hop = n_hop->id; response->metadata = request->metadata; response->sink = request->sink; response->r_seq = request->r_seq; response->source = nodedata->d_source[request->metadata]; response->d_seq = nodedata->d_seq[request->metadata]; response->d_value = nodedata->d_value[request->metadata]; response->time = nodedata->d_time[request->metadata]; response->hop = nodedata->d_hop[request->metadata]; response->position.x = request->position.x; response->position.y = request->position.y; response->position.z = request->position.z; TX(&c0, packet0); entitydata->TX_response++; packet_dealloc(packet); return; } } /* forwards the query towards the specified direction */ else { switch(request->direction){ case DIRECTION_EAST: rdv_position.x = (get_topology_area())->x; rdv_position.y = (get_node_position(c->node))->y; rdv_position.z = 0.0; break; case DIRECTION_WEST: rdv_position.x = 0.0; rdv_position.y = (get_node_position(c->node))->y; rdv_position.z = 0.0; break; default: #ifdef LOG_APPLICATION_REQUEST_ROUTING printf("[XY] Node %d (%lf,%lf) received a DATA with incorrect forwarding direction (%c) !\n",c->node,(get_node_position(c->node))->x,(get_node_position(c->node))->y,request->direction); #endif packet_dealloc(packet); return; } /* get next hop */ n_hop = xy_next_hop(c, &rdv_position); if (n_hop != NULL) { #ifdef LOG_APPLICATION_REQUEST_ROUTING printf("[XY] node %d (%lf,%lf) : forwarding request towards direction %c via node %d \n", c->node,(get_node_position(c->node))->x,(get_node_position(c->node))->y,request->direction,n_hop->id); #endif destination_t dst = {BROADCAST_ADDR, {-1, -1, -1}}; /* forward data */ if (SET_HEADER(&c0, packet, &dst) == -1) { packet_dealloc(packet); return; } request->n_hop = n_hop->id; TX(&c0, packet); entitydata->TX_query++; } else { #ifdef LOG_APPLICATION_REQUEST_ROUTING printf("[XY] node %d (%lf,%lf) : no path towards %c direction\n", c->node,(get_node_position(c->node))->x,(get_node_position(c->node))->y,request->direction); #endif } } return; }