iwlist.c

uclinux下802.11网卡的配置工具源码

	      /* Let's check if nothing (simply on) */
	      if((flags & IW_POWER_MODE) == IW_POWER_ON)
		printf(" mode:on");
	      printf("\n                 ");

	      /* Let's check the value and its type */
	      if(wrq.u.power.flags & IW_POWER_TYPE)
		print_pm_value(stdout, wrq.u.power.value, wrq.u.power.flags);

	      /* If we have been returned a MIN value, ask for the MAX */
	      if(flags & IW_POWER_MIN)
		pm_mask = IW_POWER_MAX;
	      /* If we have been returned a MAX value, ask for the MIN */
	      if(flags & IW_POWER_MAX)
		pm_mask = IW_POWER_MIN;
	      /* If we have something to ask for... */
	      if(pm_mask)
		get_pm_value(skfd, ifname, &wrq, pm_mask);

#if WIRELESS_EXT > 9
	      /* And if we have both a period and a timeout, ask the other */
	      pm_mask = (range.pm_capa & (~(wrq.u.power.flags) &
					  IW_POWER_TYPE));
	      if(pm_mask)
		{
		  int	base_mask = pm_mask;
		  flags = get_pm_value(skfd, ifname, &wrq, pm_mask);
		  pm_mask = 0;

		  /* If we have been returned a MIN value, ask for the MAX */
		  if(flags & IW_POWER_MIN)
		    pm_mask = IW_POWER_MAX | base_mask;
		  /* If we have been returned a MAX value, ask for the MIN */
		  if(flags & IW_POWER_MAX)
		    pm_mask = IW_POWER_MIN | base_mask;
		  /* If we have something to ask for... */
		  if(pm_mask)
		    get_pm_value(skfd, ifname, &wrq, pm_mask);
		}
#endif /* WIRELESS_EXT > 9 */
	    }
	}
      printf("\n");
    }
}

/*------------------------------------------------------------------*/
/*
 * Get Power Management info on all devices and print it on the screen
 */
static void
print_pm_devices(int		skfd)
{
  char		buff[1024];
  struct ifconf ifc;
  struct ifreq *ifr;
  int i;

  /* Get list of active devices */
  ifc.ifc_len = sizeof(buff);
  ifc.ifc_buf = buff;
  if(ioctl(skfd, SIOCGIFCONF, &ifc) < 0)
    {
      fprintf(stderr, "SIOCGIFCONF: %s\n", strerror(errno));
      return;
    }
  ifr = ifc.ifc_req;

  /* Print them */
  for(i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; ifr++)
    print_pm_info(skfd, ifr->ifr_name);
}

/************************** TRANSMIT POWER **************************/

/*------------------------------------------------------------------*/
/*
 * Print the number of available transmit powers for the device
 */
static void
print_txpower_info(int		skfd,
		   char *	ifname)
{
  struct iw_range	range;
  int			dbm;
  int			mwatt;
  int			k;

#if WIRELESS_EXT > 9
  /* Extract range info */
  if(get_range_info(skfd, ifname, &range) < 0)
      fprintf(stderr, "%-8.8s  no transmit-power information.\n\n",
		      ifname);
  else
    {
      if((range.num_txpower > 0) && (range.num_txpower < IW_MAX_TXPOWER))
	{
	  printf("%-8.8s  %d available transmit-powers :\n",
		 ifname, range.num_txpower);
	  /* Print them all */
	  for(k = 0; k < range.num_txpower; k++)
	    {
	      if(range.txpower_capa & IW_TXPOW_MWATT)
		{
		  dbm = mwatt2dbm(range.txpower[k]);
		  mwatt = range.txpower[k];
		}
	      else
		{
		  dbm = range.txpower[k];
		  mwatt = dbm2mwatt(range.txpower[k]);
		}
	      printf("\t  %d dBm  \t(%d mW)\n", dbm, mwatt);
	    }
	  printf("\n\n");
	}
      else
	printf("%-8.8s  No transmit-powers ? Please update driver...\n\n", ifname);
    }
#endif /* WIRELESS_EXT > 9 */
}

/*------------------------------------------------------------------*/
/*
 * Get tx-power info on all devices and print it on the screen
 */
static void
print_txpower_devices(int		skfd)
{
  char		buff[1024];
  struct ifconf ifc;
  struct ifreq *ifr;
  int i;

  /* Get list of active devices */
  ifc.ifc_len = sizeof(buff);
  ifc.ifc_buf = buff;
  if(ioctl(skfd, SIOCGIFCONF, &ifc) < 0)
    {
      fprintf(stderr, "SIOCGIFCONF: %s\n", strerror(errno));
      return;
    }
  ifr = ifc.ifc_req;

  /* Print them */
  for(i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; ifr++)
    print_txpower_info(skfd, ifr->ifr_name);
}

/*********************** RETRY LIMIT/LIFETIME ***********************/

#if WIRELESS_EXT > 10
/*------------------------------------------------------------------*/
/*
 * Print one retry value
 */
static inline int
get_retry_value(int		skfd,
		char *		ifname,
		struct iwreq *	pwrq,
		int		flags)
{
  /* Get Another retry value */
  strcpy(pwrq->ifr_name, ifname);
  pwrq->u.retry.flags = flags;
  if(ioctl(skfd, SIOCGIWRETRY, pwrq) >= 0)
    {
      /* Let's check the value and its type */
      if(pwrq->u.retry.flags & IW_RETRY_TYPE)
	{
	  printf("\n                 ");
	  print_retry_value(stdout, pwrq->u.retry.value, pwrq->u.retry.flags);
	}
    }
  return(pwrq->u.retry.flags);
}

/*------------------------------------------------------------------*/
/*
 * Print Retry info for each device
 */
static void
print_retry_info(int		skfd,
	      char *		ifname)
{
  struct iwreq		wrq;
  struct iw_range	range;

  /* Extract range info */
  if(get_range_info(skfd, ifname, &range) < 0)
      fprintf(stderr, "%-8.8s  no retry limit/lifetime information.\n\n",
	      ifname);
  else
    {
      printf("%-8.8s  ", ifname);

      /* Display min/max limit availables */
      if(range.retry_flags & IW_RETRY_LIMIT)
	{
	  int	flags = (range.retry_flags & ~(IW_RETRY_MIN | IW_RETRY_MAX));
	  /* Display if auto or fixed */
	  if(range.retry_flags & IW_RETRY_MIN)
	    printf("Auto  limit    ; ");
	  else
	    printf("Fixed limit    ; ");
	  /* Print the range */
	  print_retry_value(stdout, range.min_retry, flags | IW_RETRY_MIN);
	  printf("\n                           ");
	  print_retry_value(stdout, range.max_retry, flags | IW_RETRY_MAX);
	  printf("\n          ");
	  
	}
      /* Display min/max lifetime availables */
      if(range.r_time_flags & IW_RETRY_LIFETIME)
	{
	  int	flags = (range.r_time_flags & ~(IW_RETRY_MIN | IW_RETRY_MAX));
	  /* Display if auto or fixed */
	  if(range.r_time_flags & IW_RETRY_MIN)
	    printf("Auto  lifetime ; ");
	  else
	    printf("Fixed lifetime ; ");
	  /* Print the range */
	  print_retry_value(stdout, range.min_r_time, flags | IW_RETRY_MIN);
	  printf("\n                           ");
	  print_retry_value(stdout, range.max_r_time, flags | IW_RETRY_MAX);
	  printf("\n          ");
	  
	}

      /* Get current retry settings */
      strcpy(wrq.ifr_name, ifname);
      wrq.u.retry.flags = 0;
      if(ioctl(skfd, SIOCGIWRETRY, &wrq) >= 0)
	{
	  int	flags = wrq.u.retry.flags;

	  /* Is it disabled ? */
	  if(wrq.u.retry.disabled)
	    printf("Current mode:off\n          ");
	  else
	    {
	      int	retry_mask = 0;

	      /* Let's check the mode */
	      printf("Current mode:on\n                 ");

	      /* Let's check the value and its type */
	      if(wrq.u.retry.flags & IW_RETRY_TYPE)
		print_retry_value(stdout, wrq.u.retry.value, wrq.u.retry.flags);

	      /* If we have been returned a MIN value, ask for the MAX */
	      if(flags & IW_RETRY_MIN)
		retry_mask = IW_RETRY_MAX;
	      /* If we have been returned a MAX value, ask for the MIN */
	      if(flags & IW_RETRY_MAX)
		retry_mask = IW_RETRY_MIN;
	      /* If we have something to ask for... */
	      if(retry_mask)
		get_retry_value(skfd, ifname, &wrq, retry_mask);

	      /* And if we have both a period and a timeout, ask the other */
	      retry_mask = (range.retry_capa & (~(wrq.u.retry.flags) &
					  IW_RETRY_TYPE));
	      if(retry_mask)
		{
		  int	base_mask = retry_mask;
		  flags = get_retry_value(skfd, ifname, &wrq, retry_mask);
		  retry_mask = 0;

		  /* If we have been returned a MIN value, ask for the MAX */
		  if(flags & IW_RETRY_MIN)
		    retry_mask = IW_RETRY_MAX | base_mask;
		  /* If we have been returned a MAX value, ask for the MIN */
		  if(flags & IW_RETRY_MAX)
		    retry_mask = IW_RETRY_MIN | base_mask;
		  /* If we have something to ask for... */
		  if(retry_mask)
		    get_retry_value(skfd, ifname, &wrq, retry_mask);
		}
	    }
	}
      printf("\n");
    }
}

/*------------------------------------------------------------------*/
/*
 * Get retry info on all devices and print it on the screen
 */
static void
print_retry_devices(int		skfd)
{
  char		buff[1024];
  struct ifconf ifc;
  struct ifreq *ifr;
  int i;

  /* Get list of active devices */
  ifc.ifc_len = sizeof(buff);
  ifc.ifc_buf = buff;
  if(ioctl(skfd, SIOCGIFCONF, &ifc) < 0)
    {
      fprintf(stderr, "SIOCGIFCONF: %s\n", strerror(errno));
      return;
    }
  ifr = ifc.ifc_req;

  /* Print them */
  for(i = ifc.ifc_len / sizeof(struct ifreq); --i >= 0; ifr++)
    print_retry_info(skfd, ifr->ifr_name);
}
#endif	/* WIRELESS_EXT > 10 */

/******************************* MAIN ********************************/

/*------------------------------------------------------------------*/
/*
 * The main !
 */
int
main(int	argc,
     char **	argv)
{
  int skfd = -1;		/* generic raw socket desc.	*/

  /* Create a channel to the NET kernel. */
  if((skfd = sockets_open()) < 0)
    {
      perror("socket");
      exit(-1);
    }

  /* Help */
  if((argc == 1) || (argc > 3) ||
     (!strncmp(argv[1], "-h", 9)) || (!strcmp(argv[1], "--help")))
    {
      fprintf(stderr, "Usage: iwlist [interface] freq\n");
      fprintf(stderr, "              [interface] ap\n");
      fprintf(stderr, "              [interface] bitrate\n");
      fprintf(stderr, "              [interface] keys\n");
      fprintf(stderr, "              [interface] power\n");
      fprintf(stderr, "              [interface] txpower\n");
      fprintf(stderr, "              [interface] retries\n");
      close(skfd);
      exit(0);
    }

  /* Frequency list */
  if((!strncmp(argv[1], "freq", 4)) ||
     (!strncmp(argv[1], "channel", 7)))
    {
      print_freq_devices(skfd);
      close(skfd);
      exit(0);
    }

  /* Access Point list */
  if(!strcasecmp(argv[1], "ap"))
    {
      print_ap_devices(skfd);
      close(skfd);
      exit(0);
    }

  /* Bit-rate list */
  if((!strncmp(argv[1], "bit", 3)) ||
     (!strcmp(argv[1], "rate")))
    {
      print_bitrate_devices(skfd);
      close(skfd);
      exit(0);
    }

  /* Encryption key list */
  if((!strncmp(argv[1], "enc", 3)) ||
     (!strncmp(argv[1], "key", 3)))
    {
      print_keys_devices(skfd);
      close(skfd);
      exit(0);
    }

  /* Power Management list */
  if(!strncmp(argv[1], "power", 3))
    {
      print_pm_devices(skfd);
      close(skfd);
      exit(0);
    }

  /* Transmit Power list */
  if(!strncmp(argv[1], "txpower", 3))
    {
      print_txpower_devices(skfd);
      close(skfd);
      exit(0);
    }

#if WIRELESS_EXT > 10
  /* Retry limit/lifetime */
  if(!strncmp(argv[1], "retry", 4))
    {
      print_retry_devices(skfd);
      close(skfd);
      exit(0);
    }
#endif

  /* Special cases take two... */
  /* Frequency list */
  if((!strncmp(argv[2], "freq", 4)) ||
     (!strncmp(argv[2], "channel", 7)))
    {
      print_freq_info(skfd, argv[1]);
      close(skfd);
      exit(0);
    }

  /* Access Point  list */
  if(!strcasecmp(argv[2], "ap"))
    {
      print_ap_info(skfd, argv[1]);
      close(skfd);
      exit(0);
    }

  /* Bit-rate list */
  if((!strncmp(argv[2], "bit", 3)) ||
     (!strcmp(argv[2], "rate")))
    {
      print_bitrate_info(skfd, argv[1]);
      close(skfd);
      exit(0);
    }

  /* Encryption key list */
  if((!strncmp(argv[2], "enc", 3)) ||
     (!strncmp(argv[2], "key", 3)))
    {
      print_keys_info(skfd, argv[1]);
      close(skfd);
      exit(0);
    }

  /* Power Management list */
  if(!strncmp(argv[2], "power", 3))
    {
      print_pm_info(skfd, argv[1]);
      close(skfd);
      exit(0);
    }

  /* Transmit Power list */
  if(!strncmp(argv[2], "txpower", 3))
    {
      print_txpower_info(skfd, argv[1]);
      close(skfd);
      exit(0);
    }

#if WIRELESS_EXT > 10
  /* Retry limit/lifetime */
  if(!strncmp(argv[2], "retry", 4))
    {
      print_retry_info(skfd, argv[1]);
      close(skfd);
      exit(0);
    }
#endif

  /* Close the socket. */
  close(skfd);

  return(1);
}