Add qmi_proxy compatible with O
Change-Id: Iad3877f3f8766fd6b2e8dc19f5fac8093d34ee17
diff --git a/src/eap_peer/eap_proxy_qmi_oc.c b/src/eap_peer/eap_proxy_qmi_oc.c
new file mode 100644
index 0000000..4c07da5
--- /dev/null
+++ b/src/eap_peer/eap_proxy_qmi_oc.c
@@ -0,0 +1,2300 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2013, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of The Linux Foundation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+
+#include "includes.h"
+#include "common.h"
+
+#ifdef CONFIG_EAP_PROXY
+#include "qmi_client.h"
+#include "eap_proxy_qmi.h"
+#include "qmi_client.h"
+#include "qmi_idl_lib.h"
+#include "authentication_service_v01.h"
+#include "user_identity_module_v01.h"
+#include "eap_config.h"
+#include "common/wpa_ctrl.h"
+#if defined(ANDROID)
+#include <cutils/properties.h>
+#ifdef CONFIG_EAP_PROXY_MDM_DETECT
+#include "mdm_detect.h"
+#endif /* CONFIG_EAP_PROXY_MDM_DETECT */
+#if defined(__BIONIC_FORTIFY)
+#include <sys/system_properties.h>
+#endif
+#endif
+#include <pthread.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+
+#define IMSI_LENGTH 15
+#define WPA_UIM_QMI_EVENT_MASK_CARD_STATUS \
+ (1 << QMI_UIM_EVENT_CARD_STATUS_BIT_V01)
+#define WPA_UIM_QMI_EVENT_READ_TRANSPARENT_REQ \
+ (1 << QMI_UIM_READ_TRANSPARENT_REQ_V01)
+
+/* Default timeout (in milli-seconds) for synchronous QMI message */
+#define WPA_UIM_QMI_DEFAULT_TIMEOUT 5000
+
+#define EAP_PROXY_PROPERTY_BASEBAND "ro.baseband"
+#ifdef CONFIG_EAP_PROXY_MSM8994_TARGET
+#define EAP_PROXY_TARGET_PLATFORM "ro.board.platform"
+#endif /* CONFIG_EAP_PROXY_MSM8994_TARGET */
+#if defined(__BIONIC_FORTIFY)
+#define EAP_PROXY_PROPERTY_BASEBAND_SIZE PROP_VALUE_MAX
+#else
+#define EAP_PROXY_PROPERTY_BASEBAND_SIZE 10
+#endif
+#define EAP_PROXY_BASEBAND_VALUE_MSM "msm"
+#define EAP_PROXY_BASEBAND_VALUE_APQ "apq"
+#define EAP_PROXY_BASEBAND_VALUE_SVLTE1 "svlte1"
+#define EAP_PROXY_BASEBAND_VALUE_SVLTE2A "svlte2a"
+#define EAP_PROXY_BASEBAND_VALUE_SGLTE "sglte"
+#define EAP_PROXY_BASEBAND_VALUE_CSFB "csfb"
+#define EAP_PROXY_BASEBAND_VALUE_MDMUSB "mdm"
+#ifdef CONFIG_EAP_PROXY_MSM8994_TARGET
+#define EAP_PROXY_TARGET_PLATFORM_MSM8994 "msm8994"
+#endif /* CONFIG_EAP_PROXY_MSM8994_TARGET */
+#define EAP_PROXY_TARGET_FUSION4_5_PCIE "fusion4_5_pcie"
+#define EAP_PROXY_BASEBAND_VALUE_UNDEFINED "undefined"
+
+#ifndef ANDROID
+#ifdef SYS_gettid
+static inline pid_t gettid(void)
+{
+ return syscall(SYS_gettid);
+}
+#else
+static inline pid_t gettid(void)
+{
+ return -1;
+}
+#endif
+#endif
+
+static Boolean wpa_qmi_ssr = FALSE;
+static void eap_proxy_qmi_deinit(struct eap_proxy_sm *eap_proxy);
+static void eap_proxy_eapol_sm_set_bool(struct eap_proxy_sm *sm,
+ enum eapol_bool_var var, Boolean value);
+struct eap_proxy_sm *
+eap_proxy_init(void *eapol_ctx, const struct eapol_callbacks *eapol_cb,
+ void *msg_ctx);
+static Boolean eap_proxy_eapol_sm_get_bool(struct eap_proxy_sm *sm,
+ enum eapol_bool_var var);
+
+/* Call-back function to process an authenticationr result indication from
+ * QMI EAP service */
+static void handle_qmi_eap_ind(qmi_client_type user_handle,
+ unsigned int msg_id,
+ void* ind_buf,
+ unsigned int ind_buf_len,
+ void* ind_cb_data);
+
+static u8 *eap_proxy_getKey(struct eap_proxy_sm *eap_proxy);
+static enum eap_proxy_status eap_proxy_qmi_response_wait(struct eap_proxy_sm *eap_proxy);
+static int eap_proxy_is_state_changed(struct eap_proxy_sm *sm);
+static enum eap_proxy_status eap_proxy_process(struct eap_proxy_sm *eap_proxy,
+ u8 *eapReqData, int eapReqDataLen, struct eap_sm *eap_sm);
+static char bin_to_hexchar(u8 ch);
+
+static void wpa_qmi_client_indication_cb
+(
+ qmi_client_type user_handle,
+ unsigned long msg_id,
+ unsigned char *ind_buf_ptr,
+ int ind_buf_len,
+ void *ind_cb_data
+);
+static void dump_buff(u8 *buff, int len);
+#ifdef CONFIG_CTRL_IFACE
+static const char *eap_proxy_sm_state_txt(int state);
+#endif /* CONFIG_CTRL_IFACE */
+static Boolean eap_proxy_build_identity(struct eap_proxy_sm *eap_proxy, u8 id,
+ struct eap_sm *eap_sm);
+
+#ifdef SIM_AKA_IDENTITY_IMSI
+static char *imsi;
+static int imsi_len_g = 0;
+static int card_mnc_len = -1;
+#ifdef CONFIG_EAP_PROXY_DUAL_SIM
+static unsigned int slot = 0;
+static unsigned int session_type;
+#endif /* CONFIG_EAP_PROXY_DUAL_SIM */
+
+static Boolean wpa_qmi_register_events(int sim_num, wpa_uim_struct_type *wpa_uim);
+static Boolean wpa_qmi_read_card_imsi(int sim_num, wpa_uim_struct_type *wpa_uim);
+static Boolean wpa_qmi_read_card_status(int sim_num, wpa_uim_struct_type *wpa_uim);
+static Boolean wpa_qmi_register_auth_inds(struct eap_proxy_sm *eap_proxy);
+
+#endif
+#define EAP_SUB_TYPE_SIM_START 0x0a
+#define EAP_SUB_TYPE_AKA_IDENTITY 0x05
+#define EAP_RESP_TYPE_NAK 3
+
+
+#ifdef SIM_AKA_IDENTITY_IMSI
+static void wpa_qmi_client_indication_cb
+(
+ qmi_client_type user_handle,
+ unsigned long msg_id,
+ unsigned char *ind_buf_ptr,
+ int ind_buf_len,
+ void *ind_cb_data
+)
+{
+ u32 decoded_payload_len = 0;
+ qmi_client_error_type qmi_err = QMI_NO_ERR;
+ void * decoded_payload = NULL;
+ struct eap_proxy_sm *eap_proxy = ind_cb_data;
+ uim_status_change_ind_msg_v01* status_change_ind_ptr = NULL;
+ struct wpa_supplicant *wpa_s = NULL;
+ u32 i, card_info_len = 0;
+
+ wpa_printf(MSG_DEBUG, "eap_proxy: %s: msg_id=0x%lx", __func__, msg_id);
+
+ if (user_handle == NULL) {
+ wpa_printf(MSG_ERROR, "eap_proxy: qmi_client_type missing in callback");
+ return;
+ }
+
+ if (eap_proxy == NULL) {
+ wpa_printf(MSG_ERROR, "eap_proxy: not initialized, discard client indiataion");
+ return;
+ }
+
+ if (ind_buf_ptr == NULL) {
+ wpa_printf(MSG_ERROR, "eap_proxy: indication buffer NULL, discard client indiataion");
+ return;
+ }
+
+ qmi_idl_get_message_c_struct_len(uim_get_service_object_v01(),
+ QMI_IDL_INDICATION, msg_id,
+ &decoded_payload_len);
+
+ if(!decoded_payload_len) {
+ wpa_printf(MSG_ERROR, "eap_proxy: cann't decode payload, discard client indiataion");
+ return;
+ }
+
+ decoded_payload = os_zalloc(decoded_payload_len);
+ if (decoded_payload == NULL) {
+ wpa_printf(MSG_ERROR, "eap_proxy: failed to allocate memory");
+ return;
+ }
+
+ qmi_err = qmi_client_message_decode(user_handle,
+ QMI_IDL_INDICATION, msg_id,
+ ind_buf_ptr, ind_buf_len,
+ decoded_payload, decoded_payload_len);
+
+ if (qmi_err == QMI_NO_ERR) {
+ switch (msg_id) {
+ case QMI_UIM_STATUS_CHANGE_IND_V01:
+ status_change_ind_ptr = (uim_status_change_ind_msg_v01*)decoded_payload;
+ if (!status_change_ind_ptr->card_status_valid)
+ goto fail;
+
+ card_info_len = status_change_ind_ptr->card_status.card_info_len;
+ for (i = 0; i < card_info_len; i++) {
+ if(UIM_CARD_STATE_PRESENT_V01 !=
+ status_change_ind_ptr->card_status.card_info[i].card_state) {
+ wpa_printf(MSG_DEBUG, "eap_proxy: %s SIM card removed. flush pmksa entries.", __func__);
+ eap_proxy->eapol_cb->eap_proxy_notify_sim_status(eap_proxy->ctx, SIM_STATE_ERROR);
+ break; /* only one flush will do */
+ }
+ }
+ break;
+ default:
+ wpa_printf(MSG_DEBUG, "eap_proxy: Unknown QMI Indicaiton %lu", msg_id);
+ break;
+ }
+ }
+fail:
+ os_free(decoded_payload);
+ return;
+}
+
+static Boolean wpa_qmi_register_auth_inds(struct eap_proxy_sm *eap_proxy)
+{
+ qmi_client_error_type qmi_err_code = 0;
+ auth_indication_register_resp_msg_v01 event_resp_msg;
+ auth_indication_register_req_msg_v01 event_reg_params;
+
+ /* Register for events first */
+ os_memset(&event_reg_params, 0, sizeof(auth_indication_register_req_msg_v01));
+ os_memset(&event_resp_msg, 0, sizeof(auth_indication_register_resp_msg_v01));
+
+ event_reg_params.report_eap_notification_code_valid = TRUE;
+ event_reg_params.report_eap_notification_code = 1;
+
+ wpa_printf(MSG_DEBUG, "registering for notification codes\n");
+ qmi_err_code = qmi_client_send_msg_sync(
+ eap_proxy->qmi_auth_svc_client_ptr[eap_proxy->user_selected_sim],
+ QMI_AUTH_INDICATION_REGISTER_REQ_V01,
+ (void *) &event_reg_params,
+ sizeof(auth_indication_register_req_msg_v01),
+ (void*) &event_resp_msg,
+ sizeof(auth_indication_register_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+
+ if (qmi_err_code != QMI_NO_ERR ||
+ (event_resp_msg.resp.result != QMI_RESULT_SUCCESS_V01 &&
+ event_resp_msg.resp.error != QMI_ERR_NO_EFFECT_V01)) {
+ wpa_printf(MSG_ERROR,"QMI-ERROR Error for "
+ "QMI_AUTH_INDICATION_REGISTER_REQ_V01, qmi_err_code=%d"
+ "Error=%d\n", qmi_err_code,
+ event_resp_msg.resp.error);
+ return FALSE;
+ }
+
+ return TRUE;
+
+}
+
+static Boolean wpa_qmi_register_events(int sim_num, wpa_uim_struct_type *wpa_uim)
+{
+ qmi_client_error_type qmi_err_code = 0;
+ uim_event_reg_resp_msg_v01 event_resp_msg;
+ uim_event_reg_req_msg_v01 event_reg_params;
+
+ /* Register for events first */
+ os_memset(&event_reg_params, 0, sizeof(uim_event_reg_req_msg_v01));
+ os_memset(&event_resp_msg, 0, sizeof(uim_event_reg_resp_msg_v01));
+
+ event_reg_params.event_mask |= (WPA_UIM_QMI_EVENT_MASK_CARD_STATUS);
+ qmi_err_code = qmi_client_send_msg_sync(wpa_uim[sim_num].qmi_uim_svc_client_ptr,
+ QMI_UIM_EVENT_REG_REQ_V01,
+ (void *) &event_reg_params,
+ sizeof(uim_event_reg_req_msg_v01),
+ (void *) &event_resp_msg,
+ sizeof(uim_event_reg_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+
+ wpa_printf(MSG_ERROR, "eap_proxy: QMI_UIM_EVENT_REG_REQ_V01, "
+ "qmi_err_code: 0x%x wpa_uim[%d].qmi_uim_svc_client_ptr =%p"
+ "Error=0x%x", qmi_err_code, sim_num,
+ wpa_uim[sim_num].qmi_uim_svc_client_ptr,
+ event_resp_msg.resp.error);
+
+ if (qmi_err_code != QMI_NO_ERR ||
+ (event_resp_msg.resp.result != QMI_RESULT_SUCCESS_V01 &&
+ event_resp_msg.resp.error != QMI_ERR_NO_EFFECT_V01)) {
+ wpa_printf(MSG_ERROR,"QMI-ERROR Error for "
+ "QMI_UIM_EVENT_REG_REQ_V01, qmi_err_code=%d"
+ "Error=%d\n", qmi_err_code,
+ event_resp_msg.resp.error);
+ return FALSE;
+ }
+
+ if(event_resp_msg.event_mask_valid)
+ {
+ wpa_printf(MSG_ERROR, "eap_proxy: event_resp_msg.event=%d,\n",
+ event_resp_msg.event_mask);
+
+ }
+
+ if (wpa_qmi_read_card_status(sim_num, wpa_uim))
+ return TRUE;
+ else {
+ wpa_printf(MSG_ERROR,"eap_proxy: Error while reading SIM card status\n");
+ return FALSE;
+ }
+}
+
+static Boolean wpa_qmi_read_card_status(int sim_num, wpa_uim_struct_type *wpa_uim)
+{
+ unsigned int i = 0, j = 0;
+ Boolean card_found = FALSE;
+ qmi_client_error_type qmi_err_code = 0;
+ uim_get_card_status_resp_msg_v01 card_status_resp_msg;
+
+ wpa_printf (MSG_ERROR, "eap_proxy: reading card %d values\n", sim_num+1);
+ os_memset(&card_status_resp_msg,
+ 0,
+ sizeof(uim_get_card_status_resp_msg_v01));
+ qmi_err_code = qmi_client_send_msg_sync(wpa_uim[sim_num].qmi_uim_svc_client_ptr,
+ QMI_UIM_GET_CARD_STATUS_REQ_V01,
+ NULL,
+ 0,
+ (void *)&card_status_resp_msg,
+ sizeof(uim_get_card_status_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+
+ if (qmi_err_code != QMI_NO_ERR ||
+ card_status_resp_msg.resp.result != QMI_RESULT_SUCCESS_V01) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Error for "
+ "QMI_UIM_GET_CARD_STATUS_REQ_V01, qmi_err_code: 0x%x\n "
+ "resp_err = %d \n", qmi_err_code, card_status_resp_msg.resp.error);
+ return FALSE;
+ }
+
+ /* Updated global card status if needed */
+ if (!card_status_resp_msg.card_status_valid ||
+ (card_status_resp_msg.resp.result != QMI_RESULT_SUCCESS_V01)) {
+ wpa_printf(MSG_ERROR, "eap_proxy: card_status is not valid !\n");
+ return FALSE;
+ }
+ /* Update global in case of new card state or error code */
+ i = sim_num;
+ if ( i < QMI_UIM_CARDS_MAX_V01 &&
+ i < card_status_resp_msg.card_status.card_info_len ) {
+ wpa_printf(MSG_ERROR, "eap_proxy: card_info[i].card_state: 0x%x\n",
+ card_status_resp_msg.card_status.card_info[i].card_state);
+ wpa_printf(MSG_ERROR, "eap_proxy: card_info[i].error_code: 0x%x\n",
+ card_status_resp_msg.card_status.card_info[i].error_code);
+
+ wpa_uim[sim_num].card_info[i].card_state =
+ card_status_resp_msg.card_status.card_info[i].card_state;
+
+ wpa_uim[sim_num].card_info[i].card_error_code =
+ card_status_resp_msg.card_status.card_info[i].error_code;
+#ifdef CONFIG_EAP_PROXY_DUAL_SIM
+ do {
+ if (card_status_resp_msg.card_status.index_gw_pri != 0xFFFF) {
+ slot = (card_status_resp_msg.card_status.index_gw_pri & 0xFF00) >> 8;
+ if (slot == i) {
+ session_type = UIM_SESSION_TYPE_PRIMARY_GW_V01;
+ wpa_printf (MSG_ERROR, "eap_proxy: read_card_status:"
+ " prime slot = %d\n", slot);
+ break;
+ }
+ }
+ if (card_status_resp_msg.card_status.index_gw_sec != 0xFFFF) {
+ slot = (card_status_resp_msg.card_status.index_gw_sec & 0xFF00) >> 8;
+ if (slot == i) {
+ session_type = UIM_SESSION_TYPE_SECONDARY_GW_V01;
+ wpa_printf (MSG_ERROR, "eap_proxy: read_card_status: "
+ "second slot = %d\n", slot);
+ break;
+ }
+ }
+ wpa_printf (MSG_ERROR, "eap_proxy: read_card_status: Not GW it's 1x\n");
+ return FALSE;
+ }while(0);
+
+ if (slot > 1){
+ wpa_printf (MSG_ERROR, "eap_proxy: read_card_status: "
+ "INVALID slot = %d and i = %d\n", slot, i);
+ return FALSE;
+ }
+#endif /* CONFIG_EAP_PROXY_DUAL_SIM */
+
+ if (card_status_resp_msg.card_status.card_info[i].card_state ==
+ UIM_CARD_STATE_PRESENT_V01) {
+ for (j = 0 ; j < QMI_UIM_APPS_MAX_V01 ; j++) {
+ wpa_uim[sim_num].card_info[i].app_type = card_status_resp_msg.
+ card_status.card_info[i].app_info[j].app_type;
+
+ wpa_uim[sim_num].card_info[i].app_state = card_status_resp_msg.
+ card_status.card_info[i].app_info[j].app_state;
+
+ if (((card_status_resp_msg.card_status.card_info[i].
+ app_info[j].app_type == 1) || (card_status_resp_msg.
+ card_status.card_info[i].app_info[j].app_type == 2)) &&
+ (card_status_resp_msg.card_status.card_info[i].app_info[j].
+ app_state == UIM_APP_STATE_READY_V01)) {
+ wpa_printf(MSG_ERROR, "eap_proxy: card READY\n");
+ wpa_printf(MSG_ERROR, "eap_proxy: card_info[i].app_ty"
+ "pe: 0x%x\n", card_status_resp_msg.card_status.
+ card_info[i].app_info[j].app_type);
+ wpa_printf(MSG_ERROR, "eap_proxy: card_info[i].app_sta"
+ "te : 0x%x\n", card_status_resp_msg.card_status
+ .card_info[i].app_info[j].app_state);
+ card_found = TRUE;
+ break;
+ }
+ }
+ }
+
+ if (card_found) {
+ wpa_printf(MSG_ERROR, "eap_proxy: card found for SIM = %d\n", sim_num+1);
+ }
+ }
+
+ if ((!card_found) || (i == QMI_UIM_CARDS_MAX_V01) ||
+ (j == QMI_UIM_APPS_MAX_V01)) {
+ wpa_printf(MSG_ERROR, "eap_proxy: SIM/USIM not ready card_found=%d\n",card_found);
+ return FALSE;
+ }
+
+ wpa_printf(MSG_ERROR, "eap_proxy: SIM/USIM ready\n");
+ wpa_uim[sim_num].card_ready_idx = i;
+
+ return TRUE;
+} /* wpa_qmi_read_card_status */
+
+static int check_for_3_digit()
+{
+ int mcc = 0,i =0;
+ /*
+ -- 3 digits if MCC belongs to this group: 302, 310, 311, 312, 313, 314, 315,
+ 316, 334, 348 (decimal)
+ -- 2 digits in all other cases
+ Note: imsi values are hex characters
+ */
+ int valid_mcc[] = {302, 310, 311, 312, 313, 314, 315, 316, 334, 348};
+
+ mcc = ((imsi[0]-0x30)*100) + ((imsi[1]-0x30)*10) + (imsi[2]-0x30);
+
+ wpa_printf(MSG_ERROR, "mcc from the SIM is %d\n", mcc);
+ for(i = 0; i < sizeof(valid_mcc)/sizeof(valid_mcc[0]); i++)
+ {
+ if(mcc == valid_mcc[i])
+ return 1;
+ }
+ return 0;
+}
+
+static Boolean wpa_qmi_read_card_imsi(int sim_num, wpa_uim_struct_type *wpa_uim)
+{
+ int length;
+ unsigned char *data;
+ int src = 0, dst = 0;
+ Boolean card_found = FALSE,
+ qmi_status = TRUE;
+ qmi_client_error_type qmi_err_code = 0;
+ uim_read_transparent_req_msg_v01 qmi_read_trans_req;
+ uim_read_transparent_resp_msg_v01 read_trans_resp;
+ card_mnc_len = -1;
+
+
+ os_memset(&read_trans_resp, 0,
+ sizeof(uim_read_transparent_resp_msg_v01));
+ os_memset(&qmi_read_trans_req, 0,
+ sizeof(uim_read_transparent_req_msg_v01));
+
+ qmi_read_trans_req.read_transparent.length = 0;
+ qmi_read_trans_req.read_transparent.offset = 0;
+ qmi_read_trans_req.file_id.file_id = 0x6F07;
+ qmi_read_trans_req.file_id.path_len = 4;
+
+#ifdef CONFIG_EAP_PROXY_DUAL_SIM
+ wpa_printf (MSG_ERROR, "eap_proxy: read_card_imsi: session_type = %d\n", session_type);
+ qmi_read_trans_req.session_information.session_type = session_type;
+#else
+ qmi_read_trans_req.session_information.session_type =
+ UIM_SESSION_TYPE_PRIMARY_GW_V01;
+#endif /* CONFIG_EAP_PROXY_DUAL_SIM */
+ qmi_read_trans_req.session_information.aid_len = 0;
+
+ /* For USIM*/
+ if ((wpa_uim[sim_num].card_info[wpa_uim[sim_num].card_ready_idx].app_type ==
+ UIM_APP_TYPE_USIM_V01)) {
+ qmi_read_trans_req.file_id.path[0] = 0x00;
+ qmi_read_trans_req.file_id.path[1] = 0x3F;
+ qmi_read_trans_req.file_id.path[2] = 0xFF;
+ qmi_read_trans_req.file_id.path[3] = 0x7F;
+
+ } else /* For SIM*/
+ if ((wpa_uim[sim_num].card_info[wpa_uim[sim_num].card_ready_idx].app_type ==
+ UIM_APP_TYPE_SIM_V01)) {
+ qmi_read_trans_req.file_id.path[0] = 0x00;
+ qmi_read_trans_req.file_id.path[1] = 0x3F;
+ qmi_read_trans_req.file_id.path[2] = 0x20;
+ qmi_read_trans_req.file_id.path[3] = 0x7F;
+ }
+ else {
+ return FALSE;
+ }
+
+ qmi_err_code = qmi_client_send_msg_sync(wpa_uim[sim_num].qmi_uim_svc_client_ptr,
+ QMI_UIM_READ_TRANSPARENT_REQ_V01,
+ (void *)&qmi_read_trans_req,
+ sizeof(uim_read_transparent_req_msg_v01),
+ (void *) &read_trans_resp,
+ sizeof(uim_read_transparent_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+ if (QMI_NO_ERR != qmi_err_code ||
+ read_trans_resp.resp.result != QMI_RESULT_SUCCESS_V01) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Unable to read IMSI from UIM service;"
+ " error_ret=%d; qmi_err=%d\n", qmi_err_code,
+ read_trans_resp.resp.error);
+ qmi_status = FALSE;
+ }
+
+ if (QMI_NO_ERR == qmi_err_code) {
+ if (read_trans_resp.read_result_valid) {
+ length =
+ read_trans_resp.read_result.content_len;
+ data =
+ read_trans_resp.read_result.content;
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: IMSI SIM content length = %d\n",
+ length);
+
+ /* Received IMSI is in the 3GPP format
+ converting it into ascii string */
+ imsi = os_zalloc(2 * length);
+ if (imsi == NULL) {
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: Couldn't allocate memmory for imsi");
+ return FALSE;
+ }
+ for (src = 1, dst = 0;
+ (src < length) && (dst < (length * 2));
+ src++) {
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: IMSI read from SIM = %d src %d\n",
+ data[src], src);
+ if(data[src] == 0xFF) {
+ break;
+ }
+ if (src > 1) {
+ imsi[dst] = bin_to_hexchar(data[src] & 0x0F);
+ dst++;
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: IMSI dst = %d dst %d\n",
+ imsi[dst-1], dst);
+ }
+ /* Process upper part of byte for all bytes */
+ imsi[dst] = bin_to_hexchar(data[src] >> 4);
+ dst++;
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: IMSI dst = %d dst %d\n",
+ imsi[dst-1], dst);
+ }
+ imsi_len_g = (data[0]*2 - 1); //dst;
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: IMSI first digit = %d read length = %d"
+ "imsi %20s\n", data[0],imsi_len_g, imsi);
+ } else{
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: IMSI read failure read_result_valid = %d\n",
+ read_trans_resp.read_result_valid);
+ qmi_status = FALSE;
+ }
+ }
+ /* READ EF_AD */
+ /* if qmi_status is FALSE, UIM read for mnc may not be required - To Do */
+ qmi_read_trans_req.file_id.file_id = 0x6FAD;
+ qmi_err_code = qmi_client_send_msg_sync(wpa_uim[sim_num].qmi_uim_svc_client_ptr,
+ QMI_UIM_READ_TRANSPARENT_REQ_V01,
+ (void *)&qmi_read_trans_req,
+ sizeof(uim_read_transparent_req_msg_v01),
+ (void *)&read_trans_resp,
+ sizeof(uim_read_transparent_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+ if (QMI_NO_ERR != qmi_err_code ||
+ read_trans_resp.resp.result != QMI_RESULT_SUCCESS_V01) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Unable to read MNC from UIM service;"
+ " error_ret=%d; qmi_err=%d\n", qmi_err_code,
+ read_trans_resp.resp.error);
+ qmi_status = FALSE;
+ }
+ if (QMI_NO_ERR == qmi_err_code) {
+ if (read_trans_resp.read_result_valid) {
+ length =
+ read_trans_resp.read_result.content_len;
+ data =
+ read_trans_resp.read_result.content;
+
+ if(length >= 4)
+ card_mnc_len = 0x0f & data[3];
+ if ((card_mnc_len != 2) && (card_mnc_len != 3)) {
+ if(check_for_3_digit())
+ card_mnc_len = 3;
+ else
+ card_mnc_len = 2;
+ wpa_printf(MSG_ERROR, "Failed to get MNC length from (U)SIM "
+ "assuming %d as mcc %s to 3 digit mnc group\n",
+ card_mnc_len, card_mnc_len == 3? "belongs":"not belongs");
+ }
+ }
+ }
+
+
+ return qmi_status;
+} /* wpa_qmi_read_card_imsi */
+#endif /* SIM_AKA_IDENTITY_IMSI */
+
+#ifdef CONFIG_EAP_PROXY_MDM_DETECT
+static int eap_modem_compatible(struct dev_info *mdm_detect_info)
+{
+ char args[EAP_PROXY_PROPERTY_BASEBAND_SIZE] = {0};
+ int ret = 0;
+
+ /* Get the hardware property */
+ ret = property_get(EAP_PROXY_PROPERTY_BASEBAND, args, "");
+ if (ret > EAP_PROXY_PROPERTY_BASEBAND_SIZE){
+ wpa_printf(MSG_ERROR,"eap_proxy: property [%s] has size [%d] that exceeds max [%d]",
+ EAP_PROXY_PROPERTY_BASEBAND,
+ ret,
+ EAP_PROXY_PROPERTY_BASEBAND_SIZE);
+ return FALSE;
+ }
+
+ /* This will check for the type of hardware, and if the hardware type
+ * needs external modem, it will check if the modem type is external */
+ if(!os_strncmp(EAP_PROXY_BASEBAND_VALUE_APQ, args, 3)) {
+ for (ret = 0; ret < mdm_detect_info->num_modems; ret++) {
+ if (mdm_detect_info->mdm_list[ret].type == MDM_TYPE_EXTERNAL) {
+ wpa_printf(MSG_INFO, "eap_proxy: hardware supports external modem");
+ return TRUE;
+ }
+ }
+ wpa_printf(MSG_ERROR, "eap_proxy: hardware does not support external modem");
+ return FALSE;
+ }
+ return TRUE;
+}
+#endif /* CONFIG_EAP_PROXY_MDM_DETECT */
+
+void wpa_qmi_register_notification(void *eloop_ctx, void *timeout_ctx)
+{
+ struct eap_proxy_sm *eap_proxy = eloop_ctx;
+ wpa_printf(MSG_DEBUG, "eap_proxy: %s", __func__);
+
+ eap_proxy_qmi_deinit(eap_proxy);
+ eap_proxy_init(eap_proxy, NULL, NULL);
+}
+
+void wpa_qmi_handle_ssr(qmi_client_type user_handle, qmi_client_error_type error, void *err_cb_data)
+{
+ struct eap_proxy_sm *eap_proxy = err_cb_data;
+
+ wpa_printf(MSG_DEBUG, "eap_proxy: %s ", __func__);
+
+ wpa_qmi_ssr = TRUE;
+ eloop_register_timeout(0, 0, wpa_qmi_register_notification, eap_proxy, NULL);
+}
+
+
+static void exit_proxy_init(int signum)
+{
+ pthread_exit(NULL);
+}
+
+static void eap_proxy_post_init(struct eap_proxy_sm *eap_proxy)
+{
+ int qmiErrorCode;
+ int qmiRetCode;
+ qmi_idl_service_object_type qmi_client_service_obj[MAX_NO_OF_SIM_SUPPORTED];
+ int index;
+ static Boolean flag = FALSE;
+ struct sigaction actions;
+ int ret = 0;
+ wpa_uim_struct_type *wpa_uim = eap_proxy->wpa_uim;
+#ifdef CONFIG_EAP_PROXY_MDM_DETECT
+ struct dev_info mdm_detect_info;
+
+ /* Call ESOC API to get the number of modems.
+ * If the number of modems is not zero, only then proceed
+ * with the eap_proxy intialization.
+ */
+ ret = get_system_info(&mdm_detect_info);
+ if (ret > 0)
+ wpa_printf(MSG_ERROR, "eap_proxy: Failed to get system info, ret %d", ret);
+
+ if (mdm_detect_info.num_modems == 0) {
+ eap_proxy->proxy_state = EAP_PROXY_DISABLED;
+ wpa_printf(MSG_ERROR, "eap_proxy: No Modem support for this target"
+ " number of modems is %d", mdm_detect_info.num_modems);
+ return;
+ }
+ wpa_printf(MSG_DEBUG, "eap_proxy: num_modems = %d", mdm_detect_info.num_modems);
+
+ if(eap_modem_compatible(&mdm_detect_info) == FALSE) {
+ eap_proxy->proxy_state = EAP_PROXY_DISABLED;
+ wpa_printf(MSG_ERROR, "eap_proxy: build does not support EAP-SIM feature");
+ return;
+ }
+#endif /* CONFIG_EAP_PROXY_MDM_DETECT */
+
+ sigemptyset(&actions.sa_mask);
+ actions.sa_flags = 0;
+ actions.sa_handler = exit_proxy_init;
+ ret = sigaction(SIGUSR1,&actions,NULL);
+ if(ret < 0)
+ wpa_printf(MSG_DEBUG, "sigaction\n");
+ eap_proxy->proxy_state = EAP_PROXY_INITIALIZE;
+ eap_proxy->qmi_state = QMI_STATE_IDLE;
+ eap_proxy->key = NULL;
+ eap_proxy->iskey_valid = FALSE;
+ eap_proxy->is_state_changed = FALSE;
+ eap_proxy->isEap = FALSE;
+ eap_proxy->eap_type = EAP_TYPE_NONE;
+ eap_proxy->user_selected_sim = 0;
+
+#ifdef CONFIG_EAP_PROXY_DUAL_SIM
+ wpa_printf (MSG_ERROR,
+ "eap_proxy: eap_proxy Initializing for DUAL SIM build %d tid %d",
+ MAX_NO_OF_SIM_SUPPORTED, gettid());
+#else
+ wpa_printf (MSG_ERROR,
+ "eap_proxy: eap_proxy Initializing for Single SIM build %d tid %d",
+ MAX_NO_OF_SIM_SUPPORTED, gettid());
+#endif
+
+
+ for (index = 0; index < MAX_NO_OF_SIM_SUPPORTED; ++index) {
+
+#ifdef SIM_AKA_IDENTITY_IMSI
+ if (FALSE == eap_proxy->qmi_uim_svc_client_initialized[index]) {
+ qmi_client_os_params eap_os_params;
+ /* Init QMI_UIM service for EAP-SIM/AKA */
+ os_memset(&eap_os_params, 0, sizeof(qmi_client_os_params));
+
+ qmiErrorCode = qmi_client_init_instance(
+ uim_get_service_object_v01(),
+ QMI_CLIENT_INSTANCE_ANY,
+ wpa_qmi_client_indication_cb,
+ eap_proxy, &eap_os_params,
+ 10000,
+ &wpa_uim[index].qmi_uim_svc_client_ptr);
+
+ if ((wpa_uim[index].qmi_uim_svc_client_ptr == NULL) || (qmiErrorCode > 0)) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Could not register with QMI UIM"
+ "Service, qmi_uim_svc_client_ptr: %p,qmi_err_code: %d\n",
+ wpa_uim[index].qmi_uim_svc_client_ptr, qmiErrorCode);
+ wpa_uim[index].qmi_uim_svc_client_ptr = NULL;
+ flag = FALSE;
+ continue;
+ }
+ eap_proxy->qmi_uim_svc_client_initialized[index] = TRUE;
+
+ wpa_printf (MSG_ERROR, "eap_proxy: QMI uim service client initialized with"
+ "success tid is %d %p %d\n",
+ gettid(), wpa_uim[index].qmi_uim_svc_client_ptr, qmiErrorCode);
+ /* Register the card events with the QMI / UIM */
+ wpa_qmi_register_events(index, wpa_uim);
+ qmiErrorCode = qmi_client_register_error_cb(
+ wpa_uim[index].qmi_uim_svc_client_ptr, wpa_qmi_handle_ssr, eap_proxy);
+ wpa_printf(MSG_DEBUG,
+ "eap_proxy: qmi_client_register_error_cb() status %d\n", qmiErrorCode);
+ wpa_qmi_ssr = FALSE;
+ } else
+ wpa_printf (MSG_ERROR, "eap_proxy: QMI uim service client is already init"
+ "ialized tid is %d \n", gettid());
+
+
+ qmi_client_os_params eap_os_params;
+ os_memset(&eap_os_params, 0, sizeof(qmi_client_os_params));
+
+ qmiErrorCode = qmi_client_init_instance(auth_get_service_object_v01(),
+ QMI_CLIENT_INSTANCE_ANY,
+ handle_qmi_eap_ind,
+ eap_proxy,
+ &eap_os_params,
+ 10000,
+ &eap_proxy->qmi_auth_svc_client_ptr[index]);
+
+
+ if ((eap_proxy->qmi_auth_svc_client_ptr[index] == NULL) || (qmiErrorCode > 0)) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Could not register with QMI auth Service "
+ "qmi_auth_svc_client_ptr: %p,qmi_err_code: %d\n",
+ eap_proxy->qmi_auth_svc_client_ptr[index], qmiErrorCode);
+ eap_proxy->qmi_auth_svc_client_ptr[index] = NULL;
+ flag = FALSE;
+ continue;
+ }
+ wpa_printf (MSG_ERROR, "eap_proxy: QMI auth service client initialized with success"
+ " tid is %d %p eapol_proxy=%p\n", gettid(),
+ eap_proxy->qmi_auth_svc_client_ptr[index], eap_proxy);
+ flag = TRUE;
+ /* Register for the notifications from QMI / AUTH */
+ wpa_qmi_register_auth_inds(eap_proxy);
+#endif /* SIM_AKA_IDENTITY_IMSI */
+ }
+
+ if ( flag == FALSE ) {
+ eap_proxy->proxy_state = EAP_PROXY_DISABLED;
+ wpa_printf(MSG_ERROR, "eap_proxy: flag = %d proxy init failed\n", flag);
+ return;
+ }
+
+ eap_proxy->proxy_state = EAP_PROXY_IDLE;
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapSuccess, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapFail, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapRestart, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapResp, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapNoResp, FALSE);
+ wpa_printf (MSG_ERROR, "eap_proxy: Eap_proxy initialized successfully"
+ " tid is %d \n", gettid());
+ return;
+
+}
+
+int eap_auth_end_eap_session(qmi_client_type qmi_auth_svc_client_ptr)
+{
+ qmi_client_error_type qmiRetCode = 0;
+ auth_end_eap_session_resp_msg_v01 end_eap_session_resp_msg ;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_auth_end_eap_session: Ending EAP auth session");
+
+
+ /* Send QMI_AUTH_END_EAP_SESSION_REQ */
+
+ os_memset(&end_eap_session_resp_msg,
+ 0,
+ sizeof(auth_end_eap_session_resp_msg_v01));
+
+ qmiRetCode = qmi_client_send_msg_sync(qmi_auth_svc_client_ptr,
+ QMI_AUTH_END_EAP_SESSION_REQ_V01,
+ NULL,
+ 0,
+ (void *) &end_eap_session_resp_msg,
+ sizeof(auth_end_eap_session_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+
+ if (QMI_NO_ERR != qmiRetCode ||
+ end_eap_session_resp_msg.resp.result != QMI_RESULT_SUCCESS_V01) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Unable to End the EAP session;"
+ " error_ret=%d; qmi_err=%d\n", qmiRetCode,
+ end_eap_session_resp_msg.resp.error);
+ return -1;
+ }
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_auth_end_eap_session:"
+ " EAP auth session ended successfuly");
+
+ return 0;
+}
+
+static void eap_proxy_schedule_thread(void *eloop_ctx, void *timeout_ctx)
+{
+ struct eap_proxy_sm *eap_proxy = eloop_ctx;
+ pthread_attr_t attr;
+ int ret = -1;
+
+ pthread_attr_init(&attr);
+ pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ret = pthread_create(&eap_proxy->thread_id, &attr, eap_proxy_post_init, eap_proxy);
+ if(ret < 0)
+ wpa_printf(MSG_ERROR, "eap_proxy: starting thread is failed %d\n", ret);
+}
+
+struct eap_proxy_sm *
+eap_proxy_init(void *eapol_ctx, const struct eapol_callbacks *eapol_cb,
+ void *msg_ctx)
+{
+ int qmiErrorCode;
+ int qmiRetCode;
+ struct eap_proxy_sm *eap_proxy;
+ qmi_idl_service_object_type qmi_client_service_obj;
+
+ wpa_printf(MSG_DEBUG, "eap_proxy: %s "
+ "wpa_qmi_ssr %d", __func__, wpa_qmi_ssr);
+ if(wpa_qmi_ssr) {
+ eap_proxy = eapol_ctx;
+ } else {
+ eap_proxy = os_malloc(sizeof(struct eap_proxy_sm));
+ if (NULL == eap_proxy) {
+ wpa_printf(MSG_ERROR, "Error memory alloc for eap_proxy"
+ "eap_proxy_init\n");
+ return NULL;
+ }
+ os_memset(eap_proxy, 0, sizeof(*eap_proxy));
+ eap_proxy->ctx = eapol_ctx;
+ eap_proxy->eapol_cb = eapol_cb;
+ eap_proxy->msg_ctx = msg_ctx;
+ }
+
+ eap_proxy->proxy_state = EAP_PROXY_DISABLED;
+ eap_proxy->qmi_state = QMI_STATE_IDLE;
+ eap_proxy->key = NULL;
+ eap_proxy->iskey_valid = FALSE;
+ eap_proxy->is_state_changed = FALSE;
+ eap_proxy->isEap = FALSE;
+ eap_proxy->eap_type = EAP_TYPE_NONE;
+
+ /* delay the qmi client initialization after the eloop_run starts,
+ * in order to avoid the case of daemonize enabled, which exits the
+ * parent process that created the qmi client context.
+ */
+
+ eloop_register_timeout(0, 0, eap_proxy_schedule_thread, eap_proxy, NULL);
+ return eap_proxy;
+}
+
+
+static void eap_proxy_qmi_deinit(struct eap_proxy_sm *eap_proxy)
+{
+ int qmiRetCode;
+ int qmiErrorCode;
+ int index;
+ wpa_uim_struct_type *wpa_uim = eap_proxy->wpa_uim;
+
+ if (NULL == eap_proxy)
+ return;
+
+ pthread_kill(eap_proxy->thread_id, SIGUSR1);
+ eap_proxy->proxy_state = EAP_PROXY_DISABLED;
+
+ for (index = 0; index < MAX_NO_OF_SIM_SUPPORTED; ++index) {
+ if (TRUE == eap_proxy->eap_auth_session_flag[index]) {
+
+ /* end the current EAP session */
+ if(eap_auth_end_eap_session(eap_proxy->qmi_auth_svc_client_ptr[index]) < 0 ){
+ wpa_printf(MSG_ERROR, "eap_proxy: Unable to end the EAP session for"
+ " client %d", index+1);
+ } else {
+ wpa_printf(MSG_ERROR, "eap_proxy: Ended the QMI EAP session for "
+ "client %d\n",
+ index+1);
+ eap_proxy->eap_auth_session_flag[index] = FALSE;
+ }
+ } else {
+ wpa_printf (MSG_ERROR, "eap_proxy: session not started"
+ " for client = %d\n", index+1);
+ continue;
+ }
+
+ if ((TRUE == eap_proxy->qmi_uim_svc_client_initialized[index])) {
+ qmiRetCode = qmi_client_release(wpa_uim[index].qmi_uim_svc_client_ptr);
+ if (QMI_NO_ERR != qmiRetCode) {
+ wpa_printf (MSG_ERROR, "eap_proxy: Unable to Releas the connection"
+ " to uim service for client=%d; error_ret=%d\n;",
+ index+1, qmiRetCode);
+ }
+ wpa_printf(MSG_ERROR, "eap_proxy: Released QMI UIM service client\n");
+ eap_proxy->qmi_uim_svc_client_initialized[index] = FALSE;
+ }
+
+ qmiRetCode = qmi_client_release(eap_proxy->qmi_auth_svc_client_ptr[index]);
+ if (QMI_NO_ERR != qmiRetCode) {
+ wpa_printf (MSG_ERROR, "eap_proxy: Unable to Releas the connection"
+ " to auth service for client=%d; error_ret=%d\n;",
+ index+1, qmiRetCode);
+ } else {
+ wpa_printf(MSG_ERROR, "eap_proxy: Released QMI EAP service client\n");
+ }
+
+ }
+
+ if (NULL != eap_proxy->key) {
+ os_free(eap_proxy->key);
+ eap_proxy->key = NULL;
+ }
+
+ eap_proxy->iskey_valid = FALSE;
+ eap_proxy->is_state_changed = FALSE;
+ eap_proxy->user_selected_sim = 0;
+
+}
+
+void eap_proxy_deinit(struct eap_proxy_sm *eap_proxy)
+{
+ eap_proxy_qmi_deinit(eap_proxy);
+ if (eap_proxy != NULL) {
+ os_free(eap_proxy);
+ eap_proxy = NULL;
+ wpa_printf(MSG_INFO, "eap_proxy: eap_proxy Deinitialzed\n");
+ }
+}
+
+/* Call-back function to process an authentication result indication
+* from QMI EAP service */
+static void handle_qmi_eap_ind(qmi_client_type user_handle,
+ unsigned int msg_id,
+ void* ind_buf,
+ unsigned int ind_buf_len,
+ void* ind_cb_data)
+{
+ qmi_client_error_type qmi_err;
+ auth_eap_session_result_ind_msg_v01 eap_session_result;
+ memset(&eap_session_result, 0, sizeof(auth_eap_session_result_ind_msg_v01));
+ eap_session_result.eap_result = -1;
+ struct eap_proxy_sm *sm = (struct eap_proxy_sm *)ind_cb_data;
+
+ auth_eap_notification_code_ind_msg_v01 eap_notification;
+ memset(&eap_notification, 0, sizeof(auth_eap_notification_code_ind_msg_v01));
+
+ wpa_printf(MSG_ERROR, "eap_proxy: Handle_qmi_eap_ind msgId =%d sm=%p\n", msg_id,sm);
+ /* Decode */
+
+ switch(msg_id)
+ {
+ case QMI_AUTH_EAP_SESSION_RESULT_IND_V01:
+
+ qmi_err = qmi_client_message_decode(user_handle, QMI_IDL_INDICATION,
+ msg_id, (void*)ind_buf, ind_buf_len,
+ &eap_session_result,
+ sizeof(auth_eap_session_result_ind_msg_v01));
+ if (qmi_err != QMI_NO_ERR)
+ {
+ wpa_printf(MSG_ERROR, "eap_proxy: Error in qmi_client_message_de"
+ "code; error_code=%d \n", qmi_err);
+ sm->srvc_result = EAP_PROXY_QMI_SRVC_FAILURE;
+ return;
+ }
+ if ((eap_session_result.eap_result == 0) &&
+ (QMI_STATE_RESP_TIME_OUT != sm->qmi_state)) {
+ sm->proxy_state = EAP_PROXY_AUTH_SUCCESS;
+ sm->qmi_state = QMI_STATE_RESP_RECEIVED;
+ wpa_printf(MSG_ERROR, "eap_proxy: Handle_qmi_eap_ind EAP PROXY AUTH"
+ " SUCCESS %p set to %d\n",
+ (void *)&sm->qmi_state, sm->qmi_state);
+ } else {
+ sm->proxy_state = EAP_PROXY_AUTH_FAILURE;
+ wpa_printf(MSG_ERROR, "eap_proxy: Handle_qmi_eap_ind EAP PROXY AUTH"
+ " FAILURE \n");
+ }
+ sm->srvc_result = EAP_PROXY_QMI_SRVC_SUCCESS;
+ break;
+
+ case QMI_AUTH_EAP_NOTIFICATION_CODE_IND_V01:
+
+ qmi_err = qmi_client_message_decode(user_handle, QMI_IDL_INDICATION,
+ msg_id, (void*)ind_buf, ind_buf_len,
+ &eap_notification,
+ sizeof(auth_eap_notification_code_ind_msg_v01));
+ if (qmi_err != QMI_NO_ERR)
+ {
+ wpa_printf(MSG_ERROR, "eap_proxy: Error in qmi_client_"
+ "message_decode; error_code=%d \n", qmi_err);
+ }
+ sm->notification_code = eap_notification.eap_notification_code;
+ wpa_printf(MSG_ERROR, "eap_proxy: notificatio code is %x\n",
+ eap_notification.eap_notification_code);
+ break;
+
+ default:
+ wpa_printf(MSG_ERROR, "eap_proxy: An unexpected msg Id=%d"
+ " is given\n", msg_id);
+ break;
+ }
+
+
+}
+
+
+/* Call-back function to process an EAP response from QMI EAP service */
+static void handle_qmi_eap_reply(
+ qmi_client_type userHandle, unsigned int msg_id,
+ void *resp_c_struct, unsigned int resp_c_struct_len,
+ void *userData, qmi_client_error_type sysErrCode)
+{
+ struct eap_proxy_sm *eap_proxy = (struct eap_proxy_sm *)userData;
+ auth_send_eap_packet_resp_msg_v01* rspData =
+ (auth_send_eap_packet_resp_msg_v01*)resp_c_struct;
+
+ u8 *resp_data;
+ u32 length;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: %s started\n", __func__);
+ if (eap_proxy == NULL) {
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_proxy is NULL");
+ return;
+ }
+ if (QMI_STATE_RESP_PENDING == eap_proxy->qmi_state) {
+
+ wpa_printf(MSG_ERROR, "eap_proxy: user_selected_sim = %d\n",
+ eap_proxy->user_selected_sim+1);
+
+
+ if (QMI_NO_ERR != sysErrCode) {
+ wpa_printf(MSG_ERROR, "eap_proxy: An error is encountered with"
+ " the request: sysErrorCode=%d\n",
+ sysErrCode);
+ eap_proxy->qmi_state = QMI_STATE_RESP_TIME_OUT;
+ return;
+ }
+
+ if (NULL == rspData) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Response data is NULL\n");
+ eap_proxy->qmi_state = QMI_STATE_RESP_TIME_OUT;
+ return;
+ }
+ if((QMI_AUTH_SEND_EAP_PACKET_REQ_V01 != msg_id) &&
+ (QMI_AUTH_SEND_EAP_PACKET_EXT_REQ_V01 != msg_id))
+ {
+ wpa_printf(MSG_ERROR, "eap_proxy: Invalid msgId =%d\n", msg_id);
+ eap_proxy->qmi_state = QMI_STATE_RESP_TIME_OUT;
+ return;
+ }
+
+ /* ensure the reply packet exists */
+ if (rspData->eap_response_pkt_len <= 0 ||
+ rspData->eap_response_pkt_len > QMI_AUTH_EAP_RESP_PACKET_EXT_MAX_V01) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Reply packet is of invalid length %d"
+ " error %d result %d\n", rspData->eap_response_pkt_len,
+ rspData->resp.error, rspData->resp.result);
+ eap_proxy->qmi_state = QMI_STATE_RESP_TIME_OUT;
+ return;
+ }
+
+ length = rspData->eap_response_pkt_len;
+ eap_proxy->qmi_resp_data.eap_send_pkt_resp.length = length;
+ /* allocate a buffer to store the response data; size is EAP resp len field */
+ eap_proxy->qmi_resp_data.eap_send_pkt_resp.resp_data =
+ os_malloc(rspData->eap_response_pkt_len);
+
+ resp_data =
+ (u8 *)eap_proxy->qmi_resp_data.eap_send_pkt_resp.resp_data;
+
+ if (NULL == resp_data) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Unable to allocate memory for"
+ " reply packet\n");
+ eap_proxy->qmi_state = QMI_STATE_RESP_TIME_OUT;
+
+ return;
+ }
+
+ /* copy the response data to the allocated buffer */
+ os_memcpy(resp_data,
+ rspData->eap_response_pkt, length);
+ eap_proxy->qmi_state = QMI_STATE_RESP_RECEIVED;
+ wpa_printf(MSG_ERROR, "eap_proxy: **HANDLE_QMI_EAP_REPLY CALLBACK ENDDED **");
+
+ wpa_printf(MSG_ERROR, "eap_proxy: Dump Resp Data len %d\n", length);
+ dump_buff(resp_data, length);
+ }
+
+ return;
+}
+
+static enum eap_proxy_status eap_proxy_process(struct eap_proxy_sm *eap_proxy,
+ u8 *eapReqData, int eapReqDataLen, struct eap_sm *eap_sm)
+{
+ struct eap_hdr *hdr;
+ int qmiErrorCode;
+ enum eap_proxy_status proxy_status = EAP_PROXY_SUCCESS;
+ auth_send_eap_packet_req_msg_v01 eap_send_packet_req;
+ auth_send_eap_packet_resp_msg_v01 eap_send_packet_resp;
+ qmi_txn_handle async_txn_hdl = 0;
+
+ auth_send_eap_packet_ext_req_msg_v01 eap_send_packet_ext_req;
+ auth_send_eap_packet_ext_resp_msg_v01 eap_send_packet_ext_resp;
+
+
+ hdr = (struct eap_hdr *)eapReqData;
+ if ((EAP_CODE_REQUEST == hdr->code) &&
+ (EAP_TYPE_IDENTITY == eapReqData[4])) {
+ if (eap_proxy_eapol_sm_get_bool(eap_proxy, EAPOL_eapRestart) &&
+ eap_proxy_eapol_sm_get_bool(eap_proxy, EAPOL_portEnabled)) {
+ wpa_printf (MSG_ERROR, "eap_proxy: Already Authenticated."
+ " Clear all the flags");
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapSuccess, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapFail, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapResp, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapNoResp, FALSE);
+ if (eap_proxy->key) {
+ os_free(eap_proxy->key);
+ eap_proxy->key = NULL;
+ }
+ eap_proxy->iskey_valid = FALSE;
+ eap_proxy->is_state_changed = TRUE;
+ }
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapRestart, FALSE);
+
+ if(eap_proxy_build_identity(eap_proxy, hdr->identifier, eap_sm)) {
+ eap_proxy->proxy_state = EAP_PROXY_IDENTITY;
+ } else {
+ wpa_printf(MSG_ERROR, "eap_proxy: Error in build identity\n");
+ return EAP_PROXY_FAILURE;
+ }
+ }
+ wpa_printf(MSG_ERROR, "eap_proxy: ***********Dump ReqData len %d***********",
+ eapReqDataLen);
+ dump_buff(eapReqData, eapReqDataLen);
+ if (eapReqDataLen <= QMI_AUTH_EAP_REQ_PACKET_MAX_V01) {
+ os_memset(&eap_send_packet_req, 0, sizeof(auth_send_eap_packet_req_msg_v01));
+ os_memset(&eap_send_packet_resp, 0, sizeof(auth_send_eap_packet_resp_msg_v01));
+ eap_send_packet_req.eap_request_pkt_len = eapReqDataLen ;
+ memcpy(eap_send_packet_req.eap_request_pkt, eapReqData, eapReqDataLen);
+ } else if (eapReqDataLen <= QMI_AUTH_EAP_REQ_PACKET_EXT_MAX_V01) {
+ os_memset(&eap_send_packet_ext_req, 0,
+ sizeof(auth_send_eap_packet_ext_req_msg_v01));
+ os_memset(&eap_send_packet_ext_resp, 0,
+ sizeof(auth_send_eap_packet_ext_resp_msg_v01));
+ eap_send_packet_ext_req.eap_request_ext_pkt_len = eapReqDataLen;
+ memcpy(eap_send_packet_ext_req.eap_request_ext_pkt, eapReqData, eapReqDataLen);
+ } else {
+ wpa_printf(MSG_ERROR, "eap_proxy: Error in eap_send_packet_req\n");
+ return EAP_PROXY_FAILURE;
+ }
+
+ wpa_printf(MSG_ERROR, "eap_proxy: SIM selected by User: Selected sim = %d\n",
+ eap_proxy->user_selected_sim+1);
+ if (eap_proxy->qmi_state != QMI_STATE_IDLE) {
+ wpa_printf(MSG_ERROR, "Error in QMI state=%d\n",
+ eap_proxy->qmi_state);
+ return EAP_PROXY_FAILURE;
+ }
+
+ wpa_printf (MSG_ERROR, "eap_proxy: In eap_proxy_process case %d\n", hdr->code);
+ eap_proxy->qmi_state = QMI_STATE_RESP_PENDING;
+
+ if(eapReqDataLen <= QMI_AUTH_EAP_REQ_PACKET_MAX_V01) {
+ qmiErrorCode = qmi_client_send_msg_async(
+ eap_proxy->qmi_auth_svc_client_ptr[eap_proxy->user_selected_sim],
+ QMI_AUTH_SEND_EAP_PACKET_REQ_V01,
+ (void *) &eap_send_packet_req,
+ sizeof(auth_send_eap_packet_req_msg_v01),
+ (void *) &eap_send_packet_resp,
+ sizeof(auth_send_eap_packet_resp_msg_v01),
+ &handle_qmi_eap_reply, eap_proxy,
+ &async_txn_hdl);
+ } else if(eapReqDataLen <= QMI_AUTH_EAP_REQ_PACKET_EXT_MAX_V01) {
+ qmiErrorCode = qmi_client_send_msg_async(
+ eap_proxy->qmi_auth_svc_client_ptr[eap_proxy->user_selected_sim],
+ QMI_AUTH_SEND_EAP_PACKET_EXT_REQ_V01,
+ (void *) &eap_send_packet_ext_req,
+ sizeof(auth_send_eap_packet_ext_req_msg_v01),
+ (void *) &eap_send_packet_ext_resp,
+ sizeof(auth_send_eap_packet_ext_resp_msg_v01),
+ &handle_qmi_eap_reply, eap_proxy,
+ &async_txn_hdl);
+ }
+
+ if (QMI_NO_ERR != qmiErrorCode) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Error in sending EAP packet;"
+ " error_code=%d\n", qmiErrorCode);
+ eap_proxy->proxy_state = EAP_PROXY_DISCARD;
+ eap_proxy_eapol_sm_set_bool(eap_proxy, EAPOL_eapNoResp, TRUE);
+ eap_proxy->qmi_state = QMI_STATE_RESP_PENDING;
+ return EAP_PROXY_FAILURE;
+ } else {
+ wpa_printf (MSG_ERROR, "eap_proxy: In eap_proxy_process case %d\n", hdr->code);
+ switch (hdr->code) {
+ case EAP_CODE_SUCCESS:
+ if (EAP_PROXY_SUCCESS !=
+ eap_proxy_qmi_response_wait(eap_proxy)) {
+ eap_proxy->proxy_state = EAP_PROXY_DISCARD;
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapNoResp, TRUE);
+ return EAP_PROXY_FAILURE;
+ } else if( eap_proxy->proxy_state == EAP_PROXY_AUTH_SUCCESS ) {
+ eap_proxy_getKey(eap_proxy);
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapSuccess, TRUE);
+ /*
+ * RFC 4137 does not clear eapReq here, but this seems to be required
+ * to avoid processing the same request twice when state machine is
+ * initialized.
+ */
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapReq, FALSE);
+
+ /*
+ * RFC 4137 does not set eapNoResp here, but this seems to be required
+ * to get EAPOL Supplicant backend state machine into SUCCESS state. In
+ * addition, either eapResp or eapNoResp is required to be set after
+ * processing the received EAP frame.
+ */
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapNoResp, TRUE);
+
+ wpa_msg(eap_proxy->msg_ctx, MSG_INFO, WPA_EVENT_EAP_SUCCESS
+ "eap_proxy: EAP authentication completed successfully");
+
+ eap_proxy->is_state_changed = TRUE;
+
+ /* Retrieve the keys and store*/
+ } else if( eap_proxy->proxy_state == EAP_PROXY_AUTH_FAILURE ){
+
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapFail, TRUE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapReq, FALSE);
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapNoResp, TRUE);
+ eap_proxy->is_state_changed = TRUE;
+
+ }
+
+ break;
+
+ case EAP_CODE_FAILURE:
+ wpa_printf (MSG_ERROR,
+ "eap_proxy: in eap_proxy_process case EAP_CODE_FAILURE\n");
+ eap_proxy->proxy_state = EAP_PROXY_AUTH_FAILURE;
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapFail, TRUE);
+
+ /*
+ * RFC 4137 does not clear eapReq here, but this seems to be required
+ * to avoid processing the same request twice when state machine is
+ * initialized.
+ */
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapReq, FALSE);
+
+ /*
+ * RFC 4137 does not set eapNoResp here. However, either eapResp or
+ * eapNoResp is required to be set after processing the received EAP
+ * frame.
+ */
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapNoResp, TRUE);
+
+ wpa_msg(eap_proxy->msg_ctx, MSG_INFO, WPA_EVENT_EAP_FAILURE
+ "EAP authentication failed notification code 0x%x",
+ eap_proxy->notification_code);
+
+ eap_proxy->is_state_changed = TRUE;
+ break;
+
+ case EAP_CODE_REQUEST:
+ eap_proxy->proxy_state = EAP_PROXY_SEND_RESPONSE;
+ if (EAP_PROXY_SUCCESS !=
+ eap_proxy_qmi_response_wait(eap_proxy)) {
+ eap_proxy->proxy_state = EAP_PROXY_DISCARD;
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapNoResp, TRUE);
+ return EAP_PROXY_FAILURE;
+ } else {
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapResp, TRUE);
+ eap_proxy->proxy_state =
+ EAP_PROXY_SEND_RESPONSE;
+ }
+
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapReq, FALSE);
+ eap_proxy->is_state_changed = TRUE;
+ break;
+
+ default:
+ wpa_printf(MSG_ERROR, "eap_proxy: Error in sending EAP packet;"
+ " error_code=%d\n", qmiErrorCode);
+ eap_proxy->proxy_state = EAP_PROXY_DISCARD;
+ eap_proxy_eapol_sm_set_bool(eap_proxy,
+ EAPOL_eapNoResp, TRUE);
+ return EAP_PROXY_FAILURE;
+ }
+ }
+
+ return EAP_PROXY_SUCCESS;
+}
+
+
+
+static u8 *eap_proxy_getKey(struct eap_proxy_sm *eap_proxy)
+{
+ int qmiErrorCode;
+ int qmiRetCode;
+
+ auth_get_eap_session_keys_resp_msg_v01 key_resp_msg;
+ os_memset(&key_resp_msg, 0, sizeof(auth_get_eap_session_keys_resp_msg_v01));
+
+ qmiRetCode = qmi_client_send_msg_sync(
+ eap_proxy->qmi_auth_svc_client_ptr[eap_proxy->user_selected_sim],
+ QMI_AUTH_GET_EAP_SESSION_KEYS_REQ_V01,
+ NULL,
+ 0,
+ (void *) &key_resp_msg,
+ sizeof(auth_get_eap_session_keys_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+
+
+ /* see if the MSK is acquired successfully */
+ if (QMI_NO_ERR != qmiRetCode || key_resp_msg.resp.result != QMI_RESULT_SUCCESS_V01) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Unable to get session keys;"
+ " err_code=%d qmiErr=%d\n", qmiRetCode, key_resp_msg.resp.error);
+ eap_proxy->key = NULL;
+ return NULL;
+ }
+ wpa_printf(MSG_ERROR, "eap_proxy: %s:session_key_len =%d", __func__,
+ key_resp_msg.session_key_len);
+
+ if(key_resp_msg.session_key_len <=0 ||
+ key_resp_msg.session_key_len > EAP_PROXY_KEYING_DATA_LEN)
+ {
+ return NULL;
+
+ }
+ eap_proxy->key = os_malloc(EAP_PROXY_KEYING_DATA_LEN);
+ if(eap_proxy->key == NULL)
+ return NULL;
+
+ memset(eap_proxy->key, 0, EAP_PROXY_KEYING_DATA_LEN);
+ memcpy(eap_proxy->key, key_resp_msg.session_key, key_resp_msg.session_key_len);
+
+ eap_proxy->iskey_valid = TRUE;
+ eap_proxy->proxy_state = EAP_PROXY_AUTH_SUCCESS;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_proxy_getkey EAP KEYS ");
+ dump_buff(eap_proxy->key, EAP_PROXY_KEYING_DATA_LEN);
+ return eap_proxy->key;
+}
+
+
+/**
+ * eap_key_available - Get key availability (eapKeyAvailable variable)
+ * @sm: Pointer to EAP state machine allocated with eap_sm_init()
+ * Returns: 1 if EAP keying material is available, 0 if not
+ */
+int eap_proxy_key_available(struct eap_proxy_sm *sm)
+{
+ return sm ? sm->iskey_valid : 0;
+}
+
+
+static int eap_proxy_is_state_changed(struct eap_proxy_sm *sm)
+{
+ if (NULL == sm)
+ return 0;
+
+ if (TRUE == sm->is_state_changed) {
+ sm->is_state_changed = FALSE;
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+
+/**
+ * eap_get_eapKeyData - Get master session key (MSK) from EAP state machine
+ * @sm: Pointer to EAP state machine allocated with eap_sm_init()
+ * @len: Pointer to variable that will be set to number of bytes in the key
+ * Returns: Pointer to the EAP keying data or %NULL on failure
+ *
+ * Fetch EAP keying material (MSK, eapKeyData) from the EAP state machine. The
+ * key is available only after a successful authentication. EAP state machine
+ * continues to manage the key data and the caller must not change or free the
+ * returned data.
+ */
+const u8 * eap_proxy_get_eapKeyData(struct eap_proxy_sm *sm, size_t *len)
+{
+ if (sm == NULL || sm->key == NULL) {
+ *len = 0;
+ return NULL;
+ }
+
+ *len = EAP_PROXY_KEYING_DATA_LEN;
+ return sm->key;
+}
+
+/**
+ * eap_proxy_get_eapRespData - Get EAP response data
+ * @sm: Pointer to EAP state machine allocated with eap_sm_init()
+ * @len: Pointer to variable that will be set to the length of the response
+ * Returns: Pointer to the EAP response (eapRespData) or %NULL on failure
+ *
+ * Fetch EAP response (eapRespData) from the EAP state machine. This data is
+ * available when EAP state machine has processed an incoming EAP request. The
+ * EAP state machine does not maintain a reference to the response after this
+ * function is called and the caller is responsible for freeing the data.
+ */
+struct wpabuf * eap_proxy_get_eapRespData(struct eap_proxy_sm *eap_proxy)
+{
+ struct wpabuf *resp;
+ int len;
+ //int i;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_proxy_get_eapRespData");
+ if ( (eap_proxy == NULL) ||
+ (eap_proxy->qmi_resp_data.eap_send_pkt_resp.resp_data == NULL)
+ )
+ {
+ return NULL;
+ }
+
+ len = eap_proxy->qmi_resp_data.eap_send_pkt_resp.length;
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_proxy_get_eapRespData len = %d", len);
+ resp = wpabuf_alloc(len);
+ if (resp == NULL) {
+ wpa_printf(MSG_ERROR, "eap_proxy: buf allocation failed\n");
+ return NULL;
+ }
+
+ resp->used = len;
+ os_memcpy(resp->buf, eap_proxy->qmi_resp_data.eap_send_pkt_resp.resp_data,
+ len);
+ /*
+ for (i = 0; i < len; i++) {
+ wpa_printf (MSG_ERROR, "%c", resp->buf[i]);
+ }
+ */
+ os_free(eap_proxy->qmi_resp_data.eap_send_pkt_resp.resp_data);
+ eap_proxy->qmi_resp_data.eap_send_pkt_resp.resp_data = NULL;
+ eap_proxy->qmi_resp_data.eap_send_pkt_resp.length = 0;
+
+ return resp;
+}
+
+
+static enum eap_proxy_status eap_proxy_qmi_response_wait(struct eap_proxy_sm *eap_proxy)
+{
+
+ int count = 0;
+
+ wpa_printf(MSG_DEBUG, "eap_proxy_qmi_response_wait: Start blocking "
+ "wait eap_proxy=%p",eap_proxy);
+ do {
+ count++;
+ if (count > QMI_RESP_TIME_OUT / 2) {
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: eap_proxy_qmi_response_wait "
+ "!QMI STATE %d TIME_OUT\n",
+ eap_proxy->qmi_state);
+ eap_proxy->qmi_state = QMI_STATE_RESP_TIME_OUT;
+ break;
+ }
+
+ os_sleep(0, 2000);
+
+ if ((QMI_STATE_RESP_RECEIVED == eap_proxy->qmi_state) ||
+ (QMI_STATE_RESP_TIME_OUT == eap_proxy->qmi_state))
+ break;
+ } while (1);
+
+ wpa_printf(MSG_DEBUG, "eap_proxy: eap_proxy_qmi_response_wait: Wait done after %d "
+ "iterations: qmi_state=%d", count,
+ eap_proxy->qmi_state);
+
+ if (QMI_STATE_RESP_TIME_OUT == eap_proxy->qmi_state) {
+ wpa_printf(MSG_ERROR, "eap_proxy: QMI state Response Time out\n");
+ eap_proxy->proxy_state = EAP_PROXY_DISCARD;
+ return EAP_PROXY_FAILURE;
+ }
+ eap_proxy->qmi_state = QMI_STATE_IDLE;
+
+ return EAP_PROXY_SUCCESS;
+}
+
+
+static void eap_proxy_eapol_sm_set_bool(struct eap_proxy_sm *sm,
+ enum eapol_bool_var var, Boolean value)
+{
+ sm->eapol_cb->set_bool(sm->ctx, var, value);
+}
+
+
+static Boolean eap_proxy_eapol_sm_get_bool(struct eap_proxy_sm *sm,
+ enum eapol_bool_var var)
+{
+ return sm->eapol_cb->get_bool(sm->ctx, var);
+}
+
+
+int eap_proxy_sm_step(struct eap_proxy_sm *sm, struct eap_sm *eap_sm)
+{
+ if ((sm->proxy_state != EAP_PROXY_INITIALIZE) &&
+ (sm->proxy_state != EAP_PROXY_DISABLED)) {
+ if (TRUE == sm->isEap) {
+ if(!eap_proxy_process(sm, sm->eapReqData,
+ sm->eapReqDataLen,eap_sm)) {
+ sm->proxy_state = EAP_PROXY_AUTH_FAILURE;
+ eap_proxy_eapol_sm_set_bool(sm, EAPOL_eapRestart, TRUE);
+ }
+ sm->isEap = FALSE;
+ }
+ }
+ return eap_proxy_is_state_changed(sm);
+}
+
+
+enum eap_proxy_status
+eap_proxy_packet_update(struct eap_proxy_sm *eap_proxy, u8 *eapReqData,
+ int eapReqDataLen)
+{
+ eap_proxy->eapReqData = eapReqData;
+ eap_proxy->eapReqDataLen = eapReqDataLen;
+ eap_proxy->isEap = TRUE;
+ return EAP_PROXY_SUCCESS;
+}
+
+
+u8 * eap_proxy_get_eap_session_id(struct eap_proxy_sm *sm, size_t *len)
+{
+ wpa_printf(MSG_ERROR, "%s: enter: not implemented\n", __func__);
+ return NULL;
+}
+
+
+u8 * eap_proxy_get_emsk(struct eap_proxy_sm *sm, size_t *len)
+{
+ wpa_printf(MSG_ERROR, "%s: enter: not implemented\n", __func__);
+ return NULL;
+}
+
+
+void eap_proxy_sm_abort(struct eap_proxy_sm *sm)
+{
+ wpa_printf(MSG_ERROR, "%s: enter: not implemented\n", __func__);
+ return;
+}
+
+
+static void dump_buff(u8 *buff, int len)
+{
+ int i ;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: ---- EAP Buffer----LEN %d\n",len);
+ for (i = 0; i < len; i++) {
+ if (0 == i%8)
+ wpa_printf(MSG_DEBUG, " \n");
+ wpa_printf(MSG_ERROR, "eap_proxy: 0x%x ", buff[i]);
+ }
+ return;
+}
+static char bin_to_hexchar(u8 ch)
+{
+ if (ch < 0x0a) {
+ return ch + '0';
+ }
+ return ch + 'a' - 10;
+}
+static Boolean eap_proxy_build_identity(struct eap_proxy_sm *eap_proxy, u8 id, struct eap_sm *eap_sm)
+{
+ struct eap_hdr *resp;
+ unsigned int len;
+ u8 identity_len = 0, ret;
+ u8 imsi_id_len = 0;
+ int mnc_len = -1;
+ u8 *pos;
+ int qmiRetCode;
+ u8 idx = 0, mcc_idx = 0;
+ unsigned char *identity = NULL;
+ unsigned char *imsi_identity = NULL;
+ auth_start_eap_session_req_msg_v01 eap_auth_start;
+ auth_start_eap_session_resp_msg_v01 eap_auth_start_resp;
+ auth_set_subscription_binding_req_msg_v01 sub_req_binding;
+ auth_set_subscription_binding_resp_msg_v01 sub_resp_binding;
+
+ struct eap_method_type *m;
+ eap_identity_format_e identity_format = EAP_IDENTITY_ANNONYMOUS;
+ Boolean simEnabled = FALSE, akaEnabled = FALSE;
+ struct eap_peer_config *config = eap_get_config(eap_sm);
+ const char *realm_3gpp = "@wlan.mnc000.mcc000.3gppnetwork.org";
+ int sim_num;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: %s\n", __func__);
+ sim_num = config->sim_num - 1;
+ os_memset(&eap_auth_start, 0, sizeof(eap_auth_start));
+ os_memset(&eap_auth_start_resp, 0, sizeof(eap_auth_start_resp));
+
+ eap_auth_start.user_id_len = 0;
+ m = config->eap_methods;
+
+ if (sim_num >= MAX_NO_OF_SIM_SUPPORTED || sim_num < 0) {
+ wpa_printf (MSG_ERROR, "eap_proxy: Invalid SIM selected sim by user = %d\n",
+ sim_num+1);
+ return FALSE;
+ }
+ wpa_printf(MSG_ERROR, "eap_proxy: User selected sim = %d\n", sim_num + 1);
+
+ if (m != NULL) {
+ for (idx = 0; m[idx].vendor != EAP_VENDOR_IETF ||
+ m[idx].method != EAP_TYPE_NONE; idx++) {
+ if (m[idx].method == EAP_TYPE_AKA) {
+ akaEnabled = TRUE;
+ eap_auth_start.eap_method_mask_valid = 1;
+ eap_auth_start.eap_method_mask |= QMI_AUTH_EAP_METHOD_MASK_AKA_V01;
+ wpa_printf(MSG_ERROR, "eap_proxy: AKA Enabled\n");
+ } else if (m[idx].method == EAP_TYPE_SIM) {
+ simEnabled = TRUE;
+ eap_auth_start.eap_method_mask_valid = 1;
+ eap_auth_start.eap_method_mask |= QMI_AUTH_EAP_METHOD_MASK_SIM_V01;
+ wpa_printf(MSG_ERROR, "eap_proxy: SIM Enabled\n");
+#ifdef CONFIG_EAP_PROXY_AKA_PRIME
+ } else if (m[idx].method == EAP_TYPE_AKA_PRIME) {
+ eap_auth_start.eap_method_mask_valid = 1;
+ eap_auth_start.eap_method_mask |=
+ QMI_AUTH_EAP_METHOD_MASK_AKA_PRIME_V01;
+ wpa_printf(MSG_ERROR, "eap_proxy: AKA Prime Enabled\n");
+#endif /* CONFIG_EAP_PROXY_AKA_PRIME */
+ }
+ }
+ } else {
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_methods is NULL!\n");
+ return FALSE;
+ }
+
+ eap_auth_start.eap_method_mask_valid = 1;
+
+ idx = 0;
+#ifdef SIM_AKA_IMSI_RAW_ENABLED
+
+ identity_format = EAP_IDENTITY_IMSI_RAW;
+ eap_auth_start.user_id_valid = 1;
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP_IDENTITY_IMSI_RAW selected %d \n",
+ eap_auth_start.user_id_len);
+
+#else /* SIM_AKA_IMSI_RAW_ENABLED */
+
+ if (config->identity_len && config->identity != NULL) {
+ for (idx = 0; idx < config->identity_len; idx++) {
+ if (config->identity[idx] == 64) {
+ wpa_printf(MSG_ERROR, "eap_proxy: @ found \n");
+ mcc_idx = idx;
+ if ((mcc_idx + 18) > config->identity_len)
+ mcc_idx = 0;
+ else {
+ /* Looking for mnc and mcc pattern */
+ if (109 == config->identity[mcc_idx + 6] &&
+ (110 == config->identity[mcc_idx + 7]) &&
+ (99 == config->identity[mcc_idx + 8]) &&
+ (109 == config->identity[mcc_idx + 13]) &&
+ (99 == config->identity[mcc_idx + 14]) &&
+ (99 == config->identity[mcc_idx + 15])) {
+ mcc_idx += 9;
+ } else
+ mcc_idx = 0;
+ }
+ break;
+ }
+ }
+
+ wpa_printf(MSG_ERROR, "eap_proxy: idx %d\n", idx);
+ wpa_printf(MSG_ERROR, "eap_proxy: mcc idx %d\n", mcc_idx);
+
+ if (!idx && (config->identity_len == 1)) {
+ /* config file : @ */
+ config->identity_len = 0;
+ identity_format = EAP_IDENTITY_IMSI_3GPP_REALM;
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP_IDENTITY_IMSI_3GPP_REALM "
+ "selected \n");
+ } else if (idx && (idx < config->identity_len) && (config->identity != NULL)) {
+
+ /* config file : <>@<> or <>@<wlan.mnc000.mcc000.<>.<> */
+ identity_len = config->identity_len;
+ identity = os_malloc(config->identity_len);
+
+ if (NULL != identity) {
+ os_memset(identity, 0, config->identity_len);
+ os_memcpy(identity, config->identity,
+ config->identity_len);
+ }
+
+ /* To Do for 3GPP realm */
+ identity_format = EAP_IDENTITY_CFG_3GPP_REALM;
+ eap_auth_start.user_id_valid = 1;
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP_IDENTITY_CFG_3GPP_REALM "
+ "selected %d \n", eap_auth_start.user_id_len);
+
+ } else if ((idx == config->identity_len) && config->identity_len &&
+ (config->identity != NULL)) {
+
+ /* config file : <identity in RAW format >*/
+ identity_len = config->identity_len;
+ identity = os_malloc(config->identity_len);
+
+ if (NULL != identity) {
+ os_memset(identity, 0, config->identity_len);
+ os_memcpy(identity, config->identity,
+ config->identity_len);
+ }
+
+ identity_format = EAP_IDENTITY_CFG_RAW;
+ eap_auth_start.user_id_valid = 1;
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP_IDENTITY_CFG_RAW selected %d \n",
+ eap_auth_start.user_id_len);
+ } else if (!idx && mcc_idx) {
+
+ /* config file: @wlan.mnc000.mcc000.<>.<> */
+ identity_len = config->identity_len;
+ identity = os_malloc(config->identity_len);
+
+ if (NULL != identity) {
+ os_memset(identity, 0, config->identity_len);
+ os_memcpy(identity, config->identity,
+ config->identity_len);
+ }
+
+ identity_format = EAP_IDENTITY_IMSI_3GPP_REALM;
+ eap_auth_start.user_id_valid = 1;
+ wpa_printf(MSG_ERROR, "eap_proxy: config EAP_IDENTITY_IMSI_3GPP_REALM "
+ "selected %d\n", eap_auth_start.user_id_len);
+ }
+ } else {
+
+ if (config->anonymous_identity_len && config->anonymous_identity != NULL) {
+
+ eap_auth_start.eap_meta_identity_len = config->anonymous_identity_len;
+ os_memcpy(&eap_auth_start.eap_meta_identity ,
+ config->anonymous_identity ,
+ config->anonymous_identity_len);
+
+ identity_format = EAP_IDENTITY_ANNONYMOUS;
+ eap_auth_start.eap_meta_identity_valid = 1;
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP_IDENTITY_ANNONYMOUS selected user id "
+ "%d, annonymous %d\n", eap_auth_start.user_id_len,
+ eap_auth_start.eap_meta_identity_len);
+ } else {
+ /* config file doesn't contain any identity
+ generating IMSI@realm */
+ identity_format = EAP_IDENTITY_IMSI_3GPP_REALM;
+ eap_auth_start.user_id_valid = 1;
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP_IDENTITY_IMSI_3GPP_REALM id len %d\n",
+ eap_auth_start.user_id_len);
+ }
+ }
+#endif /* SIM_AKA_IMSI_RAW_ENABLED */
+ if (identity_format == EAP_IDENTITY_IMSI_3GPP_REALM ||
+ identity_format == EAP_IDENTITY_IMSI_RAW || mcc_idx) {
+
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP_IDENTITY_IMSI_3GPP_REALM is selected\n");
+ if (!wpa_qmi_read_card_status(sim_num, eap_proxy->wpa_uim)) {
+ wpa_printf(MSG_INFO, "eap_proxy: Read Card Status failed, return\n");
+ if (NULL != identity) {
+ os_free(identity);
+ identity = NULL;
+ }
+ return FALSE;
+ }
+
+ if (!wpa_qmi_read_card_imsi(sim_num, eap_proxy->wpa_uim)) {
+ wpa_printf(MSG_INFO, "eap_proxy: Read Card IMSI failed, return\n");
+ if (NULL != identity) {
+ os_free(identity);
+ identity = NULL;
+ }
+ return FALSE;
+ }
+
+ if (imsi == NULL) {
+ wpa_printf(MSG_INFO, "eap_proxy: IMSI not available, return\n");
+ if (NULL != identity) {
+ os_free(identity);
+ identity = NULL;
+ }
+ return FALSE;
+ } else {
+ wpa_printf(MSG_ERROR, "eap_proxy: IMSI not NULL \n");
+ if (NULL == identity)
+ wpa_printf(MSG_ERROR,
+ "eap_proxy: config file doesn't contain identity \n");
+ else
+ wpa_printf(MSG_ERROR, "eap_proxy: config file contains identity\n");
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_type: %d\n", eap_proxy->eap_type);
+
+ if (!idx) {
+
+ /* IMSI is expected as username */
+ wpa_printf(MSG_ERROR, "eap_proxy: username is not available in"
+ " config picking IMSI \n");
+
+ if (config->identity_len > 1)
+ /* @realm provided in config */
+ imsi_identity =
+ os_malloc(1 + IMSI_LENGTH + config->identity_len);
+ else if (identity_format == EAP_IDENTITY_IMSI_3GPP_REALM)
+ /* IMSI@realm not provided through config */
+ imsi_identity =
+ os_malloc(1 + IMSI_LENGTH + os_strlen(realm_3gpp));
+ else
+ /* IMSI RAW */
+ imsi_identity = os_malloc(1 + IMSI_LENGTH);
+
+ if (NULL == imsi_identity) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Memory not available\n");
+ if (NULL != identity) {
+ os_free(identity);
+ identity = NULL;
+ }
+ return FALSE;
+ } else {
+ if (config->identity_len > 1)
+ os_memset(imsi_identity, 0,
+ (1 + IMSI_LENGTH + config->identity_len));
+ else if (identity_format == EAP_IDENTITY_IMSI_3GPP_REALM)
+ os_memset(imsi_identity, 0,
+ (1 + IMSI_LENGTH + os_strlen(realm_3gpp)));
+ else
+ os_memset(imsi_identity, 0, (1 + IMSI_LENGTH));
+
+ if (eap_proxy->eap_type == EAP_TYPE_SIM)
+ imsi_identity[0] = '1';
+ else if (eap_proxy->eap_type == EAP_TYPE_AKA)
+ imsi_identity[0] = '0';
+#ifdef CONFIG_EAP_PROXY_AKA_PRIME
+ else if (eap_proxy->eap_type == EAP_TYPE_AKA_PRIME)
+ imsi_identity[0] = '6';
+#endif /* CONFIG_EAP_PROXY_AKA_PRIME */
+ else
+ /* Default value is set as SIM */
+ imsi_identity[0] = '1';
+
+ /* copying IMSI value */
+ os_memcpy(imsi_identity + 1 , imsi , imsi_len_g);
+
+ if (config->identity_len > 1 && NULL != identity) {
+ /* copying realm tag */
+ os_memcpy(imsi_identity + 1 + imsi_len_g , identity,
+ config->identity_len);
+ imsi_id_len = imsi_len_g + 1 + config->identity_len;
+ os_free(identity);
+ identity = NULL;
+ } else if(identity_format == EAP_IDENTITY_IMSI_3GPP_REALM) {
+ /* realm is not available so append it */
+ os_memcpy(imsi_identity + 1 + imsi_len_g,
+ realm_3gpp, os_strlen(realm_3gpp));
+ imsi_id_len = imsi_len_g + 1 +
+ os_strlen(realm_3gpp);
+ } else
+ /* IMSI RAW */
+ imsi_id_len = imsi_len_g + 1;
+ }
+ } else if (identity) {
+ /* idx is non-zero implies username available */
+ imsi_identity = identity;
+ imsi_id_len = config->identity_len;
+ }
+ }
+
+ if (identity_format == EAP_IDENTITY_IMSI_3GPP_REALM || mcc_idx) {
+
+ if (0 == idx) {
+ /* id = @wlan.mnc000.mcc000.<>.<> realm exist
+ but need to insert mnc and mcc values */
+ idx = imsi_len_g + 1;
+ }
+
+ if (imsi_identity != NULL) {
+ /* mcc valus */
+ imsi_identity[idx + 16] = imsi[0];
+ imsi_identity[idx + 17] = imsi[1];
+ imsi_identity[idx + 18] = imsi[2];
+ }
+
+ /* mnc valus */
+ mnc_len = card_mnc_len;
+ wpa_printf(MSG_ERROR, "eap_proxy: card mnc len %d\n", card_mnc_len);
+
+ if ((mnc_len == 2) && (imsi_identity != NULL)) {
+ imsi_identity[idx + 9] = '0';
+ imsi_identity[idx + 10] = imsi[3];
+ imsi_identity[idx + 11] = imsi[4];
+ } else if ((mnc_len == 3) && (imsi_identity != NULL)) {
+ imsi_identity[idx + 9] = imsi[3];
+ imsi_identity[idx + 10] = imsi[4];
+ imsi_identity[idx + 11] = imsi[5];
+ }
+ wpa_printf(MSG_ERROR, "eap_proxy: Appending 3gpp realm\n ");
+ }
+ identity = imsi_identity;
+ identity_len = imsi_id_len;
+ eap_auth_start.user_id_valid = 1;
+ }
+
+ eap_auth_start.user_id_len = identity_len;
+
+ if(identity_len >= QMI_AUTH_EAP_IDENTITY_MAX_CHAR_V01)
+ {
+ wpa_printf(MSG_ERROR, "eap_proxy: Invalid User Identity length =%d",identity_len);
+ return FALSE;
+ }
+
+ if(identity)
+ {
+ memcpy(&eap_auth_start.user_id, identity, identity_len);
+ eap_auth_start.user_id_valid = 1;
+ }
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap auth user identity - %20s length-%d\n ",
+ eap_auth_start.user_id, eap_auth_start.user_id_len);
+
+ if ( (sim_num < 0) || (sim_num >= MAX_NO_OF_SIM_SUPPORTED)) {
+ wpa_printf(MSG_ERROR, "eap_proxy: SIM: Invalid SIM selected by "
+ "User: Selected sim = %d\n", sim_num+1);
+ return FALSE;
+ }
+
+
+ eap_proxy->user_selected_sim = sim_num;
+ wpa_printf(MSG_ERROR, "eap_proxy: SIM selected by User: Selected sim = %d\n",
+ eap_proxy->user_selected_sim+1);
+
+ memset(&sub_req_binding, 0, sizeof(auth_set_subscription_binding_req_msg_v01));
+ memset(&sub_resp_binding, 0, sizeof(auth_set_subscription_binding_resp_msg_v01));
+#ifdef CONFIG_EAP_PROXY_DUAL_SIM
+ if (sim_num == 0) {
+ sub_req_binding.bind_subs = AUTH_PRIMARY_SUBS_V01;
+ qmiRetCode = qmi_client_send_msg_sync(eap_proxy->qmi_auth_svc_client_ptr[sim_num],
+ QMI_AUTH_SET_SUBSCRIPTION_BINDING_REQ_V01,
+ (void *) &sub_req_binding,
+ sizeof(auth_set_subscription_binding_req_msg_v01),
+ (void *) &sub_resp_binding,
+ sizeof(auth_set_subscription_binding_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+
+ if ((QMI_NO_ERR != qmiRetCode ||
+ sub_resp_binding.resp.result != QMI_RESULT_SUCCESS_V01 ) &&
+ (QMI_ERR_OP_DEVICE_UNSUPPORTED_V01 != sub_resp_binding.resp.error)) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Unable to get the qmi_auth_set_subscriptio"
+ "n_binding for sim 1; error_ret=%d; error_code=%d\n", qmiRetCode,
+ sub_resp_binding.resp.error);
+ return FALSE;
+ }
+ wpa_printf (MSG_ERROR, "eap_proxy: Binded with PRIMARY Subscription\n");
+ } else if (sim_num == 1) {
+ sub_req_binding.bind_subs = AUTH_SECONDARY_SUBS_V01;
+ qmiRetCode = qmi_client_send_msg_sync(eap_proxy->qmi_auth_svc_client_ptr[sim_num],
+ QMI_AUTH_SET_SUBSCRIPTION_BINDING_REQ_V01,
+ (void *) &sub_req_binding,
+ sizeof(auth_set_subscription_binding_req_msg_v01),
+ (void *) &sub_resp_binding,
+ sizeof(auth_set_subscription_binding_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+
+ if (QMI_NO_ERR != qmiRetCode ||
+ sub_resp_binding.resp.result != QMI_RESULT_SUCCESS_V01 ) {
+ wpa_printf(MSG_ERROR, "QMI-ERROR Unable to get the qmi_auth_set_subscriptio"
+ "n_binding for sim 2; error_ret=%d; error_code=%d\n", qmiRetCode,
+ sub_resp_binding.resp.error);
+ return FALSE;
+ }
+
+ wpa_printf (MSG_ERROR, "eap_proxy: Binded with SECONDARY Subscription\n");
+ } else {
+ wpa_printf(MSG_ERROR, "eap_proxy: Invalid SIM selected by User: "
+ "Selected sim = %d\n", sim_num+1);
+ return FALSE;
+ }
+#endif
+ if (TRUE == eap_proxy->eap_auth_session_flag[sim_num]) {
+ if(eap_auth_end_eap_session(eap_proxy->qmi_auth_svc_client_ptr[sim_num]) < 0) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Unable to end the EAP session;"
+ " sim_num%d;", sim_num);
+ }
+ eap_proxy->eap_auth_session_flag[sim_num] = FALSE;
+ }
+
+ if (FALSE == eap_proxy->eap_auth_session_flag[sim_num]) {
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_auth_start values\n");
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_auth_start.eap_method_mask = %d\n",
+ eap_auth_start.eap_method_mask);
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_auth_start.user_id_len = %d\n",
+ eap_auth_start.user_id_len);
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_auth_start.eap_meta_id_len = %d\n",
+ eap_auth_start.eap_meta_identity_len);
+ wpa_printf(MSG_ERROR, "eap_auth_start.eap_sim_aka_algo = %d\n",
+ eap_auth_start.eap_sim_aka_algo);
+ qmiRetCode = qmi_client_send_msg_sync(eap_proxy->qmi_auth_svc_client_ptr[sim_num],
+ QMI_AUTH_START_EAP_SESSION_REQ_V01,
+ (void *) &eap_auth_start,
+ sizeof(auth_start_eap_session_req_msg_v01),
+ (void *) &eap_auth_start_resp,
+ sizeof(auth_start_eap_session_resp_msg_v01),
+ WPA_UIM_QMI_DEFAULT_TIMEOUT);
+ if (QMI_NO_ERR != qmiRetCode ||
+ eap_auth_start_resp.resp.result != QMI_RESULT_SUCCESS_V01) {
+ wpa_printf(MSG_ERROR, " QMI-ERROR Unable to start the EAP session;"
+ " error_ret=%d; qmi_err=%d\n", qmiRetCode,
+ eap_auth_start_resp.resp.error);
+ if(eap_auth_start.eap_method_mask == QMI_AUTH_EAP_METHOD_MASK_AKA_PRIME_V01 &&
+ eap_auth_start_resp.resp.error == QMI_ERR_INVALID_ARG_V01)
+ wpa_printf(MSG_ERROR, "QMI-ERROR AKA' not supported\n");
+
+ return FALSE;
+ }
+ eap_proxy->eap_auth_session_flag[sim_num] = TRUE;
+ eap_proxy->notification_code = 0;
+ eap_proxy->qmi_state = QMI_STATE_IDLE;
+ wpa_printf(MSG_ERROR, "eap_proxy: EAP session started"
+ " error_ret=%d; Resp=%d\n", qmiRetCode,
+ eap_auth_start_resp.resp.error);
+ }
+
+ return TRUE;
+}
+
+
+
+#ifdef CONFIG_CTRL_IFACE
+
+/**
+ * eap_proxyl_sm_get_status - Get EAP state machine status
+ * @sm: Pointer to EAP state machine allocated with eap_sm_init()
+ * @buf: Buffer for status information
+ * @buflen: Maximum buffer length
+ * @verbose: Whether to include verbose status information
+ * Returns: Number of bytes written to buf.
+ *
+ * Query EAP state machine for status information. This function fills in a
+ * text area with current status information from the EAPOL state machine. If
+ * the buffer (buf) is not large enough, status information will be truncated
+ * to fit the buffer.
+ */
+int eap_proxy_sm_get_status(struct eap_proxy_sm *sm, char *buf, size_t buflen,
+ int verbose)
+{
+ int len, ret;
+
+ if (sm == NULL)
+ return 0;
+
+ len = os_snprintf(buf, buflen, "eap_proxy: EAP state=%s\n",
+ eap_proxy_sm_state_txt(sm->proxy_state));
+ if (len < 0 || (size_t)len >= buflen)
+ return 0;
+
+ if (sm->eap_type != EAP_TYPE_NONE) {
+ char name[8];
+
+ if (sm->eap_type == EAP_TYPE_SIM)
+ os_strlcpy(name, "SIM", 4);
+ else if (sm->eap_type == EAP_TYPE_AKA)
+ os_strlcpy(name, "AKA", 4);
+ else if (sm->eap_type == EAP_TYPE_AKA_PRIME)
+ os_strlcpy(name, "AKA'", 5);
+ else
+ os_strlcpy(name, "Unknown", 8);
+
+ ret = os_snprintf(buf + len, buflen - len,
+ "selectedMethod=%d (EAP-%s)\n",
+ sm->eap_type, name);
+ if (ret < 0 || (size_t)ret >= buflen - len)
+ return len;
+ len += ret;
+ }
+
+ return len;
+}
+
+
+static const char *eap_proxy_sm_state_txt(int state)
+{
+ switch (state) {
+ case EAP_PROXY_INITIALIZE:
+ return "INITIALIZE";
+ case EAP_PROXY_DISABLED:
+ return "DISABLED";
+ case EAP_PROXY_IDLE:
+ return "IDLE";
+ case EAP_PROXY_RECEIVED:
+ return "RECEIVED";
+ case EAP_PROXY_GET_METHOD:
+ return "GET_METHOD";
+ case EAP_PROXY_METHOD:
+ return "METHOD";
+ case EAP_PROXY_SEND_RESPONSE:
+ return "SEND_RESPONSE";
+ case EAP_PROXY_DISCARD:
+ return "DISCARD";
+ case EAP_PROXY_IDENTITY:
+ return "IDENTITY";
+ case EAP_PROXY_NOTIFICATION:
+ return "NOTIFICATION";
+ case EAP_PROXY_RETRANSMIT:
+ return "RETRANSMIT";
+ case EAP_PROXY_AUTH_SUCCESS:
+ return "SUCCESS";
+ case EAP_PROXY_AUTH_FAILURE:
+ return "FAILURE";
+ default:
+ return "UNKNOWN";
+ }
+}
+#endif /* CONFIG_CTRL_IFACE */
+
+
+/**
+ * eap_proxy_get_mcc_mnc - Get MCC/MNC
+ * @imsi_buf: Buffer for returning IMSI
+ * @imsi_len: Buffer for returning IMSI length
+ * Returns: MNC length (2 or 3) or -1 on error
+ */
+int eap_proxy_get_imsi(struct eap_proxy_sm *eap_proxy, char *imsi_buf,
+ size_t *imsi_len)
+{
+#ifdef SIM_AKA_IDENTITY_IMSI
+ int mnc_len;
+ int sim_num = eap_proxy->user_selected_sim;
+
+ if ((eap_proxy->proxy_state == EAP_PROXY_DISABLED) ||
+ (eap_proxy->proxy_state == EAP_PROXY_INITIALIZE)) {
+ wpa_printf(MSG_ERROR, "eap_proxy:%s: Not initialized\n", __func__);
+ return FALSE;
+ }
+ if (!wpa_qmi_read_card_status(sim_num, eap_proxy->wpa_uim)) {
+ wpa_printf(MSG_INFO, "eap_proxy: Card not ready");
+ return -1;
+ }
+
+ if (!wpa_qmi_read_card_imsi(sim_num, eap_proxy->wpa_uim) || imsi == NULL) {
+ wpa_printf(MSG_INFO, "eap_proxy: Failed to read card IMSI");
+ return -1;
+ }
+
+ *imsi_len = os_strlen(imsi);
+ os_memcpy(imsi_buf, imsi, *imsi_len + 1);
+
+ mnc_len = card_mnc_len;
+ if (mnc_len < 2 || mnc_len > 3)
+ mnc_len = 3; /* Default to 3 if MNC length is unknown */
+
+ os_free(imsi);
+ imsi = NULL;
+
+ return mnc_len;
+#else /* SIM_AKA_IDENTITY_IMSI */
+ return -1;
+#endif /* SIM_AKA_IDENTITY_IMSI */
+}
+
+int eap_proxy_notify_config(struct eap_proxy_sm *eap_proxy,
+ struct eap_peer_config *config)
+{
+ int ret_val;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_proxy_notify_config\n");
+ if (!eap_proxy) {
+ wpa_printf(MSG_ERROR, "eap_proxy: is NULL");
+ return FALSE;
+ }
+
+ if ((eap_proxy->proxy_state == EAP_PROXY_DISABLED) ||
+ (eap_proxy->proxy_state == EAP_PROXY_INITIALIZE)) {
+ wpa_printf(MSG_ERROR, "eap_proxy: Not initialized\n");
+ return FALSE;
+ }
+
+ if ( config && eap_proxy_allowed_method(config, EAP_VENDOR_IETF,
+ EAP_TYPE_SIM)) {
+ eap_proxy->eap_type = EAP_TYPE_SIM;
+ ret_val = TRUE;
+ } else if ( config && eap_proxy_allowed_method(config, EAP_VENDOR_IETF,
+ EAP_TYPE_AKA)) {
+ eap_proxy->eap_type = EAP_TYPE_AKA;
+ ret_val = TRUE;
+ } else if ( config && eap_proxy_allowed_method(config, EAP_VENDOR_IETF,
+ EAP_TYPE_AKA_PRIME)) {
+ eap_proxy->eap_type = EAP_TYPE_AKA_PRIME;
+ ret_val = TRUE;
+ } else
+ ret_val = FALSE;
+
+ return ret_val;
+}
+
+int eap_proxy_allowed_method(struct eap_peer_config *config, int vendor,
+ u32 method)
+{
+ int i;
+ struct eap_method_type *m;
+
+ wpa_printf(MSG_ERROR, "eap_proxy: eap_proxy_allowed_method");
+ if (config == NULL || config->eap_methods == NULL)
+ return -1;
+
+ m = config->eap_methods;
+ for (i = 0; m[i].vendor != EAP_VENDOR_IETF ||
+ m[i].method != EAP_TYPE_NONE; i++) {
+ if (m[i].vendor == vendor && m[i].method == method)
+ return 1;
+ }
+ return 0;
+}
+
+#endif /* CONFIG_EAP_PROXY */
diff --git a/src/eap_peer/eap_proxy_qmi_oc.h b/src/eap_peer/eap_proxy_qmi_oc.h
new file mode 100644
index 0000000..f597afd
--- /dev/null
+++ b/src/eap_peer/eap_proxy_qmi_oc.h
@@ -0,0 +1,140 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2013, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials provided
+ with the distribution.
+ * Neither the name of The Linux Foundation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+
+#ifndef EAP_PROXY_QMI_H
+#define EAP_PROXY_QMI_H
+
+
+#include "eap_i.h"
+#include "eap_config.h"
+#include "eloop.h"
+#include "eapol_supp/eapol_supp_sm.h"
+#include "user_identity_module_v01.h"
+
+/*msec Response Timeout*/
+#define QMI_RESP_TIME_OUT 2000
+#define EAP_PROXY_KEYING_DATA_LEN 64
+
+#ifdef CONFIG_EAP_PROXY_DUAL_SIM
+#define MAX_NO_OF_SIM_SUPPORTED 2
+#else
+#define MAX_NO_OF_SIM_SUPPORTED 1
+#endif /* CONFIG_EAP_PROXY_DUAL_SIM */
+
+typedef enum {
+ QMI_STATE_IDLE = 0x00,
+ QMI_STATE_RESP_PENDING = 0x01,
+ QMI_STATE_RESP_RECEIVED = 0x02,
+ QMI_STATE_RESP_TIME_OUT = 0x03
+} qmi_state_e;
+
+typedef enum {
+ EAP_PROXY_QMI_SRVC_NO_RESULT,
+ EAP_PROXY_QMI_SRVC_SUCCESS,
+ EAP_PROXY_QMI_SRVC_FAILURE
+} eap_proxy_qmi_srv_result;
+
+/* should match the EAP_state of eap_i.h */
+typedef enum {
+ EAP_PROXY_INITIALIZE, EAP_PROXY_DISABLED, EAP_PROXY_IDLE, EAP_PROXY_RECEIVED,
+ EAP_PROXY_GET_METHOD, EAP_PROXY_METHOD, EAP_PROXY_SEND_RESPONSE,
+ EAP_PROXY_DISCARD, EAP_PROXY_IDENTITY, EAP_PROXY_NOTIFICATION,
+ EAP_PROXY_RETRANSMIT,
+ EAP_PROXY_AUTH_SUCCESS, EAP_PROXY_AUTH_FAILURE
+} eap_proxy_state;
+
+
+enum eap_proxy_status {
+ EAP_PROXY_FAILURE = 0x00,
+ EAP_PROXY_SUCCESS
+};
+
+typedef enum {
+ EAP_IDENTITY_ANNONYMOUS = 0x00,
+ EAP_IDENTITY_IMSI_RAW = 0x02,
+ EAP_IDENTITY_IMSI_3GPP_REALM = 0x03,
+ EAP_IDENTITY_IMSI_REALM = 0x04,
+ EAP_IDENTITY_CFG_RAW = 0x05,
+ EAP_IDENTITY_CFG_3GPP_REALM = 0x06,
+ EAP_IDENTITY_CFG_REALM = 0x07,
+} eap_identity_format_e;
+
+typedef union
+{
+ struct
+ {
+ void *resp_data; /* Pointer to the Response Packet*/
+ unsigned long length; /*Length of the Response Packet*/
+ }eap_send_pkt_resp;
+
+}qmi_eap_sync_rsp_data_type;
+
+typedef struct {
+ uim_card_state_enum_v01 card_state;
+ uim_card_error_code_enum_v01 card_error_code;
+ u8 app_state;
+ u8 app_type;
+} wpa_uim_card_info_type;
+
+typedef struct {
+ int card_ready_idx;
+ wpa_uim_card_info_type card_info[QMI_UIM_CARDS_MAX_V01];
+ qmi_client_type qmi_uim_svc_client_ptr;
+ int qmi_msg_lib_handle;
+} wpa_uim_struct_type;
+
+
+struct eap_proxy_sm {
+ qmi_client_type qmi_auth_svc_client_ptr[MAX_NO_OF_SIM_SUPPORTED];
+ qmi_state_e qmi_state;
+ eap_proxy_qmi_srv_result srvc_result;
+ qmi_eap_sync_rsp_data_type qmi_resp_data;
+ eap_proxy_state proxy_state;
+ Boolean iskey_valid;
+ u8 *key;
+ Boolean is_state_changed;
+ void *ctx;
+ void *msg_ctx;
+ struct eapol_callbacks *eapol_cb;
+ u8 *eapReqData;
+ size_t eapReqDataLen;
+ Boolean isEap;
+ int eap_type;
+ int user_selected_sim;
+ int eap_auth_session_flag[MAX_NO_OF_SIM_SUPPORTED];
+ int notification_code;
+ pthread_t thread_id;
+ wpa_uim_struct_type wpa_uim[MAX_NO_OF_SIM_SUPPORTED];
+ Boolean qmi_uim_svc_client_initialized[MAX_NO_OF_SIM_SUPPORTED];
+};
+
+int eap_proxy_allowed_method(struct eap_peer_config *config, int vendor,
+ u32 method);
+
+#endif /* EAP_PROXY_QMI_H */
diff --git a/wpa_supplicant/eap_proxy_qmi_oc.mak b/wpa_supplicant/eap_proxy_qmi_oc.mak
new file mode 100644
index 0000000..0a046f6
--- /dev/null
+++ b/wpa_supplicant/eap_proxy_qmi_oc.mak
@@ -0,0 +1,19 @@
+CFLAGS += -DSIM_AKA_IDENTITY_IMSI
+CFLAGS += -DSIM_AKA_IMSI_RAW_ENABLED
+
+CFLAGS += $(shell $(PKG_CONFIG) --cflags qmi qmi-framework)
+
+LIBS += $(shell $(PKG_CONFIG) --libs qmi qmi-framework) -lpthread
+
+# EAP-AKA' (enable CONFIG_PCSC, if EAP-AKA' is used).
+# This requires CONFIG_EAP_AKA to be enabled, too.
+# This is supported only in B Family devices.
+CONFIG_EAP_AKA_PRIME=y
+
+ifdef CONFIG_EAP_PROXY_AKA_PRIME
+CFLAGS += -DCONFIG_EAP_PROXY_AKA_PRIME
+endif
+
+ifdef CONFIG_EAP_PROXY_DUAL_SIM
+CFLAGS += -DCONFIG_EAP_PROXY_DUAL_SIM
+endif
diff --git a/wpa_supplicant/eap_proxy_qmi_oc.mk b/wpa_supplicant/eap_proxy_qmi_oc.mk
new file mode 100644
index 0000000..fe0a4a9
--- /dev/null
+++ b/wpa_supplicant/eap_proxy_qmi_oc.mk
@@ -0,0 +1,37 @@
+
+LOCAL_PATH := $(call my-dir)
+
+ifeq ($(BOARD_HAS_QCOM_WLAN), true)
+L_CFLAGS += -DSIM_AKA_IDENTITY_IMSI
+#L_CFLAGS += -DSIM_AKA_IMSI_RAW_ENABLED
+
+ifdef CONFIG_EAP_PROXY_DUAL_SIM
+L_CFLAGS += -DCONFIG_EAP_PROXY_DUAL_SIM
+endif
+
+LIB_SHARED_EAP_PROXY := libqmi_cci libqmiservices libidl
+INCLUDES += $(TARGET_OUT_HEADERS)/qmi-framework/inc
+INCLUDES += $(TARGET_OUT_HEADERS)/qmi/inc
+INCLUDES += $(TARGET_OUT_HEADERS)/qmi/platform
+INCLUDES += $(TARGET_OUT_HEADERS)/qmi/core/lib/inc
+
+ifdef CONFIG_EAP_PROXY_MDM_DETECT
+L_CFLAGS += -DCONFIG_EAP_PROXY_MDM_DETECT
+INCLUDES += $(TARGET_OUT_HEADERS)/libmdmdetect/inc
+LIB_SHARED_EAP_PROXY += libmdmdetect
+endif
+
+# EAP-AKA' (enable CONFIG_PCSC, if EAP-AKA' is used).
+# This requires CONFIG_EAP_AKA to be enabled, too.
+# This is supported only in B Family devices.
+ifdef CONFIG_EAP_PROXY_AKA_PRIME
+L_CFLAGS += -DCONFIG_EAP_PROXY_AKA_PRIME
+endif
+
+ifdef CONFIG_EAP_PROXY_MSM8994_TARGET
+L_CFLAGS += -DCONFIG_EAP_PROXY_MSM8994_TARGET
+endif
+
+#ANDROID_SETGROUPS_OVERRIDE := AID_RADIO AID_WIFI AID_KEYSTORE AID_DIAG AID_INET AID_QCOM_DIAG AID_NET_RAW
+L_CFLAGS += -DANDROID_SETGROUPS_OVERRIDE=1001,1010,1017,2002,1003,3009,3004
+endif