dev_c7200.c

思科路由器仿真器,用来仿7200系列得,可以在电脑上模拟路由器-Cisco router simulator, used to fake a 7200 series can be simulated

int c7200_delete_instance(char *name)
{
   return(registry_delete_if_unused(name,OBJ_TYPE_VM,
                                    c7200_free_instance,NULL));
}

/* Delete all router instances */
int c7200_delete_all_instances(void)
{
   return(registry_delete_type(OBJ_TYPE_VM,c7200_free_instance,NULL));
}

/* Save configuration of a C7200 instance */
void c7200_save_config(c7200_t *router,FILE *fd)
{
   vm_instance_t *vm = router->vm;
   struct c7200_nio_binding *nb;
   struct c7200_pa_bay *bay;
   int i;

   /* General settings */
   fprintf(fd,"c7200 create %s %u\n",vm->name,vm->instance_id);

   fprintf(fd,"c7200 set_npe %s %s\n",vm->name,router->npe_driver->npe_type);
   fprintf(fd,"c7200 set_midplane %s %s\n",vm->name,router->midplane_type);

   /* VM configuration */
   vm_save_config(vm,fd);

   /* Port Adapter settings */
   for(i=0;i<C7200_MAX_PA_BAYS;i++) {
      if (!(bay = c7200_pa_get_info(router,i)))
         continue;

      if (bay->dev_type) {
         fprintf(fd,"c7200 add_pa_binding %s %u %s\n",
                 vm->name,i,bay->dev_type);
      }

      for(nb=bay->nio_list;nb;nb=nb->next) {
         fprintf(fd,"c7200 add_nio_binding %s %u %u %s\n",
                 vm->name,i,nb->port_id,nb->nio->name);
      }
   }

   fprintf(fd,"\n");
}

/* Save configurations of all C7200 instances */
static void c7200_reg_save_config(registry_entry_t *entry,void *opt,int *err)
{
   vm_instance_t *vm = entry->data;
   c7200_t *router = VM_C7200(vm);

   if (vm->type == VM_TYPE_C7200)
      c7200_save_config(router,(FILE *)opt);
}

void c7200_save_config_all(FILE *fd)
{
   registry_foreach_type(OBJ_TYPE_VM,c7200_reg_save_config,fd,NULL);
}

/* Set NPE eeprom definition */
static int c7200_npe_set_eeprom(c7200_t *router)
{
   const struct cisco_eeprom *eeprom;

   if (!(eeprom = c7200_get_cpu_eeprom(router->npe_driver->npe_type))) {
      vm_error(router->vm,"unknown NPE \"%s\" (internal error)!\n",
              router->npe_driver->npe_type);
      return(-1);
   }

   if (cisco_eeprom_copy(&router->cpu_eeprom,eeprom) == -1) {
      vm_error(router->vm,"unable to set NPE EEPROM.\n");
      return(-1);
   }

   return(0);
}

/* Set PEM eeprom definition */
static int c7200_pem_set_eeprom(c7200_t *router)
{
   const struct cisco_eeprom *eeprom;

   if (!(eeprom = c7200_get_pem_eeprom(router->npe_driver->npe_type))) {
      vm_error(router->vm,"no PEM EEPROM found for NPE type \"%s\"!\n",
              router->npe_driver->npe_type);
      return(-1);
   }

   if (cisco_eeprom_copy(&router->pem_eeprom,eeprom) == -1) {
      vm_error(router->vm,"unable to set PEM EEPROM.\n");
      return(-1);
   }

   return(0);
}

/* Set PA EEPROM definition */
int c7200_pa_set_eeprom(c7200_t *router,u_int pa_bay,
                        const struct cisco_eeprom *eeprom)
{
   if (pa_bay >= C7200_MAX_PA_BAYS) {
      vm_error(router->vm,"c7200_pa_set_eeprom: invalid PA Bay %u.\n",pa_bay);
      return(-1);
   }

   if (cisco_eeprom_copy(&router->pa_bay[pa_bay].eeprom,eeprom) == -1) {
      vm_error(router->vm,"c7200_pa_set_eeprom: no memory.\n");
      return(-1);
   }

   return(0);
}

/* Unset PA EEPROM definition (empty bay) */
int c7200_pa_unset_eeprom(c7200_t *router,u_int pa_bay)
{
   if (pa_bay >= C7200_MAX_PA_BAYS) {
      vm_error(router->vm,"c7200_pa_set_eeprom: invalid PA Bay %u.\n",pa_bay);
      return(-1);
   }
   
   cisco_eeprom_free(&router->pa_bay[pa_bay].eeprom);
   return(0);
}

/* Check if a bay has a port adapter */
int c7200_pa_check_eeprom(c7200_t *router,u_int pa_bay)
{
   if (!pa_bay || (pa_bay >= C7200_MAX_PA_BAYS))
      return(FALSE);

   return(cisco_eeprom_valid(&router->pa_bay[pa_bay].eeprom));
}

/* Get bay info */
struct c7200_pa_bay *c7200_pa_get_info(c7200_t *router,u_int pa_bay)
{
   if (pa_bay >= C7200_MAX_PA_BAYS)
      return NULL;

   return(&router->pa_bay[pa_bay]);
}

/* Get PA type */
char *c7200_pa_get_type(c7200_t *router,u_int pa_bay)
{
   struct c7200_pa_bay *bay;

   bay = c7200_pa_get_info(router,pa_bay);
   return((bay != NULL) ? bay->dev_type : NULL);
}

/* Get driver info about the specified slot */
void *c7200_pa_get_drvinfo(c7200_t *router,u_int pa_bay)
{
   struct c7200_pa_bay *bay;

   bay = c7200_pa_get_info(router,pa_bay);
   return((bay != NULL) ? bay->drv_info : NULL);
}

/* Set driver info for the specified slot */
int c7200_pa_set_drvinfo(c7200_t *router,u_int pa_bay,void *drv_info)
{
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   bay->drv_info = drv_info;
   return(0);
}

/* Get a PA driver */
static struct c7200_pa_driver *c7200_pa_get_driver(char *dev_type)
{
   int i;

   for(i=0;pa_drivers[i];i++)
      if (!strcmp(pa_drivers[i]->dev_type,dev_type))
         return pa_drivers[i];

   return NULL;
}

/* Add a PA binding */
int c7200_pa_add_binding(c7200_t *router,char *dev_type,u_int pa_bay)
{   
   struct c7200_pa_driver *pa_driver;
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   /* check that this bay is empty */
   if (bay->dev_type != NULL) {
      vm_error(router->vm,"a PA already exists in slot %u.\n",pa_bay);
      return(-1);
   }

   /* find the PA driver */
   if (!(pa_driver = c7200_pa_get_driver(dev_type))) {
      vm_error(router->vm,"unknown PA type '%s'.\n",dev_type);
      return(-1);
   }

   bay->dev_type = pa_driver->dev_type;
   bay->pa_driver = pa_driver;
   return(0);  
}

/* Remove a PA binding */
int c7200_pa_remove_binding(c7200_t *router,u_int pa_bay)
{   
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   /* stop if this bay is still active */
   if (bay->drv_info != NULL) {
      vm_error(router->vm,"slot %u still active.\n",pa_bay);
      return(-1);
   }

   /* check that this bay is not empty */
   if (bay->dev_type == NULL) {
      vm_error(router->vm,"slot %u is empty.\n",pa_bay);
      return(-1);
   }
   
   /* remove all NIOs bindings */ 
   c7200_pa_remove_all_nio_bindings(router,pa_bay);

   bay->dev_type  = NULL;
   bay->pa_driver = NULL;
   return(0);
}

/* Find a NIO binding */
struct c7200_nio_binding *
c7200_pa_find_nio_binding(c7200_t *router,u_int pa_bay,u_int port_id)
{   
   struct c7200_nio_binding *nb;
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return NULL;

   for(nb=bay->nio_list;nb;nb=nb->next)
      if (nb->port_id == port_id)
         return nb;

   return NULL;
}

/* Add a network IO binding */
int c7200_pa_add_nio_binding(c7200_t *router,u_int pa_bay,u_int port_id,
                             char *nio_name)
{
   struct c7200_nio_binding *nb;
   struct c7200_pa_bay *bay;
   netio_desc_t *nio;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   /* check that a NIO is not already bound to this port */
   if (c7200_pa_find_nio_binding(router,pa_bay,port_id) != NULL) {
      vm_error(router->vm,"a NIO already exists for interface %u/%u\n",
               pa_bay,port_id);
      return(-1);
   }

   /* acquire a reference on the NIO object */
   if (!(nio = netio_acquire(nio_name))) {
      vm_error(router->vm,"unable to find NIO '%s'.\n",nio_name);
      return(-1);
   }

   /* create a new binding */
   if (!(nb = malloc(sizeof(*nb)))) {
      vm_error(router->vm,"unable to create NIO binding "
               "for interface %u/%u.\n",pa_bay,port_id);
      netio_release(nio_name);
      return(-1);
   }

   memset(nb,0,sizeof(*nb));
   nb->nio       = nio;
   nb->port_id   = port_id;
   nb->next      = bay->nio_list;
   if (nb->next) nb->next->prev = nb;
   bay->nio_list = nb;
   return(0);
}

/* Remove a NIO binding */
int c7200_pa_remove_nio_binding(c7200_t *router,u_int pa_bay,u_int port_id)
{
   struct c7200_nio_binding *nb;
   struct c7200_pa_bay *bay;
   
   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   if (!(nb = c7200_pa_find_nio_binding(router,pa_bay,port_id)))
      return(-1);   /* no nio binding for this slot/port */

   /* tell the PA driver to stop using this NIO */
   if (bay->pa_driver)
      bay->pa_driver->pa_unset_nio(router,pa_bay,port_id);

   /* remove this entry from the double linked list */
   if (nb->next)
      nb->next->prev = nb->prev;

   if (nb->prev) {
      nb->prev->next = nb->next;
   } else {
      bay->nio_list = nb->next;
   }

   /* unreference NIO object */
   netio_release(nb->nio->name);
   free(nb);
   return(0);
}

/* Remove all NIO bindings for the specified PA */
int c7200_pa_remove_all_nio_bindings(c7200_t *router,u_int pa_bay)
{  
   struct c7200_nio_binding *nb,*next;
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   for(nb=bay->nio_list;nb;nb=next) {
      next = nb->next;

      /* tell the PA driver to stop using this NIO */
      if (bay->pa_driver)
         bay->pa_driver->pa_unset_nio(router,pa_bay,nb->port_id);

      /* unreference NIO object */
      netio_release(nb->nio->name);
      free(nb);
   }

   bay->nio_list = NULL;
   return(0);
}

/* Enable a Network IO descriptor for a Port Adapter */
int c7200_pa_enable_nio(c7200_t *router,u_int pa_bay,u_int port_id)
{
   struct c7200_nio_binding *nb;
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   /* check that we have an NIO binding for this interface */
   if (!(nb = c7200_pa_find_nio_binding(router,pa_bay,port_id)))
      return(-1);

   /* check that the driver is defined and successfully initialized */
   if (!bay->pa_driver || !bay->drv_info)
      return(-1);

   return(bay->pa_driver->pa_set_nio(router,pa_bay,port_id,nb->nio));
}

/* Disable Network IO descriptor of a Port Adapter */
int c7200_pa_disable_nio(c7200_t *router,u_int pa_bay,u_int port_id)
{
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   /* check that the driver is defined and successfully initialized */
   if (!bay->pa_driver || !bay->drv_info)
      return(-1);

   return(bay->pa_driver->pa_unset_nio(router,pa_bay,port_id));
}

/* Enable all NIO of the specified PA */
int c7200_pa_enable_all_nio(c7200_t *router,u_int pa_bay)
{
   struct c7200_nio_binding *nb;
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   /* check that the driver is defined and successfully initialized */
   if (!bay->pa_driver || !bay->drv_info)
      return(-1);

   for(nb=bay->nio_list;nb;nb=nb->next)
      bay->pa_driver->pa_set_nio(router,pa_bay,nb->port_id,nb->nio);

   return(0);
}

/* Disable all NIO of the specified PA */
int c7200_pa_disable_all_nio(c7200_t *router,u_int pa_bay)
{
   struct c7200_nio_binding *nb;
   struct c7200_pa_bay *bay;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);

   /* check that the driver is defined and successfully initialized */
   if (!bay->pa_driver || !bay->drv_info)
      return(-1);

   for(nb=bay->nio_list;nb;nb=nb->next)
      bay->pa_driver->pa_unset_nio(router,pa_bay,nb->port_id);

   return(0);
}

/* Initialize a Port Adapter */
int c7200_pa_init(c7200_t *router,u_int pa_bay)
{   
   struct c7200_pa_bay *bay;
   size_t len;

   if (!(bay = c7200_pa_get_info(router,pa_bay)))
      return(-1);