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