path: root/src/tapi.c

/*
 *  pwlock
 *
 * Copyright 2012  Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://floralicense.org/license/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <stdio.h>
#include <vconf.h>

#include "util.h"
#include "tapi.h"
#include "langs.h"

#ifndef PACKAGE_NAME
#define PACKAGE_NAME "org.tizen.pwlock"
#endif

static struct tapi_event tapi_events[] = {
	{TAPI_NOTI_MODEM_POWER, pwlock_tapi_noti_modem_power_cb,},
	{TAPI_NOTI_SIM_STATUS, pwlock_tapi_noti_sim_status_cb,},
};

static int _pwlock_tapi_register_noti_events(struct tapi *t)
{
	int r;
	int i;

	if (t == NULL)
		return -1;

	for (i = 0; i < t->evt_sz; i++) {
		r = tel_register_noti_event(t->handle, t->evt[i].event, t->evt[i].tapi_notification_cb, t);
		_DBG("TAPI register event : %s", t->evt[i].event);
		if (r != TAPI_API_SUCCESS) {
			_ERR("TAPI register event %s return %d",
			     t->evt[i].event, r);
			return -1;
		}
	}

	return 0;
}

static void _pwlock_tapi_deregister_noti_events(struct tapi *t)
{
	int r;
	int i;

	if (t == NULL)
		return;


	for (i = 0; i < t->evt_sz; i++) {
		r = tel_deregister_noti_event(t->handle, t->evt[i].event);
		if (r == TAPI_API_SUCCESS)
			_DBG("TAPI [%s] event unregister success", t->evt[i].event);
		else
			_ERR("TAPI [%s] event unregister return %d", t->evt[i].event, r);
	}
}

void pwlock_tapi_get_sim_lock_info_cb(TapiHandle *handle, int result, void *data, void *user_data)
{
	TelSimPinOperationResult_t sec_rt = result;
	TelSimLockInfo_t *lock = data;
	struct tapi *t = user_data;
	struct pwlock_tapi_info ti;

	_DBG("%s", __func__);

	_DBG("TAPI_SERVICE_SIM lock info reponse received");
	_DBG("set_rt[%d]", sec_rt);
	_DBG("lock->lock_type[%d]", lock->lock_type);
	_DBG("lock->lock_status[%d]-0:not need, 1:pin, 2:puk, 3:pin2, 4:puk2, 5:blocked", lock->lock_status);
	_DBG("lock->retry_count[%d]", lock->retry_count);

	ti.st = SIM_LOCK_INFO;
	ti.retry_cnt = lock->retry_count;
	
	if (t->cb)
		t->cb(&ti, t->cb_data);
}

void pwlock_tapi_noti_modem_power_cb(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
{
	;
}

void pwlock_tapi_noti_sim_status_cb(TapiHandle *handle, const char *noti_id, void *data, void *user_data)
{
	TelSimCardStatus_t *sim_status = data;
	struct tapi *t = user_data;
	struct pwlock_tapi_info ti;

	if (sim_status == NULL) {
		_ERR("pwlock_tapi_noti_sim_status_cb:status is null");
		return ;
	}

	_DBG("Sim status: 0x%x", *sim_status);

	memset(&ti, 0, sizeof(ti));

	switch (*sim_status) {
	case TAPI_SIM_STATUS_SIM_PIN_REQUIRED:
	case TAPI_SIM_STATUS_SIM_PUK_REQUIRED:
	case TAPI_SIM_STATUS_SIM_NCK_REQUIRED:
	case TAPI_SIM_STATUS_SIM_NSCK_REQUIRED:
	case TAPI_SIM_STATUS_SIM_SPCK_REQUIRED:
	case TAPI_SIM_STATUS_SIM_CCK_REQUIRED:
	case TAPI_SIM_STATUS_SIM_LOCK_REQUIRED:
		ti.st = SIM_REQUIRED_EVENT;
		break;
	case TAPI_SIM_STATUS_CARD_ERROR:
		ti.st = SIM_ERROR;
		break;
	case TAPI_SIM_STATUS_SIM_INITIALIZING:
		ti.st = SIM_WAITING;
		break;
	default:
		ti.st = SIM_OK;
		break;
	}

	if (t->cb)
		t->cb(&ti, t->cb_data);
}

void pwlock_tapi_verify_sim_pins_and_puks_cb(TapiHandle *handle, int result, void *data, void *user_data)
{
	TelSimPinOperationResult_t sec_rt = result;
	TelSimSecResult_t *res = data;
	struct tapi *t = user_data;
	struct pwlock_tapi_info ti;

	if (t == NULL) {
		_ERR("pwlock_tapi_verify_sim_pins_cb:struct tapi is null");
		return ;
	}
	if (res == NULL) {
		_ERR("pwlock_tapi_verify_sim_pins_cb:res is null");
		return ;
	}

	_DBG("sim pin/puk check result: 0x%x", sec_rt);

	memset(&ti, 0, sizeof(ti));

	switch (sec_rt) {
	/*
	case TAPI_SIM_OPERATION_TIMEOUT:
		_DBG("\tTimeout");
		ti.st = SIM_ERROR;
		break;
	*/
	case TAPI_SIM_PIN_OPERATION_SUCCESS:
		_DBG("\tType: %d", res->type);
		ti.st = SIM_OK;
		break;
	case TAPI_SIM_PIN_REQUIRED:
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_PIN;
		ti.retry_cnt = res->retry_count;
		break;
	case TAPI_SIM_PUK_REQUIRED:
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_PUK;
		ti.retry_cnt = res->retry_count;
		break;
	case TAPI_SIM_LOCK_REQUIRED:
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_LOCK;
		ti.retry_cnt = res->retry_count;
		break;
	case TAPI_SIM_NCK_REQUIRED:		/**< Network Control Key Required */
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_NCK;
		break;
	case TAPI_SIM_NSCK_REQUIRED:	/**< Network Subset Control Key Required */
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_NSCK;
		break;
	case TAPI_SIM_SPCK_REQUIRED:	/**< Service Provider Control Key Required */
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_SPCK;
		break;
	case TAPI_SIM_CCK_REQUIRED:
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_CCK;
		break;
	default:
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		if (res->type == TAPI_SIM_PTYPE_SIM)
			ti.st = SIM_REQ_LOCK;
		else
			ti.st = SIM_RETRY;
		ti.retry_cnt = res->retry_count;
		break;
	}

	_DBG("tapi_cb ti.st: %d", ti.st);

	if (t->cb)
		t->cb(&ti, t->cb_data);
}

void pwlock_tapi_disable_sim_facility_cb(TapiHandle *handle, int result, void *data, void *user_data)
{
	TelSimPinOperationResult_t sec_rt = result;
	TelSimSecResult_t *res = data;
	struct tapi *t = user_data;
	struct pwlock_tapi_info ti;

	if (t == NULL) {
		_ERR("pwlock_tapi_verify_sim_pins_cb:struct tapi is null");
		return ;
	}
	if (res == NULL) {
		_ERR("pwlock_tapi_verify_sim_pins_cb:res is null");
		return ;
	}

	_DBG("PER setting result: 0x%x", sec_rt);

	memset(&ti, 0, sizeof(ti));

	switch (sec_rt) {
	/*
	case TAPI_SIM_OPERATION_TIMEOUT:
		_DBG("\tTimeout");
		ti.st = SIM_ERROR;
		break;
	*/
	case TAPI_SIM_PIN_OPERATION_SUCCESS:
		_DBG("\tType: %d", res->type);
		ti.st = SIM_OK;
		break;
	case TAPI_SIM_NCK_REQUIRED:		/**< Network Control Key Required */
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_NCK;
		break;
	case TAPI_SIM_NSCK_REQUIRED:		/**< Network Subset Control Key Required */
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_NSCK;
		break;
	case TAPI_SIM_SPCK_REQUIRED:		/**< Service Provider Control Key Required */
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_SPCK;
		break;
	case TAPI_SIM_CCK_REQUIRED:
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_CCK;
		break;
	default:
		_DBG("\tType: %d", res->type);
		_DBG("\tRetry: %d", res->retry_count);
		ti.st = SIM_REQ_LOCK;
		break;
	}

	/*  TODO: retry or error??? */
	if (t->cb)
		t->cb(&ti, t->cb_data);
}

static enum sim_stat check_sim(TelSimCardStatus_t stat)
{
	enum sim_stat r;
	switch (stat) {
	case TAPI_SIM_STATUS_CARD_NOT_PRESENT:	/*  Card not present. */
	case TAPI_SIM_STATUS_CARD_REMOVED:	/* Card removed. */
		r = SIM_EMPTY;
		break;
		/* case 0xFF: // Sim is Initializing state.      //the value is not in TelSimCardStatus_t, remove it */
	case TAPI_SIM_STATUS_SIM_INITIALIZING:	/*  Sim is Initializing state. */
		r = SIM_WAITING;
		break;
	case TAPI_SIM_STATUS_SIM_INIT_COMPLETED:	/* Sim Initialization ok. */
		r = SIM_OK;
		break;
	case TAPI_SIM_STATUS_SIM_PIN_REQUIRED:	/* PIN required state. */
		r = SIM_REQ_PIN;
		break;
	case TAPI_SIM_STATUS_SIM_PUK_REQUIRED:	/* PUK required state. */
		r = SIM_REQ_PUK;
		break;
	case TAPI_SIM_STATUS_CARD_BLOCKED:	/* PIN/PUK blocked(permanently blocked) */
		r = SIM_BLOCKED;
		break;
	case TAPI_SIM_STATUS_SIM_LOCK_REQUIRED:	/* PH-SIM (phone-sim) locked state. */
		r = SIM_REQ_LOCK;
		break;
	case TAPI_SIM_STATUS_SIM_NCK_REQUIRED:	/* Network Control Key required state. */
		r = SIM_REQ_NCK;
		break;
	case TAPI_SIM_STATUS_SIM_NSCK_REQUIRED:	/* Network Subset Control Key required state. */
		r = SIM_REQ_NSCK;
		break;
	case TAPI_SIM_STATUS_SIM_SPCK_REQUIRED:	/* Service Provider Control Key required state. */
		r = SIM_REQ_SPCK;
		break;
	case TAPI_SIM_STATUS_SIM_CCK_REQUIRED:	/* Corporate Control Key required state. */
		r = SIM_REQ_CCK;
		break;
	case 0xff:		/* for tapi default value, timing issue */
		r = SIM_RETRY;
		break;
		/* TODO: implement more locks... */
	case TAPI_SIM_STATUS_CARD_ERROR:	/* Bad card , On the fly SIM gone bad. */
	default:
		r = SIM_ERROR;
		break;
	}
	return r;
}

enum sim_stat pwlock_tapi_check_sim(struct tapi *t, int *changed)
{
	TapiResult_t r = TAPI_API_SUCCESS;
	int card_changed = 0;
	enum sim_stat res = -1;
	TelSimCardStatus_t st = 0x00;

	_DBG("Enum size: %d", sizeof(st));
	r = tel_get_sim_init_info(t->handle, &st, &card_changed);

	_DBG("tel_get_sim_init_info return %d, sim state: %d", r, st);

	if (r == TAPI_API_SUCCESS) {
		*changed = card_changed;
		_DBG("Get tapi sim status: 0x%x card changed: %d", st,
		     *changed);
	}

	switch (r) {
	case TAPI_API_SERVICE_NOT_READY:
		res = SIM_RETRY;
		break;
	case TAPI_API_SUCCESS:
		res = check_sim(st);
		break;
	default:
		res = SIM_ERROR;
		break;
	}

	return res;
}

int pwlock_tapi_ready_check(void)
{
	int api_ret = 0;
	int vconf_val = 0;

	_DBG("%s", __func__);

	api_ret = vconf_get_int(VCONFKEY_TELEPHONY_TAPI_STATE, &vconf_val);
	if (api_ret != 0) {
		/*
		   if appn check very fast before telephony boot up, telephony can not be ready yet
		   in this point, appn should register vconf callback fuction with timer
		   timer will be used to waiting telephony boot up with limitation.
		   user should set proper time. (currently it`s up to experience)
		 */
		_DBG("fail to get vconf key value. this means telephony does not start");
	} else {
		if (vconf_val == VCONFKEY_TELEPHONY_TAPI_STATE_NONE) {
			_DBG("TAPI is not ready");
		} else {
			_DBG("TAPI is ready");
		}
	}
	return vconf_val;
}

int pwlock_tapi_get_sim_lock_info(struct tapi* t)
{
	int r;
	TelSimLockType_t pin_type = 0;

	_DBG("%s", __func__);
	
	pin_type = TAPI_SIM_LOCK_SC;

	r = tel_get_sim_lock_info(t->handle, pin_type, pwlock_tapi_get_sim_lock_info_cb, t);

	_DBG("tel_get_sim_lock_info result : %d", r);

	return 0;
}

static int verify_pins(struct tapi *t, char *code, int type)
{
	int r;
	TelSimSecPw_t pin;

	memset(&pin, 0, sizeof(pin));
	pin.type = type;
	pin.pw_len = strlen(code);
	pin.pw = (unsigned char *)code;

	_DBG("SIM PIN/PUK verifying...");

	r = tel_verifiy_sim_pins(t->handle, &pin, pwlock_tapi_verify_sim_pins_and_puks_cb, t);

	if (r != TAPI_API_SUCCESS) {
		_ERR("TAPI verify pins error %d", r);
		return -1;
	}

	return 0;
}

int pwlock_tapi_verify_pins(struct tapi *t, char *code)
{
	if (t == NULL)
		return -1;

	if (code == NULL || code[0] == '\0')
		return -1;

	return verify_pins(t, code, TAPI_SIM_PTYPE_PIN1);
}

int pwlock_tapi_verify_lock(struct tapi *t, char *code)
{
	if (t == NULL)
		return -1;

	if (code == NULL || code[0] == '\0')
		return -1;

	return verify_pins(t, code, TAPI_SIM_PTYPE_SIM);
}

int pwlock_tapi_verify_puks(struct tapi *t, char *code, char *newcode)
{
	int r;
	TelSimSecPw_t puk, pin;

	if (code == NULL || code[0] == '\0'
	    || newcode == NULL || newcode[0] == '\0')
		return -1;

	memset(&puk, 0, sizeof(puk));
	puk.type = TAPI_SIM_PTYPE_PUK1;
	puk.pw_len = strlen(code);
	puk.pw = (unsigned char *)code;

	memset(&pin, 0, sizeof(pin));
	pin.type = TAPI_SIM_PTYPE_PIN1;
	pin.pw_len = strlen(newcode);
	pin.pw = (unsigned char *)newcode;

	r = tel_verify_sim_puks(t->handle, &puk, &pin, pwlock_tapi_verify_sim_pins_and_puks_cb, t);
	if (r != TAPI_API_SUCCESS)
		return -1;

	return 0;
}

int pwlock_tapi_disable_net_pers(struct tapi *t, char *code, TelSimLockType_t type)
{
	int err_code = TAPI_API_SUCCESS;

	if (code == NULL || code[0] == '\0')
		return -1;

	TelSimFacilityPw_t facility_pw = { 0, };
	facility_pw.lock_type = type;
	facility_pw.pw = (unsigned char *)code;
	facility_pw.pw_len = strlen(code);

	err_code = tel_disable_sim_facility(t->handle, &facility_pw, pwlock_tapi_disable_sim_facility_cb, t);

	if (err_code != TAPI_API_SUCCESS) {
		_ERR("TAPI API FAIL: Error Code [0x%x]", err_code);
		return -1;
	}
	/* WAIT EVENT RESPONSE FROM HERE */
	return 0;
}

struct tapi *pwlock_tapi_init(void (*cb) (struct pwlock_tapi_info *, void *), void *data)
{
	int r;
	struct appdata *ad = (struct appdata *)data;
	struct tapi *t;
	TapiHandle *tapi_handle = NULL;

	if (ad == NULL) {
		_ERR("TAPI init error: ad is null");
		return NULL;
	}

	if (cb == NULL)
		return NULL;

	tapi_handle = tel_init(NULL);
	if (tapi_handle == NULL) {
		_ERR("TAPI init error");
		return NULL;
	}
	_DBG("TAPI init");

	t = calloc(1, sizeof(struct tapi));
	if (t == NULL) {
		_ERR("TAPI alloc data error");
		goto err;
	}
	t->handle = tapi_handle;
	t->evt = tapi_events;
	t->evt_sz = sizeof(tapi_events) / sizeof(tapi_events[0]);
	t->cb = cb;
	t->cb_data = data;

	r = _pwlock_tapi_register_noti_events(t);
	if (r == -1) {
		_ERR("TAPI register events error");
		goto err;
	}

	return t;
 err:
	if (t) {
		_pwlock_tapi_deregister_noti_events(t);
		free(t);
	}
	if (tapi_handle != NULL) {
		tel_deinit(tapi_handle);
	}

	return NULL;
}

void pwlock_tapi_exit(struct tapi **t)
{
	if (t == NULL || *t == NULL)
		return;

	_pwlock_tapi_deregister_noti_events(*t);

	if ((*t)->handle != NULL) {
		tel_deinit((*t)->handle);
	}

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