static void cancel_all_requests(liMemcachedCon *con) {
int_request *req;
GError *err1 = NULL, *err = NULL;
gboolean first = TRUE;
if (con->err) {
err1 = g_error_copy(con->err);
} else {
g_set_error(&err1, LI_MEMCACHED_ERROR, LI_MEMCACHED_CONNECTION, "Connection reset");
}
while (NULL != (req = g_queue_peek_head(&con->req_queue))) {
if (NULL == err) {
err = g_error_copy(err1);
}
if (req->req.callback) req->req.callback(&req->req, LI_MEMCACHED_RESULT_ERROR, NULL, &err);
free_request(con, req);
if (first) {
if (err) err->code = LI_MEMCACHED_DISABLED; /* "silent" fail */
if (err1) err1->code = LI_MEMCACHED_DISABLED; /* "silent" fail */
if (con->err) con->err->code = LI_MEMCACHED_DISABLED; /* "silent" fail */
first = FALSE;
}
}
if (NULL != err) g_clear_error(&err);
if (NULL != err1) g_clear_error(&err1);
}
static void
do_sparql_query_async_connection_cb (GObject *const object,
GAsyncResult *const result,
GTask *const task)
{
g_autoptr(GError) error = NULL;
TrackerSparqlConnection *const conn = tracker_sparql_connection_get_finish (
result,
&error
);
if (error) {
g_task_return_error (task, g_error_copy (error));
return;
}
SparqlQueryWork *const work = sparql_query_work_get (task);
work->connection = conn;
tracker_sparql_connection_query_async (
conn,
work->sparql,
g_task_get_cancellable (task),
(GAsyncReadyCallback) do_sparql_query_async_cursor_cb,
task
);
}
static void connect_cb(GObex *obex, GError *err, GObexPacket *rsp,
gpointer user_data)
{
struct callback_data *callback = user_data;
GError *gerr = NULL;
uint8_t rsp_code;
if (err != NULL) {
error("connect_cb: %s", err->message);
gerr = g_error_copy(err);
goto done;
}
rsp_code = g_obex_packet_get_operation(rsp, NULL);
if (rsp_code != G_OBEX_RSP_SUCCESS)
gerr = g_error_new(OBEX_IO_ERROR, -EIO,
"OBEX Connect failed with 0x%02x", rsp_code);
done:
callback->func(callback->session, NULL, gerr, callback->data);
if (gerr != NULL)
g_error_free(gerr);
obc_session_unref(callback->session);
g_free(callback);
}
static GsfInput *
gsf_infile_tar_dup (GsfInput *src_input, GError **err)
{
GsfInfileTar *res, *src;
unsigned ui;
src = GSF_INFILE_TAR (src_input);
if (src->err) {
if (err)
*err = g_error_copy (src->err);
return NULL;
}
res = (GsfInfileTar *)g_object_new (GSF_INFILE_TAR_TYPE, NULL);
gsf_infile_tar_set_source (res, src->source);
for (ui = 0; ui < src->children->len; ui++) {
/* This copies the structure. */
TarChild c = g_array_index (src->children, TarChild, ui);
c.name = g_strdup (c.name);
if (c.dir) g_object_ref (c.dir);
g_array_append_val (res->children, c);
}
return NULL;
}
liMemcachedRequest* li_memcached_get(liMemcachedCon *con, GString *key, liMemcachedCB callback, gpointer cb_data, GError **err) {
int_request* req;
if (!li_memcached_is_key_valid(key)) {
g_set_error(err, LI_MEMCACHED_ERROR, LI_MEMCACHED_BAD_KEY, "Invalid key: '%s'", key->str);
return NULL;
}
if (-1 == con->fd) memcached_connect(con);
if (-1 == con->fd) {
if (NULL == con->err) {
g_set_error(err, LI_MEMCACHED_ERROR, LI_MEMCACHED_DISABLED, "Not connected");
} else if (err) {
*err = g_error_copy(con->err);
}
return NULL;
}
req = g_slice_new0(int_request);
req->req.callback = callback;
req->req.cb_data = cb_data;
req->type = REQ_GET;
req->key = g_string_new_len(GSTR_LEN(key));
if (!push_request(con, req, err)) {
free_request(con, req);
return NULL;
}
return &req->req;
}
gboolean
lt_ext_module_precheck_tag(lt_ext_module_t *module,
lt_ext_module_data_t *data,
const lt_tag_t *tag,
GError **error)
{
GError *err = NULL;
gboolean retval;
g_return_val_if_fail (module != NULL, FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (module->funcs != NULL, FALSE);
g_return_val_if_fail (module->funcs->precheck_tag != NULL, FALSE);
retval = module->funcs->precheck_tag(data, tag, &err);
if (err) {
if (error)
*error = g_error_copy(err);
else
g_warning(err->message);
g_error_free(err);
retval = FALSE;
}
return retval;
}
static void
open_connection_async_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVfsDBusDaemon *proxy;
AsyncDBusCall *async_call = user_data;
GError *error = NULL;
proxy = gvfs_dbus_daemon_proxy_new_finish (res, &error);
if (proxy == NULL)
{
async_call->io_error = g_error_copy (error);
g_error_free (error);
async_call_finish (async_call);
return;
}
g_dbus_proxy_set_default_timeout (G_DBUS_PROXY (proxy), G_VFS_DBUS_TIMEOUT_MSECS);
gvfs_dbus_daemon_call_get_connection (proxy,
async_call->cancellable,
(GAsyncReadyCallback) async_get_connection_response,
async_call);
g_object_unref (proxy);
}
static void
print_file_done (GObject *source,
GAsyncResult *result,
gpointer data)
{
GtkPrintOperation *op = data;
GtkPrintOperationPortal *op_portal = op->priv->platform_data;
GError *error = NULL;
GVariant *ret;
ret = g_dbus_proxy_call_finish (op_portal->proxy,
result,
&error);
if (ret == NULL)
{
if (op->priv->error == NULL)
op->priv->error = g_error_copy (error);
g_warning ("Print file failed: %s", error->message);
g_error_free (error);
}
else
g_variant_unref (ret);
if (op_portal->loop)
g_main_loop_quit (op_portal->loop);
g_object_unref (op);
}
static gboolean
uca_pco_camera_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
UcaPcoCamera *camera;
UcaPcoCameraPrivate *priv;
g_return_val_if_fail (UCA_IS_PCO_CAMERA (initable), FALSE);
if (cancellable != NULL) {
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
"Cancellable initialization not supported");
return FALSE;
}
camera = UCA_PCO_CAMERA (initable);
priv = camera->priv;
if (priv->construct_error != NULL) {
if (error)
*error = g_error_copy (priv->construct_error);
return FALSE;
}
return TRUE;
}
/*
* Create a new filled #GdaRow object for the next cursor row
*
* Each new #GdaRow created is referenced only by imodel->priv->tmp_row (the #GdaDataSelect implementation
* never keeps a reference to it).
* Before a new #GdaRow gets created, the previous one, if set, is discarded.
*/
static gboolean
gda_sqlite_recordset_fetch_next (GdaDataSelect *model, GdaRow **prow, gint rownum, GError **error)
{
GdaSqliteRecordset *imodel = (GdaSqliteRecordset*) model;
if (imodel->priv->tmp_row) {
g_object_unref (imodel->priv->tmp_row);
imodel->priv->tmp_row = NULL;
}
if (imodel->priv->next_row_num != rownum) {
GError *lerror = NULL;
*prow = NULL;
g_set_error (&lerror, GDA_DATA_MODEL_ERROR,
GDA_DATA_MODEL_ROW_NOT_FOUND_ERROR,
"%s", _("Can't set iterator on requested row"));
gda_data_select_add_exception (GDA_DATA_SELECT (model), lerror);
if (error)
g_propagate_error (error, g_error_copy (lerror));
return TRUE;
}
*prow = fetch_next_sqlite_row (imodel, FALSE, error);
imodel->priv->tmp_row = *prow;
return TRUE;
}
static void
unsolicited_disable_done (MMModem *modem,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = user_data;
/* Handle modem removal, but ignore other errors */
if (g_error_matches (error, MM_MODEM_ERROR, MM_MODEM_ERROR_REMOVED))
info->error = g_error_copy (error);
else if (!modem) {
info->error = g_error_new_literal (MM_MODEM_ERROR,
MM_MODEM_ERROR_REMOVED,
"The modem was removed.");
}
if (info->error) {
mm_callback_info_schedule (info);
return;
}
/* Otherwise, kill any existing connection */
if (mm_generic_gsm_get_cid (MM_GENERIC_GSM (modem)) >= 0)
hso_call_control (MM_MODEM_HSO (modem), FALSE, TRUE, disable_done, info);
else
disable_done (modem, NULL, info);
}
static void _get_metadata_tracker_cb(GHashTable *result,
GError *error,
gpointer user_data)
{
struct _metadatas_closure *mc = (struct _metadatas_closure *) user_data;
/* Save error */
if (error) {
/* This error, if emitted with send_error is freed after the callback
chain, so we have to make a copy when we add it to the closure */
if (!mc->common->error) {
mc->common->error = g_error_copy(error);
}
}
/* Save result */
if (result)
g_hash_table_insert(mc->common->metadatas,
mc->object_id,
g_hash_table_ref(result));
mc->common->remaining--;
/* If there aren't more elements, send results */
if (mc->common->remaining == 0) {
_emit_metadatas_results(mc->common);
}
/* Free closure */
g_free(mc);
}
MechEGLConfig *
_mech_egl_config_get (gint renderable_type,
GError **error)
{
static GHashTable *egl_configs = NULL;
MechEGLConfigPrivate *egl_config;
if (G_UNLIKELY (!egl_configs))
egl_configs = g_hash_table_new (NULL, NULL);
egl_config = g_hash_table_lookup (egl_configs,
GINT_TO_POINTER (renderable_type));
if (!egl_config)
{
egl_config = _create_egl_config (renderable_type);
g_hash_table_insert (egl_configs, GINT_TO_POINTER (renderable_type),
egl_config);
}
if (G_UNLIKELY (egl_config->error))
{
if (error)
*error = g_error_copy (egl_config->error);
return NULL;
}
return (MechEGLConfig *) egl_config;
}
static void
cb_error (MilterErrorEmittable *emittable, GError *error, gpointer user_data)
{
if (actual_error)
g_error_free(actual_error);
actual_error = g_error_copy(error);
}
static void
ev_load_job_done (EvJob *ev_job,
gpointer user_data)
{
PdfLoadJob *job = user_data;
if (ev_job_is_failed (ev_job) || (ev_job->document == NULL)) {
if (job->from_old_cache)
pdf_load_job_force_refresh_cache (job);
else
pdf_load_job_complete_error (job, (ev_job->error != NULL) ?
g_error_copy (ev_job->error) :
g_error_new_literal (G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Unable to load the document")));
g_clear_object (&ev_job);
return;
}
job->document = g_object_ref (ev_job->document);
g_object_unref (ev_job);
pdf_load_job_complete_success (job);
}
static void
get_nwstate_done (MMAtSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMCallbackInfo *info = user_data;
/* If the modem has already been removed, return without
* scheduling callback */
if (mm_callback_info_check_modem_removed (info))
return;
if (error)
info->error = g_error_copy (error);
else {
MMModemIcera *self = MM_MODEM_ICERA (info->modem);
MMModemIceraPrivate *priv = MM_MODEM_ICERA_GET_PRIVATE (self);
/* The unsolicited message handler will already have run and
* removed the NWSTATE response, so we have to work around that.
*/
mm_callback_info_set_result (info, GUINT_TO_POINTER (priv->last_act), NULL);
priv->last_act = MM_MODEM_GSM_ACCESS_TECH_UNKNOWN;
}
mm_callback_info_schedule (info);
}
static void
copy_status (McdChannel *source, McdChannel *dest)
{
McdChannelPrivate *src_priv, *dst_priv;
src_priv = source->priv;
dst_priv = dest->priv;
if (dst_priv->status != src_priv->status)
{
DEBUG ("source is %d, dest is %d", src_priv->status, dst_priv->status);
if (src_priv->status == MCD_CHANNEL_STATUS_FAILED)
{
const GError *error;
error = mcd_channel_get_error (source);
/* this also takes care of setting the status */
mcd_channel_take_error (dest, g_error_copy (error));
}
else
_mcd_channel_set_status (dest, src_priv->status);
}
if (dst_priv->status == MCD_CHANNEL_STATUS_FAILED ||
dst_priv->status == MCD_CHANNEL_STATUS_DISPATCHED)
{
/* the request is completed, we are not interested in monitor the
* channel anymore */
g_signal_handlers_disconnect_by_func
(source, on_proxied_channel_status_changed, dest);
mcd_mission_abort (MCD_MISSION (dest));
}
}
static void
parse_response (MMAtSerialPort *port,
GString *response,
GError *error,
gpointer user_data)
{
MMPluginBaseSupportsTask *task = MM_PLUGIN_BASE_SUPPORTS_TASK (user_data);
MMPluginBaseSupportsTaskPrivate *task_priv = MM_PLUGIN_BASE_SUPPORTS_TASK_GET_PRIVATE (task);
if (task_priv->probe_id)
g_source_remove (task_priv->probe_id);
g_free (task_priv->probe_resp);
task_priv->probe_resp = NULL;
g_clear_error (&(task_priv->probe_error));
if (response && response->len)
task_priv->probe_resp = g_strdup (response->str);
if (error)
task_priv->probe_error = g_error_copy (error);
/* Schedule the response handler in an idle, since we can't emit the
* PROBE_RESULT signal from the serial port response handler without
* potentially destroying the serial port in the middle of its response
* handler, which it understandably doesn't like.
*/
task_priv->probe_id = g_idle_add (handle_probe_response, task);
}
static void
async_get_connection_response (GVfsDBusDaemon *proxy,
GAsyncResult *res,
gpointer user_data)
{
AsyncDBusCall *async_call = user_data;
GError *error = NULL;
gchar *address1 = NULL;
if (! gvfs_dbus_daemon_call_get_connection_finish (proxy,
&address1, NULL,
res,
&error))
{
async_call->io_error = g_error_copy (error);
g_error_free (error);
g_free (address1);
async_call_finish (async_call);
return;
}
g_dbus_connection_new_for_address (address1,
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
NULL, /* GDBusAuthObserver */
async_call->cancellable,
async_got_private_connection_cb,
async_call);
g_free (address1);
}
static void
ev_load_job_done (EvJob *ev_job,
gpointer user_data)
{
PdfLoadJob *job = user_data;
if (ev_job_is_failed (ev_job) || (ev_job->document == NULL)) {
if (job->from_old_cache) {
pdf_load_job_force_refresh_cache (job);
} else if (g_error_matches (ev_job->error, EV_DOCUMENT_ERROR, EV_DOCUMENT_ERROR_ENCRYPTED)
&& job->passwd != NULL
&& !job->passwd_tried) {
/* EvJobLoad tries using the password only after the job has
* failed once.
*/
ev_job_scheduler_push_job (ev_job, EV_JOB_PRIORITY_NONE);
job->passwd_tried = TRUE;
} else {
pdf_load_job_complete_error (job, (ev_job->error != NULL) ?
g_error_copy (ev_job->error) :
g_error_new_literal (G_IO_ERROR,
G_IO_ERROR_FAILED,
_("Unable to load the document")));
}
return;
}
job->document = g_object_ref (ev_job->document);
pdf_load_job_complete_success (job);
}
static gboolean
cheese_camera_device_initable_init (GInitable *initable,
GCancellable *cancellable,
GError **error)
{
CheeseCameraDevice *device = CHEESE_CAMERA_DEVICE (initable);
CheeseCameraDevicePrivate *priv = device->priv;
g_return_val_if_fail (CHEESE_IS_CAMERA_DEVICE (initable), FALSE);
if (cancellable != NULL)
{
g_set_error_literal (error,
CHEESE_CAMERA_DEVICE_ERROR,
CHEESE_CAMERA_DEVICE_ERROR_NOT_SUPPORTED,
_("Cancellable initialization not supported"));
return FALSE;
}
if (priv->construct_error)
{
if (error)
*error = g_error_copy (priv->construct_error);
return FALSE;
}
return TRUE;
}
/* Parsing functions to create GDataFreebaseTopicValues, and arrays of those */
static gchar *
reader_dup_member_string (JsonReader *reader, const gchar *member, GError **error)
{
const GError *reader_error;
gchar *str;
if (error != NULL && *error != NULL)
return NULL;
json_reader_read_member (reader, member);
str = g_strdup (json_reader_get_string_value (reader));
reader_error = json_reader_get_error (reader);
if (reader_error != NULL) {
g_free (str);
str = NULL;
if (error != NULL)
*error = g_error_copy (reader_error);
}
json_reader_end_member (reader);
return str;
}
static gint64
reader_parse_timestamp (JsonReader *reader, const gchar *member, GError **error)
{
const GError *reader_error;
const gchar *date_str;
gint64 timestamp = -1;
if (error != NULL && *error != NULL)
return -1;
json_reader_read_member (reader, member);
date_str = json_reader_get_string_value (reader);
reader_error = json_reader_get_error (reader);
if (reader_error != NULL) {
if (error != NULL)
*error = g_error_copy (reader_error);
} else if (date_str) {
if (!gdata_parser_int64_from_iso8601 (date_str, ×tamp))
timestamp = -1;
}
json_reader_end_member (reader);
return timestamp;
}
/**
* rb_chunk_loader_get_error:
* @loader: a #RBChunkLoader
*
* If an error has occurred that prevents the loader from providing
* any further data, this function will return a #GError, otherwise
* NULL.
*
* Return value: loader error or NULL
*/
GError *
rb_chunk_loader_get_error (RBChunkLoader *loader)
{
if (loader->priv->error)
return g_error_copy (loader->priv->error);
return NULL;
}
/**
* rb_async_copy_get_error:
* @copy: a #RBAsyncCopy
*
* If an error has occurred that prevents the copy from proceeding,
* this function will return a #GError, otherwise NULL.
*
* Return value: copy error or NULL
*/
GError *
rb_async_copy_get_error (RBAsyncCopy *copy)
{
if (copy->priv->error)
return g_error_copy (copy->priv->error);
return NULL;
}
static void
handshake_thread_completed (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
GTask *caller_task = user_data;
GTlsConnectionBase *tls = g_task_get_source_object (caller_task);
GError *error = NULL;
gboolean need_finish_handshake, success;
g_mutex_lock (&tls->op_mutex);
if (tls->need_finish_handshake)
{
need_finish_handshake = TRUE;
tls->need_finish_handshake = FALSE;
}
else
need_finish_handshake = FALSE;
g_mutex_unlock (&tls->op_mutex);
if (need_finish_handshake)
{
success = finish_handshake (tls, G_TASK (result), &error);
if (success)
g_task_return_boolean (caller_task, TRUE);
else
g_task_return_error (caller_task, error);
}
else if (tls->handshake_error)
g_task_return_error (caller_task, g_error_copy (tls->handshake_error));
else
g_task_return_boolean (caller_task, TRUE);
g_object_unref (caller_task);
}
void
seahorse_operation_copy_error (SeahorseOperation *op, GError **err)
{
g_return_if_fail (err == NULL || *err == NULL);
if (err)
*err = op->error ? g_error_copy (op->error) : NULL;
}
/**
*
* bindings of the unlink plugin call
*/
int gfal_srm_unlink_listG(plugin_handle ch, int nbfiles, const char* const* paths, GError** err)
{
GError *tmp_err = NULL;
int ret = -1, i;
if (!err)
return -1;
if (!ch || nbfiles < 0 || paths == NULL || *paths == NULL) {
gfal2_set_error(&tmp_err, gfal2_get_plugin_srm_quark(), EINVAL, __func__, "incorrect args");
}
else {
gfal_srmv2_opt* opts = (gfal_srmv2_opt*) ch;
srm_context_t context = gfal_srm_ifce_easy_context(opts, paths[0], &tmp_err);
if (context) {
for(i = 0; i < nbfiles; ++i)
gfal_srm_cache_stat_remove(ch, paths[i]);
ret = gfal_srm_rm_srmv2_internal(context, nbfiles, paths, err);
}
}
if (tmp_err) {
for (i = 1; i < nbfiles; ++i)
err[i] = g_error_copy(err[0]);
}
return ret;
}
static void
egg_task_cache_propagate_error (EggTaskCache *self,
gconstpointer key,
const GError *error)
{
GPtrArray *queued;
g_assert (EGG_IS_TASK_CACHE (self));
g_assert (error != NULL);
if ((queued = g_hash_table_lookup (self->queued, key)))
{
gint64 count = queued->len;
gsize i;
/* we can't use steal because we want the key freed */
g_ptr_array_ref (queued);
g_hash_table_remove (self->queued, key);
for (i = 0; i < queued->len; i++)
{
GTask *task;
task = g_ptr_array_index (queued, i);
g_task_return_error (task, g_error_copy (error));
}
g_ptr_array_unref (queued);
EGG_COUNTER_SUB (queued, count);
}
}
static void
do_sparql_query_async_cursor_cb (GObject *const object,
GAsyncResult *const result,
GTask *const task)
{
g_autoptr(GError) error = NULL;
SparqlQueryWork *const work = sparql_query_work_get (task);
TrackerSparqlConnection *const conn = work->connection;
TrackerSparqlCursor *const cur = tracker_sparql_connection_query_finish (
conn,
result,
&error
);
if (error) {
g_task_return_error (task, g_error_copy (error));
return;
}
g_task_return_pointer (task, cur, g_object_unref);
}
