static char *
get_trigger_name (GUdevDevice *device)
{
GList *devices, *l;
GUdevClient *client;
gboolean has_trigger = FALSE;
char *trigger_name;
const gchar * const subsystems[] = { "iio", NULL };
client = g_udev_client_new (subsystems);
devices = g_udev_client_query_by_subsystem (client, "iio");
/* Find the associated trigger */
trigger_name = g_strdup_printf ("als-dev%s", g_udev_device_get_number (device));
for (l = devices; l != NULL; l = l->next) {
GUdevDevice *dev = l->data;
if (g_strcmp0 (trigger_name, g_udev_device_get_sysfs_attr (dev, "name")) == 0) {
g_debug ("Found associated trigger at %s", g_udev_device_get_sysfs_path (dev));
has_trigger = TRUE;
break;
}
}
g_list_free_full (devices, g_object_unref);
g_clear_object (&client);
if (has_trigger)
return trigger_name;
g_warning ("Could not find trigger name associated with %s",
g_udev_device_get_sysfs_path (device));
g_free (trigger_name);
return NULL;
}
static gboolean
synce_device_initable_init (GInitable *initable, GCancellable *cancellable, GError **error)
{
g_return_val_if_fail (SYNCE_IS_DEVICE(initable), FALSE);
SynceDevice *self = SYNCE_DEVICE(initable);
SynceDevicePrivate *priv = SYNCE_DEVICE_GET_PRIVATE (self);
if (cancellable != NULL) {
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Cancellable initialization not supported");
return FALSE;
}
#if HAVE_GUDEV
g_debug("%s: connecting to udev", G_STRFUNC);
if (!(priv->gudev_client = g_udev_client_new(udev_subsystems))) {
g_critical("%s: failed to initialize connection to udev", G_STRFUNC);
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to initialize connection to udev");
return FALSE;
}
if (g_signal_connect(priv->gudev_client, "uevent", G_CALLBACK(gudev_uevent_callback), self) < 1) {
g_critical("%s: failed to connect to uevent signal", G_STRFUNC);
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Failed to initialize connection to udev");
return FALSE;
}
#endif
priv->inited = TRUE;
return TRUE;
}
TcoreUdev *tcore_udev_new(Server *s, const gchar **subsystems)
{
TcoreUdev *udev;
udev = calloc(sizeof(struct tcore_udev_type), 1);
if (!udev)
return NULL;
if (!subsystems) {
subsystems = _default_subsystems;
}
udev->server = s;
udev->client = g_udev_client_new(subsystems);
if (!udev->client) {
free(udev);
return NULL;
}
g_signal_connect(udev->client, "uevent", G_CALLBACK(_on_uevent), udev);
udev->enumer = g_udev_enumerator_new(udev->client);
return udev;
}
static void
mm_manager_init (MMManager *manager)
{
MMManagerPrivate *priv;
const gchar *subsys[5] = { "tty", "net", "usb", "usbmisc", NULL };
/* Setup private data */
manager->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE ((manager),
MM_TYPE_MANAGER,
MMManagerPrivate);
/* Setup authorization provider */
priv->authp = mm_auth_get_provider ();
priv->authp_cancellable = g_cancellable_new ();
/* Setup internal lists of device objects */
priv->devices = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
/* Setup UDev client */
priv->udev = g_udev_client_new (subsys);
g_signal_connect (priv->udev, "uevent", G_CALLBACK (handle_uevent), manager);
/* Setup Object Manager Server */
priv->object_manager = g_dbus_object_manager_server_new (MM_DBUS_PATH);
/* Enable processing of input DBus messages */
g_signal_connect (manager,
"handle-set-logging",
G_CALLBACK (handle_set_logging),
NULL);
g_signal_connect (manager,
"handle-scan-devices",
G_CALLBACK (handle_scan_devices),
NULL);
}
static gboolean
input_accel_open (GUdevDevice *device,
ReadingsUpdateFunc callback_func,
gpointer user_data)
{
const gchar * const subsystems[] = { "input", NULL };
const char *mount_matrix;
drv_data = g_new0 (DrvData, 1);
drv_data->dev = g_object_ref (device);
drv_data->parent = g_udev_device_get_parent (drv_data->dev);
drv_data->dev_path = g_udev_device_get_device_file (device);
drv_data->name = g_udev_device_get_property (device, "NAME");
drv_data->client = g_udev_client_new (subsystems);
mount_matrix = g_udev_device_get_property (device, "ACCEL_MOUNT_MATRIX");
if (!parse_mount_matrix (mount_matrix, &drv_data->mount_matrix)) {
g_warning ("Invalid mount-matrix ('%s'), falling back to identity",
mount_matrix);
parse_mount_matrix (NULL, &drv_data->mount_matrix);
}
drv_data->callback_func = callback_func;
drv_data->user_data = user_data;
g_signal_connect (drv_data->client, "uevent",
G_CALLBACK (uevent_received), NULL);
g_idle_add (first_values, NULL);
return TRUE;
}
static void
nm_atm_manager_init (NMAtmManager *self)
{
NMAtmManagerPrivate *priv = NM_ATM_MANAGER_GET_PRIVATE (self);
const char *subsys[] = { "atm", NULL };
priv->client = g_udev_client_new (subsys);
g_signal_connect (priv->client, "uevent", G_CALLBACK (handle_uevent), self);
}
/**
* cd_sensor_client_init:
**/
static void
cd_sensor_client_init (CdSensorClient *sensor_client)
{
const gchar *subsystems[] = {"usb", "video4linux", NULL};
sensor_client->priv = CD_SENSOR_CLIENT_GET_PRIVATE (sensor_client);
sensor_client->priv->array_sensors = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
sensor_client->priv->gudev_client = g_udev_client_new (subsystems);
g_signal_connect (sensor_client->priv->gudev_client, "uevent",
G_CALLBACK (cd_sensor_client_uevent_cb), sensor_client);
}
int main (int argc, char **argv)
{
SensorData *data;
GUdevClient *client;
int ret = 0;
const gchar * const subsystems[] = { "iio", "input", "platform", NULL };
guint i;
/* g_setenv ("G_MESSAGES_DEBUG", "all", TRUE); */
data = g_new0 (SensorData, 1);
data->previous_orientation = ORIENTATION_UNDEFINED;
data->uses_lux = TRUE;
/* Set up D-Bus */
setup_dbus (data);
client = g_udev_client_new (subsystems);
if (!find_sensors (client, data)) {
g_debug ("Could not find any supported sensors");
return 0;
}
g_signal_connect (G_OBJECT (client), "uevent",
G_CALLBACK (sensor_changes), data);
for (i = 0; i < NUM_SENSOR_TYPES; i++) {
data->clients[i] = create_clients_hash_table ();
if (!driver_type_exists (data, i))
continue;
if (!driver_open (DRIVER_FOR_TYPE(i), DEVICE_FOR_TYPE(i),
driver_type_to_callback_func (data->drivers[i]->type), data)) {
DRIVER_FOR_TYPE(i) = NULL;
g_clear_object (&DEVICE_FOR_TYPE(i));
}
}
if (!any_sensors_left (data))
goto out;
data->init_done = TRUE;
if (data->connection) {
send_dbus_event (data, PROP_ALL);
send_dbus_event (data, PROP_ALL_COMPASS);
}
data->loop = g_main_loop_new (NULL, TRUE);
g_main_loop_run (data->loop);
out:
free_orientation_data (data);
return ret;
}
void
gs_plugin_initialize (GsPlugin *plugin)
{
GsPluginData *priv = gs_plugin_alloc_data (plugin, sizeof(GsPluginData));
gs_plugin_add_rule (plugin, GS_PLUGIN_RULE_RUN_AFTER, "appstream");
gs_plugin_add_rule (plugin, GS_PLUGIN_RULE_RUN_BEFORE, "icons");
priv->devices = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
priv->client = g_udev_client_new (NULL);
g_signal_connect (priv->client, "uevent",
G_CALLBACK (gs_plugin_modalias_uevent_cb), plugin);
}
/**
* fu_provider_udev_init:
**/
static void
fu_provider_udev_init (FuProviderUdev *provider_udev)
{
FuProviderUdevPrivate *priv = GET_PRIVATE (provider_udev);
const gchar *subsystems[] = { NULL };
priv->devices = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_object_unref);
priv->gudev_client = g_udev_client_new (subsystems);
g_signal_connect (priv->gudev_client, "uevent",
G_CALLBACK (fu_provider_udev_client_uevent_cb), provider_udev);
}
static void
empathy_camera_device_monitor_init (EmpathyCameraDeviceMonitor *monitor)
{
#ifdef HAVE_UDEV
EmpathyCameraDeviceMonitorPrivate *priv = EMPATHY_CAMERA_DEVICE_MONITOR_GET_PRIVATE (monitor);
const gchar *const subsystems[] = {"video4linux", NULL};
priv->client = g_udev_client_new (subsystems);
g_signal_connect (G_OBJECT (priv->client), "uevent",
G_CALLBACK (empathy_camera_device_monitor_uevent_cb), monitor);
#endif /* HAVE_UDEV */
}
/**
* cd_plugin_initialize:
*/
void
cd_plugin_initialize (CdPlugin *plugin)
{
const gchar *subsystems[] = { "usb", NULL };
/* create private */
plugin->priv = CD_PLUGIN_GET_PRIVATE (CdPluginPrivate);
plugin->priv->devices = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
(GDestroyNotify) g_object_unref);
plugin->priv->udev_client = g_udev_client_new (subsystems);
}
static void
mm_plugin_base_init (MMPluginBase *self)
{
MMPluginBasePrivate *priv = MM_PLUGIN_BASE_GET_PRIVATE (self);
const char *subsys[] = { "tty", "net", NULL };
if (!cached_caps)
cached_caps = g_hash_table_new (g_str_hash, g_str_equal);
priv->client = g_udev_client_new (subsys);
priv->tasks = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
(GDestroyNotify) g_object_unref);
}
gboolean
ubiquity_webcam_available (void) {
GUdevEnumerator *enumerator;
GUdevClient *client;
GList *devices;
guint length;
const gchar *const subsystems[] = {NULL};
client = g_udev_client_new (subsystems);
enumerator = g_udev_enumerator_new (client);
g_udev_enumerator_add_match_property (enumerator, "ID_V4L_CAPABILITIES", ":capture:");
devices = g_udev_enumerator_execute (enumerator);
length = g_list_length (devices);
g_list_free_full (devices, g_object_unref);
return length > 0;
}
static gboolean
fu_altos_device_find_tty (FuAltosDevice *self, GError **error)
{
GUsbDevice *usb_device = fu_usb_device_get_dev (FU_USB_DEVICE (self));
g_autoptr(GList) devices = NULL;
g_autoptr(GUdevClient) gudev_client = g_udev_client_new (NULL);
/* find all tty devices */
devices = g_udev_client_query_by_subsystem (gudev_client, "tty");
for (GList *l = devices; l != NULL; l = l->next) {
GUdevDevice *dev = G_UDEV_DEVICE (l->data);
/* get the tty device */
const gchar *dev_file = g_udev_device_get_device_file (dev);
if (dev_file == NULL)
continue;
/* get grandparent */
dev = g_udev_device_get_parent (dev);
if (dev == NULL)
continue;
dev = g_udev_device_get_parent (dev);
if (dev == NULL)
continue;
/* check correct device */
if (g_udev_device_get_sysfs_attr_as_int (dev, "busnum") !=
g_usb_device_get_bus (usb_device))
continue;
if (g_udev_device_get_sysfs_attr_as_int (dev, "devnum") !=
g_usb_device_get_address (usb_device))
continue;
/* success */
self->tty = g_strdup (dev_file);
return TRUE;
}
/* failure */
g_set_error (error,
FWUPD_ERROR,
FWUPD_ERROR_NOT_SUPPORTED,
"failed to find tty for %u:%u",
g_usb_device_get_bus (usb_device),
g_usb_device_get_address (usb_device));
return FALSE;
}
static void
update_dmi (Manager *manager)
{
GUdevClient *client = NULL;
GUdevDevice *device = NULL;
GString *str;
gchar *s;
/* TODO: Probably need some other and/or better heuristics to yield
* useful info on as many systems as possible
*/
client = g_udev_client_new (NULL);
device = g_udev_client_query_by_sysfs_path (client, "/sys/devices/virtual/dmi/id");
if (device == NULL)
goto out;
str = g_string_new (NULL);
g_string_append_printf (str, "%s %s (%s)",
g_udev_device_get_sysfs_attr (device, "bios_vendor"),
g_udev_device_get_sysfs_attr (device, "bios_version"),
g_udev_device_get_sysfs_attr (device, "bios_date"));
cockpit_manager_set_bios (COCKPIT_MANAGER (manager), str->str);
g_string_free (str, TRUE);
str = g_string_new (NULL);
g_string_append_printf (str, "%s %s",
g_udev_device_get_sysfs_attr (device, "sys_vendor"),
g_udev_device_get_sysfs_attr (device, "product_name"));
s = get_stripped_sysfs_attr (device, "product_version");
if (s != NULL)
{
g_string_append_printf (str, " (%s)", s);
g_free (s);
}
cockpit_manager_set_system (COCKPIT_MANAGER (manager), str->str);
g_string_free (str, TRUE);
s = get_stripped_sysfs_attr (device, "product_serial");
if (s == NULL)
s = get_stripped_sysfs_attr (device, "chassis_serial");
cockpit_manager_set_system_serial (COCKPIT_MANAGER (manager), s);
out:
g_clear_object (&device);
g_clear_object (&client);
}
void udev_detect(void)
{
GUdevClient *client;
const char *subsys[2] = { "tty", NULL };
GList *list, *iter;
client = g_udev_client_new(subsys);
list = g_udev_client_query_by_subsystem(client, subsys[0]);
for (iter = list; iter; iter = g_list_next(iter)) {
dump_device_and_parent(G_UDEV_DEVICE(iter->data), 0);
if (device_is_valid(G_UDEV_DEVICE(iter->data))) {
device_dump_config(G_UDEV_DEVICE(iter->data));
}
g_object_unref(G_UDEV_DEVICE(iter->data));
}
}
void
fu_plugin_init (FuPlugin *plugin)
{
FuPluginData *data = fu_plugin_alloc_data (plugin, sizeof (FuPluginData));
const gchar *subsystems[] = { "wmi", NULL };
data->udev = g_udev_client_new (subsystems);
g_signal_connect (data->udev, "uevent",
G_CALLBACK (udev_uevent_cb), plugin);
/* initially set to true, will wait for a device_register to reset */
data->needs_forcepower = TRUE;
/* determines whether to run device_registered */
fu_plugin_thunderbolt_power_get_path (plugin);
/* make sure it's tried to coldplug */
fu_plugin_add_rule (plugin, FU_PLUGIN_RULE_RUN_AFTER, "thunderbolt");
}
static void
udisks_linux_provider_init (UDisksLinuxProvider *provider)
{
const gchar *subsystems[] = {"block", "iscsi_connection", "scsi", NULL};
GFile *file;
GError *error = NULL;
/* get ourselves an udev client */
provider->gudev_client = g_udev_client_new (subsystems);
g_signal_connect (provider->gudev_client,
"uevent",
G_CALLBACK (on_uevent),
provider);
provider->probe_request_queue = g_async_queue_new ();
provider->probe_request_thread = g_thread_new ("probing-thread",
probe_request_thread_func,
provider);
file = g_file_new_for_path (PACKAGE_SYSCONF_DIR "/udisks2");
provider->etc_udisks2_dir_monitor = g_file_monitor_directory (file,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (provider->etc_udisks2_dir_monitor != NULL)
{
g_signal_connect (provider->etc_udisks2_dir_monitor,
"changed",
G_CALLBACK (on_etc_udisks2_dir_monitor_changed),
provider);
}
else
{
udisks_warning ("Error monitoring directory %s: %s (%s, %d)",
PACKAGE_SYSCONF_DIR "/udisks2",
error->message, g_quark_to_string (error->domain), error->code);
g_clear_error (&error);
}
g_object_unref (file);
}
static void
nm_rfkill_manager_init (NMRfkillManager *self)
{
NMRfkillManagerPrivate *priv = NM_RFKILL_MANAGER_GET_PRIVATE (self);
const char *subsys[] = { "rfkill", NULL };
GList *switches, *iter;
guint32 i;
for (i = 0; i < RFKILL_TYPE_MAX; i++)
priv->rfkill_states[i] = RFKILL_UNBLOCKED;
priv->client = g_udev_client_new (subsys);
g_signal_connect (priv->client, "uevent", G_CALLBACK (handle_uevent), self);
switches = g_udev_client_query_by_subsystem (priv->client, "rfkill");
for (iter = switches; iter; iter = g_list_next (iter)) {
add_one_killswitch (self, G_UDEV_DEVICE (iter->data));
g_object_unref (G_UDEV_DEVICE (iter->data));
}
g_list_free (switches);
recheck_killswitches (self);
}
static void
init (NMSettingsPlugin *config)
{
SettingsPluginIfupdown *self = SETTINGS_PLUGIN_IFUPDOWN (config);
SettingsPluginIfupdownPrivate *priv = SETTINGS_PLUGIN_IFUPDOWN_GET_PRIVATE (self);
GHashTable *auto_ifaces;
if_block *block = NULL;
GList *keys, *iter;
GHashTableIter con_iter;
const char *block_name;
NMIfupdownConnection *connection;
const char *subsys[2] = { "net", NULL };
auto_ifaces = g_hash_table_new (g_str_hash, g_str_equal);
if(!priv->connections)
priv->connections = g_hash_table_new (g_str_hash, g_str_equal);
if(!priv->kernel_ifaces)
priv->kernel_ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
if(!priv->eni_ifaces)
priv->eni_ifaces = g_hash_table_new (g_str_hash, g_str_equal);
nm_log_info (LOGD_SETTINGS, "init!");
priv->client = g_udev_client_new (subsys);
if (!priv->client) {
nm_log_warn (LOGD_SETTINGS, " error initializing libgudev");
} else
g_signal_connect (priv->client, "uevent", G_CALLBACK (handle_uevent), self);
/* Read in all the interfaces */
ifparser_init (ENI_INTERFACES_FILE, 0);
block = ifparser_getfirst ();
while (block) {
if(!strcmp ("auto", block->type) || !strcmp ("allow-hotplug", block->type))
g_hash_table_insert (auto_ifaces, block->name, GUINT_TO_POINTER (1));
else if (!strcmp ("iface", block->type)) {
NMIfupdownConnection *exported;
/* Bridge configuration */
if(!strncmp ("br", block->name, 2)) {
/* Try to find bridge ports */
const char *ports = ifparser_getkey (block, "bridge-ports");
if (ports) {
int i;
int state = 0;
char **port_ifaces;
nm_log_info (LOGD_SETTINGS, "found bridge ports %s for %s", ports, block->name);
port_ifaces = g_strsplit_set (ports, " \t", -1);
for (i = 0; i < g_strv_length (port_ifaces); i++) {
char *token = port_ifaces[i];
/* Skip crazy stuff like regex or all */
if (!strcmp ("all", token)) {
continue;
}
/* Small SM to skip everything inside regex */
if (!strcmp ("regex", token)) {
state++;
continue;
}
if (!strcmp ("noregex", token)) {
state--;
continue;
}
if (state == 0 && strlen (token) > 0) {
nm_log_info (LOGD_SETTINGS, "adding bridge port %s to eni_ifaces", token);
g_hash_table_insert (priv->eni_ifaces, g_strdup (token), "known");
}
}
g_strfreev (port_ifaces);
}
goto next;
}
/* Skip loopback configuration */
if(!strcmp ("lo", block->name)) {
goto next;
}
/* Remove any connection for this block that was previously found */
exported = g_hash_table_lookup (priv->connections, block->name);
if (exported) {
nm_log_info (LOGD_SETTINGS, "deleting %s from connections", block->name);
nm_settings_connection_delete (NM_SETTINGS_CONNECTION (exported), NULL, NULL);
g_hash_table_remove (priv->connections, block->name);
}
/* add the new connection */
exported = nm_ifupdown_connection_new (block);
if (exported) {
nm_log_info (LOGD_SETTINGS, "adding %s to connections", block->name);
g_hash_table_insert (priv->connections, block->name, exported);
}
nm_log_info (LOGD_SETTINGS, "adding iface %s to eni_ifaces", block->name);
g_hash_table_insert (priv->eni_ifaces, block->name, "known");
} else if (!strcmp ("mapping", block->type)) {
g_hash_table_insert (priv->eni_ifaces, block->name, "known");
nm_log_info (LOGD_SETTINGS, "adding mapping %s to eni_ifaces", block->name);
}
next:
block = block->next;
}
/* Make 'auto' interfaces autoconnect=TRUE */
g_hash_table_iter_init (&con_iter, priv->connections);
while (g_hash_table_iter_next (&con_iter, (gpointer) &block_name, (gpointer) &connection)) {
NMSettingConnection *setting;
if (g_hash_table_lookup (auto_ifaces, block_name)) {
setting = nm_connection_get_setting_connection (NM_CONNECTION (connection));
g_object_set (setting, NM_SETTING_CONNECTION_AUTOCONNECT, TRUE, NULL);
nm_log_info (LOGD_SETTINGS, "autoconnect");
}
}
g_hash_table_destroy (auto_ifaces);
/* Check the config file to find out whether to manage interfaces */
priv->unmanage_well_known = !nm_config_data_get_value_boolean (NM_CONFIG_GET_DATA_ORIG,
NM_CONFIG_KEYFILE_GROUP_IFUPDOWN,
NM_CONFIG_KEYFILE_KEY_IFUPDOWN_MANAGED,
!IFUPDOWN_UNMANAGE_WELL_KNOWN_DEFAULT);
nm_log_info (LOGD_SETTINGS, "management mode: %s", priv->unmanage_well_known ? "unmanaged" : "managed");
/* Add well-known interfaces */
keys = g_udev_client_query_by_subsystem (priv->client, "net");
for (iter = keys; iter; iter = g_list_next (iter)) {
udev_device_added (self, G_UDEV_DEVICE (iter->data));
g_object_unref (G_UDEV_DEVICE (iter->data));
}
g_list_free (keys);
/* Now if we're running in managed mode, let NM know there are new connections */
if (!priv->unmanage_well_known) {
GList *con_list = g_hash_table_get_values (priv->connections);
GList *cl_iter;
for (cl_iter = con_list; cl_iter; cl_iter = g_list_next (cl_iter)) {
g_signal_emit_by_name (self,
NM_SETTINGS_PLUGIN_CONNECTION_ADDED,
NM_SETTINGS_CONNECTION (cl_iter->data));
}
g_list_free (con_list);
}
nm_log_info (LOGD_SETTINGS, "end _init.");
}
/**
* main:
**/
int
main (int argc, char **argv)
{
GOptionContext *context;
const gchar *subsystems[] = { "usb", NULL };
gboolean verbose = FALSE;
int status = EXIT_SUCCESS;
_cleanup_object_unref_ GUdevClient *udev_client = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(GCancellable) cancellable = NULL;
const GOptionEntry options[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
/* TRANSLATORS: command line option */
_("Show extra debugging information"), NULL },
{ NULL}
};
/* make this predictable */
g_random_set_seed (0xdead);
/* TRANSLATORS: A program to copy the LiveUSB image onto USB hardware */
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
status = EXIT_FAILURE;
g_print ("Failed to parse command line: %s\n", error->message);
goto out;
}
if (verbose)
g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);
/* valid arguments */
if (argc != 2 || !gmw_probe_is_block_device_valid (argv[1])) {
status = EXIT_FAILURE;
g_print ("Block device required as argument\n");
goto out;
}
/* already mounted */
if (gmw_probe_is_block_device_mounted (argv[1])) {
status = EXIT_FAILURE;
g_print ("Partition mounted from block device\n");
goto out;
}
/* probe device */
cancellable = g_cancellable_new ();
udev_client = g_udev_client_new (subsystems);
if (!gmw_probe_use_device (udev_client, argv[1], cancellable, &error)) {
status = EXIT_FAILURE;
if (g_error_matches (error, GMW_ERROR, GMW_ERROR_IS_FAKE)) {
g_print ("Device is FAKE: %s\n", error->message);
} else {
g_print ("Failed to scan device: %s\n", error->message);
}
goto out;
}
g_print ("Device is GOOD\n");
out:
g_option_context_free (context);
return status;
}
static gpointer
provider_thread (gpointer data)
{
GstV4l2DeviceProvider *provider = data;
GMainContext *context = NULL;
GMainLoop *loop = NULL;
GUdevClient *client;
GList *devices;
static const gchar *subsystems[] = { "video4linux", NULL };
GST_OBJECT_LOCK (provider);
if (provider->context)
context = g_main_context_ref (provider->context);
if (provider->loop)
loop = g_main_loop_ref (provider->loop);
if (context == NULL || loop == NULL) {
provider->started = TRUE;
g_cond_broadcast (&provider->started_cond);
GST_OBJECT_UNLOCK (provider);
return NULL;
}
GST_OBJECT_UNLOCK (provider);
g_main_context_push_thread_default (context);
client = g_udev_client_new (subsystems);
g_signal_connect (client, "uevent", G_CALLBACK (uevent_cb), provider);
devices = g_udev_client_query_by_subsystem (client, "video4linux");
while (devices) {
GUdevDevice *udev_device = devices->data;
GstDevice *gstdev;
devices = g_list_remove (devices, udev_device);
if (g_udev_device_get_property_as_int (udev_device, "ID_V4L_VERSION") == 2) {
gstdev =
gst_v4l2_device_provider_device_from_udev (provider, udev_device);
if (gstdev)
gst_device_provider_device_add (GST_DEVICE_PROVIDER (provider), gstdev);
}
g_object_unref (udev_device);
}
GST_OBJECT_LOCK (provider);
provider->started = TRUE;
g_cond_broadcast (&provider->started_cond);
GST_OBJECT_UNLOCK (provider);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_object_unref (client);
g_main_context_unref (context);
gst_object_unref (provider);
return NULL;
}
static void
rb_removable_media_manager_init (RBRemovableMediaManager *mgr)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (mgr);
priv->volume_mapping = g_hash_table_new (NULL, NULL);
priv->mount_mapping = g_hash_table_new (NULL, NULL);
priv->device_mapping = g_hash_table_new (g_direct_hash, g_direct_equal);
priv->transfer_queue = g_async_queue_new ();
/*
* Monitor new (un)mounted file systems to look for new media;
* we watch for both volumes and mounts because for some devices,
* we don't require the volume to actually be mounted.
*
* both pre-unmount and unmounted callbacks are registered because it is
* better to do it before the unmount, but sometimes we don't get those
* (e.g. someone pressing the eject button on a cd drive). If we get the
* pre-unmount signal, the corresponding unmounted signal is ignored
*/
priv->volume_monitor = g_object_ref (g_volume_monitor_get ());
priv->volume_added_id = g_signal_connect_object (priv->volume_monitor,
"volume-added",
G_CALLBACK (volume_added_cb),
mgr, 0);
priv->volume_removed_id = g_signal_connect_object (priv->volume_monitor,
"volume-removed",
G_CALLBACK (volume_removed_cb),
mgr, 0);
priv->mount_added_id = g_signal_connect_object (priv->volume_monitor,
"mount-added",
G_CALLBACK (mount_added_cb),
mgr, 0);
priv->mount_pre_unmount_id = g_signal_connect_object (priv->volume_monitor,
"mount-pre-unmount",
G_CALLBACK (mount_removed_cb),
mgr, 0);
priv->mount_removed_id = g_signal_connect_object (G_OBJECT (priv->volume_monitor),
"mount-removed",
G_CALLBACK (mount_removed_cb),
mgr, 0);
#if defined(HAVE_GUDEV)
/*
* Monitor udev device events - we're only really interested in events
* for USB devices.
*/
{
const char * const subsystems[] = { "usb", NULL };
priv->gudev_client = g_udev_client_new (subsystems);
}
priv->uevent_id = g_signal_connect_object (priv->gudev_client,
"uevent",
G_CALLBACK (uevent_cb),
mgr, 0);
#endif
/* enable debugging of media player device lookups if requested */
if (rb_debug_matches ("mpid", "")) {
mpid_enable_debug (TRUE);
}
}
static void
SCPluginIfupdown_init (NMSystemConfigInterface *config)
{
SCPluginIfupdown *self = SC_PLUGIN_IFUPDOWN (config);
SCPluginIfupdownPrivate *priv = SC_PLUGIN_IFUPDOWN_GET_PRIVATE (self);
GHashTable *auto_ifaces;
if_block *block = NULL;
NMInotifyHelper *inotify_helper;
GKeyFile* keyfile;
GError *error = NULL;
GList *keys, *iter;
const char *subsys[2] = { "net", NULL };
auto_ifaces = g_hash_table_new (g_str_hash, g_str_equal);
if(!priv->iface_connections)
priv->iface_connections = g_hash_table_new (g_str_hash, g_str_equal);
if(!priv->well_known_ifaces)
priv->well_known_ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
if(!priv->well_known_interfaces)
priv->well_known_interfaces = g_hash_table_new (g_str_hash, g_str_equal);
PLUGIN_PRINT("SCPlugin-Ifupdown", "init!");
priv->client = g_udev_client_new (subsys);
if (!priv->client) {
PLUGIN_WARN ("SCPlugin-Ifupdown", " error initializing libgudev");
} else
g_signal_connect (priv->client, "uevent", G_CALLBACK (handle_uevent), self);
priv->unmanage_well_known = IFUPDOWN_UNMANAGE_WELL_KNOWN_DEFAULT;
inotify_helper = nm_inotify_helper_get ();
priv->inotify_event_id = g_signal_connect (inotify_helper,
"event",
G_CALLBACK (update_system_hostname),
config);
priv->inotify_system_hostname_wd =
nm_inotify_helper_add_watch (inotify_helper, IFUPDOWN_SYSTEM_HOSTNAME_FILE);
update_system_hostname (inotify_helper, NULL, NULL, config);
/* Read in all the interfaces */
ifparser_init (ENI_INTERFACES_FILE, 0);
block = ifparser_getfirst ();
while (block) {
if(!strcmp ("auto", block->type) || !strcmp ("allow-hotplug", block->type))
g_hash_table_insert (auto_ifaces, block->name, GUINT_TO_POINTER (1));
else if (!strcmp ("iface", block->type)) {
NMIfupdownConnection *exported;
/* Bridge configuration */
if(!strncmp ("br", block->name, 2)) {
/* Try to find bridge ports */
const char *ports = ifparser_getkey (block, "bridge-ports");
if (ports) {
int i;
int state = 0;
char **port_ifaces;
PLUGIN_PRINT("SCPlugin-Ifupdown", "found bridge ports %s for %s", ports, block->name);
port_ifaces = g_strsplit_set (ports, " \t", -1);
for (i = 0; i < g_strv_length (port_ifaces); i++) {
char *token = port_ifaces[i];
/* Skip crazy stuff like regex or all */
if (!strcmp ("all", token)) {
continue;
}
/* Small SM to skip everything inside regex */
if (!strcmp ("regex", token)) {
state++;
continue;
}
if (!strcmp ("noregex", token)) {
state--;
continue;
}
if (state == 0 && strlen (token) > 0) {
PLUGIN_PRINT("SCPlugin-Ifupdown", "adding bridge port %s to well_known_interfaces", token);
g_hash_table_insert (priv->well_known_interfaces, g_strdup (token), "known");
}
}
g_strfreev (port_ifaces);
}
goto next;
}
/* Skip loopback configuration */
if(!strcmp ("lo", block->name)) {
goto next;
}
/* Remove any connection for this block that was previously found */
exported = g_hash_table_lookup (priv->iface_connections, block->name);
if (exported) {
PLUGIN_PRINT("SCPlugin-Ifupdown", "deleting %s from iface_connections", block->name);
nm_settings_connection_delete (NM_SETTINGS_CONNECTION (exported), ignore_cb, NULL);
g_hash_table_remove (priv->iface_connections, block->name);
}
/* add the new connection */
exported = nm_ifupdown_connection_new (block);
if (exported) {
PLUGIN_PRINT("SCPlugin-Ifupdown", "adding %s to iface_connections", block->name);
g_hash_table_insert (priv->iface_connections, block->name, exported);
}
PLUGIN_PRINT("SCPlugin-Ifupdown", "adding iface %s to well_known_interfaces", block->name);
g_hash_table_insert (priv->well_known_interfaces, block->name, "known");
} else if (!strcmp ("mapping", block->type)) {
g_hash_table_insert (priv->well_known_interfaces, block->name, "known");
PLUGIN_PRINT("SCPlugin-Ifupdown", "adding mapping %s to well_known_interfaces", block->name);
}
next:
block = block->next;
}
/* Make 'auto' interfaces autoconnect=TRUE */
keys = g_hash_table_get_keys (priv->iface_connections);
for (iter = keys; iter; iter = g_list_next (iter)) {
NMIfupdownConnection *exported;
NMSetting *setting;
if (!g_hash_table_lookup (auto_ifaces, iter->data))
continue;
exported = g_hash_table_lookup (priv->iface_connections, iter->data);
setting = NM_SETTING (nm_connection_get_setting (NM_CONNECTION (exported), NM_TYPE_SETTING_CONNECTION));
g_object_set (setting, NM_SETTING_CONNECTION_AUTOCONNECT, TRUE, NULL);
nm_settings_connection_commit_changes (NM_SETTINGS_CONNECTION (exported), ignore_cb, NULL);
PLUGIN_PRINT("SCPlugin-Ifupdown", "autoconnect");
}
g_list_free (keys);
g_hash_table_destroy (auto_ifaces);
/* Find the config file */
if (g_file_test (IFUPDOWN_SYSTEM_SETTINGS_KEY_FILE, G_FILE_TEST_EXISTS))
priv->conf_file = IFUPDOWN_SYSTEM_SETTINGS_KEY_FILE;
else
priv->conf_file = IFUPDOWN_OLD_SYSTEM_SETTINGS_KEY_FILE;
keyfile = g_key_file_new ();
if (!g_key_file_load_from_file (keyfile,
priv->conf_file,
G_KEY_FILE_NONE,
&error)) {
nm_log_info (LOGD_SETTINGS, "loading system config file (%s) caused error: (%d) %s",
priv->conf_file,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
} else {
gboolean manage_well_known;
error = NULL;
manage_well_known = g_key_file_get_boolean (keyfile,
IFUPDOWN_KEY_FILE_GROUP,
IFUPDOWN_KEY_FILE_KEY_MANAGED,
&error);
if (error) {
nm_log_info (LOGD_SETTINGS, "getting keyfile key '%s' in group '%s' failed: (%d) %s",
IFUPDOWN_KEY_FILE_GROUP,
IFUPDOWN_KEY_FILE_KEY_MANAGED,
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
} else
priv->unmanage_well_known = !manage_well_known;
}
PLUGIN_PRINT ("SCPluginIfupdown", "management mode: %s", priv->unmanage_well_known ? "unmanaged" : "managed");
if (keyfile)
g_key_file_free (keyfile);
/* Add well-known interfaces */
keys = g_udev_client_query_by_subsystem (priv->client, "net");
for (iter = keys; iter; iter = g_list_next (iter)) {
udev_device_added (self, G_UDEV_DEVICE (iter->data));
g_object_unref (G_UDEV_DEVICE (iter->data));
}
g_list_free (keys);
/* Now if we're running in managed mode, let NM know there are new connections */
if (!priv->unmanage_well_known) {
GList *con_list = g_hash_table_get_values (priv->iface_connections);
GList *cl_iter;
for (cl_iter = con_list; cl_iter; cl_iter = g_list_next (cl_iter)) {
g_signal_emit_by_name (self,
NM_SYSTEM_CONFIG_INTERFACE_CONNECTION_ADDED,
NM_SETTINGS_CONNECTION (cl_iter->data));
}
g_list_free (con_list);
}
PLUGIN_PRINT("SCPlugin-Ifupdown", "end _init.");
}
static void
nm_device_update_description (NMDevice *device)
{
NMDevicePrivate *priv;
const char *subsys[3] = { "net", "tty", NULL };
GUdevDevice *udev_device = NULL, *tmpdev;
const char *ifname;
guint32 count = 0;
const char *vendor, *model;
g_return_if_fail (NM_IS_DEVICE (device));
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->client) {
priv->client = g_udev_client_new (subsys);
if (!priv->client)
return;
}
ifname = nm_device_get_iface (device);
if (!ifname)
return;
if (NM_IS_DEVICE_ETHERNET (device) || NM_IS_DEVICE_WIFI (device))
udev_device = g_udev_client_query_by_subsystem_and_name (priv->client, "net", ifname);
else if (NM_IS_GSM_DEVICE (device) || NM_IS_CDMA_DEVICE (device))
udev_device = g_udev_client_query_by_subsystem_and_name (priv->client, "tty", ifname);
if (!udev_device)
return;
g_free (priv->product);
priv->product = NULL;
g_free (priv->vendor);
priv->vendor = NULL;
/* Walk up the chain of the device and its parents a few steps to grab
* vendor and device ID information off it.
*/
tmpdev = udev_device;
while ((count++ < 3) && tmpdev && (!priv->vendor || !priv->product)) {
if (!priv->vendor)
priv->vendor = get_decoded_property (tmpdev, "ID_VENDOR_ENC");
if (!priv->product)
priv->product = get_decoded_property (tmpdev, "ID_MODEL_ENC");
tmpdev = g_udev_device_get_parent (tmpdev);
}
/* If we didn't get strings directly from the device, try database strings */
tmpdev = udev_device;
count = 0;
while ((count++ < 3) && tmpdev && (!priv->vendor || !priv->product)) {
if (!priv->vendor) {
vendor = g_udev_device_get_property (tmpdev, "ID_VENDOR_FROM_DATABASE");
if (vendor)
priv->vendor = g_strdup (vendor);
}
if (!priv->product) {
model = g_udev_device_get_property (tmpdev, "ID_MODEL_FROM_DATABASE");
if (model)
priv->product = g_strdup (model);
}
tmpdev = g_udev_device_get_parent (tmpdev);
}
_nm_object_queue_notify (NM_OBJECT (device), NM_DEVICE_VENDOR);
_nm_object_queue_notify (NM_OBJECT (device), NM_DEVICE_PRODUCT);
}
MMQmiPort *
mm_base_modem_peek_port_qmi_for_data (MMBaseModem *self,
MMPort *data,
GError **error)
{
MMQmiPort *found;
GUdevClient *client;
GUdevDevice *data_device;
GUdevDevice *data_device_parent;
GList *l;
if (mm_port_get_subsys (data) != MM_PORT_SUBSYS_NET) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot look for QMI port associated to a non-net data port");
return NULL;
}
/* don't listen for uevents */
client = g_udev_client_new (NULL);
/* Get udev device for the data port */
data_device = (g_udev_client_query_by_subsystem_and_name (
client,
"net",
mm_port_get_device (data)));
if (!data_device) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't find udev device for port 'net/%s'",
mm_port_get_device (data));
g_object_unref (client);
return NULL;
}
/* Get parent of the data device */
data_device_parent = g_udev_device_get_parent (data_device);
if (!data_device_parent) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't get udev device parent for port 'net/%s'",
mm_port_get_device (data));
g_object_unref (data_device);
g_object_unref (client);
return NULL;
}
/* Now walk the list of QMI ports looking for a match */
found = NULL;
for (l = self->priv->qmi; l && !found; l = g_list_next (l)) {
GUdevDevice *qmi_device;
GUdevDevice *qmi_device_parent;
/* Get udev device for the QMI port */
qmi_device = (g_udev_client_query_by_subsystem_and_name (
client,
"usb",
mm_port_get_device (MM_PORT (l->data))));
if (!qmi_device) {
qmi_device = (g_udev_client_query_by_subsystem_and_name (
client,
"usbmisc",
mm_port_get_device (MM_PORT (l->data))));
if (!qmi_device) {
mm_warn ("Couldn't get udev device for QMI port '%s'",
mm_port_get_device (MM_PORT (l->data)));
continue;
}
}
/* Get parent of the QMI device */
qmi_device_parent = g_udev_device_get_parent (qmi_device);
g_object_unref (qmi_device);
if (!data_device_parent) {
mm_warn ("Couldn't get udev device parent for QMI port '%s'",
mm_port_get_device (MM_PORT (l->data)));
continue;
}
if (g_str_equal (g_udev_device_get_sysfs_path (data_device_parent),
g_udev_device_get_sysfs_path (qmi_device_parent)))
found = MM_QMI_PORT (l->data);
g_object_unref (qmi_device_parent);
}
g_object_unref (data_device_parent);
g_object_unref (data_device);
g_object_unref (client);
if (!found) {
/* For the case where we have only 1 data port and 1 QMI port and they
* don't match with the previous rules (e.g. in some Huawei modems),
* just return the found one */
if (g_list_length (self->priv->data) == 1 &&
g_list_length (self->priv->qmi) == 1 &&
self->priv->data->data == data) {
mm_info ("Assuming QMI port '%s' is associated to net/%s",
mm_port_get_device (MM_PORT (self->priv->qmi->data)),
mm_port_get_device (data));
found = MM_QMI_PORT (self->priv->qmi->data);
} else {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_NOT_FOUND,
"Couldn't find associated QMI port for 'net/%s'",
mm_port_get_device (data));
return NULL;
}
}
return found;
}
static gboolean
grab_port (MMModem *modem,
const char *subsys,
const char *name,
MMPortType suggested_type,
gpointer user_data,
GError **error)
{
MMGenericGsm *gsm = MM_GENERIC_GSM (modem);
MMPortType ptype = MM_PORT_TYPE_IGNORED;
const char *sys[] = { "tty", "net", NULL };
GUdevClient *client;
GUdevDevice *device = NULL;
MMPort *port = NULL;
const char *sysfs_path;
client = g_udev_client_new (sys);
if (!client) {
g_set_error (error, 0, 0, "Could not get udev client.");
return FALSE;
}
device = g_udev_client_query_by_subsystem_and_name (client, subsys, name);
if (!device) {
g_set_error (error, 0, 0, "Could not get udev device.");
goto out;
}
sysfs_path = g_udev_device_get_sysfs_path (device);
if (!sysfs_path) {
g_set_error (error, 0, 0, "Could not get udev device sysfs path.");
goto out;
}
if (!strcmp (subsys, "tty")) {
char *hsotype_path;
char *contents = NULL;
hsotype_path = g_build_filename (sysfs_path, "hsotype", NULL);
if (g_file_get_contents (hsotype_path, &contents, NULL, NULL)) {
if (g_str_has_prefix (contents, "Control"))
ptype = MM_PORT_TYPE_PRIMARY;
else if (g_str_has_prefix (contents, "Application") || g_str_has_prefix (contents, "Application2"))
ptype = MM_PORT_TYPE_SECONDARY;
g_free (contents);
}
g_free (hsotype_path);
}
port = mm_generic_gsm_grab_port (gsm, subsys, name, ptype, error);
if (!port)
goto out;
if (MM_IS_AT_SERIAL_PORT (port)) {
g_object_set (G_OBJECT (port), MM_SERIAL_PORT_SEND_DELAY, (guint64) 10000, NULL);
if (ptype == MM_PORT_TYPE_PRIMARY) {
GRegex *regex;
regex = g_regex_new ("_OWANCALL: (\\d),\\s*(\\d)\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, connection_enabled, modem, NULL);
g_regex_unref (regex);
regex = g_regex_new ("\\r\\n\\+PACSP0\\r\\n", G_REGEX_RAW | G_REGEX_OPTIMIZE, 0, NULL);
mm_at_serial_port_add_unsolicited_msg_handler (MM_AT_SERIAL_PORT (port), regex, NULL, NULL, NULL);
g_regex_unref (regex);
}
option_register_unsolicted_handlers (gsm, MM_AT_SERIAL_PORT (port));
}
out:
if (device)
g_object_unref (device);
g_object_unref (client);
return !!port;
}
static gboolean
get_device_info (const char *path,
int *vendor_id,
int *product_id,
char **name,
WacomBusType *bus,
WacomIntegrationFlags *integration_flags,
WacomError *error)
{
GUdevClient *client;
GUdevDevice *device;
const char * const subsystems[] = { "input", NULL };
gboolean retval;
char *bus_str;
const char *devname;
#if NEED_G_TYPE_INIT
g_type_init();
#endif
retval = FALSE;
/* The integration flags from device info are unset by default */
*integration_flags = WACOM_DEVICE_INTEGRATED_UNSET;
*name = NULL;
bus_str = NULL;
client = g_udev_client_new (subsystems);
device = g_udev_client_query_by_device_file (client, path);
if (device == NULL) {
libwacom_error_set(error, WERROR_INVALID_PATH, "Could not find device '%s' in udev", path);
goto out;
}
/* Touchpads are only for the "Finger" part of Bamboo devices */
if (!is_tablet_or_touchpad(device)) {
GUdevDevice *parent;
parent = g_udev_device_get_parent(device);
if (!parent || !is_tablet_or_touchpad(parent)) {
libwacom_error_set(error, WERROR_INVALID_PATH, "Device '%s' is not a tablet", path);
g_object_unref (parent);
goto out;
}
g_object_unref (parent);
}
/* Is the device integrated in display? */
devname = g_udev_device_get_name (device);
if (devname != NULL) {
char *sysfs_path, *contents;
sysfs_path = g_build_filename ("/sys/class/input", devname, "device/properties", NULL);
if (g_file_get_contents (sysfs_path, &contents, NULL, NULL)) {
int flag;
flag = atoi(contents);
flag &= (1 << INPUT_PROP_DIRECT) | (1 << INPUT_PROP_POINTER);
/*
* To ensure we are dealing with a screen tablet, need
* to check that it has DIRECT and non-POINTER (DIRECT
* alone is not sufficient since it's set for drawing
* tablets as well)
*/
if (flag == (1 << INPUT_PROP_DIRECT))
*integration_flags = WACOM_DEVICE_INTEGRATED_DISPLAY;
else
*integration_flags = WACOM_DEVICE_INTEGRATED_NONE;
g_free (contents);
}
g_free (sysfs_path);
}
*name = g_strdup (g_udev_device_get_sysfs_attr (device, "name"));
/* Try getting the name from the parent if that fails */
if (*name == NULL) {
GUdevDevice *parent;
parent = g_udev_device_get_parent (device);
if (!parent)
goto out;
*name = g_strdup (g_udev_device_get_sysfs_attr (parent, "name"));
g_object_unref (parent);
}
/* Parse the PRODUCT attribute (for Bluetooth, USB, I2C) */
retval = get_bus_vid_pid (device, bus, vendor_id, product_id, error);
if (retval)
goto out;
bus_str = get_bus (device);
*bus = bus_from_str (bus_str);
if (*bus == WBUSTYPE_SERIAL) {
/* The serial bus uses 0:0 as the vid/pid */
*vendor_id = 0;
*product_id = 0;
retval = TRUE;
} else {
libwacom_error_set(error, WERROR_UNKNOWN_MODEL, "Unsupported bus '%s'", bus_str);
}
out:
if (bus_str != NULL)
g_free (bus_str);
if (retval == FALSE)
g_free (*name);
if (device != NULL)
g_object_unref (device);
if (client != NULL)
g_object_unref (client);
return retval;
}
/**
* main:
**/
gint
main (gint argc, gchar *argv[])
{
gboolean ret;
gchar **paths = NULL;
GError *error = NULL;
GOptionContext *context;
guint i;
gint uid;
gint euid;
guint retval = 0;
GUdevClient *client = NULL;
const GOptionEntry options[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
_("Show extra debugging information"), NULL },
{ "simulate", 's', 0, G_OPTION_ARG_NONE, &simulate,
/* command line argument, simulate what would be done, but don't actually do it */
_("Don't actually touch the hardware, only simulate what would be done"), NULL },
{ G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, &paths,
/* TRANSLATORS: command line option: a list of files to install */
_("Device paths"), NULL },
{ NULL}
};
/* setup translations */
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
/* setup type system */
g_type_init ();
context = g_option_context_new (NULL);
/* TRANSLATORS: tool that gets called when the device needs reloading after installing firmware */
g_option_context_set_summary (context, _("PackageKit Device Reloader"));
g_option_context_add_main_entries (context, options, NULL);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
/* no input */
if (paths == NULL) {
/* TRANSLATORS: user did not specify a valid device sysfs path */
g_print ("%s\n", _("You need to specify at least one valid device path"));
retval = PK_DEVICE_REBIND_EXIT_CODE_ARGUMENTS_INVALID;
goto out;
}
/* get calling process */
uid = getuid ();
euid = geteuid ();
if (uid != 0 || euid != 0) {
/* TRANSLATORS: user did not specify a valid device sysfs path */
g_print ("%s\n", _("This script can only be used by the root user"));
retval = PK_DEVICE_REBIND_EXIT_CODE_ARGUMENTS_INVALID;
goto out;
}
/* we're running as root, be paranoid and check them for sanity */
for (i=0; paths[i] != NULL; i++) {
if (verbose) {
/* TRANSLATORS: we're going to verify the path first */
g_print ("%s: %s\n", _("Verifying device path"), paths[i]);
}
ret = pk_device_rebind_verify (paths[i], &error);
if (!ret) {
/* TRANSLATORS: user did not specify a device sysfs path that exists */
g_print ("%s: %s\n", _("Failed to verify device path"), error->message);
g_error_free (error);
retval = PK_DEVICE_REBIND_EXIT_CODE_ARGUMENTS_INVALID;
goto out;
}
}
/* use GUdev to find properties */
client = g_udev_client_new (NULL);
/* unbind and then bind all the devices */
for (i=0; paths[i] != NULL; i++) {
if (verbose) {
/* TRANSLATORS: we're going to try */
g_print ("%s: %s\n", _("Attempting to rebind device"), paths[i]);
}
ret = pk_device_rebind (client, paths[i], &error);
if (!ret) {
/* TRANSLATORS: we failed to release the current driver */
g_print ("%s: %s\n", _("Failed to rebind device"), error->message);
g_error_free (error);
retval = PK_DEVICE_REBIND_EXIT_CODE_FAILED_TO_WRITE;
goto out;
}
}
/* success */
retval = PK_DEVICE_REBIND_EXIT_CODE_SUCCESS;
out:
if (client != NULL)
g_object_unref (client);
g_strfreev (paths);
return retval;
}
