xsupconfig.c

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

{
  if (!ttls) {
    return;
  }
  printf("\t---------------eap-ttls--------------\n");
  printf("\t  TTLS Cert: \"%s\"\n", ttls->user_cert);
  printf("\t  TTLS Root Cert: \"%s\"\n", ttls->root_cert);
  printf("\t  TTLS Root Dir: \"%s\"\n", ttls->root_dir);
  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_MD5:
    printf("\t  TTLS phase2: eap_md5\n");
    break;
  default:
    printf("\t  TTLS phase2: UNDEFINED\n");    
    break;
  }
  if (ttls->phase2) dump_config_ttls_phase2(ttls->phase2);
  printf("\t------------------------------------\n");
}

int check_config_eap_ttls(struct config_eap_ttls *tmp_ttls)
{
  int errno = 0;
  
  if (tmp_ttls->phase2_type == TTLS_PHASE2_UNDEFINED || !tmp_ttls->phase2) {
    printf("No phase2 defined for ttls\n");
    errno = -1;
  }
  
  if (!config_ttls_phase2_contains_phase2(tmp_ttls->phase2, 
					  tmp_ttls->phase2_type)) {
    printf("Phase2 type chosen, but not defined.\n");
    errno = -1;      
  }
  return errno;
}

  /*******************/
 /* CONFIG_LEAP     */
/*******************/
void delete_config_eap_leap(struct config_eap_leap **tmp_leap)
{
  if (*tmp_leap == NULL)
    return;

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

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

void initialize_config_eap_leap(struct config_eap_leap **tmp_leap)
{
  if (*tmp_leap != NULL) {
    delete_config_eap_leap(tmp_leap);
  }
  *tmp_leap = 
    (struct config_eap_leap *)malloc(sizeof(struct config_eap_leap));  
  if (*tmp_leap)
    memset(*tmp_leap, 0, sizeof(struct config_eap_leap));
}

void dump_config_eap_leap(struct config_eap_leap *leap)
{
  if (!leap)
    return;
  printf("\t---------------eap-leap--------------\n");
  printf("\t  LEAP User: \"%s\"\n", leap->username);
  printf("\t  LEAP Pass: \"%s\"\n", leap->password);
  printf("\t------------------------------------\n");
}

  /*******************/
 /* CONFIG_MSCHAPV2 */
/*******************/
void delete_config_eap_mschapv2(struct config_eap_mschapv2 **tmp_mschapv2)
{
  if (*tmp_mschapv2 == NULL)
    return;

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

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

void initialize_config_eap_mschapv2(struct config_eap_mschapv2 **tmp_mschapv2)
{
  if (*tmp_mschapv2 != NULL) {
    delete_config_eap_mschapv2(tmp_mschapv2);
  }
  *tmp_mschapv2 = 
    (struct config_eap_mschapv2 *)malloc(sizeof(struct config_eap_mschapv2));  
  if (*tmp_mschapv2)
    memset(*tmp_mschapv2, 0, sizeof(struct config_eap_mschapv2));
}

void dump_config_eap_mschapv2(struct config_eap_mschapv2 *mschapv2, int level)
{
  if (!mschapv2)
    return;
  if (level == 0) {
    printf("\t---------------eap-mschapv2--------------\n");
    printf("\t  MSCHAPV2 User      : \"%s\"\n", mschapv2->username);
    printf("\t  MSCHAPV2 Pass      : \"%s\"\n", mschapv2->password);
    printf("\t  MSCHAPV2 NtPwd Hash: \"%s\"\n", mschapv2->nthash);
    printf("\t------------------------------------\n");
  }else {
  printf("\t\t^ ^ ^  eap-mschapv2  ^ ^ ^\n");
    printf("\t\t  MSCHAPV2 User      : \"%s\"\n", mschapv2->username);
    printf("\t\t  MSCHAPV2 Pass      : \"%s\"\n", mschapv2->password);
    printf("\t\t  MSCHAPV2 NtPwd Hash: \"%s\"\n", mschapv2->nthash);
  printf("\t\t^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^\n");
  }

}


  /*******************/
 /* CONFIG_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)->root_cert);
  FREE_STRING((*tmp_peap)->root_dir);
  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);
  if ((*tmp_peap)->phase2)
    delete_config_eap_method(&(*tmp_peap)->phase2);

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

void initialize_config_eap_peap(struct config_eap_peap **tmp_peap)
{
  if (*tmp_peap != NULL) {
    delete_config_eap_peap(tmp_peap);
  }
  *tmp_peap = 
    (struct config_eap_peap *)malloc(sizeof(struct config_eap_peap));  
  if (*tmp_peap)
    {
      memset(*tmp_peap, 0, sizeof(struct config_eap_peap));
    }
}

void dump_config_eap_peap(struct config_eap_peap *peap)
{
  if (!peap)
    return;
  printf("\t---------------eap-peap--------------\n");
  printf("\t  PEAP phase2 identity: \"%s\"\n", peap->identity);
  printf("\t  PEAP Cert: \"%s\"\n", peap->user_cert);
  printf("\t  PEAP Root Cert: \"%s\"\n", peap->root_cert);
  printf("\t  PEAP Root Dir: \"%s\"\n", peap->root_dir);
  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  Broken PEAPv1 Keying : ");
  switch (peap->proper_peapv1)
    {
    case 0:
      printf("NO\n");
      break;
    case 1:
      printf("YES\n");
      break;
    }
  printf("\t  PEAP IAS_QUIRK: \"%s\"\n", peap->ias_quirk ? "Yes" : "No");
    
  if (TEST_FLAG(peap->flags, CONFIG_PEAP_ALLOW_MSCV2))
    printf("\t   Allow Phase 2 Type: MSCHAPv2\n");
  if (TEST_FLAG(peap->flags, CONFIG_PEAP_ALLOW_MD5))
    printf("\t   Allow Phase 2 Type: MD5\n");
  if (TEST_FLAG(peap->flags, CONFIG_PEAP_ALLOW_SIM))
    printf("\t   Allow Phase 2 Type: SIM\n");
  if (TEST_FLAG(peap->flags, CONFIG_PEAP_ALLOW_GTC))
    printf("\t   Allow Phase 2 Type: GTC\n");
  if (TEST_FLAG(peap->flags, CONFIG_PEAP_ALLOW_OTP))
    printf("\t   Allow Phase 2 Type: OTP\n");
  if (peap->phase2) dump_config_eap_method(peap->phase2, 1);
  printf("\t------------------------------------\n");
}


  /*******************/
 /* CONFIG_SIM      */
/*******************/
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;
}

void initialize_config_eap_sim(struct config_eap_sim **tmp_sim)
{
  if (*tmp_sim != NULL) {
    delete_config_eap_sim(tmp_sim);
  }
  *tmp_sim = 
    (struct config_eap_sim *)malloc(sizeof(struct config_eap_sim));  
  if (*tmp_sim)
    memset(*tmp_sim, 0, sizeof(struct config_eap_sim));
}

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      */
/*******************/
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;
}

void initialize_config_eap_aka(struct config_eap_aka **tmp_aka)
{
  if (*tmp_aka != NULL) {
    delete_config_eap_aka(tmp_aka);
  }
  *tmp_aka = 
    (struct config_eap_aka *)malloc(sizeof(struct config_eap_aka));  
  if (*tmp_aka)
    memset(*tmp_aka, 0, sizeof(struct config_eap_aka));
}

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 */
/*********************/

// Be SURE to call config_eap_method_contains_method BEFORE adding.
// no such check will be done here.
void add_config_eap_method(struct config_eap_method **method,
			   int method_num, void *method_data)
{
  struct config_eap_method *tmp, *newmethod;

  if (!method_data)
    return;

  newmethod = 
    (struct config_eap_method *)malloc(sizeof(struct config_eap_method));
  if (newmethod == NULL)
    return;
  memset(newmethod, 0, sizeof(struct config_eap_method));
  newmethod->method_num = method_num;
  newmethod->method_data = method_data;
  
  if (*method == NULL) {
    *method = newmethod;
    return;
  }

  tmp = *method;

  while (tmp->next != NULL) {
    tmp = tmp->next;
  }
  tmp->next = newmethod;
}

void delete_config_eap_method(struct config_eap_method **method)
{
  struct config_eap_method *temp;

  if (*method == NULL)
    return;
  switch ((*method)->method_num) {
  case STATIC_WEP_METHOD:
    delete_config_static_wep((struct config_static_wep **)&((*method)->method_data));
    break;
  case WPA_PSK:
    delete_config_wpa_psk((struct config_wpa_psk **)&((*method)->method_data));
    break;
  case EAP_TYPE_TLS:
    delete_config_eap_tls((struct config_eap_tls **)&((*method)->method_data));
    break;
  case EAP_TYPE_MD5:
    delete_config_eap_md5((struct config_eap_md5 **)&(*method)->method_data);
    break;
  case EAP_TYPE_PEAP:
    delete_config_eap_peap((struct config_eap_peap **)&(*method)->method_data);
    break;

#ifdef EAP_SIM_ENABLE
  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;
#endif

  case EAP_TYPE_TTLS:
    delete_config_eap_ttls((struct config_eap_ttls **)&(*method)->method_data);
    break; 
  case EAP_TYPE_LEAP:
    delete_config_eap_leap((struct config_eap_leap **)&(*method)->method_data);
    break;
  case EAP_TYPE_MSCHAPV2:
    delete_config_eap_mschapv2((struct config_eap_mschapv2 **)&(*method)->method_data);
    break;
    
  default:
    printf("AAAH! Trying to delete an undefined config"
	   " type.\nNotify developers. Type: 0x%x\n", 
	   (*method)->method_num);
  }

  temp = (*method)->next;
  free((*method));

  if (temp)
    delete_config_eap_method(&temp);
  
}

void dump_config_eap_method(struct config_eap_method *method, int dumplevel)
{
  if (method == NULL)
    return;

  switch ((method)->method_num) {
  case STATIC_WEP_METHOD:
    dump_config_static_wep((struct config_static_wep *)((method)->method_data),
			   FALSE);
    break;
  case WPA_PSK:
    dump_config_wpa_psk((struct config_wpa_psk *)((method)->method_data));
    break;
  case EAP_TYPE_TLS:
    dump_config_eap_tls((struct config_eap_tls *)((method)->method_data));
    break;
  case EAP_TYPE_MD5:
    dump_config_eap_md5((struct config_eap_md5 *)(method)->method_data, 
			dumplevel);
    break;
  case EAP_TYPE_PEAP:
    dump_config_eap_peap((struct config_eap_peap *)(method)->method_data);
    break;

#ifdef EAP_SIM_ENABLE
  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;
#endif

  case EAP_TYPE_TTLS:
    dump_config_eap_ttls((struct config_eap_ttls *)(method)->method_data);
    break; 
  case EAP_TYPE_LEAP:
    dump_config_eap_leap((struct config_eap_leap *)(method)->method_data);
  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\n.Notify developers. Type: 0x%x\n", 
	   (method)->method_num);
  }

  dump_config_eap_method(method->next, dumplevel);
}

int config_eap_method_contains_method(struct config_eap_method *method,
				      int new_num)
{
  struct config_eap_method *tmp;

  if (!method)