/**
* tracker_miner_manager_reindex_by_mimetype:
* @manager: a #TrackerMinerManager
* @mimetypes: (in): an array of mimetypes (E.G. "text/plain"). All items
* with a mimetype in that list will be reindexed.
* @error: (out callee-allocates) (transfer full) (allow-none): return location for errors
*
* Tells the filesystem miner to reindex any file with a mimetype in
* the @mimetypes list.
*
* On failure @error will be set.
*
* Returns: %TRUE on success, otherwise %FALSE.
*
* Since: 0.10
**/
gboolean
tracker_miner_manager_reindex_by_mimetype (TrackerMinerManager *manager,
const GStrv mimetypes,
GError **error)
{
TrackerMinerManagerPrivate *priv;
GVariant *v;
GError *new_error = NULL;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE);
g_return_val_if_fail (mimetypes != NULL, FALSE);
if (!tracker_miner_manager_is_active (manager,
"org.freedesktop.Tracker1.Miner.Files")) {
g_set_error_literal (error,
TRACKER_MINER_MANAGER_ERROR,
TRACKER_MINER_MANAGER_ERROR_NOT_AVAILABLE,
"Filesystem miner is not active");
return FALSE;
}
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
v = g_dbus_connection_call_sync (priv->connection,
"org.freedesktop.Tracker1.Miner.Files.Index",
"/org/freedesktop/Tracker1/Miner/Files/Index",
"org.freedesktop.Tracker1.Miner.Files.Index",
"ReindexMimeTypes",
g_variant_new ("(^as)", mimetypes),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&new_error);
if (new_error) {
g_propagate_error (error, new_error);
return FALSE;
}
g_variant_unref (v);
return FALSE;
}
void
rejilla_uninhibit_suspend (guint cookie)
{
GError *error = NULL;
GVariant *res;
if (cookie < 0) {
g_warning ("Invalid cookie");
return;
}
conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (conn == NULL) {
g_warning ("Couldn't get a DBUS connection: %s",
error->message);
g_error_free (error);
return;
}
res = g_dbus_connection_call_sync (conn,
GS_DBUS_SERVICE,
GS_DBUS_INHIBIT_PATH,
GS_DBUS_INHIBIT_INTERFACE,
"Uninhibit",
g_variant_new("(u)",
cookie),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (res == NULL) {
g_warning ("Failed to restore the system power manager: %s",
error->message);
g_error_free (error);
} else {
g_variant_get (res, "(u)", &cookie);
g_variant_unref (res);
}
}
GVariant* execute_query (gchar *query, GError **error)
{
GVariant *ret;
ret = g_dbus_connection_call_sync (
g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL),
"org.freedesktop.Tracker1",
"/org/freedesktop/Tracker1/Resources",
"org.freedesktop.Tracker1.Resources",
"SparqlQuery",
g_variant_new ("(s)", query),
G_VARIANT_TYPE ("(aas)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
error);
return ret;
}
void execute_update (gchar *query, GError **error)
{
GVariant *ret;
ret = g_dbus_connection_call_sync (
g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL),
"org.freedesktop.Tracker1",
"/org/freedesktop/Tracker1/Resources",
"org.freedesktop.Tracker1.Resources",
"SparqlUpdate",
g_variant_new ("(s)", query),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
error);
g_object_unref (ret);
}
static void
rate_song (GDBusProxy *mpris, gdouble song_rating)
{
GHashTable *properties;
GVariantBuilder props;
GVariant *v;
GError *error = NULL;
properties = get_playing_song_info (mpris);
if (properties == NULL) {
rb_debug ("can't set rating when not playing");
return;
}
v = g_hash_table_lookup (properties, "xesam:url");
if (v == NULL) {
rb_debug ("can't set rating, no url");
return;
}
g_variant_builder_init (&props, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&props, "{sv}", "rating", g_variant_new_double (song_rating));
g_dbus_connection_call_sync (g_dbus_proxy_get_connection (mpris),
"org.gnome.Rhythmbox3",
"/org/gnome/Rhythmbox3/RhythmDB",
"org.gnome.Rhythmbox3.RhythmDB",
"SetEntryProperties",
g_variant_new ("(sa{sv})", g_variant_get_string (v, NULL), &props),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error != NULL) {
g_warning ("Error setting rating on %s: %s",
g_variant_get_string (v, NULL),
error->message);
g_clear_error (&error);
}
g_hash_table_destroy (properties);
}
BT_EXPORT_API int bluetooth_telephony_start_voice_recognition(void)
{
GError *error = NULL;
int ret;
GDBusConnection *conn = NULL;
BT_DBG("+");
conn = _bt_init_system_gdbus_conn();
if (conn == NULL) {
BT_ERR("Bluetooth telephony not initilized");
return BLUETOOTH_TELEPHONY_ERROR_INTERNAL;
}
BT_TELEPHONY_CHECK_INITIALIZED();
BT_TELEPHONY_CHECK_ENABLED();
if (!__bluetooth_telephony_get_connected_device_path()) {
return BLUETOOTH_TELEPHONY_ERROR_INTERNAL;
}
g_dbus_connection_call_sync(conn,
BLUEZ_SERVICE_NAME,
telephony_info.obj_path,
BLUEZ_HEADSET_INTERFACE,
"SetVoiceDial",
g_variant_new("(b)", TRUE),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error != NULL) {
BT_ERR("Getting DefaultAdapter failed: [%s]",
error->message);
ret = __bt_telephony_get_error(error->message);
g_clear_error(&error);
return ret;
}
BT_DBG("-");
return BLUETOOTH_TELEPHONY_ERROR_NONE;
}
static void
cs_notification_watcher_init (CsNotificationWatcher *watcher)
{
GError *error = NULL;
GVariant *rulev;
GVariant *result;
watcher->connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (!watcher->connection)
{
g_printerr ("CsNotificationWatcher: Could not connect to session bus - %s\n", error->message);
g_clear_error (&error);
return;
}
rulev = g_variant_new("(s)", MATCH_RULE);
result = g_dbus_connection_call_sync (watcher->connection,
DBUS_SERVICE,
DBUS_PATH,
DBUS_INTERFACE,
"AddMatch",
rulev,
G_VARIANT_TYPE ("()"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (!result)
{
g_printerr ("CsNotificationWatcher: Could not add match rule to bus - %s\n", error->message);
g_clear_error (&error);
return;
}
watcher->filter_id = g_dbus_connection_add_filter (watcher->connection,
(GDBusMessageFilterFunction) notification_filter_func,
watcher,
NULL);
}
gboolean
appfinder_gdbus_open_window (gboolean expanded,
const gchar *startup_id,
GError **error)
{
GVariant *reply;
GDBusConnection *connection;
GError *err = NULL;
gboolean result;
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, error);
if (G_UNLIKELY (connection == NULL))
return FALSE;
if (startup_id == NULL)
startup_id = "";
reply = g_dbus_connection_call_sync (connection,
APPFINDER_DBUS_SERVICE,
APPFINDER_DBUS_PATH,
APPFINDER_DBUS_INTERFACE,
APPFINDER_DBUS_METHOD_OPEN,
g_variant_new ("(bs)",
expanded,
startup_id),
NULL,
G_DBUS_CALL_FLAGS_NO_AUTO_START,
2000,
NULL,
&err);
g_object_unref (connection);
result = (reply != NULL);
if (G_LIKELY (result))
g_variant_unref (reply);
else
g_propagate_error (error, err);
return result;
}
static void gtlm_nfc_dispose(GObject *object)
{
GTlmNfc* self = GTLM_NFC (object);
if (self->system_bus) {
GError* error = NULL;
GVariant* agent_register_response = g_dbus_connection_call_sync (self->system_bus,
"org.neard",
"/org/neard",
"org.neard.AgentManager",
"UnregisterNDEFAgent",
g_variant_new("(os)",
"/org/tlmnfc/agent",
"application/gtlm-nfc"),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (agent_register_response == NULL) {
g_debug ("Error unregistering an agent with neard: %s", error->message);
g_error_free (error);
}
g_variant_unref(agent_register_response);
}
if (self->agent_registration_id > 0)
if (g_dbus_connection_unregister_object(self->system_bus, self->agent_registration_id) == FALSE)
g_debug("Error unregistering agent object");
if (self->neard_manager) {
g_object_unref(self->neard_manager);
self->neard_manager = NULL;
}
if (self->system_bus) {
g_object_unref(self->system_bus);
self->system_bus = NULL;
}
G_OBJECT_CLASS (gtlm_nfc_parent_class)->dispose (object);
}
static gboolean inhibit (const gchar *app_id,
const gchar *reason,
GsmInhibitorFlag flags)
{
GDBusConnection *bus;
GVariant *ret;
GError *error = NULL;
bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (bus == NULL)
{
g_warning ("Failed to connect to session bus: %s", error->message);
g_error_free (error);
return FALSE;
}
ret = g_dbus_connection_call_sync (bus,
"org.gnome.SessionManager",
"/org/gnome/SessionManager",
"org.gnome.SessionManager",
"Inhibit",
g_variant_new ("(susu)",
app_id, 0, reason, flags),
G_VARIANT_TYPE ("(u)"),
0,
G_MAXINT,
NULL,
&error);
if (ret == NULL)
{
g_warning ("Failed to call Inhibit: %s\n", error->message);
g_error_free (error);
return FALSE;
}
g_variant_unref (ret);
return TRUE;
}
static int
app_call (const gchar *app_id,
const gchar *method_name,
GVariant *parameters)
{
GDBusConnection *session;
GError *error = NULL;
gchar *object_path;
GVariant *result;
session = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (!session)
{
g_variant_unref (g_variant_ref_sink (parameters));
g_printerr (_("unable to connect to D-Bus: %s\n"), error->message);
g_error_free (error);
return 1;
}
object_path = app_path_for_id (app_id);
result = g_dbus_connection_call_sync (session, app_id, object_path, "org.freedesktop.Application",
method_name, parameters, G_VARIANT_TYPE_UNIT,
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
g_free (object_path);
if (result)
{
g_variant_unref (result);
return 0;
}
else
{
g_printerr (_("error sending %s message to application: %s\n"), method_name, error->message);
g_error_free (error);
return 1;
}
}
gboolean xfpm_dbus_register_name(GDBusConnection *connection, const gchar *name)
{
GError *error = NULL;
guint32 ret = 0;
GVariant *var;
var = g_dbus_connection_call_sync (connection,
"org.freedesktop.DBus", /* bus name */
"/org/freedesktop/DBus", /* object path */
"org.freedesktop.DBus", /* interface name */
"RequestName", /* method name */
g_variant_new ("(su)",
name,
0x4), /* DBUS_NAME_FLAG_DO_NOT_QUEUE */
G_VARIANT_TYPE ("(u)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (var)
{
g_variant_get (var, "(u)", &ret);
g_variant_unref (var);
}
if ( error )
{
g_warning("Error: %s\n",error->message);
g_error_free(error);
return FALSE;
}
if ( ret == 1 ) /* DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER */
{
return TRUE;
}
return FALSE;
}
static gboolean
start_service_by_name(void)
{
GError *error = NULL;
GVariant *var;
GDBusConnection *conn;
conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error);
if (error) {
fprintf(stderr, "Could not get session bus connection: %s\n",
error->message);
g_error_free(error);
return FALSE;
}
var = g_dbus_connection_call_sync(conn,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"StartServiceByName",
g_variant_new("(su)",
"org.lightmediascanner", 0),
G_VARIANT_TYPE("(u)"),
G_DBUS_CALL_FLAGS_NONE,
10000,
NULL,
&error);
g_object_unref(conn);
if (var)
g_variant_unref(var);
if (error) {
fprintf(stderr, "Could not start org.lightmediascanner: %s\n",
error->message);
g_error_free(error);
return FALSE;
}
return TRUE;
}
/**
* fcitx_input_method_set_imlist:
* @im: A #FcitxInputMethod
* @array: (element-type FcitxIMItem) (transfer none): A #FcitxIMItem List
*
* Set Fcitx all im list
**/
FCITX_EXPORT_API
void fcitx_input_method_set_imlist(FcitxInputMethod *im, GPtrArray *array) {
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE("a(sssb)"));
g_ptr_array_foreach(array, _fcitx_im_item_foreach_cb, &builder);
GVariant *value = g_variant_builder_end(&builder);
GError *error = NULL;
GVariant *result = g_dbus_connection_call_sync(
g_dbus_proxy_get_connection(G_DBUS_PROXY(im)),
g_dbus_proxy_get_name(G_DBUS_PROXY(im)), FCITX_IM_DBUS_PATH,
"org.freedesktop.DBus.Properties", "Set",
g_variant_new("(ssv)", FCITX_IM_DBUS_INTERFACE, "IMList", value),
G_VARIANT_TYPE_UNIT, G_DBUS_CALL_FLAGS_NONE, -1, /* timeout */
NULL, &error);
if (error) {
g_warning("%s", error->message);
g_error_free(error);
}
g_variant_unref(result);
}
/**
* tracker_miner_manager_is_active:
* @manager: a #TrackerMinerManager
* @miner: miner reference
*
* Returns the miner's current activity.
*
* Returns: %TRUE if the @miner is active, otherwise %FALSE.
*
* Since: 0.8
**/
gboolean
tracker_miner_manager_is_active (TrackerMinerManager *manager,
const gchar *miner)
{
TrackerMinerManagerPrivate *priv;
GError *error = NULL;
gboolean active = FALSE;
GVariant *v;
g_return_val_if_fail (TRACKER_IS_MINER_MANAGER (manager), FALSE);
g_return_val_if_fail (miner != NULL, FALSE);
priv = TRACKER_MINER_MANAGER_GET_PRIVATE (manager);
v = g_dbus_connection_call_sync (priv->connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"NameHasOwner",
g_variant_new ("(s)", miner),
(GVariantType *) "(b)",
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (error) {
g_critical ("Could not check whether miner '%s' is currently active: %s",
miner, error ? error->message : "no error given");
g_error_free (error);
return FALSE;
}
g_variant_get (v, "(b)", &active);
g_variant_unref (v);
return active;
}
static gboolean
update_bus_environment (State *state,
GCancellable *cancellable)
{
GVariantBuilder builder;
GVariant *reply = NULL;
GError *error = NULL;
gboolean environment_updated = FALSE;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{ss}"));
g_variant_builder_add (&builder, "{ss}", "DISPLAY", state->display_name);
g_variant_builder_add (&builder, "{ss}", "XAUTHORITY", state->auth_file);
reply = g_dbus_connection_call_sync (state->bus_connection,
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"UpdateActivationEnvironment",
g_variant_new ("(@a{ss})",
g_variant_builder_end (&builder)),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1, cancellable, &error);
if (reply == NULL) {
g_debug ("could not update activation environment: %s", error->message);
goto out;
}
g_variant_unref (reply);
environment_updated = TRUE;
out:
g_clear_error (&error);
return environment_updated;
}
static gboolean
polkit_system_bus_name_exists_sync (PolkitSubject *subject,
GCancellable *cancellable,
GError **error)
{
PolkitSystemBusName *name = POLKIT_SYSTEM_BUS_NAME (subject);
GDBusConnection *connection;
GVariant *result;
gboolean ret;
ret = FALSE;
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, cancellable, error);
if (connection == NULL)
goto out;
result = g_dbus_connection_call_sync (connection,
"org.freedesktop.DBus", /* name */
"/org/freedesktop/DBus", /* object path */
"org.freedesktop.DBus", /* interface name */
"NameHasOwner", /* method */
g_variant_new ("(s)", name->name),
G_VARIANT_TYPE ("(b)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
cancellable,
error);
if (result == NULL)
goto out;
g_variant_get (result, "(b)", &ret);
g_variant_unref (result);
out:
if (connection != NULL)
g_object_unref (connection);
return ret;
}
static gboolean
get_caller_pid (GDBusMethodInvocation *context,
GPid *pid)
{
GVariant *reply;
GError *error;
guint32 pid_as_int;
error = NULL;
reply = g_dbus_connection_call_sync (g_dbus_method_invocation_get_connection (context),
"org.freedesktop.DBus",
"/org/freedesktop/DBus",
"org.freedesktop.DBus",
"GetConnectionUnixProcessID",
g_variant_new ("(s)",
g_dbus_method_invocation_get_sender (context)),
G_VARIANT_TYPE ("(u)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (reply == NULL) {
g_warning ("Could not talk to message bus to find uid of sender %s: %s",
g_dbus_method_invocation_get_sender (context),
error->message);
g_error_free (error);
return FALSE;
}
g_variant_get (reply, "(u)", &pid_as_int);
*pid = pid_as_int;
g_variant_unref (reply);
return TRUE;
}
/**
* pk_offline_update_power_off:
**/
static void
pk_offline_update_power_off (void)
{
_cleanup_error_free_ GError *error = NULL;
_cleanup_object_unref_ GDBusConnection *connection = NULL;
_cleanup_variant_unref_ GVariant *val = NULL;
/* reboot using systemd */
sd_journal_print (LOG_INFO, "shutting down");
pk_offline_update_set_plymouth_mode ("shutdown");
/* TRANSLATORS: we've finished doing offline updates */
pk_offline_update_set_plymouth_msg (_("Shutting down after installing updates…"));
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (connection == NULL) {
sd_journal_print (LOG_WARNING,
"Failed to get system bus connection: %s",
error->message);
return;
}
val = g_dbus_connection_call_sync (connection,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"PowerOff",
NULL,
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (val == NULL) {
sd_journal_print (LOG_WARNING,
"Failed to power off: %s",
error->message);
return;
}
}
/**
* caja_uninhibit_power_manager:
* @cookie: the cookie value returned by caja_inhibit_power_manager()
*
* Uninhibits power management. This function must be called after the task
* which inhibited power management has finished, or the system will not
* return to normal power management.
*/
void
caja_uninhibit_power_manager (gint cookie)
{
GDBusConnection *connection;
GVariant *result;
GError *error = NULL;
g_return_if_fail (cookie > 0);
connection = get_dbus_connection ();
if (connection == NULL)
{
return;
}
result = g_dbus_connection_call_sync (connection,
GSM_NAME,
GSM_PATH,
GSM_INTERFACE,
"Uninhibit",
g_variant_new ("(u)", (guint) cookie),
NULL,
G_DBUS_CALL_FLAGS_NO_AUTO_START,
-1,
NULL,
&error);
if (result == NULL)
{
g_warning ("Could not uninhibit power management: %s", error->message);
g_error_free (error);
return;
}
g_variant_unref (result);
}
static gboolean
name_exists (GDBusConnection *c, const char *name)
{
GVariant *reply;
gboolean exists = FALSE;
reply = g_dbus_connection_call_sync (c,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"GetNameOwner",
g_variant_new ("(s)", name),
NULL,
G_DBUS_CALL_FLAGS_NO_AUTO_START,
-1,
NULL,
NULL);
if (reply != NULL) {
exists = TRUE;
g_variant_unref (reply);
}
return exists;
}
int dt_init(int argc, char *argv[], const int init_gui,lua_State *L)
{
#ifndef __WIN32__
if(getuid() == 0 || geteuid() == 0)
printf("WARNING: either your user id or the effective user id are 0. are you running darktable as root?\n");
#endif
// make everything go a lot faster.
_MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
#if !defined __APPLE__ && !defined __WIN32__
_dt_sigsegv_old_handler = signal(SIGSEGV,&_dt_sigsegv_handler);
#endif
#ifndef __GNUC_PREREQ
// on OSX, gcc-4.6 and clang chokes if this is not here.
#if defined __GNUC__ && defined __GNUC_MINOR__
# define __GNUC_PREREQ(maj, min) \
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
#else
# define __GNUC_PREREQ(maj, min) 0
#endif
#endif
#ifndef __has_builtin
// http://clang.llvm.org/docs/LanguageExtensions.html#feature-checking-macros
#define __has_builtin(x) false
#endif
#ifndef __SSE3__
#error "Unfortunately we depend on SSE3 instructions at this time."
#error "Please contribute a backport patch (or buy a newer processor)."
#else
#if (__GNUC_PREREQ(4,8) || __has_builtin(__builtin_cpu_supports))
//FIXME: check will work only in GCC 4.8+ !!! implement manual cpuid check !!!
//NOTE: _may_i_use_cpu_feature() looks better, but only avaliable in ICC
if (!__builtin_cpu_supports("sse3"))
{
fprintf(stderr, "[dt_init] unfortunately we depend on SSE3 instructions at this time.\n");
fprintf(stderr, "[dt_init] please contribute a backport patch (or buy a newer processor).\n");
return 1;
}
#else
//FIXME: no way to check for SSE3 in runtime, implement manual cpuid check !!!
#endif
#endif
#ifdef M_MMAP_THRESHOLD
mallopt(M_MMAP_THRESHOLD,128*1024) ; /* use mmap() for large allocations */
#endif
// we have to have our share dir in XDG_DATA_DIRS,
// otherwise GTK+ won't find our logo for the about screen (and maybe other things)
{
const gchar *xdg_data_dirs = g_getenv("XDG_DATA_DIRS");
gchar *new_xdg_data_dirs = NULL;
gboolean set_env = TRUE;
if(xdg_data_dirs != NULL && *xdg_data_dirs != '\0')
{
// check if DARKTABLE_SHAREDIR is already in there
gboolean found = FALSE;
gchar **tokens = g_strsplit(xdg_data_dirs, ":", 0);
// xdg_data_dirs is neither NULL nor empty => tokens != NULL
for(char **iter = tokens; *iter != NULL; iter++)
if(!strcmp(DARKTABLE_SHAREDIR, *iter))
{
found = TRUE;
break;
}
g_strfreev(tokens);
if(found)
set_env = FALSE;
else
new_xdg_data_dirs = g_strjoin(":", DARKTABLE_SHAREDIR, xdg_data_dirs, NULL);
}
else
{
// see http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html for a reason to use those as a default
if(!g_strcmp0(DARKTABLE_SHAREDIR, "/usr/local/share") || !g_strcmp0(DARKTABLE_SHAREDIR, "/usr/local/share/") ||
!g_strcmp0(DARKTABLE_SHAREDIR, "/usr/share") || !g_strcmp0(DARKTABLE_SHAREDIR, "/usr/share/"))
new_xdg_data_dirs = g_strdup("/usr/local/share/:/usr/share/");
else
new_xdg_data_dirs = g_strdup_printf("%s:/usr/local/share/:/usr/share/", DARKTABLE_SHAREDIR);
}
if(set_env)
g_setenv("XDG_DATA_DIRS", new_xdg_data_dirs, 1);
g_free(new_xdg_data_dirs);
}
setlocale(LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, DARKTABLE_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
// init all pointers to 0:
memset(&darktable, 0, sizeof(darktable_t));
darktable.progname = argv[0];
// database
gchar *dbfilename_from_command = NULL;
char *datadir_from_command = NULL;
char *moduledir_from_command = NULL;
char *tmpdir_from_command = NULL;
char *configdir_from_command = NULL;
char *cachedir_from_command = NULL;
#ifdef USE_LUA
char *lua_command = NULL;
#endif
darktable.num_openmp_threads = 1;
#ifdef _OPENMP
darktable.num_openmp_threads = omp_get_num_procs();
#endif
darktable.unmuted = 0;
GSList *images_to_load = NULL, *config_override = NULL;
for(int k=1; k<argc; k++)
{
if(argv[k][0] == '-')
{
if(!strcmp(argv[k], "--help"))
{
return usage(argv[0]);
}
if(!strcmp(argv[k], "-h"))
{
return usage(argv[0]);
}
else if(!strcmp(argv[k], "--version"))
{
printf("this is "PACKAGE_STRING"\ncopyright (c) 2009-2014 johannes hanika\n"PACKAGE_BUGREPORT"\n"
#ifdef _OPENMP
"OpenMP support enabled\n"
#else
"OpenMP support disabled\n"
#endif
);
return 1;
}
else if(!strcmp(argv[k], "--library"))
{
dbfilename_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--datadir"))
{
datadir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--moduledir"))
{
moduledir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--tmpdir"))
{
tmpdir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--configdir"))
{
configdir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--cachedir"))
{
cachedir_from_command = argv[++k];
}
else if(!strcmp(argv[k], "--localedir"))
{
bindtextdomain (GETTEXT_PACKAGE, argv[++k]);
}
else if(argv[k][1] == 'd' && argc > k+1)
{
if(!strcmp(argv[k+1], "all")) darktable.unmuted = 0xffffffff; // enable all debug information
else if(!strcmp(argv[k+1], "cache")) darktable.unmuted |= DT_DEBUG_CACHE; // enable debugging for lib/film/cache module
else if(!strcmp(argv[k+1], "control")) darktable.unmuted |= DT_DEBUG_CONTROL; // enable debugging for scheduler module
else if(!strcmp(argv[k+1], "dev")) darktable.unmuted |= DT_DEBUG_DEV; // develop module
else if(!strcmp(argv[k+1], "fswatch")) darktable.unmuted |= DT_DEBUG_FSWATCH; // fswatch module
else if(!strcmp(argv[k+1], "input")) darktable.unmuted |= DT_DEBUG_INPUT; // input devices
else if(!strcmp(argv[k+1], "camctl")) darktable.unmuted |= DT_DEBUG_CAMCTL; // camera control module
else if(!strcmp(argv[k+1], "perf")) darktable.unmuted |= DT_DEBUG_PERF; // performance measurements
else if(!strcmp(argv[k+1], "pwstorage")) darktable.unmuted |= DT_DEBUG_PWSTORAGE; // pwstorage module
else if(!strcmp(argv[k+1], "opencl")) darktable.unmuted |= DT_DEBUG_OPENCL; // gpu accel via opencl
else if(!strcmp(argv[k+1], "sql")) darktable.unmuted |= DT_DEBUG_SQL; // SQLite3 queries
else if(!strcmp(argv[k+1], "memory")) darktable.unmuted |= DT_DEBUG_MEMORY; // some stats on mem usage now and then.
else if(!strcmp(argv[k+1], "lighttable")) darktable.unmuted |= DT_DEBUG_LIGHTTABLE; // lighttable related stuff.
else if(!strcmp(argv[k+1], "nan")) darktable.unmuted |= DT_DEBUG_NAN; // check for NANs when processing the pipe.
else if(!strcmp(argv[k+1], "masks")) darktable.unmuted |= DT_DEBUG_MASKS; // masks related stuff.
else if(!strcmp(argv[k+1], "lua")) darktable.unmuted |= DT_DEBUG_LUA; // lua errors are reported on console
else return usage(argv[0]);
k ++;
}
else if(argv[k][1] == 't' && argc > k+1)
{
darktable.num_openmp_threads = CLAMP(atol(argv[k+1]), 1, 100);
printf("[dt_init] using %d threads for openmp parallel sections\n", darktable.num_openmp_threads);
k ++;
}
else if(!strcmp(argv[k], "--conf"))
{
gchar *keyval = g_strdup(argv[++k]), *c = keyval;
gchar *end = keyval + strlen(keyval);
while(*c != '=' && c < end) c++;
if(*c == '=' && *(c+1) != '\0')
{
*c++ = '\0';
dt_conf_string_entry_t *entry = (dt_conf_string_entry_t*)g_malloc(sizeof(dt_conf_string_entry_t));
entry->key = g_strdup(keyval);
entry->value = g_strdup(c);
config_override = g_slist_append(config_override, entry);
}
g_free(keyval);
}
else if(!strcmp(argv[k], "--luacmd"))
{
#ifdef USE_LUA
lua_command = argv[++k];
#else
++k;
#endif
}
}
#ifndef MAC_INTEGRATION
else
{
images_to_load = g_slist_append(images_to_load, argv[k]);
}
#endif
}
if(darktable.unmuted & DT_DEBUG_MEMORY)
{
fprintf(stderr, "[memory] at startup\n");
dt_print_mem_usage();
}
#ifdef _OPENMP
omp_set_num_threads(darktable.num_openmp_threads);
#endif
dt_loc_init_datadir(datadir_from_command);
dt_loc_init_plugindir(moduledir_from_command);
if(dt_loc_init_tmp_dir(tmpdir_from_command))
{
printf(_("ERROR : invalid temporary directory : %s\n"),darktable.tmpdir);
return usage(argv[0]);
}
dt_loc_init_user_config_dir(configdir_from_command);
dt_loc_init_user_cache_dir(cachedir_from_command);
#if !GLIB_CHECK_VERSION(2, 35, 0)
g_type_init();
#endif
// does not work, as gtk is not inited yet.
// even if it were, it's a super bad idea to invoke gtk stuff from
// a signal handler.
/* check cput caps */
// dt_check_cpu(argc,argv);
#ifdef HAVE_GEGL
char geglpath[PATH_MAX];
char datadir[PATH_MAX];
dt_loc_get_datadir(datadir, sizeof(datadir));
snprintf(geglpath, sizeof(geglpath), "%s/gegl:/usr/lib/gegl-0.0", datadir);
(void)setenv("GEGL_PATH", geglpath, 1);
gegl_init(&argc, &argv);
#endif
#ifdef USE_LUA
dt_lua_init_early(L);
#endif
// thread-safe init:
dt_exif_init();
char datadir[PATH_MAX];
dt_loc_get_user_config_dir (datadir, sizeof(datadir));
char filename[PATH_MAX];
snprintf(filename, sizeof(filename), "%s/darktablerc", datadir);
// initialize the config backend. this needs to be done first...
darktable.conf = (dt_conf_t *)calloc(1, sizeof(dt_conf_t));
dt_conf_init(darktable.conf, filename, config_override);
g_slist_free_full(config_override, g_free);
// set the interface language
const gchar* lang = dt_conf_get_string("ui_last/gui_language"); // we may not g_free 'lang' since it is owned by setlocale afterwards
if(lang != NULL && lang[0] != '\0')
{
if(setlocale(LC_ALL, lang) != NULL)
gtk_disable_setlocale();
}
// initialize the database
darktable.db = dt_database_init(dbfilename_from_command);
if(darktable.db == NULL)
{
printf("ERROR : cannot open database\n");
return 1;
}
else if(!dt_database_get_lock_acquired(darktable.db))
{
// send the images to the other instance via dbus
if(images_to_load)
{
GSList *p = images_to_load;
// get a connection!
GDBusConnection *connection = g_bus_get_sync(G_BUS_TYPE_SESSION,NULL, NULL);
while (p != NULL)
{
// make the filename absolute ...
gchar *filename = dt_make_path_absolute((gchar*)p->data);
if(filename == NULL) continue;
// ... and send it to the running instance of darktable
g_dbus_connection_call_sync(connection,
"org.darktable.service",
"/darktable",
"org.darktable.service.Remote",
"Open",
g_variant_new ("(s)", filename),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL);
p = g_slist_next(p);
g_free(filename);
}
g_slist_free(images_to_load);
g_object_unref(connection);
}
return 1;
}
// Initialize the signal system
darktable.signals = dt_control_signal_init();
// Make sure that the database and xmp files are in sync before starting the fswatch.
// We need conf and db to be up and running for that which is the case here.
// FIXME: is this also useful in non-gui mode?
GList *changed_xmp_files = NULL;
if(init_gui && dt_conf_get_bool("run_crawler_on_start"))
{
changed_xmp_files = dt_control_crawler_run();
}
// Initialize the filesystem watcher
darktable.fswatch=dt_fswatch_new();
#ifdef HAVE_GPHOTO2
// Initialize the camera control
darktable.camctl=dt_camctl_new();
#endif
// get max lighttable thumbnail size:
darktable.thumbnail_width = CLAMPS(dt_conf_get_int("plugins/lighttable/thumbnail_width"), 200, 3000);
darktable.thumbnail_height = CLAMPS(dt_conf_get_int("plugins/lighttable/thumbnail_height"), 200, 3000);
// and make sure it can be mip-mapped all the way from mip4 to mip0
darktable.thumbnail_width /= 16;
darktable.thumbnail_width *= 16;
darktable.thumbnail_height /= 16;
darktable.thumbnail_height *= 16;
// Initialize the password storage engine
darktable.pwstorage=dt_pwstorage_new();
// FIXME: move there into dt_database_t
dt_pthread_mutex_init(&(darktable.db_insert), NULL);
dt_pthread_mutex_init(&(darktable.plugin_threadsafe), NULL);
dt_pthread_mutex_init(&(darktable.capabilities_threadsafe), NULL);
darktable.control = (dt_control_t *)calloc(1, sizeof(dt_control_t));
if(init_gui)
{
dt_control_init(darktable.control);
}
else
{
if(dbfilename_from_command && !strcmp(dbfilename_from_command, ":memory:"))
dt_gui_presets_init(); // init preset db schema.
darktable.control->running = 0;
darktable.control->accelerators = NULL;
dt_pthread_mutex_init(&darktable.control->run_mutex, NULL);
}
// initialize collection query
darktable.collection_listeners = NULL;
darktable.collection = dt_collection_new(NULL);
/* initialize selection */
darktable.selection = dt_selection_new();
/* capabilities set to NULL */
darktable.capabilities = NULL;
#ifdef HAVE_GRAPHICSMAGICK
/* GraphicsMagick init */
InitializeMagick(darktable.progname);
#endif
darktable.opencl = (dt_opencl_t *)calloc(1, sizeof(dt_opencl_t));
#ifdef HAVE_OPENCL
dt_opencl_init(darktable.opencl, argc, argv);
#endif
darktable.blendop = (dt_blendop_t *)calloc(1, sizeof(dt_blendop_t));
dt_develop_blend_init(darktable.blendop);
darktable.points = (dt_points_t *)calloc(1, sizeof(dt_points_t));
dt_points_init(darktable.points, dt_get_num_threads());
// must come before mipmap_cache, because that one will need to access
// image dimensions stored in here:
darktable.image_cache = (dt_image_cache_t *)calloc(1, sizeof(dt_image_cache_t));
dt_image_cache_init(darktable.image_cache);
darktable.mipmap_cache = (dt_mipmap_cache_t *)calloc(1, sizeof(dt_mipmap_cache_t));
dt_mipmap_cache_init(darktable.mipmap_cache);
// The GUI must be initialized before the views, because the init()
// functions of the views depend on darktable.control->accels_* to register
// their keyboard accelerators
if(init_gui)
{
darktable.gui = (dt_gui_gtk_t *)calloc(1, sizeof(dt_gui_gtk_t));
if(dt_gui_gtk_init(darktable.gui, argc, argv)) return 1;
dt_bauhaus_init();
}
else darktable.gui = NULL;
darktable.view_manager = (dt_view_manager_t *)calloc(1, sizeof(dt_view_manager_t));
dt_view_manager_init(darktable.view_manager);
darktable.imageio = (dt_imageio_t *)calloc(1, sizeof(dt_imageio_t));
dt_imageio_init(darktable.imageio);
// load the darkroom mode plugins once:
dt_iop_load_modules_so();
if(init_gui)
{
darktable.lib = (dt_lib_t *)calloc(1, sizeof(dt_lib_t));
dt_lib_init(darktable.lib);
dt_control_load_config(darktable.control);
}
if(init_gui)
{
// Loading the keybindings
char keyfile[PATH_MAX];
// First dump the default keymapping
snprintf(keyfile, sizeof(keyfile), "%s/keyboardrc_default", datadir);
gtk_accel_map_save(keyfile);
// Removing extraneous semi-colons from the default keymap
strip_semicolons_from_keymap(keyfile);
// Then load any modified keys if available
snprintf(keyfile, sizeof(keyfile), "%s/keyboardrc", datadir);
if(g_file_test(keyfile, G_FILE_TEST_EXISTS))
gtk_accel_map_load(keyfile);
else
gtk_accel_map_save(keyfile); // Save the default keymap if none is present
// I doubt that connecting to dbus for darktable-cli makes sense
darktable.dbus = dt_dbus_init();
// initialize undo struct
darktable.undo = dt_undo_init();
// load image(s) specified on cmdline
int id = 0;
if(images_to_load)
{
// If only one image is listed, attempt to load it in darkroom
gboolean load_in_dr = (g_slist_next(images_to_load) == NULL);
GSList *p = images_to_load;
while (p != NULL)
{
// don't put these function calls into MAX(), the macro will evaluate
// it twice (and happily deadlock, in this particular case)
int newid = dt_load_from_string((gchar*)p->data, load_in_dr);
id = MAX(id, newid);
p = g_slist_next(p);
}
if (!load_in_dr || id == 0)
dt_ctl_switch_mode_to(DT_LIBRARY);
g_slist_free(images_to_load);
}
else
dt_ctl_switch_mode_to(DT_LIBRARY);
}
if(darktable.unmuted & DT_DEBUG_MEMORY)
{
fprintf(stderr, "[memory] after successful startup\n");
dt_print_mem_usage();
}
dt_image_local_copy_synch();
/* init lua last, since it's user made stuff it must be in the real environment */
#ifdef USE_LUA
dt_lua_init(darktable.lua_state.state,lua_command);
#endif
// last but not least construct the popup that asks the user about images whose xmp files are newer than the db entry
if(init_gui && changed_xmp_files)
{
dt_control_crawler_show_image_list(changed_xmp_files);
}
return 0;
}
static void _setup_agent_and_adapters(GTlmNfc* self)
{
GError *error = NULL;
/* Introspection data for the agent object we are exporting */
const gchar introspection_xml[] =
"<node>"
" <interface name='org.neard.NDEFAgent'>"
" <method name='GetNDEF'>"
" <arg type='a{sv}' name='values' direction='in'/>"
" </method>"
" <method name='Release'>"
" </method>"
" </interface>"
"</node>";
const GDBusInterfaceVTable interface_vtable =
{
_handle_agent_method_call,
_handle_agent_get_property,
_handle_agent_set_property
};
self->system_bus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (self->system_bus == NULL) {
g_debug ("Error getting a system bus: %s", error->message);
g_error_free (error);
return;
}
GDBusNodeInfo *introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
self->agent_registration_id = g_dbus_connection_register_object (self->system_bus,
"/org/tlmnfc/agent",
introspection_data->interfaces[0],
&interface_vtable,
self,
NULL,
&error);
if (self->agent_registration_id <= 0) {
g_debug ("Error registering an agent object: %s", error->message);
g_dbus_node_info_unref (introspection_data);
g_error_free (error);
return;
}
g_dbus_node_info_unref (introspection_data);
GVariant* agent_register_response = g_dbus_connection_call_sync (self->system_bus,
"org.neard",
"/org/neard",
"org.neard.AgentManager",
"RegisterNDEFAgent",
g_variant_new("(os)",
"/org/tlmnfc/agent",
"application/gtlm-nfc"),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (agent_register_response == NULL) {
g_debug ("Error registering an agent with neard: %s", error->message);
g_error_free (error);
return;
}
g_variant_unref(agent_register_response);
self->neard_manager = g_dbus_object_manager_client_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
"org.neard",
"/",
NULL, NULL, NULL, NULL,
&error);
if (self->neard_manager == NULL)
{
g_debug ("Error creating neard object manager: %s", error->message);
g_error_free (error);
return ;
}
// subscribe to interface added/removed signals
g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager),
"interface-added",
G_CALLBACK (_on_interface_added),
self);
g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager),
"interface-removed",
G_CALLBACK (_on_interface_removed),
self);
g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager),
"object-added",
G_CALLBACK (_on_object_added),
self);
g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager),
"object-removed",
G_CALLBACK (_on_object_removed),
self);
g_signal_connect (G_DBUS_OBJECT_MANAGER(self->neard_manager),
"interface-proxy-properties-changed",
G_CALLBACK (_on_property_changed),
self);
_setup_nfc_adapters(self);
return;
}
static void
_setup_nfc_adapter(GTlmNfc *self, GDBusProxy *nfc_adapter)
{
GError* error = NULL;
gboolean powered;
gboolean polling;
// for some reason the cached properties aren't updated, so we request them directly
//GVariant* powered_v = g_dbus_proxy_get_cached_property(nfc_adapter, "Powered");
GVariant* powered_resp = g_dbus_connection_call_sync (self->system_bus,
"org.neard",
g_dbus_proxy_get_object_path(nfc_adapter) ,
"org.freedesktop.DBus.Properties",
"Get",
g_variant_new("(ss)",
g_dbus_proxy_get_interface_name(nfc_adapter),
"Powered"
),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (powered_resp == NULL) {
g_debug("Powered property is absent on an adapter: %s", error->message);
g_error_free (error);
return;
}
GVariant* powered_v;
g_variant_get_child(powered_resp, 0, "v", &powered_v);
if (powered_v == NULL || !g_variant_is_of_type(powered_v, G_VARIANT_TYPE_BOOLEAN)) {
g_debug("Error retrieving powered property");
return;
}
powered = g_variant_get_boolean(powered_v);
g_variant_unref(powered_resp);
//GVariant* polling_v = g_dbus_proxy_get_cached_property(nfc_adapter, "Polling");
GVariant* polling_resp = g_dbus_connection_call_sync (self->system_bus,
"org.neard",
g_dbus_proxy_get_object_path(nfc_adapter) ,
"org.freedesktop.DBus.Properties",
"Get",
g_variant_new("(ss)",
g_dbus_proxy_get_interface_name(nfc_adapter),
"Polling"
),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (polling_resp == NULL) {
g_debug("Polling property is absent on an adapter: %s", error->message);
g_error_free (error);
return;
}
GVariant* polling_v;
g_variant_get_child(polling_resp, 0, "v", &polling_v);
if (polling_v == NULL || !g_variant_is_of_type(polling_v, G_VARIANT_TYPE_BOOLEAN)) {
g_debug("Error retrieving polling property");
return;
}
polling = g_variant_get_boolean(polling_v);
g_variant_unref(polling_resp);
GVariant* response;
if (powered == FALSE) {
// switch power on
response = g_dbus_connection_call_sync (self->system_bus,
"org.neard",
g_dbus_proxy_get_object_path(nfc_adapter) ,
"org.freedesktop.DBus.Properties",
"Set",
g_variant_new("(ssv)",
g_dbus_proxy_get_interface_name(nfc_adapter),
"Powered",
g_variant_new_boolean(TRUE)
),
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (response == NULL ) {
g_debug("Error swithing NFC adapter on: %s", error->message);
g_error_free (error);
return;
}
g_variant_unref(response);
g_debug("Switched NFC adapter on");
} else
g_debug("Adapter already switched on");
if (polling == FALSE) {
// start polling
response = g_dbus_proxy_call_sync (nfc_adapter,
"StartPollLoop",
g_variant_new("(s)", "Initiator"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (response == NULL)
{
g_debug("Error starting NFC poll loop: %s", error->message);
g_error_free (error);
return;
}
g_variant_unref(response);
g_debug("Started NFC poll loop");
} else
g_debug("Adapter already in polling mode");
}
static gboolean
gimp_unique_dbus_open (const gchar **filenames,
gboolean as_new)
{
#ifndef GIMP_CONSOLE_COMPILATION
/* for the DBus service names */
#include "gui/gimpdbusservice.h"
GDBusConnection *connection;
GError *error = NULL;
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (connection)
{
gboolean success = TRUE;
if (filenames)
{
const gchar *method = as_new ? "OpenAsNew" : "Open";
gchar *cwd = g_get_current_dir ();
gint i;
for (i = 0; filenames[i] && success; i++)
{
GFile *file;
file = g_file_new_for_commandline_arg_and_cwd (filenames[i], cwd);
if (file)
{
GVariant *result;
gchar *uri = g_file_get_uri (file);
result = g_dbus_connection_call_sync (connection,
GIMP_DBUS_SERVICE_NAME,
GIMP_DBUS_SERVICE_PATH,
GIMP_DBUS_INTERFACE_NAME,
method,
g_variant_new ("(s)",
uri),
NULL,
G_DBUS_CALL_FLAGS_NO_AUTO_START,
-1,
NULL, NULL);
g_free (uri);
if (result)
g_variant_unref (result);
else
success = FALSE;
g_object_unref (file);
}
else
{
g_printerr ("conversion to uri failed for '%s'\n",
filenames[i]);
}
}
g_free (cwd);
}
else
{
GVariant *result;
result = g_dbus_connection_call_sync (connection,
GIMP_DBUS_SERVICE_NAME,
GIMP_DBUS_SERVICE_PATH,
GIMP_DBUS_INTERFACE_NAME,
"Activate",
NULL,
NULL,
G_DBUS_CALL_FLAGS_NO_AUTO_START,
-1,
NULL, NULL);
if (result)
g_variant_unref (result);
else
success = FALSE;
}
g_object_unref (connection);
return success;
}
else
{
g_printerr ("%s\n", error->message);
g_clear_error (&error);
}
#endif
return FALSE;
}
static gint
enable_ssh_service ()
{
GDBusConnection *connection;
GError *error = NULL;
GVariant *temp_variant;
connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (!connection)
{
g_critical ("Error connecting to D-Bus system bus: %s", error->message);
g_clear_error (&error);
return 1;
}
temp_variant = g_dbus_connection_call_sync (connection,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"StartUnit",
g_variant_new ("(ss)",
SSHD_SERVICE,
"replace"),
(GVariantType *) "(o)",
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (!temp_variant)
{
g_critical ("Error starting " SSHD_SERVICE ": %s", error->message);
g_clear_error (&error);
return 1;
}
g_variant_unref (temp_variant);
temp_variant = g_dbus_connection_call_sync (connection,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"EnableUnitFiles",
g_variant_new ("(^asbb)",
service_list,
FALSE, FALSE),
(GVariantType *) "(ba(sss))",
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
if (!temp_variant)
{
g_critical ("Error enabling " SSHD_SERVICE ": %s", error->message);
g_clear_error (&error);
return 1;
}
g_variant_unref (temp_variant);
return 0;
}
static void
test_getservers_uccs (void)
{
DbusTestService * service = dbus_test_service_new(NULL);
/* RLS */
DbusTestProcess * rls = dbus_test_process_new(REMOTE_LOGON_SERVICE);
dbus_test_process_append_param(rls, "--config-file=" UCCS_CONFIG_FILE);
dbus_test_service_add_task(service, DBUS_TEST_TASK(rls));
/* Dummy */
DbusTestTask * dummy = dbus_test_task_new();
dbus_test_task_set_wait_for(dummy, "org.ArcticaProject.RemoteLogon");
dbus_test_service_add_task(service, dummy);
/* Get RLS up and running and us on that bus */
dbus_test_service_start_tasks(service);
GDBusConnection * session = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
g_dbus_connection_set_exit_on_close(session, FALSE);
GVariant * retval = g_dbus_connection_call_sync(session,
"org.ArcticaProject.RemoteLogon",
"/org/ArcticaProject/RemoteLogon",
"org.ArcticaProject.RemoteLogon",
"GetServers",
NULL, /* params */
G_VARIANT_TYPE("(a(sssba(sbva{sv})a(si)))"), /* ret type */
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL);
g_assert(retval != NULL);
g_assert(g_variant_n_children(retval) == 1);
GVariant * array = g_variant_get_child_value(retval, 0);
g_assert(g_variant_n_children(array) == 1);
g_assert(g_variant_is_of_type(array, G_VARIANT_TYPE_ARRAY));
GVariant * tuple = g_variant_get_child_value(array, 0);
if (TRUE) { /* type check */
GVariant * type = g_variant_get_child_value(tuple, 0);
g_assert(g_variant_is_of_type(type, G_VARIANT_TYPE_STRING));
g_assert(g_strcmp0(g_variant_get_string(type, NULL), "uccs") == 0);
g_variant_unref(type);
}
if (TRUE) { /* name check */
GVariant * name = g_variant_get_child_value(tuple, 1);
g_assert(g_variant_is_of_type(name, G_VARIANT_TYPE_STRING));
g_assert(g_strcmp0(g_variant_get_string(name, NULL), "Test Server Name") == 0);
g_variant_unref(name);
}
if (TRUE) { /* uri check */
GVariant * uri = g_variant_get_child_value(tuple, 2);
g_assert(g_variant_is_of_type(uri, G_VARIANT_TYPE_STRING));
g_assert(g_strcmp0(g_variant_get_string(uri, NULL), "https://uccs.test.mycompany.com/") == 0);
g_variant_unref(uri);
}
g_variant_unref(tuple);
g_variant_unref(array);
g_variant_unref(retval);
g_object_unref(session);
g_object_unref(rls);
g_object_unref(service);
return;
}
/**
* gcm_utils_install_package:
**/
gboolean
gcm_utils_install_package (const gchar *package_name, GtkWindow *window)
{
GDBusConnection *connection;
GVariant *args = NULL;
GVariant *response = NULL;
GVariantBuilder *builder = NULL;
GError *error = NULL;
gboolean ret = FALSE;
guint32 xid = 0;
gchar **packages = NULL;
g_return_val_if_fail (package_name != NULL, FALSE);
#ifndef HAVE_PACKAGEKIT
g_warning ("cannot install %s: this package was not compiled with --enable-packagekit", package_name);
goto out;
#endif
/* get xid of this window */
if (window != NULL)
xid = gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET(window)));
/* we're expecting an array of packages */
packages = g_strsplit (package_name, "|", 1);
/* get a session bus connection */
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (connection == NULL) {
/* TRANSLATORS: no DBus session bus */
g_print ("%s %s\n", _("Failed to connect to session bus:"), error->message);
g_error_free (error);
goto out;
}
/* create arguments */
builder = g_variant_builder_new (G_VARIANT_TYPE ("(uass)"));
g_variant_builder_add_value (builder, g_variant_new_uint32 (xid));
g_variant_builder_add_value (builder, g_variant_new_strv ((const gchar * const *)packages, -1));
g_variant_builder_add_value (builder, g_variant_new_string ("hide-confirm-search,hide-finished"));
args = g_variant_builder_end (builder);
/* execute sync method */
response = g_dbus_connection_call_sync (connection,
PK_DBUS_SERVICE,
PK_DBUS_PATH,
PK_DBUS_INTERFACE_MODIFY,
"InstallPackageNames",
args,
NULL,
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT, NULL, &error);
if (response == NULL) {
/* TRANSLATORS: the DBus method failed */
g_warning ("%s %s\n", _("The request failed:"), error->message);
g_error_free (error);
goto out;
}
/* success */
ret = TRUE;
out:
if (builder != NULL)
g_variant_builder_unref (builder);
if (args != NULL)
g_variant_unref (args);
if (response != NULL)
g_variant_unref (response);
g_strfreev (packages);
return ret;
}
static void
enroll_fingerprints (GtkWindow *parent,
GtkWidget *label1,
GtkWidget *label2,
UmUser *user)
{
GDBusProxy *device;
GtkBuilder *dialog;
EnrollData *data;
GtkWidget *ass;
const char *filename;
char *msg;
GVariant *result;
GError *error = NULL;
device = NULL;
if (manager == NULL) {
create_manager ();
if (manager != NULL)
device = get_first_device ();
} else {
device = get_first_device ();
}
if (manager == NULL || device == NULL) {
GtkWidget *d;
d = get_error_dialog (_("Could not access any fingerprint readers"),
_("Please contact your system administrator for help."),
parent);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (d);
return;
}
data = g_new0 (EnrollData, 1);
data->device = device;
data->label1 = label1;
data->label2 = label2;
/* Get some details about the device */
result = g_dbus_connection_call_sync (connection,
"net.reactivated.Fprint",
g_dbus_proxy_get_object_path (data->device),
"org.freedesktop.DBus.Properties",
"GetAll",
g_variant_new ("(s)", "net.reactivated.Fprint.Device"),
G_VARIANT_TYPE ("(a{sv})"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL);
if (result) {
GVariant *props;
gchar *scan_type;
g_variant_get (result, "(@a{sv})", &props);
g_variant_lookup (props, "name", "s", &data->name);
g_variant_lookup (props, "scan-type", "s", &scan_type);
if (g_strcmp0 (scan_type, "swipe") == 0)
data->is_swipe = TRUE;
g_free (scan_type);
g_variant_unref (props);
g_variant_unref (result);
}
dialog = gtk_builder_new ();
filename = UIDIR "/account-fingerprint.ui";
if (!g_file_test (filename, G_FILE_TEST_EXISTS))
filename = "data/account-fingerprint.ui";
if (!gtk_builder_add_from_file (dialog, filename, &error)) {
g_error ("%s", error->message);
g_error_free (error);
return;
}
data->dialog = dialog;
ass = WID ("assistant");
gtk_window_set_title (GTK_WINDOW (ass), _("Enable Fingerprint Login"));
gtk_window_set_transient_for (GTK_WINDOW (ass), parent);
gtk_window_set_modal (GTK_WINDOW (ass), TRUE);
gtk_window_set_resizable (GTK_WINDOW (ass), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (ass), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect (G_OBJECT (ass), "cancel",
G_CALLBACK (assistant_cancelled), data);
g_signal_connect (G_OBJECT (ass), "close",
G_CALLBACK (assistant_cancelled), data);
g_signal_connect (G_OBJECT (ass), "prepare",
G_CALLBACK (assistant_prepare), data);
/* Page 1 */
gtk_combo_box_set_active (GTK_COMBO_BOX (WID ("finger_combobox")), 0);
g_signal_connect (G_OBJECT (WID ("radiobutton1")), "toggled",
G_CALLBACK (finger_radio_button_toggled), data);
g_signal_connect (G_OBJECT (WID ("radiobutton2")), "toggled",
G_CALLBACK (finger_radio_button_toggled), data);
g_signal_connect (G_OBJECT (WID ("radiobutton3")), "toggled",
G_CALLBACK (finger_radio_button_toggled), data);
g_signal_connect (G_OBJECT (WID ("finger_combobox")), "changed",
G_CALLBACK (finger_combobox_changed), data);
data->finger = selected_finger (dialog);
g_object_set_data (G_OBJECT (WID("page1")), "name", "intro");
/* translators:
* The variable is the name of the device, for example:
* "To enable fingerprint login, you need to save one of your fingerprints, using the
* 'Digital Persona U.are.U 4000/4000B' device."
*/
msg = g_strdup_printf (_("To enable fingerprint login, you need to save one of your fingerprints, using the '%s' device."),
data->name);
gtk_label_set_text (GTK_LABEL (WID("intro-label")), msg);
g_free (msg);
gtk_assistant_set_page_complete (GTK_ASSISTANT (ass), WID("page1"), TRUE);
gtk_assistant_set_page_title (GTK_ASSISTANT (ass), WID("page1"), _("Selecting finger"));
gtk_assistant_set_page_title (GTK_ASSISTANT (ass), WID("page2"), _("Enrolling fingerprints"));
gtk_assistant_set_page_title (GTK_ASSISTANT (ass), WID("page3"), _("Summary"));
/* Page 2 */
g_object_set_data (G_OBJECT (WID("page2")), "name", "enroll");
msg = g_strdup_printf (TR(finger_str_to_msg (data->finger, data->is_swipe)), data->name);
gtk_label_set_text (GTK_LABEL (WID("enroll-label")), msg);
g_free (msg);
/* Page 3 */
g_object_set_data (G_OBJECT (WID("page3")), "name", "summary");
data->ass = ass;
gtk_widget_show_all (ass);
}
static void
assistant_prepare (GtkAssistant *ass, GtkWidget *page, EnrollData *data)
{
const char *name;
name = g_object_get_data (G_OBJECT (page), "name");
if (name == NULL)
return;
if (g_str_equal (name, "enroll")) {
GError *error = NULL;
GtkBuilder *dialog = data->dialog;
char *path;
guint i;
GVariant *result;
gint num_enroll_stages;
if (!claim (data, &error)) {
GtkWidget *d;
char *msg;
/* translators:
* The variable is the name of the device, for example:
* "Could you not access "Digital Persona U.are.U 4000/4000B" device */
msg = g_strdup_printf (_("Could not access '%s' device"), data->name);
d = get_error_dialog (msg, error->message, GTK_WINDOW (data->ass));
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (d);
g_free (msg);
enroll_data_destroy (data);
return;
}
data->state = STATE_CLAIMED;
result = g_dbus_connection_call_sync (connection,
"net.reactivated.Fprint",
g_dbus_proxy_get_object_path (data->device),
"org.freedesktop.DBus.Properties",
"Get",
g_variant_new ("(ss)", "net.reactivated.Fprint.Device", "num-enroll-stages"),
G_VARIANT_TYPE ("(v)"),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
num_enroll_stages = 0;
if (result) {
GVariant *v;
g_variant_get (result, "(v)", &v);
num_enroll_stages = g_variant_get_int32 (v);
g_variant_unref (result);
g_variant_unref (v);
}
if (num_enroll_stages < 1) {
GtkWidget *d;
char *msg;
/* translators:
* The variable is the name of the device, for example:
* "Could you not access "Digital Persona U.are.U 4000/4000B" device */
msg = g_strdup_printf (_("Could not access '%s' device"), data->name);
d = get_error_dialog (msg, "net.reactivated.Fprint.Error.Internal", GTK_WINDOW (data->ass));
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (d);
g_free (msg);
enroll_data_destroy (data);
return;
}
data->num_enroll_stages = num_enroll_stages;
/* Hide the extra "bulbs" if not needed */
for (i = MAX_ENROLL_STAGES; i > data->num_enroll_stages; i--) {
char *name;
name = g_strdup_printf ("image%d", i);
gtk_widget_hide (WID (name));
g_free (name);
}
/* And set the right image */
{
char *filename;
filename = g_strdup_printf ("%s.png", data->finger);
path = g_build_filename (UM_PIXMAP_DIR, filename, NULL);
g_free (filename);
}
for (i = 1; i <= data->num_enroll_stages; i++) {
char *name;
name = g_strdup_printf ("image%d", i);
gtk_image_set_from_file (GTK_IMAGE (WID (name)), path);
g_free (name);
}
g_free (path);
g_signal_connect (data->device, "g-signal", G_CALLBACK (device_signal_cb), data);
if (!enroll_start (data, &error)) {
GtkWidget *d;
char *msg;
/* translators:
* The variable is the name of the device, for example:
* "Could you not access "Digital Persona U.are.U 4000/4000B" device */
msg = g_strdup_printf (_("Could not start finger capture on '%s' device"), data->name);
d = get_error_dialog (msg, error->message, GTK_WINDOW (data->ass));
g_error_free (error);
gtk_dialog_run (GTK_DIALOG (d));
gtk_widget_destroy (d);
g_free (msg);
enroll_data_destroy (data);
return;
}
data->state = STATE_ENROLLING;;
} else {
if (data->state == STATE_ENROLLING) {
enroll_stop (data, NULL);
data->state = STATE_CLAIMED;
}
if (data->state == STATE_CLAIMED) {
release (data, NULL);
data->state = STATE_NONE;
}
}
}