static void
get_kind_and_mime_type (JsonReader *reader, gchar **out_kind, gchar **out_mime_type, GError **error)
{
GError *child_error = NULL;
gboolean success;
gchar *kind = NULL;
gchar *mime_type = NULL;
guint i, members;
for (i = 0, members = (guint) json_reader_count_members (reader); i < members; i++) {
json_reader_read_element (reader, i);
if (gdata_parser_string_from_json_member (reader, "kind", P_REQUIRED | P_NON_EMPTY, &kind, &success, &child_error) == TRUE) {
if (!success && child_error != NULL) {
g_propagate_prefixed_error (error, child_error,
/* Translators: the parameter is an error message */
_("Error parsing JSON: %s"),
"Failed to find ‘kind’.");
json_reader_end_element (reader);
goto out;
}
}
if (gdata_parser_string_from_json_member (reader, "mimeType", P_DEFAULT, &mime_type, &success, &child_error) == TRUE) {
if (!success && child_error != NULL) {
g_propagate_prefixed_error (error, child_error,
/* Translators: the parameter is an error message */
_("Error parsing JSON: %s"),
"Failed to find ‘mimeType’.");
json_reader_end_element (reader);
goto out;
}
}
json_reader_end_element (reader);
}
if (out_kind != NULL) {
*out_kind = kind;
kind = NULL;
}
if (out_mime_type != NULL) {
*out_mime_type = mime_type;
mime_type = NULL;
}
out:
g_free (kind);
g_free (mime_type);
}
guint64
utils_timestamp_file(const gchar* filename, GError** error)
{
RETURN_VAL_IF_FAIL(!utils_str_empty(filename), 0);
GError* err = NULL; /* NOTE: Doesn't need to be freed because we propagate it */
if (g_file_test(filename, G_FILE_TEST_EXISTS))
{
GTimeVal time;
g_autoptr(GFile) file = g_file_new_for_path(filename);
g_autoptr(GFileInfo) info = g_file_query_info(file,
G_FILE_ATTRIBUTE_TIME_MODIFIED, G_FILE_QUERY_INFO_NONE,
NULL, &err);
if (err)
{
WARNING("Could not timestamp file because: %s", err->message);
g_propagate_prefixed_error(error, err, "Could not timestamp file because: ");
return 0;
}
g_file_info_get_modification_time(info, &time);
return time.tv_sec;
}
RETURN_VAL_IF_REACHED(0);
}
bool
input_stream_global_init(GError **error_r)
{
GError *error = NULL;
for (unsigned i = 0; input_plugins[i] != NULL; ++i) {
const struct input_plugin *plugin = input_plugins[i];
assert(plugin->name != NULL);
assert(*plugin->name != 0);
assert(plugin->open != NULL);
const struct config_param *param =
input_plugin_config(plugin->name, &error);
if (param == NULL && error != NULL) {
g_propagate_error(error_r, error);
return false;
}
if (!config_get_block_bool(param, "enabled", true))
/* the plugin is disabled in mpd.conf */
continue;
if (plugin->init == NULL || plugin->init(param, &error))
input_plugins_enabled[i] = true;
else {
g_propagate_prefixed_error(error_r, error,
"Failed to initialize input plugin '%s': ",
plugin->name);
return false;
}
}
return true;
}
int
cr_xmlfile_add_chunk(cr_XmlFile *f, const char* chunk, GError **err)
{
GError *tmp_err = NULL;
assert(f);
assert(!err || *err == NULL);
assert(f->footer == 0);
if (!chunk)
return CRE_OK;
if (f->header == 0) {
cr_xmlfile_write_xml_header(f, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_error(err, tmp_err);
return code;
}
}
cr_puts(f->f, chunk, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err, "Error while write: ");
return code;
}
return CRE_OK;
}
gboolean r_umount_slot(RaucSlot *slot, GError **error) {
GError *ierror = NULL;
gboolean res = FALSE;
g_assert_nonnull(slot);
g_assert_nonnull(slot->mount_point);
g_assert_true(slot->mount_internal);
res = r_umount(slot->mount_point, &ierror);
if (!res) {
res = FALSE;
g_propagate_prefixed_error(
error,
ierror,
"failed to unmount slot: ");
goto out;
}
g_rmdir(slot->mount_point);
g_clear_pointer(&slot->mount_point, g_free);
slot->mount_internal = FALSE;
out:
return res;
}
gboolean r_mount_full(const gchar *source, const gchar *mountpoint, const gchar* type, gsize size, GError **error) {
GSubprocess *sproc = NULL;
GError *ierror = NULL;
gboolean res = FALSE;
GPtrArray *args = g_ptr_array_new_full(10, g_free);
if (getuid() != 0) {
g_ptr_array_add(args, g_strdup("sudo"));
g_ptr_array_add(args, g_strdup("--non-interactive"));
}
g_ptr_array_add(args, g_strdup("mount"));
if (type != NULL) {
g_ptr_array_add(args, g_strdup("-t"));
g_ptr_array_add(args, g_strdup(type));
}
if (size != 0) {
g_ptr_array_add(args, g_strdup("-o"));
g_ptr_array_add(args, g_strdup_printf("ro,loop,sizelimit=%"G_GSIZE_FORMAT, size));
}
g_ptr_array_add(args, g_strdup(source));
g_ptr_array_add(args, g_strdup(mountpoint));
g_ptr_array_add(args, NULL);
sproc = g_subprocess_newv((const gchar * const *)args->pdata,
G_SUBPROCESS_FLAGS_NONE, &ierror);
if (sproc == NULL) {
g_propagate_prefixed_error(
error,
ierror,
"failed to start mount: ");
goto out;
}
res = g_subprocess_wait_check(sproc, NULL, &ierror);
if (!res) {
g_propagate_prefixed_error(
error,
ierror,
"failed to run mount: ");
goto out;
}
res = TRUE;
out:
g_ptr_array_unref(args);
return res;
}
GstWlDisplay *
gst_wl_display_new_existing (struct wl_display * display,
gboolean take_ownership, GError ** error)
{
GstWlDisplay *self;
GError *err = NULL;
gint i;
g_return_val_if_fail (display != NULL, NULL);
self = g_object_new (GST_TYPE_WL_DISPLAY, NULL);
self->display = display;
self->own_display = take_ownership;
self->queue = wl_display_create_queue (self->display);
self->registry = wl_display_get_registry (self->display);
wl_proxy_set_queue ((struct wl_proxy *) self->registry, self->queue);
wl_registry_add_listener (self->registry, ®istry_listener, self);
/* we need exactly 2 roundtrips to discover global objects and their state */
for (i = 0; i < 2; i++) {
if (gst_wl_display_roundtrip (self) < 0) {
*error = g_error_new (g_quark_from_static_string ("GstWlDisplay"), 0,
"Error communicating with the wayland display");
g_object_unref (self);
return NULL;
}
}
/* verify we got all the required interfaces */
#define VERIFY_INTERFACE_EXISTS(var, interface) \
if (!self->var) { \
g_set_error (error, g_quark_from_static_string ("GstWlDisplay"), 0, \
"Could not bind to " interface ". Either it is not implemented in " \
"the compositor, or the implemented version doesn't match"); \
g_object_unref (self); \
return NULL; \
}
VERIFY_INTERFACE_EXISTS (compositor, "wl_compositor");
VERIFY_INTERFACE_EXISTS (subcompositor, "wl_subcompositor");
VERIFY_INTERFACE_EXISTS (shell, "wl_shell");
VERIFY_INTERFACE_EXISTS (shm, "wl_shm");
VERIFY_INTERFACE_EXISTS (scaler, "wl_scaler");
#undef VERIFY_INTERFACE_EXISTS
self->thread = g_thread_try_new ("GstWlDisplay", gst_wl_display_thread_run,
self, &err);
if (err) {
g_propagate_prefixed_error (error, err,
"Failed to start thread for the display's events");
g_object_unref (self);
return NULL;
}
return self;
}
GError*
sqlx_remote_execute_packed_DESTROY_many(gchar **targets, GByteArray *sid,
GByteArray *req)
{
(void) sid;
GError *err = NULL, *local_err = NULL;
GPtrArray *targets_ok = g_ptr_array_new();
struct client_s **clients = gridd_client_create_many(targets, req,
NULL, NULL);
metautils_gba_unref(req);
req = NULL;
if (clients == NULL) {
err = NEWERROR(0, "Failed to create gridd clients");
return err;
}
gridd_clients_start(clients);
err = gridd_clients_loop(clients);
for (gchar **cursor = targets; cursor && *cursor; cursor++) {
metautils_str_clean(cursor);
}
if (err)
goto end;
for (struct client_s **p = clients; p && *p; p++) {
if (!(local_err = gridd_client_error(*p))) {
g_ptr_array_add(targets_ok, g_strdup(gridd_client_url(*p)));
continue;
}
if (local_err->code == CODE_CONTAINER_NOTFOUND ||
local_err->code == CODE_NOT_FOUND) {
g_clear_error(&local_err);
g_ptr_array_add(targets_ok, g_strdup(gridd_client_url(*p)));
continue;
}
GRID_DEBUG("Database destruction attempts failed: (%d) %s",
local_err->code, local_err->message);
if (!err)
g_propagate_prefixed_error(&err, local_err,
"Failed to destroy base on %s: ",
gridd_client_url(*p));
else
g_clear_error(&local_err);
}
for (guint i = 0; i < targets_ok->len; i++) {
targets[i] = g_ptr_array_index(targets_ok, i);
}
end:
g_ptr_array_free(targets_ok, TRUE);
gridd_clients_free(clients);
return err;
}
gboolean r_mount_slot(RaucSlot *slot, GError **error) {
GError *ierror = NULL;
gboolean res = FALSE;
gchar *mount_point = NULL;
g_assert_nonnull(slot);
g_assert_null(slot->mount_point);
g_assert_false(slot->mount_internal);
if (!g_file_test(slot->device, G_FILE_TEST_EXISTS)) {
g_set_error(
error,
G_FILE_ERROR,
G_FILE_ERROR_NOENT,
"Slot device '%s' not found",
slot->device);
goto out;
}
mount_point = r_create_mount_point(slot->name, &ierror);
if (!mount_point) {
res = FALSE;
g_propagate_prefixed_error(
error,
ierror,
"failed to create mount point: ");
goto out;
}
res = r_mount_full(slot->device, mount_point, slot->type, 0, &ierror);
if (!res) {
res = FALSE;
g_propagate_prefixed_error(
error,
ierror,
"failed to mount slot: ");
goto out;
}
slot->mount_point = mount_point;
slot->mount_internal = TRUE;
out:
return res;
}
static gboolean unsquashfs(const gchar *bundlename, const gchar *contentdir, const gchar *extractfile, GError **error) {
GSubprocess *sproc = NULL;
GError *ierror = NULL;
gboolean res = FALSE;
GPtrArray *args = g_ptr_array_new_full(7, g_free);
r_context_begin_step("unsquashfs", "Uncompressing squashfs", 0);
g_ptr_array_add(args, g_strdup("unsquashfs"));
g_ptr_array_add(args, g_strdup("-dest"));
g_ptr_array_add(args, g_strdup(contentdir));
g_ptr_array_add(args, g_strdup(bundlename));
if (extractfile) {
g_ptr_array_add(args, g_strdup("-e"));
g_ptr_array_add(args, g_strdup(extractfile));
}
g_ptr_array_add(args, NULL);
sproc = g_subprocess_newv((const gchar * const *)args->pdata,
G_SUBPROCESS_FLAGS_STDOUT_SILENCE, &ierror);
if (sproc == NULL) {
g_propagate_prefixed_error(
error,
ierror,
"Failed to start unsquashfs: ");
goto out;
}
res = g_subprocess_wait_check(sproc, NULL, &ierror);
if (!res) {
g_propagate_prefixed_error(
error,
ierror,
"Failed to run unsquashfs: ");
goto out;
}
res = TRUE;
out:
r_context_end_step("unsquashfs", res);
return res;
}
static gboolean settings_handle_error(GError **err, GError *tmp_error) {
if (is_key_not_found_error(tmp_error)) {
// A missing key is not a fatal error, and should not overwrite the default value
return TRUE;
} else {
// Fatal / unknown error
g_propagate_prefixed_error(err, tmp_error, "Failed to read configuration file '%s' : ", settings.configFileName);
return FALSE;
}
}
static gboolean mksquashfs(const gchar *bundlename, const gchar *contentdir, GError **error) {
GSubprocess *sproc = NULL;
GError *ierror = NULL;
gboolean res = FALSE;
r_context_begin_step("mksquashfs", "Creating squashfs", 0);
if (g_file_test (bundlename, G_FILE_TEST_EXISTS)) {
g_set_error(error, G_FILE_ERROR, G_FILE_ERROR_EXIST, "bundle %s already exists", bundlename);
goto out;
}
sproc = g_subprocess_new(G_SUBPROCESS_FLAGS_STDOUT_SILENCE,
&ierror, "mksquashfs",
contentdir,
bundlename,
"-all-root",
"-noappend",
"-no-progress",
"-no-xattrs",
NULL);
if (sproc == NULL) {
g_propagate_prefixed_error(
error,
ierror,
"Failed to start mksquashfs: ");
goto out;
}
res = g_subprocess_wait_check(sproc, NULL, &ierror);
if (!res) {
g_propagate_prefixed_error(
error,
ierror,
"Failed to run mksquashfs: ");
goto out;
}
res = TRUE;
out:
r_context_end_step("mksquashfs", res);
return res;
}
static gboolean
load_cert (GTlsCertificate **out_cert,
GError **error)
{
GTlsCertificate *cert = NULL;
gboolean ret = FALSE;
gchar *cert_path = NULL;
const gchar *cert_dir = PACKAGE_SYSCONF_DIR "/cockpit/ws-certs.d";
GError *local_error;
local_error = NULL;
cert_path = load_cert_from_dir (cert_dir, &local_error);
if (local_error != NULL)
{
g_propagate_prefixed_error (error, local_error,
"Error loading certificates from %s: ",
cert_dir);
goto out;
}
/* Could be there's no certicate at all, so cert_path can indeed be
* NULL. If so, use (and possibly generate) a temporary self-signed
* certificate
*/
if (cert_path == NULL)
{
cert_path = generate_temp_cert (error);
if (cert_path == NULL)
goto out;
}
cert = g_tls_certificate_new_from_file (cert_path, error);
if (cert == NULL)
{
g_prefix_error (error, "Error loading certificate at path `%s': ", cert_path);
goto out;
}
g_info ("Using certificate %s", cert_path);
if (out_cert != NULL)
{
*out_cert = cert;
cert = NULL;
}
ret = TRUE;
out:
g_clear_object (&cert);
g_free (cert_path);
return ret;
}
/* Create a netlink socket, bind to it and wrap it in a GSocket */
static gboolean
create_netlink_socket (GUPnPLinuxContextManager *self, GError **error)
{
struct sockaddr_nl sa;
int fd, status;
GSocket *sock;
GError *inner_error;
inner_error = NULL;
fd = socket (PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
if (fd == -1) {
g_set_error_literal (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
"Failed to bind to netlink socket");
return FALSE;
}
memset (&sa, 0, sizeof (sa));
sa.nl_family = AF_NETLINK;
/* Listen for interface changes and IP address changes */
sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;
status = bind (fd, (struct sockaddr *) &sa, sizeof (sa));
if (status == -1) {
g_set_error_literal (error,
G_IO_ERROR,
g_io_error_from_errno (errno),
"Failed to bind to netlink socket");
close (fd);
return FALSE;
}
sock = g_socket_new_from_fd (fd, &inner_error);
if (sock == NULL) {
close (fd);
g_propagate_prefixed_error (error,
inner_error,
"Failed to create GSocket from "
"netlink socket");
return FALSE;
}
g_socket_set_blocking (sock, FALSE);
self->priv->netlink_socket = sock;
return TRUE;
}
gboolean xr_client_open(xr_client_conn* conn, const char* uri, GError** err)
{
GError* local_err = NULL;
g_return_val_if_fail(conn != NULL, FALSE);
g_return_val_if_fail(uri != NULL, FALSE);
g_return_val_if_fail(!conn->is_open, FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
xr_trace(XR_DEBUG_CLIENT_TRACE, "(conn=%p, uri=%s)", conn, uri);
// parse URI format: http://host:8080/RES
g_free(conn->host);
g_free(conn->resource);
conn->host = NULL;
conn->resource = NULL;
if (!_parse_uri(uri, &conn->secure, &conn->host, &conn->resource))
{
g_set_error(err, XR_CLIENT_ERROR, XR_CLIENT_ERROR_FAILED, "invalid URI format: %s", uri);
return FALSE;
}
// enable/disable TLS
if (conn->secure)
{
g_socket_client_set_tls(conn->client, TRUE);
g_socket_client_set_tls_validation_flags(conn->client, G_TLS_CERTIFICATE_VALIDATE_ALL & ~G_TLS_CERTIFICATE_UNKNOWN_CA & ~G_TLS_CERTIFICATE_BAD_IDENTITY);
}
else
{
g_socket_client_set_tls(conn->client, FALSE);
}
conn->conn = g_socket_client_connect_to_host(conn->client, conn->host, 80, NULL, &local_err);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Connection failed: ");
return FALSE;
}
xr_set_nodelay(g_socket_connection_get_socket(conn->conn));
conn->http = xr_http_new(G_IO_STREAM(conn->conn));
g_free(conn->session_id);
conn->session_id = g_strdup_printf("%08x%08x%08x%08x", g_random_int(), g_random_int(), g_random_int(), g_random_int());
conn->is_open = 1;
xr_client_set_http_header(conn, "X-SESSION-ID", conn->session_id);
return TRUE;
}
gboolean r_umount(const gchar *filename, GError **error) {
GSubprocess *sproc = NULL;
GError *ierror = NULL;
gboolean res = FALSE;
GPtrArray *args = g_ptr_array_new_full(10, g_free);
if (getuid() != 0) {
g_ptr_array_add(args, g_strdup("sudo"));
g_ptr_array_add(args, g_strdup("--non-interactive"));
}
g_ptr_array_add(args, g_strdup("umount"));
g_ptr_array_add(args, g_strdup(filename));
g_ptr_array_add(args, NULL);
sproc = g_subprocess_newv((const gchar * const *)args->pdata,
G_SUBPROCESS_FLAGS_NONE, &ierror);
if (sproc == NULL) {
g_propagate_prefixed_error(
error,
ierror,
"failed to start umount: ");
goto out;
}
res = g_subprocess_wait_check(sproc, NULL, &ierror);
if (!res) {
g_propagate_prefixed_error(
error,
ierror,
"failed to run umount: ");
goto out;
}
res = TRUE;
out:
g_ptr_array_unref(args);
return res;
}
gboolean xr_server_simple(const char* cert, const char* privkey, int threads, const char* bind, xr_servlet_def** servlets, GError** err)
{
GError *local_err= NULL;
GMappedFile *cert_file = g_mapped_file_new(cert, FALSE, &local_err);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Certificate load failed: ");
g_mapped_file_unref(cert_file);
return FALSE;
}
gchar *cert_pem = g_mapped_file_get_contents(cert_file);
gchar *privkey_pem = NULL;
GMappedFile *privkey_file = NULL;
if (privkey)
{
privkey_file = g_mapped_file_new(privkey, FALSE, &local_err);
if (local_err)
{
g_free(cert_pem);
g_propagate_prefixed_error(err, local_err, "Certificate load failed: ");
g_mapped_file_unref(privkey_file);
g_mapped_file_unref(cert_file);
return FALSE;
}
privkey_pem = g_mapped_file_get_contents(privkey_file);
}
gboolean retval = xr_server_simple_pem(cert_pem, privkey_pem, threads, bind, servlets, err);
g_mapped_file_unref(cert_file);
g_mapped_file_unref(privkey_file);
return retval;
}
void
ufo_task_setup (UfoTask *task,
UfoResources *resources,
GError **error)
{
GError *tmp_error = NULL;
ufo_task_node_setup (UFO_TASK_NODE (task));
UFO_TASK_GET_IFACE (task)->setup (task, resources, &tmp_error);
if (tmp_error != NULL) {
g_propagate_prefixed_error (error, tmp_error,
"%s: ", ufo_task_node_get_plugin_name (UFO_TASK_NODE (task)));
}
}
xr_server* xr_server_new(const char* cert, const char* privkey, int threads, GError** err)
{
xr_trace(XR_DEBUG_SERVER_TRACE, "(cert=%s, threads=%d, err=%p)", cert, threads, err);
GError* local_err = NULL;
g_return_val_if_fail(threads > 0 && threads < 1000, NULL);
g_return_val_if_fail (err == NULL || *err == NULL, NULL);
xr_init();
xr_server* server = g_new0(xr_server, 1);
server->secure = !!cert;
server->service = g_threaded_socket_service_new(threads);
g_signal_connect(server->service, "run", (GCallback)_xr_server_service_run, server);
if (cert)
{
gchar *cert_and_privkey = g_strconcat(cert, privkey, NULL);
server->cert = g_tls_certificate_new_from_pem(cert_and_privkey, -1, &local_err);
g_free(cert_and_privkey);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Certificate load failed: ");
goto err0;
}
}
server->sessions = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)xr_servlet_free_fini);
g_static_rw_lock_init(&server->sessions_lock);
server->sessions_cleaner = g_thread_create((GThreadFunc)sessions_cleaner_func, server, TRUE, NULL);
if (server->sessions_cleaner == NULL)
goto err1;
return server;
err1:
g_hash_table_destroy(server->sessions);
g_static_rw_lock_free(&server->sessions_lock);
if (server->cert)
g_object_unref(server->cert);
err0:
g_object_unref(server->service);
g_free(server);
return NULL;
}
gchar *
cockpit_certificate_locate (gboolean create_if_necessary,
GError **error)
{
const gchar * const* dirs = cockpit_conf_get_dirs ();
GError *local_error = NULL;
gchar *cert_dir;
gchar *cert_path;
gint i;
for (i = 0; dirs[i]; i++)
{
cert_dir = g_build_filename (dirs[i], "cockpit", "ws-certs.d", NULL);
cert_path = load_cert_from_dir (cert_dir, &local_error);
if (local_error != NULL)
{
g_propagate_prefixed_error (error, local_error,
"Error loading certificates from %s: ",
cert_dir);
g_free (cert_dir);
return NULL;
}
g_free (cert_dir);
if (cert_path)
return cert_path;
}
cert_dir = g_build_filename (dirs[0], "cockpit", "ws-certs.d", NULL);
if (create_if_necessary)
{
cert_path = generate_temp_cert (cert_dir, error);
}
else
{
cert_path = NULL;
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
"No certificate found in dir: %s", cert_dir);
}
g_free (cert_dir);
return cert_path;
}
gboolean xr_server_bind(xr_server* server, const char* bind_addr, GError** err)
{
GError* local_err = NULL;
char* addr = NULL;
int port = 0;
xr_trace(XR_DEBUG_SERVER_TRACE, "(server=%p, bind_addr=%s, err=%p)", server, bind_addr, err);
g_return_val_if_fail(server != NULL, FALSE);
g_return_val_if_fail(bind_addr != NULL, FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
g_return_val_if_fail(_parse_addr(bind_addr, &addr, &port), FALSE);
if (addr[0] == '*')
{
g_socket_listener_add_inet_port(G_SOCKET_LISTENER(server->service), (guint16)port, NULL, &local_err);
}
else
{
// build address
GInetAddress* iaddr = g_inet_address_new_from_string(addr);
if (!iaddr)
{
g_error_new(XR_SERVER_ERROR, XR_SERVER_ERROR_FAILED, "Invalid address: %s", bind_addr);
g_free(addr);
xr_server_stop(server);
return FALSE;
}
GSocketAddress* isaddr = g_inet_socket_address_new(iaddr, (guint16)port);
g_socket_listener_add_address(G_SOCKET_LISTENER(server->service), isaddr, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, NULL, &local_err);
}
g_free(addr);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Port listen failed: ");
xr_server_stop(server);
return FALSE;
}
return TRUE;
}
int
cr_xmlfile_write_xml_footer(cr_XmlFile *f, GError **err)
{
const char *xml_footer;
GError *tmp_err = NULL;
assert(f);
assert(!err || *err == NULL);
assert(f->footer == 0);
switch (f->type) {
case CR_XMLFILE_PRIMARY:
xml_footer = XML_PRIMARY_FOOTER;
break;
case CR_XMLFILE_FILELISTS:
xml_footer = XML_FILELISTS_FOOTER;
break;
case CR_XMLFILE_OTHER:
xml_footer = XML_OTHER_FOOTER;
break;
case CR_XMLFILE_PRESTODELTA:
xml_footer = XML_PRESTODELTA_FOOTER;
break;
case CR_XMLFILE_UPDATEINFO:
xml_footer = XML_UPDATEINFO_FOOTER;
break;
default:
g_critical("%s: Bad file type", __func__);
assert(0);
g_set_error(err, ERR_DOMAIN, CRE_ASSERT, "Bad file type");
return CRE_ASSERT;
}
cr_puts(f->f, xml_footer, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err, "Cannot write XML footer: ");
return code;
}
f->footer = 1;
return CRE_OK;
}
static gboolean do_connect(MegaHttpClient* http_client, GCancellable* cancellable, GError** err)
{
GError* local_err = NULL;
g_return_val_if_fail(MEGA_IS_HTTP_CLIENT(http_client), FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
MegaHttpClientPrivate* priv = http_client->priv;
do_disconnect(http_client);
// enable/disable TLS
if (priv->https)
{
if (!g_tls_backend_supports_tls(g_tls_backend_get_default()))
{
g_set_error(err, MEGA_HTTP_CLIENT_ERROR, MEGA_HTTP_CLIENT_ERROR_OTHER, "TLS backend not found, please install glib-networking.");
return FALSE;
}
g_socket_client_set_tls(priv->client, TRUE);
}
else
{
g_socket_client_set_tls(priv->client, FALSE);
}
priv->conn = g_socket_client_connect_to_host(priv->client, priv->host, priv->port, cancellable, &local_err);
if (!priv->conn)
{
g_propagate_prefixed_error(err, local_err, "Connection failed: ");
return FALSE;
}
GDataInputStream* data_stream = g_data_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(http_client->priv->conn)));
g_data_input_stream_set_newline_type(data_stream, G_DATA_STREAM_NEWLINE_TYPE_ANY);
priv->istream = G_INPUT_STREAM(data_stream);
priv->ostream = g_object_ref(g_io_stream_get_output_stream(G_IO_STREAM(http_client->priv->conn)));
return TRUE;
}
GdkPixbuf*
gt_resource_downloader_download_image(GtResourceDownloader* self,
const gchar* uri, const gchar* name, GError** error)
{
RETURN_VAL_IF_FAIL(GT_IS_RESOURCE_DOWNLOADER(self), NULL);
RETURN_VAL_IF_FAIL(!utils_str_empty(uri), NULL);
GtResourceDownloaderPrivate* priv = gt_resource_downloader_get_instance_private(self);
g_autoptr(SoupMessage) msg = NULL;
g_autoptr(GInputStream) istream = NULL;
g_autoptr(GdkPixbuf) ret = NULL;
g_autoptr(GError) err = NULL;
DEBUG("Downloading image from uri '%s'", uri);
msg = soup_message_new(SOUP_METHOD_GET, uri);
/* NOTE: So libsoup isn't actually all that thread safe and
* calling soup_session_send from multiple threads causes it to
* crash, so we wrap a mutex around it. One should use the
* download_image_immediately func if one wants to download
* several images at the same time */
g_mutex_lock(&priv->mutex);
istream = soup_session_send(priv->soup, msg, NULL, &err);
g_mutex_unlock(&priv->mutex);
if (err)
{
WARNING("Unable to download image from uri '%s' because: %s",
uri, err->message);
g_propagate_prefixed_error(error, g_steal_pointer(&err),
"Unable to download image from uri '%s' because: ", uri);
return NULL;
}
ret = download_image(self, uri, name, msg, istream, NULL, error);
return g_steal_pointer(&ret);
}
int gfal_http_access(plugin_handle plugin_data, const char* url,
int mode, GError** err)
{
struct stat buf;
GError* tmp_err = NULL;
if (gfal_http_stat(plugin_data, url, &buf, &tmp_err) != 0) {
g_propagate_prefixed_error(err, tmp_err, "[%s]", __func__);
return -1;
}
uid_t real_uid = getuid();
gid_t real_gid = getgid();
int ngroups = getgroups(0, NULL);
gid_t additional_gids[ngroups];
getgroups(ngroups, additional_gids);
if (real_uid == buf.st_uid)
mode <<= 6;
else if (real_gid == buf.st_gid)
mode <<= 3;
else {
for (int i = 0; i < ngroups; ++i) {
if (additional_gids[i] == buf.st_gid) {
mode <<= 3;
break;
}
}
}
if ((mode & buf.st_mode) != static_cast<mode_t>(mode)) {
g_set_error(err, http_plugin_domain, EACCES,
"[%s] Does not have enough permissions on '%s'", __func__, url);
return -1;
}
else {
return 0;
}
}
int
cr_xmlfile_close(cr_XmlFile *f, GError **err)
{
GError *tmp_err = NULL;
assert(!err || *err == NULL);
if (!f)
return CRE_OK;
if (f->header == 0) {
cr_xmlfile_write_xml_header(f, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_error(err, tmp_err);
return code;
}
}
if (f->footer == 0) {
cr_xmlfile_write_xml_footer(f, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_error(err, tmp_err);
return code;
}
}
cr_close(f->f, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err,
"Error while closing a file: ");
return code;
}
g_free(f);
return CRE_OK;
}
cr_XmlFile *
cr_xmlfile_sopen(const char *filename,
cr_XmlFileType type,
cr_CompressionType comtype,
cr_ContentStat *stat,
GError **err)
{
cr_XmlFile *f;
GError *tmp_err = NULL;
assert(filename);
assert(type < CR_XMLFILE_SENTINEL);
assert(comtype < CR_CW_COMPRESSION_SENTINEL);
assert(!err || *err == NULL);
if (g_file_test(filename, G_FILE_TEST_EXISTS)) {
g_set_error(err, ERR_DOMAIN, CRE_EXISTS,
"File already exists");
return NULL;
}
CR_FILE *cr_f = cr_sopen(filename,
CR_CW_MODE_WRITE,
comtype,
stat,
&tmp_err);
if (!cr_f) {
g_propagate_prefixed_error(err, tmp_err, "Cannot open %s: ", filename);
return NULL;
}
f = g_new0(cr_XmlFile, 1);
f->f = cr_f;
f->type = type;
f->header = 0;
f->footer = 0;
f->pkgs = 0;
return f;
}
static gboolean
myopen(FetchData *fetch_data, GError **error)
{
g_return_val_if_fail(fetch_data != NULL, FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
SoupRequest *request;
GError *tmp_error = NULL;
request = (SoupRequest *)soup_session_request_http_uri (session, "GET", fetch_data->url, NULL);
fetch_data->istream = soup_request_send (request, NULL, &tmp_error);
if (tmp_error != NULL) {
gchar *url = soup_uri_to_string (fetch_data->url, TRUE);
g_propagate_prefixed_error(error, tmp_error,
"While connecting to %s: ", url);
g_free (url);
return FALSE;
}
return TRUE;
}
int
cr_xml_parser_warning(cr_ParserData *pd,
cr_XmlParserWarningType type,
const char *msg,
...)
{
int ret;
va_list args;
char *warn;
GError *tmp_err;
assert(pd);
assert(msg);
if (!pd->warningcb)
return CR_CB_RET_OK;
va_start(args, msg);
g_vasprintf(&warn, msg, args);
va_end(args);
tmp_err = NULL;
ret = pd->warningcb(type, warn, pd->warningcb_data, &tmp_err);
g_free(warn);
if (ret != CR_CB_RET_OK) {
if (tmp_err)
g_propagate_prefixed_error(&pd->err, tmp_err,
"Parsing interrupted: ");
else
g_set_error(&pd->err, ERR_DOMAIN, CRE_CBINTERRUPTED,
"Parsing interrupted");
}
assert(pd->err || ret == CR_CB_RET_OK);
return ret;
}
int
lr_xml_parser_warning(LrParserData *pd,
LrXmlParserWarningType type,
const char *msg,
...)
{
int ret;
va_list args;
char *warn;
GError *tmp_err;
assert(pd);
assert(msg);
if (!pd->warningcb)
return LR_CB_RET_OK;
va_start(args, msg);
g_vasprintf(&warn, msg, args);
va_end(args);
tmp_err = NULL;
ret = pd->warningcb(type, warn, pd->warningcb_data, &tmp_err);
g_free(warn);
if (ret != LR_CB_RET_OK) {
if (tmp_err)
g_propagate_prefixed_error(&pd->err, tmp_err,
"Parsing interrupted: ");
else
g_set_error(&pd->err, LR_XML_PARSER_ERROR, LRE_CBINTERRUPTED,
"Parsing interrupted by user callback");
}
assert(pd->err || ret == LR_CB_RET_OK);
return ret;
}
