* @file: usb_moded-devicelock.c

*

* Copyright (C) 2010 Nokia Corporation. All rights reserved.

*

* @author: Philippe De Swert <philippe.de-swert@nokia.com>

* @author: Philippe De Swert <philippe.deswert@jollamobile.com>

* @author: Jonni Rainisto <jonni.rainisto@jollamobile.com>

* @author: Philippe De Swert <philippedeswert@gmail.com>

* @author: Vesa Halttunen <vesa.halttunen@jollamobile.com>

* @author: Jonni Rainisto <jonni.rainisto@jollamobile.com>

* @author: Philippe De Swert <philippe.deswert@jollamobile.com>

* @author: Simo Piiroinen <simo.piiroinen@jollamobile.com>

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the Lesser GNU General Public License

* version 2 as published by the Free Software Foundation.

*

* This program is distributed in the hope that it will be useful, but

* WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* General Public License for more details.

*

* You should have received a copy of the Lesser GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA

* 02110-1301 USA

*/

* Interacts with the devicelock to know if we can expose the system contents or not

*/

#include "usb_moded-devicelock.h"

#include "usb_moded-dbus-private.h"

#include "usb_moded-log.h"

#include <string.h>

/* ========================================================================= *

* ========================================================================= */

/** Devicelock states */

{

/** Devicelock is not active */

/** Devicelock is active */

/** Initial startup value; from usb-moded p.o.v. equals locked */

} devicelock_state_t;

/* ========================================================================= *

* Prototypes

* ========================================================================= */

/* ------------------------------------------------------------------------- *

* DEVICELOCK

* ------------------------------------------------------------------------- */

static const char *devicelock_state_repr (devicelock_state_t state);

bool devicelock_have_export_permission(void);

static void devicelock_state_changed (devicelock_state_t state);

static void devicelock_state_cancel (void);

static void devicelock_state_query_cb (DBusPendingCall *pending, void *aptr);

static void devicelock_state_query (void);

static void devicelock_state_signal (DBusMessage *msg);

static void devicelock_available_changed (const char *owner);

static void devicelock_available_cb (const char *owner);

static void devicelock_available_cancel (void);

static void devicelock_available_query (void);

static void devicelock_name_owner_signal (DBusMessage *msg);

static DBusHandlerResult devicelock_dbus_filter_cb (DBusConnection *con, DBusMessage *msg, void *aptr);

bool devicelock_start_listener (void);

void devicelock_stop_listener (void);

/* ========================================================================= *

* module state data

* ========================================================================= */

/* SystemBus connection ref used for devicelock ipc */

static DBusConnection *devicelock_con = NULL;

/* Cached devicelock state */

/* Flag for: devicelock is available on system bus */

static gboolean devicelock_is_available = FALSE;

/* ========================================================================= *

* devicelock state type

* ========================================================================= */

/** Return human readable representation of devicelock state enum

*/

static const char *

devicelock_state_repr(devicelock_state_t state)

{

LOG_REGISTER_CONTEXT;

switch( state )

{

case DEVICELOCK_UNLOCKED: repr = "DEVICELOCK_UNLOCKED"; break;

case DEVICELOCK_LOCKED: repr = "DEVICELOCK_LOCKED"; break;

case DEVICELOCK_UNDEFINED: repr = "DEVICELOCK_UNDEFINED"; break;

default: break;

}

return repr;

}

/* ========================================================================= *

* functionality provided to the other modules

* ========================================================================= */

*

*/

LOG_REGISTER_CONTEXT;

}

/* ========================================================================= *

* devicelock state queries

* ========================================================================= */

static void devicelock_state_changed(devicelock_state_t state)

LOG_REGISTER_CONTEXT;

goto EXIT;

log_debug("devicelock state: %s -> %s",

EXIT:

return;

static DBusPendingCall *devicelock_state_query_pc = 0;

static void devicelock_state_cancel(void)

{

LOG_REGISTER_CONTEXT;

if( devicelock_state_query_pc ) {

dbus_pending_call_cancel(devicelock_state_query_pc);

dbus_pending_call_unref(devicelock_state_query_pc),

devicelock_state_query_pc = 0;

}

}

LOG_REGISTER_CONTEXT;

DBusError err = DBUS_ERROR_INIT;

(void)aptr;

if( !(rsp = dbus_pending_call_steal_reply(pending)) )

{

log_err("%s.%s: no reply",

DEVICELOCK_INTERFACE, DEVICELOCK_GET_STATE_REQ);

goto EXIT;

}

if( dbus_set_error_from_message(&err, rsp) )

{

log_err("%s.%s: error reply: %s: %s",

DEVICELOCK_INTERFACE, DEVICELOCK_GET_STATE_REQ,

err.name, err.message);

goto EXIT;

}

if( !dbus_message_get_args(rsp, &err, DBUS_TYPE_INT32, &dta,

DBUS_TYPE_INVALID) )

{

log_err("%s.%s: parse error: %s: %s",

DEVICELOCK_INTERFACE, DEVICELOCK_GET_STATE_REQ,

err.name, err.message);

goto EXIT;

}

EXIT:

devicelock_state_changed(dta);

if( rsp ) dbus_message_unref(rsp);

dbus_error_free(&err);

dbus_pending_call_unref(devicelock_state_query_pc),

devicelock_state_query_pc = 0;

}

static void devicelock_state_query(void)

{

LOG_REGISTER_CONTEXT;

DBusMessage *req = NULL;

DBusPendingCall *pc = 0;

devicelock_state_cancel();

log_debug("querying device lock state");

if( !devicelock_con ) {

log_err("not connected to system bus; skip device state query");

goto EXIT;

}

req = dbus_message_new_method_call(DEVICELOCK_SERVICE,

DEVICELOCK_OBJECT,

DEVICELOCK_INTERFACE,

DEVICELOCK_GET_STATE_REQ);

if( !req )

{

log_err("%s.%s: failed to construct request",

DEVICELOCK_INTERFACE, DEVICELOCK_GET_STATE_REQ);

goto EXIT;

}

if( !dbus_connection_send_with_reply(devicelock_con, req, &pc, -1) )

goto EXIT;

if( !pc )

goto EXIT;

if( !dbus_pending_call_set_notify(pc, devicelock_state_query_cb, 0, 0) )

goto EXIT;

devicelock_state_query_pc = pc, pc = 0;

EXIT:

if( pc ) dbus_pending_call_unref(pc);

if( req ) dbus_message_unref(req);

}

static void devicelock_state_signal(DBusMessage *msg)

{

LOG_REGISTER_CONTEXT;

if( !dbus_message_get_args(msg, &err,

DBUS_TYPE_INT32, &dta,

DBUS_TYPE_INVALID) )

{

log_err("failed to parse %s.%s signal: %s: %s",

DEVICELOCK_INTERFACE, DEVICELOCK_STATE_CHANGED_SIG,

err.name, err.message);

}

devicelock_state_changed(dta);

dbus_error_free(&err);

}

/* ========================================================================= *

* devicelock name owner tracking

* ========================================================================= */

static void devicelock_available_changed(const char *owner)

{

LOG_REGISTER_CONTEXT;

gboolean is_available = (owner && *owner);

if( devicelock_is_available != is_available ) {

devicelock_is_available = is_available;

log_debug("devicelock is %s",

devicelock_is_available ? "running" : "stopped");

/* Forget cached device state */

/* Query current state on devicelock startup */

if( devicelock_is_available ) {

devicelock_state_query();

}

}

}

static DBusPendingCall *devicelock_available_pc = 0;

static void devicelock_available_cb(const char *owner)

{

LOG_REGISTER_CONTEXT;

devicelock_available_changed(owner);

dbus_pending_call_unref(devicelock_available_pc),

devicelock_available_pc = 0;

}

static void devicelock_available_cancel(void)

{

LOG_REGISTER_CONTEXT;

if( devicelock_available_pc )

{

dbus_pending_call_unref(devicelock_available_pc),

devicelock_available_pc = 0;

}

}

static void devicelock_available_query(void)

{

LOG_REGISTER_CONTEXT;

devicelock_available_cancel();

log_debug("querying %s name owner", DEVICELOCK_SERVICE);

umdbus_get_name_owner_async(DEVICELOCK_SERVICE,

devicelock_available_cb,

&devicelock_available_pc);

}

LOG_REGISTER_CONTEXT;

DBusError err = DBUS_ERROR_INIT;

const char *name = 0;

const char *prev = 0;

const char *curr = 0;

if( !dbus_message_get_args(msg, &err,

DBUS_TYPE_STRING, &name,

DBUS_TYPE_STRING, &prev,

DBUS_TYPE_STRING, &curr,

DBUS_TYPE_INVALID) )

{

log_err("failed to parse signal: %s: %s",

err.name, err.message);

}

else if( !strcmp(name, DEVICELOCK_SERVICE) )

{

devicelock_available_changed(curr);

}

dbus_error_free(&err);

}

/* ========================================================================= *

* dbus message filter

* ========================================================================= */

static DBusHandlerResult

devicelock_dbus_filter_cb(DBusConnection *con, DBusMessage *msg, void *aptr)

{

LOG_REGISTER_CONTEXT;

(void)con;

(void)aptr;

if( dbus_message_is_signal(msg,

DEVICELOCK_INTERFACE,

DEVICELOCK_STATE_CHANGED_SIG) )

{

devicelock_state_signal(msg);

}

else if( dbus_message_is_signal(msg,

DBUS_INTERFACE_DBUS,

DBUS_NAME_OWNER_CHANGED_SIG) )

{

}

return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

}

/* ========================================================================= *

* start/stop devicelock state tracking

* ========================================================================= */

bool

devicelock_start_listener(void)

LOG_REGISTER_CONTEXT;

log_debug("starting devicelock listener");

/* Get connection ref */

{

log_err("Could not connect to dbus for devicelock\n");

goto cleanup;

}

/* Add filter callback */

if( !dbus_connection_add_filter(devicelock_con,

devicelock_dbus_filter_cb , 0, 0) )

{

log_err("adding system dbus filter for devicelock failed");

goto cleanup;

}

/* Add match without blocking / error checking */

dbus_bus_add_match(devicelock_con, DEVICELOCK_STATE_CHANGED_MATCH,0);

dbus_bus_add_match(devicelock_con, DEVICELOCK_NAME_OWNER_CHANGED_MATCH,0);

/* Initiate async devicelock name owner query */

devicelock_available_query();

cleanup:

return ack;

}

LOG_REGISTER_CONTEXT;

log_debug("stopping devicelock listener");

/* Do note leave pending queries behind */

devicelock_state_cancel();

devicelock_available_cancel();

if(devicelock_con)

{

/* Remove filter callback */

dbus_connection_remove_filter(devicelock_con,

devicelock_dbus_filter_cb, 0);

if( dbus_connection_get_is_connected(devicelock_con) ) {

/* Remove match without blocking / error checking */

dbus_bus_remove_match(devicelock_con,

DEVICELOCK_STATE_CHANGED_MATCH, 0);

dbus_bus_remove_match(devicelock_con,

DEVICELOCK_NAME_OWNER_CHANGED_MATCH, 0);

}

/* Let go of connection ref */

dbus_connection_unref(devicelock_con),

devicelock_con = 0;

}

}