static void
obexftp_stop (gboolean stop_manager)
{
GError *err = NULL;
if (server_proxy == NULL)
return;
if (dbus_g_proxy_call (server_proxy, "Close", &err, G_TYPE_INVALID, G_TYPE_INVALID) == FALSE) {
if (err == NULL ||
g_error_matches (err, DBUS_GERROR, DBUS_GERROR_REMOTE_EXCEPTION) == FALSE ||
dbus_g_error_has_name (err, "org.openobex.Error.NotStarted") == FALSE) {
if (err != NULL) {
g_printerr ("Stopping Bluetooth ObexFTP server failed: %s\n",
err->message);
g_error_free (err);
}
return;
}
g_error_free (err);
}
if (stop_manager != FALSE) {
g_object_unref (server_proxy);
server_proxy = NULL;
g_object_unref (manager_proxy);
manager_proxy = NULL;
}
}
static void
stage1_enable_done (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
{
NMModemGsm *self = NM_MODEM_GSM (user_data);
NMDeviceStateReason reason;
GError *error = NULL;
if (dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID))
do_connect (self);
else {
nm_log_warn (LOGD_MB, "GSM modem enable failed: (%d) %s",
error ? error->code : -1,
error && error->message ? error->message : "(unknown)");
if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_PIN))
handle_enable_pin_required (self);
else {
/* try to translate the error reason */
reason = translate_mm_error (error);
if (reason == NM_DEVICE_STATE_REASON_UNKNOWN)
reason = NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED;
g_signal_emit_by_name (self, NM_MODEM_PREPARE_RESULT, FALSE, reason);
}
g_error_free (error);
}
}
static NMDeviceStateReason
translate_mm_error (GError *error)
{
NMDeviceStateReason reason;
if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_NO_CARRIER))
reason = NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER;
if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_NO_DIALTONE))
reason = NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT;
if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_BUSY))
reason = NM_DEVICE_STATE_REASON_MODEM_BUSY;
if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_NO_ANSWER))
reason = NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT;
if (dbus_g_error_has_name (error, MM_MODEM_ERROR_NETWORK_NOT_ALLOWED))
reason = NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED;
if (dbus_g_error_has_name (error, MM_MODEM_ERROR_NETWORK_TIMEOUT))
reason = NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT;
if (dbus_g_error_has_name (error, MM_MODEM_ERROR_NO_NETWORK))
reason = NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING;
/* FIXME: We have only GSM error messages here, and we have no idea which
activation state failed. Reasons like:
NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED,
NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED,
NM_DEVICE_STATE_REASON_GSM_APN_FAILED,
NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED,
NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED
are not used.
*/
else
reason = NM_DEVICE_STATE_REASON_UNKNOWN;
return reason;
}
static void
interface_add_cb (DBusGProxy *proxy,
DBusGProxyCall *call_id,
gpointer user_data)
{
NMSupplicantInfo *info = (NMSupplicantInfo *) user_data;
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (info->interface);
GError *error = NULL;
char *path = NULL;
if (dbus_g_proxy_end_call (proxy, call_id, &error,
DBUS_TYPE_G_OBJECT_PATH, &path,
G_TYPE_INVALID)) {
interface_add_done (info->interface, path);
} else {
if (dbus_g_error_has_name (error, WPAS_ERROR_EXISTS_ERROR)) {
/* Interface already added, just get its object path */
interface_get (info->interface);
} else if ( g_error_matches (error, DBUS_GERROR, DBUS_GERROR_SERVICE_UNKNOWN)
|| g_error_matches (error, DBUS_GERROR, DBUS_GERROR_SPAWN_EXEC_FAILED)
|| g_error_matches (error, DBUS_GERROR, DBUS_GERROR_SPAWN_FORK_FAILED)
|| g_error_matches (error, DBUS_GERROR, DBUS_GERROR_SPAWN_FAILED)
|| dbus_g_error_has_name (error, DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND)) {
/* Supplicant wasn't running and could be launched via service
* activation. Wait for it to start by moving back to the INIT
* state.
*/
nm_log_dbg (LOGD_SUPPLICANT, "(%s): failed to activate supplicant: %s",
priv->dev, error->message);
set_state (info->interface, NM_SUPPLICANT_INTERFACE_STATE_INIT);
} else {
nm_log_err (LOGD_SUPPLICANT, "(%s): error adding interface: %s",
priv->dev, error->message);
set_state (info->interface, NM_SUPPLICANT_INTERFACE_STATE_DOWN);
}
g_clear_error (&error);
}
}
void
set_fingerprint_label (GtkWidget *enable, GtkWidget *disable)
{
char **fingers;
DBusGProxy *device;
GError *error = NULL;
gtk_widget_set_no_show_all (enable, TRUE);
gtk_widget_set_no_show_all (disable, TRUE);
if (manager == NULL) {
create_manager ();
if (manager == NULL) {
gtk_widget_hide (enable);
gtk_widget_hide (disable);
return;
}
}
device = get_first_device ();
if (device == NULL) {
gtk_widget_hide (enable);
gtk_widget_hide (disable);
return;
}
if (!dbus_g_proxy_call (device, "ListEnrolledFingers", &error, G_TYPE_STRING, "", G_TYPE_INVALID,
G_TYPE_STRV, &fingers, G_TYPE_INVALID)) {
if (dbus_g_error_has_name (error, "net.reactivated.Fprint.Error.NoEnrolledPrints") == FALSE) {
gtk_widget_hide (enable);
gtk_widget_hide (disable);
g_object_unref (device);
return;
}
fingers = NULL;
}
if (fingers == NULL || g_strv_length (fingers) == 0) {
gtk_widget_hide (disable);
gtk_widget_show (enable);
is_disable = FALSE;
} else {
gtk_widget_hide (enable);
gtk_widget_show (disable);
is_disable = TRUE;
}
g_strfreev (fingers);
g_object_unref (device);
}
static void
stage1_prepare_done (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
{
NMDevice *device = NM_DEVICE (user_data);
GError *error = NULL;
dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID);
if (!error)
nm_device_activate_schedule_stage2_device_config (device);
else {
const char *required_secret = NULL;
gboolean retry_secret = FALSE;
if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_PIN))
required_secret = NM_SETTING_GSM_PIN;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_WRONG)) {
clear_pin (device);
required_secret = NM_SETTING_GSM_PIN;
retry_secret = TRUE;
} else
nm_warning ("GSM modem connection failed: %s", error->message);
if (required_secret) {
nm_device_state_changed (device, NM_DEVICE_STATE_NEED_AUTH, NM_DEVICE_STATE_REASON_NONE);
nm_act_request_get_secrets (nm_device_get_act_request (device),
NM_SETTING_GSM_SETTING_NAME,
retry_secret,
SECRETS_CALLER_GSM,
required_secret,
NULL);
} else
nm_device_state_changed (device, NM_DEVICE_STATE_FAILED, translate_mm_error (error));
g_error_free (error);
}
}
static void delete_fingerprints(DBusGProxy *dev, const char *username)
{
GError *error = NULL;
GHashTable *props;
DBusGProxy *p;
p = dbus_g_proxy_new_from_proxy(dev, "org.freedesktop.DBus.Properties", NULL);
if (!dbus_g_proxy_call (p, "GetAll", &error, G_TYPE_STRING, "net.reactivated.Fprint.Device", G_TYPE_INVALID,
dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &props, G_TYPE_INVALID))
g_error("GetAll on the Properties interface failed: %s", error->message);
if (!net_reactivated_Fprint_Device_delete_enrolled_fingers(dev, username, &error)) {
if (dbus_g_error_has_name (error, "net.reactivated.Fprint.Error.NoEnrolledPrints") == FALSE)
g_error("ListEnrolledFingers failed: %s", error->message);
else
g_print ("No fingerprints to delete on %s\n", g_value_get_string (g_hash_table_lookup (props, "name")));
} else {
g_print ("Fingerprints deleted on %s\n", g_value_get_string (g_hash_table_lookup (props, "name")));
}
g_hash_table_destroy (props);
g_object_unref (p);
}
static NMDeviceStateReason
translate_mm_error (GError *error)
{
NMDeviceStateReason reason;
if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_NO_CARRIER))
reason = NM_DEVICE_STATE_REASON_MODEM_NO_CARRIER;
else if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_NO_DIALTONE))
reason = NM_DEVICE_STATE_REASON_MODEM_NO_DIAL_TONE;
else if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_BUSY))
reason = NM_DEVICE_STATE_REASON_MODEM_BUSY;
else if (dbus_g_error_has_name (error, MM_MODEM_CONNECT_ERROR_NO_ANSWER))
reason = NM_DEVICE_STATE_REASON_MODEM_DIAL_TIMEOUT;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_NETWORK_NOT_ALLOWED))
reason = NM_DEVICE_STATE_REASON_GSM_REGISTRATION_DENIED;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_NETWORK_TIMEOUT))
reason = NM_DEVICE_STATE_REASON_GSM_REGISTRATION_TIMEOUT;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_NO_NETWORK))
reason = NM_DEVICE_STATE_REASON_GSM_REGISTRATION_NOT_SEARCHING;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_NOT_INSERTED))
reason = NM_DEVICE_STATE_REASON_GSM_SIM_NOT_INSERTED;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_PIN))
reason = NM_DEVICE_STATE_REASON_GSM_SIM_PIN_REQUIRED;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_PUK))
reason = NM_DEVICE_STATE_REASON_GSM_SIM_PUK_REQUIRED;
else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_WRONG))
reason = NM_DEVICE_STATE_REASON_GSM_SIM_WRONG;
else {
/* unable to map the ModemManager error to a NM_DEVICE_STATE_REASON */
nm_log_dbg (LOGD_MB, "unmapped dbus error detected: '%s'", dbus_g_error_get_name (error));
reason = NM_DEVICE_STATE_REASON_UNKNOWN;
}
/* FIXME: We have only GSM error messages here, and we have no idea which
activation state failed. Reasons like:
NM_DEVICE_STATE_REASON_MODEM_DIAL_FAILED,
NM_DEVICE_STATE_REASON_MODEM_INIT_FAILED,
NM_DEVICE_STATE_REASON_GSM_APN_FAILED,
NM_DEVICE_STATE_REASON_GSM_REGISTRATION_FAILED,
NM_DEVICE_STATE_REASON_GSM_PIN_CHECK_FAILED
are not used.
*/
return reason;
}
static HRESULT
get_connection_from_udev_or_odccm(SynceInfo *info, int *sockfd)
{
GError *error = NULL;
DBusGConnection *bus = NULL;
DBusGProxy *dbus_proxy = NULL;
DBusGProxy *dev_proxy = NULL;
gboolean dccm_running = FALSE;
gchar *unix_path = NULL;
gint fd = -1;
const gchar *service = NULL;
const gchar *dev_iface = NULL;
const gchar *dccm_name = NULL;
HRESULT result = E_FAIL;
/* Ensure that e.g. SYNCE_DCCM_ERROR is registered using g_dbus_error_register_error() */
synce_glib_init();
#if ENABLE_ODCCM_SUPPORT
const gchar *transport = synce_info_get_transport(info);
if (strcmp(transport, "odccm") == 0) {
service = ODCCM_SERVICE;
dev_iface = ODCCM_DEV_IFACE;
dccm_name = "odccm";
} else
#endif
{
service = DCCM_SERVICE;
dev_iface = DCCM_DEV_IFACE;
dccm_name = "dccm";
}
#if !GLIB_CHECK_VERSION (2, 36, 0)
g_type_init();
#endif
bus = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
if (bus == NULL)
{
synce_warning("%s: Failed to connect to system bus: %s", G_STRFUNC, error->message);
goto ERROR;
}
dbus_proxy = dbus_g_proxy_new_for_name (bus,
DBUS_SERVICE,
DBUS_PATH,
DBUS_IFACE);
if (dbus_proxy == NULL) {
synce_warning("%s: Failed to get dbus proxy object", G_STRFUNC);
goto ERROR;
}
if (!(dbus_g_proxy_call(dbus_proxy, "NameHasOwner",
&error,
G_TYPE_STRING, service,
G_TYPE_INVALID,
G_TYPE_BOOLEAN, &dccm_running,
G_TYPE_INVALID))) {
synce_warning("%s: Error checking owner of service %s: %s", G_STRFUNC, service, error->message);
g_object_unref(dbus_proxy);
goto ERROR;
}
g_object_unref(dbus_proxy);
if (!dccm_running) {
synce_info("%s is not running, ignoring", dccm_name);
goto ERROR;
}
dev_proxy = dbus_g_proxy_new_for_name(bus, service,
synce_info_get_object_path(info),
dev_iface);
if (dev_proxy == NULL) {
synce_warning("%s: Failed to get proxy for device '%s'", G_STRFUNC, synce_info_get_object_path(info));
goto ERROR;
}
if (!dbus_g_proxy_call(dev_proxy, "RequestConnection", &error,
G_TYPE_INVALID,
G_TYPE_STRING, &unix_path,
G_TYPE_INVALID))
{
synce_warning("%s: Failed to get a connection for %s: %s", G_STRFUNC, synce_info_get_name(info), error->message);
/* INVALID_PASSWORD isn't perfect, but seems to be the best we have */
if (dbus_g_error_has_name(error, "org.synce.dccm.Error.DeviceLocked"))
result = HRESULT_FROM_WIN32(ERROR_INVALID_PASSWORD);
g_object_unref(dev_proxy);
goto ERROR;
}
g_object_unref(dev_proxy);
fd = get_socket_from_dccm(unix_path);
g_free(unix_path);
if (fd < 0)
{
synce_warning("%s: Failed to get file-descriptor from %s for %s", G_STRFUNC, dccm_name, synce_info_get_name(info));
goto ERROR;
}
result = S_OK;
goto OUT;
ERROR:
if (error != NULL)
g_error_free(error);
OUT:
if (bus != NULL)
dbus_g_connection_unref (bus);
*sockfd = fd;
return result;
}
void
obexftp_up (void)
{
GError *err = NULL;
GSettings *settings;
char *public_dir, *server;
gboolean allow_write, require_pairing;
settings = g_settings_new (GSETTINGS_SCHEMA);
require_pairing =g_settings_get_boolean (settings, FILE_SHARING_BLUETOOTH_REQUIRE_PAIRING);
server = NULL;
if (manager_proxy == NULL) {
manager_proxy = dbus_g_proxy_new_for_name (connection,
"org.openobex",
"/org/openobex",
"org.openobex.Manager");
if (dbus_g_proxy_call (manager_proxy, "CreateBluetoothServer",
&err, G_TYPE_STRING, "00:00:00:00:00:00", G_TYPE_STRING, "ftp", G_TYPE_BOOLEAN, require_pairing, G_TYPE_INVALID,
DBUS_TYPE_G_OBJECT_PATH, &server, G_TYPE_INVALID) == FALSE) {
g_printerr ("Creating Bluetooth ObexFTP server failed: %s\n",
err->message);
g_error_free (err);
g_object_unref (manager_proxy);
manager_proxy = NULL;
return;
}
}
public_dir = lookup_public_dir ();
allow_write =g_settings_get_boolean (settings, FILE_SHARING_BLUETOOTH_ALLOW_WRITE);
g_object_unref (settings);
if (server_proxy == NULL) {
server_proxy = dbus_g_proxy_new_for_name (connection,
"org.openobex",
server,
"org.openobex.Server");
g_free (server);
}
if (dbus_g_proxy_call (server_proxy, "Start", &err,
G_TYPE_STRING, public_dir, G_TYPE_BOOLEAN, allow_write, G_TYPE_BOOLEAN, TRUE, G_TYPE_INVALID,
G_TYPE_INVALID) == FALSE) {
if (g_error_matches (err, DBUS_GERROR, DBUS_GERROR_REMOTE_EXCEPTION) != FALSE &&
dbus_g_error_has_name (err, "org.openobex.Error.Started") != FALSE) {
g_error_free (err);
g_message ("already started, ignoring error");
g_free (public_dir);
return;
}
g_printerr ("Starting Bluetooth ObexFTP server failed: %s\n",
err->message);
g_error_free (err);
g_free (public_dir);
g_object_unref (server_proxy);
server_proxy = NULL;
g_object_unref (manager_proxy);
manager_proxy = NULL;
return;
}
g_free (public_dir);
}
static void
nm_supplicant_interface_add_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
{
NMSupplicantInfo *info = (NMSupplicantInfo *) user_data;
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (info->interface);
GError *err = NULL;
char *path = NULL;
if (!dbus_g_proxy_end_call (proxy, call_id, &err,
DBUS_TYPE_G_OBJECT_PATH, &path,
G_TYPE_INVALID)) {
if (dbus_g_error_has_name (err, WPAS_ERROR_INVALID_IFACE)) {
/* Interface not added, try to add it */
nm_supplicant_interface_add_to_supplicant (info->interface, FALSE);
} else if (dbus_g_error_has_name (err, WPAS_ERROR_EXISTS_ERROR)) {
/* Interface already added, just try to get the interface */
nm_supplicant_interface_add_to_supplicant (info->interface, TRUE);
} else {
nm_log_err (LOGD_SUPPLICANT, "(%s): error getting interface: %s",
priv->dev, err->message);
}
g_error_free (err);
} else {
nm_log_dbg (LOGD_SUPPLICANT, "(%s): interface added to supplicant", priv->dev);
priv->object_path = path;
priv->iface_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr),
WPAS_DBUS_SERVICE,
path,
WPAS_DBUS_IFACE_INTERFACE);
dbus_g_proxy_add_signal (priv->iface_proxy, "ScanResultsAvailable", G_TYPE_INVALID);
dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_STRING,
G_TYPE_NONE,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_INVALID);
dbus_g_proxy_add_signal (priv->iface_proxy, "StateChange", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->iface_proxy, "ScanResultsAvailable",
G_CALLBACK (wpas_iface_query_scan_results),
info->interface,
NULL);
dbus_g_proxy_connect_signal (priv->iface_proxy, "StateChange",
G_CALLBACK (wpas_iface_handle_state_change),
info->interface,
NULL);
dbus_g_proxy_add_signal (priv->iface_proxy, "Scanning", G_TYPE_BOOLEAN, G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->iface_proxy, "Scanning",
G_CALLBACK (wpas_iface_handle_scanning),
info->interface,
NULL);
/* Interface added to the supplicant; get its initial state. */
wpas_iface_get_state (info->interface);
wpas_iface_get_scanning (info->interface);
}
}
