Esempio n. 1
0
/* Function declarations */
int main(int argc, char *argv[])
{
	unsigned value;

	nf2.device_name = DEFAULT_IFACE;

	// Open the interface if possible
	if (check_iface(&nf2))
	{
		exit(1);
	}
	if (openDescriptor(&nf2))
	{
		exit(1);
	}


	// FIXME: Perform the actual register read and print the value
	readReg(&nf2, CRYPTO_KEY_REG, &value);
	printf("Register Key is %x", value);

	closeDescriptor(&nf2);

	return 0;
}
Esempio n. 2
0
/* mallocs the array of nf2device structs and
 * populates them */
void open_interfaces(struct nf2device **nf2devices, int num_netfpgas) {
	int i;

	for (i=0; i<num_netfpgas; i++) {
		/* allocate memory for struct */
		nf2devices[i] = (struct nf2device *) malloc(sizeof(struct nf2device));
		if (nf2devices[i] == NULL) {
			fprintf(stderr, "Error: Do not have enough memory to open %u interfaces.\n", num_netfpgas);
			close_interfaces(nf2devices, i);
			exit(1);
		}

		/* allocate enough memory for "nf2cXX". Don't forget '\0' */
		nf2devices[i]->device_name = (char *) malloc(7);
		if (nf2devices[i] == NULL) {
			fprintf(stderr, "Error: Do not have enough memory to open %u interfaces.\n", num_netfpgas);
			free(nf2devices[i]);
			close_interfaces(nf2devices, i);
			exit(1);
		}

		/* copy interface name */
		sprintf(nf2devices[i]->device_name, "%s%d", NF2C, i*4);

		if (check_iface(nf2devices[i]) || openDescriptor(nf2devices[i])) {
			fprintf(stderr, "Error: check_iface or openDescriptor %s\n", nf2devices[i]->device_name);
			free(nf2devices[i]->device_name);
			free(nf2devices[i]);
			close_interfaces(nf2devices, i);
			exit(1);
		}
	}
}
Esempio n. 3
0
int main(int argc, char *argv[])
{
  nf2.device_name = DEFAULT_IFACE;

  processArgs(argc, argv);

  // Open the interface if possible
  if (check_iface(&nf2))
    {
      exit(1);
    }
  if (openDescriptor(&nf2))
    {
      exit(1);
    }
  if(argc > 5){
      printf("Numero de argumentos deve ser < 4\n");
      argc=5;
  } 
  for(int i=0; i< argc-1; i++){
     pdrop[i] = atoi(argv[i+1]);
  }
  dumpCounts();

  closeDescriptor(&nf2);

  return 0;
}
Esempio n. 4
0
int main(int argc, char *argv[])
{
	unsigned val;

        for (val=0;val<8;val++) { lost[val] = 0; stored[val]=0; removed[val]=0; }

	nf2.device_name = DEFAULT_IFACE;

	if (check_iface(&nf2))
	{
		exit(1);
	}
	if (openDescriptor(&nf2))
	{
		exit(1);
	}

        w = initscr(); cbreak(); noecho();

	show_stats();

	closeDescriptor(&nf2);

	endwin();

	return 0;
}
Esempio n. 5
0
void router_init( router_t* router ) {
#ifdef _CPUMODE_
    init_registers(router);
    router->nf.device_name = "nf10";
    check_iface( &router->nf );
    if( openDescriptor( &router->nf ) != 0 )
        die( "Error: failed to connect to the hardware" );
    else {
        /* wait for the reset to complete */
        struct timespec pause;
        pause.tv_sec = 0;
        pause.tv_nsec = 5000 * 1000; /* 5ms */
        nanosleep( &pause, NULL );
    }
#endif

    router->num_interfaces = 1;

    router->use_ospf = TRUE;

    pthread_mutex_init( &router->intf_lock, NULL );

#ifndef _THREAD_PER_PACKET_
    debug_println( "Initializing the router work queue with %u worker threads",
                   NUM_WORKER_THREADS );
    wq_init( &router->work_queue, NUM_WORKER_THREADS, &router_handle_work );
#else
    debug_println( "Router initialized (will use one thread per packet)" );
#endif
}
Esempio n. 6
0
/* Function declarations */
int main(int argc, char *argv[])
{
	unsigned value;

	nf2.device_name = DEFAULT_IFACE;

	// Open the interface if possible
	if (check_iface(&nf2))
	{
		exit(1);
	}
	if (openDescriptor(&nf2))
	{
		exit(1);
	}


	// FIXME: Perform the actual register read and print the value
	//readReg(&nf2, addr, &value);
	//printf(...)

	closeDescriptor(&nf2);

	return 0;
}
Esempio n. 7
0
int main(int argc, char *argv[])
{
	unsigned val;

	nf2.device_name = DEFAULT_IFACE;

	processArgs(argc, argv);

	// Open the interface if possible
	if (check_iface(&nf2))
	{
		exit(1);
	}
	if (openDescriptor(&nf2))
	{
		exit(1);
	}

	// Increment the argument pointer
	argc -= optind;
	argv += optind;

	// Read the registers
	readRegisters(argc, argv);

	closeDescriptor(&nf2);

	return 0;
}
Esempio n. 8
0
/*
  Checks for commandline args, intializes globals, then  begins code download.
*/
int main(int argc, char **argv) {

   nf2.device_name = DEFAULT_IFACE;

   processArgs(argc, argv);

   if (check_iface(&nf2))
   {
	   exit(1);
   }
   if (openDescriptor(&nf2))
   {
      exit(1);
   }

   if (strncmp(log_file_name, "stdout",6)) {

      if ((log_file = fopen(log_file_name, "w")) == NULL) {
	 printf("Error: unable to open logfile %s for writing.\n",
		log_file_name);
	 exit(1);
      }
   }
   else
      log_file = stdout;

   InitGlobals();

   BeginCodeDownload(bin_file_name);

   if (!cpci_reprog)
      ResetDevice();

   /* reset the PHYs */
   NF2_WR32(MDIO_0_CONTROL_REG, 0x8000);
   NF2_WR32(MDIO_1_CONTROL_REG, 0x8000);
   NF2_WR32(MDIO_2_CONTROL_REG, 0x8000);
   NF2_WR32(MDIO_3_CONTROL_REG, 0x8000);

   /* wait until the resets have been completed */
   usleep(100);

   if (intr_enable)
   {
      /* PHY interrupt mask off for link status change */
      NF2_WR32(MDIO_0_INTERRUPT_MASK_REG, 0xfffd);
      NF2_WR32(MDIO_1_INTERRUPT_MASK_REG, 0xfffd);
      NF2_WR32(MDIO_2_INTERRUPT_MASK_REG, 0xfffd);
      NF2_WR32(MDIO_3_INTERRUPT_MASK_REG, 0xfffd);
   }

   VerifyDevInfo();

   fclose(log_file);

   closeDescriptor(&nf2);

   return SUCCESS;
}
Esempio n. 9
0
void set_register(unsigned reg, unsigned val) {
  struct nf2device nf2;

  nf2.device_name = "nf2c0";
  check_iface(&nf2);
  openDescriptor(&nf2);

  writeReg(&nf2, reg, val);

  closeDescriptor(&nf2);
}
Esempio n. 10
0
void connectnf2() {
  nf2.device_name = DEFAULT_IFACE;
  check_iface( &nf2 );
  if( openDescriptor( &nf2 ) != 0 ) {
    printf( "Error: failed to connect to the hardware\n" );
    exit(1);
  }
/* wait for the reset to complete */
  struct timespec pause;
  pause.tv_sec = 0;
  pause.tv_nsec = 5000 * 1000; /* 5ms */
  nanosleep( &pause, NULL );

}
Esempio n. 11
0
unsigned get_register(unsigned reg) {
  struct nf2device nf2;
  unsigned val;

  nf2.device_name = "nf2c0";
  check_iface(&nf2);
  openDescriptor(&nf2);

  readReg(&nf2, reg, &val);

  closeDescriptor(&nf2);

  return val;
}
int main (int argc,char *argv[]) 
{
  	unsigned long q0_val, q1_val, q2_val, q3_val, ewma_val;
  	unsigned long q0_val_old, q1_val_old, q2_val_old, q3_val_old;
	unsigned long b0, b1, b2, b3;
	unsigned long overall;
	pthread_t governor_thread;
	struct struct_thread *param_thread = NULL;


	/********* NF2 INITIALIZATION **********************/
	nf2.device_name = DEFAULT_IFACE;
	if (check_iface(&nf2))
        {
                exit(1);
        }
        if (openDescriptor(&nf2))
        {
                exit(1);
        }
	/********* END NF2 INITIALIZATION ******************/

	param_thread = (struct struct_thread *)malloc(sizeof(struct struct_thread));

	param_thread->nf2 = nf2;
	param_thread->microseconds_to_sleep = MICROSECONDS_TO_SLEEP;
	param_thread->reg_to_write = 0x0000050;

	/**** POPULATE param_thread  *****/
	param_thread->th1 = 500000000.0 * 4;
	param_thread->th2 = 0;
	param_thread->th3 = 0;
	param_thread->th4 = 0;
	/**** END POPULATE param_thread  *****/

	if(pthread_create(&governor_thread,NULL,governor_function,param_thread)<0) {
		printf("pthread_create error for thread 1\n");
		exit(1);
	}


	// Call pthread_join if we want to wait for the termination of governor_thread. Else comment it
	int retcode = pthread_join(governor_thread,NULL);
        closeDescriptor(&nf2);
	free(param_thread);
        return 0;
}
Esempio n. 13
0
int main(int argc, char *argv[])
{
	unsigned val;

	nf2.device_name = DEFAULT_IFACE;

	if (check_iface(&nf2))
	{
		exit(1);
	}
	if (openDescriptor(&nf2))
	{
		exit(1);
	}

	print();

	closeDescriptor(&nf2);

	return 0;
}
Esempio n. 14
0
int main(int argc, char *argv[])
{

  nf2.device_name = DEFAULT_IFACE;


  processArgs(argc, argv);
  if (check_iface(&nf2))
  {
    exit(1);
  }
  if (openDescriptor(&nf2))
  {
    exit(1);
  }

  nf2_read_info(&nf2);
  display_info(&nf2);

  closeDescriptor(&nf2);

  return 0;
}
Esempio n. 15
0
int main(int argc, char *argv[])
{
    unsigned val, log_depth;
    int i;

    nf2.device_name = DEFAULT_IFACE;

    if (check_iface(&nf2))
    {
        exit(1);
    }
    if (openDescriptor(&nf2))
    {
        exit(1);
    }


    // Read the status register
    readReg(&nf2, PHY_TEST_PHY_0_RX_LOG_STATUS_REG, &val);

    if (!(val & 0x1))
        printf("No data in the log\n");
    else {
        log_depth = (val & 0xffffff00) >> 8;

        // Read the expected data register
        printf("Expected data:\n");
        for (i = 0; i < log_depth; i++) {
            readReg(&nf2, PHY_TEST_PHY_0_RX_LOG_EXP_DATA_REG, &val);
            if (i % 4 == 0)
                printf("%08x:", i * 4);
            printf(" %02x %02x %02x %02x",
                   (val >> 24) & 0xff,
                   (val >> 16) & 0xff,
                   (val >> 8) & 0xff,
                   (val) & 0xff);
            if (i % 4 == 3)
                printf("\n");
        }
        printf("\n");
        printf("\n");

        // Read the rx data register
        printf("Received data:\n");
        for (i = 0; i < log_depth; i++) {
            readReg(&nf2, PHY_TEST_PHY_0_RX_LOG_RX_DATA_REG, &val);
            if (i % 4 == 0)
                printf("%08x:", i * 4);
            printf(" %02x %02x %02x %02x",
                   (val >> 24) & 0xff,
                   (val >> 16) & 0xff,
                   (val >> 8) & 0xff,
                   (val) & 0xff);
            if (i % 4 == 3)
                printf("\n");
        }
        printf("\n");
        printf("\n");

        // Clear the log
        writeReg(&nf2, PHY_TEST_PHY_0_RX_LOG_CTRL_REG, 1);
    }

    /*for (j = 0; j < 250; j++) {
       readReg(&nf2, NF2_REG_TEST_BASE + j * 4, &val);
       printf("Read value %x in address %d\n", val, j*4);
    }*/


}
Esempio n. 16
0
void init(struct sr_instance* sr)
{
    unsigned int iseed = (unsigned int)time(NULL);
    srand(iseed+1);

    router_state* rs = (router_state*)malloc(sizeof(router_state));//router_state,一个结构体,在or_data_types.h定义
    assert(rs);
    bzero(rs, sizeof(router_state));
    rs->sr = sr;

	#ifdef _CPUMODE_
    init_rawsockets(rs);
	#endif


    /** INITIALIZE LOCKS **/
    rs->write_lock = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->write_lock, NULL) != 0) {
    	perror("Lock init error");
    	exit(1);
    }

    rs->arp_cache_lock = (pthread_rwlock_t*)malloc(sizeof(pthread_rwlock_t));
    if (pthread_rwlock_init(rs->arp_cache_lock, NULL) != 0) {
    	perror("Lock init error");
    	exit(1);
    }

    rs->arp_queue_lock = (pthread_rwlock_t*)malloc(sizeof(pthread_rwlock_t));
    if (pthread_rwlock_init(rs->arp_queue_lock, NULL) != 0) {
    	perror("Lock init error");
    	exit(1);
    }

    rs->if_list_lock = (pthread_rwlock_t*)malloc(sizeof(pthread_rwlock_t));
    if (pthread_rwlock_init(rs->if_list_lock, NULL) != 0) {
    	perror("Lock init error");
    	exit(1);
    }

    rs->rtable_lock = (pthread_rwlock_t*)malloc(sizeof(pthread_rwlock_t));
    if (pthread_rwlock_init(rs->rtable_lock, NULL) != 0) {
    	perror("Lock init error");
    	exit(1);
    }

    // --- CCDN lock
    rs->ctable_lock = (pthread_rwlock_t*)malloc(sizeof(pthread_rwlock_t));
    if (pthread_rwlock_init(rs->ctable_lock, NULL) != 0) {
    	perror("Lock init error");
    	exit(1);
    }

    rs->cli_commands_lock = (pthread_rwlock_t*)malloc(sizeof(pthread_rwlock_t));
    if (pthread_rwlock_init(rs->cli_commands_lock, NULL) != 0) {
    	perror("Lock init error");
    	exit(1);
    }

    rs->nat_table_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->nat_table_mutex, NULL) != 0) {
    	perror("Mutex init error");
    	exit(1);
    }

    rs->nat_table_cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
    if (pthread_cond_init(rs->nat_table_cond, NULL) != 0) {
			perror("Nat Table cond init error");
			exit(1);
    }

    rs->local_ip_filter_list_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->local_ip_filter_list_mutex, NULL) != 0) {
			perror("Local IP Filter Mutex init error");
			exit(1);
    }

    rs->log_dumper_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->log_dumper_mutex, NULL) != 0) {
			perror("Log dumper mutex init error");
			exit(1);
    }

    rs->sr = sr;
		rs->area_id = PWOSPF_AREA_ID;
		rs->pwospf_hello_interval = PWOSPF_NEIGHBOR_TIMEOUT;
		rs->pwospf_lsu_interval = PWOSPF_LSUINT;
		rs->pwospf_lsu_broadcast = 1;
		rs->arp_ttl = INITIAL_ARP_TIMEOUT;
		rs->nat_timeout = 120;

		/* clear stats */
		int i, j;
		for (i = 0; i < 8; ++i) {
			for (j = 0; j < 4; ++j) {
				rs->stats_last[i][j] = 0;
			}
			for (j = 0; j < 2; ++j) {
				rs->stats_avg[i][j] = 0.0;
			}
		}
		rs->stats_last_time.tv_sec = 0;
		rs->stats_last_time.tv_usec = 0;

		#ifdef _CPUMODE_
			rs->is_netfpga = 1;
			char* name = (char*)calloc(1, 32);
			strncpy(name, sr->interface, 32);
			rs->netfpga.device_name = name;
			rs->netfpga.fd = 0;
			rs->netfpga.net_iface = 0;

			if (check_iface(&(rs->netfpga))) {
				printf("Failure connecting to NETFPGA\n");
				exit(1);
			}

			if (openDescriptor(&(rs->netfpga))) {
				printf("Failure connecting to NETFPGA\n");
				exit(1);
			}

			/* initialize the hardware */
			init_hardware(rs);

		#else
			rs->is_netfpga = 0;
		#endif

		if (rs->is_netfpga) {
			/* Add 224.0.0.5 as a local IP Filter */
			struct in_addr ip;
			inet_pton(AF_INET, "224.0.0.5", &ip);
			add_local_ip_filter(rs, &ip, "pwospf");
		}


    /* Initialize SPING data */
    rs->sping_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->sping_mutex, NULL) != 0) {
	perror("Sping mutex init error");
    	exit(1);
    }

    rs->sping_cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
    if (pthread_cond_init(rs->sping_cond, NULL) != 0) {
			perror("Sping cond init error");
			exit(1);
    }

    /* Initialize LSU data */
    rs->pwospf_router_list_lock = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->pwospf_router_list_lock, NULL) != 0) {
			perror("Routing list mutex init error");
    	exit(1);
    }

    rs->pwospf_lsu_bcast_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->pwospf_lsu_bcast_mutex, NULL) != 0) {
			perror("LSU bcast mutex init error");
    	exit(1);
    }

    rs->pwospf_lsu_bcast_cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
    if (pthread_cond_init(rs->pwospf_lsu_bcast_cond, NULL) != 0) {
			perror("LSU bcast cond init error");
			exit(1);
    }

    rs->pwospf_lsu_queue_lock = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->pwospf_lsu_queue_lock, NULL) != 0) {
			perror("Lsu queue mutex init error");
    	exit(1);
    }


    /* Initialize PWOSPF Dijkstra Thread Mutex/Cond Var */
    rs->dijkstra_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->dijkstra_mutex, NULL) != 0) {
			perror("Dijkstra mutex init error");
    	exit(1);
    }

    rs->dijkstra_cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
    if (pthread_cond_init(rs->dijkstra_cond, NULL) != 0) {
			perror("Dijkstra cond init error");
			exit(1);
    }

    /* Initialize WWW Mutex/Cond Var */
    rs->www_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->www_mutex, NULL) != 0) {
			perror("WWW mutex init error");
    	exit(1);
    }

    rs->www_cond = (pthread_cond_t*)malloc(sizeof(pthread_cond_t));
    if (pthread_cond_init(rs->www_cond, NULL) != 0) {
			perror("WWW cond init error");
			exit(1);
    }

    /* Initialize Stats Mutex */
    rs->stats_mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    if (pthread_mutex_init(rs->stats_mutex, NULL) != 0) {
			perror("Stats mutex init error");
    	exit(1);
    }

    // --- CCDN , sr里面有一个指针是sr->interface_subsystem = rs,而main函数的最前面,rs->sr=sr
    sr_set_subsystem(sr, (void*)rs);

    // --- CCDN , pthread_create用于创建一个线程,第一个参数返回线程id,第二个设置线程属性(NULL表默认),第三个指向线程调用的函数,第四个传递参数
    /** SPAWN THE ARP QUEUE THREAD **/
    rs->arp_thread = (pthread_t*)malloc(sizeof(pthread_t));

    if(pthread_create(rs->arp_thread, NULL, arp_thread, (void *)sr) != 0) {
	    perror("Thread create error");
    }


    /** SPAWN THE PWOSPF HELLO BROADCAST THREAD **/
    rs->pwospf_hello_thread = (pthread_t*)malloc(sizeof(pthread_t));
    if(pthread_create(rs->pwospf_hello_thread, NULL, pwospf_hello_thread, (void *)sr) != 0) {
		perror("Thread create error");
    }


    /** SPAWN THE PWOSPF LSU BROADCAST THREAD **/
    rs->pwospf_lsu_thread = (pthread_t*)malloc(sizeof(pthread_t));
    if(pthread_create(rs->pwospf_lsu_thread, NULL, pwospf_lsu_thread, (void *)sr) != 0) {
	    perror("Thread create error");
    }


    /** SPAWN THE PWOSPF LSU BCAST TIMEOUT THREAD **/
    rs->pwospf_lsu_timeout_thread = (pthread_t*)malloc(sizeof(pthread_t));
    if(pthread_create(rs->pwospf_lsu_timeout_thread, NULL, pwospf_lsu_timeout_thread, (void*)sr) != 0) {
	    perror("Thread create error");
    }

    /** SPAWN THE DIJKSTRA THREAD **/
    rs->pwospf_dijkstra_thread = (pthread_t*)malloc(sizeof(pthread_t));
    if(pthread_create(rs->pwospf_dijkstra_thread, NULL, dijkstra_thread, (void*)get_router_state(sr)) != 0) {
	    perror("Thread create error");
    }


    /** SPAWN THE PWOSPF LSU BCAST THREAD **/
    rs->pwospf_lsu_bcast_thread = (pthread_t*)malloc(sizeof(pthread_t));
    if(pthread_create(rs->pwospf_lsu_bcast_thread, NULL, pwospf_lsu_bcast_thread, (void*)sr) != 0) {
	    perror("Thread create error");
    }

    /** Spawn the NAT Maintenance Thread **/
    /*
    rs->nat_maintenance_thread = (pthread_t*)malloc(sizeof(pthread_t));
    if(pthread_create(rs->nat_maintenance_thread, NULL, nat_maintenance_thread, (void*)rs) != 0) {
	    perror("Thread create error");
    }
    */

    /* if we are on the NETFPGA spawn the stats thread */
		if (rs->is_netfpga) {
	    rs->stats_thread = (pthread_t*)malloc(sizeof(pthread_t));
	    if(pthread_create(rs->stats_thread, NULL, netfpga_stats, (void*)rs) != 0) {
		    perror("Thread create error");
	    }
		}
}
Esempio n. 17
0
/* Set up all the radvd internal stuff from our own configuration */
int radvd_init(char *ifname, struct config *c) {
  struct AdvPrefix *prefix;
  sigset_t oset, nset;


  if (log_open(L_STDERR, "radvd", NULL, -1) < 0) {
    error("log_open\n");
    return -1;
  }
  srand((unsigned int)time(NULL));
  info("starting radvd on device %s\n", ifname);

  sock = open_icmpv6_socket();
  if (sock < 0) {
    error("open_icmpv6_socket\n");
    return -1;
  }
  sigemptyset(&nset);
  sigaddset(&nset, SIGALRM);
  sigprocmask(SIG_UNBLOCK, &nset, &oset);
  if (sigismember(&oset, SIGALRM))
    flog(LOG_WARNING, "SIGALRM has been unblocked. Your startup environment might be wrong.");


  /* setup the radvd struct Interface to know about all our defaults */
  iface = malloc(sizeof(struct Interface));
  if (iface == NULL)
    return -1;

  iface_init_defaults(iface);
  strncpy(iface->Name, ifname, IFNAMSIZ-1);
  iface->Name[IFNAMSIZ-1] = '\0';

  iface->next = NULL;
  iface->AdvSendAdvert = 1;

  /* check the interface exists... this probably shouldn't fail */
  if (check_device(sock, iface) < 0) {
    error("check_device!\n");
    return -1;
  }
  
  if (setup_deviceinfo(sock, iface) < 0) {
    error("setup_deviceinfo\n");
    return -1;
  }
  if (check_iface(iface) < 0) {
    error("check_iface\n");
    return -1;
  }
  if (setup_linklocal_addr(sock, iface) < 0) {
    error("setup_linklocal_addr\n");
    return -1;
  }
  if (setup_allrouters_membership(sock, iface) < 0) {
    error("setup_allrouters_membership\n");
    return -1;
  }


  /* set up the prefix we're advertising from the config struct we get passed in. */
  prefix = malloc(sizeof(struct AdvPrefix));
  if (prefix == NULL)
    return -1;

  prefix_init_defaults(prefix);
  prefix->PrefixLen = 64;
  memcpy(&prefix->Prefix, c->router_addr.s6_addr, sizeof(struct in6_addr));
  prefix->next = NULL;

  iface->AdvPrefixList = prefix;


  // config_interface();
  radvd_kickoff_adverts();

  set_debuglevel(0);

  return sock;
}
Esempio n. 18
0
int main(int argc, char *argv[])
{
    nf2.device_name = DEFAULT_IFACE;

    /* Default */
    sprintf(ip,"127.0.0.1");
    porta = 7777;

    processArgs(argc, argv);

    // Open the interface if possible
    if (check_iface(&nf2))
    {
        exit(1);
    }
    if (openDescriptor(&nf2))
    {
        exit(1);
    }

    /* SOCKET */
    int fd;
    if((fd = socket(AF_INET,SOCK_DGRAM,0)) < 0) {
        printf("ERROR! socket\n");
        goto exit_thread;
    }

    /* THREAD - dumpCount() */
    int rc;
    pthread_t thread;
    rc = pthread_create(&thread,NULL,dumpCounts,NULL);
    if(rc) {
        printf("ERROR! Return code from pthread_create is %d\n", rc);
        goto exit_no_thread;
    }

    bzero((void*)&servidor, sizeof(servidor));
    servidor.sin_family = AF_INET;
    inet_pton(AF_INET,ip,(void*)&(servidor.sin_addr.s_addr));
    servidor.sin_port = htons(porta);

    int rb;
    if((rb = bind(fd, (struct sockaddr *)&servidor, sizeof(servidor))) < 0) {
        printf("ERROR! bind\n");
        goto exit_thread;
    }

    printf("listener: waiting to recvfrom\n");

    char buf[MAXBUFLEN];
    int numbytes;
    struct sockaddr_storage their_addr;
    socklen_t addr_len;

    while(1) {
        if((numbytes = recvfrom(fd, buf, MAXBUFLEN-1, 0,
                                (struct sockaddr *)&their_addr, &addr_len)) == -1) {
            printf("ERROR! recvfrom\n");
            goto exit_thread;
        }

        buf[numbytes] = '\0';
        printf("DADOS DO PACOTE: \n%s\n\n",buf);
    }

exit_thread:
    pthread_exit(NULL);

exit_no_thread:
    closeDescriptor(&nf2);
    close(fd);
    return 0;
}
/*
  Checks for commandline args, intializes globals, then  begins code download.
*/
int download_very_fast(int frequency) {

   nf2.device_name = DEFAULT_IFACE;
   struct in_addr ip[32], mask[32], gw[32], gw_arp[32], ip_filter[32];
   unsigned int mac_hi[32];
   unsigned int mac_lo[32];
   unsigned int mac0_hi,mac0_lo;
   unsigned int mac1_hi,mac1_lo;
   unsigned int mac2_hi,mac2_lo;
   unsigned int mac3_hi,mac3_lo;

   /*if(argc<2) {
	printf("run <command> <0/1> (0 down; 1 up)\n");
	exit(1);
   }*/
   freq = frequency;
   if(freq!=0 && freq!=1) {
	printf("argument must be either 0 or 1!!!\n");
	exit(1);
   }

   if (check_iface(&nf2))
   {
	   exit(1);
   }
   if (openDescriptor(&nf2))
   {
      exit(1);
   }

   int i;
   char iface;
   unsigned int port[32];
 
   readReg(&nf2,ROUTER_OP_LUT_MAC_0_HI_REG,&mac0_hi);
   readReg(&nf2,ROUTER_OP_LUT_MAC_1_HI_REG,&mac1_hi);
   readReg(&nf2,ROUTER_OP_LUT_MAC_2_HI_REG,&mac2_hi);
   readReg(&nf2,ROUTER_OP_LUT_MAC_3_HI_REG,&mac3_hi);
   readReg(&nf2,ROUTER_OP_LUT_MAC_0_LO_REG,&mac0_lo);
   readReg(&nf2,ROUTER_OP_LUT_MAC_1_LO_REG,&mac1_lo);
   readReg(&nf2,ROUTER_OP_LUT_MAC_2_LO_REG,&mac2_lo);
   readReg(&nf2,ROUTER_OP_LUT_MAC_3_LO_REG,&mac3_lo);

   for(i=0; i<32;i++) {
	bzero(&ip_filter[i], sizeof(struct in_addr));
	writeReg(&nf2, ROUTER_OP_LUT_DST_IP_FILTER_TABLE_RD_ADDR_REG, i);
        readReg(&nf2, ROUTER_OP_LUT_DST_IP_FILTER_TABLE_ENTRY_IP_REG, &ip_filter[i].s_addr);

        bzero(&gw_arp[i], sizeof(struct in_addr));
        /* write the row number */
        writeReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_RD_ADDR_REG, i);

        /* read the four-touple (mac hi, mac lo, gw, num of misses) */
        readReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_HI_REG, &mac_hi[i]);
        readReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_LO_REG, &mac_lo[i]);
        readReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_ENTRY_NEXT_HOP_IP_REG, &gw_arp[i].s_addr);

        bzero(&ip[i], sizeof(struct in_addr));
        bzero(&mask[i], sizeof(struct in_addr));
        bzero(&gw[i], sizeof(struct in_addr));

        /* write the row number */
        writeReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_RD_ADDR_REG, i);

        /* read the four-tuple (ip, gw, mask, iface) from the hw registers */
        readReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_IP_REG, &ip[i].s_addr);
        readReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_MASK_REG, &mask[i].s_addr);
        readReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_NEXT_HOP_IP_REG, &gw[i].s_addr);
        readReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_OUTPUT_PORT_REG, &port[i]);

       }


      ResetDevice();

      writeReg(&nf2,ROUTER_OP_LUT_MAC_0_HI_REG,mac0_hi);
      writeReg(&nf2,ROUTER_OP_LUT_MAC_1_HI_REG,mac1_hi);
      writeReg(&nf2,ROUTER_OP_LUT_MAC_2_HI_REG,mac2_hi);
      writeReg(&nf2,ROUTER_OP_LUT_MAC_3_HI_REG,mac3_hi);
      writeReg(&nf2,ROUTER_OP_LUT_MAC_0_LO_REG,mac0_lo);
      writeReg(&nf2,ROUTER_OP_LUT_MAC_1_LO_REG,mac1_lo);
      writeReg(&nf2,ROUTER_OP_LUT_MAC_2_LO_REG,mac2_lo);
      writeReg(&nf2,ROUTER_OP_LUT_MAC_3_LO_REG,mac3_lo);
      for(i=0; i<32;i++) {
      	    writeReg(&nf2, ROUTER_OP_LUT_DST_IP_FILTER_TABLE_ENTRY_IP_REG, ip_filter[i].s_addr);
            writeReg(&nf2, ROUTER_OP_LUT_DST_IP_FILTER_TABLE_WR_ADDR_REG, i);

	    /* read the four-tuple (ip, gw, mask, iface) from the hw registers */
            writeReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_HI_REG, mac_hi[i]);
            writeReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_LO_REG, mac_lo[i]);
            writeReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_ENTRY_NEXT_HOP_IP_REG, gw_arp[i].s_addr);

            /* write the row number */
            writeReg(&nf2, ROUTER_OP_LUT_ARP_TABLE_WR_ADDR_REG, i);

            /* read the four-tuple (ip, gw, mask, iface) from the hw registers */
            writeReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_IP_REG, ip[i].s_addr);
            writeReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_MASK_REG, mask[i].s_addr);
            writeReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_NEXT_HOP_IP_REG, gw[i].s_addr);
            writeReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_OUTPUT_PORT_REG, port[i]);

            /* write the row number */
            writeReg(&nf2, ROUTER_OP_LUT_ROUTE_TABLE_WR_ADDR_REG, i);
        
   }

   /* wait until the resets have been completed */
   usleep(1);

   closeDescriptor(&nf2);

   return SUCCESS;
}
Esempio n. 20
0
int 
main() {
  unsigned val;
  int i;
  uint32_t queue_addr_offset = OQ_QUEUE_1_ADDR_LO_REG - OQ_QUEUE_0_ADDR_LO_REG;
  uint32_t curr_addr = 0;
  uint32_t rx_queue_size = (MEM_SIZE - 4*XMIT_QUEUE_SIZE)/8;

  uint32_t src_port = 0, dst_port = 0x100;
  uint32_t word_len = 0, len = 0x100;
  uint32_t queue_base_addr[] = {0,0,0,0};

  char *data;
  uint32_t data_len, rate_limit_offset;
  uint32_t pointer = 0, pkt_pointer = 0;
  uint32_t drop;

  nf2.device_name = DEFAULT_IFACE;
  if (check_iface(&nf2)) 
    exit(1);

  if (openDescriptor(&nf2))
    exit(1);

  // Disable the output queues by writing 0x0 to the enable register
  writeReg(&nf2, PKT_GEN_CTRL_ENABLE_REG,  0x00);

  //generate the data we want to send
  init_data(&det);
  innitialize_generator_packet(&state, &det);

  // Disable output queues
  // Note: 3 queues per port -- rx, tx and tx-during-setup
  for (i = 0; i < 3 * NUM_PORTS; i++) {
    writeReg (&nf2, (OQ_QUEUE_0_CTRL_REG + i*queue_addr_offset), 0x00);
  }

  //Set queue sizes thourght the relevant registers
  for (i = 0; i<NUM_PORTS; i++) {
    //set queue sizes for tx-during-setup
    writeReg (&nf2, (OQ_QUEUE_0_ADDR_LO_REG + (i*2)*queue_addr_offset), curr_addr);
    writeReg (&nf2, (OQ_QUEUE_0_ADDR_HI_REG + (i*2)*queue_addr_offset), curr_addr + XMIT_QUEUE_SIZE - 1);
    writeReg (&nf2, (OQ_QUEUE_0_CTRL_REG + (i*2)*queue_addr_offset), 0x02);
    curr_addr += XMIT_QUEUE_SIZE;

    //Set queue sizes for RX queues
    writeReg (&nf2,OQ_QUEUE_0_ADDR_LO_REG + (i*2+1)*queue_addr_offset, curr_addr);
    writeReg (&nf2,OQ_QUEUE_0_ADDR_HI_REG + (i*2+1)*queue_addr_offset, curr_addr+rx_queue_size-1);
    writeReg (&nf2,OQ_QUEUE_0_CTRL_REG + (i*2+1)*queue_addr_offset, 0x02);
    curr_addr += rx_queue_size;

  }
  
  for (i = 0; i < NUM_PORTS; i++) {
    //Set queue sizes for TX queues
    writeReg (&nf2, OQ_QUEUE_0_ADDR_LO_REG + (i + 2*NUM_PORTS)*queue_addr_offset, curr_addr);
    writeReg (&nf2, OQ_QUEUE_0_ADDR_HI_REG + (i + 2*NUM_PORTS)*queue_addr_offset, curr_addr + ((i == 3)?  
											       det.pkt_size + ceil(det.pkt_size/8) + 1:1) - 1);
    writeReg (&nf2,OQ_QUEUE_0_CTRL_REG + (i+2*NUM_PORTS)*queue_addr_offset,  0x02);
    queue_base_addr[i] = curr_addr;
    curr_addr += ((i == 3)? det.pkt_size + ceil(det.pkt_size/8) + 1:1);

    //$queue_base_addr[$i] = $curr_addr;
    //$curr_addr += $queue_size;
  }

  //data + netfpga packet length + 1 byte for the ctrl part for each word
  data_len = state.data_len + 9 + ceil((float)state.data_len/8);
  data = malloc(data_len);
  bzero(data, data_len);
  pointer = 0;
  pkt_pointer = 0;

  //append netfpga header
  data[pointer] = IO_QUEUE_STAGE_NUM;
  pointer++;
  *(uint16_t *)(data + pointer ) = 0x0;
  pointer+=2;
  *(uint16_t *)(data + pointer ) = (uint16_t)ceil((float)state.data_len/8);
  pointer+=2;
  *(uint16_t *)(data + pointer ) = (uint16_t)(0x100 << 3);
  pointer+=2;
  *(uint16_t *)(data + pointer ) = (uint16_t)state.data_len;
  pointer+=2;

  printf("size: %d %d output: %d\n", (uint16_t)ceil((float)state.data_len/8), state.data_len, (uint16_t)(0x100 << 3));
  
  //put data
  queue_addr_offset = OQ_QUEUE_GROUP_INST_OFFSET;

  for(i = 0; i < floor((float)state.data_len/8); i++) {
    data[pointer] = 0x0;
    pointer++;
    memcpy(data+pointer, state.data + pkt_pointer, 8);
    pkt_pointer += 8;
    pointer += 8;
  }
  data[pointer] = state.data_len - pkt_pointer;
  pointer++;
  memcpy(data+pointer, state.data + pkt_pointer, state.data_len - pkt_pointer); 
  pointer+= state.data_len - pkt_pointer;
  

  uint32_t sram_addr = SRAM_BASE_ADDR + queue_base_addr[3]*16;
  
  //finally copy data on the SRAM
  for (i = 0; i < data_len; i+=3) {
    writeReg (&nf2,sram_addr + 0x0, *((uint32_t *)(data + 4*i)));
    writeReg (&nf2,sram_addr + 0x4, *((uint32_t *)(data + 4*(i + 1))));
    writeReg (&nf2,sram_addr + 0x8, *((uint32_t *)(data + 4*(i + 2))));
    int j;
    if (4*i < 64) {
      for (j = 4*i; (j < 4*i+16); j+=4) {
	printf("%02x%02x%02x%02x ", (uint8_t)data[j], (uint8_t)data[j+1], (uint8_t)data[j+2], (uint8_t)data[j+3]);
      }
      printf("\n");
    }
    sram_addr += 12;
  }

  //ff 0000 af00 0008 7805 0000 15

  // Set the rate limiter for CPU queues
/*   for (i = 0; i < 4; i++) { */
/*     rate_limiter_set(i * 2 + 1, 200000); */
/*   } */

  queue_addr_offset = OQ_QUEUE_GROUP_INST_OFFSET;
  // Set the number of iterations for the queues with pcap files
  for (i = 0; i < NUM_PORTS; i++) {
    // rate_limiter_disable($i * 2);
    rate_limit_offset = RATE_LIMIT_1_CTRL_REG - RATE_LIMIT_0_CTRL_REG;

    //disable repetition
    writeReg(&nf2, OQ_QUEUE_0_CTRL_REG + (i + 2 * NUM_PORTS) * queue_addr_offset, 0x0);
    //
    writeReg (&nf2, RATE_LIMIT_0_CTRL_REG + 2 * i * rate_limit_offset, 0x0);
    // disable rate limit on CPU queues
    writeReg (&nf2, RATE_LIMIT_0_CTRL_REG + (2*i + 1) * rate_limit_offset, 0x0);
  }

  //set queue 3 to repeat once
  writeReg(&nf2, OQ_QUEUE_0_CTRL_REG + (3 + 2 * NUM_PORTS) * queue_addr_offset, 0x1);
  writeReg(&nf2, OQ_QUEUE_0_MAX_ITER_REG + (3 + 2 * NUM_PORTS) * queue_addr_offset, 1);


  //Enable the packet generator hardware to send the packets
  drop = 0;
/*   for (i = 0; i < NUM_PORTS; i++) { */
/*       drop = drop | (1 << i); */
    
/*     drop = drop << 8; */
/*   } */
  printf("drop 0x%X...\n", drop | 0xF);
  //packet_generator_enable (drop | 0xF);
  writeReg(&nf2, PKT_GEN_CTRL_ENABLE_REG,  drop | 0xF);

  sleep(10);

  //Finish up
  writeReg(&nf2, PKT_GEN_CTRL_ENABLE_REG, 0x0);
  for (i = 0; i < 1024; i++) {
    //    reset_delay();
    writeReg(&nf2, DELAY_RESET_REG, 1);
  }

  //display_xmit_metrics();
  printf("Transmit statistics:\n");
  printf("====================\n\n");

  for (i = 0; i < NUM_PORTS; i++) {
    uint32_t pkt_cnt, iter_cnt;
    readReg(&nf2, OQ_QUEUE_0_NUM_PKTS_REMOVED_REG + (i + 8) * queue_addr_offset, &pkt_cnt);
    readReg(&nf2, OQ_QUEUE_0_CURR_ITER_REG + (i + 8) * queue_addr_offset, &iter_cnt);
      
      printf("%d:\n", i + 8);
      printf("\tPackets: %u\n", pkt_cnt);
      printf("\tCompleted iterations: %u\n", iter_cnt);
  }
  printf("\n\n");

  //display_capture_metrics();
  
  printf("sending packet completed...");
  
  closeDescriptor(&nf2);
  
  printf("Test successful\n");  
  
}
Esempio n. 21
0
/*
 * Function usbfbus_find_interfaces ()
 *
 *    Find available USB DKU2 FBUS interfaces on the system
 */
static int usbfbus_find_interfaces(struct gn_statemachine *state)
{
	struct usb_bus *busses;
	struct usb_bus *bus;
	struct usb_device *dev;
	int c, i, a, retval = 0;
	struct fbus_usb_interface_transport *current = NULL;
	struct fbus_usb_interface_transport *tmp = NULL;
	struct usb_dev_handle *usb_handle;
	int n;

	/* For connection type dku2libusb port denotes number of DKU2 device */
	n = atoi(state->config.port_device);
	/* Assume default is first interface */
	if (n < 1) {
		n = 1;
		dprintf("port = %s is not valid for connection = dku2libusb using port = %d instead\n", state->config.port_device, n);
	}

	usb_init();
	usb_find_busses();
	usb_find_devices();

	busses = usb_get_busses();

	for (bus = busses; bus; bus = bus->next) {
		for (dev = bus->devices; dev; dev = dev->next) {
			if (dev->descriptor.idVendor == NOKIA_VENDOR_ID) {
				/* Loop through all of the configurations */
				for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
					/* Loop through all of the interfaces */
					for (i = 0; i < dev->config[c].bNumInterfaces; i++) {
						/* Loop through all of the alternate settings */
						for (a = 0; a < dev->config[c].interface[i].num_altsetting; a++) {
							/* Check if this interface is DKU2 FBUS */
							/* and find data interface */
							current = check_iface(dev, c, i, a, current);
						}
					}
				}
			}
		}
	}

	/* rewind */
	while (current && current->prev)
		current = current->prev;

	/* Take N-th device on the list */
	while (--n && current) {
		tmp = current; 
		current = current->next;
		/* free the previous element on the list -- won't be needed anymore */
		free(tmp);
	}

	if (current) {
		int s = sizeof(fbus_usb_interface);
		state->device.device_instance = calloc(1, s);
		if (!DEVINSTANCE(state))
			goto cleanup_list;

		DEVINSTANCE(state)->interface = current;
		usb_handle = usb_open(current->device);
		get_iface_string(usb_handle, &DEVINSTANCE(state)->manufacturer, 
			current->device->descriptor.iManufacturer);
		get_iface_string(usb_handle, &DEVINSTANCE(state)->product, 
			current->device->descriptor.iProduct);
		get_iface_string(usb_handle, &DEVINSTANCE(state)->serial, 
			current->device->descriptor.iSerialNumber);
		get_iface_string(usb_handle, &DEVINSTANCE(state)->configuration, 
			current->configuration_description);
		get_iface_string(usb_handle, &DEVINSTANCE(state)->control_interface, 
			current->control_interface_description);
		get_iface_string(usb_handle, &DEVINSTANCE(state)->data_interface_idle, 
			current->data_interface_idle_description);
		get_iface_string(usb_handle, &DEVINSTANCE(state)->data_interface_active, 
			current->data_interface_active_description);
		usb_close(usb_handle);
		retval = 1;
		current = current->next;
	}

cleanup_list:
	while (current) {
		tmp = current->next;
		free(current);
		current = tmp;
	}
	return retval;
}