mpls_avl.c

路由器协议平台mpls协议的设计与实现源代码。

      /* compare key of current node with supplied key                       */
      /***********************************************************************/
      result = tree->compare(key, node->key);

      if (result > 0)
      {
        /*********************************************************************/
        /* specified key is greater than key of this node, so look in right  */
        /* subtree                                                           */
        /*********************************************************************/
        if (node->right == NULL)
        {
          /*******************************************************************/
          /* We've found the previous node - so we now need to find the      */
          /* successor to this one.                                          */
          /*******************************************************************/
          found_node = mpls_avl_next(node);
          break;
        }
        node = node->right;
      }
      else if (result < 0)
      {
        /*********************************************************************/
        /* specified key is less than key of this node, so look in left      */
        /* subtree                                                           */
        /*********************************************************************/
        if (node->left == NULL)
        {
           /******************************************************************/
           /* We've found the next node so store and drop out                */
           /******************************************************************/
           found_node = node->self;
           break;
        }
        node = node->left;
      }
      else
      {
        /*********************************************************************/
        /* found the requested node                                          */
        /*********************************************************************/
        if (not_equal)
        {
          /*******************************************************************/
          /* need to find the successor node to this node                    */
          /*******************************************************************/
          found_node = mpls_avl_next(node);
        }
        else
        {
          found_node = node->self;
        }
        break;
      }
    }
  }

  return(found_node);

} /* mpls_avl_find_or_find_next */

/*****************************************************************************/
/* Standard compare functions                                                */
/*****************************************************************************/

/**PROC+**********************************************************************/
/* Name:      mpls_compare_byte                                              */
/*                                                                           */
/* Purpose:   Standard function for comparing BYTEs                          */
/*                                                                           */
/* Returns:   -1 if aa < bb                                                  */
/*             0 if aa = bb                                                  */
/*             1 if aa > bb                                                  */
/*                                                                           */
/* Params:    IN  aa                                                         */
/*            IN  bb                                                         */
/*                                                                           */
/**PROC-**********************************************************************/
int mpls_compare_byte(void *aa, void *bb)
{
  /***************************************************************************/
  /* Local Variables                                                         */
  /***************************************************************************/
  int ret_val;

  if (*(unsigned char *)aa < *(unsigned char *)bb)
  {
    ret_val = -1;
  }
  else if (*(unsigned char *)aa > *(unsigned char *)bb)
  {
    ret_val = 1;
  }
  else
  {
    ret_val = 0;
  }

  return(ret_val);

} /* mpls_compare_byte */

/**PROC+**********************************************************************/
/* Name:      mpls_compare_short                                             */
/*                                                                           */
/* Purpose:   Standard function for comparing shorts                         */
/*                                                                           */
/* Returns:   -1 if aa < bb                                                  */
/*             0 if aa = bb                                                  */
/*             1 if aa > bb                                                  */
/*                                                                           */
/* Params:    IN  aa                                                         */
/*            IN  bb                                                         */
/*                                                                           */
/**PROC-**********************************************************************/
int mpls_compare_short(void *aa, void *bb)
{
  /***************************************************************************/
  /* Local Variables                                                         */
  /***************************************************************************/
  int ret_val;

  if (*(short *)aa < *(short *)bb)
  {
    ret_val = -1;
  }
  else if (*(short *)aa > *(short *)bb)
  {
    ret_val = 1;
  }
  else
  {
    ret_val = 0;
  }

  return(ret_val);

} /* mpls_compare_short */

/**PROC+**********************************************************************/
/* Name:      mpls_compare_ushort                                            */
/*                                                                           */
/* Purpose:   Standard function for comparing USHORTs                        */
/*                                                                           */
/* Returns:   -1 if aa < bb                                                  */
/*             0 if aa = bb                                                  */
/*             1 if aa > bb                                                  */
/*                                                                           */
/* Params:    IN  aa                                                         */
/*            IN  bb                                                         */
/*                                                                           */
/**PROC-**********************************************************************/
int mpls_compare_ushort(void *aa, void *bb)
{
  /***************************************************************************/
  /* Local Variables                                                         */
  /***************************************************************************/
  int ret_val;

  if (*(unsigned short *)aa < *(unsigned short *)bb)
  {
    ret_val = -1;
  }
  else if (*(unsigned short *)aa > *(unsigned short *)bb)
  {
    ret_val = 1;
  }
  else
  {
    ret_val = 0;
  }

  return(ret_val);

} /* mpls_compare_ushort */

/**PROC+**********************************************************************/
/* Name:      mpls_compare_long                                              */
/*                                                                           */
/* Purpose:   Standard function for comparing LONGs                          */
/*                                                                           */
/* Returns:   -1 if aa < bb                                                  */
/*             0 if aa = bb                                                  */
/*             1 if aa > bb                                                  */
/*                                                                           */
/* Params:    IN  aa                                                         */
/*            IN  bb                                                         */
/*                                                                           */
/**PROC-**********************************************************************/
int mpls_compare_long(void *aa, void *bb)
{
  /***************************************************************************/
  /* Local Variables                                                         */
  /***************************************************************************/
  int ret_val;

  if (*(long *)aa < *(long *)bb)
  {
    ret_val = -1;
  }
  else if (*(long *)aa > *(long *)bb)
  {
    ret_val = 1;
  }
  else
  {
    ret_val = 0;
  }

  return(ret_val);

} /* mpls_compare_long */

/**PROC+**********************************************************************/
/* Name:      mpls_compare_ulong                                             */
/*                                                                           */
/* Purpose:   Standard function for comparing ULONGs                         */
/*                                                                           */
/* Returns:   -1 if aa < bb                                                  */
/*             0 if aa = bb                                                  */
/*             1 if aa > bb                                                  */
/*                                                                           */
/* Params:    IN  aa                                                         */
/*            IN  bb                                                         */
/*                                                                           */
/**PROC-**********************************************************************/
int mpls_compare_ulong(void *aa, void *bb)
{
  /***************************************************************************/
  /* Local Variables                                                         */
  /***************************************************************************/
  int ret_val;

  if (*(unsigned long *)aa < *(unsigned long *)bb)
  {
    ret_val = -1;
  }
  else if (*(unsigned long *)aa > *(unsigned long *)bb)
  {
    ret_val = 1;
  }
  else
  {
    ret_val = 0;
  }

  return(ret_val);

} /* mpls_compare_ulong */

/**PROC+**********************************************************************/
/* Name:      mpls_compare_int                                               */
/*                                                                           */
/* Purpose:   Standard function for comparing INTs                           */
/*                                                                           */
/* Returns:   -1 if aa < bb                                                  */
/*             0 if aa = bb                                                  */
/*             1 if aa > bb                                                  */
/*                                                                           */
/* Params:    IN  aa                                                         */
/*            IN  bb                                                         */
/*                                                                           */
/**PROC-**********************************************************************/
int mpls_compare_int(void *aa, void *bb)
{
  /***************************************************************************/
  /* Local Variables                                                         */
  /***************************************************************************/
  int ret_val;

  if (*(int *)aa < *(int *)bb)
  {
    ret_val = -1;
  }
  else if (*(int *)aa > *(int *)bb)
  {
    ret_val = 1;
  }
  else
  {
    ret_val = 0;
  }

  return(ret_val);

} /* mpls_compare_int */

/**PROC+**********************************************************************/
/* Name:      mpls_compare_uint                                              */
/*                                                                           */
/* Purpose:   Standard function for comparing UINTs                          */
/*                                                                           */
/* Returns:   -1 if aa < bb                                                  */
/*             0 if aa = bb                                                  */
/*             1 if aa > bb                                                  */
/*                                                                           */
/* Params:    IN  aa                                                         */
/*            IN  bb                                                         */
/*                                                                           */
/**PROC-**********************************************************************/
int mpls_compare_uint(void *aa, void *bb)
{
  /***************************************************************************/
  /* Local Variables                                                         */
  /***************************************************************************/
  int ret_val;

  if (*(unsigned int *)aa < *(unsigned int *)bb)
  {
    ret_val = -1;
  }
  else if (*(unsigned int *)aa > *(unsigned int *)bb)
  {
    ret_val = 1;
  }
  else
  {
    ret_val = 0;
  }

  return(ret_val);

} /* mpls_compare_uint */