xsupconfig.c

linux 下通过802.1认证的安装包

 *
 * @param[in] tmp_ttls   A double dereferenced pointer to the memory that
 *                       contains the EAP-TTLS configuration information.
 **/
void delete_config_eap_ttls(struct config_eap_ttls **tmp_ttls)
{
  if (*tmp_ttls == NULL)
    return;

  FREE_STRING((*tmp_ttls)->user_cert);
  FREE_STRING((*tmp_ttls)->crl_dir);
  FREE_STRING((*tmp_ttls)->user_key);
  FREE_STRING((*tmp_ttls)->user_key_pass);
  FREE_STRING((*tmp_ttls)->random_file);  
  FREE_STRING((*tmp_ttls)->cncheck);
  FREE_STRING((*tmp_ttls)->trusted_server);
  FREE_STRING((*tmp_ttls)->inner_id);
  if ((*tmp_ttls)->phase2_data) 
    delete_config_ttls_phase2((*tmp_ttls));

  free (*tmp_ttls);
  *tmp_ttls = NULL;
}

/**
 * \brief Dump to the screen, all of the configuration information that
 *        is known about EAP-TTLS.
 *
 * @param[in] ttls  A pointer to a structure that contains all of the 
 *                  configuration options for EAP-TTLS.
 **/
void dump_config_eap_ttls(struct config_eap_ttls *ttls)
{
  if (!ttls) {
    return;
  }
  printf("\t---------------eap-ttls--------------\n");
  printf("\t  TTLS Cert: \"%s\"\n", ttls->user_cert);
  printf("\t  TTLS CRL Dir: \"%s\"\n", ttls->crl_dir);
  printf("\t  TTLS Key: \"%s\"\n", ttls->user_key);
  printf("\t  TTLS Key Pass: \"%s\"\n", ttls->user_key_pass);
  printf("\t  TTLS Chunk Size: %d\n", ttls->chunk_size);
  printf("\t  TTLS Random Source: \"%s\"\n", ttls->random_file);
  printf("\t  TTLS CN to Check : \"%s\"\n", ttls->cncheck);
  printf("\t  TTLS Exact CN Match : %s\n", ttls->cnexact ? "yes" : "no"); 
  printf("\t  TTLS Session Resumption: ");
  switch (ttls->session_resume)
    {
    case RES_UNSET:
      printf("UNSET\n");
      break;
    case RES_YES:
      printf("YES\n");
      break;
    case RES_NO:
      printf("NO\n");
      break;
    }
  switch (ttls->phase2_type) {
  case TTLS_PHASE2_PAP:
    printf("\t  TTLS phase2: pap\n");    
    break;
  case TTLS_PHASE2_CHAP:
    printf("\t  TTLS phase2: chap\n");    
    break;
  case TTLS_PHASE2_MSCHAP:
    printf("\t  TTLS phase2: mschap\n");    
    break;
  case TTLS_PHASE2_MSCHAPV2:
    printf("\t  TTLS phase2: mschapv2\n");        
    break;
  case TTLS_PHASE2_EAP:
    printf("\t  TTLS phase2: EAP\n");
    break;
  default:
    printf("\t  TTLS phase2: UNDEFINED\n");    
    break;
  }
  if (ttls->phase2_data) dump_config_ttls_phase2(ttls);
  else printf("No phase 2 defined?\n");
  printf("\t------------------------------------\n");
}

  /*******************/
 /* CONFIG_MSCHAPV2 */
/*******************/

/**
 * \brief Clear from memory all of the configuration information that was
 *        used for EAP-MSCHAPv2 authentication.
 *
 * @param[in] tmp_mschapv2   A double dereferenced pointer to the space in
 *                           memory that contains the configuration information
 *                           for EAP-MSCHAPv2.
 **/
void delete_config_eap_mschapv2(struct config_eap_mschapv2 **tmp_mschapv2)
{
  if (*tmp_mschapv2 == NULL)
    return;

  FREE_STRING((*tmp_mschapv2)->password);
  FREE_STRING((*tmp_mschapv2)->nthash);

  free (*tmp_mschapv2);
  *tmp_mschapv2 = NULL;
}

/**
 * \brief Dump to the screen, all of the configuration settings known for
 *        EAP-MSCHAPv2.
 *
 * @param[in] mschapv2  A pointer to the configuration data for EAP-MSCHAPv2.
 * @param[in] level   The phase that the EAP-MSCHAPv2 configuration data will be
 *                    used in.  This allows the function to indent the output
 *                    correctly.
 **/
void dump_config_eap_mschapv2(struct config_eap_mschapv2 *mschapv2, int level)
{
  if (!mschapv2)
    return;
  if (level == 0) {
    printf("\t---------------eap-mschapv2--------------\n");
    if (mschapv2->password != NULL)
      printf("\t  MSCHAPV2 Pass      : \"%s\"\n", mschapv2->password);

    if (mschapv2->nthash != NULL)
      printf("\t  MSCHAPV2 NtPwd Hash: \"%s\"\n", mschapv2->nthash);

    if (mschapv2->ias_quirk == TRUE)
      {
	printf("\t  MSCHAPV2 IAS Quirk : Yes\n");
      }
    else
      {
	printf("\t  MSCHAPV2 IAS Quirk : No\n");
      }
    printf("\t------------------------------------\n");
  }else {
  printf("\t\t^ ^ ^  eap-mschapv2  ^ ^ ^\n");
    printf("\t\t  MSCHAPV2 Pass      : \"%s\"\n", mschapv2->password);
    printf("\t\t  MSCHAPV2 NtPwd Hash: \"%s\"\n", mschapv2->nthash);
    if (mschapv2->ias_quirk == TRUE)
      {
	printf("\t\t  MSCHAPV2 IAS Quirk : Yes\n");
      }
    else
      {
	printf("\t\t  MSCHAPV2 IAS Quirk : No\n");
      }
  printf("\t\t^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^\n");
  }

}


  /*******************/
 /* CONFIG_PEAP     */
/*******************/

/**
 * \brief Clear the memory used for the configuration of EAP-PEAP.
 *
 * @param[in] tmp_peap  A double dereferenced pointer to the block of 
 *                      memory that contains the configuration information
 *                      for EAP-PEAP.
 **/
void delete_config_eap_peap(struct config_eap_peap **tmp_peap)
{
  if (*tmp_peap == NULL)
    return;

  FREE_STRING((*tmp_peap)->identity);
  FREE_STRING((*tmp_peap)->user_cert);
  FREE_STRING((*tmp_peap)->crl_dir);
  FREE_STRING((*tmp_peap)->user_key)
  FREE_STRING((*tmp_peap)->user_key_pass);
  FREE_STRING((*tmp_peap)->random_file);
  FREE_STRING((*tmp_peap)->cncheck);
  FREE_STRING((*tmp_peap)->trusted_server);
  if ((*tmp_peap)->phase2)
    delete_config_eap_method(&(*tmp_peap)->phase2);

  free (*tmp_peap);
  *tmp_peap = NULL;
}

/**
 * \brief Dump to the screen, all of the known configuration options
 *        used by EAP-PEAP.
 *
 * @param[in] peap  A pointer to the memory where the PEAP configuration
 *                  data is stored.
 **/
void dump_config_eap_peap(struct config_eap_peap *peap)
{
  if (!peap)
    return;
  printf("\t---------------eap-peap--------------\n");
  printf("\t  PEAP phase 2 identity: \"%s\"\n", peap->identity);
  printf("\t  PEAP Cert: \"%s\"\n", peap->user_cert);
  printf("\t  PEAP CRL Dir: \"%s\"\n", peap->crl_dir);
  printf("\t  PEAP Key: \"%s\"\n", peap->user_key);
  printf("\t  PEAP Key Pass: \"%s\"\n", peap->user_key_pass);
  printf("\t  PEAP Chunk Size: %d\n", peap->chunk_size);
  printf("\t  PEAP Random Source: \"%s\"\n", peap->random_file);
  printf("\t  PEAP CN to Check : \"%s\"\n", peap->cncheck);
  printf("\t  PEAP Exact CN Match : %s\n", peap->cnexact ? "yes" : "no");  
  printf("\t  PEAP Session Resumption: ");
  switch (peap->session_resume)
    {
    case RES_UNSET:
      printf("UNSET\n");
      break;
    case RES_YES:
      printf("YES\n");
      break;
    case RES_NO:
      printf("NO\n");
      break;
    }
  printf("\t  Proper PEAPv1 Keying : %s\n", peap->proper_peapv1 ? "yes" : "no");

  if (peap->phase2) dump_config_eap_method(peap->phase2, 1);
  printf("\t------------------------------------\n");
}


  /*******************/
 /* CONFIG_SIM      */
/*******************/

/**
 * \brief  Clear out the memory that was used by the configuration for
 *         EAP-SIM.
 *
 * @param[in] tmp_sim  A double dereferenced pointer to the memory where the
 *                     EAP-SIM configuration is stored.
 **/
void delete_config_eap_sim(struct config_eap_sim **tmp_sim)
{
  if (*tmp_sim == NULL)
    return;

  FREE_STRING((*tmp_sim)->username);
  FREE_STRING((*tmp_sim)->password);

  free (*tmp_sim);
  *tmp_sim = NULL;
}

/**
 * \brief  Dump to the screen, all of the known configuration
 *         information to be used with an EAP-SIM authentication.
 *
 * @param[in] sim  A pointer to the memory where the EAP-SIM 
 *                 configuration is stored.
 *
 * @param[in] level  The phase that the EAP-SIM configuration will be 
 *                   used in.  This allows the function to properly
 *                   indent the output.
 **/
void dump_config_eap_sim(struct config_eap_sim *sim, int level)
{
  if (!sim)
    return;
  if (level == 0) {
    printf("\t---------------eap-sim--------------\n");
    printf("\t  SIM User: \"%s\"\n", sim->username);
    printf("\t  SIM Pass: \"%s\"\n", sim->password);
    printf("\t  SIM Auto Realm: %s\n", sim->auto_realm ? "yes" : "no");  
    printf("\t------------------------------------\n");
  } else {
    printf("\t\t^ ^ ^  eap-sim  ^ ^ ^\n");
    printf("\t\t  SIM User: \"%s\"\n", sim->username);
    printf("\t\t  SIM Pass: \"%s\"\n", sim->password);
    printf("\t\t  SIM Auto Realm: %s\n", sim->auto_realm ? "yes" : "no");  
    printf("\t\t^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^\n");
  }
}

  /*******************/
 /* CONFIG_AKA      */
/*******************/

/**
 * \brief Clear the memory used by the EAP-AKA configuration data.
 *
 * @param[in] tmp_aka   A double dereferenced pointer to the memory that
 *                      was used to store the EAP-AKA configuration
 *                      information.
 **/
void delete_config_eap_aka(struct config_eap_aka **tmp_aka)
{
  if (*tmp_aka == NULL)
    return;

  FREE_STRING((*tmp_aka)->username);
  FREE_STRING((*tmp_aka)->password);

  free (*tmp_aka);
  *tmp_aka = NULL;
}

/**
 * \brief Dump to the screen, all of the configuration information that
 *        is known about EAP-AKA.
 *
 * @param[in] aka  A pointer to all of the known configuration information
 *                 about EAP-AKA.
 *
 * @param[in] level   The phase that EAP-AKA will be used in.  This allows
 *                    the function to properly indent the output.
 **/
void dump_config_eap_aka(struct config_eap_aka *aka, int level)
{
  if (!aka)
    return;
  if (level == 0) {
    printf("\t---------------eap-aka--------------\n");
    printf("\t  AKA User: \"%s\"\n", aka->username);
    printf("\t  AKA Pass: \"%s\"\n", aka->password);
    printf("\t  AKA Auto Realm: %s\n", aka->auto_realm ? "yes" : "no");  
    printf("\t------------------------------------\n");
  } else {
    printf("\t\t^ ^ ^  eap-aka  ^ ^ ^\n");
    printf("\t\t  AKA User: \"%s\"\n", aka->username);
    printf("\t\t  AKA Pass: \"%s\"\n", aka->password);
    printf("\t\t  AKA Auto Realm: %s\n", aka->auto_realm ? "yes" : "no");  
    printf("\t\t^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^\n");
  }
}


  /*********************/
 /* CONFIG_EAP_METHOD */
/*********************/

/**
 * \brief Delete the EAP configuration specified by 'method'.
 *
 * @param[in] method   A double dereferenced pointer to the area in 
 *                     memory that contains the configuration information
 *                     about an EAP method.
 **/
void delete_config_eap_method(struct config_eap_method **method)
{
  if (method == NULL)
      return;

  if ((*method) == NULL)
      return;

  delete_config_eap_method(&(*method)->next);

  switch ((*method)->method_num) {
  case EAP_TYPE_TLS:
    delete_config_eap_tls((struct config_eap_tls **)&((*method)->method_data));
    break;
  case EAP_TYPE_MD5:
    delete_config_pwd_only((struct config_pwd_only **)&(*method)->method_data);
    break;
  case EAP_TYPE_PEAP:
    delete_config_eap_peap((struct config_eap_peap **)&(*method)->method_data);
    break;
  case EAP_TYPE_SIM:
    delete_config_eap_sim((struct config_eap_sim **)&(*method)->method_data);
    break;
  case EAP_TYPE_AKA:
    delete_config_eap_aka((struct config_eap_aka **)&(*method)->method_data);
    break;
  case EAP_TYPE_TTLS:
    delete_config_eap_ttls((struct config_eap_ttls **)&(*method)->method_data);
    break; 
  case EAP_TYPE_LEAP:
    delete_config_pwd_only((struct config_pwd_only **)&(*method)->method_data);
    break;
  case EAP_TYPE_MSCHAPV2:
    delete_config_eap_mschapv2((struct config_eap_mschapv2 **)&(*method)->method_data);
    break;
  case EAP_TYPE_OTP:
    // Nothing to clean up here.
    break;
  case EAP_TYPE_GTC:
    delete_config_pwd_only((struct config_pwd_only **)&(*method)->method_data);
    break;
  case EAP_TYPE_FAST:
    delete_config_eap_fast((struct config_eap_fast **)&(*method)->method_data);
    break;
  case EAP_TYPE_TNC:
    delete_config_eap_tnc((struct config_eap_tnc **)&(*method)->method_data);
    break;
  default:
    printf("AAAH! Trying to delete an undefined config"
	   " type in %s.\nNotify developers. Type: 0x%x\n", 
	   __FUNCTION__, (*method)->method_num);
  }
}

/**
 * \brief  Dump to the screen, all of the configuration information for the
 *         EAP method defined by 'method'.
 *
 * @param[in] method   A pointer to a structure in memory that contains information
 *                     about an EAP method's configuration, and an integer that
 *                     identifies the EAP method.
 *
 * @param[in] dumplevel   The phase that this EAP method will be used in.  This
 *                        allows the function to properly indent the output.
 **/
void dump_config_eap_method(struct config_eap_method *method, int dumplevel)
{
  if (method == NULL)
    return;

  switch ((method)->method_num) {
  case EAP_TYPE_TLS:
    dump_config_eap_tls((struct config_eap_tls *)((method)->method_data));
    break;
  case EAP_TYPE_MD5:
    dump_config_pwd_only((struct config_pwd_only *)(method)->method_data, 
			 "EAP-MD5", dumplevel);
    break;
  case EAP_TYPE_PEAP:
    dump_config_eap_peap((struct config_eap_peap *)(method)->method_data);
    break;

  case EAP_TYPE_TNC:
    dump_config_eap_tnc((struct config_eap_tnc *)(method)->method_data);
    break;

  case EAP_TYPE_SIM:
    dump_config_eap_sim((struct config_eap_sim *)(method)->method_data,
			dumplevel);
    break;
  case EAP_TYPE_AKA:
    dump_config_eap_aka((struct config_eap_aka *)(method)->method_data,
			dumplevel);
    break;
  case EAP_TYPE_FAST:
    dump_config_eap_fast((struct config_eap_fast *)(method)->method_data);
    break;
  case EAP_TYPE_TTLS:
    dump_config_eap_ttls((struct config_eap_ttls *)(method)->method_data);
    break; 
  case EAP_TYPE_LEAP:
    dump_config_pwd_only((struct config_pwd_only *)(method)->method_data,
			 "LEAP", dumplevel);
    break;
  case EAP_TYPE_OTP:
    dump_config_eap_otp((struct config_pwd_only *)(method)->method_data,
			 dumplevel);
    break;
  case EAP_TYPE_GTC:
    dump_config_pwd_only((struct config_pwd_only *)(method)->method_data,
			 "EAP-GTC", dumplevel);
    break;
  case EAP_TYPE_MSCHAPV2:
    dump_config_eap_mschapv2((struct config_eap_mschapv2 *)(method)->method_data,
			     dumplevel);
    break;
    
  default:
    printf("AAAH! Trying to dump an undefined config"
	   " type in %s\n.Notify developers. Type: 0x%x\n", 
	   __FUNCTION__, (method)->method_num);
  }