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);