/*
* @file_list : files(or directories) to delete.
* @num : number of files(or directories) in file_list
* pre_hook =NULL
* post_hook = _delete_files_async
*/
void
fileops_delete (GFile* file_list[], guint num)
{
g_debug ("fileops_delete: Begin deleting files");
GCancellable* delete_cancellable = g_cancellable_new ();
TDData* data = g_malloc0 (sizeof (TDData));
data->dest_file = NULL;
data->cancellable = delete_cancellable;
for (guint i = 0; i < num; i++)
{
GFile* src = file_list[i];
#if 1
char* src_uri = g_file_get_uri (src);
g_debug ("fileops_delete: file %d: %s", i, src_uri);
g_free (src_uri);
#endif
traverse_directory (src, _dummy_func, _delete_files_async, data);
}
g_object_unref (data->cancellable);
g_free (data);
g_debug ("fileops_delete: End deleting files");
}
static void traverse_directory(const gchar *path)
{
GDir *dir = NULL;
GError *error = NULL;
const gchar *file = NULL;
gchar *newpath = NULL;
gchar *syspath = NULL;
dir = g_dir_open(path, 0, &error);
if (!dir) {
printf("ERROR: %s, line %d, %s\n", __func__, __LINE__, error->message);
g_error_free(error);
error = NULL;
return;
}
while (file = g_dir_read_name(dir)) {
newpath = g_strdup_printf("%s/%s", path, file);
if (g_file_test(newpath, G_FILE_TEST_IS_DIR)) {
traverse_directory(newpath);
} else if (g_file_test(newpath, G_FILE_TEST_IS_REGULAR)) {
syspath = g_utf8_substring(newpath, strlen(m_buildroot), strlen(newpath));
app_pkg_add_filelist(m_apkg, syspath);
g_free(syspath);
syspath = NULL;
}
g_free(newpath);
newpath = NULL;
}
g_dir_close(dir);
dir = NULL;
}
gboolean
fileops_move (GFile* file_list[], guint num, GFile* dest_dir, gboolean prompt)
{
g_prompt = prompt;
g_move_response = NULL;
gboolean retval = TRUE;
g_debug ("fileops_move: Begin moving files");
GCancellable* move_cancellable = g_cancellable_new ();
TDData* data = g_malloc0 (sizeof (TDData));
data->cancellable = move_cancellable;
for (guint i = 0; i < num; i++)
{
GFile* src = file_list[i];
#if 1
char* src_uri = g_file_get_uri (src);
char* dest_dir_uri = g_file_get_uri (dest_dir);
g_debug ("fileops_move: file %d: %s to dest: %s", i, src_uri, dest_dir_uri);
g_free (src_uri);
g_free (dest_dir_uri);
#endif
//make sure dest_dir is a directory before proceeding.
GFileType type = g_file_query_file_type (dest_dir, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL);
if (type != G_FILE_TYPE_DIRECTORY)
{
//TODO: symbolic links
g_debug ("dest type is not directory");
return FALSE;
}
char* src_basename= g_file_get_basename (src);
GFile* move_dest_file = g_file_get_child (dest_dir, src_basename);
g_free (src_basename);
data->dest_file = move_dest_file;
//retval &= _move_files_async (src, data);
//traverse_directory (dir, _move_files_async, _dummy_func, move_dest_gfile);
retval &= traverse_directory (src, _move_files_async, _dummy_func, data);
// here i must check out if dest has the same file or directory ,if true , fileops_delete,else, nothing do
if (retval)
fileops_delete (&src, 1);//ensure original file is removed.
g_object_unref (move_dest_file);
}
g_object_unref (data->cancellable);
g_free (data);
fileops_response_free (g_move_response);
g_debug ("fileops_move: End moving files");
return retval;
}
static void proto_handle_scan(conn_t* cn, const char* dir, hlink_t** hardlinks) {
char curdir[PATH_MAX];
struct scan_data data;
data.ts = 0;
data.cn = cn;
data.hardlinks = hardlinks;
getcwd(curdir, PATH_MAX);
traverse_directory(dir, &data, find_newest_ts_worker, find_newerthan_ts_perror);
chdir(curdir);
conn_printf(cn, "SCAN %ld\n", (long int)data.ts);
}
static void find_newerthan_ts(conn_t* s, time_t ts, const char* path) {
char curdir[PATH_MAX];
struct newerthan_data data;
data.ts = ts;
data.cn = s;
getcwd(curdir, PATH_MAX);
chdir(path);
traverse_directory(".", &data, find_newerthan_ts_worker, find_newerthan_ts_perror);
chdir(curdir);
}
int copy_directory(char *source, char *target) {
/*
* Copy the entire directory given with source to the target folder.
* Returns 0 on success and a non-zero integer on failure.
*/
// Remove trailing path seperators
if (source[strlen(source) - 1] == PATHSEP)
source[strlen(source) - 1] = 0;
if (target[strlen(target) - 1] == PATHSEP)
target[strlen(target) - 1] = 0;
return traverse_directory(source, copy_callback, target);
}
const char *uploads_list_to_json(uploads_list *l) {
json_object *json_result = json_object_new_object();
json_object *json_files_array = json_object_new_array();
traverse_directory(l->uploads_path, fill_json_files_array, json_files_array);
json_object_object_add(json_result, "files", json_files_array);
char *result = strdup(json_object_to_json_string(json_result));
json_object_put(json_result);
return result;
}
static void fill_json_files_array(char *path, struct dirent *ep, void *data) {
if (ep->d_type != DT_DIR) return;
json_object *json_files_array = (json_object *)data;
json_object *json_file_entry = json_object_new_object();
char *folder_path = join_path(path, ep->d_name);
traverse_directory(folder_path, fill_json_file_entry, json_file_entry);
json_object_array_add(json_files_array, json_file_entry);
free(folder_path);
}
static void traverse_directory(const char* dir, void* data,
handle_entry_t handle_entry, handle_perror_t handle_perror) {
char buffer[PATH_MAX];
struct stat st;
DIR *dirp;
char* p;
// We're chdir() into the directory of "dir", so we need "basename" of dir, to stats on
p = my_basename(dir);
if(lstat(p,&st) == 0) {
handle_entry(data, &st, dir);
if(S_ISDIR(st.st_mode)) {
char oldcwd[PATH_MAX];
struct dirent* dp;
getcwd(oldcwd, sizeof oldcwd);
if(chdir(p) != -1) {
dirp = opendir(".");
if(dirp) {
while ((dp = readdir(dirp)) != NULL) {
if(strcmp(dp->d_name,".") != 0 && strcmp(dp->d_name,"..") != 0) {
strcpy(buffer,dir);
strcat(buffer, "/");
strcat(buffer, dp->d_name);
traverse_directory(buffer, data, handle_entry, handle_perror);
}
}
closedir(dirp);
}
else {
if(handle_perror) handle_perror(data, "opendir()");
}
if(chdir(oldcwd)==-1) {
if(handle_perror) handle_perror(data, "chdir-1");
}
}
else {
if(handle_perror) handle_perror(data, "chdir-2");
}
}
}
else {
if(handle_perror) handle_perror(data, "stat()");
}
}
static int make_image(char *source_dir, struct btrfs_root *root, int out_fd)
{
int ret;
struct btrfs_trans_handle *trans;
struct stat root_st;
struct directory_name_entry dir_head;
struct directory_name_entry *dir_entry = NULL;
ret = lstat(source_dir, &root_st);
if (ret) {
fprintf(stderr, "unable to lstat the %s\n", source_dir);
goto fail;
}
INIT_LIST_HEAD(&dir_head.list);
trans = btrfs_start_transaction(root, 1);
ret = traverse_directory(trans, root, source_dir, &dir_head, out_fd);
if (ret) {
fprintf(stderr, "unable to traverse_directory\n");
goto fail;
}
btrfs_commit_transaction(trans, root);
printf("Making image is completed.\n");
return 0;
fail:
while (!list_empty(&dir_head.list)) {
dir_entry = list_entry(dir_head.list.next,
struct directory_name_entry, list);
list_del(&dir_entry->list);
free(dir_entry);
}
fprintf(stderr, "Making image is aborted.\n");
return -1;
}
static void menu_tree_changed(GMenuTree *tree, gpointer user_data)
{
GMenuTreeDirectory *root = NULL;
GtkWidget *menuitem = NULL;
popup = gtk_menu_new();
gmenu_tree_load_sync(tree, NULL);
root = gmenu_tree_get_root_directory(tree);
if (root) {
traverse_directory(root, NULL);
gmenu_tree_item_unref(root);
root = NULL;
}
gtk_menu_shell_append(GTK_MENU_SHELL(popup), gtk_separator_menu_item_new());
menuitem = menu_item_new_with_icon_name_text("logout", _("Logout"));
gtk_menu_shell_append(GTK_MENU_SHELL(popup), menuitem);
g_object_connect(G_OBJECT(menuitem),
"signal::activate", G_CALLBACK(logout), NULL,
NULL);
}
void
install_deb(const char *deb,
void (*converted)(double *percent, void *arg, const char *filename),
void (*problem)(char *prob, void *arg),
void *arg)
{
double percent = .0;
char *meta = NULL;
char *v1 = NULL, *v2 = NULL, *v3 = NULL;
gchar *package = NULL;
gchar *version = NULL;
gchar *arch = NULL;
char out[PATH_MAX] = { '\0' };
m_arg = arg;
m_problem = problem;
m_buildroot = tmpnam(NULL);
meta = tmpnam(NULL);
if (!m_buildroot || !meta) {
printf("ERROR: failed to create temporary directory\n");
m_problem(_("ERROR: failed to create temporary directory"), arg);
goto exit;
}
#ifdef DEBUG
printf("buildroot: %s\nmeta: %s\n", m_buildroot, meta);
#endif
deb_extract(deb, m_buildroot);
percent = 0.2;
converted(&percent, m_arg, out);
deb_control(deb, meta);
percent = 0.4;
converted(&percent, m_arg, out);
v1 = malloc(256);
v2 = malloc(256);
v3 = malloc(256);
if (!v1 || !v2 || !v3) {
printf("ERROR: failed to allocate memory\n");
m_problem(_("ERROR: failed to allocate memory"), arg);
goto exit;
}
if (deb_info(deb, meta, "Package", v1) == -1)
goto exit;
package = g_utf8_substring(v1, 9, strlen(v1) - 1);
if (deb_info(deb, meta, "Version", v2) == -1)
goto exit;
version = g_utf8_substring(v2, 9, strlen(v2) - 1);
if (deb_info(deb, meta, "Architecture", v3) == -1)
goto exit;
arch = g_utf8_substring(v3, 14, strlen(v3) - 1);
m_apkg = app_pkg_new();
if (!m_apkg) {
printf("ERROR: failed to instance AppPkg object\n");
goto exit;
}
app_pkg_set_name(m_apkg, package);
app_pkg_set_version(m_apkg, version);
app_pkg_set_release(m_apkg, "1");
if (strstr(v3, "amd64"))
app_pkg_set_arch(m_apkg, "x86_64");
else
app_pkg_set_arch(m_apkg, arch);
deb_info(deb, meta, "Homepage", v1);
app_pkg_set_url(m_apkg, v1);
deb_info(deb, meta, "Section", v1);
app_pkg_set_group(m_apkg, v1);
deb_info(deb, meta, "Description", v1);
char *p = strchr(v1, '\n');
*p = '\0';
app_pkg_set_summary(m_apkg, v1);
app_pkg_set_description(m_apkg, p+1);
app_pkg_set_packager(m_apkg, "isoft-packager");
percent = 0.6;
converted(&percent, m_arg, out);
for (int i = 0; m_dirtyfiles[i]; i++) {
memset(out, 0, sizeof(out));
snprintf(out, sizeof(out) - 1, "%s/%s", m_buildroot, m_dirtyfiles[i]);
unlink(out);
}
traverse_directory(m_buildroot);
memset(out, 0, sizeof(out));
snprintf(out, sizeof(out) - 1, "%s.rpm", deb);
app_pkg_write(m_apkg, m_buildroot, out);
percent = 0.8;
converted(&percent, m_arg, out);
percent = 1.0;
converted(&percent, m_arg, out);
exit:
if (package) {
g_free(package);
package = NULL;
}
if (version) {
g_free(version);
version = NULL;
}
if (arch) {
g_free(arch);
arch = NULL;
}
if (m_apkg) {
app_pkg_free(m_apkg);
m_apkg = NULL;
}
}
// src ---> data->dest
// we make use of 'goto' to minimize duplicated 'g_free*' statement
gboolean
traverse_directory (GFile* src, GFileProcessingFunc pre_hook, GFileProcessingFunc post_hook, gpointer data)
{
gboolean retval = TRUE;
GError* error = NULL;
GFileEnumerator* src_enumerator = NULL;
src_enumerator = g_file_enumerate_children (src,
"standard::name",
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
&error);
if (error != NULL)
{
//src_enumerator must be NULL, nothing to free.
switch (error->code)
{
case G_IO_ERROR_NOT_FOUND:
//TODO: showup a message box and quit.
if (g_file_query_file_type (src, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL) == G_FILE_TYPE_REGULAR)
{
//for smb files, previous enumeration can fail and return G_IO_ERROR_NOT_FOUND.
//pass to G_IO_ERROR_NOT_DIRECTORY
}
else
{
g_debug("G_IO_ERROR_NOT_FOUND");
break;
}
case G_IO_ERROR_NOT_DIRECTORY:
//TODO:we're using a file.
// g_debug("G_IO_ERROR_NOT_DIRECTORY");
if (pre_hook (src, data) == FALSE ||
post_hook (src, data) == FALSE)
{
g_error_free (error);
return FALSE;
}
else
{
g_error_free (error);
return TRUE;
}
default:
g_debug("src found and is directory");
break;
}
// g_warning ("traverse_directory 1: %s", error->message);
g_error_free (error);
return TRUE;
}
//here, we must be in a directory.
//check if it's a symbolic link
if (pre_hook (src, data) == FALSE) //src_enumerator must be freed
{
retval = FALSE;
goto post_processing;
}
#if 1
char* src_uri = NULL;
src_uri = g_file_get_uri (src);
g_debug ("traverse_directory: chdir to : %s", src_uri);
#endif
//begin g_file_enumerator_next_file ,we must check if the file type is symbolic_link then goto post_processing:
GFileType type = g_file_query_file_type (src, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL);
if (type == G_FILE_TYPE_SYMBOLIC_LINK)
{
//TODO: symbolic links
g_debug ("-------src type is symbolic_link-------");
goto post_processing;
}
GFileInfo* file_info = NULL;
while ((file_info = g_file_enumerator_next_file (src_enumerator, NULL, &error)) != NULL)
{
//this should not be freed with g_free(). it'll be freed when we call g_object_unref
//on file_info
#if 1
const char* src_child_name = g_file_info_get_name (file_info);
g_debug ("traverse_directory: %s", src_child_name);
#endif
TDData* tddata = NULL;
GFile* src_child_file = NULL;
GFile* dest_dir = NULL; //corresponding to src
GFile* dest_child_file = NULL; //corresponding to src_child_file.
tddata = new_td_data ();
src_child_file = g_file_get_child (src, src_child_name);
dest_dir = ((TDData*)data)->dest_file;
if (dest_dir != NULL)
{
dest_child_file = g_file_get_child (dest_dir, src_child_name);
#if 1
char* dest_child_file_uri = g_file_get_uri (dest_child_file);
g_debug ("dest_child_file_uri: %s", dest_child_file_uri);
g_free (dest_child_file_uri);
#endif
}
tddata->dest_file = dest_child_file;
tddata->cancellable = ((TDData*)data)->cancellable;
//TODO:
//get out the loop recursively when operation is cancelled.
retval = traverse_directory (src_child_file, pre_hook, post_hook, tddata);
g_object_unref (src_child_file);
free_td_data (tddata);
g_object_unref (file_info);
file_info = NULL;
if (retval == FALSE)
goto post_processing;
}
//checking errors
if (error != NULL)
{
g_warning ("traverse_directory 2: %s", error->message);
g_error_free (error);
}
#if 1
//change to parent directory.
g_debug ("traverse_directory: come out: %s", src_uri);
g_free (src_uri);
#endif
post_processing:
//close enumerator.
g_file_enumerator_close (src_enumerator, NULL, &error);
g_object_unref (src_enumerator);
//checking errors
if (error != NULL)
{
g_warning ("traverse_directory 3: %s", error->message);
g_error_free (error);
}
//after processing child node. processing this directory.
if (post_hook (src, data) == FALSE)
return FALSE;
return retval;
}
void
fileops_copy (GFile* file_list[], guint num, GFile* dest_dir)
{
g_copy_response = NULL;
g_debug ("fileops_copy: Begin copying files");
GCancellable* copy_cancellable = g_cancellable_new ();
TDData* data = g_malloc0 (sizeof (TDData));
data->cancellable = copy_cancellable;
guint i;
for (i = 0; i < num; i++)
{
GFile* src = file_list[i];
#if 1
char* src_uri= g_file_get_uri (src);
char* dest_dir_uri = g_file_get_uri (dest_dir);
g_debug ("fileops_copy: file %d: %s to dest_dir: %s", i, src_uri, dest_dir_uri);
g_free (src_uri);
#endif
//make sure dest_dir is a directory before proceeding.
GFileType type = g_file_query_file_type (dest_dir, G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL);
if (type != G_FILE_TYPE_DIRECTORY)
{
//TODO: how to handle symbolic links
return;
}
// here ,we should first check the src directory is the same as the dest directory
// if is same , we should change the copy_dest_file by changing src_basename
char* src_basename = g_file_get_basename (src);
char* name = g_strdup(src_basename);
GFile* child = g_file_get_child(dest_dir, name);
const char* name_add_before = _("Untitled");
GFile* parent = g_file_get_parent(src);
char* parent_uri = g_file_get_uri(parent);
g_object_unref(parent);
if(0 == g_strcmp0(parent_uri,dest_dir_uri))
{
for (int i=0; g_file_query_exists(child, NULL) && (i<500); i++) {
g_object_unref(child);
g_free(name);
name = g_strdup_printf("%s(%d)%s",name_add_before, i,src_basename);
child = g_file_get_child(dest_dir, name);
}
}
g_free (dest_dir_uri);
g_free (src_basename);
g_free(name);
g_free(parent_uri);
data->dest_file = child;
traverse_directory (src, _copy_files_async, _dummy_func, data);
g_object_unref (data->dest_file);
}
g_object_unref (data->cancellable);
g_free (data);
fileops_response_free (g_copy_response);
g_debug ("fileops_copy: End copying files");
}
/*
* This function inherit from gnome-menus/util/test-menu-spec.c
*/
static void traverse_directory(GMenuTreeDirectory *dir, GtkWidget *parent)
{
GMenuTreeIter *iter = NULL;
GtkWidget *dir_submenu = parent ? gtk_menu_new() : NULL;
GtkWidget *entry_submenu = gtk_menu_new();
GIcon *icon = NULL;
const char *text = NULL;
GtkWidget *menuitem = NULL;
iter = gmenu_tree_directory_iter(dir);
while (TRUE) {
gpointer item = NULL;
switch (gmenu_tree_iter_next(iter)) {
case GMENU_TREE_ITEM_INVALID:
goto done;
case GMENU_TREE_ITEM_ENTRY:
item = gmenu_tree_iter_get_entry(iter);
GDesktopAppInfo *appinfo = gmenu_tree_entry_get_app_info((GMenuTreeEntry *)item);
icon = g_app_info_get_icon((GAppInfo *)appinfo);
text = g_app_info_get_display_name((GAppInfo *)appinfo);
menuitem = menu_item_new_with_icon_text(icon, text);
gtk_menu_shell_append(GTK_MENU_SHELL(entry_submenu), menuitem);
g_object_connect(G_OBJECT(menuitem),
"signal::activate", G_CALLBACK(menu_item_activate), appinfo,
NULL);
break;
case GMENU_TREE_ITEM_DIRECTORY:
item = gmenu_tree_iter_get_directory(iter);
icon = gmenu_tree_directory_get_icon((GMenuTreeDirectory *)item);
text = gmenu_tree_directory_get_name((GMenuTreeDirectory *)item);
menuitem = menu_item_new_with_icon_text(icon, text);
gtk_menu_shell_append(dir_submenu ?
GTK_MENU_SHELL(dir_submenu) :
GTK_MENU_SHELL(popup),
menuitem);
traverse_directory(item, menuitem);
break;
}
if (item) {
gmenu_tree_item_unref(item);
item = NULL;
}
continue;
done:
break;
}
if (parent) {
if (dir_submenu)
gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), dir_submenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), entry_submenu);
}
if (iter) {
gmenu_tree_iter_unref(iter);
iter = NULL;
}
}
