iwlist.c

访问网卡的各种信息

 
    case 0x01:
      printf("WEP-40 ");
      break;
 
    case 0x02:
      printf("TKIP ");
      break;
 
    case 0x03:
      printf("WRAP ");
      break;
 
    case 0x04:
      printf("CCMP ");
      break;
 
    case 0x05:
      printf("WEP-104 ");
      break;
 
    default:
      printf("Unknown ");
      break;
    }
 }
 
/*------------------------------------------------------------------*/
/*
 * Parse, and display the results of a WPA or WPA2 IE.
 *
 */
static inline void 
iw_print_ie_wpa(unsigned char *	iebuf,
                int		buflen)
{
  int			ielen = iebuf[1] + 2;
  int			offset = 2;	/* Skip the IE id, and the length. */
  unsigned char		wpa1_oui[3] = {0x00, 0x50, 0xf2};
  unsigned char		wpa2_oui[3] = {0x00, 0x0f, 0xac};
  unsigned char *	wpa_oui;
  int			i;
  uint16_t		ver = 0;
  uint16_t		cnt = 0;

  if(ielen > buflen)
    ielen = buflen;

  switch(iebuf[0])
    {
    case 0x30:		/* WPA2 */
      /* Check if we have enough data */
      if(ielen < 4)
        {
          iw_print_ie_unknown(iebuf, buflen);
           return;
        }

      wpa_oui = wpa2_oui;
      break;

    case 0xdd:		/* WPA or else */
      wpa_oui = wpa1_oui;
 
      /* Not all IEs that start with 0xdd are WPA. 
       * So check that the OUI is valid. */
      if((ielen < 8)
         || ((memcmp(&iebuf[offset], wpa_oui, 3) != 0)
             && (iebuf[offset+3] == 0x01)))
         {
          iw_print_ie_unknown(iebuf, buflen);
           return;
         }

       offset += 4;
       break;

    default:
      return;
    }
  
  /* Pick version number (little endian) */
  ver = iebuf[offset] | (iebuf[offset + 1] << 8);
  offset += 2;

  if(iebuf[0] == 0xdd)
    printf("WPA Version %d\n", ver);
  if(iebuf[0] == 0x30)
    printf("IEEE 802.11i/WPA2 Version %d\n", ver);

  /* From here, everything is technically optional. */

  /* Check if we are done */
  if(ielen < (offset + 4))
    {
      /* We have a short IE.  So we should assume TKIP/TKIP. */
      printf("                        Group Cipher : TKIP\n");
      printf("                        Pairwise Cipher : TKIP\n");
      return;
    }
 
  /* Next we have our group cipher. */
  if(memcmp(&iebuf[offset], wpa_oui, 3) != 0)
    {
      printf("                        Group Cipher : Proprietary\n");
    }
  else
    {
      printf("                        Group Cipher : ");
      iw_print_ie_cipher(iebuf[offset+3]);
      printf("\n");
    }
  offset += 4;

  /* Check if we are done */
  if(ielen < (offset + 2))
    {
      /* We don't have a pairwise cipher, or auth method. Assume TKIP. */
      printf("                        Pairwise Ciphers (1) : TKIP\n");
      return;
    }

  /* Otherwise, we have some number of pairwise ciphers. */
  cnt = iebuf[offset] | (iebuf[offset + 1] << 8);
  offset += 2;
  printf("                        Pairwise Ciphers (%d) : ", cnt);

  if(ielen < (offset + 4*cnt))
    return;

  for(i = 0; i < cnt; i++)
    {
      if(memcmp(&iebuf[offset], wpa_oui, 3) != 0)
         {
           printf("Proprietary  ");
         }
      else
        {
           iw_print_ie_cipher(iebuf[offset+3]);
         }
      offset+=4;
    }
  printf("\n");
 
  /* Check if we are done */
  if(ielen < (offset + 2))
    return;

  /* Now, we have authentication suites. */
  cnt = iebuf[offset] | (iebuf[offset + 1] << 8);
  offset += 2;
  printf("                        Authentication Suites (%d) : ", cnt);

  if(ielen < (offset + 4*cnt))
    return;

  for(i = 0; i < cnt; i++)
    {
      if(memcmp(&iebuf[offset], wpa_oui, 3) != 0)
         {
           printf("Proprietary  ");
         }
      else
        {
           switch(iebuf[offset+3])
             {
             case 0x00:
               printf("Reserved  ");
               break;

             case 0x01:
               printf("802.1X  ");
               break;

             case 0x02:
               printf("PSK  ");
               break;

             default:
               printf("Unknown  ");
               break;
             }
         }
       offset+=4;
     }
  printf("\n");
 
  /* Check if we are done */
  if(ielen < (offset + 1))
    return;

  /* Otherwise, we have capabilities bytes.
   * For now, we only care about preauth which is in bit position 1 of the
   * first byte.  (But, preauth with WPA version 1 isn't supposed to be 
   * allowed.) 8-) */
  if(iebuf[offset] & 0x01)
    {
      printf("                       Preauthentication Supported\n");
    }
}
 
/*------------------------------------------------------------------*/
/*
 * Process a generic IE and display the info in human readable form
 * for some of the most interesting ones.
 * For now, we only decode the WPA IEs.
 */
static inline void
iw_print_gen_ie(unsigned char *	buffer,
                int		buflen)
{
  int offset = 0;

  /* Loop on each IE, each IE is minimum 2 bytes */
  while(offset <= (buflen - 2))
    {
      printf("                    IE: ");

      /* Check IE type */
      switch(buffer[offset])
        {
        case 0xdd:	/* WPA1 (and other) */
        case 0x30:	/* WPA2 */
          iw_print_ie_wpa(buffer + offset, buflen);
          break;
        default:
          iw_print_ie_unknown(buffer + offset, buflen);
        }
      /* Skip over this IE to the next one in the list. */
      offset += buffer[offset+1] + 2;
    }
}

/*------------------------------------------------------------------*/
/*
 * Print one element from the scanning results
 */
static inline void
print_scanning_token(struct stream_descr *	stream,	/* Stream of events */
                     struct iw_event *		event,	/* Extracted token */
                     struct iwscan_state *	state,
                     struct iw_range *	iw_range,	/* Range info */
                     int		has_range)
{
  char		buffer[128];	/* Temporary buffer */

  /* Now, let's decode the event */
  switch(event->cmd)
    {
    case SIOCGIWAP:
      printf("          Cell %02d - Address: %s\n", state->ap_num,
             iw_saether_ntop(&event->u.ap_addr, buffer));
      state->ap_num++;
      break;
    case SIOCGIWNWID:
      if(event->u.nwid.disabled)
        printf("                    NWID:off/any\n");
      else
        printf("                    NWID:%X\n", event->u.nwid.value);
      break;
    case SIOCGIWFREQ:
      {
        double		freq;			/* Frequency/channel */
        int		channel = -1;		/* Converted to channel */
        freq = iw_freq2float(&(event->u.freq));
        /* Convert to channel if possible */
        if(has_range)
          channel = iw_freq_to_channel(freq, iw_range);
        iw_print_freq(buffer, sizeof(buffer),
                      freq, channel, event->u.freq.flags);
        printf("                    %s\n", buffer);
      }
      break;
    case SIOCGIWMODE:
      printf("                    Mode:%s\n",
             iw_operation_mode[event->u.mode]);
      break;
    case SIOCGIWNAME:
      printf("                    Protocol:%-1.16s\n", event->u.name);
      break;
    case SIOCGIWESSID:
      {
        char essid[IW_ESSID_MAX_SIZE+1];
        memset(essid, '\0', sizeof(essid));
        if((event->u.essid.pointer) && (event->u.essid.length))
          memcpy(essid, event->u.essid.pointer, event->u.essid.length);
        if(event->u.essid.flags)
          {
            /* Does it have an ESSID index ? */
            if((event->u.essid.flags & IW_ENCODE_INDEX) > 1)
              printf("                    ESSID:\"%s\" [%d]\n", essid,
                     (event->u.essid.flags & IW_ENCODE_INDEX));
            else
              printf("                    ESSID:\"%s\"\n", essid);
          }
        else
          printf("                    ESSID:off/any/hidden\n");
      }
      break;
    case SIOCGIWENCODE:
      {
        unsigned char	key[IW_ENCODING_TOKEN_MAX];
        if(event->u.data.pointer)
          memcpy(key, event->u.data.pointer, event->u.data.length);
        else
          event->u.data.flags |= IW_ENCODE_NOKEY;
        printf("                    Encryption key:");
        if(event->u.data.flags & IW_ENCODE_DISABLED)
          printf("off\n");
        else
          {
            /* Display the key */
            iw_print_key(buffer, sizeof(buffer), key, event->u.data.length,
                         event->u.data.flags);
            printf("%s", buffer);

            /* Other info... */
            if((event->u.data.flags & IW_ENCODE_INDEX) > 1)
              printf(" [%d]", event->u.data.flags & IW_ENCODE_INDEX);
            if(event->u.data.flags & IW_ENCODE_RESTRICTED)
              printf("   Security mode:restricted");
            if(event->u.data.flags & IW_ENCODE_OPEN)
              printf("   Security mode:open");
            printf("\n");
          }
      }
      break;
    case SIOCGIWRATE:
      if(state->val_index == 0)
        printf("                    Bit Rates:");
      else
        if((state->val_index % 5) == 0)
          printf("\n                              ");
        else
          printf("; ");
      iw_print_bitrate(buffer, sizeof(buffer), event->u.bitrate.value);
      printf("%s", buffer);
      /* Check for termination */
      if(stream->value == NULL)
        {
          printf("\n");
          state->val_index = 0;
        }
      else
        state->val_index++;
      break;
    case IWEVQUAL:
      {
        iw_print_stats(buffer, sizeof(buffer),
                       &event->u.qual, iw_range, has_range);
        printf("                    %s\n", buffer);
        break;
      }
    case IWEVGENIE:
      /* Informations Elements are complex, let's do only some of them */
      iw_print_gen_ie(event->u.data.pointer, event->u.data.length);
      break;
    case IWEVCUSTOM:
      {
        char custom[IW_CUSTOM_MAX+1];
        if((event->u.data.pointer) && (event->u.data.length))
          memcpy(custom, event->u.data.pointer, event->u.data.length);
        custom[event->u.data.length] = '\0';
        printf("                    Extra:%s\n", custom);
      }
      break;
    default:
      printf("                    (Unknown Wireless Token 0x%04X)\n",
             event->cmd);
   }	/* switch(event->cmd) */
}

/*------------------------------------------------------------------*/
/*
 * Perform a scanning on one device
 */
static int
print_scanning_info(int		skfd,
                    char *	ifname,
                    char *	args[],		/* Command line args */
                    int		count)		/* Args count */
{
  struct iwreq		wrq;
  unsigned char *	buffer = NULL;		/* Results */
  int			buflen = IW_SCAN_MAX_DATA; /* Min for compat WE<17 */
  struct iw_range	range;
  int			has_range;
  struct timeval	tv;				/* Select timeout */
  int			timeout = 15000000;		/* 15s */

  /* Avoid "Unused parameter" warning */
  args = args; count = count;

  /* Get range stuff */
  has_range = (iw_get_range_info(skfd, ifname, &range) >= 0);

  /* Check if the interface could support scanning. */
  if((!has_range) || (range.we_version_compiled < 14))
    {
      fprintf(stderr, "%-8.16s  Interface doesn't support scanning.\n\n",
              ifname);
      return(-1);
    }

  /* Init timeout value -> 250ms*/
  tv.tv_sec = 0;
  tv.tv_usec = 250000;

  /*
   * Here we should look at the command line args and set the IW_SCAN_ flags
   * properly
   */
  wrq.u.data.pointer = NULL;		/* Later */