static void
setup_reannouncement_timeout (GSSDPResourceGroup *resource_group)
{
int timeout;
GSSDPResourceGroupPrivate *priv;
priv = gssdp_resource_group_get_instance_private (resource_group);
/* We want to re-announce at least 3 times before the resource
* group expires to cope with the unrelialble nature of UDP.
*
* Read the paragraphs about 'CACHE-CONTROL' on pages 21-22 of
* UPnP Device Architecture Document v1.1 for further details.
* */
timeout = priv->max_age;
if (G_LIKELY (timeout > 6))
timeout = (timeout / 3) - 1;
/* Add re-announcement timer */
priv->timeout_src = g_timeout_source_new_seconds (timeout);
g_source_set_callback (priv->timeout_src,
resource_group_timeout,
resource_group, NULL);
g_source_attach (priv->timeout_src,
g_main_context_get_thread_default ());
g_source_unref (priv->timeout_src);
}
static gboolean
discovery_timeout (gpointer data)
{
GSSDPResourceBrowserPrivate *priv;
GSSDPResourceBrowser *resource_browser;
resource_browser = GSSDP_RESOURCE_BROWSER (data);
priv = gssdp_resource_browser_get_instance_private (resource_browser);
send_discovery_request (resource_browser);
priv->num_discovery += 1;
if (priv->num_discovery >= MAX_DISCOVERY_MESSAGES) {
priv->timeout_src = NULL;
priv->num_discovery = 0;
/* Setup cache refreshing */
priv->refresh_cache_src =
g_timeout_source_new_seconds (RESCAN_TIMEOUT);
g_source_set_callback
(priv->refresh_cache_src,
refresh_cache,
resource_browser,
NULL);
g_source_attach (priv->refresh_cache_src,
g_main_context_get_thread_default ());
g_source_unref (priv->refresh_cache_src);
return FALSE;
} else
return TRUE;
}
static void
reset_shutdown_timeout (TrackerController *controller)
{
TrackerControllerPrivate *priv;
GSource *source;
priv = controller->priv;
if (priv->shutdown_timeout == 0) {
return;
}
#ifdef STAYALIVE_ENABLE_TRACE
g_debug ("Stayalive --- (Re)setting timeout");
#endif /* STAYALIVE_ENABLE_TRACE */
if (priv->shutdown_source) {
g_source_destroy (priv->shutdown_source);
priv->shutdown_source = NULL;
}
source = g_timeout_source_new_seconds (priv->shutdown_timeout);
g_source_set_callback (source,
reset_shutdown_timeout_cb,
controller, NULL);
g_source_attach (source, priv->context);
priv->shutdown_source = source;
}
static void
callback (SoupSession * session, SoupMessage * msg, gpointer user_data)
{
GstSoupHttpClientSink *souphttpsink = GST_SOUP_HTTP_CLIENT_SINK (user_data);
GST_DEBUG_OBJECT (souphttpsink, "callback status=%d %s",
msg->status_code, msg->reason_phrase);
g_mutex_lock (&souphttpsink->mutex);
g_cond_signal (&souphttpsink->cond);
souphttpsink->message = NULL;
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
souphttpsink->failures++;
if (souphttpsink->retries &&
(souphttpsink->retries < 0 ||
souphttpsink->retries >= souphttpsink->failures)) {
guint64 retry_delay;
const char *retry_after =
soup_message_headers_get_one (msg->response_headers,
"Retry-After");
if (retry_after) {
gchar *end = NULL;
retry_delay = g_ascii_strtoull (retry_after, &end, 10);
if (end || errno) {
retry_delay = souphttpsink->retry_delay;
} else {
retry_delay = MAX (retry_delay, souphttpsink->retry_delay);
}
GST_WARNING_OBJECT (souphttpsink, "Could not write to HTTP URI: "
"status: %d %s (retrying PUT after %" G_GINT64_FORMAT
" seconds with Retry-After: %s)", msg->status_code,
msg->reason_phrase, retry_delay, retry_after);
} else {
retry_delay = souphttpsink->retry_delay;
GST_WARNING_OBJECT (souphttpsink, "Could not write to HTTP URI: "
"status: %d %s (retrying PUT after %" G_GINT64_FORMAT
" seconds)", msg->status_code, msg->reason_phrase, retry_delay);
}
souphttpsink->timer = g_timeout_source_new_seconds (retry_delay);
g_source_set_callback (souphttpsink->timer, (GSourceFunc) (send_message),
souphttpsink, NULL);
g_source_attach (souphttpsink->timer, souphttpsink->context);
} else {
souphttpsink->status_code = msg->status_code;
souphttpsink->reason_phrase = g_strdup (msg->reason_phrase);
}
g_mutex_unlock (&souphttpsink->mutex);
return;
}
g_list_free_full (souphttpsink->sent_buffers,
(GDestroyNotify) gst_buffer_unref);
souphttpsink->sent_buffers = NULL;
souphttpsink->failures = 0;
send_message_locked (souphttpsink);
g_mutex_unlock (&souphttpsink->mutex);
}
static void initMallocStatsCb(GMainLoop* mainLoop, int secs)
{
// negative means no stats
if ((secs < 0) || (s_mallocStatsFileStr == NULL)) return;
GSource *timeoutSource = g_timeout_source_new_seconds(secs);
g_source_set_callback(timeoutSource, mallocStatsCb, NULL, NULL);
g_source_attach(timeoutSource, g_main_loop_get_context(mainLoop));
}
GSource *
io_thread_timeout_add_seconds(guint interval,
GSourceFunc function, gpointer data)
{
GSource *source = g_timeout_source_new_seconds(interval);
g_source_set_callback(source, function, data, NULL);
g_source_attach(source, io.context);
return source;
}
static void
_service_proxy_added_port_mapping (GUPnPServiceProxy *proxy,
GUPnPServiceProxyAction *action,
gpointer user_data)
{
struct ProxyMapping *pm = user_data;
GUPnPSimpleIgd *self = pm->proxy->parent;
GError *error = NULL;
g_return_if_fail (pm->action == action);
pm->action = NULL;
if (gupnp_service_proxy_end_action (proxy, action, &error,
NULL))
{
pm->mapped = TRUE;
if (pm->proxy->external_ip)
g_signal_emit (self, signals[SIGNAL_MAPPED_EXTERNAL_PORT], 0,
pm->mapping->protocol, pm->proxy->external_ip, NULL,
pm->actual_external_port, pm->mapping->local_ip,
pm->mapping->local_port, pm->mapping->description);
if (pm->mapping->lease_duration > 0)
{
pm->renew_src =
g_timeout_source_new_seconds (pm->mapping->lease_duration / 2);
g_source_set_callback (pm->renew_src,
_renew_mapping_timeout, pm, NULL);
g_source_attach (pm->renew_src, self->priv->main_context);
}
}
else
{
g_return_if_fail (error);
/* 718 == ConflictInMappingEntry */
if (pm->mapping->requested_external_port == 0 &&
error->domain == GUPNP_CONTROL_ERROR && error->code == 718)
{
/* The previous port was already used, lets pick another random port */
pm->actual_external_port = g_random_int_range (1025, 65535);
gupnp_simple_igd_call_add_port_mapping (pm,
_service_proxy_added_port_mapping);
}
else
{
g_signal_emit (self, signals[SIGNAL_ERROR_MAPPING_PORT], error->domain,
error, pm->mapping->protocol, pm->mapping->requested_external_port,
pm->mapping->local_ip, pm->mapping->local_port,
pm->mapping->description);
}
}
g_clear_error (&error);
}
/**
* gssdp_resource_group_set_available:
* @resource_group: A #GSSDPResourceGroup
* @available: TRUE if @resource_group should be available (advertised)
*
* Sets @resource_group<!-- -->s availability to @available. Changing
* @resource_group<!-- -->s availability causes it to announce its new state
* to listening SSDP clients.
**/
void
gssdp_resource_group_set_available (GSSDPResourceGroup *resource_group,
gboolean available)
{
g_return_if_fail (GSSDP_IS_RESOURCE_GROUP (resource_group));
if (resource_group->priv->available == available)
return;
resource_group->priv->available = available;
if (available) {
int timeout;
/* We want to re-announce at least 3 times before the resource
* group expires to cope with the unrelialble nature of UDP.
*
* Read the paragraphs about 'CACHE-CONTROL' on pages 21-22 of
* UPnP Device Architecture Document v1.1 for further details.
* */
timeout = resource_group->priv->max_age;
if (G_LIKELY (timeout > 6))
timeout = (timeout / 3) - 1;
/* Add re-announcement timer */
resource_group->priv->timeout_src =
g_timeout_source_new_seconds (timeout);
g_source_set_callback (resource_group->priv->timeout_src,
resource_group_timeout,
resource_group, NULL);
g_source_attach (resource_group->priv->timeout_src,
g_main_context_get_thread_default ());
g_source_unref (resource_group->priv->timeout_src);
/* Make sure initial byebyes are sent grouped before initial
* alives */
send_announcement_set (resource_group->priv->resources,
(GFunc) send_initial_resource_byebye);
send_announcement_set (resource_group->priv->resources,
(GFunc) resource_alive);
} else {
/* Unannounce all resources */
send_announcement_set (resource_group->priv->resources,
(GFunc) resource_byebye);
/* Remove re-announcement timer */
g_source_destroy (resource_group->priv->timeout_src);
resource_group->priv->timeout_src = NULL;
}
g_object_notify (G_OBJECT (resource_group), "available");
}
static void
clock_set_timeout (MidoriBrowser* browser,
guint interval)
{
GSource* source;
source = g_timeout_source_new_seconds (interval);
g_source_set_callback (source, (GSourceFunc)clock_set_current_time, browser, NULL);
g_source_attach (source, NULL);
g_object_set_data (G_OBJECT (browser), "clock-timer", source);
g_source_unref (source);
}
void WebAppDeferredUpdateHandler::startIdleUpdateTimer()
{
if (s_paintSource)
return;
//printf("%s", __PRETTY_FUNCTION__);
s_paintSource = g_timeout_source_new_seconds(kPaintTimeOutSecs);
g_source_set_callback(s_paintSource, WebAppDeferredUpdateHandler::paintSourceCallback,
NULL, NULL);
g_source_attach(s_paintSource, g_main_context_default());
}
GSource* gattlib_timeout_add_seconds(guint interval, GSourceFunc function, gpointer data) {
GSource *source = g_timeout_source_new_seconds(interval);
assert(source != NULL);
g_source_set_callback(source, function, data, NULL);
// Attaches it to the main loop context
guint id = g_source_attach(source, g_gattlib_thread.loop_context);
g_source_unref (source);
assert(id != 0);
return source;
}
static void
gum_jsc_script_backend_unignore_later (GumScriptBackend * backend,
GumThreadId thread_id)
{
GumJscScriptBackend * self = GUM_JSC_SCRIPT_BACKEND (backend);
GumJscScriptBackendPrivate * priv = self->priv;
GMainContext * main_context;
GSource * source;
main_context = gum_script_scheduler_get_js_context (
gum_jsc_script_backend_get_scheduler (self));
gum_interceptor_ignore_current_thread (priv->interceptor);
g_rw_lock_writer_lock (&priv->ignored_lock);
priv->pending_unignores = g_slist_prepend (priv->pending_unignores,
GSIZE_TO_POINTER (thread_id));
source = priv->pending_timeout;
priv->pending_timeout = NULL;
g_rw_lock_writer_unlock (&priv->ignored_lock);
if (source != NULL)
{
g_source_destroy (source);
g_source_unref (source);
}
source = g_timeout_source_new_seconds (5);
g_source_set_callback (source, gum_flush_pending_unignores, self, NULL);
g_source_attach (source, main_context);
g_rw_lock_writer_lock (&priv->ignored_lock);
if (priv->pending_timeout == NULL)
{
priv->pending_timeout = source;
source = NULL;
}
g_rw_lock_writer_unlock (&priv->ignored_lock);
if (source != NULL)
{
g_source_destroy (source);
g_source_unref (source);
}
gum_interceptor_unignore_current_thread (priv->interceptor);
}
guint
i_timeout_add_seconds (guint interval, GSourceFunc function, gpointer data, GMainContext* context)
{
GSource* source;
guint id;
g_return_val_if_fail(function != NULL, 0);
source = g_timeout_source_new_seconds(interval);
g_source_set_callback(source, function, data, NULL);
id = g_source_attach(source, context);
g_source_unref(source);
return id;
}
void TimeoutBase::Arm()
{
LOG_TRACE("Entering function %s", __FUNCTION__);
if (m_timeout) {
Cancel();
}
GSource *timeout = g_timeout_source_new_seconds((guint)m_seconds);
g_source_set_callback(timeout, TimeoutBase::StaticWakeupTimeout, this,
NULL);
g_source_attach(timeout, g_main_context_default());
m_timeout = timeout;
}
void GMainLoopSource::scheduleAfterDelay(const char* name, std::function<bool ()> function, std::chrono::seconds delay, int priority, std::function<void ()> destroyFunction, GMainContext* context)
{
cancel();
ASSERT(!m_context.source);
m_context = {
adoptGRef(g_timeout_source_new_seconds(delay.count())),
nullptr, // cancellable
nullptr, // socketCancellable
nullptr, // voidCallback
WTF::move(function),
nullptr, // socketCallback
WTF::move(destroyFunction)
};
scheduleTimeoutSource(name, reinterpret_cast<GSourceFunc>(boolSourceCallback), priority, context);
}
static void
cockpit_request_start (CockpitWebServer *self,
GIOStream *io,
gboolean first)
{
GSocketConnection *connection;
CockpitRequest *request;
gboolean input = TRUE;
GSocket *socket;
request = g_new0 (CockpitRequest, 1);
request->web_server = self;
request->io = g_object_ref (io);
request->buffer = g_byte_array_new ();
/* Right before a successive request, EOF is not unexpected */
request->eof_okay = !first;
request->timeout = g_timeout_source_new_seconds (cockpit_webserver_request_timeout);
g_source_set_callback (request->timeout, on_request_timeout, request, NULL);
g_source_attach (request->timeout, self->main_context);
if (first)
{
connection = G_SOCKET_CONNECTION (io);
socket = g_socket_connection_get_socket (connection);
g_socket_set_blocking (socket, FALSE);
if (self->certificate)
{
request->source = g_socket_create_source (g_socket_connection_get_socket (connection),
G_IO_IN, NULL);
g_source_set_callback (request->source, (GSourceFunc)on_socket_input, request, NULL);
g_source_attach (request->source, self->main_context);
/* Wait on reading input */
input = FALSE;
}
}
/* Owns the request */
g_hash_table_add (self->requests, request);
if (input)
start_request_input (request);
}
static gboolean
on_new_connection (GSocketService * service, GSocketConnection * connection,
GObject * source_object, gpointer user_data)
{
Client *client = g_slice_new0 (Client);
GSocketAddress *addr;
GInetAddress *iaddr;
gchar *ip;
guint16 port;
addr = g_socket_connection_get_remote_address (connection, NULL);
iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr));
port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
ip = g_inet_address_to_string (iaddr);
client->name = g_strdup_printf ("%s:%u", ip, port);
g_free (ip);
g_object_unref (addr);
g_print ("New connection %s\n", client->name);
client->connection = (GSocketConnection *) g_object_ref (connection);
client->socket = g_socket_connection_get_socket (connection);
client->istream =
g_io_stream_get_input_stream (G_IO_STREAM (client->connection));
client->ostream =
g_io_stream_get_output_stream (G_IO_STREAM (client->connection));
client->current_message = g_byte_array_sized_new (1024);
client->tosource = g_timeout_source_new_seconds (5);
g_source_set_callback (client->tosource, (GSourceFunc) on_timeout, client,
NULL);
g_source_attach (client->tosource, NULL);
client->isource =
g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM
(client->istream), NULL);
g_source_set_callback (client->isource, (GSourceFunc) on_read_bytes, client,
NULL);
g_source_attach (client->isource, NULL);
G_LOCK (clients);
clients = g_list_prepend (clients, client);
G_UNLOCK (clients);
return TRUE;
}
static void
ide_omni_bar_constructed (GObject *object)
{
IdeOmniBar *self = (IdeOmniBar *)object;
g_assert (IDE_IS_OMNI_BAR (self));
G_OBJECT_CLASS (ide_omni_bar_parent_class)->constructed (object);
/*
* Start our looper, to loop through available messages.
* We will release this in destroy.
*/
self->looper_source = g_timeout_source_new_seconds (LOOPER_INTERVAL_SECONDS);
g_source_set_callback (self->looper_source, ide_omni_bar_looper_cb, self, NULL);
g_source_set_name (self->looper_source, "[ide] omnibar message looper");
g_source_attach (self->looper_source, NULL);
}
static gboolean mouse_motion (GtkWidget *widget, GdkEventMotion *event, AnypaperPreview *preview)
{
if (!GTK_WIDGET_VISIBLE (preview->priv->hbox))
{
gtk_widget_show(preview->priv->hbox);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(preview->priv->window2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
}
if (preview->priv->state == WINDOW_FULLSCREEN_STATE)
{
timeout_destroy(preview->priv->source);
preview->priv->source = g_timeout_source_new_seconds (WINDOW_FULLSCREEN_TIMEOUT);
g_source_set_callback (preview->priv->source, fullscreen_timeout_cb, preview, NULL);
g_source_attach (preview->priv->source, NULL);
}
}
gboolean
ot_admin_sysroot_lock (OstreeSysroot *sysroot,
GError **error)
{
gboolean ret = FALSE;
gboolean acquired;
struct ContextState state = {
.mainctx = g_main_context_new (),
.running = TRUE,
};
g_main_context_push_thread_default (state.mainctx);
if (!ostree_sysroot_try_lock (sysroot, &acquired, error))
goto out;
if (!acquired)
{
GSource *timeout_src = g_timeout_source_new_seconds (3);
g_source_set_callback (timeout_src, (GSourceFunc)on_sysroot_lock_timeout, &state, NULL);
g_source_attach (timeout_src, state.mainctx);
g_source_unref (timeout_src);
on_sysroot_lock_timeout (&state);
ostree_sysroot_lock_async (sysroot, NULL, (GAsyncReadyCallback)on_sysroot_lock_acquired, &state);
while (state.running)
g_main_context_iteration (state.mainctx, TRUE);
}
ret = TRUE;
out:
g_main_context_pop_thread_default (state.mainctx);
g_main_context_unref (state.mainctx);
return ret;
}
static gboolean
run_mainloop_monitor_fetcher (OtPullData *pull_data)
{
GSource *update_timeout = NULL;
GSource *idle_src;
if (pull_data->progress)
{
update_timeout = g_timeout_source_new_seconds (1);
g_source_set_callback (update_timeout, update_progress, pull_data, NULL);
g_source_attach (update_timeout, g_main_loop_get_context (pull_data->loop));
g_source_unref (update_timeout);
}
idle_src = g_idle_source_new ();
g_source_set_callback (idle_src, idle_check_outstanding_requests, pull_data, NULL);
g_source_attach (idle_src, pull_data->main_context);
g_main_loop_run (pull_data->loop);
if (update_timeout)
g_source_destroy (update_timeout);
return !pull_data->caught_error;
}
/* inotify_lock must be held before calling */
void
_im_add (inotify_sub *sub)
{
if (g_list_find (missing_sub_list, sub))
{
IM_W ("asked to add %s to missing list but it's already on the list!\n", sub->dirname);
return;
}
IM_W ("adding %s to missing list\n", sub->dirname);
missing_sub_list = g_list_prepend (missing_sub_list, sub);
/* If the timeout is turned off, we turn it back on */
if (!scan_missing_running)
{
GSource *source;
scan_missing_running = TRUE;
source = g_timeout_source_new_seconds (SCAN_MISSING_TIME);
g_source_set_callback (source, im_scan_missing, NULL, NULL);
g_source_attach (source, GLIB_PRIVATE_CALL (g_get_worker_context) ());
g_source_unref (source);
}
}
static void
test_g_source (void)
{
g_autoptr(GSource) val = g_timeout_source_new_seconds (2);
g_assert (val != NULL);
}
static void
gimp_display_shell_close_dialog (GimpDisplayShell *shell,
GimpImage *image)
{
GtkWidget *dialog;
GimpMessageBox *box;
GtkWidget *label;
GtkAccelGroup *accel_group;
GClosure *closure;
GSource *source;
guint accel_key;
GdkModifierType accel_mods;
gchar *title;
gchar *accel_string;
gchar *hint;
gchar *markup;
GFile *file;
if (shell->close_dialog)
{
gtk_window_present (GTK_WINDOW (shell->close_dialog));
return;
}
file = gimp_image_get_file (image);
title = g_strdup_printf (_("Close %s"), gimp_image_get_display_name (image));
shell->close_dialog =
dialog = gimp_message_dialog_new (title, "document-save",
GTK_WIDGET (shell),
GTK_DIALOG_DESTROY_WITH_PARENT,
gimp_standard_help_func, NULL,
NULL);
g_free (title);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("_Discard Changes"), GTK_RESPONSE_CLOSE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
(file ?
GTK_STOCK_SAVE :
GTK_STOCK_SAVE_AS), RESPONSE_SAVE,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_SAVE,
GTK_RESPONSE_CLOSE,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&shell->close_dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (gimp_display_shell_close_response),
shell);
/* connect <Primary>D to the quit/close button */
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (shell->close_dialog), accel_group);
g_object_unref (accel_group);
closure = g_closure_new_object (sizeof (GClosure),
G_OBJECT (shell->close_dialog));
g_closure_set_marshal (closure, gimp_display_shell_close_accel_marshal);
gtk_accelerator_parse ("<Primary>D", &accel_key, &accel_mods);
gtk_accel_group_connect (accel_group, accel_key, accel_mods, 0, closure);
box = GIMP_MESSAGE_DIALOG (dialog)->box;
accel_string = gtk_accelerator_get_label (accel_key, accel_mods);
hint = g_strdup_printf (_("Press %s to discard all changes and close the image."),
accel_string);
markup = g_strdup_printf ("<i><small>%s</small></i>", hint);
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_markup (GTK_LABEL (label), markup);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (markup);
g_free (hint);
g_free (accel_string);
g_signal_connect_object (image, "name-changed",
G_CALLBACK (gimp_display_shell_close_name_changed),
box, 0);
g_signal_connect_object (image, "exported",
G_CALLBACK (gimp_display_shell_close_exported),
box, 0);
gimp_display_shell_close_name_changed (image, box);
closure =
g_cclosure_new_object (G_CALLBACK (gimp_display_shell_close_time_changed),
G_OBJECT (box));
/* update every 10 seconds */
source = g_timeout_source_new_seconds (10);
g_source_set_closure (source, closure);
g_source_attach (source, NULL);
g_source_unref (source);
/* The dialog is destroyed with the shell, so it should be safe
* to hold an image pointer for the lifetime of the dialog.
*/
g_object_set_data (G_OBJECT (box), "gimp-image", image);
gimp_display_shell_close_time_changed (box);
gtk_widget_show (dialog);
}
gboolean
fs_rawudp_component_gather_local_candidates (FsRawUdpComponent *self,
GError **error)
{
if (self->priv->gathered)
{
g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,
"Call gather local candidates twice on the same component");
return FALSE;
}
if (!self->priv->udpport)
{ g_set_error (error, FS_ERROR, FS_ERROR_INVALID_ARGUMENTS,
"You can not call gather_local_candidate() after the stream has"
" been stopped");
return FALSE;
}
#ifdef HAVE_GUPNP
if (self->priv->upnp_igd &&
(self->priv->upnp_mapping || self->priv->upnp_discovery))
{
guint port;
GList *ips;
port = fs_rawudp_transmitter_udpport_get_port (self->priv->udpport);
ips = nice_interfaces_get_local_ips (FALSE);
ips = filter_ips (ips, TRUE, FALSE);
if (ips)
{
gchar *ip = g_list_first (ips)->data;
GMainContext *ctx;
if (self->priv->upnp_discovery)
{
FS_RAWUDP_COMPONENT_LOCK (self);
self->priv->upnp_signal_id = g_signal_connect (self->priv->upnp_igd,
"mapped-external-port",
G_CALLBACK (_upnp_mapped_external_port), self);
FS_RAWUDP_COMPONENT_UNLOCK (self);
}
GST_DEBUG ("Doing UPnP Discovery for local ip:%s port:%u", ip, port);
gupnp_simple_igd_add_port (GUPNP_SIMPLE_IGD (self->priv->upnp_igd),
"UDP", port, ip, port, self->priv->upnp_mapping_timeout,
"Farstream Raw UDP transmitter " PACKAGE_VERSION);
if (self->priv->upnp_discovery)
{
FS_RAWUDP_COMPONENT_LOCK (self);
self->priv->upnp_discovery_timeout_src = g_timeout_source_new_seconds (
self->priv->upnp_discovery_timeout);
g_source_set_callback (self->priv->upnp_discovery_timeout_src,
_upnp_discovery_timeout, self, NULL);
g_object_get (self->priv->upnp_igd, "main-context", &ctx, NULL);
g_source_attach (self->priv->upnp_discovery_timeout_src, ctx);
FS_RAWUDP_COMPONENT_UNLOCK (self);
}
}
else
{
FS_RAWUDP_COMPONENT_LOCK (self);
fs_rawudp_component_stop_upnp_discovery_locked (self);
FS_RAWUDP_COMPONENT_UNLOCK (self);
}
/* free list of ips */
g_list_foreach (ips, (GFunc) g_free, NULL);
g_list_free (ips);
}
#endif
if (self->priv->stun_ip)
return fs_rawudp_component_start_stun (self, error);
#ifdef HAVE_GUPNP
else if (!self->priv->upnp_signal_id)
return fs_rawudp_component_emit_local_candidates (self, error);
else
return TRUE;
#else
else
return fs_rawudp_component_emit_local_candidates (self, error);
static gboolean
VmBackupStartCommon(RpcInData *data,
gboolean forceVss)
{
GError *err = NULL;
ToolsAppCtx *ctx = data->appCtx;
VmBackupSyncProvider *provider = NULL;
size_t i;
/* List of available providers, in order of preference for loading. */
struct SyncProvider {
VmBackupSyncProvider *(*ctor)(void);
const gchar *cfgEntry;
} providers[] = {
#if defined(_WIN32)
{ VmBackup_NewVssProvider, "enableVSS" },
#endif
{ VmBackup_NewSyncDriverProvider, "enableSyncDriver" },
{ VmBackup_NewNullProvider, NULL },
};
if (forceVss) {
if (gBackupState->quiesceApps || gBackupState->quiesceFS) {
/* If quiescing is requested, only allow VSS provider */
#if defined(_WIN32)
if (VmBackupConfigGetBoolean(ctx->config, "enableVSS", TRUE)) {
provider = VmBackup_NewVssProvider();
}
#endif
} else {
/* If no quiescing is requested only allow null provider */
provider = VmBackup_NewNullProvider();
}
if (provider == NULL) {
g_warning("Requested quiescing cannot be initialized.");
goto error;
}
} else {
/* Instantiate the sync provider. */
for (i = 0; i < ARRAYSIZE(providers); i++) {
struct SyncProvider *sp = &providers[i];
if (VmBackupConfigGetBoolean(ctx->config, sp->cfgEntry, TRUE)) {
provider = sp->ctor();
if (provider != NULL) {
break;
}
}
}
}
ASSERT(provider != NULL);
/* Instantiate the backup state and start the operation. */
gBackupState->ctx = data->appCtx;
gBackupState->pollPeriod = 1000;
gBackupState->machineState = VMBACKUP_MSTATE_IDLE;
gBackupState->provider = provider;
g_debug("Using quiesceApps = %d, quiesceFS = %d, allowHWProvider = %d,"
"execScripts = %d, scriptArg = %s, timeout = %u\n",
gBackupState->quiesceApps, gBackupState->quiesceFS,
gBackupState->allowHWProvider, gBackupState->execScripts,
(gBackupState->scriptArg != NULL) ? gBackupState->scriptArg : "",
gBackupState->timeout);
g_debug("Quiescing volumes: %s",
(gBackupState->volumes) ? gBackupState->volumes : "(null)");
gBackupState->configDir = GuestApp_GetConfPath();
if (gBackupState->configDir == NULL) {
g_warning("Error getting configuration directory.");
goto error;
}
VmBackup_SendEvent(VMBACKUP_EVENT_RESET, VMBACKUP_SUCCESS, "");
if (!VmBackupStartScripts(VMBACKUP_SCRIPT_FREEZE)) {
goto error;
}
/*
* VC has a 15 minute timeout for quiesced snapshots. After that timeout,
* it just discards the operation and sends an error to the caller. But
* Tools can still keep running, blocking any new quiesced snapshot
* requests. So we set up our own timer (which is configurable, in case
* anyone wants to play with it), so that we abort any ongoing operation
* if we also hit that timeout.
*
* First check if the timeout is specified by the RPC command, if not,
* check the tools.conf file, otherwise use the default.
*
* See bug 506106.
*/
if (gBackupState->timeout == 0) {
gBackupState->timeout = (guint) g_key_file_get_integer(
gBackupState->ctx->config,
"vmbackup",
"timeout",
&err);
if (err != NULL) {
g_clear_error(&err);
gBackupState->timeout = 15 * 60;
}
}
/* Treat "0" as no timeout. */
if (gBackupState->timeout != 0) {
gBackupState->abortTimer =
g_timeout_source_new_seconds(gBackupState->timeout);
VMTOOLSAPP_ATTACH_SOURCE(gBackupState->ctx,
gBackupState->abortTimer,
VmBackupAbortTimer,
NULL,
NULL);
}
VMBACKUP_ENQUEUE_EVENT();
return RPCIN_SETRETVALS(data, "", TRUE);
error:
if (gBackupState->provider) {
gBackupState->provider->release(gBackupState->provider);
}
g_free(gBackupState->scriptArg);
g_free(gBackupState->volumes);
g_free(gBackupState);
gBackupState = NULL;
return RPCIN_SETRETVALS(data, "Error initializing quiesce operation.",
FALSE);
}
void
gvfs_udisks2_utils_spawn (guint timeout_seconds,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data,
const gchar *command_line_format,
...)
{
va_list var_args;
SpawnData *data;
GError *error;
gint child_argc;
gchar **child_argv = NULL;
data = g_slice_new0 (SpawnData);
data->simple = g_simple_async_result_new (NULL,
callback,
user_data,
gvfs_udisks2_utils_spawn);
data->main_context = g_main_context_get_thread_default ();
if (data->main_context != NULL)
g_main_context_ref (data->main_context);
data->cancellable = cancellable != NULL ? g_object_ref (cancellable) : NULL;
va_start (var_args, command_line_format);
data->command_line = g_strdup_vprintf (command_line_format, var_args);
va_end (var_args);
data->child_stdout = g_string_new (NULL);
data->child_stderr = g_string_new (NULL);
data->child_stdout_fd = -1;
data->child_stderr_fd = -1;
/* the life-cycle of SpawnData is tied to its GSimpleAsyncResult */
g_simple_async_result_set_op_res_gpointer (data->simple, data, (GDestroyNotify) spawn_data_free);
error = NULL;
if (data->cancellable != NULL)
{
/* could already be cancelled */
error = NULL;
if (g_cancellable_set_error_if_cancelled (data->cancellable, &error))
{
g_simple_async_result_take_error (data->simple, error);
g_simple_async_result_complete_in_idle (data->simple);
g_object_unref (data->simple);
goto out;
}
data->cancellable_handler_id = g_cancellable_connect (data->cancellable,
G_CALLBACK (on_cancelled),
data,
NULL);
}
error = NULL;
if (!g_shell_parse_argv (data->command_line,
&child_argc,
&child_argv,
&error))
{
g_prefix_error (&error,
"Error parsing command-line `%s': ",
data->command_line);
g_simple_async_result_take_error (data->simple, error);
g_simple_async_result_complete_in_idle (data->simple);
g_object_unref (data->simple);
goto out;
}
error = NULL;
if (!g_spawn_async_with_pipes (NULL, /* working directory */
child_argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, /* child_setup */
NULL, /* child_setup's user_data */
&(data->child_pid),
NULL, /* gint *stdin_fd */
&(data->child_stdout_fd),
&(data->child_stderr_fd),
&error))
{
g_prefix_error (&error,
"Error spawning command-line `%s': ",
data->command_line);
g_simple_async_result_take_error (data->simple, error);
g_simple_async_result_complete_in_idle (data->simple);
g_object_unref (data->simple);
goto out;
}
if (timeout_seconds > 0)
{
data->timeout_source = g_timeout_source_new_seconds (timeout_seconds);
g_source_set_priority (data->timeout_source, G_PRIORITY_DEFAULT);
g_source_set_callback (data->timeout_source, timeout_cb, data, NULL);
g_source_attach (data->timeout_source, data->main_context);
g_source_unref (data->timeout_source);
}
data->child_watch_source = g_child_watch_source_new (data->child_pid);
g_source_set_callback (data->child_watch_source, (GSourceFunc) child_watch_cb, data, NULL);
g_source_attach (data->child_watch_source, data->main_context);
g_source_unref (data->child_watch_source);
data->child_stdout_channel = g_io_channel_unix_new (data->child_stdout_fd);
g_io_channel_set_flags (data->child_stdout_channel, G_IO_FLAG_NONBLOCK, NULL);
data->child_stdout_source = g_io_create_watch (data->child_stdout_channel, G_IO_IN);
g_source_set_callback (data->child_stdout_source, (GSourceFunc) read_child_stdout, data, NULL);
g_source_attach (data->child_stdout_source, data->main_context);
g_source_unref (data->child_stdout_source);
data->child_stderr_channel = g_io_channel_unix_new (data->child_stderr_fd);
g_io_channel_set_flags (data->child_stderr_channel, G_IO_FLAG_NONBLOCK, NULL);
data->child_stderr_source = g_io_create_watch (data->child_stderr_channel, G_IO_IN);
g_source_set_callback (data->child_stderr_source, (GSourceFunc) read_child_stderr, data, NULL);
g_source_attach (data->child_stderr_source, data->main_context);
g_source_unref (data->child_stderr_source);
out:
g_strfreev (child_argv);
}
/** @girskip
* Adds a GLib main loop timeout callback that will be removed when unloading the plugin,
* preventing it to run after the plugin has been unloaded (which may lead to a segfault).
*
* @param plugin Must be @ref geany_plugin.
* @param interval The time between calls to the function, in seconds.
* @param function The function to call after the given timeout.
* @param data The user data passed to the function.
* @return the ID of the event source (you generally won't need it, or better use
* g_timeout_add_seconds() directly if you want to manage this event source manually).
*
* @see g_timeout_add_seconds()
* @since 0.21, plugin API 205.
*/
GEANY_API_SYMBOL
guint plugin_timeout_add_seconds(GeanyPlugin *plugin, guint interval, GSourceFunc function,
gpointer data)
{
return plugin_source_add(plugin, g_timeout_source_new_seconds(interval), function, data);
}
static void
gimp_display_shell_close_dialog (GimpDisplayShell *shell,
GimpImage *image)
{
GtkWidget *dialog;
GimpMessageBox *box;
GClosure *closure;
GSource *source;
gchar *title;
const gchar *uri;
if (shell->close_dialog)
{
gtk_window_present (GTK_WINDOW (shell->close_dialog));
return;
}
uri = gimp_image_get_uri (image);
title = g_strdup_printf (_("Close %s"), gimp_image_get_display_name (image));
shell->close_dialog =
dialog = gimp_message_dialog_new (title, GTK_STOCK_SAVE,
GTK_WIDGET (shell),
GTK_DIALOG_DESTROY_WITH_PARENT,
gimp_standard_help_func, NULL,
NULL);
g_free (title);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Close _without Saving"), GTK_RESPONSE_CLOSE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
(uri ?
GTK_STOCK_SAVE :
GTK_STOCK_SAVE_AS), RESPONSE_SAVE,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CANCEL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
RESPONSE_SAVE,
GTK_RESPONSE_CLOSE,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&shell->close_dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (gimp_display_shell_close_response),
shell);
box = GIMP_MESSAGE_DIALOG (dialog)->box;
g_signal_connect_object (image, "name-changed",
G_CALLBACK (gimp_display_shell_close_name_changed),
box, 0);
gimp_display_shell_close_name_changed (image, box);
closure =
g_cclosure_new_object (G_CALLBACK (gimp_display_shell_close_time_changed),
G_OBJECT (box));
/* update every 10 seconds */
source = g_timeout_source_new_seconds (10);
g_source_set_closure (source, closure);
g_source_attach (source, NULL);
g_source_unref (source);
/* The dialog is destroyed with the shell, so it should be safe
* to hold an image pointer for the lifetime of the dialog.
*/
g_object_set_data (G_OBJECT (box), "gimp-image", image);
gimp_display_shell_close_time_changed (box);
gtk_widget_show (dialog);
}
static void
resource_available (GSSDPResourceBrowser *resource_browser,
SoupMessageHeaders *headers)
{
GSSDPResourceBrowserPrivate *priv;
const char *usn;
const char *header;
Resource *resource;
gboolean was_cached;
guint timeout;
GList *locations;
gboolean destroyLocations;
GList *it1, *it2;
char *canonical_usn;
priv = gssdp_resource_browser_get_instance_private (resource_browser);
usn = soup_message_headers_get_one (headers, "USN");
if (!usn)
return; /* No USN specified */
/* Build list of locations */
locations = NULL;
destroyLocations = TRUE;
header = soup_message_headers_get_one (headers, "Location");
if (header)
locations = g_list_append (locations, g_strdup (header));
header = soup_message_headers_get_one (headers, "AL");
if (header) {
/* Parse AL header. The format is:
* <uri1><uri2>... */
const char *start, *end;
char *uri;
start = header;
while ((start = strchr (start, '<'))) {
start += 1;
if (!start || !*start)
break;
end = strchr (start, '>');
if (!end || !*end)
break;
uri = g_strndup (start, end - start);
locations = g_list_append (locations, uri);
start = end;
}
}
if (!locations)
return; /* No location specified */
if (priv->version > 0) {
char *version;
version = g_strrstr (usn, ":");
canonical_usn = g_strndup (usn, version - usn);
} else {
canonical_usn = g_strdup (usn);
}
/* Get from cache, if possible */
resource = g_hash_table_lookup (priv->resources,
canonical_usn);
/* Put usn into fresh resources, so this resource will not be
* removed on cache refreshing. */
if (priv->fresh_resources != NULL) {
g_hash_table_add (priv->fresh_resources,
g_strdup (canonical_usn));
}
/* If location does not match, expect that we missed bye bye packet */
if (resource) {
for (it1 = locations, it2 = resource->locations;
it1 && it2;
it1 = it1->next, it2 = it2->next) {
if (strcmp ((const char *) it1->data,
(const char *) it2->data) != 0) {
resource_unavailable (resource_browser, headers);
/* Will be destroyed by resource_unavailable */
resource = NULL;
break;
}
}
}
if (resource) {
/* Remove old timeout */
g_source_destroy (resource->timeout_src);
was_cached = TRUE;
} else {
/* Create new Resource data structure */
resource = g_slice_new (Resource);
resource->resource_browser = resource_browser;
resource->usn = g_strdup (usn);
resource->locations = locations;
destroyLocations = FALSE; /* Ownership passed to resource */
g_hash_table_insert (priv->resources,
canonical_usn,
resource);
was_cached = FALSE;
/* hash-table takes ownership of this */
canonical_usn = NULL;
}
g_free (canonical_usn);
/* Calculate new timeout */
header = soup_message_headers_get_one (headers, "Cache-Control");
if (header) {
GSList *list;
int res;
res = 0;
for (list = soup_header_parse_list (header);
list;
list = list->next) {
res = sscanf (list->data,
"max-age = %d",
&timeout);
if (res == 1)
break;
}
if (res != 1) {
g_warning ("Invalid 'Cache-Control' header. Assuming "
"default max-age of %d.\n"
"Header was:\n%s",
SSDP_DEFAULT_MAX_AGE,
header);
timeout = SSDP_DEFAULT_MAX_AGE;
}
soup_header_free_list (list);
} else {
const char *expires;
expires = soup_message_headers_get_one (headers, "Expires");
if (expires) {
SoupDate *soup_exp_time;
time_t exp_time, cur_time;
soup_exp_time = soup_date_new_from_string (expires);
exp_time = soup_date_to_time_t (soup_exp_time);
soup_date_free (soup_exp_time);
cur_time = time (NULL);
if (exp_time > cur_time)
timeout = exp_time - cur_time;
else {
g_warning ("Invalid 'Expires' header. Assuming "
"default max-age of %d.\n"
"Header was:\n%s",
SSDP_DEFAULT_MAX_AGE,
expires);
timeout = SSDP_DEFAULT_MAX_AGE;
}
} else {
g_warning ("No 'Cache-Control' nor any 'Expires' "
"header was specified. Assuming default "
"max-age of %d.", SSDP_DEFAULT_MAX_AGE);
timeout = SSDP_DEFAULT_MAX_AGE;
}
}
resource->timeout_src = g_timeout_source_new_seconds (timeout);
g_source_set_callback (resource->timeout_src,
resource_expire,
resource, NULL);
g_source_attach (resource->timeout_src,
g_main_context_get_thread_default ());
g_source_unref (resource->timeout_src);
/* Only continue with signal emission if this resource was not
* cached already */
if (!was_cached) {
/* Emit signal */
g_signal_emit (resource_browser,
signals[RESOURCE_AVAILABLE],
0,
usn,
locations);
}
/* Cleanup */
if (destroyLocations)
g_list_free_full (locations, g_free);
}