int __connman_technology_disable(enum connman_service_type type, DBusMessage *msg)
{
struct connman_technology *technology;
GSList *list;
int err = 0;
int ret = -ENODEV;
DBusMessage *reply;
DBG("type %d disable", type);
technology = technology_find(type);
if (technology == NULL) {
err = -ENXIO;
goto done;
}
if (technology->pending_reply != NULL) {
err = -EBUSY;
goto done;
}
if (technology->tethering == TRUE)
set_tethering(technology, FALSE);
if (msg != NULL) {
technology->enable_persistent = FALSE;
save_state(technology);
}
__connman_rfkill_block(technology->type, TRUE);
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
err = __connman_device_disable(device);
if (err == 0)
ret = 0;
}
done:
if (ret == 0) {
if (msg != NULL)
g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID);
return ret;
}
if (msg != NULL) {
if (err == -EINPROGRESS) {
technology->pending_reply = dbus_message_ref(msg);
technology->pending_timeout = g_timeout_add_seconds(10,
technology_pending_reply, technology);
} else {
reply = __connman_error_failed(msg, -err);
if (reply != NULL)
g_dbus_send_message(connection, reply);
}
}
return err;
}
int __connman_technology_disabled(enum connman_service_type type)
{
struct connman_technology *technology;
technology = technology_find(type);
if (technology == NULL)
return -ENXIO;
if (technology->pending_reply != NULL) {
g_dbus_send_reply(connection, technology->pending_reply, DBUS_TYPE_INVALID);
dbus_message_unref(technology->pending_reply);
g_source_remove(technology->pending_timeout);
technology->pending_reply = NULL;
technology->pending_timeout = 0;
}
if (__sync_fetch_and_sub(&technology->enabled, 1) != 1)
return 0;
__connman_notifier_disable(type);
technology->state = CONNMAN_TECHNOLOGY_STATE_OFFLINE;
state_changed(technology);
return 0;
}
static void report_error_return(char *input, void *user_data)
{
struct agent_data *request = user_data;
switch (confirm_input(input)) {
case 1:
if (strcmp(request->interface, AGENT_INTERFACE) == 0)
g_dbus_send_error(agent_connection, request->message,
"net.connman.Agent.Error.Retry", NULL);
else
g_dbus_send_error(agent_connection, request->message,
"net.connman.vpn.Agent.Error.Retry",
NULL);
break;
case 0:
g_dbus_send_reply(agent_connection, request->message,
DBUS_TYPE_INVALID);
break;
default:
return;
}
pending_message_remove(request);
pending_command_complete("");
}
static void pincode_response(const char *input, void *user_data)
{
DBusConnection *conn = user_data;
g_dbus_send_reply(conn, pending_message, DBUS_TYPE_STRING, &input,
DBUS_TYPE_INVALID);
}
static void capabilities_complete_callback(struct obc_session *session,
struct obc_transfer *transfer,
GError *err, void *user_data)
{
DBusMessage *message = user_data;
char *contents;
size_t size;
int perr;
if (err != NULL) {
DBusMessage *error = g_dbus_create_error(message,
"org.openobex.Error.Failed",
"%s", err->message);
g_dbus_send_message(session->conn, error);
goto done;
}
perr = obc_transfer_get_contents(transfer, &contents, &size);
if (perr < 0) {
DBusMessage *error = g_dbus_create_error(message,
"org.openobex.Error.Failed",
"Error reading contents: %s",
strerror(-perr));
g_dbus_send_message(session->conn, error);
goto done;
}
g_dbus_send_reply(session->conn, message,
DBUS_TYPE_STRING, &contents,
DBUS_TYPE_INVALID);
g_free(contents);
done:
dbus_message_unref(message);
}
static void close_channel_cb(void *context, uint8_t *apdu, size_t apdu_length,
int err)
{
struct close_channel_context *ctx = context;
char *channel_path;
DBusConnection *conn;
conn = near_dbus_get_connection();
if (err)
return close_channel_error(ctx, err);
/* Check response status */
err = __seel_apdu_resp_status(apdu, apdu_length);
if (err)
return close_channel_error(ctx, err);
channel_path = __seel_channel_get_path(ctx->channel);
if (!g_hash_table_remove(ctx->se->channel_hash, channel_path))
return close_channel_error(ctx, -ENODEV);
g_dbus_send_reply(conn, ctx->msg, DBUS_TYPE_INVALID);
dbus_message_unref(ctx->msg);
ctx->msg = NULL;
g_free(ctx);
return;
}
static void interrupt_connect_cb(GIOChannel *chan, GError *conn_err,
gpointer user_data)
{
struct input_conn *iconn = user_data;
struct input_device *idev = iconn->idev;
DBusMessage *reply = NULL;
int err;
const char *err_msg;
DBG("idev %p", idev);
if (conn_err) {
err_msg = conn_err->message;
goto failed;
}
err = input_device_connected(idev, iconn);
if (err < 0) {
err_msg = strerror(-err);
goto failed;
}
/* Replying to the requestor */
if (iconn->pending_connect) {
g_dbus_send_reply(idev->conn, iconn->pending_connect, DBUS_TYPE_INVALID);
dbus_message_unref(iconn->pending_connect);
iconn->pending_connect = NULL;
}
return;
failed:
error("%s", err_msg);
if (iconn->pending_connect) {
reply = btd_error_failed(iconn->pending_connect, err_msg);
g_dbus_send_message(idev->conn, reply);
dbus_message_unref(iconn->pending_connect);
iconn->pending_connect = NULL;
}
/* So we guarantee the interrupt channel is closed before the
* control channel (if we only do unref GLib will close it only
* after returning control to the mainloop */
if (!conn_err)
g_io_channel_shutdown(iconn->intr_io, FALSE, NULL);
g_io_channel_unref(iconn->intr_io);
iconn->intr_io = NULL;
if (iconn->ctrl_io) {
g_io_channel_unref(iconn->ctrl_io);
iconn->ctrl_io = NULL;
}
}
static void message_queued(struct ofono_sms *sms,
const struct ofono_uuid *uuid, void *data)
{
DBusConnection *conn = ofono_dbus_get_connection();
DBusMessage *msg = data;
const char *path;
path = __ofono_sms_message_path_from_uuid(sms, uuid);
g_dbus_send_reply(conn, msg, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
}
static void select_aid_cb(void *context,
uint8_t *apdu, size_t apdu_length,
int err)
{
struct open_channel_context *ctx = context;
struct seel_apdu *close_channel;
struct seel_channel *channel;
char *path;
DBusConnection *conn;
int ret;
conn = near_dbus_get_connection();
if (err != 0) {
/*
* err != 0 means SW != 9000.
* In this case, we need to clean the previously
* allocated logical channel.
*/
close_channel = __seel_apdu_close_logical_channel(ctx->channel);
if (!close_channel)
goto err;
ret = __seel_se_queue_io(ctx->se, close_channel, NULL, ctx);
if (ret < 0) {
near_error("close channel error %d", ret);
err = ret;
}
goto err;
}
channel = __seel_channel_add(ctx->se, ctx->channel,
ctx->aid, ctx->aid_len, false);
if (!channel) {
err = -ENOMEM;
goto err;
}
path = __seel_channel_get_path(channel);
g_hash_table_replace(ctx->se->channel_hash, path, channel);
g_dbus_send_reply(conn, ctx->msg,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
dbus_message_unref(ctx->msg);
ctx->msg = NULL;
g_free(ctx);
return;
err:
return open_channel_error(ctx, err);
}
void g_dbus_pending_property_success(GDBusPendingPropertySet id)
{
struct property_data *propdata;
propdata = remove_pending_property_data(id);
if (propdata == NULL)
return;
g_dbus_send_reply(propdata->conn, propdata->message,
DBUS_TYPE_INVALID);
dbus_message_unref(propdata->message);
g_free(propdata);
}
static void confirm_response(const char *input, void *user_data)
{
DBusConnection *conn = user_data;
if (!strcmp(input, "yes"))
g_dbus_send_reply(conn, pending_message, DBUS_TYPE_INVALID);
else if (!strcmp(input, "no"))
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Rejected", NULL);
else
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Canceled", NULL);
}
static void create_path(DBusConnection *conn, DBusMessage *msg,
const char *path, const char *sname)
{
/* emit signal when it is a new path */
if (sname) {
g_dbus_emit_signal(conn, NETWORK_PATH,
NETWORK_MANAGER_INTERFACE,
sname, DBUS_TYPE_STRING, &path,
DBUS_TYPE_INVALID);
}
g_dbus_send_reply(conn, msg, DBUS_TYPE_STRING, &path,
DBUS_TYPE_INVALID);
}
static void gateway_resume_complete(struct audio_device *dev, GError *err,
void *user_data)
{
struct media_owner *owner = user_data;
struct media_request *req = owner->pending;
struct media_transport *transport = owner->transport;
int fd;
uint16_t imtu, omtu;
gboolean ret;
req->id = 0;
if (dev == NULL)
goto fail;
if (err) {
error("Failed to resume gateway: error %s", err->message);
goto fail;
}
fd = gateway_get_sco_fd(dev);
if (fd < 0)
goto fail;
imtu = 48;
omtu = 48;
media_transport_set_fd(transport, fd, imtu, omtu);
if (g_strstr_len(owner->accesstype, -1, "r") == NULL)
imtu = 0;
if (g_strstr_len(owner->accesstype, -1, "w") == NULL)
omtu = 0;
ret = g_dbus_send_reply(transport->conn, req->msg,
DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_UINT16, &imtu,
DBUS_TYPE_UINT16, &omtu,
DBUS_TYPE_INVALID);
if (ret == FALSE)
goto fail;
media_owner_remove(owner);
return;
fail:
media_transport_remove(transport, owner);
}
static void passkey_response(const char *input, void *user_data)
{
DBusConnection *conn = user_data;
dbus_uint32_t passkey;
if (sscanf(input, "%u", &passkey) == 1)
g_dbus_send_reply(conn, pending_message, DBUS_TYPE_UINT32,
&passkey, DBUS_TYPE_INVALID);
else if (!strcmp(input, "no"))
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Rejected", NULL);
else
g_dbus_send_error(conn, pending_message,
"org.bluez.Error.Canceled", NULL);
}
static DBusMessage *manager_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
struct manager *mgr = data;
if (!dbus_message_iter_init(msg, &iter))
return __dbus_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __dbus_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __dbus_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(property, "Powered") == TRUE) {
gboolean powered = FALSE;
int err;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __dbus_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &powered);
if (mgr->state == INITIALIZING)
return __dbus_error_busy(msg);
if (mgr->powered == powered)
return dbus_message_new_method_return(msg);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
err = set_powered(conn, mgr, powered);
if (err < 0)
return NULL;
return NULL;
}
return __dbus_error_invalid_args(msg);
}
static void a2dp_resume_complete(struct avdtp *session,
struct avdtp_error *err, void *user_data)
{
struct media_owner *owner = user_data;
struct media_request *req = owner->pending;
struct media_transport *transport = owner->transport;
struct a2dp_sep *sep = media_endpoint_get_sep(transport->endpoint);
struct avdtp_stream *stream;
int fd;
uint16_t imtu, omtu;
gboolean ret;
req->id = 0;
if (err)
goto fail;
stream = a2dp_sep_get_stream(sep);
if (stream == NULL)
goto fail;
ret = avdtp_stream_get_transport(stream, &fd, &imtu, &omtu, NULL);
if (ret == FALSE)
goto fail;
media_transport_set_fd(transport, fd, imtu, omtu);
if (g_strstr_len(owner->accesstype, -1, "r") == NULL)
imtu = 0;
if (g_strstr_len(owner->accesstype, -1, "w") == NULL)
omtu = 0;
ret = g_dbus_send_reply(transport->conn, req->msg,
DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_UINT16, &imtu,
DBUS_TYPE_UINT16, &omtu,
DBUS_TYPE_INVALID);
if (ret == FALSE)
goto fail;
media_owner_remove(owner);
return;
fail:
media_transport_remove(transport, owner);
}
static void local_connect_cb(struct network_conn *nc, int err)
{
DBusConnection *conn = btd_get_dbus_connection();
const char *pdev = nc->dev;
if (err < 0) {
DBusMessage *reply = btd_error_failed(nc->connect,
strerror(-err));
g_dbus_send_message(conn, reply);
} else {
g_dbus_send_reply(conn, nc->connect, DBUS_TYPE_STRING, &pdev,
DBUS_TYPE_INVALID);
}
dbus_message_unref(nc->connect);
nc->connect = NULL;
}
static void interrupt_connect_cb(GIOChannel *chan, GError *conn_err,
gpointer user_data)
{
struct input_conn *iconn = user_data;
struct input_device *idev = iconn->idev;
DBusMessage *reply;
int err;
const char *err_msg;
if (conn_err) {
err_msg = conn_err->message;
g_io_channel_unref(iconn->intr_io);
iconn->intr_io = NULL;
goto failed;
}
err = input_device_connected(idev, iconn);
if (err < 0) {
err_msg = strerror(-err);
goto failed;
}
/* Replying to the requestor */
g_dbus_send_reply(idev->conn, iconn->pending_connect, DBUS_TYPE_INVALID);
dbus_message_unref(iconn->pending_connect);
iconn->pending_connect = NULL;
return;
failed:
error("%s", err_msg);
reply = connection_attempt_failed(iconn->pending_connect, err_msg);
g_dbus_send_message(idev->conn, reply);
if (iconn->ctrl_io)
g_io_channel_shutdown(iconn->ctrl_io, FALSE, NULL);
if (iconn->intr_io) {
if (!conn_err)
g_io_channel_shutdown(iconn->intr_io, FALSE, NULL);
g_io_channel_unref(iconn->intr_io);
iconn->intr_io = NULL;
}
}
static void auth_cb(DBusError *derr, void *user_data)
{
struct service_adapter *serv_adapter = user_data;
DBusMessage *reply;
struct pending_auth *auth;
bdaddr_t src;
auth = next_pending(serv_adapter);
if (auth == NULL) {
info("Authorization cancelled: Client exited");
return;
}
if (derr) {
error("Access denied: %s", derr->message);
reply = btd_error_not_authorized(auth->msg);
dbus_message_unref(auth->msg);
g_dbus_send_message(auth->conn, reply);
goto done;
}
g_dbus_send_reply(auth->conn, auth->msg,
DBUS_TYPE_INVALID);
done:
dbus_connection_unref(auth->conn);
serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list,
auth);
g_free(auth);
auth = next_pending(serv_adapter);
if (auth == NULL)
return;
if (serv_adapter->adapter)
adapter_get_address(serv_adapter->adapter, &src);
else
bacpy(&src, BDADDR_ANY);
btd_request_authorization(&src, &auth->dst,
auth->uuid, auth_cb, serv_adapter);
}
static void powered_changed(struct connman_technology *technology)
{
if (technology->dbus_registered == FALSE)
return;
if (technology->pending_reply != NULL) {
g_dbus_send_reply(connection,
technology->pending_reply, DBUS_TYPE_INVALID);
dbus_message_unref(technology->pending_reply);
technology->pending_reply = NULL;
g_source_remove(technology->pending_timeout);
technology->pending_timeout = 0;
}
__sync_synchronize();
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
DBUS_TYPE_BOOLEAN, &technology->enabled);
}
static void request_browser_return(char *input, void *user_data)
{
struct agent_data *request = user_data;
switch (confirm_input(input)) {
case 1:
g_dbus_send_reply(agent_connection, request->message,
DBUS_TYPE_INVALID);
break;
case 0:
g_dbus_send_error(agent_connection, request->message,
"net.connman.Agent.Error.Canceled", NULL);
break;
default:
return;
}
pending_message_remove(request);
pending_command_complete("");
}
static void pbap_setpath_cb(GError *err, gpointer user_data)
{
struct pbap_data *pbap = user_data;
if (err != NULL)
pbap_reset_path(user_data);
if (pbap->msg == NULL)
return;
if (err) {
DBusMessage *reply= g_dbus_create_error(pbap->msg,
ERROR_INF ".Failed",
"%s", err->message);
g_dbus_send_message(conn, reply);
} else
g_dbus_send_reply(conn, pbap->msg, DBUS_TYPE_INVALID);
dbus_message_unref(pbap->msg);
pbap->msg = NULL;
}
static void create_callback(struct obc_session *session,
struct obc_transfer *transfer,
GError *err, void *user_data)
{
struct send_data *data = user_data;
const char *path;
if (err != NULL) {
DBusMessage *error = g_dbus_create_error(data->message,
ERROR_INTERFACE ".Failed",
"%s", err->message);
g_dbus_send_message(data->connection, error);
shutdown_session(session);
goto done;
}
path = obc_session_register(session, unregister_session);
if (path == NULL) {
DBusMessage *error = g_dbus_create_error(data->message,
ERROR_INTERFACE ".Failed",
NULL);
g_dbus_send_message(data->connection, error);
shutdown_session(session);
goto done;
}
sessions = g_slist_append(sessions, session);
g_dbus_send_reply(data->connection, data->message,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
done:
dbus_message_unref(data->message);
dbus_connection_unref(data->connection);
g_free(data);
}
static gboolean bnep_setup_cb(GIOChannel *chan, GIOCondition cond,
gpointer data)
{
struct network_conn *nc = data;
struct bnep_control_rsp *rsp;
struct timeval timeo;
char pkt[BNEP_MTU];
ssize_t r;
int sk;
const char *pdev, *uuid;
gboolean connected;
if (cond & G_IO_NVAL)
return FALSE;
g_source_remove(nc->timeout_source);
nc->timeout_source = 0;
if (cond & (G_IO_HUP | G_IO_ERR)) {
error("Hangup or error on l2cap server socket");
goto failed;
}
sk = g_io_channel_unix_get_fd(chan);
memset(pkt, 0, BNEP_MTU);
r = read(sk, pkt, sizeof(pkt) -1);
if (r < 0) {
error("IO Channel read error");
goto failed;
}
if (r == 0) {
error("No packet received on l2cap socket");
goto failed;
}
errno = EPROTO;
if ((size_t) r < sizeof(*rsp)) {
error("Packet received is not bnep type");
goto failed;
}
rsp = (void *) pkt;
if (rsp->type != BNEP_CONTROL) {
error("Packet received is not bnep type");
goto failed;
}
if (rsp->ctrl != BNEP_SETUP_CONN_RSP)
return TRUE;
r = ntohs(rsp->resp);
if (r != BNEP_SUCCESS) {
error("bnep failed");
goto failed;
}
memset(&timeo, 0, sizeof(timeo));
timeo.tv_sec = 0;
setsockopt(sk, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
if (bnep_connadd(sk, BNEP_SVC_PANU, nc->dev)) {
error("%s could not be added", nc->dev);
goto failed;
}
bnep_if_up(nc->dev);
pdev = nc->dev;
uuid = bnep_uuid(nc->id);
g_dbus_send_reply(connection, nc->msg,
DBUS_TYPE_STRING, &pdev,
DBUS_TYPE_INVALID);
connected = TRUE;
emit_property_changed(connection, nc->peer->path,
NETWORK_PEER_INTERFACE, "Connected",
DBUS_TYPE_BOOLEAN, &connected);
emit_property_changed(connection, nc->peer->path,
NETWORK_PEER_INTERFACE, "Interface",
DBUS_TYPE_STRING, &pdev);
emit_property_changed(connection, nc->peer->path,
NETWORK_PEER_INTERFACE, "UUID",
DBUS_TYPE_STRING, &uuid);
nc->state = CONNECTED;
nc->dc_id = device_add_disconnect_watch(nc->peer->device, disconnect_cb,
nc, NULL);
info("%s connected", nc->dev);
/* Start watchdog */
g_io_add_watch(chan, G_IO_ERR | G_IO_HUP | G_IO_NVAL,
(GIOFunc) bnep_watchdog_cb, nc);
g_io_channel_unref(nc->io);
nc->io = NULL;
return FALSE;
failed:
cancel_connection(nc, "bnep setup failed");
return FALSE;
}
static DBusMessage *sms_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_sms *sms = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (sms->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (!strcmp(property, "ServiceCenterAddress")) {
const char *value;
struct ofono_phone_number sca;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (strlen(value) == 0 || !valid_phone_number_format(value))
return __ofono_error_invalid_format(msg);
if (sms->driver->sca_set == NULL ||
sms->driver->sca_query == NULL)
return __ofono_error_not_implemented(msg);
string_to_phone_number(value, &sca);
sms->pending = dbus_message_ref(msg);
sms->driver->sca_set(sms, &sca, sca_set_callback, sms);
return NULL;
}
if (!strcmp(property, "Bearer")) {
const char *value;
int bearer;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (sms_bearer_from_string(value, &bearer) != TRUE)
return __ofono_error_invalid_format(msg);
if (sms->driver->bearer_set == NULL ||
sms->driver->bearer_query == NULL)
return __ofono_error_not_implemented(msg);
sms->pending = dbus_message_ref(msg);
sms->driver->bearer_set(sms, bearer, bearer_set_callback, sms);
return NULL;
}
if (!strcmp(property, "UseDeliveryReports")) {
const char *path = __ofono_atom_get_path(sms->atom);
dbus_bool_t value;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
if (sms->use_delivery_reports != (ofono_bool_t) value) {
sms->use_delivery_reports = value;
ofono_dbus_signal_property_changed(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"UseDeliveryReports",
DBUS_TYPE_BOOLEAN, &value);
}
return NULL;
}
if (!strcmp(property, "Alphabet")) {
const char *value;
enum sms_alphabet alphabet;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (!sms_alphabet_from_string(value, &alphabet))
return __ofono_error_invalid_format(msg);
set_alphabet(sms, alphabet);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *set_property_lockdown(struct ofono_modem *modem,
DBusMessage *msg,
DBusMessageIter *var)
{
DBusConnection *conn = ofono_dbus_get_connection();
ofono_bool_t lockdown;
dbus_bool_t powered;
const char *caller;
int err;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(var, &lockdown);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
caller = dbus_message_get_sender(msg);
if (modem->lockdown && g_strcmp0(caller, modem->lock_owner))
return __ofono_error_access_denied(msg);
if (modem->lockdown == lockdown)
return dbus_message_new_method_return(msg);
if (lockdown == FALSE) {
lockdown_remove(modem);
goto done;
}
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
modem->lock_owner = g_strdup(caller);
modem->lock_watch = g_dbus_add_disconnect_watch(conn,
modem->lock_owner, lockdown_disconnect,
modem, NULL);
if (modem->lock_watch == 0) {
g_free(modem->lock_owner);
modem->lock_owner = NULL;
return __ofono_error_failed(msg);
}
modem->lockdown = lockdown;
if (modem->powered == FALSE)
goto done;
err = set_powered(modem, FALSE);
if (err < 0) {
if (err != -EINPROGRESS) {
lockdown_remove(modem);
return __ofono_error_failed(msg);
}
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
set_online(modem, FALSE);
powered = FALSE;
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
done:
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Lockdown", DBUS_TYPE_BOOLEAN,
&lockdown);
return NULL;
}
static DBusMessage *modem_set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_modem *modem = data;
DBusMessageIter iter, var;
const char *name;
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
if (powering_down == TRUE)
return __ofono_error_failed(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(name, "Online"))
return set_property_online(modem, msg, &var);
if (g_str_equal(name, "Powered") == TRUE) {
ofono_bool_t powered;
int err;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &powered);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
if (modem->powered == powered)
return dbus_message_new_method_return(msg);
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
if (modem->lockdown)
return __ofono_error_access_denied(msg);
err = set_powered(modem, powered);
if (err < 0) {
if (err != -EINPROGRESS)
return __ofono_error_failed(msg);
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
if (powered) {
modem_change_state(modem, MODEM_STATE_PRE_SIM);
/* Force SIM Ready for devies with no sim atom */
if (modem_has_sim(modem) == FALSE)
sim_state_watch(OFONO_SIM_STATE_READY, modem);
} else {
set_online(modem, FALSE);
modem_change_state(modem, MODEM_STATE_POWER_OFF);
}
return NULL;
}
if (g_str_equal(name, "Lockdown"))
return set_property_lockdown(modem, msg, &var);
return __ofono_error_invalid_args(msg);
}
int __connman_technology_enable(enum connman_service_type type, DBusMessage *msg)
{
struct connman_technology *technology;
GSList *list;
int err = 0;
int ret = -ENODEV;
DBusMessage *reply;
DBG("type %d enable", type);
technology = technology_find(type);
if (technology == NULL) {
err = -ENXIO;
goto done;
}
if (technology->pending_reply != NULL) {
err = -EBUSY;
goto done;
}
if (msg != NULL) {
/*
* This is a bit of a trick. When msg is not NULL it means
* thats technology_enable was invoked from the manager API. Hence we save
* the state here.
*/
technology->enable_persistent = TRUE;
save_state(technology);
}
__connman_rfkill_block(technology->type, FALSE);
/*
* An empty device list means that devices in the technology
* were rfkill blocked. The unblock above will enable the devs.
*/
if (technology->device_list == NULL)
return 0;
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
err = __connman_device_enable(device);
/*
* err = 0 : Device was enabled right away.
* If atleast one device gets enabled, we consider
* the technology to be enabled.
*/
if (err == 0)
ret = 0;
}
done:
if (ret == 0) {
if (msg != NULL)
g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID);
return ret;
}
if (msg != NULL) {
if (err == -EINPROGRESS) {
technology->pending_reply = dbus_message_ref(msg);
technology->pending_timeout = g_timeout_add_seconds(10,
technology_pending_reply, technology);
} else {
reply = __connman_error_failed(msg, -err);
if (reply != NULL)
g_dbus_send_message(connection, reply);
}
}
return err;
}