cardif_generic.c

Linux dot1x认证的实现

 * interface, we should return an error.  We should return a different error
 * if we have a problem sending the frame.
 *
 ******************************************/
int cardif_sendframe(struct interface_data *thisint)
{
  char nomac[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
  struct gen_sock_data *sockData;
  struct config_network *network_data;

  sockData = thisint->sockData;

  if (thisint == NULL) return XEMALLOC;

  if (thisint->sendframe == NULL)
    {
      debug_printf(DEBUG_NORMAL, "Cannot send NULL frame!\n");
      return XENOFRAMES;
    }

  if (thisint->send_size == 0) return XENONE;

  network_data = config_get_network_config();

  // The frame we are handed in shouldn't have a src/dest, so put it in.
  memcpy(&thisint->sendframe[0], &thisint->dest_mac[0], 6);
  memcpy(&thisint->sendframe[6], &thisint->source_mac[0], 6);

  if (memcmp(nomac, (char *)&network_data->dest_mac[0], 6) != 0)
    {
      debug_printf(DEBUG_INT, "Static MAC address defined!  Using it!\n");
      memcpy(&thisint->sendframe[0], &network_data->dest_mac[0], 6);
    }

  debug_printf(DEBUG_EVERYTHING, "Frame to be sent : \n");
  debug_hex_dump(DEBUG_EVERYTHING, thisint->sendframe, thisint->send_size);

  if (eth_send(sockData->eth, thisint->sendframe, thisint->send_size) < 0)
    {
      debug_printf(DEBUG_NORMAL, "Error sending frame!\n");
      return -1;
    }

  return XENONE;  // We didn't get an error.
}

/******************************************
 * 
 * Get a frame from the network.  Since we are in promisc. mode, we will get
 * frames that aren't intended for us.  So, check the frame, determine if it
 * is something we care about, and act accordingly.
 *
 ******************************************/
int cardif_getframe(struct interface_data *thisint)
{
  int pcap_ret_val = 0;
  char dot1x_default_dest[6] = {0x01, 0x80, 0xc2, 0x00, 0x00, 0x03};
  struct gen_sock_data *sockData;
  uint8_t resultframe[1520];

  sockData = thisint->sockData;

  pcap_ret_val = pcap_dispatch(sockData->pcap_descr, 1, 
			       (pcap_handler)packet_catch, NULL);

  if (pcap_ret_val == 1)
    {
      // We have more frames available.
      memcpy(resultframe, packet_ptr, packet_header->len);
      more_frames_avail = 1;
    } else {
      debug_printf(DEBUG_EVERYTHING, "Didn't get a frame.\n");
      more_frames_avail = 0;
    }
  
  debug_printf(DEBUG_EVERYTHING, "Got Frame : \n");
  debug_hex_dump(DEBUG_EVERYTHING, resultframe, packet_header->len);

  snmp_dot1xSuppEapolFramesRx();

  // Make sure that the frame we got is for us..
  if ((memcmp(&thisint->source_mac[0], &resultframe[0], 6) == 0) ||
      ((memcmp(&resultframe[0], &dot1x_default_dest[0], 6) == 0) &&
       (memcmp(&resultframe[6], &thisint->source_mac[0], 6) != 0)))
    {
      thisint->recv_size = packet_header->len;
      memcpy(thisint->recvframe, resultframe, packet_header->len);
      return packet_header->len;
    }

  // Otherwise it isn't for us. 
  debug_printf(DEBUG_INT, "Got a frame, not for us.\n");
  return XENOFRAMES;
}

/******************************************
 * 
 * Return true if there is a frame in the queue to be processed.
 *
 ******************************************/
int cardif_frameavail(struct interface_data *thisint)
{
  return more_frames_avail;
}

/******************************************
 *
 * Validate an interface, based on if it has a MAC address.
 *
 ******************************************/
int cardif_validate(char *interface)
{
  // Assume that the interface is valid, or the user wouldn't have
  // told us to use it. ;)
  return TRUE;
}

/******************************************
 *
 * Get the name of an interface, based on an index value.
 *
 ******************************************/
int cardif_get_int(int index, char *retInterface)
{
  // Enumerating interfaces isn't available with this driver!
  return XNOMOREINTS;
}


/*******************************************************
 *
 * Check to see if an interface is wireless.  On linux, we look in
 * /proc/net/wireless to see if the interface is registered with the
 * wireless extensions.
 *
 *******************************************************/
int cardif_int_is_wireless(char *interface)
{
  // Not ever going to be wireless!
  return FALSE;
}

/******************************************************
 *
 * Stub for wireless scan.
 *
 *****************************************************/
int cardif_start_wireless_scan(struct interface_data *thisint)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for encryption capabilities.
 *
 *****************************************************/
void cardif_get_abilities(struct interface_data *thisint)
{
  thisint->enc_capa = 0;
}

/*****************************************************
 *
 * Stub for interface attachment
 *
 *****************************************************/
void cardif_wait_for_int(char *intname)
{
}

/*****************************************************
 *
 * Stub for clearing encryption keys
 *
 *****************************************************/
int cardif_clear_keys(struct interface_data *intdata)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for wireless disassociation
 *
 *****************************************************/
int cardif_disassociate(struct interface_data *thisint, int reason_code)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for passive scan timer callback
 *
 *****************************************************/
void cardif_passive_scan_timeout(struct interface_data *ctx)
{
}

/*****************************************************
 *
 * Stub for deleting an encryption key
 *
 *****************************************************/
int cardif_delete_key(struct interface_data *intdata, int key_idx, int set_tx)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for disabling WPA association state
 *
 *****************************************************/
int cardif_disable_wpa_state(struct interface_data *thisint)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for wireless scanning
 *
 *****************************************************/
int cardif_do_wireless_scan(struct interface_data *thisint, char passive)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for disabling encryption
 *
 *****************************************************/
int cardif_enc_disable(struct interface_data *intdata)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for reassociating to a wireless network
 *
 *****************************************************/
void cardif_reassociate(struct interface_data *intiface, uint8_t reason)
{
}

/*****************************************************
 *
 * Stub for setting WEP keys
 *
 *****************************************************/
int cardif_set_wep_key(struct interface_data *thisint, uint8_t *key,
                       int keylen, int index)
{
}

/*****************************************************
 *
 * Stub for disassociate/roam
 *
 *****************************************************/
int cardif_wep_associate(struct interface_data *thisint, int zeros)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for setting CCMP keys
 *
 *****************************************************/
int cardif_set_ccmp_key(struct interface_data *thisint, char *addr, int keyidx,
                        int settx, char *key, int keylen)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for setting TKIP keys
 *
 *****************************************************/
int cardif_set_tkip_key(struct interface_data *thisint, char *addr,
			int keyidx, int settx, char *key, int keylen)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for enabling/disabling rx of unencrypted frames on an interface
 *
 *****************************************************/
int cardif_drop_unencrypted(struct interface_data *intdata, char endis)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for getting the WPA-IE
 *
 *****************************************************/
int cardif_get_wpa_ie(struct interface_data *intdata, char *iedata, int *ielen)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for getting the RSN-IE
 *
 *****************************************************/
int cardif_get_wpa2_ie(struct interface_data *intdata, char *iedata, int *ielen)
{
  return XENONE;
}

/*****************************************************
 *
 * Stub for enabling/disabling countermeasures on an interface
 *
 *****************************************************/
int cardif_countermeasures(struct interface_data *intdata, char endis)
{
  return XENONE;
}


#endif