fisheye.pc

simulator for ad hoc

}

/* Name      :  RoutingFisheyePrintNeighborInfo
 * Purpose   :  Print Neighbor Information of the node
 * Papramers :  node 
 * Return    :  None
 */

void RoutingFisheyePrintNeighborInfo(GlomoNode *node,
                                     GlomoRoutingFisheye *fisheye)
{
  char clockStr[GLOMO_MAX_STRING_LENGTH];
  FisheyeHeardNeighborInfo *tmp;
  ctoa(simclock(), clockStr);

  printf("At time %s node %ld's NeighorInfo\n",clockStr,node->nodeAddr);
  printf("Total number of neighbor %d\n",
         fisheye->topologyTable.row[node->nodeAddr].neighborNumber);
  
  tmp = fisheye->heardNeighborInfo ;
  while ( tmp != NULL) {
    ctoa(tmp->lastHeardTime,clockStr);
    printf("Neighbor ID %d LastHeard Time %s\n",tmp->nodeAddr,clockStr);
    tmp = tmp->next;
  }
  printf("----------------------------------------\n");
}

/* Name     :   RoutingFisheyeHandleIntraUpdateMsg
 * Purpose  :   Function to handle the intra update message
 * Parameter:   node
 * Return   :   none
 */
void RoutingFisheyeHandleIntraUpdateMsg(GlomoNode *node,
                                        GlomoRoutingFisheye *fisheye)
{
  clocktype randomTime;
  Message *newMsg;

   /* increase the sequence number of its own neighbor list */
   fisheye->topologyTable.row[node->nodeAddr].sequenceNumber ++ ;
  
   RoutingFisheyeSendScopeTT(node, fisheye, 0,
                             fisheye->parameter.Scope);
   /* Invoke next intra update  */
  randomTime = (clocktype)(pc_nrand(node->seed)%FisheyeRandomTimer
                           -FisheyeRandomTimer/2);
  newMsg = GLOMO_MsgAlloc(node,
                          GLOMO_APP_LAYER,
                          ROUTING_PROTOCOL_FISHEYE,
                          MSG_APP_FisheyeIntraUpdate);
  GLOMO_MsgSend(node,newMsg, randomTime+
                fisheye->parameter.IntraUpdateInterval);
  
}

/* Name     :   RoutingFisheyeHandleInterUpdateMsg
 * Purpose  :   Function to handle the inter update message
 * Parameter:   node
 * Return   :   none
 */
void RoutingFisheyeHandleInterUpdateMsg(GlomoNode *node,
                                        GlomoRoutingFisheye *fisheye)
{
  clocktype randomTime;
  Message *newMsg;

  RoutingFisheyeSendScopeTT(node,fisheye, 
                            fisheye->parameter.Scope,FisheyeInfinity);

  /* Invoke next inter update  */
  randomTime = (clocktype)(pc_nrand(node->seed)%FisheyeRandomTimer
                           -FisheyeRandomTimer/2);
  newMsg = GLOMO_MsgAlloc(node,
                          GLOMO_APP_LAYER,
                          ROUTING_PROTOCOL_FISHEYE,
                          MSG_APP_FisheyeInterUpdate);
  GLOMO_MsgSend(node,newMsg, randomTime+
                fisheye->parameter.InterUpdateInterval);
}


/* Name      :  RoutingFisheyeUpdateTT
 * Purpose   :  Update Topology Table based on the 
 *              TTupdate Message Received
 * Papramers :  node and packet header and payload
 * Return    :  None
 */
void RoutingFisheyeUpdateTT(GlomoNode *node,
                            GlomoRoutingFisheye *fisheye,
                            RoutingFisheyeHeader *header,
                            char *payload)
{
  int TTsize;
  int TTindex,sequenceNumber,i;
  short neighborNumber;
  NODE_ADDR *linkList;
  FisheyeTTRow *row;
  FisheyeNeighborInfo *tmp,*next;

  TTsize = 0;
  row = fisheye->topologyTable.row;

  while (TTsize < header->payloadSize) {
         /* Entry index */
         memcpy(&TTindex,&(payload[TTsize]),sizeof(TTindex));
         TTsize += sizeof(TTindex);      
         /* Sequence number */
         memcpy(&sequenceNumber,&(payload[TTsize]),
                sizeof(sequenceNumber));
         TTsize += sizeof(sequenceNumber);
         /* number of neighbors */
         memcpy(&neighborNumber,&(payload[TTsize]),
                sizeof(neighborNumber));
         TTsize += sizeof(neighborNumber);
         /* the neighbor IDs */
         linkList = (NODE_ADDR *) pc_malloc(neighborNumber*sizeof(NODE_ADDR));
         assert(linkList != NULL);
         for (i = 0; i < neighborNumber; i++) {
           memcpy(&(linkList[i]),&(payload[TTsize]),
                  sizeof(NODE_ADDR));
           TTsize += sizeof(NODE_ADDR);
         }
         /* update correspond TT database if the sequence number is bigger */
         if (sequenceNumber > row[TTindex].sequenceNumber){
           tmp = row[TTindex].neighborInfo;
           row[TTindex].sequenceNumber = sequenceNumber;
           row[TTindex].neighborNumber = neighborNumber;
           /* free the old memory */
           while ( tmp != NULL) {
             next = tmp->next;
             pc_free(tmp);
             tmp = next ;
           }
           row[TTindex].neighborInfo = NULL;

           for ( i = 0; i< neighborNumber;i++) {
             next = tmp;
             tmp =(FisheyeNeighborInfo *)pc_malloc(sizeof(FisheyeNeighborInfo));
             tmp->nodeAddr = linkList[neighborNumber -1-i];
             tmp->next = next;
           }
           row[TTindex].neighborInfo = tmp;
         } /* end of if (sequenceNumber > row[TTindex].sequenceNumber) */
         pc_free(linkList);
         linkList = NULL;
  } /*end of while(TTsize < header->payloadSize) */
  RoutingFisheyeFindSP(node);
}

/* Name      :  RoutingFisheyeFindSP
 * Purpose   :  Calculate shortest path base  
 *              on the current link state table
 *              using Dijkstra's algorithm
 * Papramers :  node
 * Return    :  None
 */
void RoutingFisheyeFindSP(GlomoNode *node)
{
  int i,j;
  int **connectionTable;
  GlomoRoutingFisheye *fisheye;
  FisheyeTTRow *row;

   
  int NODES = node->numNodes;
  int UNSEEN = 99999, priority ;
  int k,min,t;
  int iid;

  fisheye = (GlomoRoutingFisheye *) node->appData.routingVar;
  row = fisheye->topologyTable.row;
  
  connectionTable = (int **) 
    pc_malloc(sizeof(int *) *node->numNodes);
  
  for(i=0;i<node->numNodes;i++) 
    connectionTable[i] = 
      (int *) pc_malloc(sizeof(int)*node->numNodes);

  for (i=0;i<node->numNodes;i++) 
    for (j=0;j<node->numNodes;j++) 
      connectionTable[i][j] = 0 ;
 
  for(i=0;i<node->numNodes;i++) {
    FisheyeNeighborInfo *tmp;
    tmp = row[i].neighborInfo;
    while ( tmp != NULL ) {
      connectionTable[i][tmp->nodeAddr] = 
        connectionTable[tmp->nodeAddr][i] = 1 ;
      tmp = tmp->next;
    }
  }

  for (k=0; k<NODES; k++) {
    row[k].distance = -UNSEEN;
    row[k].prevHop  = NODES;
    row[k].nextHop  = -k;
  }

  row[NODES].distance = -(UNSEEN + 1);
  min = NODES;
  iid = node->nodeAddr;
  row[iid].nextHop  = iid;
  row[iid].distance = 0;

  for (k=iid; k!=NODES; k=min, min=NODES) {
    row[k].distance = -row[k].distance;

    for (t=0; t<NODES; t++) {
      if (row[t].distance < 0) {
        priority = row[k].distance+connectionTable[k][t];
        if (connectionTable[k][t] && (row[t].distance < -priority)){
          row[t].distance = -priority;
          row[t].prevHop   = k;
          
          if (row[t].prevHop == iid) {
            row[t].nextHop=t;
          } else {
            row[t].nextHop=row[k].nextHop;
          }
        }
        if (row[t].distance > row[min].distance) min = t;
      }
    }
  }
  
  for (k=0; k<NODES; k++) {
    NetworkUpdateForwardingTable(node, k, DEFAULT_INTERFACE, row[k].nextHop);
    if ( (int) row[k].nextHop < 0){
      row[k].nextHop=-1;
      row[k].distance=FisheyeInfinity;
      NetworkUpdateForwardingTable(
        node, k, DEFAULT_INTERFACE, NETWORK_UNREACHABLE);
    }
  }

  if (row[0].distance >= FisheyeInfinity) {
    row[0].nextHop  = -1 ;
    row[0].distance = FisheyeInfinity;
    NetworkUpdateForwardingTable(
      node, 0, DEFAULT_INTERFACE, NETWORK_UNREACHABLE);
  }

  for (i = 0;i< node->numNodes;i++) {
    pc_free(connectionTable[i]);
    connectionTable[i] = NULL;
  }
  pc_free(connectionTable);
  connectionTable = NULL;

}

/* Name      :  RoutingFisheyePrintTT
 * Purpose   :  Print the topology table of a node  
 * Papramers :  node
 * Return    :  None
 */
void RoutingFisheyePrintTT(GlomoNode *node,GlomoRoutingFisheye *fisheye)
{
  char clockStr[GLOMO_MAX_STRING_LENGTH];
  FisheyeNeighborInfo *tmp;
  FisheyeTTRow *row;
  int i;
  
  ctoa(simclock(), clockStr);
  row = fisheye->topologyTable.row;

  printf("At %s, the topoplogy table of node %d:\n",clockStr,node->nodeAddr);
  printf("----------------------------------------------\n");
  for (i=0;i< node->numNodes; i++) {
    ctoa(row[i].lastModifyTime,clockStr);
    printf("%d %d %d %hd %s %d %hd:(",
           i,row[i].nextHop,row[i].prevHop,row[i].distance,clockStr,
           row[i].sequenceNumber,row[i].neighborNumber);
    tmp = row[i].neighborInfo;
    while(tmp != NULL) {
      printf("%d ",tmp->nodeAddr);
      tmp = tmp->next;
    }
    printf(")\n");
  }
  printf("----------------------------------------------\n");
  fflush(stdout);
}

/* Name      :  RoutingFisheyePrintTTPkt
 * Purpose   :  Print the topology info from a TT pkt  
 * Papramers :  pkt
 * Return    :  None
 */
void RoutingFisheyePrintTTPkt(RoutingFisheyeHeader *header, char *payload)
{
  int TTsize;
  int TTindex,sequenceNumber,i;
  short neighborNumber;
  NODE_ADDR neighbor;
  
  printf("receive from %d payload size=%d\n",header->sourceAddr,
         header->payloadSize);

  TTsize = 0;  
  while (TTsize < header->payloadSize) {
    /* Entry index */
    memcpy(&TTindex,&(payload[TTsize]),sizeof(TTindex));
    TTsize += sizeof(TTindex);   
    printf("TTindex %d ",TTindex);
    /* Sequence number */
    memcpy(&sequenceNumber,&(payload[TTsize]),
           sizeof(sequenceNumber));
    TTsize += sizeof(sequenceNumber);
    printf("sequenceNumber %d ",sequenceNumber);
    /* number of neighbors */
    memcpy(&neighborNumber,&(payload[TTsize]),
           sizeof(neighborNumber));
    TTsize += sizeof(neighborNumber);
    printf("neighborNumber %d ", neighborNumber);
    /* the neighbor IDs */
    for (i = 0; i < neighborNumber; i++) {
      memcpy(&(neighbor),&(payload[TTsize]),
             sizeof(NODE_ADDR));
      TTsize += sizeof(NODE_ADDR);
      printf("%d ",neighbor);
    }
    printf("\n");
  }
  printf("\n");
  fflush(stdout);
}


/* Name      :  RoutingFisheyeHandleNeighborTOMsg
 * Purpose   :  Timeout stale neighbors
 * Papramers :  node, routing
 * Return    :  none
 */
void RoutingFisheyeHandleNeighborTOMsg(GlomoNode *node,
                                       GlomoRoutingFisheye *fisheye)
{
  FisheyeTTRow *row;
  FisheyeHeardNeighborInfo *trash,*prev,*current;
  clocktype randomTime;
  BOOL change;
  Message *newMsg;

  row = fisheye->topologyTable.row;
  current = prev = fisheye->heardNeighborInfo;

  change = FALSE;
  while ( current != NULL ) {
    trash = NULL;
    if ( (simclock()- current->lastHeardTime) >  
         fisheye->parameter.NeighborTOInterval) {
      change = TRUE;
      /* stale neighbor and should be removed */      
      if (current == fisheye->heardNeighborInfo) {
        fisheye->heardNeighborInfo 
          = fisheye->heardNeighborInfo->next;
        prev = fisheye->heardNeighborInfo;
      }
      else {
        prev->next = current->next;
      }
      trash = current ;
      current = current->next ;
      pc_free(trash) ;
      trash = NULL;
      row[node->nodeAddr].neighborNumber -- ;
    }
    else {        
      prev = current ;
      current = current->next ;
    }   
  }
  
  if(change) { 
    RoutingFisheyeCopyHeardToTable(node,fisheye);
    RoutingFisheyeFindSP(node);
  }

  /* schedule next TO check */
  randomTime = (clocktype)(pc_nrand(node->seed)%FisheyeRandomTimer
                           -FisheyeRandomTimer/2);
  newMsg = GLOMO_MsgAlloc(node,
                          GLOMO_APP_LAYER,
                          ROUTING_PROTOCOL_FISHEYE,
                          MSG_APP_FisheyeNeighborTimeout);

  GLOMO_MsgSend(node,newMsg,randomTime + 
                fisheye->parameter.NeighborTOInterval);  

}


/* Name      :  RoutingFisheyeCopyHeardToTable
 * Purpose   :  copy heard list to table list
 * Papramers :  node
 * Return    :  none
 */
void RoutingFisheyeCopyHeardToTable(GlomoNode *node,
                                    GlomoRoutingFisheye *fisheye)
{
  FisheyeNeighborInfo *tableTmp,*tableNext;
  FisheyeHeardNeighborInfo *heardTmp;
  tableTmp = fisheye->topologyTable.row[node->nodeAddr].neighborInfo;
  /* delete old list */
  while ( tableTmp != NULL ) {
    tableNext = tableTmp->next;
    pc_free(tableTmp);
    tableTmp = tableNext;
  }
  /* copy over Heard List to neighbor list */
  heardTmp = fisheye->heardNeighborInfo;
  while ( heardTmp != NULL) {
    tableNext = tableTmp;
    tableTmp =(FisheyeNeighborInfo *)
      pc_malloc(sizeof(FisheyeNeighborInfo));
    tableTmp->nodeAddr = heardTmp->nodeAddr;
    tableTmp->next = tableNext;
    heardTmp = heardTmp->next;
  }
  fisheye->topologyTable.row[node->nodeAddr].neighborInfo = tableTmp;
}


/* Name      :  RoutingFisheyeHandleControlPacket
 * Purpose   :  handle the control packet received from UDP
 * Papramers :  node, header, payload
 * Return    :  none
 */
void RoutingFisheyeHandleControlPacket(GlomoNode *node, 
                                       GlomoRoutingFisheye *fisheye,
                                       RoutingFisheyeHeader *header,
                                       char *payload)
{    
    RoutingFisheyeUpdateNeighborInfo(node,fisheye,header);
    RoutingFisheyeUpdateTT(node,fisheye,header,payload);     
}


/* Name      :  RoutingFisheyePrintRoutingStats
 * Purpose   :  Print Network Protocol Stats
 * Papramers :  node
 * Return    :  none
 */

void RoutingFisheyePrintRoutingStats(GlomoNode *node)
{
  char buf[GLOMO_MAX_STRING_LENGTH];
  GlomoRoutingFisheye *fisheye;
  
  fisheye = (GlomoRoutingFisheye *) node->appData.routingVar;

  sprintf(buf, "The number of Intra Scope Updates = %d\n", 
          fisheye->stats.intraScopeUpdate);
  GLOMO_PrintStat(node,"RoutingFisheye",buf);

  sprintf(buf, "The number of Inter Scope Updates = %d\n", 
          fisheye->stats.interScopeUpdate);
  GLOMO_PrintStat(node,"RoutingFisheye",buf);
  
  sprintf(buf, "The number of packets received from UDP = %d\n", 
          fisheye->stats.pktNumFromUdp);
  GLOMO_PrintStat(node,"RoutingFisheye",buf);

  sprintf(buf, "Control OH in bytes = %d\n", 
          fisheye->stats.controlOH);
  GLOMO_PrintStat(node,"RoutingFisheye",buf); 

}