static void ifx_set_sim_state(struct ifx_data *data, int state)
{
DBG("state %d", state);
switch (state) {
case 0: /* SIM not present */
case 6: /* SIM Error */
case 8: /* SIM Technical Problem */
case 9: /* SIM Removed */
ofono_sim_inserted_notify(data->sim, FALSE);
break;
case 1: /* PIN verification needed */
case 4: /* PUK verification needed */
case 5: /* SIM permanently blocked */
case 7: /* ready for attach (+COPS) */
ofono_sim_inserted_notify(data->sim, TRUE);
break;
case 2: /* PIN verification not needed – Ready */
case 3: /* PIN verified – Ready */
/*
* State 3 is handled in the SIM atom driver
* while for state 2 we should be waiting for state 7
*/
break;
case 10: /* SIM Reactivating */
case 11: /* SIM Reactivated */
case 12: /* SIM SMS Caching Completed */
case 99: /* SIM State Unknown */
ofono_warn("Unhandled SIM state %d received", state);
break;
default:
ofono_warn("Unknown SIM state %d received", state);
break;
}
}
static int android_wakelock_release(struct wakelock *lock)
{
if (lock == NULL)
return -EINVAL;
DBG("lock %p name %s acquisitions %d",
lock, lock->name, lock->acquisitions);
if (!lock->acquisitions) {
ofono_warn("Attempted to release already released lock %s", lock->name);
return -EINVAL;
}
if (lock->acquisitions > 1) {
lock->acquisitions--;
DBG("lock %s released acquisitions %d", lock->name, lock->acquisitions);
return 0;
}
if (wakelock_unlock(lock->name) < 0)
return -EIO;
lock->acquisitions = 0;
DBG("lock %s was released", lock->name);
return 0;
}
static void switch_sim_state_status(struct ofono_modem *modem, int status)
{
struct telit_data *data = ofono_modem_get_data(modem);
DBG("%p, SIM status: %d", modem, status);
switch (status) {
case 0: /* SIM not inserted */
if (data->have_sim == TRUE) {
ofono_sim_inserted_notify(data->sim, FALSE);
data->have_sim = FALSE;
data->sms_phonebook_added = FALSE;
}
break;
case 1: /* SIM inserted */
case 2: /* SIM inserted and PIN unlocked */
if (data->have_sim == FALSE) {
ofono_sim_inserted_notify(data->sim, TRUE);
data->have_sim = TRUE;
}
break;
case 3: /* SIM inserted, SMS and phonebook ready */
if (data->sms_phonebook_added == FALSE) {
ofono_phonebook_create(modem, 0, "atmodem", data->chat);
ofono_sms_create(modem, 0, "atmodem", data->chat);
data->sms_phonebook_added = TRUE;
}
break;
default:
ofono_warn("Unknown SIM state %d received", status);
break;
}
}
static void shutdown_device(struct ifx_data *data)
{
int i, fd;
DBG("");
if (data->dlc_init_source > 0) {
g_source_remove(data->dlc_init_source);
data->dlc_init_source = 0;
}
for (i = 0; i < NUM_DLC; i++) {
if (data->dlcs[i] == NULL)
continue;
g_at_chat_unref(data->dlcs[i]);
data->dlcs[i] = NULL;
}
if (data->mux) {
g_at_mux_shutdown(data->mux);
g_at_mux_unref(data->mux);
data->mux = NULL;
goto done;
}
fd = g_io_channel_unix_get_fd(data->device);
if (ioctl(fd, TIOCSETD, &data->saved_ldisc) < 0)
ofono_warn("Failed to restore line discipline");
done:
g_io_channel_unref(data->device);
data->device = NULL;
}
static void ifx_set_sim_state(struct ifx_data *data, int state)
{
DBG("state %d", state);
switch (state) {
case 0: /* SIM not present */
case 9: /* SIM Removed */
if (data->have_sim == TRUE) {
ofono_sim_inserted_notify(data->sim, FALSE);
data->have_sim = FALSE;
}
break;
case 1: /* PIN verification needed */
case 2: /* PIN verification not needed – Ready */
case 3: /* PIN verified – Ready */
case 4: /* PUK verification needed */
case 5: /* SIM permanently blocked */
case 6: /* SIM Error */
case 7: /* ready for attach (+COPS) */
case 8: /* SIM Technical Problem */
if (data->have_sim == FALSE) {
ofono_sim_inserted_notify(data->sim, TRUE);
data->have_sim = TRUE;
}
break;
default:
ofono_warn("Unknown SIM state %d received", state);
break;
}
}
static void telit_portcfg_check_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct cb_data *cbd = user_data;
ofono_location_reporting_enable_cb_t cb = cbd->cb;
struct ofono_location_reporting *lr = cbd->user;
struct gps_data *gd = ofono_location_reporting_get_data(lr);
struct ofono_error error;
int requested_portcfg, current_portcfg;
GAtResultIter iter;
DBG("lr=%p ok=%d", lr, ok);
decode_at_error(&error, g_at_result_final_response(result));
if (!ok) {
cb(&error, -1, cbd->data);
g_free(cbd);
return;
}
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "#PORTCFG:"))
goto fail;
if (!g_at_result_iter_next_number(&iter, &requested_portcfg))
goto fail;
if (!g_at_result_iter_next_number(&iter, ¤t_portcfg))
goto fail;
if (current_portcfg != 8) {
ofono_warn("Unable to start GPS, modem configuration invalid");
ofono_warn("Refer to doc/telit-modem.txt section HE910/GPS");
goto fail;
}
if (g_at_chat_send(gd->chat, "AT$GPSP=1", none_prefix,
telit_gps_enable_cb, cbd, NULL) > 0)
return;
fail:
CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
g_free(cbd);
}
static int sco_init(void)
{
GIOChannel *sco_io;
struct sockaddr_sco saddr;
struct bt_voice voice;
int sk;
socklen_t len;
sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET | O_NONBLOCK | SOCK_CLOEXEC,
BTPROTO_SCO);
if (sk < 0)
return -errno;
/* Bind to local address */
memset(&saddr, 0, sizeof(saddr));
saddr.sco_family = AF_BLUETOOTH;
bt_bacpy(&saddr.sco_bdaddr, BDADDR_ANY);
if (bind(sk, (struct sockaddr *) &saddr, sizeof(saddr)) < 0) {
close(sk);
return -errno;
}
if (setsockopt(sk, SOL_BLUETOOTH, BT_DEFER_SETUP,
&defer_setup, sizeof(defer_setup)) < 0) {
int err = -errno;
defer_setup = 0;
ofono_warn("Can't enable deferred setup: %s (%d)",
strerror(errno), errno);
close(sk);
return err;
}
memset(&voice, 0, sizeof(voice));
len = sizeof(voice);
if (defer_setup && getsockopt(sk, SOL_BLUETOOTH, BT_VOICE,
&voice, &len) == 0)
transparent_sco = TRUE;
if (listen(sk, 5) < 0) {
close(sk);
return -errno;
}
sco_io = g_io_channel_unix_new(sk);
sco_watch = g_io_add_watch(sco_io,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
sco_accept, NULL);
g_io_channel_unref(sco_io);
return 0;
}
static void dlc_disconnect(gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
DBG("");
ofono_warn("Disconnect of modem channel");
shutdown_device(data);
}
static void at_cgdcont_read_cb(gboolean ok, GAtResult *result,
gpointer user_data)
{
struct ofono_gprs *gprs = user_data;
struct gprs_data *gd = ofono_gprs_get_data(gprs);
int activated_cid = gd->last_auto_context_id;
const char *apn = NULL;
GAtResultIter iter;
DBG("ok %d", ok);
if (!ok) {
ofono_warn("Can't read CGDCONT contexts.");
return;
}
g_at_result_iter_init(&iter, result);
while (g_at_result_iter_next(&iter, "+CGDCONT:")) {
int read_cid;
if (!g_at_result_iter_next_number(&iter, &read_cid))
break;
if (read_cid != activated_cid)
continue;
/* ignore protocol */
g_at_result_iter_skip_next(&iter);
g_at_result_iter_next_string(&iter, &apn);
break;
}
if (apn)
ofono_gprs_cid_activated(gprs, activated_cid, apn);
else
ofono_warn("cid %u: Received activated but no apn present",
activated_cid);
}
static int android_wakelock_init(void)
{
if (!file_exists(ANDROID_WAKELOCK_LOCK_PATH)) {
ofono_warn("System does not support Android wakelocks.");
return 0;
}
if (wakelock_plugin_register("android-wakelock", &driver) < 0) {
ofono_error("Failed to register wakelock driver");
return -EIO;
}
return 0;
}
static void sim_status_cb(struct ril_msg *message, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ril_data *ril = ofono_modem_get_data(modem);
struct reply_sim_status *status;
DBG("");
if (message->error != RIL_E_SUCCESS) {
ril->sim_status_retries++;
ofono_error("GET_SIM_STATUS request failed: %s; retries: %d",
ril_error_to_string(message->error),
ril->sim_status_retries);
if (ril->sim_status_retries < MAX_SIM_STATUS_RETRIES)
g_timeout_add_seconds(2, sim_status_retry, modem);
else
ofono_error("Max retries for GET_SIM_STATUS exceeded!");
} else {
if ((status = g_ril_reply_parse_sim_status(ril->modem, message))
!= NULL) {
if (status->card_state == RIL_CARDSTATE_PRESENT) {
DBG("Card PRESENT; num_apps: %d",
status->num_apps);
if (!ril->have_sim) {
DBG("notify SIM inserted");
ril->have_sim = TRUE;
ofono_sim_inserted_notify(ril->sim, TRUE);
}
} else {
ofono_warn("Card NOT_PRESENT.");
if (ril->have_sim) {
DBG("notify SIM removed");
ril->have_sim = FALSE;
ofono_sim_inserted_notify(ril->sim, FALSE);
}
}
g_ril_reply_free_sim_status(status);
}
}
}
static void sim_status_cb(struct ril_msg *message, gpointer user_data)
{
DBG("error=%d", message->error);
struct ofono_modem *modem = user_data;
struct ril_data *ril = ofono_modem_get_data(modem);
struct sim_status status;
struct sim_app *apps[MAX_UICC_APPS];
/*
* ril.h claims this should NEVER fail!
* However this isn't quite true. So,
* on anything other than SUCCESS, we
* log an error, and schedule another
* GET_SIM_STATUS request.
*/
if (message->error != RIL_E_SUCCESS) {
ril->sim_status_retries++;
ofono_error("GET_SIM_STATUS reques failed: %d; retries: %d",
message->error, ril->sim_status_retries);
if (ril->sim_status_retries < MAX_SIM_STATUS_RETRIES)
ril->timer_id = g_timeout_add_seconds(2, (GSourceFunc)
send_get_sim_status,
(gpointer) modem);
else
ofono_error("Max retries for GET_SIM_STATUS exceeded!");
} else {
/* Returns TRUE if cardstate == PRESENT */
if (ril_util_parse_sim_status(ril->modem, message,
&status, apps)) {
if (status.num_apps)
ril_util_free_sim_apps(apps, status.num_apps);
} else {
ofono_warn("No SIM card present.");
}
/*
* We cannot power on modem, but we need to get
* certain interfaces up to be able to make emergency calls
* in offline mode and without SIM
*/
ofono_modem_set_powered(modem, TRUE);
}
}
static void parse_config(void)
{
GKeyFile *keyfile;
GError *err = NULL;
char **modems;
int i;
const char *filename;
char *conf_override = getenv("OFONO_PHONESIM_CONFIG");
if (conf_override)
filename = conf_override;
else
filename = CONFIGDIR "/phonesim.conf";
DBG("filename %s", filename);
keyfile = g_key_file_new();
g_key_file_set_list_separator(keyfile, ',');
if (!g_key_file_load_from_file(keyfile, filename, 0, &err)) {
ofono_warn("Reading of %s failed: %s", filename, err->message);
g_error_free(err);
goto done;
}
modems = g_key_file_get_groups(keyfile, NULL);
for (i = 0; modems[i]; i++) {
struct ofono_modem *modem;
modem = create_modem(keyfile, modems[i]);
if (modem == NULL)
continue;
modem_list = g_slist_prepend(modem_list, modem);
ofono_modem_register(modem);
}
g_strfreev(modems);
done:
g_key_file_free(keyfile);
}
static void serving_system_callback(const struct ofono_error *error,
const char *sid, void *data)
{
struct ofono_cdma_netreg *cdma_netreg = data;
const char *path = __ofono_atom_get_path(cdma_netreg->atom);
DBusConnection *conn = ofono_dbus_get_connection();
if (cdma_netreg->status != CDMA_NETWORK_REGISTRATION_STATUS_REGISTERED
&& cdma_netreg->status !=
CDMA_NETWORK_REGISTRATION_STATUS_ROAMING)
return;
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("Error during serving system query");
return;
}
DBG("Serving system Identifier: %s", sid);
if (cdma_netreg->sid != NULL && !strcmp(cdma_netreg->sid, sid))
return;
g_free(cdma_netreg->provider_name);
g_free(cdma_netreg->sid);
cdma_netreg->provider_name = NULL;
cdma_netreg->sid = g_strdup(sid);
ofono_dbus_signal_property_changed(conn, path,
OFONO_CDMA_NETWORK_REGISTRATION_INTERFACE,
"SystemIdentifier", DBUS_TYPE_STRING,
&cdma_netreg->sid);
if (__ofono_cdma_provision_get_name(sid,
&cdma_netreg->provider_name) == FALSE) {
ofono_warn("Provider name not found");
return;
}
ofono_dbus_signal_property_changed(conn, path,
OFONO_CDMA_NETWORK_REGISTRATION_INTERFACE,
"Name", DBUS_TYPE_STRING,
&cdma_netreg->provider_name);
}
static void mtk_set_fd_mode_cb(struct ril_msg *message, gpointer user_data)
{
struct cb_data *cbd = user_data;
struct set_fd_mode *user = cbd->user;
struct ofono_radio_settings *rs = user->rst;
struct radio_data *rsd = ofono_radio_settings_get_data(rs);
ofono_radio_settings_fast_dormancy_set_cb_t cb = cbd->cb;
if (message->error == RIL_E_SUCCESS ||
message->error == RIL_E_RADIO_NOT_AVAILABLE) {
if (message->error == RIL_E_RADIO_NOT_AVAILABLE)
ofono_warn("Could not set fast dormancy "
"as radio is not available");
g_ril_print_response_no_args(rsd->ril, message);
ril_set_fast_dormancy(rs, user->on, cb, cbd->data);
} else {
CALLBACK_WITH_FAILURE(cb, cbd->data);
}
g_free(user);
}
static gboolean handle_settings(struct ril_data_call *call, char *type,
char *ifname, char *raw_ip_addrs,
char *raw_dns, char *raw_gws)
{
gboolean result = FALSE;
int protocol;
char **dns_addrs = NULL, **gateways = NULL;
char **ip_addrs = NULL, **split_ip_addr = NULL;
protocol = ril_protocol_string_to_ofono_protocol(type);
if (protocol < 0) {
ofono_error("%s: invalid type(protocol) specified: %s",
__func__, type);
goto done;
}
if (ifname == NULL || strlen(ifname) == 0) {
ofono_error("%s: no interface specified: %s",
__func__, ifname);
goto done;
}
/* Split DNS addresses */
if (raw_dns)
dns_addrs = g_strsplit(raw_dns, " ", 3);
/*
* RILD can return multiple addresses; oFono only supports
* setting a single IPv4 gateway.
*/
if (raw_gws)
gateways = g_strsplit(raw_gws, " ", 3);
if (gateways == NULL || g_strv_length(gateways) == 0) {
ofono_error("%s: no gateways: %s", __func__, raw_gws);
goto done;
}
/* TODO:
* RILD can return multiple addresses; oFono only supports
* setting a single IPv4 address. At this time, we only
* use the first address. It's possible that a RIL may
* just specify the end-points of the point-to-point
* connection, in which case this code will need to
* changed to handle such a device.
*
* For now split into a maximum of three, and only use
* the first address for the remaining operations.
*/
if (raw_ip_addrs)
ip_addrs = g_strsplit(raw_ip_addrs, " ", 3);
if (ip_addrs == NULL || g_strv_length(ip_addrs) == 0) {
ofono_error("%s: no IP address: %s", __func__, raw_ip_addrs);
goto done;
}
DBG("num ip addrs is: %d", g_strv_length(ip_addrs));
if (g_strv_length(ip_addrs) > 1)
ofono_warn("%s: more than one IP addr returned: %s", __func__,
raw_ip_addrs);
/*
* Note - the address may optionally include a prefix size
* ( Eg. "/30" ). As this confuses NetworkManager, we
* explicitly strip any prefix after calculating the netmask.
*/
split_ip_addr = g_strsplit(ip_addrs[0], "/", 2);
if (split_ip_addr == NULL || g_strv_length(split_ip_addr) == 0) {
ofono_error("%s: invalid IP address field returned: %s",
__func__, ip_addrs[0]);
goto done;
}
call->protocol = protocol;
call->ifname = g_strdup(ifname);
call->ip_addr = g_strdup(split_ip_addr[0]);
call->dns_addrs = g_strdupv(dns_addrs);
call->gateways = g_strdupv(gateways);
result = TRUE;
done:
if (dns_addrs)
g_strfreev(dns_addrs);
if (gateways)
g_strfreev(gateways);
if (ip_addrs)
g_strfreev(ip_addrs);
if (split_ip_addr)
g_strfreev(split_ip_addr);
return result;
}
static void toplevel_apndb_start(GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer userdata, GError **error)
{
struct apndb_data *apndb = userdata;
struct apndb_provision_data *ap = NULL;
int i;
const gchar *carrier = NULL;
const gchar *mcc = NULL;
const gchar *mnc = NULL;
const gchar *apn = NULL;
const gchar *username = NULL;
const gchar *password = NULL;
const gchar *types = NULL;
const gchar *protocol = NULL;
const gchar *mmsproxy = NULL;
const gchar *mmsport = NULL;
const gchar *mmscenter = NULL;
const gchar *mvnomatch = NULL;
const gchar *mvnotype = NULL;
enum ofono_gprs_proto proto = OFONO_GPRS_PROTO_IP;
enum ofono_gprs_context_type type;
if (!g_str_equal(element_name, "apn"))
return;
for (i = 0; attribute_names[i]; i++) {
if (g_str_equal(attribute_names[i], "carrier"))
carrier = attribute_values[i];
else if (g_str_equal(attribute_names[i], "mcc"))
mcc = attribute_values[i];
else if (g_str_equal(attribute_names[i], "mnc"))
mnc = attribute_values[i];
}
if (mcc == NULL) {
android_apndb_g_set_error(context, error, G_MARKUP_ERROR,
G_MARKUP_ERROR_MISSING_ATTRIBUTE,
"Missing attribute: mcc");
return;
}
if (mnc == NULL) {
android_apndb_g_set_error(context, error, G_MARKUP_ERROR,
G_MARKUP_ERROR_MISSING_ATTRIBUTE,
"Missing attribute: mnc");
return;
}
if (g_str_equal(mcc, apndb->match_mcc) == FALSE ||
g_str_equal(mnc, apndb->match_mnc) == FALSE)
return;
for (i = 0; attribute_names[i]; i++) {
if (g_str_equal(attribute_names[i], "apn"))
apn = attribute_values[i];
else if (g_str_equal(attribute_names[i], "user"))
username = attribute_values[i];
else if (g_str_equal(attribute_names[i], "password"))
password = attribute_values[i];
else if (g_str_equal(attribute_names[i], "type"))
types = attribute_values[i];
else if (g_str_equal(attribute_names[i], "protocol"))
protocol = attribute_values[i];
else if (g_str_equal(attribute_names[i], "mmsc"))
mmscenter = attribute_values[i];
else if (g_str_equal(attribute_names[i], "mmsproxy"))
mmsproxy = attribute_values[i];
else if (g_str_equal(attribute_names[i], "mmsport"))
mmsport = attribute_values[i];
else if (g_str_equal(attribute_names[i], "mvno_match_data"))
mvnomatch = attribute_values[i];
else if (g_str_equal(attribute_names[i], "mvno_type"))
mvnotype = attribute_values[i];
}
if (apn == NULL) {
android_apndb_g_set_error(context, error, G_MARKUP_ERROR,
G_MARKUP_ERROR_MISSING_ATTRIBUTE,
"APN attribute missing");
return;
}
if (types == NULL) {
ofono_error("%s: apn for %s missing type attribute", __func__,
carrier);
return;
}
if (protocol != NULL) {
if (g_str_equal(protocol, "IP")) {
proto = OFONO_GPRS_PROTO_IP;
} else if (g_str_equal(protocol, "IPV6")) {
proto = OFONO_GPRS_PROTO_IPV6;
} else if (g_str_equal(protocol, "IPV4V6")) {
proto = OFONO_GPRS_PROTO_IPV4V6;
} else {
ofono_error("%s: APN %s has invalid protocol=%s"
"attribute", __func__, carrier,
protocol);
return;
}
}
if (mvnotype != NULL && mvnomatch != NULL) {
if (g_str_equal(mvnotype, "imsi")) {
DBG("APN %s is mvno_type 'imsi'", carrier);
if (imsi_match(apndb->match_imsi, mvnomatch) == FALSE) {
DBG("Skipping MVNO 'imsi' APN %s with"
" match_data: %s",
carrier, mvnomatch);
return;
}
} else if (g_str_equal(mvnotype, "spn")) {
DBG("APN %s is mvno_type 'spn'", carrier);
if (g_str_equal(mvnomatch, apndb->match_spn) == FALSE) {
DBG("Skipping mvno 'spn' APN %s with"
" match_data: %s",
carrier, mvnomatch);
return;
}
} else if (g_str_equal(mvnotype, "gid")) {
ofono_warn("%s: APN %s is unsupported mvno_type 'gid'",
__func__, carrier);
return;
}
}
type = determine_apn_type(types);
if (type == OFONO_GPRS_CONTEXT_TYPE_ANY ||
(type == OFONO_GPRS_CONTEXT_TYPE_MMS && mmsproxy == NULL)) {
DBG("Skipping %s context; types: %s", apn, types);
return;
}
ap = g_try_new0(struct apndb_provision_data, 1);
if (ap == NULL) {
ofono_error("%s: out-of-memory trying to provision APN - %s",
__func__, carrier);
return;
}
ap->gprs_data.type = type;
if (carrier != NULL)
ap->gprs_data.name = g_strdup(carrier);
if (apn != NULL)
ap->gprs_data.apn = g_strdup(apn);
if (username != NULL)
ap->gprs_data.username = g_strdup(username);
if (password != NULL)
ap->gprs_data.password = g_strdup(password);
if (mmscenter != NULL && strlen(mmscenter) > 0)
ap->gprs_data.message_center = g_strdup(mmscenter);
if (mmsproxy != NULL && strlen(mmsproxy) > 0) {
char *tmp = android_apndb_sanitize_ipv4_address(mmsproxy);
if (tmp != NULL)
mmsproxy = tmp;
if (mmsport != NULL)
ap->gprs_data.message_proxy =
g_strdup_printf("%s:%s", mmsproxy, mmsport);
else
ap->gprs_data.message_proxy = g_strdup(mmsproxy);
g_free(tmp);
}
ap->gprs_data.proto = proto;
if (mvnotype != NULL) {
ap->mvno = TRUE;
apndb->mvno_found = TRUE;
}
apndb->apns = g_slist_append(apndb->apns, ap);
}
