Example #1
0
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;
}
Example #3
0
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;
}
Example #5
0
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"
}
Example #6
0
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);
}
Example #13
0
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;
}
Example #14
0
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;
}
Example #15
0
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);

}
Example #16
0
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 ();
			}
		}
	}
}
Example #17
0
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;
	}
}
Example #18
0
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;
}
Example #19
0
static void
datalist_encode_foreach (GQuark key_id, gpointer value, gpointer str)
{
	encode_pair (str, g_quark_to_string (key_id), value);
}
Example #20
0
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;
}
Example #22
0
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);
    }
}
Example #23
0
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;
}
Example #24
0
/* 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;
}
Example #25
0
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);
}
Example #27
0
ResourceError ResourceError::genericIOError(GError* error, SoupRequest* request)
{
    return ResourceError(g_quark_to_string(G_IO_ERROR), error->code,
        failingURI(request), String::fromUTF8(error->message));
}
Example #28
0
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;
}
Example #29
0
/**
 * 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);
		}
	}
}
Example #30
0
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;
}