static void __bluetooth_network_disconnect_request_cb(DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { GError *g_error = NULL; DBusGConnection *conn = NULL; int result = BLUETOOTH_ERROR_NONE; conn = (DBusGConnection *) user_data; dbus_g_proxy_end_call(proxy, call, &g_error, G_TYPE_INVALID); g_object_unref(proxy); dbus_g_connection_unref(conn); if (g_error != NULL) { DBG("Network Client disconnection Dbus Call Error: %s\n", g_error->message); g_error_free(g_error); result = BLUETOOTH_ERROR_INTERNAL; } else { DBG("Network Client disconnection Dbus Call is done\n"); } _bluetooth_internal_event_cb(BLUETOOTH_EVENT_NETWORK_DISCONNECTED, result, NULL); }
static void add_or_change_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data) { CBInfo *info = user_data; GError *error = NULL; char *zone = NULL; if (!dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_STRING, &zone, G_TYPE_INVALID)) { g_assert (error); if (g_strcmp0 (error->message, "ZONE_ALREADY_SET") != 0) { nm_log_warn (LOGD_FIREWALL, "(%s) firewall zone add/change failed [%u]: (%d) %s", info->iface, info->id, error->code, error->message); } else { nm_log_dbg (LOGD_FIREWALL, "(%s) firewall zone add/change failed [%u]: (%d) %s", info->iface, info->id, error->code, error->message); } } else { nm_log_dbg (LOGD_FIREWALL, "(%s) firewall zone add/change succeeded [%u]", info->iface, info->id); } if (info->callback) info->callback (error, info->user_data); info->completed = TRUE; g_free (zone); g_clear_error (&error); }
static void get_device_state_cb (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data) { GValue value = {0,}; GError *error = NULL; NMDevice *nm_device = (NMDevice *) user_data; if (!dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { g_warning ("Error reading property: %s\n", error->message); g_error_free (error); return; } NMDeviceState state = g_value_get_uint (&value); if (state == NM_DEVICE_STATE_ACTIVATED) { dbus_g_proxy_begin_call (nm_device->prop_proxy, "Get", get_device_interface_cb, nm_device, NULL, G_TYPE_STRING, DEVICE_INTERFACE, G_TYPE_STRING, "Interface", G_TYPE_INVALID); } g_value_unset (&value); }
static void loc_props_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { GError *error = NULL; GHashTable *props = NULL; Modem *modem = user_data; if (!dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_MAP_OF_VARIANT, &props, G_TYPE_INVALID)) { g_warning ("%s: failed to get location interface properties: (%d) %s", __func__, error ? error->code : -1, error && error->message ? error->message : "(unknown)"); g_clear_error (&error); return; } modem_properties_changed (modem->loc_proxy, MM_DBUS_LOC_INTERFACE, props, modem); g_hash_table_destroy (props); /* Now that we know the device supports location services, get basic * modem properties and start grabbing location info. */ dbus_g_proxy_begin_call (modem->props_proxy, "GetAll", modem_props_cb, modem, NULL, G_TYPE_STRING, MM_DBUS_MODEM_INTERFACE, G_TYPE_INVALID); }
static void set_time_notify (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data) { SetTimeCallbackData *data = user_data; GError *error = NULL; if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID)) { if (data->callback) data->callback (data->data, NULL); } else { if (error->domain == DBUS_GERROR && error->code == DBUS_GERROR_NO_REPLY) { /* these errors happen because dbus doesn't * use monotonic clocks */ g_warning ("ignoring no-reply error when setting time"); g_error_free (error); if (data->callback) data->callback (data->data, NULL); } else { if (data->callback) data->callback (data->data, error); else g_error_free (error); } } }
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 void get_timezone_notify (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data) { GError *error = NULL; gboolean retval; gchar *string = NULL; GetTimezoneData *data = user_data; retval = dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &string, G_TYPE_INVALID); if (data->callback) { if (!retval) { data->callback (data->data, NULL, error); g_error_free (error); } else { data->callback (data->data, string, NULL); g_free (string); } } }
static void set_ap_scan_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; DBusGProxyCall *call; GHashTable *config_hash; if (!dbus_g_proxy_end_call (proxy, call_id, &err, G_TYPE_INVALID)) { nm_log_warn (LOGD_SUPPLICANT, "Couldn't send AP scan mode to the supplicant interface: %s.", err->message); emit_error_helper (info->interface, err); g_error_free (err); return; } nm_log_info (LOGD_SUPPLICANT, "Config: set interface ap_scan to %d", nm_supplicant_config_get_ap_scan (priv->cfg)); info = nm_supplicant_info_new (info->interface, priv->iface_proxy, info->store); config_hash = nm_supplicant_config_get_hash (priv->cfg); call = dbus_g_proxy_begin_call (priv->iface_proxy, "AddNetwork", add_network_cb, info, nm_supplicant_info_destroy, DBUS_TYPE_G_MAP_OF_VARIANT, config_hash, G_TYPE_INVALID); g_hash_table_destroy (config_hash); nm_supplicant_info_set_call (info, call); }
static void serving_system_reply (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { CdmaDeviceInfo *info = user_data; GError *error = NULL; GValueArray *array = NULL; guint32 new_sid = 0; GValue *value; if (dbus_g_proxy_end_call (proxy, call, &error, SERVING_SYSTEM_TYPE, &array, G_TYPE_INVALID)) { if (array->n_values == 3) { value = g_value_array_get_nth (array, 2); if (G_VALUE_HOLDS_UINT (value)) new_sid = g_value_get_uint (value); } g_value_array_free (array); } if (new_sid != info->sid) { info->sid = new_sid; g_free (info->provider_name); info->provider_name = mobile_helper_parse_3gpp2_operator_name (&(info->mobile_providers_database), info->sid); } g_clear_error (&error); }
static void scan_results_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data) { GError *err = NULL; GPtrArray *array = NULL; if (!dbus_g_proxy_end_call (proxy, call_id, &err, DBUS_TYPE_G_ARRAY_OF_OBJECT_PATH, &array, G_TYPE_INVALID)) { nm_log_warn (LOGD_SUPPLICANT, "could not get scan results: %s.", err->message); g_error_free (err); } else { int i; NMSupplicantInfo *info = (NMSupplicantInfo *) user_data; /* Notify listeners of the result of the scan */ g_signal_emit (info->interface, nm_supplicant_interface_signals[SCAN_RESULTS], 0, array->len); /* Fire off a "properties" call for each returned BSSID */ for (i = 0; i < array->len; i++) { char *op = g_ptr_array_index (array, i); request_bssid_properties (info->interface, op); g_free (op); } g_ptr_array_free (array, TRUE); } }
static void reply_to_stop_dtmf (DBusGProxy *proxy, DBusGProxyCall *call, void *_request) { DEBUG ("enter"); ModemRequest *request = _request; ModemCall *self = modem_request_object (request); ModemCallReply *callback = modem_request_callback (request); gpointer user_data = modem_request_user_data (request); char *stopped; GError *error = NULL; if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &stopped, G_TYPE_INVALID)) { g_free (stopped); } else { modem_error_fix (&error); DEBUG ("got " GERROR_MSG_FMT, GERROR_MSG_CODE (error)); } if (callback) callback (self, request, error, user_data); g_clear_error (&error); }
static void set_network_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; guint tmp; if (!dbus_g_proxy_end_call (proxy, call_id, &err, G_TYPE_UINT, &tmp, G_TYPE_INVALID)) { nm_log_warn (LOGD_SUPPLICANT, "Couldn't set network config: %s.", err->message); emit_error_helper (info->interface, err); g_error_free (err); } else { DBusGProxyCall *call; info = nm_supplicant_info_new (info->interface, priv->iface_proxy, priv->assoc_pcalls); call = dbus_g_proxy_begin_call (priv->iface_proxy, "selectNetwork", select_network_cb, info, nm_supplicant_info_destroy, DBUS_TYPE_G_OBJECT_PATH, dbus_g_proxy_get_path (proxy), G_TYPE_INVALID); nm_supplicant_info_set_call (info, call); } }
static void __epris_dbus_proxy_get_all_reply_cb (DBusGProxy* proxy, DBusGProxyCall* call, void* user_data) { GError* error; GHashTable* props; error = NULL; dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &props, G_TYPE_INVALID); _epris_dbus_proxy_get_all_reply (user_data, props, error); }
static void query_cb (DBusGProxy *proxy, DBusGProxyCall *call, GSimpleAsyncResult *result) { GPtrArray *strv_array; GError *error = NULL; if (dbus_g_proxy_end_call (proxy, call, &error, TYPE_STRV_ARRAY, &strv_array, G_TYPE_INVALID)) { GStrv filenames; guint i; filenames = g_new0 (char*, strv_array->len + 1); for (i = 0; i < strv_array->len; i++) { GStrv data = g_ptr_array_index (strv_array, i); filenames[i] = g_strdup (data[0]); g_strfreev (data); } g_ptr_array_free (strv_array, TRUE); g_simple_async_result_set_op_res_gpointer (result, filenames, (GDestroyNotify) g_strfreev); }
static void stage1_prepare_done (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { NMModemGsm *self = NM_MODEM_GSM (user_data); NMModemGsmPrivate *priv = NM_MODEM_GSM_GET_PRIVATE (self); GError *error = NULL; priv->call = NULL; if (priv->connect_properties) { g_hash_table_destroy (priv->connect_properties); priv->connect_properties = NULL; } if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID)) g_signal_emit_by_name (self, NM_MODEM_PREPARE_RESULT, TRUE, NM_DEVICE_STATE_REASON_NONE); else { if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_PIN)) ask_for_pin (self, FALSE); else if (dbus_g_error_has_name (error, MM_MODEM_ERROR_SIM_WRONG)) ask_for_pin (self, TRUE); else { nm_log_warn (LOGD_MB, "GSM connection failed: (%d) %s", error ? error->code : -1, error && error->message ? error->message : "(unknown)"); g_signal_emit_by_name (self, NM_MODEM_PREPARE_RESULT, FALSE, translate_mm_error (error)); } g_error_free (error); } }
static void get_all_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { NMRemoteSettings *self = NM_REMOTE_SETTINGS (user_data); GHashTable *props = NULL; GError *error = NULL; if (!dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_MAP_OF_VARIANT, &props, G_TYPE_INVALID)) { /* Don't warn when the call times out because the settings service can't * be activated or whatever. */ if (!(error->domain == DBUS_GERROR && error->code == DBUS_GERROR_NO_REPLY)) { g_warning ("%s: couldn't retrieve system settings properties: (%d) %s.", __func__, error ? error->code : -1, (error && error->message) ? error->message : "(unknown)"); } g_clear_error (&error); return; } properties_changed_cb (NULL, props, self); g_hash_table_destroy (props); }
static void stage1_pin_done (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data) { NMModemGsm *self = NM_MODEM_GSM (user_data); NMModemGsmPrivate *priv = NM_MODEM_GSM_GET_PRIVATE (self); NMDeviceStateReason reason; GError *error = NULL; if (dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID)) { /* Success; try to enable the modem again. Wait a few seconds to ensure * that ModemManager is ready for the enable right after the unlock. */ if (priv->enable_delay_id == 0) priv->enable_delay_id = g_timeout_add_seconds (4, (GSourceFunc) do_enable, self); } else { nm_log_warn (LOGD_MB, "GSM PIN unlock failed: (%d) %s", error ? error->code : -1, error && error->message ? error->message : "(unknown)"); /* 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 void enumerate_devices_done (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer data) { NMModemManager *manager = NM_MODEM_MANAGER (data); GPtrArray *modems; GError *error = NULL; if (!dbus_g_proxy_end_call (proxy, call_id, &error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &modems, G_TYPE_INVALID)) { nm_log_warn (LOGD_MB, "could not get modem list: %s", error->message); g_error_free (error); } else { int i; for (i = 0; i < modems->len; i++) { char *path = (char *) g_ptr_array_index (modems, i); create_modem (manager, path); g_free (path); } g_ptr_array_free (modems, TRUE); } }
static void _on_got_playing_status (DBusGProxy *proxy, DBusGProxyCall *call_id, GldiModuleInstance *myApplet) { cd_debug ("=== %s ()", __func__); CD_APPLET_ENTER; s_pGetStatusCall = NULL; gchar *cStatus = NULL; GValue v = G_VALUE_INIT; GError *erreur = NULL; dbus_g_proxy_end_call (proxy, call_id, &erreur, G_TYPE_VALUE, &v, G_TYPE_INVALID); if (erreur != NULL) { cd_warning ("couldn't get MPRIS status (%s)\n", erreur->message); g_error_free (erreur); } else { if (G_VALUE_HOLDS_STRING (&v)) { cStatus = (gchar*)g_value_get_string (&v); myData.iPlayingStatus = _extract_status (cStatus); g_free (cStatus); // since we don't destroy the value, we destroy its content. } } cd_mpris2_getSongInfos_async (); CD_APPLET_LEAVE (); }
static void _dvb_plugin_factory_start_service_cb_cb (DBusGProxy* proxy, DBusGProxyCall* call, void* user_data) { GError* error; guint32 status; error = NULL; dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_UINT, &status, G_TYPE_INVALID); dvb_plugin_factory_start_service_cb (user_data, status, error); }
static void uninhibit_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, RBGPMPlugin *plugin) { GError *error = NULL; dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_INVALID); if (error != NULL) { if (!ignore_error (error)) { g_warning ("Failed to invoke %s.Inhibit: %s", dbus_g_proxy_get_interface (proxy), error->message); } else { rb_debug ("uninhibit failed: %s", error->message); } g_error_free (error); } else { rb_debug ("uninhibited"); plugin->cookie = 0; } g_object_unref (plugin); }
static void manager_get_properties_call_notify (DBusGProxy *proxy, DBusGProxyCall *call, gpointer data) { CmManager *manager = data; GError *error = NULL; GHashTable *properties = NULL; if (!dbus_g_proxy_end_call ( proxy, call, &error, /* OUT values */ dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &properties, G_TYPE_INVALID)) { g_debug ("Error calling dbus_g_proxy_end_call in %s: %s\n", __FUNCTION__, error->message); g_error_free (error); return; } g_hash_table_foreach (properties, (GHFunc)manager_update_property, manager); g_hash_table_unref (properties); manager_emit_updated (manager); }
static void enumerate_modems_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { GPtrArray *modems; GError *error = NULL; int i; if (!dbus_g_proxy_end_call (proxy, call, &error, dbus_g_type_get_collection ("GPtrArray", DBUS_TYPE_G_OBJECT_PATH), &modems, G_TYPE_INVALID)) { g_warning ("%s: failed to enumerate modems: (%d) %s", __func__, error ? error->code : -1, error && error->message ? error->message : "(unknown)"); g_clear_error (&error); return; } for (i = 0; i < modems->len; i++) { char *path = g_ptr_array_index (modems, i); modem_added (NULL, path, GEOCLUE_GSMLOC_MM (user_data)); g_free (path); } g_ptr_array_free (modems, TRUE); }
static void static_stage3_done (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { NMModem *self = NM_MODEM (user_data); NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self); GValueArray *ret_array = NULL; GError *error = NULL; NMIP4Config *config = NULL; priv->call = NULL; if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_VALUE_ARRAY, &ret_array, G_TYPE_INVALID)) { NMIP4Address *addr; int i; config = nm_ip4_config_new (); addr = nm_ip4_address_new (); nm_ip4_address_set_address (addr, g_value_get_uint (g_value_array_get_nth (ret_array, 0))); nm_ip4_address_set_prefix (addr, 32); nm_ip4_config_take_address (config, addr); for (i = 0; i < ret_array->n_values; i++) { GValue *value = g_value_array_get_nth (ret_array, i); nm_ip4_config_add_nameserver (config, g_value_get_uint (value)); } g_value_array_free (ret_array); } g_signal_emit (self, signals[IP4_CONFIG_RESULT], 0, NULL, config, error); g_clear_error (&error); }
static void dun_connect_cb (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data) { NmaBtDevice *self = NMA_BT_DEVICE (user_data); NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self); GError *error = NULL; char *device; g_message ("%s: processing Connect reply", __func__); if (!dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &device, G_TYPE_INVALID)) { dun_error (self, __func__, error, _("failed to connect to the phone.")); g_clear_error (&error); goto out; } if (!device || !strlen (device)) { dun_error (self, __func__, NULL, _("failed to connect to the phone.")); g_free (device); goto out; } g_free (priv->rfcomm_iface); priv->rfcomm_iface = device; g_message ("%s: new rfcomm interface '%s'", __func__, device); out: g_message ("%s: finished", __func__); }
static void dun_connect_cb (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data) { PluginInfo *info = user_data; GError *error = NULL; char *device; g_message ("%s: processing Connect reply", __func__); if (!dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_STRING, &device, G_TYPE_INVALID)) { dun_error (info, __func__, error, _("failed to connect to the phone.")); g_clear_error (&error); goto out; } if (!device || !strlen (device)) { dun_error (info, __func__, NULL, _("failed to connect to the phone.")); g_free (device); goto out; } info->rfcomm_iface = device; g_message ("%s: new rfcomm interface '%s'", __func__, device); out: g_message ("%s: finished", __func__); }
static void remove_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data) { CBInfo *info = user_data; GError *error = NULL; char * zone = NULL; if (!dbus_g_proxy_end_call (proxy, call_id, &error, G_TYPE_STRING, &zone, G_TYPE_INVALID)) { g_assert (error); /* ignore UNKNOWN_INTERFACE errors */ if (error->message && !strstr (error->message, "UNKNOWN_INTERFACE")) { nm_log_warn (LOGD_FIREWALL, "(%s) firewall zone remove failed [%u]: (%d) %s", info->iface, info->id, error->code, error->message); } else { nm_log_dbg (LOGD_FIREWALL, "(%s) firewall zone remove failed [%u]: (%d) %s", info->iface, info->id, error->code, error->message); } } else { nm_log_dbg (LOGD_FIREWALL, "(%s) firewall zone remove succeeded [%u]", info->iface, info->id); } info->completed = TRUE; g_free (zone); g_clear_error (&error); }
static void service_get_properties_call_notify (DBusGProxy *proxy, DBusGProxyCall *call, gpointer data) { CmService *service = data; GError *error = NULL; GHashTable *properties = NULL; gint count; if (!dbus_g_proxy_end_call ( proxy, call, &error, /* OUT values */ dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &properties, G_TYPE_INVALID)) { g_debug ("Error calling dbus_g_proxy_end_call in %s on %s: %s\n", __FUNCTION__, cm_service_get_name (service), error->message); g_error_free (error); return; } count = g_hash_table_size (properties); g_hash_table_foreach (properties, (GHFunc)service_update_property, service); g_hash_table_unref (properties); service_emit_updated (service); }
static void get_devices_cb (DBusGProxy *proxy, DBusGProxyCall *call, void *user_data) { GPtrArray *device_paths; GError *error = NULL; if (!dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_ARRAY_OF_OBJECT_PATH, &device_paths, G_TYPE_INVALID)) { g_warning ("Error fetching list of devices: %s\n", error->message); g_error_free (error); return; } g_ptr_array_foreach (device_paths, (GFunc) add_device_from_path, user_data); g_ptr_array_foreach (device_paths, (GFunc) g_free, NULL); g_ptr_array_free (device_paths, TRUE); }
static void reply_to_send_message (DBusGProxy *proxy, DBusGProxyCall *call, void *_request) { ModemRequest *request = _request; ModemSMSService *self = modem_request_object (request); ModemSMSServiceSendReply *callback = modem_request_callback (request); gpointer user_data = modem_request_user_data (request); char const *message_path = NULL; GError *error = NULL; if (dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &message_path, G_TYPE_INVALID)) { char const *destination; destination = modem_request_get_data (request, "destination"); } callback (self, request, message_path, error, user_data); g_clear_error (&error); }