generate_JSON(&location,&data,&length);
send_data(handler, (char *)data,length,dest_handler);
free(data);
}
}
void ManagerLost(){
pthread_mutex_lock(&manager);
manager_available = false;
pthread_mutex_unlock(&manager);
}
void receive(__tp(handler)* sk, char* data, uint16_t len, int64_t timestamp,int64_t air_time, uint16_t src_id){
if (!memcmp(data,"LOCAL_GSD:",strlen("LOCAL_GSD:"))){
GsdReceive(data);
return;
}
LocationPacket * packet = (LocationPacket *) malloc(sizeof(LocationPacket));
generate_packet_from_JSON(data, packet);
switch(packet->type){
case CONFIRM_MANAGER:
ConfirmSpontaneousRegister(src_id,packet->required_frequency);
break;
case REQUEST_FREQUENT:
RequestFrequent(src_id,packet->required_frequency);
pthread_mutex_init(&(buff->lock), NULL);
sem_init(&(buff->full), 0, npackets);
sem_init(&(buff->empty), 0, 0);
buff->buff_size = npackets;
buff->consumer_pointer = 0;
buff->producer_pointer = 0;
buff->itens = 0;
buff->data = alloc(msg*, npackets);
return buff;
}
msg* __tp(consume)(__tp(buffer)* b) {
msg* item;
sem_wait(&(b->empty));
pthread_mutex_lock(&(b->lock));
item = (b->data)[b->consumer_pointer];
b->consumer_pointer++;
if (b->consumer_pointer >= b->buff_size)
b->consumer_pointer = 0;
b->itens--;
pthread_mutex_unlock(&(b->lock));
sem_post(&(b->full));
return item;
static void flush_buffer_app(struct sk_buff* skb, aggregate_buffer* b,
const struct net_device* out) {
struct iphdr* iph;
struct udphdr* udph;
struct in_device* ipa;
__tp(pdu)* pdu;
control_byte *cb;
__be16 srcport;
char *begin_of_buffered_data;
iph = ip_hdr(skb);
if (iph->protocol == IPPROTO_UDP) {
udph = (struct udphdr*) (((char*) iph) + (iph->ihl << 2));
srcport = udph->source;
} else {
printk(
"%s in %s:%d: IP protocol not supported by aggregation interceptor.\n",
__FUNCTION__, __FILE__, __LINE__);
return;
}
pdu = pdu_skb(skb);
if (!pdu)
return;
//Remove iphdr, udphdr and control byte.
skb_pull(skb, (iph->ihl << 2) + sizeof(struct udphdr) + sizeof(control_byte));
//put into skb buffered data
if (skb_tailroom(skb) < buffer_data_len(b)
)
if (pskb_expand_head(skb, 0, buffer_data_len(b) - skb_tailroom(skb),
GFP_ATOMIC)) {
printk (KERN_EMERG
"%s in %s:%d: Failed to expand skb tail. Reseting aggregate buffer anyway\n",
__FUNCTION__, __FILE__, __LINE__);
reset_buffer(b);
return;
}
begin_of_buffered_data = skb_put(skb, buffer_data_len(b));
memcpy(begin_of_buffered_data, b->head, buffer_data_len(b));
//--------------------------
ipa = (struct in_device*) out->ip_ptr;
if (skb_headroom(skb)
< sizeof(struct iphdr) + sizeof(struct udphdr) + sizeof(control_byte))
if (pskb_expand_head(
skb,
sizeof(struct iphdr) + sizeof(struct udphdr) + sizeof(control_byte)
- skb_headroom(skb), 0, GFP_ATOMIC)) {
printk (KERN_EMERG
"%s in %s:%d: Failed to expand skb head. Reseting aggregate buffer anyway\n",
__FUNCTION__, __FILE__, __LINE__);
reset_buffer(b);
return;
}
cb = (control_byte*) skb_push(skb, sizeof(control_byte));
udph = (struct udphdr*) skb_push(skb, sizeof(struct udphdr));
iph = (struct iphdr*) skb_push(skb, sizeof(struct iphdr));
memset(udph, 0, sizeof(struct udphdr));
iph->ihl = 5;
iph->version = 4;
iph->tos = 0;
iph->tot_len = htons(
sizeof(struct iphdr) + sizeof(struct udphdr) + sizeof(control_byte)
+ buffer_data_len(b) + n_pdu_len(pdu));
iph->id = 0;
iph->frag_off = 0;
iph->ttl = 60;
iph->protocol = IPPROTO_UDP;
iph->check = 0;
iph->saddr = ipa->ifa_list->ifa_address;
iph->daddr = b->id.ip;
iph->check = csum((uint16_t*) iph, (iph->ihl << 2) >> 1);
skb_set_network_header(skb, 0);
udph->len = htons(
sizeof(control_byte) + n_pdu_len(pdu) + buffer_data_len(b)
+ sizeof(struct udphdr));
udph->dest = b->id.port;
udph->source = srcport;
skb_set_transport_header(skb, sizeof(struct iphdr));
memset(cb, 0, sizeof(control_byte));
cb->app_aggregated = 1;
udph->check = 0;
reset_buffer(b);
return;
}
if((pb->buffer)[pb->oldest_seq % pb->size]){
free((pb->buffer)[pb->oldest_seq % pb->size]->pdu);
free((pb->buffer)[pb->oldest_seq % pb->size]);
}
pb->oldest_seq++;
}
(pb->buffer)[m->pdu->seq % pb->size] = m;
unlock_buffer(pb);
}
/*
* Return -1 in case of no packets missing.
* Return the oldest sequence number available.
* */
int64_t produce_missing_packets(packet_buffer* pb, nack_interval* nack,
__tp(buffer)* b) {
int retval = -1;
if (!nack)
return -1;
debug(I, "Received ACK - [%d:%d]\n", nack->lseq, nack->rseq);
lock_buffer(pb);
uint32_t oldest = pb->oldest_seq;
uint32_t latest = pb->largest_seq;
int lseq_pos, rseq_pos, how_many_to_produce, i;
//We do not have any packets buffered. They're too old.
if (oldest > nack->rseq) {
debug(W, "Requested %d packet not in buffer. Oldest %d\n", nack->rseq, oldest);
unlock_buffer(pb);
