gboolean
rb_uri_mkstemp (const char *prefix, char **uri_ret, GOutputStream **stream, GError **error)
{
GFile *file;
char *uri = NULL;
GFileOutputStream *fstream;
GError *e = NULL;
do {
g_free (uri);
uri = g_strdup_printf ("%s%06X", prefix, g_random_int_range (0, 0xFFFFFF));
file = g_file_new_for_uri (uri);
fstream = g_file_create (file, G_FILE_CREATE_PRIVATE, NULL, &e);
if (e != NULL) {
if (g_error_matches (e, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
g_error_free (e);
e = NULL;
}
}
} while (e == NULL && fstream == NULL);
if (fstream != NULL) {
*uri_ret = uri;
*stream = G_OUTPUT_STREAM (fstream);
return TRUE;
} else {
g_free (uri);
return FALSE;
}
}
IOChannel::IOChannel(const String& filePath, Type type)
: m_path(filePath)
, m_type(type)
{
auto path = WebCore::fileSystemRepresentation(filePath);
GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(path.data()));
switch (m_type) {
case Type::Create: {
g_file_delete(file.get(), nullptr, nullptr);
m_outputStream = adoptGRef(G_OUTPUT_STREAM(g_file_create(file.get(), static_cast<GFileCreateFlags>(G_FILE_CREATE_PRIVATE), nullptr, nullptr)));
ASSERT(m_outputStream);
GUniquePtr<char> birthtimeString(g_strdup_printf("%" G_GUINT64_FORMAT, std::chrono::system_clock::to_time_t(std::chrono::system_clock::now())));
g_file_set_attribute_string(file.get(), "xattr::birthtime", birthtimeString.get(), G_FILE_QUERY_INFO_NONE, nullptr, nullptr);
break;
}
case Type::Write: {
m_ioStream = adoptGRef(g_file_open_readwrite(file.get(), nullptr, nullptr));
ASSERT(m_ioStream);
break;
}
case Type::Read:
m_inputStream = adoptGRef(G_INPUT_STREAM(g_file_read(file.get(), nullptr, nullptr)));
ASSERT(m_inputStream);
break;
}
}
gboolean initLockFile(void)
{
gboolean ret = TRUE;
GError *error = NULL;
GFileOutputStream *stream = NULL;
gchar *tmpfile = NULL;
myLockFile = NULL;
tmpfile = g_build_filename(g_get_tmp_dir(), "obshutdown.lock", NULL);
if(g_file_test(tmpfile, G_FILE_TEST_EXISTS)) {
printMessage(MSG_ERR, "Obshutdown alredy running! Lockfile \"%s\" exist.\n", tmpfile);
ret = FALSE;
}
else {
myLockFile = g_file_new_for_path(tmpfile);
stream = g_file_create(myLockFile, G_FILE_CREATE_NONE, NULL, &error);
if (!stream) {
printMessage(MSG_ERR, "Lockfile creating failed: %s\n", error->message);
ret = FALSE;
}
else
g_object_unref(stream);
}
g_free(tmpfile);
return ret;
}
static void
do_create (GVfsBackend *backend,
GVfsJobOpenForWrite *job,
const char *filename,
GFileCreateFlags flags)
{
GFile *file;
GFileOutputStream *out;
GError *error;
file = g_vfs_get_file_for_path (g_vfs_get_local (),
filename);
error = NULL;
out = g_file_create (file, flags, G_VFS_JOB (job)->cancellable, &error);
g_object_unref (file);
if (out)
{
g_vfs_job_open_for_write_set_can_seek (job, FALSE);
g_vfs_job_open_for_write_set_handle (job, out);
g_vfs_job_succeeded (G_VFS_JOB (job));
}
else
{
g_vfs_job_failed_from_error (G_VFS_JOB (job), error);
g_error_free (error);
}
}
ScLocalStorageManager* sc_local_storage_manager_new(const gchar *url) {
ScLocalStorageManager *manager = g_new0(ScLocalStorageManager, 1);
SoupURI *uri = soup_uri_new(url);
GString *filename = g_string_new(NULL);
const gchar *host = soup_uri_get_host(uri);
const gchar *path = soup_uri_get_path(uri);
const gchar *query = soup_uri_get_query(uri);
const gchar *fragment = soup_uri_get_fragment(uri);
GFile *parent = NULL;
GError *error = NULL;
g_string_append_printf(filename, "%s/%s", host, path);
if(url[strlen(url) - 1] == '/' || g_strcmp0("/", path) == 0)
g_string_append(filename, "/index.html");
if(query) g_string_append_printf(filename, "/%s\n", query);
if(fragment) g_string_append_printf(filename, "#%s\n", fragment);
manager->file = g_file_new_for_commandline_arg(filename->str);
g_string_free(filename, TRUE);
if(g_file_query_exists(manager->file, NULL)) {
g_file_delete(manager->file, NULL, &error);
if(error && !g_error_matches(error, G_IO_ERROR,G_IO_ERROR_EXISTS)) {
g_critical(G_STRLOC ": %d : %s", error->code, error->message);
g_error_free(error);
g_object_unref(parent);
g_object_unref(manager->file);
g_free(manager);
return NULL;
}
}
parent = g_file_get_parent(manager->file);
g_file_make_directory_with_parents(parent, NULL, &error);
if(error && !g_error_matches(error, G_IO_ERROR,G_IO_ERROR_EXISTS)) {
g_critical(G_STRLOC ": %d : %s", error->code, error->message);
g_error_free(error);
g_object_unref(parent);
g_object_unref(manager->file);
g_free(manager);
return NULL;
}
error = NULL;
manager->ostream = g_file_create(manager->file, G_FILE_CREATE_NONE, NULL, &error);
if(error) {
g_critical(G_STRLOC ": %d : %s", error->code, error->message);
g_error_free(error);
g_object_unref(parent);
g_object_unref(manager->file);
g_free(manager);
return NULL;
}
return manager;
}
JS_EXPORT_API
GFile* desktop_new_file(const char* name_add_before)
{
GFile* file = _get_useable_file_templates(_("New file"),name_add_before);
GFileOutputStream* stream =
g_file_create(file, G_FILE_CREATE_NONE, NULL, NULL);
if (stream)
g_object_unref(stream);
return file;
}
static void
create_one_file (GFile *file)
{
GFileOutputStream* stream;
stream = g_file_create (file, G_FILE_CREATE_NONE, NULL, NULL);
if (stream != NULL) {
g_output_stream_close (G_OUTPUT_STREAM (stream), NULL, NULL);
g_object_unref (stream);
}
}
/* Tests the function for a simple file */
static void
test_simple_file (void)
{
g_autoptr (GFile) root = NULL;
g_autoptr (GFile) file = NULL;
root = g_file_new_for_path (g_get_tmp_dir ());
file = g_file_get_child (root, "simple_file");
g_file_create (file, G_FILE_CREATE_NONE, NULL, NULL);
g_assert_false (dir_has_files (file));
g_assert_true (g_file_delete (file, NULL, NULL));
}
static gboolean
gst_gio_sink_start (GstBaseSink * base_sink)
{
GstGioSink *sink = GST_GIO_SINK (base_sink);
GOutputStream *stream;
GCancellable *cancel = GST_GIO_BASE_SINK (sink)->cancel;
gboolean success;
GError *err = NULL;
gchar *uri;
if (sink->file == NULL) {
GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE, (NULL),
("No location or GFile given"));
return FALSE;
}
uri = g_file_get_uri (sink->file);
if (!uri)
uri = g_strdup ("(null)");
stream =
G_OUTPUT_STREAM (g_file_create (sink->file, G_FILE_CREATE_NONE, cancel,
&err));
success = (stream != NULL);
if (!success && !gst_gio_error (sink, "g_file_create", &err, NULL)) {
/*if (GST_GIO_ERROR_MATCHES (err, EXISTS)) */
/* FIXME: Retry with replace if overwrite == TRUE! */
if (GST_GIO_ERROR_MATCHES (err, NOT_FOUND))
GST_ELEMENT_ERROR (sink, RESOURCE, NOT_FOUND, (NULL),
("Could not open location %s for writing: %s", uri, err->message));
else
GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_READ, (NULL),
("Could not open location %s for writing: %s", uri, err->message));
g_free (uri);
g_clear_error (&err);
}
if (!success)
return FALSE;
GST_DEBUG_OBJECT (sink, "opened location %s", uri);
g_free (uri);
gst_gio_base_sink_set_stream (GST_GIO_BASE_SINK (sink), stream);
return GST_BASE_SINK_CLASS (parent_class)->start (base_sink);
}
void didReceiveResponse(ResourceHandle*, const ResourceResponse& response)
{
m_response = response;
m_download->didReceiveResponse(response);
if (response.httpStatusCode() >= 400) {
downloadFailed(platformDownloadNetworkError(response.httpStatusCode(), response.url(), response.httpStatusText()));
return;
}
String suggestedFilename = response.suggestedFilename();
if (suggestedFilename.isEmpty()) {
URL url = response.url();
url.setQuery(String());
url.removeFragmentIdentifier();
suggestedFilename = decodeURLEscapeSequences(url.lastPathComponent());
}
String destinationURI = m_download->decideDestinationWithSuggestedFilename(suggestedFilename, m_allowOverwrite);
if (destinationURI.isEmpty()) {
#if PLATFORM(GTK)
GUniquePtr<char> buffer(g_strdup_printf(_("Cannot determine destination URI for download with suggested filename %s"), suggestedFilename.utf8().data()));
String errorMessage = String::fromUTF8(buffer.get());
#else
String errorMessage = makeString("Cannot determine destination URI for download with suggested filename ", suggestedFilename);
#endif
downloadFailed(platformDownloadDestinationError(response, errorMessage));
return;
}
m_destinationFile = adoptGRef(g_file_new_for_uri(destinationURI.utf8().data()));
GRefPtr<GFileOutputStream> outputStream;
GUniqueOutPtr<GError> error;
if (m_allowOverwrite)
outputStream = adoptGRef(g_file_replace(m_destinationFile.get(), nullptr, FALSE, G_FILE_CREATE_NONE, nullptr, &error.outPtr()));
else
outputStream = adoptGRef(g_file_create(m_destinationFile.get(), G_FILE_CREATE_NONE, nullptr, &error.outPtr()));
if (!outputStream) {
m_destinationFile.clear();
downloadFailed(platformDownloadDestinationError(response, error->message));
return;
}
String intermediateURI = destinationURI + ".wkdownload";
m_intermediateFile = adoptGRef(g_file_new_for_uri(intermediateURI.utf8().data()));
m_outputStream = adoptGRef(g_file_replace(m_intermediateFile.get(), 0, TRUE, G_FILE_CREATE_NONE, 0, &error.outPtr()));
if (!m_outputStream) {
downloadFailed(platformDownloadDestinationError(response, error->message));
return;
}
m_download->didCreateDestination(destinationURI);
}
/* Touch. */
gboolean
misc_create_file (const gchar *filepath)
{
GFileOutputStream *noused;
GFile *file;
file = g_file_new_for_path (filepath);
noused = g_file_create (file, G_FILE_CREATE_NONE, NULL, NULL);
g_object_unref(file);
return noused != NULL;
}
void
lsm_dom_document_save_to_url (LsmDomDocument *document, const char *path, GError **error)
{
GFile *file;
GFileOutputStream *stream;
g_return_if_fail (path != NULL);
file = g_file_new_for_uri (path);
stream = g_file_create (file, G_FILE_CREATE_REPLACE_DESTINATION, NULL, error);
if (stream != NULL) {
lsm_dom_document_save_to_stream (document, G_OUTPUT_STREAM (stream), error);
g_object_unref (stream);
}
g_object_unref (file);
}
static gboolean
ori_save (gchar * fn, gboolean replace)
{
gchar *text;
GFile *fp;
GFileOutputStream *file_out;
GError *error = NULL;
char *nullstr = "NULLSTRING";
gssize bytes;
if (!fn)
fn = nullstr;
fp = g_file_new_for_uri (fn);
file_out = g_file_create (fp, G_FILE_CREATE_NONE, NULL, &error);
if ((file_out == NULL) && (error->code == G_IO_ERROR_EXISTS))
{
if (replace)
{
g_error_free (error);
/* replace file */
file_out = g_file_replace (fp, NULL, TRUE, G_FILE_CREATE_NONE, NULL, &error);
}
}
text = gui_editor_get_text (app->editor);
if (file_out == NULL)
{
gchar errmsg[MAX_ERR_MSG_SIZE + 1];
g_snprintf (errmsg, MAX_ERR_MSG_SIZE, _("Failed to save <%s>"),
fn);
gui_app_show_msg (GTK_MESSAGE_ERROR, errmsg);
return TRUE;
}
bytes = g_output_stream_write (G_OUTPUT_STREAM (file_out), text, strlen (text), NULL, NULL);
gtk_text_buffer_set_modified ((GtkTextBuffer *)app->editor->buffer, FALSE);
/* debug */
g_output_stream_close (G_OUTPUT_STREAM (file_out), NULL, NULL);
g_free (text);
if (replace)
_set_file_name (fn);
/*g_error_free (error);*/
return TRUE;
}
/* called in an I/O thread */
static GOutputStream *
get_stream_for_unique_path (const gchar *path,
const gchar *filename,
gchar **filename_used)
{
GOutputStream *stream;
GFile *file;
gchar *real_path, *real_filename, *name, *ptr;
gint idx;
ptr = g_strrstr (filename, ".png");
if (ptr != NULL)
real_filename = g_strndup (filename, ptr - filename);
else
real_filename = g_strdup (filename);
idx = 0;
real_path = NULL;
do
{
if (idx == 0)
name = g_strdup_printf ("%s.png", real_filename);
else
name = g_strdup_printf ("%s - %d.png", real_filename, idx);
real_path = g_build_filename (path, name, NULL);
g_free (name);
file = g_file_new_for_path (real_path);
stream = G_OUTPUT_STREAM (g_file_create (file, G_FILE_CREATE_NONE, NULL, NULL));
g_object_unref (file);
if (stream != NULL)
*filename_used = real_path;
else
g_free (real_path);
idx++;
}
while (stream == NULL);
g_free (real_filename);
return stream;
}
static void
_completion_create_initial_file(GFile *file, const gchar *text)
{
gchar *path;
gint len;
GFileOutputStream *stream;
gchar buffer[block_size];
g_assert(file != NULL);
g_assert(text != NULL);
len = strlen(text);
g_return_if_fail(len <= COMPLETION_STRING_SIZE);
path = g_file_get_path(file);
g_debug("Creating file: \"%s\"", path);
if((stream = g_file_create(file, G_FILE_CREATE_PRIVATE, NULL, NULL)))
{
memset(buffer, 0, block_size);
memcpy(buffer + COMPLETION_COUNTER_SIZE, text, len);
g_debug("Appending new text: \"%s\"", text);
g_output_stream_write(G_OUTPUT_STREAM(stream), buffer, block_size, NULL, NULL);
g_output_stream_flush(G_OUTPUT_STREAM(stream), NULL, NULL);
g_output_stream_close(G_OUTPUT_STREAM(stream), NULL, NULL);
g_object_unref(stream);
}
else
{
g_warning("Couldn't create file: \"%s\"", path);
}
g_free(path);
}
static void
export_png (GtkButton *button,
ChamplainView *view)
{
cairo_surface_t *surface;
GdkPixbuf *pixbuf;
GFileOutputStream *os;
GFile *file;
gint width, height;
if (champlain_view_get_state (view) != CHAMPLAIN_STATE_DONE)
return;
surface = champlain_view_to_surface (view, TRUE);
if (!surface)
return;
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
pixbuf = gdk_pixbuf_get_from_surface (surface, 0, 0, width, height);
if (!pixbuf)
return;
file = g_file_new_for_path ("champlain-map.png");
os = g_file_create (file, G_FILE_CREATE_NONE, NULL, NULL);
if (!os)
{
g_object_unref (pixbuf);
return;
}
gdk_pixbuf_save_to_stream_async (pixbuf,
G_OUTPUT_STREAM (os), "png",
NULL,
(GAsyncReadyCallback) export_to_png_cb,
NULL);
}
gboolean
ostree_create_file_from_input (GFile *dest_file,
GFileInfo *finfo,
GVariant *xattrs,
GInputStream *input,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
const char *dest_path;
guint32 uid, gid, mode;
ot_lobj GFileOutputStream *out = NULL;
if (g_cancellable_set_error_if_cancelled (cancellable, error))
return FALSE;
if (finfo != NULL)
{
mode = g_file_info_get_attribute_uint32 (finfo, "unix::mode");
}
else
{
mode = S_IFREG | 0664;
}
dest_path = ot_gfile_get_path_cached (dest_file);
if (S_ISDIR (mode))
{
if (mkdir (ot_gfile_get_path_cached (dest_file), mode) < 0)
{
ot_util_set_error_from_errno (error, errno);
goto out;
}
}
else if (S_ISREG (mode))
{
out = g_file_create (dest_file, 0, cancellable, error);
if (!out)
goto out;
if (input)
{
if (g_output_stream_splice ((GOutputStream*)out, input, 0,
cancellable, error) < 0)
goto out;
}
if (!g_output_stream_close ((GOutputStream*)out, NULL, error))
goto out;
}
else if (S_ISLNK (mode))
{
const char *target = g_file_info_get_attribute_byte_string (finfo, "standard::symlink-target");
if (symlink (target, dest_path) < 0)
{
ot_util_set_error_from_errno (error, errno);
goto out;
}
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
{
guint32 dev = g_file_info_get_attribute_uint32 (finfo, "unix::rdev");
if (mknod (dest_path, mode, dev) < 0)
{
ot_util_set_error_from_errno (error, errno);
goto out;
}
}
else if (S_ISFIFO (mode))
{
if (mkfifo (dest_path, mode) < 0)
{
ot_util_set_error_from_errno (error, errno);
goto out;
}
}
else
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Invalid mode %u", mode);
goto out;
}
if (finfo != NULL)
{
uid = g_file_info_get_attribute_uint32 (finfo, "unix::uid");
gid = g_file_info_get_attribute_uint32 (finfo, "unix::gid");
if (lchown (dest_path, uid, gid) < 0)
{
ot_util_set_error_from_errno (error, errno);
g_prefix_error (error, "lchown(%u, %u) failed: ", uid, gid);
goto out;
}
}
if (!S_ISLNK (mode))
{
if (chmod (dest_path, mode) < 0)
{
ot_util_set_error_from_errno (error, errno);
g_prefix_error (error, "chmod(%u) failed: ", mode);
goto out;
}
}
if (xattrs != NULL)
{
if (!ostree_set_xattrs (dest_file, xattrs, cancellable, error))
goto out;
}
ret = TRUE;
out:
if (!ret && !S_ISDIR(mode))
{
(void) unlink (dest_path);
}
return ret;
}
static void
catalog_new_dialog_response_cb (GtkWidget *dialog,
int response_id,
gpointer user_data)
{
GthBrowser *browser = user_data;
char *name;
GthFileData *selected_parent;
GFile *parent;
GthFileSource *file_source;
GFile *gio_parent;
char *display_name;
GError *error = NULL;
GFile *gio_file;
if (response_id != GTK_RESPONSE_OK) {
gtk_widget_destroy (dialog);
return;
}
name = gth_request_dialog_get_normalized_text (GTH_REQUEST_DIALOG (dialog));
if (_g_utf8_all_spaces (name)) {
g_free (name);
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, _("No name specified"));
return;
}
if (g_regex_match_simple ("/", name, 0, 0)) {
char *message;
message = g_strdup_printf (_("Invalid name. The following characters are not allowed: %s"), "/");
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, message);
g_free (message);
g_free (name);
return;
}
selected_parent = gth_browser_get_folder_popup_file_data (browser);
if (selected_parent != NULL) {
GthFileSource *file_source;
GFileInfo *info;
file_source = gth_main_get_file_source (selected_parent->file);
info = gth_file_source_get_file_info (file_source, selected_parent->file, GFILE_BASIC_ATTRIBUTES);
if (g_file_info_get_attribute_boolean (info, "gthumb::no-child"))
parent = g_file_get_parent (selected_parent->file);
else
parent = g_file_dup (selected_parent->file);
g_object_unref (info);
g_object_unref (file_source);
}
else
parent = g_file_new_for_uri ("catalog:///");
file_source = gth_main_get_file_source (parent);
gio_parent = gth_file_source_to_gio_file (file_source, parent);
display_name = g_strconcat (name, ".catalog", NULL);
gio_file = g_file_get_child_for_display_name (gio_parent, display_name, &error);
if (gio_file != NULL) {
GFileOutputStream *stream;
stream = g_file_create (gio_file, G_FILE_CREATE_NONE, NULL, &error);
if (stream != NULL) {
GFile *file;
GList *list;
file = gth_catalog_file_from_gio_file (gio_file, NULL);
list = g_list_prepend (NULL, file);
gth_monitor_folder_changed (gth_main_get_default_monitor (),
parent,
list,
GTH_MONITOR_EVENT_CREATED);
g_list_free (list);
g_object_unref (file);
g_object_unref (stream);
}
g_object_unref (gio_file);
}
if (error != NULL) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS))
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, _("Name already used"));
else
gth_request_dialog_set_info_text (GTH_REQUEST_DIALOG (dialog), GTK_MESSAGE_ERROR, error->message);
g_clear_error (&error);
}
else
gtk_widget_destroy (dialog);
g_free (display_name);
g_object_unref (gio_parent);
g_object_unref (file_source);
g_free (name);
}
void on_create_new(GtkAction* action, FmMainWin* win)
{
FmFolderView* fv = FM_FOLDER_VIEW(win->folder_view);
const char* name = gtk_action_get_name(action);
GError* err = NULL;
FmPath* cwd = fm_folder_view_get_cwd(fv);
FmPath* dest;
char* basename;
_retry:
basename = fm_get_user_input(GTK_WINDOW(win), _("Create New..."), _("Enter a name for the newly created file:"), _("New"));
if(!basename)
return;
dest = fm_path_new_child(cwd, basename);
g_free(basename);
if( strcmp(name, "NewFolder") == 0 )
{
GFile* gf = fm_path_to_gfile(dest);
if(!g_file_make_directory(gf, NULL, &err))
{
if(err->domain = G_IO_ERROR && err->code == G_IO_ERROR_EXISTS)
{
fm_path_unref(dest);
g_error_free(err);
g_object_unref(gf);
err = NULL;
goto _retry;
}
fm_show_error(GTK_WINDOW(win), err->message);
g_error_free(err);
}
if(!err) /* select the newly created file */
{
/*FIXME: this doesn't work since the newly created file will
* only be shown after file-created event was fired on its
* folder's monitor and after FmFolder handles it in idle
* handler. So, we cannot select it since it's not yet in
* the folder model now. */
/* fm_folder_view_select_file_path(fv, dest); */
}
g_object_unref(gf);
}
else if( strcmp(name, "NewBlank") == 0 )
{
GFile* gf = fm_path_to_gfile(dest);
GFileOutputStream* f = g_file_create(gf, G_FILE_CREATE_NONE, NULL, &err);
if(f)
{
g_output_stream_close(G_OUTPUT_STREAM(f), NULL, NULL);
g_object_unref(f);
}
else
{
if(err->domain = G_IO_ERROR && err->code == G_IO_ERROR_EXISTS)
{
fm_path_unref(dest);
g_error_free(err);
g_object_unref(gf);
err = NULL;
goto _retry;
}
fm_show_error(GTK_WINDOW(win), err->message);
g_error_free(err);
}
if(!err) /* select the newly created file */
{
/*FIXME: this doesn't work since the newly created file will
* only be shown after file-created event was fired on its
* folder's monitor and after FmFolder handles it in idle
* handler. So, we cannot select it since it's not yet in
* the folder model now. */
/* fm_folder_view_select_file_path(fv, dest); */
}
g_object_unref(gf);
}
else /* templates */
{
}
fm_path_unref(dest);
}
static gboolean
run (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
g_autoptr(GOptionContext) context = NULL;
const char *dirpath;
OtTrivialHttpd appstruct = { 0, };
OtTrivialHttpd *app = &appstruct;
glnx_unref_object SoupServer *server = NULL;
g_autoptr(GFileMonitor) dirmon = NULL;
context = g_option_context_new ("[DIR] - Simple webserver");
g_option_context_add_main_entries (context, options, NULL);
app->root_dfd = -1;
if (!g_option_context_parse (context, &argc, &argv, error))
goto out;
if (argc > 1)
dirpath = argv[1];
else
dirpath = ".";
if (!glnx_opendirat (AT_FDCWD, dirpath, TRUE, &app->root_dfd, error))
goto out;
if (!(opt_random_500s_percentage >= 0 && opt_random_500s_percentage <= 99))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Invalid --random-500s=%u", opt_random_500s_percentage);
goto out;
}
if (opt_log)
{
GOutputStream *stream = NULL;
if (g_strcmp0 (opt_log, "-") == 0)
{
if (opt_daemonize)
{
ot_util_usage_error (context, "Cannot use --log-file=- and --daemonize at the same time", error);
goto out;
}
stream = G_OUTPUT_STREAM (g_unix_output_stream_new (STDOUT_FILENO, FALSE));
}
else
{
g_autoptr(GFile) log_file = NULL;
GFileOutputStream* log_stream;
log_file = g_file_new_for_path (opt_log);
log_stream = g_file_create (log_file,
G_FILE_CREATE_PRIVATE,
cancellable,
error);
if (!log_stream)
goto out;
stream = G_OUTPUT_STREAM (log_stream);
}
app->log = stream;
}
#if SOUP_CHECK_VERSION(2, 48, 0)
server = soup_server_new (SOUP_SERVER_SERVER_HEADER, "ostree-httpd ", NULL);
if (!soup_server_listen_all (server, opt_port, 0, error))
goto out;
#else
server = soup_server_new (SOUP_SERVER_PORT, opt_port,
SOUP_SERVER_SERVER_HEADER, "ostree-httpd ",
NULL);
#endif
soup_server_add_handler (server, NULL, httpd_callback, app, NULL);
if (opt_port_file)
{
g_autofree char *portstr = NULL;
#if SOUP_CHECK_VERSION(2, 48, 0)
GSList *listeners = soup_server_get_listeners (server);
g_autoptr(GSocket) listener = NULL;
g_autoptr(GSocketAddress) addr = NULL;
g_assert (listeners);
listener = g_object_ref (listeners->data);
g_slist_free (listeners);
listeners = NULL;
addr = g_socket_get_local_address (listener, error);
if (!addr)
goto out;
g_assert (G_IS_INET_SOCKET_ADDRESS (addr));
portstr = g_strdup_printf ("%u\n", g_inet_socket_address_get_port ((GInetSocketAddress*)addr));
#else
portstr = g_strdup_printf ("%u\n", soup_server_get_port (server));
#endif
if (g_strcmp0 ("-", opt_port_file) == 0)
{
fputs (portstr, stdout); // not g_print - this must go to stdout, not a handler
fflush (stdout);
}
else if (!g_file_set_contents (opt_port_file, portstr, strlen (portstr), error))
goto out;
}
#if !SOUP_CHECK_VERSION(2, 48, 0)
soup_server_run_async (server);
#endif
if (opt_daemonize)
{
pid_t pid = fork();
if (pid == -1)
{
int errsv = errno;
g_set_error_literal (error, G_IO_ERROR, g_io_error_from_errno (errsv),
g_strerror (errsv));
goto out;
}
else if (pid > 0)
{
ret = TRUE;
goto out;
}
/* Child, continue */
if (setsid () < 0)
err (1, "setsid");
/* Daemonising: close stdout/stderr so $() et al work on us */
if (freopen("/dev/null", "r", stdin) == NULL)
err (1, "freopen");
if (freopen("/dev/null", "w", stdout) == NULL)
err (1, "freopen");
if (freopen("/dev/null", "w", stderr) == NULL)
err (1, "freopen");
}
else
{
/* Since we're used for testing purposes, let's just do this by
* default. This ensures we exit when our parent does.
*/
if (prctl (PR_SET_PDEATHSIG, SIGTERM) != 0)
{
if (errno != ENOSYS)
{
glnx_set_error_from_errno (error);
goto out;
}
}
}
app->running = TRUE;
if (opt_autoexit)
{
gboolean is_symlink = FALSE;
g_autoptr(GFile) root = NULL;
g_autoptr(GFileInfo) info = NULL;
root = g_file_new_for_path (dirpath);
info = g_file_query_info (root,
G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
cancellable, error);
if (!info)
goto out;
is_symlink = g_file_info_get_is_symlink (info);
if (is_symlink)
dirmon = g_file_monitor_file (root, 0, cancellable, error);
else
dirmon = g_file_monitor_directory (root, 0, cancellable, error);
if (!dirmon)
goto out;
g_signal_connect (dirmon, "changed", G_CALLBACK (on_dir_changed), app);
}
httpd_log (app, "serving at root %s\n", dirpath);
while (app->running)
g_main_context_iteration (NULL, TRUE);
ret = TRUE;
out:
if (app->root_dfd != -1)
(void) close (app->root_dfd);
g_clear_object (&app->log);
return ret;
}
gboolean
ot_gpgme_ctx_tmp_home_dir (gpgme_ctx_t gpgme_ctx,
const char *tmp_dir,
char **out_tmp_home_dir,
GOutputStream **out_pubring_stream,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GFile) pubring_file = NULL;
g_autoptr(GOutputStream) target_stream = NULL;
g_autofree char *pubring_path = NULL;
g_autofree char *tmp_home_dir = NULL;
gpgme_error_t gpg_error;
gboolean ret = FALSE;
g_return_val_if_fail (gpgme_ctx != NULL, FALSE);
/* GPGME has no API for using multiple keyrings (aka, gpg --keyring),
* so we create a temporary directory and tell GPGME to use it as the
* home directory. Then (optionally) create a pubring.gpg file there
* and hand the caller an open output stream to concatenate necessary
* keyring files. */
if (tmp_dir == NULL)
tmp_dir = g_get_tmp_dir ();
tmp_home_dir = g_build_filename (tmp_dir, "ostree-gpg-XXXXXX", NULL);
if (mkdtemp (tmp_home_dir) == NULL)
{
glnx_set_error_from_errno (error);
goto out;
}
/* Not documented, but gpgme_ctx_set_engine_info() accepts NULL for
* the executable file name, which leaves the old setting unchanged. */
gpg_error = gpgme_ctx_set_engine_info (gpgme_ctx,
GPGME_PROTOCOL_OpenPGP,
NULL, tmp_home_dir);
if (gpg_error != GPG_ERR_NO_ERROR)
{
ot_gpgme_error_to_gio_error (gpg_error, error);
goto out;
}
if (out_pubring_stream != NULL)
{
GFileOutputStream *pubring_stream;
glnx_unref_object GFile *pubring_file = NULL;
g_autofree char *pubring_path = NULL;
pubring_path = g_build_filename (tmp_home_dir, "pubring.gpg", NULL);
pubring_file = g_file_new_for_path (pubring_path);
pubring_stream = g_file_create (pubring_file,
G_FILE_CREATE_NONE,
cancellable, error);
if (pubring_stream == NULL)
goto out;
/* Sneaky cast from GFileOutputStream to GOutputStream. */
*out_pubring_stream = g_steal_pointer (&pubring_stream);
}
if (out_tmp_home_dir != NULL)
*out_tmp_home_dir = g_steal_pointer (&tmp_home_dir);
ret = TRUE;
out:
if (!ret)
{
/* Clean up our mess on error. */
(void) glnx_shutil_rm_rf_at (AT_FDCWD, tmp_home_dir, NULL, NULL);
}
return ret;
}
static GFile *
filebox_uploader_handle_task_create_tmp (HevFileboxUploader *self,
GObject *task, GInputStream *req_stream, GHashTable *req_htb,
GHashTable *res_htb, const gchar *ft_path, gsize size)
{
GFile *file = NULL;
gboolean status = TRUE;
gchar name[256], *path = NULL;
const gchar *remote_addr = NULL, *remote_port = NULL;
GFileOutputStream *file_ostream = NULL;
g_debug ("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
remote_addr = g_hash_table_lookup (req_htb, "REMOTE_ADDR");
remote_port = g_hash_table_lookup (req_htb, "REMOTE_PORT");
g_snprintf (name, 256, "%s-%s.tmp", remote_addr, remote_port);
path = g_build_filename (ft_path, name, NULL);
file = g_file_new_for_path (path);
g_free (path);
file_ostream = g_file_create (file, G_FILE_CREATE_PRIVATE, NULL, NULL);
if (!file_ostream) {
g_hash_table_insert (res_htb, g_strdup ("Status"), g_strdup ("403 Forbidden"));
g_object_unref (file);
return NULL;
}
/* write to tmp file */
for (; 0<size;) {
guint8 buffer[8192];
gssize rsize = 0;
rsize = g_input_stream_read (req_stream,
buffer, 8192, NULL, NULL);
if (-1 == rsize) {
status = FALSE;
break;
} else if (0 == rsize) {
break;
}
if (!g_output_stream_write_all (G_OUTPUT_STREAM (file_ostream),
buffer, rsize, NULL, NULL, NULL)) {
status = FALSE;
break;
}
size -= rsize;
}
g_object_unref (file_ostream);
if (!status) {
g_hash_table_insert (res_htb, g_strdup ("Status"),
g_strdup ("500 Internal Server Error"));
g_object_unref (file);
return NULL;
}
return file;
}
static gboolean
_save_to_uri (GESFormatter * formatter, GESTimeline * timeline,
const gchar * uri, gboolean overwrite, GError ** error)
{
GFile *file;
gboolean ret;
GString *str;
GOutputStream *stream;
GError *lerror = NULL;
g_return_val_if_fail (formatter->project, FALSE);
file = g_file_new_for_uri (uri);
stream = G_OUTPUT_STREAM (g_file_create (file, G_FILE_CREATE_NONE, NULL,
&lerror));
if (stream == NULL) {
if (overwrite && lerror->code == G_IO_ERROR_EXISTS) {
g_clear_error (&lerror);
stream = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE,
G_FILE_CREATE_NONE, NULL, &lerror));
}
if (stream == NULL)
goto failed_opening_file;
}
str = GES_BASE_XML_FORMATTER_GET_CLASS (formatter)->save (formatter,
timeline, error);
if (str == NULL)
goto serialization_failed;
ret = g_output_stream_write_all (stream, str->str, str->len, NULL,
NULL, &lerror);
ret = g_output_stream_close (stream, NULL, &lerror);
if (ret == FALSE)
GST_WARNING_OBJECT (formatter, "Could not save %s because: %s", uri,
lerror->message);
g_string_free (str, TRUE);
gst_object_unref (file);
gst_object_unref (stream);
if (lerror)
g_propagate_error (error, lerror);
return ret;
serialization_failed:
gst_object_unref (file);
g_output_stream_close (stream, NULL, NULL);
gst_object_unref (stream);
if (lerror)
g_propagate_error (error, lerror);
return FALSE;
failed_opening_file:
gst_object_unref (file);
GST_WARNING_OBJECT (formatter, "Could not open %s because: %s", uri,
lerror->message);
if (lerror)
g_propagate_error (error, lerror);
return FALSE;
}
static void
file_ptr_array_foreach_write_meta_handler (gpointer data, gpointer user_data)
{
GFile *file = G_FILE (data), *meta_file = NULL;
GObject *scgi_task = G_OBJECT (user_data);
GObject *request = NULL;
GHashTable *req_htb = NULL;
gchar *duration = NULL, *one_off = NULL, *rand_pass = NULL;
GKeyFile *meta = NULL;
GDateTime *crt_time = NULL, *exp_time = NULL;
GFileOutputStream *file_ostream = NULL;
guint64 dur = 0;
g_debug ("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
request = hev_scgi_task_get_request (HEV_SCGI_TASK (scgi_task));
req_htb = hev_scgi_request_get_header_hash_table (HEV_SCGI_REQUEST (request));
duration = g_object_get_data (scgi_task, "duration");
one_off = g_object_get_data (scgi_task, "one-off");
rand_pass = g_object_get_data (scgi_task, "rand-pass");
meta_file = g_object_get_data (G_OBJECT (file), "meta");
g_file_delete (meta_file, NULL, NULL);
meta = g_key_file_new ();
/* set meta contents */
crt_time = g_date_time_new_now_utc ();
g_key_file_set_int64 (meta, "Meta", "CrtDate",
g_date_time_to_unix (crt_time));
if (duration) {
dur = g_ascii_strtoull (duration, NULL, 10);
if ((0 >= dur) || (7 < dur))
dur = 1;
} else {
dur = 1;
}
exp_time = g_date_time_add_days (crt_time, dur);
g_key_file_set_int64 (meta, "Meta", "ExpDate",
g_date_time_to_unix (exp_time));
g_date_time_unref (exp_time);
g_date_time_unref (crt_time);
g_key_file_set_boolean (meta, "Meta", "OneOff", one_off ? TRUE : FALSE);
g_key_file_set_string (meta, "Meta", "IP",
g_hash_table_lookup (req_htb, "REMOTE_ADDR"));
g_key_file_set_string (meta, "Meta", "RandPass", rand_pass);
/* create and write to meta file */
file_ostream = g_file_create (meta_file, G_FILE_CREATE_PRIVATE, NULL, NULL);
if (file_ostream) {
gchar *data = NULL;
gsize length = 0;
data = g_key_file_to_data (meta, &length, NULL);
g_output_stream_write_all (G_OUTPUT_STREAM (file_ostream),
data, length, NULL, NULL, NULL);
g_free (data);
g_object_unref (file_ostream);
}
g_key_file_unref (meta);
}
static void
update_mimelist (NemoMimeApplicationChooser *chooser, const gchar *fn, gboolean def)
{
gchar *list_fn = g_build_filename (g_get_user_data_dir (), "applications", "mimeapps.list", NULL);
GKeyFile *mimeapps;
GFile *list_file;
list_file = g_file_new_for_path (list_fn);
mimeapps = g_key_file_new ();
if (g_file_query_exists (list_file, NULL)) {
g_key_file_load_from_file (mimeapps,
list_fn,
G_KEY_FILE_NONE,
NULL);
}
if (def) {
g_key_file_set_string (mimeapps,
DEFAULT_APPS,
chooser->details->content_type,
fn);
} else {
gsize count;
gchar **l = g_key_file_get_string_list (mimeapps,
ADDED_ASS,
chooser->details->content_type,
&count,
NULL);
gchar *new_string_list;
if (l) {
gchar *temp_list;
temp_list = g_strjoinv (";", l);
new_string_list = g_strdup_printf ("%s;%s;", fn, temp_list);
g_free (temp_list);
g_strfreev (l);
} else {
new_string_list = g_strdup_printf ("%s;", fn);
}
g_key_file_set_string (mimeapps,
ADDED_ASS,
chooser->details->content_type,
new_string_list);
}
if (g_file_query_exists (list_file, NULL)) {
g_file_delete (list_file, NULL, NULL);
}
gsize size;
gchar *buffer = g_key_file_to_data (mimeapps, &size, NULL);
GFileOutputStream *out;
gboolean res;
out = g_file_create (list_file,
G_FILE_CREATE_NONE,
NULL,
NULL);
if (out) {
res = g_output_stream_write_all (G_OUTPUT_STREAM (out),
buffer, size,
NULL,
NULL,
NULL);
if (res) {
res = g_output_stream_close (G_OUTPUT_STREAM (out),
NULL,
NULL);
}
g_object_unref (out);
}
g_free (buffer);
}
static GOutputStream *
get_checksum_stream (CheckcopyFileList * list, GFile * dest)
{
CheckcopyFileListPrivate *priv = GET_PRIVATE (list);
gchar * basename;
gchar * checksum_name;
GFileOutputStream * out = NULL;
GError *error = NULL;
GCancellable * cancel;
GFile *checksum = NULL;
gint i;
gchar *ext = "CHECKSUM";
cancel = checkcopy_get_cancellable ();
if (priv->checksum_file) {
/* We already have a file. Just append to it. */
out = g_file_append_to (priv->checksum_file, 0, cancel, &error);
if (!out || error) {
thread_show_gerror (dest, error);
g_error_free (error);
error = NULL;
return NULL;
} else {
return G_OUTPUT_STREAM (out);
}
}
/* We do not have a file yet, search for one */
basename = g_file_get_basename (dest);
i = 0;
do {
DBG ("Try %d to generate a checksum file name", i);
if (checksum) {
g_object_unref (checksum);
checksum = NULL;
}
if (error) {
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS)) {
/* There was an error, but it was not that the file already exists.
* We should abort at this point. */
thread_show_error (_("Failed to create checksum file: %s"), error->message);
g_error_free (error);
error = NULL;
break;
} else {
/* continue with next iteration */
g_error_free (error);
error = NULL;
if (i > MAX_CHECKSUM_FILE_RETRIES) {
thread_show_error (_("Maximum number of retries reached.\nCould not create a checksum file."));
break;
}
}
}
if (basename == NULL) {
checksum_name = g_strdup (ext);
} else {
if (i==0)
checksum_name = g_strconcat (basename, ".", ext, NULL);
else
checksum_name = g_strdup_printf ("%s-%d.%s", basename, i, ext);
}
checksum = g_file_resolve_relative_path (dest, checksum_name);
i++;
if (g_cancellable_set_error_if_cancelled (cancel, &error)) {
break;
}
} while ((out = g_file_create (checksum, 0, cancel, &error)) == NULL);
g_free (basename);
if (out) {
priv->checksum_file = checksum;
return G_OUTPUT_STREAM (out);
} else {
if (checksum)
g_object_unref (checksum);
return NULL;
}
}
static void
create_custom_desktop_file (NemoMimeApplicationChooser *chooser, gboolean def)
{
GKeyFile *keyfile = g_key_file_new ();
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_EXEC,
g_app_info_get_commandline (chooser->details->custom_info));
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_NAME,
g_app_info_get_display_name (chooser->details->custom_info));
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_MIME_TYPE,
chooser->details->content_type);
g_key_file_set_string (keyfile,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_TYPE,
G_KEY_FILE_DESKTOP_TYPE_APPLICATION);
gsize size;
gchar *buffer = g_key_file_to_data (keyfile, &size, NULL);
gint32 rn = g_random_int_range (0, G_MAXINT32 - 1);
gchar *fn = g_strdup_printf ("nemo_%s_%d.desktop",
g_app_info_get_display_name (chooser->details->custom_info),
rn);
gchar *path = g_build_filename (g_get_user_data_dir (), "applications", fn, NULL);
GFile *outfile = g_file_new_for_path (path);
g_free (path);
GFileOutputStream *out;
gboolean res;
out = g_file_create (outfile,
G_FILE_CREATE_NONE,
NULL,
NULL);
if (out) {
res = g_output_stream_write_all (G_OUTPUT_STREAM (out),
buffer, size,
NULL,
NULL,
NULL);
if (res) {
res = g_output_stream_close (G_OUTPUT_STREAM (out),
NULL,
NULL);
update_mimelist (chooser, fn, def);
}
g_object_unref (out);
}
g_object_unref (outfile);
g_free (fn);
g_free (buffer);
}
static GFile *
filebox_uploader_handle_task_create_file (HevFileboxUploader *self,
GHashTable *res_htb, const gchar *fp_path, const gchar *fm_path,
const gchar *filename, const gchar *contents, gsize length)
{
GFile *file = NULL, *meta = NULL;
GRegex *regex = NULL;
GMatchInfo *match_info = NULL;
gchar *file_name = NULL, *basename = NULL, *file_path = NULL, *meta_path = NULL;
GFileOutputStream *file_ostream = NULL;
g_debug ("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
/* fetch filename */
regex = g_regex_new ("filename=\"(.+)\"", 0, 0, NULL);
if (g_regex_match (regex, filename, 0, &match_info))
file_name = g_match_info_fetch (match_info, 1);
g_match_info_unref (match_info);
g_regex_unref (regex);
/* build file path and meta path */
basename = g_path_get_basename (file_name);
g_free (file_name);
file_path = g_build_filename (fp_path, basename, NULL);
meta_path = g_build_filename (fm_path, basename, NULL);
g_free (basename);
/* new file */
file = g_file_new_for_path (file_path);
g_free (file_path);
if (!file) {
g_hash_table_insert (res_htb, g_strdup ("Status"),
g_strdup ("500 Internal Server Error"));
g_free (meta_path);
return NULL;
}
/* craete file */
file_ostream = g_file_create (file, G_FILE_CREATE_PRIVATE, NULL, NULL);
if (!file_ostream) {
g_hash_table_insert (res_htb, g_strdup ("Status"),
g_strdup ("403 Forbidden"));
g_object_unref (file);
g_free (meta_path);
return NULL;
}
/* write contents to file */
if (!g_output_stream_write_all (G_OUTPUT_STREAM (file_ostream),
contents, length, NULL, NULL, NULL)) {
g_hash_table_insert (res_htb, g_strdup ("Status"),
g_strdup ("500 Internal Server Error"));
g_object_unref (file_ostream);
g_file_delete (file, NULL, NULL);
g_object_unref (file);
g_free (meta_path);
return NULL;
}
/* new meta file */
meta = g_file_new_for_path (meta_path);
g_free (meta_path);
if (!meta) {
g_hash_table_insert (res_htb, g_strdup ("Status"),
g_strdup ("500 Internal Server Error"));
g_object_unref (file_ostream);
g_file_delete (file, NULL, NULL);
g_object_unref (file);
return NULL;
}
g_object_set_data_full (G_OBJECT (file), "meta", meta,
(GDestroyNotify) g_object_unref);
g_object_unref (file_ostream);
return file;
}
static char *
create_desktop_file (const char *id,
const char *name,
const char *address,
const char *profile_dir,
GdkPixbuf *icon)
{
GKeyFile *file = NULL;
char *exec_string;
char *data = NULL;
char *filename, *apps_path, *desktop_file_path = NULL;
char *link_path;
char *wm_class;
GFile *link;
GError *error = NULL;
g_assert (profile_dir);
filename = get_app_desktop_filename (id);
if (!filename)
return NULL;
file = g_key_file_new ();
g_key_file_set_value (file, "Desktop Entry", "Name", name);
exec_string = g_strdup_printf ("epiphany --application-mode --profile=\"%s\" %s",
profile_dir,
address);
g_key_file_set_value (file, "Desktop Entry", "Exec", exec_string);
g_free (exec_string);
g_key_file_set_value (file, "Desktop Entry", "StartupNotify", "true");
g_key_file_set_value (file, "Desktop Entry", "Terminal", "false");
g_key_file_set_value (file, "Desktop Entry", "Type", "Application");
g_key_file_set_value (file, "Desktop Entry", "Categories", "Network;GNOME;GTK;");
if (icon) {
GOutputStream *stream;
char *path;
GFile *image;
path = g_build_filename (profile_dir, EPHY_WEB_APP_ICON_NAME, NULL);
image = g_file_new_for_path (path);
stream = (GOutputStream *)g_file_create (image, 0, NULL, NULL);
gdk_pixbuf_save_to_stream (icon, stream, "png", NULL, NULL, NULL);
g_key_file_set_value (file, "Desktop Entry", "Icon", path);
g_object_unref (stream);
g_object_unref (image);
g_free (path);
}
wm_class = g_strconcat (EPHY_WEB_APP_PROGRAM_NAME_PREFIX, id, NULL);
g_key_file_set_value (file, "Desktop Entry", "StartupWMClass", wm_class);
g_free (wm_class);
data = g_key_file_to_data (file, NULL, NULL);
desktop_file_path = g_build_filename (profile_dir, filename, NULL);
if (!g_file_set_contents (desktop_file_path, data, -1, NULL)) {
g_free (desktop_file_path);
desktop_file_path = NULL;
}
/* Create a symlink in XDG_DATA_DIR/applications for the Shell to
* pick up this application. */
apps_path = g_build_filename (g_get_user_data_dir (), "applications", NULL);
if (ephy_ensure_dir_exists (apps_path, &error)) {
link_path = g_build_filename (apps_path, filename, NULL);
link = g_file_new_for_path (link_path);
g_free (link_path);
g_file_make_symbolic_link (link, desktop_file_path, NULL, NULL);
g_object_unref (link);
} else {
g_warning ("Error creating application symlink: %s", error->message);
g_error_free (error);
}
g_free (apps_path);
g_free (filename);
g_free (data);
g_key_file_free (file);
return desktop_file_path;
}
/* Prepare a root filesystem, taking mainly the contents of /usr from yumroot */
static gboolean
create_rootfs_from_yumroot_content (GFile *targetroot,
GFile *yumroot,
JsonObject *treefile,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
gs_unref_object GFile *kernel_path = NULL;
gs_unref_object GFile *initramfs_path = NULL;
gs_unref_hashtable GHashTable *preserve_groups_set = NULL;
g_print ("Preparing kernel\n");
if (!do_kernel_prep (yumroot, treefile, cancellable, error))
goto out;
g_print ("Initializing rootfs\n");
if (!init_rootfs (targetroot, cancellable, error))
goto out;
g_print ("Migrating /etc/passwd to /usr/lib/\n");
if (!rpmostree_passwd_migrate_except_root (yumroot, RPM_OSTREE_PASSWD_MIGRATE_PASSWD, NULL,
cancellable, error))
goto out;
if (json_object_has_member (treefile, "etc-group-members"))
{
JsonArray *etc_group_members = json_object_get_array_member (treefile, "etc-group-members");
preserve_groups_set = _rpmostree_jsonutil_jsarray_strings_to_set (etc_group_members);
}
g_print ("Migrating /etc/group to /usr/lib/\n");
if (!rpmostree_passwd_migrate_except_root (yumroot, RPM_OSTREE_PASSWD_MIGRATE_GROUP,
preserve_groups_set,
cancellable, error))
goto out;
/* NSS configuration to look at the new files */
{
gs_unref_object GFile *yumroot_etc =
g_file_resolve_relative_path (yumroot, "etc");
if (!replace_nsswitch (yumroot_etc, cancellable, error))
goto out;
}
/* We take /usr from the yum content */
g_print ("Moving /usr to target\n");
{
gs_unref_object GFile *usr = g_file_get_child (yumroot, "usr");
if (!move_to_dir (usr, targetroot, cancellable, error))
goto out;
}
/* Except /usr/local -> ../var/usrlocal */
g_print ("Linking /usr/local -> ../var/usrlocal\n");
{
gs_unref_object GFile *target_usrlocal =
g_file_resolve_relative_path (targetroot, "usr/local");
if (!gs_shutil_rm_rf (target_usrlocal, cancellable, error))
goto out;
if (!g_file_make_symbolic_link (target_usrlocal, "../var/usrlocal",
cancellable, error))
goto out;
}
/* And now we take the contents of /etc and put them in /usr/etc */
g_print ("Moving /etc to /usr/etc\n");
{
gs_unref_object GFile *yumroot_etc =
g_file_get_child (yumroot, "etc");
gs_unref_object GFile *target_usretc =
g_file_resolve_relative_path (targetroot, "usr/etc");
if (!gs_file_rename (yumroot_etc, target_usretc,
cancellable, error))
goto out;
}
if (!migrate_rpm_and_yumdb (targetroot, yumroot, cancellable, error))
goto out;
{
gs_unref_object GFile *yumroot_var = g_file_get_child (yumroot, "var");
gs_unref_object GFile *rpmostree_tmpfiles_path =
g_file_resolve_relative_path (targetroot, "usr/lib/tmpfiles.d/rpm-ostree-autovar.conf");
gs_unref_object GFileOutputStream *tmpfiles_out =
g_file_create (rpmostree_tmpfiles_path,
G_FILE_CREATE_REPLACE_DESTINATION,
cancellable, error);
if (!tmpfiles_out)
goto out;
if (!convert_var_to_tmpfiles_d ((GOutputStream*)tmpfiles_out, yumroot, yumroot_var,
cancellable, error))
goto out;
if (!g_output_stream_close ((GOutputStream*)tmpfiles_out, cancellable, error))
goto out;
}
/* Move boot, but rename the kernel/initramfs to have a checksum */
g_print ("Moving /boot\n");
{
gs_unref_object GFile *yumroot_boot =
g_file_get_child (yumroot, "boot");
gs_unref_object GFile *target_boot =
g_file_get_child (targetroot, "boot");
gs_unref_object GFile *target_usrlib =
g_file_resolve_relative_path (targetroot, "usr/lib");
gs_unref_object GFile *target_usrlib_ostree_boot =
g_file_resolve_relative_path (target_usrlib, "ostree-boot");
RpmOstreePostprocessBootLocation boot_location =
RPMOSTREE_POSTPROCESS_BOOT_LOCATION_BOTH;
const char *boot_location_str = NULL;
if (!_rpmostree_jsonutil_object_get_optional_string_member (treefile,
"boot_location",
&boot_location_str, error))
goto out;
if (boot_location_str != NULL)
{
if (strcmp (boot_location_str, "legacy") == 0)
boot_location = RPMOSTREE_POSTPROCESS_BOOT_LOCATION_LEGACY;
else if (strcmp (boot_location_str, "both") == 0)
boot_location = RPMOSTREE_POSTPROCESS_BOOT_LOCATION_BOTH;
else if (strcmp (boot_location_str, "new") == 0)
boot_location = RPMOSTREE_POSTPROCESS_BOOT_LOCATION_NEW;
else
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Invalid boot location '%s'", boot_location_str);
goto out;
}
}
if (!gs_file_ensure_directory (target_usrlib, TRUE, cancellable, error))
goto out;
switch (boot_location)
{
case RPMOSTREE_POSTPROCESS_BOOT_LOCATION_LEGACY:
{
g_print ("Using boot location: legacy\n");
if (!gs_file_rename (yumroot_boot, target_boot, cancellable, error))
goto out;
}
break;
case RPMOSTREE_POSTPROCESS_BOOT_LOCATION_BOTH:
{
g_print ("Using boot location: both\n");
if (!gs_file_rename (yumroot_boot, target_boot, cancellable, error))
goto out;
/* Hardlink the existing content, only a little ugly as
* we'll end up sha256'ing it twice, but oh well. */
if (!gs_shutil_cp_al_or_fallback (target_boot, target_usrlib_ostree_boot, cancellable, error))
goto out;
}
break;
case RPMOSTREE_POSTPROCESS_BOOT_LOCATION_NEW:
{
g_print ("Using boot location: new\n");
if (!gs_file_rename (yumroot_boot, target_usrlib_ostree_boot, cancellable, error))
goto out;
}
break;
}
}
/* Also carry along toplevel compat links */
g_print ("Copying toplevel compat symlinks\n");
{
guint i;
const char *toplevel_links[] = { "lib", "lib64", "lib32",
"bin", "sbin" };
for (i = 0; i < G_N_ELEMENTS (toplevel_links); i++)
{
gs_unref_object GFile *srcpath =
g_file_get_child (yumroot, toplevel_links[i]);
if (g_file_query_file_type (srcpath, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL) == G_FILE_TYPE_SYMBOLIC_LINK)
{
if (!move_to_dir (srcpath, targetroot, cancellable, error))
goto out;
}
}
}
g_print ("Adding tmpfiles-ostree-integration.conf\n");
{
gs_unref_object GFile *src_pkglibdir = g_file_new_for_path (PKGLIBDIR);
gs_unref_object GFile *src_tmpfilesd =
g_file_get_child (src_pkglibdir, "tmpfiles-ostree-integration.conf");
gs_unref_object GFile *target_tmpfilesd =
g_file_resolve_relative_path (targetroot, "usr/lib/tmpfiles.d/tmpfiles-ostree-integration.conf");
gs_unref_object GFile *target_tmpfilesd_parent = g_file_get_parent (target_tmpfilesd);
if (!gs_file_ensure_directory (target_tmpfilesd_parent, TRUE, cancellable, error))
goto out;
if (!g_file_copy (src_tmpfilesd, target_tmpfilesd, 0,
cancellable, NULL, NULL, error))
goto out;
}
ret = TRUE;
out:
return ret;
}
