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