cardif_linux_wext.c

Linux上的802.1x 的supplicant的实现。很多supplicant程序都是基于它开发的

  memset(&iwr, 0x00, sizeof(iwr));

  // Specify the interface name we are asking about.
  Strncpy(iwr.ifr_name, thisint->intName, sizeof(iwr.ifr_name));

  if (ioctl(sockData->sockInt, SIOCGIWAP, &iwr) < 0) 
    {
      debug_printf(DEBUG_NORMAL, "Couldn't get MAC address for AP!\n");
      return XENOWIRELESS;
    }

  memcpy(bssid_dest, iwr.u.ap_addr.sa_data, 6);
  return XENONE;
}

/******************************************
 *
 * Ask the wireless card for the ESSID that we are currently connected to.  If
 * this is not a wireless card, or the information is not available, we should
 * return an error.
 *
 ******************************************/
int cardif_linux_wext_get_ssid(struct interface_data *thisint, char *ssid_name)
{
  struct iwreq iwr;
  struct lin_sock_data *sockData;
  char newssid[100];

  if (!xsup_assert((thisint != NULL), "thisint != NULL", FALSE))
    return XEMALLOC;

  if (!xsup_assert((ssid_name != NULL), "ssid_name != NULL", FALSE))
    return XEMALLOC;

  sockData = thisint->sockData;

  memset(&iwr, 0x00, sizeof(iwr));

  xsup_assert((sockData != NULL), "sockData != NULL", TRUE);
 
  if (!TEST_FLAG(thisint->flags, IS_WIRELESS))
    {
      // We want to verify that the interface is in fact, not wireless, and
      // not that we are in a situation where the interface has just been 
      // down.
      debug_printf(DEBUG_NORMAL, "This interface isn't wireless!\n");
      return XENOWIRELESS;
    } 

  // If we get here, and isWireless == FALSE, then we need to double
  // check that our interface is really not wireless.
  if (!TEST_FLAG(thisint->flags, IS_WIRELESS))
    {
      if (cardif_int_is_wireless(thisint->intName) == TRUE)
	{
	  SET_FLAG(thisint->flags, IS_WIRELESS);
	} else {
	  UNSET_FLAG(thisint->flags, IS_WIRELESS);
	}

      if (!TEST_FLAG(thisint->flags, IS_WIRELESS))
	{
	  UNSET_FLAG(thisint->flags, WAS_DOWN);
	}
    }

  // Specify the interface name we are asking about.
  Strncpy(iwr.ifr_name, thisint->intName, sizeof(iwr.ifr_name));

  memset(newssid, 0x00, IW_ESSID_MAX_SIZE+1);
  iwr.u.essid.pointer = (caddr_t) newssid;
  iwr.u.essid.length = 100;
  iwr.u.essid.flags = 0;

  if (ioctl(sockData->sockInt, SIOCGIWESSID, &iwr) < 0)
    {
      debug_printf(DEBUG_NORMAL, "Couldn't get ESSID!\n");
      debug_printf(DEBUG_NORMAL, "Error (%d) : %s\n", errno, strerror(errno));
      return XENOWIRELESS;
    }

  UNSET_FLAG(thisint->flags, WAS_DOWN);

  Strncpy(ssid_name, newssid, iwr.u.essid.length);

  return XENONE;
}

/***********************************************************************
 *
 *  This function is called when we roam, or disassociate.  It should
 *  reset the card to a state where it can associate with a new AP.
 *
 ***********************************************************************/
int cardif_linux_wext_wep_associate(struct interface_data *intdata, 
				    int zero_keys)
{
  uint8_t *bssid;
  struct config_globals *globals;

  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  cardif_linux_wext_wpa_state(intdata, 0);

  cardif_linux_wext_set_ssid(intdata, intdata->cur_essid);

  if (zero_keys == 0)
    {
      debug_printf(DEBUG_INT, "WEP: turning encryption off.\n");
      return cardif_linux_wext_enc_disable(intdata);
    } else if (zero_keys == 1)
      {
      debug_printf(DEBUG_INT, "WEP: zero keys.\n");
	cardif_linux_wext_zero_keys(intdata);
	return XENONE;
      } else
	{
	  debug_printf(DEBUG_NORMAL, "Invalid association value.\n");
	}

  bssid = config_ssid_get_mac();
  if (bssid != NULL)
    {
      debug_printf(DEBUG_INT, "Dest. BSSID : ");
      debug_hex_printf(DEBUG_INT, bssid, 6);
    }

  globals = config_get_globals();

  if ((!globals) || (!TEST_FLAG(globals->flags, CONFIG_GLOBALS_FIRMWARE_ROAM)))
    {
      cardif_linux_wext_set_bssid(intdata, bssid);
    }

  return XENOTHING_TO_DO;
}

#if WIRELESS_EXT > 17
int cardif_linux_wext_mlme(struct interface_data *thisint, uint16_t mlme_type,
			   uint16_t mlme_reason)
{
  struct iwreq iwr;
  struct lin_sock_data *sockData;
  struct iw_mlme iwm;

  if (!xsup_assert((thisint != NULL), "thisint != NULL", FALSE))
    return XEMALLOC;

  sockData = thisint->sockData;

  xsup_assert((sockData != NULL), "sockData != NULL", TRUE);

  // If we get here, and isWireless == FALSE, then we need to double
  // check that our interface is really not wireless.
  if (!TEST_FLAG(thisint->flags, IS_WIRELESS))
    {
      if (cardif_int_is_wireless(thisint->intName) == TRUE)
	{
	  SET_FLAG(thisint->flags, IS_WIRELESS);
	} else {
	  UNSET_FLAG(thisint->flags, IS_WIRELESS);
	}

      if (!TEST_FLAG(thisint->flags, IS_WIRELESS))
	{
	  UNSET_FLAG(thisint->flags, WAS_DOWN);
	}
    }  

  memset(&iwr, 0, sizeof(iwr));
  // Specify the interface name we are asking about.
  Strncpy(iwr.ifr_name, thisint->intName, sizeof(iwr.ifr_name));

  memset(&iwm, 0, sizeof(iwm));
  
  // Set up our MLME struct.
  iwm.cmd = mlme_type;
  iwm.reason_code = mlme_reason;
  iwm.addr.sa_family = ARPHRD_ETHER;

  // Need to specify the MAC address that we want to do this MLME for.
  memcpy(iwm.addr.sa_data, thisint->source_mac, 6);
  iwr.u.data.pointer = (caddr_t)&iwm;
  iwr.u.data.length = sizeof(iwm);

  if (ioctl(sockData->sockInt, SIOCSIWMLME, &iwr))
    {
      debug_printf(DEBUG_NORMAL, "Couldn't issue MLME request!\n");
    }
  
  return XENONE;
}
#endif

int cardif_linux_wext_disassociate(struct interface_data *intdata, int reason)
{
#if WIRELESS_EXT > 17
  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  cardif_linux_wext_mlme(intdata, IW_MLME_DISASSOC, reason);
  cardif_linux_wext_mlme(intdata, IW_MLME_DEAUTH, reason);
#endif
  return XENONE;
}

int cardif_linux_wext_set_key_ext(struct interface_data *intdata, int alg, 
				   unsigned char *addr, int keyidx, int settx, 
				   char *seq,  int seqlen, char *key, 
				   int keylen)
{
#if WIRELESS_EXT > 17
  struct iwreq wrq;
  struct lin_sock_data *sockData;
  struct iw_encode_ext *iwee;

  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  sockData = intdata->sockData;

  xsup_assert((sockData != NULL), "sockData != NULL", TRUE);

  memset(&wrq, 0x00, sizeof(wrq));
  Strncpy((char *)&wrq.ifr_name, intdata->intName, sizeof(wrq.ifr_name));

  // Allocate enough memory to hold our iw_encode_ext struct, and the
  // key itself.
  iwee = (struct iw_encode_ext *)malloc(sizeof(struct iw_encode_ext) + keylen);

  memset(iwee, 0x00, sizeof(struct iw_encode_ext));

  iwee->alg = alg;
  iwee->ext_flags = keyidx+1;

  if ((seq != NULL) && (seqlen > 0))
    {
      iwee->ext_flags |= IW_ENCODE_EXT_RX_SEQ_VALID;
      memcpy(iwee->rx_seq, seq, seqlen);
    }
  
  if (settx) 
    {
      iwee->ext_flags |= IW_ENCODE_EXT_SET_TX_KEY;
      if ((addr != NULL) && 
	  (memcmp(addr, "\0xff\0xff\0xff\0xff\0xff\0xff", 6) != 0))
	{
	  memcpy(iwee->addr.sa_data, addr, 6);
	} else {
	  memcpy(iwee->addr.sa_data, intdata->dest_mac, 6);
	}
    } else {
      iwee->ext_flags |= IW_ENCODE_EXT_GROUP_KEY;
      memset(iwee->addr.sa_data, 0xff, 6);
    }
  iwee->addr.sa_family = ARPHRD_ETHER;

  iwee->key_len = keylen;
  memcpy(iwee->key, key, keylen);

  if (key)
    {
      debug_printf(DEBUG_INT, "Key Index : %d   Length : %d\n", keyidx, keylen);
      debug_printf(DEBUG_INT, "Destination MAC : ");
      debug_hex_printf(DEBUG_INT, iwee->addr.sa_data, 6);

      debug_printf(DEBUG_INT, "Setting key : ");
      debug_hex_printf(DEBUG_INT, iwee->key, keylen);
    }

  wrq.u.encoding.pointer = (caddr_t)iwee;
  wrq.u.encoding.flags = (keyidx + 1);
  wrq.u.encoding.length = sizeof(struct iw_encode_ext) + keylen;

  if (ioctl(sockData->sockInt, SIOCSIWENCODEEXT, &wrq) < 0)
    {
      debug_printf(DEBUG_NORMAL, "Error setting key!! (IOCTL "
		   "failure.)\n");
      debug_printf(DEBUG_NORMAL, "Error %d : %s\n", errno, strerror(errno));
    }

  if (iwee)
    {
      free(iwee);
      iwee = NULL;
    }

#else
  debug_printf(DEBUG_NORMAL, "%s : Not supported by WE(%d)!\n", __FUNCTION__,
	       WIRELESS_EXT);
#endif

  return XENONE;
}


int cardif_linux_wext_set_tkip_key(struct interface_data *intdata, 
				   unsigned char *addr, int keyidx, int settx, 
				   char *key, int keylen)
{
#if WIRELESS_EXT > 17
  char seq[6] = {0x00,0x00,0x00,0x00,0x00,0x00};

  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  // IEEE 802.11i section 8.3.2.6 says we should set the TSC to 1.
  return cardif_linux_wext_set_key_ext(intdata, IW_ENCODE_ALG_TKIP, addr,
				       keyidx, settx, seq, 6, key, keylen);
#else
  debug_printf(DEBUG_NORMAL, "%s : Not supported by WE(%d)!\n", __FUNCTION__,
	       WIRELESS_EXT);
#endif
  return XENONE;
}

int cardif_linux_wext_set_ccmp_key(struct interface_data *intdata,
				   unsigned char *addr, int keyidx, int settx,
				   char *key, int keylen)
{
#if WIRELESS_EXT > 17
  char seq[6] = {0x00,0x00,0x00,0x00,0x00,0x00};

  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  // According to 802.11i, section 8.3.3.4.3e says we should set the PN to
  // 0 when a CCMP key is set. 
  return cardif_linux_wext_set_key_ext(intdata, IW_ENCODE_ALG_CCMP, addr,
				       keyidx, settx, seq, 6, key,
				       keylen);
#else
  debug_printf(DEBUG_NORMAL, "%s : Not supported by WE(%d)!\n", __FUNCTION__,
	       WIRELESS_EXT);
#endif
  return XENONE;
}

int cardif_linux_wext_wpa(struct interface_data *intdata, char state)
{
#if WIRELESS_EXT > 17
  int retval = 0;

  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  retval = cardif_linux_wext_set_iwauth(intdata, IW_AUTH_WPA_ENABLED,
					state, "change WPA state");

  if (retval == 0)
    {
      retval = cardif_linux_wext_set_iwauth(intdata, 
					    IW_AUTH_TKIP_COUNTERMEASURES,
					    FALSE, "TKIP countermeasures");

      if (retval == 0)
	{
	  retval = cardif_linux_wext_set_iwauth(intdata, 
						IW_AUTH_DROP_UNENCRYPTED,
						TRUE, "drop unencrypted");
	}
    }

  return retval;
#endif
  return XENONE;
}

int cardif_linux_wext_set_wpa_ie(struct interface_data *intdata, 
				 unsigned char *wpaie, unsigned int wpalen)
{
#if WIRELESS_EXT > 17
  struct iwreq wrq;
  struct lin_sock_data *sockData;

  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  sockData = intdata->sockData;

  xsup_assert((sockData != NULL), "sockData != NULL", TRUE);

  memset(&wrq, 0x00, sizeof(wrq));

  Strncpy((char *)&wrq.ifr_name, intdata->intName, sizeof(wrq.ifr_name));

  wrq.u.data.pointer = (caddr_t) wpaie;
  wrq.u.data.length = wpalen;
  wrq.u.data.flags = 0;

  if (ioctl(sockData->sockInt, SIOCSIWGENIE, &wrq) < 0)
    {
      debug_printf(DEBUG_NORMAL, "Error setting WPA IE!\n");
    } 
#endif
  return XENONE;
}


int cardif_linux_wext_wpa_state(struct interface_data *intdata, char state)
{

  // If we have wireless extensions 18 or higher, we can support WPA/WPA2
  // with standard ioctls.

#if WIRELESS_EXT > 17
  char wpaie[24];

  if (!xsup_assert((intdata != NULL), "intdata != NULL", FALSE))
    return XEMALLOC;

  if (state)
    {
      // Enable WPA if the interface doesn't already have it.
      cardif_linux_wext_wpa(intdata, TRUE);
    } else {
      cardif_linux_wext_wpa(intdata, FALSE);