?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r1354: Code tidying in various places (Bernard Jungen).
[rox-filer.git] / ROX-Filer / src / action.c
blob6d7a1ff636540c5ca3c4f27f44e6e5ecf5b8c760
1 /*
2 * $Id$
3 *
4 * ROX-Filer, filer for the ROX desktop project
5 * Copyright (C) 2002, the ROX-Filer team.
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
19 * Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 /* action.c - code for handling the filer action windows.
23 * These routines generally fork() and talk to us via pipes.
24 */
25
26 #include "config.h"
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <ctype.h>
31 #include <sys/param.h>
32 #include <errno.h>
33 #include <signal.h>
34 #include <sys/time.h>
35 #include <utime.h>
36
37 #include "global.h"
38
39 #include "action.h"
40 #include "abox.h"
41 #include "string.h"
42 #include "support.h"
43 #include "gui_support.h"
44 #include "filer.h"
45 #include "display.h"
46 #include "main.h"
47 #include "options.h"
48 #include "modechange.h"
49 #include "find.h"
50 #include "dir.h"
51 #include "icon.h"
52 #include "mount.h"
53
54 /* Parent->Child messages are one character each:
55 *
56 * Y/N Yes/No button clicked
57 * F Force deletion of non-writeable items
58 * Q Quiet toggled
59 * E Entry text changed
60 * W neWer toggled
61 */
62
63 typedef struct _GUIside GUIside;
64 typedef void ActionChild(gpointer data);
65 typedef void ForDirCB(const char *path, const char *dest_path);
66
67 struct _GUIside
68 {
69 ABox *abox; /* The action window widget */
70
71 int from_child; /* File descriptor */
72 FILE *to_child;
73 int input_tag; /* gdk_input_add() */
74 pid_t child; /* Process ID */
75 int errors; /* Number of errors so far */
76 gboolean show_info; /* For Disk Usage */
77
78 guchar **default_string; /* Changed when the entry changes */
79 void (*entry_string_func)(GtkWidget *widget,
80 const guchar *string);
81 };
82
83 /* These don't need to be in a structure because we fork() before
84 * using them again.
85 */
86 static gboolean mount_open_dir = FALSE;
87 static int from_parent = 0;
88 static FILE *to_parent = NULL;
89 static gboolean quiet = FALSE;
90 static GString *message = NULL;
91 static const char *action_dest = NULL;
92 static const char *action_leaf = NULL;
93 static void (*action_do_func)(const char *source, const char *dest);
94 static double size_tally; /* For Disk Usage */
95 static unsigned long dir_counter; /* For Disk Usage */
96 static unsigned long file_counter; /* For Disk Usage */
97
98 static struct mode_change *mode_change = NULL; /* For Permissions */
99 static FindCondition *find_condition = NULL; /* For Find */
100
101 /* Only used by child */
102 static gboolean o_force = FALSE;
103 static gboolean o_brief = FALSE;
104 static gboolean o_recurse = FALSE;
105 static gboolean o_newer = FALSE;
106
107 static Option o_action_copy, o_action_move, o_action_link;
108 static Option o_action_delete, o_action_mount;
109 static Option o_action_force, o_action_brief, o_action_recurse;
110 static Option o_action_newer;
111
112 /* Whenever the text in these boxes is changed we store a copy of the new
113 * string to be used as the default next time.
114 */
115 static guchar *last_chmod_string = NULL;
116 static guchar *last_find_string = NULL;
117
118 /* Set to one of the above before forking. This may change over a call to
119 * reply(). It is reset to NULL once the text is parsed.
120 */
121 static guchar *new_entry_string = NULL;
122
123 /* Static prototypes */
124 static gboolean send();
125 static gboolean send_error();
126 static gboolean send_dir(const char *dir);
127 static gboolean read_exact(int source, char *buffer, ssize_t len);
128 static void do_mount(guchar *path, gboolean mount);
129 static gboolean reply(int fd, gboolean ignore_quiet);
130 static gboolean remove_pinned_ok(GList *paths);
131
132 /* SUPPORT */
133
134
135 /* This is called whenever the user edits the entry box (if any) - send the
136 * new string.
137 */
138 static void entry_changed(GtkEditable *entry, GUIside *gui_side)
139 {
140 guchar *text;
141
142 g_return_if_fail(gui_side->default_string != NULL);
143
144 text = gtk_editable_get_chars(entry, 0, -1);
145
146 if (gui_side->entry_string_func)
147 gui_side->entry_string_func(GTK_WIDGET(entry), text);
148
149 g_free(*(gui_side->default_string));
150 *(gui_side->default_string) = text; /* Gets text's ref */
151
152 if (!gui_side->to_child)
153 return;
154
155 fputc('E', gui_side->to_child);
156 fputs(text, gui_side->to_child);
157 fputc('\n', gui_side->to_child);
158 fflush(gui_side->to_child);
159 }
160
161 void show_condition_help(gpointer data)
162 {
163 static GtkWidget *help = NULL;
164
165 if (!help)
166 {
167 GtkWidget *text, *vbox, *button, *hbox, *frame;
168
169 help = gtk_window_new(GTK_WINDOW_TOPLEVEL);
170 gtk_window_set_type_hint(GTK_WINDOW(help),
171 GDK_WINDOW_TYPE_HINT_DIALOG);
172 gtk_container_set_border_width(GTK_CONTAINER(help), 10);
173 gtk_window_set_title(GTK_WINDOW(help),
174 _("Find expression reference"));
175
176 vbox = gtk_vbox_new(FALSE, 0);
177 gtk_container_add(GTK_CONTAINER(help), vbox);
178
179 frame = gtk_frame_new(_("Quick Start"));
180 text = gtk_label_new(
181 _("Just put the name of the file you're looking for in single quotes:\n"
182 "'index.html' (to find a file called 'index.html')"));
183 gtk_misc_set_padding(GTK_MISC(text), 4, 4);
184 gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_LEFT);
185 gtk_container_add(GTK_CONTAINER(frame), text);
186 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 4);
187
188 frame = gtk_frame_new(_("Examples"));
189 text = gtk_label_new(
190 _("'*.htm', '*.html' (finds HTML files)\n"
191 "IsDir 'lib' (finds directories called 'lib')\n"
192 "IsReg 'core' (finds a regular file called 'core')\n"
193 "! (IsDir, IsReg) (is neither a directory nor a regular file)\n"
194 "mtime after 1 day ago and size > 1Mb (big, and recently modified)\n"
195 "'CVS' prune, isreg (a regular file not in CVS)\n"
196 "IsReg system(grep -q fred \"%\") (contains the word 'fred')"));
197 gtk_widget_set_name(text, "fixed-style");
198 gtk_misc_set_padding(GTK_MISC(text), 4, 4);
199 gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_LEFT);
200 gtk_container_add(GTK_CONTAINER(frame), text);
201 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 4);
202
203 frame = gtk_frame_new(_("Simple Tests"));
204 text = gtk_label_new(
205 _("IsReg, IsLink, IsDir, IsChar, IsBlock, IsDev, IsPipe, IsSocket (types)\n"
206 "IsSUID, IsSGID, IsSticky, IsReadable, IsWriteable, IsExecutable (permissions)"
207 "\n"
208 "IsEmpty, IsMine\n"
209 "\n"
210 "A pattern in single quotes is a shell-style wildcard pattern to match. If it\n"
211 "contains a slash then the match is against the full path; otherwise it is \n"
212 "against the leafname only."));
213 gtk_misc_set_padding(GTK_MISC(text), 4, 4);
214 gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_LEFT);
215 gtk_container_add(GTK_CONTAINER(frame), text);
216 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 4);
217
218 frame = gtk_frame_new(_("Comparisons"));
219 text = gtk_label_new(
220 _("<, <=, =, !=, >, >=, After, Before (compare two values)\n"
221 "5 bytes, 1Kb, 2Mb, 3Gb (file sizes)\n"
222 "2 secs|mins|hours|days|weeks|years ago|hence (times)\n"
223 "atime, ctime, mtime, now, size, inode, nlinks, uid, gid, blocks (values)"));
224 gtk_misc_set_padding(GTK_MISC(text), 4, 4);
225 gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_LEFT);
226 gtk_container_add(GTK_CONTAINER(frame), text);
227 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 4);
228
229 frame = gtk_frame_new(_("Specials"));
230 text = gtk_label_new(
231 _("system(command) (true if 'command' returns with a zero exit status; a % \n"
232 "in 'command' is replaced with the path of the current file)\n"
233 "prune (false, and prevents searching the contents of a directory).")
234 );
235 gtk_misc_set_padding(GTK_MISC(text), 4, 4);
236 gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_LEFT);
237 gtk_container_add(GTK_CONTAINER(frame), text);
238 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 4);
239
240 hbox = gtk_hbox_new(FALSE, 20);
241 gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
242
243 text = gtk_label_new(
244 _("See the ROX-Filer manual for full details."));
245 gtk_box_pack_start(GTK_BOX(hbox), text, TRUE, TRUE, 0);
246 button = gtk_button_new_with_label(_("Close"));
247 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, TRUE, 0);
248 g_signal_connect_swapped(button, "clicked",
249 G_CALLBACK(gtk_widget_hide), help);
250
251 g_signal_connect_swapped(help, "delete_event",
252 G_CALLBACK(gtk_widget_hide), help);
253 }
254
255 if (GTK_WIDGET_VISIBLE(help))
256 gtk_widget_hide(help);
257 gtk_widget_show_all(help);
258 }
259
260 static void show_chmod_help(gpointer data)
261 {
262 static GtkWidget *help = NULL;
263
264 if (!help)
265 {
266 GtkWidget *text, *vbox, *button, *hbox, *sep;
267
268 help = gtk_window_new(GTK_WINDOW_TOPLEVEL);
269 gtk_window_set_type_hint(GTK_WINDOW(help),
270 GDK_WINDOW_TYPE_HINT_DIALOG);
271 gtk_container_set_border_width(GTK_CONTAINER(help), 10);
272 gtk_window_set_title(GTK_WINDOW(help),
273 _("Permissions command reference"));
274
275 vbox = gtk_vbox_new(FALSE, 0);
276 gtk_container_add(GTK_CONTAINER(help), vbox);
277
278 text = gtk_label_new(
279 _("Normally, you can just select a command from the menu (click \n"
280 "on the arrow beside the command box). Sometimes, you need more...\n"
281 "\n"
282 "The format of a command is:\n"
283 "CHANGE, CHANGE, ...\n"
284 "Each CHANGE is:\n"
285 "WHO HOW PERMISSIONS\n"
286 "WHO is some combination of u, g and o which determines whether to\n"
287 "change the permissions for the User (owner), Group or Others.\n"
288 "HOW is +, - or = to add, remove or set exactly the permissions.\n"
289 "PERMISSIONS is some combination of the letters 'rwxXstugo'\n\n"
290
291 "Bracketed text and spaces are ignored.\n\n"
292
293 "Examples:\n"
294 "u+rw (the file owner gains read and write permission)\n"
295 "g=u (the group permissions are set to be the same as the user's)\n"
296 "o=u-w (others get the same permissions as the owner, but without "
297 "write permission)\n"
298 "a+x (everyone gets execute/access permission - same as 'ugo+x')\n"
299 "a+X (directories become accessable by everyone; files which were\n"
300 "executable by anyone become executable by everyone)\n"
301 "u+rw, go+r (two commands at once!)\n"
302 "u+s (set the SetUID bit - often has no effect on script files)\n"
303 "755 (set the permissions directly)\n"
304
305 "\nSee the chmod(1) man page for full details."));
306 gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_LEFT);
307 gtk_box_pack_start(GTK_BOX(vbox), text, TRUE, TRUE, 0);
308
309 hbox = gtk_hbox_new(FALSE, 20);
310 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
311
312 sep = gtk_hseparator_new();
313 gtk_box_pack_start(GTK_BOX(hbox), sep, TRUE, TRUE, 0);
314 button = gtk_button_new_with_label(_("Close"));
315 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, TRUE, 0);
316 g_signal_connect_swapped(button, "clicked",
317 G_CALLBACK(gtk_widget_hide), help);
318
319 g_signal_connect_swapped(help, "delete_event",
320 G_CALLBACK(gtk_widget_hide), help);
321 }
322
323 if (GTK_WIDGET_VISIBLE(help))
324 gtk_widget_hide(help);
325 gtk_widget_show_all(help);
326 }
327
328 static void process_message(GUIside *gui_side, const gchar *buffer)
329 {
330 ABox *abox = gui_side->abox;
331
332 if (*buffer == '?')
333 abox_ask(abox, buffer + 1);
334 else if (*buffer == 's')
335 dir_check_this(buffer + 1); /* Update this item */
336 else if (*buffer == '=')
337 abox_add_filename(abox, buffer + 1);
338 else if (*buffer == '#')
339 abox_clear_results(abox);
340 else if (*buffer == 'm' || *buffer == 'M')
341 {
342 /* Mount / major changes to this path */
343 if (*buffer == 'M')
344 mount_update(TRUE);
345 filer_check_mounted(buffer + 1);
346 }
347 else if (*buffer == '/')
348 abox_set_current_object(abox, buffer + 1);
349 else if (*buffer == 'o')
350 filer_opendir(buffer + 1, NULL);
351 else if (*buffer == '!')
352 {
353 gui_side->errors++;
354 abox_log(abox, buffer + 1, "error");
355 }
356 else
357 abox_log(abox, buffer + 1, NULL);
358 }
359
360 /* Called when the child sends us a message */
361 static void message_from_child(gpointer data,
362 gint source,
363 GdkInputCondition condition)
364 {
365 char buf[5];
366 GUIside *gui_side = (GUIside *) data;
367 ABox *abox = gui_side->abox;
368 GtkTextBuffer *text_buffer;
369
370 text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(abox->log));
371
372 if (read_exact(source, buf, 4))
373 {
374 ssize_t message_len;
375 char *buffer;
376
377 buf[4] = '\0';
378 message_len = strtol(buf, NULL, 16);
379 buffer = g_malloc(message_len + 1);
380 if (message_len > 0 && read_exact(source, buffer, message_len))
381 {
382 buffer[message_len] = '\0';
383 process_message(gui_side, buffer);
384 g_free(buffer);
385 return;
386 }
387 g_printerr("Child died in the middle of a message.\n");
388 }
389
390 /* The child is dead */
391 gui_side->child = 0;
392
393 fclose(gui_side->to_child);
394 gui_side->to_child = NULL;
395 close(gui_side->from_child);
396 g_source_remove(gui_side->input_tag);
397 abox_cancel_ask(gui_side->abox);
398
399 if (gui_side->errors)
400 {
401 guchar *report;
402
403 if (gui_side->errors == 1)
404 report = g_strdup(_("There was one error.\n"));
405 else
406 report = g_strdup_printf(_("There were %d errors.\n"),
407 gui_side->errors);
408
409 gtk_text_buffer_insert_at_cursor(text_buffer, report, -1);
410
411 g_free(report);
412 }
413 else if (gui_side->show_info == FALSE)
414 gtk_widget_destroy(GTK_WIDGET(gui_side->abox));
415 }
416
417 /* Scans src_dir, calling cb(item, dest_path) for each item */
418 static void for_dir_contents(ForDirCB *cb,
419 const char *src_dir,
420 const char *dest_path)
421 {
422 DIR *d;
423 struct dirent *ent;
424 GList *list = NULL, *next;
425
426 d = mc_opendir(src_dir);
427 if (!d)
428 {
429 /* Message displayed is "ERROR reading 'path': message" */
430 g_string_sprintf(message, "!%s '%s': %s\n",
431 _("ERROR reading"),
432 src_dir, g_strerror(errno));
433 send();
434 return;
435 }
436
437 send_dir(src_dir);
438
439 while ((ent = mc_readdir(d)))
440 {
441 if (ent->d_name[0] == '.' && (ent->d_name[1] == '\0'
442 || (ent->d_name[1] == '.' && ent->d_name[2] == '\0')))
443 continue;
444 list = g_list_append(list, g_strdup(make_path(src_dir,
445 ent->d_name)->str));
446 }
447 mc_closedir(d);
448
449 if (!list)
450 return;
451
452 next = list;
453
454 while (next)
455 {
456 cb((char *) next->data, dest_path);
457
458 g_free(next->data);
459 next = next->next;
460 }
461 g_list_free(list);
462 }
463
464 /* Read this many bytes into the buffer. TRUE on success. */
465 static gboolean read_exact(int source, char *buffer, ssize_t len)
466 {
467 while (len > 0)
468 {
469 ssize_t got;
470 got = read(source, buffer, len);
471 if (got < 1)
472 return FALSE;
473 len -= got;
474 buffer += got;
475 }
476 return TRUE;
477 }
478
479 /* Send 'message' to our parent process. TRUE on success. */
480 static gboolean send(void)
481 {
482 char len_buffer[5];
483 ssize_t len;
484
485 g_return_val_if_fail(message->len < 0xffff, FALSE);
486
487 sprintf(len_buffer, "%04x", message->len);
488 fwrite(len_buffer, 1, 4, to_parent);
489 len = fwrite(message->str, 1, message->len, to_parent);
490 fflush(to_parent);
491 return len == message->len;
492 }
493
494 /* Set the directory indicator at the top of the window */
495 static gboolean send_dir(const char *dir)
496 {
497 g_string_sprintf(message, "/%s", dir);
498 return send();
499 }
500
501 static gboolean send_error(void)
502 {
503 g_string_sprintf(message, "!%s: %s\n", _("ERROR"), g_strerror(errno));
504 return send();
505 }
506
507 /* Send 'Quiet' if possible, 'Yes' otherwise */
508 #if 0
509 static void find_return_pressed(GtkWidget *button, GUIside *gui_side)
510 {
511 if (GTK_WIDGET_SENSITIVE(gui_side->quiet))
512 gtk_button_clicked(GTK_BUTTON(gui_side->quiet));
513 else if (GTK_WIDGET_SENSITIVE(gui_side->yes))
514 gtk_button_clicked(GTK_BUTTON(gui_side->yes));
515 else
516 gdk_beep();
517 }
518 #endif
519
520 static void response(GtkDialog *dialog, gint response, GUIside *gui_side)
521 {
522 gchar code;
523
524 if (!gui_side->to_child)
525 return;
526
527 if (response == GTK_RESPONSE_YES)
528 code = 'Y';
529 else if (response == GTK_RESPONSE_NO)
530 code = 'N';
531 else
532 return;
533
534 fputc(code, gui_side->to_child);
535 fflush(gui_side->to_child);
536 }
537
538 static void flag_toggled(ABox *abox, gint flag, GUIside *gui_side)
539 {
540 if (!gui_side->to_child)
541 return;
542
543 fputc(flag, gui_side->to_child);
544 fflush(gui_side->to_child);
545 }
546
547 static void read_new_entry_text(void)
548 {
549 int len;
550 char c;
551 GString *new;
552
553 new = g_string_new(NULL);
554
555 for (;;)
556 {
557 len = read(from_parent, &c, 1);
558 if (len != 1)
559 {
560 fprintf(stderr, "read() error: %s\n",
561 g_strerror(errno));
562 _exit(1); /* Parent died? */
563 }
564
565 if (c == '\n')
566 break;
567 g_string_append_c(new, c);
568 }
569
570 g_free(new_entry_string);
571 new_entry_string = new->str;
572 g_string_free(new, FALSE);
573 }
574
575 static void process_flag(char flag)
576 {
577 switch (flag)
578 {
579 case 'Q':
580 quiet = !quiet;
581 break;
582 case 'F':
583 o_force = !o_force;
584 break;
585 case 'R':
586 o_recurse = !o_recurse;
587 break;
588 case 'B':
589 o_brief = !o_brief;
590 break;
591 case 'W':
592 o_newer = !o_newer;
593 break;
594 case 'E':
595 read_new_entry_text();
596 break;
597 default:
598 g_string_sprintf(message,
599 "!ERROR: Bad message '%c'\n", flag);
600 send();
601 break;
602 }
603 }
604
605 /* If the parent has sent any flag toggles, read them */
606 static void check_flags(void)
607 {
608 fd_set set;
609 int got;
610 char retval;
611 struct timeval tv;
612
613 FD_ZERO(&set);
614
615 while (1)
616 {
617 FD_SET(from_parent, &set);
618 tv.tv_sec = 0;
619 tv.tv_usec = 0;
620 got = select(from_parent + 1, &set, NULL, NULL, &tv);
621
622 if (got == -1)
623 g_error("select() failed: %s\n", g_strerror(errno));
624 else if (!got)
625 return;
626
627 got = read(from_parent, &retval, 1);
628 if (got != 1)
629 g_error("read() error: %s\n", g_strerror(errno));
630
631 process_flag(retval);
632 }
633 }
634
635 /* Read until the user sends a reply. If ignore_quiet is TRUE then
636 * the user MUST click Yes or No, else treat quiet on as Yes.
637 * If the user needs prompting then does send().
638 */
639 static gboolean reply(int fd, gboolean ignore_quiet)
640 {
641 ssize_t len;
642 char retval;
643
644 if (quiet && !ignore_quiet)
645 return TRUE;
646
647 send();
648
649 while (1)
650 {
651 len = read(fd, &retval, 1);
652 if (len != 1)
653 {
654 fprintf(stderr, "read() error: %s\n",
655 g_strerror(errno));
656 _exit(1); /* Parent died? */
657 }
658
659 switch (retval)
660 {
661 case 'Y':
662 g_string_sprintf(message, "' %s\n", _("Yes"));
663 send();
664 return TRUE;
665 case 'N':
666 g_string_sprintf(message, "' %s\n", _("No"));
667 send();
668 return FALSE;
669 default:
670 process_flag(retval);
671 break;
672 }
673 }
674 }
675
676 static void destroy_action_window(GtkWidget *widget, gpointer data)
677 {
678 GUIside *gui_side = (GUIside *) data;
679
680 if (gui_side->child)
681 {
682 kill(gui_side->child, SIGTERM);
683 fclose(gui_side->to_child);
684 close(gui_side->from_child);
685 g_source_remove(gui_side->input_tag);
686 }
687
688 g_free(gui_side);
689
690 if (--number_of_windows < 1)
691 gtk_main_quit();
692 }
693
694 /* Create two pipes, fork() a child and return a pointer to a GUIside struct
695 * (NULL on failure). The child calls func().
696 */
697 static GUIside *start_action(GtkWidget *abox, ActionChild *func, gpointer data,
698 int force, int brief, int recurse, int newer)
699 {
700 gboolean autoq;
701 int filedes[4]; /* 0 and 2 are for reading */
702 GUIside *gui_side;
703 int child;
704 struct sigaction act;
705
706 if (pipe(filedes))
707 {
708 report_error("pipe: %s", g_strerror(errno));
709 gtk_widget_destroy(abox);
710 return NULL;
711 }
712
713 if (pipe(filedes + 2))
714 {
715 close(filedes[0]);
716 close(filedes[1]);
717 report_error("pipe: %s", g_strerror(errno));
718 gtk_widget_destroy(abox);
719 return NULL;
720 }
721
722 autoq = gtk_toggle_button_get_active(
723 GTK_TOGGLE_BUTTON(ABOX(abox)->quiet));
724
725 o_force = force;
726 o_brief = brief;
727 o_recurse = recurse;
728 o_newer = newer;
729
730 child = fork();
731 switch (child)
732 {
733 case -1:
734 report_error("fork: %s", g_strerror(errno));
735 gtk_widget_destroy(abox);
736 return NULL;
737 case 0:
738 /* We are the child */
739
740 quiet = autoq;
741
742 /* Reset the SIGCHLD handler */
743 act.sa_handler = SIG_DFL;
744 sigemptyset(&act.sa_mask);
745 act.sa_flags = 0;
746 sigaction(SIGCHLD, &act, NULL);
747
748 message = g_string_new(NULL);
749 close(filedes[0]);
750 close(filedes[3]);
751 to_parent = fdopen(filedes[1], "wb");
752 from_parent = filedes[2];
753 func(data);
754 send_dir("");
755 _exit(0);
756 }
757
758 /* We are the parent */
759 close(filedes[1]);
760 close(filedes[2]);
761 gui_side = g_malloc(sizeof(GUIside));
762 gui_side->from_child = filedes[0];
763 gui_side->to_child = fdopen(filedes[3], "wb");
764 gui_side->child = child;
765 gui_side->errors = 0;
766 gui_side->show_info = FALSE;
767 gui_side->default_string = NULL;
768 gui_side->entry_string_func = NULL;
769
770 gui_side->abox = ABOX(abox);
771 g_signal_connect(abox, "destroy",
772 G_CALLBACK(destroy_action_window), gui_side);
773
774 g_signal_connect(abox, "response", G_CALLBACK(response), gui_side);
775 g_signal_connect(abox, "flag_toggled",
776 G_CALLBACK(flag_toggled), gui_side);
777
778 gui_side->input_tag = gtk_input_add_full(gui_side->from_child,
779 GDK_INPUT_READ,
780 message_from_child,
781 NULL, gui_side, NULL);
782
783 return gui_side;
784 }
785
786 /* ACTIONS ON ONE ITEM */
787
788 /* These may call themselves recursively, or ask questions, etc */
789
790 /* Updates the global size_tally, file_counter and dir_counter */
791 static void do_usage(const char *src_path, const char *unused)
792 {
793 struct stat info;
794
795 check_flags();
796
797 if (mc_lstat(src_path, &info))
798 {
799 g_string_sprintf(message, "'%s:\n", src_path);
800 send();
801 send_error();
802 }
803 else if (S_ISREG(info.st_mode) || S_ISLNK(info.st_mode))
804 {
805 file_counter++;
806 size_tally += info.st_size;
807 }
808 else if (S_ISDIR(info.st_mode))
809 {
810 dir_counter++;
811 g_string_sprintf(message, _("?Count contents of %s?"),
812 src_path);
813 if (reply(from_parent, FALSE))
814 {
815 char *safe_path;
816 safe_path = g_strdup(src_path);
817 for_dir_contents(do_usage, safe_path, safe_path);
818 g_free(safe_path);
819 }
820 }
821 else
822 file_counter++;
823 }
824
825 /* dest_path is the dir containing src_path */
826 static void do_delete(const char *src_path, const char *unused)
827 {
828 struct stat info;
829 gboolean write_prot;
830 char *safe_path;
831
832 check_flags();
833
834 if (mc_lstat(src_path, &info))
835 {
836 send_error();
837 return;
838 }
839
840 write_prot = S_ISLNK(info.st_mode) ? FALSE
841 : access(src_path, W_OK) != 0;
842 if (write_prot || !quiet)
843 {
844 g_string_sprintf(message, _("?Delete %s'%s'?"),
845 write_prot ? _("WRITE-PROTECTED ") : "",
846 src_path);
847 if (!reply(from_parent, write_prot && !o_force))
848 return;
849 }
850 else if (!o_brief)
851 {
852 g_string_sprintf(message, _("'Deleting '%s'\n"), src_path);
853 send();
854 }
855
856 safe_path = g_strdup(src_path);
857
858 if (S_ISDIR(info.st_mode))
859 {
860 for_dir_contents(do_delete, safe_path, safe_path);
861 if (rmdir(safe_path))
862 {
863 g_free(safe_path);
864 send_error();
865 return;
866 }
867 g_string_sprintf(message, _("'Directory '%s' deleted\n"),
868 safe_path);
869 send();
870 g_string_sprintf(message, "m%s", safe_path);
871 send();
872 }
873 else if (unlink(src_path))
874 send_error();
875 else
876 {
877 g_string_sprintf(message, "s%s", safe_path);
878 send();
879 }
880
881 g_free(safe_path);
882 }
883
884 /* path is the item to check. If is is a directory then we may recurse
885 * (unless prune is used).
886 */
887 static void do_find(const char *path, const char *unused)
888 {
889 FindInfo info;
890
891 check_flags();
892
893 if (!quiet)
894 {
895 g_string_sprintf(message, _("?Check '%s'?"), path);
896 if (!reply(from_parent, FALSE))
897 return;
898 }
899
900 for (;;)
901 {
902 if (new_entry_string)
903 {
904 if (find_condition)
905 find_condition_free(find_condition);
906 find_condition = find_compile(new_entry_string);
907 g_free(new_entry_string);
908 new_entry_string = NULL;
909 }
910
911 if (find_condition)
912 break;
913
914 g_string_assign(message, _("!Invalid find condition - "
915 "change it and try again\n"));
916 send();
917 g_string_sprintf(message, _("?Check '%s'?"), path);
918 if (!reply(from_parent, TRUE))
919 return;
920 }
921
922 if (mc_lstat(path, &info.stats))
923 {
924 send_error();
925 g_string_sprintf(message, _("'(while checking '%s')\n"), path);
926 send();
927 return;
928 }
929
930 info.fullpath = path;
931 time(&info.now); /* XXX: Not for each check! */
932
933 info.leaf = g_basename(path);
934 info.prune = FALSE;
935 if (find_test_condition(find_condition, &info))
936 {
937 g_string_sprintf(message, "=%s", path);
938 send();
939 }
940
941 if (S_ISDIR(info.stats.st_mode) && !info.prune)
942 {
943 char *safe_path;
944 safe_path = g_strdup(path);
945 for_dir_contents(do_find, safe_path, safe_path);
946 g_free(safe_path);
947 }
948 }
949
950 /* Like mode_compile(), but ignores spaces and bracketed bits */
951 struct mode_change *nice_mode_compile(const char *mode_string,
952 unsigned int masked_ops)
953 {
954 GString *new;
955 int brackets = 0;
956 struct mode_change *retval = NULL;
957
958 new = g_string_new(NULL);
959
960 for (; *mode_string; mode_string++)
961 {
962 if (*mode_string == '(')
963 brackets++;
964 if (*mode_string == ')')
965 {
966 brackets--;
967 if (brackets < 0)
968 break;
969 continue;
970 }
971
972 if (brackets == 0 && *mode_string != ' ')
973 g_string_append_c(new, *mode_string);
974 }
975
976 if (brackets == 0)
977 retval = mode_compile(new->str, masked_ops);
978 g_string_free(new, TRUE);
979 return retval;
980 }
981
982 static void do_chmod(const char *path, const char *unused)
983 {
984 struct stat info;
985 mode_t new_mode;
986
987 check_flags();
988
989 if (mc_lstat(path, &info))
990 {
991 send_error();
992 return;
993 }
994 if (S_ISLNK(info.st_mode))
995 return;
996
997 if (!quiet)
998 {
999 g_string_sprintf(message,
1000 _("?Change permissions of '%s'?"), path);
1001 if (!reply(from_parent, FALSE))
1002 return;
1003 }
1004 else if (!o_brief)
1005 {
1006 g_string_sprintf(message,
1007 _("'Changing permissions of '%s'\n"),
1008 path);
1009 send();
1010 }
1011
1012 for (;;)
1013 {
1014 if (new_entry_string)
1015 {
1016 if (mode_change)
1017 mode_free(mode_change);
1018 mode_change = nice_mode_compile(new_entry_string,
1019 MODE_MASK_ALL);
1020 g_free(new_entry_string);
1021 new_entry_string = NULL;
1022 }
1023
1024 if (mode_change)
1025 break;
1026
1027 g_string_assign(message,
1028 _("!Invalid mode command - change it and try again\n"));
1029 send();
1030 g_string_sprintf(message,
1031 _("?Change permissions of '%s'?"), path);
1032 if (!reply(from_parent, TRUE))
1033 return;
1034 }
1035
1036 if (mc_lstat(path, &info))
1037 {
1038 send_error();
1039 return;
1040 }
1041 if (S_ISLNK(info.st_mode))
1042 return;
1043
1044 new_mode = mode_adjust(info.st_mode, mode_change);
1045 if (chmod(path, new_mode))
1046 {
1047 send_error();
1048 return;
1049 }
1050
1051 g_string_sprintf(message, "s%s", path);
1052 send();
1053
1054 if (S_ISDIR(info.st_mode))
1055 {
1056 g_string_sprintf(message, "m%s", path);
1057 send();
1058
1059 if (o_recurse)
1060 {
1061 guchar *safe_path;
1062 safe_path = g_strdup(path);
1063 for_dir_contents(do_chmod, safe_path, safe_path);
1064 g_free(safe_path);
1065 }
1066 }
1067 }
1068
1069 /* We want to copy 'object' into directory 'dir'. If 'action_leaf'
1070 * is set then that is the new leafname, otherwise the leafname stays
1071 * the same.
1072 */
1073 static char *make_dest_path(const char *object, const char *dir)
1074 {
1075 const char *leaf;
1076
1077 if (action_leaf)
1078 leaf = action_leaf;
1079 else
1080 {
1081 leaf = strrchr(object, '/');
1082 if (!leaf)
1083 leaf = object; /* Error? */
1084 else
1085 leaf++;
1086 }
1087
1088 return make_path(dir, leaf)->str;
1089 }
1090
1091 /* If action_leaf is not NULL it specifies the new leaf name */
1092 static void do_copy2(const char *path, const char *dest)
1093 {
1094 char *dest_path;
1095 struct stat info;
1096 struct stat dest_info;
1097
1098 check_flags();
1099
1100 dest_path = make_dest_path(path, dest);
1101
1102 if (mc_lstat(path, &info))
1103 {
1104 send_error();
1105 return;
1106 }
1107
1108 if (mc_lstat(dest_path, &dest_info) == 0)
1109 {
1110 int err;
1111 gboolean merge;
1112
1113 merge = S_ISDIR(info.st_mode) && S_ISDIR(dest_info.st_mode);
1114
1115 if (!merge && o_newer && info.st_mtime > dest_info.st_mtime)
1116 {
1117 /* Newer; keep going */
1118 }
1119 else
1120 {
1121 g_string_sprintf(message,
1122 _("?'%s' already exists - %s?"), dest_path,
1123 merge ? _("merge contents") : _("overwrite"));
1124
1125 if (!reply(from_parent, TRUE))
1126 return;
1127 }
1128
1129 if (!merge)
1130 {
1131 if (S_ISDIR(dest_info.st_mode))
1132 err = rmdir(dest_path);
1133 else
1134 err = unlink(dest_path);
1135
1136 if (err)
1137 {
1138 send_error();
1139 if (errno != ENOENT)
1140 return;
1141 g_string_sprintf(message,
1142 _("'Trying copy anyway...\n"));
1143 send();
1144 }
1145 }
1146 }
1147 else if (!quiet)
1148 {
1149 g_string_sprintf(message,
1150 _("?Copy %s as %s?"), path, dest_path);
1151 if (!reply(from_parent, FALSE))
1152 return;
1153 }
1154 else
1155 {
1156 g_string_sprintf(message, _("'Copying %s as %s\n"), path,
1157 dest_path);
1158 send();
1159 }
1160
1161 if (S_ISDIR(info.st_mode))
1162 {
1163 mode_t mode = info.st_mode;
1164 char *safe_path, *safe_dest;
1165 struct stat dest_info;
1166 gboolean exists;
1167
1168 safe_path = g_strdup(path);
1169 safe_dest = g_strdup(dest_path);
1170
1171 exists = !mc_lstat(dest_path, &dest_info);
1172
1173 if (exists && !S_ISDIR(dest_info.st_mode))
1174 {
1175 g_string_sprintf(message,
1176 _("!ERROR: Destination already exists, "
1177 "but is not a directory\n"));
1178 send();
1179 }
1180 else if (exists == FALSE && mkdir(dest_path, 0700 | mode))
1181 send_error();
1182 else
1183 {
1184 if (!exists)
1185 {
1186 /* (just been created then) */
1187 g_string_sprintf(message, "s%s", dest_path);
1188 send();
1189 }
1190
1191 action_leaf = NULL;
1192 for_dir_contents(do_copy2, safe_path, safe_dest);
1193 /* Note: dest_path now invalid... */
1194
1195 if (!exists)
1196 {
1197 struct utimbuf utb;
1198
1199 /* We may have created the directory with
1200 * more permissions than the source so that
1201 * we could write to it... change it back now.
1202 */
1203 if (chmod(safe_dest, mode))
1204 send_error();
1205
1206 /* Also, try to preserve the timestamps */
1207 utb.actime = info.st_atime;
1208 utb.modtime = info.st_mtime;
1209
1210 utime(safe_dest, &utb);
1211 }
1212 }
1213
1214 g_free(safe_path);
1215 g_free(safe_dest);
1216 }
1217 else if (S_ISLNK(info.st_mode))
1218 {
1219 char *target;
1220
1221 /* Not all versions of cp(1) can make symlinks,
1222 * so we special-case it.
1223 */
1224
1225 target = readlink_dup(path);
1226 if (target)
1227 {
1228 if (symlink(target, dest_path))
1229 send_error();
1230 else
1231 {
1232 g_string_sprintf(message, "s%s", dest_path);
1233 send();
1234 }
1235
1236 g_free(target);
1237 }
1238 else
1239 send_error();
1240 }
1241 else
1242 {
1243 guchar *error;
1244
1245 error = copy_file(path, dest_path);
1246
1247 if (error)
1248 {
1249 g_string_sprintf(message, _("!%s\nFailed to copy '%s'"),
1250 error, path);
1251 g_free(error);
1252 send();
1253 }
1254 else
1255 {
1256 g_string_sprintf(message, "s%s", dest_path);
1257 send();
1258 }
1259 }
1260 }
1261
1262 /* If action_leaf is not NULL it specifies the new leaf name */
1263 static void do_move2(const char *path, const char *dest)
1264 {
1265 char *dest_path;
1266 const char *argv[] = {"mv", "-f", NULL, NULL, NULL};
1267 struct stat info2;
1268 gboolean is_dir;
1269 char *err;
1270
1271 check_flags();
1272
1273 dest_path = make_dest_path(path, dest);
1274
1275 is_dir = mc_lstat(path, &info2) == 0 && S_ISDIR(info2.st_mode);
1276
1277 if (access(dest_path, F_OK) == 0)
1278 {
1279 struct stat info;
1280 int err;
1281
1282 if (mc_lstat(dest_path, &info))
1283 {
1284 send_error();
1285 return;
1286 }
1287
1288 if (!is_dir && o_newer && info2.st_mtime > info.st_mtime)
1289 {
1290 /* Newer; keep going */
1291 }
1292 else
1293 {
1294 g_string_sprintf(message,
1295 _("?'%s' already exists - overwrite?"),
1296 dest_path);
1297 if (!reply(from_parent, TRUE))
1298 return;
1299 }
1300
1301 if (S_ISDIR(info.st_mode))
1302 err = rmdir(dest_path);
1303 else
1304 err = unlink(dest_path);
1305
1306 if (err)
1307 {
1308 send_error();
1309 if (errno != ENOENT)
1310 return;
1311 g_string_sprintf(message,
1312 _("'Trying move anyway...\n"));
1313 send();
1314 }
1315 }
1316 else if (!quiet)
1317 {
1318 g_string_sprintf(message,
1319 _("?Move %s as %s?"), path, dest_path);
1320 if (!reply(from_parent, FALSE))
1321 return;
1322 }
1323 else
1324 {
1325 g_string_sprintf(message, _("'Moving %s as %s\n"), path,
1326 dest_path);
1327 send();
1328 }
1329
1330 argv[2] = path;
1331 argv[3] = dest_path;
1332
1333 err = fork_exec_wait(argv);
1334 if (err)
1335 {
1336 g_string_sprintf(message,
1337 _("!%s\nFailed to move %s as %s\n"),
1338 err, path, dest_path);
1339 send();
1340
1341 g_free(err);
1342 }
1343 else
1344 {
1345 g_string_sprintf(message, "s%s", dest_path);
1346 send();
1347
1348 if (is_dir)
1349 g_string_sprintf(message, "m%s", path);
1350 else
1351 g_string_sprintf(message, "s%s", path);
1352
1353 send();
1354 }
1355 }
1356
1357 /* Copy path to dest.
1358 * Check that path not copied into itself.
1359 */
1360 static void do_copy(const char *path, const char *dest)
1361 {
1362 if (is_sub_dir(make_dest_path(path, dest), path))
1363 {
1364 g_string_sprintf(message,
1365 _("!ERROR: Can't copy object into itself\n"));
1366 send();
1367 }
1368 else
1369 do_copy2(path, dest);
1370 }
1371
1372 /* Move path to dest.
1373 * Check that path not moved into itself.
1374 */
1375 static void do_move(const char *path, const char *dest)
1376 {
1377 if (is_sub_dir(make_dest_path(path, dest), path))
1378 {
1379 g_string_sprintf(message,
1380 _("!ERROR: Can't move/rename object into itself\n"));
1381 send();
1382 }
1383 else
1384 do_move2(path, dest);
1385 }
1386
1387 static void do_link(const char *path, const char *dest)
1388 {
1389 char *dest_path;
1390
1391 check_flags();
1392
1393 dest_path = make_dest_path(path, dest);
1394
1395 if (quiet)
1396 {
1397 g_string_sprintf(message, _("'Linking %s as %s\n"), path,
1398 dest_path);
1399 send();
1400 }
1401 else
1402 {
1403 g_string_sprintf(message,
1404 _("?Link %s as %s?"), path, dest_path);
1405 if (!reply(from_parent, FALSE))
1406 return;
1407 }
1408
1409 if (symlink(path, dest_path))
1410 send_error();
1411 else
1412 {
1413 g_string_sprintf(message, "s%s", dest_path);
1414 send();
1415 }
1416 }
1417
1418 /* Mount/umount this item (depending on 'mount') */
1419 static void do_mount(guchar *path, gboolean mount)
1420 {
1421 const char *argv[3] = {NULL, NULL, NULL};
1422 char *err;
1423
1424 check_flags();
1425
1426 argv[0] = mount ? "mount" : "umount";
1427 argv[1] = path;
1428
1429 if (quiet)
1430 {
1431 g_string_sprintf(message,
1432 mount ? _("'Mounting %s\n")
1433 : _("'Unmounting %s\n"),
1434 path);
1435 send();
1436 }
1437 else
1438 {
1439 g_string_sprintf(message,
1440 mount ? _("?Mount %s?")
1441 : _("?Unmount %s?"),
1442 path);
1443 if (!reply(from_parent, FALSE))
1444 return;
1445 }
1446
1447 err = fork_exec_wait(argv);
1448 if (err)
1449 {
1450 g_string_sprintf(message, mount ?
1451 _("!%s\nMount failed\n") :
1452 _("!%s\nUnmount failed\n"), err);
1453 send();
1454 g_free(err);
1455 }
1456 else
1457 {
1458 g_string_sprintf(message, "M%s", path);
1459 send();
1460 if (mount && mount_open_dir)
1461 {
1462 g_string_sprintf(message, "o%s", path);
1463 send();
1464 }
1465 }
1466 }
1467
1468 /* CHILD MAIN LOOPS */
1469
1470 /* After forking, the child calls one of these functions */
1471
1472 /* We use a double for total size in order to count beyond 4Gb */
1473 static void usage_cb(gpointer data)
1474 {
1475 GList *paths = (GList *) data;
1476 double total_size = 0;
1477 gchar *tmp;
1478
1479 dir_counter = file_counter = 0;
1480
1481 for (; paths; paths = paths->next)
1482 {
1483 guchar *path = (guchar *) paths->data;
1484
1485 send_dir(path);
1486
1487 size_tally = 0;
1488
1489 do_usage(path, NULL);
1490
1491 g_string_sprintf(message, "'%s: %s\n",
1492 g_basename(path),
1493 format_double_size(size_tally));
1494 send();
1495 total_size += size_tally;
1496 }
1497
1498 g_string_sprintf(message, _("'\nTotal: %s ("),
1499 format_double_size(total_size));
1500
1501 if (file_counter)
1502 {
1503 tmp = g_strdup_printf("%ld %s%s",
1504 file_counter,
1505 file_counter == 1 ? _("file") : _("files"),
1506 dir_counter ? ", " : ")\n");
1507 g_string_append(message, tmp);
1508 g_free(tmp);
1509 }
1510
1511 if (file_counter == 0 && dir_counter == 0)
1512 g_string_append(message, _("no directories)\n"));
1513 else if (dir_counter)
1514 {
1515 tmp = g_strdup_printf("%ld %s)\n",
1516 dir_counter,
1517 dir_counter == 1 ? _("directory")
1518 : _("directories"));
1519 g_string_append(message, tmp);
1520 g_free(tmp);
1521 }
1522
1523 send();
1524 }
1525
1526 #ifdef DO_MOUNT_POINTS
1527 static void mount_cb(gpointer data)
1528 {
1529 GList *paths = (GList *) data;
1530 gboolean mount_points = FALSE;
1531
1532 for (; paths; paths = paths->next)
1533 {
1534 guchar *path = (guchar *) paths->data;
1535
1536 if (mount_is_mounted(path, NULL, NULL))
1537 do_mount(path, FALSE); /* Unmount */
1538 else if (g_hash_table_lookup(fstab_mounts, path))
1539 do_mount(path, TRUE); /* Mount */
1540 else
1541 continue;
1542
1543 mount_points = TRUE;
1544 }
1545
1546 g_string_sprintf(message,
1547 mount_points ? _("'\nDone\n")
1548 : _("!No mount points selected!\n"));
1549 send();
1550 }
1551 #endif
1552
1553 /* (use g_dirname() instead?) */
1554 static guchar *dirname(guchar *path)
1555 {
1556 guchar *slash;
1557
1558 slash = strrchr(path, '/');
1559 g_return_val_if_fail(slash != NULL, g_strdup(path));
1560
1561 if (slash != path)
1562 return g_strndup(path, slash - path);
1563 return g_strdup("/");
1564 }
1565
1566 static void delete_cb(gpointer data)
1567 {
1568 GList *paths = (GList *) data;
1569
1570 while (paths)
1571 {
1572 guchar *path = (guchar *) paths->data;
1573 guchar *dir;
1574
1575 dir = dirname(path);
1576 send_dir(dir);
1577
1578 do_delete(path, dir);
1579
1580 g_free(dir);
1581 paths = paths->next;
1582 }
1583
1584 g_string_sprintf(message, _("'\nDone\n"));
1585 send();
1586 }
1587
1588 static void find_cb(gpointer data)
1589 {
1590 GList *all_paths = (GList *) data;
1591 GList *paths;
1592
1593 while (1)
1594 {
1595 for (paths = all_paths; paths; paths = paths->next)
1596 {
1597 guchar *path = (guchar *) paths->data;
1598
1599 send_dir(path);
1600
1601 do_find(path, NULL);
1602 }
1603
1604 g_string_assign(message, _("?Another search?"));
1605 if (!reply(from_parent, TRUE))
1606 break;
1607 g_string_assign(message, "#");
1608 send();
1609 }
1610
1611 g_string_sprintf(message, _("'\nDone\n"));
1612 send();
1613 }
1614
1615 static void chmod_cb(gpointer data)
1616 {
1617 GList *paths = (GList *) data;
1618
1619 for (; paths; paths = paths->next)
1620 {
1621 guchar *path = (guchar *) paths->data;
1622 struct stat info;
1623
1624 send_dir(path);
1625
1626 if (mc_stat(path, &info) != 0)
1627 send_error();
1628 else if (S_ISLNK(info.st_mode))
1629 {
1630 g_string_sprintf(message,
1631 _("!'%s' is a symbolic link\n"),
1632 g_basename(path));
1633 send();
1634 }
1635 else
1636 do_chmod(path, NULL);
1637 }
1638
1639 g_string_sprintf(message, _("'\nDone\n"));
1640 send();
1641 }
1642
1643 static void list_cb(gpointer data)
1644 {
1645 GList *paths = (GList *) data;
1646
1647 while (paths)
1648 {
1649 send_dir((char *) paths->data);
1650
1651 action_do_func((char *) paths->data, action_dest);
1652
1653 paths = paths->next;
1654 }
1655
1656 g_string_sprintf(message, _("'\nDone\n"));
1657 send();
1658 }
1659
1660 /* EXTERNAL INTERFACE */
1661
1662 void action_find(GList *paths)
1663 {
1664 GUIside *gui_side;
1665 GtkWidget *abox;
1666
1667 if (!paths)
1668 {
1669 report_error(_("You need to select some items "
1670 "to search through"));
1671 return;
1672 }
1673
1674 if (!last_find_string)
1675 last_find_string = g_strdup("'core'");
1676
1677 new_entry_string = last_find_string;
1678
1679 abox = abox_new(_("Find"), FALSE);
1680 gui_side = start_action(abox, find_cb, paths,
1681 o_action_force.int_value,
1682 o_action_brief.int_value,
1683 o_action_recurse.int_value,
1684 o_action_newer.int_value);
1685 if (!gui_side)
1686 return;
1687
1688 abox_add_results(ABOX(abox));
1689
1690 gui_side->default_string = &last_find_string;
1691 abox_add_entry(ABOX(abox), last_find_string,
1692 new_help_button(show_condition_help, NULL));
1693 g_signal_connect(ABOX(abox)->entry, "changed",
1694 G_CALLBACK(entry_changed), gui_side);
1695 set_find_string_colour(ABOX(abox)->entry, last_find_string);
1696
1697 gui_side->show_info = TRUE;
1698 gui_side->entry_string_func = set_find_string_colour;
1699
1700 number_of_windows++;
1701 gtk_widget_show_all(abox);
1702 }
1703
1704 /* Count disk space used by selected items */
1705 void action_usage(GList *paths)
1706 {
1707 GUIside *gui_side;
1708 GtkWidget *abox;
1709
1710 if (!paths)
1711 {
1712 report_error(_("You need to select some items to count"));
1713 return;
1714 }
1715
1716 abox = abox_new(_("Disk Usage"), TRUE);
1717
1718 gui_side = start_action(abox, usage_cb, paths,
1719 o_action_force.int_value,
1720 o_action_brief.int_value,
1721 o_action_recurse.int_value,
1722 o_action_newer.int_value);
1723 if (!gui_side)
1724 return;
1725
1726 gui_side->show_info = TRUE;
1727
1728 number_of_windows++;
1729
1730 gtk_widget_show(abox);
1731 }
1732
1733 /* Mount/unmount listed items (paths).
1734 * Free the list after this function returns.
1735 * If open_dir is TRUE and the dir is successfully mounted, open it.
1736 * quiet can be -1 for default.
1737 */
1738 void action_mount(GList *paths, gboolean open_dir, int quiet)
1739 {
1740 #ifdef DO_MOUNT_POINTS
1741 GUIside *gui_side;
1742 GtkWidget *abox;
1743
1744 if (quiet == -1)
1745 quiet = o_action_mount.int_value;
1746
1747 mount_open_dir = open_dir;
1748
1749 abox = abox_new(_("Mount / Unmount"), quiet);
1750 gui_side = start_action(abox, mount_cb, paths,
1751 o_action_force.int_value,
1752 o_action_brief.int_value,
1753 o_action_recurse.int_value,
1754 o_action_newer.int_value);
1755 if (!gui_side)
1756 return;
1757
1758 number_of_windows++;
1759 gtk_widget_show(abox);
1760 #else
1761 report_error(
1762 _("ROX-Filer does not yet support mount points on your "
1763 "system. Sorry."));
1764 #endif /* DO_MOUNT_POINTS */
1765 }
1766
1767 /* Deletes all selected items in the window */
1768 void action_delete(GList *paths)
1769 {
1770 GUIside *gui_side;
1771 GtkWidget *abox;
1772
1773 if (!remove_pinned_ok(paths))
1774 return;
1775
1776 abox = abox_new(_("Delete"), o_action_delete.int_value);
1777 gui_side = start_action(abox, delete_cb, paths,
1778 o_action_force.int_value,
1779 o_action_brief.int_value,
1780 o_action_recurse.int_value,
1781 o_action_newer.int_value);
1782 if (!gui_side)
1783 return;
1784
1785 abox_add_flag(ABOX(abox),
1786 _("Force"), _("Don't confirm deletion of non-writeable items"),
1787 'F', o_action_force.int_value);
1788 abox_add_flag(ABOX(abox),
1789 _("Brief"), _("Only log directories being deleted"),
1790 'B', o_action_brief.int_value);
1791
1792 number_of_windows++;
1793 gtk_widget_show(abox);
1794 }
1795
1796 /* Change the permissions of the selected items */
1797 void action_chmod(GList *paths)
1798 {
1799 GtkWidget *abox;
1800 GUIside *gui_side;
1801 static GList *presets = NULL;
1802
1803 if (!paths)
1804 {
1805 report_error(_("You need to select the items "
1806 "whose permissions you want to change"));
1807 return;
1808 }
1809
1810 if (!presets)
1811 {
1812 presets = g_list_append(presets, (gchar *)
1813 _("a+x (Make executable/searchable)"));
1814 presets = g_list_append(presets, (gchar *)
1815 _("a-x (Make non-executable/non-searchable)"));
1816 presets = g_list_append(presets, (gchar *)
1817 _("u+rw (Give owner read+write)"));
1818 presets = g_list_append(presets, (gchar *)
1819 _("go-rwx (Private - owner access only)"));
1820 presets = g_list_append(presets, (gchar *)
1821 _("go=u-w (Public access, not write)"));
1822 }
1823
1824 if (!last_chmod_string)
1825 last_chmod_string = g_strdup((guchar *) presets->data);
1826 new_entry_string = last_chmod_string;
1827
1828 abox = abox_new(_("Permissions"), FALSE);
1829 gui_side = start_action(abox, chmod_cb, paths,
1830 o_action_force.int_value,
1831 o_action_brief.int_value,
1832 o_action_recurse.int_value,
1833 o_action_newer.int_value);
1834 if (!gui_side)
1835 return;
1836
1837 abox_add_flag(ABOX(abox),
1838 _("Brief"), _("Don't list processed files"),
1839 'B', o_action_brief.int_value);
1840 abox_add_flag(ABOX(abox),
1841 _("Recurse"), _("Also change contents of subdirectories"),
1842 'R', o_action_recurse.int_value);
1843
1844 gui_side->default_string = &last_chmod_string;
1845 abox_add_combo(ABOX(abox), presets, last_chmod_string,
1846 new_help_button(show_chmod_help, NULL));
1847
1848 g_signal_connect(ABOX(abox)->entry, "changed",
1849 G_CALLBACK(entry_changed), gui_side);
1850 #if 0
1851 g_signal_connect_swapped(gui_side->entry, "activate",
1852 G_CALLBACK(gtk_button_clicked),
1853 gui_side->yes);
1854 #endif
1855
1856 number_of_windows++;
1857 gtk_widget_show(abox);
1858 }
1859
1860 /* If leaf is NULL then the copy has the same name as the original.
1861 * quiet can be -1 for default.
1862 */
1863 void action_copy(GList *paths, const char *dest, const char *leaf, int quiet)
1864 {
1865 GUIside *gui_side;
1866 GtkWidget *abox;
1867
1868 if (quiet == -1)
1869 quiet = o_action_copy.int_value;
1870
1871 action_dest = dest;
1872 action_leaf = leaf;
1873 action_do_func = do_copy;
1874
1875 abox = abox_new(_("Copy"), quiet);
1876 gui_side = start_action(abox, list_cb, paths,
1877 o_action_force.int_value,
1878 o_action_brief.int_value,
1879 o_action_recurse.int_value,
1880 o_action_newer.int_value);
1881 if (!gui_side)
1882 return;
1883
1884 abox_add_flag(ABOX(abox),
1885 _("Newer"),
1886 _("Only over-write if source is newer than destination."),
1887 'W', o_action_newer.int_value);
1888
1889 number_of_windows++;
1890 gtk_widget_show(abox);
1891 }
1892
1893 /* If leaf is NULL then the file is not renamed.
1894 * quiet can be -1 for default.
1895 */
1896 void action_move(GList *paths, const char *dest, const char *leaf, int quiet)
1897 {
1898 GUIside *gui_side;
1899 GtkWidget *abox;
1900
1901 if (quiet == -1)
1902 quiet = o_action_move.int_value;
1903
1904 action_dest = dest;
1905 action_leaf = leaf;
1906 action_do_func = do_move;
1907
1908 abox = abox_new(_("Move"), quiet);
1909 gui_side = start_action(abox, list_cb, paths,
1910 o_action_force.int_value,
1911 o_action_brief.int_value,
1912 o_action_recurse.int_value,
1913 o_action_newer.int_value);
1914 if (!gui_side)
1915 return;
1916
1917 abox_add_flag(ABOX(abox),
1918 _("Newer"),
1919 _("Only over-write if source is newer than destination."),
1920 'W', o_action_newer.int_value);
1921 number_of_windows++;
1922 gtk_widget_show(abox);
1923 }
1924
1925 /* If leaf is NULL then the link will have the same name */
1926 /* XXX: No quiet option here? */
1927 void action_link(GList *paths, const char *dest, const char *leaf)
1928 {
1929 GtkWidget *abox;
1930 GUIside *gui_side;
1931
1932 action_dest = dest;
1933 action_leaf = leaf;
1934 action_do_func = do_link;
1935
1936 abox = abox_new(_("Link"), o_action_link.int_value);
1937 gui_side = start_action(abox, list_cb, paths,
1938 o_action_force.int_value,
1939 o_action_brief.int_value,
1940 o_action_recurse.int_value,
1941 o_action_newer.int_value);
1942 if (!gui_side)
1943 return;
1944
1945 number_of_windows++;
1946 gtk_widget_show(abox);
1947 }
1948
1949 void action_init(void)
1950 {
1951 option_add_int(&o_action_copy, "action_copy", 1);
1952 option_add_int(&o_action_move, "action_move", 1);
1953 option_add_int(&o_action_link, "action_link", 1);
1954 option_add_int(&o_action_delete, "action_delete", 0);
1955 option_add_int(&o_action_mount, "action_mount", 1);
1956 option_add_int(&o_action_force, "action_force", FALSE);
1957 option_add_int(&o_action_brief, "action_brief", FALSE);
1958 option_add_int(&o_action_recurse, "action_recurse", FALSE);
1959 option_add_int(&o_action_newer, "action_newer", FALSE);
1960 }
1961
1962 #define MAX_ASK 4
1963
1964 /* Check to see if any of the selected items (or their children) are
1965 * on the pinboard or panel. If so, ask for confirmation.
1966 *
1967 * TRUE if it's OK to lose them.
1968 */
1969 static gboolean remove_pinned_ok(GList *paths)
1970 {
1971 GList *ask = NULL, *next;
1972 GString *message;
1973 int i, ask_n = 0;
1974 gboolean retval;
1975
1976 while (paths)
1977 {
1978 guchar *path = (guchar *) paths->data;
1979
1980 if (icons_require(path))
1981 {
1982 if (++ask_n > MAX_ASK)
1983 break;
1984 ask = g_list_append(ask, path);
1985 }
1986
1987 paths = paths->next;
1988 }
1989
1990 if (!ask)
1991 return TRUE;
1992
1993 if (ask_n > MAX_ASK)
1994 {
1995 message = g_string_new(_("Deleting items such as "));
1996 ask_n--;
1997 }
1998 else if (ask_n == 1)
1999 message = g_string_new(_("Deleting the item "));
2000 else
2001 message = g_string_new(_("Deleting the items "));
2002
2003 i = 0;
2004 for (next = ask; next; next = next->next)
2005 {
2006 guchar *path = (guchar *) next->data;
2007 guchar *leaf;
2008
2009 leaf = strrchr(path, '/');
2010 if (leaf)
2011 leaf++;
2012 else
2013 leaf = path;
2014
2015 g_string_append_c(message, '`');
2016 g_string_append(message, leaf);
2017 g_string_append_c(message, '\'');
2018 i++;
2019 if (i == ask_n - 1 && i > 0)
2020 g_string_append(message, _(" and "));
2021 else if (i < ask_n)
2022 g_string_append(message, ", ");
2023 }
2024
2025 g_list_free(ask);
2026
2027 if (ask_n == 1)
2028 message = g_string_append(message,
2029 _(" will affect some items on the pinboard "
2030 "or panel - really delete it?"));
2031 else
2032 {
2033 if (ask_n > MAX_ASK)
2034 message = g_string_append_c(message, ',');
2035 message = g_string_append(message,
2036 _(" will affect some items on the pinboard "
2037 "or panel - really delete them?"));
2038 }
2039
2040 retval = get_choice(PROJECT, message->str,
2041 2, _("Cancel"), _("Delete")) == 1;
2042
2043 g_string_free(message, TRUE);
2044
2045 return retval;
2046 }
2047
2048 void set_find_string_colour(GtkWidget *widget, const guchar *string)
2049 {
2050 FindCondition *cond;
2051
2052 cond = find_compile(string);
2053 entry_set_error(widget, !cond);
2054
2055 if (cond)
2056 find_condition_free(cond);
2057 }
Filer for the ROX desktop