static gboolean vibrator_timed_outputclass_real_vibrate_co (VibratorTimedOutputclassVibrateData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
default:
g_assert_not_reached ();
}
_state_0:
_data_->_tmp1_ = _data_->self->priv->pulses;
if (_data_->_tmp1_ > ((guint) 0)) {
_data_->_tmp0_ = TRUE;
} else {
_data_->_tmp2_ = _data_->self->priv->fulltimeoutwatch;
_data_->_tmp0_ = _data_->_tmp2_ > ((guint) 0);
}
_data_->_tmp3_ = _data_->_tmp0_;
if (_data_->_tmp3_) {
_data_->_tmp4_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INVALID_PARAMETER, "Already vibrating... please try again");
_data_->_inner_error_ = _data_->_tmp4_;
if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
_data_->_tmp5_ = _data_->milliseconds;
if (_data_->_tmp5_ < 50) {
_data_->_tmp6_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INVALID_PARAMETER, "Vibration timeout needs to be at least 50 milliseconds");
_data_->_inner_error_ = _data_->_tmp6_;
if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
vibrator_timed_outputclass_cleanTimeouts (_data_->self);
_data_->_tmp7_ = _data_->milliseconds;
vibrator_timed_outputclass_set_enable (_data_->self, _data_->_tmp7_);
_data_->_tmp8_ = _data_->milliseconds;
_data_->_tmp9_ = 0U;
_data_->_tmp9_ = g_timeout_add_full (G_PRIORITY_DEFAULT, (guint) _data_->_tmp8_, ___lambda2__gsource_func, g_object_ref (_data_->self), g_object_unref);
_data_->self->priv->fulltimeoutwatch = _data_->_tmp9_;
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
static void
tp_file_start_transfer (EmpathyTpFile *self)
{
gint fd, domain, res = 0;
GError *error = NULL;
struct sockaddr *my_addr = NULL;
size_t my_size = 0;
if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_UNIX)
{
domain = AF_UNIX;
}
else if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_IPV4)
{
domain = AF_INET;
}
else
{
error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
EMPATHY_FT_ERROR_NOT_SUPPORTED, _("Socket type not supported"));
DEBUG ("Socket not supported, closing channel");
ft_operation_close_with_error (self, error);
g_clear_error (&error);
return;
}
fd = socket (domain, SOCK_STREAM, 0);
if (fd < 0)
{
int code = errno;
error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
EMPATHY_FT_ERROR_SOCKET, g_strerror (code));
DEBUG ("Failed to create socket, closing channel");
ft_operation_close_with_error (self, error);
g_clear_error (&error);
return;
}
if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_UNIX)
{
struct sockaddr_un addr;
memset (&addr, 0, sizeof (addr));
addr.sun_family = domain;
strncpy (addr.sun_path, self->priv->socket_address->data,
self->priv->socket_address->len);
my_addr = (struct sockaddr *) &addr;
my_size = sizeof (addr);
}
else if (self->priv->socket_address_type == TP_SOCKET_ADDRESS_TYPE_IPV4)
{
struct sockaddr_in addr;
memset (&addr, 0, sizeof (addr));
addr.sin_family = domain;
inet_pton (AF_INET, self->priv->socket_address->data, &addr.sin_addr);
addr.sin_port = htons (self->priv->port);
my_addr = (struct sockaddr *) &addr;
my_size = sizeof (addr);
}
res = connect (fd, my_addr, my_size);
if (res < 0)
{
int code = errno;
error = g_error_new_literal (EMPATHY_FT_ERROR_QUARK,
EMPATHY_FT_ERROR_SOCKET, g_strerror (code));
DEBUG ("Failed to connect socket, closing channel");
ft_operation_close_with_error (self, error);
close (fd);
g_clear_error (&error);
return;
}
DEBUG ("Start the transfer");
self->priv->start_time = empathy_time_get_current ();
/* notify we're starting a transfer */
if (self->priv->progress_callback != NULL)
self->priv->progress_callback (self, 0, self->priv->progress_user_data);
if (self->priv->incoming)
{
GInputStream *socket_stream;
socket_stream = g_unix_input_stream_new (fd, TRUE);
g_output_stream_splice_async (self->priv->out_stream, socket_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, self->priv->cancellable,
splice_stream_ready_cb, self);
g_object_unref (socket_stream);
}
else
{
GOutputStream *socket_stream;
socket_stream = g_unix_output_stream_new (fd, TRUE);
g_output_stream_splice_async (socket_stream, self->priv->in_stream,
G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE |
G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET,
G_PRIORITY_DEFAULT, self->priv->cancellable,
splice_stream_ready_cb, self);
g_object_unref (socket_stream);
}
}
void
ephy_sqlite_connection_get_error (EphySQLiteConnection *self, GError **error)
{
if (error)
*error = g_error_new_literal (get_ephy_sqlite_quark (), 0, sqlite3_errmsg (self->database));
}
static void
master_shunt_read (FlowShunt *shunt, FlowPacket *packet, FlowSshMaster *ssh_master)
{
FlowSshMasterPrivate *priv = ssh_master->priv;
FlowPacketFormat packet_format = flow_packet_get_format (packet);
gpointer packet_data = flow_packet_get_data (packet);
const gchar *signal_to_emit = NULL;
g_mutex_lock (priv->mutex);
if (packet_format == FLOW_PACKET_FORMAT_OBJECT && FLOW_IS_DETAILED_EVENT (packet_data))
{
FlowDetailedEvent *detailed_event = (FlowDetailedEvent *) packet_data;
if (flow_detailed_event_matches (detailed_event, FLOW_STREAM_DOMAIN, FLOW_STREAM_BEGIN))
{
/* Shell command is running, but not yet connected to remote end */
}
else if (flow_detailed_event_matches (detailed_event, FLOW_STREAM_DOMAIN, FLOW_STREAM_END))
{
flow_shunt_destroy (priv->shunt);
priv->shunt = NULL;
if (priv->is_connecting)
{
if (priv->connect_error)
g_error_free (priv->connect_error);
priv->connect_error = g_error_new_literal (FLOW_SSH_DOMAIN_QUARK, FLOW_SSH_MASTER_FAILED,
"Could not connect SSH master");
signal_to_emit = "connect-finished";
}
else
{
signal_to_emit = "disconnected";
}
priv->is_connecting = FALSE;
priv->is_connected = FALSE;
}
else if (flow_detailed_event_matches (detailed_event, FLOW_STREAM_DOMAIN, FLOW_STREAM_DENIED))
{
flow_shunt_destroy (priv->shunt);
priv->shunt = NULL;
if (priv->connect_error)
g_error_free (priv->connect_error);
priv->connect_error = g_error_new_literal (FLOW_SSH_DOMAIN_QUARK, FLOW_SSH_MASTER_FAILED,
"Could not start SSH master");
priv->is_connecting = FALSE;
signal_to_emit = "connect-finished";
}
}
else if (packet_format == FLOW_PACKET_FORMAT_BUFFER)
{
if (priv->is_connecting)
signal_to_emit = "connect-finished";
priv->is_connected = TRUE;
priv->is_connecting = FALSE;
if (!is_master_working (ssh_master))
{
flow_shunt_destroy (priv->shunt);
priv->shunt = NULL;
}
}
g_mutex_unlock (priv->mutex);
flow_packet_unref (packet);
if (signal_to_emit)
g_signal_emit_by_name (ssh_master, signal_to_emit);
}
static void
thunar_apr_desktop_page_save (ThunarAprDesktopPage *desktop_page,
GtkWidget *widget)
{
GtkWidget *toplevel;
GtkWidget *message;
GKeyFile *key_file;
GError *error = NULL;
gchar *filename;
gchar *data;
gchar *uri;
gsize data_length;
FILE *fp;
/* verify that we still have a valid file */
if (THUNAR_APR_ABSTRACT_PAGE (desktop_page)->file == NULL)
return;
/* determine the local path to the file */
uri = thunarx_file_info_get_uri (THUNAR_APR_ABSTRACT_PAGE (desktop_page)->file);
filename = g_filename_from_uri (uri, NULL, NULL);
g_free (uri);
/* verify that we have a valid local path */
if (G_UNLIKELY (filename == NULL))
return;
/* allocate the key file resources */
key_file = g_key_file_new ();
/* try to parse the key file */
if (g_key_file_load_from_file (key_file, filename, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error))
{
/* save the widget changes to the key file */
thunar_apr_desktop_page_save_widget (desktop_page, widget, key_file);
/* give empty desktop files a type */
if (!g_key_file_has_key (key_file, G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_TYPE, NULL))
{
g_key_file_set_string (key_file,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_TYPE,
"Application");
}
/* determine the content of the key file */
data = g_key_file_to_data (key_file, &data_length, &error);
if (G_LIKELY (data_length > 0))
{
/* try to save the key file content to disk */
fp = fopen (filename, "w");
if (G_LIKELY (fp != NULL))
{
if (fwrite (data, data_length, 1, fp) != 1)
error = g_error_new_literal (G_FILE_ERROR, g_file_error_from_errno (errno), g_strerror (errno));
fclose (fp);
}
else
{
error = g_error_new_literal (G_FILE_ERROR, g_file_error_from_errno (errno), g_strerror (errno));
}
}
/* cleanup */
g_free (data);
}
/* check if we succeed */
if (G_UNLIKELY (error != NULL))
{
/* display an error dialog to the user */
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (desktop_page));
message = gtk_message_dialog_new ((GtkWindow *) toplevel,
GTK_DIALOG_DESTROY_WITH_PARENT
| GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Failed to save \"%s\"."), filename);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (message), "%s.", error->message);
gtk_dialog_run (GTK_DIALOG (message));
gtk_widget_destroy (message);
g_error_free (error);
}
/* cleanup */
g_key_file_free (key_file);
g_free (filename);
}
static GError *
format_message (GQuark id, char const *message)
{
char const *msg = message ? message : "";
return g_error_new_literal (id, 0, msg);
}
/**
* g_dbus_address_get_stream_sync:
* @address: A valid D-Bus address.
* @out_guid: %NULL or return location to store the GUID extracted from @address, if any.
* @cancellable: (allow-none): A #GCancellable or %NULL.
* @error: Return location for error or %NULL.
*
* Synchronously connects to an endpoint specified by @address and
* sets up the connection so it is in a state to run the client-side
* of the D-Bus authentication conversation.
*
* This is a synchronous failable function. See
* g_dbus_address_get_stream() for the asynchronous version.
*
* Returns: (transfer full): A #GIOStream or %NULL if @error is set.
*
* Since: 2.26
*/
GIOStream *
g_dbus_address_get_stream_sync (const gchar *address,
gchar **out_guid,
GCancellable *cancellable,
GError **error)
{
GIOStream *ret;
gchar **addr_array;
guint n;
GError *last_error;
g_return_val_if_fail (address != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = NULL;
last_error = NULL;
addr_array = g_strsplit (address, ";", 0);
if (addr_array != NULL && addr_array[0] == NULL)
{
last_error = g_error_new_literal (G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("The given address is empty"));
goto out;
}
for (n = 0; addr_array != NULL && addr_array[n] != NULL; n++)
{
const gchar *addr = addr_array[n];
GError *this_error;
this_error = NULL;
ret = g_dbus_address_try_connect_one (addr,
out_guid,
cancellable,
&this_error);
if (ret != NULL)
{
goto out;
}
else
{
g_assert (this_error != NULL);
if (last_error != NULL)
g_error_free (last_error);
last_error = this_error;
}
}
out:
if (ret != NULL)
{
if (last_error != NULL)
g_error_free (last_error);
}
else
{
g_assert (last_error != NULL);
g_propagate_error (error, last_error);
}
g_strfreev (addr_array);
return ret;
}
static void
get_ip4_config_done (MMAtSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = (MMCallbackInfo *) user_data;
char **items, **iter;
GArray *dns_array;
int i;
guint32 tmp;
gint cid;
/* If the modem has already been removed, return without
* scheduling callback */
if (mm_callback_info_check_modem_removed (info))
return;
if (error) {
info->error = g_error_copy (error);
goto out;
} else if (!g_str_has_prefix (response->str, IPDPADDR_TAG)) {
info->error = g_error_new_literal (MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Retrieving failed: invalid response.");
goto out;
}
cid = _get_cid (MM_MODEM_ICERA (info->modem));
dns_array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 2);
/* %IPDPADDR: <cid>,<ip>,<gw>,<dns1>,<dns2>[,<nbns1>,<nbns2>] */
items = g_strsplit (response->str + strlen (IPDPADDR_TAG), ", ", 0);
for (iter = items, i = 0; *iter; iter++, i++) {
if (i == 0) { /* CID */
long int num;
errno = 0;
num = strtol (*iter, NULL, 10);
if (errno != 0 || num < 0 || (gint) num != cid) {
info->error = g_error_new (MM_MODEM_ERROR, MM_MODEM_ERROR_GENERAL,
"Unknown CID in IPDPADDR response ("
"got %d, expected %d)", (guint) num, cid);
break;
}
} else if (i == 1) { /* IP address */
if (inet_pton (AF_INET, *iter, &tmp) > 0)
mm_callback_info_set_data (info, "ip4-address", GUINT_TO_POINTER (tmp), NULL);
} else if (i == 3) { /* DNS 1 */
if (inet_pton (AF_INET, *iter, &tmp) > 0)
g_array_append_val (dns_array, tmp);
} else if (i == 4) { /* DNS 2 */
if (inet_pton (AF_INET, *iter, &tmp) > 0)
g_array_append_val (dns_array, tmp);
}
}
g_strfreev (items);
mm_callback_info_set_data (info, "ip4-dns", dns_array, free_dns_array);
out:
mm_callback_info_schedule (info);
}
static gboolean pdp_qmi_real_sc_activate_co (PdpQmiScActivateData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
default:
g_assert_not_reached ();
}
_state_0:
_data_->_tmp0_ = fso_gsm_pdp_handler_get_modem ((FsoGsmPdpHandler*) _data_->self);
_data_->_tmp1_ = _data_->_tmp0_;
_data_->_tmp2_ = NULL;
_data_->_tmp2_ = fso_gsm_modem_data (_data_->_tmp1_);
_data_->data = _data_->_tmp2_;
_data_->_tmp3_ = _data_->data;
_data_->_tmp4_ = _data_->_tmp3_->contextParams;
if (_data_->_tmp4_ == NULL) {
_data_->_tmp5_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "Context parameters not set");
_data_->_inner_error_ = _data_->_tmp5_;
if ((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
_g_object_unref0 (_data_->data);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
_g_object_unref0 (_data_->data);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
_data_->_tmp6_ = _data_->data;
_data_->_tmp7_ = _data_->_tmp6_->contextParams;
_data_->_tmp8_ = _data_->_tmp7_->apn;
if (_data_->_tmp8_ == NULL) {
_data_->_tmp9_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INTERNAL_ERROR, "APN not set");
_data_->_inner_error_ = _data_->_tmp9_;
if ((_data_->_inner_error_->domain == FREE_SMARTPHONE_GSM_ERROR) || (_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
_g_object_unref0 (_data_->data);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
_g_object_unref0 (_data_->data);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
_data_->_tmp10_ = _data_->data;
_data_->_tmp11_ = _data_->_tmp10_->contextParams;
_data_->_tmp12_ = _data_->_tmp11_->apn;
_data_->_tmp13_ = NULL;
_data_->_tmp13_ = string_to_string (_data_->_tmp12_);
_data_->_tmp14_ = _data_->data;
_data_->_tmp15_ = _data_->_tmp14_->contextParams;
_data_->_tmp16_ = _data_->_tmp15_->username;
_data_->_tmp17_ = NULL;
_data_->_tmp17_ = string_to_string (_data_->_tmp16_);
_data_->_tmp18_ = _data_->data;
_data_->_tmp19_ = _data_->_tmp18_->contextParams;
_data_->_tmp20_ = _data_->_tmp19_->password;
_data_->_tmp21_ = NULL;
_data_->_tmp21_ = string_to_string (_data_->_tmp20_);
_data_->_tmp22_ = NULL;
_data_->_tmp22_ = g_strconcat ("up:", _data_->_tmp13_, " ", _data_->_tmp17_, " ", _data_->_tmp21_, NULL);
_data_->cmdline = _data_->_tmp22_;
_data_->_tmp23_ = _data_->self->fd;
_data_->_tmp24_ = _data_->cmdline;
_data_->_tmp25_ = _data_->cmdline;
_data_->_tmp26_ = strlen (_data_->_tmp25_);
_data_->_tmp27_ = _data_->_tmp26_;
write (_data_->_tmp23_, _data_->_tmp24_, (gsize) _data_->_tmp27_);
_g_free0 (_data_->cmdline);
_g_object_unref0 (_data_->data);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
static void
keyring_find_secrets_cb (GnomeKeyringResult result,
GList *list,
gpointer user_data)
{
KeyringCall *call = user_data;
Request *r = call->r;
GError *error = NULL;
const char *connection_id = NULL;
GHashTable *secrets = NULL, *settings = NULL;
GList *iter;
gboolean hint_found = FALSE, ask = FALSE;
r->keyring_calls = g_slist_remove (r->keyring_calls, call);
if (r->canceled) {
/* Callback already called by NM or dispose */
request_free (r);
return;
}
connection_id = nm_connection_get_id (r->connection);
if (result == GNOME_KEYRING_RESULT_CANCELLED) {
error = g_error_new_literal (NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_USER_CANCELED,
"The secrets request was canceled by the user");
goto done;
} else if ( result != GNOME_KEYRING_RESULT_OK
&& result != GNOME_KEYRING_RESULT_NO_MATCH) {
error = g_error_new (NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_INTERNAL_ERROR,
"%s.%d - failed to read secrets from keyring (result %d)",
__FILE__, __LINE__, result);
goto done;
}
/* Only ask if we're allowed to, ie if flags != NM_SECRET_AGENT_GET_SECRETS_FLAG_NONE */
if (r->flags && g_list_length (list) == 0) {
g_message ("No keyring secrets found for %s/%s; asking user.", connection_id, r->setting_name);
ask_for_secrets (r);
return;
}
secrets = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, destroy_gvalue);
/* Extract the secrets from the list of matching keyring items */
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
GnomeKeyringFound *found = iter->data;
GnomeKeyringAttribute *attr;
const char *key_name = NULL;
int i;
for (i = 0; i < found->attributes->len; i++) {
attr = &(gnome_keyring_attribute_list_index (found->attributes, i));
if ( (strcmp (attr->name, KEYRING_SK_TAG) == 0)
&& (attr->type == GNOME_KEYRING_ATTRIBUTE_TYPE_STRING)) {
key_name = attr->value.string;
g_hash_table_insert (secrets, g_strdup (key_name), string_to_gvalue (found->secret));
/* See if this property matches a given hint */
if (r->hints && r->hints[0]) {
if (!g_strcmp0 (r->hints[0], key_name) || !g_strcmp0 (r->hints[1], key_name))
hint_found = TRUE;
}
break;
}
}
}
/* If there were hints, and none of the hints were returned by the keyring,
* get some new secrets.
*/
if (r->flags) {
if (r->hints && r->hints[0] && !hint_found)
ask = TRUE;
else if (r->flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW) {
g_message ("New secrets for %s/%s requested; ask the user", connection_id, r->setting_name);
ask = TRUE;
} else if ( (r->flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION)
&& is_connection_always_ask (r->connection))
ask = TRUE;
}
/* Returned secrets are a{sa{sv}}; this is the outer a{s...} hash that
* will contain all the individual settings hashes.
*/
settings = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_destroy);
g_hash_table_insert (settings, g_strdup (r->setting_name), secrets);
done:
if (ask) {
GHashTableIter hash_iter;
const char *setting_name;
GHashTable *setting_hash;
/* Stuff all the found secrets into the connection for the UI to use */
g_hash_table_iter_init (&hash_iter, settings);
while (g_hash_table_iter_next (&hash_iter,
(gpointer *) &setting_name,
(gpointer *) &setting_hash)) {
nm_connection_update_secrets (r->connection,
setting_name,
setting_hash,
NULL);
}
ask_for_secrets (r);
} else {
/* Otherwise send the secrets back to NetworkManager */
r->get_callback (NM_SECRET_AGENT (r->agent), r->connection, error ? NULL : settings, error, r->callback_data);
request_free (r);
}
if (settings)
g_hash_table_destroy (settings);
g_clear_error (&error);
}
static gboolean tracker_bus_fd_cursor_real_next (TrackerSparqlCursor* base, GCancellable* cancellable, GError** error) {
TrackerBusFDCursor * self;
gboolean result = FALSE;
gint last_offset = 0;
gboolean _tmp0_ = FALSE;
GCancellable* _tmp1_ = NULL;
gulong _tmp5_ = 0UL;
gulong _tmp6_ = 0UL;
gint _tmp7_ = 0;
gchar* _tmp8_ = NULL;
gulong _tmp9_ = 0UL;
gulong _tmp10_ = 0UL;
gint _tmp11_ = 0;
gint _tmp12_ = 0;
gchar* _tmp13_ = NULL;
gulong _tmp14_ = 0UL;
gulong _tmp15_ = 0UL;
gint _tmp16_ = 0;
gint _tmp17_ = 0;
gint _tmp18_ = 0;
gchar* _tmp19_ = NULL;
gulong _tmp20_ = 0UL;
gulong _tmp21_ = 0UL;
gint _tmp22_ = 0;
GError * _inner_error_ = NULL;
#line 86 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self = (TrackerBusFDCursor*) base;
#line 89 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp1_ = cancellable;
#line 89 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
if (_tmp1_ != NULL) {
#line 402 "tracker-bus-fd-cursor.c"
GCancellable* _tmp2_ = NULL;
gboolean _tmp3_ = FALSE;
#line 89 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp2_ = cancellable;
#line 89 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp3_ = g_cancellable_is_cancelled (_tmp2_);
#line 89 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp0_ = _tmp3_;
#line 411 "tracker-bus-fd-cursor.c"
} else {
#line 89 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp0_ = FALSE;
#line 415 "tracker-bus-fd-cursor.c"
}
#line 89 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
if (_tmp0_) {
#line 419 "tracker-bus-fd-cursor.c"
GError* _tmp4_ = NULL;
#line 90 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp4_ = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Operation was cancelled");
#line 90 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_inner_error_ = _tmp4_;
#line 90 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
g_propagate_error (error, _inner_error_);
#line 90 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
return FALSE;
#line 429 "tracker-bus-fd-cursor.c"
}
#line 93 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp5_ = self->buffer_index;
#line 93 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp6_ = self->buffer_size;
#line 93 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
if (_tmp5_ >= _tmp6_) {
#line 94 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
result = FALSE;
#line 94 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
return result;
#line 441 "tracker-bus-fd-cursor.c"
}
#line 104 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp7_ = tracker_bus_fd_cursor_buffer_read_int (self);
#line 104 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self->_n_columns = _tmp7_;
#line 108 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp8_ = self->buffer;
#line 108 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp9_ = self->buffer_index;
#line 108 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self->types = (gint*) (_tmp8_ + _tmp9_);
#line 109 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp10_ = self->buffer_index;
#line 109 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp11_ = tracker_sparql_cursor_get_n_columns ((TrackerSparqlCursor*) self);
#line 109 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp12_ = _tmp11_;
#line 109 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self->buffer_index = _tmp10_ + (sizeof (gint) * _tmp12_);
#line 111 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp13_ = self->buffer;
#line 111 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp14_ = self->buffer_index;
#line 111 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self->offsets = (gint*) (_tmp13_ + _tmp14_);
#line 112 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp15_ = self->buffer_index;
#line 112 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp16_ = tracker_sparql_cursor_get_n_columns ((TrackerSparqlCursor*) self);
#line 112 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp17_ = _tmp16_;
#line 112 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self->buffer_index = _tmp15_ + (sizeof (gint) * (_tmp17_ - 1));
#line 113 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp18_ = tracker_bus_fd_cursor_buffer_read_int (self);
#line 113 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
last_offset = _tmp18_;
#line 115 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp19_ = self->buffer;
#line 115 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp20_ = self->buffer_index;
#line 115 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self->data = _tmp19_ + _tmp20_;
#line 117 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp21_ = self->buffer_index;
#line 117 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
_tmp22_ = last_offset;
#line 117 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
self->buffer_index = _tmp21_ + (_tmp22_ + 1);
#line 119 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
result = TRUE;
#line 119 "/home/martyn/Source/checkout/gnome/tracker/src/libtracker-bus/tracker-bus-fd-cursor.vala"
return result;
#line 495 "tracker-bus-fd-cursor.c"
}
static void
on_autorun_loaded (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
GFile *autorun_file;
gchar *content;
gchar *relative_icon_path;
gsize content_length;
GError *error;
relative_icon_path = NULL;
autorun_file = G_FILE (source_object);
error = NULL;
if (g_file_load_contents_finish (autorun_file,
res,
&content,
&content_length,
NULL,
&error))
{
/* Scan through for an "icon=" line. Can't use GKeyFile,
* because .inf files aren't always valid key files
**/
GRegex *icon_regex;
GMatchInfo *match_info;
/* [^,] is because sometimes the icon= line
* has a comma at the end
**/
icon_regex = g_regex_new ("icon=([^,\\r\\n]+)",
G_REGEX_CASELESS, 0, NULL);
g_regex_match (icon_regex, content, 0,
&match_info);
/* Even if there are multiple matches, pick only the
* first.
**/
if (g_match_info_matches (match_info))
{
gchar *chr;
gchar *word = g_match_info_fetch (match_info, 1);
/* Replace '\' with '/' */
while ((chr = strchr (word, '\\')) != NULL)
*chr = '/';
/* If the file name's not valid UTF-8,
* don't even try to load it
**/
if (g_utf8_validate (word, -1, NULL))
{
relative_icon_path = word;
}
else
{
/* TODO: mark for translation. Strictly, this isn't very important; this string
* will never be displayed since all current users of g_vfs_mount_info_query_autorun_info()
* passes NULL for the GError**.
*/
error = g_error_new_literal (G_IO_ERROR,
G_IO_ERROR_FAILED,
"Icon name is not valid UTF-8");
g_free (word);
}
}
g_match_info_free (match_info);
g_regex_unref (icon_regex);
g_free (content);
}
/* some autorun.in points to the .exe file for the icon; make sure we avoid using that */
if (relative_icon_path != NULL)
{
if (!g_str_has_suffix (relative_icon_path, ".exe"))
{
GFile *root;
root = g_file_get_parent (autorun_file);
_g_find_file_insensitive_async (root,
relative_icon_path,
NULL,
on_icon_file_located,
simple);
g_object_unref (root);
}
else
{
/* TODO: mark for translation. Strictly, this isn't very important; this string
* will never be displayed since all current users of g_vfs_mount_info_query_autorun_info()
* passes NULL for the GError**.
*/
error = g_error_new_literal (G_IO_ERROR,
G_IO_ERROR_FAILED,
"Icon is an .exe file");
}
}
if (error != NULL)
{
g_simple_async_result_set_from_error (simple, error);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
g_error_free (error);
}
g_free (relative_icon_path);
}
static void
bdmv_metadata_thread (GSimpleAsyncResult *result,
GObject *object,
GCancellable *cancellable)
{
BLURAY *bd;
META_DL *meta;
GError *error;
GFile *file;
char *disc_root;
char *icon;
char *name;
const char *lang;
file = G_FILE (object);
disc_root = g_file_get_path (file);
bd = bd_open (disc_root, NULL);
g_free (disc_root);
if (bd == NULL)
{
error = g_error_new_literal (G_IO_ERROR,
G_IO_ERROR_FAILED,
"Device is not a Blu-Ray disc");
goto error;
}
lang = get_iso_639_3_for_locale ();
if (lang != NULL)
bd_set_player_setting_str (bd, BLURAY_PLAYER_SETTING_MENU_LANG, lang);
meta = bd_get_meta (bd);
if (meta == NULL)
{
error = g_error_new_literal (G_IO_ERROR,
G_IO_ERROR_FAILED,
"Device is not a Blu-Ray disc, or has no metadata");
bd_close (bd);
goto error;
}
name = icon = NULL;
if (meta != NULL)
{
if (meta->di_name && *meta->di_name)
name = g_strdup (meta->di_name);
icon = g_strdup (get_icon (meta));
}
/* We're missing either an icon, or the name */
if (!name || !icon)
{
bd_set_player_setting_str (bd, BLURAY_PLAYER_SETTING_MENU_LANG, "eng");
meta = bd_get_meta (bd);
if (meta != NULL && name == NULL && meta->di_name && *meta->di_name)
name = meta->di_name;
if (meta != NULL && icon == NULL)
icon = g_strdup (get_icon (meta));
}
/* Set the results */
if (icon != NULL)
{
char *icon_path;
GFile *icon_file;
icon_path = g_strdup_printf ("BDMV/META/DL/%s", icon);
g_free (icon);
icon_file = g_file_resolve_relative_path (file, icon_path);
g_free (icon_path);
g_simple_async_result_set_op_res_gpointer (result,
g_file_icon_new (icon_file),
NULL);
}
else
{
g_simple_async_result_set_op_res_gpointer (result, NULL, NULL);
}
if (name != NULL)
g_object_set_data_full (G_OBJECT (result), "name", name, g_free);
bd_close (bd);
return;
error:
g_simple_async_result_set_from_error (result, error);
g_simple_async_result_set_op_res_gpointer (result, NULL, NULL);
g_error_free (error);
}
gssize fusion_tls_connection_send (FusionTLSConnection* self, guint8* buffer, int buffer_length1, GCancellable* cancellable, GError** error) {
gssize result = 0L;
gssize ret = 0L;
GSocket* _tmp0_ = NULL;
gboolean _tmp1_ = FALSE;
GCancellable* _tmp3_ = NULL;
GError * _inner_error_ = NULL;
g_return_val_if_fail (self != NULL, 0L);
g_warning ("TLSConnection.vala:123: SEND");
_tmp0_ = self->priv->socket;
_tmp1_ = g_socket_is_closed (_tmp0_);
if (_tmp1_) {
GError* _tmp2_ = NULL;
_tmp2_ = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CLOSED, "Socket is already closed");
_inner_error_ = _tmp2_;
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
_tmp3_ = cancellable;
g_cancellable_set_error_if_cancelled (_tmp3_, &_inner_error_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
while (TRUE) {
gboolean _tmp4_ = FALSE;
GSocket* _tmp5_ = NULL;
gboolean _tmp6_ = FALSE;
gboolean _tmp11_ = FALSE;
struct gnutls_session_int* _tmp12_ = NULL;
guint8* _tmp13_ = NULL;
gint _tmp13__length1 = 0;
guint8* _tmp14_ = NULL;
gint _tmp14__length1 = 0;
gssize _tmp15_ = 0L;
gssize _tmp16_ = 0L;
_tmp5_ = self->priv->socket;
_tmp6_ = g_socket_get_blocking (_tmp5_);
if (_tmp6_) {
gboolean _tmp7_ = FALSE;
GSocket* _tmp8_ = NULL;
GCancellable* _tmp9_ = NULL;
gboolean _tmp10_ = FALSE;
_tmp8_ = self->priv->socket;
_tmp9_ = cancellable;
_tmp10_ = g_socket_condition_wait (_tmp8_, G_IO_OUT, _tmp9_, &_inner_error_);
_tmp7_ = _tmp10_;
if (_inner_error_ != NULL) {
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
_tmp4_ = !_tmp7_;
} else {
_tmp4_ = FALSE;
}
_tmp11_ = _tmp4_;
if (_tmp11_) {
result = (gssize) (-1);
return result;
}
_tmp12_ = self->tls_session;
_tmp13_ = buffer;
_tmp13__length1 = buffer_length1;
_tmp14_ = buffer;
_tmp14__length1 = buffer_length1;
_tmp15_ = gnutls_record_send (_tmp12_, _tmp13_, (gsize) _tmp14__length1);
ret = _tmp15_;
_tmp16_ = ret;
if (_tmp16_ < ((gssize) 0)) {
int ecode = 0;
gssize _tmp17_ = 0L;
int _tmp18_ = 0;
gboolean _tmp19_ = FALSE;
GSocket* _tmp20_ = NULL;
gboolean _tmp21_ = FALSE;
gboolean _tmp23_ = FALSE;
int _tmp24_ = 0;
_tmp17_ = ret;
ecode = (int) _tmp17_;
_tmp18_ = ecode;
if (_tmp18_ == GNUTLS_E_INTERRUPTED) {
continue;
}
_tmp20_ = self->priv->socket;
_tmp21_ = g_socket_get_blocking (_tmp20_);
if (_tmp21_) {
int _tmp22_ = 0;
_tmp22_ = ecode;
_tmp19_ = _tmp22_ == GNUTLS_E_AGAIN;
} else {
_tmp19_ = FALSE;
}
_tmp23_ = _tmp19_;
if (_tmp23_) {
continue;
}
_tmp24_ = ecode;
fusion_tls_connection_handle_error (self, _tmp24_, 2, &_inner_error_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
continue;
}
break;
}
result = ret;
return result;
}
/*
* IO watcher for stdout, called whenever there is data to read from the backend.
* This is where most of the actual IO handling happens.
*/
static gboolean
io_watch_stdout (GIOChannel *source, GIOCondition condition, PasswdHandler *passwd_handler)
{
static GString *str = NULL; /* Persistent buffer */
gchar buf[BUFSIZE]; /* Temporary buffer */
gsize bytes_read;
GError *gio_error = NULL; /* Error returned by functions */
GError *error = NULL; /* Error sent to callbacks */
gboolean reinit = FALSE;
/* Initialize buffer */
if (str == NULL) {
str = g_string_new ("");
}
if (g_io_channel_read_chars (source, buf, BUFSIZE, &bytes_read, &gio_error)
!= G_IO_STATUS_NORMAL) {
g_warning ("IO Channel read error: %s", gio_error->message);
g_error_free (gio_error);
return TRUE;
}
str = g_string_append_len (str, buf, bytes_read);
/* In which state is the backend? */
switch (passwd_handler->backend_state) {
case PASSWD_STATE_AUTH:
/* Passwd is asking for our current password */
if (is_string_complete (str->str, "assword: ", "failure", "wrong", "error", NULL)) {
if (strstr (str->str, "assword: ") != NULL) {
/* Authentication successful */
passwd_handler->backend_state = PASSWD_STATE_NEW;
/* Trigger callback to update authentication status */
if (passwd_handler->auth_cb)
passwd_handler->auth_cb (passwd_handler,
NULL,
passwd_handler->auth_cb_data);
} else {
/* Authentication failed */
error = g_error_new_literal (PASSWD_ERROR, PASSWD_ERROR_AUTH_FAILED,
_("Authentication failed"));
passwd_handler->changing_password = FALSE;
/* This error can happen both while authenticating or while changing password:
* if chpasswd_cb is set, this means we're already changing password */
if (passwd_handler->chpasswd_cb)
passwd_handler->chpasswd_cb (passwd_handler,
error,
passwd_handler->chpasswd_cb_data);
else if (passwd_handler->auth_cb)
passwd_handler->auth_cb (passwd_handler,
error,
passwd_handler->auth_cb_data);
g_error_free (error);
}
reinit = TRUE;
}
break;
case PASSWD_STATE_NEW:
/* Passwd is asking for our new password */
if (is_string_complete (str->str, "assword: ", NULL)) {
/* Advance to next state */
passwd_handler->backend_state = PASSWD_STATE_RETYPE;
/* Pop retyped password from queue and into IO channel */
io_queue_pop (passwd_handler->backend_stdin_queue, passwd_handler->backend_stdin);
reinit = TRUE;
}
break;
case PASSWD_STATE_RETYPE:
/* Passwd is asking for our retyped new password */
if (is_string_complete (str->str,
"successfully",
"short",
"longer",
"palindrome",
"dictionary",
"simple",
"simplistic",
"similar",
"case",
"different",
"wrapped",
"recovered",
"recent",
"unchanged",
"match",
"1 numeric or special",
"failure",
"DIFFERENT",
"BAD PASSWORD",
NULL)) {
if (strstr (str->str, "successfully") != NULL) {
/* Hooray! */
passwd_handler->backend_state = PASSWD_STATE_DONE;
/* Trigger callback to update status */
if (passwd_handler->chpasswd_cb)
passwd_handler->chpasswd_cb (passwd_handler,
NULL,
passwd_handler->chpasswd_cb_data);
}
else {
/* Ohnoes! */
if (strstr (str->str, "recovered") != NULL) {
/* What does this indicate?
* "Authentication information cannot be recovered?" from libpam? */
error = g_error_new_literal (PASSWD_ERROR, PASSWD_ERROR_UNKNOWN,
str->str);
} else if (strstr (str->str, "short") != NULL ||
strstr (str->str, "longer") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password is too short"));
} else if (strstr (str->str, "palindrome") != NULL ||
strstr (str->str, "simple") != NULL ||
strstr (str->str, "simplistic") != NULL ||
strstr (str->str, "dictionary") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password is too simple"));
} else if (strstr (str->str, "similar") != NULL ||
strstr (str->str, "different") != NULL ||
strstr (str->str, "case") != NULL ||
strstr (str->str, "wrapped") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The old and new passwords are too similar"));
} else if (strstr (str->str, "recent") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password has already been used recently."));
} else if (strstr (str->str, "1 numeric or special") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password must contain numeric or special characters"));
} else if (strstr (str->str, "unchanged") != NULL ||
strstr (str->str, "match") != NULL) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The old and new passwords are the same"));
} else if (strstr (str->str, "failure") != NULL) {
/* Authentication failure */
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_AUTH_FAILED,
_("Your password has been changed since you initially authenticated!"));
}
else if (strstr (str->str, "DIFFERENT")) {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_REJECTED,
_("The new password does not contain enough different characters"));
}
else {
error = g_error_new (PASSWD_ERROR, PASSWD_ERROR_UNKNOWN,
_("Unknown error"));
}
/* At this point, passwd might have exited, in which case
* child_watch_cb should clean up for us and remove this watcher.
* On some error conditions though, passwd just re-prompts us
* for our new password. */
passwd_handler->backend_state = PASSWD_STATE_ERR;
passwd_handler->changing_password = FALSE;
/* Trigger callback to update status */
if (passwd_handler->chpasswd_cb)
passwd_handler->chpasswd_cb (passwd_handler,
error,
passwd_handler->chpasswd_cb_data);
g_error_free (error);
}
reinit = TRUE;
/* child_watch_cb should clean up for us now */
}
break;
case PASSWD_STATE_NONE:
/* Passwd is not asking for anything yet */
if (is_string_complete (str->str, "assword: ", NULL)) {
/* If the user does not have a password set,
* passwd will immediately ask for the new password,
* so skip the AUTH phase */
if (is_string_complete (str->str, "new", "New", NULL)) {
gchar *pw;
passwd_handler->backend_state = PASSWD_STATE_NEW;
/* since passwd didn't ask for our old password
* in this case, simply remove it from the queue */
pw = g_queue_pop_head (passwd_handler->backend_stdin_queue);
g_free (pw);
/* Pop the IO queue, i.e. send new password */
io_queue_pop (passwd_handler->backend_stdin_queue, passwd_handler->backend_stdin);
} else {
passwd_handler->backend_state = PASSWD_STATE_AUTH;
/* Pop the IO queue, i.e. send current password */
io_queue_pop (passwd_handler->backend_stdin_queue, passwd_handler->backend_stdin);
}
reinit = TRUE;
}
break;
default:
/* Passwd has returned an error */
reinit = TRUE;
break;
}
if (reinit) {
g_string_free (str, TRUE);
str = NULL;
}
/* Continue calling us */
return TRUE;
}
DaemonConfigurationServerConfiguration* daemon_configuration_server_configuration_Parse (const gchar* input, GError** error) {
DaemonConfigurationServerConfiguration* result = NULL;
gchar** _tmp0_;
gchar** _tmp1_ = NULL;
gchar** parts;
gint parts_length1;
gint _parts_size_;
gboolean _tmp3_ = FALSE;
gint _tmp4_;
gchar** _tmp7_;
gchar** _tmp8_ = NULL;
gchar** channels;
gint channels_length1;
gint _channels_size_;
gchar* host = NULL;
guint16* port = NULL;
gchar* _tmp9_ = NULL;
guint16* _tmp10_ = NULL;
guint16* _tmp12_;
guint16* _tmp13_;
guint16* _tmp16_;
DaemonConfigurationServerConfiguration* _tmp17_ = NULL;
GError * _inner_error_ = NULL;
g_return_val_if_fail (input != NULL, NULL);
_tmp1_ = _tmp0_ = g_strsplit (input, "/", 0);
parts = _tmp1_;
parts_length1 = _vala_array_length (_tmp0_);
_parts_size_ = _vala_array_length (_tmp0_);
if (parts_length1 != 2) {
GError* _tmp2_ = NULL;
_tmp2_ = g_error_new_literal (DAEMON_CONFIGURATION_CONFIGURATION_ERROR, DAEMON_CONFIGURATION_CONFIGURATION_ERROR_Invalid, "Invalid format");
_inner_error_ = _tmp2_;
if (_inner_error_->domain == DAEMON_CONFIGURATION_CONFIGURATION_ERROR) {
g_propagate_error (error, _inner_error_);
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
return NULL;
} else {
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return NULL;
}
}
_tmp4_ = strlen (parts[0]);
if (_tmp4_ == 0) {
_tmp3_ = TRUE;
} else {
gint _tmp5_;
_tmp5_ = strlen (parts[1]);
_tmp3_ = _tmp5_ == 0;
}
if (_tmp3_) {
GError* _tmp6_ = NULL;
_tmp6_ = g_error_new_literal (DAEMON_CONFIGURATION_CONFIGURATION_ERROR, DAEMON_CONFIGURATION_CONFIGURATION_ERROR_Invalid, "Must specify both Server and Channel(s)");
_inner_error_ = _tmp6_;
if (_inner_error_->domain == DAEMON_CONFIGURATION_CONFIGURATION_ERROR) {
g_propagate_error (error, _inner_error_);
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
return NULL;
} else {
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return NULL;
}
}
_tmp8_ = _tmp7_ = g_strsplit (parts[1], ",", 0);
channels = _tmp8_;
channels_length1 = _vala_array_length (_tmp7_);
_channels_size_ = _vala_array_length (_tmp7_);
daemon_helpers_typehelper_ParseHostAndPort (parts[0], &_tmp9_, &_tmp10_, &_inner_error_);
_g_free0 (host);
host = _tmp9_;
_g_free0 (port);
port = _tmp10_;
if (_inner_error_ != NULL) {
if (_inner_error_->domain == DAEMON_HELPERS_DAEMON_ERROR) {
goto __catch27_daemon_helpers_daemon_error;
}
_g_free0 (port);
_g_free0 (host);
channels = (_vala_array_free (channels, channels_length1, (GDestroyNotify) g_free), NULL);
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return NULL;
}
goto __finally27;
__catch27_daemon_helpers_daemon_error:
{
GError * _error_;
GError* _tmp11_ = NULL;
_error_ = _inner_error_;
_inner_error_ = NULL;
_tmp11_ = g_error_new_literal (DAEMON_CONFIGURATION_CONFIGURATION_ERROR, DAEMON_CONFIGURATION_CONFIGURATION_ERROR_Invalid, _error_->message);
_inner_error_ = _tmp11_;
_g_error_free0 (_error_);
goto __finally27;
}
__finally27:
if (_inner_error_ != NULL) {
if (_inner_error_->domain == DAEMON_CONFIGURATION_CONFIGURATION_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (port);
_g_free0 (host);
channels = (_vala_array_free (channels, channels_length1, (GDestroyNotify) g_free), NULL);
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
return NULL;
} else {
_g_free0 (port);
_g_free0 (host);
channels = (_vala_array_free (channels, channels_length1, (GDestroyNotify) g_free), NULL);
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return NULL;
}
}
_tmp12_ = __uint16_dup0 (port);
_tmp13_ = _tmp12_;
if (_tmp13_ == NULL) {
gint _tmp14_;
guint16* _tmp15_;
_tmp14_ = 6667;
_tmp15_ = __uint16_dup0 (&_tmp14_);
_g_free0 (_tmp13_);
_tmp13_ = _tmp15_;
}
_tmp16_ = __uint16_dup0 (_tmp13_);
_g_free0 (port);
port = _tmp16_;
_tmp17_ = daemon_configuration_server_configuration_new (host, *port, channels, channels_length1);
result = _tmp17_;
_g_free0 (_tmp13_);
_g_free0 (port);
_g_free0 (host);
channels = (_vala_array_free (channels, channels_length1, (GDestroyNotify) g_free), NULL);
parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
return result;
}
static GthImage *
flickr_thumbnail_loader (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean *loaded_original,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image = NULL;
GthThumbLoader *thumb_loader = user_data;
FlickrPhoto *photo;
const char *uri = NULL;
photo = (FlickrPhoto *) g_file_info_get_attribute_object (file_data->info, "flickr::object");
requested_size = gth_thumb_loader_get_requested_size (thumb_loader);
if (requested_size == FLICKR_SIZE_SMALL_SQUARE)
uri = photo->url[FLICKR_URL_SQ];
else if (requested_size == FLICKR_SIZE_THUMBNAIL)
uri = photo->url[FLICKR_URL_T];
else if (requested_size == FLICKR_SIZE_SMALL)
uri = photo->url[FLICKR_URL_S];
else if (requested_size == FLICKR_SIZE_MEDIUM)
uri = photo->url[FLICKR_URL_M];
if (uri == NULL)
uri = photo->url[FLICKR_URL_O];
if (uri != NULL) {
GFile *file;
void *buffer;
gsize size;
file = g_file_new_for_uri (uri);
if (_g_file_load_in_buffer (file, &buffer, &size, cancellable, error)) {
GInputStream *stream;
GdkPixbuf *pixbuf;
stream = g_memory_input_stream_new_from_data (buffer, size, g_free);
pixbuf = gdk_pixbuf_new_from_stream (stream, cancellable, error);
if (pixbuf != NULL) {
GdkPixbuf *rotated;
rotated = gdk_pixbuf_apply_embedded_orientation (pixbuf);
g_object_unref (pixbuf);
pixbuf = rotated;
image = gth_image_new_for_pixbuf (pixbuf);
}
g_object_unref (pixbuf);
g_object_unref (stream);
}
g_object_unref (file);
}
else
*error = g_error_new_literal (GTH_ERROR, 0, "cannot generate the thumbnail");
return image;
}
static void
keyring_find_secrets_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
Request *r = user_data;
GError *error = NULL;
GError *search_error = NULL;
const char *connection_id = NULL;
GHashTable *secrets = NULL, *settings = NULL;
GList *list = NULL;
GList *iter;
gboolean hint_found = FALSE, ask = FALSE;
r->keyring_calls--;
if (g_cancellable_is_cancelled (r->cancellable)) {
/* Callback already called by NM or dispose */
request_free (r);
return;
}
list = secret_service_search_finish (NULL, result, &search_error);
connection_id = nm_connection_get_id (r->connection);
if (g_error_matches (search_error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
error = g_error_new_literal (NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_USER_CANCELED,
"The secrets request was canceled by the user");
g_error_free (search_error);
goto done;
} else if (search_error) {
error = g_error_new (NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_INTERNAL_ERROR,
"%s.%d - failed to read secrets from keyring (%s)",
__FILE__, __LINE__, search_error->message);
g_error_free (search_error);
goto done;
}
/* Only ask if we're allowed to, so that eg a connection editor which
* requests secrets for its UI, for a connection which doesn't have any
* secrets yet, doesn't trigger the applet secrets dialog.
*/
if ( (r->flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION)
&& g_list_length (list) == 0) {
g_message ("No keyring secrets found for %s/%s; asking user.", connection_id, r->setting_name);
ask_for_secrets (r);
return;
}
secrets = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, destroy_gvalue);
/* Extract the secrets from the list of matching keyring items */
for (iter = list; iter != NULL; iter = g_list_next (iter)) {
SecretItem *item = iter->data;
SecretValue *secret;
const char *key_name;
GHashTable *attributes;
secret = secret_item_get_secret (item);
if (secret) {
attributes = secret_item_get_attributes (item);
key_name = g_hash_table_lookup (attributes, KEYRING_SK_TAG);
if (!key_name) {
g_hash_table_unref (attributes);
secret_value_unref (secret);
continue;
}
g_hash_table_insert (secrets, g_strdup (key_name),
string_to_gvalue (secret_value_get (secret, NULL)));
/* See if this property matches a given hint */
if (r->hints && r->hints[0]) {
if (!g_strcmp0 (r->hints[0], key_name) || !g_strcmp0 (r->hints[1], key_name))
hint_found = TRUE;
}
g_hash_table_unref (attributes);
secret_value_unref (secret);
break;
}
}
/* If there were hints, and none of the hints were returned by the keyring,
* get some new secrets.
*/
if (r->flags) {
if (r->hints && r->hints[0] && !hint_found)
ask = TRUE;
else if (r->flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW) {
g_message ("New secrets for %s/%s requested; ask the user", connection_id, r->setting_name);
ask = TRUE;
} else if ( (r->flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ALLOW_INTERACTION)
&& is_connection_always_ask (r->connection))
ask = TRUE;
}
/* Returned secrets are a{sa{sv}}; this is the outer a{s...} hash that
* will contain all the individual settings hashes.
*/
settings = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_hash_table_destroy);
g_hash_table_insert (settings, g_strdup (r->setting_name), secrets);
done:
g_list_free_full (list, g_object_unref);
if (ask) {
GHashTableIter hash_iter;
const char *setting_name;
GHashTable *setting_hash;
/* Stuff all the found secrets into the connection for the UI to use */
g_hash_table_iter_init (&hash_iter, settings);
while (g_hash_table_iter_next (&hash_iter,
(gpointer *) &setting_name,
(gpointer *) &setting_hash)) {
nm_connection_update_secrets (r->connection,
setting_name,
setting_hash,
NULL);
}
ask_for_secrets (r);
} else {
/* Otherwise send the secrets back to NetworkManager */
r->get_callback (NM_SECRET_AGENT (r->agent), r->connection, error ? NULL : settings, error, r->callback_data);
request_free (r);
}
if (settings)
g_hash_table_destroy (settings);
g_clear_error (&error);
}
void
dlg_export_to_picasaweb (GthBrowser *browser,
GList *file_list)
{
DialogData *data;
GtkTreeSelection *selection;
GList *scan;
int n_total;
goffset total_size;
char *total_size_formatted;
char *text;
data = g_new0 (DialogData, 1);
data->browser = browser;
data->settings = g_settings_new (GTHUMB_PICASAWEB_SCHEMA);
data->location = gth_file_data_dup (gth_browser_get_location_data (browser));
data->builder = _gtk_builder_new_from_file ("export-to-picasaweb.ui", "picasaweb");
data->dialog = _gtk_builder_get_widget (data->builder, "export_dialog");
data->cancellable = g_cancellable_new ();
{
GtkCellLayout *cell_layout;
GtkCellRenderer *renderer;
cell_layout = GTK_CELL_LAYOUT (GET_WIDGET ("name_treeviewcolumn"));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, FALSE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"icon-name", ALBUM_ICON_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, TRUE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"text", ALBUM_NAME_COLUMN,
NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (cell_layout, renderer, FALSE);
gtk_cell_layout_set_attributes (cell_layout, renderer,
"icon-name", ALBUM_EMBLEM_COLUMN,
NULL);
}
_gtk_window_resize_to_fit_screen_height (data->dialog, 500);
data->file_list = NULL;
n_total = 0;
total_size = 0;
for (scan = file_list; scan; scan = scan->next) {
GthFileData *file_data = scan->data;
const char *mime_type;
mime_type = gth_file_data_get_mime_type (file_data);
if (g_content_type_equals (mime_type, "image/bmp")
|| g_content_type_equals (mime_type, "image/gif")
|| g_content_type_equals (mime_type, "image/jpeg")
|| g_content_type_equals (mime_type, "image/png"))
{
total_size += g_file_info_get_size (file_data->info);
n_total++;
data->file_list = g_list_prepend (data->file_list, g_object_ref (file_data));
}
}
data->file_list = g_list_reverse (data->file_list);
if (data->file_list == NULL) {
GError *error;
gth_task_dialog (GTH_TASK (data->service), TRUE, NULL);
error = g_error_new_literal (GTH_ERROR, GTH_ERROR_GENERIC, _("No valid file selected."));
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (browser), _("Could not export the files"), error);
g_clear_error (&error);
destroy_dialog (data);
return;
}
total_size_formatted = g_format_size (total_size);
text = g_strdup_printf (g_dngettext (NULL, "%d file (%s)", "%d files (%s)", n_total), n_total, total_size_formatted);
gtk_label_set_text (GTK_LABEL (GET_WIDGET ("images_info_label")), text);
g_free (text);
g_free (total_size_formatted);
/* Set the widget data */
data->list_view = gth_file_list_new (gth_grid_view_new (), GTH_FILE_LIST_MODE_NO_SELECTION, FALSE);
gth_file_list_set_thumb_size (GTH_FILE_LIST (data->list_view), 112);
gth_file_list_enable_thumbs (GTH_FILE_LIST (data->list_view), TRUE);
gth_file_list_set_ignore_hidden (GTH_FILE_LIST (data->list_view), TRUE);
gth_file_list_set_caption (GTH_FILE_LIST (data->list_view), "none");
gth_file_list_set_sort_func (GTH_FILE_LIST (data->list_view), gth_main_get_sort_type ("file::name")->cmp_func, FALSE);
gtk_widget_show (data->list_view);
gtk_box_pack_start (GTK_BOX (GET_WIDGET ("images_box")), data->list_view, TRUE, TRUE, 0);
gth_file_list_set_files (GTH_FILE_LIST (data->list_view), data->file_list);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("album_liststore")), ALBUM_NAME_COLUMN, GTK_SORT_ASCENDING);
gtk_widget_set_sensitive (GET_WIDGET ("upload_button"), FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("resize_checkbutton")),
g_settings_get_int (data->settings, PREF_PICASAWEB_RESIZE_WIDTH) != -1);
_gtk_combo_box_add_image_sizes (GTK_COMBO_BOX (GET_WIDGET ("resize_combobox")),
g_settings_get_int (data->settings, PREF_PICASAWEB_RESIZE_WIDTH),
g_settings_get_int (data->settings, PREF_PICASAWEB_RESIZE_HEIGHT));
/* Set the signals handlers. */
g_signal_connect (data->dialog,
"delete-event",
G_CALLBACK (gtk_true),
NULL);
g_signal_connect (data->dialog,
"response",
G_CALLBACK (export_dialog_response_cb),
data);
g_signal_connect (GET_WIDGET ("add_album_button"),
"clicked",
G_CALLBACK (add_album_button_clicked_cb),
data);
g_signal_connect (GET_WIDGET ("edit_accounts_button"),
"clicked",
G_CALLBACK (edit_accounts_button_clicked_cb),
data);
g_signal_connect (GET_WIDGET ("account_combobox"),
"changed",
G_CALLBACK (account_combobox_changed_cb),
data);
g_signal_connect (GET_WIDGET ("resize_checkbutton"),
"toggled",
G_CALLBACK (resize_checkbutton_toggled_cb),
data);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (GET_WIDGET ("albums_treeview")));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection,
"changed",
G_CALLBACK (albums_treeview_selection_changed_cb),
data);
update_sensitivity (data);
data->service = picasa_web_service_new (data->cancellable,
GTK_WIDGET (data->browser),
data->dialog);
g_signal_connect (data->service,
"account-ready",
G_CALLBACK (service_account_ready_cb),
data);
g_signal_connect (data->service,
"accounts-changed",
G_CALLBACK (service_accounts_changed_cb),
data);
data->progress_dialog = gth_progress_dialog_new (GTK_WINDOW (data->browser));
gth_progress_dialog_add_task (GTH_PROGRESS_DIALOG (data->progress_dialog), GTH_TASK (data->service));
web_service_autoconnect (WEB_SERVICE (data->service));
}
static void
get_secrets (NMSecretAgent *agent,
NMConnection *connection,
const char *connection_path,
const char *setting_name,
const char **hints,
guint32 flags,
NMSecretAgentGetSecretsFunc callback,
gpointer callback_data)
{
AppletAgentPrivate *priv = APPLET_AGENT_GET_PRIVATE (agent);
Request *r;
GError *error = NULL;
NMSettingConnection *s_con;
NMSetting *setting;
const char *uuid, *ctype;
GHashTable *attrs;
setting = nm_connection_get_setting_by_name (connection, setting_name);
if (!setting) {
error = g_error_new (NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_INVALID_CONNECTION,
"%s.%d - Connection didn't have requested setting '%s'.",
__FILE__, __LINE__, setting_name);
callback (agent, connection, NULL, error, callback_data);
g_error_free (error);
return;
}
uuid = nm_connection_get_uuid (connection);
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
ctype = nm_setting_connection_get_connection_type (s_con);
if (!uuid || !ctype) {
error = g_error_new (NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_INVALID_CONNECTION,
"%s.%d - Connection didn't have required UUID.",
__FILE__, __LINE__);
callback (agent, connection, NULL, error, callback_data);
g_error_free (error);
return;
}
/* Track the secrets request */
r = request_new (agent, connection, connection_path, setting_name, hints, flags, callback, NULL, NULL, callback_data);
g_hash_table_insert (priv->requests, GUINT_TO_POINTER (r->id), r);
/* VPN passwords are handled by the VPN plugin's auth dialog */
if (!strcmp (ctype, NM_SETTING_VPN_SETTING_NAME)) {
ask_for_secrets (r);
return;
}
/* Only handle non-VPN secrets if we're supposed to */
if (priv->vpn_only == TRUE) {
error = g_error_new_literal (NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_NO_SECRETS,
"Only handling VPN secrets at this time.");
callback (agent, connection, NULL, error, callback_data);
g_error_free (error);
return;
}
/* For everything else we scrape the keyring for secrets first, and ask
* later if required.
*/
attrs = secret_attributes_build (&network_manager_secret_schema,
KEYRING_UUID_TAG, uuid,
KEYRING_SN_TAG, setting_name,
NULL);
secret_service_search (NULL, &network_manager_secret_schema, attrs,
SECRET_SEARCH_ALL | SECRET_SEARCH_UNLOCK | SECRET_SEARCH_LOAD_SECRETS,
r->cancellable, keyring_find_secrets_cb, r);
r->keyring_calls++;
g_hash_table_unref (attrs);
}
static void
korva_upnp_file_server_on_metadata_query_run_done (GObject *sender,
GAsyncResult *res,
gpointer user_data)
{
QueryMetaData *data = (QueryMetaData *) user_data;
GSimpleAsyncResult *result = data->result;
HostFileResult *result_data;
guint port;
GError *error = NULL;
if (!korva_upnp_metadata_query_run_finish (KORVA_UPNP_METADATA_QUERY (sender),
res,
&error)) {
if (error->domain != KORVA_CONTROLLER1_ERROR) {
int code;
code = error->code;
g_error_free (error);
error = NULL;
if (code == G_IO_ERROR_NOT_FOUND) {
error = g_error_new_literal (KORVA_CONTROLLER1_ERROR,
KORVA_CONTROLLER1_ERROR_FILE_NOT_FOUND,
"File not found");
} else {
error = g_error_new_literal (KORVA_CONTROLLER1_ERROR,
KORVA_CONTROLLER1_ERROR_NOT_ACCESSIBLE,
"File not accessible");
}
}
g_simple_async_result_take_error (data->result, error);
g_object_unref (data->data);
goto out;
}
g_signal_connect_swapped (data->data,
"timeout",
G_CALLBACK (korva_upnp_file_server_on_host_data_timeout),
data->self);
g_hash_table_insert (data->self->priv->host_data,
korva_upnp_host_data_get_file (data->data),
data->data);
g_hash_table_insert (data->self->priv->id_map,
korva_upnp_host_data_get_id (data->data),
korva_upnp_host_data_get_file (data->data));
port = soup_server_get_port (data->self->priv->http_server);
result_data = g_new0 (HostFileResult, 1);
result_data->params = korva_upnp_host_data_get_meta_data (data->data);
result_data->uri = korva_upnp_host_data_get_uri (data->data, data->iface, port);
g_simple_async_result_set_op_res_gpointer (result, result_data, g_free);
data->result = NULL;
out:
g_free (data->iface);
data->iface = NULL;
g_simple_async_result_complete_in_idle (result);
g_object_unref (result);
g_object_unref (sender);
g_slice_free (QueryMetaData, data);
}
int
main (int argc,
char **argv)
{
GCancellable *cancellable = g_cancellable_new ();
RpmOstreeCommand *command;
int exit_status = EXIT_SUCCESS;
int in, out;
const char *command_name = NULL;
g_autofree char *prgname = NULL;
GError *local_error = NULL;
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
g_setenv ("GIO_USE_VFS", "local", TRUE);
g_set_prgname (argv[0]);
setlocale (LC_ALL, "");
/*
* Parse the global options. We rearrange the options as
* necessary, in order to pass relevant options through
* to the commands, but also have them take effect globally.
*/
for (in = 1, out = 1; in < argc; in++, out++)
{
/* The non-option is the command, take it out of the arguments */
if (argv[in][0] != '-')
{
if (command_name == NULL)
{
command_name = argv[in];
out--;
continue;
}
}
else if (g_str_equal (argv[in], "--"))
{
break;
}
argv[out] = argv[in];
}
argc = out;
g_unix_signal_add (SIGINT, on_sigint, cancellable);
g_unix_signal_add (SIGTERM, on_sigint, cancellable);
g_unix_signal_add (SIGHUP, on_sigint, cancellable);
/* Keep the "rpm" command working for backward-compatibility. */
if (g_strcmp0 (command_name, "rpm") == 0)
command_name = "db";
command = lookup_command_of_type (supported_commands, command_name, NULL);
if (!command)
command = lookup_command_of_type (legacy_alias_commands, command_name, NULL);
if (!command)
command = lookup_command_of_type (preview_commands, command_name, "a preview");
if (!command)
command = lookup_command_of_type (experimental_commands, command_name, "an experimental");
if (!command)
{
g_autoptr(GOptionContext) context = option_context_new_with_commands ();
g_autofree char *help = NULL;
/* This will not return for some options (e.g. --version). */
(void) rpmostree_option_context_parse (context, NULL, &argc, &argv,
RPM_OSTREE_BUILTIN_FLAG_LOCAL_CMD,
NULL, NULL, NULL);
if (command_name == NULL)
{
local_error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED,
"No command specified");
}
else
{
local_error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
"Unknown command '%s'", command_name);
}
help = g_option_context_get_help (context, FALSE, NULL);
g_printerr ("%s", help);
exit_status = EXIT_FAILURE;
goto out;
}
prgname = g_strdup_printf ("%s %s", g_get_prgname (), command_name);
g_set_prgname (prgname);
exit_status = command->fn (argc, argv, cancellable, &local_error);
out:
if (local_error != NULL)
{
int is_tty = isatty (1);
const char *prefix = "";
const char *suffix = "";
if (is_tty)
{
prefix = "\x1b[31m\x1b[1m"; /* red, bold */
suffix = "\x1b[22m\x1b[0m"; /* bold off, color reset */
}
g_dbus_error_strip_remote_error (local_error);
g_printerr ("%serror: %s%s\n", prefix, suffix, local_error->message);
g_error_free (local_error);
/* Print a warning if the exit status indicates success when we
* actually had an error, so it gets reported and fixed quickly. */
g_warn_if_fail (exit_status != EXIT_SUCCESS);
}
return exit_status;
}
FlowShunt *
flow_ssh_master_run_command (FlowSshMaster *ssh_master, const gchar *remote_command, GError **error)
{
FlowSshMasterPrivate *priv;
gchar *remote_name = NULL;
gint remote_port;
gchar *cmd = NULL;
FlowShunt *shunt = NULL;
g_return_val_if_fail (FLOW_IS_SSH_MASTER (ssh_master), NULL);
priv = ssh_master->priv;
g_mutex_lock (priv->mutex);
if (!priv->is_connected)
{
GError *my_error = g_error_new_literal (FLOW_SSH_DOMAIN_QUARK, FLOW_SSH_MASTER_NOT_CONNECTED,
"SSH master is not connected");
g_propagate_error (error, my_error);
goto out;
}
remote_port = flow_ip_service_get_port (priv->remote_ip_service);
remote_name = flow_ip_service_get_name (priv->remote_ip_service);
g_assert (remote_name != NULL);
if (is_master_supported (ssh_master))
{
if (remote_port > 0)
{
cmd = g_strdup_printf ("ssh " EXTRA_SSH_OP_OPTIONS " -o 'ControlPath %s' -p %d %s%s%s %s",
priv->control_path,
remote_port,
priv->remote_user ? priv->remote_user : "",
priv->remote_user ? "@" : "",
remote_name,
remote_command);
}
else
{
cmd = g_strdup_printf ("ssh " EXTRA_SSH_OP_OPTIONS " -o 'ControlPath %s' %s%s%s %s",
priv->control_path,
priv->remote_user ? priv->remote_user : "",
priv->remote_user ? "@" : "",
remote_name,
remote_command);
}
}
else
{
if (remote_port > 0)
cmd = g_strdup_printf ("ssh " EXTRA_SSH_OP_OPTIONS " -p %d %s%s%s %s",
remote_port,
priv->remote_user ? priv->remote_user : "",
priv->remote_user ? "@" : "",
remote_name,
remote_command);
else
cmd = g_strdup_printf ("ssh " EXTRA_SSH_OP_OPTIONS " %s%s%s %s",
priv->remote_user ? priv->remote_user : "",
priv->remote_user ? "@" : "",
remote_name,
remote_command);
}
shunt = flow_spawn_command_line (cmd);
out:
g_mutex_unlock (priv->mutex);
g_free (cmd);
g_free (remote_name);
return shunt;
}
static void set_file_error(GQuark domain, gint code, gchar *message) {
if (file_error)
g_clear_error(&file_error);
g_propagate_error(&file_error, g_error_new_literal(domain, code, message));
}
GimpValueArray *
gimp_pdb_execute_procedure_by_name (GimpPDB *pdb,
GimpContext *context,
GimpProgress *progress,
GError **error,
const gchar *name,
...)
{
GimpProcedure *procedure;
GimpValueArray *args;
GimpValueArray *return_vals;
va_list va_args;
gint i;
g_return_val_if_fail (GIMP_IS_PDB (pdb), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
g_return_val_if_fail (name != NULL, NULL);
procedure = gimp_pdb_lookup_procedure (pdb, name);
if (! procedure)
{
GError *pdb_error = g_error_new (GIMP_PDB_ERROR,
GIMP_PDB_ERROR_PROCEDURE_NOT_FOUND,
_("Procedure '%s' not found"), name);
return_vals = gimp_procedure_get_return_values (NULL, FALSE, pdb_error);
g_propagate_error (error, pdb_error);
return return_vals;
}
args = gimp_procedure_get_arguments (procedure);
va_start (va_args, name);
for (i = 0; i < procedure->num_args; i++)
{
GValue *value;
GType arg_type;
gchar *error_msg = NULL;
arg_type = va_arg (va_args, GType);
if (arg_type == G_TYPE_NONE)
break;
value = gimp_value_array_index (args, i);
if (arg_type != G_VALUE_TYPE (value))
{
GError *pdb_error;
const gchar *expected = g_type_name (G_VALUE_TYPE (value));
const gchar *got = g_type_name (arg_type);
gimp_value_array_unref (args);
pdb_error = g_error_new (GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Procedure '%s' has been called with a "
"wrong type for argument #%d. "
"Expected %s, got %s."),
gimp_object_get_name (procedure),
i + 1, expected, got);
return_vals = gimp_procedure_get_return_values (procedure,
FALSE, pdb_error);
g_propagate_error (error, pdb_error);
va_end (va_args);
return return_vals;
}
G_VALUE_COLLECT (value, va_args, G_VALUE_NOCOPY_CONTENTS, &error_msg);
if (error_msg)
{
GError *pdb_error = g_error_new_literal (GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INTERNAL_ERROR,
error_msg);
g_warning ("%s: %s", G_STRFUNC, error_msg);
g_free (error_msg);
gimp_value_array_unref (args);
return_vals = gimp_procedure_get_return_values (procedure,
FALSE, pdb_error);
g_propagate_error (error, pdb_error);
va_end (va_args);
return return_vals;
}
}
va_end (va_args);
return_vals = gimp_pdb_execute_procedure_by_name_args (pdb, context,
progress, error,
name, args);
gimp_value_array_unref (args);
return return_vals;
}
static void skk_map_file_load (SkkMapFile* self, const gchar* rule, const gchar* type, const gchar* name, GeeSet* included, GError** error) {
const gchar* _tmp0_;
SkkRuleMetadata* _tmp1_ = NULL;
SkkRuleMetadata* metadata;
SkkRuleMetadata* _tmp2_;
SkkRuleMetadata* _tmp5_;
const gchar* _tmp6_;
const gchar* _tmp7_;
const gchar* _tmp8_;
gchar* _tmp9_;
gchar* _tmp10_;
gchar* _tmp11_ = NULL;
gchar* _tmp12_;
gchar* filename;
const gchar* _tmp13_;
gboolean _tmp14_ = FALSE;
JsonParser* _tmp17_;
JsonParser* parser;
JsonParser* _tmp30_;
JsonNode* _tmp31_ = NULL;
JsonNode* _tmp32_;
JsonNode* root;
JsonNode* _tmp33_;
JsonNodeType _tmp34_ = 0;
JsonNode* _tmp36_;
JsonObject* _tmp37_ = NULL;
JsonObject* _tmp38_;
JsonObject* object;
JsonNode* member = NULL;
JsonObject* _tmp39_;
gboolean _tmp40_ = FALSE;
JsonObject* _tmp83_;
gboolean _tmp84_ = FALSE;
GError * _inner_error_ = NULL;
g_return_if_fail (self != NULL);
g_return_if_fail (rule != NULL);
g_return_if_fail (type != NULL);
g_return_if_fail (name != NULL);
g_return_if_fail (included != NULL);
_tmp0_ = rule;
_tmp1_ = skk_rule_find_rule (_tmp0_);
metadata = _tmp1_;
_tmp2_ = metadata;
if (_tmp2_ == NULL) {
const gchar* _tmp3_;
GError* _tmp4_;
_tmp3_ = rule;
_tmp4_ = g_error_new (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "can't find rule %s", _tmp3_);
_inner_error_ = _tmp4_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp5_ = metadata;
_tmp6_ = (*_tmp5_).base_dir;
_tmp7_ = type;
_tmp8_ = name;
_tmp9_ = g_strconcat (_tmp8_, ".json", NULL);
_tmp10_ = _tmp9_;
_tmp11_ = g_build_filename (_tmp6_, _tmp7_, _tmp10_, NULL);
_tmp12_ = _tmp11_;
_g_free0 (_tmp10_);
filename = _tmp12_;
_tmp13_ = filename;
_tmp14_ = g_file_test (_tmp13_, G_FILE_TEST_EXISTS);
if (!_tmp14_) {
const gchar* _tmp15_;
GError* _tmp16_;
_tmp15_ = filename;
_tmp16_ = g_error_new (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "no such file %s", _tmp15_);
_inner_error_ = _tmp16_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp17_ = json_parser_new ();
parser = _tmp17_;
{
JsonParser* _tmp18_;
const gchar* _tmp19_;
gboolean _tmp20_ = FALSE;
gboolean _tmp21_;
_tmp18_ = parser;
_tmp19_ = filename;
_tmp20_ = json_parser_load_from_file (_tmp18_, _tmp19_, &_inner_error_);
_tmp21_ = _tmp20_;
if (_inner_error_ != NULL) {
goto __catch28_g_error;
}
if (!_tmp21_) {
GError* _tmp22_;
_tmp22_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "");
_inner_error_ = _tmp22_;
goto __catch28_g_error;
}
}
goto __finally28;
__catch28_g_error:
{
GError* e = NULL;
const gchar* _tmp23_;
GError* _tmp24_;
const gchar* _tmp25_;
gchar* _tmp26_ = NULL;
gchar* _tmp27_;
GError* _tmp28_;
GError* _tmp29_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp23_ = filename;
_tmp24_ = e;
_tmp25_ = _tmp24_->message;
_tmp26_ = g_strdup_printf ("can't load %s: %s", _tmp23_, _tmp25_);
_tmp27_ = _tmp26_;
_tmp28_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, _tmp27_);
_tmp29_ = _tmp28_;
_g_free0 (_tmp27_);
_inner_error_ = _tmp29_;
_g_error_free0 (e);
goto __finally28;
}
__finally28:
if (_inner_error_ != NULL) {
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp30_ = parser;
_tmp31_ = json_parser_get_root (_tmp30_);
_tmp32_ = __vala_JsonNode_copy0 (_tmp31_);
root = _tmp32_;
_tmp33_ = root;
_tmp34_ = json_node_get_node_type (_tmp33_);
if (_tmp34_ != JSON_NODE_OBJECT) {
GError* _tmp35_;
_tmp35_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "root element must be an object");
_inner_error_ = _tmp35_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp36_ = root;
_tmp37_ = json_node_get_object (_tmp36_);
_tmp38_ = __vala_JsonObject_copy0 (_tmp37_);
object = _tmp38_;
_tmp39_ = object;
_tmp40_ = json_object_has_member (_tmp39_, "include");
if (_tmp40_) {
JsonObject* _tmp41_;
JsonNode* _tmp42_ = NULL;
JsonNode* _tmp43_;
JsonNode* _tmp44_;
JsonNodeType _tmp45_ = 0;
JsonNode* _tmp47_;
JsonArray* _tmp48_ = NULL;
JsonArray* _tmp49_;
JsonArray* include;
JsonArray* _tmp50_;
GList* _tmp51_ = NULL;
GList* elements;
GList* _tmp52_;
_tmp41_ = object;
_tmp42_ = json_object_get_member (_tmp41_, "include");
_tmp43_ = __vala_JsonNode_copy0 (_tmp42_);
__vala_JsonNode_free0 (member);
member = _tmp43_;
_tmp44_ = member;
_tmp45_ = json_node_get_node_type (_tmp44_);
if (_tmp45_ != JSON_NODE_ARRAY) {
GError* _tmp46_;
_tmp46_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "\"include\" element must be an array");
_inner_error_ = _tmp46_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp47_ = member;
_tmp48_ = json_node_get_array (_tmp47_);
_tmp49_ = __vala_JsonArray_copy0 (_tmp48_);
include = _tmp49_;
_tmp50_ = include;
_tmp51_ = json_array_get_elements (_tmp50_);
elements = _tmp51_;
_tmp52_ = elements;
{
GList* element_collection = NULL;
GList* element_it = NULL;
element_collection = _tmp52_;
for (element_it = element_collection; element_it != NULL; element_it = element_it->next) {
JsonNode* element = NULL;
element = (JsonNode*) element_it->data;
{
JsonNode* _tmp53_;
const gchar* _tmp54_ = NULL;
gchar* _tmp55_;
gchar* parent;
GeeSet* _tmp56_;
const gchar* _tmp57_;
gboolean _tmp58_ = FALSE;
const gchar* _tmp61_;
gint _tmp62_ = 0;
gint index;
gint _tmp63_;
GeeSet* _tmp81_;
const gchar* _tmp82_;
_tmp53_ = element;
_tmp54_ = json_node_get_string (_tmp53_);
_tmp55_ = g_strdup (_tmp54_);
parent = _tmp55_;
_tmp56_ = included;
_tmp57_ = parent;
_tmp58_ = gee_collection_contains ((GeeCollection*) _tmp56_, _tmp57_);
if (_tmp58_) {
const gchar* _tmp59_;
GError* _tmp60_;
_tmp59_ = parent;
_tmp60_ = g_error_new (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "found circular include of %s", _tmp59_);
_inner_error_ = _tmp60_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp61_ = parent;
_tmp62_ = string_index_of (_tmp61_, "/", 0);
index = _tmp62_;
_tmp63_ = index;
if (_tmp63_ < 0) {
const gchar* _tmp64_;
const gchar* _tmp65_;
const gchar* _tmp66_;
GeeSet* _tmp67_;
_tmp64_ = rule;
_tmp65_ = type;
_tmp66_ = parent;
_tmp67_ = included;
skk_map_file_load (self, _tmp64_, _tmp65_, _tmp66_, _tmp67_, &_inner_error_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
} else {
const gchar* _tmp68_;
gint _tmp69_;
gchar* _tmp70_ = NULL;
gchar* _tmp71_;
const gchar* _tmp72_;
const gchar* _tmp73_;
gint _tmp74_;
const gchar* _tmp75_;
gint _tmp76_;
gint _tmp77_;
gchar* _tmp78_ = NULL;
gchar* _tmp79_;
GeeSet* _tmp80_;
_tmp68_ = parent;
_tmp69_ = index;
_tmp70_ = string_slice (_tmp68_, (glong) 0, (glong) _tmp69_);
_tmp71_ = _tmp70_;
_tmp72_ = type;
_tmp73_ = parent;
_tmp74_ = index;
_tmp75_ = parent;
_tmp76_ = strlen (_tmp75_);
_tmp77_ = _tmp76_;
_tmp78_ = string_slice (_tmp73_, (glong) (_tmp74_ + 1), (glong) _tmp77_);
_tmp79_ = _tmp78_;
_tmp80_ = included;
skk_map_file_load (self, _tmp71_, _tmp72_, _tmp79_, _tmp80_, &_inner_error_);
_g_free0 (_tmp79_);
_g_free0 (_tmp71_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_free0 (parent);
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
}
_tmp81_ = included;
_tmp82_ = parent;
gee_collection_add ((GeeCollection*) _tmp81_, _tmp82_);
_g_free0 (parent);
}
}
}
_g_list_free0 (elements);
__vala_JsonArray_free0 (include);
}
_tmp83_ = object;
_tmp84_ = json_object_has_member (_tmp83_, "define");
if (_tmp84_) {
JsonObject* _tmp85_;
JsonNode* _tmp86_ = NULL;
JsonNode* _tmp87_;
JsonNode* _tmp88_;
JsonNodeType _tmp89_ = 0;
JsonNode* _tmp91_;
JsonObject* _tmp92_ = NULL;
JsonObject* _tmp93_;
JsonObject* define;
JsonObject* _tmp94_;
GList* _tmp95_ = NULL;
GList* keys;
GList* _tmp96_;
_tmp85_ = object;
_tmp86_ = json_object_get_member (_tmp85_, "define");
_tmp87_ = __vala_JsonNode_copy0 (_tmp86_);
__vala_JsonNode_free0 (member);
member = _tmp87_;
_tmp88_ = member;
_tmp89_ = json_node_get_node_type (_tmp88_);
if (_tmp89_ != JSON_NODE_OBJECT) {
GError* _tmp90_;
_tmp90_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "\"define\" element must be an object");
_inner_error_ = _tmp90_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp91_ = member;
_tmp92_ = json_node_get_object (_tmp91_);
_tmp93_ = __vala_JsonObject_copy0 (_tmp92_);
define = _tmp93_;
_tmp94_ = define;
_tmp95_ = json_object_get_members (_tmp94_);
keys = _tmp95_;
_tmp96_ = keys;
{
GList* key_collection = NULL;
GList* key_it = NULL;
key_collection = _tmp96_;
for (key_it = key_collection; key_it != NULL; key_it = key_it->next) {
const gchar* key = NULL;
key = (const gchar*) key_it->data;
{
GeeMap* _tmp97_;
const gchar* _tmp98_;
gboolean _tmp99_ = FALSE;
JsonObject* _tmp104_;
const gchar* _tmp105_;
JsonNode* _tmp106_ = NULL;
JsonNode* _tmp107_;
JsonNode* _tmp108_;
JsonNodeType _tmp109_ = 0;
GeeMap* _tmp111_;
const gchar* _tmp112_;
gpointer _tmp113_ = NULL;
GeeMap* _tmp114_;
JsonNode* _tmp115_;
JsonObject* _tmp116_ = NULL;
_tmp97_ = self->priv->maps;
_tmp98_ = key;
_tmp99_ = gee_map_has_key (_tmp97_, _tmp98_);
if (!_tmp99_) {
GeeHashMap* _tmp100_;
GeeHashMap* map;
GeeMap* _tmp101_;
const gchar* _tmp102_;
GeeHashMap* _tmp103_;
_tmp100_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, g_free, json_node_get_type (), (GBoxedCopyFunc) _vala_JsonNode_copy, _vala_JsonNode_free, NULL, NULL, NULL);
map = _tmp100_;
_tmp101_ = self->priv->maps;
_tmp102_ = key;
_tmp103_ = map;
gee_map_set (_tmp101_, _tmp102_, (GeeMap*) _tmp103_);
_g_object_unref0 (map);
}
_tmp104_ = define;
_tmp105_ = key;
_tmp106_ = json_object_get_member (_tmp104_, _tmp105_);
_tmp107_ = __vala_JsonNode_copy0 (_tmp106_);
__vala_JsonNode_free0 (member);
member = _tmp107_;
_tmp108_ = member;
_tmp109_ = json_node_get_node_type (_tmp108_);
if (_tmp109_ != JSON_NODE_OBJECT) {
GError* _tmp110_;
_tmp110_ = g_error_new_literal (SKK_RULE_PARSE_ERROR, SKK_RULE_PARSE_ERROR_FAILED, "map element must be an object");
_inner_error_ = _tmp110_;
if (_inner_error_->domain == SKK_RULE_PARSE_ERROR) {
g_propagate_error (error, _inner_error_);
_g_list_free0 (keys);
__vala_JsonObject_free0 (define);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
return;
} else {
_g_list_free0 (keys);
__vala_JsonObject_free0 (define);
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return;
}
}
_tmp111_ = self->priv->maps;
_tmp112_ = key;
_tmp113_ = gee_map_get (_tmp111_, _tmp112_);
_tmp114_ = (GeeMap*) _tmp113_;
_tmp115_ = member;
_tmp116_ = json_node_get_object (_tmp115_);
skk_map_file_load_map (self, _tmp114_, _tmp116_);
_g_object_unref0 (_tmp114_);
}
}
}
_g_list_free0 (keys);
__vala_JsonObject_free0 (define);
}
__vala_JsonNode_free0 (member);
__vala_JsonObject_free0 (object);
__vala_JsonNode_free0 (root);
_g_object_unref0 (parser);
_g_free0 (filename);
_skk_rule_metadata_free0 (metadata);
}
static void
set_error_from_string (const char *string, GError **error)
{
if (error)
*error = g_error_new_literal (get_ephy_sqlite_quark (), 0, string);
}
static RejillaBurnResult
rejilla_mkisofs_read_stderr (RejillaProcess *process, const gchar *line)
{
gchar fraction_str [7] = { 0, };
RejillaMkisofs *mkisofs;
RejillaMkisofsPrivate *priv;
mkisofs = REJILLA_MKISOFS (process);
priv = REJILLA_MKISOFS_PRIVATE (process);
if (strstr (line, "estimate finish")
&& sscanf (line, "%6c%% done, estimate finish", fraction_str) == 1) {
gdouble fraction;
fraction = g_strtod (fraction_str, NULL) / (gdouble) 100.0;
rejilla_job_set_progress (REJILLA_JOB (mkisofs), fraction);
rejilla_job_start_progress (REJILLA_JOB (process), FALSE);
}
else if (strstr (line, "Input/output error. Read error on old image")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_IMAGE_LAST_SESSION,
_("Last session import failed")));
}
else if (strstr (line, "Unable to sort directory")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_WRITE_IMAGE,
_("An image could not be created")));
}
else if (strstr (line, "have the same joliet name")
|| strstr (line, "Joliet tree sort failed.")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_IMAGE_JOLIET,
_("An image could not be created")));
}
else if (strstr (line, "Use mkisofs -help")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_GENERAL,
_("This version of mkisofs is not supported")));
}
/* else if ((pos = strstr (line,"mkisofs: Permission denied. "))) {
int res = FALSE;
gboolean isdir = FALSE;
char *path = NULL;
pos += strlen ("mkisofs: Permission denied. ");
if (!strncmp (pos, "Unable to open directory ", 24)) {
isdir = TRUE;
pos += strlen ("Unable to open directory ");
path = g_strdup (pos);
path[strlen (path) - 1] = 0;
}
else if (!strncmp (pos, "File ", 5)) {
char *end;
isdir = FALSE;
pos += strlen ("File ");
end = strstr (pos, " is not readable - ignoring");
if (end)
path = g_strndup (pos, end - pos);
}
else
return TRUE;
res = rejilla_mkisofs_base_ask_unreadable_file (REJILLA_GENISOIMAGE_BASE (process),
path,
isdir);
if (!res) {
g_free (path);
rejilla_job_progress_changed (REJILLA_JOB (process), 1.0, -1);
rejilla_job_cancel (REJILLA_JOB (process), FALSE);
return FALSE;
}
}*/
else if (strstr (line, "Incorrectly encoded string")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_INPUT_INVALID,
_("Some files have invalid filenames")));
}
else if (strstr (line, "Unknown charset")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_INPUT_INVALID,
_("Unknown character encoding")));
}
else if (strstr (line, "No space left on device")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_DISK_SPACE,
_("There is no space left on the device")));
}
else if (strstr (line, "Unable to open disc image file")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_PERMISSION,
_("You do not have the required permission to write at this location")));
}
else if (strstr (line, "Value too large for defined data type")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_MEDIUM_SPACE,
_("Not enough space available on the disc")));
}
/** REMINDER: these should not be necessary
else if (strstr (line, "Resource temporarily unavailable")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_INPUT,
_("Data could not be written")));
}
else if (strstr (line, "Bad file descriptor.")) {
rejilla_job_error (REJILLA_JOB (process),
g_error_new_literal (REJILLA_BURN_ERROR,
REJILLA_BURN_ERROR_INPUT,
_("Internal error: bad file descriptor")));
}
**/
return REJILLA_BURN_OK;
}
static gpointer
brasero_dvdcss_write_image_thread (gpointer data)
{
guchar buf [DVDCSS_BLOCK_SIZE * BRASERO_DVDCSS_I_BLOCKS];
BraseroScrambledSectorRange *range = NULL;
BraseroMedium *medium = NULL;
BraseroVolFile *files = NULL;
dvdcss_handle *handle = NULL;
BraseroDrive *drive = NULL;
BraseroDvdcssPrivate *priv;
gint64 written_sectors = 0;
BraseroDvdcss *self = data;
BraseroTrack *track = NULL;
guint64 remaining_sectors;
FILE *output_fd = NULL;
BraseroVolSrc *vol;
gint64 volume_size;
GQueue *map = NULL;
brasero_job_set_use_average_rate (BRASERO_JOB (self), TRUE);
brasero_job_set_current_action (BRASERO_JOB (self),
BRASERO_BURN_ACTION_ANALYSING,
_("Retrieving DVD keys"),
FALSE);
brasero_job_start_progress (BRASERO_JOB (self), FALSE);
priv = BRASERO_DVDCSS_PRIVATE (self);
/* get the contents of the DVD */
brasero_job_get_current_track (BRASERO_JOB (self), &track);
drive = brasero_track_disc_get_drive (BRASERO_TRACK_DISC (track));
vol = brasero_volume_source_open_file (brasero_drive_get_device (drive), &priv->error);
files = brasero_volume_get_files (vol,
0,
NULL,
NULL,
NULL,
&priv->error);
brasero_volume_source_close (vol);
if (!files)
goto end;
medium = brasero_drive_get_medium (drive);
brasero_medium_get_data_size (medium, NULL, &volume_size);
if (volume_size == -1) {
priv->error = g_error_new (BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
_("The size of the volume could not be retrieved"));
goto end;
}
/* create a handle/open DVD */
handle = dvdcss_open (brasero_drive_get_device (drive));
if (!handle) {
priv->error = g_error_new (BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
_("Video DVD could not be opened"));
goto end;
}
/* look through the files to get the ranges of encrypted sectors
* and cache the CSS keys while at it. */
map = g_queue_new ();
if (!brasero_dvdcss_create_scrambled_sectors_map (self, drive, map, handle, files, &priv->error))
goto end;
BRASERO_JOB_LOG (self, "DVD map created (keys retrieved)");
g_queue_sort (map, brasero_dvdcss_sort_ranges, NULL);
brasero_volume_file_free (files);
files = NULL;
if (dvdcss_seek (handle, 0, DVDCSS_NOFLAGS) < 0) {
BRASERO_JOB_LOG (self, "Error initial seeking");
priv->error = g_error_new (BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
_("Error while reading video DVD (%s)"),
dvdcss_error (handle));
goto end;
}
brasero_job_set_current_action (BRASERO_JOB (self),
BRASERO_BURN_ACTION_DRIVE_COPY,
_("Copying video DVD"),
FALSE);
brasero_job_start_progress (BRASERO_JOB (self), TRUE);
remaining_sectors = volume_size;
range = g_queue_pop_head (map);
if (brasero_job_get_fd_out (BRASERO_JOB (self), NULL) != BRASERO_BURN_OK) {
gchar *output = NULL;
brasero_job_get_image_output (BRASERO_JOB (self), &output, NULL);
output_fd = fopen (output, "w");
if (!output_fd) {
priv->error = g_error_new_literal (BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
g_strerror (errno));
g_free (output);
goto end;
}
g_free (output);
}
while (remaining_sectors) {
gint flag;
guint64 num_blocks, data_size;
if (priv->cancel)
break;
num_blocks = BRASERO_DVDCSS_I_BLOCKS;
/* see if we are approaching the end of the dvd */
if (num_blocks > remaining_sectors)
num_blocks = remaining_sectors;
/* see if we need to update the key */
if (!range || written_sectors < range->start) {
/* this is in a non scrambled sectors range */
flag = DVDCSS_NOFLAGS;
/* we don't want to mix scrambled and non scrambled sectors */
if (range && written_sectors + num_blocks > range->start)
num_blocks = range->start - written_sectors;
}
else {
/* this is in a scrambled sectors range */
flag = DVDCSS_READ_DECRYPT;
/* see if we need to update the key */
if (written_sectors == range->start) {
int pos;
pos = dvdcss_seek (handle, written_sectors, DVDCSS_SEEK_KEY);
if (pos < 0) {
BRASERO_JOB_LOG (self, "Error seeking");
priv->error = g_error_new (BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
_("Error while reading video DVD (%s)"),
dvdcss_error (handle));
break;
}
}
/* we don't want to mix scrambled and non scrambled sectors
* NOTE: range->end address is the next non scrambled sector */
if (written_sectors + num_blocks > range->end)
num_blocks = range->end - written_sectors;
if (written_sectors + num_blocks == range->end) {
/* update to get the next range of scrambled sectors */
g_free (range);
range = g_queue_pop_head (map);
}
}
num_blocks = dvdcss_read (handle, buf, num_blocks, flag);
if (num_blocks < 0) {
BRASERO_JOB_LOG (self, "Error reading");
priv->error = g_error_new (BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
_("Error while reading video DVD (%s)"),
dvdcss_error (handle));
break;
}
data_size = num_blocks * DVDCSS_BLOCK_SIZE;
if (output_fd) {
if (fwrite (buf, 1, data_size, output_fd) != data_size) {
int errsv = errno;
priv->error = g_error_new (BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
_("Data could not be written (%s)"),
g_strerror (errsv));
break;
}
}
else {
BraseroBurnResult result;
result = brasero_dvdcss_write_sector_to_fd (self,
buf,
data_size);
if (result != BRASERO_BURN_OK)
break;
}
written_sectors += num_blocks;
remaining_sectors -= num_blocks;
brasero_job_set_written_track (BRASERO_JOB (self), written_sectors * DVDCSS_BLOCK_SIZE);
}
end:
if (range)
g_free (range);
if (handle)
dvdcss_close (handle);
if (files)
brasero_volume_file_free (files);
if (output_fd)
fclose (output_fd);
if (map) {
g_queue_foreach (map, (GFunc) g_free, NULL);
g_queue_free (map);
}
if (!priv->cancel)
priv->thread_id = g_idle_add (brasero_dvdcss_thread_finished, self);
/* End thread */
g_mutex_lock (priv->mutex);
priv->thread = NULL;
g_cond_signal (priv->cond);
g_mutex_unlock (priv->mutex);
g_thread_exit (NULL);
return NULL;
}
static gboolean vibrator_timed_outputclass_real_vibrate_pattern_co (VibratorTimedOutputclassVibratePatternData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
default:
g_assert_not_reached ();
}
_state_0:
_data_->_tmp1_ = _data_->self->priv->pulses;
if (_data_->_tmp1_ > ((guint) 0)) {
_data_->_tmp0_ = TRUE;
} else {
_data_->_tmp2_ = _data_->self->priv->fulltimeoutwatch;
_data_->_tmp0_ = _data_->_tmp2_ > ((guint) 0);
}
_data_->_tmp3_ = _data_->_tmp0_;
if (_data_->_tmp3_) {
_data_->_tmp4_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INVALID_PARAMETER, "Already vibrating... please try again");
_data_->_inner_error_ = _data_->_tmp4_;
if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
_data_->_tmp5_ = _data_->pulses;
if (_data_->_tmp5_ < 1) {
_data_->_tmp6_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INVALID_PARAMETER, "Number of pulses needs to be at least 1");
_data_->_inner_error_ = _data_->_tmp6_;
if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
_data_->_tmp7_ = _data_->delay_on;
if (_data_->_tmp7_ < 50) {
_data_->_tmp8_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INVALID_PARAMETER, "Delay on duration needs to be at least 50 milliseconds");
_data_->_inner_error_ = _data_->_tmp8_;
if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
_data_->_tmp9_ = _data_->delay_off;
if (_data_->_tmp9_ < 50) {
_data_->_tmp10_ = g_error_new_literal (FREE_SMARTPHONE_ERROR, FREE_SMARTPHONE_ERROR_INVALID_PARAMETER, "Delay off duration needs to be at least 50 milliseconds");
_data_->_inner_error_ = _data_->_tmp10_;
if (((_data_->_inner_error_->domain == FREE_SMARTPHONE_ERROR) || (_data_->_inner_error_->domain == G_DBUS_ERROR)) || (_data_->_inner_error_->domain == G_IO_ERROR)) {
g_simple_async_result_set_from_error (_data_->_async_result, _data_->_inner_error_);
g_error_free (_data_->_inner_error_);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
}
_data_->_tmp11_ = _data_->delay_on;
_data_->self->priv->don = (guint) _data_->_tmp11_;
_data_->_tmp12_ = _data_->delay_off;
_data_->self->priv->doff = (guint) _data_->_tmp12_;
_data_->_tmp13_ = _data_->pulses;
_data_->self->priv->pulses = (guint) _data_->_tmp13_;
vibrator_timed_outputclass_onToggleTimeout (_data_->self);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}