C++ rpl_get_parent_ipaddr函数代码示例

static rpl_parent_t *
best_parent(rpl_parent_t *p1, rpl_parent_t *p2)
{
  rpl_rank_t r1, r2;
  rpl_dag_t *dag;

  PRINTF("RPL: Comparing parent ");
  PRINT6ADDR(rpl_get_parent_ipaddr(p1));
  PRINTF(" (confidence %d, rank %d) with parent ",
        p1->link_metric, p1->rank);
  PRINT6ADDR(rpl_get_parent_ipaddr(p2));
  PRINTF(" (confidence %d, rank %d)\n",
        p2->link_metric, p2->rank);


  r1 = DAG_RANK(p1->rank, p1->dag->instance) * RPL_MIN_HOPRANKINC  +
         p1->link_metric;
  r2 = DAG_RANK(p2->rank, p1->dag->instance) * RPL_MIN_HOPRANKINC  +
         p2->link_metric;
  /* Compare two parents by looking both and their rank and at the ETX
     for that parent. We choose the parent that has the most
     favourable combination. */

  dag = (rpl_dag_t *)p1->dag; /* Both parents must be in the same DAG. */
  if(r1 < r2 + MIN_DIFFERENCE &&
     r1 > r2 - MIN_DIFFERENCE) {
    return dag->preferred_parent;
  } else if(r1 < r2) {
    return p1;
  } else {
    return p2;
  }
}

/*---------------------------------------------------------------------------*/
void
rpl_nullify_parent(rpl_parent_t *parent)
{
  rpl_dag_t *dag = parent->dag;

#if WITH_ORPL
  /* We don't have a preferred parent in ORPL.
   * We simply recalculate our EDC. */
  dag->instance->of->calculate_rank(parent, 0);
  return;
#endif /* WITH_ORPL */

  /* This function can be called when the preferred parent is NULL, so we
     need to handle this condition in order to trigger uip_ds6_defrt_rm. */
  if(parent == dag->preferred_parent || dag->preferred_parent == NULL) {
    rpl_set_preferred_parent(dag, NULL);
    dag->rank = INFINITE_RANK;
    if(dag->joined) {
      if(dag->instance->def_route != NULL) {
        PRINTF("RPL: Removing default route ");
        PRINT6ADDR(rpl_get_parent_ipaddr(parent));
        PRINTF("\n");
        uip_ds6_defrt_rm(dag->instance->def_route);
        dag->instance->def_route = NULL;
      }
      dao_output(parent, RPL_ZERO_LIFETIME);
    }
  }

  PRINTF("RPL: Nullifying parent ");
  PRINT6ADDR(rpl_get_parent_ipaddr(parent));
  PRINTF("\n");
}

uint16_t
create_parent_msg(char *buf,rpl_parent_t *parent, uint8_t preferred)
{
	uint8_t n = 0;
	uip_ds6_nbr_t *nbr;

	uip_ipaddr_t * addr = rpl_get_parent_ipaddr(parent);

	n += sprintf(&(buf[n]), "{\"eui\":\"%04x%04x%04x%04x\",",
					UIP_HTONS(addr->u16[4]),
					UIP_HTONS(addr->u16[5]),
					UIP_HTONS(addr->u16[6]),
					UIP_HTONS(addr->u16[7]));
	
	n += sprintf(&(buf[n]), "\"pref\":");

	if(preferred == 1)
	{
		n += sprintf(&(buf[n]), "true,");
	}else
	{
		n += sprintf(&(buf[n]), "false,");
	}

	nbr = rpl_get_nbr(parent); // Estimated Retransmission part (ETX) value

	n += sprintf(&(buf[n]), "\"etx\":%d}",nbr->link_metric);

	buf[n] = 0; // clear next buffer value
	PRINTF("buf: %s\n", buf); // print the buffer value
	return n;
}

/*---------------------------------------------------------------------------*/
static void res_rpl_parent_get_handler(void *request, void *response,
  uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
  uint16_t length;
  rpl_instance_t *instance;
  char message[REST_MAX_CHUNK_SIZE];

  memset(message, 0, REST_MAX_CHUNK_SIZE);
  instance = rpl_get_instance(RPL_DEFAULT_INSTANCE);
  /* Print the parent */
  if(instance != NULL &&
    instance->current_dag != NULL &&
    instance->current_dag->preferred_parent != NULL) {
    sprintf(&message[0], "RPL Parent: ");
    sprint_addr6(&message[0],
      rpl_get_parent_ipaddr(instance->current_dag->preferred_parent));
  } else {
    sprintf(&message[0], "No parent yet\n");
  }
  length = strlen(&message[0]);
  memcpy(buffer, message, length);

  REST.set_header_content_type(response, REST.type.TEXT_PLAIN);
  REST.set_header_etag(response, (uint8_t *)&length, 1);
  REST.set_response_payload(response, buffer, length);
}

/*---------------------------------------------------------------------------*/
void monitor_parents(void)
{
	rpl_parent_t *p;
	uip_ipaddr_t *dest;
 uint16_t temp1,temp2;

//counter++;
	rpl_parent_t *pref_parent =(&instance_table[0])->current_dag->preferred_parent;
//	rpl_instance_t *instance=&instance_table[0];
temp1 = ((((&instance_table[0])->current_dag->rank)%256)*100)/256;
	printf("rank= %u.%u:{", (((&instance_table[0])->current_dag->rank)/256), temp1);
	for(p = nbr_table_head(rpl_parents); p != NULL ;     p = nbr_table_next(rpl_parents, p))
	{	dest=rpl_get_parent_ipaddr(p);
		printf("(");
		if(p==pref_parent)
			printf("pref-prnt ");
		printf("%02x ", ((uint8_t *)dest)[15]);
temp1 = ((p->link_metric%128)*100)/128;
temp2 = ((p->rank%256)*100)/256;
		printf(" etx=%d.%2d,rank=%u.%2u)", p->link_metric/128, temp1 ,p->rank/256 , temp2);
//printf("%d- etx=%d.%2d,rank=%u.%2u)", counter, p->link_metric/128, temp1 ,p->rank/256 , temp2);
//printf("%d   %d.%2d \n", counter, p->link_metric/128, temp1);
		  /*PRINTF("RPL: My path ETX to the root is %u.%u\n",
			instance->mc.obj.etx / RPL_DAG_MC_ETX_DIVISOR,
			(instance->mc.obj.etx % RPL_DAG_MC_ETX_DIVISOR * 100) /
			 RPL_DAG_MC_ETX_DIVISOR);*/
		}
	printf("}\n");

}

/*---------------------------------------------------------------------------*/
const uip_ipaddr_t *
simple_rpl_parent(void)
{
    rpl_dag_t *dag;

    dag = rpl_get_any_dag();
    if(dag != NULL && dag->preferred_parent != NULL) {
        return rpl_get_parent_ipaddr(dag->preferred_parent);
    }
    return NULL;
}

/*---------------------------------------------------------------------------*/
static void
handle_probing_timer(void *ptr)
{
  rpl_instance_t *instance = (rpl_instance_t *)ptr;
  rpl_parent_t *probing_target = RPL_PROBING_SELECT_FUNC(instance->current_dag);

  /* Perform probing */
  if(probing_target != NULL && rpl_get_parent_ipaddr(probing_target) != NULL) {
    PRINTF("RPL: probing %3u\n",
        nbr_table_get_lladdr(rpl_parents, probing_target)->u8[7]);
    /* Send probe, e.g. unicast DIO or DIS */
    RPL_PROBING_SEND_FUNC(instance, rpl_get_parent_ipaddr(probing_target));
  }

  /* Schedule next probing */
  rpl_schedule_probing(instance);

#if DEBUG
  rpl_print_neighbor_list();
#endif
}

/*---------------------------------------------------------------------------*/
int
rpl_process_parent_event(rpl_instance_t *instance, rpl_parent_t *p)
{
  int return_value;

#if DEBUG
  rpl_rank_t old_rank;

  old_rank = instance->current_dag->rank;
#endif /* DEBUG */

  return_value = 1;

  if(!acceptable_rank(p->dag, p->rank)) {
    /* The candidate parent is no longer valid: the rank increase resulting
       from the choice of it as a parent would be too high. */
    PRINTF("RPL: Unacceptable rank %u\n", (unsigned)p->rank);
    rpl_nullify_parent(p);
    if(p != instance->current_dag->preferred_parent) {
      return 0;
    } else {
      return_value = 0;
    }
  }

  if(rpl_select_dag(instance, p) == NULL) {
    /* No suitable parent; trigger a local repair. */
    PRINTF("RPL: No parents found in any DAG\n");
    rpl_local_repair(instance);
    return 0;
  }
#if DEBUG
  if(DAG_RANK(old_rank, instance) !=
     DAG_RANK(instance->current_dag->rank, instance)) {
    PRINTF("RPL: Moving in the instance from rank %hu to %hu\n",
           DAG_RANK(old_rank, instance), DAG_RANK(instance->current_dag->rank,
                                                  instance));
    if(instance->current_dag->rank != INFINITE_RANK) {
      PRINTF("RPL: The preferred parent is ");
      PRINT6ADDR(rpl_get_parent_ipaddr
                   (instance->current_dag->preferred_parent));
      PRINTF(" (rank %u)\n",
             (unsigned)DAG_RANK(instance->current_dag->preferred_parent->rank,
                                instance));
    } else {
      PRINTF("RPL: We don't have any parent");
    }
  }
#endif /* DEBUG */

  return return_value;
}

static void
res_get_handler(void *request, void *response, uint8_t *buffer, uint16_t preferred_size, int32_t *offset)
{
	rpl_dag_t *dag;
	rpl_parent_t *parent;
	int32_t strpos = 0;
	const uip_ipaddr_t *addr;
	addr = &uip_ds6_if.addr_list[1].ipaddr;
	dag = rpl_get_any_dag();

	parent_index = 0;

	if (dag != NULL)
	{
		/* seek to the parents entry and return it */
		strpos += sprintf(&(buffer[strpos]),"{\"node\":\"n%x\"",addr->u8[15]); // last addr byte of mote
		strpos += sprintf(&(buffer[strpos]),",\"nbr\":{");
		parent = nbr_table_head(rpl_parents);  // addr of first neighbor
		while (parent != NULL)
		{
			etx_table[parent_index].nbr_addr = rpl_get_parent_ipaddr(parent)->u8[15];
			etx_table[parent_index].nbr_etx = rpl_get_parent_link_metric(parent);
			etx_table[parent_index].p = parent;
			strpos += sprintf(&(buffer[strpos]),"\"n%x\":%u,",etx_table[parent_index].nbr_addr, etx_table[parent_index].nbr_etx);
			parent = nbr_table_next(rpl_parents, parent);
			parent_index++;
		}
		PRINTF("parent_index:%d\n",parent_index);
	}
	else
	{ /* no DAG */
		strpos += sprintf(&(buffer[strpos]),"{}\n");
	}
	//PRINTF("strpos: %ld\n", strpos);
	//rpl_print_neighbor_list(); // get parents for debug purposes
	//PRINTF("buf_parents: %s\n", buffer);
	strpos += sprintf(&(buffer[strpos-1]),"}}\n"); //replace the last comma
	//PRINTF("strpos-after: %ld\n", strpos);
	REST.set_header_content_type(response, APPLICATION_JSON);
	REST.set_header_max_age(response, res_etx.periodic->period / CLOCK_SECOND);
	//*offset = -1;  // try to fix Copper response
	REST.set_response_payload(response, buffer, snprintf((char *)buffer, preferred_size, "%s", buffer));

	/* The REST.subscription_handler() will be called for observable resources by the REST framework. */
}

void
collect_common_net_print(void)
{
  rpl_dag_t *dag;
  uip_ds6_route_t *r;

  /* Let's suppose we have only one instance */
  dag = rpl_get_any_dag();
  if(dag->preferred_parent != NULL) {
    PRINTF("Preferred parent: ");
    PRINT6ADDR(rpl_get_parent_ipaddr(dag->preferred_parent));
    PRINTF("\n");
  }
  for(r = uip_ds6_route_head();
      r != NULL;
      r = uip_ds6_route_next(r)) {
    PRINT6ADDR(&r->ipaddr);
  }
  PRINTF("---\n");
}

/* length of an neighbor entry, must be fixed width */
uint16_t create_parent_msg(char *buf, rpl_parent_t *parent, uint8_t preferred)
{
	uint8_t n = 0;

	uip_ipaddr_t * addr = rpl_get_parent_ipaddr(parent);

	n += sprintf(&(buf[n]), "{\"eui\":\"%04x%04x%04x%04x\",",
		     UIP_HTONS(addr->u16[4]),
		     UIP_HTONS(addr->u16[5]),
		     UIP_HTONS(addr->u16[6]),
		     UIP_HTONS(addr->u16[7]));
	n += sprintf(&(buf[n]), "\"pref\":");
	if(preferred == 1) {
		n += sprintf(&(buf[n]), "true,");
	} else {
		n += sprintf(&(buf[n]), "false,");
	}
	n += sprintf(&(buf[n]), "\"etx\":%d}", rpl_get_parent_link_metric(parent));

	buf[n] = 0;
	PRINTF("buf: %s\n", buf);
	return n;
}

void
collect_common_send()
{
  /* Send the query reply back to the sink */
  rpl_parent_t *preferred_parent;
  rpl_dag_t *dag;

  query_reply_t qrpkt;
  dag = rpl_get_any_dag();
  if(dag != NULL) {
    preferred_parent = dag->preferred_parent;
  if(preferred_parent != NULL) {
    uip_ds6_nbr_t *nbr;
  nbr = uip_ds6_nbr_lookup(rpl_get_parent_ipaddr(preferred_parent));
  if(nbr != NULL) {
    // Use parts of the IPv6 address as the parent address, in reversed byte order. 
        qrpkt.parent_etx = (uint16_t)preferred_parent->link_metric + preferred_parent->rank;
      }
    }
  }
  uip_udp_packet_sendto(client_conn, &qrpkt, sizeof(qrpkt),
      &server_ipaddr, UIP_HTONS(UDP_SERVER_PORT));
}

/*---------------------------------------------------------------------------*/
void
collect_common_send(void)
{
  static uint8_t seqno;
  struct {
    uint8_t seqno;
    uint8_t for_alignment;
    struct collect_view_data_msg msg;
  } msg;
  /* struct collect_neighbor *n; */
  uint16_t parent_etx;
  uint16_t rtmetric;
  uint16_t num_neighbors;
  uint16_t beacon_interval;
  rpl_parent_t *preferred_parent;
  rimeaddr_t parent;
  rpl_dag_t *dag;

  if(client_conn == NULL) {
    /* Not setup yet */
    return;
  }
  memset(&msg, 0, sizeof(msg));
  seqno++;
  if(seqno == 0) {
    /* Wrap to 128 to identify restarts */
    seqno = 128;
  }
  msg.seqno = seqno;

  rimeaddr_copy(&parent, &rimeaddr_null);
  parent_etx = 0;

  /* Let's suppose we have only one instance */
  dag = rpl_get_any_dag();
  if(dag != NULL) {
    preferred_parent = dag->preferred_parent;
    if(preferred_parent != NULL) {
      uip_ds6_nbr_t *nbr;
      nbr = uip_ds6_nbr_lookup(rpl_get_parent_ipaddr(preferred_parent));
      if(nbr != NULL) {
        /* Use parts of the IPv6 address as the parent address, in reversed byte order. */
        parent.u8[RIMEADDR_SIZE - 1] = nbr->ipaddr.u8[sizeof(uip_ipaddr_t) - 2];
        parent.u8[RIMEADDR_SIZE - 2] = nbr->ipaddr.u8[sizeof(uip_ipaddr_t) - 1];
        parent_etx = rpl_get_parent_rank((rimeaddr_t *) uip_ds6_nbr_get_ll(nbr)) / 2;
      }
    }
    rtmetric = dag->rank;
    beacon_interval = (uint16_t) ((2L << dag->instance->dio_intcurrent) / 1000);
    num_neighbors = RPL_PARENT_COUNT(dag);
  } else {
    rtmetric = 0;
    beacon_interval = 0;
    num_neighbors = 0;
  }

  /* num_neighbors = collect_neighbor_list_num(&tc.neighbor_list); */
  collect_view_construct_message(&msg.msg, &parent,
                                 parent_etx, rtmetric,
                                 num_neighbors, beacon_interval);

  uip_udp_packet_sendto(client_conn, &msg, sizeof(msg),
                        &server_ipaddr, UIP_HTONS(UDP_SERVER_PORT));
}

/*simple-udp-rpl---------------------------------------------------------------------------*/
static void
receiver(struct simple_udp_connection *c,
         const uip_ipaddr_t *sender_addr,
         uint16_t sender_port,
         const uip_ipaddr_t *receiver_addr,
         uint16_t receiver_port,
         const uint8_t *data,
         uint16_t datalen)
{
// #ifdef WITH_LEAPFROG //for packet elimination
//   int leapfrog_elimination_flag = 0;
    
//   if(data[0] == LEAPFROG_DATA_HEADER){
//     char tmp_lf_pc = data[1] - LEAPFROG_BEACON_OFFSET;
//     int tmp_sid = sender_addr->u8[15];
//     char tmp_lf_an = leapfrog_elimination_id_array[tmp_sid];

//     if(tmp_lf_an <= LEAPFROG_DATA_COUNTER_WIDTH){
//       if(tmp_lf_pc <= tmp_lf_an || LEAPFROG_DATA_COUNTER_MAX - (LEAPFROG_DATA_COUNTER_WIDTH - tmp_lf_an ) <= tmp_lf_pc) leapfrog_elimination_flag = 1; 
//     }else{
//       if(tmp_lf_an - LEAPFROG_DATA_COUNTER_WIDTH <= tmp_lf_pc && tmp_lf_pc <= tmp_lf_an) leapfrog_elimination_flag = 1;
//     }

//     if(leapfrog_elimination_flag == 1){
//       PRINTF("LEAPFROG: Elimination discard data\n");
//     }else{
//       PRINTF("LEAPFROG: ");
//       leapfrog_elimination_id_array[tmp_sid] = tmp_lf_pc;
//     }
//   }

//   if(leapfrog_elimination_flag != 1){
// #endif /*WITH_LEAPFROG*/

  printf("DATA: received from ");
  uip_debug_ipaddr_print(sender_addr);
  printf(" on port %d from port %d with length %d: '%s'\n",
         receiver_port, sender_port, datalen, data);

#ifdef WITH_LEAPFROG //for beaconing
  if(data[0] == LEAPFROG_BEACON_HEADER){
    char temp_sid = 0; //sender id of packet
    char temp_pid = 0; //sender's parent id
    char temp_gid = 0; //sender's grand parent id
    char temp_aid = 0; //sender's alt parent id
    temp_sid = sender_addr->u8[15]; //get most least byte. must be modified to store whole address
    temp_pid = data[2] - LEAPFROG_BEACON_OFFSET;
    temp_gid = data[4] - LEAPFROG_BEACON_OFFSET;
    temp_aid = data[6] - LEAPFROG_BEACON_OFFSET;
    char temp_pps_num;
    char temp_pps_str[LEAPFROG_NUM_NEIGHBOR_NODE];
    int temp_pps_itr;
    temp_pps_num = data[8] - LEAPFROG_BEACON_OFFSET;
    for(temp_pps_itr = 0; temp_pps_itr < (int)temp_pps_num; temp_pps_itr++){ //do nothing if temp_pps_num = 0
      temp_pps_str[temp_pps_itr] = data[8 + 1 + temp_pps_itr];
    }
    temp_pps_str[temp_pps_itr] = '\0';

    printf("LEAPFROG: receive beacon S %d P %d GP %d AP %d PPs #%d %s\n", temp_sid, temp_pid, temp_gid, temp_aid, temp_pps_num, temp_pps_str);
    
    //judge and registor parent, grandparent, alt parent 
    uip_ipaddr_t * addr;
    #ifdef WITH_LEAPFROG_TSCH
    char my_id = 0;
    addr = &uip_ds6_if.addr_list[2].ipaddr; //get own ID. [2] seems to be default
    if(addr != NULL){
      my_id = addr->u8[15];
    }
    #endif //WITH_LEAPFROG_TSCH
    addr = rpl_get_parent_ipaddr(default_instance->current_dag->preferred_parent);
    if(addr != NULL){
      char my_pid = addr->u8[15];
//      if(leapfrog_parent_id == 0){ //registor parent
//        leapfrog_parent_id = my_pid;
//      }else 
      //new parent and reset P, GP, AP
      if(leapfrog_parent_id != my_pid){ //new parent and reset P, GP, AP
        leapfrog_parent_id = my_pid;
        leapfrog_grand_parent_id = 0;
        leapfrog_alt_parent_id = 0;
        printf("LEAPFROG: reset P GP AP\n");
      }
      //judge Grand Parent
      if(leapfrog_parent_id > 0 && leapfrog_parent_id == my_pid){ //judge Grand Parent
        if(temp_sid == my_pid){
          if(temp_pid > 0 && temp_pid != my_pid){
            leapfrog_grand_parent_id = temp_pid; //get grand parent
          }
        }
      }
      //judge Alternate Parent
      if(leapfrog_grand_parent_id > 0 && temp_pid > 0 && leapfrog_grand_parent_id == temp_pid && leapfrog_parent_id != temp_sid){ //judge Alt Parent
        if(leapfrog_alt_parent_id != temp_sid){
          leapfrog_alt_parent_id = temp_sid; //get alt parent
#ifdef WITH_LEAPFROG_TSCH //add unicast tx link to AP based on own(child) ID
          linkaddr_copy(&alt_parent_linkaddr, packetbuf_addr(PACKETBUF_ADDR_SENDER));
          //alt_parent_linkaddr.u8[7] = leapfrog_alt_parent_id; //for tsch
          //printf("LEAPFROG-TSCH: update AP %d %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", 
          //  leapfrog_alt_parent_id,
//.........这里部分代码省略.........

/*---------------------------------------------------------------------------*/
static void
sendpacket(int mode)
{

    static uip_ipaddr_t *parent_ipaddr=NULL,tempadd;
    static rpl_dag_t *current_dag=NULL;
    	
    static int i=0;
    static rpl_instance_t * instance_id=NULL;
    for(i = 0; i < RPL_MAX_INSTANCES; ++i) {
        if(instance_table[i].used && instance_table[i].current_dag->joined) {
            current_dag = instance_table[i].current_dag;
            instance_id = &instance_table[i];
            break;
        }
    }

    if(current_dag != NULL) {
        parent_ipaddr=rpl_get_parent_ipaddr(current_dag->preferred_parent);
    }else return; //if current dag is null return

    if(!parent_ipaddr->u8[15])// if parent is null return
	return;	    
	 		
    uip_ds6_nbr_t *nbr=NULL;
    int num = uip_ds6_nbr_num();
    int sizeof_buf = sizeof(int) + sizeof(uint8_t)  + sizeof(uint8_t) + sizeof(int) + sizeof(uint16_t) +sizeof(uint8_t) + sizeof(uint16_t)+ sizeof(int) + num * ( sizeof(uint8_t) + sizeof(uint16_t) );
    // code + node + id_of_intermediate + msg_instance + own rank + parent + rank + numof_nbr*(nbr+rank)
    unsigned char buf[sizeof_buf];
    unsigned char * buf_p = buf;
    i=2;myrank=current_dag->rank;
    MAPPER_ADD_PACKETDATA(buf_p, i);
    MAPPER_ADD_PACKETDATA(buf_p, myip.u8[15]);

	
    if(mode)		//for first time setting 
    msg_instance = 100*myip.u8[15]; 	
        		
    MAPPER_ADD_PACKETDATA(buf_p, myip.u8[15]);   //added to track limited boradcasting intermediate node id
    MAPPER_ADD_PACKETDATA(buf_p, msg_instance);        //added to track limited boradcasting
    msg_instance++;	

    
    MAPPER_ADD_PACKETDATA(buf_p, current_dag->rank);
    MAPPER_ADD_PACKETDATA(buf_p, parent_ipaddr->u8[15]);
    MAPPER_ADD_PACKETDATA(buf_p, current_dag->preferred_parent->rank);
    MAPPER_ADD_PACKETDATA(buf_p, num);

    printf(" %02x R %u P %u PR %u Bufsize %d msg_instance %d ",myip.u8[15],current_dag->rank,parent_ipaddr->u8[15],current_dag->preferred_parent->rank, sizeof_buf, msg_instance-1);

    num_nbrs=0;
    rpl_parent_t *p=NULL; 
    for(nbr = nbr_table_head(ds6_neighbors); nbr != NULL; nbr = nbr_table_next(ds6_neighbors, nbr)) {
        //p=find_parent_any_dag_any_instance(&nbr->ipaddr);
        p=rpl_find_parent_any_dag(instance_id, &nbr->ipaddr);
	
        MAPPER_ADD_PACKETDATA(buf_p,nbr->ipaddr.u8[15]);
        //rank = rpl_get_parent_rank(uip_ds6_nbr_get_ll(nbr));
        MAPPER_ADD_PACKETDATA(buf_p,p->rank);
        printf("No of nbrs %d : %02x rank %u ",num,nbr->ipaddr.u8[15],p->rank);
	
	nbrs[num_nbrs]=nbr->ipaddr.u8[15];
	num_nbrs++;

    }
    printf("\n");

    if(mode)	
    {
	uip_udp_packet_sendto(client_conn, buf, sizeof(buf), &server_ipaddr, UIP_HTONS(2345));
	uip_create_unspecified(&client_conn->ripaddr);    
	parent_change=0;
	printf("parent change info send via unicast 6BR\n");		
    }
    else
    {   
	

	//uip_udp_packet_sendto(client_conn, buf, sizeof(buf), &server_ipaddr, UIP_HTONS(2345));//temporaryly aadded
	//uip_create_unspecified(&client_conn->ripaddr);  
	
	//send_broadcast(buf,sizeof(buf)); ///*
	//uip_create_unspecified(&udp_bconn->ripaddr);

	int j=0;
	for(i=0,j=0;i<=num_nbrs*3;i++,j=0)
		for(nbr = nbr_table_head(ds6_neighbors); nbr != NULL; nbr = nbr_table_next(ds6_neighbors, nbr)) {        
		uip_ipaddr_copy(&tempadd, &nbr->ipaddr);
		j++;
		if(nbr->ipaddr.u8[15]!=myip.u8[15] && i==j){
			uip_udp_packet_sendto(client_conn, buf, sizeof(buf), &tempadd, UIP_HTONS(10000+(int)tempadd.u8[15]));
			printf("send to %u \n",tempadd.u8[15]);
			uip_create_unspecified(&client_conn->ripaddr);
		}
	}	
	printf("parent change info send via broadcast 6BR\n");		
    }		 	
}