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; }
static gboolean populate_field_settings (GQuark field, const GValue * value, gpointer pfx) { gchar *field_name ; gpointer *pfxd = (gpointer*)pfx; XAMediaRecorderAdaptationCtx *ctxx = (XAMediaRecorderAdaptationCtx *) *pfxd; field_name = (gchar*)g_quark_to_string (field); if((strcasecmp((const char*)field_name,"channels") == 0)) { if(GST_VALUE_HOLDS_INT_RANGE(value) == TRUE) { (ctxx)->audioEncSettings.channelsIn = gst_value_get_int_range_max (value); (ctxx)->audioEncSettings.channelsOut = gst_value_get_int_range_max (value); }else { (ctxx)->audioEncSettings.channelsIn = g_value_get_int(value); (ctxx)->audioEncSettings.channelsOut = g_value_get_int(value); } } if((strcasecmp((const char*)field_name,"depth") == 0)) { if(GST_VALUE_HOLDS_INT_RANGE(value) == TRUE) { (ctxx)->audioEncSettings.bitsPerSample = gst_value_get_int_range_min (value); }else { (ctxx)->audioEncSettings.bitsPerSample = g_value_get_int(value); } } if((strcasecmp((const char*)field_name,"endianness") == 0)) { if(GST_VALUE_HOLDS_INT_RANGE(value) == TRUE) { (ctxx)->audioEncSettings.blockAlignment = gst_value_get_int_range_min (value); }else { (ctxx)->audioEncSettings.blockAlignment = g_value_get_int(value); } } if((strcasecmp((const char*)field_name,"bitrate") == 0)) { if(GST_VALUE_HOLDS_INT_RANGE(value) == TRUE) { (ctxx)->audioEncSettings.bitRate = gst_value_get_int_range_min (value); }else { (ctxx)->audioEncSettings.bitRate = g_value_get_int(value); } } if((strcasecmp((const char*)field_name,"rate") == 0)) { if(GST_VALUE_HOLDS_INT_RANGE(value) == TRUE) { (ctxx)->audioEncSettings.sampleRate = gst_value_get_int_range_min (value)*1000; }else { (ctxx)->audioEncSettings.sampleRate = g_value_get_int(value) * 1000; } } return TRUE; }
ResourceError ResourceError::tlsError(SoupRequest* request, unsigned /* tlsErrors */, GTlsCertificate*) { return ResourceError(g_quark_to_string(SOUP_HTTP_ERROR), SOUP_STATUS_SSL_FAILED, failingURI(request), unacceptableTLSCertificate()); }
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 gboolean rygel_mediathek_rss_container_parse_response (RygelMediathekRssContainer* self, const char* data, gsize length) { #line 178 "rygel-mediathek-rss-container.c" gboolean result = FALSE; GError * _inner_error_; gboolean ret; xmlDoc* doc; #line 52 "rygel-mediathek-rss-container.vala" g_return_val_if_fail (self != NULL, FALSE); #line 52 "rygel-mediathek-rss-container.vala" g_return_val_if_fail (data != NULL, FALSE); #line 187 "rygel-mediathek-rss-container.c" _inner_error_ = NULL; #line 53 "rygel-mediathek-rss-container.vala" ret = FALSE; #line 54 "rygel-mediathek-rss-container.vala" doc = xmlParseMemory (data, (gint) length); #line 55 "rygel-mediathek-rss-container.vala" if (doc != NULL) { #line 195 "rygel-mediathek-rss-container.c" xmlXPathContext* ctx; xmlXPathObject* xpo; gboolean _tmp0_ = FALSE; #line 56 "rygel-mediathek-rss-container.vala" gee_abstract_collection_clear ((GeeAbstractCollection*) ((RygelSimpleContainer*) self)->children); #line 57 "rygel-mediathek-rss-container.vala" ((RygelMediaContainer*) self)->child_count = 0; #line 59 "rygel-mediathek-rss-container.vala" ctx = xmlXPathNewContext (doc); #line 60 "rygel-mediathek-rss-container.vala" xpo = xmlXPathEval ("/rss/channel/title", ctx); #line 61 "rygel-mediathek-rss-container.vala" if (xpo->type == XPATH_NODESET) { #line 62 "rygel-mediathek-rss-container.vala" _tmp0_ = xmlXPathNodeSetGetLength (xpo->nodesetval) > 0; #line 211 "rygel-mediathek-rss-container.c" } else { #line 61 "rygel-mediathek-rss-container.vala" _tmp0_ = FALSE; #line 215 "rygel-mediathek-rss-container.c" } #line 61 "rygel-mediathek-rss-container.vala" if (_tmp0_) { #line 219 "rygel-mediathek-rss-container.c" char* _tmp1_; #line 64 "rygel-mediathek-rss-container.vala" rygel_media_object_set_title ((RygelMediaObject*) self, _tmp1_ = xmlNodeGetContent (xmlXPathNodeSetItem (xpo->nodesetval, 0))); #line 223 "rygel-mediathek-rss-container.c" _g_free0 (_tmp1_); } #line 67 "rygel-mediathek-rss-container.vala" xpo = xmlXPathEval ("/rss/channel/item", ctx); #line 68 "rygel-mediathek-rss-container.vala" if (xpo->type == XPATH_NODESET) { #line 230 "rygel-mediathek-rss-container.c" { gint i; #line 69 "rygel-mediathek-rss-container.vala" i = 0; #line 235 "rygel-mediathek-rss-container.c" { gboolean _tmp2_; #line 69 "rygel-mediathek-rss-container.vala" _tmp2_ = TRUE; #line 69 "rygel-mediathek-rss-container.vala" while (TRUE) { #line 242 "rygel-mediathek-rss-container.c" xmlNode* node; #line 69 "rygel-mediathek-rss-container.vala" if (!_tmp2_) { #line 69 "rygel-mediathek-rss-container.vala" i++; #line 248 "rygel-mediathek-rss-container.c" } #line 69 "rygel-mediathek-rss-container.vala" _tmp2_ = FALSE; #line 69 "rygel-mediathek-rss-container.vala" if (!(i < xmlXPathNodeSetGetLength (xpo->nodesetval))) { #line 69 "rygel-mediathek-rss-container.vala" break; #line 256 "rygel-mediathek-rss-container.c" } #line 70 "rygel-mediathek-rss-container.vala" node = xmlXPathNodeSetItem (xpo->nodesetval, i); #line 260 "rygel-mediathek-rss-container.c" { RygelMediathekVideoItem* item; #line 73 "rygel-mediathek-rss-container.vala" item = rygel_mediathek_video_item_create_from_xml ((RygelMediaContainer*) self, node, &_inner_error_); #line 265 "rygel-mediathek-rss-container.c" if (_inner_error_ != NULL) { if (_inner_error_->domain == RYGEL_MEDIATHEK_VIDEO_ITEM_ERROR) { goto __catch3_rygel_mediathek_video_item_error; } _xmlXPathFreeContext0 (ctx); 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 FALSE; } #line 75 "rygel-mediathek-rss-container.vala" rygel_simple_container_add_child ((RygelSimpleContainer*) self, (RygelMediaObject*) item); #line 76 "rygel-mediathek-rss-container.vala" ret = TRUE; #line 279 "rygel-mediathek-rss-container.c" _g_object_unref0 (item); } goto __finally3; __catch3_rygel_mediathek_video_item_error: { GError * _error_; _error_ = _inner_error_; _inner_error_ = NULL; { #line 79 "rygel-mediathek-rss-container.vala" g_warning (_ ("Error creating video item: %s"), _error_->message); #line 291 "rygel-mediathek-rss-container.c" _g_error_free0 (_error_); } } __finally3: if (_inner_error_ != NULL) { _xmlXPathFreeContext0 (ctx); 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 FALSE; } } } } } else { #line 85 "rygel-mediathek-rss-container.vala" g_warning ("rygel-mediathek-rss-container.vala:85: %s", _ ("XPath query failed")); #line 308 "rygel-mediathek-rss-container.c" } #line 88 "rygel-mediathek-rss-container.vala" xmlFreeDoc (doc); #line 89 "rygel-mediathek-rss-container.vala" rygel_media_container_updated ((RygelMediaContainer*) self); #line 314 "rygel-mediathek-rss-container.c" _xmlXPathFreeContext0 (ctx); } else { #line 92 "rygel-mediathek-rss-container.vala" g_warning ("rygel-mediathek-rss-container.vala:92: %s", _ ("Failed to parse doc")); #line 319 "rygel-mediathek-rss-container.c" } result = ret; #line 95 "rygel-mediathek-rss-container.vala" return result; #line 324 "rygel-mediathek-rss-container.c" }
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 gboolean rotation_plugin_store_state_co (RotationPluginStoreStateData* _data_) { switch (_data_->_state_) { case 0: goto _state_0; case 1: goto _state_1; case 2: goto _state_2; default: g_assert_not_reached (); } _state_0: _data_->_tmp0_ = NULL; g_object_get ((PeasActivatable*) _data_->self, "object", &_data_->_tmp0_, NULL); _data_->_tmp1_ = NULL; _data_->_tmp1_ = _data_->_tmp0_; _data_->t = G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp1_, totem_object_get_type (), TotemObject); _data_->_tmp2_ = NULL; _data_->_tmp2_ = _data_->t; _data_->_tmp3_ = NULL; _data_->_tmp3_ = totem_object_get_current_mrl (_data_->_tmp2_); _data_->mrl = _data_->_tmp3_; _data_->_tmp4_ = NULL; _data_->_tmp4_ = _data_->mrl; if (_data_->_tmp4_ == NULL) { _g_free0 (_data_->mrl); _g_object_unref0 (_data_->t); 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; } _data_->_tmp5_ = NULL; _data_->_tmp5_ = _data_->mrl; _data_->_tmp6_ = NULL; _data_->_tmp6_ = g_file_new_for_uri (_data_->_tmp5_); _data_->file = _data_->_tmp6_; { _data_->_tmp7_ = NULL; _data_->_tmp7_ = _data_->file; _data_->_state_ = 1; g_file_query_info_async (_data_->_tmp7_, GIO_ROTATION_FILE_ATTRIBUTE, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, NULL, rotation_plugin_store_state_ready, _data_); return FALSE; _state_1: _data_->_tmp8_ = NULL; _data_->_tmp8_ = g_file_query_info_finish (_data_->_tmp7_, _data_->_res_, &_data_->_inner_error_); _data_->file_info = _data_->_tmp8_; if (G_UNLIKELY (_data_->_inner_error_ != NULL)) { if (g_error_matches (_data_->_inner_error_, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) { goto __catch0_g_io_error_not_supported; } goto __catch0_g_error; } _data_->_tmp9_ = NULL; _data_->_tmp9_ = g_strdup (""); _data_->state_str = _data_->_tmp9_; _data_->_tmp10_ = NULL; _data_->_tmp10_ = _data_->self->priv->bvw; _data_->_tmp11_ = 0; _data_->_tmp11_ = bacon_video_widget_get_rotation (_data_->_tmp10_); _data_->rotation = _data_->_tmp11_; _data_->_tmp12_ = 0; _data_->_tmp12_ = _data_->rotation; if (_data_->_tmp12_ != BVW_ROTATION_R_ZERO) { _data_->_tmp13_ = 0; _data_->_tmp13_ = _data_->rotation; _data_->_tmp14_ = NULL; _data_->_tmp14_ = g_strdup_printf ("%u", (guint) _data_->_tmp13_); _g_free0 (_data_->state_str); _data_->state_str = _data_->_tmp14_; } _data_->_tmp15_ = NULL; _data_->_tmp15_ = _data_->file_info; _data_->_tmp16_ = NULL; _data_->_tmp16_ = _data_->state_str; g_file_info_set_attribute_string (_data_->_tmp15_, GIO_ROTATION_FILE_ATTRIBUTE, _data_->_tmp16_); _data_->_tmp17_ = NULL; _data_->_tmp17_ = _data_->file; _data_->_tmp18_ = NULL; _data_->_tmp18_ = _data_->file_info; _data_->_state_ = 2; g_file_set_attributes_async (_data_->_tmp17_, _data_->_tmp18_, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, NULL, rotation_plugin_store_state_ready, _data_); return FALSE; _state_2: g_file_set_attributes_finish (_data_->_tmp17_, _data_->_res_, NULL, &_data_->_inner_error_); if (G_UNLIKELY (_data_->_inner_error_ != NULL)) { _g_free0 (_data_->state_str); _g_object_unref0 (_data_->file_info); if (g_error_matches (_data_->_inner_error_, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) { goto __catch0_g_io_error_not_supported; } goto __catch0_g_error; } _g_free0 (_data_->state_str); _g_object_unref0 (_data_->file_info); } goto __finally0; __catch0_g_io_error_not_supported: { _data_->e = _data_->_inner_error_; _data_->_inner_error_ = NULL; _g_error_free0 (_data_->e); } goto __finally0; __catch0_g_error: { _data_->_vala1_e = _data_->_inner_error_; _data_->_inner_error_ = NULL; _data_->_tmp19_ = NULL; _data_->_tmp19_ = _data_->_vala1_e; _data_->_tmp20_ = NULL; _data_->_tmp20_ = _data_->_tmp19_->message; g_warning ("totem-rotation-plugin.vala:156: Could not store file attribute: %s", _data_->_tmp20_); _g_error_free0 (_data_->_vala1_e); } __finally0: if (G_UNLIKELY (_data_->_inner_error_ != NULL)) { _g_object_unref0 (_data_->file); _g_free0 (_data_->mrl); _g_object_unref0 (_data_->t); 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; } _g_object_unref0 (_data_->file); _g_free0 (_data_->mrl); _g_object_unref0 (_data_->t); 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 gboolean fusion_tls_output_stream_real_write_async_co (FusionTlsOutputStreamWriteAsyncData* _data_) { switch (_data_->_state_) { case 0: goto _state_0; case 1: goto _state_1; default: g_assert_not_reached (); } _state_0: _data_->_tmp0_ = NULL; _data_->_tmp0_ = _data_->self->priv->socket; _data_->_tmp1_ = 0; _data_->_tmp1_ = g_socket_condition_check (_data_->_tmp0_, G_IO_OUT); if (_data_->_tmp1_ == 0) { _data_->_tmp2_ = NULL; _data_->_tmp2_ = _data_->self->priv->socket; _data_->_tmp3_ = NULL; _data_->_tmp3_ = _data_->cancellable; _data_->_tmp4_ = NULL; _data_->_tmp4_ = g_socket_create_source (_data_->_tmp2_, (G_IO_OUT | G_IO_HUP) | G_IO_ERR, _data_->_tmp3_); _data_->source = _data_->_tmp4_; _data_->_tmp5_ = NULL; _data_->_tmp5_ = _data_->source; g_source_set_callback (_data_->_tmp5_, (GSourceFunc) _fusion_tls_output_stream_real_write_async_co_gsocket_source_func, _data_, NULL); _data_->_tmp6_ = NULL; _data_->_tmp6_ = _data_->source; _data_->_tmp7_ = NULL; _data_->_tmp7_ = g_main_context_get_thread_default (); g_source_attach (_data_->_tmp6_, _data_->_tmp7_); _data_->_state_ = 1; return FALSE; _state_1: ; _g_source_unref0 (_data_->source); } _data_->_tmp9_ = NULL; _data_->_tmp9_ = _data_->self->priv->connection; _data_->_tmp10_ = NULL; _data_->_tmp10__length1 = 0; _data_->_tmp10_ = _data_->buffer; _data_->_tmp10__length1 = _data_->buffer_length1; _data_->_tmp11_ = NULL; _data_->_tmp11_ = _data_->cancellable; _data_->_tmp12_ = 0L; _data_->_tmp12_ = fusion_tls_connection_send (_data_->_tmp9_, _data_->_tmp10_, _data_->_tmp10__length1, _data_->_tmp11_, &_data_->_inner_error_); _data_->_tmp8_ = _data_->_tmp12_; if (_data_->_inner_error_ != NULL) { if (_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_->result = _data_->_tmp8_; 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; 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 gboolean fusion_tls_output_stream_real_close (GOutputStream* base, GCancellable* cancellable, GError** error) { FusionTLSOutputStream * self; gboolean result = FALSE; GError * _inner_error_ = NULL; self = (FusionTLSOutputStream*) base; { GSocket* _tmp0_ = NULL; _tmp0_ = self->priv->socket; g_socket_close (_tmp0_, &_inner_error_); if (_inner_error_ != NULL) { goto __catch5_g_error; } result = TRUE; return result; } goto __finally5; __catch5_g_error: { GError* e = NULL; e = _inner_error_; _inner_error_ = NULL; result = FALSE; _g_error_free0 (e); return result; } __finally5: 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 FALSE; }
ResourceError ResourceError::authenticationError(SoupMessage* message) { ASSERT(message); return ResourceError(g_quark_to_string(SOUP_HTTP_ERROR), message->status_code, failingURI(soup_message_get_uri(message)), String::fromUTF8(message->reason_phrase)); }
/** * {@inheritDoc} */ static void plank_items_dock_item_preferences_real_verify (PlankServicesPreferences* base, const gchar* prop) { PlankItemsDockItemPreferences * self; const gchar* _tmp0_ = NULL; const gchar* _tmp1_ = NULL; GQuark _tmp3_ = 0U; static GQuark _tmp2_label0 = 0; GError * _inner_error_ = NULL; self = (PlankItemsDockItemPreferences*) base; g_return_if_fail (prop != NULL); _tmp0_ = prop; _tmp1_ = _tmp0_; _tmp3_ = (NULL == _tmp1_) ? 0 : g_quark_from_string (_tmp1_); if (_tmp3_ == ((0 != _tmp2_label0) ? _tmp2_label0 : (_tmp2_label0 = g_quark_from_static_string ("Launcher")))) { switch (0) { default: { const gchar* _tmp4_ = NULL; gboolean _tmp5_ = FALSE; _tmp4_ = self->priv->_Launcher; _tmp5_ = g_str_has_prefix (_tmp4_, "/"); if (_tmp5_) { { gchar* _tmp6_ = NULL; const gchar* _tmp7_ = NULL; gchar* _tmp8_ = NULL; _tmp7_ = self->priv->_Launcher; _tmp8_ = g_filename_to_uri (_tmp7_, NULL, &_inner_error_); _tmp6_ = _tmp8_; if (_inner_error_ != NULL) { if (_inner_error_->domain == G_CONVERT_ERROR) { goto __catch28_g_convert_error; } 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; } plank_items_dock_item_preferences_set_Launcher (self, _tmp6_); _g_free0 (_tmp6_); } goto __finally28; __catch28_g_convert_error: { GError* e = NULL; GError* _tmp9_ = NULL; const gchar* _tmp10_ = NULL; e = _inner_error_; _inner_error_ = NULL; _tmp9_ = e; _tmp10_ = _tmp9_->message; g_warning ("DockItemPreferences.vala:74: %s", _tmp10_); _g_error_free0 (e); } __finally28: if (_inner_error_ != 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; } } break; } } } }
ResourceError ResourceError::transportError(SoupRequest* request, int statusCode, const String& reasonPhrase) { return ResourceError(g_quark_to_string(SOUP_HTTP_ERROR), statusCode, failingURI(request), reasonPhrase); }
static GString* gwy_si_unit_format(GwySIUnit *siunit, const GwySIStyleSpec *fs, GString *string) { const gchar *prefix = "No GCC, this can't be used uninitialized"; GwySimpleUnit *unit; gint i, prefix_bearer, move_me_to_end; if (!string) string = g_string_new(""); else g_string_truncate(string, 0); /* if there is a single unit with negative exponent, move it to the end * TODO: we may want more sophistication here */ move_me_to_end = -1; if (siunit->units->len > 1) { for (i = 0; i < siunit->units->len; i++) { unit = &g_array_index(siunit->units, GwySimpleUnit, i); if (unit->power < 0) { if (move_me_to_end >= 0) { move_me_to_end = -1; break; } move_me_to_end = i; } } } /* find a victim to prepend a prefix to. mwhahaha */ prefix_bearer = -1; if (siunit->power10) { for (i = 0; i < siunit->units->len; i++) { if (i == move_me_to_end) continue; unit = &g_array_index(siunit->units, GwySimpleUnit, i); if (siunit->power10 % (3*abs(unit->power)) == 0) { prefix_bearer = i; break; } } } if (siunit->power10 && prefix_bearer < 0 && move_me_to_end >= 0) { unit = &g_array_index(siunit->units, GwySimpleUnit, move_me_to_end); if (siunit->power10 % (3*abs(unit->power)) == 0) prefix_bearer = move_me_to_end; } /* check whether we are not out of prefix range */ if (prefix_bearer >= 0) { unit = &g_array_index(siunit->units, GwySimpleUnit, prefix_bearer); prefix = gwy_si_unit_prefix(siunit->power10/unit->power); if (!prefix) prefix_bearer = -1; } /* if we were unable to place the prefix, we must add a power of 10 */ if (siunit->power10 && prefix_bearer < 0) { switch (siunit->power10) { case -1: g_string_append(string, "0.1"); break; case 1: g_string_append(string, "10"); break; case 2: g_string_append(string, "100"); break; default: if (fs->power10_prefix) g_string_append(string, fs->power10_prefix); g_string_append_printf(string, "%d", siunit->power10); if (fs->power_suffix) g_string_append(string, fs->power_suffix); break; } if (fs->power_unit_separator && siunit->units->len) g_string_append(string, fs->power_unit_separator); } /* append units */ for (i = 0; i < siunit->units->len; i++) { if (i == move_me_to_end) continue; if (i > 1 || (i && move_me_to_end)) { g_string_append(string, fs->unit_times); } unit = &g_array_index(siunit->units, GwySimpleUnit, i); if (i == prefix_bearer) g_string_append(string, prefix); g_string_append(string, g_quark_to_string(unit->unit)); if (unit->power != 1) { if (fs->power_prefix) g_string_append(string, fs->power_prefix); g_string_append_printf(string, "%d", unit->power); if (fs->power_suffix) g_string_append(string, fs->power_suffix); } } if (move_me_to_end >= 0) { g_string_append(string, fs->unit_division); unit = &g_array_index(siunit->units, GwySimpleUnit, move_me_to_end); if (move_me_to_end == prefix_bearer) g_string_append(string, prefix); g_string_append(string, g_quark_to_string(unit->unit)); if (unit->power != -1) { if (fs->power_prefix) g_string_append(string, fs->power_prefix); g_string_append_printf(string, "%d", -unit->power); if (fs->power_suffix) g_string_append(string, fs->power_suffix); } } return string; }
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 run_nice_transmitter_test (gint n_parameters, GParameter *params, gint flags) { GError *error = NULL; FsTransmitter *trans = NULL, *trans2 = NULL; FsStreamTransmitter *st = NULL, *st2 = NULL; GstBus *bus = NULL; GstElement *pipeline = NULL; GstElement *pipeline2 = NULL; FsNiceTestParticipant *p1 = NULL, *p2 = NULL; memset (buffer_count, 0, sizeof(gint)*4); memset (received_known, 0, sizeof(guint)*4); running = TRUE; associate_on_source = !(flags & FLAG_NO_SOURCE); is_address_local = (flags & FLAG_IS_LOCAL); force_candidates = (flags & FLAG_FORCE_CANDIDATES); if (flags & FLAG_RECVONLY_FILTER) ts_fail_unless (fs_fake_filter_register ()); if (flags & FLAG_NOT_SENDING) { buffer_count[0][0] = 20; received_known[0][0] = 20; buffer_count[1][0] = 20; received_known[1][0] = 20; } loop = g_main_loop_new (NULL, FALSE); trans = fs_transmitter_new ("nice", 2, 0, &error); if (error) { ts_fail ("Error creating transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); } ts_fail_if (trans == NULL, "No transmitter create, yet error is still NULL"); if (flags & FLAG_RECVONLY_FILTER) ts_fail_unless (g_signal_connect (trans, "get-recvonly-filter", G_CALLBACK (_get_recvonly_filter), NULL)); trans2 = fs_transmitter_new ("nice", 2, 0, &error); if (error) { ts_fail ("Error creating transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); } ts_fail_if (trans2 == NULL, "No transmitter create, yet error is still NULL"); if (flags & FLAG_RECVONLY_FILTER) ts_fail_unless (g_signal_connect (trans2, "get-recvonly-filter", G_CALLBACK (_get_recvonly_filter), NULL)); pipeline = setup_pipeline (trans, G_CALLBACK (_handoff_handler1)); pipeline2 = setup_pipeline (trans2, G_CALLBACK (_handoff_handler2)); g_object_set_data (G_OBJECT (trans), "pipeline", pipeline); g_object_set_data (G_OBJECT (trans2), "pipeline", pipeline2); bus = gst_element_get_bus (pipeline); gst_bus_add_watch (bus, bus_error_callback, NULL); gst_object_unref (bus); bus = gst_element_get_bus (pipeline2); gst_bus_add_watch (bus, bus_error_callback, NULL); gst_object_unref (bus); /* * I'm passing the participant because any gobject will work, * but it should be the participant */ p1 = g_object_new (fs_nice_test_participant_get_type (), NULL); p2 = g_object_new (fs_nice_test_participant_get_type (), NULL); st = fs_transmitter_new_stream_transmitter (trans, FS_PARTICIPANT (p1), n_parameters, params, &error); if (error) ts_fail ("Error creating stream transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_if (st == NULL, "No stream transmitter created, yet error is NULL"); st2 = fs_transmitter_new_stream_transmitter (trans2, FS_PARTICIPANT (p2), n_parameters, params, &error); if (error) ts_fail ("Error creating stream transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_if (st2 == NULL, "No stream transmitter created, yet error is NULL"); g_object_set (st, "sending", !(flags & FLAG_NOT_SENDING), NULL); g_object_set (st2, "sending", !(flags & FLAG_NOT_SENDING), NULL); ts_fail_unless (g_signal_connect (st, "new-local-candidate", G_CALLBACK (_new_local_candidate), st2), "Could not connect new-local-candidate signal"); ts_fail_unless (g_signal_connect (st, "local-candidates-prepared", G_CALLBACK (_local_candidates_prepared), st2), "Could not connect local-candidates-prepared signal"); ts_fail_unless (g_signal_connect (st, "new-active-candidate-pair", G_CALLBACK (_new_active_candidate_pair), trans), "Could not connect new-active-candidate-pair signal"); ts_fail_unless (g_signal_connect (st, "error", G_CALLBACK (stream_transmitter_error), NULL), "Could not connect error signal"); ts_fail_unless (g_signal_connect (st, "state-changed", G_CALLBACK (_stream_state_changed), trans), "Could not connect to state-changed signal"); ts_fail_unless (g_signal_connect (st, "known-source-packet-received", G_CALLBACK (_known_source_packet_received), GUINT_TO_POINTER (1)), "Could not connect to known-source-packet-received signal"); ts_fail_unless (g_signal_connect (st2, "new-local-candidate", G_CALLBACK (_new_local_candidate), st), "Could not connect new-local-candidate signal"); ts_fail_unless (g_signal_connect (st2, "local-candidates-prepared", G_CALLBACK (_local_candidates_prepared), st), "Could not connect local-candidates-prepared signal"); ts_fail_unless (g_signal_connect (st2, "new-active-candidate-pair", G_CALLBACK (_new_active_candidate_pair), trans2), "Could not connect new-active-candidate-pair signal"); ts_fail_unless (g_signal_connect (st2, "error", G_CALLBACK (stream_transmitter_error), NULL), "Could not connect error signal"); ts_fail_unless (g_signal_connect (st2, "state-changed", G_CALLBACK (_stream_state_changed), trans2), "Could not connect to state-changed signal"); ts_fail_unless (g_signal_connect (st2, "known-source-packet-received", G_CALLBACK (_known_source_packet_received), GUINT_TO_POINTER (2)), "Could not connect to known-source-packet-received signal"); ts_fail_if (gst_element_set_state (pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE, "Could not set the pipeline to playing"); ts_fail_if (gst_element_set_state (pipeline2, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE, "Could not set the pipeline to playing"); if (!fs_stream_transmitter_gather_local_candidates (st, &error)) { if (error) ts_fail ("Could not start gathering local candidates %s", error->message); else ts_fail ("Could not start gathering candidates" " (without a specified error)"); } if (!fs_stream_transmitter_gather_local_candidates (st2, &error)) { if (error) ts_fail ("Could not start gathering local candidates %s", error->message); else ts_fail ("Could not start gathering candidates" " (without a specified error)"); } g_idle_add (check_running, NULL); g_main_loop_run (loop); fs_stream_transmitter_stop (st); fs_stream_transmitter_stop (st2); gst_element_set_state (pipeline, GST_STATE_NULL); gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE); gst_element_set_state (pipeline2, GST_STATE_NULL); gst_element_get_state (pipeline2, NULL, NULL, GST_CLOCK_TIME_NONE); if (st) g_object_unref (st); if (st2) g_object_unref (st2); g_object_unref (trans); g_object_unref (trans2); g_object_unref (p1); g_object_unref (p2); gst_object_unref (pipeline); g_main_loop_unref (loop); }
static void fusion_tls_connection_handle_error (FusionTLSConnection* self, int ecode, gint where, GError** error) { gboolean _tmp0_ = FALSE; int _tmp1_ = 0; gboolean _tmp3_ = FALSE; gboolean _tmp8_ = FALSE; int _tmp9_ = 0; gboolean _tmp12_ = FALSE; GError * _inner_error_ = NULL; g_return_if_fail (self != NULL); _tmp1_ = ecode; if (_tmp1_ == GNUTLS_E_WARNING_ALERT_RECEIVED) { _tmp0_ = TRUE; } else { int _tmp2_ = 0; _tmp2_ = ecode; _tmp0_ = _tmp2_ == GNUTLS_E_FATAL_ALERT_RECEIVED; } _tmp3_ = _tmp0_; if (_tmp3_) { gnutls_alert_description_t alert = 0; struct gnutls_session_int* _tmp4_ = NULL; gnutls_alert_description_t _tmp5_ = 0; gnutls_alert_description_t _tmp6_ = 0; const gchar* _tmp7_ = NULL; _tmp4_ = self->tls_session; _tmp5_ = gnutls_alert_get (_tmp4_); alert = _tmp5_; _tmp6_ = alert; _tmp7_ = gnutls_alert_get_name (_tmp6_); g_warning ("TLSConnection.vala:74: TLS handshake alert: %s", _tmp7_); } _tmp9_ = ecode; if (_tmp9_ < 0) { int _tmp10_ = 0; gboolean _tmp11_ = FALSE; _tmp10_ = ecode; _tmp11_ = gnutls_error_is_fatal (_tmp10_); _tmp8_ = _tmp11_; } else { _tmp8_ = FALSE; } _tmp12_ = _tmp8_; if (_tmp12_) { gint _tmp13_ = 0; _tmp13_ = where; switch (_tmp13_) { case 0: { int _tmp14_ = 0; const gchar* _tmp15_ = NULL; GError* _tmp16_ = NULL; _tmp14_ = ecode; _tmp15_ = gnutls_strerror (_tmp14_); _tmp16_ = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "Handshake failed: %s", _tmp15_); _inner_error_ = _tmp16_; if (_inner_error_->domain == G_IO_ERROR) { g_propagate_error (error, _inner_error_); return; } 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; } } case 1: { int _tmp17_ = 0; const gchar* _tmp18_ = NULL; GError* _tmp19_ = NULL; _tmp17_ = ecode; _tmp18_ = gnutls_strerror (_tmp17_); _tmp19_ = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "Receive failed: %s", _tmp18_); _inner_error_ = _tmp19_; if (_inner_error_->domain == G_IO_ERROR) { g_propagate_error (error, _inner_error_); return; } 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; } } case 2: { int _tmp20_ = 0; const gchar* _tmp21_ = NULL; GError* _tmp22_ = NULL; _tmp20_ = ecode; _tmp21_ = gnutls_strerror (_tmp20_); _tmp22_ = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "Send failed: %s", _tmp21_); _inner_error_ = _tmp22_; if (_inner_error_->domain == G_IO_ERROR) { g_propagate_error (error, _inner_error_); return; } 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; } } default: { g_assert_not_reached (); } } } }
void ease_welcome_actor_set_slide_size (EaseWelcomeActor* self, gint w, gint h) { #line 240 "ease-welcome-actor.c" GError * _inner_error_ = NULL; #line 150 "ease-welcome-actor.vala" g_return_if_fail (self != NULL); #line 153 "ease-welcome-actor.vala" clutter_cairo_texture_set_surface_size (self->priv->slide_actor, (guint) w, (guint) h); #line 246 "ease-welcome-actor.c" { EaseSlide* slide; cairo_t* _tmp0_; #line 158 "ease-welcome-actor.vala" slide = ease_welcome_actor_create_slide (self, w, h); #line 159 "ease-welcome-actor.vala" ease_slide_cairo_render_sized (slide, _tmp0_ = clutter_cairo_texture_create (self->priv->slide_actor), w, h, &_inner_error_); #line 254 "ease-welcome-actor.c" _cairo_destroy0 (_tmp0_); if (_inner_error_ != NULL) { _g_object_unref0 (slide); goto __catch20_g_error; } _g_object_unref0 (slide); } goto __finally20; __catch20_g_error: { GError * e; e = _inner_error_; _inner_error_ = NULL; { #line 163 "ease-welcome-actor.vala" g_critical (_ ("Error rendering preview: %s"), e->message); #line 271 "ease-welcome-actor.c" _g_error_free0 (e); } } __finally20: if (_inner_error_ != 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; } }
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; }
static void datalist_encode_foreach (GQuark key_id, gpointer value, gpointer str) { encode_pair (str, g_quark_to_string (key_id), value); }
static gssize fusion_tls_input_stream_real_read (GInputStream* base, guint8* buffer, int buffer_length1, GCancellable* cancellable, GError** error) { FusionTLSInputStream * self; gssize result = 0L; gssize _tmp0_ = 0L; FusionTLSConnection* _tmp1_ = NULL; guint8* _tmp2_ = NULL; gint _tmp2__length1 = 0; GCancellable* _tmp3_ = NULL; gssize _tmp4_ = 0L; GError * _inner_error_ = NULL; self = (FusionTLSInputStream*) base; _tmp1_ = self->priv->connection; _tmp2_ = buffer; _tmp2__length1 = buffer_length1; _tmp3_ = cancellable; _tmp4_ = fusion_tls_connection_receive (_tmp1_, _tmp2_, _tmp2__length1, _tmp3_, &_inner_error_); _tmp0_ = _tmp4_; 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; } } result = _tmp0_; return result; }
static gboolean rotation_plugin_try_restore_state_co (RotationPluginTryRestoreStateData* _data_) { switch (_data_->_state_) { case 0: goto _state_0; case 1: goto _state_1; default: g_assert_not_reached (); } _state_0: _data_->_tmp0_ = NULL; _data_->_tmp0_ = _data_->mrl; _data_->_tmp1_ = NULL; _data_->_tmp1_ = g_file_new_for_uri (_data_->_tmp0_); _data_->file = _data_->_tmp1_; _data_->_tmp3_ = NULL; _data_->_tmp3_ = _data_->file; _data_->_tmp4_ = FALSE; _data_->_tmp4_ = g_file_has_uri_scheme (_data_->_tmp3_, "http"); if (_data_->_tmp4_) { _data_->_tmp2_ = TRUE; } else { _data_->_tmp5_ = NULL; _data_->_tmp5_ = _data_->file; _data_->_tmp6_ = FALSE; _data_->_tmp6_ = g_file_has_uri_scheme (_data_->_tmp5_, "dvd"); _data_->_tmp2_ = _data_->_tmp6_; } if (_data_->_tmp2_) { _g_object_unref0 (_data_->file); 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; } { _data_->_tmp7_ = NULL; _data_->_tmp7_ = _data_->file; _data_->_state_ = 1; g_file_query_info_async (_data_->_tmp7_, GIO_ROTATION_FILE_ATTRIBUTE, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, NULL, rotation_plugin_try_restore_state_ready, _data_); return FALSE; _state_1: _data_->_tmp8_ = NULL; _data_->_tmp8_ = g_file_query_info_finish (_data_->_tmp7_, _data_->_res_, &_data_->_inner_error_); _data_->file_info = _data_->_tmp8_; if (G_UNLIKELY (_data_->_inner_error_ != NULL)) { if (g_error_matches (_data_->_inner_error_, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) { goto __catch1_g_io_error_not_supported; } goto __catch1_g_error; } _data_->_tmp9_ = NULL; _data_->_tmp9_ = _data_->file_info; _data_->_tmp10_ = NULL; _data_->_tmp10_ = g_file_info_get_attribute_string (_data_->_tmp9_, GIO_ROTATION_FILE_ATTRIBUTE); _data_->_tmp11_ = NULL; _data_->_tmp11_ = g_strdup (_data_->_tmp10_); _data_->state_str = _data_->_tmp11_; _data_->_tmp12_ = NULL; _data_->_tmp12_ = _data_->state_str; if (_data_->_tmp12_ != NULL) { _data_->_tmp13_ = NULL; _data_->_tmp13_ = _data_->state_str; _data_->_tmp14_ = 0ULL; _data_->_tmp14_ = uint64_parse (_data_->_tmp13_); _data_->state = (gint) ((BvwRotation) _data_->_tmp14_); _data_->_tmp15_ = NULL; _data_->_tmp15_ = _data_->self->priv->bvw; _data_->_tmp16_ = 0; _data_->_tmp16_ = _data_->state; bacon_video_widget_set_rotation (_data_->_tmp15_, (BvwRotation) _data_->_tmp16_); } _g_free0 (_data_->state_str); _g_object_unref0 (_data_->file_info); } goto __finally1; __catch1_g_io_error_not_supported: { _data_->e = _data_->_inner_error_; _data_->_inner_error_ = NULL; _g_error_free0 (_data_->e); } goto __finally1; __catch1_g_error: { _data_->_vala1_e = _data_->_inner_error_; _data_->_inner_error_ = NULL; _data_->_tmp17_ = NULL; _data_->_tmp17_ = _data_->_vala1_e; _data_->_tmp18_ = NULL; _data_->_tmp18_ = _data_->_tmp17_->message; g_warning ("totem-rotation-plugin.vala:175: Could not query file attribute: %s", _data_->_tmp18_); _g_error_free0 (_data_->_vala1_e); } __finally1: if (G_UNLIKELY (_data_->_inner_error_ != NULL)) { _g_object_unref0 (_data_->file); 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; } _g_object_unref0 (_data_->file); 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 add_config_file (GoaDaemon *daemon, const gchar *path, GHashTable *group_name_to_key_file_data, GList **key_files_to_free) { GKeyFile *key_file; GError *error; key_file = g_key_file_new (); error = NULL; if (!g_key_file_load_from_file (key_file, path, G_KEY_FILE_NONE, &error)) { if (!(error->domain == G_FILE_ERROR && error->code == G_FILE_ERROR_NOENT)) { g_warning ("Error loading %s: %s (%s, %d)", path, error->message, g_quark_to_string (error->domain), error->code); } g_error_free (error); g_key_file_free (key_file); } else { gchar **groups; const char *guid; gsize num_groups; guint n; guid = g_dbus_connection_get_guid (daemon->connection); groups = g_key_file_get_groups (key_file, &num_groups); for (n = 0; n < num_groups; n++) { if (g_str_has_prefix (groups[n], "Account ")) { gboolean is_temporary; char *session_id; is_temporary = g_key_file_get_boolean (key_file, groups[n], "IsTemporary", NULL); if (is_temporary) { session_id = g_key_file_get_string (key_file, groups[n], "SessionId", NULL); /* discard temporary accounts from older sessions */ if (session_id != NULL && g_strcmp0 (session_id, guid) != 0) { g_debug ("ignoring account \"%s\" in file %s because it's stale", groups[n], path); g_free (groups[n]); g_free (session_id); continue; } g_free (session_id); } else { g_key_file_remove_key (key_file, groups[n], "SessionId", NULL); } g_hash_table_insert (group_name_to_key_file_data, groups[n], /* steals string */ key_file_data_new (key_file, path)); } else { g_warning ("Unexpected group \"%s\" in file %s", groups[n], path); g_free (groups[n]); } } g_free (groups); *key_files_to_free = g_list_prepend (*key_files_to_free, key_file); } }
static gboolean wxgtk_webview_webkit_error(WebKitWebView*, WebKitWebFrame*, gchar *uri, gpointer web_error, wxWebViewWebKit* webKitWindow) { webKitWindow->m_busy = false; wxWebViewNavigationError type = wxWEB_NAV_ERR_OTHER; GError* error = (GError*)web_error; wxString description(error->message, wxConvUTF8); if (strcmp(g_quark_to_string(error->domain), "soup_http_error_quark") == 0) { switch (error->code) { case SOUP_STATUS_CANCELLED: type = wxWEB_NAV_ERR_USER_CANCELLED; break; case SOUP_STATUS_CANT_RESOLVE: case SOUP_STATUS_NOT_FOUND: type = wxWEB_NAV_ERR_NOT_FOUND; break; case SOUP_STATUS_CANT_RESOLVE_PROXY: case SOUP_STATUS_CANT_CONNECT: case SOUP_STATUS_CANT_CONNECT_PROXY: case SOUP_STATUS_SSL_FAILED: case SOUP_STATUS_IO_ERROR: type = wxWEB_NAV_ERR_CONNECTION; break; case SOUP_STATUS_MALFORMED: //case SOUP_STATUS_TOO_MANY_REDIRECTS: type = wxWEB_NAV_ERR_REQUEST; break; //case SOUP_STATUS_NO_CONTENT: //case SOUP_STATUS_RESET_CONTENT: case SOUP_STATUS_BAD_REQUEST: type = wxWEB_NAV_ERR_REQUEST; break; case SOUP_STATUS_UNAUTHORIZED: case SOUP_STATUS_FORBIDDEN: type = wxWEB_NAV_ERR_AUTH; break; case SOUP_STATUS_METHOD_NOT_ALLOWED: case SOUP_STATUS_NOT_ACCEPTABLE: type = wxWEB_NAV_ERR_SECURITY; break; case SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED: type = wxWEB_NAV_ERR_AUTH; break; case SOUP_STATUS_REQUEST_TIMEOUT: type = wxWEB_NAV_ERR_CONNECTION; break; //case SOUP_STATUS_PAYMENT_REQUIRED: case SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE: case SOUP_STATUS_REQUEST_URI_TOO_LONG: case SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE: type = wxWEB_NAV_ERR_REQUEST; break; case SOUP_STATUS_BAD_GATEWAY: case SOUP_STATUS_SERVICE_UNAVAILABLE: case SOUP_STATUS_GATEWAY_TIMEOUT: type = wxWEB_NAV_ERR_CONNECTION; break; case SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED: type = wxWEB_NAV_ERR_REQUEST; break; //case SOUP_STATUS_INSUFFICIENT_STORAGE: //case SOUP_STATUS_NOT_EXTENDED: } } else if (strcmp(g_quark_to_string(error->domain), "webkit-network-error-quark") == 0) { switch (error->code) { //WEBKIT_NETWORK_ERROR_FAILED: //WEBKIT_NETWORK_ERROR_TRANSPORT: case WEBKIT_NETWORK_ERROR_UNKNOWN_PROTOCOL: type = wxWEB_NAV_ERR_REQUEST; break; case WEBKIT_NETWORK_ERROR_CANCELLED: type = wxWEB_NAV_ERR_USER_CANCELLED; break; case WEBKIT_NETWORK_ERROR_FILE_DOES_NOT_EXIST: type = wxWEB_NAV_ERR_NOT_FOUND; break; } } else if (strcmp(g_quark_to_string(error->domain), "webkit-policy-error-quark") == 0) { switch (error->code) { //case WEBKIT_POLICY_ERROR_FAILED: //case WEBKIT_POLICY_ERROR_CANNOT_SHOW_MIME_TYPE: //case WEBKIT_POLICY_ERROR_CANNOT_SHOW_URL: //case WEBKIT_POLICY_ERROR_FRAME_LOAD_INTERRUPTED_BY_POLICY_CHANGE: case WEBKIT_POLICY_ERROR_CANNOT_USE_RESTRICTED_PORT: type = wxWEB_NAV_ERR_SECURITY; break; } } /* webkit_plugin_error_quark else { printf("Error domain %s\n", g_quark_to_string(error->domain)); } */ wxWebViewEvent event(wxEVT_COMMAND_WEB_VIEW_ERROR, webKitWindow->GetId(), uri, ""); event.SetString(description); event.SetInt(type); if (webKitWindow && webKitWindow->GetEventHandler()) { webKitWindow->GetEventHandler()->ProcessEvent(event); } return FALSE; }
/* returns FALSE if object is not (or no longer) valid */ static gboolean update_account_object (GoaDaemon *daemon, GoaObjectSkeleton *object, const gchar *path, const gchar *group, GKeyFile *key_file, gboolean just_added) { GoaAccount *account; GoaProvider *provider; gboolean ret; gchar *identity; gchar *presentation_identity; gchar *type; gchar *name; GIcon *icon; gchar *serialized_icon; GError *error; g_return_val_if_fail (GOA_IS_DAEMON (daemon), FALSE); g_return_val_if_fail (G_IS_DBUS_OBJECT_SKELETON (object), FALSE); g_return_val_if_fail (group != NULL, FALSE); g_return_val_if_fail (key_file != NULL, FALSE); ret = FALSE; identity = NULL; type = NULL; account = NULL; name = NULL; icon = NULL; serialized_icon = NULL; g_debug ("updating %s %d", g_dbus_object_get_object_path (G_DBUS_OBJECT (object)), just_added); type = g_key_file_get_string (key_file, group, "Provider", NULL); identity = g_key_file_get_string (key_file, group, "Identity", NULL); presentation_identity = g_key_file_get_string (key_file, group, "PresentationIdentity", NULL); if (just_added) { account = goa_account_skeleton_new (); goa_object_skeleton_set_account (object, account); } else { account = goa_object_get_account (GOA_OBJECT (object)); } provider = goa_provider_get_for_provider_type (type); if (provider == NULL) { g_warning ("Unsupported account type %s for identity %s (no provider)", type, identity); goto out; } goa_account_set_id (account, g_strrstr (g_dbus_object_get_object_path (G_DBUS_OBJECT (object)), "/") + 1); goa_account_set_provider_type (account, type); goa_account_set_identity (account, identity); goa_account_set_presentation_identity (account, presentation_identity); error = NULL; if (!goa_provider_build_object (provider, object, key_file, group, daemon->connection, just_added, &error)) { g_warning ("Error parsing account: %s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); goto out; } name = goa_provider_get_provider_name (provider, GOA_OBJECT (object)); goa_account_set_provider_name (account, name); icon = goa_provider_get_provider_icon (provider, GOA_OBJECT (object)); serialized_icon = g_icon_to_string (icon); goa_account_set_provider_icon (account, serialized_icon); ret = TRUE; out: g_free (serialized_icon); if (icon != NULL) g_object_unref (icon); g_free (name); if (provider != NULL) g_object_unref (provider); g_object_unref (account); g_free (type); g_free (identity); return ret; }
void generatecdf_run(GenerateCDFAction* action) { MAGIC_ASSERT(action); // CumulativeDistribution* cdf = cdf_generate(action->id, action->center, action->width, action->tail); warning("cdf '%s' not supported", g_quark_to_string(action->id)); }
static void gfire_sq_ase_details_vars(GQuark p_key, gpointer p_data, gpointer p_udata) { g_string_append_printf((GString*)p_udata, "<b>%s:</b> %s<br>", g_quark_to_string(p_key), (gchar*)p_data); }
ResourceError ResourceError::genericIOError(GError* error, SoupRequest* request) { return ResourceError(g_quark_to_string(G_IO_ERROR), error->code, failingURI(request), String::fromUTF8(error->message)); }
static gboolean set_the_candidates (gpointer user_data) { FsStreamTransmitter *st = FS_STREAM_TRANSMITTER (user_data); GList *candidates = g_object_get_data (G_OBJECT (st), "candidates-set"); gboolean ret; GError *error = NULL; if (!candidates) { g_debug ("Skipping libnice check because it found NO local candidates"); g_atomic_int_set(&running, FALSE); g_main_loop_quit (loop); return FALSE; } if (force_candidates) { GList *item = NULL; GList *next = NULL; GList *new_list = NULL; for (item = candidates; item; item = next) { FsCandidate *cand = item->data; GList *item2 = NULL; next = g_list_next (item); if (cand->type != FS_CANDIDATE_TYPE_HOST) continue; if (cand->component_id != 1) continue; for (item2 = candidates; item2; item2 = g_list_next (item2)) { FsCandidate *cand2 = item2->data; if (cand2->component_id == 2 && !strcmp (cand->foundation, cand2->foundation)) { new_list = g_list_append (new_list, cand); new_list = g_list_append (new_list, cand2); goto got_candidates; } } } ts_fail ("Could not find two matching host candidates???"); got_candidates: ts_fail_unless (g_list_length (new_list) == 2); ret = fs_stream_transmitter_force_remote_candidates (st, new_list, &error); } else { ret = fs_stream_transmitter_add_remote_candidates (st, candidates, &error); } if (error) ts_fail ("Error while adding candidate: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_unless (ret == TRUE, "No detailed error setting remote_candidate"); fs_candidate_list_destroy (candidates); return FALSE; }
/** * Main file interface for logging */ static void file_log_function (const gchar *module, const gchar *id, const gchar *function, gint level_flags, const gchar *message, gpointer arg) { gchar tmpbuf[256], timebuf[32], modulebuf[64]; gchar *m; time_t now; struct tm *tms; struct iovec iov[5]; gulong r = 0, mr = 0; guint64 cksum; size_t mlen, mremain; const gchar *cptype = NULL; gboolean got_time = FALSE; rspamd_logger_t *rspamd_log = arg; if (!rspamd_log->enabled) { return; } /* Check throttling due to write errors */ if (rspamd_log->throttling) { now = time (NULL); if (rspamd_log->throttling_time != now) { rspamd_log->throttling_time = now; got_time = TRUE; } else { /* Do not try to write to file too often while throttling */ return; } } /* Check repeats */ mlen = strlen (message); cksum = rspamd_log_calculate_cksum (message, mlen); if (cksum == rspamd_log->last_line_cksum) { rspamd_log->repeats++; if (rspamd_log->repeats > REPEATS_MIN && rspamd_log->repeats < REPEATS_MAX) { /* Do not log anything */ if (rspamd_log->saved_message == NULL) { rspamd_log->saved_message = g_strdup (message); rspamd_log->saved_function = g_strdup (function); if (module) { rspamd_log->saved_module = g_strdup (module); } if (id) { rspamd_log->saved_id = g_strdup (id); } rspamd_log->saved_loglevel = level_flags; } return; } else if (rspamd_log->repeats > REPEATS_MAX) { rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats); rspamd_log->repeats = 0; /* It is safe to use temporary buffer here as it is not static */ if (rspamd_log->saved_message) { file_log_function (rspamd_log->saved_module, rspamd_log->saved_id, rspamd_log->saved_function, rspamd_log->saved_loglevel, rspamd_log->saved_message, arg); g_free (rspamd_log->saved_message); g_free (rspamd_log->saved_function); g_free (rspamd_log->saved_module); g_free (rspamd_log->saved_id); rspamd_log->saved_message = NULL; rspamd_log->saved_function = NULL; rspamd_log->saved_module = NULL; rspamd_log->saved_id = NULL; } file_log_function ("logger", NULL, G_STRFUNC, rspamd_log->saved_loglevel, tmpbuf, arg); file_log_function (module, id, function, level_flags, message, arg); rspamd_log->repeats = REPEATS_MIN + 1; return; } } else { /* Reset counter if new message differs from saved message */ rspamd_log->last_line_cksum = cksum; if (rspamd_log->repeats > REPEATS_MIN) { rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "Last message repeated %ud times", rspamd_log->repeats); rspamd_log->repeats = 0; if (rspamd_log->saved_message) { file_log_function (rspamd_log->saved_module, rspamd_log->saved_id, rspamd_log->saved_function, rspamd_log->saved_loglevel, rspamd_log->saved_message, arg); g_free (rspamd_log->saved_message); g_free (rspamd_log->saved_function); g_free (rspamd_log->saved_module); g_free (rspamd_log->saved_id); rspamd_log->saved_message = NULL; rspamd_log->saved_function = NULL; rspamd_log->saved_module = NULL; rspamd_log->saved_id = NULL; } file_log_function ("logger", NULL, G_STRFUNC, level_flags, tmpbuf, arg); /* It is safe to use temporary buffer here as it is not static */ file_log_function (module, id, function, level_flags, message, arg); return; } else { rspamd_log->repeats = 0; } } if (rspamd_log->cfg->log_extended) { if (!got_time) { now = time (NULL); } /* Format time */ if (!rspamd_log->cfg->log_systemd) { tms = localtime (&now); strftime (timebuf, sizeof (timebuf), "%F %H:%M:%S", tms); } cptype = g_quark_to_string (rspamd_log->process_type); if (rspamd_log->cfg->log_color) { if (level_flags & G_LOG_LEVEL_INFO) { /* White */ r = rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "\033[0;37m"); } else if (level_flags & G_LOG_LEVEL_WARNING) { /* Magenta */ r = rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "\033[0;32m"); } else if (level_flags & G_LOG_LEVEL_CRITICAL) { /* Red */ r = rspamd_snprintf (tmpbuf, sizeof (tmpbuf), "\033[1;31m"); } } else { r = 0; } if (!rspamd_log->cfg->log_systemd) { r += rspamd_snprintf (tmpbuf + r, sizeof (tmpbuf) - r, "%s #%P(%s) ", timebuf, rspamd_log->pid, cptype); } else { r += rspamd_snprintf (tmpbuf + r, sizeof (tmpbuf) - r, "(%s) ", cptype); } modulebuf[0] = '\0'; mremain = sizeof (modulebuf); m = modulebuf; if (id != NULL) { mr = rspamd_snprintf (m, mremain, "<%*.s>; ", LOG_ID, id); m += mr; mremain -= mr; } if (module != NULL) { mr = rspamd_snprintf (m, mremain, "%s; ", module); m += mr; mremain -= mr; } if (function != NULL) { mr = rspamd_snprintf (m, mremain, "%s: ", function); m += mr; mremain -= mr; } else { mr = rspamd_snprintf (m, mremain, ": "); m += mr; mremain -= mr; } /* Construct IOV for log line */ iov[0].iov_base = tmpbuf; iov[0].iov_len = r; iov[1].iov_base = modulebuf; iov[1].iov_len = m - modulebuf; iov[2].iov_base = (void *) message; iov[2].iov_len = mlen; iov[3].iov_base = (void *) &lf_chr; iov[3].iov_len = 1; if (rspamd_log->cfg->log_color) { iov[4].iov_base = "\033[0m"; iov[4].iov_len = sizeof ("\033[0m") - 1; /* Call helper (for buffering) */ file_log_helper (rspamd_log, iov, 5); } else { /* Call helper (for buffering) */ file_log_helper (rspamd_log, iov, 4); } } else { iov[0].iov_base = (void *) message; iov[0].iov_len = mlen; iov[1].iov_base = (void *) &lf_chr; iov[1].iov_len = 1; if (rspamd_log->cfg->log_color) { iov[2].iov_base = "\033[0m"; iov[2].iov_len = sizeof ("\033[0m") - 1; /* Call helper (for buffering) */ file_log_helper (rspamd_log, iov, 3); } else { /* Call helper (for buffering) */ file_log_helper (rspamd_log, iov, 2); } } }
static GwyContainer* rhk_sm4_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { RHKFile rhkfile; RHKObject *obj, o; GwyContainer *meta, *container = NULL; guchar *buffer = NULL; gsize size = 0; GError *err = NULL; const guchar *p; GString *key = NULL; guint i, imageid = 0, graphid = 0; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } gwy_clear(&rhkfile, 1); if (size < HEADER_SIZE) { err_TOO_SHORT(error); goto fail; } /* File header */ p = buffer + MAGIC_OFFSET + MAGIC_TOTAL_SIZE; rhkfile.page_count = gwy_get_guint32_le(&p); rhkfile.object_count = gwy_get_guint32_le(&p); rhkfile.object_field_size = gwy_get_guint32_le(&p); gwy_debug("page_count: %u, object_count: %u, object_field_size: %u", rhkfile.page_count, rhkfile.object_count, rhkfile.object_field_size); if (rhkfile.object_field_size != OBJECT_SIZE) g_warning("Object field size %u differs from %u", rhkfile.object_field_size, OBJECT_SIZE); rhkfile.reserved1 = gwy_get_guint32_le(&p); rhkfile.reserved2 = gwy_get_guint32_le(&p); /* Header objects */ if (!(rhkfile.objects = rhk_sm4_read_objects(buffer, p, size, rhkfile.object_count, RHK_OBJECT_FILE_HEADER, error))) goto fail; /* Find page index header */ if (!(obj = rhk_sm4_find_object(rhkfile.objects, rhkfile.object_count, RHK_OBJECT_PAGE_INDEX_HEADER, RHK_OBJECT_FILE_HEADER, error)) || !rhk_sm4_read_page_index_header(&rhkfile.page_index_header, obj, buffer, size, error)) goto fail; /* There, find the page index array. That's a single object in the object * list but it contains a page_count-long sequence of page indices. */ rhkfile.page_indices = g_new0(RHKPageIndex, rhkfile.page_index_header.page_count); if (!(obj = rhk_sm4_find_object(rhkfile.page_index_header.objects, rhkfile.page_index_header.object_count, RHK_OBJECT_PAGE_INDEX_ARRAY, RHK_OBJECT_PAGE_INDEX_HEADER, error))) goto fail; o = *obj; for (i = 0; i < rhkfile.page_index_header.page_count; i++) { if (!rhk_sm4_read_page_index(rhkfile.page_indices + i, &o, buffer, size, error)) goto fail; /* Carefully move to the next page index */ o.offset += o.size + OBJECT_SIZE*rhkfile.page_indices[i].object_count; } container = gwy_container_new(); key = g_string_new(NULL); /* Read pages */ for (i = 0; i < rhkfile.page_index_header.page_count; i++) { RHKPageIndex *pi = rhkfile.page_indices + i; RHKPage *page = &pi->page; /* Page must contain header */ if (!(obj = rhk_sm4_find_object(pi->objects, pi->object_count, RHK_OBJECT_PAGE_HEADER, RHK_OBJECT_PAGE_INDEX, error)) || !rhk_sm4_read_page_header(page, obj, buffer, size, error)) goto fail; /* Page must contain data */ if (!(obj = rhk_sm4_find_object(pi->objects, pi->object_count, RHK_OBJECT_PAGE_DATA, RHK_OBJECT_PAGE_INDEX, error)) || !rhk_sm4_read_page_data(page, obj, buffer, error)) goto fail; /* Page may contain strings */ if (!(obj = rhk_sm4_find_object(page->objects, page->object_count, RHK_OBJECT_STRING_DATA, RHK_OBJECT_PAGE_HEADER, NULL)) || !rhk_sm4_read_string_data(page, obj, pi->page.string_count, buffer)) { g_warning("Failed to read string data in page %u", i); } /* Read the data */ if (pi->data_type == RHK_DATA_IMAGE) { GwyDataField *dfield = rhk_sm4_page_to_data_field(page); GQuark quark = gwy_app_get_data_key_for_id(imageid); const gchar *scandir, *name; gchar *title; gwy_container_set_object(container, quark, dfield); g_object_unref(dfield); if ((name = page->strings[RHK_STRING_LABEL])) { scandir = gwy_enum_to_string(page->scan_dir, scan_directions, G_N_ELEMENTS(scan_directions)); g_string_assign(key, g_quark_to_string(quark)); g_string_append(key, "/title"); if (scandir && *scandir) title = g_strdup_printf("%s [%s]", name, scandir); else title = g_strdup(name); gwy_container_set_string_by_name(container, key->str, title); } meta = rhk_sm4_get_metadata(pi, page); g_string_printf(key, "/%u/meta", imageid); gwy_container_set_object_by_name(container, key->str, meta); g_object_unref(meta); imageid++; } else if (pi->data_type == RHK_DATA_LINE) { GwyGraphModel *gmodel; RHKSpecDriftHeader *drift_header = NULL; RHKSpecInfo *spec_infos = NULL; gwy_debug("page_type %u", page->page_type); gwy_debug("line_type %u", page->line_type); gwy_debug("page_sizes %u %u", page->x_size, page->y_size); /* Page may contain drift header */ if ((obj = rhk_sm4_find_object(page->objects, page->object_count, RHK_OBJECT_SPEC_DRIFT_HEADER, RHK_OBJECT_PAGE_HEADER, NULL))) drift_header = rhk_sm4_read_drift_header(obj, buffer); if ((obj = rhk_sm4_find_object(page->objects, page->object_count, RHK_OBJECT_SPEC_DRIFT_DATA, RHK_OBJECT_PAGE_HEADER, NULL))) spec_infos = rhk_sm4_read_spec_info(obj, buffer, size, page->y_size); /* FIXME: RHK_STRING_PLL_PRO_STATUS may contain interesting * metadata. But we have no place where to put it. */ if ((gmodel = rhk_sm4_page_to_graph_model(page))) { graphid++; gwy_container_set_object(container, gwy_app_get_graph_key_for_id(graphid), gmodel); g_object_unref(gmodel); } g_free(spec_infos); g_free(drift_header); } } if (!imageid && !graphid) err_NO_DATA(error); fail: gwy_file_abandon_contents(buffer, size, NULL); rhk_sm4_free(&rhkfile); if (!imageid && !graphid) { gwy_object_unref(container); } if (key) g_string_free(key, TRUE); return container; }