LCOV - code coverage report
Current view: top level - src/eap_server - eap_server_identity.c (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1475438200 Lines: 70 79 88.6 %
Date: 2016-10-02 Functions: 9 9 100.0 %

          Line data    Source code
       1             : /*
       2             :  * hostapd / EAP-Identity
       3             :  * Copyright (c) 2004-2006, Jouni Malinen <j@w1.fi>
       4             :  *
       5             :  * This software may be distributed under the terms of the BSD license.
       6             :  * See README for more details.
       7             :  */
       8             : 
       9             : #include "includes.h"
      10             : 
      11             : #include "common.h"
      12             : #include "eap_i.h"
      13             : 
      14             : 
      15             : struct eap_identity_data {
      16             :         enum { CONTINUE, SUCCESS, FAILURE } state;
      17             :         int pick_up;
      18             : };
      19             : 
      20             : 
      21        4756 : static void * eap_identity_init(struct eap_sm *sm)
      22             : {
      23             :         struct eap_identity_data *data;
      24             : 
      25        4756 :         data = os_zalloc(sizeof(*data));
      26        4756 :         if (data == NULL)
      27           2 :                 return NULL;
      28        4754 :         data->state = CONTINUE;
      29             : 
      30        4754 :         return data;
      31             : }
      32             : 
      33             : 
      34        1640 : static void * eap_identity_initPickUp(struct eap_sm *sm)
      35             : {
      36             :         struct eap_identity_data *data;
      37        1640 :         data = eap_identity_init(sm);
      38        1640 :         if (data) {
      39        1640 :                 data->pick_up = 1;
      40             :         }
      41        1640 :         return data;
      42             : }
      43             : 
      44             : 
      45        4754 : static void eap_identity_reset(struct eap_sm *sm, void *priv)
      46             : {
      47        4754 :         struct eap_identity_data *data = priv;
      48        4754 :         os_free(data);
      49        4754 : }
      50             : 
      51             : 
      52        3075 : static struct wpabuf * eap_identity_buildReq(struct eap_sm *sm, void *priv,
      53             :                                              u8 id)
      54             : {
      55        3075 :         struct eap_identity_data *data = priv;
      56             :         struct wpabuf *req;
      57             :         const char *req_data;
      58             :         size_t req_data_len;
      59             : 
      60        3075 :         if (sm->eapol_cb->get_eap_req_id_text) {
      61        3075 :                 req_data = sm->eapol_cb->get_eap_req_id_text(sm->eapol_ctx,
      62             :                                                              &req_data_len);
      63             :         } else {
      64           0 :                 req_data = NULL;
      65           0 :                 req_data_len = 0;
      66             :         }
      67        3075 :         req = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_IDENTITY, req_data_len,
      68             :                             EAP_CODE_REQUEST, id);
      69        3075 :         if (req == NULL) {
      70           2 :                 wpa_printf(MSG_ERROR, "EAP-Identity: Failed to allocate "
      71             :                            "memory for request");
      72           2 :                 data->state = FAILURE;
      73           2 :                 return NULL;
      74             :         }
      75             : 
      76        3073 :         wpabuf_put_data(req, req_data, req_data_len);
      77             : 
      78        3073 :         return req;
      79             : }
      80             : 
      81             : 
      82        4711 : static Boolean eap_identity_check(struct eap_sm *sm, void *priv,
      83             :                                   struct wpabuf *respData)
      84             : {
      85             :         const u8 *pos;
      86             :         size_t len;
      87             : 
      88        4711 :         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_IDENTITY,
      89             :                                respData, &len);
      90        4711 :         if (pos == NULL) {
      91           0 :                 wpa_printf(MSG_INFO, "EAP-Identity: Invalid frame");
      92           0 :                 return TRUE;
      93             :         }
      94             : 
      95        4711 :         return FALSE;
      96             : }
      97             : 
      98             : 
      99        4711 : static void eap_identity_process(struct eap_sm *sm, void *priv,
     100             :                                  struct wpabuf *respData)
     101             : {
     102        4711 :         struct eap_identity_data *data = priv;
     103             :         const u8 *pos;
     104             :         size_t len;
     105             :         char *buf;
     106             : 
     107        4711 :         if (data->pick_up) {
     108        1640 :                 if (eap_identity_check(sm, data, respData)) {
     109           0 :                         wpa_printf(MSG_DEBUG, "EAP-Identity: failed to pick "
     110             :                                    "up already started negotiation");
     111           0 :                         data->state = FAILURE;
     112           0 :                         return;
     113             :                 }
     114        1640 :                 data->pick_up = 0;
     115             :         }
     116             : 
     117        4711 :         pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_IDENTITY,
     118             :                                respData, &len);
     119        4711 :         if (pos == NULL)
     120           0 :                 return; /* Should not happen - frame already validated */
     121             : 
     122        4711 :         wpa_hexdump_ascii(MSG_DEBUG, "EAP-Identity: Peer identity", pos, len);
     123        4711 :         buf = os_malloc(len * 4 + 1);
     124        4711 :         if (buf) {
     125        4709 :                 printf_encode(buf, len * 4 + 1, pos, len);
     126        4709 :                 eap_log_msg(sm, "EAP-Response/Identity '%s'", buf);
     127        4709 :                 os_free(buf);
     128             :         }
     129        4711 :         if (sm->identity)
     130         237 :                 sm->update_user = TRUE;
     131        4711 :         os_free(sm->identity);
     132        4711 :         sm->identity = os_malloc(len ? len : 1);
     133        4711 :         if (sm->identity == NULL) {
     134           3 :                 data->state = FAILURE;
     135             :         } else {
     136        4708 :                 os_memcpy(sm->identity, pos, len);
     137        4708 :                 sm->identity_len = len;
     138        4708 :                 data->state = SUCCESS;
     139             :         }
     140             : }
     141             : 
     142             : 
     143        7192 : static Boolean eap_identity_isDone(struct eap_sm *sm, void *priv)
     144             : {
     145        7192 :         struct eap_identity_data *data = priv;
     146        7192 :         return data->state != CONTINUE;
     147             : }
     148             : 
     149             : 
     150        2648 : static Boolean eap_identity_isSuccess(struct eap_sm *sm, void *priv)
     151             : {
     152        2648 :         struct eap_identity_data *data = priv;
     153        2648 :         return data->state == SUCCESS;
     154             : }
     155             : 
     156             : 
     157          74 : int eap_server_identity_register(void)
     158             : {
     159             :         struct eap_method *eap;
     160             : 
     161          74 :         eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
     162             :                                       EAP_VENDOR_IETF, EAP_TYPE_IDENTITY,
     163             :                                       "Identity");
     164          74 :         if (eap == NULL)
     165           0 :                 return -1;
     166             : 
     167          74 :         eap->init = eap_identity_init;
     168          74 :         eap->initPickUp = eap_identity_initPickUp;
     169          74 :         eap->reset = eap_identity_reset;
     170          74 :         eap->buildReq = eap_identity_buildReq;
     171          74 :         eap->check = eap_identity_check;
     172          74 :         eap->process = eap_identity_process;
     173          74 :         eap->isDone = eap_identity_isDone;
     174          74 :         eap->isSuccess = eap_identity_isSuccess;
     175             : 
     176          74 :         return eap_server_method_register(eap);
     177             : }

Generated by: LCOV version 1.10